Linux Audio

Check our new training course

Yocto / OpenEmbedded training

Feb 10-13, 2025
Register
Loading...
v6.2
   1// SPDX-License-Identifier: LGPL-2.1
   2/*
 
   3 *
   4 *   Copyright (C) International Business Machines  Corp., 2002,2011
   5 *   Author(s): Steve French (sfrench@us.ibm.com)
   6 *
 
 
 
 
 
 
 
 
 
 
 
 
 
   7 */
   8#include <linux/fs.h>
   9#include <linux/net.h>
  10#include <linux/string.h>
  11#include <linux/sched/mm.h>
  12#include <linux/sched/signal.h>
  13#include <linux/list.h>
  14#include <linux/wait.h>
  15#include <linux/slab.h>
  16#include <linux/pagemap.h>
  17#include <linux/ctype.h>
  18#include <linux/utsname.h>
  19#include <linux/mempool.h>
  20#include <linux/delay.h>
  21#include <linux/completion.h>
  22#include <linux/kthread.h>
  23#include <linux/pagevec.h>
  24#include <linux/freezer.h>
  25#include <linux/namei.h>
  26#include <linux/uuid.h>
  27#include <linux/uaccess.h>
  28#include <asm/processor.h>
  29#include <linux/inet.h>
  30#include <linux/module.h>
  31#include <keys/user-type.h>
  32#include <net/ipv6.h>
  33#include <linux/parser.h>
  34#include <linux/bvec.h>
  35#include "cifspdu.h"
  36#include "cifsglob.h"
  37#include "cifsproto.h"
  38#include "cifs_unicode.h"
  39#include "cifs_debug.h"
  40#include "cifs_fs_sb.h"
  41#include "ntlmssp.h"
  42#include "nterr.h"
  43#include "rfc1002pdu.h"
  44#include "fscache.h"
  45#include "smb2proto.h"
  46#include "smbdirect.h"
  47#include "dns_resolve.h"
  48#ifdef CONFIG_CIFS_DFS_UPCALL
  49#include "dfs.h"
  50#include "dfs_cache.h"
  51#endif
  52#include "fs_context.h"
  53#include "cifs_swn.h"
  54
  55extern mempool_t *cifs_req_poolp;
  56extern bool disable_legacy_dialects;
  57
  58/* FIXME: should these be tunable? */
  59#define TLINK_ERROR_EXPIRE	(1 * HZ)
  60#define TLINK_IDLE_EXPIRE	(600 * HZ)
  61
  62/* Drop the connection to not overload the server */
  63#define NUM_STATUS_IO_TIMEOUT   5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  64
  65static int ip_connect(struct TCP_Server_Info *server);
  66static int generic_ip_connect(struct TCP_Server_Info *server);
  67static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
  68static void cifs_prune_tlinks(struct work_struct *work);
 
 
  69
  70/*
  71 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
  72 * get their ip addresses changed at some point.
  73 *
  74 * This should be called with server->srv_mutex held.
  75 */
  76static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server)
  77{
  78	int rc;
  79	int len;
  80	char *unc;
  81	struct sockaddr_storage ss;
  82	time64_t expiry, now;
  83	unsigned long ttl = SMB_DNS_RESOLVE_INTERVAL_DEFAULT;
  84
  85	if (!server->hostname)
  86		return -EINVAL;
  87
  88	/* if server hostname isn't populated, there's nothing to do here */
  89	if (server->hostname[0] == '\0')
  90		return 0;
  91
  92	len = strlen(server->hostname) + 3;
  93
  94	unc = kmalloc(len, GFP_KERNEL);
  95	if (!unc) {
  96		cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
  97		return -ENOMEM;
  98	}
  99	scnprintf(unc, len, "\\\\%s", server->hostname);
 100
 101	spin_lock(&server->srv_lock);
 102	ss = server->dstaddr;
 103	spin_unlock(&server->srv_lock);
 104
 105	rc = dns_resolve_server_name_to_ip(unc, (struct sockaddr *)&ss, &expiry);
 106	kfree(unc);
 107
 108	if (rc < 0) {
 109		cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
 110			 __func__, server->hostname, rc);
 111		goto requeue_resolve;
 112	}
 113
 114	spin_lock(&server->srv_lock);
 115	memcpy(&server->dstaddr, &ss, sizeof(server->dstaddr));
 116	spin_unlock(&server->srv_lock);
 117
 118	now = ktime_get_real_seconds();
 119	if (expiry && expiry > now)
 120		/* To make sure we don't use the cached entry, retry 1s */
 121		ttl = max_t(unsigned long, expiry - now, SMB_DNS_RESOLVE_INTERVAL_MIN) + 1;
 122
 123requeue_resolve:
 124	cifs_dbg(FYI, "%s: next dns resolution scheduled for %lu seconds in the future\n",
 125		 __func__, ttl);
 126	mod_delayed_work(cifsiod_wq, &server->resolve, (ttl * HZ));
 127
 128	return rc;
 129}
 130
 131static void smb2_query_server_interfaces(struct work_struct *work)
 132{
 133	int rc;
 134	struct cifs_tcon *tcon = container_of(work,
 135					struct cifs_tcon,
 136					query_interfaces.work);
 137
 138	/*
 139	 * query server network interfaces, in case they change
 140	 */
 141	rc = SMB3_request_interfaces(0, tcon, false);
 142	if (rc) {
 143		cifs_dbg(FYI, "%s: failed to query server interfaces: %d\n",
 144				__func__, rc);
 145	}
 146
 147	queue_delayed_work(cifsiod_wq, &tcon->query_interfaces,
 148			   (SMB_INTERFACE_POLL_INTERVAL * HZ));
 149}
 150
 151static void cifs_resolve_server(struct work_struct *work)
 152{
 153	int rc;
 154	struct TCP_Server_Info *server = container_of(work,
 155					struct TCP_Server_Info, resolve.work);
 156
 157	cifs_server_lock(server);
 158
 159	/*
 160	 * Resolve the hostname again to make sure that IP address is up-to-date.
 161	 */
 162	rc = reconn_set_ipaddr_from_hostname(server);
 163	if (rc) {
 164		cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
 165				__func__, rc);
 166	}
 167
 168	cifs_server_unlock(server);
 169}
 170
 171/*
 172 * Update the tcpStatus for the server.
 173 * This is used to signal the cifsd thread to call cifs_reconnect
 174 * ONLY cifsd thread should call cifs_reconnect. For any other
 175 * thread, use this function
 176 *
 177 * @server: the tcp ses for which reconnect is needed
 178 * @all_channels: if this needs to be done for all channels
 
 
 179 */
 180void
 181cifs_signal_cifsd_for_reconnect(struct TCP_Server_Info *server,
 182				bool all_channels)
 183{
 184	struct TCP_Server_Info *pserver;
 
 185	struct cifs_ses *ses;
 186	int i;
 187
 188	/* If server is a channel, select the primary channel */
 189	pserver = CIFS_SERVER_IS_CHAN(server) ? server->primary_server : server;
 190
 191	spin_lock(&pserver->srv_lock);
 192	if (!all_channels) {
 193		pserver->tcpStatus = CifsNeedReconnect;
 194		spin_unlock(&pserver->srv_lock);
 195		return;
 196	}
 197	spin_unlock(&pserver->srv_lock);
 198
 199	spin_lock(&cifs_tcp_ses_lock);
 200	list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) {
 201		spin_lock(&ses->chan_lock);
 202		for (i = 0; i < ses->chan_count; i++) {
 203			spin_lock(&ses->chans[i].server->srv_lock);
 204			ses->chans[i].server->tcpStatus = CifsNeedReconnect;
 205			spin_unlock(&ses->chans[i].server->srv_lock);
 206		}
 207		spin_unlock(&ses->chan_lock);
 208	}
 209	spin_unlock(&cifs_tcp_ses_lock);
 210}
 211
 212/*
 213 * Mark all sessions and tcons for reconnect.
 214 * IMPORTANT: make sure that this gets called only from
 215 * cifsd thread. For any other thread, use
 216 * cifs_signal_cifsd_for_reconnect
 217 *
 218 * @server: the tcp ses for which reconnect is needed
 219 * @server needs to be previously set to CifsNeedReconnect.
 220 * @mark_smb_session: whether even sessions need to be marked
 221 */
 222void
 223cifs_mark_tcp_ses_conns_for_reconnect(struct TCP_Server_Info *server,
 224				      bool mark_smb_session)
 225{
 226	struct TCP_Server_Info *pserver;
 227	struct cifs_ses *ses, *nses;
 228	struct cifs_tcon *tcon;
 
 
 229
 230	/*
 231	 * before reconnecting the tcp session, mark the smb session (uid) and the tid bad so they
 232	 * are not used until reconnected.
 233	 */
 234	cifs_dbg(FYI, "%s: marking necessary sessions and tcons for reconnect\n", __func__);
 235
 236	/* If server is a channel, select the primary channel */
 237	pserver = CIFS_SERVER_IS_CHAN(server) ? server->primary_server : server;
 
 
 238
 
 239
 
 
 
 240	spin_lock(&cifs_tcp_ses_lock);
 241	list_for_each_entry_safe(ses, nses, &pserver->smb_ses_list, smb_ses_list) {
 242		/* check if iface is still active */
 243		if (!cifs_chan_is_iface_active(ses, server))
 244			cifs_chan_update_iface(ses, server);
 245
 246		spin_lock(&ses->chan_lock);
 247		if (!mark_smb_session && cifs_chan_needs_reconnect(ses, server))
 248			goto next_session;
 249
 250		if (mark_smb_session)
 251			CIFS_SET_ALL_CHANS_NEED_RECONNECT(ses);
 252		else
 253			cifs_chan_set_need_reconnect(ses, server);
 254
 255		/* If all channels need reconnect, then tcon needs reconnect */
 256		if (!mark_smb_session && !CIFS_ALL_CHANS_NEED_RECONNECT(ses))
 257			goto next_session;
 258
 259		ses->ses_status = SES_NEED_RECON;
 260
 261		list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
 262			tcon->need_reconnect = true;
 263			tcon->status = TID_NEED_RECON;
 264		}
 265		if (ses->tcon_ipc) {
 266			ses->tcon_ipc->need_reconnect = true;
 267			ses->tcon_ipc->status = TID_NEED_RECON;
 268		}
 269
 270next_session:
 271		spin_unlock(&ses->chan_lock);
 272	}
 273	spin_unlock(&cifs_tcp_ses_lock);
 274}
 275
 276static void
 277cifs_abort_connection(struct TCP_Server_Info *server)
 278{
 279	struct mid_q_entry *mid, *nmid;
 280	struct list_head retry_list;
 281
 282	server->maxBuf = 0;
 283	server->max_read = 0;
 284
 285	/* do not want to be sending data on a socket we are freeing */
 286	cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
 287	cifs_server_lock(server);
 288	if (server->ssocket) {
 289		cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", server->ssocket->state,
 290			 server->ssocket->flags);
 291		kernel_sock_shutdown(server->ssocket, SHUT_WR);
 292		cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", server->ssocket->state,
 293			 server->ssocket->flags);
 
 294		sock_release(server->ssocket);
 295		server->ssocket = NULL;
 296	}
 297	server->sequence_number = 0;
 298	server->session_estab = false;
 299	kfree_sensitive(server->session_key.response);
 300	server->session_key.response = NULL;
 301	server->session_key.len = 0;
 302	server->lstrp = jiffies;
 
 303
 304	/* mark submitted MIDs for retry and issue callback */
 305	INIT_LIST_HEAD(&retry_list);
 306	cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
 307	spin_lock(&server->mid_lock);
 308	list_for_each_entry_safe(mid, nmid, &server->pending_mid_q, qhead) {
 309		kref_get(&mid->refcount);
 310		if (mid->mid_state == MID_REQUEST_SUBMITTED)
 311			mid->mid_state = MID_RETRY_NEEDED;
 312		list_move(&mid->qhead, &retry_list);
 313		mid->mid_flags |= MID_DELETED;
 
 
 
 
 
 
 
 314	}
 315	spin_unlock(&server->mid_lock);
 316	cifs_server_unlock(server);
 317
 318	cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
 319	list_for_each_entry_safe(mid, nmid, &retry_list, qhead) {
 320		list_del_init(&mid->qhead);
 321		mid->callback(mid);
 322		release_mid(mid);
 323	}
 324
 325	if (cifs_rdma_enabled(server)) {
 326		cifs_server_lock(server);
 327		smbd_destroy(server);
 328		cifs_server_unlock(server);
 329	}
 330}
 331
 332static bool cifs_tcp_ses_needs_reconnect(struct TCP_Server_Info *server, int num_targets)
 333{
 334	spin_lock(&server->srv_lock);
 335	server->nr_targets = num_targets;
 336	if (server->tcpStatus == CifsExiting) {
 337		/* the demux thread will exit normally next time through the loop */
 338		spin_unlock(&server->srv_lock);
 339		wake_up(&server->response_q);
 340		return false;
 341	}
 342
 343	cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
 344	trace_smb3_reconnect(server->CurrentMid, server->conn_id,
 345			     server->hostname);
 346	server->tcpStatus = CifsNeedReconnect;
 347
 348	spin_unlock(&server->srv_lock);
 349	return true;
 350}
 351
 352/*
 353 * cifs tcp session reconnection
 354 *
 355 * mark tcp session as reconnecting so temporarily locked
 356 * mark all smb sessions as reconnecting for tcp session
 357 * reconnect tcp session
 358 * wake up waiters on reconnection? - (not needed currently)
 359 *
 360 * if mark_smb_session is passed as true, unconditionally mark
 361 * the smb session (and tcon) for reconnect as well. This value
 362 * doesn't really matter for non-multichannel scenario.
 363 *
 364 */
 365static int __cifs_reconnect(struct TCP_Server_Info *server,
 366			    bool mark_smb_session)
 367{
 368	int rc = 0;
 369
 370	if (!cifs_tcp_ses_needs_reconnect(server, 1))
 371		return 0;
 372
 373	cifs_mark_tcp_ses_conns_for_reconnect(server, mark_smb_session);
 374
 375	cifs_abort_connection(server);
 376
 377	do {
 378		try_to_freeze();
 379		cifs_server_lock(server);
 380
 381		if (!cifs_swn_set_server_dstaddr(server)) {
 382			/* resolve the hostname again to make sure that IP address is up-to-date */
 383			rc = reconn_set_ipaddr_from_hostname(server);
 384			cifs_dbg(FYI, "%s: reconn_set_ipaddr_from_hostname: rc=%d\n", __func__, rc);
 385		}
 386
 387		if (cifs_rdma_enabled(server))
 388			rc = smbd_reconnect(server);
 389		else
 390			rc = generic_ip_connect(server);
 391		if (rc) {
 392			cifs_server_unlock(server);
 393			cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
 394			msleep(3000);
 395		} else {
 396			atomic_inc(&tcpSesReconnectCount);
 397			set_credits(server, 1);
 398			spin_lock(&server->srv_lock);
 399			if (server->tcpStatus != CifsExiting)
 400				server->tcpStatus = CifsNeedNegotiate;
 401			spin_unlock(&server->srv_lock);
 402			cifs_swn_reset_server_dstaddr(server);
 403			cifs_server_unlock(server);
 404			mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
 405		}
 406	} while (server->tcpStatus == CifsNeedReconnect);
 407
 408	spin_lock(&server->srv_lock);
 409	if (server->tcpStatus == CifsNeedNegotiate)
 410		mod_delayed_work(cifsiod_wq, &server->echo, 0);
 411	spin_unlock(&server->srv_lock);
 412
 413	wake_up(&server->response_q);
 414	return rc;
 415}
 416
 417#ifdef CONFIG_CIFS_DFS_UPCALL
 418static int __reconnect_target_unlocked(struct TCP_Server_Info *server, const char *target)
 419{
 420	int rc;
 421	char *hostname;
 422
 423	if (!cifs_swn_set_server_dstaddr(server)) {
 424		if (server->hostname != target) {
 425			hostname = extract_hostname(target);
 426			if (!IS_ERR(hostname)) {
 427				kfree(server->hostname);
 428				server->hostname = hostname;
 429			} else {
 430				cifs_dbg(FYI, "%s: couldn't extract hostname or address from dfs target: %ld\n",
 431					 __func__, PTR_ERR(hostname));
 432				cifs_dbg(FYI, "%s: default to last target server: %s\n", __func__,
 433					 server->hostname);
 434			}
 435		}
 436		/* resolve the hostname again to make sure that IP address is up-to-date. */
 437		rc = reconn_set_ipaddr_from_hostname(server);
 438		cifs_dbg(FYI, "%s: reconn_set_ipaddr_from_hostname: rc=%d\n", __func__, rc);
 439	}
 440	/* Reconnect the socket */
 441	if (cifs_rdma_enabled(server))
 442		rc = smbd_reconnect(server);
 443	else
 444		rc = generic_ip_connect(server);
 445
 446	return rc;
 447}
 448
 449static int reconnect_target_unlocked(struct TCP_Server_Info *server, struct dfs_cache_tgt_list *tl,
 450				     struct dfs_cache_tgt_iterator **target_hint)
 451{
 452	int rc;
 453	struct dfs_cache_tgt_iterator *tit;
 
 
 454
 455	*target_hint = NULL;
 
 456
 457	/* If dfs target list is empty, then reconnect to last server */
 458	tit = dfs_cache_get_tgt_iterator(tl);
 459	if (!tit)
 460		return __reconnect_target_unlocked(server, server->hostname);
 461
 462	/* Otherwise, try every dfs target in @tl */
 463	for (; tit; tit = dfs_cache_get_next_tgt(tl, tit)) {
 464		rc = __reconnect_target_unlocked(server, dfs_cache_get_tgt_name(tit));
 465		if (!rc) {
 466			*target_hint = tit;
 467			break;
 468		}
 469	}
 470	return rc;
 471}
 472
 473static int reconnect_dfs_server(struct TCP_Server_Info *server)
 474{
 475	int rc = 0;
 476	const char *refpath = server->current_fullpath + 1;
 477	struct dfs_cache_tgt_list tl = DFS_CACHE_TGT_LIST_INIT(tl);
 478	struct dfs_cache_tgt_iterator *target_hint = NULL;
 479	int num_targets = 0;
 480
 481	/*
 482	 * Determine the number of dfs targets the referral path in @cifs_sb resolves to.
 483	 *
 484	 * smb2_reconnect() needs to know how long it should wait based upon the number of dfs
 485	 * targets (server->nr_targets).  It's also possible that the cached referral was cleared
 486	 * through /proc/fs/cifs/dfscache or the target list is empty due to server settings after
 487	 * refreshing the referral, so, in this case, default it to 1.
 488	 */
 489	if (!dfs_cache_noreq_find(refpath, NULL, &tl))
 490		num_targets = dfs_cache_get_nr_tgts(&tl);
 491	if (!num_targets)
 492		num_targets = 1;
 493
 494	if (!cifs_tcp_ses_needs_reconnect(server, num_targets))
 495		return 0;
 
 
 
 
 
 496
 497	/*
 498	 * Unconditionally mark all sessions & tcons for reconnect as we might be connecting to a
 499	 * different server or share during failover.  It could be improved by adding some logic to
 500	 * only do that in case it connects to a different server or share, though.
 501	 */
 502	cifs_mark_tcp_ses_conns_for_reconnect(server, true);
 503
 504	cifs_abort_connection(server);
 
 
 
 
 
 
 
 
 505
 506	do {
 507		try_to_freeze();
 508		cifs_server_lock(server);
 
 
 
 
 
 
 509
 510		rc = reconnect_target_unlocked(server, &tl, &target_hint);
 511		if (rc) {
 512			/* Failed to reconnect socket */
 513			cifs_server_unlock(server);
 514			cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
 515			msleep(3000);
 516			continue;
 517		}
 518		/*
 519		 * Socket was created.  Update tcp session status to CifsNeedNegotiate so that a
 520		 * process waiting for reconnect will know it needs to re-establish session and tcon
 521		 * through the reconnected target server.
 522		 */
 523		atomic_inc(&tcpSesReconnectCount);
 524		set_credits(server, 1);
 525		spin_lock(&server->srv_lock);
 526		if (server->tcpStatus != CifsExiting)
 527			server->tcpStatus = CifsNeedNegotiate;
 528		spin_unlock(&server->srv_lock);
 529		cifs_swn_reset_server_dstaddr(server);
 530		cifs_server_unlock(server);
 531		mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
 532	} while (server->tcpStatus == CifsNeedReconnect);
 533
 534	dfs_cache_noreq_update_tgthint(refpath, target_hint);
 535	dfs_cache_free_tgts(&tl);
 
 536
 537	/* Need to set up echo worker again once connection has been established */
 538	spin_lock(&server->srv_lock);
 539	if (server->tcpStatus == CifsNeedNegotiate)
 540		mod_delayed_work(cifsiod_wq, &server->echo, 0);
 541	spin_unlock(&server->srv_lock);
 542
 543	wake_up(&server->response_q);
 544	return rc;
 545}
 546
 547int cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session)
 548{
 549	mutex_lock(&server->refpath_lock);
 550	if (!server->leaf_fullpath) {
 551		mutex_unlock(&server->refpath_lock);
 552		return __cifs_reconnect(server, mark_smb_session);
 553	}
 554	mutex_unlock(&server->refpath_lock);
 555
 556	return reconnect_dfs_server(server);
 557}
 558#else
 559int cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session)
 560{
 561	return __cifs_reconnect(server, mark_smb_session);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 562}
 563#endif
 564
 565static void
 566cifs_echo_request(struct work_struct *work)
 567{
 568	int rc;
 569	struct TCP_Server_Info *server = container_of(work,
 570					struct TCP_Server_Info, echo.work);
 571
 572	/*
 573	 * We cannot send an echo if it is disabled.
 574	 * Also, no need to ping if we got a response recently.
 
 575	 */
 576
 577	if (server->tcpStatus == CifsNeedReconnect ||
 578	    server->tcpStatus == CifsExiting ||
 579	    server->tcpStatus == CifsNew ||
 580	    (server->ops->can_echo && !server->ops->can_echo(server)) ||
 581	    time_before(jiffies, server->lstrp + server->echo_interval - HZ))
 582		goto requeue_echo;
 583
 584	rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
 585	if (rc)
 586		cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
 587			 server->hostname);
 588
 589	/* Check witness registrations */
 590	cifs_swn_check();
 591
 592requeue_echo:
 593	queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
 594}
 595
 596static bool
 597allocate_buffers(struct TCP_Server_Info *server)
 598{
 599	if (!server->bigbuf) {
 600		server->bigbuf = (char *)cifs_buf_get();
 601		if (!server->bigbuf) {
 602			cifs_server_dbg(VFS, "No memory for large SMB response\n");
 603			msleep(3000);
 604			/* retry will check if exiting */
 605			return false;
 606		}
 607	} else if (server->large_buf) {
 608		/* we are reusing a dirty large buf, clear its start */
 609		memset(server->bigbuf, 0, HEADER_SIZE(server));
 610	}
 611
 612	if (!server->smallbuf) {
 613		server->smallbuf = (char *)cifs_small_buf_get();
 614		if (!server->smallbuf) {
 615			cifs_server_dbg(VFS, "No memory for SMB response\n");
 616			msleep(1000);
 617			/* retry will check if exiting */
 618			return false;
 619		}
 620		/* beginning of smb buffer is cleared in our buf_get */
 621	} else {
 622		/* if existing small buf clear beginning */
 623		memset(server->smallbuf, 0, HEADER_SIZE(server));
 624	}
 625
 626	return true;
 627}
 628
 629static bool
 630server_unresponsive(struct TCP_Server_Info *server)
 631{
 632	/*
 633	 * We need to wait 3 echo intervals to make sure we handle such
 634	 * situations right:
 635	 * 1s  client sends a normal SMB request
 636	 * 2s  client gets a response
 637	 * 30s echo workqueue job pops, and decides we got a response recently
 638	 *     and don't need to send another
 639	 * ...
 640	 * 65s kernel_recvmsg times out, and we see that we haven't gotten
 641	 *     a response in >60s.
 642	 */
 643	spin_lock(&server->srv_lock);
 644	if ((server->tcpStatus == CifsGood ||
 645	    server->tcpStatus == CifsNeedNegotiate) &&
 646	    (!server->ops->can_echo || server->ops->can_echo(server)) &&
 647	    time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
 648		spin_unlock(&server->srv_lock);
 649		cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
 650			 (3 * server->echo_interval) / HZ);
 651		cifs_reconnect(server, false);
 652		return true;
 653	}
 654	spin_unlock(&server->srv_lock);
 655
 656	return false;
 657}
 658
 659static inline bool
 660zero_credits(struct TCP_Server_Info *server)
 
 
 
 
 
 
 
 
 
 
 
 
 
 661{
 662	int val;
 663
 664	spin_lock(&server->req_lock);
 665	val = server->credits + server->echo_credits + server->oplock_credits;
 666	if (server->in_flight == 0 && val == 0) {
 667		spin_unlock(&server->req_lock);
 668		return true;
 
 
 
 
 
 669	}
 670	spin_unlock(&server->req_lock);
 671	return false;
 
 
 672}
 673
 674static int
 675cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 676{
 677	int length = 0;
 678	int total_read;
 
 
 
 679
 680	for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
 681		try_to_freeze();
 
 682
 683		/* reconnect if no credits and no requests in flight */
 684		if (zero_credits(server)) {
 685			cifs_reconnect(server, false);
 686			return -ECONNABORTED;
 687		}
 688
 689		if (server_unresponsive(server))
 690			return -ECONNABORTED;
 691		if (cifs_rdma_enabled(server) && server->smbd_conn)
 692			length = smbd_recv(server->smbd_conn, smb_msg);
 693		else
 694			length = sock_recvmsg(server->ssocket, smb_msg, 0);
 695
 696		spin_lock(&server->srv_lock);
 697		if (server->tcpStatus == CifsExiting) {
 698			spin_unlock(&server->srv_lock);
 699			return -ESHUTDOWN;
 700		}
 701
 702		if (server->tcpStatus == CifsNeedReconnect) {
 703			spin_unlock(&server->srv_lock);
 704			cifs_reconnect(server, false);
 705			return -ECONNABORTED;
 706		}
 707		spin_unlock(&server->srv_lock);
 708
 709		if (length == -ERESTARTSYS ||
 710		    length == -EAGAIN ||
 711		    length == -EINTR) {
 
 
 
 
 
 
 
 712			/*
 713			 * Minimum sleep to prevent looping, allowing socket
 714			 * to clear and app threads to set tcpStatus
 715			 * CifsNeedReconnect if server hung.
 716			 */
 717			usleep_range(1000, 2000);
 718			length = 0;
 719			continue;
 720		}
 721
 722		if (length <= 0) {
 723			cifs_dbg(FYI, "Received no data or error: %d\n", length);
 724			cifs_reconnect(server, false);
 725			return -ECONNABORTED;
 726		}
 727	}
 728	return total_read;
 729}
 730
 731int
 732cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 733		      unsigned int to_read)
 734{
 735	struct msghdr smb_msg = {};
 736	struct kvec iov = {.iov_base = buf, .iov_len = to_read};
 737	iov_iter_kvec(&smb_msg.msg_iter, ITER_DEST, &iov, 1, to_read);
 738
 739	return cifs_readv_from_socket(server, &smb_msg);
 740}
 741
 742ssize_t
 743cifs_discard_from_socket(struct TCP_Server_Info *server, size_t to_read)
 744{
 745	struct msghdr smb_msg = {};
 746
 747	/*
 748	 *  iov_iter_discard already sets smb_msg.type and count and iov_offset
 749	 *  and cifs_readv_from_socket sets msg_control and msg_controllen
 750	 *  so little to initialize in struct msghdr
 751	 */
 752	iov_iter_discard(&smb_msg.msg_iter, ITER_DEST, to_read);
 753
 754	return cifs_readv_from_socket(server, &smb_msg);
 755}
 756
 757int
 758cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
 759	unsigned int page_offset, unsigned int to_read)
 760{
 761	struct msghdr smb_msg = {};
 762	struct bio_vec bv = {
 763		.bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
 764	iov_iter_bvec(&smb_msg.msg_iter, ITER_DEST, &bv, 1, to_read);
 765	return cifs_readv_from_socket(server, &smb_msg);
 766}
 767
 768static bool
 769is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 770{
 771	/*
 772	 * The first byte big endian of the length field,
 773	 * is actually not part of the length but the type
 774	 * with the most common, zero, as regular data.
 775	 */
 776	switch (type) {
 777	case RFC1002_SESSION_MESSAGE:
 778		/* Regular SMB response */
 779		return true;
 780	case RFC1002_SESSION_KEEP_ALIVE:
 781		cifs_dbg(FYI, "RFC 1002 session keep alive\n");
 782		break;
 783	case RFC1002_POSITIVE_SESSION_RESPONSE:
 784		cifs_dbg(FYI, "RFC 1002 positive session response\n");
 785		break;
 786	case RFC1002_NEGATIVE_SESSION_RESPONSE:
 787		/*
 788		 * We get this from Windows 98 instead of an error on
 789		 * SMB negprot response.
 790		 */
 791		cifs_dbg(FYI, "RFC 1002 negative session response\n");
 792		/* give server a second to clean up */
 793		msleep(1000);
 794		/*
 795		 * Always try 445 first on reconnect since we get NACK
 796		 * on some if we ever connected to port 139 (the NACK
 797		 * is since we do not begin with RFC1001 session
 798		 * initialize frame).
 799		 */
 800		cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 801		cifs_reconnect(server, true);
 
 802		break;
 803	default:
 804		cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
 805		cifs_reconnect(server, true);
 806	}
 807
 808	return false;
 809}
 810
 811void
 812dequeue_mid(struct mid_q_entry *mid, bool malformed)
 813{
 814#ifdef CONFIG_CIFS_STATS2
 815	mid->when_received = jiffies;
 816#endif
 817	spin_lock(&mid->server->mid_lock);
 818	if (!malformed)
 819		mid->mid_state = MID_RESPONSE_RECEIVED;
 820	else
 821		mid->mid_state = MID_RESPONSE_MALFORMED;
 822	/*
 823	 * Trying to handle/dequeue a mid after the send_recv()
 824	 * function has finished processing it is a bug.
 825	 */
 826	if (mid->mid_flags & MID_DELETED) {
 827		spin_unlock(&mid->server->mid_lock);
 828		pr_warn_once("trying to dequeue a deleted mid\n");
 829	} else {
 830		list_del_init(&mid->qhead);
 831		mid->mid_flags |= MID_DELETED;
 832		spin_unlock(&mid->server->mid_lock);
 833	}
 834}
 835
 836static unsigned int
 837smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
 838{
 839	struct smb2_hdr *shdr = (struct smb2_hdr *)buffer;
 840
 841	/*
 842	 * SMB1 does not use credits.
 843	 */
 844	if (is_smb1(server))
 845		return 0;
 846
 847	return le16_to_cpu(shdr->CreditRequest);
 848}
 849
 850static void
 851handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 852	   char *buf, int malformed)
 853{
 854	if (server->ops->check_trans2 &&
 855	    server->ops->check_trans2(mid, server, buf, malformed))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 856		return;
 857	mid->credits_received = smb2_get_credits_from_hdr(buf, server);
 858	mid->resp_buf = buf;
 859	mid->large_buf = server->large_buf;
 860	/* Was previous buf put in mpx struct for multi-rsp? */
 861	if (!mid->multiRsp) {
 862		/* smb buffer will be freed by user thread */
 863		if (server->large_buf)
 864			server->bigbuf = NULL;
 865		else
 866			server->smallbuf = NULL;
 867	}
 868	dequeue_mid(mid, malformed);
 869}
 870
 871int
 872cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required)
 873{
 874	bool srv_sign_required = server->sec_mode & server->vals->signing_required;
 875	bool srv_sign_enabled = server->sec_mode & server->vals->signing_enabled;
 876	bool mnt_sign_enabled;
 877
 878	/*
 879	 * Is signing required by mnt options? If not then check
 880	 * global_secflags to see if it is there.
 881	 */
 882	if (!mnt_sign_required)
 883		mnt_sign_required = ((global_secflags & CIFSSEC_MUST_SIGN) ==
 884						CIFSSEC_MUST_SIGN);
 885
 886	/*
 887	 * If signing is required then it's automatically enabled too,
 888	 * otherwise, check to see if the secflags allow it.
 889	 */
 890	mnt_sign_enabled = mnt_sign_required ? mnt_sign_required :
 891				(global_secflags & CIFSSEC_MAY_SIGN);
 892
 893	/* If server requires signing, does client allow it? */
 894	if (srv_sign_required) {
 895		if (!mnt_sign_enabled) {
 896			cifs_dbg(VFS, "Server requires signing, but it's disabled in SecurityFlags!\n");
 897			return -EOPNOTSUPP;
 898		}
 899		server->sign = true;
 900	}
 901
 902	/* If client requires signing, does server allow it? */
 903	if (mnt_sign_required) {
 904		if (!srv_sign_enabled) {
 905			cifs_dbg(VFS, "Server does not support signing!\n");
 906			return -EOPNOTSUPP;
 907		}
 908		server->sign = true;
 909	}
 910
 911	if (cifs_rdma_enabled(server) && server->sign)
 912		cifs_dbg(VFS, "Signing is enabled, and RDMA read/write will be disabled\n");
 913
 914	return 0;
 915}
 916
 917
 918static void clean_demultiplex_info(struct TCP_Server_Info *server)
 919{
 920	int length;
 921
 922	/* take it off the list, if it's not already */
 923	spin_lock(&server->srv_lock);
 924	list_del_init(&server->tcp_ses_list);
 925	spin_unlock(&server->srv_lock);
 926
 927	cancel_delayed_work_sync(&server->echo);
 928	cancel_delayed_work_sync(&server->resolve);
 929
 930	spin_lock(&server->srv_lock);
 931	server->tcpStatus = CifsExiting;
 932	spin_unlock(&server->srv_lock);
 933	wake_up_all(&server->response_q);
 934
 935	/* check if we have blocked requests that need to free */
 936	spin_lock(&server->req_lock);
 937	if (server->credits <= 0)
 938		server->credits = 1;
 939	spin_unlock(&server->req_lock);
 940	/*
 941	 * Although there should not be any requests blocked on this queue it
 942	 * can not hurt to be paranoid and try to wake up requests that may
 943	 * haven been blocked when more than 50 at time were on the wire to the
 944	 * same server - they now will see the session is in exit state and get
 945	 * out of SendReceive.
 946	 */
 947	wake_up_all(&server->request_q);
 948	/* give those requests time to exit */
 949	msleep(125);
 950	if (cifs_rdma_enabled(server))
 951		smbd_destroy(server);
 952	if (server->ssocket) {
 953		sock_release(server->ssocket);
 954		server->ssocket = NULL;
 955	}
 956
 957	if (!list_empty(&server->pending_mid_q)) {
 958		struct list_head dispose_list;
 959		struct mid_q_entry *mid_entry;
 960		struct list_head *tmp, *tmp2;
 961
 962		INIT_LIST_HEAD(&dispose_list);
 963		spin_lock(&server->mid_lock);
 964		list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 965			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 966			cifs_dbg(FYI, "Clearing mid %llu\n", mid_entry->mid);
 967			kref_get(&mid_entry->refcount);
 968			mid_entry->mid_state = MID_SHUTDOWN;
 969			list_move(&mid_entry->qhead, &dispose_list);
 970			mid_entry->mid_flags |= MID_DELETED;
 971		}
 972		spin_unlock(&server->mid_lock);
 973
 974		/* now walk dispose list and issue callbacks */
 975		list_for_each_safe(tmp, tmp2, &dispose_list) {
 976			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 977			cifs_dbg(FYI, "Callback mid %llu\n", mid_entry->mid);
 978			list_del_init(&mid_entry->qhead);
 979			mid_entry->callback(mid_entry);
 980			release_mid(mid_entry);
 981		}
 982		/* 1/8th of sec is more than enough time for them to exit */
 983		msleep(125);
 984	}
 985
 986	if (!list_empty(&server->pending_mid_q)) {
 987		/*
 988		 * mpx threads have not exited yet give them at least the smb
 989		 * send timeout time for long ops.
 990		 *
 991		 * Due to delays on oplock break requests, we need to wait at
 992		 * least 45 seconds before giving up on a request getting a
 993		 * response and going ahead and killing cifsd.
 994		 */
 995		cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
 996		msleep(46000);
 997		/*
 998		 * If threads still have not exited they are probably never
 999		 * coming home not much else we can do but free the memory.
1000		 */
1001	}
1002
1003#ifdef CONFIG_CIFS_DFS_UPCALL
1004	kfree(server->origin_fullpath);
1005	kfree(server->leaf_fullpath);
1006#endif
1007	kfree(server);
1008
1009	length = atomic_dec_return(&tcpSesAllocCount);
1010	if (length > 0)
1011		mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 
1012}
1013
1014static int
1015standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1016{
1017	int length;
1018	char *buf = server->smallbuf;
1019	unsigned int pdu_length = server->pdu_size;
1020
1021	/* make sure this will fit in a large buffer */
1022	if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1023	    HEADER_PREAMBLE_SIZE(server)) {
1024		cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1025		cifs_reconnect(server, true);
1026		return -ECONNABORTED;
 
1027	}
1028
1029	/* switch to large buffer if too big for a small one */
1030	if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1031		server->large_buf = true;
1032		memcpy(server->bigbuf, buf, server->total_read);
1033		buf = server->bigbuf;
1034	}
1035
1036	/* now read the rest */
1037	length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1038				       pdu_length - MID_HEADER_SIZE(server));
1039
1040	if (length < 0)
1041		return length;
1042	server->total_read += length;
1043
1044	dump_smb(buf, server->total_read);
1045
1046	return cifs_handle_standard(server, mid);
1047}
1048
1049int
1050cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1051{
1052	char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1053	int rc;
1054
1055	/*
1056	 * We know that we received enough to get to the MID as we
1057	 * checked the pdu_length earlier. Now check to see
1058	 * if the rest of the header is OK.
 
1059	 *
1060	 * 48 bytes is enough to display the header and a little bit
1061	 * into the payload for debugging purposes.
1062	 */
1063	rc = server->ops->check_message(buf, server->total_read, server);
1064	if (rc)
1065		cifs_dump_mem("Bad SMB: ", buf,
1066			min_t(unsigned int, server->total_read, 48));
1067
1068	if (server->ops->is_session_expired &&
1069	    server->ops->is_session_expired(buf)) {
1070		cifs_reconnect(server, true);
1071		return -1;
1072	}
1073
1074	if (server->ops->is_status_pending &&
1075	    server->ops->is_status_pending(buf, server))
1076		return -1;
1077
1078	if (!mid)
1079		return rc;
1080
1081	handle_mid(mid, server, buf, rc);
1082	return 0;
1083}
1084
1085static void
1086smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1087{
1088	struct smb2_hdr *shdr = (struct smb2_hdr *)buffer;
1089	int scredits, in_flight;
1090
1091	/*
1092	 * SMB1 does not use credits.
1093	 */
1094	if (is_smb1(server))
1095		return;
1096
1097	if (shdr->CreditRequest) {
1098		spin_lock(&server->req_lock);
1099		server->credits += le16_to_cpu(shdr->CreditRequest);
1100		scredits = server->credits;
1101		in_flight = server->in_flight;
1102		spin_unlock(&server->req_lock);
1103		wake_up(&server->request_q);
1104
1105		trace_smb3_hdr_credits(server->CurrentMid,
1106				server->conn_id, server->hostname, scredits,
1107				le16_to_cpu(shdr->CreditRequest), in_flight);
1108		cifs_server_dbg(FYI, "%s: added %u credits total=%d\n",
1109				__func__, le16_to_cpu(shdr->CreditRequest),
1110				scredits);
1111	}
1112}
1113
1114
1115static int
1116cifs_demultiplex_thread(void *p)
1117{
1118	int i, num_mids, length;
1119	struct TCP_Server_Info *server = p;
1120	unsigned int pdu_length;
1121	unsigned int next_offset;
1122	char *buf = NULL;
1123	struct task_struct *task_to_wake = NULL;
1124	struct mid_q_entry *mids[MAX_COMPOUND];
1125	char *bufs[MAX_COMPOUND];
1126	unsigned int noreclaim_flag, num_io_timeout = 0;
1127
1128	noreclaim_flag = memalloc_noreclaim_save();
1129	cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1130
1131	length = atomic_inc_return(&tcpSesAllocCount);
1132	if (length > 1)
1133		mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 
1134
1135	set_freezable();
1136	allow_kernel_signal(SIGKILL);
1137	while (server->tcpStatus != CifsExiting) {
1138		if (try_to_freeze())
1139			continue;
1140
1141		if (!allocate_buffers(server))
1142			continue;
1143
1144		server->large_buf = false;
1145		buf = server->smallbuf;
1146		pdu_length = 4; /* enough to get RFC1001 header */
1147
1148		length = cifs_read_from_socket(server, buf, pdu_length);
1149		if (length < 0)
1150			continue;
1151
1152		if (is_smb1(server))
1153			server->total_read = length;
1154		else
1155			server->total_read = 0;
1156
1157		/*
1158		 * The right amount was read from socket - 4 bytes,
1159		 * so we can now interpret the length field.
1160		 */
1161		pdu_length = get_rfc1002_length(buf);
1162
1163		cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1164		if (!is_smb_response(server, buf[0]))
1165			continue;
1166next_pdu:
1167		server->pdu_size = pdu_length;
1168
1169		/* make sure we have enough to get to the MID */
1170		if (server->pdu_size < MID_HEADER_SIZE(server)) {
1171			cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
1172				 server->pdu_size);
1173			cifs_reconnect(server, true);
 
1174			continue;
1175		}
1176
1177		/* read down to the MID */
1178		length = cifs_read_from_socket(server,
1179			     buf + HEADER_PREAMBLE_SIZE(server),
1180			     MID_HEADER_SIZE(server));
1181		if (length < 0)
1182			continue;
1183		server->total_read += length;
1184
1185		if (server->ops->next_header) {
1186			next_offset = server->ops->next_header(buf);
1187			if (next_offset)
1188				server->pdu_size = next_offset;
1189		}
1190
1191		memset(mids, 0, sizeof(mids));
1192		memset(bufs, 0, sizeof(bufs));
1193		num_mids = 0;
1194
1195		if (server->ops->is_transform_hdr &&
1196		    server->ops->receive_transform &&
1197		    server->ops->is_transform_hdr(buf)) {
1198			length = server->ops->receive_transform(server,
1199								mids,
1200								bufs,
1201								&num_mids);
1202		} else {
1203			mids[0] = server->ops->find_mid(server, buf);
1204			bufs[0] = buf;
1205			num_mids = 1;
1206
1207			if (!mids[0] || !mids[0]->receive)
1208				length = standard_receive3(server, mids[0]);
1209			else
1210				length = mids[0]->receive(server, mids[0]);
1211		}
1212
1213		if (length < 0) {
1214			for (i = 0; i < num_mids; i++)
1215				if (mids[i])
1216					release_mid(mids[i]);
1217			continue;
1218		}
1219
1220		if (server->ops->is_status_io_timeout &&
1221		    server->ops->is_status_io_timeout(buf)) {
1222			num_io_timeout++;
1223			if (num_io_timeout > NUM_STATUS_IO_TIMEOUT) {
1224				cifs_reconnect(server, false);
1225				num_io_timeout = 0;
1226				continue;
1227			}
1228		}
1229
1230		server->lstrp = jiffies;
1231
1232		for (i = 0; i < num_mids; i++) {
1233			if (mids[i] != NULL) {
1234				mids[i]->resp_buf_size = server->pdu_size;
1235
1236				if (bufs[i] && server->ops->is_network_name_deleted)
1237					server->ops->is_network_name_deleted(bufs[i],
1238									server);
1239
1240				if (!mids[i]->multiRsp || mids[i]->multiEnd)
1241					mids[i]->callback(mids[i]);
1242
1243				release_mid(mids[i]);
1244			} else if (server->ops->is_oplock_break &&
1245				   server->ops->is_oplock_break(bufs[i],
1246								server)) {
1247				smb2_add_credits_from_hdr(bufs[i], server);
1248				cifs_dbg(FYI, "Received oplock break\n");
1249			} else {
1250				cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
1251						atomic_read(&mid_count));
1252				cifs_dump_mem("Received Data is: ", bufs[i],
1253					      HEADER_SIZE(server));
1254				smb2_add_credits_from_hdr(bufs[i], server);
1255#ifdef CONFIG_CIFS_DEBUG2
1256				if (server->ops->dump_detail)
1257					server->ops->dump_detail(bufs[i],
1258								 server);
1259				cifs_dump_mids(server);
1260#endif /* CIFS_DEBUG2 */
1261			}
1262		}
1263
1264		if (pdu_length > server->pdu_size) {
1265			if (!allocate_buffers(server))
1266				continue;
1267			pdu_length -= server->pdu_size;
1268			server->total_read = 0;
1269			server->large_buf = false;
1270			buf = server->smallbuf;
1271			goto next_pdu;
1272		}
1273	} /* end while !EXITING */
1274
1275	/* buffer usually freed in free_mid - need to free it here on exit */
1276	cifs_buf_release(server->bigbuf);
1277	if (server->smallbuf) /* no sense logging a debug message if NULL */
1278		cifs_small_buf_release(server->smallbuf);
1279
1280	task_to_wake = xchg(&server->tsk, NULL);
1281	clean_demultiplex_info(server);
1282
1283	/* if server->tsk was NULL then wait for a signal before exiting */
1284	if (!task_to_wake) {
1285		set_current_state(TASK_INTERRUPTIBLE);
1286		while (!signal_pending(current)) {
1287			schedule();
1288			set_current_state(TASK_INTERRUPTIBLE);
1289		}
1290		set_current_state(TASK_RUNNING);
1291	}
1292
1293	memalloc_noreclaim_restore(noreclaim_flag);
1294	module_put_and_kthread_exit(0);
1295}
1296
1297/*
1298 * Returns true if srcaddr isn't specified and rhs isn't specified, or
1299 * if srcaddr is specified and matches the IP address of the rhs argument
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1300 */
1301bool
1302cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs)
1303{
1304	switch (srcaddr->sa_family) {
1305	case AF_UNSPEC:
1306		return (rhs->sa_family == AF_UNSPEC);
1307	case AF_INET: {
1308		struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1309		struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1310		return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1311	}
1312	case AF_INET6: {
1313		struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1314		struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1315		return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1316	}
1317	default:
1318		WARN_ON(1);
1319		return false; /* don't expect to be here */
1320	}
1321}
1322
1323/*
1324 * If no port is specified in addr structure, we try to match with 445 port
1325 * and if it fails - with 139 ports. It should be called only if address
1326 * families of server and addr are equal.
1327 */
1328static bool
1329match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1330{
1331	__be16 port, *sport;
1332
1333	/* SMBDirect manages its own ports, don't match it here */
1334	if (server->rdma)
1335		return true;
1336
1337	switch (addr->sa_family) {
1338	case AF_INET:
1339		sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1340		port = ((struct sockaddr_in *) addr)->sin_port;
1341		break;
1342	case AF_INET6:
1343		sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1344		port = ((struct sockaddr_in6 *) addr)->sin6_port;
1345		break;
1346	default:
1347		WARN_ON(1);
1348		return false;
1349	}
1350
1351	if (!port) {
1352		port = htons(CIFS_PORT);
1353		if (port == *sport)
1354			return true;
1355
1356		port = htons(RFC1001_PORT);
1357	}
1358
1359	return port == *sport;
1360}
1361
1362static bool match_server_address(struct TCP_Server_Info *server, struct sockaddr *addr)
 
 
1363{
1364	switch (addr->sa_family) {
1365	case AF_INET: {
1366		struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1367		struct sockaddr_in *srv_addr4 =
1368					(struct sockaddr_in *)&server->dstaddr;
1369
1370		if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1371			return false;
1372		break;
1373	}
1374	case AF_INET6: {
1375		struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1376		struct sockaddr_in6 *srv_addr6 =
1377					(struct sockaddr_in6 *)&server->dstaddr;
1378
1379		if (!ipv6_addr_equal(&addr6->sin6_addr,
1380				     &srv_addr6->sin6_addr))
1381			return false;
1382		if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1383			return false;
1384		break;
1385	}
1386	default:
1387		WARN_ON(1);
1388		return false; /* don't expect to be here */
1389	}
1390
 
 
 
1391	return true;
1392}
1393
1394static bool
1395match_security(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1396{
1397	/*
1398	 * The select_sectype function should either return the ctx->sectype
1399	 * that was specified, or "Unspecified" if that sectype was not
1400	 * compatible with the given NEGOTIATE request.
1401	 */
1402	if (server->ops->select_sectype(server, ctx->sectype)
1403	     == Unspecified)
1404		return false;
1405
1406	/*
1407	 * Now check if signing mode is acceptable. No need to check
1408	 * global_secflags at this point since if MUST_SIGN is set then
1409	 * the server->sign had better be too.
1410	 */
1411	if (ctx->sign && !server->sign)
1412		return false;
1413
1414	return true;
1415}
1416
1417static bool dfs_src_pathname_equal(const char *s1, const char *s2)
1418{
1419	if (strlen(s1) != strlen(s2))
1420		return false;
1421	for (; *s1; s1++, s2++) {
1422		if (*s1 == '/' || *s1 == '\\') {
1423			if (*s2 != '/' && *s2 != '\\')
1424				return false;
1425		} else if (tolower(*s1) != tolower(*s2))
1426			return false;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1427	}
 
 
 
 
 
 
 
 
 
 
1428	return true;
1429}
1430
1431/* this function must be called with srv_lock held */
1432static int match_server(struct TCP_Server_Info *server, struct smb3_fs_context *ctx,
1433			bool dfs_super_cmp)
1434{
1435	struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr;
1436
1437	if (ctx->nosharesock)
1438		return 0;
1439
1440	/* this server does not share socket */
1441	if (server->nosharesock)
1442		return 0;
1443
1444	/* If multidialect negotiation see if existing sessions match one */
1445	if (strcmp(ctx->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
1446		if (server->vals->protocol_id < SMB30_PROT_ID)
1447			return 0;
1448	} else if (strcmp(ctx->vals->version_string,
1449		   SMBDEFAULT_VERSION_STRING) == 0) {
1450		if (server->vals->protocol_id < SMB21_PROT_ID)
1451			return 0;
1452	} else if ((server->vals != ctx->vals) || (server->ops != ctx->ops))
1453		return 0;
1454
1455	if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1456		return 0;
1457
1458	if (!cifs_match_ipaddr((struct sockaddr *)&ctx->srcaddr,
1459			       (struct sockaddr *)&server->srcaddr))
1460		return 0;
1461	/*
1462	 * When matching DFS superblocks, we only check for original source pathname as the
1463	 * currently connected target might be different than the one parsed earlier in i.e.
1464	 * mount.cifs(8).
1465	 */
1466	if (dfs_super_cmp) {
1467		if (!ctx->source || !server->origin_fullpath ||
1468		    !dfs_src_pathname_equal(server->origin_fullpath, ctx->source))
1469			return 0;
1470	} else {
1471		/* Skip addr, hostname and port matching for DFS connections */
1472		if (server->leaf_fullpath) {
1473			if (!ctx->leaf_fullpath ||
1474			    strcasecmp(server->leaf_fullpath, ctx->leaf_fullpath))
1475				return 0;
1476		} else if (strcasecmp(server->hostname, ctx->server_hostname) ||
1477			   !match_server_address(server, addr) ||
1478			   !match_port(server, addr)) {
1479			return 0;
1480		}
1481	}
1482
1483	if (!match_security(server, ctx))
1484		return 0;
1485
1486	if (server->echo_interval != ctx->echo_interval * HZ)
1487		return 0;
1488
1489	if (server->rdma != ctx->rdma)
1490		return 0;
1491
1492	if (server->ignore_signature != ctx->ignore_signature)
1493		return 0;
1494
1495	if (server->min_offload != ctx->min_offload)
1496		return 0;
1497
1498	return 1;
1499}
1500
1501struct TCP_Server_Info *
1502cifs_find_tcp_session(struct smb3_fs_context *ctx)
1503{
1504	struct TCP_Server_Info *server;
1505
1506	spin_lock(&cifs_tcp_ses_lock);
1507	list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1508		spin_lock(&server->srv_lock);
1509		/*
1510		 * Skip ses channels since they're only handled in lower layers
1511		 * (e.g. cifs_send_recv).
1512		 */
1513		if (CIFS_SERVER_IS_CHAN(server) || !match_server(server, ctx, false)) {
1514			spin_unlock(&server->srv_lock);
1515			continue;
1516		}
1517		spin_unlock(&server->srv_lock);
1518
1519		++server->srv_count;
1520		spin_unlock(&cifs_tcp_ses_lock);
1521		cifs_dbg(FYI, "Existing tcp session with server found\n");
1522		return server;
1523	}
1524	spin_unlock(&cifs_tcp_ses_lock);
1525	return NULL;
1526}
1527
1528void
1529cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
1530{
1531	struct task_struct *task;
1532
1533	spin_lock(&cifs_tcp_ses_lock);
1534	if (--server->srv_count > 0) {
1535		spin_unlock(&cifs_tcp_ses_lock);
1536		return;
1537	}
1538
1539	/* srv_count can never go negative */
1540	WARN_ON(server->srv_count < 0);
1541
1542	put_net(cifs_net_ns(server));
1543
1544	list_del_init(&server->tcp_ses_list);
1545	spin_unlock(&cifs_tcp_ses_lock);
1546
1547	/* For secondary channels, we pick up ref-count on the primary server */
1548	if (CIFS_SERVER_IS_CHAN(server))
1549		cifs_put_tcp_session(server->primary_server, from_reconnect);
1550
1551	cancel_delayed_work_sync(&server->echo);
1552	cancel_delayed_work_sync(&server->resolve);
1553
1554	if (from_reconnect)
1555		/*
1556		 * Avoid deadlock here: reconnect work calls
1557		 * cifs_put_tcp_session() at its end. Need to be sure
1558		 * that reconnect work does nothing with server pointer after
1559		 * that step.
1560		 */
1561		cancel_delayed_work(&server->reconnect);
1562	else
1563		cancel_delayed_work_sync(&server->reconnect);
1564
1565	spin_lock(&server->srv_lock);
1566	server->tcpStatus = CifsExiting;
1567	spin_unlock(&server->srv_lock);
1568
1569	cifs_crypto_secmech_release(server);
 
1570
1571	kfree_sensitive(server->session_key.response);
1572	server->session_key.response = NULL;
1573	server->session_key.len = 0;
1574	kfree(server->hostname);
1575	server->hostname = NULL;
1576
1577	task = xchg(&server->tsk, NULL);
1578	if (task)
1579		send_sig(SIGKILL, task, 1);
1580}
1581
1582struct TCP_Server_Info *
1583cifs_get_tcp_session(struct smb3_fs_context *ctx,
1584		     struct TCP_Server_Info *primary_server)
1585{
1586	struct TCP_Server_Info *tcp_ses = NULL;
 
 
 
1587	int rc;
1588
1589	cifs_dbg(FYI, "UNC: %s\n", ctx->UNC);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1590
1591	/* see if we already have a matching tcp_ses */
1592	tcp_ses = cifs_find_tcp_session(ctx);
1593	if (tcp_ses)
1594		return tcp_ses;
1595
1596	tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1597	if (!tcp_ses) {
1598		rc = -ENOMEM;
1599		goto out_err;
1600	}
1601
1602	tcp_ses->hostname = kstrdup(ctx->server_hostname, GFP_KERNEL);
1603	if (!tcp_ses->hostname) {
1604		rc = -ENOMEM;
1605		goto out_err;
1606	}
1607
1608	if (ctx->leaf_fullpath) {
1609		tcp_ses->leaf_fullpath = kstrdup(ctx->leaf_fullpath, GFP_KERNEL);
1610		if (!tcp_ses->leaf_fullpath) {
1611			rc = -ENOMEM;
1612			goto out_err;
1613		}
1614		tcp_ses->current_fullpath = tcp_ses->leaf_fullpath;
1615	}
1616
1617	if (ctx->nosharesock)
1618		tcp_ses->nosharesock = true;
1619
1620	tcp_ses->ops = ctx->ops;
1621	tcp_ses->vals = ctx->vals;
1622	cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
 
 
 
 
 
1623
1624	tcp_ses->conn_id = atomic_inc_return(&tcpSesNextId);
1625	tcp_ses->noblockcnt = ctx->rootfs;
1626	tcp_ses->noblocksnd = ctx->noblocksnd || ctx->rootfs;
1627	tcp_ses->noautotune = ctx->noautotune;
1628	tcp_ses->tcp_nodelay = ctx->sockopt_tcp_nodelay;
1629	tcp_ses->rdma = ctx->rdma;
1630	tcp_ses->in_flight = 0;
1631	tcp_ses->max_in_flight = 0;
1632	tcp_ses->credits = 1;
1633	if (primary_server) {
1634		spin_lock(&cifs_tcp_ses_lock);
1635		++primary_server->srv_count;
1636		spin_unlock(&cifs_tcp_ses_lock);
1637		tcp_ses->primary_server = primary_server;
1638	}
1639	init_waitqueue_head(&tcp_ses->response_q);
1640	init_waitqueue_head(&tcp_ses->request_q);
1641	INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1642	mutex_init(&tcp_ses->_srv_mutex);
1643	memcpy(tcp_ses->workstation_RFC1001_name,
1644		ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1645	memcpy(tcp_ses->server_RFC1001_name,
1646		ctx->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1647	tcp_ses->session_estab = false;
1648	tcp_ses->sequence_number = 0;
1649	tcp_ses->reconnect_instance = 1;
1650	tcp_ses->lstrp = jiffies;
1651	tcp_ses->compress_algorithm = cpu_to_le16(ctx->compression);
1652	spin_lock_init(&tcp_ses->req_lock);
1653	spin_lock_init(&tcp_ses->srv_lock);
1654	spin_lock_init(&tcp_ses->mid_lock);
1655	INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1656	INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1657	INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1658	INIT_DELAYED_WORK(&tcp_ses->resolve, cifs_resolve_server);
1659	INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
1660	mutex_init(&tcp_ses->reconnect_mutex);
1661#ifdef CONFIG_CIFS_DFS_UPCALL
1662	mutex_init(&tcp_ses->refpath_lock);
1663#endif
1664	memcpy(&tcp_ses->srcaddr, &ctx->srcaddr,
1665	       sizeof(tcp_ses->srcaddr));
1666	memcpy(&tcp_ses->dstaddr, &ctx->dstaddr,
1667		sizeof(tcp_ses->dstaddr));
1668	if (ctx->use_client_guid)
1669		memcpy(tcp_ses->client_guid, ctx->client_guid,
1670		       SMB2_CLIENT_GUID_SIZE);
1671	else
1672		generate_random_uuid(tcp_ses->client_guid);
1673	/*
1674	 * at this point we are the only ones with the pointer
1675	 * to the struct since the kernel thread not created yet
1676	 * no need to spinlock this init of tcpStatus or srv_count
1677	 */
1678	tcp_ses->tcpStatus = CifsNew;
 
 
1679	++tcp_ses->srv_count;
1680
1681	if (ctx->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
1682		ctx->echo_interval <= SMB_ECHO_INTERVAL_MAX)
1683		tcp_ses->echo_interval = ctx->echo_interval * HZ;
1684	else
1685		tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
1686	if (tcp_ses->rdma) {
1687#ifndef CONFIG_CIFS_SMB_DIRECT
1688		cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
1689		rc = -ENOENT;
1690		goto out_err_crypto_release;
1691#endif
1692		tcp_ses->smbd_conn = smbd_get_connection(
1693			tcp_ses, (struct sockaddr *)&ctx->dstaddr);
1694		if (tcp_ses->smbd_conn) {
1695			cifs_dbg(VFS, "RDMA transport established\n");
1696			rc = 0;
1697			goto smbd_connected;
1698		} else {
1699			rc = -ENOENT;
1700			goto out_err_crypto_release;
1701		}
1702	}
1703	rc = ip_connect(tcp_ses);
1704	if (rc < 0) {
1705		cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
1706		goto out_err_crypto_release;
1707	}
1708smbd_connected:
1709	/*
1710	 * since we're in a cifs function already, we know that
1711	 * this will succeed. No need for try_module_get().
1712	 */
1713	__module_get(THIS_MODULE);
1714	tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1715				  tcp_ses, "cifsd");
1716	if (IS_ERR(tcp_ses->tsk)) {
1717		rc = PTR_ERR(tcp_ses->tsk);
1718		cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
1719		module_put(THIS_MODULE);
1720		goto out_err_crypto_release;
1721	}
1722	tcp_ses->min_offload = ctx->min_offload;
1723	/*
1724	 * at this point we are the only ones with the pointer
1725	 * to the struct since the kernel thread not created yet
1726	 * no need to spinlock this update of tcpStatus
1727	 */
1728	spin_lock(&tcp_ses->srv_lock);
1729	tcp_ses->tcpStatus = CifsNeedNegotiate;
1730	spin_unlock(&tcp_ses->srv_lock);
1731
1732	if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
1733		tcp_ses->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
1734	else
1735		tcp_ses->max_credits = ctx->max_credits;
1736
1737	tcp_ses->nr_targets = 1;
1738	tcp_ses->ignore_signature = ctx->ignore_signature;
1739	/* thread spawned, put it on the list */
1740	spin_lock(&cifs_tcp_ses_lock);
1741	list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1742	spin_unlock(&cifs_tcp_ses_lock);
1743
1744	/* queue echo request delayed work */
1745	queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
1746
1747	/* queue dns resolution delayed work */
1748	cifs_dbg(FYI, "%s: next dns resolution scheduled for %d seconds in the future\n",
1749		 __func__, SMB_DNS_RESOLVE_INTERVAL_DEFAULT);
1750
1751	queue_delayed_work(cifsiod_wq, &tcp_ses->resolve, (SMB_DNS_RESOLVE_INTERVAL_DEFAULT * HZ));
 
1752
1753	return tcp_ses;
1754
1755out_err_crypto_release:
1756	cifs_crypto_secmech_release(tcp_ses);
1757
1758	put_net(cifs_net_ns(tcp_ses));
1759
1760out_err:
1761	if (tcp_ses) {
1762		if (CIFS_SERVER_IS_CHAN(tcp_ses))
1763			cifs_put_tcp_session(tcp_ses->primary_server, false);
1764		kfree(tcp_ses->hostname);
1765		kfree(tcp_ses->leaf_fullpath);
1766		if (tcp_ses->ssocket)
1767			sock_release(tcp_ses->ssocket);
1768		kfree(tcp_ses);
1769	}
1770	return ERR_PTR(rc);
1771}
1772
1773/* this function must be called with ses_lock held */
1774static int match_session(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1775{
1776	if (ctx->sectype != Unspecified &&
1777	    ctx->sectype != ses->sectype)
1778		return 0;
1779
1780	/*
1781	 * If an existing session is limited to less channels than
1782	 * requested, it should not be reused
1783	 */
1784	spin_lock(&ses->chan_lock);
1785	if (ses->chan_max < ctx->max_channels) {
1786		spin_unlock(&ses->chan_lock);
1787		return 0;
1788	}
1789	spin_unlock(&ses->chan_lock);
1790
1791	switch (ses->sectype) {
1792	case Kerberos:
1793		if (!uid_eq(ctx->cred_uid, ses->cred_uid))
1794			return 0;
1795		break;
1796	default:
1797		/* NULL username means anonymous session */
1798		if (ses->user_name == NULL) {
1799			if (!ctx->nullauth)
1800				return 0;
1801			break;
1802		}
1803
1804		/* anything else takes username/password */
1805		if (strncmp(ses->user_name,
1806			    ctx->username ? ctx->username : "",
1807			    CIFS_MAX_USERNAME_LEN))
1808			return 0;
1809		if ((ctx->username && strlen(ctx->username) != 0) &&
1810		    ses->password != NULL &&
1811		    strncmp(ses->password,
1812			    ctx->password ? ctx->password : "",
1813			    CIFS_MAX_PASSWORD_LEN))
1814			return 0;
1815	}
1816	return 1;
1817}
1818
1819/**
1820 * cifs_setup_ipc - helper to setup the IPC tcon for the session
1821 * @ses: smb session to issue the request on
1822 * @ctx: the superblock configuration context to use for building the
1823 *       new tree connection for the IPC (interprocess communication RPC)
1824 *
1825 * A new IPC connection is made and stored in the session
1826 * tcon_ipc. The IPC tcon has the same lifetime as the session.
1827 */
1828static int
1829cifs_setup_ipc(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1830{
1831	int rc = 0, xid;
1832	struct cifs_tcon *tcon;
1833	char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
1834	bool seal = false;
1835	struct TCP_Server_Info *server = ses->server;
1836
1837	/*
1838	 * If the mount request that resulted in the creation of the
1839	 * session requires encryption, force IPC to be encrypted too.
1840	 */
1841	if (ctx->seal) {
1842		if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
1843			seal = true;
1844		else {
1845			cifs_server_dbg(VFS,
1846				 "IPC: server doesn't support encryption\n");
1847			return -EOPNOTSUPP;
1848		}
1849	}
1850
1851	tcon = tconInfoAlloc();
1852	if (tcon == NULL)
1853		return -ENOMEM;
1854
1855	scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
1856
1857	xid = get_xid();
1858	tcon->ses = ses;
1859	tcon->ipc = true;
1860	tcon->seal = seal;
1861	rc = server->ops->tree_connect(xid, ses, unc, tcon, ctx->local_nls);
1862	free_xid(xid);
1863
1864	if (rc) {
1865		cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
1866		tconInfoFree(tcon);
1867		goto out;
1868	}
1869
1870	cifs_dbg(FYI, "IPC tcon rc=%d ipc tid=0x%x\n", rc, tcon->tid);
1871
1872	spin_lock(&tcon->tc_lock);
1873	tcon->status = TID_GOOD;
1874	spin_unlock(&tcon->tc_lock);
1875	ses->tcon_ipc = tcon;
1876out:
1877	return rc;
1878}
1879
1880/**
1881 * cifs_free_ipc - helper to release the session IPC tcon
1882 * @ses: smb session to unmount the IPC from
1883 *
1884 * Needs to be called everytime a session is destroyed.
1885 *
1886 * On session close, the IPC is closed and the server must release all tcons of the session.
1887 * No need to send a tree disconnect here.
1888 *
1889 * Besides, it will make the server to not close durable and resilient files on session close, as
1890 * specified in MS-SMB2 3.3.5.6 Receiving an SMB2 LOGOFF Request.
1891 */
1892static int
1893cifs_free_ipc(struct cifs_ses *ses)
1894{
1895	struct cifs_tcon *tcon = ses->tcon_ipc;
1896
1897	if (tcon == NULL)
1898		return 0;
1899
1900	tconInfoFree(tcon);
1901	ses->tcon_ipc = NULL;
1902	return 0;
1903}
1904
1905static struct cifs_ses *
1906cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1907{
1908	struct cifs_ses *ses;
1909
1910	spin_lock(&cifs_tcp_ses_lock);
1911	list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1912		spin_lock(&ses->ses_lock);
1913		if (ses->ses_status == SES_EXITING) {
1914			spin_unlock(&ses->ses_lock);
1915			continue;
1916		}
1917		if (!match_session(ses, ctx)) {
1918			spin_unlock(&ses->ses_lock);
1919			continue;
1920		}
1921		spin_unlock(&ses->ses_lock);
1922
1923		++ses->ses_count;
1924		spin_unlock(&cifs_tcp_ses_lock);
1925		return ses;
1926	}
1927	spin_unlock(&cifs_tcp_ses_lock);
1928	return NULL;
1929}
1930
1931void cifs_put_smb_ses(struct cifs_ses *ses)
 
1932{
1933	unsigned int rc, xid;
1934	unsigned int chan_count;
1935	struct TCP_Server_Info *server = ses->server;
1936
1937	spin_lock(&ses->ses_lock);
1938	if (ses->ses_status == SES_EXITING) {
1939		spin_unlock(&ses->ses_lock);
1940		return;
1941	}
1942	spin_unlock(&ses->ses_lock);
1943
1944	cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
1945	cifs_dbg(FYI,
1946		 "%s: ses ipc: %s\n", __func__, ses->tcon_ipc ? ses->tcon_ipc->tree_name : "NONE");
1947
1948	spin_lock(&cifs_tcp_ses_lock);
1949	if (--ses->ses_count > 0) {
1950		spin_unlock(&cifs_tcp_ses_lock);
1951		return;
1952	}
1953	spin_unlock(&cifs_tcp_ses_lock);
1954
1955	/* ses_count can never go negative */
1956	WARN_ON(ses->ses_count < 0);
1957
1958	if (ses->ses_status == SES_GOOD)
1959		ses->ses_status = SES_EXITING;
1960
1961	cifs_free_ipc(ses);
1962
1963	if (ses->ses_status == SES_EXITING && server->ops->logoff) {
1964		xid = get_xid();
1965		rc = server->ops->logoff(xid, ses);
1966		if (rc)
1967			cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
1968				__func__, rc);
1969		_free_xid(xid);
1970	}
1971
1972	spin_lock(&cifs_tcp_ses_lock);
1973	list_del_init(&ses->smb_ses_list);
1974	spin_unlock(&cifs_tcp_ses_lock);
1975
1976	chan_count = ses->chan_count;
1977
1978	/* close any extra channels */
1979	if (chan_count > 1) {
1980		int i;
1981
1982		for (i = 1; i < chan_count; i++) {
1983			if (ses->chans[i].iface) {
1984				kref_put(&ses->chans[i].iface->refcount, release_iface);
1985				ses->chans[i].iface = NULL;
1986			}
1987			cifs_put_tcp_session(ses->chans[i].server, 0);
1988			ses->chans[i].server = NULL;
1989		}
1990	}
1991
1992	sesInfoFree(ses);
1993	cifs_put_tcp_session(server, 0);
1994}
1995
1996#ifdef CONFIG_KEYS
1997
1998/* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
1999#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2000
2001/* Populate username and pw fields from keyring if possible */
2002static int
2003cifs_set_cifscreds(struct smb3_fs_context *ctx, struct cifs_ses *ses)
2004{
2005	int rc = 0;
2006	int is_domain = 0;
2007	const char *delim, *payload;
2008	char *desc;
2009	ssize_t len;
2010	struct key *key;
2011	struct TCP_Server_Info *server = ses->server;
2012	struct sockaddr_in *sa;
2013	struct sockaddr_in6 *sa6;
2014	const struct user_key_payload *upayload;
2015
2016	desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2017	if (!desc)
2018		return -ENOMEM;
2019
2020	/* try to find an address key first */
2021	switch (server->dstaddr.ss_family) {
2022	case AF_INET:
2023		sa = (struct sockaddr_in *)&server->dstaddr;
2024		sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2025		break;
2026	case AF_INET6:
2027		sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2028		sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2029		break;
2030	default:
2031		cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2032			 server->dstaddr.ss_family);
2033		rc = -EINVAL;
2034		goto out_err;
2035	}
2036
2037	cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2038	key = request_key(&key_type_logon, desc, "");
2039	if (IS_ERR(key)) {
2040		if (!ses->domainName) {
2041			cifs_dbg(FYI, "domainName is NULL\n");
2042			rc = PTR_ERR(key);
2043			goto out_err;
2044		}
2045
2046		/* didn't work, try to find a domain key */
2047		sprintf(desc, "cifs:d:%s", ses->domainName);
2048		cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2049		key = request_key(&key_type_logon, desc, "");
2050		if (IS_ERR(key)) {
2051			rc = PTR_ERR(key);
2052			goto out_err;
2053		}
2054		is_domain = 1;
2055	}
2056
2057	down_read(&key->sem);
2058	upayload = user_key_payload_locked(key);
2059	if (IS_ERR_OR_NULL(upayload)) {
2060		rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2061		goto out_key_put;
2062	}
2063
2064	/* find first : in payload */
2065	payload = upayload->data;
2066	delim = strnchr(payload, upayload->datalen, ':');
2067	cifs_dbg(FYI, "payload=%s\n", payload);
2068	if (!delim) {
2069		cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2070			 upayload->datalen);
2071		rc = -EINVAL;
2072		goto out_key_put;
2073	}
2074
2075	len = delim - payload;
2076	if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2077		cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2078			 len);
2079		rc = -EINVAL;
2080		goto out_key_put;
2081	}
2082
2083	ctx->username = kstrndup(payload, len, GFP_KERNEL);
2084	if (!ctx->username) {
2085		cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2086			 len);
2087		rc = -ENOMEM;
2088		goto out_key_put;
2089	}
2090	cifs_dbg(FYI, "%s: username=%s\n", __func__, ctx->username);
2091
2092	len = key->datalen - (len + 1);
2093	if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2094		cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2095		rc = -EINVAL;
2096		kfree(ctx->username);
2097		ctx->username = NULL;
2098		goto out_key_put;
2099	}
2100
2101	++delim;
2102	ctx->password = kstrndup(delim, len, GFP_KERNEL);
2103	if (!ctx->password) {
2104		cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2105			 len);
2106		rc = -ENOMEM;
2107		kfree(ctx->username);
2108		ctx->username = NULL;
2109		goto out_key_put;
2110	}
2111
2112	/*
2113	 * If we have a domain key then we must set the domainName in the
2114	 * for the request.
2115	 */
2116	if (is_domain && ses->domainName) {
2117		ctx->domainname = kstrdup(ses->domainName, GFP_KERNEL);
2118		if (!ctx->domainname) {
2119			cifs_dbg(FYI, "Unable to allocate %zd bytes for domain\n",
2120				 len);
2121			rc = -ENOMEM;
2122			kfree(ctx->username);
2123			ctx->username = NULL;
2124			kfree_sensitive(ctx->password);
2125			ctx->password = NULL;
2126			goto out_key_put;
2127		}
2128	}
2129
2130	strscpy(ctx->workstation_name, ses->workstation_name, sizeof(ctx->workstation_name));
2131
2132out_key_put:
2133	up_read(&key->sem);
2134	key_put(key);
2135out_err:
2136	kfree(desc);
2137	cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2138	return rc;
2139}
2140#else /* ! CONFIG_KEYS */
2141static inline int
2142cifs_set_cifscreds(struct smb3_fs_context *ctx __attribute__((unused)),
2143		   struct cifs_ses *ses __attribute__((unused)))
2144{
2145	return -ENOSYS;
2146}
2147#endif /* CONFIG_KEYS */
2148
2149/**
2150 * cifs_get_smb_ses - get a session matching @ctx data from @server
2151 * @server: server to setup the session to
2152 * @ctx: superblock configuration context to use to setup the session
2153 *
2154 * This function assumes it is being called from cifs_mount() where we
2155 * already got a server reference (server refcount +1). See
2156 * cifs_get_tcon() for refcount explanations.
2157 */
2158struct cifs_ses *
2159cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
2160{
2161	int rc = 0;
2162	unsigned int xid;
2163	struct cifs_ses *ses;
2164	struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2165	struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2166
2167	xid = get_xid();
2168
2169	ses = cifs_find_smb_ses(server, ctx);
2170	if (ses) {
2171		cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2172			 ses->ses_status);
2173
2174		spin_lock(&ses->chan_lock);
2175		if (cifs_chan_needs_reconnect(ses, server)) {
2176			spin_unlock(&ses->chan_lock);
2177			cifs_dbg(FYI, "Session needs reconnect\n");
2178
2179			mutex_lock(&ses->session_mutex);
2180			rc = cifs_negotiate_protocol(xid, ses, server);
2181			if (rc) {
2182				mutex_unlock(&ses->session_mutex);
2183				/* problem -- put our ses reference */
2184				cifs_put_smb_ses(ses);
2185				free_xid(xid);
2186				return ERR_PTR(rc);
2187			}
2188
2189			rc = cifs_setup_session(xid, ses, server,
2190						ctx->local_nls);
2191			if (rc) {
2192				mutex_unlock(&ses->session_mutex);
2193				/* problem -- put our reference */
2194				cifs_put_smb_ses(ses);
2195				free_xid(xid);
2196				return ERR_PTR(rc);
2197			}
2198			mutex_unlock(&ses->session_mutex);
2199
2200			spin_lock(&ses->chan_lock);
2201		}
2202		spin_unlock(&ses->chan_lock);
2203
2204		/* existing SMB ses has a server reference already */
2205		cifs_put_tcp_session(server, 0);
2206		free_xid(xid);
2207		return ses;
2208	}
2209
2210	rc = -ENOMEM;
2211
2212	cifs_dbg(FYI, "Existing smb sess not found\n");
2213	ses = sesInfoAlloc();
2214	if (ses == NULL)
2215		goto get_ses_fail;
2216
2217	/* new SMB session uses our server ref */
2218	ses->server = server;
2219	if (server->dstaddr.ss_family == AF_INET6)
2220		sprintf(ses->ip_addr, "%pI6", &addr6->sin6_addr);
2221	else
2222		sprintf(ses->ip_addr, "%pI4", &addr->sin_addr);
2223
2224	if (ctx->username) {
2225		ses->user_name = kstrdup(ctx->username, GFP_KERNEL);
2226		if (!ses->user_name)
2227			goto get_ses_fail;
2228	}
2229
2230	/* ctx->password freed at unmount */
2231	if (ctx->password) {
2232		ses->password = kstrdup(ctx->password, GFP_KERNEL);
2233		if (!ses->password)
2234			goto get_ses_fail;
2235	}
2236	if (ctx->domainname) {
2237		ses->domainName = kstrdup(ctx->domainname, GFP_KERNEL);
2238		if (!ses->domainName)
2239			goto get_ses_fail;
2240	}
 
 
2241
2242	strscpy(ses->workstation_name, ctx->workstation_name, sizeof(ses->workstation_name));
2243
2244	if (ctx->domainauto)
2245		ses->domainAuto = ctx->domainauto;
2246	ses->cred_uid = ctx->cred_uid;
2247	ses->linux_uid = ctx->linux_uid;
2248
2249	ses->sectype = ctx->sectype;
2250	ses->sign = ctx->sign;
2251
2252	/* add server as first channel */
2253	spin_lock(&ses->chan_lock);
2254	ses->chans[0].server = server;
2255	ses->chan_count = 1;
2256	ses->chan_max = ctx->multichannel ? ctx->max_channels:1;
2257	ses->chans_need_reconnect = 1;
2258	spin_unlock(&ses->chan_lock);
2259
2260	mutex_lock(&ses->session_mutex);
2261	rc = cifs_negotiate_protocol(xid, ses, server);
2262	if (!rc)
2263		rc = cifs_setup_session(xid, ses, server, ctx->local_nls);
2264	mutex_unlock(&ses->session_mutex);
2265
2266	/* each channel uses a different signing key */
2267	spin_lock(&ses->chan_lock);
2268	memcpy(ses->chans[0].signkey, ses->smb3signingkey,
2269	       sizeof(ses->smb3signingkey));
2270	spin_unlock(&ses->chan_lock);
2271
2272	if (rc)
2273		goto get_ses_fail;
2274
2275	/*
2276	 * success, put it on the list and add it as first channel
2277	 * note: the session becomes active soon after this. So you'll
2278	 * need to lock before changing something in the session.
2279	 */
2280	spin_lock(&cifs_tcp_ses_lock);
2281	list_add(&ses->smb_ses_list, &server->smb_ses_list);
2282	spin_unlock(&cifs_tcp_ses_lock);
2283
2284	cifs_setup_ipc(ses, ctx);
2285
2286	free_xid(xid);
2287
2288	return ses;
2289
2290get_ses_fail:
2291	sesInfoFree(ses);
2292	free_xid(xid);
2293	return ERR_PTR(rc);
2294}
2295
2296/* this function must be called with tc_lock held */
2297static int match_tcon(struct cifs_tcon *tcon, struct smb3_fs_context *ctx, bool dfs_super_cmp)
2298{
2299	if (tcon->status == TID_EXITING)
2300		return 0;
2301	/* Skip UNC validation when matching DFS superblocks */
2302	if (!dfs_super_cmp && strncmp(tcon->tree_name, ctx->UNC, MAX_TREE_SIZE))
2303		return 0;
2304	if (tcon->seal != ctx->seal)
2305		return 0;
2306	if (tcon->snapshot_time != ctx->snapshot_time)
2307		return 0;
2308	if (tcon->handle_timeout != ctx->handle_timeout)
2309		return 0;
2310	if (tcon->no_lease != ctx->no_lease)
2311		return 0;
2312	if (tcon->nodelete != ctx->nodelete)
2313		return 0;
2314	return 1;
2315}
2316
2317static struct cifs_tcon *
2318cifs_find_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
2319{
 
2320	struct cifs_tcon *tcon;
2321
2322	spin_lock(&cifs_tcp_ses_lock);
2323	list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
2324		spin_lock(&tcon->tc_lock);
2325		if (!match_tcon(tcon, ctx, false)) {
2326			spin_unlock(&tcon->tc_lock);
2327			continue;
2328		}
2329		++tcon->tc_count;
2330		spin_unlock(&tcon->tc_lock);
2331		spin_unlock(&cifs_tcp_ses_lock);
2332		return tcon;
2333	}
2334	spin_unlock(&cifs_tcp_ses_lock);
2335	return NULL;
2336}
2337
2338void
2339cifs_put_tcon(struct cifs_tcon *tcon)
2340{
2341	unsigned int xid;
2342	struct cifs_ses *ses;
2343
2344	/*
2345	 * IPC tcon share the lifetime of their session and are
2346	 * destroyed in the session put function
2347	 */
2348	if (tcon == NULL || tcon->ipc)
2349		return;
2350
2351	ses = tcon->ses;
2352	cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2353	spin_lock(&cifs_tcp_ses_lock);
2354	spin_lock(&tcon->tc_lock);
2355	if (--tcon->tc_count > 0) {
2356		spin_unlock(&tcon->tc_lock);
2357		spin_unlock(&cifs_tcp_ses_lock);
2358		return;
2359	}
2360
2361	/* tc_count can never go negative */
2362	WARN_ON(tcon->tc_count < 0);
2363
2364	list_del_init(&tcon->tcon_list);
2365	spin_unlock(&tcon->tc_lock);
2366	spin_unlock(&cifs_tcp_ses_lock);
2367
2368	/* cancel polling of interfaces */
2369	cancel_delayed_work_sync(&tcon->query_interfaces);
2370
2371	if (tcon->use_witness) {
2372		int rc;
2373
2374		rc = cifs_swn_unregister(tcon);
2375		if (rc < 0) {
2376			cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
2377					__func__, rc);
2378		}
2379	}
2380
2381	xid = get_xid();
2382	if (ses->server->ops->tree_disconnect)
2383		ses->server->ops->tree_disconnect(xid, tcon);
2384	_free_xid(xid);
2385
2386	cifs_fscache_release_super_cookie(tcon);
2387	tconInfoFree(tcon);
2388	cifs_put_smb_ses(ses);
2389}
2390
2391/**
2392 * cifs_get_tcon - get a tcon matching @ctx data from @ses
2393 * @ses: smb session to issue the request on
2394 * @ctx: the superblock configuration context to use for building the
2395 *
2396 * - tcon refcount is the number of mount points using the tcon.
2397 * - ses refcount is the number of tcon using the session.
2398 *
2399 * 1. This function assumes it is being called from cifs_mount() where
2400 *    we already got a session reference (ses refcount +1).
2401 *
2402 * 2. Since we're in the context of adding a mount point, the end
2403 *    result should be either:
2404 *
2405 * a) a new tcon already allocated with refcount=1 (1 mount point) and
2406 *    its session refcount incremented (1 new tcon). This +1 was
2407 *    already done in (1).
2408 *
2409 * b) an existing tcon with refcount+1 (add a mount point to it) and
2410 *    identical ses refcount (no new tcon). Because of (1) we need to
2411 *    decrement the ses refcount.
2412 */
2413static struct cifs_tcon *
2414cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
2415{
2416	int rc, xid;
2417	struct cifs_tcon *tcon;
2418
2419	tcon = cifs_find_tcon(ses, ctx);
2420	if (tcon) {
2421		/*
2422		 * tcon has refcount already incremented but we need to
2423		 * decrement extra ses reference gotten by caller (case b)
2424		 */
2425		cifs_dbg(FYI, "Found match on UNC path\n");
2426		cifs_put_smb_ses(ses);
 
 
 
2427		return tcon;
2428	}
2429
2430	if (!ses->server->ops->tree_connect) {
2431		rc = -ENOSYS;
2432		goto out_fail;
2433	}
2434
2435	tcon = tconInfoAlloc();
2436	if (tcon == NULL) {
2437		rc = -ENOMEM;
2438		goto out_fail;
2439	}
2440
2441	if (ctx->snapshot_time) {
2442		if (ses->server->vals->protocol_id == 0) {
2443			cifs_dbg(VFS,
2444			     "Use SMB2 or later for snapshot mount option\n");
2445			rc = -EOPNOTSUPP;
2446			goto out_fail;
2447		} else
2448			tcon->snapshot_time = ctx->snapshot_time;
2449	}
2450
2451	if (ctx->handle_timeout) {
2452		if (ses->server->vals->protocol_id == 0) {
2453			cifs_dbg(VFS,
2454			     "Use SMB2.1 or later for handle timeout option\n");
2455			rc = -EOPNOTSUPP;
2456			goto out_fail;
2457		} else
2458			tcon->handle_timeout = ctx->handle_timeout;
2459	}
2460
2461	tcon->ses = ses;
2462	if (ctx->password) {
2463		tcon->password = kstrdup(ctx->password, GFP_KERNEL);
2464		if (!tcon->password) {
2465			rc = -ENOMEM;
2466			goto out_fail;
2467		}
2468	}
2469
2470	if (ctx->seal) {
2471		if (ses->server->vals->protocol_id == 0) {
2472			cifs_dbg(VFS,
2473				 "SMB3 or later required for encryption\n");
2474			rc = -EOPNOTSUPP;
2475			goto out_fail;
2476		} else if (tcon->ses->server->capabilities &
2477					SMB2_GLOBAL_CAP_ENCRYPTION)
2478			tcon->seal = true;
2479		else {
2480			cifs_dbg(VFS, "Encryption is not supported on share\n");
2481			rc = -EOPNOTSUPP;
2482			goto out_fail;
2483		}
2484	}
2485
2486	if (ctx->linux_ext) {
2487		if (ses->server->posix_ext_supported) {
2488			tcon->posix_extensions = true;
2489			pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
2490		} else if ((ses->server->vals->protocol_id == SMB311_PROT_ID) ||
2491		    (strcmp(ses->server->vals->version_string,
2492		     SMB3ANY_VERSION_STRING) == 0) ||
2493		    (strcmp(ses->server->vals->version_string,
2494		     SMBDEFAULT_VERSION_STRING) == 0)) {
2495			cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions\n");
2496			rc = -EOPNOTSUPP;
2497			goto out_fail;
2498		} else {
2499			cifs_dbg(VFS, "Check vers= mount option. SMB3.11 "
2500				"disabled but required for POSIX extensions\n");
2501			rc = -EOPNOTSUPP;
2502			goto out_fail;
2503		}
2504	}
2505
2506	xid = get_xid();
2507	rc = ses->server->ops->tree_connect(xid, ses, ctx->UNC, tcon,
2508					    ctx->local_nls);
2509	free_xid(xid);
2510	cifs_dbg(FYI, "Tcon rc = %d\n", rc);
 
 
2511	if (rc)
2512		goto out_fail;
2513
2514	tcon->use_persistent = false;
2515	/* check if SMB2 or later, CIFS does not support persistent handles */
2516	if (ctx->persistent) {
2517		if (ses->server->vals->protocol_id == 0) {
2518			cifs_dbg(VFS,
2519			     "SMB3 or later required for persistent handles\n");
2520			rc = -EOPNOTSUPP;
2521			goto out_fail;
2522		} else if (ses->server->capabilities &
2523			   SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2524			tcon->use_persistent = true;
2525		else /* persistent handles requested but not supported */ {
2526			cifs_dbg(VFS,
2527				"Persistent handles not supported on share\n");
2528			rc = -EOPNOTSUPP;
2529			goto out_fail;
2530		}
2531	} else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2532	     && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2533	     && (ctx->nopersistent == false)) {
2534		cifs_dbg(FYI, "enabling persistent handles\n");
2535		tcon->use_persistent = true;
2536	} else if (ctx->resilient) {
2537		if (ses->server->vals->protocol_id == 0) {
2538			cifs_dbg(VFS,
2539			     "SMB2.1 or later required for resilient handles\n");
2540			rc = -EOPNOTSUPP;
2541			goto out_fail;
2542		}
2543		tcon->use_resilient = true;
2544	}
2545
2546	tcon->use_witness = false;
2547	if (IS_ENABLED(CONFIG_CIFS_SWN_UPCALL) && ctx->witness) {
2548		if (ses->server->vals->protocol_id >= SMB30_PROT_ID) {
2549			if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) {
2550				/*
2551				 * Set witness in use flag in first place
2552				 * to retry registration in the echo task
2553				 */
2554				tcon->use_witness = true;
2555				/* And try to register immediately */
2556				rc = cifs_swn_register(tcon);
2557				if (rc < 0) {
2558					cifs_dbg(VFS, "Failed to register for witness notifications: %d\n", rc);
2559					goto out_fail;
2560				}
2561			} else {
2562				/* TODO: try to extend for non-cluster uses (eg multichannel) */
2563				cifs_dbg(VFS, "witness requested on mount but no CLUSTER capability on share\n");
2564				rc = -EOPNOTSUPP;
2565				goto out_fail;
2566			}
2567		} else {
2568			cifs_dbg(VFS, "SMB3 or later required for witness option\n");
2569			rc = -EOPNOTSUPP;
2570			goto out_fail;
2571		}
2572	}
2573
2574	/* If the user really knows what they are doing they can override */
2575	if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
2576		if (ctx->cache_ro)
2577			cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
2578		else if (ctx->cache_rw)
2579			cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
2580	}
2581
2582	if (ctx->no_lease) {
2583		if (ses->server->vals->protocol_id == 0) {
2584			cifs_dbg(VFS,
2585				"SMB2 or later required for nolease option\n");
2586			rc = -EOPNOTSUPP;
2587			goto out_fail;
2588		} else
2589			tcon->no_lease = ctx->no_lease;
2590	}
2591
2592	/*
2593	 * We can have only one retry value for a connection to a share so for
2594	 * resources mounted more than once to the same server share the last
2595	 * value passed in for the retry flag is used.
2596	 */
2597	tcon->retry = ctx->retry;
2598	tcon->nocase = ctx->nocase;
2599	tcon->broken_sparse_sup = ctx->no_sparse;
2600	if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
2601		tcon->nohandlecache = ctx->nohandlecache;
2602	else
2603		tcon->nohandlecache = true;
2604	tcon->nodelete = ctx->nodelete;
2605	tcon->local_lease = ctx->local_lease;
2606	INIT_LIST_HEAD(&tcon->pending_opens);
2607	tcon->status = TID_GOOD;
2608
2609	INIT_DELAYED_WORK(&tcon->query_interfaces,
2610			  smb2_query_server_interfaces);
2611	if (ses->server->dialect >= SMB30_PROT_ID &&
2612	    (ses->server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
2613		/* schedule query interfaces poll */
2614		queue_delayed_work(cifsiod_wq, &tcon->query_interfaces,
2615				   (SMB_INTERFACE_POLL_INTERVAL * HZ));
2616	}
2617
2618	spin_lock(&cifs_tcp_ses_lock);
2619	list_add(&tcon->tcon_list, &ses->tcon_list);
2620	spin_unlock(&cifs_tcp_ses_lock);
2621
 
 
2622	return tcon;
2623
2624out_fail:
2625	tconInfoFree(tcon);
2626	return ERR_PTR(rc);
2627}
2628
2629void
2630cifs_put_tlink(struct tcon_link *tlink)
2631{
2632	if (!tlink || IS_ERR(tlink))
2633		return;
2634
2635	if (!atomic_dec_and_test(&tlink->tl_count) ||
2636	    test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2637		tlink->tl_time = jiffies;
2638		return;
2639	}
2640
2641	if (!IS_ERR(tlink_tcon(tlink)))
2642		cifs_put_tcon(tlink_tcon(tlink));
2643	kfree(tlink);
2644	return;
2645}
2646
 
 
 
 
 
 
2647static int
2648compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2649{
2650	struct cifs_sb_info *old = CIFS_SB(sb);
2651	struct cifs_sb_info *new = mnt_data->cifs_sb;
2652	unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
2653	unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
2654
2655	if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2656		return 0;
2657
2658	if (old->mnt_cifs_serverino_autodisabled)
2659		newflags &= ~CIFS_MOUNT_SERVER_INUM;
2660
2661	if (oldflags != newflags)
2662		return 0;
2663
2664	/*
2665	 * We want to share sb only if we don't specify an r/wsize or
2666	 * specified r/wsize is greater than or equal to existing one.
2667	 */
2668	if (new->ctx->wsize && new->ctx->wsize < old->ctx->wsize)
2669		return 0;
2670
2671	if (new->ctx->rsize && new->ctx->rsize < old->ctx->rsize)
2672		return 0;
2673
2674	if (!uid_eq(old->ctx->linux_uid, new->ctx->linux_uid) ||
2675	    !gid_eq(old->ctx->linux_gid, new->ctx->linux_gid))
2676		return 0;
2677
2678	if (old->ctx->file_mode != new->ctx->file_mode ||
2679	    old->ctx->dir_mode != new->ctx->dir_mode)
2680		return 0;
2681
2682	if (strcmp(old->local_nls->charset, new->local_nls->charset))
2683		return 0;
2684
2685	if (old->ctx->acregmax != new->ctx->acregmax)
2686		return 0;
2687	if (old->ctx->acdirmax != new->ctx->acdirmax)
2688		return 0;
2689	if (old->ctx->closetimeo != new->ctx->closetimeo)
2690		return 0;
2691
2692	return 1;
2693}
2694
2695static int
2696match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2697{
2698	struct cifs_sb_info *old = CIFS_SB(sb);
2699	struct cifs_sb_info *new = mnt_data->cifs_sb;
2700	bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2701		old->prepath;
2702	bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2703		new->prepath;
2704
2705	if (old_set && new_set && !strcmp(new->prepath, old->prepath))
2706		return 1;
2707	else if (!old_set && !new_set)
2708		return 1;
2709
2710	return 0;
2711}
2712
2713int
2714cifs_match_super(struct super_block *sb, void *data)
2715{
2716	struct cifs_mnt_data *mnt_data = data;
2717	struct smb3_fs_context *ctx;
2718	struct cifs_sb_info *cifs_sb;
2719	struct TCP_Server_Info *tcp_srv;
2720	struct cifs_ses *ses;
2721	struct cifs_tcon *tcon;
2722	struct tcon_link *tlink;
2723	bool dfs_super_cmp;
2724	int rc = 0;
2725
 
 
2726	spin_lock(&cifs_tcp_ses_lock);
2727	cifs_sb = CIFS_SB(sb);
2728	tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2729	if (tlink == NULL) {
2730		/* can not match superblock if tlink were ever null */
2731		spin_unlock(&cifs_tcp_ses_lock);
2732		return 0;
2733	}
2734	tcon = tlink_tcon(tlink);
2735	ses = tcon->ses;
2736	tcp_srv = ses->server;
2737
2738	dfs_super_cmp = IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) && tcp_srv->origin_fullpath;
 
 
 
