/* 
   Unix SMB/CIFS implementation.
   client trans2 operations
   Copyright (C) James Myers 2003
   Copyright (C) Andrew Tridgell 2003
   Copyright (C) James Peach 2007
   
   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 3 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, see <http://www.gnu.org/licenses/>.
*/

#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/raw/raw_proto.h"
#include "librpc/gen_ndr/ndr_security.h"

/* local macros to make the code more readable */
#define FINFO_CHECK_MIN_SIZE(size) if (blob->length < (size)) { \
      DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected min of %d\n", \
	       (int)blob->length, parms->generic.level, (size))); \
      return NT_STATUS_INFO_LENGTH_MISMATCH; \
}
#define FINFO_CHECK_SIZE(size) if (blob->length != (size)) { \
      DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected %d\n", \
	       (int)blob->length, parms->generic.level, (size))); \
      return NT_STATUS_INFO_LENGTH_MISMATCH; \
}

/*
  parse a stream information structure
*/
NTSTATUS smbcli_parse_stream_info(DATA_BLOB blob, TALLOC_CTX *mem_ctx,
				  struct stream_information *io)
{
	uint32_t ofs = 0;
	io->num_streams = 0;
	io->streams = NULL;

	while (blob.length - ofs >= 24) {
		unsigned int n = io->num_streams;
		uint32_t nlen, len;
		bool ret;
		void *vstr;
		size_t converted_size = 0;

		io->streams = 
			talloc_realloc(mem_ctx, io->streams, struct stream_struct, n+1);
		if (!io->streams) {
			return NT_STATUS_NO_MEMORY;
		}
		nlen                      = IVAL(blob.data, ofs + 0x04);
		io->streams[n].size       = BVAL(blob.data, ofs + 0x08);
		io->streams[n].alloc_size = BVAL(blob.data, ofs + 0x10);
		if (nlen > blob.length - (ofs + 24)) {
			return NT_STATUS_INFO_LENGTH_MISMATCH;
		}
		ret = convert_string_talloc(io->streams, 
					     CH_UTF16, CH_UNIX,
					     blob.data+ofs+24, nlen, &vstr, &converted_size);
		if (!ret) {
			return NT_STATUS_ILLEGAL_CHARACTER;
		}
		io->streams[n].stream_name.s = (const char *)vstr;
		io->streams[n].stream_name.private_length = nlen;
		io->num_streams++;
		len = IVAL(blob.data, ofs);
		if (len > blob.length - ofs) {
			return NT_STATUS_INFO_LENGTH_MISMATCH;
		}
		if (len == 0) break;
		ofs += len;
	}

	return NT_STATUS_OK;
}

