/*
 * $Id: sock.c,v 1.2 2009/04/14 11:32:51 obarthel Exp $
 *
 * :ts=4
 *
 * sock.c
 *
 * Copyright (C) 1995 by Paal-Kr. Engstad and Volker Lendecke
 * Modified by Christian Starkjohann <cs -at- hal -dot- kph -dot- tuwien -dot- ac -dot- at>
 * Modified for use with AmigaOS by Olaf Barthel <obarthel -at- gmx -dot- net>
 */

#include "smbfs.h"

/*****************************************************************************/

#include <smb/smb_fs.h>
#include <smb/smb.h>
#include <smb/smbno.h>

/*****************************************************************************/

#include "smb_abstraction.h"

/*****************************************************************************/

/* The following is an attempt to decode the data that is received
 * and sent. Because so much of smbfs was created by reverse-engineering
 * the protocol it is difficult to say what works, and how.
 */

#if defined(DUMP_SMB)

/*****************************************************************************/

extern VOID VARARGS68K SPrintf(STRPTR buffer, STRPTR formatString,...);

/*****************************************************************************/

/* This can be used to enable or disable the SMB packet dump output. */
static int dump_smb_enabled;

/*****************************************************************************/

/* The command packets are identified by the command code, but the
 * contents are interpreted differently if the packets are sent by
 * the client ("From consumer") or by the server ("To consumer").
 */
enum smb_packet_source_t
{
	smb_packet_from_consumer,
	smb_packet_to_consumer
};

/*****************************************************************************/

/* Known SMB command codes. */
#define SMB_COM_CREATE_DIRECTORY 0x00
#define SMB_COM_DELETE_DIRECTORY 0x01
#define SMB_COM_OPEN 0x02
#define SMB_COM_CREATE 0x03
#define SMB_COM_CLOSE 0x04
#define SMB_COM_FLUSH 0x05
#define SMB_COM_DELETE 0x06
#define SMB_COM_RENAME 0x07
#define SMB_COM_QUERY_INFORMATION 0x08
#define SMB_COM_SET_INFORMATION 0x09
#define SMB_COM_READ 0x0A
#define SMB_COM_WRITE 0x0B
#define SMB_COM_LOCK_BYTE_RANGE 0x0C
#define SMB_COM_UNLOCK_BYTE_RANGE 0x0D
#define SMB_COM_CREATE_TEMPORARY 0x0E
#define SMB_COM_CREATE_NEW 0x0F
#define SMB_COM_CHECK_DIRECTORY 0x10
#define SMB_COM_PROCESS_EXIT 0x11
#define SMB_COM_SEEK 0x12
#define SMB_COM_LOCK_AND_READ 0x13
#define SMB_COM_WRITE_AND_UNLOCK 0x14
#define SMB_COM_READ_RAW 0x1A
#define SMB_COM_READ_MPX 0x1B
#define SMB_COM_READ_MPX_SECONDARY 0x1C
#define SMB_COM_WRITE_RAW 0x1D
#define SMB_COM_WRITE_MPX 0x1E
#define SMB_COM_WRITE_MPX_SECONDARY 0x1F
#define SMB_COM_WRITE_COMPLETE 0x20
#define SMB_COM_QUERY_SERVER 0x21
#define SMB_COM_SET_INFORMATION2 0x22
#define SMB_COM_QUERY_INFORMATION2 0x23
#define SMB_COM_LOCKING_ANDX 0x24
#define SMB_COM_TRANSACTION 0x25
#define SMB_COM_TRANSACTION_SECONDARY 0x26
#define SMB_COM_IOCTL 0x27
#define SMB_COM_IOCTL_SECONDARY 0x28
#define SMB_COM_COPY 0x29
#define SMB_COM_MOVE 0x2A
#define SMB_COM_ECHO 0x2B
#define SMB_COM_WRITE_AND_CLOSE 0x2C
#define SMB_COM_OPEN_ANDX 0x2D
#define SMB_COM_READ_ANDX 0x2E
#define SMB_COM_WRITE_ANDX 0x2F
#define SMB_COM_NEW_FILE_SIZE 0x30
#define SMB_COM_CLOSE_AND_TREE_DISC 0x31
#define SMB_COM_TRANSACTION2 0x32
#define SMB_COM_TRANSACTION2_SECONDARY 0x33
#define SMB_COM_FIND_CLOSE2 0x34
#define SMB_COM_FIND_NOTIFY_CLOSE 0x35
#define SMB_COM_TREE_CONNECT 0x70
#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_SECURITY_PACKAGE_ANDX 0x7E
#define SMB_COM_QUERY_INFORMATION_DISK 0x80
#define SMB_COM_SEARCH 0x81
#define SMB_COM_FIND 0x82
#define SMB_COM_FIND_UNIQUE 0x83
#define SMB_COM_FIND_CLOSE 0x84
#define SMB_COM_NT_TRANSACT 0xA0
#define SMB_COM_NT_TRANSACT_SECONDARY 0xA1
#define SMB_COM_NT_CREATE_ANDX 0xA2
#define SMB_COM_NT_CANCEL 0xA4
#define SMB_COM_NT_RENAME 0xA5
#define SMB_COM_OPEN_PRINT_FILE 0xC0
#define SMB_COM_WRITE_PRINT_FILE 0xC1
#define SMB_COM_CLOSE_PRINT_FILE 0xC2
#define SMB_COM_GET_PRINT_QUEUE 0xC3
#define SMB_COM_READ_BULK 0xD8
#define SMB_COM_WRITE_BULK 0xD9
#define SMB_COM_WRITE_BULK_DATA 0xDA
#define SMB_COM_INVALID 0xFE
#define SMB_COM_NO_ANDX_COMMAND 0xFF

/* SMB_COM_TRANSACTION2 subcommand codes. */
enum
{
	TRANS2_OPEN2=0x00,
	TRANS2_FIND_FIRST2=0x01,
	TRANS2_FIND_NEXT2=0x02,
	TRANS2_QUERY_FS_INFORMATION=0x03,
	TRANS2_QUERY_PATH_INFORMATION=0x05,
	TRANS2_SET_PATH_INFORMATION=0x06,
	TRANS2_QUERY_FILE_INFORMATION=0x07,
	TRANS2_SET_FILE_INFORMATION=0x08,
	TRANS2_FSCTL=0x09,
	TRANS2_IOCTL2=0x0A,
	TRANS2_FIND_NOTIFY_FIRST=0x0B,
	TRANS2_FIND_NOTIFY_NEXT=0x0C,
	TRANS2_CREATE_DIRECTORY=0x0D,
	TRANS2_SESSION_SETUP=0x0E
};

struct smb_header
{
	unsigned char signature[4];	// Contains 0xFF, 'SMB'	[BYTE smb_idf[4]]
	unsigned char command;		// Command code [BYTE smb_com]
	unsigned long status;		// Error code class [BYTE smb_rcls]
	unsigned char flags;		// Reserved [BYTE smb_reh]
	unsigned short flags2;		// Error code [BYTE smb_err]
	
	struct
	{
		unsigned short pid_high;
		unsigned short signature[4];
	} extra;
	
	unsigned short tid;			// Tree ID # [WORD smb_tid]
	unsigned short pid;			// Callers process id [WORD smb_pid]
	unsigned short uid;			// User ID [WORD smb_uid]
	unsigned short mid;			// Multiplex ID [WORD smb_mid]

	int num_parameter_words;	// Count of parameter words [BYTE smb_wct]
	unsigned char * parameters;	// Variable number of parameter words [SHORT smb_wvw[..]]

	int num_data_bytes;			// Number of data bytes following [WORD smb_bcc]
	unsigned char * data;		// Variable number of data bytes [BYTE smb_data[..]]
};

struct decode_context
{
	const unsigned char *	data;
	int						offset;
	int						length;
	int						overflow;
};

static void
init_decode_context(const unsigned char * data,int length,struct decode_context * dc)
{
	dc->data		= data;
	dc->offset		= 0;
	dc->length		= length;
	dc->overflow	= 0;
}

static void
skip_bytes(struct decode_context * dc,int count)
{
	if(dc->offset + count <= dc->length)
		dc->offset += count;
	else
		dc->overflow = 1;
}

static void
skip_words(struct decode_context * dc,int count)
{
	skip_bytes(dc,count * 2);
}

static const unsigned char *
next_bytes(struct decode_context * dc,int count)
{
	const unsigned char * result;
	
	result = &dc->data[dc->offset];

	if(dc->offset + count <= dc->length)
		dc->offset += count;
	else
		dc->overflow = 1;
		
	return(result);
}

static unsigned char
next_byte(struct decode_context * dc)
{
	unsigned char result;
	
	result = dc->data[dc->offset];

	if(dc->offset <= dc->length)
		dc->offset++;
	else
		dc->overflow = 1;
		
	return(result);
}

static const unsigned char *
next_words(struct decode_context * dc,int count)
{
	return(next_bytes(dc,count * 2));
}

static unsigned short
next_word(struct decode_context * dc)
{
	unsigned short result;
	
	result = dc->data[dc->offset] | (((unsigned short)dc->data[dc->offset+1]) << 8);

	if(dc->offset + 2 <= dc->length)
		dc->offset += 2;
	else
		dc->overflow = 1;
		
	return(result);
}

static unsigned long
next_dword(struct decode_context * dc)
{
	unsigned short result;
	
	result =
		dc->data[dc->offset] |
		(((unsigned long)dc->data[dc->offset+1]) << 8) |
		(((unsigned long)dc->data[dc->offset+2]) << 16) |
		(((unsigned long)dc->data[dc->offset+3]) << 24);

	if(dc->offset + 4 <= dc->length)
		dc->offset += 4;
	else
		dc->overflow = 1;
		
	return(result);
}

static int
fill_header(const unsigned char * packet,int length,struct smb_header * header)
{
	struct decode_context dc;
	int num_bytes_read;
	
	init_decode_context(packet,length,&dc);
	
	memset(header,0,sizeof(header));
	
	memcpy(header->signature,next_bytes(&dc,4),4);
	header->command = next_byte(&dc);
	header->status = next_dword(&dc);
	header->flags = next_byte(&dc);
	header->flags2 = next_word(&dc);
	header->extra.pid_high = next_word(&dc);
	memcpy(header->extra.signature,next_words(&dc,4),sizeof(unsigned short) * 4);
	skip_words(&dc,1);
	header->tid = next_word(&dc);
	header->pid = next_word(&dc);
	header->uid = next_word(&dc);
	header->mid = next_word(&dc);

	header->num_parameter_words = next_byte(&dc);
	header->parameters = (unsigned char *)next_words(&dc,header->num_parameter_words);

	header->num_data_bytes = next_word(&dc);
	header->data = (unsigned char *)next_bytes(&dc,header->num_data_bytes);

	num_bytes_read = dc.offset;

	return(num_bytes_read);
}

static int
is_smb_andx_command(unsigned char command)
{
	static const unsigned char andx_commands[9] =
	{
		SMB_COM_LOCKING_ANDX,
		SMB_COM_OPEN_ANDX,
		SMB_COM_READ_ANDX,
		SMB_COM_WRITE_ANDX,
		SMB_COM_SESSION_SETUP_ANDX,
		SMB_COM_LOGOFF_ANDX,
		SMB_COM_TREE_CONNECT_ANDX,
		SMB_COM_SECURITY_PACKAGE_ANDX,
		SMB_COM_NT_CREATE_ANDX
	};
	
	int result = 0;
	int i;
	
	for(i = 0 ; i < 9 ; i++)
	{
		if(command == andx_commands[i])
		{
			result = 1;
			break;
		}
	}
	
	return(result);
}

static const char *
get_smb_transaction2_subcommand_name(int command)
{
	static const struct { int code ; const char * name; } code_name_tab[] =
	{
		{ TRANS2_OPEN2, "TRANS2_OPEN2" },
		{ TRANS2_FIND_FIRST2, "TRANS2_FIND_FIRST2" },
		{ TRANS2_FIND_NEXT2, "TRANS2_FIND_NEXT2" },
		{ TRANS2_QUERY_FS_INFORMATION, "TRANS2_QUERY_FS_INFORMATION" },
		{ TRANS2_QUERY_PATH_INFORMATION, "TRANS2_QUERY_PATH_INFORMATION" },
		{ TRANS2_SET_PATH_INFORMATION, "TRANS2_SET_PATH_INFORMATION" },
		{ TRANS2_QUERY_FILE_INFORMATION, "TRANS2_QUERY_FILE_INFORMATION" },
		{ TRANS2_SET_FILE_INFORMATION, "TRANS2_SET_FILE_INFORMATION" },
		{ TRANS2_FSCTL, "TRANS2_FSCTL" },
		{ TRANS2_IOCTL2, "TRANS2_IOCTL2" },
		{ TRANS2_FIND_NOTIFY_FIRST, "TRANS2_FIND_NOTIFY_FIRST" },
		{ TRANS2_FIND_NOTIFY_NEXT, "TRANS2_FIND_NOTIFY_NEXT" },
		{ TRANS2_CREATE_DIRECTORY, "TRANS2_CREATE_DIRECTORY" },
		{ TRANS2_SESSION_SETUP, "TRANS2_SESSION_SETUP" },
		{ -1, NULL }
	};

	const char * result = NULL;
	int i;

	for(i = 0 ; code_name_tab[i].code != -1 ; i++)
	{
		if(command == code_name_tab[i].code)
		{
			result = code_name_tab[i].name;
			break;
		}
	}

	return(result);
}

static const char *
get_smb_command_name(unsigned char command)
{
	static const struct { int code; const char * name; } code_name_tab[] =
	{
		{ SMB_COM_CREATE_DIRECTORY, "CREATE_DIRECTORY" },
		{ SMB_COM_DELETE_DIRECTORY, "DELETE_DIRECTORY" },
		{ SMB_COM_OPEN, "OPEN" },
		{ SMB_COM_CREATE, "CREATE" },
		{ SMB_COM_CLOSE, "CLOSE" },
		{ SMB_COM_FLUSH, "FLUSH" },
		{ SMB_COM_DELETE, "DELETE" },
		{ SMB_COM_RENAME, "RENAME" },
		{ SMB_COM_QUERY_INFORMATION, "QUERY_INFORMATION" },
		{ SMB_COM_SET_INFORMATION, "SET_INFORMATION" },
		{ SMB_COM_READ, "READ" },
		{ SMB_COM_WRITE, "WRITE" },
		{ SMB_COM_LOCK_BYTE_RANGE, "LOCK_BYTE_RANGE" },
		{ SMB_COM_UNLOCK_BYTE_RANGE, "UNLOCK_BYTE_RANGE" },
		{ SMB_COM_CREATE_TEMPORARY, "CREATE_TEMPORARY" },
		{ SMB_COM_CREATE_NEW, "CREATE_NEW" },
		{ SMB_COM_CHECK_DIRECTORY, "CHECK_DIRECTORY" },
		{ SMB_COM_PROCESS_EXIT, "PROCESS_EXIT" },
		{ SMB_COM_SEEK, "SEEK" },
		{ SMB_COM_LOCK_AND_READ, "LOCK_AND_READ" },
		{ SMB_COM_WRITE_AND_UNLOCK, "WRITE_AND_UNLOCK" },
		{ SMB_COM_READ_RAW, "READ_RAW" },
		{ SMB_COM_READ_MPX, "READ_MPX" },
		{ SMB_COM_READ_MPX_SECONDARY, "READ_MPX_SECONDARY" },
		{ SMB_COM_WRITE_RAW, "WRITE_RAW" },
		{ SMB_COM_WRITE_MPX, "WRITE_MPX" },
		{ SMB_COM_WRITE_MPX_SECONDARY, "WRITE_MPX_SECONDARY" },
		{ SMB_COM_WRITE_COMPLETE, "WRITE_COMPLETE" },
		{ SMB_COM_QUERY_SERVER, "QUERY_SERVER" },
		{ SMB_COM_SET_INFORMATION2, "SET_INFORMATION2" },
		{ SMB_COM_QUERY_INFORMATION2, "QUERY_INFORMATION2" },
		{ SMB_COM_LOCKING_ANDX, "LOCKING_ANDX" },
		{ SMB_COM_TRANSACTION, "TRANSACTION" },
		{ SMB_COM_TRANSACTION_SECONDARY, "TRANSACTION_SECONDARY" },
		{ SMB_COM_IOCTL, "IOCTL" },
		{ SMB_COM_IOCTL_SECONDARY, "IOCTL_SECONDARY" },
		{ SMB_COM_COPY, "COPY" },
		{ SMB_COM_MOVE, "MOVE" },
		{ SMB_COM_ECHO, "ECHO" },
		{ SMB_COM_WRITE_AND_CLOSE, "WRITE_AND_CLOSE" },
		{ SMB_COM_OPEN_ANDX, "OPEN_ANDX" },
		{ SMB_COM_READ_ANDX, "READ_ANDX" },
		{ SMB_COM_WRITE_ANDX, "WRITE_ANDX" },
		{ SMB_COM_NEW_FILE_SIZE, "NEW_FILE_SIZE" },
		{ SMB_COM_CLOSE_AND_TREE_DISC, "CLOSE_AND_TREE_DISC" },
		{ SMB_COM_TRANSACTION2, "TRANSACTION2" },
		{ SMB_COM_TRANSACTION2_SECONDARY, "TRANSACTION2_SECONDARY" },
		{ SMB_COM_FIND_CLOSE2, "FIND_CLOSE2" },
		{ SMB_COM_FIND_NOTIFY_CLOSE, "FIND_NOTIFY_CLOSE" },
		{ SMB_COM_TREE_CONNECT, "TREE_CONNECT" },
		{ SMB_COM_TREE_DISCONNECT, "TREE_DISCONNECT" },
		{ SMB_COM_NEGOTIATE, "NEGOTIATE" },
		{ SMB_COM_SESSION_SETUP_ANDX, "SESSION_SETUP_ANDX" },
		{ SMB_COM_LOGOFF_ANDX, "LOGOFF_ANDX" },
		{ SMB_COM_TREE_CONNECT_ANDX, "TREE_CONNECT_ANDX" },
		{ SMB_COM_SECURITY_PACKAGE_ANDX, "SECURITY_PACKAGE_ANDX" },
		{ SMB_COM_QUERY_INFORMATION_DISK, "QUERY_INFORMATION_DISK" },
		{ SMB_COM_SEARCH, "SEARCH" },
		{ SMB_COM_FIND, "FIND" },
		{ SMB_COM_FIND_UNIQUE, "FIND_UNIQUE" },
		{ SMB_COM_FIND_CLOSE, "FIND_CLOSE" },
		{ SMB_COM_NT_TRANSACT, "NT_TRANSACT" },
		{ SMB_COM_NT_TRANSACT_SECONDARY, "NT_TRANSACT_SECONDARY" },
		{ SMB_COM_NT_CREATE_ANDX, "NT_CREATE_ANDX" },
		{ SMB_COM_NT_CANCEL, "NT_CANCEL" },
		{ SMB_COM_NT_RENAME, "NT_RENAME" },
		{ SMB_COM_OPEN_PRINT_FILE, "OPEN_PRINT_FILE" },
		{ SMB_COM_WRITE_PRINT_FILE, "WRITE_PRINT_FILE" },
		{ SMB_COM_CLOSE_PRINT_FILE, "CLOSE_PRINT_FILE" },
		{ SMB_COM_GET_PRINT_QUEUE, "GET_PRINT_QUEUE" },
		{ SMB_COM_READ_BULK, "READ_BULK" },
		{ SMB_COM_WRITE_BULK, "WRITE_BULK" },
		{ SMB_COM_WRITE_BULK_DATA, "WRITE_BULK_DATA" },
		{ SMB_COM_INVALID, "INVALID" },
		{ SMB_COM_NO_ANDX_COMMAND, "NO_ANDX_COMMAND" },
		{ -1, NULL }
	};
	
	const char * result = NULL;
	int i;
	
	for(i = 0 ; code_name_tab[i].code != -1 ; i++)
	{
		if(command == code_name_tab[i].code)
		{
			result = code_name_tab[i].name;
			break;
		}
	}
	
	return(result);
}

