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