/*
  parse the fsinfo 'passthru' level replies
*/
NTSTATUS smb_raw_fileinfo_passthru_parse(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, 
					 enum smb_fileinfo_level level,
					 union smb_fileinfo *parms)
{	
	switch (level) {
	case RAW_FILEINFO_BASIC_INFORMATION:
		/* some servers return 40 bytes and some 36. w2k3 return 40, so thats
		   what we should do, but we need to accept 36 */
		if (blob->length != 36) {
			FINFO_CHECK_SIZE(40);
		}
		parms->basic_info.out.create_time = smbcli_pull_nttime(blob->data, 0);
		parms->basic_info.out.access_time = smbcli_pull_nttime(blob->data, 8);
		parms->basic_info.out.write_time  = smbcli_pull_nttime(blob->data, 16);
		parms->basic_info.out.change_time = smbcli_pull_nttime(blob->data, 24);
		parms->basic_info.out.attrib      = IVAL(blob->data, 32);
		return NT_STATUS_OK;

	case RAW_FILEINFO_STANDARD_INFORMATION:
		FINFO_CHECK_SIZE(24);
		parms->standard_info.out.alloc_size =     BVAL(blob->data, 0);
		parms->standard_info.out.size =           BVAL(blob->data, 8);
		parms->standard_info.out.nlink =          IVAL(blob->data, 16);
		parms->standard_info.out.delete_pending = CVAL(blob->data, 20);
		parms->standard_info.out.directory =      CVAL(blob->data, 21);
		return NT_STATUS_OK;

	case RAW_FILEINFO_EA_INFORMATION:
		FINFO_CHECK_SIZE(4);
		parms->ea_info.out.ea_size = IVAL(blob->data, 0);
		return NT_STATUS_OK;

	case RAW_FILEINFO_NAME_INFORMATION:
		FINFO_CHECK_MIN_SIZE(4);
		smbcli_blob_pull_string(NULL, mem_ctx, blob, 
					&parms->name_info.out.fname, 0, 4, STR_UNICODE);
		return NT_STATUS_OK;

	case RAW_FILEINFO_ALL_INFORMATION:
		FINFO_CHECK_MIN_SIZE(72);
		parms->all_info.out.create_time =           smbcli_pull_nttime(blob->data, 0);
		parms->all_info.out.access_time =           smbcli_pull_nttime(blob->data, 8);
		parms->all_info.out.write_time =            smbcli_pull_nttime(blob->data, 16);
		parms->all_info.out.change_time =           smbcli_pull_nttime(blob->data, 24);
		parms->all_info.out.attrib =                IVAL(blob->data, 32);
		parms->all_info.out.alloc_size =            BVAL(blob->data, 40);
		parms->all_info.out.size =                  BVAL(blob->data, 48);
		parms->all_info.out.nlink =                 IVAL(blob->data, 56);
		parms->all_info.out.delete_pending =        CVAL(blob->data, 60);
		parms->all_info.out.directory =             CVAL(blob->data, 61);
#if 1
		parms->all_info.out.ea_size =               IVAL(blob->data, 64);
		smbcli_blob_pull_string(NULL, mem_ctx, blob,
					&parms->all_info.out.fname, 68, 72, STR_UNICODE);
#else
		/* this is what the CIFS spec says - and its totally
		   wrong, but its useful having it here so we can
		   quickly adapt to broken servers when running
		   tests */
		parms->all_info.out.ea_size =               IVAL(blob->data, 72);
		/* access flags 4 bytes at 76
		   current_position 8 bytes at 80
		   mode 4 bytes at 88
		   alignment 4 bytes at 92
		*/
		smbcli_blob_pull_string(NULL, mem_ctx, blob,
					&parms->all_info.out.fname, 96, 100, STR_UNICODE);
#endif
		return NT_STATUS_OK;

	case RAW_FILEINFO_ALT_NAME_INFORMATION:
		FINFO_CHECK_MIN_SIZE(4);
		smbcli_blob_pull_string(NULL, mem_ctx, blob, 
					&parms->alt_name_info.out.fname, 0, 4, STR_UNICODE);
		return NT_STATUS_OK;

	case RAW_FILEINFO_STREAM_INFORMATION:
		return smbcli_parse_stream_info(*blob, mem_ctx, &parms->stream_info.out);

	case RAW_FILEINFO_INTERNAL_INFORMATION:
		FINFO_CHECK_SIZE(8);
		parms->internal_information.out.file_id = BVAL(blob->data, 0);
		return NT_STATUS_OK;

	case RAW_FILEINFO_ACCESS_INFORMATION:
		FINFO_CHECK_SIZE(4);
		parms->access_information.out.access_flags = IVAL(blob->data, 0);
		return NT_STATUS_OK;

	case RAW_FILEINFO_POSITION_INFORMATION:
		FINFO_CHECK_SIZE(8);
		parms->position_information.out.position = BVAL(blob->data, 0);
		return NT_STATUS_OK;

	case RAW_FILEINFO_MODE_INFORMATION:
		FINFO_CHECK_SIZE(4);
		parms->mode_information.out.mode = IVAL(blob->data, 0);
		return NT_STATUS_OK;

	case RAW_FILEINFO_ALIGNMENT_INFORMATION:
		FINFO_CHECK_SIZE(4);
		parms->alignment_information.out.alignment_requirement 
			= IVAL(blob->data, 0);
		return NT_STATUS_OK;

	case RAW_FILEINFO_COMPRESSION_INFORMATION:
		FINFO_CHECK_SIZE(16);
		parms->compression_info.out.compressed_size = BVAL(blob->data,  0);
		parms->compression_info.out.format          = SVAL(blob->data,  8);
		parms->compression_info.out.unit_shift      = CVAL(blob->data, 10);
		parms->compression_info.out.chunk_shift     = CVAL(blob->data, 11);
		parms->compression_info.out.cluster_shift   = CVAL(blob->data, 12);
		/* 3 bytes of padding */
		return NT_STATUS_OK;

	case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:		
		FINFO_CHECK_SIZE(56);
		parms->network_open_information.out.create_time = smbcli_pull_nttime(blob->data,  0);
		parms->network_open_information.out.access_time = smbcli_pull_nttime(blob->data,  8);
		parms->network_open_information.out.write_time =  smbcli_pull_nttime(blob->data, 16);
		parms->network_open_information.out.change_time = smbcli_pull_nttime(blob->data, 24);
		parms->network_open_information.out.alloc_size =             BVAL(blob->data, 32);
		parms->network_open_information.out.size = 	             BVAL(blob->data, 40);
		parms->network_open_information.out.attrib = 	             IVAL(blob->data, 48);
		return NT_STATUS_OK;

	case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
		FINFO_CHECK_SIZE(8);
		parms->attribute_tag_information.out.attrib =      IVAL(blob->data, 0);
		parms->attribute_tag_information.out.reparse_tag = IVAL(blob->data, 4);
		return NT_STATUS_OK;

	case RAW_FILEINFO_NORMALIZED_NAME_INFORMATION:
		FINFO_CHECK_MIN_SIZE(4);
		smbcli_blob_pull_string(NULL, mem_ctx, blob,
					&parms->normalized_name_info.out.fname,
					0, 4, STR_UNICODE);
		return NT_STATUS_OK;

	case RAW_FILEINFO_SMB2_ALL_EAS:
		FINFO_CHECK_MIN_SIZE(4);
		return ea_pull_list_chained(blob, mem_ctx, 
					    &parms->all_eas.out.num_eas,
					    &parms->all_eas.out.eas);

	case RAW_FILEINFO_SMB2_ALL_INFORMATION:
		FINFO_CHECK_MIN_SIZE(0x64);
		parms->all_info2.out.create_time    = smbcli_pull_nttime(blob->data, 0x00);
		parms->all_info2.out.access_time    = smbcli_pull_nttime(blob->data, 0x08);
		parms->all_info2.out.write_time     = smbcli_pull_nttime(blob->data, 0x10);
		parms->all_info2.out.change_time    = smbcli_pull_nttime(blob->data, 0x18);
		parms->all_info2.out.attrib         = IVAL(blob->data, 0x20);
		parms->all_info2.out.unknown1       = IVAL(blob->data, 0x24);
		parms->all_info2.out.alloc_size     = BVAL(blob->data, 0x28);
		parms->all_info2.out.size           = BVAL(blob->data, 0x30);
		parms->all_info2.out.nlink          = IVAL(blob->data, 0x38);
		parms->all_info2.out.delete_pending = CVAL(blob->data, 0x3C);
		parms->all_info2.out.directory      = CVAL(blob->data, 0x3D);
		/* 0x3E-0x3F padding */
		parms->all_info2.out.file_id        = BVAL(blob->data, 0x40);
		parms->all_info2.out.ea_size        = IVAL(blob->data, 0x48);
		parms->all_info2.out.access_mask    = IVAL(blob->data, 0x4C);
		parms->all_info2.out.position       = BVAL(blob->data, 0x50);
		parms->all_info2.out.mode           = IVAL(blob->data, 0x58);
		parms->all_info2.out.alignment_requirement = IVAL(blob->data, 0x5C);
		smbcli_blob_pull_string(NULL, mem_ctx, blob,
					&parms->all_info2.out.fname, 0x60, 0x64, STR_UNICODE);
		return NT_STATUS_OK;

	case RAW_FILEINFO_SEC_DESC: {
		enum ndr_err_code ndr_err;

		parms->query_secdesc.out.sd = talloc(mem_ctx, struct security_descriptor);
		NT_STATUS_HAVE_NO_MEMORY(parms->query_secdesc.out.sd);

		ndr_err = ndr_pull_struct_blob(blob, mem_ctx,
			parms->query_secdesc.out.sd,
			(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
			return ndr_map_error2ntstatus(ndr_err);
		}

		return NT_STATUS_OK;
	}

	default:
		break;
	}

	return NT_STATUS_INVALID_LEVEL;
}


/****************************************************************************
 Handle qfileinfo/qpathinfo trans2 backend.
****************************************************************************/
static NTSTATUS smb_raw_info_backend(struct smbcli_session *session,
				     TALLOC_CTX *mem_ctx,
				     union smb_fileinfo *parms, 
				     DATA_BLOB *blob)
{	
	switch (parms->generic.level) {
	case RAW_FILEINFO_GENERIC:
	case RAW_FILEINFO_GETATTR:
	case RAW_FILEINFO_GETATTRE:
	case RAW_FILEINFO_SEC_DESC:
		/* not handled here */
		return NT_STATUS_INVALID_LEVEL;

	case RAW_FILEINFO_STANDARD:
		FINFO_CHECK_SIZE(22);
		parms->standard.out.create_time = raw_pull_dos_date2(session->transport,
								     blob->data +  0);
		parms->standard.out.access_time = raw_pull_dos_date2(session->transport,
								     blob->data +  4);
		parms->standard.out.write_time =  raw_pull_dos_date2(session->transport,
								     blob->data +  8);
		parms->standard.out.size =        IVAL(blob->data,             12);
		parms->standard.out.alloc_size =  IVAL(blob->data,             16);
		parms->standard.out.attrib =      SVAL(blob->data,             20);
		return NT_STATUS_OK;

	case RAW_FILEINFO_EA_SIZE:
		FINFO_CHECK_SIZE(26);
		parms->ea_size.out.create_time = raw_pull_dos_date2(session->transport,
								    blob->data +  0);
		parms->ea_size.out.access_time = raw_pull_dos_date2(session->transport,
								    blob->data +  4);
		parms->ea_size.out.write_time =  raw_pull_dos_date2(session->transport,
								    blob->data +  8);
		parms->ea_size.out.size =        IVAL(blob->data,             12);
		parms->ea_size.out.alloc_size =  IVAL(blob->data,             16);
		parms->ea_size.out.attrib =      SVAL(blob->data,             20);
		parms->ea_size.out.ea_size =     IVAL(blob->data,             22);
		return NT_STATUS_OK;

	case RAW_FILEINFO_EA_LIST:
		FINFO_CHECK_MIN_SIZE(4);
		return ea_pull_list(blob, mem_ctx, 
				    &parms->ea_list.out.num_eas,
				    &parms->ea_list.out.eas);

	case RAW_FILEINFO_ALL_EAS:
		FINFO_CHECK_MIN_SIZE(4);
		return ea_pull_list(blob, mem_ctx, 
				    &parms->all_eas.out.num_eas,
				    &parms->all_eas.out.eas);

	case RAW_FILEINFO_IS_NAME_VALID:
		/* no data! */
		FINFO_CHECK_SIZE(0);
		return NT_STATUS_OK;

	case RAW_FILEINFO_BASIC_INFO:
	case RAW_FILEINFO_BASIC_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_BASIC_INFORMATION, parms);

	case RAW_FILEINFO_STANDARD_INFO:
	case RAW_FILEINFO_STANDARD_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_STANDARD_INFORMATION, parms);