#define SMB_FLAGS_SERVER_TO_REDIR	0x80
#define SMB_FLAGS_REQUEST_BATCH_OPLOCK	0x40
#define SMB_FLAGS_REQUEST_OPLOCK	0x20
#define SMB_FLAGS_CANONICAL_PATHNAMES	0x10
#define SMB_FLAGS_CASELESS_PATHNAMES	0x08
#define SMB_FLAGS_CLIENT_BUF_AVAIL	0x02
#define SMB_FLAGS_SUPPORT_LOCKREAD	0x01

#define SMB_FLAGS2_UNICODE_STRINGS	0x8000
#define SMB_FLAGS2_32BIT_STATUS		0x4000
#define SMB_FLAGS2_READ_IF_EXECUTE	0x2000
#define SMB_FLAGS2_DFS_PATHNAME		0x1000
#define SMB_FLAGS2_EXTENDED_SECURITY	0x0800
#define SMB_FLAGS2_IS_LONG_NAME		0x0040
#define SMB_FLAGS2_SECURITY_SIGNATURE	0x0004
#define SMB_FLAGS2_EAS			0x0002
#define SMB_FLAGS2_KNOWS_LONG_NAMES	0x0001

struct line_buffer
{
	char line[512];
	size_t length;
};

static void
init_line_buffer(struct line_buffer *lb)
{
	lb->length = 0;
	lb->line[lb->length] = '\0';
}

static void
set_line_buffer(struct line_buffer *lb,int c,size_t len)
{
	if(len > sizeof(lb->line)-1)
		len = sizeof(lb->line)-1;

	memset(lb->line,c,len);

	lb->length = len;
	lb->line[lb->length] = '\0';
}

static void
copy_string_to_line_buffer(struct line_buffer *lb,const char *str,size_t len,size_t pos)
{
	if(pos+len > sizeof(lb->line)-1)
	{
		if(pos < sizeof(lb->line)-1)
			len = sizeof(lb->line)-1 - pos;
		else
			len = 0;
	}

	if(len > 0)
	{
		memmove(&lb->line[pos],str,len);

		if(lb->length < pos+len)
		{
			lb->length = pos+len;
			lb->line[lb->length] = '\0';
		}
	}
}

static void
add_lb_flag(struct line_buffer *lb,const char * str)
{
	size_t len = strlen(str);

	if(lb->length == 0)
	{
		if(lb->length + len < sizeof(lb->line)-1)
		{
			memcpy(&lb->line[lb->length],str,len);
			lb->length += len;

			lb->line[lb->length] = '\0';
		}
	}
	else
	{
		if(lb->length + 2 + len < sizeof(lb->line)-1)
		{
			memcpy(&lb->line[lb->length],", ",2);
			lb->length += 2;

			memcpy(&lb->line[lb->length],str,len);
			lb->length += len;

			lb->line[lb->length] = '\0';
		}
	}
}

static unsigned long next_data_dword(const unsigned char * data,int * offset_ptr)
{
	int offset = (*offset_ptr);
	unsigned long result;

	result =
		(((unsigned long)data[offset + 3]) << 24) |
		(((unsigned long)data[offset + 2]) << 16) |
		(((unsigned long)data[offset + 1]) <<  8) |
		  (unsigned long)data[offset + 0];

	(*offset_ptr) = offset + 4;

	return(result);
}


static unsigned short next_data_word(const unsigned char * data,int * offset_ptr)
{
	int offset = (*offset_ptr);
	unsigned short result;

	result =
		(((unsigned short)data[offset+1]) << 8) |
		  (unsigned short)data[offset+0];

	(*offset_ptr) = offset + 2;

	return(result);
}

static unsigned char next_data_byte(const unsigned char * data,int * offset_ptr)
{
	int offset = (*offset_ptr);
	unsigned char result;

	result = data[offset];

	(*offset_ptr) = offset + 1;

	return(result);
}

/* Commands tested in need of documentation:
 *
 * SMB_COM_CREATE_DIRECTORY (0x00)
 * SMB_COM_DELETE_DIRECTORY (0x01)
 * SMB_COM_DELETE (0x06)
 * SMB_COM_RENAME (0x07)
 * SMB_COM_SET_INFORMATION2 (0x22)
 * SMB_COM_QUERY_INFORMATION2 (0x23)
 * SMB_COM_LOCKING_ANDX (0x24)
 * SMB_COM_TREE_CONNECT (0x70)
 * SMB_COM_SEARCH (0x81)
 *
 * Incomplete:
 *
 * TRANSACTION2 (0x32)
 *
 * Mostly complete:
 *
 * OPEN (SMBopen, 0x02)
 * CREATE (SMBcreate, 0x03)
 * CLOSE (SMBclose, 0x04)
 * QUERY_INFORMATION (SMBgetatr, 0x08)
 * SET_INFORMATION (SMBsetatr, 0x09)
 * READ (SMBread, 0x0A)
 * WRITE (SMBwrite, 0x0B)
 * SEEK (SMBlseek, 0x12)
 * READ_RAW (0x1A)
 * TREE_CONNECT_ANDX (SMBtcon, 0x70)
 * NEGOTIATE (SMBnegprot, 0x72)
 * SESSION_SETUP_AND (0x73)
 * QUERY_INFORMATION_DISK (SMBdskattr, 0x80)
 */
