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