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