static void
print_smb_contents(const struct smb_header * header,int command,enum smb_packet_source_t smb_packet_source,int num_parameter_words,const unsigned char * parameters,int num_data_bytes,const unsigned char * data)
{
	unsigned short vwv[256];
	int i,j;
	
	if(num_parameter_words > 255)
		num_parameter_words = 255;

	for(i = j = 0 ; i < num_parameter_words ; i++, j += 2)
		vwv[i] = (((int)parameters[j+1]) << 8) + parameters[j];

	if(command == SMB_COM_OPEN)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			char filename[256];
			int access_mode;
			int search_attribute;

			if(num_data_bytes > 255)
				num_data_bytes = 255;
			
			memmove(filename,data,num_data_bytes);
			filename[num_data_bytes] = '\0';
			
			access_mode = vwv[0];
			Printf("access mode = 0x%04lx\n",access_mode);

			switch(access_mode & 0x0007)
			{
				case 0:

					Printf("              Open for reading\n");
					break;

				case 1:

					Printf("              Open for writing\n");
					break;

				case 2:

					Printf("              Open for reading and writing\n");
					break;

				case 3:

					Printf("              Open for execution\n");
					break;

				default:

					break;
			}

			switch((access_mode & 0x0070) >> 4)
			{
				case 0:

					Printf("              Compatibility mode\n");
					break;

				case 1:

					Printf("              Deny read/write/execute others (exclusive use requested)\n");
					break;

				case 2:

					Printf("              Deny write to others\n");
					break;

				case 3:

					Printf("              Deny read/execute to others\n");
					break;

				case 4:

					Printf("              Deny nothing to others\n");
					break;

				default:

					break;
			}

			switch((access_mode & 0x0700) >> 8)
			{
				case 0:

					Printf("              Unknown locality of reference\n");
					break;

				case 1:

					Printf("              Mainly sequential access\n");
					break;

				case 2:

					Printf("              Mainly random access\n");
					break;

				case 3:

					Printf("              Random access with some locality\n");
					break;

				default:

					break;
			}

			if(access_mode & 0x1000)
				Printf("              Perform caching on file\n");
			else
				Printf("              Do not cache the file\n");

			if(access_mode & 0x4000)
				Printf("              No read ahead or write behind is allowed on this file or device\n");

			search_attribute = vwv[1];
			Printf("search attribute = 0x%04lx\n",search_attribute);

			if(search_attribute & 0x0100)
				Printf("                   SMB_SEARCH_ATTRIBUTE_READONLY\n");

			if(search_attribute & 0x0200)
				Printf("                   SMB_SEARCH_ATTRIBUTE_HIDDEN\n");

			if(search_attribute & 0x0400)
				Printf("                   SMB_SEARCH_ATTRIBUTE_SYSTEM\n");

			if(search_attribute & 0x1000)
				Printf("                   SMB_SEARCH_ATTRIBUTE_DIRECTORY\n");

			if(search_attribute & 0x2000)
				Printf("                   SMB_SEARCH_ATTRIBUTE_ARCHIVE\n");

			Printf("buffer format = %ld\n",filename[0]);
			Printf("file pathname = '%s'\n",filename+1);
		}
		else
		{
			int access_mode;
			int file_attributes;

			Printf("file handle = 0x%04lx\n",vwv[0]);

			file_attributes = vwv[1];
			Printf("file attributes = 0x%04lx\n",file_attributes);

			if((file_attributes & 0x001f) == 0)
				Printf("                  SMB_FILE_ATTRIBUTE_NORMAL\n");

			if(file_attributes & 0x0001)
				Printf("                  SMB_FILE_ATTRIBUTE_READ_ONLY\n");

			if(file_attributes & 0x0002)
				Printf("                  SMB_FILE_ATTRIBUTE_HIDDEN\n");

			if(file_attributes & 0x0004)
				Printf("                  SMB_FILE_ATTRIBUTE_SYSTEM\n");

			if(file_attributes & 0x0008)
				Printf("                  SMB_FILE_ATTRIBUTE_VOLUME\n");

			if(file_attributes & 0x0010)
				Printf("                  SMB_FILE_ATTRIBUTE_DIRECTORY\n");

			if(file_attributes & 0x0020)
				Printf("                  SMB_FILE_ATTRIBUTE_ARCHIVE\n");

			Printf("last modified = 0x%04lx%04lx\n",vwv[3],vwv[2]);
			Printf("file size = %ld\n",(((int)vwv[5]) << 16) + vwv[4]);

			access_mode = vwv[6];
			Printf("access mode = 0x%04lx\n",access_mode);

			switch(access_mode & 0x0007)
			{
				case 0:

					Printf("              Open for reading\n");
					break;

				case 1:

					Printf("              Open for writing\n");
					break;

				case 2:

					Printf("              Open for reading and writing\n");
					break;

				case 3:

					Printf("              Open for execution\n");
					break;

				default:

					break;
			}

			switch((access_mode & 0x0070) >> 4)
			{
				case 0:

					Printf("              Compatibility mode\n");
					break;

				case 1:

					Printf("              Deny read/write/execute others (exclusive use requested)\n");
					break;

				case 2:

					Printf("              Deny write to others\n");
					break;

				case 3:

					Printf("              Deny read/execute to others\n");
					break;

				case 4:

					Printf("              Deny nothing to others\n");
					break;

				default:

					break;
			}

			switch((access_mode & 0x0700) >> 8)
			{
				case 0:

					Printf("              Unknown locality of reference\n");
					break;

				case 1:

					Printf("              Mainly sequential access\n");
					break;

				case 2:

					Printf("              Mainly random access\n");
					break;

				case 3:

					Printf("              Random access with some locality\n");
					break;

				default:

					break;
			}

			if(access_mode & 0x1000)
				Printf("              Perform caching on file\n");
			else
				Printf("              Do not cache the file\n");

			if(access_mode & 0x4000)
				Printf("              No read ahead or write behind is allowed on this file or device\n");
		}
	}
	else if (command == SMB_COM_CREATE)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			char filename[256];
			int file_attributes;
			
			if(num_data_bytes > 255)
				num_data_bytes = 255;
			
			memmove(filename,data,num_data_bytes);
			filename[num_data_bytes] = '\0';
			
			file_attributes = vwv[0];
			Printf("file attributes = 0x%04lx\n",file_attributes);

			if((file_attributes & 0x001f) == 0)
				Printf("                  SMB_FILE_ATTRIBUTE_NORMAL\n");

			if(file_attributes & 0x0001)
				Printf("                  SMB_FILE_ATTRIBUTE_READ_ONLY\n");

			if(file_attributes & 0x0002)
				Printf("                  SMB_FILE_ATTRIBUTE_HIDDEN\n");

			if(file_attributes & 0x0004)
				Printf("                  SMB_FILE_ATTRIBUTE_SYSTEM\n");

			if(file_attributes & 0x0008)
				Printf("                  SMB_FILE_ATTRIBUTE_VOLUME\n");

			if(file_attributes & 0x0010)
				Printf("                  SMB_FILE_ATTRIBUTE_DIRECTORY\n");

			if(file_attributes & 0x0020)
				Printf("                  SMB_FILE_ATTRIBUTE_ARCHIVE\n");

			Printf("creation time = 0x%04l%04lx\n",vwv[2],vwv[1]);
			Printf("buffer format = %ld\n",filename[0]);
			Printf("file pathname = '%s'\n",filename+1);
		}
		else
		{
			Printf("file handle = 0x%04lx\n",vwv[0]);
		}
	}
	else if (command == SMB_COM_CLOSE)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			Printf("file handle = 0x%04lx\n",vwv[0]);
			Printf("last time modified = 0x%04lx%04lx\n",vwv[2],vwv[1]);
		}
	}
	else if (command == SMB_COM_QUERY_INFORMATION)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			char filename[256];
			
			if(num_data_bytes > 255)
				num_data_bytes = 255;
			
			memmove(filename,data,num_data_bytes);
			filename[num_data_bytes] = '\0';
			
			Printf("buffer format = 0x%02lx\n",filename[0]);
			Printf("file pathname = '%s'\n",filename+1);
		}
		else
		{
			int file_attributes;

			file_attributes = vwv[0];
			Printf("file attributes = 0x%04lx\n",file_attributes);

			if((file_attributes & 0x001f) == 0)
				Printf("                  SMB_FILE_ATTRIBUTE_NORMAL\n");

			if(file_attributes & 0x0001)
				Printf("                  SMB_FILE_ATTRIBUTE_READ_ONLY\n");

			if(file_attributes & 0x0002)
				Printf("                  SMB_FILE_ATTRIBUTE_HIDDEN\n");

			if(file_attributes & 0x0004)
				Printf("                  SMB_FILE_ATTRIBUTE_SYSTEM\n");

			if(file_attributes & 0x0008)
				Printf("                  SMB_FILE_ATTRIBUTE_VOLUME\n");

			if(file_attributes & 0x0010)
				Printf("                  SMB_FILE_ATTRIBUTE_DIRECTORY\n");

			if(file_attributes & 0x0020)
				Printf("                  SMB_FILE_ATTRIBUTE_ARCHIVE\n");

			Printf("last write time = 0x%04lx%04lx\n",vwv[2],vwv[1]);
			Printf("file size = %ld\n",(((int)vwv[4]) << 16) + vwv[3]);
		}
	}
	else if (command == SMB_COM_SET_INFORMATION)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			char filename[256];
			int file_attributes;
			
			if(num_data_bytes > 255)
				num_data_bytes = 255;
			
			memmove(filename,data,num_data_bytes);
			filename[num_data_bytes] = '\0';
			
			file_attributes = vwv[0];
			Printf("file attributes = 0x%04lx\n",file_attributes);

			if((file_attributes & 0x001f) == 0)
				Printf("                  SMB_FILE_ATTRIBUTE_NORMAL\n");

			if(file_attributes & 0x0001)
				Printf("                  SMB_FILE_ATTRIBUTE_READ_ONLY\n");

			if(file_attributes & 0x0002)
				Printf("                  SMB_FILE_ATTRIBUTE_HIDDEN\n");

			if(file_attributes & 0x0004)
				Printf("                  SMB_FILE_ATTRIBUTE_SYSTEM\n");

			if(file_attributes & 0x0008)
				Printf("                  SMB_FILE_ATTRIBUTE_VOLUME\n");

			if(file_attributes & 0x0010)
				Printf("                  SMB_FILE_ATTRIBUTE_DIRECTORY\n");

			if(file_attributes & 0x0020)
				Printf("                  SMB_FILE_ATTRIBUTE_ARCHIVE\n");

			Printf("creation time = 0x%04lx%04lx\n",vwv[2],vwv[1]);
			Printf("file pathname = '%s'\n",filename+1);
		}
	}
	else if (command == SMB_COM_READ)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			Printf("file handle = 0x%04lx\n",vwv[0]);
			Printf("count of bytes = %ld\n",vwv[1]);
			Printf("offset = %ld\n",(((int)vwv[3]) << 16) + vwv[2]);
			Printf("count left = %ld\n",vwv[4]);
		}
		else
		{
			Printf("count = %ld\n",vwv[0]);
		}
	}
	else if (command == SMB_COM_WRITE)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			Printf("file handle = 0x%04lx\n",vwv[0]);
			Printf("count of bytes = %ld\n",vwv[1]);
			Printf("offset = %ld\n",(((int)vwv[3]) << 16) + vwv[2]);
			Printf("count left = %ld\n",vwv[4]);
		}
		else
		{
			Printf("count = %ld\n",vwv[0]);
		}
	}
	else if (command == SMB_COM_SEEK)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			int mode;

			Printf("file handle = 0x%04lx\n",vwv[0]);

			mode = vwv[1];
			Printf("mode = 0x%04lx\n",mode);

			switch(mode)
			{
				case 1:

					Printf("              Seek from the start of the file\n");
					break;

				case 2:

					Printf("              Seek from the current position\n");
					break;

				case 3:

					Printf("              Seek from the end of the file\n");
					break;
			}

			Printf("offset = %ld\n",(long)((((unsigned long)vwv[3]) << 16) | vwv[2]));
		}
		else
		{
			Printf("absolute position = %lu\n",(((unsigned long)vwv[1]) << 16) | vwv[0]);
		}
	}
	else if (command == SMB_COM_READ_RAW)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			Printf("file handle = 0x%04lx\n",vwv[0]);
			Printf("offset = %lu\n",(((unsigned long)vwv[2]) << 16) | vwv[1]);
			Printf("maximum count of bytes to return = %ld\n",vwv[3]);
			Printf("minimum count of byte to return = %ld\n",vwv[4]);
			Printf("timeout = %ld\n",(((int)vwv[6]) << 16) + vwv[5]);

			if(num_parameter_words == 0x0A)
				Printf("offset high = %lu\n",(((unsigned long)vwv[9]) << 16) | vwv[8]);
		}
	}
	else if (command == SMB_COM_TRANSACTION2)
	{
		const unsigned short * setup_words;
		const char * subcommand_name;

		if(smb_packet_source == smb_packet_from_consumer)
		{
			Printf("total parameter count = %ld\n",vwv[0]);
			Printf("total data count = %ld\n",vwv[1]);
			Printf("max parameter count = %ld\n",vwv[2]);
			Printf("max data count = %ld\n",vwv[3]);
			Printf("max setup count = %ld\n",vwv[4] >> 8);
			Printf("flags = 0x%04lx\n",vwv[5]);
			Printf("timeout = %ld\n",(((int)vwv[7]) << 16) + vwv[6]);
			Printf("parameter count = %ld\n",vwv[9]);
			Printf("data offset = %ld\n",vwv[10]);
			Printf("setup count = %ld\n",vwv[11] >> 8);
			
			setup_words = &vwv[12];

			subcommand_name = get_smb_transaction2_subcommand_name(setup_words[0]);
			if(subcommand_name != NULL)
				Printf("subcommand = %s\n",subcommand_name);
			else
				Printf("subcommand = %ld\n",setup_words[0]);
		}
		else if (num_parameter_words > 0 || num_data_bytes > 0)
		{
			Printf("total parameter count = %ld\n",vwv[0]);
			Printf("total data count = %ld\n",vwv[1]);
			Printf("parameter count = %ld\n",vwv[3]);
			Printf("parameter offset = %ld\n",vwv[4]);
			Printf("parameter displacement = %ld\n",vwv[5]);
			Printf("data count = %ld\n",vwv[6]);
			Printf("data offset = %ld\n",vwv[7]);
			Printf("data displacement = %ld\n",vwv[8]);
			Printf("setup count = %ld\n",vwv[9] >> 8);

			setup_words = &vwv[10];

			subcommand_name = get_smb_transaction2_subcommand_name(setup_words[0]);
			if(subcommand_name != NULL)
				Printf("subcommand = %s\n",subcommand_name);
			else
				Printf("subcommand = %ld\n",setup_words[0]);
		}
	}
	else if (command == SMB_COM_TREE_CONNECT_ANDX)
	{
		char args[1024];

		if(num_data_bytes > 1023)
			num_data_bytes = 1023;
			
		memmove(args,data,num_data_bytes);
		args[num_data_bytes] = '\0';
			
		if(smb_packet_source == smb_packet_from_consumer)
		{
			const char * path;
			const char * password;
			const char * dev_name;
			int len;
			int flags;
			int password_length;

			flags = vwv[0];
			Printf("flags = 0x%04lx\n",flags);

			if(flags & 0x0001)
				Printf("        TREE_CONNECT_ANDX_DISCONNECT_TID\n");

			password_length = vwv[1];

			Printf("password length = %ld\n",password_length);

			password = args;
			len = password_length;
			
			/* There could be a padding byte here which
			 * aligns the account name to a word
			 * boundary.
			 */
			if((header->flags2 & SMB_FLAGS2_UNICODE_STRINGS) && (len % 2) == 1)
				len++;

			/* ZZZ could be a Unicode string. */
			path = &password[len];
			len = (int)strlen(path)+1;

			dev_name = &path[len];
			
			Printf("path = '%s'\n",path);
			// Printf("password = '%s'\n",password);
			Printf("dev name = '%s'\n",dev_name);
		}
		else
		{
			int len;
			const char * service;
			const char * native_file_system;

			service = args;
			len = strlen(service)+1;

			/* ZZZ this could be Unicode text. */
			native_file_system = &service[len];

			Printf("service = '%s'\n",service);
			Printf("native file system = '%s'\n",native_file_system);
		}
	}
	else if (command == SMB_COM_NEGOTIATE)
	{
		if(smb_packet_source == smb_packet_from_consumer)
		{
			char args[1024];
			const char * dialect;
			int dialect_index;
			int len;
			
			if(num_data_bytes > 1023)
				num_data_bytes = 1023;
			
			memmove(args,data,num_data_bytes);
			args[num_data_bytes] = '\0';
			
			dialect = args;
			dialect_index = 0;
			
			while(dialect < &args[num_data_bytes])
			{
				Printf("dialect[%ld] = '%s'\n",dialect_index++,&dialect[1]);
				
				len = strlen(&dialect[1]);
				
				dialect = &dialect[1+len+1];
			}
		}
		else
		{
			/* Assuming that the data returned is for
			 * the "NT LAN MANAGER" dialect.
			 */
			if(num_parameter_words == 0x11)
			{
				int offset = 0;
				int challenge_length;
				int security_mode;
				unsigned long capabilities;
				struct line_buffer lb;
				int unicode_char;
				int output_offset;

				Printf("dialect index = %ld\n",next_data_word(parameters,&offset));

				security_mode = next_data_byte(parameters,&offset);
				Printf("security mode = %ld\n",security_mode);

				if(security_mode & 0x01)
					Printf("                NEGOTIATE_USER_SECURITY\n");

				if(security_mode & 0x02)
					Printf("                NEGOTIATE_ENCRYPT_PASSWORDS\n");

				if(security_mode & 0x04)
					Printf("                NEGOTIATE_SECURITY_SIGNATURES_ENABLE\n");

				if(security_mode & 0x08)
					Printf("                NEGOTIATE_SECURITY_SIGNATURES_REQUIRED\n");

				if(security_mode & 0xF0)
					Printf("                Reserved = 0x%lx\n",security_mode >> 4);

				Printf("max mpx count = %ld\n",next_data_word(parameters,&offset));
				Printf("max number cvs = %ld\n",next_data_word(parameters,&offset));
				Printf("max buffer size = %ld\n",next_data_dword(parameters,&offset));
				Printf("max raw size = %ld\n",next_data_dword(parameters,&offset));
				Printf("session key = %ld\n",next_data_dword(parameters,&offset));

				capabilities = next_data_dword(parameters,&offset);
				Printf("capabilities = 0x%08lx\n",capabilities);

				if(capabilities & 0x00000001)
					Printf("               CAP_RAW_MODE\n");

				if(capabilities & 0x00000002)
					Printf("               CAP_MPX_MODE\n");

				if(capabilities & 0x00000004)
					Printf("               CAP_UNICODE\n");

				if(capabilities & 0x00000008)
					Printf("               CAP_LARGE_FILES\n");

				if(capabilities & 0x00000010)
					Printf("               CAP_NT_SMBS\n");

				if(capabilities & 0x00000020)
					Printf("               CAP_RPC_REMOTE_APIS\n");

				if(capabilities & 0x00000040)
					Printf("               CAP_STATUS32\n");

				if(capabilities & 0x00000080)
					Printf("               CAP_LEVEL_II_OPLOCKS\n");

				if(capabilities & 0x00000100)
					Printf("               CAP_LOCK_AND_READ\n");

				if(capabilities & 0x00000200)
					Printf("               CAP_NT_FIND\n");

				if(capabilities & 0x00000400)
					Printf("               CAP_BULK_TRANSFER\n");

				if(capabilities & 0x00000800)
					Printf("               CAP_COMPRESSED_DATA\n");

				if(capabilities & 0x00001000)
					Printf("               CAP_DFS\n");

				if(capabilities & 0x00002000)
					Printf("               CAP_QUADWORD_ALIGNED\n");

				if(capabilities & 0x00004000)
					Printf("               CAP_LARGE_READX\n");

				Printf("system time = 0x%08lx%08lx\n",next_data_dword(parameters,&offset),next_data_dword(parameters,&offset));
				Printf("server time zone = %ld\n",next_data_word(parameters,&offset));

				challenge_length = next_data_byte(parameters,&offset);
				Printf("challenge length = %ld\n",challenge_length);

				if(challenge_length > 0)
				{
					if(challenge_length == 8)
					{
						Printf("challenge = %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx\n",
							data[0],data[1],data[2],data[3],
							data[4],data[5],data[6],data[7]);
					}
				}

				init_line_buffer(&lb);

				offset = challenge_length;
				output_offset = 0;

				while(offset < num_data_bytes)
				{
					unicode_char = next_data_word(data,&offset);
					if(unicode_char == 0)
						break;

					if(' ' <= unicode_char && unicode_char < 127)
					{
						char c = unicode_char;

						copy_string_to_line_buffer(&lb,&c,1,output_offset);
						output_offset++;
					}
					else
					{
						char code_string[40];

						SPrintf(code_string,"<%02lx%02ld>",unicode_char >> 8,unicode_char & 0xff);

						copy_string_to_line_buffer(&lb,code_string,strlen(code_string),output_offset);
						output_offset += strlen(code_string);
					}
				}
				
				Printf("Domain name = '%s'\n",lb.line);
			}
			else
			{
				Printf("dialect index = %ld\n",vwv[0]);
			}
		}
	}
	else if (command == SMB_COM_SESSION_SETUP_ANDX)
	{
		char args[1024];
		char * args_end;
		int len;
		const char * oem_password = "";
		const char * unicode_password = "";
		const char * account_name = "";
		const char * primary_domain = "";
		const char * native_os = "";
		const char * native_lan_man = "";
		
		if(num_data_bytes > 1023)
			num_data_bytes = 1023;
		
		memmove(args,data,num_data_bytes);
		args[num_data_bytes] = '\0';

		args_end = &args[num_data_bytes];

		if(smb_packet_source == smb_packet_from_consumer)
		{
			int oem_password_length;
			int unicode_password_length;
			unsigned long capabilities;

			Printf("consumer's maximum buffer size = %ld\n",vwv[0]);
			Printf("actual maximum multiplexed pending requests = %ld\n",vwv[1]);
			Printf("vc number = %ld\n",vwv[2]);
			Printf("session key = 0x%04lx%04lx\n",vwv[4],vwv[3]);

			oem_password_length = vwv[5];
			Printf("oem password length = %ld\n",oem_password_length);

			unicode_password_length = vwv[6];
			Printf("unicode password length = %ld\n",unicode_password_length);

			capabilities = (((unsigned long)vwv[10]) << 16) + vwv[9];

			Printf("capabilities = 0x%08lx\n",capabilities);
			
			if(capabilities & 0x00000001)
				Printf("               CAP_RAW_MODE\n");

			if(capabilities & 0x00000002)
				Printf("               CAP_MPX_MODE\n");

			if(capabilities & 0x00000004)
				Printf("               CAP_UNICODE\n");

			if(capabilities & 0x00000008)
				Printf("               CAP_LARGE_FILES\n");

			if(capabilities & 0x00000010)
				Printf("               CAP_NT_SMBS\n");

			if(capabilities & 0x00000020)
				Printf("               CAP_RPC_REMOTE_APIS\n");

			if(capabilities & 0x00000040)
				Printf("               CAP_STATUS32\n");

			if(capabilities & 0x00000080)
				Printf("               CAP_LEVEL_II_OPLOCKS\n");

			if(capabilities & 0x00000100)
				Printf("               CAP_LOCK_AND_READ\n");

			if(capabilities & 0x00000200)
				Printf("               CAP_NT_FIND\n");

			if(capabilities & 0x00000400)
				Printf("               CAP_BULK_TRANSFER\n");

			if(capabilities & 0x00000800)
				Printf("               CAP_COMPRESSED_DATA\n");

			if(capabilities & 0x00001000)
				Printf("               CAP_DFS\n");

			if(capabilities & 0x00002000)
				Printf("               CAP_QUADWORD_ALIGNED\n");

			if(capabilities & 0x00004000)
				Printf("               CAP_LARGE_READX\n");

			if(num_data_bytes > 0)
			{
				oem_password = args;
				
				len = oem_password_length;
				
				unicode_password = &oem_password[len];
				if(unicode_password < args_end)
				{
					len = unicode_password_length;

					/* There could be a padding byte here which
					 * aligns the account name to a word
					 * boundary.
					 */
					if((header->flags2 & SMB_FLAGS2_UNICODE_STRINGS) && (len % 2) == 1)
						len++;

					account_name = &unicode_password[len];
					if(account_name < args_end)
					{
						len = strlen(account_name);
						
						/* ZZZ could be Unicode if SMB_FLAGS2_UNICODE_STRINGS is set. */
						primary_domain = &account_name[len+1];
						if(primary_domain < args_end)
						{
							len = strlen(primary_domain);
						
							/* ZZZ could be Unicode if SMB_FLAGS2_UNICODE_STRINGS is set. */
							native_os = &primary_domain[len+1];
							if(native_os < args_end)
							{
								len = strlen(native_os);
						
								/* ZZZ could be Unicode if SMB_FLAGS2_UNICODE_STRINGS is set. */
								native_lan_man = &native_os[len+1];
							}
						}
					}
				}
			}
			
			Printf("account name = '%s'\n",account_name);
			Printf("primary domain = '%s'\n",primary_domain);
			Printf("native os = '%s'\n",native_os);
			Printf("native lan man = '%s'\n",native_lan_man);
		}
		else
		{
			int request_mode;

			request_mode = vwv[0];
			Printf("request mode = 0x%04lx\n",request_mode);

			if(request_mode & 0x0001)
				Printf("               SMB_SETUP_GUEST\n");

			if(request_mode & 0x0002)
				Printf("               SMB_SETUP_USE_LANMAN_KEY\n");

			if(num_data_bytes > 0)
			{
				/* ZZZ could be Unicode if SMB_FLAGS2_UNICODE_STRINGS is set. */
				native_os = args;
				
				len = strlen(native_os);
				
				/* ZZZ could be Unicode if SMB_FLAGS2_UNICODE_STRINGS is set. */
				native_lan_man = &native_os[len+1];
				if(native_lan_man < args_end)
				{
					len = strlen(native_lan_man);

					/* ZZZ could be Unicode if SMB_FLAGS2_UNICODE_STRINGS is set. */
					primary_domain = &native_lan_man[len+1];
				}
			}
			
			Printf("native os = '%s'\n",native_os);
			Printf("native lan man = '%s'\n",native_lan_man);
			Printf("primary domain = '%s'\n",primary_domain);
		}
	}
	else if (command == SMB_COM_QUERY_INFORMATION_DISK)
	{
		if(smb_packet_source == smb_packet_to_consumer)
		{
			Printf("allocation units/server = %ld\n",vwv[0]);
			Printf("blocks/allocation unit = %ld\n",vwv[1]);
			Printf("block size (in bytes) = %ld\n",vwv[2]);
			Printf("free allocation units = %ld\n",vwv[3]);
		}
	}
}

