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