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