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