fs/cifs/connect.c

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