2739
2740	ctx = mnt_data->ctx;
 
 
 
 
 
2741
2742	spin_lock(&tcp_srv->srv_lock);
2743	spin_lock(&ses->ses_lock);
2744	spin_lock(&tcon->tc_lock);
2745	if (!match_server(tcp_srv, ctx, dfs_super_cmp) ||
2746	    !match_session(ses, ctx) ||
2747	    !match_tcon(tcon, ctx, dfs_super_cmp) ||
2748	    !match_prepath(sb, mnt_data)) {
2749		rc = 0;
2750		goto out;
2751	}
2752
2753	rc = compare_mount_options(sb, mnt_data);
2754out:
2755	spin_unlock(&tcon->tc_lock);
2756	spin_unlock(&ses->ses_lock);
2757	spin_unlock(&tcp_srv->srv_lock);
2758
2759	spin_unlock(&cifs_tcp_ses_lock);
2760	cifs_put_tlink(tlink);
2761	return rc;
2762}
2763
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2764#ifdef CONFIG_DEBUG_LOCK_ALLOC
2765static struct lock_class_key cifs_key[2];
2766static struct lock_class_key cifs_slock_key[2];
2767
2768static inline void
2769cifs_reclassify_socket4(struct socket *sock)
2770{
2771	struct sock *sk = sock->sk;
2772	BUG_ON(!sock_allow_reclassification(sk));
2773	sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2774		&cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2775}
2776
2777static inline void
2778cifs_reclassify_socket6(struct socket *sock)
2779{
2780	struct sock *sk = sock->sk;
2781	BUG_ON(!sock_allow_reclassification(sk));
2782	sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2783		&cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2784}
2785#else
2786static inline void
2787cifs_reclassify_socket4(struct socket *sock)
2788{
2789}
2790
2791static inline void
2792cifs_reclassify_socket6(struct socket *sock)
2793{
2794}
2795#endif
2796
2797/* See RFC1001 section 14 on representation of Netbios names */
2798static void rfc1002mangle(char *target, char *source, unsigned int length)
2799{
2800	unsigned int i, j;
2801
2802	for (i = 0, j = 0; i < (length); i++) {
2803		/* mask a nibble at a time and encode */
2804		target[j] = 'A' + (0x0F & (source[i] >> 4));
2805		target[j+1] = 'A' + (0x0F & source[i]);
2806		j += 2;
2807	}
2808
2809}
2810
2811static int
2812bind_socket(struct TCP_Server_Info *server)
2813{
2814	int rc = 0;
2815	if (server->srcaddr.ss_family != AF_UNSPEC) {
2816		/* Bind to the specified local IP address */
2817		struct socket *socket = server->ssocket;
2818		rc = socket->ops->bind(socket,
2819				       (struct sockaddr *) &server->srcaddr,
2820				       sizeof(server->srcaddr));
2821		if (rc < 0) {
2822			struct sockaddr_in *saddr4;
2823			struct sockaddr_in6 *saddr6;
2824			saddr4 = (struct sockaddr_in *)&server->srcaddr;
2825			saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2826			if (saddr6->sin6_family == AF_INET6)
2827				cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2828					 &saddr6->sin6_addr, rc);
 
2829			else
2830				cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2831					 &saddr4->sin_addr.s_addr, rc);
 
2832		}
2833	}
2834	return rc;
2835}
2836
2837static int
2838ip_rfc1001_connect(struct TCP_Server_Info *server)
2839{
2840	int rc = 0;
2841	/*
2842	 * some servers require RFC1001 sessinit before sending
2843	 * negprot - BB check reconnection in case where second
2844	 * sessinit is sent but no second negprot
2845	 */
2846	struct rfc1002_session_packet *ses_init_buf;
2847	unsigned int req_noscope_len;
2848	struct smb_hdr *smb_buf;
2849
2850	ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2851			       GFP_KERNEL);
2852
2853	if (ses_init_buf) {
2854		ses_init_buf->trailer.session_req.called_len = 32;
2855
2856		if (server->server_RFC1001_name[0] != 0)
 
2857			rfc1002mangle(ses_init_buf->trailer.
2858				      session_req.called_name,
2859				      server->server_RFC1001_name,
2860				      RFC1001_NAME_LEN_WITH_NULL);
2861		else
2862			rfc1002mangle(ses_init_buf->trailer.
2863				      session_req.called_name,
2864				      DEFAULT_CIFS_CALLED_NAME,
2865				      RFC1001_NAME_LEN_WITH_NULL);
2866
2867		ses_init_buf->trailer.session_req.calling_len = 32;
2868
2869		/*
2870		 * calling name ends in null (byte 16) from old smb
2871		 * convention.
2872		 */
2873		if (server->workstation_RFC1001_name[0] != 0)
 
2874			rfc1002mangle(ses_init_buf->trailer.
2875				      session_req.calling_name,
2876				      server->workstation_RFC1001_name,
2877				      RFC1001_NAME_LEN_WITH_NULL);
2878		else
2879			rfc1002mangle(ses_init_buf->trailer.
2880				      session_req.calling_name,
2881				      "LINUX_CIFS_CLNT",
2882				      RFC1001_NAME_LEN_WITH_NULL);
2883
2884		ses_init_buf->trailer.session_req.scope1 = 0;
2885		ses_init_buf->trailer.session_req.scope2 = 0;
2886		smb_buf = (struct smb_hdr *)ses_init_buf;
2887
2888		/* sizeof RFC1002_SESSION_REQUEST with no scopes */
2889		req_noscope_len = sizeof(struct rfc1002_session_packet) - 2;
2890
2891		/* == cpu_to_be32(0x81000044) */
2892		smb_buf->smb_buf_length =
2893			cpu_to_be32((RFC1002_SESSION_REQUEST << 24) | req_noscope_len);
2894		rc = smb_send(server, smb_buf, 0x44);
2895		kfree(ses_init_buf);
2896		/*
2897		 * RFC1001 layer in at least one server
2898		 * requires very short break before negprot
2899		 * presumably because not expecting negprot
2900		 * to follow so fast.  This is a simple
2901		 * solution that works without
2902		 * complicating the code and causes no
2903		 * significant slowing down on mount
2904		 * for everyone else
2905		 */
2906		usleep_range(1000, 2000);
2907	}
2908	/*
2909	 * else the negprot may still work without this
2910	 * even though malloc failed
2911	 */
2912
2913	return rc;
2914}
2915
2916static int
2917generic_ip_connect(struct TCP_Server_Info *server)
2918{
2919	int rc = 0;
2920	__be16 sport;
2921	int slen, sfamily;
2922	struct socket *socket = server->ssocket;
2923	struct sockaddr *saddr;
2924
2925	saddr = (struct sockaddr *) &server->dstaddr;
2926
2927	if (server->dstaddr.ss_family == AF_INET6) {
2928		struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;
2929
2930		sport = ipv6->sin6_port;
2931		slen = sizeof(struct sockaddr_in6);
2932		sfamily = AF_INET6;
2933		cifs_dbg(FYI, "%s: connecting to [%pI6]:%d\n", __func__, &ipv6->sin6_addr,
2934				ntohs(sport));
2935	} else {
2936		struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;
2937
2938		sport = ipv4->sin_port;
2939		slen = sizeof(struct sockaddr_in);
2940		sfamily = AF_INET;
2941		cifs_dbg(FYI, "%s: connecting to %pI4:%d\n", __func__, &ipv4->sin_addr,
2942				ntohs(sport));
2943	}
2944
2945	if (socket == NULL) {
2946		rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2947				   IPPROTO_TCP, &socket, 1);
2948		if (rc < 0) {
2949			cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
2950			server->ssocket = NULL;
2951			return rc;
2952		}
2953
2954		/* BB other socket options to set KEEPALIVE, NODELAY? */
2955		cifs_dbg(FYI, "Socket created\n");
2956		server->ssocket = socket;
2957		socket->sk->sk_allocation = GFP_NOFS;
2958		socket->sk->sk_use_task_frag = false;
2959		if (sfamily == AF_INET6)
2960			cifs_reclassify_socket6(socket);
2961		else
2962			cifs_reclassify_socket4(socket);
2963	}
2964
2965	rc = bind_socket(server);
2966	if (rc < 0)
2967		return rc;
2968
2969	/*
2970	 * Eventually check for other socket options to change from
2971	 * the default. sock_setsockopt not used because it expects
2972	 * user space buffer
2973	 */
2974	socket->sk->sk_rcvtimeo = 7 * HZ;
2975	socket->sk->sk_sndtimeo = 5 * HZ;
2976
2977	/* make the bufsizes depend on wsize/rsize and max requests */
2978	if (server->noautotune) {
2979		if (socket->sk->sk_sndbuf < (200 * 1024))
2980			socket->sk->sk_sndbuf = 200 * 1024;
2981		if (socket->sk->sk_rcvbuf < (140 * 1024))
2982			socket->sk->sk_rcvbuf = 140 * 1024;
2983	}
2984
2985	if (server->tcp_nodelay)
2986		tcp_sock_set_nodelay(socket->sk);
 
 
 
 
 