	case RAW_FILEINFO_EA_INFO:
	case RAW_FILEINFO_EA_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_EA_INFORMATION, parms);

	case RAW_FILEINFO_NAME_INFO:
	case RAW_FILEINFO_NAME_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_NAME_INFORMATION, parms);

	case RAW_FILEINFO_ALL_INFO:
	case RAW_FILEINFO_ALL_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_ALL_INFORMATION, parms);

	case RAW_FILEINFO_ALT_NAME_INFO:
	case RAW_FILEINFO_ALT_NAME_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_ALT_NAME_INFORMATION, parms);

	case RAW_FILEINFO_STREAM_INFO:
	case RAW_FILEINFO_STREAM_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_STREAM_INFORMATION, parms);

	case RAW_FILEINFO_INTERNAL_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_INTERNAL_INFORMATION, parms);

	case RAW_FILEINFO_ACCESS_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_ACCESS_INFORMATION, parms);

	case RAW_FILEINFO_POSITION_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_POSITION_INFORMATION, parms);

	case RAW_FILEINFO_MODE_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_MODE_INFORMATION, parms);

	case RAW_FILEINFO_ALIGNMENT_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_ALIGNMENT_INFORMATION, parms);

	case RAW_FILEINFO_COMPRESSION_INFO:
	case RAW_FILEINFO_COMPRESSION_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_COMPRESSION_INFORMATION, parms);

	case RAW_FILEINFO_UNIX_BASIC:
		FINFO_CHECK_SIZE(100);
		parms->unix_basic_info.out.end_of_file        =            BVAL(blob->data,  0);
		parms->unix_basic_info.out.num_bytes          =            BVAL(blob->data,  8);
		parms->unix_basic_info.out.status_change_time = smbcli_pull_nttime(blob->data, 16);
		parms->unix_basic_info.out.access_time        = smbcli_pull_nttime(blob->data, 24);
		parms->unix_basic_info.out.change_time        = smbcli_pull_nttime(blob->data, 32);
		parms->unix_basic_info.out.uid                =            BVAL(blob->data, 40);
		parms->unix_basic_info.out.gid                =            BVAL(blob->data, 48);
		parms->unix_basic_info.out.file_type          =            IVAL(blob->data, 52);
		parms->unix_basic_info.out.dev_major          =            BVAL(blob->data, 60);
		parms->unix_basic_info.out.dev_minor          =            BVAL(blob->data, 68);
		parms->unix_basic_info.out.unique_id          =            BVAL(blob->data, 76);
		parms->unix_basic_info.out.permissions        =            BVAL(blob->data, 84);
		parms->unix_basic_info.out.nlink              =            BVAL(blob->data, 92);
		return NT_STATUS_OK;

	case RAW_FILEINFO_UNIX_INFO2:
		FINFO_CHECK_SIZE(116);
		parms->unix_info2.out.end_of_file	= BVAL(blob->data,  0);
		parms->unix_info2.out.num_bytes		= BVAL(blob->data,  8);
		parms->unix_info2.out.status_change_time = smbcli_pull_nttime(blob->data, 16);
		parms->unix_info2.out.access_time	= smbcli_pull_nttime(blob->data, 24);
		parms->unix_info2.out.change_time	= smbcli_pull_nttime(blob->data, 32);
		parms->unix_info2.out.uid		= BVAL(blob->data, 40);
		parms->unix_info2.out.gid		= BVAL(blob->data, 48);
		parms->unix_info2.out.file_type		= IVAL(blob->data, 52);
		parms->unix_info2.out.dev_major		= BVAL(blob->data, 60);
		parms->unix_info2.out.dev_minor		= BVAL(blob->data, 68);
		parms->unix_info2.out.unique_id		= BVAL(blob->data, 76);
		parms->unix_info2.out.permissions	= BVAL(blob->data, 84);
		parms->unix_info2.out.nlink		= BVAL(blob->data, 92);
		parms->unix_info2.out.create_time	= smbcli_pull_nttime(blob->data, 100);
		parms->unix_info2.out.file_flags	= IVAL(blob->data, 108);
		parms->unix_info2.out.flags_mask	= IVAL(blob->data, 112);
		return NT_STATUS_OK;

	case RAW_FILEINFO_UNIX_LINK:
		smbcli_blob_pull_string(session, mem_ctx, blob, 
				     &parms->unix_link_info.out.link_dest, 0, 4, STR_UNICODE);
		return NT_STATUS_OK;
		
	case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:		
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_NETWORK_OPEN_INFORMATION, parms);

	case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION, parms);

	case RAW_FILEINFO_NORMALIZED_NAME_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
						       RAW_FILEINFO_NORMALIZED_NAME_INFORMATION, parms);

	case RAW_FILEINFO_SMB2_ALL_INFORMATION:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_SMB2_ALL_INFORMATION, parms);

	case RAW_FILEINFO_SMB2_ALL_EAS:
		return smb_raw_fileinfo_passthru_parse(blob, mem_ctx, 
						       RAW_FILEINFO_SMB2_ALL_EAS, parms);

	}

	return NT_STATUS_INVALID_LEVEL;
}


