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