2987
2988	cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
2989		 socket->sk->sk_sndbuf,
2990		 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2991
2992	rc = socket->ops->connect(socket, saddr, slen,
2993				  server->noblockcnt ? O_NONBLOCK : 0);
2994	/*
2995	 * When mounting SMB root file systems, we do not want to block in
2996	 * connect. Otherwise bail out and then let cifs_reconnect() perform
2997	 * reconnect failover - if possible.
2998	 */
2999	if (server->noblockcnt && rc == -EINPROGRESS)
3000		rc = 0;
3001	if (rc < 0) {
3002		cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3003		trace_smb3_connect_err(server->hostname, server->conn_id, &server->dstaddr, rc);
3004		sock_release(socket);
3005		server->ssocket = NULL;
3006		return rc;
3007	}
3008	trace_smb3_connect_done(server->hostname, server->conn_id, &server->dstaddr);
3009	if (sport == htons(RFC1001_PORT))
3010		rc = ip_rfc1001_connect(server);
3011
3012	return rc;
3013}
3014
3015static int
3016ip_connect(struct TCP_Server_Info *server)
3017{
3018	__be16 *sport;
3019	struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3020	struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3021
3022	if (server->dstaddr.ss_family == AF_INET6)
3023		sport = &addr6->sin6_port;
3024	else
3025		sport = &addr->sin_port;
3026
3027	if (*sport == 0) {
3028		int rc;
3029
3030		/* try with 445 port at first */
3031		*sport = htons(CIFS_PORT);
3032
3033		rc = generic_ip_connect(server);
3034		if (rc >= 0)
3035			return rc;
3036
3037		/* if it failed, try with 139 port */
3038		*sport = htons(RFC1001_PORT);
3039	}
3040
3041	return generic_ip_connect(server);
3042}
3043
3044#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3045void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3046			  struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3047{
3048	/*
3049	 * If we are reconnecting then should we check to see if
3050	 * any requested capabilities changed locally e.g. via
3051	 * remount but we can not do much about it here
3052	 * if they have (even if we could detect it by the following)
3053	 * Perhaps we could add a backpointer to array of sb from tcon
3054	 * or if we change to make all sb to same share the same
3055	 * sb as NFS - then we only have one backpointer to sb.
3056	 * What if we wanted to mount the server share twice once with
3057	 * and once without posixacls or posix paths?
3058	 */
3059	__u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3060
3061	if (ctx && ctx->no_linux_ext) {
3062		tcon->fsUnixInfo.Capability = 0;
3063		tcon->unix_ext = 0; /* Unix Extensions disabled */
3064		cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3065		return;
3066	} else if (ctx)
3067		tcon->unix_ext = 1; /* Unix Extensions supported */
3068
3069	if (!tcon->unix_ext) {
3070		cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3071		return;
3072	}
3073
3074	if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3075		__u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3076		cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3077		/*
3078		 * check for reconnect case in which we do not
3079		 * want to change the mount behavior if we can avoid it
3080		 */
3081		if (ctx == NULL) {
3082			/*
3083			 * turn off POSIX ACL and PATHNAMES if not set
3084			 * originally at mount time
3085			 */
3086			if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3087				cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3088			if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3089				if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3090					cifs_dbg(VFS, "POSIXPATH support change\n");
3091				cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3092			} else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3093				cifs_dbg(VFS, "possible reconnect error\n");
3094				cifs_dbg(VFS, "server disabled POSIX path support\n");
3095			}
3096		}
3097
3098		if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3099			cifs_dbg(VFS, "per-share encryption not supported yet\n");
3100
3101		cap &= CIFS_UNIX_CAP_MASK;
3102		if (ctx && ctx->no_psx_acl)
3103			cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3104		else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3105			cifs_dbg(FYI, "negotiated posix acl support\n");
3106			if (cifs_sb)
3107				cifs_sb->mnt_cifs_flags |=
3108					CIFS_MOUNT_POSIXACL;
3109		}
3110
3111		if (ctx && ctx->posix_paths == 0)
3112			cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3113		else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3114			cifs_dbg(FYI, "negotiate posix pathnames\n");
3115			if (cifs_sb)
3116				cifs_sb->mnt_cifs_flags |=
3117					CIFS_MOUNT_POSIX_PATHS;
3118		}
3119
3120		cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3121#ifdef CONFIG_CIFS_DEBUG2
3122		if (cap & CIFS_UNIX_FCNTL_CAP)
3123			cifs_dbg(FYI, "FCNTL cap\n");
3124		if (cap & CIFS_UNIX_EXTATTR_CAP)
3125			cifs_dbg(FYI, "EXTATTR cap\n");
3126		if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3127			cifs_dbg(FYI, "POSIX path cap\n");
3128		if (cap & CIFS_UNIX_XATTR_CAP)
3129			cifs_dbg(FYI, "XATTR cap\n");
3130		if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3131			cifs_dbg(FYI, "POSIX ACL cap\n");
3132		if (cap & CIFS_UNIX_LARGE_READ_CAP)
3133			cifs_dbg(FYI, "very large read cap\n");
3134		if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3135			cifs_dbg(FYI, "very large write cap\n");
3136		if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3137			cifs_dbg(FYI, "transport encryption cap\n");
3138		if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3139			cifs_dbg(FYI, "mandatory transport encryption cap\n");
3140#endif /* CIFS_DEBUG2 */
3141		if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3142			if (ctx == NULL)
3143				cifs_dbg(FYI, "resetting capabilities failed\n");
3144			else
3145				cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
 
 
 
 
 
