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