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