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