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         mutex_unlock(&server->srv_mutex);
 372
 373         /* mark submitted MIDs for retry and issue callback */
 374         INIT_LIST_HEAD(&retry_list);
 375         cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
 376         spin_lock(&GlobalMid_Lock);
 377         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 378                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 379                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 380                         mid_entry->mid_state = MID_RETRY_NEEDED;
 381                 list_move(&mid_entry->qhead, &retry_list);
 382         }
 383         spin_unlock(&GlobalMid_Lock);
 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         char *desc, *delim, *payload;
2362         ssize_t len;
2363         struct key *key;
2364         struct TCP_Server_Info *server = ses->server;
2365         struct sockaddr_in *sa;
2366         struct sockaddr_in6 *sa6;
2367         struct user_key_payload *upayload;
2368
2369         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2370         if (!desc)
2371                 return -ENOMEM;
2372
2373         /* try to find an address key first */
2374         switch (server->dstaddr.ss_family) {
2375         case AF_INET:
2376                 sa = (struct sockaddr_in *)&server->dstaddr;
2377                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2378                 break;
2379         case AF_INET6:
2380                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2381                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2382                 break;
2383         default:
2384                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2385                          server->dstaddr.ss_family);
2386                 rc = -EINVAL;
2387                 goto out_err;
2388         }
2389
2390         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2391         key = request_key(&key_type_logon, desc, "");
2392         if (IS_ERR(key)) {
2393                 if (!ses->domainName) {
2394                         cifs_dbg(FYI, "domainName is NULL\n");
2395                         rc = PTR_ERR(key);
2396                         goto out_err;
2397                 }
2398
2399                 /* didn't work, try to find a domain key */
2400                 sprintf(desc, "cifs:d:%s", ses->domainName);
2401                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2402                 key = request_key(&key_type_logon, desc, "");
2403                 if (IS_ERR(key)) {
2404                         rc = PTR_ERR(key);
2405                         goto out_err;
2406                 }
2407         }
2408
2409         down_read(&key->sem);
2410         upayload = key->payload.data;
2411         if (IS_ERR_OR_NULL(upayload)) {
2412                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2413                 goto out_key_put;
2414         }
2415
2416         /* find first : in payload */
2417         payload = (char *)upayload->data;
2418         delim = strnchr(payload, upayload->datalen, ':');
2419         cifs_dbg(FYI, "payload=%s\n", payload);
2420         if (!delim) {
2421                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2422                          upayload->datalen);
2423                 rc = -EINVAL;
2424                 goto out_key_put;
2425         }
2426
2427         len = delim - payload;
2428         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2429                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2430                          len);
2431                 rc = -EINVAL;
2432                 goto out_key_put;
2433         }
2434
2435         vol->username = kstrndup(payload, len, GFP_KERNEL);
2436         if (!vol->username) {
2437                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2438                          len);
2439                 rc = -ENOMEM;
2440                 goto out_key_put;
2441         }
2442         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2443
2444         len = key->datalen - (len + 1);
2445         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2446                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2447                 rc = -EINVAL;
2448                 kfree(vol->username);
2449                 vol->username = NULL;
2450                 goto out_key_put;
2451         }
2452
2453         ++delim;
2454         vol->password = kstrndup(delim, len, GFP_KERNEL);
2455         if (!vol->password) {
2456                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2457                          len);
2458                 rc = -ENOMEM;
2459                 kfree(vol->username);
2460                 vol->username = NULL;
2461                 goto out_key_put;
2462         }
2463
2464 out_key_put:
2465         up_read(&key->sem);
2466         key_put(key);
2467 out_err:
2468         kfree(desc);
2469         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2470         return rc;
2471 }
2472 #else /* ! CONFIG_KEYS */
2473 static inline int
2474 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2475                    struct cifs_ses *ses __attribute__((unused)))
2476 {
2477         return -ENOSYS;
2478 }
2479 #endif /* CONFIG_KEYS */
2480
2481 static struct cifs_ses *
2482 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2483 {
2484         int rc = -ENOMEM;
2485         unsigned int xid;
2486         struct cifs_ses *ses;
2487         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2488         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2489
2490         xid = get_xid();
2491
2492         ses = cifs_find_smb_ses(server, volume_info);
2493         if (ses) {
2494                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2495                          ses->status);
2496
2497                 mutex_lock(&ses->session_mutex);
2498                 rc = cifs_negotiate_protocol(xid, ses);
2499                 if (rc) {
2500                         mutex_unlock(&ses->session_mutex);
2501                         /* problem -- put our ses reference */
2502                         cifs_put_smb_ses(ses);
2503                         free_xid(xid);
2504                         return ERR_PTR(rc);
2505                 }
2506                 if (ses->need_reconnect) {
2507                         cifs_dbg(FYI, "Session needs reconnect\n");
2508                         rc = cifs_setup_session(xid, ses,
2509                                                 volume_info->local_nls);
2510                         if (rc) {
2511                                 mutex_unlock(&ses->session_mutex);
2512                                 /* problem -- put our reference */
2513                                 cifs_put_smb_ses(ses);
2514                                 free_xid(xid);
2515                                 return ERR_PTR(rc);
2516                         }
2517                 }
2518                 mutex_unlock(&ses->session_mutex);
2519
2520                 /* existing SMB ses has a server reference already */
2521                 cifs_put_tcp_session(server);
2522                 free_xid(xid);
2523                 return ses;
2524         }
2525
2526         cifs_dbg(FYI, "Existing smb sess not found\n");
2527         ses = sesInfoAlloc();
2528         if (ses == NULL)
2529                 goto get_ses_fail;
2530
2531         /* new SMB session uses our server ref */
2532         ses->server = server;
2533         if (server->dstaddr.ss_family == AF_INET6)
2534                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2535         else
2536                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2537
2538         if (volume_info->username) {
2539                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2540                 if (!ses->user_name)
2541                         goto get_ses_fail;
2542         }
2543
2544         /* volume_info->password freed at unmount */
2545         if (volume_info->password) {
2546                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2547                 if (!ses->password)
2548                         goto get_ses_fail;
2549         }
2550         if (volume_info->domainname) {
2551                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2552                 if (!ses->domainName)
2553                         goto get_ses_fail;
2554         }
2555         ses->cred_uid = volume_info->cred_uid;
2556         ses->linux_uid = volume_info->linux_uid;
2557
2558         ses->sectype = volume_info->sectype;
2559         ses->sign = volume_info->sign;
2560
2561         mutex_lock(&ses->session_mutex);
2562         rc = cifs_negotiate_protocol(xid, ses);
2563         if (!rc)
2564                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2565         mutex_unlock(&ses->session_mutex);
2566         if (rc)
2567                 goto get_ses_fail;
2568
2569         /* success, put it on the list */
2570         spin_lock(&cifs_tcp_ses_lock);
2571         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2572         spin_unlock(&cifs_tcp_ses_lock);
2573
2574         free_xid(xid);
2575         return ses;
2576
2577 get_ses_fail:
2578         sesInfoFree(ses);
2579         free_xid(xid);
2580         return ERR_PTR(rc);
2581 }
2582
2583 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2584 {
2585         if (tcon->tidStatus == CifsExiting)
2586                 return 0;
2587         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2588                 return 0;
2589         return 1;
2590 }
2591
2592 static struct cifs_tcon *
2593 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2594 {
2595         struct list_head *tmp;
2596         struct cifs_tcon *tcon;
2597
2598         spin_lock(&cifs_tcp_ses_lock);
2599         list_for_each(tmp, &ses->tcon_list) {
2600                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2601                 if (!match_tcon(tcon, unc))
2602                         continue;
2603                 ++tcon->tc_count;
2604                 spin_unlock(&cifs_tcp_ses_lock);
2605                 return tcon;
2606         }
2607         spin_unlock(&cifs_tcp_ses_lock);
2608         return NULL;
2609 }
2610
2611 static void
2612 cifs_put_tcon(struct cifs_tcon *tcon)
2613 {
2614         unsigned int xid;
2615         struct cifs_ses *ses = tcon->ses;
2616
2617         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2618         spin_lock(&cifs_tcp_ses_lock);
2619         if (--tcon->tc_count > 0) {
2620                 spin_unlock(&cifs_tcp_ses_lock);
2621                 return;
2622         }
2623
2624         list_del_init(&tcon->tcon_list);
2625         spin_unlock(&cifs_tcp_ses_lock);
2626
2627         xid = get_xid();
2628         if (ses->server->ops->tree_disconnect)
2629                 ses->server->ops->tree_disconnect(xid, tcon);
2630         _free_xid(xid);
2631
2632         cifs_fscache_release_super_cookie(tcon);
2633         tconInfoFree(tcon);
2634         cifs_put_smb_ses(ses);
2635 }
2636
2637 static struct cifs_tcon *
2638 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2639 {
2640         int rc, xid;
2641         struct cifs_tcon *tcon;
2642
2643         tcon = cifs_find_tcon(ses, volume_info->UNC);
2644         if (tcon) {
2645                 cifs_dbg(FYI, "Found match on UNC path\n");
2646                 /* existing tcon already has a reference */
2647                 cifs_put_smb_ses(ses);
2648                 if (tcon->seal != volume_info->seal)
2649                         cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2650                 return tcon;
2651         }
2652
2653         if (!ses->server->ops->tree_connect) {
2654                 rc = -ENOSYS;
2655                 goto out_fail;
2656         }
2657
2658         tcon = tconInfoAlloc();
2659         if (tcon == NULL) {
2660                 rc = -ENOMEM;
2661                 goto out_fail;
2662         }
2663
2664         tcon->ses = ses;
2665         if (volume_info->password) {
2666                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2667                 if (!tcon->password) {
2668                         rc = -ENOMEM;
2669                         goto out_fail;
2670                 }
2671         }
2672
2673         /*
2674          * BB Do we need to wrap session_mutex around this TCon call and Unix
2675          * SetFS as we do on SessSetup and reconnect?
2676          */
2677         xid = get_xid();
2678         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2679                                             volume_info->local_nls);
2680         free_xid(xid);
2681         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2682         if (rc)
2683                 goto out_fail;
2684
2685         if (volume_info->nodfs) {
2686                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2687                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2688         }
2689         tcon->seal = volume_info->seal;
2690         tcon->use_persistent = false;
2691         /* check if SMB2 or later, CIFS does not support persistent handles */
2692         if (volume_info->persistent) {
2693                 if (ses->server->vals->protocol_id == 0) {
2694                         cifs_dbg(VFS,
2695                              "SMB3 or later required for persistent handles\n");
2696                         rc = -EOPNOTSUPP;
2697                         goto out_fail;
2698 #ifdef CONFIG_CIFS_SMB2
2699                 } else if (ses->server->capabilities &
2700                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2701                         tcon->use_persistent = true;
2702                 else /* persistent handles requested but not supported */ {
2703                         cifs_dbg(VFS,
2704                                 "Persistent handles not supported on share\n");
2705                         rc = -EOPNOTSUPP;
2706                         goto out_fail;
2707 #endif /* CONFIG_CIFS_SMB2 */
2708                 }
2709 #ifdef CONFIG_CIFS_SMB2
2710         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2711              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2712              && (volume_info->nopersistent == false)) {
2713                 cifs_dbg(FYI, "enabling persistent handles\n");
2714                 tcon->use_persistent = true;
2715 #endif /* CONFIG_CIFS_SMB2 */
2716         } else if (volume_info->resilient) {
2717                 if (ses->server->vals->protocol_id == 0) {
2718                         cifs_dbg(VFS,
2719                              "SMB2.1 or later required for resilient handles\n");
2720                         rc = -EOPNOTSUPP;
2721                         goto out_fail;
2722                 }
2723                 tcon->use_resilient = true;
2724         }
2725
2726         /*
2727          * We can have only one retry value for a connection to a share so for
2728          * resources mounted more than once to the same server share the last
2729          * value passed in for the retry flag is used.
2730          */
2731         tcon->retry = volume_info->retry;
2732         tcon->nocase = volume_info->nocase;
2733         tcon->local_lease = volume_info->local_lease;
2734         INIT_LIST_HEAD(&tcon->pending_opens);
2735
2736         spin_lock(&cifs_tcp_ses_lock);
2737         list_add(&tcon->tcon_list, &ses->tcon_list);
2738         spin_unlock(&cifs_tcp_ses_lock);
2739
2740         cifs_fscache_get_super_cookie(tcon);
2741
2742         return tcon;
2743
2744 out_fail:
2745         tconInfoFree(tcon);
2746         return ERR_PTR(rc);
2747 }
2748
2749 void
2750 cifs_put_tlink(struct tcon_link *tlink)
2751 {
2752         if (!tlink || IS_ERR(tlink))
2753                 return;
2754
2755         if (!atomic_dec_and_test(&tlink->tl_count) ||
2756             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2757                 tlink->tl_time = jiffies;
2758                 return;
2759         }
2760
2761         if (!IS_ERR(tlink_tcon(tlink)))
2762                 cifs_put_tcon(tlink_tcon(tlink));
2763         kfree(tlink);
2764         return;
2765 }
2766
2767 static inline struct tcon_link *
2768 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2769 {
2770         return cifs_sb->master_tlink;
2771 }
2772
2773 static int
2774 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2775 {
2776         struct cifs_sb_info *old = CIFS_SB(sb);
2777         struct cifs_sb_info *new = mnt_data->cifs_sb;
2778
2779         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2780                 return 0;
2781
2782         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2783             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2784                 return 0;
2785
2786         /*
2787          * We want to share sb only if we don't specify an r/wsize or
2788          * specified r/wsize is greater than or equal to existing one.
2789          */
2790         if (new->wsize && new->wsize < old->wsize)
2791                 return 0;
2792
2793         if (new->rsize && new->rsize < old->rsize)
2794                 return 0;
2795
2796         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2797                 return 0;
2798
2799         if (old->mnt_file_mode != new->mnt_file_mode ||
2800             old->mnt_dir_mode != new->mnt_dir_mode)
2801                 return 0;
2802
2803         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2804                 return 0;
2805
2806         if (old->actimeo != new->actimeo)
2807                 return 0;
2808
2809         return 1;
2810 }
2811
2812 int
2813 cifs_match_super(struct super_block *sb, void *data)
2814 {
2815         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2816         struct smb_vol *volume_info;
2817         struct cifs_sb_info *cifs_sb;
2818         struct TCP_Server_Info *tcp_srv;
2819         struct cifs_ses *ses;
2820         struct cifs_tcon *tcon;
2821         struct tcon_link *tlink;
2822         int rc = 0;
2823
2824         spin_lock(&cifs_tcp_ses_lock);
2825         cifs_sb = CIFS_SB(sb);
2826         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2827         if (IS_ERR(tlink)) {
2828                 spin_unlock(&cifs_tcp_ses_lock);
2829                 return rc;
2830         }
2831         tcon = tlink_tcon(tlink);
2832         ses = tcon->ses;
2833         tcp_srv = ses->server;
2834
2835         volume_info = mnt_data->vol;
2836
2837         if (!match_server(tcp_srv, volume_info) ||
2838             !match_session(ses, volume_info) ||
2839             !match_tcon(tcon, volume_info->UNC)) {
2840                 rc = 0;
2841                 goto out;
2842         }
2843
2844         rc = compare_mount_options(sb, mnt_data);
2845 out:
2846         spin_unlock(&cifs_tcp_ses_lock);
2847         cifs_put_tlink(tlink);
2848         return rc;
2849 }
2850
2851 int
2852 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2853              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2854              struct dfs_info3_param **referrals, int remap)
2855 {
2856         char *temp_unc;
2857         int rc = 0;
2858
2859         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2860                 return -ENOSYS;
2861
2862         *num_referrals = 0;
2863         *referrals = NULL;
2864
2865         if (ses->ipc_tid == 0) {
2866                 temp_unc = kmalloc(2 /* for slashes */ +
2867                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2868                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2869                 if (temp_unc == NULL)
2870                         return -ENOMEM;
2871                 temp_unc[0] = '\\';
2872                 temp_unc[1] = '\\';
2873                 strcpy(temp_unc + 2, ses->serverName);
2874                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2875                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2876                                                     nls_codepage);
2877                 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2878                 kfree(temp_unc);
2879         }
2880         if (rc == 0)
2881                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2882                                                      referrals, num_referrals,
2883                                                      nls_codepage, remap);
2884         /*
2885          * BB - map targetUNCs to dfs_info3 structures, here or in
2886          * ses->server->ops->get_dfs_refer.
2887          */
2888
2889         return rc;
2890 }
2891
2892 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2893 static struct lock_class_key cifs_key[2];
2894 static struct lock_class_key cifs_slock_key[2];
2895
2896 static inline void
2897 cifs_reclassify_socket4(struct socket *sock)
2898 {
2899         struct sock *sk = sock->sk;
2900         BUG_ON(sock_owned_by_user(sk));
2901         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2902                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2903 }
2904
2905 static inline void
2906 cifs_reclassify_socket6(struct socket *sock)
2907 {
2908         struct sock *sk = sock->sk;
2909         BUG_ON(sock_owned_by_user(sk));
2910         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2911                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2912 }
2913 #else
2914 static inline void
2915 cifs_reclassify_socket4(struct socket *sock)
2916 {
2917 }
2918
2919 static inline void
2920 cifs_reclassify_socket6(struct socket *sock)
2921 {
2922 }
2923 #endif
2924
2925 /* See RFC1001 section 14 on representation of Netbios names */
2926 static void rfc1002mangle(char *target, char *source, unsigned int length)
2927 {
2928         unsigned int i, j;
2929
2930         for (i = 0, j = 0; i < (length); i++) {
2931                 /* mask a nibble at a time and encode */
2932                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2933                 target[j+1] = 'A' + (0x0F & source[i]);
2934                 j += 2;
2935         }
2936
2937 }
2938
2939 static int
2940 bind_socket(struct TCP_Server_Info *server)
2941 {
2942         int rc = 0;
2943         if (server->srcaddr.ss_family != AF_UNSPEC) {
2944                 /* Bind to the specified local IP address */
2945                 struct socket *socket = server->ssocket;
2946                 rc = socket->ops->bind(socket,
2947                                        (struct sockaddr *) &server->srcaddr,
2948                                        sizeof(server->srcaddr));
2949                 if (rc < 0) {
2950                         struct sockaddr_in *saddr4;
2951                         struct sockaddr_in6 *saddr6;
2952                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2953                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2954                         if (saddr6->sin6_family == AF_INET6)
2955                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2956                                          &saddr6->sin6_addr, rc);
2957                         else
2958                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2959                                          &saddr4->sin_addr.s_addr, rc);
2960                 }
2961         }
2962         return rc;
2963 }
2964
2965 static int
2966 ip_rfc1001_connect(struct TCP_Server_Info *server)
2967 {
2968         int rc = 0;
2969         /*
2970          * some servers require RFC1001 sessinit before sending
2971          * negprot - BB check reconnection in case where second
2972          * sessinit is sent but no second negprot
2973          */
2974         struct rfc1002_session_packet *ses_init_buf;
2975         struct smb_hdr *smb_buf;
2976         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2977                                GFP_KERNEL);
2978         if (ses_init_buf) {
2979                 ses_init_buf->trailer.session_req.called_len = 32;
2980
2981                 if (server->server_RFC1001_name &&
2982                     server->server_RFC1001_name[0] != 0)
2983                         rfc1002mangle(ses_init_buf->trailer.
2984                                       session_req.called_name,
2985                                       server->server_RFC1001_name,
2986                                       RFC1001_NAME_LEN_WITH_NULL);
2987                 else
2988                         rfc1002mangle(ses_init_buf->trailer.
2989                                       session_req.called_name,
2990                                       DEFAULT_CIFS_CALLED_NAME,
2991                                       RFC1001_NAME_LEN_WITH_NULL);
2992
2993                 ses_init_buf->trailer.session_req.calling_len = 32;
2994
2995                 /*
2996                  * calling name ends in null (byte 16) from old smb
2997                  * convention.
2998                  */
2999                 if (server->workstation_RFC1001_name[0] != 0)
3000                         rfc1002mangle(ses_init_buf->trailer.
3001                                       session_req.calling_name,
3002                                       server->workstation_RFC1001_name,
3003                                       RFC1001_NAME_LEN_WITH_NULL);
3004                 else
3005                         rfc1002mangle(ses_init_buf->trailer.
3006                                       session_req.calling_name,
3007                                       "LINUX_CIFS_CLNT",
3008                                       RFC1001_NAME_LEN_WITH_NULL);
3009
3010                 ses_init_buf->trailer.session_req.scope1 = 0;
3011                 ses_init_buf->trailer.session_req.scope2 = 0;
3012                 smb_buf = (struct smb_hdr *)ses_init_buf;
3013
3014                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3015                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3016                 rc = smb_send(server, smb_buf, 0x44);
3017                 kfree(ses_init_buf);
3018                 /*
3019                  * RFC1001 layer in at least one server
3020                  * requires very short break before negprot
3021                  * presumably because not expecting negprot
3022                  * to follow so fast.  This is a simple
3023                  * solution that works without
3024                  * complicating the code and causes no
3025                  * significant slowing down on mount
3026                  * for everyone else
3027                  */
3028                 usleep_range(1000, 2000);
3029         }
3030         /*
3031          * else the negprot may still work without this
3032          * even though malloc failed
3033          */
3034
3035         return rc;
3036 }
3037
3038 static int
3039 generic_ip_connect(struct TCP_Server_Info *server)
3040 {
3041         int rc = 0;
3042         __be16 sport;
3043         int slen, sfamily;
3044         struct socket *socket = server->ssocket;
3045         struct sockaddr *saddr;
3046
3047         saddr = (struct sockaddr *) &server->dstaddr;
3048
3049         if (server->dstaddr.ss_family == AF_INET6) {
3050                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3051                 slen = sizeof(struct sockaddr_in6);
3052                 sfamily = AF_INET6;
3053         } else {
3054                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3055                 slen = sizeof(struct sockaddr_in);
3056                 sfamily = AF_INET;
3057         }
3058
3059         if (socket == NULL) {
3060                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3061                                    IPPROTO_TCP, &socket, 1);
3062                 if (rc < 0) {
3063                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
3064                         server->ssocket = NULL;
3065                         return rc;
3066                 }
3067
3068                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3069                 cifs_dbg(FYI, "Socket created\n");
3070                 server->ssocket = socket;
3071                 socket->sk->sk_allocation = GFP_NOFS;
3072                 if (sfamily == AF_INET6)
3073                         cifs_reclassify_socket6(socket);
3074                 else
3075                         cifs_reclassify_socket4(socket);
3076         }
3077
3078         rc = bind_socket(server);
3079         if (rc < 0)
3080                 return rc;
3081
3082         /*
3083          * Eventually check for other socket options to change from
3084          * the default. sock_setsockopt not used because it expects
3085          * user space buffer
3086          */
3087         socket->sk->sk_rcvtimeo = 7 * HZ;
3088         socket->sk->sk_sndtimeo = 5 * HZ;
3089
3090         /* make the bufsizes depend on wsize/rsize and max requests */
3091         if (server->noautotune) {
3092                 if (socket->sk->sk_sndbuf < (200 * 1024))
3093                         socket->sk->sk_sndbuf = 200 * 1024;
3094                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3095                         socket->sk->sk_rcvbuf = 140 * 1024;
3096         }
3097
3098         if (server->tcp_nodelay) {
3099                 int val = 1;
3100                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3101                                 (char *)&val, sizeof(val));
3102                 if (rc)
3103                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3104                                  rc);
3105         }
3106
3107         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3108                  socket->sk->sk_sndbuf,
3109                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3110
3111         rc = socket->ops->connect(socket, saddr, slen, 0);
3112         if (rc < 0) {
3113                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3114                 sock_release(socket);
3115                 server->ssocket = NULL;
3116                 return rc;
3117         }
3118
3119         if (sport == htons(RFC1001_PORT))
3120                 rc = ip_rfc1001_connect(server);
3121
3122         return rc;
3123 }
3124
3125 static int
3126 ip_connect(struct TCP_Server_Info *server)
3127 {
3128         __be16 *sport;
3129         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3130         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3131
3132         if (server->dstaddr.ss_family == AF_INET6)
3133                 sport = &addr6->sin6_port;
3134         else
3135                 sport = &addr->sin_port;
3136
3137         if (*sport == 0) {
3138                 int rc;
3139
3140                 /* try with 445 port at first */
3141                 *sport = htons(CIFS_PORT);
3142
3143                 rc = generic_ip_connect(server);
3144                 if (rc >= 0)
3145                         return rc;
3146
3147                 /* if it failed, try with 139 port */
3148                 *sport = htons(RFC1001_PORT);
3149         }
3150
3151         return generic_ip_connect(server);
3152 }
3153
3154 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3155                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3156 {
3157         /* if we are reconnecting then should we check to see if
3158          * any requested capabilities changed locally e.g. via
3159          * remount but we can not do much about it here
3160          * if they have (even if we could detect it by the following)
3161          * Perhaps we could add a backpointer to array of sb from tcon
3162          * or if we change to make all sb to same share the same
3163          * sb as NFS - then we only have one backpointer to sb.
3164          * What if we wanted to mount the server share twice once with
3165          * and once without posixacls or posix paths? */
3166         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3167
3168         if (vol_info && vol_info->no_linux_ext) {
3169                 tcon->fsUnixInfo.Capability = 0;
3170                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3171                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3172                 return;
3173         } else if (vol_info)
3174                 tcon->unix_ext = 1; /* Unix Extensions supported */
3175
3176         if (tcon->unix_ext == 0) {
3177                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3178                 return;
3179         }
3180
3181         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3182                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3183                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3184                 /* check for reconnect case in which we do not
3185                    want to change the mount behavior if we can avoid it */
3186                 if (vol_info == NULL) {
3187                         /* turn off POSIX ACL and PATHNAMES if not set
3188                            originally at mount time */
3189                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3190                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3191                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3192                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3193                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3194                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3195                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3196                                 cifs_dbg(VFS, "possible reconnect error\n");
3197                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3198                         }
3199                 }
3200
3201                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3202                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3203
3204                 cap &= CIFS_UNIX_CAP_MASK;
3205                 if (vol_info && vol_info->no_psx_acl)
3206                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3207                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3208                         cifs_dbg(FYI, "negotiated posix acl support\n");
3209                         if (cifs_sb)
3210                                 cifs_sb->mnt_cifs_flags |=
3211                                         CIFS_MOUNT_POSIXACL;
3212                 }
3213
3214                 if (vol_info && vol_info->posix_paths == 0)
3215                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3216                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3217                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3218                         if (cifs_sb)
3219                                 cifs_sb->mnt_cifs_flags |=
3220                                         CIFS_MOUNT_POSIX_PATHS;
3221                 }
3222
3223                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3224 #ifdef CONFIG_CIFS_DEBUG2
3225                 if (cap & CIFS_UNIX_FCNTL_CAP)
3226                         cifs_dbg(FYI, "FCNTL cap\n");
3227                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3228                         cifs_dbg(FYI, "EXTATTR cap\n");
3229                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3230                         cifs_dbg(FYI, "POSIX path cap\n");
3231                 if (cap & CIFS_UNIX_XATTR_CAP)
3232                         cifs_dbg(FYI, "XATTR cap\n");
3233                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3234                         cifs_dbg(FYI, "POSIX ACL cap\n");
3235                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3236                         cifs_dbg(FYI, "very large read cap\n");
3237                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3238                         cifs_dbg(FYI, "very large write cap\n");
3239                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3240                         cifs_dbg(FYI, "transport encryption cap\n");
3241                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3242                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3243 #endif /* CIFS_DEBUG2 */
3244                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3245                         if (vol_info == NULL) {
3246                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3247                         } else
3248                                 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");
3249
3250                 }
3251         }
3252 }
3253
3254 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3255                         struct cifs_sb_info *cifs_sb)
3256 {
3257         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3258
3259         spin_lock_init(&cifs_sb->tlink_tree_lock);
3260         cifs_sb->tlink_tree = RB_ROOT;
3261
3262         /*
3263          * Temporarily set r/wsize for matching superblock. If we end up using
3264          * new sb then client will later negotiate it downward if needed.
3265          */
3266         cifs_sb->rsize = pvolume_info->rsize;
3267         cifs_sb->wsize = pvolume_info->wsize;
3268
3269         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3270         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3271         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3272         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3273         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
3274                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3275
3276         cifs_sb->actimeo = pvolume_info->actimeo;
3277         cifs_sb->local_nls = pvolume_info->local_nls;
3278
3279         if (pvolume_info->noperm)
3280                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3281         if (pvolume_info->setuids)
3282                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3283         if (pvolume_info->server_ino)
3284                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3285         if (pvolume_info->remap)
3286                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3287         if (pvolume_info->sfu_remap)
3288                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3289         if (pvolume_info->no_xattr)
3290                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3291         if (pvolume_info->sfu_emul)
3292                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3293         if (pvolume_info->nobrl)
3294                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3295         if (pvolume_info->nostrictsync)
3296                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3297         if (pvolume_info->mand_lock)
3298                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3299         if (pvolume_info->rwpidforward)
3300                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3301         if (pvolume_info->cifs_acl)
3302                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3303         if (pvolume_info->backupuid_specified) {
3304                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3305                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3306         }
3307         if (pvolume_info->backupgid_specified) {
3308                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3309                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3310         }
3311         if (pvolume_info->override_uid)
3312                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3313         if (pvolume_info->override_gid)
3314                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3315         if (pvolume_info->dynperm)
3316                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3317         if (pvolume_info->fsc)
3318                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3319         if (pvolume_info->multiuser)
3320                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3321                                             CIFS_MOUNT_NO_PERM);
3322         if (pvolume_info->strict_io)
3323                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3324         if (pvolume_info->direct_io) {
3325                 cifs_dbg(FYI, "mounting share using direct i/o\n");
3326                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3327         }
3328         if (pvolume_info->mfsymlinks) {
3329                 if (pvolume_info->sfu_emul) {
3330                         /*
3331                          * Our SFU ("Services for Unix" emulation does not allow
3332                          * creating symlinks but does allow reading existing SFU
3333                          * symlinks (it does allow both creating and reading SFU
3334                          * style mknod and FIFOs though). When "mfsymlinks" and
3335                          * "sfu" are both enabled at the same time, it allows
3336                          * reading both types of symlinks, but will only create
3337                          * them with mfsymlinks format. This allows better
3338                          * Apple compatibility (probably better for Samba too)
3339                          * while still recognizing old Windows style symlinks.
3340                          */
3341                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3342                 }
3343                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3344         }
3345
3346         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3347                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3348 }
3349
3350 static void
3351 cleanup_volume_info_contents(struct smb_vol *volume_info)
3352 {
3353         kfree(volume_info->username);
3354         kzfree(volume_info->password);
3355         kfree(volume_info->UNC);
3356         kfree(volume_info->domainname);
3357         kfree(volume_info->iocharset);
3358         kfree(volume_info->prepath);
3359 }
3360
3361 void
3362 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3363 {
3364         if (!volume_info)
3365                 return;
3366         cleanup_volume_info_contents(volume_info);
3367         kfree(volume_info);
3368 }
3369
3370
3371 #ifdef CONFIG_CIFS_DFS_UPCALL
3372 /*
3373  * cifs_build_path_to_root returns full path to root when we do not have an
3374  * exiting connection (tcon)
3375  */
3376 static char *
3377 build_unc_path_to_root(const struct smb_vol *vol,
3378                 const struct cifs_sb_info *cifs_sb)
3379 {
3380         char *full_path, *pos;
3381         unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3382         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3383
3384         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3385         if (full_path == NULL)
3386                 return ERR_PTR(-ENOMEM);
3387
3388         strncpy(full_path, vol->UNC, unc_len);
3389         pos = full_path + unc_len;
3390
3391         if (pplen) {
3392                 *pos = CIFS_DIR_SEP(cifs_sb);
3393                 strncpy(pos + 1, vol->prepath, pplen);
3394                 pos += pplen;
3395         }
3396
3397         *pos = '\0'; /* add trailing null */
3398         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3399         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3400         return full_path;
3401 }
3402
3403 /*
3404  * Perform a dfs referral query for a share and (optionally) prefix
3405  *
3406  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3407  * to a string containing updated options for the submount.  Otherwise it
3408  * will be left untouched.
3409  *
3410  * Returns the rc from get_dfs_path to the caller, which can be used to
3411  * determine whether there were referrals.
3412  */
3413 static int
3414 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3415                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3416                     int check_prefix)
3417 {
3418         int rc;
3419         unsigned int num_referrals = 0;
3420         struct dfs_info3_param *referrals = NULL;
3421         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3422
3423         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3424         if (IS_ERR(full_path))
3425                 return PTR_ERR(full_path);
3426
3427         /* For DFS paths, skip the first '\' of the UNC */
3428         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3429
3430         rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3431                           &num_referrals, &referrals, cifs_remap(cifs_sb));
3432
3433         if (!rc && num_referrals > 0) {
3434                 char *fake_devname = NULL;
3435
3436                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3437                                                    full_path + 1, referrals,
3438                                                    &fake_devname);
3439
3440                 free_dfs_info_array(referrals, num_referrals);
3441
3442                 if (IS_ERR(mdata)) {
3443                         rc = PTR_ERR(mdata);
3444                         mdata = NULL;
3445                 } else {
3446                         cleanup_volume_info_contents(volume_info);
3447                         rc = cifs_setup_volume_info(volume_info, mdata,
3448                                                         fake_devname);
3449                 }
3450                 kfree(fake_devname);
3451                 kfree(cifs_sb->mountdata);
3452                 cifs_sb->mountdata = mdata;
3453         }
3454         kfree(full_path);
3455         return rc;
3456 }
3457 #endif
3458
3459 static int
3460 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3461                         const char *devname)
3462 {
3463         int rc = 0;
3464
3465         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3466                 return -EINVAL;
3467
3468         if (volume_info->nullauth) {
3469                 cifs_dbg(FYI, "Anonymous login\n");
3470                 kfree(volume_info->username);
3471                 volume_info->username = NULL;
3472         } else if (volume_info->username) {
3473                 /* BB fixme parse for domain name here */
3474                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3475         } else {
3476                 cifs_dbg(VFS, "No username specified\n");
3477         /* In userspace mount helper we can get user name from alternate
3478            locations such as env variables and files on disk */
3479                 return -EINVAL;
3480         }
3481
3482         /* this is needed for ASCII cp to Unicode converts */
3483         if (volume_info->iocharset == NULL) {
3484                 /* load_nls_default cannot return null */
3485                 volume_info->local_nls = load_nls_default();
3486         } else {
3487                 volume_info->local_nls = load_nls(volume_info->iocharset);
3488                 if (volume_info->local_nls == NULL) {
3489                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3490                                  volume_info->iocharset);
3491                         return -ELIBACC;
3492                 }
3493         }
3494
3495         return rc;
3496 }
3497
3498 struct smb_vol *
3499 cifs_get_volume_info(char *mount_data, const char *devname)
3500 {
3501         int rc;
3502         struct smb_vol *volume_info;
3503
3504         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3505         if (!volume_info)
3506                 return ERR_PTR(-ENOMEM);
3507
3508         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3509         if (rc) {
3510                 cifs_cleanup_volume_info(volume_info);
3511                 volume_info = ERR_PTR(rc);
3512         }
3513
3514         return volume_info;
3515 }
3516
3517 int
3518 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3519 {
3520         int rc;
3521         unsigned int xid;
3522         struct cifs_ses *ses;
3523         struct cifs_tcon *tcon;
3524         struct TCP_Server_Info *server;
3525         char   *full_path;
3526         struct tcon_link *tlink;
3527 #ifdef CONFIG_CIFS_DFS_UPCALL
3528         int referral_walks_count = 0;
3529 #endif
3530
3531         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3532         if (rc)
3533                 return rc;
3534
3535 #ifdef CONFIG_CIFS_DFS_UPCALL
3536 try_mount_again:
3537         /* cleanup activities if we're chasing a referral */
3538         if (referral_walks_count) {
3539                 if (tcon)
3540                         cifs_put_tcon(tcon);
3541                 else if (ses)
3542                         cifs_put_smb_ses(ses);
3543
3544                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3545
3546                 free_xid(xid);
3547         }
3548 #endif
3549         rc = 0;
3550         tcon = NULL;
3551         ses = NULL;
3552         server = NULL;
3553         full_path = NULL;
3554         tlink = NULL;
3555
3556         xid = get_xid();
3557
3558         /* get a reference to a tcp session */
3559         server = cifs_get_tcp_session(volume_info);
3560         if (IS_ERR(server)) {
3561                 rc = PTR_ERR(server);
3562                 bdi_destroy(&cifs_sb->bdi);
3563                 goto out;
3564         }
3565
3566         /* get a reference to a SMB session */
3567         ses = cifs_get_smb_ses(server, volume_info);
3568         if (IS_ERR(ses)) {
3569                 rc = PTR_ERR(ses);
3570                 ses = NULL;
3571                 goto mount_fail_check;
3572         }
3573
3574 #ifdef CONFIG_CIFS_SMB2
3575         if ((volume_info->persistent == true) && ((ses->server->capabilities &
3576                 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3577                 cifs_dbg(VFS, "persistent handles not supported by server\n");
3578                 rc = -EOPNOTSUPP;
3579                 goto mount_fail_check;
3580         }
3581 #endif /* CONFIG_CIFS_SMB2*/
3582
3583         /* search for existing tcon to this server share */
3584         tcon = cifs_get_tcon(ses, volume_info);
3585         if (IS_ERR(tcon)) {
3586                 rc = PTR_ERR(tcon);
3587                 tcon = NULL;
3588                 goto remote_path_check;
3589         }
3590
3591         /* tell server which Unix caps we support */
3592         if (cap_unix(tcon->ses)) {
3593                 /* reset of caps checks mount to see if unix extensions
3594                    disabled for just this mount */
3595                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3596                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3597                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3598                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3599                         rc = -EACCES;
3600                         goto mount_fail_check;
3601                 }
3602         } else
3603                 tcon->unix_ext = 0; /* server does not support them */
3604
3605         /* do not care if a following call succeed - informational */
3606         if (!tcon->ipc && server->ops->qfs_tcon)
3607                 server->ops->qfs_tcon(xid, tcon);
3608
3609         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3610         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3611
3612         /* tune readahead according to rsize */
3613         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3614
3615 remote_path_check:
3616 #ifdef CONFIG_CIFS_DFS_UPCALL
3617         /*
3618          * Perform an unconditional check for whether there are DFS
3619          * referrals for this path without prefix, to provide support
3620          * for DFS referrals from w2k8 servers which don't seem to respond
3621          * with PATH_NOT_COVERED to requests that include the prefix.
3622          * Chase the referral if found, otherwise continue normally.
3623          */
3624         if (referral_walks_count == 0) {
3625                 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3626                                                 false);
3627                 if (!refrc) {
3628                         referral_walks_count++;
3629                         goto try_mount_again;
3630                 }
3631         }
3632 #endif
3633
3634         /* check if a whole path is not remote */
3635         if (!rc && tcon) {
3636                 if (!server->ops->is_path_accessible) {
3637                         rc = -ENOSYS;
3638                         goto mount_fail_check;
3639                 }
3640                 /*
3641                  * cifs_build_path_to_root works only when we have a valid tcon
3642                  */
3643                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3644                 if (full_path == NULL) {
3645                         rc = -ENOMEM;
3646                         goto mount_fail_check;
3647                 }
3648                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3649                                                      full_path);
3650                 if (rc != 0 && rc != -EREMOTE) {
3651                         kfree(full_path);
3652                         goto mount_fail_check;
3653                 }
3654                 kfree(full_path);
3655         }
3656
3657         /* get referral if needed */
3658         if (rc == -EREMOTE) {
3659 #ifdef CONFIG_CIFS_DFS_UPCALL
3660                 if (referral_walks_count > MAX_NESTED_LINKS) {
3661                         /*
3662                          * BB: when we implement proper loop detection,
3663                          *     we will remove this check. But now we need it
3664                          *     to prevent an indefinite loop if 'DFS tree' is
3665                          *     misconfigured (i.e. has loops).
3666                          */
3667                         rc = -ELOOP;
3668                         goto mount_fail_check;
3669                 }
3670
3671                 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3672
3673                 if (!rc) {
3674                         referral_walks_count++;
3675                         goto try_mount_again;
3676                 }
3677                 goto mount_fail_check;
3678 #else /* No DFS support, return error on mount */
3679                 rc = -EOPNOTSUPP;
3680 #endif
3681         }
3682
3683         if (rc)
3684                 goto mount_fail_check;
3685
3686         /* now, hang the tcon off of the superblock */
3687         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3688         if (tlink == NULL) {
3689                 rc = -ENOMEM;
3690                 goto mount_fail_check;
3691         }
3692
3693         tlink->tl_uid = ses->linux_uid;
3694         tlink->tl_tcon = tcon;
3695         tlink->tl_time = jiffies;
3696         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3697         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3698
3699         cifs_sb->master_tlink = tlink;
3700         spin_lock(&cifs_sb->tlink_tree_lock);
3701         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3702         spin_unlock(&cifs_sb->tlink_tree_lock);
3703
3704         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3705                                 TLINK_IDLE_EXPIRE);
3706
3707 mount_fail_check:
3708         /* on error free sesinfo and tcon struct if needed */
3709         if (rc) {
3710                 /* If find_unc succeeded then rc == 0 so we can not end */
3711                 /* up accidentally freeing someone elses tcon struct */
3712                 if (tcon)
3713                         cifs_put_tcon(tcon);
3714                 else if (ses)
3715                         cifs_put_smb_ses(ses);
3716                 else
3717                         cifs_put_tcp_session(server);
3718                 bdi_destroy(&cifs_sb->bdi);
3719         }
3720
3721 out:
3722         free_xid(xid);
3723         return rc;
3724 }
3725
3726 /*
3727  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3728  * pointer may be NULL.
3729  */
3730 int
3731 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3732          const char *tree, struct cifs_tcon *tcon,
3733          const struct nls_table *nls_codepage)
3734 {
3735         struct smb_hdr *smb_buffer;
3736         struct smb_hdr *smb_buffer_response;
3737         TCONX_REQ *pSMB;
3738         TCONX_RSP *pSMBr;
3739         unsigned char *bcc_ptr;
3740         int rc = 0;
3741         int length;
3742         __u16 bytes_left, count;
3743
3744         if (ses == NULL)
3745                 return -EIO;
3746
3747         smb_buffer = cifs_buf_get();
3748         if (smb_buffer == NULL)
3749                 return -ENOMEM;
3750
3751         smb_buffer_response = smb_buffer;
3752
3753         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3754                         NULL /*no tid */ , 4 /*wct */ );
3755
3756         smb_buffer->Mid = get_next_mid(ses->server);
3757         smb_buffer->Uid = ses->Suid;
3758         pSMB = (TCONX_REQ *) smb_buffer;
3759         pSMBr = (TCONX_RSP *) smb_buffer_response;
3760
3761         pSMB->AndXCommand = 0xFF;
3762         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3763         bcc_ptr = &pSMB->Password[0];
3764         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3765                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3766                 *bcc_ptr = 0; /* password is null byte */
3767                 bcc_ptr++;              /* skip password */
3768                 /* already aligned so no need to do it below */
3769         } else {
3770                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3771                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3772                    specified as required (when that support is added to
3773                    the vfs in the future) as only NTLM or the much
3774                    weaker LANMAN (which we do not send by default) is accepted
3775                    by Samba (not sure whether other servers allow
3776                    NTLMv2 password here) */
3777 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3778                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3779                     (ses->sectype == LANMAN))
3780                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3781                                          ses->server->sec_mode &
3782                                             SECMODE_PW_ENCRYPT ? true : false,
3783                                          bcc_ptr);
3784                 else
3785 #endif /* CIFS_WEAK_PW_HASH */
3786                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3787                                         bcc_ptr, nls_codepage);
3788                 if (rc) {
3789                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3790                                  __func__, rc);
3791                         cifs_buf_release(smb_buffer);
3792                         return rc;
3793                 }
3794
3795                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3796                 if (ses->capabilities & CAP_UNICODE) {
3797                         /* must align unicode strings */
3798                         *bcc_ptr = 0; /* null byte password */
3799                         bcc_ptr++;
3800                 }
3801         }
3802
3803         if (ses->server->sign)
3804                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3805
3806         if (ses->capabilities & CAP_STATUS32) {
3807                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3808         }
3809         if (ses->capabilities & CAP_DFS) {
3810                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3811         }
3812         if (ses->capabilities & CAP_UNICODE) {
3813                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3814                 length =
3815                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3816                         6 /* max utf8 char length in bytes */ *
3817                         (/* server len*/ + 256 /* share len */), nls_codepage);
3818                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3819                 bcc_ptr += 2;   /* skip trailing null */
3820         } else {                /* ASCII */
3821                 strcpy(bcc_ptr, tree);
3822                 bcc_ptr += strlen(tree) + 1;
3823         }
3824         strcpy(bcc_ptr, "?????");
3825         bcc_ptr += strlen("?????");
3826         bcc_ptr += 1;
3827         count = bcc_ptr - &pSMB->Password[0];
3828         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3829                                         pSMB->hdr.smb_buf_length) + count);
3830         pSMB->ByteCount = cpu_to_le16(count);
3831
3832         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3833                          0);
3834
3835         /* above now done in SendReceive */
3836         if ((rc == 0) && (tcon != NULL)) {
3837                 bool is_unicode;
3838
3839                 tcon->tidStatus = CifsGood;
3840                 tcon->need_reconnect = false;
3841                 tcon->tid = smb_buffer_response->Tid;
3842                 bcc_ptr = pByteArea(smb_buffer_response);
3843                 bytes_left = get_bcc(smb_buffer_response);
3844                 length = strnlen(bcc_ptr, bytes_left - 2);
3845                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3846                         is_unicode = true;
3847                 else
3848                         is_unicode = false;
3849
3850
3851                 /* skip service field (NB: this field is always ASCII) */
3852                 if (length == 3) {
3853                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3854                             (bcc_ptr[2] == 'C')) {
3855                                 cifs_dbg(FYI, "IPC connection\n");
3856                                 tcon->ipc = 1;
3857                         }
3858                 } else if (length == 2) {
3859                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3860                                 /* the most common case */
3861                                 cifs_dbg(FYI, "disk share connection\n");
3862                         }
3863                 }
3864                 bcc_ptr += length + 1;
3865                 bytes_left -= (length + 1);
3866                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3867
3868                 /* mostly informational -- no need to fail on error here */
3869                 kfree(tcon->nativeFileSystem);
3870                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3871                                                       bytes_left, is_unicode,
3872                                                       nls_codepage);
3873
3874                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3875
3876                 if ((smb_buffer_response->WordCount == 3) ||
3877                          (smb_buffer_response->WordCount == 7))
3878                         /* field is in same location */
3879                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3880                 else
3881                         tcon->Flags = 0;
3882                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3883         } else if ((rc == 0) && tcon == NULL) {
3884                 /* all we need to save for IPC$ connection */
3885                 ses->ipc_tid = smb_buffer_response->Tid;
3886         }
3887
3888         cifs_buf_release(smb_buffer);
3889         return rc;
3890 }
3891
3892 static void delayed_free(struct rcu_head *p)
3893 {
3894         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3895         unload_nls(sbi->local_nls);
3896         kfree(sbi);
3897 }
3898
3899 void
3900 cifs_umount(struct cifs_sb_info *cifs_sb)
3901 {
3902         struct rb_root *root = &cifs_sb->tlink_tree;
3903         struct rb_node *node;
3904         struct tcon_link *tlink;
3905
3906         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3907
3908         spin_lock(&cifs_sb->tlink_tree_lock);
3909         while ((node = rb_first(root))) {
3910                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3911                 cifs_get_tlink(tlink);
3912                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3913                 rb_erase(node, root);
3914
3915                 spin_unlock(&cifs_sb->tlink_tree_lock);
3916                 cifs_put_tlink(tlink);
3917                 spin_lock(&cifs_sb->tlink_tree_lock);
3918         }
3919         spin_unlock(&cifs_sb->tlink_tree_lock);
3920
3921         bdi_destroy(&cifs_sb->bdi);
3922         kfree(cifs_sb->mountdata);
3923         call_rcu(&cifs_sb->rcu, delayed_free);
3924 }
3925
3926 int
3927 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3928 {
3929         int rc = 0;
3930         struct TCP_Server_Info *server = ses->server;
3931
3932         if (!server->ops->need_neg || !server->ops->negotiate)
3933                 return -ENOSYS;
3934
3935         /* only send once per connect */
3936         if (!server->ops->need_neg(server))
3937                 return 0;
3938
3939         set_credits(server, 1);
3940
3941         rc = server->ops->negotiate(xid, ses);
3942         if (rc == 0) {
3943                 spin_lock(&GlobalMid_Lock);
3944                 if (server->tcpStatus == CifsNeedNegotiate)
3945                         server->tcpStatus = CifsGood;
3946                 else
3947                         rc = -EHOSTDOWN;
3948                 spin_unlock(&GlobalMid_Lock);
3949         }
3950
3951         return rc;
3952 }
3953
3954 int
3955 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3956                    struct nls_table *nls_info)
3957 {
3958         int rc = -ENOSYS;
3959         struct TCP_Server_Info *server = ses->server;
3960
3961         ses->capabilities = server->capabilities;
3962         if (linuxExtEnabled == 0)
3963                 ses->capabilities &= (~server->vals->cap_unix);
3964
3965         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3966                  server->sec_mode, server->capabilities, server->timeAdj);
3967
3968         if (server->ops->sess_setup)
3969                 rc = server->ops->sess_setup(xid, ses, nls_info);
3970
3971         if (rc)
3972                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3973
3974         return rc;
3975 }
3976
3977 static int
3978 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3979 {
3980         vol->sectype = ses->sectype;
3981
3982         /* krb5 is special, since we don't need username or pw */
3983         if (vol->sectype == Kerberos)
3984                 return 0;
3985
3986         return cifs_set_cifscreds(vol, ses);
3987 }
3988
3989 static struct cifs_tcon *
3990 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3991 {
3992         int rc;
3993         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3994         struct cifs_ses *ses;
3995         struct cifs_tcon *tcon = NULL;
3996         struct smb_vol *vol_info;
3997
3998         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3999         if (vol_info == NULL)
4000                 return ERR_PTR(-ENOMEM);
4001
4002         vol_info->local_nls = cifs_sb->local_nls;
4003         vol_info->linux_uid = fsuid;
4004         vol_info->cred_uid = fsuid;
4005         vol_info->UNC = master_tcon->treeName;
4006         vol_info->retry = master_tcon->retry;
4007         vol_info->nocase = master_tcon->nocase;
4008         vol_info->local_lease = master_tcon->local_lease;
4009         vol_info->no_linux_ext = !master_tcon->unix_ext;
4010         vol_info->sectype = master_tcon->ses->sectype;
4011         vol_info->sign = master_tcon->ses->sign;
4012
4013         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4014         if (rc) {
4015                 tcon = ERR_PTR(rc);
4016                 goto out;
4017         }
4018
4019         /* get a reference for the same TCP session */
4020         spin_lock(&cifs_tcp_ses_lock);
4021         ++master_tcon->ses->server->srv_count;
4022         spin_unlock(&cifs_tcp_ses_lock);
4023
4024         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4025         if (IS_ERR(ses)) {
4026                 tcon = (struct cifs_tcon *)ses;
4027                 cifs_put_tcp_session(master_tcon->ses->server);
4028                 goto out;
4029         }
4030
4031         tcon = cifs_get_tcon(ses, vol_info);
4032         if (IS_ERR(tcon)) {
4033                 cifs_put_smb_ses(ses);
4034                 goto out;
4035         }
4036
4037         if (cap_unix(ses))
4038                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4039 out:
4040         kfree(vol_info->username);
4041         kfree(vol_info->password);
4042         kfree(vol_info);
4043
4044         return tcon;
4045 }
4046
4047 struct cifs_tcon *
4048 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4049 {
4050         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4051 }
4052
4053 /* find and return a tlink with given uid */
4054 static struct tcon_link *
4055 tlink_rb_search(struct rb_root *root, kuid_t uid)
4056 {
4057         struct rb_node *node = root->rb_node;
4058         struct tcon_link *tlink;
4059
4060         while (node) {
4061                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4062
4063                 if (uid_gt(tlink->tl_uid, uid))
4064                         node = node->rb_left;
4065                 else if (uid_lt(tlink->tl_uid, uid))
4066                         node = node->rb_right;
4067                 else
4068                         return tlink;
4069         }
4070         return NULL;
4071 }
4072
4073 /* insert a tcon_link into the tree */
4074 static void
4075 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4076 {
4077         struct rb_node **new = &(root->rb_node), *parent = NULL;
4078         struct tcon_link *tlink;
4079
4080         while (*new) {
4081                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4082                 parent = *new;
4083
4084                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4085                         new = &((*new)->rb_left);
4086                 else
4087                         new = &((*new)->rb_right);
4088         }
4089
4090         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4091         rb_insert_color(&new_tlink->tl_rbnode, root);
4092 }
4093
4094 /*
4095  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4096  * current task.
4097  *
4098  * If the superblock doesn't refer to a multiuser mount, then just return
4099  * the master tcon for the mount.
4100  *
4101  * First, search the rbtree for an existing tcon for this fsuid. If one
4102  * exists, then check to see if it's pending construction. If it is then wait
4103  * for construction to complete. Once it's no longer pending, check to see if
4104  * it failed and either return an error or retry construction, depending on
4105  * the timeout.
4106  *
4107  * If one doesn't exist then insert a new tcon_link struct into the tree and
4108  * try to construct a new one.
4109  */
4110 struct tcon_link *
4111 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4112 {
4113         int ret;
4114         kuid_t fsuid = current_fsuid();
4115         struct tcon_link *tlink, *newtlink;
4116
4117         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4118                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4119
4120         spin_lock(&cifs_sb->tlink_tree_lock);
4121         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4122         if (tlink)
4123                 cifs_get_tlink(tlink);
4124         spin_unlock(&cifs_sb->tlink_tree_lock);
4125
4126         if (tlink == NULL) {
4127                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4128                 if (newtlink == NULL)
4129                         return ERR_PTR(-ENOMEM);
4130                 newtlink->tl_uid = fsuid;
4131                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4132                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4133                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4134                 cifs_get_tlink(newtlink);
4135
4136                 spin_lock(&cifs_sb->tlink_tree_lock);
4137                 /* was one inserted after previous search? */
4138                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4139                 if (tlink) {
4140                         cifs_get_tlink(tlink);
4141                         spin_unlock(&cifs_sb->tlink_tree_lock);
4142                         kfree(newtlink);
4143                         goto wait_for_construction;
4144                 }
4145                 tlink = newtlink;
4146                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4147                 spin_unlock(&cifs_sb->tlink_tree_lock);
4148         } else {
4149 wait_for_construction:
4150                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4151                                   TASK_INTERRUPTIBLE);
4152                 if (ret) {
4153                         cifs_put_tlink(tlink);
4154                         return ERR_PTR(-ERESTARTSYS);
4155                 }
4156
4157                 /* if it's good, return it */
4158                 if (!IS_ERR(tlink->tl_tcon))
4159                         return tlink;
4160
4161                 /* return error if we tried this already recently */
4162                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4163                         cifs_put_tlink(tlink);
4164                         return ERR_PTR(-EACCES);
4165                 }
4166
4167                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4168                         goto wait_for_construction;
4169         }
4170
4171         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4172         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4173         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4174
4175         if (IS_ERR(tlink->tl_tcon)) {
4176                 cifs_put_tlink(tlink);
4177                 return ERR_PTR(-EACCES);
4178         }
4179
4180         return tlink;
4181 }
4182
4183 /*
4184  * periodic workqueue job that scans tcon_tree for a superblock and closes
4185  * out tcons.
4186  */
4187 static void
4188 cifs_prune_tlinks(struct work_struct *work)
4189 {
4190         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4191                                                     prune_tlinks.work);
4192         struct rb_root *root = &cifs_sb->tlink_tree;
4193         struct rb_node *node = rb_first(root);
4194         struct rb_node *tmp;
4195         struct tcon_link *tlink;
4196
4197         /*
4198          * Because we drop the spinlock in the loop in order to put the tlink
4199          * it's not guarded against removal of links from the tree. The only
4200          * places that remove entries from the tree are this function and
4201          * umounts. Because this function is non-reentrant and is canceled
4202          * before umount can proceed, this is safe.
4203          */
4204         spin_lock(&cifs_sb->tlink_tree_lock);
4205         node = rb_first(root);
4206         while (node != NULL) {
4207                 tmp = node;
4208                 node = rb_next(tmp);
4209                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4210
4211                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4212                     atomic_read(&tlink->tl_count) != 0 ||
4213                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4214                         continue;
4215
4216                 cifs_get_tlink(tlink);
4217                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4218                 rb_erase(tmp, root);
4219
4220                 spin_unlock(&cifs_sb->tlink_tree_lock);
4221                 cifs_put_tlink(tlink);
4222                 spin_lock(&cifs_sb->tlink_tree_lock);
4223         }
4224         spin_unlock(&cifs_sb->tlink_tree_lock);
4225
4226         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4227                                 TLINK_IDLE_EXPIRE);
4228 }