diff --git a/documentation/history.doc b/documentation/history.doc index abeb5bf..01815fe 100644 --- a/documentation/history.doc +++ b/documentation/history.doc @@ -758,3 +758,10 @@ smbfs 1.83 (20.3.2016) - Reworked the SMB decoding so that the ANDX commands can be handled properly. Not that I have actually seen any of these commands at work, mind you. + + +smbfs 1.84 (25.3.2016) + +- Major rework of the code which decodes individual commands, + their parameters and the responses. This is still incomplete, + but it's a lot more useful now than before. diff --git a/source_code/smbfs_rev.h b/source_code/smbfs_rev.h index b349139..6eb92b1 100644 --- a/source_code/smbfs_rev.h +++ b/source_code/smbfs_rev.h @@ -1,6 +1,6 @@ #define VERSION 1 -#define REVISION 83 -#define DATE "20.3.2016" -#define VERS "smbfs 1.83" -#define VSTRING "smbfs 1.83 (20.3.2016)\r\n" -#define VERSTAG "\0$VER: smbfs 1.83 (20.3.2016)" +#define REVISION 84 +#define DATE "25.3.2016" +#define VERS "smbfs 1.84" +#define VSTRING "smbfs 1.84 (25.3.2016)\r\n" +#define VERSTAG "\0$VER: smbfs 1.84 (25.3.2016)" diff --git a/source_code/smbfs_rev.rev b/source_code/smbfs_rev.rev index 76a8b2b..871727d 100644 --- a/source_code/smbfs_rev.rev +++ b/source_code/smbfs_rev.rev @@ -1 +1 @@ -83 +84 diff --git a/source_code/sock.c b/source_code/sock.c index f44d26c..0daee64 100644 --- a/source_code/sock.c +++ b/source_code/sock.c @@ -1,7 +1,7 @@ /* * $Id: sock.c,v 1.2 2009/04/14 11:32:51 obarthel Exp $ * - * :ts=8 + * :ts=4 * * sock.c * @@ -33,6 +33,10 @@ /*****************************************************************************/ +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; @@ -48,7 +52,6 @@ enum smb_packet_source_t smb_packet_to_consumer }; - /*****************************************************************************/ /* Known SMB command codes. */ @@ -128,6 +131,25 @@ enum smb_packet_source_t #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]] @@ -142,32 +164,32 @@ struct smb_header 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] + 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] + 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; + 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->data = data; + dc->offset = 0; + dc->length = length; dc->overflow = 0; } @@ -321,6 +343,43 @@ is_smb_andx_command(unsigned char command) 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) { @@ -515,26 +574,1038 @@ add_lb_flag(struct line_buffer *lb,const char * str) } } +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: * - * CLOSE - * CREATE - * NEGOTIATE - * OPEN - * QUERY_INFORMATION - * QUERY_INFORMATION_DISK - * READ - * READ_RAW - * SEEK - * SESSION_SETUP_ANDX - * SET_INFORMATION - * TRANSACTION2 - * TREE_CONNECT_ANDX - * WRITE + * 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) +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 @@ -542,8 +1613,6 @@ print_smb_data(struct line_buffer * lb,int num_data_bytes_left,const unsigned ch { if(num_data_bytes_left > 0) { - extern VOID VARARGS68K SPrintf(STRPTR buffer, STRPTR formatString,...); - int row_offset = 0; char format_buffer[20]; char dword_buffer[20]; @@ -647,6 +1716,1208 @@ print_smb_parameters(int num_parameter_words,const unsigned char *parameters) 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; @@ -656,9 +2927,124 @@ print_smb_header(const struct smb_header * header,int header_length,const unsign Printf("source = to consumer (client <-- server)\n"); if(header->flags2 & SMB_FLAGS2_32BIT_STATUS) - Printf("status = level:%ld, facility:%ld, code:%ld\n",header->status & 3,(header->status >> 4) & 4095,(header->status >> 16) & 32767); + { + 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 - Printf("status = class:%ld, code:%ld\n",header->status & 255,(header->status >> 16) & 32767); + { + 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 = "); @@ -706,14 +3092,14 @@ print_smb_header(const struct smb_header * header,int header_length,const unsign init_line_buffer(&lb); if(header->flags2 & SMB_FLAGS2_UNICODE_STRINGS) - add_lb_flag(&lb,"strings=Unicode"); + add_lb_flag(&lb,"string-format=Unicode"); else - add_lb_flag(&lb,"strings=ASCII"); + add_lb_flag(&lb,"string-format=ASCII"); if(header->flags2 & SMB_FLAGS2_32BIT_STATUS) - add_lb_flag(&lb,"status-code=NT_STATUS"); + add_lb_flag(&lb,"status-code=NT_STATUS format"); else - add_lb_flag(&lb,"status-code=DOS error"); + 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"); @@ -731,9 +3117,9 @@ print_smb_header(const struct smb_header * header,int header_length,const unsign add_lb_flag(&lb,"security=normal"); if(header->flags2 & SMB_FLAGS2_IS_LONG_NAME) - add_lb_flag(&lb,"names=long"); + add_lb_flag(&lb,"name-format=long"); else - add_lb_flag(&lb,"names=8.3"); + add_lb_flag(&lb,"name-format=8.3"); if(header->flags2 & SMB_FLAGS2_SECURITY_SIGNATURE) add_lb_flag(&lb,"security-signature=MAC"); @@ -761,32 +3147,32 @@ print_smb_header(const struct smb_header * header,int header_length,const unsign Printf("length = %ld (packet size:%ld, buffer size:%ld)\n",header_length,packet_size,max_buffer_size); - 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); - if(is_smb_andx_command(header->command)) { const unsigned char * andx_header = (const unsigned char *)header->parameters; - int offset = andx_header[2] + (((int)andx_header[3]) << 8); + 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]; @@ -800,7 +3186,7 @@ print_smb_header(const struct smb_header * header,int header_length,const unsign else Printf("command = 0x%02lx (ANDX)\n",header->command); - Printf("andx_offset = 0x%02lx\n",andx_header[2] + (((int)andx_header[3]) << 8)); + Printf("andx_offset = 0x%02lx\n",(((int)andx_header[3]) << 8) + andx_header[2]); Printf("parameter words = %ld\n",num_parameter_words); @@ -814,9 +3200,33 @@ print_smb_header(const struct smb_header * header,int header_length,const unsign if(num_data_bytes > 0) print_smb_data(&lb,num_data_bytes,&andx_header[4 + num_parameter_words * 2 + 2]); - offset = andx_header[2] + (((int)andx_header[3]) << 8); + 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 @@ -869,101 +3279,104 @@ void control_smb_dump(int enable) 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]; + 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; - } + /* 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; - } + 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; + /* Check the session type. */ + switch (peek_buf[0]) + { + /* 0x00 == session message */ + case 0x00: + /* 0x82 == positive session response */ + case 0x82: - /* 0x85 == session keepalive */ - case 0x85: - LOG (("smb_receive_raw: Got SESSION KEEP ALIVE\n")); - goto re_recv; + break; - /* 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; - } + /* 0x85 == session keepalive */ + case 0x85: - /* 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; - } + LOG (("smb_receive_raw: Got SESSION KEEP ALIVE\n")); + goto re_recv; - /* 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; - } + /* 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; - } + memcpy (target, peek_buf, 4); + target += 4; + } - already_read = 0; + 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)); + 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); + result = (-errno); - goto out; - } + goto out; + } - already_read += result; - } + 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) */ + #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; + result = already_read; out: - return result; + return result; } /* smb_receive @@ -971,273 +3384,273 @@ smb_receive_raw (const struct smb_server *server, int sock_fd, unsigned char *ta static int smb_receive (struct smb_server *server, int sock_fd) { - byte * packet = server->packet; - int result; + 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; - } + 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); + 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)); + if (server->rcls != 0) + LOG (("smb_receive: rcls=%ld, err=%ld\n", server->rcls, server->err)); out: - return result; + 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; + unsigned char *inbuf = server->packet; + int total_data; + int total_param; + int result; - LOG (("smb_receive_trans2: enter\n")); + LOG (("smb_receive_trans2: enter\n")); - (*data_len) = (*param_len) = 0; - (*param) = (*data) = NULL; + (*data_len) = (*param_len) = 0; + (*param) = (*data) = NULL; - result = smb_receive (server, sock_fd); - if (result < 0) - goto fail; + result = smb_receive (server, sock_fd); + if (result < 0) + goto fail; - if (server->rcls != 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); + /* 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")); + if ((total_data > server->max_xmit) || (total_param > server->max_xmit)) + { + LOG (("smb_receive_trans2: data/param too long\n")); - result = -EIO; - goto fail; - } + 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")); + /* 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; - } + 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")); + /* 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; - } + result = -ENOMEM; + goto fail; + } + } + else + { + (*param) = NULL; + } - LOG (("smb_rec_trans2: total_data/param: %ld/%ld\n", total_data, total_param)); + 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; - } + 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)); + 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); + (*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 (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)); + 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); + (*data_len) += WVAL (inbuf, smb_drcnt); - LOG (("smb_rec_trans2: drcnt/prcnt: %ld/%ld\n", WVAL (inbuf, smb_drcnt), WVAL (inbuf, smb_prcnt))); + 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; - } + /* 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; + 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; + result = smb_receive (server, sock_fd); + if (result < 0) + goto fail; - if (server->rcls != 0) - { - result = -EIO; - goto fail; - } - } + if (server->rcls != 0) + { + result = -EIO; + goto fail; + } + } - LOG (("smb_receive_trans2: normal exit\n")); - return 0; + LOG (("smb_receive_trans2: normal exit\n")); + return 0; fail: - LOG (("smb_receive_trans2: failed exit\n")); + LOG (("smb_receive_trans2: failed exit\n")); - if((*param) != NULL) - free (*param); + if((*param) != NULL) + free (*param); - if((*data) != NULL) - free (*data); + if((*data) != NULL) + free (*data); - (*param) = (*data) = NULL; + (*param) = (*data) = NULL; - return result; + return result; } int smb_release (struct smb_server *server) { - int result; + int result; - if (server->mount_data.fd >= 0) - CloseSocket (server->mount_data.fd); + 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; - } + server->mount_data.fd = socket (AF_INET, SOCK_STREAM, 0); + if (server->mount_data.fd < 0) + { + result = (-errno); + goto out; + } - result = 0; + result = 0; out: - return result; + return result; } int smb_connect (struct smb_server *server) { - int sock_fd = server->mount_data.fd; - int result; + int sock_fd = server->mount_data.fd; + int result; - if (sock_fd < 0) - { - result = (-EBADF); - goto out; - } + 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); + result = connect (sock_fd, (struct sockaddr *)&server->mount_data.addr, sizeof(struct sockaddr_in)); + if(result < 0) + result = (-errno); out: - return(result); + 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!) + * 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; + 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 ((sock_fd < 0) || (buffer == NULL)) + { + LOG (("smb_request: Bad server!\n")); + result = -EBADF; + goto out; + } - if (server->state != CONN_VALID) - { - result = -EIO; - goto out; - } + if (server->state != CONN_VALID) + { + result = -EIO; + goto out; + } - len = smb_len (buffer) + 4; + len = smb_len (buffer) + 4; - LOG (("smb_request: len = %ld cmd = 0x%lx\n", len, buffer[8])); + 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) */ + #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 = 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); - } + result = (-errno); + } + else + { + result = smb_receive (server, sock_fd); + } out: - if (result < 0) - { - server->state = CONN_INVALID; - smb_invalidate_all_inodes (server); - } + if (result < 0) + { + server->state = CONN_INVALID; + smb_invalidate_all_inodes (server); + } - LOG (("smb_request: result = %ld\n", result)); + LOG (("smb_request: result = %ld\n", result)); - return (result); + return (result); } /* This is not really a trans2 request, we assume that you only have @@ -1245,99 +3658,99 @@ smb_request (struct smb_server *server) 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; + int len, result; + int sock_fd = server->mount_data.fd; + unsigned char *buffer = server->packet; - if (server->state != CONN_VALID) - { - result = -EIO; - goto out; - } + if (server->state != CONN_VALID) + { + result = -EIO; + goto out; + } - len = smb_len (buffer) + 4; + len = smb_len (buffer) + 4; - LOG (("smb_request: len = %ld cmd = 0x%02lx\n", len, buffer[8])); + 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) */ + #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 = 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); - } + 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); - } + if (result < 0) + { + server->state = CONN_INVALID; + smb_invalidate_all_inodes (server); + } - LOG (("smb_trans2_request: result = %ld\n", result)); + LOG (("smb_trans2_request: result = %ld\n", result)); - return 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; + int len, result; + int sock_fd = server->mount_data.fd; + unsigned char *buffer = server->packet; - if (server->state != CONN_VALID) - { - result = -EIO; - goto out; - } + if (server->state != CONN_VALID) + { + result = -EIO; + goto out; + } - len = smb_len (buffer) + 4; + 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)); + 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) */ + #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); + result = send (sock_fd, (void *) buffer, len, 0); - LOG (("smb_request_read_raw: send returned %ld\n", result)); + LOG (("smb_request_read_raw: send returned %ld\n", result)); - if (result < 0) - { - LOG (("smb_request_read_raw: send error = %ld\n", errno)); + 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); - } + 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); - } + if (result < 0) + { + server->state = CONN_INVALID; + smb_invalidate_all_inodes (server); + } - LOG (("smb_request_read_raw: result = %ld\n", result)); + LOG (("smb_request_read_raw: result = %ld\n", result)); - return result; + return result; } /* Source must be in user space. smb_request_write_raw assumes that @@ -1346,55 +3759,55 @@ smb_request_read_raw (struct smb_server *server, unsigned char *target, int max_ 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; + int result; + byte nb_header[4]; + int sock_fd = server->mount_data.fd; - if (server->state != CONN_VALID) - { - result = -EIO; - goto out; - } + if (server->state != CONN_VALID) + { + result = -EIO; + goto out; + } - smb_encode_smb_length (nb_header, length); + 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 *) 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; - } + 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)); + LOG (("smb_request_write_raw: send returned %ld\n", result)); - if (result == length) - result = smb_receive (server, sock_fd); + if (result == length) + result = smb_receive (server, sock_fd); out: - if (result < 0) - { - server->state = CONN_INVALID; + if (result < 0) + { + server->state = CONN_INVALID; - smb_invalidate_all_inodes (server); - } + smb_invalidate_all_inodes (server); + } - if (result > 0) - result = length; + if (result > 0) + result = length; - LOG (("smb_request_write_raw: result = %ld\n", result)); + LOG (("smb_request_write_raw: result = %ld\n", result)); - return result; + return result; }