/****************************************************************************
 Very raw query file info - returns param/data blobs - (async send)
****************************************************************************/
static struct smbcli_request *smb_raw_fileinfo_blob_send(struct smbcli_tree *tree,
							 uint16_t fnum, 
							 uint16_t info_level,
							 DATA_BLOB data)
{
	struct smb_trans2 tp;
	uint16_t setup = TRANSACT2_QFILEINFO;
	struct smbcli_request *req;
	TALLOC_CTX *mem_ctx = talloc_init("raw_fileinfo");
	
	tp.in.max_setup = 0;
	tp.in.flags = 0; 
	tp.in.timeout = 0;
	tp.in.setup_count = 1;
	tp.in.data = data;
	tp.in.max_param = 2;
	tp.in.max_data = 0xFFFF;
	tp.in.setup = &setup;
	
	tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
	if (!tp.in.params.data) {
		talloc_free(mem_ctx);
		return NULL;
	}

	SSVAL(tp.in.params.data, 0, fnum);
	SSVAL(tp.in.params.data, 2, info_level);

	req = smb_raw_trans2_send(tree, &tp);

	talloc_free(mem_ctx);

	return req;
}


/****************************************************************************
 Very raw query file info - returns param/data blobs - (async recv)
****************************************************************************/
static NTSTATUS smb_raw_fileinfo_blob_recv(struct smbcli_request *req,
					   TALLOC_CTX *mem_ctx,
					   DATA_BLOB *blob)
{
	struct smb_trans2 tp;
	NTSTATUS status = smb_raw_trans2_recv(req, mem_ctx, &tp);
	if (NT_STATUS_IS_OK(status)) {
		*blob = tp.out.data;
	}
	return status;
}

