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