fs/cifs/connect.c

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