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