Pileus Git - ~andy/linux/blob - fs/cifs/connect.c

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