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