/****************************************************************************
 Very raw query path info - returns param/data blobs (async send)
****************************************************************************/
static struct smbcli_request *smb_raw_pathinfo_blob_send(struct smbcli_tree *tree,
							 const char *fname,
							 uint16_t info_level,
							 DATA_BLOB data)
{
	struct smb_trans2 tp;
	uint16_t setup = TRANSACT2_QPATHINFO;
	struct smbcli_request *req;
	TALLOC_CTX *mem_ctx = talloc_init("raw_pathinfo");

	tp.in.max_setup = 0;
	tp.in.flags = 0; 
	tp.in.timeout = 0;
	tp.in.setup_count = 1;
	tp.in.data = data;
	tp.in.max_param = 2;
	tp.in.max_data = 0xFFFF;
	tp.in.setup = &setup;
	
	tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
	if (!tp.in.params.data) {
		talloc_free(mem_ctx);
		return NULL;
	}

	SSVAL(tp.in.params.data, 0, info_level);
	SIVAL(tp.in.params.data, 2, 0);
	smbcli_blob_append_string(tree->session, mem_ctx, &tp.in.params,
			       fname, STR_TERMINATE);
	
	req = smb_raw_trans2_send(tree, &tp);

	talloc_free(mem_ctx);

	return req;
}

/****************************************************************************
 send a SMBgetatr (async send)
****************************************************************************/
static struct smbcli_request *smb_raw_getattr_send(struct smbcli_tree *tree,
						union smb_fileinfo *parms)
{
	struct smbcli_request *req;
	
