fs/cifs/connect.c

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