static void
print_smb_data(struct line_buffer * lb,int num_data_bytes_left,const unsigned char * data_bytes)
{
	if(num_data_bytes_left > 0)
	{
		int row_offset = 0;
		char format_buffer[20];
		char dword_buffer[20];
		int num_bytes_per_row,dword_pos;
		size_t dword_buffer_len;
		unsigned char c;
		int c_pos;

		while(num_data_bytes_left > 0)
		{
			/* The output line should be filled with blank spaces. */
			set_line_buffer(lb,' ',60);

			/* Print the row offset (in bytes) at the start of the
			 * output line.
			 */
			SPrintf(format_buffer,"%04lx:",row_offset);

			copy_string_to_line_buffer(lb,format_buffer,5,0);

			/* Print up to 16 bytes per row. */
			if(num_data_bytes_left > 16)
				num_bytes_per_row = 16;
			else
				num_bytes_per_row = num_data_bytes_left;

			dword_pos = 6;
			dword_buffer[0] = '\0';
			dword_buffer_len = 0;
			c_pos = 45;

			/* Print the bytes in hex format, followed by a column
			 * of the same data bytes interpreted as printable
			 * characters.
			 */
			while(num_bytes_per_row > 0)
			{
				c = (*data_bytes++);
				num_bytes_per_row--;
				row_offset++;
				num_data_bytes_left--;

				/* Convert this data byte to hexadecimal
				 * representation.
				 */
				SPrintf(format_buffer,"%02lx",c);

				strcat(dword_buffer,format_buffer);
				dword_buffer_len += 2;

				/* Is this not a printable character? If so,
				 * substitute it with '.'.
				 */
				if(c < ' ' || c == 127 || (128 <= c && c <= 160))
					c = '.';

				copy_string_to_line_buffer(lb,(char *)&c,1,c_pos);
				c_pos++;

				/* If we have converted four bytes to hexadecimal
				 * format, put them into the output buffer.
				 */
				if(dword_buffer_len >= 8)
				{
					copy_string_to_line_buffer(lb,dword_buffer,8,dword_pos);
					dword_pos += 9;

					dword_buffer[0] = '\0';
					dword_buffer_len = 0;
				}
			}

			/* If we did not convert a multiple of 32 bytes per row,
			 * add the last conversion buffer contents.
			 */
			if(dword_buffer_len > 0)
				copy_string_to_line_buffer(lb,dword_buffer,dword_buffer_len,dword_pos);

			Printf("             %s\n",lb->line);
		}
	}
}

static void
print_smb_parameters(int num_parameter_words,const unsigned char *parameters)
{
	if(num_parameter_words > 0)
	{
		int word_value;
		int i,j;

		for(i = j = 0 ; i < num_parameter_words ; i++, j++)
		{
			word_value = parameters[j] + (((int)parameters[j+1]) << 8);

			Printf("                  %04lx: %04lx (bytes: %02lx%02lx)\n",i,word_value,parameters[j],parameters[j+1]);
		}
	}
}

