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/sched/signal.h>
  25 #include <linux/list.h>
  26 #include <linux/wait.h>
  27 #include <linux/slab.h>
  28 #include <linux/pagemap.h>
  29 #include <linux/ctype.h>
  30 #include <linux/utsname.h>
  31 #include <linux/mempool.h>
  32 #include <linux/delay.h>
  33 #include <linux/completion.h>
  34 #include <linux/kthread.h>
  35 #include <linux/pagevec.h>
  36 #include <linux/freezer.h>
  37 #include <linux/namei.h>
  38 #include <linux/uaccess.h>
  39 #include <asm/processor.h>
  40 #include <linux/inet.h>
  41 #include <linux/module.h>
  42 #include <keys/user-type.h>
  43 #include <net/ipv6.h>
  44 #include <linux/parser.h>
  45 #include <linux/bvec.h>
  46
  47 #include "cifspdu.h"
  48 #include "cifsglob.h"
  49 #include "cifsproto.h"
  50 #include "cifs_unicode.h"
  51 #include "cifs_debug.h"
  52 #include "cifs_fs_sb.h"
  53 #include "ntlmssp.h"
  54 #include "nterr.h"
  55 #include "rfc1002pdu.h"
  56 #include "fscache.h"
  57 #ifdef CONFIG_CIFS_SMB2
  58 #include "smb2proto.h"
  59 #endif
  60
  61 #define CIFS_PORT 445
  62 #define RFC1001_PORT 139
  63
  64 extern mempool_t *cifs_req_poolp;
  65
  66 /* FIXME: should these be tunable? */
  67 #define TLINK_ERROR_EXPIRE      (1 * HZ)
  68 #define TLINK_IDLE_EXPIRE       (600 * HZ)
  69
  70 enum {
  71         /* Mount options that take no arguments */
  72         Opt_user_xattr, Opt_nouser_xattr,
  73         Opt_forceuid, Opt_noforceuid,
  74         Opt_forcegid, Opt_noforcegid,
  75         Opt_noblocksend, Opt_noautotune,
  76         Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
  77         Opt_mapposix, Opt_nomapposix,
  78         Opt_mapchars, Opt_nomapchars, Opt_sfu,
  79         Opt_nosfu, Opt_nodfs, Opt_posixpaths,
  80         Opt_noposixpaths, Opt_nounix,
  81         Opt_nocase,
  82         Opt_brl, Opt_nobrl,
  83         Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
  84         Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
  85         Opt_nohard, Opt_nosoft,
  86         Opt_nointr, Opt_intr,
  87         Opt_nostrictsync, Opt_strictsync,
  88         Opt_serverino, Opt_noserverino,
  89         Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
  90         Opt_acl, Opt_noacl, Opt_locallease,
  91         Opt_sign, Opt_seal, Opt_noac,
  92         Opt_fsc, Opt_mfsymlinks,
  93         Opt_multiuser, Opt_sloppy, Opt_nosharesock,
  94         Opt_persistent, Opt_nopersistent,
  95         Opt_resilient, Opt_noresilient,
  96         Opt_domainauto,
  97
  98         /* Mount options which take numeric value */
  99         Opt_backupuid, Opt_backupgid, Opt_uid,
 100         Opt_cruid, Opt_gid, Opt_file_mode,
 101         Opt_dirmode, Opt_port,
 102         Opt_rsize, Opt_wsize, Opt_actimeo,
 103         Opt_echo_interval, Opt_max_credits,
 104         Opt_snapshot,
 105
 106         /* Mount options which take string value */
 107         Opt_user, Opt_pass, Opt_ip,
 108         Opt_domain, Opt_srcaddr, Opt_iocharset,
 109         Opt_netbiosname, Opt_servern,
 110         Opt_ver, Opt_vers, Opt_sec, Opt_cache,
 111
 112         /* Mount options to be ignored */
 113         Opt_ignore,
 114
 115         /* Options which could be blank */
 116         Opt_blank_pass,
 117         Opt_blank_user,
 118         Opt_blank_ip,
 119
 120         Opt_err
 121 };
 122
 123 static const match_table_t cifs_mount_option_tokens = {
 124
 125         { Opt_user_xattr, "user_xattr" },
 126         { Opt_nouser_xattr, "nouser_xattr" },
 127         { Opt_forceuid, "forceuid" },
 128         { Opt_noforceuid, "noforceuid" },
 129         { Opt_forcegid, "forcegid" },
 130         { Opt_noforcegid, "noforcegid" },
 131         { Opt_noblocksend, "noblocksend" },
 132         { Opt_noautotune, "noautotune" },
 133         { Opt_hard, "hard" },
 134         { Opt_soft, "soft" },
 135         { Opt_perm, "perm" },
 136         { Opt_noperm, "noperm" },
 137         { Opt_mapchars, "mapchars" }, /* SFU style */
 138         { Opt_nomapchars, "nomapchars" },
 139         { Opt_mapposix, "mapposix" }, /* SFM style */
 140         { Opt_nomapposix, "nomapposix" },
 141         { Opt_sfu, "sfu" },
 142         { Opt_nosfu, "nosfu" },
 143         { Opt_nodfs, "nodfs" },
 144         { Opt_posixpaths, "posixpaths" },
 145         { Opt_noposixpaths, "noposixpaths" },
 146         { Opt_nounix, "nounix" },
 147         { Opt_nounix, "nolinux" },
 148         { Opt_nocase, "nocase" },
 149         { Opt_nocase, "ignorecase" },
 150         { Opt_brl, "brl" },
 151         { Opt_nobrl, "nobrl" },
 152         { Opt_nobrl, "nolock" },
 153         { Opt_forcemandatorylock, "forcemandatorylock" },
 154         { Opt_forcemandatorylock, "forcemand" },
 155         { Opt_setuids, "setuids" },
 156         { Opt_nosetuids, "nosetuids" },
 157         { Opt_setuidfromacl, "idsfromsid" },
 158         { Opt_dynperm, "dynperm" },
 159         { Opt_nodynperm, "nodynperm" },
 160         { Opt_nohard, "nohard" },
 161         { Opt_nosoft, "nosoft" },
 162         { Opt_nointr, "nointr" },
 163         { Opt_intr, "intr" },
 164         { Opt_nostrictsync, "nostrictsync" },
 165         { Opt_strictsync, "strictsync" },
 166         { Opt_serverino, "serverino" },
 167         { Opt_noserverino, "noserverino" },
 168         { Opt_rwpidforward, "rwpidforward" },
 169         { Opt_cifsacl, "cifsacl" },
 170         { Opt_nocifsacl, "nocifsacl" },
 171         { Opt_acl, "acl" },
 172         { Opt_noacl, "noacl" },
 173         { Opt_locallease, "locallease" },
 174         { Opt_sign, "sign" },
 175         { Opt_seal, "seal" },
 176         { Opt_noac, "noac" },
 177         { Opt_fsc, "fsc" },
 178         { Opt_mfsymlinks, "mfsymlinks" },
 179         { Opt_multiuser, "multiuser" },
 180         { Opt_sloppy, "sloppy" },
 181         { Opt_nosharesock, "nosharesock" },
 182         { Opt_persistent, "persistenthandles"},
 183         { Opt_nopersistent, "nopersistenthandles"},
 184         { Opt_resilient, "resilienthandles"},
 185         { Opt_noresilient, "noresilienthandles"},
 186         { Opt_domainauto, "domainauto"},
 187
 188         { Opt_backupuid, "backupuid=%s" },
 189         { Opt_backupgid, "backupgid=%s" },
 190         { Opt_uid, "uid=%s" },
 191         { Opt_cruid, "cruid=%s" },
 192         { Opt_gid, "gid=%s" },
 193         { Opt_file_mode, "file_mode=%s" },
 194         { Opt_dirmode, "dirmode=%s" },
 195         { Opt_dirmode, "dir_mode=%s" },
 196         { Opt_port, "port=%s" },
 197         { Opt_rsize, "rsize=%s" },
 198         { Opt_wsize, "wsize=%s" },
 199         { Opt_actimeo, "actimeo=%s" },
 200         { Opt_echo_interval, "echo_interval=%s" },
 201         { Opt_max_credits, "max_credits=%s" },
 202         { Opt_snapshot, "snapshot=%s" },
 203
 204         { Opt_blank_user, "user=" },
 205         { Opt_blank_user, "username=" },
 206         { Opt_user, "user=%s" },
 207         { Opt_user, "username=%s" },
 208         { Opt_blank_pass, "pass=" },
 209         { Opt_blank_pass, "password=" },
 210         { Opt_pass, "pass=%s" },
 211         { Opt_pass, "password=%s" },
 212         { Opt_blank_ip, "ip=" },
 213         { Opt_blank_ip, "addr=" },
 214         { Opt_ip, "ip=%s" },
 215         { Opt_ip, "addr=%s" },
 216         { Opt_ignore, "unc=%s" },
 217         { Opt_ignore, "target=%s" },
 218         { Opt_ignore, "path=%s" },
 219         { Opt_domain, "dom=%s" },
 220         { Opt_domain, "domain=%s" },
 221         { Opt_domain, "workgroup=%s" },
 222         { Opt_srcaddr, "srcaddr=%s" },
 223         { Opt_ignore, "prefixpath=%s" },
 224         { Opt_iocharset, "iocharset=%s" },
 225         { Opt_netbiosname, "netbiosname=%s" },
 226         { Opt_servern, "servern=%s" },
 227         { Opt_ver, "ver=%s" },
 228         { Opt_vers, "vers=%s" },
 229         { Opt_sec, "sec=%s" },
 230         { Opt_cache, "cache=%s" },
 231
 232         { Opt_ignore, "cred" },
 233         { Opt_ignore, "credentials" },
 234         { Opt_ignore, "cred=%s" },
 235         { Opt_ignore, "credentials=%s" },
 236         { Opt_ignore, "guest" },
 237         { Opt_ignore, "rw" },
 238         { Opt_ignore, "ro" },
 239         { Opt_ignore, "suid" },
 240         { Opt_ignore, "nosuid" },
 241         { Opt_ignore, "exec" },
 242         { Opt_ignore, "noexec" },
 243         { Opt_ignore, "nodev" },
 244         { Opt_ignore, "noauto" },
 245         { Opt_ignore, "dev" },
 246         { Opt_ignore, "mand" },
 247         { Opt_ignore, "nomand" },
 248         { Opt_ignore, "_netdev" },
 249
 250         { Opt_err, NULL }
 251 };
 252
 253 enum {
 254         Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
 255         Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
 256         Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
 257         Opt_sec_ntlmv2i, Opt_sec_lanman,
 258         Opt_sec_none,
 259
 260         Opt_sec_err
 261 };
 262
 263 static const match_table_t cifs_secflavor_tokens = {
 264         { Opt_sec_krb5, "krb5" },
 265         { Opt_sec_krb5i, "krb5i" },
 266         { Opt_sec_krb5p, "krb5p" },
 267         { Opt_sec_ntlmsspi, "ntlmsspi" },
 268         { Opt_sec_ntlmssp, "ntlmssp" },
 269         { Opt_ntlm, "ntlm" },
 270         { Opt_sec_ntlmi, "ntlmi" },
 271         { Opt_sec_ntlmv2, "nontlm" },
 272         { Opt_sec_ntlmv2, "ntlmv2" },
 273         { Opt_sec_ntlmv2i, "ntlmv2i" },
 274         { Opt_sec_lanman, "lanman" },
 275         { Opt_sec_none, "none" },
 276
 277         { Opt_sec_err, NULL }
 278 };
 279
 280 /* cache flavors */
 281 enum {
 282         Opt_cache_loose,
 283         Opt_cache_strict,
 284         Opt_cache_none,
 285         Opt_cache_err
 286 };
 287
 288 static const match_table_t cifs_cacheflavor_tokens = {
 289         { Opt_cache_loose, "loose" },
 290         { Opt_cache_strict, "strict" },
 291         { Opt_cache_none, "none" },
 292         { Opt_cache_err, NULL }
 293 };
 294
 295 static const match_table_t cifs_smb_version_tokens = {
 296         { Smb_1, SMB1_VERSION_STRING },
 297         { Smb_20, SMB20_VERSION_STRING},
 298         { Smb_21, SMB21_VERSION_STRING },
 299         { Smb_30, SMB30_VERSION_STRING },
 300         { Smb_302, SMB302_VERSION_STRING },
 301 #ifdef CONFIG_CIFS_SMB311
 302         { Smb_311, SMB311_VERSION_STRING },
 303         { Smb_311, ALT_SMB311_VERSION_STRING },
 304 #endif /* SMB311 */
 305         { Smb_version_err, NULL }
 306 };
 307
 308 static int ip_connect(struct TCP_Server_Info *server);
 309 static int generic_ip_connect(struct TCP_Server_Info *server);
 310 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 311 static void cifs_prune_tlinks(struct work_struct *work);
 312 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
 313                                         const char *devname);
 314
 315 /*
 316  * cifs tcp session reconnection
 317  *
 318  * mark tcp session as reconnecting so temporarily locked
 319  * mark all smb sessions as reconnecting for tcp session
 320  * reconnect tcp session
 321  * wake up waiters on reconnection? - (not needed currently)
 322  */
 323 int
 324 cifs_reconnect(struct TCP_Server_Info *server)
 325 {
 326         int rc = 0;
 327         struct list_head *tmp, *tmp2;
 328         struct cifs_ses *ses;
 329         struct cifs_tcon *tcon;
 330         struct mid_q_entry *mid_entry;
 331         struct list_head retry_list;
 332
 333         spin_lock(&GlobalMid_Lock);
 334         if (server->tcpStatus == CifsExiting) {
 335                 /* the demux thread will exit normally
 336                 next time through the loop */
 337                 spin_unlock(&GlobalMid_Lock);
 338                 return rc;
 339         } else
 340                 server->tcpStatus = CifsNeedReconnect;
 341         spin_unlock(&GlobalMid_Lock);
 342         server->maxBuf = 0;
 343 #ifdef CONFIG_CIFS_SMB2
 344         server->max_read = 0;
 345 #endif
 346
 347         cifs_dbg(FYI, "Reconnecting tcp session\n");
 348
 349         /* before reconnecting the tcp session, mark the smb session (uid)
 350                 and the tid bad so they are not used until reconnected */
 351         cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
 352                  __func__);
 353         spin_lock(&cifs_tcp_ses_lock);
 354         list_for_each(tmp, &server->smb_ses_list) {
 355                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 356                 ses->need_reconnect = true;
 357                 ses->ipc_tid = 0;
 358                 list_for_each(tmp2, &ses->tcon_list) {
 359                         tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
 360                         tcon->need_reconnect = true;
 361                 }
 362         }
 363         spin_unlock(&cifs_tcp_ses_lock);
 364
 365         /* do not want to be sending data on a socket we are freeing */
 366         cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
 367         mutex_lock(&server->srv_mutex);
 368         if (server->ssocket) {
 369                 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
 370                          server->ssocket->state, server->ssocket->flags);
 371                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 372                 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
 373                          server->ssocket->state, server->ssocket->flags);
 374                 sock_release(server->ssocket);
 375                 server->ssocket = NULL;
 376         }
 377         server->sequence_number = 0;
 378         server->session_estab = false;
 379         kfree(server->session_key.response);
 380         server->session_key.response = NULL;
 381         server->session_key.len = 0;
 382         server->lstrp = jiffies;
 383
 384         /* mark submitted MIDs for retry and issue callback */
 385         INIT_LIST_HEAD(&retry_list);
 386         cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
 387         spin_lock(&GlobalMid_Lock);
 388         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 389                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 390                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 391                         mid_entry->mid_state = MID_RETRY_NEEDED;
 392                 list_move(&mid_entry->qhead, &retry_list);
 393         }
 394         spin_unlock(&GlobalMid_Lock);
 395         mutex_unlock(&server->srv_mutex);
 396
 397         cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
 398         list_for_each_safe(tmp, tmp2, &retry_list) {
 399                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 400                 list_del_init(&mid_entry->qhead);
 401                 mid_entry->callback(mid_entry);
 402         }
 403
 404         do {
 405                 try_to_freeze();
 406
 407                 /* we should try only the port we connected to before */
 408                 mutex_lock(&server->srv_mutex);
 409                 rc = generic_ip_connect(server);
 410                 if (rc) {
 411                         cifs_dbg(FYI, "reconnect error %d\n", rc);
 412                         mutex_unlock(&server->srv_mutex);
 413                         msleep(3000);
 414                 } else {
 415                         atomic_inc(&tcpSesReconnectCount);
 416                         spin_lock(&GlobalMid_Lock);
 417                         if (server->tcpStatus != CifsExiting)
 418                                 server->tcpStatus = CifsNeedNegotiate;
 419                         spin_unlock(&GlobalMid_Lock);
 420                         mutex_unlock(&server->srv_mutex);
 421                 }
 422         } while (server->tcpStatus == CifsNeedReconnect);
 423
 424         if (server->tcpStatus == CifsNeedNegotiate)
 425                 mod_delayed_work(cifsiod_wq, &server->echo, 0);
 426
 427         return rc;
 428 }
 429
 430 static void
 431 cifs_echo_request(struct work_struct *work)
 432 {
 433         int rc;
 434         struct TCP_Server_Info *server = container_of(work,
 435                                         struct TCP_Server_Info, echo.work);
 436         unsigned long echo_interval;
 437
 438         /*
 439          * If we need to renegotiate, set echo interval to zero to
 440          * immediately call echo service where we can renegotiate.
 441          */
 442         if (server->tcpStatus == CifsNeedNegotiate)
 443                 echo_interval = 0;
 444         else
 445                 echo_interval = server->echo_interval;
 446
 447         /*
 448          * We cannot send an echo if it is disabled.
 449          * Also, no need to ping if we got a response recently.
 450          */
 451
 452         if (server->tcpStatus == CifsNeedReconnect ||
 453             server->tcpStatus == CifsExiting ||
 454             server->tcpStatus == CifsNew ||
 455             (server->ops->can_echo && !server->ops->can_echo(server)) ||
 456             time_before(jiffies, server->lstrp + echo_interval - HZ))
 457                 goto requeue_echo;
 458
 459         rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
 460         if (rc)
 461                 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
 462                          server->hostname);
 463
 464 requeue_echo:
 465         queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
 466 }
 467
 468 static bool
 469 allocate_buffers(struct TCP_Server_Info *server)
 470 {
 471         if (!server->bigbuf) {
 472                 server->bigbuf = (char *)cifs_buf_get();
 473                 if (!server->bigbuf) {
 474                         cifs_dbg(VFS, "No memory for large SMB response\n");
 475                         msleep(3000);
 476                         /* retry will check if exiting */
 477                         return false;
 478                 }
 479         } else if (server->large_buf) {
 480                 /* we are reusing a dirty large buf, clear its start */
 481                 memset(server->bigbuf, 0, HEADER_SIZE(server));
 482         }
 483
 484         if (!server->smallbuf) {
 485                 server->smallbuf = (char *)cifs_small_buf_get();
 486                 if (!server->smallbuf) {
 487                         cifs_dbg(VFS, "No memory for SMB response\n");
 488                         msleep(1000);
 489                         /* retry will check if exiting */
 490                         return false;
 491                 }
 492                 /* beginning of smb buffer is cleared in our buf_get */
 493         } else {
 494                 /* if existing small buf clear beginning */
 495                 memset(server->smallbuf, 0, HEADER_SIZE(server));
 496         }
 497
 498         return true;
 499 }
 500
 501 static bool
 502 server_unresponsive(struct TCP_Server_Info *server)
 503 {
 504         /*
 505          * We need to wait 2 echo intervals to make sure we handle such
 506          * situations right:
 507          * 1s  client sends a normal SMB request
 508          * 2s  client gets a response
 509          * 30s echo workqueue job pops, and decides we got a response recently
 510          *     and don't need to send another
 511          * ...
 512          * 65s kernel_recvmsg times out, and we see that we haven't gotten
 513          *     a response in >60s.
 514          */
 515         if (server->tcpStatus == CifsGood &&
 516             time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
 517                 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
 518                          server->hostname, (2 * server->echo_interval) / HZ);
 519                 cifs_reconnect(server);
 520                 wake_up(&server->response_q);
 521                 return true;
 522         }
 523
 524         return false;
 525 }
 526
 527 static int
 528 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
 529 {
 530         int length = 0;
 531         int total_read;
 532
 533         smb_msg->msg_control = NULL;
 534         smb_msg->msg_controllen = 0;
 535
 536         for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
 537                 try_to_freeze();
 538
 539                 if (server_unresponsive(server))
 540                         return -ECONNABORTED;
 541
 542                 length = sock_recvmsg(server->ssocket, smb_msg, 0);
 543
 544                 if (server->tcpStatus == CifsExiting)
 545                         return -ESHUTDOWN;
 546
 547                 if (server->tcpStatus == CifsNeedReconnect) {
 548                         cifs_reconnect(server);
 549                         return -ECONNABORTED;
 550                 }
 551
 552                 if (length == -ERESTARTSYS ||
 553                     length == -EAGAIN ||
 554                     length == -EINTR) {
 555                         /*
 556                          * Minimum sleep to prevent looping, allowing socket
 557                          * to clear and app threads to set tcpStatus
 558                          * CifsNeedReconnect if server hung.
 559                          */
 560                         usleep_range(1000, 2000);
 561                         length = 0;
 562                         continue;
 563                 }
 564
 565                 if (length <= 0) {
 566                         cifs_dbg(FYI, "Received no data or error: %d\n", length);
 567                         cifs_reconnect(server);
 568                         return -ECONNABORTED;
 569                 }
 570         }
 571         return total_read;
 572 }
 573
 574 int
 575 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 576                       unsigned int to_read)
 577 {
 578         struct msghdr smb_msg;
 579         struct kvec iov = {.iov_base = buf, .iov_len = to_read};
 580         iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
 581
 582         return cifs_readv_from_socket(server, &smb_msg);
 583 }
 584
 585 int
 586 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
 587                       unsigned int to_read)
 588 {
 589         struct msghdr smb_msg;
 590         struct bio_vec bv = {.bv_page = page, .bv_len = to_read};
 591         iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
 592         return cifs_readv_from_socket(server, &smb_msg);
 593 }
 594
 595 static bool
 596 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 597 {
 598         /*
 599          * The first byte big endian of the length field,
 600          * is actually not part of the length but the type
 601          * with the most common, zero, as regular data.
 602          */
 603         switch (type) {
 604         case RFC1002_SESSION_MESSAGE:
 605                 /* Regular SMB response */
 606                 return true;
 607         case RFC1002_SESSION_KEEP_ALIVE:
 608                 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
 609                 break;
 610         case RFC1002_POSITIVE_SESSION_RESPONSE:
 611                 cifs_dbg(FYI, "RFC 1002 positive session response\n");
 612                 break;
 613         case RFC1002_NEGATIVE_SESSION_RESPONSE:
 614                 /*
 615                  * We get this from Windows 98 instead of an error on
 616                  * SMB negprot response.
 617                  */
 618                 cifs_dbg(FYI, "RFC 1002 negative session response\n");
 619                 /* give server a second to clean up */
 620                 msleep(1000);
 621                 /*
 622                  * Always try 445 first on reconnect since we get NACK
 623                  * on some if we ever connected to port 139 (the NACK
 624                  * is since we do not begin with RFC1001 session
 625                  * initialize frame).
 626                  */
 627                 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 628                 cifs_reconnect(server);
 629                 wake_up(&server->response_q);
 630                 break;
 631         default:
 632                 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
 633                 cifs_reconnect(server);
 634         }
 635
 636         return false;
 637 }
 638
 639 void
 640 dequeue_mid(struct mid_q_entry *mid, bool malformed)
 641 {
 642 #ifdef CONFIG_CIFS_STATS2
 643         mid->when_received = jiffies;
 644 #endif
 645         spin_lock(&GlobalMid_Lock);
 646         if (!malformed)
 647                 mid->mid_state = MID_RESPONSE_RECEIVED;
 648         else
 649                 mid->mid_state = MID_RESPONSE_MALFORMED;
 650         list_del_init(&mid->qhead);
 651         spin_unlock(&GlobalMid_Lock);
 652 }
 653
 654 static void
 655 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 656            char *buf, int malformed)
 657 {
 658         if (server->ops->check_trans2 &&
 659             server->ops->check_trans2(mid, server, buf, malformed))
 660                 return;
 661         mid->resp_buf = buf;
 662         mid->large_buf = server->large_buf;
 663         /* Was previous buf put in mpx struct for multi-rsp? */
 664         if (!mid->multiRsp) {
 665                 /* smb buffer will be freed by user thread */
 666                 if (server->large_buf)
 667                         server->bigbuf = NULL;
 668                 else
 669                         server->smallbuf = NULL;
 670         }
 671         dequeue_mid(mid, malformed);
 672 }
 673
 674 static void clean_demultiplex_info(struct TCP_Server_Info *server)
 675 {
 676         int length;
 677
 678         /* take it off the list, if it's not already */
 679         spin_lock(&cifs_tcp_ses_lock);
 680         list_del_init(&server->tcp_ses_list);
 681         spin_unlock(&cifs_tcp_ses_lock);
 682
 683         spin_lock(&GlobalMid_Lock);
 684         server->tcpStatus = CifsExiting;
 685         spin_unlock(&GlobalMid_Lock);
 686         wake_up_all(&server->response_q);
 687
 688         /* check if we have blocked requests that need to free */
 689         spin_lock(&server->req_lock);
 690         if (server->credits <= 0)
 691                 server->credits = 1;
 692         spin_unlock(&server->req_lock);
 693         /*
 694          * Although there should not be any requests blocked on this queue it
 695          * can not hurt to be paranoid and try to wake up requests that may
 696          * haven been blocked when more than 50 at time were on the wire to the
 697          * same server - they now will see the session is in exit state and get
 698          * out of SendReceive.
 699          */
 700         wake_up_all(&server->request_q);
 701         /* give those requests time to exit */
 702         msleep(125);
 703
 704         if (server->ssocket) {
 705                 sock_release(server->ssocket);
 706                 server->ssocket = NULL;
 707         }
 708
 709         if (!list_empty(&server->pending_mid_q)) {
 710                 struct list_head dispose_list;
 711                 struct mid_q_entry *mid_entry;
 712                 struct list_head *tmp, *tmp2;
 713
 714                 INIT_LIST_HEAD(&dispose_list);
 715                 spin_lock(&GlobalMid_Lock);
 716                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 717                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 718                         cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
 719                         mid_entry->mid_state = MID_SHUTDOWN;
 720                         list_move(&mid_entry->qhead, &dispose_list);
 721                 }
 722                 spin_unlock(&GlobalMid_Lock);
 723
 724                 /* now walk dispose list and issue callbacks */
 725                 list_for_each_safe(tmp, tmp2, &dispose_list) {
 726                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 727                         cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
 728                         list_del_init(&mid_entry->qhead);
 729                         mid_entry->callback(mid_entry);
 730                 }
 731                 /* 1/8th of sec is more than enough time for them to exit */
 732                 msleep(125);
 733         }
 734
 735         if (!list_empty(&server->pending_mid_q)) {
 736                 /*
 737                  * mpx threads have not exited yet give them at least the smb
 738                  * send timeout time for long ops.
 739                  *
 740                  * Due to delays on oplock break requests, we need to wait at
 741                  * least 45 seconds before giving up on a request getting a
 742                  * response and going ahead and killing cifsd.
 743                  */
 744                 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
 745                 msleep(46000);
 746                 /*
 747                  * If threads still have not exited they are probably never
 748                  * coming home not much else we can do but free the memory.
 749                  */
 750         }
 751
 752         kfree(server->hostname);
 753         kfree(server);
 754
 755         length = atomic_dec_return(&tcpSesAllocCount);
 756         if (length > 0)
 757                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 758 }
 759
 760 static int
 761 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 762 {
 763         int length;
 764         char *buf = server->smallbuf;
 765         unsigned int pdu_length = get_rfc1002_length(buf);
 766
 767         /* make sure this will fit in a large buffer */
 768         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
 769                 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
 770                 cifs_reconnect(server);
 771                 wake_up(&server->response_q);
 772                 return -ECONNABORTED;
 773         }
 774
 775         /* switch to large buffer if too big for a small one */
 776         if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 777                 server->large_buf = true;
 778                 memcpy(server->bigbuf, buf, server->total_read);
 779                 buf = server->bigbuf;
 780         }
 781
 782         /* now read the rest */
 783         length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
 784                                 pdu_length - HEADER_SIZE(server) + 1 + 4);
 785         if (length < 0)
 786                 return length;
 787         server->total_read += length;
 788
 789         dump_smb(buf, server->total_read);
 790
 791         return cifs_handle_standard(server, mid);
 792 }
 793
 794 int
 795 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 796 {
 797         char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
 798         int length;
 799
 800         /*
 801          * We know that we received enough to get to the MID as we
 802          * checked the pdu_length earlier. Now check to see
 803          * if the rest of the header is OK. We borrow the length
 804          * var for the rest of the loop to avoid a new stack var.
 805          *
 806          * 48 bytes is enough to display the header and a little bit
 807          * into the payload for debugging purposes.
 808          */
 809         length = server->ops->check_message(buf, server->total_read, server);
 810         if (length != 0)
 811                 cifs_dump_mem("Bad SMB: ", buf,
 812                         min_t(unsigned int, server->total_read, 48));
 813
 814         if (server->ops->is_status_pending &&
 815             server->ops->is_status_pending(buf, server, length))
 816                 return -1;
 817
 818         if (!mid)
 819                 return length;
 820
 821         handle_mid(mid, server, buf, length);
 822         return 0;
 823 }
 824
 825 static int
 826 cifs_demultiplex_thread(void *p)
 827 {
 828         int length;
 829         struct TCP_Server_Info *server = p;
 830         unsigned int pdu_length;
 831         char *buf = NULL;
 832         struct task_struct *task_to_wake = NULL;
 833         struct mid_q_entry *mid_entry;
 834
 835         current->flags |= PF_MEMALLOC;
 836         cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
 837
 838         length = atomic_inc_return(&tcpSesAllocCount);
 839         if (length > 1)
 840                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 841
 842         set_freezable();
 843         while (server->tcpStatus != CifsExiting) {
 844                 if (try_to_freeze())
 845                         continue;
 846
 847                 if (!allocate_buffers(server))
 848                         continue;
 849
 850                 server->large_buf = false;
 851                 buf = server->smallbuf;
 852                 pdu_length = 4; /* enough to get RFC1001 header */
 853
 854                 length = cifs_read_from_socket(server, buf, pdu_length);
 855                 if (length < 0)
 856                         continue;
 857                 server->total_read = length;
 858
 859                 /*
 860                  * The right amount was read from socket - 4 bytes,
 861                  * so we can now interpret the length field.
 862                  */
 863                 pdu_length = get_rfc1002_length(buf);
 864
 865                 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
 866                 if (!is_smb_response(server, buf[0]))
 867                         continue;
 868
 869                 /* make sure we have enough to get to the MID */
 870                 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
 871                         cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
 872                                  pdu_length);
 873                         cifs_reconnect(server);
 874                         wake_up(&server->response_q);
 875                         continue;
 876                 }
 877
 878                 /* read down to the MID */
 879                 length = cifs_read_from_socket(server, buf + 4,
 880                                                HEADER_SIZE(server) - 1 - 4);
 881                 if (length < 0)
 882                         continue;
 883                 server->total_read += length;
 884
 885                 if (server->ops->is_transform_hdr &&
 886                     server->ops->receive_transform &&
 887                     server->ops->is_transform_hdr(buf)) {
 888                         length = server->ops->receive_transform(server,
 889                                                                 &mid_entry);
 890                 } else {
 891                         mid_entry = server->ops->find_mid(server, buf);
 892
 893                         if (!mid_entry || !mid_entry->receive)
 894                                 length = standard_receive3(server, mid_entry);
 895                         else
 896                                 length = mid_entry->receive(server, mid_entry);
 897                 }
 898
 899                 if (length < 0)
 900                         continue;
 901
 902                 if (server->large_buf)
 903                         buf = server->bigbuf;
 904
 905                 server->lstrp = jiffies;
 906                 if (mid_entry != NULL) {
 907                         if (!mid_entry->multiRsp || mid_entry->multiEnd)
 908                                 mid_entry->callback(mid_entry);
 909                 } else if (!server->ops->is_oplock_break ||
 910                            !server->ops->is_oplock_break(buf, server)) {
 911                         cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
 912                                  atomic_read(&midCount));
 913                         cifs_dump_mem("Received Data is: ", buf,
 914                                       HEADER_SIZE(server));
 915 #ifdef CONFIG_CIFS_DEBUG2
 916                         if (server->ops->dump_detail)
 917                                 server->ops->dump_detail(buf);
 918                         cifs_dump_mids(server);
 919 #endif /* CIFS_DEBUG2 */
 920
 921                 }
 922         } /* end while !EXITING */
 923
 924         /* buffer usually freed in free_mid - need to free it here on exit */
 925         cifs_buf_release(server->bigbuf);
 926         if (server->smallbuf) /* no sense logging a debug message if NULL */
 927                 cifs_small_buf_release(server->smallbuf);
 928
 929         task_to_wake = xchg(&server->tsk, NULL);
 930         clean_demultiplex_info(server);
 931
 932         /* if server->tsk was NULL then wait for a signal before exiting */
 933         if (!task_to_wake) {
 934                 set_current_state(TASK_INTERRUPTIBLE);
 935                 while (!signal_pending(current)) {
 936                         schedule();
 937                         set_current_state(TASK_INTERRUPTIBLE);
 938                 }
 939                 set_current_state(TASK_RUNNING);
 940         }
 941
 942         module_put_and_exit(0);
 943 }
 944
 945 /* extract the host portion of the UNC string */
 946 static char *
 947 extract_hostname(const char *unc)
 948 {
 949         const char *src;
 950         char *dst, *delim;
 951         unsigned int len;
 952
 953         /* skip double chars at beginning of string */
 954         /* BB: check validity of these bytes? */
 955         src = unc + 2;
 956
 957         /* delimiter between hostname and sharename is always '\\' now */
 958         delim = strchr(src, '\\');
 959         if (!delim)
 960                 return ERR_PTR(-EINVAL);
 961
 962         len = delim - src;
 963         dst = kmalloc((len + 1), GFP_KERNEL);
 964         if (dst == NULL)
 965                 return ERR_PTR(-ENOMEM);
 966
 967         memcpy(dst, src, len);
 968         dst[len] = '\0';
 969
 970         return dst;
 971 }
 972
 973 static int get_option_ul(substring_t args[], unsigned long *option)
 974 {
 975         int rc;
 976         char *string;
 977
 978         string = match_strdup(args);
 979         if (string == NULL)
 980                 return -ENOMEM;
 981         rc = kstrtoul(string, 0, option);
 982         kfree(string);
 983
 984         return rc;
 985 }
 986
 987 static int get_option_uid(substring_t args[], kuid_t *result)
 988 {
 989         unsigned long value;
 990         kuid_t uid;
 991         int rc;
 992
 993         rc = get_option_ul(args, &value);
 994         if (rc)
 995                 return rc;
 996
 997         uid = make_kuid(current_user_ns(), value);
 998         if (!uid_valid(uid))
 999                 return -EINVAL;
1000
1001         *result = uid;
1002         return 0;
1003 }
1004
1005 static int get_option_gid(substring_t args[], kgid_t *result)
1006 {
1007         unsigned long value;
1008         kgid_t gid;
1009         int rc;
1010
1011         rc = get_option_ul(args, &value);
1012         if (rc)
1013                 return rc;
1014
1015         gid = make_kgid(current_user_ns(), value);
1016         if (!gid_valid(gid))
1017                 return -EINVAL;
1018
1019         *result = gid;
1020         return 0;
1021 }
1022
1023 static int cifs_parse_security_flavors(char *value,
1024                                        struct smb_vol *vol)
1025 {
1026
1027         substring_t args[MAX_OPT_ARGS];
1028
1029         /*
1030          * With mount options, the last one should win. Reset any existing
1031          * settings back to default.
1032          */
1033         vol->sectype = Unspecified;
1034         vol->sign = false;
1035
1036         switch (match_token(value, cifs_secflavor_tokens, args)) {
1037         case Opt_sec_krb5p:
1038                 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1039                 return 1;
1040         case Opt_sec_krb5i:
1041                 vol->sign = true;
1042                 /* Fallthrough */
1043         case Opt_sec_krb5:
1044                 vol->sectype = Kerberos;
1045                 break;
1046         case Opt_sec_ntlmsspi:
1047                 vol->sign = true;
1048                 /* Fallthrough */
1049         case Opt_sec_ntlmssp:
1050                 vol->sectype = RawNTLMSSP;
1051                 break;
1052         case Opt_sec_ntlmi:
1053                 vol->sign = true;
1054                 /* Fallthrough */
1055         case Opt_ntlm:
1056                 vol->sectype = NTLM;
1057                 break;
1058         case Opt_sec_ntlmv2i:
1059                 vol->sign = true;
1060                 /* Fallthrough */
1061         case Opt_sec_ntlmv2:
1062                 vol->sectype = NTLMv2;
1063                 break;
1064 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1065         case Opt_sec_lanman:
1066                 vol->sectype = LANMAN;
1067                 break;
1068 #endif
1069         case Opt_sec_none:
1070                 vol->nullauth = 1;
1071                 break;
1072         default:
1073                 cifs_dbg(VFS, "bad security option: %s\n", value);
1074                 return 1;
1075         }
1076
1077         return 0;
1078 }
1079
1080 static int
1081 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1082 {
1083         substring_t args[MAX_OPT_ARGS];
1084
1085         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1086         case Opt_cache_loose:
1087                 vol->direct_io = false;
1088                 vol->strict_io = false;
1089                 break;
1090         case Opt_cache_strict:
1091                 vol->direct_io = false;
1092                 vol->strict_io = true;
1093                 break;
1094         case Opt_cache_none:
1095                 vol->direct_io = true;
1096                 vol->strict_io = false;
1097                 break;
1098         default:
1099                 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1100                 return 1;
1101         }
1102         return 0;
1103 }
1104
1105 static int
1106 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1107 {
1108         substring_t args[MAX_OPT_ARGS];
1109
1110         switch (match_token(value, cifs_smb_version_tokens, args)) {
1111         case Smb_1:
1112                 vol->ops = &smb1_operations;
1113                 vol->vals = &smb1_values;
1114                 break;
1115 #ifdef CONFIG_CIFS_SMB2
1116         case Smb_20:
1117                 vol->ops = &smb20_operations;
1118                 vol->vals = &smb20_values;
1119                 break;
1120         case Smb_21:
1121                 vol->ops = &smb21_operations;
1122                 vol->vals = &smb21_values;
1123                 break;
1124         case Smb_30:
1125                 vol->ops = &smb30_operations;
1126                 vol->vals = &smb30_values;
1127                 break;
1128         case Smb_302:
1129                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1130                 vol->vals = &smb302_values;
1131                 break;
1132 #ifdef CONFIG_CIFS_SMB311
1133         case Smb_311:
1134                 vol->ops = &smb311_operations;
1135                 vol->vals = &smb311_values;
1136                 break;
1137 #endif /* SMB311 */
1138 #endif
1139         default:
1140                 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1141                 return 1;
1142         }
1143         return 0;
1144 }
1145
1146 /*
1147  * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1148  * fields with the result. Returns 0 on success and an error otherwise.
1149  */
1150 static int
1151 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1152 {
1153         char *pos;
1154         const char *delims = "/\\";
1155         size_t len;
1156
1157         /* make sure we have a valid UNC double delimiter prefix */
1158         len = strspn(devname, delims);
1159         if (len != 2)
1160                 return -EINVAL;
1161
1162         /* find delimiter between host and sharename */
1163         pos = strpbrk(devname + 2, delims);
1164         if (!pos)
1165                 return -EINVAL;
1166
1167         /* skip past delimiter */
1168         ++pos;
1169
1170         /* now go until next delimiter or end of string */
1171         len = strcspn(pos, delims);
1172
1173         /* move "pos" up to delimiter or NULL */
1174         pos += len;
1175         vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1176         if (!vol->UNC)
1177                 return -ENOMEM;
1178
1179         convert_delimiter(vol->UNC, '\\');
1180
1181         /* skip any delimiter */
1182         if (*pos == '/' || *pos == '\\')
1183                 pos++;
1184
1185         /* If pos is NULL then no prepath */
1186         if (!*pos)
1187                 return 0;
1188
1189         vol->prepath = kstrdup(pos, GFP_KERNEL);
1190         if (!vol->prepath)
1191                 return -ENOMEM;
1192
1193         return 0;
1194 }
1195
1196 static int
1197 cifs_parse_mount_options(const char *mountdata, const char *devname,
1198                          struct smb_vol *vol)
1199 {
1200         char *data, *end;
1201         char *mountdata_copy = NULL, *options;
1202         unsigned int  temp_len, i, j;
1203         char separator[2];
1204         short int override_uid = -1;
1205         short int override_gid = -1;
1206         bool uid_specified = false;
1207         bool gid_specified = false;
1208         bool sloppy = false;
1209         char *invalid = NULL;
1210         char *nodename = utsname()->nodename;
1211         char *string = NULL;
1212         char *tmp_end, *value;
1213         char delim;
1214         bool got_ip = false;
1215         unsigned short port = 0;
1216         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1217
1218         separator[0] = ',';
1219         separator[1] = 0;
1220         delim = separator[0];
1221
1222         /* ensure we always start with zeroed-out smb_vol */
1223         memset(vol, 0, sizeof(*vol));
1224
1225         /*
1226          * does not have to be perfect mapping since field is
1227          * informational, only used for servers that do not support
1228          * port 445 and it can be overridden at mount time
1229          */
1230         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1231         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1232                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1233
1234         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1235         /* null target name indicates to use *SMBSERVR default called name
1236            if we end up sending RFC1001 session initialize */
1237         vol->target_rfc1001_name[0] = 0;
1238         vol->cred_uid = current_uid();
1239         vol->linux_uid = current_uid();
1240         vol->linux_gid = current_gid();
1241
1242         /*
1243          * default to SFM style remapping of seven reserved characters
1244          * unless user overrides it or we negotiate CIFS POSIX where
1245          * it is unnecessary.  Can not simultaneously use more than one mapping
1246          * since then readdir could list files that open could not open
1247          */
1248         vol->remap = true;
1249
1250         /* default to only allowing write access to owner of the mount */
1251         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1252
1253         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1254         /* default is always to request posix paths. */
1255         vol->posix_paths = 1;
1256         /* default to using server inode numbers where available */
1257         vol->server_ino = 1;
1258
1259         /* default is to use strict cifs caching semantics */
1260         vol->strict_io = true;
1261
1262         vol->actimeo = CIFS_DEF_ACTIMEO;
1263
1264         /* FIXME: add autonegotiation -- for now, SMB1 is default */
1265         vol->ops = &smb1_operations;
1266         vol->vals = &smb1_values;
1267
1268         vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1269
1270         if (!mountdata)
1271                 goto cifs_parse_mount_err;
1272
1273         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1274         if (!mountdata_copy)
1275                 goto cifs_parse_mount_err;
1276
1277         options = mountdata_copy;
1278         end = options + strlen(options);
1279
1280         if (strncmp(options, "sep=", 4) == 0) {
1281                 if (options[4] != 0) {
1282                         separator[0] = options[4];
1283                         options += 5;
1284                 } else {
1285                         cifs_dbg(FYI, "Null separator not allowed\n");
1286                 }
1287         }
1288         vol->backupuid_specified = false; /* no backup intent for a user */
1289         vol->backupgid_specified = false; /* no backup intent for a group */
1290
1291         switch (cifs_parse_devname(devname, vol)) {
1292         case 0:
1293                 break;
1294         case -ENOMEM:
1295                 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1296                 goto cifs_parse_mount_err;
1297         case -EINVAL:
1298                 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1299                 goto cifs_parse_mount_err;
1300         default:
1301                 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1302                 goto cifs_parse_mount_err;
1303         }
1304
1305         while ((data = strsep(&options, separator)) != NULL) {
1306                 substring_t args[MAX_OPT_ARGS];
1307                 unsigned long option;
1308                 int token;
1309
1310                 if (!*data)
1311                         continue;
1312
1313                 token = match_token(data, cifs_mount_option_tokens, args);
1314
1315                 switch (token) {
1316
1317                 /* Ingnore the following */
1318                 case Opt_ignore:
1319                         break;
1320
1321                 /* Boolean values */
1322                 case Opt_user_xattr:
1323                         vol->no_xattr = 0;
1324                         break;
1325                 case Opt_nouser_xattr:
1326                         vol->no_xattr = 1;
1327                         break;
1328                 case Opt_forceuid:
1329                         override_uid = 1;
1330                         break;
1331                 case Opt_noforceuid:
1332                         override_uid = 0;
1333                         break;
1334                 case Opt_forcegid:
1335                         override_gid = 1;
1336                         break;
1337                 case Opt_noforcegid:
1338                         override_gid = 0;
1339                         break;
1340                 case Opt_noblocksend:
1341                         vol->noblocksnd = 1;
1342                         break;
1343                 case Opt_noautotune:
1344                         vol->noautotune = 1;
1345                         break;
1346                 case Opt_hard:
1347                         vol->retry = 1;
1348                         break;
1349                 case Opt_soft:
1350                         vol->retry = 0;
1351                         break;
1352                 case Opt_perm:
1353                         vol->noperm = 0;
1354                         break;
1355                 case Opt_noperm:
1356                         vol->noperm = 1;
1357                         break;
1358                 case Opt_mapchars:
1359                         vol->sfu_remap = true;
1360                         vol->remap = false; /* disable SFM mapping */
1361                         break;
1362                 case Opt_nomapchars:
1363                         vol->sfu_remap = false;
1364                         break;
1365                 case Opt_mapposix:
1366                         vol->remap = true;
1367                         vol->sfu_remap = false; /* disable SFU mapping */
1368                         break;
1369                 case Opt_nomapposix:
1370                         vol->remap = false;
1371                         break;
1372                 case Opt_sfu:
1373                         vol->sfu_emul = 1;
1374                         break;
1375                 case Opt_nosfu:
1376                         vol->sfu_emul = 0;
1377                         break;
1378                 case Opt_nodfs:
1379                         vol->nodfs = 1;
1380                         break;
1381                 case Opt_posixpaths:
1382                         vol->posix_paths = 1;
1383                         break;
1384                 case Opt_noposixpaths:
1385                         vol->posix_paths = 0;
1386                         break;
1387                 case Opt_nounix:
1388                         vol->no_linux_ext = 1;
1389                         break;
1390                 case Opt_nocase:
1391                         vol->nocase = 1;
1392                         break;
1393                 case Opt_brl:
1394                         vol->nobrl =  0;
1395                         break;
1396                 case Opt_nobrl:
1397                         vol->nobrl =  1;
1398                         /*
1399                          * turn off mandatory locking in mode
1400                          * if remote locking is turned off since the
1401                          * local vfs will do advisory
1402                          */
1403                         if (vol->file_mode ==
1404                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1405                                 vol->file_mode = S_IALLUGO;
1406                         break;
1407                 case Opt_forcemandatorylock:
1408                         vol->mand_lock = 1;
1409                         break;
1410                 case Opt_setuids:
1411                         vol->setuids = 1;
1412                         break;
1413                 case Opt_nosetuids:
1414                         vol->setuids = 0;
1415                         break;
1416                 case Opt_setuidfromacl:
1417                         vol->setuidfromacl = 1;
1418                         break;
1419                 case Opt_dynperm:
1420                         vol->dynperm = true;
1421                         break;
1422                 case Opt_nodynperm:
1423                         vol->dynperm = false;
1424                         break;
1425                 case Opt_nohard:
1426                         vol->retry = 0;
1427                         break;
1428                 case Opt_nosoft:
1429                         vol->retry = 1;
1430                         break;
1431                 case Opt_nointr:
1432                         vol->intr = 0;
1433                         break;
1434                 case Opt_intr:
1435                         vol->intr = 1;
1436                         break;
1437                 case Opt_nostrictsync:
1438                         vol->nostrictsync = 1;
1439                         break;
1440                 case Opt_strictsync:
1441                         vol->nostrictsync = 0;
1442                         break;
1443                 case Opt_serverino:
1444                         vol->server_ino = 1;
1445                         break;
1446                 case Opt_noserverino:
1447                         vol->server_ino = 0;
1448                         break;
1449                 case Opt_rwpidforward:
1450                         vol->rwpidforward = 1;
1451                         break;
1452                 case Opt_cifsacl:
1453                         vol->cifs_acl = 1;
1454                         break;
1455                 case Opt_nocifsacl:
1456                         vol->cifs_acl = 0;
1457                         break;
1458                 case Opt_acl:
1459                         vol->no_psx_acl = 0;
1460                         break;
1461                 case Opt_noacl:
1462                         vol->no_psx_acl = 1;
1463                         break;
1464                 case Opt_locallease:
1465                         vol->local_lease = 1;
1466                         break;
1467                 case Opt_sign:
1468                         vol->sign = true;
1469                         break;
1470                 case Opt_seal:
1471                         /* we do not do the following in secFlags because seal
1472                          * is a per tree connection (mount) not a per socket
1473                          * or per-smb connection option in the protocol
1474                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1475                          */
1476                         vol->seal = 1;
1477                         break;
1478                 case Opt_noac:
1479                         pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1480                         break;
1481                 case Opt_fsc:
1482 #ifndef CONFIG_CIFS_FSCACHE
1483                         cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1484                         goto cifs_parse_mount_err;
1485 #endif
1486                         vol->fsc = true;
1487                         break;
1488                 case Opt_mfsymlinks:
1489                         vol->mfsymlinks = true;
1490                         break;
1491                 case Opt_multiuser:
1492                         vol->multiuser = true;
1493                         break;
1494                 case Opt_sloppy:
1495                         sloppy = true;
1496                         break;
1497                 case Opt_nosharesock:
1498                         vol->nosharesock = true;
1499                         break;
1500                 case Opt_nopersistent:
1501                         vol->nopersistent = true;
1502                         if (vol->persistent) {
1503                                 cifs_dbg(VFS,
1504                                   "persistenthandles mount options conflict\n");
1505                                 goto cifs_parse_mount_err;
1506                         }
1507                         break;
1508                 case Opt_persistent:
1509                         vol->persistent = true;
1510                         if ((vol->nopersistent) || (vol->resilient)) {
1511                                 cifs_dbg(VFS,
1512                                   "persistenthandles mount options conflict\n");
1513                                 goto cifs_parse_mount_err;
1514                         }
1515                         break;
1516                 case Opt_resilient:
1517                         vol->resilient = true;
1518                         if (vol->persistent) {
1519                                 cifs_dbg(VFS,
1520                                   "persistenthandles mount options conflict\n");
1521                                 goto cifs_parse_mount_err;
1522                         }
1523                         break;
1524                 case Opt_noresilient:
1525                         vol->resilient = false; /* already the default */
1526                         break;
1527                 case Opt_domainauto:
1528                         vol->domainauto = true;
1529                         break;
1530
1531                 /* Numeric Values */
1532                 case Opt_backupuid:
1533                         if (get_option_uid(args, &vol->backupuid)) {
1534                                 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1535                                          __func__);
1536                                 goto cifs_parse_mount_err;
1537                         }
1538                         vol->backupuid_specified = true;
1539                         break;
1540                 case Opt_backupgid:
1541                         if (get_option_gid(args, &vol->backupgid)) {
1542                                 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1543                                          __func__);
1544                                 goto cifs_parse_mount_err;
1545                         }
1546                         vol->backupgid_specified = true;
1547                         break;
1548                 case Opt_uid:
1549                         if (get_option_uid(args, &vol->linux_uid)) {
1550                                 cifs_dbg(VFS, "%s: Invalid uid value\n",
1551                                          __func__);
1552                                 goto cifs_parse_mount_err;
1553                         }
1554                         uid_specified = true;
1555                         break;
1556                 case Opt_cruid:
1557                         if (get_option_uid(args, &vol->cred_uid)) {
1558                                 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1559                                          __func__);
1560                                 goto cifs_parse_mount_err;
1561                         }
1562                         break;
1563                 case Opt_gid:
1564                         if (get_option_gid(args, &vol->linux_gid)) {
1565                                 cifs_dbg(VFS, "%s: Invalid gid value\n",
1566                                          __func__);
1567                                 goto cifs_parse_mount_err;
1568                         }
1569                         gid_specified = true;
1570                         break;
1571                 case Opt_file_mode:
1572                         if (get_option_ul(args, &option)) {
1573                                 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1574                                          __func__);
1575                                 goto cifs_parse_mount_err;
1576                         }
1577                         vol->file_mode = option;
1578                         break;
1579                 case Opt_dirmode:
1580                         if (get_option_ul(args, &option)) {
1581                                 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1582                                          __func__);
1583                                 goto cifs_parse_mount_err;
1584                         }
1585                         vol->dir_mode = option;
1586                         break;
1587                 case Opt_port:
1588                         if (get_option_ul(args, &option) ||
1589                             option > USHRT_MAX) {
1590                                 cifs_dbg(VFS, "%s: Invalid port value\n",
1591                                          __func__);
1592                                 goto cifs_parse_mount_err;
1593                         }
1594                         port = (unsigned short)option;
1595                         break;
1596                 case Opt_rsize:
1597                         if (get_option_ul(args, &option)) {
1598                                 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1599                                          __func__);
1600                                 goto cifs_parse_mount_err;
1601                         }
1602                         vol->rsize = option;
1603                         break;
1604                 case Opt_wsize:
1605                         if (get_option_ul(args, &option)) {
1606                                 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1607                                          __func__);
1608                                 goto cifs_parse_mount_err;
1609                         }
1610                         vol->wsize = option;
1611                         break;
1612                 case Opt_actimeo:
1613                         if (get_option_ul(args, &option)) {
1614                                 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1615                                          __func__);
1616                                 goto cifs_parse_mount_err;
1617                         }
1618                         vol->actimeo = HZ * option;
1619                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1620                                 cifs_dbg(VFS, "attribute cache timeout too large\n");
1621                                 goto cifs_parse_mount_err;
1622                         }
1623                         break;
1624                 case Opt_echo_interval:
1625                         if (get_option_ul(args, &option)) {
1626                                 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1627                                          __func__);
1628                                 goto cifs_parse_mount_err;
1629                         }
1630                         vol->echo_interval = option;
1631                         break;
1632                 case Opt_snapshot:
1633                         if (get_option_ul(args, &option)) {
1634                                 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1635                                          __func__);
1636                                 goto cifs_parse_mount_err;
1637                         }
1638                         vol->snapshot_time = option;
1639                         break;
1640                 case Opt_max_credits:
1641                         if (get_option_ul(args, &option) || (option < 20) ||
1642                             (option > 60000)) {
1643                                 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1644                                          __func__);
1645                                 goto cifs_parse_mount_err;
1646                         }
1647                         vol->max_credits = option;
1648                         break;
1649
1650                 /* String Arguments */
1651
1652                 case Opt_blank_user:
1653                         /* null user, ie. anonymous authentication */
1654                         vol->nullauth = 1;
1655                         vol->username = NULL;
1656                         break;
1657                 case Opt_user:
1658                         string = match_strdup(args);
1659                         if (string == NULL)
1660                                 goto out_nomem;
1661
1662                         if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1663                                                         CIFS_MAX_USERNAME_LEN) {
1664                                 pr_warn("CIFS: username too long\n");
1665                                 goto cifs_parse_mount_err;
1666                         }
1667
1668                         kfree(vol->username);
1669                         vol->username = kstrdup(string, GFP_KERNEL);
1670                         if (!vol->username)
1671                                 goto cifs_parse_mount_err;
1672                         break;
1673                 case Opt_blank_pass:
1674                         /* passwords have to be handled differently
1675                          * to allow the character used for deliminator
1676                          * to be passed within them
1677                          */
1678
1679                         /*
1680                          * Check if this is a case where the  password
1681                          * starts with a delimiter
1682                          */
1683                         tmp_end = strchr(data, '=');
1684                         tmp_end++;
1685                         if (!(tmp_end < end && tmp_end[1] == delim)) {
1686                                 /* No it is not. Set the password to NULL */
1687                                 kfree(vol->password);
1688                                 vol->password = NULL;
1689                                 break;
1690                         }
1691                         /* Yes it is. Drop down to Opt_pass below.*/
1692                 case Opt_pass:
1693                         /* Obtain the value string */
1694                         value = strchr(data, '=');
1695                         value++;
1696
1697                         /* Set tmp_end to end of the string */
1698                         tmp_end = (char *) value + strlen(value);
1699
1700                         /* Check if following character is the deliminator
1701                          * If yes, we have encountered a double deliminator
1702                          * reset the NULL character to the deliminator
1703                          */
1704                         if (tmp_end < end && tmp_end[1] == delim) {
1705                                 tmp_end[0] = delim;
1706
1707                                 /* Keep iterating until we get to a single
1708                                  * deliminator OR the end
1709                                  */
1710                                 while ((tmp_end = strchr(tmp_end, delim))
1711                                         != NULL && (tmp_end[1] == delim)) {
1712                                                 tmp_end = (char *) &tmp_end[2];
1713                                 }
1714
1715                                 /* Reset var options to point to next element */
1716                                 if (tmp_end) {
1717                                         tmp_end[0] = '\0';
1718                                         options = (char *) &tmp_end[1];
1719                                 } else
1720                                         /* Reached the end of the mount option
1721                                          * string */
1722                                         options = end;
1723                         }
1724
1725                         kfree(vol->password);
1726                         /* Now build new password string */
1727                         temp_len = strlen(value);
1728                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1729                         if (vol->password == NULL) {
1730                                 pr_warn("CIFS: no memory for password\n");
1731                                 goto cifs_parse_mount_err;
1732                         }
1733
1734                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1735                                 vol->password[j] = value[i];
1736                                 if ((value[i] == delim) &&
1737                                      value[i+1] == delim)
1738                                         /* skip the second deliminator */
1739                                         i++;
1740                         }
1741                         vol->password[j] = '\0';
1742                         break;
1743                 case Opt_blank_ip:
1744                         /* FIXME: should this be an error instead? */
1745                         got_ip = false;
1746                         break;
1747                 case Opt_ip:
1748                         string = match_strdup(args);
1749                         if (string == NULL)
1750                                 goto out_nomem;
1751
1752                         if (!cifs_convert_address(dstaddr, string,
1753                                         strlen(string))) {
1754                                 pr_err("CIFS: bad ip= option (%s).\n", string);
1755                                 goto cifs_parse_mount_err;
1756                         }
1757                         got_ip = true;
1758                         break;
1759                 case Opt_domain:
1760                         string = match_strdup(args);
1761                         if (string == NULL)
1762                                 goto out_nomem;
1763
1764                         if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1765                                         == CIFS_MAX_DOMAINNAME_LEN) {
1766                                 pr_warn("CIFS: domain name too long\n");
1767                                 goto cifs_parse_mount_err;
1768                         }
1769
1770                         kfree(vol->domainname);
1771                         vol->domainname = kstrdup(string, GFP_KERNEL);
1772                         if (!vol->domainname) {
1773                                 pr_warn("CIFS: no memory for domainname\n");
1774                                 goto cifs_parse_mount_err;
1775                         }
1776                         cifs_dbg(FYI, "Domain name set\n");
1777                         break;
1778                 case Opt_srcaddr:
1779                         string = match_strdup(args);
1780                         if (string == NULL)
1781                                 goto out_nomem;
1782
1783                         if (!cifs_convert_address(
1784                                         (struct sockaddr *)&vol->srcaddr,
1785                                         string, strlen(string))) {
1786                                 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1787                                         string);
1788                                 goto cifs_parse_mount_err;
1789                         }
1790                         break;
1791                 case Opt_iocharset:
1792                         string = match_strdup(args);
1793                         if (string == NULL)
1794                                 goto out_nomem;
1795
1796                         if (strnlen(string, 1024) >= 65) {
1797                                 pr_warn("CIFS: iocharset name too long.\n");
1798                                 goto cifs_parse_mount_err;
1799                         }
1800
1801                          if (strncasecmp(string, "default", 7) != 0) {
1802                                 kfree(vol->iocharset);
1803                                 vol->iocharset = kstrdup(string,
1804                                                          GFP_KERNEL);
1805                                 if (!vol->iocharset) {
1806                                         pr_warn("CIFS: no memory for charset\n");
1807                                         goto cifs_parse_mount_err;
1808                                 }
1809                         }
1810                         /* if iocharset not set then load_nls_default
1811                          * is used by caller
1812                          */
1813                          cifs_dbg(FYI, "iocharset set to %s\n", string);
1814                         break;
1815                 case Opt_netbiosname:
1816                         string = match_strdup(args);
1817                         if (string == NULL)
1818                                 goto out_nomem;
1819
1820                         memset(vol->source_rfc1001_name, 0x20,
1821                                 RFC1001_NAME_LEN);
1822                         /*
1823                          * FIXME: are there cases in which a comma can
1824                          * be valid in workstation netbios name (and
1825                          * need special handling)?
1826                          */
1827                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1828                                 /* don't ucase netbiosname for user */
1829                                 if (string[i] == 0)
1830                                         break;
1831                                 vol->source_rfc1001_name[i] = string[i];
1832                         }
1833                         /* The string has 16th byte zero still from
1834                          * set at top of the function
1835                          */
1836                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1837                                 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1838                         break;
1839                 case Opt_servern:
1840                         /* servernetbiosname specified override *SMBSERVER */
1841                         string = match_strdup(args);
1842                         if (string == NULL)
1843                                 goto out_nomem;
1844
1845                         /* last byte, type, is 0x20 for servr type */
1846                         memset(vol->target_rfc1001_name, 0x20,
1847                                 RFC1001_NAME_LEN_WITH_NULL);
1848
1849                         /* BB are there cases in which a comma can be
1850                            valid in this workstation netbios name
1851                            (and need special handling)? */
1852
1853                         /* user or mount helper must uppercase the
1854                            netbios name */
1855                         for (i = 0; i < 15; i++) {
1856                                 if (string[i] == 0)
1857                                         break;
1858                                 vol->target_rfc1001_name[i] = string[i];
1859                         }
1860                         /* The string has 16th byte zero still from
1861                            set at top of the function  */
1862                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1863                                 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1864                         break;
1865                 case Opt_ver:
1866                         string = match_strdup(args);
1867                         if (string == NULL)
1868                                 goto out_nomem;
1869
1870                         if (strncasecmp(string, "1", 1) == 0) {
1871                                 /* This is the default */
1872                                 break;
1873                         }
1874                         /* For all other value, error */
1875                         pr_warn("CIFS: Invalid version specified\n");
1876                         goto cifs_parse_mount_err;
1877                 case Opt_vers:
1878                         string = match_strdup(args);
1879                         if (string == NULL)
1880                                 goto out_nomem;
1881
1882                         if (cifs_parse_smb_version(string, vol) != 0)
1883                                 goto cifs_parse_mount_err;
1884                         break;
1885                 case Opt_sec:
1886                         string = match_strdup(args);
1887                         if (string == NULL)
1888                                 goto out_nomem;
1889
1890                         if (cifs_parse_security_flavors(string, vol) != 0)
1891                                 goto cifs_parse_mount_err;
1892                         break;
1893                 case Opt_cache:
1894                         string = match_strdup(args);
1895                         if (string == NULL)
1896                                 goto out_nomem;
1897
1898                         if (cifs_parse_cache_flavor(string, vol) != 0)
1899                                 goto cifs_parse_mount_err;
1900                         break;
1901                 default:
1902                         /*
1903                          * An option we don't recognize. Save it off for later
1904                          * if we haven't already found one
1905                          */
1906                         if (!invalid)
1907                                 invalid = data;
1908                         break;
1909                 }
1910                 /* Free up any allocated string */
1911                 kfree(string);
1912                 string = NULL;
1913         }
1914
1915         if (!sloppy && invalid) {
1916                 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1917                 goto cifs_parse_mount_err;
1918         }
1919
1920 #ifndef CONFIG_KEYS
1921         /* Muliuser mounts require CONFIG_KEYS support */
1922         if (vol->multiuser) {
1923                 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1924                 goto cifs_parse_mount_err;
1925         }
1926 #endif
1927         if (!vol->UNC) {
1928                 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1929                 goto cifs_parse_mount_err;
1930         }
1931
1932         /* make sure UNC has a share name */
1933         if (!strchr(vol->UNC + 3, '\\')) {
1934                 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1935                 goto cifs_parse_mount_err;
1936         }
1937
1938         if (!got_ip) {
1939                 /* No ip= option specified? Try to get it from UNC */
1940                 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1941                                                 strlen(&vol->UNC[2]))) {
1942                         pr_err("Unable to determine destination address.\n");
1943                         goto cifs_parse_mount_err;
1944                 }
1945         }
1946
1947         /* set the port that we got earlier */
1948         cifs_set_port(dstaddr, port);
1949
1950         if (uid_specified)
1951                 vol->override_uid = override_uid;
1952         else if (override_uid == 1)
1953                 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1954
1955         if (gid_specified)
1956                 vol->override_gid = override_gid;
1957         else if (override_gid == 1)
1958                 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1959
1960         kfree(mountdata_copy);
1961         return 0;
1962
1963 out_nomem:
1964         pr_warn("Could not allocate temporary buffer\n");
1965 cifs_parse_mount_err:
1966         kfree(string);
1967         kfree(mountdata_copy);
1968         return 1;
1969 }
1970
1971 /** Returns true if srcaddr isn't specified and rhs isn't
1972  * specified, or if srcaddr is specified and
1973  * matches the IP address of the rhs argument.
1974  */
1975 static bool
1976 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1977 {
1978         switch (srcaddr->sa_family) {
1979         case AF_UNSPEC:
1980                 return (rhs->sa_family == AF_UNSPEC);
1981         case AF_INET: {
1982                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1983                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1984                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1985         }
1986         case AF_INET6: {
1987                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1988                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1989                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1990         }
1991         default:
1992                 WARN_ON(1);
1993                 return false; /* don't expect to be here */
1994         }
1995 }
1996
1997 /*
1998  * If no port is specified in addr structure, we try to match with 445 port
1999  * and if it fails - with 139 ports. It should be called only if address
2000  * families of server and addr are equal.
2001  */
2002 static bool
2003 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2004 {
2005         __be16 port, *sport;
2006
2007         switch (addr->sa_family) {
2008         case AF_INET:
2009                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2010                 port = ((struct sockaddr_in *) addr)->sin_port;
2011                 break;
2012         case AF_INET6:
2013                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2014                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2015                 break;
2016         default:
2017                 WARN_ON(1);
2018                 return false;
2019         }
2020
2021         if (!port) {
2022                 port = htons(CIFS_PORT);
2023                 if (port == *sport)
2024                         return true;
2025
2026                 port = htons(RFC1001_PORT);
2027         }
2028
2029         return port == *sport;
2030 }
2031
2032 static bool
2033 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2034               struct sockaddr *srcaddr)
2035 {
2036         switch (addr->sa_family) {
2037         case AF_INET: {
2038                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2039                 struct sockaddr_in *srv_addr4 =
2040                                         (struct sockaddr_in *)&server->dstaddr;
2041
2042                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2043                         return false;
2044                 break;
2045         }
2046         case AF_INET6: {
2047                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2048                 struct sockaddr_in6 *srv_addr6 =
2049                                         (struct sockaddr_in6 *)&server->dstaddr;
2050
2051                 if (!ipv6_addr_equal(&addr6->sin6_addr,
2052                                      &srv_addr6->sin6_addr))
2053                         return false;
2054                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2055                         return false;
2056                 break;
2057         }
2058         default:
2059                 WARN_ON(1);
2060                 return false; /* don't expect to be here */
2061         }
2062
2063         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2064                 return false;
2065
2066         return true;
2067 }
2068
2069 static bool
2070 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2071 {
2072         /*
2073          * The select_sectype function should either return the vol->sectype
2074          * that was specified, or "Unspecified" if that sectype was not
2075          * compatible with the given NEGOTIATE request.
2076          */
2077         if (server->ops->select_sectype(server, vol->sectype)
2078              == Unspecified)
2079                 return false;
2080
2081         /*
2082          * Now check if signing mode is acceptable. No need to check
2083          * global_secflags at this point since if MUST_SIGN is set then
2084          * the server->sign had better be too.
2085          */
2086         if (vol->sign && !server->sign)
2087                 return false;
2088
2089         return true;
2090 }
2091
2092 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2093 {
2094         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2095
2096         if (vol->nosharesock)
2097                 return 0;
2098
2099         if ((server->vals != vol->vals) || (server->ops != vol->ops))
2100                 return 0;
2101
2102         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2103                 return 0;
2104
2105         if (!match_address(server, addr,
2106                            (struct sockaddr *)&vol->srcaddr))
2107                 return 0;
2108
2109         if (!match_port(server, addr))
2110                 return 0;
2111
2112         if (!match_security(server, vol))
2113                 return 0;
2114
2115         if (server->echo_interval != vol->echo_interval * HZ)
2116                 return 0;
2117
2118         return 1;
2119 }
2120
2121 static struct TCP_Server_Info *
2122 cifs_find_tcp_session(struct smb_vol *vol)
2123 {
2124         struct TCP_Server_Info *server;
2125
2126         spin_lock(&cifs_tcp_ses_lock);
2127         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2128                 if (!match_server(server, vol))
2129                         continue;
2130
2131                 ++server->srv_count;
2132                 spin_unlock(&cifs_tcp_ses_lock);
2133                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2134                 return server;
2135         }
2136         spin_unlock(&cifs_tcp_ses_lock);
2137         return NULL;
2138 }
2139
2140 void
2141 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2142 {
2143         struct task_struct *task;
2144
2145         spin_lock(&cifs_tcp_ses_lock);
2146         if (--server->srv_count > 0) {
2147                 spin_unlock(&cifs_tcp_ses_lock);
2148                 return;
2149         }
2150
2151         put_net(cifs_net_ns(server));
2152
2153         list_del_init(&server->tcp_ses_list);
2154         spin_unlock(&cifs_tcp_ses_lock);
2155
2156         cancel_delayed_work_sync(&server->echo);
2157
2158 #ifdef CONFIG_CIFS_SMB2
2159         if (from_reconnect)
2160                 /*
2161                  * Avoid deadlock here: reconnect work calls
2162                  * cifs_put_tcp_session() at its end. Need to be sure
2163                  * that reconnect work does nothing with server pointer after
2164                  * that step.
2165                  */
2166                 cancel_delayed_work(&server->reconnect);
2167         else
2168                 cancel_delayed_work_sync(&server->reconnect);
2169 #endif
2170
2171         spin_lock(&GlobalMid_Lock);
2172         server->tcpStatus = CifsExiting;
2173         spin_unlock(&GlobalMid_Lock);
2174
2175         cifs_crypto_secmech_release(server);
2176         cifs_fscache_release_client_cookie(server);
2177
2178         kfree(server->session_key.response);
2179         server->session_key.response = NULL;
2180         server->session_key.len = 0;
2181
2182         task = xchg(&server->tsk, NULL);
2183         if (task)
2184                 force_sig(SIGKILL, task);
2185 }
2186
2187 static struct TCP_Server_Info *
2188 cifs_get_tcp_session(struct smb_vol *volume_info)
2189 {
2190         struct TCP_Server_Info *tcp_ses = NULL;
2191         int rc;
2192
2193         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2194
2195         /* see if we already have a matching tcp_ses */
2196         tcp_ses = cifs_find_tcp_session(volume_info);
2197         if (tcp_ses)
2198                 return tcp_ses;
2199
2200         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2201         if (!tcp_ses) {
2202                 rc = -ENOMEM;
2203                 goto out_err;
2204         }
2205
2206         tcp_ses->ops = volume_info->ops;
2207         tcp_ses->vals = volume_info->vals;
2208         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2209         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2210         if (IS_ERR(tcp_ses->hostname)) {
2211                 rc = PTR_ERR(tcp_ses->hostname);
2212                 goto out_err_crypto_release;
2213         }
2214
2215         tcp_ses->noblocksnd = volume_info->noblocksnd;
2216         tcp_ses->noautotune = volume_info->noautotune;
2217         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2218         tcp_ses->in_flight = 0;
2219         tcp_ses->credits = 1;
2220         init_waitqueue_head(&tcp_ses->response_q);
2221         init_waitqueue_head(&tcp_ses->request_q);
2222         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2223         mutex_init(&tcp_ses->srv_mutex);
2224         memcpy(tcp_ses->workstation_RFC1001_name,
2225                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2226         memcpy(tcp_ses->server_RFC1001_name,
2227                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2228         tcp_ses->session_estab = false;
2229         tcp_ses->sequence_number = 0;
2230         tcp_ses->lstrp = jiffies;
2231         spin_lock_init(&tcp_ses->req_lock);
2232         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2233         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2234         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2235 #ifdef CONFIG_CIFS_SMB2
2236         INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2237         mutex_init(&tcp_ses->reconnect_mutex);
2238 #endif
2239         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2240                sizeof(tcp_ses->srcaddr));
2241         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2242                 sizeof(tcp_ses->dstaddr));
2243 #ifdef CONFIG_CIFS_SMB2
2244         generate_random_uuid(tcp_ses->client_guid);
2245 #endif
2246         /*
2247          * at this point we are the only ones with the pointer
2248          * to the struct since the kernel thread not created yet
2249          * no need to spinlock this init of tcpStatus or srv_count
2250          */
2251         tcp_ses->tcpStatus = CifsNew;
2252         ++tcp_ses->srv_count;
2253
2254         if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2255                 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2256                 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2257         else
2258                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2259
2260         rc = ip_connect(tcp_ses);
2261         if (rc < 0) {
2262                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2263                 goto out_err_crypto_release;
2264         }
2265
2266         /*
2267          * since we're in a cifs function already, we know that
2268          * this will succeed. No need for try_module_get().
2269          */
2270         __module_get(THIS_MODULE);
2271         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2272                                   tcp_ses, "cifsd");
2273         if (IS_ERR(tcp_ses->tsk)) {
2274                 rc = PTR_ERR(tcp_ses->tsk);
2275                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2276                 module_put(THIS_MODULE);
2277                 goto out_err_crypto_release;
2278         }
2279         tcp_ses->tcpStatus = CifsNeedNegotiate;
2280
2281         /* thread spawned, put it on the list */
2282         spin_lock(&cifs_tcp_ses_lock);
2283         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2284         spin_unlock(&cifs_tcp_ses_lock);
2285
2286         cifs_fscache_get_client_cookie(tcp_ses);
2287
2288         /* queue echo request delayed work */
2289         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2290
2291         return tcp_ses;
2292
2293 out_err_crypto_release:
2294         cifs_crypto_secmech_release(tcp_ses);
2295
2296         put_net(cifs_net_ns(tcp_ses));
2297
2298 out_err:
2299         if (tcp_ses) {
2300                 if (!IS_ERR(tcp_ses->hostname))
2301                         kfree(tcp_ses->hostname);
2302                 if (tcp_ses->ssocket)
2303                         sock_release(tcp_ses->ssocket);
2304                 kfree(tcp_ses);
2305         }
2306         return ERR_PTR(rc);
2307 }
2308
2309 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2310 {
2311         if (vol->sectype != Unspecified &&
2312             vol->sectype != ses->sectype)
2313                 return 0;
2314
2315         switch (ses->sectype) {
2316         case Kerberos:
2317                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2318                         return 0;
2319                 break;
2320         default:
2321                 /* NULL username means anonymous session */
2322                 if (ses->user_name == NULL) {
2323                         if (!vol->nullauth)
2324                                 return 0;
2325                         break;
2326                 }
2327
2328                 /* anything else takes username/password */
2329                 if (strncmp(ses->user_name,
2330                             vol->username ? vol->username : "",
2331                             CIFS_MAX_USERNAME_LEN))
2332                         return 0;
2333                 if ((vol->username && strlen(vol->username) != 0) &&
2334                     ses->password != NULL &&
2335                     strncmp(ses->password,
2336                             vol->password ? vol->password : "",
2337                             CIFS_MAX_PASSWORD_LEN))
2338                         return 0;
2339         }
2340         return 1;
2341 }
2342
2343 static struct cifs_ses *
2344 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2345 {
2346         struct cifs_ses *ses;
2347
2348         spin_lock(&cifs_tcp_ses_lock);
2349         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2350                 if (ses->status == CifsExiting)
2351                         continue;
2352                 if (!match_session(ses, vol))
2353                         continue;
2354                 ++ses->ses_count;
2355                 spin_unlock(&cifs_tcp_ses_lock);
2356                 return ses;
2357         }
2358         spin_unlock(&cifs_tcp_ses_lock);
2359         return NULL;
2360 }
2361
2362 static void
2363 cifs_put_smb_ses(struct cifs_ses *ses)
2364 {
2365         unsigned int rc, xid;
2366         struct TCP_Server_Info *server = ses->server;
2367
2368         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2369
2370         spin_lock(&cifs_tcp_ses_lock);
2371         if (ses->status == CifsExiting) {
2372                 spin_unlock(&cifs_tcp_ses_lock);
2373                 return;
2374         }
2375         if (--ses->ses_count > 0) {
2376                 spin_unlock(&cifs_tcp_ses_lock);
2377                 return;
2378         }
2379         if (ses->status == CifsGood)
2380                 ses->status = CifsExiting;
2381         spin_unlock(&cifs_tcp_ses_lock);
2382
2383         if (ses->status == CifsExiting && server->ops->logoff) {
2384                 xid = get_xid();
2385                 rc = server->ops->logoff(xid, ses);
2386                 if (rc)
2387                         cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2388                                 __func__, rc);
2389                 _free_xid(xid);
2390         }
2391
2392         spin_lock(&cifs_tcp_ses_lock);
2393         list_del_init(&ses->smb_ses_list);
2394         spin_unlock(&cifs_tcp_ses_lock);
2395
2396         sesInfoFree(ses);
2397         cifs_put_tcp_session(server, 0);
2398 }
2399
2400 #ifdef CONFIG_KEYS
2401
2402 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2403 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2404
2405 /* Populate username and pw fields from keyring if possible */
2406 static int
2407 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2408 {
2409         int rc = 0;
2410         const char *delim, *payload;
2411         char *desc;
2412         ssize_t len;
2413         struct key *key;
2414         struct TCP_Server_Info *server = ses->server;
2415         struct sockaddr_in *sa;
2416         struct sockaddr_in6 *sa6;
2417         const struct user_key_payload *upayload;
2418
2419         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2420         if (!desc)
2421                 return -ENOMEM;
2422
2423         /* try to find an address key first */
2424         switch (server->dstaddr.ss_family) {
2425         case AF_INET:
2426                 sa = (struct sockaddr_in *)&server->dstaddr;
2427                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2428                 break;
2429         case AF_INET6:
2430                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2431                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2432                 break;
2433         default:
2434                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2435                          server->dstaddr.ss_family);
2436                 rc = -EINVAL;
2437                 goto out_err;
2438         }
2439
2440         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2441         key = request_key(&key_type_logon, desc, "");
2442         if (IS_ERR(key)) {
2443                 if (!ses->domainName) {
2444                         cifs_dbg(FYI, "domainName is NULL\n");
2445                         rc = PTR_ERR(key);
2446                         goto out_err;
2447                 }
2448
2449                 /* didn't work, try to find a domain key */
2450                 sprintf(desc, "cifs:d:%s", ses->domainName);
2451                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2452                 key = request_key(&key_type_logon, desc, "");
2453                 if (IS_ERR(key)) {
2454                         rc = PTR_ERR(key);
2455                         goto out_err;
2456                 }
2457         }
2458
2459         down_read(&key->sem);
2460         upayload = user_key_payload_locked(key);
2461         if (IS_ERR_OR_NULL(upayload)) {
2462                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2463                 goto out_key_put;
2464         }
2465
2466         /* find first : in payload */
2467         payload = upayload->data;
2468         delim = strnchr(payload, upayload->datalen, ':');
2469         cifs_dbg(FYI, "payload=%s\n", payload);
2470         if (!delim) {
2471                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2472                          upayload->datalen);
2473                 rc = -EINVAL;
2474                 goto out_key_put;
2475         }
2476
2477         len = delim - payload;
2478         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2479                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2480                          len);
2481                 rc = -EINVAL;
2482                 goto out_key_put;
2483         }
2484
2485         vol->username = kstrndup(payload, len, GFP_KERNEL);
2486         if (!vol->username) {
2487                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2488                          len);
2489                 rc = -ENOMEM;
2490                 goto out_key_put;
2491         }
2492         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2493
2494         len = key->datalen - (len + 1);
2495         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2496                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2497                 rc = -EINVAL;
2498                 kfree(vol->username);
2499                 vol->username = NULL;
2500                 goto out_key_put;
2501         }
2502
2503         ++delim;
2504         vol->password = kstrndup(delim, len, GFP_KERNEL);
2505         if (!vol->password) {
2506                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2507                          len);
2508                 rc = -ENOMEM;
2509                 kfree(vol->username);
2510                 vol->username = NULL;
2511                 goto out_key_put;
2512         }
2513
2514 out_key_put:
2515         up_read(&key->sem);
2516         key_put(key);
2517 out_err:
2518         kfree(desc);
2519         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2520         return rc;
2521 }
2522 #else /* ! CONFIG_KEYS */
2523 static inline int
2524 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2525                    struct cifs_ses *ses __attribute__((unused)))
2526 {
2527         return -ENOSYS;
2528 }
2529 #endif /* CONFIG_KEYS */
2530
2531 static struct cifs_ses *
2532 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2533 {
2534         int rc = -ENOMEM;
2535         unsigned int xid;
2536         struct cifs_ses *ses;
2537         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2538         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2539
2540         xid = get_xid();
2541
2542         ses = cifs_find_smb_ses(server, volume_info);
2543         if (ses) {
2544                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2545                          ses->status);
2546
2547                 mutex_lock(&ses->session_mutex);
2548                 rc = cifs_negotiate_protocol(xid, ses);
2549                 if (rc) {
2550                         mutex_unlock(&ses->session_mutex);
2551                         /* problem -- put our ses reference */
2552                         cifs_put_smb_ses(ses);
2553                         free_xid(xid);
2554                         return ERR_PTR(rc);
2555                 }
2556                 if (ses->need_reconnect) {
2557                         cifs_dbg(FYI, "Session needs reconnect\n");
2558                         rc = cifs_setup_session(xid, ses,
2559                                                 volume_info->local_nls);
2560                         if (rc) {
2561                                 mutex_unlock(&ses->session_mutex);
2562                                 /* problem -- put our reference */
2563                                 cifs_put_smb_ses(ses);
2564                                 free_xid(xid);
2565                                 return ERR_PTR(rc);
2566                         }
2567                 }
2568                 mutex_unlock(&ses->session_mutex);
2569
2570                 /* existing SMB ses has a server reference already */
2571                 cifs_put_tcp_session(server, 0);
2572                 free_xid(xid);
2573                 return ses;
2574         }
2575
2576         cifs_dbg(FYI, "Existing smb sess not found\n");
2577         ses = sesInfoAlloc();
2578         if (ses == NULL)
2579                 goto get_ses_fail;
2580
2581         /* new SMB session uses our server ref */
2582         ses->server = server;
2583         if (server->dstaddr.ss_family == AF_INET6)
2584                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2585         else
2586                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2587
2588         if (volume_info->username) {
2589                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2590                 if (!ses->user_name)
2591                         goto get_ses_fail;
2592         }
2593
2594         /* volume_info->password freed at unmount */
2595         if (volume_info->password) {
2596                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2597                 if (!ses->password)
2598                         goto get_ses_fail;
2599         }
2600         if (volume_info->domainname) {
2601                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2602                 if (!ses->domainName)
2603                         goto get_ses_fail;
2604         }
2605         if (volume_info->domainauto)
2606                 ses->domainAuto = volume_info->domainauto;
2607         ses->cred_uid = volume_info->cred_uid;
2608         ses->linux_uid = volume_info->linux_uid;
2609
2610         ses->sectype = volume_info->sectype;
2611         ses->sign = volume_info->sign;
2612
2613         mutex_lock(&ses->session_mutex);
2614         rc = cifs_negotiate_protocol(xid, ses);
2615         if (!rc)
2616                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2617         mutex_unlock(&ses->session_mutex);
2618         if (rc)
2619                 goto get_ses_fail;
2620
2621         /* success, put it on the list */
2622         spin_lock(&cifs_tcp_ses_lock);
2623         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2624         spin_unlock(&cifs_tcp_ses_lock);
2625
2626         free_xid(xid);
2627         return ses;
2628
2629 get_ses_fail:
2630         sesInfoFree(ses);
2631         free_xid(xid);
2632         return ERR_PTR(rc);
2633 }
2634
2635 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
2636 {
2637         if (tcon->tidStatus == CifsExiting)
2638                 return 0;
2639         if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
2640                 return 0;
2641         if (tcon->seal != volume_info->seal)
2642                 return 0;
2643 #ifdef CONFIG_CIFS_SMB2
2644         if (tcon->snapshot_time != volume_info->snapshot_time)
2645                 return 0;
2646 #endif /* CONFIG_CIFS_SMB2 */
2647         return 1;
2648 }
2649
2650 static struct cifs_tcon *
2651 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2652 {
2653         struct list_head *tmp;
2654         struct cifs_tcon *tcon;
2655
2656         spin_lock(&cifs_tcp_ses_lock);
2657         list_for_each(tmp, &ses->tcon_list) {
2658                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2659                 if (!match_tcon(tcon, volume_info))
2660                         continue;
2661                 ++tcon->tc_count;
2662                 spin_unlock(&cifs_tcp_ses_lock);
2663                 return tcon;
2664         }
2665         spin_unlock(&cifs_tcp_ses_lock);
2666         return NULL;
2667 }
2668
2669 void
2670 cifs_put_tcon(struct cifs_tcon *tcon)
2671 {
2672         unsigned int xid;
2673         struct cifs_ses *ses = tcon->ses;
2674
2675         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2676         spin_lock(&cifs_tcp_ses_lock);
2677         if (--tcon->tc_count > 0) {
2678                 spin_unlock(&cifs_tcp_ses_lock);
2679                 return;
2680         }
2681
2682         list_del_init(&tcon->tcon_list);
2683         spin_unlock(&cifs_tcp_ses_lock);
2684
2685         xid = get_xid();
2686         if (ses->server->ops->tree_disconnect)
2687                 ses->server->ops->tree_disconnect(xid, tcon);
2688         _free_xid(xid);
2689
2690         cifs_fscache_release_super_cookie(tcon);
2691         tconInfoFree(tcon);
2692         cifs_put_smb_ses(ses);
2693 }
2694
2695 static struct cifs_tcon *
2696 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2697 {
2698         int rc, xid;
2699         struct cifs_tcon *tcon;
2700
2701         tcon = cifs_find_tcon(ses, volume_info);
2702         if (tcon) {
2703                 cifs_dbg(FYI, "Found match on UNC path\n");
2704                 /* existing tcon already has a reference */
2705                 cifs_put_smb_ses(ses);
2706                 return tcon;
2707         }
2708
2709         if (!ses->server->ops->tree_connect) {
2710                 rc = -ENOSYS;
2711                 goto out_fail;
2712         }
2713
2714         tcon = tconInfoAlloc();
2715         if (tcon == NULL) {
2716                 rc = -ENOMEM;
2717                 goto out_fail;
2718         }
2719
2720         if (volume_info->snapshot_time) {
2721 #ifdef CONFIG_CIFS_SMB2
2722                 if (ses->server->vals->protocol_id == 0) {
2723                         cifs_dbg(VFS,
2724                              "Use SMB2 or later for snapshot mount option\n");
2725                         rc = -EOPNOTSUPP;
2726                         goto out_fail;
2727                 } else
2728                         tcon->snapshot_time = volume_info->snapshot_time;
2729 #else
2730                 cifs_dbg(VFS, "Snapshot mount option requires SMB2 support\n");
2731                 rc = -EOPNOTSUPP;
2732                 goto out_fail;
2733 #endif /* CONFIG_CIFS_SMB2 */
2734         }
2735
2736         tcon->ses = ses;
2737         if (volume_info->password) {
2738                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2739                 if (!tcon->password) {
2740                         rc = -ENOMEM;
2741                         goto out_fail;
2742                 }
2743         }
2744
2745         /*
2746          * BB Do we need to wrap session_mutex around this TCon call and Unix
2747          * SetFS as we do on SessSetup and reconnect?
2748          */
2749         xid = get_xid();
2750         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2751                                             volume_info->local_nls);
2752         free_xid(xid);
2753         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2754         if (rc)
2755                 goto out_fail;
2756
2757         if (volume_info->nodfs) {
2758                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2759                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2760         }
2761         tcon->use_persistent = false;
2762         /* check if SMB2 or later, CIFS does not support persistent handles */
2763         if (volume_info->persistent) {
2764                 if (ses->server->vals->protocol_id == 0) {
2765                         cifs_dbg(VFS,
2766                              "SMB3 or later required for persistent handles\n");
2767                         rc = -EOPNOTSUPP;
2768                         goto out_fail;
2769 #ifdef CONFIG_CIFS_SMB2
2770                 } else if (ses->server->capabilities &
2771                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2772                         tcon->use_persistent = true;
2773                 else /* persistent handles requested but not supported */ {
2774                         cifs_dbg(VFS,
2775                                 "Persistent handles not supported on share\n");
2776                         rc = -EOPNOTSUPP;
2777                         goto out_fail;
2778 #endif /* CONFIG_CIFS_SMB2 */
2779                 }
2780 #ifdef CONFIG_CIFS_SMB2
2781         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2782              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2783              && (volume_info->nopersistent == false)) {
2784                 cifs_dbg(FYI, "enabling persistent handles\n");
2785                 tcon->use_persistent = true;
2786 #endif /* CONFIG_CIFS_SMB2 */
2787         } else if (volume_info->resilient) {
2788                 if (ses->server->vals->protocol_id == 0) {
2789                         cifs_dbg(VFS,
2790                              "SMB2.1 or later required for resilient handles\n");
2791                         rc = -EOPNOTSUPP;
2792                         goto out_fail;
2793                 }
2794                 tcon->use_resilient = true;
2795         }
2796
2797         if (volume_info->seal) {
2798                 if (ses->server->vals->protocol_id == 0) {
2799                         cifs_dbg(VFS,
2800                                  "SMB3 or later required for encryption\n");
2801                         rc = -EOPNOTSUPP;
2802                         goto out_fail;
2803 #ifdef CONFIG_CIFS_SMB2
2804                 } else if (tcon->ses->server->capabilities &
2805                                         SMB2_GLOBAL_CAP_ENCRYPTION)
2806                         tcon->seal = true;
2807                 else {
2808                         cifs_dbg(VFS, "Encryption is not supported on share\n");
2809                         rc = -EOPNOTSUPP;
2810                         goto out_fail;
2811 #endif /* CONFIG_CIFS_SMB2 */
2812                 }
2813         }
2814
2815         /*
2816          * We can have only one retry value for a connection to a share so for
2817          * resources mounted more than once to the same server share the last
2818          * value passed in for the retry flag is used.
2819          */
2820         tcon->retry = volume_info->retry;
2821         tcon->nocase = volume_info->nocase;
2822         tcon->local_lease = volume_info->local_lease;
2823         INIT_LIST_HEAD(&tcon->pending_opens);
2824
2825         spin_lock(&cifs_tcp_ses_lock);
2826         list_add(&tcon->tcon_list, &ses->tcon_list);
2827         spin_unlock(&cifs_tcp_ses_lock);
2828
2829         cifs_fscache_get_super_cookie(tcon);
2830
2831         return tcon;
2832
2833 out_fail:
2834         tconInfoFree(tcon);
2835         return ERR_PTR(rc);
2836 }
2837
2838 void
2839 cifs_put_tlink(struct tcon_link *tlink)
2840 {
2841         if (!tlink || IS_ERR(tlink))
2842                 return;
2843
2844         if (!atomic_dec_and_test(&tlink->tl_count) ||
2845             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2846                 tlink->tl_time = jiffies;
2847                 return;
2848         }
2849
2850         if (!IS_ERR(tlink_tcon(tlink)))
2851                 cifs_put_tcon(tlink_tcon(tlink));
2852         kfree(tlink);
2853         return;
2854 }
2855
2856 static inline struct tcon_link *
2857 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2858 {
2859         return cifs_sb->master_tlink;
2860 }
2861
2862 static int
2863 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2864 {
2865         struct cifs_sb_info *old = CIFS_SB(sb);
2866         struct cifs_sb_info *new = mnt_data->cifs_sb;
2867
2868         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2869                 return 0;
2870
2871         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2872             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2873                 return 0;
2874
2875         /*
2876          * We want to share sb only if we don't specify an r/wsize or
2877          * specified r/wsize is greater than or equal to existing one.
2878          */
2879         if (new->wsize && new->wsize < old->wsize)
2880                 return 0;
2881
2882         if (new->rsize && new->rsize < old->rsize)
2883                 return 0;
2884
2885         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2886                 return 0;
2887
2888         if (old->mnt_file_mode != new->mnt_file_mode ||
2889             old->mnt_dir_mode != new->mnt_dir_mode)
2890                 return 0;
2891
2892         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2893                 return 0;
2894
2895         if (old->actimeo != new->actimeo)
2896                 return 0;
2897
2898         return 1;
2899 }
2900
2901 static int
2902 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2903 {
2904         struct cifs_sb_info *old = CIFS_SB(sb);
2905         struct cifs_sb_info *new = mnt_data->cifs_sb;
2906
2907         if (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) {
2908                 if (!(new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH))
2909                         return 0;
2910                 /* The prepath should be null terminated strings */
2911                 if (strcmp(new->prepath, old->prepath))
2912                         return 0;
2913
2914                 return 1;
2915         }
2916         return 0;
2917 }
2918
2919 int
2920 cifs_match_super(struct super_block *sb, void *data)
2921 {
2922         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2923         struct smb_vol *volume_info;
2924         struct cifs_sb_info *cifs_sb;
2925         struct TCP_Server_Info *tcp_srv;
2926         struct cifs_ses *ses;
2927         struct cifs_tcon *tcon;
2928         struct tcon_link *tlink;
2929         int rc = 0;
2930
2931         spin_lock(&cifs_tcp_ses_lock);
2932         cifs_sb = CIFS_SB(sb);
2933         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2934         if (IS_ERR(tlink)) {
2935                 spin_unlock(&cifs_tcp_ses_lock);
2936                 return rc;
2937         }
2938         tcon = tlink_tcon(tlink);
2939         ses = tcon->ses;
2940         tcp_srv = ses->server;
2941
2942         volume_info = mnt_data->vol;
2943
2944         if (!match_server(tcp_srv, volume_info) ||
2945             !match_session(ses, volume_info) ||
2946             !match_tcon(tcon, volume_info) ||
2947             !match_prepath(sb, mnt_data)) {
2948                 rc = 0;
2949                 goto out;
2950         }
2951
2952         rc = compare_mount_options(sb, mnt_data);
2953 out:
2954         spin_unlock(&cifs_tcp_ses_lock);
2955         cifs_put_tlink(tlink);
2956         return rc;
2957 }
2958
2959 int
2960 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2961              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2962              struct dfs_info3_param **referrals, int remap)
2963 {
2964         char *temp_unc;
2965         int rc = 0;
2966
2967         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2968                 return -ENOSYS;
2969
2970         *num_referrals = 0;
2971         *referrals = NULL;
2972
2973         if (ses->ipc_tid == 0) {
2974                 temp_unc = kmalloc(2 /* for slashes */ +
2975                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2976                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2977                 if (temp_unc == NULL)
2978                         return -ENOMEM;
2979                 temp_unc[0] = '\\';
2980                 temp_unc[1] = '\\';
2981                 strcpy(temp_unc + 2, ses->serverName);
2982                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2983                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2984                                                     nls_codepage);
2985                 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2986                 kfree(temp_unc);
2987         }
2988         if (rc == 0)
2989                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2990                                                      referrals, num_referrals,
2991                                                      nls_codepage, remap);
2992         /*
2993          * BB - map targetUNCs to dfs_info3 structures, here or in
2994          * ses->server->ops->get_dfs_refer.
2995          */
2996
2997         return rc;
2998 }
2999
3000 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3001 static struct lock_class_key cifs_key[2];
3002 static struct lock_class_key cifs_slock_key[2];
3003
3004 static inline void
3005 cifs_reclassify_socket4(struct socket *sock)
3006 {
3007         struct sock *sk = sock->sk;
3008         BUG_ON(!sock_allow_reclassification(sk));
3009         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3010                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3011 }
3012
3013 static inline void
3014 cifs_reclassify_socket6(struct socket *sock)
3015 {
3016         struct sock *sk = sock->sk;
3017         BUG_ON(!sock_allow_reclassification(sk));
3018         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3019                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3020 }
3021 #else
3022 static inline void
3023 cifs_reclassify_socket4(struct socket *sock)
3024 {
3025 }
3026
3027 static inline void
3028 cifs_reclassify_socket6(struct socket *sock)
3029 {
3030 }
3031 #endif
3032
3033 /* See RFC1001 section 14 on representation of Netbios names */
3034 static void rfc1002mangle(char *target, char *source, unsigned int length)
3035 {
3036         unsigned int i, j;
3037
3038         for (i = 0, j = 0; i < (length); i++) {
3039                 /* mask a nibble at a time and encode */
3040                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3041                 target[j+1] = 'A' + (0x0F & source[i]);
3042                 j += 2;
3043         }
3044
3045 }
3046
3047 static int
3048 bind_socket(struct TCP_Server_Info *server)
3049 {
3050         int rc = 0;
3051         if (server->srcaddr.ss_family != AF_UNSPEC) {
3052                 /* Bind to the specified local IP address */
3053                 struct socket *socket = server->ssocket;
3054                 rc = socket->ops->bind(socket,
3055                                        (struct sockaddr *) &server->srcaddr,
3056                                        sizeof(server->srcaddr));
3057                 if (rc < 0) {
3058                         struct sockaddr_in *saddr4;
3059                         struct sockaddr_in6 *saddr6;
3060                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3061                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3062                         if (saddr6->sin6_family == AF_INET6)
3063                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3064                                          &saddr6->sin6_addr, rc);
3065                         else
3066                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3067                                          &saddr4->sin_addr.s_addr, rc);
3068                 }
3069         }
3070         return rc;
3071 }
3072
3073 static int
3074 ip_rfc1001_connect(struct TCP_Server_Info *server)
3075 {
3076         int rc = 0;
3077         /*
3078          * some servers require RFC1001 sessinit before sending
3079          * negprot - BB check reconnection in case where second
3080          * sessinit is sent but no second negprot
3081          */
3082         struct rfc1002_session_packet *ses_init_buf;
3083         struct smb_hdr *smb_buf;
3084         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3085                                GFP_KERNEL);
3086         if (ses_init_buf) {
3087                 ses_init_buf->trailer.session_req.called_len = 32;
3088
3089                 if (server->server_RFC1001_name[0] != 0)
3090                         rfc1002mangle(ses_init_buf->trailer.
3091                                       session_req.called_name,
3092                                       server->server_RFC1001_name,
3093                                       RFC1001_NAME_LEN_WITH_NULL);
3094                 else
3095                         rfc1002mangle(ses_init_buf->trailer.
3096                                       session_req.called_name,
3097                                       DEFAULT_CIFS_CALLED_NAME,
3098                                       RFC1001_NAME_LEN_WITH_NULL);
3099
3100                 ses_init_buf->trailer.session_req.calling_len = 32;
3101
3102                 /*
3103                  * calling name ends in null (byte 16) from old smb
3104                  * convention.
3105                  */
3106                 if (server->workstation_RFC1001_name[0] != 0)
3107                         rfc1002mangle(ses_init_buf->trailer.
3108                                       session_req.calling_name,
3109                                       server->workstation_RFC1001_name,
3110                                       RFC1001_NAME_LEN_WITH_NULL);
3111                 else
3112                         rfc1002mangle(ses_init_buf->trailer.
3113                                       session_req.calling_name,
3114                                       "LINUX_CIFS_CLNT",
3115                                       RFC1001_NAME_LEN_WITH_NULL);
3116
3117                 ses_init_buf->trailer.session_req.scope1 = 0;
3118                 ses_init_buf->trailer.session_req.scope2 = 0;
3119                 smb_buf = (struct smb_hdr *)ses_init_buf;
3120
3121                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3122                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3123                 rc = smb_send(server, smb_buf, 0x44);
3124                 kfree(ses_init_buf);
3125                 /*
3126                  * RFC1001 layer in at least one server
3127                  * requires very short break before negprot
3128                  * presumably because not expecting negprot
3129                  * to follow so fast.  This is a simple
3130                  * solution that works without
3131                  * complicating the code and causes no
3132                  * significant slowing down on mount
3133                  * for everyone else
3134                  */
3135                 usleep_range(1000, 2000);
3136         }
3137         /*
3138          * else the negprot may still work without this
3139          * even though malloc failed
3140          */
3141
3142         return rc;
3143 }
3144
3145 static int
3146 generic_ip_connect(struct TCP_Server_Info *server)
3147 {
3148         int rc = 0;
3149         __be16 sport;