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