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