fs/cifs/connect.c

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