	req = smbcli_request_setup(tree, SMBgetatr, 0, 0);
	if (!req) return NULL;

	smbcli_req_append_ascii4(req, parms->getattr.in.file.path, STR_TERMINATE);
	
	if (!smbcli_request_send(req)) {
		smbcli_request_destroy(req);
		return NULL;
	}

	return req;
}

/****************************************************************************
 send a SMBgetatr (async recv)
****************************************************************************/
static NTSTATUS smb_raw_getattr_recv(struct smbcli_request *req,
				     union smb_fileinfo *parms)
{
	if (!smbcli_request_receive(req) ||
	    smbcli_request_is_error(req)) {
		return smbcli_request_destroy(req);
	}

	SMBCLI_CHECK_WCT(req, 10);
	parms->getattr.out.attrib =     SVAL(req->in.vwv, VWV(0));
	parms->getattr.out.write_time = raw_pull_dos_date3(req->transport,
							   req->in.vwv + VWV(1));
	parms->getattr.out.size =       IVAL(req->in.vwv, VWV(3));

failed:
	return smbcli_request_destroy(req);
}


/****************************************************************************
 Handle SMBgetattrE (async send)
****************************************************************************/
static struct smbcli_request *smb_raw_getattrE_send(struct smbcli_tree *tree,
						 union smb_fileinfo *parms)
{
	struct smbcli_request *req;
	
