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