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