diff options
Diffstat (limited to 'recipes/linux/linux-wrt-2.4.30/305-cifs-1.20c')
| -rw-r--r-- | recipes/linux/linux-wrt-2.4.30/305-cifs-1.20c | 22022 |
1 files changed, 22022 insertions, 0 deletions
diff --git a/recipes/linux/linux-wrt-2.4.30/305-cifs-1.20c b/recipes/linux/linux-wrt-2.4.30/305-cifs-1.20c new file mode 100644 index 0000000000..bdccf4de9f --- /dev/null +++ b/recipes/linux/linux-wrt-2.4.30/305-cifs-1.20c @@ -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, ¤t_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 |