3146
3147		}
3148	}
3149}
3150#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3151
3152int cifs_setup_cifs_sb(struct cifs_sb_info *cifs_sb)
 
3153{
3154	struct smb3_fs_context *ctx = cifs_sb->ctx;
3155
3156	INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3157
3158	spin_lock_init(&cifs_sb->tlink_tree_lock);
3159	cifs_sb->tlink_tree = RB_ROOT;
3160
3161	cifs_dbg(FYI, "file mode: %04ho  dir mode: %04ho\n",
3162		 ctx->file_mode, ctx->dir_mode);
 
 
 
 
3163
3164	/* this is needed for ASCII cp to Unicode converts */
3165	if (ctx->iocharset == NULL) {
3166		/* load_nls_default cannot return null */
3167		cifs_sb->local_nls = load_nls_default();
3168	} else {
3169		cifs_sb->local_nls = load_nls(ctx->iocharset);
3170		if (cifs_sb->local_nls == NULL) {
3171			cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3172				 ctx->iocharset);
3173			return -ELIBACC;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3174		}
3175	}
3176	ctx->local_nls = cifs_sb->local_nls;
3177
3178	smb3_update_mnt_flags(cifs_sb);
 
 
 
3179
3180	if (ctx->direct_io)
3181		cifs_dbg(FYI, "mounting share using direct i/o\n");
3182	if (ctx->cache_ro) {
3183		cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
3184		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
3185	} else if (ctx->cache_rw) {
3186		cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
3187		cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
3188					    CIFS_MOUNT_RW_CACHE);
3189	}
3190
3191	if ((ctx->cifs_acl) && (ctx->dynperm))
3192		cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3193
3194	if (ctx->prepath) {
3195		cifs_sb->prepath = kstrdup(ctx->prepath, GFP_KERNEL);
3196		if (cifs_sb->prepath == NULL)
3197			return -ENOMEM;
3198		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3199	}
3200
3201	return 0;
3202}
 
 
 
 
 
3203
3204/* Release all succeed connections */
3205void cifs_mount_put_conns(struct cifs_mount_ctx *mnt_ctx)
3206{
3207	int rc = 0;
 
 
3208
3209	if (mnt_ctx->tcon)
3210		cifs_put_tcon(mnt_ctx->tcon);
3211	else if (mnt_ctx->ses)
3212		cifs_put_smb_ses(mnt_ctx->ses);
3213	else if (mnt_ctx->server)
3214		cifs_put_tcp_session(mnt_ctx->server, 0);
3215	mnt_ctx->cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3216	free_xid(mnt_ctx->xid);
3217}
3218
3219int cifs_mount_get_session(struct cifs_mount_ctx *mnt_ctx)
3220{
3221	struct TCP_Server_Info *server = NULL;
3222	struct smb3_fs_context *ctx;
3223	struct cifs_ses *ses = NULL;
3224	unsigned int xid;
3225	int rc = 0;
3226
3227	xid = get_xid();
 
 
 
 
 
 
 
 
 
 
3228
3229	if (WARN_ON_ONCE(!mnt_ctx || !mnt_ctx->fs_ctx)) {
3230		rc = -EINVAL;
3231		goto out;
3232	}
3233	ctx = mnt_ctx->fs_ctx;
 
 
 
 
 
 
 
 
 
3234
3235	/* get a reference to a tcp session */
3236	server = cifs_get_tcp_session(ctx, NULL);
3237	if (IS_ERR(server)) {
3238		rc = PTR_ERR(server);
3239		server = NULL;
3240		goto out;
3241	}
3242
3243	/* get a reference to a SMB session */
3244	ses = cifs_get_smb_ses(server, ctx);
3245	if (IS_ERR(ses)) {
3246		rc = PTR_ERR(ses);
3247		ses = NULL;
3248		goto out;
3249	}
 
 
 
3250
3251	if ((ctx->persistent == true) && (!(ses->server->capabilities &
3252					    SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
3253		cifs_server_dbg(VFS, "persistent handles not supported by server\n");
3254		rc = -EOPNOTSUPP;
3255	}
3256
3257out:
3258	mnt_ctx->xid = xid;
3259	mnt_ctx->server = server;
3260	mnt_ctx->ses = ses;
3261	mnt_ctx->tcon = NULL;
3262
3263	return rc;
3264}
3265
3266int cifs_mount_get_tcon(struct cifs_mount_ctx *mnt_ctx)
 
3267{
3268	struct TCP_Server_Info *server;
3269	struct cifs_sb_info *cifs_sb;
3270	struct smb3_fs_context *ctx;
3271	struct cifs_tcon *tcon = NULL;
3272	int rc = 0;
3273
3274	if (WARN_ON_ONCE(!mnt_ctx || !mnt_ctx->server || !mnt_ctx->ses || !mnt_ctx->fs_ctx ||
3275			 !mnt_ctx->cifs_sb)) {
3276		rc = -EINVAL;
3277		goto out;
3278	}
3279	server = mnt_ctx->server;
3280	ctx = mnt_ctx->fs_ctx;
3281	cifs_sb = mnt_ctx->cifs_sb;
3282
3283	/* search for existing tcon to this server share */
3284	tcon = cifs_get_tcon(mnt_ctx->ses, ctx);
3285	if (IS_ERR(tcon)) {
3286		rc = PTR_ERR(tcon);
3287		tcon = NULL;
3288		goto out;
3289	}
3290
3291	/* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
3292	if (tcon->posix_extensions)
3293		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
3294
3295#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3296	/* tell server which Unix caps we support */
3297	if (cap_unix(tcon->ses)) {
3298		/*
3299		 * reset of caps checks mount to see if unix extensions disabled
3300		 * for just this mount.
3301		 */
3302		reset_cifs_unix_caps(mnt_ctx->xid, tcon, cifs_sb, ctx);
3303		spin_lock(&tcon->ses->server->srv_lock);
3304		if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3305		    (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3306		     CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3307			spin_unlock(&tcon->ses->server->srv_lock);
3308			rc = -EACCES;
3309			goto out;
3310		}
3311		spin_unlock(&tcon->ses->server->srv_lock);
3312	} else
3313#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3314		tcon->unix_ext = 0; /* server does not support them */
3315
3316	/* do not care if a following call succeed - informational */
3317	if (!tcon->pipe && server->ops->qfs_tcon) {
3318		server->ops->qfs_tcon(mnt_ctx->xid, tcon, cifs_sb);
3319		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
3320			if (tcon->fsDevInfo.DeviceCharacteristics &
3321			    cpu_to_le32(FILE_READ_ONLY_DEVICE))
3322				cifs_dbg(VFS, "mounted to read only share\n");
3323			else if ((cifs_sb->mnt_cifs_flags &
3324				  CIFS_MOUNT_RW_CACHE) == 0)
3325				cifs_dbg(VFS, "read only mount of RW share\n");
3326			/* no need to log a RW mount of a typical RW share */
3327		}
3328	}
3329
3330	/*
3331	 * Clamp the rsize/wsize mount arguments if they are too big for the server
3332	 * and set the rsize/wsize to the negotiated values if not passed in by
3333	 * the user on mount
 
 
 
 
 
 
 
3334	 */
3335	if ((cifs_sb->ctx->wsize == 0) ||
3336	    (cifs_sb->ctx->wsize > server->ops->negotiate_wsize(tcon, ctx)))
3337		cifs_sb->ctx->wsize = server->ops->negotiate_wsize(tcon, ctx);
3338	if ((cifs_sb->ctx->rsize == 0) ||
3339	    (cifs_sb->ctx->rsize > server->ops->negotiate_rsize(tcon, ctx)))
3340		cifs_sb->ctx->rsize = server->ops->negotiate_rsize(tcon, ctx);
 
 
3341
3342	/*
3343	 * The cookie is initialized from volume info returned above.
3344	 * Inside cifs_fscache_get_super_cookie it checks
3345	 * that we do not get super cookie twice.
3346	 */
3347	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
3348		cifs_fscache_get_super_cookie(tcon);
3349
3350out:
3351	mnt_ctx->tcon = tcon;
3352	return rc;
 
 
 
 
3353}
3354
3355static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
3356			     struct cifs_tcon *tcon)
 
3357{
3358	struct tcon_link *tlink;
 
3359
3360	/* hang the tcon off of the superblock */
3361	tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3362	if (tlink == NULL)
3363		return -ENOMEM;
3364
3365	tlink->tl_uid = ses->linux_uid;
3366	tlink->tl_tcon = tcon;
3367	tlink->tl_time = jiffies;
3368	set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3369	set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3370
3371	cifs_sb->master_tlink = tlink;
3372	spin_lock(&cifs_sb->tlink_tree_lock);
3373	tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3374	spin_unlock(&cifs_sb->tlink_tree_lock);
 
 
3375
3376	queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3377				TLINK_IDLE_EXPIRE);
3378	return 0;
 
 
 
 
 
 
 
 
3379}
3380
3381static int
3382cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3383					unsigned int xid,
3384					struct cifs_tcon *tcon,
3385					struct cifs_sb_info *cifs_sb,
3386					char *full_path,
3387					int added_treename)
3388{
3389	int rc;
3390	char *s;
3391	char sep, tmp;
3392	int skip = added_treename ? 1 : 0;
3393
3394	sep = CIFS_DIR_SEP(cifs_sb);
3395	s = full_path;
3396
3397	rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3398	while (rc == 0) {
3399		/* skip separators */
3400		while (*s == sep)
3401			s++;
3402		if (!*s)
3403			break;
3404		/* next separator */
3405		while (*s && *s != sep)
3406			s++;
3407		/*
3408		 * if the treename is added, we then have to skip the first
3409		 * part within the separators
3410		 */
3411		if (skip) {
3412			skip = 0;
3413			continue;
3414		}
3415		/*
3416		 * temporarily null-terminate the path at the end of
3417		 * the current component
3418		 */
3419		tmp = *s;
3420		*s = 0;
3421		rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3422						     full_path);
3423		*s = tmp;
3424	}
3425	return rc;
 
 
 
 
3426}
3427
3428/*
3429 * Check if path is remote (i.e. a DFS share).
 
 
 
 
3430 *
3431 * Return -EREMOTE if it is, otherwise 0 or -errno.
 
3432 */
3433int cifs_is_path_remote(struct cifs_mount_ctx *mnt_ctx)
 
 
 
3434{
3435	int rc;
3436	struct cifs_sb_info *cifs_sb = mnt_ctx->cifs_sb;
3437	struct TCP_Server_Info *server = mnt_ctx->server;
3438	unsigned int xid = mnt_ctx->xid;
3439	struct cifs_tcon *tcon = mnt_ctx->tcon;
3440	struct smb3_fs_context *ctx = mnt_ctx->fs_ctx;
3441	char *full_path;
3442
3443	if (!server->ops->is_path_accessible)
3444		return -EOPNOTSUPP;
 
3445
3446	/*
3447	 * cifs_build_path_to_root works only when we have a valid tcon
3448	 */
3449	full_path = cifs_build_path_to_root(ctx, cifs_sb, tcon,
3450					    tcon->Flags & SMB_SHARE_IS_IN_DFS);
3451	if (full_path == NULL)
3452		return -ENOMEM;
3453
3454	cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
 
 
3455
3456	rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3457					     full_path);
3458	if (rc != 0 && rc != -EREMOTE)
3459		goto out;
 
 
3460
3461	if (rc != -EREMOTE) {
3462		rc = cifs_are_all_path_components_accessible(server, xid, tcon,
3463			cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
3464		if (rc != 0) {
3465			cifs_server_dbg(VFS, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3466			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3467			rc = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3468		}
3469	}
3470
3471out:
3472	kfree(full_path);
3473	return rc;
3474}
3475
3476#ifdef CONFIG_CIFS_DFS_UPCALL
3477int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3478{
3479	struct cifs_mount_ctx mnt_ctx = { .cifs_sb = cifs_sb, .fs_ctx = ctx, };
3480	bool isdfs;
3481	int rc;
 
 
 
 
 
 
 
 
 
3482
3483	uuid_gen(&mnt_ctx.mount_id);
3484	rc = dfs_mount_share(&mnt_ctx, &isdfs);
3485	if (rc)
3486		goto error;
3487	if (!isdfs)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3488		goto out;
 
3489
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3490	/*
3491	 * After reconnecting to a different server, unique ids won't match anymore, so we disable
3492	 * serverino. This prevents dentry revalidation to think the dentry are stale (ESTALE).
3493	 */
3494	cifs_autodisable_serverino(cifs_sb);
3495	/*
3496	 * Force the use of prefix path to support failover on DFS paths that resolve to targets
3497	 * that have different prefix paths.
3498	 */
3499	cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3500	kfree(cifs_sb->prepath);
3501	cifs_sb->prepath = ctx->prepath;
3502	ctx->prepath = NULL;
3503	uuid_copy(&cifs_sb->dfs_mount_id, &mnt_ctx.mount_id);
 
 
 
 
3504
3505out:
3506	cifs_try_adding_channels(cifs_sb, mnt_ctx.ses);
3507	rc = mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
3508	if (rc)
3509		goto error;
 
 
 
 
 
 
 
 
 
 
3510
3511	free_xid(mnt_ctx.xid);
3512	return rc;
 
 
 
 
 
 
 
 
 
 
 
3513
3514error:
3515	dfs_cache_put_refsrv_sessions(&mnt_ctx.mount_id);
3516	kfree(mnt_ctx.origin_fullpath);
3517	kfree(mnt_ctx.leaf_fullpath);
3518	cifs_mount_put_conns(&mnt_ctx);
3519	return rc;
3520}
3521#else
3522int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3523{
3524	int rc = 0;
3525	struct cifs_mount_ctx mnt_ctx = { .cifs_sb = cifs_sb, .fs_ctx = ctx, };
3526
3527	rc = cifs_mount_get_session(&mnt_ctx);
3528	if (rc)
3529		goto error;
 
 
 
 
 
 
3530
3531	rc = cifs_mount_get_tcon(&mnt_ctx);
3532	if (rc)
3533		goto error;
3534
3535	rc = cifs_is_path_remote(&mnt_ctx);
3536	if (rc == -EREMOTE)
3537		rc = -EOPNOTSUPP;
3538	if (rc)
3539		goto error;
 
3540
3541	rc = mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
3542	if (rc)
3543		goto error;
 
 
3544
3545	free_xid(mnt_ctx.xid);
3546	return rc;
 
 
3547
3548error:
3549	cifs_mount_put_conns(&mnt_ctx);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3550	return rc;
3551}
3552#endif
3553
3554/*
3555 * Issue a TREE_CONNECT request.
 
3556 */
3557int
3558CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3559	 const char *tree, struct cifs_tcon *tcon,
3560	 const struct nls_table *nls_codepage)
3561{
3562	struct smb_hdr *smb_buffer;
3563	struct smb_hdr *smb_buffer_response;
3564	TCONX_REQ *pSMB;
3565	TCONX_RSP *pSMBr;
3566	unsigned char *bcc_ptr;
3567	int rc = 0;
3568	int length;
3569	__u16 bytes_left, count;
3570
3571	if (ses == NULL)
3572		return -EIO;
3573
3574	smb_buffer = cifs_buf_get();
3575	if (smb_buffer == NULL)
3576		return -ENOMEM;
3577
3578	smb_buffer_response = smb_buffer;
3579
3580	header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3581			NULL /*no tid */ , 4 /*wct */ );
3582
3583	smb_buffer->Mid = get_next_mid(ses->server);
3584	smb_buffer->Uid = ses->Suid;
3585	pSMB = (TCONX_REQ *) smb_buffer;
3586	pSMBr = (TCONX_RSP *) smb_buffer_response;
3587
3588	pSMB->AndXCommand = 0xFF;
3589	pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3590	bcc_ptr = &pSMB->Password[0];
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3591
3592	pSMB->PasswordLength = cpu_to_le16(1);	/* minimum */
3593	*bcc_ptr = 0; /* password is null byte */
3594	bcc_ptr++;              /* skip password */
3595	/* already aligned so no need to do it below */
 
 
 
3596
3597	if (ses->server->sign)
 
3598		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3599
3600	if (ses->capabilities & CAP_STATUS32) {
3601		smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3602	}
3603	if (ses->capabilities & CAP_DFS) {
3604		smb_buffer->Flags2 |= SMBFLG2_DFS;
3605	}
3606	if (ses->capabilities & CAP_UNICODE) {
3607		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3608		length =
3609		    cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3610			6 /* max utf8 char length in bytes */ *
3611			(/* server len*/ + 256 /* share len */), nls_codepage);
3612		bcc_ptr += 2 * length;	/* convert num 16 bit words to bytes */
3613		bcc_ptr += 2;	/* skip trailing null */
3614	} else {		/* ASCII */
3615		strcpy(bcc_ptr, tree);
3616		bcc_ptr += strlen(tree) + 1;
3617	}
3618	strcpy(bcc_ptr, "?????");
3619	bcc_ptr += strlen("?????");
3620	bcc_ptr += 1;
3621	count = bcc_ptr - &pSMB->Password[0];
3622	be32_add_cpu(&pSMB->hdr.smb_buf_length, count);
 
3623	pSMB->ByteCount = cpu_to_le16(count);
3624
3625	rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3626			 0);
3627
3628	/* above now done in SendReceive */
3629	if (rc == 0) {
3630		bool is_unicode;
3631
 
 
3632		tcon->tid = smb_buffer_response->Tid;
3633		bcc_ptr = pByteArea(smb_buffer_response);
3634		bytes_left = get_bcc(smb_buffer_response);
3635		length = strnlen(bcc_ptr, bytes_left - 2);
3636		if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3637			is_unicode = true;
3638		else
3639			is_unicode = false;
3640
3641
3642		/* skip service field (NB: this field is always ASCII) */
3643		if (length == 3) {
3644			if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3645			    (bcc_ptr[2] == 'C')) {
3646				cifs_dbg(FYI, "IPC connection\n");
3647				tcon->ipc = true;
3648				tcon->pipe = true;
3649			}
3650		} else if (length == 2) {
3651			if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3652				/* the most common case */
3653				cifs_dbg(FYI, "disk share connection\n");
3654			}
3655		}
3656		bcc_ptr += length + 1;
3657		bytes_left -= (length + 1);
3658		strscpy(tcon->tree_name, tree, sizeof(tcon->tree_name));
3659
3660		/* mostly informational -- no need to fail on error here */
3661		kfree(tcon->nativeFileSystem);
3662		tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3663						      bytes_left, is_unicode,
3664						      nls_codepage);
3665
3666		cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3667
3668		if ((smb_buffer_response->WordCount == 3) ||
3669			 (smb_buffer_response->WordCount == 7))
3670			/* field is in same location */
3671			tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3672		else
3673			tcon->Flags = 0;
3674		cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
 
 
 
3675	}
3676
3677	cifs_buf_release(smb_buffer);
3678	return rc;
3679}
3680
3681static void delayed_free(struct rcu_head *p)
3682{
3683	struct cifs_sb_info *cifs_sb = container_of(p, struct cifs_sb_info, rcu);
3684
3685	unload_nls(cifs_sb->local_nls);
3686	smb3_cleanup_fs_context(cifs_sb->ctx);
3687	kfree(cifs_sb);
3688}
3689
3690void
3691cifs_umount(struct cifs_sb_info *cifs_sb)
3692{
3693	struct rb_root *root = &cifs_sb->tlink_tree;
3694	struct rb_node *node;
3695	struct tcon_link *tlink;
3696
3697	cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3698
3699	spin_lock(&cifs_sb->tlink_tree_lock);
3700	while ((node = rb_first(root))) {
3701		tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3702		cifs_get_tlink(tlink);
3703		clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3704		rb_erase(node, root);
3705
3706		spin_unlock(&cifs_sb->tlink_tree_lock);
3707		cifs_put_tlink(tlink);
3708		spin_lock(&cifs_sb->tlink_tree_lock);
3709	}
3710	spin_unlock(&cifs_sb->tlink_tree_lock);
3711
3712	kfree(cifs_sb->prepath);
3713#ifdef CONFIG_CIFS_DFS_UPCALL
3714	dfs_cache_put_refsrv_sessions(&cifs_sb->dfs_mount_id);
3715#endif
3716	call_rcu(&cifs_sb->rcu, delayed_free);
3717}
3718
3719int
3720cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses,
3721			struct TCP_Server_Info *server)
3722{
3723	int rc = 0;
3724
3725	if (!server->ops->need_neg || !server->ops->negotiate)
3726		return -ENOSYS;
3727
3728	/* only send once per connect */
3729	spin_lock(&server->srv_lock);
3730	if (!server->ops->need_neg(server) ||
3731	    server->tcpStatus != CifsNeedNegotiate) {
3732		spin_unlock(&server->srv_lock);
3733		return 0;
3734	}
3735	server->tcpStatus = CifsInNegotiate;
3736	spin_unlock(&server->srv_lock);
3737
3738	rc = server->ops->negotiate(xid, ses, server);
 
 
 
 
 
 
 
 
3739	if (rc == 0) {
3740		spin_lock(&server->srv_lock);
3741		if (server->tcpStatus == CifsInNegotiate)
3742			server->tcpStatus = CifsGood;
3743		else
3744			rc = -EHOSTDOWN;
3745		spin_unlock(&server->srv_lock);
3746	} else {
3747		spin_lock(&server->srv_lock);
3748		if (server->tcpStatus == CifsInNegotiate)
3749			server->tcpStatus = CifsNeedNegotiate;
3750		spin_unlock(&server->srv_lock);
3751	}
3752
3753	return rc;
3754}
3755
3756int
3757cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3758		   struct TCP_Server_Info *server,
3759		   struct nls_table *nls_info)
3760{
3761	int rc = -ENOSYS;
3762	struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3763	struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3764	bool is_binding = false;
3765
3766	spin_lock(&ses->ses_lock);
3767	if (server->dstaddr.ss_family == AF_INET6)
3768		scnprintf(ses->ip_addr, sizeof(ses->ip_addr), "%pI6", &addr6->sin6_addr);
3769	else
3770		scnprintf(ses->ip_addr, sizeof(ses->ip_addr), "%pI4", &addr->sin_addr);
3771
3772	if (ses->ses_status != SES_GOOD &&
3773	    ses->ses_status != SES_NEW &&
3774	    ses->ses_status != SES_NEED_RECON) {
3775		spin_unlock(&ses->ses_lock);
3776		return 0;
3777	}
3778
3779	/* only send once per connect */
3780	spin_lock(&ses->chan_lock);
3781	if (CIFS_ALL_CHANS_GOOD(ses) ||
3782	    cifs_chan_in_reconnect(ses, server)) {
3783		spin_unlock(&ses->chan_lock);
3784		spin_unlock(&ses->ses_lock);
3785		return 0;
3786	}
3787	is_binding = !CIFS_ALL_CHANS_NEED_RECONNECT(ses);
3788	cifs_chan_set_in_reconnect(ses, server);
3789	spin_unlock(&ses->chan_lock);
3790
3791	if (!is_binding)
3792		ses->ses_status = SES_IN_SETUP;
3793	spin_unlock(&ses->ses_lock);
3794
3795	if (!is_binding) {
3796		ses->capabilities = server->capabilities;
3797		if (!linuxExtEnabled)
3798			ses->capabilities &= (~server->vals->cap_unix);
3799
3800		if (ses->auth_key.response) {
3801			cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
3802				 ses->auth_key.response);
3803			kfree_sensitive(ses->auth_key.response);
3804			ses->auth_key.response = NULL;
3805			ses->auth_key.len = 0;
3806		}
3807	}
3808
3809	cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3810		 server->sec_mode, server->capabilities, server->timeAdj);
3811
3812	if (server->ops->sess_setup)
3813		rc = server->ops->sess_setup(xid, ses, server, nls_info);
3814
3815	if (rc) {
3816		cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3817		spin_lock(&ses->ses_lock);
3818		if (ses->ses_status == SES_IN_SETUP)
3819			ses->ses_status = SES_NEED_RECON;
3820		spin_lock(&ses->chan_lock);
3821		cifs_chan_clear_in_reconnect(ses, server);
3822		spin_unlock(&ses->chan_lock);
3823		spin_unlock(&ses->ses_lock);
3824	} else {
3825		spin_lock(&ses->ses_lock);
3826		if (ses->ses_status == SES_IN_SETUP)
3827			ses->ses_status = SES_GOOD;
3828		spin_lock(&ses->chan_lock);
3829		cifs_chan_clear_in_reconnect(ses, server);
3830		cifs_chan_clear_need_reconnect(ses, server);
3831		spin_unlock(&ses->chan_lock);
3832		spin_unlock(&ses->ses_lock);
 
 
 
 
 
 
 
3833	}
3834
 
 
 
 
 
 
3835	return rc;
3836}
3837
3838static int
3839cifs_set_vol_auth(struct smb3_fs_context *ctx, struct cifs_ses *ses)
3840{
3841	ctx->sectype = ses->sectype;
3842
3843	/* krb5 is special, since we don't need username or pw */
3844	if (ctx->sectype == Kerberos)
3845		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
3846
3847	return cifs_set_cifscreds(ctx, ses);
3848}
3849
3850static struct cifs_tcon *
3851cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3852{
3853	int rc;
3854	struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3855	struct cifs_ses *ses;
3856	struct cifs_tcon *tcon = NULL;
3857	struct smb3_fs_context *ctx;
3858
3859	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
3860	if (ctx == NULL)
3861		return ERR_PTR(-ENOMEM);
3862
3863	ctx->local_nls = cifs_sb->local_nls;
3864	ctx->linux_uid = fsuid;
3865	ctx->cred_uid = fsuid;
3866	ctx->UNC = master_tcon->tree_name;
3867	ctx->retry = master_tcon->retry;
3868	ctx->nocase = master_tcon->nocase;
3869	ctx->nohandlecache = master_tcon->nohandlecache;
3870	ctx->local_lease = master_tcon->local_lease;
3871	ctx->no_lease = master_tcon->no_lease;
3872	ctx->resilient = master_tcon->use_resilient;
3873	ctx->persistent = master_tcon->use_persistent;
3874	ctx->handle_timeout = master_tcon->handle_timeout;
3875	ctx->no_linux_ext = !master_tcon->unix_ext;
3876	ctx->linux_ext = master_tcon->posix_extensions;
3877	ctx->sectype = master_tcon->ses->sectype;
3878	ctx->sign = master_tcon->ses->sign;
3879	ctx->seal = master_tcon->seal;
3880	ctx->witness = master_tcon->use_witness;
3881
3882	rc = cifs_set_vol_auth(ctx, master_tcon->ses);
3883	if (rc) {
3884		tcon = ERR_PTR(rc);
3885		goto out;
3886	}
3887
3888	/* get a reference for the same TCP session */
3889	spin_lock(&cifs_tcp_ses_lock);
3890	++master_tcon->ses->server->srv_count;
3891	spin_unlock(&cifs_tcp_ses_lock);
3892
3893	ses = cifs_get_smb_ses(master_tcon->ses->server, ctx);
3894	if (IS_ERR(ses)) {
3895		tcon = (struct cifs_tcon *)ses;
3896		cifs_put_tcp_session(master_tcon->ses->server, 0);
3897		goto out;
3898	}
3899
3900	tcon = cifs_get_tcon(ses, ctx);
3901	if (IS_ERR(tcon)) {
3902		cifs_put_smb_ses(ses);
3903		goto out;
3904	}
3905
3906#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
3907	if (cap_unix(ses))
3908		reset_cifs_unix_caps(0, tcon, NULL, ctx);
3909#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
3910
3911out:
3912	kfree(ctx->username);
3913	kfree_sensitive(ctx->password);
3914	kfree(ctx);
3915
3916	return tcon;
3917}
3918
3919struct cifs_tcon *
3920cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3921{
3922	return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3923}
3924
 
 
 
 
 
 
 
