fs/cifs/connect.c

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