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->ops->need_neg || server->ops->need_neg(server) ||
 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         unsigned 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 && server->ops->logoff) {
2270                 xid = GetXid();
2271                 server->ops->logoff(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;
2410         unsigned int xid;
2411         struct cifs_ses *ses;
2412         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2413         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2414
2415         xid = GetXid();
2416
2417         ses = cifs_find_smb_ses(server, volume_info);
2418         if (ses) {
2419                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2420
2421                 mutex_lock(&ses->session_mutex);
2422                 rc = cifs_negotiate_protocol(xid, ses);
2423                 if (rc) {
2424                         mutex_unlock(&ses->session_mutex);
2425                         /* problem -- put our ses reference */
2426                         cifs_put_smb_ses(ses);
2427                         FreeXid(xid);
2428                         return ERR_PTR(rc);
2429                 }
2430                 if (ses->need_reconnect) {
2431                         cFYI(1, "Session needs reconnect");
2432                         rc = cifs_setup_session(xid, ses,
2433                                                 volume_info->local_nls);
2434                         if (rc) {
2435                                 mutex_unlock(&ses->session_mutex);
2436                                 /* problem -- put our reference */
2437                                 cifs_put_smb_ses(ses);
2438                                 FreeXid(xid);
2439                                 return ERR_PTR(rc);
2440                         }
2441                 }
2442                 mutex_unlock(&ses->session_mutex);
2443
2444                 /* existing SMB ses has a server reference already */
2445                 cifs_put_tcp_session(server);
2446                 FreeXid(xid);
2447                 return ses;
2448         }
2449
2450         cFYI(1, "Existing smb sess not found");
2451         ses = sesInfoAlloc();
2452         if (ses == NULL)
2453                 goto get_ses_fail;
2454
2455         /* new SMB session uses our server ref */
2456         ses->server = server;
2457         if (server->dstaddr.ss_family == AF_INET6)
2458                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2459         else
2460                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2461
2462         if (volume_info->username) {
2463                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2464                 if (!ses->user_name)
2465                         goto get_ses_fail;
2466         }
2467
2468         /* volume_info->password freed at unmount */
2469         if (volume_info->password) {
2470                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2471                 if (!ses->password)
2472                         goto get_ses_fail;
2473         }
2474         if (volume_info->domainname) {
2475                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2476                 if (!ses->domainName)
2477                         goto get_ses_fail;
2478         }
2479         ses->cred_uid = volume_info->cred_uid;
2480         ses->linux_uid = volume_info->linux_uid;
2481
2482         /* ntlmv2 is much stronger than ntlm security, and has been broadly
2483         supported for many years, time to update default security mechanism */
2484         if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2485                 warned_on_ntlm = true;
2486                 cERROR(1, "default security mechanism requested.  The default "
2487                         "security mechanism will be upgraded from ntlm to "
2488                         "ntlmv2 in kernel release 3.3");
2489         }
2490         ses->overrideSecFlg = volume_info->secFlg;
2491
2492         mutex_lock(&ses->session_mutex);
2493         rc = cifs_negotiate_protocol(xid, ses);
2494         if (!rc)
2495                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2496         mutex_unlock(&ses->session_mutex);
2497         if (rc)
2498                 goto get_ses_fail;
2499
2500         /* success, put it on the list */
2501         spin_lock(&cifs_tcp_ses_lock);
2502         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2503         spin_unlock(&cifs_tcp_ses_lock);
2504
2505         FreeXid(xid);
2506         return ses;
2507
2508 get_ses_fail:
2509         sesInfoFree(ses);
2510         FreeXid(xid);
2511         return ERR_PTR(rc);
2512 }
2513
2514 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2515 {
2516         if (tcon->tidStatus == CifsExiting)
2517                 return 0;
2518         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2519                 return 0;
2520         return 1;
2521 }
2522
2523 static struct cifs_tcon *
2524 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2525 {
2526         struct list_head *tmp;
2527         struct cifs_tcon *tcon;
2528
2529         spin_lock(&cifs_tcp_ses_lock);
2530         list_for_each(tmp, &ses->tcon_list) {
2531                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2532                 if (!match_tcon(tcon, unc))
2533                         continue;
2534                 ++tcon->tc_count;
2535                 spin_unlock(&cifs_tcp_ses_lock);
2536                 return tcon;
2537         }
2538         spin_unlock(&cifs_tcp_ses_lock);
2539         return NULL;
2540 }
2541
2542 static void
2543 cifs_put_tcon(struct cifs_tcon *tcon)
2544 {
2545         unsigned int xid;
2546         struct cifs_ses *ses = tcon->ses;
2547
2548         cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2549         spin_lock(&cifs_tcp_ses_lock);
2550         if (--tcon->tc_count > 0) {
2551                 spin_unlock(&cifs_tcp_ses_lock);
2552                 return;
2553         }
2554
2555         list_del_init(&tcon->tcon_list);
2556         spin_unlock(&cifs_tcp_ses_lock);
2557
2558         xid = GetXid();
2559         if (ses->server->ops->tree_disconnect)
2560                 ses->server->ops->tree_disconnect(xid, tcon);
2561         _FreeXid(xid);
2562
2563         cifs_fscache_release_super_cookie(tcon);
2564         tconInfoFree(tcon);
2565         cifs_put_smb_ses(ses);
2566 }
2567
2568 static struct cifs_tcon *
2569 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2570 {
2571         int rc, xid;
2572         struct cifs_tcon *tcon;
2573
2574         tcon = cifs_find_tcon(ses, volume_info->UNC);
2575         if (tcon) {
2576                 cFYI(1, "Found match on UNC path");
2577                 /* existing tcon already has a reference */
2578                 cifs_put_smb_ses(ses);
2579                 if (tcon->seal != volume_info->seal)
2580                         cERROR(1, "transport encryption setting "
2581                                    "conflicts with existing tid");
2582                 return tcon;
2583         }
2584
2585         if (!ses->server->ops->tree_connect) {
2586                 rc = -ENOSYS;
2587                 goto out_fail;
2588         }
2589
2590         tcon = tconInfoAlloc();
2591         if (tcon == NULL) {
2592                 rc = -ENOMEM;
2593                 goto out_fail;
2594         }
2595
2596         tcon->ses = ses;
2597         if (volume_info->password) {
2598                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2599                 if (!tcon->password) {
2600                         rc = -ENOMEM;
2601                         goto out_fail;
2602                 }
2603         }
2604
2605         if (strchr(volume_info->UNC + 3, '\\') == NULL
2606             && strchr(volume_info->UNC + 3, '/') == NULL) {
2607                 cERROR(1, "Missing share name");
2608                 rc = -ENODEV;
2609                 goto out_fail;
2610         }
2611
2612         /*
2613          * BB Do we need to wrap session_mutex around this TCon call and Unix
2614          * SetFS as we do on SessSetup and reconnect?
2615          */
2616         xid = GetXid();
2617         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2618                                             volume_info->local_nls);
2619         FreeXid(xid);
2620         cFYI(1, "Tcon rc = %d", rc);
2621         if (rc)
2622                 goto out_fail;
2623
2624         if (volume_info->nodfs) {
2625                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2626                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2627         }
2628         tcon->seal = volume_info->seal;
2629         /*
2630          * We can have only one retry value for a connection to a share so for
2631          * resources mounted more than once to the same server share the last
2632          * value passed in for the retry flag is used.
2633          */
2634         tcon->retry = volume_info->retry;
2635         tcon->nocase = volume_info->nocase;
2636         tcon->local_lease = volume_info->local_lease;
2637
2638         spin_lock(&cifs_tcp_ses_lock);
2639         list_add(&tcon->tcon_list, &ses->tcon_list);
2640         spin_unlock(&cifs_tcp_ses_lock);
2641
2642         cifs_fscache_get_super_cookie(tcon);
2643
2644         return tcon;
2645
2646 out_fail:
2647         tconInfoFree(tcon);
2648         return ERR_PTR(rc);
2649 }
2650
2651 void
2652 cifs_put_tlink(struct tcon_link *tlink)
2653 {
2654         if (!tlink || IS_ERR(tlink))
2655                 return;
2656
2657         if (!atomic_dec_and_test(&tlink->tl_count) ||
2658             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2659                 tlink->tl_time = jiffies;
2660                 return;
2661         }
2662
2663         if (!IS_ERR(tlink_tcon(tlink)))
2664                 cifs_put_tcon(tlink_tcon(tlink));
2665         kfree(tlink);
2666         return;
2667 }
2668
2669 static inline struct tcon_link *
2670 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2671 {
2672         return cifs_sb->master_tlink;
2673 }
2674
2675 static int
2676 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2677 {
2678         struct cifs_sb_info *old = CIFS_SB(sb);
2679         struct cifs_sb_info *new = mnt_data->cifs_sb;
2680
2681         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2682                 return 0;
2683
2684         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2685             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2686                 return 0;
2687
2688         /*
2689          * We want to share sb only if we don't specify an r/wsize or
2690          * specified r/wsize is greater than or equal to existing one.
2691          */
2692         if (new->wsize && new->wsize < old->wsize)
2693                 return 0;
2694
2695         if (new->rsize && new->rsize < old->rsize)
2696                 return 0;
2697
2698         if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2699                 return 0;
2700
2701         if (old->mnt_file_mode != new->mnt_file_mode ||
2702             old->mnt_dir_mode != new->mnt_dir_mode)
2703                 return 0;
2704
2705         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2706                 return 0;
2707
2708         if (old->actimeo != new->actimeo)
2709                 return 0;
2710
2711         return 1;
2712 }
2713
2714 int
2715 cifs_match_super(struct super_block *sb, void *data)
2716 {
2717         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2718         struct smb_vol *volume_info;
2719         struct cifs_sb_info *cifs_sb;
2720         struct TCP_Server_Info *tcp_srv;
2721         struct cifs_ses *ses;
2722         struct cifs_tcon *tcon;
2723         struct tcon_link *tlink;
2724         struct sockaddr_storage addr;
2725         int rc = 0;
2726
2727         memset(&addr, 0, sizeof(struct sockaddr_storage));
2728
2729         spin_lock(&cifs_tcp_ses_lock);
2730         cifs_sb = CIFS_SB(sb);
2731         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2732         if (IS_ERR(tlink)) {
2733                 spin_unlock(&cifs_tcp_ses_lock);
2734                 return rc;
2735         }
2736         tcon = tlink_tcon(tlink);
2737         ses = tcon->ses;
2738         tcp_srv = ses->server;
2739
2740         volume_info = mnt_data->vol;
2741
2742         if (!volume_info->UNCip || !volume_info->UNC)
2743                 goto out;
2744
2745         rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2746                                 volume_info->UNCip,
2747                                 strlen(volume_info->UNCip),
2748                                 volume_info->port);
2749         if (!rc)
2750                 goto out;
2751
2752         if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2753             !match_session(ses, volume_info) ||
2754             !match_tcon(tcon, volume_info->UNC)) {
2755                 rc = 0;
2756                 goto out;
2757         }
2758
2759         rc = compare_mount_options(sb, mnt_data);
2760 out:
2761         spin_unlock(&cifs_tcp_ses_lock);
2762         cifs_put_tlink(tlink);
2763         return rc;
2764 }
2765
2766 int
2767 get_dfs_path(int xid, struct cifs_ses *ses, const char *old_path,
2768              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2769              struct dfs_info3_param **referrals, int remap)
2770 {
2771         char *temp_unc;
2772         int rc = 0;
2773
2774         if (!ses->server->ops->tree_connect)
2775                 return -ENOSYS;
2776
2777         *num_referrals = 0;
2778         *referrals = NULL;
2779
2780         if (ses->ipc_tid == 0) {
2781                 temp_unc = kmalloc(2 /* for slashes */ +
2782                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2783                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2784                 if (temp_unc == NULL)
2785                         return -ENOMEM;
2786                 temp_unc[0] = '\\';
2787                 temp_unc[1] = '\\';
2788                 strcpy(temp_unc + 2, ses->serverName);
2789                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2790                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2791                                                     nls_codepage);
2792                 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
2793                 kfree(temp_unc);
2794         }
2795         if (rc == 0)
2796                 rc = CIFSGetDFSRefer(xid, ses, old_path, referrals,
2797                                      num_referrals, nls_codepage, remap);
2798         /*
2799          * BB - map targetUNCs to dfs_info3 structures, here or in
2800          * CIFSGetDFSRefer.
2801          */
2802
2803         return rc;
2804 }
2805
2806 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2807 static struct lock_class_key cifs_key[2];
2808 static struct lock_class_key cifs_slock_key[2];
2809
2810 static inline void
2811 cifs_reclassify_socket4(struct socket *sock)
2812 {
2813         struct sock *sk = sock->sk;
2814         BUG_ON(sock_owned_by_user(sk));
2815         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2816                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2817 }
2818
2819 static inline void
2820 cifs_reclassify_socket6(struct socket *sock)
2821 {
2822         struct sock *sk = sock->sk;
2823         BUG_ON(sock_owned_by_user(sk));
2824         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2825                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2826 }
2827 #else
2828 static inline void
2829 cifs_reclassify_socket4(struct socket *sock)
2830 {
2831 }
2832
2833 static inline void
2834 cifs_reclassify_socket6(struct socket *sock)
2835 {
2836 }
2837 #endif
2838
2839 /* See RFC1001 section 14 on representation of Netbios names */
2840 static void rfc1002mangle(char *target, char *source, unsigned int length)
2841 {
2842         unsigned int i, j;
2843
2844         for (i = 0, j = 0; i < (length); i++) {
2845                 /* mask a nibble at a time and encode */
2846                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2847                 target[j+1] = 'A' + (0x0F & source[i]);
2848                 j += 2;
2849         }
2850
2851 }
2852
2853 static int
2854 bind_socket(struct TCP_Server_Info *server)
2855 {
2856         int rc = 0;
2857         if (server->srcaddr.ss_family != AF_UNSPEC) {
2858                 /* Bind to the specified local IP address */
2859                 struct socket *socket = server->ssocket;
2860                 rc = socket->ops->bind(socket,
2861                                        (struct sockaddr *) &server->srcaddr,
2862                                        sizeof(server->srcaddr));
2863                 if (rc < 0) {
2864                         struct sockaddr_in *saddr4;
2865                         struct sockaddr_in6 *saddr6;
2866                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2867                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2868                         if (saddr6->sin6_family == AF_INET6)
2869                                 cERROR(1, "cifs: "
2870                                        "Failed to bind to: %pI6c, error: %d",
2871                                        &saddr6->sin6_addr, rc);
2872                         else
2873                                 cERROR(1, "cifs: "
2874                                        "Failed to bind to: %pI4, error: %d",
2875                                        &saddr4->sin_addr.s_addr, rc);
2876                 }
2877         }
2878         return rc;
2879 }
2880
2881 static int
2882 ip_rfc1001_connect(struct TCP_Server_Info *server)
2883 {
2884         int rc = 0;
2885         /*
2886          * some servers require RFC1001 sessinit before sending
2887          * negprot - BB check reconnection in case where second
2888          * sessinit is sent but no second negprot
2889          */
2890         struct rfc1002_session_packet *ses_init_buf;
2891         struct smb_hdr *smb_buf;
2892         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2893                                GFP_KERNEL);
2894         if (ses_init_buf) {
2895                 ses_init_buf->trailer.session_req.called_len = 32;
2896
2897                 if (server->server_RFC1001_name &&
2898                     server->server_RFC1001_name[0] != 0)
2899                         rfc1002mangle(ses_init_buf->trailer.
2900                                       session_req.called_name,
2901                                       server->server_RFC1001_name,
2902                                       RFC1001_NAME_LEN_WITH_NULL);
2903                 else
2904                         rfc1002mangle(ses_init_buf->trailer.
2905                                       session_req.called_name,
2906                                       DEFAULT_CIFS_CALLED_NAME,
2907                                       RFC1001_NAME_LEN_WITH_NULL);
2908
2909                 ses_init_buf->trailer.session_req.calling_len = 32;
2910
2911                 /*
2912                  * calling name ends in null (byte 16) from old smb
2913                  * convention.
2914                  */
2915                 if (server->workstation_RFC1001_name &&
2916                     server->workstation_RFC1001_name[0] != 0)
2917                         rfc1002mangle(ses_init_buf->trailer.
2918                                       session_req.calling_name,
2919                                       server->workstation_RFC1001_name,
2920                                       RFC1001_NAME_LEN_WITH_NULL);
2921                 else
2922                         rfc1002mangle(ses_init_buf->trailer.
2923                                       session_req.calling_name,
2924                                       "LINUX_CIFS_CLNT",
2925                                       RFC1001_NAME_LEN_WITH_NULL);
2926
2927                 ses_init_buf->trailer.session_req.scope1 = 0;
2928                 ses_init_buf->trailer.session_req.scope2 = 0;
2929                 smb_buf = (struct smb_hdr *)ses_init_buf;
2930
2931                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2932                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2933                 rc = smb_send(server, smb_buf, 0x44);
2934                 kfree(ses_init_buf);
2935                 /*
2936                  * RFC1001 layer in at least one server
2937                  * requires very short break before negprot
2938                  * presumably because not expecting negprot
2939                  * to follow so fast.  This is a simple
2940                  * solution that works without
2941                  * complicating the code and causes no
2942                  * significant slowing down on mount
2943                  * for everyone else
2944                  */
2945                 usleep_range(1000, 2000);
2946         }
2947         /*
2948          * else the negprot may still work without this
2949          * even though malloc failed
2950          */
2951
2952         return rc;
2953 }
2954
2955 static int
2956 generic_ip_connect(struct TCP_Server_Info *server)
2957 {
2958         int rc = 0;
2959         __be16 sport;
2960         int slen, sfamily;
2961         struct socket *socket = server->ssocket;
2962         struct sockaddr *saddr;
2963
2964         saddr = (struct sockaddr *) &server->dstaddr;
2965
2966         if (server->dstaddr.ss_family == AF_INET6) {
2967                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2968                 slen = sizeof(struct sockaddr_in6);
2969                 sfamily = AF_INET6;
2970         } else {
2971                 sport = ((struct sockaddr_in *) saddr)->sin_port;
2972                 slen = sizeof(struct sockaddr_in);
2973                 sfamily = AF_INET;
2974         }
2975
2976         if (socket == NULL) {
2977                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2978                                    IPPROTO_TCP, &socket, 1);
2979                 if (rc < 0) {
2980                         cERROR(1, "Error %d creating socket", rc);
2981                         server->ssocket = NULL;
2982                         return rc;
2983                 }
2984
2985                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2986                 cFYI(1, "Socket created");
2987                 server->ssocket = socket;
2988                 socket->sk->sk_allocation = GFP_NOFS;
2989                 if (sfamily == AF_INET6)
2990                         cifs_reclassify_socket6(socket);
2991                 else
2992                         cifs_reclassify_socket4(socket);
2993         }
2994
2995         rc = bind_socket(server);
2996         if (rc < 0)
2997                 return rc;
2998
2999         /*
3000          * Eventually check for other socket options to change from
3001          * the default. sock_setsockopt not used because it expects
3002          * user space buffer
3003          */
3004         socket->sk->sk_rcvtimeo = 7 * HZ;
3005         socket->sk->sk_sndtimeo = 5 * HZ;
3006
3007         /* make the bufsizes depend on wsize/rsize and max requests */
3008         if (server->noautotune) {
3009                 if (socket->sk->sk_sndbuf < (200 * 1024))
3010                         socket->sk->sk_sndbuf = 200 * 1024;
3011                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3012                         socket->sk->sk_rcvbuf = 140 * 1024;
3013         }
3014
3015         if (server->tcp_nodelay) {
3016                 int val = 1;
3017                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3018                                 (char *)&val, sizeof(val));
3019                 if (rc)
3020                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3021         }
3022
3023          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3024                  socket->sk->sk_sndbuf,
3025                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3026
3027         rc = socket->ops->connect(socket, saddr, slen, 0);
3028         if (rc < 0) {
3029                 cFYI(1, "Error %d connecting to server", rc);
3030                 sock_release(socket);
3031                 server->ssocket = NULL;
3032                 return rc;
3033         }
3034
3035         if (sport == htons(RFC1001_PORT))
3036                 rc = ip_rfc1001_connect(server);
3037
3038         return rc;
3039 }
3040
3041 static int
3042 ip_connect(struct TCP_Server_Info *server)
3043 {
3044         __be16 *sport;
3045         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3046         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3047
3048         if (server->dstaddr.ss_family == AF_INET6)
3049                 sport = &addr6->sin6_port;
3050         else
3051                 sport = &addr->sin_port;
3052
3053         if (*sport == 0) {
3054                 int rc;
3055
3056                 /* try with 445 port at first */
3057                 *sport = htons(CIFS_PORT);
3058
3059                 rc = generic_ip_connect(server);
3060                 if (rc >= 0)
3061                         return rc;
3062
3063                 /* if it failed, try with 139 port */
3064                 *sport = htons(RFC1001_PORT);
3065         }
3066
3067         return generic_ip_connect(server);
3068 }
3069
3070 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
3071                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3072 {
3073         /* if we are reconnecting then should we check to see if
3074          * any requested capabilities changed locally e.g. via
3075          * remount but we can not do much about it here
3076          * if they have (even if we could detect it by the following)
3077          * Perhaps we could add a backpointer to array of sb from tcon
3078          * or if we change to make all sb to same share the same
3079          * sb as NFS - then we only have one backpointer to sb.
3080          * What if we wanted to mount the server share twice once with
3081          * and once without posixacls or posix paths? */
3082         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3083
3084         if (vol_info && vol_info->no_linux_ext) {
3085                 tcon->fsUnixInfo.Capability = 0;
3086                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3087                 cFYI(1, "Linux protocol extensions disabled");
3088                 return;
3089         } else if (vol_info)
3090                 tcon->unix_ext = 1; /* Unix Extensions supported */
3091
3092         if (tcon->unix_ext == 0) {
3093                 cFYI(1, "Unix extensions disabled so not set on reconnect");
3094                 return;
3095         }
3096
3097         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3098                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3099                 cFYI(1, "unix caps which server supports %lld", cap);
3100                 /* check for reconnect case in which we do not
3101                    want to change the mount behavior if we can avoid it */
3102                 if (vol_info == NULL) {
3103                         /* turn off POSIX ACL and PATHNAMES if not set
3104                            originally at mount time */
3105                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3106                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3107                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3108                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3109                                         cERROR(1, "POSIXPATH support change");
3110                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3111                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3112                                 cERROR(1, "possible reconnect error");
3113                                 cERROR(1, "server disabled POSIX path support");
3114                         }
3115                 }
3116
3117                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3118                         cERROR(1, "per-share encryption not supported yet");
3119
3120                 cap &= CIFS_UNIX_CAP_MASK;
3121                 if (vol_info && vol_info->no_psx_acl)
3122                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3123                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3124                         cFYI(1, "negotiated posix acl support");
3125                         if (cifs_sb)
3126                                 cifs_sb->mnt_cifs_flags |=
3127                                         CIFS_MOUNT_POSIXACL;
3128                 }
3129
3130                 if (vol_info && vol_info->posix_paths == 0)
3131                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3132                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3133                         cFYI(1, "negotiate posix pathnames");
3134                         if (cifs_sb)
3135                                 cifs_sb->mnt_cifs_flags |=
3136                                         CIFS_MOUNT_POSIX_PATHS;
3137                 }
3138
3139                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3140 #ifdef CONFIG_CIFS_DEBUG2
3141                 if (cap & CIFS_UNIX_FCNTL_CAP)
3142                         cFYI(1, "FCNTL cap");
3143                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3144                         cFYI(1, "EXTATTR cap");
3145                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3146                         cFYI(1, "POSIX path cap");
3147                 if (cap & CIFS_UNIX_XATTR_CAP)
3148                         cFYI(1, "XATTR cap");
3149                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3150                         cFYI(1, "POSIX ACL cap");
3151                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3152                         cFYI(1, "very large read cap");
3153                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3154                         cFYI(1, "very large write cap");
3155                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3156                         cFYI(1, "transport encryption cap");
3157                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3158                         cFYI(1, "mandatory transport encryption cap");
3159 #endif /* CIFS_DEBUG2 */
3160                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3161                         if (vol_info == NULL) {
3162                                 cFYI(1, "resetting capabilities failed");
3163                         } else
3164                                 cERROR(1, "Negotiating Unix capabilities "
3165                                            "with the server failed. Consider "
3166                                            "mounting with the Unix Extensions "
3167                                            "disabled if problems are found "
3168                                            "by specifying the nounix mount "
3169                                            "option.");
3170
3171                 }
3172         }
3173 }
3174
3175 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3176                         struct cifs_sb_info *cifs_sb)
3177 {
3178         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3179
3180         spin_lock_init(&cifs_sb->tlink_tree_lock);
3181         cifs_sb->tlink_tree = RB_ROOT;
3182
3183         /*
3184          * Temporarily set r/wsize for matching superblock. If we end up using
3185          * new sb then client will later negotiate it downward if needed.
3186          */
3187         cifs_sb->rsize = pvolume_info->rsize;
3188         cifs_sb->wsize = pvolume_info->wsize;
3189
3190         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3191         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3192         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3193         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3194         cFYI(1, "file mode: 0x%hx  dir mode: 0x%hx",
3195                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3196
3197         cifs_sb->actimeo = pvolume_info->actimeo;
3198         cifs_sb->local_nls = pvolume_info->local_nls;
3199
3200         if (pvolume_info->noperm)
3201                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3202         if (pvolume_info->setuids)
3203                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3204         if (pvolume_info->server_ino)
3205                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3206         if (pvolume_info->remap)
3207                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3208         if (pvolume_info->no_xattr)
3209                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3210         if (pvolume_info->sfu_emul)
3211                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3212         if (pvolume_info->nobrl)
3213                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3214         if (pvolume_info->nostrictsync)
3215                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3216         if (pvolume_info->mand_lock)
3217                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3218         if (pvolume_info->rwpidforward)
3219                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3220         if (pvolume_info->cifs_acl)
3221                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3222         if (pvolume_info->backupuid_specified) {
3223                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3224                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3225         }
3226         if (pvolume_info->backupgid_specified) {
3227                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3228                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3229         }
3230         if (pvolume_info->override_uid)
3231                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3232         if (pvolume_info->override_gid)
3233                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3234         if (pvolume_info->dynperm)
3235                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3236         if (pvolume_info->fsc)
3237                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3238         if (pvolume_info->multiuser)
3239                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3240                                             CIFS_MOUNT_NO_PERM);
3241         if (pvolume_info->strict_io)
3242                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3243         if (pvolume_info->direct_io) {
3244                 cFYI(1, "mounting share using direct i/o");
3245                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3246         }
3247         if (pvolume_info->mfsymlinks) {
3248                 if (pvolume_info->sfu_emul) {
3249                         cERROR(1,  "mount option mfsymlinks ignored if sfu "
3250                                    "mount option is used");
3251                 } else {
3252                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3253                 }
3254         }
3255
3256         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3257                 cERROR(1, "mount option dynperm ignored if cifsacl "
3258                            "mount option supported");
3259 }
3260
3261 /*
3262  * When the server supports very large reads and writes via POSIX extensions,
3263  * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3264  * including the RFC1001 length.
3265  *
3266  * Note that this might make for "interesting" allocation problems during
3267  * writeback however as we have to allocate an array of pointers for the
3268  * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3269  *
3270  * For reads, there is a similar problem as we need to allocate an array
3271  * of kvecs to handle the receive, though that should only need to be done
3272  * once.
3273  */
3274 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3275 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3276
3277 /*
3278  * When the server doesn't allow large posix writes, only allow a rsize/wsize
3279  * of 2^17-1 minus the size of the call header. That allows for a read or
3280  * write up to the maximum size described by RFC1002.
3281  */
3282 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3283 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3284
3285 /*
3286  * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3287  * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3288  * a single wsize request with a single call.
3289  */
3290 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3291
3292 /*
3293  * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3294  * those values when posix extensions aren't in force. In actuality here, we
3295  * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3296  * to be ok with the extra byte even though Windows doesn't send writes that
3297  * are that large.
3298  *
3299  * Citation:
3300  *
3301  * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3302  */
3303 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3304 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3305
3306 /*
3307  * On hosts with high memory, we can't currently support wsize/rsize that are
3308  * larger than we can kmap at once. Cap the rsize/wsize at
3309  * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
3310  * larger than that anyway.
3311  */
3312 #ifdef CONFIG_HIGHMEM
3313 #define CIFS_KMAP_SIZE_LIMIT    (LAST_PKMAP * PAGE_CACHE_SIZE)
3314 #else /* CONFIG_HIGHMEM */
3315 #define CIFS_KMAP_SIZE_LIMIT    (1<<24)
3316 #endif /* CONFIG_HIGHMEM */
3317
3318 static unsigned int
3319 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3320 {
3321         __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3322         struct TCP_Server_Info *server = tcon->ses->server;
3323         unsigned int wsize;
3324
3325         /* start with specified wsize, or default */
3326         if (pvolume_info->wsize)
3327                 wsize = pvolume_info->wsize;
3328         else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3329                 wsize = CIFS_DEFAULT_IOSIZE;
3330         else
3331                 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3332
3333         /* can server support 24-bit write sizes? (via UNIX extensions) */
3334         if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3335                 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3336
3337         /*
3338          * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3339          * Limit it to max buffer offered by the server, minus the size of the
3340          * WRITEX header, not including the 4 byte RFC1001 length.
3341          */
3342         if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3343             (!(server->capabilities & CAP_UNIX) &&
3344              (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3345                 wsize = min_t(unsigned int, wsize,
3346                                 server->maxBuf - sizeof(WRITE_REQ) + 4);
3347
3348         /* limit to the amount that we can kmap at once */
3349         wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
3350
3351         /* hard limit of CIFS_MAX_WSIZE */
3352         wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3353
3354         return wsize;
3355 }
3356
3357 static unsigned int
3358 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3359 {
3360         __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3361         struct TCP_Server_Info *server = tcon->ses->server;
3362         unsigned int rsize, defsize;
3363
3364         /*
3365          * Set default value...
3366          *
3367          * HACK alert! Ancient servers have very small buffers. Even though
3368          * MS-CIFS indicates that servers are only limited by the client's
3369          * bufsize for reads, testing against win98se shows that it throws
3370          * INVALID_PARAMETER errors if you try to request too large a read.
3371          * OS/2 just sends back short reads.
3372          *
3373          * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
3374          * it can't handle a read request larger than its MaxBufferSize either.
3375          */
3376         if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3377                 defsize = CIFS_DEFAULT_IOSIZE;
3378         else if (server->capabilities & CAP_LARGE_READ_X)
3379                 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3380         else
3381                 defsize = server->maxBuf - sizeof(READ_RSP);
3382
3383         rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3384
3385         /*
3386          * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3387          * the client's MaxBufferSize.
3388          */
3389         if (!(server->capabilities & CAP_LARGE_READ_X))
3390                 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3391
3392         /* limit to the amount that we can kmap at once */
3393         rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
3394
3395         /* hard limit of CIFS_MAX_RSIZE */
3396         rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3397
3398         return rsize;
3399 }
3400
3401 static int
3402 is_path_accessible(int xid, struct cifs_tcon *tcon,
3403                    struct cifs_sb_info *cifs_sb, const char *full_path)
3404 {
3405         int rc;
3406         FILE_ALL_INFO *pfile_info;
3407
3408         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3409         if (pfile_info == NULL)
3410                 return -ENOMEM;
3411
3412         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3413                               0 /* not legacy */, cifs_sb->local_nls,
3414                               cifs_sb->mnt_cifs_flags &
3415                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
3416
3417         if (rc == -EOPNOTSUPP || rc == -EINVAL)
3418                 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3419                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3420                                   CIFS_MOUNT_MAP_SPECIAL_CHR);
3421         kfree(pfile_info);
3422         return rc;
3423 }
3424
3425 static void
3426 cleanup_volume_info_contents(struct smb_vol *volume_info)
3427 {
3428         kfree(volume_info->username);
3429         kzfree(volume_info->password);
3430         if (volume_info->UNCip != volume_info->UNC + 2)
3431                 kfree(volume_info->UNCip);
3432         kfree(volume_info->UNC);
3433         kfree(volume_info->domainname);
3434         kfree(volume_info->iocharset);
3435         kfree(volume_info->prepath);
3436 }
3437
3438 void
3439 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3440 {
3441         if (!volume_info)
3442                 return;
3443         cleanup_volume_info_contents(volume_info);
3444         kfree(volume_info);
3445 }
3446
3447
3448 #ifdef CONFIG_CIFS_DFS_UPCALL
3449 /* build_path_to_root returns full path to root when
3450  * we do not have an exiting connection (tcon) */
3451 static char *
3452 build_unc_path_to_root(const struct smb_vol *vol,
3453                 const struct cifs_sb_info *cifs_sb)
3454 {
3455         char *full_path, *pos;
3456         unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3457         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3458
3459         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3460         if (full_path == NULL)
3461                 return ERR_PTR(-ENOMEM);
3462
3463         strncpy(full_path, vol->UNC, unc_len);
3464         pos = full_path + unc_len;
3465
3466         if (pplen) {
3467                 strncpy(pos, vol->prepath, pplen);
3468                 pos += pplen;
3469         }
3470
3471         *pos = '\0'; /* add trailing null */
3472         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3473         cFYI(1, "%s: full_path=%s", __func__, full_path);
3474         return full_path;
3475 }
3476
3477 /*
3478  * Perform a dfs referral query for a share and (optionally) prefix
3479  *
3480  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3481  * to a string containing updated options for the submount.  Otherwise it
3482  * will be left untouched.
3483  *
3484  * Returns the rc from get_dfs_path to the caller, which can be used to
3485  * determine whether there were referrals.
3486  */
3487 static int
3488 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3489                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3490                     int check_prefix)
3491 {
3492         int rc;
3493         unsigned int num_referrals = 0;
3494         struct dfs_info3_param *referrals = NULL;
3495         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3496
3497         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3498         if (IS_ERR(full_path))
3499                 return PTR_ERR(full_path);
3500
3501         /* For DFS paths, skip the first '\' of the UNC */
3502         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3503
3504         rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3505                           &num_referrals, &referrals,
3506                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3507
3508         if (!rc && num_referrals > 0) {
3509                 char *fake_devname = NULL;
3510
3511                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3512                                                    full_path + 1, referrals,
3513                                                    &fake_devname);
3514
3515                 free_dfs_info_array(referrals, num_referrals);
3516
3517                 if (IS_ERR(mdata)) {
3518                         rc = PTR_ERR(mdata);
3519                         mdata = NULL;
3520                 } else {
3521                         cleanup_volume_info_contents(volume_info);
3522                         memset(volume_info, '\0', sizeof(*volume_info));
3523                         rc = cifs_setup_volume_info(volume_info, mdata,
3524                                                         fake_devname);
3525                 }
3526                 kfree(fake_devname);
3527                 kfree(cifs_sb->mountdata);
3528                 cifs_sb->mountdata = mdata;
3529         }
3530         kfree(full_path);
3531         return rc;
3532 }
3533 #endif
3534
3535 static int
3536 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3537                         const char *devname)
3538 {
3539         int rc = 0;
3540
3541         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3542                 return -EINVAL;
3543
3544
3545         if (volume_info->nullauth) {
3546                 cFYI(1, "Anonymous login");
3547                 kfree(volume_info->username);
3548                 volume_info->username = NULL;
3549         } else if (volume_info->username) {
3550                 /* BB fixme parse for domain name here */
3551                 cFYI(1, "Username: %s", volume_info->username);
3552         } else {
3553                 cifserror("No username specified");
3554         /* In userspace mount helper we can get user name from alternate
3555            locations such as env variables and files on disk */
3556                 return -EINVAL;
3557         }
3558
3559         /* this is needed for ASCII cp to Unicode converts */
3560         if (volume_info->iocharset == NULL) {
3561                 /* load_nls_default cannot return null */
3562                 volume_info->local_nls = load_nls_default();
3563         } else {
3564                 volume_info->local_nls = load_nls(volume_info->iocharset);
3565                 if (volume_info->local_nls == NULL) {
3566                         cERROR(1, "CIFS mount error: iocharset %s not found",
3567                                  volume_info->iocharset);
3568                         return -ELIBACC;
3569                 }
3570         }
3571
3572         return rc;
3573 }
3574
3575 struct smb_vol *
3576 cifs_get_volume_info(char *mount_data, const char *devname)
3577 {
3578         int rc;
3579         struct smb_vol *volume_info;
3580
3581         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3582         if (!volume_info)
3583                 return ERR_PTR(-ENOMEM);
3584
3585         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3586         if (rc) {
3587                 cifs_cleanup_volume_info(volume_info);
3588                 volume_info = ERR_PTR(rc);
3589         }
3590
3591         return volume_info;
3592 }
3593
3594 int
3595 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3596 {
3597         int rc;
3598         int xid;
3599         struct cifs_ses *pSesInfo;
3600         struct cifs_tcon *tcon;
3601         struct TCP_Server_Info *srvTcp;
3602         char   *full_path;
3603         struct tcon_link *tlink;
3604 #ifdef CONFIG_CIFS_DFS_UPCALL
3605         int referral_walks_count = 0;
3606 #endif
3607
3608         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3609         if (rc)
3610                 return rc;
3611
3612 #ifdef CONFIG_CIFS_DFS_UPCALL
3613 try_mount_again:
3614         /* cleanup activities if we're chasing a referral */
3615         if (referral_walks_count) {
3616                 if (tcon)
3617                         cifs_put_tcon(tcon);
3618                 else if (pSesInfo)
3619                         cifs_put_smb_ses(pSesInfo);
3620
3621                 FreeXid(xid);
3622         }
3623 #endif
3624         rc = 0;
3625         tcon = NULL;
3626         pSesInfo = NULL;
3627         srvTcp = NULL;
3628         full_path = NULL;
3629         tlink = NULL;
3630
3631         xid = GetXid();
3632
3633         /* get a reference to a tcp session */
3634         srvTcp = cifs_get_tcp_session(volume_info);
3635         if (IS_ERR(srvTcp)) {
3636                 rc = PTR_ERR(srvTcp);
3637                 bdi_destroy(&cifs_sb->bdi);
3638                 goto out;
3639         }
3640
3641         /* get a reference to a SMB session */
3642         pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3643         if (IS_ERR(pSesInfo)) {
3644                 rc = PTR_ERR(pSesInfo);
3645                 pSesInfo = NULL;
3646                 goto mount_fail_check;
3647         }
3648
3649         /* search for existing tcon to this server share */
3650         tcon = cifs_get_tcon(pSesInfo, volume_info);
3651         if (IS_ERR(tcon)) {
3652                 rc = PTR_ERR(tcon);
3653                 tcon = NULL;
3654                 goto remote_path_check;
3655         }
3656
3657         /* tell server which Unix caps we support */
3658         if (tcon->ses->capabilities & CAP_UNIX) {
3659                 /* reset of caps checks mount to see if unix extensions
3660                    disabled for just this mount */
3661                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3662                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3663                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3664                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3665                         rc = -EACCES;
3666                         goto mount_fail_check;
3667                 }
3668         } else
3669                 tcon->unix_ext = 0; /* server does not support them */
3670
3671         /* do not care if following two calls succeed - informational */
3672         if (!tcon->ipc) {
3673                 CIFSSMBQFSDeviceInfo(xid, tcon);
3674                 CIFSSMBQFSAttributeInfo(xid, tcon);
3675         }
3676
3677         cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3678         cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3679
3680         /* tune readahead according to rsize */
3681         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3682
3683 remote_path_check:
3684 #ifdef CONFIG_CIFS_DFS_UPCALL
3685         /*
3686          * Perform an unconditional check for whether there are DFS
3687          * referrals for this path without prefix, to provide support
3688          * for DFS referrals from w2k8 servers which don't seem to respond
3689          * with PATH_NOT_COVERED to requests that include the prefix.
3690          * Chase the referral if found, otherwise continue normally.
3691          */
3692         if (referral_walks_count == 0) {
3693                 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3694                                                 cifs_sb, false);
3695                 if (!refrc) {
3696                         referral_walks_count++;
3697                         goto try_mount_again;
3698                 }
3699         }
3700 #endif
3701
3702         /* check if a whole path is not remote */
3703         if (!rc && tcon) {
3704                 /* build_path_to_root works only when we have a valid tcon */
3705                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3706                 if (full_path == NULL) {
3707                         rc = -ENOMEM;
3708                         goto mount_fail_check;
3709                 }
3710                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3711                 if (rc != 0 && rc != -EREMOTE) {
3712                         kfree(full_path);
3713                         goto mount_fail_check;
3714                 }
3715                 kfree(full_path);
3716         }
3717
3718         /* get referral if needed */
3719         if (rc == -EREMOTE) {
3720 #ifdef CONFIG_CIFS_DFS_UPCALL
3721                 if (referral_walks_count > MAX_NESTED_LINKS) {
3722                         /*
3723                          * BB: when we implement proper loop detection,
3724                          *     we will remove this check. But now we need it
3725                          *     to prevent an indefinite loop if 'DFS tree' is
3726                          *     misconfigured (i.e. has loops).
3727                          */
3728                         rc = -ELOOP;
3729                         goto mount_fail_check;
3730                 }
3731
3732                 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3733                                          true);
3734
3735                 if (!rc) {
3736                         referral_walks_count++;
3737                         goto try_mount_again;
3738                 }
3739                 goto mount_fail_check;
3740 #else /* No DFS support, return error on mount */
3741                 rc = -EOPNOTSUPP;
3742 #endif
3743         }
3744
3745         if (rc)
3746                 goto mount_fail_check;
3747
3748         /* now, hang the tcon off of the superblock */
3749         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3750         if (tlink == NULL) {
3751                 rc = -ENOMEM;
3752                 goto mount_fail_check;
3753         }
3754
3755         tlink->tl_uid = pSesInfo->linux_uid;
3756         tlink->tl_tcon = tcon;
3757         tlink->tl_time = jiffies;
3758         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3759         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3760
3761         cifs_sb->master_tlink = tlink;
3762         spin_lock(&cifs_sb->tlink_tree_lock);
3763         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3764         spin_unlock(&cifs_sb->tlink_tree_lock);
3765
3766         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3767                                 TLINK_IDLE_EXPIRE);
3768
3769 mount_fail_check:
3770         /* on error free sesinfo and tcon struct if needed */
3771         if (rc) {
3772                 /* If find_unc succeeded then rc == 0 so we can not end */
3773                 /* up accidentally freeing someone elses tcon struct */
3774                 if (tcon)
3775                         cifs_put_tcon(tcon);
3776                 else if (pSesInfo)
3777                         cifs_put_smb_ses(pSesInfo);
3778                 else
3779                         cifs_put_tcp_session(srvTcp);
3780                 bdi_destroy(&cifs_sb->bdi);
3781         }
3782
3783 out:
3784         FreeXid(xid);
3785         return rc;
3786 }
3787
3788 /*
3789  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3790  * pointer may be NULL.
3791  */
3792 int
3793 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3794          const char *tree, struct cifs_tcon *tcon,
3795          const struct nls_table *nls_codepage)
3796 {
3797         struct smb_hdr *smb_buffer;
3798         struct smb_hdr *smb_buffer_response;
3799         TCONX_REQ *pSMB;
3800         TCONX_RSP *pSMBr;
3801         unsigned char *bcc_ptr;
3802         int rc = 0;
3803         int length;
3804         __u16 bytes_left, count;
3805
3806         if (ses == NULL)
3807                 return -EIO;
3808
3809         smb_buffer = cifs_buf_get();
3810         if (smb_buffer == NULL)
3811                 return -ENOMEM;
3812
3813         smb_buffer_response = smb_buffer;
3814
3815         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3816                         NULL /*no tid */ , 4 /*wct */ );
3817
3818         smb_buffer->Mid = get_next_mid(ses->server);
3819         smb_buffer->Uid = ses->Suid;
3820         pSMB = (TCONX_REQ *) smb_buffer;
3821         pSMBr = (TCONX_RSP *) smb_buffer_response;
3822
3823         pSMB->AndXCommand = 0xFF;
3824         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3825         bcc_ptr = &pSMB->Password[0];
3826         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3827                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3828                 *bcc_ptr = 0; /* password is null byte */
3829                 bcc_ptr++;              /* skip password */
3830                 /* already aligned so no need to do it below */
3831         } else {
3832                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3833                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3834                    specified as required (when that support is added to
3835                    the vfs in the future) as only NTLM or the much
3836                    weaker LANMAN (which we do not send by default) is accepted
3837                    by Samba (not sure whether other servers allow
3838                    NTLMv2 password here) */
3839 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3840                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3841                     (ses->server->secType == LANMAN))
3842                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3843                                          ses->server->sec_mode &
3844                                             SECMODE_PW_ENCRYPT ? true : false,
3845                                          bcc_ptr);
3846                 else
3847 #endif /* CIFS_WEAK_PW_HASH */
3848                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3849                                         bcc_ptr, nls_codepage);
3850
3851                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3852                 if (ses->capabilities & CAP_UNICODE) {
3853                         /* must align unicode strings */
3854                         *bcc_ptr = 0; /* null byte password */
3855                         bcc_ptr++;
3856                 }
3857         }
3858
3859         if (ses->server->sec_mode &
3860                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3861                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3862
3863         if (ses->capabilities & CAP_STATUS32) {
3864                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3865         }
3866         if (ses->capabilities & CAP_DFS) {
3867                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3868         }
3869         if (ses->capabilities & CAP_UNICODE) {
3870                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3871                 length =
3872                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3873                         6 /* max utf8 char length in bytes */ *
3874                         (/* server len*/ + 256 /* share len */), nls_codepage);
3875                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3876                 bcc_ptr += 2;   /* skip trailing null */
3877         } else {                /* ASCII */
3878                 strcpy(bcc_ptr, tree);
3879                 bcc_ptr += strlen(tree) + 1;
3880         }
3881         strcpy(bcc_ptr, "?????");
3882         bcc_ptr += strlen("?????");
3883         bcc_ptr += 1;
3884         count = bcc_ptr - &pSMB->Password[0];
3885         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3886                                         pSMB->hdr.smb_buf_length) + count);
3887         pSMB->ByteCount = cpu_to_le16(count);
3888
3889         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3890                          0);
3891
3892         /* above now done in SendReceive */
3893         if ((rc == 0) && (tcon != NULL)) {
3894                 bool is_unicode;
3895
3896                 tcon->tidStatus = CifsGood;
3897                 tcon->need_reconnect = false;
3898                 tcon->tid = smb_buffer_response->Tid;
3899                 bcc_ptr = pByteArea(smb_buffer_response);
3900                 bytes_left = get_bcc(smb_buffer_response);
3901                 length = strnlen(bcc_ptr, bytes_left - 2);
3902                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3903                         is_unicode = true;
3904                 else
3905                         is_unicode = false;
3906
3907
3908                 /* skip service field (NB: this field is always ASCII) */
3909                 if (length == 3) {
3910                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3911                             (bcc_ptr[2] == 'C')) {
3912                                 cFYI(1, "IPC connection");
3913                                 tcon->ipc = 1;
3914                         }
3915                 } else if (length == 2) {
3916                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3917                                 /* the most common case */
3918                                 cFYI(1, "disk share connection");
3919                         }
3920                 }
3921                 bcc_ptr += length + 1;
3922                 bytes_left -= (length + 1);
3923                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3924
3925                 /* mostly informational -- no need to fail on error here */
3926                 kfree(tcon->nativeFileSystem);
3927                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3928                                                       bytes_left, is_unicode,
3929                                                       nls_codepage);
3930
3931                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3932
3933                 if ((smb_buffer_response->WordCount == 3) ||
3934                          (smb_buffer_response->WordCount == 7))
3935                         /* field is in same location */
3936                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3937                 else
3938                         tcon->Flags = 0;
3939                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3940         } else if ((rc == 0) && tcon == NULL) {
3941                 /* all we need to save for IPC$ connection */
3942                 ses->ipc_tid = smb_buffer_response->Tid;
3943         }
3944
3945         cifs_buf_release(smb_buffer);
3946         return rc;
3947 }
3948
3949 void
3950 cifs_umount(struct cifs_sb_info *cifs_sb)
3951 {
3952         struct rb_root *root = &cifs_sb->tlink_tree;
3953         struct rb_node *node;
3954         struct tcon_link *tlink;
3955
3956         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3957
3958         spin_lock(&cifs_sb->tlink_tree_lock);
3959         while ((node = rb_first(root))) {
3960                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3961                 cifs_get_tlink(tlink);
3962                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3963                 rb_erase(node, root);
3964
3965                 spin_unlock(&cifs_sb->tlink_tree_lock);
3966                 cifs_put_tlink(tlink);
3967                 spin_lock(&cifs_sb->tlink_tree_lock);
3968         }
3969         spin_unlock(&cifs_sb->tlink_tree_lock);
3970
3971         bdi_destroy(&cifs_sb->bdi);
3972         kfree(cifs_sb->mountdata);
3973         unload_nls(cifs_sb->local_nls);
3974         kfree(cifs_sb);
3975 }
3976
3977 int
3978 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3979 {
3980         int rc = 0;
3981         struct TCP_Server_Info *server = ses->server;
3982
3983         if (!server->ops->need_neg || !server->ops->negotiate)
3984                 return -ENOSYS;
3985
3986         /* only send once per connect */
3987         if (!server->ops->need_neg(server))
3988                 return 0;
3989
3990         set_credits(server, 1);
3991
3992         rc = server->ops->negotiate(xid, ses);
3993         if (rc == 0) {
3994                 spin_lock(&GlobalMid_Lock);
3995                 if (server->tcpStatus == CifsNeedNegotiate)
3996                         server->tcpStatus = CifsGood;
3997                 else
3998                         rc = -EHOSTDOWN;
3999                 spin_unlock(&GlobalMid_Lock);
4000         }
4001
4002         return rc;
4003 }
4004
4005 int
4006 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4007                    struct nls_table *nls_info)
4008 {
4009         int rc = -ENOSYS;
4010         struct TCP_Server_Info *server = ses->server;
4011
4012         ses->flags = 0;
4013         ses->capabilities = server->capabilities;
4014         if (linuxExtEnabled == 0)
4015                 ses->capabilities &= (~CAP_UNIX);
4016
4017         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4018                  server->sec_mode, server->capabilities, server->timeAdj);
4019
4020         if (server->ops->sess_setup)
4021                 rc = server->ops->sess_setup(xid, ses, nls_info);
4022
4023         if (rc) {
4024                 cERROR(1, "Send error in SessSetup = %d", rc);
4025         } else {
4026                 mutex_lock(&ses->server->srv_mutex);
4027                 if (!server->session_estab) {
4028                         server->session_key.response = ses->auth_key.response;
4029                         server->session_key.len = ses->auth_key.len;
4030                         server->sequence_number = 0x2;
4031                         server->session_estab = true;
4032                         ses->auth_key.response = NULL;
4033                 }
4034                 mutex_unlock(&server->srv_mutex);
4035
4036                 cFYI(1, "CIFS Session Established successfully");
4037                 spin_lock(&GlobalMid_Lock);
4038                 ses->status = CifsGood;
4039                 ses->need_reconnect = false;
4040                 spin_unlock(&GlobalMid_Lock);
4041         }
4042
4043         kfree(ses->auth_key.response);
4044         ses->auth_key.response = NULL;
4045         ses->auth_key.len = 0;
4046         kfree(ses->ntlmssp);
4047         ses->ntlmssp = NULL;
4048
4049         return rc;
4050 }
4051
4052 static int
4053 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4054 {
4055         switch (ses->server->secType) {
4056         case Kerberos:
4057                 vol->secFlg = CIFSSEC_MUST_KRB5;
4058                 return 0;
4059         case NTLMv2:
4060                 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4061                 break;
4062         case NTLM:
4063                 vol->secFlg = CIFSSEC_MUST_NTLM;
4064                 break;
4065         case RawNTLMSSP:
4066                 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4067                 break;
4068         case LANMAN:
4069                 vol->secFlg = CIFSSEC_MUST_LANMAN;
4070                 break;
4071         }
4072
4073         return cifs_set_cifscreds(vol, ses);
4074 }
4075
4076 static struct cifs_tcon *
4077 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4078 {
4079         int rc;
4080         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4081         struct cifs_ses *ses;
4082         struct cifs_tcon *tcon = NULL;
4083         struct smb_vol *vol_info;
4084
4085         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4086         if (vol_info == NULL)
4087                 return ERR_PTR(-ENOMEM);
4088
4089         vol_info->local_nls = cifs_sb->local_nls;
4090         vol_info->linux_uid = fsuid;
4091         vol_info->cred_uid = fsuid;
4092         vol_info->UNC = master_tcon->treeName;
4093         vol_info->retry = master_tcon->retry;
4094         vol_info->nocase = master_tcon->nocase;
4095         vol_info->local_lease = master_tcon->local_lease;
4096         vol_info->no_linux_ext = !master_tcon->unix_ext;
4097
4098         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4099         if (rc) {
4100                 tcon = ERR_PTR(rc);
4101                 goto out;
4102         }
4103
4104         /* get a reference for the same TCP session */
4105         spin_lock(&cifs_tcp_ses_lock);
4106         ++master_tcon->ses->server->srv_count;
4107         spin_unlock(&cifs_tcp_ses_lock);
4108
4109         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4110         if (IS_ERR(ses)) {
4111                 tcon = (struct cifs_tcon *)ses;
4112                 cifs_put_tcp_session(master_tcon->ses->server);
4113                 goto out;
4114         }
4115
4116         tcon = cifs_get_tcon(ses, vol_info);
4117         if (IS_ERR(tcon)) {
4118                 cifs_put_smb_ses(ses);
4119                 goto out;
4120         }
4121
4122         if (ses->capabilities & CAP_UNIX)
4123                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4124 out:
4125         kfree(vol_info->username);
4126         kfree(vol_info->password);
4127         kfree(vol_info);
4128
4129         return tcon;
4130 }
4131
4132 struct cifs_tcon *
4133 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4134 {
4135         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4136 }
4137
4138 static int
4139 cifs_sb_tcon_pending_wait(void *unused)
4140 {
4141         schedule();
4142         return signal_pending(current) ? -ERESTARTSYS : 0;
4143 }
4144
4145 /* find and return a tlink with given uid */
4146 static struct tcon_link *
4147 tlink_rb_search(struct rb_root *root, uid_t uid)
4148 {
4149         struct rb_node *node = root->rb_node;
4150         struct tcon_link *tlink;
4151
4152         while (node) {
4153                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4154
4155                 if (tlink->tl_uid > uid)
4156                         node = node->rb_left;
4157                 else if (tlink->tl_uid < uid)
4158                         node = node->rb_right;
4159                 else
4160                         return tlink;
4161         }
4162         return NULL;
4163 }
4164
4165 /* insert a tcon_link into the tree */
4166 static void
4167 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4168 {
4169         struct rb_node **new = &(root->rb_node), *parent = NULL;
4170         struct tcon_link *tlink;
4171
4172         while (*new) {
4173                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4174                 parent = *new;
4175
4176                 if (tlink->tl_uid > new_tlink->tl_uid)
4177                         new = &((*new)->rb_left);
4178                 else
4179                         new = &((*new)->rb_right);
4180         }
4181
4182         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4183         rb_insert_color(&new_tlink->tl_rbnode, root);
4184 }
4185
4186 /*
4187  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4188  * current task.
4189  *
4190  * If the superblock doesn't refer to a multiuser mount, then just return
4191  * the master tcon for the mount.
4192  *
4193  * First, search the rbtree for an existing tcon for this fsuid. If one
4194  * exists, then check to see if it's pending construction. If it is then wait
4195  * for construction to complete. Once it's no longer pending, check to see if
4196  * it failed and either return an error or retry construction, depending on
4197  * the timeout.
4198  *
4199  * If one doesn't exist then insert a new tcon_link struct into the tree and
4200  * try to construct a new one.
4201  */
4202 struct tcon_link *
4203 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4204 {
4205         int ret;
4206         uid_t fsuid = current_fsuid();
4207         struct tcon_link *tlink, *newtlink;
4208
4209         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4210                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4211
4212         spin_lock(&cifs_sb->tlink_tree_lock);
4213         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4214         if (tlink)
4215                 cifs_get_tlink(tlink);
4216         spin_unlock(&cifs_sb->tlink_tree_lock);
4217
4218         if (tlink == NULL) {
4219                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4220                 if (newtlink == NULL)
4221                         return ERR_PTR(-ENOMEM);
4222                 newtlink->tl_uid = fsuid;
4223                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4224                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4225                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4226                 cifs_get_tlink(newtlink);
4227
4228                 spin_lock(&cifs_sb->tlink_tree_lock);
4229                 /* was one inserted after previous search? */
4230                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4231                 if (tlink) {
4232                         cifs_get_tlink(tlink);
4233                         spin_unlock(&cifs_sb->tlink_tree_lock);
4234                         kfree(newtlink);
4235                         goto wait_for_construction;
4236                 }
4237                 tlink = newtlink;
4238                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4239                 spin_unlock(&cifs_sb->tlink_tree_lock);
4240         } else {
4241 wait_for_construction:
4242                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4243                                   cifs_sb_tcon_pending_wait,
4244                                   TASK_INTERRUPTIBLE);
4245                 if (ret) {
4246                         cifs_put_tlink(tlink);
4247                         return ERR_PTR(ret);
4248                 }
4249
4250                 /* if it's good, return it */
4251                 if (!IS_ERR(tlink->tl_tcon))
4252                         return tlink;
4253
4254                 /* return error if we tried this already recently */
4255                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4256                         cifs_put_tlink(tlink);
4257                         return ERR_PTR(-EACCES);
4258                 }
4259
4260                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4261                         goto wait_for_construction;
4262         }
4263
4264         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4265         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4266         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4267
4268         if (IS_ERR(tlink->tl_tcon)) {
4269                 cifs_put_tlink(tlink);
4270                 return ERR_PTR(-EACCES);
4271         }
4272
4273         return tlink;
4274 }
4275
4276 /*
4277  * periodic workqueue job that scans tcon_tree for a superblock and closes
4278  * out tcons.
4279  */
4280 static void
4281 cifs_prune_tlinks(struct work_struct *work)
4282 {
4283         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4284                                                     prune_tlinks.work);
4285         struct rb_root *root = &cifs_sb->tlink_tree;
4286         struct rb_node *node = rb_first(root);
4287         struct rb_node *tmp;
4288         struct tcon_link *tlink;
4289
4290         /*
4291          * Because we drop the spinlock in the loop in order to put the tlink
4292          * it's not guarded against removal of links from the tree. The only
4293          * places that remove entries from the tree are this function and
4294          * umounts. Because this function is non-reentrant and is canceled
4295          * before umount can proceed, this is safe.
4296          */
4297         spin_lock(&cifs_sb->tlink_tree_lock);
4298         node = rb_first(root);
4299         while (node != NULL) {
4300                 tmp = node;
4301                 node = rb_next(tmp);
4302                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4303
4304                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4305                     atomic_read(&tlink->tl_count) != 0 ||
4306                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4307                         continue;
4308
4309                 cifs_get_tlink(tlink);
4310                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4311                 rb_erase(tmp, root);
4312
4313                 spin_unlock(&cifs_sb->tlink_tree_lock);
4314                 cifs_put_tlink(tlink);
4315                 spin_lock(&cifs_sb->tlink_tree_lock);
4316         }
4317         spin_unlock(&cifs_sb->tlink_tree_lock);
4318
4319         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4320                                 TLINK_IDLE_EXPIRE);
4321 }