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