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