SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/cifs/connect.c

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