fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2009
   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 <net/ipv6.h>
  41 #include "cifspdu.h"
  42 #include "cifsglob.h"
  43 #include "cifsproto.h"
  44 #include "cifs_unicode.h"
  45 #include "cifs_debug.h"
  46 #include "cifs_fs_sb.h"
  47 #include "ntlmssp.h"
  48 #include "nterr.h"
  49 #include "rfc1002pdu.h"
  50 #include "fscache.h"
  51
  52 #define CIFS_PORT 445
  53 #define RFC1001_PORT 139
  54
  55 /* SMB echo "timeout" -- FIXME: tunable? */
  56 #define SMB_ECHO_INTERVAL (60 * HZ)
  57
  58 extern mempool_t *cifs_req_poolp;
  59
  60 struct smb_vol {
  61         char *username;
  62         char *password;
  63         char *domainname;
  64         char *UNC;
  65         char *UNCip;
  66         char *iocharset;  /* local code page for mapping to and from Unicode */
  67         char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
  68         char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
  69         uid_t cred_uid;
  70         uid_t linux_uid;
  71         gid_t linux_gid;
  72         mode_t file_mode;
  73         mode_t dir_mode;
  74         unsigned secFlg;
  75         bool retry:1;
  76         bool intr:1;
  77         bool setuids:1;
  78         bool override_uid:1;
  79         bool override_gid:1;
  80         bool dynperm:1;
  81         bool noperm:1;
  82         bool no_psx_acl:1; /* set if posix acl support should be disabled */
  83         bool cifs_acl:1;
  84         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
  85         bool server_ino:1; /* use inode numbers from server ie UniqueId */
  86         bool direct_io:1;
  87         bool strict_io:1; /* strict cache behavior */
  88         bool remap:1;      /* set to remap seven reserved chars in filenames */
  89         bool posix_paths:1; /* unset to not ask for posix pathnames. */
  90         bool no_linux_ext:1;
  91         bool sfu_emul:1;
  92         bool nullauth:1;   /* attempt to authenticate with null user */
  93         bool nocase:1;     /* request case insensitive filenames */
  94         bool nobrl:1;      /* disable sending byte range locks to srv */
  95         bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
  96         bool seal:1;       /* request transport encryption on share */
  97         bool nodfs:1;      /* Do not request DFS, even if available */
  98         bool local_lease:1; /* check leases only on local system, not remote */
  99         bool noblocksnd:1;
 100         bool noautotune:1;
 101         bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
 102         bool fsc:1;     /* enable fscache */
 103         bool mfsymlinks:1; /* use Minshall+French Symlinks */
 104         bool multiuser:1;
 105         unsigned int rsize;
 106         unsigned int wsize;
 107         bool sockopt_tcp_nodelay:1;
 108         unsigned short int port;
 109         unsigned long actimeo; /* attribute cache timeout (jiffies) */
 110         char *prepath;
 111         struct sockaddr_storage srcaddr; /* allow binding to a local IP */
 112         struct nls_table *local_nls;
 113 };
 114
 115 /* FIXME: should these be tunable? */
 116 #define TLINK_ERROR_EXPIRE      (1 * HZ)
 117 #define TLINK_IDLE_EXPIRE       (600 * HZ)
 118
 119 static int ip_connect(struct TCP_Server_Info *server);
 120 static int generic_ip_connect(struct TCP_Server_Info *server);
 121 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 122 static void cifs_prune_tlinks(struct work_struct *work);
 123
 124 /*
 125  * cifs tcp session reconnection
 126  *
 127  * mark tcp session as reconnecting so temporarily locked
 128  * mark all smb sessions as reconnecting for tcp session
 129  * reconnect tcp session
 130  * wake up waiters on reconnection? - (not needed currently)
 131  */
 132 static int
 133 cifs_reconnect(struct TCP_Server_Info *server)
 134 {
 135         int rc = 0;
 136         struct list_head *tmp, *tmp2;
 137         struct cifsSesInfo *ses;
 138         struct cifsTconInfo *tcon;
 139         struct mid_q_entry *mid_entry;
 140
 141         spin_lock(&GlobalMid_Lock);
 142         if (server->tcpStatus == CifsExiting) {
 143                 /* the demux thread will exit normally
 144                 next time through the loop */
 145                 spin_unlock(&GlobalMid_Lock);
 146                 return rc;
 147         } else
 148                 server->tcpStatus = CifsNeedReconnect;
 149         spin_unlock(&GlobalMid_Lock);
 150         server->maxBuf = 0;
 151
 152         cFYI(1, "Reconnecting tcp session");
 153
 154         /* before reconnecting the tcp session, mark the smb session (uid)
 155                 and the tid bad so they are not used until reconnected */
 156         cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
 157         spin_lock(&cifs_tcp_ses_lock);
 158         list_for_each(tmp, &server->smb_ses_list) {
 159                 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
 160                 ses->need_reconnect = true;
 161                 ses->ipc_tid = 0;
 162                 list_for_each(tmp2, &ses->tcon_list) {
 163                         tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
 164                         tcon->need_reconnect = true;
 165                 }
 166         }
 167         spin_unlock(&cifs_tcp_ses_lock);
 168
 169         /* do not want to be sending data on a socket we are freeing */
 170         cFYI(1, "%s: tearing down socket", __func__);
 171         mutex_lock(&server->srv_mutex);
 172         if (server->ssocket) {
 173                 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
 174                         server->ssocket->flags);
 175                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 176                 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
 177                         server->ssocket->state,
 178                         server->ssocket->flags);
 179                 sock_release(server->ssocket);
 180                 server->ssocket = NULL;
 181         }
 182         server->sequence_number = 0;
 183         server->session_estab = false;
 184         kfree(server->session_key.response);
 185         server->session_key.response = NULL;
 186         server->session_key.len = 0;
 187         server->lstrp = jiffies;
 188         mutex_unlock(&server->srv_mutex);
 189
 190         /* mark submitted MIDs for retry and issue callback */
 191         cFYI(1, "%s: issuing mid callbacks", __func__);
 192         spin_lock(&GlobalMid_Lock);
 193         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 194                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 195                 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
 196                         mid_entry->midState = MID_RETRY_NEEDED;
 197                 list_del_init(&mid_entry->qhead);
 198                 mid_entry->callback(mid_entry);
 199         }
 200         spin_unlock(&GlobalMid_Lock);
 201
 202         while (server->tcpStatus == CifsNeedReconnect) {
 203                 try_to_freeze();
 204
 205                 /* we should try only the port we connected to before */
 206                 rc = generic_ip_connect(server);
 207                 if (rc) {
 208                         cFYI(1, "reconnect error %d", rc);
 209                         msleep(3000);
 210                 } else {
 211                         atomic_inc(&tcpSesReconnectCount);
 212                         spin_lock(&GlobalMid_Lock);
 213                         if (server->tcpStatus != CifsExiting)
 214                                 server->tcpStatus = CifsNeedNegotiate;
 215                         spin_unlock(&GlobalMid_Lock);
 216                 }
 217         }
 218
 219         return rc;
 220 }
 221
 222 /*
 223         return codes:
 224                 0       not a transact2, or all data present
 225                 >0      transact2 with that much data missing
 226                 -EINVAL = invalid transact2
 227
 228  */
 229 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
 230 {
 231         struct smb_t2_rsp *pSMBt;
 232         int remaining;
 233         __u16 total_data_size, data_in_this_rsp;
 234
 235         if (pSMB->Command != SMB_COM_TRANSACTION2)
 236                 return 0;
 237
 238         /* check for plausible wct, bcc and t2 data and parm sizes */
 239         /* check for parm and data offset going beyond end of smb */
 240         if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
 241                 cFYI(1, "invalid transact2 word count");
 242                 return -EINVAL;
 243         }
 244
 245         pSMBt = (struct smb_t2_rsp *)pSMB;
 246
 247         total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 248         data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 249
 250         if (total_data_size == data_in_this_rsp)
 251                 return 0;
 252         else if (total_data_size < data_in_this_rsp) {
 253                 cFYI(1, "total data %d smaller than data in frame %d",
 254                         total_data_size, data_in_this_rsp);
 255                 return -EINVAL;
 256         }
 257
 258         remaining = total_data_size - data_in_this_rsp;
 259
 260         cFYI(1, "missing %d bytes from transact2, check next response",
 261                 remaining);
 262         if (total_data_size > maxBufSize) {
 263                 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
 264                         total_data_size, maxBufSize);
 265                 return -EINVAL;
 266         }
 267         return remaining;
 268 }
 269
 270 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
 271 {
 272         struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
 273         struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)pTargetSMB;
 274         char *data_area_of_target;
 275         char *data_area_of_buf2;
 276         int remaining;
 277         unsigned int byte_count, total_in_buf;
 278         __u16 total_data_size, total_in_buf2;
 279
 280         total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 281
 282         if (total_data_size !=
 283             get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
 284                 cFYI(1, "total data size of primary and secondary t2 differ");
 285
 286         total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 287
 288         remaining = total_data_size - total_in_buf;
 289
 290         if (remaining < 0)
 291                 return -EPROTO;
 292
 293         if (remaining == 0) /* nothing to do, ignore */
 294                 return 0;
 295
 296         total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
 297         if (remaining < total_in_buf2) {
 298                 cFYI(1, "transact2 2nd response contains too much data");
 299         }
 300
 301         /* find end of first SMB data area */
 302         data_area_of_target = (char *)&pSMBt->hdr.Protocol +
 303                                 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
 304         /* validate target area */
 305
 306         data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
 307                                 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
 308
 309         data_area_of_target += total_in_buf;
 310
 311         /* copy second buffer into end of first buffer */
 312         total_in_buf += total_in_buf2;
 313         /* is the result too big for the field? */
 314         if (total_in_buf > USHRT_MAX)
 315                 return -EPROTO;
 316         put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
 317
 318         /* fix up the BCC */
 319         byte_count = get_bcc_le(pTargetSMB);
 320         byte_count += total_in_buf2;
 321         /* is the result too big for the field? */
 322         if (byte_count > USHRT_MAX)
 323                 return -EPROTO;
 324         put_bcc_le(byte_count, pTargetSMB);
 325
 326         byte_count = pTargetSMB->smb_buf_length;
 327         byte_count += total_in_buf2;
 328         /* don't allow buffer to overflow */
 329         if (byte_count > CIFSMaxBufSize)
 330                 return -ENOBUFS;
 331         pTargetSMB->smb_buf_length = byte_count;
 332
 333         memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
 334
 335         if (remaining == total_in_buf2) {
 336                 cFYI(1, "found the last secondary response");
 337                 return 0; /* we are done */
 338         } else /* more responses to go */
 339                 return 1;
 340 }
 341
 342 static void
 343 cifs_echo_request(struct work_struct *work)
 344 {
 345         int rc;
 346         struct TCP_Server_Info *server = container_of(work,
 347                                         struct TCP_Server_Info, echo.work);
 348
 349         /*
 350          * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
 351          * done, which is indicated by maxBuf != 0. Also, no need to ping if
 352          * we got a response recently
 353          */
 354         if (server->maxBuf == 0 ||
 355             time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
 356                 goto requeue_echo;
 357
 358         rc = CIFSSMBEcho(server);
 359         if (rc)
 360                 cFYI(1, "Unable to send echo request to server: %s",
 361                         server->hostname);
 362
 363 requeue_echo:
 364         queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
 365 }
 366
 367 static int
 368 cifs_demultiplex_thread(struct TCP_Server_Info *server)
 369 {
 370         int length;
 371         unsigned int pdu_length, total_read;
 372         struct smb_hdr *smb_buffer = NULL;
 373         struct smb_hdr *bigbuf = NULL;
 374         struct smb_hdr *smallbuf = NULL;
 375         struct msghdr smb_msg;
 376         struct kvec iov;
 377         struct socket *csocket = server->ssocket;
 378         struct list_head *tmp, *tmp2;
 379         struct task_struct *task_to_wake = NULL;
 380         struct mid_q_entry *mid_entry;
 381         char temp;
 382         bool isLargeBuf = false;
 383         bool isMultiRsp;
 384         int reconnect;
 385
 386         current->flags |= PF_MEMALLOC;
 387         cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
 388
 389         length = atomic_inc_return(&tcpSesAllocCount);
 390         if (length > 1)
 391                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 392                                 GFP_KERNEL);
 393
 394         set_freezable();
 395         while (server->tcpStatus != CifsExiting) {
 396                 if (try_to_freeze())
 397                         continue;
 398                 if (bigbuf == NULL) {
 399                         bigbuf = cifs_buf_get();
 400                         if (!bigbuf) {
 401                                 cERROR(1, "No memory for large SMB response");
 402                                 msleep(3000);
 403                                 /* retry will check if exiting */
 404                                 continue;
 405                         }
 406                 } else if (isLargeBuf) {
 407                         /* we are reusing a dirty large buf, clear its start */
 408                         memset(bigbuf, 0, sizeof(struct smb_hdr));
 409                 }
 410
 411                 if (smallbuf == NULL) {
 412                         smallbuf = cifs_small_buf_get();
 413                         if (!smallbuf) {
 414                                 cERROR(1, "No memory for SMB response");
 415                                 msleep(1000);
 416                                 /* retry will check if exiting */
 417                                 continue;
 418                         }
 419                         /* beginning of smb buffer is cleared in our buf_get */
 420                 } else /* if existing small buf clear beginning */
 421                         memset(smallbuf, 0, sizeof(struct smb_hdr));
 422
 423                 isLargeBuf = false;
 424                 isMultiRsp = false;
 425                 smb_buffer = smallbuf;
 426                 iov.iov_base = smb_buffer;
 427                 iov.iov_len = 4;
 428                 smb_msg.msg_control = NULL;
 429                 smb_msg.msg_controllen = 0;
 430                 pdu_length = 4; /* enough to get RFC1001 header */
 431
 432 incomplete_rcv:
 433                 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
 434                     time_after(jiffies, server->lstrp +
 435                                         (echo_retries * SMB_ECHO_INTERVAL))) {
 436                         cERROR(1, "Server %s has not responded in %d seconds. "
 437                                   "Reconnecting...", server->hostname,
 438                                   (echo_retries * SMB_ECHO_INTERVAL / HZ));
 439                         cifs_reconnect(server);
 440                         csocket = server->ssocket;
 441                         wake_up(&server->response_q);
 442                         continue;
 443                 }
 444
 445                 length =
 446                     kernel_recvmsg(csocket, &smb_msg,
 447                                 &iov, 1, pdu_length, 0 /* BB other flags? */);
 448
 449                 if (server->tcpStatus == CifsExiting) {
 450                         break;
 451                 } else if (server->tcpStatus == CifsNeedReconnect) {
 452                         cFYI(1, "Reconnect after server stopped responding");
 453                         cifs_reconnect(server);
 454                         cFYI(1, "call to reconnect done");
 455                         csocket = server->ssocket;
 456                         continue;
 457                 } else if (length == -ERESTARTSYS ||
 458                            length == -EAGAIN ||
 459                            length == -EINTR) {
 460                         msleep(1); /* minimum sleep to prevent looping
 461                                 allowing socket to clear and app threads to set
 462                                 tcpStatus CifsNeedReconnect if server hung */
 463                         if (pdu_length < 4) {
 464                                 iov.iov_base = (4 - pdu_length) +
 465                                                         (char *)smb_buffer;
 466                                 iov.iov_len = pdu_length;
 467                                 smb_msg.msg_control = NULL;
 468                                 smb_msg.msg_controllen = 0;
 469                                 goto incomplete_rcv;
 470                         } else
 471                                 continue;
 472                 } else if (length <= 0) {
 473                         cFYI(1, "Reconnect after unexpected peek error %d",
 474                                 length);
 475                         cifs_reconnect(server);
 476                         csocket = server->ssocket;
 477                         wake_up(&server->response_q);
 478                         continue;
 479                 } else if (length < pdu_length) {
 480                         cFYI(1, "requested %d bytes but only got %d bytes",
 481                                   pdu_length, length);
 482                         pdu_length -= length;
 483                         msleep(1);
 484                         goto incomplete_rcv;
 485                 }
 486
 487                 /* The right amount was read from socket - 4 bytes */
 488                 /* so we can now interpret the length field */
 489
 490                 /* the first byte big endian of the length field,
 491                 is actually not part of the length but the type
 492                 with the most common, zero, as regular data */
 493                 temp = *((char *) smb_buffer);
 494
 495                 /* Note that FC 1001 length is big endian on the wire,
 496                 but we convert it here so it is always manipulated
 497                 as host byte order */
 498                 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
 499                 smb_buffer->smb_buf_length = pdu_length;
 500
 501                 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
 502
 503                 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
 504                         continue;
 505                 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
 506                         cFYI(1, "Good RFC 1002 session rsp");
 507                         continue;
 508                 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
 509                         /* we get this from Windows 98 instead of
 510                            an error on SMB negprot response */
 511                         cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
 512                                 pdu_length);
 513                         /* give server a second to clean up  */
 514                         msleep(1000);
 515                         /* always try 445 first on reconnect since we get NACK
 516                          * on some if we ever connected to port 139 (the NACK
 517                          * is since we do not begin with RFC1001 session
 518                          * initialize frame)
 519                          */
 520                         cifs_set_port((struct sockaddr *)
 521                                         &server->dstaddr, CIFS_PORT);
 522                         cifs_reconnect(server);
 523                         csocket = server->ssocket;
 524                         wake_up(&server->response_q);
 525                         continue;
 526                 } else if (temp != (char) 0) {
 527                         cERROR(1, "Unknown RFC 1002 frame");
 528                         cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
 529                                       length);
 530                         cifs_reconnect(server);
 531                         csocket = server->ssocket;
 532                         continue;
 533                 }
 534
 535                 /* else we have an SMB response */
 536                 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
 537                             (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
 538                         cERROR(1, "Invalid size SMB length %d pdu_length %d",
 539                                         length, pdu_length+4);
 540                         cifs_reconnect(server);
 541                         csocket = server->ssocket;
 542                         wake_up(&server->response_q);
 543                         continue;
 544                 }
 545
 546                 /* else length ok */
 547                 reconnect = 0;
 548
 549                 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 550                         isLargeBuf = true;
 551                         memcpy(bigbuf, smallbuf, 4);
 552                         smb_buffer = bigbuf;
 553                 }
 554                 length = 0;
 555                 iov.iov_base = 4 + (char *)smb_buffer;
 556                 iov.iov_len = pdu_length;
 557                 for (total_read = 0; total_read < pdu_length;
 558                      total_read += length) {
 559                         length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
 560                                                 pdu_length - total_read, 0);
 561                         if (server->tcpStatus == CifsExiting) {
 562                                 /* then will exit */
 563                                 reconnect = 2;
 564                                 break;
 565                         } else if (server->tcpStatus == CifsNeedReconnect) {
 566                                 cifs_reconnect(server);
 567                                 csocket = server->ssocket;
 568                                 /* Reconnect wakes up rspns q */
 569                                 /* Now we will reread sock */
 570                                 reconnect = 1;
 571                                 break;
 572                         } else if (length == -ERESTARTSYS ||
 573                                    length == -EAGAIN ||
 574                                    length == -EINTR) {
 575                                 msleep(1); /* minimum sleep to prevent looping,
 576                                               allowing socket to clear and app
 577                                               threads to set tcpStatus
 578                                               CifsNeedReconnect if server hung*/
 579                                 length = 0;
 580                                 continue;
 581                         } else if (length <= 0) {
 582                                 cERROR(1, "Received no data, expecting %d",
 583                                               pdu_length - total_read);
 584                                 cifs_reconnect(server);
 585                                 csocket = server->ssocket;
 586                                 reconnect = 1;
 587                                 break;
 588                         }
 589                 }
 590                 if (reconnect == 2)
 591                         break;
 592                 else if (reconnect == 1)
 593                         continue;
 594
 595                 total_read += 4; /* account for rfc1002 hdr */
 596
 597                 dump_smb(smb_buffer, total_read);
 598
 599                 /*
 600                  * We know that we received enough to get to the MID as we
 601                  * checked the pdu_length earlier. Now check to see
 602                  * if the rest of the header is OK. We borrow the length
 603                  * var for the rest of the loop to avoid a new stack var.
 604                  *
 605                  * 48 bytes is enough to display the header and a little bit
 606                  * into the payload for debugging purposes.
 607                  */
 608                 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
 609                 if (length != 0)
 610                         cifs_dump_mem("Bad SMB: ", smb_buffer,
 611                                         min_t(unsigned int, total_read, 48));
 612
 613                 mid_entry = NULL;
 614                 server->lstrp = jiffies;
 615
 616                 spin_lock(&GlobalMid_Lock);
 617                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 618                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 619
 620                         if (mid_entry->mid != smb_buffer->Mid ||
 621                             mid_entry->midState != MID_REQUEST_SUBMITTED ||
 622                             mid_entry->command != smb_buffer->Command) {
 623                                 mid_entry = NULL;
 624                                 continue;
 625                         }
 626
 627                         if (length == 0 &&
 628                             check2ndT2(smb_buffer, server->maxBuf) > 0) {
 629                                 /* We have a multipart transact2 resp */
 630                                 isMultiRsp = true;
 631                                 if (mid_entry->resp_buf) {
 632                                         /* merge response - fix up 1st*/
 633                                         length = coalesce_t2(smb_buffer,
 634                                                         mid_entry->resp_buf);
 635                                         if (length > 0) {
 636                                                 length = 0;
 637                                                 mid_entry->multiRsp = true;
 638                                                 break;
 639                                         } else {
 640                                                 /* all parts received or
 641                                                  * packet is malformed
 642                                                  */
 643                                                 mid_entry->multiEnd = true;
 644                                                 goto multi_t2_fnd;
 645                                         }
 646                                 } else {
 647                                         if (!isLargeBuf) {
 648                                                 /*
 649                                                  * FIXME: switch to already
 650                                                  *        allocated largebuf?
 651                                                  */
 652                                                 cERROR(1, "1st trans2 resp "
 653                                                           "needs bigbuf");
 654                                         } else {
 655                                                 /* Have first buffer */
 656                                                 mid_entry->resp_buf =
 657                                                          smb_buffer;
 658                                                 mid_entry->largeBuf = true;
 659                                                 bigbuf = NULL;
 660                                         }
 661                                 }
 662                                 break;
 663                         }
 664                         mid_entry->resp_buf = smb_buffer;
 665                         mid_entry->largeBuf = isLargeBuf;
 666 multi_t2_fnd:
 667                         if (length == 0)
 668                                 mid_entry->midState = MID_RESPONSE_RECEIVED;
 669                         else
 670                                 mid_entry->midState = MID_RESPONSE_MALFORMED;
 671 #ifdef CONFIG_CIFS_STATS2
 672                         mid_entry->when_received = jiffies;
 673 #endif
 674                         list_del_init(&mid_entry->qhead);
 675                         mid_entry->callback(mid_entry);
 676                         break;
 677                 }
 678                 spin_unlock(&GlobalMid_Lock);
 679
 680                 if (mid_entry != NULL) {
 681                         /* Was previous buf put in mpx struct for multi-rsp? */
 682                         if (!isMultiRsp) {
 683                                 /* smb buffer will be freed by user thread */
 684                                 if (isLargeBuf)
 685                                         bigbuf = NULL;
 686                                 else
 687                                         smallbuf = NULL;
 688                         }
 689                 } else if (length != 0) {
 690                         /* response sanity checks failed */
 691                         continue;
 692                 } else if (!is_valid_oplock_break(smb_buffer, server) &&
 693                            !isMultiRsp) {
 694                         cERROR(1, "No task to wake, unknown frame received! "
 695                                    "NumMids %d", atomic_read(&midCount));
 696                         cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
 697                                       sizeof(struct smb_hdr));
 698 #ifdef CONFIG_CIFS_DEBUG2
 699                         cifs_dump_detail(smb_buffer);
 700                         cifs_dump_mids(server);
 701 #endif /* CIFS_DEBUG2 */
 702
 703                 }
 704         } /* end while !EXITING */
 705
 706         /* take it off the list, if it's not already */
 707         spin_lock(&cifs_tcp_ses_lock);
 708         list_del_init(&server->tcp_ses_list);
 709         spin_unlock(&cifs_tcp_ses_lock);
 710
 711         spin_lock(&GlobalMid_Lock);
 712         server->tcpStatus = CifsExiting;
 713         spin_unlock(&GlobalMid_Lock);
 714         wake_up_all(&server->response_q);
 715
 716         /* check if we have blocked requests that need to free */
 717         /* Note that cifs_max_pending is normally 50, but
 718         can be set at module install time to as little as two */
 719         spin_lock(&GlobalMid_Lock);
 720         if (atomic_read(&server->inFlight) >= cifs_max_pending)
 721                 atomic_set(&server->inFlight, cifs_max_pending - 1);
 722         /* We do not want to set the max_pending too low or we
 723         could end up with the counter going negative */
 724         spin_unlock(&GlobalMid_Lock);
 725         /* Although there should not be any requests blocked on
 726         this queue it can not hurt to be paranoid and try to wake up requests
 727         that may haven been blocked when more than 50 at time were on the wire
 728         to the same server - they now will see the session is in exit state
 729         and get out of SendReceive.  */
 730         wake_up_all(&server->request_q);
 731         /* give those requests time to exit */
 732         msleep(125);
 733
 734         if (server->ssocket) {
 735                 sock_release(csocket);
 736                 server->ssocket = NULL;
 737         }
 738         /* buffer usuallly freed in free_mid - need to free it here on exit */
 739         cifs_buf_release(bigbuf);
 740         if (smallbuf) /* no sense logging a debug message if NULL */
 741                 cifs_small_buf_release(smallbuf);
 742
 743         if (!list_empty(&server->pending_mid_q)) {
 744                 spin_lock(&GlobalMid_Lock);
 745                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 746                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 747                         cFYI(1, "Clearing Mid 0x%x - issuing callback",
 748                                          mid_entry->mid);
 749                         list_del_init(&mid_entry->qhead);
 750                         mid_entry->callback(mid_entry);
 751                 }
 752                 spin_unlock(&GlobalMid_Lock);
 753                 /* 1/8th of sec is more than enough time for them to exit */
 754                 msleep(125);
 755         }
 756
 757         if (!list_empty(&server->pending_mid_q)) {
 758                 /* mpx threads have not exited yet give them
 759                 at least the smb send timeout time for long ops */
 760                 /* due to delays on oplock break requests, we need
 761                 to wait at least 45 seconds before giving up
 762                 on a request getting a response and going ahead
 763                 and killing cifsd */
 764                 cFYI(1, "Wait for exit from demultiplex thread");
 765                 msleep(46000);
 766                 /* if threads still have not exited they are probably never
 767                 coming home not much else we can do but free the memory */
 768         }
 769
 770         kfree(server->hostname);
 771         task_to_wake = xchg(&server->tsk, NULL);
 772         kfree(server);
 773
 774         length = atomic_dec_return(&tcpSesAllocCount);
 775         if (length  > 0)
 776                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 777                                 GFP_KERNEL);
 778
 779         /* if server->tsk was NULL then wait for a signal before exiting */
 780         if (!task_to_wake) {
 781                 set_current_state(TASK_INTERRUPTIBLE);
 782                 while (!signal_pending(current)) {
 783                         schedule();
 784                         set_current_state(TASK_INTERRUPTIBLE);
 785                 }
 786                 set_current_state(TASK_RUNNING);
 787         }
 788
 789         module_put_and_exit(0);
 790 }
 791
 792 /* extract the host portion of the UNC string */
 793 static char *
 794 extract_hostname(const char *unc)
 795 {
 796         const char *src;
 797         char *dst, *delim;
 798         unsigned int len;
 799
 800         /* skip double chars at beginning of string */
 801         /* BB: check validity of these bytes? */
 802         src = unc + 2;
 803
 804         /* delimiter between hostname and sharename is always '\\' now */
 805         delim = strchr(src, '\\');
 806         if (!delim)
 807                 return ERR_PTR(-EINVAL);
 808
 809         len = delim - src;
 810         dst = kmalloc((len + 1), GFP_KERNEL);
 811         if (dst == NULL)
 812                 return ERR_PTR(-ENOMEM);
 813
 814         memcpy(dst, src, len);
 815         dst[len] = '\0';
 816
 817         return dst;
 818 }
 819
 820 static int
 821 cifs_parse_mount_options(char *options, const char *devname,
 822                          struct smb_vol *vol)
 823 {
 824         char *value, *data, *end;
 825         unsigned int  temp_len, i, j;
 826         char separator[2];
 827         short int override_uid = -1;
 828         short int override_gid = -1;
 829         bool uid_specified = false;
 830         bool gid_specified = false;
 831         char *nodename = utsname()->nodename;
 832
 833         separator[0] = ',';
 834         separator[1] = 0;
 835
 836         /*
 837          * does not have to be perfect mapping since field is
 838          * informational, only used for servers that do not support
 839          * port 445 and it can be overridden at mount time
 840          */
 841         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
 842         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
 843                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
 844
 845         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
 846         /* null target name indicates to use *SMBSERVR default called name
 847            if we end up sending RFC1001 session initialize */
 848         vol->target_rfc1001_name[0] = 0;
 849         vol->cred_uid = current_uid();
 850         vol->linux_uid = current_uid();
 851         vol->linux_gid = current_gid();
 852
 853         /* default to only allowing write access to owner of the mount */
 854         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
 855
 856         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
 857         /* default is always to request posix paths. */
 858         vol->posix_paths = 1;
 859         /* default to using server inode numbers where available */
 860         vol->server_ino = 1;
 861
 862         vol->actimeo = CIFS_DEF_ACTIMEO;
 863
 864         if (!options)
 865                 return 1;
 866
 867         end = options + strlen(options);
 868         if (strncmp(options, "sep=", 4) == 0) {
 869                 if (options[4] != 0) {
 870                         separator[0] = options[4];
 871                         options += 5;
 872                 } else {
 873                         cFYI(1, "Null separator not allowed");
 874                 }
 875         }
 876
 877         while ((data = strsep(&options, separator)) != NULL) {
 878                 if (!*data)
 879                         continue;
 880                 if ((value = strchr(data, '=')) != NULL)
 881                         *value++ = '\0';
 882
 883                 /* Have to parse this before we parse for "user" */
 884                 if (strnicmp(data, "user_xattr", 10) == 0) {
 885                         vol->no_xattr = 0;
 886                 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
 887                         vol->no_xattr = 1;
 888                 } else if (strnicmp(data, "user", 4) == 0) {
 889                         if (!value) {
 890                                 printk(KERN_WARNING
 891                                        "CIFS: invalid or missing username\n");
 892                                 return 1;       /* needs_arg; */
 893                         } else if (!*value) {
 894                                 /* null user, ie anonymous, authentication */
 895                                 vol->nullauth = 1;
 896                         }
 897                         if (strnlen(value, MAX_USERNAME_SIZE) <
 898                                                 MAX_USERNAME_SIZE) {
 899                                 vol->username = value;
 900                         } else {
 901                                 printk(KERN_WARNING "CIFS: username too long\n");
 902                                 return 1;
 903                         }
 904                 } else if (strnicmp(data, "pass", 4) == 0) {
 905                         if (!value) {
 906                                 vol->password = NULL;
 907                                 continue;
 908                         } else if (value[0] == 0) {
 909                                 /* check if string begins with double comma
 910                                    since that would mean the password really
 911                                    does start with a comma, and would not
 912                                    indicate an empty string */
 913                                 if (value[1] != separator[0]) {
 914                                         vol->password = NULL;
 915                                         continue;
 916                                 }
 917                         }
 918                         temp_len = strlen(value);
 919                         /* removed password length check, NTLM passwords
 920                                 can be arbitrarily long */
 921
 922                         /* if comma in password, the string will be
 923                         prematurely null terminated.  Commas in password are
 924                         specified across the cifs mount interface by a double
 925                         comma ie ,, and a comma used as in other cases ie ','
 926                         as a parameter delimiter/separator is single and due
 927                         to the strsep above is temporarily zeroed. */
 928
 929                         /* NB: password legally can have multiple commas and
 930                         the only illegal character in a password is null */
 931
 932                         if ((value[temp_len] == 0) &&
 933                             (value + temp_len < end) &&
 934                             (value[temp_len+1] == separator[0])) {
 935                                 /* reinsert comma */
 936                                 value[temp_len] = separator[0];
 937                                 temp_len += 2;  /* move after second comma */
 938                                 while (value[temp_len] != 0)  {
 939                                         if (value[temp_len] == separator[0]) {
 940                                                 if (value[temp_len+1] ==
 941                                                      separator[0]) {
 942                                                 /* skip second comma */
 943                                                         temp_len++;
 944                                                 } else {
 945                                                 /* single comma indicating start
 946                                                          of next parm */
 947                                                         break;
 948                                                 }
 949                                         }
 950                                         temp_len++;
 951                                 }
 952                                 if (value[temp_len] == 0) {
 953                                         options = NULL;
 954                                 } else {
 955                                         value[temp_len] = 0;
 956                                         /* point option to start of next parm */
 957                                         options = value + temp_len + 1;
 958                                 }
 959                                 /* go from value to value + temp_len condensing
 960                                 double commas to singles. Note that this ends up
 961                                 allocating a few bytes too many, which is ok */
 962                                 vol->password = kzalloc(temp_len, GFP_KERNEL);
 963                                 if (vol->password == NULL) {
 964                                         printk(KERN_WARNING "CIFS: no memory "
 965                                                             "for password\n");
 966                                         return 1;
 967                                 }
 968                                 for (i = 0, j = 0; i < temp_len; i++, j++) {
 969                                         vol->password[j] = value[i];
 970                                         if (value[i] == separator[0]
 971                                                 && value[i+1] == separator[0]) {
 972                                                 /* skip second comma */
 973                                                 i++;
 974                                         }
 975                                 }
 976                                 vol->password[j] = 0;
 977                         } else {
 978                                 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
 979                                 if (vol->password == NULL) {
 980                                         printk(KERN_WARNING "CIFS: no memory "
 981                                                             "for password\n");
 982                                         return 1;
 983                                 }
 984                                 strcpy(vol->password, value);
 985                         }
 986                 } else if (!strnicmp(data, "ip", 2) ||
 987                            !strnicmp(data, "addr", 4)) {
 988                         if (!value || !*value) {
 989                                 vol->UNCip = NULL;
 990                         } else if (strnlen(value, INET6_ADDRSTRLEN) <
 991                                                         INET6_ADDRSTRLEN) {
 992                                 vol->UNCip = value;
 993                         } else {
 994                                 printk(KERN_WARNING "CIFS: ip address "
 995                                                     "too long\n");
 996                                 return 1;
 997                         }
 998                 } else if (strnicmp(data, "sec", 3) == 0) {
 999                         if (!value || !*value) {
1000                                 cERROR(1, "no security value specified");
1001                                 continue;
1002                         } else if (strnicmp(value, "krb5i", 5) == 0) {
1003                                 vol->secFlg |= CIFSSEC_MAY_KRB5 |
1004                                         CIFSSEC_MUST_SIGN;
1005                         } else if (strnicmp(value, "krb5p", 5) == 0) {
1006                                 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1007                                         CIFSSEC_MAY_KRB5; */
1008                                 cERROR(1, "Krb5 cifs privacy not supported");
1009                                 return 1;
1010                         } else if (strnicmp(value, "krb5", 4) == 0) {
1011                                 vol->secFlg |= CIFSSEC_MAY_KRB5;
1012                         } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1013                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1014                                         CIFSSEC_MUST_SIGN;
1015                         } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1016                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1017                         } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1018                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1019                                         CIFSSEC_MUST_SIGN;
1020                         } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1021                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1022                         } else if (strnicmp(value, "ntlmi", 5) == 0) {
1023                                 vol->secFlg |= CIFSSEC_MAY_NTLM |
1024                                         CIFSSEC_MUST_SIGN;
1025                         } else if (strnicmp(value, "ntlm", 4) == 0) {
1026                                 /* ntlm is default so can be turned off too */
1027                                 vol->secFlg |= CIFSSEC_MAY_NTLM;
1028                         } else if (strnicmp(value, "nontlm", 6) == 0) {
1029                                 /* BB is there a better way to do this? */
1030                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1031 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1032                         } else if (strnicmp(value, "lanman", 6) == 0) {
1033                                 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1034 #endif
1035                         } else if (strnicmp(value, "none", 4) == 0) {
1036                                 vol->nullauth = 1;
1037                         } else {
1038                                 cERROR(1, "bad security option: %s", value);
1039                                 return 1;
1040                         }
1041                 } else if ((strnicmp(data, "unc", 3) == 0)
1042                            || (strnicmp(data, "target", 6) == 0)
1043                            || (strnicmp(data, "path", 4) == 0)) {
1044                         if (!value || !*value) {
1045                                 printk(KERN_WARNING "CIFS: invalid path to "
1046                                                     "network resource\n");
1047                                 return 1;       /* needs_arg; */
1048                         }
1049                         if ((temp_len = strnlen(value, 300)) < 300) {
1050                                 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1051                                 if (vol->UNC == NULL)
1052                                         return 1;
1053                                 strcpy(vol->UNC, value);
1054                                 if (strncmp(vol->UNC, "//", 2) == 0) {
1055                                         vol->UNC[0] = '\\';
1056                                         vol->UNC[1] = '\\';
1057                                 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1058                                         printk(KERN_WARNING
1059                                                "CIFS: UNC Path does not begin "
1060                                                "with // or \\\\ \n");
1061                                         return 1;
1062                                 }
1063                         } else {
1064                                 printk(KERN_WARNING "CIFS: UNC name too long\n");
1065                                 return 1;
1066                         }
1067                 } else if ((strnicmp(data, "domain", 3) == 0)
1068                            || (strnicmp(data, "workgroup", 5) == 0)) {
1069                         if (!value || !*value) {
1070                                 printk(KERN_WARNING "CIFS: invalid domain name\n");
1071                                 return 1;       /* needs_arg; */
1072                         }
1073                         /* BB are there cases in which a comma can be valid in
1074                         a domain name and need special handling? */
1075                         if (strnlen(value, 256) < 256) {
1076                                 vol->domainname = value;
1077                                 cFYI(1, "Domain name set");
1078                         } else {
1079                                 printk(KERN_WARNING "CIFS: domain name too "
1080                                                     "long\n");
1081                                 return 1;
1082                         }
1083                 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1084                         vol->srcaddr.ss_family = AF_UNSPEC;
1085
1086                         if (!value || !*value) {
1087                                 printk(KERN_WARNING "CIFS: srcaddr value"
1088                                        " not specified.\n");
1089                                 return 1;       /* needs_arg; */
1090                         }
1091                         i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1092                                                  value, strlen(value));
1093                         if (i == 0) {
1094                                 printk(KERN_WARNING "CIFS:  Could not parse"
1095                                        " srcaddr: %s\n",
1096                                        value);
1097                                 return 1;
1098                         }
1099                 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1100                         if (!value || !*value) {
1101                                 printk(KERN_WARNING
1102                                         "CIFS: invalid path prefix\n");
1103                                 return 1;       /* needs_argument */
1104                         }
1105                         if ((temp_len = strnlen(value, 1024)) < 1024) {
1106                                 if (value[0] != '/')
1107                                         temp_len++;  /* missing leading slash */
1108                                 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1109                                 if (vol->prepath == NULL)
1110                                         return 1;
1111                                 if (value[0] != '/') {
1112                                         vol->prepath[0] = '/';
1113                                         strcpy(vol->prepath+1, value);
1114                                 } else
1115                                         strcpy(vol->prepath, value);
1116                                 cFYI(1, "prefix path %s", vol->prepath);
1117                         } else {
1118                                 printk(KERN_WARNING "CIFS: prefix too long\n");
1119                                 return 1;
1120                         }
1121                 } else if (strnicmp(data, "iocharset", 9) == 0) {
1122                         if (!value || !*value) {
1123                                 printk(KERN_WARNING "CIFS: invalid iocharset "
1124                                                     "specified\n");
1125                                 return 1;       /* needs_arg; */
1126                         }
1127                         if (strnlen(value, 65) < 65) {
1128                                 if (strnicmp(value, "default", 7))
1129                                         vol->iocharset = value;
1130                                 /* if iocharset not set then load_nls_default
1131                                    is used by caller */
1132                                 cFYI(1, "iocharset set to %s", value);
1133                         } else {
1134                                 printk(KERN_WARNING "CIFS: iocharset name "
1135                                                     "too long.\n");
1136                                 return 1;
1137                         }
1138                 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1139                         vol->linux_uid = simple_strtoul(value, &value, 0);
1140                         uid_specified = true;
1141                 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1142                         vol->cred_uid = simple_strtoul(value, &value, 0);
1143                 } else if (!strnicmp(data, "forceuid", 8)) {
1144                         override_uid = 1;
1145                 } else if (!strnicmp(data, "noforceuid", 10)) {
1146                         override_uid = 0;
1147                 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1148                         vol->linux_gid = simple_strtoul(value, &value, 0);
1149                         gid_specified = true;
1150                 } else if (!strnicmp(data, "forcegid", 8)) {
1151                         override_gid = 1;
1152                 } else if (!strnicmp(data, "noforcegid", 10)) {
1153                         override_gid = 0;
1154                 } else if (strnicmp(data, "file_mode", 4) == 0) {
1155                         if (value && *value) {
1156                                 vol->file_mode =
1157                                         simple_strtoul(value, &value, 0);
1158                         }
1159                 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1160                         if (value && *value) {
1161                                 vol->dir_mode =
1162                                         simple_strtoul(value, &value, 0);
1163                         }
1164                 } else if (strnicmp(data, "dirmode", 4) == 0) {
1165                         if (value && *value) {
1166                                 vol->dir_mode =
1167                                         simple_strtoul(value, &value, 0);
1168                         }
1169                 } else if (strnicmp(data, "port", 4) == 0) {
1170                         if (value && *value) {
1171                                 vol->port =
1172                                         simple_strtoul(value, &value, 0);
1173                         }
1174                 } else if (strnicmp(data, "rsize", 5) == 0) {
1175                         if (value && *value) {
1176                                 vol->rsize =
1177                                         simple_strtoul(value, &value, 0);
1178                         }
1179                 } else if (strnicmp(data, "wsize", 5) == 0) {
1180                         if (value && *value) {
1181                                 vol->wsize =
1182                                         simple_strtoul(value, &value, 0);
1183                         }
1184                 } else if (strnicmp(data, "sockopt", 5) == 0) {
1185                         if (!value || !*value) {
1186                                 cERROR(1, "no socket option specified");
1187                                 continue;
1188                         } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1189                                 vol->sockopt_tcp_nodelay = 1;
1190                         }
1191                 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1192                         if (!value || !*value || (*value == ' ')) {
1193                                 cFYI(1, "invalid (empty) netbiosname");
1194                         } else {
1195                                 memset(vol->source_rfc1001_name, 0x20,
1196                                         RFC1001_NAME_LEN);
1197                                 /*
1198                                  * FIXME: are there cases in which a comma can
1199                                  * be valid in workstation netbios name (and
1200                                  * need special handling)?
1201                                  */
1202                                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1203                                         /* don't ucase netbiosname for user */
1204                                         if (value[i] == 0)
1205                                                 break;
1206                                         vol->source_rfc1001_name[i] = value[i];
1207                                 }
1208                                 /* The string has 16th byte zero still from
1209                                 set at top of the function  */
1210                                 if (i == RFC1001_NAME_LEN && value[i] != 0)
1211                                         printk(KERN_WARNING "CIFS: netbiosname"
1212                                                 " longer than 15 truncated.\n");
1213                         }
1214                 } else if (strnicmp(data, "servern", 7) == 0) {
1215                         /* servernetbiosname specified override *SMBSERVER */
1216                         if (!value || !*value || (*value == ' ')) {
1217                                 cFYI(1, "empty server netbiosname specified");
1218                         } else {
1219                                 /* last byte, type, is 0x20 for servr type */
1220                                 memset(vol->target_rfc1001_name, 0x20,
1221                                         RFC1001_NAME_LEN_WITH_NULL);
1222
1223                                 for (i = 0; i < 15; i++) {
1224                                 /* BB are there cases in which a comma can be
1225                                    valid in this workstation netbios name
1226                                    (and need special handling)? */
1227
1228                                 /* user or mount helper must uppercase
1229                                    the netbiosname */
1230                                         if (value[i] == 0)
1231                                                 break;
1232                                         else
1233                                                 vol->target_rfc1001_name[i] =
1234                                                                 value[i];
1235                                 }
1236                                 /* The string has 16th byte zero still from
1237                                    set at top of the function  */
1238                                 if (i == RFC1001_NAME_LEN && value[i] != 0)
1239                                         printk(KERN_WARNING "CIFS: server net"
1240                                         "biosname longer than 15 truncated.\n");
1241                         }
1242                 } else if (strnicmp(data, "actimeo", 7) == 0) {
1243                         if (value && *value) {
1244                                 vol->actimeo = HZ * simple_strtoul(value,
1245                                                                    &value, 0);
1246                                 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1247                                         cERROR(1, "CIFS: attribute cache"
1248                                                         "timeout too large");
1249                                         return 1;
1250                                 }
1251                         }
1252                 } else if (strnicmp(data, "credentials", 4) == 0) {
1253                         /* ignore */
1254                 } else if (strnicmp(data, "version", 3) == 0) {
1255                         /* ignore */
1256                 } else if (strnicmp(data, "guest", 5) == 0) {
1257                         /* ignore */
1258                 } else if (strnicmp(data, "rw", 2) == 0) {
1259                         /* ignore */
1260                 } else if (strnicmp(data, "ro", 2) == 0) {
1261                         /* ignore */
1262                 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1263                         vol->noblocksnd = 1;
1264                 } else if (strnicmp(data, "noautotune", 10) == 0) {
1265                         vol->noautotune = 1;
1266                 } else if ((strnicmp(data, "suid", 4) == 0) ||
1267                                    (strnicmp(data, "nosuid", 6) == 0) ||
1268                                    (strnicmp(data, "exec", 4) == 0) ||
1269                                    (strnicmp(data, "noexec", 6) == 0) ||
1270                                    (strnicmp(data, "nodev", 5) == 0) ||
1271                                    (strnicmp(data, "noauto", 6) == 0) ||
1272                                    (strnicmp(data, "dev", 3) == 0)) {
1273                         /*  The mount tool or mount.cifs helper (if present)
1274                             uses these opts to set flags, and the flags are read
1275                             by the kernel vfs layer before we get here (ie
1276                             before read super) so there is no point trying to
1277                             parse these options again and set anything and it
1278                             is ok to just ignore them */
1279                         continue;
1280                 } else if (strnicmp(data, "hard", 4) == 0) {
1281                         vol->retry = 1;
1282                 } else if (strnicmp(data, "soft", 4) == 0) {
1283                         vol->retry = 0;
1284                 } else if (strnicmp(data, "perm", 4) == 0) {
1285                         vol->noperm = 0;
1286                 } else if (strnicmp(data, "noperm", 6) == 0) {
1287                         vol->noperm = 1;
1288                 } else if (strnicmp(data, "mapchars", 8) == 0) {
1289                         vol->remap = 1;
1290                 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1291                         vol->remap = 0;
1292                 } else if (strnicmp(data, "sfu", 3) == 0) {
1293                         vol->sfu_emul = 1;
1294                 } else if (strnicmp(data, "nosfu", 5) == 0) {
1295                         vol->sfu_emul = 0;
1296                 } else if (strnicmp(data, "nodfs", 5) == 0) {
1297                         vol->nodfs = 1;
1298                 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1299                         vol->posix_paths = 1;
1300                 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1301                         vol->posix_paths = 0;
1302                 } else if (strnicmp(data, "nounix", 6) == 0) {
1303                         vol->no_linux_ext = 1;
1304                 } else if (strnicmp(data, "nolinux", 7) == 0) {
1305                         vol->no_linux_ext = 1;
1306                 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1307                            (strnicmp(data, "ignorecase", 10)  == 0)) {
1308                         vol->nocase = 1;
1309                 } else if (strnicmp(data, "mand", 4) == 0) {
1310                         /* ignore */
1311                 } else if (strnicmp(data, "nomand", 6) == 0) {
1312                         /* ignore */
1313                 } else if (strnicmp(data, "_netdev", 7) == 0) {
1314                         /* ignore */
1315                 } else if (strnicmp(data, "brl", 3) == 0) {
1316                         vol->nobrl =  0;
1317                 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1318                            (strnicmp(data, "nolock", 6) == 0)) {
1319                         vol->nobrl =  1;
1320                         /* turn off mandatory locking in mode
1321                         if remote locking is turned off since the
1322                         local vfs will do advisory */
1323                         if (vol->file_mode ==
1324                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1325                                 vol->file_mode = S_IALLUGO;
1326                 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1327                         /* will take the shorter form "forcemand" as well */
1328                         /* This mount option will force use of mandatory
1329                           (DOS/Windows style) byte range locks, instead of
1330                           using posix advisory byte range locks, even if the
1331                           Unix extensions are available and posix locks would
1332                           be supported otherwise. If Unix extensions are not
1333                           negotiated this has no effect since mandatory locks
1334                           would be used (mandatory locks is all that those
1335                           those servers support) */
1336                         vol->mand_lock = 1;
1337                 } else if (strnicmp(data, "setuids", 7) == 0) {
1338                         vol->setuids = 1;
1339                 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1340                         vol->setuids = 0;
1341                 } else if (strnicmp(data, "dynperm", 7) == 0) {
1342                         vol->dynperm = true;
1343                 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1344                         vol->dynperm = false;
1345                 } else if (strnicmp(data, "nohard", 6) == 0) {
1346                         vol->retry = 0;
1347                 } else if (strnicmp(data, "nosoft", 6) == 0) {
1348                         vol->retry = 1;
1349                 } else if (strnicmp(data, "nointr", 6) == 0) {
1350                         vol->intr = 0;
1351                 } else if (strnicmp(data, "intr", 4) == 0) {
1352                         vol->intr = 1;
1353                 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1354                         vol->nostrictsync = 1;
1355                 } else if (strnicmp(data, "strictsync", 10) == 0) {
1356                         vol->nostrictsync = 0;
1357                 } else if (strnicmp(data, "serverino", 7) == 0) {
1358                         vol->server_ino = 1;
1359                 } else if (strnicmp(data, "noserverino", 9) == 0) {
1360                         vol->server_ino = 0;
1361                 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1362                         vol->cifs_acl = 1;
1363                 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1364                         vol->cifs_acl = 0;
1365                 } else if (strnicmp(data, "acl", 3) == 0) {
1366                         vol->no_psx_acl = 0;
1367                 } else if (strnicmp(data, "noacl", 5) == 0) {
1368                         vol->no_psx_acl = 1;
1369                 } else if (strnicmp(data, "locallease", 6) == 0) {
1370                         vol->local_lease = 1;
1371                 } else if (strnicmp(data, "sign", 4) == 0) {
1372                         vol->secFlg |= CIFSSEC_MUST_SIGN;
1373                 } else if (strnicmp(data, "seal", 4) == 0) {
1374                         /* we do not do the following in secFlags because seal
1375                            is a per tree connection (mount) not a per socket
1376                            or per-smb connection option in the protocol */
1377                         /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1378                         vol->seal = 1;
1379                 } else if (strnicmp(data, "direct", 6) == 0) {
1380                         vol->direct_io = 1;
1381                 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1382                         vol->direct_io = 1;
1383                 } else if (strnicmp(data, "strictcache", 11) == 0) {
1384                         vol->strict_io = 1;
1385                 } else if (strnicmp(data, "noac", 4) == 0) {
1386                         printk(KERN_WARNING "CIFS: Mount option noac not "
1387                                 "supported. Instead set "
1388                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1389                 } else if (strnicmp(data, "fsc", 3) == 0) {
1390 #ifndef CONFIG_CIFS_FSCACHE
1391                         cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1392                                   "kernel config option set");
1393                         return 1;
1394 #endif
1395                         vol->fsc = true;
1396                 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1397                         vol->mfsymlinks = true;
1398                 } else if (strnicmp(data, "multiuser", 8) == 0) {
1399                         vol->multiuser = true;
1400                 } else
1401                         printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1402                                                 data);
1403         }
1404         if (vol->UNC == NULL) {
1405                 if (devname == NULL) {
1406                         printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1407                                                 "target\n");
1408                         return 1;
1409                 }
1410                 if ((temp_len = strnlen(devname, 300)) < 300) {
1411                         vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1412                         if (vol->UNC == NULL)
1413                                 return 1;
1414                         strcpy(vol->UNC, devname);
1415                         if (strncmp(vol->UNC, "//", 2) == 0) {
1416                                 vol->UNC[0] = '\\';
1417                                 vol->UNC[1] = '\\';
1418                         } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1419                                 printk(KERN_WARNING "CIFS: UNC Path does not "
1420                                                     "begin with // or \\\\ \n");
1421                                 return 1;
1422                         }
1423                         value = strpbrk(vol->UNC+2, "/\\");
1424                         if (value)
1425                                 *value = '\\';
1426                 } else {
1427                         printk(KERN_WARNING "CIFS: UNC name too long\n");
1428                         return 1;
1429                 }
1430         }
1431
1432         if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1433                 cERROR(1, "Multiuser mounts currently require krb5 "
1434                           "authentication!");
1435                 return 1;
1436         }
1437
1438         if (vol->UNCip == NULL)
1439                 vol->UNCip = &vol->UNC[2];
1440
1441         if (uid_specified)
1442                 vol->override_uid = override_uid;
1443         else if (override_uid == 1)
1444                 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1445                                    "specified with no uid= option.\n");
1446
1447         if (gid_specified)
1448                 vol->override_gid = override_gid;
1449         else if (override_gid == 1)
1450                 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1451                                    "specified with no gid= option.\n");
1452
1453         return 0;
1454 }
1455
1456 /** Returns true if srcaddr isn't specified and rhs isn't
1457  * specified, or if srcaddr is specified and
1458  * matches the IP address of the rhs argument.
1459  */
1460 static bool
1461 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1462 {
1463         switch (srcaddr->sa_family) {
1464         case AF_UNSPEC:
1465                 return (rhs->sa_family == AF_UNSPEC);
1466         case AF_INET: {
1467                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1468                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1469                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1470         }
1471         case AF_INET6: {
1472                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1473                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1474                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1475         }
1476         default:
1477                 WARN_ON(1);
1478                 return false; /* don't expect to be here */
1479         }
1480 }
1481
1482 /*
1483  * If no port is specified in addr structure, we try to match with 445 port
1484  * and if it fails - with 139 ports. It should be called only if address
1485  * families of server and addr are equal.
1486  */
1487 static bool
1488 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1489 {
1490         __be16 port, *sport;
1491
1492         switch (addr->sa_family) {
1493         case AF_INET:
1494                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1495                 port = ((struct sockaddr_in *) addr)->sin_port;
1496                 break;
1497         case AF_INET6:
1498                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1499                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1500                 break;
1501         default:
1502                 WARN_ON(1);
1503                 return false;
1504         }
1505
1506         if (!port) {
1507                 port = htons(CIFS_PORT);
1508                 if (port == *sport)
1509                         return true;
1510
1511                 port = htons(RFC1001_PORT);
1512         }
1513
1514         return port == *sport;
1515 }
1516
1517 static bool
1518 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1519               struct sockaddr *srcaddr)
1520 {
1521         switch (addr->sa_family) {
1522         case AF_INET: {
1523                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1524                 struct sockaddr_in *srv_addr4 =
1525                                         (struct sockaddr_in *)&server->dstaddr;
1526
1527                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1528                         return false;
1529                 break;
1530         }
1531         case AF_INET6: {
1532                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1533                 struct sockaddr_in6 *srv_addr6 =
1534                                         (struct sockaddr_in6 *)&server->dstaddr;
1535
1536                 if (!ipv6_addr_equal(&addr6->sin6_addr,
1537                                      &srv_addr6->sin6_addr))
1538                         return false;
1539                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1540                         return false;
1541                 break;
1542         }
1543         default:
1544                 WARN_ON(1);
1545                 return false; /* don't expect to be here */
1546         }
1547
1548         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1549                 return false;
1550
1551         return true;
1552 }
1553
1554 static bool
1555 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1556 {
1557         unsigned int secFlags;
1558
1559         if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1560                 secFlags = vol->secFlg;
1561         else
1562                 secFlags = global_secflags | vol->secFlg;
1563
1564         switch (server->secType) {
1565         case LANMAN:
1566                 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1567                         return false;
1568                 break;
1569         case NTLMv2:
1570                 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1571                         return false;
1572                 break;
1573         case NTLM:
1574                 if (!(secFlags & CIFSSEC_MAY_NTLM))
1575                         return false;
1576                 break;
1577         case Kerberos:
1578                 if (!(secFlags & CIFSSEC_MAY_KRB5))
1579                         return false;
1580                 break;
1581         case RawNTLMSSP:
1582                 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1583                         return false;
1584                 break;
1585         default:
1586                 /* shouldn't happen */
1587                 return false;
1588         }
1589
1590         /* now check if signing mode is acceptable */
1591         if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1592             (server->secMode & SECMODE_SIGN_REQUIRED))
1593                         return false;
1594         else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1595                  (server->secMode &
1596                   (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1597                         return false;
1598
1599         return true;
1600 }
1601
1602 static struct TCP_Server_Info *
1603 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1604 {
1605         struct TCP_Server_Info *server;
1606
1607         spin_lock(&cifs_tcp_ses_lock);
1608         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1609                 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1610                         continue;
1611
1612                 if (!match_address(server, addr,
1613                                    (struct sockaddr *)&vol->srcaddr))
1614                         continue;
1615
1616                 if (!match_port(server, addr))
1617                         continue;
1618
1619                 if (!match_security(server, vol))
1620                         continue;
1621
1622                 ++server->srv_count;
1623                 spin_unlock(&cifs_tcp_ses_lock);
1624                 cFYI(1, "Existing tcp session with server found");
1625                 return server;
1626         }
1627         spin_unlock(&cifs_tcp_ses_lock);
1628         return NULL;
1629 }
1630
1631 static void
1632 cifs_put_tcp_session(struct TCP_Server_Info *server)
1633 {
1634         struct task_struct *task;
1635
1636         spin_lock(&cifs_tcp_ses_lock);
1637         if (--server->srv_count > 0) {
1638                 spin_unlock(&cifs_tcp_ses_lock);
1639                 return;
1640         }
1641
1642         put_net(cifs_net_ns(server));
1643
1644         list_del_init(&server->tcp_ses_list);
1645         spin_unlock(&cifs_tcp_ses_lock);
1646
1647         cancel_delayed_work_sync(&server->echo);
1648
1649         spin_lock(&GlobalMid_Lock);
1650         server->tcpStatus = CifsExiting;
1651         spin_unlock(&GlobalMid_Lock);
1652
1653         cifs_crypto_shash_release(server);
1654         cifs_fscache_release_client_cookie(server);
1655
1656         kfree(server->session_key.response);
1657         server->session_key.response = NULL;
1658         server->session_key.len = 0;
1659
1660         task = xchg(&server->tsk, NULL);
1661         if (task)
1662                 force_sig(SIGKILL, task);
1663 }
1664
1665 static struct TCP_Server_Info *
1666 cifs_get_tcp_session(struct smb_vol *volume_info)
1667 {
1668         struct TCP_Server_Info *tcp_ses = NULL;
1669         struct sockaddr_storage addr;
1670         struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1671         struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1672         int rc;
1673
1674         memset(&addr, 0, sizeof(struct sockaddr_storage));
1675
1676         cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1677
1678         if (volume_info->UNCip && volume_info->UNC) {
1679                 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1680                                         volume_info->UNCip,
1681                                         strlen(volume_info->UNCip),
1682                                         volume_info->port);
1683                 if (!rc) {
1684                         /* we failed translating address */
1685                         rc = -EINVAL;
1686                         goto out_err;
1687                 }
1688         } else if (volume_info->UNCip) {
1689                 /* BB using ip addr as tcp_ses name to connect to the
1690                    DFS root below */
1691                 cERROR(1, "Connecting to DFS root not implemented yet");
1692                 rc = -EINVAL;
1693                 goto out_err;
1694         } else /* which tcp_sess DFS root would we conect to */ {
1695                 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1696                         "unc=//192.168.1.100/public) specified");
1697                 rc = -EINVAL;
1698                 goto out_err;
1699         }
1700
1701         /* see if we already have a matching tcp_ses */
1702         tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1703         if (tcp_ses)
1704                 return tcp_ses;
1705
1706         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1707         if (!tcp_ses) {
1708                 rc = -ENOMEM;
1709                 goto out_err;
1710         }
1711
1712         rc = cifs_crypto_shash_allocate(tcp_ses);
1713         if (rc) {
1714                 cERROR(1, "could not setup hash structures rc %d", rc);
1715                 goto out_err;
1716         }
1717
1718         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1719         tcp_ses->hostname = extract_hostname(volume_info->UNC);
1720         if (IS_ERR(tcp_ses->hostname)) {
1721                 rc = PTR_ERR(tcp_ses->hostname);
1722                 goto out_err_crypto_release;
1723         }
1724
1725         tcp_ses->noblocksnd = volume_info->noblocksnd;
1726         tcp_ses->noautotune = volume_info->noautotune;
1727         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1728         atomic_set(&tcp_ses->inFlight, 0);
1729         init_waitqueue_head(&tcp_ses->response_q);
1730         init_waitqueue_head(&tcp_ses->request_q);
1731         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1732         mutex_init(&tcp_ses->srv_mutex);
1733         memcpy(tcp_ses->workstation_RFC1001_name,
1734                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1735         memcpy(tcp_ses->server_RFC1001_name,
1736                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1737         tcp_ses->session_estab = false;
1738         tcp_ses->sequence_number = 0;
1739         tcp_ses->lstrp = jiffies;
1740         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1741         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1742         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1743
1744         /*
1745          * at this point we are the only ones with the pointer
1746          * to the struct since the kernel thread not created yet
1747          * no need to spinlock this init of tcpStatus or srv_count
1748          */
1749         tcp_ses->tcpStatus = CifsNew;
1750         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1751                sizeof(tcp_ses->srcaddr));
1752         ++tcp_ses->srv_count;
1753
1754         if (addr.ss_family == AF_INET6) {
1755                 cFYI(1, "attempting ipv6 connect");
1756                 /* BB should we allow ipv6 on port 139? */
1757                 /* other OS never observed in Wild doing 139 with v6 */
1758                 memcpy(&tcp_ses->dstaddr, sin_server6,
1759                        sizeof(struct sockaddr_in6));
1760         } else
1761                 memcpy(&tcp_ses->dstaddr, sin_server,
1762                        sizeof(struct sockaddr_in));
1763
1764         rc = ip_connect(tcp_ses);
1765         if (rc < 0) {
1766                 cERROR(1, "Error connecting to socket. Aborting operation");
1767                 goto out_err_crypto_release;
1768         }
1769
1770         /*
1771          * since we're in a cifs function already, we know that
1772          * this will succeed. No need for try_module_get().
1773          */
1774         __module_get(THIS_MODULE);
1775         tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1776                                   tcp_ses, "cifsd");
1777         if (IS_ERR(tcp_ses->tsk)) {
1778                 rc = PTR_ERR(tcp_ses->tsk);
1779                 cERROR(1, "error %d create cifsd thread", rc);
1780                 module_put(THIS_MODULE);
1781                 goto out_err_crypto_release;
1782         }
1783         tcp_ses->tcpStatus = CifsNeedNegotiate;
1784
1785         /* thread spawned, put it on the list */
1786         spin_lock(&cifs_tcp_ses_lock);
1787         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1788         spin_unlock(&cifs_tcp_ses_lock);
1789
1790         cifs_fscache_get_client_cookie(tcp_ses);
1791
1792         /* queue echo request delayed work */
1793         queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1794
1795         return tcp_ses;
1796
1797 out_err_crypto_release:
1798         cifs_crypto_shash_release(tcp_ses);
1799
1800         put_net(cifs_net_ns(tcp_ses));
1801
1802 out_err:
1803         if (tcp_ses) {
1804                 if (!IS_ERR(tcp_ses->hostname))
1805                         kfree(tcp_ses->hostname);
1806                 if (tcp_ses->ssocket)
1807                         sock_release(tcp_ses->ssocket);
1808                 kfree(tcp_ses);
1809         }
1810         return ERR_PTR(rc);
1811 }
1812
1813 static struct cifsSesInfo *
1814 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1815 {
1816         struct cifsSesInfo *ses;
1817
1818         spin_lock(&cifs_tcp_ses_lock);
1819         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1820                 switch (server->secType) {
1821                 case Kerberos:
1822                         if (vol->cred_uid != ses->cred_uid)
1823                                 continue;
1824                         break;
1825                 default:
1826                         /* anything else takes username/password */
1827                         if (ses->user_name == NULL)
1828                                 continue;
1829                         if (strncmp(ses->user_name, vol->username,
1830                                     MAX_USERNAME_SIZE))
1831                                 continue;
1832                         if (strlen(vol->username) != 0 &&
1833                             ses->password != NULL &&
1834                             strncmp(ses->password,
1835                                     vol->password ? vol->password : "",
1836                                     MAX_PASSWORD_SIZE))
1837                                 continue;
1838                 }
1839                 ++ses->ses_count;
1840                 spin_unlock(&cifs_tcp_ses_lock);
1841                 return ses;
1842         }
1843         spin_unlock(&cifs_tcp_ses_lock);
1844         return NULL;
1845 }
1846
1847 static void
1848 cifs_put_smb_ses(struct cifsSesInfo *ses)
1849 {
1850         int xid;
1851         struct TCP_Server_Info *server = ses->server;
1852
1853         cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1854         spin_lock(&cifs_tcp_ses_lock);
1855         if (--ses->ses_count > 0) {
1856                 spin_unlock(&cifs_tcp_ses_lock);
1857                 return;
1858         }
1859
1860         list_del_init(&ses->smb_ses_list);
1861         spin_unlock(&cifs_tcp_ses_lock);
1862
1863         if (ses->status == CifsGood) {
1864                 xid = GetXid();
1865                 CIFSSMBLogoff(xid, ses);
1866                 _FreeXid(xid);
1867         }
1868         sesInfoFree(ses);
1869         cifs_put_tcp_session(server);
1870 }
1871
1872 static bool warned_on_ntlm;  /* globals init to false automatically */
1873
1874 static struct cifsSesInfo *
1875 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1876 {
1877         int rc = -ENOMEM, xid;
1878         struct cifsSesInfo *ses;
1879         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1880         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1881
1882         xid = GetXid();
1883
1884         ses = cifs_find_smb_ses(server, volume_info);
1885         if (ses) {
1886                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1887
1888                 mutex_lock(&ses->session_mutex);
1889                 rc = cifs_negotiate_protocol(xid, ses);
1890                 if (rc) {
1891                         mutex_unlock(&ses->session_mutex);
1892                         /* problem -- put our ses reference */
1893                         cifs_put_smb_ses(ses);
1894                         FreeXid(xid);
1895                         return ERR_PTR(rc);
1896                 }
1897                 if (ses->need_reconnect) {
1898                         cFYI(1, "Session needs reconnect");
1899                         rc = cifs_setup_session(xid, ses,
1900                                                 volume_info->local_nls);
1901                         if (rc) {
1902                                 mutex_unlock(&ses->session_mutex);
1903                                 /* problem -- put our reference */
1904                                 cifs_put_smb_ses(ses);
1905                                 FreeXid(xid);
1906                                 return ERR_PTR(rc);
1907                         }
1908                 }
1909                 mutex_unlock(&ses->session_mutex);
1910
1911                 /* existing SMB ses has a server reference already */
1912                 cifs_put_tcp_session(server);
1913                 FreeXid(xid);
1914                 return ses;
1915         }
1916
1917         cFYI(1, "Existing smb sess not found");
1918         ses = sesInfoAlloc();
1919         if (ses == NULL)
1920                 goto get_ses_fail;
1921
1922         /* new SMB session uses our server ref */
1923         ses->server = server;
1924         if (server->dstaddr.ss_family == AF_INET6)
1925                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1926         else
1927                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1928
1929         if (volume_info->username) {
1930                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1931                 if (!ses->user_name)
1932                         goto get_ses_fail;
1933         }
1934
1935         /* volume_info->password freed at unmount */
1936         if (volume_info->password) {
1937                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1938                 if (!ses->password)
1939                         goto get_ses_fail;
1940         }
1941         if (volume_info->domainname) {
1942                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1943                 if (!ses->domainName)
1944                         goto get_ses_fail;
1945         }
1946         ses->cred_uid = volume_info->cred_uid;
1947         ses->linux_uid = volume_info->linux_uid;
1948
1949         /* ntlmv2 is much stronger than ntlm security, and has been broadly
1950         supported for many years, time to update default security mechanism */
1951         if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1952                 warned_on_ntlm = true;
1953                 cERROR(1, "default security mechanism requested.  The default "
1954                         "security mechanism will be upgraded from ntlm to "
1955                         "ntlmv2 in kernel release 2.6.41");
1956         }
1957         ses->overrideSecFlg = volume_info->secFlg;
1958
1959         mutex_lock(&ses->session_mutex);
1960         rc = cifs_negotiate_protocol(xid, ses);
1961         if (!rc)
1962                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1963         mutex_unlock(&ses->session_mutex);
1964         if (rc)
1965                 goto get_ses_fail;
1966
1967         /* success, put it on the list */
1968         spin_lock(&cifs_tcp_ses_lock);
1969         list_add(&ses->smb_ses_list, &server->smb_ses_list);
1970         spin_unlock(&cifs_tcp_ses_lock);
1971
1972         FreeXid(xid);
1973         return ses;
1974
1975 get_ses_fail:
1976         sesInfoFree(ses);
1977         FreeXid(xid);
1978         return ERR_PTR(rc);
1979 }
1980
1981 static struct cifsTconInfo *
1982 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1983 {
1984         struct list_head *tmp;
1985         struct cifsTconInfo *tcon;
1986
1987         spin_lock(&cifs_tcp_ses_lock);
1988         list_for_each(tmp, &ses->tcon_list) {
1989                 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1990                 if (tcon->tidStatus == CifsExiting)
1991                         continue;
1992                 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1993                         continue;
1994
1995                 ++tcon->tc_count;
1996                 spin_unlock(&cifs_tcp_ses_lock);
1997                 return tcon;
1998         }
1999         spin_unlock(&cifs_tcp_ses_lock);
2000         return NULL;
2001 }
2002
2003 static void
2004 cifs_put_tcon(struct cifsTconInfo *tcon)
2005 {
2006         int xid;
2007         struct cifsSesInfo *ses = tcon->ses;
2008
2009         cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2010         spin_lock(&cifs_tcp_ses_lock);
2011         if (--tcon->tc_count > 0) {
2012                 spin_unlock(&cifs_tcp_ses_lock);
2013                 return;
2014         }
2015
2016         list_del_init(&tcon->tcon_list);
2017         spin_unlock(&cifs_tcp_ses_lock);
2018
2019         xid = GetXid();
2020         CIFSSMBTDis(xid, tcon);
2021         _FreeXid(xid);
2022
2023         cifs_fscache_release_super_cookie(tcon);
2024         tconInfoFree(tcon);
2025         cifs_put_smb_ses(ses);
2026 }
2027
2028 static struct cifsTconInfo *
2029 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
2030 {
2031         int rc, xid;
2032         struct cifsTconInfo *tcon;
2033
2034         tcon = cifs_find_tcon(ses, volume_info->UNC);
2035         if (tcon) {
2036                 cFYI(1, "Found match on UNC path");
2037                 /* existing tcon already has a reference */
2038                 cifs_put_smb_ses(ses);
2039                 if (tcon->seal != volume_info->seal)
2040                         cERROR(1, "transport encryption setting "
2041                                    "conflicts with existing tid");
2042                 return tcon;
2043         }
2044
2045         tcon = tconInfoAlloc();
2046         if (tcon == NULL) {
2047                 rc = -ENOMEM;
2048                 goto out_fail;
2049         }
2050
2051         tcon->ses = ses;
2052         if (volume_info->password) {
2053                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2054                 if (!tcon->password) {
2055                         rc = -ENOMEM;
2056                         goto out_fail;
2057                 }
2058         }
2059
2060         if (strchr(volume_info->UNC + 3, '\\') == NULL
2061             && strchr(volume_info->UNC + 3, '/') == NULL) {
2062                 cERROR(1, "Missing share name");
2063                 rc = -ENODEV;
2064                 goto out_fail;
2065         }
2066
2067         /* BB Do we need to wrap session_mutex around
2068          * this TCon call and Unix SetFS as
2069          * we do on SessSetup and reconnect? */
2070         xid = GetXid();
2071         rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2072         FreeXid(xid);
2073         cFYI(1, "CIFS Tcon rc = %d", rc);
2074         if (rc)
2075                 goto out_fail;
2076
2077         if (volume_info->nodfs) {
2078                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2079                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2080         }
2081         tcon->seal = volume_info->seal;
2082         /* we can have only one retry value for a connection
2083            to a share so for resources mounted more than once
2084            to the same server share the last value passed in
2085            for the retry flag is used */
2086         tcon->retry = volume_info->retry;
2087         tcon->nocase = volume_info->nocase;
2088         tcon->local_lease = volume_info->local_lease;
2089
2090         spin_lock(&cifs_tcp_ses_lock);
2091         list_add(&tcon->tcon_list, &ses->tcon_list);
2092         spin_unlock(&cifs_tcp_ses_lock);
2093
2094         cifs_fscache_get_super_cookie(tcon);
2095
2096         return tcon;
2097
2098 out_fail:
2099         tconInfoFree(tcon);
2100         return ERR_PTR(rc);
2101 }
2102
2103 void
2104 cifs_put_tlink(struct tcon_link *tlink)
2105 {
2106         if (!tlink || IS_ERR(tlink))
2107                 return;
2108
2109         if (!atomic_dec_and_test(&tlink->tl_count) ||
2110             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2111                 tlink->tl_time = jiffies;
2112                 return;
2113         }
2114
2115         if (!IS_ERR(tlink_tcon(tlink)))
2116                 cifs_put_tcon(tlink_tcon(tlink));
2117         kfree(tlink);
2118         return;
2119 }
2120
2121 int
2122 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2123              const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2124              struct dfs_info3_param **preferrals, int remap)
2125 {
2126         char *temp_unc;
2127         int rc = 0;
2128
2129         *pnum_referrals = 0;
2130         *preferrals = NULL;
2131
2132         if (pSesInfo->ipc_tid == 0) {
2133                 temp_unc = kmalloc(2 /* for slashes */ +
2134                         strnlen(pSesInfo->serverName,
2135                                 SERVER_NAME_LEN_WITH_NULL * 2)
2136                                  + 1 + 4 /* slash IPC$ */  + 2,
2137                                 GFP_KERNEL);
2138                 if (temp_unc == NULL)
2139                         return -ENOMEM;
2140                 temp_unc[0] = '\\';
2141                 temp_unc[1] = '\\';
2142                 strcpy(temp_unc + 2, pSesInfo->serverName);
2143                 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2144                 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2145                 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2146                 kfree(temp_unc);
2147         }
2148         if (rc == 0)
2149                 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2150                                      pnum_referrals, nls_codepage, remap);
2151         /* BB map targetUNCs to dfs_info3 structures, here or
2152                 in CIFSGetDFSRefer BB */
2153
2154         return rc;
2155 }
2156
2157 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2158 static struct lock_class_key cifs_key[2];
2159 static struct lock_class_key cifs_slock_key[2];
2160
2161 static inline void
2162 cifs_reclassify_socket4(struct socket *sock)
2163 {
2164         struct sock *sk = sock->sk;
2165         BUG_ON(sock_owned_by_user(sk));
2166         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2167                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2168 }
2169
2170 static inline void
2171 cifs_reclassify_socket6(struct socket *sock)
2172 {
2173         struct sock *sk = sock->sk;
2174         BUG_ON(sock_owned_by_user(sk));
2175         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2176                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2177 }
2178 #else
2179 static inline void
2180 cifs_reclassify_socket4(struct socket *sock)
2181 {
2182 }
2183
2184 static inline void
2185 cifs_reclassify_socket6(struct socket *sock)
2186 {
2187 }
2188 #endif
2189
2190 /* See RFC1001 section 14 on representation of Netbios names */
2191 static void rfc1002mangle(char *target, char *source, unsigned int length)
2192 {
2193         unsigned int i, j;
2194
2195         for (i = 0, j = 0; i < (length); i++) {
2196                 /* mask a nibble at a time and encode */
2197                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2198                 target[j+1] = 'A' + (0x0F & source[i]);
2199                 j += 2;
2200         }
2201
2202 }
2203
2204 static int
2205 bind_socket(struct TCP_Server_Info *server)
2206 {
2207         int rc = 0;
2208         if (server->srcaddr.ss_family != AF_UNSPEC) {
2209                 /* Bind to the specified local IP address */
2210                 struct socket *socket = server->ssocket;
2211                 rc = socket->ops->bind(socket,
2212                                        (struct sockaddr *) &server->srcaddr,
2213                                        sizeof(server->srcaddr));
2214                 if (rc < 0) {
2215                         struct sockaddr_in *saddr4;
2216                         struct sockaddr_in6 *saddr6;
2217                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2218                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2219                         if (saddr6->sin6_family == AF_INET6)
2220                                 cERROR(1, "cifs: "
2221                                        "Failed to bind to: %pI6c, error: %d\n",
2222                                        &saddr6->sin6_addr, rc);
2223                         else
2224                                 cERROR(1, "cifs: "
2225                                        "Failed to bind to: %pI4, error: %d\n",
2226                                        &saddr4->sin_addr.s_addr, rc);
2227                 }
2228         }
2229         return rc;
2230 }
2231
2232 static int
2233 ip_rfc1001_connect(struct TCP_Server_Info *server)
2234 {
2235         int rc = 0;
2236         /*
2237          * some servers require RFC1001 sessinit before sending
2238          * negprot - BB check reconnection in case where second
2239          * sessinit is sent but no second negprot
2240          */
2241         struct rfc1002_session_packet *ses_init_buf;
2242         struct smb_hdr *smb_buf;
2243         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2244                                GFP_KERNEL);
2245         if (ses_init_buf) {
2246                 ses_init_buf->trailer.session_req.called_len = 32;
2247
2248                 if (server->server_RFC1001_name &&
2249                     server->server_RFC1001_name[0] != 0)
2250                         rfc1002mangle(ses_init_buf->trailer.
2251                                       session_req.called_name,
2252                                       server->server_RFC1001_name,
2253                                       RFC1001_NAME_LEN_WITH_NULL);
2254                 else
2255                         rfc1002mangle(ses_init_buf->trailer.
2256                                       session_req.called_name,
2257                                       DEFAULT_CIFS_CALLED_NAME,
2258                                       RFC1001_NAME_LEN_WITH_NULL);
2259
2260                 ses_init_buf->trailer.session_req.calling_len = 32;
2261
2262                 /*
2263                  * calling name ends in null (byte 16) from old smb
2264                  * convention.
2265                  */
2266                 if (server->workstation_RFC1001_name &&
2267                     server->workstation_RFC1001_name[0] != 0)
2268                         rfc1002mangle(ses_init_buf->trailer.
2269                                       session_req.calling_name,
2270                                       server->workstation_RFC1001_name,
2271                                       RFC1001_NAME_LEN_WITH_NULL);
2272                 else
2273                         rfc1002mangle(ses_init_buf->trailer.
2274                                       session_req.calling_name,
2275                                       "LINUX_CIFS_CLNT",
2276                                       RFC1001_NAME_LEN_WITH_NULL);
2277
2278                 ses_init_buf->trailer.session_req.scope1 = 0;
2279                 ses_init_buf->trailer.session_req.scope2 = 0;
2280                 smb_buf = (struct smb_hdr *)ses_init_buf;
2281
2282                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2283                 smb_buf->smb_buf_length = 0x81000044;
2284                 rc = smb_send(server, smb_buf, 0x44);
2285                 kfree(ses_init_buf);
2286                 /*
2287                  * RFC1001 layer in at least one server
2288                  * requires very short break before negprot
2289                  * presumably because not expecting negprot
2290                  * to follow so fast.  This is a simple
2291                  * solution that works without
2292                  * complicating the code and causes no
2293                  * significant slowing down on mount
2294                  * for everyone else
2295                  */
2296                 usleep_range(1000, 2000);
2297         }
2298         /*
2299          * else the negprot may still work without this
2300          * even though malloc failed
2301          */
2302
2303         return rc;
2304 }
2305
2306 static int
2307 generic_ip_connect(struct TCP_Server_Info *server)
2308 {
2309         int rc = 0;
2310         __be16 sport;
2311         int slen, sfamily;
2312         struct socket *socket = server->ssocket;
2313         struct sockaddr *saddr;
2314
2315         saddr = (struct sockaddr *) &server->dstaddr;
2316
2317         if (server->dstaddr.ss_family == AF_INET6) {
2318                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2319                 slen = sizeof(struct sockaddr_in6);
2320                 sfamily = AF_INET6;
2321         } else {
2322                 sport = ((struct sockaddr_in *) saddr)->sin_port;
2323                 slen = sizeof(struct sockaddr_in);
2324                 sfamily = AF_INET;
2325         }
2326
2327         if (socket == NULL) {
2328                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2329                                    IPPROTO_TCP, &socket, 1);
2330                 if (rc < 0) {
2331                         cERROR(1, "Error %d creating socket", rc);
2332                         server->ssocket = NULL;
2333                         return rc;
2334                 }
2335
2336                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2337                 cFYI(1, "Socket created");
2338                 server->ssocket = socket;
2339                 socket->sk->sk_allocation = GFP_NOFS;
2340                 if (sfamily == AF_INET6)
2341                         cifs_reclassify_socket6(socket);
2342                 else
2343                         cifs_reclassify_socket4(socket);
2344         }
2345
2346         rc = bind_socket(server);
2347         if (rc < 0)
2348                 return rc;
2349
2350         rc = socket->ops->connect(socket, saddr, slen, 0);
2351         if (rc < 0) {
2352                 cFYI(1, "Error %d connecting to server", rc);
2353                 sock_release(socket);
2354                 server->ssocket = NULL;
2355                 return rc;
2356         }
2357
2358         /*
2359          * Eventually check for other socket options to change from
2360          * the default. sock_setsockopt not used because it expects
2361          * user space buffer
2362          */
2363         socket->sk->sk_rcvtimeo = 7 * HZ;
2364         socket->sk->sk_sndtimeo = 5 * HZ;
2365
2366         /* make the bufsizes depend on wsize/rsize and max requests */
2367         if (server->noautotune) {
2368                 if (socket->sk->sk_sndbuf < (200 * 1024))
2369                         socket->sk->sk_sndbuf = 200 * 1024;
2370                 if (socket->sk->sk_rcvbuf < (140 * 1024))
2371                         socket->sk->sk_rcvbuf = 140 * 1024;
2372         }
2373
2374         if (server->tcp_nodelay) {
2375                 int val = 1;
2376                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2377                                 (char *)&val, sizeof(val));
2378                 if (rc)
2379                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2380         }
2381
2382          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2383                  socket->sk->sk_sndbuf,
2384                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2385
2386         if (sport == htons(RFC1001_PORT))
2387                 rc = ip_rfc1001_connect(server);
2388
2389         return rc;
2390 }
2391
2392 static int
2393 ip_connect(struct TCP_Server_Info *server)
2394 {
2395         __be16 *sport;
2396         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2397         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2398
2399         if (server->dstaddr.ss_family == AF_INET6)
2400                 sport = &addr6->sin6_port;
2401         else
2402                 sport = &addr->sin_port;
2403
2404         if (*sport == 0) {
2405                 int rc;
2406
2407                 /* try with 445 port at first */
2408                 *sport = htons(CIFS_PORT);
2409
2410                 rc = generic_ip_connect(server);
2411                 if (rc >= 0)
2412                         return rc;
2413
2414                 /* if it failed, try with 139 port */
2415                 *sport = htons(RFC1001_PORT);
2416         }
2417
2418         return generic_ip_connect(server);
2419 }
2420
2421 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2422                           struct super_block *sb, struct smb_vol *vol_info)
2423 {
2424         /* if we are reconnecting then should we check to see if
2425          * any requested capabilities changed locally e.g. via
2426          * remount but we can not do much about it here
2427          * if they have (even if we could detect it by the following)
2428          * Perhaps we could add a backpointer to array of sb from tcon
2429          * or if we change to make all sb to same share the same
2430          * sb as NFS - then we only have one backpointer to sb.
2431          * What if we wanted to mount the server share twice once with
2432          * and once without posixacls or posix paths? */
2433         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2434
2435         if (vol_info && vol_info->no_linux_ext) {
2436                 tcon->fsUnixInfo.Capability = 0;
2437                 tcon->unix_ext = 0; /* Unix Extensions disabled */
2438                 cFYI(1, "Linux protocol extensions disabled");
2439                 return;
2440         } else if (vol_info)
2441                 tcon->unix_ext = 1; /* Unix Extensions supported */
2442
2443         if (tcon->unix_ext == 0) {
2444                 cFYI(1, "Unix extensions disabled so not set on reconnect");
2445                 return;
2446         }
2447
2448         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2449                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2450
2451                 /* check for reconnect case in which we do not
2452                    want to change the mount behavior if we can avoid it */
2453                 if (vol_info == NULL) {
2454                         /* turn off POSIX ACL and PATHNAMES if not set
2455                            originally at mount time */
2456                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2457                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2458                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2459                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2460                                         cERROR(1, "POSIXPATH support change");
2461                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2462                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2463                                 cERROR(1, "possible reconnect error");
2464                                 cERROR(1, "server disabled POSIX path support");
2465                         }
2466                 }
2467
2468                 cap &= CIFS_UNIX_CAP_MASK;
2469                 if (vol_info && vol_info->no_psx_acl)
2470                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2471                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2472                         cFYI(1, "negotiated posix acl support");
2473                         if (sb)
2474                                 sb->s_flags |= MS_POSIXACL;
2475                 }
2476
2477                 if (vol_info && vol_info->posix_paths == 0)
2478                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2479                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2480                         cFYI(1, "negotiate posix pathnames");
2481                         if (sb)
2482                                 CIFS_SB(sb)->mnt_cifs_flags |=
2483                                         CIFS_MOUNT_POSIX_PATHS;
2484                 }
2485
2486                 /* We might be setting the path sep back to a different
2487                 form if we are reconnecting and the server switched its
2488                 posix path capability for this share */
2489                 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2490                         CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2491
2492                 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2493                         if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2494                                 CIFS_SB(sb)->rsize = 127 * 1024;
2495                                 cFYI(DBG2, "larger reads not supported by srv");
2496                         }
2497                 }
2498
2499
2500                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2501 #ifdef CONFIG_CIFS_DEBUG2
2502                 if (cap & CIFS_UNIX_FCNTL_CAP)
2503                         cFYI(1, "FCNTL cap");
2504                 if (cap & CIFS_UNIX_EXTATTR_CAP)
2505                         cFYI(1, "EXTATTR cap");
2506                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2507                         cFYI(1, "POSIX path cap");
2508                 if (cap & CIFS_UNIX_XATTR_CAP)
2509                         cFYI(1, "XATTR cap");
2510                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2511                         cFYI(1, "POSIX ACL cap");
2512                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2513                         cFYI(1, "very large read cap");
2514                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2515                         cFYI(1, "very large write cap");
2516 #endif /* CIFS_DEBUG2 */
2517                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2518                         if (vol_info == NULL) {
2519                                 cFYI(1, "resetting capabilities failed");
2520                         } else
2521                                 cERROR(1, "Negotiating Unix capabilities "
2522                                            "with the server failed.  Consider "
2523                                            "mounting with the Unix Extensions\n"
2524                                            "disabled, if problems are found, "
2525                                            "by specifying the nounix mount "
2526                                            "option.");
2527
2528                 }
2529         }
2530 }
2531
2532 static void
2533 convert_delimiter(char *path, char delim)
2534 {
2535         int i;
2536         char old_delim;
2537
2538         if (path == NULL)
2539                 return;
2540
2541         if (delim == '/')
2542                 old_delim = '\\';
2543         else
2544                 old_delim = '/';
2545
2546         for (i = 0; path[i] != '\0'; i++) {
2547                 if (path[i] == old_delim)
2548                         path[i] = delim;
2549         }
2550 }
2551
2552 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2553                           struct cifs_sb_info *cifs_sb)
2554 {
2555         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2556
2557         if (pvolume_info->rsize > CIFSMaxBufSize) {
2558                 cERROR(1, "rsize %d too large, using MaxBufSize",
2559                         pvolume_info->rsize);
2560                 cifs_sb->rsize = CIFSMaxBufSize;
2561         } else if ((pvolume_info->rsize) &&
2562                         (pvolume_info->rsize <= CIFSMaxBufSize))
2563                 cifs_sb->rsize = pvolume_info->rsize;
2564         else /* default */
2565                 cifs_sb->rsize = CIFSMaxBufSize;
2566
2567         if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2568                 cERROR(1, "wsize %d too large, using 4096 instead",
2569                           pvolume_info->wsize);
2570                 cifs_sb->wsize = 4096;
2571         } else if (pvolume_info->wsize)
2572                 cifs_sb->wsize = pvolume_info->wsize;
2573         else
2574                 cifs_sb->wsize = min_t(const int,
2575                                         PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2576                                         127*1024);
2577                 /* old default of CIFSMaxBufSize was too small now
2578                    that SMB Write2 can send multiple pages in kvec.
2579                    RFC1001 does not describe what happens when frame
2580                    bigger than 128K is sent so use that as max in
2581                    conjunction with 52K kvec constraint on arch with 4K
2582                    page size  */
2583
2584         if (cifs_sb->rsize < 2048) {
2585                 cifs_sb->rsize = 2048;
2586                 /* Windows ME may prefer this */
2587                 cFYI(1, "readsize set to minimum: 2048");
2588         }
2589         /* calculate prepath */
2590         cifs_sb->prepath = pvolume_info->prepath;
2591         if (cifs_sb->prepath) {
2592                 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2593                 /* we can not convert the / to \ in the path
2594                 separators in the prefixpath yet because we do not
2595                 know (until reset_cifs_unix_caps is called later)
2596                 whether POSIX PATH CAP is available. We normalize
2597                 the / to \ after reset_cifs_unix_caps is called */
2598                 pvolume_info->prepath = NULL;
2599         } else
2600                 cifs_sb->prepathlen = 0;
2601         cifs_sb->mnt_uid = pvolume_info->linux_uid;
2602         cifs_sb->mnt_gid = pvolume_info->linux_gid;
2603         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2604         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2605         cFYI(1, "file mode: 0x%x  dir mode: 0x%x",
2606                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2607
2608         cifs_sb->actimeo = pvolume_info->actimeo;
2609
2610         if (pvolume_info->noperm)
2611                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2612         if (pvolume_info->setuids)
2613                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2614         if (pvolume_info->server_ino)
2615                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2616         if (pvolume_info->remap)
2617                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2618         if (pvolume_info->no_xattr)
2619                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2620         if (pvolume_info->sfu_emul)
2621                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2622         if (pvolume_info->nobrl)
2623                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2624         if (pvolume_info->nostrictsync)
2625                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2626         if (pvolume_info->mand_lock)
2627                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2628         if (pvolume_info->cifs_acl)
2629                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2630         if (pvolume_info->override_uid)
2631                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2632         if (pvolume_info->override_gid)
2633                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2634         if (pvolume_info->dynperm)
2635                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2636         if (pvolume_info->fsc)
2637                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2638         if (pvolume_info->multiuser)
2639                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2640                                             CIFS_MOUNT_NO_PERM);
2641         if (pvolume_info->strict_io)
2642                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2643         if (pvolume_info->direct_io) {
2644                 cFYI(1, "mounting share using direct i/o");
2645                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2646         }
2647         if (pvolume_info->mfsymlinks) {
2648                 if (pvolume_info->sfu_emul) {
2649                         cERROR(1,  "mount option mfsymlinks ignored if sfu "
2650                                    "mount option is used");
2651                 } else {
2652                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2653                 }
2654         }
2655
2656         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2657                 cERROR(1, "mount option dynperm ignored if cifsacl "
2658                            "mount option supported");
2659 }
2660
2661 static int
2662 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2663                    struct cifs_sb_info *cifs_sb, const char *full_path)
2664 {
2665         int rc;
2666         FILE_ALL_INFO *pfile_info;
2667
2668         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2669         if (pfile_info == NULL)
2670                 return -ENOMEM;
2671
2672         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2673                               0 /* not legacy */, cifs_sb->local_nls,
2674                               cifs_sb->mnt_cifs_flags &
2675                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2676         kfree(pfile_info);
2677         return rc;
2678 }
2679
2680 static void
2681 cleanup_volume_info(struct smb_vol **pvolume_info)
2682 {
2683         struct smb_vol *volume_info;
2684
2685         if (!pvolume_info || !*pvolume_info)
2686                 return;
2687
2688         volume_info = *pvolume_info;
2689         kzfree(volume_info->password);
2690         kfree(volume_info->UNC);
2691         kfree(volume_info->prepath);
2692         kfree(volume_info);
2693         *pvolume_info = NULL;
2694         return;
2695 }
2696
2697 #ifdef CONFIG_CIFS_DFS_UPCALL
2698 /* build_path_to_root returns full path to root when
2699  * we do not have an exiting connection (tcon) */
2700 static char *
2701 build_unc_path_to_root(const struct smb_vol *volume_info,
2702                 const struct cifs_sb_info *cifs_sb)
2703 {
2704         char *full_path;
2705
2706         int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2707         full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2708         if (full_path == NULL)
2709                 return ERR_PTR(-ENOMEM);
2710
2711         strncpy(full_path, volume_info->UNC, unc_len);
2712         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2713                 int i;
2714                 for (i = 0; i < unc_len; i++) {
2715                         if (full_path[i] == '\\')
2716                                 full_path[i] = '/';
2717                 }
2718         }
2719
2720         if (cifs_sb->prepathlen)
2721                 strncpy(full_path + unc_len, cifs_sb->prepath,
2722                                 cifs_sb->prepathlen);
2723
2724         full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2725         return full_path;
2726 }
2727 #endif
2728
2729 int
2730 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2731                 char *mount_data_global, const char *devname)
2732 {
2733         int rc;
2734         int xid;
2735         struct smb_vol *volume_info;
2736         struct cifsSesInfo *pSesInfo;
2737         struct cifsTconInfo *tcon;
2738         struct TCP_Server_Info *srvTcp;
2739         char   *full_path;
2740         char *mount_data = mount_data_global;
2741         struct tcon_link *tlink;
2742 #ifdef CONFIG_CIFS_DFS_UPCALL
2743         struct dfs_info3_param *referrals = NULL;
2744         unsigned int num_referrals = 0;
2745         int referral_walks_count = 0;
2746 try_mount_again:
2747 #endif
2748         rc = 0;
2749         tcon = NULL;
2750         pSesInfo = NULL;
2751         srvTcp = NULL;
2752         full_path = NULL;
2753         tlink = NULL;
2754
2755         xid = GetXid();
2756
2757         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2758         if (!volume_info) {
2759                 rc = -ENOMEM;
2760                 goto out;
2761         }
2762
2763         if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2764                 rc = -EINVAL;
2765                 goto out;
2766         }
2767
2768         if (volume_info->nullauth) {
2769                 cFYI(1, "null user");
2770                 volume_info->username = "";
2771         } else if (volume_info->username) {
2772                 /* BB fixme parse for domain name here */
2773                 cFYI(1, "Username: %s", volume_info->username);
2774         } else {
2775                 cifserror("No username specified");
2776         /* In userspace mount helper we can get user name from alternate
2777            locations such as env variables and files on disk */
2778                 rc = -EINVAL;
2779                 goto out;
2780         }
2781
2782         /* this is needed for ASCII cp to Unicode converts */
2783         if (volume_info->iocharset == NULL) {
2784                 /* load_nls_default cannot return null */
2785                 volume_info->local_nls = load_nls_default();
2786         } else {
2787                 volume_info->local_nls = load_nls(volume_info->iocharset);
2788                 if (volume_info->local_nls == NULL) {
2789                         cERROR(1, "CIFS mount error: iocharset %s not found",
2790                                  volume_info->iocharset);
2791                         rc = -ELIBACC;
2792                         goto out;
2793                 }
2794         }
2795         cifs_sb->local_nls = volume_info->local_nls;
2796
2797         /* get a reference to a tcp session */
2798         srvTcp = cifs_get_tcp_session(volume_info);
2799         if (IS_ERR(srvTcp)) {
2800                 rc = PTR_ERR(srvTcp);
2801                 goto out;
2802         }
2803
2804         /* get a reference to a SMB session */
2805         pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2806         if (IS_ERR(pSesInfo)) {
2807                 rc = PTR_ERR(pSesInfo);
2808                 pSesInfo = NULL;
2809                 goto mount_fail_check;
2810         }
2811
2812         setup_cifs_sb(volume_info, cifs_sb);
2813         if (pSesInfo->capabilities & CAP_LARGE_FILES)
2814                 sb->s_maxbytes = MAX_LFS_FILESIZE;
2815         else
2816                 sb->s_maxbytes = MAX_NON_LFS;
2817
2818         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2819         sb->s_time_gran = 100;
2820
2821         /* search for existing tcon to this server share */
2822         tcon = cifs_get_tcon(pSesInfo, volume_info);
2823         if (IS_ERR(tcon)) {
2824                 rc = PTR_ERR(tcon);
2825                 tcon = NULL;
2826                 goto remote_path_check;
2827         }
2828
2829         /* do not care if following two calls succeed - informational */
2830         if (!tcon->ipc) {
2831                 CIFSSMBQFSDeviceInfo(xid, tcon);
2832                 CIFSSMBQFSAttributeInfo(xid, tcon);
2833         }
2834
2835         /* tell server which Unix caps we support */
2836         if (tcon->ses->capabilities & CAP_UNIX)
2837                 /* reset of caps checks mount to see if unix extensions
2838                    disabled for just this mount */
2839                 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2840         else
2841                 tcon->unix_ext = 0; /* server does not support them */
2842
2843         /* convert forward to back slashes in prepath here if needed */
2844         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2845                 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2846
2847         if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2848                 cifs_sb->rsize = 1024 * 127;
2849                 cFYI(DBG2, "no very large read support, rsize now 127K");
2850         }
2851         if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2852                 cifs_sb->wsize = min(cifs_sb->wsize,
2853                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2854         if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2855                 cifs_sb->rsize = min(cifs_sb->rsize,
2856                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2857
2858 remote_path_check:
2859         /* check if a whole path (including prepath) is not remote */
2860         if (!rc && tcon) {
2861                 /* build_path_to_root works only when we have a valid tcon */
2862                 full_path = cifs_build_path_to_root(cifs_sb, tcon);
2863                 if (full_path == NULL) {
2864                         rc = -ENOMEM;
2865                         goto mount_fail_check;
2866                 }
2867                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2868                 if (rc != 0 && rc != -EREMOTE) {
2869                         kfree(full_path);
2870                         goto mount_fail_check;
2871                 }
2872                 kfree(full_path);
2873         }
2874
2875         /* get referral if needed */
2876         if (rc == -EREMOTE) {
2877 #ifdef CONFIG_CIFS_DFS_UPCALL
2878                 if (referral_walks_count > MAX_NESTED_LINKS) {
2879                         /*
2880                          * BB: when we implement proper loop detection,
2881                          *     we will remove this check. But now we need it
2882                          *     to prevent an indefinite loop if 'DFS tree' is
2883                          *     misconfigured (i.e. has loops).
2884                          */
2885                         rc = -ELOOP;
2886                         goto mount_fail_check;
2887                 }
2888                 /* convert forward to back slashes in prepath here if needed */
2889                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2890                         convert_delimiter(cifs_sb->prepath,
2891                                         CIFS_DIR_SEP(cifs_sb));
2892                 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2893                 if (IS_ERR(full_path)) {
2894                         rc = PTR_ERR(full_path);
2895                         goto mount_fail_check;
2896                 }
2897
2898                 cFYI(1, "Getting referral for: %s", full_path);
2899                 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2900                         cifs_sb->local_nls, &num_referrals, &referrals,
2901                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2902                 if (!rc && num_referrals > 0) {
2903                         char *fake_devname = NULL;
2904
2905                         if (mount_data != mount_data_global)
2906                                 kfree(mount_data);
2907
2908                         mount_data = cifs_compose_mount_options(
2909                                         cifs_sb->mountdata, full_path + 1,
2910                                         referrals, &fake_devname);
2911
2912                         free_dfs_info_array(referrals, num_referrals);
2913                         kfree(fake_devname);
2914                         kfree(full_path);
2915
2916                         if (IS_ERR(mount_data)) {
2917                                 rc = PTR_ERR(mount_data);
2918                                 mount_data = NULL;
2919                                 goto mount_fail_check;
2920                         }
2921
2922                         if (tcon)
2923                                 cifs_put_tcon(tcon);
2924                         else if (pSesInfo)
2925                                 cifs_put_smb_ses(pSesInfo);
2926
2927                         cleanup_volume_info(&volume_info);
2928                         referral_walks_count++;
2929                         FreeXid(xid);
2930                         goto try_mount_again;
2931                 }
2932 #else /* No DFS support, return error on mount */
2933                 rc = -EOPNOTSUPP;
2934 #endif
2935         }
2936
2937         if (rc)
2938                 goto mount_fail_check;
2939
2940         /* now, hang the tcon off of the superblock */
2941         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2942         if (tlink == NULL) {
2943                 rc = -ENOMEM;
2944                 goto mount_fail_check;
2945         }
2946
2947         tlink->tl_uid = pSesInfo->linux_uid;
2948         tlink->tl_tcon = tcon;
2949         tlink->tl_time = jiffies;
2950         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2951         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2952
2953         cifs_sb->master_tlink = tlink;
2954         spin_lock(&cifs_sb->tlink_tree_lock);
2955         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2956         spin_unlock(&cifs_sb->tlink_tree_lock);
2957
2958         queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2959                                 TLINK_IDLE_EXPIRE);
2960
2961 mount_fail_check:
2962         /* on error free sesinfo and tcon struct if needed */
2963         if (rc) {
2964                 if (mount_data != mount_data_global)
2965                         kfree(mount_data);
2966                 /* If find_unc succeeded then rc == 0 so we can not end */
2967                 /* up accidentally freeing someone elses tcon struct */
2968                 if (tcon)
2969                         cifs_put_tcon(tcon);
2970                 else if (pSesInfo)
2971                         cifs_put_smb_ses(pSesInfo);
2972                 else
2973                         cifs_put_tcp_session(srvTcp);
2974                 goto out;
2975         }
2976
2977         /* volume_info->password is freed above when existing session found
2978         (in which case it is not needed anymore) but when new sesion is created
2979         the password ptr is put in the new session structure (in which case the
2980         password will be freed at unmount time) */
2981 out:
2982         /* zero out password before freeing */
2983         cleanup_volume_info(&volume_info);
2984         FreeXid(xid);
2985         return rc;
2986 }
2987
2988 int
2989 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2990          const char *tree, struct cifsTconInfo *tcon,
2991          const struct nls_table *nls_codepage)
2992 {
2993         struct smb_hdr *smb_buffer;
2994         struct smb_hdr *smb_buffer_response;
2995         TCONX_REQ *pSMB;
2996         TCONX_RSP *pSMBr;
2997         unsigned char *bcc_ptr;
2998         int rc = 0;
2999         int length;
3000         __u16 bytes_left, count;
3001
3002         if (ses == NULL)
3003                 return -EIO;
3004
3005         smb_buffer = cifs_buf_get();
3006         if (smb_buffer == NULL)
3007                 return -ENOMEM;
3008
3009         smb_buffer_response = smb_buffer;
3010
3011         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3012                         NULL /*no tid */ , 4 /*wct */ );
3013
3014         smb_buffer->Mid = GetNextMid(ses->server);
3015         smb_buffer->Uid = ses->Suid;
3016         pSMB = (TCONX_REQ *) smb_buffer;
3017         pSMBr = (TCONX_RSP *) smb_buffer_response;
3018
3019         pSMB->AndXCommand = 0xFF;
3020         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3021         bcc_ptr = &pSMB->Password[0];
3022         if ((ses->server->secMode) & SECMODE_USER) {
3023                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3024                 *bcc_ptr = 0; /* password is null byte */
3025                 bcc_ptr++;              /* skip password */
3026                 /* already aligned so no need to do it below */
3027         } else {
3028                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3029                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3030                    specified as required (when that support is added to
3031                    the vfs in the future) as only NTLM or the much
3032                    weaker LANMAN (which we do not send by default) is accepted
3033                    by Samba (not sure whether other servers allow
3034                    NTLMv2 password here) */
3035 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3036                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3037                     (ses->server->secType == LANMAN))
3038                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3039                                          ses->server->secMode &
3040                                             SECMODE_PW_ENCRYPT ? true : false,
3041                                          bcc_ptr);
3042                 else
3043 #endif /* CIFS_WEAK_PW_HASH */
3044                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3045                                         bcc_ptr);
3046
3047                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3048                 if (ses->capabilities & CAP_UNICODE) {
3049                         /* must align unicode strings */
3050                         *bcc_ptr = 0; /* null byte password */
3051                         bcc_ptr++;
3052                 }
3053         }
3054
3055         if (ses->server->secMode &
3056                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3057                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3058
3059         if (ses->capabilities & CAP_STATUS32) {
3060                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3061         }
3062         if (ses->capabilities & CAP_DFS) {
3063                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3064         }
3065         if (ses->capabilities & CAP_UNICODE) {
3066                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3067                 length =
3068                     cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3069                         6 /* max utf8 char length in bytes */ *
3070                         (/* server len*/ + 256 /* share len */), nls_codepage);
3071                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3072                 bcc_ptr += 2;   /* skip trailing null */
3073         } else {                /* ASCII */
3074                 strcpy(bcc_ptr, tree);
3075                 bcc_ptr += strlen(tree) + 1;
3076         }
3077         strcpy(bcc_ptr, "?????");
3078         bcc_ptr += strlen("?????");
3079         bcc_ptr += 1;
3080         count = bcc_ptr - &pSMB->Password[0];
3081         pSMB->hdr.smb_buf_length += count;
3082         pSMB->ByteCount = cpu_to_le16(count);
3083
3084         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3085                          0);
3086
3087         /* above now done in SendReceive */
3088         if ((rc == 0) && (tcon != NULL)) {
3089                 bool is_unicode;
3090
3091                 tcon->tidStatus = CifsGood;
3092                 tcon->need_reconnect = false;
3093                 tcon->tid = smb_buffer_response->Tid;
3094                 bcc_ptr = pByteArea(smb_buffer_response);
3095                 bytes_left = get_bcc(smb_buffer_response);
3096                 length = strnlen(bcc_ptr, bytes_left - 2);
3097                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3098                         is_unicode = true;
3099                 else
3100                         is_unicode = false;
3101
3102
3103                 /* skip service field (NB: this field is always ASCII) */
3104                 if (length == 3) {
3105                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3106                             (bcc_ptr[2] == 'C')) {
3107                                 cFYI(1, "IPC connection");
3108                                 tcon->ipc = 1;
3109                         }
3110                 } else if (length == 2) {
3111                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3112                                 /* the most common case */
3113                                 cFYI(1, "disk share connection");
3114                         }
3115                 }
3116                 bcc_ptr += length + 1;
3117                 bytes_left -= (length + 1);
3118                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3119
3120                 /* mostly informational -- no need to fail on error here */
3121                 kfree(tcon->nativeFileSystem);
3122                 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3123                                                       bytes_left, is_unicode,
3124                                                       nls_codepage);
3125
3126                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3127
3128                 if ((smb_buffer_response->WordCount == 3) ||
3129                          (smb_buffer_response->WordCount == 7))
3130                         /* field is in same location */
3131                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3132                 else
3133                         tcon->Flags = 0;
3134                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3135         } else if ((rc == 0) && tcon == NULL) {
3136                 /* all we need to save for IPC$ connection */
3137                 ses->ipc_tid = smb_buffer_response->Tid;
3138         }
3139
3140         cifs_buf_release(smb_buffer);
3141         return rc;
3142 }
3143
3144 int
3145 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3146 {
3147         struct rb_root *root = &cifs_sb->tlink_tree;
3148         struct rb_node *node;
3149         struct tcon_link *tlink;
3150         char *tmp;
3151
3152         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3153
3154         spin_lock(&cifs_sb->tlink_tree_lock);
3155         while ((node = rb_first(root))) {
3156                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3157                 cifs_get_tlink(tlink);
3158                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3159                 rb_erase(node, root);
3160
3161                 spin_unlock(&cifs_sb->tlink_tree_lock);
3162                 cifs_put_tlink(tlink);
3163                 spin_lock(&cifs_sb->tlink_tree_lock);
3164         }
3165         spin_unlock(&cifs_sb->tlink_tree_lock);
3166
3167         tmp = cifs_sb->prepath;
3168         cifs_sb->prepathlen = 0;
3169         cifs_sb->prepath = NULL;
3170         kfree(tmp);
3171
3172         return 0;
3173 }
3174
3175 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3176 {
3177         int rc = 0;
3178         struct TCP_Server_Info *server = ses->server;
3179
3180         /* only send once per connect */
3181         if (server->maxBuf != 0)
3182                 return 0;
3183
3184         rc = CIFSSMBNegotiate(xid, ses);
3185         if (rc == -EAGAIN) {
3186                 /* retry only once on 1st time connection */
3187                 rc = CIFSSMBNegotiate(xid, ses);
3188                 if (rc == -EAGAIN)
3189                         rc = -EHOSTDOWN;
3190         }
3191         if (rc == 0) {
3192                 spin_lock(&GlobalMid_Lock);
3193                 if (server->tcpStatus != CifsExiting)
3194                         server->tcpStatus = CifsGood;
3195                 else
3196                         rc = -EHOSTDOWN;
3197                 spin_unlock(&GlobalMid_Lock);
3198
3199         }
3200
3201         return rc;
3202 }
3203
3204
3205 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3206                         struct nls_table *nls_info)
3207 {
3208         int rc = 0;
3209         struct TCP_Server_Info *server = ses->server;
3210
3211         ses->flags = 0;
3212         ses->capabilities = server->capabilities;
3213         if (linuxExtEnabled == 0)
3214                 ses->capabilities &= (~CAP_UNIX);
3215
3216         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3217                  server->secMode, server->capabilities, server->timeAdj);
3218
3219         rc = CIFS_SessSetup(xid, ses, nls_info);
3220         if (rc) {
3221                 cERROR(1, "Send error in SessSetup = %d", rc);
3222         } else {
3223                 mutex_lock(&ses->server->srv_mutex);
3224                 if (!server->session_estab) {
3225                         server->session_key.response = ses->auth_key.response;
3226                         server->session_key.len = ses->auth_key.len;
3227                         server->sequence_number = 0x2;
3228                         server->session_estab = true;
3229                         ses->auth_key.response = NULL;
3230                 }
3231                 mutex_unlock(&server->srv_mutex);
3232
3233                 cFYI(1, "CIFS Session Established successfully");
3234                 spin_lock(&GlobalMid_Lock);
3235                 ses->status = CifsGood;
3236                 ses->need_reconnect = false;
3237                 spin_unlock(&GlobalMid_Lock);
3238         }
3239
3240         kfree(ses->auth_key.response);
3241         ses->auth_key.response = NULL;
3242         ses->auth_key.len = 0;
3243         kfree(ses->ntlmssp);
3244         ses->ntlmssp = NULL;
3245
3246         return rc;
3247 }
3248
3249 static struct cifsTconInfo *
3250 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3251 {
3252         struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3253         struct cifsSesInfo *ses;
3254         struct cifsTconInfo *tcon = NULL;
3255         struct smb_vol *vol_info;
3256         char username[MAX_USERNAME_SIZE + 1];
3257
3258         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3259         if (vol_info == NULL) {
3260                 tcon = ERR_PTR(-ENOMEM);
3261                 goto out;
3262         }
3263
3264         snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3265         vol_info->username = username;
3266         vol_info->local_nls = cifs_sb->local_nls;
3267         vol_info->linux_uid = fsuid;
3268         vol_info->cred_uid = fsuid;
3269         vol_info->UNC = master_tcon->treeName;
3270         vol_info->retry = master_tcon->retry;
3271         vol_info->nocase = master_tcon->nocase;
3272         vol_info->local_lease = master_tcon->local_lease;
3273         vol_info->no_linux_ext = !master_tcon->unix_ext;
3274
3275         /* FIXME: allow for other secFlg settings */
3276         vol_info->secFlg = CIFSSEC_MUST_KRB5;
3277
3278         /* get a reference for the same TCP session */
3279         spin_lock(&cifs_tcp_ses_lock);
3280         ++master_tcon->ses->server->srv_count;
3281         spin_unlock(&cifs_tcp_ses_lock);
3282
3283         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3284         if (IS_ERR(ses)) {
3285                 tcon = (struct cifsTconInfo *)ses;
3286                 cifs_put_tcp_session(master_tcon->ses->server);
3287                 goto out;
3288         }
3289
3290         tcon = cifs_get_tcon(ses, vol_info);
3291         if (IS_ERR(tcon)) {
3292                 cifs_put_smb_ses(ses);
3293                 goto out;
3294         }
3295
3296         if (ses->capabilities & CAP_UNIX)
3297                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3298 out:
3299         kfree(vol_info);
3300
3301         return tcon;
3302 }
3303
3304 static inline struct tcon_link *
3305 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3306 {
3307         return cifs_sb->master_tlink;
3308 }
3309
3310 struct cifsTconInfo *
3311 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3312 {
3313         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3314 }
3315
3316 static int
3317 cifs_sb_tcon_pending_wait(void *unused)
3318 {
3319         schedule();
3320         return signal_pending(current) ? -ERESTARTSYS : 0;
3321 }
3322
3323 /* find and return a tlink with given uid */
3324 static struct tcon_link *
3325 tlink_rb_search(struct rb_root *root, uid_t uid)
3326 {
3327         struct rb_node *node = root->rb_node;
3328         struct tcon_link *tlink;
3329
3330         while (node) {
3331                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3332
3333                 if (tlink->tl_uid > uid)
3334                         node = node->rb_left;
3335                 else if (tlink->tl_uid < uid)
3336                         node = node->rb_right;
3337                 else
3338                         return tlink;
3339         }
3340         return NULL;
3341 }
3342
3343 /* insert a tcon_link into the tree */
3344 static void
3345 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3346 {
3347         struct rb_node **new = &(root->rb_node), *parent = NULL;
3348         struct tcon_link *tlink;
3349
3350         while (*new) {
3351                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3352                 parent = *new;
3353
3354                 if (tlink->tl_uid > new_tlink->tl_uid)
3355                         new = &((*new)->rb_left);
3356                 else
3357                         new = &((*new)->rb_right);
3358         }
3359
3360         rb_link_node(&new_tlink->tl_rbnode, parent, new);
3361         rb_insert_color(&new_tlink->tl_rbnode, root);
3362 }
3363
3364 /*
3365  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3366  * current task.
3367  *
3368  * If the superblock doesn't refer to a multiuser mount, then just return
3369  * the master tcon for the mount.
3370  *
3371  * First, search the rbtree for an existing tcon for this fsuid. If one
3372  * exists, then check to see if it's pending construction. If it is then wait
3373  * for construction to complete. Once it's no longer pending, check to see if
3374  * it failed and either return an error or retry construction, depending on
3375  * the timeout.
3376  *
3377  * If one doesn't exist then insert a new tcon_link struct into the tree and
3378  * try to construct a new one.
3379  */
3380 struct tcon_link *
3381 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3382 {
3383         int ret;
3384         uid_t fsuid = current_fsuid();
3385         struct tcon_link *tlink, *newtlink;
3386
3387         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3388                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3389
3390         spin_lock(&cifs_sb->tlink_tree_lock);
3391         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3392         if (tlink)
3393                 cifs_get_tlink(tlink);
3394         spin_unlock(&cifs_sb->tlink_tree_lock);
3395
3396         if (tlink == NULL) {
3397                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3398                 if (newtlink == NULL)
3399                         return ERR_PTR(-ENOMEM);
3400                 newtlink->tl_uid = fsuid;
3401                 newtlink->tl_tcon = ERR_PTR(-EACCES);
3402                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3403                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3404                 cifs_get_tlink(newtlink);
3405
3406                 spin_lock(&cifs_sb->tlink_tree_lock);
3407                 /* was one inserted after previous search? */
3408                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3409                 if (tlink) {
3410                         cifs_get_tlink(tlink);
3411                         spin_unlock(&cifs_sb->tlink_tree_lock);
3412                         kfree(newtlink);
3413                         goto wait_for_construction;
3414                 }
3415                 tlink = newtlink;
3416                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3417                 spin_unlock(&cifs_sb->tlink_tree_lock);
3418         } else {
3419 wait_for_construction:
3420                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3421                                   cifs_sb_tcon_pending_wait,
3422                                   TASK_INTERRUPTIBLE);
3423                 if (ret) {
3424                         cifs_put_tlink(tlink);
3425                         return ERR_PTR(ret);
3426                 }
3427
3428                 /* if it's good, return it */
3429                 if (!IS_ERR(tlink->tl_tcon))
3430                         return tlink;
3431
3432                 /* return error if we tried this already recently */
3433                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3434                         cifs_put_tlink(tlink);
3435                         return ERR_PTR(-EACCES);
3436                 }
3437
3438                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3439                         goto wait_for_construction;
3440         }
3441
3442         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3443         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3444         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3445
3446         if (IS_ERR(tlink->tl_tcon)) {
3447                 cifs_put_tlink(tlink);
3448                 return ERR_PTR(-EACCES);
3449         }
3450
3451         return tlink;
3452 }
3453
3454 /*
3455  * periodic workqueue job that scans tcon_tree for a superblock and closes
3456  * out tcons.
3457  */
3458 static void
3459 cifs_prune_tlinks(struct work_struct *work)
3460 {
3461         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3462                                                     prune_tlinks.work);
3463         struct rb_root *root = &cifs_sb->tlink_tree;
3464         struct rb_node *node = rb_first(root);
3465         struct rb_node *tmp;
3466         struct tcon_link *tlink;
3467
3468         /*
3469          * Because we drop the spinlock in the loop in order to put the tlink
3470          * it's not guarded against removal of links from the tree. The only
3471          * places that remove entries from the tree are this function and
3472          * umounts. Because this function is non-reentrant and is canceled
3473          * before umount can proceed, this is safe.
3474          */
3475         spin_lock(&cifs_sb->tlink_tree_lock);
3476         node = rb_first(root);
3477         while (node != NULL) {
3478                 tmp = node;
3479                 node = rb_next(tmp);
3480                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3481
3482                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3483                     atomic_read(&tlink->tl_count) != 0 ||
3484                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3485                         continue;
3486
3487                 cifs_get_tlink(tlink);
3488                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3489                 rb_erase(tmp, root);
3490
3491                 spin_unlock(&cifs_sb->tlink_tree_lock);
3492                 cifs_put_tlink(tlink);
3493                 spin_lock(&cifs_sb->tlink_tree_lock);
3494         }
3495         spin_unlock(&cifs_sb->tlink_tree_lock);
3496
3497         queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3498                                 TLINK_IDLE_EXPIRE);
3499 }