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

   1 /*
   2  *   fs/cifs/cifssmb.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2008
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   Contains the routines for constructing the SMB PDUs themselves
   8  *
   9  *   This library is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU Lesser General Public License as published
  11  *   by the Free Software Foundation; either version 2.1 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This library is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  *   the GNU Lesser General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU Lesser General Public License
  20  *   along with this library; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24  /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c   */
  25  /* These are mostly routines that operate on a pathname, or on a tree id     */
  26  /* (mounted volume), but there are eight handle based routines which must be */
  27  /* treated slightly differently for reconnection purposes since we never     */
  28  /* want to reuse a stale file handle and only the caller knows the file info */
  29
  30 #include <linux/fs.h>
  31 #include <linux/kernel.h>
  32 #include <linux/vfs.h>
  33 #include <linux/posix_acl_xattr.h>
  34 #include <asm/uaccess.h>
  35 #include "cifspdu.h"
  36 #include "cifsglob.h"
  37 #include "cifsacl.h"
  38 #include "cifsproto.h"
  39 #include "cifs_unicode.h"
  40 #include "cifs_debug.h"
  41
  42 #ifdef CONFIG_CIFS_POSIX
  43 static struct {
  44         int index;
  45         char *name;
  46 } protocols[] = {
  47 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  48         {LANMAN_PROT, "\2LM1.2X002"},
  49         {LANMAN2_PROT, "\2LANMAN2.1"},
  50 #endif /* weak password hashing for legacy clients */
  51         {CIFS_PROT, "\2NT LM 0.12"},
  52         {POSIX_PROT, "\2POSIX 2"},
  53         {BAD_PROT, "\2"}
  54 };
  55 #else
  56 static struct {
  57         int index;
  58         char *name;
  59 } protocols[] = {
  60 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  61         {LANMAN_PROT, "\2LM1.2X002"},
  62         {LANMAN2_PROT, "\2LANMAN2.1"},
  63 #endif /* weak password hashing for legacy clients */
  64         {CIFS_PROT, "\2NT LM 0.12"},
  65         {BAD_PROT, "\2"}
  66 };
  67 #endif
  68
  69 /* define the number of elements in the cifs dialect array */
  70 #ifdef CONFIG_CIFS_POSIX
  71 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  72 #define CIFS_NUM_PROT 4
  73 #else
  74 #define CIFS_NUM_PROT 2
  75 #endif /* CIFS_WEAK_PW_HASH */
  76 #else /* not posix */
  77 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  78 #define CIFS_NUM_PROT 3
  79 #else
  80 #define CIFS_NUM_PROT 1
  81 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
  82 #endif /* CIFS_POSIX */
  83
  84
  85 /* Mark as invalid, all open files on tree connections since they
  86    were closed when session to server was lost */
  87 static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
  88 {
  89         struct cifsFileInfo *open_file = NULL;
  90         struct list_head *tmp;
  91         struct list_head *tmp1;
  92
  93 /* list all files open on tree connection and mark them invalid */
  94         write_lock(&GlobalSMBSeslock);
  95         list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
  96                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
  97                 if (open_file)
  98                         open_file->invalidHandle = TRUE;
  99         }
 100         write_unlock(&GlobalSMBSeslock);
 101         /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
 102            to this tcon */
 103 }
 104
 105 /* Allocate and return pointer to an SMB request buffer, and set basic
 106    SMB information in the SMB header.  If the return code is zero, this
 107    function must have filled in request_buf pointer */
 108 static int
 109 small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
 110                 void **request_buf)
 111 {
 112         int rc = 0;
 113
 114         /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
 115            check for tcp and smb session status done differently
 116            for those three - in the calling routine */
 117         if (tcon) {
 118                 if (tcon->tidStatus == CifsExiting) {
 119                         /* only tree disconnect, open, and write,
 120                         (and ulogoff which does not have tcon)
 121                         are allowed as we start force umount */
 122                         if ((smb_command != SMB_COM_WRITE_ANDX) &&
 123                            (smb_command != SMB_COM_OPEN_ANDX) &&
 124                            (smb_command != SMB_COM_TREE_DISCONNECT)) {
 125                                 cFYI(1, ("can not send cmd %d while umounting",
 126                                         smb_command));
 127                                 return -ENODEV;
 128                         }
 129                 }
 130                 if ((tcon->ses) && (tcon->ses->status != CifsExiting) &&
 131                                   (tcon->ses->server)) {
 132                         struct nls_table *nls_codepage;
 133                                 /* Give Demultiplex thread up to 10 seconds to
 134                                    reconnect, should be greater than cifs socket
 135                                    timeout which is 7 seconds */
 136                         while (tcon->ses->server->tcpStatus ==
 137                                                          CifsNeedReconnect) {
 138                                 wait_event_interruptible_timeout(tcon->ses->server->response_q,
 139                                         (tcon->ses->server->tcpStatus ==
 140                                                         CifsGood), 10 * HZ);
 141                                 if (tcon->ses->server->tcpStatus ==
 142                                                         CifsNeedReconnect) {
 143                                         /* on "soft" mounts we wait once */
 144                                         if ((tcon->retry == FALSE) ||
 145                                            (tcon->ses->status == CifsExiting)) {
 146                                                 cFYI(1, ("gave up waiting on "
 147                                                       "reconnect in smb_init"));
 148                                                 return -EHOSTDOWN;
 149                                         } /* else "hard" mount - keep retrying
 150                                              until process is killed or server
 151                                              comes back on-line */
 152                                 } else /* TCP session is reestablished now */
 153                                         break;
 154                         }
 155
 156                         nls_codepage = load_nls_default();
 157                 /* need to prevent multiple threads trying to
 158                 simultaneously reconnect the same SMB session */
 159                         down(&tcon->ses->sesSem);
 160                         if (tcon->ses->status == CifsNeedReconnect)
 161                                 rc = cifs_setup_session(0, tcon->ses,
 162                                                         nls_codepage);
 163                         if (!rc && (tcon->tidStatus == CifsNeedReconnect)) {
 164                                 mark_open_files_invalid(tcon);
 165                                 rc = CIFSTCon(0, tcon->ses, tcon->treeName,
 166                                               tcon, nls_codepage);
 167                                 up(&tcon->ses->sesSem);
 168                                 /* tell server which Unix caps we support */
 169                                 if (tcon->ses->capabilities & CAP_UNIX)
 170                                         reset_cifs_unix_caps(0 /* no xid */,
 171                                                 tcon,
 172                                                 NULL /* we do not know sb */,
 173                                                 NULL /* no vol info */);
 174                                 /* BB FIXME add code to check if wsize needs
 175                                    update due to negotiated smb buffer size
 176                                    shrinking */
 177                                 if (rc == 0)
 178                                         atomic_inc(&tconInfoReconnectCount);
 179
 180                                 cFYI(1, ("reconnect tcon rc = %d", rc));
 181                                 /* Removed call to reopen open files here.
 182                                    It is safer (and faster) to reopen files
 183                                    one at a time as needed in read and write */
 184
 185                                 /* Check if handle based operation so we
 186                                    know whether we can continue or not without
 187                                    returning to caller to reset file handle */
 188                                 switch (smb_command) {
 189                                         case SMB_COM_READ_ANDX:
 190                                         case SMB_COM_WRITE_ANDX:
 191                                         case SMB_COM_CLOSE:
 192                                         case SMB_COM_FIND_CLOSE2:
 193                                         case SMB_COM_LOCKING_ANDX: {
 194                                                 unload_nls(nls_codepage);
 195                                                 return -EAGAIN;
 196                                         }
 197                                 }
 198                         } else {
 199                                 up(&tcon->ses->sesSem);
 200                         }
 201                         unload_nls(nls_codepage);
 202
 203                 } else {
 204                         return -EIO;
 205                 }
 206         }
 207         if (rc)
 208                 return rc;
 209
 210         *request_buf = cifs_small_buf_get();
 211         if (*request_buf == NULL) {
 212                 /* BB should we add a retry in here if not a writepage? */
 213                 return -ENOMEM;
 214         }
 215
 216         header_assemble((struct smb_hdr *) *request_buf, smb_command,
 217                         tcon, wct);
 218
 219         if (tcon != NULL)
 220                 cifs_stats_inc(&tcon->num_smbs_sent);
 221
 222         return rc;
 223 }
 224
 225 int
 226 small_smb_init_no_tc(const int smb_command, const int wct,
 227                      struct cifsSesInfo *ses, void **request_buf)
 228 {
 229         int rc;
 230         struct smb_hdr *buffer;
 231
 232         rc = small_smb_init(smb_command, wct, NULL, request_buf);
 233         if (rc)
 234                 return rc;
 235
 236         buffer = (struct smb_hdr *)*request_buf;
 237         buffer->Mid = GetNextMid(ses->server);
 238         if (ses->capabilities & CAP_UNICODE)
 239                 buffer->Flags2 |= SMBFLG2_UNICODE;
 240         if (ses->capabilities & CAP_STATUS32)
 241                 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
 242
 243         /* uid, tid can stay at zero as set in header assemble */
 244
 245         /* BB add support for turning on the signing when
 246         this function is used after 1st of session setup requests */
 247
 248         return rc;
 249 }
 250
 251 /* If the return code is zero, this function must fill in request_buf pointer */
 252 static int
 253 smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
 254          void **request_buf /* returned */ ,
 255          void **response_buf /* returned */ )
 256 {
 257         int rc = 0;
 258
 259         /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
 260            check for tcp and smb session status done differently
 261            for those three - in the calling routine */
 262         if (tcon) {
 263                 if (tcon->tidStatus == CifsExiting) {
 264                         /* only tree disconnect, open, and write,
 265                           (and ulogoff which does not have tcon)
 266                           are allowed as we start force umount */
 267                         if ((smb_command != SMB_COM_WRITE_ANDX) &&
 268                            (smb_command != SMB_COM_OPEN_ANDX) &&
 269                            (smb_command != SMB_COM_TREE_DISCONNECT)) {
 270                                 cFYI(1, ("can not send cmd %d while umounting",
 271                                         smb_command));
 272                                 return -ENODEV;
 273                         }
 274                 }
 275
 276                 if ((tcon->ses) && (tcon->ses->status != CifsExiting) &&
 277                                   (tcon->ses->server)) {
 278                         struct nls_table *nls_codepage;
 279                                 /* Give Demultiplex thread up to 10 seconds to
 280                                    reconnect, should be greater than cifs socket
 281                                    timeout which is 7 seconds */
 282                         while (tcon->ses->server->tcpStatus ==
 283                                                         CifsNeedReconnect) {
 284                                 wait_event_interruptible_timeout(tcon->ses->server->response_q,
 285                                         (tcon->ses->server->tcpStatus ==
 286                                                         CifsGood), 10 * HZ);
 287                                 if (tcon->ses->server->tcpStatus ==
 288                                                 CifsNeedReconnect) {
 289                                         /* on "soft" mounts we wait once */
 290                                         if ((tcon->retry == FALSE) ||
 291                                            (tcon->ses->status == CifsExiting)) {
 292                                                 cFYI(1, ("gave up waiting on "
 293                                                       "reconnect in smb_init"));
 294                                                 return -EHOSTDOWN;
 295                                         } /* else "hard" mount - keep retrying
 296                                              until process is killed or server
 297                                              comes on-line */
 298                                 } else /* TCP session is reestablished now */
 299                                         break;
 300                         }
 301                         nls_codepage = load_nls_default();
 302                 /* need to prevent multiple threads trying to
 303                 simultaneously reconnect the same SMB session */
 304                         down(&tcon->ses->sesSem);
 305                         if (tcon->ses->status == CifsNeedReconnect)
 306                                 rc = cifs_setup_session(0, tcon->ses,
 307                                                         nls_codepage);
 308                         if (!rc && (tcon->tidStatus == CifsNeedReconnect)) {
 309                                 mark_open_files_invalid(tcon);
 310                                 rc = CIFSTCon(0, tcon->ses, tcon->treeName,
 311                                               tcon, nls_codepage);
 312                                 up(&tcon->ses->sesSem);
 313                                 /* tell server which Unix caps we support */
 314                                 if (tcon->ses->capabilities & CAP_UNIX)
 315                                         reset_cifs_unix_caps(0 /* no xid */,
 316                                                 tcon,
 317                                                 NULL /* do not know sb */,
 318                                                 NULL /* no vol info */);
 319                                 /* BB FIXME add code to check if wsize needs
 320                                 update due to negotiated smb buffer size
 321                                 shrinking */
 322                                 if (rc == 0)
 323                                         atomic_inc(&tconInfoReconnectCount);
 324
 325                                 cFYI(1, ("reconnect tcon rc = %d", rc));
 326                                 /* Removed call to reopen open files here.
 327                                    It is safer (and faster) to reopen files
 328                                    one at a time as needed in read and write */
 329
 330                                 /* Check if handle based operation so we
 331                                    know whether we can continue or not without
 332                                    returning to caller to reset file handle */
 333                                 switch (smb_command) {
 334                                         case SMB_COM_READ_ANDX:
 335                                         case SMB_COM_WRITE_ANDX:
 336                                         case SMB_COM_CLOSE:
 337                                         case SMB_COM_FIND_CLOSE2:
 338                                         case SMB_COM_LOCKING_ANDX: {
 339                                                 unload_nls(nls_codepage);
 340                                                 return -EAGAIN;
 341                                         }
 342                                 }
 343                         } else {
 344                                 up(&tcon->ses->sesSem);
 345                         }
 346                         unload_nls(nls_codepage);
 347
 348                 } else {
 349                         return -EIO;
 350                 }
 351         }
 352         if (rc)
 353                 return rc;
 354
 355         *request_buf = cifs_buf_get();
 356         if (*request_buf == NULL) {
 357                 /* BB should we add a retry in here if not a writepage? */
 358                 return -ENOMEM;
 359         }
 360     /* Although the original thought was we needed the response buf for  */
 361     /* potential retries of smb operations it turns out we can determine */
 362     /* from the mid flags when the request buffer can be resent without  */
 363     /* having to use a second distinct buffer for the response */
 364         if (response_buf)
 365                 *response_buf = *request_buf;
 366
 367         header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
 368                         wct);
 369
 370         if (tcon != NULL)
 371                 cifs_stats_inc(&tcon->num_smbs_sent);
 372
 373         return rc;
 374 }
 375
 376 static int validate_t2(struct smb_t2_rsp *pSMB)
 377 {
 378         int rc = -EINVAL;
 379         int total_size;
 380         char *pBCC;
 381
 382         /* check for plausible wct, bcc and t2 data and parm sizes */
 383         /* check for parm and data offset going beyond end of smb */
 384         if (pSMB->hdr.WordCount >= 10) {
 385                 if ((le16_to_cpu(pSMB->t2_rsp.ParameterOffset) <= 1024) &&
 386                    (le16_to_cpu(pSMB->t2_rsp.DataOffset) <= 1024)) {
 387                         /* check that bcc is at least as big as parms + data */
 388                         /* check that bcc is less than negotiated smb buffer */
 389                         total_size = le16_to_cpu(pSMB->t2_rsp.ParameterCount);
 390                         if (total_size < 512) {
 391                                 total_size +=
 392                                         le16_to_cpu(pSMB->t2_rsp.DataCount);
 393                                 /* BCC le converted in SendReceive */
 394                                 pBCC = (pSMB->hdr.WordCount * 2) +
 395                                         sizeof(struct smb_hdr) +
 396                                         (char *)pSMB;
 397                                 if ((total_size <= (*(u16 *)pBCC)) &&
 398                                    (total_size <
 399                                         CIFSMaxBufSize+MAX_CIFS_HDR_SIZE)) {
 400                                         return 0;
 401                                 }
 402                         }
 403                 }
 404         }
 405         cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
 406                 sizeof(struct smb_t2_rsp) + 16);
 407         return rc;
 408 }
 409 int
 410 CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
 411 {
 412         NEGOTIATE_REQ *pSMB;
 413         NEGOTIATE_RSP *pSMBr;
 414         int rc = 0;
 415         int bytes_returned;
 416         int i;
 417         struct TCP_Server_Info *server;
 418         u16 count;
 419         unsigned int secFlags;
 420         u16 dialect;
 421
 422         if (ses->server)
 423                 server = ses->server;
 424         else {
 425                 rc = -EIO;
 426                 return rc;
 427         }
 428         rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
 429                       (void **) &pSMB, (void **) &pSMBr);
 430         if (rc)
 431                 return rc;
 432
 433         /* if any of auth flags (ie not sign or seal) are overriden use them */
 434         if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
 435                 secFlags = ses->overrideSecFlg;  /* BB FIXME fix sign flags? */
 436         else /* if override flags set only sign/seal OR them with global auth */
 437                 secFlags = extended_security | ses->overrideSecFlg;
 438
 439         cFYI(1, ("secFlags 0x%x", secFlags));
 440
 441         pSMB->hdr.Mid = GetNextMid(server);
 442         pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
 443
 444         if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
 445                 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
 446         else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_KRB5) {
 447                 cFYI(1, ("Kerberos only mechanism, enable extended security"));
 448                 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
 449         }
 450
 451         count = 0;
 452         for (i = 0; i < CIFS_NUM_PROT; i++) {
 453                 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
 454                 count += strlen(protocols[i].name) + 1;
 455                 /* null at end of source and target buffers anyway */
 456         }
 457         pSMB->hdr.smb_buf_length += count;
 458         pSMB->ByteCount = cpu_to_le16(count);
 459
 460         rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
 461                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 462         if (rc != 0)
 463                 goto neg_err_exit;
 464
 465         dialect = le16_to_cpu(pSMBr->DialectIndex);
 466         cFYI(1, ("Dialect: %d", dialect));
 467         /* Check wct = 1 error case */
 468         if ((pSMBr->hdr.WordCount < 13) || (dialect == BAD_PROT)) {
 469                 /* core returns wct = 1, but we do not ask for core - otherwise
 470                 small wct just comes when dialect index is -1 indicating we
 471                 could not negotiate a common dialect */
 472                 rc = -EOPNOTSUPP;
 473                 goto neg_err_exit;
 474 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 475         } else if ((pSMBr->hdr.WordCount == 13)
 476                         && ((dialect == LANMAN_PROT)
 477                                 || (dialect == LANMAN2_PROT))) {
 478                 __s16 tmp;
 479                 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
 480
 481                 if ((secFlags & CIFSSEC_MAY_LANMAN) ||
 482                         (secFlags & CIFSSEC_MAY_PLNTXT))
 483                         server->secType = LANMAN;
 484                 else {
 485                         cERROR(1, ("mount failed weak security disabled"
 486                                    " in /proc/fs/cifs/SecurityFlags"));
 487                         rc = -EOPNOTSUPP;
 488                         goto neg_err_exit;
 489                 }
 490                 server->secMode = (__u8)le16_to_cpu(rsp->SecurityMode);
 491                 server->maxReq = le16_to_cpu(rsp->MaxMpxCount);
 492                 server->maxBuf = min((__u32)le16_to_cpu(rsp->MaxBufSize),
 493                                 (__u32)CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
 494                 GETU32(server->sessid) = le32_to_cpu(rsp->SessionKey);
 495                 /* even though we do not use raw we might as well set this
 496                 accurately, in case we ever find a need for it */
 497                 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
 498                         server->maxRw = 0xFF00;
 499                         server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
 500                 } else {
 501                         server->maxRw = 0;/* we do not need to use raw anyway */
 502                         server->capabilities = CAP_MPX_MODE;
 503                 }
 504                 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
 505                 if (tmp == -1) {
 506                         /* OS/2 often does not set timezone therefore
 507                          * we must use server time to calc time zone.
 508                          * Could deviate slightly from the right zone.
 509                          * Smallest defined timezone difference is 15 minutes
 510                          * (i.e. Nepal).  Rounding up/down is done to match
 511                          * this requirement.
 512                          */
 513                         int val, seconds, remain, result;
 514                         struct timespec ts, utc;
 515                         utc = CURRENT_TIME;
 516                         ts = cnvrtDosUnixTm(le16_to_cpu(rsp->SrvTime.Date),
 517                                                 le16_to_cpu(rsp->SrvTime.Time));
 518                         cFYI(1, ("SrvTime %d sec since 1970 (utc: %d) diff: %d",
 519                                 (int)ts.tv_sec, (int)utc.tv_sec,
 520                                 (int)(utc.tv_sec - ts.tv_sec)));
 521                         val = (int)(utc.tv_sec - ts.tv_sec);
 522                         seconds = abs(val);
 523                         result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
 524                         remain = seconds % MIN_TZ_ADJ;
 525                         if (remain >= (MIN_TZ_ADJ / 2))
 526                                 result += MIN_TZ_ADJ;
 527                         if (val < 0)
 528                                 result = -result;
 529                         server->timeAdj = result;
 530                 } else {
 531                         server->timeAdj = (int)tmp;
 532                         server->timeAdj *= 60; /* also in seconds */
 533                 }
 534                 cFYI(1, ("server->timeAdj: %d seconds", server->timeAdj));
 535
 536
 537                 /* BB get server time for time conversions and add
 538                 code to use it and timezone since this is not UTC */
 539
 540                 if (rsp->EncryptionKeyLength ==
 541                                 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
 542                         memcpy(server->cryptKey, rsp->EncryptionKey,
 543                                 CIFS_CRYPTO_KEY_SIZE);
 544                 } else if (server->secMode & SECMODE_PW_ENCRYPT) {
 545                         rc = -EIO; /* need cryptkey unless plain text */
 546                         goto neg_err_exit;
 547                 }
 548
 549                 cFYI(1, ("LANMAN negotiated"));
 550                 /* we will not end up setting signing flags - as no signing
 551                 was in LANMAN and server did not return the flags on */
 552                 goto signing_check;
 553 #else /* weak security disabled */
 554         } else if (pSMBr->hdr.WordCount == 13) {
 555                 cERROR(1, ("mount failed, cifs module not built "
 556                           "with CIFS_WEAK_PW_HASH support"));
 557                         rc = -EOPNOTSUPP;
 558 #endif /* WEAK_PW_HASH */
 559                 goto neg_err_exit;
 560         } else if (pSMBr->hdr.WordCount != 17) {
 561                 /* unknown wct */
 562                 rc = -EOPNOTSUPP;
 563                 goto neg_err_exit;
 564         }
 565         /* else wct == 17 NTLM */
 566         server->secMode = pSMBr->SecurityMode;
 567         if ((server->secMode & SECMODE_USER) == 0)
 568                 cFYI(1, ("share mode security"));
 569
 570         if ((server->secMode & SECMODE_PW_ENCRYPT) == 0)
 571 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 572                 if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
 573 #endif /* CIFS_WEAK_PW_HASH */
 574                         cERROR(1, ("Server requests plain text password"
 575                                   " but client support disabled"));
 576
 577         if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
 578                 server->secType = NTLMv2;
 579         else if (secFlags & CIFSSEC_MAY_NTLM)
 580                 server->secType = NTLM;
 581         else if (secFlags & CIFSSEC_MAY_NTLMV2)
 582                 server->secType = NTLMv2;
 583         else if (secFlags & CIFSSEC_MAY_KRB5)
 584                 server->secType = Kerberos;
 585         else if (secFlags & CIFSSEC_MAY_LANMAN)
 586                 server->secType = LANMAN;
 587 /* #ifdef CONFIG_CIFS_EXPERIMENTAL
 588         else if (secFlags & CIFSSEC_MAY_PLNTXT)
 589                 server->secType = ??
 590 #endif */
 591         else {
 592                 rc = -EOPNOTSUPP;
 593                 cERROR(1, ("Invalid security type"));
 594                 goto neg_err_exit;
 595         }
 596         /* else ... any others ...? */
 597
 598         /* one byte, so no need to convert this or EncryptionKeyLen from
 599            little endian */
 600         server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
 601         /* probably no need to store and check maxvcs */
 602         server->maxBuf = min(le32_to_cpu(pSMBr->MaxBufferSize),
 603                         (__u32) CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
 604         server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
 605         cFYI(DBG2, ("Max buf = %d", ses->server->maxBuf));
 606         GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
 607         server->capabilities = le32_to_cpu(pSMBr->Capabilities);
 608         server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
 609         server->timeAdj *= 60;
 610         if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
 611                 memcpy(server->cryptKey, pSMBr->u.EncryptionKey,
 612                        CIFS_CRYPTO_KEY_SIZE);
 613         } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC)
 614                         && (pSMBr->EncryptionKeyLength == 0)) {
 615                 /* decode security blob */
 616         } else if (server->secMode & SECMODE_PW_ENCRYPT) {
 617                 rc = -EIO; /* no crypt key only if plain text pwd */
 618                 goto neg_err_exit;
 619         }
 620
 621         /* BB might be helpful to save off the domain of server here */
 622
 623         if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) &&
 624                 (server->capabilities & CAP_EXTENDED_SECURITY)) {
 625                 count = pSMBr->ByteCount;
 626                 if (count < 16) {
 627                         rc = -EIO;
 628                         goto neg_err_exit;
 629                 }
 630
 631                 if (server->socketUseCount.counter > 1) {
 632                         if (memcmp(server->server_GUID,
 633                                    pSMBr->u.extended_response.
 634                                    GUID, 16) != 0) {
 635                                 cFYI(1, ("server UID changed"));
 636                                 memcpy(server->server_GUID,
 637                                         pSMBr->u.extended_response.GUID,
 638                                         16);
 639                         }
 640                 } else
 641                         memcpy(server->server_GUID,
 642                                pSMBr->u.extended_response.GUID, 16);
 643
 644                 if (count == 16) {
 645                         server->secType = RawNTLMSSP;
 646                 } else {
 647                         rc = decode_negTokenInit(pSMBr->u.extended_response.
 648                                                  SecurityBlob,
 649                                                  count - 16,
 650                                                  &server->secType);
 651                         if (rc == 1) {
 652                                 rc = 0;
 653                         } else {
 654                                 rc = -EINVAL;
 655                         }
 656                 }
 657         } else
 658                 server->capabilities &= ~CAP_EXTENDED_SECURITY;
 659
 660 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 661 signing_check:
 662 #endif
 663         if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
 664                 /* MUST_SIGN already includes the MAY_SIGN FLAG
 665                    so if this is zero it means that signing is disabled */
 666                 cFYI(1, ("Signing disabled"));
 667                 if (server->secMode & SECMODE_SIGN_REQUIRED) {
 668                         cERROR(1, ("Server requires "
 669                                    "packet signing to be enabled in "
 670                                    "/proc/fs/cifs/SecurityFlags."));
 671                         rc = -EOPNOTSUPP;
 672                 }
 673                 server->secMode &=
 674                         ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
 675         } else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
 676                 /* signing required */
 677                 cFYI(1, ("Must sign - secFlags 0x%x", secFlags));
 678                 if ((server->secMode &
 679                         (SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
 680                         cERROR(1,
 681                                 ("signing required but server lacks support"));
 682                         rc = -EOPNOTSUPP;
 683                 } else
 684                         server->secMode |= SECMODE_SIGN_REQUIRED;
 685         } else {
 686                 /* signing optional ie CIFSSEC_MAY_SIGN */
 687                 if ((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
 688                         server->secMode &=
 689                                 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
 690         }
 691
 692 neg_err_exit:
 693         cifs_buf_release(pSMB);
 694
 695         cFYI(1, ("negprot rc %d", rc));
 696         return rc;
 697 }
 698
 699 int
 700 CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
 701 {
 702         struct smb_hdr *smb_buffer;
 703         int rc = 0;
 704
 705         cFYI(1, ("In tree disconnect"));
 706         /*
 707          *  If last user of the connection and
 708          *  connection alive - disconnect it
 709          *  If this is the last connection on the server session disconnect it
 710          *  (and inside session disconnect we should check if tcp socket needs
 711          *  to be freed and kernel thread woken up).
 712          */
 713         if (tcon)
 714                 down(&tcon->tconSem);
 715         else
 716                 return -EIO;
 717
 718         atomic_dec(&tcon->useCount);
 719         if (atomic_read(&tcon->useCount) > 0) {
 720                 up(&tcon->tconSem);
 721                 return -EBUSY;
 722         }
 723
 724         /* No need to return error on this operation if tid invalidated and
 725         closed on server already e.g. due to tcp session crashing */
 726         if (tcon->tidStatus == CifsNeedReconnect) {
 727                 up(&tcon->tconSem);
 728                 return 0;
 729         }
 730
 731         if ((tcon->ses == NULL) || (tcon->ses->server == NULL)) {
 732                 up(&tcon->tconSem);
 733                 return -EIO;
 734         }
 735         rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
 736                             (void **)&smb_buffer);
 737         if (rc) {
 738                 up(&tcon->tconSem);
 739                 return rc;
 740         }
 741
 742         rc = SendReceiveNoRsp(xid, tcon->ses, smb_buffer, 0);
 743         if (rc)
 744                 cFYI(1, ("Tree disconnect failed %d", rc));
 745
 746         up(&tcon->tconSem);
 747
 748         /* No need to return error on this operation if tid invalidated and
 749         closed on server already e.g. due to tcp session crashing */
 750         if (rc == -EAGAIN)
 751                 rc = 0;
 752
 753         return rc;
 754 }
 755
 756 int
 757 CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
 758 {
 759         LOGOFF_ANDX_REQ *pSMB;
 760         int rc = 0;
 761
 762         cFYI(1, ("In SMBLogoff for session disconnect"));
 763         if (ses)
 764                 down(&ses->sesSem);
 765         else
 766                 return -EIO;
 767
 768         atomic_dec(&ses->inUse);
 769         if (atomic_read(&ses->inUse) > 0) {
 770                 up(&ses->sesSem);
 771                 return -EBUSY;
 772         }
 773         rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
 774         if (rc) {
 775                 up(&ses->sesSem);
 776                 return rc;
 777         }
 778
 779         if (ses->server) {
 780                 pSMB->hdr.Mid = GetNextMid(ses->server);
 781
 782                 if (ses->server->secMode &
 783                    (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 784                         pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 785         }
 786
 787         pSMB->hdr.Uid = ses->Suid;
 788
 789         pSMB->AndXCommand = 0xFF;
 790         rc = SendReceiveNoRsp(xid, ses, (struct smb_hdr *) pSMB, 0);
 791         if (ses->server) {
 792                 atomic_dec(&ses->server->socketUseCount);
 793                 if (atomic_read(&ses->server->socketUseCount) == 0) {
 794                         spin_lock(&GlobalMid_Lock);
 795                         ses->server->tcpStatus = CifsExiting;
 796                         spin_unlock(&GlobalMid_Lock);
 797                         rc = -ESHUTDOWN;
 798                 }
 799         }
 800         up(&ses->sesSem);
 801
 802         /* if session dead then we do not need to do ulogoff,
 803                 since server closed smb session, no sense reporting
 804                 error */
 805         if (rc == -EAGAIN)
 806                 rc = 0;
 807         return rc;
 808 }
 809
 810 int
 811 CIFSPOSIXDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
 812                  __u16 type, const struct nls_table *nls_codepage, int remap)
 813 {
 814         TRANSACTION2_SPI_REQ *pSMB = NULL;
 815         TRANSACTION2_SPI_RSP *pSMBr = NULL;
 816         struct unlink_psx_rq *pRqD;
 817         int name_len;
 818         int rc = 0;
 819         int bytes_returned = 0;
 820         __u16 params, param_offset, offset, byte_count;
 821
 822         cFYI(1, ("In POSIX delete"));
 823 PsxDelete:
 824         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
 825                       (void **) &pSMBr);
 826         if (rc)
 827                 return rc;
 828
 829         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
 830                 name_len =
 831                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
 832                                      PATH_MAX, nls_codepage, remap);
 833                 name_len++;     /* trailing null */
 834                 name_len *= 2;
 835         } else { /* BB add path length overrun check */
 836                 name_len = strnlen(fileName, PATH_MAX);
 837                 name_len++;     /* trailing null */
 838                 strncpy(pSMB->FileName, fileName, name_len);
 839         }
 840
 841         params = 6 + name_len;
 842         pSMB->MaxParameterCount = cpu_to_le16(2);
 843         pSMB->MaxDataCount = 0; /* BB double check this with jra */
 844         pSMB->MaxSetupCount = 0;
 845         pSMB->Reserved = 0;
 846         pSMB->Flags = 0;
 847         pSMB->Timeout = 0;
 848         pSMB->Reserved2 = 0;
 849         param_offset = offsetof(struct smb_com_transaction2_spi_req,
 850                                 InformationLevel) - 4;
 851         offset = param_offset + params;
 852
 853         /* Setup pointer to Request Data (inode type) */
 854         pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
 855         pRqD->type = cpu_to_le16(type);
 856         pSMB->ParameterOffset = cpu_to_le16(param_offset);
 857         pSMB->DataOffset = cpu_to_le16(offset);
 858         pSMB->SetupCount = 1;
 859         pSMB->Reserved3 = 0;
 860         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
 861         byte_count = 3 /* pad */  + params + sizeof(struct unlink_psx_rq);
 862
 863         pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
 864         pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
 865         pSMB->ParameterCount = cpu_to_le16(params);
 866         pSMB->TotalParameterCount = pSMB->ParameterCount;
 867         pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
 868         pSMB->Reserved4 = 0;
 869         pSMB->hdr.smb_buf_length += byte_count;
 870         pSMB->ByteCount = cpu_to_le16(byte_count);
 871         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
 872                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 873         if (rc)
 874                 cFYI(1, ("Posix delete returned %d", rc));
 875         cifs_buf_release(pSMB);
 876
 877         cifs_stats_inc(&tcon->num_deletes);
 878
 879         if (rc == -EAGAIN)
 880                 goto PsxDelete;
 881
 882         return rc;
 883 }
 884
 885 int
 886 CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
 887                const struct nls_table *nls_codepage, int remap)
 888 {
 889         DELETE_FILE_REQ *pSMB = NULL;
 890         DELETE_FILE_RSP *pSMBr = NULL;
 891         int rc = 0;
 892         int bytes_returned;
 893         int name_len;
 894
 895 DelFileRetry:
 896         rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
 897                       (void **) &pSMBr);
 898         if (rc)
 899                 return rc;
 900
 901         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
 902                 name_len =
 903                     cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
 904                                      PATH_MAX, nls_codepage, remap);
 905                 name_len++;     /* trailing null */
 906                 name_len *= 2;
 907         } else {                /* BB improve check for buffer overruns BB */
 908                 name_len = strnlen(fileName, PATH_MAX);
 909                 name_len++;     /* trailing null */
 910                 strncpy(pSMB->fileName, fileName, name_len);
 911         }
 912         pSMB->SearchAttributes =
 913             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
 914         pSMB->BufferFormat = 0x04;
 915         pSMB->hdr.smb_buf_length += name_len + 1;
 916         pSMB->ByteCount = cpu_to_le16(name_len + 1);
 917         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
 918                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 919         cifs_stats_inc(&tcon->num_deletes);
 920         if (rc)
 921                 cFYI(1, ("Error in RMFile = %d", rc));
 922
 923         cifs_buf_release(pSMB);
 924         if (rc == -EAGAIN)
 925                 goto DelFileRetry;
 926
 927         return rc;
 928 }
 929
 930 int
 931 CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon, const char *dirName,
 932              const struct nls_table *nls_codepage, int remap)
 933 {
 934         DELETE_DIRECTORY_REQ *pSMB = NULL;
 935         DELETE_DIRECTORY_RSP *pSMBr = NULL;
 936         int rc = 0;
 937         int bytes_returned;
 938         int name_len;
 939
 940         cFYI(1, ("In CIFSSMBRmDir"));
 941 RmDirRetry:
 942         rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
 943                       (void **) &pSMBr);
 944         if (rc)
 945                 return rc;
 946
 947         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
 948                 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, dirName,
 949                                          PATH_MAX, nls_codepage, remap);
 950                 name_len++;     /* trailing null */
 951                 name_len *= 2;
 952         } else {                /* BB improve check for buffer overruns BB */
 953                 name_len = strnlen(dirName, PATH_MAX);
 954                 name_len++;     /* trailing null */
 955                 strncpy(pSMB->DirName, dirName, name_len);
 956         }
 957
 958         pSMB->BufferFormat = 0x04;
 959         pSMB->hdr.smb_buf_length += name_len + 1;
 960         pSMB->ByteCount = cpu_to_le16(name_len + 1);
 961         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
 962                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 963         cifs_stats_inc(&tcon->num_rmdirs);
 964         if (rc)
 965                 cFYI(1, ("Error in RMDir = %d", rc));
 966
 967         cifs_buf_release(pSMB);
 968         if (rc == -EAGAIN)
 969                 goto RmDirRetry;
 970         return rc;
 971 }
 972
 973 int
 974 CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
 975              const char *name, const struct nls_table *nls_codepage, int remap)
 976 {
 977         int rc = 0;
 978         CREATE_DIRECTORY_REQ *pSMB = NULL;
 979         CREATE_DIRECTORY_RSP *pSMBr = NULL;
 980         int bytes_returned;
 981         int name_len;
 982
 983         cFYI(1, ("In CIFSSMBMkDir"));
 984 MkDirRetry:
 985         rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
 986                       (void **) &pSMBr);
 987         if (rc)
 988                 return rc;
 989
 990         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
 991                 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
 992                                             PATH_MAX, nls_codepage, remap);
 993                 name_len++;     /* trailing null */
 994                 name_len *= 2;
 995         } else {                /* BB improve check for buffer overruns BB */
 996                 name_len = strnlen(name, PATH_MAX);
 997                 name_len++;     /* trailing null */
 998                 strncpy(pSMB->DirName, name, name_len);
 999         }