3925/* find and return a tlink with given uid */
3926static struct tcon_link *
3927tlink_rb_search(struct rb_root *root, kuid_t uid)
3928{
3929	struct rb_node *node = root->rb_node;
3930	struct tcon_link *tlink;
3931
3932	while (node) {
3933		tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3934
3935		if (uid_gt(tlink->tl_uid, uid))
3936			node = node->rb_left;
3937		else if (uid_lt(tlink->tl_uid, uid))
3938			node = node->rb_right;
3939		else
3940			return tlink;
3941	}
3942	return NULL;
3943}
3944
3945/* insert a tcon_link into the tree */
3946static void
3947tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3948{
3949	struct rb_node **new = &(root->rb_node), *parent = NULL;
3950	struct tcon_link *tlink;
3951
3952	while (*new) {
3953		tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3954		parent = *new;
3955
3956		if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
3957			new = &((*new)->rb_left);
3958		else
3959			new = &((*new)->rb_right);
3960	}
3961
3962	rb_link_node(&new_tlink->tl_rbnode, parent, new);
3963	rb_insert_color(&new_tlink->tl_rbnode, root);
3964}
3965
3966/*
3967 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3968 * current task.
3969 *
3970 * If the superblock doesn't refer to a multiuser mount, then just return
3971 * the master tcon for the mount.
3972 *
3973 * First, search the rbtree for an existing tcon for this fsuid. If one
3974 * exists, then check to see if it's pending construction. If it is then wait
3975 * for construction to complete. Once it's no longer pending, check to see if
3976 * it failed and either return an error or retry construction, depending on
3977 * the timeout.
3978 *
3979 * If one doesn't exist then insert a new tcon_link struct into the tree and
3980 * try to construct a new one.
3981 */
3982struct tcon_link *
3983cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3984{
3985	int ret;
3986	kuid_t fsuid = current_fsuid();
3987	struct tcon_link *tlink, *newtlink;
3988
3989	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3990		return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3991
3992	spin_lock(&cifs_sb->tlink_tree_lock);
3993	tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3994	if (tlink)
3995		cifs_get_tlink(tlink);
3996	spin_unlock(&cifs_sb->tlink_tree_lock);
3997
3998	if (tlink == NULL) {
3999		newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4000		if (newtlink == NULL)
4001			return ERR_PTR(-ENOMEM);
4002		newtlink->tl_uid = fsuid;
4003		newtlink->tl_tcon = ERR_PTR(-EACCES);
4004		set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4005		set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4006		cifs_get_tlink(newtlink);
4007
4008		spin_lock(&cifs_sb->tlink_tree_lock);
4009		/* was one inserted after previous search? */
4010		tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4011		if (tlink) {
4012			cifs_get_tlink(tlink);
4013			spin_unlock(&cifs_sb->tlink_tree_lock);
4014			kfree(newtlink);
4015			goto wait_for_construction;
4016		}
4017		tlink = newtlink;
4018		tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4019		spin_unlock(&cifs_sb->tlink_tree_lock);
4020	} else {
4021wait_for_construction:
4022		ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
 
4023				  TASK_INTERRUPTIBLE);
4024		if (ret) {
4025			cifs_put_tlink(tlink);
4026			return ERR_PTR(-ERESTARTSYS);
4027		}
4028
4029		/* if it's good, return it */
4030		if (!IS_ERR(tlink->tl_tcon))
4031			return tlink;
4032
4033		/* return error if we tried this already recently */
4034		if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4035			cifs_put_tlink(tlink);
4036			return ERR_PTR(-EACCES);
4037		}
4038
4039		if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4040			goto wait_for_construction;
4041	}
4042
4043	tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4044	clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4045	wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4046
4047	if (IS_ERR(tlink->tl_tcon)) {
4048		cifs_put_tlink(tlink);
4049		return ERR_PTR(-EACCES);
4050	}
4051
4052	return tlink;
4053}
4054
4055/*
4056 * periodic workqueue job that scans tcon_tree for a superblock and closes
4057 * out tcons.
4058 */
4059static void
4060cifs_prune_tlinks(struct work_struct *work)
4061{
4062	struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4063						    prune_tlinks.work);
4064	struct rb_root *root = &cifs_sb->tlink_tree;
4065	struct rb_node *node;
4066	struct rb_node *tmp;
4067	struct tcon_link *tlink;
4068
4069	/*
4070	 * Because we drop the spinlock in the loop in order to put the tlink
4071	 * it's not guarded against removal of links from the tree. The only
4072	 * places that remove entries from the tree are this function and
4073	 * umounts. Because this function is non-reentrant and is canceled
4074	 * before umount can proceed, this is safe.
4075	 */
4076	spin_lock(&cifs_sb->tlink_tree_lock);
4077	node = rb_first(root);
4078	while (node != NULL) {
4079		tmp = node;
4080		node = rb_next(tmp);
4081		tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4082
4083		if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4084		    atomic_read(&tlink->tl_count) != 0 ||
4085		    time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4086			continue;
4087
4088		cifs_get_tlink(tlink);
4089		clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4090		rb_erase(tmp, root);
4091
4092		spin_unlock(&cifs_sb->tlink_tree_lock);
4093		cifs_put_tlink(tlink);
4094		spin_lock(&cifs_sb->tlink_tree_lock);
4095	}
4096	spin_unlock(&cifs_sb->tlink_tree_lock);
4097
4098	queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4099				TLINK_IDLE_EXPIRE);
4100}
4101
4102#ifndef CONFIG_CIFS_DFS_UPCALL
4103int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4104{
4105	int rc;
4106	const struct smb_version_operations *ops = tcon->ses->server->ops;
4107
4108	/* only send once per connect */
4109	spin_lock(&tcon->tc_lock);
4110	if (tcon->ses->ses_status != SES_GOOD ||
4111	    (tcon->status != TID_NEW &&
4112	    tcon->status != TID_NEED_TCON)) {
4113		spin_unlock(&tcon->tc_lock);
4114		return 0;
4115	}
4116	tcon->status = TID_IN_TCON;
4117	spin_unlock(&tcon->tc_lock);
4118
4119	rc = ops->tree_connect(xid, tcon->ses, tcon->tree_name, tcon, nlsc);
4120	if (rc) {
4121		spin_lock(&tcon->tc_lock);
4122		if (tcon->status == TID_IN_TCON)
4123			tcon->status = TID_NEED_TCON;
4124		spin_unlock(&tcon->tc_lock);
4125	} else {
4126		spin_lock(&tcon->tc_lock);
4127		if (tcon->status == TID_IN_TCON)
4128			tcon->status = TID_GOOD;
4129		tcon->need_reconnect = false;
4130		spin_unlock(&tcon->tc_lock);
4131	}
4132
4133	return rc;
4134}
4135#endif
v3.5.6
 
   1/*
   2 *   fs/cifs/connect.c
   3 *
   4 *   Copyright (C) International Business Machines  Corp., 2002,2011
   5 *   Author(s): Steve French (sfrench@us.ibm.com)
   6 *
   7 *   This library is free software; you can redistribute it and/or modify
   8 *   it under the terms of the GNU Lesser General Public License as published
   9 *   by the Free Software Foundation; either version 2.1 of the License, or
  10 *   (at your option) any later version.
  11 *
  12 *   This library is distributed in the hope that it will be useful,
  13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15 *   the GNU Lesser General Public License for more details.
  16 *
  17 *   You should have received a copy of the GNU Lesser General Public License
  18 *   along with this library; if not, write to the Free Software
  19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20 */
  21#include <linux/fs.h>
  22#include <linux/net.h>
  23#include <linux/string.h>
 
 
  24#include <linux/list.h>
  25#include <linux/wait.h>
  26#include <linux/slab.h>
  27#include <linux/pagemap.h>
  28#include <linux/ctype.h>
  29#include <linux/utsname.h>
  30#include <linux/mempool.h>
  31#include <linux/delay.h>
  32#include <linux/completion.h>
  33#include <linux/kthread.h>
  34#include <linux/pagevec.h>
  35#include <linux/freezer.h>
  36#include <linux/namei.h>
  37#include <asm/uaccess.h>
 
  38#include <asm/processor.h>
  39#include <linux/inet.h>
  40#include <linux/module.h>
  41#include <keys/user-type.h>
  42#include <net/ipv6.h>
  43#include <linux/parser.h>
  44
  45#include "cifspdu.h"
  46#include "cifsglob.h"
  47#include "cifsproto.h"
  48#include "cifs_unicode.h"
  49#include "cifs_debug.h"
  50#include "cifs_fs_sb.h"
  51#include "ntlmssp.h"
  52#include "nterr.h"
  53#include "rfc1002pdu.h"
  54#include "fscache.h"
  55
  56#define CIFS_PORT 445
  57#define RFC1001_PORT 139
  58
  59/* SMB echo "timeout" -- FIXME: tunable? */
  60#define SMB_ECHO_INTERVAL (60 * HZ)
 
 
 
  61
  62extern mempool_t *cifs_req_poolp;
 
  63
  64/* FIXME: should these be tunable? */
  65#define TLINK_ERROR_EXPIRE	(1 * HZ)
  66#define TLINK_IDLE_EXPIRE	(600 * HZ)
  67
  68enum {
  69
  70	/* Mount options that take no arguments */
  71	Opt_user_xattr, Opt_nouser_xattr,
  72	Opt_forceuid, Opt_noforceuid,
  73	Opt_noblocksend, Opt_noautotune,
  74	Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
  75	Opt_mapchars, Opt_nomapchars, Opt_sfu,
  76	Opt_nosfu, Opt_nodfs, Opt_posixpaths,
  77	Opt_noposixpaths, Opt_nounix,
  78	Opt_nocase,
  79	Opt_brl, Opt_nobrl,
  80	Opt_forcemandatorylock, Opt_setuids,
  81	Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
  82	Opt_nohard, Opt_nosoft,
  83	Opt_nointr, Opt_intr,
  84	Opt_nostrictsync, Opt_strictsync,
  85	Opt_serverino, Opt_noserverino,
  86	Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
  87	Opt_acl, Opt_noacl, Opt_locallease,
  88	Opt_sign, Opt_seal, Opt_direct,
  89	Opt_strictcache, Opt_noac,
  90	Opt_fsc, Opt_mfsymlinks,
  91	Opt_multiuser, Opt_sloppy,
  92
  93	/* Mount options which take numeric value */
  94	Opt_backupuid, Opt_backupgid, Opt_uid,
  95	Opt_cruid, Opt_gid, Opt_file_mode,
  96	Opt_dirmode, Opt_port,
  97	Opt_rsize, Opt_wsize, Opt_actimeo,
  98
  99	/* Mount options which take string value */
 100	Opt_user, Opt_pass, Opt_ip,
 101	Opt_unc, Opt_domain,
 102	Opt_srcaddr, Opt_prefixpath,
 103	Opt_iocharset, Opt_sockopt,
 104	Opt_netbiosname, Opt_servern,
 105	Opt_ver, Opt_vers, Opt_sec, Opt_cache,
 106
 107	/* Mount options to be ignored */
 108	Opt_ignore,
 109
 110	/* Options which could be blank */
 111	Opt_blank_pass,
 112	Opt_blank_user,
 113	Opt_blank_ip,
 114
 115	Opt_err
 116};
 117
 118static const match_table_t cifs_mount_option_tokens = {
 119
 120	{ Opt_user_xattr, "user_xattr" },
 121	{ Opt_nouser_xattr, "nouser_xattr" },
 122	{ Opt_forceuid, "forceuid" },
 123	{ Opt_noforceuid, "noforceuid" },
 124	{ Opt_noblocksend, "noblocksend" },
 125	{ Opt_noautotune, "noautotune" },
 126	{ Opt_hard, "hard" },
 127	{ Opt_soft, "soft" },
 128	{ Opt_perm, "perm" },
 129	{ Opt_noperm, "noperm" },
 130	{ Opt_mapchars, "mapchars" },
 131	{ Opt_nomapchars, "nomapchars" },
 132	{ Opt_sfu, "sfu" },
 133	{ Opt_nosfu, "nosfu" },
 134	{ Opt_nodfs, "nodfs" },
 135	{ Opt_posixpaths, "posixpaths" },
 136	{ Opt_noposixpaths, "noposixpaths" },
 137	{ Opt_nounix, "nounix" },
 138	{ Opt_nounix, "nolinux" },
 139	{ Opt_nocase, "nocase" },
 140	{ Opt_nocase, "ignorecase" },
 141	{ Opt_brl, "brl" },
 142	{ Opt_nobrl, "nobrl" },
 143	{ Opt_nobrl, "nolock" },
 144	{ Opt_forcemandatorylock, "forcemandatorylock" },
 145	{ Opt_forcemandatorylock, "forcemand" },
 146	{ Opt_setuids, "setuids" },
 147	{ Opt_nosetuids, "nosetuids" },
 148	{ Opt_dynperm, "dynperm" },
 149	{ Opt_nodynperm, "nodynperm" },
 150	{ Opt_nohard, "nohard" },
 151	{ Opt_nosoft, "nosoft" },
 152	{ Opt_nointr, "nointr" },
 153	{ Opt_intr, "intr" },
 154	{ Opt_nostrictsync, "nostrictsync" },
 155	{ Opt_strictsync, "strictsync" },
 156	{ Opt_serverino, "serverino" },
 157	{ Opt_noserverino, "noserverino" },
 158	{ Opt_rwpidforward, "rwpidforward" },
 159	{ Opt_cifsacl, "cifsacl" },
 160	{ Opt_nocifsacl, "nocifsacl" },
 161	{ Opt_acl, "acl" },
 162	{ Opt_noacl, "noacl" },
 163	{ Opt_locallease, "locallease" },
 164	{ Opt_sign, "sign" },
 165	{ Opt_seal, "seal" },
 166	{ Opt_direct, "direct" },
 167	{ Opt_direct, "directio" },
 168	{ Opt_direct, "forcedirectio" },
 169	{ Opt_strictcache, "strictcache" },
 170	{ Opt_noac, "noac" },
 171	{ Opt_fsc, "fsc" },
 172	{ Opt_mfsymlinks, "mfsymlinks" },
 173	{ Opt_multiuser, "multiuser" },
 174	{ Opt_sloppy, "sloppy" },
 175
 176	{ Opt_backupuid, "backupuid=%s" },
 177	{ Opt_backupgid, "backupgid=%s" },
 178	{ Opt_uid, "uid=%s" },
 179	{ Opt_cruid, "cruid=%s" },
 180	{ Opt_gid, "gid=%s" },
 181	{ Opt_file_mode, "file_mode=%s" },
 182	{ Opt_dirmode, "dirmode=%s" },
 183	{ Opt_dirmode, "dir_mode=%s" },
 184	{ Opt_port, "port=%s" },
 185	{ Opt_rsize, "rsize=%s" },
 186	{ Opt_wsize, "wsize=%s" },
 187	{ Opt_actimeo, "actimeo=%s" },
 188
 189	{ Opt_blank_user, "user=" },
 190	{ Opt_blank_user, "username=" },
 191	{ Opt_user, "user=%s" },
 192	{ Opt_user, "username=%s" },
 193	{ Opt_blank_pass, "pass=" },
 194	{ Opt_pass, "pass=%s" },
 195	{ Opt_pass, "password=%s" },
 196	{ Opt_blank_ip, "ip=" },
 197	{ Opt_blank_ip, "addr=" },
 198	{ Opt_ip, "ip=%s" },
 199	{ Opt_ip, "addr=%s" },
 200	{ Opt_unc, "unc=%s" },
 201	{ Opt_unc, "target=%s" },
 202	{ Opt_unc, "path=%s" },
 203	{ Opt_domain, "dom=%s" },
 204	{ Opt_domain, "domain=%s" },
 205	{ Opt_domain, "workgroup=%s" },
 206	{ Opt_srcaddr, "srcaddr=%s" },
 207	{ Opt_prefixpath, "prefixpath=%s" },
 208	{ Opt_iocharset, "iocharset=%s" },
 209	{ Opt_sockopt, "sockopt=%s" },
 210	{ Opt_netbiosname, "netbiosname=%s" },
 211	{ Opt_servern, "servern=%s" },
 212	{ Opt_ver, "ver=%s" },
 213	{ Opt_vers, "vers=%s" },
 214	{ Opt_sec, "sec=%s" },
 215	{ Opt_cache, "cache=%s" },
 216
 217	{ Opt_ignore, "cred" },
 218	{ Opt_ignore, "credentials" },
 219	{ Opt_ignore, "cred=%s" },
 220	{ Opt_ignore, "credentials=%s" },
 221	{ Opt_ignore, "guest" },
 222	{ Opt_ignore, "rw" },
 223	{ Opt_ignore, "ro" },
 224	{ Opt_ignore, "suid" },
 225	{ Opt_ignore, "nosuid" },
 226	{ Opt_ignore, "exec" },
 227	{ Opt_ignore, "noexec" },
 228	{ Opt_ignore, "nodev" },
 229	{ Opt_ignore, "noauto" },
 230	{ Opt_ignore, "dev" },
 231	{ Opt_ignore, "mand" },
 232	{ Opt_ignore, "nomand" },
 233	{ Opt_ignore, "_netdev" },
 234
 235	{ Opt_err, NULL }
 236};
 237
 238enum {
 239	Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
 240	Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
 241	Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
 242	Opt_sec_ntlmv2i, Opt_sec_lanman,
 243	Opt_sec_none,
 244
 245	Opt_sec_err
 246};
 247
 248static const match_table_t cifs_secflavor_tokens = {
 249	{ Opt_sec_krb5, "krb5" },
 250	{ Opt_sec_krb5i, "krb5i" },
 251	{ Opt_sec_krb5p, "krb5p" },
 252	{ Opt_sec_ntlmsspi, "ntlmsspi" },
 253	{ Opt_sec_ntlmssp, "ntlmssp" },
 254	{ Opt_ntlm, "ntlm" },
 255	{ Opt_sec_ntlmi, "ntlmi" },
 256	{ Opt_sec_ntlmv2, "nontlm" },
 257	{ Opt_sec_ntlmv2, "ntlmv2" },
 258	{ Opt_sec_ntlmv2i, "ntlmv2i" },
 259	{ Opt_sec_lanman, "lanman" },
 260	{ Opt_sec_none, "none" },
 261
 262	{ Opt_sec_err, NULL }
 263};
 264
 265/* cache flavors */
 266enum {
 267	Opt_cache_loose,
 268	Opt_cache_strict,
 269	Opt_cache_none,
 270	Opt_cache_err
 271};
 272
 273static const match_table_t cifs_cacheflavor_tokens = {
 274	{ Opt_cache_loose, "loose" },
 275	{ Opt_cache_strict, "strict" },
 276	{ Opt_cache_none, "none" },
 277	{ Opt_cache_err, NULL }
 278};
 279
 280static const match_table_t cifs_smb_version_tokens = {
 281	{ Smb_1, SMB1_VERSION_STRING },
 282	{ Smb_21, SMB21_VERSION_STRING },
 283};
 284
 285static int ip_connect(struct TCP_Server_Info *server);
 286static int generic_ip_connect(struct TCP_Server_Info *server);
 287static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 288static void cifs_prune_tlinks(struct work_struct *work);
 289static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
 290					const char *devname);
 291
 292/*
 293 * cifs tcp session reconnection
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 294 *
 295 * mark tcp session as reconnecting so temporarily locked
 296 * mark all smb sessions as reconnecting for tcp session
 297 * reconnect tcp session
 298 * wake up waiters on reconnection? - (not needed currently)
 299 */
 300static int
 301cifs_reconnect(struct TCP_Server_Info *server)
 
 302{
 303	int rc = 0;
 304	struct list_head *tmp, *tmp2;
 305	struct cifs_ses *ses;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 306	struct cifs_tcon *tcon;
 307	struct mid_q_entry *mid_entry;
 308	struct list_head retry_list;
 309
 310	spin_lock(&GlobalMid_Lock);
 311	if (server->tcpStatus == CifsExiting) {
 312		/* the demux thread will exit normally
 313		next time through the loop */
 314		spin_unlock(&GlobalMid_Lock);
 315		return rc;
 316	} else
 317		server->tcpStatus = CifsNeedReconnect;
 318	spin_unlock(&GlobalMid_Lock);
 319	server->maxBuf = 0;
 320
 321	cFYI(1, "Reconnecting tcp session");
 322
 323	/* before reconnecting the tcp session, mark the smb session (uid)
 324		and the tid bad so they are not used until reconnected */
 325	cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
 326	spin_lock(&cifs_tcp_ses_lock);
 327	list_for_each(tmp, &server->smb_ses_list) {
 328		ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 329		ses->need_reconnect = true;
 330		ses->ipc_tid = 0;
 331		list_for_each(tmp2, &ses->tcon_list) {
 332			tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 333			tcon->need_reconnect = true;
 
 334		}
 
 
 
 
 
 
 
 335	}
 336	spin_unlock(&cifs_tcp_ses_lock);
 
 
 
 
 
 
 
 
 
 
 337
 338	/* do not want to be sending data on a socket we are freeing */
 339	cFYI(1, "%s: tearing down socket", __func__);
 340	mutex_lock(&server->srv_mutex);
 341	if (server->ssocket) {
 342		cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
 343			server->ssocket->flags);
 344		kernel_sock_shutdown(server->ssocket, SHUT_WR);
 345		cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
 346			server->ssocket->state,
 347			server->ssocket->flags);
 348		sock_release(server->ssocket);
 349		server->ssocket = NULL;
 350	}
 351	server->sequence_number = 0;
 352	server->session_estab = false;
 353	kfree(server->session_key.response);
 354	server->session_key.response = NULL;
 355	server->session_key.len = 0;
 356	server->lstrp = jiffies;
 357	mutex_unlock(&server->srv_mutex);
 358
 359	/* mark submitted MIDs for retry and issue callback */
 360	INIT_LIST_HEAD(&retry_list);
 361	cFYI(1, "%s: moving mids to private list", __func__);
 362	spin_lock(&GlobalMid_Lock);
 363	list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 364		mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 365		if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 366			mid_entry->mid_state = MID_RETRY_NEEDED;
 367		list_move(&mid_entry->qhead, &retry_list);
 368	}
 369	spin_unlock(&GlobalMid_Lock);
 370
 371	cFYI(1, "%s: issuing mid callbacks", __func__);
 372	list_for_each_safe(tmp, tmp2, &retry_list) {
 373		mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 374		list_del_init(&mid_entry->qhead);
 375		mid_entry->callback(mid_entry);
 376	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 377
 378	do {
 379		try_to_freeze();
 
 380
 381		/* we should try only the port we connected to before */
 382		rc = generic_ip_connect(server);
 
 
 
 
 
 
 
 
 383		if (rc) {
 384			cFYI(1, "reconnect error %d", rc);
 
 385			msleep(3000);
 386		} else {
 387			atomic_inc(&tcpSesReconnectCount);
 388			spin_lock(&GlobalMid_Lock);
 
 389			if (server->tcpStatus != CifsExiting)
 390				server->tcpStatus = CifsNeedNegotiate;
 391			spin_unlock(&GlobalMid_Lock);
 
 
 
 392		}
 393	} while (server->tcpStatus == CifsNeedReconnect);
 394
 
 
 
 
 
 
 395	return rc;
 396}
 397
 398/*
 399	return codes:
 400		0 	not a transact2, or all data present
 401		>0 	transact2 with that much data missing
 402		-EINVAL = invalid transact2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 403
 404 */
 405static int check2ndT2(char *buf)
 406{
 407	struct smb_hdr *pSMB = (struct smb_hdr *)buf;
 408	struct smb_t2_rsp *pSMBt;
 409	int remaining;
 410	__u16 total_data_size, data_in_this_rsp;
 411
 412	if (pSMB->Command != SMB_COM_TRANSACTION2)
 413		return 0;
 414
 415	/* check for plausible wct, bcc and t2 data and parm sizes */
 416	/* check for parm and data offset going beyond end of smb */
 417	if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
 418		cFYI(1, "invalid transact2 word count");
 419		return -EINVAL;
 
 
 
 
 
 
 
 420	}
 
 
 421
 422	pSMBt = (struct smb_t2_rsp *)pSMB;
 
 
 
 
 
 
 423
 424	total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 425	data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 
 
 
 
 
 
 
 
 
 
 426
 427	if (total_data_size == data_in_this_rsp)
 428		return 0;
 429	else if (total_data_size < data_in_this_rsp) {
 430		cFYI(1, "total data %d smaller than data in frame %d",
 431			total_data_size, data_in_this_rsp);
 432		return -EINVAL;
 433	}
 434
 435	remaining = total_data_size - data_in_this_rsp;
 
 
 
 
 
 436
 437	cFYI(1, "missing %d bytes from transact2, check next response",
 438		remaining);
 439	if (total_data_size > CIFSMaxBufSize) {
 440		cERROR(1, "TotalDataSize %d is over maximum buffer %d",
 441			total_data_size, CIFSMaxBufSize);
 442		return -EINVAL;
 443	}
 444	return remaining;
 445}
 446
 447static int coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
 448{
 449	struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
 450	struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)target_hdr;
 451	char *data_area_of_tgt;
 452	char *data_area_of_src;
 453	int remaining;
 454	unsigned int byte_count, total_in_tgt;
 455	__u16 tgt_total_cnt, src_total_cnt, total_in_src;
 456
 457	src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
 458	tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 459
 460	if (tgt_total_cnt != src_total_cnt)
 461		cFYI(1, "total data count of primary and secondary t2 differ "
 462			"source=%hu target=%hu", src_total_cnt, tgt_total_cnt);
 463
 464	total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 
 
 
 
 465
 466	remaining = tgt_total_cnt - total_in_tgt;
 
 
 467
 468	if (remaining < 0) {
 469		cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
 470			"total_in_tgt=%hu", tgt_total_cnt, total_in_tgt);
 471		return -EPROTO;
 
 
 472	}
 
 473
 474	if (remaining == 0) {
 475		/* nothing to do, ignore */
 476		cFYI(1, "no more data remains");
 477		return 0;
 478	}
 479
 480	total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
 481	if (remaining < total_in_src)
 482		cFYI(1, "transact2 2nd response contains too much data");
 483
 484	/* find end of first SMB data area */
 485	data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
 486				get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
 487
 488	/* validate target area */
 489	data_area_of_src = (char *)&pSMBs->hdr.Protocol +
 490				get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
 491
 492	data_area_of_tgt += total_in_tgt;
 493
 494	total_in_tgt += total_in_src;
 495	/* is the result too big for the field? */
 496	if (total_in_tgt > USHRT_MAX) {
 497		cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt);
 498		return -EPROTO;
 499	}
 500	put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
 501
 502	/* fix up the BCC */
 503	byte_count = get_bcc(target_hdr);
 504	byte_count += total_in_src;
 505	/* is the result too big for the field? */
 506	if (byte_count > USHRT_MAX) {
 507		cFYI(1, "coalesced BCC too large (%u)", byte_count);
 508		return -EPROTO;
 509	}
 510	put_bcc(byte_count, target_hdr);
 511
 512	byte_count = be32_to_cpu(target_hdr->smb_buf_length);
 513	byte_count += total_in_src;
 514	/* don't allow buffer to overflow */
 515	if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
 516		cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count);
 517		return -ENOBUFS;
 518	}
 519	target_hdr->smb_buf_length = cpu_to_be32(byte_count);
 520
 521	/* copy second buffer into end of first buffer */
 522	memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
 523
 524	if (remaining != total_in_src) {
 525		/* more responses to go */
 526		cFYI(1, "waiting for more secondary responses");
 527		return 1;
 528	}
 529
 530	/* we are done */
 531	cFYI(1, "found the last secondary response");
 532	return 0;
 533}
 
 534
 535static void
 536cifs_echo_request(struct work_struct *work)
 537{
 538	int rc;
 539	struct TCP_Server_Info *server = container_of(work,
 540					struct TCP_Server_Info, echo.work);
 541
 542	/*
 543	 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
 544	 * done, which is indicated by maxBuf != 0. Also, no need to ping if
 545	 * we got a response recently
 546	 */
 547	if (server->maxBuf == 0 ||
 548	    time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
 
 
 
 
 549		goto requeue_echo;
 550
 551	rc = CIFSSMBEcho(server);
 552	if (rc)
 553		cFYI(1, "Unable to send echo request to server: %s",
 554			server->hostname);
 
 
 
 555
 556requeue_echo:
 557	queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
 558}
 559
 560static bool
 561allocate_buffers(struct TCP_Server_Info *server)
 562{
 563	if (!server->bigbuf) {
 564		server->bigbuf = (char *)cifs_buf_get();
 565		if (!server->bigbuf) {
 566			cERROR(1, "No memory for large SMB response");
 567			msleep(3000);
 568			/* retry will check if exiting */
 569			return false;
 570		}
 571	} else if (server->large_buf) {
 572		/* we are reusing a dirty large buf, clear its start */
 573		memset(server->bigbuf, 0, HEADER_SIZE(server));
 574	}
 575
 576	if (!server->smallbuf) {
 577		server->smallbuf = (char *)cifs_small_buf_get();
 578		if (!server->smallbuf) {
 579			cERROR(1, "No memory for SMB response");
 580			msleep(1000);
 581			/* retry will check if exiting */
 582			return false;
 583		}
 584		/* beginning of smb buffer is cleared in our buf_get */
 585	} else {
 586		/* if existing small buf clear beginning */
 587		memset(server->smallbuf, 0, HEADER_SIZE(server));
 588	}
 589
 590	return true;
 591}
 592
 593static bool
 594server_unresponsive(struct TCP_Server_Info *server)
 595{
 596	/*
 597	 * We need to wait 2 echo intervals to make sure we handle such
 598	 * situations right:
 599	 * 1s  client sends a normal SMB request
 600	 * 2s  client gets a response
 601	 * 30s echo workqueue job pops, and decides we got a response recently
 602	 *     and don't need to send another
 603	 * ...
 604	 * 65s kernel_recvmsg times out, and we see that we haven't gotten
 605	 *     a response in >60s.
 606	 */
 607	if (server->tcpStatus == CifsGood &&
 608	    time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
 609		cERROR(1, "Server %s has not responded in %d seconds. "
 610			  "Reconnecting...", server->hostname,
 611			  (2 * SMB_ECHO_INTERVAL) / HZ);
 612		cifs_reconnect(server);
 613		wake_up(&server->response_q);
 
 
 614		return true;
 615	}
 
 616
 617	return false;
 618}
 619
 620/*
 621 * kvec_array_init - clone a kvec array, and advance into it
 622 * @new:	pointer to memory for cloned array
 623 * @iov:	pointer to original array
 624 * @nr_segs:	number of members in original array
 625 * @bytes:	number of bytes to advance into the cloned array
 626 *
 627 * This function will copy the array provided in iov to a section of memory
 628 * and advance the specified number of bytes into the new array. It returns
 629 * the number of segments in the new array. "new" must be at least as big as
 630 * the original iov array.
 631 */
 632static unsigned int
 633kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
 634		size_t bytes)
 635{
 636	size_t base = 0;
 637
 638	while (bytes || !iov->iov_len) {
 639		int copy = min(bytes, iov->iov_len);
 640
 641		bytes -= copy;
 642		base += copy;
 643		if (iov->iov_len == base) {
 644			iov++;
 645			nr_segs--;
 646			base = 0;
 647		}
 648	}
 649	memcpy(new, iov, sizeof(*iov) * nr_segs);
 650	new->iov_base += base;
 651	new->iov_len -= base;
 652	return nr_segs;
 653}
 654
 655static struct kvec *
 656get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
 657{
 658	struct kvec *new_iov;
 659
 660	if (server->iov && nr_segs <= server->nr_iov)
 661		return server->iov;
 662
 663	/* not big enough -- allocate a new one and release the old */
 664	new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
 665	if (new_iov) {
 666		kfree(server->iov);
 667		server->iov = new_iov;
 668		server->nr_iov = nr_segs;
 669	}
 670	return new_iov;
 671}
 672
 673int
 674cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
 675		       unsigned int nr_segs, unsigned int to_read)
 676{
 677	int length = 0;
 678	int total_read;
 679	unsigned int segs;
 680	struct msghdr smb_msg;
 681	struct kvec *iov;
 682
 683	iov = get_server_iovec(server, nr_segs);
 684	if (!iov)
 685		return -ENOMEM;
 686
 687	smb_msg.msg_control = NULL;
 688	smb_msg.msg_controllen = 0;
 
 
 
 689
 690	for (total_read = 0; to_read; total_read += length, to_read -= length) {
 691		try_to_freeze();
 
 
 
 
 692
 693		if (server_unresponsive(server)) {
 694			total_read = -EAGAIN;
 695			break;
 
 696		}
 697
 698		segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
 699
 700		length = kernel_recvmsg(server->ssocket, &smb_msg,
 701					iov, segs, to_read, 0);
 
 
 702
 703		if (server->tcpStatus == CifsExiting) {
 704			total_read = -ESHUTDOWN;
 705			break;
 706		} else if (server->tcpStatus == CifsNeedReconnect) {
 707			cifs_reconnect(server);
 708			total_read = -EAGAIN;
 709			break;
 710		} else if (length == -ERESTARTSYS ||
 711			   length == -EAGAIN ||
 712			   length == -EINTR) {
 713			/*
 714			 * Minimum sleep to prevent looping, allowing socket
 715			 * to clear and app threads to set tcpStatus
 716			 * CifsNeedReconnect if server hung.
 717			 */
 718			usleep_range(1000, 2000);
 719			length = 0;
 720			continue;
 721		} else if (length <= 0) {
 722			cFYI(1, "Received no data or error: expecting %d "
 723				"got %d", to_read, length);
 724			cifs_reconnect(server);
 725			total_read = -EAGAIN;
 726			break;
 727		}
 728	}
 729	return total_read;
 730}
 731
 732int
 733cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 734		      unsigned int to_read)
 735{
 736	struct kvec iov;
 
 
 
 
 
 737
 738	iov.iov_base = buf;
 739	iov.iov_len = to_read;
 
 
 
 
 
 
 
 
 
 740
 741	return cifs_readv_from_socket(server, &iov, 1, to_read);
 
 
 
 
 
 
 
 
 
 
 
 742}
 743
 744static bool
 745is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 746{
 747	/*
 748	 * The first byte big endian of the length field,
 749	 * is actually not part of the length but the type
 750	 * with the most common, zero, as regular data.
 751	 */
 752	switch (type) {
 753	case RFC1002_SESSION_MESSAGE:
 754		/* Regular SMB response */
 755		return true;
 756	case RFC1002_SESSION_KEEP_ALIVE:
 757		cFYI(1, "RFC 1002 session keep alive");
 758		break;
 759	case RFC1002_POSITIVE_SESSION_RESPONSE:
 760		cFYI(1, "RFC 1002 positive session response");
 761		break;
 762	case RFC1002_NEGATIVE_SESSION_RESPONSE:
 763		/*
 764		 * We get this from Windows 98 instead of an error on
 765		 * SMB negprot response.
 766		 */
 767		cFYI(1, "RFC 1002 negative session response");
 768		/* give server a second to clean up */
 769		msleep(1000);
 770		/*
 771		 * Always try 445 first on reconnect since we get NACK
 772		 * on some if we ever connected to port 139 (the NACK
 773		 * is since we do not begin with RFC1001 session
 774		 * initialize frame).
 775		 */
 776		cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 777		cifs_reconnect(server);
 778		wake_up(&server->response_q);
 779		break;
 780	default:
 781		cERROR(1, "RFC 1002 unknown response type 0x%x", type);
 782		cifs_reconnect(server);
 783	}
 784
 785	return false;
 786}
 787
 788void
 789dequeue_mid(struct mid_q_entry *mid, bool malformed)
 790{
 791#ifdef CONFIG_CIFS_STATS2
 792	mid->when_received = jiffies;
 793#endif
 794	spin_lock(&GlobalMid_Lock);
 795	if (!malformed)
 796		mid->mid_state = MID_RESPONSE_RECEIVED;
 797	else
 798		mid->mid_state = MID_RESPONSE_MALFORMED;
 799	list_del_init(&mid->qhead);
 800	spin_unlock(&GlobalMid_Lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 801}
 802
 803static void
 804handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 805	   char *buf, int malformed)
 806{
 807	if (malformed == 0 && check2ndT2(buf) > 0) {
 808		mid->multiRsp = true;
 809		if (mid->resp_buf) {
 810			/* merge response - fix up 1st*/
 811			malformed = coalesce_t2(buf, mid->resp_buf);
 812			if (malformed > 0)
 813				return;
 814
 815			/* All parts received or packet is malformed. */
 816			mid->multiEnd = true;
 817			return dequeue_mid(mid, malformed);
 818		}
 819		if (!server->large_buf) {
 820			/*FIXME: switch to already allocated largebuf?*/
 821			cERROR(1, "1st trans2 resp needs bigbuf");
 822		} else {
 823			/* Have first buffer */
 824			mid->resp_buf = buf;
 825			mid->large_buf = true;
 826			server->bigbuf = NULL;
 827		}
 828		return;
 829	}
 830	mid->resp_buf = buf;
 831	mid->large_buf = server->large_buf;
 832	/* Was previous buf put in mpx struct for multi-rsp? */
 833	if (!mid->multiRsp) {
 834		/* smb buffer will be freed by user thread */
 835		if (server->large_buf)
 836			server->bigbuf = NULL;
 837		else
 838			server->smallbuf = NULL;
 839	}
 840	dequeue_mid(mid, malformed);
 841}
 842
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 843static void clean_demultiplex_info(struct TCP_Server_Info *server)
 844{
 845	int length;
 846
 847	/* take it off the list, if it's not already */
 848	spin_lock(&cifs_tcp_ses_lock);
 849	list_del_init(&server->tcp_ses_list);
 850	spin_unlock(&cifs_tcp_ses_lock);
 
 
 
 851
 852	spin_lock(&GlobalMid_Lock);
 853	server->tcpStatus = CifsExiting;
 854	spin_unlock(&GlobalMid_Lock);
 855	wake_up_all(&server->response_q);
 856
 857	/* check if we have blocked requests that need to free */
 858	spin_lock(&server->req_lock);
 859	if (server->credits <= 0)
 860		server->credits = 1;
 861	spin_unlock(&server->req_lock);
 862	/*
 863	 * Although there should not be any requests blocked on this queue it
 864	 * can not hurt to be paranoid and try to wake up requests that may
 865	 * haven been blocked when more than 50 at time were on the wire to the
 866	 * same server - they now will see the session is in exit state and get
 867	 * out of SendReceive.
 868	 */
 869	wake_up_all(&server->request_q);
 870	/* give those requests time to exit */
 871	msleep(125);
 872
 
 873	if (server->ssocket) {
 874		sock_release(server->ssocket);
 875		server->ssocket = NULL;
 876	}
 877
 878	if (!list_empty(&server->pending_mid_q)) {
 879		struct list_head dispose_list;
 880		struct mid_q_entry *mid_entry;
 881		struct list_head *tmp, *tmp2;
 882
 883		INIT_LIST_HEAD(&dispose_list);
 884		spin_lock(&GlobalMid_Lock);
 885		list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 886			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 887			cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
 
 888			mid_entry->mid_state = MID_SHUTDOWN;
 889			list_move(&mid_entry->qhead, &dispose_list);
 
 890		}
 891		spin_unlock(&GlobalMid_Lock);
 892
 893		/* now walk dispose list and issue callbacks */
 894		list_for_each_safe(tmp, tmp2, &dispose_list) {
 895			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 896			cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
 897			list_del_init(&mid_entry->qhead);
 898			mid_entry->callback(mid_entry);
 
 899		}
 900		/* 1/8th of sec is more than enough time for them to exit */
 901		msleep(125);
 902	}
 903
 904	if (!list_empty(&server->pending_mid_q)) {
 905		/*
 906		 * mpx threads have not exited yet give them at least the smb
 907		 * send timeout time for long ops.
 908		 *
 909		 * Due to delays on oplock break requests, we need to wait at
 910		 * least 45 seconds before giving up on a request getting a
 911		 * response and going ahead and killing cifsd.
 912		 */
 913		cFYI(1, "Wait for exit from demultiplex thread");
 914		msleep(46000);
 915		/*
 916		 * If threads still have not exited they are probably never
 917		 * coming home not much else we can do but free the memory.
 918		 */
 919	}
 920
 921	kfree(server->hostname);
 922	kfree(server->iov);
 
 
 923	kfree(server);
 924
 925	length = atomic_dec_return(&tcpSesAllocCount);
 926	if (length > 0)
 927		mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 928				GFP_KERNEL);
 929}
 930
 931static int
 932standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 933{
 934	int length;
 935	char *buf = server->smallbuf;
 936	unsigned int pdu_length = get_rfc1002_length(buf);
 937
 938	/* make sure this will fit in a large buffer */
 939	if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
 940		cERROR(1, "SMB response too long (%u bytes)",
 941			pdu_length);
 942		cifs_reconnect(server);
 943		wake_up(&server->response_q);
 944		return -EAGAIN;
 945	}
 946
 947	/* switch to large buffer if too big for a small one */
 948	if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 949		server->large_buf = true;
 950		memcpy(server->bigbuf, buf, server->total_read);
 951		buf = server->bigbuf;
 952	}
 953
 954	/* now read the rest */
 955	length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
 956				pdu_length - HEADER_SIZE(server) + 1 + 4);
 
 957	if (length < 0)
 958		return length;
 959	server->total_read += length;
 960
 961	dump_smb(buf, server->total_read);
 962
 
 
 
 
 
 
 
 
 
 963	/*
 964	 * We know that we received enough to get to the MID as we
 965	 * checked the pdu_length earlier. Now check to see
 966	 * if the rest of the header is OK. We borrow the length
 967	 * var for the rest of the loop to avoid a new stack var.
 968	 *
 969	 * 48 bytes is enough to display the header and a little bit
 970	 * into the payload for debugging purposes.
 971	 */
 972	length = server->ops->check_message(buf, server->total_read);
 973	if (length != 0)
 974		cifs_dump_mem("Bad SMB: ", buf,
 975			min_t(unsigned int, server->total_read, 48));
 976
 
 
 
 
 
 
 
 
 
 
 977	if (!mid)
 978		return length;
 979
 980	handle_mid(mid, server, buf, length);
 981	return 0;
 982}
 983
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 984static int
 985cifs_demultiplex_thread(void *p)
 986{
 987	int length;
 988	struct TCP_Server_Info *server = p;
 989	unsigned int pdu_length;
 
 990	char *buf = NULL;
 991	struct task_struct *task_to_wake = NULL;
 992	struct mid_q_entry *mid_entry;
 
 
 993
 994	current->flags |= PF_MEMALLOC;
 995	cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
 996
 997	length = atomic_inc_return(&tcpSesAllocCount);
 998	if (length > 1)
 999		mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
1000				GFP_KERNEL);
1001
1002	set_freezable();
 
1003	while (server->tcpStatus != CifsExiting) {
1004		if (try_to_freeze())
1005			continue;
1006
1007		if (!allocate_buffers(server))
1008			continue;
1009
1010		server->large_buf = false;
1011		buf = server->smallbuf;
1012		pdu_length = 4; /* enough to get RFC1001 header */
1013
1014		length = cifs_read_from_socket(server, buf, pdu_length);
1015		if (length < 0)
1016			continue;
1017		server->total_read = length;
 
 
 
 
1018
1019		/*
1020		 * The right amount was read from socket - 4 bytes,
1021		 * so we can now interpret the length field.
1022		 */
1023		pdu_length = get_rfc1002_length(buf);
1024
1025		cFYI(1, "RFC1002 header 0x%x", pdu_length);
1026		if (!is_smb_response(server, buf[0]))
1027			continue;
 
 
1028
1029		/* make sure we have enough to get to the MID */
1030		if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
1031			cERROR(1, "SMB response too short (%u bytes)",
1032				pdu_length);
1033			cifs_reconnect(server);
1034			wake_up(&server->response_q);
1035			continue;
1036		}
1037
1038		/* read down to the MID */
1039		length = cifs_read_from_socket(server, buf + 4,
1040					       HEADER_SIZE(server) - 1 - 4);
 
1041		if (length < 0)
1042			continue;
1043		server->total_read += length;
1044
1045		mid_entry = server->ops->find_mid(server, buf);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1046
1047		if (!mid_entry || !mid_entry->receive)
1048			length = standard_receive3(server, mid_entry);
1049		else
1050			length = mid_entry->receive(server, mid_entry);
 
