Pileus Git - ~andy/linux/blob - fs/cifs/connect.c

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