fs/cifs/cifssmb.c

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