1051
1052		if (length < 0)
 
 
 
1053			continue;
 
1054
1055		if (server->large_buf)
1056			buf = server->bigbuf;
 
 
 
 
 
 
 
1057
1058		server->lstrp = jiffies;
1059		if (mid_entry != NULL) {
1060			if (!mid_entry->multiRsp || mid_entry->multiEnd)
1061				mid_entry->callback(mid_entry);
1062		} else if (!server->ops->is_oplock_break ||
1063			   !server->ops->is_oplock_break(buf, server)) {
1064			cERROR(1, "No task to wake, unknown frame received! "
1065				   "NumMids %d", atomic_read(&midCount));
1066			cifs_dump_mem("Received Data is: ", buf,
1067				      HEADER_SIZE(server));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1068#ifdef CONFIG_CIFS_DEBUG2
1069			if (server->ops->dump_detail)
1070				server->ops->dump_detail(buf);
1071			cifs_dump_mids(server);
 
1072#endif /* CIFS_DEBUG2 */
 
 
1073
 
 
 
 
 
 
 
 
1074		}
1075	} /* end while !EXITING */
1076
1077	/* buffer usually freed in free_mid - need to free it here on exit */
1078	cifs_buf_release(server->bigbuf);
1079	if (server->smallbuf) /* no sense logging a debug message if NULL */
1080		cifs_small_buf_release(server->smallbuf);
1081
1082	task_to_wake = xchg(&server->tsk, NULL);
1083	clean_demultiplex_info(server);
1084
1085	/* if server->tsk was NULL then wait for a signal before exiting */
1086	if (!task_to_wake) {
1087		set_current_state(TASK_INTERRUPTIBLE);
1088		while (!signal_pending(current)) {
1089			schedule();
1090			set_current_state(TASK_INTERRUPTIBLE);
1091		}
1092		set_current_state(TASK_RUNNING);
1093	}
1094
1095	module_put_and_exit(0);
 
1096}
1097
1098/* extract the host portion of the UNC string */
1099static char *
1100extract_hostname(const char *unc)
1101{
1102	const char *src;
1103	char *dst, *delim;
1104	unsigned int len;
1105
1106	/* skip double chars at beginning of string */
1107	/* BB: check validity of these bytes? */
1108	src = unc + 2;
1109
1110	/* delimiter between hostname and sharename is always '\\' now */
1111	delim = strchr(src, '\\');
1112	if (!delim)
1113		return ERR_PTR(-EINVAL);
1114
1115	len = delim - src;
1116	dst = kmalloc((len + 1), GFP_KERNEL);
1117	if (dst == NULL)
1118		return ERR_PTR(-ENOMEM);
1119
1120	memcpy(dst, src, len);
1121	dst[len] = '\0';
1122
1123	return dst;
1124}
1125
1126static int get_option_ul(substring_t args[], unsigned long *option)
1127{
1128	int rc;
1129	char *string;
1130
1131	string = match_strdup(args);
1132	if (string == NULL)
1133		return -ENOMEM;
1134	rc = kstrtoul(string, 0, option);
1135	kfree(string);
1136
1137	return rc;
1138}
1139
1140
1141static int cifs_parse_security_flavors(char *value,
1142				       struct smb_vol *vol)
1143{
1144
1145	substring_t args[MAX_OPT_ARGS];
1146
1147	switch (match_token(value, cifs_secflavor_tokens, args)) {
1148	case Opt_sec_krb5:
1149		vol->secFlg |= CIFSSEC_MAY_KRB5;
1150		break;
1151	case Opt_sec_krb5i:
1152		vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1153		break;
1154	case Opt_sec_krb5p:
1155		/* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1156		cERROR(1, "Krb5 cifs privacy not supported");
1157		break;
1158	case Opt_sec_ntlmssp:
1159		vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1160		break;
1161	case Opt_sec_ntlmsspi:
1162		vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1163		break;
1164	case Opt_ntlm:
1165		/* ntlm is default so can be turned off too */
1166		vol->secFlg |= CIFSSEC_MAY_NTLM;
1167		break;
1168	case Opt_sec_ntlmi:
1169		vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1170		break;
1171	case Opt_sec_ntlmv2:
1172		vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1173		break;
1174	case Opt_sec_ntlmv2i:
1175		vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1176		break;
1177#ifdef CONFIG_CIFS_WEAK_PW_HASH
1178	case Opt_sec_lanman:
1179		vol->secFlg |= CIFSSEC_MAY_LANMAN;
1180		break;
1181#endif
1182	case Opt_sec_none:
1183		vol->nullauth = 1;
1184		break;
1185	default:
1186		cERROR(1, "bad security option: %s", value);
1187		return 1;
1188	}
1189
1190	return 0;
1191}
1192
1193static int
1194cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1195{
1196	substring_t args[MAX_OPT_ARGS];
1197
1198	switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1199	case Opt_cache_loose:
1200		vol->direct_io = false;
1201		vol->strict_io = false;
1202		break;
1203	case Opt_cache_strict:
1204		vol->direct_io = false;
1205		vol->strict_io = true;
1206		break;
1207	case Opt_cache_none:
1208		vol->direct_io = true;
1209		vol->strict_io = false;
1210		break;
1211	default:
1212		cERROR(1, "bad cache= option: %s", value);
1213		return 1;
1214	}
1215	return 0;
1216}
1217
1218static int
1219cifs_parse_smb_version(char *value, struct smb_vol *vol)
1220{
1221	substring_t args[MAX_OPT_ARGS];
1222
1223	switch (match_token(value, cifs_smb_version_tokens, args)) {
1224	case Smb_1:
1225		vol->ops = &smb1_operations;
1226		vol->vals = &smb1_values;
1227		break;
1228#ifdef CONFIG_CIFS_SMB2
1229	case Smb_21:
1230		vol->ops = &smb21_operations;
1231		vol->vals = &smb21_values;
1232		break;
1233#endif
1234	default:
1235		cERROR(1, "Unknown vers= option specified: %s", value);
1236		return 1;
1237	}
1238	return 0;
1239}
1240
1241static int
1242cifs_parse_mount_options(const char *mountdata, const char *devname,
1243			 struct smb_vol *vol)
1244{
1245	char *data, *end;
1246	char *mountdata_copy = NULL, *options;
1247	unsigned int  temp_len, i, j;
1248	char separator[2];
1249	short int override_uid = -1;
1250	short int override_gid = -1;
1251	bool uid_specified = false;
1252	bool gid_specified = false;
1253	bool sloppy = false;
1254	char *invalid = NULL;
1255	char *nodename = utsname()->nodename;
1256	char *string = NULL;
1257	char *tmp_end, *value;
1258	char delim;
1259	bool cache_specified = false;
1260	static bool cache_warned = false;
1261
1262	separator[0] = ',';
1263	separator[1] = 0;
1264	delim = separator[0];
1265
1266	/*
1267	 * does not have to be perfect mapping since field is
1268	 * informational, only used for servers that do not support
1269	 * port 445 and it can be overridden at mount time
1270	 */
1271	memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1272	for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1273		vol->source_rfc1001_name[i] = toupper(nodename[i]);
1274
1275	vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1276	/* null target name indicates to use *SMBSERVR default called name
1277	   if we end up sending RFC1001 session initialize */
1278	vol->target_rfc1001_name[0] = 0;
1279	vol->cred_uid = current_uid();
1280	vol->linux_uid = current_uid();
1281	vol->linux_gid = current_gid();
1282
1283	/* default to only allowing write access to owner of the mount */
1284	vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1285
1286	/* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1287	/* default is always to request posix paths. */
1288	vol->posix_paths = 1;
1289	/* default to using server inode numbers where available */
1290	vol->server_ino = 1;
1291
1292	vol->actimeo = CIFS_DEF_ACTIMEO;
1293
1294	/* FIXME: add autonegotiation -- for now, SMB1 is default */
1295	vol->ops = &smb1_operations;
1296	vol->vals = &smb1_values;
1297
1298	if (!mountdata)
1299		goto cifs_parse_mount_err;
1300
1301	mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1302	if (!mountdata_copy)
1303		goto cifs_parse_mount_err;
1304
1305	options = mountdata_copy;
1306	end = options + strlen(options);
1307
1308	if (strncmp(options, "sep=", 4) == 0) {
1309		if (options[4] != 0) {
1310			separator[0] = options[4];
1311			options += 5;
1312		} else {
1313			cFYI(1, "Null separator not allowed");
1314		}
1315	}
1316	vol->backupuid_specified = false; /* no backup intent for a user */
1317	vol->backupgid_specified = false; /* no backup intent for a group */
1318
1319	while ((data = strsep(&options, separator)) != NULL) {
1320		substring_t args[MAX_OPT_ARGS];
1321		unsigned long option;
1322		int token;
1323
1324		if (!*data)
1325			continue;
1326
1327		token = match_token(data, cifs_mount_option_tokens, args);
1328
1329		switch (token) {
1330
1331		/* Ingnore the following */
1332		case Opt_ignore:
1333			break;
1334
1335		/* Boolean values */
1336		case Opt_user_xattr:
1337			vol->no_xattr = 0;
1338			break;
1339		case Opt_nouser_xattr:
1340			vol->no_xattr = 1;
1341			break;
1342		case Opt_forceuid:
1343			override_uid = 1;
1344			break;
1345		case Opt_noforceuid:
1346			override_uid = 0;
1347			break;
1348		case Opt_noblocksend:
1349			vol->noblocksnd = 1;
1350			break;
1351		case Opt_noautotune:
1352			vol->noautotune = 1;
1353			break;
1354		case Opt_hard:
1355			vol->retry = 1;
1356			break;
1357		case Opt_soft:
1358			vol->retry = 0;
1359			break;
1360		case Opt_perm:
1361			vol->noperm = 0;
1362			break;
1363		case Opt_noperm:
1364			vol->noperm = 1;
1365			break;
1366		case Opt_mapchars:
1367			vol->remap = 1;
1368			break;
1369		case Opt_nomapchars:
1370			vol->remap = 0;
1371			break;
1372		case Opt_sfu:
1373			vol->sfu_emul = 1;
1374			break;
1375		case Opt_nosfu:
1376			vol->sfu_emul = 0;
1377			break;
1378		case Opt_nodfs:
1379			vol->nodfs = 1;
1380			break;
1381		case Opt_posixpaths:
1382			vol->posix_paths = 1;
1383			break;
1384		case Opt_noposixpaths:
1385			vol->posix_paths = 0;
1386			break;
1387		case Opt_nounix:
1388			vol->no_linux_ext = 1;
1389			break;
1390		case Opt_nocase:
1391			vol->nocase = 1;
1392			break;
1393		case Opt_brl:
1394			vol->nobrl =  0;
1395			break;
1396		case Opt_nobrl:
1397			vol->nobrl =  1;
1398			/*
1399			 * turn off mandatory locking in mode
1400			 * if remote locking is turned off since the
1401			 * local vfs will do advisory
1402			 */
1403			if (vol->file_mode ==
1404				(S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1405				vol->file_mode = S_IALLUGO;
1406			break;
1407		case Opt_forcemandatorylock:
1408			vol->mand_lock = 1;
1409			break;
1410		case Opt_setuids:
1411			vol->setuids = 1;
1412			break;
1413		case Opt_nosetuids:
1414			vol->setuids = 0;
1415			break;
1416		case Opt_dynperm:
1417			vol->dynperm = true;
1418			break;
1419		case Opt_nodynperm:
1420			vol->dynperm = false;
1421			break;
1422		case Opt_nohard:
1423			vol->retry = 0;
1424			break;
1425		case Opt_nosoft:
1426			vol->retry = 1;
1427			break;
1428		case Opt_nointr:
1429			vol->intr = 0;
1430			break;
1431		case Opt_intr:
1432			vol->intr = 1;
1433			break;
1434		case Opt_nostrictsync:
1435			vol->nostrictsync = 1;
1436			break;
1437		case Opt_strictsync:
1438			vol->nostrictsync = 0;
1439			break;
1440		case Opt_serverino:
1441			vol->server_ino = 1;
1442			break;
1443		case Opt_noserverino:
1444			vol->server_ino = 0;
1445			break;
1446		case Opt_rwpidforward:
1447			vol->rwpidforward = 1;
1448			break;
1449		case Opt_cifsacl:
1450			vol->cifs_acl = 1;
1451			break;
1452		case Opt_nocifsacl:
1453			vol->cifs_acl = 0;
1454			break;
1455		case Opt_acl:
1456			vol->no_psx_acl = 0;
1457			break;
1458		case Opt_noacl:
1459			vol->no_psx_acl = 1;
1460			break;
1461		case Opt_locallease:
1462			vol->local_lease = 1;
1463			break;
1464		case Opt_sign:
1465			vol->secFlg |= CIFSSEC_MUST_SIGN;
1466			break;
1467		case Opt_seal:
1468			/* we do not do the following in secFlags because seal
1469			 * is a per tree connection (mount) not a per socket
1470			 * or per-smb connection option in the protocol
1471			 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1472			 */
1473			vol->seal = 1;
1474			break;
1475		case Opt_direct:
1476			cache_specified = true;
1477			vol->direct_io = true;
1478			vol->strict_io = false;
1479			cERROR(1, "The \"directio\" option will be removed in "
1480				  "3.7. Please switch to the \"cache=none\" "
1481				  "option.");
1482			break;
1483		case Opt_strictcache:
1484			cache_specified = true;
1485			vol->direct_io = false;
1486			vol->strict_io = true;
1487			cERROR(1, "The \"strictcache\" option will be removed "
1488				"in 3.7. Please switch to the \"cache=strict\" "
1489				"option.");
1490			break;
1491		case Opt_noac:
1492			printk(KERN_WARNING "CIFS: Mount option noac not "
1493				"supported. Instead set "
1494				"/proc/fs/cifs/LookupCacheEnabled to 0\n");
1495			break;
1496		case Opt_fsc:
1497#ifndef CONFIG_CIFS_FSCACHE
1498			cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1499				  "kernel config option set");
1500			goto cifs_parse_mount_err;
1501#endif
1502			vol->fsc = true;
1503			break;
1504		case Opt_mfsymlinks:
1505			vol->mfsymlinks = true;
1506			break;
1507		case Opt_multiuser:
1508			vol->multiuser = true;
1509			break;
1510		case Opt_sloppy:
1511			sloppy = true;
1512			break;
1513
1514		/* Numeric Values */
1515		case Opt_backupuid:
1516			if (get_option_ul(args, &option)) {
1517				cERROR(1, "%s: Invalid backupuid value",
1518					__func__);
1519				goto cifs_parse_mount_err;
1520			}
1521			vol->backupuid = option;
1522			vol->backupuid_specified = true;
1523			break;
1524		case Opt_backupgid:
1525			if (get_option_ul(args, &option)) {
1526				cERROR(1, "%s: Invalid backupgid value",
1527					__func__);
1528				goto cifs_parse_mount_err;
1529			}
1530			vol->backupgid = option;
1531			vol->backupgid_specified = true;
1532			break;
1533		case Opt_uid:
1534			if (get_option_ul(args, &option)) {
1535				cERROR(1, "%s: Invalid uid value",
1536					__func__);
1537				goto cifs_parse_mount_err;
1538			}
1539			vol->linux_uid = option;
1540			uid_specified = true;
1541			break;
1542		case Opt_cruid:
1543			if (get_option_ul(args, &option)) {
1544				cERROR(1, "%s: Invalid cruid value",
1545					__func__);
1546				goto cifs_parse_mount_err;
1547			}
1548			vol->cred_uid = option;
1549			break;
1550		case Opt_gid:
1551			if (get_option_ul(args, &option)) {
1552				cERROR(1, "%s: Invalid gid value",
1553						__func__);
1554				goto cifs_parse_mount_err;
1555			}
1556			vol->linux_gid = option;
1557			gid_specified = true;
1558			break;
1559		case Opt_file_mode:
1560			if (get_option_ul(args, &option)) {
1561				cERROR(1, "%s: Invalid file_mode value",
1562					__func__);
1563				goto cifs_parse_mount_err;
1564			}
1565			vol->file_mode = option;
1566			break;
1567		case Opt_dirmode:
1568			if (get_option_ul(args, &option)) {
1569				cERROR(1, "%s: Invalid dir_mode value",
1570					__func__);
1571				goto cifs_parse_mount_err;
1572			}
1573			vol->dir_mode = option;
1574			break;
1575		case Opt_port:
1576			if (get_option_ul(args, &option)) {
1577				cERROR(1, "%s: Invalid port value",
1578					__func__);
1579				goto cifs_parse_mount_err;
1580			}
1581			vol->port = option;
1582			break;
1583		case Opt_rsize:
1584			if (get_option_ul(args, &option)) {
1585				cERROR(1, "%s: Invalid rsize value",
1586					__func__);
1587				goto cifs_parse_mount_err;
1588			}
1589			vol->rsize = option;
1590			break;
1591		case Opt_wsize:
1592			if (get_option_ul(args, &option)) {
1593				cERROR(1, "%s: Invalid wsize value",
1594					__func__);
1595				goto cifs_parse_mount_err;
1596			}
1597			vol->wsize = option;
1598			break;
1599		case Opt_actimeo:
1600			if (get_option_ul(args, &option)) {
1601				cERROR(1, "%s: Invalid actimeo value",
1602					__func__);
1603				goto cifs_parse_mount_err;
1604			}
1605			vol->actimeo = HZ * option;
1606			if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1607				cERROR(1, "CIFS: attribute cache"
1608					  "timeout too large");
1609				goto cifs_parse_mount_err;
1610			}
1611			break;
1612
1613		/* String Arguments */
1614
1615		case Opt_blank_user:
1616			/* null user, ie. anonymous authentication */
1617			vol->nullauth = 1;
1618			vol->username = NULL;
1619			break;
1620		case Opt_user:
1621			string = match_strdup(args);
1622			if (string == NULL)
1623				goto out_nomem;
1624
1625			if (strnlen(string, MAX_USERNAME_SIZE) >
1626							MAX_USERNAME_SIZE) {
1627				printk(KERN_WARNING "CIFS: username too long\n");
1628				goto cifs_parse_mount_err;
1629			}
1630			vol->username = kstrdup(string, GFP_KERNEL);
1631			if (!vol->username) {
1632				printk(KERN_WARNING "CIFS: no memory "
1633						    "for username\n");
1634				goto cifs_parse_mount_err;
1635			}
1636			break;
1637		case Opt_blank_pass:
1638			vol->password = NULL;
1639			break;
1640		case Opt_pass:
1641			/* passwords have to be handled differently
1642			 * to allow the character used for deliminator
1643			 * to be passed within them
1644			 */
1645
1646			/* Obtain the value string */
1647			value = strchr(data, '=');
1648			value++;
1649
1650			/* Set tmp_end to end of the string */
1651			tmp_end = (char *) value + strlen(value);
1652
1653			/* Check if following character is the deliminator
1654			 * If yes, we have encountered a double deliminator
1655			 * reset the NULL character to the deliminator
1656			 */
1657			if (tmp_end < end && tmp_end[1] == delim) {
1658				tmp_end[0] = delim;
1659
1660				/* Keep iterating until we get to a single
1661				 * deliminator OR the end
1662				 */
1663				while ((tmp_end = strchr(tmp_end, delim))
1664					!= NULL && (tmp_end[1] == delim)) {
1665						tmp_end = (char *) &tmp_end[2];
1666				}
1667
1668				/* Reset var options to point to next element */
1669				if (tmp_end) {
1670					tmp_end[0] = '\0';
1671					options = (char *) &tmp_end[1];
1672				} else
1673					/* Reached the end of the mount option
1674					 * string */
1675					options = end;
1676			}
1677
1678			/* Now build new password string */
1679			temp_len = strlen(value);
1680			vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1681			if (vol->password == NULL) {
1682				printk(KERN_WARNING "CIFS: no memory "
1683						    "for password\n");
1684				goto cifs_parse_mount_err;
1685			}
1686
1687			for (i = 0, j = 0; i < temp_len; i++, j++) {
1688				vol->password[j] = value[i];
1689				if ((value[i] == delim) &&
1690				     value[i+1] == delim)
1691					/* skip the second deliminator */
1692					i++;
1693			}
1694			vol->password[j] = '\0';
1695			break;
1696		case Opt_blank_ip:
1697			vol->UNCip = NULL;
1698			break;
1699		case Opt_ip:
1700			string = match_strdup(args);
1701			if (string == NULL)
1702				goto out_nomem;
1703
1704			if (strnlen(string, INET6_ADDRSTRLEN) >
1705						INET6_ADDRSTRLEN) {
1706				printk(KERN_WARNING "CIFS: ip address "
1707						    "too long\n");
1708				goto cifs_parse_mount_err;
1709			}
1710			vol->UNCip = kstrdup(string, GFP_KERNEL);
1711			if (!vol->UNCip) {
1712				printk(KERN_WARNING "CIFS: no memory "
1713						    "for UNC IP\n");
1714				goto cifs_parse_mount_err;
1715			}
1716			break;
1717		case Opt_unc:
1718			string = match_strdup(args);
1719			if (string == NULL)
1720				goto out_nomem;
1721
1722			temp_len = strnlen(string, 300);
1723			if (temp_len  == 300) {
1724				printk(KERN_WARNING "CIFS: UNC name too long\n");
1725				goto cifs_parse_mount_err;
1726			}
1727
1728			vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1729			if (vol->UNC == NULL) {
1730				printk(KERN_WARNING "CIFS: no memory for UNC\n");
1731				goto cifs_parse_mount_err;
1732			}
1733			strcpy(vol->UNC, string);
1734
1735			if (strncmp(string, "//", 2) == 0) {
1736				vol->UNC[0] = '\\';
1737				vol->UNC[1] = '\\';
1738			} else if (strncmp(string, "\\\\", 2) != 0) {
1739				printk(KERN_WARNING "CIFS: UNC Path does not "
1740						    "begin with // or \\\\\n");
1741				goto cifs_parse_mount_err;
1742			}
1743
1744			break;
1745		case Opt_domain:
1746			string = match_strdup(args);
1747			if (string == NULL)
1748				goto out_nomem;
1749
1750			if (strnlen(string, 256) == 256) {
1751				printk(KERN_WARNING "CIFS: domain name too"
1752						    " long\n");
1753				goto cifs_parse_mount_err;
1754			}
1755
1756			vol->domainname = kstrdup(string, GFP_KERNEL);
1757			if (!vol->domainname) {
1758				printk(KERN_WARNING "CIFS: no memory "
1759						    "for domainname\n");
1760				goto cifs_parse_mount_err;
1761			}
1762			cFYI(1, "Domain name set");
1763			break;
1764		case Opt_srcaddr:
1765			string = match_strdup(args);
1766			if (string == NULL)
1767				goto out_nomem;
1768
1769			if (!cifs_convert_address(
1770					(struct sockaddr *)&vol->srcaddr,
1771					string, strlen(string))) {
1772				printk(KERN_WARNING "CIFS:  Could not parse"
1773						    " srcaddr: %s\n", string);
1774				goto cifs_parse_mount_err;
1775			}
1776			break;
1777		case Opt_prefixpath:
1778			string = match_strdup(args);
1779			if (string == NULL)
1780				goto out_nomem;
1781
1782			temp_len = strnlen(string, 1024);
1783			if (string[0] != '/')
1784				temp_len++; /* missing leading slash */
1785			if (temp_len > 1024) {
1786				printk(KERN_WARNING "CIFS: prefix too long\n");
1787				goto cifs_parse_mount_err;
1788			}
1789
1790			vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1791			if (vol->prepath == NULL) {
1792				printk(KERN_WARNING "CIFS: no memory "
1793						    "for path prefix\n");
1794				goto cifs_parse_mount_err;
1795			}
1796
1797			if (string[0] != '/') {
1798				vol->prepath[0] = '/';
1799				strcpy(vol->prepath+1, string);
1800			} else
1801				strcpy(vol->prepath, string);
1802
1803			break;
1804		case Opt_iocharset:
1805			string = match_strdup(args);
1806			if (string == NULL)
1807				goto out_nomem;
1808
1809			if (strnlen(string, 1024) >= 65) {
1810				printk(KERN_WARNING "CIFS: iocharset name "
1811						    "too long.\n");
1812				goto cifs_parse_mount_err;
1813			}
1814
1815			 if (strnicmp(string, "default", 7) != 0) {
1816				vol->iocharset = kstrdup(string,
1817							 GFP_KERNEL);
1818				if (!vol->iocharset) {
1819					printk(KERN_WARNING "CIFS: no memory"
1820							    "for charset\n");
1821					goto cifs_parse_mount_err;
1822				}
1823			}
1824			/* if iocharset not set then load_nls_default
1825			 * is used by caller
1826			 */
1827			cFYI(1, "iocharset set to %s", string);
1828			break;
1829		case Opt_sockopt:
1830			string = match_strdup(args);
1831			if (string == NULL)
1832				goto out_nomem;
1833
1834			if (strnicmp(string, "TCP_NODELAY", 11) == 0)
1835				vol->sockopt_tcp_nodelay = 1;
1836			break;
1837		case Opt_netbiosname:
1838			string = match_strdup(args);
1839			if (string == NULL)
1840				goto out_nomem;
1841
1842			memset(vol->source_rfc1001_name, 0x20,
1843				RFC1001_NAME_LEN);
1844			/*
1845			 * FIXME: are there cases in which a comma can
1846			 * be valid in workstation netbios name (and
1847			 * need special handling)?
1848			 */
1849			for (i = 0; i < RFC1001_NAME_LEN; i++) {
1850				/* don't ucase netbiosname for user */
1851				if (string[i] == 0)
1852					break;
1853				vol->source_rfc1001_name[i] = string[i];
1854			}
1855			/* The string has 16th byte zero still from
1856			 * set at top of the function
1857			 */
1858			if (i == RFC1001_NAME_LEN && string[i] != 0)
1859				printk(KERN_WARNING "CIFS: netbiosname"
1860				       " longer than 15 truncated.\n");
1861
1862			break;
1863		case Opt_servern:
1864			/* servernetbiosname specified override *SMBSERVER */
1865			string = match_strdup(args);
1866			if (string == NULL)
1867				goto out_nomem;
1868
1869			/* last byte, type, is 0x20 for servr type */
1870			memset(vol->target_rfc1001_name, 0x20,
1871				RFC1001_NAME_LEN_WITH_NULL);
1872
1873			/* BB are there cases in which a comma can be
1874			   valid in this workstation netbios name
1875			   (and need special handling)? */
1876
1877			/* user or mount helper must uppercase the
1878			   netbios name */
1879			for (i = 0; i < 15; i++) {
1880				if (string[i] == 0)
1881					break;
1882				vol->target_rfc1001_name[i] = string[i];
1883			}
1884			/* The string has 16th byte zero still from
1885			   set at top of the function  */
1886			if (i == RFC1001_NAME_LEN && string[i] != 0)
1887				printk(KERN_WARNING "CIFS: server net"
1888				       "biosname longer than 15 truncated.\n");
1889			break;
1890		case Opt_ver:
1891			string = match_strdup(args);
1892			if (string == NULL)
1893				goto out_nomem;
1894
1895			if (strnicmp(string, "1", 1) == 0) {
1896				/* This is the default */
1897				break;
1898			}
1899			/* For all other value, error */
1900			printk(KERN_WARNING "CIFS: Invalid version"
1901					    " specified\n");
1902			goto cifs_parse_mount_err;
1903		case Opt_vers:
1904			string = match_strdup(args);
1905			if (string == NULL)
1906				goto out_nomem;
1907
1908			if (cifs_parse_smb_version(string, vol) != 0)
1909				goto cifs_parse_mount_err;
1910			break;
1911		case Opt_sec:
1912			string = match_strdup(args);
1913			if (string == NULL)
1914				goto out_nomem;
1915
1916			if (cifs_parse_security_flavors(string, vol) != 0)
1917				goto cifs_parse_mount_err;
1918			break;
1919		case Opt_cache:
1920			cache_specified = true;
1921			string = match_strdup(args);
1922			if (string == NULL)
1923				goto out_nomem;
1924
1925			if (cifs_parse_cache_flavor(string, vol) != 0)
1926				goto cifs_parse_mount_err;
1927			break;
1928		default:
1929			/*
1930			 * An option we don't recognize. Save it off for later
1931			 * if we haven't already found one
1932			 */
1933			if (!invalid)
1934				invalid = data;
1935			break;
1936		}
1937		/* Free up any allocated string */
1938		kfree(string);
1939		string = NULL;
1940	}
1941
1942	if (!sloppy && invalid) {
1943		printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1944		goto cifs_parse_mount_err;
1945	}
1946
1947#ifndef CONFIG_KEYS
1948	/* Muliuser mounts require CONFIG_KEYS support */
1949	if (vol->multiuser) {
1950		cERROR(1, "Multiuser mounts require kernels with "
1951			  "CONFIG_KEYS enabled.");
1952		goto cifs_parse_mount_err;
1953	}
1954#endif
1955
1956	if (vol->UNCip == NULL)
1957		vol->UNCip = &vol->UNC[2];
1958
1959	if (uid_specified)
1960		vol->override_uid = override_uid;
1961	else if (override_uid == 1)
1962		printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1963				   "specified with no uid= option.\n");
1964
1965	if (gid_specified)
1966		vol->override_gid = override_gid;
1967	else if (override_gid == 1)
1968		printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1969				   "specified with no gid= option.\n");
1970
1971	/* FIXME: remove this block in 3.7 */
1972	if (!cache_specified && !cache_warned) {
1973		cache_warned = true;
1974		printk(KERN_NOTICE "CIFS: no cache= option specified, using "
1975				   "\"cache=loose\". This default will change "
1976				   "to \"cache=strict\" in 3.7.\n");
1977	}
1978
1979	kfree(mountdata_copy);
1980	return 0;
1981
1982out_nomem:
1983	printk(KERN_WARNING "Could not allocate temporary buffer\n");
1984cifs_parse_mount_err:
1985	kfree(string);
1986	kfree(mountdata_copy);
1987	return 1;
1988}
1989
1990/** Returns true if srcaddr isn't specified and rhs isn't
1991 * specified, or if srcaddr is specified and
1992 * matches the IP address of the rhs argument.
1993 */
1994static bool
1995srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1996{
1997	switch (srcaddr->sa_family) {
1998	case AF_UNSPEC:
1999		return (rhs->sa_family == AF_UNSPEC);
2000	case AF_INET: {
2001		struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2002		struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2003		return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2004	}
2005	case AF_INET6: {
2006		struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2007		struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
2008		return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2009	}
2010	default:
2011		WARN_ON(1);
2012		return false; /* don't expect to be here */
2013	}
2014}
2015
2016/*
2017 * If no port is specified in addr structure, we try to match with 445 port
2018 * and if it fails - with 139 ports. It should be called only if address
2019 * families of server and addr are equal.
2020 */
2021static bool
2022match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2023{
2024	__be16 port, *sport;
2025
 
 
 
 
2026	switch (addr->sa_family) {
2027	case AF_INET:
2028		sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2029		port = ((struct sockaddr_in *) addr)->sin_port;
2030		break;
2031	case AF_INET6:
2032		sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2033		port = ((struct sockaddr_in6 *) addr)->sin6_port;
2034		break;
2035	default:
2036		WARN_ON(1);
2037		return false;
2038	}
2039
2040	if (!port) {
2041		port = htons(CIFS_PORT);
2042		if (port == *sport)
2043			return true;
2044
2045		port = htons(RFC1001_PORT);
2046	}
2047
2048	return port == *sport;
2049}
2050
2051static bool
2052match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2053	      struct sockaddr *srcaddr)
2054{
2055	switch (addr->sa_family) {
2056	case AF_INET: {
2057		struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2058		struct sockaddr_in *srv_addr4 =
2059					(struct sockaddr_in *)&server->dstaddr;
2060
2061		if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2062			return false;
2063		break;
2064	}
2065	case AF_INET6: {
2066		struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2067		struct sockaddr_in6 *srv_addr6 =
2068					(struct sockaddr_in6 *)&server->dstaddr;
2069
2070		if (!ipv6_addr_equal(&addr6->sin6_addr,
2071				     &srv_addr6->sin6_addr))
2072			return false;
2073		if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2074			return false;
2075		break;
2076	}
2077	default:
2078		WARN_ON(1);
2079		return false; /* don't expect to be here */
2080	}
2081
2082	if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2083		return false;
2084
2085	return true;
2086}
2087
2088static bool
2089match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2090{
2091	unsigned int secFlags;
 
 
 
 
 
 
 
2092
2093	if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2094		secFlags = vol->secFlg;
2095	else
2096		secFlags = global_secflags | vol->secFlg;
 
 
 
 
 
 
2097
2098	switch (server->secType) {
2099	case LANMAN:
2100		if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2101			return false;
2102		break;
2103	case NTLMv2:
2104		if (!(secFlags & CIFSSEC_MAY_NTLMV2))
 
 
2105			return false;
2106		break;
2107	case NTLM:
2108		if (!(secFlags & CIFSSEC_MAY_NTLM))
2109			return false;
2110		break;
2111	case Kerberos:
2112		if (!(secFlags & CIFSSEC_MAY_KRB5))
2113			return false;
2114		break;
2115	case RawNTLMSSP:
2116		if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2117			return false;
2118		break;
2119	default:
2120		/* shouldn't happen */
2121		return false;
2122	}
2123
2124	/* now check if signing mode is acceptable */
2125	if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2126	    (server->sec_mode & SECMODE_SIGN_REQUIRED))
2127			return false;
2128	else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2129		 (server->sec_mode &
2130		  (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2131			return false;
2132
2133	return true;
2134}
2135
2136static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
2137			 struct smb_vol *vol)
 
2138{
2139	if ((server->vals != vol->vals) || (server->ops != vol->ops))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2140		return 0;
2141
2142	if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2143		return 0;
2144
2145	if (!match_address(server, addr,
2146			   (struct sockaddr *)&vol->srcaddr))
2147		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2148
2149	if (!match_port(server, addr))
2150		return 0;
2151
2152	if (!match_security(server, vol))
 
 
 
 
 
 
 
 
 
2153		return 0;
2154
2155	return 1;
2156}
2157
2158static struct TCP_Server_Info *
2159cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
2160{
2161	struct TCP_Server_Info *server;
2162
2163	spin_lock(&cifs_tcp_ses_lock);
2164	list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2165		if (!match_server(server, addr, vol))
 
 
 
 
 
 
2166			continue;
 
 
2167
2168		++server->srv_count;
2169		spin_unlock(&cifs_tcp_ses_lock);
2170		cFYI(1, "Existing tcp session with server found");
2171		return server;
2172	}
2173	spin_unlock(&cifs_tcp_ses_lock);
2174	return NULL;
2175}
2176
2177static void
2178cifs_put_tcp_session(struct TCP_Server_Info *server)
2179{
2180	struct task_struct *task;
2181
2182	spin_lock(&cifs_tcp_ses_lock);
2183	if (--server->srv_count > 0) {
2184		spin_unlock(&cifs_tcp_ses_lock);
2185		return;
2186	}
2187
 
 
 
2188	put_net(cifs_net_ns(server));
2189
2190	list_del_init(&server->tcp_ses_list);
2191	spin_unlock(&cifs_tcp_ses_lock);
2192
 
 
 
 
2193	cancel_delayed_work_sync(&server->echo);
 
 
 
 
 
 
 
 
 
 
 
 
2194
2195	spin_lock(&GlobalMid_Lock);
2196	server->tcpStatus = CifsExiting;
2197	spin_unlock(&GlobalMid_Lock);
2198
2199	cifs_crypto_shash_release(server);
2200	cifs_fscache_release_client_cookie(server);
2201
2202	kfree(server->session_key.response);
2203	server->session_key.response = NULL;
2204	server->session_key.len = 0;
 
 
2205
2206	task = xchg(&server->tsk, NULL);
2207	if (task)
2208		force_sig(SIGKILL, task);
2209}
2210
2211static struct TCP_Server_Info *
2212cifs_get_tcp_session(struct smb_vol *volume_info)
 
