fs/cifs/connect.c

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