fs/cifs/connect.c

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