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