fs/cifs/connect.c

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