git.oblomov.eu Git - linux-2.6/blob - fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2009
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/net.h>
  23 #include <linux/string.h>
  24 #include <linux/list.h>
  25 #include <linux/wait.h>
  26 #include <linux/pagemap.h>
  27 #include <linux/ctype.h>
  28 #include <linux/utsname.h>
  29 #include <linux/mempool.h>
  30 #include <linux/delay.h>
  31 #include <linux/completion.h>
  32 #include <linux/kthread.h>
  33 #include <linux/pagevec.h>
  34 #include <linux/freezer.h>
  35 #include <linux/namei.h>
  36 #include <asm/uaccess.h>
  37 #include <asm/processor.h>
  38 #include <linux/inet.h>
  39 #include <net/ipv6.h>
  40 #include "cifspdu.h"
  41 #include "cifsglob.h"
  42 #include "cifsproto.h"
  43 #include "cifs_unicode.h"
  44 #include "cifs_debug.h"
  45 #include "cifs_fs_sb.h"
  46 #include "ntlmssp.h"
  47 #include "nterr.h"
  48 #include "rfc1002pdu.h"
  49 #include "cn_cifs.h"
  50
  51 #define CIFS_PORT 445
  52 #define RFC1001_PORT 139
  53
  54 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
  55                          unsigned char *p24);
  56
  57 extern mempool_t *cifs_req_poolp;
  58
  59 struct smb_vol {
  60         char *username;
  61         char *password;
  62         char *domainname;
  63         char *UNC;
  64         char *UNCip;
  65         char *iocharset;  /* local code page for mapping to and from Unicode */
  66         char source_rfc1001_name[16]; /* netbios name of client */
  67         char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
  68         uid_t linux_uid;
  69         gid_t linux_gid;
  70         mode_t file_mode;
  71         mode_t dir_mode;
  72         unsigned secFlg;
  73         bool rw:1;
  74         bool retry:1;
  75         bool intr:1;
  76         bool setuids:1;
  77         bool override_uid:1;
  78         bool override_gid:1;
  79         bool dynperm:1;
  80         bool noperm:1;
  81         bool no_psx_acl:1; /* set if posix acl support should be disabled */
  82         bool cifs_acl:1;
  83         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
  84         bool server_ino:1; /* use inode numbers from server ie UniqueId */
  85         bool direct_io:1;
  86         bool remap:1;      /* set to remap seven reserved chars in filenames */
  87         bool posix_paths:1; /* unset to not ask for posix pathnames. */
  88         bool no_linux_ext:1;
  89         bool sfu_emul:1;
  90         bool nullauth:1;   /* attempt to authenticate with null user */
  91         bool nocase:1;     /* request case insensitive filenames */
  92         bool nobrl:1;      /* disable sending byte range locks to srv */
  93         bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
  94         bool seal:1;       /* request transport encryption on share */
  95         bool nodfs:1;      /* Do not request DFS, even if available */
  96         bool local_lease:1; /* check leases only on local system, not remote */
  97         bool noblocksnd:1;
  98         bool noautotune:1;
  99         bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
 100         unsigned int rsize;
 101         unsigned int wsize;
 102         unsigned int sockopt;
 103         unsigned short int port;
 104         char *prepath;
 105 };
 106
 107 static int ipv4_connect(struct TCP_Server_Info *server);
 108 static int ipv6_connect(struct TCP_Server_Info *server);
 109
 110 /*
 111  * cifs tcp session reconnection
 112  *
 113  * mark tcp session as reconnecting so temporarily locked
 114  * mark all smb sessions as reconnecting for tcp session
 115  * reconnect tcp session
 116  * wake up waiters on reconnection? - (not needed currently)
 117  */
 118 static int
 119 cifs_reconnect(struct TCP_Server_Info *server)
 120 {
 121         int rc = 0;
 122         struct list_head *tmp, *tmp2;
 123         struct cifsSesInfo *ses;
 124         struct cifsTconInfo *tcon;
 125         struct mid_q_entry *mid_entry;
 126
 127         spin_lock(&GlobalMid_Lock);
 128         if (server->tcpStatus == CifsExiting) {
 129                 /* the demux thread will exit normally
 130                 next time through the loop */
 131                 spin_unlock(&GlobalMid_Lock);
 132                 return rc;
 133         } else
 134                 server->tcpStatus = CifsNeedReconnect;
 135         spin_unlock(&GlobalMid_Lock);
 136         server->maxBuf = 0;
 137
 138         cFYI(1, ("Reconnecting tcp session"));
 139
 140         /* before reconnecting the tcp session, mark the smb session (uid)
 141                 and the tid bad so they are not used until reconnected */
 142         read_lock(&cifs_tcp_ses_lock);
 143         list_for_each(tmp, &server->smb_ses_list) {
 144                 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
 145                 ses->need_reconnect = true;
 146                 ses->ipc_tid = 0;
 147                 list_for_each(tmp2, &ses->tcon_list) {
 148                         tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
 149                         tcon->need_reconnect = true;
 150                 }
 151         }
 152         read_unlock(&cifs_tcp_ses_lock);
 153         /* do not want to be sending data on a socket we are freeing */
 154         mutex_lock(&server->srv_mutex);
 155         if (server->ssocket) {
 156                 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
 157                         server->ssocket->flags));
 158                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 159                 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
 160                         server->ssocket->state,
 161                         server->ssocket->flags));
 162                 sock_release(server->ssocket);
 163                 server->ssocket = NULL;
 164         }
 165
 166         spin_lock(&GlobalMid_Lock);
 167         list_for_each(tmp, &server->pending_mid_q) {
 168                 mid_entry = list_entry(tmp, struct
 169                                         mid_q_entry,
 170                                         qhead);
 171                 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
 172                                 /* Mark other intransit requests as needing
 173                                    retry so we do not immediately mark the
 174                                    session bad again (ie after we reconnect
 175                                    below) as they timeout too */
 176                         mid_entry->midState = MID_RETRY_NEEDED;
 177                 }
 178         }
 179         spin_unlock(&GlobalMid_Lock);
 180         mutex_unlock(&server->srv_mutex);
 181
 182         while ((server->tcpStatus != CifsExiting) &&
 183                (server->tcpStatus != CifsGood)) {
 184                 try_to_freeze();
 185                 if (server->addr.sockAddr6.sin6_family == AF_INET6)
 186                         rc = ipv6_connect(server);
 187                 else
 188                         rc = ipv4_connect(server);
 189                 if (rc) {
 190                         cFYI(1, ("reconnect error %d", rc));
 191                         msleep(3000);
 192                 } else {
 193                         atomic_inc(&tcpSesReconnectCount);
 194                         spin_lock(&GlobalMid_Lock);
 195                         if (server->tcpStatus != CifsExiting)
 196                                 server->tcpStatus = CifsGood;
 197                         server->sequence_number = 0;
 198                         spin_unlock(&GlobalMid_Lock);
 199         /*              atomic_set(&server->inFlight,0);*/
 200                         wake_up(&server->response_q);
 201                 }
 202         }
 203         return rc;
 204 }
 205
 206 /*
 207         return codes:
 208                 0       not a transact2, or all data present
 209                 >0      transact2 with that much data missing
 210                 -EINVAL = invalid transact2
 211
 212  */
 213 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
 214 {
 215         struct smb_t2_rsp *pSMBt;
 216         int total_data_size;
 217         int data_in_this_rsp;
 218         int remaining;
 219
 220         if (pSMB->Command != SMB_COM_TRANSACTION2)
 221                 return 0;
 222
 223         /* check for plausible wct, bcc and t2 data and parm sizes */
 224         /* check for parm and data offset going beyond end of smb */
 225         if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
 226                 cFYI(1, ("invalid transact2 word count"));
 227                 return -EINVAL;
 228         }
 229
 230         pSMBt = (struct smb_t2_rsp *)pSMB;
 231
 232         total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
 233         data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
 234
 235         remaining = total_data_size - data_in_this_rsp;
 236
 237         if (remaining == 0)
 238                 return 0;
 239         else if (remaining < 0) {
 240                 cFYI(1, ("total data %d smaller than data in frame %d",
 241                         total_data_size, data_in_this_rsp));
 242                 return -EINVAL;
 243         } else {
 244                 cFYI(1, ("missing %d bytes from transact2, check next response",
 245                         remaining));
 246                 if (total_data_size > maxBufSize) {
 247                         cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
 248                                 total_data_size, maxBufSize));
 249                         return -EINVAL;
 250                 }
 251                 return remaining;
 252         }
 253 }
 254
 255 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
 256 {
 257         struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
 258         struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)pTargetSMB;
 259         int total_data_size;
 260         int total_in_buf;
 261         int remaining;
 262         int total_in_buf2;
 263         char *data_area_of_target;
 264         char *data_area_of_buf2;
 265         __u16 byte_count;
 266
 267         total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
 268
 269         if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
 270                 cFYI(1, ("total data size of primary and secondary t2 differ"));
 271         }
 272
 273         total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
 274
 275         remaining = total_data_size - total_in_buf;
 276
 277         if (remaining < 0)
 278                 return -EINVAL;
 279
 280         if (remaining == 0) /* nothing to do, ignore */
 281                 return 0;
 282
 283         total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
 284         if (remaining < total_in_buf2) {
 285                 cFYI(1, ("transact2 2nd response contains too much data"));
 286         }
 287
 288         /* find end of first SMB data area */
 289         data_area_of_target = (char *)&pSMBt->hdr.Protocol +
 290                                 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
 291         /* validate target area */
 292
 293         data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
 294                                         le16_to_cpu(pSMB2->t2_rsp.DataOffset);
 295
 296         data_area_of_target += total_in_buf;
 297
 298         /* copy second buffer into end of first buffer */
 299         memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
 300         total_in_buf += total_in_buf2;
 301         pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
 302         byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
 303         byte_count += total_in_buf2;
 304         BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
 305
 306         byte_count = pTargetSMB->smb_buf_length;
 307         byte_count += total_in_buf2;
 308
 309         /* BB also add check that we are not beyond maximum buffer size */
 310
 311         pTargetSMB->smb_buf_length = byte_count;
 312
 313         if (remaining == total_in_buf2) {
 314                 cFYI(1, ("found the last secondary response"));
 315                 return 0; /* we are done */
 316         } else /* more responses to go */
 317                 return 1;
 318
 319 }
 320
 321 static int
 322 cifs_demultiplex_thread(struct TCP_Server_Info *server)
 323 {
 324         int length;
 325         unsigned int pdu_length, total_read;
 326         struct smb_hdr *smb_buffer = NULL;
 327         struct smb_hdr *bigbuf = NULL;
 328         struct smb_hdr *smallbuf = NULL;
 329         struct msghdr smb_msg;
 330         struct kvec iov;
 331         struct socket *csocket = server->ssocket;
 332         struct list_head *tmp;
 333         struct cifsSesInfo *ses;
 334         struct task_struct *task_to_wake = NULL;
 335         struct mid_q_entry *mid_entry;
 336         char temp;
 337         bool isLargeBuf = false;
 338         bool isMultiRsp;
 339         int reconnect;
 340
 341         current->flags |= PF_MEMALLOC;
 342         cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
 343
 344         length = atomic_inc_return(&tcpSesAllocCount);
 345         if (length > 1)
 346                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 347                                 GFP_KERNEL);
 348
 349         set_freezable();
 350         while (server->tcpStatus != CifsExiting) {
 351                 if (try_to_freeze())
 352                         continue;
 353                 if (bigbuf == NULL) {
 354                         bigbuf = cifs_buf_get();
 355                         if (!bigbuf) {
 356                                 cERROR(1, ("No memory for large SMB response"));
 357                                 msleep(3000);
 358                                 /* retry will check if exiting */
 359                                 continue;
 360                         }
 361                 } else if (isLargeBuf) {
 362                         /* we are reusing a dirty large buf, clear its start */
 363                         memset(bigbuf, 0, sizeof(struct smb_hdr));
 364                 }
 365
 366                 if (smallbuf == NULL) {
 367                         smallbuf = cifs_small_buf_get();
 368                         if (!smallbuf) {
 369                                 cERROR(1, ("No memory for SMB response"));
 370                                 msleep(1000);
 371                                 /* retry will check if exiting */
 372                                 continue;
 373                         }
 374                         /* beginning of smb buffer is cleared in our buf_get */
 375                 } else /* if existing small buf clear beginning */
 376                         memset(smallbuf, 0, sizeof(struct smb_hdr));
 377
 378                 isLargeBuf = false;
 379                 isMultiRsp = false;
 380                 smb_buffer = smallbuf;
 381                 iov.iov_base = smb_buffer;
 382                 iov.iov_len = 4;
 383                 smb_msg.msg_control = NULL;
 384                 smb_msg.msg_controllen = 0;
 385                 pdu_length = 4; /* enough to get RFC1001 header */
 386 incomplete_rcv:
 387                 length =
 388                     kernel_recvmsg(csocket, &smb_msg,
 389                                 &iov, 1, pdu_length, 0 /* BB other flags? */);
 390
 391                 if (server->tcpStatus == CifsExiting) {
 392                         break;
 393                 } else if (server->tcpStatus == CifsNeedReconnect) {
 394                         cFYI(1, ("Reconnect after server stopped responding"));
 395                         cifs_reconnect(server);
 396                         cFYI(1, ("call to reconnect done"));
 397                         csocket = server->ssocket;
 398                         continue;
 399                 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
 400                         msleep(1); /* minimum sleep to prevent looping
 401                                 allowing socket to clear and app threads to set
 402                                 tcpStatus CifsNeedReconnect if server hung */
 403                         if (pdu_length < 4) {
 404                                 iov.iov_base = (4 - pdu_length) +
 405                                                         (char *)smb_buffer;
 406                                 iov.iov_len = pdu_length;
 407                                 smb_msg.msg_control = NULL;
 408                                 smb_msg.msg_controllen = 0;
 409                                 goto incomplete_rcv;
 410                         } else
 411                                 continue;
 412                 } else if (length <= 0) {
 413                         if (server->tcpStatus == CifsNew) {
 414                                 cFYI(1, ("tcp session abend after SMBnegprot"));
 415                                 /* some servers kill the TCP session rather than
 416                                    returning an SMB negprot error, in which
 417                                    case reconnecting here is not going to help,
 418                                    and so simply return error to mount */
 419                                 break;
 420                         }
 421                         if (!try_to_freeze() && (length == -EINTR)) {
 422                                 cFYI(1, ("cifsd thread killed"));
 423                                 break;
 424                         }
 425                         cFYI(1, ("Reconnect after unexpected peek error %d",
 426                                 length));
 427                         cifs_reconnect(server);
 428                         csocket = server->ssocket;
 429                         wake_up(&server->response_q);
 430                         continue;
 431                 } else if (length < pdu_length) {
 432                         cFYI(1, ("requested %d bytes but only got %d bytes",
 433                                   pdu_length, length));
 434                         pdu_length -= length;
 435                         msleep(1);
 436                         goto incomplete_rcv;
 437                 }
 438
 439                 /* The right amount was read from socket - 4 bytes */
 440                 /* so we can now interpret the length field */
 441
 442                 /* the first byte big endian of the length field,
 443                 is actually not part of the length but the type
 444                 with the most common, zero, as regular data */
 445                 temp = *((char *) smb_buffer);
 446
 447                 /* Note that FC 1001 length is big endian on the wire,
 448                 but we convert it here so it is always manipulated
 449                 as host byte order */
 450                 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
 451                 smb_buffer->smb_buf_length = pdu_length;
 452
 453                 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
 454
 455                 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
 456                         continue;
 457                 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
 458                         cFYI(1, ("Good RFC 1002 session rsp"));
 459                         continue;
 460                 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
 461                         /* we get this from Windows 98 instead of
 462                            an error on SMB negprot response */
 463                         cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
 464                                 pdu_length));
 465                         if (server->tcpStatus == CifsNew) {
 466                                 /* if nack on negprot (rather than
 467                                 ret of smb negprot error) reconnecting
 468                                 not going to help, ret error to mount */
 469                                 break;
 470                         } else {
 471                                 /* give server a second to
 472                                 clean up before reconnect attempt */
 473                                 msleep(1000);
 474                                 /* always try 445 first on reconnect
 475                                 since we get NACK on some if we ever
 476                                 connected to port 139 (the NACK is
 477                                 since we do not begin with RFC1001
 478                                 session initialize frame) */
 479                                 server->addr.sockAddr.sin_port =
 480                                         htons(CIFS_PORT);
 481                                 cifs_reconnect(server);
 482                                 csocket = server->ssocket;
 483                                 wake_up(&server->response_q);
 484                                 continue;
 485                         }
 486                 } else if (temp != (char) 0) {
 487                         cERROR(1, ("Unknown RFC 1002 frame"));
 488                         cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
 489                                       length);
 490                         cifs_reconnect(server);
 491                         csocket = server->ssocket;
 492                         continue;
 493                 }
 494
 495                 /* else we have an SMB response */
 496                 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
 497                             (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
 498                         cERROR(1, ("Invalid size SMB length %d pdu_length %d",
 499                                         length, pdu_length+4));
 500                         cifs_reconnect(server);
 501                         csocket = server->ssocket;
 502                         wake_up(&server->response_q);
 503                         continue;
 504                 }
 505
 506                 /* else length ok */
 507                 reconnect = 0;
 508
 509                 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 510                         isLargeBuf = true;
 511                         memcpy(bigbuf, smallbuf, 4);
 512                         smb_buffer = bigbuf;
 513                 }
 514                 length = 0;
 515                 iov.iov_base = 4 + (char *)smb_buffer;
 516                 iov.iov_len = pdu_length;
 517                 for (total_read = 0; total_read < pdu_length;
 518                      total_read += length) {
 519                         length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
 520                                                 pdu_length - total_read, 0);
 521                         if ((server->tcpStatus == CifsExiting) ||
 522                             (length == -EINTR)) {
 523                                 /* then will exit */
 524                                 reconnect = 2;
 525                                 break;
 526                         } else if (server->tcpStatus == CifsNeedReconnect) {
 527                                 cifs_reconnect(server);
 528                                 csocket = server->ssocket;
 529                                 /* Reconnect wakes up rspns q */
 530                                 /* Now we will reread sock */
 531                                 reconnect = 1;
 532                                 break;
 533                         } else if ((length == -ERESTARTSYS) ||
 534                                    (length == -EAGAIN)) {
 535                                 msleep(1); /* minimum sleep to prevent looping,
 536                                               allowing socket to clear and app
 537                                               threads to set tcpStatus
 538                                               CifsNeedReconnect if server hung*/
 539                                 length = 0;
 540                                 continue;
 541                         } else if (length <= 0) {
 542                                 cERROR(1, ("Received no data, expecting %d",
 543                                               pdu_length - total_read));
 544                                 cifs_reconnect(server);
 545                                 csocket = server->ssocket;
 546                                 reconnect = 1;
 547                                 break;
 548                         }
 549                 }
 550                 if (reconnect == 2)
 551                         break;
 552                 else if (reconnect == 1)
 553                         continue;
 554
 555                 length += 4; /* account for rfc1002 hdr */
 556
 557
 558                 dump_smb(smb_buffer, length);
 559                 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
 560                         cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
 561                         continue;
 562                 }
 563
 564
 565                 task_to_wake = NULL;
 566                 spin_lock(&GlobalMid_Lock);
 567                 list_for_each(tmp, &server->pending_mid_q) {
 568                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 569
 570                         if ((mid_entry->mid == smb_buffer->Mid) &&
 571                             (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
 572                             (mid_entry->command == smb_buffer->Command)) {
 573                                 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
 574                                         /* We have a multipart transact2 resp */
 575                                         isMultiRsp = true;
 576                                         if (mid_entry->resp_buf) {
 577                                                 /* merge response - fix up 1st*/
 578                                                 if (coalesce_t2(smb_buffer,
 579                                                         mid_entry->resp_buf)) {
 580                                                         mid_entry->multiRsp =
 581                                                                  true;
 582                                                         break;
 583                                                 } else {
 584                                                         /* all parts received */
 585                                                         mid_entry->multiEnd =
 586                                                                  true;
 587                                                         goto multi_t2_fnd;
 588                                                 }
 589                                         } else {
 590                                                 if (!isLargeBuf) {
 591                                                         cERROR(1,("1st trans2 resp needs bigbuf"));
 592                                         /* BB maybe we can fix this up,  switch
 593                                            to already allocated large buffer? */
 594                                                 } else {
 595                                                         /* Have first buffer */
 596                                                         mid_entry->resp_buf =
 597                                                                  smb_buffer;
 598                                                         mid_entry->largeBuf =
 599                                                                  true;
 600                                                         bigbuf = NULL;
 601                                                 }
 602                                         }
 603                                         break;
 604                                 }
 605                                 mid_entry->resp_buf = smb_buffer;
 606                                 mid_entry->largeBuf = isLargeBuf;
 607 multi_t2_fnd:
 608                                 task_to_wake = mid_entry->tsk;
 609                                 mid_entry->midState = MID_RESPONSE_RECEIVED;
 610 #ifdef CONFIG_CIFS_STATS2
 611                                 mid_entry->when_received = jiffies;
 612 #endif
 613                                 /* so we do not time out requests to  server
 614                                 which is still responding (since server could
 615                                 be busy but not dead) */
 616                                 server->lstrp = jiffies;
 617                                 break;
 618                         }
 619                 }
 620                 spin_unlock(&GlobalMid_Lock);
 621                 if (task_to_wake) {
 622                         /* Was previous buf put in mpx struct for multi-rsp? */
 623                         if (!isMultiRsp) {
 624                                 /* smb buffer will be freed by user thread */
 625                                 if (isLargeBuf)
 626                                         bigbuf = NULL;
 627                                 else
 628                                         smallbuf = NULL;
 629                         }
 630                         wake_up_process(task_to_wake);
 631                 } else if (!is_valid_oplock_break(smb_buffer, server) &&
 632                            !isMultiRsp) {
 633                         cERROR(1, ("No task to wake, unknown frame received! "
 634                                    "NumMids %d", midCount.counter));
 635                         cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
 636                                       sizeof(struct smb_hdr));
 637 #ifdef CONFIG_CIFS_DEBUG2
 638                         cifs_dump_detail(smb_buffer);
 639                         cifs_dump_mids(server);
 640 #endif /* CIFS_DEBUG2 */
 641
 642                 }
 643         } /* end while !EXITING */
 644
 645         /* take it off the list, if it's not already */
 646         write_lock(&cifs_tcp_ses_lock);
 647         list_del_init(&server->tcp_ses_list);
 648         write_unlock(&cifs_tcp_ses_lock);
 649
 650         spin_lock(&GlobalMid_Lock);
 651         server->tcpStatus = CifsExiting;
 652         spin_unlock(&GlobalMid_Lock);
 653         wake_up_all(&server->response_q);
 654
 655         /* check if we have blocked requests that need to free */
 656         /* Note that cifs_max_pending is normally 50, but
 657         can be set at module install time to as little as two */
 658         spin_lock(&GlobalMid_Lock);
 659         if (atomic_read(&server->inFlight) >= cifs_max_pending)
 660                 atomic_set(&server->inFlight, cifs_max_pending - 1);
 661         /* We do not want to set the max_pending too low or we
 662         could end up with the counter going negative */
 663         spin_unlock(&GlobalMid_Lock);
 664         /* Although there should not be any requests blocked on
 665         this queue it can not hurt to be paranoid and try to wake up requests
 666         that may haven been blocked when more than 50 at time were on the wire
 667         to the same server - they now will see the session is in exit state
 668         and get out of SendReceive.  */
 669         wake_up_all(&server->request_q);
 670         /* give those requests time to exit */
 671         msleep(125);
 672
 673         if (server->ssocket) {
 674                 sock_release(csocket);
 675                 server->ssocket = NULL;
 676         }
 677         /* buffer usuallly freed in free_mid - need to free it here on exit */
 678         cifs_buf_release(bigbuf);
 679         if (smallbuf) /* no sense logging a debug message if NULL */
 680                 cifs_small_buf_release(smallbuf);
 681
 682         /*
 683          * BB: we shouldn't have to do any of this. It shouldn't be
 684          * possible to exit from the thread with active SMB sessions
 685          */
 686         read_lock(&cifs_tcp_ses_lock);
 687         if (list_empty(&server->pending_mid_q)) {
 688                 /* loop through server session structures attached to this and
 689                     mark them dead */
 690                 list_for_each(tmp, &server->smb_ses_list) {
 691                         ses = list_entry(tmp, struct cifsSesInfo,
 692                                          smb_ses_list);
 693                         ses->status = CifsExiting;
 694                         ses->server = NULL;
 695                 }
 696                 read_unlock(&cifs_tcp_ses_lock);
 697         } else {
 698                 /* although we can not zero the server struct pointer yet,
 699                 since there are active requests which may depnd on them,
 700                 mark the corresponding SMB sessions as exiting too */
 701                 list_for_each(tmp, &server->smb_ses_list) {
 702                         ses = list_entry(tmp, struct cifsSesInfo,
 703                                          smb_ses_list);
 704                         ses->status = CifsExiting;
 705                 }
 706
 707                 spin_lock(&GlobalMid_Lock);
 708                 list_for_each(tmp, &server->pending_mid_q) {
 709                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 710                         if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
 711                                 cFYI(1, ("Clearing Mid 0x%x - waking up ",
 712                                          mid_entry->mid));
 713                                 task_to_wake = mid_entry->tsk;
 714                                 if (task_to_wake)
 715                                         wake_up_process(task_to_wake);
 716                         }
 717                 }
 718                 spin_unlock(&GlobalMid_Lock);
 719                 read_unlock(&cifs_tcp_ses_lock);
 720                 /* 1/8th of sec is more than enough time for them to exit */
 721                 msleep(125);
 722         }
 723
 724         if (!list_empty(&server->pending_mid_q)) {
 725                 /* mpx threads have not exited yet give them
 726                 at least the smb send timeout time for long ops */
 727                 /* due to delays on oplock break requests, we need
 728                 to wait at least 45 seconds before giving up
 729                 on a request getting a response and going ahead
 730                 and killing cifsd */
 731                 cFYI(1, ("Wait for exit from demultiplex thread"));
 732                 msleep(46000);
 733                 /* if threads still have not exited they are probably never
 734                 coming home not much else we can do but free the memory */
 735         }
 736
 737         /* last chance to mark ses pointers invalid
 738         if there are any pointing to this (e.g
 739         if a crazy root user tried to kill cifsd
 740         kernel thread explicitly this might happen) */
 741         /* BB: This shouldn't be necessary, see above */
 742         read_lock(&cifs_tcp_ses_lock);
 743         list_for_each(tmp, &server->smb_ses_list) {
 744                 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
 745                 ses->server = NULL;
 746         }
 747         read_unlock(&cifs_tcp_ses_lock);
 748
 749         kfree(server->hostname);
 750         task_to_wake = xchg(&server->tsk, NULL);
 751         kfree(server);
 752
 753         length = atomic_dec_return(&tcpSesAllocCount);
 754         if (length  > 0)
 755                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 756                                 GFP_KERNEL);
 757
 758         /* if server->tsk was NULL then wait for a signal before exiting */
 759         if (!task_to_wake) {
 760                 set_current_state(TASK_INTERRUPTIBLE);
 761                 while (!signal_pending(current)) {
 762                         schedule();
 763                         set_current_state(TASK_INTERRUPTIBLE);
 764                 }
 765                 set_current_state(TASK_RUNNING);
 766         }
 767
 768         module_put_and_exit(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();  /* use current_euid() instead? */
 829         vol->linux_gid = current_gid();
 830
 831         /* default to only allowing write access to owner of the mount */
 832         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
 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         /* default to using server inode numbers where available */
 839         vol->server_ino = 1;
 840
 841         if (!options)
 842                 return 1;
 843
 844         if (strncmp(options, "sep=", 4) == 0) {
 845                 if (options[4] != 0) {
 846                         separator[0] = options[4];
 847                         options += 5;
 848                 } else {
 849                         cFYI(1, ("Null separator not allowed"));
 850                 }
 851         }
 852
 853         while ((data = strsep(&options, separator)) != NULL) {
 854                 if (!*data)
 855                         continue;
 856                 if ((value = strchr(data, '=')) != NULL)
 857                         *value++ = '\0';
 858
 859                 /* Have to parse this before we parse for "user" */
 860                 if (strnicmp(data, "user_xattr", 10) == 0) {
 861                         vol->no_xattr = 0;
 862                 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
 863                         vol->no_xattr = 1;
 864                 } else if (strnicmp(data, "user", 4) == 0) {
 865                         if (!value) {
 866                                 printk(KERN_WARNING
 867                                        "CIFS: invalid or missing username\n");
 868                                 return 1;       /* needs_arg; */
 869                         } else if (!*value) {
 870                                 /* null user, ie anonymous, authentication */
 871                                 vol->nullauth = 1;
 872                         }
 873                         if (strnlen(value, 200) < 200) {
 874                                 vol->username = value;
 875                         } else {
 876                                 printk(KERN_WARNING "CIFS: username too long\n");
 877                                 return 1;
 878                         }
 879                 } else if (strnicmp(data, "pass", 4) == 0) {
 880                         if (!value) {
 881                                 vol->password = NULL;
 882                                 continue;
 883                         } else if (value[0] == 0) {
 884                                 /* check if string begins with double comma
 885                                    since that would mean the password really
 886                                    does start with a comma, and would not
 887                                    indicate an empty string */
 888                                 if (value[1] != separator[0]) {
 889                                         vol->password = NULL;
 890                                         continue;
 891                                 }
 892                         }
 893                         temp_len = strlen(value);
 894                         /* removed password length check, NTLM passwords
 895                                 can be arbitrarily long */
 896
 897                         /* if comma in password, the string will be
 898                         prematurely null terminated.  Commas in password are
 899                         specified across the cifs mount interface by a double
 900                         comma ie ,, and a comma used as in other cases ie ','
 901                         as a parameter delimiter/separator is single and due
 902                         to the strsep above is temporarily zeroed. */
 903
 904                         /* NB: password legally can have multiple commas and
 905                         the only illegal character in a password is null */
 906
 907                         if ((value[temp_len] == 0) &&
 908                             (value[temp_len+1] == separator[0])) {
 909                                 /* reinsert comma */
 910                                 value[temp_len] = separator[0];
 911                                 temp_len += 2;  /* move after second comma */
 912                                 while (value[temp_len] != 0)  {
 913                                         if (value[temp_len] == separator[0]) {
 914                                                 if (value[temp_len+1] ==
 915                                                      separator[0]) {
 916                                                 /* skip second comma */
 917                                                         temp_len++;
 918                                                 } else {
 919                                                 /* single comma indicating start
 920                                                          of next parm */
 921                                                         break;
 922                                                 }
 923                                         }
 924                                         temp_len++;
 925                                 }
 926                                 if (value[temp_len] == 0) {
 927                                         options = NULL;
 928                                 } else {
 929                                         value[temp_len] = 0;
 930                                         /* point option to start of next parm */
 931                                         options = value + temp_len + 1;
 932                                 }
 933                                 /* go from value to value + temp_len condensing
 934                                 double commas to singles. Note that this ends up
 935                                 allocating a few bytes too many, which is ok */
 936                                 vol->password = kzalloc(temp_len, GFP_KERNEL);
 937                                 if (vol->password == NULL) {
 938                                         printk(KERN_WARNING "CIFS: no memory "
 939                                                             "for password\n");
 940                                         return 1;
 941                                 }
 942                                 for (i = 0, j = 0; i < temp_len; i++, j++) {
 943                                         vol->password[j] = value[i];
 944                                         if (value[i] == separator[0]
 945                                                 && value[i+1] == separator[0]) {
 946                                                 /* skip second comma */
 947                                                 i++;
 948                                         }
 949                                 }
 950                                 vol->password[j] = 0;
 951                         } else {
 952                                 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
 953                                 if (vol->password == NULL) {
 954                                         printk(KERN_WARNING "CIFS: no memory "
 955                                                             "for password\n");
 956                                         return 1;
 957                                 }
 958                                 strcpy(vol->password, value);
 959                         }
 960                 } else if (!strnicmp(data, "ip", 2) ||
 961                            !strnicmp(data, "addr", 4)) {
 962                         if (!value || !*value) {
 963                                 vol->UNCip = NULL;
 964                         } else if (strnlen(value, INET6_ADDRSTRLEN) <
 965                                                         INET6_ADDRSTRLEN) {
 966                                 vol->UNCip = value;
 967                         } else {
 968                                 printk(KERN_WARNING "CIFS: ip address "
 969                                                     "too long\n");
 970                                 return 1;
 971                         }
 972                 } else if (strnicmp(data, "sec", 3) == 0) {
 973                         if (!value || !*value) {
 974                                 cERROR(1, ("no security value specified"));
 975                                 continue;
 976                         } else if (strnicmp(value, "krb5i", 5) == 0) {
 977                                 vol->secFlg |= CIFSSEC_MAY_KRB5 |
 978                                         CIFSSEC_MUST_SIGN;
 979                         } else if (strnicmp(value, "krb5p", 5) == 0) {
 980                                 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
 981                                         CIFSSEC_MAY_KRB5; */
 982                                 cERROR(1, ("Krb5 cifs privacy not supported"));
 983                                 return 1;
 984                         } else if (strnicmp(value, "krb5", 4) == 0) {
 985                                 vol->secFlg |= CIFSSEC_MAY_KRB5;
 986 #ifdef CONFIG_CIFS_EXPERIMENTAL
 987                         } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
 988                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
 989                                         CIFSSEC_MUST_SIGN;
 990                         } else if (strnicmp(value, "ntlmssp", 7) == 0) {
 991                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
 992 #endif
 993                         } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
 994                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
 995                                         CIFSSEC_MUST_SIGN;
 996                         } else if (strnicmp(value, "ntlmv2", 6) == 0) {
 997                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
 998                         } else if (strnicmp(value, "ntlmi", 5) == 0) {
 999                                 vol->secFlg |= CIFSSEC_MAY_NTLM |
1000                                         CIFSSEC_MUST_SIGN;
1001                         } else if (strnicmp(value, "ntlm", 4) == 0) {
1002                                 /* ntlm is default so can be turned off too */
1003                                 vol->secFlg |= CIFSSEC_MAY_NTLM;
1004                         } else if (strnicmp(value, "nontlm", 6) == 0) {
1005                                 /* BB is there a better way to do this? */
1006                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1007 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1008                         } else if (strnicmp(value, "lanman", 6) == 0) {
1009                                 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1010 #endif
1011                         } else if (strnicmp(value, "none", 4) == 0) {
1012                                 vol->nullauth = 1;
1013                         } else {
1014                                 cERROR(1, ("bad security option: %s", value));
1015                                 return 1;
1016                         }
1017                 } else if ((strnicmp(data, "unc", 3) == 0)
1018                            || (strnicmp(data, "target", 6) == 0)
1019                            || (strnicmp(data, "path", 4) == 0)) {
1020                         if (!value || !*value) {
1021                                 printk(KERN_WARNING "CIFS: invalid path to "
1022                                                     "network resource\n");
1023                                 return 1;       /* needs_arg; */
1024                         }
1025                         if ((temp_len = strnlen(value, 300)) < 300) {
1026                                 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1027                                 if (vol->UNC == NULL)
1028                                         return 1;
1029                                 strcpy(vol->UNC, value);
1030                                 if (strncmp(vol->UNC, "//", 2) == 0) {
1031                                         vol->UNC[0] = '\\';
1032                                         vol->UNC[1] = '\\';
1033                                 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1034                                         printk(KERN_WARNING
1035                                                "CIFS: UNC Path does not begin "
1036                                                "with // or \\\\ \n");
1037                                         return 1;
1038                                 }
1039                         } else {
1040                                 printk(KERN_WARNING "CIFS: UNC name too long\n");
1041                                 return 1;
1042                         }
1043                 } else if ((strnicmp(data, "domain", 3) == 0)
1044                            || (strnicmp(data, "workgroup", 5) == 0)) {
1045                         if (!value || !*value) {
1046                                 printk(KERN_WARNING "CIFS: invalid domain name\n");
1047                                 return 1;       /* needs_arg; */
1048                         }
1049                         /* BB are there cases in which a comma can be valid in
1050                         a domain name and need special handling? */
1051                         if (strnlen(value, 256) < 256) {
1052                                 vol->domainname = value;
1053                                 cFYI(1, ("Domain name set"));
1054                         } else {
1055                                 printk(KERN_WARNING "CIFS: domain name too "
1056                                                     "long\n");
1057                                 return 1;
1058                         }
1059                 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1060                         if (!value || !*value) {
1061                                 printk(KERN_WARNING
1062                                         "CIFS: invalid path prefix\n");
1063                                 return 1;       /* needs_argument */
1064                         }
1065                         if ((temp_len = strnlen(value, 1024)) < 1024) {
1066                                 if (value[0] != '/')
1067                                         temp_len++;  /* missing leading slash */
1068                                 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1069                                 if (vol->prepath == NULL)
1070                                         return 1;
1071                                 if (value[0] != '/') {
1072                                         vol->prepath[0] = '/';
1073                                         strcpy(vol->prepath+1, value);
1074                                 } else
1075                                         strcpy(vol->prepath, value);
1076                                 cFYI(1, ("prefix path %s", vol->prepath));
1077                         } else {
1078                                 printk(KERN_WARNING "CIFS: prefix too long\n");
1079                                 return 1;
1080                         }
1081                 } else if (strnicmp(data, "iocharset", 9) == 0) {
1082                         if (!value || !*value) {
1083                                 printk(KERN_WARNING "CIFS: invalid iocharset "
1084                                                     "specified\n");
1085                                 return 1;       /* needs_arg; */
1086                         }
1087                         if (strnlen(value, 65) < 65) {
1088                                 if (strnicmp(value, "default", 7))
1089                                         vol->iocharset = value;
1090                                 /* if iocharset not set then load_nls_default
1091                                    is used by caller */
1092                                 cFYI(1, ("iocharset set to %s", value));
1093                         } else {
1094                                 printk(KERN_WARNING "CIFS: iocharset name "
1095                                                     "too long.\n");
1096                                 return 1;
1097                         }
1098                 } else if (strnicmp(data, "uid", 3) == 0) {
1099                         if (value && *value)
1100                                 vol->linux_uid =
1101                                         simple_strtoul(value, &value, 0);
1102                 } else if (strnicmp(data, "forceuid", 8) == 0) {
1103                                 vol->override_uid = 1;
1104                 } else if (strnicmp(data, "gid", 3) == 0) {
1105                         if (value && *value)
1106                                 vol->linux_gid =
1107                                         simple_strtoul(value, &value, 0);
1108                 } else if (strnicmp(data, "forcegid", 8) == 0) {
1109                                 vol->override_gid = 1;
1110                 } else if (strnicmp(data, "file_mode", 4) == 0) {
1111                         if (value && *value) {
1112                                 vol->file_mode =
1113                                         simple_strtoul(value, &value, 0);
1114                         }
1115                 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1116                         if (value && *value) {
1117                                 vol->dir_mode =
1118                                         simple_strtoul(value, &value, 0);
1119                         }
1120                 } else if (strnicmp(data, "dirmode", 4) == 0) {
1121                         if (value && *value) {
1122                                 vol->dir_mode =
1123                                         simple_strtoul(value, &value, 0);
1124                         }
1125                 } else if (strnicmp(data, "port", 4) == 0) {
1126                         if (value && *value) {
1127                                 vol->port =
1128                                         simple_strtoul(value, &value, 0);
1129                         }
1130                 } else if (strnicmp(data, "rsize", 5) == 0) {
1131                         if (value && *value) {
1132                                 vol->rsize =
1133                                         simple_strtoul(value, &value, 0);
1134                         }
1135                 } else if (strnicmp(data, "wsize", 5) == 0) {
1136                         if (value && *value) {
1137                                 vol->wsize =
1138                                         simple_strtoul(value, &value, 0);
1139                         }
1140                 } else if (strnicmp(data, "sockopt", 5) == 0) {
1141                         if (value && *value) {
1142                                 vol->sockopt =
1143                                         simple_strtoul(value, &value, 0);
1144                         }
1145                 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1146                         if (!value || !*value || (*value == ' ')) {
1147                                 cFYI(1, ("invalid (empty) netbiosname"));
1148                         } else {
1149                                 memset(vol->source_rfc1001_name, 0x20, 15);
1150                                 for (i = 0; i < 15; i++) {
1151                                 /* BB are there cases in which a comma can be
1152                                 valid in this workstation netbios name (and need
1153                                 special handling)? */
1154
1155                                 /* We do not uppercase netbiosname for user */
1156                                         if (value[i] == 0)
1157                                                 break;
1158                                         else
1159                                                 vol->source_rfc1001_name[i] =
1160                                                                 value[i];
1161                                 }
1162                                 /* The string has 16th byte zero still from
1163                                 set at top of the function  */
1164                                 if ((i == 15) && (value[i] != 0))
1165                                         printk(KERN_WARNING "CIFS: netbiosname"
1166                                                 " longer than 15 truncated.\n");
1167                         }
1168                 } else if (strnicmp(data, "servern", 7) == 0) {
1169                         /* servernetbiosname specified override *SMBSERVER */
1170                         if (!value || !*value || (*value == ' ')) {
1171                                 cFYI(1, ("empty server netbiosname specified"));
1172                         } else {
1173                                 /* last byte, type, is 0x20 for servr type */
1174                                 memset(vol->target_rfc1001_name, 0x20, 16);
1175
1176                                 for (i = 0; i < 15; i++) {
1177                                 /* BB are there cases in which a comma can be
1178                                    valid in this workstation netbios name
1179                                    (and need special handling)? */
1180
1181                                 /* user or mount helper must uppercase
1182                                    the netbiosname */
1183                                         if (value[i] == 0)
1184                                                 break;
1185                                         else
1186                                                 vol->target_rfc1001_name[i] =
1187                                                                 value[i];
1188                                 }
1189                                 /* The string has 16th byte zero still from
1190                                    set at top of the function  */
1191                                 if ((i == 15) && (value[i] != 0))
1192                                         printk(KERN_WARNING "CIFS: server net"
1193                                         "biosname longer than 15 truncated.\n");
1194                         }
1195                 } else if (strnicmp(data, "credentials", 4) == 0) {
1196                         /* ignore */
1197                 } else if (strnicmp(data, "version", 3) == 0) {
1198                         /* ignore */
1199                 } else if (strnicmp(data, "guest", 5) == 0) {
1200                         /* ignore */
1201                 } else if (strnicmp(data, "rw", 2) == 0) {
1202                         vol->rw = true;
1203                 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1204                         vol->noblocksnd = 1;
1205                 } else if (strnicmp(data, "noautotune", 10) == 0) {
1206                         vol->noautotune = 1;
1207                 } else if ((strnicmp(data, "suid", 4) == 0) ||
1208                                    (strnicmp(data, "nosuid", 6) == 0) ||
1209                                    (strnicmp(data, "exec", 4) == 0) ||
1210                                    (strnicmp(data, "noexec", 6) == 0) ||
1211                                    (strnicmp(data, "nodev", 5) == 0) ||
1212                                    (strnicmp(data, "noauto", 6) == 0) ||
1213                                    (strnicmp(data, "dev", 3) == 0)) {
1214                         /*  The mount tool or mount.cifs helper (if present)
1215                             uses these opts to set flags, and the flags are read
1216                             by the kernel vfs layer before we get here (ie
1217                             before read super) so there is no point trying to
1218                             parse these options again and set anything and it
1219                             is ok to just ignore them */
1220                         continue;
1221                 } else if (strnicmp(data, "ro", 2) == 0) {
1222                         vol->rw = false;
1223                 } else if (strnicmp(data, "hard", 4) == 0) {
1224                         vol->retry = 1;
1225                 } else if (strnicmp(data, "soft", 4) == 0) {
1226                         vol->retry = 0;
1227                 } else if (strnicmp(data, "perm", 4) == 0) {
1228                         vol->noperm = 0;
1229                 } else if (strnicmp(data, "noperm", 6) == 0) {
1230                         vol->noperm = 1;
1231                 } else if (strnicmp(data, "mapchars", 8) == 0) {
1232                         vol->remap = 1;
1233                 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1234                         vol->remap = 0;
1235                 } else if (strnicmp(data, "sfu", 3) == 0) {
1236                         vol->sfu_emul = 1;
1237                 } else if (strnicmp(data, "nosfu", 5) == 0) {
1238                         vol->sfu_emul = 0;
1239                 } else if (strnicmp(data, "nodfs", 5) == 0) {
1240                         vol->nodfs = 1;
1241                 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1242                         vol->posix_paths = 1;
1243                 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1244                         vol->posix_paths = 0;
1245                 } else if (strnicmp(data, "nounix", 6) == 0) {
1246                         vol->no_linux_ext = 1;
1247                 } else if (strnicmp(data, "nolinux", 7) == 0) {
1248                         vol->no_linux_ext = 1;
1249                 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1250                            (strnicmp(data, "ignorecase", 10)  == 0)) {
1251                         vol->nocase = 1;
1252                 } else if (strnicmp(data, "brl", 3) == 0) {
1253                         vol->nobrl =  0;
1254                 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1255                            (strnicmp(data, "nolock", 6) == 0)) {
1256                         vol->nobrl =  1;
1257                         /* turn off mandatory locking in mode
1258                         if remote locking is turned off since the
1259                         local vfs will do advisory */
1260                         if (vol->file_mode ==
1261                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1262                                 vol->file_mode = S_IALLUGO;
1263                 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1264                         /* will take the shorter form "forcemand" as well */
1265                         /* This mount option will force use of mandatory
1266                           (DOS/Windows style) byte range locks, instead of
1267                           using posix advisory byte range locks, even if the
1268                           Unix extensions are available and posix locks would
1269                           be supported otherwise. If Unix extensions are not
1270                           negotiated this has no effect since mandatory locks
1271                           would be used (mandatory locks is all that those
1272                           those servers support) */
1273                         vol->mand_lock = 1;
1274                 } else if (strnicmp(data, "setuids", 7) == 0) {
1275                         vol->setuids = 1;
1276                 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1277                         vol->setuids = 0;
1278                 } else if (strnicmp(data, "dynperm", 7) == 0) {
1279                         vol->dynperm = true;
1280                 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1281                         vol->dynperm = false;
1282                 } else if (strnicmp(data, "nohard", 6) == 0) {
1283                         vol->retry = 0;
1284                 } else if (strnicmp(data, "nosoft", 6) == 0) {
1285                         vol->retry = 1;
1286                 } else if (strnicmp(data, "nointr", 6) == 0) {
1287                         vol->intr = 0;
1288                 } else if (strnicmp(data, "intr", 4) == 0) {
1289                         vol->intr = 1;
1290                 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1291                         vol->nostrictsync = 1;
1292                 } else if (strnicmp(data, "strictsync", 10) == 0) {
1293                         vol->nostrictsync = 0;
1294                 } else if (strnicmp(data, "serverino", 7) == 0) {
1295                         vol->server_ino = 1;
1296                 } else if (strnicmp(data, "noserverino", 9) == 0) {
1297                         vol->server_ino = 0;
1298                 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1299                         vol->cifs_acl = 1;
1300                 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1301                         vol->cifs_acl = 0;
1302                 } else if (strnicmp(data, "acl", 3) == 0) {
1303                         vol->no_psx_acl = 0;
1304                 } else if (strnicmp(data, "noacl", 5) == 0) {
1305                         vol->no_psx_acl = 1;
1306 #ifdef CONFIG_CIFS_EXPERIMENTAL
1307                 } else if (strnicmp(data, "locallease", 6) == 0) {
1308                         vol->local_lease = 1;
1309 #endif
1310                 } else if (strnicmp(data, "sign", 4) == 0) {
1311                         vol->secFlg |= CIFSSEC_MUST_SIGN;
1312                 } else if (strnicmp(data, "seal", 4) == 0) {
1313                         /* we do not do the following in secFlags because seal
1314                            is a per tree connection (mount) not a per socket
1315                            or per-smb connection option in the protocol */
1316                         /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1317                         vol->seal = 1;
1318                 } else if (strnicmp(data, "direct", 6) == 0) {
1319                         vol->direct_io = 1;
1320                 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1321                         vol->direct_io = 1;
1322                 } else if (strnicmp(data, "noac", 4) == 0) {
1323                         printk(KERN_WARNING "CIFS: Mount option noac not "
1324                                 "supported. Instead set "
1325                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1326                 } else
1327                         printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1328                                                 data);
1329         }
1330         if (vol->UNC == NULL) {
1331                 if (devname == NULL) {
1332                         printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1333                                                 "target\n");
1334                         return 1;
1335                 }
1336                 if ((temp_len = strnlen(devname, 300)) < 300) {
1337                         vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1338                         if (vol->UNC == NULL)
1339                                 return 1;
1340                         strcpy(vol->UNC, devname);
1341                         if (strncmp(vol->UNC, "//", 2) == 0) {
1342                                 vol->UNC[0] = '\\';
1343                                 vol->UNC[1] = '\\';
1344                         } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1345                                 printk(KERN_WARNING "CIFS: UNC Path does not "
1346                                                     "begin with // or \\\\ \n");
1347                                 return 1;
1348                         }
1349                         value = strpbrk(vol->UNC+2, "/\\");
1350                         if (value)
1351                                 *value = '\\';
1352                 } else {
1353                         printk(KERN_WARNING "CIFS: UNC name too long\n");
1354                         return 1;
1355                 }
1356         }
1357         if (vol->UNCip == NULL)
1358                 vol->UNCip = &vol->UNC[2];
1359
1360         return 0;
1361 }
1362
1363 static struct TCP_Server_Info *
1364 cifs_find_tcp_session(struct sockaddr_storage *addr)
1365 {
1366         struct list_head *tmp;
1367         struct TCP_Server_Info *server;
1368         struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
1369         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
1370
1371         write_lock(&cifs_tcp_ses_lock);
1372         list_for_each(tmp, &cifs_tcp_ses_list) {
1373                 server = list_entry(tmp, struct TCP_Server_Info,
1374                                     tcp_ses_list);
1375                 /*
1376                  * the demux thread can exit on its own while still in CifsNew
1377                  * so don't accept any sockets in that state. Since the
1378                  * tcpStatus never changes back to CifsNew it's safe to check
1379                  * for this without a lock.
1380                  */
1381                 if (server->tcpStatus == CifsNew)
1382                         continue;
1383
1384                 if (addr->ss_family == AF_INET &&
1385                     (addr4->sin_addr.s_addr !=
1386                      server->addr.sockAddr.sin_addr.s_addr))
1387                         continue;
1388                 else if (addr->ss_family == AF_INET6 &&
1389                          (!ipv6_addr_equal(&server->addr.sockAddr6.sin6_addr,
1390                                            &addr6->sin6_addr) ||
1391                           server->addr.sockAddr6.sin6_scope_id !=
1392                                            addr6->sin6_scope_id))
1393                         continue;
1394
1395                 ++server->srv_count;
1396                 write_unlock(&cifs_tcp_ses_lock);
1397                 cFYI(1, ("Existing tcp session with server found"));
1398                 return server;
1399         }
1400         write_unlock(&cifs_tcp_ses_lock);
1401         return NULL;
1402 }
1403
1404 static void
1405 cifs_put_tcp_session(struct TCP_Server_Info *server)
1406 {
1407         struct task_struct *task;
1408
1409         write_lock(&cifs_tcp_ses_lock);
1410         if (--server->srv_count > 0) {
1411                 write_unlock(&cifs_tcp_ses_lock);
1412                 return;
1413         }
1414
1415         list_del_init(&server->tcp_ses_list);
1416         write_unlock(&cifs_tcp_ses_lock);
1417
1418         spin_lock(&GlobalMid_Lock);
1419         server->tcpStatus = CifsExiting;
1420         spin_unlock(&GlobalMid_Lock);
1421
1422         task = xchg(&server->tsk, NULL);
1423         if (task)
1424                 force_sig(SIGKILL, task);
1425 }
1426
1427 static struct TCP_Server_Info *
1428 cifs_get_tcp_session(struct smb_vol *volume_info)
1429 {
1430         struct TCP_Server_Info *tcp_ses = NULL;
1431         struct sockaddr_storage addr;
1432         struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1433         struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1434         int rc;
1435
1436         memset(&addr, 0, sizeof(struct sockaddr_storage));
1437
1438         cFYI(1, ("UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip));
1439
1440         if (volume_info->UNCip && volume_info->UNC) {
1441                 rc = cifs_convert_address(volume_info->UNCip, &addr);
1442                 if (!rc) {
1443                         /* we failed translating address */
1444                         rc = -EINVAL;
1445                         goto out_err;
1446                 }
1447         } else if (volume_info->UNCip) {
1448                 /* BB using ip addr as tcp_ses name to connect to the
1449                    DFS root below */
1450                 cERROR(1, ("Connecting to DFS root not implemented yet"));
1451                 rc = -EINVAL;
1452                 goto out_err;
1453         } else /* which tcp_sess DFS root would we conect to */ {
1454                 cERROR(1,
1455                        ("CIFS mount error: No UNC path (e.g. -o "
1456                         "unc=//192.168.1.100/public) specified"));
1457                 rc = -EINVAL;
1458                 goto out_err;
1459         }
1460
1461         /* see if we already have a matching tcp_ses */
1462         tcp_ses = cifs_find_tcp_session(&addr);
1463         if (tcp_ses)
1464                 return tcp_ses;
1465
1466         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1467         if (!tcp_ses) {
1468                 rc = -ENOMEM;
1469                 goto out_err;
1470         }
1471
1472         tcp_ses->hostname = extract_hostname(volume_info->UNC);
1473         if (IS_ERR(tcp_ses->hostname)) {
1474                 rc = PTR_ERR(tcp_ses->hostname);
1475                 goto out_err;
1476         }
1477
1478         tcp_ses->noblocksnd = volume_info->noblocksnd;
1479         tcp_ses->noautotune = volume_info->noautotune;
1480         atomic_set(&tcp_ses->inFlight, 0);
1481         init_waitqueue_head(&tcp_ses->response_q);
1482         init_waitqueue_head(&tcp_ses->request_q);
1483         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1484         mutex_init(&tcp_ses->srv_mutex);
1485         memcpy(tcp_ses->workstation_RFC1001_name,
1486                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1487         memcpy(tcp_ses->server_RFC1001_name,
1488                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1489         tcp_ses->sequence_number = 0;
1490         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1491         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1492
1493         /*
1494          * at this point we are the only ones with the pointer
1495          * to the struct since the kernel thread not created yet
1496          * no need to spinlock this init of tcpStatus or srv_count
1497          */
1498         tcp_ses->tcpStatus = CifsNew;
1499         ++tcp_ses->srv_count;
1500
1501         if (addr.ss_family == AF_INET6) {
1502                 cFYI(1, ("attempting ipv6 connect"));
1503                 /* BB should we allow ipv6 on port 139? */
1504                 /* other OS never observed in Wild doing 139 with v6 */
1505                 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1506                         sizeof(struct sockaddr_in6));
1507                 sin_server6->sin6_port = htons(volume_info->port);
1508                 rc = ipv6_connect(tcp_ses);
1509         } else {
1510                 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1511                         sizeof(struct sockaddr_in));
1512                 sin_server->sin_port = htons(volume_info->port);
1513                 rc = ipv4_connect(tcp_ses);
1514         }
1515         if (rc < 0) {
1516                 cERROR(1, ("Error connecting to socket. Aborting operation"));
1517                 goto out_err;
1518         }
1519
1520         /*
1521          * since we're in a cifs function already, we know that
1522          * this will succeed. No need for try_module_get().
1523          */
1524         __module_get(THIS_MODULE);
1525         tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1526                                   tcp_ses, "cifsd");
1527         if (IS_ERR(tcp_ses->tsk)) {
1528                 rc = PTR_ERR(tcp_ses->tsk);
1529                 cERROR(1, ("error %d create cifsd thread", rc));
1530                 module_put(THIS_MODULE);
1531                 goto out_err;
1532         }
1533
1534         /* thread spawned, put it on the list */
1535         write_lock(&cifs_tcp_ses_lock);
1536         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1537         write_unlock(&cifs_tcp_ses_lock);
1538
1539         return tcp_ses;
1540
1541 out_err:
1542         if (tcp_ses) {
1543                 kfree(tcp_ses->hostname);
1544                 if (tcp_ses->ssocket)
1545                         sock_release(tcp_ses->ssocket);
1546                 kfree(tcp_ses);
1547         }
1548         return ERR_PTR(rc);
1549 }
1550
1551 static struct cifsSesInfo *
1552 cifs_find_smb_ses(struct TCP_Server_Info *server, char *username)
1553 {
1554         struct list_head *tmp;
1555         struct cifsSesInfo *ses;
1556
1557         write_lock(&cifs_tcp_ses_lock);
1558         list_for_each(tmp, &server->smb_ses_list) {
1559                 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
1560                 if (strncmp(ses->userName, username, MAX_USERNAME_SIZE))
1561                         continue;
1562
1563                 ++ses->ses_count;
1564                 write_unlock(&cifs_tcp_ses_lock);
1565                 return ses;
1566         }
1567         write_unlock(&cifs_tcp_ses_lock);
1568         return NULL;
1569 }
1570
1571 static void
1572 cifs_put_smb_ses(struct cifsSesInfo *ses)
1573 {
1574         int xid;
1575         struct TCP_Server_Info *server = ses->server;
1576
1577         write_lock(&cifs_tcp_ses_lock);
1578         if (--ses->ses_count > 0) {
1579                 write_unlock(&cifs_tcp_ses_lock);
1580                 return;
1581         }
1582
1583         list_del_init(&ses->smb_ses_list);
1584         write_unlock(&cifs_tcp_ses_lock);
1585
1586         if (ses->status == CifsGood) {
1587                 xid = GetXid();
1588                 CIFSSMBLogoff(xid, ses);
1589                 _FreeXid(xid);
1590         }
1591         sesInfoFree(ses);
1592         cifs_put_tcp_session(server);
1593 }
1594
1595 static struct cifsTconInfo *
1596 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1597 {
1598         struct list_head *tmp;
1599         struct cifsTconInfo *tcon;
1600
1601         write_lock(&cifs_tcp_ses_lock);
1602         list_for_each(tmp, &ses->tcon_list) {
1603                 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1604                 if (tcon->tidStatus == CifsExiting)
1605                         continue;
1606                 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1607                         continue;
1608
1609                 ++tcon->tc_count;
1610                 write_unlock(&cifs_tcp_ses_lock);
1611                 return tcon;
1612         }
1613         write_unlock(&cifs_tcp_ses_lock);
1614         return NULL;
1615 }
1616
1617 static void
1618 cifs_put_tcon(struct cifsTconInfo *tcon)
1619 {
1620         int xid;
1621         struct cifsSesInfo *ses = tcon->ses;
1622
1623         write_lock(&cifs_tcp_ses_lock);
1624         if (--tcon->tc_count > 0) {
1625                 write_unlock(&cifs_tcp_ses_lock);
1626                 return;
1627         }
1628
1629         list_del_init(&tcon->tcon_list);
1630         write_unlock(&cifs_tcp_ses_lock);
1631
1632         xid = GetXid();
1633         CIFSSMBTDis(xid, tcon);
1634         _FreeXid(xid);
1635
1636         DeleteTconOplockQEntries(tcon);
1637         tconInfoFree(tcon);
1638         cifs_put_smb_ses(ses);
1639 }
1640
1641 int
1642 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1643              const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1644              struct dfs_info3_param **preferrals, int remap)
1645 {
1646         char *temp_unc;
1647         int rc = 0;
1648
1649         *pnum_referrals = 0;
1650         *preferrals = NULL;
1651
1652         if (pSesInfo->ipc_tid == 0) {
1653                 temp_unc = kmalloc(2 /* for slashes */ +
1654                         strnlen(pSesInfo->serverName,
1655                                 SERVER_NAME_LEN_WITH_NULL * 2)
1656                                  + 1 + 4 /* slash IPC$ */  + 2,
1657                                 GFP_KERNEL);
1658                 if (temp_unc == NULL)
1659                         return -ENOMEM;
1660                 temp_unc[0] = '\\';
1661                 temp_unc[1] = '\\';
1662                 strcpy(temp_unc + 2, pSesInfo->serverName);
1663                 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1664                 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1665                 cFYI(1,
1666                      ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1667                 kfree(temp_unc);
1668         }
1669         if (rc == 0)
1670                 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1671                                      pnum_referrals, nls_codepage, remap);
1672         /* BB map targetUNCs to dfs_info3 structures, here or
1673                 in CIFSGetDFSRefer BB */
1674
1675         return rc;
1676 }
1677
1678 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1679 static struct lock_class_key cifs_key[2];
1680 static struct lock_class_key cifs_slock_key[2];
1681
1682 static inline void
1683 cifs_reclassify_socket4(struct socket *sock)
1684 {
1685         struct sock *sk = sock->sk;
1686         BUG_ON(sock_owned_by_user(sk));
1687         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1688                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1689 }
1690
1691 static inline void
1692 cifs_reclassify_socket6(struct socket *sock)
1693 {
1694         struct sock *sk = sock->sk;
1695         BUG_ON(sock_owned_by_user(sk));
1696         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1697                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1698 }
1699 #else
1700 static inline void
1701 cifs_reclassify_socket4(struct socket *sock)
1702 {
1703 }
1704
1705 static inline void
1706 cifs_reclassify_socket6(struct socket *sock)
1707 {
1708 }
1709 #endif
1710
1711 /* See RFC1001 section 14 on representation of Netbios names */
1712 static void rfc1002mangle(char *target, char *source, unsigned int length)
1713 {
1714         unsigned int i, j;
1715
1716         for (i = 0, j = 0; i < (length); i++) {
1717                 /* mask a nibble at a time and encode */
1718                 target[j] = 'A' + (0x0F & (source[i] >> 4));
1719                 target[j+1] = 'A' + (0x0F & source[i]);
1720                 j += 2;
1721         }
1722
1723 }
1724
1725
1726 static int
1727 ipv4_connect(struct TCP_Server_Info *server)
1728 {
1729         int rc = 0;
1730         bool connected = false;
1731         __be16 orig_port = 0;
1732         struct socket *socket = server->ssocket;
1733
1734         if (socket == NULL) {
1735                 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1736                                       IPPROTO_TCP, &socket);
1737                 if (rc < 0) {
1738                         cERROR(1, ("Error %d creating socket", rc));
1739                         return rc;
1740                 }
1741
1742                 /* BB other socket options to set KEEPALIVE, NODELAY? */
1743                 cFYI(1, ("Socket created"));
1744                 server->ssocket = socket;
1745                 socket->sk->sk_allocation = GFP_NOFS;
1746                 cifs_reclassify_socket4(socket);
1747         }
1748
1749         /* user overrode default port */
1750         if (server->addr.sockAddr.sin_port) {
1751                 rc = socket->ops->connect(socket, (struct sockaddr *)
1752                                           &server->addr.sockAddr,
1753                                           sizeof(struct sockaddr_in), 0);
1754                 if (rc >= 0)
1755                         connected = true;
1756         }
1757
1758         if (!connected) {
1759                 /* save original port so we can retry user specified port
1760                         later if fall back ports fail this time  */
1761                 orig_port = server->addr.sockAddr.sin_port;
1762
1763                 /* do not retry on the same port we just failed on */
1764                 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
1765                         server->addr.sockAddr.sin_port = htons(CIFS_PORT);
1766                         rc = socket->ops->connect(socket,
1767                                                 (struct sockaddr *)
1768                                                 &server->addr.sockAddr,
1769                                                 sizeof(struct sockaddr_in), 0);
1770                         if (rc >= 0)
1771                                 connected = true;
1772                 }
1773         }
1774         if (!connected) {
1775                 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
1776                 rc = socket->ops->connect(socket, (struct sockaddr *)
1777                                               &server->addr.sockAddr,
1778                                               sizeof(struct sockaddr_in), 0);
1779                 if (rc >= 0)
1780                         connected = true;
1781         }
1782
1783         /* give up here - unless we want to retry on different
1784                 protocol families some day */
1785         if (!connected) {
1786                 if (orig_port)
1787                         server->addr.sockAddr.sin_port = orig_port;
1788                 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1789                 sock_release(socket);
1790                 server->ssocket = NULL;
1791                 return rc;
1792         }
1793
1794
1795         /*
1796          * Eventually check for other socket options to change from
1797          *  the default. sock_setsockopt not used because it expects
1798          *  user space buffer
1799          */
1800         socket->sk->sk_rcvtimeo = 7 * HZ;
1801         socket->sk->sk_sndtimeo = 5 * HZ;
1802
1803         /* make the bufsizes depend on wsize/rsize and max requests */
1804         if (server->noautotune) {
1805                 if (socket->sk->sk_sndbuf < (200 * 1024))
1806                         socket->sk->sk_sndbuf = 200 * 1024;
1807                 if (socket->sk->sk_rcvbuf < (140 * 1024))
1808                         socket->sk->sk_rcvbuf = 140 * 1024;
1809         }
1810
1811          cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1812                  socket->sk->sk_sndbuf,
1813                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo));
1814
1815         /* send RFC1001 sessinit */
1816         if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
1817                 /* some servers require RFC1001 sessinit before sending
1818                 negprot - BB check reconnection in case where second
1819                 sessinit is sent but no second negprot */
1820                 struct rfc1002_session_packet *ses_init_buf;
1821                 struct smb_hdr *smb_buf;
1822                 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1823                                        GFP_KERNEL);
1824                 if (ses_init_buf) {
1825                         ses_init_buf->trailer.session_req.called_len = 32;
1826                         if (server->server_RFC1001_name &&
1827                             server->server_RFC1001_name[0] != 0)
1828                                 rfc1002mangle(ses_init_buf->trailer.
1829                                                 session_req.called_name,
1830                                               server->server_RFC1001_name,
1831                                               RFC1001_NAME_LEN_WITH_NULL);
1832                         else
1833                                 rfc1002mangle(ses_init_buf->trailer.
1834                                                 session_req.called_name,
1835                                               DEFAULT_CIFS_CALLED_NAME,
1836                                               RFC1001_NAME_LEN_WITH_NULL);
1837
1838                         ses_init_buf->trailer.session_req.calling_len = 32;
1839
1840                         /* calling name ends in null (byte 16) from old smb
1841                         convention. */
1842                         if (server->workstation_RFC1001_name &&
1843                             server->workstation_RFC1001_name[0] != 0)
1844                                 rfc1002mangle(ses_init_buf->trailer.
1845                                                 session_req.calling_name,
1846                                               server->workstation_RFC1001_name,
1847                                               RFC1001_NAME_LEN_WITH_NULL);
1848                         else
1849                                 rfc1002mangle(ses_init_buf->trailer.
1850                                                 session_req.calling_name,
1851                                               "LINUX_CIFS_CLNT",
1852                                               RFC1001_NAME_LEN_WITH_NULL);
1853
1854                         ses_init_buf->trailer.session_req.scope1 = 0;
1855                         ses_init_buf->trailer.session_req.scope2 = 0;
1856                         smb_buf = (struct smb_hdr *)ses_init_buf;
1857                         /* sizeof RFC1002_SESSION_REQUEST with no scope */
1858                         smb_buf->smb_buf_length = 0x81000044;
1859                         rc = smb_send(server, smb_buf, 0x44);
1860                         kfree(ses_init_buf);
1861                         msleep(1); /* RFC1001 layer in at least one server
1862                                       requires very short break before negprot
1863                                       presumably because not expecting negprot
1864                                       to follow so fast.  This is a simple
1865                                       solution that works without
1866                                       complicating the code and causes no
1867                                       significant slowing down on mount
1868                                       for everyone else */
1869                 }
1870                 /* else the negprot may still work without this
1871                 even though malloc failed */
1872
1873         }
1874
1875         return rc;
1876 }
1877
1878 static int
1879 ipv6_connect(struct TCP_Server_Info *server)
1880 {
1881         int rc = 0;
1882         bool connected = false;
1883         __be16 orig_port = 0;
1884         struct socket *socket = server->ssocket;
1885
1886         if (socket == NULL) {
1887                 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1888                                       IPPROTO_TCP, &socket);
1889                 if (rc < 0) {
1890                         cERROR(1, ("Error %d creating ipv6 socket", rc));
1891                         socket = NULL;
1892                         return rc;
1893                 }
1894
1895                 /* BB other socket options to set KEEPALIVE, NODELAY? */
1896                 cFYI(1, ("ipv6 Socket created"));
1897                 server->ssocket = socket;
1898                 socket->sk->sk_allocation = GFP_NOFS;
1899                 cifs_reclassify_socket6(socket);
1900         }
1901
1902         /* user overrode default port */
1903         if (server->addr.sockAddr6.sin6_port) {
1904                 rc = socket->ops->connect(socket,
1905                                 (struct sockaddr *) &server->addr.sockAddr6,
1906                                 sizeof(struct sockaddr_in6), 0);
1907                 if (rc >= 0)
1908                         connected = true;
1909         }
1910
1911         if (!connected) {
1912                 /* save original port so we can retry user specified port
1913                         later if fall back ports fail this time  */
1914
1915                 orig_port = server->addr.sockAddr6.sin6_port;
1916                 /* do not retry on the same port we just failed on */
1917                 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
1918                         server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
1919                         rc = socket->ops->connect(socket, (struct sockaddr *)
1920                                         &server->addr.sockAddr6,
1921                                         sizeof(struct sockaddr_in6), 0);
1922                         if (rc >= 0)
1923                                 connected = true;
1924                 }
1925         }
1926         if (!connected) {
1927                 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
1928                 rc = socket->ops->connect(socket, (struct sockaddr *)
1929                                 &server->addr.sockAddr6,
1930                                 sizeof(struct sockaddr_in6), 0);
1931                 if (rc >= 0)
1932                         connected = true;
1933         }
1934
1935         /* give up here - unless we want to retry on different
1936                 protocol families some day */
1937         if (!connected) {
1938                 if (orig_port)
1939                         server->addr.sockAddr6.sin6_port = orig_port;
1940                 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1941                 sock_release(socket);
1942                 server->ssocket = NULL;
1943                 return rc;
1944         }
1945
1946         /*
1947          * Eventually check for other socket options to change from
1948          * the default. sock_setsockopt not used because it expects
1949          * user space buffer
1950          */
1951         socket->sk->sk_rcvtimeo = 7 * HZ;
1952         socket->sk->sk_sndtimeo = 5 * HZ;
1953         server->ssocket = socket;
1954
1955         return rc;
1956 }
1957
1958 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1959                           struct super_block *sb, struct smb_vol *vol_info)
1960 {
1961         /* if we are reconnecting then should we check to see if
1962          * any requested capabilities changed locally e.g. via
1963          * remount but we can not do much about it here
1964          * if they have (even if we could detect it by the following)
1965          * Perhaps we could add a backpointer to array of sb from tcon
1966          * or if we change to make all sb to same share the same
1967          * sb as NFS - then we only have one backpointer to sb.
1968          * What if we wanted to mount the server share twice once with
1969          * and once without posixacls or posix paths? */
1970         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1971
1972         if (vol_info && vol_info->no_linux_ext) {
1973                 tcon->fsUnixInfo.Capability = 0;
1974                 tcon->unix_ext = 0; /* Unix Extensions disabled */
1975                 cFYI(1, ("Linux protocol extensions disabled"));
1976                 return;
1977         } else if (vol_info)
1978                 tcon->unix_ext = 1; /* Unix Extensions supported */
1979
1980         if (tcon->unix_ext == 0) {
1981                 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1982                 return;
1983         }
1984
1985         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
1986                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1987
1988                 /* check for reconnect case in which we do not
1989                    want to change the mount behavior if we can avoid it */
1990                 if (vol_info == NULL) {
1991                         /* turn off POSIX ACL and PATHNAMES if not set
1992                            originally at mount time */
1993                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
1994                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
1995                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
1996                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
1997                                         cERROR(1, ("POSIXPATH support change"));
1998                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
1999                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2000                                 cERROR(1, ("possible reconnect error"));
2001                                 cERROR(1,
2002                                         ("server disabled POSIX path support"));
2003                         }
2004                 }
2005
2006                 cap &= CIFS_UNIX_CAP_MASK;
2007                 if (vol_info && vol_info->no_psx_acl)
2008                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2009                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2010                         cFYI(1, ("negotiated posix acl support"));
2011                         if (sb)
2012                                 sb->s_flags |= MS_POSIXACL;
2013                 }
2014
2015                 if (vol_info && vol_info->posix_paths == 0)
2016                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2017                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2018                         cFYI(1, ("negotiate posix pathnames"));
2019                         if (sb)
2020                                 CIFS_SB(sb)->mnt_cifs_flags |=
2021                                         CIFS_MOUNT_POSIX_PATHS;
2022                 }
2023
2024                 /* We might be setting the path sep back to a different
2025                 form if we are reconnecting and the server switched its
2026                 posix path capability for this share */
2027                 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2028                         CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2029
2030                 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2031                         if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2032                                 CIFS_SB(sb)->rsize = 127 * 1024;
2033                                 cFYI(DBG2,
2034                                         ("larger reads not supported by srv"));
2035                         }
2036                 }
2037
2038
2039                 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
2040 #ifdef CONFIG_CIFS_DEBUG2
2041                 if (cap & CIFS_UNIX_FCNTL_CAP)
2042                         cFYI(1, ("FCNTL cap"));
2043                 if (cap & CIFS_UNIX_EXTATTR_CAP)
2044                         cFYI(1, ("EXTATTR cap"));
2045                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2046                         cFYI(1, ("POSIX path cap"));
2047                 if (cap & CIFS_UNIX_XATTR_CAP)
2048                         cFYI(1, ("XATTR cap"));
2049                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2050                         cFYI(1, ("POSIX ACL cap"));
2051                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2052                         cFYI(1, ("very large read cap"));
2053                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2054                         cFYI(1, ("very large write cap"));
2055 #endif /* CIFS_DEBUG2 */
2056                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2057                         if (vol_info == NULL) {
2058                                 cFYI(1, ("resetting capabilities failed"));
2059                         } else
2060                                 cERROR(1, ("Negotiating Unix capabilities "
2061                                            "with the server failed.  Consider "
2062                                            "mounting with the Unix Extensions\n"
2063                                            "disabled, if problems are found, "
2064                                            "by specifying the nounix mount "
2065                                            "option."));
2066
2067                 }
2068         }
2069 }
2070
2071 static void
2072 convert_delimiter(char *path, char delim)
2073 {
2074         int i;
2075         char old_delim;
2076
2077         if (path == NULL)
2078                 return;
2079
2080         if (delim == '/')
2081                 old_delim = '\\';
2082         else
2083                 old_delim = '/';
2084
2085         for (i = 0; path[i] != '\0'; i++) {
2086                 if (path[i] == old_delim)
2087                         path[i] = delim;
2088         }
2089 }
2090
2091 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2092                           struct cifs_sb_info *cifs_sb)
2093 {
2094         if (pvolume_info->rsize > CIFSMaxBufSize) {
2095                 cERROR(1, ("rsize %d too large, using MaxBufSize",
2096                         pvolume_info->rsize));
2097                 cifs_sb->rsize = CIFSMaxBufSize;
2098         } else if ((pvolume_info->rsize) &&
2099                         (pvolume_info->rsize <= CIFSMaxBufSize))
2100                 cifs_sb->rsize = pvolume_info->rsize;
2101         else /* default */
2102                 cifs_sb->rsize = CIFSMaxBufSize;
2103
2104         if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2105                 cERROR(1, ("wsize %d too large, using 4096 instead",
2106                           pvolume_info->wsize));
2107                 cifs_sb->wsize = 4096;
2108         } else if (pvolume_info->wsize)
2109                 cifs_sb->wsize = pvolume_info->wsize;
2110         else
2111                 cifs_sb->wsize = min_t(const int,
2112                                         PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2113                                         127*1024);
2114                 /* old default of CIFSMaxBufSize was too small now
2115                    that SMB Write2 can send multiple pages in kvec.
2116                    RFC1001 does not describe what happens when frame
2117                    bigger than 128K is sent so use that as max in
2118                    conjunction with 52K kvec constraint on arch with 4K
2119                    page size  */
2120
2121         if (cifs_sb->rsize < 2048) {
2122                 cifs_sb->rsize = 2048;
2123                 /* Windows ME may prefer this */
2124                 cFYI(1, ("readsize set to minimum: 2048"));
2125         }
2126         /* calculate prepath */
2127         cifs_sb->prepath = pvolume_info->prepath;
2128         if (cifs_sb->prepath) {
2129                 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2130                 /* we can not convert the / to \ in the path
2131                 separators in the prefixpath yet because we do not
2132                 know (until reset_cifs_unix_caps is called later)
2133                 whether POSIX PATH CAP is available. We normalize
2134                 the / to \ after reset_cifs_unix_caps is called */
2135                 pvolume_info->prepath = NULL;
2136         } else
2137                 cifs_sb->prepathlen = 0;
2138         cifs_sb->mnt_uid = pvolume_info->linux_uid;
2139         cifs_sb->mnt_gid = pvolume_info->linux_gid;
2140         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2141         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2142         cFYI(1, ("file mode: 0x%x  dir mode: 0x%x",
2143                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2144
2145         if (pvolume_info->noperm)
2146                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2147         if (pvolume_info->setuids)
2148                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2149         if (pvolume_info->server_ino)
2150                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2151         if (pvolume_info->remap)
2152                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2153         if (pvolume_info->no_xattr)
2154                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2155         if (pvolume_info->sfu_emul)
2156                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2157         if (pvolume_info->nobrl)
2158                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2159         if (pvolume_info->nostrictsync)
2160                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2161         if (pvolume_info->mand_lock)
2162                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2163         if (pvolume_info->cifs_acl)
2164                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2165         if (pvolume_info->override_uid)
2166                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2167         if (pvolume_info->override_gid)
2168                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2169         if (pvolume_info->dynperm)
2170                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2171         if (pvolume_info->direct_io) {
2172                 cFYI(1, ("mounting share using direct i/o"));
2173                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2174         }
2175
2176         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2177                 cERROR(1, ("mount option dynperm ignored if cifsacl "
2178                            "mount option supported"));
2179 }
2180
2181 static int
2182 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2183                    struct cifs_sb_info *cifs_sb, const char *full_path)
2184 {
2185         int rc;
2186         __u64 inode_num;
2187         FILE_ALL_INFO *pfile_info;
2188
2189         rc = CIFSGetSrvInodeNumber(xid, tcon, full_path, &inode_num,
2190                                    cifs_sb->local_nls,
2191                                    cifs_sb->mnt_cifs_flags &
2192                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2193         if (rc != -EOPNOTSUPP)
2194                 return rc;
2195
2196         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2197         if (pfile_info == NULL)
2198                 return -ENOMEM;
2199
2200         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2201                               0 /* not legacy */, cifs_sb->local_nls,
2202                               cifs_sb->mnt_cifs_flags &
2203                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2204         kfree(pfile_info);
2205         return rc;
2206 }
2207
2208 static void
2209 cleanup_volume_info(struct smb_vol **pvolume_info)
2210 {
2211         struct smb_vol *volume_info;
2212
2213         if (!pvolume_info && !*pvolume_info)
2214                 return;
2215
2216         volume_info = *pvolume_info;
2217         kzfree(volume_info->password);
2218         kfree(volume_info->UNC);
2219         kfree(volume_info->prepath);
2220         kfree(volume_info);
2221         *pvolume_info = NULL;
2222         return;
2223 }
2224
2225 #ifdef CONFIG_CIFS_DFS_UPCALL
2226 /* build_path_to_root returns full path to root when
2227  * we do not have an exiting connection (tcon) */
2228 static char *
2229 build_unc_path_to_root(const struct smb_vol *volume_info,
2230                 const struct cifs_sb_info *cifs_sb)
2231 {
2232         char *full_path;
2233
2234         int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2235         full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2236         if (full_path == NULL)
2237                 return ERR_PTR(-ENOMEM);
2238
2239         strncpy(full_path, volume_info->UNC, unc_len);
2240         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2241                 int i;
2242                 for (i = 0; i < unc_len; i++) {
2243                         if (full_path[i] == '\\')
2244                                 full_path[i] = '/';
2245                 }
2246         }
2247
2248         if (cifs_sb->prepathlen)
2249                 strncpy(full_path + unc_len, cifs_sb->prepath,
2250                                 cifs_sb->prepathlen);
2251
2252         full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2253         return full_path;
2254 }
2255 #endif
2256
2257 int
2258 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2259                 char *mount_data_global, const char *devname)
2260 {
2261         int rc = 0;
2262         int xid;
2263         struct smb_vol *volume_info;
2264         struct cifsSesInfo *pSesInfo = NULL;
2265         struct cifsTconInfo *tcon = NULL;
2266         struct TCP_Server_Info *srvTcp = NULL;
2267         char   *full_path;
2268         char *mount_data = mount_data_global;
2269 #ifdef CONFIG_CIFS_DFS_UPCALL
2270         struct dfs_info3_param *referrals = NULL;
2271         unsigned int num_referrals = 0;
2272         int referral_walks_count = 0;
2273 try_mount_again:
2274 #endif
2275         full_path = NULL;
2276
2277         xid = GetXid();
2278
2279         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2280         if (!volume_info) {
2281                 rc = -ENOMEM;
2282                 goto out;
2283         }
2284
2285         if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2286                 rc = -EINVAL;
2287                 goto out;
2288         }
2289
2290         if (volume_info->nullauth) {
2291                 cFYI(1, ("null user"));
2292                 volume_info->username = "";
2293         } else if (volume_info->username) {
2294                 /* BB fixme parse for domain name here */
2295                 cFYI(1, ("Username: %s", volume_info->username));
2296         } else {
2297                 cifserror("No username specified");
2298         /* In userspace mount helper we can get user name from alternate
2299            locations such as env variables and files on disk */
2300                 rc = -EINVAL;
2301                 goto out;
2302         }
2303
2304
2305         /* this is needed for ASCII cp to Unicode converts */
2306         if (volume_info->iocharset == NULL) {
2307                 cifs_sb->local_nls = load_nls_default();
2308         /* load_nls_default can not return null */
2309         } else {
2310                 cifs_sb->local_nls = load_nls(volume_info->iocharset);
2311                 if (cifs_sb->local_nls == NULL) {
2312                         cERROR(1, ("CIFS mount error: iocharset %s not found",
2313                                  volume_info->iocharset));
2314                         rc = -ELIBACC;
2315                         goto out;
2316                 }
2317         }
2318
2319         /* get a reference to a tcp session */
2320         srvTcp = cifs_get_tcp_session(volume_info);
2321         if (IS_ERR(srvTcp)) {
2322                 rc = PTR_ERR(srvTcp);
2323                 goto out;
2324         }
2325
2326         pSesInfo = cifs_find_smb_ses(srvTcp, volume_info->username);
2327         if (pSesInfo) {
2328                 cFYI(1, ("Existing smb sess found (status=%d)",
2329                         pSesInfo->status));
2330                 /*
2331                  * The existing SMB session already has a reference to srvTcp,
2332                  * so we can put back the extra one we got before
2333                  */
2334                 cifs_put_tcp_session(srvTcp);
2335
2336                 down(&pSesInfo->sesSem);
2337                 if (pSesInfo->need_reconnect) {
2338                         cFYI(1, ("Session needs reconnect"));
2339                         rc = cifs_setup_session(xid, pSesInfo,
2340                                                 cifs_sb->local_nls);
2341                 }
2342                 up(&pSesInfo->sesSem);
2343         } else if (!rc) {
2344                 cFYI(1, ("Existing smb sess not found"));
2345                 pSesInfo = sesInfoAlloc();
2346                 if (pSesInfo == NULL) {
2347                         rc = -ENOMEM;
2348                         goto mount_fail_check;
2349                 }
2350
2351                 /* new SMB session uses our srvTcp ref */
2352                 pSesInfo->server = srvTcp;
2353                 if (srvTcp->addr.sockAddr6.sin6_family == AF_INET6)
2354                         sprintf(pSesInfo->serverName, "%pI6",
2355                                 &srvTcp->addr.sockAddr6.sin6_addr);
2356                 else
2357                         sprintf(pSesInfo->serverName, "%pI4",
2358                                 &srvTcp->addr.sockAddr.sin_addr.s_addr);
2359
2360                 write_lock(&cifs_tcp_ses_lock);
2361                 list_add(&pSesInfo->smb_ses_list, &srvTcp->smb_ses_list);
2362                 write_unlock(&cifs_tcp_ses_lock);
2363
2364                 /* volume_info->password freed at unmount */
2365                 if (volume_info->password) {
2366                         pSesInfo->password = kstrdup(volume_info->password,
2367                                                      GFP_KERNEL);
2368                         if (!pSesInfo->password) {
2369                                 rc = -ENOMEM;
2370                                 goto mount_fail_check;
2371                         }
2372                 }
2373                 if (volume_info->username)
2374                         strncpy(pSesInfo->userName, volume_info->username,
2375                                 MAX_USERNAME_SIZE);
2376                 if (volume_info->domainname) {
2377                         int len = strlen(volume_info->domainname);
2378                         pSesInfo->domainName = kmalloc(len + 1, GFP_KERNEL);
2379                         if (pSesInfo->domainName)
2380                                 strcpy(pSesInfo->domainName,
2381                                         volume_info->domainname);
2382                 }
2383                 pSesInfo->linux_uid = volume_info->linux_uid;
2384                 pSesInfo->overrideSecFlg = volume_info->secFlg;
2385                 down(&pSesInfo->sesSem);
2386
2387                 /* BB FIXME need to pass vol->secFlgs BB */
2388                 rc = cifs_setup_session(xid, pSesInfo,
2389                                         cifs_sb->local_nls);
2390                 up(&pSesInfo->sesSem);
2391         }
2392
2393         /* search for existing tcon to this server share */
2394         if (!rc) {
2395                 setup_cifs_sb(volume_info, cifs_sb);
2396
2397                 tcon = cifs_find_tcon(pSesInfo, volume_info->UNC);
2398                 if (tcon) {
2399                         cFYI(1, ("Found match on UNC path"));
2400                         /* existing tcon already has a reference */
2401                         cifs_put_smb_ses(pSesInfo);
2402                         if (tcon->seal != volume_info->seal)
2403                                 cERROR(1, ("transport encryption setting "
2404                                            "conflicts with existing tid"));
2405                 } else {
2406                         tcon = tconInfoAlloc();
2407                         if (tcon == NULL) {
2408                                 rc = -ENOMEM;
2409                                 goto mount_fail_check;
2410                         }
2411
2412                         tcon->ses = pSesInfo;
2413                         if (volume_info->password) {
2414                                 tcon->password = kstrdup(volume_info->password,
2415                                                          GFP_KERNEL);
2416                                 if (!tcon->password) {
2417                                         rc = -ENOMEM;
2418                                         goto mount_fail_check;
2419                                 }
2420                         }
2421
2422                         if ((strchr(volume_info->UNC + 3, '\\') == NULL)
2423                             && (strchr(volume_info->UNC + 3, '/') == NULL)) {
2424                                 cERROR(1, ("Missing share name"));
2425                                 rc = -ENODEV;
2426                                 goto mount_fail_check;
2427                         } else {
2428                                 /* BB Do we need to wrap sesSem around
2429                                  * this TCon call and Unix SetFS as
2430                                  * we do on SessSetup and reconnect? */
2431                                 rc = CIFSTCon(xid, pSesInfo, volume_info->UNC,
2432                                               tcon, cifs_sb->local_nls);
2433                                 cFYI(1, ("CIFS Tcon rc = %d", rc));
2434                                 if (volume_info->nodfs) {
2435                                         tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2436                                         cFYI(1, ("DFS disabled (%d)",
2437                                                 tcon->Flags));
2438                                 }
2439                         }
2440                         if (rc)
2441                                 goto remote_path_check;
2442                         tcon->seal = volume_info->seal;
2443                         write_lock(&cifs_tcp_ses_lock);
2444                         list_add(&tcon->tcon_list, &pSesInfo->tcon_list);
2445                         write_unlock(&cifs_tcp_ses_lock);
2446                 }
2447
2448                 /* we can have only one retry value for a connection
2449                    to a share so for resources mounted more than once
2450                    to the same server share the last value passed in
2451                    for the retry flag is used */
2452                 tcon->retry = volume_info->retry;
2453                 tcon->nocase = volume_info->nocase;
2454                 tcon->local_lease = volume_info->local_lease;
2455         }
2456         if (pSesInfo) {
2457                 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2458                         sb->s_maxbytes = (u64) 1 << 63;
2459                 } else
2460                         sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2461         }
2462
2463         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2464         sb->s_time_gran = 100;
2465
2466         if (rc)
2467                 goto remote_path_check;
2468
2469         cifs_sb->tcon = tcon;
2470
2471         /* do not care if following two calls succeed - informational */
2472         if (!tcon->ipc) {
2473                 CIFSSMBQFSDeviceInfo(xid, tcon);
2474                 CIFSSMBQFSAttributeInfo(xid, tcon);
2475         }
2476
2477         /* tell server which Unix caps we support */
2478         if (tcon->ses->capabilities & CAP_UNIX)
2479                 /* reset of caps checks mount to see if unix extensions
2480                    disabled for just this mount */
2481                 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2482         else
2483                 tcon->unix_ext = 0; /* server does not support them */
2484
2485         /* convert forward to back slashes in prepath here if needed */
2486         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2487                 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2488
2489         if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2490                 cifs_sb->rsize = 1024 * 127;
2491                 cFYI(DBG2, ("no very large read support, rsize now 127K"));
2492         }
2493         if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2494                 cifs_sb->wsize = min(cifs_sb->wsize,
2495                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2496         if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2497                 cifs_sb->rsize = min(cifs_sb->rsize,
2498                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2499
2500 remote_path_check:
2501         /* check if a whole path (including prepath) is not remote */
2502         if (!rc && cifs_sb->prepathlen && tcon) {
2503                 /* build_path_to_root works only when we have a valid tcon */
2504                 full_path = cifs_build_path_to_root(cifs_sb);
2505                 if (full_path == NULL) {
2506                         rc = -ENOMEM;
2507                         goto mount_fail_check;
2508                 }
2509                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2510                 if (rc != -EREMOTE) {
2511                         kfree(full_path);
2512                         goto mount_fail_check;
2513                 }
2514                 kfree(full_path);
2515         }
2516
2517         /* get referral if needed */
2518         if (rc == -EREMOTE) {
2519 #ifdef CONFIG_CIFS_DFS_UPCALL
2520                 if (referral_walks_count > MAX_NESTED_LINKS) {
2521                         /*
2522                          * BB: when we implement proper loop detection,
2523                          *     we will remove this check. But now we need it
2524                          *     to prevent an indefinite loop if 'DFS tree' is
2525                          *     misconfigured (i.e. has loops).
2526                          */
2527                         rc = -ELOOP;
2528                         goto mount_fail_check;
2529                 }
2530                 /* convert forward to back slashes in prepath here if needed */
2531                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2532                         convert_delimiter(cifs_sb->prepath,
2533                                         CIFS_DIR_SEP(cifs_sb));
2534                 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2535                 if (IS_ERR(full_path)) {
2536                         rc = PTR_ERR(full_path);
2537                         goto mount_fail_check;
2538                 }
2539
2540                 cFYI(1, ("Getting referral for: %s", full_path));
2541                 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2542                         cifs_sb->local_nls, &num_referrals, &referrals,
2543                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2544                 if (!rc && num_referrals > 0) {
2545                         char *fake_devname = NULL;
2546
2547                         if (mount_data != mount_data_global)
2548                                 kfree(mount_data);
2549                         mount_data = cifs_compose_mount_options(
2550                                         cifs_sb->mountdata, full_path + 1,
2551                                         referrals, &fake_devname);
2552                         kfree(fake_devname);
2553                         free_dfs_info_array(referrals, num_referrals);
2554
2555                         if (tcon)
2556                                 cifs_put_tcon(tcon);
2557                         else if (pSesInfo)
2558                                 cifs_put_smb_ses(pSesInfo);
2559
2560                         cleanup_volume_info(&volume_info);
2561                         FreeXid(xid);
2562                         kfree(full_path);
2563                         referral_walks_count++;
2564                         goto try_mount_again;
2565                 }
2566 #else /* No DFS support, return error on mount */
2567                 rc = -EOPNOTSUPP;
2568 #endif
2569         }
2570
2571 mount_fail_check:
2572         /* on error free sesinfo and tcon struct if needed */
2573         if (rc) {
2574                 if (mount_data != mount_data_global)
2575                         kfree(mount_data);
2576                 /* If find_unc succeeded then rc == 0 so we can not end */
2577                 /* up accidently freeing someone elses tcon struct */
2578                 if (tcon)
2579                         cifs_put_tcon(tcon);
2580                 else if (pSesInfo)
2581                         cifs_put_smb_ses(pSesInfo);
2582                 else
2583                         cifs_put_tcp_session(srvTcp);
2584                 goto out;
2585         }
2586
2587         /* volume_info->password is freed above when existing session found
2588         (in which case it is not needed anymore) but when new sesion is created
2589         the password ptr is put in the new session structure (in which case the
2590         password will be freed at unmount time) */
2591 out:
2592         /* zero out password before freeing */
2593         cleanup_volume_info(&volume_info);
2594         FreeXid(xid);
2595         return rc;
2596 }
2597
2598 int
2599 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2600          const char *tree, struct cifsTconInfo *tcon,
2601          const struct nls_table *nls_codepage)
2602 {
2603         struct smb_hdr *smb_buffer;
2604         struct smb_hdr *smb_buffer_response;
2605         TCONX_REQ *pSMB;
2606         TCONX_RSP *pSMBr;
2607         unsigned char *bcc_ptr;
2608         int rc = 0;
2609         int length, bytes_left;
2610         __u16 count;
2611
2612         if (ses == NULL)
2613                 return -EIO;
2614
2615         smb_buffer = cifs_buf_get();
2616         if (smb_buffer == NULL) {
2617                 return -ENOMEM;
2618         }
2619         smb_buffer_response = smb_buffer;
2620
2621         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2622                         NULL /*no tid */ , 4 /*wct */ );
2623
2624         smb_buffer->Mid = GetNextMid(ses->server);
2625         smb_buffer->Uid = ses->Suid;
2626         pSMB = (TCONX_REQ *) smb_buffer;
2627         pSMBr = (TCONX_RSP *) smb_buffer_response;
2628
2629         pSMB->AndXCommand = 0xFF;
2630         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2631         bcc_ptr = &pSMB->Password[0];
2632         if ((ses->server->secMode) & SECMODE_USER) {
2633                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
2634                 *bcc_ptr = 0; /* password is null byte */
2635                 bcc_ptr++;              /* skip password */
2636                 /* already aligned so no need to do it below */
2637         } else {
2638                 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
2639                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2640                    specified as required (when that support is added to
2641                    the vfs in the future) as only NTLM or the much
2642                    weaker LANMAN (which we do not send by default) is accepted
2643                    by Samba (not sure whether other servers allow
2644                    NTLMv2 password here) */
2645 #ifdef CONFIG_CIFS_WEAK_PW_HASH
2646                 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
2647                     (ses->server->secType == LANMAN))
2648                         calc_lanman_hash(tcon->password, ses->server->cryptKey,
2649                                          ses->server->secMode &
2650                                             SECMODE_PW_ENCRYPT ? true : false,
2651                                          bcc_ptr);
2652                 else
2653 #endif /* CIFS_WEAK_PW_HASH */
2654                 SMBNTencrypt(tcon->password, ses->server->cryptKey,
2655                              bcc_ptr);
2656
2657                 bcc_ptr += CIFS_SESS_KEY_SIZE;
2658                 if (ses->capabilities & CAP_UNICODE) {
2659                         /* must align unicode strings */
2660                         *bcc_ptr = 0; /* null byte password */
2661                         bcc_ptr++;
2662                 }
2663         }
2664
2665         if (ses->server->secMode &
2666                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2667                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2668
2669         if (ses->capabilities & CAP_STATUS32) {
2670                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2671         }
2672         if (ses->capabilities & CAP_DFS) {
2673                 smb_buffer->Flags2 |= SMBFLG2_DFS;
2674         }
2675         if (ses->capabilities & CAP_UNICODE) {
2676                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2677                 length =
2678                     cifs_strtoUCS((__le16 *) bcc_ptr, tree,
2679                         6 /* max utf8 char length in bytes */ *
2680                         (/* server len*/ + 256 /* share len */), nls_codepage);
2681                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
2682                 bcc_ptr += 2;   /* skip trailing null */
2683         } else {                /* ASCII */
2684                 strcpy(bcc_ptr, tree);
2685                 bcc_ptr += strlen(tree) + 1;
2686         }
2687         strcpy(bcc_ptr, "?????");
2688         bcc_ptr += strlen("?????");
2689         bcc_ptr += 1;
2690         count = bcc_ptr - &pSMB->Password[0];
2691         pSMB->hdr.smb_buf_length += count;
2692         pSMB->ByteCount = cpu_to_le16(count);
2693
2694         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
2695                          CIFS_STD_OP);
2696
2697         /* above now done in SendReceive */
2698         if ((rc == 0) && (tcon != NULL)) {
2699                 bool is_unicode;
2700
2701                 tcon->tidStatus = CifsGood;
2702                 tcon->need_reconnect = false;
2703                 tcon->tid = smb_buffer_response->Tid;
2704                 bcc_ptr = pByteArea(smb_buffer_response);
2705                 bytes_left = BCC(smb_buffer_response);
2706                 length = strnlen(bcc_ptr, bytes_left - 2);
2707                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
2708                         is_unicode = true;
2709                 else
2710                         is_unicode = false;
2711
2712
2713                 /* skip service field (NB: this field is always ASCII) */
2714                 if (length == 3) {
2715                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
2716                             (bcc_ptr[2] == 'C')) {
2717                                 cFYI(1, ("IPC connection"));
2718                                 tcon->ipc = 1;
2719                         }
2720                 } else if (length == 2) {
2721                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
2722                                 /* the most common case */
2723                                 cFYI(1, ("disk share connection"));
2724                         }
2725                 }
2726                 bcc_ptr += length + 1;
2727                 bytes_left -= (length + 1);
2728                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
2729
2730                 /* mostly informational -- no need to fail on error here */
2731                 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
2732                                                       bytes_left, is_unicode,
2733                                                       nls_codepage);
2734
2735                 cFYI(1, ("nativeFileSystem=%s", tcon->nativeFileSystem));
2736
2737                 if ((smb_buffer_response->WordCount == 3) ||
2738                          (smb_buffer_response->WordCount == 7))
2739                         /* field is in same location */
2740                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
2741                 else
2742                         tcon->Flags = 0;
2743                 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
2744         } else if ((rc == 0) && tcon == NULL) {
2745                 /* all we need to save for IPC$ connection */
2746                 ses->ipc_tid = smb_buffer_response->Tid;
2747         }
2748
2749         cifs_buf_release(smb_buffer);
2750         return rc;
2751 }
2752
2753 int
2754 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
2755 {
2756         int rc = 0;
2757         char *tmp;
2758
2759         if (cifs_sb->tcon)
2760                 cifs_put_tcon(cifs_sb->tcon);
2761
2762         cifs_sb->tcon = NULL;
2763         tmp = cifs_sb->prepath;
2764         cifs_sb->prepathlen = 0;
2765         cifs_sb->prepath = NULL;
2766         kfree(tmp);
2767
2768         return rc;
2769 }
2770
2771 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
2772                                            struct nls_table *nls_info)
2773 {
2774         int rc = 0;
2775         int first_time = 0;
2776         struct TCP_Server_Info *server = pSesInfo->server;
2777
2778         /* what if server changes its buffer size after dropping the session? */
2779         if (server->maxBuf == 0) /* no need to send on reconnect */ {
2780                 rc = CIFSSMBNegotiate(xid, pSesInfo);
2781                 if (rc == -EAGAIN) {
2782                         /* retry only once on 1st time connection */
2783                         rc = CIFSSMBNegotiate(xid, pSesInfo);
2784                         if (rc == -EAGAIN)
2785                                 rc = -EHOSTDOWN;
2786                 }
2787                 if (rc == 0) {
2788                         spin_lock(&GlobalMid_Lock);
2789                         if (server->tcpStatus != CifsExiting)
2790                                 server->tcpStatus = CifsGood;
2791                         else
2792                                 rc = -EHOSTDOWN;
2793                         spin_unlock(&GlobalMid_Lock);
2794
2795                 }
2796                 first_time = 1;
2797         }
2798
2799         if (rc)
2800                 goto ss_err_exit;
2801
2802         pSesInfo->flags = 0;
2803         pSesInfo->capabilities = server->capabilities;
2804         if (linuxExtEnabled == 0)
2805                 pSesInfo->capabilities &= (~CAP_UNIX);
2806
2807         cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
2808                  server->secMode, server->capabilities, server->timeAdj));
2809
2810         rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
2811         if (rc) {
2812                 cERROR(1, ("Send error in SessSetup = %d", rc));
2813         } else {
2814                 cFYI(1, ("CIFS Session Established successfully"));
2815                 spin_lock(&GlobalMid_Lock);
2816                 pSesInfo->status = CifsGood;
2817                 pSesInfo->need_reconnect = false;
2818                 spin_unlock(&GlobalMid_Lock);
2819         }
2820
2821 ss_err_exit:
2822         return rc;
2823 }
2824