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