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