fs/cifs/connect.c

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