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                         vol->username = kstrdup(string, GFP_KERNEL);
1603                         if (!vol->username)
1604                                 goto cifs_parse_mount_err;
1605                         break;
1606                 case Opt_blank_pass:
1607                         /* passwords have to be handled differently
1608                          * to allow the character used for deliminator
1609                          * to be passed within them
1610                          */
1611
1612                         /*
1613                          * Check if this is a case where the  password
1614                          * starts with a delimiter
1615                          */
1616                         tmp_end = strchr(data, '=');
1617                         tmp_end++;
1618                         if (!(tmp_end < end && tmp_end[1] == delim)) {
1619                                 /* No it is not. Set the password to NULL */
1620                                 kfree(vol->password);
1621                                 vol->password = NULL;
1622                                 break;
1623                         }
1624                         /* Yes it is. Drop down to Opt_pass below.*/
1625                 case Opt_pass:
1626                         /* Obtain the value string */
1627                         value = strchr(data, '=');
1628                         value++;
1629
1630                         /* Set tmp_end to end of the string */
1631                         tmp_end = (char *) value + strlen(value);
1632
1633                         /* Check if following character is the deliminator
1634                          * If yes, we have encountered a double deliminator
1635                          * reset the NULL character to the deliminator
1636                          */
1637                         if (tmp_end < end && tmp_end[1] == delim) {
1638                                 tmp_end[0] = delim;
1639
1640                                 /* Keep iterating until we get to a single
1641                                  * deliminator OR the end
1642                                  */
1643                                 while ((tmp_end = strchr(tmp_end, delim))
1644                                         != NULL && (tmp_end[1] == delim)) {
1645                                                 tmp_end = (char *) &tmp_end[2];
1646                                 }
1647
1648                                 /* Reset var options to point to next element */
1649                                 if (tmp_end) {
1650                                         tmp_end[0] = '\0';
1651                                         options = (char *) &tmp_end[1];
1652                                 } else
1653                                         /* Reached the end of the mount option
1654                                          * string */
1655                                         options = end;
1656                         }
1657
1658                         kfree(vol->password);
1659                         /* Now build new password string */
1660                         temp_len = strlen(value);
1661                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1662                         if (vol->password == NULL) {
1663                                 pr_warn("CIFS: no memory for password\n");
1664                                 goto cifs_parse_mount_err;
1665                         }
1666
1667                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1668                                 vol->password[j] = value[i];
1669                                 if ((value[i] == delim) &&
1670                                      value[i+1] == delim)
1671                                         /* skip the second deliminator */
1672                                         i++;
1673                         }
1674                         vol->password[j] = '\0';
1675                         break;
1676                 case Opt_blank_ip:
1677                         /* FIXME: should this be an error instead? */
1678                         got_ip = false;
1679                         break;
1680                 case Opt_ip:
1681                         string = match_strdup(args);
1682                         if (string == NULL)
1683                                 goto out_nomem;
1684
1685                         if (!cifs_convert_address(dstaddr, string,
1686                                         strlen(string))) {
1687                                 pr_err("CIFS: bad ip= option (%s).\n", string);
1688                                 goto cifs_parse_mount_err;
1689                         }
1690                         got_ip = true;
1691                         break;
1692                 case Opt_domain:
1693                         string = match_strdup(args);
1694                         if (string == NULL)
1695                                 goto out_nomem;
1696
1697                         if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1698                                         == CIFS_MAX_DOMAINNAME_LEN) {
1699                                 pr_warn("CIFS: domain name too long\n");
1700                                 goto cifs_parse_mount_err;
1701                         }
1702
1703                         vol->domainname = kstrdup(string, GFP_KERNEL);
1704                         if (!vol->domainname) {
1705                                 pr_warn("CIFS: no memory for domainname\n");
1706                                 goto cifs_parse_mount_err;
1707                         }
1708                         cifs_dbg(FYI, "Domain name set\n");
1709                         break;
1710                 case Opt_srcaddr:
1711                         string = match_strdup(args);
1712                         if (string == NULL)
1713                                 goto out_nomem;
1714
1715                         if (!cifs_convert_address(
1716                                         (struct sockaddr *)&vol->srcaddr,
1717                                         string, strlen(string))) {
1718                                 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1719                                         string);
1720                                 goto cifs_parse_mount_err;
1721                         }
1722                         break;
1723                 case Opt_iocharset:
1724                         string = match_strdup(args);
1725                         if (string == NULL)
1726                                 goto out_nomem;
1727
1728                         if (strnlen(string, 1024) >= 65) {
1729                                 pr_warn("CIFS: iocharset name too long.\n");
1730                                 goto cifs_parse_mount_err;
1731                         }
1732
1733                          if (strncasecmp(string, "default", 7) != 0) {
1734                                 vol->iocharset = kstrdup(string,
1735                                                          GFP_KERNEL);
1736                                 if (!vol->iocharset) {
1737                                         pr_warn("CIFS: no memory for charset\n");
1738                                         goto cifs_parse_mount_err;
1739                                 }
1740                         }
1741                         /* if iocharset not set then load_nls_default
1742                          * is used by caller
1743                          */
1744                          cifs_dbg(FYI, "iocharset set to %s\n", string);
1745                         break;
1746                 case Opt_netbiosname:
1747                         string = match_strdup(args);
1748                         if (string == NULL)
1749                                 goto out_nomem;
1750
1751                         memset(vol->source_rfc1001_name, 0x20,
1752                                 RFC1001_NAME_LEN);
1753                         /*
1754                          * FIXME: are there cases in which a comma can
1755                          * be valid in workstation netbios name (and
1756                          * need special handling)?
1757                          */
1758                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1759                                 /* don't ucase netbiosname for user */
1760                                 if (string[i] == 0)
1761                                         break;
1762                                 vol->source_rfc1001_name[i] = string[i];
1763                         }
1764                         /* The string has 16th byte zero still from
1765                          * set at top of the function
1766                          */
1767                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1768                                 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1769                         break;
1770                 case Opt_servern:
1771                         /* servernetbiosname specified override *SMBSERVER */
1772                         string = match_strdup(args);
1773                         if (string == NULL)
1774                                 goto out_nomem;
1775
1776                         /* last byte, type, is 0x20 for servr type */
1777                         memset(vol->target_rfc1001_name, 0x20,
1778                                 RFC1001_NAME_LEN_WITH_NULL);
1779
1780                         /* BB are there cases in which a comma can be
1781                            valid in this workstation netbios name
1782                            (and need special handling)? */
1783
1784                         /* user or mount helper must uppercase the
1785                            netbios name */
1786                         for (i = 0; i < 15; i++) {
1787                                 if (string[i] == 0)
1788                                         break;
1789                                 vol->target_rfc1001_name[i] = string[i];
1790                         }
1791                         /* The string has 16th byte zero still from
1792                            set at top of the function  */
1793                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1794                                 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1795                         break;
1796                 case Opt_ver:
1797                         string = match_strdup(args);
1798                         if (string == NULL)
1799                                 goto out_nomem;
1800
1801                         if (strncasecmp(string, "1", 1) == 0) {
1802                                 /* This is the default */
1803                                 break;
1804                         }
1805                         /* For all other value, error */
1806                         pr_warn("CIFS: Invalid version specified\n");
1807                         goto cifs_parse_mount_err;
1808                 case Opt_vers:
1809                         string = match_strdup(args);
1810                         if (string == NULL)
1811                                 goto out_nomem;
1812
1813                         if (cifs_parse_smb_version(string, vol) != 0)
1814                                 goto cifs_parse_mount_err;
1815                         break;
1816                 case Opt_sec:
1817                         string = match_strdup(args);
1818                         if (string == NULL)
1819                                 goto out_nomem;
1820
1821                         if (cifs_parse_security_flavors(string, vol) != 0)
1822                                 goto cifs_parse_mount_err;
1823                         break;
1824                 case Opt_cache:
1825                         string = match_strdup(args);
1826                         if (string == NULL)
1827                                 goto out_nomem;
1828
1829                         if (cifs_parse_cache_flavor(string, vol) != 0)
1830                                 goto cifs_parse_mount_err;
1831                         break;
1832                 default:
1833                         /*
1834                          * An option we don't recognize. Save it off for later
1835                          * if we haven't already found one
1836                          */
1837                         if (!invalid)
1838                                 invalid = data;
1839                         break;
1840                 }
1841                 /* Free up any allocated string */
1842                 kfree(string);
1843                 string = NULL;
1844         }
1845
1846         if (!sloppy && invalid) {
1847                 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1848                 goto cifs_parse_mount_err;
1849         }
1850
1851 #ifndef CONFIG_KEYS
1852         /* Muliuser mounts require CONFIG_KEYS support */
1853         if (vol->multiuser) {
1854                 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1855                 goto cifs_parse_mount_err;
1856         }
1857 #endif
1858         if (!vol->UNC) {
1859                 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1860                 goto cifs_parse_mount_err;
1861         }
1862
1863         /* make sure UNC has a share name */
1864         if (!strchr(vol->UNC + 3, '\\')) {
1865                 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1866                 goto cifs_parse_mount_err;
1867         }
1868
1869         if (!got_ip) {
1870                 /* No ip= option specified? Try to get it from UNC */
1871                 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1872                                                 strlen(&vol->UNC[2]))) {
1873                         pr_err("Unable to determine destination address.\n");
1874                         goto cifs_parse_mount_err;
1875                 }
1876         }
1877
1878         /* set the port that we got earlier */
1879         cifs_set_port(dstaddr, port);
1880
1881         if (uid_specified)
1882                 vol->override_uid = override_uid;
1883         else if (override_uid == 1)
1884                 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1885
1886         if (gid_specified)
1887                 vol->override_gid = override_gid;
1888         else if (override_gid == 1)
1889                 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1890
1891         kfree(mountdata_copy);
1892         return 0;
1893
1894 out_nomem:
1895         pr_warn("Could not allocate temporary buffer\n");
1896 cifs_parse_mount_err:
1897         kfree(string);
1898         kfree(mountdata_copy);
1899         return 1;
1900 }
1901
1902 /** Returns true if srcaddr isn't specified and rhs isn't
1903  * specified, or if srcaddr is specified and
1904  * matches the IP address of the rhs argument.
1905  */
1906 static bool
1907 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1908 {
1909         switch (srcaddr->sa_family) {
1910         case AF_UNSPEC:
1911                 return (rhs->sa_family == AF_UNSPEC);
1912         case AF_INET: {
1913                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1914                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1915                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1916         }
1917         case AF_INET6: {
1918                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1919                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1920                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1921         }
1922         default:
1923                 WARN_ON(1);
1924                 return false; /* don't expect to be here */
1925         }
1926 }
1927
1928 /*
1929  * If no port is specified in addr structure, we try to match with 445 port
1930  * and if it fails - with 139 ports. It should be called only if address
1931  * families of server and addr are equal.
1932  */
1933 static bool
1934 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1935 {
1936         __be16 port, *sport;
1937
1938         switch (addr->sa_family) {
1939         case AF_INET:
1940                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1941                 port = ((struct sockaddr_in *) addr)->sin_port;
1942                 break;
1943         case AF_INET6:
1944                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1945                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1946                 break;
1947         default:
1948                 WARN_ON(1);
1949                 return false;
1950         }
1951
1952         if (!port) {
1953                 port = htons(CIFS_PORT);
1954                 if (port == *sport)
1955                         return true;
1956
1957                 port = htons(RFC1001_PORT);
1958         }
1959
1960         return port == *sport;
1961 }
1962
1963 static bool
1964 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1965               struct sockaddr *srcaddr)
1966 {
1967         switch (addr->sa_family) {
1968         case AF_INET: {
1969                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1970                 struct sockaddr_in *srv_addr4 =
1971                                         (struct sockaddr_in *)&server->dstaddr;
1972
1973                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1974                         return false;
1975                 break;
1976         }
1977         case AF_INET6: {
1978                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1979                 struct sockaddr_in6 *srv_addr6 =
1980                                         (struct sockaddr_in6 *)&server->dstaddr;
1981
1982                 if (!ipv6_addr_equal(&addr6->sin6_addr,
1983                                      &srv_addr6->sin6_addr))
1984                         return false;
1985                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1986                         return false;
1987                 break;
1988         }
1989         default:
1990                 WARN_ON(1);
1991                 return false; /* don't expect to be here */
1992         }
1993
1994         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1995                 return false;
1996
1997         return true;
1998 }
1999
2000 static bool
2001 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2002 {
2003         /*
2004          * The select_sectype function should either return the vol->sectype
2005          * that was specified, or "Unspecified" if that sectype was not
2006          * compatible with the given NEGOTIATE request.
2007          */
2008         if (select_sectype(server, vol->sectype) == Unspecified)
2009                 return false;
2010
2011         /*
2012          * Now check if signing mode is acceptable. No need to check
2013          * global_secflags at this point since if MUST_SIGN is set then
2014          * the server->sign had better be too.
2015          */
2016         if (vol->sign && !server->sign)
2017                 return false;
2018
2019         return true;
2020 }
2021
2022 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2023 {
2024         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2025
2026         if (vol->nosharesock)
2027                 return 0;
2028
2029         if ((server->vals != vol->vals) || (server->ops != vol->ops))
2030                 return 0;
2031
2032         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2033                 return 0;
2034
2035         if (!match_address(server, addr,
2036                            (struct sockaddr *)&vol->srcaddr))
2037                 return 0;
2038
2039         if (!match_port(server, addr))
2040                 return 0;
2041
2042         if (!match_security(server, vol))
2043                 return 0;
2044
2045         return 1;
2046 }
2047
2048 static struct TCP_Server_Info *
2049 cifs_find_tcp_session(struct smb_vol *vol)
2050 {
2051         struct TCP_Server_Info *server;
2052
2053         spin_lock(&cifs_tcp_ses_lock);
2054         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2055                 if (!match_server(server, vol))
2056                         continue;
2057
2058                 ++server->srv_count;
2059                 spin_unlock(&cifs_tcp_ses_lock);
2060                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2061                 return server;
2062         }
2063         spin_unlock(&cifs_tcp_ses_lock);
2064         return NULL;
2065 }
2066
2067 static void
2068 cifs_put_tcp_session(struct TCP_Server_Info *server)
2069 {
2070         struct task_struct *task;
2071
2072         spin_lock(&cifs_tcp_ses_lock);
2073         if (--server->srv_count > 0) {
2074                 spin_unlock(&cifs_tcp_ses_lock);
2075                 return;
2076         }
2077
2078         put_net(cifs_net_ns(server));
2079
2080         list_del_init(&server->tcp_ses_list);
2081         spin_unlock(&cifs_tcp_ses_lock);
2082
2083         cancel_delayed_work_sync(&server->echo);
2084
2085         spin_lock(&GlobalMid_Lock);
2086         server->tcpStatus = CifsExiting;
2087         spin_unlock(&GlobalMid_Lock);
2088
2089         cifs_crypto_shash_release(server);
2090         cifs_fscache_release_client_cookie(server);
2091
2092         kfree(server->session_key.response);
2093         server->session_key.response = NULL;
2094         server->session_key.len = 0;
2095
2096         task = xchg(&server->tsk, NULL);
2097         if (task)
2098                 force_sig(SIGKILL, task);
2099 }
2100
2101 static struct TCP_Server_Info *
2102 cifs_get_tcp_session(struct smb_vol *volume_info)
2103 {
2104         struct TCP_Server_Info *tcp_ses = NULL;
2105         int rc;
2106
2107         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2108
2109         /* see if we already have a matching tcp_ses */
2110         tcp_ses = cifs_find_tcp_session(volume_info);
2111         if (tcp_ses)
2112                 return tcp_ses;
2113
2114         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2115         if (!tcp_ses) {
2116                 rc = -ENOMEM;
2117                 goto out_err;
2118         }
2119
2120         tcp_ses->ops = volume_info->ops;
2121         tcp_ses->vals = volume_info->vals;
2122         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2123         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2124         if (IS_ERR(tcp_ses->hostname)) {
2125                 rc = PTR_ERR(tcp_ses->hostname);
2126                 goto out_err_crypto_release;
2127         }
2128
2129         tcp_ses->noblocksnd = volume_info->noblocksnd;
2130         tcp_ses->noautotune = volume_info->noautotune;
2131         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2132         tcp_ses->in_flight = 0;
2133         tcp_ses->credits = 1;
2134         init_waitqueue_head(&tcp_ses->response_q);
2135         init_waitqueue_head(&tcp_ses->request_q);
2136         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2137         mutex_init(&tcp_ses->srv_mutex);
2138         memcpy(tcp_ses->workstation_RFC1001_name,
2139                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2140         memcpy(tcp_ses->server_RFC1001_name,
2141                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2142         tcp_ses->session_estab = false;
2143         tcp_ses->sequence_number = 0;
2144         tcp_ses->lstrp = jiffies;
2145         spin_lock_init(&tcp_ses->req_lock);
2146         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2147         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2148         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2149         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2150                sizeof(tcp_ses->srcaddr));
2151         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2152                 sizeof(tcp_ses->dstaddr));
2153 #ifdef CONFIG_CIFS_SMB2
2154         get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2155 #endif
2156         /*
2157          * at this point we are the only ones with the pointer
2158          * to the struct since the kernel thread not created yet
2159          * no need to spinlock this init of tcpStatus or srv_count
2160          */
2161         tcp_ses->tcpStatus = CifsNew;
2162         ++tcp_ses->srv_count;
2163
2164         rc = ip_connect(tcp_ses);
2165         if (rc < 0) {
2166                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2167                 goto out_err_crypto_release;
2168         }
2169
2170         /*
2171          * since we're in a cifs function already, we know that
2172          * this will succeed. No need for try_module_get().
2173          */
2174         __module_get(THIS_MODULE);
2175         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2176                                   tcp_ses, "cifsd");
2177         if (IS_ERR(tcp_ses->tsk)) {
2178                 rc = PTR_ERR(tcp_ses->tsk);
2179                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2180                 module_put(THIS_MODULE);
2181                 goto out_err_crypto_release;
2182         }
2183         tcp_ses->tcpStatus = CifsNeedNegotiate;
2184
2185         /* thread spawned, put it on the list */
2186         spin_lock(&cifs_tcp_ses_lock);
2187         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2188         spin_unlock(&cifs_tcp_ses_lock);
2189
2190         cifs_fscache_get_client_cookie(tcp_ses);
2191
2192         /* queue echo request delayed work */
2193         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2194
2195         return tcp_ses;
2196
2197 out_err_crypto_release:
2198         cifs_crypto_shash_release(tcp_ses);
2199
2200         put_net(cifs_net_ns(tcp_ses));
2201
2202 out_err:
2203         if (tcp_ses) {
2204                 if (!IS_ERR(tcp_ses->hostname))
2205                         kfree(tcp_ses->hostname);
2206                 if (tcp_ses->ssocket)
2207                         sock_release(tcp_ses->ssocket);
2208                 kfree(tcp_ses);
2209         }
2210         return ERR_PTR(rc);
2211 }
2212
2213 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2214 {
2215         if (vol->sectype != Unspecified &&
2216             vol->sectype != ses->sectype)
2217                 return 0;
2218
2219         switch (ses->sectype) {
2220         case Kerberos:
2221                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2222                         return 0;
2223                 break;
2224         default:
2225                 /* NULL username means anonymous session */
2226                 if (ses->user_name == NULL) {
2227                         if (!vol->nullauth)
2228                                 return 0;
2229                         break;
2230                 }
2231
2232                 /* anything else takes username/password */
2233                 if (strncmp(ses->user_name,
2234                             vol->username ? vol->username : "",
2235                             CIFS_MAX_USERNAME_LEN))
2236                         return 0;
2237                 if ((vol->username && strlen(vol->username) != 0) &&
2238                     ses->password != NULL &&
2239                     strncmp(ses->password,
2240                             vol->password ? vol->password : "",
2241                             CIFS_MAX_PASSWORD_LEN))
2242                         return 0;
2243         }
2244         return 1;
2245 }
2246
2247 static struct cifs_ses *
2248 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2249 {
2250         struct cifs_ses *ses;
2251
2252         spin_lock(&cifs_tcp_ses_lock);
2253         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2254                 if (ses->status == CifsExiting)
2255                         continue;
2256                 if (!match_session(ses, vol))
2257                         continue;
2258                 ++ses->ses_count;
2259                 spin_unlock(&cifs_tcp_ses_lock);
2260                 return ses;
2261         }
2262         spin_unlock(&cifs_tcp_ses_lock);
2263         return NULL;
2264 }
2265
2266 static void
2267 cifs_put_smb_ses(struct cifs_ses *ses)
2268 {
2269         unsigned int rc, xid;
2270         struct TCP_Server_Info *server = ses->server;
2271
2272         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2273
2274         spin_lock(&cifs_tcp_ses_lock);
2275         if (ses->status == CifsExiting) {
2276                 spin_unlock(&cifs_tcp_ses_lock);
2277                 return;
2278         }
2279         if (--ses->ses_count > 0) {
2280                 spin_unlock(&cifs_tcp_ses_lock);
2281                 return;
2282         }
2283         if (ses->status == CifsGood)
2284                 ses->status = CifsExiting;
2285         spin_unlock(&cifs_tcp_ses_lock);
2286
2287         if (ses->status == CifsExiting && server->ops->logoff) {
2288                 xid = get_xid();
2289                 rc = server->ops->logoff(xid, ses);
2290                 if (rc)
2291                         cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2292                                 __func__, rc);
2293                 _free_xid(xid);
2294         }
2295
2296         spin_lock(&cifs_tcp_ses_lock);
2297         list_del_init(&ses->smb_ses_list);
2298         spin_unlock(&cifs_tcp_ses_lock);
2299
2300         sesInfoFree(ses);
2301         cifs_put_tcp_session(server);
2302 }
2303
2304 #ifdef CONFIG_KEYS
2305
2306 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2307 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2308
2309 /* Populate username and pw fields from keyring if possible */
2310 static int
2311 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2312 {
2313         int rc = 0;
2314         char *desc, *delim, *payload;
2315         ssize_t len;
2316         struct key *key;
2317         struct TCP_Server_Info *server = ses->server;
2318         struct sockaddr_in *sa;
2319         struct sockaddr_in6 *sa6;
2320         struct user_key_payload *upayload;
2321
2322         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2323         if (!desc)
2324                 return -ENOMEM;
2325
2326         /* try to find an address key first */
2327         switch (server->dstaddr.ss_family) {
2328         case AF_INET:
2329                 sa = (struct sockaddr_in *)&server->dstaddr;
2330                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2331                 break;
2332         case AF_INET6:
2333                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2334                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2335                 break;
2336         default:
2337                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2338                          server->dstaddr.ss_family);
2339                 rc = -EINVAL;
2340                 goto out_err;
2341         }
2342
2343         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2344         key = request_key(&key_type_logon, desc, "");
2345         if (IS_ERR(key)) {
2346                 if (!ses->domainName) {
2347                         cifs_dbg(FYI, "domainName is NULL\n");
2348                         rc = PTR_ERR(key);
2349                         goto out_err;
2350                 }
2351
2352                 /* didn't work, try to find a domain key */
2353                 sprintf(desc, "cifs:d:%s", ses->domainName);
2354                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2355                 key = request_key(&key_type_logon, desc, "");
2356                 if (IS_ERR(key)) {
2357                         rc = PTR_ERR(key);
2358                         goto out_err;
2359                 }
2360         }
2361
2362         down_read(&key->sem);
2363         upayload = key->payload.data;
2364         if (IS_ERR_OR_NULL(upayload)) {
2365                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2366                 goto out_key_put;
2367         }
2368
2369         /* find first : in payload */
2370         payload = (char *)upayload->data;
2371         delim = strnchr(payload, upayload->datalen, ':');
2372         cifs_dbg(FYI, "payload=%s\n", payload);
2373         if (!delim) {
2374                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2375                          upayload->datalen);
2376                 rc = -EINVAL;
2377                 goto out_key_put;
2378         }
2379
2380         len = delim - payload;
2381         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2382                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2383                          len);
2384                 rc = -EINVAL;
2385                 goto out_key_put;
2386         }
2387
2388         vol->username = kstrndup(payload, len, GFP_KERNEL);
2389         if (!vol->username) {
2390                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2391                          len);
2392                 rc = -ENOMEM;
2393                 goto out_key_put;
2394         }
2395         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2396
2397         len = key->datalen - (len + 1);
2398         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2399                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2400                 rc = -EINVAL;
2401                 kfree(vol->username);
2402                 vol->username = NULL;
2403                 goto out_key_put;
2404         }
2405
2406         ++delim;
2407         vol->password = kstrndup(delim, len, GFP_KERNEL);
2408         if (!vol->password) {
2409                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2410                          len);
2411                 rc = -ENOMEM;
2412                 kfree(vol->username);
2413                 vol->username = NULL;
2414                 goto out_key_put;
2415         }
2416
2417 out_key_put:
2418         up_read(&key->sem);
2419         key_put(key);
2420 out_err:
2421         kfree(desc);
2422         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2423         return rc;
2424 }
2425 #else /* ! CONFIG_KEYS */
2426 static inline int
2427 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2428                    struct cifs_ses *ses __attribute__((unused)))
2429 {
2430         return -ENOSYS;
2431 }
2432 #endif /* CONFIG_KEYS */
2433
2434 static struct cifs_ses *
2435 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2436 {
2437         int rc = -ENOMEM;
2438         unsigned int xid;
2439         struct cifs_ses *ses;
2440         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2441         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2442
2443         xid = get_xid();
2444
2445         ses = cifs_find_smb_ses(server, volume_info);
2446         if (ses) {
2447                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2448                          ses->status);
2449
2450                 mutex_lock(&ses->session_mutex);
2451                 rc = cifs_negotiate_protocol(xid, ses);
2452                 if (rc) {
2453                         mutex_unlock(&ses->session_mutex);
2454                         /* problem -- put our ses reference */
2455                         cifs_put_smb_ses(ses);
2456                         free_xid(xid);
2457                         return ERR_PTR(rc);
2458                 }
2459                 if (ses->need_reconnect) {
2460                         cifs_dbg(FYI, "Session needs reconnect\n");
2461                         rc = cifs_setup_session(xid, ses,
2462                                                 volume_info->local_nls);
2463                         if (rc) {
2464                                 mutex_unlock(&ses->session_mutex);
2465                                 /* problem -- put our reference */
2466                                 cifs_put_smb_ses(ses);
2467                                 free_xid(xid);
2468                                 return ERR_PTR(rc);
2469                         }
2470                 }
2471                 mutex_unlock(&ses->session_mutex);
2472
2473                 /* existing SMB ses has a server reference already */
2474                 cifs_put_tcp_session(server);
2475                 free_xid(xid);
2476                 return ses;
2477         }
2478
2479         cifs_dbg(FYI, "Existing smb sess not found\n");
2480         ses = sesInfoAlloc();
2481         if (ses == NULL)
2482                 goto get_ses_fail;
2483
2484         /* new SMB session uses our server ref */
2485         ses->server = server;
2486         if (server->dstaddr.ss_family == AF_INET6)
2487                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2488         else
2489                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2490
2491         if (volume_info->username) {
2492                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2493                 if (!ses->user_name)
2494                         goto get_ses_fail;
2495         }
2496
2497         /* volume_info->password freed at unmount */
2498         if (volume_info->password) {
2499                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2500                 if (!ses->password)
2501                         goto get_ses_fail;
2502         }
2503         if (volume_info->domainname) {
2504                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2505                 if (!ses->domainName)
2506                         goto get_ses_fail;
2507         }
2508         ses->cred_uid = volume_info->cred_uid;
2509         ses->linux_uid = volume_info->linux_uid;
2510
2511         ses->sectype = volume_info->sectype;
2512         ses->sign = volume_info->sign;
2513
2514         mutex_lock(&ses->session_mutex);
2515         rc = cifs_negotiate_protocol(xid, ses);
2516         if (!rc)
2517                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2518         mutex_unlock(&ses->session_mutex);
2519         if (rc)
2520                 goto get_ses_fail;
2521
2522         /* success, put it on the list */
2523         spin_lock(&cifs_tcp_ses_lock);
2524         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2525         spin_unlock(&cifs_tcp_ses_lock);
2526
2527         free_xid(xid);
2528         return ses;
2529
2530 get_ses_fail:
2531         sesInfoFree(ses);
2532         free_xid(xid);
2533         return ERR_PTR(rc);
2534 }
2535
2536 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2537 {
2538         if (tcon->tidStatus == CifsExiting)
2539                 return 0;
2540         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2541                 return 0;
2542         return 1;
2543 }
2544
2545 static struct cifs_tcon *
2546 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2547 {
2548         struct list_head *tmp;
2549         struct cifs_tcon *tcon;
2550
2551         spin_lock(&cifs_tcp_ses_lock);
2552         list_for_each(tmp, &ses->tcon_list) {
2553                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2554                 if (!match_tcon(tcon, unc))
2555                         continue;
2556                 ++tcon->tc_count;
2557                 spin_unlock(&cifs_tcp_ses_lock);
2558                 return tcon;
2559         }
2560         spin_unlock(&cifs_tcp_ses_lock);
2561         return NULL;
2562 }
2563
2564 static void
2565 cifs_put_tcon(struct cifs_tcon *tcon)
2566 {
2567         unsigned int xid;
2568         struct cifs_ses *ses = tcon->ses;
2569
2570         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2571         spin_lock(&cifs_tcp_ses_lock);
2572         if (--tcon->tc_count > 0) {
2573                 spin_unlock(&cifs_tcp_ses_lock);
2574                 return;
2575         }
2576
2577         list_del_init(&tcon->tcon_list);
2578         spin_unlock(&cifs_tcp_ses_lock);
2579
2580         xid = get_xid();
2581         if (ses->server->ops->tree_disconnect)
2582                 ses->server->ops->tree_disconnect(xid, tcon);
2583         _free_xid(xid);
2584
2585         cifs_fscache_release_super_cookie(tcon);
2586         tconInfoFree(tcon);
2587         cifs_put_smb_ses(ses);
2588 }
2589
2590 static struct cifs_tcon *
2591 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2592 {
2593         int rc, xid;
2594         struct cifs_tcon *tcon;
2595
2596         tcon = cifs_find_tcon(ses, volume_info->UNC);
2597         if (tcon) {
2598                 cifs_dbg(FYI, "Found match on UNC path\n");
2599                 /* existing tcon already has a reference */
2600                 cifs_put_smb_ses(ses);
2601                 if (tcon->seal != volume_info->seal)
2602                         cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2603                 return tcon;
2604         }
2605
2606         if (!ses->server->ops->tree_connect) {
2607                 rc = -ENOSYS;
2608                 goto out_fail;
2609         }
2610
2611         tcon = tconInfoAlloc();
2612         if (tcon == NULL) {
2613                 rc = -ENOMEM;
2614                 goto out_fail;
2615         }
2616
2617         tcon->ses = ses;
2618         if (volume_info->password) {
2619                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2620                 if (!tcon->password) {
2621                         rc = -ENOMEM;
2622                         goto out_fail;
2623                 }
2624         }
2625
2626         /*
2627          * BB Do we need to wrap session_mutex around this TCon call and Unix
2628          * SetFS as we do on SessSetup and reconnect?
2629          */
2630         xid = get_xid();
2631         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2632                                             volume_info->local_nls);
2633         free_xid(xid);
2634         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2635         if (rc)
2636                 goto out_fail;
2637
2638         if (volume_info->nodfs) {
2639                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2640                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2641         }
2642         tcon->seal = volume_info->seal;
2643         /*
2644          * We can have only one retry value for a connection to a share so for
2645          * resources mounted more than once to the same server share the last
2646          * value passed in for the retry flag is used.
2647          */
2648         tcon->retry = volume_info->retry;
2649         tcon->nocase = volume_info->nocase;
2650         tcon->local_lease = volume_info->local_lease;
2651         INIT_LIST_HEAD(&tcon->pending_opens);
2652
2653         spin_lock(&cifs_tcp_ses_lock);
2654         list_add(&tcon->tcon_list, &ses->tcon_list);
2655         spin_unlock(&cifs_tcp_ses_lock);
2656
2657         cifs_fscache_get_super_cookie(tcon);
2658
2659         return tcon;
2660
2661 out_fail:
2662         tconInfoFree(tcon);
2663         return ERR_PTR(rc);
2664 }
2665
2666 void
2667 cifs_put_tlink(struct tcon_link *tlink)
2668 {
2669         if (!tlink || IS_ERR(tlink))
2670                 return;
2671
2672         if (!atomic_dec_and_test(&tlink->tl_count) ||
2673             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2674                 tlink->tl_time = jiffies;
2675                 return;
2676         }
2677
2678         if (!IS_ERR(tlink_tcon(tlink)))
2679                 cifs_put_tcon(tlink_tcon(tlink));
2680         kfree(tlink);
2681         return;
2682 }
2683
2684 static inline struct tcon_link *
2685 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2686 {
2687         return cifs_sb->master_tlink;
2688 }
2689
2690 static int
2691 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2692 {
2693         struct cifs_sb_info *old = CIFS_SB(sb);
2694         struct cifs_sb_info *new = mnt_data->cifs_sb;
2695
2696         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2697                 return 0;
2698
2699         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2700             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2701                 return 0;
2702
2703         /*
2704          * We want to share sb only if we don't specify an r/wsize or
2705          * specified r/wsize is greater than or equal to existing one.
2706          */
2707         if (new->wsize && new->wsize < old->wsize)
2708                 return 0;
2709
2710         if (new->rsize && new->rsize < old->rsize)
2711                 return 0;
2712
2713         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2714                 return 0;
2715
2716         if (old->mnt_file_mode != new->mnt_file_mode ||
2717             old->mnt_dir_mode != new->mnt_dir_mode)
2718                 return 0;
2719
2720         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2721                 return 0;
2722
2723         if (old->actimeo != new->actimeo)
2724                 return 0;
2725
2726         return 1;
2727 }
2728
2729 int
2730 cifs_match_super(struct super_block *sb, void *data)
2731 {
2732         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2733         struct smb_vol *volume_info;
2734         struct cifs_sb_info *cifs_sb;
2735         struct TCP_Server_Info *tcp_srv;
2736         struct cifs_ses *ses;
2737         struct cifs_tcon *tcon;
2738         struct tcon_link *tlink;
2739         int rc = 0;
2740
2741         spin_lock(&cifs_tcp_ses_lock);
2742         cifs_sb = CIFS_SB(sb);
2743         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2744         if (IS_ERR(tlink)) {
2745                 spin_unlock(&cifs_tcp_ses_lock);
2746                 return rc;
2747         }
2748         tcon = tlink_tcon(tlink);
2749         ses = tcon->ses;
2750         tcp_srv = ses->server;
2751
2752         volume_info = mnt_data->vol;
2753
2754         if (!match_server(tcp_srv, volume_info) ||
2755             !match_session(ses, volume_info) ||
2756             !match_tcon(tcon, volume_info->UNC)) {
2757                 rc = 0;
2758                 goto out;
2759         }
2760
2761         rc = compare_mount_options(sb, mnt_data);
2762 out:
2763         spin_unlock(&cifs_tcp_ses_lock);
2764         cifs_put_tlink(tlink);
2765         return rc;
2766 }
2767
2768 int
2769 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2770              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2771              struct dfs_info3_param **referrals, int remap)
2772 {
2773         char *temp_unc;
2774         int rc = 0;
2775
2776         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2777                 return -ENOSYS;
2778
2779         *num_referrals = 0;
2780         *referrals = NULL;
2781
2782         if (ses->ipc_tid == 0) {
2783                 temp_unc = kmalloc(2 /* for slashes */ +
2784                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2785                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2786                 if (temp_unc == NULL)
2787                         return -ENOMEM;
2788                 temp_unc[0] = '\\';
2789                 temp_unc[1] = '\\';
2790                 strcpy(temp_unc + 2, ses->serverName);
2791                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2792                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2793                                                     nls_codepage);
2794                 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2795                 kfree(temp_unc);
2796         }
2797         if (rc == 0)
2798                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2799                                                      referrals, num_referrals,
2800                                                      nls_codepage, remap);
2801         /*
2802          * BB - map targetUNCs to dfs_info3 structures, here or in
2803          * ses->server->ops->get_dfs_refer.
2804          */
2805
2806         return rc;
2807 }
2808
2809 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2810 static struct lock_class_key cifs_key[2];
2811 static struct lock_class_key cifs_slock_key[2];
2812
2813 static inline void
2814 cifs_reclassify_socket4(struct socket *sock)
2815 {
2816         struct sock *sk = sock->sk;
2817         BUG_ON(sock_owned_by_user(sk));
2818         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2819                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2820 }
2821
2822 static inline void
2823 cifs_reclassify_socket6(struct socket *sock)
2824 {
2825         struct sock *sk = sock->sk;
2826         BUG_ON(sock_owned_by_user(sk));
2827         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2828                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2829 }
2830 #else
2831 static inline void
2832 cifs_reclassify_socket4(struct socket *sock)
2833 {
2834 }
2835
2836 static inline void
2837 cifs_reclassify_socket6(struct socket *sock)
2838 {
2839 }
2840 #endif
2841
2842 /* See RFC1001 section 14 on representation of Netbios names */
2843 static void rfc1002mangle(char *target, char *source, unsigned int length)
2844 {
2845         unsigned int i, j;
2846
2847         for (i = 0, j = 0; i < (length); i++) {
2848                 /* mask a nibble at a time and encode */
2849                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2850                 target[j+1] = 'A' + (0x0F & source[i]);
2851                 j += 2;
2852         }
2853
2854 }
2855
2856 static int
2857 bind_socket(struct TCP_Server_Info *server)
2858 {
2859         int rc = 0;
2860         if (server->srcaddr.ss_family != AF_UNSPEC) {
2861                 /* Bind to the specified local IP address */
2862                 struct socket *socket = server->ssocket;
2863                 rc = socket->ops->bind(socket,
2864                                        (struct sockaddr *) &server->srcaddr,
2865                                        sizeof(server->srcaddr));
2866                 if (rc < 0) {
2867                         struct sockaddr_in *saddr4;
2868                         struct sockaddr_in6 *saddr6;
2869                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2870                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2871                         if (saddr6->sin6_family == AF_INET6)
2872                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2873                                          &saddr6->sin6_addr, rc);
2874                         else
2875                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2876                                          &saddr4->sin_addr.s_addr, rc);
2877                 }
2878         }
2879         return rc;
2880 }
2881
2882 static int
2883 ip_rfc1001_connect(struct TCP_Server_Info *server)
2884 {
2885         int rc = 0;
2886         /*
2887          * some servers require RFC1001 sessinit before sending
2888          * negprot - BB check reconnection in case where second
2889          * sessinit is sent but no second negprot
2890          */
2891         struct rfc1002_session_packet *ses_init_buf;
2892         struct smb_hdr *smb_buf;
2893         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2894                                GFP_KERNEL);
2895         if (ses_init_buf) {
2896                 ses_init_buf->trailer.session_req.called_len = 32;
2897
2898                 if (server->server_RFC1001_name &&
2899                     server->server_RFC1001_name[0] != 0)
2900                         rfc1002mangle(ses_init_buf->trailer.
2901                                       session_req.called_name,
2902                                       server->server_RFC1001_name,
2903                                       RFC1001_NAME_LEN_WITH_NULL);
2904                 else
2905                         rfc1002mangle(ses_init_buf->trailer.
2906                                       session_req.called_name,
2907                                       DEFAULT_CIFS_CALLED_NAME,
2908                                       RFC1001_NAME_LEN_WITH_NULL);
2909
2910                 ses_init_buf->trailer.session_req.calling_len = 32;
2911
2912                 /*
2913                  * calling name ends in null (byte 16) from old smb
2914                  * convention.
2915                  */
2916                 if (server->workstation_RFC1001_name &&
2917                     server->workstation_RFC1001_name[0] != 0)
2918                         rfc1002mangle(ses_init_buf->trailer.
2919                                       session_req.calling_name,
2920                                       server->workstation_RFC1001_name,
2921                                       RFC1001_NAME_LEN_WITH_NULL);
2922                 else
2923                         rfc1002mangle(ses_init_buf->trailer.
2924                                       session_req.calling_name,
2925                                       "LINUX_CIFS_CLNT",
2926                                       RFC1001_NAME_LEN_WITH_NULL);
2927
2928                 ses_init_buf->trailer.session_req.scope1 = 0;
2929                 ses_init_buf->trailer.session_req.scope2 = 0;
2930                 smb_buf = (struct smb_hdr *)ses_init_buf;
2931
2932                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2933                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2934                 rc = smb_send(server, smb_buf, 0x44);
2935                 kfree(ses_init_buf);
2936                 /*
2937                  * RFC1001 layer in at least one server
2938                  * requires very short break before negprot
2939                  * presumably because not expecting negprot
2940                  * to follow so fast.  This is a simple
2941                  * solution that works without
2942                  * complicating the code and causes no
2943                  * significant slowing down on mount
2944                  * for everyone else
2945                  */
2946                 usleep_range(1000, 2000);
2947         }
2948         /*
2949          * else the negprot may still work without this
2950          * even though malloc failed
2951          */
2952
2953         return rc;
2954 }
2955
2956 static int
2957 generic_ip_connect(struct TCP_Server_Info *server)
2958 {
2959         int rc = 0;
2960         __be16 sport;
2961         int slen, sfamily;
2962         struct socket *socket = server->ssocket;
2963         struct sockaddr *saddr;
2964
2965         saddr = (struct sockaddr *) &server->dstaddr;
2966
2967         if (server->dstaddr.ss_family == AF_INET6) {
2968                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2969                 slen = sizeof(struct sockaddr_in6);
2970                 sfamily = AF_INET6;
2971         } else {
2972                 sport = ((struct sockaddr_in *) saddr)->sin_port;
2973                 slen = sizeof(struct sockaddr_in);
2974                 sfamily = AF_INET;
2975         }
2976
2977         if (socket == NULL) {
2978                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2979                                    IPPROTO_TCP, &socket, 1);
2980                 if (rc < 0) {
2981                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
2982                         server->ssocket = NULL;
2983                         return rc;
2984                 }
2985
2986                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2987                 cifs_dbg(FYI, "Socket created\n");
2988                 server->ssocket = socket;
2989                 socket->sk->sk_allocation = GFP_NOFS;
2990                 if (sfamily == AF_INET6)
2991                         cifs_reclassify_socket6(socket);
2992                 else
2993                         cifs_reclassify_socket4(socket);
2994         }
2995
2996         rc = bind_socket(server);
2997         if (rc < 0)
2998                 return rc;
2999
3000         /*
3001          * Eventually check for other socket options to change from
3002          * the default. sock_setsockopt not used because it expects
3003          * user space buffer
3004          */
3005         socket->sk->sk_rcvtimeo = 7 * HZ;
3006         socket->sk->sk_sndtimeo = 5 * HZ;
3007
3008         /* make the bufsizes depend on wsize/rsize and max requests */
3009         if (server->noautotune) {
3010                 if (socket->sk->sk_sndbuf < (200 * 1024))
3011                         socket->sk->sk_sndbuf = 200 * 1024;
3012                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3013                         socket->sk->sk_rcvbuf = 140 * 1024;
3014         }
3015
3016         if (server->tcp_nodelay) {
3017                 int val = 1;
3018                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3019                                 (char *)&val, sizeof(val));
3020                 if (rc)
3021                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3022                                  rc);
3023         }
3024
3025         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3026                  socket->sk->sk_sndbuf,
3027                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3028
3029         rc = socket->ops->connect(socket, saddr, slen, 0);
3030         if (rc < 0) {
3031                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3032                 sock_release(socket);
3033                 server->ssocket = NULL;
3034                 return rc;
3035         }
3036
3037         if (sport == htons(RFC1001_PORT))
3038                 rc = ip_rfc1001_connect(server);
3039
3040         return rc;
3041 }
3042
3043 static int
3044 ip_connect(struct TCP_Server_Info *server)
3045 {
3046         __be16 *sport;
3047         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3048         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3049
3050         if (server->dstaddr.ss_family == AF_INET6)
3051                 sport = &addr6->sin6_port;
3052         else
3053                 sport = &addr->sin_port;
3054
3055         if (*sport == 0) {
3056                 int rc;
3057
3058                 /* try with 445 port at first */
3059                 *sport = htons(CIFS_PORT);
3060
3061                 rc = generic_ip_connect(server);
3062                 if (rc >= 0)
3063                         return rc;
3064
3065                 /* if it failed, try with 139 port */
3066                 *sport = htons(RFC1001_PORT);
3067         }
3068
3069         return generic_ip_connect(server);
3070 }
3071
3072 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3073                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3074 {
3075         /* if we are reconnecting then should we check to see if
3076          * any requested capabilities changed locally e.g. via
3077          * remount but we can not do much about it here
3078          * if they have (even if we could detect it by the following)
3079          * Perhaps we could add a backpointer to array of sb from tcon
3080          * or if we change to make all sb to same share the same
3081          * sb as NFS - then we only have one backpointer to sb.
3082          * What if we wanted to mount the server share twice once with
3083          * and once without posixacls or posix paths? */
3084         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3085
3086         if (vol_info && vol_info->no_linux_ext) {
3087                 tcon->fsUnixInfo.Capability = 0;
3088                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3089                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3090                 return;
3091         } else if (vol_info)
3092                 tcon->unix_ext = 1; /* Unix Extensions supported */
3093
3094         if (tcon->unix_ext == 0) {
3095                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3096                 return;
3097         }
3098
3099         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3100                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3101                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3102                 /* check for reconnect case in which we do not
3103                    want to change the mount behavior if we can avoid it */
3104                 if (vol_info == NULL) {
3105                         /* turn off POSIX ACL and PATHNAMES if not set
3106                            originally at mount time */
3107                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3108                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3109                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3110                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3111                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3112                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3113                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3114                                 cifs_dbg(VFS, "possible reconnect error\n");
3115                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3116                         }
3117                 }
3118
3119                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3120                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3121
3122                 cap &= CIFS_UNIX_CAP_MASK;
3123                 if (vol_info && vol_info->no_psx_acl)
3124                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3125                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3126                         cifs_dbg(FYI, "negotiated posix acl support\n");
3127                         if (cifs_sb)
3128                                 cifs_sb->mnt_cifs_flags |=
3129                                         CIFS_MOUNT_POSIXACL;
3130                 }
3131
3132                 if (vol_info && vol_info->posix_paths == 0)
3133                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3134                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3135                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3136                         if (cifs_sb)
3137                                 cifs_sb->mnt_cifs_flags |=
3138                                         CIFS_MOUNT_POSIX_PATHS;
3139                 }
3140
3141                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3142 #ifdef CONFIG_CIFS_DEBUG2
3143                 if (cap & CIFS_UNIX_FCNTL_CAP)
3144                         cifs_dbg(FYI, "FCNTL cap\n");
3145                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3146                         cifs_dbg(FYI, "EXTATTR cap\n");
3147                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3148                         cifs_dbg(FYI, "POSIX path cap\n");
3149                 if (cap & CIFS_UNIX_XATTR_CAP)
3150                         cifs_dbg(FYI, "XATTR cap\n");
3151                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3152                         cifs_dbg(FYI, "POSIX ACL cap\n");
3153                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3154                         cifs_dbg(FYI, "very large read cap\n");
3155                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3156                         cifs_dbg(FYI, "very large write cap\n");
3157                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3158                         cifs_dbg(FYI, "transport encryption cap\n");
3159                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3160                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3161 #endif /* CIFS_DEBUG2 */
3162                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3163                         if (vol_info == NULL) {
3164                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3165                         } else
3166                                 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");
3167
3168                 }
3169         }
3170 }
3171
3172 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3173                         struct cifs_sb_info *cifs_sb)
3174 {
3175         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3176
3177         spin_lock_init(&cifs_sb->tlink_tree_lock);
3178         cifs_sb->tlink_tree = RB_ROOT;
3179
3180         /*
3181          * Temporarily set r/wsize for matching superblock. If we end up using
3182          * new sb then client will later negotiate it downward if needed.
3183          */
3184         cifs_sb->rsize = pvolume_info->rsize;
3185         cifs_sb->wsize = pvolume_info->wsize;
3186
3187         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3188         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3189         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3190         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3191         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
3192                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3193
3194         cifs_sb->actimeo = pvolume_info->actimeo;
3195         cifs_sb->local_nls = pvolume_info->local_nls;
3196
3197         if (pvolume_info->noperm)
3198                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3199         if (pvolume_info->setuids)
3200                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3201         if (pvolume_info->server_ino)
3202                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3203         if (pvolume_info->remap)
3204                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3205         if (pvolume_info->sfu_remap)
3206                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3207         if (pvolume_info->no_xattr)
3208                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3209         if (pvolume_info->sfu_emul)
3210                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3211         if (pvolume_info->nobrl)
3212                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3213         if (pvolume_info->nostrictsync)
3214                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3215         if (pvolume_info->mand_lock)
3216                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3217         if (pvolume_info->rwpidforward)
3218                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3219         if (pvolume_info->cifs_acl)
3220                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3221         if (pvolume_info->backupuid_specified) {
3222                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3223                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3224         }
3225         if (pvolume_info->backupgid_specified) {
3226                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3227                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3228         }
3229         if (pvolume_info->override_uid)
3230                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3231         if (pvolume_info->override_gid)
3232                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3233         if (pvolume_info->dynperm)
3234                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3235         if (pvolume_info->fsc)
3236                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3237         if (pvolume_info->multiuser)
3238                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3239                                             CIFS_MOUNT_NO_PERM);
3240         if (pvolume_info->strict_io)
3241                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3242         if (pvolume_info->direct_io) {
3243                 cifs_dbg(FYI, "mounting share using direct i/o\n");
3244                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3245         }
3246         if (pvolume_info->mfsymlinks) {
3247                 if (pvolume_info->sfu_emul) {
3248                         /*
3249                          * Our SFU ("Services for Unix" emulation does not allow
3250                          * creating symlinks but does allow reading existing SFU
3251                          * symlinks (it does allow both creating and reading SFU
3252                          * style mknod and FIFOs though). When "mfsymlinks" and
3253                          * "sfu" are both enabled at the same time, it allows
3254                          * reading both types of symlinks, but will only create
3255                          * them with mfsymlinks format. This allows better
3256                          * Apple compatibility (probably better for Samba too)
3257                          * while still recognizing old Windows style symlinks.
3258                          */
3259                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3260                 }
3261                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3262         }
3263
3264         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3265                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3266 }
3267
3268 static void
3269 cleanup_volume_info_contents(struct smb_vol *volume_info)
3270 {
3271         kfree(volume_info->username);
3272         kzfree(volume_info->password);
3273         kfree(volume_info->UNC);
3274         kfree(volume_info->domainname);
3275         kfree(volume_info->iocharset);
3276         kfree(volume_info->prepath);
3277 }
3278
3279 void
3280 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3281 {
3282         if (!volume_info)
3283                 return;
3284         cleanup_volume_info_contents(volume_info);
3285         kfree(volume_info);
3286 }
3287
3288
3289 #ifdef CONFIG_CIFS_DFS_UPCALL
3290 /*
3291  * cifs_build_path_to_root returns full path to root when we do not have an
3292  * exiting connection (tcon)
3293  */
3294 static char *
3295 build_unc_path_to_root(const struct smb_vol *vol,
3296                 const struct cifs_sb_info *cifs_sb)
3297 {
3298         char *full_path, *pos;
3299         unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3300         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3301
3302         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3303         if (full_path == NULL)
3304                 return ERR_PTR(-ENOMEM);
3305
3306         strncpy(full_path, vol->UNC, unc_len);
3307         pos = full_path + unc_len;
3308
3309         if (pplen) {
3310                 *pos = CIFS_DIR_SEP(cifs_sb);
3311                 strncpy(pos + 1, vol->prepath, pplen);
3312                 pos += pplen;
3313         }
3314
3315         *pos = '\0'; /* add trailing null */
3316         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3317         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3318         return full_path;
3319 }
3320
3321 /*
3322  * Perform a dfs referral query for a share and (optionally) prefix
3323  *
3324  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3325  * to a string containing updated options for the submount.  Otherwise it
3326  * will be left untouched.
3327  *
3328  * Returns the rc from get_dfs_path to the caller, which can be used to
3329  * determine whether there were referrals.
3330  */
3331 static int
3332 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3333                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3334                     int check_prefix)
3335 {
3336         int rc;
3337         unsigned int num_referrals = 0;
3338         struct dfs_info3_param *referrals = NULL;
3339         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3340
3341         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3342         if (IS_ERR(full_path))
3343                 return PTR_ERR(full_path);
3344
3345         /* For DFS paths, skip the first '\' of the UNC */
3346         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3347
3348         rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3349                           &num_referrals, &referrals, cifs_remap(cifs_sb));
3350
3351         if (!rc && num_referrals > 0) {
3352                 char *fake_devname = NULL;
3353
3354                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3355                                                    full_path + 1, referrals,
3356                                                    &fake_devname);
3357
3358                 free_dfs_info_array(referrals, num_referrals);
3359
3360                 if (IS_ERR(mdata)) {
3361                         rc = PTR_ERR(mdata);
3362                         mdata = NULL;
3363                 } else {
3364                         cleanup_volume_info_contents(volume_info);
3365                         rc = cifs_setup_volume_info(volume_info, mdata,
3366                                                         fake_devname);
3367                 }
3368                 kfree(fake_devname);
3369                 kfree(cifs_sb->mountdata);
3370                 cifs_sb->mountdata = mdata;
3371         }
3372         kfree(full_path);
3373         return rc;
3374 }
3375 #endif
3376
3377 static int
3378 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3379                         const char *devname)
3380 {
3381         int rc = 0;
3382
3383         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3384                 return -EINVAL;
3385
3386         if (volume_info->nullauth) {
3387                 cifs_dbg(FYI, "Anonymous login\n");
3388                 kfree(volume_info->username);
3389                 volume_info->username = NULL;
3390         } else if (volume_info->username) {
3391                 /* BB fixme parse for domain name here */
3392                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3393         } else {
3394                 cifs_dbg(VFS, "No username specified\n");
3395         /* In userspace mount helper we can get user name from alternate
3396            locations such as env variables and files on disk */
3397                 return -EINVAL;
3398         }
3399
3400         /* this is needed for ASCII cp to Unicode converts */
3401         if (volume_info->iocharset == NULL) {
3402                 /* load_nls_default cannot return null */
3403                 volume_info->local_nls = load_nls_default();
3404         } else {
3405                 volume_info->local_nls = load_nls(volume_info->iocharset);
3406                 if (volume_info->local_nls == NULL) {
3407                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3408                                  volume_info->iocharset);
3409                         return -ELIBACC;
3410                 }
3411         }
3412
3413         return rc;
3414 }
3415
3416 struct smb_vol *
3417 cifs_get_volume_info(char *mount_data, const char *devname)
3418 {
3419         int rc;
3420         struct smb_vol *volume_info;
3421
3422         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3423         if (!volume_info)
3424                 return ERR_PTR(-ENOMEM);
3425
3426         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3427         if (rc) {
3428                 cifs_cleanup_volume_info(volume_info);
3429                 volume_info = ERR_PTR(rc);
3430         }
3431
3432         return volume_info;
3433 }
3434
3435 int
3436 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3437 {
3438         int rc;
3439         unsigned int xid;
3440         struct cifs_ses *ses;
3441         struct cifs_tcon *tcon;
3442         struct TCP_Server_Info *server;
3443         char   *full_path;
3444         struct tcon_link *tlink;
3445 #ifdef CONFIG_CIFS_DFS_UPCALL
3446         int referral_walks_count = 0;
3447 #endif
3448
3449         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3450         if (rc)
3451                 return rc;
3452
3453 #ifdef CONFIG_CIFS_DFS_UPCALL
3454 try_mount_again:
3455         /* cleanup activities if we're chasing a referral */
3456         if (referral_walks_count) {
3457                 if (tcon)
3458                         cifs_put_tcon(tcon);
3459                 else if (ses)
3460                         cifs_put_smb_ses(ses);
3461
3462                 free_xid(xid);
3463         }
3464 #endif
3465         rc = 0;
3466         tcon = NULL;
3467         ses = NULL;
3468         server = NULL;
3469         full_path = NULL;
3470         tlink = NULL;
3471
3472         xid = get_xid();
3473
3474         /* get a reference to a tcp session */
3475         server = cifs_get_tcp_session(volume_info);
3476         if (IS_ERR(server)) {
3477                 rc = PTR_ERR(server);
3478                 bdi_destroy(&cifs_sb->bdi);
3479                 goto out;
3480         }
3481
3482         /* get a reference to a SMB session */
3483         ses = cifs_get_smb_ses(server, volume_info);
3484         if (IS_ERR(ses)) {
3485                 rc = PTR_ERR(ses);
3486                 ses = NULL;
3487                 goto mount_fail_check;
3488         }
3489
3490         /* search for existing tcon to this server share */
3491         tcon = cifs_get_tcon(ses, volume_info);
3492         if (IS_ERR(tcon)) {
3493                 rc = PTR_ERR(tcon);
3494                 tcon = NULL;
3495                 goto remote_path_check;
3496         }
3497
3498         /* tell server which Unix caps we support */
3499         if (cap_unix(tcon->ses)) {
3500                 /* reset of caps checks mount to see if unix extensions
3501                    disabled for just this mount */
3502                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3503                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3504                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3505                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3506                         rc = -EACCES;
3507                         goto mount_fail_check;
3508                 }
3509         } else
3510                 tcon->unix_ext = 0; /* server does not support them */
3511
3512         /* do not care if a following call succeed - informational */
3513         if (!tcon->ipc && server->ops->qfs_tcon)
3514                 server->ops->qfs_tcon(xid, tcon);
3515
3516         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3517         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3518
3519         /* tune readahead according to rsize */
3520         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3521
3522 remote_path_check:
3523 #ifdef CONFIG_CIFS_DFS_UPCALL
3524         /*
3525          * Perform an unconditional check for whether there are DFS
3526          * referrals for this path without prefix, to provide support
3527          * for DFS referrals from w2k8 servers which don't seem to respond
3528          * with PATH_NOT_COVERED to requests that include the prefix.
3529          * Chase the referral if found, otherwise continue normally.
3530          */
3531         if (referral_walks_count == 0) {
3532                 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3533                                                 false);
3534                 if (!refrc) {
3535                         referral_walks_count++;
3536                         goto try_mount_again;
3537                 }
3538         }
3539 #endif
3540
3541         /* check if a whole path is not remote */
3542         if (!rc && tcon) {
3543                 if (!server->ops->is_path_accessible) {
3544                         rc = -ENOSYS;
3545                         goto mount_fail_check;
3546                 }
3547                 /*
3548                  * cifs_build_path_to_root works only when we have a valid tcon
3549                  */
3550                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3551                 if (full_path == NULL) {
3552                         rc = -ENOMEM;
3553                         goto mount_fail_check;
3554                 }
3555                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3556                                                      full_path);
3557                 if (rc != 0 && rc != -EREMOTE) {
3558                         kfree(full_path);
3559                         goto mount_fail_check;
3560                 }
3561                 kfree(full_path);
3562         }
3563
3564         /* get referral if needed */
3565         if (rc == -EREMOTE) {
3566 #ifdef CONFIG_CIFS_DFS_UPCALL
3567                 if (referral_walks_count > MAX_NESTED_LINKS) {
3568                         /*
3569                          * BB: when we implement proper loop detection,
3570                          *     we will remove this check. But now we need it
3571                          *     to prevent an indefinite loop if 'DFS tree' is
3572                          *     misconfigured (i.e. has loops).
3573                          */
3574                         rc = -ELOOP;
3575                         goto mount_fail_check;
3576                 }
3577
3578                 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3579
3580                 if (!rc) {
3581                         referral_walks_count++;
3582                         goto try_mount_again;
3583                 }
3584                 goto mount_fail_check;
3585 #else /* No DFS support, return error on mount */
3586                 rc = -EOPNOTSUPP;
3587 #endif
3588         }
3589
3590         if (rc)
3591                 goto mount_fail_check;
3592
3593         /* now, hang the tcon off of the superblock */
3594         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3595         if (tlink == NULL) {
3596                 rc = -ENOMEM;
3597                 goto mount_fail_check;
3598         }
3599
3600         tlink->tl_uid = ses->linux_uid;
3601         tlink->tl_tcon = tcon;
3602         tlink->tl_time = jiffies;
3603         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3604         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3605
3606         cifs_sb->master_tlink = tlink;
3607         spin_lock(&cifs_sb->tlink_tree_lock);
3608         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3609         spin_unlock(&cifs_sb->tlink_tree_lock);
3610
3611         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3612                                 TLINK_IDLE_EXPIRE);
3613
3614 mount_fail_check:
3615         /* on error free sesinfo and tcon struct if needed */
3616         if (rc) {
3617                 /* If find_unc succeeded then rc == 0 so we can not end */
3618                 /* up accidentally freeing someone elses tcon struct */
3619                 if (tcon)
3620                         cifs_put_tcon(tcon);
3621                 else if (ses)
3622                         cifs_put_smb_ses(ses);
3623                 else
3624                         cifs_put_tcp_session(server);
3625                 bdi_destroy(&cifs_sb->bdi);
3626         }
3627
3628 out:
3629         free_xid(xid);
3630         return rc;
3631 }
3632
3633 /*
3634  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3635  * pointer may be NULL.
3636  */
3637 int
3638 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3639          const char *tree, struct cifs_tcon *tcon,
3640          const struct nls_table *nls_codepage)
3641 {
3642         struct smb_hdr *smb_buffer;
3643         struct smb_hdr *smb_buffer_response;
3644         TCONX_REQ *pSMB;
3645         TCONX_RSP *pSMBr;
3646         unsigned char *bcc_ptr;
3647         int rc = 0;
3648         int length;
3649         __u16 bytes_left, count;
3650
3651         if (ses == NULL)
3652                 return -EIO;
3653
3654         smb_buffer = cifs_buf_get();
3655         if (smb_buffer == NULL)
3656                 return -ENOMEM;
3657
3658         smb_buffer_response = smb_buffer;
3659
3660         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3661                         NULL /*no tid */ , 4 /*wct */ );
3662
3663         smb_buffer->Mid = get_next_mid(ses->server);
3664         smb_buffer->Uid = ses->Suid;
3665         pSMB = (TCONX_REQ *) smb_buffer;
3666         pSMBr = (TCONX_RSP *) smb_buffer_response;
3667
3668         pSMB->AndXCommand = 0xFF;
3669         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3670         bcc_ptr = &pSMB->Password[0];
3671         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3672                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3673                 *bcc_ptr = 0; /* password is null byte */
3674                 bcc_ptr++;              /* skip password */
3675                 /* already aligned so no need to do it below */
3676         } else {
3677                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3678                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3679                    specified as required (when that support is added to
3680                    the vfs in the future) as only NTLM or the much
3681                    weaker LANMAN (which we do not send by default) is accepted
3682                    by Samba (not sure whether other servers allow
3683                    NTLMv2 password here) */
3684 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3685                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3686                     (ses->sectype == LANMAN))
3687                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3688                                          ses->server->sec_mode &
3689                                             SECMODE_PW_ENCRYPT ? true : false,
3690                                          bcc_ptr);
3691                 else
3692 #endif /* CIFS_WEAK_PW_HASH */
3693                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3694                                         bcc_ptr, nls_codepage);
3695
3696                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3697                 if (ses->capabilities & CAP_UNICODE) {
3698                         /* must align unicode strings */
3699                         *bcc_ptr = 0; /* null byte password */
3700                         bcc_ptr++;
3701                 }
3702         }
3703
3704         if (ses->server->sign)
3705                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3706
3707         if (ses->capabilities & CAP_STATUS32) {
3708                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3709         }
3710         if (ses->capabilities & CAP_DFS) {
3711                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3712         }
3713         if (ses->capabilities & CAP_UNICODE) {
3714                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3715                 length =
3716                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3717                         6 /* max utf8 char length in bytes */ *
3718                         (/* server len*/ + 256 /* share len */), nls_codepage);
3719                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3720                 bcc_ptr += 2;   /* skip trailing null */
3721         } else {                /* ASCII */
3722                 strcpy(bcc_ptr, tree);
3723                 bcc_ptr += strlen(tree) + 1;
3724         }
3725         strcpy(bcc_ptr, "?????");
3726         bcc_ptr += strlen("?????");
3727         bcc_ptr += 1;
3728         count = bcc_ptr - &pSMB->Password[0];
3729         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3730                                         pSMB->hdr.smb_buf_length) + count);
3731         pSMB->ByteCount = cpu_to_le16(count);
3732
3733         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3734                          0);
3735
3736         /* above now done in SendReceive */
3737         if ((rc == 0) && (tcon != NULL)) {
3738                 bool is_unicode;
3739
3740                 tcon->tidStatus = CifsGood;
3741                 tcon->need_reconnect = false;
3742                 tcon->tid = smb_buffer_response->Tid;
3743                 bcc_ptr = pByteArea(smb_buffer_response);
3744                 bytes_left = get_bcc(smb_buffer_response);
3745                 length = strnlen(bcc_ptr, bytes_left - 2);
3746                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3747                         is_unicode = true;
3748                 else
3749                         is_unicode = false;
3750
3751
3752                 /* skip service field (NB: this field is always ASCII) */
3753                 if (length == 3) {
3754                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3755                             (bcc_ptr[2] == 'C')) {
3756                                 cifs_dbg(FYI, "IPC connection\n");
3757                                 tcon->ipc = 1;
3758                         }
3759                 } else if (length == 2) {
3760                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3761                                 /* the most common case */
3762                                 cifs_dbg(FYI, "disk share connection\n");
3763                         }
3764                 }
3765                 bcc_ptr += length + 1;
3766                 bytes_left -= (length + 1);
3767                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3768
3769                 /* mostly informational -- no need to fail on error here */
3770                 kfree(tcon->nativeFileSystem);
3771                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3772                                                       bytes_left, is_unicode,
3773                                                       nls_codepage);
3774
3775                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3776
3777                 if ((smb_buffer_response->WordCount == 3) ||
3778                          (smb_buffer_response->WordCount == 7))
3779                         /* field is in same location */
3780                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3781                 else
3782                         tcon->Flags = 0;
3783                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3784         } else if ((rc == 0) && tcon == NULL) {
3785                 /* all we need to save for IPC$ connection */
3786                 ses->ipc_tid = smb_buffer_response->Tid;
3787         }
3788
3789         cifs_buf_release(smb_buffer);
3790         return rc;
3791 }
3792
3793 static void delayed_free(struct rcu_head *p)
3794 {
3795         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3796         unload_nls(sbi->local_nls);
3797         kfree(sbi);
3798 }
3799
3800 void
3801 cifs_umount(struct cifs_sb_info *cifs_sb)
3802 {
3803         struct rb_root *root = &cifs_sb->tlink_tree;
3804         struct rb_node *node;
3805         struct tcon_link *tlink;
3806
3807         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3808
3809         spin_lock(&cifs_sb->tlink_tree_lock);
3810         while ((node = rb_first(root))) {
3811                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3812                 cifs_get_tlink(tlink);
3813                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3814                 rb_erase(node, root);
3815
3816                 spin_unlock(&cifs_sb->tlink_tree_lock);
3817                 cifs_put_tlink(tlink);
3818                 spin_lock(&cifs_sb->tlink_tree_lock);
3819         }
3820         spin_unlock(&cifs_sb->tlink_tree_lock);
3821
3822         bdi_destroy(&cifs_sb->bdi);
3823         kfree(cifs_sb->mountdata);
3824         call_rcu(&cifs_sb->rcu, delayed_free);
3825 }
3826
3827 int
3828 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3829 {
3830         int rc = 0;
3831         struct TCP_Server_Info *server = ses->server;
3832
3833         if (!server->ops->need_neg || !server->ops->negotiate)
3834                 return -ENOSYS;
3835
3836         /* only send once per connect */
3837         if (!server->ops->need_neg(server))
3838                 return 0;
3839
3840         set_credits(server, 1);
3841
3842         rc = server->ops->negotiate(xid, ses);
3843         if (rc == 0) {
3844                 spin_lock(&GlobalMid_Lock);
3845                 if (server->tcpStatus == CifsNeedNegotiate)
3846                         server->tcpStatus = CifsGood;
3847                 else
3848                         rc = -EHOSTDOWN;
3849                 spin_unlock(&GlobalMid_Lock);
3850         }
3851
3852         return rc;
3853 }
3854
3855 int
3856 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3857                    struct nls_table *nls_info)
3858 {
3859         int rc = -ENOSYS;
3860         struct TCP_Server_Info *server = ses->server;
3861
3862         ses->capabilities = server->capabilities;
3863         if (linuxExtEnabled == 0)
3864                 ses->capabilities &= (~server->vals->cap_unix);
3865
3866         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3867                  server->sec_mode, server->capabilities, server->timeAdj);
3868
3869         if (server->ops->sess_setup)
3870                 rc = server->ops->sess_setup(xid, ses, nls_info);
3871
3872         if (rc)
3873                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3874
3875         return rc;
3876 }
3877
3878 static int
3879 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3880 {
3881         vol->sectype = ses->sectype;
3882
3883         /* krb5 is special, since we don't need username or pw */
3884         if (vol->sectype == Kerberos)
3885                 return 0;
3886
3887         return cifs_set_cifscreds(vol, ses);
3888 }
3889
3890 static struct cifs_tcon *
3891 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3892 {
3893         int rc;
3894         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3895         struct cifs_ses *ses;
3896         struct cifs_tcon *tcon = NULL;
3897         struct smb_vol *vol_info;
3898
3899         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3900         if (vol_info == NULL)
3901                 return ERR_PTR(-ENOMEM);
3902
3903         vol_info->local_nls = cifs_sb->local_nls;
3904         vol_info->linux_uid = fsuid;
3905         vol_info->cred_uid = fsuid;
3906         vol_info->UNC = master_tcon->treeName;
3907         vol_info->retry = master_tcon->retry;
3908         vol_info->nocase = master_tcon->nocase;
3909         vol_info->local_lease = master_tcon->local_lease;
3910         vol_info->no_linux_ext = !master_tcon->unix_ext;
3911         vol_info->sectype = master_tcon->ses->sectype;
3912         vol_info->sign = master_tcon->ses->sign;
3913
3914         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3915         if (rc) {
3916                 tcon = ERR_PTR(rc);
3917                 goto out;
3918         }
3919
3920         /* get a reference for the same TCP session */
3921         spin_lock(&cifs_tcp_ses_lock);
3922         ++master_tcon->ses->server->srv_count;
3923         spin_unlock(&cifs_tcp_ses_lock);
3924
3925         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3926         if (IS_ERR(ses)) {
3927                 tcon = (struct cifs_tcon *)ses;
3928                 cifs_put_tcp_session(master_tcon->ses->server);
3929                 goto out;
3930         }
3931
3932         tcon = cifs_get_tcon(ses, vol_info);
3933         if (IS_ERR(tcon)) {
3934                 cifs_put_smb_ses(ses);
3935                 goto out;
3936         }
3937
3938         if (cap_unix(ses))
3939                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3940 out:
3941         kfree(vol_info->username);
3942         kfree(vol_info->password);
3943         kfree(vol_info);
3944
3945         return tcon;
3946 }
3947
3948 struct cifs_tcon *
3949 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3950 {
3951         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3952 }
3953
3954 /* find and return a tlink with given uid */
3955 static struct tcon_link *
3956 tlink_rb_search(struct rb_root *root, kuid_t uid)
3957 {
3958         struct rb_node *node = root->rb_node;
3959         struct tcon_link *tlink;
3960
3961         while (node) {
3962                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3963
3964                 if (uid_gt(tlink->tl_uid, uid))
3965                         node = node->rb_left;
3966                 else if (uid_lt(tlink->tl_uid, uid))
3967                         node = node->rb_right;
3968                 else
3969                         return tlink;
3970         }
3971         return NULL;
3972 }
3973
3974 /* insert a tcon_link into the tree */
3975 static void
3976 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3977 {
3978         struct rb_node **new = &(root->rb_node), *parent = NULL;
3979         struct tcon_link *tlink;
3980
3981         while (*new) {
3982                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3983                 parent = *new;
3984
3985                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
3986                         new = &((*new)->rb_left);
3987                 else
3988                         new = &((*new)->rb_right);
3989         }
3990
3991         rb_link_node(&new_tlink->tl_rbnode, parent, new);
3992         rb_insert_color(&new_tlink->tl_rbnode, root);
3993 }
3994
3995 /*
3996  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3997  * current task.
3998  *
3999  * If the superblock doesn't refer to a multiuser mount, then just return
4000  * the master tcon for the mount.
4001  *
4002  * First, search the rbtree for an existing tcon for this fsuid. If one
4003  * exists, then check to see if it's pending construction. If it is then wait
4004  * for construction to complete. Once it's no longer pending, check to see if
4005  * it failed and either return an error or retry construction, depending on
4006  * the timeout.
4007  *
4008  * If one doesn't exist then insert a new tcon_link struct into the tree and
4009  * try to construct a new one.
4010  */
4011 struct tcon_link *
4012 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4013 {
4014         int ret;
4015         kuid_t fsuid = current_fsuid();
4016         struct tcon_link *tlink, *newtlink;
4017
4018         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4019                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4020
4021         spin_lock(&cifs_sb->tlink_tree_lock);
4022         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4023         if (tlink)
4024                 cifs_get_tlink(tlink);
4025         spin_unlock(&cifs_sb->tlink_tree_lock);
4026
4027         if (tlink == NULL) {
4028                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4029                 if (newtlink == NULL)
4030                         return ERR_PTR(-ENOMEM);
4031                 newtlink->tl_uid = fsuid;
4032                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4033                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4034                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4035                 cifs_get_tlink(newtlink);
4036
4037                 spin_lock(&cifs_sb->tlink_tree_lock);
4038                 /* was one inserted after previous search? */
4039                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4040                 if (tlink) {
4041                         cifs_get_tlink(tlink);
4042                         spin_unlock(&cifs_sb->tlink_tree_lock);
4043                         kfree(newtlink);
4044                         goto wait_for_construction;
4045                 }
4046                 tlink = newtlink;
4047                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4048                 spin_unlock(&cifs_sb->tlink_tree_lock);
4049         } else {
4050 wait_for_construction:
4051                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4052                                   TASK_INTERRUPTIBLE);
4053                 if (ret) {
4054                         cifs_put_tlink(tlink);
4055                         return ERR_PTR(-ERESTARTSYS);
4056                 }
4057
4058                 /* if it's good, return it */
4059                 if (!IS_ERR(tlink->tl_tcon))
4060                         return tlink;
4061
4062                 /* return error if we tried this already recently */
4063                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4064                         cifs_put_tlink(tlink);
4065                         return ERR_PTR(-EACCES);
4066                 }
4067
4068                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4069                         goto wait_for_construction;
4070         }
4071
4072         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4073         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4074         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4075
4076         if (IS_ERR(tlink->tl_tcon)) {
4077                 cifs_put_tlink(tlink);
4078                 return ERR_PTR(-EACCES);
4079         }
4080
4081         return tlink;
4082 }
4083
4084 /*
4085  * periodic workqueue job that scans tcon_tree for a superblock and closes
4086  * out tcons.
4087  */
4088 static void
4089 cifs_prune_tlinks(struct work_struct *work)
4090 {
4091         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4092                                                     prune_tlinks.work);
4093         struct rb_root *root = &cifs_sb->tlink_tree;
4094         struct rb_node *node = rb_first(root);
4095         struct rb_node *tmp;
4096         struct tcon_link *tlink;
4097
4098         /*
4099          * Because we drop the spinlock in the loop in order to put the tlink
4100          * it's not guarded against removal of links from the tree. The only
4101          * places that remove entries from the tree are this function and
4102          * umounts. Because this function is non-reentrant and is canceled
4103          * before umount can proceed, this is safe.
4104          */
4105         spin_lock(&cifs_sb->tlink_tree_lock);
4106         node = rb_first(root);
4107         while (node != NULL) {
4108                 tmp = node;
4109                 node = rb_next(tmp);
4110                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4111
4112                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4113                     atomic_read(&tlink->tl_count) != 0 ||
4114                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4115                         continue;
4116
4117                 cifs_get_tlink(tlink);
4118                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4119                 rb_erase(tmp, root);
4120
4121                 spin_unlock(&cifs_sb->tlink_tree_lock);
4122                 cifs_put_tlink(tlink);
4123                 spin_lock(&cifs_sb->tlink_tree_lock);
4124         }
4125         spin_unlock(&cifs_sb->tlink_tree_lock);
4126
4127         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4128                                 TLINK_IDLE_EXPIRE);
4129 }