2213{
2214	struct TCP_Server_Info *tcp_ses = NULL;
2215	struct sockaddr_storage addr;
2216	struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2217	struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2218	int rc;
2219
2220	memset(&addr, 0, sizeof(struct sockaddr_storage));
2221
2222	cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
2223
2224	if (volume_info->UNCip && volume_info->UNC) {
2225		rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2226					volume_info->UNCip,
2227					strlen(volume_info->UNCip),
2228					volume_info->port);
2229		if (!rc) {
2230			/* we failed translating address */
2231			rc = -EINVAL;
2232			goto out_err;
2233		}
2234	} else if (volume_info->UNCip) {
2235		/* BB using ip addr as tcp_ses name to connect to the
2236		   DFS root below */
2237		cERROR(1, "Connecting to DFS root not implemented yet");
2238		rc = -EINVAL;
2239		goto out_err;
2240	} else /* which tcp_sess DFS root would we conect to */ {
2241		cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2242			"unc=//192.168.1.100/public) specified");
2243		rc = -EINVAL;
2244		goto out_err;
2245	}
2246
2247	/* see if we already have a matching tcp_ses */
2248	tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
2249	if (tcp_ses)
2250		return tcp_ses;
2251
2252	tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2253	if (!tcp_ses) {
2254		rc = -ENOMEM;
2255		goto out_err;
2256	}
2257
2258	rc = cifs_crypto_shash_allocate(tcp_ses);
2259	if (rc) {
2260		cERROR(1, "could not setup hash structures rc %d", rc);
2261		goto out_err;
2262	}
2263
2264	tcp_ses->ops = volume_info->ops;
2265	tcp_ses->vals = volume_info->vals;
 
 
 
 
 
 
 
 
 
 
 
 
2266	cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2267	tcp_ses->hostname = extract_hostname(volume_info->UNC);
2268	if (IS_ERR(tcp_ses->hostname)) {
2269		rc = PTR_ERR(tcp_ses->hostname);
2270		goto out_err_crypto_release;
2271	}
2272
2273	tcp_ses->noblocksnd = volume_info->noblocksnd;
2274	tcp_ses->noautotune = volume_info->noautotune;
2275	tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
 
 
 
2276	tcp_ses->in_flight = 0;
 
2277	tcp_ses->credits = 1;
 
 
 
 
 
 
2278	init_waitqueue_head(&tcp_ses->response_q);
2279	init_waitqueue_head(&tcp_ses->request_q);
2280	INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2281	mutex_init(&tcp_ses->srv_mutex);
2282	memcpy(tcp_ses->workstation_RFC1001_name,
2283		volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2284	memcpy(tcp_ses->server_RFC1001_name,
2285		volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2286	tcp_ses->session_estab = false;
2287	tcp_ses->sequence_number = 0;
 
2288	tcp_ses->lstrp = jiffies;
 
2289	spin_lock_init(&tcp_ses->req_lock);
 
 
2290	INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2291	INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2292	INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2293
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2294	/*
2295	 * at this point we are the only ones with the pointer
2296	 * to the struct since the kernel thread not created yet
2297	 * no need to spinlock this init of tcpStatus or srv_count
2298	 */
2299	tcp_ses->tcpStatus = CifsNew;
2300	memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2301	       sizeof(tcp_ses->srcaddr));
2302	++tcp_ses->srv_count;
2303
2304	if (addr.ss_family == AF_INET6) {
2305		cFYI(1, "attempting ipv6 connect");
2306		/* BB should we allow ipv6 on port 139? */
2307		/* other OS never observed in Wild doing 139 with v6 */
2308		memcpy(&tcp_ses->dstaddr, sin_server6,
2309		       sizeof(struct sockaddr_in6));
2310	} else
2311		memcpy(&tcp_ses->dstaddr, sin_server,
2312		       sizeof(struct sockaddr_in));
2313
 
 
 
 
 
 
 
 
 
 
 
 
2314	rc = ip_connect(tcp_ses);
2315	if (rc < 0) {
2316		cERROR(1, "Error connecting to socket. Aborting operation");
2317		goto out_err_crypto_release;
2318	}
2319
2320	/*
2321	 * since we're in a cifs function already, we know that
2322	 * this will succeed. No need for try_module_get().
2323	 */
2324	__module_get(THIS_MODULE);
2325	tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2326				  tcp_ses, "cifsd");
2327	if (IS_ERR(tcp_ses->tsk)) {
2328		rc = PTR_ERR(tcp_ses->tsk);
2329		cERROR(1, "error %d create cifsd thread", rc);
2330		module_put(THIS_MODULE);
2331		goto out_err_crypto_release;
2332	}
 
 
 
 
 
 
 
2333	tcp_ses->tcpStatus = CifsNeedNegotiate;
 
 
 
 
 
 
2334
 
 
2335	/* thread spawned, put it on the list */
2336	spin_lock(&cifs_tcp_ses_lock);
2337	list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2338	spin_unlock(&cifs_tcp_ses_lock);
2339
2340	cifs_fscache_get_client_cookie(tcp_ses);
 
 
 
 
 
2341
2342	/* queue echo request delayed work */
2343	queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2344
2345	return tcp_ses;
2346
2347out_err_crypto_release:
2348	cifs_crypto_shash_release(tcp_ses);
2349
2350	put_net(cifs_net_ns(tcp_ses));
2351
2352out_err:
2353	if (tcp_ses) {
2354		if (!IS_ERR(tcp_ses->hostname))
2355			kfree(tcp_ses->hostname);
 
 
2356		if (tcp_ses->ssocket)
2357			sock_release(tcp_ses->ssocket);
2358		kfree(tcp_ses);
2359	}
2360	return ERR_PTR(rc);
2361}
2362
2363static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
 
2364{
2365	switch (ses->server->secType) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2366	case Kerberos:
2367		if (vol->cred_uid != ses->cred_uid)
2368			return 0;
2369		break;
2370	default:
2371		/* NULL username means anonymous session */
2372		if (ses->user_name == NULL) {
2373			if (!vol->nullauth)
2374				return 0;
2375			break;
2376		}
2377
2378		/* anything else takes username/password */
2379		if (strncmp(ses->user_name,
2380			    vol->username ? vol->username : "",
2381			    MAX_USERNAME_SIZE))
2382			return 0;
2383		if (strlen(vol->username) != 0 &&
2384		    ses->password != NULL &&
2385		    strncmp(ses->password,
2386			    vol->password ? vol->password : "",
2387			    MAX_PASSWORD_SIZE))
2388			return 0;
2389	}
2390	return 1;
2391}
2392
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2393static struct cifs_ses *
2394cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2395{
2396	struct cifs_ses *ses;
2397
2398	spin_lock(&cifs_tcp_ses_lock);
2399	list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2400		if (!match_session(ses, vol))
 
 
 
 
 
 
2401			continue;
 
 
 
2402		++ses->ses_count;
2403		spin_unlock(&cifs_tcp_ses_lock);
2404		return ses;
2405	}
2406	spin_unlock(&cifs_tcp_ses_lock);
2407	return NULL;
2408}
2409
2410static void
2411cifs_put_smb_ses(struct cifs_ses *ses)
2412{
2413	int xid;
 
2414	struct TCP_Server_Info *server = ses->server;
2415
2416	cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
 
 
 
 
 
 
 
 
 
 
2417	spin_lock(&cifs_tcp_ses_lock);
2418	if (--ses->ses_count > 0) {
2419		spin_unlock(&cifs_tcp_ses_lock);
2420		return;
2421	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2422
 
2423	list_del_init(&ses->smb_ses_list);
2424	spin_unlock(&cifs_tcp_ses_lock);
2425
2426	if (ses->status == CifsGood) {
2427		xid = GetXid();
2428		CIFSSMBLogoff(xid, ses);
2429		_FreeXid(xid);
 
 
 
 
 
 
 
 
 
 
2430	}
 
2431	sesInfoFree(ses);
2432	cifs_put_tcp_session(server);
2433}
2434
2435#ifdef CONFIG_KEYS
2436
2437/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2438#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2439
2440/* Populate username and pw fields from keyring if possible */
2441static int
2442cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2443{
2444	int rc = 0;
2445	char *desc, *delim, *payload;
 
 
2446	ssize_t len;
2447	struct key *key;
2448	struct TCP_Server_Info *server = ses->server;
2449	struct sockaddr_in *sa;
2450	struct sockaddr_in6 *sa6;
2451	struct user_key_payload *upayload;
2452
2453	desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2454	if (!desc)
2455		return -ENOMEM;
2456
2457	/* try to find an address key first */
2458	switch (server->dstaddr.ss_family) {
2459	case AF_INET:
2460		sa = (struct sockaddr_in *)&server->dstaddr;
2461		sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2462		break;
2463	case AF_INET6:
2464		sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2465		sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2466		break;
2467	default:
2468		cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
 
2469		rc = -EINVAL;
2470		goto out_err;
2471	}
2472
2473	cFYI(1, "%s: desc=%s", __func__, desc);
2474	key = request_key(&key_type_logon, desc, "");
2475	if (IS_ERR(key)) {
2476		if (!ses->domainName) {
2477			cFYI(1, "domainName is NULL");
2478			rc = PTR_ERR(key);
2479			goto out_err;
2480		}
2481
2482		/* didn't work, try to find a domain key */
2483		sprintf(desc, "cifs:d:%s", ses->domainName);
2484		cFYI(1, "%s: desc=%s", __func__, desc);
2485		key = request_key(&key_type_logon, desc, "");
2486		if (IS_ERR(key)) {
2487			rc = PTR_ERR(key);
2488			goto out_err;
2489		}
 
2490	}
2491
2492	down_read(&key->sem);
2493	upayload = key->payload.data;
2494	if (IS_ERR_OR_NULL(upayload)) {
2495		rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2496		goto out_key_put;
2497	}
2498
2499	/* find first : in payload */
2500	payload = (char *)upayload->data;
2501	delim = strnchr(payload, upayload->datalen, ':');
2502	cFYI(1, "payload=%s", payload);
2503	if (!delim) {
2504		cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2505				upayload->datalen);
2506		rc = -EINVAL;
2507		goto out_key_put;
2508	}
2509
2510	len = delim - payload;
2511	if (len > MAX_USERNAME_SIZE || len <= 0) {
2512		cFYI(1, "Bad value from username search (len=%zd)", len);
 
2513		rc = -EINVAL;
2514		goto out_key_put;
2515	}
2516
2517	vol->username = kstrndup(payload, len, GFP_KERNEL);
2518	if (!vol->username) {
2519		cFYI(1, "Unable to allocate %zd bytes for username", len);
 
2520		rc = -ENOMEM;
2521		goto out_key_put;
2522	}
2523	cFYI(1, "%s: username=%s", __func__, vol->username);
2524
2525	len = key->datalen - (len + 1);
2526	if (len > MAX_PASSWORD_SIZE || len <= 0) {
2527		cFYI(1, "Bad len for password search (len=%zd)", len);
2528		rc = -EINVAL;
2529		kfree(vol->username);
2530		vol->username = NULL;
2531		goto out_key_put;
2532	}
2533
2534	++delim;
2535	vol->password = kstrndup(delim, len, GFP_KERNEL);
2536	if (!vol->password) {
2537		cFYI(1, "Unable to allocate %zd bytes for password", len);
 
2538		rc = -ENOMEM;
2539		kfree(vol->username);
2540		vol->username = NULL;
2541		goto out_key_put;
2542	}
2543
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2544out_key_put:
2545	up_read(&key->sem);
2546	key_put(key);
2547out_err:
2548	kfree(desc);
2549	cFYI(1, "%s: returning %d", __func__, rc);
2550	return rc;
2551}
2552#else /* ! CONFIG_KEYS */
2553static inline int
2554cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2555		   struct cifs_ses *ses __attribute__((unused)))
2556{
2557	return -ENOSYS;
2558}
2559#endif /* CONFIG_KEYS */
2560
2561static bool warned_on_ntlm;  /* globals init to false automatically */
2562
2563static struct cifs_ses *
2564cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
 
 
 
 
 
 
 
2565{
2566	int rc = -ENOMEM, xid;
 
2567	struct cifs_ses *ses;
2568	struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2569	struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2570
2571	xid = GetXid();
2572
2573	ses = cifs_find_smb_ses(server, volume_info);
2574	if (ses) {
2575		cFYI(1, "Existing smb sess found (status=%d)", ses->status);
 
2576
2577		mutex_lock(&ses->session_mutex);
2578		rc = cifs_negotiate_protocol(xid, ses);
2579		if (rc) {
2580			mutex_unlock(&ses->session_mutex);
2581			/* problem -- put our ses reference */
2582			cifs_put_smb_ses(ses);
2583			FreeXid(xid);
2584			return ERR_PTR(rc);
2585		}
2586		if (ses->need_reconnect) {
2587			cFYI(1, "Session needs reconnect");
2588			rc = cifs_setup_session(xid, ses,
2589						volume_info->local_nls);
 
 
 
 
2590			if (rc) {
2591				mutex_unlock(&ses->session_mutex);
2592				/* problem -- put our reference */
2593				cifs_put_smb_ses(ses);
2594				FreeXid(xid);
2595				return ERR_PTR(rc);
2596			}
 
 
 
2597		}
2598		mutex_unlock(&ses->session_mutex);
2599
2600		/* existing SMB ses has a server reference already */
2601		cifs_put_tcp_session(server);
2602		FreeXid(xid);
2603		return ses;
2604	}
2605
2606	cFYI(1, "Existing smb sess not found");
 
 
2607	ses = sesInfoAlloc();
2608	if (ses == NULL)
2609		goto get_ses_fail;
2610
2611	/* new SMB session uses our server ref */
2612	ses->server = server;
2613	if (server->dstaddr.ss_family == AF_INET6)
2614		sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2615	else
2616		sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2617
2618	if (volume_info->username) {
2619		ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2620		if (!ses->user_name)
2621			goto get_ses_fail;
2622	}
2623
2624	/* volume_info->password freed at unmount */
2625	if (volume_info->password) {
2626		ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2627		if (!ses->password)
2628			goto get_ses_fail;
2629	}
2630	if (volume_info->domainname) {
2631		ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2632		if (!ses->domainName)
2633			goto get_ses_fail;
2634	}
2635	ses->cred_uid = volume_info->cred_uid;
2636	ses->linux_uid = volume_info->linux_uid;
2637
2638	/* ntlmv2 is much stronger than ntlm security, and has been broadly
2639	supported for many years, time to update default security mechanism */
2640	if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2641		warned_on_ntlm = true;
2642		cERROR(1, "default security mechanism requested.  The default "
2643			"security mechanism will be upgraded from ntlm to "
2644			"ntlmv2 in kernel release 3.3");
2645	}
2646	ses->overrideSecFlg = volume_info->secFlg;
 
 
 
 
 
 
 
 
2647
2648	mutex_lock(&ses->session_mutex);
2649	rc = cifs_negotiate_protocol(xid, ses);
2650	if (!rc)
2651		rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2652	mutex_unlock(&ses->session_mutex);
 
 
 
 
 
 
 
2653	if (rc)
2654		goto get_ses_fail;
2655
2656	/* success, put it on the list */
 
 
 
 
2657	spin_lock(&cifs_tcp_ses_lock);
2658	list_add(&ses->smb_ses_list, &server->smb_ses_list);
2659	spin_unlock(&cifs_tcp_ses_lock);
2660
2661	FreeXid(xid);
 
 
 
2662	return ses;
2663
2664get_ses_fail:
2665	sesInfoFree(ses);
2666	FreeXid(xid);
2667	return ERR_PTR(rc);
2668}
2669
2670static int match_tcon(struct cifs_tcon *tcon, const char *unc)
 
2671{
2672	if (tcon->tidStatus == CifsExiting)
 
 
 
2673		return 0;
2674	if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
 
 
 
 
 
 
 
 
2675		return 0;
2676	return 1;
2677}
2678
2679static struct cifs_tcon *
2680cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2681{
2682	struct list_head *tmp;
2683	struct cifs_tcon *tcon;
2684
2685	spin_lock(&cifs_tcp_ses_lock);
2686	list_for_each(tmp, &ses->tcon_list) {
2687		tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2688		if (!match_tcon(tcon, unc))
 
2689			continue;
 
2690		++tcon->tc_count;
 
2691		spin_unlock(&cifs_tcp_ses_lock);
2692		return tcon;
2693	}
2694	spin_unlock(&cifs_tcp_ses_lock);
2695	return NULL;
2696}
2697
2698static void
2699cifs_put_tcon(struct cifs_tcon *tcon)
2700{
2701	int xid;
2702	struct cifs_ses *ses = tcon->ses;
 
 
 
 
 
 
 
2703
2704	cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
 
2705	spin_lock(&cifs_tcp_ses_lock);
 
2706	if (--tcon->tc_count > 0) {
 
2707		spin_unlock(&cifs_tcp_ses_lock);
2708		return;
2709	}
2710
 
 
 
2711	list_del_init(&tcon->tcon_list);
 
2712	spin_unlock(&cifs_tcp_ses_lock);
2713
2714	xid = GetXid();
2715	CIFSSMBTDis(xid, tcon);
2716	_FreeXid(xid);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2717
2718	cifs_fscache_release_super_cookie(tcon);
2719	tconInfoFree(tcon);
2720	cifs_put_smb_ses(ses);
2721}
2722
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2723static struct cifs_tcon *
2724cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2725{
2726	int rc, xid;
2727	struct cifs_tcon *tcon;
2728
2729	tcon = cifs_find_tcon(ses, volume_info->UNC);
2730	if (tcon) {
2731		cFYI(1, "Found match on UNC path");
2732		/* existing tcon already has a reference */
 
 
 
2733		cifs_put_smb_ses(ses);
2734		if (tcon->seal != volume_info->seal)
2735			cERROR(1, "transport encryption setting "
2736				   "conflicts with existing tid");
2737		return tcon;
2738	}
2739
 
 
 
 
 
2740	tcon = tconInfoAlloc();
2741	if (tcon == NULL) {
2742		rc = -ENOMEM;
2743		goto out_fail;
2744	}
2745
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2746	tcon->ses = ses;
2747	if (volume_info->password) {
2748		tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2749		if (!tcon->password) {
2750			rc = -ENOMEM;
2751			goto out_fail;
2752		}
2753	}
2754
2755	if (strchr(volume_info->UNC + 3, '\\') == NULL
2756	    && strchr(volume_info->UNC + 3, '/') == NULL) {
2757		cERROR(1, "Missing share name");
2758		rc = -ENODEV;
2759		goto out_fail;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2760	}
2761
2762	/* BB Do we need to wrap session_mutex around
2763	 * this TCon call and Unix SetFS as
2764	 * we do on SessSetup and reconnect? */
2765	xid = GetXid();
2766	rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2767	FreeXid(xid);
2768	cFYI(1, "CIFS Tcon rc = %d", rc);
2769	if (rc)
2770		goto out_fail;
2771
2772	if (volume_info->nodfs) {
2773		tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2774		cFYI(1, "DFS disabled (%d)", tcon->Flags);
2775	}
2776	tcon->seal = volume_info->seal;
2777	/* we can have only one retry value for a connection
2778	   to a share so for resources mounted more than once
2779	   to the same server share the last value passed in
2780	   for the retry flag is used */
2781	tcon->retry = volume_info->retry;
2782	tcon->nocase = volume_info->nocase;
2783	tcon->local_lease = volume_info->local_lease;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2784
2785	spin_lock(&cifs_tcp_ses_lock);
2786	list_add(&tcon->tcon_list, &ses->tcon_list);
2787	spin_unlock(&cifs_tcp_ses_lock);
2788
2789	cifs_fscache_get_super_cookie(tcon);
2790
2791	return tcon;
2792
2793out_fail:
2794	tconInfoFree(tcon);
2795	return ERR_PTR(rc);
2796}
2797
2798void
2799cifs_put_tlink(struct tcon_link *tlink)
2800{
2801	if (!tlink || IS_ERR(tlink))
2802		return;
2803
2804	if (!atomic_dec_and_test(&tlink->tl_count) ||
2805	    test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2806		tlink->tl_time = jiffies;
2807		return;
2808	}
2809
2810	if (!IS_ERR(tlink_tcon(tlink)))
2811		cifs_put_tcon(tlink_tcon(tlink));
2812	kfree(tlink);
2813	return;
2814}
2815
2816static inline struct tcon_link *
2817cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2818{
2819	return cifs_sb->master_tlink;
2820}
2821
2822static int
2823compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2824{
2825	struct cifs_sb_info *old = CIFS_SB(sb);
2826	struct cifs_sb_info *new = mnt_data->cifs_sb;
 
 
2827
2828	if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2829		return 0;
2830
2831	if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2832	    (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
 
 
2833		return 0;
2834
2835	/*
2836	 * We want to share sb only if we don't specify an r/wsize or
2837	 * specified r/wsize is greater than or equal to existing one.
2838	 */
2839	if (new->wsize && new->wsize < old->wsize)
2840		return 0;
2841
2842	if (new->rsize && new->rsize < old->rsize)
2843		return 0;
2844
2845	if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
 
2846		return 0;
2847
2848	if (old->mnt_file_mode != new->mnt_file_mode ||
2849	    old->mnt_dir_mode != new->mnt_dir_mode)
2850		return 0;
2851
2852	if (strcmp(old->local_nls->charset, new->local_nls->charset))
2853		return 0;
2854
2855	if (old->actimeo != new->actimeo)
 
 
 
 
2856		return 0;
2857
2858	return 1;
2859}
2860
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2861int
2862cifs_match_super(struct super_block *sb, void *data)
2863{
2864	struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2865	struct smb_vol *volume_info;
2866	struct cifs_sb_info *cifs_sb;
2867	struct TCP_Server_Info *tcp_srv;
2868	struct cifs_ses *ses;
2869	struct cifs_tcon *tcon;
2870	struct tcon_link *tlink;
2871	struct sockaddr_storage addr;
2872	int rc = 0;
2873
2874	memset(&addr, 0, sizeof(struct sockaddr_storage));
2875
2876	spin_lock(&cifs_tcp_ses_lock);
2877	cifs_sb = CIFS_SB(sb);
2878	tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2879	if (IS_ERR(tlink)) {
 
2880		spin_unlock(&cifs_tcp_ses_lock);
2881		return rc;
2882	}
2883	tcon = tlink_tcon(tlink);
2884	ses = tcon->ses;
2885	tcp_srv = ses->server;
2886
2887	volume_info = mnt_data->vol;
2888
2889	if (!volume_info->UNCip || !volume_info->UNC)
2890		goto out;
2891
2892	rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2893				volume_info->UNCip,
2894				strlen(volume_info->UNCip),
2895				volume_info->port);
2896	if (!rc)
2897		goto out;
2898
2899	if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2900	    !match_session(ses, volume_info) ||
2901	    !match_tcon(tcon, volume_info->UNC)) {
 
 
 
 
2902		rc = 0;
2903		goto out;
2904	}
2905
2906	rc = compare_mount_options(sb, mnt_data);
2907out:
 
 
 
 
2908	spin_unlock(&cifs_tcp_ses_lock);
2909	cifs_put_tlink(tlink);
2910	return rc;
2911}
2912
2913int
2914get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2915	     const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2916	     struct dfs_info3_param **preferrals, int remap)
2917{
2918	char *temp_unc;
2919	int rc = 0;
2920
2921	*pnum_referrals = 0;
2922	*preferrals = NULL;
2923
2924	if (pSesInfo->ipc_tid == 0) {
2925		temp_unc = kmalloc(2 /* for slashes */ +
2926			strnlen(pSesInfo->serverName,
2927				SERVER_NAME_LEN_WITH_NULL * 2)
2928				 + 1 + 4 /* slash IPC$ */  + 2,
2929				GFP_KERNEL);
2930		if (temp_unc == NULL)
2931			return -ENOMEM;
2932		temp_unc[0] = '\\';
2933		temp_unc[1] = '\\';
2934		strcpy(temp_unc + 2, pSesInfo->serverName);
2935		strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2936		rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2937		cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2938		kfree(temp_unc);
2939	}
2940	if (rc == 0)
2941		rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2942				     pnum_referrals, nls_codepage, remap);
2943	/* BB map targetUNCs to dfs_info3 structures, here or
2944		in CIFSGetDFSRefer BB */
2945
2946	return rc;
2947}
2948
2949#ifdef CONFIG_DEBUG_LOCK_ALLOC
2950static struct lock_class_key cifs_key[2];
2951static struct lock_class_key cifs_slock_key[2];
2952
2953static inline void
2954cifs_reclassify_socket4(struct socket *sock)
2955{
2956	struct sock *sk = sock->sk;
2957	BUG_ON(sock_owned_by_user(sk));
2958	sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2959		&cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2960}
2961
2962static inline void
2963cifs_reclassify_socket6(struct socket *sock)
2964{
2965	struct sock *sk = sock->sk;
2966	BUG_ON(sock_owned_by_user(sk));
2967	sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2968		&cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2969}
2970#else
2971static inline void
2972cifs_reclassify_socket4(struct socket *sock)
2973{
2974}
2975
2976static inline void
2977cifs_reclassify_socket6(struct socket *sock)
2978{
2979}
2980#endif
2981
2982/* See RFC1001 section 14 on representation of Netbios names */
2983static void rfc1002mangle(char *target, char *source, unsigned int length)
2984{
2985	unsigned int i, j;
2986
2987	for (i = 0, j = 0; i < (length); i++) {
2988		/* mask a nibble at a time and encode */
2989		target[j] = 'A' + (0x0F & (source[i] >> 4));
2990		target[j+1] = 'A' + (0x0F & source[i]);
2991		j += 2;
2992	}
2993
2994}
2995
2996static int
2997bind_socket(struct TCP_Server_Info *server)
2998{
2999	int rc = 0;
3000	if (server->srcaddr.ss_family != AF_UNSPEC) {
3001		/* Bind to the specified local IP address */
3002		struct socket *socket = server->ssocket;
3003		rc = socket->ops->bind(socket,
3004				       (struct sockaddr *) &server->srcaddr,
3005				       sizeof(server->srcaddr));
3006		if (rc < 0) {
3007			struct sockaddr_in *saddr4;
3008			struct sockaddr_in6 *saddr6;
3009			saddr4 = (struct sockaddr_in *)&server->srcaddr;
3010			saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3011			if (saddr6->sin6_family == AF_INET6)
3012				cERROR(1, "cifs: "
3013				       "Failed to bind to: %pI6c, error: %d\n",
3014				       &saddr6->sin6_addr, rc);
3015			else
3016				cERROR(1, "cifs: "
3017				       "Failed to bind to: %pI4, error: %d\n",
3018				       &saddr4->sin_addr.s_addr, rc);
3019		}
3020	}
3021	return rc;
3022}
3023
3024static int
3025ip_rfc1001_connect(struct TCP_Server_Info *server)
3026{
3027	int rc = 0;
3028	/*
3029	 * some servers require RFC1001 sessinit before sending
3030	 * negprot - BB check reconnection in case where second
3031	 * sessinit is sent but no second negprot
3032	 */
3033	struct rfc1002_session_packet *ses_init_buf;
 
3034	struct smb_hdr *smb_buf;
 
3035	ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3036			       GFP_KERNEL);
 
3037	if (ses_init_buf) {
3038		ses_init_buf->trailer.session_req.called_len = 32;
3039
3040		if (server->server_RFC1001_name &&
3041		    server->server_RFC1001_name[0] != 0)
3042			rfc1002mangle(ses_init_buf->trailer.
3043				      session_req.called_name,
3044				      server->server_RFC1001_name,
3045				      RFC1001_NAME_LEN_WITH_NULL);
3046		else
3047			rfc1002mangle(ses_init_buf->trailer.
3048				      session_req.called_name,
3049				      DEFAULT_CIFS_CALLED_NAME,
3050				      RFC1001_NAME_LEN_WITH_NULL);
3051
3052		ses_init_buf->trailer.session_req.calling_len = 32;
3053
3054		/*
3055		 * calling name ends in null (byte 16) from old smb
3056		 * convention.
3057		 */
3058		if (server->workstation_RFC1001_name &&
3059		    server->workstation_RFC1001_name[0] != 0)
3060			rfc1002mangle(ses_init_buf->trailer.
3061				      session_req.calling_name,
3062				      server->workstation_RFC1001_name,
3063				      RFC1001_NAME_LEN_WITH_NULL);
3064		else
3065			rfc1002mangle(ses_init_buf->trailer.
3066				      session_req.calling_name,
3067				      "LINUX_CIFS_CLNT",
3068				      RFC1001_NAME_LEN_WITH_NULL);
3069
3070		ses_init_buf->trailer.session_req.scope1 = 0;
3071		ses_init_buf->trailer.session_req.scope2 = 0;
3072		smb_buf = (struct smb_hdr *)ses_init_buf;
3073
3074		/* sizeof RFC1002_SESSION_REQUEST with no scope */
3075		smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
 
 
 
 
3076		rc = smb_send(server, smb_buf, 0x44);
3077		kfree(ses_init_buf);
3078		/*
3079		 * RFC1001 layer in at least one server
3080		 * requires very short break before negprot
3081		 * presumably because not expecting negprot
3082		 * to follow so fast.  This is a simple
3083		 * solution that works without
3084		 * complicating the code and causes no
3085		 * significant slowing down on mount
3086		 * for everyone else
3087		 */
3088		usleep_range(1000, 2000);
3089	}
3090	/*
3091	 * else the negprot may still work without this
3092	 * even though malloc failed
3093	 */
3094
3095	return rc;
3096}
3097
3098static int
3099generic_ip_connect(struct TCP_Server_Info *server)
3100{
3101	int rc = 0;
3102	__be16 sport;
3103	int slen, sfamily;
3104	struct socket *socket = server->ssocket;
3105	struct sockaddr *saddr;
3106
3107	saddr = (struct sockaddr *) &server->dstaddr;
3108
3109	if (server->dstaddr.ss_family == AF_INET6) {
3110		sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
 
 
3111		slen = sizeof(struct sockaddr_in6);
3112		sfamily = AF_INET6;
 
 
3113	} else {
3114		sport = ((struct sockaddr_in *) saddr)->sin_port;
 
 
3115		slen = sizeof(struct sockaddr_in);
3116		sfamily = AF_INET;
 
 
3117	}
3118
3119	if (socket == NULL) {
3120		rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3121				   IPPROTO_TCP, &socket, 1);
3122		if (rc < 0) {
3123			cERROR(1, "Error %d creating socket", rc);
3124			server->ssocket = NULL;
3125			return rc;
3126		}
3127
3128		/* BB other socket options to set KEEPALIVE, NODELAY? */
3129		cFYI(1, "Socket created");
3130		server->ssocket = socket;
3131		socket->sk->sk_allocation = GFP_NOFS;
 
3132		if (sfamily == AF_INET6)
3133			cifs_reclassify_socket6(socket);
3134		else
3135			cifs_reclassify_socket4(socket);
3136	}
3137
3138	rc = bind_socket(server);
3139	if (rc < 0)
3140		return rc;
3141
3142	/*
3143	 * Eventually check for other socket options to change from
3144	 * the default. sock_setsockopt not used because it expects
3145	 * user space buffer
3146	 */
3147	socket->sk->sk_rcvtimeo = 7 * HZ;
3148	socket->sk->sk_sndtimeo = 5 * HZ;
3149
3150	/* make the bufsizes depend on wsize/rsize and max requests */
3151	if (server->noautotune) {
3152		if (socket->sk->sk_sndbuf < (200 * 1024))
3153			socket->sk->sk_sndbuf = 200 * 1024;
3154		if (socket->sk->sk_rcvbuf < (140 * 1024))
3155			socket->sk->sk_rcvbuf = 140 * 1024;
3156	}
3157
3158	if (server->tcp_nodelay) {
3159		int val = 1;
3160		rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3161				(char *)&val, sizeof(val));
3162		if (rc)
3163			cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3164	}
3165
3166	 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3167		 socket->sk->sk_sndbuf,
3168		 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3169
3170	rc = socket->ops->connect(socket, saddr, slen, 0);
 
 
 
 
 
 
 
 
3171	if (rc < 0) {
3172		cFYI(1, "Error %d connecting to server", rc);
 
3173		sock_release(socket);
3174		server->ssocket = NULL;
3175		return rc;
3176	}
3177
3178	if (sport == htons(RFC1001_PORT))
3179		rc = ip_rfc1001_connect(server);
3180
3181	return rc;
3182}
3183
3184static int
3185ip_connect(struct TCP_Server_Info *server)
3186{
3187	__be16 *sport;
3188	struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3189	struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3190
3191	if (server->dstaddr.ss_family == AF_INET6)
3192		sport = &addr6->sin6_port;
3193	else
3194		sport = &addr->sin_port;
3195
3196	if (*sport == 0) {
3197		int rc;
3198
3199		/* try with 445 port at first */
3200		*sport = htons(CIFS_PORT);
3201
3202		rc = generic_ip_connect(server);
3203		if (rc >= 0)
3204			return rc;
3205
3206		/* if it failed, try with 139 port */
3207		*sport = htons(RFC1001_PORT);
3208	}
3209
3210	return generic_ip_connect(server);
3211}
3212
3213void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
3214			  struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
 
3215{
3216	/* if we are reconnecting then should we check to see if
 
3217	 * any requested capabilities changed locally e.g. via
3218	 * remount but we can not do much about it here
3219	 * if they have (even if we could detect it by the following)
3220	 * Perhaps we could add a backpointer to array of sb from tcon
3221	 * or if we change to make all sb to same share the same
3222	 * sb as NFS - then we only have one backpointer to sb.
3223	 * What if we wanted to mount the server share twice once with
3224	 * and once without posixacls or posix paths? */
 
3225	__u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3226
3227	if (vol_info && vol_info->no_linux_ext) {
3228		tcon->fsUnixInfo.Capability = 0;
3229		tcon->unix_ext = 0; /* Unix Extensions disabled */
3230		cFYI(1, "Linux protocol extensions disabled");
3231		return;
3232	} else if (vol_info)
3233		tcon->unix_ext = 1; /* Unix Extensions supported */
3234
3235	if (tcon->unix_ext == 0) {
3236		cFYI(1, "Unix extensions disabled so not set on reconnect");
3237		return;
3238	}
3239
3240	if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3241		__u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3242		cFYI(1, "unix caps which server supports %lld", cap);
3243		/* check for reconnect case in which we do not
3244		   want to change the mount behavior if we can avoid it */
3245		if (vol_info == NULL) {
3246			/* turn off POSIX ACL and PATHNAMES if not set
3247			   originally at mount time */
 
 
 
 
3248			if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3249				cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3250			if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3251				if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3252					cERROR(1, "POSIXPATH support change");
3253				cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3254			} else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3255				cERROR(1, "possible reconnect error");
3256				cERROR(1, "server disabled POSIX path support");
3257			}
3258		}
3259
3260		if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3261			cERROR(1, "per-share encryption not supported yet");
3262
3263		cap &= CIFS_UNIX_CAP_MASK;
3264		if (vol_info && vol_info->no_psx_acl)
3265			cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3266		else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3267			cFYI(1, "negotiated posix acl support");
3268			if (cifs_sb)
3269				cifs_sb->mnt_cifs_flags |=
3270					CIFS_MOUNT_POSIXACL;
3271		}
3272
3273		if (vol_info && vol_info->posix_paths == 0)
3274			cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3275		else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3276			cFYI(1, "negotiate posix pathnames");
3277			if (cifs_sb)
3278				cifs_sb->mnt_cifs_flags |=
3279					CIFS_MOUNT_POSIX_PATHS;
3280		}
3281
3282		cFYI(1, "Negotiate caps 0x%x", (int)cap);
3283#ifdef CONFIG_CIFS_DEBUG2
3284		if (cap & CIFS_UNIX_FCNTL_CAP)
3285			cFYI(1, "FCNTL cap");
3286		if (cap & CIFS_UNIX_EXTATTR_CAP)
3287			cFYI(1, "EXTATTR cap");
3288		if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3289			cFYI(1, "POSIX path cap");
3290		if (cap & CIFS_UNIX_XATTR_CAP)
3291			cFYI(1, "XATTR cap");
3292		if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3293			cFYI(1, "POSIX ACL cap");
3294		if (cap & CIFS_UNIX_LARGE_READ_CAP)
3295			cFYI(1, "very large read cap");
3296		if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3297			cFYI(1, "very large write cap");
3298		if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3299			cFYI(1, "transport encryption cap");
3300		if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3301			cFYI(1, "mandatory transport encryption cap");
3302#endif /* CIFS_DEBUG2 */
3303		if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3304			if (vol_info == NULL) {
3305				cFYI(1, "resetting capabilities failed");
3306			} else
3307				cERROR(1, "Negotiating Unix capabilities "
3308					   "with the server failed.  Consider "
3309					   "mounting with the Unix Extensions\n"
3310					   "disabled, if problems are found, "
3311					   "by specifying the nounix mount "
3312					   "option.");
3313
3314		}
3315	}
3316}
 