static void
print_smb_header(const struct smb_header * header,int header_length,const unsigned char *packet,int packet_size,enum smb_packet_source_t smb_packet_source,int max_buffer_size)
{
	enum errdos_t
	{
		errdos_badfunc=1,
		errdos_badfile=2,
		errdos_badpath=3,
		errdos_nofids=4,
		errdos_noaccess=5,
		errdos_badfid=6,
		errdos_badmcb=7,
		errdos_nomem=8,
		errdos_badmem=9,
		errdos_badenv=10,
		errdos_badformat=11,
		errdos_badaccess=12,
		errdos_baddata=13,
		errdos_baddrive=15,
		errdos_remcd=16,
		errdos_diffdevice=17,
		errdos_nofiles=18,
		errdos_badshare=32,
		errdos_lock=33,
		errdos_filexists=80,
		errdos_quota=512,
		errdos_notALink=513,
	};

	enum errsrv_t
	{
		errsrv_error=1,
		errsrv_badpw=2,
		errsrv_access=4,
		errsrv_invtid=5,
		errsrv_invnetname=6,
		errsrv_invdevice=7,
		errsrv_qfull=49,
		errsrv_qtoobig=50,
		errsrv_qeof=51,
		errsrv_invpfid=52,
		errsrv_smbcmd=64,
		errsrv_srverror=65,
		errsrv_badBID=66,
		errsrv_filespecs=67,
		errsrv_badLink=68,
		errsrv_badpermits=69,
		errsrv_badPID=70,
		errsrv_setattrmode=71,
		errsrv_paused=81,
		errsrv_msgoff=82,
		errsrv_noroom=83,
		errsrv_rmuns=87,
		errsrv_timeout=88,
		errsrv_noresource=89,
		errsrv_toomanyuids=90,
		errsrv_baduid=91,
		errsrv_usempx=250,
		errsrv_usestd=251,
		errsrv_contmpx=252,
		errsrv_badPassword=254,
		errsrv_notifyEnumDir=1024,
		errsrv_accountExpired=2239,
		errsrv_badClient=2240,
		errsrv_badLogonTime=2241,
		errsrv_passwordExpired=2242,
		errsrv_nosupport=65535,
	};

	enum errhrd_t
	{
		errhrd_nowrite=19,
		errhrd_badunit=20,
		errhrd_notready=21,
		errhrd_badcmd=22,
		errhrd_data=23,
		errhrd_badreq=24,
		errhrd_seek=25,
		errhrd_badmedia=26,
		errhrd_badsector=27,
		errhrd_nopaper=28,
		errhrd_write=29,
		errhrd_read=30,
		errhrd_general=31,
		errhrd_badshare=32,
		errhrd_lock=33,
		errhrd_wrongdisk=34,
		errhrd_FCBUnavail=35,
		errhrd_sharebufexc=36,
	};

	enum nt_status_t
	{
		nt_status_unsuccessful=1,
		nt_status_not_implemented=2,
		nt_status_invalid_info_class=3,
		nt_status_info_length_mismatch=4,
		nt_status_access_violation=5,
		nt_status_in_page_error=6,
		nt_status_pagefile_quota=7,
		nt_status_invalid_handle=8,
		nt_status_bad_initial_stack=9,
		nt_status_bad_initial_pc=10,
		nt_status_invalid_cid=11,
		nt_status_timer_not_canceled=12,
		nt_status_invalid_parameter=13,
		nt_status_no_such_device=14,
		nt_status_no_such_file=15,
		nt_status_invalid_device_request=16,
		nt_status_end_of_file=17,
		nt_status_wrong_volume=18,
		nt_status_no_media_in_device=19,
		nt_status_unrecognized_media=20,
		nt_status_nonexistent_sector=21,
		nt_status_more_processing_required=22,
		nt_status_no_memory=23,
		nt_status_conflicting_addresses=24,
		nt_status_not_mapped_view=25,
		nt_status_unable_to_free_vm=26,
		nt_status_unable_to_delete_section=27,
		nt_status_invalid_system_service=28,
		nt_status_illegal_instruction=29,
		nt_status_invalid_lock_sequence=30,
		nt_status_invalid_view_size=31,
		nt_status_invalid_file_for_section=32,
		nt_status_already_committed=33,
		nt_status_access_denied=34,
		nt_status_buffer_too_small=35,
		nt_status_object_type_mismatch=36,
		nt_status_noncontinuable_exception=37,
		nt_status_invalid_disposition=38,
		nt_status_unwind=39,
		nt_status_bad_stack=40,
		nt_status_invalid_unwind_target=41,
		nt_status_not_locked=42,
		nt_status_parity_error=43,
		nt_status_unable_to_decommit_vm=44,
		nt_status_not_committed=45,
		nt_status_invalid_port_attributes=46,
		nt_status_port_message_too_long=47,
		nt_status_invalid_parameter_mix=48,
		nt_status_invalid_quota_lower=49,
		nt_status_disk_corrupt_error=50,
		nt_status_object_name_invalid=51,
		nt_status_object_name_not_found=52,
		nt_status_object_name_collision=53,
		nt_status_handle_not_waitable=54,
		nt_status_port_disconnected=55,
		nt_status_device_already_attached=56,
		nt_status_object_path_invalid=57,
		nt_status_object_path_not_found=58,
		nt_status_object_path_syntax_bad=59,
		nt_status_data_overrun=60,
		nt_status_data_late_error=61,
		nt_status_data_error=62,
		nt_status_crc_error=63,
		nt_status_section_too_big=64,
		nt_status_port_connection_refused=65,
		nt_status_invalid_port_handle=66,
		nt_status_sharing_violation=67,
		nt_status_quota_exceeded=68,
		nt_status_invalid_page_protection=69,
		nt_status_mutant_not_owned=70,
		nt_status_semaphore_limit_exceeded=71,
		nt_status_port_already_set=72,
		nt_status_section_not_image=73,
		nt_status_suspend_count_exceeded=74,
		nt_status_thread_is_terminating=75,
		nt_status_bad_working_set_limit=76,
		nt_status_incompatible_file_map=77,
		nt_status_section_protection=78,
		nt_status_eas_not_supported=79,
		nt_status_ea_too_large=80,
		nt_status_nonexistent_ea_entry=81,
		nt_status_no_eas_on_file=82,
		nt_status_ea_corrupt_error=83,
		nt_status_file_lock_conflict=84,
		nt_status_lock_not_granted=85,
		nt_status_delete_pending=86,
		nt_status_ctl_file_not_supported=87,
		nt_status_unknown_revision=88,
		nt_status_revision_mismatch=89,
		nt_status_invalid_owner=90,
		nt_status_invalid_primary_group=91,
		nt_status_no_impersonation_token=92,
		nt_status_cant_disable_mandatory=93,
		nt_status_no_logon_servers=94,
		nt_status_no_such_logon_session=95,
		nt_status_no_such_privilege=96,
		nt_status_privilege_not_held=97,
		nt_status_invalid_account_name=98,
		nt_status_user_exists=99,
		nt_status_no_such_user=100,
		nt_status_group_exists=101,
		nt_status_no_such_group=102,
		nt_status_member_in_group=103,
		nt_status_member_not_in_group=104,
		nt_status_last_admin=105,
		nt_status_wrong_password=106,
		nt_status_ill_formed_password=107,
		nt_status_password_restriction=108,
		nt_status_logon_failure=109,
		nt_status_account_restriction=110,
		nt_status_invalid_logon_hours=111,
		nt_status_invalid_workstation=112,
		nt_status_password_expired=113,
		nt_status_account_disabled=114,
		nt_status_none_mapped=115,
		nt_status_too_many_luids_requested=116,
		nt_status_luids_exhausted=117,
		nt_status_invalid_sub_authority=118,
		nt_status_invalid_acl=119,
		nt_status_invalid_sid=120,
		nt_status_invalid_security_descr=121,
		nt_status_procedure_not_found=122,
		nt_status_invalid_image_format=123,
		nt_status_no_token=124,
		nt_status_bad_inheritance_acl=125,
		nt_status_range_not_locked=126,
		nt_status_disk_full=127,
		nt_status_server_disabled=128,
		nt_status_server_not_disabled=129,
		nt_status_too_many_guids_requested=130,
		nt_status_guids_exhausted=131,
		nt_status_invalid_id_authority=132,
		nt_status_agents_exhausted=133,
		nt_status_invalid_volume_label=134,
		nt_status_section_not_extended=135,
		nt_status_not_mapped_data=136,
		nt_status_resource_data_not_found=137,
		nt_status_resource_type_not_found=138,
		nt_status_resource_name_not_found=139,
		nt_status_array_bounds_exceeded=140,
		nt_status_float_denormal_operand=141,
		nt_status_float_divide_by_zero=142,
		nt_status_float_inexact_result=143,
		nt_status_float_invalid_operation=144,
		nt_status_float_overflow=145,
		nt_status_float_stack_check=146,
		nt_status_float_underflow=147,
		nt_status_integer_divide_by_zero=148,
		nt_status_integer_overflow=149,
		nt_status_privileged_instruction=150,
		nt_status_too_many_paging_files=151,
		nt_status_file_invalid=152,
		nt_status_allotted_space_exceeded=153,
		nt_status_insufficient_resources=154,
		nt_status_dfs_exit_path_found=155,
		nt_status_device_data_error=156,
		nt_status_device_not_connected=157,
		nt_status_device_power_failure=158,
		nt_status_free_vm_not_at_base=159,
		nt_status_memory_not_allocated=160,
		nt_status_working_set_quota=161,
		nt_status_media_write_protected=162,
		nt_status_device_not_ready=163,
		nt_status_invalid_group_attributes=164,
		nt_status_bad_impersonation_level=165,
		nt_status_cant_open_anonymous=166,
		nt_status_bad_validation_class=167,
		nt_status_bad_token_type=168,
		nt_status_bad_master_boot_record=169,
		nt_status_instruction_misalignment=170,
		nt_status_instance_not_available=171,
		nt_status_pipe_not_available=172,
		nt_status_invalid_pipe_state=173,
		nt_status_pipe_busy=174,
		nt_status_illegal_function=175,
		nt_status_pipe_disconnected=176,
		nt_status_pipe_closing=177,
		nt_status_pipe_connected=178,
		nt_status_pipe_listening=179,
		nt_status_invalid_read_mode=180,
		nt_status_io_timeout=181,
		nt_status_file_forced_closed=182,
		nt_status_profiling_not_started=183,
		nt_status_profiling_not_stopped=184,
		nt_status_could_not_interpret=185,
		nt_status_file_is_a_directory=186,
		nt_status_not_supported=187,
		nt_status_remote_not_listening=188,
		nt_status_duplicate_name=189,
		nt_status_bad_network_path=190,
		nt_status_network_busy=191,
		nt_status_device_does_not_exist=192,
		nt_status_too_many_commands=193,
		nt_status_adapter_hardware_error=194,
		nt_status_invalid_network_response=195,
		nt_status_unexpected_network_error=196,
		nt_status_bad_remote_adapter=197,
		nt_status_print_queue_full=198,
		nt_status_no_spool_space=199,
		nt_status_print_cancelled=200,
		nt_status_network_name_deleted=201,
		nt_status_network_access_denied=202,
		nt_status_bad_device_type=203,
		nt_status_bad_network_name=204,
		nt_status_too_many_names=205,
		nt_status_too_many_sessions=206,
		nt_status_sharing_paused=207,
		nt_status_request_not_accepted=208,
		nt_status_redirector_paused=209,
		nt_status_net_write_fault=210,
		nt_status_profiling_at_limit=211,
		nt_status_not_same_device=212,
		nt_status_file_renamed=213,
		nt_status_virtual_circuit_closed=214,
		nt_status_no_security_on_object=215,
		nt_status_cant_wait=216,
		nt_status_pipe_empty=217,
		nt_status_cant_access_domain_info=218,
		nt_status_cant_terminate_self=219,
		nt_status_invalid_server_state=220,
		nt_status_invalid_domain_state=221,
		nt_status_invalid_domain_role=222,
		nt_status_no_such_domain=223,
		nt_status_domain_exists=224,
		nt_status_domain_limit_exceeded=225,
		nt_status_oplock_not_granted=226,
		nt_status_invalid_oplock_protocol=227,
		nt_status_internal_db_corruption=228,
		nt_status_internal_error=229,
		nt_status_generic_not_mapped=230,
		nt_status_bad_descriptor_format=231,
		nt_status_invalid_user_buffer=232,
		nt_status_unexpected_io_error=233,
		nt_status_unexpected_mm_create_err=234,
		nt_status_unexpected_mm_map_error=235,
		nt_status_unexpected_mm_extend_err=236,
		nt_status_not_logon_process=237,
		nt_status_logon_session_exists=238,
		nt_status_invalid_parameter_1=239,
		nt_status_invalid_parameter_2=240,
		nt_status_invalid_parameter_3=241,
		nt_status_invalid_parameter_4=242,
		nt_status_invalid_parameter_5=243,
		nt_status_invalid_parameter_6=244,
		nt_status_invalid_parameter_7=245,
		nt_status_invalid_parameter_8=246,
		nt_status_invalid_parameter_9=247,
		nt_status_invalid_parameter_10=248,
		nt_status_invalid_parameter_11=249,
		nt_status_invalid_parameter_12=250,
		nt_status_redirector_not_started=251,
		nt_status_redirector_started=252,
		nt_status_stack_overflow=253,
		nt_status_no_such_package=254,
		nt_status_bad_function_table=255,
		nt_status_directory_not_empty=257,
		nt_status_file_corrupt_error=258,
		nt_status_not_a_directory=259,
		nt_status_bad_logon_session_state=260,
		nt_status_logon_session_collision=261,
		nt_status_name_too_long=262,
		nt_status_files_open=263,
		nt_status_connection_in_use=264,
		nt_status_message_not_found=265,
		nt_status_process_is_terminating=266,
		nt_status_invalid_logon_type=267,
		nt_status_no_guid_translation=268,
		nt_status_cannot_impersonate=269,
		nt_status_image_already_loaded=270,
		nt_status_abios_not_present=271,
		nt_status_abios_lid_not_exist=272,
		nt_status_abios_lid_already_owned=273,
		nt_status_abios_not_lid_owner=274,
		nt_status_abios_invalid_command=275,
		nt_status_abios_invalid_lid=276,
		nt_status_abios_selector_not_available=277,
		nt_status_abios_invalid_selector=278,
		nt_status_no_ldt=279,
		nt_status_invalid_ldt_size=280,
		nt_status_invalid_ldt_offset=281,
		nt_status_invalid_ldt_descriptor=282,
		nt_status_invalid_image_ne_format=283,
		nt_status_rxact_invalid_state=284,
		nt_status_rxact_commit_failure=285,
		nt_status_mapped_file_size_zero=286,
		nt_status_too_many_opened_files=287,
		nt_status_cancelled=288,
		nt_status_cannot_delete=289,
		nt_status_invalid_computer_name=290,
		nt_status_file_deleted=291,
		nt_status_special_account=292,
		nt_status_special_group=293,
		nt_status_special_user=294,
		nt_status_members_primary_group=295,
		nt_status_file_closed=296,
		nt_status_too_many_threads=297,
		nt_status_thread_not_in_process=298,
		nt_status_token_already_in_use=299,
		nt_status_pagefile_quota_exceeded=300,
		nt_status_commitment_limit=301,
		nt_status_invalid_image_le_format=302,
		nt_status_invalid_image_not_mz=303,
		nt_status_invalid_image_protect=304,
		nt_status_invalid_image_win_16=305,
		nt_status_logon_server_conflict=306,
		nt_status_time_difference_at_dc=307,
		nt_status_synchronization_required=308,
		nt_status_dll_not_found=309,
		nt_status_open_failed=310,
		nt_status_io_privilege_failed=311,
		nt_status_ordinal_not_found=312,
		nt_status_entrypoint_not_found=313,
		nt_status_control_c_exit=314,
		nt_status_local_disconnect=315,
		nt_status_remote_disconnect=316,
		nt_status_remote_resources=317,
		nt_status_link_failed=318,
		nt_status_link_timeout=319,
		nt_status_invalid_connection=320,
		nt_status_invalid_address=321,
		nt_status_dll_init_failed=322,
		nt_status_missing_systemfile=323,
		nt_status_unhandled_exception=324,
		nt_status_app_init_failure=325,
		nt_status_pagefile_create_failed=326,
		nt_status_no_pagefile=327,
		nt_status_invalid_level=328,
		nt_status_wrong_password_core=329,
		nt_status_illegal_float_context=330,
		nt_status_pipe_broken=331,
		nt_status_registry_corrupt=332,
		nt_status_registry_io_failed=333,
		nt_status_no_event_pair=334,
		nt_status_unrecognized_volume=335,
		nt_status_serial_no_device_inited=336,
		nt_status_no_such_alias=337,
		nt_status_member_not_in_alias=338,
		nt_status_member_in_alias=339,
		nt_status_alias_exists=340,
		nt_status_logon_not_granted=341,
		nt_status_too_many_secrets=342,
		nt_status_secret_too_long=343,
		nt_status_internal_db_error=344,
		nt_status_fullscreen_mode=345,
		nt_status_too_many_context_ids=346,
		nt_status_logon_type_not_granted=347,
		nt_status_not_registry_file=348,
		nt_status_nt_cross_encryption_required=349,
		nt_status_domain_ctrlr_config_error=350,
		nt_status_ft_missing_member=351,
		nt_status_ill_formed_service_entry=352,
		nt_status_illegal_character=353,
		nt_status_unmappable_character=354,
		nt_status_undefined_character=355,
		nt_status_floppy_volume=356,
		nt_status_floppy_id_mark_not_found=357,
		nt_status_floppy_wrong_cylinder=358,
		nt_status_floppy_unknown_error=359,
		nt_status_floppy_bad_registers=360,
		nt_status_disk_recalibrate_failed=361,
		nt_status_disk_operation_failed=362,
		nt_status_disk_reset_failed=363,
		nt_status_shared_irq_busy=364,
		nt_status_ft_orphaning=365,
		nt_status_partition_failure=370,
		nt_status_invalid_block_length=371,
		nt_status_device_not_partitioned=372,
		nt_status_unable_to_lock_media=373,
		nt_status_unable_to_unload_media=374,
		nt_status_eom_overflow=375,
		nt_status_no_media=376,
		nt_status_no_such_member=378,
		nt_status_invalid_member=379,
		nt_status_key_deleted=380,
		nt_status_no_log_space=381,
		nt_status_too_many_sids=382,
		nt_status_lm_cross_encryption_required=383,
		nt_status_key_has_children=384,
		nt_status_child_must_be_volatile=385,
		nt_status_device_configuration_error=386,
		nt_status_driver_internal_error=387,
		nt_status_invalid_device_state=388,
		nt_status_io_device_error=389,
		nt_status_device_protocol_error=390,
		nt_status_backup_controller=391,
		nt_status_log_file_full=392,
		nt_status_too_late=393,
		nt_status_no_trust_lsa_secret=394,
		nt_status_no_trust_sam_account=395,
		nt_status_trusted_domain_failure=396,
		nt_status_trusted_relationship_failure=397,
		nt_status_eventlog_file_corrupt=398,
		nt_status_eventlog_cant_start=399,
		nt_status_trust_failure=400,
		nt_status_mutant_limit_exceeded=401,
		nt_status_netlogon_not_started=402,
		nt_status_account_expired=403,
		nt_status_possible_deadlock=404,
		nt_status_network_credential_conflict=405,
		nt_status_remote_session_limit=406,
		nt_status_eventlog_file_changed=407,
		nt_status_nologon_interdomain_trust_account=408,
		nt_status_nologon_workstation_trust_account=409,
		nt_status_nologon_server_trust_account=410,
		nt_status_domain_trust_inconsistent=411,
		nt_status_fs_driver_required=412,
		nt_status_no_user_session_key=514,
		nt_status_user_session_deleted=515,
		nt_status_resource_lang_not_found=516,
		nt_status_insuff_server_resources=517,
		nt_status_invalid_buffer_size=518,
		nt_status_invalid_address_component=519,
		nt_status_invalid_address_wildcard=520,
		nt_status_too_many_addresses=521,
		nt_status_address_already_exists=522,
		nt_status_address_closed=523,
		nt_status_connection_disconnected=524,
		nt_status_connection_reset=525,
		nt_status_too_many_nodes=526,
		nt_status_transaction_aborted=527,
		nt_status_transaction_timed_out=528,
		nt_status_transaction_no_release=529,
		nt_status_transaction_no_match=530,
		nt_status_transaction_responded=531,
		nt_status_transaction_invalid_id=532,
		nt_status_transaction_invalid_type=533,
		nt_status_not_server_session=534,
		nt_status_not_client_session=535,
		nt_status_cannot_load_registry_file=536,
		nt_status_debug_attach_failed=537,
		nt_status_system_process_terminated=538,
		nt_status_data_not_accepted=539,
		nt_status_no_browser_servers_found=540,
		nt_status_vdm_hard_error=541,
		nt_status_driver_cancel_timeout=542,
		nt_status_reply_message_mismatch=543,
		nt_status_mapped_alignment=544,
		nt_status_image_checksum_mismatch=545,
		nt_status_lost_writebehind_data=546,
		nt_status_client_server_parameters_invalid=547,
		nt_status_password_must_change=548,
		nt_status_not_found=549,
		nt_status_not_tiny_stream=550,
		nt_status_recovery_failure=551,
		nt_status_stack_overflow_read=552,
		nt_status_fail_check=553,
		nt_status_duplicate_objectid=554,
		nt_status_objectid_exists=555,
		nt_status_convert_to_large=556,
		nt_status_retry=557,
		nt_status_found_out_of_scope=558,
		nt_status_allocate_bucket=559,
		nt_status_propset_not_found=560,
		nt_status_marshall_overflow=561,
		nt_status_invalid_variant=562,
		nt_status_domain_controller_not_found=563,
		nt_status_account_locked_out=564,
		nt_status_handle_not_closable=565,
		nt_status_connection_refused=566,
		nt_status_graceful_disconnect=567,
		nt_status_address_already_associated=568,
		nt_status_address_not_associated=569,
		nt_status_connection_invalid=570,
		nt_status_connection_active=571,
		nt_status_network_unreachable=572,
		nt_status_host_unreachable=573,
		nt_status_protocol_unreachable=574,
		nt_status_port_unreachable=575,
		nt_status_request_aborted=576,
		nt_status_connection_aborted=577,
		nt_status_bad_compression_buffer=578,
		nt_status_user_mapped_file=579,
		nt_status_audit_failed=580,
		nt_status_timer_resolution_not_set=581,
		nt_status_connection_count_limit=582,
		nt_status_login_time_restriction=583,
		nt_status_login_wksta_restriction=584,
		nt_status_image_mp_up_mismatch=585,
		nt_status_insufficient_logon_info=592,
		nt_status_bad_dll_entrypoint=593,
		nt_status_bad_service_entrypoint=594,
		nt_status_lpc_reply_lost=595,
		nt_status_ip_address_conflict1=596,
		nt_status_ip_address_conflict2=597,
		nt_status_registry_quota_limit=598,
		nt_status_path_not_covered=599,
		nt_status_no_callback_active=600,
		nt_status_license_quota_exceeded=601,
		nt_status_pwd_too_short=602,
		nt_status_pwd_too_recent=603,
		nt_status_pwd_history_conflict=604,
		nt_status_plugplay_no_device=606,
		nt_status_unsupported_compression=607,
		nt_status_invalid_hw_profile=608,
		nt_status_invalid_plugplay_device_path=609,
		nt_status_driver_ordinal_not_found=610,
		nt_status_driver_entrypoint_not_found=611,
		nt_status_resource_not_owned=612,
		nt_status_too_many_links=613,
		nt_status_quota_list_inconsistent=614,
		nt_status_file_is_offline=615,
		// nt_status_notify_enum_dir=268,
	};

	struct error_label_entry
	{
		int code;
		const char * label;
	};

	static const struct error_label_entry dos_errors[] =
	{
		{ 0, "not specified" },
		{ errdos_badfunc, "badfunc" },
		{ errdos_badfile, "badfile" },
		{ errdos_badpath, "badpath" },
		{ errdos_nofids, "nofids" },
		{ errdos_noaccess, "noaccess" },
		{ errdos_badfid, "badfid" },
		{ errdos_badmcb, "badmcb" },
		{ errdos_nomem, "nomem" },
		{ errdos_badmem, "badmem" },
		{ errdos_badenv, "badenv" },
		{ errdos_badformat, "badformat" },
		{ errdos_badaccess, "badaccess" },
		{ errdos_baddata, "baddata" },
		{ errdos_baddrive, "baddrive" },
		{ errdos_remcd, "remcd" },
		{ errdos_diffdevice, "diffdevice" },
		{ errdos_nofiles, "nofiles" },
		{ errdos_badshare, "badshare" },
		{ errdos_lock, "lock" },
		{ errdos_filexists, "filexists" },
		{ errdos_quota, "quota" },
		{ errdos_notALink, "notALink" },
		{ -1, NULL }
	};

	static const struct error_label_entry server_errors[] =
	{
		{ 0, "not specified" },
		{ errsrv_error, "error" },
		{ errsrv_badpw, "badpw" },
		{ errsrv_access, "access" },
		{ errsrv_invtid, "invtid" },
		{ errsrv_invnetname, "invnetname" },
		{ errsrv_invdevice, "invdevice" },
		{ errsrv_qfull, "qfull" },
		{ errsrv_qtoobig, "qtoobig" },
		{ errsrv_qeof, "qeof" },
		{ errsrv_invpfid, "invpfid" },
		{ errsrv_smbcmd, "smbcmd" },
		{ errsrv_srverror, "srverror" },
		{ errsrv_badBID, "badBID" },
		{ errsrv_filespecs, "filespecs" },
		{ errsrv_badLink, "badLink" },
		{ errsrv_badpermits, "badpermits" },
		{ errsrv_badPID, "badPID" },
		{ errsrv_setattrmode, "setattrmode" },
		{ errsrv_paused, "paused" },
		{ errsrv_msgoff, "msgoff" },
		{ errsrv_noroom, "noroom" },
		{ errsrv_rmuns, "rmuns" },
		{ errsrv_timeout, "timeout" },
		{ errsrv_noresource, "noresource" },
		{ errsrv_toomanyuids, "toomanyuids" },
		{ errsrv_baduid, "baduid" },
		{ errsrv_usempx, "usempx" },
		{ errsrv_usestd, "usestd" },
		{ errsrv_contmpx, "contmpx" },
		{ errsrv_badPassword, "badPassword" },
		{ errsrv_notifyEnumDir, "notifyEnumDir" },
		{ errsrv_accountExpired, "accountExpired" },
		{ errsrv_badClient, "badClient" },
		{ errsrv_badLogonTime, "badLogonTime" },
		{ errsrv_passwordExpired, "passwordExpired" },
		{ errsrv_nosupport, "nosupport" },
		{ -1, NULL }
	};

	static const struct error_label_entry hardware_errors[] =
	{
		{ 0, "not specified" },
		{ errhrd_nowrite, "nowrite" },
		{ errhrd_badunit, "badunit" },
		{ errhrd_notready, "notready" },
		{ errhrd_badcmd, "badcmd" },
		{ errhrd_data, "data" },
		{ errhrd_badreq, "badreq" },
		{ errhrd_seek, "seek" },
		{ errhrd_badmedia, "badmedia" },
		{ errhrd_badsector, "badsector" },
		{ errhrd_nopaper, "nopaper" },
		{ errhrd_write, "write" },
		{ errhrd_read, "read" },
		{ errhrd_general, "general" },
		{ errhrd_badshare, "badshare" },
		{ errhrd_lock, "lock" },
		{ errhrd_wrongdisk, "wrongdisk" },
		{ errhrd_FCBUnavail, "FCBUnavail" },
		{ errhrd_sharebufexc, "sharebufexc" },
		{ -1, NULL }
	};

	static const struct error_label_entry nt_error_codes[] =
	{
		{ 0, "not specified" },
		{ nt_status_unsuccessful, "unsuccessful" },
		{ nt_status_not_implemented, "not_implemented" },
		{ nt_status_invalid_info_class, "invalid_info_class" },
		{ nt_status_info_length_mismatch, "info_length_mismatch" },
		{ nt_status_access_violation, "access_violation" },
		{ nt_status_in_page_error, "in_page_error" },
		{ nt_status_pagefile_quota, "pagefile_quota" },
		{ nt_status_invalid_handle, "invalid_handle" },
		{ nt_status_bad_initial_stack, "bad_initial_stack" },
		{ nt_status_bad_initial_pc, "bad_initial_pc" },
		{ nt_status_invalid_cid, "invalid_cid" },
		{ nt_status_timer_not_canceled, "timer_not_canceled" },
		{ nt_status_invalid_parameter, "invalid_parameter" },
		{ nt_status_no_such_device, "no_such_device" },
		{ nt_status_no_such_file, "no_such_file" },
		{ nt_status_invalid_device_request, "invalid_device_request" },
		{ nt_status_end_of_file, "end_of_file" },
		{ nt_status_wrong_volume, "wrong_volume" },
		{ nt_status_no_media_in_device, "no_media_in_device" },
		{ nt_status_unrecognized_media, "unrecognized_media" },
		{ nt_status_nonexistent_sector, "nonexistent_sector" },
		{ nt_status_more_processing_required, "more_processing_required" },
		{ nt_status_no_memory, "no_memory" },
		{ nt_status_conflicting_addresses, "conflicting_addresses" },
		{ nt_status_not_mapped_view, "not_mapped_view" },
		{ nt_status_unable_to_free_vm, "unable_to_free_vm" },
		{ nt_status_unable_to_delete_section, "unable_to_delete_section" },
		{ nt_status_invalid_system_service, "invalid_system_service" },
		{ nt_status_illegal_instruction, "illegal_instruction" },
		{ nt_status_invalid_lock_sequence, "invalid_lock_sequence" },
		{ nt_status_invalid_view_size, "invalid_view_size" },
		{ nt_status_invalid_file_for_section, "invalid_file_for_section" },
		{ nt_status_already_committed, "already_committed" },
		{ nt_status_access_denied, "access_denied" },
		{ nt_status_buffer_too_small, "buffer_too_small" },
		{ nt_status_object_type_mismatch, "object_type_mismatch" },
		{ nt_status_noncontinuable_exception, "noncontinuable_exception" },
		{ nt_status_invalid_disposition, "invalid_disposition" },
		{ nt_status_unwind, "unwind" },
		{ nt_status_bad_stack, "bad_stack" },
		{ nt_status_invalid_unwind_target, "invalid_unwind_target" },
		{ nt_status_not_locked, "not_locked" },
		{ nt_status_parity_error, "parity_error" },
		{ nt_status_unable_to_decommit_vm, "unable_to_decommit_vm" },
		{ nt_status_not_committed, "not_committed" },
		{ nt_status_invalid_port_attributes, "invalid_port_attributes" },
		{ nt_status_port_message_too_long, "port_message_too_long" },
		{ nt_status_invalid_parameter_mix, "invalid_parameter_mix" },
		{ nt_status_invalid_quota_lower, "invalid_quota_lower" },
		{ nt_status_disk_corrupt_error, "disk_corrupt_error" },
		{ nt_status_object_name_invalid, "object_name_invalid" },
		{ nt_status_object_name_not_found, "object_name_not_found" },
		{ nt_status_object_name_collision, "object_name_collision" },
		{ nt_status_handle_not_waitable, "handle_not_waitable" },
		{ nt_status_port_disconnected, "port_disconnected" },
		{ nt_status_device_already_attached, "device_already_attached" },
		{ nt_status_object_path_invalid, "object_path_invalid" },
		{ nt_status_object_path_not_found, "object_path_not_found" },
		{ nt_status_object_path_syntax_bad, "object_path_syntax_bad" },
		{ nt_status_data_overrun, "data_overrun" },
		{ nt_status_data_late_error, "data_late_error" },
		{ nt_status_data_error, "data_error" },
		{ nt_status_crc_error, "crc_error" },
		{ nt_status_section_too_big, "section_too_big" },
		{ nt_status_port_connection_refused, "port_connection_refused" },
		{ nt_status_invalid_port_handle, "invalid_port_handle" },
		{ nt_status_sharing_violation, "sharing_violation" },
		{ nt_status_quota_exceeded, "quota_exceeded" },
		{ nt_status_invalid_page_protection, "invalid_page_protection" },
		{ nt_status_mutant_not_owned, "mutant_not_owned" },
		{ nt_status_semaphore_limit_exceeded, "semaphore_limit_exceeded" },
		{ nt_status_port_already_set, "port_already_set" },
		{ nt_status_section_not_image, "section_not_image" },
		{ nt_status_suspend_count_exceeded, "suspend_count_exceeded" },
		{ nt_status_thread_is_terminating, "thread_is_terminating" },
		{ nt_status_bad_working_set_limit, "bad_working_set_limit" },
		{ nt_status_incompatible_file_map, "incompatible_file_map" },
		{ nt_status_section_protection, "section_protection" },
		{ nt_status_eas_not_supported, "eas_not_supported" },
		{ nt_status_ea_too_large, "ea_too_large" },
		{ nt_status_nonexistent_ea_entry, "nonexistent_ea_entry" },
		{ nt_status_no_eas_on_file, "no_eas_on_file" },
		{ nt_status_ea_corrupt_error, "ea_corrupt_error" },
		{ nt_status_file_lock_conflict, "file_lock_conflict" },
		{ nt_status_lock_not_granted, "lock_not_granted" },
		{ nt_status_delete_pending, "delete_pending" },
		{ nt_status_ctl_file_not_supported, "ctl_file_not_supported" },
		{ nt_status_unknown_revision, "unknown_revision" },
		{ nt_status_revision_mismatch, "revision_mismatch" },
		{ nt_status_invalid_owner, "invalid_owner" },
		{ nt_status_invalid_primary_group, "invalid_primary_group" },
		{ nt_status_no_impersonation_token, "no_impersonation_token" },
		{ nt_status_cant_disable_mandatory, "cant_disable_mandatory" },
		{ nt_status_no_logon_servers, "no_logon_servers" },
		{ nt_status_no_such_logon_session, "no_such_logon_session" },
		{ nt_status_no_such_privilege, "no_such_privilege" },
		{ nt_status_privilege_not_held, "privilege_not_held" },
		{ nt_status_invalid_account_name, "invalid_account_name" },
		{ nt_status_user_exists, "user_exists" },
		{ nt_status_no_such_user, "no_such_user" },
		{ nt_status_group_exists, "group_exists" },
		{ nt_status_no_such_group, "no_such_group" },
		{ nt_status_member_in_group, "member_in_group" },
		{ nt_status_member_not_in_group, "member_not_in_group" },
		{ nt_status_last_admin, "last_admin" },
		{ nt_status_wrong_password, "wrong_password" },
		{ nt_status_ill_formed_password, "ill_formed_password" },
		{ nt_status_password_restriction, "password_restriction" },
		{ nt_status_logon_failure, "logon_failure" },
		{ nt_status_account_restriction, "account_restriction" },
		{ nt_status_invalid_logon_hours, "invalid_logon_hours" },
		{ nt_status_invalid_workstation, "invalid_workstation" },
		{ nt_status_password_expired, "password_expired" },
		{ nt_status_account_disabled, "account_disabled" },
		{ nt_status_none_mapped, "none_mapped" },
		{ nt_status_too_many_luids_requested, "too_many_luids_requested" },
		{ nt_status_luids_exhausted, "luids_exhausted" },
		{ nt_status_invalid_sub_authority, "invalid_sub_authority" },
		{ nt_status_invalid_acl, "invalid_acl" },
		{ nt_status_invalid_sid, "invalid_sid" },
		{ nt_status_invalid_security_descr, "invalid_security_descr" },
		{ nt_status_procedure_not_found, "procedure_not_found" },
		{ nt_status_invalid_image_format, "invalid_image_format" },
		{ nt_status_no_token, "no_token" },
		{ nt_status_bad_inheritance_acl, "bad_inheritance_acl" },
		{ nt_status_range_not_locked, "range_not_locked" },
		{ nt_status_disk_full, "disk_full" },
		{ nt_status_server_disabled, "server_disabled" },
		{ nt_status_server_not_disabled, "server_not_disabled" },
		{ nt_status_too_many_guids_requested, "too_many_guids_requested" },
		{ nt_status_guids_exhausted, "guids_exhausted" },
		{ nt_status_invalid_id_authority, "invalid_id_authority" },
		{ nt_status_agents_exhausted, "agents_exhausted" },
		{ nt_status_invalid_volume_label, "invalid_volume_label" },
		{ nt_status_section_not_extended, "section_not_extended" },
		{ nt_status_not_mapped_data, "not_mapped_data" },
		{ nt_status_resource_data_not_found, "resource_data_not_found" },
		{ nt_status_resource_type_not_found, "resource_type_not_found" },
		{ nt_status_resource_name_not_found, "resource_name_not_found" },
		{ nt_status_array_bounds_exceeded, "array_bounds_exceeded" },
		{ nt_status_float_denormal_operand, "float_denormal_operand" },
		{ nt_status_float_divide_by_zero, "float_divide_by_zero" },
		{ nt_status_float_inexact_result, "float_inexact_result" },
		{ nt_status_float_invalid_operation, "float_invalid_operation" },
		{ nt_status_float_overflow, "float_overflow" },
		{ nt_status_float_stack_check, "float_stack_check" },
		{ nt_status_float_underflow, "float_underflow" },
		{ nt_status_integer_divide_by_zero, "integer_divide_by_zero" },
		{ nt_status_integer_overflow, "integer_overflow" },
		{ nt_status_privileged_instruction, "privileged_instruction" },
		{ nt_status_too_many_paging_files, "too_many_paging_files" },
		{ nt_status_file_invalid, "file_invalid" },
		{ nt_status_allotted_space_exceeded, "allotted_space_exceeded" },
		{ nt_status_insufficient_resources, "insufficient_resources" },
		{ nt_status_dfs_exit_path_found, "dfs_exit_path_found" },
		{ nt_status_device_data_error, "device_data_error" },
		{ nt_status_device_not_connected, "device_not_connected" },
		{ nt_status_device_power_failure, "device_power_failure" },
		{ nt_status_free_vm_not_at_base, "free_vm_not_at_base" },
		{ nt_status_memory_not_allocated, "memory_not_allocated" },
		{ nt_status_working_set_quota, "working_set_quota" },
		{ nt_status_media_write_protected, "media_write_protected" },
		{ nt_status_device_not_ready, "device_not_ready" },
		{ nt_status_invalid_group_attributes, "invalid_group_attributes" },
		{ nt_status_bad_impersonation_level, "bad_impersonation_level" },
		{ nt_status_cant_open_anonymous, "cant_open_anonymous" },
		{ nt_status_bad_validation_class, "bad_validation_class" },
		{ nt_status_bad_token_type, "bad_token_type" },
		{ nt_status_bad_master_boot_record, "bad_master_boot_record" },
		{ nt_status_instruction_misalignment, "instruction_misalignment" },
		{ nt_status_instance_not_available, "instance_not_available" },
		{ nt_status_pipe_not_available, "pipe_not_available" },
		{ nt_status_invalid_pipe_state, "invalid_pipe_state" },
		{ nt_status_pipe_busy, "pipe_busy" },
		{ nt_status_illegal_function, "illegal_function" },
		{ nt_status_pipe_disconnected, "pipe_disconnected" },
		{ nt_status_pipe_closing, "pipe_closing" },
		{ nt_status_pipe_connected, "pipe_connected" },
		{ nt_status_pipe_listening, "pipe_listening" },
		{ nt_status_invalid_read_mode, "invalid_read_mode" },
		{ nt_status_io_timeout, "io_timeout" },
		{ nt_status_file_forced_closed, "file_forced_closed" },
		{ nt_status_profiling_not_started, "profiling_not_started" },
		{ nt_status_profiling_not_stopped, "profiling_not_stopped" },
		{ nt_status_could_not_interpret, "could_not_interpret" },
		{ nt_status_file_is_a_directory, "file_is_a_directory" },
		{ nt_status_not_supported, "not_supported" },
		{ nt_status_remote_not_listening, "remote_not_listening" },
		{ nt_status_duplicate_name, "duplicate_name" },
		{ nt_status_bad_network_path, "bad_network_path" },
		{ nt_status_network_busy, "network_busy" },
		{ nt_status_device_does_not_exist, "device_does_not_exist" },
		{ nt_status_too_many_commands, "too_many_commands" },
		{ nt_status_adapter_hardware_error, "adapter_hardware_error" },
		{ nt_status_invalid_network_response, "invalid_network_response" },
		{ nt_status_unexpected_network_error, "unexpected_network_error" },
		{ nt_status_bad_remote_adapter, "bad_remote_adapter" },
		{ nt_status_print_queue_full, "print_queue_full" },
		{ nt_status_no_spool_space, "no_spool_space" },
		{ nt_status_print_cancelled, "print_cancelled" },
		{ nt_status_network_name_deleted, "network_name_deleted" },
		{ nt_status_network_access_denied, "network_access_denied" },
		{ nt_status_bad_device_type, "bad_device_type" },
		{ nt_status_bad_network_name, "bad_network_name" },
		{ nt_status_too_many_names, "too_many_names" },
		{ nt_status_too_many_sessions, "too_many_sessions" },
		{ nt_status_sharing_paused, "sharing_paused" },
		{ nt_status_request_not_accepted, "request_not_accepted" },
		{ nt_status_redirector_paused, "redirector_paused" },
		{ nt_status_net_write_fault, "net_write_fault" },
		{ nt_status_profiling_at_limit, "profiling_at_limit" },
		{ nt_status_not_same_device, "not_same_device" },
		{ nt_status_file_renamed, "file_renamed" },
		{ nt_status_virtual_circuit_closed, "virtual_circuit_closed" },
		{ nt_status_no_security_on_object, "no_security_on_object" },
		{ nt_status_cant_wait, "cant_wait" },
		{ nt_status_pipe_empty, "pipe_empty" },
		{ nt_status_cant_access_domain_info, "cant_access_domain_info" },
		{ nt_status_cant_terminate_self, "cant_terminate_self" },
		{ nt_status_invalid_server_state, "invalid_server_state" },
		{ nt_status_invalid_domain_state, "invalid_domain_state" },
		{ nt_status_invalid_domain_role, "invalid_domain_role" },
		{ nt_status_no_such_domain, "no_such_domain" },
		{ nt_status_domain_exists, "domain_exists" },
		{ nt_status_domain_limit_exceeded, "domain_limit_exceeded" },
		{ nt_status_oplock_not_granted, "oplock_not_granted" },
		{ nt_status_invalid_oplock_protocol, "invalid_oplock_protocol" },
		{ nt_status_internal_db_corruption, "internal_db_corruption" },
		{ nt_status_internal_error, "internal_error" },
		{ nt_status_generic_not_mapped, "generic_not_mapped" },
		{ nt_status_bad_descriptor_format, "bad_descriptor_format" },
		{ nt_status_invalid_user_buffer, "invalid_user_buffer" },
		{ nt_status_unexpected_io_error, "unexpected_io_error" },
		{ nt_status_unexpected_mm_create_err, "unexpected_mm_create_err" },
		{ nt_status_unexpected_mm_map_error, "unexpected_mm_map_error" },
		{ nt_status_unexpected_mm_extend_err, "unexpected_mm_extend_err" },
		{ nt_status_not_logon_process, "not_logon_process" },
		{ nt_status_logon_session_exists, "logon_session_exists" },
		{ nt_status_invalid_parameter_1, "invalid_parameter_1" },
		{ nt_status_invalid_parameter_2, "invalid_parameter_2" },
		{ nt_status_invalid_parameter_3, "invalid_parameter_3" },
		{ nt_status_invalid_parameter_4, "invalid_parameter_4" },
		{ nt_status_invalid_parameter_5, "invalid_parameter_5" },
		{ nt_status_invalid_parameter_6, "invalid_parameter_6" },
		{ nt_status_invalid_parameter_7, "invalid_parameter_7" },
		{ nt_status_invalid_parameter_8, "invalid_parameter_8" },
		{ nt_status_invalid_parameter_9, "invalid_parameter_9" },
		{ nt_status_invalid_parameter_10, "invalid_parameter_10" },
		{ nt_status_invalid_parameter_11, "invalid_parameter_11" },
		{ nt_status_invalid_parameter_12, "invalid_parameter_12" },
		{ nt_status_redirector_not_started, "redirector_not_started" },
		{ nt_status_redirector_started, "redirector_started" },
		{ nt_status_stack_overflow, "stack_overflow" },
		{ nt_status_no_such_package, "no_such_package" },
		{ nt_status_bad_function_table, "bad_function_table" },
		{ nt_status_directory_not_empty, "directory_not_empty" },
		{ nt_status_file_corrupt_error, "file_corrupt_error" },
		{ nt_status_not_a_directory, "not_a_directory" },
		{ nt_status_bad_logon_session_state, "bad_logon_session_state" },
		{ nt_status_logon_session_collision, "logon_session_collision" },
		{ nt_status_name_too_long, "name_too_long" },
		{ nt_status_files_open, "files_open" },
		{ nt_status_connection_in_use, "connection_in_use" },
		{ nt_status_message_not_found, "message_not_found" },
		{ nt_status_process_is_terminating, "process_is_terminating" },
		{ nt_status_invalid_logon_type, "invalid_logon_type" },
		{ nt_status_no_guid_translation, "no_guid_translation" },
		{ nt_status_cannot_impersonate, "cannot_impersonate" },
		{ nt_status_image_already_loaded, "image_already_loaded" },
		{ nt_status_abios_not_present, "abios_not_present" },
		{ nt_status_abios_lid_not_exist, "abios_lid_not_exist" },
		{ nt_status_abios_lid_already_owned, "abios_lid_already_owned" },
		{ nt_status_abios_not_lid_owner, "abios_not_lid_owner" },
		{ nt_status_abios_invalid_command, "abios_invalid_command" },
		{ nt_status_abios_invalid_lid, "abios_invalid_lid" },
		{ nt_status_abios_selector_not_available, "abios_selector_not_available" },
		{ nt_status_abios_invalid_selector, "abios_invalid_selector" },
		{ nt_status_no_ldt, "no_ldt" },
		{ nt_status_invalid_ldt_size, "invalid_ldt_size" },
		{ nt_status_invalid_ldt_offset, "invalid_ldt_offset" },
		{ nt_status_invalid_ldt_descriptor, "invalid_ldt_descriptor" },
		{ nt_status_invalid_image_ne_format, "invalid_image_ne_format" },
		{ nt_status_rxact_invalid_state, "rxact_invalid_state" },
		{ nt_status_rxact_commit_failure, "rxact_commit_failure" },
		{ nt_status_mapped_file_size_zero, "mapped_file_size_zero" },
		{ nt_status_too_many_opened_files, "too_many_opened_files" },
		{ nt_status_cancelled, "cancelled" },
		{ nt_status_cannot_delete, "cannot_delete" },
		{ nt_status_invalid_computer_name, "invalid_computer_name" },
		{ nt_status_file_deleted, "file_deleted" },
		{ nt_status_special_account, "special_account" },
		{ nt_status_special_group, "special_group" },
		{ nt_status_special_user, "special_user" },
		{ nt_status_members_primary_group, "members_primary_group" },
		{ nt_status_file_closed, "file_closed" },
		{ nt_status_too_many_threads, "too_many_threads" },
		{ nt_status_thread_not_in_process, "thread_not_in_process" },
		{ nt_status_token_already_in_use, "token_already_in_use" },
		{ nt_status_pagefile_quota_exceeded, "pagefile_quota_exceeded" },
		{ nt_status_commitment_limit, "commitment_limit" },
		{ nt_status_invalid_image_le_format, "invalid_image_le_format" },
		{ nt_status_invalid_image_not_mz, "invalid_image_not_mz" },
		{ nt_status_invalid_image_protect, "invalid_image_protect" },
		{ nt_status_invalid_image_win_16, "invalid_image_win_16" },
		{ nt_status_logon_server_conflict, "logon_server_conflict" },
		{ nt_status_time_difference_at_dc, "time_difference_at_dc" },
		{ nt_status_synchronization_required, "synchronization_required" },
		{ nt_status_dll_not_found, "dll_not_found" },
		{ nt_status_open_failed, "open_failed" },
		{ nt_status_io_privilege_failed, "io_privilege_failed" },
		{ nt_status_ordinal_not_found, "ordinal_not_found" },
		{ nt_status_entrypoint_not_found, "entrypoint_not_found" },
		{ nt_status_control_c_exit, "control_c_exit" },
		{ nt_status_local_disconnect, "local_disconnect" },
		{ nt_status_remote_disconnect, "remote_disconnect" },
		{ nt_status_remote_resources, "remote_resources" },
		{ nt_status_link_failed, "link_failed" },
		{ nt_status_link_timeout, "link_timeout" },
		{ nt_status_invalid_connection, "invalid_connection" },
		{ nt_status_invalid_address, "invalid_address" },
		{ nt_status_dll_init_failed, "dll_init_failed" },
		{ nt_status_missing_systemfile, "missing_systemfile" },
		{ nt_status_unhandled_exception, "unhandled_exception" },
		{ nt_status_app_init_failure, "app_init_failure" },
		{ nt_status_pagefile_create_failed, "pagefile_create_failed" },
		{ nt_status_no_pagefile, "no_pagefile" },
		{ nt_status_invalid_level, "invalid_level" },
		{ nt_status_wrong_password_core, "wrong_password_core" },
		{ nt_status_illegal_float_context, "illegal_float_context" },
		{ nt_status_pipe_broken, "pipe_broken" },
		{ nt_status_registry_corrupt, "registry_corrupt" },
		{ nt_status_registry_io_failed, "registry_io_failed" },
		{ nt_status_no_event_pair, "no_event_pair" },
		{ nt_status_unrecognized_volume, "unrecognized_volume" },
		{ nt_status_serial_no_device_inited, "serial_no_device_inited" },
		{ nt_status_no_such_alias, "no_such_alias" },
		{ nt_status_member_not_in_alias, "member_not_in_alias" },
		{ nt_status_member_in_alias, "member_in_alias" },
		{ nt_status_alias_exists, "alias_exists" },
		{ nt_status_logon_not_granted, "logon_not_granted" },
		{ nt_status_too_many_secrets, "too_many_secrets" },
		{ nt_status_secret_too_long, "secret_too_long" },
		{ nt_status_internal_db_error, "internal_db_error" },
		{ nt_status_fullscreen_mode, "fullscreen_mode" },
		{ nt_status_too_many_context_ids, "too_many_context_ids" },
		{ nt_status_logon_type_not_granted, "logon_type_not_granted" },
		{ nt_status_not_registry_file, "not_registry_file" },
		{ nt_status_nt_cross_encryption_required, "nt_cross_encryption_required" },
		{ nt_status_domain_ctrlr_config_error, "domain_ctrlr_config_error" },
		{ nt_status_ft_missing_member, "ft_missing_member" },
		{ nt_status_ill_formed_service_entry, "ill_formed_service_entry" },
		{ nt_status_illegal_character, "illegal_character" },
		{ nt_status_unmappable_character, "unmappable_character" },
		{ nt_status_undefined_character, "undefined_character" },
		{ nt_status_floppy_volume, "floppy_volume" },
		{ nt_status_floppy_id_mark_not_found, "floppy_id_mark_not_found" },
		{ nt_status_floppy_wrong_cylinder, "floppy_wrong_cylinder" },
		{ nt_status_floppy_unknown_error, "floppy_unknown_error" },
		{ nt_status_floppy_bad_registers, "floppy_bad_registers" },
		{ nt_status_disk_recalibrate_failed, "disk_recalibrate_failed" },
		{ nt_status_disk_operation_failed, "disk_operation_failed" },
		{ nt_status_disk_reset_failed, "disk_reset_failed" },
		{ nt_status_shared_irq_busy, "shared_irq_busy" },
		{ nt_status_ft_orphaning, "ft_orphaning" },
		{ nt_status_partition_failure, "partition_failure" },
		{ nt_status_invalid_block_length, "invalid_block_length" },
		{ nt_status_device_not_partitioned, "device_not_partitioned" },
		{ nt_status_unable_to_lock_media, "unable_to_lock_media" },
		{ nt_status_unable_to_unload_media, "unable_to_unload_media" },
		{ nt_status_eom_overflow, "eom_overflow" },
		{ nt_status_no_media, "no_media" },
		{ nt_status_no_such_member, "no_such_member" },
		{ nt_status_invalid_member, "invalid_member" },
		{ nt_status_key_deleted, "key_deleted" },
		{ nt_status_no_log_space, "no_log_space" },
		{ nt_status_too_many_sids, "too_many_sids" },
		{ nt_status_lm_cross_encryption_required, "lm_cross_encryption_required" },
		{ nt_status_key_has_children, "key_has_children" },
		{ nt_status_child_must_be_volatile, "child_must_be_volatile" },
		{ nt_status_device_configuration_error, "device_configuration_error" },
		{ nt_status_driver_internal_error, "driver_internal_error" },
		{ nt_status_invalid_device_state, "invalid_device_state" },
		{ nt_status_io_device_error, "io_device_error" },
		{ nt_status_device_protocol_error, "device_protocol_error" },
		{ nt_status_backup_controller, "backup_controller" },
		{ nt_status_log_file_full, "log_file_full" },
		{ nt_status_too_late, "too_late" },
		{ nt_status_no_trust_lsa_secret, "no_trust_lsa_secret" },
		{ nt_status_no_trust_sam_account, "no_trust_sam_account" },
		{ nt_status_trusted_domain_failure, "trusted_domain_failure" },
		{ nt_status_trusted_relationship_failure, "trusted_relationship_failure" },
		{ nt_status_eventlog_file_corrupt, "eventlog_file_corrupt" },
		{ nt_status_eventlog_cant_start, "eventlog_cant_start" },
		{ nt_status_trust_failure, "trust_failure" },
		{ nt_status_mutant_limit_exceeded, "mutant_limit_exceeded" },
		{ nt_status_netlogon_not_started, "netlogon_not_started" },
		{ nt_status_account_expired, "account_expired" },
		{ nt_status_possible_deadlock, "possible_deadlock" },
		{ nt_status_network_credential_conflict, "network_credential_conflict" },
		{ nt_status_remote_session_limit, "remote_session_limit" },
		{ nt_status_eventlog_file_changed, "eventlog_file_changed" },
		{ nt_status_nologon_interdomain_trust_account, "nologon_interdomain_trust_account" },
		{ nt_status_nologon_workstation_trust_account, "nologon_workstation_trust_account" },
		{ nt_status_nologon_server_trust_account, "nologon_server_trust_account" },
		{ nt_status_domain_trust_inconsistent, "domain_trust_inconsistent" },
		{ nt_status_fs_driver_required, "fs_driver_required" },
		{ nt_status_no_user_session_key, "no_user_session_key" },
		{ nt_status_user_session_deleted, "user_session_deleted" },
		{ nt_status_resource_lang_not_found, "resource_lang_not_found" },
		{ nt_status_insuff_server_resources, "insuff_server_resources" },
		{ nt_status_invalid_buffer_size, "invalid_buffer_size" },
		{ nt_status_invalid_address_component, "invalid_address_component" },
		{ nt_status_invalid_address_wildcard, "invalid_address_wildcard" },
		{ nt_status_too_many_addresses, "too_many_addresses" },
		{ nt_status_address_already_exists, "address_already_exists" },
		{ nt_status_address_closed, "address_closed" },
		{ nt_status_connection_disconnected, "connection_disconnected" },
		{ nt_status_connection_reset, "connection_reset" },
		{ nt_status_too_many_nodes, "too_many_nodes" },
		{ nt_status_transaction_aborted, "transaction_aborted" },
		{ nt_status_transaction_timed_out, "transaction_timed_out" },
		{ nt_status_transaction_no_release, "transaction_no_release" },
		{ nt_status_transaction_no_match, "transaction_no_match" },
		{ nt_status_transaction_responded, "transaction_responded" },
		{ nt_status_transaction_invalid_id, "transaction_invalid_id" },
		{ nt_status_transaction_invalid_type, "transaction_invalid_type" },
		{ nt_status_not_server_session, "not_server_session" },
		{ nt_status_not_client_session, "not_client_session" },
		{ nt_status_cannot_load_registry_file, "cannot_load_registry_file" },
		{ nt_status_debug_attach_failed, "debug_attach_failed" },
		{ nt_status_system_process_terminated, "system_process_terminated" },
		{ nt_status_data_not_accepted, "data_not_accepted" },
		{ nt_status_no_browser_servers_found, "no_browser_servers_found" },
		{ nt_status_vdm_hard_error, "vdm_hard_error" },
		{ nt_status_driver_cancel_timeout, "driver_cancel_timeout" },
		{ nt_status_reply_message_mismatch, "reply_message_mismatch" },
		{ nt_status_mapped_alignment, "mapped_alignment" },
		{ nt_status_image_checksum_mismatch, "image_checksum_mismatch" },
		{ nt_status_lost_writebehind_data, "lost_writebehind_data" },
		{ nt_status_client_server_parameters_invalid, "client_server_parameters_invalid" },
		{ nt_status_password_must_change, "password_must_change" },
		{ nt_status_not_found, "not_found" },
		{ nt_status_not_tiny_stream, "not_tiny_stream" },
		{ nt_status_recovery_failure, "recovery_failure" },
		{ nt_status_stack_overflow_read, "stack_overflow_read" },
		{ nt_status_fail_check, "fail_check" },
		{ nt_status_duplicate_objectid, "duplicate_objectid" },
		{ nt_status_objectid_exists, "objectid_exists" },
		{ nt_status_convert_to_large, "convert_to_large" },
		{ nt_status_retry, "retry" },
		{ nt_status_found_out_of_scope, "found_out_of_scope" },
		{ nt_status_allocate_bucket, "allocate_bucket" },
		{ nt_status_propset_not_found, "propset_not_found" },
		{ nt_status_marshall_overflow, "marshall_overflow" },
		{ nt_status_invalid_variant, "invalid_variant" },
		{ nt_status_domain_controller_not_found, "domain_controller_not_found" },
		{ nt_status_account_locked_out, "account_locked_out" },
		{ nt_status_handle_not_closable, "handle_not_closable" },
		{ nt_status_connection_refused, "connection_refused" },
		{ nt_status_graceful_disconnect, "graceful_disconnect" },
		{ nt_status_address_already_associated, "address_already_associated" },
		{ nt_status_address_not_associated, "address_not_associated" },
		{ nt_status_connection_invalid, "connection_invalid" },
		{ nt_status_connection_active, "connection_active" },
		{ nt_status_network_unreachable, "network_unreachable" },
		{ nt_status_host_unreachable, "host_unreachable" },
		{ nt_status_protocol_unreachable, "protocol_unreachable" },
		{ nt_status_port_unreachable, "port_unreachable" },
		{ nt_status_request_aborted, "request_aborted" },
		{ nt_status_connection_aborted, "connection_aborted" },
		{ nt_status_bad_compression_buffer, "bad_compression_buffer" },
		{ nt_status_user_mapped_file, "user_mapped_file" },
		{ nt_status_audit_failed, "audit_failed" },
		{ nt_status_timer_resolution_not_set, "timer_resolution_not_set" },
		{ nt_status_connection_count_limit, "connection_count_limit" },
		{ nt_status_login_time_restriction, "login_time_restriction" },
		{ nt_status_login_wksta_restriction, "login_wksta_restriction" },
		{ nt_status_image_mp_up_mismatch, "image_mp_up_mismatch" },
		{ nt_status_insufficient_logon_info, "insufficient_logon_info" },
		{ nt_status_bad_dll_entrypoint, "bad_dll_entrypoint" },
		{ nt_status_bad_service_entrypoint, "bad_service_entrypoint" },
		{ nt_status_lpc_reply_lost, "lpc_reply_lost" },
		{ nt_status_ip_address_conflict1, "ip_address_conflict1" },
		{ nt_status_ip_address_conflict2, "ip_address_conflict2" },
		{ nt_status_registry_quota_limit, "registry_quota_limit" },
		{ nt_status_path_not_covered, "path_not_covered" },
		{ nt_status_no_callback_active, "no_callback_active" },
		{ nt_status_license_quota_exceeded, "license_quota_exceeded" },
		{ nt_status_pwd_too_short, "pwd_too_short" },
		{ nt_status_pwd_too_recent, "pwd_too_recent" },
		{ nt_status_pwd_history_conflict, "pwd_history_conflict" },
		{ nt_status_plugplay_no_device, "plugplay_no_device" },
		{ nt_status_unsupported_compression, "unsupported_compression" },
		{ nt_status_invalid_hw_profile, "invalid_hw_profile" },
		{ nt_status_invalid_plugplay_device_path, "invalid_plugplay_device_path" },
		{ nt_status_driver_ordinal_not_found, "driver_ordinal_not_found" },
		{ nt_status_driver_entrypoint_not_found, "driver_entrypoint_not_found" },
		{ nt_status_resource_not_owned, "resource_not_owned" },
		{ nt_status_too_many_links, "too_many_links" },
		{ nt_status_quota_list_inconsistent, "quota_list_inconsistent" },
		{ nt_status_file_is_offline, "file_is_offline" },
		//{ nt_status_notify_enum_dir, "notify_enum_dir" },
		{ -1, NULL }
	};

	const char * command_name;
	struct line_buffer lb;

	if(smb_packet_source == smb_packet_from_consumer)
		Printf("source = from consumer (client --> server)\n");
	else
		Printf("source = to consumer (client <-- server)\n");

	if(header->flags2 & SMB_FLAGS2_32BIT_STATUS)
	{
		int level,facility,error_code;
		const char * level_name;
		const char * facility_name = "?";
		const char * error_code_name = "?";
		int i;

		level = (header->status >> 29) & 0x3;
		facility = (header->status >> 16) & 0x0fff;
		error_code = header->status & 0xffff;

		switch(level)
		{
			case 0:

				level_name = "success";
				break;

			case 1:

				level_name = "information";
				break;

			case 2:

				level_name = "warning";
				break;

			case 3:
			default:

				level_name = "error";
				break;
		}

		for(i = 0 ; nt_error_codes[i].code != -1 ; i++)
		{
			if(nt_error_codes[i].code == error_code)
			{
				error_code_name = nt_error_codes[i].label;
				break;
			}
		}

		Printf("status = [%08lx] level:%s (%ld), facility:%s (%ld), code:%s (%ld)\n",header->status,level,level_name,facility,facility_name,error_code,error_code_name);
	}
	else
	{
		const char * error_class_name;
		int error_class_value;
		const char * error_code_name = "?";
		int error_code_value;
		int i;

		error_class_value = header->status & 255;
		error_code_value = (header->status >> 16) & 32767;

		switch(error_class_value)
		{
			case 0:

				error_class_name = "success";
				error_code_name = "no error";
				break;

			case 1:

				error_class_name = "DOS error";

				for(i = 0 ; dos_errors[i].code != -1 ; i++)
				{
					if(dos_errors[i].code == error_code_value)
					{
						error_code_name = dos_errors[i].label;
						break;
					}
				}

				break;

			case 2:

				error_class_name = "server error";

				for(i = 0 ; server_errors[i].code != -1 ; i++)
				{
					if(server_errors[i].code == error_code_value)
					{
						error_code_name = server_errors[i].label;
						break;
					}
				}

				break;

			case 3:

				error_class_name = "hardware error";

				for(i = 0 ; hardware_errors[i].code != -1 ; i++)
				{
					if(hardware_errors[i].code == error_code_value)
					{
						error_code_name = hardware_errors[i].label;
						break;
					}
				}

				break;

			default:

				error_class_name = "Command error";
				break;
		}

		Printf("status = error:%s (%ld), code:%s (%ld)\n",error_class_name,error_class_value,error_code_name,error_code_value);
	}

	Printf("flags = ");

	init_line_buffer(&lb);

	if(header->flags & SMB_FLAGS_SERVER_TO_REDIR)
		add_lb_flag(&lb,"type=reply");
	else
		add_lb_flag(&lb,"type=request");

	if(header->flags & SMB_FLAGS_REQUEST_BATCH_OPLOCK)
		add_lb_flag(&lb,"request-batch-oplock=batch");
	else
		add_lb_flag(&lb,"request-batch-oplock=exclusive");

	if(header->flags & SMB_FLAGS_REQUEST_OPLOCK)
		add_lb_flag(&lb,"request-oplock=yes");
	else
		add_lb_flag(&lb,"request-oplock=no");

	if(header->flags & SMB_FLAGS_CANONICAL_PATHNAMES)
		add_lb_flag(&lb,"canonical-pathnames=canonical");
	else
		add_lb_flag(&lb,"canonical-pathnames=host format");

	if(header->flags & SMB_FLAGS_CASELESS_PATHNAMES)
		add_lb_flag(&lb,"caseless-pathnames=yes");
	else
		add_lb_flag(&lb,"caseless-pathnames=no");

	if(header->flags & SMB_FLAGS_CLIENT_BUF_AVAIL)
		add_lb_flag(&lb,"client-buf-avail=yes");
	else
		add_lb_flag(&lb,"client-buf-avail=no");

	if(header->flags & SMB_FLAGS_SUPPORT_LOCKREAD)
		add_lb_flag(&lb,"support-lockread=yes");
	else
		add_lb_flag(&lb,"support-lockread=no");

	Printf("%s\n",lb.line);

	Printf("flags2 = ");

	init_line_buffer(&lb);

	if(header->flags2 & SMB_FLAGS2_UNICODE_STRINGS)
		add_lb_flag(&lb,"string-format=Unicode");
	else
		add_lb_flag(&lb,"string-format=ASCII");

	if(header->flags2 & SMB_FLAGS2_32BIT_STATUS)
		add_lb_flag(&lb,"status-code=NT_STATUS format");
	else
		add_lb_flag(&lb,"status-code=DOS error format");

	if(header->flags2 & SMB_FLAGS2_READ_IF_EXECUTE)
		add_lb_flag(&lb,"read-if-execute=yes");
	else
		add_lb_flag(&lb,"read-if-execute=no");

	if(header->flags2 & SMB_FLAGS2_DFS_PATHNAME)
		add_lb_flag(&lb,"pathname=DFS");
	else
		add_lb_flag(&lb,"pathname=normal");

	if(header->flags2 & SMB_FLAGS2_EXTENDED_SECURITY)
		add_lb_flag(&lb,"security=extended");
	else
		add_lb_flag(&lb,"security=normal");

	if(header->flags2 & SMB_FLAGS2_IS_LONG_NAME)
		add_lb_flag(&lb,"name-format=long");
	else
		add_lb_flag(&lb,"name-format=8.3");

	if(header->flags2 & SMB_FLAGS2_SECURITY_SIGNATURE)
		add_lb_flag(&lb,"security-signature=MAC");
	else
		add_lb_flag(&lb,"security-signature=none");

	if(header->flags2 & SMB_FLAGS2_EAS)
		add_lb_flag(&lb,"extended-attributes=yes");
	else
		add_lb_flag(&lb,"extended-attributes=no");

	if(header->flags2 & SMB_FLAGS2_KNOWS_LONG_NAMES)
		add_lb_flag(&lb,"client-names-supported=long");
	else
		add_lb_flag(&lb,"client-names-supported=8.3");

	Printf("%s\n",lb.line);

	Printf("signature = %04lx%04lx%04lx%04lx\n",header->extra.signature[0],header->extra.signature[1],header->extra.signature[2],header->extra.signature[3]);

	Printf("tid = %04lx\n",header->tid);
	Printf("pid = %04lx\n",header->pid);
	Printf("uid = %04lx\n",header->uid);
	Printf("mid = %04lx\n",header->mid);

	Printf("length = %ld (packet size:%ld, buffer size:%ld)\n",header_length,packet_size,max_buffer_size);

	if(is_smb_andx_command(header->command))
	{
		const unsigned char * andx_header = (const unsigned char *)header->parameters;
		int offset = (((int)andx_header[3]) << 8) + andx_header[2];
		int num_parameter_words,num_data_bytes;

		command_name = get_smb_command_name(header->command);

		if(command_name != NULL)
			Printf("command = %s (ANDX)\n",command_name);
		else
			Printf("command = 0x%02lx (ANDX)\n",header->command);

		Printf("parameter words = %ld\n",header->num_parameter_words - 2);
		
		if(header->num_parameter_words - 2 > 0)
			print_smb_parameters(header->num_parameter_words - 2,&header->parameters[4]);

		Printf("data bytes = %ld\n",header->num_data_bytes);

		/* If there are any data bytes, print them like "type hex .." would. */
		if(header->num_data_bytes > 0)
			print_smb_data(&lb,header->num_data_bytes,header->data);

		print_smb_contents(header, header->command, smb_packet_source, header->num_parameter_words - 2, &header->parameters[4], header->num_data_bytes, header->data);

		while(andx_header[0] != 0xff && offset > 0 && offset < packet_size)
		{
			andx_header = &packet[offset];

			num_parameter_words = (*andx_header++);

			command_name = get_smb_command_name(andx_header[0]);

			if(command_name != NULL)
				Printf("command = %s (ANDX)\n",command_name);
			else
				Printf("command = 0x%02lx (ANDX)\n",header->command);

			Printf("andx_offset = 0x%02lx\n",(((int)andx_header[3]) << 8) + andx_header[2]);

			Printf("parameter words = %ld\n",num_parameter_words);
	
			if(num_parameter_words > 0)
				print_smb_parameters(num_parameter_words,&andx_header[4]);

			num_data_bytes = andx_header[4 + num_parameter_words * 2] + (((int)andx_header[4 + num_parameter_words * 2 + 1]) << 8);

			Printf("data bytes = %ld\n",num_data_bytes);

			if(num_data_bytes > 0)
				print_smb_data(&lb,num_data_bytes,&andx_header[4 + num_parameter_words * 2 + 2]);

			print_smb_contents(header, andx_header[0], smb_packet_source, num_parameter_words, &andx_header[4], num_data_bytes, &andx_header[4 + num_parameter_words * 2 + 2]);

			offset = (((int)andx_header[3]) << 8) + andx_header[2];
		}
	}
	else
	{
		command_name = get_smb_command_name(header->command);

		if(command_name != NULL)
			Printf("command = %s\n",command_name);
		else
			Printf("command = 0x%02lx\n",header->command);

		Printf("parameter words = %ld\n",header->num_parameter_words);
		
		if(header->num_parameter_words > 0)
			print_smb_parameters(header->num_parameter_words,(unsigned char *)header->parameters);

		Printf("data bytes = %ld\n",header->num_data_bytes);

		/* If there are any data bytes, print them like "type hex .." would. */
		if(header->num_data_bytes > 0)
			print_smb_data(&lb,header->num_data_bytes,header->data);

		print_smb_contents(header, header->command, smb_packet_source, header->num_parameter_words, header->parameters, header->num_data_bytes, header->data);
	}
}

