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