	req = smbcli_request_setup(tree, SMBgetattrE, 1, 0);
	if (!req) return NULL;
	
	SSVAL(req->out.vwv, VWV(0), parms->getattre.in.file.fnum);
	if (!smbcli_request_send(req)) {
		smbcli_request_destroy(req);
		return NULL;
	}

	return req;
}

/****************************************************************************
 Handle SMBgetattrE (async send)
****************************************************************************/
static NTSTATUS smb_raw_getattrE_recv(struct smbcli_request *req,
				      union smb_fileinfo *parms)
{
	if (!smbcli_request_receive(req) ||
	    smbcli_request_is_error(req)) {
		return smbcli_request_destroy(req);
	}
	
	SMBCLI_CHECK_WCT(req, 11);
	parms->getattre.out.create_time =   raw_pull_dos_date2(req->transport,
							       req->in.vwv + VWV(0));
	parms->getattre.out.access_time =   raw_pull_dos_date2(req->transport,
							       req->in.vwv + VWV(2));
	parms->getattre.out.write_time  =   raw_pull_dos_date2(req->transport,
							       req->in.vwv + VWV(4));
	parms->getattre.out.size =          IVAL(req->in.vwv,             VWV(6));
	parms->getattre.out.alloc_size =    IVAL(req->in.vwv,             VWV(8));
	parms->getattre.out.attrib =        SVAL(req->in.vwv,             VWV(10));

failed:
	return smbcli_request_destroy(req);
}