static void
dump_smb(const char *file_name,int line_number,const void * packet,int length,enum smb_packet_source_t smb_packet_source,int max_buffer_size)
{
	if(dump_smb_enabled && length > 4 && memcmp(packet,"\xffSMB",4) == 0)
	{
		struct smb_header header;
		int num_bytes_read;
		
		num_bytes_read = fill_header(packet,length,&header);
		if(num_bytes_read <= length)
		{
			Printf("---\n");
			Printf("%s:%ld\n",file_name,line_number);

			print_smb_header(&header,num_bytes_read,packet,length,smb_packet_source,max_buffer_size);

			Printf("---\n\n");
		}
	}
}

/*****************************************************************************/

void control_smb_dump(int enable)
{
	dump_smb_enabled = enable;
}

/*****************************************************************************/

#else

/*****************************************************************************/

void control_smb_dump(int enable)
{
}

/*****************************************************************************/

#endif /* defined(DUMP_SMB) */

/*****************************************************************************/

/* smb_receive_raw
   fs points to the correct segment, sock != NULL, target != NULL
   The smb header is only stored if want_header != 0. */
static int
smb_receive_raw (const struct smb_server *server, int sock_fd, unsigned char *target, int max_raw_length, int want_header)
{
	int len, result;
	int already_read;
	unsigned char peek_buf[4];

 re_recv:

	/* Read the NetBIOS session header (rfc-1002) */
	result = recvfrom (sock_fd, (void *) peek_buf, 4, 0, NULL, NULL);
	if (result < 0)
	{
		LOG (("smb_receive_raw: recv error = %ld\n", errno));
		result = (-errno);
		goto out;
	}

	if (result < 4)
	{
		LOG (("smb_receive_raw: got less than 4 bytes\n"));
		result = -EIO;
		goto out;
	}

	/* Check the session type. */
	switch (peek_buf[0])
	{
		/* 0x00 == session message */
		case 0x00:
		/* 0x82 == positive session response */
		case 0x82:

			break;

		/* 0x85 == session keepalive */
		case 0x85:

			LOG (("smb_receive_raw: Got SESSION KEEP ALIVE\n"));
			goto re_recv;

		/* 0x81 == session request */
		/* 0x83 == negative session response */
		/* 0x84 == retarget session response */
		default:

			LOG (("smb_receive_raw: Invalid packet 0x%02lx\n", peek_buf[0]));
			result = -EIO;
			goto out;
	}

	/* The length in the RFC NB header is the raw data length (17 bits) */
	len = (int)smb_len (peek_buf);
	if (len > max_raw_length)
	{
		LOG (("smb_receive_raw: Received length (%ld) > max_xmit (%ld)!\n", len, max_raw_length));
		result = -EIO;
		goto out;
	}

	/* Prepend the NetBIOS header to what is read? */
	if (want_header)
	{
		/* Check for buffer overflow. */
		if(len + 4 > max_raw_length)
		{
			LOG (("smb_receive_raw: Received length (%ld) > max_xmit (%ld)!\n", len, max_raw_length));
			result = -EIO;
			goto out;
		}
	
		memcpy (target, peek_buf, 4);
		target += 4;
	}

	already_read = 0;

	while (already_read < len)
	{
		result = recvfrom (sock_fd, (void *) (target + already_read), len - already_read, 0, NULL, NULL);
		if (result < 0)
		{
			LOG (("smb_receive_raw: recvfrom error = %ld\n", errno));

			result = (-errno);

			goto out;
		}

		already_read += result;
	}

	#if defined(DUMP_SMB)
	dump_smb(__FILE__,__LINE__,target,already_read,smb_packet_to_consumer,server->max_recv);
	#endif /* defined(DUMP_SMB) */

	result = already_read;

 out:

	return result;
}

