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