1000
1001         pSMB->BufferFormat = 0x04;
1002         pSMB->hdr.smb_buf_length += name_len + 1;
1003         pSMB->ByteCount = cpu_to_le16(name_len + 1);
1004         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1005                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1006         cifs_stats_inc(&tcon->num_mkdirs);
1007         if (rc)
1008                 cFYI(1, ("Error in Mkdir = %d", rc));
1009
1010         cifs_buf_release(pSMB);
1011         if (rc == -EAGAIN)
1012                 goto MkDirRetry;
1013         return rc;
1014 }
1015
1016 int
1017 CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
1018                 __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
1019                 __u32 *pOplock, const char *name,
1020                 const struct nls_table *nls_codepage, int remap)
1021 {
1022         TRANSACTION2_SPI_REQ *pSMB = NULL;
1023         TRANSACTION2_SPI_RSP *pSMBr = NULL;
1024         int name_len;
1025         int rc = 0;
1026         int bytes_returned = 0;
1027         __u16 params, param_offset, offset, byte_count, count;
1028         OPEN_PSX_REQ *pdata;
1029         OPEN_PSX_RSP *psx_rsp;
1030
1031         cFYI(1, ("In POSIX Create"));
1032 PsxCreat:
1033         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1034                       (void **) &pSMBr);
1035         if (rc)
1036                 return rc;
1037
1038         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1039                 name_len =
1040                     cifsConvertToUCS((__le16 *) pSMB->FileName, name,
1041                                      PATH_MAX, nls_codepage, remap);
1042                 name_len++;     /* trailing null */
1043                 name_len *= 2;
1044         } else {        /* BB improve the check for buffer overruns BB */
1045                 name_len = strnlen(name, PATH_MAX);
1046                 name_len++;     /* trailing null */
1047                 strncpy(pSMB->FileName, name, name_len);
1048         }
1049
1050         params = 6 + name_len;
1051         count = sizeof(OPEN_PSX_REQ);
1052         pSMB->MaxParameterCount = cpu_to_le16(2);
1053         pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1054         pSMB->MaxSetupCount = 0;
1055         pSMB->Reserved = 0;
1056         pSMB->Flags = 0;
1057         pSMB->Timeout = 0;
1058         pSMB->Reserved2 = 0;
1059         param_offset = offsetof(struct smb_com_transaction2_spi_req,
1060                                 InformationLevel) - 4;
1061         offset = param_offset + params;
1062         pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
1063         pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1064         pdata->Permissions = cpu_to_le64(mode);
1065         pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
1066         pdata->OpenFlags =  cpu_to_le32(*pOplock);
1067         pSMB->ParameterOffset = cpu_to_le16(param_offset);
1068         pSMB->DataOffset = cpu_to_le16(offset);
1069         pSMB->SetupCount = 1;
1070         pSMB->Reserved3 = 0;
1071         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1072         byte_count = 3 /* pad */  + params + count;
1073
1074         pSMB->DataCount = cpu_to_le16(count);
1075         pSMB->ParameterCount = cpu_to_le16(params);
1076         pSMB->TotalDataCount = pSMB->DataCount;
1077         pSMB->TotalParameterCount = pSMB->ParameterCount;
1078         pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1079         pSMB->Reserved4 = 0;
1080         pSMB->hdr.smb_buf_length += byte_count;
1081         pSMB->ByteCount = cpu_to_le16(byte_count);
1082         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1083                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1084         if (rc) {
1085                 cFYI(1, ("Posix create returned %d", rc));
1086                 goto psx_create_err;
1087         }
1088
1089         cFYI(1, ("copying inode info"));
1090         rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1091
1092         if (rc || (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP))) {
1093                 rc = -EIO;      /* bad smb */
1094                 goto psx_create_err;
1095         }
1096
1097         /* copy return information to pRetData */
1098         psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
1099                         + le16_to_cpu(pSMBr->t2.DataOffset));
1100
1101         *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
1102         if (netfid)
1103                 *netfid = psx_rsp->Fid;   /* cifs fid stays in le */
1104         /* Let caller know file was created so we can set the mode. */
1105         /* Do we care about the CreateAction in any other cases? */
1106         if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
1107                 *pOplock |= CIFS_CREATE_ACTION;
1108         /* check to make sure response data is there */
1109         if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1110                 pRetData->Type = cpu_to_le32(-1); /* unknown */
1111                 cFYI(DBG2, ("unknown type"));
1112         } else {
1113                 if (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP)
1114                                         + sizeof(FILE_UNIX_BASIC_INFO)) {
1115                         cERROR(1, ("Open response data too small"));
1116                         pRetData->Type = cpu_to_le32(-1);
1117                         goto psx_create_err;
1118                 }
1119                 memcpy((char *) pRetData,
1120                         (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
1121                         sizeof(FILE_UNIX_BASIC_INFO));
1122         }
1123
1124 psx_create_err:
1125         cifs_buf_release(pSMB);
1126
1127         cifs_stats_inc(&tcon->num_mkdirs);
1128
1129         if (rc == -EAGAIN)
1130                 goto PsxCreat;
1131
1132         return rc;
1133 }
1134
1135 static __u16 convert_disposition(int disposition)
1136 {
1137         __u16 ofun = 0;
1138
1139         switch (disposition) {
1140                 case FILE_SUPERSEDE:
1141                         ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1142                         break;
1143                 case FILE_OPEN:
1144                         ofun = SMBOPEN_OAPPEND;
1145                         break;
1146                 case FILE_CREATE:
1147                         ofun = SMBOPEN_OCREATE;
1148                         break;
1149                 case FILE_OPEN_IF:
1150                         ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1151                         break;
1152                 case FILE_OVERWRITE:
1153                         ofun = SMBOPEN_OTRUNC;
1154                         break;
1155                 case FILE_OVERWRITE_IF:
1156                         ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1157                         break;
1158                 default:
1159                         cFYI(1, ("unknown disposition %d", disposition));
1160                         ofun =  SMBOPEN_OAPPEND; /* regular open */
1161         }
1162         return ofun;
1163 }
1164
1165 int
1166 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
1167             const char *fileName, const int openDisposition,
1168             const int access_flags, const int create_options, __u16 *netfid,
1169             int *pOplock, FILE_ALL_INFO *pfile_info,
1170             const struct nls_table *nls_codepage, int remap)
1171 {
1172         int rc = -EACCES;
1173         OPENX_REQ *pSMB = NULL;
1174         OPENX_RSP *pSMBr = NULL;
1175         int bytes_returned;
1176         int name_len;
1177         __u16 count;
1178
1179 OldOpenRetry:
1180         rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1181                       (void **) &pSMBr);
1182         if (rc)
1183                 return rc;
1184
1185         pSMB->AndXCommand = 0xFF;       /* none */
1186
1187         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1188                 count = 1;      /* account for one byte pad to word boundary */
1189                 name_len =
1190                    cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1191                                     fileName, PATH_MAX, nls_codepage, remap);
1192                 name_len++;     /* trailing null */
1193                 name_len *= 2;
1194         } else {                /* BB improve check for buffer overruns BB */
1195                 count = 0;      /* no pad */
1196                 name_len = strnlen(fileName, PATH_MAX);
1197                 name_len++;     /* trailing null */
1198                 strncpy(pSMB->fileName, fileName, name_len);
1199         }
1200         if (*pOplock & REQ_OPLOCK)
1201                 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1202         else if (*pOplock & REQ_BATCHOPLOCK)
1203                 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1204
1205         pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1206         /* BB fixme add conversion for access_flags to bits 0 - 2 of mode */
1207         /* 0 = read
1208            1 = write
1209            2 = rw
1210            3 = execute
1211          */
1212         pSMB->Mode = cpu_to_le16(2);
1213         pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1214         /* set file as system file if special file such
1215            as fifo and server expecting SFU style and
1216            no Unix extensions */
1217
1218         if (create_options & CREATE_OPTION_SPECIAL)
1219                 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1220         else /* BB FIXME BB */
1221                 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1222
1223         /* if ((omode & S_IWUGO) == 0)
1224                 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
1225         /*  Above line causes problems due to vfs splitting create into two
1226             pieces - need to set mode after file created not while it is
1227             being created */
1228
1229         /* BB FIXME BB */
1230 /*      pSMB->CreateOptions = cpu_to_le32(create_options &
1231                                                  CREATE_OPTIONS_MASK); */
1232         /* BB FIXME END BB */
1233
1234         pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1235         pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1236         count += name_len;
1237         pSMB->hdr.smb_buf_length += count;
1238
1239         pSMB->ByteCount = cpu_to_le16(count);
1240         /* long_op set to 1 to allow for oplock break timeouts */
1241         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1242                         (struct smb_hdr *)pSMBr, &bytes_returned, CIFS_LONG_OP);
1243         cifs_stats_inc(&tcon->num_opens);
1244         if (rc) {
1245                 cFYI(1, ("Error in Open = %d", rc));
1246         } else {
1247         /* BB verify if wct == 15 */
1248
1249 /*              *pOplock = pSMBr->OplockLevel; */  /* BB take from action field BB */
1250
1251                 *netfid = pSMBr->Fid;   /* cifs fid stays in le */
1252                 /* Let caller know file was created so we can set the mode. */
1253                 /* Do we care about the CreateAction in any other cases? */
1254         /* BB FIXME BB */
1255 /*              if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1256                         *pOplock |= CIFS_CREATE_ACTION; */
1257         /* BB FIXME END */
1258
1259                 if (pfile_info) {
1260                         pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1261                         pfile_info->LastAccessTime = 0; /* BB fixme */
1262                         pfile_info->LastWriteTime = 0; /* BB fixme */
1263                         pfile_info->ChangeTime = 0;  /* BB fixme */
1264                         pfile_info->Attributes =
1265                                 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1266                         /* the file_info buf is endian converted by caller */
1267                         pfile_info->AllocationSize =
1268                                 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1269                         pfile_info->EndOfFile = pfile_info->AllocationSize;
1270                         pfile_info->NumberOfLinks = cpu_to_le32(1);
1271                 }
1272         }
1273
1274         cifs_buf_release(pSMB);
1275         if (rc == -EAGAIN)
1276                 goto OldOpenRetry;
1277         return rc;
1278 }
1279
1280 int
1281 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
1282             const char *fileName, const int openDisposition,
1283             const int access_flags, const int create_options, __u16 *netfid,
1284             int *pOplock, FILE_ALL_INFO *pfile_info,
1285             const struct nls_table *nls_codepage, int remap)
1286 {
1287         int rc = -EACCES;
1288         OPEN_REQ *pSMB = NULL;
1289         OPEN_RSP *pSMBr = NULL;
1290         int bytes_returned;
1291         int name_len;
1292         __u16 count;
1293
1294 openRetry:
1295         rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1296                       (void **) &pSMBr);
1297         if (rc)
1298                 return rc;
1299
1300         pSMB->AndXCommand = 0xFF;       /* none */
1301
1302         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1303                 count = 1;      /* account for one byte pad to word boundary */
1304                 name_len =
1305                     cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1306                                      fileName, PATH_MAX, nls_codepage, remap);
1307                 name_len++;     /* trailing null */
1308                 name_len *= 2;
1309                 pSMB->NameLength = cpu_to_le16(name_len);
1310         } else {                /* BB improve check for buffer overruns BB */
1311                 count = 0;      /* no pad */
1312                 name_len = strnlen(fileName, PATH_MAX);
1313                 name_len++;     /* trailing null */
1314                 pSMB->NameLength = cpu_to_le16(name_len);
1315                 strncpy(pSMB->fileName, fileName, name_len);
1316         }
1317         if (*pOplock & REQ_OPLOCK)
1318                 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1319         else if (*pOplock & REQ_BATCHOPLOCK)
1320                 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1321         pSMB->DesiredAccess = cpu_to_le32(access_flags);
1322         pSMB->AllocationSize = 0;
1323         /* set file as system file if special file such
1324            as fifo and server expecting SFU style and
1325            no Unix extensions */
1326         if (create_options & CREATE_OPTION_SPECIAL)
1327                 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1328         else
1329                 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1330         /* XP does not handle ATTR_POSIX_SEMANTICS */
1331         /* but it helps speed up case sensitive checks for other
1332         servers such as Samba */
1333         if (tcon->ses->capabilities & CAP_UNIX)
1334                 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1335
1336         /* if ((omode & S_IWUGO) == 0)
1337                 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
1338         /*  Above line causes problems due to vfs splitting create into two
1339                 pieces - need to set mode after file created not while it is
1340                 being created */
1341         pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1342         pSMB->CreateDisposition = cpu_to_le32(openDisposition);
1343         pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1344         /* BB Expirement with various impersonation levels and verify */
1345         pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1346         pSMB->SecurityFlags =
1347             SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1348
1349         count += name_len;
1350         pSMB->hdr.smb_buf_length += count;
1351
1352         pSMB->ByteCount = cpu_to_le16(count);
1353         /* long_op set to 1 to allow for oplock break timeouts */
1354         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1355                         (struct smb_hdr *)pSMBr, &bytes_returned, CIFS_LONG_OP);
1356         cifs_stats_inc(&tcon->num_opens);
1357         if (rc) {
1358                 cFYI(1, ("Error in Open = %d", rc));
1359         } else {
1360                 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
1361                 *netfid = pSMBr->Fid;   /* cifs fid stays in le */
1362                 /* Let caller know file was created so we can set the mode. */
1363                 /* Do we care about the CreateAction in any other cases? */
1364                 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1365                         *pOplock |= CIFS_CREATE_ACTION;
1366                 if (pfile_info) {
1367                     memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1368                         36 /* CreationTime to Attributes */);
1369                     /* the file_info buf is endian converted by caller */
1370                     pfile_info->AllocationSize = pSMBr->AllocationSize;
1371                     pfile_info->EndOfFile = pSMBr->EndOfFile;
1372                     pfile_info->NumberOfLinks = cpu_to_le32(1);
1373                 }
1374         }
1375
1376         cifs_buf_release(pSMB);
1377         if (rc == -EAGAIN)
1378                 goto openRetry;
1379         return rc;
1380 }
1381
1382 int
1383 CIFSSMBRead(const int xid, struct cifsTconInfo *tcon, const int netfid,
1384             const unsigned int count, const __u64 lseek, unsigned int *nbytes,
1385             char **buf, int *pbuf_type)
1386 {
1387         int rc = -EACCES;
1388         READ_REQ *pSMB = NULL;
1389         READ_RSP *pSMBr = NULL;
1390         char *pReadData = NULL;
1391         int wct;
1392         int resp_buf_type = 0;
1393         struct kvec iov[1];
1394
1395         cFYI(1, ("Reading %d bytes on fid %d", count, netfid));
1396         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1397                 wct = 12;
1398         else
1399                 wct = 10; /* old style read */
1400
1401         *nbytes = 0;
1402         rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1403         if (rc)
1404                 return rc;
1405
1406         /* tcon and ses pointer are checked in smb_init */
1407         if (tcon->ses->server == NULL)
1408                 return -ECONNABORTED;
1409
1410         pSMB->AndXCommand = 0xFF;       /* none */
1411         pSMB->Fid = netfid;
1412         pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
1413         if (wct == 12)
1414                 pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
1415         else if ((lseek >> 32) > 0) /* can not handle this big offset for old */
1416                 return -EIO;
1417
1418         pSMB->Remaining = 0;
1419         pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1420         pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1421         if (wct == 12)
1422                 pSMB->ByteCount = 0;  /* no need to do le conversion since 0 */
1423         else {
1424                 /* old style read */
1425                 struct smb_com_readx_req *pSMBW =
1426                         (struct smb_com_readx_req *)pSMB;
1427                 pSMBW->ByteCount = 0;
1428         }
1429
1430         iov[0].iov_base = (char *)pSMB;
1431         iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1432         rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1433                          &resp_buf_type, CIFS_STD_OP | CIFS_LOG_ERROR);
1434         cifs_stats_inc(&tcon->num_reads);
1435         pSMBr = (READ_RSP *)iov[0].iov_base;
1436         if (rc) {
1437                 cERROR(1, ("Send error in read = %d", rc));
1438         } else {
1439                 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1440                 data_length = data_length << 16;
1441                 data_length += le16_to_cpu(pSMBr->DataLength);
1442                 *nbytes = data_length;
1443
1444                 /*check that DataLength would not go beyond end of SMB */
1445                 if ((data_length > CIFSMaxBufSize)
1446                                 || (data_length > count)) {
1447                         cFYI(1, ("bad length %d for count %d",
1448                                  data_length, count));
1449                         rc = -EIO;
1450                         *nbytes = 0;
1451                 } else {
1452                         pReadData = (char *) (&pSMBr->hdr.Protocol) +
1453                                         le16_to_cpu(pSMBr->DataOffset);
1454 /*                      if (rc = copy_to_user(buf, pReadData, data_length)) {
1455                                 cERROR(1,("Faulting on read rc = %d",rc));
1456                                 rc = -EFAULT;
1457                         }*/ /* can not use copy_to_user when using page cache*/
1458                         if (*buf)
1459                                 memcpy(*buf, pReadData, data_length);
1460                 }
1461         }
1462
1463 /*      cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1464         if (*buf) {
1465                 if (resp_buf_type == CIFS_SMALL_BUFFER)
1466                         cifs_small_buf_release(iov[0].iov_base);
1467                 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1468                         cifs_buf_release(iov[0].iov_base);
1469         } else if (resp_buf_type != CIFS_NO_BUFFER) {
1470                 /* return buffer to caller to free */
1471                 *buf = iov[0].iov_base;
1472                 if (resp_buf_type == CIFS_SMALL_BUFFER)
1473                         *pbuf_type = CIFS_SMALL_BUFFER;
1474                 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1475                         *pbuf_type = CIFS_LARGE_BUFFER;
1476         } /* else no valid buffer on return - leave as null */
1477
1478         /* Note: On -EAGAIN error only caller can retry on handle based calls
1479                 since file handle passed in no longer valid */
1480         return rc;
1481 }
1482
1483
1484 int
1485 CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
1486              const int netfid, const unsigned int count,
1487              const __u64 offset, unsigned int *nbytes, const char *buf,
1488              const char __user *ubuf, const int long_op)
1489 {
1490         int rc = -EACCES;
1491         WRITE_REQ *pSMB = NULL;
1492         WRITE_RSP *pSMBr = NULL;
1493         int bytes_returned, wct;
1494         __u32 bytes_sent;
1495         __u16 byte_count;
1496
1497         /* cFYI(1,("write at %lld %d bytes",offset,count));*/
1498         if (tcon->ses == NULL)
1499                 return -ECONNABORTED;
1500
1501         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1502                 wct = 14;
1503         else
1504                 wct = 12;
1505
1506         rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1507                       (void **) &pSMBr);
1508         if (rc)
1509                 return rc;
1510         /* tcon and ses pointer are checked in smb_init */
1511         if (tcon->ses->server == NULL)
1512                 return -ECONNABORTED;
1513
1514         pSMB->AndXCommand = 0xFF;       /* none */
1515         pSMB->Fid = netfid;
1516         pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1517         if (wct == 14)
1518                 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1519         else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1520                 return -EIO;
1521
1522         pSMB->Reserved = 0xFFFFFFFF;
1523         pSMB->WriteMode = 0;
1524         pSMB->Remaining = 0;
1525
1526         /* Can increase buffer size if buffer is big enough in some cases ie we
1527         can send more if LARGE_WRITE_X capability returned by the server and if
1528         our buffer is big enough or if we convert to iovecs on socket writes
1529         and eliminate the copy to the CIFS buffer */
1530         if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1531                 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1532         } else {
1533                 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1534                          & ~0xFF;
1535         }
1536
1537         if (bytes_sent > count)
1538                 bytes_sent = count;
1539         pSMB->DataOffset =
1540                 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1541         if (buf)
1542             memcpy(pSMB->Data, buf, bytes_sent);
1543         else if (ubuf) {
1544                 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1545                         cifs_buf_release(pSMB);
1546                         return -EFAULT;
1547                 }
1548         } else if (count != 0) {
1549                 /* No buffer */
1550                 cifs_buf_release(pSMB);
1551                 return -EINVAL;
1552         } /* else setting file size with write of zero bytes */
1553         if (wct == 14)
1554                 byte_count = bytes_sent + 1; /* pad */
1555         else /* wct == 12 */
1556                 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1557
1558         pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1559         pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1560         pSMB->hdr.smb_buf_length += byte_count;
1561
1562         if (wct == 14)
1563                 pSMB->ByteCount = cpu_to_le16(byte_count);
1564         else { /* old style write has byte count 4 bytes earlier
1565                   so 4 bytes pad  */
1566                 struct smb_com_writex_req *pSMBW =
1567                         (struct smb_com_writex_req *)pSMB;
1568                 pSMBW->ByteCount = cpu_to_le16(byte_count);
1569         }
1570
1571         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1572                          (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1573         cifs_stats_inc(&tcon->num_writes);
1574         if (rc) {
1575                 cFYI(1, ("Send error in write = %d", rc));
1576                 *nbytes = 0;
1577         } else {
1578                 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1579                 *nbytes = (*nbytes) << 16;
1580                 *nbytes += le16_to_cpu(pSMBr->Count);
1581         }
1582
1583         cifs_buf_release(pSMB);
1584
1585         /* Note: On -EAGAIN error only caller can retry on handle based calls
1586                 since file handle passed in no longer valid */
1587
1588         return rc;
1589 }
1590
1591 int
1592 CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
1593              const int netfid, const unsigned int count,
1594              const __u64 offset, unsigned int *nbytes, struct kvec *iov,
1595              int n_vec, const int long_op)
1596 {
1597         int rc = -EACCES;
1598         WRITE_REQ *pSMB = NULL;
1599         int wct;
1600         int smb_hdr_len;
1601         int resp_buf_type = 0;
1602
1603         cFYI(1, ("write2 at %lld %d bytes", (long long)offset, count));
1604
1605         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1606                 wct = 14;
1607         else
1608                 wct = 12;
1609         rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
1610         if (rc)
1611                 return rc;
1612         /* tcon and ses pointer are checked in smb_init */
1613         if (tcon->ses->server == NULL)
1614                 return -ECONNABORTED;
1615
1616         pSMB->AndXCommand = 0xFF;       /* none */
1617         pSMB->Fid = netfid;
1618         pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1619         if (wct == 14)
1620                 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1621         else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1622                 return -EIO;
1623         pSMB->Reserved = 0xFFFFFFFF;
1624         pSMB->WriteMode = 0;
1625         pSMB->Remaining = 0;
1626
1627         pSMB->DataOffset =
1628             cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1629
1630         pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
1631         pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
1632         smb_hdr_len = pSMB->hdr.smb_buf_length + 1; /* hdr + 1 byte pad */
1633         if (wct == 14)
1634                 pSMB->hdr.smb_buf_length += count+1;
1635         else /* wct == 12 */
1636                 pSMB->hdr.smb_buf_length += count+5; /* smb data starts later */
1637         if (wct == 14)
1638                 pSMB->ByteCount = cpu_to_le16(count + 1);
1639         else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
1640                 struct smb_com_writex_req *pSMBW =
1641                                 (struct smb_com_writex_req *)pSMB;
1642                 pSMBW->ByteCount = cpu_to_le16(count + 5);
1643         }
1644         iov[0].iov_base = pSMB;
1645         if (wct == 14)
1646                 iov[0].iov_len = smb_hdr_len + 4;
1647         else /* wct == 12 pad bigger by four bytes */
1648                 iov[0].iov_len = smb_hdr_len + 8;
1649
1650
1651         rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
1652                           long_op);
1653         cifs_stats_inc(&tcon->num_writes);
1654         if (rc) {
1655                 cFYI(1, ("Send error Write2 = %d", rc));
1656                 *nbytes = 0;
1657         } else if (resp_buf_type == 0) {
1658                 /* presumably this can not happen, but best to be safe */
1659                 rc = -EIO;
1660                 *nbytes = 0;
1661         } else {
1662                 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
1663                 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1664                 *nbytes = (*nbytes) << 16;
1665                 *nbytes += le16_to_cpu(pSMBr->Count);
1666         }
1667
1668 /*      cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1669         if (resp_buf_type == CIFS_SMALL_BUFFER)
1670                 cifs_small_buf_release(iov[0].iov_base);
1671         else if (resp_buf_type == CIFS_LARGE_BUFFER)
1672                 cifs_buf_release(iov[0].iov_base);
1673
1674         /* Note: On -EAGAIN error only caller can retry on handle based calls
1675                 since file handle passed in no longer valid */
1676
1677         return rc;
1678 }
1679
1680
1681 int
1682 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
1683             const __u16 smb_file_id, const __u64 len,
1684             const __u64 offset, const __u32 numUnlock,
1685             const __u32 numLock, const __u8 lockType, const int waitFlag)
1686 {
1687         int rc = 0;
1688         LOCK_REQ *pSMB = NULL;
1689         LOCK_RSP *pSMBr = NULL;
1690         int bytes_returned;
1691         int timeout = 0;
1692         __u16 count;
1693
1694         cFYI(1, ("CIFSSMBLock timeout %d numLock %d", waitFlag, numLock));
1695         rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1696
1697         if (rc)
1698                 return rc;
1699
1700         pSMBr = (LOCK_RSP *)pSMB; /* BB removeme BB */
1701
1702         if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1703                 timeout = CIFS_ASYNC_OP; /* no response expected */
1704                 pSMB->Timeout = 0;
1705         } else if (waitFlag == TRUE) {
1706                 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1707                 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1708         } else {
1709                 pSMB->Timeout = 0;
1710         }
1711
1712         pSMB->NumberOfLocks = cpu_to_le16(numLock);
1713         pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1714         pSMB->LockType = lockType;
1715         pSMB->AndXCommand = 0xFF;       /* none */
1716         pSMB->Fid = smb_file_id; /* netfid stays le */
1717
1718         if ((numLock != 0) || (numUnlock != 0)) {
1719                 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
1720                 /* BB where to store pid high? */
1721                 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1722                 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1723                 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1724                 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1725                 count = sizeof(LOCKING_ANDX_RANGE);
1726         } else {
1727                 /* oplock break */
1728                 count = 0;
1729         }
1730         pSMB->hdr.smb_buf_length += count;
1731         pSMB->ByteCount = cpu_to_le16(count);
1732
1733         if (waitFlag) {
1734                 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1735                         (struct smb_hdr *) pSMBr, &bytes_returned);
1736                 cifs_small_buf_release(pSMB);
1737         } else {
1738                 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *)pSMB,
1739                                       timeout);
1740                 /* SMB buffer freed by function above */
1741         }
1742         cifs_stats_inc(&tcon->num_locks);
1743         if (rc)
1744                 cFYI(1, ("Send error in Lock = %d", rc));
1745
1746         /* Note: On -EAGAIN error only caller can retry on handle based calls
1747         since file handle passed in no longer valid */
1748         return rc;
1749 }
1750
1751 int
1752 CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
1753                 const __u16 smb_file_id, const int get_flag, const __u64 len,
1754                 struct file_lock *pLockData, const __u16 lock_type,
1755                 const int waitFlag)
1756 {
1757         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
1758         struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1759         struct cifs_posix_lock *parm_data;
1760         int rc = 0;
1761         int timeout = 0;
1762         int bytes_returned = 0;
1763         int resp_buf_type = 0;
1764         __u16 params, param_offset, offset, byte_count, count;
1765         struct kvec iov[1];
1766
1767         cFYI(1, ("Posix Lock"));
1768
1769         if (pLockData == NULL)
1770                 return EINVAL;
1771
1772         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
1773
1774         if (rc)
1775                 return rc;
1776
1777         pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
1778
1779         params = 6;
1780         pSMB->MaxSetupCount = 0;
1781         pSMB->Reserved = 0;
1782         pSMB->Flags = 0;
1783         pSMB->Reserved2 = 0;
1784         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1785         offset = param_offset + params;
1786
1787         count = sizeof(struct cifs_posix_lock);
1788         pSMB->MaxParameterCount = cpu_to_le16(2);
1789         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
1790         pSMB->SetupCount = 1;
1791         pSMB->Reserved3 = 0;
1792         if (get_flag)
1793                 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
1794         else
1795                 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1796         byte_count = 3 /* pad */  + params + count;
1797         pSMB->DataCount = cpu_to_le16(count);
1798         pSMB->ParameterCount = cpu_to_le16(params);
1799         pSMB->TotalDataCount = pSMB->DataCount;
1800         pSMB->TotalParameterCount = pSMB->ParameterCount;
1801         pSMB->ParameterOffset = cpu_to_le16(param_offset);
1802         parm_data = (struct cifs_posix_lock *)
1803                         (((char *) &pSMB->hdr.Protocol) + offset);
1804
1805         parm_data->lock_type = cpu_to_le16(lock_type);
1806         if (waitFlag) {
1807                 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1808                 parm_data->lock_flags = cpu_to_le16(1);
1809                 pSMB->Timeout = cpu_to_le32(-1);
1810         } else
1811                 pSMB->Timeout = 0;
1812
1813         parm_data->pid = cpu_to_le32(current->tgid);
1814         parm_data->start = cpu_to_le64(pLockData->fl_start);
1815         parm_data->length = cpu_to_le64(len);  /* normalize negative numbers */
1816
1817         pSMB->DataOffset = cpu_to_le16(offset);
1818         pSMB->Fid = smb_file_id;
1819         pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
1820         pSMB->Reserved4 = 0;
1821         pSMB->hdr.smb_buf_length += byte_count;
1822         pSMB->ByteCount = cpu_to_le16(byte_count);
1823         if (waitFlag) {
1824                 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1825                         (struct smb_hdr *) pSMBr, &bytes_returned);
1826         } else {
1827                 iov[0].iov_base = (char *)pSMB;
1828                 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1829                 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1830                                 &resp_buf_type, timeout);
1831                 pSMB = NULL; /* request buf already freed by SendReceive2. Do
1832                                 not try to free it twice below on exit */
1833                 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
1834         }
1835
1836         if (rc) {
1837                 cFYI(1, ("Send error in Posix Lock = %d", rc));
1838         } else if (get_flag) {
1839                 /* lock structure can be returned on get */
1840                 __u16 data_offset;
1841                 __u16 data_count;
1842                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1843
1844                 if (rc || (pSMBr->ByteCount < sizeof(struct cifs_posix_lock))) {
1845                         rc = -EIO;      /* bad smb */
1846                         goto plk_err_exit;
1847                 }
1848                 if (pLockData == NULL) {
1849                         rc = -EINVAL;
1850                         goto plk_err_exit;
1851                 }
1852                 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1853                 data_count  = le16_to_cpu(pSMBr->t2.DataCount);
1854                 if (data_count < sizeof(struct cifs_posix_lock)) {
1855                         rc = -EIO;
1856                         goto plk_err_exit;
1857                 }
1858                 parm_data = (struct cifs_posix_lock *)
1859                         ((char *)&pSMBr->hdr.Protocol + data_offset);
1860                 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
1861                         pLockData->fl_type = F_UNLCK;
1862         }
1863
1864 plk_err_exit:
1865         if (pSMB)
1866                 cifs_small_buf_release(pSMB);
1867
1868         if (resp_buf_type == CIFS_SMALL_BUFFER)
1869                 cifs_small_buf_release(iov[0].iov_base);
1870         else if (resp_buf_type == CIFS_LARGE_BUFFER)
1871                 cifs_buf_release(iov[0].iov_base);
1872
1873         /* Note: On -EAGAIN error only caller can retry on handle based calls
1874            since file handle passed in no longer valid */
1875
1876         return rc;
1877 }
1878
1879
1880 int
1881 CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
1882 {
1883         int rc = 0;
1884         CLOSE_REQ *pSMB = NULL;
1885         cFYI(1, ("In CIFSSMBClose"));
1886
1887 /* do not retry on dead session on close */
1888         rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1889         if (rc == -EAGAIN)
1890                 return 0;
1891         if (rc)
1892                 return rc;
1893
1894         pSMB->FileID = (__u16) smb_file_id;
1895         pSMB->LastWriteTime = 0xFFFFFFFF;
1896         pSMB->ByteCount = 0;
1897         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
1898         cifs_stats_inc(&tcon->num_closes);
1899         if (rc) {
1900                 if (rc != -EINTR) {
1901                         /* EINTR is expected when user ctl-c to kill app */
1902                         cERROR(1, ("Send error in Close = %d", rc));
1903                 }
1904         }
1905
1906         /* Since session is dead, file will be closed on server already */
1907         if (rc == -EAGAIN)
1908                 rc = 0;
1909
1910         return rc;
1911 }
1912
1913 int
1914 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1915               const char *fromName, const char *toName,
1916               const struct nls_table *nls_codepage, int remap)
1917 {
1918         int rc = 0;
1919         RENAME_REQ *pSMB = NULL;
1920         RENAME_RSP *pSMBr = NULL;
1921         int bytes_returned;
1922         int name_len, name_len2;
1923         __u16 count;
1924
1925         cFYI(1, ("In CIFSSMBRename"));
1926 renameRetry:
1927         rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1928                       (void **) &pSMBr);
1929         if (rc)
1930                 return rc;
1931
1932         pSMB->BufferFormat = 0x04;
1933         pSMB->SearchAttributes =
1934             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1935                         ATTR_DIRECTORY);
1936
1937         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1938                 name_len =
1939                     cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1940                                      PATH_MAX, nls_codepage, remap);
1941                 name_len++;     /* trailing null */
1942                 name_len *= 2;
1943                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
1944         /* protocol requires ASCII signature byte on Unicode string */
1945                 pSMB->OldFileName[name_len + 1] = 0x00;
1946                 name_len2 =
1947                     cifsConvertToUCS((__le16 *) &pSMB->OldFileName[name_len + 2],
1948                                      toName, PATH_MAX, nls_codepage, remap);
1949                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
1950                 name_len2 *= 2; /* convert to bytes */
1951         } else {        /* BB improve the check for buffer overruns BB */
1952                 name_len = strnlen(fromName, PATH_MAX);
1953                 name_len++;     /* trailing null */
1954                 strncpy(pSMB->OldFileName, fromName, name_len);
1955                 name_len2 = strnlen(toName, PATH_MAX);
1956                 name_len2++;    /* trailing null */
1957                 pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
1958                 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1959                 name_len2++;    /* trailing null */
1960                 name_len2++;    /* signature byte */
1961         }
1962
1963         count = 1 /* 1st signature byte */  + name_len + name_len2;
1964         pSMB->hdr.smb_buf_length += count;
1965         pSMB->ByteCount = cpu_to_le16(count);
1966
1967         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1968                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1969         cifs_stats_inc(&tcon->num_renames);
1970         if (rc)
1971                 cFYI(1, ("Send error in rename = %d", rc));
1972
1973         cifs_buf_release(pSMB);
1974
1975         if (rc == -EAGAIN)
1976                 goto renameRetry;
1977
1978         return rc;
1979 }
1980
1981 int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
1982                 int netfid, char *target_name,
1983                 const struct nls_table *nls_codepage, int remap)
1984 {
1985         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
1986         struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1987         struct set_file_rename *rename_info;
1988         char *data_offset;
1989         char dummy_string[30];
1990         int rc = 0;
1991         int bytes_returned = 0;
1992         int len_of_str;
1993         __u16 params, param_offset, offset, count, byte_count;
1994
1995         cFYI(1, ("Rename to File by handle"));
1996         rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
1997                         (void **) &pSMBr);
1998         if (rc)
1999                 return rc;
2000
2001         params = 6;
2002         pSMB->MaxSetupCount = 0;
2003         pSMB->Reserved = 0;
2004         pSMB->Flags = 0;
2005         pSMB->Timeout = 0;
2006         pSMB->Reserved2 = 0;
2007         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2008         offset = param_offset + params;
2009
2010         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2011         rename_info = (struct set_file_rename *) data_offset;
2012         pSMB->MaxParameterCount = cpu_to_le16(2);
2013         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2014         pSMB->SetupCount = 1;
2015         pSMB->Reserved3 = 0;
2016         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2017         byte_count = 3 /* pad */  + params;
2018         pSMB->ParameterCount = cpu_to_le16(params);
2019         pSMB->TotalParameterCount = pSMB->ParameterCount;
2020         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2021         pSMB->DataOffset = cpu_to_le16(offset);
2022         /* construct random name ".cifs_tmp<inodenum><mid>" */
2023         rename_info->overwrite = cpu_to_le32(1);
2024         rename_info->root_fid  = 0;
2025         /* unicode only call */
2026         if (target_name == NULL) {
2027                 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2028                 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2029                                         dummy_string, 24, nls_codepage, remap);
2030         } else {
2031                 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2032                                         target_name, PATH_MAX, nls_codepage,
2033                                         remap);
2034         }
2035         rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2036         count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
2037         byte_count += count;
2038         pSMB->DataCount = cpu_to_le16(count);
2039         pSMB->TotalDataCount = pSMB->DataCount;
2040         pSMB->Fid = netfid;
2041         pSMB->InformationLevel =
2042                 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2043         pSMB->Reserved4 = 0;
2044         pSMB->hdr.smb_buf_length += byte_count;
2045         pSMB->ByteCount = cpu_to_le16(byte_count);
2046         rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2047                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2048         cifs_stats_inc(&pTcon->num_t2renames);
2049         if (rc)
2050                 cFYI(1, ("Send error in Rename (by file handle) = %d", rc));
2051
2052         cifs_buf_release(pSMB);
2053
2054         /* Note: On -EAGAIN error only caller can retry on handle based calls
2055                 since file handle passed in no longer valid */
2056
2057         return rc;
2058 }
2059
2060 int
2061 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char *fromName,
2062             const __u16 target_tid, const char *toName, const int flags,
2063             const struct nls_table *nls_codepage, int remap)
2064 {
2065         int rc = 0;
2066         COPY_REQ *pSMB = NULL;
2067         COPY_RSP *pSMBr = NULL;
2068         int bytes_returned;
2069         int name_len, name_len2;
2070         __u16 count;
2071
2072         cFYI(1, ("In CIFSSMBCopy"));
2073 copyRetry:
2074         rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2075                         (void **) &pSMBr);
2076         if (rc)
2077                 return rc;
2078
2079         pSMB->BufferFormat = 0x04;
2080         pSMB->Tid2 = target_tid;
2081
2082         pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2083
2084         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2085                 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
2086                                             fromName, PATH_MAX, nls_codepage,
2087                                             remap);
2088                 name_len++;     /* trailing null */
2089                 name_len *= 2;
2090                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
2091                 /* protocol requires ASCII signature byte on Unicode string */
2092                 pSMB->OldFileName[name_len + 1] = 0x00;
2093                 name_len2 =
2094                     cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2095                                 toName, PATH_MAX, nls_codepage, remap);
2096                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
2097                 name_len2 *= 2; /* convert to bytes */
2098         } else {        /* BB improve the check for buffer overruns BB */
2099                 name_len = strnlen(fromName, PATH_MAX);
2100                 name_len++;     /* trailing null */
2101                 strncpy(pSMB->OldFileName, fromName, name_len);
2102                 name_len2 = strnlen(toName, PATH_MAX);
2103                 name_len2++;    /* trailing null */
2104                 pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
2105                 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2106                 name_len2++;    /* trailing null */
2107                 name_len2++;    /* signature byte */
2108         }
2109
2110         count = 1 /* 1st signature byte */  + name_len + name_len2;
2111         pSMB->hdr.smb_buf_length += count;
2112         pSMB->ByteCount = cpu_to_le16(count);
2113
2114         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2115                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2116         if (rc) {
2117                 cFYI(1, ("Send error in copy = %d with %d files copied",
2118                         rc, le16_to_cpu(pSMBr->CopyCount)));
2119         }
2120         if (pSMB)
2121                 cifs_buf_release(pSMB);
2122
2123         if (rc == -EAGAIN)
2124                 goto copyRetry;
2125
2126         return rc;
2127 }
2128
2129 int
2130 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
2131                       const char *fromName, const char *toName,
2132                       const struct nls_table *nls_codepage)
2133 {
2134         TRANSACTION2_SPI_REQ *pSMB = NULL;
2135         TRANSACTION2_SPI_RSP *pSMBr = NULL;
2136         char *data_offset;
2137         int name_len;
2138         int name_len_target;
2139         int rc = 0;
2140         int bytes_returned = 0;
2141         __u16 params, param_offset, offset, byte_count;
2142
2143         cFYI(1, ("In Symlink Unix style"));
2144 createSymLinkRetry:
2145         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2146                       (void **) &pSMBr);
2147         if (rc)
2148                 return rc;
2149
2150         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2151                 name_len =
2152                     cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
2153                                   /* find define for this maxpathcomponent */
2154                                   , nls_codepage);
2155                 name_len++;     /* trailing null */
2156                 name_len *= 2;
2157
2158         } else {        /* BB improve the check for buffer overruns BB */
2159                 name_len = strnlen(fromName, PATH_MAX);
2160                 name_len++;     /* trailing null */
2161                 strncpy(pSMB->FileName, fromName, name_len);
2162         }
2163         params = 6 + name_len;
2164         pSMB->MaxSetupCount = 0;
2165         pSMB->Reserved = 0;
2166         pSMB->Flags = 0;
2167         pSMB->Timeout = 0;
2168         pSMB->Reserved2 = 0;
2169         param_offset = offsetof(struct smb_com_transaction2_spi_req,
2170                                 InformationLevel) - 4;
2171         offset = param_offset + params;
2172
2173         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2174         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2175                 name_len_target =
2176                     cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
2177                                   /* find define for this maxpathcomponent */
2178                                   , nls_codepage);
2179                 name_len_target++;      /* trailing null */
2180                 name_len_target *= 2;
2181         } else {        /* BB improve the check for buffer overruns BB */
2182                 name_len_target = strnlen(toName, PATH_MAX);
2183                 name_len_target++;      /* trailing null */
2184                 strncpy(data_offset, toName, name_len_target);
2185         }
2186
2187         pSMB->MaxParameterCount = cpu_to_le16(2);
2188         /* BB find exact max on data count below from sess */
2189         pSMB->MaxDataCount = cpu_to_le16(1000);
2190         pSMB->SetupCount = 1;
2191         pSMB->Reserved3 = 0;
2192         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2193         byte_count = 3 /* pad */  + params + name_len_target;
2194         pSMB->DataCount = cpu_to_le16(name_len_target);
2195         pSMB->ParameterCount = cpu_to_le16(params);
2196         pSMB->TotalDataCount = pSMB->DataCount;
2197         pSMB->TotalParameterCount = pSMB->ParameterCount;
2198         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2199         pSMB->DataOffset = cpu_to_le16(offset);
2200         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2201         pSMB->Reserved4 = 0;
2202         pSMB->hdr.smb_buf_length += byte_count;
2203         pSMB->ByteCount = cpu_to_le16(byte_count);
2204         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2205                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2206         cifs_stats_inc(&tcon->num_symlinks);
2207         if (rc)
2208                 cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
2209
2210         if (pSMB)
2211                 cifs_buf_release(pSMB);
2212
2213         if (rc == -EAGAIN)
2214                 goto createSymLinkRetry;
2215
2216         return rc;
2217 }
2218
2219 int
2220 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2221                        const char *fromName, const char *toName,
2222                        const struct nls_table *nls_codepage, int remap)
2223 {
2224         TRANSACTION2_SPI_REQ *pSMB = NULL;
2225         TRANSACTION2_SPI_RSP *pSMBr = NULL;
2226         char *data_offset;
2227         int name_len;
2228         int name_len_target;
2229         int rc = 0;
2230         int bytes_returned = 0;
2231         __u16 params, param_offset, offset, byte_count;
2232
2233         cFYI(1, ("In Create Hard link Unix style"));
2234 createHardLinkRetry:
2235         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2236                       (void **) &pSMBr);
2237         if (rc)
2238                 return rc;
2239
2240         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2241                 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
2242                                             PATH_MAX, nls_codepage, remap);
2243                 name_len++;     /* trailing null */
2244                 name_len *= 2;
2245
2246         } else {        /* BB improve the check for buffer overruns BB */
2247                 name_len = strnlen(toName, PATH_MAX);
2248                 name_len++;     /* trailing null */
2249                 strncpy(pSMB->FileName, toName, name_len);
2250         }
2251         params = 6 + name_len;
2252         pSMB->MaxSetupCount = 0;
2253         pSMB->Reserved = 0;
2254         pSMB->Flags = 0;
2255         pSMB->Timeout = 0;
2256         pSMB->Reserved2 = 0;
2257         param_offset = offsetof(struct smb_com_transaction2_spi_req,
2258                                 InformationLevel) - 4;
2259         offset = param_offset + params;
2260
2261         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2262         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2263                 name_len_target =
2264                     cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
2265                                      nls_codepage, remap);
2266                 name_len_target++;      /* trailing null */
2267                 name_len_target *= 2;
2268         } else {        /* BB improve the check for buffer overruns BB */
2269                 name_len_target = strnlen(fromName, PATH_MAX);
2270                 name_len_target++;      /* trailing null */
2271                 strncpy(data_offset, fromName, name_len_target);
2272         }
2273
2274         pSMB->MaxParameterCount = cpu_to_le16(2);
2275         /* BB find exact max on data count below from sess*/
2276         pSMB->MaxDataCount = cpu_to_le16(1000);
2277         pSMB->SetupCount = 1;
2278         pSMB->Reserved3 = 0;
2279         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2280         byte_count = 3 /* pad */  + params + name_len_target;
2281         pSMB->ParameterCount = cpu_to_le16(params);
2282         pSMB->TotalParameterCount = pSMB->ParameterCount;
2283         pSMB->DataCount = cpu_to_le16(name_len_target);
2284         pSMB->TotalDataCount = pSMB->DataCount;
2285         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2286         pSMB->DataOffset = cpu_to_le16(offset);
2287         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2288         pSMB->Reserved4 = 0;
2289         pSMB->hdr.smb_buf_length += byte_count;
2290         pSMB->ByteCount = cpu_to_le16(byte_count);
2291         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2292                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2293         cifs_stats_inc(&tcon->num_hardlinks);
2294         if (rc)
2295                 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
2296
2297         cifs_buf_release(pSMB);
2298         if (rc == -EAGAIN)
2299                 goto createHardLinkRetry;
2300
2301         return rc;
2302 }
2303
2304 int
2305 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2306                    const char *fromName, const char *toName,
2307                    const struct nls_table *nls_codepage, int remap)
2308 {
2309         int rc = 0;
2310         NT_RENAME_REQ *pSMB = NULL;
2311         RENAME_RSP *pSMBr = NULL;
2312         int bytes_returned;
2313         int name_len, name_len2;
2314         __u16 count;
2315
2316         cFYI(1, ("In CIFSCreateHardLink"));
2317 winCreateHardLinkRetry:
2318
2319         rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2320                       (void **) &pSMBr);
2321         if (rc)
2322                 return rc;
2323
2324         pSMB->SearchAttributes =
2325             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2326                         ATTR_DIRECTORY);
2327         pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2328         pSMB->ClusterCount = 0;
2329
2330         pSMB->BufferFormat = 0x04;
2331
2332         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2333                 name_len =
2334                     cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
2335                                      PATH_MAX, nls_codepage, remap);
2336                 name_len++;     /* trailing null */
2337                 name_len *= 2;
2338                 pSMB->OldFileName[name_len] = 0;        /* pad */
2339                 pSMB->OldFileName[name_len + 1] = 0x04;
2340                 name_len2 =
2341                     cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2342                                      toName, PATH_MAX, nls_codepage, remap);
2343                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
2344                 name_len2 *= 2; /* convert to bytes */
2345         } else {        /* BB improve the check for buffer overruns BB */
2346                 name_len = strnlen(fromName, PATH_MAX);
2347                 name_len++;     /* trailing null */
2348                 strncpy(pSMB->OldFileName, fromName, name_len);
2349                 name_len2 = strnlen(toName, PATH_MAX);
2350                 name_len2++;    /* trailing null */
2351                 pSMB->OldFileName[name_len] = 0x04;     /* 2nd buffer format */
2352                 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2353                 name_len2++;    /* trailing null */
2354                 name_len2++;    /* signature byte */
2355         }
2356
2357         count = 1 /* string type byte */  + name_len + name_len2;
2358         pSMB->hdr.smb_buf_length += count;
2359         pSMB->ByteCount = cpu_to_le16(count);
2360
2361         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2362                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2363         cifs_stats_inc(&tcon->num_hardlinks);
2364         if (rc)
2365                 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
2366
2367         cifs_buf_release(pSMB);
2368         if (rc == -EAGAIN)
2369                 goto winCreateHardLinkRetry;
2370
2371         return rc;
2372 }
2373
2374 int
2375 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
2376                         const unsigned char *searchName,
2377                         char *symlinkinfo, const int buflen,
2378                         const struct nls_table *nls_codepage)
2379 {
2380 /* SMB_QUERY_FILE_UNIX_LINK */
2381         TRANSACTION2_QPI_REQ *pSMB = NULL;
2382         TRANSACTION2_QPI_RSP *pSMBr = NULL;
2383         int rc = 0;
2384         int bytes_returned;
2385         int name_len;
2386         __u16 params, byte_count;
2387
2388         cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
2389
2390 querySymLinkRetry:
2391         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2392                       (void **) &pSMBr);
2393         if (rc)
2394                 return rc;
2395
2396         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2397                 name_len =
2398                     cifs_strtoUCS((__le16 *) pSMB->FileName, searchName,
2399                                   PATH_MAX, nls_codepage);
2400                 name_len++;     /* trailing null */
2401                 name_len *= 2;
2402         } else {        /* BB improve the check for buffer overruns BB */
2403                 name_len = strnlen(searchName, PATH_MAX);
2404                 name_len++;     /* trailing null */
2405                 strncpy(pSMB->FileName, searchName, name_len);
2406         }
2407
2408         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
2409         pSMB->TotalDataCount = 0;
2410         pSMB->MaxParameterCount = cpu_to_le16(2);
2411         /* BB find exact max data count below from sess structure BB */
2412         pSMB->MaxDataCount = cpu_to_le16(4000);
2413         pSMB->MaxSetupCount = 0;
2414         pSMB->Reserved = 0;
2415         pSMB->Flags = 0;
2416         pSMB->Timeout = 0;
2417         pSMB->Reserved2 = 0;
2418         pSMB->ParameterOffset = cpu_to_le16(offsetof(
2419         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
2420         pSMB->DataCount = 0;
2421         pSMB->DataOffset = 0;
2422         pSMB->SetupCount = 1;
2423         pSMB->Reserved3 = 0;
2424         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2425         byte_count = params + 1 /* pad */ ;
2426         pSMB->TotalParameterCount = cpu_to_le16(params);
2427         pSMB->ParameterCount = pSMB->TotalParameterCount;
2428         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
2429         pSMB->Reserved4 = 0;
2430         pSMB->hdr.smb_buf_length += byte_count;
2431         pSMB->ByteCount = cpu_to_le16(byte_count);
2432
2433         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2434                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2435         if (rc) {
2436                 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
2437         } else {
2438                 /* decode response */
2439
2440                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2441                 if (rc || (pSMBr->ByteCount < 2))
2442                 /* BB also check enough total bytes returned */
2443                         rc = -EIO;      /* bad smb */
2444                 else {
2445                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2446                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2447
2448                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2449                                 name_len = UniStrnlen((wchar_t *) ((char *)
2450                                         &pSMBr->hdr.Protocol + data_offset),
2451                                         min_t(const int, buflen, count) / 2);
2452                         /* BB FIXME investigate remapping reserved chars here */
2453                                 cifs_strfromUCS_le(symlinkinfo,
2454                                         (__le16 *) ((char *)&pSMBr->hdr.Protocol
2455                                                         + data_offset),
2456                                         name_len, nls_codepage);
2457                         } else {
2458                                 strncpy(symlinkinfo,
2459                                         (char *) &pSMBr->hdr.Protocol +
2460                                                 data_offset,
2461                                         min_t(const int, buflen, count));
2462                         }
2463                         symlinkinfo[buflen] = 0;
2464         /* just in case so calling code does not go off the end of buffer */
2465                 }
2466         }
2467         cifs_buf_release(pSMB);
2468         if (rc == -EAGAIN)
2469                 goto querySymLinkRetry;
2470         return rc;
2471 }
2472
2473 #ifdef CONFIG_CIFS_EXPERIMENTAL
2474 /* Initialize NT TRANSACT SMB into small smb request buffer.
2475    This assumes that all NT TRANSACTS that we init here have
2476    total parm and data under about 400 bytes (to fit in small cifs
2477    buffer size), which is the case so far, it easily fits. NB:
2478         Setup words themselves and ByteCount
2479         MaxSetupCount (size of returned setup area) and
2480         MaxParameterCount (returned parms size) must be set by caller */
2481 static int
2482 smb_init_nttransact(const __u16 sub_command, const int setup_count,
2483                    const int parm_len, struct cifsTconInfo *tcon,
2484                    void **ret_buf)
2485 {
2486         int rc;
2487         __u32 temp_offset;
2488         struct smb_com_ntransact_req *pSMB;
2489
2490         rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
2491                                 (void **)&pSMB);
2492         if (rc)
2493                 return rc;
2494         *ret_buf = (void *)pSMB;
2495         pSMB->Reserved = 0;
2496         pSMB->TotalParameterCount = cpu_to_le32(parm_len);
2497         pSMB->TotalDataCount  = 0;
2498         pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2499                                           MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2500         pSMB->ParameterCount = pSMB->TotalParameterCount;
2501         pSMB->DataCount  = pSMB->TotalDataCount;
2502         temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
2503                         (setup_count * 2) - 4 /* for rfc1001 length itself */;
2504         pSMB->ParameterOffset = cpu_to_le32(temp_offset);
2505         pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
2506         pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
2507         pSMB->SubCommand = cpu_to_le16(sub_command);
2508         return 0;
2509 }
2510
2511 static int
2512 validate_ntransact(char *buf, char **ppparm, char **ppdata,
2513                    __u32 *pparmlen, __u32 *pdatalen)
2514 {
2515         char *end_of_smb;
2516         __u32 data_count, data_offset, parm_count, parm_offset;
2517         struct smb_com_ntransact_rsp *pSMBr;
2518
2519         *pdatalen = 0;
2520         *pparmlen = 0;
2521
2522         if (buf == NULL)
2523                 return -EINVAL;
2524
2525         pSMBr = (struct smb_com_ntransact_rsp *)buf;
2526
2527         /* ByteCount was converted from little endian in SendReceive */
2528         end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount +
2529                         (char *)&pSMBr->ByteCount;
2530
2531         data_offset = le32_to_cpu(pSMBr->DataOffset);
2532         data_count = le32_to_cpu(pSMBr->DataCount);
2533         parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
2534         parm_count = le32_to_cpu(pSMBr->ParameterCount);
2535
2536         *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
2537         *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
2538
2539         /* should we also check that parm and data areas do not overlap? */
2540         if (*ppparm > end_of_smb) {
2541                 cFYI(1, ("parms start after end of smb"));
2542                 return -EINVAL;
2543         } else if (parm_count + *ppparm > end_of_smb) {
2544                 cFYI(1, ("parm end after end of smb"));
2545                 return -EINVAL;
2546         } else if (*ppdata > end_of_smb) {
2547                 cFYI(1, ("data starts after end of smb"));
2548                 return -EINVAL;
2549         } else if (data_count + *ppdata > end_of_smb) {
2550                 cFYI(1, ("data %p + count %d (%p) ends after end of smb %p start %p",
2551                         *ppdata, data_count, (data_count + *ppdata),
2552                         end_of_smb, pSMBr));
2553                 return -EINVAL;
2554         } else if (parm_count + data_count > pSMBr->ByteCount) {
2555                 cFYI(1, ("parm count and data count larger than SMB"));
2556                 return -EINVAL;
2557         }
2558         *pdatalen = data_count;
2559         *pparmlen = parm_count;
2560         return 0;
2561 }
2562 #endif /* CIFS_EXPERIMENTAL */
2563
2564 int
2565 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
2566                         const unsigned char *searchName,
2567                         char *symlinkinfo, const int buflen, __u16 fid,
2568                         const struct nls_table *nls_codepage)
2569 {
2570         int rc = 0;
2571         int bytes_returned;
2572         int name_len;
2573         struct smb_com_transaction_ioctl_req *pSMB;
2574         struct smb_com_transaction_ioctl_rsp *pSMBr;
2575
2576         cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
2577         rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2578                       (void **) &pSMBr);
2579         if (rc)
2580                 return rc;
2581
2582         pSMB->TotalParameterCount = 0 ;
2583         pSMB->TotalDataCount = 0;
2584         pSMB->MaxParameterCount = cpu_to_le32(2);
2585         /* BB find exact data count max from sess structure BB */
2586         pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2587                                           MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2588         pSMB->MaxSetupCount = 4;
2589         pSMB->Reserved = 0;
2590         pSMB->ParameterOffset = 0;
2591         pSMB->DataCount = 0;
2592         pSMB->DataOffset = 0;
2593         pSMB->SetupCount = 4;
2594         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2595         pSMB->ParameterCount = pSMB->TotalParameterCount;
2596         pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
2597         pSMB->IsFsctl = 1; /* FSCTL */
2598         pSMB->IsRootFlag = 0;
2599         pSMB->Fid = fid; /* file handle always le */
2600         pSMB->ByteCount = 0;
2601
2602         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2603                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2604         if (rc) {
2605                 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
2606         } else {                /* decode response */
2607                 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
2608                 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
2609                 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
2610                 /* BB also check enough total bytes returned */
2611                         rc = -EIO;      /* bad smb */
2612                 else {
2613                         if (data_count && (data_count < 2048)) {
2614                                 char *end_of_smb = 2 /* sizeof byte count */ +
2615                                                 pSMBr->ByteCount +
2616                                                 (char *)&pSMBr->ByteCount;
2617
2618                                 struct reparse_data *reparse_buf =
2619                                                 (struct reparse_data *)
2620                                                 ((char *)&pSMBr->hdr.Protocol
2621                                                                  + data_offset);
2622                                 if ((char *)reparse_buf >= end_of_smb) {
2623                                         rc = -EIO;
2624                                         goto qreparse_out;
2625                                 }
2626                                 if ((reparse_buf->LinkNamesBuf +
2627                                         reparse_buf->TargetNameOffset +
2628                                         reparse_buf->TargetNameLen) >
2629                                                 end_of_smb) {
2630                                         cFYI(1, ("reparse buf beyond SMB"));
2631                                         rc = -EIO;
2632                                         goto qreparse_out;
2633                                 }
2634
2635                                 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2636                                         name_len = UniStrnlen((wchar_t *)
2637                                                 (reparse_buf->LinkNamesBuf +
2638                                                 reparse_buf->TargetNameOffset),
2639                                                 min(buflen/2,
2640                                                 reparse_buf->TargetNameLen / 2));
2641                                         cifs_strfromUCS_le(symlinkinfo,
2642                                                 (__le16 *) (reparse_buf->LinkNamesBuf +
2643                                                 reparse_buf->TargetNameOffset),
2644                                                 name_len, nls_codepage);
2645                                 } else { /* ASCII names */
2646                                         strncpy(symlinkinfo,
2647                                                 reparse_buf->LinkNamesBuf +
2648                                                 reparse_buf->TargetNameOffset,
2649                                                 min_t(const int, buflen,
2650                                                    reparse_buf->TargetNameLen));
2651                                 }
2652                         } else {
2653                                 rc = -EIO;
2654                                 cFYI(1, ("Invalid return data count on "
2655                                          "get reparse info ioctl"));
2656                         }
2657                         symlinkinfo[buflen] = 0; /* just in case so the caller
2658                                         does not go off the end of the buffer */
2659                         cFYI(1, ("readlink result - %s", symlinkinfo));
2660                 }
2661         }
2662 qreparse_out:
2663         cifs_buf_release(pSMB);
2664
2665         /* Note: On -EAGAIN error only caller can retry on handle based calls
2666                 since file handle passed in no longer valid */
2667
2668         return rc;
2669 }
2670
2671 #ifdef CONFIG_CIFS_POSIX
2672
2673 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
2674 static void cifs_convert_ace(posix_acl_xattr_entry *ace,
2675                              struct cifs_posix_ace *cifs_ace)
2676 {
2677         /* u8 cifs fields do not need le conversion */
2678         ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
2679         ace->e_tag  = cpu_to_le16(cifs_ace->cifs_e_tag);
2680         ace->e_id   = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
2681         /* cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id)); */
2682
2683         return;
2684 }
2685
2686 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
2687 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
2688                                const int acl_type, const int size_of_data_area)
2689 {
2690         int size =  0;
2691         int i;
2692         __u16 count;
2693         struct cifs_posix_ace *pACE;
2694         struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
2695         posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
2696
2697         if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
2698                 return -EOPNOTSUPP;
2699
2700         if (acl_type & ACL_TYPE_ACCESS) {
2701                 count = le16_to_cpu(cifs_acl->access_entry_count);
2702                 pACE = &cifs_acl->ace_array[0];
2703                 size = sizeof(struct cifs_posix_acl);
2704                 size += sizeof(struct cifs_posix_ace) * count;
2705                 /* check if we would go beyond end of SMB */
2706                 if (size_of_data_area < size) {
2707                         cFYI(1, ("bad CIFS POSIX ACL size %d vs. %d",
2708                                 size_of_data_area, size));
2709                         return -EINVAL;
2710                 }
2711         } else if (acl_type & ACL_TYPE_DEFAULT) {
2712                 count = le16_to_cpu(cifs_acl->access_entry_count);
2713                 size = sizeof(struct cifs_posix_acl);
2714                 size += sizeof(struct cifs_posix_ace) * count;
2715 /* skip past access ACEs to get to default ACEs */
2716                 pACE = &cifs_acl->ace_array[count];
2717                 count = le16_to_cpu(cifs_acl->default_entry_count);
2718                 size += sizeof(struct cifs_posix_ace) * count;
2719                 /* check if we would go beyond end of SMB */
2720                 if (size_of_data_area < size)
2721                         return -EINVAL;
2722         } else {
2723                 /* illegal type */
2724                 return -EINVAL;
2725         }
2726
2727         size = posix_acl_xattr_size(count);
2728         if ((buflen == 0) || (local_acl == NULL)) {
2729                 /* used to query ACL EA size */
2730         } else if (size > buflen) {
2731                 return -ERANGE;
2732         } else /* buffer big enough */ {
2733                 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
2734                 for (i = 0; i < count ; i++) {
2735                         cifs_convert_ace(&local_acl->a_entries[i], pACE);
2736                         pACE++;
2737                 }
2738         }
2739         return size;
2740 }
2741
2742 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
2743                                      const posix_acl_xattr_entry *local_ace)
2744 {
2745         __u16 rc = 0; /* 0 = ACL converted ok */
2746
2747         cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
2748         cifs_ace->cifs_e_tag =  le16_to_cpu(local_ace->e_tag);
2749         /* BB is there a better way to handle the large uid? */
2750         if (local_ace->e_id == cpu_to_le32(-1)) {
2751         /* Probably no need to le convert -1 on any arch but can not hurt */
2752                 cifs_ace->cifs_uid = cpu_to_le64(-1);
2753         } else
2754                 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
2755         /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
2756         return rc;
2757 }
2758
2759 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
2760 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
2761                                const int buflen, const int acl_type)
2762 {
2763         __u16 rc = 0;
2764         struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
2765         posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
2766         int count;
2767         int i;
2768
2769         if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
2770                 return 0;
2771
2772         count = posix_acl_xattr_count((size_t)buflen);
2773         cFYI(1, ("setting acl with %d entries from buf of length %d and "
2774                 "version of %d",
2775                 count, buflen, le32_to_cpu(local_acl->a_version)));
2776         if (le32_to_cpu(local_acl->a_version) != 2) {
2777                 cFYI(1, ("unknown POSIX ACL version %d",
2778                      le32_to_cpu(local_acl->a_version)));
2779                 return 0;
2780         }
2781         cifs_acl->version = cpu_to_le16(1);
2782         if (acl_type == ACL_TYPE_ACCESS)
2783                 cifs_acl->access_entry_count = cpu_to_le16(count);
2784         else if (acl_type == ACL_TYPE_DEFAULT)
2785                 cifs_acl->default_entry_count = cpu_to_le16(count);
2786         else {
2787                 cFYI(1, ("unknown ACL type %d", acl_type));
2788                 return 0;
2789         }
2790         for (i = 0; i < count; i++) {
2791                 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
2792                                         &local_acl->a_entries[i]);
2793                 if (rc != 0) {
2794                         /* ACE not converted */
2795                         break;
2796                 }
2797         }
2798         if (rc == 0) {
2799                 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
2800                 rc += sizeof(struct cifs_posix_acl);
2801                 /* BB add check to make sure ACL does not overflow SMB */
2802         }
2803         return rc;
2804 }
2805
2806 int
2807 CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
2808                    const unsigned char *searchName,
2809                    char *acl_inf, const int buflen, const int acl_type,
2810                    const struct nls_table *nls_codepage, int remap)
2811 {
2812 /* SMB_QUERY_POSIX_ACL */
2813         TRANSACTION2_QPI_REQ *pSMB = NULL;
2814         TRANSACTION2_QPI_RSP *pSMBr = NULL;
2815         int rc = 0;
2816         int bytes_returned;
2817         int name_len;
2818         __u16 params, byte_count;
2819
2820         cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
2821
2822 queryAclRetry:
2823         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2824                 (void **) &pSMBr);
2825         if (rc)
2826                 return rc;
2827
2828         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2829                 name_len =
2830                         cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2831                                          PATH_MAX, nls_codepage, remap);
2832                 name_len++;     /* trailing null */
2833                 name_len *= 2;
2834                 pSMB->FileName[name_len] = 0;
2835                 pSMB->FileName[name_len+1] = 0;
2836         } else {        /* BB improve the check for buffer overruns BB */
2837                 name_len = strnlen(searchName, PATH_MAX);
2838                 name_len++;     /* trailing null */
2839                 strncpy(pSMB->FileName, searchName, name_len);
2840         }
2841
2842         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
2843         pSMB->TotalDataCount = 0;
2844         pSMB->MaxParameterCount = cpu_to_le16(2);
2845         /* BB find exact max data count below from sess structure BB */
2846         pSMB->MaxDataCount = cpu_to_le16(4000);
2847         pSMB->MaxSetupCount = 0;
2848         pSMB->Reserved = 0;
2849         pSMB->Flags = 0;
2850         pSMB->Timeout = 0;
2851         pSMB->Reserved2 = 0;
2852         pSMB->ParameterOffset = cpu_to_le16(
2853                 offsetof(struct smb_com_transaction2_qpi_req,
2854                          InformationLevel) - 4);
2855         pSMB->DataCount = 0;
2856         pSMB->DataOffset = 0;
2857         pSMB->SetupCount = 1;
2858         pSMB->Reserved3 = 0;
2859         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2860         byte_count = params + 1 /* pad */ ;
2861         pSMB->TotalParameterCount = cpu_to_le16(params);
2862         pSMB->ParameterCount = pSMB->TotalParameterCount;
2863         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
2864         pSMB->Reserved4 = 0;
2865         pSMB->hdr.smb_buf_length += byte_count;
2866         pSMB->ByteCount = cpu_to_le16(byte_count);
2867
2868         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2869                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2870         cifs_stats_inc(&tcon->num_acl_get);
2871         if (rc) {
2872                 cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
2873         } else {
2874                 /* decode response */
2875
2876                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2877                 if (rc || (pSMBr->ByteCount < 2))
2878                 /* BB also check enough total bytes returned */
2879                         rc = -EIO;      /* bad smb */
2880                 else {
2881                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2882                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2883                         rc = cifs_copy_posix_acl(acl_inf,
2884                                 (char *)&pSMBr->hdr.Protocol+data_offset,
2885                                 buflen, acl_type, count);
2886                 }
2887         }
2888         cifs_buf_release(pSMB);
2889         if (rc == -EAGAIN)
2890                 goto queryAclRetry;
2891         return rc;
2892 }
2893
2894 int
2895 CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
2896                    const unsigned char *fileName,
2897                    const char *local_acl, const int buflen,
2898                    const int acl_type,
2899                    const struct nls_table *nls_codepage, int remap)
2900 {
2901         struct smb_com_transaction2_spi_req *pSMB = NULL;
2902         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2903         char *parm_data;
2904         int name_len;
2905         int rc = 0;
2906         int bytes_returned = 0;
2907         __u16 params, byte_count, data_count, param_offset, offset;
2908
2909         cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
2910 setAclRetry:
2911         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2912                       (void **) &pSMBr);
2913         if (rc)
2914                 return rc;
2915         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2916                 name_len =
2917                         cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
2918                                       PATH_MAX, nls_codepage, remap);
2919                 name_len++;     /* trailing null */
2920                 name_len *= 2;
2921         } else {        /* BB improve the check for buffer overruns BB */
2922                 name_len = strnlen(fileName, PATH_MAX);
2923                 name_len++;     /* trailing null */
2924                 strncpy(pSMB->FileName, fileName, name_len);
2925         }
2926         params = 6 + name_len;
2927         pSMB->MaxParameterCount = cpu_to_le16(2);
2928         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
2929         pSMB->MaxSetupCount = 0;
2930         pSMB->Reserved = 0;
2931         pSMB->Flags = 0;
2932         pSMB->Timeout = 0;
2933         pSMB->Reserved2 = 0;
2934         param_offset = offsetof(struct smb_com_transaction2_spi_req,
2935                                 InformationLevel) - 4;
2936         offset = param_offset + params;
2937         parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
2938         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2939
2940         /* convert to on the wire format for POSIX ACL */
2941         data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
2942
2943         if (data_count == 0) {
2944                 rc = -EOPNOTSUPP;
2945                 goto setACLerrorExit;
2946         }
2947         pSMB->DataOffset = cpu_to_le16(offset);
2948         pSMB->SetupCount = 1;
2949         pSMB->Reserved3 = 0;
2950         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2951         pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
2952         byte_count = 3 /* pad */  + params + data_count;
2953         pSMB->DataCount = cpu_to_le16(data_count);
2954         pSMB->TotalDataCount = pSMB->DataCount;
2955         pSMB->ParameterCount = cpu_to_le16(params);
2956         pSMB->TotalParameterCount = pSMB->ParameterCount;
2957         pSMB->Reserved4 = 0;
2958         pSMB->hdr.smb_buf_length += byte_count;
2959         pSMB->ByteCount = cpu_to_le16(byte_count);
2960         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2961                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2962         if (rc)
2963                 cFYI(1, ("Set POSIX ACL returned %d", rc));
2964
2965 setACLerrorExit:
2966         cifs_buf_release(pSMB);
2967         if (rc == -EAGAIN)
2968                 goto setAclRetry;
2969         return rc;
2970 }
2971
2972 /* BB fix tabs in this function FIXME BB */
2973 int
2974 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
2975                const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
2976 {
2977         int rc = 0;
2978         struct smb_t2_qfi_req *pSMB = NULL;
2979         struct smb_t2_qfi_rsp *pSMBr = NULL;
2980         int bytes_returned;
2981         __u16 params, byte_count;
2982
2983         cFYI(1, ("In GetExtAttr"));
2984         if (tcon == NULL)
2985                 return -ENODEV;
2986
2987 GetExtAttrRetry:
2988         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2989                         (void **) &pSMBr);
2990         if (rc)
2991                 return rc;
2992
2993         params = 2 /* level */ + 2 /* fid */;
2994         pSMB->t2.TotalDataCount = 0;
2995         pSMB->t2.MaxParameterCount = cpu_to_le16(4);
2996         /* BB find exact max data count below from sess structure BB */
2997         pSMB->t2.MaxDataCount = cpu_to_le16(4000);
2998         pSMB->t2.MaxSetupCount = 0;
2999         pSMB->t2.Reserved = 0;
3000         pSMB->t2.Flags = 0;
3001         pSMB->t2.Timeout = 0;
3002         pSMB->t2.Reserved2 = 0;
3003         pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3004                                                Fid) - 4);
3005         pSMB->t2.DataCount = 0;
3006         pSMB->t2.DataOffset = 0;
3007         pSMB->t2.SetupCount = 1;
3008         pSMB->t2.Reserved3 = 0;
3009         pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3010         byte_count = params + 1 /* pad */ ;
3011         pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3012         pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3013         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3014         pSMB->Pad = 0;
3015         pSMB->Fid = netfid;
3016         pSMB->hdr.smb_buf_length += byte_count;
3017         pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3018
3019         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3020                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3021         if (rc) {
3022                 cFYI(1, ("error %d in GetExtAttr", rc));
3023         } else {
3024                 /* decode response */
3025                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3026                 if (rc || (pSMBr->ByteCount < 2))
3027                 /* BB also check enough total bytes returned */
3028                         /* If rc should we check for EOPNOSUPP and
3029                            disable the srvino flag? or in caller? */
3030                         rc = -EIO;      /* bad smb */
3031                 else {
3032                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3033                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3034                         struct file_chattr_info *pfinfo;
3035                         /* BB Do we need a cast or hash here ? */
3036                         if (count != 16) {
3037                                 cFYI(1, ("Illegal size ret in GetExtAttr"));
3038                                 rc = -EIO;
3039                                 goto GetExtAttrOut;
3040                         }
3041                         pfinfo = (struct file_chattr_info *)
3042                                  (data_offset + (char *) &pSMBr->hdr.Protocol);
3043                         *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3044                         *pMask = le64_to_cpu(pfinfo->mask);
3045                 }
3046         }
3047 GetExtAttrOut:
3048         cifs_buf_release(pSMB);
3049         if (rc == -EAGAIN)
3050                 goto GetExtAttrRetry;
3051         return rc;
3052 }
3053
3054 #endif /* CONFIG_POSIX */
3055
3056 #ifdef CONFIG_CIFS_EXPERIMENTAL
3057 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3058 int
3059 CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
3060                   struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3061 {
3062         int rc = 0;
3063         int buf_type = 0;
3064         QUERY_SEC_DESC_REQ *pSMB;
3065         struct kvec iov[1];
3066
3067         cFYI(1, ("GetCifsACL"));
3068
3069         *pbuflen = 0;
3070         *acl_inf = NULL;
3071
3072         rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3073                         8 /* parm len */, tcon, (void **) &pSMB);
3074         if (rc)
3075                 return rc;
3076
3077         pSMB->MaxParameterCount = cpu_to_le32(4);
3078         /* BB TEST with big acls that might need to be e.g. larger than 16K */
3079         pSMB->MaxSetupCount = 0;
3080         pSMB->Fid = fid; /* file handle always le */
3081         pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3082                                      CIFS_ACL_DACL);
3083         pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3084         pSMB->hdr.smb_buf_length += 11;
3085         iov[0].iov_base = (char *)pSMB;
3086         iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
3087
3088         rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3089                          CIFS_STD_OP);
3090         cifs_stats_inc(&tcon->num_acl_get);
3091         if (rc) {
3092                 cFYI(1, ("Send error in QuerySecDesc = %d", rc));
3093         } else {                /* decode response */
3094                 __le32 *parm;
3095                 __u32 parm_len;
3096                 __u32 acl_len;
3097                 struct smb_com_ntransact_rsp *pSMBr;
3098                 char *pdata;
3099
3100 /* validate_nttransact */
3101                 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3102                                         &pdata, &parm_len, pbuflen);
3103                 if (rc)
3104                         goto qsec_out;
3105                 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3106
3107                 cFYI(1, ("smb %p parm %p data %p", pSMBr, parm, *acl_inf));
3108
3109                 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3110                         rc = -EIO;      /* bad smb */
3111                         *pbuflen = 0;
3112                         goto qsec_out;
3113                 }
3114
3115 /* BB check that data area is minimum length and as big as acl_len */
3116
3117                 acl_len = le32_to_cpu(*parm);
3118                 if (acl_len != *pbuflen) {
3119                         cERROR(1, ("acl length %d does not match %d",
3120                                    acl_len, *pbuflen));
3121                         if (*pbuflen > acl_len)
3122                                 *pbuflen = acl_len;
3123                 }
3124
3125                 /* check if buffer is big enough for the acl
3126                    header followed by the smallest SID */
3127                 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3128                     (*pbuflen >= 64 * 1024)) {
3129                         cERROR(1, ("bad acl length %d", *pbuflen));
3130                         rc = -EINVAL;
3131                         *pbuflen = 0;
3132                 } else {
3133                         *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3134                         if (*acl_inf == NULL) {
3135                                 *pbuflen = 0;
3136                                 rc = -ENOMEM;
3137                         }
3138                         memcpy(*acl_inf, pdata, *pbuflen);
3139                 }
3140         }
3141 qsec_out:
3142         if (buf_type == CIFS_SMALL_BUFFER)
3143                 cifs_small_buf_release(iov[0].iov_base);
3144         else if (buf_type == CIFS_LARGE_BUFFER)
3145                 cifs_buf_release(iov[0].iov_base);
3146 /*      cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3147         return rc;
3148 }
3149
3150 int
3151 CIFSSMBSetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
3152                         struct cifs_ntsd *pntsd, __u32 acllen)
3153 {
3154         __u16 byte_count, param_count, data_count, param_offset, data_offset;
3155         int rc = 0;
3156         int bytes_returned = 0;
3157         SET_SEC_DESC_REQ *pSMB = NULL;
3158         NTRANSACT_RSP *pSMBr = NULL;
3159
3160 setCifsAclRetry:
3161         rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3162                         (void **) &pSMBr);
3163         if (rc)
3164                         return (rc);
3165
3166         pSMB->MaxSetupCount = 0;
3167         pSMB->Reserved = 0;
3168
3169         param_count = 8;
3170         param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3171         data_count = acllen;
3172         data_offset = param_offset + param_count;
3173         byte_count = 3 /* pad */  + param_count;
3174
3175         pSMB->DataCount = cpu_to_le32(data_count);
3176         pSMB->TotalDataCount = pSMB->DataCount;
3177         pSMB->MaxParameterCount = cpu_to_le32(4);
3178         pSMB->MaxDataCount = cpu_to_le32(16384);
3179         pSMB->ParameterCount = cpu_to_le32(param_count);
3180         pSMB->ParameterOffset = cpu_to_le32(param_offset);
3181         pSMB->TotalParameterCount = pSMB->ParameterCount;
3182         pSMB->DataOffset = cpu_to_le32(data_offset);
3183         pSMB->SetupCount = 0;
3184         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3185         pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3186
3187         pSMB->Fid = fid; /* file handle always le */
3188         pSMB->Reserved2 = 0;
3189         pSMB->AclFlags = cpu_to_le32(CIFS_ACL_DACL);
3190
3191         if (pntsd && acllen) {
3192                 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3193                         (char *) pntsd,
3194                         acllen);
3195                 pSMB->hdr.smb_buf_length += (byte_count + data_count);
3196
3197         } else
3198                 pSMB->hdr.smb_buf_length += byte_count;
3199
3200         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3201                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3202
3203         cFYI(1, ("SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc));
3204         if (rc)
3205                 cFYI(1, ("Set CIFS ACL returned %d", rc));
3206         cifs_buf_release(pSMB);
3207
3208         if (rc == -EAGAIN)
3209                 goto setCifsAclRetry;
3210
3211         return (rc);
3212 }
3213
3214 #endif /* CONFIG_CIFS_EXPERIMENTAL */
3215
3216 /* Legacy Query Path Information call for lookup to old servers such
3217    as Win9x/WinME */
3218 int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
3219                         const unsigned char *searchName,
3220                         FILE_ALL_INFO *pFinfo,
3221                         const struct nls_table *nls_codepage, int remap)
3222 {
3223         QUERY_INFORMATION_REQ *pSMB;
3224         QUERY_INFORMATION_RSP *pSMBr;
3225         int rc = 0;
3226         int bytes_returned;
3227         int name_len;
3228
3229         cFYI(1, ("In SMBQPath path %s", searchName));
3230 QInfRetry:
3231         rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3232                       (void **) &pSMBr);
3233         if (rc)
3234                 return rc;
3235
3236         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3237                 name_len =
3238                         cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3239                                         PATH_MAX, nls_codepage, remap);
3240                 name_len++;     /* trailing null */
3241                 name_len *= 2;
3242         } else {
3243                 name_len = strnlen(searchName, PATH_MAX);
3244                 name_len++;     /* trailing null */
3245                 strncpy(pSMB->FileName, searchName, name_len);
3246         }
3247         pSMB->BufferFormat = 0x04;
3248         name_len++; /* account for buffer type byte */
3249         pSMB->hdr.smb_buf_length += (__u16) name_len;
3250         pSMB->ByteCount = cpu_to_le16(name_len);
3251
3252         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3253                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3254         if (rc) {
3255                 cFYI(1, ("Send error in QueryInfo = %d", rc));
3256         } else if (pFinfo) {
3257                 struct timespec ts;
3258                 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3259
3260                 /* decode response */
3261                 /* BB FIXME - add time zone adjustment BB */
3262                 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
3263                 ts.tv_nsec = 0;
3264                 ts.tv_sec = time;
3265                 /* decode time fields */
3266                 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3267                 pFinfo->LastWriteTime = pFinfo->ChangeTime;
3268                 pFinfo->LastAccessTime = 0;
3269                 pFinfo->AllocationSize =
3270                         cpu_to_le64(le32_to_cpu(pSMBr->size));
3271                 pFinfo->EndOfFile = pFinfo->AllocationSize;
3272                 pFinfo->Attributes =
3273                         cpu_to_le32(le16_to_cpu(pSMBr->attr));
3274         } else
3275                 rc = -EIO; /* bad buffer passed in */
3276
3277         cifs_buf_release(pSMB);
3278
3279         if (rc == -EAGAIN)
3280                 goto QInfRetry;
3281
3282         return rc;
3283 }
3284
3285
3286
3287
3288 int
3289 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
3290                  const unsigned char *searchName,
3291                  FILE_ALL_INFO *pFindData,
3292                  int legacy /* old style infolevel */,
3293                  const struct nls_table *nls_codepage, int remap)
3294 {
3295 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3296         TRANSACTION2_QPI_REQ *pSMB = NULL;
3297         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3298         int rc = 0;
3299         int bytes_returned;
3300         int name_len;
3301         __u16 params, byte_count;
3302
3303 /* cFYI(1, ("In QPathInfo path %s", searchName)); */
3304 QPathInfoRetry:
3305         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3306                       (void **) &pSMBr);
3307         if (rc)
3308                 return rc;
3309
3310         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3311                 name_len =
3312                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3313                                      PATH_MAX, nls_codepage, remap);
3314                 name_len++;     /* trailing null */
3315                 name_len *= 2;
3316         } else {        /* BB improve the check for buffer overruns BB */
3317                 name_len = strnlen(searchName, PATH_MAX);
3318                 name_len++;     /* trailing null */
3319                 strncpy(pSMB->FileName, searchName, name_len);
3320         }
3321
3322         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3323         pSMB->TotalDataCount = 0;
3324         pSMB->MaxParameterCount = cpu_to_le16(2);
3325         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3326         pSMB->MaxSetupCount = 0;
3327         pSMB->Reserved = 0;
3328         pSMB->Flags = 0;
3329         pSMB->Timeout = 0;
3330         pSMB->Reserved2 = 0;
3331         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3332         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3333         pSMB->DataCount = 0;
3334         pSMB->DataOffset = 0;
3335         pSMB->SetupCount = 1;
3336         pSMB->Reserved3 = 0;
3337         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3338         byte_count = params + 1 /* pad */ ;
3339         pSMB->TotalParameterCount = cpu_to_le16(params);
3340         pSMB->ParameterCount = pSMB->TotalParameterCount;
3341         if (legacy)
3342                 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
3343         else
3344                 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3345         pSMB->Reserved4 = 0;
3346         pSMB->hdr.smb_buf_length += byte_count;
3347         pSMB->ByteCount = cpu_to_le16(byte_count);
3348
3349         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3350                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3351         if (rc) {
3352                 cFYI(1, ("Send error in QPathInfo = %d", rc));
3353         } else {                /* decode response */
3354                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3355
3356                 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3357                         rc = -EIO;
3358                 else if (!legacy && (pSMBr->ByteCount < 40))
3359                         rc = -EIO;      /* bad smb */
3360                 else if (legacy && (pSMBr->ByteCount < 24))
3361                         rc = -EIO;  /* 24 or 26 expected but we do not read
3362                                         last field */
3363                 else if (pFindData) {
3364                         int size;
3365                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3366
3367                         /* On legacy responses we do not read the last field,
3368                         EAsize, fortunately since it varies by subdialect and
3369                         also note it differs on Set vs. Get, ie two bytes or 4
3370                         bytes depending but we don't care here */
3371                         if (legacy)
3372                                 size = sizeof(FILE_INFO_STANDARD);
3373                         else
3374                                 size = sizeof(FILE_ALL_INFO);
3375                         memcpy((char *) pFindData,
3376                                (char *) &pSMBr->hdr.Protocol +
3377                                data_offset, size);
3378                 } else
3379                     rc = -ENOMEM;
3380         }
3381         cifs_buf_release(pSMB);
3382         if (rc == -EAGAIN)
3383                 goto QPathInfoRetry;
3384
3385         return rc;
3386 }
3387
3388 int
3389 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
3390                      const unsigned char *searchName,
3391                      FILE_UNIX_BASIC_INFO * pFindData,
3392                      const struct nls_table *nls_codepage, int remap)
3393 {
3394 /* SMB_QUERY_FILE_UNIX_BASIC */
3395         TRANSACTION2_QPI_REQ *pSMB = NULL;
3396         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3397         int rc = 0;
3398         int bytes_returned = 0;
3399         int name_len;
3400         __u16 params, byte_count;
3401
3402         cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
3403 UnixQPathInfoRetry:
3404         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3405                       (void **) &pSMBr);
3406         if (rc)
3407                 return rc;
3408
3409         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3410                 name_len =
3411                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3412                                   PATH_MAX, nls_codepage, remap);
3413                 name_len++;     /* trailing null */
3414                 name_len *= 2;
3415         } else {        /* BB improve the check for buffer overruns BB */
3416                 name_len = strnlen(searchName, PATH_MAX);
3417                 name_len++;     /* trailing null */
3418                 strncpy(pSMB->FileName, searchName, name_len);
3419         }
3420
3421         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3422         pSMB->TotalDataCount = 0;
3423         pSMB->MaxParameterCount = cpu_to_le16(2);
3424         /* BB find exact max SMB PDU from sess structure BB */
3425         pSMB->MaxDataCount = cpu_to_le16(4000);
3426         pSMB->MaxSetupCount = 0;
3427         pSMB->Reserved = 0;
3428         pSMB->Flags = 0;
3429         pSMB->Timeout = 0;
3430         pSMB->Reserved2 = 0;
3431         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3432         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3433         pSMB->DataCount = 0;
3434         pSMB->DataOffset = 0;
3435         pSMB->SetupCount = 1;
3436         pSMB->Reserved3 = 0;
3437         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3438         byte_count = params + 1 /* pad */ ;
3439         pSMB->TotalParameterCount = cpu_to_le16(params);
3440         pSMB->ParameterCount = pSMB->TotalParameterCount;
3441         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3442         pSMB->Reserved4 = 0;
3443         pSMB->hdr.smb_buf_length += byte_count;
3444         pSMB->ByteCount = cpu_to_le16(byte_count);
3445
3446         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3447                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3448         if (rc) {
3449                 cFYI(1, ("Send error in QPathInfo = %d", rc));
3450         } else {                /* decode response */
3451                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3452
3453                 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
3454                         cERROR(1, ("Malformed FILE_UNIX_BASIC_INFO response.\n"
3455                                    "Unix Extensions can be disabled on mount "
3456                                    "by specifying the nosfu mount option."));
3457                         rc = -EIO;      /* bad smb */
3458                 } else {
3459                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3460                         memcpy((char *) pFindData,
3461                                (char *) &pSMBr->hdr.Protocol +
3462                                data_offset,
3463                                sizeof(FILE_UNIX_BASIC_INFO));
3464                 }
3465         }
3466         cifs_buf_release(pSMB);
3467         if (rc == -EAGAIN)
3468                 goto UnixQPathInfoRetry;
3469
3470         return rc;
3471 }
3472
3473 /* xid, tcon, searchName and codepage are input parms, rest are returned */
3474 int
3475 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
3476               const char *searchName,
3477               const struct nls_table *nls_codepage,
3478               __u16 *pnetfid,
3479               struct cifs_search_info *psrch_inf, int remap, const char dirsep)
3480 {
3481 /* level 257 SMB_ */
3482         TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3483         TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3484         T2_FFIRST_RSP_PARMS *parms;
3485         int rc = 0;
3486         int bytes_returned = 0;
3487         int name_len;
3488         __u16 params, byte_count;
3489
3490         cFYI(1, ("In FindFirst for %s", searchName));
3491
3492 findFirstRetry:
3493         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3494                       (void **) &pSMBr);
3495         if (rc)
3496                 return rc;
3497
3498         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3499                 name_len =
3500                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3501                                  PATH_MAX, nls_codepage, remap);
3502                 /* We can not add the asterik earlier in case
3503                 it got remapped to 0xF03A as if it were part of the
3504                 directory name instead of a wildcard */
3505                 name_len *= 2;
3506                 pSMB->FileName[name_len] = dirsep;
3507                 pSMB->FileName[name_len+1] = 0;
3508                 pSMB->FileName[name_len+2] = '*';
3509                 pSMB->FileName[name_len+3] = 0;
3510                 name_len += 4; /* now the trailing null */
3511                 pSMB->FileName[name_len] = 0; /* null terminate just in case */
3512                 pSMB->FileName[name_len+1] = 0;
3513                 name_len += 2;
3514         } else {        /* BB add check for overrun of SMB buf BB */
3515                 name_len = strnlen(searchName, PATH_MAX);
3516 /* BB fix here and in unicode clause above ie
3517                 if (name_len > buffersize-header)
3518                         free buffer exit; BB */
3519                 strncpy(pSMB->FileName, searchName, name_len);
3520                 pSMB->FileName[name_len] = dirsep;
3521                 pSMB->FileName[name_len+1] = '*';
3522                 pSMB->FileName[name_len+2] = 0;
3523                 name_len += 3;
3524         }
3525
3526         params = 12 + name_len /* includes null */ ;
3527         pSMB->TotalDataCount = 0;       /* no EAs */
3528         pSMB->MaxParameterCount = cpu_to_le16(10);
3529         pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
3530                                           MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
3531         pSMB->MaxSetupCount = 0;
3532         pSMB->Reserved = 0;
3533         pSMB->Flags = 0;
3534         pSMB->Timeout = 0;
3535         pSMB->Reserved2 = 0;
3536         byte_count = params + 1 /* pad */ ;
3537         pSMB->TotalParameterCount = cpu_to_le16(params);
3538         pSMB->ParameterCount = pSMB->TotalParameterCount;
3539         pSMB->ParameterOffset = cpu_to_le16(
3540               offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
3541                 - 4);
3542         pSMB->DataCount = 0;
3543         pSMB->DataOffset = 0;
3544         pSMB->SetupCount = 1;   /* one byte, no need to make endian neutral */
3545         pSMB->Reserved3 = 0;
3546         pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3547         pSMB->SearchAttributes =
3548             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3549                         ATTR_DIRECTORY);
3550         pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
3551         pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
3552                 CIFS_SEARCH_RETURN_RESUME);
3553         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3554
3555         /* BB what should we set StorageType to? Does it matter? BB */
3556         pSMB->SearchStorageType = 0;
3557         pSMB->hdr.smb_buf_length += byte_count;
3558         pSMB->ByteCount = cpu_to_le16(byte_count);
3559
3560         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3561                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3562         cifs_stats_inc(&tcon->num_ffirst);
3563
3564         if (rc) {/* BB add logic to retry regular search if Unix search
3565                         rejected unexpectedly by server */
3566                 /* BB Add code to handle unsupported level rc */
3567                 cFYI(1, ("Error in FindFirst = %d", rc));
3568
3569                 cifs_buf_release(pSMB);
3570
3571                 /* BB eventually could optimize out free and realloc of buf */
3572                 /*    for this case */
3573                 if (rc == -EAGAIN)
3574                         goto findFirstRetry;
3575         } else { /* decode response */
3576                 /* BB remember to free buffer if error BB */
3577                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3578                 if (rc == 0) {
3579                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3580                                 psrch_inf->unicode = TRUE;
3581                         else
3582                                 psrch_inf->unicode = FALSE;
3583
3584                         psrch_inf->ntwrk_buf_start = (char *)pSMBr;
3585                         psrch_inf->smallBuf = 0;
3586                         psrch_inf->srch_entries_start =
3587                                 (char *) &pSMBr->hdr.Protocol +
3588                                         le16_to_cpu(pSMBr->t2.DataOffset);
3589                         parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
3590                                le16_to_cpu(pSMBr->t2.ParameterOffset));
3591
3592                         if (parms->EndofSearch)
3593                                 psrch_inf->endOfSearch = TRUE;
3594                         else
3595                                 psrch_inf->endOfSearch = FALSE;
3596
3597                         psrch_inf->entries_in_buffer =
3598                                         le16_to_cpu(parms->SearchCount);
3599                         psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
3600                                 psrch_inf->entries_in_buffer;
3601                         *pnetfid = parms->SearchHandle;
3602                 } else {
3603                         cifs_buf_release(pSMB);
3604                 }
3605         }
3606
3607         return rc;
3608 }
3609
3610 int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
3611                  __u16 searchHandle, struct cifs_search_info *psrch_inf)
3612 {
3613         TRANSACTION2_FNEXT_REQ *pSMB = NULL;
3614         TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
3615         T2_FNEXT_RSP_PARMS *parms;
3616         char *response_data;
3617         int rc = 0;
3618         int bytes_returned, name_len;
3619         __u16 params, byte_count;
3620
3621         cFYI(1, ("In FindNext"));
3622
3623         if (psrch_inf->endOfSearch == TRUE)
3624                 return -ENOENT;
3625
3626         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3627                 (void **) &pSMBr);
3628         if (rc)
3629                 return rc;
3630
3631         params = 14; /* includes 2 bytes of null string, converted to LE below*/
3632         byte_count = 0;
3633         pSMB->TotalDataCount = 0;       /* no EAs */
3634         pSMB->MaxParameterCount = cpu_to_le16(8);
3635         pSMB->MaxDataCount =
3636                 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) &
3637                                 0xFFFFFF00);
3638         pSMB->MaxSetupCount = 0;
3639         pSMB->Reserved = 0;
3640         pSMB->Flags = 0;
3641         pSMB->Timeout = 0;
3642         pSMB->Reserved2 = 0;
3643         pSMB->ParameterOffset =  cpu_to_le16(
3644               offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
3645         pSMB->DataCount = 0;
3646         pSMB->DataOffset = 0;
3647         pSMB->SetupCount = 1;
3648         pSMB->Reserved3 = 0;
3649         pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
3650         pSMB->SearchHandle = searchHandle;      /* always kept as le */
3651         pSMB->SearchCount =
3652                 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
3653         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3654         pSMB->ResumeKey = psrch_inf->resume_key;
3655         pSMB->SearchFlags =
3656               cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
3657
3658         name_len = psrch_inf->resume_name_len;
3659         params += name_len;
3660         if (name_len < PATH_MAX) {
3661                 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
3662                 byte_count += name_len;
3663                 /* 14 byte parm len above enough for 2 byte null terminator */
3664                 pSMB->ResumeFileName[name_len] = 0;
3665                 pSMB->ResumeFileName[name_len+1] = 0;
3666         } else {
3667                 rc = -EINVAL;
3668                 goto FNext2_err_exit;
3669         }
3670         byte_count = params + 1 /* pad */ ;
3671         pSMB->TotalParameterCount = cpu_to_le16(params);
3672         pSMB->ParameterCount = pSMB->TotalParameterCount;
3673         pSMB->hdr.smb_buf_length += byte_count;
3674         pSMB->ByteCount = cpu_to_le16(byte_count);
3675
3676         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3677                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3678         cifs_stats_inc(&tcon->num_fnext);
3679         if (rc) {
3680                 if (rc == -EBADF) {
3681                         psrch_inf->endOfSearch = TRUE;
3682                         rc = 0; /* search probably was closed at end of search*/
3683                 } else
3684                         cFYI(1, ("FindNext returned = %d", rc));
3685         } else {                /* decode response */
3686                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3687
3688                 if (rc == 0) {
3689                         /* BB fixme add lock for file (srch_info) struct here */
3690                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3691                                 psrch_inf->unicode = TRUE;
3692                         else
3693                                 psrch_inf->unicode = FALSE;
3694                         response_data = (char *) &pSMBr->hdr.Protocol +
3695                                le16_to_cpu(pSMBr->t2.ParameterOffset);
3696                         parms = (T2_FNEXT_RSP_PARMS *)response_data;
3697                         response_data = (char *)&pSMBr->hdr.Protocol +
3698                                 le16_to_cpu(pSMBr->t2.DataOffset);
3699                         if (psrch_inf->smallBuf)
3700                                 cifs_small_buf_release(
3701                                         psrch_inf->ntwrk_buf_start);
3702                         else
3703                                 cifs_buf_release(psrch_inf->ntwrk_buf_start);
3704                         psrch_inf->srch_entries_start = response_data;
3705                         psrch_inf->ntwrk_buf_start = (char *)pSMB;
3706                         psrch_inf->smallBuf = 0;
3707                         if (parms->EndofSearch)
3708                                 psrch_inf->endOfSearch = TRUE;
3709                         else
3710                                 psrch_inf->endOfSearch = FALSE;
3711                         psrch_inf->entries_in_buffer =
3712                                                 le16_to_cpu(parms->SearchCount);
3713                         psrch_inf->index_of_last_entry +=
3714                                 psrch_inf->entries_in_buffer;
3715 /*  cFYI(1,("fnxt2 entries in buf %d index_of_last %d",
3716             psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry)); */
3717
3718                         /* BB fixme add unlock here */
3719                 }
3720
3721         }
3722
3723         /* BB On error, should we leave previous search buf (and count and
3724         last entry fields) intact or free the previous one? */
3725
3726         /* Note: On -EAGAIN error only caller can retry on handle based calls
3727         since file handle passed in no longer valid */
3728 FNext2_err_exit:
3729         if (rc != 0)
3730                 cifs_buf_release(pSMB);
3731         return rc;
3732 }
3733
3734 int
3735 CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
3736               const __u16 searchHandle)
3737 {
3738         int rc = 0;
3739         FINDCLOSE_REQ *pSMB = NULL;
3740
3741         cFYI(1, ("In CIFSSMBFindClose"));
3742         rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
3743
3744         /* no sense returning error if session restarted
3745                 as file handle has been closed */
3746         if (rc == -EAGAIN)
3747                 return 0;
3748         if (rc)
3749                 return rc;
3750
3751         pSMB->FileID = searchHandle;
3752         pSMB->ByteCount = 0;
3753         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
3754         if (rc)
3755                 cERROR(1, ("Send error in FindClose = %d", rc));
3756
3757         cifs_stats_inc(&tcon->num_fclose);
3758
3759         /* Since session is dead, search handle closed on server already */
3760         if (rc == -EAGAIN)
3761                 rc = 0;
3762
3763         return rc;
3764 }
3765
3766 int
3767 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
3768                       const unsigned char *searchName,
3769                       __u64 *inode_number,
3770                       const struct nls_table *nls_codepage, int remap)
3771 {
3772         int rc = 0;
3773         TRANSACTION2_QPI_REQ *pSMB = NULL;
3774         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3775         int name_len, bytes_returned;
3776         __u16 params, byte_count;
3777
3778         cFYI(1, ("In GetSrvInodeNum for %s", searchName));
3779         if (tcon == NULL)
3780                 return -ENODEV;
3781
3782 GetInodeNumberRetry:
3783         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3784                       (void **) &pSMBr);
3785         if (rc)
3786                 return rc;
3787
3788         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3789                 name_len =
3790                         cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3791                                          PATH_MAX, nls_codepage, remap);
3792                 name_len++;     /* trailing null */
3793                 name_len *= 2;
3794         } else {        /* BB improve the check for buffer overruns BB */
3795                 name_len = strnlen(searchName, PATH_MAX);
3796                 name_len++;     /* trailing null */
3797                 strncpy(pSMB->FileName, searchName, name_len);
3798         }
3799
3800         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
3801         pSMB->TotalDataCount = 0;
3802         pSMB->MaxParameterCount = cpu_to_le16(2);
3803         /* BB find exact max data count below from sess structure BB */
3804         pSMB->MaxDataCount = cpu_to_le16(4000);
3805         pSMB->MaxSetupCount = 0;
3806         pSMB->Reserved = 0;
3807         pSMB->Flags = 0;
3808         pSMB->Timeout = 0;
3809         pSMB->Reserved2 = 0;
3810         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3811                 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3812         pSMB->DataCount = 0;
3813         pSMB->DataOffset = 0;
3814         pSMB->SetupCount = 1;
3815         pSMB->Reserved3 = 0;
3816         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3817         byte_count = params + 1 /* pad */ ;
3818         pSMB->TotalParameterCount = cpu_to_le16(params);
3819         pSMB->ParameterCount = pSMB->TotalParameterCount;
3820         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
3821         pSMB->Reserved4 = 0;
3822         pSMB->hdr.smb_buf_length += byte_count;
3823         pSMB->ByteCount = cpu_to_le16(byte_count);
3824
3825         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3826                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3827         if (rc) {
3828                 cFYI(1, ("error %d in QueryInternalInfo", rc));
3829         } else {
3830                 /* decode response */
3831                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3832                 if (rc || (pSMBr->ByteCount < 2))
3833                 /* BB also check enough total bytes returned */
3834                         /* If rc should we check for EOPNOSUPP and
3835                         disable the srvino flag? or in caller? */
3836                         rc = -EIO;      /* bad smb */
3837                 else {
3838                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3839                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3840                         struct file_internal_info *pfinfo;
3841                         /* BB Do we need a cast or hash here ? */
3842                         if (count < 8) {
3843                                 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
3844                                 rc = -EIO;
3845                                 goto GetInodeNumOut;
3846                         }
3847                         pfinfo = (struct file_internal_info *)
3848                                 (data_offset + (char *) &pSMBr->hdr.Protocol);
3849                         *inode_number = pfinfo->UniqueId;
3850                 }
3851         }
3852 GetInodeNumOut:
3853         cifs_buf_release(pSMB);
3854         if (rc == -EAGAIN)
3855                 goto GetInodeNumberRetry;
3856         return rc;
3857 }
3858
3859 int
3860 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
3861                 const unsigned char *searchName,
3862                 unsigned char **targetUNCs,
3863                 unsigned int *number_of_UNC_in_array,
3864                 const struct nls_table *nls_codepage, int remap)
3865 {
3866 /* TRANS2_GET_DFS_REFERRAL */
3867         TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
3868         TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
3869         struct dfs_referral_level_3 *referrals = NULL;
3870         int rc = 0;
3871         int bytes_returned;
3872         int name_len;
3873         unsigned int i;
3874         char *temp;
3875         __u16 params, byte_count;
3876         *number_of_UNC_in_array = 0;
3877         *targetUNCs = NULL;
3878
3879         cFYI(1, ("In GetDFSRefer the path %s", searchName));
3880         if (ses == NULL)
3881                 return -ENODEV;
3882 getDFSRetry:
3883         rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
3884                       (void **) &pSMBr);
3885         if (rc)
3886                 return rc;
3887
3888         /* server pointer checked in called function,
3889         but should never be null here anyway */
3890         pSMB->hdr.Mid = GetNextMid(ses->server);
3891         pSMB->hdr.Tid = ses->ipc_tid;
3892         pSMB->hdr.Uid = ses->Suid;
3893         if (ses->capabilities & CAP_STATUS32)
3894                 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
3895         if (ses->capabilities & CAP_DFS)
3896                 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
3897
3898         if (ses->capabilities & CAP_UNICODE) {
3899                 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
3900                 name_len =
3901                     cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
3902                                      searchName, PATH_MAX, nls_codepage, remap);
3903                 name_len++;     /* trailing null */
3904                 name_len *= 2;
3905         } else {        /* BB improve the check for buffer overruns BB */
3906                 name_len = strnlen(searchName, PATH_MAX);
3907                 name_len++;     /* trailing null */
3908                 strncpy(pSMB->RequestFileName, searchName, name_len);
3909         }
3910
3911         if (ses->server) {
3912                 if (ses->server->secMode &
3913                    (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3914                         pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3915         }
3916
3917         pSMB->hdr.Uid = ses->Suid;
3918
3919         params = 2 /* level */  + name_len /*includes null */ ;
3920         pSMB->TotalDataCount = 0;
3921         pSMB->DataCount = 0;
3922         pSMB->DataOffset = 0;
3923         pSMB->MaxParameterCount = 0;
3924         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3925         pSMB->MaxSetupCount = 0;
3926         pSMB->Reserved = 0;
3927         pSMB->Flags = 0;
3928         pSMB->Timeout = 0;
3929         pSMB->Reserved2 = 0;
3930         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3931           struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
3932         pSMB->SetupCount = 1;
3933         pSMB->Reserved3 = 0;
3934         pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
3935         byte_count = params + 3 /* pad */ ;
3936         pSMB->ParameterCount = cpu_to_le16(params);
3937         pSMB->TotalParameterCount = pSMB->ParameterCount;
3938         pSMB->MaxReferralLevel = cpu_to_le16(3);
3939         pSMB->hdr.smb_buf_length += byte_count;
3940         pSMB->ByteCount = cpu_to_le16(byte_count);
3941
3942         rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
3943                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3944         if (rc) {
3945                 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
3946         } else {                /* decode response */
3947 /* BB Add logic to parse referrals here */
3948                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3949
3950                 /* BB Also check if enough total bytes returned? */
3951                 if (rc || (pSMBr->ByteCount < 17))
3952                         rc = -EIO;      /* bad smb */
3953                 else {
3954                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3955                         __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
3956
3957                         cFYI(1,
3958                             ("Decoding GetDFSRefer response BCC: %d  Offset %d",
3959                               pSMBr->ByteCount, data_offset));
3960                         referrals =
3961                             (struct dfs_referral_level_3 *)
3962                                         (8 /* sizeof start of data block */ +
3963                                         data_offset +
3964                                         (char *) &pSMBr->hdr.Protocol);
3965                         cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n"
3966                                 "for referral one refer size: 0x%x srv "
3967                                 "type: 0x%x refer flags: 0x%x ttl: 0x%x",
3968                                 le16_to_cpu(pSMBr->NumberOfReferrals),
3969                                 le16_to_cpu(pSMBr->DFSFlags),
3970                                 le16_to_cpu(referrals->ReferralSize),
3971                                 le16_to_cpu(referrals->ServerType),
3972                                 le16_to_cpu(referrals->ReferralFlags),
3973                                 le16_to_cpu(referrals->TimeToLive)));
3974                         /* BB This field is actually two bytes in from start of
3975                            data block so we could do safety check that DataBlock
3976                            begins at address of pSMBr->NumberOfReferrals */
3977                         *number_of_UNC_in_array =
3978                                         le16_to_cpu(pSMBr->NumberOfReferrals);
3979
3980                         /* BB Fix below so can return more than one referral */
3981                         if (*number_of_UNC_in_array > 1)
3982                                 *number_of_UNC_in_array = 1;
3983
3984                         /* get the length of the strings describing refs */
3985                         name_len = 0;
3986                         for (i = 0; i < *number_of_UNC_in_array; i++) {
3987                                 /* make sure that DfsPathOffset not past end */
3988                                 __u16 offset =
3989                                         le16_to_cpu(referrals->DfsPathOffset);
3990                                 if (offset > data_count) {
3991                                         /* if invalid referral, stop here and do
3992                                         not try to copy any more */
3993                                         *number_of_UNC_in_array = i;
3994                                         break;
3995                                 }
3996                                 temp = ((char *)referrals) + offset;
3997
3998                                 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3999                                         name_len += UniStrnlen((wchar_t *)temp,
4000                                                                 data_count);
4001                                 } else {
4002                                         name_len += strnlen(temp, data_count);
4003                                 }
4004                                 referrals++;
4005                                 /* BB add check that referral pointer does
4006                                    not fall off end PDU */
4007                         }
4008                         /* BB add check for name_len bigger than bcc */
4009                         *targetUNCs =
4010                                 kmalloc(name_len+1+(*number_of_UNC_in_array),
4011                                         GFP_KERNEL);
4012                         if (*targetUNCs == NULL) {
4013                                 rc = -ENOMEM;
4014                                 goto GetDFSRefExit;
4015                         }
4016                         /* copy the ref strings */
4017                         referrals = (struct dfs_referral_level_3 *)
4018                                         (8 /* sizeof data hdr */ + data_offset +
4019                                         (char *) &pSMBr->hdr.Protocol);
4020
4021                         for (i = 0; i < *number_of_UNC_in_array; i++) {
4022                                 temp = ((char *)referrals) +
4023                                           le16_to_cpu(referrals->DfsPathOffset);
4024                                 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
4025                                         cifs_strfromUCS_le(*targetUNCs,
4026                                                           (__le16 *) temp,
4027                                                           name_len,
4028                                                           nls_codepage);
4029                                 } else {
4030                                         strncpy(*targetUNCs, temp, name_len);
4031                                 }
4032                                 /*  BB update target_uncs pointers */
4033                                 referrals++;
4034                         }
4035                         temp = *targetUNCs;
4036                         temp[name_len] = 0;
4037                 }
4038
4039         }
4040 GetDFSRefExit:
4041         if (pSMB)
4042                 cifs_buf_release(pSMB);
4043
4044         if (rc == -EAGAIN)
4045                 goto getDFSRetry;
4046
4047         return rc;
4048 }
4049
4050 /* Query File System Info such as free space to old servers such as Win 9x */
4051 int
4052 SMBOldQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4053 {
4054 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4055         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4056         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4057         FILE_SYSTEM_ALLOC_INFO *response_data;
4058         int rc = 0;
4059         int bytes_returned = 0;
4060         __u16 params, byte_count;
4061
4062         cFYI(1, ("OldQFSInfo"));
4063 oldQFSInfoRetry:
4064         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4065                 (void **) &pSMBr);
4066         if (rc)
4067                 return rc;
4068
4069         params = 2;     /* level */
4070         pSMB->TotalDataCount = 0;
4071         pSMB->MaxParameterCount = cpu_to_le16(2);
4072         pSMB->MaxDataCount = cpu_to_le16(1000);
4073         pSMB->MaxSetupCount = 0;
4074         pSMB->Reserved = 0;
4075         pSMB->Flags = 0;
4076         pSMB->Timeout = 0;
4077         pSMB->Reserved2 = 0;
4078         byte_count = params + 1 /* pad */ ;
4079         pSMB->TotalParameterCount = cpu_to_le16(params);
4080         pSMB->ParameterCount = pSMB->TotalParameterCount;
4081         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4082         struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4083         pSMB->DataCount = 0;
4084         pSMB->DataOffset = 0;
4085         pSMB->SetupCount = 1;
4086         pSMB->Reserved3 = 0;
4087         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4088         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4089         pSMB->hdr.smb_buf_length += byte_count;
4090         pSMB->ByteCount = cpu_to_le16(byte_count);
4091
4092         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4093                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4094         if (rc) {
4095                 cFYI(1, ("Send error in QFSInfo = %d", rc));
4096         } else {                /* decode response */
4097                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4098
4099                 if (rc || (pSMBr->ByteCount < 18))
4100                         rc = -EIO;      /* bad smb */
4101                 else {
4102                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4103                         cFYI(1, ("qfsinf resp BCC: %d  Offset %d",
4104                                  pSMBr->ByteCount, data_offset));
4105
4106                         response_data = (FILE_SYSTEM_ALLOC_INFO *)
4107                                 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4108                         FSData->f_bsize =
4109                                 le16_to_cpu(response_data->BytesPerSector) *
4110                                 le32_to_cpu(response_data->
4111                                         SectorsPerAllocationUnit);
4112                         FSData->f_blocks =
4113                                le32_to_cpu(response_data->TotalAllocationUnits);
4114                         FSData->f_bfree = FSData->f_bavail =
4115                                 le32_to_cpu(response_data->FreeAllocationUnits);
4116                         cFYI(1,
4117                              ("Blocks: %lld  Free: %lld Block size %ld",
4118                               (unsigned long long)FSData->f_blocks,
4119                               (unsigned long long)FSData->f_bfree,
4120                               FSData->f_bsize));
4121                 }
4122         }
4123         cifs_buf_release(pSMB);
4124
4125         if (rc == -EAGAIN)
4126                 goto oldQFSInfoRetry;
4127
4128         return rc;
4129 }
4130
4131 int
4132 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4133 {
4134 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4135         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4136         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4137         FILE_SYSTEM_INFO *response_data;
4138         int rc = 0;
4139         int bytes_returned = 0;
4140         __u16 params, byte_count;
4141
4142         cFYI(1, ("In QFSInfo"));
4143 QFSInfoRetry:
4144         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4145                       (void **) &pSMBr);
4146         if (rc)
4147                 return rc;
4148
4149         params = 2;     /* level */
4150         pSMB->TotalDataCount = 0;
4151         pSMB->MaxParameterCount = cpu_to_le16(2);
4152         pSMB->MaxDataCount = cpu_to_le16(1000);
4153         pSMB->MaxSetupCount = 0;
4154         pSMB->Reserved = 0;
4155         pSMB->Flags = 0;
4156         pSMB->Timeout = 0;
4157         pSMB->Reserved2 = 0;
4158         byte_count = params + 1 /* pad */ ;
4159         pSMB->TotalParameterCount = cpu_to_le16(params);
4160         pSMB->ParameterCount = pSMB->TotalParameterCount;
4161         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4162                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4163         pSMB->DataCount = 0;
4164         pSMB->DataOffset = 0;
4165         pSMB->SetupCount = 1;
4166         pSMB->Reserved3 = 0;
4167         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4168         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
4169         pSMB->hdr.smb_buf_length += byte_count;
4170         pSMB->ByteCount = cpu_to_le16(byte_count);
4171
4172         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4173                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4174         if (rc) {
4175                 cFYI(1, ("Send error in QFSInfo = %d", rc));
4176         } else {                /* decode response */
4177                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4178
4179                 if (rc || (pSMBr->ByteCount < 24))
4180                         rc = -EIO;      /* bad smb */
4181                 else {
4182                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4183
4184                         response_data =
4185                             (FILE_SYSTEM_INFO
4186                              *) (((char *) &pSMBr->hdr.Protocol) +
4187                                  data_offset);
4188                         FSData->f_bsize =
4189                             le32_to_cpu(response_data->BytesPerSector) *
4190                             le32_to_cpu(response_data->
4191                                         SectorsPerAllocationUnit);
4192                         FSData->f_blocks =
4193                             le64_to_cpu(response_data->TotalAllocationUnits);
4194                         FSData->f_bfree = FSData->f_bavail =
4195                             le64_to_cpu(response_data->FreeAllocationUnits);
4196                         cFYI(1,
4197                              ("Blocks: %lld  Free: %lld Block size %ld",
4198                               (unsigned long long)FSData->f_blocks,
4199                               (unsigned long long)FSData->f_bfree,
4200                               FSData->f_bsize));
4201                 }
4202         }
4203         cifs_buf_release(pSMB);
4204
4205         if (rc == -EAGAIN)
4206                 goto QFSInfoRetry;
4207
4208         return rc;
4209 }
4210
4211 int
4212 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon)
4213 {
4214 /* level 0x105  SMB_QUERY_FILE_SYSTEM_INFO */
4215         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4216         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4217         FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
4218         int rc = 0;
4219         int bytes_returned = 0;
4220         __u16 params, byte_count;
4221
4222         cFYI(1, ("In QFSAttributeInfo"));
4223 QFSAttributeRetry:
4224         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4225                       (void **) &pSMBr);
4226         if (rc)
4227                 return rc;
4228
4229         params = 2;     /* level */
4230         pSMB->TotalDataCount = 0;
4231         pSMB->MaxParameterCount = cpu_to_le16(2);
4232         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4233         pSMB->MaxSetupCount = 0;
4234         pSMB->Reserved = 0;
4235         pSMB->Flags = 0;
4236         pSMB->Timeout = 0;
4237         pSMB->Reserved2 = 0;
4238         byte_count = params + 1 /* pad */ ;
4239         pSMB->TotalParameterCount = cpu_to_le16(params);
4240         pSMB->ParameterCount = pSMB->TotalParameterCount;
4241         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4242                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4243         pSMB->DataCount = 0;
4244         pSMB->DataOffset = 0;
4245         pSMB->SetupCount = 1;
4246         pSMB->Reserved3 = 0;
4247         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4248         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
4249         pSMB->hdr.smb_buf_length += byte_count;
4250         pSMB->ByteCount = cpu_to_le16(byte_count);
4251
4252         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4253                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4254         if (rc) {
4255                 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
4256         } else {                /* decode response */
4257                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4258
4259                 if (rc || (pSMBr->ByteCount < 13)) {
4260                         /* BB also check if enough bytes returned */
4261                         rc = -EIO;      /* bad smb */
4262                 } else {
4263                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4264                         response_data =
4265                             (FILE_SYSTEM_ATTRIBUTE_INFO
4266                              *) (((char *) &pSMBr->hdr.Protocol) +
4267                                  data_offset);
4268                         memcpy(&tcon->fsAttrInfo, response_data,
4269                                sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
4270                 }
4271         }
4272         cifs_buf_release(pSMB);
4273
4274         if (rc == -EAGAIN)
4275                 goto QFSAttributeRetry;
4276
4277         return rc;
4278 }
4279
4280 int
4281 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon)
4282 {
4283 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
4284         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4285         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4286         FILE_SYSTEM_DEVICE_INFO *response_data;
4287         int rc = 0;
4288         int bytes_returned = 0;
4289         __u16 params, byte_count;
4290
4291         cFYI(1, ("In QFSDeviceInfo"));
4292 QFSDeviceRetry:
4293         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4294                       (void **) &pSMBr);
4295         if (rc)
4296                 return rc;
4297
4298         params = 2;     /* level */
4299         pSMB->TotalDataCount = 0;
4300         pSMB->MaxParameterCount = cpu_to_le16(2);
4301         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4302         pSMB->MaxSetupCount = 0;
4303         pSMB->Reserved = 0;
4304         pSMB->Flags = 0;
4305         pSMB->Timeout = 0;
4306         pSMB->Reserved2 = 0;
4307         byte_count = params + 1 /* pad */ ;
4308         pSMB->TotalParameterCount = cpu_to_le16(params);
4309         pSMB->ParameterCount = pSMB->TotalParameterCount;
4310         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4311                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4312
4313         pSMB->DataCount = 0;
4314         pSMB->DataOffset = 0;
4315         pSMB->SetupCount = 1;
4316         pSMB->Reserved3 = 0;
4317         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4318         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
4319         pSMB->hdr.smb_buf_length += byte_count;
4320         pSMB->ByteCount = cpu_to_le16(byte_count);
4321
4322         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4323                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4324         if (rc) {
4325                 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
4326         } else {                /* decode response */
4327                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4328
4329                 if (rc || (pSMBr->ByteCount < sizeof(FILE_SYSTEM_DEVICE_INFO)))
4330                         rc = -EIO;      /* bad smb */
4331                 else {
4332                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4333                         response_data =
4334                             (FILE_SYSTEM_DEVICE_INFO *)
4335                                 (((char *) &pSMBr->hdr.Protocol) +
4336                                  data_offset);
4337                         memcpy(&tcon->fsDevInfo, response_data,
4338                                sizeof(FILE_SYSTEM_DEVICE_INFO));
4339                 }
4340         }
4341         cifs_buf_release(pSMB);
4342
4343         if (rc == -EAGAIN)
4344                 goto QFSDeviceRetry;
4345
4346         return rc;
4347 }
4348
4349 int
4350 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon)
4351 {
4352 /* level 0x200  SMB_QUERY_CIFS_UNIX_INFO */
4353         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4354         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4355         FILE_SYSTEM_UNIX_INFO *response_data;
4356         int rc = 0;
4357         int bytes_returned = 0;
4358         __u16 params, byte_count;
4359
4360         cFYI(1, ("In QFSUnixInfo"));
4361 QFSUnixRetry:
4362         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4363                       (void **) &pSMBr);
4364         if (rc)
4365                 return rc;
4366
4367         params = 2;     /* level */
4368         pSMB->TotalDataCount = 0;
4369         pSMB->DataCount = 0;
4370         pSMB->DataOffset = 0;
4371         pSMB->MaxParameterCount = cpu_to_le16(2);
4372         pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
4373         pSMB->MaxSetupCount = 0;
4374         pSMB->Reserved = 0;
4375         pSMB->Flags = 0;
4376         pSMB->Timeout = 0;
4377         pSMB->Reserved2 = 0;
4378         byte_count = params + 1 /* pad */ ;
4379         pSMB->ParameterCount = cpu_to_le16(params);
4380         pSMB->TotalParameterCount = pSMB->ParameterCount;
4381         pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4382                         smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4383         pSMB->SetupCount = 1;
4384         pSMB->Reserved3 = 0;
4385         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4386         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
4387         pSMB->hdr.smb_buf_length += byte_count;
4388         pSMB->ByteCount = cpu_to_le16(byte_count);
4389
4390         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4391                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4392         if (rc) {
4393                 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
4394         } else {                /* decode response */
4395                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4396
4397                 if (rc || (pSMBr->ByteCount < 13)) {
4398                         rc = -EIO;      /* bad smb */
4399                 } else {
4400                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4401                         response_data =
4402                             (FILE_SYSTEM_UNIX_INFO
4403                              *) (((char *) &pSMBr->hdr.Protocol) +
4404                                  data_offset);
4405                         memcpy(&tcon->fsUnixInfo, response_data,
4406                                sizeof(FILE_SYSTEM_UNIX_INFO));
4407                 }
4408         }
4409         cifs_buf_release(pSMB);
4410
4411         if (rc == -EAGAIN)
4412                 goto QFSUnixRetry;
4413
4414
4415         return rc;
4416 }
4417
4418 int
4419 CIFSSMBSetFSUnixInfo(const int xid, struct cifsTconInfo *tcon, __u64 cap)
4420 {
4421 /* level 0x200  SMB_SET_CIFS_UNIX_INFO */
4422         TRANSACTION2_SETFSI_REQ *pSMB = NULL;
4423         TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
4424         int rc = 0;
4425         int bytes_returned = 0;
4426         __u16 params, param_offset, offset, byte_count;
4427
4428         cFYI(1, ("In SETFSUnixInfo"));
4429 SETFSUnixRetry:
4430         /* BB switch to small buf init to save memory */
4431         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4432                       (void **) &pSMBr);
4433         if (rc)
4434                 return rc;
4435
4436         params = 4;     /* 2 bytes zero followed by info level. */
4437         pSMB->MaxSetupCount = 0;
4438         pSMB->Reserved = 0;
4439         pSMB->Flags = 0;
4440         pSMB->Timeout = 0;
4441         pSMB->Reserved2 = 0;
4442         param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
4443                                 - 4;
4444         offset = param_offset + params;
4445
4446         pSMB->MaxParameterCount = cpu_to_le16(4);
4447         pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
4448         pSMB->SetupCount = 1;
4449         pSMB->Reserved3 = 0;
4450         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
4451         byte_count = 1 /* pad */ + params + 12;
4452
4453         pSMB->DataCount = cpu_to_le16(12);
4454         pSMB->ParameterCount = cpu_to_le16(params);
4455         pSMB->TotalDataCount = pSMB->DataCount;
4456         pSMB->TotalParameterCount = pSMB->ParameterCount;
4457         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4458         pSMB->DataOffset = cpu_to_le16(offset);
4459
4460         /* Params. */
4461         pSMB->FileNum = 0;
4462         pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
4463
4464         /* Data. */
4465         pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
4466         pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
4467         pSMB->ClientUnixCap = cpu_to_le64(cap);
4468
4469         pSMB->hdr.smb_buf_length += byte_count;
4470         pSMB->ByteCount = cpu_to_le16(byte_count);
4471
4472         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4473                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4474         if (rc) {
4475                 cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
4476         } else {                /* decode response */
4477                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4478                 if (rc)
4479                         rc = -EIO;      /* bad smb */
4480         }
4481         cifs_buf_release(pSMB);
4482
4483         if (rc == -EAGAIN)
4484                 goto SETFSUnixRetry;
4485
4486         return rc;
4487 }
4488
4489
4490
4491 int
4492 CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
4493                    struct kstatfs *FSData)
4494 {
4495 /* level 0x201  SMB_QUERY_CIFS_POSIX_INFO */
4496         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4497         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4498         FILE_SYSTEM_POSIX_INFO *response_data;
4499         int rc = 0;
4500         int bytes_returned = 0;
4501         __u16 params, byte_count;
4502
4503         cFYI(1, ("In QFSPosixInfo"));
4504 QFSPosixRetry:
4505         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4506                       (void **) &pSMBr);
4507         if (rc)
4508                 return rc;
4509
4510         params = 2;     /* level */
4511         pSMB->TotalDataCount = 0;
4512         pSMB->DataCount = 0;
4513         pSMB->DataOffset = 0;
4514         pSMB->MaxParameterCount = cpu_to_le16(2);
4515         pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
4516         pSMB->MaxSetupCount = 0;
4517         pSMB->Reserved = 0;
4518         pSMB->Flags = 0;
4519         pSMB->Timeout = 0;
4520         pSMB->Reserved2 = 0;
4521         byte_count = params + 1 /* pad */ ;
4522         pSMB->ParameterCount = cpu_to_le16(params);
4523         pSMB->TotalParameterCount = pSMB->ParameterCount;
4524         pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4525                         smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4526         pSMB->SetupCount = 1;
4527         pSMB->Reserved3 = 0;
4528         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4529         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
4530         pSMB->hdr.smb_buf_length += byte_count;
4531         pSMB->ByteCount = cpu_to_le16(byte_count);
4532
4533         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4534                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4535         if (rc) {
4536                 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
4537         } else {                /* decode response */
4538                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4539
4540                 if (rc || (pSMBr->ByteCount < 13)) {
4541                         rc = -EIO;      /* bad smb */
4542                 } else {
4543                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4544                         response_data =
4545                             (FILE_SYSTEM_POSIX_INFO
4546                              *) (((char *) &pSMBr->hdr.Protocol) +
4547                                  data_offset);
4548                         FSData->f_bsize =
4549                                         le32_to_cpu(response_data->BlockSize);
4550                         FSData->f_blocks =
4551                                         le64_to_cpu(response_data->TotalBlocks);
4552                         FSData->f_bfree =
4553                             le64_to_cpu(response_data->BlocksAvail);
4554                         if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
4555                                 FSData->f_bavail = FSData->f_bfree;
4556                         } else {
4557                                 FSData->f_bavail =
4558                                     le64_to_cpu(response_data->UserBlocksAvail);
4559                         }
4560                         if (response_data->TotalFileNodes != cpu_to_le64(-1))
4561                                 FSData->f_files =
4562                                      le64_to_cpu(response_data->TotalFileNodes);
4563                         if (response_data->FreeFileNodes != cpu_to_le64(-1))
4564                                 FSData->f_ffree =
4565                                       le64_to_cpu(response_data->FreeFileNodes);
4566                 }
4567         }
4568         cifs_buf_release(pSMB);
4569
4570         if (rc == -EAGAIN)
4571                 goto QFSPosixRetry;
4572
4573         return rc;
4574 }
4575
4576
4577 /* We can not use write of zero bytes trick to
4578    set file size due to need for large file support.  Also note that
4579    this SetPathInfo is preferred to SetFileInfo based method in next
4580    routine which is only needed to work around a sharing violation bug
4581    in Samba which this routine can run into */
4582
4583 int
4584 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4585               __u64 size, int SetAllocation,
4586               const struct nls_table *nls_codepage, int remap)
4587 {
4588         struct smb_com_transaction2_spi_req *pSMB = NULL;
4589         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4590         struct file_end_of_file_info *parm_data;
4591         int name_len;
4592         int rc = 0;
4593         int bytes_returned = 0;
4594         __u16 params, byte_count, data_count, param_offset, offset;
4595
4596         cFYI(1, ("In SetEOF"));
4597 SetEOFRetry:
4598         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4599                       (void **) &pSMBr);
4600         if (rc)
4601                 return rc;
4602
4603         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4604                 name_len =
4605                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4606                                      PATH_MAX, nls_codepage, remap);
4607                 name_len++;     /* trailing null */
4608                 name_len *= 2;
4609         } else {        /* BB improve the check for buffer overruns BB */
4610                 name_len = strnlen(fileName, PATH_MAX);
4611                 name_len++;     /* trailing null */
4612                 strncpy(pSMB->FileName, fileName, name_len);
4613         }
4614         params = 6 + name_len;
4615         data_count = sizeof(struct file_end_of_file_info);
4616         pSMB->MaxParameterCount = cpu_to_le16(2);
4617         pSMB->MaxDataCount = cpu_to_le16(4100);
4618         pSMB->MaxSetupCount = 0;
4619         pSMB->Reserved = 0;
4620         pSMB->Flags = 0;
4621         pSMB->Timeout = 0;
4622         pSMB->Reserved2 = 0;
4623         param_offset = offsetof(struct smb_com_transaction2_spi_req,
4624                                 InformationLevel) - 4;
4625         offset = param_offset + params;
4626         if (SetAllocation) {
4627                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4628                         pSMB->InformationLevel =
4629                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4630                 else
4631                         pSMB->InformationLevel =
4632                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4633         } else /* Set File Size */  {
4634             if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4635                     pSMB->InformationLevel =
4636                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4637             else
4638                     pSMB->InformationLevel =
4639                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4640         }
4641
4642         parm_data =
4643             (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4644                                        offset);
4645         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4646         pSMB->DataOffset = cpu_to_le16(offset);
4647         pSMB->SetupCount = 1;
4648         pSMB->Reserved3 = 0;
4649         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4650         byte_count = 3 /* pad */  + params + data_count;
4651         pSMB->DataCount = cpu_to_le16(data_count);
4652         pSMB->TotalDataCount = pSMB->DataCount;
4653         pSMB->ParameterCount = cpu_to_le16(params);
4654         pSMB->TotalParameterCount = pSMB->ParameterCount;
4655         pSMB->Reserved4 = 0;
4656         pSMB->hdr.smb_buf_length += byte_count;
4657         parm_data->FileSize = cpu_to_le64(size);
4658         pSMB->ByteCount = cpu_to_le16(byte_count);
4659         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4660                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4661         if (rc)
4662                 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
4663
4664         cifs_buf_release(pSMB);
4665
4666         if (rc == -EAGAIN)
4667                 goto SetEOFRetry;
4668
4669         return rc;
4670 }
4671
4672 int
4673 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
4674                    __u16 fid, __u32 pid_of_opener, int SetAllocation)
4675 {
4676         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
4677         char *data_offset;
4678         struct file_end_of_file_info *parm_data;
4679         int rc = 0;
4680         __u16 params, param_offset, offset, byte_count, count;
4681
4682         cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
4683                         (long long)size));
4684         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4685
4686         if (rc)
4687                 return rc;
4688
4689         pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4690         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
4691
4692         params = 6;
4693         pSMB->MaxSetupCount = 0;
4694         pSMB->Reserved = 0;
4695         pSMB->Flags = 0;
4696         pSMB->Timeout = 0;
4697         pSMB->Reserved2 = 0;
4698         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4699         offset = param_offset + params;
4700
4701         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4702
4703         count = sizeof(struct file_end_of_file_info);
4704         pSMB->MaxParameterCount = cpu_to_le16(2);
4705         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4706         pSMB->SetupCount = 1;
4707         pSMB->Reserved3 = 0;
4708         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4709         byte_count = 3 /* pad */  + params + count;
4710         pSMB->DataCount = cpu_to_le16(count);
4711         pSMB->ParameterCount = cpu_to_le16(params);
4712         pSMB->TotalDataCount = pSMB->DataCount;
4713         pSMB->TotalParameterCount = pSMB->ParameterCount;
4714         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4715         parm_data =
4716                 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
4717                                 + offset);
4718         pSMB->DataOffset = cpu_to_le16(offset);
4719         parm_data->FileSize = cpu_to_le64(size);
4720         pSMB->Fid = fid;
4721         if (SetAllocation) {
4722                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4723                         pSMB->InformationLevel =
4724                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4725                 else
4726                         pSMB->InformationLevel =
4727                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4728         } else /* Set File Size */  {
4729             if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4730                     pSMB->InformationLevel =
4731                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4732             else
4733                     pSMB->InformationLevel =
4734                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4735         }
4736         pSMB->Reserved4 = 0;
4737         pSMB->hdr.smb_buf_length += byte_count;
4738         pSMB->ByteCount = cpu_to_le16(byte_count);
4739         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
4740         if (rc) {
4741                 cFYI(1,
4742                      ("Send error in SetFileInfo (SetFileSize) = %d",
4743                       rc));
4744         }
4745
4746         /* Note: On -EAGAIN error only caller can retry on handle based calls
4747                 since file handle passed in no longer valid */
4748
4749         return rc;
4750 }
4751
4752 /* Some legacy servers such as NT4 require that the file times be set on
4753    an open handle, rather than by pathname - this is awkward due to
4754    potential access conflicts on the open, but it is unavoidable for these
4755    old servers since the only other choice is to go from 100 nanosecond DCE
4756    time and resort to the original setpathinfo level which takes the ancient
4757    DOS time format with 2 second granularity */
4758 int
4759 CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
4760                     const FILE_BASIC_INFO *data, __u16 fid)
4761 {
4762         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
4763         char *data_offset;
4764         int rc = 0;
4765         __u16 params, param_offset, offset, byte_count, count;
4766
4767         cFYI(1, ("Set Times (via SetFileInfo)"));
4768         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4769
4770         if (rc)
4771                 return rc;
4772
4773         /* At this point there is no need to override the current pid
4774         with the pid of the opener, but that could change if we someday
4775         use an existing handle (rather than opening one on the fly) */
4776         /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4777         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
4778
4779         params = 6;
4780         pSMB->MaxSetupCount = 0;
4781         pSMB->Reserved = 0;
4782         pSMB->Flags = 0;
4783         pSMB->Timeout = 0;
4784         pSMB->Reserved2 = 0;
4785         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4786         offset = param_offset + params;
4787
4788         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4789
4790         count = sizeof(FILE_BASIC_INFO);
4791         pSMB->MaxParameterCount = cpu_to_le16(2);
4792         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4793         pSMB->SetupCount = 1;
4794         pSMB->Reserved3 = 0;
4795         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4796         byte_count = 3 /* pad */  + params + count;
4797         pSMB->DataCount = cpu_to_le16(count);
4798         pSMB->ParameterCount = cpu_to_le16(params);
4799         pSMB->TotalDataCount = pSMB->DataCount;
4800         pSMB->TotalParameterCount = pSMB->ParameterCount;
4801         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4802         pSMB->DataOffset = cpu_to_le16(offset);
4803         pSMB->Fid = fid;
4804         if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4805                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4806         else
4807                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4808         pSMB->Reserved4 = 0;
4809         pSMB->hdr.smb_buf_length += byte_count;
4810         pSMB->ByteCount = cpu_to_le16(byte_count);
4811         memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
4812         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
4813         if (rc)
4814                 cFYI(1, ("Send error in Set Time (SetFileInfo) = %d", rc));
4815
4816         /* Note: On -EAGAIN error only caller can retry on handle based calls
4817                 since file handle passed in no longer valid */
4818
4819         return rc;
4820 }
4821
4822
4823 int
4824 CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4825                 const FILE_BASIC_INFO *data,
4826                 const struct nls_table *nls_codepage, int remap)
4827 {
4828         TRANSACTION2_SPI_REQ *pSMB = NULL;
4829         TRANSACTION2_SPI_RSP *pSMBr = NULL;
4830         int name_len;
4831         int rc = 0;
4832         int bytes_returned = 0;
4833         char *data_offset;
4834         __u16 params, param_offset, offset, byte_count, count;
4835
4836         cFYI(1, ("In SetTimes"));
4837
4838 SetTimesRetry:
4839         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4840                       (void **) &pSMBr);
4841         if (rc)
4842                 return rc;
4843
4844         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4845                 name_len =
4846                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4847                                      PATH_MAX, nls_codepage, remap);
4848                 name_len++;     /* trailing null */
4849                 name_len *= 2;
4850         } else {        /* BB improve the check for buffer overruns BB */
4851                 name_len = strnlen(fileName, PATH_MAX);
4852                 name_len++;     /* trailing null */
4853                 strncpy(pSMB->FileName, fileName, name_len);
4854         }
4855
4856         params = 6 + name_len;
4857         count = sizeof(FILE_BASIC_INFO);
4858         pSMB->MaxParameterCount = cpu_to_le16(2);
4859         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4860         pSMB->MaxSetupCount = 0;
4861         pSMB->Reserved = 0;
4862         pSMB->Flags = 0;
4863         pSMB->Timeout = 0;
4864         pSMB->Reserved2 = 0;
4865         param_offset = offsetof(struct smb_com_transaction2_spi_req,
4866                                 InformationLevel) - 4;
4867         offset = param_offset + params;
4868         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4869         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4870         pSMB->DataOffset = cpu_to_le16(offset);
4871         pSMB->SetupCount = 1;
4872         pSMB->Reserved3 = 0;
4873         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4874         byte_count = 3 /* pad */  + params + count;
4875
4876         pSMB->DataCount = cpu_to_le16(count);
4877         pSMB->ParameterCount = cpu_to_le16(params);
4878         pSMB->TotalDataCount = pSMB->DataCount;
4879         pSMB->TotalParameterCount = pSMB->ParameterCount;
4880         if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4881                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4882         else
4883                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4884         pSMB->Reserved4 = 0;
4885         pSMB->hdr.smb_buf_length += byte_count;
4886         memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
4887         pSMB->ByteCount = cpu_to_le16(byte_count);
4888         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4889                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4890         if (rc)
4891                 cFYI(1, ("SetPathInfo (times) returned %d", rc));
4892
4893         cifs_buf_release(pSMB);
4894
4895         if (rc == -EAGAIN)
4896                 goto SetTimesRetry;
4897
4898         return rc;
4899 }
4900
4901 /* Can not be used to set time stamps yet (due to old DOS time format) */
4902 /* Can be used to set attributes */
4903 #if 0  /* Possibly not needed - since it turns out that strangely NT4 has a bug
4904           handling it anyway and NT4 was what we thought it would be needed for
4905           Do not delete it until we prove whether needed for Win9x though */
4906 int
4907 CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
4908                 __u16 dos_attrs, const struct nls_table *nls_codepage)
4909 {
4910         SETATTR_REQ *pSMB = NULL;
4911         SETATTR_RSP *pSMBr = NULL;
4912         int rc = 0;
4913         int bytes_returned;
4914         int name_len;
4915
4916         cFYI(1, ("In SetAttrLegacy"));
4917
4918 SetAttrLgcyRetry:
4919         rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
4920                       (void **) &pSMBr);
4921         if (rc)
4922                 return rc;
4923
4924         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4925                 name_len =
4926                         ConvertToUCS((__le16 *) pSMB->fileName, fileName,
4927                                 PATH_MAX, nls_codepage);
4928                 name_len++;     /* trailing null */
4929                 name_len *= 2;
4930         } else {        /* BB improve the check for buffer overruns BB */
4931                 name_len = strnlen(fileName, PATH_MAX);
4932                 name_len++;     /* trailing null */
4933                 strncpy(pSMB->fileName, fileName, name_len);
4934         }
4935         pSMB->attr = cpu_to_le16(dos_attrs);
4936         pSMB->BufferFormat = 0x04;
4937         pSMB->hdr.smb_buf_length += name_len + 1;
4938         pSMB->ByteCount = cpu_to_le16(name_len + 1);
4939         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4940                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4941         if (rc)
4942                 cFYI(1, ("Error in LegacySetAttr = %d", rc));
4943
4944         cifs_buf_release(pSMB);
4945
4946         if (rc == -EAGAIN)
4947                 goto SetAttrLgcyRetry;
4948
4949         return rc;
4950 }
4951 #endif /* temporarily unneeded SetAttr legacy function */
4952
4953 int
4954 CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
4955                     char *fileName, __u64 mode, __u64 uid, __u64 gid,
4956                     dev_t device, const struct nls_table *nls_codepage,
4957                     int remap)
4958 {
4959         TRANSACTION2_SPI_REQ *pSMB = NULL;
4960         TRANSACTION2_SPI_RSP *pSMBr = NULL;
4961         int name_len;
4962         int rc = 0;
4963         int bytes_returned = 0;
4964         FILE_UNIX_BASIC_INFO *data_offset;
4965         __u16 params, param_offset, offset, count, byte_count;
4966
4967         cFYI(1, ("In SetUID/GID/Mode"));
4968 setPermsRetry:
4969         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4970                       (void **) &pSMBr);
4971         if (rc)
4972                 return rc;
4973
4974         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4975                 name_len =
4976                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4977                                      PATH_MAX, nls_codepage, remap);
4978                 name_len++;     /* trailing null */
4979                 name_len *= 2;
4980         } else {        /* BB improve the check for buffer overruns BB */
4981                 name_len = strnlen(fileName, PATH_MAX);
4982                 name_len++;     /* trailing null */
4983                 strncpy(pSMB->FileName, fileName, name_len);
4984         }
4985
4986         params = 6 + name_len;
4987         count = sizeof(FILE_UNIX_BASIC_INFO);
4988         pSMB->MaxParameterCount = cpu_to_le16(2);
4989         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4990         pSMB->MaxSetupCount = 0;
4991         pSMB->Reserved = 0;
4992         pSMB->Flags = 0;
4993         pSMB->Timeout = 0;
4994         pSMB->Reserved2 = 0;
4995         param_offset = offsetof(struct smb_com_transaction2_spi_req,
4996                                 InformationLevel) - 4;
4997         offset = param_offset + params;
4998         data_offset =
4999             (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
5000                                       offset);
5001         memset(data_offset, 0, count);
5002         pSMB->DataOffset = cpu_to_le16(offset);
5003         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5004         pSMB->SetupCount = 1;
5005         pSMB->Reserved3 = 0;
5006         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5007         byte_count = 3 /* pad */  + params + count;
5008         pSMB->ParameterCount = cpu_to_le16(params);
5009         pSMB->DataCount = cpu_to_le16(count);
5010         pSMB->TotalParameterCount = pSMB->ParameterCount;
5011         pSMB->TotalDataCount = pSMB->DataCount;
5012         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5013         pSMB->Reserved4 = 0;
5014         pSMB->hdr.smb_buf_length += byte_count;
5015         /* Samba server ignores set of file size to zero due to bugs in some
5016         older clients, but we should be precise - we use SetFileSize to
5017         set file size and do not want to truncate file size to zero
5018         accidently as happened on one Samba server beta by putting
5019         zero instead of -1 here */
5020         data_offset->EndOfFile = NO_CHANGE_64;
5021         data_offset->NumOfBytes = NO_CHANGE_64;
5022         data_offset->LastStatusChange = NO_CHANGE_64;
5023         data_offset->LastAccessTime = NO_CHANGE_64;
5024         data_offset->LastModificationTime = NO_CHANGE_64;
5025         data_offset->Uid = cpu_to_le64(uid);
5026         data_offset->Gid = cpu_to_le64(gid);
5027         /* better to leave device as zero when it is  */
5028         data_offset->DevMajor = cpu_to_le64(MAJOR(device));
5029         data_offset->DevMinor = cpu_to_le64(MINOR(device));
5030         data_offset->Permissions = cpu_to_le64(mode);
5031
5032         if (S_ISREG(mode))
5033                 data_offset->Type = cpu_to_le32(UNIX_FILE);
5034         else if (S_ISDIR(mode))
5035                 data_offset->Type = cpu_to_le32(UNIX_DIR);
5036         else if (S_ISLNK(mode))
5037                 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5038         else if (S_ISCHR(mode))
5039                 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5040         else if (S_ISBLK(mode))
5041                 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5042         else if (S_ISFIFO(mode))
5043                 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5044         else if (S_ISSOCK(mode))
5045                 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5046
5047
5048         pSMB->ByteCount = cpu_to_le16(byte_count);
5049         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5050                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5051         if (rc)
5052                 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
5053
5054         if (pSMB)
5055                 cifs_buf_release(pSMB);
5056         if (rc == -EAGAIN)
5057                 goto setPermsRetry;
5058         return rc;
5059 }
5060
5061 int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
5062                   const int notify_subdirs, const __u16 netfid,
5063                   __u32 filter, struct file *pfile, int multishot,
5064                   const struct nls_table *nls_codepage)
5065 {
5066         int rc = 0;
5067         struct smb_com_transaction_change_notify_req *pSMB = NULL;
5068         struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
5069         struct dir_notify_req *dnotify_req;
5070         int bytes_returned;
5071
5072         cFYI(1, ("In CIFSSMBNotify for file handle %d", (int)netfid));
5073         rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
5074                       (void **) &pSMBr);
5075         if (rc)
5076                 return rc;
5077
5078         pSMB->TotalParameterCount = 0 ;
5079         pSMB->TotalDataCount = 0;
5080         pSMB->MaxParameterCount = cpu_to_le32(2);
5081         /* BB find exact data count max from sess structure BB */
5082         pSMB->MaxDataCount = 0; /* same in little endian or be */
5083 /* BB VERIFY verify which is correct for above BB */
5084         pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
5085                                              MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
5086
5087         pSMB->MaxSetupCount = 4;
5088         pSMB->Reserved = 0;
5089         pSMB->ParameterOffset = 0;
5090         pSMB->DataCount = 0;
5091         pSMB->DataOffset = 0;
5092         pSMB->SetupCount = 4; /* single byte does not need le conversion */
5093         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
5094         pSMB->ParameterCount = pSMB->TotalParameterCount;
5095         if (notify_subdirs)
5096                 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
5097         pSMB->Reserved2 = 0;
5098         pSMB->CompletionFilter = cpu_to_le32(filter);
5099         pSMB->Fid = netfid; /* file handle always le */
5100         pSMB->ByteCount = 0;
5101
5102         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5103                          (struct smb_hdr *)pSMBr, &bytes_returned,
5104                          CIFS_ASYNC_OP);
5105         if (rc) {
5106                 cFYI(1, ("Error in Notify = %d", rc));
5107         } else {
5108                 /* Add file to outstanding requests */
5109                 /* BB change to kmem cache alloc */
5110                 dnotify_req = kmalloc(
5111                                                 sizeof(struct dir_notify_req),
5112                                                  GFP_KERNEL);
5113                 if (dnotify_req) {
5114                         dnotify_req->Pid = pSMB->hdr.Pid;
5115                         dnotify_req->PidHigh = pSMB->hdr.PidHigh;
5116                         dnotify_req->Mid = pSMB->hdr.Mid;
5117                         dnotify_req->Tid = pSMB->hdr.Tid;
5118                         dnotify_req->Uid = pSMB->hdr.Uid;
5119                         dnotify_req->netfid = netfid;
5120                         dnotify_req->pfile = pfile;
5121                         dnotify_req->filter = filter;
5122                         dnotify_req->multishot = multishot;
5123                         spin_lock(&GlobalMid_Lock);
5124                         list_add_tail(&dnotify_req->lhead,
5125                                         &GlobalDnotifyReqList);
5126                         spin_unlock(&GlobalMid_Lock);
5127                 } else
5128                         rc = -ENOMEM;
5129         }
5130         cifs_buf_release(pSMB);
5131         return rc;
5132 }
5133 #ifdef CONFIG_CIFS_XATTR
5134 ssize_t
5135 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
5136                  const unsigned char *searchName,
5137                  char *EAData, size_t buf_size,
5138                  const struct nls_table *nls_codepage, int remap)
5139 {
5140                 /* BB assumes one setup word */
5141         TRANSACTION2_QPI_REQ *pSMB = NULL;
5142         TRANSACTION2_QPI_RSP *pSMBr = NULL;
5143         int rc = 0;
5144         int bytes_returned;
5145         int name_len;
5146         struct fea *temp_fea;
5147         char *temp_ptr;
5148         __u16 params, byte_count;
5149
5150         cFYI(1, ("In Query All EAs path %s", searchName));
5151 QAllEAsRetry:
5152         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5153                       (void **) &pSMBr);
5154         if (rc)
5155                 return rc;
5156
5157         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5158                 name_len =
5159                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5160                                      PATH_MAX, nls_codepage, remap);
5161                 name_len++;     /* trailing null */
5162                 name_len *= 2;
5163         } else {        /* BB improve the check for buffer overruns BB */
5164                 name_len = strnlen(searchName, PATH_MAX);
5165                 name_len++;     /* trailing null */
5166                 strncpy(pSMB->FileName, searchName, name_len);
5167         }
5168
5169         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5170         pSMB->TotalDataCount = 0;
5171         pSMB->MaxParameterCount = cpu_to_le16(2);
5172         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
5173         pSMB->MaxSetupCount = 0;
5174         pSMB->Reserved = 0;
5175         pSMB->Flags = 0;
5176         pSMB->Timeout = 0;
5177         pSMB->Reserved2 = 0;
5178         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5179         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5180         pSMB->DataCount = 0;
5181         pSMB->DataOffset = 0;
5182         pSMB->SetupCount = 1;
5183         pSMB->Reserved3 = 0;
5184         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5185         byte_count = params + 1 /* pad */ ;
5186         pSMB->TotalParameterCount = cpu_to_le16(params);
5187         pSMB->ParameterCount = pSMB->TotalParameterCount;
5188         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5189         pSMB->Reserved4 = 0;
5190         pSMB->hdr.smb_buf_length += byte_count;
5191         pSMB->ByteCount = cpu_to_le16(byte_count);
5192
5193         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5194                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5195         if (rc) {
5196                 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
5197         } else {                /* decode response */
5198                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5199
5200                 /* BB also check enough total bytes returned */
5201                 /* BB we need to improve the validity checking
5202                 of these trans2 responses */
5203                 if (rc || (pSMBr->ByteCount < 4))
5204                         rc = -EIO;      /* bad smb */
5205            /* else if (pFindData){
5206                         memcpy((char *) pFindData,
5207                                (char *) &pSMBr->hdr.Protocol +
5208                                data_offset, kl);
5209                 }*/ else {
5210                         /* check that length of list is not more than bcc */
5211                         /* check that each entry does not go beyond length
5212                            of list */
5213                         /* check that each element of each entry does not
5214                            go beyond end of list */
5215                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5216                         struct fealist *ea_response_data;
5217                         rc = 0;
5218                         /* validate_trans2_offsets() */
5219                         /* BB check if start of smb + data_offset > &bcc+ bcc */
5220                         ea_response_data = (struct fealist *)
5221                                 (((char *) &pSMBr->hdr.Protocol) +
5222                                 data_offset);
5223                         name_len = le32_to_cpu(ea_response_data->list_len);
5224                         cFYI(1, ("ea length %d", name_len));
5225                         if (name_len <= 8) {
5226                         /* returned EA size zeroed at top of function */
5227                                 cFYI(1, ("empty EA list returned from server"));
5228                         } else {
5229                                 /* account for ea list len */
5230                                 name_len -= 4;
5231                                 temp_fea = ea_response_data->list;
5232                                 temp_ptr = (char *)temp_fea;
5233                                 while (name_len > 0) {
5234                                         __u16 value_len;
5235                                         name_len -= 4;
5236                                         temp_ptr += 4;
5237                                         rc += temp_fea->name_len;
5238                                 /* account for prefix user. and trailing null */
5239                                         rc = rc + 5 + 1;
5240                                         if (rc < (int)buf_size) {
5241                                                 memcpy(EAData, "user.", 5);
5242                                                 EAData += 5;
5243                                                 memcpy(EAData, temp_ptr,
5244                                                        temp_fea->name_len);
5245                                                 EAData += temp_fea->name_len;
5246                                                 /* null terminate name */
5247                                                 *EAData = 0;
5248                                                 EAData = EAData + 1;
5249                                         } else if (buf_size == 0) {
5250                                                 /* skip copy - calc size only */
5251                                         } else {
5252                                                 /* stop before overrun buffer */
5253                                                 rc = -ERANGE;
5254                                                 break;
5255                                         }
5256                                         name_len -= temp_fea->name_len;
5257                                         temp_ptr += temp_fea->name_len;
5258                                         /* account for trailing null */
5259                                         name_len--;
5260                                         temp_ptr++;
5261                                         value_len =
5262                                               le16_to_cpu(temp_fea->value_len);
5263                                         name_len -= value_len;
5264                                         temp_ptr += value_len;
5265                                         /* BB check that temp_ptr is still
5266                                               within the SMB BB*/
5267
5268                                         /* no trailing null to account for
5269                                            in value len */
5270                                         /* go on to next EA */
5271                                         temp_fea = (struct fea *)temp_ptr;
5272                                 }
5273                         }
5274                 }
5275         }
5276         if (pSMB)
5277                 cifs_buf_release(pSMB);
5278         if (rc == -EAGAIN)
5279                 goto QAllEAsRetry;
5280
5281         return (ssize_t)rc;
5282 }
5283
5284 ssize_t CIFSSMBQueryEA(const int xid, struct cifsTconInfo *tcon,
5285                 const unsigned char *searchName, const unsigned char *ea_name,
5286                 unsigned char *ea_value, size_t buf_size,
5287                 const struct nls_table *nls_codepage, int remap)
5288 {
5289         TRANSACTION2_QPI_REQ *pSMB = NULL;
5290         TRANSACTION2_QPI_RSP *pSMBr = NULL;
5291         int rc = 0;
5292         int bytes_returned;
5293         int name_len;
5294         struct fea *temp_fea;
5295         char *temp_ptr;
5296         __u16 params, byte_count;
5297
5298         cFYI(1, ("In Query EA path %s", searchName));
5299 QEARetry:
5300         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5301                       (void **) &pSMBr);
5302         if (rc)
5303                 return rc;
5304
5305         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5306                 name_len =
5307                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5308                                      PATH_MAX, nls_codepage, remap);
5309                 name_len++;     /* trailing null */
5310                 name_len *= 2;
5311         } else {        /* BB improve the check for buffer overruns BB */
5312                 name_len = strnlen(searchName, PATH_MAX);
5313                 name_len++;     /* trailing null */
5314                 strncpy(pSMB->FileName, searchName, name_len);
5315         }
5316
5317         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5318         pSMB->TotalDataCount = 0;
5319         pSMB->MaxParameterCount = cpu_to_le16(2);
5320         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
5321         pSMB->MaxSetupCount = 0;
5322         pSMB->Reserved = 0;
5323         pSMB->Flags = 0;
5324         pSMB->Timeout = 0;
5325         pSMB->Reserved2 = 0;
5326         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5327                 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5328         pSMB->DataCount = 0;
5329         pSMB->DataOffset = 0;
5330         pSMB->SetupCount = 1;
5331         pSMB->Reserved3 = 0;
5332         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5333         byte_count = params + 1 /* pad */ ;
5334         pSMB->TotalParameterCount = cpu_to_le16(params);
5335         pSMB->ParameterCount = pSMB->TotalParameterCount;
5336         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5337         pSMB->Reserved4 = 0;
5338         pSMB->hdr.smb_buf_length += byte_count;
5339         pSMB->ByteCount = cpu_to_le16(byte_count);
5340
5341         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5342                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5343         if (rc) {
5344                 cFYI(1, ("Send error in Query EA = %d", rc));
5345         } else {                /* decode response */
5346                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5347
5348                 /* BB also check enough total bytes returned */
5349                 /* BB we need to improve the validity checking
5350                 of these trans2 responses */
5351                 if (rc || (pSMBr->ByteCount < 4))
5352                         rc = -EIO;      /* bad smb */
5353            /* else if (pFindData){
5354                         memcpy((char *) pFindData,
5355                                (char *) &pSMBr->hdr.Protocol +
5356                                data_offset, kl);
5357                 }*/ else {
5358                         /* check that length of list is not more than bcc */
5359                         /* check that each entry does not go beyond length
5360                            of list */
5361                         /* check that each element of each entry does not
5362                            go beyond end of list */
5363                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5364                         struct fealist *ea_response_data;
5365                         rc = -ENODATA;
5366                         /* validate_trans2_offsets() */
5367                         /* BB check if start of smb + data_offset > &bcc+ bcc*/
5368                         ea_response_data = (struct fealist *)
5369                                 (((char *) &pSMBr->hdr.Protocol) +
5370                                 data_offset);
5371                         name_len = le32_to_cpu(ea_response_data->list_len);
5372                         cFYI(1, ("ea length %d", name_len));
5373                         if (name_len <= 8) {
5374                         /* returned EA size zeroed at top of function */
5375                                 cFYI(1, ("empty EA list returned from server"));
5376                         } else {
5377                                 /* account for ea list len */
5378                                 name_len -= 4;
5379                                 temp_fea = ea_response_data->list;
5380                                 temp_ptr = (char *)temp_fea;
5381                                 /* loop through checking if we have a matching
5382                                 name and then return the associated value */
5383                                 while (name_len > 0) {
5384                                         __u16 value_len;
5385                                         name_len -= 4;
5386                                         temp_ptr += 4;
5387                                         value_len =
5388                                               le16_to_cpu(temp_fea->value_len);
5389                                 /* BB validate that value_len falls within SMB,
5390                                 even though maximum for name_len is 255 */
5391                                         if (memcmp(temp_fea->name, ea_name,
5392                                                   temp_fea->name_len) == 0) {
5393                                                 /* found a match */
5394                                                 rc = value_len;
5395                                 /* account for prefix user. and trailing null */
5396                                                 if (rc <= (int)buf_size) {
5397                                                         memcpy(ea_value,
5398                                                                 temp_fea->name+temp_fea->name_len+1,
5399                                                                 rc);
5400                                                         /* ea values, unlike ea
5401                                                            names, are not null
5402                                                            terminated */
5403                                                 } else if (buf_size == 0) {
5404                                                 /* skip copy - calc size only */
5405                                                 } else {
5406                                                 /* stop before overrun buffer */
5407                                                         rc = -ERANGE;
5408                                                 }
5409                                                 break;
5410                                         }
5411                                         name_len -= temp_fea->name_len;
5412                                         temp_ptr += temp_fea->name_len;
5413                                         /* account for trailing null */
5414                                         name_len--;
5415                                         temp_ptr++;
5416                                         name_len -= value_len;
5417                                         temp_ptr += value_len;
5418                                         /* No trailing null to account for in
5419                                            value_len.  Go on to next EA */
5420                                         temp_fea = (struct fea *)temp_ptr;
5421                                 }
5422                         }
5423                 }
5424         }
5425         if (pSMB)
5426                 cifs_buf_release(pSMB);
5427         if (rc == -EAGAIN)
5428                 goto QEARetry;
5429
5430         return (ssize_t)rc;
5431 }
5432
5433 int
5434 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
5435              const char *ea_name, const void *ea_value,
5436              const __u16 ea_value_len, const struct nls_table *nls_codepage,
5437              int remap)
5438 {
5439         struct smb_com_transaction2_spi_req *pSMB = NULL;
5440         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5441         struct fealist *parm_data;
5442         int name_len;
5443         int rc = 0;
5444         int bytes_returned = 0;
5445         __u16 params, param_offset, byte_count, offset, count;
5446
5447         cFYI(1, ("In SetEA"));
5448 SetEARetry:
5449         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5450                       (void **) &pSMBr);
5451         if (rc)
5452                 return rc;
5453
5454         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5455                 name_len =
5456                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
5457                                      PATH_MAX, nls_codepage, remap);
5458                 name_len++;     /* trailing null */
5459                 name_len *= 2;
5460         } else {        /* BB improve the check for buffer overruns BB */
5461                 name_len = strnlen(fileName, PATH_MAX);
5462                 name_len++;     /* trailing null */
5463                 strncpy(pSMB->FileName, fileName, name_len);
5464         }
5465
5466         params = 6 + name_len;
5467
5468         /* done calculating parms using name_len of file name,
5469         now use name_len to calculate length of ea name
5470         we are going to create in the inode xattrs */
5471         if (ea_name == NULL)
5472                 name_len = 0;
5473         else
5474                 name_len = strnlen(ea_name, 255);
5475
5476         count = sizeof(*parm_data) + ea_value_len + name_len;
5477         pSMB->MaxParameterCount = cpu_to_le16(2);
5478         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
5479         pSMB->MaxSetupCount = 0;
5480         pSMB->Reserved = 0;
5481         pSMB->Flags = 0;
5482         pSMB->Timeout = 0;
5483         pSMB->Reserved2 = 0;
5484         param_offset = offsetof(struct smb_com_transaction2_spi_req,
5485                                 InformationLevel) - 4;
5486         offset = param_offset + params;
5487         pSMB->InformationLevel =
5488                 cpu_to_le16(SMB_SET_FILE_EA);
5489
5490         parm_data =
5491                 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
5492                                        offset);
5493         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5494         pSMB->DataOffset = cpu_to_le16(offset);
5495         pSMB->SetupCount = 1;
5496         pSMB->Reserved3 = 0;
5497         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5498         byte_count = 3 /* pad */  + params + count;
5499         pSMB->DataCount = cpu_to_le16(count);
5500         parm_data->list_len = cpu_to_le32(count);
5501         parm_data->list[0].EA_flags = 0;
5502         /* we checked above that name len is less than 255 */
5503         parm_data->list[0].name_len = (__u8)name_len;
5504         /* EA names are always ASCII */
5505         if (ea_name)
5506                 strncpy(parm_data->list[0].name, ea_name, name_len);
5507         parm_data->list[0].name[name_len] = 0;
5508         parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
5509         /* caller ensures that ea_value_len is less than 64K but
5510         we need to ensure that it fits within the smb */
5511
5512         /*BB add length check to see if it would fit in
5513              negotiated SMB buffer size BB */
5514         /* if (ea_value_len > buffer_size - 512 (enough for header)) */
5515         if (ea_value_len)
5516                 memcpy(parm_data->list[0].name+name_len+1,
5517                        ea_value, ea_value_len);
5518
5519         pSMB->TotalDataCount = pSMB->DataCount;
5520         pSMB->ParameterCount = cpu_to_le16(params);
5521         pSMB->TotalParameterCount = pSMB->ParameterCount;
5522         pSMB->Reserved4 = 0;
5523         pSMB->hdr.smb_buf_length += byte_count;
5524         pSMB->ByteCount = cpu_to_le16(byte_count);
5525         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5526                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5527         if (rc)
5528                 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
5529
5530         cifs_buf_release(pSMB);
5531
5532         if (rc == -EAGAIN)
5533                 goto SetEARetry;
5534
5535         return rc;
5536 }
5537
5538 #endif