/* smb_receive
   fs points to the correct segment, server != NULL, sock!=NULL */
static int
smb_receive (struct smb_server *server, int sock_fd)
{
	byte * packet = server->packet;
	int result;

	result = smb_receive_raw (server, sock_fd, packet,
	                          server->max_recv - 4, /* max_xmit in server includes NB header */
	                          1); /* We want the header */
	if (result < 0)
	{
		LOG (("smb_receive: receive error: %ld\n", result));
		goto out;
	}

	server->rcls = *((unsigned char *) (packet + 9));
	server->err = WVAL (packet, 11);

	if (server->rcls != 0)
		LOG (("smb_receive: rcls=%ld, err=%ld\n", server->rcls, server->err));

 out:

	return result;
}

/* smb_receive's preconditions also apply here. */
static int
smb_receive_trans2 (struct smb_server *server, int sock_fd, int *data_len, int *param_len, char **data, char **param)
{
	unsigned char *inbuf = server->packet;
	int total_data;
	int total_param;
	int result;

	LOG (("smb_receive_trans2: enter\n"));

	(*data_len) = (*param_len) = 0;
	(*param) = (*data) = NULL;

	result = smb_receive (server, sock_fd);
	if (result < 0)
		goto fail;

	if (server->rcls != 0)
		goto fail;

	/* parse out the lengths */
	total_data = WVAL (inbuf, smb_tdrcnt);
	total_param = WVAL (inbuf, smb_tprcnt);

	if ((total_data > server->max_xmit) || (total_param > server->max_xmit))
	{
		LOG (("smb_receive_trans2: data/param too long\n"));

		result = -EIO;
		goto fail;
	}

	/* Allocate it, but only if there is something to allocate
	   in the first place. ZZZ this may not be the proper approach,
	   and we should return an error for 'no data'. */
	if(total_data > 0)
	{
		(*data) = malloc (total_data);
		if ((*data) == NULL)
		{
			LOG (("smb_receive_trans2: could not alloc data area\n"));

			result = -ENOMEM;
			goto fail;
		}
	}
	else
	{
		(*data) = NULL;
	}

	/* Allocate it, but only if there is something to allocate
	   in the first place. ZZZ this may not be the proper approach,
	   and we should return an error for 'no parameters'. */
	if(total_param > 0)
	{
		(*param) = malloc(total_param);
		if ((*param) == NULL)
		{
			LOG (("smb_receive_trans2: could not alloc param area\n"));

			result = -ENOMEM;
			goto fail;
		}
	}
	else
	{
		(*param) = NULL;
	}

	LOG (("smb_rec_trans2: total_data/param: %ld/%ld\n", total_data, total_param));

	while (1)
	{
		if (WVAL (inbuf, smb_prdisp) + WVAL (inbuf, smb_prcnt) > total_param)
		{
			LOG (("smb_receive_trans2: invalid parameters\n"));
			result = -EIO;
			goto fail;
		}

		if((*param) != NULL)
			memcpy ((*param) + WVAL (inbuf, smb_prdisp), smb_base (inbuf) + WVAL (inbuf, smb_proff), WVAL (inbuf, smb_prcnt));

		(*param_len) += WVAL (inbuf, smb_prcnt);

		if (WVAL (inbuf, smb_drdisp) + WVAL (inbuf, smb_drcnt) > total_data)
		{
			LOG (("smb_receive_trans2: invalid data block\n"));
			result = -EIO;
			goto fail;
		}

		if((*data) != NULL)
			memcpy ((*data) + WVAL (inbuf, smb_drdisp), smb_base (inbuf) + WVAL (inbuf, smb_droff), WVAL (inbuf, smb_drcnt));

		(*data_len) += WVAL (inbuf, smb_drcnt);

		LOG (("smb_rec_trans2: drcnt/prcnt: %ld/%ld\n", WVAL (inbuf, smb_drcnt), WVAL (inbuf, smb_prcnt)));

		/* parse out the total lengths again - they can shrink! */
		if ((WVAL (inbuf, smb_tdrcnt) > total_data) || (WVAL (inbuf, smb_tprcnt) > total_param))
		{
			LOG (("smb_receive_trans2: data/params grew!\n"));
			result = -EIO;
			goto fail;
		}

		total_data = WVAL (inbuf, smb_tdrcnt);
		total_param = WVAL (inbuf, smb_tprcnt);
		if (total_data <= (*data_len) && total_param <= (*param_len))
			break;

		result = smb_receive (server, sock_fd);
		if (result < 0)
			goto fail;

		if (server->rcls != 0)
		{
			result = -EIO;
			goto fail;
		}
	}

	LOG (("smb_receive_trans2: normal exit\n"));
	return 0;

 fail:

	LOG (("smb_receive_trans2: failed exit\n"));

	if((*param) != NULL)
		free (*param);

	if((*data) != NULL)
		free (*data);

	(*param) = (*data) = NULL;

	return result;
}

