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