fs/cifs/connect.c

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