fs/cifs/connect.c

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