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

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