fs/cifs/connect.c

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