move package/linux into target/linux, use wbx' new kernel code. support building images with more than one kernel, split kernel module parts off of packages that use their own kernel modules (fuse, shfs, openswan). some cleanup in the image building process in target/. image builder is disabled for now, needs some fixing.

git-svn-id: svn://svn.openwrt.org/openwrt/trunk@1085 3c298f89-4303-0410-b956-a3cf2f4a3e73

1 files changed, 22022 insertions, 0 deletions

diff --git a/openwrt/target/linux/linux-2.4/patches/107-cifs.patch b/openwrt/target/linux/linux-2.4/patches/107-cifs.patch
new file mode 100644
index 0000000000..bdccf4de9f
--- /dev/null
+++ b/openwrt/target/linux/linux-2.4/patches/107-cifs.patch
@@ -0,0 +1,22022 @@
+diff -urN linux-2.4.29.old/Documentation/Configure.help linux-2.4.29/Documentation/Configure.help
+--- linux-2.4.29.old/Documentation/Configure.help	2005-03-21 19:30:22.000000000 +0100
++++ linux-2.4.29/Documentation/Configure.help	2005-03-21 19:36:51.000000000 +0100
+@@ -17943,6 +17943,34 @@
+ 
+   If you don't know what all this is about, say N.
+ 
++CIFS (Common Internet File System) support
++CONFIG_CIFS
++  This is the client VFS module for the Common Internet File System
++  (CIFS) protocol which is the successor to the Server Message Block 
++  (SMB) protocol, the native file sharing mechanism for most early
++  PC operating systems.  CIFS is fully supported by current network
++  file servers such as Windows 2000, Windows 2003 (including  
++  Windows XP) as well by Samba (which provides excellent CIFS
++  server support for Linux and many other operating systems).  
++  The smbfs module should be used instead of this cifs module for
++  mounting to older SMB servers such as OS/2.  The smbfs and cifs
++  modules can coexist and do not conflict.
++
++  The intent of this module is to provide the most advanced network
++  file system function for CIFS compliant servers, including better
++  POSIX compliance, secure per-user session establishment, high
++  performance safe distributed caching (oplock), optional packet
++  signing, Unicode support and other internationalization improvements
++  For more information see the project page at
++  http://us1.samba.org/samba/Linux_CIFS_client.html 
++
++CIFS Debugging
++CONFIG_CIFS_DEBUG
++  If you are experiencing any problems with the CIFS filesystem, say
++  Y here.  This will result in additional debugging messages to be
++  written to the system log.  Under normal circumstances, this
++  results in very little overhead.  
++
+ SMB file system support (to mount Windows shares etc.)
+ CONFIG_SMB_FS
+   SMB (Server Message Block) is the protocol Windows for Workgroups
+diff -urN linux-2.4.29.old/Documentation/filesystems/00-INDEX linux-2.4.29/Documentation/filesystems/00-INDEX
+--- linux-2.4.29.old/Documentation/filesystems/00-INDEX	2004-02-18 14:36:30.000000000 +0100
++++ linux-2.4.29/Documentation/filesystems/00-INDEX	2005-03-21 19:36:51.000000000 +0100
+@@ -10,6 +10,8 @@
+ 	- info for the BeOS file system (BFS)
+ bfs.txt
+ 	- info for the SCO UnixWare Boot Filesystem (BFS).
++cifs.txt
++	- info on the Common Internet File System (CIFS)
+ coda.txt
+ 	- description of the CODA filesystem.
+ cramfs.txt
+diff -urN linux-2.4.29.old/Documentation/filesystems/cifs.txt linux-2.4.29/Documentation/filesystems/cifs.txt
+--- linux-2.4.29.old/Documentation/filesystems/cifs.txt	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/Documentation/filesystems/cifs.txt	2005-03-21 19:36:51.000000000 +0100
+@@ -0,0 +1,51 @@
++  This is the client VFS module for the Common Internet File System
++  (CIFS) protocol which is the successor to the Server Message Block 
++  (SMB) protocol, the native file sharing mechanism for most early
++  PC operating systems.  CIFS is fully supported by current network
++  file servers such as Windows 2000, Windows 2003 (including  
++  Windows XP) as well by Samba (which provides excellent CIFS
++  server support for Linux and many other operating systems), so
++  this network filesystem client can mount to a wide variety of
++  servers.  The smbfs module should be used instead of this cifs module
++  for mounting to older SMB servers such as OS/2.  The smbfs and cifs
++  modules can coexist and do not conflict.  The CIFS VFS filesystem
++  module is designed to work well with servers that implement the
++  newer versions (dialects) of the SMB/CIFS protocol such as Samba, 
++  the program written by Andrew Tridgell that turns any Unix host 
++  into a SMB/CIFS file server.
++
++  The intent of this module is to provide the most advanced network
++  file system function for CIFS compliant servers, including better
++  POSIX compliance, secure per-user session establishment, high
++  performance safe distributed caching (oplock), optional packet
++  signing, large files, Unicode support and other internationalization
++  improvements. Since both Samba server and this filesystem client support
++  the CIFS Unix extensions, the combination can provide a reasonable 
++  alternative to NFSv4 for fileserving in some Linux to Linux environments,
++  not just in Linux to Windows environments.
++
++  This filesystem has an optional mount utility (mount.cifs) that can
++  be obtained from the project page and installed in the path in the same
++  directory with the other mount helpers (such as mount.smbfs). 
++  Mounting using the cifs filesystem without installing the mount helper
++  requires specifying the server's ip address.
++
++  For Linux 2.4:
++    mount //anything/here /mnt_target -o
++            user=username,pass=password,unc=//ip_address_of_server/sharename
++
++  For Linux 2.5: 
++    mount //ip_address_of_server/sharename /mnt_target -o user=username, pass=password
++
++
++  For more information on the module see the project page at
++
++      http://us1.samba.org/samba/Linux_CIFS_client.html 
++
++  For more information on CIFS see:
++
++      http://www.snia.org/tech_activities/CIFS
++
++  or the Samba site:
++     
++      http://www.samba.org
+diff -urN linux-2.4.29.old/fs/cifs/asn1.c linux-2.4.29/fs/cifs/asn1.c
+--- linux-2.4.29.old/fs/cifs/asn1.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/asn1.c	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,614 @@
++/* 
++ * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in
++ * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich
++ *      
++ * Copyright (c) 2000 RP Internet (www.rpi.net.au).
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/types.h>
++#include <linux/kernel.h>
++#include <linux/mm.h>
++#include <linux/slab.h>
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifs_debug.h"
++
++/*****************************************************************************
++ *
++ * Basic ASN.1 decoding routines (gxsnmp author Dirk Wisse)
++ *
++ *****************************************************************************/
++
++/* Class */
++#define ASN1_UNI	0	/* Universal */
++#define ASN1_APL	1	/* Application */
++#define ASN1_CTX	2	/* Context */
++#define ASN1_PRV	3	/* Private */
++
++/* Tag */
++#define ASN1_EOC	0	/* End Of Contents or N/A */
++#define ASN1_BOL	1	/* Boolean */
++#define ASN1_INT	2	/* Integer */
++#define ASN1_BTS	3	/* Bit String */
++#define ASN1_OTS	4	/* Octet String */
++#define ASN1_NUL	5	/* Null */
++#define ASN1_OJI	6	/* Object Identifier  */
++#define ASN1_OJD	7	/* Object Description */
++#define ASN1_EXT	8	/* External */
++#define ASN1_SEQ	16	/* Sequence */
++#define ASN1_SET	17	/* Set */
++#define ASN1_NUMSTR	18	/* Numerical String */
++#define ASN1_PRNSTR	19	/* Printable String */
++#define ASN1_TEXSTR	20	/* Teletext String */
++#define ASN1_VIDSTR	21	/* Video String */
++#define ASN1_IA5STR	22	/* IA5 String */
++#define ASN1_UNITIM	23	/* Universal Time */
++#define ASN1_GENTIM	24	/* General Time */
++#define ASN1_GRASTR	25	/* Graphical String */
++#define ASN1_VISSTR	26	/* Visible String */
++#define ASN1_GENSTR	27	/* General String */
++
++/* Primitive / Constructed methods*/
++#define ASN1_PRI	0	/* Primitive */
++#define ASN1_CON	1	/* Constructed */
++
++/*
++ * Error codes.
++ */
++#define ASN1_ERR_NOERROR		0
++#define ASN1_ERR_DEC_EMPTY		2
++#define ASN1_ERR_DEC_EOC_MISMATCH	3
++#define ASN1_ERR_DEC_LENGTH_MISMATCH	4
++#define ASN1_ERR_DEC_BADVALUE		5
++
++#define SPNEGO_OID_LEN 7
++#define NTLMSSP_OID_LEN  10
++unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 };
++unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 };
++
++/* 
++ * ASN.1 context.
++ */
++struct asn1_ctx {
++	int error;		/* Error condition */
++	unsigned char *pointer;	/* Octet just to be decoded */
++	unsigned char *begin;	/* First octet */
++	unsigned char *end;	/* Octet after last octet */
++};
++
++/*
++ * Octet string (not null terminated)
++ */
++struct asn1_octstr {
++	unsigned char *data;
++	unsigned int len;
++};
++
++static void
++asn1_open(struct asn1_ctx *ctx, unsigned char *buf, unsigned int len)
++{
++	ctx->begin = buf;
++	ctx->end = buf + len;
++	ctx->pointer = buf;
++	ctx->error = ASN1_ERR_NOERROR;
++}
++
++static unsigned char
++asn1_octet_decode(struct asn1_ctx *ctx, unsigned char *ch)
++{
++	if (ctx->pointer >= ctx->end) {
++		ctx->error = ASN1_ERR_DEC_EMPTY;
++		return 0;
++	}
++	*ch = *(ctx->pointer)++;
++	return 1;
++}
++
++static unsigned char
++asn1_tag_decode(struct asn1_ctx *ctx, unsigned int *tag)
++{
++	unsigned char ch;
++
++	*tag = 0;
++
++	do {
++		if (!asn1_octet_decode(ctx, &ch))
++			return 0;
++		*tag <<= 7;
++		*tag |= ch & 0x7F;
++	} while ((ch & 0x80) == 0x80);
++	return 1;
++}
++
++static unsigned char
++asn1_id_decode(struct asn1_ctx *ctx,
++	       unsigned int *cls, unsigned int *con, unsigned int *tag)
++{
++	unsigned char ch;
++
++	if (!asn1_octet_decode(ctx, &ch))
++		return 0;
++
++	*cls = (ch & 0xC0) >> 6;
++	*con = (ch & 0x20) >> 5;
++	*tag = (ch & 0x1F);
++
++	if (*tag == 0x1F) {
++		if (!asn1_tag_decode(ctx, tag))
++			return 0;
++	}
++	return 1;
++}
++
++static unsigned char
++asn1_length_decode(struct asn1_ctx *ctx, unsigned int *def, unsigned int *len)
++{
++	unsigned char ch, cnt;
++
++	if (!asn1_octet_decode(ctx, &ch))
++		return 0;
++
++	if (ch == 0x80)
++		*def = 0;
++	else {
++		*def = 1;
++
++		if (ch < 0x80)
++			*len = ch;
++		else {
++			cnt = (unsigned char) (ch & 0x7F);
++			*len = 0;
++
++			while (cnt > 0) {
++				if (!asn1_octet_decode(ctx, &ch))
++					return 0;
++				*len <<= 8;
++				*len |= ch;
++				cnt--;
++			}
++		}
++	}
++	return 1;
++}
++
++static unsigned char
++asn1_header_decode(struct asn1_ctx *ctx,
++		   unsigned char **eoc,
++		   unsigned int *cls, unsigned int *con, unsigned int *tag)
++{
++	unsigned int def, len;
++
++	if (!asn1_id_decode(ctx, cls, con, tag))
++		return 0;
++
++	if (!asn1_length_decode(ctx, &def, &len))
++		return 0;
++
++	if (def)
++		*eoc = ctx->pointer + len;
++	else
++		*eoc = NULL;
++	return 1;
++}
++
++static unsigned char
++asn1_eoc_decode(struct asn1_ctx *ctx, unsigned char *eoc)
++{
++	unsigned char ch;
++
++	if (eoc == 0) {
++		if (!asn1_octet_decode(ctx, &ch))
++			return 0;
++
++		if (ch != 0x00) {
++			ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
++			return 0;
++		}
++
++		if (!asn1_octet_decode(ctx, &ch))
++			return 0;
++
++		if (ch != 0x00) {
++			ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
++			return 0;
++		}
++		return 1;
++	} else {
++		if (ctx->pointer != eoc) {
++			ctx->error = ASN1_ERR_DEC_LENGTH_MISMATCH;
++			return 0;
++		}
++		return 1;
++	}
++}
++
++/* static unsigned char asn1_null_decode(struct asn1_ctx *ctx,
++				      unsigned char *eoc)
++{
++	ctx->pointer = eoc;
++	return 1;
++}
++
++static unsigned char asn1_long_decode(struct asn1_ctx *ctx,
++				      unsigned char *eoc, long *integer)
++{
++	unsigned char ch;
++	unsigned int len;
++
++	if (!asn1_octet_decode(ctx, &ch))
++		return 0;
++
++	*integer = (signed char) ch;
++	len = 1;
++
++	while (ctx->pointer < eoc) {
++		if (++len > sizeof(long)) {
++			ctx->error = ASN1_ERR_DEC_BADVALUE;
++			return 0;
++		}
++
++		if (!asn1_octet_decode(ctx, &ch))
++			return 0;
++
++		*integer <<= 8;
++		*integer |= ch;
++	}
++	return 1;
++}
++
++static unsigned char asn1_uint_decode(struct asn1_ctx *ctx,
++				      unsigned char *eoc,
++				      unsigned int *integer)
++{
++	unsigned char ch;
++	unsigned int len;
++
++	if (!asn1_octet_decode(ctx, &ch))
++		return 0;
++
++	*integer = ch;
++	if (ch == 0)
++		len = 0;
++	else
++		len = 1;
++
++	while (ctx->pointer < eoc) {
++		if (++len > sizeof(unsigned int)) {
++			ctx->error = ASN1_ERR_DEC_BADVALUE;
++			return 0;
++		}
++
++		if (!asn1_octet_decode(ctx, &ch))
++			return 0;
++
++		*integer <<= 8;
++		*integer |= ch;
++	}
++	return 1;
++}
++
++static unsigned char asn1_ulong_decode(struct asn1_ctx *ctx,
++				       unsigned char *eoc,
++				       unsigned long *integer)
++{
++	unsigned char ch;
++	unsigned int len;
++
++	if (!asn1_octet_decode(ctx, &ch))
++		return 0;
++
++	*integer = ch;
++	if (ch == 0)
++		len = 0;
++	else
++		len = 1;
++
++	while (ctx->pointer < eoc) {
++		if (++len > sizeof(unsigned long)) {
++			ctx->error = ASN1_ERR_DEC_BADVALUE;
++			return 0;
++		}
++
++		if (!asn1_octet_decode(ctx, &ch))
++			return 0;
++
++		*integer <<= 8;
++		*integer |= ch;
++	}
++	return 1;
++} 
++
++static unsigned char
++asn1_octets_decode(struct asn1_ctx *ctx,
++		   unsigned char *eoc,
++		   unsigned char **octets, unsigned int *len)
++{
++	unsigned char *ptr;
++
++	*len = 0;
++
++	*octets = kmalloc(eoc - ctx->pointer, GFP_ATOMIC);
++	if (*octets == NULL) {
++		return 0;
++	}
++
++	ptr = *octets;
++	while (ctx->pointer < eoc) {
++		if (!asn1_octet_decode(ctx, (unsigned char *) ptr++)) {
++			kfree(*octets);
++			*octets = NULL;
++			return 0;
++		}
++		(*len)++;
++	}
++	return 1;
++} */
++
++static unsigned char
++asn1_subid_decode(struct asn1_ctx *ctx, unsigned long *subid)
++{
++	unsigned char ch;
++
++	*subid = 0;
++
++	do {
++		if (!asn1_octet_decode(ctx, &ch))
++			return 0;
++
++		*subid <<= 7;
++		*subid |= ch & 0x7F;
++	} while ((ch & 0x80) == 0x80);
++	return 1;
++}
++
++static unsigned char
++asn1_oid_decode(struct asn1_ctx *ctx,
++		unsigned char *eoc, unsigned long **oid, unsigned int *len)
++{
++	unsigned long subid;
++	unsigned int size;
++	unsigned long *optr;
++
++	size = eoc - ctx->pointer + 1;
++	*oid = kmalloc(size * sizeof (unsigned long), GFP_ATOMIC);
++	if (*oid == NULL) {
++		return 0;
++	}
++
++	optr = *oid;
++
++	if (!asn1_subid_decode(ctx, &subid)) {
++		kfree(*oid);
++		*oid = NULL;
++		return 0;
++	}
++
++	if (subid < 40) {
++		optr[0] = 0;
++		optr[1] = subid;
++	} else if (subid < 80) {
++		optr[0] = 1;
++		optr[1] = subid - 40;
++	} else {
++		optr[0] = 2;
++		optr[1] = subid - 80;
++	}
++
++	*len = 2;
++	optr += 2;
++
++	while (ctx->pointer < eoc) {
++		if (++(*len) > size) {
++			ctx->error = ASN1_ERR_DEC_BADVALUE;
++			kfree(*oid);
++			*oid = NULL;
++			return 0;
++		}
++
++		if (!asn1_subid_decode(ctx, optr++)) {
++			kfree(*oid);
++			*oid = NULL;
++			return 0;
++		}
++	}
++	return 1;
++}
++
++static int
++compare_oid(unsigned long *oid1, unsigned int oid1len,
++	    unsigned long *oid2, unsigned int oid2len)
++{
++	unsigned int i;
++
++	if (oid1len != oid2len)
++		return 0;
++	else {
++		for (i = 0; i < oid1len; i++) {
++			if (oid1[i] != oid2[i])
++				return 0;
++		}
++		return 1;
++	}
++}
++
++	/* BB check for endian conversion issues here */
++
++int
++decode_negTokenInit(unsigned char *security_blob, int length,
++		    enum securityEnum *secType)
++{
++	struct asn1_ctx ctx;
++	unsigned char *end;
++	unsigned char *sequence_end;
++	unsigned long *oid;
++	unsigned int cls, con, tag, oidlen, rc;
++	int use_ntlmssp = FALSE;
++
++    *secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default */
++
++	/* cifs_dump_mem(" Received SecBlob ", security_blob, length); */
++
++	asn1_open(&ctx, security_blob, length);
++
++	if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++		cFYI(1, ("Error decoding negTokenInit header "));
++		return 0;
++	} else if ((cls != ASN1_APL) || (con != ASN1_CON)
++		   || (tag != ASN1_EOC)) {
++		cFYI(1, ("cls = %d con = %d tag = %d", cls, con, tag));
++		return 0;
++	} else {
++		/*      remember to free obj->oid */
++		rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
++		if (rc) {
++			if ((tag == ASN1_OJI) && (cls == ASN1_PRI)) {
++				rc = asn1_oid_decode(&ctx, end, &oid, &oidlen);
++				if (rc) {
++					rc = compare_oid(oid, oidlen,
++							 SPNEGO_OID,
++							 SPNEGO_OID_LEN);
++					kfree(oid);
++				}
++			} else
++				rc = 0;
++		}
++
++		if (!rc) {
++			cFYI(1, ("Error decoding negTokenInit header"));
++			return 0;
++		}
++
++		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++			cFYI(1, ("Error decoding negTokenInit "));
++			return 0;
++		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)
++			   || (tag != ASN1_EOC)) {
++			cFYI(1,("cls = %d con = %d tag = %d end = %p (%d) exit 0",
++			      cls, con, tag, end, *end));
++			return 0;
++		}
++
++		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++			cFYI(1, ("Error decoding negTokenInit "));
++			return 0;
++		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
++			   || (tag != ASN1_SEQ)) {
++			cFYI(1,("cls = %d con = %d tag = %d end = %p (%d) exit 1",
++			      cls, con, tag, end, *end));
++			return 0;
++		}
++
++		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++			cFYI(1, ("Error decoding 2nd part of negTokenInit "));
++			return 0;
++		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)
++			   || (tag != ASN1_EOC)) {
++			cFYI(1,
++			     ("cls = %d con = %d tag = %d end = %p (%d) exit 0",
++			      cls, con, tag, end, *end));
++			return 0;
++		}
++
++		if (asn1_header_decode
++		    (&ctx, &sequence_end, &cls, &con, &tag) == 0) {
++			cFYI(1, ("Error decoding 2nd part of negTokenInit "));
++			return 0;
++		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
++			   || (tag != ASN1_SEQ)) {
++			cFYI(1,
++			     ("cls = %d con = %d tag = %d end = %p (%d) exit 1",
++			      cls, con, tag, end, *end));
++			return 0;
++		}
++
++		while (!asn1_eoc_decode(&ctx, sequence_end)) {
++			rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
++			if (!rc) {
++				cFYI(1,
++				     ("Error 1 decoding negTokenInit header exit 2"));
++				return 0;
++			}
++			if ((tag == ASN1_OJI) && (con == ASN1_PRI)) {
++				asn1_oid_decode(&ctx, end, &oid, &oidlen);
++				cFYI(1,
++				     ("OID len = %d oid = 0x%lx 0x%lx 0x%lx 0x%lx",
++				      oidlen, *oid, *(oid + 1), *(oid + 2),
++				      *(oid + 3)));
++				rc = compare_oid(oid, oidlen, NTLMSSP_OID,
++						 NTLMSSP_OID_LEN);
++				kfree(oid);
++				if (rc)
++					use_ntlmssp = TRUE;
++			} else {
++				cFYI(1,("This should be an oid what is going on? "));
++			}
++		}
++
++		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++			cFYI(1,
++			     ("Error decoding last part of negTokenInit exit 3"));
++			return 0;
++		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {	/* tag = 3 indicating mechListMIC */
++			cFYI(1,
++			     ("Exit 4 cls = %d con = %d tag = %d end = %p (%d)",
++			      cls, con, tag, end, *end));
++			return 0;
++		}
++		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++			cFYI(1,
++			     ("Error decoding last part of negTokenInit exit 5"));
++			return 0;
++		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
++			   || (tag != ASN1_SEQ)) {
++			cFYI(1,
++			     ("Exit 6 cls = %d con = %d tag = %d end = %p (%d)",
++			      cls, con, tag, end, *end));
++		}
++
++		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++			cFYI(1,
++			     ("Error decoding last part of negTokenInit exit 7"));
++			return 0;
++		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {
++			cFYI(1,
++			     ("Exit 8 cls = %d con = %d tag = %d end = %p (%d)",
++			      cls, con, tag, end, *end));
++			return 0;
++		}
++		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
++			cFYI(1,
++			     ("Error decoding last part of negTokenInit exit 9"));
++			return 0;
++		} else if ((cls != ASN1_UNI) || (con != ASN1_PRI)
++			   || (tag != ASN1_GENSTR)) {
++			cFYI(1,
++			     ("Exit 10 cls = %d con = %d tag = %d end = %p (%d)",
++			      cls, con, tag, end, *end));
++			return 0;
++		}
++		cFYI(1, ("Need to call asn1_octets_decode() function for this %s", ctx.pointer));	/* is this UTF-8 or ASCII? */
++	}
++
++	/* if (use_kerberos) 
++	   *secType = Kerberos 
++	   else */
++	if (use_ntlmssp) {
++		*secType = NTLMSSP;
++	}
++
++	return 1;
++}
+diff -urN linux-2.4.29.old/fs/cifs/AUTHORS linux-2.4.29/fs/cifs/AUTHORS
+--- linux-2.4.29.old/fs/cifs/AUTHORS	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/AUTHORS	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,37 @@
++Original Author
++===============
++Steve French (sfrench@samba.org)
++
++The author wishes to express his appreciation and thanks to:
++Andrew Tridgell (Samba team) for his early suggestions about smb/cifs VFS
++improvements. Thanks to IBM for allowing me the time and test resources to pursue
++this project. Jim McDonough from IBM (and the Samba Team) for his help.
++The IBM Linux JFS team for explaining many esoteric Linux filesystem features.
++Dave Boutcher of IBM Rochester (author of the OS/400 smb/cifs filesystem client)
++for proving years ago that a very good smb/cifs client could be done on a Unix like 
++operating system.  Volker Lendecke, Andrew Tridgell, Urban Widmark, John Newbigin 
++and others for their work on the Linux smbfs module over the years. Thanks to
++the other members of the Storage Network Industry Association CIFS Technical
++Workgroup for their work specifying this highly complex protocol and finally
++thanks to the Samba team for their technical advice and encouragement.
++
++Patch Contributors
++------------------
++Zwane Mwaikambo
++Andi Kleen
++Amrut Joshi
++Shobhit Dayal
++Sergey Vlasov
++Richard Hughes
++Yury Umanets
++
++Test case and Bug Report contributors
++-------------------------------------
++Thanks to those in the community who have submitted detailed bug reports
++and debug of problems they have found:  Jochen Dolze, David Blaine,
++Rene Scharfe, Martin Josefsson, Alexander Wild, Anthony Liguori,
++Lars Muller, Urban Widmark, Massimiliano Ferrero, Howard Owen,
++Olaf Kirch, Kieron Briggs, Nick Millington and others. 
++
++And thanks to the IBM LTC and Power test teams and SuSE testers for
++finding multiple bugs during excellent stress test runs.
+diff -urN linux-2.4.29.old/fs/cifs/CHANGES linux-2.4.29/fs/cifs/CHANGES
+--- linux-2.4.29.old/fs/cifs/CHANGES	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/CHANGES	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,572 @@
++Version 1.20
++------------
++Make transaction counts more consistent. Merge /proc/fs/cifs/SimultaneousOps
++info into /proc/fs/cifs/DebugData.  Fix oops in rare oops in readdir 
++(in build_wildcard_path_from_dentry).  Fix mknod to pass type field
++(block/char/fifo) properly.  Remove spurious mount warning log entry when
++credentials passed as mount argument. Set major/minor device number in
++inode for block and char devices when unix extensions enabled.
++
++Version 1.19
++------------
++Fix /proc/fs/cifs/Stats and DebugData display to handle larger
++amounts of return data. Properly limit requests to MAX_REQ (50
++is the usual maximum active multiplex SMB/CIFS requests per server).
++Do not kill cifsd (and thus hurt the other SMB session) when more than one
++session to the same server (but with different userids) exists and one
++of the two user's smb sessions is being removed while leaving the other.
++Do not loop reconnecting in cifsd demultiplex thread when admin
++kills the thread without going through unmount.
++
++Version 1.18
++------------
++Do not rename hardlinked files (since that should be a noop). Flush
++cached write behind data when reopening a file after session abend,
++except when already in write. Grab per socket sem during reconnect 
++to avoid oops in sendmsg if overlapping with reconnect. Do not
++reset cached inode file size on readdir for files open for write on 
++client.
++
++
++Version 1.17
++------------
++Update number of blocks in file so du command is happier (in Linux a fake
++blocksize of 512 is required for calculating number of blocks in inode).
++Fix prepare write of partial pages to read in data from server if possible.
++Fix race on tcpStatus field between unmount and reconnection code, causing
++cifsd process sometimes to hang around forever. Improve out of memory
++checks in cifs_filldir
++
++Version 1.16
++------------
++Fix incorrect file size in file handle based setattr on big endian hardware.
++Fix oops in build_path_from_dentry when out of memory.  Add checks for invalid
++and closing file structs in writepage/partialpagewrite.  Add statistics
++for each mounted share (new menuconfig option). Fix endianness problem in
++volume information displayed in /proc/fs/cifs/DebugData (only affects
++affects big endian architectures). Prevent renames while constructing
++path names for open, mkdir and rmdir.
++
++Version 1.15
++------------
++Change to mempools for alloc smb request buffers and multiplex structs
++to better handle low memory problems (and potential deadlocks).
++
++Version 1.14
++------------
++Fix incomplete listings of large directories on Samba servers when Unix
++extensions enabled.  Fix oops when smb_buffer can not be allocated. Fix
++rename deadlock when writing out dirty pages at same time.
++
++Version 1.13
++------------
++Fix open of files in which O_CREATE can cause the mode to change in
++some cases. Fix case in which retry of write overlaps file close.
++Fix PPC64 build error.  Reduce excessive stack usage in smb password
++hashing. Fix overwrite of Linux user's view of file mode to Windows servers.
++
++Version 1.12
++------------
++Fixes for large file copy, signal handling, socket retry, buffer
++allocation and low memory situations.
++
++Version 1.11
++------------
++Better port 139 support to Windows servers (RFC1001/RFC1002 Session_Initialize)
++also now allowing support for specifying client netbiosname.  NT4 support added.
++
++Version 1.10
++------------
++Fix reconnection (and certain failed mounts) to properly wake up the
++blocked users thread so it does not seem hung (in some cases was blocked
++until the cifs receive timeout expired). Fix spurious error logging
++to kernel log when application with open network files killed. 
++
++Version 1.09
++------------
++Fix /proc/fs module unload warning message (that could be logged
++to the kernel log). Fix intermittent failure in connectathon
++test7 (hardlink count not immediately refreshed in case in which
++inode metadata can be incorrectly kept cached when time near zero)
++
++Version 1.08
++------------
++Allow file_mode and dir_mode (specified at mount time) to be enforced
++locally (the server already enforced its own ACLs too) for servers
++that do not report the correct mode (do not support the 
++CIFS Unix Extensions).
++
++Version 1.07
++------------
++Fix some small memory leaks in some unmount error paths. Fix major leak
++of cache pages in readpages causing multiple read oriented stress
++testcases (including fsx, and even large file copy) to fail over time. 
++
++Version 1.06
++------------
++Send NTCreateX with ATTR_POSIX if Linux/Unix extensions negotiated with server.
++This allows files that differ only in case and improves performance of file
++creation and file open to such servers.  Fix semaphore conflict which causes 
++slow delete of open file to Samba (which unfortunately can cause an oplock
++break to self while vfs_unlink held i_sem) which can hang for 20 seconds.
++
++Version 1.05
++------------
++fixes to cifs_readpages for fsx test case
++
++Version 1.04
++------------
++Fix caching data integrity bug when extending file size especially when no
++oplock on file.  Fix spurious logging of valid already parsed mount options
++that are parsed outside of the cifs vfs such as nosuid.
++
++
++Version 1.03
++------------
++Connect to server when port number override not specified, and tcp port
++unitialized.  Reset search to restart at correct file when kernel routine
++filldir returns error during large directory searches (readdir). 
++
++Version 1.02
++------------
++Fix caching problem when files opened by multiple clients in which 
++page cache could contain stale data, and write through did
++not occur often enough while file was still open when read ahead
++(read oplock) not allowed.  Treat "sep=" when first mount option
++as an overrride of comma as the default separator between mount
++options. 
++
++Version 1.01
++------------
++Allow passwords longer than 16 bytes. Allow null password string.
++
++Version 1.00
++------------
++Gracefully clean up failed mounts when attempting to mount to servers such as
++Windows 98 that terminate tcp sessions during prototocol negotiation.  Handle
++embedded commas in mount parsing of passwords.
++
++Version 0.99
++------------
++Invalidate local inode cached pages on oplock break and when last file
++instance is closed so that the client does not continue using stale local
++copy rather than later modified server copy of file.  Do not reconnect
++when server drops the tcp session prematurely before negotiate
++protocol response.  Fix oops in roepen_file when dentry freed.  Allow
++the support for CIFS Unix Extensions to be disabled via proc interface.
++
++Version 0.98
++------------
++Fix hang in commit_write during reconnection of open files under heavy load.
++Fix unload_nls oops in a mount failure path. Serialize writes to same socket
++which also fixes any possible races when cifs signatures are enabled in SMBs
++being sent out of signature sequence number order.    
++
++Version 0.97
++------------
++Fix byte range locking bug (endian problem) causing bad offset and
++length.
++
++Version 0.96
++------------
++Fix oops (in send_sig) caused by CIFS unmount code trying to
++wake up the demultiplex thread after it had exited. Do not log
++error on harmless oplock release of closed handle.
++
++Version 0.95
++------------
++Fix unsafe global variable usage and password hash failure on gcc 3.3.1
++Fix problem reconnecting secondary mounts to same server after session 
++failure.  Fix invalid dentry - race in mkdir when directory gets created
++by another client between the lookup and mkdir.
++ 
++Version 0.94
++------------
++Fix to list processing in reopen_files. Fix reconnection when server hung
++but tcpip session still alive.  Set proper timeout on socket read.
++
++Version 0.93
++------------
++Add missing mount options including iocharset.  SMP fixes in write and open. 
++Fix errors in reconnecting after TCP session failure.  Fix module unloading
++of default nls codepage
++
++Version 0.92
++------------
++Active smb transactions should never go negative (fix double FreeXid). Fix
++list processing in file routines. Check return code on kmalloc in open.
++Fix spinlock usage for SMP.
++
++Version 0.91
++------------
++Fix oops in reopen_files when invalid dentry. drop dentry on server rename 
++and on revalidate errors. Fix cases where pid is now tgid.  Fix return code
++on create hard link when server does not support them. 
++
++Version 0.90
++------------
++Fix scheduling while atomic error in getting inode info on newly created file. 
++Fix truncate of existing files opened with O_CREAT but not O_TRUNC set.
++
++Version 0.89
++------------
++Fix oops on write to dead tcp session. Remove error log write for case when file open
++O_CREAT but not O_EXCL
++
++Version 0.88
++------------
++Fix non-POSIX behavior on rename of open file and delete of open file by taking 
++advantage of trans2 SetFileInfo rename facility if available on target server.
++Retry on ENOSPC and EAGAIN socket errors.
++
++Version 0.87
++------------
++Fix oops on big endian readdir.  Set blksize to be even power of two (2**blkbits) to fix
++allocation size miscalculation. After oplock token lost do not read through
++cache. 
++
++Version 0.86
++------------
++Fix oops on empty file readahead.  Fix for file size handling for locally cached files.
++
++Version 0.85
++------------
++Fix oops in mkdir when server fails to return inode info. Fix oops in reopen_files
++during auto reconnection to server after server recovered from failure.
++
++Version 0.84
++------------
++Finish support for Linux 2.5 open/create changes, which removes the
++redundant NTCreate/QPathInfo/close that was sent during file create.
++Enable oplock by default. Enable packet signing by default (needed to 
++access many recent Windows servers)
++
++Version 0.83
++------------
++Fix oops when mounting to long server names caused by inverted parms to kmalloc.
++Fix MultiuserMount (/proc/fs/cifs configuration setting) so that when enabled
++we will choose a cifs user session (smb uid) that better matches the local
++uid if a) the mount uid does not match the current uid and b) we have another
++session to the same server (ip address) for a different mount which
++matches the current local uid.
++
++Version 0.82
++------------
++Add support for mknod of block or character devices.  Fix oplock
++code (distributed caching) to properly send response to oplock
++break from server.
++
++Version 0.81
++------------
++Finish up CIFS packet digital signing for the default
++NTLM security case. This should help Windows 2003
++network interoperability since it is common for
++packet signing to be required now. Fix statfs (stat -f)
++which recently started returning errors due to 
++invalid value (-1 instead of 0) being set in the
++struct kstatfs f_ffiles field.
++
++Version 0.80
++-----------
++Fix oops on stopping oplock thread when removing cifs when
++built as module.
++
++Version 0.79
++------------
++Fix mount options for ro (readonly), uid, gid and file and directory mode. 
++
++Version 0.78
++------------
++Fix errors displayed on failed mounts to be more understandable.
++Fixed various incorrect or misleading smb to posix error code mappings.
++
++Version 0.77
++------------
++Fix display of NTFS DFS junctions to display as symlinks.
++They are the network equivalent.  Fix oops in 
++cifs_partialpagewrite caused by missing spinlock protection
++of openfile linked list.  Allow writebehind caching errors to 
++be returned to the application at file close.
++
++Version 0.76
++------------
++Clean up options displayed in /proc/mounts by show_options to
++be more consistent with other filesystems.
++
++Version 0.75
++------------
++Fix delete of readonly file to Windows servers.  Reflect
++presence or absence of read only dos attribute in mode
++bits for servers that do not support CIFS Unix extensions.
++Fix shortened results on readdir of large directories to
++servers supporting CIFS Unix extensions (caused by
++incorrect resume key).
++
++Version 0.74
++------------
++Fix truncate bug (set file size) that could cause hangs e.g. running fsx
++
++Version 0.73
++------------
++unload nls if mount fails.
++
++Version 0.72
++------------
++Add resume key support to search (readdir) code to workaround
++Windows bug.  Add /proc/fs/cifs/LookupCacheEnable which
++allows disabling caching of attribute information for
++lookups.
++
++Version 0.71
++------------
++Add more oplock handling (distributed caching code).  Remove
++dead code.  Remove excessive stack space utilization from
++symlink routines.
++
++Version 0.70
++------------
++Fix oops in get dfs referral (triggered when null path sent in to
++mount).  Add support for overriding rsize at mount time.
++
++Version 0.69
++------------
++Fix buffer overrun in readdir which caused intermittent kernel oopses.
++Fix writepage code to release kmap on write data.  Allow "-ip=" new 
++mount option to be passed in on parameter distinct from the first part
++(server name portion of) the UNC name.  Allow override of the
++tcp port of the target server via new mount option "-port="  
++
++Version 0.68
++------------
++Fix search handle leak on rewind.  Fix setuid and gid so that they are 
++reflected in the local inode immediately.  Cleanup of whitespace
++to make 2.4 and 2.5 versions more consistent.
++
++
++Version 0.67
++------------
++Fix signal sending so that captive thread (cifsd) exits on umount 
++(which was causing the warning in kmem_cache_free of the request buffers
++at rmmod time).  This had broken as a sideeffect of the recent global
++kernel change to daemonize.  Fix memory leak in readdir code which
++showed up in "ls -R" (and applications that did search rewinding).
++
++Version 0.66
++------------
++Reconnect tids and fids after session reconnection (still do not
++reconnect byte range locks though).  Fix problem caching
++lookup information for directory inodes, improving performance,
++especially in deep directory trees.  Fix various build warnings.
++
++Version 0.65
++------------
++Finish fixes to commit write for caching/readahead consistency.  fsx 
++now works to Samba servers.  Fix oops caused when readahead
++was interrupted by a signal.
++
++Version 0.64
++------------
++Fix data corruption (in partial page after truncate) that caused fsx to
++fail to Windows servers.  Cleaned up some extraneous error logging in
++common error paths.  Add generic sendfile support.
++
++Version 0.63
++------------
++Fix memory leak in AllocMidQEntry.
++Finish reconnection logic, so connection with server can be dropped
++(or server rebooted) and the cifs client will reconnect.  
++
++Version 0.62
++------------
++Fix temporary socket leak when bad userid or password specified 
++(or other SMBSessSetup failure).  Increase maximum buffer size to slightly
++over 16K to allow negotiation of up to Samba and Windows server default read 
++sizes.  Add support for readpages
++
++Version 0.61
++------------
++Fix oops when username not passed in on mount.  Extensive fixes and improvements
++to error logging (strip redundant newlines, change debug macros to ensure newline
++passed in and to be more consistent).  Fix writepage wrong file handle problem,
++a readonly file handle could be incorrectly used to attempt to write out
++file updates through the page cache to multiply open files.  This could cause
++the iozone benchmark to fail on the fwrite test. Fix bug mounting two different
++shares to the same Windows server when using different usernames
++(doing this to Samba servers worked but Windows was rejecting it) - now it is
++possible to use different userids when connecting to the same server from a
++Linux client. Fix oops when treeDisconnect called during unmount on
++previously freed socket.
++
++Version 0.60
++------------
++Fix oops in readpages caused by not setting address space operations in inode in 
++rare code path. 
++
++Version 0.59
++------------
++Includes support for deleting of open files and renaming over existing files (per POSIX
++requirement).  Add readlink support for Windows junction points (directory symlinks).
++
++Version 0.58
++------------
++Changed read and write to go through pagecache. Added additional address space operations.
++Memory mapped operations now working.
++
++Version 0.57
++------------
++Added writepage code for additional memory mapping support.  Fixed leak in xids causing
++the simultaneous operations counter (/proc/fs/cifs/SimultaneousOps) to increase on 
++every stat call.  Additional formatting cleanup. 
++
++Version 0.56
++------------
++Fix bigendian bug in order of time conversion. Merge 2.5 to 2.4 version.  Formatting cleanup.   
++
++Version 0.55
++------------
++Fixes from Zwane Mwaikambo for adding missing return code checking in a few places.
++Also included a modified version of his fix to protect global list manipulation of
++the smb session and tree connection and mid related global variables.
++
++Version 0.54
++------------
++Fix problem with captive thread hanging around at unmount time.  Adjust to 2.5.42-pre
++changes to superblock layout.   Remove wasteful allocation of smb buffers (now the send 
++buffer is reused for responses).  Add more oplock handling. Additional minor cleanup.
++
++Version 0.53
++------------
++More stylistic updates to better match kernel style.  Add additional statistics
++for filesystem which can be viewed via /proc/fs/cifs.  Add more pieces of NTLMv2
++and CIFS Packet Signing enablement.
++
++Version 0.52
++------------
++Replace call to sleep_on with safer wait_on_event.
++Make stylistic changes to better match kernel style recommendations.
++Remove most typedef usage (except for the PDUs themselves).
++
++Version 0.51
++------------
++Update mount so the -unc mount option is no longer required (the ip address can be specified
++in a UNC style device name.   Implementation of readpage/writepage started.
++
++Version 0.50
++------------
++Fix intermittent problem with incorrect smb header checking on badly 
++fragmented tcp responses
++
++Version 0.49
++------------
++Fixes to setting of allocation size and file size.
++
++Version 0.48
++------------
++Various 2.5.38 fixes.  Now works on 2.5.38
++
++Version 0.47
++------------
++Prepare for 2.5 kernel merge.  Remove ifdefs.
++
++Version 0.46
++------------
++Socket buffer management fixes.  Fix dual free.
++
++Version 0.45
++------------
++Various big endian fixes for hardlinks and symlinks and also for dfs.
++
++Version 0.44
++------------
++Various big endian fixes for servers with Unix extensions such as Samba
++
++Version 0.43
++------------
++Various FindNext fixes for incorrect filenames on large directory searches on big endian
++clients.  basic posix file i/o tests now work on big endian machines, not just le
++
++Version 0.42
++------------
++SessionSetup and NegotiateProtocol now work from Big Endian machines.
++Various Big Endian fixes found during testing on the Linux on 390.  Various fixes for compatibility with older
++versions of 2.4 kernel (now builds and works again on kernels at least as early as 2.4.7).
++
++Version 0.41
++------------
++Various minor fixes for Connectathon Posix "basic" file i/o test suite.  Directory caching fixed so hardlinked
++files now return the correct rumber of links on fstat as they are repeatedly linked and unlinked.
++
++Version 0.40
++------------
++Implemented "Raw" (i.e. not encapsulated in SPNEGO) NTLMSSP (i.e. the Security Provider Interface used to negotiate
++session advanced session authentication).  Raw NTLMSSP is preferred by Windows 2000 Professional and Windows XP.
++Began implementing support for SPNEGO encapsulation of NTLMSSP based session authentication blobs
++(which is the mechanism preferred by Windows 2000 server in the absence of Kerberos).
++
++Version 0.38
++------------
++Introduced optional mount helper utility mount.cifs and made coreq changes to cifs vfs to enable
++it. Fixed a few bugs in the DFS code (e.g. bcc two bytes too short and incorrect uid in PDU).
++
++Version 0.37
++------------
++Rewrote much of connection and mount/unmount logic to handle bugs with
++multiple uses to same share, multiple users to same server etc.
++
++Version 0.36
++------------
++Fixed major problem with dentry corruption (missing call to dput)
++
++Version 0.35
++------------
++Rewrite of readdir code to fix bug. Various fixes for bigendian machines.
++Begin adding oplock support.  Multiusermount and oplockEnabled flags added to /proc/fs/cifs
++although corresponding function not fully implemented in the vfs yet
++
++Version 0.34
++------------
++Fixed dentry caching bug, misc. cleanup 
++
++Version 0.33
++------------
++Fixed 2.5 support to handle build and configure changes as well as misc. 2.5 changes.  Now can build
++on current 2.5 beta version (2.5.24) of the Linux kernel as well as on 2.4 Linux kernels.
++Support for STATUS codes (newer 32 bit NT error codes) added.  DFS support begun to be added.
++
++Version 0.32
++------------
++Unix extensions (symlink, readlink, hardlink, chmod and some chgrp and chown) implemented
++and tested against Samba 2.2.5
++
++
++Version 0.31
++------------
++1) Fixed lockrange to be correct (it was one byte too short)
++
++2) Fixed GETLK (i.e. the fcntl call to test a range of bytes in a file to see if locked) to correctly 
++show range as locked when there is a conflict with an existing lock.
++
++3) default file perms are now 2767 (indicating support for mandatory locks) instead of 777 for directories
++in most cases.  Eventually will offer optional ability to query server for the correct perms.
++
++3) Fixed eventual trap when mounting twice to different shares on the same server when the first succeeded 
++but the second one was invalid and failed (the second one was incorrectly disconnecting the tcp and smb
++session) 
++
++4) Fixed error logging of valid mount options
++
++5) Removed logging of password field.
++
++6) Moved negotiate, treeDisconnect and uloggoffX (only tConx and SessSetup remain in connect.c) to cifssmb.c
++and cleaned them up and made them more consistent with other cifs functions. 
++
++7) Server support for Unix extensions is now fully detected and FindFirst is implemented both ways 
++(with or without Unix exentions) but FindNext and QueryPathInfo with the Unix extensions are not completed,
++nor is the symlink support using the Unix extensions
++
++8) Started adding the readlink and follow_link code 
++
++Version 0.3 
++-----------
++Initial drop
++
+diff -urN linux-2.4.29.old/fs/cifs/cifs_debug.c linux-2.4.29/fs/cifs/cifs_debug.c
+--- linux-2.4.29.old/fs/cifs/cifs_debug.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifs_debug.c	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,797 @@
++/*
++ *   fs/cifs_debug.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2000,2003
++ *
++ *   Modified by Steve French (sfrench@us.ibm.com)
++ *
++ *   This program is free software;  you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License as published by
++ *   the Free Software Foundation; either version 2 of the License, or 
++ *   (at your option) any later version.
++ * 
++ *   This program is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU General Public License for more details.
++ *
++ *   You should have received a copy of the GNU General Public License
++ *   along with this program;  if not, write to the Free Software 
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++#include <linux/fs.h>
++#include <linux/string.h>
++#include <linux/ctype.h>
++#include <linux/module.h>
++#include <linux/proc_fs.h>
++#include <asm/uaccess.h>
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_debug.h"
++
++void
++cifs_dump_mem(char *label, void *data, int length)
++{
++	int i, j;
++	int *intptr = data;
++	char *charptr = data;
++	char buf[10], line[80];
++
++	printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n\n", 
++		label, length, data);
++	for (i = 0; i < length; i += 16) {
++		line[0] = 0;
++		for (j = 0; (j < 4) && (i + j * 4 < length); j++) {
++			sprintf(buf, " %08x", intptr[i / 4 + j]);
++			strcat(line, buf);
++		}
++		buf[0] = ' ';
++		buf[2] = 0;
++		for (j = 0; (j < 16) && (i + j < length); j++) {
++			buf[1] = isprint(charptr[i + j]) ? charptr[i + j] : '.';
++			strcat(line, buf);
++		}
++		printk(KERN_DEBUG "%s\n", line);
++	}
++}
++
++#ifdef CONFIG_PROC_FS
++int
++cifs_debug_data_read(char *buf, char **beginBuffer, off_t offset,
++		     int count, int *eof, void *data)
++{
++	struct list_head *tmp;
++	struct list_head *tmp1;
++	struct mid_q_entry * mid_entry;
++	struct cifsSesInfo *ses;
++	struct cifsTconInfo *tcon;
++	int i;
++	int length = 0;
++	char * original_buf = buf;
++
++	*beginBuffer = buf + offset;
++
++	
++	length =
++	    sprintf(buf,
++		    "Display Internal CIFS Data Structures for Debugging\n"
++		    "---------------------------------------------------\n");
++	buf += length;
++
++	length = sprintf(buf, "Servers:\n");
++	buf += length;
++
++	i = 0;
++	read_lock(&GlobalSMBSeslock);
++	list_for_each(tmp, &GlobalSMBSessionList) {
++		i++;
++		ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
++		length =
++		    sprintf(buf,
++			    "\n%d) Name: %s  Domain: %s Mounts: %d ServerOS: %s  \n\tServerNOS: %s\tCapabilities: 0x%x\n\tSMB session status: %d\tTCP status: %d",
++				i, ses->serverName, ses->serverDomain, atomic_read(&ses->inUse),
++				ses->serverOS, ses->serverNOS, ses->capabilities,ses->status,ses->server->tcpStatus);
++		buf += length;
++		if(ses->server) {
++			buf += sprintf(buf, "\n\tLocal Users To Server: %d SecMode: 0x%x Req Active: %d",
++				atomic_read(&ses->server->socketUseCount),
++				ses->server->secMode,
++				atomic_read(&ses->server->inFlight));
++			
++			length = sprintf(buf, "\nMIDs: \n");
++			buf += length;
++
++			spin_lock(&GlobalMid_Lock);
++			list_for_each(tmp1, &ses->server->pending_mid_q) {
++				mid_entry = list_entry(tmp1, struct
++					mid_q_entry,
++					qhead);
++				if(mid_entry) {
++					length = sprintf(buf,"State: %d com: %d pid: %d tsk: %p mid %d\n",mid_entry->midState,mid_entry->command,mid_entry->pid,mid_entry->tsk,mid_entry->mid);
++					buf += length;
++				}
++			}
++			spin_unlock(&GlobalMid_Lock); 
++		}
++
++	}
++	read_unlock(&GlobalSMBSeslock);
++	sprintf(buf, "\n");
++	buf++;
++
++	length = sprintf(buf, "\nShares:\n");
++	buf += length;
++
++	i = 0;
++	read_lock(&GlobalSMBSeslock);
++	list_for_each(tmp, &GlobalTreeConnectionList) {
++		i++;
++		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
++		length =
++		    sprintf(buf,
++			    "\n%d) %s Uses: %d Type: %s Characteristics: 0x%x Attributes: 0x%x\nPathComponentMax: %d Status: %d",
++			    i, tcon->treeName,
++			    atomic_read(&tcon->useCount),
++			    tcon->nativeFileSystem,
++			    tcon->fsDevInfo.DeviceCharacteristics,
++			    tcon->fsAttrInfo.Attributes,
++			    tcon->fsAttrInfo.MaxPathNameComponentLength,tcon->tidStatus);
++		buf += length;        
++		if (tcon->fsDevInfo.DeviceType == FILE_DEVICE_DISK)
++			length = sprintf(buf, " type: DISK ");
++		else if (tcon->fsDevInfo.DeviceType == FILE_DEVICE_CD_ROM)
++			length = sprintf(buf, " type: CDROM ");
++		else
++			length =
++			    sprintf(buf, " type: %d ",
++				    tcon->fsDevInfo.DeviceType);
++		buf += length;
++		if(tcon->tidStatus == CifsNeedReconnect) {
++			buf += sprintf(buf, "\tDISCONNECTED ");
++			length += 14;
++		}
++	}
++	read_unlock(&GlobalSMBSeslock);
++
++	length = sprintf(buf, "\n");
++	buf += length;
++
++	/* BB add code to dump additional info such as TCP session info now */
++	/* Now calculate total size of returned data */
++	length = buf - original_buf;
++
++	if(offset + count >= length)
++		*eof = 1;
++	if(length < offset) {
++		*eof = 1;
++		return 0;
++	} else {
++		length = length - offset;
++	}
++	if (length > count)
++		length = count;
++
++	return length;
++}
++
++#ifdef CONFIG_CIFS_STATS
++int
++cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
++		  int count, int *eof, void *data)
++{
++	int item_length,i,length;
++	struct list_head *tmp;
++	struct cifsTconInfo *tcon;
++
++	*beginBuffer = buf + offset;
++
++	length = sprintf(buf,
++			"Resources in use\nCIFS Session: %d\n",
++			sesInfoAllocCount.counter);
++	buf += length;
++	item_length = 
++		sprintf(buf,"Share (unique mount targets): %d\n",
++			tconInfoAllocCount.counter);
++	length += item_length;
++	buf += item_length;      
++	item_length = 
++		sprintf(buf,"SMB Request/Response Buffer: %d\n",
++			bufAllocCount.counter);
++	length += item_length;
++	buf += item_length;      
++	item_length = 
++		sprintf(buf,"Operations (MIDs): %d\n",
++			midCount.counter);
++	length += item_length;
++	buf += item_length;
++	item_length = sprintf(buf,
++		"\n%d session %d share reconnects\n",
++		tcpSesReconnectCount.counter,tconInfoReconnectCount.counter);
++	length += item_length;
++	buf += item_length;
++
++	item_length = sprintf(buf,
++		"Total vfs operations: %d maximum at one time: %d\n",
++		GlobalCurrentXid,GlobalMaxActiveXid);
++	length += item_length;
++	buf += item_length;
++
++	i = 0;
++	read_lock(&GlobalSMBSeslock);
++	list_for_each(tmp, &GlobalTreeConnectionList) {
++		i++;
++		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
++		item_length = sprintf(buf,"\n%d) %s",i, tcon->treeName);
++		buf += item_length;
++		length += item_length;
++		if(tcon->tidStatus == CifsNeedReconnect) {
++			buf += sprintf(buf, "\tDISCONNECTED ");
++			length += 14;
++		}
++		item_length = sprintf(buf,"\nSMBs: %d Oplock Breaks: %d",
++			atomic_read(&tcon->num_smbs_sent),
++			atomic_read(&tcon->num_oplock_brks));
++		buf += item_length;
++		length += item_length;
++		item_length = sprintf(buf,"\nReads: %d Bytes %lld",
++			atomic_read(&tcon->num_reads),
++			(long long)(tcon->bytes_read));
++		buf += item_length;
++		length += item_length;
++		item_length = sprintf(buf,"\nWrites: %d Bytes: %lld",
++			atomic_read(&tcon->num_writes),
++			(long long)(tcon->bytes_written));
++		buf += item_length;
++		length += item_length;
++		item_length = sprintf(buf,
++			"\nOpens: %d Deletes: %d\nMkdirs: %d Rmdirs: %d",
++			atomic_read(&tcon->num_opens),
++			atomic_read(&tcon->num_deletes),
++			atomic_read(&tcon->num_mkdirs),
++			atomic_read(&tcon->num_rmdirs));
++		buf += item_length;
++		length += item_length;
++		item_length = sprintf(buf,
++			"\nRenames: %d T2 Renames %d",
++			atomic_read(&tcon->num_renames),
++			atomic_read(&tcon->num_t2renames));
++		buf += item_length;
++		length += item_length;
++	}
++	read_unlock(&GlobalSMBSeslock);
++
++	buf += sprintf(buf,"\n");
++	length++;
++
++	if(offset + count >= length)
++		*eof = 1;
++	if(length < offset) {
++		*eof = 1;
++		return 0;
++	} else {
++		length = length - offset;
++	}
++	if (length > count)
++		length = count;
++		
++	return length;
++}
++#endif
++
++struct proc_dir_entry *proc_fs_cifs;
++read_proc_t cifs_txanchor_read;
++static read_proc_t cifsFYI_read;
++static write_proc_t cifsFYI_write;
++static read_proc_t oplockEnabled_read;
++static write_proc_t oplockEnabled_write;
++static read_proc_t lookupFlag_read;
++static write_proc_t lookupFlag_write;
++static read_proc_t traceSMB_read;
++static write_proc_t traceSMB_write;
++static read_proc_t multiuser_mount_read;
++static write_proc_t multiuser_mount_write;
++static read_proc_t extended_security_read;
++static write_proc_t extended_security_write;
++static read_proc_t ntlmv2_enabled_read;
++static write_proc_t ntlmv2_enabled_write;
++static read_proc_t packet_signing_enabled_read;
++static write_proc_t packet_signing_enabled_write;
++static read_proc_t quotaEnabled_read;
++static write_proc_t quotaEnabled_write;
++static read_proc_t linuxExtensionsEnabled_read;
++static write_proc_t linuxExtensionsEnabled_write;
++
++void
++cifs_proc_init(void)
++{
++	struct proc_dir_entry *pde;
++
++	proc_fs_cifs = proc_mkdir("cifs", proc_root_fs);
++	if (proc_fs_cifs == NULL)
++		return;
++
++	proc_fs_cifs->owner = THIS_MODULE;
++	create_proc_read_entry("DebugData", 0, proc_fs_cifs,
++				cifs_debug_data_read, NULL);
++
++#ifdef CONFIG_CIFS_STATS
++	create_proc_read_entry("Stats", 0, proc_fs_cifs,
++				cifs_stats_read, NULL);
++#endif
++	pde = create_proc_read_entry("cifsFYI", 0, proc_fs_cifs,
++				cifsFYI_read, NULL);
++	if (pde)
++		pde->write_proc = cifsFYI_write;
++
++	pde =
++	    create_proc_read_entry("traceSMB", 0, proc_fs_cifs,
++				traceSMB_read, NULL);
++	if (pde)
++		pde->write_proc = traceSMB_write;
++
++	pde = create_proc_read_entry("OplockEnabled", 0, proc_fs_cifs,
++				oplockEnabled_read, NULL);
++	if (pde)
++		pde->write_proc = oplockEnabled_write;
++
++	pde = create_proc_read_entry("QuotaEnabled", 0, proc_fs_cifs,
++				quotaEnabled_read, NULL);
++	if (pde)
++		pde->write_proc = quotaEnabled_write;
++
++	pde = create_proc_read_entry("LinuxExtensionsEnabled", 0, proc_fs_cifs,
++				linuxExtensionsEnabled_read, NULL);
++	if (pde)
++		pde->write_proc = linuxExtensionsEnabled_write;
++
++	pde =
++	    create_proc_read_entry("MultiuserMount", 0, proc_fs_cifs,
++				multiuser_mount_read, NULL);
++	if (pde)
++		pde->write_proc = multiuser_mount_write;
++
++	pde =
++	    create_proc_read_entry("ExtendedSecurity", 0, proc_fs_cifs,
++				extended_security_read, NULL);
++	if (pde)
++		pde->write_proc = extended_security_write;
++
++	pde =
++	create_proc_read_entry("LookupCacheEnabled", 0, proc_fs_cifs,
++				lookupFlag_read, NULL);
++	if (pde)
++		pde->write_proc = lookupFlag_write;
++
++	pde =
++	    create_proc_read_entry("NTLMV2Enabled", 0, proc_fs_cifs,
++				ntlmv2_enabled_read, NULL);
++	if (pde)
++		pde->write_proc = ntlmv2_enabled_write;
++
++	pde =
++	    create_proc_read_entry("PacketSigningEnabled", 0, proc_fs_cifs,
++				packet_signing_enabled_read, NULL);
++	if (pde)
++		pde->write_proc = packet_signing_enabled_write;
++}
++
++void
++cifs_proc_clean(void)
++{
++	if (proc_fs_cifs == NULL)
++		return;
++
++	remove_proc_entry("DebugData", proc_fs_cifs);
++	remove_proc_entry("cifsFYI", proc_fs_cifs);
++	remove_proc_entry("traceSMB", proc_fs_cifs);
++#ifdef CONFIG_CIFS_STATS
++	remove_proc_entry("Stats", proc_fs_cifs);
++#endif
++	remove_proc_entry("MultiuserMount", proc_fs_cifs);
++	remove_proc_entry("OplockEnabled", proc_fs_cifs);
++	remove_proc_entry("NTLMV2Enabled",proc_fs_cifs);
++	remove_proc_entry("ExtendedSecurity",proc_fs_cifs);
++	remove_proc_entry("PacketSigningEnabled",proc_fs_cifs);
++	remove_proc_entry("LinuxExtensionsEnabled",proc_fs_cifs);
++	remove_proc_entry("QuotaEnabled",proc_fs_cifs);
++	remove_proc_entry("LookupCacheEnabled",proc_fs_cifs);
++	remove_proc_entry("cifs", proc_root_fs);
++}
++
++static int
++cifsFYI_read(char *page, char **start, off_t off, int count,
++	     int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", cifsFYI);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++cifsFYI_write(struct file *file, const char *buffer,
++	      unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		cifsFYI = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		cifsFYI = 1;
++
++	return count;
++}
++
++static int
++oplockEnabled_read(char *page, char **start, off_t off,
++		   int count, int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", oplockEnabled);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++oplockEnabled_write(struct file *file, const char *buffer,
++		    unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		oplockEnabled = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		oplockEnabled = 1;
++
++	return count;
++}
++
++static int
++quotaEnabled_read(char *page, char **start, off_t off,
++                   int count, int *eof, void *data)
++{
++        int len;
++
++        len = sprintf(page, "%d\n", quotaEnabled);
++/* could also check if quotas are enabled in kernel
++	as a whole first */
++        len -= off;
++        *start = page + off;
++
++        if (len > count)
++                len = count;
++        else
++                *eof = 1;
++
++        if (len < 0)
++                len = 0;
++
++        return len;
++}
++static int
++quotaEnabled_write(struct file *file, const char *buffer,
++                    unsigned long count, void *data)
++{
++        char c;
++        int rc;
++
++        rc = get_user(c, buffer);
++        if (rc)
++                return rc;
++        if (c == '0' || c == 'n' || c == 'N')
++                quotaEnabled = 0;
++        else if (c == '1' || c == 'y' || c == 'Y')
++                quotaEnabled = 1;
++
++        return count;
++}
++
++static int
++linuxExtensionsEnabled_read(char *page, char **start, off_t off,
++                   int count, int *eof, void *data)
++{
++        int len;
++
++        len = sprintf(page, "%d\n", linuxExtEnabled);
++/* could also check if quotas are enabled in kernel
++	as a whole first */
++        len -= off;
++        *start = page + off;
++
++        if (len > count)
++                len = count;
++        else
++                *eof = 1;
++
++        if (len < 0)
++                len = 0;
++
++        return len;
++}
++static int
++linuxExtensionsEnabled_write(struct file *file, const char *buffer,
++                    unsigned long count, void *data)
++{
++        char c;
++        int rc;
++
++        rc = get_user(c, buffer);
++        if (rc)
++                return rc;
++        if (c == '0' || c == 'n' || c == 'N')
++                linuxExtEnabled = 0;
++        else if (c == '1' || c == 'y' || c == 'Y')
++                linuxExtEnabled = 1;
++
++        return count;
++}
++
++
++static int
++lookupFlag_read(char *page, char **start, off_t off,
++		   int count, int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", lookupCacheEnabled);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++lookupFlag_write(struct file *file, const char *buffer,
++		    unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		lookupCacheEnabled = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		lookupCacheEnabled = 1;
++
++	return count;
++}
++static int
++traceSMB_read(char *page, char **start, off_t off, int count,
++	      int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", traceSMB);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++traceSMB_write(struct file *file, const char *buffer,
++	       unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		traceSMB = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		traceSMB = 1;
++
++	return count;
++}
++
++static int
++multiuser_mount_read(char *page, char **start, off_t off,
++		     int count, int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", multiuser_mount);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++multiuser_mount_write(struct file *file, const char *buffer,
++		      unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		multiuser_mount = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		multiuser_mount = 1;
++
++	return count;
++}
++
++static int
++extended_security_read(char *page, char **start, off_t off,
++		       int count, int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", extended_security);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++extended_security_write(struct file *file, const char *buffer,
++			unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		extended_security = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		extended_security = 1;
++
++	return count;
++}
++
++static int
++ntlmv2_enabled_read(char *page, char **start, off_t off,
++		       int count, int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", ntlmv2_support);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++ntlmv2_enabled_write(struct file *file, const char *buffer,
++			unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		ntlmv2_support = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		ntlmv2_support = 1;
++
++	return count;
++}
++
++static int
++packet_signing_enabled_read(char *page, char **start, off_t off,
++		       int count, int *eof, void *data)
++{
++	int len;
++
++	len = sprintf(page, "%d\n", sign_CIFS_PDUs);
++
++	len -= off;
++	*start = page + off;
++
++	if (len > count)
++		len = count;
++	else
++		*eof = 1;
++
++	if (len < 0)
++		len = 0;
++
++	return len;
++}
++static int
++packet_signing_enabled_write(struct file *file, const char *buffer,
++			unsigned long count, void *data)
++{
++	char c;
++	int rc;
++
++	rc = get_user(c, buffer);
++	if (rc)
++		return rc;
++	if (c == '0' || c == 'n' || c == 'N')
++		sign_CIFS_PDUs = 0;
++	else if (c == '1' || c == 'y' || c == 'Y')
++		sign_CIFS_PDUs = 1;
++	else if (c == '2')
++		sign_CIFS_PDUs = 2;
++
++	return count;
++}
++
++
++#endif
+diff -urN linux-2.4.29.old/fs/cifs/cifs_debug.h linux-2.4.29/fs/cifs/cifs_debug.h
+--- linux-2.4.29.old/fs/cifs/cifs_debug.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifs_debug.h	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,66 @@
++/*
++ *
++ *   Copyright (c) International Business Machines  Corp., 2000,2002
++ *   Modified by Steve French (sfrench@us.ibm.com)
++ *
++ *   This program is free software;  you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License as published by
++ *   the Free Software Foundation; either version 2 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This program is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU General Public License for more details.
++ *
++ *   You should have received a copy of the GNU General Public License
++ *   along with this program;  if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++*/
++#define CIFS_DEBUG		/* BB temporary */
++
++#ifndef _H_CIFS_DEBUG
++#define _H_CIFS_DEBUG
++
++void cifs_dump_mem(char *label, void *data, int length);
++extern int traceSMB;		/* flag which enables the function below */
++void dump_smb(struct smb_hdr *, int);
++
++/*
++ *	debug ON
++ *	--------
++ */
++#ifdef CIFS_DEBUG
++
++
++/* information message: e.g., configuration, major event */
++extern int cifsFYI;
++#define cifsfyi(format,arg...) if (cifsFYI) printk(KERN_DEBUG " " __FILE__ ": " format "\n" "" , ## arg)
++
++#define cFYI(button,prspec) if (button) cifsfyi prspec
++
++#define cifswarn(format, arg...) printk(KERN_WARNING ": " format "\n" , ## arg)
++
++/* debug event message: */
++extern int cifsERROR;
++
++#define cEVENT(format,arg...) if (cifsERROR) printk(KERN_EVENT __FILE__ ": " format "\n" , ## arg)
++
++/* error event message: e.g., i/o error */
++#define cifserror(format,arg...) if (cifsERROR) printk(KERN_ERR " CIFS VFS: " format "\n" "" , ## arg)
++
++#define cERROR(button, prspec) if (button) cifserror prspec
++
++/*
++ *	debug OFF
++ *	---------
++ */
++#else		/* _CIFS_DEBUG */
++#define cERROR(button,prspec)
++#define cEVENT(format,arg...)
++#define cFYI(button, prspec)
++#define cifserror(format,arg...)
++#endif		/* _CIFS_DEBUG */
++
++#endif				/* _H_CIFS_DEBUG */
+diff -urN linux-2.4.29.old/fs/cifs/cifsencrypt.c linux-2.4.29/fs/cifs/cifsencrypt.c
+--- linux-2.4.29.old/fs/cifs/cifsencrypt.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifsencrypt.c	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,204 @@
++/*
++ *   fs/cifs/cifsencrypt.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#include <linux/fs.h>
++#include "cifspdu.h"
++#include "cifsglob.h" 
++#include "cifs_debug.h"
++#include "md5.h"
++#include "cifs_unicode.h"
++
++/* Calculate and return the CIFS signature based on the mac key and the smb pdu */
++/* the 16 byte signature must be allocated by the caller  */
++/* Note we only use the 1st eight bytes */
++/* Note that the smb header signature field on input contains the  
++	sequence number before this function is called */
++
++extern void mdfour(unsigned char *out, unsigned char *in, int n);
++extern void E_md4hash(const unsigned char *passwd, unsigned char *p16);
++	
++static int cifs_calculate_signature(const struct smb_hdr * cifs_pdu, const char * key, char * signature)
++{
++	struct	MD5Context context;
++
++	if((cifs_pdu == NULL) || (signature == NULL))
++		return -EINVAL;
++
++	MD5Init(&context);
++	MD5Update(&context,key,CIFS_SESSION_KEY_SIZE+16);
++	MD5Update(&context,cifs_pdu->Protocol,cifs_pdu->smb_buf_length);
++	MD5Final(signature,&context);
++	return 0;
++}
++
++int cifs_sign_smb(struct smb_hdr * cifs_pdu, struct cifsSesInfo * ses,
++	__u32 * pexpected_response_sequence_number)
++{
++	int rc = 0;
++	char smb_signature[20];
++
++	/* BB remember to initialize sequence number elsewhere and initialize mac_signing key elsewhere BB */
++	/* BB remember to add code to save expected sequence number in midQ entry BB */
++
++	if((cifs_pdu == NULL) || (ses == NULL))
++		return -EINVAL;
++
++	if((le32_to_cpu(cifs_pdu->Flags2) & SMBFLG2_SECURITY_SIGNATURE) == 0) 
++		return rc;
++
++	spin_lock(&GlobalMid_Lock);
++	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(ses->sequence_number);
++	cifs_pdu->Signature.Sequence.Reserved = 0;
++	
++	*pexpected_response_sequence_number = ses->sequence_number++;
++	ses->sequence_number++;
++	spin_unlock(&GlobalMid_Lock);
++
++	rc = cifs_calculate_signature(cifs_pdu, ses->mac_signing_key,smb_signature);
++	if(rc)
++		memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
++	else
++		memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
++
++	return rc;
++}
++
++int cifs_verify_signature(struct smb_hdr * cifs_pdu, const char * mac_key,
++	__u32 expected_sequence_number)
++{
++	unsigned int rc;
++	char server_response_sig[8];
++	char what_we_think_sig_should_be[20];
++
++	if((cifs_pdu == NULL) || (mac_key == NULL))
++		return -EINVAL;
++
++	if (cifs_pdu->Command == SMB_COM_NEGOTIATE)
++		return 0;
++
++	if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
++		struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)cifs_pdu;
++	    if(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
++			return 0;
++	}
++
++	/* BB what if signatures are supposed to be on for session but server does not
++		send one? BB */
++	
++	/* Do not need to verify session setups with signature "BSRSPYL "  */
++	if(memcmp(cifs_pdu->Signature.SecuritySignature,"BSRSPYL ",8)==0)
++		cFYI(1,("dummy signature received for smb command 0x%x",cifs_pdu->Command));
++
++	expected_sequence_number = cpu_to_le32(expected_sequence_number);
++
++	/* save off the origiginal signature so we can modify the smb and check
++		its signature against what the server sent */
++	memcpy(server_response_sig,cifs_pdu->Signature.SecuritySignature,8);
++
++	cifs_pdu->Signature.Sequence.SequenceNumber = expected_sequence_number;
++	cifs_pdu->Signature.Sequence.Reserved = 0;
++
++	rc = cifs_calculate_signature(cifs_pdu, mac_key,
++		what_we_think_sig_should_be);
++
++	if(rc)
++		return rc;
++
++	
++/*	cifs_dump_mem("what we think it should be: ",what_we_think_sig_should_be,16); */
++
++	if(memcmp(server_response_sig, what_we_think_sig_should_be, 8))
++		return -EACCES;
++	else
++		return 0;
++
++}
++
++/* We fill in key by putting in 40 byte array which was allocated by caller */
++int cifs_calculate_mac_key(char * key, const char * rn, const char * password)
++{
++	char temp_key[16];
++	if ((key == NULL) || (rn == NULL))
++		return -EINVAL;
++
++	E_md4hash(password, temp_key);
++	mdfour(key,temp_key,16);
++	memcpy(key+16,rn, CIFS_SESSION_KEY_SIZE);
++	return 0;
++}
++
++int CalcNTLMv2_partial_mac_key(struct cifsSesInfo * ses, struct nls_table * nls_info)
++{
++	char temp_hash[16];
++	struct HMACMD5Context ctx;
++	char * ucase_buf;
++	wchar_t * unicode_buf;
++	unsigned int i,user_name_len,dom_name_len;
++
++	if(ses)
++		return -EINVAL;
++
++	E_md4hash(ses->password, temp_hash);
++
++	hmac_md5_init_limK_to_64(temp_hash, 16, &ctx);
++	user_name_len = strlen(ses->userName);
++	if(user_name_len > MAX_USERNAME_SIZE)
++		return -EINVAL;
++	dom_name_len = strlen(ses->domainName);
++	if(dom_name_len > MAX_USERNAME_SIZE)
++		return -EINVAL;
++  
++	ucase_buf = kmalloc((MAX_USERNAME_SIZE+1), GFP_KERNEL);
++	unicode_buf = kmalloc((MAX_USERNAME_SIZE+1)*4, GFP_KERNEL);
++   
++	for(i=0;i<user_name_len;i++)
++		ucase_buf[i] = nls_info->charset2upper[(int)ses->userName[i]];
++	ucase_buf[i] = 0;
++	user_name_len = cifs_strtoUCS(unicode_buf, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
++	unicode_buf[user_name_len] = 0;
++	user_name_len++;
++
++	for(i=0;i<dom_name_len;i++)
++		ucase_buf[i] = nls_info->charset2upper[(int)ses->domainName[i]];
++	ucase_buf[i] = 0;
++	dom_name_len = cifs_strtoUCS(unicode_buf+user_name_len, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
++
++	unicode_buf[user_name_len + dom_name_len] = 0;
++	hmac_md5_update((const unsigned char *) unicode_buf,
++		(user_name_len+dom_name_len)*2,&ctx);
++
++	hmac_md5_final(ses->mac_signing_key,&ctx);
++	kfree(ucase_buf);
++	kfree(unicode_buf);
++	return 0;
++}
++void CalcNTLMv2_response(const struct cifsSesInfo * ses,char * v2_session_response)
++{
++	struct HMACMD5Context context;
++	memcpy(v2_session_response + 8, ses->server->cryptKey,8);
++	/* gen_blob(v2_session_response + 16); */
++	hmac_md5_init_limK_to_64(ses->mac_signing_key, 16, &context);
++
++	hmac_md5_update(ses->server->cryptKey,8,&context);
++/*	hmac_md5_update(v2_session_response+16)client thing,8,&context); */ /* BB fix */
++
++	hmac_md5_final(v2_session_response,&context);
++}
+diff -urN linux-2.4.29.old/fs/cifs/cifserr.c linux-2.4.29/fs/cifs/cifserr.c
+--- linux-2.4.29.old/fs/cifs/cifserr.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifserr.c	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,70 @@
++/*
++ *   fs/cifserr.c
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#include <linux/errno.h>
++#include <linux/fs.h>
++#include <linux/smbno.h>
++#include "cifsfs.h"
++
++int map_cifs_error(int error_class, int error_code,
++		   int status_codes_negotiated)
++{
++
++
++	if (status_codes_negotiated) {
++		switch (error_code) {
++		default:
++			return EIO;
++		}
++	} else
++		switch (error_class) {
++		case SUCCESS:
++			return 0;
++
++		case ERRDOS:
++			switch (error_code) {
++			case ERRbadfunc:
++				return EINVAL;
++			default:
++				return EIO;
++			}
++
++		case ERRSRV:
++			switch (error_code) {
++			default:
++				return EIO;
++			}
++
++		case ERRHRD:
++			switch (error_code) {
++			default:
++				return EIO;
++			}
++		default:
++			return EIO;
++		}
++	return 0;
++}
++
++int map_smb_error(int error_class, int error_code)
++{
++	return map_cifs_error(error_class, error_code, FALSE);
++}
+diff -urN linux-2.4.29.old/fs/cifs/cifsfs.c linux-2.4.29/fs/cifs/cifsfs.c
+--- linux-2.4.29.old/fs/cifs/cifsfs.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifsfs.c	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,769 @@
++/*
++ *   fs/cifs/cifsfs.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2004
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   Common Internet FileSystem (CIFS) client
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++/* Note that BB means BUGBUG (ie something to fix eventually) */
++
++#include <linux/module.h>
++#include <linux/fs.h>
++#include <linux/mount.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/version.h>
++#include <linux/list.h>
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,15))
++#include <linux/seq_file.h>
++#endif
++#include <linux/vfs.h>
++#include "cifsfs.h"
++#include "cifspdu.h"
++#define DECLARE_GLOBALS_HERE
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_debug.h"
++#include "cifs_fs_sb.h"
++#include <linux/mm.h>
++#define CIFS_MAGIC_NUMBER 0xFF534D42	/* the first four bytes of SMB PDUs */
++/* BB when mempool_resize is added back in, we will resize pool on new mount */
++#define CIFS_MIN_RCV_POOL 11 /* enough for progress to five servers */
++
++#ifdef CONFIG_CIFS_QUOTA
++static struct quotactl_ops cifs_quotactl_ops;
++#endif
++
++extern struct file_system_type cifs_fs_type;
++
++int cifsFYI = 0;
++int cifsERROR = 1;
++int traceSMB = 0;
++unsigned int oplockEnabled = 1;
++unsigned int quotaEnabled = 0;
++unsigned int linuxExtEnabled = 1;
++unsigned int lookupCacheEnabled = 1;
++unsigned int multiuser_mount = 0;
++unsigned int extended_security = 0;
++unsigned int ntlmv2_support = 0;
++unsigned int sign_CIFS_PDUs = 1;
++unsigned int CIFSMaximumBufferSize = CIFS_MAX_MSGSIZE;
++struct task_struct * oplockThread = NULL;
++
++extern int cifs_mount(struct super_block *, struct cifs_sb_info *, char *,
++			const char *);
++extern int cifs_umount(struct super_block *, struct cifs_sb_info *);
++void cifs_proc_init(void);
++void cifs_proc_clean(void);
++
++static DECLARE_COMPLETION(cifs_oplock_exited);
++
++
++struct super_block *
++cifs_read_super(struct super_block *sb, void *data, int silent)
++{
++	struct inode *inode;
++	struct cifs_sb_info *cifs_sb;
++	int rc = 0;
++
++	sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
++	cifs_sb = CIFS_SB(sb);
++	if(cifs_sb == NULL)
++		return 0;
++	else
++		memset(cifs_sb,0,sizeof(struct cifs_sb_info));
++	
++
++	rc = cifs_mount(sb, cifs_sb, data, NULL);
++
++	if (rc) {
++		if (!silent)
++			cERROR(1,
++			       ("cifs_mount failed w/return code = %d", rc));
++		goto out_mount_failed;
++	}
++
++	sb->s_magic = CIFS_MAGIC_NUMBER;
++	sb->s_op = &cifs_super_ops;
++/*	if(cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
++	    sb->s_blocksize = cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
++#ifdef CONFIG_CIFS_QUOTA
++	sb->s_qcop = &cifs_quotactl_ops;
++#endif
++	sb->s_blocksize = CIFS_MAX_MSGSIZE;
++	sb->s_blocksize_bits = 14;	/* default 2**14 = CIFS_MAX_MSGSIZE */
++	inode = iget(sb, ROOT_I);
++
++	if (!inode) {
++		goto out_no_root;
++	}
++
++	sb->s_root = d_alloc_root(inode);
++
++	if (!sb->s_root) {
++		goto out_no_root;
++	}
++
++	return sb;
++
++out_no_root:
++	cERROR(1, ("cifs_read_super: get root inode failed"));
++	if (inode)
++		iput(inode);
++
++out_mount_failed:
++	if(cifs_sb->local_nls)
++		unload_nls(cifs_sb->local_nls);
++	sb->s_dev = 0;
++	return 0;
++}
++
++static void
++cifs_put_super(struct super_block *sb)
++{
++	int rc = 0;
++	struct cifs_sb_info *cifs_sb;
++
++	cFYI(1, ("In cifs_put_super"));
++	cifs_sb = CIFS_SB(sb);
++	if(cifs_sb == NULL) {
++		cFYI(1,("Empty cifs superblock info passed to unmount"));
++		return;
++	}
++	rc = cifs_umount(sb, cifs_sb); 
++	if (rc) {
++		cERROR(1, ("cifs_umount failed with return code %d", rc));
++	}
++	unload_nls(cifs_sb->local_nls);
++	return;
++}
++
++static int
++cifs_statfs(struct super_block *sb, struct statfs *buf)
++{
++	int xid, rc;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(sb);
++	pTcon = cifs_sb->tcon;
++
++	buf->f_type = CIFS_MAGIC_NUMBER;
++
++	/* instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO */
++	buf->f_namelen = PATH_MAX;	/* PATH_MAX may be too long - it would presumably
++					   be length of total path, note that some servers may be 
++					   able to support more than this, but best to be safe
++					   since Win2k and others can not handle very long filenames */
++	buf->f_files = 0;	/* undefined */
++	buf->f_ffree = 0;	/* unlimited */
++
++	rc = CIFSSMBQFSInfo(xid, pTcon, buf, cifs_sb->local_nls);
++
++	/*     
++	   int f_type;
++	   __fsid_t f_fsid;
++	   int f_namelen;  */
++	/* BB get from info put in tcon struct at mount time with call to QFSAttrInfo */
++	FreeXid(xid);
++	return 0;		/* always return success? what if volume is no longer available? */
++}
++
++static int cifs_permission(struct inode * inode, int mask)
++{
++	/* the server does permission checks, we do not need to do it here */
++	return 0;
++}
++
++kmem_cache_t *cifs_req_cachep;
++kmem_cache_t *cifs_mid_cachep;
++kmem_cache_t *cifs_oplock_cachep;
++
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
++static struct inode *
++cifs_alloc_inode(struct super_block *sb)
++{
++        struct cifsInodeInfo *cifs_inode;
++        cifs_inode =
++            (struct cifsInodeInfo *) kmem_cache_alloc(cifs_inode_cachep,
++                                                      SLAB_KERNEL);
++        if (!cifs_inode)
++                return NULL;
++        cifs_inode->cifsAttrs = 0x20;   /* default */
++        atomic_set(&cifs_inode->inUse, 0);
++        cifs_inode->time = 0;
++        /* Until the file is open and we have gotten oplock
++        info back from the server, can not assume caching of
++        file data or metadata */
++        cifs_inode->clientCanCacheRead = FALSE;
++        cifs_inode->clientCanCacheAll = FALSE;
++        INIT_LIST_HEAD(&cifs_inode->openFileList);
++        return &cifs_inode->vfs_inode;
++}
++
++static void
++cifs_destroy_inode(struct inode *inode)
++{
++	kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
++}
++#endif
++
++/*
++ * cifs_show_options() is for displaying mount options in /proc/mounts.
++ * Not all settable options are displayed but most of the important
++ * ones are.
++ */
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,15))
++static int
++cifs_show_options(struct seq_file *s, struct vfsmount *m)
++{
++	struct cifs_sb_info *cifs_sb;
++
++	cifs_sb = CIFS_SB(m->mnt_sb);
++
++	if (cifs_sb) {
++		if (cifs_sb->tcon) {
++			seq_printf(s, ",unc=%s", cifs_sb->tcon->treeName);
++			if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->userName))
++				seq_printf(s, ",username=%s",
++					   cifs_sb->tcon->ses->userName);
++			if(cifs_sb->tcon->ses->domainName)
++				seq_printf(s, ",domain=%s",
++					cifs_sb->tcon->ses->domainName);
++		}
++		seq_printf(s, ",rsize=%d",cifs_sb->rsize);
++		seq_printf(s, ",wsize=%d",cifs_sb->wsize);
++	}
++	return 0;
++}
++#endif
++
++#ifdef CONFIG_CIFS_QUOTA
++int cifs_xquota_set(struct super_block * sb, int quota_type, qid_t qid,
++		struct fs_disk_quota * pdquota)
++{
++	int xid;
++	int rc = 0;
++	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
++	struct cifsTconInfo *pTcon;
++	
++	if(cifs_sb)
++		pTcon = cifs_sb->tcon;
++	else
++		return -EIO;
++
++
++	xid = GetXid();
++	if(pTcon) {
++		cFYI(1,("set type: 0x%x id: %d",quota_type,qid));		
++	} else {
++		return -EIO;
++	}
++
++	FreeXid(xid);
++	return rc;
++}
++
++int cifs_xquota_get(struct super_block * sb, int quota_type, qid_t qid,
++                struct fs_disk_quota * pdquota)
++{
++	int xid;
++	int rc = 0;
++	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
++	struct cifsTconInfo *pTcon;
++
++	if(cifs_sb)
++		pTcon = cifs_sb->tcon;
++	else
++		return -EIO;
++
++	xid = GetXid();
++	if(pTcon) {
++                cFYI(1,("set type: 0x%x id: %d",quota_type,qid));
++	} else {
++		rc = -EIO;
++	}
++
++	FreeXid(xid);
++	return rc;
++}
++
++int cifs_xstate_set(struct super_block * sb, unsigned int flags, int operation)
++{
++	int xid; 
++	int rc = 0;
++	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
++	struct cifsTconInfo *pTcon;
++
++	if(cifs_sb)
++		pTcon = cifs_sb->tcon;
++	else
++		return -EIO;
++
++	xid = GetXid();
++	if(pTcon) {
++                cFYI(1,("flags: 0x%x operation: 0x%x",flags,operation));
++	} else {
++		rc = -EIO;
++	}
++
++	FreeXid(xid);
++	return rc;
++}
++
++int cifs_xstate_get(struct super_block * sb, struct fs_quota_stat *qstats)
++{
++	int xid;
++	int rc = 0;
++	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
++	struct cifsTconInfo *pTcon;
++
++	if(cifs_sb) {
++		pTcon = cifs_sb->tcon;
++	} else {
++		return -EIO;
++	}
++	xid = GetXid();
++	if(pTcon) {
++		cFYI(1,("pqstats %p",qstats));		
++	} else {
++		rc = -EIO;
++	}
++
++	FreeXid(xid);
++	return rc;
++}
++
++static struct quotactl_ops cifs_quotactl_ops = {
++	.set_xquota	= cifs_xquota_set,
++	.get_xquota	= cifs_xquota_set,
++	.set_xstate	= cifs_xstate_set,
++	.get_xstate	= cifs_xstate_get,
++};
++#endif
++
++static int cifs_remount(struct super_block *sb, int *flags, char *data)
++{
++	*flags |= MS_NODIRATIME;
++	return 0;
++}
++
++struct super_operations cifs_super_ops = {
++	.read_inode = cifs_read_inode,
++	.put_super = cifs_put_super,
++	.statfs = cifs_statfs,
++/*	.alloc_inode = cifs_alloc_inode,
++	.destroy_inode = cifs_destroy_inode, */
++/*	.drop_inode	    = generic_delete_inode, 
++	.delete_inode	= cifs_delete_inode,  *//* Do not need the above two functions     
++   unless later we add lazy close of inodes or unless the kernel forgets to call
++   us with the same number of releases (closes) as opens */
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,15))
++	.show_options = cifs_show_options,
++#endif
++/*    .umount_begin   = cifs_umount_begin, *//* consider adding in the future */
++};
++
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
++static struct super_block *
++cifs_get_sb(struct file_system_type *fs_type,
++	    int flags, const char *dev_name, void *data)
++{
++	int rc;
++	struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
++
++	cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
++
++	if (IS_ERR(sb))
++		return sb;
++
++	sb->s_flags = flags;
++
++	rc = cifs_read_super(sb, data, dev_name, flags & MS_VERBOSE ? 1 : 0);
++	if (rc) {
++		up_write(&sb->s_umount);
++		deactivate_super(sb);
++		return ERR_PTR(rc);
++	}
++	sb->s_flags |= MS_ACTIVE;
++	return sb;
++}
++#endif
++
++static ssize_t
++cifs_read_wrapper(struct file * file, char *read_data, size_t read_size,
++          loff_t * poffset)
++{
++	if(file == NULL)
++		return -EIO;
++	else if(file->f_dentry == NULL)
++		return -EIO;
++	else if(file->f_dentry->d_inode == NULL)
++		return -EIO;
++
++	if(CIFS_I(file->f_dentry->d_inode)->clientCanCacheRead) {
++		return generic_file_read(file,read_data,read_size,poffset);
++	} else {
++		/* BB do we need to lock inode from here until after invalidate? */
++/*		if(file->f_dentry->d_inode->i_mapping) {
++			filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
++			filemap_fdatawait(file->f_dentry->d_inode->i_mapping);
++		}*/
++/*		cifs_revalidate(file->f_dentry);*/ /* BB fixme */
++
++		/* BB we should make timer configurable - perhaps 
++		   by simply calling cifs_revalidate here */
++		/* invalidate_remote_inode(file->f_dentry->d_inode);*/
++		return generic_file_read(file,read_data,read_size,poffset);
++	}
++}
++
++static ssize_t
++cifs_write_wrapper(struct file * file, const char *write_data,
++           size_t write_size, loff_t * poffset) 
++{
++	ssize_t written;
++
++	if(file == NULL)
++		return -EIO;
++	else if(file->f_dentry == NULL)
++		return -EIO;
++	else if(file->f_dentry->d_inode == NULL)
++		return -EIO;
++
++	/* check whether we can cache writes locally */
++	written = generic_file_write(file,write_data,write_size,poffset);
++	if(!CIFS_I(file->f_dentry->d_inode)->clientCanCacheAll)  {
++		if(file->f_dentry->d_inode->i_mapping) {
++			filemap_fdatasync(file->f_dentry->d_inode->i_mapping);
++		}
++	}
++	return written;
++}
++
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
++static struct file_system_type cifs_fs_type = {
++	.owner = THIS_MODULE,
++	.name = "cifs",
++	.get_sb = cifs_get_sb,
++	.kill_sb = kill_anon_super,
++	/*  .fs_flags */
++};
++#endif
++
++static DECLARE_FSTYPE(cifs_fs_type, "cifs", cifs_read_super,0);
++
++
++struct inode_operations cifs_dir_inode_ops = {
++	.create = cifs_create,
++	.lookup = cifs_lookup,
++	.unlink = cifs_unlink,
++	.link = cifs_hardlink,
++	.mkdir = cifs_mkdir,
++	.rmdir = cifs_rmdir,
++	.rename = cifs_rename,
++	.permission = cifs_permission,
++	.revalidate = cifs_revalidate,  
++	.setattr = cifs_setattr,
++	.symlink = cifs_symlink,
++	.mknod   = cifs_mknod,
++};
++
++struct inode_operations cifs_file_inode_ops = {
++	.revalidate = cifs_revalidate,
++	.setattr = cifs_setattr,
++/*	.getattr = cifs_getattr,*/
++	.rename = cifs_rename,
++	.permission = cifs_permission,
++#ifdef CONFIG_CIFS_XATTR
++	.setxattr = cifs_setxattr,
++	.getxattr = cifs_getxattr,
++	.listxattr = cifs_listxattr,
++	.removexattr = cifs_removexattr,
++#endif 
++};
++
++struct inode_operations cifs_symlink_inode_ops = {
++	.readlink = cifs_readlink,
++	.follow_link = cifs_follow_link,
++	.permission = cifs_permission,
++	/* BB add the following two eventually */
++	/* revalidate: cifs_revalidate,
++	   setattr:    cifs_notify_change, *//* BB do we need notify change */
++#ifdef CONFIG_CIFS_XATTR
++	.setxattr = cifs_setxattr,
++	.getxattr = cifs_getxattr,
++	.listxattr = cifs_listxattr,
++	.removexattr = cifs_removexattr,
++#endif 
++};
++
++struct file_operations cifs_file_ops = {
++	.read = cifs_read_wrapper,
++	.write = cifs_write_wrapper, 
++	.open = cifs_open,
++	.release = cifs_close,
++	.lock = cifs_lock,
++	.fsync = cifs_fsync,
++	.flush = cifs_flush,
++	.mmap  = cifs_file_mmap,
++/*	.sendfile = generic_file_sendfile,*/
++#ifdef CONFIG_CIFS_FCNTL
++	.fcntl = cifs_fcntl,
++#endif
++};
++
++struct file_operations cifs_dir_ops = {
++	.readdir = cifs_readdir,
++	.release = cifs_closedir,
++	.read    = generic_read_dir,
++#ifdef CONFIG_CIFS_FCNTL
++	.fcntl   = cifs_fcntl,
++#endif
++};
++/*
++static void
++cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
++{
++	struct cifsInodeInfo *cifsi = (struct cifsInodeInfo *) inode;
++
++	if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
++	    SLAB_CTOR_CONSTRUCTOR) {
++		inode_init_once(&cifsi->vfs_inode);
++		INIT_LIST_HEAD(&cifsi->lockList);
++	}
++}
++
++static int
++cifs_init_inodecache(void)
++{
++	cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
++					      sizeof (struct cifsInodeInfo),
++					      0, SLAB_HWCACHE_ALIGN,
++					      cifs_init_once, NULL);
++	if (cifs_inode_cachep == NULL)
++		return -ENOMEM;
++	
++
++	return 0;
++}
++
++static void
++cifs_destroy_inodecache(void)
++{
++	if (kmem_cache_destroy(cifs_inode_cachep))
++		printk(KERN_WARNING "cifs_inode_cache: error freeing\n");
++} */
++
++static int
++cifs_init_request_bufs(void)
++{
++	cifs_req_cachep = kmem_cache_create("cifs_request",
++					    CIFS_MAX_MSGSIZE +
++					    MAX_CIFS_HDR_SIZE, 0,
++					    SLAB_HWCACHE_ALIGN, NULL, NULL);
++	if (cifs_req_cachep == NULL)
++		return -ENOMEM;
++
++	return 0;
++}
++
++static void
++cifs_destroy_request_bufs(void)
++{
++	if (kmem_cache_destroy(cifs_req_cachep))
++		printk(KERN_WARNING
++		       "cifs_destroy_request_cache: error not all structures were freed\n");
++}
++
++static int
++cifs_init_mids(void)
++{
++	cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
++				sizeof (struct mid_q_entry), 0,
++				SLAB_HWCACHE_ALIGN, NULL, NULL);
++	if (cifs_mid_cachep == NULL)
++		return -ENOMEM;
++	cifs_oplock_cachep = kmem_cache_create("cifs_oplock_struct",
++				sizeof (struct oplock_q_entry), 0,
++				SLAB_HWCACHE_ALIGN, NULL, NULL);
++	if (cifs_oplock_cachep == NULL) {
++		kmem_cache_destroy(cifs_mid_cachep);
++		return -ENOMEM;
++	}
++
++	return 0;
++}
++
++static void
++cifs_destroy_mids(void)
++{
++	if (kmem_cache_destroy(cifs_mid_cachep))
++		printk(KERN_WARNING
++		       "cifs_destroy_mids: error not all structures were freed\n");
++	if (kmem_cache_destroy(cifs_oplock_cachep))
++		printk(KERN_WARNING
++		       "error not all oplock structures were freed\n");
++}
++
++static int cifs_oplock_thread(void * dummyarg)
++{
++	struct oplock_q_entry * oplock_item;
++	struct cifsTconInfo *pTcon;
++	struct inode * inode;
++	__u16  netfid;
++	int rc = 0;
++
++	daemonize();
++	sprintf(current->comm,"cifsoplockd");
++
++	oplockThread = current;
++	do {
++		set_current_state(TASK_INTERRUPTIBLE);
++		
++		schedule_timeout(1*HZ);  
++		spin_lock(&GlobalMid_Lock);
++		if(list_empty(&GlobalOplock_Q)) {
++			spin_unlock(&GlobalMid_Lock);
++			set_current_state(TASK_INTERRUPTIBLE);
++			schedule_timeout(39*HZ);
++		} else {
++			oplock_item = list_entry(GlobalOplock_Q.next, 
++				struct oplock_q_entry, qhead);
++			if(oplock_item) {
++				cFYI(1,("found oplock item to write out")); 
++				pTcon = oplock_item->tcon;
++				inode = oplock_item->pinode;
++				netfid = oplock_item->netfid;
++				spin_unlock(&GlobalMid_Lock);
++				DeleteOplockQEntry(oplock_item);
++				/* can not grab inode sem here since it would
++				deadlock when oplock received on delete 
++				since vfs_unlink holds the i_sem across
++				the call */
++				/* down(&inode->i_sem);*/
++				if (S_ISREG(inode->i_mode)) {
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,17))
++					rc = filemap_fdatasync(inode->i_mapping);
++					if(rc)
++						CIFS_I(inode)->write_behind_rc = rc;
++#else 
++					filemap_fdatasync(inode->i_mapping);
++#endif
++					if(CIFS_I(inode)->clientCanCacheRead == 0) 
++						invalidate_inode_pages(inode);
++				} else
++					rc = 0;
++				/* releasing a stale oplock after recent reconnection 
++				of smb session using a now incorrect file 
++				handle is not a data integrity issue but do  
++				not bother sending an oplock release if session 
++				to server still is disconnected since oplock 
++				already released by the server in that case */
++				if(pTcon->tidStatus != CifsNeedReconnect) {
++					rc = CIFSSMBLock(0, pTcon, 
++						netfid,
++						0 /* len */ , 0 /* offset */, 0, 
++						0, LOCKING_ANDX_OPLOCK_RELEASE,
++						0 /* wait flag */);
++					cFYI(1,("Oplock release rc = %d ",rc));
++				}
++			} else
++				spin_unlock(&GlobalMid_Lock);
++		}
++	} while(!signal_pending(current));
++	complete_and_exit (&cifs_oplock_exited, 0);
++}
++
++static int __init
++init_cifs(void)
++{
++	int rc = 0;
++#if CONFIG_PROC_FS
++	cifs_proc_init();
++#endif
++	INIT_LIST_HEAD(&GlobalServerList);	/* BB not implemented yet */
++	INIT_LIST_HEAD(&GlobalSMBSessionList);
++	INIT_LIST_HEAD(&GlobalTreeConnectionList);
++	INIT_LIST_HEAD(&GlobalOplock_Q);
++/*
++ *  Initialize Global counters
++ */
++	atomic_set(&sesInfoAllocCount, 0);
++	atomic_set(&tconInfoAllocCount, 0);
++	atomic_set(&tcpSesReconnectCount, 0);
++	atomic_set(&tconInfoReconnectCount, 0);
++
++	atomic_set(&bufAllocCount, 0);
++	atomic_set(&midCount, 0);
++	GlobalCurrentXid = 0;
++	GlobalTotalActiveXid = 0;
++	GlobalMaxActiveXid = 0;
++	GlobalSMBSeslock = RW_LOCK_UNLOCKED;
++	GlobalMid_Lock = SPIN_LOCK_UNLOCKED;
++
++/*	rc = cifs_init_inodecache();*/
++	if (!rc) {
++		rc = cifs_init_mids();
++		if (!rc) {
++			rc = cifs_init_request_bufs();
++			if (!rc) {
++				rc = register_filesystem(&cifs_fs_type);
++				if (!rc) {                
++					kernel_thread(cifs_oplock_thread, NULL, 
++						CLONE_FS | CLONE_FILES | CLONE_VM);
++					return rc; /* Success */
++				} else
++					cifs_destroy_request_bufs();
++			}
++			cifs_destroy_mids();
++		}
++/*		cifs_destroy_inodecache(); */
++	}
++#if CONFIG_PROC_FS
++	cifs_proc_clean();
++#endif
++	return rc;
++}
++
++static void __exit
++exit_cifs(void)
++{
++	cFYI(0, ("In unregister ie exit_cifs"));
++#if CONFIG_PROC_FS
++	cifs_proc_clean();
++#endif
++    	unregister_filesystem(&cifs_fs_type);
++/*	cifs_destroy_inodecache();*/
++	cifs_destroy_mids();
++	cifs_destroy_request_bufs();
++	if(oplockThread) {
++		send_sig(SIGTERM, oplockThread, 1);
++		wait_for_completion(&cifs_oplock_exited);
++	}
++}
++
++MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
++MODULE_LICENSE("GPL");		/* combination of LGPL + GPL source behaves as GPL */
++MODULE_DESCRIPTION
++    ("VFS to access servers complying with the SNIA CIFS Specification e.g. Samba and Windows");
++module_init(init_cifs)
++module_exit(exit_cifs)
+diff -urN linux-2.4.29.old/fs/cifs/cifsfs.h linux-2.4.29/fs/cifs/cifsfs.h
+--- linux-2.4.29.old/fs/cifs/cifsfs.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifsfs.h	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,97 @@
++/*
++ *   fs/cifs/cifsfs.h
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++
++#ifndef _CIFSFS_H
++#define _CIFSFS_H
++
++#define ROOT_I 2
++
++#ifndef FALSE
++#define FALSE 0
++#endif
++
++#ifndef TRUE
++#define TRUE 1
++#endif
++
++extern int map_cifs_error(int error_class, int error_code,
++			  int status_codes_negotiated);
++
++extern struct address_space_operations cifs_addr_ops;
++
++/* Functions related to super block operations */
++extern struct super_operations cifs_super_ops;
++extern void cifs_put_inode(struct inode *);
++extern void cifs_read_inode(struct inode *);
++extern void cifs_delete_inode(struct inode *);
++/* extern void cifs_write_inode(struct inode *); *//* BB not needed yet */
++
++/* Functions related to inodes */
++extern struct inode_operations cifs_dir_inode_ops;
++extern int cifs_create(struct inode *, struct dentry *, int);
++extern struct dentry *cifs_lookup(struct inode *, struct dentry *);
++extern int cifs_unlink(struct inode *, struct dentry *);
++extern int cifs_hardlink(struct dentry *, struct inode *, struct dentry *);
++extern int cifs_mknod(struct inode *, struct dentry *, int, int);
++extern int cifs_mkdir(struct inode *, struct dentry *, int);
++extern int cifs_rmdir(struct inode *, struct dentry *);
++extern int cifs_rename(struct inode *, struct dentry *, struct inode *,
++		       struct dentry *);
++extern int cifs_revalidate(struct dentry *);
++extern int cifs_setattr(struct dentry *, struct iattr *);
++
++extern struct inode_operations cifs_file_inode_ops;
++extern void cifs_truncate_file(struct inode *);
++extern struct inode_operations cifs_symlink_inode_ops;
++
++/* Functions related to files and directories */
++extern struct file_operations cifs_file_ops;
++extern int cifs_open(struct inode *inode, struct file *file);
++extern int cifs_close(struct inode *inode, struct file *file);
++extern int cifs_closedir(struct inode *inode, struct file *file);
++extern ssize_t cifs_read(struct file *file, char *read_data,
++			 size_t read_size, loff_t * poffset);
++extern ssize_t cifs_write(struct file *file, const char *write_data,
++			  size_t write_size, loff_t * poffset);
++extern int cifs_lock(struct file *, int, struct file_lock *);
++extern int cifs_fsync(struct file *, struct dentry *, int);
++extern int cifs_flush(struct file *);
++extern int cifs_file_mmap(struct file * , struct vm_area_struct *);
++extern struct file_operations cifs_dir_ops;
++extern int cifs_dir_open(struct inode *inode, struct file *file);
++extern int cifs_readdir(struct file *file, void *direntry, filldir_t filldir);
++extern long cifs_fcntl(int, unsigned int, unsigned long, struct file *);
++
++/* Functions related to dir entries */
++extern struct dentry_operations cifs_dentry_ops;
++
++/* Functions related to symlinks */
++extern int cifs_follow_link(struct dentry *direntry, struct nameidata *nd);
++extern int cifs_readlink(struct dentry *direntry, char *buffer, int buflen);
++extern int cifs_symlink(struct inode *inode, struct dentry *direntry,
++			const char *symname);
++extern int	cifs_removexattr(struct dentry *, const char *);
++extern int 	cifs_setxattr(struct dentry *, const char *, const void *,
++			 size_t, int);
++extern ssize_t	cifs_getxattr(struct dentry *, const char *, void *, size_t);
++extern ssize_t	cifs_listxattr(struct dentry *, char *, size_t);
++#define CIFS_VERSION   "1.20"
++#endif				/* _CIFSFS_H */
+diff -urN linux-2.4.29.old/fs/cifs/cifs_fs_sb.h linux-2.4.29/fs/cifs/cifs_fs_sb.h
+--- linux-2.4.29.old/fs/cifs/cifs_fs_sb.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifs_fs_sb.h	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,32 @@
++/*
++ *   fs/cifs/cifs_fs_sb.h
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ */
++#ifndef _CIFS_FS_SB_H
++#define _CIFS_FS_SB_H
++
++struct cifs_sb_info {
++	struct cifsTconInfo *tcon;	/* primary mount */
++	struct list_head nested_tcon_q;
++	struct nls_table *local_nls;
++	unsigned int rsize;
++	unsigned int wsize;
++	uid_t	mnt_uid;
++	gid_t	mnt_gid;
++	mode_t	mnt_file_mode;
++	mode_t	mnt_dir_mode;
++};
++#endif				/* _CIFS_FS_SB_H */
+diff -urN linux-2.4.29.old/fs/cifs/cifsglob.h linux-2.4.29/fs/cifs/cifsglob.h
+--- linux-2.4.29.old/fs/cifs/cifsglob.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifsglob.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,413 @@
++/*
++ *   fs/cifs/cifsglob.h
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ * 
++ */
++#include <linux/in.h>
++#include <linux/in6.h>
++#include "cifs_fs_sb.h"
++/*
++ * The sizes of various internal tables and strings
++ */
++#define MAX_UID_INFO 16
++#define MAX_SES_INFO 2
++#define MAX_TCON_INFO 4
++
++#define MAX_TREE_SIZE 2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1
++#define MAX_SERVER_SIZE 15
++#define MAX_SHARE_SIZE  64	/* used to be 20 - this should still be enough */
++#define MAX_USERNAME_SIZE 32	/* 32 is to allow for 15 char names + null
++				   termination then *2 for unicode versions */
++#define MAX_PASSWORD_SIZE 16
++
++/*
++ * MAX_REQ is the maximum number of requests that WE will send
++ * on one socket concurently. It also matches the most common
++ * value of max multiplex returned by servers.  We may 
++ * eventually want to use the negotiated value (in case
++ * future servers can handle more) when we are more confident that
++ * we will not have problems oveloading the socket with pending
++ * write data.
++ */
++#define CIFS_MAX_REQ 50 
++
++#define SERVER_NAME_LENGTH 15
++#define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)
++
++/* used to define string lengths for reversing unicode strings */
++/*         (256+1)*2 = 514                                     */
++/*           (max path length + 1 for null) * 2 for unicode    */
++#define MAX_NAME 514
++
++#include "cifspdu.h"
++
++#ifndef FALSE
++#define FALSE 0
++#endif
++
++#ifndef TRUE
++#define TRUE 1
++#endif
++
++#ifndef XATTR_DOS_ATTRIB
++#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
++#endif
++
++/*
++ * This information is kept on every Server we know about.
++ *
++ * Some things to note:
++ *
++ */
++#define SERVER_NAME_LEN_WITH_NULL	(SERVER_NAME_LENGTH + 1)
++
++/*
++ * CIFS vfs client Status information (based on what we know.)
++ */
++
++ /* associated with each tcp and smb session */
++enum statusEnum {
++	CifsNew = 0,
++	CifsGood,
++	CifsExiting,
++	CifsNeedReconnect
++};
++
++enum securityEnum {
++	NTLM = 0,		/* Legacy NTLM012 auth with NTLM hash */
++	NTLMv2,			/* Legacy NTLM auth with NTLMv2 hash */
++	RawNTLMSSP,		/* NTLMSSP without SPNEGO */
++	NTLMSSP,		/* NTLMSSP via SPNEGO */
++	Kerberos		/* Kerberos via SPNEGO */
++};
++
++enum protocolEnum {
++	IPV4 = 0,
++	IPV6,
++	SCTP
++	/* Netbios frames protocol not supported at this time */
++};
++
++/*
++ *****************************************************************
++ * Except the CIFS PDUs themselves all the
++ * globally interesting structs should go here
++ *****************************************************************
++ */
++
++struct TCP_Server_Info {
++	char server_Name[SERVER_NAME_LEN_WITH_NULL];	/* 15 chars + X'20'in 16th */
++	char unicode_server_Name[SERVER_NAME_LEN_WITH_NULL * 2];	/* Unicode version of server_Name */
++	struct socket *ssocket;
++	union {
++		struct sockaddr_in sockAddr;
++		struct sockaddr_in6 sockAddr6;
++	} addr;
++	wait_queue_head_t response_q; 
++	wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
++	struct list_head pending_mid_q;
++	void *Server_NlsInfo;	/* BB - placeholder for future NLS info  */
++	unsigned short server_codepage;	/* codepage for the server    */
++	unsigned long ip_address;	/* IP addr for the server if known     */
++	enum protocolEnum protocolType;	
++	char versionMajor;
++	char versionMinor;
++	int svlocal:1;		/* local server or remote */
++	atomic_t socketUseCount; /* number of open cifs sessions on socket */
++	atomic_t inFlight;  /* number of requests on the wire to server */
++	enum statusEnum tcpStatus; /* what we think the status is */
++	struct semaphore tcpSem;
++	struct task_struct *tsk;
++	char server_GUID[16];
++	char secMode;
++	enum securityEnum secType;
++	unsigned int maxReq;	/* Clients should submit no more */
++	/* than maxReq distinct unanswered SMBs to the server when using  */
++	/* multiplexed reads or writes */
++	unsigned int maxBuf;	/* maxBuf specifies the maximum */
++	/* message size the server can send or receive for non-raw SMBs */
++	unsigned int maxRw;	/* maxRw specifies the maximum */
++	/* message size the server can send or receive for */
++	/* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
++	char sessid[4];		/* unique token id for this session */
++	/* (returned on Negotiate */
++	int capabilities; /* allow selective disabling of caps by smb sess */
++	__u16 timeZone;
++	char cryptKey[CIFS_CRYPTO_KEY_SIZE];
++	char workstation_RFC1001_name[16]; /* 16th byte is always zero */
++};
++
++/*
++ * The following is our shortcut to user information.  We surface the uid,
++ * and name. We always get the password on the fly in case it
++ * has changed. We also hang a list of sessions owned by this user off here. 
++ */
++struct cifsUidInfo {
++	struct list_head userList;
++	struct list_head sessionList; /* SMB sessions for this user */
++	uid_t linux_uid;
++	char user[MAX_USERNAME_SIZE + 1];	/* ascii name of user */
++	/* BB may need ptr or callback for PAM or WinBind info */
++};
++
++/*
++ * Session structure.  One of these for each uid session with a particular host
++ */
++struct cifsSesInfo {
++	struct list_head cifsSessionList;
++	struct semaphore sesSem;
++	struct cifsUidInfo *uidInfo;	/* pointer to user info */
++	struct TCP_Server_Info *server;	/* pointer to server info */
++	atomic_t inUse; /* # of mounts (tree connections) on this ses */
++	enum statusEnum status;
++	__u32 sequence_number;  /* needed for CIFS PDU signature */
++	__u16 ipc_tid;		/* special tid for connection to IPC share */
++	char mac_signing_key[CIFS_SESSION_KEY_SIZE + 16];	
++	char *serverOS;		/* name of operating system underlying the server */
++	char *serverNOS;	/* name of network operating system that the server is running */
++	char *serverDomain;	/* security realm of server */
++	int Suid;		/* remote smb uid  */
++	uid_t linux_uid;        /* local Linux uid */
++	int capabilities;
++	char serverName[SERVER_NAME_LEN_WITH_NULL * 2];	/* BB make bigger for tcp names - will ipv6 and sctp addresses fit here?? */
++	char userName[MAX_USERNAME_SIZE + 1];
++	char domainName[MAX_USERNAME_SIZE + 1];
++	char * password;
++};
++
++/*
++ * there is one of these for each connection to a resource on a particular
++ * session 
++ */
++struct cifsTconInfo {
++	struct list_head cifsConnectionList;
++	struct list_head openFileList;
++	struct semaphore tconSem;
++	struct cifsSesInfo *ses;	/* pointer to session associated with */
++	char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource (in ASCII not UTF) */
++	char *nativeFileSystem;
++	__u16 tid;		/* The 2 byte tree id */
++	__u16 Flags;		/* optional support bits */
++	enum statusEnum tidStatus;
++	atomic_t useCount;	/* how many mounts (explicit or implicit) to this share */
++#ifdef CONFIG_CIFS_STATS
++	atomic_t num_smbs_sent;
++	atomic_t num_writes;
++	atomic_t num_reads;
++	atomic_t num_oplock_brks;
++	atomic_t num_opens;
++	atomic_t num_deletes;
++	atomic_t num_mkdirs;
++	atomic_t num_rmdirs;
++	atomic_t num_renames;
++	atomic_t num_t2renames;
++	__u64    bytes_read;
++	__u64    bytes_written;
++	spinlock_t stat_lock;
++#endif
++	FILE_SYSTEM_DEVICE_INFO fsDevInfo;
++	FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo;	/* ok if file system name truncated */
++	FILE_SYSTEM_UNIX_INFO fsUnixInfo;
++	int retry:1;
++	/* BB add field for back pointer to sb struct? */
++};
++
++/*
++ * This info hangs off the cifsFileInfo structure.  This is used to track
++ * byte stream locks on the file
++ */
++struct cifsLockInfo {
++	struct cifsLockInfo *next;
++	int start;
++	int length;
++	int type;
++};
++
++/*
++ * One of these for each open instance of a file
++ */
++struct cifsFileInfo {
++	struct list_head tlist;	/* pointer to next fid owned by tcon */
++	struct list_head flist;	/* next fid (file instance) for this inode */
++	unsigned int uid;	/* allows finding which FileInfo structure */
++	__u32 pid;		/* process id who opened file */
++	__u16 netfid;		/* file id from remote */
++	/* BB add lock scope info here if needed */ ;
++	/* lock scope id (0 if none) */
++	struct file * pfile; /* needed for writepage */
++	struct inode * pInode; /* needed for oplock break */
++	int endOfSearch:1;	/* we have reached end of search */
++	int closePend:1;	/* file is marked to close */
++	int emptyDir:1;
++	int invalidHandle:1;  /* file closed via session abend */
++	struct semaphore fh_sem; /* prevents reopen race after dead ses*/
++	char * search_resume_name;
++	unsigned int resume_name_length;
++	__u32 resume_key;
++};
++
++/*
++ * One of these for each file inode
++ */
++
++struct cifsInodeInfo {
++	struct list_head lockList;
++	/* BB add in lists for dirty pages - i.e. write caching info for oplock */
++	struct list_head openFileList;
++	int write_behind_rc;
++	__u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
++	atomic_t inUse;	 /* num concurrent users (local openers cifs) of file*/
++	unsigned long time;	/* jiffies of last update/check of inode */
++	int clientCanCacheRead:1; /* read oplock */
++	int clientCanCacheAll:1;  /* read and writebehind oplock */
++	int oplockPending:1;
++	struct inode vfs_inode;
++};
++
++static inline struct cifsInodeInfo * CIFS_I(struct inode *inode)
++{
++        return (struct cifsInodeInfo *)&(inode->u);
++}
++
++static inline struct cifs_sb_info * CIFS_SB(struct super_block *sb)
++{
++        return (struct cifs_sb_info *) &(sb->u);
++}
++
++
++/* one of these for every pending CIFS request to the server */
++struct mid_q_entry {
++	struct list_head qhead;	/* mids waiting on reply from this server */
++	__u16 mid;		/* multiplex id */
++	__u16 pid;		/* process id */
++	__u32 sequence_number;  /* for CIFS signing */
++	__u16 command;		/* smb command code */
++	struct timeval when_sent;	/* time when smb sent */
++	struct cifsSesInfo *ses;	/* smb was sent to this server */
++	struct task_struct *tsk;	/* task waiting for response */
++	struct smb_hdr *resp_buf;	/* response buffer */
++	int midState;	/* wish this were enum but can not pass to wait_event */
++};
++
++struct oplock_q_entry {
++	struct list_head qhead;
++	struct inode * pinode;
++	struct cifsTconInfo * tcon; 
++	__u16 netfid;
++};
++
++#define   MID_FREE 0
++#define   MID_REQUEST_ALLOCATED 1
++#define   MID_REQUEST_SUBMITTED 2
++#define   MID_RESPONSE_RECEIVED 4
++#define   MID_RETRY_NEEDED      8 /* session closed while this request out */
++
++/*
++ *****************************************************************
++ * All constants go here
++ *****************************************************************
++ */
++
++#define UID_HASH (16)
++
++/*
++ * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
++ * following to be declared.
++ */
++
++/****************************************************************************
++ *  Locking notes.  All updates to global variables and lists should be
++ *                  protected by spinlocks or semaphores.
++ *
++ *  Spinlocks
++ *  ---------
++ *  GlobalMid_Lock protects:
++ *	list operations on pending_mid_q and oplockQ
++ *      updates to XID counters, multiplex id  and SMB sequence numbers
++ *  GlobalSMBSesLock protects:
++ *	list operations on tcp and SMB session lists and tCon lists
++ *  f_owner.lock protects certain per file struct operations
++ *  mapping->page_lock protects certain per page operations
++ *
++ *  Semaphores
++ *  ----------
++ *  sesSem     operations on smb session
++ *  tconSem    operations on tree connection
++ *  fh_sem      file handle reconnection operations 
++ *
++ ****************************************************************************/
++
++#ifdef DECLARE_GLOBALS_HERE
++#define GLOBAL_EXTERN
++#else
++#define GLOBAL_EXTERN extern
++#endif
++
++/*
++ * The list of servers that did not respond with NT LM 0.12.
++ * This list helps improve performance and eliminate the messages indicating
++ * that we had a communications error talking to the server in this list. 
++ */
++GLOBAL_EXTERN struct servers_not_supported *NotSuppList;	/*@z4a */
++
++/*
++ * The following is a hash table of all the users we know about.
++ */
++GLOBAL_EXTERN struct smbUidInfo *GlobalUidList[UID_HASH];
++
++GLOBAL_EXTERN struct list_head GlobalServerList; /* BB not implemented yet */
++GLOBAL_EXTERN struct list_head GlobalSMBSessionList;
++GLOBAL_EXTERN struct list_head GlobalTreeConnectionList;
++GLOBAL_EXTERN rwlock_t GlobalSMBSeslock;  /* protects list inserts on 3 above */
++
++GLOBAL_EXTERN struct list_head GlobalOplock_Q;
++
++/*
++ * Global transaction id (XID) information
++ */
++GLOBAL_EXTERN unsigned int GlobalCurrentXid;	/* protected by GlobalMid_Sem */
++GLOBAL_EXTERN unsigned int GlobalTotalActiveXid;	/* prot by GlobalMid_Sem */
++GLOBAL_EXTERN unsigned int GlobalMaxActiveXid;	/* prot by GlobalMid_Sem */
++GLOBAL_EXTERN spinlock_t GlobalMid_Lock;  /* protects above and list operations */
++					/* on midQ entries */
++GLOBAL_EXTERN char Local_System_Name[15];
++
++/*
++ *  Global counters, updated atomically
++ */
++GLOBAL_EXTERN atomic_t sesInfoAllocCount;
++GLOBAL_EXTERN atomic_t tconInfoAllocCount;
++
++GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
++GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
++
++/* Various Debug counters to remove someday (BB) */
++GLOBAL_EXTERN atomic_t bufAllocCount;
++GLOBAL_EXTERN atomic_t midCount;
++
++/* Misc globals */
++GLOBAL_EXTERN unsigned int multiuser_mount;	/* if enabled allows new sessions
++				to be established on existing mount if we
++				have the uid/password or Kerberos credential 
++				or equivalent for current user */
++GLOBAL_EXTERN unsigned int oplockEnabled;
++GLOBAL_EXTERN unsigned int quotaEnabled;
++GLOBAL_EXTERN unsigned int lookupCacheEnabled;
++GLOBAL_EXTERN unsigned int extended_security;	/* if on, session setup sent 
++				with more secure ntlmssp2 challenge/resp */
++GLOBAL_EXTERN unsigned int ntlmv2_support;  /* better optional password hash */
++GLOBAL_EXTERN unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
++GLOBAL_EXTERN unsigned int linuxExtEnabled;  /* enable Linux/Unix CIFS extensions */
++
+diff -urN linux-2.4.29.old/fs/cifs/cifspdu.h linux-2.4.29/fs/cifs/cifspdu.h
+--- linux-2.4.29.old/fs/cifs/cifspdu.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifspdu.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,1793 @@
++/*
++ *   fs/cifs/cifspdu.h
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++
++#ifndef _CIFSPDU_H
++#define _CIFSPDU_H
++
++#include <net/sock.h>
++
++#define CIFS_PROT   0
++#define BAD_PROT    CIFS_PROT+1
++
++/* SMB command codes */
++#define SMB_COM_CREATE_DIRECTORY      0x00
++#define SMB_COM_DELETE_DIRECTORY      0x01
++#define SMB_COM_CLOSE                 0x04
++#define SMB_COM_DELETE                0x06
++#define SMB_COM_RENAME                0x07
++#define SMB_COM_LOCKING_ANDX          0x24
++#define SMB_COM_COPY                  0x29
++#define SMB_COM_READ_ANDX             0x2E
++#define SMB_COM_WRITE_ANDX            0x2F
++#define SMB_COM_TRANSACTION2          0x32
++#define SMB_COM_TRANSACTION2_SECONDARY 0x33
++#define SMB_COM_FIND_CLOSE2           0x34
++#define SMB_COM_TREE_DISCONNECT       0x71
++#define SMB_COM_NEGOTIATE             0x72
++#define SMB_COM_SESSION_SETUP_ANDX    0x73
++#define SMB_COM_LOGOFF_ANDX           0x74
++#define SMB_COM_TREE_CONNECT_ANDX     0x75
++#define SMB_COM_NT_TRANSACT           0xA0
++#define SMB_COM_NT_TRANSACT_SECONDARY 0xA1
++#define SMB_COM_NT_CREATE_ANDX        0xA2
++#define SMB_COM_NT_RENAME             0xA5
++
++/* Transact2 subcommand codes */
++#define TRANS2_OPEN                   0x00
++#define TRANS2_FIND_FIRST             0x01
++#define TRANS2_FIND_NEXT              0x02
++#define TRANS2_QUERY_FS_INFORMATION   0x03
++#define TRANS2_QUERY_PATH_INFORMATION 0x05
++#define TRANS2_SET_PATH_INFORMATION   0x06
++#define TRANS2_QUERY_FILE_INFORMATION 0x07
++#define TRANS2_SET_FILE_INFORMATION   0x08
++#define TRANS2_GET_DFS_REFERRAL       0x10
++#define TRANS2_REPORT_DFS_INCOSISTENCY 0x11
++
++/* NT Transact subcommand codes */
++#define NT_TRANSACT_CREATE            0x01
++#define NT_TRANSACT_IOCTL             0x02
++#define NT_TRANSACT_SET_SECURITY_DESC 0x03
++#define NT_TRANSACT_NOTIFY_CHANGE     0x04
++#define NT_TRANSACT_RENAME            0x05
++#define NT_TRANSACT_QUERY_SECURITY_DESC 0x06
++#define NT_TRANSACT_GET_USER_QUOTA    0x07
++#define NT_TRANSACT_SET_USER_QUOTA    0x08
++
++#define MAX_CIFS_HDR_SIZE 256	/* chained NTCreateXReadX will probably be biggest */
++
++/* internal cifs vfs structures */
++/*****************************************************************
++ * All constants go here
++ *****************************************************************
++ */
++
++/*
++ * Starting value for maximum SMB size negotiation
++ */
++#define CIFS_MAX_MSGSIZE (4*4096)
++
++/*
++ * Size of encrypted user password in bytes
++ */
++#define CIFS_ENCPWD_SIZE (16)
++
++/*
++ * Size of the crypto key returned on the negotiate SMB in bytes
++ */
++#define CIFS_CRYPTO_KEY_SIZE (8)
++
++/*
++ * Size of the session key (crypto key encrypted with the password
++ */
++#define CIFS_SESSION_KEY_SIZE (24)
++
++/*
++ * Maximum user name length
++ */
++#define CIFS_UNLEN (20)
++
++/*
++ * Flags on SMB open
++ */
++#define SMBOPEN_WRITE_THROUGH 0x4000
++#define SMBOPEN_DENY_ALL      0x0010
++#define SMBOPEN_DENY_WRITE    0x0020
++#define SMBOPEN_DENY_READ     0x0030
++#define SMBOPEN_DENY_NONE     0x0040
++#define SMBOPEN_READ          0x0000
++#define SMBOPEN_WRITE         0x0001
++#define SMBOPEN_READWRITE     0x0002
++#define SMBOPEN_EXECUTE       0x0003
++
++#define SMBOPEN_OCREATE       0x0010
++#define SMBOPEN_OTRUNC        0x0002
++#define SMBOPEN_OAPPEND       0x0001
++
++/*
++ * SMB flag definitions 
++ */
++#define SMBFLG_EXTD_LOCK 0x01	/* server supports lock-read write-unlock primitives */
++#define SMBFLG_RCV_POSTED 0x02	/* obsolete */
++#define SMBFLG_RSVD 0x04
++#define SMBFLG_CASELESS 0x08	/* all pathnames treated as caseless (off implies case sensitive file handling requested) */
++#define SMBFLG_CANONICAL_PATH_FORMAT 0x10	/* obsolete */
++#define SMBFLG_OLD_OPLOCK 0x20	/* obsolete */
++#define SMBFLG_OLD_OPLOCK_NOTIFY 0x40	/* obsolete */
++#define SMBFLG_RESPONSE 0x80	/* this PDU is a response from server */
++
++/*
++ * SMB flag2 definitions 
++ */
++#define SMBFLG2_KNOWS_LONG_NAMES 0x0001	/* can send long (non-8.3) path names in response */
++#define SMBFLG2_KNOWS_EAS 0x0002
++#define SMBFLG2_SECURITY_SIGNATURE 0x0004
++#define SMBFLG2_IS_LONG_NAME 0x0040
++#define SMBFLG2_EXT_SEC 0x0800
++#define SMBFLG2_DFS 0x1000
++#define SMBFLG2_PAGING_IO 0x2000
++#define SMBFLG2_ERR_STATUS 0x4000
++#define SMBFLG2_UNICODE 0x8000
++
++/*
++ * These are the file access permission bits defined in CIFS for the
++ * NTCreateAndX as well as the level 0x107
++ * TRANS2_QUERY_PATH_INFORMATION API.  The level 0x107, SMB_QUERY_FILE_ALL_INFO
++ * responds with the AccessFlags.
++ * The AccessFlags specifies the access permissions a caller has to the
++ * file and can have any suitable combination of the following values:
++ */
++
++#define FILE_READ_DATA        0x00000001	/* Data can be read from the file   */
++#define FILE_WRITE_DATA       0x00000002	/* Data can be written to the file  */
++#define FILE_APPEND_DATA      0x00000004	/* Data can be appended to the file */
++#define FILE_READ_EA          0x00000008	/* Extended attributes associated   */
++					 /* with the file can be read        */
++#define FILE_WRITE_EA         0x00000010	/* Extended attributes associated   */
++					 /* with the file can be written     */
++#define FILE_EXECUTE          0x00000020	/*Data can be read into memory from */
++					 /* the file using system paging I/O */
++#define FILE_DELETE_CHILD     0x00000040
++#define FILE_READ_ATTRIBUTES  0x00000080	/* Attributes associated with the   */
++					 /* file can be read                 */
++#define FILE_WRITE_ATTRIBUTES 0x00000100	/* Attributes associated with the   */
++					 /* file can be written              */
++#define DELETE                0x00010000	/* The file can be deleted          */
++#define READ_CONTROL          0x00020000	/* The access control list and      */
++					 /* ownership associated with the    */
++					 /* file can be read                 */
++#define WRITE_DAC             0x00040000	/* The access control list and      */
++					 /* ownership associated with the    */
++					 /* file can be written.             */
++#define WRITE_OWNER           0x00080000	/* Ownership information associated */
++					 /* with the file can be written     */
++#define SYNCHRONIZE           0x00100000	/* The file handle can waited on to */
++					 /* synchronize with the completion  */
++					 /* of an input/output request       */
++#define GENERIC_ALL           0x10000000
++#define GENERIC_EXECUTE       0x20000000
++#define GENERIC_WRITE         0x40000000
++#define GENERIC_READ          0x80000000
++					 /* In summary - Relevant file       */
++					 /* access flags from CIFS are       */
++					 /* file_read_data, file_write_data  */
++					 /* file_execute, file_read_attributes */
++					 /* write_dac, and delete.           */
++
++/*
++ * Invalid readdir handle
++ */
++#define CIFS_NO_HANDLE        0xFFFF
++
++/* IPC$ in ASCII */
++#define CIFS_IPC_RESOURCE "\x49\x50\x43\x24"
++
++/* IPC$ in Unicode */
++#define CIFS_IPC_UNICODE_RESOURCE "\x00\x49\x00\x50\x00\x43\x00\x24\x00\x00"
++
++/* Unicode Null terminate 2 bytes of 0 */
++#define UNICODE_NULL "\x00\x00"
++#define ASCII_NULL 0x00
++
++/*
++ * Server type values (returned on EnumServer API
++ */
++#define CIFS_SV_TYPE_DC     0x00000008
++#define CIFS_SV_TYPE_BACKDC 0x00000010
++
++/*
++ * Alias type flags (From EnumAlias API call
++ */
++#define CIFS_ALIAS_TYPE_FILE 0x0001
++#define CIFS_SHARE_TYPE_FILE 0x0000
++
++/*
++ * File Attribute flags
++ */
++#define ATTR_READONLY  0x0001
++#define ATTR_HIDDEN    0x0002
++#define ATTR_SYSTEM    0x0004
++#define ATTR_VOLUME    0x0008
++#define ATTR_DIRECTORY 0x0010
++#define ATTR_ARCHIVE   0x0020
++#define ATTR_DEVICE    0x0040
++#define ATTR_NORMAL    0x0080
++#define ATTR_TEMPORARY 0x0100
++#define ATTR_SPARSE    0x0200
++#define ATTR_REPARSE   0x0400
++#define ATTR_COMPRESSED 0x0800
++#define ATTR_OFFLINE    0x1000	/* ie file not immediately available - offline storage */
++#define ATTR_NOT_CONTENT_INDEXED 0x2000
++#define ATTR_ENCRYPTED  0x4000
++#define ATTR_POSIX_SEMANTICS 0x01000000
++#define ATTR_BACKUP_SEMANTICS 0x02000000
++#define ATTR_DELETE_ON_CLOSE 0x04000000
++#define ATTR_SEQUENTIAL_SCAN 0x08000000
++#define ATTR_RANDOM_ACCESS   0x10000000
++#define ATTR_NO_BUFFERING    0x20000000
++#define ATTR_WRITE_THROUGH   0x80000000
++
++/* ShareAccess flags */
++#define FILE_NO_SHARE     0x00000000
++#define FILE_SHARE_READ   0x00000001
++#define FILE_SHARE_WRITE  0x00000002
++#define FILE_SHARE_DELETE 0x00000004
++#define FILE_SHARE_ALL    0x00000007
++
++/* CreateDisposition flags */
++#define FILE_SUPERSEDE    0x00000000
++#define FILE_OPEN         0x00000001
++#define FILE_CREATE       0x00000002
++#define FILE_OPEN_IF      0x00000003
++#define FILE_OVERWRITE    0x00000004
++#define FILE_OVERWRITE_IF 0x00000005
++
++/* CreateOptions */
++#define CREATE_NOT_FILE		0x00000001	/* if set must not be file */
++#define CREATE_WRITE_THROUGH	0x00000002
++#define CREATE_NOT_DIR		0x00000040	/* if set must not be directory */
++#define CREATE_RANDOM_ACCESS	0x00000800
++#define CREATE_DELETE_ON_CLOSE	0x00001000
++#define OPEN_REPARSE_POINT	0x00200000
++
++/* ImpersonationLevel flags */
++#define SECURITY_ANONYMOUS      0
++#define SECURITY_IDENTIFICATION 1
++#define SECURITY_IMPERSONATION  2
++#define SECURITY_DELEGATION     3
++
++/* SecurityFlags */
++#define SECURITY_CONTEXT_TRACKING 0x01
++#define SECURITY_EFFECTIVE_ONLY   0x02
++
++/*
++ * Default PID value, used in all SMBs where the PID is not important
++ */
++#define CIFS_DFT_PID  0x1234
++
++/*
++ * We use the same routine for Copy and Move SMBs.  This flag is used to
++ * distinguish
++ */
++#define CIFS_COPY_OP 1
++#define CIFS_RENAME_OP 2
++
++#define GETU16(var)  (*((__u16 *)var))	/* BB check for endian issues */
++#define GETU32(var)  (*((__u32 *)var))	/* BB check for endian issues */
++
++#pragma pack(1)
++
++struct smb_hdr {
++	__u32 smb_buf_length;	/* big endian on wire *//* BB length is only two or three bytes - with one or two byte type preceding it but that is always zero - we could mask the type byte off just in case BB */
++	__u8 Protocol[4];
++	__u8 Command;
++	union {
++		struct {
++			__u8 ErrorClass;
++			__u8 Reserved;
++			__u16 Error;	/* note: treated as little endian (le) on wire */
++		} DosError;
++		__u32 CifsError;	/* note: le */
++	} Status;
++	__u8 Flags;
++	__u16 Flags2;		/* note: le */
++	__u16 PidHigh;		/* note: le */
++	union {
++		struct {
++			__u32 SequenceNumber;  /* le */
++			__u32 Reserved; /* zero */
++		} Sequence;
++		__u8 SecuritySignature[8];	/* le */
++	} Signature;
++	__u8 pad[2];
++	__u16 Tid;
++	__u16 Pid;		/* note: le */
++	__u16 Uid;
++	__u16 Mid;
++	__u8 WordCount;
++};
++/* given a pointer to an smb_hdr retrieve the value of byte count */
++#define BCC(smb_var) ( *(__u16 *)((char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) ) )
++
++/* given a pointer to an smb_hdr retrieve the pointer to the byte area */
++#define pByteArea(smb_var) ((char *)smb_var + sizeof(struct smb_hdr) + (2* smb_var->WordCount) + 2 )
++
++/*
++ * Computer Name Length
++ */
++#define CNLEN 15
++
++/*
++ * Share Name Length					  @S8A
++ * Note:  This length is limited by the SMB used to get   @S8A
++ *        the Share info.   NetShareEnum only returns 13  @S8A
++ *        chars, including the null termination.          @S8A 
++ */
++#define SNLEN 12		/*@S8A */
++
++/*
++ * Comment Length
++ */
++#define MAXCOMMENTLEN 40
++
++/*
++ * The OS/2 maximum path name
++ */
++#define MAX_PATHCONF 256
++
++/*
++ *  SMB frame definitions  (following must be packed structs)
++ *  See the SNIA CIFS Specification for details.
++ *
++ *  The Naming convention is the lower case version of the
++ *  smb command code name for the struct and this is typedef to the
++ *  uppercase version of the same name with the prefix SMB_ removed 
++ *  for brevity.  Although typedefs are not commonly used for 
++ *  structure definitions in the Linux kernel, their use in the
++ *  CIFS standards document, which this code is based on, may
++ *  make this one of the cases where typedefs for structures make
++ *  sense to improve readability for readers of the standards doc.
++ *  Typedefs can always be removed later if they are too distracting
++ *  and they are only used for the CIFSs PDUs themselves, not
++ *  internal cifs vfs structures
++ *  
++ */
++
++typedef struct negotiate_req {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;
++	unsigned char DialectsArray[1];
++} NEGOTIATE_REQ;
++
++typedef struct negotiate_rsp {
++	struct smb_hdr hdr;	/* wct = 17 */
++	__u16 DialectIndex;
++	__u8 SecurityMode;
++	__u16 MaxMpxCount;
++	__u16 MaxNumberVcs;
++	__u32 MaxBufferSize;
++	__u32 MaxRawSize;
++	__u32 SessionKey;
++	__u32 Capabilities;	/* see below */
++	__u32 SystemTimeLow;
++	__u32 SystemTimeHigh;
++	__u16 ServerTimeZone;
++	__u8 EncryptionKeyLength;
++	__u16 ByteCount;
++	union {
++		unsigned char EncryptionKey[1];	/* if cap extended security is off */
++		/* followed by Domain name - if extended security is off */
++		/* followed by 16 bytes of server GUID */
++		/* followed by security blob if cap_extended_security negotiated */
++		struct {
++			unsigned char GUID[16];
++			unsigned char SecurityBlob[1];
++		} extended_response;
++	} u;
++} NEGOTIATE_RSP;
++
++/* SecurityMode bits */
++#define SECMODE_USER          0x01	/* off indicates share level security */
++#define SECMODE_PW_ENCRYPT    0x02
++#define SECMODE_SIGN_ENABLED  0x04	/* SMB security signatures enabled */
++#define SECMODE_SIGN_REQUIRED 0x08	/* SMB security signatures required */
++
++/* Negotiate response Capabilities */
++#define CAP_RAW_MODE           0x00000001
++#define CAP_MPX_MODE           0x00000002
++#define CAP_UNICODE            0x00000004
++#define CAP_LARGE_FILES        0x00000008
++#define CAP_NT_SMBS            0x00000010	/* implies CAP_NT_FIND */
++#define CAP_RPC_REMOTE_APIS    0x00000020
++#define CAP_STATUS32           0x00000040
++#define CAP_LEVEL_II_OPLOCKS   0x00000080
++#define CAP_LOCK_AND_READ      0x00000100
++#define CAP_NT_FIND            0x00000200
++#define CAP_DFS                0x00001000
++#define CAP_INFOLEVEL_PASSTHRU 0x00002000
++#define CAP_LARGE_READ_X       0x00004000
++#define CAP_LARGE_WRITE_X      0x00008000
++#define CAP_UNIX               0x00800000
++#define CAP_RESERVED           0x02000000
++#define CAP_BULK_TRANSFER      0x20000000
++#define CAP_COMPRESSED_DATA    0x40000000
++#define CAP_EXTENDED_SECURITY  0x80000000
++
++typedef union smb_com_session_setup_andx {
++	struct {		/* request format */
++		struct smb_hdr hdr;	/* wct = 12 */
++		__u8 AndXCommand;
++		__u8 AndXReserved;
++		__u16 AndXOffset;
++		__u16 MaxBufferSize;
++		__u16 MaxMpxCount;
++		__u16 VcNumber;
++		__u32 SessionKey;
++		__u16 SecurityBlobLength;
++		__u32 Reserved;
++		__u32 Capabilities;	/* see below */
++		__u16 ByteCount;
++		unsigned char SecurityBlob[1];	/* followed by */
++		/* STRING NativeOS */
++		/* STRING NativeLanMan */
++	} req;			/* NTLM request format (with extended security */
++
++	struct {		/* request format */
++		struct smb_hdr hdr;	/* wct = 13 */
++		__u8 AndXCommand;
++		__u8 AndXReserved;
++		__u16 AndXOffset;
++		__u16 MaxBufferSize;
++		__u16 MaxMpxCount;
++		__u16 VcNumber;
++		__u32 SessionKey;
++		__u16 CaseInsensitivePasswordLength;	/* ASCII password length */
++		__u16 CaseSensitivePasswordLength;	/* Unicode password length */
++		__u32 Reserved;	/* see below */
++		__u32 Capabilities;
++		__u16 ByteCount;
++		unsigned char CaseInsensitivePassword[1];	/* followed by: */
++		/* unsigned char * CaseSensitivePassword; */
++		/* STRING AccountName */
++		/* STRING PrimaryDomain */
++		/* STRING NativeOS */
++		/* STRING NativeLanMan */
++	} req_no_secext;	/* NTLM request format (without extended security */
++
++	struct {		/* default (NTLM) response format */
++		struct smb_hdr hdr;	/* wct = 4 */
++		__u8 AndXCommand;
++		__u8 AndXReserved;
++		__u16 AndXOffset;
++		__u16 Action;	/* see below */
++		__u16 SecurityBlobLength;
++		__u16 ByteCount;
++		unsigned char SecurityBlob[1];	/* followed by */
++/*      unsigned char  * NativeOS;      */
++/*	unsigned char  * NativeLanMan;  */
++/*      unsigned char  * PrimaryDomain; */
++	} resp;			/* NTLM response format (with or without extended security */
++
++	struct {		/* request format */
++		struct smb_hdr hdr;	/* wct = 10 */
++		__u8 AndXCommand;
++		__u8 AndXReserved;
++		__u16 AndXOffset;
++		__u16 MaxBufferSize;
++		__u16 MaxMpxCount;
++		__u16 VcNumber;
++		__u32 SessionKey;
++		__u16 PassswordLength;
++		__u32 Reserved;
++		__u16 ByteCount;
++		unsigned char AccountPassword[1];	/* followed by */
++		/* STRING AccountName */
++		/* STRING PrimaryDomain */
++		/* STRING NativeOS */
++		/* STRING NativeLanMan */
++	} old_req;		/* pre-NTLM (LANMAN2.1) request format */
++
++	struct {		/* default (NTLM) response format */
++		struct smb_hdr hdr;	/* wct = 3 */
++		__u8 AndXCommand;
++		__u8 AndXReserved;
++		__u16 AndXOffset;
++		__u16 Action;	/* see below */
++		__u16 ByteCount;
++		unsigned char NativeOS[1];	/* followed by */
++/*	unsigned char * NativeLanMan; */
++/*      unsigned char * PrimaryDomain; */
++	} old_resp;		/* pre-NTLM (LANMAN2.1) response format */
++} SESSION_SETUP_ANDX;
++
++#define CIFS_NETWORK_OPSYS "CIFS VFS Client for Linux"
++
++/* Capabilities bits (for NTLM SessSetup request) */
++#define CAP_UNICODE            0x00000004
++#define CAP_LARGE_FILES        0x00000008
++#define CAP_NT_SMBS            0x00000010
++#define CAP_STATUS32           0x00000040
++#define CAP_LEVEL_II_OPLOCKS   0x00000080
++#define CAP_NT_FIND            0x00000200	/* reserved should be zero (presumably because NT_SMBs implies the same thing) */
++#define CAP_BULK_TRANSFER      0x20000000
++#define CAP_EXTENDED_SECURITY  0x80000000
++
++/* Action bits */
++#define GUEST_LOGIN 1
++
++typedef struct smb_com_tconx_req {
++	struct smb_hdr hdr;	/* wct = 4 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 Flags;		/* see below */
++	__u16 PasswordLength;
++	__u16 ByteCount;
++	unsigned char Password[1];	/* followed by */
++/* STRING Path    *//* \\server\share name */
++	/* STRING Service */
++} TCONX_REQ;
++
++typedef struct smb_com_tconx_rsp {
++	struct smb_hdr hdr;	/* wct = 3 *//* note that Win2000 has sent wct=7 in some cases on responses. Four unspecified words followed OptionalSupport */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 OptionalSupport;	/* see below */
++	__u16 ByteCount;
++	unsigned char Service[1];	/* always ASCII, not Unicode */
++	/* STRING NativeFileSystem */
++} TCONX_RSP;
++
++/* tree connect Flags */
++#define DISCONNECT_TID          0x0001
++#define TCON_EXTENDED_SECINFO   0x0008
++/* OptionalSupport bits */
++#define SMB_SUPPORT_SEARCH_BITS 0x0001	/* must have bits (exclusive searches suppt. */
++#define SMB_SHARE_IS_IN_DFS     0x0002
++
++typedef struct smb_com_logoff_andx_req {
++
++	struct smb_hdr hdr;	/* wct = 2 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 ByteCount;
++} LOGOFF_ANDX_REQ;
++
++typedef struct smb_com_logoff_andx_rsp {
++	struct smb_hdr hdr;	/* wct = 2 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 ByteCount;
++} LOGOFF_ANDX_RSP;
++
++typedef union smb_com_tree_disconnect {	/* as an altetnative can use flag on tree_connect PDU to effect disconnect *//* probably the simplest SMB PDU */
++	struct {
++		struct smb_hdr hdr;	/* wct = 0 */
++		__u16 ByteCount;	/* bcc = 0 */
++	} req;
++	struct {
++		struct smb_hdr hdr;	/* wct = 0 */
++		__u16 ByteCount;	/* bcc = 0 */
++	} resp;
++} TREE_DISCONNECT;
++
++typedef struct smb_com_close_req {
++	struct smb_hdr hdr;	/* wct = 3 */
++	__u16 FileID;
++	__u32 LastWriteTime;	/* should be zero */
++	__u16 ByteCount;	/* 0 */
++} CLOSE_REQ;
++
++typedef struct smb_com_close_rsp {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;	/* bct = 0 */
++} CLOSE_RSP;
++
++typedef struct smb_com_findclose_req {
++	struct smb_hdr hdr; /* wct = 1 */
++	__u16 FileID;
++	__u16 ByteCount;    /* 0 */
++} FINDCLOSE_REQ;
++
++/* OpenFlags */
++#define REQ_OPLOCK         0x00000002
++#define REQ_BATCHOPLOCK    0x00000004
++#define REQ_OPENDIRONLY    0x00000008
++
++typedef struct smb_com_open_req {	/* also handles create */
++	struct smb_hdr hdr;	/* wct = 24 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u8 Reserved;		/* Must Be Zero */
++	__u16 NameLength;
++	__u32 OpenFlags;
++	__u32 RootDirectoryFid;
++	__u32 DesiredAccess;
++	__u64 AllocationSize;
++	__u32 FileAttributes;
++	__u32 ShareAccess;
++	__u32 CreateDisposition;
++	__u32 CreateOptions;
++	__u32 ImpersonationLevel;
++	__u8 SecurityFlags;
++	__u16 ByteCount;
++	char fileName[1];
++} OPEN_REQ;
++
++/* open response: oplock levels */
++#define OPLOCK_NONE  	 0
++#define OPLOCK_EXCLUSIVE 1
++#define OPLOCK_BATCH	 2
++#define OPLOCK_READ	 3  /* level 2 oplock */
++
++/* open response for CreateAction shifted left */
++#define CIFS_CREATE_ACTION 0x20000 /* file created */
++
++typedef struct smb_com_open_rsp {
++	struct smb_hdr hdr;	/* wct = 34 BB */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u8 OplockLevel;
++	__u16 Fid;
++	__u32 CreateAction;
++	__u64 CreationTime;
++	__u64 LastAccessTime;
++	__u64 LastWriteTime;
++	__u64 ChangeTime;
++	__u32 FileAttributes;
++	__u64 AllocationSize;
++	__u64 EndOfFile;
++	__u16 FileType;
++	__u16 DeviceState;
++	__u8 DirectoryFlag;
++	__u16 ByteCount;	/* bct = 0 */
++} OPEN_RSP;
++
++typedef struct smb_com_write_req {
++	struct smb_hdr hdr;	/* wct = 14 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 Fid;
++	__u32 OffsetLow;
++	__u32 Reserved;
++	__u16 WriteMode;
++	__u16 Remaining;
++	__u16 DataLengthHigh;
++	__u16 DataLengthLow;
++	__u16 DataOffset;
++	__u32 OffsetHigh;
++	__u16 ByteCount;
++	__u8 Pad;		/* BB check for whether padded to DWORD boundary and optimum performance here */
++	char Data[1];
++} WRITE_REQ;
++
++typedef struct smb_com_write_rsp {
++	struct smb_hdr hdr;	/* wct = 6 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 Count;
++	__u16 Remaining;
++	__u32 Reserved;
++	__u16 ByteCount;
++} WRITE_RSP;
++
++typedef struct smb_com_read_req {
++	struct smb_hdr hdr;	/* wct = 12 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 Fid;
++	__u32 OffsetLow;
++	__u16 MaxCount;
++	__u16 MinCount;		/* obsolete */
++	__u32 MaxCountHigh;
++	__u16 Remaining;
++	__u32 OffsetHigh;
++	__u16 ByteCount;
++} READ_REQ;
++
++typedef struct smb_com_read_rsp {
++	struct smb_hdr hdr;	/* wct = 12 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 Remaining;
++	__u16 DataCompactionMode;
++	__u16 Reserved;
++	__u16 DataLength;
++	__u16 DataOffset;
++	__u16 DataLengthHigh;
++	__u64 Reserved2;
++	__u16 ByteCount;
++	__u8 Pad;		/* BB check for whether padded to DWORD boundary and optimum performance here */
++	char Data[1];
++} READ_RSP;
++
++typedef struct locking_andx_range {
++	__u16 Pid;
++	__u16 Pad;
++	__u32 OffsetHigh;
++	__u32 OffsetLow;
++	__u32 LengthHigh;
++	__u32 LengthLow;
++} LOCKING_ANDX_RANGE;
++
++#define LOCKING_ANDX_SHARED_LOCK     0x01
++#define LOCKING_ANDX_OPLOCK_RELEASE  0x02
++#define LOCKING_ANDX_CHANGE_LOCKTYPE 0x04
++#define LOCKING_ANDX_CANCEL_LOCK     0x08
++#define LOCKING_ANDX_LARGE_FILES     0x10	/* always on for us */
++
++typedef struct smb_com_lock_req {
++	struct smb_hdr hdr;	/* wct = 8 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 Fid;
++	__u8 LockType;
++	__u8 OplockLevel;
++	__u32 Timeout;
++	__u16 NumberOfUnlocks;
++	__u16 NumberOfLocks;
++	__u16 ByteCount;
++	LOCKING_ANDX_RANGE Locks[1];
++} LOCK_REQ;
++
++typedef struct smb_com_lock_rsp {
++	struct smb_hdr hdr;	/* wct = 2 */
++	__u8 AndXCommand;
++	__u8 AndXReserved;
++	__u16 AndXOffset;
++	__u16 ByteCount;
++} LOCK_RSP;
++
++typedef struct smb_com_rename_req {
++	struct smb_hdr hdr;	/* wct = 1 */
++	__u16 SearchAttributes;	/* target file attributes */
++	__u16 ByteCount;
++	__u8 BufferFormat;	/* 4 = ASCII or Unicode */
++	unsigned char OldFileName[1];
++	/* followed by __u8 BufferFormat2 */
++	/* followed by NewFileName */
++} RENAME_REQ;
++
++	/* copy request flags */
++#define COPY_MUST_BE_FILE      0x0001
++#define COPY_MUST_BE_DIR       0x0002
++#define COPY_TARGET_MODE_ASCII 0x0004 /* if not set, binary */
++#define COPY_SOURCE_MODE_ASCII 0x0008 /* if not set, binary */
++#define COPY_VERIFY_WRITES     0x0010
++#define COPY_TREE              0x0020 
++
++typedef struct smb_com_copy_req {
++	struct smb_hdr hdr;	/* wct = 3 */
++	__u16 Tid2;
++	__u16 OpenFunction;
++	__u16 Flags;
++	__u16 ByteCount;
++	__u8 BufferFormat;	/* 4 = ASCII or Unicode */ 
++	unsigned char OldFileName[1];
++	/* followed by __u8 BufferFormat2 */
++	/* followed by NewFileName string */
++} COPY_REQ;
++
++typedef struct smb_com_copy_rsp {
++	struct smb_hdr hdr;     /* wct = 1 */
++	__u16 CopyCount;    /* number of files copied */
++	__u16 ByteCount;    /* may be zero */
++	__u8 BufferFormat;  /* 0x04 - only present if errored file follows */
++	unsigned char ErrorFileName[1]; /* only present if error in copy */
++} COPY_RSP;
++
++#define CREATE_HARD_LINK		0x103
++#define MOVEFILE_COPY_ALLOWED		0x0002
++#define MOVEFILE_REPLACE_EXISTING	0x0001
++
++typedef struct smb_com_nt_rename_req {	/* A5 - also used for create hardlink */
++	struct smb_hdr hdr;	/* wct = 4 */
++	__u16 SearchAttributes;	/* target file attributes */
++	__u16 Flags;		/* spec says Information Level */
++	__u32 ClusterCount;
++	__u16 ByteCount;
++	__u8 BufferFormat;	/* 4 = ASCII or Unicode */
++	unsigned char OldFileName[1];
++	/* followed by __u8 BufferFormat2 */
++	/* followed by NewFileName */
++} NT_RENAME_REQ;
++
++typedef struct smb_com_rename_rsp {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;	/* bct = 0 */
++} RENAME_RSP;
++
++typedef struct smb_com_delete_file_req {
++	struct smb_hdr hdr;	/* wct = 1 */
++	__u16 SearchAttributes;
++	__u16 ByteCount;
++	__u8 BufferFormat;	/* 4 = ASCII */
++	unsigned char fileName[1];
++} DELETE_FILE_REQ;
++
++typedef struct smb_com_delete_file_rsp {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;	/* bct = 0 */
++} DELETE_FILE_RSP;
++
++typedef struct smb_com_delete_directory_req {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;
++	__u8 BufferFormat;	/* 4 = ASCII */
++	unsigned char DirName[1];
++} DELETE_DIRECTORY_REQ;
++
++typedef struct smb_com_delete_directory_rsp {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;	/* bct = 0 */
++} DELETE_DIRECTORY_RSP;
++
++typedef struct smb_com_create_directory_req {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;
++	__u8 BufferFormat;	/* 4 = ASCII */
++	unsigned char DirName[1];
++} CREATE_DIRECTORY_REQ;
++
++typedef struct smb_com_create_directory_rsp {
++	struct smb_hdr hdr;	/* wct = 0 */
++	__u16 ByteCount;	/* bct = 0 */
++} CREATE_DIRECTORY_RSP;
++
++/***************************************************/
++/* NT Transact structure defintions follow         */
++/* Currently only ioctl and notify are implemented */
++/***************************************************/
++typedef struct smb_com_transaction_ioctl_req {
++	struct smb_hdr hdr;	/* wct = 23 */
++	__u8 MaxSetupCount;
++	__u16 Reserved;
++	__u32 TotalParameterCount;
++	__u32 TotalDataCount;
++	__u32 MaxParameterCount;
++	__u32 MaxDataCount;
++	__u32 ParameterCount;
++	__u32 ParameterOffset;
++	__u32 DataCount;
++	__u32 DataOffset;
++	__u8 SetupCount; /* four setup words follow subcommand */
++	/* SNIA spec incorrectly included spurious pad here */
++	__u16 SubCommand;/* 2 = IOCTL/FSCTL */
++	__u32 FunctionCode;
++	__u16 Fid;
++	__u8 IsFsctl;    /* 1 = File System Control, 0 = device control (IOCTL)*/
++	__u8 IsRootFlag; /* 1 = apply command to root of share (must be DFS share)*/
++	__u16 ByteCount;
++	__u8 Pad[3];
++	__u8 Data[1];
++} TRANSACT_IOCTL_REQ;
++
++typedef struct smb_com_transaction_ioctl_rsp {
++	struct smb_hdr hdr;	/* wct = 19 */
++	__u8 Reserved[3];
++	__u32 TotalParameterCount;
++	__u32 TotalDataCount;
++	__u32 ParameterCount;
++	__u32 ParameterOffset;
++	__u32 ParameterDisplacement;
++	__u32 DataCount;
++	__u32 DataOffset;
++	__u32 DataDisplacement;
++	__u8 SetupCount;	/* 1 */
++	__u16 ReturnedDataLen;
++	__u16 ByteCount;
++	__u8 Pad[3];
++} TRANSACT_IOCTL_RSP;
++
++typedef struct smb_com_transaction_change_notify_req {
++	struct smb_hdr hdr;     /* wct = 23 */
++	__u8 MaxSetupCount;
++	__u16 Reserved;
++	__u32 TotalParameterCount;
++	__u32 TotalDataCount;
++	__u32 MaxParameterCount;
++	__u32 MaxDataCount;
++	__u32 ParameterCount;
++	__u32 ParameterOffset;
++	__u32 DataCount;
++	__u32 DataOffset;
++	__u8 SetupCount; /* four setup words follow subcommand */
++	/* SNIA spec incorrectly included spurious pad here */
++	__u16 SubCommand;/* 4 = Change Notify */
++	__u32 CompletionFilter;  /* operation to monitor */
++	__u16 Fid;
++	__u8 WatchTree;  /* 1 = Monitor subdirectories */
++	__u8 Reserved2;
++	__u16 ByteCount;
++/* __u8 Pad[3];*/
++/*	__u8 Data[1];*/
++} TRANSACT_CHANGE_NOTIFY_REQ;
++
++typedef struct smb_com_transaction_change_notify_rsp {
++	struct smb_hdr hdr;	/* wct = 18 */
++	__u8 Reserved[3];
++	__u32 TotalParameterCount;
++	__u32 TotalDataCount;
++	__u32 ParameterCount;
++	__u32 ParameterOffset;
++	__u32 ParameterDisplacement;
++	__u32 DataCount;
++	__u32 DataOffset;
++	__u32 DataDisplacement;
++	__u8 SetupCount;   /* 0 */
++	__u16 ByteCount;
++	/* __u8 Pad[3]; */
++} TRANSACT_CHANGE_NOTIFY_RSP;
++/* Completion Filter flags for Notify */
++#define FILE_NOTIFY_CHANGE_FILE_NAME    0x00000001
++#define FILE_NOTIFY_CHANGE_DIR_NAME     0x00000002
++#define FILE_NOTIFY_CHANGE_NAME         0x00000003
++#define FILE_NOTIFY_CHANGE_ATTRIBUTES   0x00000004
++#define FILE_NOTIFY_CHANGE_SIZE         0x00000008
++#define FILE_NOTIFY_CHANGE_LAST_WRITE   0x00000010
++#define FILE_NOTIFY_CHANGE_LAST_ACCESS  0x00000020
++#define FILE_NOTIFY_CHANGE_CREATION     0x00000040
++#define FILE_NOTIFY_CHANGE_EA           0x00000080
++#define FILE_NOTIFY_CHANGE_SECURITY     0x00000100
++#define FILE_NOTIFY_CHANGE_STREAM_NAME  0x00000200
++#define FILE_NOTIFY_CHANGE_STREAM_SIZE  0x00000400
++#define FILE_NOTIFY_CHANGE_STREAM_WRITE 0x00000800
++
++#define FILE_ACTION_ADDED		0x00000001
++#define FILE_ACTION_REMOVED		0x00000002
++#define FILE_ACTION_MODIFIED		0x00000003
++#define FILE_ACTION_RENAMED_OLD_NAME	0x00000004
++#define FILE_ACTION_RENAMED_NEW_NAME	0x00000005
++#define FILE_ACTION_ADDED_STREAM	0x00000006
++#define FILE_ACTION_REMOVED_STREAM	0x00000007
++#define FILE_ACTION_MODIFIED_STREAM	0x00000008
++
++/* response contains array of the following structures */
++struct file_notify_information {
++	__u32 NextEntryOffset;
++	__u32 Action;
++	__u32 FileNameLength;
++	__u8  FileName[1];
++}; 
++
++struct reparse_data {
++	__u32	ReparseTag;
++	__u16	ReparseDataLength;
++	__u16	Reserved;
++	__u16	AltNameOffset;
++	__u16	AltNameLen;
++	__u16	TargetNameOffset;
++	__u16	TargetNameLen;
++	char	LinkNamesBuf[1];
++};
++
++struct cifs_quota_data {
++	__u32	rsrvd1;  /* 0 */
++	__u32	sid_size;
++	__u64	rsrvd2;  /* 0 */
++	__u64	space_used;
++	__u64	soft_limit;
++	__u64	hard_limit;
++	char	sid[1];  /* variable size? */
++};
++
++/* quota sub commands */
++#define QUOTA_LIST_CONTINUE	    0
++#define QUOTA_LIST_START	0x100
++#define QUOTA_FOR_SID		0x101
++
++typedef union smb_com_transaction2 {
++	struct {
++		struct smb_hdr hdr;	/* wct = 14+ */
++		__u16 TotalParameterCount;
++		__u16 TotalDataCount;
++		__u16 MaxParameterCount;
++		__u16 MaxDataCount;
++		__u8 MaxSetupCount;
++		__u8 Reserved;
++		__u16 Flags;
++		__u32 Timeout;
++		__u16 Reserved2;
++		__u16 ParameterCount;
++		__u16 ParameterOffset;
++		__u16 DataCount;
++		__u16 DataOffset;
++		__u8 SetupCount;
++		__u8 Reserved3;
++		__u16 SubCommand;	/* 1st setup word - can be followed by SetupCount words */
++		__u16 ByteCount;	/* careful - setupcount is not always one */
++	} req;
++	struct {
++		struct smb_hdr hdr;	/* wct = 0 */
++		__u16 TotalParameterCount;
++		__u16 TotalDataCount;
++		__u16 Reserved;
++		__u16 ParameterCount;
++		__u16 ParamterOffset;
++		__u16 ParameterDisplacement;
++		__u16 DataCount;
++		__u16 DataOffset;
++		__u16 DataDisplacement;
++		__u8 SetupCount;
++		__u8 Reserved1;	/* should be zero setup words following */
++		__u16 ByteCount;
++		__u16 Reserved2;	/* parameter word reserved - present for infolevels > 100 */
++		/* data area follows */
++	} resp;
++} TRANSACTION2;
++
++/* PathInfo/FileInfo infolevels */
++#define SMB_INFO_STANDARD                   1
++#define SMB_INFO_QUERY_EAS_FROM_LIST        3
++#define SMB_INFO_QUERY_ALL_EAS              4
++#define SMB_INFO_IS_NAME_VALID              6
++#define SMB_QUERY_FILE_BASIC_INFO       0x101
++#define SMB_QUERY_FILE_STANDARD_INFO    0x102
++#define SMB_QUERY_FILE_EA_INFO          0x103
++#define SMB_QUERY_FILE_NAME_INFO        0x104
++#define SMB_QUERY_FILE_ALLOCATION_INFO  0x105
++#define SMB_QUERY_FILE_END_OF_FILEINFO  0x106
++#define SMB_QUERY_FILE_ALL_INFO         0x107
++#define SMB_QUERY_ALT_NAME_INFO         0x108
++#define SMB_QUERY_FILE_STREAM_INFO      0x109
++#define SMB_QUERY_FILE_COMPRESSION_INFO 0x10B
++#define SMB_QUERY_FILE_UNIX_BASIC       0x200
++#define SMB_QUERY_FILE_UNIX_LINK        0x201
++
++#define SMB_SET_FILE_BASIC_INFO	        0x101
++#define SMB_SET_FILE_DISPOSITION_INFO   0x102
++#define SMB_SET_FILE_ALLOCATION_INFO    0x103
++#define SMB_SET_FILE_END_OF_FILE_INFO   0x104
++#define SMB_SET_FILE_UNIX_BASIC         0x200
++#define SMB_SET_FILE_UNIX_LINK          0x201
++#define SMB_SET_FILE_UNIX_HLINK         0x203
++#define SMB_SET_FILE_BASIC_INFO2        0x3ec
++#define SMB_SET_FILE_RENAME_INFORMATION 0x3f2
++#define SMB_FILE_ALL_INFO2              0x3fa
++#define SMB_SET_FILE_ALLOCATION_INFO2   0x3fb
++#define SMB_SET_FILE_END_OF_FILE_INFO2  0x3fc
++#define SMB_FILE_MOVE_CLUSTER_INFO      0x407
++#define SMB_FILE_QUOTA_INFO             0x408
++#define SMB_FILE_REPARSEPOINT_INFO      0x409
++#define SMB_FILE_MAXIMUM_INFO           0x40d
++
++/* Find File infolevels */
++#define SMB_FIND_FILE_DIRECTORY_INFO      0x101
++#define SMB_FIND_FILE_FULL_DIRECTORY_INFO 0x102
++#define SMB_FIND_FILE_NAMES_INFO          0x103
++#define SMB_FIND_FILE_BOTH_DIRECTORY_INFO 0x104
++#define SMB_FIND_FILE_UNIX                0x202
++
++typedef struct smb_com_transaction2_qpi_req {
++	struct smb_hdr hdr;	/* wct = 14+ */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 MaxParameterCount;
++	__u16 MaxDataCount;
++	__u8 MaxSetupCount;
++	__u8 Reserved;
++	__u16 Flags;
++	__u32 Timeout;
++	__u16 Reserved2;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u8 SetupCount;
++	__u8 Reserved3;
++	__u16 SubCommand;	/* one setup word */
++	__u16 ByteCount;
++	__u8 Pad;
++	__u16 InformationLevel;
++	__u32 Reserved4;
++	char FileName[1];
++} TRANSACTION2_QPI_REQ;
++
++typedef struct smb_com_transaction2_qpi_rsp {
++	struct smb_hdr hdr;	/* wct = 10 + SetupCount */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 Reserved;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 ParameterDisplacement;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u16 DataDisplacement;
++	__u8 SetupCount;
++	__u8 Reserved1;		/* should be zero setup words following */
++	__u16 ByteCount;
++	__u16 Reserved2;	/* parameter word reserved - present for infolevels > 100 */
++} TRANSACTION2_QPI_RSP;
++
++typedef struct smb_com_transaction2_spi_req {
++	struct smb_hdr hdr;	/* wct = 15 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 MaxParameterCount;
++	__u16 MaxDataCount;
++	__u8 MaxSetupCount;
++	__u8 Reserved;
++	__u16 Flags;
++	__u32 Timeout;
++	__u16 Reserved2;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u8 SetupCount;
++	__u8 Reserved3;
++	__u16 SubCommand;	/* one setup word */
++	__u16 ByteCount;
++	__u8 Pad;
++	__u16 Pad1;
++	__u16 InformationLevel;
++	__u32 Reserved4;
++	char FileName[1];
++} TRANSACTION2_SPI_REQ;
++
++typedef struct smb_com_transaction2_spi_rsp {
++	struct smb_hdr hdr;	/* wct = 10 + SetupCount */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 Reserved;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 ParameterDisplacement;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u16 DataDisplacement;
++	__u8 SetupCount;
++	__u8 Reserved1;		/* should be zero setup words following */
++	__u16 ByteCount;
++	__u16 Reserved2;	/* parameter word reserved - present for infolevels > 100 */
++} TRANSACTION2_SPI_RSP;
++
++struct set_file_rename {
++	__u32 overwrite;   /* 1 = overwrite dest */
++	__u32 root_fid;   /* zero */
++	__u32 target_name_len;
++	char  target_name[0];  /* Must be unicode */
++};
++
++struct smb_com_transaction2_sfi_req {
++	struct smb_hdr hdr;	/* wct = 15 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 MaxParameterCount;
++	__u16 MaxDataCount;
++	__u8 MaxSetupCount;
++	__u8 Reserved;
++	__u16 Flags;
++	__u32 Timeout;
++	__u16 Reserved2;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u8 SetupCount;
++	__u8 Reserved3;
++	__u16 SubCommand;	/* one setup word */
++	__u16 ByteCount;
++	__u8 Pad;
++	__u16 Pad1;
++	__u16 Fid;
++	__u16 InformationLevel;
++	__u16 Reserved4;	
++};
++
++struct smb_com_transaction2_sfi_rsp {
++	struct smb_hdr hdr;	/* wct = 10 + SetupCount */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 Reserved;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 ParameterDisplacement;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u16 DataDisplacement;
++	__u8 SetupCount;
++	__u8 Reserved1;		/* should be zero setup words following */
++	__u16 ByteCount;
++	__u16 Reserved2;	/* parameter word reserved - present for infolevels > 100 */
++};
++
++
++/*
++ * Flags on T2 FINDFIRST and FINDNEXT 
++ */
++#define CIFS_SEARCH_CLOSE_ALWAYS  0x0001
++#define CIFS_SEARCH_CLOSE_AT_END  0x0002
++#define CIFS_SEARCH_RETURN_RESUME 0x0004
++#define CIFS_SEARCH_CONTINUE_FROM_LAST 0x0008
++#define CIFS_SEARCH_BACKUP_SEARCH 0x0010
++
++/*
++ * Size of the resume key on FINDFIRST and FINDNEXT calls
++ */
++#define CIFS_SMB_RESUME_KEY_SIZE 4
++
++typedef struct smb_com_transaction2_ffirst_req {
++	struct smb_hdr hdr;	/* wct = 15 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 MaxParameterCount;
++	__u16 MaxDataCount;
++	__u8 MaxSetupCount;
++	__u8 Reserved;
++	__u16 Flags;
++	__u32 Timeout;
++	__u16 Reserved2;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u8 SetupCount;	/* one */
++	__u8 Reserved3;
++	__u16 SubCommand;	/* TRANS2_FIND_FIRST */
++	__u16 ByteCount;
++	__u8 Pad;
++	__u16 SearchAttributes;
++	__u16 SearchCount;
++	__u16 SearchFlags;
++	__u16 InformationLevel;
++	__u32 SearchStorageType;
++	char FileName[1];
++} TRANSACTION2_FFIRST_REQ;
++
++typedef struct smb_com_transaction2_ffirst_rsp {
++	struct smb_hdr hdr;	/* wct = 10 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 Reserved;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 ParameterDisplacement;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u16 DataDisplacement;
++	__u8 SetupCount;
++	__u8 Reserved1;		/* should be zero setup words following */
++	__u16 ByteCount;
++} TRANSACTION2_FFIRST_RSP;
++
++typedef struct smb_com_transaction2_ffirst_rsp_parms {
++	__u16 SearchHandle;
++	__u16 SearchCount;
++	__u16 EndofSearch;
++	__u16 EAErrorOffset;
++	__u16 LastNameOffset;
++} T2_FFIRST_RSP_PARMS;
++
++typedef struct smb_com_transaction2_fnext_req {
++	struct smb_hdr hdr;	/* wct = 15 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 MaxParameterCount;
++	__u16 MaxDataCount;
++	__u8 MaxSetupCount;
++	__u8 Reserved;
++	__u16 Flags;
++	__u32 Timeout;
++	__u16 Reserved2;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u8 SetupCount;	/* one */
++	__u8 Reserved3;
++	__u16 SubCommand;	/* TRANS2_FIND_NEXT */
++	__u16 ByteCount;
++	__u8 Pad;
++	__u16 SearchHandle;
++	__u16 SearchCount;
++	__u16 InformationLevel;
++	__u32 ResumeKey;
++	__u16 SearchFlags;
++	char ResumeFileName[1];
++} TRANSACTION2_FNEXT_REQ;
++
++typedef struct smb_com_transaction2_fnext_rsp {
++	struct smb_hdr hdr;	/* wct = 10 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 Reserved;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 ParameterDisplacement;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u16 DataDisplacement;
++	__u8 SetupCount;
++	__u8 Reserved1;		/* should be zero setup words following */
++	__u16 ByteCount;
++} TRANSACTION2_FNEXT_RSP;
++
++typedef struct smb_com_transaction2_fnext_rsp_parms {
++	__u16 SearchCount;
++	__u16 EndofSearch;
++	__u16 EAErrorOffset;
++	__u16 LastNameOffset;
++} T2_FNEXT_RSP_PARMS;
++
++/* QFSInfo Levels */
++#define SMB_INFO_ALLOCATION         1
++#define SMB_INFO_VOLUME             2
++#define SMB_QUERY_FS_VOLUME_INFO    0x102
++#define SMB_QUERY_FS_SIZE_INFO      0x103
++#define SMB_QUERY_FS_DEVICE_INFO    0x104
++#define SMB_QUERY_FS_ATTRIBUTE_INFO 0x105
++#define SMB_QUERY_CIFS_UNIX_INFO    0x200
++#define SMB_QUERY_LABEL_INFO        0x3ea
++#define SMB_QUERY_FS_QUOTA_INFO     0x3ee
++
++typedef struct smb_com_transaction2_qfsi_req {
++	struct smb_hdr hdr;	/* wct = 14+ */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 MaxParameterCount;
++	__u16 MaxDataCount;
++	__u8 MaxSetupCount;
++	__u8 Reserved;
++	__u16 Flags;
++	__u32 Timeout;
++	__u16 Reserved2;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u8 SetupCount;
++	__u8 Reserved3;
++	__u16 SubCommand;	/* one setup word */
++	__u16 ByteCount;
++	__u8 Pad;
++	__u16 InformationLevel;
++} TRANSACTION2_QFSI_REQ;
++
++typedef struct smb_com_transaction_qfsi_rsp {
++	struct smb_hdr hdr;	/* wct = 10 + SetupCount */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 Reserved;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 ParameterDisplacement;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u16 DataDisplacement;
++	__u8 SetupCount;
++	__u8 Reserved1;		/* should be zero setup words following */
++	__u16 ByteCount;
++	__u8 Pad;		/* may be three bytes *//* followed by data area */
++} TRANSACTION2_QFSI_RSP;
++
++typedef struct smb_com_transaction2_get_dfs_refer_req {
++	struct smb_hdr hdr;	/* wct = 15 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 MaxParameterCount;
++	__u16 MaxDataCount;
++	__u8 MaxSetupCount;
++	__u8 Reserved;
++	__u16 Flags;
++	__u32 Timeout;
++	__u16 Reserved2;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u8 SetupCount;
++	__u8 Reserved3;
++	__u16 SubCommand;	/* one setup word */
++	__u16 ByteCount;
++	__u8 Pad[3];		/* Win2K has sent 0x0F01 (max resp length perhaps?) followed by one byte pad - doesn't seem to matter though */
++	__u16 MaxReferralLevel;
++	char RequestFileName[1];
++} TRANSACTION2_GET_DFS_REFER_REQ;
++
++typedef struct dfs_referral_level_3 {
++	__u16 VersionNumber;
++	__u16 ReferralSize;
++	__u16 ServerType;	/* 0x0001 = CIFS server */
++	__u16 ReferralFlags;	/* or proximity - not clear which since always set to zero - SNIA spec says 0x01 means strip off PathConsumed chars before submitting RequestFileName to remote node */
++	__u16 TimeToLive;
++	__u16 Proximity;
++	__u16 DfsPathOffset;
++	__u16 DfsAlternatePathOffset;
++	__u16 NetworkAddressOffset;
++} REFERRAL3;
++
++typedef struct smb_com_transaction_get_dfs_refer_rsp {
++	struct smb_hdr hdr;	/* wct = 10 */
++	__u16 TotalParameterCount;
++	__u16 TotalDataCount;
++	__u16 Reserved;
++	__u16 ParameterCount;
++	__u16 ParameterOffset;
++	__u16 ParameterDisplacement;
++	__u16 DataCount;
++	__u16 DataOffset;
++	__u16 DataDisplacement;
++	__u8 SetupCount;
++	__u8 Reserved1;		/* zero setup words following */
++	__u16 ByteCount;
++	__u8 Pad;
++	__u16 PathConsumed;
++	__u16 NumberOfReferrals;
++	__u16 DFSFlags;
++	__u16 Pad2;
++	REFERRAL3 referrals[1];	/* array of level 3 dfs_referral structures */
++	/* followed by the strings pointed to by the referral structures */
++} TRANSACTION2_GET_DFS_REFER_RSP;
++
++/* DFS Flags */
++#define DFSREF_REFERRAL_SERVER  0x0001
++#define DFSREF_STORAGE_SERVER   0x0002
++
++/* IOCTL information */
++/* List of ioctl function codes that look to be of interest to remote clients like this. */
++/* Need to do some experimentation to make sure they all work remotely.                  */
++/* Some of the following such as the encryption/compression ones would be                */
++/* invoked from tools via a specialized hook into the VFS rather than via the            */
++/* standard vfs entry points */
++#define FSCTL_REQUEST_OPLOCK_LEVEL_1 0x00090000
++#define FSCTL_REQUEST_OPLOCK_LEVEL_2 0x00090004
++#define FSCTL_REQUEST_BATCH_OPLOCK   0x00090008
++#define FSCTL_LOCK_VOLUME            0x00090018
++#define FSCTL_UNLOCK_VOLUME          0x0009001C
++#define FSCTL_GET_COMPRESSION        0x0009003C
++#define FSCTL_SET_COMPRESSION        0x0009C040
++#define FSCTL_REQUEST_FILTER_OPLOCK  0x0009008C
++#define FSCTL_FILESYS_GET_STATISTICS 0x00090090
++#define FSCTL_SET_REPARSE_POINT      0x000900A4
++#define FSCTL_GET_REPARSE_POINT      0x000900A8
++#define FSCTL_DELETE_REPARSE_POINT   0x000900AC
++#define FSCTL_SET_SPARSE             0x000900C4
++#define FSCTL_SET_ZERO_DATA          0x000900C8
++#define FSCTL_SET_ENCRYPTION         0x000900D7
++#define FSCTL_ENCRYPTION_FSCTL_IO    0x000900DB
++#define FSCTL_WRITE_RAW_ENCRYPTED    0x000900DF
++#define FSCTL_READ_RAW_ENCRYPTED     0x000900E3
++#define FSCTL_SIS_COPYFILE           0x00090100
++#define FSCTL_SIS_LINK_FILES         0x0009C104
++
++#define IO_REPARSE_TAG_MOUNT_POINT   0xA0000003
++#define IO_REPARSE_TAG_HSM           0xC0000004
++#define IO_REPARSE_TAG_SIS           0x80000007
++
++/*
++ ************************************************************************
++ * All structs for everything above the SMB PDUs themselves
++ * (such as the T2 level specific data) go here                  
++ ************************************************************************
++ */
++
++/*
++ * Information on a server
++ */
++
++struct serverInfo {
++	char name[16];
++	unsigned char versionMajor;
++	unsigned char versionMinor;
++	unsigned long type;
++	unsigned int commentOffset;
++};
++
++/*
++ * The following structure is the format of the data returned on a NetShareEnum
++ * with level "90" (x5A)
++ */
++
++struct shareInfo {
++	char shareName[13];
++	char pad;
++	unsigned short type;
++	unsigned int commentOffset;
++};
++
++struct aliasInfo {
++	char aliasName[9];
++	char pad;
++	unsigned int commentOffset;
++	unsigned char type[2];
++};
++
++struct aliasInfo92 {
++	int aliasNameOffset;
++	int serverNameOffset;
++	int shareNameOffset;
++};
++
++typedef struct {
++	__u64 TotalAllocationUnits;
++	__u64 FreeAllocationUnits;
++	__u32 SectorsPerAllocationUnit;
++	__u32 BytesPerSector;
++} FILE_SYSTEM_INFO;		/* size info, level 0x103 */
++
++typedef struct {
++	__u16 MajorVersionNumber;
++	__u16 MinorVersionNumber;
++	__u64 Capability;
++} FILE_SYSTEM_UNIX_INFO;	/* Unix extensions info, level 0x200 */
++/* Linux/Unix extensions capability flags */
++#define CIFS_UNIX_FCNTL_CAP             0x00000001 /* support for fcntl locks */
++#define CIFS_UNIX_POSIX_ACL_CAP         0x00000002
++
++/* DeviceType Flags */
++#define FILE_DEVICE_CD_ROM              0x00000002
++#define FILE_DEVICE_CD_ROM_FILE_SYSTEM  0x00000003
++#define FILE_DEVICE_DFS                 0x00000006
++#define FILE_DEVICE_DISK                0x00000007
++#define FILE_DEVICE_DISK_FILE_SYSTEM    0x00000008
++#define FILE_DEVICE_FILE_SYSTEM         0x00000009
++#define FILE_DEVICE_NAMED_PIPE          0x00000011
++#define FILE_DEVICE_NETWORK             0x00000012
++#define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014
++#define FILE_DEVICE_NULL                0x00000015
++#define FILE_DEVICE_PARALLEL_PORT       0x00000016
++#define FILE_DEVICE_PRINTER             0x00000018
++#define FILE_DEVICE_SERIAL_PORT         0x0000001b
++#define FILE_DEVICE_STREAMS             0x0000001e
++#define FILE_DEVICE_TAPE                0x0000001f
++#define FILE_DEVICE_TAPE_FILE_SYSTEM    0x00000020
++#define FILE_DEVICE_VIRTUAL_DISK        0x00000024
++#define FILE_DEVICE_NETWORK_REDIRECTOR  0x00000028
++
++typedef struct {
++	__u32 DeviceType;
++	__u32 DeviceCharacteristics;
++} FILE_SYSTEM_DEVICE_INFO;	/* device info, level 0x104 */
++
++typedef struct {
++	__u32 Attributes;
++	__u32 MaxPathNameComponentLength;
++	__u32 FileSystemNameLen;
++	char FileSystemName[52];	/* do not really need to save this - so potentially get only subset of name */
++} FILE_SYSTEM_ATTRIBUTE_INFO;
++
++typedef struct {		/* data block encoding of response to level 263 QPathInfo */
++	__u64 CreationTime;
++	__u64 LastAccessTime;
++	__u64 LastWriteTime;
++	__u64 ChangeTime;
++	__u32 Attributes;
++	__u32 Pad1;
++	__u64 AllocationSize;
++	__u64 EndOfFile;	/* size ie offset to first free byte in file */
++	__u32 NumberOfLinks;	/* hard links */
++	__u8 DeletePending;
++	__u8 Directory;
++	__u16 Pad2;
++	__u64 IndexNumber;
++	__u32 EASize;
++	__u32 AccessFlags;
++	__u64 IndexNumber1;
++	__u64 CurrentByteOffset;
++	__u32 Mode;
++	__u32 AlignmentRequirement;
++	__u32 FileNameLength;
++	char FileName[1];
++} FILE_ALL_INFO;		/* level 263 QPathInfo */
++
++typedef struct {
++	__u64 EndOfFile;
++	__u64 NumOfBytes;
++	__u64 LastStatusChange;	/*SNIA spec says DCE time for the three time fields */
++	__u64 LastAccessTime;
++	__u64 LastModificationTime;
++	__u64 Uid;
++	__u64 Gid;
++	__u32 Type;
++	__u64 DevMajor;
++	__u64 DevMinor;
++	__u64 UniqueId;
++	__u64 Permissions;
++	__u64 Nlinks;
++} FILE_UNIX_BASIC_INFO;		/* level 512 QPathInfo */
++
++typedef struct {
++	char LinkDest[1];
++} FILE_UNIX_LINK_INFO;		/* level 513 QPathInfo */
++
++/* defines for enumerating possible values of the Unix type field below */
++#define UNIX_FILE      0
++#define UNIX_DIR       1
++#define UNIX_SYMLINK   2
++#define UNIX_CHARDEV   3
++#define UNIX_BLOCKDEV  4
++#define UNIX_FIFO      5
++#define UNIX_SOCKET    6
++
++typedef struct {
++	__u32 NextEntryOffset;
++	__u32 ResumeKey;
++	__u64 EndOfFile;
++	__u64 NumOfBytes;
++	__u64 LastStatusChange;	/*SNIA spec says DCE time for the three time fields */
++	__u64 LastAccessTime;
++	__u64 LastModificationTime;
++	__u64 Uid;
++	__u64 Gid;
++	__u32 Type;
++	__u64 DevMajor;
++	__u64 DevMinor;
++	__u64 UniqueId;
++	__u64 Permissions;
++	__u64 Nlinks;
++	char FileName[1];
++} FILE_UNIX_INFO;
++
++typedef struct {
++	__u64 CreationTime;
++	__u64 LastAccessTime;
++	__u64 LastWriteTime;
++	__u64 ChangeTime;
++	__u32 Attributes;
++	__u32 Pad;
++} FILE_BASIC_INFO;		/* size info, level 0x101 */
++
++struct file_allocation_info {
++	__u64 AllocationSize;
++};		/* size info, level 0x103 */
++
++struct file_end_of_file_info {
++	__u64 FileSize;		/* offset to end of file */
++};	/* size info, level 0x104 */
++
++typedef struct {
++	__u32 NextEntryOffset;
++	__u32 FileIndex;
++	__u64 CreationTime;
++	__u64 LastAccessTime;
++	__u64 LastWriteTime;
++	__u64 ChangeTime;
++	__u64 EndOfFile;
++	__u64 AllocationSize;
++	__u32 ExtFileAttributes;
++	__u32 FileNameLength;
++	char FileName[1];
++} FILE_DIRECTORY_INFO;   /* level 257 FF response data area */
++
++struct gea {
++	unsigned char cbName;
++	char szName[1];
++};
++
++struct gealist {
++	unsigned long cbList;
++	struct gea list[1];
++};
++
++struct fea {
++	unsigned char EA_flags;
++	__u8 name_len;
++	__u16 value_len;
++	char szName[1];
++	/* optionally followed by value */
++};
++/* flags for _FEA.fEA */
++#define FEA_NEEDEA         0x80	/* need EA bit */
++
++struct fealist {
++	__u32 list_len;
++	struct fea list[1];
++};
++
++/* used to hold an arbitrary blob of data */
++struct data_blob {
++	__u8 *data;
++	size_t length;
++	void (*free) (struct data_blob * data_blob);
++};
++
++#ifdef CONFIG_CIFS_POSIX
++/* 
++	For better POSIX semantics from Linux client, (even better
++	than the existing CIFS Unix Extensions) we need updated PDUs for:
++	
++	1) PosixCreateX - to set and return the mode, inode#, device info and
++	perhaps add a CreateDevice - to create Pipes and other special .inodes
++	Also note POSIX open flags
++	2) Close - to return the last write time to do cache across close more safely
++	3) PosixQFSInfo - to return statfs info
++	4) FindFirst return unique inode number - what about resume key, two forms short (matches readdir) and full (enough info to cache inodes)
++	5) Mkdir - set mode
++	
++	And under consideration: 
++	6) FindClose2 (return nanosecond timestamp ??)
++	7) Use nanosecond timestamps throughout all time fields if 
++	   corresponding attribute flag is set
++	8) sendfile - handle based copy
++	9) Direct i/o
++	10) "POSIX ACL" support
++	11) Misc fcntls?
++	
++	what about fixing 64 bit alignment
++	
++	There are also various legacy SMB/CIFS requests used as is
++	
++	From existing Lanman and NTLM dialects:
++	--------------------------------------
++	NEGOTIATE
++	SESSION_SETUP_ANDX (BB which?)
++	TREE_CONNECT_ANDX (BB which wct?)
++	TREE_DISCONNECT (BB add volume timestamp on response)
++	LOGOFF_ANDX
++	DELETE (note delete open file behavior)
++	DELETE_DIRECTORY
++	READ_AND_X
++	WRITE_AND_X
++	LOCKING_AND_X (note posix lock semantics)
++	RENAME (note rename across dirs and open file rename posix behaviors)
++	NT_RENAME (for hardlinks) Is this good enough for all features?
++	FIND_CLOSE2
++	TRANSACTION2 (18 cases)
++		SMB_SET_FILE_END_OF_FILE_INFO2 SMB_SET_PATH_END_OF_FILE_INFO2
++		(BB verify that never need to set allocation size)
++		SMB_SET_FILE_BASIC_INFO2 (setting times - BB can it be done via Unix ext?)
++	
++	COPY (note support for copy across directories) - FUTURE, OPTIONAL
++	setting/getting OS/2 EAs - FUTURE (BB can this handle
++	        setting Linux xattrs perfectly)         - OPTIONAL
++    dnotify                                         - FUTURE, OPTIONAL
++    quota                                           - FUTURE, OPTIONAL
++			
++	Note that various requests implemented for NT interop such as 
++		NT_TRANSACT (IOCTL) QueryReparseInfo
++	are unneeded to servers compliant with the CIFS POSIX extensions
++	
++	From CIFS Unix Extensions:
++	-------------------------
++	T2 SET_PATH_INFO (SMB_SET_FILE_UNIX_LINK) for symlinks
++	T2 SET_PATH_INFO (SMB_SET_FILE_BASIC_INFO2)
++	T2 QUERY_PATH_INFO (SMB_QUERY_FILE_UNIX_LINK)
++	T2 QUERY_PATH_INFO (SMB_QUERY_FILE_UNIX_BASIC) - BB check for missing inode fields
++					Actually need QUERY_FILE_UNIX_INFO since has inode num
++					BB what about a) blksize/blkbits/blocks
++								  b) i_version
++								  c) i_rdev
++								  d) notify mask?
++								  e) generation
++								  f) size_seqcount
++	T2 FIND_FIRST/FIND_NEXT FIND_FILE_UNIX
++	TRANS2_GET_DFS_REFERRAL				  - OPTIONAL but recommended
++	T2_QFS_INFO QueryDevice/AttributeInfo - OPTIONAL
++	
++	
++ */
++#endif 
++
++#pragma pack()			/* resume default structure packing */
++
++#endif				/* _CIFSPDU_H */
+diff -urN linux-2.4.29.old/fs/cifs/cifsproto.h linux-2.4.29/fs/cifs/cifsproto.h
+--- linux-2.4.29.old/fs/cifs/cifsproto.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifsproto.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,254 @@
++/*
++ *   fs/cifs/cifsproto.h
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++#ifndef _CIFSPROTO_H
++#define _CIFSPROTO_H
++#include <linux/nls.h>
++
++struct statfs;
++
++/*
++ *****************************************************************
++ * All Prototypes
++ *****************************************************************
++ */
++
++extern struct smb_hdr *cifs_buf_get(void);
++extern void cifs_buf_release(void *);
++extern int smb_send(struct socket *, struct smb_hdr *,
++			unsigned int /* length */ , struct sockaddr *);
++extern unsigned int _GetXid(void);
++extern void _FreeXid(unsigned int);
++#define GetXid() (int)_GetXid(); cFYI(1,("CIFS VFS: in %s as Xid: %d with uid: %d",__FUNCTION__, xid,current->fsuid));
++#define FreeXid(curr_xid) {_FreeXid(curr_xid); cFYI(1,("CIFS VFS: leaving %s (xid = %d) rc = %d",__FUNCTION__,curr_xid,rc));}
++extern char *build_path_from_dentry(struct dentry *);
++extern char *build_wildcard_path_from_dentry(struct dentry *direntry);
++extern void renew_parental_timestamps(struct dentry *direntry);
++extern int SendReceive(const unsigned int /* xid */ , struct cifsSesInfo *,
++			struct smb_hdr * /* input */ ,
++			struct smb_hdr * /* out */ ,
++			int * /* bytes returned */ , const int long_op);
++extern int checkSMBhdr(struct smb_hdr *smb, __u16 mid);
++extern int checkSMB(struct smb_hdr *smb, __u16 mid, int length);
++extern int is_valid_oplock_break(struct smb_hdr *smb);
++extern unsigned int smbCalcSize(struct smb_hdr *ptr);
++extern int decode_negTokenInit(unsigned char *security_blob, int length,
++			enum securityEnum *secType);
++extern int map_smb_to_linux_error(struct smb_hdr *smb);
++extern void header_assemble(struct smb_hdr *, char /* command */ ,
++			const struct cifsTconInfo *, int
++			/* length of fixed section (word count) in two byte units  */
++			);
++struct oplock_q_entry * AllocOplockQEntry(struct inode *, u16, struct cifsTconInfo *);
++void DeleteOplockQEntry(struct oplock_q_entry *);
++extern time_t cifs_NTtimeToUnix(u64 /* utc nanoseconds since 1601 */ );
++extern u64 cifs_UnixTimeToNT(time_t);
++extern int cifs_get_inode_info(struct inode **pinode,
++			const unsigned char *search_path, 
++			FILE_ALL_INFO * pfile_info,
++			struct super_block *sb, int xid);
++extern int cifs_get_inode_info_unix(struct inode **pinode,
++			const unsigned char *search_path,
++			struct super_block *sb,int xid);
++
++extern int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo, 
++			struct nls_table * nls_info);
++extern int CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses);
++
++extern int CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
++			const char *tree, struct cifsTconInfo *tcon,
++			const struct nls_table *);
++
++extern int CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
++			const char *searchName,
++			FILE_DIRECTORY_INFO * findData,
++			T2_FFIRST_RSP_PARMS * findParms,
++			const struct nls_table *nls_codepage,
++			int *pUnicodeFlag,
++			int *pUnixFlag /* if Unix extensions used */ );
++extern int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
++			FILE_DIRECTORY_INFO * findData,
++			T2_FNEXT_RSP_PARMS * findParms,
++			const __u16 searchHandle, char * resume_name,
++			int name_length, __u32 resume_key,
++			int *UnicodeFlag, int *pUnixFlag);
++
++extern int CIFSFindClose(const int, struct cifsTconInfo *tcon,
++			const __u16 search_handle);
++
++extern int CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
++			const unsigned char *searchName,
++			FILE_ALL_INFO * findData,
++			const struct nls_table *nls_codepage);
++
++extern int CIFSSMBUnixQPathInfo(const int xid,
++			struct cifsTconInfo *tcon,
++			const unsigned char *searchName,
++			FILE_UNIX_BASIC_INFO * pFindData,
++			const struct nls_table *nls_codepage);
++
++extern int CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
++			const unsigned char *searchName,
++			unsigned char **targetUNCs,
++			unsigned int *number_of_UNC_in_array,
++			const struct nls_table *nls_codepage);
++
++extern int connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
++			const char *old_path,
++			const struct nls_table *nls_codepage);
++extern int get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
++			const char *old_path, const struct nls_table *nls_codepage, 
++			unsigned int *pnum_referrals, unsigned char ** preferrals);
++extern int CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon,
++			struct statfs *FSData,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBQFSAttributeInfo(const int xid,
++			struct cifsTconInfo *tcon,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon,
++			const struct nls_table *nls_codepage);
++
++extern int CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon,
++			char *fileName, FILE_BASIC_INFO * data,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon,
++			char *fileName, __u64 size,int setAllocationSizeFlag,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon,
++			 __u64 size, __u16 fileHandle,__u32 opener_pid, int AllocSizeFlag);
++extern int CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *pTcon,
++			char *full_path, __u64 mode, __u64 uid,
++			__u64 gid, dev_t dev, const struct nls_table *nls_codepage);
++
++extern int CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
++			const char *newName,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon,
++			const char *name, const struct nls_table *nls_codepage);
++
++extern int CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon,
++			const char *name,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
++			const char *fromName, const char *toName,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
++			int netfid, char * target_name, const struct nls_table *nls_codepage);
++extern int CIFSCreateHardLink(const int xid,
++			struct cifsTconInfo *tcon,
++			const char *fromName, const char *toName,
++			const struct nls_table *nls_codepage);
++extern int CIFSUnixCreateHardLink(const int xid,
++			struct cifsTconInfo *tcon,
++			const char *fromName, const char *toName,
++			const struct nls_table *nls_codepage);
++extern int CIFSUnixCreateSymLink(const int xid,
++			struct cifsTconInfo *tcon,
++			const char *fromName, const char *toName,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBUnixQuerySymLink(const int xid,
++			struct cifsTconInfo *tcon,
++			const unsigned char *searchName,
++			char *syminfo, const int buflen,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBQueryReparseLinkInfo(const int xid, 
++			struct cifsTconInfo *tcon,
++			const unsigned char *searchName,
++			char *symlinkinfo, const int buflen, __u16 fid,
++			const struct nls_table *nls_codepage);
++
++extern int CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
++			const char *fileName, const int disposition,
++			const int access_flags, const int omode,
++			__u16 * netfid, int *pOplock, FILE_ALL_INFO *,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBClose(const int xid, struct cifsTconInfo *tcon,
++			const int smb_file_id);
++
++extern int CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
++			const int netfid, unsigned int count,
++			const __u64 lseek, unsigned int *nbytes, char **buf);
++extern int CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
++			const int netfid, const unsigned int count,
++			const __u64 lseek, unsigned int *nbytes,
++			const char *buf, const int long_op);
++extern int CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
++			const __u16 netfid, const __u64 len,
++			const __u64 offset, const __u32 numUnlock,
++			const __u32 numLock, const __u8 lockType,
++			const int waitFlag);
++
++extern int CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon);
++extern int CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses);
++
++extern struct cifsSesInfo *sesInfoAlloc(void);
++extern void sesInfoFree(struct cifsSesInfo *);
++extern struct cifsTconInfo *tconInfoAlloc(void);
++extern void tconInfoFree(struct cifsTconInfo *);
++
++extern int cifs_reconnect(struct TCP_Server_Info *server);
++
++extern int cifs_sign_smb(struct smb_hdr *, struct cifsSesInfo *,__u32 *);
++extern int cifs_verify_signature(const struct smb_hdr *, const char * mac_key,
++	__u32 expected_sequence_number);
++extern int cifs_calculate_mac_key(char * key,const char * rn,const char * pass);
++extern void CalcNTLMv2_partial_mac_key(struct cifsSesInfo *, struct nls_table *);
++extern void CalcNTLMv2_response(const struct cifsSesInfo *,char * );
++
++extern int CIFSBuildServerList(int xid, char *serverBufferList,
++			int recordlength, int *entries,
++			int *totalEntries, int *topoChangedFlag);
++extern int CIFSSMBQueryShares(int xid, struct cifsTconInfo *tcon,
++			struct shareInfo *shareList, int bufferLen,
++			int *entries, int *totalEntries);
++extern int CIFSSMBQueryAlias(int xid, struct cifsTconInfo *tcon,
++			struct aliasInfo *aliasList, int bufferLen,
++			int *entries, int *totalEntries);
++extern int CIFSSMBAliasInfo(int xid, struct cifsTconInfo *tcon,
++			char *aliasName, char *serverName,
++			char *shareName, char *comment);
++extern int CIFSSMBGetShareInfo(int xid, struct cifsTconInfo *tcon,
++			char *share, char *comment);
++extern int CIFSSMBGetUserPerms(int xid, struct cifsTconInfo *tcon,
++			char *userName, char *searchName, int *perms);
++extern int CIFSSMBSync(int xid, struct cifsTconInfo *tcon, int netfid, int pid);
++
++extern int CIFSSMBSeek(int xid,
++			struct cifsTconInfo *tcon,
++			int netfid,
++			int pid,
++			int whence, unsigned long offset, long long *newoffset);
++
++extern int CIFSSMBCopy(int xid,
++			struct cifsTconInfo *source_tcon,
++			const char *fromName,
++			const __u16 target_tid,
++			const char *toName, const int flags,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon, 
++			const int notify_subdirs,const __u16 netfid,__u32 filter,
++			const struct nls_table *nls_codepage);
++extern int CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
++		 const unsigned char *searchName,
++		 char * EAData, size_t size,
++		 const struct nls_table *nls_codepage);
++#endif			/* _CIFSPROTO_H */
+diff -urN linux-2.4.29.old/fs/cifs/cifssmb.c linux-2.4.29/fs/cifs/cifssmb.c
+--- linux-2.4.29.old/fs/cifs/cifssmb.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifssmb.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,3016 @@
++/*
++ *   fs/cifs/cifssmb.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   Contains the routines for constructing the SMB PDUs themselves
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++ /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c   */
++ /* These are mostly routines that operate on a pathname, or on a tree id     */
++ /* (mounted volume), but there are eight handle based routines which must be */
++ /* treated slightly different for reconnection purposes since we never want  */
++ /* to reuse a stale file handle and the caller knows the file handle */
++
++#include <linux/fs.h>
++#include <linux/kernel.h>
++#include <linux/vfs.h>
++#include <asm/uaccess.h>
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_unicode.h"
++#include "cifs_debug.h"
++
++#ifdef CONFIG_CIFS_POSIX
++static struct {
++	int index;
++	char *name;
++} protocols[] = {
++	{CIFS_PROT, "\2NT LM 0.12"}, 
++	{CIFS_PROT, "\2POSIX 2"},
++	{BAD_PROT, "\2"}
++};
++#else
++static struct {
++	int index;
++	char *name;
++} protocols[] = {
++	{CIFS_PROT, "\2NT LM 0.12"}, 
++	{BAD_PROT, "\2"}
++};
++#endif
++
++
++/* Mark as invalid, all open files on tree connections since they
++   were closed when session to server was lost */
++static void mark_open_files_invalid(struct cifsTconInfo * pTcon)
++{
++	struct cifsFileInfo *open_file = NULL;
++	struct list_head * tmp;
++	struct list_head * tmp1;
++
++/* list all files open on tree connection and mark them invalid */
++	write_lock(&GlobalSMBSeslock);
++	list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
++		open_file = list_entry(tmp,struct cifsFileInfo, tlist);
++		if(open_file) {
++			open_file->invalidHandle = TRUE;
++		}
++	}
++	write_unlock(&GlobalSMBSeslock);
++	/* BB Add call to invalidate_inodes(sb) for all superblocks mounted to this tcon */
++}
++
++static int
++smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
++	 void **request_buf /* returned */ ,
++	 void **response_buf /* returned */ )
++{
++	int rc = 0;
++	int timeout = 10 * HZ;
++
++	/* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
++	   check for tcp and smb session status done differently
++	   for those three - in the calling routine */
++	if(tcon) {
++		if((tcon->ses) && (tcon->ses->server)){
++			struct nls_table *nls_codepage;
++				/* Give Demultiplex thread up to 10 seconds to 
++					reconnect, should be greater than cifs socket
++					timeout which is 7 seconds */
++			while(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
++				while ((tcon->ses->server->tcpStatus != CifsGood) && (timeout > 0)){
++					timeout = interruptible_sleep_on_timeout(&tcon->ses->server->response_q,timeout);
++				}
++				if(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
++					/* on "soft" mounts we wait once */
++					if((tcon->retry == FALSE) || 
++					   (tcon->ses->status == CifsExiting)) {
++						cFYI(1,("gave up waiting on reconnect in smb_init"));
++						return -EHOSTDOWN;
++					} /* else "hard" mount - keep retrying until 
++					process is killed or server comes back up */
++				} else /* TCP session is reestablished now */
++					break;
++				 
++			}
++			
++			nls_codepage = load_nls_default();
++		/* need to prevent multiple threads trying to
++		simultaneously reconnect the same SMB session */
++			down(&tcon->ses->sesSem);
++			if(tcon->ses->status == CifsNeedReconnect)
++				rc = cifs_setup_session(0, tcon->ses, nls_codepage);
++			if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
++				mark_open_files_invalid(tcon);
++				rc = CIFSTCon(0, tcon->ses, tcon->treeName, tcon,
++					nls_codepage);
++				up(&tcon->ses->sesSem);
++				if(rc == 0)
++					atomic_inc(&tconInfoReconnectCount);
++
++				cFYI(1, ("reconnect tcon rc = %d", rc));
++				/* Removed call to reopen open files here - 
++					it is safer (and faster) to reopen files
++					one at a time as needed in read and write */
++
++				/* Check if handle based operation so we 
++					know whether we can continue or not without
++					returning to caller to reset file handle */
++				switch(smb_command) {
++					case SMB_COM_READ_ANDX:
++					case SMB_COM_WRITE_ANDX:
++					case SMB_COM_CLOSE:
++					case SMB_COM_FIND_CLOSE2:
++					case SMB_COM_LOCKING_ANDX: {
++						unload_nls(nls_codepage);
++						return -EAGAIN;
++					}
++				}
++			} else {
++				up(&tcon->ses->sesSem);
++			}
++			unload_nls(nls_codepage);
++
++		} else {
++			return -EIO;
++		}
++	}
++	if(rc)
++		return rc;
++
++	*request_buf = cifs_buf_get();
++	if (*request_buf == 0) {
++		/* BB should we add a retry in here if not a writepage? */
++		return -ENOMEM;
++	}
++    /* Although the original thought was we needed the response buf for  */
++    /* potential retries of smb operations it turns out we can determine */
++    /* from the mid flags when the request buffer can be resent without  */
++    /* having to use a second distinct buffer for the response */
++	*response_buf = *request_buf; 
++
++	header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
++			wct /*wct */ );
++
++#ifdef CONFIG_CIFS_STATS
++        if(tcon != NULL) {
++                atomic_inc(&tcon->num_smbs_sent);
++        }
++#endif
++	return rc;
++}
++
++int
++CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
++{
++	NEGOTIATE_REQ *pSMB;
++	NEGOTIATE_RSP *pSMBr;
++	int rc = 0;
++	int bytes_returned;
++	struct TCP_Server_Info * server;
++
++	if(ses->server)
++		server = ses->server;
++	else {
++		rc = -EIO;
++		return rc;
++	}
++	rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
++		      (void **) &pSMB, (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
++	if (extended_security)
++		pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
++
++	pSMB->ByteCount = strlen(protocols[0].name) + 1;
++	strncpy(pSMB->DialectsArray, protocols[0].name, 30);	
++    /* null guaranteed to be at end of source and target buffers anyway */
++
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc == 0) {
++		server->secMode = pSMBr->SecurityMode;	
++		server->secType = NTLM; /* BB override default for NTLMv2 or krb*/
++		/* one byte - no need to convert this or EncryptionKeyLen from le,*/
++		server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
++		/* probably no need to store and check maxvcs */
++		server->maxBuf =
++			min(le32_to_cpu(pSMBr->MaxBufferSize),
++			(__u32) CIFS_MAX_MSGSIZE + MAX_CIFS_HDR_SIZE);
++		server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
++		cFYI(0, ("Max buf = %d ", ses->server->maxBuf));
++		GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
++		server->capabilities = le32_to_cpu(pSMBr->Capabilities);
++		server->timeZone = le16_to_cpu(pSMBr->ServerTimeZone);	
++        /* BB with UTC do we ever need to be using srvr timezone? */
++		if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
++			memcpy(server->cryptKey, pSMBr->u.EncryptionKey,
++			       CIFS_CRYPTO_KEY_SIZE);
++		} else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC)
++			   && (pSMBr->EncryptionKeyLength == 0)) {
++			/* decode security blob */
++		} else
++			rc = -EIO;
++
++		/* BB might be helpful to save off the domain of server here */
++
++		if (pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) {
++			if (pSMBr->ByteCount < 16)
++				rc = -EIO;
++			else if (pSMBr->ByteCount == 16) {
++				server->secType = RawNTLMSSP;
++				if (server->socketUseCount.counter > 1) {
++					if (memcmp
++						(server->server_GUID,
++						pSMBr->u.extended_response.
++						GUID, 16) != 0) {
++						cFYI(1,
++							("UID of server does not match previous connection to same ip address"));
++						memcpy(server->
++							server_GUID,
++							pSMBr->u.
++							extended_response.
++							GUID, 16);
++					}
++				} else
++					memcpy(server->server_GUID,
++					       pSMBr->u.extended_response.
++					       GUID, 16);
++			} else {
++				rc = decode_negTokenInit(pSMBr->u.
++							 extended_response.
++							 SecurityBlob,
++							 pSMBr->ByteCount -
++							 16, &server->secType);
++			}
++		} else
++			server->capabilities &= ~CAP_EXTENDED_SECURITY;
++		if(sign_CIFS_PDUs == FALSE) {        
++			if(server->secMode & SECMODE_SIGN_REQUIRED)
++				cERROR(1,
++				 ("Server requires /proc/fs/cifs/PacketSigningEnabled"));
++			server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
++		} else if(sign_CIFS_PDUs == 1) {
++			if((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
++				server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
++		}
++				
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	return rc;
++}
++
++int
++CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
++{
++	struct smb_hdr *smb_buffer;
++	struct smb_hdr *smb_buffer_response;
++	int rc = 0;
++	int length;
++
++	cFYI(1, ("In tree disconnect"));
++	/*
++	 *  If last user of the connection and
++	 *  connection alive - disconnect it
++	 *  If this is the last connection on the server session disconnect it
++	 *  (and inside session disconnect we should check if tcp socket needs 
++	 *  to be freed and kernel thread woken up).
++	 */
++	if (tcon)
++		down(&tcon->tconSem);
++	else
++		return -EIO;
++
++	atomic_dec(&tcon->useCount);
++	if (atomic_read(&tcon->useCount) > 0) {
++		up(&tcon->tconSem);
++		return -EBUSY;
++	}
++
++	/* No need to return error on this operation if tid invalidated and 
++	closed on server already e.g. due to tcp session crashing */
++	if(tcon->tidStatus == CifsNeedReconnect) {
++		up(&tcon->tconSem);
++		return 0;  
++	}
++
++	if((tcon->ses == 0) || (tcon->ses->server == 0)) {    
++		up(&tcon->tconSem);
++		return -EIO;
++	}
++
++	rc = smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
++		      (void **) &smb_buffer, (void **) &smb_buffer_response);
++	if (rc) {
++		up(&tcon->tconSem);
++		return rc;
++	}
++	rc = SendReceive(xid, tcon->ses, smb_buffer, smb_buffer_response,
++			 &length, 0);
++	if (rc)
++		cFYI(1, (" Tree disconnect failed %d", rc));
++
++	if (smb_buffer)
++		cifs_buf_release(smb_buffer);
++	up(&tcon->tconSem);
++
++	/* No need to return error on this operation if tid invalidated and 
++	closed on server already e.g. due to tcp session crashing */
++	if (rc == -EAGAIN)
++		rc = 0;
++
++	return rc;
++}
++
++int
++CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
++{
++	struct smb_hdr *smb_buffer_response;
++	LOGOFF_ANDX_REQ *pSMB;
++	int rc = 0;
++	int length;
++
++	cFYI(1, ("In SMBLogoff for session disconnect"));
++	if (ses)
++		down(&ses->sesSem);
++	else
++		return -EIO;
++
++	atomic_dec(&ses->inUse);
++	if (atomic_read(&ses->inUse) > 0) {
++		up(&ses->sesSem);
++		return -EBUSY;
++	}
++
++	rc = smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL /* no tcon anymore */,
++		 (void **) &pSMB, (void **) &smb_buffer_response);
++
++	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
++		pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
++
++	if (rc) {
++		up(&ses->sesSem);
++		return rc;
++	}
++
++	pSMB->hdr.Uid = ses->Suid;
++
++	pSMB->AndXCommand = 0xFF;
++	rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
++			 smb_buffer_response, &length, 0);
++	if (ses->server) {
++		atomic_dec(&ses->server->socketUseCount);
++		if (atomic_read(&ses->server->socketUseCount) == 0) {
++			spin_lock(&GlobalMid_Lock);
++			ses->server->tcpStatus = CifsExiting;
++			spin_unlock(&GlobalMid_Lock);
++			rc = -ESHUTDOWN;
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	up(&ses->sesSem);
++
++	/* if session dead then we do not need to do ulogoff,
++		since server closed smb session, no sense reporting 
++		error */
++	if (rc == -EAGAIN)
++		rc = 0;
++	return rc;
++}
++
++int
++CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon,
++	       const char *fileName, const struct nls_table *nls_codepage)
++{
++	DELETE_FILE_REQ *pSMB = NULL;
++	DELETE_FILE_RSP *pSMBr = NULL;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++
++DelFileRetry:
++	rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->fileName, fileName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fileName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->fileName, fileName, name_len);
++	}
++	pSMB->SearchAttributes =
++	    cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
++	pSMB->ByteCount = name_len + 1;
++	pSMB->BufferFormat = 0x04;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Error in RMFile = %d", rc));
++	} 
++#ifdef CONFIG_CIFS_STATS
++        else {
++		atomic_inc(&tcon->num_deletes);
++        }
++#endif
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto DelFileRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon,
++	     const char *dirName, const struct nls_table *nls_codepage)
++{
++	DELETE_DIRECTORY_REQ *pSMB = NULL;
++	DELETE_DIRECTORY_RSP *pSMBr = NULL;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++
++	cFYI(1, ("In CIFSSMBRmDir"));
++RmDirRetry:
++	rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len = cifs_strtoUCS((wchar_t *) pSMB->DirName, dirName, 530
++				/* find define for this maxpathcomponent */
++				, nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(dirName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->DirName, dirName, name_len);
++	}
++
++	pSMB->ByteCount = name_len + 1;
++	pSMB->BufferFormat = 0x04;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Error in RMDir = %d", rc));
++	}
++#ifdef CONFIG_CIFS_STATS
++        else {
++		atomic_inc(&tcon->num_rmdirs);
++        }
++#endif
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto RmDirRetry;
++	return rc;
++}
++
++int
++CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
++	     const char *name, const struct nls_table *nls_codepage)
++{
++	int rc = 0;
++	CREATE_DIRECTORY_REQ *pSMB = NULL;
++	CREATE_DIRECTORY_RSP *pSMBr = NULL;
++	int bytes_returned;
++	int name_len;
++
++	cFYI(1, ("In CIFSSMBMkDir"));
++MkDirRetry:
++	rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len = cifs_strtoUCS((wchar_t *) pSMB->DirName, name, 530
++					 /* find define for this maxpathcomponent */
++					 , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(name, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->DirName, name, name_len);
++	}
++
++	pSMB->ByteCount = name_len + 1 /* for buf format */ ;
++	pSMB->BufferFormat = 0x04;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Error in Mkdir = %d", rc));
++	}
++#ifdef CONFIG_CIFS_STATS
++        else {
++		atomic_inc(&tcon->num_mkdirs);
++        }
++#endif
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto MkDirRetry;
++	return rc;
++}
++
++int
++CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
++	    const char *fileName, const int openDisposition,
++	    const int access_flags, const int create_options, __u16 * netfid,
++	    int *pOplock, FILE_ALL_INFO * pfile_info, 
++	    const struct nls_table *nls_codepage)
++{
++	int rc = -EACCES;
++	OPEN_REQ *pSMB = NULL;
++	OPEN_RSP *pSMBr = NULL;
++	int bytes_returned;
++	int name_len;
++
++openRetry:
++	rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->AndXCommand = 0xFF;	/* none */
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		pSMB->ByteCount = 1;	/* account for one byte pad to word boundary */
++		name_len =
++		    cifs_strtoUCS((wchar_t *) (pSMB->fileName + 1),
++				  fileName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++		pSMB->NameLength = cpu_to_le16(name_len);
++	} else {		/* BB improve the check for buffer overruns BB */
++		pSMB->ByteCount = 0;	/* no pad */
++		name_len = strnlen(fileName, 530);
++		name_len++;	/* trailing null */
++		pSMB->NameLength = cpu_to_le16(name_len);
++		strncpy(pSMB->fileName, fileName, name_len);
++	}
++	if (*pOplock & REQ_OPLOCK)
++		pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
++	else if (*pOplock & REQ_BATCHOPLOCK) {
++		pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
++	}
++	pSMB->DesiredAccess = cpu_to_le32(access_flags);
++	pSMB->AllocationSize = 0;
++	pSMB->FileAttributes = ATTR_NORMAL;
++	/* XP does not handle ATTR_POSIX_SEMANTICS */
++	/* but it helps speed up case sensitive checks for other
++	servers such as Samba */
++	if (tcon->ses->capabilities & CAP_UNIX)
++		pSMB->FileAttributes |= ATTR_POSIX_SEMANTICS;
++
++	/* if ((omode & S_IWUGO) == 0)
++		pSMB->FileAttributes |= ATTR_READONLY;*/
++	/*  Above line causes problems due to vfs splitting create into two
++		pieces - need to set mode after file created not while it is
++		being created */
++	pSMB->FileAttributes = cpu_to_le32(pSMB->FileAttributes);
++	pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
++	pSMB->CreateDisposition = cpu_to_le32(openDisposition);
++	pSMB->CreateOptions = cpu_to_le32(create_options);
++	pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);	/* BB ??*/
++	pSMB->SecurityFlags =
++	    cpu_to_le32(SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY);
++
++	pSMB->ByteCount += name_len;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	/* long_op set to 1 to allow for oplock break timeouts */
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
++	if (rc) {
++		cFYI(1, ("Error in Open = %d", rc));
++	} else {
++		*pOplock = pSMBr->OplockLevel;	/* one byte no need to le_to_cpu */
++		*netfid = pSMBr->Fid;	/* cifs fid stays in le */
++		/* Let caller know file was created so we can set the mode. */
++		/* Do we care about the CreateAction in any other cases? */
++		if(cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
++			*pOplock |= CIFS_CREATE_ACTION; 
++		if(pfile_info) {
++		    memcpy((char *)pfile_info,(char *)&pSMBr->CreationTime,
++			36 /* CreationTime to Attributes */);
++		    /* the file_info buf is endian converted by caller */
++		    pfile_info->AllocationSize = pSMBr->AllocationSize;
++		    pfile_info->EndOfFile = pSMBr->EndOfFile;
++		    pfile_info->NumberOfLinks = cpu_to_le32(1);
++		}
++
++#ifdef CONFIG_CIFS_STATS
++		atomic_inc(&tcon->num_opens);
++#endif
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto openRetry;
++	return rc;
++}
++
++/* If no buffer passed in, then caller wants to do the copy
++	as in the case of readpages so the SMB buffer must be
++	freed by the caller */
++
++int
++CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
++	    const int netfid, const unsigned int count,
++	    const __u64 lseek, unsigned int *nbytes, char **buf)
++{
++	int rc = -EACCES;
++	READ_REQ *pSMB = NULL;
++	READ_RSP *pSMBr = NULL;
++	char *pReadData = NULL;
++	int bytes_returned;
++
++	*nbytes = 0;
++	rc = smb_init(SMB_COM_READ_ANDX, 12, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	/* tcon and ses pointer are checked in smb_init */
++	if (tcon->ses->server == NULL)
++		return -ECONNABORTED;
++
++	pSMB->AndXCommand = 0xFF;	/* none */
++	pSMB->Fid = netfid;
++	pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
++	pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
++	pSMB->Remaining = 0;
++	pSMB->MaxCount = cpu_to_le16(count);
++	pSMB->MaxCountHigh = 0;
++	pSMB->ByteCount = 0;  /* no need to do le conversion since it is 0 */
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cERROR(1, ("Send error in read = %d", rc));
++	} else {
++		pSMBr->DataLength = le16_to_cpu(pSMBr->DataLength);
++		*nbytes = pSMBr->DataLength;
++		/*check that DataLength would not go beyond end of SMB */
++		if ((pSMBr->DataLength > CIFS_MAX_MSGSIZE) 
++				|| (pSMBr->DataLength > count)) {
++			cFYI(1,("bad length %d for count %d",pSMBr->DataLength,count));
++			rc = -EIO;
++			*nbytes = 0;
++		} else {
++			pReadData =
++			    (char *) (&pSMBr->hdr.Protocol) +
++			    le16_to_cpu(pSMBr->DataOffset);
++/*			if(rc = copy_to_user(buf, pReadData, pSMBr->DataLength)) {
++				cERROR(1,("Faulting on read rc = %d",rc));
++				rc = -EFAULT;
++			}*/ /* can not use copy_to_user when using page cache*/
++			if(*buf)
++			    memcpy(*buf,pReadData,pSMBr->DataLength);
++		}
++	}
++	if (pSMB) {
++		if(*buf)
++			cifs_buf_release(pSMB);
++		else
++			*buf = (char *)pSMB;
++	}
++
++	/* Note: On -EAGAIN error only caller can retry on handle based calls 
++		since file handle passed in no longer valid */
++	return rc;
++}
++
++int
++CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
++	     const int netfid, const unsigned int count,
++	     const __u64 offset, unsigned int *nbytes, const char *buf,
++	     const int long_op)
++{
++	int rc = -EACCES;
++	WRITE_REQ *pSMB = NULL;
++	WRITE_RSP *pSMBr = NULL;
++	int bytes_returned;
++
++	rc = smb_init(SMB_COM_WRITE_ANDX, 14, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++	/* tcon and ses pointer are checked in smb_init */
++	if (tcon->ses->server == NULL)
++		return -ECONNABORTED;
++
++	pSMB->AndXCommand = 0xFF;	/* none */
++	pSMB->Fid = netfid;
++	pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
++	pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
++	pSMB->Remaining = 0;
++	if (count > ((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00))
++		pSMB->DataLengthLow =
++		    (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00;
++	else
++		pSMB->DataLengthLow = count;
++	pSMB->DataLengthHigh = 0;
++	pSMB->DataOffset =
++	    cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
++
++	memcpy(pSMB->Data,buf,pSMB->DataLengthLow);
++
++	pSMB->ByteCount += pSMB->DataLengthLow + 1 /* pad */ ;
++	pSMB->DataLengthLow = cpu_to_le16(pSMB->DataLengthLow);
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
++	if (rc) {
++		cFYI(1, ("Send error in write = %d", rc));
++		*nbytes = 0;
++	} else
++		*nbytes = le16_to_cpu(pSMBr->Count);
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Note: On -EAGAIN error only caller can retry on handle based calls 
++		since file handle passed in no longer valid */
++
++	return rc;
++}
++
++int
++CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
++	    const __u16 smb_file_id, const __u64 len,
++	    const __u64 offset, const __u32 numUnlock,
++	    const __u32 numLock, const __u8 lockType, const int waitFlag)
++{
++	int rc = 0;
++	LOCK_REQ *pSMB = NULL;
++	LOCK_RSP *pSMBr = NULL;
++	int bytes_returned;
++	int timeout = 0;
++	__u64 temp;
++
++	cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d",waitFlag,numLock));
++	rc = smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if(lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
++		timeout = -1; /* no response expected */
++		pSMB->Timeout = 0;
++	} else if (waitFlag == TRUE) {
++		timeout = 3;  /* blocking operation, no timeout */
++		pSMB->Timeout = -1; /* blocking - do not time out */
++	} else {
++		pSMB->Timeout = 0;
++	}
++
++	pSMB->NumberOfLocks = cpu_to_le32(numLock);
++	pSMB->NumberOfUnlocks = cpu_to_le32(numUnlock);
++	pSMB->LockType = lockType;
++	pSMB->AndXCommand = 0xFF;	/* none */
++	pSMB->Fid = smb_file_id; /* netfid stays le */
++
++	if(numLock != 0) {
++		pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
++		/* BB where to store pid high? */
++		temp = cpu_to_le64(len);
++		pSMB->Locks[0].LengthLow = (__u32)(temp & 0xFFFFFFFF);
++		pSMB->Locks[0].LengthHigh =  (__u32)(temp>>32);
++		temp = cpu_to_le64(offset);
++		pSMB->Locks[0].OffsetLow = (__u32)(temp & 0xFFFFFFFF);
++		pSMB->Locks[0].OffsetHigh = (__u32)(temp>>32);
++		pSMB->ByteCount = sizeof (LOCKING_ANDX_RANGE);
++	} else {
++		/* oplock break */
++		pSMB->ByteCount = 0;
++	}
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
++
++	if (rc) {
++		cFYI(1, ("Send error in Lock = %d", rc));
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Note: On -EAGAIN error only caller can retry on handle based calls 
++	since file handle passed in no longer valid */
++	return rc;
++}
++
++int
++CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
++{
++	int rc = 0;
++	CLOSE_REQ *pSMB = NULL;
++	CLOSE_RSP *pSMBr = NULL;
++	int bytes_returned;
++	cFYI(1, ("In CIFSSMBClose"));
++
++/* do not retry on dead session on close */
++	rc = smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if(rc == -EAGAIN)
++		return 0;
++	if (rc)
++		return rc;
++
++	pSMB->FileID = (__u16) smb_file_id;
++	pSMB->LastWriteTime = 0;
++	pSMB->ByteCount = 0;
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		if(rc!=-EINTR) {
++			/* EINTR is expected when user ctl-c to kill app */
++			cERROR(1, ("Send error in Close = %d", rc));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Since session is dead, file will be closed on server already */
++	if(rc == -EAGAIN)
++		rc = 0;
++
++	return rc;
++}
++
++int
++CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
++	      const char *fromName, const char *toName,
++	      const struct nls_table *nls_codepage)
++{
++	int rc = 0;
++	RENAME_REQ *pSMB = NULL;
++	RENAME_RSP *pSMBr = NULL;
++	int bytes_returned;
++	int name_len, name_len2;
++
++	cFYI(1, ("In CIFSSMBRename"));
++renameRetry:
++	rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->BufferFormat = 0x04;
++	pSMB->SearchAttributes =
++	    cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
++			ATTR_DIRECTORY);
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->OldFileName, fromName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++		pSMB->OldFileName[name_len] = 0x04;	/* pad */
++	/* protocol requires ASCII signature byte on Unicode string */
++		pSMB->OldFileName[name_len + 1] = 0x00;
++		name_len2 =
++		    cifs_strtoUCS((wchar_t *) & pSMB->
++				  OldFileName[name_len + 2], toName, 530,
++				  nls_codepage);
++		name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
++		name_len2 *= 2;	/* convert to bytes */
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fromName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->OldFileName, fromName, name_len);
++		name_len2 = strnlen(toName, 530);
++		name_len2++;	/* trailing null */
++		pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
++		strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
++		name_len2++;	/* trailing null */
++		name_len2++;	/* signature byte */
++	}
++
++	pSMB->ByteCount = 1 /* 1st signature byte */  + name_len + name_len2;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in rename = %d", rc));
++	} 
++
++#ifdef CONFIG_CIFS_STATS
++	  else {
++		atomic_inc(&tcon->num_renames);
++	}
++#endif
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto renameRetry;
++
++	return rc;
++}
++
++int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon, 
++		int netfid, char * target_name, const struct nls_table * nls_codepage) 
++{
++	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
++	struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
++	struct set_file_rename * rename_info;
++	char *data_offset;
++	char dummy_string[30];
++	int rc = 0;
++	int bytes_returned = 0;
++	int len_of_str;
++
++	cFYI(1, ("Rename to File by handle"));
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
++			(void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->ParameterCount = 6;
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = offsetof(struct smb_com_transaction2_sfi_req,
++				Fid) - 4;
++	pSMB->DataOffset = pSMB->ParameterOffset + pSMB->ParameterCount;
++
++	data_offset = (char *) (&pSMB->hdr.Protocol) + pSMB->DataOffset;
++	rename_info = (struct set_file_rename *) data_offset;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
++	pSMB->ByteCount = 3 /* pad */  + pSMB->ParameterCount;
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(pSMB->ParameterOffset);
++	pSMB->DataOffset = cpu_to_le16(pSMB->DataOffset);
++	/* construct random name ".cifs_tmp<inodenum><mid>" */
++	rename_info->overwrite = cpu_to_le32(1);
++	rename_info->root_fid  = 0;
++	/* unicode only call */
++	if(target_name == NULL) {
++		sprintf(dummy_string,"cifs%x",pSMB->hdr.Mid);
++	        len_of_str = cifs_strtoUCS((wchar_t *) rename_info->target_name, dummy_string, 24, nls_codepage);
++	} else {
++		len_of_str = cifs_strtoUCS((wchar_t *) rename_info->target_name, target_name, 530, nls_codepage);
++	}
++	rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
++	pSMB->DataCount = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
++	pSMB->ByteCount += pSMB->DataCount;
++	pSMB->DataCount = cpu_to_le16(pSMB->DataCount);
++	pSMB->TotalDataCount = pSMB->DataCount;
++	pSMB->Fid = netfid;
++	pSMB->InformationLevel =
++		cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
++                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1,("Send error in Rename (by file handle) = %d", rc));
++	}
++#ifdef CONFIG_CIFS_STATS
++	  else {
++		atomic_inc(&pTcon->num_t2renames);
++	}
++#endif
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Note: On -EAGAIN error only caller can retry on handle based calls
++		since file handle passed in no longer valid */
++
++	return rc;
++}
++
++int
++CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char * fromName, 
++            const __u16 target_tid, const char *toName, const int flags,
++            const struct nls_table *nls_codepage)
++{
++	int rc = 0;
++	COPY_REQ *pSMB = NULL;
++	COPY_RSP *pSMBr = NULL;
++	int bytes_returned;
++	int name_len, name_len2;
++
++	cFYI(1, ("In CIFSSMBCopy"));
++copyRetry:
++	rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
++			(void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->BufferFormat = 0x04;
++	pSMB->Tid2 = target_tid;
++
++	if(flags & COPY_TREE)
++		pSMB->Flags |= COPY_TREE;
++	pSMB->Flags = cpu_to_le16(pSMB->Flags);
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len = cifs_strtoUCS((wchar_t *) pSMB->OldFileName, 
++				fromName, 
++				530 /* find define for this maxpathcomponent */,
++				nls_codepage);
++		name_len++;     /* trailing null */
++		name_len *= 2;
++		pSMB->OldFileName[name_len] = 0x04;     /* pad */
++		/* protocol requires ASCII signature byte on Unicode string */
++		pSMB->OldFileName[name_len + 1] = 0x00;
++		name_len2 = cifs_strtoUCS((wchar_t *) & pSMB->
++				OldFileName[name_len + 2], toName, 530,
++				nls_codepage);
++		name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
++		name_len2 *= 2; /* convert to bytes */
++	} else {                /* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fromName, 530);
++		name_len++;     /* trailing null */
++		strncpy(pSMB->OldFileName, fromName, name_len);
++		name_len2 = strnlen(toName, 530);
++		name_len2++;    /* trailing null */
++		pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
++		strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
++		name_len2++;    /* trailing null */
++		name_len2++;    /* signature byte */
++	}
++
++	pSMB->ByteCount = 1 /* 1st signature byte */  + name_len + name_len2;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++		(struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in copy = %d with %d files copied",
++			rc, pSMBr->CopyCount));
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto copyRetry;
++
++	return rc;
++}
++
++int
++CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
++		      const char *fromName, const char *toName,
++		      const struct nls_table *nls_codepage)
++{
++	TRANSACTION2_SPI_REQ *pSMB = NULL;
++	TRANSACTION2_SPI_RSP *pSMBr = NULL;
++	char *data_offset;
++	int name_len;
++	int name_len_target;
++	int rc = 0;
++	int bytes_returned = 0;
++
++	cFYI(1, ("In Symlink Unix style"));
++createSymLinkRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, fromName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fromName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, fromName, name_len);
++	}
++	pSMB->ParameterCount = 6 + name_len;
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = offsetof(struct smb_com_transaction2_spi_req,
++                                     InformationLevel) - 4;
++	pSMB->DataOffset = pSMB->ParameterOffset + pSMB->ParameterCount;
++
++	data_offset = (char *) (&pSMB->hdr.Protocol) + pSMB->DataOffset;
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len_target =
++		    cifs_strtoUCS((wchar_t *) data_offset, toName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len_target++;	/* trailing null */
++		name_len_target *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len_target = strnlen(toName, 530);
++		name_len_target++;	/* trailing null */
++		strncpy(data_offset, toName, name_len_target);
++	}
++
++	pSMB->DataCount = name_len_target;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	/* BB find exact max on data count below from sess */
++	pSMB->MaxDataCount = cpu_to_le16(1000);
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
++	pSMB->ByteCount = 3 /* pad */  + pSMB->ParameterCount + pSMB->DataCount;
++	pSMB->DataCount = cpu_to_le16(pSMB->DataCount);
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalDataCount = pSMB->DataCount;
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(pSMB->ParameterOffset);
++	pSMB->DataOffset = cpu_to_le16(pSMB->DataOffset);
++	pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1,
++		     ("Send error in SetPathInfo (create symlink) = %d",
++		      rc));
++	}
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto createSymLinkRetry;
++
++	return rc;
++}
++
++int
++CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
++		       const char *fromName, const char *toName,
++		       const struct nls_table *nls_codepage)
++{
++	TRANSACTION2_SPI_REQ *pSMB = NULL;
++	TRANSACTION2_SPI_RSP *pSMBr = NULL;
++	char *data_offset;
++	int name_len;
++	int name_len_target;
++	int rc = 0;
++	int bytes_returned = 0;
++
++	cFYI(1, ("In Create Hard link Unix style"));
++createHardLinkRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len = cifs_strtoUCS((wchar_t *) pSMB->FileName, toName, 530
++					 /* find define for this maxpathcomponent */
++					 , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(toName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, toName, name_len);
++	}
++	pSMB->ParameterCount = 6 + name_len;
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = offsetof(struct smb_com_transaction2_spi_req,
++                                     InformationLevel) - 4;
++	pSMB->DataOffset = pSMB->ParameterOffset + pSMB->ParameterCount;
++
++	data_offset = (char *) (&pSMB->hdr.Protocol) + pSMB->DataOffset;
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len_target =
++		    cifs_strtoUCS((wchar_t *) data_offset, fromName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len_target++;	/* trailing null */
++		name_len_target *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len_target = strnlen(fromName, 530);
++		name_len_target++;	/* trailing null */
++		strncpy(data_offset, fromName, name_len_target);
++	}
++
++	pSMB->DataCount = name_len_target;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	/* BB find exact max on data count below from sess*/
++	pSMB->MaxDataCount = cpu_to_le16(1000);
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
++	pSMB->ByteCount = 3 /* pad */  + pSMB->ParameterCount + pSMB->DataCount;
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->DataCount = cpu_to_le16(pSMB->DataCount);
++	pSMB->TotalDataCount = pSMB->DataCount;
++	pSMB->ParameterOffset = cpu_to_le16(pSMB->ParameterOffset);
++	pSMB->DataOffset = cpu_to_le16(pSMB->DataOffset);
++	pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
++	}
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto createHardLinkRetry;
++
++	return rc;
++}
++
++int
++CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
++		   const char *fromName, const char *toName,
++		   const struct nls_table *nls_codepage)
++{
++	int rc = 0;
++	NT_RENAME_REQ *pSMB = NULL;
++	RENAME_RSP *pSMBr = NULL;
++	int bytes_returned;
++	int name_len, name_len2;
++
++	cFYI(1, ("In CIFSCreateHardLink"));
++winCreateHardLinkRetry:
++
++	rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->SearchAttributes =
++	    cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
++			ATTR_DIRECTORY);
++	pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
++	pSMB->ClusterCount = 0;
++
++	pSMB->BufferFormat = 0x04;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->OldFileName, fromName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++		pSMB->OldFileName[name_len] = 0;	/* pad */
++		pSMB->OldFileName[name_len + 1] = 0x04; 
++		name_len2 =
++		    cifs_strtoUCS((wchar_t *) & pSMB->
++				  OldFileName[name_len + 2], toName, 530,
++				  nls_codepage);
++		name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
++		name_len2 *= 2;	/* convert to bytes */
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fromName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->OldFileName, fromName, name_len);
++		name_len2 = strnlen(toName, 530);
++		name_len2++;	/* trailing null */
++		pSMB->OldFileName[name_len] = 0x04;	/* 2nd buffer format */
++		strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
++		name_len2++;	/* trailing null */
++		name_len2++;	/* signature byte */
++	}
++
++	pSMB->ByteCount = 1 /* string type byte */  + name_len + name_len2;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto winCreateHardLinkRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
++			const unsigned char *searchName,
++			char *symlinkinfo, const int buflen,
++			const struct nls_table *nls_codepage)
++{
++/* SMB_QUERY_FILE_UNIX_LINK */
++	TRANSACTION2_QPI_REQ *pSMB = NULL;
++	TRANSACTION2_QPI_RSP *pSMBr = NULL;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++
++	cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
++
++querySymLinkRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(searchName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, searchName, name_len);
++	}
++
++	pSMB->TotalParameterCount =
++	    2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	/* BB find exact max data count below from sess structure BB */
++	pSMB->MaxDataCount = cpu_to_le16(4000);
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		pSMBr->DataCount = le16_to_cpu(pSMBr->DataCount);
++		if ((pSMBr->ByteCount < 2) || (pSMBr->DataOffset > 512))
++		/* BB also check enough total bytes returned */
++			rc = -EIO;	/* bad smb */
++		else {
++			if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
++				name_len = UniStrnlen((wchar_t *) ((char *)
++					&pSMBr->hdr.Protocol +pSMBr->DataOffset),
++					min_t(const int, buflen,pSMBr->DataCount) / 2);
++				cifs_strfromUCS_le(symlinkinfo,
++					(wchar_t *) ((char *)&pSMBr->hdr.Protocol +
++						pSMBr->DataOffset),
++					name_len, nls_codepage);
++			} else {
++				strncpy(symlinkinfo,
++					(char *) &pSMBr->hdr.Protocol + 
++						pSMBr->DataOffset,
++					min_t(const int, buflen, pSMBr->DataCount));
++			}
++			symlinkinfo[buflen] = 0;
++	/* just in case so calling code does not go off the end of buffer */
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto querySymLinkRetry;
++	return rc;
++}
++
++
++
++int
++CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
++			const unsigned char *searchName,
++			char *symlinkinfo, const int buflen,__u16 fid,
++			const struct nls_table *nls_codepage)
++{
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++	struct smb_com_transaction_ioctl_req * pSMB;
++	struct smb_com_transaction_ioctl_rsp * pSMBr;
++
++	cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
++	rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->TotalParameterCount = 0 ;
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le32(2);
++	/* BB find exact data count max from sess structure BB */
++	pSMB->MaxDataCount = cpu_to_le32(4000);
++	pSMB->MaxSetupCount = 4;
++	pSMB->Reserved = 0;
++	pSMB->ParameterOffset = 0;
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 4;
++	pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
++	pSMB->IsFsctl = 1; /* FSCTL */
++	pSMB->IsRootFlag = 0;
++	pSMB->Fid = fid; /* file handle always le */
++	pSMB->ByteCount = 0;
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		pSMBr->DataCount = le16_to_cpu(pSMBr->DataCount);
++		if ((pSMBr->ByteCount < 2) || (pSMBr->DataOffset > 512))
++		/* BB also check enough total bytes returned */
++			rc = -EIO;	/* bad smb */
++		else {
++			if(pSMBr->DataCount && (pSMBr->DataCount < 2048)) {
++		/* could also validate reparse tag && better check name length */
++				struct reparse_data * reparse_buf = (struct reparse_data *)
++					((char *)&pSMBr->hdr.Protocol + pSMBr->DataOffset);
++				if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
++					name_len = UniStrnlen((wchar_t *)
++							(reparse_buf->LinkNamesBuf + 
++							reparse_buf->TargetNameOffset),
++							min(buflen/2, reparse_buf->TargetNameLen / 2)); 
++					cifs_strfromUCS_le(symlinkinfo,
++						(wchar_t *) (reparse_buf->LinkNamesBuf + 
++						reparse_buf->TargetNameOffset),
++						name_len, nls_codepage);
++				} else { /* ASCII names */
++					strncpy(symlinkinfo,reparse_buf->LinkNamesBuf + 
++						reparse_buf->TargetNameOffset, 
++						min_t(const int, buflen, reparse_buf->TargetNameLen));
++				}
++			} else {
++				rc = -EIO;
++				cFYI(1,("Invalid return data count on get reparse info ioctl"));
++			}
++			symlinkinfo[buflen] = 0; /* just in case so the caller
++					does not go off the end of the buffer */
++			cFYI(1,("readlink result - %s ",symlinkinfo));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Note: On -EAGAIN error only caller can retry on handle based calls
++		since file handle passed in no longer valid */
++
++	return rc;
++}
++
++int
++CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
++		 const unsigned char *searchName,
++		 FILE_ALL_INFO * pFindData,
++		 const struct nls_table *nls_codepage)
++{
++/* level 263 SMB_QUERY_FILE_ALL_INFO */
++	TRANSACTION2_QPI_REQ *pSMB = NULL;
++	TRANSACTION2_QPI_RSP *pSMBr = NULL;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++
++	cFYI(1, ("In QPathInfo path %s", searchName));
++QPathInfoRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(searchName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, searchName, name_len);
++	}
++
++	pSMB->TotalParameterCount = 2 /* level */  + 4 /* reserved */  +
++	    name_len /* includes null */ ;
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(4000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in QPathInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		/* BB also check enough total bytes returned */
++		/* BB we need to improve the validity checking
++		of these trans2 responses */
++		if ((pSMBr->ByteCount < 40) || (pSMBr->DataOffset > 512)) 
++			rc = -EIO;	/* bad smb */
++		else if (pFindData){
++			memcpy((char *) pFindData,
++			       (char *) &pSMBr->hdr.Protocol +
++			       pSMBr->DataOffset, sizeof (FILE_ALL_INFO));
++		} else
++		    rc = -ENOMEM;
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto QPathInfoRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
++		     const unsigned char *searchName,
++		     FILE_UNIX_BASIC_INFO * pFindData,
++		     const struct nls_table *nls_codepage)
++{
++/* SMB_QUERY_FILE_UNIX_BASIC */
++	TRANSACTION2_QPI_REQ *pSMB = NULL;
++	TRANSACTION2_QPI_RSP *pSMBr = NULL;
++	int rc = 0;
++	int bytes_returned = 0;
++	int name_len;
++
++	cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
++UnixQPathInfoRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(searchName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, searchName, name_len);
++	}
++
++	pSMB->TotalParameterCount = 2 /* level */  + 4 /* reserved */  +
++	    name_len /* includes null */ ;
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxDataCount = cpu_to_le16(4000); 
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in QPathInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		/* BB also check if enough total bytes returned */
++		if ((pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO)) || 
++			(pSMBr->DataOffset > 512) || 
++			(pSMBr->DataOffset < sizeof(struct smb_hdr))) {
++			cFYI(1,("UnixQPathinfo invalid data offset %d bytes returned %d",
++					(int)pSMBr->DataOffset,bytes_returned));
++			rc = -EIO;	/* bad smb */
++		} else {
++			memcpy((char *) pFindData,
++			       (char *) &pSMBr->hdr.Protocol +
++			       pSMBr->DataOffset,
++			       sizeof (FILE_UNIX_BASIC_INFO));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto UnixQPathInfoRetry;
++
++	return rc;
++}
++
++int
++CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
++	       const char *searchName, FILE_ALL_INFO * findData,
++	       const struct nls_table *nls_codepage)
++{
++/* level 257 SMB_ */
++	TRANSACTION2_FFIRST_REQ *pSMB = NULL;
++	TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++
++	cFYI(1, ("In FindUnique"));
++findUniqueRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(searchName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, searchName, name_len);
++	}
++
++	pSMB->TotalParameterCount = 12 + name_len /* includes null */ ;
++	pSMB->TotalDataCount = 0;	/* no EAs */
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(4000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = cpu_to_le16(
++        offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;	/* one byte, no need to le convert */
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalDataCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->SearchAttributes =
++	    cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
++			ATTR_DIRECTORY);
++	pSMB->SearchCount = cpu_to_le16(16);	/* BB increase */
++	pSMB->SearchFlags = cpu_to_le16(1);
++	pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
++	pSMB->SearchStorageType = 0;	/* BB what should we set this to? BB */
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++
++	if (rc) {
++		cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
++	} else {		/* decode response */
++
++		/* BB fill in */
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto findUniqueRetry;
++
++	return rc;
++}
++
++int
++CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
++	      const char *searchName, FILE_DIRECTORY_INFO * findData,
++	      T2_FFIRST_RSP_PARMS * findParms,
++	      const struct nls_table *nls_codepage, int *pUnicodeFlag,
++	      int *pUnixFlag)
++{
++/* level 257 SMB_ */
++	TRANSACTION2_FFIRST_REQ *pSMB = NULL;
++	TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
++	char *response_data;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++
++	cFYI(1, ("In FindFirst"));
++findFirstRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(searchName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, searchName, name_len);
++	}
++
++	pSMB->TotalParameterCount = 12 + name_len /* includes null */ ;
++	pSMB->TotalDataCount = 0;	/* no EAs */
++	pSMB->MaxParameterCount = cpu_to_le16(10);
++	pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
++					  MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 
++        smb_com_transaction2_ffirst_req, SearchAttributes) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;	/* one byte no need to make endian neutral */
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
++	pSMB->SearchAttributes =
++	    cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
++			ATTR_DIRECTORY);
++	pSMB->SearchCount = cpu_to_le16(CIFS_MAX_MSGSIZE / sizeof (FILE_DIRECTORY_INFO));	/* should this be shrunk even more ? */
++	pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
++
++	/* test for Unix extensions */
++	if (tcon->ses->capabilities & CAP_UNIX) {
++		pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
++		*pUnixFlag = TRUE;
++	} else {
++		pSMB->InformationLevel =
++		    cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
++		*pUnixFlag = FALSE;
++	}
++	pSMB->SearchStorageType = 0;	/* BB what should we set this to? It is not clear if it matters BB */
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++
++	if (rc) {		/* BB add logic to retry regular search if Unix search rejected unexpectedly by server */
++		cFYI(1, ("Error in FindFirst = %d", rc));
++	} else {		/* decode response */
++		/* BB add safety checks for these memcpys */
++		if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
++			*pUnicodeFlag = TRUE;
++		else
++			*pUnicodeFlag = FALSE;
++		memcpy(findParms,
++		       (char *) &pSMBr->hdr.Protocol +
++		       le16_to_cpu(pSMBr->ParameterOffset),
++		       sizeof (T2_FFIRST_RSP_PARMS));
++		/* search handle can stay LE and EAoffset not needed so not converted */
++		findParms->EndofSearch = le16_to_cpu(findParms->EndofSearch);
++		findParms->LastNameOffset =
++		    le16_to_cpu(findParms->LastNameOffset);
++		findParms->SearchCount = le16_to_cpu(findParms->SearchCount);
++		response_data =
++		    (char *) &pSMBr->hdr.Protocol +
++		    le16_to_cpu(pSMBr->DataOffset);
++		memcpy(findData, response_data, le16_to_cpu(pSMBr->DataCount));
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto findFirstRetry;
++
++	return rc;
++}
++
++int
++CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
++		FILE_DIRECTORY_INFO * findData, T2_FNEXT_RSP_PARMS * findParms,
++		const __u16 searchHandle, char * resume_file_name, int name_len,
++		__u32 resume_key, int *pUnicodeFlag, int *pUnixFlag)
++{
++/* level 257 SMB_ */
++	TRANSACTION2_FNEXT_REQ *pSMB = NULL;
++	TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
++	char *response_data;
++	int rc = 0;
++	int bytes_returned;
++
++	cFYI(1, ("In FindNext"));
++
++	if(resume_file_name == NULL) {
++		return -EIO;
++	}
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->TotalParameterCount = 14;	/* includes 2 bytes of null string, converted to LE below */
++	pSMB->TotalDataCount = 0;	/* no EAs */
++	pSMB->MaxParameterCount = cpu_to_le16(8);
++	pSMB->MaxDataCount =
++	    cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset =  cpu_to_le16(offsetof(
++        struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
++	pSMB->SearchHandle = searchHandle;	/* always kept as le */
++	findParms->SearchCount = 0;	/* set to zero in case of error */
++	pSMB->SearchCount =
++	    cpu_to_le16(CIFS_MAX_MSGSIZE / sizeof (FILE_DIRECTORY_INFO));
++	/* test for Unix extensions */
++	if (tcon->ses->capabilities & CAP_UNIX) {
++		pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
++		*pUnixFlag = TRUE;
++	} else {
++		pSMB->InformationLevel =
++		    cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
++		*pUnixFlag = FALSE;
++	}
++	pSMB->ResumeKey = resume_key;
++	pSMB->SearchFlags =
++	    cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
++	/* BB add check to make sure we do not cross end of smb */
++	if(name_len < CIFS_MAX_MSGSIZE) {
++		memcpy(pSMB->ResumeFileName, resume_file_name, name_len);
++		pSMB->ByteCount += name_len;
++	}
++	pSMB->TotalParameterCount += name_len;
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	/* BB improve error handling here */
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++
++	if (rc) {
++		if (rc == -EBADF)
++			rc = 0;	/* search probably was closed at end of search above */
++		else
++			cFYI(1, ("FindNext returned = %d", rc));
++	} else {		/* decode response */
++		/* BB add safety checks for these memcpys */
++		if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
++			*pUnicodeFlag = TRUE;
++		else
++			*pUnicodeFlag = FALSE;
++		memcpy(findParms,
++		       (char *) &pSMBr->hdr.Protocol +
++		       le16_to_cpu(pSMBr->ParameterOffset),
++		       sizeof (T2_FNEXT_RSP_PARMS));
++		findParms->EndofSearch = le16_to_cpu(findParms->EndofSearch);
++		findParms->LastNameOffset =
++		    le16_to_cpu(findParms->LastNameOffset);
++		findParms->SearchCount = le16_to_cpu(findParms->SearchCount);
++		response_data =
++		    (char *) &pSMBr->hdr.Protocol +
++		    le16_to_cpu(pSMBr->DataOffset);
++		memcpy(findData, response_data, le16_to_cpu(pSMBr->DataCount));
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Note: On -EAGAIN error only caller can retry on handle based calls
++		since file handle passed in no longer valid */
++
++	return rc;
++}
++
++int
++CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
++{
++	int rc = 0;
++	FINDCLOSE_REQ *pSMB = NULL;
++	CLOSE_RSP *pSMBr = NULL;
++	int bytes_returned;
++
++	cFYI(1, ("In CIFSSMBFindClose"));
++	rc = smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	/* no sense returning error if session restarted
++		file handle has been closed */
++	if(rc == -EAGAIN)
++		return 0;
++	if (rc)
++		return rc;
++
++	pSMB->FileID = searchHandle;
++	pSMB->ByteCount = 0;
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cERROR(1, ("Send error in FindClose = %d", rc));
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Since session is dead, search handle closed on server already */
++	if (rc == -EAGAIN)
++		rc = 0;
++
++	return rc;
++}
++
++int
++CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
++		const unsigned char *searchName,
++		unsigned char **targetUNCs,
++		unsigned int *number_of_UNC_in_array,
++		const struct nls_table *nls_codepage)
++{
++/* TRANS2_GET_DFS_REFERRAL */
++	TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
++	TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
++	struct dfs_referral_level_3 * referrals = NULL;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++	unsigned int i;
++	char * temp;
++	*number_of_UNC_in_array = 0;
++	*targetUNCs = NULL;
++
++	cFYI(1, ("In GetDFSRefer the path %s", searchName));
++	if (ses == NULL)
++		return -ENODEV;
++getDFSRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->hdr.Tid = ses->ipc_tid;
++	pSMB->hdr.Uid = ses->Suid;
++	if (ses->capabilities & CAP_STATUS32) {
++		pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
++	}
++	if (ses->capabilities & CAP_DFS) {
++		pSMB->hdr.Flags2 |= SMBFLG2_DFS;
++	}
++
++	if (ses->capabilities & CAP_UNICODE) {
++		pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->RequestFileName,
++				  searchName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(searchName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->RequestFileName, searchName, name_len);
++	}
++
++	pSMB->ParameterCount = 2 /* level */  + name_len /*includes null */ ;
++	pSMB->TotalDataCount = 0;
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->MaxParameterCount = 0;
++	pSMB->MaxDataCount = cpu_to_le16(4000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
++	pSMB->ByteCount = pSMB->ParameterCount + 3 /* pad */ ;
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->MaxReferralLevel = cpu_to_le16(3);
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in GetDFSRefer = %d", rc));
++	} else {		/* decode response */
++/* BB Add logic to parse referrals here */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		pSMBr->DataCount = le16_to_cpu(pSMBr->DataCount);
++		cFYI(1,
++		     ("Decoding GetDFSRefer response.  BCC: %d  Offset %d",
++		      pSMBr->ByteCount, pSMBr->DataOffset));
++		if ((pSMBr->ByteCount < 17) || (pSMBr->DataOffset > 512))	/* BB also check enough total bytes returned */
++			rc = -EIO;	/* bad smb */
++		else {
++			referrals = 
++			    (struct dfs_referral_level_3 *) 
++					(8 /* sizeof start of data block */ +
++					pSMBr->DataOffset +
++					(char *) &pSMBr->hdr.Protocol); 
++			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",pSMBr->NumberOfReferrals,pSMBr->DFSFlags, referrals->ReferralSize,referrals->ServerType,referrals->ReferralFlags,referrals->TimeToLive));
++			/* BB This field is actually two bytes in from start of
++			   data block so we could do safety check that DataBlock
++			   begins at address of pSMBr->NumberOfReferrals */
++			*number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
++
++			/* BB Fix below so can return more than one referral */
++			if(*number_of_UNC_in_array > 1)
++				*number_of_UNC_in_array = 1;
++
++			/* get the length of the strings describing refs */
++			name_len = 0;
++			for(i=0;i<*number_of_UNC_in_array;i++) {
++				/* make sure that DfsPathOffset not past end */
++				referrals->DfsPathOffset = le16_to_cpu(referrals->DfsPathOffset);
++				if(referrals->DfsPathOffset > pSMBr->DataCount) {
++					/* if invalid referral, stop here and do 
++					not try to copy any more */
++					*number_of_UNC_in_array = i;
++					break;
++				} 
++				temp = ((char *)referrals) + referrals->DfsPathOffset;
++
++				if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
++					name_len += UniStrnlen((wchar_t *)temp,pSMBr->DataCount);
++				} else {
++					name_len += strnlen(temp,pSMBr->DataCount);
++				}
++				referrals++;
++				/* BB add check that referral pointer does not fall off end PDU */
++				
++			}
++			/* BB add check for name_len bigger than bcc */
++			*targetUNCs = 
++				kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
++			/* copy the ref strings */
++			referrals =  
++			    (struct dfs_referral_level_3 *) 
++					(8 /* sizeof data hdr */ +
++					pSMBr->DataOffset + 
++					(char *) &pSMBr->hdr.Protocol);
++
++			for(i=0;i<*number_of_UNC_in_array;i++) {
++				temp = ((char *)referrals) + referrals->DfsPathOffset;
++				if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
++					cifs_strfromUCS_le(*targetUNCs,
++						(wchar_t *) temp, name_len, nls_codepage);
++				} else {
++					strncpy(*targetUNCs,temp,name_len);
++				}
++				/*  BB update target_uncs pointers */
++				referrals++;
++			}
++			temp = *targetUNCs;
++			temp[name_len] = 0;
++		}
++
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto getDFSRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon,
++	       struct statfs *FSData, const struct nls_table *nls_codepage)
++{
++/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
++	TRANSACTION2_QFSI_REQ *pSMB = NULL;
++	TRANSACTION2_QFSI_RSP *pSMBr = NULL;
++	FILE_SYSTEM_INFO *response_data;
++	int rc = 0;
++	int bytes_returned = 0;
++
++	cFYI(1, ("In QFSInfo"));
++QFSInfoRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->TotalParameterCount = 2;	/* level */
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
++	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cERROR(1, ("Send error in QFSInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		cFYI(1,
++		     ("Decoding qfsinfo response.  BCC: %d  Offset %d",
++		      pSMBr->ByteCount, pSMBr->DataOffset));
++		if ((pSMBr->ByteCount < 24) || (pSMBr->DataOffset > 512))	/* BB also check enough total bytes returned */
++			rc = -EIO;	/* bad smb */
++		else {
++			response_data =
++			    (FILE_SYSTEM_INFO
++			     *) (((char *) &pSMBr->hdr.Protocol) +
++				 pSMBr->DataOffset);
++			FSData->f_bsize =
++			    le32_to_cpu(response_data->BytesPerSector) *
++			    le32_to_cpu(response_data->
++					SectorsPerAllocationUnit);
++			FSData->f_blocks =
++			    le64_to_cpu(response_data->TotalAllocationUnits);
++			FSData->f_bfree = FSData->f_bavail =
++			    le64_to_cpu(response_data->FreeAllocationUnits);
++			cFYI(1,
++			     ("Blocks: %lld  Free: %lld Block size %ld",
++			      (unsigned long long)FSData->f_blocks,
++			      (unsigned long long)FSData->f_bfree,
++			      FSData->f_bsize));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto QFSInfoRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBQFSAttributeInfo(int xid, struct cifsTconInfo *tcon,
++			const struct nls_table *nls_codepage)
++{
++/* level 0x105  SMB_QUERY_FILE_SYSTEM_INFO */
++	TRANSACTION2_QFSI_REQ *pSMB = NULL;
++	TRANSACTION2_QFSI_RSP *pSMBr = NULL;
++	FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
++	int rc = 0;
++	int bytes_returned = 0;
++
++	cFYI(1, ("In QFSAttributeInfo"));
++QFSAttributeRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->TotalParameterCount = 2;	/* level */
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
++	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		if ((pSMBr->ByteCount < 13) || (pSMBr->DataOffset > 512)) {	/* BB also check enough bytes returned */
++			rc = -EIO;	/* bad smb */
++		} else {
++			response_data =
++			    (FILE_SYSTEM_ATTRIBUTE_INFO
++			     *) (((char *) &pSMBr->hdr.Protocol) +
++				 pSMBr->DataOffset);
++			response_data->Attributes = le32_to_cpu(response_data->Attributes);
++			response_data->MaxPathNameComponentLength = 
++				le32_to_cpu(response_data->MaxPathNameComponentLength);
++			response_data->FileSystemNameLen = 
++				le32_to_cpu(response_data->FileSystemNameLen);
++			memcpy(&tcon->fsAttrInfo, response_data,
++			       sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto QFSAttributeRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBQFSDeviceInfo(int xid, struct cifsTconInfo *tcon,
++		     const struct nls_table *nls_codepage)
++{
++/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
++	TRANSACTION2_QFSI_REQ *pSMB = NULL;
++	TRANSACTION2_QFSI_RSP *pSMBr = NULL;
++	FILE_SYSTEM_DEVICE_INFO *response_data;
++	int rc = 0;
++	int bytes_returned = 0;
++
++	cFYI(1, ("In QFSDeviceInfo"));
++QFSDeviceRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->TotalParameterCount = 2;	/* level */
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
++
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
++	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		if ((pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO))
++                 || (pSMBr->DataOffset > 512))
++			rc = -EIO;	/* bad smb */
++		else {
++			response_data =
++			    (FILE_SYSTEM_DEVICE_INFO
++			     *) (((char *) &pSMBr->hdr.Protocol) +
++				 pSMBr->DataOffset);
++			response_data->DeviceType = 
++				le32_to_cpu(response_data->DeviceType);
++			response_data->DeviceCharacteristics = 
++				le32_to_cpu(response_data->DeviceCharacteristics);
++			memcpy(&tcon->fsDevInfo, response_data,
++			       sizeof (FILE_SYSTEM_DEVICE_INFO));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto QFSDeviceRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBQFSUnixInfo(int xid, struct cifsTconInfo *tcon,
++		   const struct nls_table *nls_codepage)
++{
++/* level 0x200  SMB_QUERY_CIFS_UNIX_INFO */
++	TRANSACTION2_QFSI_REQ *pSMB = NULL;
++	TRANSACTION2_QFSI_RSP *pSMBr = NULL;
++	FILE_SYSTEM_UNIX_INFO *response_data;
++	int rc = 0;
++	int bytes_returned = 0;
++
++	cFYI(1, ("In QFSUnixInfo"));
++QFSUnixRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->ParameterCount = 2;	/* level */
++	pSMB->TotalDataCount = 0;
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(100);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ByteCount = pSMB->ParameterCount + 1 /* pad */ ;
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(struct 
++        smb_com_transaction2_qfsi_req, InformationLevel) - 4);
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
++	pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = cpu_to_le16(pSMBr->DataOffset);
++		if ((pSMBr->ByteCount < 13) || (pSMBr->DataOffset > 512)) {
++			rc = -EIO;	/* bad smb */
++		} else {
++			response_data =
++			    (FILE_SYSTEM_UNIX_INFO
++			     *) (((char *) &pSMBr->hdr.Protocol) +
++				 pSMBr->DataOffset);
++			response_data->MajorVersionNumber =
++				le16_to_cpu(response_data->MajorVersionNumber);
++			response_data->MinorVersionNumber =
++				le16_to_cpu(response_data->MinorVersionNumber);
++			response_data->Capability =
++				le64_to_cpu(response_data->Capability);
++			memcpy(&tcon->fsUnixInfo, response_data,
++			       sizeof (FILE_SYSTEM_UNIX_INFO));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto QFSUnixRetry;
++
++
++	return rc;
++}
++
++/* We can not use write of zero bytes trick to 
++   set file size due to need for large file support.  Also note that 
++   this SetPathInfo is preferred to SetFileInfo based method in next 
++   routine which is only needed to work around a sharing violation bug
++   in Samba which this routine can run into */
++
++int
++CIFSSMBSetEOF(int xid, struct cifsTconInfo *tcon, char *fileName,
++	      __u64 size, int SetAllocation, const struct nls_table *nls_codepage)
++{
++	struct smb_com_transaction2_spi_req *pSMB = NULL;
++	struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
++	struct file_end_of_file_info *parm_data;
++	int name_len;
++	int rc = 0;
++	int bytes_returned = 0;
++
++	cFYI(1, ("In SetEOF"));
++SetEOFRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fileName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, fileName, name_len);
++	}
++	pSMB->ParameterCount = 6 + name_len;
++	pSMB->DataCount = sizeof (struct file_end_of_file_info);
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find max SMB size from sess */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = offsetof(struct smb_com_transaction2_spi_req,
++                                     InformationLevel) - 4;
++	pSMB->DataOffset = pSMB->ParameterOffset + pSMB->ParameterCount;
++	if(SetAllocation) {
++        	if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
++	            pSMB->InformationLevel =
++                	cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
++        	else
++	            pSMB->InformationLevel =
++        	        cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
++	} else /* Set File Size */  {    
++	    if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
++		    pSMB->InformationLevel =
++		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
++	    else
++		    pSMB->InformationLevel =
++		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
++	}
++
++	parm_data =
++	    (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
++				       pSMB->DataOffset);
++	pSMB->ParameterOffset = cpu_to_le16(pSMB->ParameterOffset);
++	pSMB->DataOffset = cpu_to_le16(pSMB->DataOffset);
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
++	pSMB->ByteCount = 3 /* pad */  + pSMB->ParameterCount + pSMB->DataCount;
++	pSMB->DataCount = cpu_to_le16(pSMB->DataCount);
++	pSMB->TotalDataCount = pSMB->DataCount;
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	parm_data->FileSize = cpu_to_le64(size);
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("SetPathInfo (file size) returned %d", rc));
++	}
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto SetEOFRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size, 
++                   __u16 fid, __u32 pid_of_opener, int SetAllocation)
++{
++	struct smb_com_transaction2_sfi_req *pSMB  = NULL;
++	struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
++	char *data_offset;
++	struct file_end_of_file_info *parm_data;
++	int rc = 0;
++	int bytes_returned = 0;
++	__u32 tmp;
++
++	cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
++			(long long)size));
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	tmp = cpu_to_le32(pid_of_opener);  /* override pid of current process
++                                         so network fid will be valid */
++	pSMB->hdr.Pid = tmp & 0xFFFF;
++	tmp >>= 16;
++	pSMB->hdr.PidHigh = tmp & 0xFFFF;
++    
++	pSMB->ParameterCount = 6;
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = offsetof(struct smb_com_transaction2_sfi_req,
++                                     Fid) - 4;
++	pSMB->DataOffset = pSMB->ParameterOffset + pSMB->ParameterCount;
++
++	data_offset = (char *) (&pSMB->hdr.Protocol) + pSMB->DataOffset;	
++
++	pSMB->DataCount = sizeof(struct file_end_of_file_info);
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find max SMB PDU from sess */
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
++	pSMB->ByteCount = 3 /* pad */  + pSMB->ParameterCount + pSMB->DataCount;
++	pSMB->DataCount = cpu_to_le16(pSMB->DataCount);
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalDataCount = pSMB->DataCount;
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->ParameterOffset = cpu_to_le16(pSMB->ParameterOffset);
++	parm_data =
++		(struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
++			pSMB->DataOffset);
++	pSMB->DataOffset = cpu_to_le16(pSMB->DataOffset); /* now safe to change to le */
++	parm_data->FileSize = cpu_to_le64(size);
++	pSMB->Fid = fid;
++	if(SetAllocation) {
++		if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
++			pSMB->InformationLevel =
++				cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
++		else
++			pSMB->InformationLevel =
++				cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
++	} else /* Set File Size */  {    
++	    if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
++		    pSMB->InformationLevel =
++		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
++	    else
++		    pSMB->InformationLevel =
++		        cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
++	}
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1,
++		     ("Send error in SetFileInfo (SetFileSize) = %d",
++		      rc));
++	}
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	/* Note: On -EAGAIN error only caller can retry on handle based calls 
++		since file handle passed in no longer valid */
++
++	return rc;
++}
++
++int
++CIFSSMBSetTimes(int xid, struct cifsTconInfo *tcon, char *fileName,
++		FILE_BASIC_INFO * data, const struct nls_table *nls_codepage)
++{
++	TRANSACTION2_SPI_REQ *pSMB = NULL;
++	TRANSACTION2_SPI_RSP *pSMBr = NULL;
++	int name_len;
++	int rc = 0;
++	int bytes_returned = 0;
++	char *data_offset;
++
++	cFYI(1, ("In SetTimes"));
++
++SetTimesRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fileName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, fileName, name_len);
++	}
++
++	pSMB->ParameterCount = 6 + name_len;
++	pSMB->DataCount = sizeof (FILE_BASIC_INFO);
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = offsetof(struct smb_com_transaction2_spi_req,
++                                     InformationLevel) - 4;
++	pSMB->DataOffset = pSMB->ParameterOffset + pSMB->ParameterCount;
++	data_offset = (char *) (&pSMB->hdr.Protocol) + pSMB->DataOffset;
++	pSMB->ParameterOffset = cpu_to_le16(pSMB->ParameterOffset);
++	pSMB->DataOffset = cpu_to_le16(pSMB->DataOffset);
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
++	pSMB->ByteCount = 3 /* pad */  + pSMB->ParameterCount + pSMB->DataCount;
++
++	pSMB->DataCount = cpu_to_le16(pSMB->DataCount);
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->TotalDataCount = pSMB->DataCount;
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
++		pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
++	else
++		pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("SetPathInfo (times) returned %d", rc));
++	}
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++
++	if (rc == -EAGAIN)
++		goto SetTimesRetry;
++
++	return rc;
++}
++
++int
++CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
++		    char *fileName, __u64 mode, __u64 uid, __u64 gid,
++		    dev_t device, const struct nls_table *nls_codepage)
++{
++	TRANSACTION2_SPI_REQ *pSMB = NULL;
++	TRANSACTION2_SPI_RSP *pSMBr = NULL;
++	int name_len;
++	int rc = 0;
++	int bytes_returned = 0;
++	FILE_UNIX_BASIC_INFO *data_offset;
++
++	cFYI(1, ("In SetUID/GID/Mode"));
++setPermsRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(fileName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, fileName, name_len);
++	}
++
++	pSMB->ParameterCount = 6 + name_len;
++	pSMB->DataCount = sizeof (FILE_UNIX_BASIC_INFO);
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(1000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = offsetof(struct smb_com_transaction2_spi_req,
++                                     InformationLevel) - 4;
++	pSMB->DataOffset = pSMB->ParameterOffset + pSMB->ParameterCount;
++	data_offset =
++	    (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
++				      pSMB->DataOffset);
++	pSMB->DataOffset = cpu_to_le16(pSMB->DataOffset);
++	pSMB->ParameterOffset = cpu_to_le16(pSMB->ParameterOffset);
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
++	pSMB->ByteCount = 3 /* pad */  + pSMB->ParameterCount + pSMB->DataCount;
++	pSMB->ParameterCount = cpu_to_le16(pSMB->ParameterCount);
++	pSMB->DataCount = cpu_to_le16(pSMB->DataCount);
++	pSMB->TotalParameterCount = pSMB->ParameterCount;
++	pSMB->TotalDataCount = pSMB->DataCount;
++	pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	data_offset->Uid = cpu_to_le64(uid);
++	data_offset->Gid = cpu_to_le64(gid);
++	/* better to leave device as zero when it is  */
++	data_offset->DevMajor = cpu_to_le64(MAJOR(device));
++	data_offset->DevMinor = cpu_to_le64(MINOR(device));
++	data_offset->Permissions = cpu_to_le64(mode);
++    
++	if(S_ISREG(mode))
++		data_offset->Type = cpu_to_le32(UNIX_FILE);
++	else if(S_ISDIR(mode))
++		data_offset->Type = cpu_to_le32(UNIX_DIR);
++	else if(S_ISLNK(mode))
++		data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
++	else if(S_ISCHR(mode))
++		data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
++	else if(S_ISBLK(mode))
++		data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
++	else if(S_ISFIFO(mode))
++		data_offset->Type = cpu_to_le32(UNIX_FIFO);
++	else if(S_ISSOCK(mode))
++		data_offset->Type = cpu_to_le32(UNIX_SOCKET);
++
++
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("SetPathInfo (perms) returned %d", rc));
++	}
++
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto setPermsRetry;
++	return rc;
++}
++
++int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon, 
++			const int notify_subdirs, const __u16 netfid,
++			__u32 filter, const struct nls_table *nls_codepage)
++{
++	int rc = 0;
++	struct smb_com_transaction_change_notify_req * pSMB = NULL;
++	struct smb_com_transaction_change_notify_rsp * pSMBr = NULL;
++	int bytes_returned;
++
++	cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
++	rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
++                      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	pSMB->TotalParameterCount = 0 ;
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le32(2);
++	/* BB find exact data count max from sess structure BB */
++	pSMB->MaxDataCount = 0; /* same in little endian or be */
++	pSMB->MaxSetupCount = 4;
++	pSMB->Reserved = 0;
++	pSMB->ParameterOffset = 0;
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 4; /* single byte does not need le conversion */
++	pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	if(notify_subdirs)
++		pSMB->WatchTree = 1; /* one byte - no le conversion needed */
++	pSMB->Reserved2 = 0;
++	pSMB->CompletionFilter = cpu_to_le32(filter);
++	pSMB->Fid = netfid; /* file handle always le */
++	pSMB->ByteCount = 0;
++
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			(struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Error in Notify = %d", rc));
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++/*		if (rc == -EAGAIN)
++			goto NotifyRetry; */
++	return rc;	
++}
++#ifdef CONFIG_CIFS_XATTR
++int
++CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
++		 const unsigned char *searchName,
++		 char * EAData, size_t size,
++		 const struct nls_table *nls_codepage)
++{
++		/* BB assumes one setup word */
++	TRANSACTION2_QPI_REQ *pSMB = NULL;
++	TRANSACTION2_QPI_RSP *pSMBr = NULL;
++	int rc = 0;
++	int bytes_returned;
++	int name_len;
++
++	cFYI(1, ("In Query All EAs path %s", searchName));
++QAllEAsRetry:
++	rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
++		      (void **) &pSMBr);
++	if (rc)
++		return rc;
++
++	if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
++		name_len =
++		    cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
++				  /* find define for this maxpathcomponent */
++				  , nls_codepage);
++		name_len++;	/* trailing null */
++		name_len *= 2;
++	} else {		/* BB improve the check for buffer overruns BB */
++		name_len = strnlen(searchName, 530);
++		name_len++;	/* trailing null */
++		strncpy(pSMB->FileName, searchName, name_len);
++	}
++
++	pSMB->TotalParameterCount = 2 /* level */  + 4 /* reserved */  +
++	    name_len /* includes null */ ;
++	pSMB->TotalDataCount = 0;
++	pSMB->MaxParameterCount = cpu_to_le16(2);
++	pSMB->MaxDataCount = cpu_to_le16(4000);	/* BB find exact max SMB PDU from sess structure BB */
++	pSMB->MaxSetupCount = 0;
++	pSMB->Reserved = 0;
++	pSMB->Flags = 0;
++	pSMB->Timeout = 0;
++	pSMB->Reserved2 = 0;
++	pSMB->ParameterOffset = cpu_to_le16(offsetof(
++        struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
++	pSMB->DataCount = 0;
++	pSMB->DataOffset = 0;
++	pSMB->SetupCount = 1;
++	pSMB->Reserved3 = 0;
++	pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
++	pSMB->ByteCount = pSMB->TotalParameterCount + 1 /* pad */ ;
++	pSMB->TotalParameterCount = cpu_to_le16(pSMB->TotalParameterCount);
++	pSMB->ParameterCount = pSMB->TotalParameterCount;
++	pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
++	pSMB->Reserved4 = 0;
++	pSMB->hdr.smb_buf_length += pSMB->ByteCount;
++	pSMB->ByteCount = cpu_to_le16(pSMB->ByteCount);
++
++	rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
++			 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
++	if (rc) {
++		cFYI(1, ("Send error in QueryAllEAs = %d", rc));
++	} else {		/* decode response */
++		pSMBr->DataOffset = le16_to_cpu(pSMBr->DataOffset);
++		/* BB also check enough total bytes returned */
++		/* BB we need to improve the validity checking
++		of these trans2 responses */
++		if ((pSMBr->ByteCount < 4) || (pSMBr->DataOffset > 512)) 
++			rc = -EIO;	/* bad smb */
++	   /* else if (pFindData){
++			memcpy((char *) pFindData,
++			       (char *) &pSMBr->hdr.Protocol +
++			       pSMBr->DataOffset, kl);
++		}*/ else {
++			/* check that length of list is not more than bcc */
++			/* check that each entry does not go beyond length
++			   of list */
++			/* check that each element of each entry does not
++			   go beyond end of list */
++			struct fealist * ea_response_data;
++			rc = 0;
++			/* validate_trans2_offsets() */
++			/* BB to check if(start of smb + pSMBr->DataOffset > &bcc+ bcc)*/
++			ea_response_data = (struct fealist *)
++				(((char *) &pSMBr->hdr.Protocol) +
++				pSMBr->DataOffset);
++			cFYI(1,("ea length %d",ea_response_data->list_len));
++		}
++	}
++	if (pSMB)
++		cifs_buf_release(pSMB);
++	if (rc == -EAGAIN)
++		goto QAllEAsRetry;
++
++	return rc;
++}
++#endif
+diff -urN linux-2.4.29.old/fs/cifs/cifs_unicode.c linux-2.4.29/fs/cifs/cifs_unicode.c
+--- linux-2.4.29.old/fs/cifs/cifs_unicode.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifs_unicode.c	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,87 @@
++/*
++ *   fs/cifs/cifs_unicode.c
++ *
++ *   Copyright (c) International Business Machines  Corp., 2000,2002
++ *   Modified by Steve French (sfrench@us.ibm.com)
++ *
++ *   This program is free software;  you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License as published by
++ *   the Free Software Foundation; either version 2 of the License, or 
++ *   (at your option) any later version.
++ * 
++ *   This program is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU General Public License for more details.
++ *
++ *   You should have received a copy of the GNU General Public License
++ *   along with this program;  if not, write to the Free Software 
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++#include <linux/fs.h>
++#include "cifs_unicode.h"
++#include "cifs_uniupr.h"
++#include "cifspdu.h"
++#include "cifs_debug.h"
++
++/*
++ * NAME:	cifs_strfromUCS()
++ *
++ * FUNCTION:	Convert little-endian unicode string to character string
++ *
++ */
++int
++cifs_strfromUCS_le(char *to, const wchar_t * from,	/* LITTLE ENDIAN */
++		   int len, const struct nls_table *codepage)
++{
++	int i;
++	int outlen = 0;
++
++	for (i = 0; (i < len) && from[i]; i++) {
++		int charlen;
++		/* 2.4.0 kernel or greater */
++		charlen =
++		    codepage->uni2char(le16_to_cpu(from[i]), &to[outlen],
++				       NLS_MAX_CHARSET_SIZE);
++		if (charlen > 0) {
++			outlen += charlen;
++		} else {
++			to[outlen++] = '?';
++		}
++	}
++	to[outlen] = 0;
++	return outlen;
++}
++
++/*
++ * NAME:	cifs_strtoUCS()
++ *
++ * FUNCTION:	Convert character string to unicode string
++ *
++ */
++int
++cifs_strtoUCS(wchar_t * to, const char *from, int len,
++	      const struct nls_table *codepage)
++{
++	int charlen;
++	int i;
++
++	for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
++
++		/* works for 2.4.0 kernel or later */
++		charlen = codepage->char2uni(from, len, &to[i]);
++		if (charlen < 1) {
++			cERROR(1,
++			       ("cifs_strtoUCS: char2uni returned %d",
++				charlen));
++			to[i] = cpu_to_le16(0x003f);	/* a question mark */
++			charlen = 1;
++		}
++		to[i] = cpu_to_le16(to[i]);
++
++	}
++
++	to[i] = 0;
++	return i;
++}
++
+diff -urN linux-2.4.29.old/fs/cifs/cifs_unicode.h linux-2.4.29/fs/cifs/cifs_unicode.h
+--- linux-2.4.29.old/fs/cifs/cifs_unicode.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifs_unicode.h	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,353 @@
++/*
++ * cifs_unicode:  Unicode kernel case support
++ *
++ * Function:
++ *     Convert a unicode character to upper or lower case using
++ *     compressed tables.
++ *
++ *   Copyright (c) International Business Machines  Corp., 2000,2002
++ *
++ *   This program is free software;  you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License as published by
++ *   the Free Software Foundation; either version 2 of the License, or 
++ *   (at your option) any later version.
++ * 
++ *   This program is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU General Public License for more details.
++ *
++ *   You should have received a copy of the GNU General Public License
++ *   along with this program;  if not, write to the Free Software 
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ *
++ * Notes:
++ *     These APIs are based on the C library functions.  The semantics
++ *     should match the C functions but with expanded size operands.
++ *
++ *     The upper/lower functions are based on a table created by mkupr.
++ *     This is a compressed table of upper and lower case conversion.
++ *
++ */
++
++#include <asm/byteorder.h>
++#include <linux/types.h>
++#include <linux/nls.h>
++
++#define  UNIUPR_NOLOWER		/* Example to not expand lower case tables */
++
++/* Just define what we want from uniupr.h.  We don't want to define the tables
++ * in each source file.
++ */
++#ifndef	UNICASERANGE_DEFINED
++struct UniCaseRange {
++	wchar_t start;
++	wchar_t end;
++	signed char *table;
++};
++#endif				/* UNICASERANGE_DEFINED */
++
++#ifndef UNIUPR_NOUPPER
++extern signed char CifsUniUpperTable[512];
++extern const struct UniCaseRange CifsUniUpperRange[];
++#endif				/* UNIUPR_NOUPPER */
++
++#ifndef UNIUPR_NOLOWER
++extern signed char UniLowerTable[512];
++extern struct UniCaseRange UniLowerRange[];
++#endif				/* UNIUPR_NOLOWER */
++
++#ifdef __KERNEL__
++int cifs_strfromUCS_le(char *, const wchar_t *, int, const struct nls_table *);
++int cifs_strtoUCS(wchar_t *, const char *, int, const struct nls_table *);
++#endif
++
++/*
++ * UniStrcat:  Concatenate the second string to the first
++ *
++ * Returns:
++ *     Address of the first string
++ */
++static inline wchar_t *
++UniStrcat(wchar_t * ucs1, const wchar_t * ucs2)
++{
++	wchar_t *anchor = ucs1;	/* save a pointer to start of ucs1 */
++
++	while (*ucs1++) ;	/* To end of first string */
++	ucs1--;			/* Return to the null */
++	while ((*ucs1++ = *ucs2++)) ;	/* copy string 2 over */
++	return anchor;
++}
++
++/*
++ * UniStrchr:  Find a character in a string
++ *
++ * Returns:
++ *     Address of first occurrence of character in string
++ *     or NULL if the character is not in the string
++ */
++static inline wchar_t *
++UniStrchr(const wchar_t * ucs, wchar_t uc)
++{
++	while ((*ucs != uc) && *ucs)
++		ucs++;
++
++	if (*ucs == uc)
++		return (wchar_t *) ucs;
++	return NULL;
++}
++
++/*
++ * UniStrcmp:  Compare two strings
++ *
++ * Returns:
++ *     < 0:  First string is less than second
++ *     = 0:  Strings are equal
++ *     > 0:  First string is greater than second
++ */
++static inline int
++UniStrcmp(const wchar_t * ucs1, const wchar_t * ucs2)
++{
++	while ((*ucs1 == *ucs2) && *ucs1) {
++		ucs1++;
++		ucs2++;
++	}
++	return (int) *ucs1 - (int) *ucs2;
++}
++
++/*
++ * UniStrcpy:  Copy a string
++ */
++static inline wchar_t *
++UniStrcpy(wchar_t * ucs1, const wchar_t * ucs2)
++{
++	wchar_t *anchor = ucs1;	/* save the start of result string */
++
++	while ((*ucs1++ = *ucs2++)) ;
++	return anchor;
++}
++
++/*
++ * UniStrlen:  Return the length of a string (in 16 bit Unicode chars not bytes)
++ */
++static inline size_t
++UniStrlen(const wchar_t * ucs1)
++{
++	int i = 0;
++
++	while (*ucs1++)
++		i++;
++	return i;
++}
++
++/*
++ * UniStrnlen:  Return the length (in 16 bit Unicode chars not bytes) of a string (length limited)
++ */
++static inline size_t
++UniStrnlen(const wchar_t * ucs1, int maxlen)
++{
++	int i = 0;
++
++	while (*ucs1++) {
++		i++;
++		if (i >= maxlen)
++			break;
++	}
++	return i;
++}
++
++/*
++ * UniStrncat:  Concatenate length limited string
++ */
++static inline wchar_t *
++UniStrncat(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
++{
++	wchar_t *anchor = ucs1;	/* save pointer to string 1 */
++
++	while (*ucs1++) ;
++	ucs1--;			/* point to null terminator of s1 */
++	while (n-- && (*ucs1 = *ucs2)) {	/* copy s2 after s1 */
++		ucs1++;
++		ucs2++;
++	}
++	*ucs1 = 0;		/* Null terminate the result */
++	return (anchor);
++}
++
++/*
++ * UniStrncmp:  Compare length limited string
++ */
++static inline int
++UniStrncmp(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
++{
++	if (!n)
++		return 0;	/* Null strings are equal */
++	while ((*ucs1 == *ucs2) && *ucs1 && --n) {
++		ucs1++;
++		ucs2++;
++	}
++	return (int) *ucs1 - (int) *ucs2;
++}
++
++/*
++ * UniStrncmp_le:  Compare length limited string - native to little-endian
++ */
++static inline int
++UniStrncmp_le(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
++{
++	if (!n)
++		return 0;	/* Null strings are equal */
++	while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) {
++		ucs1++;
++		ucs2++;
++	}
++	return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
++}
++
++/*
++ * UniStrncpy:  Copy length limited string with pad
++ */
++static inline wchar_t *
++UniStrncpy(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
++{
++	wchar_t *anchor = ucs1;
++
++	while (n-- && *ucs2)	/* Copy the strings */
++		*ucs1++ = *ucs2++;
++
++	n++;
++	while (n--)		/* Pad with nulls */
++		*ucs1++ = 0;
++	return anchor;
++}
++
++/*
++ * UniStrncpy_le:  Copy length limited string with pad to little-endian
++ */
++static inline wchar_t *
++UniStrncpy_le(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
++{
++	wchar_t *anchor = ucs1;
++
++	while (n-- && *ucs2)	/* Copy the strings */
++		*ucs1++ = __le16_to_cpu(*ucs2++);
++
++	n++;
++	while (n--)		/* Pad with nulls */
++		*ucs1++ = 0;
++	return anchor;
++}
++
++/*
++ * UniStrstr:  Find a string in a string
++ *
++ * Returns:
++ *     Address of first match found
++ *     NULL if no matching string is found
++ */
++static inline wchar_t *
++UniStrstr(const wchar_t * ucs1, const wchar_t * ucs2)
++{
++	const wchar_t *anchor1 = ucs1;
++	const wchar_t *anchor2 = ucs2;
++
++	while (*ucs1) {
++		if (*ucs1 == *ucs2) {	/* Partial match found */
++			ucs1++;
++			ucs2++;
++		} else {
++			if (!*ucs2)	/* Match found */
++				return (wchar_t *) anchor1;
++			ucs1 = ++anchor1;	/* No match */
++			ucs2 = anchor2;
++		}
++	}
++
++	if (!*ucs2)		/* Both end together */
++		return (wchar_t *) anchor1;	/* Match found */
++	return NULL;		/* No match */
++}
++
++#ifndef UNIUPR_NOUPPER
++/*
++ * UniToupper:  Convert a unicode character to upper case
++ */
++static inline wchar_t
++UniToupper(register wchar_t uc)
++{
++	register const struct UniCaseRange *rp;
++
++	if (uc < sizeof (CifsUniUpperTable)) {	/* Latin characters */
++		return uc + CifsUniUpperTable[uc];	/* Use base tables */
++	} else {
++		rp = CifsUniUpperRange;	/* Use range tables */
++		while (rp->start) {
++			if (uc < rp->start)	/* Before start of range */
++				return uc;	/* Uppercase = input */
++			if (uc <= rp->end)	/* In range */
++				return uc + rp->table[uc - rp->start];
++			rp++;	/* Try next range */
++		}
++	}
++	return uc;		/* Past last range */
++}
++
++/*
++ * UniStrupr:  Upper case a unicode string
++ */
++static inline wchar_t *
++UniStrupr(register wchar_t * upin)
++{
++	register wchar_t *up;
++
++	up = upin;
++	while (*up) {		/* For all characters */
++		*up = UniToupper(*up);
++		up++;
++	}
++	return upin;		/* Return input pointer */
++}
++#endif				/* UNIUPR_NOUPPER */
++
++#ifndef UNIUPR_NOLOWER
++/*
++ * UniTolower:  Convert a unicode character to lower case
++ */
++static inline wchar_t
++UniTolower(wchar_t uc)
++{
++	register struct UniCaseRange *rp;
++
++	if (uc < sizeof (UniLowerTable)) {	/* Latin characters */
++		return uc + UniLowerTable[uc];	/* Use base tables */
++	} else {
++		rp = UniLowerRange;	/* Use range tables */
++		while (rp->start) {
++			if (uc < rp->start)	/* Before start of range */
++				return uc;	/* Uppercase = input */
++			if (uc <= rp->end)	/* In range */
++				return uc + rp->table[uc - rp->start];
++			rp++;	/* Try next range */
++		}
++	}
++	return uc;		/* Past last range */
++}
++
++/*
++ * UniStrlwr:  Lower case a unicode string
++ */
++static inline wchar_t *
++UniStrlwr(register wchar_t * upin)
++{
++	register wchar_t *up;
++
++	up = upin;
++	while (*up) {		/* For all characters */
++		*up = UniTolower(*up);
++		up++;
++	}
++	return upin;		/* Return input pointer */
++}
++
++#endif
+diff -urN linux-2.4.29.old/fs/cifs/cifs_uniupr.h linux-2.4.29/fs/cifs/cifs_uniupr.h
+--- linux-2.4.29.old/fs/cifs/cifs_uniupr.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/cifs_uniupr.h	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,253 @@
++/*
++ *   Copyright (c) International Business Machines  Corp., 2000,2002
++ *
++ *   This program is free software;  you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License as published by
++ *   the Free Software Foundation; either version 2 of the License, or 
++ *   (at your option) any later version.
++ * 
++ *   This program is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU General Public License for more details.
++ *
++ *   You should have received a copy of the GNU General Public License
++ *   along with this program;  if not, write to the Free Software 
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ * uniupr.h - Unicode compressed case ranges
++ *
++*/
++
++#ifndef UNIUPR_NOUPPER
++/*
++ * Latin upper case
++ */
++signed char CifsUniUpperTable[512] = {
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 000-00f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 010-01f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 020-02f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 030-03f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 040-04f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 050-05f */
++	0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,	/* 060-06f */
++	-32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, 0, 0, 0, 0,	/* 070-07f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 080-08f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 090-09f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0a0-0af */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0b0-0bf */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0c0-0cf */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0d0-0df */
++	-32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,	/* 0e0-0ef */
++	-32, -32, -32, -32, -32, -32, -32, 0, -32, -32, -32, -32, -32, -32, -32, 121,	/* 0f0-0ff */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 100-10f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 110-11f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 120-12f */
++	0, 0, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0,	/* 130-13f */
++	-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1,	/* 140-14f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 150-15f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 160-16f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0,	/* 170-17f */
++	0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0,	/* 180-18f */
++	0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0,	/* 190-19f */
++	0, -1, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0,	/* 1a0-1af */
++	-1, 0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0,	/* 1b0-1bf */
++	0, 0, 0, 0, 0, -1, -2, 0, -1, -2, 0, -1, -2, 0, -1, 0,	/* 1c0-1cf */
++	-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -79, 0, -1,	/* 1d0-1df */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e0-1ef */
++	0, 0, -1, -2, 0, -1, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1f0-1ff */
++};
++
++/* Upper case range - Greek */
++static signed char UniCaseRangeU03a0[47] = {
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -38, -37, -37, -37,	/* 3a0-3af */
++	0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,	/* 3b0-3bf */
++	-32, -32, -31, -32, -32, -32, -32, -32, -32, -32, -32, -32, -64,
++	-63, -63,
++};
++
++/* Upper case range - Cyrillic */
++static signed char UniCaseRangeU0430[48] = {
++	-32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,	/* 430-43f */
++	-32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,	/* 440-44f */
++	0, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 0, -80, -80,	/* 450-45f */
++};
++
++/* Upper case range - Extended cyrillic */
++static signed char UniCaseRangeU0490[61] = {
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 490-49f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 4a0-4af */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 4b0-4bf */
++	0, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1,
++};
++
++/* Upper case range - Extended latin and greek */
++static signed char UniCaseRangeU1e00[509] = {
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e00-1e0f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e10-1e1f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e20-1e2f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e30-1e3f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e40-1e4f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e50-1e5f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e60-1e6f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e70-1e7f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1e80-1e8f */
++	0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, -59, 0, -1, 0, -1,	/* 1e90-1e9f */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1ea0-1eaf */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1eb0-1ebf */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1ec0-1ecf */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1ed0-1edf */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,	/* 1ee0-1eef */
++	0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0,	/* 1ef0-1eff */
++	8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f00-1f0f */
++	8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f10-1f1f */
++	8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f20-1f2f */
++	8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f30-1f3f */
++	8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f40-1f4f */
++	0, 8, 0, 8, 0, 8, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f50-1f5f */
++	8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f60-1f6f */
++	74, 74, 86, 86, 86, 86, 100, 100, 0, 0, 112, 112, 126, 126, 0, 0,	/* 1f70-1f7f */
++	8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f80-1f8f */
++	8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f90-1f9f */
++	8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1fa0-1faf */
++	8, 8, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1fb0-1fbf */
++	0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1fc0-1fcf */
++	8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1fd0-1fdf */
++	8, 8, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1fe0-1fef */
++	0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++};
++
++/* Upper case range - Wide latin */
++static signed char UniCaseRangeUff40[27] = {
++	0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,	/* ff40-ff4f */
++	-32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,
++};
++
++/*
++ * Upper Case Range
++ */
++const struct UniCaseRange CifsUniUpperRange[] = {
++	{0x03a0, 0x03ce, UniCaseRangeU03a0},
++	{0x0430, 0x045f, UniCaseRangeU0430},
++	{0x0490, 0x04cc, UniCaseRangeU0490},
++	{0x1e00, 0x1ffc, UniCaseRangeU1e00},
++	{0xff40, 0xff5a, UniCaseRangeUff40},
++	{0, 0, NULL}
++};
++#endif
++
++#ifndef UNIUPR_NOLOWER
++/*
++ * Latin lower case
++ */
++static signed char CifsUniLowerTable[512] = {
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 000-00f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 010-01f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 020-02f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 030-03f */
++	0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,	/* 040-04f */
++	32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0,	/* 050-05f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 060-06f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 070-07f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 080-08f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 090-09f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0a0-0af */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0b0-0bf */
++	32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,	/* 0c0-0cf */
++	32, 32, 32, 32, 32, 32, 32, 0, 32, 32, 32, 32, 32, 32, 32, 0,	/* 0d0-0df */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0e0-0ef */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0f0-0ff */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 100-10f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 110-11f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 120-12f */
++	0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,	/* 130-13f */
++	0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0,	/* 140-14f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 150-15f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 160-16f */
++	1, 0, 1, 0, 1, 0, 1, 0, -121, 1, 0, 1, 0, 1, 0, 0,	/* 170-17f */
++	0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 79, 0,	/* 180-18f */
++	0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,	/* 190-19f */
++	1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1,	/* 1a0-1af */
++	0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,	/* 1b0-1bf */
++	0, 0, 0, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 1, 0, 1,	/* 1c0-1cf */
++	0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0,	/* 1d0-1df */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e0-1ef */
++	0, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1f0-1ff */
++};
++
++/* Lower case range - Greek */
++static signed char UniCaseRangeL0380[44] = {
++	0, 0, 0, 0, 0, 0, 38, 0, 37, 37, 37, 0, 64, 0, 63, 63,	/* 380-38f */
++	0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,	/* 390-39f */
++	32, 32, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32,
++};
++
++/* Lower case range - Cyrillic */
++static signed char UniCaseRangeL0400[48] = {
++	0, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 0, 80, 80,	/* 400-40f */
++	32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,	/* 410-41f */
++	32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,	/* 420-42f */
++};
++
++/* Lower case range - Extended cyrillic */
++static signed char UniCaseRangeL0490[60] = {
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 490-49f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 4a0-4af */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 4b0-4bf */
++	0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
++};
++
++/* Lower case range - Extended latin and greek */
++static signed char UniCaseRangeL1e00[504] = {
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e00-1e0f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e10-1e1f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e20-1e2f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e30-1e3f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e40-1e4f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e50-1e5f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e60-1e6f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e70-1e7f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1e80-1e8f */
++	1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,	/* 1e90-1e9f */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1ea0-1eaf */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1eb0-1ebf */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1ec0-1ecf */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1ed0-1edf */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,	/* 1ee0-1eef */
++	1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,	/* 1ef0-1eff */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8,	/* 1f00-1f0f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, 0, 0,	/* 1f10-1f1f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8,	/* 1f20-1f2f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8,	/* 1f30-1f3f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, 0, 0,	/* 1f40-1f4f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, -8, 0, -8, 0, -8, 0, -8,	/* 1f50-1f5f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8,	/* 1f60-1f6f */
++	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 1f70-1f7f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8,	/* 1f80-1f8f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8,	/* 1f90-1f9f */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8,	/* 1fa0-1faf */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -74, -74, -9, 0, 0, 0,	/* 1fb0-1fbf */
++	0, 0, 0, 0, 0, 0, 0, 0, -86, -86, -86, -86, -9, 0, 0, 0,	/* 1fc0-1fcf */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -100, -100, 0, 0, 0, 0,	/* 1fd0-1fdf */
++	0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -112, -112, -7, 0, 0, 0,	/* 1fe0-1fef */
++	0, 0, 0, 0, 0, 0, 0, 0,
++};
++
++/* Lower case range - Wide latin */
++static signed char UniCaseRangeLff20[27] = {
++	0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,	/* ff20-ff2f */
++	32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
++};
++
++/*
++ * Lower Case Range
++ */
++const static struct UniCaseRange CifsUniLowerRange[] = {
++	0x0380, 0x03ab, UniCaseRangeL0380,
++	0x0400, 0x042f, UniCaseRangeL0400,
++	0x0490, 0x04cb, UniCaseRangeL0490,
++	0x1e00, 0x1ff7, UniCaseRangeL1e00,
++	0xff20, 0xff3a, UniCaseRangeLff20,
++	0, 0, 0
++};
++#endif
+diff -urN linux-2.4.29.old/fs/cifs/connect.c linux-2.4.29/fs/cifs/connect.c
+--- linux-2.4.29.old/fs/cifs/connect.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/connect.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,2924 @@
++/*
++ *   fs/cifs/connect.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2004
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++#include <linux/fs.h>
++#include <linux/net.h>
++#include <linux/string.h>
++#include <linux/list.h>
++#include <linux/wait.h>
++#include <linux/version.h>
++#include <linux/ipv6.h>
++#include <linux/pagemap.h>
++#include <linux/ctype.h>
++#include <linux/utsname.h>
++#include <asm/uaccess.h>
++#include <asm/processor.h>
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_unicode.h"
++#include "cifs_debug.h"
++#include "cifs_fs_sb.h"
++#include "ntlmssp.h"
++#include "nterr.h"
++#include "rfc1002pdu.h"
++
++#define CIFS_PORT 445
++#define RFC1001_PORT 139
++
++extern void SMBencrypt(unsigned char *passwd, unsigned char *c8,
++		       unsigned char *p24);
++extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
++			 unsigned char *p24);
++extern int cifs_inet_pton(int, const char *, void *dst);
++
++struct smb_vol {
++	char *username;
++	char *password;
++	char *domainname;
++	char *UNC;
++	char *UNCip;
++	char *iocharset;  /* local code page for mapping to and from Unicode */
++	char source_rfc1001_name[16]; /* netbios name of client */
++	uid_t linux_uid;
++	gid_t linux_gid;
++	mode_t file_mode;
++	mode_t dir_mode;
++	int rw:1;
++	int retry:1;
++	int intr:1;
++	unsigned int rsize;
++	unsigned int wsize;
++	unsigned int sockopt;
++	unsigned short int port;
++};
++
++static int ipv4_connect(struct sockaddr_in *psin_server, 
++			struct socket **csocket,
++			char * netb_name);
++static int ipv6_connect(struct sockaddr_in6 *psin_server, 
++			struct socket **csocket);
++
++
++	/* 
++	 * cifs tcp session reconnection
++	 * 
++	 * mark tcp session as reconnecting so temporarily locked
++	 * mark all smb sessions as reconnecting for tcp session
++	 * reconnect tcp session
++	 * wake up waiters on reconnection? - (not needed currently)
++	 */
++
++int
++cifs_reconnect(struct TCP_Server_Info *server)
++{
++	int rc = 0;
++	struct list_head *tmp;
++	struct cifsSesInfo *ses;
++	struct cifsTconInfo *tcon;
++	struct mid_q_entry * mid_entry;
++	
++	spin_lock(&GlobalMid_Lock);
++	if(server->tcpStatus == CifsExiting) {
++		/* the demux thread will exit normally 
++		next time through the loop */
++		spin_unlock(&GlobalMid_Lock);
++		return rc;
++	} else
++		server->tcpStatus = CifsNeedReconnect;
++	spin_unlock(&GlobalMid_Lock);
++	server->maxBuf = 0;
++
++	cFYI(1, ("Reconnecting tcp session "));
++
++	/* before reconnecting the tcp session, mark the smb session (uid)
++		and the tid bad so they are not used until reconnected */
++	read_lock(&GlobalSMBSeslock);
++	list_for_each(tmp, &GlobalSMBSessionList) {
++		ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
++		if (ses->server) {
++			if (ses->server == server) {
++				ses->status = CifsNeedReconnect;
++				ses->ipc_tid = 0;
++			}
++		}
++		/* else tcp and smb sessions need reconnection */
++	}
++	list_for_each(tmp, &GlobalTreeConnectionList) {
++		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
++		if((tcon) && (tcon->ses) && (tcon->ses->server == server)) {
++			tcon->tidStatus = CifsNeedReconnect;
++		}
++	}
++	read_unlock(&GlobalSMBSeslock);
++	/* do not want to be sending data on a socket we are freeing */
++	down(&server->tcpSem); 
++	if(server->ssocket) {
++		cFYI(1,("State: 0x%x Flags: 0x%lx", server->ssocket->state,
++			server->ssocket->flags));
++		server->ssocket->ops->shutdown(server->ssocket,SEND_SHUTDOWN);
++		cFYI(1,("Post shutdown state: 0x%x Flags: 0x%lx", server->ssocket->state,
++			server->ssocket->flags));
++		sock_release(server->ssocket);
++		server->ssocket = NULL;
++	}
++
++	spin_lock(&GlobalMid_Lock);
++	list_for_each(tmp, &server->pending_mid_q) {
++		mid_entry = list_entry(tmp, struct
++					mid_q_entry,
++					qhead);
++		if(mid_entry) {
++			if(mid_entry->midState == MID_REQUEST_SUBMITTED) {
++				/* Mark other intransit requests as needing retry so 
++				  we do not immediately mark the session bad again 
++				  (ie after we reconnect below) as they timeout too */
++				mid_entry->midState = MID_RETRY_NEEDED;
++			}
++		}
++	}
++	spin_unlock(&GlobalMid_Lock);
++	up(&server->tcpSem); 
++
++	while ((server->tcpStatus != CifsExiting) && (server->tcpStatus != CifsGood))
++	{
++		if(server->protocolType == IPV6) {
++			rc = ipv6_connect(&server->addr.sockAddr6,&server->ssocket);
++		} else {
++			rc = ipv4_connect(&server->addr.sockAddr, 
++					&server->ssocket,
++					server->workstation_RFC1001_name);
++		}
++		if(rc) {
++			set_current_state(TASK_INTERRUPTIBLE);
++			schedule_timeout(3 * HZ);
++		} else {
++			atomic_inc(&tcpSesReconnectCount);
++			spin_lock(&GlobalMid_Lock);
++			if(server->tcpStatus != CifsExiting)
++				server->tcpStatus = CifsGood;
++			spin_unlock(&GlobalMid_Lock);
++	/*		atomic_set(&server->inFlight,0);*/
++			wake_up(&server->response_q);
++		}
++	}
++	return rc;
++}
++
++static int
++cifs_demultiplex_thread(struct TCP_Server_Info *server)
++{
++	int length;
++	unsigned int pdu_length, total_read;
++	struct smb_hdr *smb_buffer = NULL;
++	struct msghdr smb_msg;
++	mm_segment_t temp_fs;
++	struct iovec iov;
++	struct socket *csocket = server->ssocket;
++	struct list_head *tmp;
++	struct cifsSesInfo *ses;
++	struct task_struct *task_to_wake = NULL;
++	struct mid_q_entry *mid_entry;
++	char *temp;
++
++	daemonize();
++	sprintf(current->comm,"cifsd");
++	/* allow_signal(SIGKILL);*/
++	current->flags |= PF_MEMALLOC;
++	server->tsk = current;	/* save process info to wake at shutdown */
++	cFYI(1, ("Demultiplex PID: %d", current->pid));
++
++	temp_fs = get_fs();	/* we must turn off socket api parm checking */
++	set_fs(get_ds());
++
++	while (server->tcpStatus != CifsExiting) {
++		if (smb_buffer == NULL)
++			smb_buffer = cifs_buf_get();
++		else
++			memset(smb_buffer, 0, sizeof (struct smb_hdr));
++
++		if (smb_buffer == NULL) {
++			cERROR(1,("Can not get memory for SMB response"));
++			set_current_state(TASK_INTERRUPTIBLE);
++			schedule_timeout(HZ * 3); /* give system time to free memory */
++			continue;
++		}
++		iov.iov_base = smb_buffer;
++		iov.iov_len = sizeof (struct smb_hdr) - 1;	
++        /* 1 byte less above since wct is not always returned in error cases */
++		smb_msg.msg_iov = &iov;
++		smb_msg.msg_iovlen = 1;
++		smb_msg.msg_control = NULL;
++		smb_msg.msg_controllen = 0;
++
++		length =
++		    sock_recvmsg(csocket, &smb_msg,
++				 sizeof (struct smb_hdr) -
++				 1 /* RFC1001 header and SMB header */ ,
++				 MSG_PEEK /* flags see socket.h */ );
++
++		if(server->tcpStatus == CifsExiting) {
++			break;
++		} else if (server->tcpStatus == CifsNeedReconnect) {
++			cFYI(1,("Reconnecting after server stopped responding"));
++			cifs_reconnect(server);
++			cFYI(1,("call to reconnect done"));
++			csocket = server->ssocket;
++			continue;
++		} else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
++			set_current_state(TASK_INTERRUPTIBLE);
++			schedule_timeout(1); /* minimum sleep to prevent looping
++				allowing socket to clear and app threads to set
++				tcpStatus CifsNeedReconnect if server hung */
++			continue;
++		} else if (length <= 0) {
++			if(server->tcpStatus == CifsNew) {
++				cFYI(1,("tcp session abended prematurely (after SMBnegprot)"));
++				/* some servers kill tcp session rather than returning
++					smb negprot error in which case reconnecting here is
++					not going to help - return error to mount */
++				break;
++			}
++			if(length == -EINTR) { 
++				cFYI(1,("cifsd thread killed"));
++				break;
++			}
++			cFYI(1,("Reconnecting after unexpected peek error %d",length));
++			cifs_reconnect(server);
++			csocket = server->ssocket;
++			wake_up(&server->response_q);
++			continue;
++		}
++
++		pdu_length = 4 + ntohl(smb_buffer->smb_buf_length);
++		/* Ony read pdu_length after below checks for too short (due
++		   to e.g. int overflow) and too long ie beyond end of buf */
++		cFYI(1, ("Peek length rcvd: 0x%x beginning 0x%x)", length, pdu_length));
++
++		temp = (char *) smb_buffer;
++		if (length > 3) {
++			if (temp[0] == (char) RFC1002_SESSION_KEEP_ALIVE) {
++				iov.iov_base = smb_buffer;
++				iov.iov_len = 4;
++				length = sock_recvmsg(csocket, &smb_msg, 4, 0);
++				cFYI(0,("Received 4 byte keep alive packet"));
++			} else if (temp[0] == (char) RFC1002_POSITIVE_SESSION_RESPONSE) {
++				iov.iov_base = smb_buffer;
++					iov.iov_len = 4;
++					length = sock_recvmsg(csocket, &smb_msg, 4, 0);
++					cFYI(1,("Good RFC 1002 session rsp"));
++			} else if ((temp[0] == (char)RFC1002_NEGATIVE_SESSION_RESPONSE)
++				   && (length == 5)) {
++				/* we get this from Windows 98 instead of error on SMB negprot response */
++				cFYI(1,("Negative RFC 1002 Session Response Error 0x%x)",temp[4]));
++				if(server->tcpStatus == CifsNew) {
++					/* if nack on negprot (rather than 
++					ret of smb negprot error) reconnecting
++					not going to help, ret error to mount */
++					break;
++				} else {
++					/* give server a second to
++					clean up before reconnect attempt */
++					set_current_state(TASK_INTERRUPTIBLE);
++					schedule_timeout(HZ);
++					/* always try 445 first on reconnect
++					since we get NACK on some if we ever
++					connected to port 139 (the NACK is 
++					since we do not begin with RFC1001
++					session initialize frame) */
++					server->addr.sockAddr.sin_port = CIFS_PORT;
++					cifs_reconnect(server);
++					csocket = server->ssocket;
++					wake_up(&server->response_q);
++					continue;
++				}
++			} else if (temp[0] != (char) 0) {
++				cERROR(1,("Unknown RFC 1002 frame"));
++				cifs_dump_mem(" Received Data: ", temp, length);
++				cifs_reconnect(server);
++				csocket = server->ssocket;
++				continue;
++			} else {
++				if ((length != sizeof (struct smb_hdr) - 1)
++				    || (pdu_length >
++					CIFS_MAX_MSGSIZE + MAX_CIFS_HDR_SIZE)
++				    || (pdu_length <
++					sizeof (struct smb_hdr) - 1)
++				    ||
++				    (checkSMBhdr
++				     (smb_buffer, smb_buffer->Mid))) {
++					cERROR(1,
++					    ("Invalid size or format for SMB found with length %d and pdu_lenght %d",
++						length, pdu_length));
++					cifs_dump_mem("Received Data is: ",temp,sizeof(struct smb_hdr));
++					/* could we fix this network corruption by finding next 
++						smb header (instead of killing the session) and
++						restart reading from next valid SMB found? */
++					cifs_reconnect(server);
++					csocket = server->ssocket;
++					continue;
++				} else {	/* length ok */
++
++					length = 0;
++					iov.iov_base = smb_buffer;
++					iov.iov_len = pdu_length;
++					for (total_read = 0; 
++					     total_read < pdu_length;
++					     total_read += length) {	
++						length = sock_recvmsg(csocket, &smb_msg, 
++							pdu_length - total_read, 0);
++						if (length == 0) {
++							cERROR(1,
++							       ("Zero length receive when expecting %d ",
++								pdu_length - total_read));
++							cifs_reconnect(server);
++							csocket = server->ssocket;
++							continue;
++						}
++					}
++				}
++
++				dump_smb(smb_buffer, length);
++				if (checkSMB
++				    (smb_buffer, smb_buffer->Mid, total_read)) {
++					cERROR(1, ("Bad SMB Received "));
++					continue;
++				}
++
++				task_to_wake = NULL;
++				spin_lock(&GlobalMid_Lock);
++				list_for_each(tmp, &server->pending_mid_q) {
++					mid_entry = list_entry(tmp, struct
++							       mid_q_entry,
++							       qhead);
++
++					if ((mid_entry->mid == smb_buffer->Mid) && (mid_entry->midState == MID_REQUEST_SUBMITTED)) {
++						cFYI(1,
++						     (" Mid 0x%x matched - waking up ",mid_entry->mid));
++						task_to_wake = mid_entry->tsk;
++						mid_entry->resp_buf =
++						    smb_buffer;
++						mid_entry->midState =
++						    MID_RESPONSE_RECEIVED;
++					}
++				}
++				spin_unlock(&GlobalMid_Lock);
++				if (task_to_wake) {
++					smb_buffer = NULL;	/* will be freed by users thread after he is done */
++					wake_up_process(task_to_wake);
++				} else if (is_valid_oplock_break(smb_buffer) == FALSE) {                          
++					cERROR(1, ("No task to wake, unknown frame rcvd!"));
++					cifs_dump_mem("Received Data is: ",temp,sizeof(struct smb_hdr));
++				}
++			}
++		} else {
++			cFYI(0,
++			     ("Frame less than four bytes received  %d bytes long.",
++			      length));
++			if (length > 0) {
++				length = sock_recvmsg(csocket, &smb_msg, length, 0);	/* throw away junk frame */
++				cFYI(1,
++				     (" with junk  0x%x in it ",
++				      *(__u32 *) smb_buffer));
++			}
++		}
++	}
++	spin_lock(&GlobalMid_Lock);
++	server->tcpStatus = CifsExiting;
++	server->tsk = NULL;
++	atomic_set(&server->inFlight, 0);
++	spin_unlock(&GlobalMid_Lock);
++	/* Although there should not be any requests blocked on 
++	this queue it can not hurt to be paranoid and try to wake up requests
++	that may haven been blocked when more than 50 at time were on the wire 
++	to the same server - they now will see the session is in exit state
++	and get out of SendReceive.  */
++	wake_up_all(&server->request_q);
++	/* give those requests time to exit */
++	set_current_state(TASK_INTERRUPTIBLE);
++	schedule_timeout(HZ/8);
++
++	if(server->ssocket) {
++		sock_release(csocket);
++		server->ssocket = NULL;
++	}
++	set_fs(temp_fs);
++	if (smb_buffer) /* buffer usually freed in free_mid - need to free it on error or exit */
++		cifs_buf_release(smb_buffer);
++
++	read_lock(&GlobalSMBSeslock);
++	if (list_empty(&server->pending_mid_q)) {
++		/* loop through server session structures attached to this and mark them dead */
++		list_for_each(tmp, &GlobalSMBSessionList) {
++			ses =
++			    list_entry(tmp, struct cifsSesInfo,
++				       cifsSessionList);
++			if (ses->server == server) {
++				ses->status = CifsExiting;
++				ses->server = NULL;
++			}
++		}
++		read_unlock(&GlobalSMBSeslock);
++	} else {
++		spin_lock(&GlobalMid_Lock);
++		list_for_each(tmp, &server->pending_mid_q) {
++		mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
++			if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
++				cFYI(1,
++					 (" Clearing Mid 0x%x - waking up ",mid_entry->mid));
++				task_to_wake = mid_entry->tsk;
++				if(task_to_wake) {
++					wake_up_process(task_to_wake);
++				}
++			}
++		}
++		spin_unlock(&GlobalMid_Lock);
++		read_unlock(&GlobalSMBSeslock);
++		set_current_state(TASK_INTERRUPTIBLE);
++		/* 1/8th of sec is more than enough time for them to exit */
++		schedule_timeout(HZ/8); 
++	}
++
++	if (list_empty(&server->pending_mid_q)) {
++		/* mpx threads have not exited yet give them 
++		at least the smb send timeout time for long ops */
++		cFYI(1, ("Wait for exit from demultiplex thread"));
++		set_current_state(TASK_INTERRUPTIBLE);
++		schedule_timeout(46 * HZ);	
++		/* if threads still have not exited they are probably never
++		coming home not much else we can do but free the memory */
++	}
++	kfree(server);
++
++	set_current_state(TASK_INTERRUPTIBLE);
++	schedule_timeout(HZ/4);
++	return 0;
++}
++
++static void * 
++cifs_kcalloc(size_t size, int type)
++{
++	void *addr;
++	addr = kmalloc(size, type);
++	if (addr)
++		memset(addr, 0, size);
++	return addr;
++}
++
++static int
++cifs_parse_mount_options(char *options, const char *devname, struct smb_vol *vol)
++{
++	char *value;
++	char *data;
++	unsigned int  temp_len, i, j;
++	char separator[2];
++
++	separator[0] = ',';
++	separator[1] = 0; 
++
++	memset(vol->source_rfc1001_name,0x20,15);
++	for(i=0;i < strnlen(system_utsname.nodename,15);i++) {
++		/* does not have to be a perfect mapping since the field is
++		informational, only used for servers that do not support
++		port 445 and it can be overridden at mount time */
++		vol->source_rfc1001_name[i] = toupper(system_utsname.nodename[i]);
++	}
++	vol->source_rfc1001_name[15] = 0;
++
++	vol->linux_uid = current->uid;	/* current->euid instead? */
++	vol->linux_gid = current->gid;
++	vol->dir_mode = S_IRWXUGO;
++	/* 2767 perms indicate mandatory locking support */
++	vol->file_mode = S_IALLUGO & ~(S_ISUID | S_IXGRP);
++
++	/* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
++	vol->rw = TRUE;
++
++	if (!options)
++		return 1;
++
++	if(strncmp(options,"sep=",4) == 0) {
++		if(options[4] != 0) {
++			separator[0] = options[4];
++			options += 5;
++		} else {
++			cFYI(1,("Null separator not allowed"));
++		}
++	}
++		
++	while ((data = strsep(&options, separator)) != NULL) {
++		if (!*data)
++			continue;
++		if ((value = strchr(data, '=')) != NULL)
++			*value++ = '\0';
++		if (strnicmp(data, "user", 4) == 0) {
++			if (!value || !*value) {
++				printk(KERN_WARNING
++				       "CIFS: invalid or missing username\n");
++				return 1;	/* needs_arg; */
++			}
++			if (strnlen(value, 200) < 200) {
++				vol->username = value;
++			} else {
++				printk(KERN_WARNING "CIFS: username too long\n");
++				return 1;
++			}
++		} else if (strnicmp(data, "pass", 4) == 0) {
++			if (!value || !*value) {
++				vol->password = NULL;
++				continue;
++			}
++			temp_len = strlen(value);
++			/* removed password length check, NTLM passwords
++				can be arbitrarily long */
++
++			/* if comma in password, the string will be 
++			prematurely null terminated.  Commas in password are
++			specified across the cifs mount interface by a double
++			comma ie ,, and a comma used as in other cases ie ','
++			as a parameter delimiter/separator is single and due
++			to the strsep above is temporarily zeroed. */
++
++			/* NB: password legally can have multiple commas and
++			the only illegal character in a password is null */
++				
++			if ((value[temp_len] == 0) && (value[temp_len+1] == separator[0])) {
++				/* reinsert comma */
++				value[temp_len] = separator[0];
++				temp_len+=2;  /* move after the second comma */
++				while(value[temp_len] != 0)  {
++					if((value[temp_len] == separator[0]) && (value[temp_len+1] != separator[0])) {
++						/* single comma indicating start of next parm */
++						break;
++					}
++					temp_len++;
++				}
++				if(value[temp_len] == 0) {
++					options = NULL;
++				} else {
++					value[temp_len] = 0;
++					/* move options to point to start of next parm */
++					options = value + temp_len + 1;
++				}
++				/* go from value to (value + temp_len) condensing double commas to singles */
++				vol->password = cifs_kcalloc(temp_len, GFP_KERNEL);
++				for(i=0,j=0;i<temp_len;i++,j++) {
++					vol->password[j] = value[i];
++					if(value[i] == separator[0] && value[i+1] == separator[0]) {
++						/* skip second comma */
++						i++;
++					}
++				}
++				/* value[temp_len] is zeroed above so
++					 vol->password[temp_len] guaranteed to be null */
++			} else {
++				vol->password = cifs_kcalloc(temp_len + 1, GFP_KERNEL);
++				strcpy(vol->password, value);
++			}
++		} else if (strnicmp(data, "ip", 2) == 0) {
++			if (!value || !*value) {
++				vol->UNCip = NULL;
++			} else if (strnlen(value, 35) < 35) {
++				vol->UNCip = value;
++			} else {
++				printk(KERN_WARNING "CIFS: ip address too long\n");
++				return 1;
++			}
++		} else if ((strnicmp(data, "unc", 3) == 0)
++			   || (strnicmp(data, "target", 6) == 0)
++			   || (strnicmp(data, "path", 4) == 0)) {
++			if (!value || !*value) {
++				printk(KERN_WARNING
++				       "CIFS: invalid path to network resource\n");
++				return 1;	/* needs_arg; */
++			}
++			if ((temp_len = strnlen(value, 300)) < 300) {
++				vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
++				if(vol->UNC == NULL)
++					return 1;
++				strcpy(vol->UNC,value);
++				if (strncmp(vol->UNC, "//", 2) == 0) {
++					vol->UNC[0] = '\\';
++					vol->UNC[1] = '\\';
++				} else if (strncmp(vol->UNC, "\\\\", 2) != 0) {	                   
++					printk(KERN_WARNING
++					       "CIFS: UNC Path does not begin with // or \\\\ \n");
++					return 1;
++				}
++			} else {
++				printk(KERN_WARNING "CIFS: UNC name too long\n");
++				return 1;
++			}
++		} else if ((strnicmp(data, "domain", 3) == 0)
++			   || (strnicmp(data, "workgroup", 5) == 0)) {
++			if (!value || !*value) {
++				printk(KERN_WARNING "CIFS: invalid domain name\n");
++				return 1;	/* needs_arg; */
++			}
++			/* BB are there cases in which a comma can be valid in
++			a domain name and need special handling? */
++			if (strnlen(value, 65) < 65) {
++				vol->domainname = value;
++				cFYI(1, ("Domain name set"));
++			} else {
++				printk(KERN_WARNING "CIFS: domain name too long\n");
++				return 1;
++			}
++		} else if (strnicmp(data, "iocharset", 9) == 0) {
++			if (!value || !*value) {
++				printk(KERN_WARNING "CIFS: invalid iocharset specified\n");
++				return 1;	/* needs_arg; */
++			}
++			if (strnlen(value, 65) < 65) {
++				if(strnicmp(value,"default",7))
++					vol->iocharset = value;
++				/* if iocharset not set load_nls_default used by caller */
++				cFYI(1, ("iocharset set to %s",value));
++			} else {
++				printk(KERN_WARNING "CIFS: iocharset name too long.\n");
++				return 1;
++			}
++		} else if (strnicmp(data, "uid", 3) == 0) {
++			if (value && *value) {
++				vol->linux_uid =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "gid", 3) == 0) {
++			if (value && *value) {
++				vol->linux_gid =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "file_mode", 4) == 0) {
++			if (value && *value) {
++				vol->file_mode =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "dir_mode", 3) == 0) {
++			if (value && *value) {
++				vol->dir_mode =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "port", 4) == 0) {
++			if (value && *value) {
++				vol->port =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "rsize", 5) == 0) {
++			if (value && *value) {
++				vol->rsize =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "wsize", 5) == 0) {
++			if (value && *value) {
++				vol->wsize =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "sockopt", 5) == 0) {
++			if (value && *value) {
++				vol->sockopt =
++					simple_strtoul(value, &value, 0);
++			}
++		} else if (strnicmp(data, "netbiosname", 4) == 0) {
++			if (!value || !*value || (*value == ' ')) {
++				cFYI(1,("invalid (empty) netbiosname specified"));
++			} else {
++				memset(vol->source_rfc1001_name,0x20,15);
++				for(i=0;i<15;i++) {
++				/* BB are there cases in which a comma can be 
++				valid in this workstation netbios name (and need
++				special handling)? */
++
++				/* We do not uppercase netbiosname for user */
++					if (value[i]==0)
++						break;
++					else 
++						vol->source_rfc1001_name[i] = value[i];
++				}
++				/* The string has 16th byte zero still from
++				set at top of the function  */
++				if((i==15) && (value[i] != 0))
++					printk(KERN_WARNING "CIFS: netbiosname longer than 15 and was truncated.\n");
++			}
++		} else if (strnicmp(data, "credentials", 4) == 0) {
++			/* ignore */
++		} else if (strnicmp(data, "version", 3) == 0) {
++			/* ignore */
++		} else if (strnicmp(data, "rw", 2) == 0) {
++			vol->rw = TRUE;
++		} else if ((strnicmp(data, "suid", 4) == 0) ||
++				   (strnicmp(data, "nosuid", 6) == 0) ||
++				   (strnicmp(data, "exec", 4) == 0) ||
++				   (strnicmp(data, "noexec", 6) == 0) ||
++				   (strnicmp(data, "nodev", 5) == 0) ||
++				   (strnicmp(data, "noauto", 6) == 0) ||
++				   (strnicmp(data, "dev", 3) == 0)) {
++			/*  The mount tool or mount.cifs helper (if present)
++				uses these opts to set flags, and the flags are read
++				by the kernel vfs layer before we get here (ie
++				before read super) so there is no point trying to
++				parse these options again and set anything and it
++				is ok to just ignore them */
++			continue;
++		} else if (strnicmp(data, "ro", 2) == 0) {
++			vol->rw = FALSE;
++		} else if (strnicmp(data, "hard", 4) == 0) {
++			vol->retry = 1;
++		} else if (strnicmp(data, "soft", 4) == 0) {
++			vol->retry = 0;
++		} else if (strnicmp(data, "nohard", 6) == 0) {
++			vol->retry = 0;
++		} else if (strnicmp(data, "nosoft", 6) == 0) {
++			vol->retry = 1;
++		} else if (strnicmp(data, "nointr", 6) == 0) {
++			vol->intr = 0;
++		} else if (strnicmp(data, "intr", 4) == 0) {
++			vol->intr = 1;
++		} else if (strnicmp(data, "noac", 4) == 0) {
++			printk(KERN_WARNING "CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
++		} else
++			printk(KERN_WARNING "CIFS: Unknown mount option %s\n",data);
++	}
++	if (vol->UNC == NULL) {
++		if(devname == NULL) {
++			printk(KERN_WARNING "CIFS: Missing UNC name for mount target\n");
++			return 1;
++		}
++		if ((temp_len = strnlen(devname, 300)) < 300) {
++			vol->UNC = kmalloc(temp_len+1,GFP_KERNEL);
++			if(vol->UNC == NULL)
++				return 1;
++			strcpy(vol->UNC,devname);
++			if (strncmp(vol->UNC, "//", 2) == 0) {
++				vol->UNC[0] = '\\';
++				vol->UNC[1] = '\\';
++			} else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
++				printk(KERN_WARNING "CIFS: UNC Path does not begin with // or \\\\ \n");
++				return 1;
++			}
++		} else {
++			printk(KERN_WARNING "CIFS: UNC name too long\n");
++			return 1;
++		}
++	}
++	if(vol->UNCip == 0)
++		vol->UNCip = &vol->UNC[2];
++
++	return 0;
++}
++
++static struct cifsSesInfo *
++cifs_find_tcp_session(__u32 new_target_ip_addr,
++		 char *userName, struct TCP_Server_Info **psrvTcp)
++{
++	struct list_head *tmp;
++	struct cifsSesInfo *ses;
++
++	*psrvTcp = NULL;
++	read_lock(&GlobalSMBSeslock);
++	list_for_each(tmp, &GlobalSMBSessionList) {
++		ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
++		if (ses->server) {
++			if (ses->server->addr.sockAddr.sin_addr.s_addr ==
++			    new_target_ip_addr) {
++				/* BB lock server and tcp session and increment use count here?? */
++				*psrvTcp = ses->server;	/* found a match on the TCP session */
++				/* BB check if reconnection needed */
++				if (strncmp
++				    (ses->userName, userName,
++				     MAX_USERNAME_SIZE) == 0){
++					read_unlock(&GlobalSMBSeslock);
++					return ses;	/* found exact match on both tcp and SMB sessions */
++				}
++			}
++		}
++		/* else tcp and smb sessions need reconnection */
++	}
++	read_unlock(&GlobalSMBSeslock);
++	return NULL;
++}
++
++static struct cifsTconInfo *
++find_unc(__u32 new_target_ip_addr, char *uncName, char *userName)
++{
++	struct list_head *tmp;
++	struct cifsTconInfo *tcon;
++
++	read_lock(&GlobalSMBSeslock);
++	list_for_each(tmp, &GlobalTreeConnectionList) {
++		cFYI(1, ("Next tcon - "));
++		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
++		if (tcon->ses) {
++			if (tcon->ses->server) {
++				cFYI(1,
++				     (" old ip addr: %x == new ip %x ?",
++				      tcon->ses->server->addr.sockAddr.sin_addr.
++				      s_addr, new_target_ip_addr));
++				if (tcon->ses->server->addr.sockAddr.sin_addr.
++				    s_addr == new_target_ip_addr) {
++	/* BB lock tcon and server and tcp session and increment use count here? */
++					/* found a match on the TCP session */
++					/* BB check if reconnection needed */
++					cFYI(1,("Matched ip, old UNC: %s == new: %s ?",
++					      tcon->treeName, uncName));
++					if (strncmp
++					    (tcon->treeName, uncName,
++					     MAX_TREE_SIZE) == 0) {
++						cFYI(1,
++						     ("Matched UNC, old user: %s == new: %s ?",
++						      tcon->treeName, uncName));
++						if (strncmp
++						    (tcon->ses->userName,
++						     userName,
++						     MAX_USERNAME_SIZE) == 0) {
++							read_unlock(&GlobalSMBSeslock);
++							return tcon;/* also matched user (smb session)*/
++						}
++					}
++				}
++			}
++		}
++	}
++	read_unlock(&GlobalSMBSeslock);
++	return NULL;
++}
++
++int
++connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
++		    const char *old_path, const struct nls_table *nls_codepage)
++{
++	unsigned char *referrals = NULL;
++	unsigned int num_referrals;
++	int rc = 0;
++
++	rc = get_dfs_path(xid, pSesInfo,old_path, nls_codepage, 
++			&num_referrals, &referrals);
++
++	/* BB Add in code to: if valid refrl, if not ip address contact
++		the helper that resolves tcp names, mount to it, try to 
++		tcon to it unmount it if fail */
++
++	if(referrals)
++		kfree(referrals);
++
++	return rc;
++}
++
++int
++get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
++			const char *old_path, const struct nls_table *nls_codepage, 
++			unsigned int *pnum_referrals, unsigned char ** preferrals)
++{
++	char *temp_unc;
++	int rc = 0;
++
++	*pnum_referrals = 0;
++
++	if (pSesInfo->ipc_tid == 0) {
++		temp_unc = kmalloc(2 /* for slashes */ +
++			strnlen(pSesInfo->serverName,SERVER_NAME_LEN_WITH_NULL * 2)
++				 + 1 + 4 /* slash IPC$ */  + 2,
++				GFP_KERNEL);
++		if (temp_unc == NULL)
++			return -ENOMEM;
++		temp_unc[0] = '\\';
++		temp_unc[1] = '\\';
++		strcpy(temp_unc + 2, pSesInfo->serverName);
++		strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
++		rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
++		cFYI(1,
++		     ("CIFS Tcon rc = %d ipc_tid = %d", rc,pSesInfo->ipc_tid));
++		kfree(temp_unc);
++	}
++	if (rc == 0)
++		rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
++				     pnum_referrals, nls_codepage);
++
++	return rc;
++}
++
++/* See RFC1001 section 14 on representation of Netbios names */
++static void rfc1002mangle(char * target,char * source, unsigned int length)
++{
++	unsigned int i,j;
++
++	for(i=0,j=0;i<(length);i++) {
++		/* mask a nibble at a time and encode */
++		target[j] = 'A' + (0x0F & (source[i] >> 4));
++		target[j+1] = 'A' + (0x0F & source[i]);
++		j+=2;
++	}
++
++}
++
++
++static int
++ipv4_connect(struct sockaddr_in *psin_server, struct socket **csocket, 
++			 char * netbios_name)
++{
++	int rc = 0;
++	int connected = 0;
++	unsigned short int orig_port = 0;
++
++	if(*csocket == NULL) {
++		rc = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, csocket);
++		if (rc < 0) {
++			cERROR(1, ("Error %d creating socket",rc));
++			*csocket = NULL;
++			return rc;
++		} else {
++		/* BB other socket options to set KEEPALIVE, NODELAY? */
++			cFYI(1,("Socket created"));
++			(*csocket)->sk->allocation = GFP_NOFS; 
++		}
++	}
++
++	psin_server->sin_family = AF_INET;
++	if(psin_server->sin_port) { /* user overrode default port */
++		rc = (*csocket)->ops->connect(*csocket,
++				(struct sockaddr *) psin_server,
++				sizeof (struct sockaddr_in),0);
++		if (rc >= 0)
++			connected = 1;
++	} 
++
++	if(!connected) {
++		/* save original port so we can retry user specified port  
++			later if fall back ports fail this time  */
++		orig_port = psin_server->sin_port;
++
++		/* do not retry on the same port we just failed on */
++		if(psin_server->sin_port != htons(CIFS_PORT)) {
++			psin_server->sin_port = htons(CIFS_PORT);
++
++			rc = (*csocket)->ops->connect(*csocket,
++					(struct sockaddr *) psin_server,
++					sizeof (struct sockaddr_in),0);
++			if (rc >= 0)
++				connected = 1;
++		}
++	}
++	if (!connected) {
++		psin_server->sin_port = htons(RFC1001_PORT);
++		rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
++					      psin_server, sizeof (struct sockaddr_in),0);
++		if (rc >= 0) 
++			connected = 1;
++	}
++
++	/* give up here - unless we want to retry on different
++		protocol families some day */
++	if (!connected) {
++		if(orig_port)
++			psin_server->sin_port = orig_port;
++		cFYI(1,("Error %d connecting to server via ipv4",rc));
++		sock_release(*csocket);
++		*csocket = NULL;
++		return rc;
++	}
++	/* Eventually check for other socket options to change from 
++		the default. sock_setsockopt not used because it expects 
++		user space buffer */
++	(*csocket)->sk->rcvtimeo = 7 * HZ;
++			
++	/* send RFC1001 sessinit */
++
++	if(psin_server->sin_port == htons(139)) {
++		/* some servers require RFC1001 sessinit before sending
++		negprot - BB check reconnection in case where second 
++		sessinit is sent but no second negprot */
++		struct rfc1002_session_packet * ses_init_buf;
++		struct smb_hdr * smb_buf;
++		ses_init_buf = cifs_kcalloc(sizeof(struct rfc1002_session_packet), GFP_KERNEL);
++		if(ses_init_buf) {
++			ses_init_buf->trailer.session_req.called_len = 32;
++			rfc1002mangle(ses_init_buf->trailer.session_req.called_name,
++				DEFAULT_CIFS_CALLED_NAME,16);
++			ses_init_buf->trailer.session_req.calling_len = 32;
++			/* calling name ends in null (byte 16) from old smb
++			convention. */
++			if(netbios_name && (netbios_name[0] !=0)) {
++				rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
++					netbios_name,16);
++			} else {
++				rfc1002mangle(ses_init_buf->trailer.session_req.calling_name,
++					"LINUX_CIFS_CLNT",16);
++			}
++			ses_init_buf->trailer.session_req.scope1 = 0;
++			ses_init_buf->trailer.session_req.scope2 = 0;
++			smb_buf = (struct smb_hdr *)ses_init_buf;
++			/* sizeof RFC1002_SESSION_REQUEST with no scope */
++			smb_buf->smb_buf_length = 0x81000044;
++			rc = smb_send(*csocket, smb_buf, 0x44,
++				(struct sockaddr *)psin_server);
++			kfree(ses_init_buf);
++		}
++		/* else the negprot may still work without this 
++		even though malloc failed */
++		
++	}
++		
++	return rc;
++}
++
++static int
++ipv6_connect(struct sockaddr_in6 *psin_server, struct socket **csocket)
++{
++	int rc = 0;
++	int connected = 0;
++
++	if(*csocket == NULL) {
++		rc = sock_create(PF_INET6, SOCK_STREAM, IPPROTO_TCP, csocket);
++		if (rc < 0) {
++			cERROR(1, ("Error %d creating ipv6 socket",rc));
++			*csocket = NULL;
++			return rc;
++		} else {
++		/* BB other socket options to set KEEPALIVE, NODELAY? */
++			 cFYI(1,("ipv6 Socket created"));
++			(*csocket)->sk->allocation = GFP_NOFS;
++		}
++	}
++
++	psin_server->sin6_family = AF_INET6;
++
++	if(psin_server->sin6_port) { /* user overrode default port */
++		rc = (*csocket)->ops->connect(*csocket,
++				(struct sockaddr *) psin_server,
++				sizeof (struct sockaddr_in6),0);
++		if (rc >= 0)
++			connected = 1;
++	} 
++
++	if(!connected) {
++		/* do not retry on the same port we just failed on */
++		if(psin_server->sin6_port != htons(CIFS_PORT)) {
++			psin_server->sin6_port = htons(CIFS_PORT);
++
++			rc = (*csocket)->ops->connect(*csocket,
++					(struct sockaddr *) psin_server,
++					sizeof (struct sockaddr_in6),0);
++			if (rc >= 0)
++				connected = 1;
++		}
++	}
++	if (!connected) {
++		psin_server->sin6_port = htons(RFC1001_PORT);
++		rc = (*csocket)->ops->connect(*csocket, (struct sockaddr *)
++					 psin_server, sizeof (struct sockaddr_in6),0);
++		if (rc >= 0) 
++			connected = 1;
++	}
++
++	/* give up here - unless we want to retry on different
++		protocol families some day */
++	if (!connected) {
++		cFYI(1,("Error %d connecting to server via ipv6",rc));
++		sock_release(*csocket);
++		*csocket = NULL;
++		return rc;
++	}
++	/* Eventually check for other socket options to change from 
++		the default. sock_setsockopt not used because it expects 
++		user space buffer */
++	(*csocket)->sk->rcvtimeo = 7 * HZ;
++		
++	return rc;
++}
++
++int
++cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
++	   char *mount_data, const char *devname)
++{
++	int rc = 0;
++	int xid;
++	struct socket *csocket = NULL;
++	struct sockaddr_in sin_server;
++	struct sockaddr_in6 sin_server6;
++	struct smb_vol volume_info;
++	struct cifsSesInfo *pSesInfo = NULL;
++	struct cifsSesInfo *existingCifsSes = NULL;
++	struct cifsTconInfo *tcon = NULL;
++	struct TCP_Server_Info *srvTcp = NULL;
++
++	xid = GetXid();
++
++	cFYI(1, ("Entering cifs_mount. Xid: %d with: %s", xid, mount_data)); /* BB removeme BB fixme */
++	
++	memset(&volume_info,0,sizeof(struct smb_vol));
++	if (cifs_parse_mount_options(mount_data, devname, &volume_info)) {
++		if(volume_info.UNC)
++			kfree(volume_info.UNC);
++		if(volume_info.password)
++			kfree(volume_info.password);
++		FreeXid(xid);
++		return -EINVAL;
++	}
++
++	if (volume_info.username) {
++		cFYI(1, ("Username: %s ", volume_info.username));
++
++	} else {
++		cifserror("No username specified ");
++        /* In userspace mount helper we can get user name from alternate
++           locations such as env variables and files on disk */
++		if(volume_info.UNC)
++			kfree(volume_info.UNC);
++		if(volume_info.password)
++			kfree(volume_info.password);
++		FreeXid(xid);
++		return -EINVAL;
++	}
++
++	if (volume_info.UNCip && volume_info.UNC) {
++		rc = cifs_inet_pton(AF_INET, volume_info.UNCip,&sin_server.sin_addr.s_addr);
++
++		if(rc == 0) {
++			/* not ipv4 address, try ipv6 */
++			rc = cifs_inet_pton(AF_INET6,volume_info.UNCip,&sin_server6.sin6_addr.in6_u); 
++		} 
++       
++		if(rc != 1) {
++			/* we failed translating address */
++			if(volume_info.UNC)
++				kfree(volume_info.UNC);
++			if(volume_info.password)
++				kfree(volume_info.password);
++			FreeXid(xid);
++			return -EINVAL;
++		}
++
++		cFYI(1, ("UNC: %s ip: %s", volume_info.UNC, volume_info.UNCip));
++		/* success */
++		rc = 0;
++	} else if (volume_info.UNCip){
++		/* BB using ip addr as server name connect to the DFS root below */
++		cERROR(1,("Connecting to DFS root not implemented yet"));
++		if(volume_info.UNC)
++			kfree(volume_info.UNC);
++		if(volume_info.password)
++			kfree(volume_info.password);
++		FreeXid(xid);
++		return -EINVAL;
++	} else /* which servers DFS root would we conect to */ {
++		cERROR(1,
++		       ("CIFS mount error: No UNC path (e.g. -o unc=//192.168.1.100/public) specified  "));
++		if(volume_info.UNC)
++			kfree(volume_info.UNC);
++		if(volume_info.password)
++			kfree(volume_info.password);
++		FreeXid(xid);
++		return -EINVAL;
++	}
++
++	/* this is needed for ASCII cp to Unicode converts */
++	if(volume_info.iocharset == NULL) {
++		cifs_sb->local_nls = load_nls_default();
++	/* load_nls_default can not return null */
++	} else {
++		cifs_sb->local_nls = load_nls(volume_info.iocharset);
++		if(cifs_sb->local_nls == NULL) {
++			cERROR(1,("CIFS mount error: iocharset %s not found",volume_info.iocharset));
++			if(volume_info.UNC)
++				kfree(volume_info.UNC);
++			if(volume_info.password)
++				kfree(volume_info.password);
++			FreeXid(xid);
++			return -ELIBACC;
++		}
++	}
++
++	existingCifsSes =
++	    cifs_find_tcp_session(sin_server.sin_addr.s_addr,
++			     volume_info.username, &srvTcp);
++	if (srvTcp) {
++		cFYI(1, ("Existing tcp session with server found "));                
++	} else {	/* create socket */
++		if(volume_info.port)
++			sin_server.sin_port = htons(volume_info.port);
++		else
++			sin_server.sin_port = 0;
++		rc = ipv4_connect(&sin_server,&csocket,volume_info.source_rfc1001_name);
++		if (rc < 0) {
++			cERROR(1,
++			       ("Error connecting to IPv4 socket. Aborting operation"));
++			if(csocket != NULL)
++				sock_release(csocket);
++			if(volume_info.UNC)
++				kfree(volume_info.UNC);
++			if(volume_info.password)
++				kfree(volume_info.password);
++			FreeXid(xid);
++			return rc;
++		}
++
++		srvTcp = kmalloc(sizeof (struct TCP_Server_Info), GFP_KERNEL);
++		if (srvTcp == NULL) {
++			rc = -ENOMEM;
++			sock_release(csocket);
++			if(volume_info.UNC)
++				kfree(volume_info.UNC);
++			if(volume_info.password)
++				kfree(volume_info.password);
++			FreeXid(xid);
++			return rc;
++		} else {
++			memset(srvTcp, 0, sizeof (struct TCP_Server_Info));
++			memcpy(&srvTcp->addr.sockAddr, &sin_server, sizeof (struct sockaddr_in));
++			atomic_set(&srvTcp->inFlight,0);
++			/* BB Add code for ipv6 case too */
++			srvTcp->ssocket = csocket;
++			srvTcp->protocolType = IPV4;
++			init_waitqueue_head(&srvTcp->response_q);
++			init_waitqueue_head(&srvTcp->request_q);
++			INIT_LIST_HEAD(&srvTcp->pending_mid_q);
++			/* at this point we are the only ones with the pointer
++			to the struct since the kernel thread not created yet
++			so no need to spinlock this init of tcpStatus */
++			srvTcp->tcpStatus = CifsNew;
++			init_MUTEX(&srvTcp->tcpSem);
++			kernel_thread((void *)(void *)cifs_demultiplex_thread, srvTcp,
++				      CLONE_FS | CLONE_FILES | CLONE_VM);
++			memcpy(srvTcp->workstation_RFC1001_name, volume_info.source_rfc1001_name,16);
++		}
++	}
++
++	if (existingCifsSes) {
++		pSesInfo = existingCifsSes;
++		cFYI(1, ("Existing smb sess found "));
++		if(volume_info.password)
++			kfree(volume_info.password);
++		/* volume_info.UNC freed at end of function */
++	} else if (!rc) {
++		cFYI(1, ("Existing smb sess not found "));
++		pSesInfo = sesInfoAlloc();
++		if (pSesInfo == NULL)
++			rc = -ENOMEM;
++		else {
++			pSesInfo->server = srvTcp;
++			sprintf(pSesInfo->serverName, "%u.%u.%u.%u",
++				NIPQUAD(sin_server.sin_addr.s_addr));
++		}
++
++		if (!rc){
++			/* volume_info.password freed at unmount */   
++			if (volume_info.password)
++				pSesInfo->password = volume_info.password;
++			if (volume_info.username)
++				strncpy(pSesInfo->userName,
++					volume_info.username,MAX_USERNAME_SIZE);
++			if (volume_info.domainname)
++				strncpy(pSesInfo->domainName,
++					volume_info.domainname,MAX_USERNAME_SIZE);
++			pSesInfo->linux_uid = volume_info.linux_uid;
++			down(&pSesInfo->sesSem);
++			rc = cifs_setup_session(xid,pSesInfo, cifs_sb->local_nls);
++			up(&pSesInfo->sesSem);
++			if(!rc)
++				atomic_inc(&srvTcp->socketUseCount);
++		} else
++			if(volume_info.password)
++				kfree(volume_info.password);
++	}
++    
++	/* search for existing tcon to this server share */
++	if (!rc) {
++		if((volume_info.rsize) && (volume_info.rsize + MAX_CIFS_HDR_SIZE < srvTcp->maxBuf))
++			cifs_sb->rsize = volume_info.rsize;
++		else
++			cifs_sb->rsize = srvTcp->maxBuf - MAX_CIFS_HDR_SIZE; /* default */
++		if((volume_info.wsize) && (volume_info.wsize + MAX_CIFS_HDR_SIZE < srvTcp->maxBuf))
++			cifs_sb->wsize = volume_info.wsize;
++		else
++			cifs_sb->wsize = srvTcp->maxBuf - MAX_CIFS_HDR_SIZE; /* default */
++		if(cifs_sb->rsize < PAGE_CACHE_SIZE) {
++			cifs_sb->rsize = PAGE_CACHE_SIZE;
++			cERROR(1,("Attempt to set readsize for mount to less than one page (4096)"));
++		}
++		cifs_sb->mnt_uid = volume_info.linux_uid;
++		cifs_sb->mnt_gid = volume_info.linux_gid;
++		cifs_sb->mnt_file_mode = volume_info.file_mode;
++		cifs_sb->mnt_dir_mode = volume_info.dir_mode;
++		cFYI(1,("file mode: 0x%x  dir mode: 0x%x",cifs_sb->mnt_file_mode,cifs_sb->mnt_dir_mode));
++		tcon =
++		    find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
++			     volume_info.username);
++		if (tcon) {
++			cFYI(1, ("Found match on UNC path "));
++			/* we can have only one retry value for a connection
++			   to a share so for resources mounted more than once
++			   to the same server share the last value passed in 
++			   for the retry flag is used */
++			tcon->retry = volume_info.retry;
++		} else {
++			tcon = tconInfoAlloc();
++			if (tcon == NULL)
++				rc = -ENOMEM;
++			else {
++				/* check for null share name ie connect to dfs root */
++
++				/* BB check if this works for exactly length three strings */
++				if ((strchr(volume_info.UNC + 3, '\\') == NULL)
++				    && (strchr(volume_info.UNC + 3, '/') ==
++					NULL)) {
++					rc = connect_to_dfs_path(xid,
++								 pSesInfo,
++								 "",
++								 cifs_sb->
++								 local_nls);
++					if(volume_info.UNC)
++						kfree(volume_info.UNC);
++					FreeXid(xid);
++					return -ENODEV;
++				} else {
++					rc = CIFSTCon(xid, pSesInfo, 
++						volume_info.UNC,
++						tcon, cifs_sb->local_nls);
++					cFYI(1, ("CIFS Tcon rc = %d", rc));
++				}
++				if (!rc) {
++					atomic_inc(&pSesInfo->inUse);
++					tcon->retry = volume_info.retry;
++				}
++			}
++		}
++	}
++	if(pSesInfo) {
++		if (pSesInfo->capabilities & CAP_LARGE_FILES) {
++			sb->s_maxbytes = (u64) 1 << 63;
++		} else
++			sb->s_maxbytes = (u64) 1 << 31;	/* 2 GB */
++	}
++
++/* on error free sesinfo and tcon struct if needed */
++	if (rc) {
++		/* if session setup failed, use count is zero but
++		we still need to free cifsd thread */
++		if(atomic_read(&srvTcp->socketUseCount) == 0) {
++			spin_lock(&GlobalMid_Lock);
++			srvTcp->tcpStatus = CifsExiting;
++			spin_unlock(&GlobalMid_Lock);
++			if(srvTcp->tsk)
++				send_sig(SIGKILL,srvTcp->tsk,1);
++		}
++		 /* If find_unc succeeded then rc == 0 so we can not end */
++		if (tcon)  /* up accidently freeing someone elses tcon struct */
++			tconInfoFree(tcon);
++		if (existingCifsSes == 0) {
++			if (pSesInfo) {
++				if ((pSesInfo->server) && 
++				    (pSesInfo->status == CifsGood)) {
++					int temp_rc;
++					temp_rc = CIFSSMBLogoff(xid, pSesInfo);
++					/* if the socketUseCount is now zero */
++					if((temp_rc == -ESHUTDOWN) &&
++					   (pSesInfo->server->tsk))
++						send_sig(SIGKILL,pSesInfo->server->tsk,1);
++				} else
++					cFYI(1, ("No session or bad tcon"));
++				sesInfoFree(pSesInfo);
++				/* pSesInfo = NULL; */
++			}
++		}
++	} else {
++		atomic_inc(&tcon->useCount);
++		cifs_sb->tcon = tcon;
++		tcon->ses = pSesInfo;
++
++		/* do not care if following two calls succeed - informational only */
++		CIFSSMBQFSDeviceInfo(xid, tcon, cifs_sb->local_nls);
++		CIFSSMBQFSAttributeInfo(xid, tcon, cifs_sb->local_nls);
++		if (tcon->ses->capabilities & CAP_UNIX)
++			CIFSSMBQFSUnixInfo(xid, tcon, cifs_sb->local_nls);
++	}
++
++	/* volume_info.password is freed above when existing session found
++	(in which case it is not needed anymore) but when new sesion is created
++	the password ptr is put in the new session structure (in which case the
++	password will be freed at unmount time) */
++	if(volume_info.UNC)
++		kfree(volume_info.UNC);
++	FreeXid(xid);
++	return rc;
++}
++
++static int
++CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
++	      char session_key[CIFS_SESSION_KEY_SIZE],
++	      const struct nls_table *nls_codepage)
++{
++	struct smb_hdr *smb_buffer;
++	struct smb_hdr *smb_buffer_response;
++	SESSION_SETUP_ANDX *pSMB;
++	SESSION_SETUP_ANDX *pSMBr;
++	char *bcc_ptr;
++	char *user = ses->userName;
++	char *domain = ses->domainName;
++	int rc = 0;
++	int remaining_words = 0;
++	int bytes_returned = 0;
++	int len;
++
++	cFYI(1, ("In sesssetup "));
++
++	smb_buffer = cifs_buf_get();
++	if (smb_buffer == 0) {
++		return -ENOMEM;
++	}
++	smb_buffer_response = smb_buffer;
++	pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
++
++	/* send SMBsessionSetup here */
++	header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
++			NULL /* no tCon exists yet */ , 13 /* wct */ );
++
++	pSMB->req_no_secext.AndXCommand = 0xFF;
++	pSMB->req_no_secext.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
++	pSMB->req_no_secext.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
++
++	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
++		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
++
++	pSMB->req_no_secext.Capabilities =
++	    CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS;
++	if (ses->capabilities & CAP_UNICODE) {
++		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
++		pSMB->req_no_secext.Capabilities |= CAP_UNICODE;
++	}
++	if (ses->capabilities & CAP_STATUS32) {
++		smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
++		pSMB->req_no_secext.Capabilities |= CAP_STATUS32;
++	}
++	if (ses->capabilities & CAP_DFS) {
++		smb_buffer->Flags2 |= SMBFLG2_DFS;
++		pSMB->req_no_secext.Capabilities |= CAP_DFS;
++	}
++	pSMB->req_no_secext.Capabilities =
++	    cpu_to_le32(pSMB->req_no_secext.Capabilities);
++	/* pSMB->req_no_secext.CaseInsensitivePasswordLength =
++	   CIFS_SESSION_KEY_SIZE; */
++	pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
++	pSMB->req_no_secext.CaseSensitivePasswordLength =
++	    cpu_to_le16(CIFS_SESSION_KEY_SIZE);
++	bcc_ptr = pByteArea(smb_buffer);
++	/* memcpy(bcc_ptr, (char *) lm_session_key, CIFS_SESSION_KEY_SIZE);
++	   bcc_ptr += CIFS_SESSION_KEY_SIZE; */
++	memcpy(bcc_ptr, (char *) session_key, CIFS_SESSION_KEY_SIZE);
++	bcc_ptr += CIFS_SESSION_KEY_SIZE;
++
++	if (ses->capabilities & CAP_UNICODE) {
++		if ((long) bcc_ptr % 2) {	/* must be word aligned for Unicode */
++			*bcc_ptr = 0;
++			bcc_ptr++;
++		}
++		if(user == NULL)
++			bytes_returned = 0; /* skill null user */
++	        else
++			bytes_returned =
++			        cifs_strtoUCS((wchar_t *) bcc_ptr, user, 100,
++					nls_codepage);
++		bcc_ptr += 2 * bytes_returned;	/* convert num 16 bit words to bytes */
++		bcc_ptr += 2;	/* trailing null */
++		if (domain == NULL)
++			bytes_returned =
++			    cifs_strtoUCS((wchar_t *) bcc_ptr,
++					  "CIFS_LINUX_DOM", 32, nls_codepage);
++		else
++			bytes_returned =
++			    cifs_strtoUCS((wchar_t *) bcc_ptr, domain, 64,
++					  nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, "Linux version ",
++				  32, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, UTS_RELEASE, 32,
++				  nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, CIFS_NETWORK_OPSYS,
++				  64, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;
++	} else {
++		if(user != NULL) {                
++		    strncpy(bcc_ptr, user, 200);
++		    bcc_ptr += strnlen(user, 200);
++		}
++		*bcc_ptr = 0;
++		bcc_ptr++;
++		if (domain == NULL) {
++			strcpy(bcc_ptr, "CIFS_LINUX_DOM");
++			bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
++		} else {
++			strncpy(bcc_ptr, domain, 64);
++			bcc_ptr += strnlen(domain, 64);
++			*bcc_ptr = 0;
++			bcc_ptr++;
++		}
++		strcpy(bcc_ptr, "Linux version ");
++		bcc_ptr += strlen("Linux version ");
++		strcpy(bcc_ptr, UTS_RELEASE);
++		bcc_ptr += strlen(UTS_RELEASE) + 1;
++		strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
++		bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
++	}
++	BCC(smb_buffer) = (long) bcc_ptr - (long) pByteArea(smb_buffer);
++	smb_buffer->smb_buf_length += BCC(smb_buffer);
++	BCC(smb_buffer) = cpu_to_le16(BCC(smb_buffer));
++
++	rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
++			 &bytes_returned, 1);
++	if (rc) {
++/* rc = map_smb_to_linux_error(smb_buffer_response); now done in SendReceive */
++	} else if ((smb_buffer_response->WordCount == 3)
++		   || (smb_buffer_response->WordCount == 4)) {
++		pSMBr->resp.Action = le16_to_cpu(pSMBr->resp.Action);
++		if (pSMBr->resp.Action & GUEST_LOGIN)
++			cFYI(1, (" Guest login"));	/* do we want to mark SesInfo struct ? */
++		if (ses) {
++			ses->Suid = smb_buffer_response->Uid;	/* UID left in wire format (le) */
++			cFYI(1, ("UID = %d ", ses->Suid));
++         /* response can have either 3 or 4 word count - Samba sends 3 */
++			bcc_ptr = pByteArea(smb_buffer_response);	
++			if ((pSMBr->resp.hdr.WordCount == 3)
++			    || ((pSMBr->resp.hdr.WordCount == 4)
++				&& (pSMBr->resp.SecurityBlobLength <
++				    pSMBr->resp.ByteCount))) {
++				if (pSMBr->resp.hdr.WordCount == 4)
++					bcc_ptr +=
++					    pSMBr->resp.SecurityBlobLength;
++
++				if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
++					if ((long) (bcc_ptr) % 2) {
++						remaining_words =
++						    (BCC(smb_buffer_response)
++						     - 1) / 2;
++						bcc_ptr++;	/* Unicode strings must be word aligned */
++					} else {
++						remaining_words =
++						    BCC
++						    (smb_buffer_response) / 2;
++					}
++					len =
++					    UniStrnlen((wchar_t *) bcc_ptr,
++						       remaining_words - 1);
++/* We look for obvious messed up bcc or strings in response so we do not go off
++   the end since (at least) WIN2K and Windows XP have a major bug in not null
++   terminating last Unicode string in response  */
++					ses->serverOS = cifs_kcalloc(2 * (len + 1), GFP_KERNEL);
++					cifs_strfromUCS_le(ses->serverOS,
++							   (wchar_t *)bcc_ptr, len,nls_codepage);
++					bcc_ptr += 2 * (len + 1);
++					remaining_words -= len + 1;
++					ses->serverOS[2 * len] = 0;
++					ses->serverOS[1 + (2 * len)] = 0;
++					if (remaining_words > 0) {
++						len = UniStrnlen((wchar_t *)bcc_ptr,
++								 remaining_words
++								 - 1);
++						ses->serverNOS =cifs_kcalloc(2 * (len + 1),GFP_KERNEL);
++						cifs_strfromUCS_le(ses->serverNOS,
++								   (wchar_t *)bcc_ptr,len,nls_codepage);
++						bcc_ptr += 2 * (len + 1);
++						ses->serverNOS[2 * len] = 0;
++						ses->serverNOS[1 + (2 * len)] = 0;
++						remaining_words -= len + 1;
++						if (remaining_words > 0) {
++							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);	
++          /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
++							ses->serverDomain =
++							    cifs_kcalloc(2*(len+1),GFP_KERNEL);
++							cifs_strfromUCS_le(ses->serverDomain,
++							     (wchar_t *)bcc_ptr,len,nls_codepage);
++							bcc_ptr += 2 * (len + 1);
++							ses->serverDomain[2*len] = 0;
++							ses->serverDomain[1+(2*len)] = 0;
++						} /* else no more room so create dummy domain string */
++						else
++							ses->serverDomain =
++							    cifs_kcalloc(2,
++								    GFP_KERNEL);
++					} else {	/* no room so create dummy domain and NOS string */
++						ses->serverDomain =
++						    cifs_kcalloc(2, GFP_KERNEL);
++						ses->serverNOS =
++						    cifs_kcalloc(2, GFP_KERNEL);
++					}
++				} else {	/* ASCII */
++					len = strnlen(bcc_ptr, 1024);
++					if (((long) bcc_ptr + len) - (long)
++					    pByteArea(smb_buffer_response)
++					    <= BCC(smb_buffer_response)) {
++						ses->serverOS = cifs_kcalloc(len + 1,GFP_KERNEL);
++						strncpy(ses->serverOS,bcc_ptr, len);
++
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;	/* null terminate the string */
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverNOS = cifs_kcalloc(len + 1,GFP_KERNEL);
++						strncpy(ses->serverNOS, bcc_ptr, len);
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverDomain = cifs_kcalloc(len + 1,GFP_KERNEL);
++						strncpy(ses->serverDomain, bcc_ptr, len);
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++					} else
++						cFYI(1,
++						     ("Variable field of length %d extends beyond end of smb ",
++						      len));
++				}
++			} else {
++				cERROR(1,
++				       (" Security Blob Length extends beyond end of SMB"));
++			}
++		} else {
++			cERROR(1, ("No session structure passed in."));
++		}
++	} else {
++		cERROR(1,
++		       (" Invalid Word count %d: ",
++			smb_buffer_response->WordCount));
++		rc = -EIO;
++	}
++	
++	if (smb_buffer)
++		cifs_buf_release(smb_buffer);
++
++	return rc;
++}
++
++static int
++CIFSSpnegoSessSetup(unsigned int xid, struct cifsSesInfo *ses,
++		char *SecurityBlob,int SecurityBlobLength,
++		const struct nls_table *nls_codepage)
++{
++	struct smb_hdr *smb_buffer;
++	struct smb_hdr *smb_buffer_response;
++	SESSION_SETUP_ANDX *pSMB;
++	SESSION_SETUP_ANDX *pSMBr;
++	char *bcc_ptr;
++	char *user = ses->userName;
++	char *domain = ses->domainName;
++	int rc = 0;
++	int remaining_words = 0;
++	int bytes_returned = 0;
++	int len;
++
++	cFYI(1, ("In spnego sesssetup "));
++
++	smb_buffer = cifs_buf_get();
++	if (smb_buffer == 0) {
++		return -ENOMEM;
++	}
++	smb_buffer_response = smb_buffer;
++	pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
++
++	/* send SMBsessionSetup here */
++	header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
++			NULL /* no tCon exists yet */ , 12 /* wct */ );
++	pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
++	pSMB->req.AndXCommand = 0xFF;
++	pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
++	pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
++
++	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
++		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
++
++	pSMB->req.Capabilities =
++	    CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
++	    CAP_EXTENDED_SECURITY;
++	if (ses->capabilities & CAP_UNICODE) {
++		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
++		pSMB->req.Capabilities |= CAP_UNICODE;
++	}
++	if (ses->capabilities & CAP_STATUS32) {
++		smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
++		pSMB->req.Capabilities |= CAP_STATUS32;
++	}
++	if (ses->capabilities & CAP_DFS) {
++		smb_buffer->Flags2 |= SMBFLG2_DFS;
++		pSMB->req.Capabilities |= CAP_DFS;
++	}
++	pSMB->req.Capabilities = cpu_to_le32(pSMB->req.Capabilities);
++
++	pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
++	bcc_ptr = pByteArea(smb_buffer);
++	memcpy(bcc_ptr, SecurityBlob, SecurityBlobLength);
++	bcc_ptr += SecurityBlobLength;
++
++	if (ses->capabilities & CAP_UNICODE) {
++		if ((long) bcc_ptr % 2) {	/* must be word aligned for Unicode strings */
++			*bcc_ptr = 0;
++			bcc_ptr++;
++		}
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, user, 100, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;	/* convert num of 16 bit words to bytes */
++		bcc_ptr += 2;	/* trailing null */
++		if (domain == NULL)
++			bytes_returned =
++			    cifs_strtoUCS((wchar_t *) bcc_ptr,
++					  "CIFS_LINUX_DOM", 32, nls_codepage);
++		else
++			bytes_returned =
++			    cifs_strtoUCS((wchar_t *) bcc_ptr, domain, 64,
++					  nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, "Linux version ",
++				  32, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, UTS_RELEASE, 32,
++				  nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, CIFS_NETWORK_OPSYS,
++				  64, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;
++	} else {
++		strncpy(bcc_ptr, user, 200);
++		bcc_ptr += strnlen(user, 200);
++		*bcc_ptr = 0;
++		bcc_ptr++;
++		if (domain == NULL) {
++			strcpy(bcc_ptr, "CIFS_LINUX_DOM");
++			bcc_ptr += strlen("CIFS_LINUX_DOM") + 1;
++		} else {
++			strncpy(bcc_ptr, domain, 64);
++			bcc_ptr += strnlen(domain, 64);
++			*bcc_ptr = 0;
++			bcc_ptr++;
++		}
++		strcpy(bcc_ptr, "Linux version ");
++		bcc_ptr += strlen("Linux version ");
++		strcpy(bcc_ptr, UTS_RELEASE);
++		bcc_ptr += strlen(UTS_RELEASE) + 1;
++		strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
++		bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
++	}
++	BCC(smb_buffer) = (long) bcc_ptr - (long) pByteArea(smb_buffer);
++	smb_buffer->smb_buf_length += BCC(smb_buffer);
++	BCC(smb_buffer) = cpu_to_le16(BCC(smb_buffer));
++
++	rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
++			 &bytes_returned, 1);
++	if (rc) {
++/*    rc = map_smb_to_linux_error(smb_buffer_response);  *//* done in SendReceive now */
++	} else if ((smb_buffer_response->WordCount == 3)
++		   || (smb_buffer_response->WordCount == 4)) {
++		pSMBr->resp.Action = le16_to_cpu(pSMBr->resp.Action);
++		pSMBr->resp.SecurityBlobLength =
++		    le16_to_cpu(pSMBr->resp.SecurityBlobLength);
++		if (pSMBr->resp.Action & GUEST_LOGIN)
++			cFYI(1, (" Guest login"));	/* BB do we want to set anything in SesInfo struct ? */
++		if (ses) {
++			ses->Suid = smb_buffer_response->Uid;	/* UID left in wire format (le) */
++			cFYI(1, ("UID = %d ", ses->Suid));
++			bcc_ptr = pByteArea(smb_buffer_response);	/* response can have either 3 or 4 word count - Samba sends 3 */
++
++			/* BB Fix below to make endian neutral !! */
++
++			if ((pSMBr->resp.hdr.WordCount == 3)
++			    || ((pSMBr->resp.hdr.WordCount == 4)
++				&& (pSMBr->resp.SecurityBlobLength <
++				    pSMBr->resp.ByteCount))) {
++				if (pSMBr->resp.hdr.WordCount == 4) {
++					bcc_ptr +=
++					    pSMBr->resp.SecurityBlobLength;
++					cFYI(1,
++					     ("Security Blob Length %d ",
++					      pSMBr->resp.SecurityBlobLength));
++				}
++
++				if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
++					if ((long) (bcc_ptr) % 2) {
++						remaining_words =
++						    (BCC(smb_buffer_response)
++						     - 1) / 2;
++						bcc_ptr++;	/* Unicode strings must be word aligned */
++					} else {
++						remaining_words =
++						    BCC
++						    (smb_buffer_response) / 2;
++					}
++					len =
++					    UniStrnlen((wchar_t *) bcc_ptr,
++						       remaining_words - 1);
++/* We look for obvious messed up bcc or strings in response so we do not go off
++   the end since (at least) WIN2K and Windows XP have a major bug in not null
++   terminating last Unicode string in response  */
++					ses->serverOS =
++					    cifs_kcalloc(2 * (len + 1), GFP_KERNEL);
++					cifs_strfromUCS_le(ses->serverOS,
++							   (wchar_t *)
++							   bcc_ptr, len,
++							   nls_codepage);
++					bcc_ptr += 2 * (len + 1);
++					remaining_words -= len + 1;
++					ses->serverOS[2 * len] = 0;
++					ses->serverOS[1 + (2 * len)] = 0;
++					if (remaining_words > 0) {
++						len = UniStrnlen((wchar_t *)bcc_ptr,
++								 remaining_words
++								 - 1);
++						ses->serverNOS =
++						    cifs_kcalloc(2 * (len + 1),
++							    GFP_KERNEL);
++						cifs_strfromUCS_le(ses->serverNOS,
++								   (wchar_t *)bcc_ptr,
++								   len,
++								   nls_codepage);
++						bcc_ptr += 2 * (len + 1);
++						ses->serverNOS[2 * len] = 0;
++						ses->serverNOS[1 + (2 * len)] = 0;
++						remaining_words -= len + 1;
++						if (remaining_words > 0) {
++							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);	
++                            /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
++							ses->serverDomain = cifs_kcalloc(2*(len+1),GFP_KERNEL);
++							cifs_strfromUCS_le(ses->serverDomain,
++							     (wchar_t *)bcc_ptr, 
++                                 len,
++							     nls_codepage);
++							bcc_ptr += 2*(len+1);
++							ses->serverDomain[2*len] = 0;
++							ses->serverDomain[1+(2*len)] = 0;
++						} /* else no more room so create dummy domain string */
++						else
++							ses->serverDomain =
++							    cifs_kcalloc(2,GFP_KERNEL);
++					} else {	/* no room so create dummy domain and NOS string */
++						ses->serverDomain = cifs_kcalloc(2, GFP_KERNEL);
++						ses->serverNOS = cifs_kcalloc(2, GFP_KERNEL);
++					}
++				} else {	/* ASCII */
++
++					len = strnlen(bcc_ptr, 1024);
++					if (((long) bcc_ptr + len) - (long)
++					    pByteArea(smb_buffer_response)
++					    <= BCC(smb_buffer_response)) {
++						ses->serverOS = cifs_kcalloc(len + 1, GFP_KERNEL);
++						strncpy(ses->serverOS, bcc_ptr, len);
++
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;	/* null terminate the string */
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverNOS = cifs_kcalloc(len + 1,GFP_KERNEL);
++						strncpy(ses->serverNOS, bcc_ptr, len);
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverDomain = cifs_kcalloc(len + 1, GFP_KERNEL);
++						strncpy(ses->serverDomain, bcc_ptr, len);
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++					} else
++						cFYI(1,
++						     ("Variable field of length %d extends beyond end of smb ",
++						      len));
++				}
++			} else {
++				cERROR(1,
++				       (" Security Blob Length extends beyond end of SMB"));
++			}
++		} else {
++			cERROR(1, ("No session structure passed in."));
++		}
++	} else {
++		cERROR(1,
++		       (" Invalid Word count %d: ",
++			smb_buffer_response->WordCount));
++		rc = -EIO;
++	}
++
++	if (smb_buffer)
++		cifs_buf_release(smb_buffer);
++
++	return rc;
++}
++
++static int
++CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
++			      struct cifsSesInfo *ses, int * pNTLMv2_flag,
++			      const struct nls_table *nls_codepage)
++{
++	struct smb_hdr *smb_buffer;
++	struct smb_hdr *smb_buffer_response;
++	SESSION_SETUP_ANDX *pSMB;
++	SESSION_SETUP_ANDX *pSMBr;
++	char *bcc_ptr;
++	char *domain = ses->domainName;
++	int rc = 0;
++	int remaining_words = 0;
++	int bytes_returned = 0;
++	int len;
++	int SecurityBlobLength = sizeof (NEGOTIATE_MESSAGE);
++	PNEGOTIATE_MESSAGE SecurityBlob;
++	PCHALLENGE_MESSAGE SecurityBlob2;
++
++	cFYI(1, ("In NTLMSSP sesssetup (negotiate) "));
++	*pNTLMv2_flag = FALSE;
++	smb_buffer = cifs_buf_get();
++	if (smb_buffer == 0) {
++		return -ENOMEM;
++	}
++	smb_buffer_response = smb_buffer;
++	pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
++	pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
++
++	/* send SMBsessionSetup here */
++	header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
++			NULL /* no tCon exists yet */ , 12 /* wct */ );
++	pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
++	pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
++
++	pSMB->req.AndXCommand = 0xFF;
++	pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
++	pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
++
++	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
++		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
++
++	pSMB->req.Capabilities =
++	    CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
++	    CAP_EXTENDED_SECURITY;
++	if (ses->capabilities & CAP_UNICODE) {
++		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
++		pSMB->req.Capabilities |= CAP_UNICODE;
++	}
++	if (ses->capabilities & CAP_STATUS32) {
++		smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
++		pSMB->req.Capabilities |= CAP_STATUS32;
++	}
++	if (ses->capabilities & CAP_DFS) {
++		smb_buffer->Flags2 |= SMBFLG2_DFS;
++		pSMB->req.Capabilities |= CAP_DFS;
++	}
++	pSMB->req.Capabilities = cpu_to_le32(pSMB->req.Capabilities);
++
++	bcc_ptr = (char *) &pSMB->req.SecurityBlob;
++	SecurityBlob = (PNEGOTIATE_MESSAGE) bcc_ptr;
++	strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
++	SecurityBlob->MessageType = NtLmNegotiate;
++	SecurityBlob->NegotiateFlags =
++	    NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_NEGOTIATE_OEM |
++	    NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_NTLM | 0x80000000 |
++	    /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
++	if(sign_CIFS_PDUs)
++		SecurityBlob->NegotiateFlags |= NTLMSSP_NEGOTIATE_SIGN;
++	if(ntlmv2_support)
++		SecurityBlob->NegotiateFlags |= NTLMSSP_NEGOTIATE_NTLMV2;
++	/* setup pointers to domain name and workstation name */
++	bcc_ptr += SecurityBlobLength;
++
++	SecurityBlob->WorkstationName.Buffer = 0;
++	SecurityBlob->WorkstationName.Length = 0;
++	SecurityBlob->WorkstationName.MaximumLength = 0;
++
++	if (domain == NULL) {
++		SecurityBlob->DomainName.Buffer = 0;
++		SecurityBlob->DomainName.Length = 0;
++		SecurityBlob->DomainName.MaximumLength = 0;
++	} else {
++		SecurityBlob->NegotiateFlags |=
++		    NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
++		strncpy(bcc_ptr, domain, 63);
++		SecurityBlob->DomainName.Length = strnlen(domain, 64);
++		SecurityBlob->DomainName.MaximumLength =
++		    cpu_to_le16(SecurityBlob->DomainName.Length);
++		SecurityBlob->DomainName.Buffer =
++		    cpu_to_le32((long) &SecurityBlob->
++				DomainString -
++				(long) &SecurityBlob->Signature);
++		bcc_ptr += SecurityBlob->DomainName.Length;
++		SecurityBlobLength += SecurityBlob->DomainName.Length;
++		SecurityBlob->DomainName.Length =
++		    cpu_to_le16(SecurityBlob->DomainName.Length);
++	}
++	if (ses->capabilities & CAP_UNICODE) {
++		if ((long) bcc_ptr % 2) {
++			*bcc_ptr = 0;
++			bcc_ptr++;
++		}
++
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, "Linux version ",
++				  32, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, UTS_RELEASE, 32,
++				  nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;	/* null terminate Linux version */
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, CIFS_NETWORK_OPSYS,
++				  64, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		*(bcc_ptr + 1) = 0;
++		*(bcc_ptr + 2) = 0;
++		bcc_ptr += 2;	/* null terminate network opsys string */
++		*(bcc_ptr + 1) = 0;
++		*(bcc_ptr + 2) = 0;
++		bcc_ptr += 2;	/* null domain */
++	} else {		/* ASCII */
++		strcpy(bcc_ptr, "Linux version ");
++		bcc_ptr += strlen("Linux version ");
++		strcpy(bcc_ptr, UTS_RELEASE);
++		bcc_ptr += strlen(UTS_RELEASE) + 1;
++		strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
++		bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
++		bcc_ptr++;	/* empty domain field */
++		*bcc_ptr = 0;
++	}
++	SecurityBlob->NegotiateFlags =
++	    cpu_to_le32(SecurityBlob->NegotiateFlags);
++	pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
++	BCC(smb_buffer) = (long) bcc_ptr - (long) pByteArea(smb_buffer);
++	smb_buffer->smb_buf_length += BCC(smb_buffer);
++	BCC(smb_buffer) = cpu_to_le16(BCC(smb_buffer));
++
++	rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
++			 &bytes_returned, 1);
++
++	if (smb_buffer_response->Status.CifsError ==
++	    (NT_STATUS_MORE_PROCESSING_REQUIRED))
++		rc = 0;
++
++	if (rc) {
++/*    rc = map_smb_to_linux_error(smb_buffer_response);  *//* done in SendReceive now */
++	} else if ((smb_buffer_response->WordCount == 3)
++		   || (smb_buffer_response->WordCount == 4)) {
++		pSMBr->resp.Action = le16_to_cpu(pSMBr->resp.Action);
++		pSMBr->resp.SecurityBlobLength =
++		    le16_to_cpu(pSMBr->resp.SecurityBlobLength);
++		if (pSMBr->resp.Action & GUEST_LOGIN)
++			cFYI(1, (" Guest login"));	
++        /* Do we want to set anything in SesInfo struct when guest login? */
++
++		bcc_ptr = pByteArea(smb_buffer_response);	
++        /* response can have either 3 or 4 word count - Samba sends 3 */
++
++		SecurityBlob2 = (PCHALLENGE_MESSAGE) bcc_ptr;
++		if (SecurityBlob2->MessageType != NtLmChallenge) {
++			cFYI(1,
++			     ("Unexpected NTLMSSP message type received %d",
++			      SecurityBlob2->MessageType));
++		} else if (ses) {
++			ses->Suid = smb_buffer_response->Uid; /* UID left in le format */ 
++			cFYI(1, ("UID = %d ", ses->Suid));
++			if ((pSMBr->resp.hdr.WordCount == 3)
++			    || ((pSMBr->resp.hdr.WordCount == 4)
++				&& (pSMBr->resp.SecurityBlobLength <
++				    pSMBr->resp.ByteCount))) {
++				if (pSMBr->resp.hdr.WordCount == 4) {
++					bcc_ptr +=
++					    pSMBr->resp.SecurityBlobLength;
++					cFYI(1,
++					     ("Security Blob Length %d ",
++					      pSMBr->resp.SecurityBlobLength));
++				}
++
++				cFYI(1, ("NTLMSSP Challenge rcvd "));
++
++				memcpy(ses->server->cryptKey,
++				       SecurityBlob2->Challenge,
++				       CIFS_CRYPTO_KEY_SIZE);
++				if(SecurityBlob2->NegotiateFlags & NTLMSSP_NEGOTIATE_NTLMV2)
++					*pNTLMv2_flag = TRUE;
++
++				if((SecurityBlob2->NegotiateFlags & 
++					NTLMSSP_NEGOTIATE_ALWAYS_SIGN) 
++					|| (sign_CIFS_PDUs > 1))
++						ses->server->secMode |= 
++							SECMODE_SIGN_REQUIRED;	
++				if ((SecurityBlob2->NegotiateFlags & 
++					NTLMSSP_NEGOTIATE_SIGN) && (sign_CIFS_PDUs))
++						ses->server->secMode |= 
++							SECMODE_SIGN_ENABLED;
++
++				if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
++					if ((long) (bcc_ptr) % 2) {
++						remaining_words =
++						    (BCC(smb_buffer_response)
++						     - 1) / 2;
++						bcc_ptr++;	/* Unicode strings must be word aligned */
++					} else {
++						remaining_words =
++						    BCC
++						    (smb_buffer_response) / 2;
++					}
++					len =
++					    UniStrnlen((wchar_t *) bcc_ptr,
++						       remaining_words - 1);
++/* We look for obvious messed up bcc or strings in response so we do not go off
++   the end since (at least) WIN2K and Windows XP have a major bug in not null
++   terminating last Unicode string in response  */
++					ses->serverOS =
++					    cifs_kcalloc(2 * (len + 1), GFP_KERNEL);
++					cifs_strfromUCS_le(ses->serverOS,
++							   (wchar_t *)
++							   bcc_ptr, len,
++							   nls_codepage);
++					bcc_ptr += 2 * (len + 1);
++					remaining_words -= len + 1;
++					ses->serverOS[2 * len] = 0;
++					ses->serverOS[1 + (2 * len)] = 0;
++					if (remaining_words > 0) {
++						len = UniStrnlen((wchar_t *)
++								 bcc_ptr,
++								 remaining_words
++								 - 1);
++						ses->serverNOS =
++						    cifs_kcalloc(2 * (len + 1),
++							    GFP_KERNEL);
++						cifs_strfromUCS_le(ses->
++								   serverNOS,
++								   (wchar_t *)
++								   bcc_ptr,
++								   len,
++								   nls_codepage);
++						bcc_ptr += 2 * (len + 1);
++						ses->serverNOS[2 * len] = 0;
++						ses->serverNOS[1 +
++							       (2 * len)] = 0;
++						remaining_words -= len + 1;
++						if (remaining_words > 0) {
++							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);	
++           /* last string is not always null terminated (for e.g. for Windows XP & 2000) */
++							ses->serverDomain =
++							    cifs_kcalloc(2 *
++								    (len +
++								     1),
++								    GFP_KERNEL);
++							cifs_strfromUCS_le
++							    (ses->
++							     serverDomain,
++							     (wchar_t *)
++							     bcc_ptr, len,
++							     nls_codepage);
++							bcc_ptr +=
++							    2 * (len + 1);
++							ses->
++							    serverDomain[2
++									 * len]
++							    = 0;
++							ses->
++							    serverDomain[1
++									 +
++									 (2
++									  *
++									  len)]
++							    = 0;
++						} /* else no more room so create dummy domain string */
++						else
++							ses->serverDomain =
++							    cifs_kcalloc(2,
++								    GFP_KERNEL);
++					} else {	/* no room so create dummy domain and NOS string */
++						ses->serverDomain =
++						    cifs_kcalloc(2, GFP_KERNEL);
++						ses->serverNOS =
++						    cifs_kcalloc(2, GFP_KERNEL);
++					}
++				} else {	/* ASCII */
++					len = strnlen(bcc_ptr, 1024);
++					if (((long) bcc_ptr + len) - (long)
++					    pByteArea(smb_buffer_response)
++					    <= BCC(smb_buffer_response)) {
++						ses->serverOS =
++						    cifs_kcalloc(len + 1,
++							    GFP_KERNEL);
++						strncpy(ses->serverOS,
++							bcc_ptr, len);
++
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;	/* null terminate string */
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverNOS =
++						    cifs_kcalloc(len + 1,
++							    GFP_KERNEL);
++						strncpy(ses->serverNOS, bcc_ptr, len);
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverDomain =
++						    cifs_kcalloc(len + 1,
++							    GFP_KERNEL);
++						strncpy(ses->serverDomain, bcc_ptr, len);	
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++					} else
++						cFYI(1,
++						     ("Variable field of length %d extends beyond end of smb ",
++						      len));
++				}
++			} else {
++				cERROR(1,
++				       (" Security Blob Length extends beyond end of SMB"));
++			}
++		} else {
++			cERROR(1, ("No session structure passed in."));
++		}
++	} else {
++		cERROR(1,
++		       (" Invalid Word count %d: ",
++			smb_buffer_response->WordCount));
++		rc = -EIO;
++	}
++
++	if (smb_buffer)
++		cifs_buf_release(smb_buffer);
++
++	return rc;
++}
++
++static int
++CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
++		char *ntlm_session_key, int ntlmv2_flag,
++		const struct nls_table *nls_codepage)
++{
++	struct smb_hdr *smb_buffer;
++	struct smb_hdr *smb_buffer_response;
++	SESSION_SETUP_ANDX *pSMB;
++	SESSION_SETUP_ANDX *pSMBr;
++	char *bcc_ptr;
++	char *user = ses->userName;
++	char *domain = ses->domainName;
++	int rc = 0;
++	int remaining_words = 0;
++	int bytes_returned = 0;
++	int len;
++	int SecurityBlobLength = sizeof (AUTHENTICATE_MESSAGE);
++	PAUTHENTICATE_MESSAGE SecurityBlob;
++
++	cFYI(1, ("In NTLMSSPSessSetup (Authenticate)"));
++
++	smb_buffer = cifs_buf_get();
++	if (smb_buffer == 0) {
++		return -ENOMEM;
++	}
++	smb_buffer_response = smb_buffer;
++	pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
++	pSMBr = (SESSION_SETUP_ANDX *) smb_buffer_response;
++
++	/* send SMBsessionSetup here */
++	header_assemble(smb_buffer, SMB_COM_SESSION_SETUP_ANDX,
++			NULL /* no tCon exists yet */ , 12 /* wct */ );
++	pSMB->req.hdr.Flags |= (SMBFLG_CASELESS | SMBFLG_CANONICAL_PATH_FORMAT);
++	pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
++	pSMB->req.AndXCommand = 0xFF;
++	pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
++	pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
++
++	pSMB->req.hdr.Uid = ses->Suid;
++
++	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
++		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
++
++	pSMB->req.Capabilities =
++	    CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
++	    CAP_EXTENDED_SECURITY;
++	if (ses->capabilities & CAP_UNICODE) {
++		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
++		pSMB->req.Capabilities |= CAP_UNICODE;
++	}
++	if (ses->capabilities & CAP_STATUS32) {
++		smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
++		pSMB->req.Capabilities |= CAP_STATUS32;
++	}
++	if (ses->capabilities & CAP_DFS) {
++		smb_buffer->Flags2 |= SMBFLG2_DFS;
++		pSMB->req.Capabilities |= CAP_DFS;
++	}
++	pSMB->req.Capabilities = cpu_to_le32(pSMB->req.Capabilities);
++
++	bcc_ptr = (char *) &pSMB->req.SecurityBlob;
++	SecurityBlob = (PAUTHENTICATE_MESSAGE) bcc_ptr;
++	strncpy(SecurityBlob->Signature, NTLMSSP_SIGNATURE, 8);
++	SecurityBlob->MessageType = NtLmAuthenticate;
++	bcc_ptr += SecurityBlobLength;
++	SecurityBlob->NegotiateFlags =
++	    NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
++	    NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
++	    0x80000000 | NTLMSSP_NEGOTIATE_128;
++	if(sign_CIFS_PDUs)
++		SecurityBlob->NegotiateFlags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
++	if(ntlmv2_flag)
++		SecurityBlob->NegotiateFlags |= NTLMSSP_NEGOTIATE_NTLMV2;
++
++/* setup pointers to domain name and workstation name */
++
++	SecurityBlob->WorkstationName.Buffer = 0;
++	SecurityBlob->WorkstationName.Length = 0;
++	SecurityBlob->WorkstationName.MaximumLength = 0;
++	SecurityBlob->SessionKey.Length = 0;
++	SecurityBlob->SessionKey.MaximumLength = 0;
++	SecurityBlob->SessionKey.Buffer = 0;
++
++	SecurityBlob->LmChallengeResponse.Length = 0;
++	SecurityBlob->LmChallengeResponse.MaximumLength = 0;
++	SecurityBlob->LmChallengeResponse.Buffer = 0;
++
++	SecurityBlob->NtChallengeResponse.Length =
++	    cpu_to_le16(CIFS_SESSION_KEY_SIZE);
++	SecurityBlob->NtChallengeResponse.MaximumLength =
++	    cpu_to_le16(CIFS_SESSION_KEY_SIZE);
++	memcpy(bcc_ptr, ntlm_session_key, CIFS_SESSION_KEY_SIZE);
++	SecurityBlob->NtChallengeResponse.Buffer =
++	    cpu_to_le32(SecurityBlobLength);
++	SecurityBlobLength += CIFS_SESSION_KEY_SIZE;
++	bcc_ptr += CIFS_SESSION_KEY_SIZE;
++
++	if (ses->capabilities & CAP_UNICODE) {
++		if (domain == NULL) {
++			SecurityBlob->DomainName.Buffer = 0;
++			SecurityBlob->DomainName.Length = 0;
++			SecurityBlob->DomainName.MaximumLength = 0;
++		} else {
++			SecurityBlob->DomainName.Length =
++			    cifs_strtoUCS((wchar_t *) bcc_ptr, domain, 64,
++					  nls_codepage);
++			SecurityBlob->DomainName.Length *= 2;
++			SecurityBlob->DomainName.MaximumLength =
++			    cpu_to_le16(SecurityBlob->DomainName.Length);
++			SecurityBlob->DomainName.Buffer =
++			    cpu_to_le32(SecurityBlobLength);
++			bcc_ptr += SecurityBlob->DomainName.Length;
++			SecurityBlobLength += SecurityBlob->DomainName.Length;
++			SecurityBlob->DomainName.Length =
++			    cpu_to_le16(SecurityBlob->DomainName.Length);
++		}
++		if (user == NULL) {
++			SecurityBlob->UserName.Buffer = 0;
++			SecurityBlob->UserName.Length = 0;
++			SecurityBlob->UserName.MaximumLength = 0;
++		} else {
++			SecurityBlob->UserName.Length =
++			    cifs_strtoUCS((wchar_t *) bcc_ptr, user, 64,
++					  nls_codepage);
++			SecurityBlob->UserName.Length *= 2;
++			SecurityBlob->UserName.MaximumLength =
++			    cpu_to_le16(SecurityBlob->UserName.Length);
++			SecurityBlob->UserName.Buffer =
++			    cpu_to_le32(SecurityBlobLength);
++			bcc_ptr += SecurityBlob->UserName.Length;
++			SecurityBlobLength += SecurityBlob->UserName.Length;
++			SecurityBlob->UserName.Length =
++			    cpu_to_le16(SecurityBlob->UserName.Length);
++		}
++
++		/* SecurityBlob->WorkstationName.Length = cifs_strtoUCS((wchar_t *) bcc_ptr, "AMACHINE",64, nls_codepage);
++		   SecurityBlob->WorkstationName.Length *= 2;
++		   SecurityBlob->WorkstationName.MaximumLength = cpu_to_le16(SecurityBlob->WorkstationName.Length);
++		   SecurityBlob->WorkstationName.Buffer = cpu_to_le32(SecurityBlobLength);
++		   bcc_ptr += SecurityBlob->WorkstationName.Length;
++		   SecurityBlobLength += SecurityBlob->WorkstationName.Length;
++		   SecurityBlob->WorkstationName.Length = cpu_to_le16(SecurityBlob->WorkstationName.Length);  */
++
++		if ((long) bcc_ptr % 2) {
++			*bcc_ptr = 0;
++			bcc_ptr++;
++		}
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, "Linux version ",
++				  32, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, UTS_RELEASE, 32,
++				  nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		bcc_ptr += 2;	/* null term version string */
++		bytes_returned =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, CIFS_NETWORK_OPSYS,
++				  64, nls_codepage);
++		bcc_ptr += 2 * bytes_returned;
++		*(bcc_ptr + 1) = 0;
++		*(bcc_ptr + 2) = 0;
++		bcc_ptr += 2;	/* null terminate network opsys string */
++		*(bcc_ptr + 1) = 0;
++		*(bcc_ptr + 2) = 0;
++		bcc_ptr += 2;	/* null domain */
++	} else {		/* ASCII */
++		if (domain == NULL) {
++			SecurityBlob->DomainName.Buffer = 0;
++			SecurityBlob->DomainName.Length = 0;
++			SecurityBlob->DomainName.MaximumLength = 0;
++		} else {
++			SecurityBlob->NegotiateFlags |=
++			    NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED;
++			strncpy(bcc_ptr, domain, 63);
++			SecurityBlob->DomainName.Length = strnlen(domain, 64);
++			SecurityBlob->DomainName.MaximumLength =
++			    cpu_to_le16(SecurityBlob->DomainName.Length);
++			SecurityBlob->DomainName.Buffer =
++			    cpu_to_le32(SecurityBlobLength);
++			bcc_ptr += SecurityBlob->DomainName.Length;
++			SecurityBlobLength += SecurityBlob->DomainName.Length;
++			SecurityBlob->DomainName.Length =
++			    cpu_to_le16(SecurityBlob->DomainName.Length);
++		}
++		if (user == NULL) {
++			SecurityBlob->UserName.Buffer = 0;
++			SecurityBlob->UserName.Length = 0;
++			SecurityBlob->UserName.MaximumLength = 0;
++		} else {
++			strncpy(bcc_ptr, user, 63);
++			SecurityBlob->UserName.Length = strnlen(user, 64);
++			SecurityBlob->UserName.MaximumLength =
++			    cpu_to_le16(SecurityBlob->UserName.Length);
++			SecurityBlob->UserName.Buffer =
++			    cpu_to_le32(SecurityBlobLength);
++			bcc_ptr += SecurityBlob->UserName.Length;
++			SecurityBlobLength += SecurityBlob->UserName.Length;
++			SecurityBlob->UserName.Length =
++			    cpu_to_le16(SecurityBlob->UserName.Length);
++		}
++		/* BB fill in our workstation name if known BB */
++
++		strcpy(bcc_ptr, "Linux version ");
++		bcc_ptr += strlen("Linux version ");
++		strcpy(bcc_ptr, UTS_RELEASE);
++		bcc_ptr += strlen(UTS_RELEASE) + 1;
++		strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
++		bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
++		bcc_ptr++;	/* null domain */
++		*bcc_ptr = 0;
++	}
++	SecurityBlob->NegotiateFlags =
++	    cpu_to_le32(SecurityBlob->NegotiateFlags);
++	pSMB->req.SecurityBlobLength = cpu_to_le16(SecurityBlobLength);
++	BCC(smb_buffer) = (long) bcc_ptr - (long) pByteArea(smb_buffer);
++	smb_buffer->smb_buf_length += BCC(smb_buffer);
++	BCC(smb_buffer) = cpu_to_le16(BCC(smb_buffer));
++
++	rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response,
++			 &bytes_returned, 1);
++	if (rc) {
++/*    rc = map_smb_to_linux_error(smb_buffer_response);  *//* done in SendReceive now */
++	} else if ((smb_buffer_response->WordCount == 3)
++		   || (smb_buffer_response->WordCount == 4)) {
++		pSMBr->resp.Action = le16_to_cpu(pSMBr->resp.Action);
++		pSMBr->resp.SecurityBlobLength =
++		    le16_to_cpu(pSMBr->resp.SecurityBlobLength);
++		if (pSMBr->resp.Action & GUEST_LOGIN)
++			cFYI(1, (" Guest login"));	/* BB do we want to set anything in SesInfo struct ? */
++/*        if(SecurityBlob2->MessageType != NtLm??){                               
++                 cFYI("Unexpected message type on auth response is %d ")); 
++        } */
++		if (ses) {
++			cFYI(1,
++			     ("Does UID on challenge %d match auth response UID %d ",
++			      ses->Suid, smb_buffer_response->Uid));
++			ses->Suid = smb_buffer_response->Uid; /* UID left in wire format */
++			bcc_ptr = pByteArea(smb_buffer_response);	
++            /* response can have either 3 or 4 word count - Samba sends 3 */
++			if ((pSMBr->resp.hdr.WordCount == 3)
++			    || ((pSMBr->resp.hdr.WordCount == 4)
++				&& (pSMBr->resp.SecurityBlobLength <
++				    pSMBr->resp.ByteCount))) {
++				if (pSMBr->resp.hdr.WordCount == 4) {
++					bcc_ptr +=
++					    pSMBr->resp.SecurityBlobLength;
++					cFYI(1,
++					     ("Security Blob Length %d ",
++					      pSMBr->resp.SecurityBlobLength));
++				}
++
++				cFYI(1,
++				     ("NTLMSSP response to Authenticate "));
++
++				if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
++					if ((long) (bcc_ptr) % 2) {
++						remaining_words =
++						    (BCC(smb_buffer_response)
++						     - 1) / 2;
++						bcc_ptr++;	/* Unicode strings must be word aligned */
++					} else {
++						remaining_words = BCC(smb_buffer_response) / 2;
++					}
++					len =
++					    UniStrnlen((wchar_t *) bcc_ptr,remaining_words - 1);
++/* We look for obvious messed up bcc or strings in response so we do not go off
++  the end since (at least) WIN2K and Windows XP have a major bug in not null
++  terminating last Unicode string in response  */
++					ses->serverOS =
++					    cifs_kcalloc(2 * (len + 1), GFP_KERNEL);
++					cifs_strfromUCS_le(ses->serverOS,
++							   (wchar_t *)
++							   bcc_ptr, len,
++							   nls_codepage);
++					bcc_ptr += 2 * (len + 1);
++					remaining_words -= len + 1;
++					ses->serverOS[2 * len] = 0;
++					ses->serverOS[1 + (2 * len)] = 0;
++					if (remaining_words > 0) {
++						len = UniStrnlen((wchar_t *)
++								 bcc_ptr,
++								 remaining_words
++								 - 1);
++						ses->serverNOS =
++						    cifs_kcalloc(2 * (len + 1),
++							    GFP_KERNEL);
++						cifs_strfromUCS_le(ses->
++								   serverNOS,
++								   (wchar_t *)
++								   bcc_ptr,
++								   len,
++								   nls_codepage);
++						bcc_ptr += 2 * (len + 1);
++						ses->serverNOS[2 * len] = 0;
++						ses->serverNOS[1+(2*len)] = 0;
++						remaining_words -= len + 1;
++						if (remaining_words > 0) {
++							len = UniStrnlen((wchar_t *) bcc_ptr, remaining_words);	
++     /* last string not always null terminated (e.g. for Windows XP & 2000) */
++							ses->serverDomain =
++							    cifs_kcalloc(2 *
++								    (len +
++								     1),
++								    GFP_KERNEL);
++							cifs_strfromUCS_le
++							    (ses->
++							     serverDomain,
++							     (wchar_t *)
++							     bcc_ptr, len,
++							     nls_codepage);
++							bcc_ptr +=
++							    2 * (len + 1);
++							ses->
++							    serverDomain[2
++									 * len]
++							    = 0;
++							ses->
++							    serverDomain[1
++									 +
++									 (2
++									  *
++									  len)]
++							    = 0;
++						} /* else no more room so create dummy domain string */
++						else
++							ses->serverDomain = cifs_kcalloc(2,GFP_KERNEL);
++					} else {  /* no room so create dummy domain and NOS string */
++						ses->serverDomain = cifs_kcalloc(2, GFP_KERNEL);
++						ses->serverNOS = cifs_kcalloc(2, GFP_KERNEL);
++					}
++				} else {	/* ASCII */
++					len = strnlen(bcc_ptr, 1024);
++					if (((long) bcc_ptr + len) - 
++                        (long) pByteArea(smb_buffer_response) 
++                            <= BCC(smb_buffer_response)) {
++						ses->serverOS = cifs_kcalloc(len + 1,GFP_KERNEL);
++						strncpy(ses->serverOS,bcc_ptr, len);
++
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;	/* null terminate the string */
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverNOS = cifs_kcalloc(len+1,GFP_KERNEL);
++						strncpy(ses->serverNOS, bcc_ptr, len);	
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++
++						len = strnlen(bcc_ptr, 1024);
++						ses->serverDomain = cifs_kcalloc(len+1,GFP_KERNEL);
++						strncpy(ses->serverDomain, bcc_ptr, len);
++						bcc_ptr += len;
++						bcc_ptr[0] = 0;
++						bcc_ptr++;
++					} else
++						cFYI(1,
++						     ("Variable field of length %d extends beyond end of smb ",
++						      len));
++				}
++			} else {
++				cERROR(1,
++				       (" Security Blob Length extends beyond end of SMB"));
++			}
++		} else {
++			cERROR(1, ("No session structure passed in."));
++		}
++	} else {
++		cERROR(1,
++		       (" Invalid Word count %d: ",
++			smb_buffer_response->WordCount));
++		rc = -EIO;
++	}
++
++	if (smb_buffer)
++		cifs_buf_release(smb_buffer);
++
++	return rc;
++}
++
++int
++CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
++	 const char *tree, struct cifsTconInfo *tcon,
++	 const struct nls_table *nls_codepage)
++{
++	struct smb_hdr *smb_buffer;
++	struct smb_hdr *smb_buffer_response;
++	TCONX_REQ *pSMB;
++	TCONX_RSP *pSMBr;
++	char *bcc_ptr;
++	int rc = 0;
++	int length;
++
++	if (ses == NULL)
++		return -EIO;
++
++	smb_buffer = cifs_buf_get();
++	if (smb_buffer == 0) {
++		return -ENOMEM;
++	}
++	smb_buffer_response = smb_buffer;
++
++	header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
++			NULL /*no tid */ , 4 /*wct */ );
++	smb_buffer->Uid = ses->Suid;
++	pSMB = (TCONX_REQ *) smb_buffer;
++	pSMBr = (TCONX_RSP *) smb_buffer_response;
++
++	pSMB->AndXCommand = 0xFF;
++	pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
++	pSMB->PasswordLength = cpu_to_le16(1);	/* minimum */
++	bcc_ptr = &(pSMB->Password[0]);
++	bcc_ptr++;		/* skip password */
++
++	if(ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
++		smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
++
++	if (ses->capabilities & CAP_STATUS32) {
++		smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
++	}
++	if (ses->capabilities & CAP_DFS) {
++		smb_buffer->Flags2 |= SMBFLG2_DFS;
++	}
++	if (ses->capabilities & CAP_UNICODE) {
++		smb_buffer->Flags2 |= SMBFLG2_UNICODE;
++		length =
++		    cifs_strtoUCS((wchar_t *) bcc_ptr, tree, 100, nls_codepage);
++		bcc_ptr += 2 * length;	/* convert num of 16 bit words to bytes */
++		bcc_ptr += 2;	/* skip trailing null */
++	} else {		/* ASCII */
++
++		strcpy(bcc_ptr, tree);
++		bcc_ptr += strlen(tree) + 1;
++	}
++	strcpy(bcc_ptr, "?????");
++	bcc_ptr += strlen("?????");
++	bcc_ptr += 1;
++	BCC(smb_buffer) = (long) bcc_ptr - (long) pByteArea(smb_buffer);
++	smb_buffer->smb_buf_length += BCC(smb_buffer);
++	BCC(smb_buffer) = cpu_to_le16(BCC(smb_buffer));
++
++	rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length, 0);
++
++	/* if (rc) rc = map_smb_to_linux_error(smb_buffer_response); */
++	/* above now done in SendReceive */
++	if ((rc == 0) && (tcon != NULL)) {
++        tcon->tidStatus = CifsGood;
++		tcon->tid = smb_buffer_response->Tid;
++		bcc_ptr = pByteArea(smb_buffer_response);
++		length = strnlen(bcc_ptr, BCC(smb_buffer_response) - 2);
++        /* skip service field (NB: this field is always ASCII) */
++		bcc_ptr += length + 1;	
++		strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
++		if (smb_buffer->Flags2 & SMBFLG2_UNICODE) {
++			length = UniStrnlen((wchar_t *) bcc_ptr, 512);
++			if (((long) bcc_ptr + (2 * length)) -
++			    (long) pByteArea(smb_buffer_response) <=
++			    BCC(smb_buffer_response)) {
++				if(tcon->nativeFileSystem)
++					kfree(tcon->nativeFileSystem);
++				tcon->nativeFileSystem =
++				    cifs_kcalloc(length + 2, GFP_KERNEL);
++				cifs_strfromUCS_le(tcon->nativeFileSystem,
++						   (wchar_t *) bcc_ptr,
++						   length, nls_codepage);
++				bcc_ptr += 2 * length;
++				bcc_ptr[0] = 0;	/* null terminate the string */
++				bcc_ptr[1] = 0;
++				bcc_ptr += 2;
++			}
++			/* else do not bother copying these informational fields */
++		} else {
++			length = strnlen(bcc_ptr, 1024);
++			if (((long) bcc_ptr + length) -
++			    (long) pByteArea(smb_buffer_response) <=
++			    BCC(smb_buffer_response)) {
++				if(tcon->nativeFileSystem)
++					kfree(tcon->nativeFileSystem);
++				tcon->nativeFileSystem =
++				    cifs_kcalloc(length + 1, GFP_KERNEL);
++				strncpy(tcon->nativeFileSystem, bcc_ptr,
++					length);
++			}
++			/* else do not bother copying these informational fields */
++		}
++		tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
++		cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
++	} else if ((rc == 0) && tcon == NULL) {
++        /* all we need to save for IPC$ connection */
++		ses->ipc_tid = smb_buffer_response->Tid;
++	}
++
++	if (smb_buffer)
++		cifs_buf_release(smb_buffer);
++	return rc;
++}
++
++int
++cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
++{
++	int rc = 0;
++	int xid;
++	struct cifsSesInfo *ses = NULL;
++	struct task_struct *cifsd_task;
++
++	xid = GetXid();
++
++	if (cifs_sb->tcon) {
++		ses = cifs_sb->tcon->ses; /* save ptr to ses before delete tcon!*/
++		rc = CIFSSMBTDis(xid, cifs_sb->tcon);
++		if (rc == -EBUSY) {
++			FreeXid(xid);
++			return 0;
++		}
++		tconInfoFree(cifs_sb->tcon);
++		if ((ses) && (ses->server)) {
++			/* save off task so we do not refer to ses later */
++			cifsd_task = ses->server->tsk;
++			cFYI(1, ("About to do SMBLogoff "));
++			rc = CIFSSMBLogoff(xid, ses);
++			if (rc == -EBUSY) {
++				FreeXid(xid);
++				return 0;
++			} else if (rc == -ESHUTDOWN) {
++				cFYI(1,("Waking up socket by sending it signal"));
++				send_sig(SIGKILL,cifsd_task,1);
++				rc = 0;
++			} /* else - we have an smb session
++				left on this socket do not kill cifsd */
++		} else
++			cFYI(1, ("No session or bad tcon"));
++	}
++	
++	cifs_sb->tcon = NULL;
++	if (ses) {
++		set_current_state(TASK_INTERRUPTIBLE);
++		schedule_timeout(HZ / 2);
++	}
++	if (ses)
++		sesInfoFree(ses);
++
++	FreeXid(xid);
++	return rc;		/* BB check if we should always return zero here */
++} 
++
++int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
++					   struct nls_table * nls_info)
++{
++	int rc = 0;
++	char ntlm_session_key[CIFS_SESSION_KEY_SIZE];
++	int ntlmv2_flag = FALSE;
++
++	/* what if server changes its buffer size after dropping the session? */
++	if(pSesInfo->server->maxBuf == 0) /* no need to send on reconnect */ {
++		rc = CIFSSMBNegotiate(xid, pSesInfo);
++		if(rc == -EAGAIN) /* retry only once on 1st time connection */ {
++			rc = CIFSSMBNegotiate(xid, pSesInfo);
++			if(rc == -EAGAIN) 
++				rc = -EHOSTDOWN;
++		}
++		if(rc == 0) {
++			spin_lock(&GlobalMid_Lock);
++			if(pSesInfo->server->tcpStatus != CifsExiting)
++				pSesInfo->server->tcpStatus = CifsGood;
++			else
++				rc = -EHOSTDOWN;
++			spin_unlock(&GlobalMid_Lock);
++
++		}
++	}
++	if (!rc) {
++		pSesInfo->capabilities = pSesInfo->server->capabilities;
++		if(linuxExtEnabled == 0)
++			pSesInfo->capabilities &= (~CAP_UNIX);
++		pSesInfo->sequence_number = 0;
++		cFYI(1,("Security Mode: 0x%x Capabilities: 0x%x Time Zone: %d",
++			pSesInfo->server->secMode,
++			pSesInfo->server->capabilities,
++			pSesInfo->server->timeZone));
++		if (extended_security
++				&& (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
++				&& (pSesInfo->server->secType == NTLMSSP)) {
++			cFYI(1, ("New style sesssetup "));
++			rc = CIFSSpnegoSessSetup(xid, pSesInfo,
++				NULL /* security blob */, 
++				0 /* blob length */,
++				nls_info);
++		} else if (extended_security
++			   && (pSesInfo->capabilities & CAP_EXTENDED_SECURITY)
++			   && (pSesInfo->server->secType == RawNTLMSSP)) {
++			cFYI(1, ("NTLMSSP sesssetup "));
++			rc = CIFSNTLMSSPNegotiateSessSetup(xid,
++						pSesInfo,
++						&ntlmv2_flag,
++						nls_info);
++			if (!rc) {
++				if(ntlmv2_flag) {
++					char * v2_response;
++					cFYI(1,("Can use more secure NTLM version 2 password hash"));
++					CalcNTLMv2_partial_mac_key(pSesInfo, 
++						nls_info);
++					v2_response = kmalloc(16 + 64 /* blob */, GFP_KERNEL);
++					if(v2_response) {
++						CalcNTLMv2_response(pSesInfo,v2_response);
++/*						cifs_calculate_ntlmv2_mac_key(pSesInfo->mac_signing_key, response, ntlm_session_key, */
++						kfree(v2_response);
++					/* BB Put dummy sig in SessSetup PDU? */
++					} else
++						rc = -ENOMEM;
++
++				} else {
++					SMBNTencrypt(pSesInfo->password,
++						pSesInfo->server->cryptKey,
++						ntlm_session_key);
++
++					cifs_calculate_mac_key(pSesInfo->mac_signing_key,
++						ntlm_session_key,
++						pSesInfo->password);
++				}
++			/* for better security the weaker lanman hash not sent
++			   in AuthSessSetup so we no longer calculate it */
++
++				rc = CIFSNTLMSSPAuthSessSetup(xid,
++					pSesInfo,
++					ntlm_session_key,
++					ntlmv2_flag,
++					nls_info);
++			}
++		} else { /* old style NTLM 0.12 session setup */
++			SMBNTencrypt(pSesInfo->password,
++				pSesInfo->server->cryptKey,
++				ntlm_session_key);
++
++			cifs_calculate_mac_key(pSesInfo->mac_signing_key, 
++				ntlm_session_key, pSesInfo->password);
++			rc = CIFSSessSetup(xid, pSesInfo,
++				ntlm_session_key, nls_info);
++		}
++		if (rc) {
++			cERROR(1,("Send error in SessSetup = %d",rc));
++		} else {
++			cFYI(1,("CIFS Session Established successfully"));
++			pSesInfo->status = CifsGood;
++		}
++	}
++	return rc;
++}
++
+diff -urN linux-2.4.29.old/fs/cifs/dir.c linux-2.4.29/fs/cifs/dir.c
+--- linux-2.4.29.old/fs/cifs/dir.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/dir.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,425 @@
++/*
++ *   fs/cifs/dir.c
++ *
++ *   vfs operations that deal with dentries
++ * 
++ *   Copyright (C) International Business Machines  Corp., 2002,2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++#include <linux/fs.h>
++#include <linux/stat.h>
++#include <linux/slab.h>
++#include "cifsfs.h"
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_debug.h"
++#include "cifs_fs_sb.h"
++
++void
++renew_parental_timestamps(struct dentry *direntry)
++{
++	/* BB check if there is a way to get the kernel to do this or if we really need this */
++	do {
++		direntry->d_time = jiffies;
++		direntry = direntry->d_parent;
++	} while (!IS_ROOT(direntry));	
++}
++
++/* Note: caller must free return buffer */
++char *
++build_path_from_dentry(struct dentry *direntry)
++{
++	struct dentry *temp;
++	int namelen = 0;
++	char *full_path;
++
++	if(direntry == NULL)
++		return NULL;  /* not much we can do if dentry is freed and
++		we need to reopen the file after it was closed implicitly
++		when the server crashed */
++
++cifs_bp_rename_retry:
++	for (temp = direntry; !IS_ROOT(temp);) {
++		namelen += (1 + temp->d_name.len);
++		temp = temp->d_parent;
++		if(temp == NULL) {
++			cERROR(1,("corrupt dentry"));
++			return NULL;
++		}
++	}
++
++	full_path = kmalloc(namelen+1, GFP_KERNEL);
++	if(full_path == NULL)
++		return full_path;
++	full_path[namelen] = 0;	/* trailing null */
++
++	for (temp = direntry; !IS_ROOT(temp);) {
++		namelen -= 1 + temp->d_name.len;
++		if (namelen < 0) {
++			break;
++		} else {
++			full_path[namelen] = '\\';
++			strncpy(full_path + namelen + 1, temp->d_name.name,
++				temp->d_name.len);
++			cFYI(0, (" name: %s ", full_path + namelen));
++		}
++		temp = temp->d_parent;
++		if(temp == NULL) {
++			cERROR(1,("corrupt dentry"));
++			kfree(full_path);
++			return NULL;
++		}
++	}
++	if (namelen != 0) {
++		cERROR(1,
++		       ("We did not end path lookup where we expected namelen is %d",
++			namelen));
++		/* presumably this is only possible if we were racing with a rename 
++		of one of the parent directories  (we can not lock the dentries
++		above us to prevent this, but retrying should be harmless) */
++		kfree(full_path);
++		namelen = 0;
++		goto cifs_bp_rename_retry;
++	}
++
++	return full_path;
++}
++
++/* Note: caller must free return buffer */
++char *
++build_wildcard_path_from_dentry(struct dentry *direntry)
++{
++	struct dentry *temp;
++	int namelen = 0;
++	char *full_path;
++
++	if(direntry == NULL)
++		return NULL;  /* not much we can do if dentry is freed and
++		we need to reopen the file after it was closed implicitly
++		when the server crashed */
++
++cifs_bwp_rename_retry:
++	for (temp = direntry; !IS_ROOT(temp);) {
++		namelen += (1 + temp->d_name.len);
++		temp = temp->d_parent;
++		if(temp == NULL) {
++			cERROR(1,("corrupt dentry"));
++			return NULL;
++		}
++	}
++
++	full_path = kmalloc(namelen+3, GFP_KERNEL);
++	if(full_path == NULL)
++		return full_path;
++
++	full_path[namelen] = '\\';
++	full_path[namelen+1] = '*';
++	full_path[namelen+2] = 0;  /* trailing null */
++
++	for (temp = direntry; !IS_ROOT(temp);) {
++		namelen -= 1 + temp->d_name.len;
++		if (namelen < 0) {
++			break;
++		} else {
++			full_path[namelen] = '\\';
++			strncpy(full_path + namelen + 1, temp->d_name.name,
++				temp->d_name.len);
++			cFYI(0, (" name: %s ", full_path + namelen));
++		}
++		temp = temp->d_parent;
++		if(temp == NULL) {
++			cERROR(1,("corrupt dentry"));
++			kfree(full_path);
++			return NULL;
++		}
++	}
++	if (namelen != 0) {
++		cERROR(1,
++		       ("We did not end path lookup where we expected namelen is %d",
++			namelen));
++		/* presumably this is only possible if we were racing with a rename 
++		of one of the parent directories  (we can not lock the dentries
++		above us to prevent this, but retrying should be harmless) */
++		kfree(full_path);
++		namelen = 0;
++		goto cifs_bwp_rename_retry;
++	}
++
++	return full_path;
++}
++
++/* Inode operations in similar order to how they appear in the Linux file fs.h */
++
++int
++cifs_create(struct inode *inode, struct dentry *direntry, int mode)
++{
++	int rc = -ENOENT;
++	int xid;
++	int oplock = 0; /* no sense requested oplock if we are just going to
++			 immediately  close the file */
++	__u16 fileHandle;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	FILE_ALL_INFO * buf = NULL;
++	struct inode *newinode = NULL;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	down(&direntry->d_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(direntry);
++	up(&direntry->d_sb->s_vfs_rename_sem);
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++
++	/* BB add processing to set equivalent of mode - e.g. via CreateX with ACLs */
++
++        buf = kmalloc(sizeof(FILE_ALL_INFO),GFP_KERNEL);
++	rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OVERWRITE_IF,
++			GENERIC_WRITE, CREATE_NOT_DIR,
++			&fileHandle, &oplock, buf, cifs_sb->local_nls);
++	if (rc) {
++		cFYI(1, ("cifs_create returned 0x%x ", rc));
++	} else {
++	/* BB for case of overwriting existing file can we use the inode that was
++		 passed in rather than creating new one?? */
++		if (pTcon->ses->capabilities & CAP_UNIX)
++			rc = cifs_get_inode_info_unix(&newinode, full_path,
++						      inode->i_sb,xid);
++		else
++			rc = cifs_get_inode_info(&newinode, full_path,
++						 buf, inode->i_sb,xid);
++
++		if (rc != 0) {
++			cFYI(1,("Create worked but get_inode_info failed with rc = %d",
++			      rc));
++		} else {
++			direntry->d_op = &cifs_dentry_ops;
++			d_instantiate(direntry, newinode);
++		}
++		CIFSSMBClose(xid, pTcon, fileHandle);
++
++		if(newinode) {
++			newinode->i_mode = mode;
++			if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)                
++				CIFSSMBUnixSetPerms(xid, pTcon, full_path, inode->i_mode,
++					(__u64)-1, 
++					(__u64)-1,
++					0 /* dev */,
++					cifs_sb->local_nls);
++			else { /* BB implement via Windows security descriptors */
++			/* eg CIFSSMBWinSetPerms(xid,pTcon,full_path,mode,-1,-1,local_nls);*/
++			/* in the meantime could set r/o dos attribute when perms are eg:
++				mode & 0222 == 0 */
++			}
++		}
++	} 
++
++	if (buf)
++	    kfree(buf);
++	if (full_path)
++	    kfree(full_path);
++	FreeXid(xid);
++
++	return rc;
++}
++
++int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, int device_number) 
++{
++	int rc = -EPERM;
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	struct inode * newinode = NULL;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	down(&direntry->d_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(direntry);
++	up(&direntry->d_sb->s_vfs_rename_sem);
++	if(full_path == NULL)
++		rc = -ENOMEM;
++	
++	if (full_path && (pTcon->ses->capabilities & CAP_UNIX)) {
++		rc = CIFSSMBUnixSetPerms(xid, pTcon,
++			full_path, mode, current->euid, current->egid,
++			device_number, cifs_sb->local_nls);
++		if(!rc) {
++			rc = cifs_get_inode_info_unix(&newinode, full_path,
++						inode->i_sb,xid);
++			direntry->d_op = &cifs_dentry_ops;
++			if(rc == 0)
++				d_instantiate(direntry, newinode);
++		}
++	}
++
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++
++	return rc;
++}
++
++
++struct dentry *
++cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry)
++{
++	int xid;
++	int rc = 0; /* to get around spurious gcc warning, set to zero here */
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct inode *newInode = NULL;
++	char *full_path = NULL;
++
++	xid = GetXid();
++
++	cFYI(1,
++	     (" parent inode = 0x%p name is: %s and dentry = 0x%p",
++	      parent_dir_inode, direntry->d_name.name, direntry));
++
++	/* BB Add check of incoming data - e.g. frame not longer than maximum SMB - let server check the namelen BB */
++
++	/* check whether path exists */
++
++	cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	/* can not grab the rename sem here since it would
++	deadlock in the cases (beginning of sys_rename itself)
++	in which we already have the sb rename sem */
++	full_path = build_path_from_dentry(direntry);
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return ERR_PTR(-ENOMEM);
++	}
++
++	if (direntry->d_inode != NULL) {
++		cFYI(1, (" non-NULL inode in lookup"));
++	} else {
++		cFYI(1, (" NULL inode in lookup"));
++	}
++	cFYI(1,
++	     (" Full path: %s inode = 0x%p", full_path, direntry->d_inode));
++
++	if (pTcon->ses->capabilities & CAP_UNIX)
++		rc = cifs_get_inode_info_unix(&newInode, full_path,
++					      parent_dir_inode->i_sb,xid);
++	else
++		rc = cifs_get_inode_info(&newInode, full_path, NULL,
++					 parent_dir_inode->i_sb,xid);
++
++	if ((rc == 0) && (newInode != NULL)) {
++		direntry->d_op = &cifs_dentry_ops;
++		d_add(direntry, newInode);
++
++		/* since paths are not looked up by component - the parent directories are presumed to be good here */
++		renew_parental_timestamps(direntry);
++
++	} else if (rc == -ENOENT) {
++		rc = 0;
++		d_add(direntry, NULL);
++	} else {
++		cERROR(1,("Error 0x%x or on cifs_get_inode_info in lookup",rc));
++		/* BB special case check for Access Denied - watch security 
++		exposure of returning dir info implicitly via different rc 
++		if file exists or not but no access BB */
++	}
++
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return ERR_PTR(rc);
++}
++
++int
++cifs_dir_open(struct inode *inode, struct file *file)
++{				/* NB: currently unused since searches are opened in readdir */
++	int rc = 0;
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	if(file->f_dentry) {
++		down(&file->f_dentry->d_sb->s_vfs_rename_sem);
++		full_path = build_wildcard_path_from_dentry(file->f_dentry);
++		up(&file->f_dentry->d_sb->s_vfs_rename_sem);
++	} else {
++		FreeXid(xid);
++		return -EIO;
++	}
++
++	cFYI(1, ("inode = 0x%p and full path is %s", inode, full_path));
++
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++static int
++cifs_d_revalidate(struct dentry *direntry, int flags)
++{
++	int isValid = 1;
++
++/*	lock_kernel(); *//* surely we do not want to lock the kernel for a whole network round trip which could take seconds */
++
++	if (direntry->d_inode) {
++		if (cifs_revalidate(direntry)) {
++			/* unlock_kernel(); */
++			return 0;
++		}
++	} else {
++		cFYI(1,
++		     ("In cifs_d_revalidate with no inode but name = %s and dentry 0x%p",
++		      direntry->d_name.name, direntry));
++	}
++
++/*    unlock_kernel(); */
++
++	return isValid;
++}
++
++/* static int cifs_d_delete(struct dentry *direntry)
++{
++	int rc = 0;
++
++	cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
++
++	return rc;
++}     */
++
++struct dentry_operations cifs_dentry_ops = {
++	.d_revalidate = cifs_d_revalidate,
++/* d_delete:       cifs_d_delete,       *//* not needed except for debugging */
++	/* no need for d_hash, d_compare, d_release, d_iput ... yet. BB confirm this BB */
++};
+diff -urN linux-2.4.29.old/fs/cifs/file.c linux-2.4.29/fs/cifs/file.c
+--- linux-2.4.29.old/fs/cifs/file.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/file.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,2185 @@
++/*
++ *   fs/cifs/file.c
++ *
++ *   vfs operations that deal with files
++ * 
++ *   Copyright (C) International Business Machines  Corp., 2002,2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++#include <linux/fs.h>
++#include <linux/stat.h>
++#include <linux/fcntl.h>
++#include <linux/version.h>
++#include <linux/pagemap.h>
++#include <linux/smp_lock.h>
++#include <linux/list.h>
++#include <asm/div64.h>
++#include <linux/mm.h>
++#include <linux/types.h>
++#include "cifsfs.h"
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_unicode.h"
++#include "cifs_debug.h"
++#include "cifs_fs_sb.h"
++
++int
++cifs_open(struct inode *inode, struct file *file)
++{
++	int rc = -EACCES;
++	int xid, oplock;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct cifsFileInfo *pCifsFile;
++	struct cifsInodeInfo *pCifsInode;
++	char *full_path = NULL;
++	int desiredAccess = 0x20197;
++	int disposition;
++	__u16 netfid;
++	FILE_ALL_INFO * buf = NULL;
++	time_t temp;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	down(&inode->i_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(file->f_dentry);
++	up(&inode->i_sb->s_vfs_rename_sem);
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++
++	cFYI(1, (" inode = 0x%p file flags are 0x%x for %s", inode, file->f_flags,full_path));
++	if ((file->f_flags & O_ACCMODE) == O_RDONLY)
++		desiredAccess = GENERIC_READ;
++	else if ((file->f_flags & O_ACCMODE) == O_WRONLY)
++		desiredAccess = GENERIC_WRITE;
++	else if ((file->f_flags & O_ACCMODE) == O_RDWR) {
++		/* GENERIC_ALL is too much permission to request */
++		/* can cause unnecessary access denied on create */
++		/* desiredAccess = GENERIC_ALL; */
++		desiredAccess = GENERIC_READ | GENERIC_WRITE;
++	}
++
++/*********************************************************************
++ *  open flag mapping table:
++ *  
++ *	POSIX Flag            CIFS Disposition
++ *	----------            ---------------- 
++ *	O_CREAT               FILE_OPEN_IF
++ *	O_CREAT | O_EXCL      FILE_CREATE
++ *	O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
++ *	O_TRUNC               FILE_OVERWRITE
++ *	none of the above     FILE_OPEN
++ *
++ *	Note that there is not a direct match between disposition
++ *	FILE_SUPERSEDE (ie create whether or not file exists although 
++ *	O_CREAT | O_TRUNC is similar but truncates the existing
++ *	file rather than creating a new file as FILE_SUPERSEDE does
++ *	(which uses the attributes / metadata passed in on open call)
++ *?
++ *?  O_SYNC is a reasonable match to CIFS writethrough flag  
++ *?  and the read write flags match reasonably.  O_LARGEFILE
++ *?  is irrelevant because largefile support is always used
++ *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
++ *	 O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
++ *********************************************************************/
++
++	/* For 2.4 case, file was already checked for existence
++		before create by vfs lookup and created in create
++		entry point, we are now just opening the newly 
++		created file with the right desiredAccess flags */
++
++	if((file->f_flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
++		disposition = FILE_OPEN_IF; 
++	else if((file->f_flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
++		disposition = FILE_OVERWRITE_IF;
++	else if((file->f_flags & O_CREAT) == O_CREAT)
++		disposition = FILE_OPEN_IF;
++	else
++		disposition = FILE_OPEN;
++
++	if (oplockEnabled)
++		oplock = REQ_OPLOCK;
++	else
++		oplock = FALSE;
++
++	/* BB pass O_SYNC flag through on file attributes .. BB */
++
++	/* Also refresh inode by passing in file_info buf returned by SMBOpen 
++	   and calling get_inode_info with returned buf (at least 
++	   helps non-Unix server case */
++
++	/* BB we can not do this if this is the second open of a file 
++	and the first handle has writebehind data, we might be 
++	able to simply do a filemap_fdatawrite/filemap_fdatawait first */
++	buf = kmalloc(sizeof(FILE_ALL_INFO),GFP_KERNEL);
++	if(buf==0) {
++		if (full_path)
++			kfree(full_path);
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++	rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
++			CREATE_NOT_DIR, &netfid, &oplock, buf, cifs_sb->local_nls);
++	if (rc) {
++		cFYI(1, ("cifs_open returned 0x%x ", rc));
++		cFYI(1, ("oplock: %d ", oplock));	
++	} else {
++		file->private_data =
++			kmalloc(sizeof (struct cifsFileInfo), GFP_KERNEL);
++		if (file->private_data) {
++			memset(file->private_data, 0, sizeof(struct cifsFileInfo));
++			pCifsFile = (struct cifsFileInfo *) file->private_data;
++			pCifsFile->netfid = netfid;
++			pCifsFile->pid = current->pid;
++			init_MUTEX(&pCifsFile->fh_sem);
++			pCifsFile->pfile = file; /* needed for writepage */
++			pCifsFile->pInode = inode;
++			pCifsFile->invalidHandle = FALSE;
++			pCifsFile->closePend     = FALSE;
++			write_lock(&GlobalSMBSeslock);
++			spin_lock(&files_lock);
++			list_add(&pCifsFile->tlist,&pTcon->openFileList);
++			pCifsInode = CIFS_I(file->f_dentry->d_inode);
++			if(pCifsInode) {
++				/* want handles we can use to read with first */
++				/* in the list so we do not have to walk the */
++				/* list to search for one in prepare_write */
++				if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
++					list_add_tail(&pCifsFile->flist,&pCifsInode->openFileList);
++				} else {
++					list_add(&pCifsFile->flist,&pCifsInode->openFileList);
++				}
++				spin_unlock(&files_lock);
++				write_unlock(&GlobalSMBSeslock);
++				if(pCifsInode->clientCanCacheRead) {
++					/* we have the inode open somewhere else
++					   no need to discard cache data */
++				} else {
++					if(buf) {
++					/* BB need same check in cifs_create too? */
++
++					/* if not oplocked, invalidate inode pages if mtime 
++					   or file size changed */
++						temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
++						if((file->f_dentry->d_inode->i_mtime == temp) && 
++							(file->f_dentry->d_inode->i_size == (loff_t)le64_to_cpu(buf->EndOfFile))) {
++							cFYI(1,("inode unchanged on server"));
++						} else {
++							if(file->f_dentry->d_inode->i_mapping) {
++							/* BB no need to lock inode until after invalidate*/
++							/* since namei code should already have it locked?*/
++								filemap_fdatasync(file->f_dentry->d_inode->i_mapping);
++							}
++							cFYI(1,("invalidating remote inode since open detected it changed"));
++							invalidate_inode_pages(file->f_dentry->d_inode);
++						}
++					}
++				}
++				if (pTcon->ses->capabilities & CAP_UNIX)
++					rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
++						full_path, inode->i_sb,xid);
++				else
++					rc = cifs_get_inode_info(&file->f_dentry->d_inode,
++						full_path, buf, inode->i_sb,xid);
++
++				if((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
++					pCifsInode->clientCanCacheAll = TRUE;
++					pCifsInode->clientCanCacheRead = TRUE;
++					cFYI(1,("Exclusive Oplock granted on inode %p",file->f_dentry->d_inode));
++				} else if((oplock & 0xF) == OPLOCK_READ)
++					pCifsInode->clientCanCacheRead = TRUE;
++			} else {
++				spin_unlock(&files_lock);
++				write_unlock(&GlobalSMBSeslock);
++			}
++			if(oplock & CIFS_CREATE_ACTION) {           
++				/* time to set mode which we can not set earlier due
++				 to problems creating new read-only files */
++				if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)                
++					CIFSSMBUnixSetPerms(xid, pTcon, full_path, inode->i_mode,
++						(__u64)-1, 
++						(__u64)-1,
++						0 /* dev */,
++						cifs_sb->local_nls);
++				else {/* BB implement via Windows security descriptors */
++			/* eg CIFSSMBWinSetPerms(xid,pTcon,full_path,mode,-1,-1,local_nls);*/
++			/* in the meantime could set r/o dos attribute when perms are eg:
++					mode & 0222 == 0 */
++				}
++			}
++		}
++	}
++
++	if (buf)
++		kfree(buf);
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++/* Try to reaquire byte range locks that were released when session */
++/* to server was lost */
++static int cifs_relock_file(struct cifsFileInfo * cifsFile)
++{
++	int rc = 0;
++
++/* BB list all locks open on this file and relock */
++
++	return rc;
++}
++
++static int cifs_reopen_file(struct inode *inode, struct file *file, int can_flush)
++{
++	int rc = -EACCES;
++	int xid, oplock;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct cifsFileInfo *pCifsFile;
++	struct cifsInodeInfo *pCifsInode;
++	char *full_path = NULL;
++	int desiredAccess = 0x20197;
++	int disposition = FILE_OPEN;
++	__u16 netfid;
++
++	if(inode == NULL)
++		return -EBADF;
++	if (file->private_data) {
++		pCifsFile = (struct cifsFileInfo *) file->private_data;
++	} else
++		return -EBADF;
++
++	xid = GetXid();
++	down(&pCifsFile->fh_sem);
++	if(pCifsFile->invalidHandle == FALSE) {
++		up(&pCifsFile->fh_sem);
++		FreeXid(xid);
++		return 0;
++	}
++
++	if(file->f_dentry == NULL) {
++		up(&pCifsFile->fh_sem);
++		cFYI(1,("failed file reopen, no valid name if dentry freed"));
++		FreeXid(xid);
++		return -EBADF;
++	}
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++/* can not grab rename sem here because various ops, including
++those that already have the rename sem can end up causing writepage
++to get called and if the server was down that means we end up here,
++and we can never tell if the caller already has the rename_sem */
++	full_path = build_path_from_dentry(file->f_dentry);
++	if(full_path == NULL) {
++		up(&pCifsFile->fh_sem);
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++
++	cFYI(1, (" inode = 0x%p file flags are 0x%x for %s", inode, file->f_flags,full_path));
++	if ((file->f_flags & O_ACCMODE) == O_RDONLY)
++		desiredAccess = GENERIC_READ;
++	else if ((file->f_flags & O_ACCMODE) == O_WRONLY)
++		desiredAccess = GENERIC_WRITE;
++	else if ((file->f_flags & O_ACCMODE) == O_RDWR) {
++		/* GENERIC_ALL is too much permission to request */
++		/* can cause unnecessary access denied on create */
++		/* desiredAccess = GENERIC_ALL; */
++		desiredAccess = GENERIC_READ | GENERIC_WRITE;
++	}
++
++	if (oplockEnabled)
++		oplock = REQ_OPLOCK;
++	else
++		oplock = FALSE;
++
++	
++	/* Can not refresh inode by passing in file_info buf to be returned
++	 by SMBOpen and then calling get_inode_info with returned buf 
++	 since file might have write behind data that needs to be flushed 
++	 and server version of file size can be stale. If we 
++	 knew for sure that inode was not dirty locally we could do this */
++
++/*	buf = kmalloc(sizeof(FILE_ALL_INFO),GFP_KERNEL);
++	if(buf==0) {
++		up(&pCifsFile->fh_sem);
++		if (full_path)
++			kfree(full_path);
++		FreeXid(xid);
++		return -ENOMEM;
++	}*/
++	rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
++				CREATE_NOT_DIR, &netfid, &oplock, NULL, cifs_sb->local_nls);
++	if (rc) {
++		up(&pCifsFile->fh_sem);
++		cFYI(1, ("cifs_open returned 0x%x ", rc));
++		cFYI(1, ("oplock: %d ", oplock));
++	} else {
++		pCifsFile->netfid = netfid;
++		pCifsFile->invalidHandle = FALSE;
++		up(&pCifsFile->fh_sem);
++		pCifsInode = CIFS_I(inode);
++		if(pCifsInode) {
++			if(can_flush) {
++				filemap_fdatasync(inode->i_mapping);
++				filemap_fdatawait(inode->i_mapping);
++			/* temporarily disable caching while we
++			go to server to get inode info */
++				pCifsInode->clientCanCacheAll = FALSE;
++				pCifsInode->clientCanCacheRead = FALSE;
++				if (pTcon->ses->capabilities & CAP_UNIX)
++					rc = cifs_get_inode_info_unix(&inode,
++						full_path, inode->i_sb,xid);
++				else
++					rc = cifs_get_inode_info(&inode,
++						full_path, NULL, inode->i_sb,xid);
++			} /* else we are writing out data to server already
++			and could deadlock if we tried to flush data, and 
++			since we do not know if we have data that would
++			invalidate the current end of file on the server
++			we can not go to the server to get the new
++			inod info */
++			if((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
++				pCifsInode->clientCanCacheAll =  TRUE;
++				pCifsInode->clientCanCacheRead = TRUE;
++				cFYI(1,("Exclusive Oplock granted on inode %p",file->f_dentry->d_inode));
++			} else if((oplock & 0xF) == OPLOCK_READ) {
++				pCifsInode->clientCanCacheRead = TRUE;
++				pCifsInode->clientCanCacheAll =  FALSE;
++			} else {
++				pCifsInode->clientCanCacheRead = FALSE;
++				pCifsInode->clientCanCacheAll =  FALSE;
++			}
++			cifs_relock_file(pCifsFile);
++		}
++	}
++
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_close(struct inode *inode, struct file *file)
++{
++	int rc = 0;
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct cifsFileInfo *pSMBFile =
++		(struct cifsFileInfo *) file->private_data;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++	if (pSMBFile) {
++		pSMBFile->closePend    = TRUE;
++		spin_lock(&files_lock);
++		if(pTcon) {
++			/* no sense reconnecting to close a file that is
++				already closed */
++			if (pTcon->tidStatus != CifsNeedReconnect) {
++				spin_unlock(&files_lock);
++				rc = CIFSSMBClose(xid,pTcon,pSMBFile->netfid);
++				spin_lock(&files_lock);
++			}
++		}
++		list_del(&pSMBFile->flist);
++		list_del(&pSMBFile->tlist);
++		spin_unlock(&files_lock);
++		if(pSMBFile->search_resume_name)
++			kfree(pSMBFile->search_resume_name);
++		kfree(file->private_data);
++		file->private_data = NULL;
++	} else
++		rc = -EBADF;
++
++	if(list_empty(&(CIFS_I(inode)->openFileList))) {
++		cFYI(1,("closing last open instance for inode %p",inode));
++		/* if the file is not open we do not know if we can cache
++		info on this inode, much less write behind and read ahead */
++		CIFS_I(inode)->clientCanCacheRead = FALSE;
++		CIFS_I(inode)->clientCanCacheAll  = FALSE;
++	}
++	if((rc ==0) && CIFS_I(inode)->write_behind_rc)
++		rc = CIFS_I(inode)->write_behind_rc;
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_closedir(struct inode *inode, struct file *file)
++{
++	int rc = 0;
++	int xid;
++	struct cifsFileInfo *pSMBFileStruct =
++	    (struct cifsFileInfo *) file->private_data;
++
++	cFYI(1, ("Closedir inode = 0x%p with ", inode));
++
++	xid = GetXid();
++
++	if (pSMBFileStruct) {
++		cFYI(1, ("Freeing private data in close dir"));
++		kfree(file->private_data);
++		file->private_data = NULL;
++	}
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
++{
++	int rc, xid;
++	__u32 lockType = LOCKING_ANDX_LARGE_FILES;
++	__u32 numLock = 0;
++	__u32 numUnlock = 0;
++	__u64 length;
++	int wait_flag = FALSE;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	length = 1 + pfLock->fl_end - pfLock->fl_start;
++
++	rc = -EACCES;
++
++	xid = GetXid();
++
++	cFYI(1,
++	     ("Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld",
++	      cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
++	      pfLock->fl_end));
++
++	if (pfLock->fl_flags & FL_POSIX)
++		cFYI(1, ("Posix "));
++	if (pfLock->fl_flags & FL_FLOCK)
++		cFYI(1, ("Flock "));
++/*	if (pfLock->fl_flags & FL_SLEEP) {
++		cFYI(1, ("Blocking lock "));
++		wait_flag = TRUE;
++	} */                          
++	if (pfLock->fl_flags & FL_ACCESS)
++		cFYI(1, ("Process suspended by mandatory locking - not implemented yet "));
++	if (pfLock->fl_flags & FL_LEASE)
++		cFYI(1, ("Lease on file - not implemented yet"));
++	if (pfLock->fl_flags & (~(FL_POSIX | FL_FLOCK | FL_ACCESS | FL_LEASE)))
++		cFYI(1, ("Unknown lock flags 0x%x",pfLock->fl_flags));
++
++	if (pfLock->fl_type == F_WRLCK) {
++		cFYI(1, ("F_WRLCK "));
++		numLock = 1;
++	} else if (pfLock->fl_type == F_UNLCK) {
++		cFYI(1, ("F_UNLCK "));
++		numUnlock = 1;
++	} else if (pfLock->fl_type == F_RDLCK) {
++		cFYI(1, ("F_RDLCK "));
++		lockType |= LOCKING_ANDX_SHARED_LOCK;
++		numLock = 1;
++	} else if (pfLock->fl_type == F_EXLCK) {
++		cFYI(1, ("F_EXLCK "));
++		numLock = 1;
++	} else if (pfLock->fl_type == F_SHLCK) {
++		cFYI(1, ("F_SHLCK "));
++		lockType |= LOCKING_ANDX_SHARED_LOCK;
++		numLock = 1;
++	} else
++		cFYI(1, ("Unknown type of lock "));
++
++	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
++	pTcon = cifs_sb->tcon;
++
++	if (file->private_data == NULL) {
++		FreeXid(xid);
++		return -EBADF;
++	}
++
++	if (IS_GETLK(cmd)) {
++		rc = CIFSSMBLock(xid, pTcon,
++				 ((struct cifsFileInfo *) file->
++				  private_data)->netfid,
++				 length,
++				 pfLock->fl_start, 0, 1, lockType,
++				 0 /* wait flag */ );
++		if (rc == 0) {
++			rc = CIFSSMBLock(xid, pTcon,
++					 ((struct cifsFileInfo *) file->
++					  private_data)->netfid,
++					 length,
++					 pfLock->fl_start, 1 /* numUnlock */ ,
++					 0 /* numLock */ , lockType,
++					 0 /* wait flag */ );
++			pfLock->fl_type = F_UNLCK;
++			if (rc != 0)
++				cERROR(1,
++					("Error unlocking previously locked range %d during test of lock ",
++					rc));
++			rc = 0;
++
++		} else {
++			/* if rc == ERR_SHARING_VIOLATION ? */
++			rc = 0;	/* do not change lock type to unlock since range in use */
++		}
++
++		FreeXid(xid);
++		return rc;
++	}
++
++	rc = CIFSSMBLock(xid, pTcon,
++			 ((struct cifsFileInfo *) file->private_data)->
++			 netfid, length,
++			 pfLock->fl_start, numUnlock, numLock, lockType,
++			 wait_flag);
++	FreeXid(xid);
++	return rc;
++}
++
++ssize_t
++cifs_write(struct file * file, const char *write_data,
++	   size_t write_size, loff_t * poffset)
++{
++	int rc = 0;
++	unsigned int bytes_written = 0;
++	unsigned int total_written;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	int xid, long_op;
++	struct cifsFileInfo * open_file;
++
++	if(file->f_dentry == NULL)
++		return -EBADF;
++
++	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
++	if(cifs_sb == NULL) {
++		return -EBADF;
++	}
++	pTcon = cifs_sb->tcon;
++
++	/*cFYI(1,
++	   (" write %d bytes to offset %lld of %s", write_size,
++	   *poffset, file->f_dentry->d_name.name)); */
++
++	if (file->private_data == NULL) {
++		return -EBADF;
++	} else {
++		open_file = (struct cifsFileInfo *) file->private_data;
++	}
++	
++	xid = GetXid();
++	if(file->f_dentry->d_inode == NULL) {
++		FreeXid(xid);
++		return -EBADF;
++	}
++
++	if (*poffset > file->f_dentry->d_inode->i_size)
++		long_op = 2;  /* writes past end of file can take a long time */
++	else
++		long_op = 1;
++
++	for (total_written = 0; write_size > total_written;
++	     total_written += bytes_written) {
++		rc = -EAGAIN;
++		while(rc == -EAGAIN) {
++			if(file->private_data == NULL) {
++				/* file has been closed on us */
++				FreeXid(xid);
++			/* if we have gotten here we have written some data
++			and blocked, and the file has been freed on us
++			while we blocked so return what we managed to write */
++				return total_written;
++			} 
++			if(open_file->closePend) {
++				FreeXid(xid);
++				if(total_written)
++					return total_written;
++				else
++					return -EBADF;
++			}
++			if (open_file->invalidHandle) {
++				if((file->f_dentry == NULL) ||
++				   (file->f_dentry->d_inode == NULL)) {
++					FreeXid(xid);
++					return total_written;
++				}
++				/* we could deadlock if we called
++				 filemap_fdatawait from here so tell
++				reopen_file not to flush data to server now */
++				rc = cifs_reopen_file(file->f_dentry->d_inode,
++					file,FALSE);
++				if(rc != 0)
++					break;
++			}
++
++			rc = CIFSSMBWrite(xid, pTcon,
++				   open_file->netfid,
++				  write_size - total_written, *poffset,
++				  &bytes_written,
++				  write_data + total_written, long_op);
++		}
++		if (rc || (bytes_written == 0)) {
++			if (total_written)
++				break;
++			else {
++				FreeXid(xid);
++				return rc;
++			}
++		} else
++			*poffset += bytes_written;
++		long_op = FALSE; /* subsequent writes fast - 15 seconds is plenty */
++	}
++
++#ifdef CONFIG_CIFS_STATS
++	if(total_written > 0) {
++		atomic_inc(&pTcon->num_writes);
++		spin_lock(&pTcon->stat_lock);
++		pTcon->bytes_written += total_written;
++		spin_unlock(&pTcon->stat_lock);
++	}
++#endif		
++
++	/* since the write may have blocked check these pointers again */
++	if(file->f_dentry) {
++		if(file->f_dentry->d_inode) {
++			file->f_dentry->d_inode->i_ctime = file->f_dentry->d_inode->i_mtime =
++				CURRENT_TIME;
++			if (total_written > 0) {
++				if (*poffset > file->f_dentry->d_inode->i_size)
++					file->f_dentry->d_inode->i_size = *poffset;
++			}
++			mark_inode_dirty_sync(file->f_dentry->d_inode);
++		}
++	}
++	FreeXid(xid);
++	return total_written;
++}
++
++static int
++cifs_partialpagewrite(struct page *page,unsigned from, unsigned to)
++{
++	struct address_space *mapping = page->mapping;
++	loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
++	char * write_data;
++	int rc = -EFAULT;
++	int bytes_written = 0;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct inode *inode;
++	struct cifsInodeInfo *cifsInode;
++	struct cifsFileInfo *open_file = NULL;
++	struct list_head *tmp;
++	struct list_head *tmp1;
++
++	if (!mapping) {
++		return -EFAULT;
++	} else if(!mapping->host) {
++		return -EFAULT;
++	}
++
++	inode = page->mapping->host;
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	offset += (loff_t)from;
++	write_data = kmap(page);
++	write_data += from;
++
++	if((to > PAGE_CACHE_SIZE) || (from > to)) {
++		kunmap(page);
++		return -EIO;
++	}
++
++	/* racing with truncate? */
++	if(offset > mapping->host->i_size) {
++		kunmap(page);
++		return 0; /* don't care */
++	}
++
++	/* check to make sure that we are not extending the file */
++	if(mapping->host->i_size - offset < (loff_t)to)
++		to = (unsigned)(mapping->host->i_size - offset); 
++		
++
++	cifsInode = CIFS_I(mapping->host);
++	read_lock(&GlobalSMBSeslock); 
++	/* BB we should start at the end */
++	list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {            
++		open_file = list_entry(tmp,struct cifsFileInfo, flist);
++		if(open_file->closePend)
++			continue;
++		/* We check if file is open for writing first */
++		if((open_file->pfile) && 
++		   ((open_file->pfile->f_flags & O_RDWR) || 
++			(open_file->pfile->f_flags & O_WRONLY))) {
++			read_unlock(&GlobalSMBSeslock);
++			bytes_written = cifs_write(open_file->pfile, write_data,
++					to-from, &offset);
++			read_lock(&GlobalSMBSeslock);
++		/* Does mm or vfs already set times? */
++			inode->i_atime = inode->i_mtime = CURRENT_TIME;
++			if ((bytes_written > 0) && (offset)) {
++				rc = 0;
++			} else if(bytes_written < 0) {
++				if(rc == -EBADF) {
++				/* have seen a case in which
++				kernel seemed to have closed/freed a file
++				even with writes active so we might as well
++				see if there are other file structs to try
++				for the same inode before giving up */
++					continue;
++				} else
++					rc = bytes_written;
++			}
++			break;  /* now that we found a valid file handle
++				and tried to write to it we are done, no
++				sense continuing to loop looking for another */
++		}
++		if(tmp->next == NULL) {
++			cFYI(1,("File instance %p removed",tmp));
++			break;
++		}
++	}
++	read_unlock(&GlobalSMBSeslock);
++	if(open_file == NULL) {
++		cFYI(1,("No writeable filehandles for inode"));
++		rc = -EIO;
++	}
++
++	kunmap(page);
++	return rc;
++}
++
++#if 0
++static int
++cifs_writepages(struct address_space *mapping, struct writeback_control *wbc)
++{
++	int rc = -EFAULT;
++	int xid;
++
++	xid = GetXid();
++/* call 16K write then Setpageuptodate */
++	FreeXid(xid);
++	return rc;
++}
++#endif
++
++static int
++cifs_writepage(struct page* page)
++{
++	int rc = -EFAULT;
++	int xid;
++
++	xid = GetXid();
++/* BB add check for wbc flags */
++	page_cache_get(page);
++        if (!Page_Uptodate(page)) {
++		cFYI(1,("ppw - page not up to date"));
++	}
++	
++	rc = cifs_partialpagewrite(page,0,PAGE_CACHE_SIZE);
++	SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,20))
++	unlock_page(page);
++#else
++	UnlockPage(page);
++#endif
++	page_cache_release(page);	
++	FreeXid(xid);
++	return rc;
++}
++
++static int
++cifs_commit_write(struct file *file, struct page *page, unsigned offset,
++		  unsigned to)
++{
++	int xid;
++	int rc = 0;
++	struct inode *inode = page->mapping->host;
++	loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
++	char * page_data;
++
++	xid = GetXid();
++	cFYI(1,("commit write for page %p up to position %lld for %d",page,position,to));
++	if (position > inode->i_size){
++		inode->i_size = position;
++		/*if (file->private_data == NULL) {
++			rc = -EBADF;
++		} else {
++			open_file = (struct cifsFileInfo *)file->private_data;
++			cifs_sb = CIFS_SB(inode->i_sb);
++			rc = -EAGAIN;
++			while(rc == -EAGAIN) {
++				if((open_file->invalidHandle) && 
++				  (!open_file->closePend)) {
++					rc = cifs_reopen_file(file->f_dentry->d_inode,file);
++					if(rc != 0)
++						break;
++				}
++				if(!open_file->closePend) {
++					rc = CIFSSMBSetFileSize(xid, cifs_sb->tcon, 
++						position, open_file->netfid,
++						open_file->pid,FALSE);
++				} else {
++					rc = -EBADF;
++					break;
++				}
++			}
++			cFYI(1,(" SetEOF (commit write) rc = %d",rc));
++		}*/
++	}
++	if (!Page_Uptodate(page)) {
++		position =  ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
++		/* can not rely on (or let) writepage write this data */
++		if(to < offset) {
++			cFYI(1,("Illegal offsets, can not copy from %d to %d",
++				offset,to));
++			FreeXid(xid);
++			return rc;
++		}
++		/* this is probably better than directly calling 
++		partialpage_write since in this function
++		the file handle is known which we might as well
++		leverage */
++		/* BB check if anything else missing out of ppw */
++		/* such as updating last write time */
++		page_data = kmap(page);
++		rc = cifs_write(file, page_data+offset,to-offset,
++                                        &position);
++		if(rc > 0)
++			rc = 0;
++		/* else if rc < 0 should we set writebehind rc? */
++		kunmap(page);
++	} else {	
++		set_page_dirty(page);
++	}
++
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
++{
++	int xid;
++	int rc = 0;
++	struct inode * inode = file->f_dentry->d_inode;
++
++	xid = GetXid();
++
++	cFYI(1, ("Sync file - name: %s datasync: 0x%x ", 
++		dentry->d_name.name, datasync));
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,17))	
++	rc = filemap_fdatasync(inode->i_mapping);
++#else
++	filemap_fdatasync(inode->i_mapping);
++#endif
++	if(rc == 0)
++		CIFS_I(inode)->write_behind_rc = 0;
++	FreeXid(xid);
++	return rc;
++}
++
++static int
++cifs_sync_page(struct page *page)
++{
++	struct address_space *mapping;
++	struct inode *inode;
++	unsigned long index = page->index;
++	unsigned int rpages = 0;
++	int rc = 0;
++
++	cFYI(1,("sync page %p",page));
++	mapping = page->mapping;
++	if (!mapping)
++		return 0;
++	inode = mapping->host;
++	if (!inode)
++		return 0;
++
++/*	fill in rpages then 
++    result = cifs_pagein_inode(inode, index, rpages); *//* BB finish */
++
++	cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
++
++	if (rc < 0)
++		return rc;
++	return 0;
++}
++
++/*
++ * As file closes, flush all cached write data for this inode checking
++ * for write behind errors.
++ *
++ */
++int cifs_flush(struct file *file)
++{
++	struct inode * inode = file->f_dentry->d_inode;
++	int rc = 0;
++
++	/* Rather than do the steps manually: */
++	/* lock the inode for writing */
++	/* loop through pages looking for write behind data (dirty pages) */
++	/* coalesce into contiguous 16K (or smaller) chunks to write to server */
++	/* send to server (prefer in parallel) */
++	/* deal with writebehind errors */
++	/* unlock inode for writing */
++	/* filemapfdatawrite appears easier for the time being */
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,17))
++	rc = filemap_fdatasync(inode->i_mapping);
++#else
++	filemap_fdatasync(inode->i_mapping);
++#endif
++	if(rc == 0) /* reset wb rc if we were able to write out dirty pages */
++		CIFS_I(inode)->write_behind_rc = 0;
++		
++	cFYI(1,("Flush inode %p file %p rc %d",inode,file,rc));
++
++	return rc;
++}
++
++
++ssize_t
++cifs_read(struct file * file, char *read_data, size_t read_size,
++	  loff_t * poffset)
++{
++	int rc = -EACCES;
++	unsigned int bytes_read = 0;
++	unsigned int total_read;
++	unsigned int current_read_size;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	int xid;
++	char * current_offset;
++	struct cifsFileInfo * open_file;
++
++	xid = GetXid();
++	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
++	pTcon = cifs_sb->tcon;
++
++	if (file->private_data == NULL) {
++		FreeXid(xid);
++		return -EBADF;
++	}
++	open_file = (struct cifsFileInfo *)file->private_data;
++
++	if((file->f_flags & O_ACCMODE) == O_WRONLY) {
++		cFYI(1,("attempting read on write only file instance"));
++	}
++
++	for (total_read = 0,current_offset=read_data; read_size > total_read;
++				total_read += bytes_read,current_offset+=bytes_read) {
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,15))
++		current_read_size = min_t(const int,read_size - total_read,cifs_sb->rsize);
++#else
++                current_read_size = min(read_size - total_read,cifs_sb->rsize);
++#endif
++		rc = -EAGAIN;
++		while(rc == -EAGAIN) {
++			if ((open_file->invalidHandle) && (!open_file->closePend)) {
++				rc = cifs_reopen_file(file->f_dentry->d_inode,
++					file,TRUE);
++				if(rc != 0)
++					break;
++			}
++
++			rc = CIFSSMBRead(xid, pTcon,
++				 open_file->netfid,
++				 current_read_size, *poffset,
++				 &bytes_read, &current_offset);
++		}
++		if (rc || (bytes_read == 0)) {
++			if (total_read) {
++				break;
++			} else {
++				FreeXid(xid);
++				return rc;
++			}
++		} else {
++#ifdef CONFIG_CIFS_STATS
++			atomic_inc(&pTcon->num_reads);
++			spin_lock(&pTcon->stat_lock);
++			pTcon->bytes_read += total_read;
++			spin_unlock(&pTcon->stat_lock);
++#endif
++			*poffset += bytes_read;
++		}
++	}
++	FreeXid(xid);
++	return total_read;
++}
++
++int cifs_file_mmap(struct file * file, struct vm_area_struct * vma)
++{
++	struct dentry * dentry = file->f_dentry;
++	int	rc, xid;
++
++	xid = GetXid();
++	rc = cifs_revalidate(dentry);
++	if (rc) {
++		cFYI(1,("Validation prior to mmap failed, error=%d", rc));
++		FreeXid(xid);
++		return rc;
++	}
++	rc = generic_file_mmap(file, vma);
++	FreeXid(xid);
++	return rc;
++}
++
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
++static void cifs_copy_cache_pages(struct address_space *mapping, 
++		struct list_head *pages, int bytes_read, 
++		char *data,struct pagevec * plru_pvec)
++{
++	struct page *page;
++	char * target;
++
++	while (bytes_read > 0) {
++		if(list_empty(pages))
++			break;
++
++		page = list_entry(pages->prev, struct page, lru);
++		list_del(&page->lru);
++
++		if (add_to_page_cache(page, mapping, page->index, GFP_KERNEL)) {
++			page_cache_release(page);
++			cFYI(1,("Add page cache failed"));
++			continue;
++		}
++
++		target = kmap_atomic(page,KM_USER0);
++
++		if(PAGE_CACHE_SIZE > bytes_read) {
++			memcpy(target,data,bytes_read);
++			/* zero the tail end of this partial page */
++			memset(target+bytes_read,0,PAGE_CACHE_SIZE-bytes_read);
++			bytes_read = 0;
++		} else {
++			memcpy(target,data,PAGE_CACHE_SIZE);
++			bytes_read -= PAGE_CACHE_SIZE;
++		}
++		kunmap_atomic(target,KM_USER0);
++
++		flush_dcache_page(page);
++		SetPageUptodate(page);
++		unlock_page(page);
++		if (!pagevec_add(plru_pvec, page))
++			__pagevec_lru_add(plru_pvec);
++		data += PAGE_CACHE_SIZE;
++	}
++	return;
++}
++
++
++static int
++cifs_readpages(struct file *file, struct address_space *mapping,
++		struct list_head *page_list, unsigned num_pages)
++{
++	int rc = -EACCES;
++	int xid;
++	loff_t offset;
++	struct page * page;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	int bytes_read = 0;
++	unsigned int read_size,i;
++	char * smb_read_data = NULL;
++	struct smb_com_read_rsp * pSMBr;
++	struct pagevec lru_pvec;
++	struct cifsFileInfo * open_file;
++
++	xid = GetXid();
++	if (file->private_data == NULL) {
++		FreeXid(xid);
++		return -EBADF;
++	}
++	open_file = (struct cifsFileInfo *)file->private_data;
++	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
++	pTcon = cifs_sb->tcon;
++
++	pagevec_init(&lru_pvec, 0);
++
++	for(i = 0;i<num_pages;) {
++		unsigned contig_pages;
++		struct page * tmp_page;
++		unsigned long expected_index;
++
++		if(list_empty(page_list)) {
++			break;
++		}
++		page = list_entry(page_list->prev, struct page, lru);
++		offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
++
++		/* count adjacent pages that we will read into */
++		contig_pages = 0;
++		expected_index = list_entry(page_list->prev,struct page,lru)->index;
++		list_for_each_entry_reverse(tmp_page,page_list,lru) {
++			if(tmp_page->index == expected_index) {
++				contig_pages++;
++				expected_index++;
++			} else {
++				break; 
++			}
++		}
++		if(contig_pages + i >  num_pages) {
++			contig_pages = num_pages - i;
++		}
++
++		/* for reads over a certain size could initiate async read ahead */
++
++		read_size = contig_pages * PAGE_CACHE_SIZE;
++		/* Read size needs to be in multiples of one page */
++		read_size = min_t(const unsigned int,read_size,cifs_sb->rsize & PAGE_CACHE_MASK);
++
++		rc = -EAGAIN;
++		while(rc == -EAGAIN) {
++			if ((open_file->invalidHandle) && (!open_file->closePend)) {
++				rc = cifs_reopen_file(file->f_dentry->d_inode,
++					file, TRUE);
++				if(rc != 0)
++					break;
++			}
++
++			rc = CIFSSMBRead(xid, pTcon,
++				open_file->netfid,
++				read_size, offset,
++				&bytes_read, &smb_read_data);
++			/* BB need to check return code here */
++			if(rc== -EAGAIN) {
++				if(smb_read_data) {
++					cifs_buf_release(smb_read_data);
++					smb_read_data = NULL;
++				}
++			}
++		}
++		if ((rc < 0) || (smb_read_data == NULL)) {
++			cFYI(1,("Read error in readpages: %d",rc));
++			/* clean up remaing pages off list */
++			while (!list_empty(page_list) && (i < num_pages)) {
++				page = list_entry(page_list->prev, struct page, lru);
++				list_del(&page->lru);
++				page_cache_release(page);
++			}
++			break;
++		} else if (bytes_read > 0) {
++			pSMBr = (struct smb_com_read_rsp *)smb_read_data;
++			cifs_copy_cache_pages(mapping, page_list, bytes_read,
++				smb_read_data + 4 /* RFC1001 hdr */ +
++				le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
++
++			i +=  bytes_read >> PAGE_CACHE_SHIFT;
++#ifdef CONFIG_CIFS_STATS
++			atomic_inc(&pTcon->num_reads);
++			spin_lock(&pTcon->stat_lock);
++			pTcon->bytes_read += bytes_read;
++			spin_unlock(&pTcon->stat_lock);
++#endif
++			if((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
++				cFYI(1,("Partial page %d of %d read to cache",i++,num_pages));
++
++				i++; /* account for partial page */
++
++				/* server copy of file can have smaller size than client */
++				/* BB do we need to verify this common case ? this case is ok - 
++				if we are at server EOF we will hit it on next read */
++
++			/* while(!list_empty(page_list) && (i < num_pages)) {
++					page = list_entry(page_list->prev,struct page, list);
++					list_del(&page->list);
++					page_cache_release(page);
++				}
++				break; */
++			}
++		} else {
++			cFYI(1,("No bytes read (%d) at offset %lld . Cleaning remaining pages from readahead list",bytes_read,offset)); 
++			/* BB turn off caching and do new lookup on file size at server? */
++			while (!list_empty(page_list) && (i < num_pages)) {
++				page = list_entry(page_list->prev, struct page, lru);
++				list_del(&page->lru);
++				page_cache_release(page); /* BB removeme - replace with zero of page? */
++			}
++			break;
++		}
++		if(smb_read_data) {
++			cifs_buf_release(smb_read_data);
++			smb_read_data = NULL;
++		}
++		bytes_read = 0;
++	}
++
++	pagevec_lru_add(&lru_pvec);
++
++/* need to free smb_read_data buf before exit */
++	if(smb_read_data) {
++		cifs_buf_release(smb_read_data);
++		smb_read_data = NULL;
++	} 
++
++	FreeXid(xid);
++	return rc;
++}
++#endif
++
++static int cifs_readpage_worker(struct file *file, struct page *page, loff_t * poffset)
++{
++	char * read_data;
++	int rc;
++
++	page_cache_get(page);
++	read_data = kmap(page);
++	/* for reads over a certain size could initiate async read ahead */
++                                                                                                                           
++	rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
++                                                                                                                           
++	if (rc < 0)
++		goto io_error;
++	else {
++		cFYI(1,("Bytes read %d ",rc));
++	}
++                                                                                                                           
++	file->f_dentry->d_inode->i_atime = CURRENT_TIME;
++                                                                                                                           
++	if(PAGE_CACHE_SIZE > rc) {
++		memset(read_data+rc, 0, PAGE_CACHE_SIZE - rc);
++	}
++	flush_dcache_page(page);
++	SetPageUptodate(page);
++	rc = 0;
++                                                                                                                           
++io_error:
++        kunmap(page);
++	page_cache_release(page);
++	return rc;
++}
++
++static int
++cifs_readpage(struct file *file, struct page *page)
++{
++	loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
++	int rc = -EACCES;
++	int xid;
++
++	xid = GetXid();
++
++	if (file->private_data == NULL) {
++		FreeXid(xid);
++		return -EBADF;
++	}
++
++	cFYI(1,("readpage %p at offset %d 0x%x\n",page,(int)offset,(int)offset));
++
++	rc = cifs_readpage_worker(file,page,&offset);
++
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,20))
++	unlock_page(page);
++#else
++	UnlockPage(page);
++#endif
++
++	FreeXid(xid);
++	return rc;
++}
++
++/* We do not want to update the file size from server for inodes
++   open for write - to avoid races with writepage extending
++   the file - in the future we could consider allowing
++   refreshing the inode only on increases in the file size
++   but this is tricky to do without racing with writebehind
++   page caching in the current Linux kernel design */
++
++int is_size_safe_to_change(struct cifsInodeInfo * cifsInode)
++{
++	struct list_head *tmp;
++	struct list_head *tmp1;
++	struct cifsFileInfo *open_file = NULL;
++	int rc = TRUE;
++
++	if(cifsInode == NULL)
++		return rc;
++
++	read_lock(&GlobalSMBSeslock);
++	list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
++		open_file = list_entry(tmp,struct cifsFileInfo, flist);
++		if(open_file == NULL)
++			break;
++		if(open_file->closePend)
++			continue;
++	/* We check if file is open for writing,
++	BB we could supplement this with a check to see if file size
++	changes have been flushed to server - ie inode metadata dirty */
++		if((open_file->pfile) &&
++		   ((open_file->pfile->f_flags & O_RDWR) ||
++		    (open_file->pfile->f_flags & O_WRONLY))) {
++			rc = FALSE;
++			break;
++		}
++		if(tmp->next == NULL) {
++			cFYI(1,("File instance %p removed",tmp));
++			break;
++		}
++	}
++	read_unlock(&GlobalSMBSeslock);
++	return rc;
++}
++
++
++void
++fill_in_inode(struct inode *tmp_inode,
++	      FILE_DIRECTORY_INFO * pfindData, int *pobject_type)
++{
++	struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
++	struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
++
++	pfindData->ExtFileAttributes =
++	    le32_to_cpu(pfindData->ExtFileAttributes);
++	pfindData->AllocationSize = le64_to_cpu(pfindData->AllocationSize);
++	pfindData->EndOfFile = le64_to_cpu(pfindData->EndOfFile);
++	cifsInfo->cifsAttrs = pfindData->ExtFileAttributes;
++	cifsInfo->time = jiffies;
++
++	/* Linux can not store file creation time unfortunately so ignore it */
++	tmp_inode->i_atime =
++	    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
++	tmp_inode->i_mtime =
++	    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
++	tmp_inode->i_ctime =
++	    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
++	/* treat dos attribute of read-only as read-only mode bit e.g. 555? */
++	/* 2767 perms - indicate mandatory locking */
++		/* BB fill in uid and gid here? with help from winbind? 
++			or retrieve from NTFS stream extended attribute */
++	if(atomic_read(&cifsInfo->inUse) == 0) {
++		tmp_inode->i_uid = cifs_sb->mnt_uid;
++		tmp_inode->i_gid = cifs_sb->mnt_gid;
++		/* set default mode. will override for dirs below */
++		tmp_inode->i_mode = cifs_sb->mnt_file_mode;
++	}
++
++	cFYI(0,
++	     ("CIFS FFIRST: Attributes came in as 0x%x",
++	      pfindData->ExtFileAttributes));
++	if (pfindData->ExtFileAttributes & ATTR_REPARSE) {
++		*pobject_type = DT_LNK;
++		/* BB can this and S_IFREG or S_IFDIR be set as in Windows? */
++		tmp_inode->i_mode |= S_IFLNK;
++	} else if (pfindData->ExtFileAttributes & ATTR_DIRECTORY) {
++		*pobject_type = DT_DIR;
++		/* override default perms since we do not lock dirs */
++		if(atomic_read(&cifsInfo->inUse) == 0) {
++			tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
++		}
++		tmp_inode->i_mode |= S_IFDIR;
++	} else {
++		*pobject_type = DT_REG;
++		tmp_inode->i_mode |= S_IFREG;
++		if(pfindData->ExtFileAttributes & ATTR_READONLY)
++			tmp_inode->i_mode &= ~(S_IWUGO);
++
++	}/* could add code here - to validate if device or weird share type? */
++
++	/* can not fill in nlink here as in qpathinfo version and Unx search */
++	if(atomic_read(&cifsInfo->inUse) == 0) {
++		atomic_set(&cifsInfo->inUse,1);
++	}
++	if(is_size_safe_to_change(cifsInfo)) {
++		/* can not safely change the file size here if the
++		client is writing to it due to potential races */
++		tmp_inode->i_size = pfindData->EndOfFile;
++
++	/* 512 bytes (2**9) is the fake blocksize that must be used */
++	/* for this calculation, even though the reported blocksize is larger */
++		tmp_inode->i_blocks = (512 - 1 + pfindData->AllocationSize) >> 9;
++	}
++
++	if (pfindData->AllocationSize < pfindData->EndOfFile)
++		cFYI(1, ("Possible sparse file: allocation size less than end of file "));
++	cFYI(1,
++	     ("File Size %ld and blocks %ld and blocksize %ld",
++	      (unsigned long) tmp_inode->i_size, tmp_inode->i_blocks,
++	      tmp_inode->i_blksize));
++	if (S_ISREG(tmp_inode->i_mode)) {
++		cFYI(1, (" File inode "));
++		tmp_inode->i_op = &cifs_file_inode_ops;
++		tmp_inode->i_fop = &cifs_file_ops;
++		tmp_inode->i_data.a_ops = &cifs_addr_ops;
++	} else if (S_ISDIR(tmp_inode->i_mode)) {
++		cFYI(1, (" Directory inode"));
++		tmp_inode->i_op = &cifs_dir_inode_ops;
++		tmp_inode->i_fop = &cifs_dir_ops;
++	} else if (S_ISLNK(tmp_inode->i_mode)) {
++		cFYI(1, (" Symbolic Link inode "));
++		tmp_inode->i_op = &cifs_symlink_inode_ops;
++	} else {
++		cFYI(1, (" Init special inode "));
++		init_special_inode(tmp_inode, tmp_inode->i_mode,
++				   kdev_t_to_nr(tmp_inode->i_rdev));
++	}
++}
++
++void
++unix_fill_in_inode(struct inode *tmp_inode,
++		   FILE_UNIX_INFO * pfindData, int *pobject_type)
++{
++	struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
++	cifsInfo->time = jiffies;
++	atomic_inc(&cifsInfo->inUse);
++
++	tmp_inode->i_atime =
++	    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
++	tmp_inode->i_mtime =
++	    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastModificationTime));
++	tmp_inode->i_ctime =
++	    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastStatusChange));
++
++	tmp_inode->i_mode = le64_to_cpu(pfindData->Permissions);
++	pfindData->Type = le32_to_cpu(pfindData->Type);
++	if (pfindData->Type == UNIX_FILE) {
++		*pobject_type = DT_REG;
++		tmp_inode->i_mode |= S_IFREG;
++	} else if (pfindData->Type == UNIX_SYMLINK) {
++		*pobject_type = DT_LNK;
++		tmp_inode->i_mode |= S_IFLNK;
++	} else if (pfindData->Type == UNIX_DIR) {
++		*pobject_type = DT_DIR;
++		tmp_inode->i_mode |= S_IFDIR;
++	} else if (pfindData->Type == UNIX_CHARDEV) {
++		*pobject_type = DT_CHR;
++		tmp_inode->i_mode |= S_IFCHR;
++		tmp_inode->i_rdev = MKDEV(le64_to_cpu(pfindData->DevMajor),
++				le64_to_cpu(pfindData->DevMinor) & MINORMASK);
++	} else if (pfindData->Type == UNIX_BLOCKDEV) {
++		*pobject_type = DT_BLK;
++		tmp_inode->i_mode |= S_IFBLK;
++		tmp_inode->i_rdev = MKDEV(le64_to_cpu(pfindData->DevMajor),
++				le64_to_cpu(pfindData->DevMinor) & MINORMASK);
++	} else if (pfindData->Type == UNIX_FIFO) {
++		*pobject_type = DT_FIFO;
++		tmp_inode->i_mode |= S_IFIFO;
++	} else if (pfindData->Type == UNIX_SOCKET) {
++		*pobject_type = DT_SOCK;
++		tmp_inode->i_mode |= S_IFSOCK;
++	}
++
++	tmp_inode->i_uid = le64_to_cpu(pfindData->Uid);
++	tmp_inode->i_gid = le64_to_cpu(pfindData->Gid);
++	tmp_inode->i_nlink = le64_to_cpu(pfindData->Nlinks);
++
++	pfindData->NumOfBytes = le64_to_cpu(pfindData->NumOfBytes);
++	if(is_size_safe_to_change(cifsInfo)) {
++		/* can not safely change the file size here if the
++		client is writing to it due to potential races */
++		pfindData->EndOfFile = le64_to_cpu(pfindData->EndOfFile);
++		tmp_inode->i_size = pfindData->EndOfFile;
++
++	/* 512 bytes (2**9) is the fake blocksize that must be used */
++	/* for this calculation, not the real blocksize */
++		tmp_inode->i_blocks = (512 - 1 + pfindData->NumOfBytes) >> 9;
++	}
++
++	if (S_ISREG(tmp_inode->i_mode)) {
++		cFYI(1, ("File inode"));
++		tmp_inode->i_op = &cifs_file_inode_ops;
++		tmp_inode->i_fop = &cifs_file_ops;
++		tmp_inode->i_data.a_ops = &cifs_addr_ops;
++	} else if (S_ISDIR(tmp_inode->i_mode)) {
++		cFYI(1, ("Directory inode"));
++		tmp_inode->i_op = &cifs_dir_inode_ops;
++		tmp_inode->i_fop = &cifs_dir_ops;
++	} else if (S_ISLNK(tmp_inode->i_mode)) {
++		cFYI(1, ("Symbolic Link inode"));
++		tmp_inode->i_op = &cifs_symlink_inode_ops;
++/* tmp_inode->i_fop = *//* do not need to set to anything */
++	} else {
++		cFYI(1, ("Special inode")); 
++		init_special_inode(tmp_inode, tmp_inode->i_mode,
++				   kdev_t_to_nr(tmp_inode->i_rdev));
++	}
++}
++
++static void
++construct_dentry(struct qstr *qstring, struct file *file,
++		 struct inode **ptmp_inode, struct dentry **pnew_dentry)
++{
++	struct dentry *tmp_dentry;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct cifsInodeInfo *pCifsI;
++
++	cFYI(1, ("For %s ", qstring->name));
++	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
++	pTcon = cifs_sb->tcon;
++
++	qstring->hash = full_name_hash(qstring->name, qstring->len);
++	tmp_dentry = d_lookup(file->f_dentry, qstring);
++	if (tmp_dentry) {
++		cFYI(0, (" existing dentry with inode 0x%p", tmp_dentry->d_inode));
++		*ptmp_inode = tmp_dentry->d_inode;
++		/* BB overwrite the old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len ?? */
++		if(*ptmp_inode == NULL) {
++			*ptmp_inode = new_inode(file->f_dentry->d_sb);
++			if(*ptmp_inode == NULL)
++				return;
++			d_instantiate(tmp_dentry, *ptmp_inode);
++			insert_inode_hash(*ptmp_inode);
++			pCifsI = CIFS_I(*ptmp_inode);
++			INIT_LIST_HEAD(&pCifsI->openFileList);
++			/* can not enable caching for this inode
++			until a file instance is open and we
++			can check the oplock flag on the open
++			response */
++			(*ptmp_inode)->i_blksize = CIFS_MAX_MSGSIZE;
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,15))
++			(*ptmp_inode)->i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
++#endif
++			pCifsI->clientCanCacheRead = FALSE;
++			pCifsI->clientCanCacheAll = FALSE;
++			pCifsI->time = 0;
++			/* do not need to set cifs Attrs since
++			they are about to be overwritten
++			in fill_in_inode */
++			atomic_set(&pCifsI->inUse, 0);
++		}
++	} else {
++		tmp_dentry = d_alloc(file->f_dentry, qstring);
++		if(tmp_dentry == NULL) {
++			cERROR(1,("Failed allocating dentry"));
++			return;
++		}
++
++		if(ptmp_inode) {			
++			*ptmp_inode = new_inode(file->f_dentry->d_sb);
++			if(*ptmp_inode == NULL)
++				return;
++			pCifsI = CIFS_I(*ptmp_inode);
++			insert_inode_hash(*ptmp_inode);
++			INIT_LIST_HEAD(&pCifsI->openFileList);
++			/* can not enable caching for this inode 
++			until a file instance is open and we
++			can check the oplock flag on the open
++			response */
++	                (*ptmp_inode)->i_blksize = CIFS_MAX_MSGSIZE;
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,15))
++			(*ptmp_inode)->i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
++#endif
++			pCifsI->clientCanCacheRead = FALSE;
++			pCifsI->clientCanCacheAll = FALSE;
++			pCifsI->time = 0;
++			/* do not need to set cifs Attrs since
++				they are about to be overwritten 
++				in fill_in_inode */
++			atomic_set(&pCifsI->inUse, 0);
++		}
++		tmp_dentry->d_op = &cifs_dentry_ops;
++		d_instantiate(tmp_dentry, *ptmp_inode);
++		d_rehash(tmp_dentry);
++	}
++
++	tmp_dentry->d_time = jiffies;
++	*pnew_dentry = tmp_dentry;
++}
++
++static void reset_resume_key(struct file * dir_file, 
++				unsigned char * filename, 
++				unsigned int len,int Unicode,struct nls_table * nls_tab) {
++	struct cifsFileInfo *cifsFile;
++
++	cifsFile = (struct cifsFileInfo *)dir_file->private_data;
++	if(cifsFile == NULL)
++		return;
++	if(cifsFile->search_resume_name) {
++		kfree(cifsFile->search_resume_name);
++	}
++
++	if(Unicode) 
++		len *= 2;
++	cifsFile->resume_name_length = len;
++
++	cifsFile->search_resume_name = 
++		kmalloc(cifsFile->resume_name_length, GFP_KERNEL);
++
++	if(cifsFile->search_resume_name == NULL) {
++		cERROR(1,("failed new resume key allocate, length %d",
++				  cifsFile->resume_name_length));
++		return;
++	}
++	if(Unicode)
++		cifs_strtoUCS((wchar_t *) cifsFile->search_resume_name,
++			filename, len, nls_tab);
++	else
++		memcpy(cifsFile->search_resume_name, filename, 
++		   cifsFile->resume_name_length);
++	cFYI(1,("Reset resume key to: %s with len %d",filename,len));
++	return;
++}
++
++
++
++static int
++cifs_filldir(struct qstr *pqstring, FILE_DIRECTORY_INFO * pfindData,
++	     struct file *file, filldir_t filldir, void *direntry)
++{
++	struct inode *tmp_inode;
++	struct dentry *tmp_dentry;
++	int object_type,rc;
++
++	pqstring->name = pfindData->FileName;
++	pqstring->len = pfindData->FileNameLength;
++
++	construct_dentry(pqstring, file, &tmp_inode, &tmp_dentry);
++	if((tmp_inode == NULL) || (tmp_dentry == NULL)) {
++		return -ENOMEM;
++	}
++	fill_in_inode(tmp_inode, pfindData, &object_type);
++	rc = filldir(direntry, pfindData->FileName, pqstring->len, file->f_pos,
++		tmp_inode->i_ino, object_type);
++	if(rc) {
++		/* due to readdir error we need to recalculate resume 
++		key so next readdir will restart on right entry */
++		cFYI(1,("Error %d on filldir of %s",rc ,pfindData->FileName));
++	}
++	dput(tmp_dentry);
++	return rc;
++}
++
++static int
++cifs_filldir_unix(struct qstr *pqstring,
++		  FILE_UNIX_INFO * pUnixFindData, struct file *file,
++		  filldir_t filldir, void *direntry)
++{
++	struct inode *tmp_inode;
++	struct dentry *tmp_dentry;
++	int object_type, rc;
++
++	pqstring->name = pUnixFindData->FileName;
++	pqstring->len = strnlen(pUnixFindData->FileName, MAX_PATHCONF);
++
++	construct_dentry(pqstring, file, &tmp_inode, &tmp_dentry);
++        if((tmp_inode == NULL) || (tmp_dentry == NULL)) {
++                return -ENOMEM;
++        }
++
++	unix_fill_in_inode(tmp_inode, pUnixFindData, &object_type);
++	rc = filldir(direntry, pUnixFindData->FileName, pqstring->len,
++		file->f_pos, tmp_inode->i_ino, object_type);
++	if(rc) {
++		/* due to readdir error we need to recalculate resume 
++			key so next readdir will restart on right entry */
++		cFYI(1,("Error %d on filldir of %s",rc ,pUnixFindData->FileName));
++	}
++	dput(tmp_dentry);
++	return rc;
++}
++
++int
++cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
++{
++	int rc = 0;
++	int xid;
++	int Unicode = FALSE;
++	int UnixSearch = FALSE;
++	unsigned int bufsize, i;
++	__u16 searchHandle;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct cifsFileInfo *cifsFile = NULL;
++	char *full_path = NULL;
++	char *data;
++	struct qstr qstring;
++	T2_FFIRST_RSP_PARMS findParms;
++	T2_FNEXT_RSP_PARMS findNextParms;
++	FILE_DIRECTORY_INFO *pfindData;
++	FILE_DIRECTORY_INFO *lastFindData;
++	FILE_UNIX_INFO *pfindDataUnix;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(file->f_dentry->d_sb);
++	pTcon = cifs_sb->tcon;
++	bufsize = pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE;
++	if(bufsize > CIFS_MAX_MSGSIZE) {
++		FreeXid(xid);
++		return -EIO;
++	}
++	data = kmalloc(bufsize, GFP_KERNEL);
++	pfindData = (FILE_DIRECTORY_INFO *) data;
++
++	if(file->f_dentry == NULL) {
++		FreeXid(xid);
++		return -EIO;
++	}
++	down(&file->f_dentry->d_sb->s_vfs_rename_sem);
++	full_path = build_wildcard_path_from_dentry(file->f_dentry);
++	up(&file->f_dentry->d_sb->s_vfs_rename_sem);
++
++
++	cFYI(1, ("Full path: %s start at: %lld ", full_path, file->f_pos));
++
++	switch ((int) file->f_pos) {
++	case 0:
++		if (filldir(direntry, ".", 1, file->f_pos,
++		     file->f_dentry->d_inode->i_ino, DT_DIR) < 0) {
++			cERROR(1, ("Filldir for current dir failed "));
++			break;
++		}
++		file->f_pos++;
++		/* fallthrough */
++	case 1:
++		if (filldir(direntry, "..", 2, file->f_pos,
++		     file->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
++			cERROR(1, ("Filldir for parent dir failed "));
++			break;
++		}
++		file->f_pos++;
++		/* fallthrough */
++	case 2:
++		if (file->private_data != NULL) {
++			cifsFile =
++				(struct cifsFileInfo *) file->private_data;
++			if (cifsFile->endOfSearch) {
++				if(cifsFile->emptyDir) {
++					cFYI(1, ("End of search, empty dir"));
++					rc = 0;
++					break;
++				}
++			} else {
++				cifsFile->invalidHandle = TRUE;
++				CIFSFindClose(xid, pTcon, cifsFile->netfid);
++			}
++			if(cifsFile->search_resume_name) {
++				kfree(cifsFile->search_resume_name);
++				cifsFile->search_resume_name = NULL;
++			}
++		}
++		rc = CIFSFindFirst(xid, pTcon, full_path, pfindData,
++				&findParms, cifs_sb->local_nls,
++				&Unicode, &UnixSearch);
++		cFYI(1, ("Count: %d  End: %d ", findParms.SearchCount,
++			findParms.EndofSearch));
++ 
++		if (rc == 0) {
++			searchHandle = findParms.SearchHandle;
++			if(file->private_data == NULL)
++				file->private_data =
++					kmalloc(sizeof(struct cifsFileInfo),GFP_KERNEL);
++			if (file->private_data) {
++				memset(file->private_data, 0,
++				       sizeof (struct cifsFileInfo));
++				cifsFile =
++				    (struct cifsFileInfo *) file->private_data;
++				cifsFile->netfid = searchHandle;
++				cifsFile->invalidHandle = FALSE;
++				init_MUTEX(&cifsFile->fh_sem);
++			} else {
++				rc = -ENOMEM;
++				break;
++			}
++
++			renew_parental_timestamps(file->f_dentry);
++			lastFindData = 
++				(FILE_DIRECTORY_INFO *) ((char *) pfindData + 
++					findParms.LastNameOffset);
++			if((char *)lastFindData > (char *)pfindData + bufsize) {
++				cFYI(1,("last search entry past end of packet"));
++				rc = -EIO;
++				break;
++			}
++			/* Offset of resume key same for levels 257 and 514 */
++			cifsFile->resume_key = lastFindData->FileIndex;
++			if(UnixSearch == FALSE) {
++				cifsFile->resume_name_length = 
++					le32_to_cpu(lastFindData->FileNameLength);
++				if(cifsFile->resume_name_length > bufsize - 64) {
++					cFYI(1,("Illegal resume file name length %d",
++						cifsFile->resume_name_length));
++					rc = -ENOMEM;
++					break;
++				}
++				cifsFile->search_resume_name = 
++					kmalloc(cifsFile->resume_name_length, GFP_KERNEL);
++				cFYI(1,("Last file: %s with name %d bytes long",
++					lastFindData->FileName,
++					cifsFile->resume_name_length));
++				memcpy(cifsFile->search_resume_name,
++					lastFindData->FileName, 
++					cifsFile->resume_name_length);
++			} else {
++				pfindDataUnix = (FILE_UNIX_INFO *)lastFindData;
++				if (Unicode == TRUE) {
++					for(i=0;(pfindDataUnix->FileName[i] 
++						    | pfindDataUnix->FileName[i+1]);
++						i+=2) {
++						if(i > bufsize-64)
++							break;
++					}
++					cifsFile->resume_name_length = i + 2;
++				} else {
++					cifsFile->resume_name_length = 
++						strnlen(pfindDataUnix->FileName,
++							bufsize-63);
++				}
++				if(cifsFile->resume_name_length > bufsize - 64) {
++					cFYI(1,("Illegal resume file name length %d",
++						cifsFile->resume_name_length));
++					rc = -ENOMEM;
++					break;
++				}
++				cifsFile->search_resume_name = 
++					kmalloc(cifsFile->resume_name_length, GFP_KERNEL);
++				cFYI(1,("Last file: %s with name %d bytes long",
++					pfindDataUnix->FileName,
++					cifsFile->resume_name_length));
++				memcpy(cifsFile->search_resume_name,
++					pfindDataUnix->FileName, 
++					cifsFile->resume_name_length);
++			}
++			for (i = 2; i < (unsigned int)findParms.SearchCount + 2; i++) {
++				if (UnixSearch == FALSE) {
++					pfindData->FileNameLength =
++					  le32_to_cpu(pfindData->FileNameLength);
++					if (Unicode == TRUE)
++						pfindData->FileNameLength =
++						    cifs_strfromUCS_le
++						    (pfindData->FileName,
++						     (wchar_t *)
++						     pfindData->FileName,
++						     (pfindData->
++						      FileNameLength) / 2,
++						     cifs_sb->local_nls);
++					qstring.len = pfindData->FileNameLength;
++					if (((qstring.len != 1)
++					     || (pfindData->FileName[0] != '.'))
++					    && ((qstring.len != 2)
++						|| (pfindData->
++						    FileName[0] != '.')
++						|| (pfindData->
++						    FileName[1] != '.'))) {
++						if(cifs_filldir(&qstring,
++							     pfindData,
++							     file, filldir,
++							     direntry)) {
++							/* do not end search if
++								kernel not ready to take
++								remaining entries yet */
++							reset_resume_key(file, pfindData->FileName,qstring.len,
++								Unicode, cifs_sb->local_nls);
++							findParms.EndofSearch = 0;
++							break;
++						}
++						file->f_pos++;
++					}
++				} else {	/* UnixSearch */
++					pfindDataUnix =
++					    (FILE_UNIX_INFO *) pfindData;
++					if (Unicode == TRUE)
++						qstring.len =
++							cifs_strfromUCS_le
++							(pfindDataUnix->FileName,
++							(wchar_t *)
++							pfindDataUnix->FileName,
++							MAX_PATHCONF,
++							cifs_sb->local_nls);
++					else
++						qstring.len =
++							strnlen(pfindDataUnix->
++							  FileName,
++							  MAX_PATHCONF);
++					if (((qstring.len != 1)
++					     || (pfindDataUnix->
++						 FileName[0] != '.'))
++					    && ((qstring.len != 2)
++						|| (pfindDataUnix->
++						    FileName[0] != '.')
++						|| (pfindDataUnix->
++						    FileName[1] != '.'))) {
++						if(cifs_filldir_unix(&qstring,
++								  pfindDataUnix,
++								  file,
++								  filldir,
++								  direntry)) {
++							/* do not end search if
++								kernel not ready to take
++								remaining entries yet */
++							findParms.EndofSearch = 0;
++							reset_resume_key(file, pfindDataUnix->FileName,
++								qstring.len,Unicode,cifs_sb->local_nls);
++							break;
++						}
++						file->f_pos++;
++					}
++				}
++				/* works also for Unix ff struct since first field of both */
++				pfindData = 
++					(FILE_DIRECTORY_INFO *) ((char *) pfindData
++						 + le32_to_cpu(pfindData->NextEntryOffset));
++				/* BB also should check to make sure that pointer is not beyond the end of the SMB */
++				/* if(pfindData > lastFindData) rc = -EIO; break; */
++			}	/* end for loop */
++			if ((findParms.EndofSearch != 0) && cifsFile) {
++				cifsFile->endOfSearch = TRUE;
++				if(findParms.SearchCount == 2)
++					cifsFile->emptyDir = TRUE;
++			}
++		} else {
++			if (cifsFile)
++				cifsFile->endOfSearch = TRUE;
++			/* unless parent directory gone do not return error */
++			rc = 0;
++		}
++		break;
++	default:
++		if (file->private_data == NULL) {
++			rc = -EBADF;
++			cFYI(1,
++			     ("Readdir on closed srch, pos = %lld",
++			      file->f_pos));
++		} else {
++			cifsFile = (struct cifsFileInfo *) file->private_data;
++			if (cifsFile->endOfSearch) {
++				rc = 0;
++				cFYI(1, ("End of search "));
++				break;
++			}
++			searchHandle = cifsFile->netfid;
++			rc = CIFSFindNext(xid, pTcon, pfindData,
++				&findNextParms, searchHandle, 
++				cifsFile->search_resume_name,
++				cifsFile->resume_name_length,
++				cifsFile->resume_key,
++				&Unicode, &UnixSearch);
++			cFYI(1,("Count: %d  End: %d ",
++			      findNextParms.SearchCount,
++			      findNextParms.EndofSearch));
++			if ((rc == 0) && (findNextParms.SearchCount != 0)) {
++			/* BB save off resume key, key name and name length  */
++				lastFindData = 
++					(FILE_DIRECTORY_INFO *) ((char *) pfindData 
++						+ findNextParms.LastNameOffset);
++				if((char *)lastFindData > (char *)pfindData + bufsize) {
++					cFYI(1,("last search entry past end of packet"));
++					rc = -EIO;
++					break;
++				}
++				/* Offset of resume key same for levels 257 and 514 */
++				cifsFile->resume_key = lastFindData->FileIndex;
++
++				if(UnixSearch == FALSE) {
++					cifsFile->resume_name_length = 
++						le32_to_cpu(lastFindData->FileNameLength);
++					if(cifsFile->resume_name_length > bufsize - 64) {
++						cFYI(1,("Illegal resume file name length %d",
++							cifsFile->resume_name_length));
++						rc = -ENOMEM;
++						break;
++					}
++					/* Free the memory allocated by previous findfirst 
++					or findnext call - we can not reuse the memory since
++					the resume name may not be same string length */
++					if(cifsFile->search_resume_name)
++						kfree(cifsFile->search_resume_name);
++					cifsFile->search_resume_name = 
++						kmalloc(cifsFile->resume_name_length, GFP_KERNEL);
++					cFYI(1,("Last file: %s with name %d bytes long",
++						lastFindData->FileName,
++						cifsFile->resume_name_length));
++					memcpy(cifsFile->search_resume_name,
++						lastFindData->FileName, 
++						cifsFile->resume_name_length);
++				} else {
++					pfindDataUnix = (FILE_UNIX_INFO *)lastFindData;
++					if (Unicode == TRUE) {
++						for(i=0;(pfindDataUnix->FileName[i] 
++								| pfindDataUnix->FileName[i+1]);
++							i+=2) {
++							if(i > bufsize-64)
++								break;
++						}
++						cifsFile->resume_name_length = i + 2;
++					} else {
++						cifsFile->resume_name_length = 
++							strnlen(pfindDataUnix->
++							 FileName,
++							 MAX_PATHCONF);
++					}
++					if(cifsFile->resume_name_length > bufsize - 64) {
++						cFYI(1,("Illegal resume file name length %d",
++								cifsFile->resume_name_length));
++						rc = -ENOMEM;
++						break;
++					}
++					/* Free the memory allocated by previous findfirst 
++					or findnext call - we can not reuse the memory since
++					the resume name may not be same string length */
++					if(cifsFile->search_resume_name)
++						kfree(cifsFile->search_resume_name);
++					cifsFile->search_resume_name = 
++						kmalloc(cifsFile->resume_name_length, GFP_KERNEL);
++					cFYI(1,("fnext last file: %s with name %d bytes long",
++						pfindDataUnix->FileName,
++						cifsFile->resume_name_length));
++					memcpy(cifsFile->search_resume_name,
++						pfindDataUnix->FileName, 
++						cifsFile->resume_name_length);
++				}
++
++				for (i = 0; i < findNextParms.SearchCount; i++) {
++					pfindData->FileNameLength =
++					    le32_to_cpu(pfindData->
++							FileNameLength);
++					if (UnixSearch == FALSE) {
++						if (Unicode == TRUE)
++							pfindData->FileNameLength =
++							  cifs_strfromUCS_le
++							  (pfindData->FileName,
++							  (wchar_t *)
++							  pfindData->FileName,
++							  (pfindData->FileNameLength)/ 2,
++							  cifs_sb->local_nls);
++						qstring.len = 
++							pfindData->FileNameLength;
++						if (((qstring.len != 1)
++						    || (pfindData->FileName[0] != '.'))
++						    && ((qstring.len != 2)
++							|| (pfindData->FileName[0] != '.')
++							|| (pfindData->FileName[1] !=
++							    '.'))) {
++							if(cifs_filldir
++							    (&qstring,
++							     pfindData,
++							     file, filldir,
++							     direntry)) {
++							/* do not end search if
++								kernel not ready to take
++								remaining entries yet */
++								findNextParms.EndofSearch = 0;
++								reset_resume_key(file, pfindData->FileName,qstring.len,
++									Unicode,cifs_sb->local_nls);
++								break;
++							}
++							file->f_pos++;
++						}
++					} else {	/* UnixSearch */
++						pfindDataUnix =
++						    (FILE_UNIX_INFO *)
++						    pfindData;
++						if (Unicode == TRUE)
++							qstring.len =
++							  cifs_strfromUCS_le
++							  (pfindDataUnix->FileName,
++							  (wchar_t *)
++							  pfindDataUnix->FileName,
++							  MAX_PATHCONF,
++							  cifs_sb->local_nls);
++						else
++							qstring.len =
++							  strnlen
++							  (pfindDataUnix->
++							  FileName,
++							  MAX_PATHCONF);
++						if (((qstring.len != 1)
++						     || (pfindDataUnix->
++							 FileName[0] != '.'))
++						    && ((qstring.len != 2)
++							|| (pfindDataUnix->
++							    FileName[0] != '.')
++							|| (pfindDataUnix->
++							    FileName[1] !=
++							    '.'))) {
++							if(cifs_filldir_unix
++							    (&qstring,
++							     pfindDataUnix,
++							     file, filldir,
++							     direntry)) {
++								/* do not end search if
++								kernel not ready to take
++								remaining entries yet */
++								findNextParms.EndofSearch = 0;
++								reset_resume_key(file, pfindDataUnix->FileName,qstring.len,
++									Unicode,cifs_sb->local_nls);
++								break;
++							}
++							file->f_pos++;
++						}
++					}
++					pfindData = (FILE_DIRECTORY_INFO *) ((char *) pfindData + le32_to_cpu(pfindData->NextEntryOffset));	/* works also for Unix find struct since this is the first field of both */
++					/* BB also should check to make sure that pointer is not beyond the end of the SMB */
++				} /* end for loop */
++				if (findNextParms.EndofSearch != 0) {
++					cifsFile->endOfSearch = TRUE;
++				}
++			} else {
++				cifsFile->endOfSearch = TRUE;
++				rc = 0;	/* unless parent directory disappeared - do not return error here (eg Access Denied or no more files) */
++			}
++		}
++	} /* end switch */
++	if (data)
++		kfree(data);
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++
++	return rc;
++}
++int cifs_prepare_write(struct file *file, struct page *page,
++			unsigned from, unsigned to)
++{
++	int rc = 0;
++        loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
++	cFYI(1,("prepare write for page %p from %d to %d",page,from,to));
++	if (!Page_Uptodate(page)) {
++	/*	if (to - from != PAGE_CACHE_SIZE) {
++			void *kaddr = kmap_atomic(page, KM_USER0);
++			memset(kaddr, 0, from);
++			memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
++			flush_dcache_page(page);
++			kunmap_atomic(kaddr, KM_USER0);
++		} */
++		/* If we are writing a full page it will be up to date,
++		no need to read from the server */
++		if((to==PAGE_CACHE_SIZE) && (from == 0))
++			SetPageUptodate(page);
++
++		/* might as well read a page, it is fast enough */
++		if((file->f_flags & O_ACCMODE) != O_WRONLY) {
++			rc = cifs_readpage_worker(file,page,&offset);
++		} else {
++		/* should we try using another
++		file handle if there is one - how would we lock it
++		to prevent close of that handle racing with this read? */
++		/* In any case this will be written out by commit_write */
++		}
++	}
++
++	/* BB should we pass any errors back? e.g. if we do not have read access to the file */
++	return 0;
++}
++
++
++struct address_space_operations cifs_addr_ops = {
++	.readpage = cifs_readpage,
++/*	.readpages = cifs_readpages, */
++	.writepage = cifs_writepage,
++	.prepare_write = cifs_prepare_write, 
++	.commit_write = cifs_commit_write,
++	.sync_page = cifs_sync_page,
++	/*.direct_IO = */
++};
+diff -urN linux-2.4.29.old/fs/cifs/inode.c linux-2.4.29/fs/cifs/inode.c
+--- linux-2.4.29.old/fs/cifs/inode.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/inode.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,1079 @@
++/*
++ *   fs/cifs/inode.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++#include <linux/fs.h>
++#include <linux/stat.h>
++#include <linux/pagemap.h>
++#include <linux/version.h>
++#include <asm/div64.h>
++#include "cifsfs.h"
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_debug.h"
++#include "cifs_fs_sb.h"
++
++extern int is_size_safe_to_change(struct cifsInodeInfo *);
++
++struct inode * get_cifs_inode(struct super_block * sb)
++{
++	struct inode * newinode;
++	newinode = new_inode(sb);
++	cFYI(1,("got new inode %p",newinode));
++	if(newinode) {    
++		struct cifsInodeInfo * cifsInfo = CIFS_I(newinode);
++		cifsInfo->clientCanCacheRead = FALSE;
++		cifsInfo->clientCanCacheAll = FALSE;
++		INIT_LIST_HEAD(&cifsInfo->openFileList);
++		cifsInfo->cifsAttrs = 0x20;   /* default */
++		newinode->i_blksize = CIFS_MAX_MSGSIZE;
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,15))
++		newinode->i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
++#endif
++		atomic_set(&cifsInfo->inUse, 0);
++		cifsInfo->time = 0;
++		insert_inode_hash(newinode);
++	}
++	return newinode;
++
++}
++
++int
++cifs_get_inode_info_unix(struct inode **pinode,
++			 const unsigned char *search_path,
++			 struct super_block *sb,int xid)
++{
++	int rc = 0;
++	FILE_UNIX_BASIC_INFO findData;
++	struct cifsTconInfo *pTcon;
++	struct inode *inode;
++	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
++	char *tmp_path;
++
++	pTcon = cifs_sb->tcon;
++	cFYI(1, (" Getting info on %s ", search_path));
++	/* we could have done a find first instead but this returns more info */
++	rc = CIFSSMBUnixQPathInfo(xid, pTcon, search_path, &findData,
++				  cifs_sb->local_nls);
++	/* dump_mem("\nUnixQPathInfo return data", &findData, sizeof(findData)); */
++	if (rc) {
++		if (rc == -EREMOTE) {
++			tmp_path =
++			    kmalloc(strnlen
++				    (pTcon->treeName,
++				     MAX_TREE_SIZE + 1) +
++				    strnlen(search_path, MAX_PATHCONF) + 1,
++				    GFP_KERNEL);
++			if (tmp_path == NULL) {
++				return -ENOMEM;
++			}
++        /* have to skip first of the double backslash of UNC name */
++			strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);	
++			strncat(tmp_path, search_path, MAX_PATHCONF);
++			rc = connect_to_dfs_path(xid, pTcon->ses,
++						 /* treename + */ tmp_path,
++						 cifs_sb->local_nls);
++			kfree(tmp_path);
++
++			/* BB fix up inode etc. */
++		} else if (rc) {
++			return rc;
++		}
++
++	} else {
++		struct cifsInodeInfo *cifsInfo;
++
++		/* get new inode */
++		if (*pinode == NULL) {
++			*pinode = get_cifs_inode(sb);
++		}
++		if(*pinode == NULL) {
++			return -ENOMEM;
++		}
++			
++		inode = *pinode;
++		cifsInfo = CIFS_I(inode);
++
++		cFYI(1, (" Old time %ld ", cifsInfo->time));
++		cifsInfo->time = jiffies;
++		cFYI(1, (" New time %ld ", cifsInfo->time));
++		atomic_set(&cifsInfo->inUse,1);	/* ok to set on every refresh of inode */
++
++		inode->i_atime =
++		    cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
++		inode->i_mtime =
++		    cifs_NTtimeToUnix(le64_to_cpu
++				(findData.LastModificationTime));
++		inode->i_ctime =
++		    cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
++		inode->i_mode = le64_to_cpu(findData.Permissions);
++		findData.Type = le32_to_cpu(findData.Type);
++		if (findData.Type == UNIX_FILE) {
++			inode->i_mode |= S_IFREG;
++		} else if (findData.Type == UNIX_SYMLINK) {
++			inode->i_mode |= S_IFLNK;
++		} else if (findData.Type == UNIX_DIR) {
++			inode->i_mode |= S_IFDIR;
++		} else if (findData.Type == UNIX_CHARDEV) {
++			inode->i_mode |= S_IFCHR;
++			inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
++				le64_to_cpu(findData.DevMinor) & MINORMASK);
++		} else if (findData.Type == UNIX_BLOCKDEV) {
++			inode->i_mode |= S_IFBLK;
++			inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
++				le64_to_cpu(findData.DevMinor) & MINORMASK);
++		} else if (findData.Type == UNIX_FIFO) {
++			inode->i_mode |= S_IFIFO;
++		} else if (findData.Type == UNIX_SOCKET) {
++			inode->i_mode |= S_IFSOCK;
++		}
++		inode->i_uid = le64_to_cpu(findData.Uid);
++		inode->i_gid = le64_to_cpu(findData.Gid);
++		inode->i_nlink = le64_to_cpu(findData.Nlinks);
++		findData.NumOfBytes = le64_to_cpu(findData.NumOfBytes);
++		findData.EndOfFile = le64_to_cpu(findData.EndOfFile);
++
++		if(is_size_safe_to_change(cifsInfo)) {
++		/* can not safely change the file size here if the
++		   client is writing to it due to potential races */
++			inode->i_size = findData.EndOfFile;
++/* blksize needs to be multiple of two. So safer to default to blksize
++	and blkbits set in superblock so 2**blkbits and blksize will match */
++/*		inode->i_blksize =
++		    (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
++
++		/* This seems incredibly stupid but it turns out that
++		i_blocks is not related to (i_size / i_blksize), instead a
++		size of 512 is required to be used for calculating num blocks */
++		 
++
++/*		inode->i_blocks = 
++	                (inode->i_blksize - 1 + findData.NumOfBytes) >> inode->i_blkbits;*/
++
++		/* 512 bytes (2**9) is the fake blocksize that must be used */
++		/* for this calculation */
++			inode->i_blocks = (512 - 1 + findData.NumOfBytes) >> 9;
++		}
++
++		if (findData.NumOfBytes < findData.EndOfFile)
++			cFYI(1, ("Server inconsistency Error: it says allocation size less than end of file "));
++		cFYI(1,
++		     ("Size %ld and blocks %ld ",
++		      (unsigned long) inode->i_size, inode->i_blocks));
++		if (S_ISREG(inode->i_mode)) {
++			cFYI(1, (" File inode "));
++			inode->i_op = &cifs_file_inode_ops;
++			inode->i_fop = &cifs_file_ops;
++			inode->i_data.a_ops = &cifs_addr_ops;
++		} else if (S_ISDIR(inode->i_mode)) {
++			cFYI(1, (" Directory inode"));
++			inode->i_op = &cifs_dir_inode_ops;
++			inode->i_fop = &cifs_dir_ops;
++		} else if (S_ISLNK(inode->i_mode)) {
++			cFYI(1, (" Symbolic Link inode "));
++			inode->i_op = &cifs_symlink_inode_ops;
++/* tmp_inode->i_fop = *//* do not need to set to anything */
++		} else {
++			cFYI(1, (" Init special inode "));
++			init_special_inode(inode, inode->i_mode,
++					   kdev_t_to_nr(inode->i_rdev));
++		}
++	}
++	return rc;
++}
++
++int
++cifs_get_inode_info(struct inode **pinode, const unsigned char *search_path, 
++		FILE_ALL_INFO * pfindData, struct super_block *sb, int xid)
++{
++	int rc = 0;
++	struct cifsTconInfo *pTcon;
++	struct inode *inode;
++	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
++	char *tmp_path;
++	char *buf = NULL;
++
++	pTcon = cifs_sb->tcon;
++	cFYI(1,("Getting info on %s ", search_path));
++
++	if((pfindData == NULL) && (*pinode != NULL)) {
++		if(CIFS_I(*pinode)->clientCanCacheRead) {
++			cFYI(1,("No need to revalidate inode sizes on cached file "));
++			return rc;
++		}
++	}
++
++	/* if file info not passed in then get it from server */
++	if(pfindData == NULL) {
++		buf = kmalloc(sizeof(FILE_ALL_INFO),GFP_KERNEL);
++		pfindData = (FILE_ALL_INFO *)buf;
++	/* could do find first instead but this returns more info */
++		rc = CIFSSMBQPathInfo(xid, pTcon, search_path, pfindData,
++			      cifs_sb->local_nls);
++	}
++	/* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
++	if (rc) {
++		if (rc == -EREMOTE) {
++			tmp_path =
++			    kmalloc(strnlen
++				    (pTcon->treeName,
++				     MAX_TREE_SIZE + 1) +
++				    strnlen(search_path, MAX_PATHCONF) + 1,
++				    GFP_KERNEL);
++			if (tmp_path == NULL) {
++				if(buf)
++					kfree(buf);
++				return -ENOMEM;
++			}
++
++			strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
++			strncat(tmp_path, search_path, MAX_PATHCONF);
++			rc = connect_to_dfs_path(xid, pTcon->ses,
++						 /* treename + */ tmp_path,
++						 cifs_sb->local_nls);
++			kfree(tmp_path);
++			/* BB fix up inode etc. */
++		} else if (rc) {
++			if(buf)
++				kfree(buf);
++			return rc;
++		}
++	} else {
++		struct cifsInodeInfo *cifsInfo;
++
++		/* get new inode */
++		if (*pinode == NULL) {
++			*pinode = get_cifs_inode(sb);
++		}
++		if(*pinode == NULL)
++			return -ENOMEM;
++		inode = *pinode;
++		cifsInfo = CIFS_I(inode);
++		pfindData->Attributes = le32_to_cpu(pfindData->Attributes);
++		cifsInfo->cifsAttrs = pfindData->Attributes;
++		cFYI(1, (" Old time %ld ", cifsInfo->time));
++		cifsInfo->time = jiffies;
++		cFYI(1, (" New time %ld ", cifsInfo->time));
++
++/* blksize needs to be multiple of two. So safer to default to blksize
++        and blkbits set in superblock so 2**blkbits and blksize will match */
++/*		inode->i_blksize =
++		    (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
++
++		/* Linux can not store file creation time unfortunately so we ignore it */
++		inode->i_atime =
++		    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
++		inode->i_mtime =
++		    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
++		inode->i_ctime =
++		    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
++		cFYI(0,
++		     (" Attributes came in as 0x%x ", pfindData->Attributes));
++
++		/* set default mode. will override for dirs below */
++		if(atomic_read(&cifsInfo->inUse) == 0)
++			/* new inode, can safely set these fields */
++			inode->i_mode = cifs_sb->mnt_file_mode;
++
++		if (pfindData->Attributes & ATTR_REPARSE) {
++	/* Can IFLNK be set as it basically is on windows with IFREG or IFDIR? */
++			inode->i_mode |= S_IFLNK;
++		} else if (pfindData->Attributes & ATTR_DIRECTORY) {
++	/* override default perms since we do not do byte range locking on dirs */
++			inode->i_mode = cifs_sb->mnt_dir_mode;
++			inode->i_mode |= S_IFDIR;
++		} else {
++			inode->i_mode |= S_IFREG;
++			/* treat the dos attribute of read-only as read-only mode e.g. 555 */
++			if(cifsInfo->cifsAttrs & ATTR_READONLY)
++				inode->i_mode &= ~(S_IWUGO);
++   /* BB add code here - validate if device or weird share or device type? */
++		}
++		if(is_size_safe_to_change(cifsInfo)) {
++		/* can not safely change the file size here if the
++		client is writing to it due to potential races */
++			inode->i_size = le64_to_cpu(pfindData->EndOfFile);
++
++		/* 512 bytes (2**9) is the fake blocksize that must be used */
++		/* for this calculation */
++			inode->i_blocks = (512 - 1 + pfindData->AllocationSize)
++				 >> 9;
++		}
++                pfindData->AllocationSize = le64_to_cpu(pfindData->AllocationSize);
++
++		cFYI(1,
++		     (" Size %ld and blocks %ld ",
++		      (unsigned long) inode->i_size, inode->i_blocks));
++		inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
++
++		/* BB fill in uid and gid here? with help from winbind? 
++			or retrieve from NTFS stream extended attribute */
++		if(atomic_read(&cifsInfo->inUse) == 0) {
++			inode->i_uid = cifs_sb->mnt_uid;
++			inode->i_gid = cifs_sb->mnt_gid;
++			/* set so we do not keep refreshing these fields with
++			bad data after user has changed them in memory */
++			atomic_set(&cifsInfo->inUse,1);
++		}
++		
++		if (S_ISREG(inode->i_mode)) {
++			cFYI(1, (" File inode "));
++			inode->i_op = &cifs_file_inode_ops;
++			inode->i_fop = &cifs_file_ops;
++			inode->i_data.a_ops = &cifs_addr_ops;
++		} else if (S_ISDIR(inode->i_mode)) {
++			cFYI(1, (" Directory inode "));
++			inode->i_op = &cifs_dir_inode_ops;
++			inode->i_fop = &cifs_dir_ops;
++		} else if (S_ISLNK(inode->i_mode)) {
++			cFYI(1, (" Symbolic Link inode "));
++			inode->i_op = &cifs_symlink_inode_ops;
++		} else {
++			init_special_inode(inode, inode->i_mode,
++					   kdev_t_to_nr(inode->i_rdev));
++		}
++	}
++	if(buf)
++	    kfree(buf);
++	return rc;
++}
++
++void
++cifs_read_inode(struct inode *inode)
++{				/* gets root inode */
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsInodeInfo *cifs_inode;
++	
++	cifs_sb = CIFS_SB(inode->i_sb);
++	xid = GetXid();
++	
++	cifs_inode = CIFS_I(inode);
++	cifs_inode->cifsAttrs = ATTR_DIRECTORY; 
++	atomic_set(&cifs_inode->inUse, 0);
++	cifs_inode->time = 0;
++	inode->i_blksize = CIFS_MAX_MSGSIZE;
++	inode->i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
++
++	INIT_LIST_HEAD(&cifs_inode->openFileList);
++
++	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
++		cifs_get_inode_info_unix(&inode, "", inode->i_sb,xid);
++	else
++		cifs_get_inode_info(&inode, "", NULL, inode->i_sb,xid);
++	/* can not call macro FreeXid here since in a void func */
++	_FreeXid(xid);
++}
++
++int
++cifs_unlink(struct inode *inode, struct dentry *direntry)
++{
++	int rc = 0;
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	struct cifsInodeInfo *cifsInode;
++	FILE_BASIC_INFO * pinfo_buf;
++
++	cFYI(1, (" cifs_unlink, inode = 0x%p with ", inode));
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++/* Unlink can be called from rename so we can not grab
++	the sem here since we deadlock otherwise */
++/*	down(&direntry->d_sb->s_vfs_rename_sem);*/
++	full_path = build_path_from_dentry(direntry);
++/*	up(&direntry->d_sb->s_vfs_rename_sem);*/
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++	rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls);
++
++	if (!rc) {
++		direntry->d_inode->i_nlink--;
++	} else if (rc == -ENOENT) {
++		d_drop(direntry);
++	} else if (rc == -ETXTBSY) {
++		int oplock = FALSE;
++		__u16 netfid;
++
++		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE, 
++				CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
++				&netfid, &oplock, NULL, cifs_sb->local_nls);
++		if(rc==0) {
++			CIFSSMBRenameOpenFile(xid,pTcon,netfid,
++				NULL, cifs_sb->local_nls);
++			CIFSSMBClose(xid, pTcon, netfid);
++			direntry->d_inode->i_nlink--;
++		}
++	} else if (rc == -EACCES) {
++		/* try only if r/o attribute set in local lookup data? */
++		pinfo_buf = (FILE_BASIC_INFO *)kmalloc(sizeof(FILE_BASIC_INFO),GFP_KERNEL);
++		if(pinfo_buf) {
++			memset(pinfo_buf,0,sizeof(FILE_BASIC_INFO));        
++		/* ATTRS set to normal clears r/o bit */
++			pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
++			rc = CIFSSMBSetTimes(xid, pTcon, full_path, pinfo_buf,
++				cifs_sb->local_nls);
++			kfree(pinfo_buf);
++		}
++		if(rc==0) {
++			rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls);
++			if (!rc) {
++				direntry->d_inode->i_nlink--;
++			} else if (rc == -ETXTBSY) {
++				int oplock = FALSE;
++				__u16 netfid;
++
++				rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
++						CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
++						&netfid, &oplock, NULL, cifs_sb->local_nls);
++				if(rc==0) {
++					CIFSSMBRenameOpenFile(xid,pTcon,netfid,NULL,cifs_sb->local_nls);
++					CIFSSMBClose(xid, pTcon, netfid);
++		                        direntry->d_inode->i_nlink--;
++				}
++			/* BB if rc = -ETXTBUSY goto the rename logic BB */
++			}
++		}
++	}
++	cifsInode = CIFS_I(direntry->d_inode);
++	cifsInode->time = 0;	/* will force revalidate to get info when needed */
++	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
++	    CURRENT_TIME;
++	cifsInode = CIFS_I(inode);
++	cifsInode->time = 0;	/* force revalidate of dir as well */
++
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
++{
++	int rc = 0;
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	struct inode *newinode = NULL;
++
++	cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p ", mode, inode));
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	down(&inode->i_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(direntry);
++	up(&inode->i_sb->s_vfs_rename_sem);
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++	/* BB add setting the equivalent of mode via CreateX w/ACLs */
++	rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls);
++	if (rc) {
++		cFYI(1, ("cifs_mkdir returned 0x%x ", rc));
++		d_drop(direntry);
++	} else {
++		inode->i_nlink++;
++		if (pTcon->ses->capabilities & CAP_UNIX)
++			rc = cifs_get_inode_info_unix(&newinode, full_path,
++						      inode->i_sb,xid);
++		else
++			rc = cifs_get_inode_info(&newinode, full_path,NULL,
++						 inode->i_sb,xid);
++
++		direntry->d_op = &cifs_dentry_ops;
++		d_instantiate(direntry, newinode);
++		if(direntry->d_inode)
++			direntry->d_inode->i_nlink = 2;
++		if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)                
++			CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode,
++				(__u64)-1,  
++				(__u64)-1,
++				0 /* dev_t */,
++				cifs_sb->local_nls);
++		else { /* BB to be implemented via Windows secrty descriptors*/
++		/* eg CIFSSMBWinSetPerms(xid,pTcon,full_path,mode,-1,-1,local_nls);*/
++		}
++	}
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++
++	return rc;
++}
++
++int
++cifs_rmdir(struct inode *inode, struct dentry *direntry)
++{
++	int rc = 0;
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	struct cifsInodeInfo *cifsInode;
++
++	cFYI(1, (" cifs_rmdir, inode = 0x%p with ", inode));
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	down(&inode->i_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(direntry);
++	up(&inode->i_sb->s_vfs_rename_sem);
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++
++	rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls);
++
++	if (!rc) {
++		inode->i_nlink--;
++		direntry->d_inode->i_size = 0;
++		direntry->d_inode->i_nlink = 0;
++	}
++
++	cifsInode = CIFS_I(direntry->d_inode);
++	cifsInode->time = 0;	/* force revalidate to go get info when needed */
++	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
++	    CURRENT_TIME;
++
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
++	    struct inode *target_inode, struct dentry *target_direntry)
++{
++	char *fromName;
++	char *toName;
++	struct cifs_sb_info *cifs_sb_source;
++	struct cifs_sb_info *cifs_sb_target;
++	struct cifsTconInfo *pTcon;
++	int xid;
++	int rc = 0;
++
++	xid = GetXid();
++
++	cifs_sb_target = CIFS_SB(target_inode->i_sb);
++	cifs_sb_source = CIFS_SB(source_inode->i_sb);
++	pTcon = cifs_sb_source->tcon;
++
++	if (pTcon != cifs_sb_target->tcon) {
++		FreeXid(xid);    
++		return -EXDEV;	/* BB actually could be allowed if same server, but
++                     different share. Might eventually add support for this */
++	}
++
++	/* we already  have the rename sem so we do not need
++	to grab it again here to protect the path integrity */
++	fromName = build_path_from_dentry(source_direntry);
++	toName = build_path_from_dentry(target_direntry);
++	if((fromName == NULL) || (toName == NULL)) {
++		rc = -ENOMEM;
++		goto cifs_rename_exit;
++	}
++
++	rc = CIFSSMBRename(xid, pTcon, fromName, toName,
++			   cifs_sb_source->local_nls);
++	if(rc == -EEXIST) {
++		/* check if they are the same file 
++		because rename of hardlinked files is a noop */
++		FILE_UNIX_BASIC_INFO * info_buf_source;
++		FILE_UNIX_BASIC_INFO * info_buf_target;
++
++		info_buf_source = 
++			kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),GFP_KERNEL);
++		if(info_buf_source != NULL) {
++			info_buf_target = info_buf_source+1;
++			rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName, 
++				info_buf_source, cifs_sb_source->local_nls);
++			if(rc == 0) {
++				rc = CIFSSMBUnixQPathInfo(xid,pTcon,toName,
++						info_buf_target,
++						cifs_sb_target->local_nls);
++			}
++			if((rc == 0) && 
++				(info_buf_source->UniqueId == 
++				 info_buf_target->UniqueId)) {
++			/* do not rename since the files are hardlinked 
++			   which is a noop */
++			} else {
++			/* we either can not tell the files are hardlinked
++			(as with Windows servers) or files are not hardlinked 
++			so delete the target manually before renaming to
++			follow POSIX rather than Windows semantics */
++				cifs_unlink(target_inode, target_direntry);
++				rc = CIFSSMBRename(xid, pTcon, fromName, toName,
++					cifs_sb_source->local_nls);
++			}
++			kfree(info_buf_source);
++		} /* if we can not get memory just leave rc as EEXIST */
++	}
++
++	if((rc == -EIO)||(rc == -EEXIST)) {
++		int oplock = FALSE;
++		__u16 netfid;
++
++		rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
++					CREATE_NOT_DIR,
++					&netfid, &oplock, NULL, cifs_sb_source->local_nls);
++		if(rc==0) {
++			CIFSSMBRenameOpenFile(xid,pTcon,netfid,
++					toName, cifs_sb_source->local_nls);
++			CIFSSMBClose(xid, pTcon, netfid);
++		}
++	}
++
++cifs_rename_exit:
++	if (fromName)
++		kfree(fromName);
++	if (toName)
++		kfree(toName);
++
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_revalidate(struct dentry *direntry)
++{
++	int xid;
++	int rc = 0;
++	char *full_path;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsInodeInfo *cifsInode;
++	loff_t local_size;
++	time_t local_mtime;
++	int invalidate_inode = FALSE;
++
++	if(direntry->d_inode == NULL)
++		return -ENOENT;
++
++	cifsInode = CIFS_I(direntry->d_inode);
++
++	if(cifsInode == NULL)
++		return -ENOENT;
++
++	/* no sense revalidating inode info on file that no one can write */
++	if(CIFS_I(direntry->d_inode)->clientCanCacheRead)
++		return rc;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(direntry->d_sb);
++
++	/* can not safely grab the rename sem here if
++	rename calls revalidate since that would deadlock */
++	full_path = build_path_from_dentry(direntry);
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++	cFYI(1,
++	     ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld",
++	      full_path, direntry->d_inode,
++	      direntry->d_inode->i_count.counter, direntry,
++	      direntry->d_time, jiffies));
++
++	if (cifsInode->time == 0){
++		/* was set to zero previously to force revalidate */
++	} else if (time_before(jiffies, cifsInode->time + HZ) && lookupCacheEnabled) {
++	    if((S_ISREG(direntry->d_inode->i_mode) == 0) || 
++			(direntry->d_inode->i_nlink == 1)) {  
++			if (full_path)
++				kfree(full_path);
++			FreeXid(xid);
++			return rc;
++		} else {
++			cFYI(1,("Have to revalidate file due to hardlinks"));
++		}            
++	}
++	
++	/* save mtime and size */
++	local_mtime = direntry->d_inode->i_mtime;
++	local_size  = direntry->d_inode->i_size;
++
++	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
++		rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
++					 direntry->d_sb,xid);
++		if(rc) {
++			cFYI(1,("error on getting revalidate info %d",rc));
++/*			if(rc != -ENOENT)
++				rc = 0; */ /* BB should we cache info on certain errors? */
++		}
++	} else {
++		rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
++				    direntry->d_sb,xid);
++		if(rc) {
++			cFYI(1,("error on getting revalidate info %d",rc));
++/*			if(rc != -ENOENT)
++				rc = 0; */  /* BB should we cache info on certain errors? */
++		}
++	}
++	/* should we remap certain errors, access denied?, to zero */
++
++	/* if not oplocked, we invalidate inode pages if mtime 
++	   or file size had changed on server */
++
++	if((local_mtime == direntry->d_inode->i_mtime) && 
++		(local_size == direntry->d_inode->i_size)) {
++		cFYI(1,("cifs_revalidate - inode unchanged"));
++	} else {
++		/* file may have changed on server */
++		if(cifsInode->clientCanCacheRead) {
++			/* no need to invalidate inode pages since we were
++			   the only ones who could have modified the file and
++			   the server copy is staler than ours */
++		} else {
++			invalidate_inode = TRUE;
++		}
++	}
++
++	/* can not grab this sem since kernel filesys locking
++		documentation indicates i_sem may be taken by the kernel 
++		on lookup and rename which could deadlock if we grab
++		the i_sem here as well */
++/*	down(&direntry->d_inode->i_sem);*/
++	/* need to write out dirty pages here  */
++	if(direntry->d_inode->i_mapping) {
++		/* do we need to lock inode until after invalidate completes below? */
++		filemap_fdatasync(direntry->d_inode->i_mapping);
++	}
++	if(invalidate_inode) {
++		filemap_fdatawait(direntry->d_inode->i_mapping);
++		/* may eventually have to do this for open files too */
++		if(list_empty(&(cifsInode->openFileList))) {
++			/* Has changed on server - flush read ahead pages */
++			cFYI(1,("Invalidating read ahead data on closed file"));
++			invalidate_inode_pages(direntry->d_inode);
++		}
++	}
++/*	up(&direntry->d_inode->i_sem);*/
++	
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++
++	return rc;
++}
++
++/* int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
++{
++	int err = cifs_revalidate(dentry);
++	if (!err)
++		generic_fillattr(dentry->d_inode, stat);
++	return err;
++} */
++
++void
++cifs_truncate_file(struct inode *inode)
++{				/* BB remove - may not need this function after all BB */
++	int xid;
++	int rc = -EIO;
++	int found = FALSE;
++	struct cifsFileInfo *open_file = NULL;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	struct cifsInodeInfo *cifsInode;
++	struct dentry *dirent;
++	struct list_head * tmp;
++	char *full_path = NULL;   
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	/* To avoid spurious oplock breaks from server, in the case
++		of inodes that we already have open, avoid doing path
++		based setting of file size if we can do it by handle.
++		This keeps our caching token (oplock) and avoids
++		timeouts when the local oplock break takes longer to flush
++		writebehind data than the SMB timeout for the SetPathInfo 
++		request would allow */
++	read_lock(&GlobalSMBSeslock); 
++	cifsInode = CIFS_I(inode);
++	list_for_each(tmp, &cifsInode->openFileList) {            
++		open_file = list_entry(tmp,struct cifsFileInfo, flist);
++		/* We check if file is open for writing first */
++		if((open_file->pfile) && (!open_file->invalidHandle) &&
++		   ((open_file->pfile->f_flags & O_RDWR) || 
++			(open_file->pfile->f_flags & O_WRONLY))) {
++			read_unlock(&GlobalSMBSeslock);
++			found = TRUE;
++			rc = CIFSSMBSetFileSize(xid, pTcon, inode->i_size,
++			   open_file->netfid,open_file->pid,FALSE);
++			if(rc == 0) {
++				FreeXid(xid);
++				return;
++			} 
++			/* Do not need reopen and retry on EAGAIN since we will
++				retry by pathname below */
++			if(rc == -EAGAIN)
++				rc = -EHOSTDOWN;
++
++			break;  /* now that we found one valid file handle no
++				sense continuing to loop trying others */
++		}
++	}
++	if(found == FALSE)
++		read_unlock(&GlobalSMBSeslock);
++
++	if (list_empty(&inode->i_dentry)) {
++		cERROR(1,
++		       ("Can not get pathname from empty dentry in inode 0x%p ",
++			inode));
++		FreeXid(xid);
++		return;
++	}
++
++	dirent = list_entry(inode->i_dentry.next, struct dentry, d_alias);
++	if (dirent) {
++		full_path = build_path_from_dentry(dirent);
++		rc = CIFSSMBSetEOF(xid, pTcon, full_path, inode->i_size,FALSE,
++				   cifs_sb->local_nls);
++		cFYI(1,(" SetEOF (truncate) rc = %d",rc));
++		if (!rc)
++			CIFSSMBSetEOF(xid,pTcon,full_path,inode->i_size,TRUE,cifs_sb->local_nls);
++           /* allocation size setting seems optional so ignore return code */
++	}
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return;
++}
++
++static int cifs_truncate_page(struct address_space *mapping, loff_t from)
++{
++	unsigned long index = from >> PAGE_CACHE_SHIFT;
++	unsigned offset = from & (PAGE_CACHE_SIZE-1);
++	struct page *page;
++	char *kaddr;
++	int rc = 0;
++
++	page = grab_cache_page(mapping, index);
++	if (!page)
++		return -ENOMEM;
++
++	kaddr = kmap_atomic(page, KM_USER0);
++	memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
++	flush_dcache_page(page);
++	kunmap_atomic(kaddr, KM_USER0);
++	unlock_page(page);
++	page_cache_release(page);
++	return rc;
++}
++
++int
++cifs_setattr(struct dentry *direntry, struct iattr *attrs)
++{
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	int rc = -EACCES;
++	int found = FALSE;
++	struct cifsFileInfo *open_file = NULL;
++	FILE_BASIC_INFO time_buf;
++	int set_time = FALSE;
++	__u64 mode = 0xFFFFFFFFFFFFFFFFULL;
++	__u64 uid = 0xFFFFFFFFFFFFFFFFULL;
++	__u64 gid = 0xFFFFFFFFFFFFFFFFULL;
++	struct cifsInodeInfo *cifsInode;
++	struct list_head * tmp;
++
++	xid = GetXid();
++
++	cFYI(1,
++	     (" In cifs_setattr, name = %s attrs->iavalid 0x%x ",
++	      direntry->d_name.name, attrs->ia_valid));
++	cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	down(&direntry->d_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(direntry);
++	up(&direntry->d_sb->s_vfs_rename_sem);
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++	cifsInode = CIFS_I(direntry->d_inode);
++
++	/* BB check if we need to refresh inode from server now ? BB */
++
++	/* need to flush data before changing file size on server */
++	filemap_fdatasync(direntry->d_inode->i_mapping);
++
++	if (attrs->ia_valid & ATTR_SIZE) {
++		read_lock(&GlobalSMBSeslock); 
++		/* To avoid spurious oplock breaks from server, in the case
++			of inodes that we already have open, avoid doing path
++			based setting of file size if we can do it by handle.
++			This keeps our caching token (oplock) and avoids
++			timeouts when the local oplock break takes longer to flush
++			writebehind data than the SMB timeout for the SetPathInfo 
++			request would allow */
++		list_for_each(tmp, &cifsInode->openFileList) {            
++			open_file = list_entry(tmp,struct cifsFileInfo, flist);
++			/* We check if file is open for writing first */
++			if((open_file->pfile) &&
++				((open_file->pfile->f_flags & O_RDWR) || 
++				 (open_file->pfile->f_flags & O_WRONLY))) {
++				if(open_file->invalidHandle == FALSE) {
++					/* we found a valid, writeable network file 
++					handle to use to try to set the file size */
++					__u16 nfid = open_file->netfid;
++					__u32 npid = open_file->pid;
++					read_unlock(&GlobalSMBSeslock);
++					found = TRUE;
++					rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
++					   nfid,npid,FALSE);
++					cFYI(1,("SetFileSize by handle (setattrs) rc = %d",rc));
++				/* Do not need reopen and retry on EAGAIN since we will
++					retry by pathname below */
++
++					break;  /* now that we found one valid file handle no
++						sense continuing to loop trying others */
++				}
++			}
++		}
++		if(found == FALSE) {
++			read_unlock(&GlobalSMBSeslock);
++		}
++
++
++		if(rc != 0) {
++			/* Set file size by pathname rather than by handle either
++			because no valid, writeable file handle for it was found or
++			because there was an error setting it by handle */
++			rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,FALSE,
++				   cifs_sb->local_nls);
++			cFYI(1,(" SetEOF by path (setattrs) rc = %d",rc));
++		}
++        
++	/*  Server is ok setting allocation size implicitly - no need to call: */
++	/*CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE, cifs_sb->local_nls);*/
++
++		if (rc == 0) {
++			rc = vmtruncate(direntry->d_inode, attrs->ia_size);
++			cifs_truncate_page(direntry->d_inode->i_mapping, direntry->d_inode->i_size);
++		}
++	}
++	if (attrs->ia_valid & ATTR_UID) {
++		cFYI(1, (" CIFS - UID changed to %d", attrs->ia_uid));
++		uid = attrs->ia_uid;
++		/*        entry->uid = cpu_to_le16(attr->ia_uid); */
++	}
++	if (attrs->ia_valid & ATTR_GID) {
++		cFYI(1, (" CIFS - GID changed to %d", attrs->ia_gid));
++		gid = attrs->ia_gid;
++		/*      entry->gid = cpu_to_le16(attr->ia_gid); */
++	}
++
++	time_buf.Attributes = 0;
++	if (attrs->ia_valid & ATTR_MODE) {
++		cFYI(1, (" CIFS - Mode changed to 0x%x", attrs->ia_mode));
++		mode = attrs->ia_mode;
++		/* entry->mode = cpu_to_le16(attr->ia_mode); */
++	}
++
++	if ((cifs_sb->tcon->ses->capabilities & CAP_UNIX)
++	    && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
++		rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
++				0 /* dev_t */, cifs_sb->local_nls);
++	else if (attrs->ia_valid & ATTR_MODE) {
++		if((mode & S_IWUGO) == 0) /* not writeable */ {
++			if((cifsInode->cifsAttrs & ATTR_READONLY) == 0)
++				time_buf.Attributes = 
++					cpu_to_le32(cifsInode->cifsAttrs | ATTR_READONLY);
++		} else if((mode & S_IWUGO) == S_IWUGO) {
++			if(cifsInode->cifsAttrs & ATTR_READONLY)
++				time_buf.Attributes = 
++					cpu_to_le32(cifsInode->cifsAttrs & (~ATTR_READONLY));
++		}
++		/* BB to be implemented - via Windows security descriptors or streams */
++		/* CIFSSMBWinSetPerms(xid,pTcon,full_path,mode,uid,gid,cifs_sb->local_nls);*/
++	}
++
++	if (attrs->ia_valid & ATTR_ATIME) {
++		set_time = TRUE;
++		time_buf.LastAccessTime =
++		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
++	} else
++		time_buf.LastAccessTime = 0;
++
++	if (attrs->ia_valid & ATTR_MTIME) {
++		set_time = TRUE;
++		time_buf.LastWriteTime =
++		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
++	} else
++		time_buf.LastWriteTime = 0;
++
++	if (attrs->ia_valid & ATTR_CTIME) {
++		set_time = TRUE;
++		time_buf.ChangeTime =
++		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
++	} else
++		time_buf.ChangeTime = 0;
++
++	if (set_time | time_buf.Attributes) {
++		/* BB what if setting one attribute fails  
++			(such as size) but time setting works */
++		time_buf.CreationTime = 0;	/* do not change */
++		/* In the future we should experiment - try setting timestamps
++			 via Handle (SetFileInfo) instead of by path */
++		rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
++				cifs_sb->local_nls);
++	}
++
++	/* do not  need local check to inode_check_ok since the server does that */
++	if (!rc)
++		rc = inode_setattr(direntry->d_inode, attrs);
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++void
++cifs_delete_inode(struct inode *inode)
++{
++	cFYI(1, ("In cifs_delete_inode, inode = 0x%p ", inode));
++	/* may have to add back in if and when safe distributed caching of
++		directories added e.g. via FindNotify */
++}
+diff -urN linux-2.4.29.old/fs/cifs/link.c linux-2.4.29/fs/cifs/link.c
+--- linux-2.4.29.old/fs/cifs/link.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/link.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,328 @@
++/*
++ *   fs/cifs/link.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++#include <linux/fs.h>
++#include <linux/stat.h>
++#include "cifsfs.h"
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_debug.h"
++#include "cifs_fs_sb.h"
++
++int
++cifs_hardlink(struct dentry *old_file, struct inode *inode,
++	      struct dentry *direntry)
++{
++	int rc = -EACCES;
++	int xid;
++	char *fromName = NULL;
++	char *toName = NULL;
++	struct cifs_sb_info *cifs_sb_target;
++	struct cifsTconInfo *pTcon;
++	struct cifsInodeInfo *cifsInode;
++
++	xid = GetXid();
++
++	cifs_sb_target = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb_target->tcon;
++
++/* No need to check for cross device links since server will do that
++   BB note DFS case in future though (when we may have to check) */
++
++	down(&inode->i_sb->s_vfs_rename_sem);
++	fromName = build_path_from_dentry(old_file);
++	toName = build_path_from_dentry(direntry);
++	up(&inode->i_sb->s_vfs_rename_sem);
++	if((fromName == NULL) || (toName == NULL)) {
++		rc = -ENOMEM;
++		goto cifs_hl_exit;
++	}
++
++	if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX)
++		rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
++					    cifs_sb_target->local_nls);
++	else {
++		rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
++					cifs_sb_target->local_nls);
++		if(rc == -EIO)
++			rc = -EOPNOTSUPP;  
++	}
++
++/* if (!rc)     */
++	{
++		/*   renew_parental_timestamps(old_file);
++		   inode->i_nlink++;
++		   mark_inode_dirty(inode);
++		   d_instantiate(direntry, inode); */
++		/* BB add call to either mark inode dirty or refresh its data and timestamp to current time */
++	}
++	d_drop(direntry);	/* force new lookup from server */
++	cifsInode = CIFS_I(old_file->d_inode);
++	cifsInode->time = 0;	/* will force revalidate to go get info when needed */
++
++cifs_hl_exit:
++	if (fromName)
++		kfree(fromName);
++	if (toName)
++		kfree(toName);
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
++{
++	struct inode *inode = direntry->d_inode;
++	int rc = -EACCES;
++	int xid;
++	char *full_path = NULL;
++	char * target_path;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++
++	xid = GetXid();
++
++	down(&direntry->d_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(direntry);
++	up(&direntry->d_sb->s_vfs_rename_sem);
++
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++	cFYI(1, ("Full path: %s inode = 0x%p", full_path, inode));
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++	target_path = kmalloc(PATH_MAX, GFP_KERNEL);
++	if(target_path == NULL) {
++		if (full_path)
++			kfree(full_path);
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++	/* can not call the following line due to EFAULT in vfs_readlink which is presumably expecting a user space buffer */
++	/* length = cifs_readlink(direntry,target_path, sizeof(target_path) - 1);    */
++
++/* BB add read reparse point symlink code and Unix extensions symlink code here BB */
++	if (pTcon->ses->capabilities & CAP_UNIX)
++		rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
++					     target_path,
++					     PATH_MAX-1,
++					     cifs_sb->local_nls);
++	else {
++		/* rc = CIFSSMBQueryReparseLinkInfo */
++		/* BB Add code to Query ReparsePoint info */
++	}
++	/* BB Anything else to do to handle recursive links? */
++	/* BB Should we be using page symlink ops here? */
++
++	if (rc == 0) {
++
++/* BB Add special case check for Samba DFS symlinks */
++
++		target_path[PATH_MAX-1] = 0;
++		rc = vfs_follow_link(nd, target_path);
++	}
++	/* else EACCESS */
++
++	if (target_path)
++		kfree(target_path);
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
++{
++	int rc = -EOPNOTSUPP;
++	int xid;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	struct inode *newinode = NULL;
++
++	xid = GetXid();
++
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++	down(&inode->i_sb->s_vfs_rename_sem);
++	full_path = build_path_from_dentry(direntry);
++	up(&inode->i_sb->s_vfs_rename_sem);
++
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++
++	cFYI(1, ("Full path: %s ", full_path));
++	cFYI(1, ("symname is %s", symname));
++
++	/* BB what if DFS and this volume is on different share? BB */
++	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
++		rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
++					   cifs_sb->local_nls);
++	/* else
++	   rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,cifs_sb_target->local_nls); */
++
++	if (rc == 0) {
++		if (pTcon->ses->capabilities & CAP_UNIX)
++			rc = cifs_get_inode_info_unix(&newinode, full_path,
++						      inode->i_sb,xid);
++		else
++			rc = cifs_get_inode_info(&newinode, full_path, NULL,
++						 inode->i_sb,xid);
++
++		if (rc != 0) {
++			cFYI(1,
++			     ("Create symlink worked but get_inode_info failed with rc = %d ",
++			      rc));
++		} else {
++			direntry->d_op = &cifs_dentry_ops;
++			d_instantiate(direntry, newinode);
++		}
++	}
++
++	if (full_path)
++		kfree(full_path);
++	FreeXid(xid);
++	return rc;
++}
++
++int
++cifs_readlink(struct dentry *direntry, char *pBuffer, int buflen)
++{
++	struct inode *inode = direntry->d_inode;
++	int rc = -EACCES;
++	int xid;
++	int oplock = FALSE;
++	struct cifs_sb_info *cifs_sb;
++	struct cifsTconInfo *pTcon;
++	char *full_path = NULL;
++	char *tmp_path =  NULL;
++	char * tmpbuffer;
++	unsigned char * referrals = NULL;
++	int num_referrals = 0;
++	int len;
++	__u16 fid;
++
++	xid = GetXid();
++	cifs_sb = CIFS_SB(inode->i_sb);
++	pTcon = cifs_sb->tcon;
++
++/* BB would it be safe against deadlock to grab this sem 
++      even though rename itself grabs the sem and calls lookup? */
++/*       down(&inode->i_sb->s_vfs_rename_sem);*/
++	full_path = build_path_from_dentry(direntry);
++/*       up(&inode->i_sb->s_vfs_rename_sem);*/
++
++	if(full_path == NULL) {
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++
++	cFYI(1,
++	     ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d",
++	      full_path, inode, pBuffer, buflen));
++	if(buflen > PATH_MAX)
++		len = PATH_MAX;
++	else
++		len = buflen;
++	tmpbuffer = kmalloc(len,GFP_KERNEL);   
++	if(tmpbuffer == NULL) {
++		if (full_path)
++			kfree(full_path);
++		FreeXid(xid);
++		return -ENOMEM;
++	}
++
++/* BB add read reparse point symlink code and Unix extensions symlink code here BB */
++	if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
++		rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
++				tmpbuffer,
++				len - 1,
++				cifs_sb->local_nls);
++	else {
++		rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ,
++				OPEN_REPARSE_POINT,&fid, &oplock, NULL, cifs_sb->local_nls);
++		if(!rc) {
++			rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,
++				tmpbuffer,
++				len - 1, 
++				fid,
++				cifs_sb->local_nls);
++			if(CIFSSMBClose(xid, pTcon, fid)) {
++				cFYI(1,("Error closing junction point (open for ioctl)"));
++			}
++			if(rc == -EIO) {
++				/* Query if DFS Junction */
++				tmp_path =
++					kmalloc(MAX_TREE_SIZE + MAX_PATHCONF + 1,
++						GFP_KERNEL);
++				if (tmp_path) {
++					strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
++					strncat(tmp_path, full_path, MAX_PATHCONF);
++					rc = get_dfs_path(xid, pTcon->ses, tmp_path,
++						cifs_sb->local_nls, &num_referrals, &referrals);
++					cFYI(1,("Get DFS for %s rc = %d ",tmp_path, rc));
++					if((num_referrals == 0) && (rc == 0))
++						rc = -EACCES;
++					else {
++						cFYI(1,("num referral: %d",num_referrals));
++						if(referrals) {
++							cFYI(1,("referral string: %s ",referrals));
++							strncpy(tmpbuffer, referrals, len-1);                            
++						}
++					}
++					if(referrals)
++						kfree(referrals);
++					kfree(tmp_path);
++					if(referrals) {
++						kfree(referrals);
++					}
++				}
++				/* BB add code like else decode referrals then memcpy to
++				  tmpbuffer and free referrals string array BB */
++			}
++		}
++	}
++	/* BB Anything else to do to handle recursive links? */
++	/* BB Should we be using page ops here? */
++
++	/* BB null terminate returned string in pBuffer? BB */
++	if (rc == 0) {
++		rc = vfs_readlink(direntry, pBuffer, len, tmpbuffer);
++		cFYI(1,
++		     ("vfs_readlink called from cifs_readlink returned %d",
++		      rc));
++	}
++
++	if (tmpbuffer) {
++		kfree(tmpbuffer);
++	}
++	if (full_path) {
++		kfree(full_path);
++	}
++	FreeXid(xid);
++	return rc;
++}
+diff -urN linux-2.4.29.old/fs/cifs/Makefile linux-2.4.29/fs/cifs/Makefile
+--- linux-2.4.29.old/fs/cifs/Makefile	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/Makefile	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,10 @@
++#
++# Makefile for Linux CIFS VFS client 
++#
++O_TARGET := cifs.o
++
++obj-y := cifsfs.o cifssmb.o cifs_debug.o connect.o dir.o file.o inode.o link.o misc.o netmisc.o smbdes.o smbencrypt.o transport.o asn1.o md4.o md5.o cifs_unicode.o nterr.o cifsencrypt.o
++
++obj-m := $(O_TARGET)
++
++include $(TOPDIR)/Rules.make
+diff -urN linux-2.4.29.old/fs/cifs/md4.c linux-2.4.29/fs/cifs/md4.c
+--- linux-2.4.29.old/fs/cifs/md4.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/md4.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,203 @@
++/* 
++   Unix SMB/Netbios implementation.
++   Version 1.9.
++   a implementation of MD4 designed for use in the SMB authentication protocol
++   Copyright (C) Andrew Tridgell 1997-1998.
++   Modified by Steve French (sfrench@us.ibm.com) 2002-2003
++   
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++   
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++   
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++*/
++#include <linux/module.h>
++#include <linux/fs.h>
++/* NOTE: This code makes no attempt to be fast! */
++
++static __u32
++F(__u32 X, __u32 Y, __u32 Z)
++{
++	return (X & Y) | ((~X) & Z);
++}
++
++static __u32
++G(__u32 X, __u32 Y, __u32 Z)
++{
++	return (X & Y) | (X & Z) | (Y & Z);
++}
++
++static __u32
++H(__u32 X, __u32 Y, __u32 Z)
++{
++	return X ^ Y ^ Z;
++}
++
++static __u32
++lshift(__u32 x, int s)
++{
++	x &= 0xFFFFFFFF;
++	return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
++}
++
++#define ROUND1(a,b,c,d,k,s) (*a) = lshift((*a) + F(*b,*c,*d) + X[k], s)
++#define ROUND2(a,b,c,d,k,s) (*a) = lshift((*a) + G(*b,*c,*d) + X[k] + (__u32)0x5A827999,s)
++#define ROUND3(a,b,c,d,k,s) (*a) = lshift((*a) + H(*b,*c,*d) + X[k] + (__u32)0x6ED9EBA1,s)
++
++/* this applies md4 to 64 byte chunks */
++static void
++mdfour64(__u32 * M, __u32 * A, __u32 *B, __u32 * C, __u32 *D)
++{
++	int j;
++	__u32 AA, BB, CC, DD;
++	__u32 X[16];
++
++
++	for (j = 0; j < 16; j++)
++		X[j] = M[j];
++
++	AA = *A;
++	BB = *B;
++	CC = *C;
++	DD = *D;
++
++	ROUND1(A, B, C, D, 0, 3);
++	ROUND1(D, A, B, C, 1, 7);
++	ROUND1(C, D, A, B, 2, 11);
++	ROUND1(B, C, D, A, 3, 19);
++	ROUND1(A, B, C, D, 4, 3);
++	ROUND1(D, A, B, C, 5, 7);
++	ROUND1(C, D, A, B, 6, 11);
++	ROUND1(B, C, D, A, 7, 19);
++	ROUND1(A, B, C, D, 8, 3);
++	ROUND1(D, A, B, C, 9, 7);
++	ROUND1(C, D, A, B, 10, 11);
++	ROUND1(B, C, D, A, 11, 19);
++	ROUND1(A, B, C, D, 12, 3);
++	ROUND1(D, A, B, C, 13, 7);
++	ROUND1(C, D, A, B, 14, 11);
++	ROUND1(B, C, D, A, 15, 19);
++
++	ROUND2(A, B, C, D, 0, 3);
++	ROUND2(D, A, B, C, 4, 5);
++	ROUND2(C, D, A, B, 8, 9);
++	ROUND2(B, C, D, A, 12, 13);
++	ROUND2(A, B, C, D, 1, 3);
++	ROUND2(D, A, B, C, 5, 5);
++	ROUND2(C, D, A, B, 9, 9);
++	ROUND2(B, C, D, A, 13, 13);
++	ROUND2(A, B, C, D, 2, 3);
++	ROUND2(D, A, B, C, 6, 5);
++	ROUND2(C, D, A, B, 10, 9);
++	ROUND2(B, C, D, A, 14, 13);
++	ROUND2(A, B, C, D, 3, 3);
++	ROUND2(D, A, B, C, 7, 5);
++	ROUND2(C, D, A, B, 11, 9);
++	ROUND2(B, C, D, A, 15, 13);
++
++	ROUND3(A, B, C, D, 0, 3);
++	ROUND3(D, A, B, C, 8, 9);
++	ROUND3(C, D, A, B, 4, 11);
++	ROUND3(B, C, D, A, 12, 15);
++	ROUND3(A, B, C, D, 2, 3);
++	ROUND3(D, A, B, C, 10, 9);
++	ROUND3(C, D, A, B, 6, 11);
++	ROUND3(B, C, D, A, 14, 15);
++	ROUND3(A, B, C, D, 1, 3);
++	ROUND3(D, A, B, C, 9, 9);
++	ROUND3(C, D, A, B, 5, 11);
++	ROUND3(B, C, D, A, 13, 15);
++	ROUND3(A, B, C, D, 3, 3);
++	ROUND3(D, A, B, C, 11, 9);
++	ROUND3(C, D, A, B, 7, 11);
++	ROUND3(B, C, D, A, 15, 15);
++
++	*A += AA;
++	*B += BB;
++	*C += CC;
++	*D += DD;
++
++	*A &= 0xFFFFFFFF;
++	*B &= 0xFFFFFFFF;
++	*C &= 0xFFFFFFFF;
++	*D &= 0xFFFFFFFF;
++
++	for (j = 0; j < 16; j++)
++		X[j] = 0;
++}
++
++static void
++copy64(__u32 * M, unsigned char *in)
++{
++	int i;
++
++	for (i = 0; i < 16; i++)
++		M[i] = (in[i * 4 + 3] << 24) | (in[i * 4 + 2] << 16) |
++		    (in[i * 4 + 1] << 8) | (in[i * 4 + 0] << 0);
++}
++
++static void
++copy4(unsigned char *out, __u32 x)
++{
++	out[0] = x & 0xFF;
++	out[1] = (x >> 8) & 0xFF;
++	out[2] = (x >> 16) & 0xFF;
++	out[3] = (x >> 24) & 0xFF;
++}
++
++/* produce a md4 message digest from data of length n bytes */
++void
++mdfour(unsigned char *out, unsigned char *in, int n)
++{
++	unsigned char buf[128];
++	__u32 M[16];
++	__u32 b = n * 8;
++	int i;
++	__u32 A = 0x67452301;
++	__u32 B = 0xefcdab89;
++	__u32 C = 0x98badcfe;
++	__u32 D = 0x10325476;
++
++	while (n > 64) {
++		copy64(M, in);
++		mdfour64(M,&A,&B, &C, &D);
++		in += 64;
++		n -= 64;
++	}
++
++	for (i = 0; i < 128; i++)
++		buf[i] = 0;
++	memcpy(buf, in, n);
++	buf[n] = 0x80;
++
++	if (n <= 55) {
++		copy4(buf + 56, b);
++		copy64(M, buf);
++		mdfour64(M, &A, &B, &C, &D);
++	} else {
++		copy4(buf + 120, b);
++		copy64(M, buf);
++		mdfour64(M, &A, &B, &C, &D);
++		copy64(M, buf + 64);
++		mdfour64(M, &A, &B, &C, &D);
++	}
++
++	for (i = 0; i < 128; i++)
++		buf[i] = 0;
++	copy64(M, buf);
++
++	copy4(out, A);
++	copy4(out + 4, B);
++	copy4(out + 8, C);
++	copy4(out + 12, D);
++
++	A = B = C = D = 0;
++}
+diff -urN linux-2.4.29.old/fs/cifs/md5.c linux-2.4.29/fs/cifs/md5.c
+--- linux-2.4.29.old/fs/cifs/md5.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/md5.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,363 @@
++/*
++ * This code implements the MD5 message-digest algorithm.
++ * The algorithm is due to Ron Rivest.  This code was
++ * written by Colin Plumb in 1993, no copyright is claimed.
++ * This code is in the public domain; do with it what you wish.
++ *
++ * Equivalent code is available from RSA Data Security, Inc.
++ * This code has been tested against that, and is equivalent,
++ * except that you don't need to include two pages of legalese
++ * with every copy.
++ *
++ * To compute the message digest of a chunk of bytes, declare an
++ * MD5Context structure, pass it to MD5Init, call MD5Update as
++ * needed on buffers full of bytes, and then call MD5Final, which
++ * will fill a supplied 16-byte array with the digest.
++ */
++
++/* This code slightly modified to fit into Samba by 
++   abartlet@samba.org Jun 2001 
++   and to fit the cifs vfs by 
++   Steve French sfrench@us.ibm.com */
++
++#include <linux/string.h>
++#include "md5.h"
++
++static void MD5Transform(__u32 buf[4], __u32 const in[16]);
++
++/*
++ * Note: this code is harmless on little-endian machines.
++ */
++static void
++byteReverse(unsigned char *buf, unsigned longs)
++{
++	__u32 t;
++	do {
++		t = (__u32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
++		    ((unsigned) buf[1] << 8 | buf[0]);
++		*(__u32 *) buf = t;
++		buf += 4;
++	} while (--longs);
++}
++
++/*
++ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
++ * initialization constants.
++ */
++void
++MD5Init(struct MD5Context *ctx)
++{
++	ctx->buf[0] = 0x67452301;
++	ctx->buf[1] = 0xefcdab89;
++	ctx->buf[2] = 0x98badcfe;
++	ctx->buf[3] = 0x10325476;
++
++	ctx->bits[0] = 0;
++	ctx->bits[1] = 0;
++}
++
++/*
++ * Update context to reflect the concatenation of another buffer full
++ * of bytes.
++ */
++void
++MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
++{
++	register __u32 t;
++
++	/* Update bitcount */
++
++	t = ctx->bits[0];
++	if ((ctx->bits[0] = t + ((__u32) len << 3)) < t)
++		ctx->bits[1]++;	/* Carry from low to high */
++	ctx->bits[1] += len >> 29;
++
++	t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
++
++	/* Handle any leading odd-sized chunks */
++
++	if (t) {
++		unsigned char *p = (unsigned char *) ctx->in + t;
++
++		t = 64 - t;
++		if (len < t) {
++			memmove(p, buf, len);
++			return;
++		}
++		memmove(p, buf, t);
++		byteReverse(ctx->in, 16);
++		MD5Transform(ctx->buf, (__u32 *) ctx->in);
++		buf += t;
++		len -= t;
++	}
++	/* Process data in 64-byte chunks */
++
++	while (len >= 64) {
++		memmove(ctx->in, buf, 64);
++		byteReverse(ctx->in, 16);
++		MD5Transform(ctx->buf, (__u32 *) ctx->in);
++		buf += 64;
++		len -= 64;
++	}
++
++	/* Handle any remaining bytes of data. */
++
++	memmove(ctx->in, buf, len);
++}
++
++/*
++ * Final wrapup - pad to 64-byte boundary with the bit pattern 
++ * 1 0* (64-bit count of bits processed, MSB-first)
++ */
++void
++MD5Final(unsigned char digest[16], struct MD5Context *ctx)
++{
++	unsigned int count;
++	unsigned char *p;
++
++	/* Compute number of bytes mod 64 */
++	count = (ctx->bits[0] >> 3) & 0x3F;
++
++	/* Set the first char of padding to 0x80.  This is safe since there is
++	   always at least one byte free */
++	p = ctx->in + count;
++	*p++ = 0x80;
++
++	/* Bytes of padding needed to make 64 bytes */
++	count = 64 - 1 - count;
++
++	/* Pad out to 56 mod 64 */
++	if (count < 8) {
++		/* Two lots of padding:  Pad the first block to 64 bytes */
++		memset(p, 0, count);
++		byteReverse(ctx->in, 16);
++		MD5Transform(ctx->buf, (__u32 *) ctx->in);
++
++		/* Now fill the next block with 56 bytes */
++		memset(ctx->in, 0, 56);
++	} else {
++		/* Pad block to 56 bytes */
++		memset(p, 0, count - 8);
++	}
++	byteReverse(ctx->in, 14);
++
++	/* Append length in bits and transform */
++	((__u32 *) ctx->in)[14] = ctx->bits[0];
++	((__u32 *) ctx->in)[15] = ctx->bits[1];
++
++	MD5Transform(ctx->buf, (__u32 *) ctx->in);
++	byteReverse((unsigned char *) ctx->buf, 4);
++	memmove(digest, ctx->buf, 16);
++	memset(ctx, 0, sizeof(*ctx));	/* In case it's sensitive */
++}
++
++/* The four core functions - F1 is optimized somewhat */
++
++/* #define F1(x, y, z) (x & y | ~x & z) */
++#define F1(x, y, z) (z ^ (x & (y ^ z)))
++#define F2(x, y, z) F1(z, x, y)
++#define F3(x, y, z) (x ^ y ^ z)
++#define F4(x, y, z) (y ^ (x | ~z))
++
++/* This is the central step in the MD5 algorithm. */
++#define MD5STEP(f, w, x, y, z, data, s) \
++	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
++
++/*
++ * The core of the MD5 algorithm, this alters an existing MD5 hash to
++ * reflect the addition of 16 longwords of new data.  MD5Update blocks
++ * the data and converts bytes into longwords for this routine.
++ */
++static void
++MD5Transform(__u32 buf[4], __u32 const in[16])
++{
++	register __u32 a, b, c, d;
++
++	a = buf[0];
++	b = buf[1];
++	c = buf[2];
++	d = buf[3];
++
++	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
++	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
++	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
++	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
++	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
++	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
++	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
++	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
++	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
++	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
++	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
++	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
++	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
++	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
++	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
++	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
++
++	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
++	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
++	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
++	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
++	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
++	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
++	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
++	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
++	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
++	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
++	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
++	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
++	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
++	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
++	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
++	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
++
++	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
++	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
++	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
++	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
++	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
++	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
++	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
++	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
++	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
++	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
++	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
++	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
++	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
++	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
++	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
++	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
++
++	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
++	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
++	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
++	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
++	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
++	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
++	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
++	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
++	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
++	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
++	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
++	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
++	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
++	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
++	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
++	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
++
++	buf[0] += a;
++	buf[1] += b;
++	buf[2] += c;
++	buf[3] += d;
++}
++
++/***********************************************************************
++ the rfc 2104 version of hmac_md5 initialisation.
++***********************************************************************/
++void
++hmac_md5_init_rfc2104(unsigned char *key, int key_len,
++		      struct HMACMD5Context *ctx)
++{
++	int i;
++
++	/* if key is longer than 64 bytes reset it to key=MD5(key) */
++	if (key_len > 64) {
++		unsigned char tk[16];
++		struct MD5Context tctx;
++
++		MD5Init(&tctx);
++		MD5Update(&tctx, key, key_len);
++		MD5Final(tk, &tctx);
++
++		key = tk;
++		key_len = 16;
++	}
++
++	/* start out by storing key in pads */
++	memset(ctx->k_ipad, 0, sizeof (ctx->k_ipad));
++	memset(ctx->k_opad, 0, sizeof (ctx->k_opad));
++	memcpy(ctx->k_ipad, key, key_len);
++	memcpy(ctx->k_opad, key, key_len);
++
++	/* XOR key with ipad and opad values */
++	for (i = 0; i < 64; i++) {
++		ctx->k_ipad[i] ^= 0x36;
++		ctx->k_opad[i] ^= 0x5c;
++	}
++
++	MD5Init(&ctx->ctx);
++	MD5Update(&ctx->ctx, ctx->k_ipad, 64);
++}
++
++/***********************************************************************
++ the microsoft version of hmac_md5 initialisation.
++***********************************************************************/
++void
++hmac_md5_init_limK_to_64(const unsigned char *key, int key_len,
++			 struct HMACMD5Context *ctx)
++{
++	int i;
++
++	/* if key is longer than 64 bytes truncate it */
++	if (key_len > 64) {
++		key_len = 64;
++	}
++
++	/* start out by storing key in pads */
++	memset(ctx->k_ipad, 0, sizeof (ctx->k_ipad));
++	memset(ctx->k_opad, 0, sizeof (ctx->k_opad));
++	memcpy(ctx->k_ipad, key, key_len);
++	memcpy(ctx->k_opad, key, key_len);
++
++	/* XOR key with ipad and opad values */
++	for (i = 0; i < 64; i++) {
++		ctx->k_ipad[i] ^= 0x36;
++		ctx->k_opad[i] ^= 0x5c;
++	}
++
++	MD5Init(&ctx->ctx);
++	MD5Update(&ctx->ctx, ctx->k_ipad, 64);
++}
++
++/***********************************************************************
++ update hmac_md5 "inner" buffer
++***********************************************************************/
++void
++hmac_md5_update(const unsigned char *text, int text_len,
++		struct HMACMD5Context *ctx)
++{
++	MD5Update(&ctx->ctx, text, text_len);	/* then text of datagram */
++}
++
++/***********************************************************************
++ finish off hmac_md5 "inner" buffer and generate outer one.
++***********************************************************************/
++void
++hmac_md5_final(unsigned char *digest, struct HMACMD5Context *ctx)
++{
++	struct MD5Context ctx_o;
++
++	MD5Final(digest, &ctx->ctx);
++
++	MD5Init(&ctx_o);
++	MD5Update(&ctx_o, ctx->k_opad, 64);
++	MD5Update(&ctx_o, digest, 16);
++	MD5Final(digest, &ctx_o);
++}
++
++/***********************************************************
++ single function to calculate an HMAC MD5 digest from data.
++ use the microsoft hmacmd5 init method because the key is 16 bytes.
++************************************************************/
++void
++hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
++	 unsigned char *digest)
++{
++	struct HMACMD5Context ctx;
++	hmac_md5_init_limK_to_64(key, 16, &ctx);
++	if (data_len != 0) {
++		hmac_md5_update(data, data_len, &ctx);
++	}
++	hmac_md5_final(digest, &ctx);
++}
+diff -urN linux-2.4.29.old/fs/cifs/md5.h linux-2.4.29/fs/cifs/md5.h
+--- linux-2.4.29.old/fs/cifs/md5.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/md5.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,38 @@
++#ifndef MD5_H
++#define MD5_H
++#ifndef HEADER_MD5_H
++/* Try to avoid clashes with OpenSSL */
++#define HEADER_MD5_H
++#endif
++
++struct MD5Context {
++	__u32 buf[4];
++	__u32 bits[2];
++	unsigned char in[64];
++};
++#endif				/* !MD5_H */
++
++#ifndef _HMAC_MD5_H
++struct HMACMD5Context {
++	struct MD5Context ctx;
++	unsigned char k_ipad[65];
++	unsigned char k_opad[65];
++};
++#endif				/* _HMAC_MD5_H */
++
++void MD5Init(struct MD5Context *context);
++void MD5Update(struct MD5Context *context, unsigned char const *buf,
++			unsigned len);
++void MD5Final(unsigned char digest[16], struct MD5Context *context);
++
++/* The following definitions come from lib/hmacmd5.c  */
++
++void hmac_md5_init_rfc2104(unsigned char *key, int key_len,
++			struct HMACMD5Context *ctx);
++void hmac_md5_init_limK_to_64(const unsigned char *key, int key_len,
++			struct HMACMD5Context *ctx);
++void hmac_md5_update(const unsigned char *text, int text_len,
++			struct HMACMD5Context *ctx);
++void hmac_md5_final(unsigned char *digest, struct HMACMD5Context *ctx);
++void hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
++			unsigned char *digest);
+diff -urN linux-2.4.29.old/fs/cifs/misc.c linux-2.4.29/fs/cifs/misc.c
+--- linux-2.4.29.old/fs/cifs/misc.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/misc.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,463 @@
++/*
++ *   fs/cifs/misc.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2003
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++
++#include <linux/slab.h>
++#include <linux/ctype.h>
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_debug.h"
++#include "smberr.h"
++#include "nterr.h"
++
++extern kmem_cache_t *cifs_req_cachep;
++extern struct task_struct * oplockThread;
++
++__u16 GlobalMid;		/* multiplex id - rotating counter */
++
++/* The xid serves as a useful identifier for each incoming vfs request, 
++   in a similar way to the mid which is useful to track each sent smb, 
++   and CurrentXid can also provide a running counter (although it 
++   will eventually wrap past zero) of the total vfs operations handled 
++   since the cifs fs was mounted */
++
++unsigned int
++_GetXid(void)
++{
++	unsigned int xid;
++
++	spin_lock(&GlobalMid_Lock);
++	GlobalTotalActiveXid++;
++	if (GlobalTotalActiveXid > GlobalMaxActiveXid)
++		GlobalMaxActiveXid = GlobalTotalActiveXid;	/* keep high water mark for number of simultaneous vfs ops in our filesystem */
++	xid = GlobalCurrentXid++;
++	spin_unlock(&GlobalMid_Lock);
++	return xid;
++}
++
++void
++_FreeXid(unsigned int xid)
++{
++	spin_lock(&GlobalMid_Lock);
++	/* if(GlobalTotalActiveXid == 0)
++		BUG(); */
++	GlobalTotalActiveXid--;
++	spin_unlock(&GlobalMid_Lock);
++}
++
++struct cifsSesInfo *
++sesInfoAlloc(void)
++{
++	struct cifsSesInfo *ret_buf;
++
++	ret_buf =
++	    (struct cifsSesInfo *) kmalloc(sizeof (struct cifsSesInfo),
++					   GFP_KERNEL);
++	if (ret_buf) {
++		memset(ret_buf, 0, sizeof (struct cifsSesInfo));
++		write_lock(&GlobalSMBSeslock);
++		atomic_inc(&sesInfoAllocCount);
++		ret_buf->status = CifsNew;
++		list_add(&ret_buf->cifsSessionList, &GlobalSMBSessionList);
++		init_MUTEX(&ret_buf->sesSem);
++		write_unlock(&GlobalSMBSeslock);
++	}
++	return ret_buf;
++}
++
++void
++sesInfoFree(struct cifsSesInfo *buf_to_free)
++{
++	if (buf_to_free == NULL) {
++		cFYI(1, ("Null buffer passed to sesInfoFree"));
++		return;
++	}
++
++	write_lock(&GlobalSMBSeslock);
++	atomic_dec(&sesInfoAllocCount);
++	list_del(&buf_to_free->cifsSessionList);
++	write_unlock(&GlobalSMBSeslock);
++	if (buf_to_free->serverOS)
++		kfree(buf_to_free->serverOS);
++	if (buf_to_free->serverDomain)
++		kfree(buf_to_free->serverDomain);
++	if (buf_to_free->serverNOS)
++		kfree(buf_to_free->serverNOS);
++	if (buf_to_free->password)
++		kfree(buf_to_free->password);
++	kfree(buf_to_free);
++}
++
++struct cifsTconInfo *
++tconInfoAlloc(void)
++{
++	struct cifsTconInfo *ret_buf;
++	ret_buf =
++	    (struct cifsTconInfo *) kmalloc(sizeof (struct cifsTconInfo),
++					    GFP_KERNEL);
++	if (ret_buf) {
++		memset(ret_buf, 0, sizeof (struct cifsTconInfo));
++		write_lock(&GlobalSMBSeslock);
++		atomic_inc(&tconInfoAllocCount);
++		list_add(&ret_buf->cifsConnectionList,
++			 &GlobalTreeConnectionList);
++		ret_buf->tidStatus = CifsNew;
++		INIT_LIST_HEAD(&ret_buf->openFileList);
++		init_MUTEX(&ret_buf->tconSem);
++#ifdef CONFIG_CIFS_STATS
++		ret_buf->stat_lock = SPIN_LOCK_UNLOCKED;
++#endif
++		write_unlock(&GlobalSMBSeslock);
++	}
++	return ret_buf;
++}
++
++void
++tconInfoFree(struct cifsTconInfo *buf_to_free)
++{
++	if (buf_to_free == NULL) {
++		cFYI(1, ("Null buffer passed to tconInfoFree"));
++		return;
++	}
++	write_lock(&GlobalSMBSeslock);
++	atomic_dec(&tconInfoAllocCount);
++	list_del(&buf_to_free->cifsConnectionList);
++	write_unlock(&GlobalSMBSeslock);
++	if (buf_to_free->nativeFileSystem)
++		kfree(buf_to_free->nativeFileSystem);
++	kfree(buf_to_free);
++}
++
++struct smb_hdr *
++cifs_buf_get(void)
++{
++	struct smb_hdr *ret_buf = NULL;
++
++/* We could use negotiated size instead of max_msgsize - 
++   but it may be more efficient to always alloc same size 
++   albeit slightly larger than necessary and maxbuffersize 
++   defaults to this and can not be bigger */
++	ret_buf =
++	    (struct smb_hdr *) kmem_cache_alloc(cifs_req_cachep, SLAB_KERNEL);
++
++	/* clear the first few header bytes */
++	if (ret_buf) {
++		memset(ret_buf, 0, sizeof (struct smb_hdr));
++		atomic_inc(&bufAllocCount);
++	}
++
++	return ret_buf;
++}
++
++void
++cifs_buf_release(void *buf_to_free)
++{
++
++	if (buf_to_free == NULL) {
++		cFYI(1, ("Null buffer passed to cifs_buf_release"));
++		return;
++	}
++	kmem_cache_free(cifs_req_cachep, buf_to_free);
++
++	atomic_dec(&bufAllocCount);
++	return;
++}
++
++void
++header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
++		const struct cifsTconInfo *treeCon, int word_count
++		/* length of fixed section (word count) in two byte units  */
++    )
++{
++	int i;
++	__u32 tmp;
++	struct list_head* temp_item;
++	struct cifsSesInfo * ses;
++	char *temp = (char *) buffer;
++
++	for (i = 0; i < MAX_CIFS_HDR_SIZE; i++) {
++		temp[i] = 0;	/* BB is this needed ?? */
++	}
++
++	buffer->smb_buf_length =
++	    (2 * word_count) + sizeof (struct smb_hdr) -
++	    4 /*  RFC 1001 length field does not count */  +
++	    2 /* for bcc field itself */ ;
++	/* Note that this is the only network field that has to be converted to big endian and it is done just before we send it */
++
++	buffer->Protocol[0] = 0xFF;
++	buffer->Protocol[1] = 'S';
++	buffer->Protocol[2] = 'M';
++	buffer->Protocol[3] = 'B';
++	buffer->Command = smb_command;
++	buffer->Flags = 0x00;	/* case sensitive */
++	buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
++	tmp = cpu_to_le32(current->pid);
++	buffer->Pid = tmp & 0xFFFF;
++	tmp >>= 16;
++	buffer->PidHigh = tmp & 0xFFFF;
++	spin_lock(&GlobalMid_Lock);
++	GlobalMid++;
++	buffer->Mid = GlobalMid;
++	spin_unlock(&GlobalMid_Lock);
++	if (treeCon) {
++		buffer->Tid = treeCon->tid;
++		if (treeCon->ses) {
++			if (treeCon->ses->capabilities & CAP_UNICODE)
++				buffer->Flags2 |= SMBFLG2_UNICODE;
++			if (treeCon->ses->capabilities & CAP_STATUS32) {
++				buffer->Flags2 |= SMBFLG2_ERR_STATUS;
++			}
++
++			buffer->Uid = treeCon->ses->Suid;	/* always in LE format */
++			if(multiuser_mount != 0) {
++		/* For the multiuser case, there are few obvious technically  */
++		/* possible mechanisms to match the local linux user (uid)    */
++		/* to a valid remote smb user (smb_uid):		      */
++		/* 	1) Query Winbind (or other local pam/nss daemon       */
++		/* 	  for userid/password/logon_domain or credential      */
++		/*      2) Query Winbind for uid to sid to username mapping   */
++		/* 	   and see if we have a matching password for existing*/
++		/*         session for that user perhas getting password by   */
++		/*         adding a new pam_cifs module that stores passwords */
++		/*         so that the cifs vfs can get at that for all logged*/
++		/*	   on users					      */
++		/*	3) (Which is the mechanism we have chosen)	      */
++		/*	   Search through sessions to the same server for a   */
++		/*	   a match on the uid that was passed in on mount     */
++		/*         with the current processes uid (or euid?) and use  */
++		/* 	   that smb uid.   If no existing smb session for     */
++		/* 	   that uid found, use the default smb session ie     */
++		/*         the smb session for the volume mounted which is    */
++		/* 	   the same as would be used if the multiuser mount   */
++		/* 	   flag were disabled.  */
++
++		/*  BB Add support for establishing new tCon and SMB Session  */
++		/*      with userid/password pairs found on the smb session   */ 
++		/*	for other target tcp/ip addresses 		BB    */
++				if(current->uid != treeCon->ses->linux_uid) {
++					cFYI(1,("Multiuser mode and UID did not match tcon uid "));
++					read_lock(&GlobalSMBSeslock);
++					list_for_each(temp_item, &GlobalSMBSessionList) {
++						ses = list_entry(temp_item, struct cifsSesInfo, cifsSessionList);
++						if(ses->linux_uid == current->uid) {
++							if(ses->server == treeCon->ses->server) {
++								cFYI(1,("found matching uid substitute right smb_uid"));  
++								buffer->Uid = ses->Suid;
++								break;
++							} else {
++								/* BB eventually call cifs_setup_session here */
++								cFYI(1,("local UID found but smb sess with this server does not exist"));  
++							}
++						}
++					}
++					read_unlock(&GlobalSMBSeslock);
++				}
++			}
++		}
++		if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
++			buffer->Flags2 |= SMBFLG2_DFS;
++		if(treeCon->ses->server)
++			if(treeCon->ses->server->secMode & 
++			  (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
++				buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
++	}
++
++/*  endian conversion of flags is now done just before sending */
++	buffer->WordCount = (char) word_count;
++	return;
++}
++
++int
++checkSMBhdr(struct smb_hdr *smb, __u16 mid)
++{
++	/* Make sure that this really is an SMB, that it is a response, 
++	   and that the message ids match */
++	if ((*(unsigned int *) smb->Protocol == cpu_to_le32(0x424d53ff)) && 
++		(mid == smb->Mid)) {    
++		if(smb->Flags & SMBFLG_RESPONSE)
++			return 0;                    
++		else {        
++		/* only one valid case where server sends us request */
++			if(smb->Command == SMB_COM_LOCKING_ANDX)
++				return 0;
++			else
++				cERROR(1, ("Rcvd Request not response "));         
++		}
++	} else { /* bad signature or mid */
++		if (*(unsigned int *) smb->Protocol != cpu_to_le32(0x424d53ff))
++			cERROR(1,
++			       ("Bad protocol string signature header %x ",
++				*(unsigned int *) smb->Protocol));
++		if (mid != smb->Mid)
++			cERROR(1, ("Mids do not match"));
++	}
++	cERROR(1, ("bad smb detected. The Mid=%d", smb->Mid));
++	return 1;
++}
++
++int
++checkSMB(struct smb_hdr *smb, __u16 mid, int length)
++{
++	cFYI(0,
++	     ("Entering checkSMB with Length: %x, smb_buf_length: %x ",
++	      length, ntohl(smb->smb_buf_length)));
++	if (((unsigned int)length < 2 + sizeof (struct smb_hdr))
++	    || (ntohl(smb->smb_buf_length) >
++		CIFS_MAX_MSGSIZE + MAX_CIFS_HDR_SIZE - 4)) {
++		if ((unsigned int)length < 2 + sizeof (struct smb_hdr)) {
++			cERROR(1, ("Length less than 2 + sizeof smb_hdr "));
++			if (((unsigned int)length >= sizeof (struct smb_hdr) - 1)
++			    && (smb->Status.CifsError != 0))
++				return 0;	/* some error cases do not return wct and bcc */
++
++		}
++		if (ntohl(smb->smb_buf_length) >
++		    CIFS_MAX_MSGSIZE + MAX_CIFS_HDR_SIZE - 4)
++			cERROR(1,
++			       ("smb_buf_length greater than CIFS_MAX_MSGSIZE ... "));
++		cERROR(1,
++		       ("bad smb detected. Illegal length. The mid=%d",
++			smb->Mid));
++		return 1;
++	}
++
++	if (checkSMBhdr(smb, mid))
++		return 1;
++
++	if ((4 + ntohl(smb->smb_buf_length) != smbCalcSize(smb))
++	    || (4 + ntohl(smb->smb_buf_length) != (unsigned int)length)) {
++		return 0;
++	} else {
++		cERROR(1, ("smbCalcSize %x ", smbCalcSize(smb)));
++		cERROR(1,
++		       ("bad smb size detected. The Mid=%d", smb->Mid));
++		return 1;
++	}
++}
++int
++is_valid_oplock_break(struct smb_hdr *buf)
++{    
++	struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)buf;
++	struct list_head *tmp;
++	struct list_head *tmp1;
++	struct cifsTconInfo *tcon;
++	struct cifsFileInfo *netfile;
++
++	/* could add check for smb response flag 0x80 */
++	cFYI(1,("Checking for oplock break"));    
++	if(pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
++		return FALSE;
++	if(pSMB->hdr.Flags & SMBFLG_RESPONSE) {
++		/* no sense logging error on invalid handle on oplock
++		   break - harmless race between close request and oplock
++		   break response is expected from time to time writing out
++		   large dirty files cached on the client */
++		if ((NT_STATUS_INVALID_HANDLE) == 
++		   le32_to_cpu(pSMB->hdr.Status.CifsError)) { 
++			cFYI(1,("invalid handle on oplock break"));
++			return TRUE;
++		} else if (ERRbadfid == 
++		   le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
++			return TRUE;	  
++		} else {
++			return FALSE; /* on valid oplock brk we get "request" */
++		}
++	}
++	if(pSMB->hdr.WordCount != 8)
++		return FALSE;
++
++	cFYI(1,(" oplock type 0x%d level 0x%d",pSMB->LockType,pSMB->OplockLevel));
++	if(!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
++		return FALSE;    
++
++	/* look up tcon based on tid & uid */
++	read_lock(&GlobalSMBSeslock);
++	list_for_each(tmp, &GlobalTreeConnectionList) {
++		tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
++		if (tcon->tid == buf->Tid) {
++#ifdef CONFIG_CIFS_STATS
++			atomic_inc(&tcon->num_oplock_brks);
++#endif
++			list_for_each(tmp1,&tcon->openFileList){
++				netfile = list_entry(tmp1,struct cifsFileInfo,tlist);
++				if(pSMB->Fid == netfile->netfid) {
++					struct cifsInodeInfo *pCifsInode;
++					read_unlock(&GlobalSMBSeslock);
++					cFYI(1,("Matching file id, processing oplock break"));
++					pCifsInode = 
++						CIFS_I(netfile->pInode);
++					pCifsInode->clientCanCacheAll = FALSE;
++					if(pSMB->OplockLevel == 0)
++						pCifsInode->clientCanCacheRead = FALSE;
++					pCifsInode->oplockPending = TRUE;
++					AllocOplockQEntry(netfile->pInode, netfile->netfid, tcon);
++					cFYI(1,("about to wake up oplock thd"));
++					wake_up_process(oplockThread);               
++					return TRUE;
++				}
++			}
++			read_unlock(&GlobalSMBSeslock);
++			cFYI(1,("No matching file for oplock break on connection"));
++			return TRUE;
++		}
++	}
++	read_unlock(&GlobalSMBSeslock);
++	cFYI(1,("Can not process oplock break for non-existent connection"));
++	return TRUE;
++}
++
++void
++dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
++{
++	int i, j;
++	char debug_line[17];
++	unsigned char *buffer;
++
++	if (traceSMB == 0)
++		return;
++
++	buffer = (unsigned char *) smb_buf;
++	for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
++		if (i % 8 == 0) {	/* we have reached the beginning of line  */
++			printk(KERN_DEBUG "| ");
++			j = 0;
++		}
++		printk("%0#4x ", buffer[i]);
++		debug_line[2 * j] = ' ';
++		if (isprint(buffer[i]))
++			debug_line[1 + (2 * j)] = buffer[i];
++		else
++			debug_line[1 + (2 * j)] = '_';
++
++		if (i % 8 == 7) {	/* we have reached end of line, time to print ascii */
++			debug_line[16] = 0;
++			printk(" | %s\n", debug_line);
++		}
++	}
++	for (; j < 8; j++) {
++		printk("     ");
++		debug_line[2 * j] = ' ';
++		debug_line[1 + (2 * j)] = ' ';
++	}
++	printk( " | %s\n", debug_line);
++	return;
++}
+diff -urN linux-2.4.29.old/fs/cifs/netmisc.c linux-2.4.29/fs/cifs/netmisc.c
+--- linux-2.4.29.old/fs/cifs/netmisc.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/netmisc.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,905 @@
++/*
++ *   fs/cifs/netmisc.c
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ * 
++ *   Error mapping routines from Samba libsmb/errormap.c
++ *   Copyright (C) Andrew Tridgell 2001
++ *
++ *
++ *   This program is free software;  you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License as published by
++ *   the Free Software Foundation; either version 2 of the License, or 
++ *   (at your option) any later version.
++ * 
++ *   This program is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU General Public License for more details.
++ *
++ *   You should have received a copy of the GNU General Public License
++ *   along with this program;  if not, write to the Free Software 
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#include <linux/net.h>
++#include <linux/string.h>
++#include <linux/in.h>
++#include <linux/ctype.h>
++#include <linux/fs.h>
++#include <asm/div64.h>
++#include <asm/byteorder.h>
++#include "cifsfs.h"
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "smberr.h"
++#include "cifs_debug.h"
++#include "nterr.h"
++
++struct smb_to_posix_error {
++	__u16 smb_err;
++	int posix_code;
++};
++
++const struct smb_to_posix_error mapping_table_ERRDOS[] = {
++	{ERRbadfunc, -EINVAL},
++	{ERRbadfile, -ENOENT},
++	{ERRbadpath, -ENOTDIR},
++	{ERRnofids, -EMFILE},
++	{ERRnoaccess, -EACCES},
++	{ERRbadfid, -EBADF},
++	{ERRbadmcb, -EIO},
++	{ERRnomem, -ENOMEM},
++	{ERRbadmem, -EFAULT},
++	{ERRbadenv, -EFAULT},
++	{ERRbadformat, -EINVAL},
++	{ERRbadaccess, -EACCES},
++	{ERRbaddata, -EIO},
++	{ERRbaddrive, -ENXIO},
++	{ERRremcd, -EACCES},
++	{ERRdiffdevice, -EXDEV},
++	{ERRnofiles, -ENOENT},
++	{ERRbadshare, -ETXTBSY},
++	{ERRlock, -EACCES},
++	{ERRunsup, -EINVAL},
++	{ERRnosuchshare,-ENXIO},
++	{ERRfilexists, -EEXIST},
++	{ERRinvparm, -EINVAL},
++	{ERRdiskfull, -ENOSPC},
++	{ERRinvname, -ENOENT},
++	{ERRdirnotempty, -ENOTEMPTY},
++	{ERRnotlocked, -ENOLCK},
++	{ERRalreadyexists, -EEXIST},
++	{ERRmoredata, -EOVERFLOW},
++	{ErrQuota, -EDQUOT},
++	{ErrNotALink, -ENOLINK},
++	{ERRnetlogonNotStarted,-ENOPROTOOPT},
++	{0, 0}
++};
++
++const struct smb_to_posix_error mapping_table_ERRSRV[] = {
++	{ERRerror, -EIO},
++	{ERRbadpw, -EPERM},
++	{ERRbadtype, -EREMOTE},
++	{ERRaccess, -EACCES},
++	{ERRinvtid, -ENXIO},
++	{ERRinvnetname, -ENODEV},
++	{ERRinvdevice, -ENXIO},
++	{ERRqfull, -ENOSPC},
++	{ERRqtoobig, -ENOSPC},
++	{ERRqeof, -EIO},
++	{ERRinvpfid, -EBADF},
++	{ERRsmbcmd, -EBADRQC},
++	{ERRsrverror, -EIO},
++	{ERRbadBID, -EIO},
++	{ERRfilespecs, -EINVAL},
++	{ERRbadLink, -EIO},
++	{ERRbadpermits, -EINVAL},
++	{ERRbadPID, -ESRCH},
++	{ERRsetattrmode, -EINVAL},
++	{ERRpaused, -EHOSTDOWN},
++	{ERRmsgoff, -EHOSTDOWN},
++	{ERRnoroom, -ENOSPC},
++	{ERRrmuns, -EUSERS},
++	{ERRtimeout, -ETIME},
++	{ERRnoresource, -ENOBUFS},
++	{ERRtoomanyuids, -EUSERS},
++	{ERRbaduid, -EACCES},
++	{ERRusempx, -EIO},
++	{ERRusestd, -EIO},
++	{ERR_NOTIFY_ENUM_DIR, -ENOBUFS},
++	{ERRaccountexpired, -EACCES},
++	{ERRbadclient, -EACCES},
++	{ERRbadLogonTime, -EACCES},
++	{ERRpasswordExpired, -EACCES},
++	{ERRnosupport, -EINVAL},
++	{0, 0}
++};
++
++const struct smb_to_posix_error mapping_table_ERRHRD[] = {
++	{0, 0}
++};
++
++/* Convert string containing dotted ip address to binary form */
++/* returns 0 if invalid address */
++
++/* BB add address family, change rc to status flag and return union or for ipv6 */
++/*  will need parent to call something like inet_pton to convert ipv6 address  BB */
++int
++cifs_inet_pton(int address_family, char *cp,void *dst)
++{
++	struct in_addr address;
++	int value;
++	int digit;
++	int i;
++	char temp;
++	char bytes[4];
++	char *end = bytes;
++	static const int addr_class_max[4] =
++	    { 0xffffffff, 0xffffff, 0xffff, 0xff };
++
++	if(address_family != AF_INET)
++		return -EAFNOSUPPORT;
++
++	for (i = 0; i < 4; i++) {
++		bytes[i] = 0;
++	}
++
++	temp = *cp;
++
++	while (TRUE) {
++		if (!isdigit(temp))
++			return 0;
++
++		value = 0;
++		digit = 0;
++		for (;;) {
++			if (isascii(temp) && isdigit(temp)) {
++				value = (value * 10) + temp - '0';
++				temp = *++cp;
++				digit = 1;
++			} else
++				break;
++		}
++
++		if (temp == '.') {
++			if ((end > bytes + 2) || (value > 255))
++				return 0;
++			*end++ = value;
++			temp = *++cp;
++		} else if (temp == ':') {
++			cFYI(1,("IPv6 addresses not supported for CIFS mounts yet"));
++			return -1;
++		} else
++			break;
++	}
++
++	/* check for last characters */
++	if (temp != '\0' && (!isascii(temp) || !isspace(temp)))
++		if (temp != '\\') {
++			if (temp != '/')
++				return 0;
++			else
++				(*cp = '\\');	/* switch the slash the expected way */
++		}
++	if (value > addr_class_max[end - bytes])
++		return 0;
++
++	address.s_addr = *((int *) bytes) | htonl(value);
++	*((int *)dst) = address.s_addr;
++	return 1; /* success */
++}
++
++/*****************************************************************************
++convert a NT status code to a dos class/code
++ *****************************************************************************/
++/* NT status -> dos error map */
++static const struct {
++	__u8 dos_class;
++	__u16 dos_code;
++	__u32 ntstatus;
++} ntstatus_to_dos_map[] = {
++	{
++	ERRDOS, ERRgeneral, NT_STATUS_UNSUCCESSFUL}, {
++	ERRDOS, ERRbadfunc, NT_STATUS_NOT_IMPLEMENTED}, {
++	ERRDOS, 87, NT_STATUS_INVALID_INFO_CLASS}, {
++	ERRDOS, 24, NT_STATUS_INFO_LENGTH_MISMATCH}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ACCESS_VIOLATION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_IN_PAGE_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PAGEFILE_QUOTA}, {
++	ERRDOS, ERRbadfid, NT_STATUS_INVALID_HANDLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_INITIAL_STACK}, {
++	ERRDOS, 193, NT_STATUS_BAD_INITIAL_PC}, {
++	ERRDOS, 87, NT_STATUS_INVALID_CID}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TIMER_NOT_CANCELED}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER}, {
++	ERRDOS, ERRbadfile, NT_STATUS_NO_SUCH_DEVICE}, {
++	ERRDOS, ERRbadfile, NT_STATUS_NO_SUCH_FILE}, {
++	ERRDOS, ERRbadfunc, NT_STATUS_INVALID_DEVICE_REQUEST}, {
++	ERRDOS, 38, NT_STATUS_END_OF_FILE}, {
++	ERRDOS, 34, NT_STATUS_WRONG_VOLUME}, {
++	ERRDOS, 21, NT_STATUS_NO_MEDIA_IN_DEVICE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNRECOGNIZED_MEDIA}, {
++	ERRDOS, 27, NT_STATUS_NONEXISTENT_SECTOR},
++/*	{ This NT error code was 'sqashed'
++	 from NT_STATUS_MORE_PROCESSING_REQUIRED to NT_STATUS_OK 
++	 during the session setup } */
++	{
++	ERRDOS, ERRnomem, NT_STATUS_NO_MEMORY}, {
++	ERRDOS, 487, NT_STATUS_CONFLICTING_ADDRESSES}, {
++	ERRDOS, 487, NT_STATUS_NOT_MAPPED_VIEW}, {
++	ERRDOS, 87, NT_STATUS_UNABLE_TO_FREE_VM}, {
++	ERRDOS, 87, NT_STATUS_UNABLE_TO_DELETE_SECTION}, {
++	ERRDOS, 2142, NT_STATUS_INVALID_SYSTEM_SERVICE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ILLEGAL_INSTRUCTION}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_INVALID_LOCK_SEQUENCE}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_INVALID_VIEW_SIZE}, {
++	ERRDOS, 193, NT_STATUS_INVALID_FILE_FOR_SECTION}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_ALREADY_COMMITTED},
++/*	{ This NT error code was 'sqashed'
++	 from NT_STATUS_ACCESS_DENIED to NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE 
++	 during the session setup }   */
++	{
++	ERRDOS, ERRnoaccess, NT_STATUS_ACCESS_DENIED}, {
++	ERRDOS, 111, NT_STATUS_BUFFER_TOO_SMALL}, {
++	ERRDOS, ERRbadfid, NT_STATUS_OBJECT_TYPE_MISMATCH}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NONCONTINUABLE_EXCEPTION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_DISPOSITION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNWIND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_STACK}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_UNWIND_TARGET}, {
++	ERRDOS, 158, NT_STATUS_NOT_LOCKED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PARITY_ERROR}, {
++	ERRDOS, 487, NT_STATUS_UNABLE_TO_DECOMMIT_VM}, {
++	ERRDOS, 487, NT_STATUS_NOT_COMMITTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_PORT_ATTRIBUTES}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PORT_MESSAGE_TOO_LONG}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_MIX}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_QUOTA_LOWER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DISK_CORRUPT_ERROR}, {
++	ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_INVALID}, {	/* mapping changed since shell does lookup on * and expects file not found */
++	ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_NOT_FOUND}, {
++	ERRDOS, ERRalreadyexists, NT_STATUS_OBJECT_NAME_COLLISION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_HANDLE_NOT_WAITABLE}, {
++	ERRDOS, ERRbadfid, NT_STATUS_PORT_DISCONNECTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DEVICE_ALREADY_ATTACHED}, {
++	ERRDOS, 161, NT_STATUS_OBJECT_PATH_INVALID}, {
++	ERRDOS, ERRbadpath, NT_STATUS_OBJECT_PATH_NOT_FOUND}, {
++	ERRDOS, 161, NT_STATUS_OBJECT_PATH_SYNTAX_BAD}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DATA_OVERRUN}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DATA_LATE_ERROR}, {
++	ERRDOS, 23, NT_STATUS_DATA_ERROR}, {
++	ERRDOS, 23, NT_STATUS_CRC_ERROR}, {
++	ERRDOS, ERRnomem, NT_STATUS_SECTION_TOO_BIG}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_PORT_CONNECTION_REFUSED}, {
++	ERRDOS, ERRbadfid, NT_STATUS_INVALID_PORT_HANDLE}, {
++	ERRDOS, ERRbadshare, NT_STATUS_SHARING_VIOLATION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_QUOTA_EXCEEDED}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PAGE_PROTECTION}, {
++	ERRDOS, 288, NT_STATUS_MUTANT_NOT_OWNED}, {
++	ERRDOS, 298, NT_STATUS_SEMAPHORE_LIMIT_EXCEEDED}, {
++	ERRDOS, 87, NT_STATUS_PORT_ALREADY_SET}, {
++	ERRDOS, 87, NT_STATUS_SECTION_NOT_IMAGE}, {
++	ERRDOS, 156, NT_STATUS_SUSPEND_COUNT_EXCEEDED}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_THREAD_IS_TERMINATING}, {
++	ERRDOS, 87, NT_STATUS_BAD_WORKING_SET_LIMIT}, {
++	ERRDOS, 87, NT_STATUS_INCOMPATIBLE_FILE_MAP}, {
++	ERRDOS, 87, NT_STATUS_SECTION_PROTECTION}, {
++	ERRDOS, 282, NT_STATUS_EAS_NOT_SUPPORTED}, {
++	ERRDOS, 255, NT_STATUS_EA_TOO_LARGE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NONEXISTENT_EA_ENTRY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_EAS_ON_FILE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_EA_CORRUPT_ERROR}, {
++	ERRDOS, ERRlock, NT_STATUS_FILE_LOCK_CONFLICT}, {
++	ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED}, {
++	ERRDOS, ERRbadfile, NT_STATUS_DELETE_PENDING}, {
++	ERRDOS, ERRunsup, NT_STATUS_CTL_FILE_NOT_SUPPORTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNKNOWN_REVISION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REVISION_MISMATCH}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_OWNER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_PRIMARY_GROUP}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_IMPERSONATION_TOKEN}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANT_DISABLE_MANDATORY}, {
++	ERRDOS, 2215, NT_STATUS_NO_LOGON_SERVERS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SUCH_LOGON_SESSION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SUCH_PRIVILEGE}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_PRIVILEGE_NOT_HELD}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_ACCOUNT_NAME}, {
++	ERRHRD, ERRgeneral, NT_STATUS_USER_EXISTS},
++/*	{ This NT error code was 'sqashed'
++	 from NT_STATUS_NO_SUCH_USER to NT_STATUS_LOGON_FAILURE 
++	 during the session setup } */
++	{
++	ERRDOS, ERRnoaccess, NT_STATUS_NO_SUCH_USER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_GROUP_EXISTS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SUCH_GROUP}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MEMBER_IN_GROUP}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MEMBER_NOT_IN_GROUP}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LAST_ADMIN},
++/*	{ This NT error code was 'sqashed'
++	 from NT_STATUS_WRONG_PASSWORD to NT_STATUS_LOGON_FAILURE 
++	 during the session setup } */
++	{
++	ERRSRV, ERRbadpw, NT_STATUS_WRONG_PASSWORD}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ILL_FORMED_PASSWORD}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PASSWORD_RESTRICTION}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_LOGON_FAILURE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ACCOUNT_RESTRICTION}, {
++	ERRSRV, 2241, NT_STATUS_INVALID_LOGON_HOURS}, {
++	ERRSRV, 2240, NT_STATUS_INVALID_WORKSTATION}, {
++	ERRSRV, 2242, NT_STATUS_PASSWORD_EXPIRED}, {
++	ERRSRV, 2239, NT_STATUS_ACCOUNT_DISABLED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NONE_MAPPED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TOO_MANY_LUIDS_REQUESTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LUIDS_EXHAUSTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_SUB_AUTHORITY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_ACL}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_SID}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_SECURITY_DESCR}, {
++	ERRDOS, 127, NT_STATUS_PROCEDURE_NOT_FOUND}, {
++	ERRDOS, 193, NT_STATUS_INVALID_IMAGE_FORMAT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_TOKEN}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_INHERITANCE_ACL}, {
++	ERRDOS, 158, NT_STATUS_RANGE_NOT_LOCKED}, {
++	ERRDOS, 112, NT_STATUS_DISK_FULL}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SERVER_DISABLED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SERVER_NOT_DISABLED}, {
++	ERRDOS, 68, NT_STATUS_TOO_MANY_GUIDS_REQUESTED}, {
++	ERRDOS, 259, NT_STATUS_GUIDS_EXHAUSTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_ID_AUTHORITY}, {
++	ERRDOS, 259, NT_STATUS_AGENTS_EXHAUSTED}, {
++	ERRDOS, 154, NT_STATUS_INVALID_VOLUME_LABEL}, {
++	ERRDOS, 14, NT_STATUS_SECTION_NOT_EXTENDED}, {
++	ERRDOS, 487, NT_STATUS_NOT_MAPPED_DATA}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RESOURCE_DATA_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RESOURCE_TYPE_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RESOURCE_NAME_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ARRAY_BOUNDS_EXCEEDED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOAT_DENORMAL_OPERAND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOAT_DIVIDE_BY_ZERO}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOAT_INEXACT_RESULT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOAT_INVALID_OPERATION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOAT_OVERFLOW}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOAT_STACK_CHECK}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOAT_UNDERFLOW}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INTEGER_DIVIDE_BY_ZERO}, {
++	ERRDOS, 534, NT_STATUS_INTEGER_OVERFLOW}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PRIVILEGED_INSTRUCTION}, {
++	ERRDOS, ERRnomem, NT_STATUS_TOO_MANY_PAGING_FILES}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FILE_INVALID}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ALLOTTED_SPACE_EXCEEDED},
++/*	{ This NT error code was 'sqashed'
++	 from NT_STATUS_INSUFFICIENT_RESOURCES to NT_STATUS_INSUFF_SERVER_RESOURCES 
++	 during the session setup } */
++	{
++	ERRDOS, ERRnomem, NT_STATUS_INSUFFICIENT_RESOURCES}, {
++	ERRDOS, ERRbadpath, NT_STATUS_DFS_EXIT_PATH_FOUND}, {
++	ERRDOS, 23, NT_STATUS_DEVICE_DATA_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DEVICE_NOT_CONNECTED}, {
++	ERRDOS, 21, NT_STATUS_DEVICE_POWER_FAILURE}, {
++	ERRDOS, 487, NT_STATUS_FREE_VM_NOT_AT_BASE}, {
++	ERRDOS, 487, NT_STATUS_MEMORY_NOT_ALLOCATED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_WORKING_SET_QUOTA}, {
++	ERRDOS, 19, NT_STATUS_MEDIA_WRITE_PROTECTED}, {
++	ERRDOS, 21, NT_STATUS_DEVICE_NOT_READY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_GROUP_ATTRIBUTES}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_IMPERSONATION_LEVEL}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANT_OPEN_ANONYMOUS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_VALIDATION_CLASS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_TOKEN_TYPE}, {
++	ERRDOS, 87, NT_STATUS_BAD_MASTER_BOOT_RECORD}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INSTRUCTION_MISALIGNMENT}, {
++	ERRDOS, ERRpipebusy, NT_STATUS_INSTANCE_NOT_AVAILABLE}, {
++	ERRDOS, ERRpipebusy, NT_STATUS_PIPE_NOT_AVAILABLE}, {
++	ERRDOS, ERRbadpipe, NT_STATUS_INVALID_PIPE_STATE}, {
++	ERRDOS, ERRpipebusy, NT_STATUS_PIPE_BUSY}, {
++	ERRDOS, ERRbadfunc, NT_STATUS_ILLEGAL_FUNCTION}, {
++	ERRDOS, ERRnotconnected, NT_STATUS_PIPE_DISCONNECTED}, {
++	ERRDOS, ERRpipeclosing, NT_STATUS_PIPE_CLOSING}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PIPE_CONNECTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PIPE_LISTENING}, {
++	ERRDOS, ERRbadpipe, NT_STATUS_INVALID_READ_MODE}, {
++	ERRDOS, 121, NT_STATUS_IO_TIMEOUT}, {
++	ERRDOS, 38, NT_STATUS_FILE_FORCED_CLOSED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PROFILING_NOT_STARTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PROFILING_NOT_STOPPED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_COULD_NOT_INTERPRET}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_FILE_IS_A_DIRECTORY}, {
++	ERRDOS, ERRunsup, NT_STATUS_NOT_SUPPORTED}, {
++	ERRDOS, 51, NT_STATUS_REMOTE_NOT_LISTENING}, {
++	ERRDOS, 52, NT_STATUS_DUPLICATE_NAME}, {
++	ERRDOS, 53, NT_STATUS_BAD_NETWORK_PATH}, {
++	ERRDOS, 54, NT_STATUS_NETWORK_BUSY}, {
++	ERRDOS, 55, NT_STATUS_DEVICE_DOES_NOT_EXIST}, {
++	ERRDOS, 56, NT_STATUS_TOO_MANY_COMMANDS}, {
++	ERRDOS, 57, NT_STATUS_ADAPTER_HARDWARE_ERROR}, {
++	ERRDOS, 58, NT_STATUS_INVALID_NETWORK_RESPONSE}, {
++	ERRDOS, 59, NT_STATUS_UNEXPECTED_NETWORK_ERROR}, {
++	ERRDOS, 60, NT_STATUS_BAD_REMOTE_ADAPTER}, {
++	ERRDOS, 61, NT_STATUS_PRINT_QUEUE_FULL}, {
++	ERRDOS, 62, NT_STATUS_NO_SPOOL_SPACE}, {
++	ERRDOS, 63, NT_STATUS_PRINT_CANCELLED}, {
++	ERRDOS, 64, NT_STATUS_NETWORK_NAME_DELETED}, {
++	ERRDOS, 65, NT_STATUS_NETWORK_ACCESS_DENIED}, {
++	ERRDOS, 66, NT_STATUS_BAD_DEVICE_TYPE}, {
++	ERRDOS, ERRnosuchshare, NT_STATUS_BAD_NETWORK_NAME}, {
++	ERRDOS, 68, NT_STATUS_TOO_MANY_NAMES}, {
++	ERRDOS, 69, NT_STATUS_TOO_MANY_SESSIONS}, {
++	ERRDOS, 70, NT_STATUS_SHARING_PAUSED}, {
++	ERRDOS, 71, NT_STATUS_REQUEST_NOT_ACCEPTED}, {
++	ERRDOS, 72, NT_STATUS_REDIRECTOR_PAUSED}, {
++	ERRDOS, 88, NT_STATUS_NET_WRITE_FAULT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PROFILING_AT_LIMIT}, {
++	ERRDOS, ERRdiffdevice, NT_STATUS_NOT_SAME_DEVICE}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_FILE_RENAMED}, {
++	ERRDOS, 240, NT_STATUS_VIRTUAL_CIRCUIT_CLOSED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SECURITY_ON_OBJECT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANT_WAIT}, {
++	ERRDOS, ERRpipeclosing, NT_STATUS_PIPE_EMPTY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANT_ACCESS_DOMAIN_INFO}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANT_TERMINATE_SELF}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_SERVER_STATE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_DOMAIN_STATE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_DOMAIN_ROLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SUCH_DOMAIN}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DOMAIN_EXISTS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DOMAIN_LIMIT_EXCEEDED}, {
++	ERRDOS, 300, NT_STATUS_OPLOCK_NOT_GRANTED}, {
++	ERRDOS, 301, NT_STATUS_INVALID_OPLOCK_PROTOCOL}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INTERNAL_DB_CORRUPTION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INTERNAL_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_GENERIC_NOT_MAPPED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_DESCRIPTOR_FORMAT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_USER_BUFFER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNEXPECTED_IO_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNEXPECTED_MM_CREATE_ERR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNEXPECTED_MM_MAP_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNEXPECTED_MM_EXTEND_ERR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NOT_LOGON_PROCESS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOGON_SESSION_EXISTS}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_1}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_2}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_3}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_4}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_5}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_6}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_7}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_8}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_9}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_10}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_11}, {
++	ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_12}, {
++	ERRDOS, ERRbadpath, NT_STATUS_REDIRECTOR_NOT_STARTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REDIRECTOR_STARTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_STACK_OVERFLOW}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SUCH_PACKAGE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_FUNCTION_TABLE}, {
++	ERRDOS, 203, 0xc0000100}, {
++	ERRDOS, 145, NT_STATUS_DIRECTORY_NOT_EMPTY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FILE_CORRUPT_ERROR}, {
++	ERRDOS, 267, NT_STATUS_NOT_A_DIRECTORY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_LOGON_SESSION_STATE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOGON_SESSION_COLLISION}, {
++	ERRDOS, 206, NT_STATUS_NAME_TOO_LONG}, {
++	ERRDOS, 2401, NT_STATUS_FILES_OPEN}, {
++	ERRDOS, 2404, NT_STATUS_CONNECTION_IN_USE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MESSAGE_NOT_FOUND}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_PROCESS_IS_TERMINATING}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_LOGON_TYPE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_GUID_TRANSLATION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANNOT_IMPERSONATE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_IMAGE_ALREADY_LOADED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_NOT_PRESENT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_LID_NOT_EXIST}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_LID_ALREADY_OWNED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_NOT_LID_OWNER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_INVALID_COMMAND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_INVALID_LID}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_SELECTOR_NOT_AVAILABLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ABIOS_INVALID_SELECTOR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_LDT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_LDT_SIZE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_LDT_OFFSET}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_LDT_DESCRIPTOR}, {
++	ERRDOS, 193, NT_STATUS_INVALID_IMAGE_NE_FORMAT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RXACT_INVALID_STATE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RXACT_COMMIT_FAILURE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MAPPED_FILE_SIZE_ZERO}, {
++	ERRDOS, ERRnofids, NT_STATUS_TOO_MANY_OPENED_FILES}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANCELLED}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_CANNOT_DELETE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_COMPUTER_NAME}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_FILE_DELETED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SPECIAL_ACCOUNT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SPECIAL_GROUP}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SPECIAL_USER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MEMBERS_PRIMARY_GROUP}, {
++	ERRDOS, ERRbadfid, NT_STATUS_FILE_CLOSED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TOO_MANY_THREADS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_THREAD_NOT_IN_PROCESS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TOKEN_ALREADY_IN_USE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PAGEFILE_QUOTA_EXCEEDED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_COMMITMENT_LIMIT}, {
++	ERRDOS, 193, NT_STATUS_INVALID_IMAGE_LE_FORMAT}, {
++	ERRDOS, 193, NT_STATUS_INVALID_IMAGE_NOT_MZ}, {
++	ERRDOS, 193, NT_STATUS_INVALID_IMAGE_PROTECT}, {
++	ERRDOS, 193, NT_STATUS_INVALID_IMAGE_WIN_16}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOGON_SERVER_CONFLICT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TIME_DIFFERENCE_AT_DC}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SYNCHRONIZATION_REQUIRED}, {
++	ERRDOS, 126, NT_STATUS_DLL_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_OPEN_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_IO_PRIVILEGE_FAILED}, {
++	ERRDOS, 182, NT_STATUS_ORDINAL_NOT_FOUND}, {
++	ERRDOS, 127, NT_STATUS_ENTRYPOINT_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CONTROL_C_EXIT}, {
++	ERRDOS, 64, NT_STATUS_LOCAL_DISCONNECT}, {
++	ERRDOS, 64, NT_STATUS_REMOTE_DISCONNECT}, {
++	ERRDOS, 51, NT_STATUS_REMOTE_RESOURCES}, {
++	ERRDOS, 59, NT_STATUS_LINK_FAILED}, {
++	ERRDOS, 59, NT_STATUS_LINK_TIMEOUT}, {
++	ERRDOS, 59, NT_STATUS_INVALID_CONNECTION}, {
++	ERRDOS, 59, NT_STATUS_INVALID_ADDRESS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DLL_INIT_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MISSING_SYSTEMFILE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNHANDLED_EXCEPTION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_APP_INIT_FAILURE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PAGEFILE_CREATE_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_PAGEFILE}, {
++	ERRDOS, 124, NT_STATUS_INVALID_LEVEL}, {
++	ERRDOS, 86, NT_STATUS_WRONG_PASSWORD_CORE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ILLEGAL_FLOAT_CONTEXT}, {
++	ERRDOS, 109, NT_STATUS_PIPE_BROKEN}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REGISTRY_CORRUPT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REGISTRY_IO_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_EVENT_PAIR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNRECOGNIZED_VOLUME}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SERIAL_NO_DEVICE_INITED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SUCH_ALIAS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MEMBER_NOT_IN_ALIAS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MEMBER_IN_ALIAS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ALIAS_EXISTS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOGON_NOT_GRANTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TOO_MANY_SECRETS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SECRET_TOO_LONG}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INTERNAL_DB_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FULLSCREEN_MODE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TOO_MANY_CONTEXT_IDS}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_LOGON_TYPE_NOT_GRANTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NOT_REGISTRY_FILE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NT_CROSS_ENCRYPTION_REQUIRED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DOMAIN_CTRLR_CONFIG_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FT_MISSING_MEMBER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ILL_FORMED_SERVICE_ENTRY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ILLEGAL_CHARACTER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNMAPPABLE_CHARACTER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNDEFINED_CHARACTER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOPPY_VOLUME}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOPPY_ID_MARK_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOPPY_WRONG_CYLINDER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOPPY_UNKNOWN_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FLOPPY_BAD_REGISTERS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DISK_RECALIBRATE_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DISK_OPERATION_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DISK_RESET_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SHARED_IRQ_BUSY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FT_ORPHANING}, {
++	ERRHRD, ERRgeneral, 0xc000016e}, {
++	ERRHRD, ERRgeneral, 0xc000016f}, {
++	ERRHRD, ERRgeneral, 0xc0000170}, {
++	ERRHRD, ERRgeneral, 0xc0000171}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PARTITION_FAILURE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_BLOCK_LENGTH}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DEVICE_NOT_PARTITIONED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNABLE_TO_LOCK_MEDIA}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNABLE_TO_UNLOAD_MEDIA}, {
++	ERRHRD, ERRgeneral, NT_STATUS_EOM_OVERFLOW}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_MEDIA}, {
++	ERRHRD, ERRgeneral, 0xc0000179}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_SUCH_MEMBER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_MEMBER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_KEY_DELETED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_LOG_SPACE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TOO_MANY_SIDS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LM_CROSS_ENCRYPTION_REQUIRED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_KEY_HAS_CHILDREN}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CHILD_MUST_BE_VOLATILE}, {
++	ERRDOS, 87, NT_STATUS_DEVICE_CONFIGURATION_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DRIVER_INTERNAL_ERROR}, {
++	ERRDOS, 22, NT_STATUS_INVALID_DEVICE_STATE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_IO_DEVICE_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DEVICE_PROTOCOL_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BACKUP_CONTROLLER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOG_FILE_FULL}, {
++	ERRDOS, 19, NT_STATUS_TOO_LATE}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_NO_TRUST_LSA_SECRET},
++/*	{ This NT error code was 'sqashed'
++	 from NT_STATUS_NO_TRUST_SAM_ACCOUNT to NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE 
++	 during the session setup } */
++	{
++	ERRDOS, ERRnoaccess, NT_STATUS_NO_TRUST_SAM_ACCOUNT}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_TRUSTED_DOMAIN_FAILURE}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_EVENTLOG_FILE_CORRUPT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_EVENTLOG_CANT_START}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_TRUST_FAILURE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MUTANT_LIMIT_EXCEEDED}, {
++	ERRDOS, ERRnetlogonNotStarted, NT_STATUS_NETLOGON_NOT_STARTED}, {
++	ERRSRV, 2239, NT_STATUS_ACCOUNT_EXPIRED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_POSSIBLE_DEADLOCK}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NETWORK_CREDENTIAL_CONFLICT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REMOTE_SESSION_LIMIT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_EVENTLOG_FILE_CHANGED}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT},
++/*	{ This NT error code was 'sqashed'
++	 from NT_STATUS_DOMAIN_TRUST_INCONSISTENT to NT_STATUS_LOGON_FAILURE 
++	 during the session setup }  */
++	{
++	ERRDOS, ERRnoaccess, NT_STATUS_DOMAIN_TRUST_INCONSISTENT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FS_DRIVER_REQUIRED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_USER_SESSION_KEY}, {
++	ERRDOS, 59, NT_STATUS_USER_SESSION_DELETED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RESOURCE_LANG_NOT_FOUND}, {
++	ERRDOS, ERRnomem, NT_STATUS_INSUFF_SERVER_RESOURCES}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_BUFFER_SIZE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_ADDRESS_COMPONENT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_ADDRESS_WILDCARD}, {
++	ERRDOS, 68, NT_STATUS_TOO_MANY_ADDRESSES}, {
++	ERRDOS, 52, NT_STATUS_ADDRESS_ALREADY_EXISTS}, {
++	ERRDOS, 64, NT_STATUS_ADDRESS_CLOSED}, {
++	ERRDOS, 64, NT_STATUS_CONNECTION_DISCONNECTED}, {
++	ERRDOS, 64, NT_STATUS_CONNECTION_RESET}, {
++	ERRDOS, 68, NT_STATUS_TOO_MANY_NODES}, {
++	ERRDOS, 59, NT_STATUS_TRANSACTION_ABORTED}, {
++	ERRDOS, 59, NT_STATUS_TRANSACTION_TIMED_OUT}, {
++	ERRDOS, 59, NT_STATUS_TRANSACTION_NO_RELEASE}, {
++	ERRDOS, 59, NT_STATUS_TRANSACTION_NO_MATCH}, {
++	ERRDOS, 59, NT_STATUS_TRANSACTION_RESPONDED}, {
++	ERRDOS, 59, NT_STATUS_TRANSACTION_INVALID_ID}, {
++	ERRDOS, 59, NT_STATUS_TRANSACTION_INVALID_TYPE}, {
++	ERRDOS, ERRunsup, NT_STATUS_NOT_SERVER_SESSION}, {
++	ERRDOS, ERRunsup, NT_STATUS_NOT_CLIENT_SESSION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CANNOT_LOAD_REGISTRY_FILE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DEBUG_ATTACH_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_SYSTEM_PROCESS_TERMINATED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DATA_NOT_ACCEPTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_BROWSER_SERVERS_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_VDM_HARD_ERROR}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DRIVER_CANCEL_TIMEOUT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REPLY_MESSAGE_MISMATCH}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MAPPED_ALIGNMENT}, {
++	ERRDOS, 193, NT_STATUS_IMAGE_CHECKSUM_MISMATCH}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOST_WRITEBEHIND_DATA}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CLIENT_SERVER_PARAMETERS_INVALID}, {
++	ERRSRV, 2242, NT_STATUS_PASSWORD_MUST_CHANGE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NOT_TINY_STREAM}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RECOVERY_FAILURE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_STACK_OVERFLOW_READ}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FAIL_CHECK}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DUPLICATE_OBJECTID}, {
++	ERRHRD, ERRgeneral, NT_STATUS_OBJECTID_EXISTS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CONVERT_TO_LARGE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_RETRY}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FOUND_OUT_OF_SCOPE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ALLOCATE_BUCKET}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PROPSET_NOT_FOUND}, {
++	ERRHRD, ERRgeneral, NT_STATUS_MARSHALL_OVERFLOW}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_VARIANT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND}, {
++	ERRDOS, ERRnoaccess, NT_STATUS_ACCOUNT_LOCKED_OUT}, {
++	ERRDOS, ERRbadfid, NT_STATUS_HANDLE_NOT_CLOSABLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CONNECTION_REFUSED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_GRACEFUL_DISCONNECT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ADDRESS_ALREADY_ASSOCIATED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_ADDRESS_NOT_ASSOCIATED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CONNECTION_INVALID}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CONNECTION_ACTIVE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NETWORK_UNREACHABLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_HOST_UNREACHABLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PROTOCOL_UNREACHABLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PORT_UNREACHABLE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REQUEST_ABORTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CONNECTION_ABORTED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_COMPRESSION_BUFFER}, {
++	ERRHRD, ERRgeneral, NT_STATUS_USER_MAPPED_FILE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_AUDIT_FAILED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TIMER_RESOLUTION_NOT_SET}, {
++	ERRHRD, ERRgeneral, NT_STATUS_CONNECTION_COUNT_LIMIT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOGIN_TIME_RESTRICTION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LOGIN_WKSTA_RESTRICTION}, {
++	ERRDOS, 193, NT_STATUS_IMAGE_MP_UP_MISMATCH}, {
++	ERRHRD, ERRgeneral, 0xc000024a}, {
++	ERRHRD, ERRgeneral, 0xc000024b}, {
++	ERRHRD, ERRgeneral, 0xc000024c}, {
++	ERRHRD, ERRgeneral, 0xc000024d}, {
++	ERRHRD, ERRgeneral, 0xc000024e}, {
++	ERRHRD, ERRgeneral, 0xc000024f}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INSUFFICIENT_LOGON_INFO}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_DLL_ENTRYPOINT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_BAD_SERVICE_ENTRYPOINT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LPC_REPLY_LOST}, {
++	ERRHRD, ERRgeneral, NT_STATUS_IP_ADDRESS_CONFLICT1}, {
++	ERRHRD, ERRgeneral, NT_STATUS_IP_ADDRESS_CONFLICT2}, {
++	ERRHRD, ERRgeneral, NT_STATUS_REGISTRY_QUOTA_LIMIT}, {
++	ERRSRV, 3, NT_STATUS_PATH_NOT_COVERED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_NO_CALLBACK_ACTIVE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_LICENSE_QUOTA_EXCEEDED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PWD_TOO_SHORT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PWD_TOO_RECENT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PWD_HISTORY_CONFLICT}, {
++	ERRHRD, ERRgeneral, 0xc000025d}, {
++	ERRHRD, ERRgeneral, NT_STATUS_PLUGPLAY_NO_DEVICE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_UNSUPPORTED_COMPRESSION}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_HW_PROFILE}, {
++	ERRHRD, ERRgeneral, NT_STATUS_INVALID_PLUGPLAY_DEVICE_PATH}, {
++	ERRDOS, 182, NT_STATUS_DRIVER_ORDINAL_NOT_FOUND}, {
++	ERRDOS, 127, NT_STATUS_DRIVER_ENTRYPOINT_NOT_FOUND}, {
++	ERRDOS, 288, NT_STATUS_RESOURCE_NOT_OWNED}, {
++	ERRHRD, ERRgeneral, NT_STATUS_TOO_MANY_LINKS}, {
++	ERRHRD, ERRgeneral, NT_STATUS_QUOTA_LIST_INCONSISTENT}, {
++	ERRHRD, ERRgeneral, NT_STATUS_FILE_IS_OFFLINE}, {
++	ERRDOS, 21, 0xc000026e}, {
++	ERRDOS, 161, 0xc0000281}, {
++	ERRDOS, ERRnoaccess, 0xc000028a}, {
++	ERRDOS, ERRnoaccess, 0xc000028b}, {
++	ERRHRD, ERRgeneral, 0xc000028c}, {
++	ERRDOS, ERRnoaccess, 0xc000028d}, {
++	ERRDOS, ERRnoaccess, 0xc000028e}, {
++	ERRDOS, ERRnoaccess, 0xc000028f}, {
++	ERRDOS, ERRnoaccess, 0xc0000290}, {
++ERRDOS, ERRbadfunc, 0xc000029c},};
++
++/*****************************************************************************
++ Print an error message from the status code
++ *****************************************************************************/
++static void
++cifs_print_status(__u32 status_code)
++{
++	int idx = 0;
++
++	while (nt_errs[idx].nt_errstr != NULL) {
++		if (((nt_errs[idx].nt_errcode) & 0xFFFFFF) ==
++		    (status_code & 0xFFFFFF)) {
++			printk(KERN_NOTICE "Status code returned 0x%08x %s\n",
++				   status_code,nt_errs[idx].nt_errstr);
++		}
++		idx++;
++	}
++	return;
++}
++
++
++static void
++ntstatus_to_dos(__u32 ntstatus, __u8 * eclass, __u16 * ecode)
++{
++	int i;
++	if (ntstatus == 0) {
++		*eclass = 0;
++		*ecode = 0;
++		return;
++	}
++	for (i = 0; ntstatus_to_dos_map[i].ntstatus; i++) {
++		if (ntstatus == ntstatus_to_dos_map[i].ntstatus) {
++			*eclass = ntstatus_to_dos_map[i].dos_class;
++			*ecode = ntstatus_to_dos_map[i].dos_code;
++			return;
++		}
++	}
++	*eclass = ERRHRD;
++	*ecode = ERRgeneral;
++}
++
++int
++map_smb_to_linux_error(struct smb_hdr *smb)
++{
++	unsigned int i;
++	int rc = -EIO;		/* if transport error smb error may not be set */
++	__u8 smberrclass;
++	__u16 smberrcode;
++
++	/* BB if NT Status codes - map NT BB */
++
++	/* old style smb error codes */
++	if (smb->Status.CifsError == 0)
++		return 0;
++
++	if (smb->Flags2 & SMBFLG2_ERR_STATUS) {
++		/* translate the newer STATUS codes to old style errors and then to POSIX errors */
++		smb->Status.CifsError = le32_to_cpu(smb->Status.CifsError);
++		if(cifsFYI)
++			cifs_print_status(smb->Status.CifsError);
++		ntstatus_to_dos(smb->Status.CifsError, &smberrclass,
++				&smberrcode);
++	} else {
++		smberrclass = smb->Status.DosError.ErrorClass;
++		smb->Status.DosError.Error =
++		    le16_to_cpu(smb->Status.DosError.Error);
++		smberrcode = smb->Status.DosError.Error;
++	}
++
++	/* old style errors */
++
++	/* DOS class smb error codes - map DOS */
++	if (smberrclass == ERRDOS) {	/* one byte field no need to byte reverse */
++		for (i = 0;
++		     i <
++		     sizeof (mapping_table_ERRDOS) /
++		     sizeof (struct smb_to_posix_error); i++) {
++			if (mapping_table_ERRDOS[i].smb_err == 0)
++				break;
++			else if (mapping_table_ERRDOS[i].smb_err == smberrcode) {
++				rc = mapping_table_ERRDOS[i].posix_code;
++				break;
++			}
++			/* else try the next error mapping one to see if it will match */
++		}
++	} else if (smberrclass == ERRSRV) {	/* server class of error codes */
++		for (i = 0;
++		     i <
++		     sizeof (mapping_table_ERRSRV) /
++		     sizeof (struct smb_to_posix_error); i++) {
++			if (mapping_table_ERRSRV[i].smb_err == 0)
++				break;
++			else if (mapping_table_ERRSRV[i].smb_err == smberrcode) {
++				rc = mapping_table_ERRSRV[i].posix_code;
++				break;
++			}
++			/* else try the next error mapping one to see if it will match */
++		}
++	}
++	/* else ERRHRD class errors or junk  - return EIO */
++
++	cFYI(1, (" !!Mapping smb error code %d to POSIX err %d !!", smberrcode,rc));
++
++	/* generic corrective action e.g. reconnect SMB session on ERRbaduid could be added */
++
++	return rc;
++}
++
++/*
++ * calculate the size of the SMB message based on the fixed header
++ * portion, the number of word parameters and the data portion of the message
++ */
++unsigned int
++smbCalcSize(struct smb_hdr *ptr)
++{
++	return (sizeof (struct smb_hdr) + (2 * ptr->WordCount) +
++		BCC(ptr));
++}
++
++/* The following are taken from fs/ntfs/util.c */
++
++#define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
++
++    /*
++     * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
++     * into Unix UTC (based 1970-01-01, in seconds).
++     */
++time_t
++cifs_NTtimeToUnix(__u64 ntutc)
++{
++	/* BB what about the timezone? BB */
++
++	/* Subtract the NTFS time offset, then convert to 1s intervals. */
++	u64 t;
++
++	t = ntutc - NTFS_TIME_OFFSET;
++	do_div(t, 10000000);
++	return (time_t)t;
++}
++
++/* Convert the Unix UTC into NT UTC. */
++__u64
++cifs_UnixTimeToNT(time_t t)
++{
++	__u64 dce_time;
++   /* Convert to 100ns intervals and then add the NTFS time offset. */
++	dce_time = (__u64) t * 10000000;
++	dce_time += NTFS_TIME_OFFSET;
++	return dce_time;
++}
+diff -urN linux-2.4.29.old/fs/cifs/nterr.c linux-2.4.29/fs/cifs/nterr.c
+--- linux-2.4.29.old/fs/cifs/nterr.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/nterr.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,687 @@
++/* 
++ *  Unix SMB/Netbios implementation.
++ *  Version 1.9.
++ *  RPC Pipe client / server routines
++ *  Copyright (C) Luke Kenneth Casson Leighton 1997-2001.
++ *  
++ *  This program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2 of the License, or
++ *  (at your option) any later version.
++ *  
++ *  This program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *  GNU General Public License for more details.
++ *  
++ *  You should have received a copy of the GNU General Public License
++ *  along with this program; if not, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++/* NT error codes - see nterr.h */
++#include <linux/types.h>
++#include <linux/fs.h>
++#include "nterr.h"
++
++const struct nt_err_code_struct nt_errs[] = {
++	{"NT_STATUS_OK", NT_STATUS_OK},
++	{"NT_STATUS_UNSUCCESSFUL", NT_STATUS_UNSUCCESSFUL},
++	{"NT_STATUS_NOT_IMPLEMENTED", NT_STATUS_NOT_IMPLEMENTED},
++	{"NT_STATUS_INVALID_INFO_CLASS", NT_STATUS_INVALID_INFO_CLASS},
++	{"NT_STATUS_INFO_LENGTH_MISMATCH", NT_STATUS_INFO_LENGTH_MISMATCH},
++	{"NT_STATUS_ACCESS_VIOLATION", NT_STATUS_ACCESS_VIOLATION},
++	{"STATUS_BUFFER_OVERFLOW", STATUS_BUFFER_OVERFLOW},
++	{"NT_STATUS_IN_PAGE_ERROR", NT_STATUS_IN_PAGE_ERROR},
++	{"NT_STATUS_PAGEFILE_QUOTA", NT_STATUS_PAGEFILE_QUOTA},
++	{"NT_STATUS_INVALID_HANDLE", NT_STATUS_INVALID_HANDLE},
++	{"NT_STATUS_BAD_INITIAL_STACK", NT_STATUS_BAD_INITIAL_STACK},
++	{"NT_STATUS_BAD_INITIAL_PC", NT_STATUS_BAD_INITIAL_PC},
++	{"NT_STATUS_INVALID_CID", NT_STATUS_INVALID_CID},
++	{"NT_STATUS_TIMER_NOT_CANCELED", NT_STATUS_TIMER_NOT_CANCELED},
++	{"NT_STATUS_INVALID_PARAMETER", NT_STATUS_INVALID_PARAMETER},
++	{"NT_STATUS_NO_SUCH_DEVICE", NT_STATUS_NO_SUCH_DEVICE},
++	{"NT_STATUS_NO_SUCH_FILE", NT_STATUS_NO_SUCH_FILE},
++	{"NT_STATUS_INVALID_DEVICE_REQUEST",
++	 NT_STATUS_INVALID_DEVICE_REQUEST},
++	{"NT_STATUS_END_OF_FILE", NT_STATUS_END_OF_FILE},
++	{"NT_STATUS_WRONG_VOLUME", NT_STATUS_WRONG_VOLUME},
++	{"NT_STATUS_NO_MEDIA_IN_DEVICE", NT_STATUS_NO_MEDIA_IN_DEVICE},
++	{"NT_STATUS_UNRECOGNIZED_MEDIA", NT_STATUS_UNRECOGNIZED_MEDIA},
++	{"NT_STATUS_NONEXISTENT_SECTOR", NT_STATUS_NONEXISTENT_SECTOR},
++	{"NT_STATUS_MORE_PROCESSING_REQUIRED",
++	 NT_STATUS_MORE_PROCESSING_REQUIRED},
++	{"NT_STATUS_NO_MEMORY", NT_STATUS_NO_MEMORY},
++	{"NT_STATUS_CONFLICTING_ADDRESSES",
++	 NT_STATUS_CONFLICTING_ADDRESSES},
++	{"NT_STATUS_NOT_MAPPED_VIEW", NT_STATUS_NOT_MAPPED_VIEW},
++	{"NT_STATUS_UNABLE_TO_FREE_VM", NT_STATUS_UNABLE_TO_FREE_VM},
++	{"NT_STATUS_UNABLE_TO_DELETE_SECTION",
++	 NT_STATUS_UNABLE_TO_DELETE_SECTION},
++	{"NT_STATUS_INVALID_SYSTEM_SERVICE",
++	 NT_STATUS_INVALID_SYSTEM_SERVICE},
++	{"NT_STATUS_ILLEGAL_INSTRUCTION", NT_STATUS_ILLEGAL_INSTRUCTION},
++	{"NT_STATUS_INVALID_LOCK_SEQUENCE",
++	 NT_STATUS_INVALID_LOCK_SEQUENCE},
++	{"NT_STATUS_INVALID_VIEW_SIZE", NT_STATUS_INVALID_VIEW_SIZE},
++	{"NT_STATUS_INVALID_FILE_FOR_SECTION",
++	 NT_STATUS_INVALID_FILE_FOR_SECTION},
++	{"NT_STATUS_ALREADY_COMMITTED", NT_STATUS_ALREADY_COMMITTED},
++	{"NT_STATUS_ACCESS_DENIED", NT_STATUS_ACCESS_DENIED},
++	{"NT_STATUS_BUFFER_TOO_SMALL", NT_STATUS_BUFFER_TOO_SMALL},
++	{"NT_STATUS_OBJECT_TYPE_MISMATCH", NT_STATUS_OBJECT_TYPE_MISMATCH},
++	{"NT_STATUS_NONCONTINUABLE_EXCEPTION",
++	 NT_STATUS_NONCONTINUABLE_EXCEPTION},
++	{"NT_STATUS_INVALID_DISPOSITION", NT_STATUS_INVALID_DISPOSITION},
++	{"NT_STATUS_UNWIND", NT_STATUS_UNWIND},
++	{"NT_STATUS_BAD_STACK", NT_STATUS_BAD_STACK},
++	{"NT_STATUS_INVALID_UNWIND_TARGET",
++	 NT_STATUS_INVALID_UNWIND_TARGET},
++	{"NT_STATUS_NOT_LOCKED", NT_STATUS_NOT_LOCKED},
++	{"NT_STATUS_PARITY_ERROR", NT_STATUS_PARITY_ERROR},
++	{"NT_STATUS_UNABLE_TO_DECOMMIT_VM",
++	 NT_STATUS_UNABLE_TO_DECOMMIT_VM},
++	{"NT_STATUS_NOT_COMMITTED", NT_STATUS_NOT_COMMITTED},
++	{"NT_STATUS_INVALID_PORT_ATTRIBUTES",
++	 NT_STATUS_INVALID_PORT_ATTRIBUTES},
++	{"NT_STATUS_PORT_MESSAGE_TOO_LONG",
++	 NT_STATUS_PORT_MESSAGE_TOO_LONG},
++	{"NT_STATUS_INVALID_PARAMETER_MIX",
++	 NT_STATUS_INVALID_PARAMETER_MIX},
++	{"NT_STATUS_INVALID_QUOTA_LOWER", NT_STATUS_INVALID_QUOTA_LOWER},
++	{"NT_STATUS_DISK_CORRUPT_ERROR", NT_STATUS_DISK_CORRUPT_ERROR},
++	{"NT_STATUS_OBJECT_NAME_INVALID", NT_STATUS_OBJECT_NAME_INVALID},
++	{"NT_STATUS_OBJECT_NAME_NOT_FOUND",
++	 NT_STATUS_OBJECT_NAME_NOT_FOUND},
++	{"NT_STATUS_OBJECT_NAME_COLLISION",
++	 NT_STATUS_OBJECT_NAME_COLLISION},
++	{"NT_STATUS_HANDLE_NOT_WAITABLE", NT_STATUS_HANDLE_NOT_WAITABLE},
++	{"NT_STATUS_PORT_DISCONNECTED", NT_STATUS_PORT_DISCONNECTED},
++	{"NT_STATUS_DEVICE_ALREADY_ATTACHED",
++	 NT_STATUS_DEVICE_ALREADY_ATTACHED},
++	{"NT_STATUS_OBJECT_PATH_INVALID", NT_STATUS_OBJECT_PATH_INVALID},
++	{"NT_STATUS_OBJECT_PATH_NOT_FOUND",
++	 NT_STATUS_OBJECT_PATH_NOT_FOUND},
++	{"NT_STATUS_OBJECT_PATH_SYNTAX_BAD",
++	 NT_STATUS_OBJECT_PATH_SYNTAX_BAD},
++	{"NT_STATUS_DATA_OVERRUN", NT_STATUS_DATA_OVERRUN},
++	{"NT_STATUS_DATA_LATE_ERROR", NT_STATUS_DATA_LATE_ERROR},
++	{"NT_STATUS_DATA_ERROR", NT_STATUS_DATA_ERROR},
++	{"NT_STATUS_CRC_ERROR", NT_STATUS_CRC_ERROR},
++	{"NT_STATUS_SECTION_TOO_BIG", NT_STATUS_SECTION_TOO_BIG},
++	{"NT_STATUS_PORT_CONNECTION_REFUSED",
++	 NT_STATUS_PORT_CONNECTION_REFUSED},
++	{"NT_STATUS_INVALID_PORT_HANDLE", NT_STATUS_INVALID_PORT_HANDLE},
++	{"NT_STATUS_SHARING_VIOLATION", NT_STATUS_SHARING_VIOLATION},
++	{"NT_STATUS_QUOTA_EXCEEDED", NT_STATUS_QUOTA_EXCEEDED},
++	{"NT_STATUS_INVALID_PAGE_PROTECTION",
++	 NT_STATUS_INVALID_PAGE_PROTECTION},
++	{"NT_STATUS_MUTANT_NOT_OWNED", NT_STATUS_MUTANT_NOT_OWNED},
++	{"NT_STATUS_SEMAPHORE_LIMIT_EXCEEDED",
++	 NT_STATUS_SEMAPHORE_LIMIT_EXCEEDED},
++	{"NT_STATUS_PORT_ALREADY_SET", NT_STATUS_PORT_ALREADY_SET},
++	{"NT_STATUS_SECTION_NOT_IMAGE", NT_STATUS_SECTION_NOT_IMAGE},
++	{"NT_STATUS_SUSPEND_COUNT_EXCEEDED",
++	 NT_STATUS_SUSPEND_COUNT_EXCEEDED},
++	{"NT_STATUS_THREAD_IS_TERMINATING",
++	 NT_STATUS_THREAD_IS_TERMINATING},
++	{"NT_STATUS_BAD_WORKING_SET_LIMIT",
++	 NT_STATUS_BAD_WORKING_SET_LIMIT},
++	{"NT_STATUS_INCOMPATIBLE_FILE_MAP",
++	 NT_STATUS_INCOMPATIBLE_FILE_MAP},
++	{"NT_STATUS_SECTION_PROTECTION", NT_STATUS_SECTION_PROTECTION},
++	{"NT_STATUS_EAS_NOT_SUPPORTED", NT_STATUS_EAS_NOT_SUPPORTED},
++	{"NT_STATUS_EA_TOO_LARGE", NT_STATUS_EA_TOO_LARGE},
++	{"NT_STATUS_NONEXISTENT_EA_ENTRY", NT_STATUS_NONEXISTENT_EA_ENTRY},
++	{"NT_STATUS_NO_EAS_ON_FILE", NT_STATUS_NO_EAS_ON_FILE},
++	{"NT_STATUS_EA_CORRUPT_ERROR", NT_STATUS_EA_CORRUPT_ERROR},
++	{"NT_STATUS_FILE_LOCK_CONFLICT", NT_STATUS_FILE_LOCK_CONFLICT},
++	{"NT_STATUS_LOCK_NOT_GRANTED", NT_STATUS_LOCK_NOT_GRANTED},
++	{"NT_STATUS_DELETE_PENDING", NT_STATUS_DELETE_PENDING},
++	{"NT_STATUS_CTL_FILE_NOT_SUPPORTED",
++	 NT_STATUS_CTL_FILE_NOT_SUPPORTED},
++	{"NT_STATUS_UNKNOWN_REVISION", NT_STATUS_UNKNOWN_REVISION},
++	{"NT_STATUS_REVISION_MISMATCH", NT_STATUS_REVISION_MISMATCH},
++	{"NT_STATUS_INVALID_OWNER", NT_STATUS_INVALID_OWNER},
++	{"NT_STATUS_INVALID_PRIMARY_GROUP",
++	 NT_STATUS_INVALID_PRIMARY_GROUP},
++	{"NT_STATUS_NO_IMPERSONATION_TOKEN",
++	 NT_STATUS_NO_IMPERSONATION_TOKEN},
++	{"NT_STATUS_CANT_DISABLE_MANDATORY",
++	 NT_STATUS_CANT_DISABLE_MANDATORY},
++	{"NT_STATUS_NO_LOGON_SERVERS", NT_STATUS_NO_LOGON_SERVERS},
++	{"NT_STATUS_NO_SUCH_LOGON_SESSION",
++	 NT_STATUS_NO_SUCH_LOGON_SESSION},
++	{"NT_STATUS_NO_SUCH_PRIVILEGE", NT_STATUS_NO_SUCH_PRIVILEGE},
++	{"NT_STATUS_PRIVILEGE_NOT_HELD", NT_STATUS_PRIVILEGE_NOT_HELD},
++	{"NT_STATUS_INVALID_ACCOUNT_NAME", NT_STATUS_INVALID_ACCOUNT_NAME},
++	{"NT_STATUS_USER_EXISTS", NT_STATUS_USER_EXISTS},
++	{"NT_STATUS_NO_SUCH_USER", NT_STATUS_NO_SUCH_USER},
++	{"NT_STATUS_GROUP_EXISTS", NT_STATUS_GROUP_EXISTS},
++	{"NT_STATUS_NO_SUCH_GROUP", NT_STATUS_NO_SUCH_GROUP},
++	{"NT_STATUS_MEMBER_IN_GROUP", NT_STATUS_MEMBER_IN_GROUP},
++	{"NT_STATUS_MEMBER_NOT_IN_GROUP", NT_STATUS_MEMBER_NOT_IN_GROUP},
++	{"NT_STATUS_LAST_ADMIN", NT_STATUS_LAST_ADMIN},
++	{"NT_STATUS_WRONG_PASSWORD", NT_STATUS_WRONG_PASSWORD},
++	{"NT_STATUS_ILL_FORMED_PASSWORD", NT_STATUS_ILL_FORMED_PASSWORD},
++	{"NT_STATUS_PASSWORD_RESTRICTION", NT_STATUS_PASSWORD_RESTRICTION},
++	{"NT_STATUS_LOGON_FAILURE", NT_STATUS_LOGON_FAILURE},
++	{"NT_STATUS_ACCOUNT_RESTRICTION", NT_STATUS_ACCOUNT_RESTRICTION},
++	{"NT_STATUS_INVALID_LOGON_HOURS", NT_STATUS_INVALID_LOGON_HOURS},
++	{"NT_STATUS_INVALID_WORKSTATION", NT_STATUS_INVALID_WORKSTATION},
++	{"NT_STATUS_PASSWORD_EXPIRED", NT_STATUS_PASSWORD_EXPIRED},
++	{"NT_STATUS_ACCOUNT_DISABLED", NT_STATUS_ACCOUNT_DISABLED},
++	{"NT_STATUS_NONE_MAPPED", NT_STATUS_NONE_MAPPED},
++	{"NT_STATUS_TOO_MANY_LUIDS_REQUESTED",
++	 NT_STATUS_TOO_MANY_LUIDS_REQUESTED},
++	{"NT_STATUS_LUIDS_EXHAUSTED", NT_STATUS_LUIDS_EXHAUSTED},
++	{"NT_STATUS_INVALID_SUB_AUTHORITY",
++	 NT_STATUS_INVALID_SUB_AUTHORITY},
++	{"NT_STATUS_INVALID_ACL", NT_STATUS_INVALID_ACL},
++	{"NT_STATUS_INVALID_SID", NT_STATUS_INVALID_SID},
++	{"NT_STATUS_INVALID_SECURITY_DESCR",
++	 NT_STATUS_INVALID_SECURITY_DESCR},
++	{"NT_STATUS_PROCEDURE_NOT_FOUND", NT_STATUS_PROCEDURE_NOT_FOUND},
++	{"NT_STATUS_INVALID_IMAGE_FORMAT", NT_STATUS_INVALID_IMAGE_FORMAT},
++	{"NT_STATUS_NO_TOKEN", NT_STATUS_NO_TOKEN},
++	{"NT_STATUS_BAD_INHERITANCE_ACL", NT_STATUS_BAD_INHERITANCE_ACL},
++	{"NT_STATUS_RANGE_NOT_LOCKED", NT_STATUS_RANGE_NOT_LOCKED},
++	{"NT_STATUS_DISK_FULL", NT_STATUS_DISK_FULL},
++	{"NT_STATUS_SERVER_DISABLED", NT_STATUS_SERVER_DISABLED},
++	{"NT_STATUS_SERVER_NOT_DISABLED", NT_STATUS_SERVER_NOT_DISABLED},
++	{"NT_STATUS_TOO_MANY_GUIDS_REQUESTED",
++	 NT_STATUS_TOO_MANY_GUIDS_REQUESTED},
++	{"NT_STATUS_GUIDS_EXHAUSTED", NT_STATUS_GUIDS_EXHAUSTED},
++	{"NT_STATUS_INVALID_ID_AUTHORITY", NT_STATUS_INVALID_ID_AUTHORITY},
++	{"NT_STATUS_AGENTS_EXHAUSTED", NT_STATUS_AGENTS_EXHAUSTED},
++	{"NT_STATUS_INVALID_VOLUME_LABEL", NT_STATUS_INVALID_VOLUME_LABEL},
++	{"NT_STATUS_SECTION_NOT_EXTENDED", NT_STATUS_SECTION_NOT_EXTENDED},
++	{"NT_STATUS_NOT_MAPPED_DATA", NT_STATUS_NOT_MAPPED_DATA},
++	{"NT_STATUS_RESOURCE_DATA_NOT_FOUND",
++	 NT_STATUS_RESOURCE_DATA_NOT_FOUND},
++	{"NT_STATUS_RESOURCE_TYPE_NOT_FOUND",
++	 NT_STATUS_RESOURCE_TYPE_NOT_FOUND},
++	{"NT_STATUS_RESOURCE_NAME_NOT_FOUND",
++	 NT_STATUS_RESOURCE_NAME_NOT_FOUND},
++	{"NT_STATUS_ARRAY_BOUNDS_EXCEEDED",
++	 NT_STATUS_ARRAY_BOUNDS_EXCEEDED},
++	{"NT_STATUS_FLOAT_DENORMAL_OPERAND",
++	 NT_STATUS_FLOAT_DENORMAL_OPERAND},
++	{"NT_STATUS_FLOAT_DIVIDE_BY_ZERO", NT_STATUS_FLOAT_DIVIDE_BY_ZERO},
++	{"NT_STATUS_FLOAT_INEXACT_RESULT", NT_STATUS_FLOAT_INEXACT_RESULT},
++	{"NT_STATUS_FLOAT_INVALID_OPERATION",
++	 NT_STATUS_FLOAT_INVALID_OPERATION},
++	{"NT_STATUS_FLOAT_OVERFLOW", NT_STATUS_FLOAT_OVERFLOW},
++	{"NT_STATUS_FLOAT_STACK_CHECK", NT_STATUS_FLOAT_STACK_CHECK},
++	{"NT_STATUS_FLOAT_UNDERFLOW", NT_STATUS_FLOAT_UNDERFLOW},
++	{"NT_STATUS_INTEGER_DIVIDE_BY_ZERO",
++	 NT_STATUS_INTEGER_DIVIDE_BY_ZERO},
++	{"NT_STATUS_INTEGER_OVERFLOW", NT_STATUS_INTEGER_OVERFLOW},
++	{"NT_STATUS_PRIVILEGED_INSTRUCTION",
++	 NT_STATUS_PRIVILEGED_INSTRUCTION},
++	{"NT_STATUS_TOO_MANY_PAGING_FILES",
++	 NT_STATUS_TOO_MANY_PAGING_FILES},
++	{"NT_STATUS_FILE_INVALID", NT_STATUS_FILE_INVALID},
++	{"NT_STATUS_ALLOTTED_SPACE_EXCEEDED",
++	 NT_STATUS_ALLOTTED_SPACE_EXCEEDED},
++	{"NT_STATUS_INSUFFICIENT_RESOURCES",
++	 NT_STATUS_INSUFFICIENT_RESOURCES},
++	{"NT_STATUS_DFS_EXIT_PATH_FOUND", NT_STATUS_DFS_EXIT_PATH_FOUND},
++	{"NT_STATUS_DEVICE_DATA_ERROR", NT_STATUS_DEVICE_DATA_ERROR},
++	{"NT_STATUS_DEVICE_NOT_CONNECTED", NT_STATUS_DEVICE_NOT_CONNECTED},
++	{"NT_STATUS_DEVICE_POWER_FAILURE", NT_STATUS_DEVICE_POWER_FAILURE},
++	{"NT_STATUS_FREE_VM_NOT_AT_BASE", NT_STATUS_FREE_VM_NOT_AT_BASE},
++	{"NT_STATUS_MEMORY_NOT_ALLOCATED", NT_STATUS_MEMORY_NOT_ALLOCATED},
++	{"NT_STATUS_WORKING_SET_QUOTA", NT_STATUS_WORKING_SET_QUOTA},
++	{"NT_STATUS_MEDIA_WRITE_PROTECTED",
++	 NT_STATUS_MEDIA_WRITE_PROTECTED},
++	{"NT_STATUS_DEVICE_NOT_READY", NT_STATUS_DEVICE_NOT_READY},
++	{"NT_STATUS_INVALID_GROUP_ATTRIBUTES",
++	 NT_STATUS_INVALID_GROUP_ATTRIBUTES},
++	{"NT_STATUS_BAD_IMPERSONATION_LEVEL",
++	 NT_STATUS_BAD_IMPERSONATION_LEVEL},
++	{"NT_STATUS_CANT_OPEN_ANONYMOUS", NT_STATUS_CANT_OPEN_ANONYMOUS},
++	{"NT_STATUS_BAD_VALIDATION_CLASS", NT_STATUS_BAD_VALIDATION_CLASS},
++	{"NT_STATUS_BAD_TOKEN_TYPE", NT_STATUS_BAD_TOKEN_TYPE},
++	{"NT_STATUS_BAD_MASTER_BOOT_RECORD",
++	 NT_STATUS_BAD_MASTER_BOOT_RECORD},
++	{"NT_STATUS_INSTRUCTION_MISALIGNMENT",
++	 NT_STATUS_INSTRUCTION_MISALIGNMENT},
++	{"NT_STATUS_INSTANCE_NOT_AVAILABLE",
++	 NT_STATUS_INSTANCE_NOT_AVAILABLE},
++	{"NT_STATUS_PIPE_NOT_AVAILABLE", NT_STATUS_PIPE_NOT_AVAILABLE},
++	{"NT_STATUS_INVALID_PIPE_STATE", NT_STATUS_INVALID_PIPE_STATE},
++	{"NT_STATUS_PIPE_BUSY", NT_STATUS_PIPE_BUSY},
++	{"NT_STATUS_ILLEGAL_FUNCTION", NT_STATUS_ILLEGAL_FUNCTION},
++	{"NT_STATUS_PIPE_DISCONNECTED", NT_STATUS_PIPE_DISCONNECTED},
++	{"NT_STATUS_PIPE_CLOSING", NT_STATUS_PIPE_CLOSING},
++	{"NT_STATUS_PIPE_CONNECTED", NT_STATUS_PIPE_CONNECTED},
++	{"NT_STATUS_PIPE_LISTENING", NT_STATUS_PIPE_LISTENING},
++	{"NT_STATUS_INVALID_READ_MODE", NT_STATUS_INVALID_READ_MODE},
++	{"NT_STATUS_IO_TIMEOUT", NT_STATUS_IO_TIMEOUT},
++	{"NT_STATUS_FILE_FORCED_CLOSED", NT_STATUS_FILE_FORCED_CLOSED},
++	{"NT_STATUS_PROFILING_NOT_STARTED",
++	 NT_STATUS_PROFILING_NOT_STARTED},
++	{"NT_STATUS_PROFILING_NOT_STOPPED",
++	 NT_STATUS_PROFILING_NOT_STOPPED},
++	{"NT_STATUS_COULD_NOT_INTERPRET", NT_STATUS_COULD_NOT_INTERPRET},
++	{"NT_STATUS_FILE_IS_A_DIRECTORY", NT_STATUS_FILE_IS_A_DIRECTORY},
++	{"NT_STATUS_NOT_SUPPORTED", NT_STATUS_NOT_SUPPORTED},
++	{"NT_STATUS_REMOTE_NOT_LISTENING", NT_STATUS_REMOTE_NOT_LISTENING},
++	{"NT_STATUS_DUPLICATE_NAME", NT_STATUS_DUPLICATE_NAME},
++	{"NT_STATUS_BAD_NETWORK_PATH", NT_STATUS_BAD_NETWORK_PATH},
++	{"NT_STATUS_NETWORK_BUSY", NT_STATUS_NETWORK_BUSY},
++	{"NT_STATUS_DEVICE_DOES_NOT_EXIST",
++	 NT_STATUS_DEVICE_DOES_NOT_EXIST},
++	{"NT_STATUS_TOO_MANY_COMMANDS", NT_STATUS_TOO_MANY_COMMANDS},
++	{"NT_STATUS_ADAPTER_HARDWARE_ERROR",
++	 NT_STATUS_ADAPTER_HARDWARE_ERROR},
++	{"NT_STATUS_INVALID_NETWORK_RESPONSE",
++	 NT_STATUS_INVALID_NETWORK_RESPONSE},
++	{"NT_STATUS_UNEXPECTED_NETWORK_ERROR",
++	 NT_STATUS_UNEXPECTED_NETWORK_ERROR},
++	{"NT_STATUS_BAD_REMOTE_ADAPTER", NT_STATUS_BAD_REMOTE_ADAPTER},
++	{"NT_STATUS_PRINT_QUEUE_FULL", NT_STATUS_PRINT_QUEUE_FULL},
++	{"NT_STATUS_NO_SPOOL_SPACE", NT_STATUS_NO_SPOOL_SPACE},
++	{"NT_STATUS_PRINT_CANCELLED", NT_STATUS_PRINT_CANCELLED},
++	{"NT_STATUS_NETWORK_NAME_DELETED", NT_STATUS_NETWORK_NAME_DELETED},
++	{"NT_STATUS_NETWORK_ACCESS_DENIED",
++	 NT_STATUS_NETWORK_ACCESS_DENIED},
++	{"NT_STATUS_BAD_DEVICE_TYPE", NT_STATUS_BAD_DEVICE_TYPE},
++	{"NT_STATUS_BAD_NETWORK_NAME", NT_STATUS_BAD_NETWORK_NAME},
++	{"NT_STATUS_TOO_MANY_NAMES", NT_STATUS_TOO_MANY_NAMES},
++	{"NT_STATUS_TOO_MANY_SESSIONS", NT_STATUS_TOO_MANY_SESSIONS},
++	{"NT_STATUS_SHARING_PAUSED", NT_STATUS_SHARING_PAUSED},
++	{"NT_STATUS_REQUEST_NOT_ACCEPTED", NT_STATUS_REQUEST_NOT_ACCEPTED},
++	{"NT_STATUS_REDIRECTOR_PAUSED", NT_STATUS_REDIRECTOR_PAUSED},
++	{"NT_STATUS_NET_WRITE_FAULT", NT_STATUS_NET_WRITE_FAULT},
++	{"NT_STATUS_PROFILING_AT_LIMIT", NT_STATUS_PROFILING_AT_LIMIT},
++	{"NT_STATUS_NOT_SAME_DEVICE", NT_STATUS_NOT_SAME_DEVICE},
++	{"NT_STATUS_FILE_RENAMED", NT_STATUS_FILE_RENAMED},
++	{"NT_STATUS_VIRTUAL_CIRCUIT_CLOSED",
++	 NT_STATUS_VIRTUAL_CIRCUIT_CLOSED},
++	{"NT_STATUS_NO_SECURITY_ON_OBJECT",
++	 NT_STATUS_NO_SECURITY_ON_OBJECT},
++	{"NT_STATUS_CANT_WAIT", NT_STATUS_CANT_WAIT},
++	{"NT_STATUS_PIPE_EMPTY", NT_STATUS_PIPE_EMPTY},
++	{"NT_STATUS_CANT_ACCESS_DOMAIN_INFO",
++	 NT_STATUS_CANT_ACCESS_DOMAIN_INFO},
++	{"NT_STATUS_CANT_TERMINATE_SELF", NT_STATUS_CANT_TERMINATE_SELF},
++	{"NT_STATUS_INVALID_SERVER_STATE", NT_STATUS_INVALID_SERVER_STATE},
++	{"NT_STATUS_INVALID_DOMAIN_STATE", NT_STATUS_INVALID_DOMAIN_STATE},
++	{"NT_STATUS_INVALID_DOMAIN_ROLE", NT_STATUS_INVALID_DOMAIN_ROLE},
++	{"NT_STATUS_NO_SUCH_DOMAIN", NT_STATUS_NO_SUCH_DOMAIN},
++	{"NT_STATUS_DOMAIN_EXISTS", NT_STATUS_DOMAIN_EXISTS},
++	{"NT_STATUS_DOMAIN_LIMIT_EXCEEDED",
++	 NT_STATUS_DOMAIN_LIMIT_EXCEEDED},
++	{"NT_STATUS_OPLOCK_NOT_GRANTED", NT_STATUS_OPLOCK_NOT_GRANTED},
++	{"NT_STATUS_INVALID_OPLOCK_PROTOCOL",
++	 NT_STATUS_INVALID_OPLOCK_PROTOCOL},
++	{"NT_STATUS_INTERNAL_DB_CORRUPTION",
++	 NT_STATUS_INTERNAL_DB_CORRUPTION},
++	{"NT_STATUS_INTERNAL_ERROR", NT_STATUS_INTERNAL_ERROR},
++	{"NT_STATUS_GENERIC_NOT_MAPPED", NT_STATUS_GENERIC_NOT_MAPPED},
++	{"NT_STATUS_BAD_DESCRIPTOR_FORMAT",
++	 NT_STATUS_BAD_DESCRIPTOR_FORMAT},
++	{"NT_STATUS_INVALID_USER_BUFFER", NT_STATUS_INVALID_USER_BUFFER},
++	{"NT_STATUS_UNEXPECTED_IO_ERROR", NT_STATUS_UNEXPECTED_IO_ERROR},
++	{"NT_STATUS_UNEXPECTED_MM_CREATE_ERR",
++	 NT_STATUS_UNEXPECTED_MM_CREATE_ERR},
++	{"NT_STATUS_UNEXPECTED_MM_MAP_ERROR",
++	 NT_STATUS_UNEXPECTED_MM_MAP_ERROR},
++	{"NT_STATUS_UNEXPECTED_MM_EXTEND_ERR",
++	 NT_STATUS_UNEXPECTED_MM_EXTEND_ERR},
++	{"NT_STATUS_NOT_LOGON_PROCESS", NT_STATUS_NOT_LOGON_PROCESS},
++	{"NT_STATUS_LOGON_SESSION_EXISTS", NT_STATUS_LOGON_SESSION_EXISTS},
++	{"NT_STATUS_INVALID_PARAMETER_1", NT_STATUS_INVALID_PARAMETER_1},
++	{"NT_STATUS_INVALID_PARAMETER_2", NT_STATUS_INVALID_PARAMETER_2},
++	{"NT_STATUS_INVALID_PARAMETER_3", NT_STATUS_INVALID_PARAMETER_3},
++	{"NT_STATUS_INVALID_PARAMETER_4", NT_STATUS_INVALID_PARAMETER_4},
++	{"NT_STATUS_INVALID_PARAMETER_5", NT_STATUS_INVALID_PARAMETER_5},
++	{"NT_STATUS_INVALID_PARAMETER_6", NT_STATUS_INVALID_PARAMETER_6},
++	{"NT_STATUS_INVALID_PARAMETER_7", NT_STATUS_INVALID_PARAMETER_7},
++	{"NT_STATUS_INVALID_PARAMETER_8", NT_STATUS_INVALID_PARAMETER_8},
++	{"NT_STATUS_INVALID_PARAMETER_9", NT_STATUS_INVALID_PARAMETER_9},
++	{"NT_STATUS_INVALID_PARAMETER_10", NT_STATUS_INVALID_PARAMETER_10},
++	{"NT_STATUS_INVALID_PARAMETER_11", NT_STATUS_INVALID_PARAMETER_11},
++	{"NT_STATUS_INVALID_PARAMETER_12", NT_STATUS_INVALID_PARAMETER_12},
++	{"NT_STATUS_REDIRECTOR_NOT_STARTED",
++	 NT_STATUS_REDIRECTOR_NOT_STARTED},
++	{"NT_STATUS_REDIRECTOR_STARTED", NT_STATUS_REDIRECTOR_STARTED},
++	{"NT_STATUS_STACK_OVERFLOW", NT_STATUS_STACK_OVERFLOW},
++	{"NT_STATUS_NO_SUCH_PACKAGE", NT_STATUS_NO_SUCH_PACKAGE},
++	{"NT_STATUS_BAD_FUNCTION_TABLE", NT_STATUS_BAD_FUNCTION_TABLE},
++	{"NT_STATUS_DIRECTORY_NOT_EMPTY", NT_STATUS_DIRECTORY_NOT_EMPTY},
++	{"NT_STATUS_FILE_CORRUPT_ERROR", NT_STATUS_FILE_CORRUPT_ERROR},
++	{"NT_STATUS_NOT_A_DIRECTORY", NT_STATUS_NOT_A_DIRECTORY},
++	{"NT_STATUS_BAD_LOGON_SESSION_STATE",
++	 NT_STATUS_BAD_LOGON_SESSION_STATE},
++	{"NT_STATUS_LOGON_SESSION_COLLISION",
++	 NT_STATUS_LOGON_SESSION_COLLISION},
++	{"NT_STATUS_NAME_TOO_LONG", NT_STATUS_NAME_TOO_LONG},
++	{"NT_STATUS_FILES_OPEN", NT_STATUS_FILES_OPEN},
++	{"NT_STATUS_CONNECTION_IN_USE", NT_STATUS_CONNECTION_IN_USE},
++	{"NT_STATUS_MESSAGE_NOT_FOUND", NT_STATUS_MESSAGE_NOT_FOUND},
++	{"NT_STATUS_PROCESS_IS_TERMINATING",
++	 NT_STATUS_PROCESS_IS_TERMINATING},
++	{"NT_STATUS_INVALID_LOGON_TYPE", NT_STATUS_INVALID_LOGON_TYPE},
++	{"NT_STATUS_NO_GUID_TRANSLATION", NT_STATUS_NO_GUID_TRANSLATION},
++	{"NT_STATUS_CANNOT_IMPERSONATE", NT_STATUS_CANNOT_IMPERSONATE},
++	{"NT_STATUS_IMAGE_ALREADY_LOADED", NT_STATUS_IMAGE_ALREADY_LOADED},
++	{"NT_STATUS_ABIOS_NOT_PRESENT", NT_STATUS_ABIOS_NOT_PRESENT},
++	{"NT_STATUS_ABIOS_LID_NOT_EXIST", NT_STATUS_ABIOS_LID_NOT_EXIST},
++	{"NT_STATUS_ABIOS_LID_ALREADY_OWNED",
++	 NT_STATUS_ABIOS_LID_ALREADY_OWNED},
++	{"NT_STATUS_ABIOS_NOT_LID_OWNER", NT_STATUS_ABIOS_NOT_LID_OWNER},
++	{"NT_STATUS_ABIOS_INVALID_COMMAND",
++	 NT_STATUS_ABIOS_INVALID_COMMAND},
++	{"NT_STATUS_ABIOS_INVALID_LID", NT_STATUS_ABIOS_INVALID_LID},
++	{"NT_STATUS_ABIOS_SELECTOR_NOT_AVAILABLE",
++	 NT_STATUS_ABIOS_SELECTOR_NOT_AVAILABLE},
++	{"NT_STATUS_ABIOS_INVALID_SELECTOR",
++	 NT_STATUS_ABIOS_INVALID_SELECTOR},
++	{"NT_STATUS_NO_LDT", NT_STATUS_NO_LDT},
++	{"NT_STATUS_INVALID_LDT_SIZE", NT_STATUS_INVALID_LDT_SIZE},
++	{"NT_STATUS_INVALID_LDT_OFFSET", NT_STATUS_INVALID_LDT_OFFSET},
++	{"NT_STATUS_INVALID_LDT_DESCRIPTOR",
++	 NT_STATUS_INVALID_LDT_DESCRIPTOR},
++	{"NT_STATUS_INVALID_IMAGE_NE_FORMAT",
++	 NT_STATUS_INVALID_IMAGE_NE_FORMAT},
++	{"NT_STATUS_RXACT_INVALID_STATE", NT_STATUS_RXACT_INVALID_STATE},
++	{"NT_STATUS_RXACT_COMMIT_FAILURE", NT_STATUS_RXACT_COMMIT_FAILURE},
++	{"NT_STATUS_MAPPED_FILE_SIZE_ZERO",
++	 NT_STATUS_MAPPED_FILE_SIZE_ZERO},
++	{"NT_STATUS_TOO_MANY_OPENED_FILES",
++	 NT_STATUS_TOO_MANY_OPENED_FILES},
++	{"NT_STATUS_CANCELLED", NT_STATUS_CANCELLED},
++	{"NT_STATUS_CANNOT_DELETE", NT_STATUS_CANNOT_DELETE},
++	{"NT_STATUS_INVALID_COMPUTER_NAME",
++	 NT_STATUS_INVALID_COMPUTER_NAME},
++	{"NT_STATUS_FILE_DELETED", NT_STATUS_FILE_DELETED},
++	{"NT_STATUS_SPECIAL_ACCOUNT", NT_STATUS_SPECIAL_ACCOUNT},
++	{"NT_STATUS_SPECIAL_GROUP", NT_STATUS_SPECIAL_GROUP},
++	{"NT_STATUS_SPECIAL_USER", NT_STATUS_SPECIAL_USER},
++	{"NT_STATUS_MEMBERS_PRIMARY_GROUP",
++	 NT_STATUS_MEMBERS_PRIMARY_GROUP},
++	{"NT_STATUS_FILE_CLOSED", NT_STATUS_FILE_CLOSED},
++	{"NT_STATUS_TOO_MANY_THREADS", NT_STATUS_TOO_MANY_THREADS},
++	{"NT_STATUS_THREAD_NOT_IN_PROCESS",
++	 NT_STATUS_THREAD_NOT_IN_PROCESS},
++	{"NT_STATUS_TOKEN_ALREADY_IN_USE", NT_STATUS_TOKEN_ALREADY_IN_USE},
++	{"NT_STATUS_PAGEFILE_QUOTA_EXCEEDED",
++	 NT_STATUS_PAGEFILE_QUOTA_EXCEEDED},
++	{"NT_STATUS_COMMITMENT_LIMIT", NT_STATUS_COMMITMENT_LIMIT},
++	{"NT_STATUS_INVALID_IMAGE_LE_FORMAT",
++	 NT_STATUS_INVALID_IMAGE_LE_FORMAT},
++	{"NT_STATUS_INVALID_IMAGE_NOT_MZ", NT_STATUS_INVALID_IMAGE_NOT_MZ},
++	{"NT_STATUS_INVALID_IMAGE_PROTECT",
++	 NT_STATUS_INVALID_IMAGE_PROTECT},
++	{"NT_STATUS_INVALID_IMAGE_WIN_16", NT_STATUS_INVALID_IMAGE_WIN_16},
++	{"NT_STATUS_LOGON_SERVER_CONFLICT",
++	 NT_STATUS_LOGON_SERVER_CONFLICT},
++	{"NT_STATUS_TIME_DIFFERENCE_AT_DC",
++	 NT_STATUS_TIME_DIFFERENCE_AT_DC},
++	{"NT_STATUS_SYNCHRONIZATION_REQUIRED",
++	 NT_STATUS_SYNCHRONIZATION_REQUIRED},
++	{"NT_STATUS_DLL_NOT_FOUND", NT_STATUS_DLL_NOT_FOUND},
++	{"NT_STATUS_OPEN_FAILED", NT_STATUS_OPEN_FAILED},
++	{"NT_STATUS_IO_PRIVILEGE_FAILED", NT_STATUS_IO_PRIVILEGE_FAILED},
++	{"NT_STATUS_ORDINAL_NOT_FOUND", NT_STATUS_ORDINAL_NOT_FOUND},
++	{"NT_STATUS_ENTRYPOINT_NOT_FOUND", NT_STATUS_ENTRYPOINT_NOT_FOUND},
++	{"NT_STATUS_CONTROL_C_EXIT", NT_STATUS_CONTROL_C_EXIT},
++	{"NT_STATUS_LOCAL_DISCONNECT", NT_STATUS_LOCAL_DISCONNECT},
++	{"NT_STATUS_REMOTE_DISCONNECT", NT_STATUS_REMOTE_DISCONNECT},
++	{"NT_STATUS_REMOTE_RESOURCES", NT_STATUS_REMOTE_RESOURCES},
++	{"NT_STATUS_LINK_FAILED", NT_STATUS_LINK_FAILED},
++	{"NT_STATUS_LINK_TIMEOUT", NT_STATUS_LINK_TIMEOUT},
++	{"NT_STATUS_INVALID_CONNECTION", NT_STATUS_INVALID_CONNECTION},
++	{"NT_STATUS_INVALID_ADDRESS", NT_STATUS_INVALID_ADDRESS},
++	{"NT_STATUS_DLL_INIT_FAILED", NT_STATUS_DLL_INIT_FAILED},
++	{"NT_STATUS_MISSING_SYSTEMFILE", NT_STATUS_MISSING_SYSTEMFILE},
++	{"NT_STATUS_UNHANDLED_EXCEPTION", NT_STATUS_UNHANDLED_EXCEPTION},
++	{"NT_STATUS_APP_INIT_FAILURE", NT_STATUS_APP_INIT_FAILURE},
++	{"NT_STATUS_PAGEFILE_CREATE_FAILED",
++	 NT_STATUS_PAGEFILE_CREATE_FAILED},
++	{"NT_STATUS_NO_PAGEFILE", NT_STATUS_NO_PAGEFILE},
++	{"NT_STATUS_INVALID_LEVEL", NT_STATUS_INVALID_LEVEL},
++	{"NT_STATUS_WRONG_PASSWORD_CORE", NT_STATUS_WRONG_PASSWORD_CORE},
++	{"NT_STATUS_ILLEGAL_FLOAT_CONTEXT",
++	 NT_STATUS_ILLEGAL_FLOAT_CONTEXT},
++	{"NT_STATUS_PIPE_BROKEN", NT_STATUS_PIPE_BROKEN},
++	{"NT_STATUS_REGISTRY_CORRUPT", NT_STATUS_REGISTRY_CORRUPT},
++	{"NT_STATUS_REGISTRY_IO_FAILED", NT_STATUS_REGISTRY_IO_FAILED},
++	{"NT_STATUS_NO_EVENT_PAIR", NT_STATUS_NO_EVENT_PAIR},
++	{"NT_STATUS_UNRECOGNIZED_VOLUME", NT_STATUS_UNRECOGNIZED_VOLUME},
++	{"NT_STATUS_SERIAL_NO_DEVICE_INITED",
++	 NT_STATUS_SERIAL_NO_DEVICE_INITED},
++	{"NT_STATUS_NO_SUCH_ALIAS", NT_STATUS_NO_SUCH_ALIAS},
++	{"NT_STATUS_MEMBER_NOT_IN_ALIAS", NT_STATUS_MEMBER_NOT_IN_ALIAS},
++	{"NT_STATUS_MEMBER_IN_ALIAS", NT_STATUS_MEMBER_IN_ALIAS},
++	{"NT_STATUS_ALIAS_EXISTS", NT_STATUS_ALIAS_EXISTS},
++	{"NT_STATUS_LOGON_NOT_GRANTED", NT_STATUS_LOGON_NOT_GRANTED},
++	{"NT_STATUS_TOO_MANY_SECRETS", NT_STATUS_TOO_MANY_SECRETS},
++	{"NT_STATUS_SECRET_TOO_LONG", NT_STATUS_SECRET_TOO_LONG},
++	{"NT_STATUS_INTERNAL_DB_ERROR", NT_STATUS_INTERNAL_DB_ERROR},
++	{"NT_STATUS_FULLSCREEN_MODE", NT_STATUS_FULLSCREEN_MODE},
++	{"NT_STATUS_TOO_MANY_CONTEXT_IDS", NT_STATUS_TOO_MANY_CONTEXT_IDS},
++	{"NT_STATUS_LOGON_TYPE_NOT_GRANTED",
++	 NT_STATUS_LOGON_TYPE_NOT_GRANTED},
++	{"NT_STATUS_NOT_REGISTRY_FILE", NT_STATUS_NOT_REGISTRY_FILE},
++	{"NT_STATUS_NT_CROSS_ENCRYPTION_REQUIRED",
++	 NT_STATUS_NT_CROSS_ENCRYPTION_REQUIRED},
++	{"NT_STATUS_DOMAIN_CTRLR_CONFIG_ERROR",
++	 NT_STATUS_DOMAIN_CTRLR_CONFIG_ERROR},
++	{"NT_STATUS_FT_MISSING_MEMBER", NT_STATUS_FT_MISSING_MEMBER},
++	{"NT_STATUS_ILL_FORMED_SERVICE_ENTRY",
++	 NT_STATUS_ILL_FORMED_SERVICE_ENTRY},
++	{"NT_STATUS_ILLEGAL_CHARACTER", NT_STATUS_ILLEGAL_CHARACTER},
++	{"NT_STATUS_UNMAPPABLE_CHARACTER", NT_STATUS_UNMAPPABLE_CHARACTER},
++	{"NT_STATUS_UNDEFINED_CHARACTER", NT_STATUS_UNDEFINED_CHARACTER},
++	{"NT_STATUS_FLOPPY_VOLUME", NT_STATUS_FLOPPY_VOLUME},
++	{"NT_STATUS_FLOPPY_ID_MARK_NOT_FOUND",
++	 NT_STATUS_FLOPPY_ID_MARK_NOT_FOUND},
++	{"NT_STATUS_FLOPPY_WRONG_CYLINDER",
++	 NT_STATUS_FLOPPY_WRONG_CYLINDER},
++	{"NT_STATUS_FLOPPY_UNKNOWN_ERROR", NT_STATUS_FLOPPY_UNKNOWN_ERROR},
++	{"NT_STATUS_FLOPPY_BAD_REGISTERS", NT_STATUS_FLOPPY_BAD_REGISTERS},
++	{"NT_STATUS_DISK_RECALIBRATE_FAILED",
++	 NT_STATUS_DISK_RECALIBRATE_FAILED},
++	{"NT_STATUS_DISK_OPERATION_FAILED",
++	 NT_STATUS_DISK_OPERATION_FAILED},
++	{"NT_STATUS_DISK_RESET_FAILED", NT_STATUS_DISK_RESET_FAILED},
++	{"NT_STATUS_SHARED_IRQ_BUSY", NT_STATUS_SHARED_IRQ_BUSY},
++	{"NT_STATUS_FT_ORPHANING", NT_STATUS_FT_ORPHANING},
++	{"NT_STATUS_PARTITION_FAILURE", NT_STATUS_PARTITION_FAILURE},
++	{"NT_STATUS_INVALID_BLOCK_LENGTH", NT_STATUS_INVALID_BLOCK_LENGTH},
++	{"NT_STATUS_DEVICE_NOT_PARTITIONED",
++	 NT_STATUS_DEVICE_NOT_PARTITIONED},
++	{"NT_STATUS_UNABLE_TO_LOCK_MEDIA", NT_STATUS_UNABLE_TO_LOCK_MEDIA},
++	{"NT_STATUS_UNABLE_TO_UNLOAD_MEDIA",
++	 NT_STATUS_UNABLE_TO_UNLOAD_MEDIA},
++	{"NT_STATUS_EOM_OVERFLOW", NT_STATUS_EOM_OVERFLOW},
++	{"NT_STATUS_NO_MEDIA", NT_STATUS_NO_MEDIA},
++	{"NT_STATUS_NO_SUCH_MEMBER", NT_STATUS_NO_SUCH_MEMBER},
++	{"NT_STATUS_INVALID_MEMBER", NT_STATUS_INVALID_MEMBER},
++	{"NT_STATUS_KEY_DELETED", NT_STATUS_KEY_DELETED},
++	{"NT_STATUS_NO_LOG_SPACE", NT_STATUS_NO_LOG_SPACE},
++	{"NT_STATUS_TOO_MANY_SIDS", NT_STATUS_TOO_MANY_SIDS},
++	{"NT_STATUS_LM_CROSS_ENCRYPTION_REQUIRED",
++	 NT_STATUS_LM_CROSS_ENCRYPTION_REQUIRED},
++	{"NT_STATUS_KEY_HAS_CHILDREN", NT_STATUS_KEY_HAS_CHILDREN},
++	{"NT_STATUS_CHILD_MUST_BE_VOLATILE",
++	 NT_STATUS_CHILD_MUST_BE_VOLATILE},
++	{"NT_STATUS_DEVICE_CONFIGURATION_ERROR",
++	 NT_STATUS_DEVICE_CONFIGURATION_ERROR},
++	{"NT_STATUS_DRIVER_INTERNAL_ERROR",
++	 NT_STATUS_DRIVER_INTERNAL_ERROR},
++	{"NT_STATUS_INVALID_DEVICE_STATE", NT_STATUS_INVALID_DEVICE_STATE},
++	{"NT_STATUS_IO_DEVICE_ERROR", NT_STATUS_IO_DEVICE_ERROR},
++	{"NT_STATUS_DEVICE_PROTOCOL_ERROR",
++	 NT_STATUS_DEVICE_PROTOCOL_ERROR},
++	{"NT_STATUS_BACKUP_CONTROLLER", NT_STATUS_BACKUP_CONTROLLER},
++	{"NT_STATUS_LOG_FILE_FULL", NT_STATUS_LOG_FILE_FULL},
++	{"NT_STATUS_TOO_LATE", NT_STATUS_TOO_LATE},
++	{"NT_STATUS_NO_TRUST_LSA_SECRET", NT_STATUS_NO_TRUST_LSA_SECRET},
++	{"NT_STATUS_NO_TRUST_SAM_ACCOUNT", NT_STATUS_NO_TRUST_SAM_ACCOUNT},
++	{"NT_STATUS_TRUSTED_DOMAIN_FAILURE",
++	 NT_STATUS_TRUSTED_DOMAIN_FAILURE},
++	{"NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE",
++	 NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE},
++	{"NT_STATUS_EVENTLOG_FILE_CORRUPT",
++	 NT_STATUS_EVENTLOG_FILE_CORRUPT},
++	{"NT_STATUS_EVENTLOG_CANT_START", NT_STATUS_EVENTLOG_CANT_START},
++	{"NT_STATUS_TRUST_FAILURE", NT_STATUS_TRUST_FAILURE},
++	{"NT_STATUS_MUTANT_LIMIT_EXCEEDED",
++	 NT_STATUS_MUTANT_LIMIT_EXCEEDED},
++	{"NT_STATUS_NETLOGON_NOT_STARTED", NT_STATUS_NETLOGON_NOT_STARTED},
++	{"NT_STATUS_ACCOUNT_EXPIRED", NT_STATUS_ACCOUNT_EXPIRED},
++	{"NT_STATUS_POSSIBLE_DEADLOCK", NT_STATUS_POSSIBLE_DEADLOCK},
++	{"NT_STATUS_NETWORK_CREDENTIAL_CONFLICT",
++	 NT_STATUS_NETWORK_CREDENTIAL_CONFLICT},
++	{"NT_STATUS_REMOTE_SESSION_LIMIT", NT_STATUS_REMOTE_SESSION_LIMIT},
++	{"NT_STATUS_EVENTLOG_FILE_CHANGED",
++	 NT_STATUS_EVENTLOG_FILE_CHANGED},
++	{"NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT",
++	 NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT},
++	{"NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT",
++	 NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT},
++	{"NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT",
++	 NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT},
++	{"NT_STATUS_DOMAIN_TRUST_INCONSISTENT",
++	 NT_STATUS_DOMAIN_TRUST_INCONSISTENT},
++	{"NT_STATUS_FS_DRIVER_REQUIRED", NT_STATUS_FS_DRIVER_REQUIRED},
++	{"NT_STATUS_NO_USER_SESSION_KEY", NT_STATUS_NO_USER_SESSION_KEY},
++	{"NT_STATUS_USER_SESSION_DELETED", NT_STATUS_USER_SESSION_DELETED},
++	{"NT_STATUS_RESOURCE_LANG_NOT_FOUND",
++	 NT_STATUS_RESOURCE_LANG_NOT_FOUND},
++	{"NT_STATUS_INSUFF_SERVER_RESOURCES",
++	 NT_STATUS_INSUFF_SERVER_RESOURCES},
++	{"NT_STATUS_INVALID_BUFFER_SIZE", NT_STATUS_INVALID_BUFFER_SIZE},
++	{"NT_STATUS_INVALID_ADDRESS_COMPONENT",
++	 NT_STATUS_INVALID_ADDRESS_COMPONENT},
++	{"NT_STATUS_INVALID_ADDRESS_WILDCARD",
++	 NT_STATUS_INVALID_ADDRESS_WILDCARD},
++	{"NT_STATUS_TOO_MANY_ADDRESSES", NT_STATUS_TOO_MANY_ADDRESSES},
++	{"NT_STATUS_ADDRESS_ALREADY_EXISTS",
++	 NT_STATUS_ADDRESS_ALREADY_EXISTS},
++	{"NT_STATUS_ADDRESS_CLOSED", NT_STATUS_ADDRESS_CLOSED},
++	{"NT_STATUS_CONNECTION_DISCONNECTED",
++	 NT_STATUS_CONNECTION_DISCONNECTED},
++	{"NT_STATUS_CONNECTION_RESET", NT_STATUS_CONNECTION_RESET},
++	{"NT_STATUS_TOO_MANY_NODES", NT_STATUS_TOO_MANY_NODES},
++	{"NT_STATUS_TRANSACTION_ABORTED", NT_STATUS_TRANSACTION_ABORTED},
++	{"NT_STATUS_TRANSACTION_TIMED_OUT",
++	 NT_STATUS_TRANSACTION_TIMED_OUT},
++	{"NT_STATUS_TRANSACTION_NO_RELEASE",
++	 NT_STATUS_TRANSACTION_NO_RELEASE},
++	{"NT_STATUS_TRANSACTION_NO_MATCH", NT_STATUS_TRANSACTION_NO_MATCH},
++	{"NT_STATUS_TRANSACTION_RESPONDED",
++	 NT_STATUS_TRANSACTION_RESPONDED},
++	{"NT_STATUS_TRANSACTION_INVALID_ID",
++	 NT_STATUS_TRANSACTION_INVALID_ID},
++	{"NT_STATUS_TRANSACTION_INVALID_TYPE",
++	 NT_STATUS_TRANSACTION_INVALID_TYPE},
++	{"NT_STATUS_NOT_SERVER_SESSION", NT_STATUS_NOT_SERVER_SESSION},
++	{"NT_STATUS_NOT_CLIENT_SESSION", NT_STATUS_NOT_CLIENT_SESSION},
++	{"NT_STATUS_CANNOT_LOAD_REGISTRY_FILE",
++	 NT_STATUS_CANNOT_LOAD_REGISTRY_FILE},
++	{"NT_STATUS_DEBUG_ATTACH_FAILED", NT_STATUS_DEBUG_ATTACH_FAILED},
++	{"NT_STATUS_SYSTEM_PROCESS_TERMINATED",
++	 NT_STATUS_SYSTEM_PROCESS_TERMINATED},
++	{"NT_STATUS_DATA_NOT_ACCEPTED", NT_STATUS_DATA_NOT_ACCEPTED},
++	{"NT_STATUS_NO_BROWSER_SERVERS_FOUND",
++	 NT_STATUS_NO_BROWSER_SERVERS_FOUND},
++	{"NT_STATUS_VDM_HARD_ERROR", NT_STATUS_VDM_HARD_ERROR},
++	{"NT_STATUS_DRIVER_CANCEL_TIMEOUT",
++	 NT_STATUS_DRIVER_CANCEL_TIMEOUT},
++	{"NT_STATUS_REPLY_MESSAGE_MISMATCH",
++	 NT_STATUS_REPLY_MESSAGE_MISMATCH},
++	{"NT_STATUS_MAPPED_ALIGNMENT", NT_STATUS_MAPPED_ALIGNMENT},
++	{"NT_STATUS_IMAGE_CHECKSUM_MISMATCH",
++	 NT_STATUS_IMAGE_CHECKSUM_MISMATCH},
++	{"NT_STATUS_LOST_WRITEBEHIND_DATA",
++	 NT_STATUS_LOST_WRITEBEHIND_DATA},
++	{"NT_STATUS_CLIENT_SERVER_PARAMETERS_INVALID",
++	 NT_STATUS_CLIENT_SERVER_PARAMETERS_INVALID},
++	{"NT_STATUS_PASSWORD_MUST_CHANGE", NT_STATUS_PASSWORD_MUST_CHANGE},
++	{"NT_STATUS_NOT_FOUND", NT_STATUS_NOT_FOUND},
++	{"NT_STATUS_NOT_TINY_STREAM", NT_STATUS_NOT_TINY_STREAM},
++	{"NT_STATUS_RECOVERY_FAILURE", NT_STATUS_RECOVERY_FAILURE},
++	{"NT_STATUS_STACK_OVERFLOW_READ", NT_STATUS_STACK_OVERFLOW_READ},
++	{"NT_STATUS_FAIL_CHECK", NT_STATUS_FAIL_CHECK},
++	{"NT_STATUS_DUPLICATE_OBJECTID", NT_STATUS_DUPLICATE_OBJECTID},
++	{"NT_STATUS_OBJECTID_EXISTS", NT_STATUS_OBJECTID_EXISTS},
++	{"NT_STATUS_CONVERT_TO_LARGE", NT_STATUS_CONVERT_TO_LARGE},
++	{"NT_STATUS_RETRY", NT_STATUS_RETRY},
++	{"NT_STATUS_FOUND_OUT_OF_SCOPE", NT_STATUS_FOUND_OUT_OF_SCOPE},
++	{"NT_STATUS_ALLOCATE_BUCKET", NT_STATUS_ALLOCATE_BUCKET},
++	{"NT_STATUS_PROPSET_NOT_FOUND", NT_STATUS_PROPSET_NOT_FOUND},
++	{"NT_STATUS_MARSHALL_OVERFLOW", NT_STATUS_MARSHALL_OVERFLOW},
++	{"NT_STATUS_INVALID_VARIANT", NT_STATUS_INVALID_VARIANT},
++	{"NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND",
++	 NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND},
++	{"NT_STATUS_ACCOUNT_LOCKED_OUT", NT_STATUS_ACCOUNT_LOCKED_OUT},
++	{"NT_STATUS_HANDLE_NOT_CLOSABLE", NT_STATUS_HANDLE_NOT_CLOSABLE},
++	{"NT_STATUS_CONNECTION_REFUSED", NT_STATUS_CONNECTION_REFUSED},
++	{"NT_STATUS_GRACEFUL_DISCONNECT", NT_STATUS_GRACEFUL_DISCONNECT},
++	{"NT_STATUS_ADDRESS_ALREADY_ASSOCIATED",
++	 NT_STATUS_ADDRESS_ALREADY_ASSOCIATED},
++	{"NT_STATUS_ADDRESS_NOT_ASSOCIATED",
++	 NT_STATUS_ADDRESS_NOT_ASSOCIATED},
++	{"NT_STATUS_CONNECTION_INVALID", NT_STATUS_CONNECTION_INVALID},
++	{"NT_STATUS_CONNECTION_ACTIVE", NT_STATUS_CONNECTION_ACTIVE},
++	{"NT_STATUS_NETWORK_UNREACHABLE", NT_STATUS_NETWORK_UNREACHABLE},
++	{"NT_STATUS_HOST_UNREACHABLE", NT_STATUS_HOST_UNREACHABLE},
++	{"NT_STATUS_PROTOCOL_UNREACHABLE", NT_STATUS_PROTOCOL_UNREACHABLE},
++	{"NT_STATUS_PORT_UNREACHABLE", NT_STATUS_PORT_UNREACHABLE},
++	{"NT_STATUS_REQUEST_ABORTED", NT_STATUS_REQUEST_ABORTED},
++	{"NT_STATUS_CONNECTION_ABORTED", NT_STATUS_CONNECTION_ABORTED},
++	{"NT_STATUS_BAD_COMPRESSION_BUFFER",
++	 NT_STATUS_BAD_COMPRESSION_BUFFER},
++	{"NT_STATUS_USER_MAPPED_FILE", NT_STATUS_USER_MAPPED_FILE},
++	{"NT_STATUS_AUDIT_FAILED", NT_STATUS_AUDIT_FAILED},
++	{"NT_STATUS_TIMER_RESOLUTION_NOT_SET",
++	 NT_STATUS_TIMER_RESOLUTION_NOT_SET},
++	{"NT_STATUS_CONNECTION_COUNT_LIMIT",
++	 NT_STATUS_CONNECTION_COUNT_LIMIT},
++	{"NT_STATUS_LOGIN_TIME_RESTRICTION",
++	 NT_STATUS_LOGIN_TIME_RESTRICTION},
++	{"NT_STATUS_LOGIN_WKSTA_RESTRICTION",
++	 NT_STATUS_LOGIN_WKSTA_RESTRICTION},
++	{"NT_STATUS_IMAGE_MP_UP_MISMATCH", NT_STATUS_IMAGE_MP_UP_MISMATCH},
++	{"NT_STATUS_INSUFFICIENT_LOGON_INFO",
++	 NT_STATUS_INSUFFICIENT_LOGON_INFO},
++	{"NT_STATUS_BAD_DLL_ENTRYPOINT", NT_STATUS_BAD_DLL_ENTRYPOINT},
++	{"NT_STATUS_BAD_SERVICE_ENTRYPOINT",
++	 NT_STATUS_BAD_SERVICE_ENTRYPOINT},
++	{"NT_STATUS_LPC_REPLY_LOST", NT_STATUS_LPC_REPLY_LOST},
++	{"NT_STATUS_IP_ADDRESS_CONFLICT1", NT_STATUS_IP_ADDRESS_CONFLICT1},
++	{"NT_STATUS_IP_ADDRESS_CONFLICT2", NT_STATUS_IP_ADDRESS_CONFLICT2},
++	{"NT_STATUS_REGISTRY_QUOTA_LIMIT", NT_STATUS_REGISTRY_QUOTA_LIMIT},
++	{"NT_STATUS_PATH_NOT_COVERED", NT_STATUS_PATH_NOT_COVERED},
++	{"NT_STATUS_NO_CALLBACK_ACTIVE", NT_STATUS_NO_CALLBACK_ACTIVE},
++	{"NT_STATUS_LICENSE_QUOTA_EXCEEDED",
++	 NT_STATUS_LICENSE_QUOTA_EXCEEDED},
++	{"NT_STATUS_PWD_TOO_SHORT", NT_STATUS_PWD_TOO_SHORT},
++	{"NT_STATUS_PWD_TOO_RECENT", NT_STATUS_PWD_TOO_RECENT},
++	{"NT_STATUS_PWD_HISTORY_CONFLICT", NT_STATUS_PWD_HISTORY_CONFLICT},
++	{"NT_STATUS_PLUGPLAY_NO_DEVICE", NT_STATUS_PLUGPLAY_NO_DEVICE},
++	{"NT_STATUS_UNSUPPORTED_COMPRESSION",
++	 NT_STATUS_UNSUPPORTED_COMPRESSION},
++	{"NT_STATUS_INVALID_HW_PROFILE", NT_STATUS_INVALID_HW_PROFILE},
++	{"NT_STATUS_INVALID_PLUGPLAY_DEVICE_PATH",
++	 NT_STATUS_INVALID_PLUGPLAY_DEVICE_PATH},
++	{"NT_STATUS_DRIVER_ORDINAL_NOT_FOUND",
++	 NT_STATUS_DRIVER_ORDINAL_NOT_FOUND},
++	{"NT_STATUS_DRIVER_ENTRYPOINT_NOT_FOUND",
++	 NT_STATUS_DRIVER_ENTRYPOINT_NOT_FOUND},
++	{"NT_STATUS_RESOURCE_NOT_OWNED", NT_STATUS_RESOURCE_NOT_OWNED},
++	{"NT_STATUS_TOO_MANY_LINKS", NT_STATUS_TOO_MANY_LINKS},
++	{"NT_STATUS_QUOTA_LIST_INCONSISTENT",
++	 NT_STATUS_QUOTA_LIST_INCONSISTENT},
++	{"NT_STATUS_FILE_IS_OFFLINE", NT_STATUS_FILE_IS_OFFLINE},
++	{"NT_STATUS_NO_MORE_ENTRIES", NT_STATUS_NO_MORE_ENTRIES},
++	{"STATUS_MORE_ENTRIES", STATUS_MORE_ENTRIES},
++	{"STATUS_SOME_UNMAPPED", STATUS_SOME_UNMAPPED},
++	{NULL, 0}
++};
+diff -urN linux-2.4.29.old/fs/cifs/nterr.h linux-2.4.29/fs/cifs/nterr.h
+--- linux-2.4.29.old/fs/cifs/nterr.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/nterr.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,556 @@
++/* 
++   Unix SMB/Netbios implementation.
++   Version 1.9.
++   NT error code constants
++   Copyright (C) Andrew Tridgell              1992-2000
++   Copyright (C) John H Terpstra              1996-2000
++   Copyright (C) Luke Kenneth Casson Leighton 1996-2000
++   Copyright (C) Paul Ashton                  1998-2000
++   
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++   
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++   
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++*/
++
++
++
++#ifndef _NTERR_H
++#define _NTERR_H
++
++struct nt_err_code_struct {
++	char *nt_errstr;
++	__u32 nt_errcode;
++};
++
++extern const struct nt_err_code_struct nt_errs[];
++
++/* Win32 Status codes. */
++
++#define STATUS_BUFFER_OVERFLOW            0x80000005
++#define STATUS_MORE_ENTRIES               0x0105
++#define ERROR_INVALID_PARAMETER		  0x0057
++#define ERROR_INSUFFICIENT_BUFFER	  0x007a
++#define STATUS_1804	                  0x070c
++#define STATUS_NOTIFY_ENUM_DIR            0x010c
++
++/* Win32 Error codes extracted using a loop in smbclient then printing a
++   netmon sniff to a file. */
++
++#define NT_STATUS_OK 0x0000
++#define STATUS_SOME_UNMAPPED       0x0107
++#define STATUS_BUFFER_OVERFLOW     0x80000005
++#define NT_STATUS_NO_MORE_ENTRIES  0x8000001a
++#define NT_STATUS_UNSUCCESSFUL 0xC0000000 | 0x0001
++#define NT_STATUS_NOT_IMPLEMENTED 0xC0000000 | 0x0002
++#define NT_STATUS_INVALID_INFO_CLASS 0xC0000000 | 0x0003
++#define NT_STATUS_INFO_LENGTH_MISMATCH 0xC0000000 | 0x0004
++#define NT_STATUS_ACCESS_VIOLATION 0xC0000000 | 0x0005
++#define NT_STATUS_IN_PAGE_ERROR 0xC0000000 | 0x0006
++#define NT_STATUS_PAGEFILE_QUOTA 0xC0000000 | 0x0007
++#define NT_STATUS_INVALID_HANDLE 0xC0000000 | 0x0008
++#define NT_STATUS_BAD_INITIAL_STACK 0xC0000000 | 0x0009
++#define NT_STATUS_BAD_INITIAL_PC 0xC0000000 | 0x000a
++#define NT_STATUS_INVALID_CID 0xC0000000 | 0x000b
++#define NT_STATUS_TIMER_NOT_CANCELED 0xC0000000 | 0x000c
++#define NT_STATUS_INVALID_PARAMETER 0xC0000000 | 0x000d
++#define NT_STATUS_NO_SUCH_DEVICE 0xC0000000 | 0x000e
++#define NT_STATUS_NO_SUCH_FILE 0xC0000000 | 0x000f
++#define NT_STATUS_INVALID_DEVICE_REQUEST 0xC0000000 | 0x0010
++#define NT_STATUS_END_OF_FILE 0xC0000000 | 0x0011
++#define NT_STATUS_WRONG_VOLUME 0xC0000000 | 0x0012
++#define NT_STATUS_NO_MEDIA_IN_DEVICE 0xC0000000 | 0x0013
++#define NT_STATUS_UNRECOGNIZED_MEDIA 0xC0000000 | 0x0014
++#define NT_STATUS_NONEXISTENT_SECTOR 0xC0000000 | 0x0015
++#define NT_STATUS_MORE_PROCESSING_REQUIRED 0xC0000000 | 0x0016
++#define NT_STATUS_NO_MEMORY 0xC0000000 | 0x0017
++#define NT_STATUS_CONFLICTING_ADDRESSES 0xC0000000 | 0x0018
++#define NT_STATUS_NOT_MAPPED_VIEW 0xC0000000 | 0x0019
++#define NT_STATUS_UNABLE_TO_FREE_VM 0x80000000 | 0x001a
++#define NT_STATUS_UNABLE_TO_DELETE_SECTION 0xC0000000 | 0x001b
++#define NT_STATUS_INVALID_SYSTEM_SERVICE 0xC0000000 | 0x001c
++#define NT_STATUS_ILLEGAL_INSTRUCTION 0xC0000000 | 0x001d
++#define NT_STATUS_INVALID_LOCK_SEQUENCE 0xC0000000 | 0x001e
++#define NT_STATUS_INVALID_VIEW_SIZE 0xC0000000 | 0x001f
++#define NT_STATUS_INVALID_FILE_FOR_SECTION 0xC0000000 | 0x0020
++#define NT_STATUS_ALREADY_COMMITTED 0xC0000000 | 0x0021
++#define NT_STATUS_ACCESS_DENIED 0xC0000000 | 0x0022
++#define NT_STATUS_BUFFER_TOO_SMALL 0xC0000000 | 0x0023
++#define NT_STATUS_OBJECT_TYPE_MISMATCH 0xC0000000 | 0x0024
++#define NT_STATUS_NONCONTINUABLE_EXCEPTION 0xC0000000 | 0x0025
++#define NT_STATUS_INVALID_DISPOSITION 0xC0000000 | 0x0026
++#define NT_STATUS_UNWIND 0xC0000000 | 0x0027
++#define NT_STATUS_BAD_STACK 0xC0000000 | 0x0028
++#define NT_STATUS_INVALID_UNWIND_TARGET 0xC0000000 | 0x0029
++#define NT_STATUS_NOT_LOCKED 0xC0000000 | 0x002a
++#define NT_STATUS_PARITY_ERROR 0xC0000000 | 0x002b
++#define NT_STATUS_UNABLE_TO_DECOMMIT_VM 0xC0000000 | 0x002c
++#define NT_STATUS_NOT_COMMITTED 0xC0000000 | 0x002d
++#define NT_STATUS_INVALID_PORT_ATTRIBUTES 0xC0000000 | 0x002e
++#define NT_STATUS_PORT_MESSAGE_TOO_LONG 0xC0000000 | 0x002f
++#define NT_STATUS_INVALID_PARAMETER_MIX 0xC0000000 | 0x0030
++#define NT_STATUS_INVALID_QUOTA_LOWER 0xC0000000 | 0x0031
++#define NT_STATUS_DISK_CORRUPT_ERROR 0xC0000000 | 0x0032
++#define NT_STATUS_OBJECT_NAME_INVALID 0xC0000000 | 0x0033
++#define NT_STATUS_OBJECT_NAME_NOT_FOUND 0xC0000000 | 0x0034
++#define NT_STATUS_OBJECT_NAME_COLLISION 0xC0000000 | 0x0035
++#define NT_STATUS_HANDLE_NOT_WAITABLE 0xC0000000 | 0x0036
++#define NT_STATUS_PORT_DISCONNECTED 0xC0000000 | 0x0037
++#define NT_STATUS_DEVICE_ALREADY_ATTACHED 0xC0000000 | 0x0038
++#define NT_STATUS_OBJECT_PATH_INVALID 0xC0000000 | 0x0039
++#define NT_STATUS_OBJECT_PATH_NOT_FOUND 0xC0000000 | 0x003a
++#define NT_STATUS_OBJECT_PATH_SYNTAX_BAD 0xC0000000 | 0x003b
++#define NT_STATUS_DATA_OVERRUN 0xC0000000 | 0x003c
++#define NT_STATUS_DATA_LATE_ERROR 0xC0000000 | 0x003d
++#define NT_STATUS_DATA_ERROR 0xC0000000 | 0x003e
++#define NT_STATUS_CRC_ERROR 0xC0000000 | 0x003f
++#define NT_STATUS_SECTION_TOO_BIG 0xC0000000 | 0x0040
++#define NT_STATUS_PORT_CONNECTION_REFUSED 0xC0000000 | 0x0041
++#define NT_STATUS_INVALID_PORT_HANDLE 0xC0000000 | 0x0042
++#define NT_STATUS_SHARING_VIOLATION 0xC0000000 | 0x0043
++#define NT_STATUS_QUOTA_EXCEEDED 0xC0000000 | 0x0044
++#define NT_STATUS_INVALID_PAGE_PROTECTION 0xC0000000 | 0x0045
++#define NT_STATUS_MUTANT_NOT_OWNED 0xC0000000 | 0x0046
++#define NT_STATUS_SEMAPHORE_LIMIT_EXCEEDED 0xC0000000 | 0x0047
++#define NT_STATUS_PORT_ALREADY_SET 0xC0000000 | 0x0048
++#define NT_STATUS_SECTION_NOT_IMAGE 0xC0000000 | 0x0049
++#define NT_STATUS_SUSPEND_COUNT_EXCEEDED 0xC0000000 | 0x004a
++#define NT_STATUS_THREAD_IS_TERMINATING 0xC0000000 | 0x004b
++#define NT_STATUS_BAD_WORKING_SET_LIMIT 0xC0000000 | 0x004c
++#define NT_STATUS_INCOMPATIBLE_FILE_MAP 0xC0000000 | 0x004d
++#define NT_STATUS_SECTION_PROTECTION 0xC0000000 | 0x004e
++#define NT_STATUS_EAS_NOT_SUPPORTED 0xC0000000 | 0x004f
++#define NT_STATUS_EA_TOO_LARGE 0xC0000000 | 0x0050
++#define NT_STATUS_NONEXISTENT_EA_ENTRY 0xC0000000 | 0x0051
++#define NT_STATUS_NO_EAS_ON_FILE 0xC0000000 | 0x0052
++#define NT_STATUS_EA_CORRUPT_ERROR 0xC0000000 | 0x0053
++#define NT_STATUS_FILE_LOCK_CONFLICT 0xC0000000 | 0x0054
++#define NT_STATUS_LOCK_NOT_GRANTED 0xC0000000 | 0x0055
++#define NT_STATUS_DELETE_PENDING 0xC0000000 | 0x0056
++#define NT_STATUS_CTL_FILE_NOT_SUPPORTED 0xC0000000 | 0x0057
++#define NT_STATUS_UNKNOWN_REVISION 0xC0000000 | 0x0058
++#define NT_STATUS_REVISION_MISMATCH 0xC0000000 | 0x0059
++#define NT_STATUS_INVALID_OWNER 0xC0000000 | 0x005a
++#define NT_STATUS_INVALID_PRIMARY_GROUP 0xC0000000 | 0x005b
++#define NT_STATUS_NO_IMPERSONATION_TOKEN 0xC0000000 | 0x005c
++#define NT_STATUS_CANT_DISABLE_MANDATORY 0xC0000000 | 0x005d
++#define NT_STATUS_NO_LOGON_SERVERS 0xC0000000 | 0x005e
++#define NT_STATUS_NO_SUCH_LOGON_SESSION 0xC0000000 | 0x005f
++#define NT_STATUS_NO_SUCH_PRIVILEGE 0xC0000000 | 0x0060
++#define NT_STATUS_PRIVILEGE_NOT_HELD 0xC0000000 | 0x0061
++#define NT_STATUS_INVALID_ACCOUNT_NAME 0xC0000000 | 0x0062
++#define NT_STATUS_USER_EXISTS 0xC0000000 | 0x0063
++#define NT_STATUS_NO_SUCH_USER 0xC0000000 | 0x0064
++#define NT_STATUS_GROUP_EXISTS 0xC0000000 | 0x0065
++#define NT_STATUS_NO_SUCH_GROUP 0xC0000000 | 0x0066
++#define NT_STATUS_MEMBER_IN_GROUP 0xC0000000 | 0x0067
++#define NT_STATUS_MEMBER_NOT_IN_GROUP 0xC0000000 | 0x0068
++#define NT_STATUS_LAST_ADMIN 0xC0000000 | 0x0069
++#define NT_STATUS_WRONG_PASSWORD 0xC0000000 | 0x006a
++#define NT_STATUS_ILL_FORMED_PASSWORD 0xC0000000 | 0x006b
++#define NT_STATUS_PASSWORD_RESTRICTION 0xC0000000 | 0x006c
++#define NT_STATUS_LOGON_FAILURE 0xC0000000 | 0x006d
++#define NT_STATUS_ACCOUNT_RESTRICTION 0xC0000000 | 0x006e
++#define NT_STATUS_INVALID_LOGON_HOURS 0xC0000000 | 0x006f
++#define NT_STATUS_INVALID_WORKSTATION 0xC0000000 | 0x0070
++#define NT_STATUS_PASSWORD_EXPIRED 0xC0000000 | 0x0071
++#define NT_STATUS_ACCOUNT_DISABLED 0xC0000000 | 0x0072
++#define NT_STATUS_NONE_MAPPED 0xC0000000 | 0x0073
++#define NT_STATUS_TOO_MANY_LUIDS_REQUESTED 0xC0000000 | 0x0074
++#define NT_STATUS_LUIDS_EXHAUSTED 0xC0000000 | 0x0075
++#define NT_STATUS_INVALID_SUB_AUTHORITY 0xC0000000 | 0x0076
++#define NT_STATUS_INVALID_ACL 0xC0000000 | 0x0077
++#define NT_STATUS_INVALID_SID 0xC0000000 | 0x0078
++#define NT_STATUS_INVALID_SECURITY_DESCR 0xC0000000 | 0x0079
++#define NT_STATUS_PROCEDURE_NOT_FOUND 0xC0000000 | 0x007a
++#define NT_STATUS_INVALID_IMAGE_FORMAT 0xC0000000 | 0x007b
++#define NT_STATUS_NO_TOKEN 0xC0000000 | 0x007c
++#define NT_STATUS_BAD_INHERITANCE_ACL 0xC0000000 | 0x007d
++#define NT_STATUS_RANGE_NOT_LOCKED 0xC0000000 | 0x007e
++#define NT_STATUS_DISK_FULL 0xC0000000 | 0x007f
++#define NT_STATUS_SERVER_DISABLED 0xC0000000 | 0x0080
++#define NT_STATUS_SERVER_NOT_DISABLED 0xC0000000 | 0x0081
++#define NT_STATUS_TOO_MANY_GUIDS_REQUESTED 0xC0000000 | 0x0082
++#define NT_STATUS_GUIDS_EXHAUSTED 0xC0000000 | 0x0083
++#define NT_STATUS_INVALID_ID_AUTHORITY 0xC0000000 | 0x0084
++#define NT_STATUS_AGENTS_EXHAUSTED 0xC0000000 | 0x0085
++#define NT_STATUS_INVALID_VOLUME_LABEL 0xC0000000 | 0x0086
++#define NT_STATUS_SECTION_NOT_EXTENDED 0xC0000000 | 0x0087
++#define NT_STATUS_NOT_MAPPED_DATA 0xC0000000 | 0x0088
++#define NT_STATUS_RESOURCE_DATA_NOT_FOUND 0xC0000000 | 0x0089
++#define NT_STATUS_RESOURCE_TYPE_NOT_FOUND 0xC0000000 | 0x008a
++#define NT_STATUS_RESOURCE_NAME_NOT_FOUND 0xC0000000 | 0x008b
++#define NT_STATUS_ARRAY_BOUNDS_EXCEEDED 0xC0000000 | 0x008c
++#define NT_STATUS_FLOAT_DENORMAL_OPERAND 0xC0000000 | 0x008d
++#define NT_STATUS_FLOAT_DIVIDE_BY_ZERO 0xC0000000 | 0x008e
++#define NT_STATUS_FLOAT_INEXACT_RESULT 0xC0000000 | 0x008f
++#define NT_STATUS_FLOAT_INVALID_OPERATION 0xC0000000 | 0x0090
++#define NT_STATUS_FLOAT_OVERFLOW 0xC0000000 | 0x0091
++#define NT_STATUS_FLOAT_STACK_CHECK 0xC0000000 | 0x0092
++#define NT_STATUS_FLOAT_UNDERFLOW 0xC0000000 | 0x0093
++#define NT_STATUS_INTEGER_DIVIDE_BY_ZERO 0xC0000000 | 0x0094
++#define NT_STATUS_INTEGER_OVERFLOW 0xC0000000 | 0x0095
++#define NT_STATUS_PRIVILEGED_INSTRUCTION 0xC0000000 | 0x0096
++#define NT_STATUS_TOO_MANY_PAGING_FILES 0xC0000000 | 0x0097
++#define NT_STATUS_FILE_INVALID 0xC0000000 | 0x0098
++#define NT_STATUS_ALLOTTED_SPACE_EXCEEDED 0xC0000000 | 0x0099
++#define NT_STATUS_INSUFFICIENT_RESOURCES 0xC0000000 | 0x009a
++#define NT_STATUS_DFS_EXIT_PATH_FOUND 0xC0000000 | 0x009b
++#define NT_STATUS_DEVICE_DATA_ERROR 0xC0000000 | 0x009c
++#define NT_STATUS_DEVICE_NOT_CONNECTED 0xC0000000 | 0x009d
++#define NT_STATUS_DEVICE_POWER_FAILURE 0xC0000000 | 0x009e
++#define NT_STATUS_FREE_VM_NOT_AT_BASE 0xC0000000 | 0x009f
++#define NT_STATUS_MEMORY_NOT_ALLOCATED 0xC0000000 | 0x00a0
++#define NT_STATUS_WORKING_SET_QUOTA 0xC0000000 | 0x00a1
++#define NT_STATUS_MEDIA_WRITE_PROTECTED 0xC0000000 | 0x00a2
++#define NT_STATUS_DEVICE_NOT_READY 0xC0000000 | 0x00a3
++#define NT_STATUS_INVALID_GROUP_ATTRIBUTES 0xC0000000 | 0x00a4
++#define NT_STATUS_BAD_IMPERSONATION_LEVEL 0xC0000000 | 0x00a5
++#define NT_STATUS_CANT_OPEN_ANONYMOUS 0xC0000000 | 0x00a6
++#define NT_STATUS_BAD_VALIDATION_CLASS 0xC0000000 | 0x00a7
++#define NT_STATUS_BAD_TOKEN_TYPE 0xC0000000 | 0x00a8
++#define NT_STATUS_BAD_MASTER_BOOT_RECORD 0xC0000000 | 0x00a9
++#define NT_STATUS_INSTRUCTION_MISALIGNMENT 0xC0000000 | 0x00aa
++#define NT_STATUS_INSTANCE_NOT_AVAILABLE 0xC0000000 | 0x00ab
++#define NT_STATUS_PIPE_NOT_AVAILABLE 0xC0000000 | 0x00ac
++#define NT_STATUS_INVALID_PIPE_STATE 0xC0000000 | 0x00ad
++#define NT_STATUS_PIPE_BUSY 0xC0000000 | 0x00ae
++#define NT_STATUS_ILLEGAL_FUNCTION 0xC0000000 | 0x00af
++#define NT_STATUS_PIPE_DISCONNECTED 0xC0000000 | 0x00b0
++#define NT_STATUS_PIPE_CLOSING 0xC0000000 | 0x00b1
++#define NT_STATUS_PIPE_CONNECTED 0xC0000000 | 0x00b2
++#define NT_STATUS_PIPE_LISTENING 0xC0000000 | 0x00b3
++#define NT_STATUS_INVALID_READ_MODE 0xC0000000 | 0x00b4
++#define NT_STATUS_IO_TIMEOUT 0xC0000000 | 0x00b5
++#define NT_STATUS_FILE_FORCED_CLOSED 0xC0000000 | 0x00b6
++#define NT_STATUS_PROFILING_NOT_STARTED 0xC0000000 | 0x00b7
++#define NT_STATUS_PROFILING_NOT_STOPPED 0xC0000000 | 0x00b8
++#define NT_STATUS_COULD_NOT_INTERPRET 0xC0000000 | 0x00b9
++#define NT_STATUS_FILE_IS_A_DIRECTORY 0xC0000000 | 0x00ba
++#define NT_STATUS_NOT_SUPPORTED 0xC0000000 | 0x00bb
++#define NT_STATUS_REMOTE_NOT_LISTENING 0xC0000000 | 0x00bc
++#define NT_STATUS_DUPLICATE_NAME 0xC0000000 | 0x00bd
++#define NT_STATUS_BAD_NETWORK_PATH 0xC0000000 | 0x00be
++#define NT_STATUS_NETWORK_BUSY 0xC0000000 | 0x00bf
++#define NT_STATUS_DEVICE_DOES_NOT_EXIST 0xC0000000 | 0x00c0
++#define NT_STATUS_TOO_MANY_COMMANDS 0xC0000000 | 0x00c1
++#define NT_STATUS_ADAPTER_HARDWARE_ERROR 0xC0000000 | 0x00c2
++#define NT_STATUS_INVALID_NETWORK_RESPONSE 0xC0000000 | 0x00c3
++#define NT_STATUS_UNEXPECTED_NETWORK_ERROR 0xC0000000 | 0x00c4
++#define NT_STATUS_BAD_REMOTE_ADAPTER 0xC0000000 | 0x00c5
++#define NT_STATUS_PRINT_QUEUE_FULL 0xC0000000 | 0x00c6
++#define NT_STATUS_NO_SPOOL_SPACE 0xC0000000 | 0x00c7
++#define NT_STATUS_PRINT_CANCELLED 0xC0000000 | 0x00c8
++#define NT_STATUS_NETWORK_NAME_DELETED 0xC0000000 | 0x00c9
++#define NT_STATUS_NETWORK_ACCESS_DENIED 0xC0000000 | 0x00ca
++#define NT_STATUS_BAD_DEVICE_TYPE 0xC0000000 | 0x00cb
++#define NT_STATUS_BAD_NETWORK_NAME 0xC0000000 | 0x00cc
++#define NT_STATUS_TOO_MANY_NAMES 0xC0000000 | 0x00cd
++#define NT_STATUS_TOO_MANY_SESSIONS 0xC0000000 | 0x00ce
++#define NT_STATUS_SHARING_PAUSED 0xC0000000 | 0x00cf
++#define NT_STATUS_REQUEST_NOT_ACCEPTED 0xC0000000 | 0x00d0
++#define NT_STATUS_REDIRECTOR_PAUSED 0xC0000000 | 0x00d1
++#define NT_STATUS_NET_WRITE_FAULT 0xC0000000 | 0x00d2
++#define NT_STATUS_PROFILING_AT_LIMIT 0xC0000000 | 0x00d3
++#define NT_STATUS_NOT_SAME_DEVICE 0xC0000000 | 0x00d4
++#define NT_STATUS_FILE_RENAMED 0xC0000000 | 0x00d5
++#define NT_STATUS_VIRTUAL_CIRCUIT_CLOSED 0xC0000000 | 0x00d6
++#define NT_STATUS_NO_SECURITY_ON_OBJECT 0xC0000000 | 0x00d7
++#define NT_STATUS_CANT_WAIT 0xC0000000 | 0x00d8
++#define NT_STATUS_PIPE_EMPTY 0xC0000000 | 0x00d9
++#define NT_STATUS_CANT_ACCESS_DOMAIN_INFO 0xC0000000 | 0x00da
++#define NT_STATUS_CANT_TERMINATE_SELF 0xC0000000 | 0x00db
++#define NT_STATUS_INVALID_SERVER_STATE 0xC0000000 | 0x00dc
++#define NT_STATUS_INVALID_DOMAIN_STATE 0xC0000000 | 0x00dd
++#define NT_STATUS_INVALID_DOMAIN_ROLE 0xC0000000 | 0x00de
++#define NT_STATUS_NO_SUCH_DOMAIN 0xC0000000 | 0x00df
++#define NT_STATUS_DOMAIN_EXISTS 0xC0000000 | 0x00e0
++#define NT_STATUS_DOMAIN_LIMIT_EXCEEDED 0xC0000000 | 0x00e1
++#define NT_STATUS_OPLOCK_NOT_GRANTED 0xC0000000 | 0x00e2
++#define NT_STATUS_INVALID_OPLOCK_PROTOCOL 0xC0000000 | 0x00e3
++#define NT_STATUS_INTERNAL_DB_CORRUPTION 0xC0000000 | 0x00e4
++#define NT_STATUS_INTERNAL_ERROR 0xC0000000 | 0x00e5
++#define NT_STATUS_GENERIC_NOT_MAPPED 0xC0000000 | 0x00e6
++#define NT_STATUS_BAD_DESCRIPTOR_FORMAT 0xC0000000 | 0x00e7
++#define NT_STATUS_INVALID_USER_BUFFER 0xC0000000 | 0x00e8
++#define NT_STATUS_UNEXPECTED_IO_ERROR 0xC0000000 | 0x00e9
++#define NT_STATUS_UNEXPECTED_MM_CREATE_ERR 0xC0000000 | 0x00ea
++#define NT_STATUS_UNEXPECTED_MM_MAP_ERROR 0xC0000000 | 0x00eb
++#define NT_STATUS_UNEXPECTED_MM_EXTEND_ERR 0xC0000000 | 0x00ec
++#define NT_STATUS_NOT_LOGON_PROCESS 0xC0000000 | 0x00ed
++#define NT_STATUS_LOGON_SESSION_EXISTS 0xC0000000 | 0x00ee
++#define NT_STATUS_INVALID_PARAMETER_1 0xC0000000 | 0x00ef
++#define NT_STATUS_INVALID_PARAMETER_2 0xC0000000 | 0x00f0
++#define NT_STATUS_INVALID_PARAMETER_3 0xC0000000 | 0x00f1
++#define NT_STATUS_INVALID_PARAMETER_4 0xC0000000 | 0x00f2
++#define NT_STATUS_INVALID_PARAMETER_5 0xC0000000 | 0x00f3
++#define NT_STATUS_INVALID_PARAMETER_6 0xC0000000 | 0x00f4
++#define NT_STATUS_INVALID_PARAMETER_7 0xC0000000 | 0x00f5
++#define NT_STATUS_INVALID_PARAMETER_8 0xC0000000 | 0x00f6
++#define NT_STATUS_INVALID_PARAMETER_9 0xC0000000 | 0x00f7
++#define NT_STATUS_INVALID_PARAMETER_10 0xC0000000 | 0x00f8
++#define NT_STATUS_INVALID_PARAMETER_11 0xC0000000 | 0x00f9
++#define NT_STATUS_INVALID_PARAMETER_12 0xC0000000 | 0x00fa
++#define NT_STATUS_REDIRECTOR_NOT_STARTED 0xC0000000 | 0x00fb
++#define NT_STATUS_REDIRECTOR_STARTED 0xC0000000 | 0x00fc
++#define NT_STATUS_STACK_OVERFLOW 0xC0000000 | 0x00fd
++#define NT_STATUS_NO_SUCH_PACKAGE 0xC0000000 | 0x00fe
++#define NT_STATUS_BAD_FUNCTION_TABLE 0xC0000000 | 0x00ff
++#define NT_STATUS_DIRECTORY_NOT_EMPTY 0xC0000000 | 0x0101
++#define NT_STATUS_FILE_CORRUPT_ERROR 0xC0000000 | 0x0102
++#define NT_STATUS_NOT_A_DIRECTORY 0xC0000000 | 0x0103
++#define NT_STATUS_BAD_LOGON_SESSION_STATE 0xC0000000 | 0x0104
++#define NT_STATUS_LOGON_SESSION_COLLISION 0xC0000000 | 0x0105
++#define NT_STATUS_NAME_TOO_LONG 0xC0000000 | 0x0106
++#define NT_STATUS_FILES_OPEN 0xC0000000 | 0x0107
++#define NT_STATUS_CONNECTION_IN_USE 0xC0000000 | 0x0108
++#define NT_STATUS_MESSAGE_NOT_FOUND 0xC0000000 | 0x0109
++#define NT_STATUS_PROCESS_IS_TERMINATING 0xC0000000 | 0x010a
++#define NT_STATUS_INVALID_LOGON_TYPE 0xC0000000 | 0x010b
++#define NT_STATUS_NO_GUID_TRANSLATION 0xC0000000 | 0x010c
++#define NT_STATUS_CANNOT_IMPERSONATE 0xC0000000 | 0x010d
++#define NT_STATUS_IMAGE_ALREADY_LOADED 0xC0000000 | 0x010e
++#define NT_STATUS_ABIOS_NOT_PRESENT 0xC0000000 | 0x010f
++#define NT_STATUS_ABIOS_LID_NOT_EXIST 0xC0000000 | 0x0110
++#define NT_STATUS_ABIOS_LID_ALREADY_OWNED 0xC0000000 | 0x0111
++#define NT_STATUS_ABIOS_NOT_LID_OWNER 0xC0000000 | 0x0112
++#define NT_STATUS_ABIOS_INVALID_COMMAND 0xC0000000 | 0x0113
++#define NT_STATUS_ABIOS_INVALID_LID 0xC0000000 | 0x0114
++#define NT_STATUS_ABIOS_SELECTOR_NOT_AVAILABLE 0xC0000000 | 0x0115
++#define NT_STATUS_ABIOS_INVALID_SELECTOR 0xC0000000 | 0x0116
++#define NT_STATUS_NO_LDT 0xC0000000 | 0x0117
++#define NT_STATUS_INVALID_LDT_SIZE 0xC0000000 | 0x0118
++#define NT_STATUS_INVALID_LDT_OFFSET 0xC0000000 | 0x0119
++#define NT_STATUS_INVALID_LDT_DESCRIPTOR 0xC0000000 | 0x011a
++#define NT_STATUS_INVALID_IMAGE_NE_FORMAT 0xC0000000 | 0x011b
++#define NT_STATUS_RXACT_INVALID_STATE 0xC0000000 | 0x011c
++#define NT_STATUS_RXACT_COMMIT_FAILURE 0xC0000000 | 0x011d
++#define NT_STATUS_MAPPED_FILE_SIZE_ZERO 0xC0000000 | 0x011e
++#define NT_STATUS_TOO_MANY_OPENED_FILES 0xC0000000 | 0x011f
++#define NT_STATUS_CANCELLED 0xC0000000 | 0x0120
++#define NT_STATUS_CANNOT_DELETE 0xC0000000 | 0x0121
++#define NT_STATUS_INVALID_COMPUTER_NAME 0xC0000000 | 0x0122
++#define NT_STATUS_FILE_DELETED 0xC0000000 | 0x0123
++#define NT_STATUS_SPECIAL_ACCOUNT 0xC0000000 | 0x0124
++#define NT_STATUS_SPECIAL_GROUP 0xC0000000 | 0x0125
++#define NT_STATUS_SPECIAL_USER 0xC0000000 | 0x0126
++#define NT_STATUS_MEMBERS_PRIMARY_GROUP 0xC0000000 | 0x0127
++#define NT_STATUS_FILE_CLOSED 0xC0000000 | 0x0128
++#define NT_STATUS_TOO_MANY_THREADS 0xC0000000 | 0x0129
++#define NT_STATUS_THREAD_NOT_IN_PROCESS 0xC0000000 | 0x012a
++#define NT_STATUS_TOKEN_ALREADY_IN_USE 0xC0000000 | 0x012b
++#define NT_STATUS_PAGEFILE_QUOTA_EXCEEDED 0xC0000000 | 0x012c
++#define NT_STATUS_COMMITMENT_LIMIT 0xC0000000 | 0x012d
++#define NT_STATUS_INVALID_IMAGE_LE_FORMAT 0xC0000000 | 0x012e
++#define NT_STATUS_INVALID_IMAGE_NOT_MZ 0xC0000000 | 0x012f
++#define NT_STATUS_INVALID_IMAGE_PROTECT 0xC0000000 | 0x0130
++#define NT_STATUS_INVALID_IMAGE_WIN_16 0xC0000000 | 0x0131
++#define NT_STATUS_LOGON_SERVER_CONFLICT 0xC0000000 | 0x0132
++#define NT_STATUS_TIME_DIFFERENCE_AT_DC 0xC0000000 | 0x0133
++#define NT_STATUS_SYNCHRONIZATION_REQUIRED 0xC0000000 | 0x0134
++#define NT_STATUS_DLL_NOT_FOUND 0xC0000000 | 0x0135
++#define NT_STATUS_OPEN_FAILED 0xC0000000 | 0x0136
++#define NT_STATUS_IO_PRIVILEGE_FAILED 0xC0000000 | 0x0137
++#define NT_STATUS_ORDINAL_NOT_FOUND 0xC0000000 | 0x0138
++#define NT_STATUS_ENTRYPOINT_NOT_FOUND 0xC0000000 | 0x0139
++#define NT_STATUS_CONTROL_C_EXIT 0xC0000000 | 0x013a
++#define NT_STATUS_LOCAL_DISCONNECT 0xC0000000 | 0x013b
++#define NT_STATUS_REMOTE_DISCONNECT 0xC0000000 | 0x013c
++#define NT_STATUS_REMOTE_RESOURCES 0xC0000000 | 0x013d
++#define NT_STATUS_LINK_FAILED 0xC0000000 | 0x013e
++#define NT_STATUS_LINK_TIMEOUT 0xC0000000 | 0x013f
++#define NT_STATUS_INVALID_CONNECTION 0xC0000000 | 0x0140
++#define NT_STATUS_INVALID_ADDRESS 0xC0000000 | 0x0141
++#define NT_STATUS_DLL_INIT_FAILED 0xC0000000 | 0x0142
++#define NT_STATUS_MISSING_SYSTEMFILE 0xC0000000 | 0x0143
++#define NT_STATUS_UNHANDLED_EXCEPTION 0xC0000000 | 0x0144
++#define NT_STATUS_APP_INIT_FAILURE 0xC0000000 | 0x0145
++#define NT_STATUS_PAGEFILE_CREATE_FAILED 0xC0000000 | 0x0146
++#define NT_STATUS_NO_PAGEFILE 0xC0000000 | 0x0147
++#define NT_STATUS_INVALID_LEVEL 0xC0000000 | 0x0148
++#define NT_STATUS_WRONG_PASSWORD_CORE 0xC0000000 | 0x0149
++#define NT_STATUS_ILLEGAL_FLOAT_CONTEXT 0xC0000000 | 0x014a
++#define NT_STATUS_PIPE_BROKEN 0xC0000000 | 0x014b
++#define NT_STATUS_REGISTRY_CORRUPT 0xC0000000 | 0x014c
++#define NT_STATUS_REGISTRY_IO_FAILED 0xC0000000 | 0x014d
++#define NT_STATUS_NO_EVENT_PAIR 0xC0000000 | 0x014e
++#define NT_STATUS_UNRECOGNIZED_VOLUME 0xC0000000 | 0x014f
++#define NT_STATUS_SERIAL_NO_DEVICE_INITED 0xC0000000 | 0x0150
++#define NT_STATUS_NO_SUCH_ALIAS 0xC0000000 | 0x0151
++#define NT_STATUS_MEMBER_NOT_IN_ALIAS 0xC0000000 | 0x0152
++#define NT_STATUS_MEMBER_IN_ALIAS 0xC0000000 | 0x0153
++#define NT_STATUS_ALIAS_EXISTS 0xC0000000 | 0x0154
++#define NT_STATUS_LOGON_NOT_GRANTED 0xC0000000 | 0x0155
++#define NT_STATUS_TOO_MANY_SECRETS 0xC0000000 | 0x0156
++#define NT_STATUS_SECRET_TOO_LONG 0xC0000000 | 0x0157
++#define NT_STATUS_INTERNAL_DB_ERROR 0xC0000000 | 0x0158
++#define NT_STATUS_FULLSCREEN_MODE 0xC0000000 | 0x0159
++#define NT_STATUS_TOO_MANY_CONTEXT_IDS 0xC0000000 | 0x015a
++#define NT_STATUS_LOGON_TYPE_NOT_GRANTED 0xC0000000 | 0x015b
++#define NT_STATUS_NOT_REGISTRY_FILE 0xC0000000 | 0x015c
++#define NT_STATUS_NT_CROSS_ENCRYPTION_REQUIRED 0xC0000000 | 0x015d
++#define NT_STATUS_DOMAIN_CTRLR_CONFIG_ERROR 0xC0000000 | 0x015e
++#define NT_STATUS_FT_MISSING_MEMBER 0xC0000000 | 0x015f
++#define NT_STATUS_ILL_FORMED_SERVICE_ENTRY 0xC0000000 | 0x0160
++#define NT_STATUS_ILLEGAL_CHARACTER 0xC0000000 | 0x0161
++#define NT_STATUS_UNMAPPABLE_CHARACTER 0xC0000000 | 0x0162
++#define NT_STATUS_UNDEFINED_CHARACTER 0xC0000000 | 0x0163
++#define NT_STATUS_FLOPPY_VOLUME 0xC0000000 | 0x0164
++#define NT_STATUS_FLOPPY_ID_MARK_NOT_FOUND 0xC0000000 | 0x0165
++#define NT_STATUS_FLOPPY_WRONG_CYLINDER 0xC0000000 | 0x0166
++#define NT_STATUS_FLOPPY_UNKNOWN_ERROR 0xC0000000 | 0x0167
++#define NT_STATUS_FLOPPY_BAD_REGISTERS 0xC0000000 | 0x0168
++#define NT_STATUS_DISK_RECALIBRATE_FAILED 0xC0000000 | 0x0169
++#define NT_STATUS_DISK_OPERATION_FAILED 0xC0000000 | 0x016a
++#define NT_STATUS_DISK_RESET_FAILED 0xC0000000 | 0x016b
++#define NT_STATUS_SHARED_IRQ_BUSY 0xC0000000 | 0x016c
++#define NT_STATUS_FT_ORPHANING 0xC0000000 | 0x016d
++#define NT_STATUS_PARTITION_FAILURE 0xC0000000 | 0x0172
++#define NT_STATUS_INVALID_BLOCK_LENGTH 0xC0000000 | 0x0173
++#define NT_STATUS_DEVICE_NOT_PARTITIONED 0xC0000000 | 0x0174
++#define NT_STATUS_UNABLE_TO_LOCK_MEDIA 0xC0000000 | 0x0175
++#define NT_STATUS_UNABLE_TO_UNLOAD_MEDIA 0xC0000000 | 0x0176
++#define NT_STATUS_EOM_OVERFLOW 0xC0000000 | 0x0177
++#define NT_STATUS_NO_MEDIA 0xC0000000 | 0x0178
++#define NT_STATUS_NO_SUCH_MEMBER 0xC0000000 | 0x017a
++#define NT_STATUS_INVALID_MEMBER 0xC0000000 | 0x017b
++#define NT_STATUS_KEY_DELETED 0xC0000000 | 0x017c
++#define NT_STATUS_NO_LOG_SPACE 0xC0000000 | 0x017d
++#define NT_STATUS_TOO_MANY_SIDS 0xC0000000 | 0x017e
++#define NT_STATUS_LM_CROSS_ENCRYPTION_REQUIRED 0xC0000000 | 0x017f
++#define NT_STATUS_KEY_HAS_CHILDREN 0xC0000000 | 0x0180
++#define NT_STATUS_CHILD_MUST_BE_VOLATILE 0xC0000000 | 0x0181
++#define NT_STATUS_DEVICE_CONFIGURATION_ERROR 0xC0000000 | 0x0182
++#define NT_STATUS_DRIVER_INTERNAL_ERROR 0xC0000000 | 0x0183
++#define NT_STATUS_INVALID_DEVICE_STATE 0xC0000000 | 0x0184
++#define NT_STATUS_IO_DEVICE_ERROR 0xC0000000 | 0x0185
++#define NT_STATUS_DEVICE_PROTOCOL_ERROR 0xC0000000 | 0x0186
++#define NT_STATUS_BACKUP_CONTROLLER 0xC0000000 | 0x0187
++#define NT_STATUS_LOG_FILE_FULL 0xC0000000 | 0x0188
++#define NT_STATUS_TOO_LATE 0xC0000000 | 0x0189
++#define NT_STATUS_NO_TRUST_LSA_SECRET 0xC0000000 | 0x018a
++#define NT_STATUS_NO_TRUST_SAM_ACCOUNT 0xC0000000 | 0x018b
++#define NT_STATUS_TRUSTED_DOMAIN_FAILURE 0xC0000000 | 0x018c
++#define NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE 0xC0000000 | 0x018d
++#define NT_STATUS_EVENTLOG_FILE_CORRUPT 0xC0000000 | 0x018e
++#define NT_STATUS_EVENTLOG_CANT_START 0xC0000000 | 0x018f
++#define NT_STATUS_TRUST_FAILURE 0xC0000000 | 0x0190
++#define NT_STATUS_MUTANT_LIMIT_EXCEEDED 0xC0000000 | 0x0191
++#define NT_STATUS_NETLOGON_NOT_STARTED 0xC0000000 | 0x0192
++#define NT_STATUS_ACCOUNT_EXPIRED 0xC0000000 | 0x0193
++#define NT_STATUS_POSSIBLE_DEADLOCK 0xC0000000 | 0x0194
++#define NT_STATUS_NETWORK_CREDENTIAL_CONFLICT 0xC0000000 | 0x0195
++#define NT_STATUS_REMOTE_SESSION_LIMIT 0xC0000000 | 0x0196
++#define NT_STATUS_EVENTLOG_FILE_CHANGED 0xC0000000 | 0x0197
++#define NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT 0xC0000000 | 0x0198
++#define NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT 0xC0000000 | 0x0199
++#define NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT 0xC0000000 | 0x019a
++#define NT_STATUS_DOMAIN_TRUST_INCONSISTENT 0xC0000000 | 0x019b
++#define NT_STATUS_FS_DRIVER_REQUIRED 0xC0000000 | 0x019c
++#define NT_STATUS_NO_USER_SESSION_KEY 0xC0000000 | 0x0202
++#define NT_STATUS_USER_SESSION_DELETED 0xC0000000 | 0x0203
++#define NT_STATUS_RESOURCE_LANG_NOT_FOUND 0xC0000000 | 0x0204
++#define NT_STATUS_INSUFF_SERVER_RESOURCES 0xC0000000 | 0x0205
++#define NT_STATUS_INVALID_BUFFER_SIZE 0xC0000000 | 0x0206
++#define NT_STATUS_INVALID_ADDRESS_COMPONENT 0xC0000000 | 0x0207
++#define NT_STATUS_INVALID_ADDRESS_WILDCARD 0xC0000000 | 0x0208
++#define NT_STATUS_TOO_MANY_ADDRESSES 0xC0000000 | 0x0209
++#define NT_STATUS_ADDRESS_ALREADY_EXISTS 0xC0000000 | 0x020a
++#define NT_STATUS_ADDRESS_CLOSED 0xC0000000 | 0x020b
++#define NT_STATUS_CONNECTION_DISCONNECTED 0xC0000000 | 0x020c
++#define NT_STATUS_CONNECTION_RESET 0xC0000000 | 0x020d
++#define NT_STATUS_TOO_MANY_NODES 0xC0000000 | 0x020e
++#define NT_STATUS_TRANSACTION_ABORTED 0xC0000000 | 0x020f
++#define NT_STATUS_TRANSACTION_TIMED_OUT 0xC0000000 | 0x0210
++#define NT_STATUS_TRANSACTION_NO_RELEASE 0xC0000000 | 0x0211
++#define NT_STATUS_TRANSACTION_NO_MATCH 0xC0000000 | 0x0212
++#define NT_STATUS_TRANSACTION_RESPONDED 0xC0000000 | 0x0213
++#define NT_STATUS_TRANSACTION_INVALID_ID 0xC0000000 | 0x0214
++#define NT_STATUS_TRANSACTION_INVALID_TYPE 0xC0000000 | 0x0215
++#define NT_STATUS_NOT_SERVER_SESSION 0xC0000000 | 0x0216
++#define NT_STATUS_NOT_CLIENT_SESSION 0xC0000000 | 0x0217
++#define NT_STATUS_CANNOT_LOAD_REGISTRY_FILE 0xC0000000 | 0x0218
++#define NT_STATUS_DEBUG_ATTACH_FAILED 0xC0000000 | 0x0219
++#define NT_STATUS_SYSTEM_PROCESS_TERMINATED 0xC0000000 | 0x021a
++#define NT_STATUS_DATA_NOT_ACCEPTED 0xC0000000 | 0x021b
++#define NT_STATUS_NO_BROWSER_SERVERS_FOUND 0xC0000000 | 0x021c
++#define NT_STATUS_VDM_HARD_ERROR 0xC0000000 | 0x021d
++#define NT_STATUS_DRIVER_CANCEL_TIMEOUT 0xC0000000 | 0x021e
++#define NT_STATUS_REPLY_MESSAGE_MISMATCH 0xC0000000 | 0x021f
++#define NT_STATUS_MAPPED_ALIGNMENT 0xC0000000 | 0x0220
++#define NT_STATUS_IMAGE_CHECKSUM_MISMATCH 0xC0000000 | 0x0221
++#define NT_STATUS_LOST_WRITEBEHIND_DATA 0xC0000000 | 0x0222
++#define NT_STATUS_CLIENT_SERVER_PARAMETERS_INVALID 0xC0000000 | 0x0223
++#define NT_STATUS_PASSWORD_MUST_CHANGE 0xC0000000 | 0x0224
++#define NT_STATUS_NOT_FOUND 0xC0000000 | 0x0225
++#define NT_STATUS_NOT_TINY_STREAM 0xC0000000 | 0x0226
++#define NT_STATUS_RECOVERY_FAILURE 0xC0000000 | 0x0227
++#define NT_STATUS_STACK_OVERFLOW_READ 0xC0000000 | 0x0228
++#define NT_STATUS_FAIL_CHECK 0xC0000000 | 0x0229
++#define NT_STATUS_DUPLICATE_OBJECTID 0xC0000000 | 0x022a
++#define NT_STATUS_OBJECTID_EXISTS 0xC0000000 | 0x022b
++#define NT_STATUS_CONVERT_TO_LARGE 0xC0000000 | 0x022c
++#define NT_STATUS_RETRY 0xC0000000 | 0x022d
++#define NT_STATUS_FOUND_OUT_OF_SCOPE 0xC0000000 | 0x022e
++#define NT_STATUS_ALLOCATE_BUCKET 0xC0000000 | 0x022f
++#define NT_STATUS_PROPSET_NOT_FOUND 0xC0000000 | 0x0230
++#define NT_STATUS_MARSHALL_OVERFLOW 0xC0000000 | 0x0231
++#define NT_STATUS_INVALID_VARIANT 0xC0000000 | 0x0232
++#define NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND 0xC0000000 | 0x0233
++#define NT_STATUS_ACCOUNT_LOCKED_OUT 0xC0000000 | 0x0234
++#define NT_STATUS_HANDLE_NOT_CLOSABLE 0xC0000000 | 0x0235
++#define NT_STATUS_CONNECTION_REFUSED 0xC0000000 | 0x0236
++#define NT_STATUS_GRACEFUL_DISCONNECT 0xC0000000 | 0x0237
++#define NT_STATUS_ADDRESS_ALREADY_ASSOCIATED 0xC0000000 | 0x0238
++#define NT_STATUS_ADDRESS_NOT_ASSOCIATED 0xC0000000 | 0x0239
++#define NT_STATUS_CONNECTION_INVALID 0xC0000000 | 0x023a
++#define NT_STATUS_CONNECTION_ACTIVE 0xC0000000 | 0x023b
++#define NT_STATUS_NETWORK_UNREACHABLE 0xC0000000 | 0x023c
++#define NT_STATUS_HOST_UNREACHABLE 0xC0000000 | 0x023d
++#define NT_STATUS_PROTOCOL_UNREACHABLE 0xC0000000 | 0x023e
++#define NT_STATUS_PORT_UNREACHABLE 0xC0000000 | 0x023f
++#define NT_STATUS_REQUEST_ABORTED 0xC0000000 | 0x0240
++#define NT_STATUS_CONNECTION_ABORTED 0xC0000000 | 0x0241
++#define NT_STATUS_BAD_COMPRESSION_BUFFER 0xC0000000 | 0x0242
++#define NT_STATUS_USER_MAPPED_FILE 0xC0000000 | 0x0243
++#define NT_STATUS_AUDIT_FAILED 0xC0000000 | 0x0244
++#define NT_STATUS_TIMER_RESOLUTION_NOT_SET 0xC0000000 | 0x0245
++#define NT_STATUS_CONNECTION_COUNT_LIMIT 0xC0000000 | 0x0246
++#define NT_STATUS_LOGIN_TIME_RESTRICTION 0xC0000000 | 0x0247
++#define NT_STATUS_LOGIN_WKSTA_RESTRICTION 0xC0000000 | 0x0248
++#define NT_STATUS_IMAGE_MP_UP_MISMATCH 0xC0000000 | 0x0249
++#define NT_STATUS_INSUFFICIENT_LOGON_INFO 0xC0000000 | 0x0250
++#define NT_STATUS_BAD_DLL_ENTRYPOINT 0xC0000000 | 0x0251
++#define NT_STATUS_BAD_SERVICE_ENTRYPOINT 0xC0000000 | 0x0252
++#define NT_STATUS_LPC_REPLY_LOST 0xC0000000 | 0x0253
++#define NT_STATUS_IP_ADDRESS_CONFLICT1 0xC0000000 | 0x0254
++#define NT_STATUS_IP_ADDRESS_CONFLICT2 0xC0000000 | 0x0255
++#define NT_STATUS_REGISTRY_QUOTA_LIMIT 0xC0000000 | 0x0256
++#define NT_STATUS_PATH_NOT_COVERED 0xC0000000 | 0x0257
++#define NT_STATUS_NO_CALLBACK_ACTIVE 0xC0000000 | 0x0258
++#define NT_STATUS_LICENSE_QUOTA_EXCEEDED 0xC0000000 | 0x0259
++#define NT_STATUS_PWD_TOO_SHORT 0xC0000000 | 0x025a
++#define NT_STATUS_PWD_TOO_RECENT 0xC0000000 | 0x025b
++#define NT_STATUS_PWD_HISTORY_CONFLICT 0xC0000000 | 0x025c
++#define NT_STATUS_PLUGPLAY_NO_DEVICE 0xC0000000 | 0x025e
++#define NT_STATUS_UNSUPPORTED_COMPRESSION 0xC0000000 | 0x025f
++#define NT_STATUS_INVALID_HW_PROFILE 0xC0000000 | 0x0260
++#define NT_STATUS_INVALID_PLUGPLAY_DEVICE_PATH 0xC0000000 | 0x0261
++#define NT_STATUS_DRIVER_ORDINAL_NOT_FOUND 0xC0000000 | 0x0262
++#define NT_STATUS_DRIVER_ENTRYPOINT_NOT_FOUND 0xC0000000 | 0x0263
++#define NT_STATUS_RESOURCE_NOT_OWNED 0xC0000000 | 0x0264
++#define NT_STATUS_TOO_MANY_LINKS 0xC0000000 | 0x0265
++#define NT_STATUS_QUOTA_LIST_INCONSISTENT 0xC0000000 | 0x0266
++#define NT_STATUS_FILE_IS_OFFLINE 0xC0000000 | 0x0267
++#define NT_STATUS_NO_SUCH_JOB 0xC0000000 | 0xEDE	/* scheduler */
++
++#endif				/* _NTERR_H */
+diff -urN linux-2.4.29.old/fs/cifs/ntlmssp.h linux-2.4.29/fs/cifs/ntlmssp.h
+--- linux-2.4.29.old/fs/cifs/ntlmssp.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/ntlmssp.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,101 @@
++/*
++ *   fs/cifs/ntlmssp.h
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++
++#pragma pack(1)
++
++#define NTLMSSP_SIGNATURE "NTLMSSP"
++/* Message Types */
++#define NtLmNegotiate     1
++#define NtLmChallenge     2
++#define NtLmAuthenticate  3
++#define UnknownMessage    8
++
++/* Negotiate Flags */
++#define NTLMSSP_NEGOTIATE_UNICODE       0x01	// Text strings are in unicode
++#define NTLMSSP_NEGOTIATE_OEM           0x02	// Text strings are in OEM
++#define NTLMSSP_REQUEST_TARGET          0x04	// Server return its auth realm
++#define NTLMSSP_NEGOTIATE_SIGN        0x0010	// Request signature capability
++#define NTLMSSP_NEGOTIATE_SEAL        0x0020	// Request confidentiality
++#define NTLMSSP_NEGOTIATE_DGRAM       0x0040
++#define NTLMSSP_NEGOTIATE_LM_KEY      0x0080	// Use LM session key for sign/seal
++#define NTLMSSP_NEGOTIATE_NTLM        0x0200	// NTLM authentication
++#define NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED 0x1000
++#define NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED 0x2000
++#define NTLMSSP_NEGOTIATE_LOCAL_CALL  0x4000	// client/server on same machine
++#define NTLMSSP_NEGOTIATE_ALWAYS_SIGN 0x8000	// Sign for all security levels
++#define NTLMSSP_TARGET_TYPE_DOMAIN   0x10000
++#define NTLMSSP_TARGET_TYPE_SERVER   0x20000
++#define NTLMSSP_TARGET_TYPE_SHARE    0x40000
++#define NTLMSSP_NEGOTIATE_NTLMV2     0x80000
++#define NTLMSSP_REQUEST_INIT_RESP   0x100000
++#define NTLMSSP_REQUEST_ACCEPT_RESP 0x200000
++#define NTLMSSP_REQUEST_NOT_NT_KEY  0x400000
++#define NTLMSSP_NEGOTIATE_TARGET_INFO 0x800000
++#define NTLMSSP_NEGOTIATE_128     0x20000000
++#define NTLMSSP_NEGOTIATE_KEY_XCH 0x40000000
++#define NTLMSSP_NEGOTIATE_56      0x80000000
++
++/* Although typedefs are not commonly used for structure definitions */
++/* in the Linux kernel, in this particular case they are useful      */
++/* to more closely match the standards document for NTLMSSP from     */
++/* OpenGroup and to make the code more closely match the standard in */
++/* appearance */
++
++typedef struct _SECURITY_BUFFER {
++	__u16 Length;
++	__u16 MaximumLength;
++	__u32 Buffer;		/* offset to buffer */
++} SECURITY_BUFFER;
++
++typedef struct _NEGOTIATE_MESSAGE {
++	__u8 Signature[sizeof (NTLMSSP_SIGNATURE)];
++	__u32 MessageType;     /* 1 */
++	__u32 NegotiateFlags;
++	SECURITY_BUFFER DomainName;	/* RFC 1001 style and ASCII */
++	SECURITY_BUFFER WorkstationName;	/* RFC 1001 and ASCII */
++	char DomainString[0];
++	/* followed by WorkstationString */
++} NEGOTIATE_MESSAGE, *PNEGOTIATE_MESSAGE;
++
++typedef struct _CHALLENGE_MESSAGE {
++	__u8 Signature[sizeof (NTLMSSP_SIGNATURE)];
++	__u32 MessageType;   /* 2 */
++	SECURITY_BUFFER TargetName;
++	__u32 NegotiateFlags;
++	__u8 Challenge[CIFS_CRYPTO_KEY_SIZE];
++	__u8 Reserved[8];
++	SECURITY_BUFFER TargetInfoArray;
++} CHALLENGE_MESSAGE, *PCHALLENGE_MESSAGE;
++
++typedef struct _AUTHENTICATE_MESSAGE {
++	__u8 Signature[sizeof (NTLMSSP_SIGNATURE)];
++	__u32 MessageType;  /* 3 */
++	SECURITY_BUFFER LmChallengeResponse;
++	SECURITY_BUFFER NtChallengeResponse;
++	SECURITY_BUFFER DomainName;
++	SECURITY_BUFFER UserName;
++	SECURITY_BUFFER WorkstationName;
++	SECURITY_BUFFER SessionKey;
++	__u32 NegotiateFlags;
++	char UserString[0];
++} AUTHENTICATE_MESSAGE, *PAUTHENTICATE_MESSAGE;
++
++#pragma pack()			/* resume default structure packing */
+diff -urN linux-2.4.29.old/fs/cifs/README linux-2.4.29/fs/cifs/README
+--- linux-2.4.29.old/fs/cifs/README	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/README	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,356 @@
++The CIFS VFS support for Linux supports many advanced network filesystem 
++features such as heirarchical dfs like namespace, hardlinks, locking and more.  
++It was designed to comply with the SNIA CIFS Technical Reference (which 
++supersedes the 1992 X/Open SMB Standard) as well as to perform best practice 
++practical interoperability with Windows 2000, Windows XP, Samba and equivalent 
++servers.  
++
++For questions or bug reports please contact:
++    sfrench@samba.org (sfrench@us.ibm.com) 
++
++Build instructions:
++==================
++For Linux 2.4:
++1) Get the kernel source (e.g.from http://www.kernel.org)
++and download the cifs vfs source (see the project page
++at http://us1.samba.org/samba/Linux_CIFS_client.html)
++and change directory into the top of the kernel directory
++then patch the kernel (e.g. "patch -p1 < cifs_24.patch") 
++to add the cifs vfs to your kernel configure options if
++it has not already been added (e.g. current SuSE and UL
++users do not need to apply the cifs_24.patch since the cifs vfs is
++already in the kernel configure menu) and then
++mkdir linux/fs/cifs and then copy the current cifs vfs files from
++the cifs download to your kernel build directory e.g.
++
++	cp <cifs_download_dir>/fs/cifs/* to <kernel_download_dir>/fs/cifs
++	
++2) make menuconfig (or make xconfig)
++3) select cifs from within the network filesystem choices
++4) save and exit
++5) make dep
++6) make modules (or "make" if CIFS VFS not to be built as a module)
++
++For Linux 2.5:
++1) Download the kernel (e.g. from http://www.kernel.org or from bitkeeper
++at bk://linux.bkbits.net/linux-2.5) and change directory into the top
++of the kernel directory tree (e.g. /usr/src/linux-2.5.73)
++2) make menuconfig (or make xconfig)
++3) select cifs from within the network filesystem choices
++4) save and exit
++5) make
++
++
++Installation instructions:
++=========================
++If you have built the CIFS vfs as module (successfully) simply
++type "make modules_install" (or if you prefer, manually copy the file to
++the modules directory e.g. /lib/modules/2.4.10-4GB/kernel/fs/cifs/cifs.o).
++
++If you have built the CIFS vfs into the kernel itself, follow the instructions
++for your distribution on how to install a new kernel (usually you
++would simply type "make install").
++
++If you do not have the utility mount.cifs (in the Samba 3.0 source tree and on 
++the CIFS VFS web site) copy it to the same directory in which mount.smbfs and 
++similar files reside (usually /sbin).  Although the helper software is not  
++required, mount.cifs is recommended.  Eventually the Samba 3.0 utility program 
++"net" may also be helpful since it may someday provide easier mount syntax for
++users who are used to Windows e.g.  net use <mount point> <UNC name or cifs URL>  
++Note that running the Winbind pam/nss module (logon service) on all of your
++Linux clients is useful in mapping Uids and Gids consistently across the
++domain to the proper network user.  The mount.cifs mount helper can be
++trivially built from Samba 3.0 or later source e.g. by executing:
++
++	gcc samba/source/client/mount.cifs.c -o mount.cifs
++
++Note that when the mount.cifs utility is run suid (allowing user mounts), 
++in order to reduce risks, the "nosuid" mount flag is passed in on mount to
++disallow execution of an suid program mounted on the remote target.
++When mount is executed as root, nosuid is not passed in by default,
++and execution of suid programs on the remote target would be enabled
++by default. This can be changed, as with nfs and other filesystems, 
++by simply specifying "nosuid" among the mount options. For user mounts 
++though to be able to pass the suid flag to mount requires rebuilding 
++mount.cifs with the following flag: 
++ 
++        gcc samba/source/client/mount.cifs.c -DCIFS_ALLOW_USR_SUID -o mount.cifs
++
++There is a corresponding manual page for cifs mounting in the Samba 3.0 and
++later source tree in docs/manpages/mount.cifs.8 
++
++Samba Considerations 
++==================== 
++To get the maximum benefit from the CIFS VFS, we recommend using a server that 
++supports the SNIA CIFS Unix Extensions standard (e.g.  Samba 2.2.5 or later or 
++Samba 3.0) but the CIFS vfs works fine with a wide variety of CIFS servers.  
++Note that uid, gid and file permissions will display default values if you do 
++not have a server that supports the Unix extensions for CIFS (such as Samba 
++2.2.5 or later).  To enable the Unix CIFS Extensions in the Samba server, add 
++the line: 
++
++	unix extensions = yes
++	
++to your smb.conf file on the server.  Note that the following smb.conf settings 
++are also useful (on the Samba server) when the majority of clients are Unix or 
++Linux: 
++
++	case sensitive = yes
++	delete readonly = yes 
++	ea support = yes
++
++Note that ea support is required for supporting Linux xattrs. 
++Some administrators also change the "map archive" and the "create mask" 
++parameters from their default values.  Creating special devices (mknod) 
++remotely may require specifying a mkdev function to Samba if you are not using 
++Samba 3.0.5 or later.  For more information on these see the manual pages
++("man smb.conf") on the Samba server system.  Note that the cifs vfs,
++unlike the smbfs vfs, does not read the smb.conf on the client system 
++(the few optional settings are passed in on mount via -o parameters instead).  
++Note that Samba 2.2.7 or later includes a fix that allows the CIFS VFS to delete
++open files (required for strict POSIX compliance).  Windows Servers already 
++supported this feature. Samba server does not allow symlinks that refer to files
++outside of the share, so in Samba versions prior to 3.0.5, most symlinks to
++files with absolute paths (ie beginning with slash) such as:
++	 ln -s /mnt/foo bar
++would be forbidden. Samba 3.0.5 server or later includes the ability to create 
++such symlinks safely by converting unsafe symlinks (ie symlinks to server 
++files that are outside of the share) to a samba specific format on the server
++that is ignored by local server applications and non-cifs clients and that will
++not be traversed by the Samba server).  This is opaque to the Linux client
++application using the cifs vfs. Absolute symlinks will work to Samba 3.0.5 or
++later, but only for remote clients using the CIFS Unix extensions, and will
++be invisbile to Windows clients and typically will not affect local
++applications running on the same server as Samba.  
++
++Use instructions:
++================
++Once the CIFS VFS support is built into the kernel or installed as a module 
++(cifs.o), you can use mount syntax like the following to access Samba or Windows 
++servers: 
++
++  mount -t cifs //9.53.216.11/e$ /mnt -o user=myname,pass=mypassword
++
++Before -o the option -v may be specified to make the mount.cifs
++mount helper display the mount steps more verbosely.  
++After -o the following commonly used cifs vfs specific options
++are supported:
++
++  user=<username>
++  pass=<password>
++  domain=<domain name>
++  
++Other cifs mount options are described below.  Use of TCP names (in addition to
++ip addresses) is available if the mount helper (mount.cifs) is installed. If
++you do not trust the server to which are mounted, or if you do not have
++cifs signing enabled (and the physical network is insecure), consider use
++of the standard mount options "noexec" and "nosuid" to reduce the risk of 
++running an altered binary on your local system (downloaded from a hostile server
++or altered by a hostile router).
++
++When using the mount helper mount.cifs, passwords may be specified via alternate
++mechanisms, instead of specifying it after -o using the normal "pass=" syntax
++on the command line:
++1) By including it in a credential file. Specify credentials=filename as one
++of the mount options. Credential files contain two lines
++        username=someuser
++        password=your_password
++2) By specifying the password in the PASSWD environment variable (similarly
++the user name can be taken from the USER environment variable).
++3) By specifying the password in a file by name via PASSWD_FILE
++4) By specifying the password in a file by file descriptor via PASSWD_FD
++
++If no password is provided, mount.cifs will prompt for password entry
++
++Restrictions
++============
++Servers must support the NTLM SMB dialect (which is the most recent, supported 
++by Samba and Windows NT version 4, 2000 and XP and many other SMB/CIFS servers) 
++Servers must support either "pure-TCP" (port 445 TCP/IP CIFS connections) or RFC 
++1001/1002 support for "Netbios-Over-TCP/IP." Neither of these is likely to be a 
++problem as most servers support this.  IPv6 support is planned for the future.  
++
++CIFS VFS Mount Options
++======================
++A partial list of the supported mount options follows:
++  user		The user name to use when trying to establish
++		the CIFS session.
++  password	The user password.  If the mount helper is
++		installed, the user will be prompted for password
++		if it is not supplied.
++  ip		The ip address of the target server
++  unc		The target server Universal Network Name (export) to 
++		mount.	
++  domain	Set the SMB/CIFS workgroup name prepended to the
++		username during CIFS session establishment
++  uid		If CIFS Unix extensions are not supported by the server
++		this overrides the default uid for inodes. For mounts to
++		servers which do support the CIFS Unix extensions, such
++		as a properly configured Samba server, the server provides
++		the uid, gid and mode.  For servers which do not support
++		the Unix extensions, the default uid (and gid) returned on
++		lookup of existing files is the uid (gid) of the person
++		who executed the mount (root, except when mount.cifs
++		is configured setuid for user mounts) unless the "uid=" 
++		(gid) mount option is specified.  For the uid (gid) of newly
++		created files and directories, ie files created since 
++		the last mount of the server share, the expected uid 
++		(gid) is cached as as long as the inode remains in 
++		memory on the client.   Also note that permission
++		checks (authorization checks) on accesses to a file occur
++		at the server, but there are cases in which an administrator
++		may want to restrict at the client as well.  For those
++		servers which do not report a uid/gid owner
++		(such as Windows), permissions can also be checked at the
++		client, and a crude form of client side permission checking 
++		can be enabled by specifying file_mode and dir_mode on 
++		the client
++  gid		If CIFS Unix extensions are not supported by the server
++		this overrides the default gid for inodes.
++  file_mode     If CIFS Unix extensions are not supported by the server
++		this overrides the default mode for file inodes.
++  dir_mode      If CIFS Unix extensions are not supported by the server 
++		this overrides the default mode for directory inodes.
++  port		attempt to contact the server on this tcp port, before
++		trying the usual ports (port 445, then 139).
++  iocharset     Codepage used to convert local path names to and from
++		Unicode. Unicode is used by default for network path
++		names if the server supports it.  If iocharset is
++		not specified then the nls_default specified
++		during the local client kernel build will be used.
++		If server does not support Unicode, this parameter is
++		unused.
++  rsize		default read size
++  wsize		default write size
++  rw		mount the network share read-write (note that the
++		server may still consider the share read-only)
++  ro		mount network share read-only
++  version	used to distinguish different versions of the
++		mount helper utility (not typically needed)
++  sep		if first mount option (after the -o), overrides
++		the comma as the separator between the mount
++		parms. e.g.
++			-o user=myname,password=mypassword,domain=mydom
++		could be passed instead with period as the separator by
++			-o sep=.user=myname.password=mypassword.domain=mydom
++		this might be useful when comma is contained within username
++		or password or domain. This option is less important
++		when the cifs mount helper cifs.mount (version 1.1 or later)
++		is used.
++  nosuid        Do not allow remote executables with the suid bit 
++		program to be executed.  This is only meaningful for mounts
++		to servers such as Samba which support the CIFS Unix Extensions.
++		If you do not trust the servers in your network (your mount
++		targets) it is recommended that you specify this option for
++		greater security.
++  suid          Allow remote files on this mountpoint with suid enabled to 
++		be executed (default for mounts when executed as root,
++		nosuid is default for user mounts).
++  credentials   Although ignored by the cifs kernel component, it is used by 
++		the mount helper, mount.cifs. When mount.cifs is installed it
++		opens and reads the credential file specified in order  
++		to obtain the userid and password arguments which are passed to
++		the cifs vfs.
++  guest         Although ignored by the kernel component, the mount.cifs
++		mount helper will not prompt the user for a password
++		if guest is specified on the mount options.  If no
++		password is specified a null password will be used.
++
++The mount.cifs mount helper also accepts a few mount options before -o
++including:
++
++	-S      take password from stdin (equivalent to setting the environment
++		variable "PASSWD_FD=0"
++	-V      print mount.cifs version
++	-?      display simple usage information
++
++With recent 2.6 kernel versions of modutils, the version of the cifs kernel
++module can be displayed via modinfo.
++
++Misc /proc/fs/cifs Flags and Debug Info
++=======================================
++Informational pseudo-files:
++DebugData		Displays information about active CIFS sessions
++			and shares.
++Stats			Lists summary resource usage information as well as per
++			share statistics, if CONFIG_CIFS_STATS in enabled
++			in the kernel configuration.
++
++Configuration pseudo-files:
++MultiuserMount		If set to one, more than one CIFS session to 
++			the same server ip address can be established
++			if more than one uid accesses the same mount
++			point and if the uids user/password mapping
++			information is available. (default is 0)
++PacketSigningEnabled	If set to one, cifs packet signing is enabled
++			and will be used if the server requires 
++			it.  If set to two, cifs packet signing is
++			required even if the server considers packet
++			signing optional. (default 1)
++cifsFYI			If set to one, additional debug information is
++			logged to the system error log. (default 0)
++ExtendedSecurity	If set to one, SPNEGO session establishment
++			is allowed which enables more advanced 
++			secure CIFS session establishment (default 0)
++NTLMV2Enabled		If set to one, more secure password hashes
++			are used when the server supports them and
++			when kerberos is not negotiated (default 0)
++traceSMB		If set to one, debug information is logged to the
++			system error log with the start of smb requests
++			and responses (default 0)
++LookupCacheEnable	If set to one, inode information is kept cached
++			for one second improving performance of lookups
++			(default 1)
++OplockEnabled		If set to one, safe distributed caching enabled.
++			(default 1)
++LinuxExtensionsEnabled	If set to one then the client will attempt to
++			use the CIFS "UNIX" extensions which are optional
++			protocol enhancements that allow CIFS servers
++			to return accurate UID/GID information as well
++			as support symbolic links. If you use servers
++			such as Samba that support the CIFS Unix
++			extensions but do not want to use symbolic link
++			support and want to map the uid and gid fields 
++			to values supplied at mount (rather than the 
++			actual values, then set this to zero. (default 1)
++
++These experimental features and tracing can be enabled by changing flags in 
++/proc/fs/cifs (after the cifs module has been installed or built into the 
++kernel, e.g.  insmod cifs).  To enable a feature set it to 1 e.g.  to enable 
++tracing to the kernel message log type: 
++
++	echo 1 > /proc/fs/cifs/cifsFYI
++	
++and for more extensive tracing including the start of smb requests and responses
++
++	echo 1 > /proc/fs/cifs/traceSMB
++
++Three other experimental features are under development and to test 
++require enabling an ifdef (e.g. by  adding "#define CIFS_FCNTL" in cifsglob.h)
++
++	CONFIG_CIFS_QUOTA
++
++	CONFIG_CIFS_XATTR
++
++	CONFIG_CIFS_FCNTL  (fcntl needed for support of directory change 
++			    notification and perhaps later for file leases)
++
++Per share (per client mount) statistics are available in /proc/fs/cifs/DebugData
++if the kernel was configured with cifs statistics enabled.  The statistics
++represent the number of successful (ie non-zero return code from the server) 
++SMB responses to some of the more common commands (open, delete, mkdir etc.).
++Also recorded is the total bytes read and bytes written to the server for
++that share.  Note that due to client caching effects this can be less than the
++number of bytes read and written by the application running on the client.
++The statistics for the number of total SMBs and oplock breaks are different in
++that they represent all for that share, not just those for which the server
++returned success.
++	
++Also note that "cat /proc/fs/cifs/DebugData" will display information about 
++the active sessions and the shares that are mounted.  Note: NTLMv2 enablement 
++will not work since they its implementation is not quite complete yet.
++Do not alter these configuration values unless you are doing specific testing.  
++Enabling extended security works to Windows 2000 Workstations and XP but not to 
++Windows 2000 server or Samba since it does not usually send "raw NTLMSSP" 
++(instead it sends NTLMSSP encapsulated in SPNEGO/GSSAPI, which support is not 
++complete in the CIFS VFS yet).  
+diff -urN linux-2.4.29.old/fs/cifs/rfc1002pdu.h linux-2.4.29/fs/cifs/rfc1002pdu.h
+--- linux-2.4.29.old/fs/cifs/rfc1002pdu.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/rfc1002pdu.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,79 @@
++/*
++ *   fs/cifs/rfc1002pdu.h
++ *
++ *   Protocol Data Unit definitions for RFC 1001/1002 support
++ *
++ *   Copyright (c) International Business Machines  Corp., 2004
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++
++#pragma pack(1)
++
++/* NB: unlike smb/cifs packets, the RFC1002 structures are big endian */
++
++	/* RFC 1002 session packet types */
++#define RFC1002_SESSION_MESASAGE 0x00
++#define RFC1002_SESSION_REQUEST  0x81
++#define RFC1002_POSITIVE_SESSION_RESPONSE 0x82
++#define RFC1002_NEGATIVE_SESSION_RESPONSE 0x83
++#define RFC1002_RETARGET_SESSION_RESPONSE 0x83
++#define RFC1002_SESSION_KEEP_ALIVE 0x85
++
++	/* RFC 1002 flags (only one defined */
++#define RFC1002_LENGTH_EXTEND 0x80 /* high order bit of length (ie +64K) */
++
++struct rfc1002_session_packet {
++	__u8	type;
++	__u8	flags;
++	__u16	length;
++	union {
++		struct {
++			__u8 called_len;
++			__u8 called_name[32];
++			__u8 scope1; /* null */
++			__u8 calling_len;
++			__u8 calling_name[32];
++			__u8 scope2; /* null */
++		} session_req;
++		struct {
++			__u32 retarget_ip_addr;
++			__u16 port;
++		} retarget_resp;
++		__u8 neg_ses_resp_error_code;
++		/* POSITIVE_SESSION_RESPONSE packet does not include trailer.
++		SESSION_KEEP_ALIVE packet also does not include a trailer.
++		Trailer for the SESSION_MESSAGE packet is SMB/CIFS header */
++	} trailer;
++};
++
++/* Negative Session Response error codes */
++#define RFC1002_NOT_LISTENING_CALLED  0x80 /* not listening on called name */
++#define RFC1002_NOT_LISTENING_CALLING 0x81 /* not listening on calling name */
++#define RFC1002_NOT_PRESENT           0x82 /* called name not present */
++#define RFC1002_INSUFFICIENT_RESOURCE 0x83
++#define RFC1002_UNSPECIFIED_ERROR     0x8F
++
++/* RFC 1002 Datagram service packets are not defined here as they
++are not needed for the network filesystem client unless we plan on
++implementing broadcast resolution of the server ip address (from
++server netbios name). Currently server names are resolved only via DNS
++(tcp name) or ip address or an /etc/hosts equivalent mapping to ip address.*/
++
++#define DEFAULT_CIFS_CALLED_NAME  "*SMBSERVER      "
++
++#pragma pack()		/* resume default structure packing */
++                                                             
+diff -urN linux-2.4.29.old/fs/cifs/smbdes.c linux-2.4.29/fs/cifs/smbdes.c
+--- linux-2.4.29.old/fs/cifs/smbdes.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/smbdes.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,408 @@
++/* 
++   Unix SMB/Netbios implementation.
++   Version 1.9.
++
++   a partial implementation of DES designed for use in the 
++   SMB authentication protocol
++
++   Copyright (C) Andrew Tridgell 1998
++   Modified by Steve French (sfrench@us.ibm.com) 2002,2004
++   
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++   
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++   
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++*/
++
++/* NOTES: 
++
++   This code makes no attempt to be fast! In fact, it is a very
++   slow implementation 
++
++   This code is NOT a complete DES implementation. It implements only
++   the minimum necessary for SMB authentication, as used by all SMB
++   products (including every copy of Microsoft Windows95 ever sold)
++
++   In particular, it can only do a unchained forward DES pass. This
++   means it is not possible to use this code for encryption/decryption
++   of data, instead it is only useful as a "hash" algorithm.
++
++   There is no entry point into this code that allows normal DES operation.
++
++   I believe this means that this code does not come under ITAR
++   regulations but this is NOT a legal opinion. If you are concerned
++   about the applicability of ITAR regulations to this code then you
++   should confirm it for yourself (and maybe let me know if you come
++   up with a different answer to the one above)
++*/
++#include <linux/slab.h>
++#define uchar unsigned char
++
++static uchar perm1[56] = { 57, 49, 41, 33, 25, 17, 9,
++	1, 58, 50, 42, 34, 26, 18,
++	10, 2, 59, 51, 43, 35, 27,
++	19, 11, 3, 60, 52, 44, 36,
++	63, 55, 47, 39, 31, 23, 15,
++	7, 62, 54, 46, 38, 30, 22,
++	14, 6, 61, 53, 45, 37, 29,
++	21, 13, 5, 28, 20, 12, 4
++};
++
++static uchar perm2[48] = { 14, 17, 11, 24, 1, 5,
++	3, 28, 15, 6, 21, 10,
++	23, 19, 12, 4, 26, 8,
++	16, 7, 27, 20, 13, 2,
++	41, 52, 31, 37, 47, 55,
++	30, 40, 51, 45, 33, 48,
++	44, 49, 39, 56, 34, 53,
++	46, 42, 50, 36, 29, 32
++};
++
++static uchar perm3[64] = { 58, 50, 42, 34, 26, 18, 10, 2,
++	60, 52, 44, 36, 28, 20, 12, 4,
++	62, 54, 46, 38, 30, 22, 14, 6,
++	64, 56, 48, 40, 32, 24, 16, 8,
++	57, 49, 41, 33, 25, 17, 9, 1,
++	59, 51, 43, 35, 27, 19, 11, 3,
++	61, 53, 45, 37, 29, 21, 13, 5,
++	63, 55, 47, 39, 31, 23, 15, 7
++};
++
++static uchar perm4[48] = { 32, 1, 2, 3, 4, 5,
++	4, 5, 6, 7, 8, 9,
++	8, 9, 10, 11, 12, 13,
++	12, 13, 14, 15, 16, 17,
++	16, 17, 18, 19, 20, 21,
++	20, 21, 22, 23, 24, 25,
++	24, 25, 26, 27, 28, 29,
++	28, 29, 30, 31, 32, 1
++};
++
++static uchar perm5[32] = { 16, 7, 20, 21,
++	29, 12, 28, 17,
++	1, 15, 23, 26,
++	5, 18, 31, 10,
++	2, 8, 24, 14,
++	32, 27, 3, 9,
++	19, 13, 30, 6,
++	22, 11, 4, 25
++};
++
++static uchar perm6[64] = { 40, 8, 48, 16, 56, 24, 64, 32,
++	39, 7, 47, 15, 55, 23, 63, 31,
++	38, 6, 46, 14, 54, 22, 62, 30,
++	37, 5, 45, 13, 53, 21, 61, 29,
++	36, 4, 44, 12, 52, 20, 60, 28,
++	35, 3, 43, 11, 51, 19, 59, 27,
++	34, 2, 42, 10, 50, 18, 58, 26,
++	33, 1, 41, 9, 49, 17, 57, 25
++};
++
++static uchar sc[16] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
++
++static uchar sbox[8][4][16] = {
++	{{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
++	 {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
++	 {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
++	 {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}},
++
++	{{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
++	 {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
++	 {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
++	 {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}},
++
++	{{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
++	 {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
++	 {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
++	 {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}},
++
++	{{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
++	 {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
++	 {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
++	 {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}},
++
++	{{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
++	 {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
++	 {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
++	 {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}},
++
++	{{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
++	 {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
++	 {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
++	 {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}},
++
++	{{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
++	 {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
++	 {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
++	 {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}},
++
++	{{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
++	 {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
++	 {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
++	 {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}
++};
++
++static void
++permute(char *out, char *in, uchar * p, int n)
++{
++	int i;
++	for (i = 0; i < n; i++)
++		out[i] = in[p[i] - 1];
++}
++
++static void
++lshift(char *d, int count, int n)
++{
++	char out[64];
++	int i;
++	for (i = 0; i < n; i++)
++		out[i] = d[(i + count) % n];
++	for (i = 0; i < n; i++)
++		d[i] = out[i];
++}
++
++static void
++concat(char *out, char *in1, char *in2, int l1, int l2)
++{
++	while (l1--)
++		*out++ = *in1++;
++	while (l2--)
++		*out++ = *in2++;
++}
++
++static void
++xor(char *out, char *in1, char *in2, int n)
++{
++	int i;
++	for (i = 0; i < n; i++)
++		out[i] = in1[i] ^ in2[i];
++}
++
++static void
++dohash(char *out, char *in, char *key, int forw)
++{
++	int i, j, k;
++	char *pk1;
++	char c[28];
++	char d[28];
++	char *cd;
++	char ki[16][48];
++	char *pd1;
++	char l[32], r[32];
++	char *rl;
++
++	/* Have to reduce stack usage */
++	pk1 = kmalloc(56+56+64+64,GFP_KERNEL);
++	if(pk1 == NULL)
++		return;
++
++	cd = pk1 + 56;
++	pd1= cd  + 56;
++	rl = pd1 + 64;
++
++	permute(pk1, key, perm1, 56);
++
++	for (i = 0; i < 28; i++)
++		c[i] = pk1[i];
++	for (i = 0; i < 28; i++)
++		d[i] = pk1[i + 28];
++
++	for (i = 0; i < 16; i++) {
++		lshift(c, sc[i], 28);
++		lshift(d, sc[i], 28);
++
++		concat(cd, c, d, 28, 28);
++		permute(ki[i], cd, perm2, 48);
++	}
++
++	permute(pd1, in, perm3, 64);
++
++	for (j = 0; j < 32; j++) {
++		l[j] = pd1[j];
++		r[j] = pd1[j + 32];
++	}
++
++	for (i = 0; i < 16; i++) {
++		char *er;  /* er[48]  */
++		char *erk; /* erk[48] */
++		char b[8][6];
++		char *cb;  /* cb[32]  */
++		char *pcb; /* pcb[32] */
++		char *r2;  /* r2[32]  */
++
++		er = kmalloc(48+48+32+32+32, GFP_KERNEL);
++		if(er == NULL) {
++			kfree(pk1);
++			return;
++		}
++		erk = er+48;
++		cb  = erk+48;
++		pcb = cb+32;
++		r2  = pcb+32;
++
++		permute(er, r, perm4, 48);
++
++		xor(erk, er, ki[forw ? i : 15 - i], 48);
++
++		for (j = 0; j < 8; j++)
++			for (k = 0; k < 6; k++)
++				b[j][k] = erk[j * 6 + k];
++
++		for (j = 0; j < 8; j++) {
++			int m, n;
++			m = (b[j][0] << 1) | b[j][5];
++
++			n = (b[j][1] << 3) | (b[j][2] << 2) | (b[j][3] <<
++							       1) | b[j][4];
++
++			for (k = 0; k < 4; k++)
++				b[j][k] =
++				    (sbox[j][m][n] & (1 << (3 - k))) ? 1 : 0;
++		}
++
++		for (j = 0; j < 8; j++)
++			for (k = 0; k < 4; k++)
++				cb[j * 4 + k] = b[j][k];
++		permute(pcb, cb, perm5, 32);
++
++		xor(r2, l, pcb, 32);
++
++		for (j = 0; j < 32; j++)
++			l[j] = r[j];
++
++		for (j = 0; j < 32; j++)
++			r[j] = r2[j];
++
++		kfree(er);
++	}
++
++	concat(rl, r, l, 32, 32);
++
++	permute(out, rl, perm6, 64);
++	kfree(pk1);
++}
++
++static void
++str_to_key(unsigned char *str, unsigned char *key)
++{
++	int i;
++
++	key[0] = str[0] >> 1;
++	key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2);
++	key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3);
++	key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4);
++	key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5);
++	key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6);
++	key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7);
++	key[7] = str[6] & 0x7F;
++	for (i = 0; i < 8; i++) {
++		key[i] = (key[i] << 1);
++	}
++}
++
++static void
++smbhash(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
++{
++	int i;
++	char *outb; /* outb[64] */
++	char *inb;  /* inb[64]  */
++	char *keyb; /* keyb[64] */
++	unsigned char key2[8];
++
++	outb = kmalloc(64 * 3,GFP_KERNEL);
++	if(outb == NULL)
++		return;
++
++	inb  = outb + 64;
++	keyb = inb +  64;
++
++	str_to_key(key, key2);
++
++	for (i = 0; i < 64; i++) {
++		inb[i] = (in[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
++		keyb[i] = (key2[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
++		outb[i] = 0;
++	}
++
++	dohash(outb, inb, keyb, forw);
++
++	for (i = 0; i < 8; i++) {
++		out[i] = 0;
++	}
++
++	for (i = 0; i < 64; i++) {
++		if (outb[i])
++			out[i / 8] |= (1 << (7 - (i % 8)));
++	}
++	kfree(outb);
++}
++
++void
++E_P16(unsigned char *p14, unsigned char *p16)
++{
++	unsigned char sp8[8] =
++	    { 0x4b, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25 };
++	smbhash(p16, sp8, p14, 1);
++	smbhash(p16 + 8, sp8, p14 + 7, 1);
++}
++
++void
++E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24)
++{
++	smbhash(p24, c8, p21, 1);
++	smbhash(p24 + 8, c8, p21 + 7, 1);
++	smbhash(p24 + 16, c8, p21 + 14, 1);
++}
++
++void
++D_P16(unsigned char *p14, unsigned char *in, unsigned char *out)
++{
++	smbhash(out, in, p14, 0);
++	smbhash(out + 8, in + 8, p14 + 7, 0);
++}
++
++void
++E_old_pw_hash(unsigned char *p14, unsigned char *in, unsigned char *out)
++{
++	smbhash(out, in, p14, 1);
++	smbhash(out + 8, in + 8, p14 + 7, 1);
++}
++
++void
++cred_hash1(unsigned char *out, unsigned char *in, unsigned char *key)
++{
++	unsigned char buf[8];
++
++	smbhash(buf, in, key, 1);
++	smbhash(out, buf, key + 9, 1);
++}
++
++void
++cred_hash2(unsigned char *out, unsigned char *in, unsigned char *key)
++{
++	unsigned char buf[8];
++	static unsigned char key2[8];
++
++	smbhash(buf, in, key, 1);
++	key2[0] = key[7];
++	smbhash(out, buf, key2, 1);
++}
++
++void
++cred_hash3(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
++{
++	static unsigned char key2[8];
++
++	smbhash(out, in, key, forw);
++	key2[0] = key[7];
++	smbhash(out + 8, in + 8, key2, forw);
++}
+diff -urN linux-2.4.29.old/fs/cifs/smbencrypt.c linux-2.4.29/fs/cifs/smbencrypt.c
+--- linux-2.4.29.old/fs/cifs/smbencrypt.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/smbencrypt.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,295 @@
++/* 
++   Unix SMB/Netbios implementation.
++   Version 1.9.
++   SMB parameters and setup
++   Copyright (C) Andrew Tridgell 1992-2000
++   Copyright (C) Luke Kenneth Casson Leighton 1996-2000
++   Modified by Jeremy Allison 1995.
++   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
++   Modified by Steve French (sfrench@us.ibm.com) 2002-2003
++   
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++   
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++   
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++*/
++
++#include <linux/module.h>
++#include <linux/fs.h>
++#include <linux/string.h>
++#include <linux/kernel.h>
++#include <linux/random.h>
++#include "cifs_unicode.h"
++#include "cifspdu.h"
++#include "md5.h"
++#include "cifs_debug.h"
++
++#ifndef FALSE
++#define FALSE 0
++#endif
++#ifndef TRUE
++#define TRUE 1
++#endif
++
++/* following came from the other byteorder.h to avoid include conflicts */
++#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
++#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
++#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((__u16)(val)))
++
++/*The following definitions come from  lib/md4.c  */
++
++void mdfour(unsigned char *out, unsigned char *in, int n);
++
++/*The following definitions come from  libsmb/smbdes.c  */
++
++void E_P16(unsigned char *p14, unsigned char *p16);
++void E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24);
++void D_P16(unsigned char *p14, unsigned char *in, unsigned char *out);
++void E_old_pw_hash(unsigned char *p14, unsigned char *in, unsigned char *out);
++void cred_hash1(unsigned char *out, unsigned char *in, unsigned char *key);
++void cred_hash2(unsigned char *out, unsigned char *in, unsigned char *key);
++void cred_hash3(unsigned char *out, unsigned char *in, unsigned char *key,
++		int forw);
++
++/*The following definitions come from  libsmb/smbencrypt.c  */
++
++void SMBencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24);
++void E_md4hash(const unsigned char *passwd, unsigned char *p16);
++void nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16]);
++void SMBOWFencrypt(unsigned char passwd[16], unsigned char *c8,
++		   unsigned char p24[24]);
++void NTLMSSPOWFencrypt(unsigned char passwd[8],
++		       unsigned char *ntlmchalresp, unsigned char p24[24]);
++void SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24);
++int decode_pw_buffer(char in_buffer[516], char *new_pwrd,
++		     int new_pwrd_size, __u32 * new_pw_len);
++
++/*
++   This implements the X/Open SMB password encryption
++   It takes a password, a 8 byte "crypt key" and puts 24 bytes of 
++   encrypted password into p24 */
++/* Note that password must be uppercased and null terminated */
++void
++SMBencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24)
++{
++	unsigned char p14[15], p21[21];
++
++	memset(p21, '\0', 21);
++	memset(p14, '\0', 14);
++	strncpy((char *) p14, (char *) passwd, 14);
++
++/*	strupper((char *)p14); *//* BB at least uppercase the easy range */
++	E_P16(p14, p21);
++
++	SMBOWFencrypt(p21, c8, p24);
++	
++	memset(p14,0,15);
++	memset(p21,0,21);
++}
++
++/* Routines for Windows NT MD4 Hash functions. */
++static int
++_my_wcslen(__u16 * str)
++{
++	int len = 0;
++	while (*str++ != 0)
++		len++;
++	return len;
++}
++
++/*
++ * Convert a string into an NT UNICODE string.
++ * Note that regardless of processor type 
++ * this must be in intel (little-endian)
++ * format.
++ */
++
++static int
++_my_mbstowcs(__u16 * dst, const unsigned char *src, int len)
++{				/* not a very good conversion routine - change/fix */
++	int i;
++	__u16 val;
++
++	for (i = 0; i < len; i++) {
++		val = *src;
++		SSVAL(dst, 0, val);
++		dst++;
++		src++;
++		if (val == 0)
++			break;
++	}
++	return i;
++}
++
++/* 
++ * Creates the MD4 Hash of the users password in NT UNICODE.
++ */
++
++void
++E_md4hash(const unsigned char *passwd, unsigned char *p16)
++{
++	int len;
++	__u16 wpwd[129];
++
++	/* Password cannot be longer than 128 characters */
++	if(passwd) {
++		len = strlen((char *) passwd);
++		if (len > 128) {
++			len = 128;
++		}
++		/* Password must be converted to NT unicode */
++		_my_mbstowcs(wpwd, passwd, len);
++	} else
++		len = 0;
++
++	wpwd[len] = 0;	/* Ensure string is null terminated */
++	/* Calculate length in bytes */
++	len = _my_wcslen(wpwd) * sizeof (__u16);
++
++	mdfour(p16, (unsigned char *) wpwd, len);
++	memset(wpwd,0,129 * 2);
++}
++
++/* Does both the NT and LM owfs of a user's password */
++void
++nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16])
++{
++	char passwd[514];
++
++	memset(passwd, '\0', 514);
++	if (strlen(pwd) < 513)
++		strcpy(passwd, pwd);
++	else
++		memcpy(passwd, pwd, 512);
++	/* Calculate the MD4 hash (NT compatible) of the password */
++	memset(nt_p16, '\0', 16);
++	E_md4hash(passwd, nt_p16);
++
++	/* Mangle the passwords into Lanman format */
++	passwd[14] = '\0';
++/*	strupper(passwd); */
++
++	/* Calculate the SMB (lanman) hash functions of the password */
++
++	memset(p16, '\0', 16);
++	E_P16((unsigned char *) passwd, (unsigned char *) p16);
++
++	/* clear out local copy of user's password (just being paranoid). */
++	memset(passwd, '\0', sizeof (passwd));
++}
++
++/* Does the NTLMv2 owfs of a user's password */
++void
++ntv2_owf_gen(const unsigned char owf[16], const char *user_n,
++		const char *domain_n, unsigned char kr_buf[16],
++		const struct nls_table *nls_codepage)
++{
++	wchar_t * user_u;
++	wchar_t * dom_u;
++	int user_l, domain_l;
++	struct HMACMD5Context ctx;
++
++	/* might as well do one alloc to hold both (user_u and dom_u) */
++	user_u = kmalloc(2048 * sizeof(wchar_t),GFP_KERNEL); 
++	if(user_u == NULL)
++		return;
++	dom_u = user_u + 1024;
++    
++	/* push_ucs2(NULL, user_u, user_n, (user_l+1)*2, STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER);
++	   push_ucs2(NULL, dom_u, domain_n, (domain_l+1)*2, STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER); */
++
++	/* BB user and domain may need to be uppercased */
++	user_l = cifs_strtoUCS(user_u, user_n, 511, nls_codepage);
++	domain_l = cifs_strtoUCS(dom_u, domain_n, 511, nls_codepage);
++
++	user_l++;		/* trailing null */
++	domain_l++;
++
++	hmac_md5_init_limK_to_64(owf, 16, &ctx);
++	hmac_md5_update((const unsigned char *) user_u, user_l * 2, &ctx);
++	hmac_md5_update((const unsigned char *) dom_u, domain_l * 2, &ctx);
++	hmac_md5_final(kr_buf, &ctx);
++
++	kfree(user_u);
++}
++
++/* Does the des encryption from the NT or LM MD4 hash. */
++void
++SMBOWFencrypt(unsigned char passwd[16], unsigned char *c8,
++	      unsigned char p24[24])
++{
++	unsigned char p21[21];
++
++	memset(p21, '\0', 21);
++
++	memcpy(p21, passwd, 16);
++	E_P24(p21, c8, p24);
++}
++
++/* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
++void
++NTLMSSPOWFencrypt(unsigned char passwd[8],
++		  unsigned char *ntlmchalresp, unsigned char p24[24])
++{
++	unsigned char p21[21];
++
++	memset(p21, '\0', 21);
++	memcpy(p21, passwd, 8);
++	memset(p21 + 8, 0xbd, 8);
++
++	E_P24(p21, ntlmchalresp, p24);
++}
++
++/* Does the NT MD4 hash then des encryption. */
++
++void
++SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24)
++{
++	unsigned char p21[21];
++
++	memset(p21, '\0', 21);
++
++	E_md4hash(passwd, p21);
++	SMBOWFencrypt(p21, c8, p24);
++}
++
++/* Does the md5 encryption from the NT hash for NTLMv2. */
++void
++SMBOWFencrypt_ntv2(const unsigned char kr[16],
++                   const struct data_blob * srv_chal,
++                   const struct data_blob * cli_chal, unsigned char resp_buf[16])
++{
++        struct HMACMD5Context ctx;
++
++        hmac_md5_init_limK_to_64(kr, 16, &ctx);
++        hmac_md5_update(srv_chal->data, srv_chal->length, &ctx);
++        hmac_md5_update(cli_chal->data, cli_chal->length, &ctx);
++        hmac_md5_final(resp_buf, &ctx);
++}
++
++void
++SMBsesskeygen_ntv2(const unsigned char kr[16],
++		   const unsigned char *nt_resp, __u8 sess_key[16])
++{
++	struct HMACMD5Context ctx;
++
++	hmac_md5_init_limK_to_64(kr, 16, &ctx);
++	hmac_md5_update(nt_resp, 16, &ctx);
++	hmac_md5_final((unsigned char *) sess_key, &ctx);
++}
++
++void
++SMBsesskeygen_ntv1(const unsigned char kr[16],
++		   const unsigned char *nt_resp, __u8 sess_key[16])
++{
++	mdfour((unsigned char *) sess_key, (unsigned char *) kr, 16);
++}
+diff -urN linux-2.4.29.old/fs/cifs/smberr.c linux-2.4.29/fs/cifs/smberr.c
+--- linux-2.4.29.old/fs/cifs/smberr.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/smberr.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,240 @@
++/* 
++   Unix SMB/Netbios implementation.
++   Version 1.9.
++   Copyright (C) Andrew Tridgell 1998
++   Copyright (C) Steve French (sfrench@us.ibm.com) 2002
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2 of the License, or
++   (at your option) any later version.
++   
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++   
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++*/
++include "smberr.h"
++#define NO_SYSLOG
++/* error code stuff - put together by Merik Karman
++   merik@blackadder.dsh.oz.au */
++    typedef const struct {
++	char *name;
++	int code;
++	char *message;
++	int posix_code;
++} err_code_struct;
++
++/* Dos Error Messages */
++err_code_struct dos_msgs[] = {
++	{"ERRbadfunc", ERRbadfunc, "Invalid function.", -EINVAL},
++	{"ERRbadfile", ERRbadfile, "File not found.", -ENOENT},
++	{"ERRbadpath", ERRbadpath, "Directory invalid.", -ENOENT},
++	{"ERRnofids", ERRnofids, "No file descriptors available", -EMFILE},
++	{"ERRnoaccess", ERRnoaccess, "Access denied.", -EACCES},
++	{"ERRbadfid", ERRbadfid, "Invalid file handle.", -EBADF},
++	{"ERRbadmcb", 7, "Memory control blocks destroyed.", -EIO},
++	{"ERRnomem", ERRnomem,
++	 "Insufficient server memory to perform the requested function.",
++	 -ENOMEM},
++	{"ERRbadmem", ERRbadmem, "Invalid memory block address.", -EFAULT},
++	{"ERRbadenv", ERRbadenv, "Invalid environment.", -EFAULT},
++	{"ERRbadformat", 11, "Invalid format.", -EINVAL},
++	{"ERRbadaccess", ERRbadaccess, "Invalid open mode." - EACCES},
++	{"ERRbaddata", ERRbaddata, "Invalid data.", -EIO},
++	{"ERR", ERRres, "reserved.", -EIO},
++	{"ERRbaddrive", ERRbaddrive, "Invalid drive specified.", -ENXIO},
++	{"ERRremcd", ERRremcd,
++	 "A Delete Directory request attempted  to  remove  the  server's  current directory.",
++	 -EIO},
++	{"ERRdiffdevice", ERRdiffdevice, "Not same device.", -EXDEV},
++	{"ERRnofiles", ERRnofiles, "A File Search command can find no more files matching the specified criteria.", -ENOENT},	/* Note: must map to zero manually in some places such as readdir */
++	{"ERRbadshare", ERRbadshare,
++	 "The sharing mode specified for an Open conflicts with existing  FIDs  on the file.",
++	 -EXTBSY},
++	{"ERRlock", ERRlock,
++	 "A Lock request conflicted with an existing lock or specified an  invalid mode,  or an Unlock requested attempted to remove a lock held by another process.",
++	 -EACCES},
++	{"ERRunsup", ERRunsup, "The operation is unsupported", -EINVAL},
++	{"ERRnosuchshare", ERRnosuchshare,
++	 "You specified an invalid share name", -ENXIO},
++	{"ERRfilexists", ERRfilexists,
++	 "The file named in a Create Directory, Make  New  File  or  Link  request already exists.",
++	 -EEXIST},
++	{"ERRinvalidname", ERRinvalidname, "Invalid name", -ENOENT},
++	{"ERRdiskfull", ERRdiskfull, "Disk full", -ENOSPC}
++
++	{"ERRmoredata", ERRmoredata,
++	 "There is more data to be returned.",},
++	{"ERRinvgroup", 2455, "Invalid workgroup (try the -W option)"},
++	{NULL, -1, NULL, -EIO}
++};
++
++/* Server Error Messages */
++err_code_struct server_msgs[] = {
++	{"ERRerror", 1, "Non-specific error code."},
++	{"ERRbadpw", 2,
++	 "Bad password - name/password pair in a Tree Connect or Session Setup are invalid."},
++	{"ERRbadtype", 3, "reserved."},
++	{"ERRaccess", 4,
++	 "The requester does not have  the  necessary  access  rights  within  the specified  context for the requested function. The context is defined by the TID or the UID."},
++	{"ERRinvnid", 5,
++	 "The tree ID (TID) specified in a command was invalid."},
++	{"ERRinvnetname", 6, "Invalid network name in tree connect."},
++	{"ERRinvdevice", 7,
++	 "Invalid device - printer request made to non-printer connection or  non-printer request made to printer connection."},
++	{"ERRqfull", 49,
++	 "Print queue full (files) -- returned by open print file."},
++	{"ERRqtoobig", 50, "Print queue full -- no space."},
++	{"ERRqeof", 51, "EOF on print queue dump."},
++	{"ERRinvpfid", 52, "Invalid print file FID."},
++	{"ERRsmbcmd", 64,
++	 "The server did not recognize the command received."},
++	{"ERRsrverror", 65,
++	 "The server encountered an internal error, e.g., system file unavailable."},
++	{"ERRfilespecs", 67,
++	 "The file handle (FID) and pathname parameters contained an invalid  combination of values."},
++	{"ERRreserved", 68, "reserved."},
++	{"ERRbadpermits", 69,
++	 "The access permissions specified for a file or directory are not a valid combination.  The server cannot set the requested attribute."},
++	{"ERRreserved", 70, "reserved."},
++	{"ERRsetattrmode", 71,
++	 "The attribute mode in the Set File Attribute request is invalid."},
++	{"ERRpaused", 81, "Server is paused."},
++	{"ERRmsgoff", 82, "Not receiving messages."},
++	{"ERRnoroom", 83, "No room to buffer message."},
++	{"ERRrmuns", 87, "Too many remote user names."},
++	{"ERRtimeout", 88, "Operation timed out."},
++	{"ERRnoresource", 89,
++	 "No resources currently available for request."},
++	{"ERRtoomanyuids", 90, "Too many UIDs active on this session."},
++	{"ERRbaduid", 91,
++	 "The UID is not known as a valid ID on this session."},
++	{"ERRusempx", 250, "Temp unable to support Raw, use MPX mode."},
++	{"ERRusestd", 251,
++	 "Temp unable to support Raw, use standard read/write."},
++	{"ERRcontmpx", 252, "Continue in MPX mode."},
++	{"ERRreserved", 253, "reserved."},
++	{"ERRreserved", 254, "reserved."},
++	{"ERRnosupport", 0xFFFF, "Function not supported."},
++	{NULL, -1, NULL}
++};
++
++/* Hard Error Messages */
++err_code_struct hard_msgs[] = {
++	{"ERRnowrite", 19,
++	 "Attempt to write on write-protected diskette."},
++	{"ERRbadunit", 20, "Unknown unit."},
++	{"ERRnotready", 21, "Drive not ready."},
++	{"ERRbadcmd", 22, "Unknown command."},
++	{"ERRdata", 23, "Data error (CRC)."},
++	{"ERRbadreq", 24, "Bad request structure length."},
++	{"ERRseek", 25, "Seek error."},
++	{"ERRbadmedia", 26, "Unknown media type."},
++	{"ERRbadsector", 27, "Sector not found."},
++	{"ERRnopaper", 28, "Printer out of paper."},
++	{"ERRwrite", 29, "Write fault."},
++	{"ERRread", 30, "Read fault."},
++	{"ERRgeneral", 31, "General failure."},
++	{"ERRbadshare", 32, "An open conflicts with an existing open."},
++	{"ERRlock", 33,
++	 "A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process."},
++	{"ERRwrongdisk", 34, "The wrong disk was found in a drive."},
++	{"ERRFCBUnavail", 35, "No FCBs are available to process request."},
++	{"ERRsharebufexc", 36, "A sharing buffer has been exceeded."},
++	{NULL, -1, NULL}
++};
++
++
++const struct {
++	int code;
++	char *class;
++	err_code_struct *err_msgs;
++} err_classes[] = {
++	{
++	0, "SUCCESS", NULL}, {
++	0x01, "ERRDOS", dos_msgs}, {
++	0x02, "ERRSRV", server_msgs}, {
++	0x03, "ERRHRD", hard_msgs}, {
++	0x04, "ERRXOS", NULL}, {
++	0xE1, "ERRRMX1", NULL}, {
++	0xE2, "ERRRMX2", NULL}, {
++	0xE3, "ERRRMX3", NULL}, {
++	0xFF, "ERRCMD", NULL}, {
++-1, NULL, NULL}};
++
++
++/****************************************************************************
++return a SMB error string from a SMB buffer
++****************************************************************************/
++char *smb_dos_errstr(char *inbuf)
++{
++	static pstring ret;
++	int class = CVAL(inbuf, smb_rcls);
++	int num = SVAL(inbuf, smb_err);
++	int i, j;
++
++	for (i = 0; err_classes[i].class; i++)
++		if (err_classes[i].code == class) {
++			if (err_classes[i].err_msgs) {
++				err_code_struct *err =
++				    err_classes[i].err_msgs;
++				for (j = 0; err[j].name; j++)
++					if (num == err[j].code) {
++						if (DEBUGLEVEL > 0)
++							slprintf(ret,
++								 sizeof
++								 (ret) - 1,
++								 "%s - %s (%s)",
++								 err_classes
++								 [i].class,
++								 err[j].
++								 name,
++								 err[j].
++								 message);
++						else
++							slprintf(ret,
++								 sizeof
++								 (ret) - 1,
++								 "%s - %s",
++								 err_classes
++								 [i].class,
++								 err[j].
++								 name);
++						return ret;
++					}
++			}
++
++			slprintf(ret, sizeof(ret) - 1, "%s - %d",
++				 err_classes[i].class, num);
++			return ret;
++		}
++
++	slprintf(ret, sizeof(ret) - 1, "Error: Unknown error (%d,%d)",
++		 class, num);
++	return (ret);
++}
++
++
++/*****************************************************************************
++ returns an WERROR error message.
++ *****************************************************************************/
++char *werror_str(WERROR status)
++{
++	static fstring msg;
++	slprintf(msg, sizeof(msg), "WIN32 code 0x%08x", W_ERROR_V(status));
++	return msg;
++}
++
++
++/*****************************************************************************
++map a unix errno to a win32 error
++ *****************************************************************************/
++WERROR map_werror_from_unix(int error)
++{
++	NTSTATUS status = map_nt_error_from_unix(error);
++	return ntstatus_to_werror(status);
++}
+diff -urN linux-2.4.29.old/fs/cifs/smberr.h linux-2.4.29/fs/cifs/smberr.h
+--- linux-2.4.29.old/fs/cifs/smberr.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/smberr.h	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,113 @@
++/*
++ *   fs/cifs/smberr.h
++ *
++ *   Copyright (c) International Business Machines  Corp., 2002
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   See Error Codes section of the SNIA CIFS Specification 
++ *   for more information 
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++
++#define SUCCESS 0		/* The request was successful. */
++#define ERRDOS 0x01		/* Error is from the core DOS operating system set */
++#define ERRSRV 0x02		/* Error is generated by the file server daemon */
++#define ERRHRD 0x03		/* Error is a hardware error. */
++#define ERRCMD 0xFF		/*  Command was not in the "SMB" format. */
++
++/* The following error codes may be generated with the SUCCESS error class.*/
++
++#define SUCCESS 0		/* The request was successful. */
++
++/* The following error codes may be generated with the ERRDOS error class.*/
++
++#define ERRbadfunc 1		/* Invalid function. The server did not recognize or could not perform a system call generated by the server, e.g., set the DIRECTORY attribute on a data file, invalid seek mode. */
++#define ERRbadfile 2		/*File not found. The last component of a file's pathname could not be found. */
++#define ERRbadpath 3		/* Directory invalid. A directory component in a pathname could not be found. */
++#define ERRnofids 4		/* Too many open files. The server has no file handles available. */
++#define ERRnoaccess 5		/* Access denied, the client's context does not permit the requested function. This includes the following conditions: invalid rename command, write to Fid open for read only, read on Fid open for write only, attempt to delete a non-empty directory */
++#define ERRbadfid 6		/* Invalid file handle. The file handle specified was not recognized by the server. */
++#define ERRbadmcb 7		/* Memory control blocks destroyed. */
++#define ERRnomem 8		/* Insufficient server memory to perform the requested function. */
++#define ERRbadmem 9		/* Invalid memory block address. */
++#define ERRbadenv 10		/* Invalid environment. */
++#define ERRbadformat 11		/* Invalid format. */
++#define ERRbadaccess 12		/* Invalid open mode. */
++#define ERRbaddata 13		/* Invalid data (generated only by IOCTL calls within the server). */
++#define ERRbaddrive 15		/* Invalid drive specified. */
++#define ERRremcd 16		/* A Delete Directory request attempted to remove the server's current directory. */
++#define ERRdiffdevice 17	/* Not same device (e.g., a cross volume rename was attempted */
++#define ERRnofiles 18		/* A File Search command can find no more files matching the specified criteria. */
++#define ERRgeneral 31
++#define ERRbadshare 32		/* The sharing mode specified for an Open conflicts with existing FIDs on the file. */
++#define ERRlock 33		/* A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process. */
++#define ERRunsup     50
++#define ERRnosuchshare 67
++#define ERRfilexists 80		/* The file named in the request already exists. */
++#define ERRinvparm   87
++#define ERRdiskfull  112
++#define ERRinvname   123
++#define ERRdirnotempty 145
++#define ERRnotlocked   158
++#define ERRalreadyexists 183
++#define ERRbadpipe 230
++#define ERRpipebusy 231
++#define ERRpipeclosing 232
++#define ERRnotconnected 233
++#define ERRmoredata    234
++#define ErrQuota 0x200		/* The operation would cause a quota limit to be exceeded. */
++#define ErrNotALink 0x201	/* A link operation was performed on a pathname that
++				   was not a link. */
++
++/* Following error codes may be generated with the ERRSRV error
++class.*/
++
++#define ERRerror 1		/* Non-specific error code. It is returned under the following conditions: resource other than disk space exhausted (e.g. TIDs), first SMB command was not negotiate, multiple negotiates attempted, and internal server error. */
++#define ERRbadpw 2		/* Bad password - name/password pair in a TreeConnect or Session Setup are invalid. */
++#define ERRbadtype 3		/* used for indicating DFS referral needed */
++#define ERRaccess 4		/* The client does not have the necessary access rights within the specified context for requested function. */
++#define ERRinvtid 5		/* The Tid specified in a command was invalid. */
++#define ERRinvnetname 6		/* Invalid network name in tree connect. */
++#define ERRinvdevice 7		/* Invalid device - printer request made to non-printer connection or non-printer request made to printer connection. */
++#define ERRqfull 49		/* Print queue full (files) -- returned by open print file. */
++#define ERRqtoobig 50		/* Print queue full -- no space. */
++#define ERRqeof         51	/* EOF on print queue dump */
++#define ERRinvpfid      52	/* Invalid print file FID. */
++#define ERRsmbcmd       64	/* The server did not recognize the command received. */
++#define ERRsrverror     65	/* The server encountered an internal error, e.g., system file unavailable. */
++#define ERRbadBID       66	/* (obsolete) */
++#define ERRfilespecs    67	/* The Fid and pathname parameters contained an invalid combination of values. */
++#define ERRbadLink      68	/* (obsolete) */
++#define ERRbadpermits   69	/* The access permissions specified for a file or directory are not a valid combination. */
++#define ERRbadPID       70
++#define ERRsetattrmode  71	/* attribute (mode) is invalid */
++#define ERRpaused       81	/* Server is paused */
++#define ERRmsgoff	82	/* reserved - messaging off */
++#define ERRnoroom       83	/* reserved - no room for message */
++#define ERRrmuns        87	/* reserved - too many remote names */
++#define ERRtimeout      88	/* operation timed out */
++#define ERRnoresource   89	/* No resources available for request */
++#define ERRtoomanyuids  90	/* Too many UIDs active on this session */
++#define ERRbaduid       91	/* The UID is not known as a valid user */
++#define ERRusempx      250	/* temporarily unable to use raw */
++#define ERRusestd      251	/* temporarily unable to use either raw or mpx */
++#define ERR_NOTIFY_ENUM_DIR 1024
++#define ERRaccountexpired 2239
++#define ERRbadclient      2240
++#define ERRbadLogonTime   2241
++#define ERRpasswordExpired 2242
++#define ERRnetlogonNotStarted 2455
++#define ERRnosupport       0xFFFF
+diff -urN linux-2.4.29.old/fs/cifs/TODO linux-2.4.29/fs/cifs/TODO
+--- linux-2.4.29.old/fs/cifs/TODO	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/TODO	2004-07-14 00:25:04.000000000 +0200
+@@ -0,0 +1,106 @@
++version 1.16 May 27, 2004
++
++A Partial List of Missing Features
++==================================
++
++Contributions are welcome.  There are plenty of opportunities
++for visible, important contributions to this module.  Here
++is a partial list of the known problems and missing features:
++
++a) Support for SecurityDescriptors for chmod/chgrp/chown so
++these can be supported for Windows servers
++
++b) Better pam/winbind integration
++
++c) multi-user mounts - multiplexed sessionsetups over single vc
++(ie tcp session) - prettying up needed
++
++d) Kerberos/SPNEGO session setup support - (started)
++
++e) NTLMv2 authentication (mostly implemented)
++
++f) MD5-HMAC signing SMB PDUs when SPNEGO style SessionSetup 
++used (Kerberos or NTLMSSP). Signing alreadyimplemented for NTLM
++and raw NTLMSSP already. This is important when enabling
++extended security and mounting to Windows 2003 Servers
++
++f) Directory entry caching relies on a 1 second timer, rather than 
++using FindNotify or equivalent.  - (started)
++
++g) A few byte range testcases fail due to POSIX vs. Windows/CIFS
++style byte range lock differences
++
++h) quota support
++
++i) support for the Linux 2.5 kernel new feature get_xattr and set_xattr
++which will allow us to expose dos attributes as well as real
++ACLs. This support has been started in the current code, but is
++ifdeffed out.
++
++k) finish writepages support (multi-page write behind for improved
++performance) and syncpage
++
++l) hook lower into the sockets api (as NFS/SunRPC does) to avoid the
++extra copy in/out of the socket buffers in some cases.
++
++m) finish support for IPv6.  This is mostly complete but
++needs a simple inet_pton like function to convert ipv6
++addresses in string representation.
++
++o) Better optimize open (and pathbased setfilesize) to reduce the
++oplock breaks coming from windows srv.  Piggyback identical file
++opens on top of each other by incrementing reference count rather
++than resending (helps reduce server resource utilization and avoid
++spurious oplock breaks).
++
++p) Improve performance of readpages by sending more than one read
++at a time when 8 pages or more are requested.  Evaluate whether
++reads larger than 16K would be helpful.
++
++q) For support of Windows9x/98 we need to retry failed mounts
++to *SMBSERVER (default server name) with the uppercase hostname
++in the RFC1001 session_init request.
++
++r) Add Extended Attributed support (for storing UID/GID info
++to Windows servers)
++
++s) Finish fcntl D_NOTIFY support so kde and gnome file list windows
++will autorefresh
++
++t) Add GUI tool to configure /proc/fs/cifs settings and for display of
++the CIFS statistics
++
++KNOWN BUGS (updated May 27, 2004)
++====================================
++1) existing symbolic links (Windows reparse points) are recognized but
++can not be created remotely. They are implemented for Samba and those that
++support the CIFS Unix extensions but Samba has a bug currently handling
++symlink text beginning with slash
++2) follow_link and readdir code does not follow dfs junctions
++but recognizes them
++3) create of new files to FAT partitions on Windows servers can
++succeed but still return access denied (appears to be Windows 
++server not cifs client problem) and has not been reproduced recently.
++NTFS partitions do not have this problem.
++4) debug connectathon lock test case 10 which fails against
++Samba (may be unmappable due to POSIX to Windows lock model
++differences but worth investigating).  Also debug Samba to 
++see why lock test case 7 takes longer to complete to Samba
++than to Windows.
++
++Misc testing to do
++==================
++1) check out max path names and max path name components against various server
++types. Try nested symlinks. Return max path name in stat -f information
++
++2) Modify file portion of ltp so it can run against a mounted network
++share and run it against cifs vfs.
++
++3) Additional performance testing and optimization using iozone and similar - 
++there are some easy changes that can be done to parallelize sequential writes,
++and when signing is disabled to request larger read sizes (larger than 
++negotiated size) and send larger write sizes to modern servers.
++
++4) More exhaustively test the recently added NT4 support against various
++NT4 service pack levels.
++
+diff -urN linux-2.4.29.old/fs/cifs/transport.c linux-2.4.29/fs/cifs/transport.c
+--- linux-2.4.29.old/fs/cifs/transport.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.4.29/fs/cifs/transport.c	2004-07-14 00:25:05.000000000 +0200
+@@ -0,0 +1,434 @@
++/*
++ *   fs/cifs/transport.c
++ *
++ *   Copyright (C) International Business Machines  Corp., 2002,2004
++ *   Author(s): Steve French (sfrench@us.ibm.com)
++ *
++ *   This library is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU Lesser General Public License as published
++ *   by the Free Software Foundation; either version 2.1 of the License, or
++ *   (at your option) any later version.
++ *
++ *   This library is distributed in the hope that it will be useful,
++ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
++ *   the GNU Lesser General Public License for more details.
++ *
++ *   You should have received a copy of the GNU Lesser General Public License
++ *   along with this library; if not, write to the Free Software
++ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
++ */
++
++#include <linux/fs.h>
++#include <linux/list.h>
++#include <linux/wait.h>
++#include <linux/net.h>
++#include <linux/version.h>
++#include <asm/uaccess.h>
++#include <asm/processor.h>
++#include "cifspdu.h"
++#include "cifsglob.h"
++#include "cifsproto.h"
++#include "cifs_debug.h"
++
++extern kmem_cache_t *cifs_mid_cachep;
++extern kmem_cache_t *cifs_oplock_cachep;
++
++struct mid_q_entry *
++AllocMidQEntry(struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
++{
++	struct mid_q_entry *temp;
++
++	if (ses == NULL) {
++		cERROR(1, ("Null session passed in to AllocMidQEntry "));
++		return NULL;
++	}
++	if (ses->server == NULL) {
++		cERROR(1, ("Null TCP session in AllocMidQEntry"));
++		return NULL;
++	}
++	
++	temp = (struct mid_q_entry *) kmem_cache_alloc(cifs_mid_cachep,
++						       SLAB_KERNEL);
++	if (temp == NULL)
++		return temp;
++	else {
++		memset(temp, 0, sizeof (struct mid_q_entry));
++		temp->mid = smb_buffer->Mid;	/* always LE */
++		temp->pid = current->pid;
++		temp->command = smb_buffer->Command;
++		cFYI(1, ("For smb_command %d", temp->command));
++		do_gettimeofday(&temp->when_sent);
++		temp->ses = ses;
++		temp->tsk = current;
++	}
++
++	spin_lock(&GlobalMid_Lock);
++	list_add_tail(&temp->qhead, &ses->server->pending_mid_q);
++	atomic_inc(&midCount);
++	temp->midState = MID_REQUEST_ALLOCATED;
++	spin_unlock(&GlobalMid_Lock);
++	return temp;
++}
++
++void
++DeleteMidQEntry(struct mid_q_entry *midEntry)
++{
++	spin_lock(&GlobalMid_Lock);
++	midEntry->midState = MID_FREE;
++	list_del(&midEntry->qhead);
++	atomic_dec(&midCount);
++	spin_unlock(&GlobalMid_Lock);
++	cifs_buf_release(midEntry->resp_buf);
++	kmem_cache_free(cifs_mid_cachep, midEntry);
++}
++
++struct oplock_q_entry *
++AllocOplockQEntry(struct inode * pinode, __u16 fid, struct cifsTconInfo * tcon)
++{
++	struct oplock_q_entry *temp;
++	if ((pinode== NULL) || (tcon == NULL)) {
++		cERROR(1, ("Null parms passed to AllocOplockQEntry"));
++		return NULL;
++	}
++	temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
++						       SLAB_KERNEL);
++	if (temp == NULL)
++		return temp;
++	else {
++		temp->pinode = pinode;
++		temp->tcon = tcon;
++		temp->netfid = fid;
++		spin_lock(&GlobalMid_Lock);
++		list_add_tail(&temp->qhead, &GlobalOplock_Q);
++		spin_unlock(&GlobalMid_Lock);
++	}
++	return temp;
++
++}
++
++void DeleteOplockQEntry(struct oplock_q_entry * oplockEntry)
++{
++	spin_lock(&GlobalMid_Lock); 
++    /* should we check if list empty first? */
++	list_del(&oplockEntry->qhead);
++	spin_unlock(&GlobalMid_Lock);
++	kmem_cache_free(cifs_oplock_cachep, oplockEntry);
++}
++
++int
++smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
++	 unsigned int smb_buf_length, struct sockaddr *sin)
++{
++	int rc = 0;
++	int i = 0;
++	struct msghdr smb_msg;
++	struct iovec iov;
++	mm_segment_t temp_fs;
++
++	if(ssocket == NULL)
++		return -ENOTSOCK; /* BB eventually add reconnect code here */
++	iov.iov_base = smb_buffer;
++	iov.iov_len = smb_buf_length + 4;
++
++	smb_msg.msg_name = sin;
++	smb_msg.msg_namelen = sizeof (struct sockaddr);
++	smb_msg.msg_iov = &iov;
++	smb_msg.msg_iovlen = 1;
++	smb_msg.msg_control = NULL;
++	smb_msg.msg_controllen = 0;
++	smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
++
++	/* smb header is converted in header_assemble. bcc and rest of SMB word
++	   area, and byte area if necessary, is converted to littleendian in 
++	   cifssmb.c and RFC1001 len is converted to bigendian in smb_send 
++	   Flags2 is converted in SendReceive */
++
++	smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
++	cFYI(1, ("Sending smb of length %d ", smb_buf_length));
++	dump_smb(smb_buffer, smb_buf_length + 4);
++
++	temp_fs = get_fs();	/* we must turn off socket api parm checking */
++	set_fs(get_ds());
++	while(iov.iov_len > 0) {
++		rc = sock_sendmsg(ssocket, &smb_msg, smb_buf_length + 4);
++		if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
++			i++;
++			if(i > 60) {
++				cERROR(1,
++				   ("sends on sock %p stuck for 30 seconds",
++				    ssocket));
++				rc = -EAGAIN;
++				break;
++			}
++			set_current_state(TASK_INTERRUPTIBLE);
++			schedule_timeout(HZ/2);
++			continue;
++		}
++		if (rc < 0) 
++			break;
++		iov.iov_base += rc;
++		iov.iov_len -= rc;
++	}
++	set_fs(temp_fs);
++
++	if (rc < 0) {
++		cERROR(1,("Error %d sending data on socket to server.", rc));
++	} else {
++		rc = 0;
++	}
++
++	return rc;
++}
++
++int
++SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
++	    struct smb_hdr *in_buf, struct smb_hdr *out_buf,
++	    int *pbytes_returned, const int long_op)
++{
++	int rc = 0;
++	unsigned int receive_len;
++	long timeout;
++	struct mid_q_entry *midQ;
++
++	if (ses == NULL) {
++		cERROR(1,("Null smb session"));
++		return -EIO;
++	}
++	if(ses->server == NULL) {
++		cERROR(1,("Null tcp session"));
++		return -EIO;
++	}
++
++	/* Ensure that we do not send more than 50 overlapping requests 
++	   to the same server. We may make this configurable later or
++	   use ses->maxReq */
++	if(long_op == -1) {
++		/* oplock breaks must not be held up */
++		atomic_inc(&ses->server->inFlight);
++	} else {
++		spin_lock(&GlobalMid_Lock); 
++		while(1) {        
++			if(atomic_read(&ses->server->inFlight) >= CIFS_MAX_REQ){
++				spin_unlock(&GlobalMid_Lock);
++				wait_event(ses->server->request_q,
++					atomic_read(&ses->server->inFlight)
++					 < CIFS_MAX_REQ);
++				spin_lock(&GlobalMid_Lock);
++			} else {
++				if(ses->server->tcpStatus == CifsExiting) {
++					spin_unlock(&GlobalMid_Lock);
++					return -ENOENT;
++				}
++
++			/* can not count locking commands against total since
++			   they are allowed to block on server */
++					
++				if(long_op < 3) {
++				/* update # of requests on the wire to server */
++					atomic_inc(&ses->server->inFlight);
++				}
++				spin_unlock(&GlobalMid_Lock);
++				break;
++			}
++		}
++	}
++	/* make sure that we sign in the same order that we send on this socket 
++	   and avoid races inside tcp sendmsg code that could cause corruption
++	   of smb data */
++
++	down(&ses->server->tcpSem); 
++
++	if (ses->server->tcpStatus == CifsExiting) {
++		rc = -ENOENT;
++		goto out_unlock;
++	} else if (ses->server->tcpStatus == CifsNeedReconnect) {
++		cFYI(1,("tcp session dead - return to caller to retry"));
++		rc = -EAGAIN;
++		goto out_unlock;
++	} else if (ses->status != CifsGood) {
++		/* check if SMB session is bad because we are setting it up */
++		if((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) && 
++			(in_buf->Command != SMB_COM_NEGOTIATE)) {
++			rc = -EAGAIN;
++			goto out_unlock;
++		} /* else ok - we are setting up session */
++	}
++	midQ = AllocMidQEntry(in_buf, ses);
++	if (midQ == NULL) {
++		up(&ses->server->tcpSem);
++		/* If not lock req, update # of requests on wire to server */
++		if(long_op < 3) {
++			atomic_dec(&ses->server->inFlight); 
++			wake_up(&ses->server->request_q);
++		}
++		return -ENOMEM;
++	}
++
++	if (in_buf->smb_buf_length > CIFS_MAX_MSGSIZE + MAX_CIFS_HDR_SIZE - 4) {
++		up(&ses->server->tcpSem);
++		cERROR(1,
++		       ("Illegal length, greater than maximum frame, %d ",
++			in_buf->smb_buf_length));
++		DeleteMidQEntry(midQ);
++		/* If not lock req, update # of requests on wire to server */
++		if(long_op < 3) {
++			atomic_dec(&ses->server->inFlight); 
++			wake_up(&ses->server->request_q);
++		}
++		return -EIO;
++	}
++
++	if (in_buf->smb_buf_length > 12)
++		in_buf->Flags2 = cpu_to_le16(in_buf->Flags2);
++	
++	rc = cifs_sign_smb(in_buf, ses, &midQ->sequence_number);
++
++	midQ->midState = MID_REQUEST_SUBMITTED;
++	rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
++		      (struct sockaddr *) &(ses->server->addr.sockAddr));
++	if(rc < 0) {
++		DeleteMidQEntry(midQ);
++		up(&ses->server->tcpSem);
++		/* If not lock req, update # of requests on wire to server */
++		if(long_op < 3) {
++			atomic_dec(&ses->server->inFlight); 
++			wake_up(&ses->server->request_q);
++		}
++		return rc;
++	} else
++		up(&ses->server->tcpSem);
++	if (long_op == -1)
++		goto cifs_no_response_exit;
++	else if (long_op == 2) /* writes past end of file can take looooong time */
++		timeout = 300 * HZ;
++	else if (long_op == 1)
++		timeout = 45 * HZ; /* should be greater than 
++			servers oplock break timeout (about 43 seconds) */
++	else if (long_op > 2) {
++		timeout = MAX_SCHEDULE_TIMEOUT;
++	} else
++		timeout = 15 * HZ;
++	/* wait for 15 seconds or until woken up due to response arriving or 
++	   due to last connection to this server being unmounted */
++	if (signal_pending(current)) {
++		/* if signal pending do not hold up user for full smb timeout
++		but we still give response a change to complete */
++		if(midQ->midState & MID_REQUEST_SUBMITTED) {
++			set_current_state(TASK_UNINTERRUPTIBLE);
++			timeout = sleep_on_timeout(&ses->server->response_q,2 * HZ);
++		}
++	} else { /* using normal timeout */
++		/* timeout = wait_event_interruptible_timeout(ses->server->response_q,
++			(midQ->midState & MID_RESPONSE_RECEIVED) || 
++			((ses->server->tcpStatus != CifsGood) &&
++			 (ses->server->tcpStatus != CifsNew)),
++			timeout); */ 
++		/* Can not allow user interrupts- wreaks havoc with performance */
++		if(midQ->midState & MID_REQUEST_SUBMITTED) {
++			set_current_state(TASK_UNINTERRUPTIBLE);
++			timeout = sleep_on_timeout(&ses->server->response_q,timeout);
++		}
++	}
++    
++	spin_lock(&GlobalMid_Lock);
++	if (midQ->resp_buf) {
++		spin_unlock(&GlobalMid_Lock);
++		receive_len = be32_to_cpu(midQ->resp_buf->smb_buf_length);
++	} else {
++		cERROR(1,("No response buffer"));
++		if(midQ->midState == MID_REQUEST_SUBMITTED) {
++			if(ses->server->tcpStatus == CifsExiting)
++				rc = -EHOSTDOWN;
++			else {
++				ses->server->tcpStatus = CifsNeedReconnect;
++				midQ->midState = MID_RETRY_NEEDED;
++			}
++		}
++
++		if (rc != -EHOSTDOWN) {
++			if(midQ->midState == MID_RETRY_NEEDED) {
++				rc = -EAGAIN;
++				cFYI(1,("marking request for retry"));
++			} else {
++				rc = -EIO;
++			}
++		}
++		spin_unlock(&GlobalMid_Lock);
++		DeleteMidQEntry(midQ);
++		/* If not lock req, update # of requests on wire to server */
++		if(long_op < 3) {
++			atomic_dec(&ses->server->inFlight); 
++			wake_up(&ses->server->request_q);
++		}
++		return rc;
++	}
++  
++	if (receive_len > CIFS_MAX_MSGSIZE + MAX_CIFS_HDR_SIZE) {
++		cERROR(1,
++		       ("Frame too large received.  Length: %d  Xid: %d",
++			receive_len, xid));
++		rc = -EIO;
++	} else {		/* rcvd frame is ok */
++
++		if (midQ->resp_buf && out_buf
++		    && (midQ->midState == MID_RESPONSE_RECEIVED)) {
++			memcpy(out_buf, midQ->resp_buf,
++			       receive_len +
++			       4 /* include 4 byte RFC1001 header */ );
++
++			dump_smb(out_buf, 92);
++			/* convert the length into a more usable form */
++			out_buf->smb_buf_length =
++			    be32_to_cpu(out_buf->smb_buf_length);
++			if((out_buf->smb_buf_length > 24) &&
++			   (ses->server->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))) {
++				rc = cifs_verify_signature(out_buf, ses->mac_signing_key,midQ->sequence_number); /* BB fix BB */
++				if(rc)
++					cFYI(1,("Unexpected signature received from server"));
++			}
++
++			if (out_buf->smb_buf_length > 12)
++				out_buf->Flags2 = le16_to_cpu(out_buf->Flags2);
++			if (out_buf->smb_buf_length > 28)
++				out_buf->Pid = le16_to_cpu(out_buf->Pid);
++			if (out_buf->smb_buf_length > 28)
++				out_buf->PidHigh =
++				    le16_to_cpu(out_buf->PidHigh);
++
++			*pbytes_returned = out_buf->smb_buf_length;
++
++			/* BB special case reconnect tid and reconnect uid here? */
++			rc = map_smb_to_linux_error(out_buf);
++
++			/* convert ByteCount if necessary */
++			if (receive_len >=
++			    sizeof (struct smb_hdr) -
++			    4 /* do not count RFC1001 header */  +
++			    (2 * out_buf->WordCount) + 2 /* bcc */ )
++				BCC(out_buf) = le16_to_cpu(BCC(out_buf));
++		} else {
++			rc = -EIO;
++			cFYI(1,("Bad MID state? "));
++		}
++	}
++cifs_no_response_exit:
++	DeleteMidQEntry(midQ);
++
++	if(long_op < 3) {
++		atomic_dec(&ses->server->inFlight); 
++		wake_up(&ses->server->request_q);
++	}
++
++	return rc;
++
++out_unlock:
++	up(&ses->server->tcpSem);
++	/* If not lock req, update # of requests on wire to server */
++	if(long_op < 3) {
++		atomic_dec(&ses->server->inFlight); 
++		wake_up(&ses->server->request_q);
++	}
++
++	return rc;
++}
+diff -urN linux-2.4.29.old/fs/Config.in linux-2.4.29/fs/Config.in
+--- linux-2.4.29.old/fs/Config.in	2005-03-21 19:30:22.000000000 +0100
++++ linux-2.4.29/fs/Config.in	2005-03-21 19:36:51.000000000 +0100
+@@ -146,6 +146,10 @@
+      define_bool CONFIG_LOCKD_V4 y
+    fi
+ 
++   dep_tristate 'CIFS support (advanced network filesystem for Samba, Window and other CIFS compliant servers)' CONFIG_CIFS $CONFIG_INET
++   dep_mbool '  CIFS statistics' CONFIG_CIFS_STATS $CONFIG_CIFS
++   dep_mbool '  CIFS POSIX Protocol Extensions' CONFIG_CIFS_POSIX $CONFIG_CIFS
++
+    dep_tristate 'SMB file system support (to mount Windows shares etc.)' CONFIG_SMB_FS $CONFIG_INET
+    if [ "$CONFIG_SMB_FS" != "n" ]; then
+       bool '  Use a default NLS' CONFIG_SMB_NLS_DEFAULT
+diff -urN linux-2.4.29.old/fs/Makefile linux-2.4.29/fs/Makefile
+--- linux-2.4.29.old/fs/Makefile	2005-03-21 19:30:22.000000000 +0100
++++ linux-2.4.29/fs/Makefile	2005-03-21 19:36:51.000000000 +0100
+@@ -37,6 +37,7 @@
+ subdir-$(CONFIG_VFAT_FS)	+= vfat
+ subdir-$(CONFIG_BFS_FS)		+= bfs
+ subdir-$(CONFIG_ISO9660_FS)	+= isofs
++subdir-$(CONFIG_CIFS)		+= cifs
+ subdir-$(CONFIG_DEVFS_FS)	+= devfs
+ subdir-$(CONFIG_HFSPLUS_FS)	+= hfsplus # Before hfs to find wrapped HFS+
+ subdir-$(CONFIG_HFS_FS)		+= hfs
+diff -urN linux-2.4.29.old/fs/nls/Config.in linux-2.4.29/fs/nls/Config.in
+--- linux-2.4.29.old/fs/nls/Config.in	2003-08-25 13:44:43.000000000 +0200
++++ linux-2.4.29/fs/nls/Config.in	2005-03-21 19:36:51.000000000 +0100
+@@ -11,6 +11,7 @@
+ 
+ # msdos and Joliet want NLS
+ if [ "$CONFIG_JOLIET" = "y" -o "$CONFIG_FAT_FS" != "n" \
++	-o "$CONFIG_CIFS" != "n" \
+ 	-o "$CONFIG_NTFS_FS" != "n" -o "$CONFIG_NCPFS_NLS" = "y" \
+ 	-o "$CONFIG_SMB_NLS" = "y" -o "$CONFIG_JFS_FS" != "n" \
+ 	-o "$CONFIG_BEFS_FS" != "n" -o "$CONFIG_HFSPLUS_FS" != "n" ]; then