/****************************************************************************
 Query file info (async send)
****************************************************************************/
struct smbcli_request *smb_raw_fileinfo_send(struct smbcli_tree *tree,
					     union smb_fileinfo *parms)
{
	DATA_BLOB data;
	struct smbcli_request *req;

	/* pass off the non-trans2 level to specialised functions */
	if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
		return smb_raw_getattrE_send(tree, parms);
	}
	if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
		return smb_raw_query_secdesc_send(tree, parms);
	}
	if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
		return NULL;
	}

	data = data_blob(NULL, 0);

	if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
		if (!ea_push_name_list(tree, 
				       &data,
				       parms->ea_list.in.num_names,
				       parms->ea_list.in.ea_names)) {
			return NULL;
		}
	}

	req = smb_raw_fileinfo_blob_send(tree, 
					 parms->generic.in.file.fnum,
					 parms->generic.level, data);

	data_blob_free(&data);

	return req;
}

/****************************************************************************
 Query file info (async recv)
****************************************************************************/
NTSTATUS smb_raw_fileinfo_recv(struct smbcli_request *req,
			       TALLOC_CTX *mem_ctx,
			       union smb_fileinfo *parms)
{
	DATA_BLOB blob;
	NTSTATUS status;
	struct smbcli_session *session = req?req->session:NULL;

	if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
		return smb_raw_getattrE_recv(req, parms);
	}
	if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
		return smb_raw_query_secdesc_recv(req, mem_ctx, parms);
	}
	if (parms->generic.level == RAW_FILEINFO_GETATTR) {
		return smb_raw_getattr_recv(req, parms);
	}

	status = smb_raw_fileinfo_blob_recv(req, mem_ctx, &blob);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	return smb_raw_info_backend(session, mem_ctx, parms, &blob);
}

/****************************************************************************
 Query file info (sync interface)
****************************************************************************/
_PUBLIC_ NTSTATUS smb_raw_fileinfo(struct smbcli_tree *tree,
			  TALLOC_CTX *mem_ctx,
			  union smb_fileinfo *parms)
{
	struct smbcli_request *req = smb_raw_fileinfo_send(tree, parms);
	return smb_raw_fileinfo_recv(req, mem_ctx, parms);
}

/****************************************************************************
 Query path info (async send)
****************************************************************************/
_PUBLIC_ struct smbcli_request *smb_raw_pathinfo_send(struct smbcli_tree *tree,
					     union smb_fileinfo *parms)
{
	DATA_BLOB data;
	struct smbcli_request *req;

	if (parms->generic.level == RAW_FILEINFO_GETATTR) {
		return smb_raw_getattr_send(tree, parms);
	}
	if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
		return NULL;
	}
	
	data = data_blob(NULL, 0);

	if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
		if (!ea_push_name_list(tree, 
				       &data,
				       parms->ea_list.in.num_names,
				       parms->ea_list.in.ea_names)) {
			return NULL;
		}
	}

	req = smb_raw_pathinfo_blob_send(tree, parms->generic.in.file.path,
					 parms->generic.level, data);
	data_blob_free(&data);

	return req;
}

/****************************************************************************
 Query path info (async recv)
****************************************************************************/
_PUBLIC_ NTSTATUS smb_raw_pathinfo_recv(struct smbcli_request *req,
			       TALLOC_CTX *mem_ctx,
			       union smb_fileinfo *parms)
{
	/* recv is idential to fileinfo */
	return smb_raw_fileinfo_recv(req, mem_ctx, parms);
}

/****************************************************************************
 Query path info (sync interface)
****************************************************************************/
_PUBLIC_ NTSTATUS smb_raw_pathinfo(struct smbcli_tree *tree,
			  TALLOC_CTX *mem_ctx,
			  union smb_fileinfo *parms)
{
	struct smbcli_request *req = smb_raw_pathinfo_send(tree, parms);
	return smb_raw_pathinfo_recv(req, mem_ctx, parms);
}
