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