fs/cifs/connect.c

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