int
smb_release (struct smb_server *server)
{
	int result;

	if (server->mount_data.fd >= 0)
		CloseSocket (server->mount_data.fd);

	server->mount_data.fd = socket (AF_INET, SOCK_STREAM, 0);
	if (server->mount_data.fd < 0)
	{
		result = (-errno);
		goto out;
	}

	result = 0;

 out:

	return result;
}

int
smb_connect (struct smb_server *server)
{
	int sock_fd = server->mount_data.fd;
	int result;

	if (sock_fd < 0)
	{
		result = (-EBADF);
		goto out;
	}

	result = connect (sock_fd, (struct sockaddr *)&server->mount_data.addr, sizeof(struct sockaddr_in));
	if(result < 0)
		result = (-errno);

 out:

	return(result);
}

/*****************************************************************************
 *
 * This routine was once taken from nfs, which is for udp. Here TCP does
 * most of the ugly stuff for us (thanks, Alan!)
 *
 ****************************************************************************/

int
smb_request (struct smb_server *server)
{
	int len, result;
	int sock_fd = server->mount_data.fd;
	unsigned char *buffer = server->packet;

	if ((sock_fd < 0) || (buffer == NULL))
	{
		LOG (("smb_request: Bad server!\n"));
		result = -EBADF;
		goto out;
	}

	if (server->state != CONN_VALID)
	{
		result = -EIO;
		goto out;
	}

	len = smb_len (buffer) + 4;

	LOG (("smb_request: len = %ld cmd = 0x%lx\n", len, buffer[8]));

	#if defined(DUMP_SMB)
	dump_smb(__FILE__,__LINE__,buffer+4,len-4,smb_packet_from_consumer,server->max_recv);
	#endif /* defined(DUMP_SMB) */

	result = send (sock_fd, (void *) buffer, len, 0);
	if (result < 0)
	{
		LOG (("smb_request: send error = %ld\n", errno));

		result = (-errno);
	}
	else
	{
		result = smb_receive (server, sock_fd);
	}

 out:

	if (result < 0)
	{
		server->state = CONN_INVALID;
		smb_invalidate_all_inodes (server);
	}

	LOG (("smb_request: result = %ld\n", result));

	return (result);
}

/* This is not really a trans2 request, we assume that you only have
   one packet to send. */
int
smb_trans2_request (struct smb_server *server, int *data_len, int *param_len, char **data, char **param)
{
	int len, result;
	int sock_fd = server->mount_data.fd;
	unsigned char *buffer = server->packet;

	if (server->state != CONN_VALID)
	{
		result = -EIO;
		goto out;
	}

	len = smb_len (buffer) + 4;

	LOG (("smb_request: len = %ld cmd = 0x%02lx\n", len, buffer[8]));

	#if defined(DUMP_SMB)
	dump_smb(__FILE__,__LINE__,buffer+4,len-4,smb_packet_from_consumer,server->max_recv);
	#endif /* defined(DUMP_SMB) */

	result = send (sock_fd, (void *) buffer, len, 0);
	if (result < 0)
	{
		LOG (("smb_trans2_request: send error = %ld\n", errno));

		result = (-errno);
	}
	else
	{
		result = smb_receive_trans2 (server, sock_fd, data_len, param_len, data, param);
	}

 out:

	if (result < 0)
	{
		server->state = CONN_INVALID;
		smb_invalidate_all_inodes (server);
	}

	LOG (("smb_trans2_request: result = %ld\n", result));

	return result;
}

/* target must be in user space */
int
smb_request_read_raw (struct smb_server *server, unsigned char *target, int max_len)
{
	int len, result;
	int sock_fd = server->mount_data.fd;
	unsigned char *buffer = server->packet;

	if (server->state != CONN_VALID)
	{
		result = -EIO;
		goto out;
	}

	len = smb_len (buffer) + 4;

	LOG (("smb_request_read_raw: len = %ld cmd = 0x%02lx\n", len, buffer[8]));
	LOG (("smb_request_read_raw: target=%lx, max_len=%ld\n", (unsigned int) target, max_len));
	LOG (("smb_request_read_raw: buffer=%lx, sock=%lx\n", (unsigned int) buffer, (unsigned int) sock_fd));

	#if defined(DUMP_SMB)
	dump_smb(__FILE__,__LINE__,buffer+4,len-4,smb_packet_from_consumer,server->max_recv);
	#endif /* defined(DUMP_SMB) */

	result = send (sock_fd, (void *) buffer, len, 0);

	LOG (("smb_request_read_raw: send returned %ld\n", result));

	if (result < 0)
	{
		LOG (("smb_request_read_raw: send error = %ld\n", errno));

		result = (-errno);
	}
	else
	{
		result = smb_receive_raw (server, sock_fd, target, max_len, 0);
	}

 out:

	if (result < 0)
	{
		server->state = CONN_INVALID;
		smb_invalidate_all_inodes (server);
	}

	LOG (("smb_request_read_raw: result = %ld\n", result));

	return result;
}

/* Source must be in user space. smb_request_write_raw assumes that
   the request SMBwriteBraw has been completed successfully, so that
   we can send the raw data now. */
int
smb_request_write_raw (struct smb_server *server, unsigned const char *source, int length)
{
	int result;
	byte nb_header[4];
	int sock_fd = server->mount_data.fd;

	if (server->state != CONN_VALID)
	{
		result = -EIO;
		goto out;
	}

	smb_encode_smb_length (nb_header, length);

	result = send (sock_fd, (void *) nb_header, 4, 0);
	if (result == 4)
	{
		#if defined(DUMP_SMB)
		dump_smb(__FILE__,__LINE__,source,length,smb_packet_from_consumer,server->max_recv);
		#endif /* defined(DUMP_SMB) */

		result = send (sock_fd, (void *) source, length, 0);
		if(result < 0)
			result = (-errno);
	}
	else
	{
		if(result < 0)
			result = (-errno);
		else
			result = -EIO;
	}

	LOG (("smb_request_write_raw: send returned %ld\n", result));

	if (result == length)
		result = smb_receive (server, sock_fd);

 out:

	if (result < 0)
	{
		server->state = CONN_INVALID;

		smb_invalidate_all_inodes (server);
	}

	if (result > 0)
		result = length;

	LOG (("smb_request_write_raw: result = %ld\n", result));

	return result;
}