3317
3318void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3319			struct cifs_sb_info *cifs_sb)
3320{
 
 
3321	INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3322
3323	spin_lock_init(&cifs_sb->tlink_tree_lock);
3324	cifs_sb->tlink_tree = RB_ROOT;
3325
3326	/*
3327	 * Temporarily set r/wsize for matching superblock. If we end up using
3328	 * new sb then client will later negotiate it downward if needed.
3329	 */
3330	cifs_sb->rsize = pvolume_info->rsize;
3331	cifs_sb->wsize = pvolume_info->wsize;
3332
3333	cifs_sb->mnt_uid = pvolume_info->linux_uid;
3334	cifs_sb->mnt_gid = pvolume_info->linux_gid;
3335	cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3336	cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3337	cFYI(1, "file mode: 0x%hx  dir mode: 0x%hx",
3338		cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3339
3340	cifs_sb->actimeo = pvolume_info->actimeo;
3341	cifs_sb->local_nls = pvolume_info->local_nls;
3342
3343	if (pvolume_info->noperm)
3344		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3345	if (pvolume_info->setuids)
3346		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3347	if (pvolume_info->server_ino)
3348		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3349	if (pvolume_info->remap)
3350		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3351	if (pvolume_info->no_xattr)
3352		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3353	if (pvolume_info->sfu_emul)
3354		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3355	if (pvolume_info->nobrl)
3356		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3357	if (pvolume_info->nostrictsync)
3358		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3359	if (pvolume_info->mand_lock)
3360		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3361	if (pvolume_info->rwpidforward)
3362		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3363	if (pvolume_info->cifs_acl)
3364		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3365	if (pvolume_info->backupuid_specified) {
3366		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3367		cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3368	}
3369	if (pvolume_info->backupgid_specified) {
3370		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3371		cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3372	}
3373	if (pvolume_info->override_uid)
3374		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3375	if (pvolume_info->override_gid)
3376		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3377	if (pvolume_info->dynperm)
3378		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3379	if (pvolume_info->fsc)
3380		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3381	if (pvolume_info->multiuser)
3382		cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3383					    CIFS_MOUNT_NO_PERM);
3384	if (pvolume_info->strict_io)
3385		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3386	if (pvolume_info->direct_io) {
3387		cFYI(1, "mounting share using direct i/o");
3388		cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3389	}
3390	if (pvolume_info->mfsymlinks) {
3391		if (pvolume_info->sfu_emul) {
3392			cERROR(1,  "mount option mfsymlinks ignored if sfu "
3393				   "mount option is used");
3394		} else {
3395			cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3396		}
3397	}
 
3398
3399	if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3400		cERROR(1, "mount option dynperm ignored if cifsacl "
3401			   "mount option supported");
3402}
3403
3404/*
3405 * When the server supports very large reads and writes via POSIX extensions,
3406 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3407 * including the RFC1001 length.
3408 *
3409 * Note that this might make for "interesting" allocation problems during
3410 * writeback however as we have to allocate an array of pointers for the
3411 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3412 *
3413 * For reads, there is a similar problem as we need to allocate an array
3414 * of kvecs to handle the receive, though that should only need to be done
3415 * once.
3416 */
3417#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3418#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
 
 
 
 
 
3419
3420/*
3421 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3422 * of 2^17-1 minus the size of the call header. That allows for a read or
3423 * write up to the maximum size described by RFC1002.
3424 */
3425#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3426#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3427
3428/*
3429 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3430 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3431 * a single wsize request with a single call.
3432 */
3433#define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3434
3435/*
3436 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3437 * those values when posix extensions aren't in force. In actuality here, we
3438 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3439 * to be ok with the extra byte even though Windows doesn't send writes that
3440 * are that large.
3441 *
3442 * Citation:
3443 *
3444 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3445 */
3446#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3447#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
 
 
 
 
3448
3449/*
3450 * On hosts with high memory, we can't currently support wsize/rsize that are
3451 * larger than we can kmap at once. Cap the rsize/wsize at
3452 * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
3453 * larger than that anyway.
3454 */
3455#ifdef CONFIG_HIGHMEM
3456#define CIFS_KMAP_SIZE_LIMIT	(LAST_PKMAP * PAGE_CACHE_SIZE)
3457#else /* CONFIG_HIGHMEM */
3458#define CIFS_KMAP_SIZE_LIMIT	(1<<24)
3459#endif /* CONFIG_HIGHMEM */
3460
3461static unsigned int
3462cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3463{
3464	__u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3465	struct TCP_Server_Info *server = tcon->ses->server;
3466	unsigned int wsize;
3467
3468	/* start with specified wsize, or default */
3469	if (pvolume_info->wsize)
3470		wsize = pvolume_info->wsize;
3471	else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3472		wsize = CIFS_DEFAULT_IOSIZE;
3473	else
3474		wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3475
3476	/* can server support 24-bit write sizes? (via UNIX extensions) */
3477	if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3478		wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
 
 
 
 
3479
3480	/*
3481	 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3482	 * Limit it to max buffer offered by the server, minus the size of the
3483	 * WRITEX header, not including the 4 byte RFC1001 length.
3484	 */
3485	if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3486	    (!(server->capabilities & CAP_UNIX) &&
3487	     (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3488		wsize = min_t(unsigned int, wsize,
3489				server->maxBuf - sizeof(WRITE_REQ) + 4);
3490
3491	/* limit to the amount that we can kmap at once */
3492	wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
 
 
 
3493
3494	/* hard limit of CIFS_MAX_WSIZE */
3495	wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
 
 
 
3496
3497	return wsize;
3498}
3499
3500static unsigned int
3501cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3502{
3503	__u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3504	struct TCP_Server_Info *server = tcon->ses->server;
3505	unsigned int rsize, defsize;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3506
3507	/*
3508	 * Set default value...
3509	 *
3510	 * HACK alert! Ancient servers have very small buffers. Even though
3511	 * MS-CIFS indicates that servers are only limited by the client's
3512	 * bufsize for reads, testing against win98se shows that it throws
3513	 * INVALID_PARAMETER errors if you try to request too large a read.
3514	 * OS/2 just sends back short reads.
3515	 *
3516	 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
3517	 * it can't handle a read request larger than its MaxBufferSize either.
3518	 */
3519	if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3520		defsize = CIFS_DEFAULT_IOSIZE;
3521	else if (server->capabilities & CAP_LARGE_READ_X)
3522		defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3523	else
3524		defsize = server->maxBuf - sizeof(READ_RSP);
3525
3526	rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3527
3528	/*
3529	 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3530	 * the client's MaxBufferSize.
 
3531	 */
3532	if (!(server->capabilities & CAP_LARGE_READ_X))
3533		rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3534
3535	/* limit to the amount that we can kmap at once */
3536	rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
3537
3538	/* hard limit of CIFS_MAX_RSIZE */
3539	rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3540
3541	return rsize;
3542}
3543
3544static int
3545is_path_accessible(int xid, struct cifs_tcon *tcon,
3546		   struct cifs_sb_info *cifs_sb, const char *full_path)
3547{
3548	int rc;
3549	FILE_ALL_INFO *pfile_info;
3550
3551	pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3552	if (pfile_info == NULL)
 
3553		return -ENOMEM;
3554
3555	rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3556			      0 /* not legacy */, cifs_sb->local_nls,
3557			      cifs_sb->mnt_cifs_flags &
3558				CIFS_MOUNT_MAP_SPECIAL_CHR);
3559
3560	if (rc == -EOPNOTSUPP || rc == -EINVAL)
3561		rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3562				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3563				  CIFS_MOUNT_MAP_SPECIAL_CHR);
3564	kfree(pfile_info);
3565	return rc;
3566}
3567
3568static void
3569cleanup_volume_info_contents(struct smb_vol *volume_info)
3570{
3571	kfree(volume_info->username);
3572	kzfree(volume_info->password);
3573	if (volume_info->UNCip != volume_info->UNC + 2)
3574		kfree(volume_info->UNCip);
3575	kfree(volume_info->UNC);
3576	kfree(volume_info->domainname);
3577	kfree(volume_info->iocharset);
3578	kfree(volume_info->prepath);
3579}
3580
3581void
3582cifs_cleanup_volume_info(struct smb_vol *volume_info)
 
 
 
 
 
3583{
3584	if (!volume_info)
3585		return;
3586	cleanup_volume_info_contents(volume_info);
3587	kfree(volume_info);
3588}
3589
3590
3591#ifdef CONFIG_CIFS_DFS_UPCALL
3592/* build_path_to_root returns full path to root when
3593 * we do not have an exiting connection (tcon) */
3594static char *
3595build_unc_path_to_root(const struct smb_vol *vol,
3596		const struct cifs_sb_info *cifs_sb)
3597{
3598	char *full_path, *pos;
3599	unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3600	unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3601
3602	full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3603	if (full_path == NULL)
3604		return ERR_PTR(-ENOMEM);
3605
3606	strncpy(full_path, vol->UNC, unc_len);
3607	pos = full_path + unc_len;
3608
3609	if (pplen) {
3610		strncpy(pos, vol->prepath, pplen);
3611		pos += pplen;
 
 
 
 
 
 
 
3612	}
3613
3614	*pos = '\0'; /* add trailing null */
3615	convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3616	cFYI(1, "%s: full_path=%s", __func__, full_path);
3617	return full_path;
3618}
3619
3620/*
3621 * Perform a dfs referral query for a share and (optionally) prefix
3622 *
3623 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3624 * to a string containing updated options for the submount.  Otherwise it
3625 * will be left untouched.
3626 *
3627 * Returns the rc from get_dfs_path to the caller, which can be used to
3628 * determine whether there were referrals.
3629 */
3630static int
3631expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3632		    struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3633		    int check_prefix)
3634{
3635	int rc;
3636	unsigned int num_referrals = 0;
3637	struct dfs_info3_param *referrals = NULL;
3638	char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
 
 
 
3639
3640	full_path = build_unc_path_to_root(volume_info, cifs_sb);
3641	if (IS_ERR(full_path))
3642		return PTR_ERR(full_path);
3643
3644	/* For DFS paths, skip the first '\' of the UNC */
3645	ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
 
 
 
 
 
3646
3647	rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3648			  &num_referrals, &referrals,
3649			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3650
3651	if (!rc && num_referrals > 0) {
3652		char *fake_devname = NULL;
3653
3654		mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3655						   full_path + 1, referrals,
3656						   &fake_devname);
3657
3658		free_dfs_info_array(referrals, num_referrals);
3659
3660		if (IS_ERR(mdata)) {
3661			rc = PTR_ERR(mdata);
3662			mdata = NULL;
3663		} else {
3664			cleanup_volume_info_contents(volume_info);
3665			memset(volume_info, '\0', sizeof(*volume_info));
3666			rc = cifs_setup_volume_info(volume_info, mdata,
3667							fake_devname);
3668		}
3669		kfree(fake_devname);
3670		kfree(cifs_sb->mountdata);
3671		cifs_sb->mountdata = mdata;
3672	}
3673	kfree(full_path);
3674	return rc;
3675}
3676#endif
3677
3678static int
3679cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3680			const char *devname)
3681{
3682	int rc = 0;
3683
3684	if (cifs_parse_mount_options(mount_data, devname, volume_info))
3685		return -EINVAL;
3686
3687
3688	if (volume_info->nullauth) {
3689		cFYI(1, "Anonymous login");
3690		kfree(volume_info->username);
3691		volume_info->username = NULL;
3692	} else if (volume_info->username) {
3693		/* BB fixme parse for domain name here */
3694		cFYI(1, "Username: %s", volume_info->username);
3695	} else {
3696		cifserror("No username specified");
3697	/* In userspace mount helper we can get user name from alternate
3698	   locations such as env variables and files on disk */
3699		return -EINVAL;
3700	}
3701
3702	/* this is needed for ASCII cp to Unicode converts */
3703	if (volume_info->iocharset == NULL) {
3704		/* load_nls_default cannot return null */
3705		volume_info->local_nls = load_nls_default();
3706	} else {
3707		volume_info->local_nls = load_nls(volume_info->iocharset);
3708		if (volume_info->local_nls == NULL) {
3709			cERROR(1, "CIFS mount error: iocharset %s not found",
3710				 volume_info->iocharset);
3711			return -ELIBACC;
3712		}
3713	}
3714
 
 
3715	return rc;
3716}
3717
3718struct smb_vol *
3719cifs_get_volume_info(char *mount_data, const char *devname)
3720{
3721	int rc;
3722	struct smb_vol *volume_info;
3723
3724	volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3725	if (!volume_info)
3726		return ERR_PTR(-ENOMEM);
3727
3728	rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3729	if (rc) {
3730		cifs_cleanup_volume_info(volume_info);
3731		volume_info = ERR_PTR(rc);
3732	}
3733
3734	return volume_info;
3735}
3736
3737int
3738cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3739{
 
 
3740	int rc;
3741	int xid;
3742	struct cifs_ses *pSesInfo;
3743	struct cifs_tcon *tcon;
3744	struct TCP_Server_Info *srvTcp;
3745	char   *full_path;
3746	struct tcon_link *tlink;
3747#ifdef CONFIG_CIFS_DFS_UPCALL
3748	int referral_walks_count = 0;
3749#endif
3750
3751	rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
 
3752	if (rc)
3753		return rc;
3754
3755#ifdef CONFIG_CIFS_DFS_UPCALL
3756try_mount_again:
3757	/* cleanup activities if we're chasing a referral */
3758	if (referral_walks_count) {
3759		if (tcon)
3760			cifs_put_tcon(tcon);
3761		else if (pSesInfo)
3762			cifs_put_smb_ses(pSesInfo);
3763
3764		FreeXid(xid);
3765	}
3766#endif
3767	rc = 0;
3768	tcon = NULL;
3769	pSesInfo = NULL;
3770	srvTcp = NULL;
3771	full_path = NULL;
3772	tlink = NULL;
3773
3774	xid = GetXid();
3775
3776	/* get a reference to a tcp session */
3777	srvTcp = cifs_get_tcp_session(volume_info);
3778	if (IS_ERR(srvTcp)) {
3779		rc = PTR_ERR(srvTcp);
3780		bdi_destroy(&cifs_sb->bdi);
3781		goto out;
3782	}
3783
3784	/* get a reference to a SMB session */
3785	pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3786	if (IS_ERR(pSesInfo)) {
3787		rc = PTR_ERR(pSesInfo);
3788		pSesInfo = NULL;
3789		goto mount_fail_check;
3790	}
3791
3792	/* search for existing tcon to this server share */
3793	tcon = cifs_get_tcon(pSesInfo, volume_info);
3794	if (IS_ERR(tcon)) {
3795		rc = PTR_ERR(tcon);
3796		tcon = NULL;
3797		goto remote_path_check;
3798	}
3799
3800	/* tell server which Unix caps we support */
3801	if (tcon->ses->capabilities & CAP_UNIX) {
3802		/* reset of caps checks mount to see if unix extensions
3803		   disabled for just this mount */
3804		reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3805		if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3806		    (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3807		     CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3808			rc = -EACCES;
3809			goto mount_fail_check;
3810		}
3811	} else
3812		tcon->unix_ext = 0; /* server does not support them */
3813
3814	/* do not care if following two calls succeed - informational */
3815	if (!tcon->ipc) {
3816		CIFSSMBQFSDeviceInfo(xid, tcon);
3817		CIFSSMBQFSAttributeInfo(xid, tcon);
3818	}
3819
3820	cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3821	cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3822
3823	/* tune readahead according to rsize */
3824	cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3825
3826remote_path_check:
3827#ifdef CONFIG_CIFS_DFS_UPCALL
3828	/*
3829	 * Perform an unconditional check for whether there are DFS
3830	 * referrals for this path without prefix, to provide support
3831	 * for DFS referrals from w2k8 servers which don't seem to respond
3832	 * with PATH_NOT_COVERED to requests that include the prefix.
3833	 * Chase the referral if found, otherwise continue normally.
 
 
3834	 */
3835	if (referral_walks_count == 0) {
3836		int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3837						cifs_sb, false);
3838		if (!refrc) {
3839			referral_walks_count++;
3840			goto try_mount_again;
3841		}
3842	}
3843#endif
3844
3845	/* check if a whole path is not remote */
3846	if (!rc && tcon) {
3847		/* build_path_to_root works only when we have a valid tcon */
3848		full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3849		if (full_path == NULL) {
3850			rc = -ENOMEM;
3851			goto mount_fail_check;
3852		}
3853		rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3854		if (rc != 0 && rc != -EREMOTE) {
3855			kfree(full_path);
3856			goto mount_fail_check;
3857		}
3858		kfree(full_path);
3859	}
3860
3861	/* get referral if needed */
3862	if (rc == -EREMOTE) {
3863#ifdef CONFIG_CIFS_DFS_UPCALL
3864		if (referral_walks_count > MAX_NESTED_LINKS) {
3865			/*
3866			 * BB: when we implement proper loop detection,
3867			 *     we will remove this check. But now we need it
3868			 *     to prevent an indefinite loop if 'DFS tree' is
3869			 *     misconfigured (i.e. has loops).
3870			 */
3871			rc = -ELOOP;
3872			goto mount_fail_check;
3873		}
3874
3875		rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3876					 true);
 
 
 
 
 
 
 
 
 
 
3877
3878		if (!rc) {
3879			referral_walks_count++;
3880			goto try_mount_again;
3881		}
3882		goto mount_fail_check;
3883#else /* No DFS support, return error on mount */
3884		rc = -EOPNOTSUPP;
3885#endif
3886	}
3887
 
3888	if (rc)
3889		goto mount_fail_check;
3890
3891	/* now, hang the tcon off of the superblock */
3892	tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3893	if (tlink == NULL) {
3894		rc = -ENOMEM;
3895		goto mount_fail_check;
3896	}
3897
3898	tlink->tl_uid = pSesInfo->linux_uid;
3899	tlink->tl_tcon = tcon;
3900	tlink->tl_time = jiffies;
3901	set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3902	set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3903
3904	cifs_sb->master_tlink = tlink;
3905	spin_lock(&cifs_sb->tlink_tree_lock);
3906	tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3907	spin_unlock(&cifs_sb->tlink_tree_lock);
3908
3909	queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3910				TLINK_IDLE_EXPIRE);
3911
3912mount_fail_check:
3913	/* on error free sesinfo and tcon struct if needed */
3914	if (rc) {
3915		/* If find_unc succeeded then rc == 0 so we can not end */
3916		/* up accidentally freeing someone elses tcon struct */
3917		if (tcon)
3918			cifs_put_tcon(tcon);
3919		else if (pSesInfo)
3920			cifs_put_smb_ses(pSesInfo);
3921		else
3922			cifs_put_tcp_session(srvTcp);
3923		bdi_destroy(&cifs_sb->bdi);
3924	}
3925
3926out:
3927	FreeXid(xid);
3928	return rc;
3929}
 
3930
3931/*
3932 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3933 * pointer may be NULL.
3934 */
3935int
3936CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3937	 const char *tree, struct cifs_tcon *tcon,
3938	 const struct nls_table *nls_codepage)
3939{
3940	struct smb_hdr *smb_buffer;
3941	struct smb_hdr *smb_buffer_response;
3942	TCONX_REQ *pSMB;
3943	TCONX_RSP *pSMBr;
3944	unsigned char *bcc_ptr;
3945	int rc = 0;
3946	int length;
3947	__u16 bytes_left, count;
3948
3949	if (ses == NULL)
3950		return -EIO;
3951
3952	smb_buffer = cifs_buf_get();
3953	if (smb_buffer == NULL)
3954		return -ENOMEM;
3955
3956	smb_buffer_response = smb_buffer;
3957
3958	header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3959			NULL /*no tid */ , 4 /*wct */ );
3960
3961	smb_buffer->Mid = get_next_mid(ses->server);
3962	smb_buffer->Uid = ses->Suid;
3963	pSMB = (TCONX_REQ *) smb_buffer;
3964	pSMBr = (TCONX_RSP *) smb_buffer_response;
3965
3966	pSMB->AndXCommand = 0xFF;
3967	pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3968	bcc_ptr = &pSMB->Password[0];
3969	if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3970		pSMB->PasswordLength = cpu_to_le16(1);	/* minimum */
3971		*bcc_ptr = 0; /* password is null byte */
3972		bcc_ptr++;              /* skip password */
3973		/* already aligned so no need to do it below */
3974	} else {
3975		pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3976		/* BB FIXME add code to fail this if NTLMv2 or Kerberos
3977		   specified as required (when that support is added to
3978		   the vfs in the future) as only NTLM or the much
3979		   weaker LANMAN (which we do not send by default) is accepted
3980		   by Samba (not sure whether other servers allow
3981		   NTLMv2 password here) */
3982#ifdef CONFIG_CIFS_WEAK_PW_HASH
3983		if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3984		    (ses->server->secType == LANMAN))
3985			calc_lanman_hash(tcon->password, ses->server->cryptkey,
3986					 ses->server->sec_mode &
3987					    SECMODE_PW_ENCRYPT ? true : false,
3988					 bcc_ptr);
3989		else
3990#endif /* CIFS_WEAK_PW_HASH */
3991		rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3992					bcc_ptr, nls_codepage);
3993
3994		bcc_ptr += CIFS_AUTH_RESP_SIZE;
3995		if (ses->capabilities & CAP_UNICODE) {
3996			/* must align unicode strings */
3997			*bcc_ptr = 0; /* null byte password */
3998			bcc_ptr++;
3999		}
4000	}
4001
4002	if (ses->server->sec_mode &
4003			(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4004		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4005
4006	if (ses->capabilities & CAP_STATUS32) {
4007		smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4008	}
4009	if (ses->capabilities & CAP_DFS) {
4010		smb_buffer->Flags2 |= SMBFLG2_DFS;
4011	}
4012	if (ses->capabilities & CAP_UNICODE) {
4013		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4014		length =
4015		    cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4016			6 /* max utf8 char length in bytes */ *
4017			(/* server len*/ + 256 /* share len */), nls_codepage);
4018		bcc_ptr += 2 * length;	/* convert num 16 bit words to bytes */
4019		bcc_ptr += 2;	/* skip trailing null */
4020	} else {		/* ASCII */
4021		strcpy(bcc_ptr, tree);
4022		bcc_ptr += strlen(tree) + 1;
4023	}
4024	strcpy(bcc_ptr, "?????");
4025	bcc_ptr += strlen("?????");
4026	bcc_ptr += 1;
4027	count = bcc_ptr - &pSMB->Password[0];
4028	pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4029					pSMB->hdr.smb_buf_length) + count);
4030	pSMB->ByteCount = cpu_to_le16(count);
4031
4032	rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4033			 0);
4034
4035	/* above now done in SendReceive */
4036	if ((rc == 0) && (tcon != NULL)) {
4037		bool is_unicode;
4038
4039		tcon->tidStatus = CifsGood;
4040		tcon->need_reconnect = false;
4041		tcon->tid = smb_buffer_response->Tid;
4042		bcc_ptr = pByteArea(smb_buffer_response);
4043		bytes_left = get_bcc(smb_buffer_response);
4044		length = strnlen(bcc_ptr, bytes_left - 2);
4045		if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4046			is_unicode = true;
4047		else
4048			is_unicode = false;
4049
4050
4051		/* skip service field (NB: this field is always ASCII) */
4052		if (length == 3) {
4053			if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4054			    (bcc_ptr[2] == 'C')) {
4055				cFYI(1, "IPC connection");
4056				tcon->ipc = 1;
 
4057			}
4058		} else if (length == 2) {
4059			if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4060				/* the most common case */
4061				cFYI(1, "disk share connection");
4062			}
4063		}
4064		bcc_ptr += length + 1;
4065		bytes_left -= (length + 1);
4066		strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
4067
4068		/* mostly informational -- no need to fail on error here */
4069		kfree(tcon->nativeFileSystem);
4070		tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4071						      bytes_left, is_unicode,
4072						      nls_codepage);
4073
4074		cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
4075
4076		if ((smb_buffer_response->WordCount == 3) ||
4077			 (smb_buffer_response->WordCount == 7))
4078			/* field is in same location */
4079			tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4080		else
4081			tcon->Flags = 0;
4082		cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
4083	} else if ((rc == 0) && tcon == NULL) {
4084		/* all we need to save for IPC$ connection */
4085		ses->ipc_tid = smb_buffer_response->Tid;
4086	}
4087
4088	cifs_buf_release(smb_buffer);
4089	return rc;
4090}
4091
 
 
 
 
 
 
 
 
 
4092void
4093cifs_umount(struct cifs_sb_info *cifs_sb)
4094{
4095	struct rb_root *root = &cifs_sb->tlink_tree;
4096	struct rb_node *node;
4097	struct tcon_link *tlink;
4098
4099	cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4100
4101	spin_lock(&cifs_sb->tlink_tree_lock);
4102	while ((node = rb_first(root))) {
4103		tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4104		cifs_get_tlink(tlink);
4105		clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4106		rb_erase(node, root);
4107
4108		spin_unlock(&cifs_sb->tlink_tree_lock);
4109		cifs_put_tlink(tlink);
4110		spin_lock(&cifs_sb->tlink_tree_lock);
4111	}
4112	spin_unlock(&cifs_sb->tlink_tree_lock);
4113
4114	bdi_destroy(&cifs_sb->bdi);
4115	kfree(cifs_sb->mountdata);
4116	unload_nls(cifs_sb->local_nls);
4117	kfree(cifs_sb);
 
4118}
4119
4120int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
 
 
4121{
4122	int rc = 0;
4123	struct TCP_Server_Info *server = ses->server;
 
 
4124
4125	/* only send once per connect */
4126	if (server->maxBuf != 0)
 
 
 
4127		return 0;
 
 
 
4128
4129	set_credits(server, 1);
4130	rc = CIFSSMBNegotiate(xid, ses);
4131	if (rc == -EAGAIN) {
4132		/* retry only once on 1st time connection */
4133		set_credits(server, 1);
4134		rc = CIFSSMBNegotiate(xid, ses);
4135		if (rc == -EAGAIN)
4136			rc = -EHOSTDOWN;
4137	}
4138	if (rc == 0) {
4139		spin_lock(&GlobalMid_Lock);
4140		if (server->tcpStatus == CifsNeedNegotiate)
4141			server->tcpStatus = CifsGood;
4142		else
4143			rc = -EHOSTDOWN;
4144		spin_unlock(&GlobalMid_Lock);
4145
 
 
 
 
4146	}
4147
4148	return rc;
4149}
4150
 
 
 
 
 
 
 
 
 
4151
4152int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
4153			struct nls_table *nls_info)
4154{
4155	int rc = 0;
4156	struct TCP_Server_Info *server = ses->server;
4157
4158	ses->flags = 0;
4159	ses->capabilities = server->capabilities;
4160	if (linuxExtEnabled == 0)
4161		ses->capabilities &= (~CAP_UNIX);
 
 
4162
4163	cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4164		 server->sec_mode, server->capabilities, server->timeAdj);
4165
4166	rc = CIFS_SessSetup(xid, ses, nls_info);
 
 
4167	if (rc) {
4168		cERROR(1, "Send error in SessSetup = %d", rc);
 
 
 
 
 
 
 
4169	} else {
4170		mutex_lock(&ses->server->srv_mutex);
4171		if (!server->session_estab) {
4172			server->session_key.response = ses->auth_key.response;
4173			server->session_key.len = ses->auth_key.len;
4174			server->sequence_number = 0x2;
4175			server->session_estab = true;
4176			ses->auth_key.response = NULL;
4177		}
4178		mutex_unlock(&server->srv_mutex);
4179
4180		cFYI(1, "CIFS Session Established successfully");
4181		spin_lock(&GlobalMid_Lock);
4182		ses->status = CifsGood;
4183		ses->need_reconnect = false;
4184		spin_unlock(&GlobalMid_Lock);
4185	}
4186
4187	kfree(ses->auth_key.response);
4188	ses->auth_key.response = NULL;
4189	ses->auth_key.len = 0;
4190	kfree(ses->ntlmssp);
4191	ses->ntlmssp = NULL;
4192
4193	return rc;
4194}
4195
4196static int
4197cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4198{
4199	switch (ses->server->secType) {
4200	case Kerberos:
4201		vol->secFlg = CIFSSEC_MUST_KRB5;
 
4202		return 0;
4203	case NTLMv2:
4204		vol->secFlg = CIFSSEC_MUST_NTLMV2;
4205		break;
4206	case NTLM:
4207		vol->secFlg = CIFSSEC_MUST_NTLM;
4208		break;
4209	case RawNTLMSSP:
4210		vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4211		break;
4212	case LANMAN:
4213		vol->secFlg = CIFSSEC_MUST_LANMAN;
4214		break;
4215	}
4216
4217	return cifs_set_cifscreds(vol, ses);
4218}
4219
4220static struct cifs_tcon *
4221cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4222{
4223	int rc;
4224	struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4225	struct cifs_ses *ses;
4226	struct cifs_tcon *tcon = NULL;
4227	struct smb_vol *vol_info;
4228
4229	vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4230	if (vol_info == NULL)
4231		return ERR_PTR(-ENOMEM);
4232
4233	vol_info->local_nls = cifs_sb->local_nls;
4234	vol_info->linux_uid = fsuid;
4235	vol_info->cred_uid = fsuid;
4236	vol_info->UNC = master_tcon->treeName;
4237	vol_info->retry = master_tcon->retry;
4238	vol_info->nocase = master_tcon->nocase;
4239	vol_info->local_lease = master_tcon->local_lease;
4240	vol_info->no_linux_ext = !master_tcon->unix_ext;
 
 
 
 
 
 
 
 
 
 
4241
4242	rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4243	if (rc) {
4244		tcon = ERR_PTR(rc);
4245		goto out;
4246	}
4247
4248	/* get a reference for the same TCP session */
4249	spin_lock(&cifs_tcp_ses_lock);
4250	++master_tcon->ses->server->srv_count;
4251	spin_unlock(&cifs_tcp_ses_lock);
4252
4253	ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4254	if (IS_ERR(ses)) {
4255		tcon = (struct cifs_tcon *)ses;
4256		cifs_put_tcp_session(master_tcon->ses->server);
4257		goto out;
4258	}
4259
4260	tcon = cifs_get_tcon(ses, vol_info);
4261	if (IS_ERR(tcon)) {
4262		cifs_put_smb_ses(ses);
4263		goto out;
4264	}
4265
4266	if (ses->capabilities & CAP_UNIX)
4267		reset_cifs_unix_caps(0, tcon, NULL, vol_info);
 
 
 
4268out:
4269	kfree(vol_info->username);
4270	kfree(vol_info->password);
4271	kfree(vol_info);
4272
4273	return tcon;
4274}
4275
4276struct cifs_tcon *
4277cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4278{
4279	return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4280}
4281
4282static int
4283cifs_sb_tcon_pending_wait(void *unused)
4284{
4285	schedule();
4286	return signal_pending(current) ? -ERESTARTSYS : 0;
4287}
4288
4289/* find and return a tlink with given uid */
4290static struct tcon_link *
4291tlink_rb_search(struct rb_root *root, uid_t uid)
4292{
4293	struct rb_node *node = root->rb_node;
4294	struct tcon_link *tlink;
4295
4296	while (node) {
4297		tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4298
4299		if (tlink->tl_uid > uid)
4300			node = node->rb_left;
4301		else if (tlink->tl_uid < uid)
4302			node = node->rb_right;
4303		else
4304			return tlink;
4305	}
4306	return NULL;
4307}
4308
4309/* insert a tcon_link into the tree */
4310static void
4311tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4312{
4313	struct rb_node **new = &(root->rb_node), *parent = NULL;
4314	struct tcon_link *tlink;
4315
4316	while (*new) {
4317		tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4318		parent = *new;
4319
4320		if (tlink->tl_uid > new_tlink->tl_uid)
4321			new = &((*new)->rb_left);
4322		else
4323			new = &((*new)->rb_right);
4324	}
4325
4326	rb_link_node(&new_tlink->tl_rbnode, parent, new);
4327	rb_insert_color(&new_tlink->tl_rbnode, root);
4328}
4329
4330/*
4331 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4332 * current task.
4333 *
4334 * If the superblock doesn't refer to a multiuser mount, then just return
4335 * the master tcon for the mount.
4336 *
4337 * First, search the rbtree for an existing tcon for this fsuid. If one
4338 * exists, then check to see if it's pending construction. If it is then wait
4339 * for construction to complete. Once it's no longer pending, check to see if
4340 * it failed and either return an error or retry construction, depending on
4341 * the timeout.
4342 *
4343 * If one doesn't exist then insert a new tcon_link struct into the tree and
4344 * try to construct a new one.
4345 */
4346struct tcon_link *
4347cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4348{
4349	int ret;
4350	uid_t fsuid = current_fsuid();
4351	struct tcon_link *tlink, *newtlink;
4352
4353	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4354		return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4355
4356	spin_lock(&cifs_sb->tlink_tree_lock);
4357	tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4358	if (tlink)
4359		cifs_get_tlink(tlink);
4360	spin_unlock(&cifs_sb->tlink_tree_lock);
4361
4362	if (tlink == NULL) {
4363		newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4364		if (newtlink == NULL)
4365			return ERR_PTR(-ENOMEM);
4366		newtlink->tl_uid = fsuid;
4367		newtlink->tl_tcon = ERR_PTR(-EACCES);
4368		set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4369		set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4370		cifs_get_tlink(newtlink);
4371
4372		spin_lock(&cifs_sb->tlink_tree_lock);
4373		/* was one inserted after previous search? */
4374		tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4375		if (tlink) {
4376			cifs_get_tlink(tlink);
4377			spin_unlock(&cifs_sb->tlink_tree_lock);
4378			kfree(newtlink);
4379			goto wait_for_construction;
4380		}
4381		tlink = newtlink;
4382		tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4383		spin_unlock(&cifs_sb->tlink_tree_lock);
4384	} else {
4385wait_for_construction:
4386		ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4387				  cifs_sb_tcon_pending_wait,
4388				  TASK_INTERRUPTIBLE);
4389		if (ret) {
4390			cifs_put_tlink(tlink);
4391			return ERR_PTR(ret);
4392		}
4393
4394		/* if it's good, return it */
4395		if (!IS_ERR(tlink->tl_tcon))
4396			return tlink;
4397
4398		/* return error if we tried this already recently */
4399		if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4400			cifs_put_tlink(tlink);
4401			return ERR_PTR(-EACCES);
4402		}
4403
4404		if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4405			goto wait_for_construction;
4406	}
4407
4408	tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4409	clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4410	wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4411
4412	if (IS_ERR(tlink->tl_tcon)) {
4413		cifs_put_tlink(tlink);
4414		return ERR_PTR(-EACCES);
4415	}
4416
4417	return tlink;
4418}
4419
4420/*
4421 * periodic workqueue job that scans tcon_tree for a superblock and closes
4422 * out tcons.
4423 */
4424static void
4425cifs_prune_tlinks(struct work_struct *work)
4426{
4427	struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4428						    prune_tlinks.work);
4429	struct rb_root *root = &cifs_sb->tlink_tree;
4430	struct rb_node *node = rb_first(root);
4431	struct rb_node *tmp;
4432	struct tcon_link *tlink;
4433
4434	/*
4435	 * Because we drop the spinlock in the loop in order to put the tlink
4436	 * it's not guarded against removal of links from the tree. The only
4437	 * places that remove entries from the tree are this function and
4438	 * umounts. Because this function is non-reentrant and is canceled
4439	 * before umount can proceed, this is safe.
4440	 */
4441	spin_lock(&cifs_sb->tlink_tree_lock);
4442	node = rb_first(root);
4443	while (node != NULL) {
4444		tmp = node;
4445		node = rb_next(tmp);
4446		tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4447
4448		if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4449		    atomic_read(&tlink->tl_count) != 0 ||
4450		    time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4451			continue;
4452
4453		cifs_get_tlink(tlink);
4454		clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4455		rb_erase(tmp, root);
4456
4457		spin_unlock(&cifs_sb->tlink_tree_lock);
4458		cifs_put_tlink(tlink);
4459		spin_lock(&cifs_sb->tlink_tree_lock);
4460	}
4461	spin_unlock(&cifs_sb->tlink_tree_lock);
4462
4463	queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4464				TLINK_IDLE_EXPIRE);
4465}