fs/cifs/connect.c

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