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