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