fs/cifs/connect.c

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