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