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