Commit 50a11af5bddcda9160d84f2ae3577df7451a7a95 - nfstrace

Imported Upstream version 0.4.3.1 Andrew Shadura 7 years ago

203 changed file(s) with 5247 addition(s) and 8259 deletion(s). Raw diff Collapse all Expand all

+94

-0

.clang-format less more

	0	---
	1	Language: Cpp
	2	# BasedOnStyle: Google
	3	AccessModifierOffset: -4
	4	AlignAfterOpenBracket: Align
	5	AlignConsecutiveAssignments: true
	6	AlignConsecutiveDeclarations: true
	7	AlignEscapedNewlinesLeft: true
	8	AlignOperands: true
	9	AlignTrailingComments: true
	10	AllowAllParametersOfDeclarationOnNextLine: true
	11	AllowShortBlocksOnASingleLine: true
	12	AllowShortCaseLabelsOnASingleLine: false
	13	AllowShortFunctionsOnASingleLine: Inline
	14	AllowShortIfStatementsOnASingleLine: true
	15	AllowShortLoopsOnASingleLine: true
	16	AlwaysBreakAfterDefinitionReturnType: None
	17	AlwaysBreakAfterReturnType: None
	18	AlwaysBreakBeforeMultilineStrings: true
	19	AlwaysBreakTemplateDeclarations: true
	20	BinPackArguments: true
	21	BinPackParameters: true
	22	BraceWrapping:
	23	AfterClass: false
	24	AfterControlStatement: false
	25	AfterEnum: false
	26	AfterFunction: false
	27	AfterNamespace: false
	28	AfterObjCDeclaration: false
	29	AfterStruct: false
	30	AfterUnion: false
	31	BeforeCatch: false
	32	BeforeElse: false
	33	IndentBraces: false
	34	BreakBeforeBinaryOperators: None
	35	BreakBeforeBraces: Allman
	36	BreakBeforeTernaryOperators: true
	37	BreakConstructorInitializersBeforeComma: true
	38	BreakAfterJavaFieldAnnotations: false
	39	BreakStringLiterals: true
	40	ColumnLimit: 0
	41	CommentPragmas: '^ IWYU pragma:'
	42	ConstructorInitializerAllOnOneLineOrOnePerLine: false
	43	ConstructorInitializerIndentWidth: 4
	44	ContinuationIndentWidth: 4
	45	Cpp11BracedListStyle: true
	46	DerivePointerAlignment: false
	47	DisableFormat: false
	48	ExperimentalAutoDetectBinPacking: false
	49	ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
	50	IncludeCategories:
	51	- Regex: '^<[a-z]*>' # language headers like <algorithm>
	52	Priority: 1
	53	- Regex: '^<.*\.h>' # platform headers like <unistd.h>
	54	Priority: 2
	55	- Regex: '^<.*' # other external headers
	56	Priority: 3
	57	- Regex: '.*' # any other files
	58	Priority: 4
	59	IndentCaseLabels: false
	60	IndentWidth: 4
	61	IndentWrappedFunctionNames: false
	62	KeepEmptyLinesAtTheStartOfBlocks: false
	63	MacroBlockBegin: ''
	64	MacroBlockEnd: ''
	65	MaxEmptyLinesToKeep: 1
	66	NamespaceIndentation: None
	67	ObjCBlockIndentWidth: 2
	68	ObjCSpaceAfterProperty: false
	69	ObjCSpaceBeforeProtocolList: false
	70	PenaltyBreakBeforeFirstCallParameter: 1
	71	PenaltyBreakComment: 300
	72	PenaltyBreakFirstLessLess: 120
	73	PenaltyBreakString: 1000
	74	PenaltyExcessCharacter: 1000000
	75	PenaltyReturnTypeOnItsOwnLine: 200
	76	PointerAlignment: Left
	77	ReflowComments: true
	78	SortIncludes: true
	79	SpaceAfterCStyleCast: false
	80	SpaceBeforeAssignmentOperators: true
	81	SpaceBeforeParens: Never
	82	SpaceInEmptyParentheses: false
	83	SpacesBeforeTrailingComments: 1
	84	SpacesInAngles: false
	85	SpacesInContainerLiterals: true
	86	SpacesInCStyleCastParentheses: false
	87	SpacesInParentheses: false
	88	SpacesInSquareBrackets: false
	89	Standard: Cpp11
	90	TabWidth: 4
	91	UseTab: Never
	92	...
	93

-0

.gitmodules less more

	0	[submodule "third_party/googletest"]
	1	path = third_party/googletest
	2	url = https://github.com/google/googletest.git

+30

-21

.travis.yml less more

3	3	addons:
4	4	apt:
5	5	packages:
6		- ccache
	6	- ccache
7	7	cache:
8	8	apt: true
9	9	directories:

14	14	env:
15	15	global:
16	16	- DEPS_DIR="$HOME/install"
17		- CMAKE_DIR="$DEPS_DIR/cmake-3.3.2-Linux-x86_64"
18		- CMAKE="$CMAKE_DIR/bin/cmake"
	17	- CMAKE_DIR="$DEPS_DIR/cmake-3.5.2-Linux-x86_64"
	18	- CMAKE="$CMAKE_DIR/bin/cmake"
19	19	- JSON_DIR="$DEPS_DIR/json-c-0.11"
20		- JSON_LIB="$JSON_DIR/install"
	20	- JSON_LIB="$JSON_DIR/install"
21	21	- JSON_INCLUDE_DIR="$JSON_DIR"
22	22	- LCOV_DIR="$DEPS_DIR/lcov-1.11"
23	23	- LCOV="$LCOV_DIR/bin/lcov"
24		- GMOCK_DIR="$DEPS_DIR/gmock-1.7.0"
	24	- GTEST_DIR="$TRAVIS_BUILD_DIR/third_party/googletest"
25	25
26	26	matrix:
27	27	include:
28	28	- os: linux
29		compiler: gcc-4.9
	29	compiler: gcc-6
30	30	addons:
31	31	apt:
32	32	sources: ['ubuntu-toolchain-r-test']
33		packages: ['texlive-latex-base','gcc-4.9','g++-4.9','libpcap-dev','valgrind']
34		env:
	33	packages: ['texlive-latex-base','gcc-6','g++-6','libpcap-dev','valgrind']
	34	env:
35	35	# You can not set CXX directly as Travis CI will overwrite it. You need an intermediate variable like COMPILER
36		- COMPILER=g++-4.9 CXX_FLAGS="-g -O0 -fprofile-arcs -ftest-coverage -fPIC" C_FLAGS="-g -O0 -fprofile-arcs -ftest-coverage" gcov="/usr/bin/gcov-4.9"
	36	- COMPILER=g++-6 CXX_FLAGS="-g -O0 -fprofile-arcs -ftest-coverage -fPIC" C_FLAGS="-g -O0 -fprofile-arcs -ftest-coverage" gcov="/usr/bin/gcov-6"
	37	fast_finish: true
	38	- os: linux
	39	compiler: clang-3.8
	40	addons:
	41	apt:
	42	sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
	43	packages: ['texlive-latex-base','clang-3.8','llvm-3.8-dev','libpcap-dev','valgrind']
	44	env:
	45	- COMPILER=/usr/bin/clang++-3.8 gcov="/usr/bin/gcov-6"
37	46	fast_finish: true
38	47
39	48	before_install:
	49	- git submodule update --init --recursive
40	50	- uname -a
41	51	- pwd
42	52	- export

47	57	- gem install coveralls-lcov
48	58	- \|
49	59	if [ ! -f "$CMAKE" ]; then
50		wget -O - --no-check-certificate https://cmake.org/files/v3.3/cmake-3.3.2-Linux-x86_64.tar.gz \| tar xz && cp -r cmake-3.3.2-Linux-x86_64 $DEPS_DIR
51		else
	60	wget -O - --no-check-certificate https://cmake.org/files/v3.5/cmake-3.5.2-Linux-x86_64.tar.gz \| tar xz && cp -r cmake-3.5.2-Linux-x86_64 $DEPS_DIR
	61	else
52	62	echo "Using cached cmake"
53	63	fi
54	64	- \|
55		if [ ! -f "$GMOCK_DIR/CMakeLists.txt" ]; then
56		wget -q https://googlemock.googlecode.com/files/gmock-1.7.0.zip && unzip gmock-1.7.0.zip -d $DEPS_DIR
57		else
58		echo "Using cached gmock"
59		fi
60	65
61	66	# installing libjson-c from source because #'ondrej/php5-5.6' is disallowed source in travis-ci
62	67	- \|

73	78	else
74	79	echo "Using cached lcov"
75	80	fi
	81
76	82	before_script:
77	83	- $CMAKE --version
78	84	- gcov --version
79		- $LCOV --gcov-tool "/usr/bin/gcov-4.9" --directory . --zerocounters
	85	- $LCOV --gcov-tool "/usr/bin/gcov-6" --directory . --zerocounters
80	86	script:
81	87	- mkdir debug && cd debug
82		- $CMAKE -DCMAKE_CXX_COMPILER="$COMPILER" -DCMAKE_BUILD_TYPE=DEBUG -DGMOCK_SOURCE_DIR=$GMOCK_DIR -D"CMAKE_CXX_FLAGS=$CXX_FLAGS" -DCMAKE_C_FLAGS="$C_FLAGS" -DINCLUDE_COVERAGE_INFO="true" ../
	88	- $CMAKE -DCMAKE_CXX_COMPILER="$COMPILER" -DCMAKE_BUILD_TYPE=DEBUG -DGTEST_SOURCE_DIR=$GTEST_DIR -D"CMAKE_CXX_FLAGS=$CXX_FLAGS" -DCMAKE_C_FLAGS="$C_FLAGS" -DINCLUDE_COVERAGE_INFO="true" ../
83	89	- make
84	90	- make test
85	91	- make documentation-pdflatex
86	92	- ccache -s
87	93
88	94	after_success:
89		- $LCOV --gcov-tool "/usr/bin/gcov-4.9" --compat-libtool --directory . --capture --output-file coverage.info # capture coverage info
90		- $LCOV --gcov-tool "/usr/bin/gcov-4.9" --remove coverage.info 'tests/' '/usr/' 'gmock' --output-file coverage.info # filter out system and test code
91		- coveralls-lcov coverage.info
	95	- \|
	96	if [[ "$COMPILER" == "g++"* ]]; then
	97	$LCOV --gcov-tool "/usr/bin/gcov-6" --compat-libtool --directory . --capture --output-file coverage.info # capture coverage info
	98	$LCOV --gcov-tool "/usr/bin/gcov-6" --remove coverage.info 'tests/' '/usr/' 'gmock' --output-file coverage.info # filter out system and test code
	99	coveralls-lcov coverage.info
	100	fi
92	101	# - coveralls --gcov "$(which "${GCOV}")" --encoding iso-8859-1 \|\| echo 'coveralls upload failed.'
93	102

+12

-0

CHANGELOG.md less more

	0	0.4.3
	1	=====
	2	- Switched to C++14
	3	- GCC updated to version 6; Clang updated to version 3.8
	4	- Fixed calculation of struct's member offset on x32 platform (https://github.com/epam/nfstrace/issues/19)
	5	- Fix unaligned access in buffer copies.
	6
	7	0.4.2
	8	=====
	9	- documentation converted to LaTeX format
	10	- repository was cleaned up via BFG Repo-Cleaner tool (https://rtyley.github.io/bfg-repo-cleaner/) to reduce the size.
	11
0	12	0.4.1
1	13	=====
2	14	- minor bug fixes for Debian platforms;

+14

-14

CMakeLists.txt less more

2	2
3	3	# check compiler and packages ==================================================
4	4	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
5		if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
6		message (FATAL_ERROR "GCC version must be at least 4.8")
	5	if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
	6	message (FATAL_ERROR "GCC version must be at least 5.1")
7	7	endif ()
8	8	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
9		if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.3)
10		message (FATAL_ERROR "Clang version must be at least 3.3")
	9	if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5)
	10	message (FATAL_ERROR "Clang version must be at least 3.5")
11	11	endif ()
12	12	else ()
13	13	message (WARNING "Compilation by ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION} isn't tested")

29	29	endif ()
30	30
31	31	# build application ============================================================
32		set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -pedantic -Wall -Werror -Wextra -fPIC -fvisibility=hidden")
	32	set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -pedantic -Wall -Werror -Wextra -Wno-invalid-offsetof -Wno-braced-scalar-init -fPIC -fvisibility=hidden")
33	33	set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--export-dynamic")
34	34
35	35	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND "${INCLUDE_COVERAGE_INFO}")

46	46
47	47	set (NST_VERSION_FULL "${PROJECT_NAME} ${NST_VERSION} (${CMAKE_BUILD_TYPE})")
48	48
49		string (TIMESTAMP COMPILATION_DATE "%Y-%m-%d")
	49	if (DEFINED ENV{SOURCE_DATE_EPOCH})
	50	execute_process(
	51	COMMAND "date" "-u" "-d" "@$ENV{SOURCE_DATE_EPOCH}" "+%Y-%m-%d"
	52	OUTPUT_VARIABLE COMPILATION_DATE
	53	OUTPUT_STRIP_TRAILING_WHITESPACE)
	54	else ()
	55	string (TIMESTAMP COMPILATION_DATE "%Y-%m-%d")
	56	endif ()
50	57
51	58	include_directories (src)
52	59

104	111	add_subdirectory (docs)
105	112
106	113	# code style ===================================================================
107		find_program (ASTYLE_PATH astyle)
108
109		if (ASTYLE_PATH)
110		add_custom_target (codestyle
111		COMMAND find analyzers src tests -name '.h' -o -name '.cpp' \|
112		xargs ${ASTYLE_PATH} --options=${CMAKE_SOURCE_DIR}/astyle.cfg
113		WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
114		endif ()
	114	include ("cmake/codeformat.cmake")
115	115
116	116	# valgrind reports =============================================================
117	117	include ("cmake/valgrind.cmake")

+13

-8

README.md less more

13	13	filtration, dumping, compression, statistical analysis, visualization and
14	14	provides the API for custom pluggable analysis modules.
15	15
16		`nfstrace` is written in C++11 programming language and currently supports the
	16	`nfstrace` is written in C++ programming language and supports the
17	17	following protocols:
18	18
19	19	- Ethernet
20	20	- IPv4 \| IPv6
21		- UPD \| TCP
	21	- UDP \| TCP
22	22	- NFSv3 \| NFSv4 \| NFSv4.1 \| CIFSv1 \| CIFSv2
23	23
24	24	`nfstrace` has been tested on the following GNU/Linux and FreeBSD systems:
25	25
26	26	- Debian Sid [packages](https://packages.debian.org/unstable/main/nfstrace) [build-logs](https://buildd.debian.org/status/logs.php?pkg=nfstrace)
27		- Fedora 20
	27	- Fedora 23
28	28	- OpenSUSE 13.2
29	29	- Ubuntu 14.04/14.10
30	30	- CentOS 7

48	48	Building
49	49	--------
50	50
51		Since `nfstrace` is written in C++11 you have to use `gcc` >= 4.8 or
52		`clang` >= 3.3. Additionally, you need to install development version of
	51	Since `nfstrace` is written in C++ you have to use `gcc` >= 6 or
	52	`clang` >= 3.8. Additionally, you need to install development version of
53	53	`libpcap` (version 1.3 or newer).
54	54
55		You can build `nfstrace` using [CMake](http://cmake.org) (version 2.8.12 or
	55	You can build `nfstrace` using [CMake](https://cmake.org/cmake/help/v3.5/index.html) (version 2.8.12 or
56	56	newer). From the top level project's directory run:
57	57
58	58	$ mkdir release

69	69
70	70	$ cmake -DCMAKE_INSTALL_PREFIX=/your/path ../
71	71
	72	You can use different build tools, compilers, packaging systems with required parameters.
	73	Please refer to
	74	[CMake](https://cmake.org/cmake/help/v3.3/manual/cmake.1.html),
	75	[CPack](https://cmake.org/cmake/help/v3.3/manual/cpack.1.html) and
	76	[Reference Manuals](https://cmake.org/cmake/help/v3.3/index.html).
	77
72	78
73	79	Installation
74	80	------------
75	81
76		By default `nfstrace` will be installed to `/usr/`.
77		After you build `nfstrace` simply run:
	82	You can install `nfstrace` to default location. After you build `nfstrace` simply run:
78	83
79	84	$ sudo make install
80	85

-1

VERSION less more

0		0.4.2
	0	0.4.3

+14

-16

analyzers/src/breakdown/analyzer.cpp less more

44	44	}
45	45	};
46	46
47		extern "C"
	47	extern "C" {
	48	const char* usage()
48	49	{
	50	return "No options";
	51	}
49	52
50		const char* usage()
51		{
52		return "No options";
53		}
	53	IAnalyzer* create(const char*)
	54	{
	55	return new Analyzer();
	56	}
54	57
55		IAnalyzer* create(const char*)
56		{
57		return new Analyzer();
58		}
	58	void destroy(IAnalyzer* instance)
	59	{
	60	delete instance;
	61	}
59	62
60		void destroy(IAnalyzer* instance)
61		{
62		delete instance;
63		}
	63	NST_PLUGIN_ENTRY_POINTS(&usage, &create, &destroy, nullptr)
64	64
65		NST_PLUGIN_ENTRY_POINTS (&usage, &create, &destroy, nullptr)
66
67		}//extern "C"
	65	} //extern "C"
68	66	//------------------------------------------------------------------------------

-3

analyzers/src/breakdown/breakdowncounter.cpp less more

25	25	//------------------------------------------------------------------------------
26	26	using namespace NST::breakdown;
27	27	//------------------------------------------------------------------------------
28		BreakdownCounter::BreakdownCounter(size_t count) : latencies(count, NST::breakdown::Latencies())
	28	BreakdownCounter::BreakdownCounter(size_t count)
	29	: latencies(count, NST::breakdown::Latencies())
29	30	{
30	31	}
31	32

40	41
41	42	uint64_t BreakdownCounter::get_total_count() const
42	43	{
43		return std::accumulate(std::begin(latencies), std::end(latencies), 0, [](int sum, const NST::breakdown::Latencies & latency)
44		{
	44	return std::accumulate(std::begin(latencies), std::end(latencies), 0, [](int sum, const NST::breakdown::Latencies& latency) {
45	45	return sum + latency.get_count();
46	46	});
47	47	}

-3

analyzers/src/breakdown/breakdowncounter.h less more

52	52	* \brief get_total_count returns total amount of commands
53	53	* \return commands count
54	54	*/
55		uint64_t get_total_count () const;
	55	uint64_t get_total_count() const;
56	56
57	57	private:
58		void operator= (const BreakdownCounter&) = delete;
	58	void operator=(const BreakdownCounter&) = delete;
59	59	std::vector<NST::breakdown::Latencies> latencies;
60	60	};
61	61	//------------------------------------------------------------------------------
62		#endif//BREAKDOWNCOUNTER_H
	62	#endif //BREAKDOWNCOUNTER_H
63	63	//------------------------------------------------------------------------------

-1

analyzers/src/breakdown/cifsv1breakdownanalyzer.cpp less more

18	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
19	19	*/
20	20	//------------------------------------------------------------------------------
	21	#include "cifsv1breakdownanalyzer.h"
21	22	#include "cifsv1commands.h"
22		#include "cifsv1breakdownanalyzer.h"
23	23	//------------------------------------------------------------------------------
24	24	using namespace NST::breakdown;
25	25	//------------------------------------------------------------------------------

-3

analyzers/src/breakdown/cifsv1breakdownanalyzer.h less more

30	30	{
31	31	namespace breakdown
32	32	{
33
34	33	/*! \class Analyzer for CIFS v1
35	34	* Handles CIFS v1 commands
36	35	*/
37	36	class CIFSBreakdownAnalyzer : virtual public IAnalyzer
38	37	{
39		Statistics statistics; //!< Statistics
	38	Statistics statistics; //!< Statistics
40	39	Representer representer; //!< Class for statistics representation
41	40	public:
42	41	CIFSBreakdownAnalyzer(std::ostream& o = std::cout);

116	115	void writeBulkDataSMBv1(const SMBv1::WriteBulkDataCommand* cmd, const SMBv1::WriteBulkDataArgumentType, const SMBv1::WriteBulkDataResultType) override final;
117	116	void invalidSMBv1(const SMBv1::InvalidCommand* cmd, const SMBv1::InvalidArgumentType, const SMBv1::InvalidResultType) override final;
118	117	void noAndxCommandSMBv1(const SMBv1::NoAndxCommand* cmd, const SMBv1::NoAndxCmdArgumentType, const SMBv1::NoAndxCmdResultType) override final;
	118
119	119	protected:
120	120	void flush_statistics() override;
121	121	};

123	123	} // namespace breakdown
124	124	} // namespace NST
125	125	//------------------------------------------------------------------------------
126		#endif//CIFSBREAKDOWNANALYZER_H
	126	#endif //CIFSBREAKDOWNANALYZER_H
127	127	//------------------------------------------------------------------------------

-4

analyzers/src/breakdown/cifsv1commands.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/*!
32	31	* Represents CIFS v1 commands
33	32	* Converts commands to string

36	35	{
37	36	const char* command_description(int cmd_code) override final;
38	37	const char* command_name(int cmd_code) override final;
39		size_t commands_count();
40		const char* protocol_name();
	38	size_t commands_count() override final;
	39	const char* protocol_name() override final;
41	40	};
42	41	} // namespace breakdown
43	42	} // namespace NST
44	43	//------------------------------------------------------------------------------
45		#endif//CIFS_COMMANDS_H
	44	#endif //CIFS_COMMANDS_H
46	45	//------------------------------------------------------------------------------

-3

analyzers/src/breakdown/cifsv2breakdownanalyzer.h less more

30	30	{
31	31	namespace breakdown
32	32	{
33
34	33	/*! \class Analyzer for CIFS v2
35	34	* Handles CIFS v2 commands
36	35	*/
37	36	class CIFSv2BreakdownAnalyzer : virtual public IAnalyzer
38	37	{
39		Statistics stats; //!< Statistics
	38	Statistics stats; //!< Statistics
40	39	Representer cifs2Representer; //!< Class for statistics representation
41	40	public:
42	41	CIFSv2BreakdownAnalyzer(std::ostream& o = std::cout);

59	58	void queryInfoSMBv2(const SMBv2::QueryInfoCommand* cmd, const SMBv2::QueryInfoRequest, const SMBv2::QueryInfoResponse) override final;
60	59	void setInfoSMBv2(const SMBv2::SetInfoCommand* cmd, const SMBv2::SetInfoRequest, const SMBv2::SetInfoResponse) override final;
61	60	void breakOplockSMBv2(const SMBv2::BreakOpLockCommand* cmd, const SMBv2::OplockAcknowledgment, const SMBv2::OplockResponse) override final;
	61
62	62	protected:
63	63	void flush_statistics() override;
64	64	};

66	66	} // namespace breakdown
67	67	} // namespace NST
68	68	//------------------------------------------------------------------------------
69		#endif//CIFSV2BREAKDOWNANALYZER_H
	69	#endif //CIFSV2BREAKDOWNANALYZER_H
70	70	//------------------------------------------------------------------------------

+40

-40

analyzers/src/breakdown/cifsv2commands.cpp less more

28	28	const char* NST::breakdown::SMBv2Commands::command_name(int cmd_code)
29	29	{
30	30	static std::map<Commands, const char*> cmdNames;
31		if (cmdNames.empty())
	31	if(cmdNames.empty())
32	32	{
33		cmdNames[Commands::NEGOTIATE] = "NEGOTIATE";
34		cmdNames[Commands::SESSION_SETUP] = "SESSION SETUP";
35		cmdNames[Commands::LOGOFF] = "LOGOFF";
36		cmdNames[Commands::TREE_CONNECT] = "TREE CONNECT";
37		cmdNames[Commands::TREE_DISCONNECT] = "TREE DISCONNECT";
38		cmdNames[Commands::CREATE] = "CREATE";
39		cmdNames[Commands::CLOSE] = "CLOSE";
40		cmdNames[Commands::FLUSH] = "FLUSH";
41		cmdNames[Commands::READ] = "READ";
42		cmdNames[Commands::WRITE] = "WRITE";
43		cmdNames[Commands::LOCK] = "LOCK";
44		cmdNames[Commands::IOCTL] = "IOCTL";
45		cmdNames[Commands::CANCEL] = "CANCEL";
46		cmdNames[Commands::ECHO] = "ECHO";
47		cmdNames[Commands::QUERY_DIRECTORY] = "QUERY DIRECTORY";
48		cmdNames[Commands::CHANGE_NOTIFY] = "CHANGE NOTIFY";
49		cmdNames[Commands::QUERY_INFO] = "QUERY INFO";
50		cmdNames[Commands::SET_INFO] = "SET INFO";
51		cmdNames[Commands::OPLOCK_BREAK] = "OPLOCK BREAK";
	33	cmdNames[Commands::NEGOTIATE] = "NEGOTIATE";
	34	cmdNames[Commands::SESSION_SETUP] = "SESSION SETUP";
	35	cmdNames[Commands::LOGOFF] = "LOGOFF";
	36	cmdNames[Commands::TREE_CONNECT] = "TREE CONNECT";
	37	cmdNames[Commands::TREE_DISCONNECT] = "TREE DISCONNECT";
	38	cmdNames[Commands::CREATE] = "CREATE";
	39	cmdNames[Commands::CLOSE] = "CLOSE";
	40	cmdNames[Commands::FLUSH] = "FLUSH";
	41	cmdNames[Commands::READ] = "READ";
	42	cmdNames[Commands::WRITE] = "WRITE";
	43	cmdNames[Commands::LOCK] = "LOCK";
	44	cmdNames[Commands::IOCTL] = "IOCTL";
	45	cmdNames[Commands::CANCEL] = "CANCEL";
	46	cmdNames[Commands::ECHO] = "ECHO";
	47	cmdNames[Commands::QUERY_DIRECTORY] = "QUERY DIRECTORY";
	48	cmdNames[Commands::CHANGE_NOTIFY] = "CHANGE NOTIFY";
	49	cmdNames[Commands::QUERY_INFO] = "QUERY INFO";
	50	cmdNames[Commands::SET_INFO] = "SET INFO";
	51	cmdNames[Commands::OPLOCK_BREAK] = "OPLOCK BREAK";
52	52	}
53	53	return cmdNames[static_cast<Commands>(cmd_code)];
54	54	}

61	61	const char* NST::breakdown::SMBv2Commands::command_description(int cmd_code)
62	62	{
63	63	static std::map<Commands, const char*> cmdNames;
64		if (cmdNames.empty())
	64	if(cmdNames.empty())
65	65	{
66		cmdNames[Commands::NEGOTIATE] = "NEGOTIATE";
67		cmdNames[Commands::SESSION_SETUP] = "SESSION_SETUP";
68		cmdNames[Commands::LOGOFF] = "LOGOFF";
69		cmdNames[Commands::TREE_CONNECT] = "TREE_CONNECT";
70		cmdNames[Commands::TREE_DISCONNECT] = "TREE_DISCONNECT";
71		cmdNames[Commands::CREATE] = "CREATE";
72		cmdNames[Commands::CLOSE] = "CLOSE";
73		cmdNames[Commands::FLUSH] = "FLUSH";
74		cmdNames[Commands::READ] = "READ";
75		cmdNames[Commands::WRITE] = "WRITE";
76		cmdNames[Commands::LOCK] = "LOCK";
77		cmdNames[Commands::IOCTL] = "IOCTL";
78		cmdNames[Commands::CANCEL] = "CANCEL";
79		cmdNames[Commands::ECHO] = "ECHO";
80		cmdNames[Commands::QUERY_DIRECTORY] = "QUERY_DIRECTORY";
81		cmdNames[Commands::CHANGE_NOTIFY] = "CHANGE_NOTIFY";
82		cmdNames[Commands::QUERY_INFO] = "QUERY_INFO";
83		cmdNames[Commands::SET_INFO] = "SET_INFO";
84		cmdNames[Commands::OPLOCK_BREAK] = "OPLOCK_BREAK";
	66	cmdNames[Commands::NEGOTIATE] = "NEGOTIATE";
	67	cmdNames[Commands::SESSION_SETUP] = "SESSION_SETUP";
	68	cmdNames[Commands::LOGOFF] = "LOGOFF";
	69	cmdNames[Commands::TREE_CONNECT] = "TREE_CONNECT";
	70	cmdNames[Commands::TREE_DISCONNECT] = "TREE_DISCONNECT";
	71	cmdNames[Commands::CREATE] = "CREATE";
	72	cmdNames[Commands::CLOSE] = "CLOSE";
	73	cmdNames[Commands::FLUSH] = "FLUSH";
	74	cmdNames[Commands::READ] = "READ";
	75	cmdNames[Commands::WRITE] = "WRITE";
	76	cmdNames[Commands::LOCK] = "LOCK";
	77	cmdNames[Commands::IOCTL] = "IOCTL";
	78	cmdNames[Commands::CANCEL] = "CANCEL";
	79	cmdNames[Commands::ECHO] = "ECHO";
	80	cmdNames[Commands::QUERY_DIRECTORY] = "QUERY_DIRECTORY";
	81	cmdNames[Commands::CHANGE_NOTIFY] = "CHANGE_NOTIFY";
	82	cmdNames[Commands::QUERY_INFO] = "QUERY_INFO";
	83	cmdNames[Commands::SET_INFO] = "SET_INFO";
	84	cmdNames[Commands::OPLOCK_BREAK] = "OPLOCK_BREAK";
85	85	}
86	86	return cmdNames[static_cast<Commands>(cmd_code)];
87	87	}

-4

analyzers/src/breakdown/cifsv2commands.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/*!
32	31	* Represents CIFS v2 commands
33	32	* Converts commands to string

65	64
66	65	const char* command_name(int cmd_code) override final;
67	66
68		size_t commands_count();
	67	size_t commands_count() override final;
69	68
70		const char* protocol_name();
	69	const char* protocol_name() override final;
71	70	};
72	71
73	72	} // namespace breakdown
74	73	} // namespace NST
75	74	//------------------------------------------------------------------------------
76		#endif//CIFS2_COMMANDS_H
	75	#endif //CIFS2_COMMANDS_H
77	76	//------------------------------------------------------------------------------

-2

analyzers/src/breakdown/commandrepresenter.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/*!
32	31	* \brief The CommandRepresenter struct represents interface for command representers
33	32	* Commands representer should be able to convert commands to string

66	65	} // namespace breakdown
67	66	} // namespace NST
68	67	//------------------------------------------------------------------------------
69		#endif//COMMANDREPRESENTER_H
	68	#endif //COMMANDREPRESENTER_H
70	69	//------------------------------------------------------------------------------

-6

analyzers/src/breakdown/latencies.cpp less more

25	25	using namespace NST::breakdown;
26	26	//------------------------------------------------------------------------------
27	27
28		Latencies::Latencies() : count {0}, avg {0}, m2 {0}
	28	Latencies::Latencies()
	29	: count{0}
	30	, avg{0}
	31	, m2{0}
29	32	{
30	33	timerclear(&min);
31	34	timerclear(&max);

33	36
34	37	void Latencies::add(const timeval& t)
35	38	{
36		long double x = to_sec(t);
	39	long double x = to_sec(t);
37	40	long double delta = x - avg;
38	41	avg += delta / (++count);
39	42	m2 += delta * (x - avg);

53	56
54	57	long double Latencies::get_st_dev() const
55	58	{
56		if (count < 2)
	59	if(count < 2)
57	60	{
58	61	return 0;
59	62	}

72	75
73	76	void Latencies::set_range(const timeval& t)
74	77	{
75		if (timercmp(&t, &min, < ))
	78	if(timercmp(&t, &min, <))
76	79	{
77	80	min = t;
78	81	}
79		if (min.tv_sec == 0 && min.tv_usec == 0)
	82	if(min.tv_sec == 0 && min.tv_usec == 0)
80	83	{
81	84	min = t;
82	85	}
83		if (timercmp(&t, &max, > ))
	86	if(timercmp(&t, &max, >))
84	87	{
85	88	max = t;
86	89	}

-3

analyzers/src/breakdown/latencies.h less more

29	29	{
30	30	namespace breakdown
31	31	{
32
33	32	/*!
34	33	* \brief Latencies calculates latencies
35	34	*/

81	80	timeval min;
82	81	timeval max;
83	82
84		uint64_t count;
	83	uint64_t count;
85	84	long double avg;
86	85	long double m2;
87	86	};

96	95	} // namespace breakdown
97	96	} // namespace NST
98	97	//------------------------------------------------------------------------------
99		#endif//LATENCIES_H
	98	#endif //LATENCIES_H
100	99	//------------------------------------------------------------------------------

-2

analyzers/src/breakdown/nfsv3breakdownanalyzer.cpp less more

18	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
19	19	*/
20	20	//------------------------------------------------------------------------------
	21	#include "nfsv3breakdownanalyzer.h"
21	22	#include "breakdowncounter.h"
22		#include "nfsv3breakdownanalyzer.h"
23	23	#include "nfsv3commands.h"
24	24	//------------------------------------------------------------------------------
25	25	using namespace NST::breakdown;

100	100	stats.account(proc, proc->call.ru.RM_cmb.cb_proc);
101	101	}
102	102
103
104	103	void NFSv3BreakdownAnalyzer::rename3(const RPCProcedure* proc, const NFS3::RENAME3args, const NFS3::RENAME3res)
105	104	{
106	105	stats.account(proc, proc->call.ru.RM_cmb.cb_proc);

-3

analyzers/src/breakdown/nfsv3breakdownanalyzer.h less more

30	30	{
31	31	namespace breakdown
32	32	{
33
34	33	/*! \brief NFSv3BreakdownAnalyzer Analyzer for NFS v3
35	34	* Handles NFS v3 commands
36	35	*/
37	36	class NFSv3BreakdownAnalyzer : virtual public IAnalyzer
38	37	{
39		Statistics stats; //!< Statistics
	38	Statistics stats; //!< Statistics
40	39	Representer representer; //!< Class for statistics representation
41	40	public:
42	41	NFSv3BreakdownAnalyzer(std::ostream& o = std::cout);

114	113	} // namespace breakdown
115	114	} // namespace NST
116	115	//------------------------------------------------------------------------------
117		#endif//NFSV3BREAKDOWNANALYZER_H
	116	#endif //NFSV3BREAKDOWNANALYZER_H
118	117	//------------------------------------------------------------------------------

-4

analyzers/src/breakdown/nfsv3commands.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/*!
32	31	* Represents NFS v3 commands
33	32	* Converts commands to string

37	36	public:
38	37	const char* command_description(int cmd_code) override final;
39	38	const char* command_name(int cmd_code) override final;
40		size_t commands_count() override final;
41		const char* protocol_name();
	39	size_t commands_count() override final;
	40	const char* protocol_name() override final;
42	41	};
43	42
44	43	} // namespace breakdown
45	44	} // namespace NST
46	45	//------------------------------------------------------------------------------
47		#endif//NFSV3COMMANDS_H
	46	#endif //NFSV3COMMANDS_H
48	47	//------------------------------------------------------------------------------

+57

-57

analyzers/src/breakdown/nfsv41breakdownanalyzer.cpp less more

41	41
42	42	void NFSv41BreakdownAnalyzer::access41(const RPCProcedure* proc, const NFS41::ACCESS4args, const NFS41::ACCESS4res res)
43	43	{
44		if (res)
	44	if(res)
45	45	{
46	46	stats.account(proc, ProcEnumNFS41::NFSProcedure::ACCESS);
47	47	}

49	49
50	50	void NFSv41BreakdownAnalyzer::close41(const RPCProcedure* proc, const NFS41::CLOSE4args, const NFS41::CLOSE4res res)
51	51	{
52		if (res)
	52	if(res)
53	53	{
54	54	stats.account(proc, ProcEnumNFS41::NFSProcedure::CLOSE);
55	55	}

57	57
58	58	void NFSv41BreakdownAnalyzer::commit41(const RPCProcedure* proc, const NFS41::COMMIT4args, const NFS41::COMMIT4res res)
59	59	{
60		if (res)
	60	if(res)
61	61	{
62	62	stats.account(proc, ProcEnumNFS41::NFSProcedure::COMMIT);
63	63	}

65	65
66	66	void NFSv41BreakdownAnalyzer::create41(const RPCProcedure* proc, const NFS41::CREATE4args, const NFS41::CREATE4res res)
67	67	{
68		if (res)
	68	if(res)
69	69	{
70	70	stats.account(proc, ProcEnumNFS41::NFSProcedure::CREATE);
71	71	}

73	73
74	74	void NFSv41BreakdownAnalyzer::delegpurge41(const RPCProcedure* proc, const NFS41::DELEGPURGE4args, const NFS41::DELEGPURGE4res res)
75	75	{
76		if (res)
	76	if(res)
77	77	{
78	78	stats.account(proc, ProcEnumNFS41::NFSProcedure::DELEGPURGE);
79	79	}

81	81
82	82	void NFSv41BreakdownAnalyzer::delegreturn41(const RPCProcedure* proc, const NFS41::DELEGRETURN4args, const NFS41::DELEGRETURN4res res)
83	83	{
84		if (res)
	84	if(res)
85	85	{
86	86	stats.account(proc, ProcEnumNFS41::NFSProcedure::DELEGRETURN);
87	87	}

89	89
90	90	void NFSv41BreakdownAnalyzer::getattr41(const RPCProcedure* proc, const NFS41::GETATTR4args, const NFS41::GETATTR4res res)
91	91	{
92		if (res)
	92	if(res)
93	93	{
94	94	stats.account(proc, ProcEnumNFS41::NFSProcedure::GETATTR);
95	95	}

97	97
98	98	void NFSv41BreakdownAnalyzer::getfh41(const RPCProcedure* proc, const NFS41::GETFH4res* res)
99	99	{
100		if (res)
	100	if(res)
101	101	{
102	102	stats.account(proc, ProcEnumNFS41::NFSProcedure::GETFH);
103	103	}

105	105
106	106	void NFSv41BreakdownAnalyzer::link41(const RPCProcedure* proc, const NFS41::LINK4args, const NFS41::LINK4res res)
107	107	{
108		if (res)
	108	if(res)
109	109	{
110	110	stats.account(proc, ProcEnumNFS41::NFSProcedure::LINK);
111	111	}

113	113
114	114	void NFSv41BreakdownAnalyzer::lock41(const RPCProcedure* proc, const NFS41::LOCK4args, const NFS41::LOCK4res res)
115	115	{
116		if (res)
	116	if(res)
117	117	{
118	118	stats.account(proc, ProcEnumNFS41::NFSProcedure::LOCK);
119	119	}

121	121
122	122	void NFSv41BreakdownAnalyzer::lockt41(const RPCProcedure* proc, const NFS41::LOCKT4args, const NFS41::LOCKT4res res)
123	123	{
124		if (res)
	124	if(res)
125	125	{
126	126	stats.account(proc, ProcEnumNFS41::NFSProcedure::LOCKT);
127	127	}

129	129
130	130	void NFSv41BreakdownAnalyzer::locku41(const RPCProcedure* proc, const NFS41::LOCKU4args, const NFS41::LOCKU4res res)
131	131	{
132		if (res)
	132	if(res)
133	133	{
134	134	stats.account(proc, ProcEnumNFS41::NFSProcedure::LOCKU);
135	135	}

137	137
138	138	void NFSv41BreakdownAnalyzer::lookup41(const RPCProcedure* proc, const NFS41::LOOKUP4args, const NFS41::LOOKUP4res res)
139	139	{
140		if (res)
	140	if(res)
141	141	{
142	142	stats.account(proc, ProcEnumNFS41::NFSProcedure::LOOKUP);
143	143	}

145	145
146	146	void NFSv41BreakdownAnalyzer::lookupp41(const RPCProcedure* proc, const NFS41::LOOKUPP4res* res)
147	147	{
148		if (res)
	148	if(res)
149	149	{
150	150	stats.account(proc, ProcEnumNFS41::NFSProcedure::LOOKUPP);
151	151	}

153	153
154	154	void NFSv41BreakdownAnalyzer::nverify41(const RPCProcedure* proc, const NFS41::NVERIFY4args, const NFS41::NVERIFY4res res)
155	155	{
156		if (res)
	156	if(res)
157	157	{
158	158	stats.account(proc, ProcEnumNFS41::NFSProcedure::NVERIFY);
159	159	}

161	161
162	162	void NFSv41BreakdownAnalyzer::open41(const RPCProcedure* proc, const NFS41::OPEN4args, const NFS41::OPEN4res res)
163	163	{
164		if (res)
	164	if(res)
165	165	{
166	166	stats.account(proc, ProcEnumNFS41::NFSProcedure::OPEN);
167	167	}

169	169
170	170	void NFSv41BreakdownAnalyzer::openattr41(const RPCProcedure* proc, const NFS41::OPENATTR4args, const NFS41::OPENATTR4res res)
171	171	{
172		if (res)
	172	if(res)
173	173	{
174	174	stats.account(proc, ProcEnumNFS41::NFSProcedure::OPENATTR);
175	175	}

177	177
178	178	void NFSv41BreakdownAnalyzer::open_confirm41(const RPCProcedure* proc, const NFS41::OPEN_CONFIRM4args, const NFS41::OPEN_CONFIRM4res res)
179	179	{
180		if (res)
	180	if(res)
181	181	{
182	182	stats.account(proc, ProcEnumNFS41::NFSProcedure::OPEN_CONFIRM);
183	183	}

185	185
186	186	void NFSv41BreakdownAnalyzer::open_downgrade41(const RPCProcedure* proc, const NFS41::OPEN_DOWNGRADE4args, const NFS41::OPEN_DOWNGRADE4res res)
187	187	{
188		if (res)
	188	if(res)
189	189	{
190	190	stats.account(proc, ProcEnumNFS41::NFSProcedure::OPEN_DOWNGRADE);
191	191	}

193	193
194	194	void NFSv41BreakdownAnalyzer::putfh41(const RPCProcedure* proc, const NFS41::PUTFH4args, const NFS41::PUTFH4res res)
195	195	{
196		if (res)
	196	if(res)
197	197	{
198	198	stats.account(proc, ProcEnumNFS41::NFSProcedure::PUTFH);
199	199	}

201	201
202	202	void NFSv41BreakdownAnalyzer::putpubfh41(const RPCProcedure* proc, const NFS41::PUTPUBFH4res* res)
203	203	{
204		if (res)
	204	if(res)
205	205	{
206	206	stats.account(proc, ProcEnumNFS41::NFSProcedure::PUTPUBFH);
207	207	}

209	209
210	210	void NFSv41BreakdownAnalyzer::putrootfh41(const RPCProcedure* proc, const NFS41::PUTROOTFH4res* res)
211	211	{
212		if (res)
	212	if(res)
213	213	{
214	214	stats.account(proc, ProcEnumNFS41::NFSProcedure::PUTROOTFH);
215	215	}

217	217
218	218	void NFSv41BreakdownAnalyzer::read41(const RPCProcedure* proc, const NFS41::READ4args, const NFS41::READ4res res)
219	219	{
220		if (res)
	220	if(res)
221	221	{
222	222	stats.account(proc, ProcEnumNFS41::NFSProcedure::READ);
223	223	}

225	225
226	226	void NFSv41BreakdownAnalyzer::readdir41(const RPCProcedure* proc, const NFS41::READDIR4args, const NFS41::READDIR4res res)
227	227	{
228		if (res)
	228	if(res)
229	229	{
230	230	stats.account(proc, ProcEnumNFS41::NFSProcedure::READDIR);
231	231	}

233	233
234	234	void NFSv41BreakdownAnalyzer::readlink41(const RPCProcedure* proc, const NFS41::READLINK4res* res)
235	235	{
236		if (res)
	236	if(res)
237	237	{
238	238	stats.account(proc, ProcEnumNFS41::NFSProcedure::READLINK);
239	239	}

241	241
242	242	void NFSv41BreakdownAnalyzer::remove41(const RPCProcedure* proc, const NFS41::REMOVE4args, const NFS41::REMOVE4res res)
243	243	{
244		if (res)
	244	if(res)
245	245	{
246	246	stats.account(proc, ProcEnumNFS41::NFSProcedure::REMOVE);
247	247	}

249	249
250	250	void NFSv41BreakdownAnalyzer::rename41(const RPCProcedure* proc, const NFS41::RENAME4args, const NFS41::RENAME4res res)
251	251	{
252		if (res)
	252	if(res)
253	253	{
254	254	stats.account(proc, ProcEnumNFS41::NFSProcedure::RENAME);
255	255	}

257	257
258	258	void NFSv41BreakdownAnalyzer::renew41(const RPCProcedure* proc, const NFS41::RENEW4args, const NFS41::RENEW4res res)
259	259	{
260		if (res)
	260	if(res)
261	261	{
262	262	stats.account(proc, ProcEnumNFS41::NFSProcedure::RENEW);
263	263	}

265	265
266	266	void NFSv41BreakdownAnalyzer::restorefh41(const RPCProcedure* proc, const NFS41::RESTOREFH4res* res)
267	267	{
268		if (res)
	268	if(res)
269	269	{
270	270	stats.account(proc, ProcEnumNFS41::NFSProcedure::RESTOREFH);
271	271	}

273	273
274	274	void NFSv41BreakdownAnalyzer::savefh41(const RPCProcedure* proc, const NFS41::SAVEFH4res* res)
275	275	{
276		if (res)
	276	if(res)
277	277	{
278	278	stats.account(proc, ProcEnumNFS41::NFSProcedure::SAVEFH);
279	279	}

281	281
282	282	void NFSv41BreakdownAnalyzer::secinfo41(const RPCProcedure* proc, const NFS41::SECINFO4args, const NFS41::SECINFO4res res)
283	283	{
284		if (res)
	284	if(res)
285	285	{
286	286	stats.account(proc, ProcEnumNFS41::NFSProcedure::SECINFO);
287	287	}

289	289
290	290	void NFSv41BreakdownAnalyzer::setattr41(const RPCProcedure* proc, const NFS41::SETATTR4args, const NFS41::SETATTR4res res)
291	291	{
292		if (res)
	292	if(res)
293	293	{
294	294	stats.account(proc, ProcEnumNFS41::NFSProcedure::SETATTR);
295	295	}

297	297
298	298	void NFSv41BreakdownAnalyzer::setclientid41(const RPCProcedure* proc, const NFS41::SETCLIENTID4args, const NFS41::SETCLIENTID4res res)
299	299	{
300		if (res)
	300	if(res)
301	301	{
302	302	stats.account(proc, ProcEnumNFS41::NFSProcedure::SETCLIENTID);
303	303	}

305	305
306	306	void NFSv41BreakdownAnalyzer::setclientid_confirm41(const RPCProcedure* proc, const NFS41::SETCLIENTID_CONFIRM4args, const NFS41::SETCLIENTID_CONFIRM4res res)
307	307	{
308		if (res)
	308	if(res)
309	309	{
310	310	stats.account(proc, ProcEnumNFS41::NFSProcedure::SETCLIENTID_CONFIRM);
311	311	}

313	313
314	314	void NFSv41BreakdownAnalyzer::verify41(const RPCProcedure* proc, const NFS41::VERIFY4args, const NFS41::VERIFY4res res)
315	315	{
316		if (res)
	316	if(res)
317	317	{
318	318	stats.account(proc, ProcEnumNFS41::NFSProcedure::VERIFY);
319	319	}

321	321
322	322	void NFSv41BreakdownAnalyzer::write41(const RPCProcedure* proc, const NFS41::WRITE4args, const NFS41::WRITE4res res)
323	323	{
324		if (res)
	324	if(res)
325	325	{
326	326	stats.account(proc, ProcEnumNFS41::NFSProcedure::WRITE);
327	327	}

329	329
330	330	void NFSv41BreakdownAnalyzer::release_lockowner41(const RPCProcedure* proc, const NFS41::RELEASE_LOCKOWNER4args, const NFS41::RELEASE_LOCKOWNER4res res)
331	331	{
332		if (res)
	332	if(res)
333	333	{
334	334	stats.account(proc, ProcEnumNFS41::NFSProcedure::RELEASE_LOCKOWNER);
335	335	}

337	337
338	338	void NFSv41BreakdownAnalyzer::backchannel_ctl41(const RPCProcedure* proc, const NFS41::BACKCHANNEL_CTL4args, const NFS41::BACKCHANNEL_CTL4res res)
339	339	{
340		if (res)
	340	if(res)
341	341	{
342	342	stats.account(proc, ProcEnumNFS41::NFSProcedure::BACKCHANNEL_CTL);
343	343	}

345	345
346	346	void NFSv41BreakdownAnalyzer::bind_conn_to_session41(const RPCProcedure* proc, const NFS41::BIND_CONN_TO_SESSION4args, const NFS41::BIND_CONN_TO_SESSION4res res)
347	347	{
348		if (res)
	348	if(res)
349	349	{
350	350	stats.account(proc, ProcEnumNFS41::NFSProcedure::BIND_CONN_TO_SESSION);
351	351	}

353	353
354	354	void NFSv41BreakdownAnalyzer::exchange_id41(const RPCProcedure* proc, const NFS41::EXCHANGE_ID4args, const NFS41::EXCHANGE_ID4res res)
355	355	{
356		if (res)
	356	if(res)
357	357	{
358	358	stats.account(proc, ProcEnumNFS41::NFSProcedure::EXCHANGE_ID);
359	359	}

361	361
362	362	void NFSv41BreakdownAnalyzer::create_session41(const RPCProcedure* proc, const NFS41::CREATE_SESSION4args, const NFS41::CREATE_SESSION4res res)
363	363	{
364		if (res)
	364	if(res)
365	365	{
366	366	stats.account(proc, ProcEnumNFS41::NFSProcedure::CREATE_SESSION);
367	367	}

369	369
370	370	void NFSv41BreakdownAnalyzer::destroy_session41(const RPCProcedure* proc, const NFS41::DESTROY_SESSION4args, const NFS41::DESTROY_SESSION4res res)
371	371	{
372		if (res)
	372	if(res)
373	373	{
374	374	stats.account(proc, ProcEnumNFS41::NFSProcedure::DESTROY_SESSION);
375	375	}

377	377
378	378	void NFSv41BreakdownAnalyzer::free_stateid41(const RPCProcedure* proc, const NFS41::FREE_STATEID4args, const NFS41::FREE_STATEID4res res)
379	379	{
380		if (res)
	380	if(res)
381	381	{
382	382	stats.account(proc, ProcEnumNFS41::NFSProcedure::FREE_STATEID);
383	383	}

385	385
386	386	void NFSv41BreakdownAnalyzer::get_dir_delegation41(const RPCProcedure* proc, const NFS41::GET_DIR_DELEGATION4args, const NFS41::GET_DIR_DELEGATION4res res)
387	387	{
388		if (res)
	388	if(res)
389	389	{
390	390	stats.account(proc, ProcEnumNFS41::NFSProcedure::GET_DIR_DELEGATION);
391	391	}

393	393
394	394	void NFSv41BreakdownAnalyzer::getdeviceinfo41(const RPCProcedure* proc, const NFS41::GETDEVICEINFO4args, const NFS41::GETDEVICEINFO4res res)
395	395	{
396		if (res)
	396	if(res)
397	397	{
398	398	stats.account(proc, ProcEnumNFS41::NFSProcedure::GETDEVICEINFO);
399	399	}

401	401
402	402	void NFSv41BreakdownAnalyzer::getdevicelist41(const RPCProcedure* proc, const NFS41::GETDEVICELIST4args, const NFS41::GETDEVICELIST4res res)
403	403	{
404		if (res)
	404	if(res)
405	405	{
406	406	stats.account(proc, ProcEnumNFS41::NFSProcedure::GETDEVICELIST);
407	407	}

409	409
410	410	void NFSv41BreakdownAnalyzer::layoutcommit41(const RPCProcedure* proc, const NFS41::LAYOUTCOMMIT4args, const NFS41::LAYOUTCOMMIT4res res)
411	411	{
412		if (res)
	412	if(res)
413	413	{
414	414	stats.account(proc, ProcEnumNFS41::NFSProcedure::LAYOUTCOMMIT);
415	415	}

417	417
418	418	void NFSv41BreakdownAnalyzer::layoutget41(const RPCProcedure* proc, const NFS41::LAYOUTGET4args, const NFS41::LAYOUTGET4res res)
419	419	{
420		if (res)
	420	if(res)
421	421	{
422	422	stats.account(proc, ProcEnumNFS41::NFSProcedure::LAYOUTGET);
423	423	}

425	425
426	426	void NFSv41BreakdownAnalyzer::layoutreturn41(const RPCProcedure* proc, const NFS41::LAYOUTRETURN4args, const NFS41::LAYOUTRETURN4res res)
427	427	{
428		if (res)
	428	if(res)
429	429	{
430	430	stats.account(proc, ProcEnumNFS41::NFSProcedure::LAYOUTRETURN);
431	431	}

433	433
434	434	void NFSv41BreakdownAnalyzer::secinfo_no_name41(const RPCProcedure* proc, const NFS41::SECINFO_NO_NAME4args, const NFS41::SECINFO_NO_NAME4res res)
435	435	{
436		if (res)
	436	if(res)
437	437	{
438	438	stats.account(proc, ProcEnumNFS41::NFSProcedure::SECINFO_NO_NAME);
439	439	}

441	441
442	442	void NFSv41BreakdownAnalyzer::sequence41(const RPCProcedure* proc, const NFS41::SEQUENCE4args, const NFS41::SEQUENCE4res res)
443	443	{
444		if (res)
	444	if(res)
445	445	{
446	446	stats.account(proc, ProcEnumNFS41::NFSProcedure::SEQUENCE);
447	447	}

449	449
450	450	void NFSv41BreakdownAnalyzer::set_ssv41(const RPCProcedure* proc, const NFS41::SET_SSV4args, const NFS41::SET_SSV4res res)
451	451	{
452		if (res)
	452	if(res)
453	453	{
454	454	stats.account(proc, ProcEnumNFS41::NFSProcedure::SET_SSV);
455	455	}

457	457
458	458	void NFSv41BreakdownAnalyzer::test_stateid41(const RPCProcedure* proc, const NFS41::TEST_STATEID4args, const NFS41::TEST_STATEID4res res)
459	459	{
460		if (res)
	460	if(res)
461	461	{
462	462	stats.account(proc, ProcEnumNFS41::NFSProcedure::TEST_STATEID);
463	463	}

465	465
466	466	void NFSv41BreakdownAnalyzer::want_delegation41(const RPCProcedure* proc, const NFS41::WANT_DELEGATION4args, const NFS41::WANT_DELEGATION4res res)
467	467	{
468		if (res)
	468	if(res)
469	469	{
470	470	stats.account(proc, ProcEnumNFS41::NFSProcedure::WANT_DELEGATION);
471	471	}

473	473
474	474	void NFSv41BreakdownAnalyzer::destroy_clientid41(const RPCProcedure* proc, const NFS41::DESTROY_CLIENTID4args, const NFS41::DESTROY_CLIENTID4res res)
475	475	{
476		if (res)
	476	if(res)
477	477	{
478	478	stats.account(proc, ProcEnumNFS41::NFSProcedure::DESTROY_CLIENTID);
479	479	}

481	481
482	482	void NFSv41BreakdownAnalyzer::reclaim_complete41(const RPCProcedure* proc, const NFS41::RECLAIM_COMPLETE4args, const NFS41::RECLAIM_COMPLETE4res res)
483	483	{
484		if (res)
	484	if(res)
485	485	{
486	486	stats.account(proc, ProcEnumNFS41::NFSProcedure::RECLAIM_COMPLETE);
487	487	}

489	489
490	490	void NFSv41BreakdownAnalyzer::illegal41(const RPCProcedure* proc, const NFS41::ILLEGAL4res* res)
491	491	{
492		if (res)
	492	if(res)
493	493	{
494	494	stats.account(proc, ProcEnumNFS41::NFSProcedure::ILLEGAL);
495	495	}

+14

-15

analyzers/src/breakdown/nfsv41breakdownanalyzer.h less more

30	30	{
31	31	namespace breakdown
32	32	{
33
34	33	/*! \brief Analyzer for NFS v4.1
35	34	* Handles NFS v4.1 commands
36	35	*/
37	36	class NFSv41BreakdownAnalyzer : virtual public IAnalyzer
38	37	{
39		Statistics compound_stats; //!< Statistics
40		Statistics stats; //!< Statistics
41		NFSv4Representer representer; //!< Class for statistics representation
	38	Statistics compound_stats; //!< Statistics
	39	Statistics stats; //!< Statistics
	40	NFSv4Representer representer; //!< Class for statistics representation
42	41	public:
43	42	NFSv41BreakdownAnalyzer(std::ostream& o = std::cout);
44	43	// NFSv4.1 procedures
45		void compound41(const RPCProcedure* proc,
	44	void compound41(const RPCProcedure* proc,
46	45	const struct NFS41::COMPOUND4args*,
47	46	const struct NFS41::COMPOUND4res*) override final;
48	47	// NFSv4.1 operations

68	67	void getattr41(const RPCProcedure* proc,
69	68	const struct NFS41::GETATTR4args*,
70	69	const struct NFS41::GETATTR4res* res) override final;
71		void getfh41(const RPCProcedure* proc,
	70	void getfh41(const RPCProcedure* proc,
72	71	const struct NFS41::GETFH4res* res) override final;
73	72	void link41(const RPCProcedure* proc,
74	73	const struct NFS41::LINK4args*,

85	84	void lookup41(const RPCProcedure* proc,
86	85	const struct NFS41::LOOKUP4args*,
87	86	const struct NFS41::LOOKUP4res* res) override final;
88		void lookupp41(const RPCProcedure* proc,
	87	void lookupp41(const RPCProcedure* proc,
89	88	const struct NFS41::LOOKUPP4res* res) override final;
90	89	void nverify41(const RPCProcedure* proc,
91	90	const struct NFS41::NVERIFY4args*,

105	104	void putfh41(const RPCProcedure* proc,
106	105	const struct NFS41::PUTFH4args*,
107	106	const struct NFS41::PUTFH4res* res) override final;
108		void putpubfh41(const RPCProcedure* proc,
	107	void putpubfh41(const RPCProcedure* proc,
109	108	const struct NFS41::PUTPUBFH4res* res) override final;
110		void putrootfh41(const RPCProcedure* proc,
	109	void putrootfh41(const RPCProcedure* proc,
111	110	const struct NFS41::PUTROOTFH4res* res) override final;
112	111	void read41(const RPCProcedure* proc,
113	112	const struct NFS41::READ4args*,

115	114	void readdir41(const RPCProcedure* proc,
116	115	const struct NFS41::READDIR4args*,
117	116	const struct NFS41::READDIR4res* res) override final;
118		void readlink41(const RPCProcedure* proc,
	117	void readlink41(const RPCProcedure* proc,
119	118	const struct NFS41::READLINK4res* res) override final;
120	119	void remove41(const RPCProcedure* proc,
121	120	const struct NFS41::REMOVE4args*,

126	125	void renew41(const RPCProcedure* proc,
127	126	const struct NFS41::RENEW4args*,
128	127	const struct NFS41::RENEW4res* res) override final;
129		void restorefh41(const RPCProcedure* proc,
	128	void restorefh41(const RPCProcedure* proc,
130	129	const struct NFS41::RESTOREFH4res* res) override final;
131		void savefh41(const RPCProcedure* proc,
	130	void savefh41(const RPCProcedure* proc,
132	131	const struct NFS41::SAVEFH4res* res) override final;
133	132	void secinfo41(const RPCProcedure* proc,
134	133	const struct NFS41::SECINFO4args*,

208	207	void reclaim_complete41(const RPCProcedure* proc,
209	208	const struct NFS41::RECLAIM_COMPLETE4args*,
210	209	const struct NFS41::RECLAIM_COMPLETE4res* res) override final;
211		void illegal41(const RPCProcedure* proc,
	210	void illegal41(const RPCProcedure* proc,
212	211	const struct NFS41::ILLEGAL4res* res) override final;
213	212
214	213	void flush_statistics() override;

217	216	} // namespace protocols
218	217	} // namespace NST
219	218	//------------------------------------------------------------------------------
220		#endif//NFSV41BREAKDOWNANALYZER_H
221		//------------------------------------------------------------------------------
	219	#endif //NFSV41BREAKDOWNANALYZER_H
	220	//------------------------------------------------------------------------------

-3

analyzers/src/breakdown/nfsv41commands.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/*!
32	31	* Represents NFS v 4.0 commands
33	32	* Converts commands to string

38	37	const char* command_description(int cmd_code);
39	38	const char* command_name(int cmd_code);
40	39	const char* protocol_name();
41		size_t commands_count();
	40	size_t commands_count();
42	41	};
43	42
44	43	} // namespace breakdown
45	44	} // namespace NST
46	45	//------------------------------------------------------------------------------
47		#endif//NFSV41COMMANDS_H
	46	#endif //NFSV41COMMANDS_H
48	47	//------------------------------------------------------------------------------

+39

-39

analyzers/src/breakdown/nfsv4breakdownanalyzer.cpp less more

48	48
49	49	void NFSv4BreakdownAnalyzer::access40(const RPCProcedure* proc, const NFS4::ACCESS4args, const NFS4::ACCESS4res res)
50	50	{
51		if (res)
	51	if(res)
52	52	{
53	53	stats.account(proc, ProcEnumNFS4::NFSProcedure::ACCESS);
54	54	}

56	56
57	57	void NFSv4BreakdownAnalyzer::close40(const RPCProcedure* proc, const NFS4::CLOSE4args, const NFS4::CLOSE4res res)
58	58	{
59		if (res)
	59	if(res)
60	60	{
61	61	stats.account(proc, ProcEnumNFS4::NFSProcedure::CLOSE);
62	62	}

64	64
65	65	void NFSv4BreakdownAnalyzer::commit40(const RPCProcedure* proc, const NFS4::COMMIT4args, const NFS4::COMMIT4res res)
66	66	{
67		if (res)
	67	if(res)
68	68	{
69	69	stats.account(proc, ProcEnumNFS4::NFSProcedure::COMMIT);
70	70	}

72	72
73	73	void NFSv4BreakdownAnalyzer::create40(const RPCProcedure* proc, const NFS4::CREATE4args, const NFS4::CREATE4res res)
74	74	{
75		if (res)
	75	if(res)
76	76	{
77	77	stats.account(proc, ProcEnumNFS4::NFSProcedure::CREATE);
78	78	}

80	80
81	81	void NFSv4BreakdownAnalyzer::delegpurge40(const RPCProcedure* proc, const NFS4::DELEGPURGE4args, const NFS4::DELEGPURGE4res res)
82	82	{
83		if (res)
	83	if(res)
84	84	{
85	85	stats.account(proc, ProcEnumNFS4::NFSProcedure::DELEGPURGE);
86	86	}

88	88
89	89	void NFSv4BreakdownAnalyzer::delegreturn40(const RPCProcedure* proc, const NFS4::DELEGRETURN4args, const NFS4::DELEGRETURN4res res)
90	90	{
91		if (res)
	91	if(res)
92	92	{
93	93	stats.account(proc, ProcEnumNFS4::NFSProcedure::DELEGRETURN);
94	94	}

96	96
97	97	void NFSv4BreakdownAnalyzer::getattr40(const RPCProcedure* proc, const NFS4::GETATTR4args, const NFS4::GETATTR4res res)
98	98	{
99		if (res)
	99	if(res)
100	100	{
101	101	stats.account(proc, ProcEnumNFS4::NFSProcedure::GETATTR);
102	102	}

104	104
105	105	void NFSv4BreakdownAnalyzer::getfh40(const RPCProcedure* proc, const NFS4::GETFH4res* res)
106	106	{
107		if (res)
	107	if(res)
108	108	{
109	109	stats.account(proc, ProcEnumNFS4::NFSProcedure::GETFH);
110	110	}

112	112
113	113	void NFSv4BreakdownAnalyzer::link40(const RPCProcedure* proc, const NFS4::LINK4args, const NFS4::LINK4res res)
114	114	{
115		if (res)
	115	if(res)
116	116	{
117	117	stats.account(proc, ProcEnumNFS4::NFSProcedure::LINK);
118	118	}

120	120
121	121	void NFSv4BreakdownAnalyzer::lock40(const RPCProcedure* proc, const NFS4::LOCK4args, const NFS4::LOCK4res res)
122	122	{
123		if (res)
	123	if(res)
124	124	{
125	125	stats.account(proc, ProcEnumNFS4::NFSProcedure::LOCK);
126	126	}

128	128
129	129	void NFSv4BreakdownAnalyzer::lockt40(const RPCProcedure* proc, const NFS4::LOCKT4args, const NFS4::LOCKT4res res)
130	130	{
131		if (res)
	131	if(res)
132	132	{
133	133	stats.account(proc, ProcEnumNFS4::NFSProcedure::LOCKT);
134	134	}

136	136
137	137	void NFSv4BreakdownAnalyzer::locku40(const RPCProcedure* proc, const NFS4::LOCKU4args, const NFS4::LOCKU4res res)
138	138	{
139		if (res)
	139	if(res)
140	140	{
141	141	stats.account(proc, ProcEnumNFS4::NFSProcedure::LOCKU);
142	142	}

144	144
145	145	void NFSv4BreakdownAnalyzer::lookup40(const RPCProcedure* proc, const NFS4::LOOKUP4args, const NFS4::LOOKUP4res res)
146	146	{
147		if (res)
	147	if(res)
148	148	{
149	149	stats.account(proc, ProcEnumNFS4::NFSProcedure::LOOKUP);
150	150	}

152	152
153	153	void NFSv4BreakdownAnalyzer::lookupp40(const RPCProcedure* proc, const NFS4::LOOKUPP4res* res)
154	154	{
155		if (res)
	155	if(res)
156	156	{
157	157	stats.account(proc, ProcEnumNFS4::NFSProcedure::LOOKUPP);
158	158	}

160	160
161	161	void NFSv4BreakdownAnalyzer::nverify40(const RPCProcedure* proc, const NFS4::NVERIFY4args, const NFS4::NVERIFY4res res)
162	162	{
163		if (res)
	163	if(res)
164	164	{
165	165	stats.account(proc, ProcEnumNFS4::NFSProcedure::NVERIFY);
166	166	}

168	168
169	169	void NFSv4BreakdownAnalyzer::open40(const RPCProcedure* proc, const NFS4::OPEN4args, const NFS4::OPEN4res res)
170	170	{
171		if (res)
	171	if(res)
172	172	{
173	173	stats.account(proc, ProcEnumNFS4::NFSProcedure::OPEN);
174	174	}

176	176
177	177	void NFSv4BreakdownAnalyzer::openattr40(const RPCProcedure* proc, const NFS4::OPENATTR4args, const NFS4::OPENATTR4res res)
178	178	{
179		if (res)
	179	if(res)
180	180	{
181	181	stats.account(proc, ProcEnumNFS4::NFSProcedure::OPENATTR);
182	182	}

184	184
185	185	void NFSv4BreakdownAnalyzer::open_confirm40(const RPCProcedure* proc, const NFS4::OPEN_CONFIRM4args, const NFS4::OPEN_CONFIRM4res res)
186	186	{
187		if (res)
	187	if(res)
188	188	{
189	189	stats.account(proc, ProcEnumNFS4::NFSProcedure::OPEN_CONFIRM);
190	190	}

192	192
193	193	void NFSv4BreakdownAnalyzer::open_downgrade40(const RPCProcedure* proc, const NFS4::OPEN_DOWNGRADE4args, const NFS4::OPEN_DOWNGRADE4res res)
194	194	{
195		if (res)
	195	if(res)
196	196	{
197	197	stats.account(proc, ProcEnumNFS4::NFSProcedure::OPEN_DOWNGRADE);
198	198	}

200	200
201	201	void NFSv4BreakdownAnalyzer::putfh40(const RPCProcedure* proc, const NFS4::PUTFH4args, const NFS4::PUTFH4res res)
202	202	{
203		if (res)
	203	if(res)
204	204	{
205	205	stats.account(proc, ProcEnumNFS4::NFSProcedure::PUTFH);
206	206	}

208	208
209	209	void NFSv4BreakdownAnalyzer::putpubfh40(const RPCProcedure* proc, const NFS4::PUTPUBFH4res* res)
210	210	{
211		if (res)
	211	if(res)
212	212	{
213	213	stats.account(proc, ProcEnumNFS4::NFSProcedure::PUTPUBFH);
214	214	}

216	216
217	217	void NFSv4BreakdownAnalyzer::putrootfh40(const RPCProcedure* proc, const NFS4::PUTROOTFH4res* res)
218	218	{
219		if (res)
	219	if(res)
220	220	{
221	221	stats.account(proc, ProcEnumNFS4::NFSProcedure::PUTROOTFH);
222	222	}

224	224
225	225	void NFSv4BreakdownAnalyzer::read40(const RPCProcedure* proc, const NFS4::READ4args, const NFS4::READ4res res)
226	226	{
227		if (res)
	227	if(res)
228	228	{
229	229	stats.account(proc, ProcEnumNFS4::NFSProcedure::READ);
230	230	}

232	232
233	233	void NFSv4BreakdownAnalyzer::readdir40(const RPCProcedure* proc, const NFS4::READDIR4args, const NFS4::READDIR4res res)
234	234	{
235		if (res)
	235	if(res)
236	236	{
237	237	stats.account(proc, ProcEnumNFS4::NFSProcedure::READDIR);
238	238	}

240	240
241	241	void NFSv4BreakdownAnalyzer::readlink40(const RPCProcedure* proc, const NFS4::READLINK4res* res)
242	242	{
243		if (res)
	243	if(res)
244	244	{
245	245	stats.account(proc, ProcEnumNFS4::NFSProcedure::READLINK);
246	246	}

248	248
249	249	void NFSv4BreakdownAnalyzer::remove40(const RPCProcedure* proc, const NFS4::REMOVE4args, const NFS4::REMOVE4res res)
250	250	{
251		if (res)
	251	if(res)
252	252	{
253	253	stats.account(proc, ProcEnumNFS4::NFSProcedure::REMOVE);
254	254	}

256	256
257	257	void NFSv4BreakdownAnalyzer::rename40(const RPCProcedure* proc, const NFS4::RENAME4args, const NFS4::RENAME4res res)
258	258	{
259		if (res)
	259	if(res)
260	260	{
261	261	stats.account(proc, ProcEnumNFS4::NFSProcedure::RENAME);
262	262	}

264	264
265	265	void NFSv4BreakdownAnalyzer::renew40(const RPCProcedure* proc, const NFS4::RENEW4args, const NFS4::RENEW4res res)
266	266	{
267		if (res)
	267	if(res)
268	268	{
269	269	stats.account(proc, ProcEnumNFS4::NFSProcedure::RENEW);
270	270	}

272	272
273	273	void NFSv4BreakdownAnalyzer::restorefh40(const RPCProcedure* proc, const NFS4::RESTOREFH4res* res)
274	274	{
275		if (res)
	275	if(res)
276	276	{
277	277	stats.account(proc, ProcEnumNFS4::NFSProcedure::RESTOREFH);
278	278	}

280	280
281	281	void NFSv4BreakdownAnalyzer::savefh40(const RPCProcedure* proc, const NFS4::SAVEFH4res* res)
282	282	{
283		if (res)
	283	if(res)
284	284	{
285	285	stats.account(proc, ProcEnumNFS4::NFSProcedure::SAVEFH);
286	286	}

288	288
289	289	void NFSv4BreakdownAnalyzer::secinfo40(const RPCProcedure* proc, const NFS4::SECINFO4args, const NFS4::SECINFO4res res)
290	290	{
291		if (res)
	291	if(res)
292	292	{
293	293	stats.account(proc, ProcEnumNFS4::NFSProcedure::SECINFO);
294	294	}

296	296
297	297	void NFSv4BreakdownAnalyzer::setattr40(const RPCProcedure* proc, const NFS4::SETATTR4args, const NFS4::SETATTR4res res)
298	298	{
299		if (res)
	299	if(res)
300	300	{
301	301	stats.account(proc, ProcEnumNFS4::NFSProcedure::SETATTR);
302	302	}

304	304
305	305	void NFSv4BreakdownAnalyzer::setclientid40(const RPCProcedure* proc, const NFS4::SETCLIENTID4args, const NFS4::SETCLIENTID4res res)
306	306	{
307		if (res)
	307	if(res)
308	308	{
309	309	stats.account(proc, ProcEnumNFS4::NFSProcedure::SETCLIENTID);
310	310	}

312	312
313	313	void NFSv4BreakdownAnalyzer::setclientid_confirm40(const RPCProcedure* proc, const NFS4::SETCLIENTID_CONFIRM4args, const NFS4::SETCLIENTID_CONFIRM4res res)
314	314	{
315		if (res)
	315	if(res)
316	316	{
317	317	stats.account(proc, ProcEnumNFS4::NFSProcedure::SETCLIENTID_CONFIRM);
318	318	}

320	320
321	321	void NFSv4BreakdownAnalyzer::verify40(const RPCProcedure* proc, const NFS4::VERIFY4args, const NFS4::VERIFY4res res)
322	322	{
323		if (res)
	323	if(res)
324	324	{
325	325	stats.account(proc, ProcEnumNFS4::NFSProcedure::VERIFY);
326	326	}

328	328
329	329	void NFSv4BreakdownAnalyzer::write40(const RPCProcedure* proc, const NFS4::WRITE4args, const NFS4::WRITE4res res)
330	330	{
331		if (res)
	331	if(res)
332	332	{
333	333	stats.account(proc, ProcEnumNFS4::NFSProcedure::WRITE);
334	334	}

336	336
337	337	void NFSv4BreakdownAnalyzer::release_lockowner40(const RPCProcedure* proc, const NFS4::RELEASE_LOCKOWNER4args, const NFS4::RELEASE_LOCKOWNER4res res)
338	338	{
339		if (res)
	339	if(res)
340	340	{
341	341	stats.account(proc, ProcEnumNFS4::NFSProcedure::RELEASE_LOCKOWNER);
342	342	}

344	344
345	345	void NFSv4BreakdownAnalyzer::get_dir_delegation40(const RPCProcedure* proc, const NFS4::GET_DIR_DELEGATION4args, const NFS4::GET_DIR_DELEGATION4res res)
346	346	{
347		if (res)
	347	if(res)
348	348	{
349	349	stats.account(proc, ProcEnumNFS4::NFSProcedure::GET_DIR_DELEGATION);
350	350	}

352	352
353	353	void NFSv4BreakdownAnalyzer::illegal40(const RPCProcedure* proc, const NFS4::ILLEGAL4res* res)
354	354	{
355		if (res)
	355	if(res)
356	356	{
357	357	stats.account(proc, ProcEnumNFS4::NFSProcedure::ILLEGAL);
358	358	}

+13

-14

analyzers/src/breakdown/nfsv4breakdownanalyzer.h less more

30	30	{
31	31	namespace breakdown
32	32	{
33
34	33	/*! \brief Analyzer for NFS v4
35	34	* Handles NFS v4 commands
36	35	*/

38	37	{
39	38	protected:
40	39	private:
41		Statistics compound_stats; //!< Statistics
42		Statistics stats; //!< Statistics
43		NFSv4Representer representer; //!< stream to output
	40	Statistics compound_stats; //!< Statistics
	41	Statistics stats; //!< Statistics
	42	NFSv4Representer representer; //!< stream to output
44	43	public:
45	44	NFSv4BreakdownAnalyzer(std::ostream& o = std::cout);
46	45

49	48	void null4(const RPCProcedure* proc,
50	49	const struct NFS4::NULL4args*,
51	50	const struct NFS4::NULL4res*) override final;
52		void compound4(const RPCProcedure* proc,
	51	void compound4(const RPCProcedure* proc,
53	52	const struct NFS4::COMPOUND4args*,
54	53	const struct NFS4::COMPOUND4res*) override final;
55	54

77	76	void getattr40(const RPCProcedure* proc,
78	77	const struct NFS4::GETATTR4args*,
79	78	const struct NFS4::GETATTR4res* res) override final;
80		void getfh40(const RPCProcedure* proc,
	79	void getfh40(const RPCProcedure* proc,
81	80	const struct NFS4::GETFH4res* res) override final;
82	81	void link40(const RPCProcedure* proc,
83	82	const struct NFS4::LINK4args*,

94	93	void lookup40(const RPCProcedure* proc,
95	94	const struct NFS4::LOOKUP4args*,
96	95	const struct NFS4::LOOKUP4res* res) override final;
97		void lookupp40(const RPCProcedure* proc,
	96	void lookupp40(const RPCProcedure* proc,
98	97	const struct NFS4::LOOKUPP4res* res) override final;
99	98	void nverify40(const RPCProcedure* proc,
100	99	const struct NFS4::NVERIFY4args*,

114	113	void putfh40(const RPCProcedure* proc,
115	114	const struct NFS4::PUTFH4args*,
116	115	const struct NFS4::PUTFH4res* res) override final;
117		void putpubfh40(const RPCProcedure* proc,
	116	void putpubfh40(const RPCProcedure* proc,
118	117	const struct NFS4::PUTPUBFH4res* res) override final;
119		void putrootfh40(const RPCProcedure* proc,
	118	void putrootfh40(const RPCProcedure* proc,
120	119	const struct NFS4::PUTROOTFH4res* res) override final;
121	120	void read40(const RPCProcedure* proc,
122	121	const struct NFS4::READ4args*,

124	123	void readdir40(const RPCProcedure* proc,
125	124	const struct NFS4::READDIR4args*,
126	125	const struct NFS4::READDIR4res* res) override final;
127		void readlink40(const RPCProcedure* proc,
	126	void readlink40(const RPCProcedure* proc,
128	127	const struct NFS4::READLINK4res* res) override final;
129	128	void remove40(const RPCProcedure* proc,
130	129	const struct NFS4::REMOVE4args*,

135	134	void renew40(const RPCProcedure* proc,
136	135	const struct NFS4::RENEW4args*,
137	136	const struct NFS4::RENEW4res* res) override final;
138		void restorefh40(const RPCProcedure* proc,
	137	void restorefh40(const RPCProcedure* proc,
139	138	const struct NFS4::RESTOREFH4res* res) override final;
140		void savefh40(const RPCProcedure* proc,
	139	void savefh40(const RPCProcedure* proc,
141	140	const struct NFS4::SAVEFH4res* res) override final;
142	141	void secinfo40(const RPCProcedure* proc,
143	142	const struct NFS4::SECINFO4args*,

163	162	void get_dir_delegation40(const RPCProcedure* proc,
164	163	const struct NFS4::GET_DIR_DELEGATION4args*,
165	164	const struct NFS4::GET_DIR_DELEGATION4res* res) override final;
166		void illegal40(const RPCProcedure* proc,
	165	void illegal40(const RPCProcedure* proc,
167	166	const struct NFS4::ILLEGAL4res* res) override final;
168	167	void flush_statistics() override;
169	168	};

171	170	} // namespace breakdown
172	171	} // namespace NST
173	172	//------------------------------------------------------------------------------
174		#endif//NFSV4BREAKDOWNANALYZER_H
	173	#endif //NFSV4BREAKDOWNANALYZER_H
175	174	//------------------------------------------------------------------------------

-4

analyzers/src/breakdown/nfsv4commands.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/*!
32	31	* Represents NFS v 4.0 commands
33	32	* Converts commands to string

37	36	public:
38	37	const char* command_description(int cmd_code) override final;
39	38	const char* command_name(int cmd_code) override final;
40		size_t commands_count() override final;
41		const char* protocol_name();
	39	size_t commands_count() override final;
	40	const char* protocol_name() override final;
42	41	};
43	42
44	43	} // namespace breakdown
45	44	} // namespace NST
46	45	//------------------------------------------------------------------------------
47		#endif//NFSV4COMMANDS_H
	46	#endif //NFSV4COMMANDS_H
48	47	//------------------------------------------------------------------------------

-5

analyzers/src/breakdown/nfsv4representer.cpp less more

23	23	using namespace NST::breakdown;
24	24	//------------------------------------------------------------------------------
25	25	NFSv4Representer::NFSv4Representer(std::ostream& o, CommandRepresenter* cmdRep, size_t space_for_cmd_name, size_t count_of_compounds)
26		: Representer(o, cmdRep, space_for_cmd_name), count_of_compounds(count_of_compounds)
	26	: Representer(o, cmdRep, space_for_cmd_name)
	27	, count_of_compounds(count_of_compounds)
27	28	{
28	29	}
29	30
30	31	void NFSv4Representer::onProcedureInfoPrinted(std::ostream& o, const BreakdownCounter& breakdown, unsigned procedure) const
31	32	{
32		if (procedure == 0)
	33	if(procedure == 0)
33	34	{
34	35	o << "Total procedures: " << breakdown.get_total_count()
35		<< ". Per procedure:" << std::endl;
	36	<< ". Per procedure:" << std::endl;
36	37	}
37		if (procedure == count_of_compounds)
	38	if(procedure == count_of_compounds)
38	39	{
39	40	o << "Total operations: " << breakdown.get_total_count()
40		<< ". Per operation:" << std::endl;
	41	<< ". Per operation:" << std::endl;
41	42	}
42	43	}

-2

analyzers/src/breakdown/nfsv4representer.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/**
32	31	* @brief The NFSv4Representer class
33	32	* Splits output into commands/operations lists for NFS v4.* protocols

35	34	class NFSv4Representer : public Representer
36	35	{
37	36	const size_t count_of_compounds;
	37
38	38	public:
39	39	NFSv4Representer(std::ostream& o, CommandRepresenter* cmdRep, size_t space_for_cmd_name, size_t count_of_compounds);
40	40	void onProcedureInfoPrinted(std::ostream& o, const BreakdownCounter& breakdown, unsigned procedure) const override final;

43	43	} // namespace breakdown
44	44	} // namespace NST
45	45	//------------------------------------------------------------------------------
46		#endif//NFSV4REPRESENTER_H
	46	#endif //NFSV4REPRESENTER_H
47	47	//------------------------------------------------------------------------------

+30

-31

analyzers/src/breakdown/representer.cpp less more

35	35
36	36	void Representer::flush_statistics(const Statistics& statistics)
37	37	{
38		out << "### Breakdown analyzer ###"
39		<< std::endl
40		<< cmd_representer->protocol_name()
41		<< " protocol"
42		<< std::endl;
	38	out << "### Breakdown analyzer ###" << std::endl
	39	<< cmd_representer->protocol_name() << " protocol";
43	40
44		statistics.for_each_procedure([&](const BreakdownCounter& breakdown, size_t procedure)
	41	if(statistics.has_session())
45	42	{
46		onProcedureInfoPrinted(out, breakdown, procedure);
47		size_t procedure_count = breakdown[procedure].get_count();
48		out.width(space_for_cmd_name);
49		out << std::left
50		<< cmd_representer->command_name(procedure);
51		out.width(5);
52		out << std::right
53		<< procedure_count;
54		out.width(7);
55		out.setf(std::ios::fixed, std::ios::floatfield);
56		out.precision(2);
57		out << (breakdown.get_total_count() ? ((1.0 * procedure_count / breakdown.get_total_count()) * 100.0) : 0);
58		out.setf(std::ios::fixed \| std::ios::scientific , std::ios::floatfield);
59		out << '%' << std::endl;
60		});
	43	out << std::endl;
61	44
62		if (statistics.has_session()) // is not empty?
63		{
	45	statistics.for_each_procedure([&](const BreakdownCounter& breakdown, size_t procedure) {
	46	onProcedureInfoPrinted(out, breakdown, procedure);
	47	size_t procedure_count = breakdown[procedure].get_count();
	48	out.width(space_for_cmd_name);
	49	out << std::left
	50	<< cmd_representer->command_name(procedure);
	51	out.width(5);
	52	out << std::right
	53	<< procedure_count;
	54	out.width(7);
	55	out.setf(std::ios::fixed, std::ios::floatfield);
	56	out.precision(2);
	57	out << (breakdown.get_total_count() ? ((1.0 * procedure_count / breakdown.get_total_count()) * 100.0) : 0);
	58	out.setf(std::ios::fixed \| std::ios::scientific, std::ios::floatfield);
	59	out << '%' << std::endl;
	60	});
	61
64	62	out << "Per connection info: " << std::endl;
65	63
66		statistics.for_each_session([&](const Session& session)
67		{
	64	statistics.for_each_session([&](const Session& session) {
68	65	std::stringstream ssession;
69	66	print_session(ssession, session);
70	67	print_per_session(statistics, session, ssession.str());
71	68	std::ofstream file("breakdown_" + ssession.str() + ".dat", std::ios::out \| std::ios::trunc);
72	69	store_per_session(file, statistics, session, ssession.str());
73	70	});
	71	}
	72	else
	73	{
	74	out << ": Data transmission has not been detected." << std::endl;
74	75	}
75	76	}
76	77

79	80	//TODO: does it make sense to join store_per_session & print_per_session?
80	81	file << "Session: " << ssession << std::endl;
81	82
82		statistics.for_each_procedure_in_session(session, [&](const BreakdownCounter& breakdown, size_t procedure)
83		{
	83	statistics.for_each_procedure_in_session(session, [&](const BreakdownCounter& breakdown, size_t procedure) {
84	84	uint64_t s_total_proc = breakdown.get_total_count();
85	85	file << cmd_representer->command_name(procedure);
86	86	file << ' ' << breakdown[procedure].get_count() << ' ';

97	97	{
98	98	out << "Session: " << ssession << std::endl;
99	99
100		statistics.for_each_procedure_in_session(session, [&](const BreakdownCounter& breakdown, size_t procedure)
101		{
	100	statistics.for_each_procedure_in_session(session, [&](const BreakdownCounter& breakdown, size_t procedure) {
102	101	uint64_t s_total_proc = breakdown.get_total_count();
103	102	onProcedureInfoPrinted(out, breakdown, procedure);
104	103	out.width(22);

135	134
136	135	void Representer::onProcedureInfoPrinted(std::ostream& o, const BreakdownCounter& breakdown, unsigned procedure) const
137	136	{
138		if (procedure == 0)
	137	if(procedure == 0)
139	138	{
140	139	o << "Total operations: " << breakdown.get_total_count()
141		<< ". Per operation:" << std::endl;
	140	<< ". Per operation:" << std::endl;
142	141	}
143	142	}
144	143	//------------------------------------------------------------------------------

-8

analyzers/src/breakdown/representer.h less more

24	24	#include <memory>
25	25	#include <ostream>
26	26
	27	#include "breakdowncounter.h"
27	28	#include "commandrepresenter.h"
28		#include "breakdowncounter.h"
29	29	#include "statistics.h"
30	30	//------------------------------------------------------------------------------
31	31	namespace NST
32	32	{
33	33	namespace breakdown
34	34	{
35
36	35	/*! \class Represents statistics and sends it to screen
37	36	*/
38	37	class Representer
39	38	{
40		std::ostream& out;
	39	std::ostream& out;
41	40	std::unique_ptr<CommandRepresenter> cmd_representer;
42		size_t space_for_cmd_name;
	41	size_t space_for_cmd_name;
43	42
44		void store_per_session(std::ostream& file,
45		const Statistics& statistics,
46		const Session& session,
	43	void store_per_session(std::ostream& file,
	44	const Statistics& statistics,
	45	const Session& session,
47	46	const std::string& ssession) const;
48	47
49	48	void print_per_session(const Statistics& statistics, const Session& session, const std::string& ssession) const;
	49
50	50	protected:
51	51	/**
52	52	* @brief handler of one procedure output event

55	55	* @param procedure - procedure ID
56	56	*/
57	57	virtual void onProcedureInfoPrinted(std::ostream& o, const BreakdownCounter& breakdown, unsigned procedure) const;
	58
58	59	public:
59	60	/**
60	61	* @brief Representer's constructor

74	75	} // namespace breakdown
75	76	} // namespace NST
76	77	//------------------------------------------------------------------------------
77		#endif//REPRESENTER_H
	78	#endif //REPRESENTER_H
78	79	//------------------------------------------------------------------------------

+16

-19

analyzers/src/breakdown/statistics.cpp less more

24	24	//------------------------------------------------------------------------------
25	25	bool Less::operator()(const Session& a, const Session& b) const
26	26	{
27		return ( (std::uint16_t)(a.ip_type) < (std::uint16_t)(b.ip_type) ) \|\| // compare versions of IP address
28		( ntohs(a.port[0]) < ntohs(b.port[0]) ) \|\| // compare Source(client) ports
29		( ntohs(a.port[1]) < ntohs(b.port[1]) ) \|\| // compare Destination(server) ports
	27	return ((std::uint16_t)(a.ip_type) < (std::uint16_t)(b.ip_type)) \|\| // compare versions of IP address
	28	(ntohs(a.port[0]) < ntohs(b.port[0])) \|\| // compare Source(client) ports
	29	(ntohs(a.port[1]) < ntohs(b.port[1])) \|\| // compare Destination(server) ports
30	30
31		( (a.ip_type == Session::IPType::v4) ? // compare IPv4
32		((ntohl(a.ip.v4.addr[0]) < ntohl(b.ip.v4.addr[0])) \|\| (ntohl(a.ip.v4.addr[1]) < ntohl(b.ip.v4.addr[1])))
33		:
34		(memcmp(&a.ip.v6, &b.ip.v6, sizeof(a.ip.v6)) < 0 )
35		);
	31	((a.ip_type == Session::IPType::v4) ? // compare IPv4
	32	((ntohl(a.ip.v4.addr[0]) < ntohl(b.ip.v4.addr[0])) \|\| (ntohl(a.ip.v4.addr[1]) < ntohl(b.ip.v4.addr[1])))
	33	: (memcmp(&a.ip.v6, &b.ip.v6, sizeof(a.ip.v6)) < 0));
36	34	}
37	35
38	36	Statistics::Statistics(size_t proc_types_count)

41	39	{
42	40	}
43	41
44		void Statistics::for_each_procedure(std::function<void (const BreakdownCounter&, size_t)> on_procedure) const
	42	void Statistics::for_each_procedure(std::function<void(const BreakdownCounter&, size_t)> on_procedure) const
45	43	{
46		for (size_t procedure = 0; procedure < proc_types_count; ++procedure)
	44	for(size_t procedure = 0; procedure < proc_types_count; ++procedure)
47	45	{
48	46	on_procedure(counter, procedure);
49	47	}
50	48	}
51	49
52		void Statistics::for_each_session(std::function<void (const Session&)> on_session) const
	50	void Statistics::for_each_session(std::function<void(const Session&)> on_session) const
53	51	{
54		for (auto& it : per_session_statistics)
	52	for(auto& it : per_session_statistics)
55	53	{
56	54	on_session(it.first);
57	55	}
58	56	}
59	57
60		void Statistics::for_each_procedure_in_session(const Session& session, std::function<void (const BreakdownCounter&, size_t)> on_procedure) const
	58	void Statistics::for_each_procedure_in_session(const Session& session, std::function<void(const BreakdownCounter&, size_t)> on_procedure) const
61	59	{
62		if (per_session_statistics.find(session) == per_session_statistics.end())
	60	if(per_session_statistics.find(session) == per_session_statistics.end())
63	61	{
64	62	return;
65	63	}
66	64
67	65	const BreakdownCounter& current = per_session_statistics.at(session);
68		for (size_t procedure = 0; procedure < proc_types_count; ++procedure)
	66	for(size_t procedure = 0; procedure < proc_types_count; ++procedure)
69	67	{
70	68	on_procedure(current, procedure);
71	69	}

81	79	counter[cmd_index].add(latency);
82	80
83	81	auto i = per_session_statistics.find(session);
84		if (i == per_session_statistics.end())
	82	if(i == per_session_statistics.end())
85	83	{
86		auto session_res = per_session_statistics.emplace(session, BreakdownCounter {proc_types_count});
87		if (session_res.second == false)
	84	auto session_res = per_session_statistics.emplace(session, BreakdownCounter{proc_types_count});
	85	if(session_res.second == false)
88	86	{
89	87	return;
90	88	}

92	90	}
93	91
94	92	(i->second)[cmd_index].add(latency);
95
96	93	}
97	94	//------------------------------------------------------------------------------

-9

analyzers/src/breakdown/statistics.h less more

32	32	{
33	33	namespace breakdown
34	34	{
35
36	35	/*! \brief Comparator for sessions
37	36	*/
38	37	struct Less
39	38	{
40		bool operator() (const Session& a, const Session& b) const;
	39	bool operator()(const Session& a, const Session& b) const;
41	40	};
42	41
43	42	/*! \brief All statistics data's container

45	44	struct Statistics
46	45	{
47	46	using PerSessionStatistics = std::map<Session, BreakdownCounter, Less>;
48		using ProceduresCount = std::vector<int>;
	47	using ProceduresCount = std::vector<int>;
49	48
50	49	const size_t proc_types_count; //!< Count of types of procedures
51	50

85	84	* @param cmd_code - commands code
86	85	* @param stats - statistics
87	86	*/
88		template<typename Cmd, typename Code>
	87	template <typename Cmd, typename Code>
89	88	void account(const Cmd* proc, Code cmd_code)
90	89	{
91		timeval latency {0, 0};
92		const int cmd_index = static_cast<int>(cmd_code);
93		const Session& session = *proc->session;
	90	timeval latency{0, 0};
	91	const int cmd_index = static_cast<int>(cmd_code);
	92	const Session& session = *proc->session;
94	93
95	94	// diff between 'reply' and 'call' timestamps
96	95	timersub(proc->rtimestamp, proc->ctimestamp, &latency);
97	96
98	97	account(cmd_index, session, latency);
99	98	}
	99
100	100	protected:
101	101	void account(const int cmd_index, const Session& session, const timeval latency);
102	102
103		BreakdownCounter counter; //!< Statistics for all sessions
	103	BreakdownCounter counter; //!< Statistics for all sessions
104	104	PerSessionStatistics per_session_statistics; //!< Statistics for each session
105	105	};
106	106
107	107	} // namespace breakdown
108	108	} // namespace NST
109	109	//------------------------------------------------------------------------------
110		#endif//STATISTICS_H
	110	#endif //STATISTICS_H
111	111	//------------------------------------------------------------------------------

-11

analyzers/src/breakdown/statisticscompositor.cpp less more

28	28	: Statistics(operations_stats)
29	29	, procedures_stats(procedures_stats)
30	30	{
31		procedures_stats.for_each_session([&](const Session& session)
32		{
	31	procedures_stats.for_each_session([&](const Session& session) {
33	32	auto i = per_session_statistics.find(session);
34		if (i == per_session_statistics.end())
	33	if(i == per_session_statistics.end())
35	34	{
36		per_session_statistics.emplace(session, BreakdownCounter {proc_types_count});
	35	per_session_statistics.emplace(session, BreakdownCounter{proc_types_count});
37	36	}
38	37	});
39	38	}

44	43
45	44	procedures_stats.for_each_procedure(on_procedure);
46	45
47		for (size_t procedure = procedures_stats.proc_types_count; procedure < proc_types_count; ++procedure)
	46	for(size_t procedure = procedures_stats.proc_types_count; procedure < proc_types_count; ++procedure)
48	47	{
49	48	on_procedure(counter, procedure);
50	49	}
51	50	}
52	51
53		void StatisticsCompositor::for_each_procedure_in_session(const Session& session, std::function<void (const BreakdownCounter&, size_t)> on_procedure) const
	52	void StatisticsCompositor::for_each_procedure_in_session(const Session& session, std::function<void(const BreakdownCounter&, size_t)> on_procedure) const
54	53	{
55	54	bool has_procedures_in_session = false;
56	55
57		procedures_stats.for_each_procedure_in_session(session, [&](const BreakdownCounter& breakdown, size_t proc)
58		{
	56	procedures_stats.for_each_procedure_in_session(session, [&](const BreakdownCounter& breakdown, size_t proc) {
59	57	on_procedure(breakdown, proc);
60	58	has_procedures_in_session = true;
61	59	});
62	60
63		if (!has_procedures_in_session)
	61	if(!has_procedures_in_session)
64	62	{
65	63	BreakdownCounter empty(procedures_stats.proc_types_count);
66		for (size_t procedure = 0; procedure < procedures_stats.proc_types_count; ++procedure)
	64	for(size_t procedure = 0; procedure < procedures_stats.proc_types_count; ++procedure)
67	65	{
68	66	on_procedure(empty, procedure);
69	67	}
70	68	}
71	69
72	70	const BreakdownCounter& current = per_session_statistics.at(session);
73		for (size_t procedure = procedures_stats.proc_types_count; procedure < proc_types_count; ++procedure)
	71	for(size_t procedure = procedures_stats.proc_types_count; procedure < proc_types_count; ++procedure)
74	72	{
75	73	on_procedure(current, procedure);
76	74	}

-2

analyzers/src/breakdown/statisticscompositor.h less more

27	27	{
28	28	namespace breakdown
29	29	{
30
31	30	/**
32	31	* @brief Composes 2 statistics: for procedures and functions
33	32	* It is useful for NFS v4.* protocols

35	34	class StatisticsCompositor : public Statistics
36	35	{
37	36	Statistics& procedures_stats;
	37
38	38	public:
39	39	StatisticsCompositor(Statistics& procedures_stats, Statistics& operations_stats);
40	40	void for_each_procedure(std::function<void(const BreakdownCounter&, size_t)> on_procedure) const override;

45	45	} // namespace breakdown
46	46	} // namespace NST
47	47	//------------------------------------------------------------------------------
48		#endif//STATISTICSCOMPOSITOR_H
	48	#endif //STATISTICSCOMPOSITOR_H
49	49	//------------------------------------------------------------------------------

+34

-33

analyzers/src/json/abstract_tcp_service.cpp less more

22	22	#include <functional>
23	23	#include <system_error>
24	24
	25	#include <sys/socket.h>
25	26	#include <sys/types.h>
26		#include <sys/socket.h>
27	27	#include <unistd.h>
28	28
29	29	#include "abstract_tcp_service.h"
30	30	#include "utils/log.h"
31	31	//------------------------------------------------------------------------------
32	32
33		AbstractTcpService::AbstractTcpService(std::size_t workersAmount, int port, const std::string& host, int backlog) :
34		_port{port},
35		_host{host},
36		_backlog{backlog},
37		_isRunning{true},
38		_threadPool{workersAmount},
39		_listenerThread{},
40		_serverSocket{0},
41		_tasksQueue{},
42		_tasksQueueMutex{},
43		_tasksQueueCond{}
	33	AbstractTcpService::AbstractTcpService(std::size_t workersAmount, int port, const std::string& host, int backlog)
	34	: _port{port}
	35	, _host{host}
	36	, _backlog{backlog}
	37	, _isRunning{true}
	38	, _threadPool{workersAmount}
	39	, _listenerThread{}
	40	, _serverSocket{0}
	41	, _tasksQueue{}
	42	, _tasksQueueMutex{}
	43	, _tasksQueueCond{}
44	44	{
45	45	}
46	46
47	47	AbstractTcpService::~AbstractTcpService()
48	48	{
49	49	// Disposing tasks which are still in queue
50		while (!_tasksQueue.empty())
	50	while(!_tasksQueue.empty())
51	51	{
52	52	delete _tasksQueue.front();
53	53	_tasksQueue.pop();

59	59	_isRunning = true;
60	60	// Setting up server TCP-socket
61	61	_serverSocket = socket(PF_INET, SOCK_STREAM, 0);
62		if (_serverSocket < 0)
	62	if(_serverSocket < 0)
63	63	{
64	64	throw std::system_error{errno, std::system_category(), "Opening server socket error"};
65	65	}
66	66	// Setting SO_REUSEADDR to true
67	67	int reuseAddr = 1;
68		if (setsockopt(_serverSocket, SOL_SOCKET, SO_REUSEADDR, &reuseAddr, sizeof(reuseAddr)) < 0)
	68	if(setsockopt(_serverSocket, SOL_SOCKET, SO_REUSEADDR, &reuseAddr, sizeof(reuseAddr)) < 0)
69	69	{
70	70	throw std::system_error{errno, std::system_category(), "Setting SO_REUSEADDR socket option error"};
71	71	}
72	72	// Binding server socket to endpoint
73	73	IpEndpoint endpoint{_host.c_str(), _port};
74		if (bind(_serverSocket, endpoint.addrinfo()->ai_addr, endpoint.addrinfo()->ai_addrlen) != 0)
	74	if(bind(_serverSocket, endpoint.addrinfo()->ai_addr, endpoint.addrinfo()->ai_addrlen) != 0)
75	75	{
76	76	throw std::system_error{errno, std::system_category(), "Binding server socket error"};
77	77	}
78	78	// Converting socket to listening state
79		if (listen(_serverSocket, _backlog) != 0)
	79	if(listen(_serverSocket, _backlog) != 0)
80	80	{
81	81	throw std::system_error{errno, std::system_category(), "Converting socket to listening state error"};
82	82	}
83	83	// Creating threads for thread-pool
84		for (auto & thr : _threadPool)
	84	for(auto& thr : _threadPool)
85	85	{
86	86	thr = std::thread{&AbstractTcpService::runWorker, this};
87	87	}

97	97	_tasksQueueCond.notify_all();
98	98	}
99	99	// Joining to thread-pool threads and disposing them
100		for (auto & thr : _threadPool)
	100	for(auto& thr : _threadPool)
101	101	{
102	102	thr.join();
103	103	}

108	108
109	109	void AbstractTcpService::runWorker()
110	110	{
111		while (true)
	111	while(true)
112	112	{
113	113	std::unique_ptr<AbstractTask> pendingTask;
114	114	{
115	115	std::unique_lock<std::mutex> lock{_tasksQueueMutex};
116		while (!pendingTask)
117		{
118		if (!_isRunning.load())
	116	while(!pendingTask)
	117	{
	118	if(!_isRunning.load())
119	119	{
120	120	return;
121	121	}
122		if (!_tasksQueue.empty())
	122	if(!_tasksQueue.empty())
123	123	{
124	124	pendingTask.reset(_tasksQueue.front());
125	125	_tasksQueue.pop();

136	136
137	137	void AbstractTcpService::runListener()
138	138	{
139		while (_isRunning.load())
	139	while(_isRunning.load())
140	140	{
141	141	// Accepting incoming connection on socket
142	142	struct timespec acceptDuration;

145	145	FD_ZERO(&readDescriptorsSet);
146	146	FD_SET(_serverSocket, &readDescriptorsSet);
147	147	int descriptorsCount = pselect(_serverSocket + 1, &readDescriptorsSet, NULL, NULL, &acceptDuration, NULL);
148		if (descriptorsCount == 0)
	148	if(descriptorsCount == 0)
149	149	{
150	150	// Timeout expired
151	151	continue;
152	152	}
153		else if (descriptorsCount < 0)
	153	else if(descriptorsCount < 0)
154	154	{
155	155	std::system_error e{errno, std::system_category(), "Awaiting for incoming connection on server socket error"};
156	156	LOG("ERROR: %s", e.what());
157	157	#ifdef __gnu_linux__
158	158	// Several first pselect(2) calls cause "Interrupted system call" error (errno == EINTR)
159	159	// if drop privileges option is used on Linux (see https://access.redhat.com/solutions/165483)
160		if (errno == EINTR)
	160	if(errno == EINTR)
161	161	{
162	162	continue;
163	163	}

166	166	}
167	167	// Extracting and returning pending connection
168	168	int pendingSocketDescriptor = accept(_serverSocket, NULL, NULL);
169		if (pendingSocketDescriptor < 0)
	169	if(pendingSocketDescriptor < 0)
170	170	{
171	171	std::system_error e{errno, std::system_category(), "Accepting incoming connection on server socket error"};
172	172	LOG("ERROR: %s", e.what());

176	176	std::unique_ptr<AbstractTask> newTask{createTask(pendingSocketDescriptor)};
177	177	{
178	178	std::unique_lock<std::mutex> lock(_tasksQueueMutex);
179		if (_tasksQueue.size() < MaxTasksQueueSize)
	179	if(_tasksQueue.size() < MaxTasksQueueSize)
180	180	{
181	181	_tasksQueue.push(newTask.get());
182	182	newTask.release();

192	192
193	193	//------------------------------------------------------------------------------
194	194
195		AbstractTcpService::AbstractTask::AbstractTask(int socket) :
196		_socket{socket}
197		{}
	195	AbstractTcpService::AbstractTask::AbstractTask(int socket)
	196	: _socket{socket}
	197	{
	198	}
198	199
199	200	AbstractTcpService::AbstractTask::~AbstractTask()
200	201	{

+20

-17

analyzers/src/json/abstract_tcp_service.h less more

22	22	#define ABSTRACT_TCP_SERVICE_H
23	23	//------------------------------------------------------------------------------
24	24	#include <atomic>
25		#include <condition_variable>
26	25	#include <mutex>
27	26	#include <queue>
28	27	#include <thread>
29	28	#include <vector>
	29	#include <condition_variable>
30	30
31	31	#include "ip_endpoint.h"
32	32	//------------------------------------------------------------------------------

63	63	//! Fills 'struct timespec' value using clock timeout
64	64	inline static void fillDuration(struct timespec& ts)
65	65	{
66		ts.tv_sec = ClockTimeoutMs / 1000;
	66	ts.tv_sec = ClockTimeoutMs / 1000;
67	67	ts.tv_nsec = ClockTimeoutMs % 1000 * 1000000;
68	68	}
69	69

71	71	virtual void start();
72	72	//! Stops TCP-service
73	73	virtual void stop();
	74
74	75	protected:
75	76	//! Asbtract TCP-service task
76	77	class AbstractTask

93	94
94	95	//! Task execution pure virtual method to override
95	96	virtual void execute() = 0;
	97
96	98	private:
97	99	int _socket;
98	100	};
99	101
100	102	virtual AbstractTask* createTask(int socket) = 0;
	103
101	104	private:
102	105	using ThreadPool = std::vector<std::thread>;
103	106
104		static constexpr int ClockTimeoutMs = 100;
105		static constexpr std::size_t ReadBufferSize = 1024;
106		static constexpr std::size_t WriteBufferSize = 4096;
107		static constexpr std::size_t HeaderPartSize = 1024;
108		static constexpr int MaxTasksQueueSize = 128;
	107	static constexpr int ClockTimeoutMs = 100;
	108	static constexpr std::size_t ReadBufferSize = 1024;
	109	static constexpr std::size_t WriteBufferSize = 4096;
	110	static constexpr std::size_t HeaderPartSize = 1024;
	111	static constexpr int MaxTasksQueueSize = 128;
109	112
110	113	void runWorker();
111	114	void runListener();
112	115
113		const int _port;
114		const std::string _host;
115		const int _backlog;
116		std::atomic_bool _isRunning;
117		ThreadPool _threadPool;
118		std::thread _listenerThread;
119		int _serverSocket;
	116	const int _port;
	117	const std::string _host;
	118	const int _backlog;
	119	std::atomic_bool _isRunning;
	120	ThreadPool _threadPool;
	121	std::thread _listenerThread;
	122	int _serverSocket;
120	123	std::queue<AbstractTask*> _tasksQueue;
121		std::mutex _tasksQueueMutex;
122		std::condition_variable _tasksQueueCond;
	124	std::mutex _tasksQueueMutex;
	125	std::condition_variable _tasksQueueCond;
123	126	};
124	127	//------------------------------------------------------------------------------
125		#endif//ABSTRACT_TCP_SERVICE_H
	128	#endif //ABSTRACT_TCP_SERVICE_H
126	129	//------------------------------------------------------------------------------

-7

analyzers/src/json/ip_endpoint.cpp less more

26	26	#include "ip_endpoint.h"
27	27	//------------------------------------------------------------------------------
28	28
29		IpEndpoint::IpEndpoint(const std::string& host, int port, bool hostAsAddress) :
30		_addrinfo{}
	29	IpEndpoint::IpEndpoint(const std::string& host, int port, bool hostAsAddress)
	30	: _addrinfo{}
31	31	{
32	32	struct addrinfo hints;
33	33	memset(&hints, 0, sizeof hints);
34		hints.ai_family = AF_INET;
	34	hints.ai_family = AF_INET;
35	35	hints.ai_socktype = SOCK_STREAM;
36	36	hints.ai_flags \|= AI_NUMERICSERV;
37	37	std::string serviceStr{std::to_string(port)};
38		if (host == WildcardAddress)
	38	if(host == WildcardAddress)
39	39	{
40	40	hints.ai_flags \|= AI_PASSIVE;
41	41	}
42		if ((host != WildcardAddress) && (host != LoopbackAddress))
	42	if((host != WildcardAddress) && (host != LoopbackAddress))
43	43	{
44	44	hints.ai_flags \|= AI_CANONNAME;
45		if (hostAsAddress)
	45	if(hostAsAddress)
46	46	{
47	47	hints.ai_flags \|= AI_NUMERICHOST;
48	48	}
49	49	}
50	50	int status = getaddrinfo((host == LoopbackAddress) \|\| (host == WildcardAddress) ? nullptr : host.c_str(),
51	51	serviceStr.c_str(), &hints, &_addrinfo);
52		if (status != 0)
	52	if(status != 0)
53	53	{
54	54	throw std::runtime_error{gai_strerror(status)};
55	55	}

-1

analyzers/src/json/ip_endpoint.h less more

50	50	{
51	51	return _addrinfo;
52	52	}
	53
53	54	private:
54	55	struct addrinfo* _addrinfo;
55	56	};
56	57	//------------------------------------------------------------------------------
57		#endif//IP_ENDPOINT_H
	58	#endif //IP_ENDPOINT_H
58	59	//------------------------------------------------------------------------------

+10

-10

analyzers/src/json/json_analyzer.cpp less more

21	21	#include "json_analyzer.h"
22	22	//------------------------------------------------------------------------------
23	23
24		JsonAnalyzer::JsonAnalyzer(std::size_t workersAmount, int port, const std::string& host, std::size_t maxServingDurationMs, int backlog) :
25		_jsonTcpService{*this, workersAmount, port, host, maxServingDurationMs, backlog},
26		_nfsV3Stat{},
27		_nfsV40Stat{},
28		_nfsV41Stat{}
	24	JsonAnalyzer::JsonAnalyzer(std::size_t workersAmount, int port, const std::string& host, std::size_t maxServingDurationMs, int backlog)
	25	: _jsonTcpService{*this, workersAmount, port, host, maxServingDurationMs, backlog}
	26	, _nfsV3Stat{}
	27	, _nfsV40Stat{}
	28	, _nfsV41Stat{}
29	29	{
30	30	_jsonTcpService.start();
31	31	}

36	36	}
37	37
38	38	// NFS3
39		// Procedures:
	39	// Procedures:
40	40
41	41	void JsonAnalyzer::null(const RPCProcedure* /proc/,
42	42	const struct NFS3::NULL3args* /args/,

193	193	}
194	194
195	195	// NFS4.0
196		// Procedures:
	196	// Procedures:
197	197
198	198	void JsonAnalyzer::null4(const RPCProcedure* /proc/,
199	199	const struct NFS4::NULL4args* /args/,

476	476	}
477	477
478	478	// NFS4.1
479		// Procedures:
480
	479	// Procedures:
	480
481	481	void JsonAnalyzer::compound41(const RPCProcedure* /proc/,
482	482	const struct NFS41::COMPOUND4args* /args/,
483	483	const struct NFS41::COMPOUND4res* /res/)

747	747	}
748	748
749	749	void JsonAnalyzer::bind_conn_to_session41(const RPCProcedure* /* proc */,
750		const struct NFS41::BIND_CONN_TO_SESSION4args* /* args */,
	750	const struct NFS41::BIND_CONN_TO_SESSION4args* /* args */,
751	751	const struct NFS41::BIND_CONN_TO_SESSION4res* res)
752	752	{
753	753	if(res) _nfsV41Stat.bind_conn_to_sessionOpsAmount++;

+131

-131

analyzers/src/json/json_analyzer.h less more

34	34	struct NfsV3Stat
35	35	{
36	36	// Procedures:
37		std::atomic_int nullProcsAmount = {0};
38		std::atomic_int getattrProcsAmount = {0};
39		std::atomic_int setattrProcsAmount = {0};
40		std::atomic_int lookupProcsAmount = {0};
41		std::atomic_int accessProcsAmount = {0};
42		std::atomic_int readlinkProcsAmount = {0};
43		std::atomic_int readProcsAmount = {0};
44		std::atomic_int writeProcsAmount = {0};
45		std::atomic_int createProcsAmount = {0};
46		std::atomic_int mkdirProcsAmount = {0};
47		std::atomic_int symlinkProcsAmount = {0};
48		std::atomic_int mknodProcsAmount = {0};
49		std::atomic_int removeProcsAmount = {0};
50		std::atomic_int rmdirProcsAmount = {0};
51		std::atomic_int renameProcsAmount = {0};
52		std::atomic_int linkProcsAmount = {0};
53		std::atomic_int readdirProcsAmount = {0};
	37	std::atomic_int nullProcsAmount = {0};
	38	std::atomic_int getattrProcsAmount = {0};
	39	std::atomic_int setattrProcsAmount = {0};
	40	std::atomic_int lookupProcsAmount = {0};
	41	std::atomic_int accessProcsAmount = {0};
	42	std::atomic_int readlinkProcsAmount = {0};
	43	std::atomic_int readProcsAmount = {0};
	44	std::atomic_int writeProcsAmount = {0};
	45	std::atomic_int createProcsAmount = {0};
	46	std::atomic_int mkdirProcsAmount = {0};
	47	std::atomic_int symlinkProcsAmount = {0};
	48	std::atomic_int mknodProcsAmount = {0};
	49	std::atomic_int removeProcsAmount = {0};
	50	std::atomic_int rmdirProcsAmount = {0};
	51	std::atomic_int renameProcsAmount = {0};
	52	std::atomic_int linkProcsAmount = {0};
	53	std::atomic_int readdirProcsAmount = {0};
54	54	std::atomic_int readdirplusProcsAmount = {0};
55		std::atomic_int fsstatProcsAmount = {0};
56		std::atomic_int fsinfoProcsAmount = {0};
57		std::atomic_int pathconfProcsAmount = {0};
58		std::atomic_int commitProcsAmount = {0};
	55	std::atomic_int fsstatProcsAmount = {0};
	56	std::atomic_int fsinfoProcsAmount = {0};
	57	std::atomic_int pathconfProcsAmount = {0};
	58	std::atomic_int commitProcsAmount = {0};
59	59	};
60	60	struct NfsV40Stat
61	61	{
62	62	// Procedures:
63		std::atomic_int nullProcsAmount = {0};
	63	std::atomic_int nullProcsAmount = {0};
64	64	std::atomic_int compoundProcsAmount = {0};
65	65
66	66	// Operations:
67		std::atomic_int accessOpsAmount = {0};
68		std::atomic_int closeOpsAmount = {0};
69		std::atomic_int commitOpsAmount = {0};
70		std::atomic_int createOpsAmount = {0};
71		std::atomic_int delegpurgeOpsAmount = {0};
72		std::atomic_int delegreturnOpsAmount = {0};
73		std::atomic_int getattrOpsAmount = {0};
74		std::atomic_int getfhOpsAmount = {0};
75		std::atomic_int linkOpsAmount = {0};
76		std::atomic_int lockOpsAmount = {0};
77		std::atomic_int locktOpsAmount = {0};
78		std::atomic_int lockuOpsAmount = {0};
79		std::atomic_int lookupOpsAmount = {0};
80		std::atomic_int lookuppOpsAmount = {0};
81		std::atomic_int nverifyOpsAmount = {0};
82		std::atomic_int openOpsAmount = {0};
83		std::atomic_int openattrOpsAmount = {0};
84		std::atomic_int open_confirmOpsAmount = {0};
85		std::atomic_int open_downgradeOpsAmount = {0};
86		std::atomic_int putfhOpsAmount = {0};
87		std::atomic_int putpubfhOpsAmount = {0};
88		std::atomic_int putrootfhOpsAmount = {0};
89		std::atomic_int readOpsAmount = {0};
90		std::atomic_int readdirOpsAmount = {0};
91		std::atomic_int readlinkOpsAmount = {0};
92		std::atomic_int removeOpsAmount = {0};
93		std::atomic_int renameOpsAmount = {0};
94		std::atomic_int renewOpsAmount = {0};
95		std::atomic_int restorefhOpsAmount = {0};
96		std::atomic_int savefhOpsAmount = {0};
97		std::atomic_int secinfoOpsAmount = {0};
98		std::atomic_int setattrOpsAmount = {0};
99		std::atomic_int setclientidOpsAmount = {0};
	67	std::atomic_int accessOpsAmount = {0};
	68	std::atomic_int closeOpsAmount = {0};
	69	std::atomic_int commitOpsAmount = {0};
	70	std::atomic_int createOpsAmount = {0};
	71	std::atomic_int delegpurgeOpsAmount = {0};
	72	std::atomic_int delegreturnOpsAmount = {0};
	73	std::atomic_int getattrOpsAmount = {0};
	74	std::atomic_int getfhOpsAmount = {0};
	75	std::atomic_int linkOpsAmount = {0};
	76	std::atomic_int lockOpsAmount = {0};
	77	std::atomic_int locktOpsAmount = {0};
	78	std::atomic_int lockuOpsAmount = {0};
	79	std::atomic_int lookupOpsAmount = {0};
	80	std::atomic_int lookuppOpsAmount = {0};
	81	std::atomic_int nverifyOpsAmount = {0};
	82	std::atomic_int openOpsAmount = {0};
	83	std::atomic_int openattrOpsAmount = {0};
	84	std::atomic_int open_confirmOpsAmount = {0};
	85	std::atomic_int open_downgradeOpsAmount = {0};
	86	std::atomic_int putfhOpsAmount = {0};
	87	std::atomic_int putpubfhOpsAmount = {0};
	88	std::atomic_int putrootfhOpsAmount = {0};
	89	std::atomic_int readOpsAmount = {0};
	90	std::atomic_int readdirOpsAmount = {0};
	91	std::atomic_int readlinkOpsAmount = {0};
	92	std::atomic_int removeOpsAmount = {0};
	93	std::atomic_int renameOpsAmount = {0};
	94	std::atomic_int renewOpsAmount = {0};
	95	std::atomic_int restorefhOpsAmount = {0};
	96	std::atomic_int savefhOpsAmount = {0};
	97	std::atomic_int secinfoOpsAmount = {0};
	98	std::atomic_int setattrOpsAmount = {0};
	99	std::atomic_int setclientidOpsAmount = {0};
100	100	std::atomic_int setclientid_confirmOpsAmount = {0};
101		std::atomic_int verifyOpsAmount = {0};
102		std::atomic_int writeOpsAmount = {0};
103		std::atomic_int release_lockownerOpsAmount = {0};
104		std::atomic_int get_dir_delegationOpsAmount = {0};
105		std::atomic_int illegalOpsAmount = {0};
	101	std::atomic_int verifyOpsAmount = {0};
	102	std::atomic_int writeOpsAmount = {0};
	103	std::atomic_int release_lockownerOpsAmount = {0};
	104	std::atomic_int get_dir_delegationOpsAmount = {0};
	105	std::atomic_int illegalOpsAmount = {0};
106	106	};
107	107	struct NfsV41Stat
108	108	{
109	109	// Procedures:
110		std::atomic_int nullProcsAmount = {0};
	110	std::atomic_int nullProcsAmount = {0};
111	111	std::atomic_int compoundProcsAmount = {0};
112	112
113	113	// Operations:
114		std::atomic_int accessOpsAmount = {0};
115		std::atomic_int closeOpsAmount = {0};
116		std::atomic_int commitOpsAmount = {0};
117		std::atomic_int createOpsAmount = {0};
118		std::atomic_int delegpurgeOpsAmount = {0};
119		std::atomic_int delegreturnOpsAmount = {0};
120		std::atomic_int getattrOpsAmount = {0};
121		std::atomic_int getfhOpsAmount = {0};
122		std::atomic_int linkOpsAmount = {0};
123		std::atomic_int lockOpsAmount = {0};
124		std::atomic_int locktOpsAmount = {0};
125		std::atomic_int lockuOpsAmount = {0};
126		std::atomic_int lookupOpsAmount = {0};
127		std::atomic_int lookuppOpsAmount = {0};
128		std::atomic_int nverifyOpsAmount = {0};
129		std::atomic_int openOpsAmount = {0};
130		std::atomic_int openattrOpsAmount = {0};
131		std::atomic_int open_confirmOpsAmount = {0};
132		std::atomic_int open_downgradeOpsAmount = {0};
133		std::atomic_int putfhOpsAmount = {0};
134		std::atomic_int putpubfhOpsAmount = {0};
135		std::atomic_int putrootfhOpsAmount = {0};
136		std::atomic_int readOpsAmount = {0};
137		std::atomic_int readdirOpsAmount = {0};
138		std::atomic_int readlinkOpsAmount = {0};
139		std::atomic_int removeOpsAmount = {0};
140		std::atomic_int renameOpsAmount = {0};
141		std::atomic_int renewOpsAmount = {0};
142		std::atomic_int restorefhOpsAmount = {0};
143		std::atomic_int savefhOpsAmount = {0};
144		std::atomic_int secinfoOpsAmount = {0};
145		std::atomic_int setattrOpsAmount = {0};
146		std::atomic_int setclientidOpsAmount = {0};
147		std::atomic_int setclientid_confirmOpsAmount = {0};
148		std::atomic_int verifyOpsAmount = {0};
149		std::atomic_int writeOpsAmount = {0};
150		std::atomic_int release_lockownerOpsAmount = {0};
151		std::atomic_int backchannel_ctlOpsAmount = {0};
	114	std::atomic_int accessOpsAmount = {0};
	115	std::atomic_int closeOpsAmount = {0};
	116	std::atomic_int commitOpsAmount = {0};
	117	std::atomic_int createOpsAmount = {0};
	118	std::atomic_int delegpurgeOpsAmount = {0};
	119	std::atomic_int delegreturnOpsAmount = {0};
	120	std::atomic_int getattrOpsAmount = {0};
	121	std::atomic_int getfhOpsAmount = {0};
	122	std::atomic_int linkOpsAmount = {0};
	123	std::atomic_int lockOpsAmount = {0};
	124	std::atomic_int locktOpsAmount = {0};
	125	std::atomic_int lockuOpsAmount = {0};
	126	std::atomic_int lookupOpsAmount = {0};
	127	std::atomic_int lookuppOpsAmount = {0};
	128	std::atomic_int nverifyOpsAmount = {0};
	129	std::atomic_int openOpsAmount = {0};
	130	std::atomic_int openattrOpsAmount = {0};
	131	std::atomic_int open_confirmOpsAmount = {0};
	132	std::atomic_int open_downgradeOpsAmount = {0};
	133	std::atomic_int putfhOpsAmount = {0};
	134	std::atomic_int putpubfhOpsAmount = {0};
	135	std::atomic_int putrootfhOpsAmount = {0};
	136	std::atomic_int readOpsAmount = {0};
	137	std::atomic_int readdirOpsAmount = {0};
	138	std::atomic_int readlinkOpsAmount = {0};
	139	std::atomic_int removeOpsAmount = {0};
	140	std::atomic_int renameOpsAmount = {0};
	141	std::atomic_int renewOpsAmount = {0};
	142	std::atomic_int restorefhOpsAmount = {0};
	143	std::atomic_int savefhOpsAmount = {0};
	144	std::atomic_int secinfoOpsAmount = {0};
	145	std::atomic_int setattrOpsAmount = {0};
	146	std::atomic_int setclientidOpsAmount = {0};
	147	std::atomic_int setclientid_confirmOpsAmount = {0};
	148	std::atomic_int verifyOpsAmount = {0};
	149	std::atomic_int writeOpsAmount = {0};
	150	std::atomic_int release_lockownerOpsAmount = {0};
	151	std::atomic_int backchannel_ctlOpsAmount = {0};
152	152	std::atomic_int bind_conn_to_sessionOpsAmount = {0};
153		std::atomic_int exchange_idOpsAmount = {0};
154		std::atomic_int create_sessionOpsAmount = {0};
155		std::atomic_int destroy_sessionOpsAmount = {0};
156		std::atomic_int free_stateidOpsAmount = {0};
157		std::atomic_int get_dir_delegationOpsAmount = {0};
158		std::atomic_int getdeviceinfoOpsAmount = {0};
159		std::atomic_int getdevicelistOpsAmount = {0};
160		std::atomic_int layoutcommitOpsAmount = {0};
161		std::atomic_int layoutgetOpsAmount = {0};
162		std::atomic_int layoutreturnOpsAmount = {0};
163		std::atomic_int secinfo_no_nameOpsAmount = {0};
164		std::atomic_int sequenceOpsAmount = {0};
165		std::atomic_int set_ssvOpsAmount = {0};
166		std::atomic_int test_stateidOpsAmount = {0};
167		std::atomic_int want_delegationOpsAmount = {0};
168		std::atomic_int destroy_clientidOpsAmount = {0};
169		std::atomic_int reclaim_completeOpsAmount = {0};
170		std::atomic_int illegalOpsAmount = {0};
	153	std::atomic_int exchange_idOpsAmount = {0};
	154	std::atomic_int create_sessionOpsAmount = {0};
	155	std::atomic_int destroy_sessionOpsAmount = {0};
	156	std::atomic_int free_stateidOpsAmount = {0};
	157	std::atomic_int get_dir_delegationOpsAmount = {0};
	158	std::atomic_int getdeviceinfoOpsAmount = {0};
	159	std::atomic_int getdevicelistOpsAmount = {0};
	160	std::atomic_int layoutcommitOpsAmount = {0};
	161	std::atomic_int layoutgetOpsAmount = {0};
	162	std::atomic_int layoutreturnOpsAmount = {0};
	163	std::atomic_int secinfo_no_nameOpsAmount = {0};
	164	std::atomic_int sequenceOpsAmount = {0};
	165	std::atomic_int set_ssvOpsAmount = {0};
	166	std::atomic_int test_stateidOpsAmount = {0};
	167	std::atomic_int want_delegationOpsAmount = {0};
	168	std::atomic_int destroy_clientidOpsAmount = {0};
	169	std::atomic_int reclaim_completeOpsAmount = {0};
	170	std::atomic_int illegalOpsAmount = {0};
171	171	};
172	172
173	173	JsonAnalyzer(std::size_t workersAmount, int port, const std::string& host, std::size_t maxServingDurationMs, int backlog);

264	264	const struct NFS3::COMMIT3res* /res/) override final;
265	265
266	266	// NFS4.0 procedures
267
	267
268	268	void null4(const RPCProcedure* /proc/,
269	269	const struct NFS4::NULL4args* /args/,
270	270	const struct NFS4::NULL4res* /res/) override final;

279	279	const struct NFS4::ACCESS4args* /* args */,
280	280	const struct NFS4::ACCESS4res* res) override final;
281	281	void close40(const RPCProcedure* /* proc */,
282		const struct NFS4::CLOSE4args* /* args */,
283		const struct NFS4::CLOSE4res* res) override final;
	282	const struct NFS4::CLOSE4args* /* args */,
	283	const struct NFS4::CLOSE4res* res) override final;
284	284	void commit40(const RPCProcedure* /* proc */,
285	285	const struct NFS4::COMMIT4args* /* args */,
286	286	const struct NFS4::COMMIT4res* res) override final;

386	386	const struct NFS4::ILLEGAL4res* res) override final;
387	387
388	388	// NFSv4.1 procedures
389
	389
390	390	void compound41(const RPCProcedure* /proc/,
391	391	const struct NFS41::COMPOUND4args* /args/,
392	392	const struct NFS41::COMPOUND4res* /res/) override final;

397	397	const struct NFS41::ACCESS4args* /* args */,
398	398	const struct NFS41::ACCESS4res* res) override final;
399	399	void close41(const RPCProcedure* /* proc */,
400		const struct NFS41::CLOSE4args* /* args */,
401		const struct NFS41::CLOSE4res* res) override final;
	400	const struct NFS41::CLOSE4args* /* args */,
	401	const struct NFS41::CLOSE4res* res) override final;
402	402	void commit41(const RPCProcedure* /* proc */,
403	403	const struct NFS41::COMMIT4args* /* args */,
404	404	const struct NFS41::COMMIT4res* res) override final;

501	501	const struct NFS41::BACKCHANNEL_CTL4args* /* args */,
502	502	const struct NFS41::BACKCHANNEL_CTL4res* res) override final;
503	503	void bind_conn_to_session41(const RPCProcedure* /* proc */,
504		const struct NFS41::BIND_CONN_TO_SESSION4args* /* args */,
	504	const struct NFS41::BIND_CONN_TO_SESSION4args* /* args */,
505	505	const struct NFS41::BIND_CONN_TO_SESSION4res* res) override final;
506	506	void exchange_id41(const RPCProcedure* /* proc */,
507	507	const struct NFS41::EXCHANGE_ID4args* /* args */,

534	534	const struct NFS41::LAYOUTRETURN4args* /* args */,
535	535	const struct NFS41::LAYOUTRETURN4res* res) override final;
536	536	void secinfo_no_name41(const RPCProcedure* /* proc */,
537		const NFS41::SECINFO_NO_NAME4args* /* args */,
538		const NFS41::SECINFO_NO_NAME4res* res) override final;
	537	const NFS41::SECINFO_NO_NAME4args* /* args */,
	538	const NFS41::SECINFO_NO_NAME4res* res) override final;
539	539	void sequence41(const RPCProcedure* /* proc */,
540	540	const struct NFS41::SEQUENCE4args* /* args */,
541	541	const struct NFS41::SEQUENCE4res* res) override final;

576	576
577	577	private:
578	578	JsonTcpService _jsonTcpService;
579		NfsV3Stat _nfsV3Stat;
580		NfsV40Stat _nfsV40Stat;
581		NfsV41Stat _nfsV41Stat;
	579	NfsV3Stat _nfsV3Stat;
	580	NfsV40Stat _nfsV40Stat;
	581	NfsV41Stat _nfsV41Stat;
582	582	};
583	583	//------------------------------------------------------------------------------
584		#endif//JSON_ANALYZER_H
585		//------------------------------------------------------------------------------
	584	#endif //JSON_ANALYZER_H
	585	//------------------------------------------------------------------------------

+74

-76

analyzers/src/json/json_plugin.cpp less more

22	22	#include "json_analyzer.h"
23	23	//------------------------------------------------------------------------------
24	24
25		static constexpr int DefaultPort = 8888;
26		static constexpr const char * DefaultHost = IpEndpoint::WildcardAddress;
27		static constexpr std::size_t DefaultWorkersAmount = 10U;
28		static constexpr int DefaultBacklog = 15;
	25	static constexpr int DefaultPort = 8888;
	26	static constexpr const char* DefaultHost = IpEndpoint::WildcardAddress;
	27	static constexpr std::size_t DefaultWorkersAmount = 10U;
	28	static constexpr int DefaultBacklog = 15;
29	29	static constexpr std::size_t DefaultMaxServingDurationMs = 500U;
30	30
31		extern "C"
	31	extern "C" {
	32
	33	const char* usage()
32	34	{
	35	return "host - Network interface to listen (default is to listen all interfaces)\n"
	36	"port - IP-port to bind to (default is 8888)\n"
	37	"workers - Amount of worker threads (default is 10)\n"
	38	"duration - Max serving duration in milliseconds (default is 500 ms)\n"
	39	"backlog - Listen backlog (default is 15)";
	40	}
33	41
34		const char* usage()
	42	IAnalyzer* create(const char* opts)
	43	{
	44	// Initializing plugin options with default values
	45	int backlog = DefaultBacklog;
	46	std::size_t maxServingDurationMs = DefaultMaxServingDurationMs;
	47	std::string host{DefaultHost};
	48	int port = DefaultPort;
	49	std::size_t workersAmount = DefaultWorkersAmount;
	50	// Parising plugin options
	51	enum
35	52	{
36		return "host - Network interface to listen (default is to listen all interfaces)\n"
37		"port - IP-port to bind to (default is 8888)\n"
38		"workers - Amount of worker threads (default is 10)\n"
39		"duration - Max serving duration in milliseconds (default is 500 ms)\n"
40		"backlog - Listen backlog (default is 15)";
41		}
42
43		IAnalyzer* create(const char* opts)
44		{
45		// Initializing plugin options with default values
46		int backlog = DefaultBacklog;
47		std::size_t maxServingDurationMs = DefaultMaxServingDurationMs;
48		std::string host{DefaultHost};
49		int port = DefaultPort;
50		std::size_t workersAmount = DefaultWorkersAmount;
51		// Parising plugin options
52		enum
53		{
54		BACKLOG_SUBOPT_INDEX = 0,
55		DURATION_SUBOPT_INDEX,
56		HOST_SUBOPT_INDEX,
57		PORT_SUBOPT_INDEX,
58		WORKERS_SUBOPT_INDEX
59		};
60		char backlogSubOptName[] = "backlog";
61		char durationSubOptName[] = "duration";
62		char hostSubOptName[] = "host";
63		char portSubOptName[] = "port";
64		char workersSubOptName[] = "workers";
65		char* const tokens[] =
	53	BACKLOG_SUBOPT_INDEX = 0,
	54	DURATION_SUBOPT_INDEX,
	55	HOST_SUBOPT_INDEX,
	56	PORT_SUBOPT_INDEX,
	57	WORKERS_SUBOPT_INDEX
	58	};
	59	char backlogSubOptName[] = "backlog";
	60	char durationSubOptName[] = "duration";
	61	char hostSubOptName[] = "host";
	62	char portSubOptName[] = "port";
	63	char workersSubOptName[] = "workers";
	64	char* const tokens[] =
66	65	{
67	66	backlogSubOptName,
68	67	durationSubOptName,
69	68	hostSubOptName,
70	69	portSubOptName,
71	70	workersSubOptName,
72		NULL
73		};
74		std::size_t optsLen = strlen(opts);
75		std::vector<char> optsBuf{opts, opts + optsLen + 2};
76		char* optionp = &optsBuf[0];
77		char* valuep;
78		int optIndex;
79		while ((optIndex = getsubopt(&optionp, tokens, &valuep)) >= 0)
	71	NULL};
	72	std::size_t optsLen = strlen(opts);
	73	std::vector<char> optsBuf{opts, opts + optsLen + 2};
	74	char* optionp = &optsBuf[0];
	75	char* valuep;
	76	int optIndex;
	77	while((optIndex = getsubopt(&optionp, tokens, &valuep)) >= 0)
	78	{
	79	try
80	80	{
81		try
	81	switch(optIndex)
82	82	{
83		switch (optIndex)
84		{
85		case BACKLOG_SUBOPT_INDEX:
86		backlog = std::stoi(valuep);
87		break;
88		case DURATION_SUBOPT_INDEX:
89		maxServingDurationMs = std::stoul(valuep);
90		break;
91		case HOST_SUBOPT_INDEX:
92		host = valuep;
93		break;
94		case PORT_SUBOPT_INDEX:
95		port = std::stoi(valuep);
96		break;
97		case WORKERS_SUBOPT_INDEX:
98		workersAmount = std::stoul(valuep);
99		break;
100		default:
101		throw std::runtime_error{std::string{"Invalid suboption index: "} + std::to_string(optIndex)};
102		}
103		}
104		catch (std::logic_error& e)
105		{
106		throw std::runtime_error{std::string{"Invalid value provided for '"} + tokens[optIndex] + "' suboption"};
	83	case BACKLOG_SUBOPT_INDEX:
	84	backlog = std::stoi(valuep);
	85	break;
	86	case DURATION_SUBOPT_INDEX:
	87	maxServingDurationMs = std::stoul(valuep);
	88	break;
	89	case HOST_SUBOPT_INDEX:
	90	host = valuep;
	91	break;
	92	case PORT_SUBOPT_INDEX:
	93	port = std::stoi(valuep);
	94	break;
	95	case WORKERS_SUBOPT_INDEX:
	96	workersAmount = std::stoul(valuep);
	97	break;
	98	default:
	99	throw std::runtime_error{std::string{"Invalid suboption index: "} + std::to_string(optIndex)};
107	100	}
108	101	}
109		// Creating and returning plugin
110		return new JsonAnalyzer{workersAmount, port, host, maxServingDurationMs, backlog};
	102	catch(std::logic_error& e)
	103	{
	104	throw std::runtime_error{std::string{"Invalid value provided for '"} + tokens[optIndex] + "' suboption"};
	105	}
111	106	}
	107	// Creating and returning plugin
	108	return new JsonAnalyzer{workersAmount, port, host, maxServingDurationMs, backlog};
	109	}
112	110
113		void destroy(IAnalyzer* instance)
114		{
115		delete instance;
116		}
	111	void destroy(IAnalyzer* instance)
	112	{
	113	delete instance;
	114	}
117	115
118		NST_PLUGIN_ENTRY_POINTS (&usage, &create, &destroy, nullptr)
	116	NST_PLUGIN_ENTRY_POINTS(&usage, &create, &destroy, nullptr)
119	117
120	118	} //extern "C"
121	119

+20

-18

analyzers/src/json/json_tcp_service.cpp less more

28	28	//------------------------------------------------------------------------------
29	29
30	30	JsonTcpService::JsonTcpService(JsonAnalyzer& analyzer, std::size_t workersAmount, int port, const std::string& host,
31		std::size_t maxServingDurationMs, int backlog) :
32		AbstractTcpService{workersAmount, port, host, backlog},
33		_analyzer(analyzer),
34		_maxServingDurationMs{maxServingDurationMs}
35		{}
	31	std::size_t maxServingDurationMs, int backlog)
	32	: AbstractTcpService{workersAmount, port, host, backlog}
	33	, _analyzer(analyzer)
	34	, _maxServingDurationMs{maxServingDurationMs}
	35	{
	36	}
36	37
37	38	AbstractTcpService::AbstractTask* JsonTcpService::createTask(int socket)
38	39	{

41	42
42	43	//------------------------------------------------------------------------------
43	44
44		JsonTcpService::Task::Task(JsonTcpService& service, int socket) :
45		AbstractTask{socket},
46		_service(service)
47		{}
	45	JsonTcpService::Task::Task(JsonTcpService& service, int socket)
	46	: AbstractTask{socket}
	47	, _service(service)
	48	{
	49	}
48	50
49	51	void JsonTcpService::Task::execute()
50	52	{
51	53	std::chrono::system_clock::time_point servingStarted = std::chrono::system_clock::now();
52	54	// Composing JSON with statistics
53		struct json_object* root = json_object_new_object();
	55	struct json_object* root = json_object_new_object();
54	56	struct json_object* nfsV3Stat = json_object_new_object();
55	57	// NFS3 procedures:
56	58	json_object_object_add(nfsV3Stat, "null", json_object_new_int64(_service._analyzer.getNfsV3Stat().nullProcsAmount.load()));

189	191
190	192	// Sending JSON to the client
191	193	std::size_t totalBytesSent = 0U;
192		while (totalBytesSent < json.length())
	194	while(totalBytesSent < json.length())
193	195	{
194		if (!_service.isRunning())
	196	if(!_service.isRunning())
195	197	{
196	198	LOG("WARNING: Service shutdown detected - terminating task execution");
197	199	return;
198	200	}
199		if (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - servingStarted).count() >
200		static_cast<std::chrono::milliseconds::rep>(_service._maxServingDurationMs))
	201	if(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - servingStarted).count() >
	202	static_cast<std::chrono::milliseconds::rep>(_service._maxServingDurationMs))
201	203	{
202	204	// TODO: Use general logging
203	205	LOG("WARNING: A client is too slow - terminating task execution");

209	211	FD_ZERO(&writeDescriptorsSet);
210	212	FD_SET(socket(), &writeDescriptorsSet);
211	213	int descriptorsCount = pselect(socket() + 1, NULL, &writeDescriptorsSet, NULL, &writeDuration, NULL);
212		if (descriptorsCount < 0)
	214	if(descriptorsCount < 0)
213	215	{
214	216	throw std::system_error{errno, std::system_category(), "Error awaiting for sending data availability on socket"};
215	217	}
216		else if (descriptorsCount == 0)
	218	else if(descriptorsCount == 0)
217	219	{
218	220	// Timeout expired
219	221	continue;
220	222	}
221	223	ssize_t bytesSent = send(socket(), json.data() + totalBytesSent, json.length() - totalBytesSent, MSG_NOSIGNAL);
222		if (bytesSent < 0)
	224	if(bytesSent < 0)
223	225	{
224	226	std::system_error e{errno, std::system_category(), "Sending data to client error"};
225	227	LOG("WARNING: %s", e.what());
226	228	return;
227	229	}
228		else if (bytesSent == 0)
	230	else if(bytesSent == 0)
229	231	{
230	232	LOG("WARNING: Connection has been aborted by client while sending data");
231	233	return;

-2

analyzers/src/json/json_tcp_service.h less more

29	29	JsonTcpService() = delete;
30	30	JsonTcpService(class JsonAnalyzer& analyzer, std::size_t workersAmount, int port, const std::string& host,
31	31	std::size_t maxServingDurationMs, int backlog);
	32
32	33	private:
33	34	class Task : public AbstractTask
34	35	{

37	38	Task() = delete;
38	39
39	40	void execute() override final;
	41
40	42	private:
41	43	JsonTcpService& _service;
42	44	};

44	46	AbstractTask* createTask(int socket) override final;
45	47
46	48	JsonAnalyzer& _analyzer;
47		std::size_t _maxServingDurationMs;
	49	std::size_t _maxServingDurationMs;
48	50	};
49	51	//------------------------------------------------------------------------------
50		#endif//JSON_TCP_SERVICE_H
	52	#endif //JSON_TCP_SERVICE_H
51	53	//------------------------------------------------------------------------------

+63

-62

analyzers/src/test/test_analyzer.cpp less more

26	26	class TestAnalyzer : public IAnalyzer
27	27	{
28	28	public:
29		TestAnalyzer(const char* opts):options(opts)
	29	TestAnalyzer(const char* opts)
	30	: options(opts)
30	31	{
31	32	std::cout << "TestAnalyzer::TestAnalyzer(" << options << ')' << std::endl;
32	33	}

39	40	// NFSv3 procedures
40	41
41	42	void null(const RPCProcedure* /proc/,
42		const struct NFS3::NULL3args* /args/,
43		const struct NFS3::NULL3res* /res/) override final
	43	const struct NFS3::NULL3args* /args/,
	44	const struct NFS3::NULL3res* /res/) override final
44	45	{
45	46	std::cout << "TestAnalyzer::null()" << std::endl;
46	47	}
47	48
48	49	void getattr3(const RPCProcedure* /proc/,
49		const struct NFS3::GETATTR3args* /args/,
50		const struct NFS3::GETATTR3res* /res/) override final
	50	const struct NFS3::GETATTR3args* /args/,
	51	const struct NFS3::GETATTR3res* /res/) override final
51	52	{
52	53	std::cout << "TestAnalyzer::getattr3()" << std::endl;
53	54	}
54	55
55	56	void setattr3(const RPCProcedure* /proc/,
56		const struct NFS3::SETATTR3args* /args/,
57		const struct NFS3::SETATTR3res* /res/) override final
	57	const struct NFS3::SETATTR3args* /args/,
	58	const struct NFS3::SETATTR3res* /res/) override final
58	59	{
59	60	std::cout << "TestAnalyzer::setattr3()" << std::endl;
60	61	}
61	62
62	63	void lookup3(const RPCProcedure* /proc/,
63		const struct NFS3::LOOKUP3args* /args/,
64		const struct NFS3::LOOKUP3res* /res/) override final
	64	const struct NFS3::LOOKUP3args* /args/,
	65	const struct NFS3::LOOKUP3res* /res/) override final
65	66	{
66	67	std::cout << "TestAnalyzer::lookup3()" << std::endl;
67	68	}
68	69
69	70	void access3(const RPCProcedure* /proc/,
70		const struct NFS3::ACCESS3args* /args/,
71		const struct NFS3::ACCESS3res* /res/) override final
	71	const struct NFS3::ACCESS3args* /args/,
	72	const struct NFS3::ACCESS3res* /res/) override final
72	73	{
73	74	std::cout << "TestAnalyzer::access3()" << std::endl;
74	75	}
75	76
76	77	void readlink3(const RPCProcedure* /proc/,
77		const struct NFS3::READLINK3args* /args/,
78		const struct NFS3::READLINK3res* /res/) override final
	78	const struct NFS3::READLINK3args* /args/,
	79	const struct NFS3::READLINK3res* /res/) override final
79	80	{
80	81	std::cout << "TestAnalyzer::readlink3()" << std::endl;
81	82	}
82	83
83	84	void read3(const RPCProcedure* /proc/,
84		const struct NFS3::READ3args* /args/,
85		const struct NFS3::READ3res* /res/) override final
	85	const struct NFS3::READ3args* /args/,
	86	const struct NFS3::READ3res* /res/) override final
86	87	{
87	88	std::cout << "TestAnalyzer::read3()" << std::endl;
88	89	}
89	90
90	91	void write3(const RPCProcedure* /proc/,
91		const struct NFS3::WRITE3args* /args/,
92		const struct NFS3::WRITE3res* /res/) override final
	92	const struct NFS3::WRITE3args* /args/,
	93	const struct NFS3::WRITE3res* /res/) override final
93	94	{
94	95	std::cout << "TestAnalyzer::write3()" << std::endl;
95	96	}
96	97
97	98	void create3(const RPCProcedure* /proc/,
98		const struct NFS3::CREATE3args* /args/,
99		const struct NFS3::CREATE3res* /res/) override final
	99	const struct NFS3::CREATE3args* /args/,
	100	const struct NFS3::CREATE3res* /res/) override final
100	101	{
101	102	std::cout << "TestAnalyzer::create3()" << std::endl;
102	103	}
103	104
104	105	void mkdir3(const RPCProcedure* /proc/,
105		const struct NFS3::MKDIR3args* /args/,
106		const struct NFS3::MKDIR3res* /res/) override final
	106	const struct NFS3::MKDIR3args* /args/,
	107	const struct NFS3::MKDIR3res* /res/) override final
107	108	{
108	109	std::cout << "TestAnalyzer::mkdir3()" << std::endl;
109	110	}
110	111
111	112	void symlink3(const RPCProcedure* /proc/,
112		const struct NFS3::SYMLINK3args* /args/,
113		const struct NFS3::SYMLINK3res* /res/) override final
	113	const struct NFS3::SYMLINK3args* /args/,
	114	const struct NFS3::SYMLINK3res* /res/) override final
114	115	{
115	116	std::cout << "TestAnalyzer::symlink3()" << std::endl;
116	117	}
117	118
118	119	void mknod3(const RPCProcedure* /proc/,
119		const struct NFS3::MKNOD3args* /args/,
120		const struct NFS3::MKNOD3res* /res/) override final
	120	const struct NFS3::MKNOD3args* /args/,
	121	const struct NFS3::MKNOD3res* /res/) override final
121	122	{
122	123	std::cout << "TestAnalyzer::mknod3()" << std::endl;
123	124	}
124	125
125	126	void remove3(const RPCProcedure* /proc/,
126		const struct NFS3::REMOVE3args* /args/,
127		const struct NFS3::REMOVE3res* /res/) override final
	127	const struct NFS3::REMOVE3args* /args/,
	128	const struct NFS3::REMOVE3res* /res/) override final
128	129	{
129	130	std::cout << "TestAnalyzer::remove3()" << std::endl;
130	131	}
131	132
132	133	void rmdir3(const RPCProcedure* /proc/,
133		const struct NFS3::RMDIR3args* /args/,
134		const struct NFS3::RMDIR3res* /res/) override final
	134	const struct NFS3::RMDIR3args* /args/,
	135	const struct NFS3::RMDIR3res* /res/) override final
135	136	{
136	137	std::cout << "TestAnalyzer::rmdir3()" << std::endl;
137	138	}
138	139
139	140	void rename3(const RPCProcedure* /proc/,
140		const struct NFS3::RENAME3args* /args/,
141		const struct NFS3::RENAME3res* /res/) override final
	141	const struct NFS3::RENAME3args* /args/,
	142	const struct NFS3::RENAME3res* /res/) override final
142	143	{
143	144	std::cout << "TestAnalyzer::rename3()" << std::endl;
144	145	}
145	146
146	147	void link3(const RPCProcedure* /proc/,
147		const struct NFS3::LINK3args* /args/,
148		const struct NFS3::LINK3res* /res/) override final
	148	const struct NFS3::LINK3args* /args/,
	149	const struct NFS3::LINK3res* /res/) override final
149	150	{
150	151	std::cout << "TestAnalyzer::link3()" << std::endl;
151	152	}
152	153
153	154	void readdir3(const RPCProcedure* /proc/,
154		const struct NFS3::READDIR3args* /args/,
155		const struct NFS3::READDIR3res* /res/) override final
	155	const struct NFS3::READDIR3args* /args/,
	156	const struct NFS3::READDIR3res* /res/) override final
156	157	{
157	158	std::cout << "TestAnalyzer::readdir3()" << std::endl;
158	159	}
159	160
160	161	void readdirplus3(const RPCProcedure* /proc/,
161		const struct NFS3::READDIRPLUS3args* /args/,
162		const struct NFS3::READDIRPLUS3res* /res/) override final
	162	const struct NFS3::READDIRPLUS3args* /args/,
	163	const struct NFS3::READDIRPLUS3res* /res/) override final
163	164	{
164	165	std::cout << "TestAnalyzer::readdirplus3()" << std::endl;
165	166	}
166	167
167	168	void fsstat3(const RPCProcedure* /proc/,
168		const struct NFS3::FSSTAT3args* /args/,
169		const struct NFS3::FSSTAT3res* /res/) override final
	169	const struct NFS3::FSSTAT3args* /args/,
	170	const struct NFS3::FSSTAT3res* /res/) override final
170	171	{
171	172	std::cout << "TestAnalyzer::fsstat3()" << std::endl;
172	173	}
173	174
174	175	void fsinfo3(const RPCProcedure* /proc/,
175		const struct NFS3::FSINFO3args* /args/,
176		const struct NFS3::FSINFO3res* /res/) override final
	176	const struct NFS3::FSINFO3args* /args/,
	177	const struct NFS3::FSINFO3res* /res/) override final
177	178	{
178	179	std::cout << "TestAnalyzer::fsinfo3()" << std::endl;
179	180	}
180	181
181	182	void pathconf3(const RPCProcedure* /proc/,
182		const struct NFS3::PATHCONF3args* /args/,
183		const struct NFS3::PATHCONF3res* /res/) override final
	183	const struct NFS3::PATHCONF3args* /args/,
	184	const struct NFS3::PATHCONF3res* /res/) override final
184	185	{
185	186	std::cout << "TestAnalyzer::pathconf3()" << std::endl;
186	187	}
187	188
188	189	void commit3(const RPCProcedure* /proc/,
189		const struct NFS3::COMMIT3args* /args/,
190		const struct NFS3::COMMIT3res* /res/) override final
	190	const struct NFS3::COMMIT3args* /args/,
	191	const struct NFS3::COMMIT3res* /res/) override final
191	192	{
192	193	std::cout << "TestAnalyzer::commit3()" << std::endl;
193	194	}

201	202	std::cout << "TestAnalyzer::null4()" << std::endl;
202	203	}
203	204	void compound4(const RPCProcedure* /proc/,
204		const struct NFS4::COMPOUND4args* /args/,
205		const struct NFS4::COMPOUND4res* /res/) override final
	205	const struct NFS4::COMPOUND4args* /args/,
	206	const struct NFS4::COMPOUND4res* /res/) override final
206	207	{
207	208	std::cout << "TestAnalyzer::compound4()" << std::endl;
208	209	}

216	217	std::cout << "TestAnalyzer" << std::endl;
217	218	}
218	219	void close40(const RPCProcedure* /* proc */,
219		const struct NFS4::CLOSE4args* /* args */,
220		const struct NFS4::CLOSE4res* /* res */) override final
	220	const struct NFS4::CLOSE4args* /* args */,
	221	const struct NFS4::CLOSE4res* /* res */) override final
221	222	{
222	223	std::cout << "TestAnalyzer" << std::endl;
223	224	}

439	440	// NFSv4.1 procedures
440	441
441	442	void compound41(const RPCProcedure* /proc/,
442		const struct NFS41::COMPOUND4args* /args/,
443		const struct NFS41::COMPOUND4res* /res/) override final
	443	const struct NFS41::COMPOUND4args* /args/,
	444	const struct NFS41::COMPOUND4res* /res/) override final
444	445	{
445	446	std::cout << "TestAnalyzer::compound4()" << std::endl;
446	447	}

454	455	std::cout << "TestAnalyzer" << std::endl;
455	456	}
456	457	void close41(const RPCProcedure* /* proc */,
457		const struct NFS41::CLOSE4args* /* args */,
458		const struct NFS41::CLOSE4res* /* res */) override final
	458	const struct NFS41::CLOSE4args* /* args */,
	459	const struct NFS41::CLOSE4res* /* res */) override final
459	460	{
460	461	std::cout << "TestAnalyzer" << std::endl;
461	462	}

669	670	std::cout << "TestAnalyzer" << std::endl;
670	671	}
671	672	void bind_conn_to_session41(const RPCProcedure* /* proc */,
672		const struct NFS41::BIND_CONN_TO_SESSION4args* /* args */,
	673	const struct NFS41::BIND_CONN_TO_SESSION4args* /* args */,
673	674	const struct NFS41::BIND_CONN_TO_SESSION4res* /* res */) override final
674	675	{
675	676	std::cout << "TestAnalyzer" << std::endl;

735	736	std::cout << "TestAnalyzer" << std::endl;
736	737	}
737	738	void secinfo_no_name41(const RPCProcedure* /* proc */,
738		const NFS41::SECINFO_NO_NAME4args* /* args */,
739		const NFS41::SECINFO_NO_NAME4res* /* res */) override final
	739	const NFS41::SECINFO_NO_NAME4args* /* args */,
	740	const NFS41::SECINFO_NO_NAME4res* /* res */) override final
740	741	{
741	742	std::cout << "TestAnalyzer" << std::endl;
742	743	}

782	783	std::cout << "TestAnalyzer" << std::endl;
783	784	}
784	785
785		virtual void flush_statistics()
	786	virtual void flush_statistics() override
786	787	{
787	788	std::cout << "TestAnalyzer::flush_statistics()" << std::endl;
788	789	}
	790
789	791	private:
790	792	std::string options;
791	793	};
792	794
793		extern "C"
794		{
	795	extern "C" {
795	796
796	797	const char* usage()
797	798	{

814	815	return &requirements;
815	816	}
816	817
817		NST_PLUGIN_ENTRY_POINTS (&usage, &create, &destroy, nullptr)
818
819		}//extern "C"
	818	NST_PLUGIN_ENTRY_POINTS(&usage, &create, &destroy, nullptr)
	819
	820	} //extern "C"
820	821	//------------------------------------------------------------------------------

+15

-15

analyzers/src/watch/nc_windows/header_window.cpp less more

29	29	//------------------------------------------------------------------------------
30	30	namespace HEADER
31	31	{
32		const int MEMO_LINE = 1;
33		const int HOST_LINE = 2;
34		const int DATE_LINE = 3;
	32	const int MEMO_LINE = 1;
	33	const int HOST_LINE = 2;
	34	const int DATE_LINE = 3;
35	35	const int ELAPSED_LINE = 4;
36		const int HOST_SIZE = 128;
	36	const int HOST_SIZE = 128;
37	37	}
38	38
39	39	void HeaderWindow::destroy()
40	40	{
41		if (_window == nullptr)
	41	if(_window == nullptr)
42	42	{
43	43	return;
44	44	}

49	49	}
50	50
51	51	HeaderWindow::HeaderWindow(MainWindow& w)
52		: _start_time {time(NULL)}
	52	: _start_time{time(NULL)}
53	53	{
54		if (w._window == nullptr)
	54	if(w._window == nullptr)
55	55	{
56	56	throw std::runtime_error("Initialization of Header window failed.");
57	57	}

64	64
65	65	void HeaderWindow::update()
66	66	{
67		if (_window == nullptr)
	67	if(_window == nullptr)
68	68	{
69	69	return;
70	70	}
71	71	time_t actual_time = time(nullptr);
72		tm* t = localtime(&actual_time);
73		time_t shift_time = actual_time - _start_time;
	72	tm* t = localtime(&actual_time);
	73	time_t shift_time = actual_time - _start_time;
74	74	/* tm starts with 0 month and 1900 year*/
75	75	mvwprintw(_window, HEADER::DATE_LINE, FIRST_CHAR_POS, "Date: \t %d.%d.%d \t Time: %d:%d:%d ", t->tm_mday, t->tm_mon + 1, t->tm_year + 1900, t->tm_hour, t->tm_min, t->tm_sec);
76	76	mvwprintw(_window, HEADER::ELAPSED_LINE, FIRST_CHAR_POS, "Elapsed time: \t %d days; %d:%d:%d times",
77	77	shift_time / SECINDAY, shift_time % SECINDAY / SECINHOUR, shift_time % SECINHOUR / SECINMIN, shift_time % SECINMIN);
78		wrefresh (_window);
	78	wrefresh(_window);
79	79	}
80	80
81	81	void HeaderWindow::resize(MainWindow& m)
82	82	{
83		if (_window != nullptr)
	83	if(_window != nullptr)
84	84	{
85	85	destroy();
86	86	}
87		if (m._window != nullptr)
	87	if(m._window != nullptr)
88	88	{
89	89	_window = subwin(m._window, std::min(static_cast<int>(m._window->_maxy), GUI_HEADER_HEIGHT), std::min(static_cast<int>(m._window->_maxx), GUI_LENGTH), 0, 0);
90	90	}
91		if (_window != nullptr)
	91	if(_window != nullptr)
92	92	{
93	93	werase(_window);
94		wborder(_window, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE, ACS_ULCORNER, ACS_URCORNER , ACS_LLCORNER, ACS_LRCORNER);
	94	wborder(_window, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE, ACS_ULCORNER, ACS_URCORNER, ACS_LLCORNER, ACS_LRCORNER);
95	95	char HOST_NAME[HEADER::HOST_SIZE];
96	96	gethostname(HOST_NAME, HEADER::HOST_SIZE);
97	97	mvwprintw(_window, HEADER::MEMO_LINE, FIRST_CHAR_POS, "%s", "Nfstrace watch plugin. To scroll press up or down keys. Ctrl + c to exit.");

-3

analyzers/src/watch/nc_windows/header_window.h less more

28	28	class HeaderWindow
29	29	{
30	30	WINDOW* _window;
31		time_t _start_time;
32		void destroy();
	31	time_t _start_time;
	32	void destroy();
33	33
34	34	public:
35	35	HeaderWindow() = delete;

45	45	void resize(MainWindow&);
46	46	};
47	47	//------------------------------------------------------------------------------
48		#endif//HEADER_WINDOWS_H
	48	#endif //HEADER_WINDOWS_H
49	49	//------------------------------------------------------------------------------

+14

-16

analyzers/src/watch/nc_windows/main_window.cpp less more

26	26	//------------------------------------------------------------------------------
27	27	void MainWindow::init()
28	28	{
29		if (_window != nullptr)
	29	if(_window != nullptr)
30	30	{
31	31	destroy();
32	32	}
33	33	_window = initscr();
34		if (_window == nullptr)
	34	if(_window == nullptr)
35	35	{
36	36	throw std::runtime_error("Initialization of Main window failed.");
37	37	}
38	38	noecho();
39	39	cbreak();
40		intrflush(stdscr, false); // flush main window
41		curs_set(0); // disable blinking cursore
42
43		keypad(_window, true); // init keyboard
44		timeout(200); // set keyboard timeout
45
46		start_color(); // set background color
47		if (_window != nullptr)
	40	intrflush(stdscr, false); // flush main window
	41	curs_set(0); // disable blinking cursore
	42	keypad(_window, true); // init keyboard
	43	timeout(200); // set keyboard timeout
	44	start_color(); // set background color
	45	if(_window != nullptr)
48	46	{
49	47	werase(_window);
50	48	}

62	60
63	61	void MainWindow::cleanStdin(int key)
64	62	{
65		while ((key != EOF) && (key != '\n') && (key != ' '))
	63	while((key != EOF) && (key != '\n') && (key != ' '))
66	64	{
67	65	key = getch();
68	66	}
69	67	}
70	68
71	69	MainWindow::MainWindow()
72		: _window {nullptr}
	70	: _window{nullptr}
73	71	{
74	72	init();
75	73	}

83	81	{
84	82	int key = wgetch(_window);
85	83
86		if (key != KEY_UP && key != KEY_DOWN && key != KEY_LEFT && key != KEY_RIGHT)
	84	if(key != KEY_UP && key != KEY_DOWN && key != KEY_LEFT && key != KEY_RIGHT)
87	85	{
88	86	key = 0;
89	87	}

93	91
94	92	void MainWindow::resize()
95	93	{
96		if (_window != nullptr)
	94	if(_window != nullptr)
97	95	{
98	96	destroy();
99	97	}

102	100
103	101	void MainWindow::update() const
104	102	{
105		if (_window != nullptr)
	103	if(_window != nullptr)
106	104	{
107	105	refresh();
108	106	}
109	107	}
110		//------------------------------------------------------------------------------⏎
	108	//------------------------------------------------------------------------------

-2

analyzers/src/watch/nc_windows/main_window.h less more

31	31
32	32	void init();
33	33	void destroy();
	34
34	35	static void cleanStdin(int);
35	36
36	37	public:
37
38	38	MainWindow();
39	39	~MainWindow();
40	40

51	51	void update() const;
52	52	};
53	53	//------------------------------------------------------------------------------
54		#endif//MAIN_WINDOW_H
	54	#endif //MAIN_WINDOW_H
55	55	//------------------------------------------------------------------------------

-3

analyzers/src/watch/nc_windows/nc_window_const.h less more

23	23	//------------------------------------------------------------------------------
24	24	namespace
25	25	{
26
27	26	const unsigned int SECINMIN = 60;
28	27	const unsigned int SECINHOUR = 60 * 60;
29	28	const unsigned int SECINDAY = 60 * 60 * 24;

40	39
41	40	const int FIRST_CHAR_POS = 1;
42	41	const int EMPTY_LINE = 1;
43
44	42	}
45	43	//------------------------------------------------------------------------------
46		#endif//NC_WINDOW_CONST_H
	44	#endif //NC_WINDOW_CONST_H
47	45	//------------------------------------------------------------------------------

+27

-29

analyzers/src/watch/nc_windows/statistics_window.cpp less more

28	28	//------------------------------------------------------------------------------
29	29	namespace STATISTICS
30	30	{
31		const int PROTOCOLS_LINE = 1;
	31	const int PROTOCOLS_LINE = 1;
32	32	const int FIRST_OPERATION_LINE = 3;
33		const int DEFAULT_LINES = 10;
34		const int DEFAULT_GROUP = 1;
	33	const int DEFAULT_LINES = 10;
	34	const int DEFAULT_GROUP = 1;
35	35	}
36	36
37	37	void StatisticsWindow::destroy()
38	38	{
39		if (_window == nullptr)
	39	if(_window == nullptr)
40	40	{
41	41	return;
42	42	}

48	48
49	49	bool StatisticsWindow::canWrite(unsigned int i)
50	50	{
51		return (i >= _scrollOffset.at(_activeProtocol) + STATISTICS::FIRST_OPERATION_LINE && i - _scrollOffset.at(_activeProtocol) + BORDER_SIZE < static_cast<unsigned int>(_window->_maxy));
	51	return (i >= _scrollOffset.at(_activeProtocol) + STATISTICS::FIRST_OPERATION_LINE && i - _scrollOffset.at(_activeProtocol) + BORDER_SIZE < static_cast<unsigned int>(_window->_maxy));
52	52	}
53	53
54	54	StatisticsWindow::StatisticsWindow(MainWindow& w, StatisticsContainers& c)
55		: _window {nullptr}
56		, _activeProtocol {nullptr}
	55	: _window{nullptr}
	56	, _activeProtocol{nullptr}
57	57	{
58		if (w._window == nullptr)
	58	if(w._window == nullptr)
59	59	{
60	60	throw std::runtime_error("Initialization of Header window failed.");
61	61	}
62		for (auto i : c)
	62	for(auto i : c)
63	63	{
64	64	_allProtocols.push_back((i.first)->getProtocolName());
65	65	_scrollOffset.insert(std::make_pair<AbstractProtocol, std::size_t>(reinterpret_cast<AbstractProtocol>(i.first), 0));
66	66	};
67	67	_activeProtocol = (c.begin())->first;
68		_statistic = c.at(_activeProtocol);
	68	_statistic = c.at(_activeProtocol);
69	69	resize(w);
70	70	}
71	71

75	75
76	76	void StatisticsWindow::scrollContent(int i)
77	77	{
78		if (i > 0 && _scrollOffset.at(_activeProtocol) <= MAXSHIFT - SHIFTCU)
	78	if(i > 0 && _scrollOffset.at(_activeProtocol) <= MAXSHIFT - SHIFTCU)
79	79	{
80	80	_scrollOffset.at(_activeProtocol) += SHIFTCU;
81	81	updateProtocol(_activeProtocol);
82	82	}
83		else if (i < 0 && _scrollOffset.at(_activeProtocol) >= SHIFTCU)
	83	else if(i < 0 && _scrollOffset.at(_activeProtocol) >= SHIFTCU)
84	84	{
85	85	_scrollOffset.at(_activeProtocol) -= SHIFTCU;
86	86	updateProtocol(_activeProtocol);

91	91	{
92	92	if(p != nullptr)
93	93	_activeProtocol = p;
94		if (_window == nullptr)
	94	if(_window == nullptr)
95	95	{
96	96	return;
97	97	}
98	98	werase(_window);
99		wborder(_window, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE, ACS_ULCORNER, ACS_URCORNER , ACS_LLCORNER, ACS_LRCORNER);
	99	wborder(_window, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE, ACS_ULCORNER, ACS_URCORNER, ACS_LLCORNER, ACS_LRCORNER);
100	100
101	101	std::string tmp(" ");
102		for_each (_allProtocols.begin(), _allProtocols.end(), [&](std::string& s)
103		{
104		if (!s.compare(_activeProtocol->getProtocolName()))
	102	for_each(_allProtocols.begin(), _allProtocols.end(), [&](std::string& s) {
	103	if(!s.compare(_activeProtocol->getProtocolName()))
105	104	{
106	105	tmp += std::string(" < ") + s + std::string(" > ");
107	106	}

111	110	}
112	111
113	112	});
114		mvwprintw(_window, STATISTICS::PROTOCOLS_LINE , FIRST_CHAR_POS, "%s", tmp.c_str());
	113	mvwprintw(_window, STATISTICS::PROTOCOLS_LINE, FIRST_CHAR_POS, "%s", tmp.c_str());
115	114
116	115	unsigned int line = STATISTICS::FIRST_OPERATION_LINE;
117	116	for(unsigned int i = STATISTICS::DEFAULT_GROUP; i <= _activeProtocol->getGroups(); i++)
118	117	{
119		if ( canWrite(line))
	118	if(canWrite(line))
120	119	{
121	120	mvwprintw(_window, line - (_scrollOffset.at(p)), FIRST_CHAR_POS, "%s", "Total:");
122	121	}
123	122	line++;
124		for (unsigned int j = _activeProtocol->getGroupBegin(i); j < _activeProtocol->getGroupBegin(i + 1); j++)
	123	for(unsigned int j = _activeProtocol->getGroupBegin(i); j < _activeProtocol->getGroupBegin(i + 1); j++)
125	124	{
126		if ( canWrite(line))
	125	if(canWrite(line))
127	126	{
128	127	mvwprintw(_window, line - (_scrollOffset.at(p)), FIRST_CHAR_POS, "%s", p->printProcedure(j));
129	128	}

131	130	}
132	131	line++;
133	132	}
134
135	133	}
136	134
137	135	void StatisticsWindow::update(const ProtocolStatistic& d)
138	136	{
139	137	_statistic = d;
140		if (_statistic.empty() \|\| _window == nullptr)
	138	if(_statistic.empty() \|\| _window == nullptr)
141	139	{
142	140	return;
143	141	}

151	149	{
152	150	m += _statistic[tmp];
153	151	}
154		if ( canWrite(line))
	152	if(canWrite(line))
155	153	{
156	154	mvwprintw(_window, line - (_scrollOffset.at(_activeProtocol)), FIRST_CHAR_POS + 25, "%d", m);
157	155	}
158	156	line++;
159		for (unsigned int j = _activeProtocol->getGroupBegin(i); j < _activeProtocol->getGroupBegin(i + 1); j++)
	157	for(unsigned int j = _activeProtocol->getGroupBegin(i); j < _activeProtocol->getGroupBegin(i + 1); j++)
160	158	{
161		if ( canWrite(line))
	159	if(canWrite(line))
162	160	{
163	161	mvwprintw(_window, line - _scrollOffset.at(_activeProtocol), COUNTERS_POS, "%lu ", _statistic[j]);
164	162	mvwprintw(_window, line - _scrollOffset.at(_activeProtocol), PERSENT_POS, "%-3.2f%% ",

173	171
174	172	void StatisticsWindow::resize(MainWindow& m)
175	173	{
176		if (_window != nullptr)
	174	if(_window != nullptr)
177	175	{
178	176	destroy();
179	177	}
180	178	int tmp_size = STATISTICS::DEFAULT_LINES;
181		if (_activeProtocol != nullptr)
	179	if(_activeProtocol != nullptr)
182	180	{
183	181	tmp_size = _activeProtocol->getAmount() + 2 * BORDER_SIZE + 2 * EMPTY_LINE + STATISTICS::PROTOCOLS_LINE + _activeProtocol->getGroups() * EMPTY_LINE * _activeProtocol->getGroups();
184	182	}
185		if (m._window != nullptr && m._window->_maxy > GUI_HEADER_HEIGHT)
	183	if(m._window != nullptr && m._window->_maxy > GUI_HEADER_HEIGHT)
186	184	{
187	185	_window = subwin(m._window, std::min(static_cast<int>(m._window->_maxy - GUI_HEADER_HEIGHT), tmp_size),
188	186	std::min(static_cast<int>(m._window->_maxx), GUI_LENGTH), GUI_HEADER_HEIGHT - BORDER_SIZE, 0);

+13

-13

analyzers/src/watch/nc_windows/statistics_window.h less more

21	21	#ifndef STATISTICS_WINDOW_H
22	22	#define STATISTICS_WINDOW_H
23	23	//------------------------------------------------------------------------------
	24	#include <vector>
24	25	#include <unordered_map>
25		#include <vector>
26	26
27	27	#include "../protocols/abstract_protocol.h"
28	28	#include "main_window.h"
29	29	//------------------------------------------------------------------------------
30	30	class StatisticsWindow
31	31	{
32		using ProtocolStatistic = std::vector<std::size_t>;
	32	using ProtocolStatistic = std::vector<std::size_t>;
33	33	using StatisticsContainers = std::unordered_map<AbstractProtocol*, ProtocolStatistic>;
34	34
35		private:
36		WINDOW* _window;
37		AbstractProtocol* _activeProtocol;
38		std::vector<std::string> _allProtocols;
39		std::unordered_map<AbstractProtocol*, unsigned int> _scrollOffset;
40		ProtocolStatistic _statistic;
41		void destroy();
42		bool canWrite(unsigned int);
43
44	35	public:
45		StatisticsWindow() = delete;
46	36	StatisticsWindow(MainWindow&, StatisticsContainers&);
47	37	~StatisticsWindow();
48	38

65	55	/*! Only set active protocol, do not update new protocol's commands.
66	56	*/
67	57	void setProtocol(AbstractProtocol*);
	58
	59	private:
	60	void destroy();
	61	bool canWrite(unsigned int);
	62
	63	WINDOW* _window;
	64	AbstractProtocol* _activeProtocol;
	65	std::vector<std::string> _allProtocols;
	66	std::unordered_map<AbstractProtocol*, unsigned int> _scrollOffset;
	67	ProtocolStatistic _statistic;
68	68	};
69	69	//------------------------------------------------------------------------------
70		#endif//STATISTICS_WINDOWS_H
	70	#endif //STATISTICS_WINDOWS_H
71	71	//------------------------------------------------------------------------------

-4

analyzers/src/watch/protocols/abstract_protocol.cpp less more

23	23	//------------------------------------------------------------------------------
24	24	namespace
25	25	{
26		const int EMPTY_GROUP = 1;
	26	const int EMPTY_GROUP = 1;
27	27	}
28	28
29	29	AbstractProtocol::AbstractProtocol(const char* n, std::size_t i)
30		: name {n}
31		, amount {i}
	30	: name{n}
	31	, amount{i}
32	32	{
33	33	}
34	34

58	58
59	59	std::size_t AbstractProtocol::getGroupBegin(std::size_t i)
60	60	{
61		if( i == EMPTY_GROUP)
	61	if(i == EMPTY_GROUP)
62	62	return 0;
63	63	else
64	64	return amount;

-1

analyzers/src/watch/protocols/abstract_protocol.h less more

61	61	std::size_t amount;
62	62	};
63	63	//------------------------------------------------------------------------------
64		#endif//ABSTRACT_PROTOCOL_H
	64	#endif //ABSTRACT_PROTOCOL_H
65	65	//------------------------------------------------------------------------------

-2

analyzers/src/watch/protocols/cifsv1_protocol.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <api/plugin_api.h> // include plugin development definitions
	22
22	23	#include "cifsv1_protocol.h"
23	24	//------------------------------------------------------------------------------
24	25	//------------------------------------------------------------------------------
25	26	CIFSv1Protocol::CIFSv1Protocol()
26		: AbstractProtocol {"CIFS v1", static_cast<std::size_t>(SMBv1::SMBv1Commands::CMD_COUNT)}
	27	: AbstractProtocol{"CIFS v1", static_cast<std::size_t>(SMBv1::SMBv1Commands::CMD_COUNT)}
27	28	{
28	29	}
29	30

33	34
34	35	const char* CIFSv1Protocol::printProcedure(std::size_t i)
35	36	{
36		if ( i >= static_cast<std::size_t>(SMBv1::SMBv1Commands::CMD_COUNT)) { return nullptr; }
	37	if(i >= static_cast<std::size_t>(SMBv1::SMBv1Commands::CMD_COUNT))
	38	{
	39	return nullptr;
	40	}
37	41	return print_cifs1_procedures(static_cast<SMBv1::SMBv1Commands>(i));
38	42	}
39	43	//------------------------------------------------------------------------------

-1

analyzers/src/watch/protocols/cifsv1_protocol.h less more

31	31	virtual const char* printProcedure(std::size_t);
32	32	};
33	33	//------------------------------------------------------------------------------
34		#endif//CIFSV1_PROTOCOL_H
	34	#endif //CIFSV1_PROTOCOL_H
35	35	//------------------------------------------------------------------------------

-2

analyzers/src/watch/protocols/cifsv2_protocol.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <api/plugin_api.h> // include plugin development definitions
	22
22	23	#include "cifsv2_protocol.h"
23	24	//------------------------------------------------------------------------------
24	25	CIFSv2Protocol::CIFSv2Protocol()
25		: AbstractProtocol {"CIFS v2", static_cast<std::size_t>(SMBv2::SMBv2Commands::CMD_COUNT)}
	26	: AbstractProtocol{"CIFS v2", static_cast<std::size_t>(SMBv2::SMBv2Commands::CMD_COUNT)}
26	27	{
27	28	}
28	29

32	33
33	34	const char* CIFSv2Protocol::printProcedure(std::size_t i)
34	35	{
35		if ( i >= static_cast<std::size_t>(SMBv2::SMBv2Commands::CMD_COUNT)) { return nullptr; }
	36	if(i >= static_cast<std::size_t>(SMBv2::SMBv2Commands::CMD_COUNT))
	37	{
	38	return nullptr;
	39	}
36	40	return print_cifs2_procedures(static_cast<SMBv2::SMBv2Commands>(i));
37	41	}
38	42	//------------------------------------------------------------------------------

-1

analyzers/src/watch/protocols/cifsv2_protocol.h less more

31	31	virtual const char* printProcedure(std::size_t);
32	32	};
33	33	//------------------------------------------------------------------------------
34		#endif//CIFSV2_PROTOCOL_H
	34	#endif //CIFSV2_PROTOCOL_H
35	35	//------------------------------------------------------------------------------

-3

analyzers/src/watch/protocols/nfsv3_protocol.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <api/plugin_api.h> // include plugin development definitions
	22
22	23	#include "nfsv3_protocol.h"
23	24	//------------------------------------------------------------------------------
24	25	NFSv3Protocol::NFSv3Protocol()
25		: AbstractProtocol {"NFS v3", ProcEnumNFS3::count}
	26	: AbstractProtocol{"NFS v3", ProcEnumNFS3::count}
26	27	{
27	28	}
28	29

32	33
33	34	const char* NFSv3Protocol::printProcedure(std::size_t i)
34	35	{
35		if ( i > ProcEnumNFS3::count) { return nullptr; }
36		return print_nfs3_procedures(static_cast<ProcEnumNFS3::NFSProcedure>(i));
	36	if(i > ProcEnumNFS3::count)
	37	{
	38	return nullptr;
	39	}
	40	return print_nfs3_procedures(static_cast<ProcEnumNFS3::NFSProcedure>(i));
37	41	}
38	42	//------------------------------------------------------------------------------

-1

analyzers/src/watch/protocols/nfsv3_protocol.h less more

31	31	virtual const char* printProcedure(std::size_t);
32	32	};
33	33	//------------------------------------------------------------------------------
34		#endif//NFSV3_PROTOCOL_H
	34	#endif //NFSV3_PROTOCOL_H
35	35	//------------------------------------------------------------------------------

-5

analyzers/src/watch/protocols/nfsv41_protocol.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <api/plugin_api.h> // include plugin development definitions
	22
22	23	#include "nfsv41_protocol.h"
23	24	//------------------------------------------------------------------------------
24	25	namespace
25	26	{
26	27	const int NFSV41_NUMBEROFGROUPS = 2;
27		const int PROCEDURES_GROUP = 1;
28		const int OPERATIONS_GROUP = 2;
	28	const int PROCEDURES_GROUP = 1;
	29	const int OPERATIONS_GROUP = 2;
29	30	}
30	31
31	32	NFSv41Protocol::NFSv41Protocol()
32		: AbstractProtocol {"NFS v41", ProcEnumNFS41::count}
	33	: AbstractProtocol{"NFS v41", ProcEnumNFS41::count}
33	34	{
34	35	}
35	36

39	40
40	41	const char* NFSv41Protocol::printProcedure(std::size_t i)
41	42	{
42		if ( i > ProcEnumNFS41::count) { return nullptr; }
43		return print_nfs41_procedures(static_cast<ProcEnumNFS41::NFSProcedure>(i));
	43	if(i > ProcEnumNFS41::count)
	44	{
	45	return nullptr;
	46	}
	47	return print_nfs41_procedures(static_cast<ProcEnumNFS41::NFSProcedure>(i));
44	48	}
45	49
46	50	std::size_t NFSv41Protocol::getGroups()

-1

analyzers/src/watch/protocols/nfsv41_protocol.h less more

33	33	virtual std::size_t getGroupBegin(std::size_t);
34	34	};
35	35	//------------------------------------------------------------------------------
36		#endif//NFSV41_PROTOCOL_H
	36	#endif //NFSV41_PROTOCOL_H
37	37	//------------------------------------------------------------------------------

-5

analyzers/src/watch/protocols/nfsv4_protocol.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <api/plugin_api.h> // include plugin development definitions
	22
22	23	#include "nfsv4_protocol.h"
23	24	//------------------------------------------------------------------------------
24	25	namespace
25	26	{
26	27	const int NFSV4_NUMBER_OF_GROUPS = 2;
27		const int PROCEDURES_GROUP = 1;
28		const int OPERATIONS_GROUP = 2;
	28	const int PROCEDURES_GROUP = 1;
	29	const int OPERATIONS_GROUP = 2;
29	30	}
30	31
31	32	NFSv4Protocol::NFSv4Protocol()
32		: AbstractProtocol {"NFS v4", ProcEnumNFS4::count}
	33	: AbstractProtocol{"NFS v4", ProcEnumNFS4::count}
33	34	{
34	35	}
35	36

39	40
40	41	const char* NFSv4Protocol::printProcedure(std::size_t i)
41	42	{
42		if ( i > ProcEnumNFS4::count) { return nullptr; }
43		return print_nfs4_procedures(static_cast<ProcEnumNFS4::NFSProcedure>(i));
	43	if(i > ProcEnumNFS4::count)
	44	{
	45	return nullptr;
	46	}
	47	return print_nfs4_procedures(static_cast<ProcEnumNFS4::NFSProcedure>(i));
44	48	}
45	49
46	50	std::size_t NFSv4Protocol::getGroups()

-1

analyzers/src/watch/protocols/nfsv4_protocol.h less more

33	33	virtual std::size_t getGroupBegin(std::size_t);
34	34	};
35	35	//------------------------------------------------------------------------------
36		#endif//PROTOCOLS_H
	36	#endif //PROTOCOLS_H
37	37	//------------------------------------------------------------------------------

+37

-39

analyzers/src/watch/user_gui.cpp less more

45	45	// prepare for select
46	46	fd_set rfds;
47	47
48		MainWindow mainWindow;
	48	MainWindow mainWindow;
49	49	HeaderWindow headerWindow(mainWindow);
50	50	StatisticsWindow statisticsWindow(mainWindow, _statisticsContainers);
51	51

62	62
63	63	statisticsWindow.updateProtocol(_activeProtocol);
64	64
65		while (_running.test_and_set())
66		{
67		if (_shouldResize)
	65	while(_running.test_and_set())
	66	{
	67	if(_shouldResize)
68	68	{
69	69	mainWindow.resize();
70	70	headerWindow.resize(mainWindow);

73	73
74	74	_shouldResize = false;
75	75	}
76		if (_running.test_and_set())
77		{
78		std::unique_lock<std::mutex>lck(_statisticsDeltaMutex);
	76	if(_running.test_and_set())
	77	{
	78	std::unique_lock<std::mutex> lck(_statisticsDeltaMutex);
79	79	tmp = _statisticsContainers.at(_activeProtocol);
80	80	}
81	81	headerWindow.update();
82	82	statisticsWindow.update(tmp);
83	83	mainWindow.update();
84	84
85		if( select(STDIN_FILENO + 1, &rfds, nullptr, nullptr, &tv) == -1)
	85	if(select(STDIN_FILENO + 1, &rfds, nullptr, nullptr, &tv) == -1)
86	86	{
87	87	break;
88	88	}
89	89	else
90	90	{
91	91	key = mainWindow.inputKeys();
92		if (key == KEY_LEFT \|\| key == KEY_RIGHT)
	92	if(key == KEY_LEFT \|\| key == KEY_RIGHT)
93	93	{
94		auto it = find_if (_allProtocols.begin(), _allProtocols.end(), [&](std::string s)
95		{
	94	auto it = find_if(_allProtocols.begin(), _allProtocols.end(), [&](std::string s) {
96	95	return !(s.compare(_activeProtocol->getProtocolName()));
97	96	});
98		if (it != _allProtocols.end())
	97	if(it != _allProtocols.end())
99	98	{
100		if (key == KEY_LEFT)
	99	if(key == KEY_LEFT)
101	100	{
102		if (it + 1 == _allProtocols.end())
	101	if(it + 1 == _allProtocols.end())
103	102	it = _allProtocols.begin();
104	103	else
105	104	++it;
106	105	}
107		else if (key == KEY_RIGHT)
	106	else if(key == KEY_RIGHT)
108	107	{
109		if (it == _allProtocols.begin())
	108	if(it == _allProtocols.begin())
110	109	it = _allProtocols.end() - 1;
111	110	else
112	111	--it;
113	112	}
114		auto a = find_if ( _statisticsContainers.begin(), _statisticsContainers.end(),[&](std::pair<AbstractProtocol*, std::vector<std::size_t> > p)
115		{
	113	auto a = find_if(_statisticsContainers.begin(), _statisticsContainers.end(), [&](std::pair<AbstractProtocol*, std::vector<std::size_t>> p) {
116	114	return !(p.first->getProtocolName().compare(*it));
117	115	});
118		if (a != _statisticsContainers.end())
	116	if(a != _statisticsContainers.end())
119	117	{
120	118	_activeProtocol = a->first;
121	119	statisticsWindow.setProtocol(_activeProtocol);
122	120	statisticsWindow.resize(mainWindow);
123	121	{
124		std::unique_lock<std::mutex>lck(_statisticsDeltaMutex);
	122	std::unique_lock<std::mutex> lck(_statisticsDeltaMutex);
125	123	tmp = a->second;
126	124	}
127	125	statisticsWindow.update(tmp);
128	126	}
129	127	}
130	128	}
131		else if (key == KEY_UP)
	129	else if(key == KEY_UP)
132	130	{
133	131	statisticsWindow.scrollContent(SCROLL_UP);
134	132	statisticsWindow.update(tmp);
135	133	}
136		else if (key == KEY_DOWN)
	134	else if(key == KEY_DOWN)
137	135	{
138	136	statisticsWindow.scrollContent(SCROLL_DOWN);
139	137	statisticsWindow.update(tmp);

142	140	tv = getTimeval();
143	141	}
144	142	}
145		catch (std::runtime_error& e)
	143	catch(std::runtime_error& e)
146	144	{
147	145	std::cerr << "Watch plugin error: " << e.what();
148	146	}

151	149	timeval UserGUI::getTimeval() const
152	150	{
153	151	struct timeval tv;
154		tv.tv_sec = _refresh_delta / MSEC;
	152	tv.tv_sec = _refresh_delta / MSEC;
155	153	tv.tv_usec = _refresh_delta % MSEC;
156	154	return tv;
157	155	}
158	156
159		UserGUI::UserGUI(const char* opts, std::vector<AbstractProtocol* >& data)
160		: _refresh_delta {900000}
161		, _shouldResize {false}
162		, _running {ATOMIC_FLAG_INIT}
163		, _activeProtocol(nullptr)
	157	UserGUI::UserGUI(const char* opts, std::vector<AbstractProtocol*>& data)
	158	: _refresh_delta{900000}
	159	, _shouldResize{false}
	160	, _running{ATOMIC_FLAG_INIT}
	161	, _activeProtocol(nullptr)
164	162	{
165	163	try
166	164	{
167		if (opts != nullptr && *opts != '\0' )
	165	if(opts != nullptr && *opts != '\0')
168	166	{
169	167	_refresh_delta = std::stoul(opts);
170	168	}
171		for (auto it = data.begin(); it != data.end(); ++it)
	169	for(auto it = data.begin(); it != data.end(); ++it)
172	170	{
173	171	_allProtocols.push_back((*it)->getProtocolName());
174		_statisticsContainers.insert(std::make_pair<AbstractProtocol, std::vector<std::size_t> >((AbstractProtocol&&)(it), std::vector<std::size_t>((it)->getAmount(), 0)));
175		}
176		if (_activeProtocol == nullptr && ! data.empty())
	172	_statisticsContainers.insert(std::make_pair<AbstractProtocol, std::vector<std::size_t>>((AbstractProtocol &&)(it), std::vector<std::size_t>((it)->getAmount(), 0)));
	173	}
	174	if(_activeProtocol == nullptr && !data.empty())
177	175	{
178	176	_activeProtocol = data.back();
179	177	}
180	178	}
181		catch (std::exception& e)
182		{
183		throw std::runtime_error {std::string{"Error in plugin options processing. OPTS: "} + opts + std::string(" Error: ") + e.what()};
	179	catch(std::exception& e)
	180	{
	181	throw std::runtime_error{std::string{"Error in plugin options processing. OPTS: "} + opts + std::string(" Error: ") + e.what()};
184	182	}
185	183	_running.test_and_set();
186	184	_guiThread = std::thread(&UserGUI::run, this);

196	194	{
197	195	std::vector<std::size_t>::iterator it;
198	196	std::vector<std::size_t>::iterator st;
199		std::unique_lock<std::mutex>lck(_statisticsDeltaMutex);
200		for (it = (_statisticsContainers.at(p)).begin(), st = d.begin(); it != (_statisticsContainers.at(p)).end() && st != d.end(); ++it, ++st)
	197	std::unique_lock<std::mutex> lck(_statisticsDeltaMutex);
	198	for(it = (_statisticsContainers.at(p)).begin(), st = d.begin(); it != (_statisticsContainers.at(p)).end() && st != d.end(); ++it, ++st)
201	199	{
202	200	(it) += (st);
203	201	}

+17

-19

analyzers/src/watch/user_gui.h less more

28	28	#include <vector>
29	29
30	30	#include <ncurses.h>
	31
31	32	#include "protocols/abstract_protocol.h"
32	33	//------------------------------------------------------------------------------
33	34	class UserGUI
34	35	{
35	36	public:
36		using ProtocolStatistic = std::vector<std::size_t>;
	37	using ProtocolStatistic = std::vector<std::size_t>;
37	38	using StatisticsContainers = std::unordered_map<AbstractProtocol*, ProtocolStatistic>;
38	39
39		private:
40		unsigned long _refresh_delta; // in microseconds
41
42		std::atomic<bool> _shouldResize;
43		std::mutex _statisticsDeltaMutex;
44		std::atomic_flag _running;
45
46		StatisticsContainers _statisticsContainers;
47
48		AbstractProtocol* _activeProtocol;
49		std::thread _guiThread;
50		std::vector<std::string> _allProtocols;
51		void run();
52		timeval getTimeval() const;
53		public:
54
55	40	UserGUI() = delete;
56		UserGUI(const char, std::vector<AbstractProtocol >&);
	41	UserGUI(const char, std::vector<AbstractProtocol>&);
57	42	~UserGUI();
58	43
59	44	/*! Update Protocol's data.

63	48	/*! Enable screen full update. Use for resize main window.
64	49	*/
65	50	void enableUpdate();
	51
	52	private:
	53	void run();
	54	timeval getTimeval() const;
	55
	56	unsigned long _refresh_delta; // in microseconds
	57	std::atomic<bool> _shouldResize;
	58	std::mutex _statisticsDeltaMutex;
	59	std::atomic_flag _running;
	60	StatisticsContainers _statisticsContainers;
	61	AbstractProtocol* _activeProtocol;
	62	std::thread _guiThread;
	63	std::vector<std::string> _allProtocols;
66	64	};
67	65	//------------------------------------------------------------------------------
68		#endif//USERGUI_H
	66	#endif //USERGUI_H
69	67	//------------------------------------------------------------------------------

+52

-51

analyzers/src/watch/watch_analyzer.cpp less more

23	23	#include <string>
24	24	#include <unordered_map>
25	25
26		#include <unistd.h>
27	26	#include <signal.h>
28	27	#include <sys/time.h>
29	28	#include <sys/types.h>
	29	#include <unistd.h>
30	30
31	31	#include "watch_analyzer.h"
32	32	//------------------------------------------------------------------------------
33	33	WatchAnalyzer::WatchAnalyzer(const char* opts)
34		: _cifsv2 {}
35		, _cifsv1 {}
36		, _nfsv41 {}
37		, _nfsv4 {}
38		, _nfsv3 {}
39		, protocols {&_cifsv2, &_cifsv1, &_nfsv41, &_nfsv4, &_nfsv3}
40		, gui {opts, protocols}
	34	: _cifsv2{}
	35	, _cifsv1{}
	36	, _nfsv41{}
	37	, _nfsv4{}
	38	, _nfsv3{}
	39	, protocols{&_cifsv2, &_cifsv1, &_nfsv41, &_nfsv4, &_nfsv3}
	40	, gui{opts, protocols}
41	41	{
42	42	}
43	43

45	45	{
46	46	}
47	47
	48	// clang-format off
48	49	void WatchAnalyzer::null(const RPCProcedure* proc,
49	50	const struct NFS3::NULL3args*,
50	51	const struct NFS3::NULL3res*) { nfs_account(proc); }

877	878	{
878	879	cifs_account(_cifsv2, static_cast<int>(SMBv2::SMBv2Commands::OPLOCK_BREAK));
879	880	}
	881	// clang-format on
880	882
881	883	void WatchAnalyzer::flush_statistics()
882	884	{

884	886
885	887	void WatchAnalyzer::on_unix_signal(int signo)
886	888	{
887		if (signo == SIGWINCH)
	889	if(signo == SIGWINCH)
888	890	{
889	891	gui.enableUpdate();
890	892	}
891	893	}
892	894
893		void WatchAnalyzer::cifs_account(AbstractProtocol &protocol, int cmd_code)
894		{
895		std::vector<std::size_t> cifs_proc_count (static_cast<std::size_t>(protocol.getAmount()), 0);
	895	void WatchAnalyzer::cifs_account(AbstractProtocol& protocol, int cmd_code)
	896	{
	897	std::vector<std::size_t> cifs_proc_count(static_cast<std::size_t>(protocol.getAmount()), 0);
896	898	++cifs_proc_count[cmd_code];
897	899	gui.update(&protocol, cifs_proc_count);
898	900	}

902	904	const u_int nfs_proc = proc->call.ru.RM_cmb.cb_proc;
903	905	const u_int nfs_vers = proc->call.ru.RM_cmb.cb_vers;
904	906
905		if (nfs_vers == NFS_V4)
	907	if(nfs_vers == NFS_V4)
906	908	{
907		if (nfs_minor_vers == NFS_V40)
	909	if(nfs_minor_vers == NFS_V40)
908	910	{
909		std::vector<std::size_t> nfs4_proc_count (ProcEnumNFS4::count, 0);
	911	std::vector<std::size_t> nfs4_proc_count(ProcEnumNFS4::count, 0);
910	912	++nfs4_proc_count[nfs_proc];
911	913	gui.update(&_nfsv4, nfs4_proc_count);
912	914	}
913	915
914		if (nfs_minor_vers == NFS_V41 \|\| nfs_proc == ProcEnumNFS4::NFS_NULL)
	916	if(nfs_minor_vers == NFS_V41 \|\| nfs_proc == ProcEnumNFS4::NFS_NULL)
915	917	{
916		std::vector<std::size_t> nfs41_proc_count (ProcEnumNFS41::count, 0);
	918	std::vector<std::size_t> nfs41_proc_count(ProcEnumNFS41::count, 0);
917	919	++nfs41_proc_count[nfs_proc];
918	920	gui.update(&_nfsv41, nfs41_proc_count);
919	921	}
920	922	}
921		else if (nfs_vers == NFS_V3)
	923	else if(nfs_vers == NFS_V3)
922	924	{
923		std::vector<std::size_t> nfs3_proc_count (ProcEnumNFS3::count, 0);
	925	std::vector<std::size_t> nfs3_proc_count(ProcEnumNFS3::count, 0);
924	926	++nfs3_proc_count[nfs_proc];
925	927	gui.update(&_nfsv3, nfs3_proc_count);
926	928	}

928	930
929	931	void WatchAnalyzer::account40_op(const RPCProcedure* /proc/, const ProcEnumNFS4::NFSProcedure operation)
930	932	{
931		std::vector<std::size_t> nfs4_proc_count (ProcEnumNFS4::count, 0);
	933	std::vector<std::size_t> nfs4_proc_count(ProcEnumNFS4::count, 0);
932	934	++nfs4_proc_count[operation];
933	935	gui.update(&_nfsv4, nfs4_proc_count);
934	936	}
935	937
936	938	void WatchAnalyzer::account41_op(const RPCProcedure* /proc/, const ProcEnumNFS41::NFSProcedure operation)
937	939	{
938		std::vector<std::size_t> nfs41_proc_count (ProcEnumNFS41::count, 0);
	940	std::vector<std::size_t> nfs41_proc_count(ProcEnumNFS41::count, 0);
939	941	++nfs41_proc_count[operation];
940	942	gui.update(&_nfsv41, nfs41_proc_count);
941	943	}
942	944	//------------------------------------------------------------------------------
943		extern "C"
944		{
945
946		const char* usage()
	945	extern "C" {
	946
	947	const char* usage()
	948	{
	949	return "User can set chrono output timeout in msec.\n"
	950	"You have to run nfstrace with verbosity level set to 0 (nfstrace -v 0 ...)";
	951	}
	952
	953	IAnalyzer* create(const char* opts)
	954	{
	955	try
947	956	{
948		return "User can set chrono output timeout in msec.\n"
949		"You have to run nfstrace with verbosity level set to 0 (nfstrace -v 0 ...)";
	957	return new WatchAnalyzer(opts);
950	958	}
951
952		IAnalyzer* create(const char* opts)
	959	catch(std::exception& e)
953	960	{
954		try
955		{
956		return new WatchAnalyzer(opts);
957		}
958		catch (std::exception& e)
959		{
960		std::cerr << "Can't initalize plugin: " << e.what() << std::endl;
961		return nullptr;
962		}
	961	std::cerr << "Can't initalize plugin: " << e.what() << std::endl;
	962	return nullptr;
963	963	}
964
965		void destroy(IAnalyzer* instance)
966		{
967		delete instance;
968		}
969
970		const AnalyzerRequirements* requirements()
971		{
972		static const AnalyzerRequirements requirements{true};
973		return &requirements;
974		}
975
976		NST_PLUGIN_ENTRY_POINTS (&usage, &create, &destroy, &requirements)
	964	}
	965
	966	void destroy(IAnalyzer* instance)
	967	{
	968	delete instance;
	969	}
	970
	971	const AnalyzerRequirements* requirements()
	972	{
	973	static const AnalyzerRequirements requirements{true};
	974	return &requirements;
	975	}
	976
	977	NST_PLUGIN_ENTRY_POINTS(&usage, &create, &destroy, &requirements)
977	978	}
978	979	//------------------------------------------------------------------------------

+11

-11

analyzers/src/watch/watch_analyzer.h less more

25	25	#include <condition_variable>
26	26
27	27	#include <api/plugin_api.h> // include plugin development definitions
28		#include "protocols/nfsv3_protocol.h"
29		#include "protocols/nfsv4_protocol.h"
30		#include "protocols/nfsv41_protocol.h"
	28
31	29	#include "protocols/cifsv1_protocol.h"
32	30	#include "protocols/cifsv2_protocol.h"
	31	#include "protocols/nfsv3_protocol.h"
	32	#include "protocols/nfsv41_protocol.h"
	33	#include "protocols/nfsv4_protocol.h"
33	34	#include "user_gui.h"
34	35	//------------------------------------------------------------------------------
35	36	class WatchAnalyzer : public IAnalyzer

109	110	const struct NFS3::COMMIT3res*) override final;
110	111	// NFS v4
111	112	virtual void null4(const RPCProcedure*,
112		const struct NFS4::NULL4args*,
113		const struct NFS4::NULL4res*) override final;
	113	const struct NFS4::NULL4args*,
	114	const struct NFS4::NULL4res*) override final;
114	115	virtual void compound4(const RPCProcedure*,
115	116	const struct NFS4::COMPOUND4args*,
116	117	const struct NFS4::COMPOUND4res*) override final;

491	492	virtual void breakOplockSMBv2(const SMBv2::BreakOpLockCommand, const SMBv2::OplockAcknowledgment, const SMBv2::OplockResponse*) override final;
492	493
493	494	private:
494
495	495	void count_proc(const RPCProcedure* proc);
496		void cifs_account(AbstractProtocol &protocol, int cmd_code);
	496	void cifs_account(AbstractProtocol& protocol, int cmd_code);
497	497	void nfs_account(const RPCProcedure*,
498	498	const unsigned int nfs_minor_vers = NFS_V41);
499	499	void account40_op(const RPCProcedure*, const ProcEnumNFS4::NFSProcedure);

505	505	NFSv4Protocol _nfsv4;
506	506	NFSv3Protocol _nfsv3;
507	507
508		std::vector<AbstractProtocol* > protocols;
509		UserGUI gui;
	508	std::vector<AbstractProtocol*> protocols;
	509	UserGUI gui;
510	510	};
511	511	//------------------------------------------------------------------------------
512		#endif//WATCH_ANALYZER_H
513		//------------------------------------------------------------------------------
	512	#endif //WATCH_ANALYZER_H
	513	//------------------------------------------------------------------------------

-23

~~astyle.cfg~~ less more

0		# Bracket style
1		--style=ansi
2
3		# Tab
4		--indent=spaces=4
5
6		# Indentation
7		--indent-preprocessor
8		--max-instatement-indent=80
9
10		# Padding
11		--pad-oper
12		--pad-header
13		--align-pointer=type
14		--align-reference=type
15
16		# Formatting
17		--add-brackets
18		--keep-one-line-blocks
19		--convert-tabs
20
21		# Other
22		--lineend=linux

+13

-10

cmake/FindJSON.cmake less more

16	16	# in sid:
17	17	# $ sudo apt-get install libjson-c-dev
18	18
19		find_path(JSON_INCLUDE_DIR NAMES json-c/json.h json/json.h)
	19
	20	#[[
	21	Debian and Ubuntu have json-c in /usr/include/json-c and jsoncpp in /usr/include/jsoncpp/json
	22	Arch and Fedora have json-c in /usr/include/json-c and jsoncpp in /usr/include/json
	23	Searching for json_c_version.h avoids finding json.h of jsoncpp.
	24	]]
	25	find_path(JSON_INCLUDE_DIR NAMES json_c_version.h json.h PATHS /usr/include/json-c /usr/include/json)
20	26	find_library(JSON_LIBRARY NAMES json-c json)
21	27
22	28	include(FindPackageHandleStandardArgs)
23	29	find_package_handle_standard_args(JSON DEFAULT_MSG
24		JSON_LIBRARY
25		JSON_INCLUDE_DIR
26		)
	30	JSON_LIBRARY JSON_INCLUDE_DIR
	31	)
27	32
28	33	if(JSON_FOUND)
29		set(JSON_LIBRARIES ${JSON_LIBRARY})
30		# hack to get old and new layout working:
31		set(JSON_INCLUDE_DIRS ${JSON_INCLUDE_DIR}/json-c
32		${JSON_INCLUDE_DIR}/json)
	34	set(JSON_LIBRARIES ${JSON_LIBRARY})
	35	set(JSON_INCLUDE_DIRS ${JSON_INCLUDE_DIR})
33	36	endif()
34	37
35	38	mark_as_advanced(
36		JSON_LIBRARY
37		JSON_INCLUDE_DIR
	39	JSON_LIBRARY
	40	JSON_INCLUDE_DIRS
38	41	)

+14

-0

cmake/codeformat.cmake less more

	0	find_program (clangformat clang-format)
	1	if (clangformat)
	2	execute_process (COMMAND ${clangformat} -version OUTPUT_VARIABLE version_string)
	3	string (REGEX MATCH "([0-9]\\.[0-9]\\.?[0-9]?)" version "${version_string}")
	4	if (${version} VERSION_LESS "3.9")
	5	message (STATUS "Found ${version_string} less that required clang-format 3.9")
	6	else()
	7	add_custom_target (clang-format
	8	COMMAND find analyzers src tests docs -name '.h' -o -name '.cpp' \| xargs ${clangformat} -i -style=file
	9	WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
	10	COMMENT "Reformat sources by clang-format"
	11	SOURCES ${CMAKE_SOURCE_DIR}/.clang-format)
	12	endif()
	13	endif()

-1

cmake/packaging.cmake less more

	0	set (CPACK_PACKAGE_VENDOR "EPAM Systems")
0	1	set (CPACK_PACKAGE_VERSION ${NST_VERSION})
1	2	set (CPACK_PACKAGING_INSTALL_PREFIX "/usr")
2	3	set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "NFS tracing/monitoring/capturing/statistic tool")

4	5
5	6	set (CPACK_RPM_PACKAGE_GROUP "Applications/Internet")
6	7	set (CPACK_RPM_PACKAGE_LICENSE "GPLv2")
7		set (CPACK_RPM_PACKAGE_VENDOR "EPAM Systems")
8	8	set (CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /usr/share/man /usr/share/man/man8)
9	9	set (CPACK_RPM_PACKAGE_REQUIRES "libpcap >= 1.3.0-1")
10	10	if (${CMAKE_SYSTEM_NAME} MATCHES "Linux" AND EXISTS "/etc/os-release")

-5

docs/template.cpp less more

30	30	//------------------------------------------------------------------------------
31	31	namespace hello
32	32	{
33
34		SayHello::SayHello() : text{"Hello, World!"}, value{0}
	33	SayHello::SayHello()
	34	: text{"Hello, World!"}
	35	, value{0}
35	36	{
36	37	}
37	38	SayHello::~SayHello()

60	61	assert(42 == hello.get());
61	62
62	63	// FizzBuzz
63		for(std::size_t i=1; i<=100; i++)
	64	for(std::size_t i = 1; i <= 100; i++)
64	65	{
65	66	if((i % 15) == 0)
66	67	{
67	68	std::cout << "FizzBuzz\n";
68	69	}
69		else if(i % 3 == 0) std::cout << "Fizz\n";
70		else if(i % 5 == 0) std::cout << "Buzz\n";
	70	else if(i % 3 == 0)
	71	std::cout << "Fizz\n";
	72	else if(i % 5 == 0)
	73	std::cout << "Buzz\n";
71	74	else
72	75	{
73	76	std::cout << i << '\n';

-10

docs/template.h less more

21	21	#ifndef TEMPLATE_H
22	22	#define TEMPLATE_H
23	23	//------------------------------------------------------------------------------
24		#include <cstdint> // include language headers in alphabetical order
	24	#include <cstdint> // include language headers in alphabetical order
25	25	#include <string>
26	26	//------------------------------------------------------------------------------
27		#define MY_MIN(a,b) (((a) < (b)) ? (a) : (b)) //!< This is example of preprocessor usage
	27	#define MY_MIN(a, b) (((a) < (b)) ? (a) : (b)) //!< This is example of preprocessor usage
28	28	//------------------------------------------------------------------------------
29	29	namespace hello
30	30	{
31
32	31	/*! \class Represents some entity
33	32	*/
34	33	class SayHello
35	34	{
36	35	public:
37		SayHello();// May be uncommented
38		~SayHello();// May be uncommented
	36	SayHello(); // May be uncommented
	37	~SayHello(); // May be uncommented
39	38
40		SayHello(const SayHello&) = delete;
	39	SayHello(const SayHello&) = delete;
41	40	SayHello& operator=(const SayHello&) = delete;
42	41
43	42	/*! small functions may be implemented in-place
44	43	* \return hello string
45	44	*/
46	45	inline const std::string& say() const { return text; }
47
48	46	/*! Sets some value
49	47	* \param v - new value
50	48	*/

56	54	std::uint32_t get_value() const;
57	55
58	56	private:
59		std::string text;//!< Hello phrase
	57	std::string text; //!< Hello phrase
60	58	std::uint32_t value; //!< just a value for get/set methods
61	59
62		static const unsigned int BAD_COFFEE;//!< Some constant
	60	static const unsigned int BAD_COFFEE; //!< Some constant
63	61	};
64	62
65	63	} // namespace hello
66	64	//------------------------------------------------------------------------------
67		#endif//TEMPLATE_H
	65	#endif //TEMPLATE_H
68	66	//------------------------------------------------------------------------------

-4

src/analysis/analysis_manager.cpp less more

24	24	{
25	25	namespace analysis
26	26	{
27
28	27	AnalysisManager::AnalysisManager(RunningStatus& status, const Parameters& params)
29		: analysiss {nullptr}
30		, queue {nullptr}
31		, parser_thread{nullptr}
	28	: analysiss{nullptr}
	29	, queue{nullptr}
	30	, parser_thread{nullptr}
32	31	{
33	32	analysiss.reset(new Analyzers(params));
34	33

+10

-10

src/analysis/analysis_manager.h less more

25	25
26	26	#include "analysis/analyzers.h"
27	27	#include "analysis/parser_thread.h"
	28	#include "analysis/parsers.h"
28	29	#include "controller/parameters.h"
29	30	#include "controller/running_status.h"
30	31	#include "utils/filtered_data.h"
31		#include "analysis/parsers.h"
32	32	//------------------------------------------------------------------------------
33	33	namespace NST
34	34	{
35	35	namespace analysis
36	36	{
37
38	37	class AnalysisManager
39	38	{
40	39	using Parameters = NST::controller::Parameters;
41	40	using RunningStatus = NST::controller::RunningStatus;
42	41	using FilteredDataQueue = NST::utils::FilteredDataQueue;
	42
43	43	public:
44	44	AnalysisManager(RunningStatus& status, const Parameters& params);
45		AnalysisManager(const AnalysisManager&) = delete;
	45	AnalysisManager(const AnalysisManager&) = delete;
46	46	AnalysisManager& operator=(const AnalysisManager&) = delete;
47		~AnalysisManager() = default;
	47	~AnalysisManager() = default;
48	48
49	49	FilteredDataQueue& get_queue() { return *queue; }
50
51		void start();
52		void stop();
	50	void start();
	51	void stop();
53	52
54	53	inline void on_unix_signal(int signo)
55	54	{

60	59	{
61	60	return analysiss->isSilent();
62	61	}
	62
63	63	private:
64		std::unique_ptr<Analyzers> analysiss;
65		std::unique_ptr<FilteredDataQueue> queue;
	64	std::unique_ptr<Analyzers> analysiss;
	65	std::unique_ptr<FilteredDataQueue> queue;
66	66	std::unique_ptr<ParserThread<Parsers>> parser_thread;
67	67	};
68	68
69	69	} // namespace analysis
70	70	} // namespace NST
71	71	//------------------------------------------------------------------------------
72		#endif//ANALYSIS_MANAGER_H
	72	#endif //ANALYSIS_MANAGER_H
73	73	//------------------------------------------------------------------------------

-2

src/analysis/analyzers.cpp less more

26	26	{
27	27	namespace analysis
28	28	{
29
30	29	Analyzers::Analyzers(const controller::Parameters& params)
31		: _silent{false}
	30	: _silent{false}
32	31	{
33	32	for(const auto& a : params.analysis_modules())
34	33	{

+13

-19

src/analysis/analyzers.h less more

32	32	{
33	33	namespace analysis
34	34	{
35
36	35	class Analyzers
37	36	{
38		using Storage = std::vector<IAnalyzer*>;
39		using Plugins = std::vector< std::unique_ptr<PluginInstance> >;
40		using BuiltIns= std::vector< std::unique_ptr<IAnalyzer> >;
	37	using Storage = std::vector<IAnalyzer*>;
	38	using Plugins = std::vector<std::unique_ptr<PluginInstance>>;
	39	using BuiltIns = std::vector<std::unique_ptr<IAnalyzer>>;
41	40
42	41	public:
43	42	Analyzers(const controller::Parameters& params);
44		Analyzers(const Analyzers&) = delete;
	43	Analyzers(const Analyzers&) = delete;
45	44	Analyzers& operator=(const Analyzers&) = delete;
46	45
47	46	//! This function is used for passing ALL possible procedures to analyzers
48		template
49		<
	47	template <
50	48	typename Handle,
51		typename Procedure
52		>
	49	typename Procedure>
53	50	inline void operator()(Handle handle, const Procedure& proc)
54	51	{
55	52	for(const auto a : modules)

59	56	}
60	57
61	58	//! This function is used for passing args- or res-only NFS4.x operations (ex. NFSv4 ILLEGAL) to analyzers
62		template
63		<
	59	template <
64	60	typename Handle,
65		typename ArgOrResType
66		>
	61	typename ArgOrResType>
67	62	inline void operator()(Handle handle, const RPCProcedure* rpc, ArgOrResType* arg_or_res)
68	63	{
69	64	for(const auto a : modules)

73	68	}
74	69
75	70	//! This function is used for passing args + res NFS4.x operations (ex. NFSv4.x ACCESS) to analyzers
76		template
77		<
	71	template <
78	72	typename Handle,
79	73	typename ArgopType,
80		typename ResopType
81		>
	74	typename ResopType>
82	75	inline void operator()(Handle handle, const RPCProcedure* rpc, ArgopType* arg, ResopType* res)
83	76	{
84	77	for(const auto a : modules)

106	99	{
107	100	return _silent;
108	101	}
	102
109	103	private:
110	104	Storage modules; // pointers to all modules (plugins and builtins)
111	105	Plugins plugins;
112	106	BuiltIns builtin;
113		bool _silent;
	107	bool _silent;
114	108	};
115	109
116	110	} // namespace analysis
117	111	} // namespace NST
118	112	//------------------------------------------------------------------------------
119		#endif//ANALYZERS_H
	113	#endif //ANALYZERS_H
120	114	//------------------------------------------------------------------------------

+109

-111

src/analysis/cifs_parser.cpp less more

26	26	using namespace NST::analysis;
27	27
28	28	CIFSParser::CIFSParser(Analyzers& a)
29		: analyzers(a)
	29	: analyzers(a)
30	30	{
31	31	}
32	32
33	33	bool CIFSParser::parse_data(FilteredDataQueue::Ptr& data)
34	34	{
35		if (const CIFSv1::MessageHeader* header = CIFSv1::get_header(data->data))
	35	if(const CIFSv1::MessageHeader* header = CIFSv1::get_header(data->data))
36	36	{
37	37	parse_packet(header, std::move(data));
38	38	return true;
39	39	}
40		else if (const CIFSv2::MessageHeader* header = CIFSv2::get_header(data->data))
	40	else if(const CIFSv2::MessageHeader* header = CIFSv2::get_header(data->data))
41	41	{
42	42	parse_packet(header, std::move(data));
43	43	return true;

54	54	using namespace NST::API::SMBv1;
55	55	using namespace NST::protocols::CIFSv1;
56	56
57		if (header->isFlag(Flags::REPLY))
	57	if(header->isFlag(Flags::REPLY))
58	58	{
59	59	// It is response
60		if (Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::REPLY))
	60	if(Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::REPLY))
61	61	{
62	62	FilteredDataQueue::Ptr&& requestData = session->get_call_data(header->sec.sequenceNumber);
63		if (requestData)
	63	if(requestData)
64	64	{
65		if (const MessageHeader* request = get_header(requestData->data))
	65	if(const MessageHeader* request = get_header(requestData->data))
66	66	{
67	67	return analyse_operation(session, request, header, std::move(requestData), std::move(ptr));
68	68	}

74	74	else
75	75	{
76	76	// It is request
77		if (Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::CALL))
	77	if(Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::CALL))
78	78	{
79	79	return session->save_call_data(header->sec.sequenceNumber, std::move(ptr));
80	80	}

87	87	using namespace NST::API::SMBv2;
88	88	using namespace NST::protocols::CIFSv2;
89	89
90		if (header->isFlag(Flags::SERVER_TO_REDIR))
	90	if(header->isFlag(Flags::SERVER_TO_REDIR))
91	91	{
92	92	// It is response
93		if (Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::REPLY))
	93	if(Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::REPLY))
94	94	{
95	95	FilteredDataQueue::Ptr&& requestData = session->get_call_data(header->messageId);
96		if (requestData)
	96	if(requestData)
97	97	{
98		if (const MessageHeader* request = get_header(requestData->data))
	98	if(const MessageHeader* request = get_header(requestData->data))
99	99	{
100	100	return analyse_operation(session, request, header, std::move(requestData), std::move(ptr));
101	101	}

107	107	else
108	108	{
109	109	// It is request
110		if (Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::CALL))
	110	if(Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::CALL))
111	111	{
112	112	// It is async request
113		if (header->isFlag(Flags::ASYNC_COMMAND))
	113	if(header->isFlag(Flags::ASYNC_COMMAND))
114	114	{
115	115	return analyse_operation(session, header, nullptr, std::move(ptr), std::move(nullptr));
116	116	}

120	120	}
121	121	}
122	122
123		void CIFSParser::analyse_operation(Session* session,
	123	void CIFSParser::analyse_operation(Session* session,
124	124	const CIFSv1::MessageHeader* request,
125	125	const CIFSv1::MessageHeader* /response/,
126	126	NST::utils::FilteredDataQueue::Ptr&& requestData,

129	129	using namespace NST::API::SMBv1;
130	130	using namespace NST::protocols::CIFSv1;
131	131
132		//FIXME: code smells. Too much code
133		switch (request->cmd_code)
	132	switch(request->cmd_code)
134	133	{
135	134	case Commands::CREATE_DIRECTORY:
136		return analyzers(&IAnalyzer::ISMBv1::createDirectorySMBv1, command<CreateDirectoryCommand>(requestData, responseData, session));
	135	return analyzers(&IAnalyzer::ISMBv1::createDirectorySMBv1, command<CreateDirectoryCommand>(requestData, responseData, session));
137	136	case Commands::DELETE_DIRECTORY:
138		return analyzers(&IAnalyzer::ISMBv1::deleteDirectorySMBv1, command<DeleteDirectoryCommand>(requestData, responseData, session));
	137	return analyzers(&IAnalyzer::ISMBv1::deleteDirectorySMBv1, command<DeleteDirectoryCommand>(requestData, responseData, session));
139	138	case Commands::OPEN:
140		return analyzers(&IAnalyzer::ISMBv1::openSMBv1, command<OpenCommand>(requestData, responseData, session));
	139	return analyzers(&IAnalyzer::ISMBv1::openSMBv1, command<OpenCommand>(requestData, responseData, session));
141	140	case Commands::CREATE:
142		return analyzers(&IAnalyzer::ISMBv1::createSMBv1, command<CreateCommand>(requestData, responseData, session));
	141	return analyzers(&IAnalyzer::ISMBv1::createSMBv1, command<CreateCommand>(requestData, responseData, session));
143	142	case Commands::CLOSE:
144		return analyzers(&IAnalyzer::ISMBv1::closeSMBv1, command<CloseCommand>(requestData, responseData, session));
	143	return analyzers(&IAnalyzer::ISMBv1::closeSMBv1, command<CloseCommand>(requestData, responseData, session));
145	144	case Commands::FLUSH:
146		return analyzers(&IAnalyzer::ISMBv1::flushSMBv1, command<FlushCommand>(requestData, responseData, session));
	145	return analyzers(&IAnalyzer::ISMBv1::flushSMBv1, command<FlushCommand>(requestData, responseData, session));
147	146	case Commands::DELETE:
148		return analyzers(&IAnalyzer::ISMBv1::deleteSMBv1, command<DeleteCommand>(requestData, responseData, session));
	147	return analyzers(&IAnalyzer::ISMBv1::deleteSMBv1, command<DeleteCommand>(requestData, responseData, session));
149	148	case Commands::RENAME:
150		return analyzers(&IAnalyzer::ISMBv1::renameSMBv1, command<RenameCommand>(requestData, responseData, session));
	149	return analyzers(&IAnalyzer::ISMBv1::renameSMBv1, command<RenameCommand>(requestData, responseData, session));
151	150	case Commands::QUERY_INFORMATION:
152		return analyzers(&IAnalyzer::ISMBv1::queryInfoSMBv1, command<QueryInformationCommand>(requestData, responseData, session));
	151	return analyzers(&IAnalyzer::ISMBv1::queryInfoSMBv1, command<QueryInformationCommand>(requestData, responseData, session));
153	152	case Commands::SET_INFORMATION:
154		return analyzers(&IAnalyzer::ISMBv1::setInfoSMBv1, command<SetInformationCommand>(requestData, responseData, session));
	153	return analyzers(&IAnalyzer::ISMBv1::setInfoSMBv1, command<SetInformationCommand>(requestData, responseData, session));
155	154	case Commands::READ:
156		return analyzers(&IAnalyzer::ISMBv1::readSMBv1, command<ReadCommand>(requestData, responseData, session));
	155	return analyzers(&IAnalyzer::ISMBv1::readSMBv1, command<ReadCommand>(requestData, responseData, session));
157	156	case Commands::WRITE:
158		return analyzers(&IAnalyzer::ISMBv1::writeSMBv1, command<WriteCommand>(requestData, responseData, session));
	157	return analyzers(&IAnalyzer::ISMBv1::writeSMBv1, command<WriteCommand>(requestData, responseData, session));
159	158	case Commands::LOCK_BYTE_RANGE:
160		return analyzers(&IAnalyzer::ISMBv1::lockByteRangeSMBv1, command<LockByteRangeCommand>(requestData, responseData, session));
	159	return analyzers(&IAnalyzer::ISMBv1::lockByteRangeSMBv1, command<LockByteRangeCommand>(requestData, responseData, session));
161	160	case Commands::UNLOCK_BYTE_RANGE:
162		return analyzers(&IAnalyzer::ISMBv1::unlockByteRangeSMBv1, command<UnlockByteRangeCommand>(requestData, responseData, session));
	161	return analyzers(&IAnalyzer::ISMBv1::unlockByteRangeSMBv1, command<UnlockByteRangeCommand>(requestData, responseData, session));
163	162	case Commands::CREATE_TEMPORARY:
164		return analyzers(&IAnalyzer::ISMBv1::createTmpSMBv1, command<CreateTemporaryCommand>(requestData, responseData, session));
	163	return analyzers(&IAnalyzer::ISMBv1::createTmpSMBv1, command<CreateTemporaryCommand>(requestData, responseData, session));
165	164	case Commands::CREATE_NEW:
166		return analyzers(&IAnalyzer::ISMBv1::createNewSMBv1, command<CreateNewCommand>(requestData, responseData, session));
	165	return analyzers(&IAnalyzer::ISMBv1::createNewSMBv1, command<CreateNewCommand>(requestData, responseData, session));
167	166	case Commands::CHECK_DIRECTORY:
168		return analyzers(&IAnalyzer::ISMBv1::checkDirectorySMBv1, command<CheckDirectoryCommand>(requestData, responseData, session));
	167	return analyzers(&IAnalyzer::ISMBv1::checkDirectorySMBv1, command<CheckDirectoryCommand>(requestData, responseData, session));
169	168	case Commands::PROCESS_EXIT:
170		return analyzers(&IAnalyzer::ISMBv1::processExitSMBv1, command<ProcessExitCommand>(requestData, responseData, session));
	169	return analyzers(&IAnalyzer::ISMBv1::processExitSMBv1, command<ProcessExitCommand>(requestData, responseData, session));
171	170	case Commands::SEEK:
172		return analyzers(&IAnalyzer::ISMBv1::seekSMBv1, command<SeekCommand>(requestData, responseData, session));
	171	return analyzers(&IAnalyzer::ISMBv1::seekSMBv1, command<SeekCommand>(requestData, responseData, session));
173	172	case Commands::LOCK_AND_READ:
174		return analyzers(&IAnalyzer::ISMBv1::lockAndReadSMBv1, command<LockAndReadCommand>(requestData, responseData, session));
	173	return analyzers(&IAnalyzer::ISMBv1::lockAndReadSMBv1, command<LockAndReadCommand>(requestData, responseData, session));
175	174	case Commands::WRITE_AND_UNLOCK:
176		return analyzers(&IAnalyzer::ISMBv1::writeAndUnlockSMBv1, command<WriteAndUnlockCommand>(requestData, responseData, session));
	175	return analyzers(&IAnalyzer::ISMBv1::writeAndUnlockSMBv1, command<WriteAndUnlockCommand>(requestData, responseData, session));
177	176	case Commands::READ_RAW:
178		return analyzers(&IAnalyzer::ISMBv1::readRawSMBv1, command<ReadRawCommand>(requestData, responseData, session));
	177	return analyzers(&IAnalyzer::ISMBv1::readRawSMBv1, command<ReadRawCommand>(requestData, responseData, session));
179	178	case Commands::READ_MPX:
180		return analyzers(&IAnalyzer::ISMBv1::readMpxSMBv1, command<ReadMpxCommand>(requestData, responseData, session));
	179	return analyzers(&IAnalyzer::ISMBv1::readMpxSMBv1, command<ReadMpxCommand>(requestData, responseData, session));
181	180	case Commands::READ_MPX_SECONDARY:
182		return analyzers(&IAnalyzer::ISMBv1::readMpxSecondarySMBv1, command<ReadMpxSecondaryCommand>(requestData, responseData, session));
	181	return analyzers(&IAnalyzer::ISMBv1::readMpxSecondarySMBv1, command<ReadMpxSecondaryCommand>(requestData, responseData, session));
183	182	case Commands::WRITE_RAW:
184		return analyzers(&IAnalyzer::ISMBv1::writeRawSMBv1, command<WriteRawCommand>(requestData, responseData, session));
	183	return analyzers(&IAnalyzer::ISMBv1::writeRawSMBv1, command<WriteRawCommand>(requestData, responseData, session));
185	184	case Commands::WRITE_MPX:
186		return analyzers(&IAnalyzer::ISMBv1::writeMpxSMBv1, command<WriteMpxCommand>(requestData, responseData, session));
	185	return analyzers(&IAnalyzer::ISMBv1::writeMpxSMBv1, command<WriteMpxCommand>(requestData, responseData, session));
187	186	case Commands::WRITE_MPX_SECONDARY:
188		return analyzers(&IAnalyzer::ISMBv1::writeMpxSecondarySMBv1, command<WriteMpxSecondaryCommand>(requestData, responseData, session));
	187	return analyzers(&IAnalyzer::ISMBv1::writeMpxSecondarySMBv1, command<WriteMpxSecondaryCommand>(requestData, responseData, session));
189	188	case Commands::WRITE_COMPLETE:
190		return analyzers(&IAnalyzer::ISMBv1::writeCompleteSMBv1, command<WriteCompleteCommand>(requestData, responseData, session));
	189	return analyzers(&IAnalyzer::ISMBv1::writeCompleteSMBv1, command<WriteCompleteCommand>(requestData, responseData, session));
191	190	case Commands::QUERY_SERVER:
192		return analyzers(&IAnalyzer::ISMBv1::queryServerSMBv1, command<QueryServerCommand>(requestData, responseData, session));
	191	return analyzers(&IAnalyzer::ISMBv1::queryServerSMBv1, command<QueryServerCommand>(requestData, responseData, session));
193	192	case Commands::SET_INFORMATION2:
194		return analyzers(&IAnalyzer::ISMBv1::setInfo2SMBv1, command<SetInformation2Command>(requestData, responseData, session));
	193	return analyzers(&IAnalyzer::ISMBv1::setInfo2SMBv1, command<SetInformation2Command>(requestData, responseData, session));
195	194	case Commands::QUERY_INFORMATION2:
196		return analyzers(&IAnalyzer::ISMBv1::queryInfo2SMBv1, command<QueryInformation2Command>(requestData, responseData, session));
	195	return analyzers(&IAnalyzer::ISMBv1::queryInfo2SMBv1, command<QueryInformation2Command>(requestData, responseData, session));
197	196	case Commands::LOCKING_ANDX:
198		return analyzers(&IAnalyzer::ISMBv1::lockingAndxSMBv1, command<LockingAndxCommand>(requestData, responseData, session));
	197	return analyzers(&IAnalyzer::ISMBv1::lockingAndxSMBv1, command<LockingAndxCommand>(requestData, responseData, session));
199	198	case Commands::TRANSACTION:
200		return analyzers(&IAnalyzer::ISMBv1::transactionSMBv1, command<TransactionCommand>(requestData, responseData, session));
	199	return analyzers(&IAnalyzer::ISMBv1::transactionSMBv1, command<TransactionCommand>(requestData, responseData, session));
201	200	case Commands::TRANSACTION_SECONDARY:
202	201	return analyzers(&IAnalyzer::ISMBv1::transactionSecondarySMBv1, command<TransactionSecondaryCommand>(requestData, responseData, session));
203	202	case Commands::IOCTL:
204		return analyzers(&IAnalyzer::ISMBv1::ioctlSMBv1, command<IoctlCommand>(requestData, responseData, session));
	203	return analyzers(&IAnalyzer::ISMBv1::ioctlSMBv1, command<IoctlCommand>(requestData, responseData, session));
205	204	case Commands::IOCTL_SECONDARY:
206		return analyzers(&IAnalyzer::ISMBv1::ioctlSecondarySMBv1, command<IoctlSecondaryCommand>(requestData, responseData, session));
	205	return analyzers(&IAnalyzer::ISMBv1::ioctlSecondarySMBv1, command<IoctlSecondaryCommand>(requestData, responseData, session));
207	206	case Commands::COPY:
208		return analyzers(&IAnalyzer::ISMBv1::copySMBv1, command<CopyCommand>(requestData, responseData, session));
	207	return analyzers(&IAnalyzer::ISMBv1::copySMBv1, command<CopyCommand>(requestData, responseData, session));
209	208	case Commands::MOVE:
210		return analyzers(&IAnalyzer::ISMBv1::moveSMBv1, command<MoveCommand>(requestData, responseData, session));
	209	return analyzers(&IAnalyzer::ISMBv1::moveSMBv1, command<MoveCommand>(requestData, responseData, session));
211	210	case Commands::ECHO:
212		return analyzers(&IAnalyzer::ISMBv1::echoSMBv1, command<EchoCommand>(requestData, responseData, session));
	211	return analyzers(&IAnalyzer::ISMBv1::echoSMBv1, command<EchoCommand>(requestData, responseData, session));
213	212	case Commands::WRITE_AND_CLOSE:
214		return analyzers(&IAnalyzer::ISMBv1::writeAndCloseSMBv1, command<WriteAndCloseCommand>(requestData, responseData, session));
	213	return analyzers(&IAnalyzer::ISMBv1::writeAndCloseSMBv1, command<WriteAndCloseCommand>(requestData, responseData, session));
215	214	case Commands::OPEN_ANDX:
216		return analyzers(&IAnalyzer::ISMBv1::openAndxSMBv1, command<OpenAndxCommand>(requestData, responseData, session));
	215	return analyzers(&IAnalyzer::ISMBv1::openAndxSMBv1, command<OpenAndxCommand>(requestData, responseData, session));
217	216	case Commands::READ_ANDX:
218		return analyzers(&IAnalyzer::ISMBv1::readAndxSMBv1, command<ReadAndxCommand>(requestData, responseData, session));
	217	return analyzers(&IAnalyzer::ISMBv1::readAndxSMBv1, command<ReadAndxCommand>(requestData, responseData, session));
219	218	case Commands::WRITE_ANDX:
220		return analyzers(&IAnalyzer::ISMBv1::writeAndxSMBv1, command<WriteAndxCommand>(requestData, responseData, session));
	219	return analyzers(&IAnalyzer::ISMBv1::writeAndxSMBv1, command<WriteAndxCommand>(requestData, responseData, session));
221	220	case Commands::NEW_FILE_SIZE:
222		return analyzers(&IAnalyzer::ISMBv1::newFileSizeSMBv1, command<NewFileSizeCommand>(requestData, responseData, session));
	221	return analyzers(&IAnalyzer::ISMBv1::newFileSizeSMBv1, command<NewFileSizeCommand>(requestData, responseData, session));
223	222	case Commands::CLOSE_AND_TREE_DISC:
224		return analyzers(&IAnalyzer::ISMBv1::closeAndTreeDiscSMBv1, command<CloseAndTreeDiscCommand>(requestData, responseData, session));
	223	return analyzers(&IAnalyzer::ISMBv1::closeAndTreeDiscSMBv1, command<CloseAndTreeDiscCommand>(requestData, responseData, session));
225	224	case Commands::TRANSACTION2:
226		return analyzers(&IAnalyzer::ISMBv1::transaction2SMBv1, command<Transaction2Command>(requestData, responseData, session));
	225	return analyzers(&IAnalyzer::ISMBv1::transaction2SMBv1, command<Transaction2Command>(requestData, responseData, session));
227	226	case Commands::TRANSACTION2_SECONDARY:
228	227	return analyzers(&IAnalyzer::ISMBv1::transaction2SecondarySMBv1, command<Transaction2SecondaryCommand>(requestData, responseData, session));
229	228	case Commands::FIND_CLOSE2:
230		return analyzers(&IAnalyzer::ISMBv1::findClose2SMBv1, command<FindClose2Command>(requestData, responseData, session));
	229	return analyzers(&IAnalyzer::ISMBv1::findClose2SMBv1, command<FindClose2Command>(requestData, responseData, session));
231	230	case Commands::FIND_NOTIFY_CLOSE:
232		return analyzers(&IAnalyzer::ISMBv1::findNotifyCloseSMBv1, command<FindNotifyCloseCommand>(requestData, responseData, session));
	231	return analyzers(&IAnalyzer::ISMBv1::findNotifyCloseSMBv1, command<FindNotifyCloseCommand>(requestData, responseData, session));
233	232	case Commands::TREE_CONNECT:
234		return analyzers(&IAnalyzer::ISMBv1::treeConnectSMBv1, command<TreeConnectCommand>(requestData, responseData, session));
	233	return analyzers(&IAnalyzer::ISMBv1::treeConnectSMBv1, command<TreeConnectCommand>(requestData, responseData, session));
235	234	case Commands::TREE_DISCONNECT:
236		return analyzers(&IAnalyzer::ISMBv1::treeDisconnectSMBv1, command<TreeDisconnectCommand>(requestData, responseData, session));
	235	return analyzers(&IAnalyzer::ISMBv1::treeDisconnectSMBv1, command<TreeDisconnectCommand>(requestData, responseData, session));
237	236	case Commands::NEGOTIATE:
238		return analyzers(&IAnalyzer::ISMBv1::negotiateSMBv1, command<NegotiateCommand>(requestData, responseData, session));
	237	return analyzers(&IAnalyzer::ISMBv1::negotiateSMBv1, command<NegotiateCommand>(requestData, responseData, session));
239	238	case Commands::SESSION_SETUP_ANDX:
240		return analyzers(&IAnalyzer::ISMBv1::sessionSetupAndxSMBv1, command<SessionSetupAndxCommand>(requestData, responseData, session));
	239	return analyzers(&IAnalyzer::ISMBv1::sessionSetupAndxSMBv1, command<SessionSetupAndxCommand>(requestData, responseData, session));
241	240	case Commands::LOGOFF_ANDX:
242		return analyzers(&IAnalyzer::ISMBv1::logoffAndxSMBv1, command<LogoffAndxCommand>(requestData, responseData, session));
	241	return analyzers(&IAnalyzer::ISMBv1::logoffAndxSMBv1, command<LogoffAndxCommand>(requestData, responseData, session));
243	242	case Commands::TREE_CONNECT_ANDX:
244		return analyzers(&IAnalyzer::ISMBv1::treeConnectAndxSMBv1, command<TreeConnectAndxCommand>(requestData, responseData, session));
	243	return analyzers(&IAnalyzer::ISMBv1::treeConnectAndxSMBv1, command<TreeConnectAndxCommand>(requestData, responseData, session));
245	244	case Commands::SECURITY_PACKAGE_ANDX:
246		return analyzers(&IAnalyzer::ISMBv1::securityPackageAndxSMBv1, command<SecurityPackageAndxCommand>(requestData, responseData, session));
	245	return analyzers(&IAnalyzer::ISMBv1::securityPackageAndxSMBv1, command<SecurityPackageAndxCommand>(requestData, responseData, session));
247	246	case Commands::QUERY_INFORMATION_DISK:
248	247	return analyzers(&IAnalyzer::ISMBv1::queryInformationDiskSMBv1, command<QueryInformationDiskCommand>(requestData, responseData, session));
249	248	case Commands::SEARCH:
250		return analyzers(&IAnalyzer::ISMBv1::searchSMBv1, command<SearchCommand>(requestData, responseData, session));
	249	return analyzers(&IAnalyzer::ISMBv1::searchSMBv1, command<SearchCommand>(requestData, responseData, session));
251	250	case Commands::FIND:
252		return analyzers(&IAnalyzer::ISMBv1::findSMBv1, command<FindCommand>(requestData, responseData, session));
	251	return analyzers(&IAnalyzer::ISMBv1::findSMBv1, command<FindCommand>(requestData, responseData, session));
253	252	case Commands::FIND_UNIQUE:
254		return analyzers(&IAnalyzer::ISMBv1::findUniqueSMBv1, command<FindUniqueCommand>(requestData, responseData, session));
	253	return analyzers(&IAnalyzer::ISMBv1::findUniqueSMBv1, command<FindUniqueCommand>(requestData, responseData, session));
255	254	case Commands::FIND_CLOSE:
256		return analyzers(&IAnalyzer::ISMBv1::findCloseSMBv1, command<FindCloseCommand>(requestData, responseData, session));
	255	return analyzers(&IAnalyzer::ISMBv1::findCloseSMBv1, command<FindCloseCommand>(requestData, responseData, session));
257	256	case Commands::NT_TRANSACT:
258		return analyzers(&IAnalyzer::ISMBv1::ntTransactSMBv1, command<NtTransactCommand>(requestData, responseData, session));
	257	return analyzers(&IAnalyzer::ISMBv1::ntTransactSMBv1, command<NtTransactCommand>(requestData, responseData, session));
259	258	case Commands::NT_TRANSACT_SECONDARY:
260		return analyzers(&IAnalyzer::ISMBv1::ntTransactSecondarySMBv1, command<NtTransactSecondaryCommand>(requestData, responseData, session));
	259	return analyzers(&IAnalyzer::ISMBv1::ntTransactSecondarySMBv1, command<NtTransactSecondaryCommand>(requestData, responseData, session));
261	260	case Commands::NT_CREATE_ANDX:
262		return analyzers(&IAnalyzer::ISMBv1::ntCreateAndxSMBv1, command<NtCreateAndxCommand>(requestData, responseData, session));
	261	return analyzers(&IAnalyzer::ISMBv1::ntCreateAndxSMBv1, command<NtCreateAndxCommand>(requestData, responseData, session));
263	262	case Commands::NT_CANCEL:
264		return analyzers(&IAnalyzer::ISMBv1::ntCancelSMBv1, command<NtCancelCommand>(requestData, responseData, session));
	263	return analyzers(&IAnalyzer::ISMBv1::ntCancelSMBv1, command<NtCancelCommand>(requestData, responseData, session));
265	264	case Commands::NT_RENAME:
266		return analyzers(&IAnalyzer::ISMBv1::ntRenameSMBv1, command<NtRenameCommand>(requestData, responseData, session));
	265	return analyzers(&IAnalyzer::ISMBv1::ntRenameSMBv1, command<NtRenameCommand>(requestData, responseData, session));
267	266	case Commands::OPEN_PRINT_FILE:
268		return analyzers(&IAnalyzer::ISMBv1::openPrintFileSMBv1, command<OpenPrintFileCommand>(requestData, responseData, session));
	267	return analyzers(&IAnalyzer::ISMBv1::openPrintFileSMBv1, command<OpenPrintFileCommand>(requestData, responseData, session));
269	268	case Commands::WRITE_PRINT_FILE:
270		return analyzers(&IAnalyzer::ISMBv1::writePrintFileSMBv1, command<WritePrintFileCommand>(requestData, responseData, session));
	269	return analyzers(&IAnalyzer::ISMBv1::writePrintFileSMBv1, command<WritePrintFileCommand>(requestData, responseData, session));
271	270	case Commands::CLOSE_PRINT_FILE:
272		return analyzers(&IAnalyzer::ISMBv1::closePrintFileSMBv1, command<ClosePrintFileCommand>(requestData, responseData, session));
	271	return analyzers(&IAnalyzer::ISMBv1::closePrintFileSMBv1, command<ClosePrintFileCommand>(requestData, responseData, session));
273	272	case Commands::GET_PRINT_QUEUE:
274		return analyzers(&IAnalyzer::ISMBv1::getPrintQueueSMBv1, command<GetPrintQueueCommand>(requestData, responseData, session));
	273	return analyzers(&IAnalyzer::ISMBv1::getPrintQueueSMBv1, command<GetPrintQueueCommand>(requestData, responseData, session));
275	274	case Commands::READ_BULK:
276		return analyzers(&IAnalyzer::ISMBv1::readBulkSMBv1, command<ReadBulkCommand>(requestData, responseData, session));
	275	return analyzers(&IAnalyzer::ISMBv1::readBulkSMBv1, command<ReadBulkCommand>(requestData, responseData, session));
277	276	case Commands::WRITE_BULK:
278		return analyzers(&IAnalyzer::ISMBv1::writeBulkSMBv1, command<WriteBulkCommand>(requestData, responseData, session));
	277	return analyzers(&IAnalyzer::ISMBv1::writeBulkSMBv1, command<WriteBulkCommand>(requestData, responseData, session));
279	278	case Commands::WRITE_BULK_DATA:
280		return analyzers(&IAnalyzer::ISMBv1::writeBulkDataSMBv1, command<WriteBulkDataCommand>(requestData, responseData, session));
	279	return analyzers(&IAnalyzer::ISMBv1::writeBulkDataSMBv1, command<WriteBulkDataCommand>(requestData, responseData, session));
281	280	case Commands::INVALID:
282		return analyzers(&IAnalyzer::ISMBv1::invalidSMBv1, command<InvalidCommand>(requestData, responseData, session));
	281	return analyzers(&IAnalyzer::ISMBv1::invalidSMBv1, command<InvalidCommand>(requestData, responseData, session));
283	282	case Commands::NO_ANDX_COMMAND:
284		return analyzers(&IAnalyzer::ISMBv1::noAndxCommandSMBv1, command<NoAndxCommand>(requestData, responseData, session));
	283	return analyzers(&IAnalyzer::ISMBv1::noAndxCommandSMBv1, command<NoAndxCommand>(requestData, responseData, session));
285	284	default:
286	285	LOG("Usupported command");
287	286	}
288	287	}
289	288
290
291		void CIFSParser::analyse_operation(Session* session,
	289	void CIFSParser::analyse_operation(Session* session,
292	290	const CIFSv2::MessageHeader* request,
293	291	const CIFSv2::MessageHeader* /response/,
294	292	NST::utils::FilteredDataQueue::Ptr&& requestData,

297	295	using namespace NST::API::SMBv2;
298	296	using namespace NST::protocols::CIFSv2;
299	297
300		switch (request->cmd_code)
	298	switch(request->cmd_code)
301	299	{
302	300	case SMBv2Commands::CLOSE:
303		return analyzers(&IAnalyzer::ISMBv2::closeFileSMBv2, command<CloseFileCommand>(requestData, responseData, session));
	301	return analyzers(&IAnalyzer::ISMBv2::closeFileSMBv2, command<CloseFileCommand>(requestData, responseData, session));
304	302	case SMBv2Commands::NEGOTIATE:
305		return analyzers(&IAnalyzer::ISMBv2::negotiateSMBv2, command<NegotiateCommand>(requestData, responseData, session));
	303	return analyzers(&IAnalyzer::ISMBv2::negotiateSMBv2, command<NegotiateCommand>(requestData, responseData, session));
306	304	case SMBv2Commands::SESSION_SETUP:
307		return analyzers(&IAnalyzer::ISMBv2::sessionSetupSMBv2, command<SessionSetupCommand>(requestData, responseData, session));
	305	return analyzers(&IAnalyzer::ISMBv2::sessionSetupSMBv2, command<SessionSetupCommand>(requestData, responseData, session));
308	306	case SMBv2Commands::LOGOFF:
309		return analyzers(&IAnalyzer::ISMBv2::logOffSMBv2, command<LogOffCommand>(requestData, responseData, session));
	307	return analyzers(&IAnalyzer::ISMBv2::logOffSMBv2, command<LogOffCommand>(requestData, responseData, session));
310	308	case SMBv2Commands::TREE_CONNECT:
311		return analyzers(&IAnalyzer::ISMBv2::treeConnectSMBv2, command<TreeConnectCommand>(requestData, responseData, session));
	309	return analyzers(&IAnalyzer::ISMBv2::treeConnectSMBv2, command<TreeConnectCommand>(requestData, responseData, session));
312	310	case SMBv2Commands::TREE_DISCONNECT:
313		return analyzers(&IAnalyzer::ISMBv2::treeDisconnectSMBv2, command<TreeDisconnectCommand>(requestData, responseData, session));
	311	return analyzers(&IAnalyzer::ISMBv2::treeDisconnectSMBv2, command<TreeDisconnectCommand>(requestData, responseData, session));
314	312	case SMBv2Commands::CREATE:
315		return analyzers(&IAnalyzer::ISMBv2::createSMBv2, command<CreateCommand>(requestData, responseData, session));
	313	return analyzers(&IAnalyzer::ISMBv2::createSMBv2, command<CreateCommand>(requestData, responseData, session));
316	314	case SMBv2Commands::FLUSH:
317		return analyzers(&IAnalyzer::ISMBv2::flushSMBv2, command<FlushCommand>(requestData, responseData, session));
	315	return analyzers(&IAnalyzer::ISMBv2::flushSMBv2, command<FlushCommand>(requestData, responseData, session));
318	316	case SMBv2Commands::READ:
319		return analyzers(&IAnalyzer::ISMBv2::readSMBv2, command<ReadCommand>(requestData, responseData, session));
	317	return analyzers(&IAnalyzer::ISMBv2::readSMBv2, command<ReadCommand>(requestData, responseData, session));
320	318	case SMBv2Commands::WRITE:
321		return analyzers(&IAnalyzer::ISMBv2::writeSMBv2, command<WriteCommand>(requestData, responseData, session));
	319	return analyzers(&IAnalyzer::ISMBv2::writeSMBv2, command<WriteCommand>(requestData, responseData, session));
322	320	case SMBv2Commands::LOCK:
323		return analyzers(&IAnalyzer::ISMBv2::lockSMBv2, command<LockCommand>(requestData, responseData, session));
	321	return analyzers(&IAnalyzer::ISMBv2::lockSMBv2, command<LockCommand>(requestData, responseData, session));
324	322	case SMBv2Commands::IOCTL:
325		return analyzers(&IAnalyzer::ISMBv2::ioctlSMBv2, command<IoctlCommand>(requestData, responseData, session));
	323	return analyzers(&IAnalyzer::ISMBv2::ioctlSMBv2, command<IoctlCommand>(requestData, responseData, session));
326	324	case SMBv2Commands::CANCEL:
327		return analyzers(&IAnalyzer::ISMBv2::cancelSMBv2, command<CancelCommand>(requestData, responseData, session));
	325	return analyzers(&IAnalyzer::ISMBv2::cancelSMBv2, command<CancelCommand>(requestData, responseData, session));
328	326	case SMBv2Commands::ECHO:
329		return analyzers(&IAnalyzer::ISMBv2::echoSMBv2, command<EchoCommand>(requestData, responseData, session));
	327	return analyzers(&IAnalyzer::ISMBv2::echoSMBv2, command<EchoCommand>(requestData, responseData, session));
330	328	case SMBv2Commands::QUERY_DIRECTORY:
331		return analyzers(&IAnalyzer::ISMBv2::queryDirSMBv2, command<QueryDirCommand>(requestData, responseData, session));
	329	return analyzers(&IAnalyzer::ISMBv2::queryDirSMBv2, command<QueryDirCommand>(requestData, responseData, session));
332	330	case SMBv2Commands::CHANGE_NOTIFY:
333		return analyzers(&IAnalyzer::ISMBv2::changeNotifySMBv2, command<ChangeNotifyCommand>(requestData, responseData, session));
	331	return analyzers(&IAnalyzer::ISMBv2::changeNotifySMBv2, command<ChangeNotifyCommand>(requestData, responseData, session));
334	332	case SMBv2Commands::QUERY_INFO:
335		return analyzers(&IAnalyzer::ISMBv2::queryInfoSMBv2, command<QueryInfoCommand>(requestData, responseData, session));
	333	return analyzers(&IAnalyzer::ISMBv2::queryInfoSMBv2, command<QueryInfoCommand>(requestData, responseData, session));
336	334	case SMBv2Commands::SET_INFO:
337		return analyzers(&IAnalyzer::ISMBv2::setInfoSMBv2, command<SetInfoCommand>(requestData, responseData, session));
	335	return analyzers(&IAnalyzer::ISMBv2::setInfoSMBv2, command<SetInfoCommand>(requestData, responseData, session));
338	336	case SMBv2Commands::OPLOCK_BREAK:
339		return analyzers(&IAnalyzer::ISMBv2::breakOplockSMBv2, command<BreakOpLockCommand>(requestData, responseData, session));
	337	return analyzers(&IAnalyzer::ISMBv2::breakOplockSMBv2, command<BreakOpLockCommand>(requestData, responseData, session));
340	338	default:
341	339	LOG("Usupported command");
342	340	}

+15

-13

src/analysis/cifs_parser.h less more

31	31	{
32	32	namespace analysis
33	33	{
34
35	34	/*! \class It is class which can parse CIFS messages and it called by ParserThread
36	35	*/
37	36	class CIFSParser
38	37	{
39		using FilteredDataQueue = NST::utils::FilteredDataQueue;//!< Packets queue
	38	using FilteredDataQueue = NST::utils::FilteredDataQueue; //!< Packets queue
40	39
41		Analyzers& analyzers;//!< Plugins manager
42		Sessions<Session> sessions;//!< Sessions list
	40	Analyzers& analyzers; //!< Plugins manager
	41	Sessions<Session> sessions; //!< Sessions list
43	42
44	43	/*! Parses SMBv1 packet
45	44	* \param header - Message's header

54	53	* \param requestData - Call's data
55	54	* \param responseData - Reply's data
56	55	*/
57		inline void analyse_operation(Session* session,
	56	inline void analyse_operation(Session* session,
58	57	const protocols::CIFSv1::MessageHeader* request,
59	58	const protocols::CIFSv1::MessageHeader* response,
60		FilteredDataQueue::Ptr&& requestData,
61		FilteredDataQueue::Ptr&& responseData);
	59	FilteredDataQueue::Ptr&& requestData,
	60	FilteredDataQueue::Ptr&& responseData);
62	61
63	62	/*! Parses SMB v2 packet
64	63	* \param header - Message's header

73	72	* \param requestData - Call's data
74	73	* \param responseData - Reply's data
75	74	*/
76		inline void analyse_operation(Session* session,
	75	inline void analyse_operation(Session* session,
77	76	const protocols::CIFSv2::MessageHeader* request,
78	77	const protocols::CIFSv2::MessageHeader* response,
79		FilteredDataQueue::Ptr&& requestData,
80		FilteredDataQueue::Ptr&& responseData);
	78	FilteredDataQueue::Ptr&& requestData,
	79	FilteredDataQueue::Ptr&& responseData);
	80
81	81	public:
82
83	82	CIFSParser(Analyzers& a);
84		CIFSParser(CIFSParser& c) : analyzers(c.analyzers) {}
	83	CIFSParser(CIFSParser& c)
	84	: analyzers(c.analyzers)
	85	{
	86	}
85	87
86	88	/*! Function which will be called by ParserThread class
87	89	* \param data - raw packet

93	95	} // analysis
94	96	} // NST
95	97	//------------------------------------------------------------------------------
96		#endif//CIFS_PARSER_H
	98	#endif //CIFS_PARSER_H
97	99	//------------------------------------------------------------------------------

+131

-128

src/analysis/nfs_parser.cpp less more

30	30	{
31	31	namespace analysis
32	32	{
33
34
35	33	bool NFSParser::parse_data(FilteredDataQueue::Ptr& ptr)
36	34	{
37	35	using namespace NST::protocols::rpc;
38	36
39	37	// TODO: refactor and generalize this code
40		if (ptr->dlen < sizeof(MessageHeader))
	38	if(ptr->dlen < sizeof(MessageHeader))
41	39	{
42	40	return false;
43	41	}
44	42	auto msg = reinterpret_cast<const MessageHeader*>(ptr->data);
45		switch (msg->type())
	43	switch(msg->type())
46	44	{
47	45	case MsgType::CALL:
48	46	{
49		if (ptr->dlen < sizeof(CallHeader))
	47	if(ptr->dlen < sizeof(CallHeader))
50	48	{
51	49	return false;
52	50	}
53	51
54	52	auto call = static_cast<const CallHeader*>(msg);
55	53
56		if (RPCValidator::check(call) && (protocols::NFS4::Validator::check(call) \|\|
57		protocols::NFS3::Validator::check(call)))
	54	if(RPCValidator::check(call) && (protocols::NFS4::Validator::check(call) \|\|
	55	protocols::NFS3::Validator::check(call)))
58	56	{
59	57	Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::CALL);
60		if (session)
	58	if(session)
61	59	{
62	60	session->save_call_data(call->xid(), std::move(ptr));
63	61	}

67	65	break;
68	66	case MsgType::REPLY:
69	67	{
70		if (ptr->dlen < sizeof(ReplyHeader))
	68	if(ptr->dlen < sizeof(ReplyHeader))
71	69	{
72	70	return false;
73	71	}
74	72	auto reply = static_cast<const ReplyHeader*>(msg);
75	73
76		if (!RPCValidator::check(reply))
	74	if(!RPCValidator::check(reply))
77	75	{
78	76	return false;
79	77	}
80	78
81	79	Session* session = sessions.get_session(ptr->session, ptr->direction, MsgType::REPLY);
82		if (session)
	80	if(session)
83	81	{
84	82	FilteredDataQueue::Ptr&& call_data = session->get_call_data(reply->xid());
85		if (call_data)
	83	if(call_data)
86	84	{
87	85	analyze_nfs_procedure(std::move(call_data), std::move(ptr), session);
88	86	}

103	101	using NFS40CompoundType = NST::protocols::NFS4::NFSPROC4RPCGEN_COMPOUND;
104	102	using NFS41CompoundType = NST::protocols::NFS41::NFSPROC41RPCGEN_COMPOUND;
105	103
106		template
107		<
108		typename ArgOpType,
109		typename ResOpType,
110		typename NFS4CompoundType
111		>
	104	template <
	105	typename ArgOpType,
	106	typename ResOpType,
	107	typename NFS4CompoundType>
112	108	void analyze_nfs4_operations(Analyzers& analyzers, NFS4CompoundType& nfs4_compound_procedure);
113	109
114	110	inline void analyze_nfs40_operations(Analyzers& analyzers, NFS40CompoundType& nfs40_compound_procedure)
115	111	{
116		analyze_nfs4_operations < NST::API::NFS4::nfs_argop4,
	112	analyze_nfs4_operations<NST::API::NFS4::nfs_argop4,
117	113	NST::API::NFS4::nfs_resop4,
118		NFS40CompoundType > (analyzers, nfs40_compound_procedure);
	114	NFS40CompoundType>(analyzers, nfs40_compound_procedure);
119	115	}
120	116
121	117	inline void analyze_nfs41_operations(Analyzers& analyzers, NFS41CompoundType& nfs41_compound_procedure)
122	118	{
123		analyze_nfs4_operations < NST::API::NFS41::nfs_argop4,
	119	analyze_nfs4_operations<NST::API::NFS41::nfs_argop4,
124	120	NST::API::NFS41::nfs_resop4,
125		NFS41CompoundType > (analyzers, nfs41_compound_procedure);
126		}
127
128		void nfs4_ops_switch(Analyzers& analyzers,
129		const RPCProcedure* rpc_procedure,
	121	NFS41CompoundType>(analyzers, nfs41_compound_procedure);
	122	}
	123
	124	void nfs4_ops_switch(Analyzers& analyzers,
	125	const RPCProcedure* rpc_procedure,
130	126	const NST::API::NFS4::nfs_argop4* arg,
131	127	const NST::API::NFS4::nfs_resop4* res);
132	128
133		void nfs4_ops_switch(Analyzers& analyzers,
134		const RPCProcedure* rpc_procedure,
	129	void nfs4_ops_switch(Analyzers& analyzers,
	130	const RPCProcedure* rpc_procedure,
135	131	const NST::API::NFS41::nfs_argop4* arg,
136	132	const NST::API::NFS41::nfs_resop4* res);
137	133

140	136	static inline void analyze_nfsv3_procedure(const uint32_t procedure, XDRDecoder&& c, XDRDecoder&& r, const Session* s, Analyzers& analyzers)
141	137	{
142	138	using namespace NST::protocols::NFS3;
143		switch (procedure)
	139	switch(procedure)
144	140	{
145	141	case ProcEnumNFS3::NFS_NULL:
146		analyzers(&IAnalyzer::INFSv3rpcgen::null, NFSPROC3RPCGEN_NULL {c, r, s});
	142	analyzers(&IAnalyzer::INFSv3rpcgen::null, NFSPROC3RPCGEN_NULL{c, r, s});
147	143	break;
148	144	case ProcEnumNFS3::GETATTR:
149		analyzers(&IAnalyzer::INFSv3rpcgen::getattr3, NFSPROC3RPCGEN_GETATTR {c, r, s});
	145	analyzers(&IAnalyzer::INFSv3rpcgen::getattr3, NFSPROC3RPCGEN_GETATTR{c, r, s});
150	146	break;
151	147	case ProcEnumNFS3::SETATTR:
152		analyzers(&IAnalyzer::INFSv3rpcgen::setattr3, NFSPROC3RPCGEN_SETATTR {c, r, s});
	148	analyzers(&IAnalyzer::INFSv3rpcgen::setattr3, NFSPROC3RPCGEN_SETATTR{c, r, s});
153	149	break;
154	150	case ProcEnumNFS3::LOOKUP:
155		analyzers(&IAnalyzer::INFSv3rpcgen::lookup3, NFSPROC3RPCGEN_LOOKUP {c, r, s});
	151	analyzers(&IAnalyzer::INFSv3rpcgen::lookup3, NFSPROC3RPCGEN_LOOKUP{c, r, s});
156	152	break;
157	153	case ProcEnumNFS3::ACCESS:
158		analyzers(&IAnalyzer::INFSv3rpcgen::access3, NFSPROC3RPCGEN_ACCESS {c, r, s});
	154	analyzers(&IAnalyzer::INFSv3rpcgen::access3, NFSPROC3RPCGEN_ACCESS{c, r, s});
159	155	break;
160	156	case ProcEnumNFS3::READLINK:
161		analyzers(&IAnalyzer::INFSv3rpcgen::readlink3, NFSPROC3RPCGEN_READLINK {c, r, s});
	157	analyzers(&IAnalyzer::INFSv3rpcgen::readlink3, NFSPROC3RPCGEN_READLINK{c, r, s});
162	158	break;
163	159	case ProcEnumNFS3::READ:
164		analyzers(&IAnalyzer::INFSv3rpcgen::read3, NFSPROC3RPCGEN_READ {c, r, s});
	160	analyzers(&IAnalyzer::INFSv3rpcgen::read3, NFSPROC3RPCGEN_READ{c, r, s});
165	161	break;
166	162	case ProcEnumNFS3::WRITE:
167		analyzers(&IAnalyzer::INFSv3rpcgen::write3, NFSPROC3RPCGEN_WRITE {c, r, s});
	163	analyzers(&IAnalyzer::INFSv3rpcgen::write3, NFSPROC3RPCGEN_WRITE{c, r, s});
168	164	break;
169	165	case ProcEnumNFS3::CREATE:
170		analyzers(&IAnalyzer::INFSv3rpcgen::create3, NFSPROC3RPCGEN_CREATE {c, r, s});
	166	analyzers(&IAnalyzer::INFSv3rpcgen::create3, NFSPROC3RPCGEN_CREATE{c, r, s});
171	167	break;
172	168	case ProcEnumNFS3::MKDIR:
173		analyzers(&IAnalyzer::INFSv3rpcgen::mkdir3, NFSPROC3RPCGEN_MKDIR {c, r, s});
	169	analyzers(&IAnalyzer::INFSv3rpcgen::mkdir3, NFSPROC3RPCGEN_MKDIR{c, r, s});
174	170	break;
175	171	case ProcEnumNFS3::SYMLINK:
176		analyzers(&IAnalyzer::INFSv3rpcgen::symlink3, NFSPROC3RPCGEN_SYMLINK {c, r, s});
	172	analyzers(&IAnalyzer::INFSv3rpcgen::symlink3, NFSPROC3RPCGEN_SYMLINK{c, r, s});
177	173	break;
178	174	case ProcEnumNFS3::MKNOD:
179		analyzers(&IAnalyzer::INFSv3rpcgen::mknod3, NFSPROC3RPCGEN_MKNOD {c, r, s});
	175	analyzers(&IAnalyzer::INFSv3rpcgen::mknod3, NFSPROC3RPCGEN_MKNOD{c, r, s});
180	176	break;
181	177	case ProcEnumNFS3::REMOVE:
182		analyzers(&IAnalyzer::INFSv3rpcgen::remove3, NFSPROC3RPCGEN_REMOVE {c, r, s});
	178	analyzers(&IAnalyzer::INFSv3rpcgen::remove3, NFSPROC3RPCGEN_REMOVE{c, r, s});
183	179	break;
184	180	case ProcEnumNFS3::RMDIR:
185		analyzers(&IAnalyzer::INFSv3rpcgen::rmdir3, NFSPROC3RPCGEN_RMDIR {c, r, s});
	181	analyzers(&IAnalyzer::INFSv3rpcgen::rmdir3, NFSPROC3RPCGEN_RMDIR{c, r, s});
186	182	break;
187	183	case ProcEnumNFS3::RENAME:
188		analyzers(&IAnalyzer::INFSv3rpcgen::rename3, NFSPROC3RPCGEN_RENAME {c, r, s});
	184	analyzers(&IAnalyzer::INFSv3rpcgen::rename3, NFSPROC3RPCGEN_RENAME{c, r, s});
189	185	break;
190	186	case ProcEnumNFS3::LINK:
191		analyzers(&IAnalyzer::INFSv3rpcgen::link3, NFSPROC3RPCGEN_LINK {c, r, s});
	187	analyzers(&IAnalyzer::INFSv3rpcgen::link3, NFSPROC3RPCGEN_LINK{c, r, s});
192	188	break;
193	189	case ProcEnumNFS3::READDIR:
194		analyzers(&IAnalyzer::INFSv3rpcgen::readdir3, NFSPROC3RPCGEN_READDIR {c, r, s});
	190	analyzers(&IAnalyzer::INFSv3rpcgen::readdir3, NFSPROC3RPCGEN_READDIR{c, r, s});
195	191	break;
196	192	case ProcEnumNFS3::READDIRPLUS:
197		analyzers(&IAnalyzer::INFSv3rpcgen::readdirplus3, NFSPROC3RPCGEN_READDIRPLUS {c, r, s});
	193	analyzers(&IAnalyzer::INFSv3rpcgen::readdirplus3, NFSPROC3RPCGEN_READDIRPLUS{c, r, s});
198	194	break;
199	195	case ProcEnumNFS3::FSSTAT:
200		analyzers(&IAnalyzer::INFSv3rpcgen::fsstat3, NFSPROC3RPCGEN_FSSTAT {c, r, s});
	196	analyzers(&IAnalyzer::INFSv3rpcgen::fsstat3, NFSPROC3RPCGEN_FSSTAT{c, r, s});
201	197	break;
202	198	case ProcEnumNFS3::FSINFO:
203		analyzers(&IAnalyzer::INFSv3rpcgen::fsinfo3, NFSPROC3RPCGEN_FSINFO {c, r, s});
	199	analyzers(&IAnalyzer::INFSv3rpcgen::fsinfo3, NFSPROC3RPCGEN_FSINFO{c, r, s});
204	200	break;
205	201	case ProcEnumNFS3::PATHCONF:
206		analyzers(&IAnalyzer::INFSv3rpcgen::pathconf3, NFSPROC3RPCGEN_PATHCONF {c, r, s});
	202	analyzers(&IAnalyzer::INFSv3rpcgen::pathconf3, NFSPROC3RPCGEN_PATHCONF{c, r, s});
207	203	break;
208	204	case ProcEnumNFS3::COMMIT:
209		analyzers(&IAnalyzer::INFSv3rpcgen::commit3, NFSPROC3RPCGEN_COMMIT {c, r, s});
	205	analyzers(&IAnalyzer::INFSv3rpcgen::commit3, NFSPROC3RPCGEN_COMMIT{c, r, s});
210	206	break;
211	207	}
212	208	}

216	212	using namespace NST::protocols::NFS4;
217	213	using namespace NST::protocols::NFS41;
218	214
219		switch (get_nfs4_compound_minor_version(procedure, c.data().data))
	215	switch(get_nfs4_compound_minor_version(procedure, c.data().data))
220	216	{
221	217	case NFS_V40:
222		switch (procedure)
	218	switch(procedure)
223	219	{
224	220	case ProcEnumNFS4::NFS_NULL:
225		analyzers(&IAnalyzer::INFSv4rpcgen::null4, NFSPROC4RPCGEN_NULL { c, r, s });
	221	analyzers(&IAnalyzer::INFSv4rpcgen::null4, NFSPROC4RPCGEN_NULL{c, r, s});
226	222	break;
227	223	case ProcEnumNFS4::COMPOUND:
228		NFSPROC4RPCGEN_COMPOUND compound { c, r, s };
	224	NFSPROC4RPCGEN_COMPOUND compound{c, r, s};
229	225	analyzers(&IAnalyzer::INFSv4rpcgen::compound4, compound);
230	226	analyze_nfs40_operations(analyzers, compound);
231	227	break;
232	228	}
233	229	break;
234	230	case NFS_V41:
235		if (ProcEnumNFS41::COMPOUND == procedure)
236		{
237		NFSPROC41RPCGEN_COMPOUND compound { c, r, s };
	231	if(ProcEnumNFS41::COMPOUND == procedure)
	232	{
	233	NFSPROC41RPCGEN_COMPOUND compound{c, r, s};
238	234	analyzers(&IAnalyzer::INFSv41rpcgen::compound41, compound);
239	235	analyze_nfs41_operations(analyzers, compound);
240	236	}

242	238	}
243	239	}
244	240
245		void NFSParser::analyze_nfs_procedure( FilteredDataQueue::Ptr&& call,
246		FilteredDataQueue::Ptr&& reply,
247		Session* session)
	241	void NFSParser::analyze_nfs_procedure(FilteredDataQueue::Ptr&& call,
	242	FilteredDataQueue::Ptr&& reply,
	243	Session* session)
248	244	{
249	245	using namespace NST::protocols::rpc;
250	246
251		auto header = reinterpret_cast<const CallHeader*>(call->data);
252		const uint32_t major_version {header->vers()};
253		const uint32_t procedure {header->proc()};
	247	auto header = reinterpret_cast<const CallHeader*>(call->data);
	248	const uint32_t major_version{header->vers()};
	249	const uint32_t procedure{header->proc()};
254	250
255	251	try
256	252	{
257		const Session* s { session->get_session() };
258
259		switch (major_version)
	253	const Session* s{session->get_session()};
	254
	255	switch(major_version)
260	256	{
261	257	case NFS_V4:
262	258	analyze_nfsv4_procedure(procedure, std::move(call), std::move(reply), s, this->analyzers);

266	262	break;
267	263	}
268	264	}
269		catch (XDRDecoderError& e)
270		{
271		const char* procedure_name {"Unknown procedure"};
272		switch (major_version)
	265	catch(XDRDecoderError& e)
	266	{
	267	const char* procedure_name{"Unknown procedure"};
	268	switch(major_version)
273	269	{
274	270	case NFS_V4:
275	271	procedure_name = print_nfs4_procedures(static_cast<ProcEnumNFS4::NFSProcedure>(procedure));

293	289	*/
294	290	static uint32_t get_nfs4_compound_minor_version(const uint32_t procedure, const std::uint8_t* rpc_nfs4_call)
295	291	{
296		if (ProcEnumNFS4::COMPOUND != procedure)
	292	if(ProcEnumNFS4::COMPOUND != procedure)
297	293	{
298	294	return 0;
299	295	}

320	316
321	317	//! Common internal function for parsing NFSv4.x's COMPOUND procedure
322	318	//! It's supposed to be used inside analyze_nfs_procedure only
323		template
324		<
325		typename ArgOpType, // Type of arguments(call part of nfs's procedure)
326		typename ResOpType, // Type of results(reply part of nfs's procedure)
327		typename NFS4CompoundType // Type of NFSv4.x COMPOUND procedure. Can be 4.0 or 4.1
328		>
	319	template <
	320	typename ArgOpType, // Type of arguments(call part of nfs's procedure)
	321	typename ResOpType, // Type of results(reply part of nfs's procedure)
	322	typename NFS4CompoundType // Type of NFSv4.x COMPOUND procedure. Can be 4.0 or 4.1
	323	>
329	324	void analyze_nfs4_operations(Analyzers& analyzers, NFS4CompoundType& nfs4_compound_procedure)
330	325	{
331		ArgOpType* arg {nullptr};
332		ResOpType* res {nullptr};
333
334		uint32_t arg_ops_count {0}; // Amount of NFS operations (call part)
335		uint32_t res_ops_count {0}; // Amount of NFS operations (reply part)
336		uint32_t total_ops_count {0};
337
338		if (nfs4_compound_procedure.parg) // Checking if COMPOUND procedure has valid arg
	326	ArgOpType* arg{nullptr};
	327	ResOpType* res{nullptr};
	328
	329	uint32_t arg_ops_count{0}; // Amount of NFS operations (call part)
	330	uint32_t res_ops_count{0}; // Amount of NFS operations (reply part)
	331	uint32_t total_ops_count{0};
	332
	333	if(nfs4_compound_procedure.parg) // Checking if COMPOUND procedure has valid arg
339	334	{
340	335	arg_ops_count = nfs4_compound_procedure.parg->argarray.argarray_len;
341		arg = nfs4_compound_procedure.parg->argarray.argarray_val;
342		}
343
344		if (nfs4_compound_procedure.pres) // Checking if COMPOUND procedure has valid res
	336	arg = nfs4_compound_procedure.parg->argarray.argarray_val;
	337	}
	338
	339	if(nfs4_compound_procedure.pres) // Checking if COMPOUND procedure has valid res
345	340	{
346	341	res_ops_count = nfs4_compound_procedure.pres->resarray.resarray_len;
347		res = nfs4_compound_procedure.pres->resarray.resarray_val;
	342	res = nfs4_compound_procedure.pres->resarray.resarray_val;
348	343	}
349	344
350	345	// Determing which part of COMPOUND has the biggest amount of operations.
351	346	total_ops_count = arg_ops_count > res_ops_count ? arg_ops_count : res_ops_count;
352	347
353	348	// Traversing through ALL COMPOUND procedure's operations
354		for (uint32_t i {0}; i < total_ops_count; i++)
355		{
356		if ((arg && res) && (arg->argop != res->resop))
	349	for(uint32_t i{0}; i < total_ops_count; i++)
	350	{
	351	if((arg && res) && (arg->argop != res->resop))
357	352	{
358	353	// Passing each operation to analyzers using the helper's function
359	354	nfs4_ops_switch(analyzers, &nfs4_compound_procedure, arg, nullptr);

364	359	nfs4_ops_switch(analyzers, &nfs4_compound_procedure, arg, res);
365	360	}
366	361
367		if (arg && i < (arg_ops_count - 1)) { arg++; }
368		else { arg = nullptr; }
369		if (res && i < (res_ops_count - 1)) { res++; }
370		else { res = nullptr; }
	362	if(arg && i < (arg_ops_count - 1))
	363	{
	364	arg++;
	365	}
	366	else
	367	{
	368	arg = nullptr;
	369	}
	370	if(res && i < (res_ops_count - 1))
	371	{
	372	res++;
	373	}
	374	else
	375	{
	376	res = nullptr;
	377	}
371	378	}
372	379	}
373	380
374	381	//! Internal function for proper passing NFSv4.x's arg + res operations to analyzers
375	382	//! It's supposed to be used inside nfs4_ops_switch only
376		template
377		<
378		typename nfs_argop4_t,
379		typename nfs_resop4_t,
380		typename IAnalyzer_func_t,
381		typename nfs_argop_member_t,
382		typename nfs_resop_member_t
383		>
384		inline void analyze(Analyzers& analyzers,
	383	template <
	384	typename nfs_argop4_t,
	385	typename nfs_resop4_t,
	386	typename IAnalyzer_func_t,
	387	typename nfs_argop_member_t,
	388	typename nfs_resop_member_t>
	389	inline void analyze(Analyzers& analyzers,
385	390	const RPCProcedure* rpc_procedure,
386	391	const nfs_argop4_t* arg,
387	392	const nfs_resop4_t* res,
388		IAnalyzer_func_t&& IAnalyzer_function,
389		nfs_argop_member_t arg_operation,
390		nfs_resop_member_t res_operation)
	393	IAnalyzer_func_t&& IAnalyzer_function,
	394	nfs_argop_member_t arg_operation,
	395	nfs_resop_member_t res_operation)
391	396	{
392	397	analyzers(IAnalyzer_function, rpc_procedure,
393		arg == nullptr ? nullptr : & (arg->nfs_argop4_u.*arg_operation),
394		res == nullptr ? nullptr : & (res->nfs_resop4_u.*res_operation));
	398	arg == nullptr ? nullptr : &(arg->nfs_argop4_u.*arg_operation),
	399	res == nullptr ? nullptr : &(res->nfs_resop4_u.*res_operation));
395	400	}
396	401
397	402	//! Internal function for proper passing NFSv4.x's res-only operations to analyzers
398	403	//! It's supposed to be used inside nfs4_ops_switch only
399		template
400		<
401		typename nfs_resop4_t,
402		typename IAnalyzer_func_t,
403		typename nfs_resop_member_t
404		>
405		inline void analyze(Analyzers& analyzers,
	404	template <
	405	typename nfs_resop4_t,
	406	typename IAnalyzer_func_t,
	407	typename nfs_resop_member_t>
	408	inline void analyze(Analyzers& analyzers,
406	409	const RPCProcedure* rpc_procedure,
407	410	const nfs_resop4_t* res,
408		IAnalyzer_func_t&& IAnalyzer_function,
409		nfs_resop_member_t res_operation)
	411	IAnalyzer_func_t&& IAnalyzer_function,
	412	nfs_resop_member_t res_operation)
410	413	{
411	414	analyzers(IAnalyzer_function, rpc_procedure,
412		res == nullptr ? nullptr : & (res->nfs_resop4_u.*res_operation));
	415	res == nullptr ? nullptr : &(res->nfs_resop4_u.*res_operation));
413	416	}
414	417
415	418	//! Internal function for proper passing NFSv4.0's operations to analyzers
416	419	//! It's supposed to be used inside analyze_nfs4_operations only
417		void nfs4_ops_switch(Analyzers& analyzers,
418		const RPCProcedure* rpc_procedure,
	420	void nfs4_ops_switch(Analyzers& analyzers,
	421	const RPCProcedure* rpc_procedure,
419	422	const NST::API::NFS4::nfs_argop4* arg,
420	423	const NST::API::NFS4::nfs_resop4* res)
421	424	{

424	427	using res_t = NST::API::NFS4::nfs_resop4_u_t;
425	428
426	429	uint32_t nfs_op_num = arg ? arg->argop : res->resop;
427		switch (nfs_op_num)
	430	switch(nfs_op_num)
428	431	{
429	432	case ProcEnumNFS4::ACCESS:
430	433	analyze(analyzers, rpc_procedure, arg, res,

659	662
660	663	//! Internal function for proper passing NFSv4.1's operations to analyzers
661	664	//! It's supposed to be used inside analyze_nfs4_operations only
662		void nfs4_ops_switch(Analyzers& analyzers,
663		const RPCProcedure* rpc_procedure,
	665	void nfs4_ops_switch(Analyzers& analyzers,
	666	const RPCProcedure* rpc_procedure,
664	667	const NST::API::NFS41::nfs_argop4* arg,
665	668	const NST::API::NFS41::nfs_resop4* res)
666	669	{

669	672	using res_t = NST::API::NFS41::nfs_resop4_u_t;
670	673
671	674	uint32_t nfs_op_num = arg ? arg->argop : res->resop;
672		switch (nfs_op_num)
	675	switch(nfs_op_num)
673	676	{
674	677	case ProcEnumNFS41::ACCESS:
675	678	analyze(analyzers, rpc_procedure, arg, res,

+12

-7

src/analysis/nfs_parser.h less more

31	31	{
32	32	namespace analysis
33	33	{
34
35	34	/*! \class It is class which can parse NFS messages and it called by ParserThread
36	35	*/
37	36	class NFSParser
38	37	{
39	38	using FilteredDataQueue = NST::utils::FilteredDataQueue;
40	39
41		Analyzers& analyzers;
	40	Analyzers& analyzers;
42	41	Sessions<Session> sessions;
	42
43	43	public:
44
45		NFSParser(Analyzers& a) : analyzers(a) {}
46		NFSParser(NFSParser& c) : analyzers(c.analyzers) {}
	44	NFSParser(Analyzers& a)
	45	: analyzers(a)
	46	{
	47	}
	48	NFSParser(NFSParser& c)
	49	: analyzers(c.analyzers)
	50	{
	51	}
47	52
48	53	/*! Function which will be called by ParserThread class
49	54	* \param data - RPC packet

54	59	void parse_data(FilteredDataQueue::Ptr&& data);
55	60	void analyze_nfs_procedure(FilteredDataQueue::Ptr&& call,
56	61	FilteredDataQueue::Ptr&& reply,
57		Session* session);
	62	Session* session);
58	63	};
59	64
60	65	} // analysis
61	66	} // NST
62	67	//------------------------------------------------------------------------------
63		#endif//NFS_PARSER_H
	68	#endif //NFS_PARSER_H
64	69	//------------------------------------------------------------------------------

+11

-14

src/analysis/parser_thread.h less more

32	32	{
33	33	namespace analysis
34	34	{
35
36	35	template <typename Parser>
37	36	class ParserThread
38	37	{
39	38	using RunningStatus = NST::controller::RunningStatus;
40	39	using FilteredDataQueue = NST::utils::FilteredDataQueue;
	40
41	41	public:
42	42	ParserThread(Parser p, FilteredDataQueue& q, RunningStatus& s)
43		: status (s)
44		, queue (q)
45		, running {ATOMIC_FLAG_INIT} // false
46		, parser(p)
	43	: status(s)
	44	, queue(q)
	45	, running{ATOMIC_FLAG_INIT} // false
	46	, parser(p)
47	47	{
48	48	}
49	49
50	50	~ParserThread()
51	51	{
52		if (parsing.joinable()) stop();
	52	if(parsing.joinable()) stop();
53	53	}
54	54
55	55	void start()

64	64	parsing.join();
65	65	}
66	66
67
68	67	private:
69
70	68	inline void thread()
71	69	{
72	70	try

102	100	{
103	101	FilteredDataQueue::Ptr data = list.get_current();
104	102	parser.parse_data(data);
105		}
106		while(list);
	103	} while(list);
107	104	}
108	105	}
109	106
110		RunningStatus& status;
	107	RunningStatus& status;
111	108	FilteredDataQueue& queue;
112	109
113		std::thread parsing;
	110	std::thread parsing;
114	111	std::atomic_flag running;
115		Parser parser;
	112	Parser parser;
116	113	};
117	114
118	115	} // namespace analysis
119	116	} // namespace NST
120	117	//------------------------------------------------------------------------------
121		#endif//NFS_PARSER_THREAD_H
	118	#endif //NFS_PARSER_THREAD_H
122	119	//------------------------------------------------------------------------------

-9

src/analysis/parsers.h less more

29	29	{
30	30	namespace analysis
31	31	{
32
33	32	/*!
34	33	* Composite parser which parses both CIFS&NFS
35	34	*/
36	35	class Parsers
37	36	{
38	37	using FilteredDataQueue = NST::utils::FilteredDataQueue;
39		CIFSParser parser_cifs;//!< CIFS parser
40		NFSParser parser_nfs;//!< NFS parser
	38	CIFSParser parser_cifs; //!< CIFS parser
	39	NFSParser parser_nfs; //!< NFS parser
41	40	public:
42
43	41	Parsers(Analyzers& a)
44	42	: parser_cifs(a)
45	43	, parser_nfs(a)
46		{}
	44	{
	45	}
47	46
48	47	Parsers(Parsers& c)
49	48	: parser_cifs(c.parser_cifs)
50	49	, parser_nfs(c.parser_nfs)
51		{}
	50	{
	51	}
52	52
53	53	/*! Function which will be called by ParserThread class
54	54	* \param data - packet
55	55	*/
56	56	inline void parse_data(FilteredDataQueue::Ptr& data)
57	57	{
58		if (!parser_nfs.parse_data(data))
	58	if(!parser_nfs.parse_data(data))
59	59	{
60		if (!parser_cifs.parse_data(data))
	60	if(!parser_cifs.parse_data(data))
61	61	{
62	62	LOG("Unknown packet to analysis");
63	63	}
64	64	}
65	65	}
66
67	66	};
68	67
69	68	} // analysis

-10

src/analysis/plugin.cpp less more

26	26	{
27	27	namespace analysis
28	28	{
29
30	29	bool Plugin::isSilent()
31	30	{
32		if (requirements != nullptr)
	31	if(requirements != nullptr)
33	32	{
34	33	// Processing analyzer requirements
35	34	const AnalyzerRequirements* r = requirements();
36		if (r != nullptr)
	35	if(r != nullptr)
37	36	{
38	37	return r->silence;
39	38	}

43	42
44	43	Plugin::Plugin(const std::string& path)
45	44	: DynamicLoad{path}
46		, usage {nullptr}
47		, create {nullptr}
	45	, usage{nullptr}
	46	, create{nullptr}
48	47	, destroy{nullptr}
49	48	, requirements{nullptr}
50	49	{

64	63	// Add 2.0 specific initialization here
65	64	case NST_PLUGIN_API_VERSION:
66	65	default:
67		usage = entry_points->usage;
68		create = entry_points->create;
69		destroy = entry_points->destroy;
	66	usage = entry_points->usage;
	67	create = entry_points->create;
	68	destroy = entry_points->destroy;
70	69	requirements = entry_points->requirements;
71	70	}
72	71
73		if(!usage \|\| !create \|\| !destroy)
	72	if(!usage \|\| !create \|\| !destroy)
74	73	{
75	74	throw std::runtime_error{path + ": can't load entry point for some plugin function(s)"};
76	75	}

83	82	}
84	83
85	84	PluginInstance::PluginInstance(const std::string& path, const std::string& args)
86		: Plugin{path}
	85	: Plugin{path}
87	86	{
88	87	analysis = create(args.c_str());
89	88	if(!analysis) throw std::runtime_error{path + ": create call returns NULL-pointer"};

-8

src/analysis/plugin.h less more

30	30	{
31	31	namespace analysis
32	32	{
33
34	33	class Plugin : private NST::utils::DynamicLoad
35	34	{
36	35	public:

39	38
40	39	protected:
41	40	explicit Plugin(const std::string& path);
42		Plugin(const Plugin&) = delete;
	41	Plugin(const Plugin&) = delete;
43	42	Plugin& operator=(const Plugin&) = delete;
44	43
45		plugin_usage_func usage;
46		plugin_create_func create;
47		plugin_destroy_func destroy;
	44	plugin_usage_func usage;
	45	plugin_create_func create;
	46	plugin_destroy_func destroy;
48	47	plugin_requirements_func requirements;
49	48	};
50	49

52	51	{
53	52	public:
54	53	PluginInstance(const std::string& path, const std::string& args);
55		PluginInstance(const PluginInstance&) = delete;
	54	PluginInstance(const PluginInstance&) = delete;
56	55	PluginInstance& operator=(const PluginInstance&) = delete;
57	56	~PluginInstance();
58	57
59	58	inline IAnalyzer* instance() const { return analysis; }
60		inline bool silent(){ return isSilent(); }
	59	inline bool silent() { return isSilent(); }
61	60	private:
62	61	IAnalyzer* analysis;
63	62	};

65	64	} // namespace analysis
66	65	} // namespace NST
67	66	//------------------------------------------------------------------------------
68		#endif//PLUGIN_H
	67	#endif //PLUGIN_H
69	68	//------------------------------------------------------------------------------

+1278

-1092

src/analysis/print_analyzer.cpp less more

18	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
19	19	*/
20	20	//------------------------------------------------------------------------------
	21	#include <algorithm>
	22	#include <ctime>
21	23	#include <iomanip>
22		#include <time.h>
23		#include <algorithm>
	24	#include <sstream>
24	25	#include <utility>
25		#include <sstream>
26	26
27	27	#include "analysis/print_analyzer.h"
28	28	#include "protocols/cifs/cifs.h"
29	29	#include "protocols/cifs2/cifs2.h"
	30	#include "protocols/cifs2/cifs2_utils.h"
30	31	#include "protocols/nfs/nfs_utils.h"
31	32	#include "protocols/nfs3/nfs3_utils.h"
	33	#include "protocols/nfs4/nfs41_utils.h"
32	34	#include "protocols/nfs4/nfs4_utils.h"
33		#include "protocols/nfs4/nfs41_utils.h"
34		#include "protocols/cifs2/cifs2_utils.h"
35	35	#include "utils/sessions.h"
36	36	//------------------------------------------------------------------------------
37	37	namespace NST
38	38	{
39	39	namespace analysis
40	40	{
41
42	41	using SMBv1Commands = NST::API::SMBv1::SMBv1Commands;
43	42	using SMBv2Commands = NST::API::SMBv2::SMBv2Commands;
44	43	using namespace NST::protocols::CIFSv2;

51	50	namespace NFS41 = NST::API::NFS41;
52	51
53	52	namespace
54		{
	53	{
55	54	bool print_procedure(std::ostream& out, const RPCProcedure* proc)
56	55	{
57	56	using namespace NST::utils;
58		bool result {false};
	57	bool result{false};
59	58	out << *(proc->session);
60	59
61		auto& call = proc->call;
62		const unsigned long nfs_version {call.ru.RM_cmb.cb_vers};
63		if (out_all())
64		{
65		out << " XID: " << call.rm_xid
	60	auto& call = proc->call;
	61	const unsigned long nfs_version{call.ru.RM_cmb.cb_vers};
	62	if(out_all())
	63	{
	64	out << " XID: " << call.rm_xid
66	65	<< " RPC version: " << call.ru.RM_cmb.cb_rpcvers
67	66	<< " RPC program: " << call.ru.RM_cmb.cb_prog
68		<< " version: " << nfs_version << ' ';
69		}
70		switch (nfs_version)
	67	<< " version: " << nfs_version << ' ';
	68	}
	69	switch(nfs_version)
71	70	{
72	71	case NFS_V3:
73	72	out << print_nfs3_procedures(static_cast<ProcEnumNFS3::NFSProcedure>(call.ru.RM_cmb.cb_proc));

79	78
80	79	// check procedure reply
81	80	auto& reply = proc->reply;
82		if (reply.ru.RM_rmb.rp_stat == reply_stat::MSG_ACCEPTED)
83		{
84		switch (reply.ru.RM_rmb.ru.RP_ar.ar_stat)
	81	if(reply.ru.RM_rmb.rp_stat == reply_stat::MSG_ACCEPTED)
	82	{
	83	switch(reply.ru.RM_rmb.ru.RP_ar.ar_stat)
85	84	{
86	85	case accept_stat::SUCCESS:
87		result = true; // Ok, reply is correct
	86	result = true; // Ok, reply is correct
88	87	break;
89	88	case accept_stat::PROG_MISMATCH:
90	89	out << " Program mismatch: "
91		<< " low: " << reply.ru.RM_rmb.ru.RP_ar.ru.AR_versions.low
	90	<< " low: " << reply.ru.RM_rmb.ru.RP_ar.ru.AR_versions.low
92	91	<< " high: " << reply.ru.RM_rmb.ru.RP_ar.ru.AR_versions.high;
93	92	break;
94	93	case accept_stat::PROG_UNAVAIL:

105	104	break;
106	105	}
107	106	}
108		else if (reply.ru.RM_rmb.rp_stat == reply_stat::MSG_DENIED)
	107	else if(reply.ru.RM_rmb.rp_stat == reply_stat::MSG_DENIED)
109	108	{
110	109	out << " RPC Call rejected: ";
111		switch (reply.ru.RM_rmb.ru.RP_dr.rj_stat)
	110	switch(reply.ru.RM_rmb.ru.RP_dr.rj_stat)
112	111	{
113	112	case reject_stat::RPC_MISMATCH:
114	113	out << "RPC version number mismatch, "

120	119	case reject_stat::AUTH_ERROR:
121	120	{
122	121	out << " Authentication check: ";
123		switch (reply.ru.RM_rmb.ru.RP_dr.ru.RJ_why)
	122	switch(reply.ru.RM_rmb.ru.RP_dr.ru.RJ_why)
124	123	{
125	124	case auth_stat::AUTH_OK:
126	125	out << "OK";

165	164	std::ostream& print_time(std::ostream& out, uint64_t time)
166	165	{
167	166	// TODO: Replace with C++ 11 functions
168		if (time != 0)
	167	if(time != 0)
169	168	{
170	169	const auto EPOCH_DIFF = 0x019DB1DED53E8000LL; /* 116444736000000000 nsecs */
171		const auto RATE_DIFF = 10000000; /* 100 nsecs */
	170	const auto RATE_DIFF = 10000000; /* 100 nsecs */
172	171
173	172	uint64_t unixTimestamp = (time - EPOCH_DIFF) / RATE_DIFF;
174		time_t t = static_cast<time_t>(unixTimestamp);
	173	time_t t = static_cast<time_t>(unixTimestamp);
175	174
176	175	// NOTE: If you ever want to print the year/day/month separately like this:
177	176	//

180	179	// do not forget adding 1900 to tm_year field, just to get current year
181	180	// lt->tm_year + 1900
182	181
183		const char *pTime = ctime(&t);
184		if (pTime != nullptr)
	182	const char* pTime = ctime(&t);
	183	if(pTime != nullptr)
185	184	{
186	185	// ctime adds "\n" at the end - remove it.
187	186	size_t len = std::strlen(pTime);

196	195	return out;
197	196	}
198	197
199		std::ostream& print_buffer(std::ostream& out, const uint8_t *buffer, uint16_t len)
	198	std::ostream& print_buffer(std::ostream& out, const uint8_t* buffer, uint16_t len)
200	199	{
201	200	// TODO: Add unicode support
202	201	const char* char_buffer = reinterpret_cast<const char*>(buffer);

210	209	return out;
211	210	}
212	211
213		std::ostream& print_buffer_hex(std::ostream& out, const uint8_t *buffer, uint16_t len)
	212	std::ostream& print_buffer_hex(std::ostream& out, const uint8_t* buffer, uint16_t len)
214	213	{
215	214	for(uint16_t i = 0; i < len; i++)
216	215	{

228	227
229	228	// print hex value with preceding 0 (zeros) if necessary
230	229	// ( e.g: 0x01 will be printed as 01 or 0x00 as 00 )
231		auto print_hex = [&out](uint32_t value, uint8_t bitShift)
232		{
	230	auto print_hex = [&out](uint32_t value, uint8_t bitShift) {
233	231	out << std::hex << std::setfill('0') << std::setw(2)
234	232	<< (static_cast<uint32_t>(value >> bitShift) & 0xFF) << std::dec;
235	233	};
236	234
237	235	print_hex(refGuid.Data1, 24);
238	236	print_hex(refGuid.Data1, 16);
239		print_hex(refGuid.Data1, 8);
240		print_hex(refGuid.Data1, 0);
	237	print_hex(refGuid.Data1, 8);
	238	print_hex(refGuid.Data1, 0);
241	239	out << "-";
242	240	print_hex(refGuid.Data2, 8);
243	241	print_hex(refGuid.Data2, 0);

255	253	}
256	254	}
257	255
258		template<typename CommandType>
	256	template <typename CommandType>
259	257	std::ostream& print_session(std::ostream& out, CommandType* cmd)
260	258	{
261	259	using namespace NST::utils;

264	262	return out;
265	263	}
266	264
267		template<typename CommandType>
	265	template <typename CommandType>
268	266	std::ostream& print_smbv2_common_info_req(std::ostream& out, SMBv2Commands, CommandType* cmd)
269	267	{
270	268	out << " Structure size = ";

272	270	return out;
273	271	}
274	272
275		template<typename CommandType>
	273	template <typename CommandType>
276	274	std::ostream& print_smbv2_common_info_resp(std::ostream& out, SMBv2Commands, CommandType* cmd)
277	275	{
278	276	out << " Structure size = ";
279	277	print_hex16(out, cmd->pres->structureSize);
280	278	return out;
281		}
	279	}
282	280
283	281	std::ostream& print_smbv2_header(std::ostream& out, const RawMessageHeader* header)
284	282	{
285		if (header == nullptr)
	283	if(header == nullptr)
286	284	{
287	285	return out;
288	286	}

308	306	out << " Credit Charge = " << header->CreditCharge << "\n";
309	307
310	308	bool isResponse = header->flags & static_cast<uint32_t>(Flags::SERVER_TO_REDIR);
311		if (isResponse)
	309	if(isResponse)
312	310	{
313	311	SMBv2::NTStatus status = static_cast<SMBv2::NTStatus>(header->status);
314	312	print_enum(out, "NT Status", status);

321	319	out << "\n";
322	320	print_enum(out, "Command", header->cmd_code) << "\n";
323	321
324		if (isResponse)
	322	if(isResponse)
325	323	{
326	324	out << " Credits granted = " << header->Credit << "\n";
327	325	}

408	406	<< "\n";
409	407
410	408	print_enum(out, "Security mode", cmd->parg->securityMode) << "\n";
411		print_enum(out, "Capabilities", cmd->parg->capabilities) << "\n";
	409	print_enum(out, "Capabilities", cmd->parg->capabilities) << "\n";
412	410
413	411	out << " Client Guid = ";
414	412	print_guid(out, cmd->parg->clientGUID);

427	425	print_smbv2_header(out, cmd->res_header) << "\n";
428	426	print_smbv2_common_info_resp(out, cmdEnum, cmd) << "\n";
429	427
430		print_enum(out, "Security mode", res->securityMode) << "\n";
	428	print_enum(out, "Security mode", res->securityMode) << "\n";
431	429
432	430	out << " Dialect = ";
433	431	print_hex16(out, res->dialectRevision);

456	454
457	455	out << "\n Boot Time = ";
458	456	print_time(out, res->serverStartTime);
459
460	457	}
461	458
462	459	void PrintAnalyzer::sessionSetupSMBv2(const SMBv2::SessionSetupCommand* cmd,

468	465	print_session(out, cmd) << "\n";
469	466	print_smbv2_header(out, cmd->req_header) << "\n";
470	467	print_smbv2_common_info_req(out, cmdEnum, cmd) << "\n";
471		print_enum(out, "Flags", cmd->parg->VcNumber) << "\n";
472		print_enum(out, "Security mode", cmd->parg->securityMode) << "\n";
473		print_enum(out, "Capabilities", cmd->parg->capabilities) << "\n";
	468	print_enum(out, "Flags", cmd->parg->VcNumber) << "\n";
	469	print_enum(out, "Security mode", cmd->parg->securityMode) << "\n";
	470	print_enum(out, "Capabilities", cmd->parg->capabilities) << "\n";
474	471	out << " Channel = " << cmd->parg->Channel << "\n"
475	472	<< " Previous session id = " << cmd->parg->PreviousSessionId << "\n";
476	473	print_smbv2_header(out, cmd->res_header) << "\n";

506	503	if(plen > 0)
507	504	{
508	505	out << " Tree =";
509		print_buffer(out,cmd->parg->Buffer, plen) << "\n";
	506	print_buffer(out, cmd->parg->Buffer, plen) << "\n";
510	507	}
511	508	print_smbv2_header(out, cmd->res_header) << "\n";
512	509	print_smbv2_common_info_resp(out, cmdEnum, cmd) << "\n";
513	510	print_enum(out, "Share types", res->ShareType) << "\n";
514	511	print_enum(out, "Capabilities", res->capabilities) << "\n";
515	512	print_enum(out, "Share flags", res->shareFlags) << "\n";
516		print_enum(out, "Access mask", static_cast<SMBv2::AccessMask>(res->MaximalAccess));
	513	print_enum(out, "Access mask", static_cast<SMBv2::AccessMask>(res->MaximalAccess));
517	514	}
518	515
519	516	void PrintAnalyzer::treeDisconnectSMBv2(const SMBv2::TreeDisconnectCommand* cmd,

537	534	print_session(out, cmd) << "\n";
538	535	print_smbv2_header(out, cmd->req_header) << "\n";
539	536	print_smbv2_common_info_req(out, cmdEnum, cmd) << "\n";
540		print_enum(out, "Oplock", cmd->parg->RequestedOplockLevel) << "\n";
541		print_enum(out, "Impersonation", cmd->parg->ImpersonationLevel) << "\n";
542		out << " Create Flags = ";
	537	print_enum(out, "Oplock", cmd->parg->RequestedOplockLevel) << "\n";
	538	print_enum(out, "Impersonation", cmd->parg->ImpersonationLevel) << "\n";
	539	out << " Create Flags = ";
543	540	print_hex64(out, cmd->parg->SmbCreateFlags);
544	541	out << "\n";
545		print_enum(out, "Access Mask", cmd->parg->desiredAccess) << "\n";
546		print_enum(out, "File Attributes", cmd->parg->attributes) << "\n";
547		print_enum(out, "Share Access", cmd->parg->shareAccess) << "\n";
548		print_enum(out, "Disposition", cmd->parg->createDisposition) << "\n";
549		print_enum(out, "Create Options", cmd->parg->createOptions) << "\n";
	542	print_enum(out, "Access Mask", cmd->parg->desiredAccess) << "\n";
	543	print_enum(out, "File Attributes", cmd->parg->attributes) << "\n";
	544	print_enum(out, "Share Access", cmd->parg->shareAccess) << "\n";
	545	print_enum(out, "Disposition", cmd->parg->createDisposition) << "\n";
	546	print_enum(out, "Create Options", cmd->parg->createOptions) << "\n";
550	547
551	548	const auto len = NST::API::SMBv2::pc_to_net(cmd->parg->NameLength);
552	549	if(len > 0)

559	556	print_smbv2_header(out, cmd->res_header) << "\n";
560	557	print_smbv2_common_info_resp(out, cmdEnum, cmd) << "\n";
561	558
562		print_enum(out, "Oplock", res->oplockLevel) << "\n";
	559	print_enum(out, "Oplock", res->oplockLevel) << "\n";
563	560	out << " Response Flags = ";
564	561	print_hex8(out, res->flag);
565	562	out << "\n";
566		print_enum(out, "Create Action", res->CreateAction) << "\n";
567
568		if (cmd->res_header && cmd->res_header->status == to_integral(SMBv2::NTStatus::STATUS_SUCCESS))
	563	print_enum(out, "Create Action", res->CreateAction) << "\n";
	564
	565	if(cmd->res_header && cmd->res_header->status == to_integral(SMBv2::NTStatus::STATUS_SUCCESS))
569	566	{
570	567	out << " Create = ";
571	568	print_time(out, res->CreationTime);

585	582	out << "\n End Of File = ";
586	583	out << res->EndofFile << "\n";
587	584
588		print_enum(out, "File Attributes", res->attributes);
	585	print_enum(out, "File Attributes", res->attributes);
589	586	}
590	587	}
591	588

642	639	print_hex16(out, cmd->parg->dataOffset);
643	640
644	641	out << "\n"
645		<< " Write Length = " << cmd->parg->Length << "\n"
646		<< " File Offset = " << cmd->parg->Offset << "\n"
647		<< " Channel = " << to_integral(cmd->parg->Channel) << "\n"
648		<< " Remaining Bytes = " << cmd->parg->RemainingBytes << "\n"
649		<< " Channel Info Offset = " << cmd->parg->WriteChannelInfoOffset << "\n"
650		<< " Channel Info Length = " << cmd->parg->WriteChannelInfoLength << "\n";
651		print_enum(out, "Write Flags", cmd->parg->Flags) << "\n";
	642	<< " Write Length = " << cmd->parg->Length << "\n"
	643	<< " File Offset = " << cmd->parg->Offset << "\n"
	644	<< " Channel = " << to_integral(cmd->parg->Channel) << "\n"
	645	<< " Remaining Bytes = " << cmd->parg->RemainingBytes << "\n"
	646	<< " Channel Info Offset = " << cmd->parg->WriteChannelInfoOffset << "\n"
	647	<< " Channel Info Length = " << cmd->parg->WriteChannelInfoLength << "\n";
	648	print_enum(out, "Write Flags", cmd->parg->Flags) << "\n";
652	649
653	650	print_smbv2_header(out, cmd->res_header) << "\n";
654	651	print_smbv2_common_info_resp(out, cmdEnum, cmd) << "\n";

680	677	SMBv2Commands cmdEnum = SMBv2Commands::IOCTL;
681	678	print_session(out, cmd) << "\n";
682	679	print_smbv2_header(out, cmd->req_header) << "\n";
683		print_smbv2_common_info_req(out, cmdEnum, cmd) << "\n";
684		print_enum(out, "Control Code", cmd->parg->CtlCode) << "\n";
	680	print_smbv2_common_info_req(out, cmdEnum, cmd) << "\n";
	681	print_enum(out, "Control Code", cmd->parg->CtlCode) << "\n";
685	682	out << " Input offset = " << cmd->parg->InputOffset << "\n"
686	683	<< " Input count = " << cmd->parg->InputCount << "\n"
687	684	<< " Max input response = " << cmd->parg->MaxInputResponse << "\n"

690	687	<< " Max output response = " << cmd->parg->MaxOutputResponse << "\n";
691	688	print_smbv2_header(out, cmd->res_header) << "\n";
692	689	print_smbv2_common_info_resp(out, cmdEnum, cmd) << "\n";
693		print_enum(out, "Control Code", res->CtlCode) << "\n";
	690	print_enum(out, "Control Code", res->CtlCode) << "\n";
694	691	out << " Input offset = " << res->InputOffset << "\n"
695	692	<< " Input count = " << res->InputCount << "\n"
696	693	<< " Output offset = " << res->OutputOffset << "\n"

725	722	print_session(out, cmd) << "\n";
726	723	print_smbv2_header(out, cmd->req_header) << "\n";
727	724	print_smbv2_common_info_req(out, cmdEnum, cmd) << "\n";
728		print_enum(out, "Info level", cmd->parg->infoType) << "\n";
	725	print_enum(out, "Info level", cmd->parg->infoType) << "\n";
729	726	out << " File index = " << cmd->parg->FileIndex << "\n"
730	727	<< " Output buffer length = " << cmd->parg->OutputBufferLength << "\n"
731	728	<< " Search pattern =";

748	745	print_smbv2_header(out, cmd->res_header) << "\n";
749	746	print_smbv2_common_info_resp(out, cmdEnum, cmd) << "\n";
750	747	out << " Offset = ";
751		print_hex32(out, res->OutputBufferOffset);
	748	print_hex32(out, res->OutputBufferOffset);
752	749	out << "\n";
753	750	out << " Length = ";
754	751	print_hex32(out, res->OutputBufferLength);

761	758	print_session(out, cmd) << "\n";
762	759	print_smbv2_header(out, cmd->req_header) << "\n";
763	760	print_smbv2_common_info_req(out, cmdEnum, cmd) << "\n";
764		print_enum(out, "Class", cmd->parg->infoType) << "\n";
	761	print_enum(out, "Class", cmd->parg->infoType) << "\n";
765	762	print_info_levels(out, cmd->parg->infoType, cmd->parg->FileInfoClass) << "\n";
766	763	//TODO: Print GUID handle file
767	764	print_smbv2_header(out, cmd->res_header) << "\n";
768	765	print_smbv2_common_info_resp(out, cmdEnum, cmd) << "\n";
769	766	out << " Offset = ";
770		print_hex32(out, res->OutputBufferOffset);
	767	print_hex32(out, res->OutputBufferOffset);
771	768	out << "\n Length = ";
772	769	print_hex32(out, res->OutputBufferLength);
773	770	}

779	776	print_session(out, cmd) << "\n";
780	777	print_smbv2_header(out, cmd->req_header) << "\n";
781	778	print_smbv2_common_info_req(out, cmdEnum, cmd) << "\n";
782		print_enum(out, "Class", cmd->parg->infoType) << "\n";
	779	print_enum(out, "Class", cmd->parg->infoType) << "\n";
783	780	print_info_levels(out, cmd->parg->infoType, cmd->parg->FileInfoClass) << "\n";
784	781	out << " Setinfo Size = ";
785		print_hex32(out, cmd->parg->BufferLength);
	782	print_hex32(out, cmd->parg->BufferLength);
786	783	out << "\n Setinfo Offset = ";
787	784	print_hex16(out, cmd->parg->BufferOffset);
788	785	out << "\n";

791	788	}
792	789
793	790	void PrintAnalyzer::breakOplockSMBv2(const SMBv2::BreakOpLockCommand* cmd,
794		const SMBv2::OplockAcknowledgment*,
795		const SMBv2::OplockResponse* res)
	791	const SMBv2::OplockAcknowledgment*,
	792	const SMBv2::OplockResponse* res)
796	793	{
797	794	SMBv2Commands cmdEnum = SMBv2Commands::OPLOCK_BREAK;
798	795

817	814	const struct NFS3::NULL3args*,
818	815	const struct NFS3::NULL3res*)
819	816	{
820		if (!print_procedure(out, proc)) { return; }
	817	if(!print_procedure(out, proc)) {
	818	return;
	819	}
821	820	out << "\tCALL []\n\tREPLY []\n";
822	821	}
823	822

825	824	const struct NFS3::GETATTR3args* args,
826	825	const struct NFS3::GETATTR3res* res)
827	826	{
828		if (!print_procedure(out, proc)) { return; }
829
830		if (args)
	827	if(!print_procedure(out, proc)) {
	828	return;
	829	}
	830
	831	if(args)
831	832	{
832	833	out << "\tCALL ["
833	834	<< " object: " << args->object
834	835	<< " ]\n";
835	836	}
836		if (res)
	837	if(res)
837	838	{
838	839	out << "\tREPLY [ status: " << res->status;
839		if (out_all() && res->status == NFS3::nfsstat3::NFS3_OK)
	840	if(out_all() && res->status == NFS3::nfsstat3::NFS3_OK)
840	841	out << " obj attributes: "
841	842	<< res->GETATTR3res_u.resok.obj_attributes;
842	843	out << " ]\n";

847	848	const struct NFS3::SETATTR3args* args,
848	849	const struct NFS3::SETATTR3res* res)
849	850	{
850		if (!print_procedure(out, proc)) { return; }
851
852		if (args)
	851	if(!print_procedure(out, proc)) {
	852	return;
	853	}
	854
	855	if(args)
853	856	{
854	857	out << "\tCALL [ object: " << args->object
855		<< " new attributes: " << args->new_attributes
856		<< " guard: " << args->guard
	858	<< " new attributes: " << args->new_attributes
	859	<< " guard: " << args->guard
857	860	<< " ]\n";
858	861	}
859		if (res)
	862	if(res)
860	863	{
861	864	out << "\tREPLY [ status: " << res->status;
862		if (out_all())
863		{
864		if (res->status == NFS3::nfsstat3::NFS3_OK)
	865	if(out_all())
	866	{
	867	if(res->status == NFS3::nfsstat3::NFS3_OK)
865	868	out << " obj_wcc: "
866	869	<< res->SETATTR3res_u.resok.obj_wcc;
867	870	else

876	879	const struct NFS3::LOOKUP3args* args,
877	880	const struct NFS3::LOOKUP3res* res)
878	881	{
879		if (!print_procedure(out, proc)) { return; }
880
881		if (args) { out << "\tCALL [ what: " << args->what << " ]\n"; }
882		if (res)
	882	if(!print_procedure(out, proc)) {
	883	return;
	884	}
	885
	886	if(args) {
	887	out << "\tCALL [ what: " << args->what << " ]\n";
	888	}
	889	if(res)
883	890	{
884	891	out << "\tREPLY [ status: " << res->status;
885		if (out_all())
886		{
887		if (res->status == NFS3::nfsstat3::NFS3_OK)
	892	if(out_all())
	893	{
	894	if(res->status == NFS3::nfsstat3::NFS3_OK)
888	895	out << " object: "
889	896	<< res->LOOKUP3res_u.resok.object
890	897	<< " object attributes: "

903	910	const struct NFS3::ACCESS3args* args,
904	911	const struct NFS3::ACCESS3res* res)
905	912	{
906		if (!print_procedure(out, proc)) { return; }
907
908		if (args)
	913	if(!print_procedure(out, proc)) {
	914	return;
	915	}
	916
	917	if(args)
909	918	{
910	919	out << "\tCALL [ object: ";
911	920	print_nfs_fh(out,

916	925	out << " ]\n";
917	926	}
918	927
919		if (res)
	928	if(res)
920	929	{
921	930	out << "\tREPLY [ status: " << res->status;
922		if (out_all())
923		{
924		if (res->status == NFS3::nfsstat3::NFS3_OK)
	931	if(out_all())
	932	{
	933	if(res->status == NFS3::nfsstat3::NFS3_OK)
925	934	{
926	935	out << " object attributes: "
927	936	<< res->ACCESS3res_u.resok.obj_attributes

942	951	const struct NFS3::READLINK3args* args,
943	952	const struct NFS3::READLINK3res* res)
944	953	{
945		if (!print_procedure(out, proc)) { return; }
946
947		if (args) { out << "\tCALL [ symlink: " << args->symlink << " ]\n"; }
948		if (res)
	954	if(!print_procedure(out, proc)) {
	955	return;
	956	}
	957
	958	if(args) {
	959	out << "\tCALL [ symlink: " << args->symlink << " ]\n";
	960	}
	961	if(res)
949	962	{
950	963	out << "\tREPLY [ status: " << res->status;
951		if (out_all())
952		{
953		if (res->status == NFS3::nfsstat3::NFS3_OK)
	964	if(out_all())
	965	{
	966	if(res->status == NFS3::nfsstat3::NFS3_OK)
954	967	out << " symlink attributes: "
955	968	<< res->READLINK3res_u.resok.symlink_attributes
956	969	<< " data: "

967	980	const struct NFS3::READ3args* args,
968	981	const struct NFS3::READ3res* res)
969	982	{
970		if (!print_procedure(out, proc)) { return; }
971
972		if (args)
	983	if(!print_procedure(out, proc)) {
	984	return;
	985	}
	986
	987	if(args)
973	988	{
974	989	out << "\tCALL [ file: " << args->file
975	990	<< " offset: " << args->offset
976		<< " count: " << args->count
	991	<< " count: " << args->count
977	992	<< " ]\n";
978	993	}
979		if (res)
	994	if(res)
980	995	{
981	996	out << "\tREPLY [ status: " << res->status;
982		if (out_all())
983		{
984		if (res->status == NFS3::nfsstat3::NFS3_OK)
	997	if(out_all())
	998	{
	999	if(res->status == NFS3::nfsstat3::NFS3_OK)
985	1000	{
986	1001	out << " file attributes: "
987	1002	<< res->READ3res_u.resok.file_attributes

1004	1019	const struct NFS3::WRITE3args* args,
1005	1020	const struct NFS3::WRITE3res* res)
1006	1021	{
1007		if (!print_procedure(out, proc)) { return; }
1008
1009		if (args)
	1022	if(!print_procedure(out, proc)) {
	1023	return;
	1024	}
	1025
	1026	if(args)
1010	1027	{
1011	1028	out << "\tCALL [ file: " << args->file
1012	1029	<< " offset: " << args->offset
1013		<< " count: " << args->count
	1030	<< " count: " << args->count
1014	1031	<< " stable: " << args->stable
1015	1032	<< " ]\n";
1016	1033	}
1017		if (res)
	1034	if(res)
1018	1035	{
1019	1036	out << "\tREPLY [ status: " << res->status;
1020		if (out_all())
1021		{
1022		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1037	if(out_all())
	1038	{
	1039	if(res->status == NFS3::nfsstat3::NFS3_OK)
1023	1040	{
1024	1041	out << " file_wcc: "
1025	1042	<< res->WRITE3res_u.resok.file_wcc

1046	1063	const struct NFS3::CREATE3args* args,
1047	1064	const struct NFS3::CREATE3res* res)
1048	1065	{
1049		if (!print_procedure(out, proc)) { return; }
1050
1051		if (args)
	1066	if(!print_procedure(out, proc)) {
	1067	return;
	1068	}
	1069
	1070	if(args)
1052	1071	out << "\tCALL [ where: " << args->where
1053	1072	<< " how: " << args->how
1054	1073	<< " ]\n";
1055		if (res)
	1074	if(res)
1056	1075	{
1057	1076	out << "\tREPLY [ status: " << res->status;
1058		if (out_all())
1059		{
1060		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1077	if(out_all())
	1078	{
	1079	if(res->status == NFS3::nfsstat3::NFS3_OK)
1061	1080	out << " obj: "
1062	1081	<< res->CREATE3res_u.resok.obj
1063	1082	<< " obj attributes: "

1076	1095	const struct NFS3::MKDIR3args* args,
1077	1096	const struct NFS3::MKDIR3res* res)
1078	1097	{
1079		if (!print_procedure(out, proc)) { return; }
1080
1081		if (args)
	1098	if(!print_procedure(out, proc)) {
	1099	return;
	1100	}
	1101
	1102	if(args)
1082	1103	out << "\tCALL [ where: " << args->where
1083		<< " attributes: " << args->attributes
	1104	<< " attributes: " << args->attributes
1084	1105	<< " ]\n";
1085		if (res)
	1106	if(res)
1086	1107	{
1087	1108	out << "\tREPLY [ status: " << res->status;
1088		if (out_all())
1089		{
1090		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1109	if(out_all())
	1110	{
	1111	if(res->status == NFS3::nfsstat3::NFS3_OK)
1091	1112	out << " obj: "
1092	1113	<< res->MKDIR3res_u.resok.obj
1093	1114	<< " obj attributes: "

1106	1127	const struct NFS3::SYMLINK3args* args,
1107	1128	const struct NFS3::SYMLINK3res* res)
1108	1129	{
1109		if (!print_procedure(out, proc)) { return; }
1110
1111		if (args)
	1130	if(!print_procedure(out, proc)) {
	1131	return;
	1132	}
	1133
	1134	if(args)
1112	1135	out << "\tCALL [ where: " << args->where
1113		<< " symlink: " << args->symlink
	1136	<< " symlink: " << args->symlink
1114	1137	<< " ]\n";
1115		if (res)
	1138	if(res)
1116	1139	{
1117	1140	out << "\tREPLY [ status: " << res->status;
1118		if (out_all())
1119		{
1120		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1141	if(out_all())
	1142	{
	1143	if(res->status == NFS3::nfsstat3::NFS3_OK)
1121	1144	out << " obj: "
1122	1145	<< res->SYMLINK3res_u.resok.obj
1123	1146	<< " obj attributes: "

1136	1159	const struct NFS3::MKNOD3args* args,
1137	1160	const struct NFS3::MKNOD3res* res)
1138	1161	{
1139		if (!print_procedure(out, proc)) { return; }
1140
1141		if (args)
	1162	if(!print_procedure(out, proc)) {
	1163	return;
	1164	}
	1165
	1166	if(args)
1142	1167	{
1143	1168	out << "\tCALL [ where: " << args->where
1144		<< " what: " << args->what
	1169	<< " what: " << args->what
1145	1170	<< " ]\n";
1146	1171	}
1147		if (res)
	1172	if(res)
1148	1173	{
1149	1174	out << "\tREPLY [ status: " << res->status;
1150		if (out_all())
1151		{
1152		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1175	if(out_all())
	1176	{
	1177	if(res->status == NFS3::nfsstat3::NFS3_OK)
1153	1178	out << " obj: "
1154	1179	<< res->MKNOD3res_u.resok.obj
1155	1180	<< " obj attributes: "

1168	1193	const struct NFS3::REMOVE3args* args,
1169	1194	const struct NFS3::REMOVE3res* res)
1170	1195	{
1171		if (!print_procedure(out, proc)) { return; }
1172
1173		if (args)
	1196	if(!print_procedure(out, proc)) {
	1197	return;
	1198	}
	1199
	1200	if(args)
1174	1201	{
1175	1202	out << "\tCALL [ object: " << args->object << " ]\n";
1176	1203	}
1177		if (res)
	1204	if(res)
1178	1205	{
1179	1206	out << "\tREPLY [ status: " << res->status;
1180		if (out_all())
1181		{
1182		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1207	if(out_all())
	1208	{
	1209	if(res->status == NFS3::nfsstat3::NFS3_OK)
1183	1210	out << " dir_wcc: "
1184	1211	<< res->REMOVE3res_u.resok.dir_wcc;
1185	1212	else

1194	1221	const struct NFS3::RMDIR3args* args,
1195	1222	const struct NFS3::RMDIR3res* res)
1196	1223	{
1197		if (!print_procedure(out, proc)) { return; }
1198
1199		if (args)
	1224	if(!print_procedure(out, proc)) {
	1225	return;
	1226	}
	1227
	1228	if(args)
1200	1229	{
1201	1230	out << "\tCALL [ object: " << args->object << " ]\n";
1202	1231	}
1203		if (res)
	1232	if(res)
1204	1233	{
1205	1234	out << "\tREPLY [ status: " << res->status;
1206		if (out_all())
1207		{
1208		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1235	if(out_all())
	1236	{
	1237	if(res->status == NFS3::nfsstat3::NFS3_OK)
1209	1238	out << " dir_wcc: "
1210	1239	<< res->RMDIR3res_u.resok.dir_wcc;
1211	1240	else

1220	1249	const struct NFS3::RENAME3args* args,
1221	1250	const struct NFS3::RENAME3res* res)
1222	1251	{
1223		if (!print_procedure(out, proc)) { return; }
1224
1225		if (args)
	1252	if(!print_procedure(out, proc)) {
	1253	return;
	1254	}
	1255
	1256	if(args)
1226	1257	out << "\tCALL [ from: " << args->from
1227		<< " to: " << args->to
	1258	<< " to: " << args->to
1228	1259	<< " ]\n";
1229		if (res)
	1260	if(res)
1230	1261	{
1231	1262	out << "\tREPLY [ status: " << res->status;
1232		if (out_all())
1233		{
1234		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1263	if(out_all())
	1264	{
	1265	if(res->status == NFS3::nfsstat3::NFS3_OK)
1235	1266	out << " from dir_wcc: "
1236	1267	<< res->RENAME3res_u.resok.fromdir_wcc
1237	1268	<< " to dir_wcc: "

1250	1281	const struct NFS3::LINK3args* args,
1251	1282	const struct NFS3::LINK3res* res)
1252	1283	{
1253		if (!print_procedure(out, proc)) { return; }
1254
1255		if (args)
	1284	if(!print_procedure(out, proc)) {
	1285	return;
	1286	}
	1287
	1288	if(args)
1256	1289	out << "\tCALL [ file: " << args->file
1257		<< " link: " << args->link
	1290	<< " link: " << args->link
1258	1291	<< " ]\n";
1259		if (res)
	1292	if(res)
1260	1293	{
1261	1294	out << "\tREPLY [ status: " << res->status;
1262		if (out_all())
1263		{
1264		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1295	if(out_all())
	1296	{
	1297	if(res->status == NFS3::nfsstat3::NFS3_OK)
1265	1298	out << " file attributes: "
1266	1299	<< res->LINK3res_u.resok.file_attributes
1267	1300	<< " link dir_wcc: "

1280	1313	const struct NFS3::READDIR3args* args,
1281	1314	const struct NFS3::READDIR3res* res)
1282	1315	{
1283		if (!print_procedure(out, proc)) { return; }
1284
1285		if (args)
	1316	if(!print_procedure(out, proc)) {
	1317	return;
	1318	}
	1319
	1320	if(args)
1286	1321	{
1287	1322	out << "\tCALL [ dir: " << args->dir
1288		<< " cookie: " << args->cookie
	1323	<< " cookie: " << args->cookie
1289	1324	<< " cookieverf: ";
1290	1325	print_hex(out,
1291	1326	args->cookieverf,

1293	1328	out << " count: " << args->count
1294	1329	<< " ]\n";
1295	1330	}
1296		if (res)
	1331	if(res)
1297	1332	{
1298	1333	out << "\tREPLY [ status: " << res->status;
1299		if (out_all())
1300		{
1301		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1334	if(out_all())
	1335	{
	1336	if(res->status == NFS3::nfsstat3::NFS3_OK)
1302	1337	{
1303	1338	out << " dir attributes: "
1304	1339	<< res->READDIR3res_u.resok.dir_attributes

1323	1358	const struct NFS3::READDIRPLUS3args* args,
1324	1359	const struct NFS3::READDIRPLUS3res* res)
1325	1360	{
1326		if (!print_procedure(out, proc)) { return; }
1327
1328		if (args)
	1361	if(!print_procedure(out, proc)) {
	1362	return;
	1363	}
	1364
	1365	if(args)
1329	1366	{
1330	1367	out << "\tCALL [ dir: " << args->dir
1331		<< " cookie: " << args->cookie
	1368	<< " cookie: " << args->cookie
1332	1369	<< " cookieverf: ";
1333	1370	print_hex(out,
1334	1371	args->cookieverf,

1337	1374	<< " max count: " << args->maxcount
1338	1375	<< " ]\n";
1339	1376	}
1340		if (res)
	1377	if(res)
1341	1378	{
1342	1379	out << "\tREPLY [ status: " << res->status;
1343		if (out_all())
1344		{
1345		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1380	if(out_all())
	1381	{
	1382	if(res->status == NFS3::nfsstat3::NFS3_OK)
1346	1383	{
1347	1384	out << " dir attributes: "
1348	1385	<< res->READDIRPLUS3res_u.resok.dir_attributes

1367	1404	const struct NFS3::FSSTAT3args* args,
1368	1405	const struct NFS3::FSSTAT3res* res)
1369	1406	{
1370		if (!print_procedure(out, proc)) { return; }
1371
1372		if (args)
	1407	if(!print_procedure(out, proc)) {
	1408	return;
	1409	}
	1410
	1411	if(args)
1373	1412	{
1374	1413	out << "\tCALL [ fsroot: " << args->fsroot << " ]\n";
1375	1414	}
1376		if (res)
	1415	if(res)
1377	1416	{
1378	1417	out << "\tREPLY [ status: " << res->status;
1379		if (out_all())
1380		{
1381		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1418	if(out_all())
	1419	{
	1420	if(res->status == NFS3::nfsstat3::NFS3_OK)
1382	1421	out << " obj attributes: "
1383	1422	<< res->FSSTAT3res_u.resok.obj_attributes
1384	1423	<< " tbytes: "

1407	1446	const struct NFS3::FSINFO3args* args,
1408	1447	const struct NFS3::FSINFO3res* res)
1409	1448	{
1410		if (!print_procedure(out, proc)) { return; }
1411
1412		if (args)
	1449	if(!print_procedure(out, proc)) {
	1450	return;
	1451	}
	1452
	1453	if(args)
1413	1454	{
1414	1455	out << "\tCALL [ fsroot: " << args->fsroot << " ]\n";
1415	1456	}
1416		if (res)
	1457	if(res)
1417	1458	{
1418	1459	out << "\tREPLY [ status: " << res->status;
1419		if (out_all())
1420		{
1421		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1460	if(out_all())
	1461	{
	1462	if(res->status == NFS3::nfsstat3::NFS3_OK)
1422	1463	out << " obj attributes: "
1423	1464	<< res->FSINFO3res_u.resok.obj_attributes
1424	1465	<< " rtmax: "

1465	1506	const struct NFS3::PATHCONF3args* args,
1466	1507	const struct NFS3::PATHCONF3res* res)
1467	1508	{
1468		if (!print_procedure(out, proc)) { return; }
1469
1470		if (args)
	1509	if(!print_procedure(out, proc)) {
	1510	return;
	1511	}
	1512
	1513	if(args)
1471	1514	{
1472	1515	out << "\tCALL [ object: " << args->object << " ]\n";
1473	1516	}
1474		if (res)
	1517	if(res)
1475	1518	{
1476	1519	out << "\tREPLY [ status: " << res->status;
1477		if (out_all())
1478		{
1479		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1520	if(out_all())
	1521	{
	1522	if(res->status == NFS3::nfsstat3::NFS3_OK)
1480	1523	out << " obj attributes: "
1481	1524	<< res->PATHCONF3res_u.resok.obj_attributes
1482	1525	<< " link max: "

1503	1546	const struct NFS3::COMMIT3args* args,
1504	1547	const struct NFS3::COMMIT3res* res)
1505	1548	{
1506		if (!print_procedure(out, proc)) { return; }
1507
1508		if (args)
	1549	if(!print_procedure(out, proc)) {
	1550	return;
	1551	}
	1552
	1553	if(args)
1509	1554	out << "\tCALL [ file: " << args->file
1510		<< " offset: " << args->offset
1511		<< " count: " << args->count
	1555	<< " offset: " << args->offset
	1556	<< " count: " << args->count
1512	1557	<< " ]\n";
1513		if (res)
	1558	if(res)
1514	1559	{
1515	1560	out << "\tREPLY [ status: " << res->status;
1516		if (out_all())
1517		{
1518		if (res->status == NFS3::nfsstat3::NFS3_OK)
	1561	if(out_all())
	1562	{
	1563	if(res->status == NFS3::nfsstat3::NFS3_OK)
1519	1564	{
1520	1565	out << " file_wcc: "
1521	1566	<< res->COMMIT3res_u.resok.file_wcc

1534	1579	}
1535	1580	}
1536	1581
1537
1538	1582	// Print NFSv4 procedures
1539	1583	// 1st line - PRC information: src and dst hosts, status of RPC procedure
1540	1584	// 2nd line - <tabulation>related RPC procedure-specific arguments

1546	1590	const struct NFS4::NULL4args*,
1547	1591	const struct NFS4::NULL4res*)
1548	1592	{
1549		if (!print_procedure(out, proc)) { return; }
	1593	if(!print_procedure(out, proc)) {
	1594	return;
	1595	}
1550	1596
1551	1597	out << "\tCALL []\n\tREPLY []\n";
1552	1598	}

1555	1601	const struct NFS4::COMPOUND4args* args,
1556	1602	const struct NFS4::COMPOUND4res* res)
1557	1603	{
1558		if (!print_procedure(out, proc)) { return; }
1559
1560		const u_int* array_len {};
1561		if (args)
	1604	if(!print_procedure(out, proc)) {
	1605	return;
	1606	}
	1607
	1608	const u_int* array_len{};
	1609	if(args)
1562	1610	{
1563	1611	array_len = &args->argarray.argarray_len;
1564	1612	out << "\tCALL [ operations: " << *array_len
1565		<< " tag: " << args->tag
1566		<< " minor version: " << args->minorversion;
1567		if (*array_len)
1568		{
1569		NFS4::nfs_argop4* current_el {args->argarray.argarray_val};
1570		for (u_int i = 0; i < *array_len; i++, current_el++)
	1613	<< " tag: " << args->tag
	1614	<< " minor version: " << args->minorversion;
	1615	if(*array_len)
	1616	{
	1617	NFS4::nfs_argop4* current_el{args->argarray.argarray_val};
	1618	for(u_int i = 0; i < *array_len; i++, current_el++)
1571	1619	{
1572	1620	out << "\n\t\t[ ";
1573	1621	nfs4_operation(current_el);

1576	1624	out << " ]\n";
1577	1625	}
1578	1626	}
1579		if (res)
	1627	if(res)
1580	1628	{
1581	1629	array_len = &res->resarray.resarray_len;
1582	1630	out << "\tREPLY [ operations: " << *array_len;
1583		if (*array_len)
1584		{
1585		NFS4::nfs_resop4* current_el {res->resarray.resarray_val};
1586		for (u_int i = 0; i < *array_len; i++, current_el++)
	1631	if(*array_len)
	1632	{
	1633	NFS4::nfs_resop4* current_el{res->resarray.resarray_val};
	1634	for(u_int i = 0; i < *array_len; i++, current_el++)
1587	1635	{
1588	1636	out << "\n\t\t[ ";
1589	1637	nfs4_operation(current_el);

1596	1644
1597	1645	void PrintAnalyzer::nfs4_operation(const struct NFS4::nfs_argop4* op)
1598	1646	{
1599		if (op)
	1647	if(op)
1600	1648	{
1601	1649	out << print_nfs4_procedures(static_cast<ProcEnumNFS4::NFSProcedure>(op->argop))
1602	1650	<< '(' << op->argop << ") [ ";
1603		switch (op->argop)
	1651	switch(op->argop)
1604	1652	{
1605	1653	case NFS4::OP_ACCESS:
1606	1654	return nfs4_operation(&op->nfs_argop4_u.opaccess);

1687	1735
1688	1736	void PrintAnalyzer::nfs4_operation(const struct NFS4::nfs_resop4* op)
1689	1737	{
1690		if (op)
	1738	if(op)
1691	1739	{
1692	1740	out << print_nfs4_procedures(static_cast<ProcEnumNFS4::NFSProcedure>(op->resop))
1693	1741	<< '(' << op->resop << ") [ ";
1694		switch (op->resop)
	1742	switch(op->resop)
1695	1743	{
1696	1744	case NFS4::OP_ACCESS:
1697	1745	return nfs4_operation(&op->nfs_resop4_u.opaccess);

1778	1826
1779	1827	void PrintAnalyzer::nfs4_operation(const struct NFS4::ACCESS4args* args)
1780	1828	{
1781		if (args)
1782		{
1783		if ((args->access) & NFS4::ACCESS4_READ) { out << "READ "; }
1784		if ((args->access) & NFS4::ACCESS4_LOOKUP) { out << "LOOKUP "; }
1785		if ((args->access) & NFS4::ACCESS4_MODIFY) { out << "MODIFY "; }
1786		if ((args->access) & NFS4::ACCESS4_EXTEND) { out << "EXTEND "; }
1787		if ((args->access) & NFS4::ACCESS4_DELETE) { out << "DELETE "; }
1788		if ((args->access) & NFS4::ACCESS4_EXECUTE) { out << "EXECUTE "; }
1789		}
1790		}
1791
1792		void PrintAnalyzer::nfs4_operation(const struct NFS4::ACCESS4res* res)
1793		{
1794		if (res)
1795		{
1796		out << "status: " << res->status;
1797		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	1829	if(args)
	1830	{
	1831	if((args->access) & NFS4::ACCESS4_READ) {
	1832	out << "READ ";
	1833	}
	1834	if((args->access) & NFS4::ACCESS4_LOOKUP) {
	1835	out << "LOOKUP ";
	1836	}
	1837	if((args->access) & NFS4::ACCESS4_MODIFY) {
	1838	out << "MODIFY ";
	1839	}
	1840	if((args->access) & NFS4::ACCESS4_EXTEND) {
	1841	out << "EXTEND ";
	1842	}
	1843	if((args->access) & NFS4::ACCESS4_DELETE) {
	1844	out << "DELETE ";
	1845	}
	1846	if((args->access) & NFS4::ACCESS4_EXECUTE) {
	1847	out << "EXECUTE ";
	1848	}
	1849	}
	1850	}
	1851
	1852	void PrintAnalyzer::nfs4_operation(const struct NFS4::ACCESS4res* res)
	1853	{
	1854	if(res)
	1855	{
	1856	out << "status: " << res->status;
	1857	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
1798	1858	{
1799	1859	out << " supported: ";
1800		if ((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_READ)
	1860	if((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_READ)
1801	1861	{
1802	1862	out << "READ ";
1803	1863	}
1804		if ((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_LOOKUP)
	1864	if((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_LOOKUP)
1805	1865	{
1806	1866	out << "LOOKUP ";
1807	1867	}
1808		if ((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_MODIFY)
	1868	if((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_MODIFY)
1809	1869	{
1810	1870	out << "MODIFY ";
1811	1871	}
1812		if ((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_EXTEND)
	1872	if((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_EXTEND)
1813	1873	{
1814	1874	out << "EXTEND ";
1815	1875	}
1816		if ((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_DELETE)
	1876	if((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_DELETE)
1817	1877	{
1818	1878	out << "DELETE ";
1819	1879	}
1820		if ((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_EXECUTE)
	1880	if((res->ACCESS4res_u.resok4.supported) & NFS4::ACCESS4_EXECUTE)
1821	1881	{
1822	1882	out << "EXECUTE ";
1823	1883	}
1824	1884	out << " access: ";
1825		if ((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_READ)
	1885	if((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_READ)
1826	1886	{
1827	1887	out << "READ ";
1828	1888	}
1829		if ((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_LOOKUP)
	1889	if((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_LOOKUP)
1830	1890	{
1831	1891	out << "LOOKUP ";
1832	1892	}
1833		if ((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_MODIFY)
	1893	if((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_MODIFY)
1834	1894	{
1835	1895	out << "MODIFY ";
1836	1896	}
1837		if ((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_EXTEND)
	1897	if((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_EXTEND)
1838	1898	{
1839	1899	out << "EXTEND ";
1840	1900	}
1841		if ((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_DELETE)
	1901	if((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_DELETE)
1842	1902	{
1843	1903	out << "DELETE ";
1844	1904	}
1845		if ((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_EXECUTE)
	1905	if((res->ACCESS4res_u.resok4.access) & NFS4::ACCESS4_EXECUTE)
1846	1906	{
1847	1907	out << "EXECUTE ";
1848	1908	}

1852	1912
1853	1913	void PrintAnalyzer::nfs4_operation(const struct NFS4::CLOSE4args* args)
1854	1914	{
1855		if (args)
1856		{
1857		out << "seqid: " << std::hex << args->seqid << std::dec
	1915	if(args)
	1916	{
	1917	out << "seqid: " << std::hex << args->seqid << std::dec
1858	1918	<< " open state id:" << args->open_stateid;
1859	1919	}
1860	1920	}
1861	1921
1862		void PrintAnalyzer::nfs4_operation(const struct NFS4::CLOSE4res* res)
1863		{
1864		if (res)
1865		{
1866		out << "status: " << res->status;
1867		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	1922	void PrintAnalyzer::nfs4_operation(const struct NFS4::CLOSE4res* res)
	1923	{
	1924	if(res)
	1925	{
	1926	out << "status: " << res->status;
	1927	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
1868	1928	{
1869	1929	out << " open state id:" << res->CLOSE4res_u.open_stateid;
1870	1930	}

1873	1933
1874	1934	void PrintAnalyzer::nfs4_operation(const struct NFS4::COMMIT4args* args)
1875	1935	{
1876		if (args)
1877		{
1878		out << "offset: " << args->offset
1879		<< " count: " << args->count;
1880		}
1881		}
1882
1883		void PrintAnalyzer::nfs4_operation(const struct NFS4::COMMIT4res* res)
1884		{
1885		if (res)
1886		{
1887		out << "status: " << res->status;
1888		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	1936	if(args)
	1937	{
	1938	out << "offset: " << args->offset
	1939	<< " count: " << args->count;
	1940	}
	1941	}
	1942
	1943	void PrintAnalyzer::nfs4_operation(const struct NFS4::COMMIT4res* res)
	1944	{
	1945	if(res)
	1946	{
	1947	out << "status: " << res->status;
	1948	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
1889	1949	{
1890	1950	out << " write verifier: ";
1891	1951	print_hex(out,

1897	1957
1898	1958	void PrintAnalyzer::nfs4_operation(const struct NFS4::CREATE4args* args)
1899	1959	{
1900		if (args)
1901		{
1902		out << "object type: " << args->objtype
1903		<< " object name: " << args->objname
	1960	if(args)
	1961	{
	1962	out << "object type: " << args->objtype
	1963	<< " object name: " << args->objname
1904	1964	<< " create attributes: " << args->createattrs;
1905	1965	}
1906	1966	}
1907	1967
1908		void PrintAnalyzer::nfs4_operation(const struct NFS4::CREATE4res* res)
1909		{
1910		if (res)
1911		{
1912		out << "status: " << res->status;
1913		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	1968	void PrintAnalyzer::nfs4_operation(const struct NFS4::CREATE4res* res)
	1969	{
	1970	if(res)
	1971	{
	1972	out << "status: " << res->status;
	1973	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
1914	1974	out << res->CREATE4res_u.resok4.cinfo << ' '
1915	1975	<< res->CREATE4res_u.resok4.attrset;
1916	1976	}

1918	1978
1919	1979	void PrintAnalyzer::nfs4_operation(const struct NFS4::DELEGPURGE4args* args)
1920	1980	{
1921		if (args) { out << "client id: " << std::hex << args->clientid << std::dec; }
1922		}
1923
1924		void PrintAnalyzer::nfs4_operation(const struct NFS4::DELEGPURGE4res* res)
1925		{
1926		if (res) { out << "status: " << res->status; }
	1981	if(args) {
	1982	out << "client id: " << std::hex << args->clientid << std::dec;
	1983	}
	1984	}
	1985
	1986	void PrintAnalyzer::nfs4_operation(const struct NFS4::DELEGPURGE4res* res)
	1987	{
	1988	if(res) {
	1989	out << "status: " << res->status;
	1990	}
1927	1991	}
1928	1992
1929	1993	void PrintAnalyzer::nfs4_operation(const struct NFS4::DELEGRETURN4args* args)
1930	1994	{
1931		if (args) { out << args->deleg_stateid; }
1932		}
1933
1934		void PrintAnalyzer::nfs4_operation(const struct NFS4::DELEGRETURN4res* res)
1935		{
1936		if (res) { out << "status: " << res->status; }
	1995	if(args) {
	1996	out << args->deleg_stateid;
	1997	}
	1998	}
	1999
	2000	void PrintAnalyzer::nfs4_operation(const struct NFS4::DELEGRETURN4res* res)
	2001	{
	2002	if(res) {
	2003	out << "status: " << res->status;
	2004	}
1937	2005	}
1938	2006
1939	2007	void PrintAnalyzer::nfs4_operation(const struct NFS4::GETATTR4args* args)
1940	2008	{
1941		if (args) { out << args->attr_request; }
1942		}
1943
1944		void PrintAnalyzer::nfs4_operation(const struct NFS4::GETATTR4res* res)
1945		{
1946		if (res)
1947		{
1948		out << "status: " << res->status;
1949		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2009	if(args) {
	2010	out << args->attr_request;
	2011	}
	2012	}
	2013
	2014	void PrintAnalyzer::nfs4_operation(const struct NFS4::GETATTR4res* res)
	2015	{
	2016	if(res)
	2017	{
	2018	out << "status: " << res->status;
	2019	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
1950	2020	{
1951	2021	out << ' ' << res->GETATTR4res_u.resok4.obj_attributes;
1952	2022	}

1955	2025
1956	2026	void PrintAnalyzer::nfs4_operation(const struct NFS4::LINK4args* args)
1957	2027	{
1958		if (args) { out << "new name: " << args->newname; }
1959		}
1960
1961		void PrintAnalyzer::nfs4_operation(const struct NFS4::LINK4res* res)
1962		{
1963		if (res)
1964		{
1965		out << "status: " << res->status;
1966		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2028	if(args) {
	2029	out << "new name: " << args->newname;
	2030	}
	2031	}
	2032
	2033	void PrintAnalyzer::nfs4_operation(const struct NFS4::LINK4res* res)
	2034	{
	2035	if(res)
	2036	{
	2037	out << "status: " << res->status;
	2038	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
1967	2039	{
1968	2040	out << ' ' << res->LINK4res_u.resok4.cinfo;
1969	2041	}

1972	2044
1973	2045	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCK4args* args)
1974	2046	{
1975		if (args)
1976		{
1977		out << "lock type: " << args->locktype
1978		<< " reclaim: " << args->reclaim
1979		<< " offset: " << args->offset
1980		<< " length: " << args->length
1981		<< " locker: " << args->locker;
1982		}
1983		}
1984
1985		void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCK4res* res)
1986		{
1987		if (res)
1988		{
1989		out << "status: " << res->status;
1990		if (out_all())
1991		{
1992		switch (res->status)
	2047	if(args)
	2048	{
	2049	out << "lock type: " << args->locktype
	2050	<< " reclaim: " << args->reclaim
	2051	<< " offset: " << args->offset
	2052	<< " length: " << args->length
	2053	<< " locker: " << args->locker;
	2054	}
	2055	}
	2056
	2057	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCK4res* res)
	2058	{
	2059	if(res)
	2060	{
	2061	out << "status: " << res->status;
	2062	if(out_all())
	2063	{
	2064	switch(res->status)
1993	2065	{
1994	2066	case NFS4::nfsstat4::NFS4_OK:
1995	2067	out << " lock stat id: "
1996	2068	<< res->LOCK4res_u.resok4.lock_stateid;
1997	2069	break;
1998	2070	case NFS4::nfsstat4::NFS4ERR_DENIED:
1999		out << " offset: " << res->LOCK4res_u.denied.offset
2000		<< " length: " << res->LOCK4res_u.denied.length
	2071	out << " offset: " << res->LOCK4res_u.denied.offset
	2072	<< " length: " << res->LOCK4res_u.denied.length
2001	2073	<< " lock type: " << res->LOCK4res_u.denied.locktype
2002		<< " owner: " << res->LOCK4res_u.denied.owner;
	2074	<< " owner: " << res->LOCK4res_u.denied.owner;
2003	2075	break;
2004	2076	default:
2005	2077	break;

2010	2082
2011	2083	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCKT4args* args)
2012	2084	{
2013		if (args)
2014		{
2015		out << "lock type: " << args->locktype
2016		<< " offset: " << args->offset
2017		<< " length: " << args->length
2018		<< " owner: " << args->owner;
2019		}
2020		}
2021
2022		void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCKT4res* res)
2023		{
2024		if (res)
2025		{
2026		out << "status: " << res->status;
2027		if (out_all() && res->status == NFS4::nfsstat4::NFS4ERR_DENIED)
2028		out << " offset: " << res->LOCKT4res_u.denied.offset
2029		<< " length: " << res->LOCKT4res_u.denied.length
	2085	if(args)
	2086	{
	2087	out << "lock type: " << args->locktype
	2088	<< " offset: " << args->offset
	2089	<< " length: " << args->length
	2090	<< " owner: " << args->owner;
	2091	}
	2092	}
	2093
	2094	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCKT4res* res)
	2095	{
	2096	if(res)
	2097	{
	2098	out << "status: " << res->status;
	2099	if(out_all() && res->status == NFS4::nfsstat4::NFS4ERR_DENIED)
	2100	out << " offset: " << res->LOCKT4res_u.denied.offset
	2101	<< " length: " << res->LOCKT4res_u.denied.length
2030	2102	<< " lock type: " << res->LOCKT4res_u.denied.locktype
2031		<< " owner: " << res->LOCKT4res_u.denied.owner;
	2103	<< " owner: " << res->LOCKT4res_u.denied.owner;
2032	2104	}
2033	2105	}
2034	2106
2035	2107	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCKU4args* args)
2036	2108	{
2037		if (args)
2038		{
2039		out << "lock type: " << args->locktype
2040		<< " seqid: " << std::hex << args->seqid << std::dec
	2109	if(args)
	2110	{
	2111	out << "lock type: " << args->locktype
	2112	<< " seqid: " << std::hex << args->seqid << std::dec
2041	2113	<< " lock state id: " << args->lock_stateid
2042		<< " offset: " << args->offset
2043		<< " length: " << args->length;
2044		}
2045		}
2046
2047		void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCKU4res* res)
2048		{
2049		if (res)
2050		{
2051		out << "status: " << res->status;
2052		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2114	<< " offset: " << args->offset
	2115	<< " length: " << args->length;
	2116	}
	2117	}
	2118
	2119	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOCKU4res* res)
	2120	{
	2121	if(res)
	2122	{
	2123	out << "status: " << res->status;
	2124	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2053	2125	{
2054	2126	out << " lock state id: " << res->LOCKU4res_u.lock_stateid;
2055	2127	}

2058	2130
2059	2131	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOOKUP4args* args)
2060	2132	{
2061		if (args) { out << "object name: " << args->objname; }
2062		}
2063
2064		void PrintAnalyzer::nfs4_operation(const struct NFS4::LOOKUP4res* res)
2065		{
2066		if (res) { out << "status: " << res->status; }
	2133	if(args) {
	2134	out << "object name: " << args->objname;
	2135	}
	2136	}
	2137
	2138	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOOKUP4res* res)
	2139	{
	2140	if(res) {
	2141	out << "status: " << res->status;
	2142	}
2067	2143	}
2068	2144
2069	2145	void PrintAnalyzer::nfs4_operation(const struct NFS4::NVERIFY4args* args)
2070	2146	{
2071		if (args) { out << "object attributes: " << args->obj_attributes; }
2072		}
2073
2074		void PrintAnalyzer::nfs4_operation(const struct NFS4::NVERIFY4res* res)
2075		{
2076		if (res) { out << "status: " << res->status; }
	2147	if(args) {
	2148	out << "object attributes: " << args->obj_attributes;
	2149	}
	2150	}
	2151
	2152	void PrintAnalyzer::nfs4_operation(const struct NFS4::NVERIFY4res* res)
	2153	{
	2154	if(res) {
	2155	out << "status: " << res->status;
	2156	}
2077	2157	}
2078	2158
2079	2159	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN4args* args)
2080	2160	{
2081		static const char* const open4_share_access[4] = {"", "READ", "WRITE", "BOTH"};
	2161	static const char* const open4_share_access[4] = {"", "READ", "WRITE", "BOTH"};
2082	2162	static const char* const open4_share_deny[4] = {"NONE", "READ", "WRITE", "BOTH"};
2083	2163
2084		if (args)
2085		{
2086		out << "seqid: " << std::hex << args->seqid << std::dec
	2164	if(args)
	2165	{
	2166	out << "seqid: " << std::hex << args->seqid << std::dec
2087	2167	<< " share access: " << open4_share_access[args->share_access]
2088		<< " share deny: " << open4_share_deny[args->share_deny]
	2168	<< " share deny: " << open4_share_deny[args->share_deny]
2089	2169	<< ' ' << args->owner
2090	2170	<< ' ' << args->openhow
2091	2171	<< ' ' << args->claim;
2092	2172	}
2093	2173	}
2094	2174
2095		void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN4res* res)
2096		{
2097		if (res)
2098		{
2099		out << "status: " << res->status;
2100		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2175	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN4res* res)
	2176	{
	2177	if(res)
	2178	{
	2179	out << "status: " << res->status;
	2180	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2101	2181	out << res->OPEN4res_u.resok4.stateid
2102	2182	<< res->OPEN4res_u.resok4.cinfo
2103	2183	<< " results flags: "

2109	2189
2110	2190	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPENATTR4args* args)
2111	2191	{
2112		if (args) { out << "create directory: " << args->createdir; }
2113		}
2114
2115		void PrintAnalyzer::nfs4_operation(const struct NFS4::OPENATTR4res* res)
2116		{
2117		if (res) { out << "status: " << res->status; }
	2192	if(args) {
	2193	out << "create directory: " << args->createdir;
	2194	}
	2195	}
	2196
	2197	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPENATTR4res* res)
	2198	{
	2199	if(res) {
	2200	out << "status: " << res->status;
	2201	}
2118	2202	}
2119	2203
2120	2204	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN_CONFIRM4args* args)
2121	2205	{
2122		if (args)
2123		{
2124		out << "open state id:" << args->open_stateid
2125		<< " seqid: " << std::hex << args->seqid << std::dec;
2126		}
2127		}
2128
2129		void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN_CONFIRM4res* res)
2130		{
2131		if (res)
2132		{
2133		out << "status: " << res->status;
2134		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2206	if(args)
	2207	{
	2208	out << "open state id:" << args->open_stateid
	2209	<< " seqid: " << std::hex << args->seqid << std::dec;
	2210	}
	2211	}
	2212
	2213	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN_CONFIRM4res* res)
	2214	{
	2215	if(res)
	2216	{
	2217	out << "status: " << res->status;
	2218	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2135	2219	{
2136	2220	out << " open state id:" << res->OPEN_CONFIRM4res_u.resok4.open_stateid;
2137	2221	}

2140	2224
2141	2225	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN_DOWNGRADE4args* args)
2142	2226	{
2143		if (args)
	2227	if(args)
2144	2228	{
2145	2229	out << " open state id: " << args->open_stateid
2146		<< " seqid: " << std::hex << args->seqid << std::dec
2147		<< " share access: " << args->share_access
2148		<< " share deny: " << args->share_deny;
2149		}
2150		}
2151
2152		void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN_DOWNGRADE4res* res)
2153		{
2154		if (res)
2155		{
2156		out << "status: " << res->status;
2157		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2230	<< " seqid: " << std::hex << args->seqid << std::dec
	2231	<< " share access: " << args->share_access
	2232	<< " share deny: " << args->share_deny;
	2233	}
	2234	}
	2235
	2236	void PrintAnalyzer::nfs4_operation(const struct NFS4::OPEN_DOWNGRADE4res* res)
	2237	{
	2238	if(res)
	2239	{
	2240	out << "status: " << res->status;
	2241	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2158	2242	{
2159	2243	out << ' ' << res->OPEN_DOWNGRADE4res_u.resok4.open_stateid;
2160	2244	}

2163	2247
2164	2248	void PrintAnalyzer::nfs4_operation(const struct NFS4::PUTFH4args* args)
2165	2249	{
2166		if (args)
	2250	if(args)
2167	2251	{
2168	2252	out << "object: ";
2169	2253	print_nfs_fh(out, args->object.nfs_fh4_val, args->object.nfs_fh4_len);
2170	2254	}
2171	2255	}
2172	2256
2173		void PrintAnalyzer::nfs4_operation(const struct NFS4::PUTFH4res* res)
2174		{
2175		if (res) { out << "status: " << res->status; }
	2257	void PrintAnalyzer::nfs4_operation(const struct NFS4::PUTFH4res* res)
	2258	{
	2259	if(res) {
	2260	out << "status: " << res->status;
	2261	}
2176	2262	}
2177	2263
2178	2264	void PrintAnalyzer::nfs4_operation(const struct NFS4::READ4args* args)
2179	2265	{
2180		if (args)
	2266	if(args)
2181	2267	{
2182	2268	out << args->stateid
2183		<< " offset: " << args->offset
2184		<< " count: " << args->count;
2185		}
2186		}
2187
2188		void PrintAnalyzer::nfs4_operation(const struct NFS4::READ4res* res)
2189		{
2190		if (res)
2191		{
2192		out << "status: " << res->status;
2193		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2269	<< " offset: " << args->offset
	2270	<< " count: " << args->count;
	2271	}
	2272	}
	2273
	2274	void PrintAnalyzer::nfs4_operation(const struct NFS4::READ4res* res)
	2275	{
	2276	if(res)
	2277	{
	2278	out << "status: " << res->status;
	2279	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2194	2280	{
2195	2281	out << " eof: " << res->READ4res_u.resok4.eof;
2196		if (res->READ4res_u.resok4.data.data_len)
	2282	if(res->READ4res_u.resok4.data.data_len)
2197	2283	{
2198	2284	out << " data : " << *res->READ4res_u.resok4.data.data_val;
2199	2285	}

2203	2289
2204	2290	void PrintAnalyzer::nfs4_operation(const struct NFS4::READDIR4args* args)
2205	2291	{
2206		if (args)
2207		{
2208		out << "cookie: " << args->cookie
2209		<< " cookieverf: " << args->cookieverf
2210		<< " dir count: " << args->dircount
2211		<< " max count: " << args->maxcount
	2292	if(args)
	2293	{
	2294	out << "cookie: " << args->cookie
	2295	<< " cookieverf: " << args->cookieverf
	2296	<< " dir count: " << args->dircount
	2297	<< " max count: " << args->maxcount
2212	2298	<< " attributes request: " << args->attr_request;
2213	2299	}
2214	2300	}
2215	2301
2216		void PrintAnalyzer::nfs4_operation(const struct NFS4::READDIR4res* res)
2217		{
2218		if (res)
2219		{
2220		out << "status: " << res->status;
2221		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2302	void PrintAnalyzer::nfs4_operation(const struct NFS4::READDIR4res* res)
	2303	{
	2304	if(res)
	2305	{
	2306	out << "status: " << res->status;
	2307	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2222	2308	out << " cookie verifier: " << res->READDIR4res_u.resok4.cookieverf
2223		<< " reply: " << res->READDIR4res_u.resok4.reply;
	2309	<< " reply: " << res->READDIR4res_u.resok4.reply;
2224	2310	}
2225	2311	}
2226	2312
2227	2313	void PrintAnalyzer::nfs4_operation(const struct NFS4::REMOVE4args* args)
2228	2314	{
2229		if (args) { out << "target: " << args->target; }
2230		}
2231
2232		void PrintAnalyzer::nfs4_operation(const struct NFS4::REMOVE4res* res)
2233		{
2234		if (res)
2235		{
2236		out << "status: " << res->status;
2237		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2315	if(args) {
	2316	out << "target: " << args->target;
	2317	}
	2318	}
	2319
	2320	void PrintAnalyzer::nfs4_operation(const struct NFS4::REMOVE4res* res)
	2321	{
	2322	if(res)
	2323	{
	2324	out << "status: " << res->status;
	2325	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2238	2326	{
2239	2327	out << ' ' << res->REMOVE4res_u.resok4.cinfo;
2240	2328	}

2243	2331
2244	2332	void PrintAnalyzer::nfs4_operation(const struct NFS4::RENAME4args* args)
2245	2333	{
2246		if (args)
2247		{
2248		out << "old name: " << args->oldname
	2334	if(args)
	2335	{
	2336	out << "old name: " << args->oldname
2249	2337	<< " new name: " << args->newname;
2250	2338	}
2251	2339	}
2252	2340
2253		void PrintAnalyzer::nfs4_operation(const struct NFS4::RENAME4res* res)
2254		{
2255		if (res)
2256		{
2257		out << "status: " << res->status;
2258		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2341	void PrintAnalyzer::nfs4_operation(const struct NFS4::RENAME4res* res)
	2342	{
	2343	if(res)
	2344	{
	2345	out << "status: " << res->status;
	2346	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2259	2347	out << " source: "
2260	2348	<< res->RENAME4res_u.resok4.source_cinfo
2261	2349	<< " target: "

2265	2353
2266	2354	void PrintAnalyzer::nfs4_operation(const struct NFS4::RENEW4args* args)
2267	2355	{
2268		if (args)
	2356	if(args)
2269	2357	{
2270	2358	out << "client id: "
2271	2359	<< std::hex << args->clientid << std::dec;
2272	2360	}
2273	2361	}
2274	2362
2275		void PrintAnalyzer::nfs4_operation(const struct NFS4::RENEW4res* res)
2276		{
2277		if (res) { out << "status: " << res->status; }
	2363	void PrintAnalyzer::nfs4_operation(const struct NFS4::RENEW4res* res)
	2364	{
	2365	if(res) {
	2366	out << "status: " << res->status;
	2367	}
2278	2368	}
2279	2369
2280	2370	void PrintAnalyzer::nfs4_operation(const struct NFS4::SECINFO4args* args)
2281	2371	{
2282		if (args) { out << "name: " << args->name; }
2283		}
2284
2285		void PrintAnalyzer::nfs4_operation(const struct NFS4::SECINFO4res* res)
2286		{
2287		if (res)
2288		{
2289		out << "status: " << res->status;
2290		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2291		{
2292		if (res->SECINFO4res_u.resok4.SECINFO4resok_len)
	2372	if(args) {
	2373	out << "name: " << args->name;
	2374	}
	2375	}
	2376
	2377	void PrintAnalyzer::nfs4_operation(const struct NFS4::SECINFO4res* res)
	2378	{
	2379	if(res)
	2380	{
	2381	out << "status: " << res->status;
	2382	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2383	{
	2384	if(res->SECINFO4res_u.resok4.SECINFO4resok_len)
2293	2385	out << " data : "
2294	2386	<< *res->SECINFO4res_u.resok4.SECINFO4resok_val;
2295	2387	}

2298	2390
2299	2391	void PrintAnalyzer::nfs4_operation(const struct NFS4::SETATTR4args* args)
2300	2392	{
2301		if (args)
	2393	if(args)
2302	2394	{
2303	2395	out << "state id:" << args->stateid
2304	2396	<< ' ' << args->obj_attributes;
2305	2397	}
2306	2398	}
2307	2399
2308		void PrintAnalyzer::nfs4_operation(const struct NFS4::SETATTR4res* res)
2309		{
2310		if (res)
2311		{
2312		out << "status: " << res->status;
2313		if (out_all()) { out << ' ' << res->attrsset; }
	2400	void PrintAnalyzer::nfs4_operation(const struct NFS4::SETATTR4res* res)
	2401	{
	2402	if(res)
	2403	{
	2404	out << "status: " << res->status;
	2405	if(out_all()) {
	2406	out << ' ' << res->attrsset;
	2407	}
2314	2408	}
2315	2409	}
2316	2410
2317	2411	void PrintAnalyzer::nfs4_operation(const struct NFS4::SETCLIENTID4args* args)
2318	2412	{
2319		if (args)
	2413	if(args)
2320	2414	{
2321	2415	out << args->client
2322	2416	<< " callback: "

2326	2420	}
2327	2421	}
2328	2422
2329		void PrintAnalyzer::nfs4_operation(const struct NFS4::SETCLIENTID4res* res)
2330		{
2331		if (res)
2332		{
2333		out << "status: " << res->status;
2334		if (out_all())
2335		{
2336		switch (res->status)
	2423	void PrintAnalyzer::nfs4_operation(const struct NFS4::SETCLIENTID4res* res)
	2424	{
	2425	if(res)
	2426	{
	2427	out << "status: " << res->status;
	2428	if(out_all())
	2429	{
	2430	switch(res->status)
2337	2431	{
2338	2432	case NFS4::nfsstat4::NFS4_OK:
2339	2433	out << " client id: "

2355	2449
2356	2450	void PrintAnalyzer::nfs4_operation(const struct NFS4::SETCLIENTID_CONFIRM4args* args)
2357	2451	{
2358		if (args)
	2452	if(args)
2359	2453	{
2360	2454	out << " client id: " << std::hex << args->clientid << std::dec
2361	2455	<< " verifier: ";

2363	2457	}
2364	2458	}
2365	2459
2366		void PrintAnalyzer::nfs4_operation(const struct NFS4::SETCLIENTID_CONFIRM4res* res)
2367		{
2368		if (res) { out << "status: " << res->status; }
	2460	void PrintAnalyzer::nfs4_operation(const struct NFS4::SETCLIENTID_CONFIRM4res* res)
	2461	{
	2462	if(res) {
	2463	out << "status: " << res->status;
	2464	}
2369	2465	}
2370	2466
2371	2467	void PrintAnalyzer::nfs4_operation(const struct NFS4::VERIFY4args* args)
2372	2468	{
2373		if (args) { out << "object attributes: " << args->obj_attributes; }
2374		}
2375
2376		void PrintAnalyzer::nfs4_operation(const struct NFS4::VERIFY4res* res)
2377		{
2378		if (res) { out << "status: " << res->status; }
	2469	if(args) {
	2470	out << "object attributes: " << args->obj_attributes;
	2471	}
	2472	}
	2473
	2474	void PrintAnalyzer::nfs4_operation(const struct NFS4::VERIFY4res* res)
	2475	{
	2476	if(res) {
	2477	out << "status: " << res->status;
	2478	}
2379	2479	}
2380	2480
2381	2481	void PrintAnalyzer::nfs4_operation(const struct NFS4::WRITE4args* args)
2382	2482	{
2383		if (args)
	2483	if(args)
2384	2484	{
2385	2485	out << args->stateid
2386		<< " offset: " << args->offset
2387		<< " stable: " << args->stable
	2486	<< " offset: " << args->offset
	2487	<< " stable: " << args->stable
2388	2488	<< " data length: " << args->data.data_len;
2389	2489	}
2390	2490	}
2391	2491
2392		void PrintAnalyzer::nfs4_operation(const struct NFS4::WRITE4res* res)
2393		{
2394		if (res)
2395		{
2396		out << "status: " << res->status;
2397		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2398		{
2399		out << " count: " << res->WRITE4res_u.resok4.count
2400		<< " committed: " << res->WRITE4res_u.resok4.committed
	2492	void PrintAnalyzer::nfs4_operation(const struct NFS4::WRITE4res* res)
	2493	{
	2494	if(res)
	2495	{
	2496	out << "status: " << res->status;
	2497	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2498	{
	2499	out << " count: " << res->WRITE4res_u.resok4.count
	2500	<< " committed: " << res->WRITE4res_u.resok4.committed
2401	2501	<< " write verifier: ";
2402	2502	print_hex(out,
2403	2503	res->WRITE4res_u.resok4.writeverf,

2408	2508
2409	2509	void PrintAnalyzer::nfs4_operation(const struct NFS4::RELEASE_LOCKOWNER4args* args)
2410	2510	{
2411		if (args) { out << "lock owner: " << args->lock_owner; }
2412		}
2413
2414		void PrintAnalyzer::nfs4_operation(const struct NFS4::RELEASE_LOCKOWNER4res* res)
2415		{
2416		if (res) { out << "status: " << res->status; }
	2511	if(args) {
	2512	out << "lock owner: " << args->lock_owner;
	2513	}
	2514	}
	2515
	2516	void PrintAnalyzer::nfs4_operation(const struct NFS4::RELEASE_LOCKOWNER4res* res)
	2517	{
	2518	if(res) {
	2519	out << "status: " << res->status;
	2520	}
2417	2521	}
2418	2522
2419	2523	void PrintAnalyzer::nfs4_operation(const struct NFS4::GET_DIR_DELEGATION4args* args)
2420	2524	{
2421		if (args)
2422		out << "client id: " << args->clientid
2423		<< " notification types: " << args->notif_types
2424		<< " dir notification delay: " << args->dir_notif_delay
	2525	if(args)
	2526	out << "client id: " << args->clientid
	2527	<< " notification types: " << args->notif_types
	2528	<< " dir notification delay: " << args->dir_notif_delay
2425	2529	<< " dir entry notification delay: " << args->dir_entry_notif_delay;
2426	2530	}
2427	2531
2428		void PrintAnalyzer::nfs4_operation(const struct NFS4::GET_DIR_DELEGATION4res* res)
2429		{
2430		if (res)
2431		{
2432		out << "status: " << res->status;
2433		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2532	void PrintAnalyzer::nfs4_operation(const struct NFS4::GET_DIR_DELEGATION4res* res)
	2533	{
	2534	if(res)
	2535	{
	2536	out << "status: " << res->status;
	2537	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2434	2538	out << ' ' << res->GET_DIR_DELEGATION4res_u.resok4.stateid
2435	2539	<< " status: "
2436	2540	<< res->GET_DIR_DELEGATION4res_u.resok4.status

2445	2549
2446	2550	void PrintAnalyzer::nfs4_operation(const struct NFS4::GETFH4res* res)
2447	2551	{
2448		if (res)
2449		{
2450		out << "status: " << res->status;
2451		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2552	if(res)
	2553	{
	2554	out << "status: " << res->status;
	2555	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2452	2556	{
2453	2557	out << " object: " << res->GETFH4res_u.resok4.object;
2454	2558	}

2457	2561
2458	2562	void PrintAnalyzer::nfs4_operation(const struct NFS4::LOOKUPP4res* res)
2459	2563	{
2460		if (res) { out << "status: " << res->status; }
	2564	if(res) {
	2565	out << "status: " << res->status;
	2566	}
2461	2567	}
2462	2568
2463	2569	void PrintAnalyzer::nfs4_operation(const struct NFS4::PUTPUBFH4res* res)
2464	2570	{
2465		if (res) { out << "status: " << res->status; }
	2571	if(res) {
	2572	out << "status: " << res->status;
	2573	}
2466	2574	}
2467	2575
2468	2576	void PrintAnalyzer::nfs4_operation(const struct NFS4::PUTROOTFH4res* res)
2469	2577	{
2470		if (res) { out << "status: " << res->status; }
	2578	if(res) {
	2579	out << "status: " << res->status;
	2580	}
2471	2581	}
2472	2582
2473	2583	void PrintAnalyzer::nfs4_operation(const struct NFS4::READLINK4res* res)
2474	2584	{
2475		if (res)
2476		{
2477		out << "status: " << res->status;
2478		if (out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
	2585	if(res)
	2586	{
	2587	out << "status: " << res->status;
	2588	if(out_all() && res->status == NFS4::nfsstat4::NFS4_OK)
2479	2589	{
2480	2590	out << " link: " << res->READLINK4res_u.resok4.link;
2481	2591	}

2484	2594
2485	2595	void PrintAnalyzer::nfs4_operation(const struct NFS4::RESTOREFH4res* res)
2486	2596	{
2487		if (res) { out << "status: " << res->status; }
	2597	if(res) {
	2598	out << "status: " << res->status;
	2599	}
2488	2600	}
2489	2601
2490	2602	void PrintAnalyzer::nfs4_operation(const struct NFS4::SAVEFH4res* res)
2491	2603	{
2492		if (res) { out << "status: " << res->status; }
	2604	if(res) {
	2605	out << "status: " << res->status;
	2606	}
2493	2607	}
2494	2608
2495	2609	void PrintAnalyzer::nfs4_operation(const struct NFS4::ILLEGAL4res* res)
2496	2610	{
2497		if (res) { out << "status: " << res->status; }
	2611	if(res) {
	2612	out << "status: " << res->status;
	2613	}
2498	2614	}
2499	2615
2500	2616	// Print NFSv4.1 procedures

2504	2620	// 4th line - <tabulation>related RPC procedure-specific results
2505	2621	// 5rd line - <tabulation>related NFSv4-operations
2506	2622
2507
2508	2623	void PrintAnalyzer::compound41(const RPCProcedure* proc,
2509	2624	const struct NFS41::COMPOUND4args* args,
2510	2625	const struct NFS41::COMPOUND4res* res)
2511	2626	{
2512		if (!print_procedure(out, proc)) { return; }
2513
2514		const u_int* array_len {};
2515		if (args)
	2627	if(!print_procedure(out, proc)) {
	2628	return;
	2629	}
	2630
	2631	const u_int* array_len{};
	2632	if(args)
2516	2633	{
2517	2634	array_len = &args->argarray.argarray_len;
2518	2635	out << "\tCALL [ operations: " << *array_len
2519		<< " tag: " << args->tag
2520		<< " minor version: " << args->minorversion;
2521
2522		if (*array_len)
2523		{
2524		NFS41::nfs_argop4* current_el {args->argarray.argarray_val};
2525		for (u_int i {0}; i < *array_len; i++, current_el++)
	2636	<< " tag: " << args->tag
	2637	<< " minor version: " << args->minorversion;
	2638
	2639	if(*array_len)
	2640	{
	2641	NFS41::nfs_argop4* current_el{args->argarray.argarray_val};
	2642	for(u_int i{0}; i < *array_len; i++, current_el++)
2526	2643	{
2527	2644	out << "\n\t\t[ ";
2528	2645	nfs41_operation(current_el);

2531	2648	out << " ]\n";
2532	2649	}
2533	2650	}
2534		if (res)
	2651	if(res)
2535	2652	{
2536	2653	array_len = &res->resarray.resarray_len;
2537	2654	out << "\tREPLY [ operations: " << *array_len
2538		<< " status: " << res->status
2539		<< " tag: " << res->tag;
2540		if (*array_len)
2541		{
2542		NFS41::nfs_resop4* current_el {res->resarray.resarray_val};
2543		for (u_int i {0}; i < *array_len; i++, current_el++)
	2655	<< " status: " << res->status
	2656	<< " tag: " << res->tag;
	2657	if(*array_len)
	2658	{
	2659	NFS41::nfs_resop4* current_el{res->resarray.resarray_val};
	2660	for(u_int i{0}; i < *array_len; i++, current_el++)
2544	2661	{
2545	2662	out << "\n\t\t[ ";
2546	2663	nfs41_operation(current_el);

2553	2670
2554	2671	void PrintAnalyzer::nfs41_operation(const struct NFS41::nfs_argop4* op)
2555	2672	{
2556		if (op)
	2673	if(op)
2557	2674	{
2558	2675	out << print_nfs41_procedures(static_cast<ProcEnumNFS41::NFSProcedure>(op->argop))
2559	2676	<< '(' << op->argop << ") [ ";
2560		switch (op->argop)
	2677	switch(op->argop)
2561	2678	{
2562	2679	case NFS41::OP_ACCESS:
2563	2680	return nfs41_operation(&op->nfs_argop4_u.opaccess);

2682	2799
2683	2800	void PrintAnalyzer::nfs41_operation(const struct NFS41::nfs_resop4* op)
2684	2801	{
2685		if (op)
	2802	if(op)
2686	2803	{
2687	2804	out << print_nfs41_procedures(static_cast<ProcEnumNFS41::NFSProcedure>(op->resop))
2688	2805	<< '(' << op->resop << ") [ ";
2689		switch (op->resop)
	2806	switch(op->resop)
2690	2807	{
2691	2808	case NFS41::OP_ACCESS:
2692	2809	return nfs41_operation(&op->nfs_resop4_u.opaccess);

2811	2928
2812	2929	void PrintAnalyzer::nfs41_operation(const struct NFS41::ACCESS4args* args)
2813	2930	{
2814		if (args)
2815		{
2816		if ((args->access) & NFS41::ACCESS4_READ) { out << "READ "; }
2817		if ((args->access) & NFS41::ACCESS4_LOOKUP) { out << "LOOKUP "; }
2818		if ((args->access) & NFS41::ACCESS4_MODIFY) { out << "MODIFY "; }
2819		if ((args->access) & NFS41::ACCESS4_EXTEND) { out << "EXTEND "; }
2820		if ((args->access) & NFS41::ACCESS4_DELETE) { out << "DELETE "; }
2821		if ((args->access) & NFS41::ACCESS4_EXECUTE) { out << "EXECUTE "; }
2822		}
2823		}
2824
2825		void PrintAnalyzer::nfs41_operation(const struct NFS41::ACCESS4res* res)
2826		{
2827		if (res)
2828		{
2829		out << "status: " << res->status;
2830		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	2931	if(args)
	2932	{
	2933	if((args->access) & NFS41::ACCESS4_READ) {
	2934	out << "READ ";
	2935	}
	2936	if((args->access) & NFS41::ACCESS4_LOOKUP) {
	2937	out << "LOOKUP ";
	2938	}
	2939	if((args->access) & NFS41::ACCESS4_MODIFY) {
	2940	out << "MODIFY ";
	2941	}
	2942	if((args->access) & NFS41::ACCESS4_EXTEND) {
	2943	out << "EXTEND ";
	2944	}
	2945	if((args->access) & NFS41::ACCESS4_DELETE) {
	2946	out << "DELETE ";
	2947	}
	2948	if((args->access) & NFS41::ACCESS4_EXECUTE) {
	2949	out << "EXECUTE ";
	2950	}
	2951	}
	2952	}
	2953
	2954	void PrintAnalyzer::nfs41_operation(const struct NFS41::ACCESS4res* res)
	2955	{
	2956	if(res)
	2957	{
	2958	out << "status: " << res->status;
	2959	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
2831	2960	{
2832	2961	out << " supported: ";
2833		if ((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_READ)
	2962	if((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_READ)
2834	2963	{
2835	2964	out << "READ ";
2836	2965	}
2837		if ((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_LOOKUP)
	2966	if((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_LOOKUP)
2838	2967	{
2839	2968	out << "LOOKUP ";
2840	2969	}
2841		if ((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_MODIFY)
	2970	if((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_MODIFY)
2842	2971	{
2843	2972	out << "MODIFY ";
2844	2973	}
2845		if ((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_EXTEND)
	2974	if((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_EXTEND)
2846	2975	{
2847	2976	out << "EXTEND ";
2848	2977	}
2849		if ((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_DELETE)
	2978	if((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_DELETE)
2850	2979	{
2851	2980	out << "DELETE ";
2852	2981	}
2853		if ((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_EXECUTE)
	2982	if((res->ACCESS4res_u.resok4.supported) & NFS41::ACCESS4_EXECUTE)
2854	2983	{
2855	2984	out << "EXECUTE ";
2856	2985	}
2857	2986	out << " access: ";
2858		if ((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_READ)
	2987	if((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_READ)
2859	2988	{
2860	2989	out << "READ ";
2861	2990	}
2862		if ((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_LOOKUP)
	2991	if((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_LOOKUP)
2863	2992	{
2864	2993	out << "LOOKUP ";
2865	2994	}
2866		if ((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_MODIFY)
	2995	if((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_MODIFY)
2867	2996	{
2868	2997	out << "MODIFY ";
2869	2998	}
2870		if ((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_EXTEND)
	2999	if((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_EXTEND)
2871	3000	{
2872	3001	out << "EXTEND ";
2873	3002	}
2874		if ((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_DELETE)
	3003	if((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_DELETE)
2875	3004	{
2876	3005	out << "DELETE ";
2877	3006	}
2878		if ((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_EXECUTE)
	3007	if((res->ACCESS4res_u.resok4.access) & NFS41::ACCESS4_EXECUTE)
2879	3008	{
2880	3009	out << "EXECUTE ";
2881	3010	}

2885	3014
2886	3015	void PrintAnalyzer::nfs41_operation(const struct NFS41::CLOSE4args* args)
2887	3016	{
2888		if (args)
2889		{
2890		out << "seqid: " << std::hex << args->seqid << std::dec
	3017	if(args)
	3018	{
	3019	out << "seqid: " << std::hex << args->seqid << std::dec
2891	3020	<< " open state id:" << args->open_stateid;
2892	3021	}
2893	3022	}
2894	3023
2895		void PrintAnalyzer::nfs41_operation(const struct NFS41::CLOSE4res* res)
2896		{
2897		if (res)
2898		{
2899		out << "status: " << res->status;
2900		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3024	void PrintAnalyzer::nfs41_operation(const struct NFS41::CLOSE4res* res)
	3025	{
	3026	if(res)
	3027	{
	3028	out << "status: " << res->status;
	3029	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
2901	3030	{
2902	3031	out << " open state id:" << res->CLOSE4res_u.open_stateid;
2903	3032	}

2906	3035
2907	3036	void PrintAnalyzer::nfs41_operation(const struct NFS41::COMMIT4args* args)
2908	3037	{
2909		if (args)
2910		{
2911		out << "offset: " << args->offset
2912		<< " count: " << args->count;
2913		}
2914		}
2915
2916		void PrintAnalyzer::nfs41_operation(const struct NFS41::COMMIT4res* res)
2917		{
2918		if (res)
2919		{
2920		out << "status: " << res->status;
2921		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3038	if(args)
	3039	{
	3040	out << "offset: " << args->offset
	3041	<< " count: " << args->count;
	3042	}
	3043	}
	3044
	3045	void PrintAnalyzer::nfs41_operation(const struct NFS41::COMMIT4res* res)
	3046	{
	3047	if(res)
	3048	{
	3049	out << "status: " << res->status;
	3050	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
2922	3051	{
2923	3052	out << " write verifier: ";
2924	3053	print_hex(out,

2930	3059
2931	3060	void PrintAnalyzer::nfs41_operation(const struct NFS41::CREATE4args* args)
2932	3061	{
2933		if (args)
2934		{
2935		out << "object type: " << args->objtype
2936		<< " object name: " << args->objname
	3062	if(args)
	3063	{
	3064	out << "object type: " << args->objtype
	3065	<< " object name: " << args->objname
2937	3066	<< " create attributes: " << args->createattrs;
2938	3067	}
2939	3068	}
2940	3069
2941		void PrintAnalyzer::nfs41_operation(const struct NFS41::CREATE4res* res)
2942		{
2943		if (res)
2944		{
2945		out << "status: " << res->status;
2946		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3070	void PrintAnalyzer::nfs41_operation(const struct NFS41::CREATE4res* res)
	3071	{
	3072	if(res)
	3073	{
	3074	out << "status: " << res->status;
	3075	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
2947	3076	out << res->CREATE4res_u.resok4.cinfo << ' '
2948	3077	<< res->CREATE4res_u.resok4.attrset;
2949	3078	}

2951	3080
2952	3081	void PrintAnalyzer::nfs41_operation(const struct NFS41::DELEGPURGE4args* args)
2953	3082	{
2954		if (args) { out << "client id: " << std::hex << args->clientid << std::dec; }
2955		}
2956
2957		void PrintAnalyzer::nfs41_operation(const struct NFS41::DELEGPURGE4res* res)
2958		{
2959		if (res) { out << "status: " << res->status; }
	3083	if(args) {
	3084	out << "client id: " << std::hex << args->clientid << std::dec;
	3085	}
	3086	}
	3087
	3088	void PrintAnalyzer::nfs41_operation(const struct NFS41::DELEGPURGE4res* res)
	3089	{
	3090	if(res) {
	3091	out << "status: " << res->status;
	3092	}
2960	3093	}
2961	3094
2962	3095	void PrintAnalyzer::nfs41_operation(const struct NFS41::DELEGRETURN4args* args)
2963	3096	{
2964		if (args) { out << args->deleg_stateid; }
2965		}
2966
2967		void PrintAnalyzer::nfs41_operation(const struct NFS41::DELEGRETURN4res* res)
2968		{
2969		if (res) { out << "status: " << res->status; }
	3097	if(args) {
	3098	out << args->deleg_stateid;
	3099	}
	3100	}
	3101
	3102	void PrintAnalyzer::nfs41_operation(const struct NFS41::DELEGRETURN4res* res)
	3103	{
	3104	if(res) {
	3105	out << "status: " << res->status;
	3106	}
2970	3107	}
2971	3108
2972	3109	void PrintAnalyzer::nfs41_operation(const struct NFS41::GETATTR4args* args)
2973	3110	{
2974		if (args) { out << args->attr_request; }
2975		}
2976
2977		void PrintAnalyzer::nfs41_operation(const struct NFS41::GETATTR4res* res)
2978		{
2979		if (res)
2980		{
2981		out << "status: " << res->status;
2982		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3111	if(args) {
	3112	out << args->attr_request;
	3113	}
	3114	}
	3115
	3116	void PrintAnalyzer::nfs41_operation(const struct NFS41::GETATTR4res* res)
	3117	{
	3118	if(res)
	3119	{
	3120	out << "status: " << res->status;
	3121	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
2983	3122	{
2984	3123	out << ' ' << res->GETATTR4res_u.resok4.obj_attributes;
2985	3124	}

2988	3127
2989	3128	void PrintAnalyzer::nfs41_operation(const struct NFS41::LINK4args* args)
2990	3129	{
2991		if (args) { out << "new name: " << args->newname; }
2992		}
2993
2994		void PrintAnalyzer::nfs41_operation(const struct NFS41::LINK4res* res)
2995		{
2996		if (res)
2997		{
2998		out << "status: " << res->status;
2999		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3130	if(args) {
	3131	out << "new name: " << args->newname;
	3132	}
	3133	}
	3134
	3135	void PrintAnalyzer::nfs41_operation(const struct NFS41::LINK4res* res)
	3136	{
	3137	if(res)
	3138	{
	3139	out << "status: " << res->status;
	3140	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3000	3141	{
3001	3142	out << ' ' << res->LINK4res_u.resok4.cinfo;
3002	3143	}

3005	3146
3006	3147	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCK4args* args)
3007	3148	{
3008		if (args)
3009		{
3010		out << "lock type: " << args->locktype
3011		<< " reclaim: " << args->reclaim
3012		<< " offset: " << args->offset
3013		<< " length: " << args->length
3014		<< " locker: " << args->locker;
3015		}
3016		}
3017
3018		void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCK4res* res)
3019		{
3020		if (res)
3021		{
3022		out << "status: " << res->status;
3023		if (out_all())
3024		{
3025		switch (res->status)
	3149	if(args)
	3150	{
	3151	out << "lock type: " << args->locktype
	3152	<< " reclaim: " << args->reclaim
	3153	<< " offset: " << args->offset
	3154	<< " length: " << args->length
	3155	<< " locker: " << args->locker;
	3156	}
	3157	}
	3158
	3159	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCK4res* res)
	3160	{
	3161	if(res)
	3162	{
	3163	out << "status: " << res->status;
	3164	if(out_all())
	3165	{
	3166	switch(res->status)
3026	3167	{
3027	3168	case NFS41::nfsstat4::NFS4_OK:
3028	3169	out << " lock stat id: "
3029	3170	<< res->LOCK4res_u.resok4.lock_stateid;
3030	3171	break;
3031	3172	case NFS41::nfsstat4::NFS4ERR_DENIED:
3032		out << " offset: " << res->LOCK4res_u.denied.offset
3033		<< " length: " << res->LOCK4res_u.denied.length
	3173	out << " offset: " << res->LOCK4res_u.denied.offset
	3174	<< " length: " << res->LOCK4res_u.denied.length
3034	3175	<< " lock type: " << res->LOCK4res_u.denied.locktype
3035		<< " owner: " << res->LOCK4res_u.denied.owner;
	3176	<< " owner: " << res->LOCK4res_u.denied.owner;
3036	3177	break;
3037	3178	default:
3038	3179	break;

3043	3184
3044	3185	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCKT4args* args)
3045	3186	{
3046		if (args)
3047		{
3048		out << "lock type: " << args->locktype
3049		<< " offset: " << args->offset
3050		<< " length: " << args->length
3051		<< " owner: " << args->owner;
3052		}
3053		}
3054
3055		void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCKT4res* res)
3056		{
3057		if (res)
3058		{
3059		out << "status: " << res->status;
3060		if (out_all() && res->status == NFS41::nfsstat4::NFS4ERR_DENIED)
3061		out << " offset: " << res->LOCKT4res_u.denied.offset
3062		<< " length: " << res->LOCKT4res_u.denied.length
	3187	if(args)
	3188	{
	3189	out << "lock type: " << args->locktype
	3190	<< " offset: " << args->offset
	3191	<< " length: " << args->length
	3192	<< " owner: " << args->owner;
	3193	}
	3194	}
	3195
	3196	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCKT4res* res)
	3197	{
	3198	if(res)
	3199	{
	3200	out << "status: " << res->status;
	3201	if(out_all() && res->status == NFS41::nfsstat4::NFS4ERR_DENIED)
	3202	out << " offset: " << res->LOCKT4res_u.denied.offset
	3203	<< " length: " << res->LOCKT4res_u.denied.length
3063	3204	<< " lock type: " << res->LOCKT4res_u.denied.locktype
3064		<< " owner: " << res->LOCKT4res_u.denied.owner;
	3205	<< " owner: " << res->LOCKT4res_u.denied.owner;
3065	3206	}
3066	3207	}
3067	3208
3068	3209	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCKU4args* args)
3069	3210	{
3070		if (args)
3071		{
3072		out << "lock type: " << args->locktype
3073		<< " seqid: " << std::hex << args->seqid << std::dec
	3211	if(args)
	3212	{
	3213	out << "lock type: " << args->locktype
	3214	<< " seqid: " << std::hex << args->seqid << std::dec
3074	3215	<< " lock state id: " << args->lock_stateid
3075		<< " offset: " << args->offset
3076		<< " length: " << args->length;
3077		}
3078		}
3079
3080		void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCKU4res* res)
3081		{
3082		if (res)
3083		{
3084		out << "status: " << res->status;
3085		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3216	<< " offset: " << args->offset
	3217	<< " length: " << args->length;
	3218	}
	3219	}
	3220
	3221	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOCKU4res* res)
	3222	{
	3223	if(res)
	3224	{
	3225	out << "status: " << res->status;
	3226	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3086	3227	{
3087	3228	out << " lock state id: " << res->LOCKU4res_u.lock_stateid;
3088	3229	}

3091	3232
3092	3233	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOOKUP4args* args)
3093	3234	{
3094		if (args) { out << "object name: " << args->objname; }
3095		}
3096
3097		void PrintAnalyzer::nfs41_operation(const struct NFS41::LOOKUP4res* res)
3098		{
3099		if (res) { out << "status: " << res->status; }
	3235	if(args) {
	3236	out << "object name: " << args->objname;
	3237	}
	3238	}
	3239
	3240	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOOKUP4res* res)
	3241	{
	3242	if(res) {
	3243	out << "status: " << res->status;
	3244	}
3100	3245	}
3101	3246
3102	3247	void PrintAnalyzer::nfs41_operation(const struct NFS41::NVERIFY4args* args)
3103	3248	{
3104		if (args) { out << "object attributes: " << args->obj_attributes; }
3105		}
3106
3107		void PrintAnalyzer::nfs41_operation(const struct NFS41::NVERIFY4res* res)
3108		{
3109		if (res) { out << "status: " << res->status; }
	3249	if(args) {
	3250	out << "object attributes: " << args->obj_attributes;
	3251	}
	3252	}
	3253
	3254	void PrintAnalyzer::nfs41_operation(const struct NFS41::NVERIFY4res* res)
	3255	{
	3256	if(res) {
	3257	out << "status: " << res->status;
	3258	}
3110	3259	}
3111	3260
3112	3261	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN4args* args)
3113	3262	{
3114		static const char* const open4_share_access[4] = {"", "READ", "WRITE", "BOTH"};
	3263	static const char* const open4_share_access[4] = {"", "READ", "WRITE", "BOTH"};
3115	3264	static const char* const open4_share_deny[4] = {"NONE", "READ", "WRITE", "BOTH"};
3116	3265
3117		if (args)
3118		{
3119		out << "seqid: " << std::hex << args->seqid << std::dec
	3266	if(args)
	3267	{
	3268	out << "seqid: " << std::hex << args->seqid << std::dec
3120	3269	<< " share access: " << open4_share_access[args->share_access]
3121		<< " share deny: " << open4_share_deny[args->share_deny]
	3270	<< " share deny: " << open4_share_deny[args->share_deny]
3122	3271	<< ' ' << args->owner
3123	3272	<< ' ' << args->openhow
3124	3273	<< ' ' << args->claim;
3125	3274	}
3126	3275	}
3127	3276
3128		void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN4res* res)
3129		{
3130		if (res)
3131		{
3132		out << "status: " << res->status;
3133		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3277	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN4res* res)
	3278	{
	3279	if(res)
	3280	{
	3281	out << "status: " << res->status;
	3282	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3134	3283	out << res->OPEN4res_u.resok4.stateid
3135	3284	<< res->OPEN4res_u.resok4.cinfo
3136	3285	<< " results flags: "

3142	3291
3143	3292	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPENATTR4args* args)
3144	3293	{
3145		if (args) { out << "create directory: " << args->createdir; }
3146		}
3147
3148		void PrintAnalyzer::nfs41_operation(const struct NFS41::OPENATTR4res* res)
3149		{
3150		if (res) { out << "status: " << res->status; }
	3294	if(args) {
	3295	out << "create directory: " << args->createdir;
	3296	}
	3297	}
	3298
	3299	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPENATTR4res* res)
	3300	{
	3301	if(res) {
	3302	out << "status: " << res->status;
	3303	}
3151	3304	}
3152	3305
3153	3306	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN_CONFIRM4args* args)
3154	3307	{
3155		if (args)
3156		{
3157		out << "open state id:" << args->open_stateid
3158		<< " seqid: " << std::hex << args->seqid << std::dec;
3159		}
3160		}
3161
3162		void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN_CONFIRM4res* res)
3163		{
3164		if (res)
3165		{
3166		out << "status: " << res->status;
3167		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3308	if(args)
	3309	{
	3310	out << "open state id:" << args->open_stateid
	3311	<< " seqid: " << std::hex << args->seqid << std::dec;
	3312	}
	3313	}
	3314
	3315	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN_CONFIRM4res* res)
	3316	{
	3317	if(res)
	3318	{
	3319	out << "status: " << res->status;
	3320	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3168	3321	{
3169	3322	out << " open state id:" << res->OPEN_CONFIRM4res_u.resok4.open_stateid;
3170	3323	}

3173	3326
3174	3327	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN_DOWNGRADE4args* args)
3175	3328	{
3176		if (args)
	3329	if(args)
3177	3330	{
3178	3331	out << " open state id: " << args->open_stateid
3179		<< " seqid: " << std::hex << args->seqid << std::dec
3180		<< " share access: " << args->share_access
3181		<< " share deny: " << args->share_deny;
3182		}
3183		}
3184
3185		void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN_DOWNGRADE4res* res)
3186		{
3187		if (res)
3188		{
3189		out << "status: " << res->status;
3190		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3332	<< " seqid: " << std::hex << args->seqid << std::dec
	3333	<< " share access: " << args->share_access
	3334	<< " share deny: " << args->share_deny;
	3335	}
	3336	}
	3337
	3338	void PrintAnalyzer::nfs41_operation(const struct NFS41::OPEN_DOWNGRADE4res* res)
	3339	{
	3340	if(res)
	3341	{
	3342	out << "status: " << res->status;
	3343	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3191	3344	{
3192	3345	out << ' ' << res->OPEN_DOWNGRADE4res_u.resok4.open_stateid;
3193	3346	}

3196	3349
3197	3350	void PrintAnalyzer::nfs41_operation(const struct NFS41::PUTFH4args* args)
3198	3351	{
3199		if (args)
	3352	if(args)
3200	3353	{
3201	3354	out << "object: ";
3202	3355	print_nfs_fh(out, args->object.nfs_fh4_val, args->object.nfs_fh4_len);
3203	3356	}
3204	3357	}
3205	3358
3206		void PrintAnalyzer::nfs41_operation(const struct NFS41::PUTFH4res* res)
3207		{
3208		if (res) { out << "status: " << res->status; }
	3359	void PrintAnalyzer::nfs41_operation(const struct NFS41::PUTFH4res* res)
	3360	{
	3361	if(res) {
	3362	out << "status: " << res->status;
	3363	}
3209	3364	}
3210	3365
3211	3366	void PrintAnalyzer::nfs41_operation(const struct NFS41::READ4args* args)
3212	3367	{
3213		if (args)
	3368	if(args)
3214	3369	{
3215	3370	out << args->stateid
3216		<< " offset: " << args->offset
3217		<< " count: " << args->count;
3218		}
3219		}
3220
3221		void PrintAnalyzer::nfs41_operation(const struct NFS41::READ4res* res)
3222		{
3223		if (res)
3224		{
3225		out << "status: " << res->status;
3226		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3371	<< " offset: " << args->offset
	3372	<< " count: " << args->count;
	3373	}
	3374	}
	3375
	3376	void PrintAnalyzer::nfs41_operation(const struct NFS41::READ4res* res)
	3377	{
	3378	if(res)
	3379	{
	3380	out << "status: " << res->status;
	3381	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3227	3382	{
3228	3383	out << " eof: " << res->READ4res_u.resok4.eof;
3229		if (res->READ4res_u.resok4.data.data_len)
	3384	if(res->READ4res_u.resok4.data.data_len)
3230	3385	{
3231	3386	out << " data: " << *res->READ4res_u.resok4.data.data_val;
3232	3387	}

3236	3391
3237	3392	void PrintAnalyzer::nfs41_operation(const struct NFS41::READDIR4args* args)
3238	3393	{
3239		if (args)
3240		{
3241		out << "cookie: " << args->cookie
3242		<< " cookieverf: " << args->cookieverf
3243		<< " dir count: " << args->dircount
3244		<< " max count: " << args->maxcount
	3394	if(args)
	3395	{
	3396	out << "cookie: " << args->cookie
	3397	<< " cookieverf: " << args->cookieverf
	3398	<< " dir count: " << args->dircount
	3399	<< " max count: " << args->maxcount
3245	3400	<< " attributes request: " << args->attr_request;
3246	3401	}
3247	3402	}
3248	3403
3249		void PrintAnalyzer::nfs41_operation(const struct NFS41::READDIR4res* res)
3250		{
3251		if (res)
3252		{
3253		out << "status: " << res->status;
3254		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3404	void PrintAnalyzer::nfs41_operation(const struct NFS41::READDIR4res* res)
	3405	{
	3406	if(res)
	3407	{
	3408	out << "status: " << res->status;
	3409	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3255	3410	out << " cookie verifier: " << res->READDIR4res_u.resok4.cookieverf
3256		<< " reply: " << res->READDIR4res_u.resok4.reply;
	3411	<< " reply: " << res->READDIR4res_u.resok4.reply;
3257	3412	}
3258	3413	}
3259	3414
3260	3415	void PrintAnalyzer::nfs41_operation(const struct NFS41::REMOVE4args* args)
3261	3416	{
3262		if (args) { out << "target: " << args->target; }
3263		}
3264
3265		void PrintAnalyzer::nfs41_operation(const struct NFS41::REMOVE4res* res)
3266		{
3267		if (res)
3268		{
3269		out << "status: " << res->status;
3270		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3417	if(args) {
	3418	out << "target: " << args->target;
	3419	}
	3420	}
	3421
	3422	void PrintAnalyzer::nfs41_operation(const struct NFS41::REMOVE4res* res)
	3423	{
	3424	if(res)
	3425	{
	3426	out << "status: " << res->status;
	3427	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3271	3428	{
3272	3429	out << ' ' << res->REMOVE4res_u.resok4.cinfo;
3273	3430	}

3276	3433
3277	3434	void PrintAnalyzer::nfs41_operation(const struct NFS41::RENAME4args* args)
3278	3435	{
3279		if (args)
3280		{
3281		out << "old name: " << args->oldname
	3436	if(args)
	3437	{
	3438	out << "old name: " << args->oldname
3282	3439	<< " new name: " << args->newname;
3283	3440	}
3284	3441	}
3285	3442
3286		void PrintAnalyzer::nfs41_operation(const struct NFS41::RENAME4res* res)
3287		{
3288		if (res)
3289		{
3290		out << "status: " << res->status;
3291		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3443	void PrintAnalyzer::nfs41_operation(const struct NFS41::RENAME4res* res)
	3444	{
	3445	if(res)
	3446	{
	3447	out << "status: " << res->status;
	3448	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3292	3449	out << " source: "
3293	3450	<< res->RENAME4res_u.resok4.source_cinfo
3294	3451	<< " target: "

3298	3455
3299	3456	void PrintAnalyzer::nfs41_operation(const struct NFS41::RENEW4args* args)
3300	3457	{
3301		if (args)
	3458	if(args)
3302	3459	{
3303	3460	out << "client id: "
3304	3461	<< std::hex << args->clientid << std::dec;
3305	3462	}
3306	3463	}
3307	3464
3308		void PrintAnalyzer::nfs41_operation(const struct NFS41::RENEW4res* res)
3309		{
3310		if (res) { out << "status: " << res->status; }
	3465	void PrintAnalyzer::nfs41_operation(const struct NFS41::RENEW4res* res)
	3466	{
	3467	if(res) {
	3468	out << "status: " << res->status;
	3469	}
3311	3470	}
3312	3471
3313	3472	void PrintAnalyzer::nfs41_operation(const struct NFS41::SECINFO4args* args)
3314	3473	{
3315		if (args) { out << "name: " << args->name; }
3316		}
3317
3318		void PrintAnalyzer::nfs41_operation(const struct NFS41::SECINFO4res* res)
3319		{
3320		if (res)
3321		{
3322		out << "status: " << res->status;
3323		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3324		{
3325		if (res->SECINFO4res_u.resok4.SECINFO4resok_len)
	3474	if(args) {
	3475	out << "name: " << args->name;
	3476	}
	3477	}
	3478
	3479	void PrintAnalyzer::nfs41_operation(const struct NFS41::SECINFO4res* res)
	3480	{
	3481	if(res)
	3482	{
	3483	out << "status: " << res->status;
	3484	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3485	{
	3486	if(res->SECINFO4res_u.resok4.SECINFO4resok_len)
3326	3487	{
3327	3488	out << *res->SECINFO4res_u.resok4.SECINFO4resok_val;
3328	3489	}

3332	3493
3333	3494	void PrintAnalyzer::nfs41_operation(const struct NFS41::SETATTR4args* args)
3334	3495	{
3335		if (args)
	3496	if(args)
3336	3497	{
3337	3498	out << "state id:" << args->stateid
3338	3499	<< ' ' << args->obj_attributes;
3339	3500	}
3340	3501	}
3341	3502
3342		void PrintAnalyzer::nfs41_operation(const struct NFS41::SETATTR4res* res)
3343		{
3344		if (res)
3345		{
3346		out << "status: " << res->status;
3347		if (out_all()) { out << ' ' << res->attrsset; }
	3503	void PrintAnalyzer::nfs41_operation(const struct NFS41::SETATTR4res* res)
	3504	{
	3505	if(res)
	3506	{
	3507	out << "status: " << res->status;
	3508	if(out_all()) {
	3509	out << ' ' << res->attrsset;
	3510	}
3348	3511	}
3349	3512	}
3350	3513
3351	3514	void PrintAnalyzer::nfs41_operation(const struct NFS41::SETCLIENTID4args* args)
3352	3515	{
3353		if (args)
	3516	if(args)
3354	3517	{
3355	3518	out << args->client
3356	3519	<< " callback: "

3360	3523	}
3361	3524	}
3362	3525
3363		void PrintAnalyzer::nfs41_operation(const struct NFS41::SETCLIENTID4res* res)
3364		{
3365		if (res)
3366		{
3367		out << "status: " << res->status;
3368		if (out_all())
3369		{
3370		switch (res->status)
	3526	void PrintAnalyzer::nfs41_operation(const struct NFS41::SETCLIENTID4res* res)
	3527	{
	3528	if(res)
	3529	{
	3530	out << "status: " << res->status;
	3531	if(out_all())
	3532	{
	3533	switch(res->status)
3371	3534	{
3372	3535	case NFS41::nfsstat4::NFS4_OK:
3373	3536	out << " client id: "

3389	3552
3390	3553	void PrintAnalyzer::nfs41_operation(const struct NFS41::SETCLIENTID_CONFIRM4args* args)
3391	3554	{
3392		if (args)
	3555	if(args)
3393	3556	{
3394	3557	out << " client id: " << std::hex << args->clientid << std::dec
3395	3558	<< " verifier: ";

3397	3560	}
3398	3561	}
3399	3562
3400		void PrintAnalyzer::nfs41_operation(const struct NFS41::SETCLIENTID_CONFIRM4res* res)
3401		{
3402		if (res) { out << "status: " << res->status; }
	3563	void PrintAnalyzer::nfs41_operation(const struct NFS41::SETCLIENTID_CONFIRM4res* res)
	3564	{
	3565	if(res) {
	3566	out << "status: " << res->status;
	3567	}
3403	3568	}
3404	3569
3405	3570	void PrintAnalyzer::nfs41_operation(const struct NFS41::VERIFY4args* args)
3406	3571	{
3407		if (args) { out << "object attributes: " << args->obj_attributes; }
3408		}
3409
3410		void PrintAnalyzer::nfs41_operation(const struct NFS41::VERIFY4res* res)
3411		{
3412		if (res) { out << "status: " << res->status; }
	3572	if(args) {
	3573	out << "object attributes: " << args->obj_attributes;
	3574	}
	3575	}
	3576
	3577	void PrintAnalyzer::nfs41_operation(const struct NFS41::VERIFY4res* res)
	3578	{
	3579	if(res) {
	3580	out << "status: " << res->status;
	3581	}
3413	3582	}
3414	3583
3415	3584	void PrintAnalyzer::nfs41_operation(const struct NFS41::WRITE4args* args)
3416	3585	{
3417		if (args)
	3586	if(args)
3418	3587	{
3419	3588	out << args->stateid
3420		<< " offset: " << args->offset
3421		<< " stable: " << args->stable
	3589	<< " offset: " << args->offset
	3590	<< " stable: " << args->stable
3422	3591	<< " data length: " << args->data.data_len;
3423	3592	}
3424	3593	}
3425	3594
3426		void PrintAnalyzer::nfs41_operation(const struct NFS41::WRITE4res* res)
3427		{
3428		if (res)
3429		{
3430		out << "status: " << res->status;
3431		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3432		{
3433		out << " count: " << res->WRITE4res_u.resok4.count
3434		<< " committed: " << res->WRITE4res_u.resok4.committed
	3595	void PrintAnalyzer::nfs41_operation(const struct NFS41::WRITE4res* res)
	3596	{
	3597	if(res)
	3598	{
	3599	out << "status: " << res->status;
	3600	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3601	{
	3602	out << " count: " << res->WRITE4res_u.resok4.count
	3603	<< " committed: " << res->WRITE4res_u.resok4.committed
3435	3604	<< " write verifier: ";
3436	3605	print_hex(out,
3437	3606	res->WRITE4res_u.resok4.writeverf,

3442	3611
3443	3612	void PrintAnalyzer::nfs41_operation(const struct NFS41::RELEASE_LOCKOWNER4args* args)
3444	3613	{
3445		if (args) { out << "lock owner: " << args->lock_owner; }
3446		}
3447
3448		void PrintAnalyzer::nfs41_operation(const struct NFS41::RELEASE_LOCKOWNER4res* res)
3449		{
3450		if (res) { out << "status: " << res->status; }
	3614	if(args) {
	3615	out << "lock owner: " << args->lock_owner;
	3616	}
	3617	}
	3618
	3619	void PrintAnalyzer::nfs41_operation(const struct NFS41::RELEASE_LOCKOWNER4res* res)
	3620	{
	3621	if(res) {
	3622	out << "status: " << res->status;
	3623	}
3451	3624	}
3452	3625
3453	3626	void PrintAnalyzer::nfs41_operation(const struct NFS41::GETFH4res* res)
3454	3627	{
3455		if (res)
3456		{
3457		out << "status: " << res->status;
3458		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3628	if(res)
	3629	{
	3630	out << "status: " << res->status;
	3631	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3459	3632	{
3460	3633	out << " object: " << res->GETFH4res_u.resok4.object;
3461	3634	}

3464	3637
3465	3638	void PrintAnalyzer::nfs41_operation(const struct NFS41::LOOKUPP4res* res)
3466	3639	{
3467		if (res) { out << "status: " << res->status; }
	3640	if(res) {
	3641	out << "status: " << res->status;
	3642	}
3468	3643	}
3469	3644
3470	3645	void PrintAnalyzer::nfs41_operation(const struct NFS41::PUTPUBFH4res* res)
3471	3646	{
3472		if (res) { out << "status: " << res->status; }
	3647	if(res) {
	3648	out << "status: " << res->status;
	3649	}
3473	3650	}
3474	3651
3475	3652	void PrintAnalyzer::nfs41_operation(const struct NFS41::PUTROOTFH4res* res)
3476	3653	{
3477		if (res) { out << "status: " << res->status; }
	3654	if(res) {
	3655	out << "status: " << res->status;
	3656	}
3478	3657	}
3479	3658
3480	3659	void PrintAnalyzer::nfs41_operation(const struct NFS41::READLINK4res* res)
3481	3660	{
3482		if (res)
3483		{
3484		out << "status: " << res->status;
3485		if (out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
	3661	if(res)
	3662	{
	3663	out << "status: " << res->status;
	3664	if(out_all() && res->status == NFS41::nfsstat4::NFS4_OK)
3486	3665	{
3487	3666	out << " link: " << res->READLINK4res_u.resok4.link;
3488	3667	}

3491	3670
3492	3671	void PrintAnalyzer::nfs41_operation(const struct NFS41::RESTOREFH4res* res)
3493	3672	{
3494		if (res) { out << "status: " << res->status; }
	3673	if(res) {
	3674	out << "status: " << res->status;
	3675	}
3495	3676	}
3496	3677
3497	3678	void PrintAnalyzer::nfs41_operation(const struct NFS41::SAVEFH4res* res)
3498	3679	{
3499		if (res) { out << "status: " << res->status; }
	3680	if(res) {
	3681	out << "status: " << res->status;
	3682	}
3500	3683	}
3501	3684
3502	3685	void PrintAnalyzer::nfs41_operation(const struct NFS41::GET_DIR_DELEGATION4args* args)
3503	3686	{
3504		if (args)
3505		out << "signal delegation available: " << args->gdda_signal_deleg_avail
3506		<< " notification types: " << args->gdda_notification_types
3507		<< " child attr delay: " << args->gdda_child_attr_delay
3508		<< " dir attr delay: " << args->gdda_dir_attr_delay
3509		<< " child child attributes: " << args->gdda_child_attributes
3510		<< " child dir attributes: " << args->gdda_dir_attributes;
3511		}
3512
3513		void PrintAnalyzer::nfs41_operation(const struct NFS41::GET_DIR_DELEGATION4res* res)
3514		{
3515		if (res)
	3687	if(args)
	3688	out << "signal delegation available: " << args->gdda_signal_deleg_avail
	3689	<< " notification types: " << args->gdda_notification_types
	3690	<< " child attr delay: " << args->gdda_child_attr_delay
	3691	<< " dir attr delay: " << args->gdda_dir_attr_delay
	3692	<< " child child attributes: " << args->gdda_child_attributes
	3693	<< " child dir attributes: " << args->gdda_dir_attributes;
	3694	}
	3695
	3696	void PrintAnalyzer::nfs41_operation(const struct NFS41::GET_DIR_DELEGATION4res* res)
	3697	{
	3698	if(res)
3516	3699	{
3517	3700	out << "status: " << res->gddr_status;
3518		if (out_all() && res->gddr_status == NFS41::nfsstat4::NFS4_OK)
	3701	if(out_all() && res->gddr_status == NFS41::nfsstat4::NFS4_OK)
3519	3702	{
3520	3703	out << " status: " << res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.gddrnf_status;
3521		if (out_all() && res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.gddrnf_status == NFS41::gddrnf4_status::GDD4_OK)
3522		{
3523		out << " cookieverf: ";
	3704	if(out_all() && res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.gddrnf_status == NFS41::gddrnf4_status::GDD4_OK)
	3705	{
	3706	out << " cookieverf: ";
3524	3707	print_hex(out,
3525	3708	res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_cookieverf,
3526	3709	NFS41::NFS4_VERIFIER_SIZE);
3527	3710	out << " stateid: "
3528		<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_stateid
	3711	<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_stateid
3529	3712	<< " notification: "
3530		<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_notification
	3713	<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_notification
3531	3714	<< " child attributes: "
3532		<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_child_attributes
	3715	<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_child_attributes
3533	3716	<< " dir attributes: "
3534		<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_dir_attributes;
	3717	<< res->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4.GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4.gddr_dir_attributes;
3535	3718	}
3536	3719	else
3537	3720	{

3544	3727
3545	3728	void PrintAnalyzer::nfs41_operation(const struct NFS41::BACKCHANNEL_CTL4args* args)
3546	3729	{
3547		if (args)
3548		{
3549		out << "program: " << args->bca_cb_program
	3730	if(args)
	3731	{
	3732	out << "program: " << args->bca_cb_program
3550	3733	<< " sec parms: ";
3551		NFS41::callback_sec_parms4* current_el {args->bca_sec_parms.bca_sec_parms_val};
3552		for (u_int i {0}; i < args->bca_sec_parms.bca_sec_parms_len; i++, current_el++)
	3734	NFS41::callback_sec_parms4* current_el{args->bca_sec_parms.bca_sec_parms_val};
	3735	for(u_int i{0}; i < args->bca_sec_parms.bca_sec_parms_len; i++, current_el++)
3553	3736	{
3554	3737	out << ' ' << current_el;
3555	3738	}

3558	3741
3559	3742	void PrintAnalyzer::nfs41_operation(const struct NFS41::BACKCHANNEL_CTL4res* res)
3560	3743	{
3561		if (res) { out << "status: " << res->bcr_status; }
	3744	if(res) {
	3745	out << "status: " << res->bcr_status;
	3746	}
3562	3747	}
3563	3748
3564	3749	void PrintAnalyzer::nfs41_operation(const struct NFS41::BIND_CONN_TO_SESSION4args* args)
3565	3750	{
3566		if (args)
3567		{
3568		out << "sessid: ";
	3751	if(args)
	3752	{
	3753	out << "sessid: ";
3569	3754	print_hex(out,
3570	3755	args->bctsa_sessid,
3571	3756	NFS41::NFS4_SESSIONID_SIZE);
3572		out << " dir: " << args->bctsa_dir
	3757	out << " dir: " << args->bctsa_dir
3573	3758	<< " use conn in rdma mode: " << args->bctsa_use_conn_in_rdma_mode;
3574	3759	}
3575	3760	}
3576	3761
3577	3762	void PrintAnalyzer::nfs41_operation(const struct NFS41::BIND_CONN_TO_SESSION4res* res)
3578	3763	{
3579		if (res)
	3764	if(res)
3580	3765	{
3581	3766	out << "status: " << res->bctsr_status;
3582		if (out_all() && res->bctsr_status == NFS41::nfsstat4::NFS4_OK)
	3767	if(out_all() && res->bctsr_status == NFS41::nfsstat4::NFS4_OK)
3583	3768	{
3584	3769	out << " sessid: ";
3585	3770	print_hex(out,

3595	3780
3596	3781	void PrintAnalyzer::nfs41_operation(const struct NFS41::EXCHANGE_ID4args* args)
3597	3782	{
3598		if (args)
3599		{
3600		out << "client owner: " << args->eia_clientowner
3601		<< " flags: " << args->eia_flags
	3783	if(args)
	3784	{
	3785	out << "client owner: " << args->eia_clientowner
	3786	<< " flags: " << args->eia_flags
3602	3787	<< " state protect: " << args->eia_state_protect
3603	3788	<< " client impl id: ";
3604		NFS41::nfs_impl_id4* current_el {args->eia_client_impl_id.eia_client_impl_id_val};
3605		for (u_int i {0}; i < args->eia_client_impl_id.eia_client_impl_id_len; i++, current_el++)
	3789	NFS41::nfs_impl_id4* current_el{args->eia_client_impl_id.eia_client_impl_id_val};
	3790	for(u_int i{0}; i < args->eia_client_impl_id.eia_client_impl_id_len; i++, current_el++)
3606	3791	{
3607	3792	out << ' ' << current_el;
3608	3793	}

3611	3796
3612	3797	void PrintAnalyzer::nfs41_operation(const struct NFS41::EXCHANGE_ID4res* res)
3613	3798	{
3614		if (res)
	3799	if(res)
3615	3800	{
3616	3801	out << "status: " << res->eir_status;
3617		if (out_all() && res->eir_status == NFS41::nfsstat4::NFS4_OK)
3618		{
3619		out << " clientid: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_clientid
	3802	if(out_all() && res->eir_status == NFS41::nfsstat4::NFS4_OK)
	3803	{
	3804	out << " clientid: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_clientid
3620	3805	<< " sequenceid: 0x" << std::hex << res->EXCHANGE_ID4res_u.eir_resok4.eir_sequenceid << std::dec
3621		<< " flags: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_flags
3622		<< " state protect: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_state_protect
3623		<< " server owner: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_server_owner
	3806	<< " flags: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_flags
	3807	<< " state protect: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_state_protect
	3808	<< " server owner: " << res->EXCHANGE_ID4res_u.eir_resok4.eir_server_owner
3624	3809	<< " server scope: ";
3625	3810	print_hex(out,
3626	3811	res->EXCHANGE_ID4res_u.eir_resok4.eir_server_scope.eir_server_scope_val,
3627	3812	res->EXCHANGE_ID4res_u.eir_resok4.eir_server_scope.eir_server_scope_len);
3628	3813	out << " server impl id:";
3629		NFS41::nfs_impl_id4* current_el {res->EXCHANGE_ID4res_u.eir_resok4.eir_server_impl_id.eir_server_impl_id_val};
3630		for (u_int i {0}; i < res->EXCHANGE_ID4res_u.eir_resok4.eir_server_impl_id.eir_server_impl_id_len; i++, current_el++)
	3814	NFS41::nfs_impl_id4* current_el{res->EXCHANGE_ID4res_u.eir_resok4.eir_server_impl_id.eir_server_impl_id_val};
	3815	for(u_int i{0}; i < res->EXCHANGE_ID4res_u.eir_resok4.eir_server_impl_id.eir_server_impl_id_len; i++, current_el++)
3631	3816	{
3632	3817	out << ' ' << current_el;
3633	3818	}

3637	3822
3638	3823	void PrintAnalyzer::nfs41_operation(const struct NFS41::CREATE_SESSION4args* args)
3639	3824	{
3640		if (args)
3641		{
3642		out << "clientid: 0x" << std::hex << args->csa_clientid
3643		<< "; seqid: 0x" << std::hex << args->csa_sequence << std::dec
3644		<< "; flags: " << args->csa_flags
3645		<< "; fore chan attrs: [ " << args->csa_fore_chan_attrs << " ] "
3646		<< "; fore back attrs: [ " << args->csa_back_chan_attrs << " ] "
3647		<< "; cb program: 0x" << std::hex << args->csa_cb_program << std::dec
	3825	if(args)
	3826	{
	3827	out << "clientid: 0x" << std::hex << args->csa_clientid
	3828	<< "; seqid: 0x" << std::hex << args->csa_sequence << std::dec
	3829	<< "; flags: " << args->csa_flags
	3830	<< "; fore chan attrs: [ " << args->csa_fore_chan_attrs << " ] "
	3831	<< "; fore back attrs: [ " << args->csa_back_chan_attrs << " ] "
	3832	<< "; cb program: 0x" << std::hex << args->csa_cb_program << std::dec
3648	3833	<< "; callback sec parms:";
3649		NFS41::callback_sec_parms4* current_el {args->csa_sec_parms.csa_sec_parms_val};
3650		for (u_int i {0}; i < args->csa_sec_parms.csa_sec_parms_len; i++, current_el++)
	3834	NFS41::callback_sec_parms4* current_el{args->csa_sec_parms.csa_sec_parms_val};
	3835	for(u_int i{0}; i < args->csa_sec_parms.csa_sec_parms_len; i++, current_el++)
3651	3836	{
3652	3837	out << ' ' << current_el;
3653	3838	}

3656	3841
3657	3842	void PrintAnalyzer::nfs41_operation(const struct NFS41::CREATE_SESSION4res* res)
3658	3843	{
3659		if (res)
	3844	if(res)
3660	3845	{
3661	3846	out << "status: " << res->csr_status;
3662		if (out_all() && res->csr_status == NFS41::nfsstat4::NFS4_OK)
	3847	if(out_all() && res->csr_status == NFS41::nfsstat4::NFS4_OK)
3663	3848	{
3664	3849	out << " session id: ";
3665	3850	print_hex(out,
3666	3851	res->CREATE_SESSION4res_u.csr_resok4.csr_sessionid,
3667	3852	NFS41::NFS4_SESSIONID_SIZE);
3668	3853	out << " sequenceid: 0x" << std::hex << res->CREATE_SESSION4res_u.csr_resok4.csr_sequence << std::dec
3669		<< " flags: " << res->CREATE_SESSION4res_u.csr_resok4.csr_flags
3670		<< " fore chan attrs: " << res->CREATE_SESSION4res_u.csr_resok4.csr_fore_chan_attrs
3671		<< " fore back attrs: " << res->CREATE_SESSION4res_u.csr_resok4.csr_back_chan_attrs;
	3854	<< " flags: " << res->CREATE_SESSION4res_u.csr_resok4.csr_flags
	3855	<< " fore chan attrs: " << res->CREATE_SESSION4res_u.csr_resok4.csr_fore_chan_attrs
	3856	<< " fore back attrs: " << res->CREATE_SESSION4res_u.csr_resok4.csr_back_chan_attrs;
3672	3857	}
3673	3858	}
3674	3859	}
3675	3860
3676	3861	void PrintAnalyzer::nfs41_operation(const struct NFS41::DESTROY_SESSION4args* args)
3677	3862	{
3678		if (args)
	3863	if(args)
3679	3864	{
3680	3865	out << "session id: ";
3681	3866	print_hex(out,

3686	3871
3687	3872	void PrintAnalyzer::nfs41_operation(const struct NFS41::DESTROY_SESSION4res* res)
3688	3873	{
3689		if (res)
	3874	if(res)
3690	3875	{
3691	3876	out << "status: " << res->dsr_status;
3692	3877	}

3694	3879
3695	3880	void PrintAnalyzer::nfs41_operation(const struct NFS41::FREE_STATEID4args* args)
3696	3881	{
3697		if (args)
	3882	if(args)
3698	3883	{
3699	3884	out << "stateid: " << args->fsa_stateid;
3700	3885	}

3702	3887
3703	3888	void PrintAnalyzer::nfs41_operation(const struct NFS41::FREE_STATEID4res* res)
3704	3889	{
3705		if (res)
	3890	if(res)
3706	3891	{
3707	3892	out << "status: " << res->fsr_status;
3708	3893	}

3710	3895
3711	3896	void PrintAnalyzer::nfs41_operation(const struct NFS41::GETDEVICEINFO4args* args)
3712	3897	{
3713		if (args)
3714		{
3715		out << "device id: " << args->gdia_device_id
3716		<< " layout type: " << args->gdia_layout_type
3717		<< " maxcount: " << args->gdia_maxcount
	3898	if(args)
	3899	{
	3900	out << "device id: " << args->gdia_device_id
	3901	<< " layout type: " << args->gdia_layout_type
	3902	<< " maxcount: " << args->gdia_maxcount
3718	3903	<< " notify types: " << args->gdia_notify_types;
3719	3904	}
3720	3905	}
3721	3906
3722	3907	void PrintAnalyzer::nfs41_operation(const struct NFS41::GETDEVICEINFO4res* res)
3723	3908	{
3724		if (res)
	3909	if(res)
3725	3910	{
3726	3911	out << "status: " << res->gdir_status;
3727		if (out_all())
3728		{
3729		if (res->gdir_status == NFS41::nfsstat4::NFS4_OK)
3730		{
3731		out << " device addr: " << res->GETDEVICEINFO4res_u.gdir_resok4.gdir_device_addr
	3912	if(out_all())
	3913	{
	3914	if(res->gdir_status == NFS41::nfsstat4::NFS4_OK)
	3915	{
	3916	out << " device addr: " << res->GETDEVICEINFO4res_u.gdir_resok4.gdir_device_addr
3732	3917	<< " notification: " << res->GETDEVICEINFO4res_u.gdir_resok4.gdir_notification;
3733	3918	}
3734		if (res->gdir_status == NFS41::nfsstat4::NFS4ERR_TOOSMALL)
	3919	if(res->gdir_status == NFS41::nfsstat4::NFS4ERR_TOOSMALL)
3735	3920	{
3736	3921	out << " min count: " << res->GETDEVICEINFO4res_u.gdir_mincount;
3737	3922	}

3741	3926
3742	3927	void PrintAnalyzer::nfs41_operation(const struct NFS41::GETDEVICELIST4args* args)
3743	3928	{
3744		if (args)
3745		{
3746		out << "layout type: " << args->gdla_layout_type
	3929	if(args)
	3930	{
	3931	out << "layout type: " << args->gdla_layout_type
3747	3932	<< " max devices: " << args->gdla_maxdevices
3748		<< " cookie: " << args->gdla_cookie
3749		<< " cookieverf: " << args->gdla_cookieverf;
	3933	<< " cookie: " << args->gdla_cookie
	3934	<< " cookieverf: " << args->gdla_cookieverf;
3750	3935	}
3751	3936	}
3752	3937
3753	3938	void PrintAnalyzer::nfs41_operation(const struct NFS41::GETDEVICELIST4res* res)
3754	3939	{
3755		if (res)
	3940	if(res)
3756	3941	{
3757	3942	out << "status: " << res->gdlr_status;
3758		if (out_all() && res->gdlr_status == NFS41::nfsstat4::NFS4_OK)
3759		{
3760		out << " cookie: " << res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_cookie
3761		<< " cookieverf: " << res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_cookieverf
	3943	if(out_all() && res->gdlr_status == NFS41::nfsstat4::NFS4_OK)
	3944	{
	3945	out << " cookie: " << res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_cookie
	3946	<< " cookieverf: " << res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_cookieverf
3762	3947	<< " device id list: ";
3763		NFS41::deviceid4* current_el {res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_deviceid_list.gdlr_deviceid_list_val};
3764		for (u_int i {0}; i < res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_deviceid_list.gdlr_deviceid_list_len; i++, current_el++)
	3948	NFS41::deviceid4* current_el{res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_deviceid_list.gdlr_deviceid_list_val};
	3949	for(u_int i{0}; i < res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_deviceid_list.gdlr_deviceid_list_len; i++, current_el++)
3765	3950	{
3766	3951	out << ' ' << current_el;
3767	3952	}
3768		out << " eof: " << res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_eof;
	3953	out << " eof: " << res->GETDEVICELIST4res_u.gdlr_resok4.gdlr_eof;
3769	3954	}
3770	3955	}
3771	3956	}
3772	3957
3773	3958	void PrintAnalyzer::nfs41_operation(const struct NFS41::LAYOUTCOMMIT4args* args)
3774	3959	{
3775		if (args)
3776		{
3777		out << "offset: " << args->loca_offset
3778		<< " length: " << args->loca_length
3779		<< " reclaim: " << args->loca_reclaim
3780		<< " stateid: " << args->loca_stateid
3781		<< " last write offset: " << args->loca_last_write_offset
3782		<< " time modify: " << args->loca_time_modify
3783		<< " tayout update: " << args->loca_layoutupdate;
	3960	if(args)
	3961	{
	3962	out << "offset: " << args->loca_offset
	3963	<< " length: " << args->loca_length
	3964	<< " reclaim: " << args->loca_reclaim
	3965	<< " stateid: " << args->loca_stateid
	3966	<< " last write offset: " << args->loca_last_write_offset
	3967	<< " time modify: " << args->loca_time_modify
	3968	<< " tayout update: " << args->loca_layoutupdate;
3784	3969	}
3785	3970	}
3786	3971
3787	3972	void PrintAnalyzer::nfs41_operation(const struct NFS41::LAYOUTCOMMIT4res* res)
3788	3973	{
3789		if (res)
	3974	if(res)
3790	3975	{
3791	3976	out << "status: " << res->locr_status;
3792		if (out_all() && res->locr_status == NFS41::nfsstat4::NFS4_OK)
	3977	if(out_all() && res->locr_status == NFS41::nfsstat4::NFS4_OK)
3793	3978	{
3794	3979	out << " new size: " << res->LAYOUTCOMMIT4res_u.locr_resok4.locr_newsize;
3795	3980	}

3798	3983
3799	3984	void PrintAnalyzer::nfs41_operation(const struct NFS41::LAYOUTGET4args* args)
3800	3985	{
3801		if (args)
3802		{
3803		out << "signal layout avail: " << args->loga_signal_layout_avail
3804		<< " layout type: " << args->loga_layout_type
3805		<< " iomode: " << args->loga_iomode
3806		<< " offset: " << args->loga_offset
3807		<< " length: " << args->loga_length
3808		<< " minlength: " << args->loga_minlength
3809		<< " stateid: " << args->loga_stateid
3810		<< " maxcount: " << args->loga_maxcount;
	3986	if(args)
	3987	{
	3988	out << "signal layout avail: " << args->loga_signal_layout_avail
	3989	<< " layout type: " << args->loga_layout_type
	3990	<< " iomode: " << args->loga_iomode
	3991	<< " offset: " << args->loga_offset
	3992	<< " length: " << args->loga_length
	3993	<< " minlength: " << args->loga_minlength
	3994	<< " stateid: " << args->loga_stateid
	3995	<< " maxcount: " << args->loga_maxcount;
3811	3996	}
3812	3997	}
3813	3998
3814	3999	void PrintAnalyzer::nfs41_operation(const struct NFS41::LAYOUTGET4res* res)
3815	4000	{
3816		if (res)
	4001	if(res)
3817	4002	{
3818	4003	out << "status: " << res->logr_status;
3819		if (out_all())
3820		{
3821		if (res->logr_status == NFS41::nfsstat4::NFS4_OK)
	4004	if(out_all())
	4005	{
	4006	if(res->logr_status == NFS41::nfsstat4::NFS4_OK)
3822	4007	{
3823	4008	out << " return on close: "
3824	4009	<< res->LAYOUTGET4res_u.logr_resok4.logr_return_on_close

3826	4011	<< res->LAYOUTGET4res_u.logr_resok4.logr_stateid
3827	4012	<< " layout:x ";
3828	4013	NFS41::layout4* current_el = res->LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val;
3829		for (u_int i {0}; i < res->LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_len; i++, current_el++)
	4014	for(u_int i{0}; i < res->LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_len; i++, current_el++)
3830	4015	{
3831	4016	out << ' ' << current_el;
3832	4017	}
3833	4018	}
3834	4019	}
3835		if (res->logr_status == NFS41::nfsstat4::NFS4ERR_LAYOUTTRYLATER)
	4020	if(res->logr_status == NFS41::nfsstat4::NFS4ERR_LAYOUTTRYLATER)
3836	4021	{
3837	4022	out << "will signal layout avail: "
3838	4023	<< res->LAYOUTGET4res_u.logr_will_signal_layout_avail;

3842	4027
3843	4028	void PrintAnalyzer::nfs41_operation(const struct NFS41::LAYOUTRETURN4args* args)
3844	4029	{
3845		if (args)
3846		{
3847		out << "reclaim: " << args->lora_reclaim
3848		<< " layout type: " << args->lora_layout_type
3849		<< " iomode: " << args->lora_iomode
	4030	if(args)
	4031	{
	4032	out << "reclaim: " << args->lora_reclaim
	4033	<< " layout type: " << args->lora_layout_type
	4034	<< " iomode: " << args->lora_iomode
3850	4035	<< " layout return: " << args->lora_layoutreturn;
3851	4036	}
3852	4037	}
3853	4038
3854	4039	void PrintAnalyzer::nfs41_operation(const struct NFS41::LAYOUTRETURN4res* res)
3855	4040	{
3856		if (res)
	4041	if(res)
3857	4042	{
3858	4043	out << "status: " << res->lorr_status;
3859		if (out_all() && res->lorr_status == NFS41::nfsstat4::NFS4_OK)
	4044	if(out_all() && res->lorr_status == NFS41::nfsstat4::NFS4_OK)
3860	4045	{
3861	4046	out << " stateid: " << res->LAYOUTRETURN4res_u.lorr_stateid;
3862	4047	}

3865	4050
3866	4051	void PrintAnalyzer::nfs41_operation(const struct NFS41::SEQUENCE4args* args)
3867	4052	{
3868		if (args)
3869		{
3870		out << "sessionid: ";
	4053	if(args)
	4054	{
	4055	out << "sessionid: ";
3871	4056	print_hex(out,
3872	4057	args->sa_sessionid,
3873	4058	NFS41::NFS4_SESSIONID_SIZE);
3874	4059	out << " sequenceid: 0x" << std::hex << args->sa_sequenceid << std::dec
3875		<< " slotid: " << args->sa_slotid
3876		<< " cache this: " << args->sa_cachethis;
	4060	<< " slotid: " << args->sa_slotid
	4061	<< " cache this: " << args->sa_cachethis;
3877	4062	}
3878	4063	}
3879	4064
3880	4065	void PrintAnalyzer::nfs41_operation(const struct NFS41::SEQUENCE4res* res)
3881	4066	{
3882		if (res)
	4067	if(res)
3883	4068	{
3884	4069	out << "status: " << res->sr_status;
3885		if (out_all() && res->sr_status == NFS41::nfsstat4::NFS4_OK)
	4070	if(out_all() && res->sr_status == NFS41::nfsstat4::NFS4_OK)
3886	4071	{
3887	4072	out << " session: ";
3888	4073	print_hex(out,
3889	4074	res->SEQUENCE4res_u.sr_resok4.sr_sessionid,
3890	4075	NFS41::NFS4_SESSIONID_SIZE);
3891	4076	out << " sequenceid: 0x" << std::hex << res->SEQUENCE4res_u.sr_resok4.sr_sequenceid << std::dec
3892		<< " slotid: " << res->SEQUENCE4res_u.sr_resok4.sr_slotid
3893		<< " highest slotid: " << res->SEQUENCE4res_u.sr_resok4.sr_highest_slotid
3894		<< " target highest slotid: " << res->SEQUENCE4res_u.sr_resok4.sr_target_highest_slotid
3895		<< " status flags: " << res->SEQUENCE4res_u.sr_resok4.sr_status_flags;
	4077	<< " slotid: " << res->SEQUENCE4res_u.sr_resok4.sr_slotid
	4078	<< " highest slotid: " << res->SEQUENCE4res_u.sr_resok4.sr_highest_slotid
	4079	<< " target highest slotid: " << res->SEQUENCE4res_u.sr_resok4.sr_target_highest_slotid
	4080	<< " status flags: " << res->SEQUENCE4res_u.sr_resok4.sr_status_flags;
3896	4081	}
3897	4082	}
3898	4083	}

3900	4085	//SECINFO_NO_NAME4args
3901	4086	void PrintAnalyzer::nfs41_operation(const enum NFS41::secinfo_style4* args)
3902	4087	{
3903		if (args)
	4088	if(args)
3904	4089	{
3905	4090	out << ' ' << *args;
3906	4091	}

3908	4093
3909	4094	void PrintAnalyzer::nfs41_operation(const struct NFS41::SET_SSV4args* args)
3910	4095	{
3911		if (args)
	4096	if(args)
3912	4097	{
3913	4098	out << "ssv: ";
3914	4099	out.write(args->ssa_ssv.ssa_ssv_val,

3921	4106
3922	4107	void PrintAnalyzer::nfs41_operation(const struct NFS41::SET_SSV4res* res)
3923	4108	{
3924		if (res)
	4109	if(res)
3925	4110	{
3926	4111	out << "status: " << res->ssr_status;
3927		if (out_all() && res->ssr_status == NFS41::nfsstat4::NFS4_OK)
	4112	if(out_all() && res->ssr_status == NFS41::nfsstat4::NFS4_OK)
3928	4113	{
3929	4114	out << " digest: ";
3930	4115	out.write(res->SET_SSV4res_u.ssr_resok4.ssr_digest.ssr_digest_val,

3935	4120
3936	4121	void PrintAnalyzer::nfs41_operation(const struct NFS41::TEST_STATEID4args* args)
3937	4122	{
3938		if (args)
	4123	if(args)
3939	4124	{
3940	4125	out << "stateids:";
3941	4126	NFS41::stateid4* current_el = args->ts_stateids.ts_stateids_val;
3942		for (u_int i {0}; i < args->ts_stateids.ts_stateids_len; i++, current_el++)
	4127	for(u_int i{0}; i < args->ts_stateids.ts_stateids_len; i++, current_el++)
3943	4128	{
3944	4129	out << ' ' << current_el;
3945	4130	}

3948	4133
3949	4134	void PrintAnalyzer::nfs41_operation(const struct NFS41::TEST_STATEID4res* res)
3950	4135	{
3951		if (res)
	4136	if(res)
3952	4137	{
3953	4138	out << "status: " << res->tsr_status;
3954		if (out_all() && res->tsr_status == NFS41::nfsstat4::NFS4_OK)
	4139	if(out_all() && res->tsr_status == NFS41::nfsstat4::NFS4_OK)
3955	4140	{
3956	4141	out << " status codes: ";
3957	4142	NFS41::nfsstat4* current_el = res->TEST_STATEID4res_u.tsr_resok4.tsr_status_codes.tsr_status_codes_val;
3958		for (u_int i {0}; i < res->TEST_STATEID4res_u.tsr_resok4.tsr_status_codes.tsr_status_codes_len; i++, current_el++)
	4143	for(u_int i{0}; i < res->TEST_STATEID4res_u.tsr_resok4.tsr_status_codes.tsr_status_codes_len; i++, current_el++)
3959	4144	{
3960	4145	out << ' ' << current_el;
3961	4146	}

3965	4150
3966	4151	void PrintAnalyzer::nfs41_operation(const struct NFS41::WANT_DELEGATION4args* args)
3967	4152	{
3968		if (args)
3969		{
3970		out << "want: " << args->wda_want
	4153	if(args)
	4154	{
	4155	out << "want: " << args->wda_want
3971	4156	<< " claim: " << args->wda_claim;
3972	4157	}
3973	4158	}
3974	4159
3975	4160	void PrintAnalyzer::nfs41_operation(const struct NFS41::WANT_DELEGATION4res* res)
3976	4161	{
3977		if (res)
	4162	if(res)
3978	4163	{
3979	4164	out << "status: " << res->wdr_status;
3980		if (out_all() && res->wdr_status == NFS41::nfsstat4::NFS4_OK)
	4165	if(out_all() && res->wdr_status == NFS41::nfsstat4::NFS4_OK)
3981	4166	{
3982	4167	out << res->WANT_DELEGATION4res_u.wdr_resok4;
3983	4168	}

3986	4171
3987	4172	void PrintAnalyzer::nfs41_operation(const struct NFS41::DESTROY_CLIENTID4args* args)
3988	4173	{
3989		if (args)
	4174	if(args)
3990	4175	{
3991	4176	out << "clientid: " << args->dca_clientid;
3992	4177	}

3994	4179
3995	4180	void PrintAnalyzer::nfs41_operation(const struct NFS41::DESTROY_CLIENTID4res* res)
3996	4181	{
3997		if (res)
	4182	if(res)
3998	4183	{
3999	4184	out << "status: " << res->dcr_status;
4000	4185	}

4002	4187
4003	4188	void PrintAnalyzer::nfs41_operation(const struct NFS41::RECLAIM_COMPLETE4args* args)
4004	4189	{
4005		if (args)
	4190	if(args)
4006	4191	{
4007	4192	out << "one fs: " << args->rca_one_fs;
4008	4193	}

4010	4195
4011	4196	void PrintAnalyzer::nfs41_operation(const struct NFS41::RECLAIM_COMPLETE4res* res)
4012	4197	{
4013		if (res)
	4198	if(res)
4014	4199	{
4015	4200	out << "status: " << res->rcr_status;
4016	4201	}

4018	4203
4019	4204	void PrintAnalyzer::nfs41_operation(const struct NFS41::ILLEGAL4res* res)
4020	4205	{
4021		if (res) { out << "status: " << res->status; }
4022		}
4023
	4206	if(res) {
	4207	out << "status: " << res->status;
	4208	}
	4209	}
4024	4210
4025	4211	void PrintAnalyzer::flush_statistics()
4026	4212	{

-6

src/analysis/print_analyzer.h less more

29	29	{
30	30	namespace analysis
31	31	{
32
33	32	namespace NFS3 = NST::API::NFS3;
34	33	namespace NFS4 = NST::API::NFS4;
35	34	namespace NFS41 = NST::API::NFS41;

37	36	class PrintAnalyzer : public IAnalyzer
38	37	{
39	38	public:
40		PrintAnalyzer(std::ostream& o) : out(o)
	39	PrintAnalyzer(std::ostream& o)
	40	: out(o)
41	41	{
42	42	}
43	43	~PrintAnalyzer()
44	44	{
45	45	}
46	46
	47	// clang-format off
47	48	void closeFileSMBv2(const SMBv2::CloseFileCommand*,
48	49	const SMBv2::CloseRequest*,
49	50	const SMBv2::CloseResponse*) override final;

455	456	void nfs41_operation(const struct NFS41::SAVEFH4res* res);
456	457
457	458	void nfs41_operation(const struct NFS41::ILLEGAL4res* res);
458
	459	// clang-format on
459	460	void flush_statistics() override final;
460	461
461	462	private:
462		PrintAnalyzer(const PrintAnalyzer&) = delete;
	463	PrintAnalyzer(const PrintAnalyzer&) = delete;
463	464	PrintAnalyzer& operator=(const PrintAnalyzer&) = delete;
464	465
465	466	std::ostream& out;

468	469	} // namespace analysis
469	470	} // namespace NST
470	471	//------------------------------------------------------------------------------
471		#endif//PRINT_ANALYZER_H
472		//------------------------------------------------------------------------------
	472	#endif //PRINT_ANALYZER_H
	473	//------------------------------------------------------------------------------

+14

-16

src/analysis/rpc_sessions.h less more

24	24	#include <cinttypes>
25	25	#include <memory>
26	26	#include <string>
	27	#include <utility>
27	28	#include <vector>
28	29	#include <unordered_map>
29		#include <utility>
30	30
31	31	#include "protocols/rpc/rpc_header.h"
32	32	#include "utils/filtered_data.h"

38	38	{
39	39	namespace analysis
40	40	{
41
42	41	class Session : public utils::ApplicationSession
43	42	{
44	43	using FilteredDataQueue = NST::utils::FilteredDataQueue;
	44
45	45	public:
46
47	46	Session(const utils::NetworkSession& s, utils::Session::Direction call_direction)
48		: utils::ApplicationSession{s, call_direction}
	47	: utils::ApplicationSession{s, call_direction}
49	48	{
50	49	utils::Out message;
51	50	message << "Detect session " << str();
52	51	}
53		~Session() = default;
54		Session(const Session&) = delete;
	52	~Session() = default;
	53	Session(const Session&) = delete;
55	54	Session& operator=(const Session&) = delete;
56
	55
57	56	void save_call_data(const std::uint64_t xid, FilteredDataQueue::Ptr&& data)
58	57	{
59	58	FilteredDataQueue::Ptr& e = operations[xid];
60		if(e) // xid call already exists
	59	if(e) // xid call already exists
61	60	{
62	61	LOG("replace RPC Call XID:%" PRIu64 " for %s", xid, str().c_str());
63	62	}
64	63
65		e = std::move(data); // replace existing or set new
	64	e = std::move(data); // replace existing or set new
66	65	}
67	66	inline FilteredDataQueue::Ptr get_call_data(const std::uint64_t xid)
68	67	{

83	82
84	83	inline const Session* get_session() const { return this; }
85	84	private:
86
87	85	// TODO: add custom allocator based on BlockAllocator
88	86	// to decrease cost of expensive insert/erase operations
89	87	std::unordered_map<std::uint64_t, FilteredDataQueue::Ptr> operations;

95	93	public:
96	94	using MsgType = NST::protocols::rpc::MsgType;
97	95
98		Sessions() = default;
99		~Sessions()= default;
100		Sessions(const Sessions&) = delete;
	96	Sessions() = default;
	97	~Sessions() = default;
	98	Sessions(const Sessions&) = delete;
101	99	Sessions& operator=(const Sessions&) = delete;
102	100
103	101	Session* get_session(utils::NetworkSession* app, NST::utils::Session::Direction dir, MsgType type)

106	104	{
107	105	if(type == MsgType::CALL) // add new session only for Call
108	106	{
109		std::unique_ptr<Session> ptr{ new Session{*app, dir} };
	107	std::unique_ptr<Session> ptr{new Session{*app, dir}};
110	108	sessions.emplace_back(std::move(ptr));
111	109
112	110	app->application = sessions.back().get(); // set reference

117	115	}
118	116
119	117	private:
120		std::vector< std::unique_ptr<Session> > sessions;
	118	std::vector<std::unique_ptr<Session>> sessions;
121	119	};
122	120
123	121	} // namespace analysis
124	122	} // namespace NST
125	123	//------------------------------------------------------------------------------
126		#endif//RPC_SESSIONS_H
	124	#endif //RPC_SESSIONS_H
127	125	//------------------------------------------------------------------------------

-1

src/api/cifs2_commands.h less more

31	31	*/
32	32	namespace SMBv2
33	33	{
	34	// clang-format off
34	35
35	36	/*! CIFS v2 commands
36	37	*/

1251	1252	} __attribute__ ((__packed__));
1252	1253
1253	1254	} // namespace SMBv2
	1255
	1256	// clang-format on
	1257
1254	1258	} // namespace API
1255	1259	} // namespace NST
1256	1260	//------------------------------------------------------------------------------
1257		#endif//API_CIFS2_COMMANDS_H
	1261	#endif // API_CIFS2_COMMANDS_H
1258	1262	//------------------------------------------------------------------------------

-2

src/api/cifs_commands.h less more

33	33	*/
34	34	namespace SMBv1
35	35	{
	36	// clang-format off
36	37
37	38	/*! CIFS v1 commands list
38	39	*/

343	344	struct NoAndxCmdArgumentType{} __attribute__ ((__packed__)); //!< No command's arguments
344	345	struct NoAndxCmdResultType{} __attribute__ ((__packed__)); //!< No command's results
345	346
	347	// clang-format om
	348
346	349	} // namespace SMBv1
347	350	} // namespace API
348	351	} // namespace NST
349	352	//------------------------------------------------------------------------------
350		#endif//API_CIFS_COMMANDS_H
351		//------------------------------------------------------------------------------
	353	#endif// API_CIFS_COMMANDS_H
	354	//------------------------------------------------------------------------------

+20

-17

src/api/cifs_pc_to_net.h less more

29	29	#define NFSTRACE_BIG_ENDIAN __BIG_ENDIAN
30	30	#define NFSTRACE_LITTLE_ENDIAN __LITTLE_ENDIAN
31	31	#else
	32	#include <machine/endian.h>
32	33	#include <sys/param.h>
33		#include <machine/endian.h>
34	34	#define NFSTRACE_BYTE_ORDER BYTE_ORDER
35	35	#define NFSTRACE_BIG_ENDIAN BIG_ENDIAN
36	36	#define NFSTRACE_LITTLE_ENDIAN LITTLE_ENDIAN

42	42	{
43	43	namespace SMBv2
44	44	{
45
46		# if NFSTRACE_BYTE_ORDER == NFSTRACE_BIG_ENDIAN
	45	#if NFSTRACE_BYTE_ORDER == NFSTRACE_BIG_ENDIAN
47	46
48	47	// TODO: rename this function template to LEconstant2host
49	48
50		template<class T>
	49	template <class T>
51	50	constexpr T pc_to_net(T t)
52	51	{
53	52	static_assert(t == T{}, "try to not use pc_to_net w/o specialization");
54	53	return t;
55	54	}
56	55
57		template<>
	56	// clang-format off
	57
	58	template <>
58	59	constexpr std::uint64_t pc_to_net(std::uint64_t t)
59	60	{
60	61	return ((t & 0xFF00000000000000) >> 56)

67	68	\| ((t & 0x00000000000000FF) << 56);
68	69	}
69	70
70		template<>
	71	template <>
71	72	constexpr uint32_t pc_to_net(uint32_t t)
72	73	{
73	74	return ((t & 0xFF000000) >> 24)

76	77	\| ((t & 0x000000FF) << 24);
77	78	}
78	79
79		template<>
	80	template <>
80	81	constexpr uint16_t pc_to_net(uint16_t t)
81	82	{
82	83	return ((t & 0xFF00) >> 8)
83	84	\| ((t & 0x00FF) << 8);
84	85	}
85	86
86		template<>
	87	// clang-format on
	88
	89	template <>
87	90	constexpr std::uint8_t pc_to_net(std::uint8_t v)
88	91	{
89	92	return v;
90	93	}
91	94
92		template<>
	95	template <>
93	96	constexpr std::int64_t pc_to_net(std::int64_t v)
94	97	{
95	98	return pc_to_net((std::uint64_t)v);
96	99	}
97	100
98		template<>
	101	template <>
99	102	constexpr std::int32_t pc_to_net(std::int32_t v)
100	103	{
101	104	return pc_to_net((std::uint32_t)v);
102	105	}
103	106
104		template<>
	107	template <>
105	108	constexpr std::int16_t pc_to_net(std::int16_t v)
106	109	{
107	110	return pc_to_net((std::uint16_t)v);
108	111	}
109	112
110		template<>
	113	template <>
111	114	constexpr std::int8_t pc_to_net(std::int8_t v)
112	115	{
113	116	return pc_to_net((std::uint8_t)v);
114	117	}
115	118
116		# else
117		# if NFSTRACE_BYTE_ORDER == NFSTRACE_LITTLE_ENDIAN
	119	#else
	120	#if NFSTRACE_BYTE_ORDER == NFSTRACE_LITTLE_ENDIAN
118	121
119	122	/*!
120	123	* Does nothing for Intel
121	124	*/
122		template<class T>
	125	template <class T>
123	126	constexpr T pc_to_net(T t)
124	127	{
125	128	return t;
126	129	}
127	130
128		# endif
	131	#endif
129	132	#endif
130	133
131	134	} // SMBv2
132	135	} // API
133	136	} // NST
134	137	//------------------------------------------------------------------------------
135		#endif//PC_TO_NET_H
	138	#endif // PC_TO_NET_H
136	139	//------------------------------------------------------------------------------

+108

-112

src/api/cifs_types.h less more

23	23	//------------------------------------------------------------------------------
24	24	#include <sys/time.h>
25	25
	26	#include "cifs2_commands.h"
26	27	#include "cifs_commands.h"
27		#include "cifs2_commands.h"
28	28	#include "procedure.h"
29	29	//------------------------------------------------------------------------------
30	30	namespace NST

33	33	{
34	34	namespace CIFSv1
35	35	{
36		struct RawMessageHeader;
	36	struct RawMessageHeader;
37	37	}
38	38	namespace CIFSv2
39	39	{
40		struct RawMessageHeader;
	40	struct RawMessageHeader;
41	41	}
42	42	} // namespace protocols
43	43	namespace API
44	44	{
45
46	45	/*! SMB 1 version
47	46	*/
48	47	namespace SMBv1
49	48	{
50
51		using Session = u_int16_t;//!< Session IDentifier
	49	using Session = u_int16_t; //!< Session IDentifier
52	50
53	51	/*! Represents one SMB command
54	52	*/
55	53	template <
56	54	typename Header,
57	55	typename Request,
58		typename Response
59		>
	56	typename Response>
60	57	class Command : public Procedure<int>
61	58	{
62	59	public:
63		using RequestType = Request;
64		using ResponseType = Response;
65		using HeaderType = Header;
66		const HeaderType* req_header = nullptr;
67		const HeaderType* res_header = nullptr;
68		const RequestType* parg = nullptr;//!< Arguments of specified command
69		const ResponseType* pres = nullptr;//!< Results of specified command
	60	using RequestType = Request;
	61	using ResponseType = Response;
	62	using HeaderType = Header;
	63	const HeaderType* req_header = nullptr;
	64	const HeaderType* res_header = nullptr;
	65	const RequestType* parg = nullptr; //!< Arguments of specified command
	66	const ResponseType* pres = nullptr; //!< Results of specified command
70	67	};
71	68
72		using CreateDirectoryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CreateDirectoryArgumentType, CreateDirectoryResultType>; //!< CreateDirectory command
73		using DeleteDirectoryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, DeleteDirectoryArgumentType, DeleteDirectoryResultType>; //!< DeleteDirectory command
74		using OpenCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, OpenArgumentType, OpenResultType>; //!< Open command
75		using CreateCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CreateArgumentType, CreateResultType>; //!< Create command
76		using CloseCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CloseArgumentType, CloseResultType>; //!< Close command
77		using FlushCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, FlushArgumentType, FlushResultType>; //!< Flush command
78		using DeleteCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, DeleteArgumentType, DeleteResultType>; //!< Delete command
79		using RenameCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, RenameArgumentType, RenameResultType>; //!< Rename command
80		using QueryInformationCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, QueryInformationArgumentType, QueryInformationResultType>; //!< QueryInformation command. This transaction is used to get information about a specific file or directory. There are several information levels that can be queried.
81		using SetInformationCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, SetInformationArgumentType, SetInformationResultType>; //!< Set Information command. This transaction is used to set the standard and extended attribute information of a specific file or directory on the server.
82		using ReadCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ReadArgumentType, ReadResultType>; //!< Read command
83		using WriteCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteArgumentType, WriteResultType>; //!< Write command
84		using LockByteRangeCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, LockByteRangeArgumentType, LockByteRangeResultType>; //!< Lock Byte Range command. This command is used to explicitly lock a contiguous range of bytes in an open regular file.
85		using UnlockByteRangeCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, UnlockByteRangeArgumentType, UnlockByteRangeResultType>; //!< UnLock Byte Range command
86		using CreateTemporaryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CreateTemporaryArgumentType, CreateTemporaryResultType>; //!< Create Temporary file command. This command is used to create a file for temporary use by the client.
87		using CreateNewCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CreateNewArgumentType, CreateNewResultType>; //!< Create a new file command. This command is used to create a new file. It MUST NOT truncate or overwrite an existing file.
88		using CheckDirectoryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CheckDirectoryArgumentType, CheckDirectoryResultType>; //!< CheckDirectory command. This command is used to verify that a specified path resolves to a valid directory on the server.
89		using ProcessExitCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ProcessExitArgumentType, ProcessExitResultType>; //!< Process Exit command.An SMB_COM_PROCESS_EXIT request is sent by the client to indicate the catastrophic failure of a client process.
90		using SeekCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, SeekArgumentType, SeekResultType>; //!< Seek command
91		using LockAndReadCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, LockAndReadArgumentType, LockAndReadResultType>; //!< Lock And Read command
92		using WriteAndUnlockCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteAndUnlockArgumentType, WriteAndUnlockResultType>; //!< Write And Unlock command
93		using ReadRawCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ReadRawArgumentType, ReadRawResultType>; //!< Read raw command
94		using ReadMpxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ReadMpxArgumentType, ReadMpxResultType>; //!< Read Mpx command. This is a specialized read command intended to maximize the performance of reading large blocks of data from a regular file while allowing for other operations to take place between the client and the server.
95		using ReadMpxSecondaryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ReadMpxSecondaryArgumentType, ReadMpxSecondaryResultType>; //!< Read Read Mpx Secondary command
96		using WriteRawCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteRawArgumentType, WriteRawResultType>; //!< Write Raw command. The command permits a client to send a large unformatted data (raw byte) message over the SMB transport without requiring the usual SMB request format
97		using WriteMpxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteMpxArgumentType, WriteMpxResultType>; //!< Write Mpx command
98		using WriteMpxSecondaryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteMpxSecondaryArgumentType, WriteMpxSecondaryResultType>; //!< Write Mpx 2 command
99		using WriteCompleteCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteCompleteArgumentType, WriteCompleteResultType>; //!< Write Complete command
100		using QueryServerCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, QueryServerArgumentType, QueryServerResultType>; //!< Query Server (reserved) command
101		using SetInformation2Command = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, SetInformation2ArgumentType, SetInformation2ResultType>; //!< Set Information 2 command
102		using QueryInformation2Command = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, QueryInformation2ArgumentType, QueryInformation2ResultType>; //!< Query Information 2 command
103		using LockingAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, LockingAndxArgumentType, LockingAndxResultType>; //!< Lock some bytes of the file command
104		using TransactionCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, TransactionArgumentType, TransactionResultType>; //!< Transaction command.These commands operate on mailslots and named pipes, which are interprocess communication endpoints within the CIFS file system
105		using TransactionSecondaryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, TransactionSecondaryArgumentType, TransactionSecondaryResultType>; //!< Transaction 2 command
106		using IoctlCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, IoctlArgumentType, IoctlResultType>; //!< Ioctl command
107		using IoctlSecondaryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, IoctlSecondaryArgumentType, IoctlSecondaryResultType>; //!< Ioctl 2 command
108		using CopyCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CopyArgumentType, CopyResultType>; //!< Copy command
109		using MoveCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, MoveArgumentType, MoveResultType>; //!< Move command
110		using EchoCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, EchoArgumentType, EchoResultType>; //!< Echo command
111		using WriteAndCloseCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteAndCloseArgumentType, WriteAndCloseResultType>; //!< Write And Close command
112		using OpenAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, OpenAndxArgumentType, OpenAndxResultType>; //!< Open 2 command
113		using ReadAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ReadAndxArgumentType, ReadAndxResultType>; //!< Read 2 command
114		using WriteAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteAndxArgumentType, WriteAndxResultType>; //!< Write 2 command
115		using NewFileSizeCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NewFileSizeArgumentType, NewFileSizeResultType>; //!< New File Size command. Reserved but not implemented
116		using CloseAndTreeDiscCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, CloseAndTreeDiscArgumentType, CloseAndTreeDiscResultType>; //!< Reserved command
117		using Transaction2Command = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, Transaction2ArgumentType, Transaction2ResultType>; //!< Transaction 2 command
118		using Transaction2SecondaryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, Transaction2SecondaryArgumentType, Transaction2SecondaryResultType>; //!< Transaction 3 command
119		using FindClose2Command = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, FindClose2ArgumentType, FindClose2ResultType>; //!< Search handle close command
120		using FindNotifyCloseCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, FindNotifyCloseArgumentType, FindNotifyCloseResultType>; //!< Search handle close command
121		using TreeConnectCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, TreeConnectArgumentType, TreeConnectResultType>; //!< establish a client connection to a server share command
122		using TreeDisconnectCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, TreeDisconnectArgumentType, TreeDisconnectResultType>; //!< Disconnect command
123		using NegotiateCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NegotiateArgumentType, NegotiateResultType>; //!< Negotiate command
124		using SessionSetupAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, SessionSetupAndxArgumentType, SessionSetupAndxResultType>; //!< Session setup command
125		using LogoffAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, LogoffAndxArgumentType, LogoffAndxResultType>; //!< Log off command
126		using TreeConnectAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, TreeConnectAndxArgumentType, TreeConnectAndxResultType>; //!< Tree Connect command
127		using SecurityPackageAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, SecurityPackageAndxArgumentType, SecurityPackageAndxResultType>; //!< Security Package command
128		using QueryInformationDiskCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, QueryInformationDiskArgumentType, QueryInformationDiskResultType>; //!< Query Disk Information command
129		using SearchCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, SearchArgumentType, SearchResultType>; //!< Search command
130		using FindCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, FindArgumentType, FindResultType>; //!< Find command
131		using FindUniqueCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, FindUniqueArgumentType, FindUniqueResultType>; //!< Find unique command
132		using FindCloseCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, FindCloseArgumentType, FindCloseResultType>; //!< Find close command
133		using NtTransactCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NtTransactArgumentType, NtTransactResultType>; //!< Transact command
134		using NtTransactSecondaryCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NtTransactSecondaryArgumentType, NtTransactSecondaryResultType>; //!< Transact 2 command
135		using NtCreateAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NtCreateAndxArgumentType, NtCreateAndxResultType>; //!< Create command
136		using NtCancelCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NtCancelArgumentType, NtCancelResultType>; //!< Cancel command
137		using NtRenameCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NtRenameArgumentType, NtRenameResultType>; //!< Rename command
138		using OpenPrintFileCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, OpenPrintFileArgumentType, OpenPrintFileResultType>; //!< Open Print File command
139		using WritePrintFileCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WritePrintFileArgumentType, WritePrintFileResultType>; //!< Write Print File command
140		using ClosePrintFileCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ClosePrintFileArgumentType, ClosePrintFileResultType>; //!< Close Print File command
141		using GetPrintQueueCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, GetPrintQueueArgumentType, GetPrintQueueResultType>; //!< Get Print Queue command
142		using ReadBulkCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, ReadBulkArgumentType, ReadBulkResultType>; //!< Read Bulk command
143		using WriteBulkCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteBulkArgumentType, WriteBulkResultType>; //!< Write Bulk command
144		using WriteBulkDataCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, WriteBulkDataArgumentType, WriteBulkDataResultType>; //!< Write Bulk command
145		using InvalidCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, InvalidArgumentType, InvalidResultType>; //!< Invalid command
146		using NoAndxCommand = SMBv1::Command< NST::protocols::CIFSv1::RawMessageHeader, NoAndxCmdArgumentType, NoAndxCmdResultType>; //!< No command
	69	using CreateDirectoryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CreateDirectoryArgumentType, CreateDirectoryResultType>; //!< CreateDirectory command
	70	using DeleteDirectoryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, DeleteDirectoryArgumentType, DeleteDirectoryResultType>; //!< DeleteDirectory command
	71	using OpenCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, OpenArgumentType, OpenResultType>; //!< Open command
	72	using CreateCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CreateArgumentType, CreateResultType>; //!< Create command
	73	using CloseCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CloseArgumentType, CloseResultType>; //!< Close command
	74	using FlushCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, FlushArgumentType, FlushResultType>; //!< Flush command
	75	using DeleteCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, DeleteArgumentType, DeleteResultType>; //!< Delete command
	76	using RenameCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, RenameArgumentType, RenameResultType>; //!< Rename command
	77	using QueryInformationCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, QueryInformationArgumentType, QueryInformationResultType>; //!< QueryInformation command. This transaction is used to get information about a specific file or directory. There are several information levels that can be queried.
	78	using SetInformationCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, SetInformationArgumentType, SetInformationResultType>; //!< Set Information command. This transaction is used to set the standard and extended attribute information of a specific file or directory on the server.
	79	using ReadCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ReadArgumentType, ReadResultType>; //!< Read command
	80	using WriteCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteArgumentType, WriteResultType>; //!< Write command
	81	using LockByteRangeCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, LockByteRangeArgumentType, LockByteRangeResultType>; //!< Lock Byte Range command. This command is used to explicitly lock a contiguous range of bytes in an open regular file.
	82	using UnlockByteRangeCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, UnlockByteRangeArgumentType, UnlockByteRangeResultType>; //!< UnLock Byte Range command
	83	using CreateTemporaryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CreateTemporaryArgumentType, CreateTemporaryResultType>; //!< Create Temporary file command. This command is used to create a file for temporary use by the client.
	84	using CreateNewCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CreateNewArgumentType, CreateNewResultType>; //!< Create a new file command. This command is used to create a new file. It MUST NOT truncate or overwrite an existing file.
	85	using CheckDirectoryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CheckDirectoryArgumentType, CheckDirectoryResultType>; //!< CheckDirectory command. This command is used to verify that a specified path resolves to a valid directory on the server.
	86	using ProcessExitCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ProcessExitArgumentType, ProcessExitResultType>; //!< Process Exit command.An SMB_COM_PROCESS_EXIT request is sent by the client to indicate the catastrophic failure of a client process.
	87	using SeekCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, SeekArgumentType, SeekResultType>; //!< Seek command
	88	using LockAndReadCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, LockAndReadArgumentType, LockAndReadResultType>; //!< Lock And Read command
	89	using WriteAndUnlockCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteAndUnlockArgumentType, WriteAndUnlockResultType>; //!< Write And Unlock command
	90	using ReadRawCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ReadRawArgumentType, ReadRawResultType>; //!< Read raw command
	91	using ReadMpxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ReadMpxArgumentType, ReadMpxResultType>; //!< Read Mpx command. This is a specialized read command intended to maximize the performance of reading large blocks of data from a regular file while allowing for other operations to take place between the client and the server.
	92	using ReadMpxSecondaryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ReadMpxSecondaryArgumentType, ReadMpxSecondaryResultType>; //!< Read Read Mpx Secondary command
	93	using WriteRawCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteRawArgumentType, WriteRawResultType>; //!< Write Raw command. The command permits a client to send a large unformatted data (raw byte) message over the SMB transport without requiring the usual SMB request format
	94	using WriteMpxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteMpxArgumentType, WriteMpxResultType>; //!< Write Mpx command
	95	using WriteMpxSecondaryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteMpxSecondaryArgumentType, WriteMpxSecondaryResultType>; //!< Write Mpx 2 command
	96	using WriteCompleteCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteCompleteArgumentType, WriteCompleteResultType>; //!< Write Complete command
	97	using QueryServerCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, QueryServerArgumentType, QueryServerResultType>; //!< Query Server (reserved) command
	98	using SetInformation2Command = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, SetInformation2ArgumentType, SetInformation2ResultType>; //!< Set Information 2 command
	99	using QueryInformation2Command = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, QueryInformation2ArgumentType, QueryInformation2ResultType>; //!< Query Information 2 command
	100	using LockingAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, LockingAndxArgumentType, LockingAndxResultType>; //!< Lock some bytes of the file command
	101	using TransactionCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, TransactionArgumentType, TransactionResultType>; //!< Transaction command.These commands operate on mailslots and named pipes, which are interprocess communication endpoints within the CIFS file system
	102	using TransactionSecondaryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, TransactionSecondaryArgumentType, TransactionSecondaryResultType>; //!< Transaction 2 command
	103	using IoctlCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, IoctlArgumentType, IoctlResultType>; //!< Ioctl command
	104	using IoctlSecondaryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, IoctlSecondaryArgumentType, IoctlSecondaryResultType>; //!< Ioctl 2 command
	105	using CopyCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CopyArgumentType, CopyResultType>; //!< Copy command
	106	using MoveCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, MoveArgumentType, MoveResultType>; //!< Move command
	107	using EchoCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, EchoArgumentType, EchoResultType>; //!< Echo command
	108	using WriteAndCloseCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteAndCloseArgumentType, WriteAndCloseResultType>; //!< Write And Close command
	109	using OpenAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, OpenAndxArgumentType, OpenAndxResultType>; //!< Open 2 command
	110	using ReadAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ReadAndxArgumentType, ReadAndxResultType>; //!< Read 2 command
	111	using WriteAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteAndxArgumentType, WriteAndxResultType>; //!< Write 2 command
	112	using NewFileSizeCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NewFileSizeArgumentType, NewFileSizeResultType>; //!< New File Size command. Reserved but not implemented
	113	using CloseAndTreeDiscCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, CloseAndTreeDiscArgumentType, CloseAndTreeDiscResultType>; //!< Reserved command
	114	using Transaction2Command = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, Transaction2ArgumentType, Transaction2ResultType>; //!< Transaction 2 command
	115	using Transaction2SecondaryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, Transaction2SecondaryArgumentType, Transaction2SecondaryResultType>; //!< Transaction 3 command
	116	using FindClose2Command = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, FindClose2ArgumentType, FindClose2ResultType>; //!< Search handle close command
	117	using FindNotifyCloseCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, FindNotifyCloseArgumentType, FindNotifyCloseResultType>; //!< Search handle close command
	118	using TreeConnectCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, TreeConnectArgumentType, TreeConnectResultType>; //!< establish a client connection to a server share command
	119	using TreeDisconnectCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, TreeDisconnectArgumentType, TreeDisconnectResultType>; //!< Disconnect command
	120	using NegotiateCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NegotiateArgumentType, NegotiateResultType>; //!< Negotiate command
	121	using SessionSetupAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, SessionSetupAndxArgumentType, SessionSetupAndxResultType>; //!< Session setup command
	122	using LogoffAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, LogoffAndxArgumentType, LogoffAndxResultType>; //!< Log off command
	123	using TreeConnectAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, TreeConnectAndxArgumentType, TreeConnectAndxResultType>; //!< Tree Connect command
	124	using SecurityPackageAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, SecurityPackageAndxArgumentType, SecurityPackageAndxResultType>; //!< Security Package command
	125	using QueryInformationDiskCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, QueryInformationDiskArgumentType, QueryInformationDiskResultType>; //!< Query Disk Information command
	126	using SearchCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, SearchArgumentType, SearchResultType>; //!< Search command
	127	using FindCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, FindArgumentType, FindResultType>; //!< Find command
	128	using FindUniqueCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, FindUniqueArgumentType, FindUniqueResultType>; //!< Find unique command
	129	using FindCloseCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, FindCloseArgumentType, FindCloseResultType>; //!< Find close command
	130	using NtTransactCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NtTransactArgumentType, NtTransactResultType>; //!< Transact command
	131	using NtTransactSecondaryCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NtTransactSecondaryArgumentType, NtTransactSecondaryResultType>; //!< Transact 2 command
	132	using NtCreateAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NtCreateAndxArgumentType, NtCreateAndxResultType>; //!< Create command
	133	using NtCancelCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NtCancelArgumentType, NtCancelResultType>; //!< Cancel command
	134	using NtRenameCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NtRenameArgumentType, NtRenameResultType>; //!< Rename command
	135	using OpenPrintFileCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, OpenPrintFileArgumentType, OpenPrintFileResultType>; //!< Open Print File command
	136	using WritePrintFileCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WritePrintFileArgumentType, WritePrintFileResultType>; //!< Write Print File command
	137	using ClosePrintFileCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ClosePrintFileArgumentType, ClosePrintFileResultType>; //!< Close Print File command
	138	using GetPrintQueueCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, GetPrintQueueArgumentType, GetPrintQueueResultType>; //!< Get Print Queue command
	139	using ReadBulkCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, ReadBulkArgumentType, ReadBulkResultType>; //!< Read Bulk command
	140	using WriteBulkCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteBulkArgumentType, WriteBulkResultType>; //!< Write Bulk command
	141	using WriteBulkDataCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, WriteBulkDataArgumentType, WriteBulkDataResultType>; //!< Write Bulk command
	142	using InvalidCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, InvalidArgumentType, InvalidResultType>; //!< Invalid command
	143	using NoAndxCommand = SMBv1::Command<NST::protocols::CIFSv1::RawMessageHeader, NoAndxCmdArgumentType, NoAndxCmdResultType>; //!< No command
147	144
148		}//SMBv1
	145	} //SMBv1
149	146
150	147	/*! SMB 2 version
151	148	*/
152	149	namespace SMBv2
153	150	{
154
155		using CloseFileCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, CloseRequest, CloseResponse>; //!< Close file command
156		using NegotiateCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, NegotiateRequest, NegotiateResponse>; //!< Negotiate command
157		using SessionSetupCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, SessionSetupRequest, SessionSetupResponse>; //!< Session setup command
158		using EchoCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, EchoRequest, EchoResponse>; //!< Echo command
159		using LogOffCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, LogOffRequest, LogOffResponse>; //!< Log off command
160		using TreeConnectCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, TreeConnectRequest, TreeConnectResponse>; //!< Tree connect command
161		using TreeDisconnectCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, TreeDisconnectRequest, TreeDisconnectResponse>; //!< Tree disconnect command
162		using CreateCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, CreateRequest, CreateResponse>; //!< Create command
163		using QueryInfoCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, QueryInfoRequest, QueryInfoResponse>; //!< Query Info command
164		using QueryDirCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, QueryDirRequest, QueryDirResponse>; //!< Query directory command
165		using FlushCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, FlushRequest, FlushResponse>; //!< Flush command
166		using ReadCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, ReadRequest, ReadResponse>; //!< Read command
167		using WriteCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, WriteRequest, WriteResponse>; //!< Write command
168		using LockCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, LockRequest, LockResponse>; //!< Lock command
169		using CancelCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, CancelRequest, CancelResponce>; //!< Cancel command
170		using ChangeNotifyCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, ChangeNotifyRequest, ChangeNotifyResponse>; //!< Change Notify command
171		using BreakOpLockCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, OplockAcknowledgment, OplockResponse>; //!< Break opportunistic lock command
172		using IoctlCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, IoCtlRequest, IoCtlResponse>; //!< Ioctl command
173		using SetInfoCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, SetInfoRequest, SetInfoResponse>; //!< Set Info command
	151	using CloseFileCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, CloseRequest, CloseResponse>; //!< Close file command
	152	using NegotiateCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, NegotiateRequest, NegotiateResponse>; //!< Negotiate command
	153	using SessionSetupCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, SessionSetupRequest, SessionSetupResponse>; //!< Session setup command
	154	using EchoCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, EchoRequest, EchoResponse>; //!< Echo command
	155	using LogOffCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, LogOffRequest, LogOffResponse>; //!< Log off command
	156	using TreeConnectCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, TreeConnectRequest, TreeConnectResponse>; //!< Tree connect command
	157	using TreeDisconnectCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, TreeDisconnectRequest, TreeDisconnectResponse>; //!< Tree disconnect command
	158	using CreateCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, CreateRequest, CreateResponse>; //!< Create command
	159	using QueryInfoCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, QueryInfoRequest, QueryInfoResponse>; //!< Query Info command
	160	using QueryDirCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, QueryDirRequest, QueryDirResponse>; //!< Query directory command
	161	using FlushCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, FlushRequest, FlushResponse>; //!< Flush command
	162	using ReadCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, ReadRequest, ReadResponse>; //!< Read command
	163	using WriteCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, WriteRequest, WriteResponse>; //!< Write command
	164	using LockCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, LockRequest, LockResponse>; //!< Lock command
	165	using CancelCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, CancelRequest, CancelResponce>; //!< Cancel command
	166	using ChangeNotifyCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, ChangeNotifyRequest, ChangeNotifyResponse>; //!< Change Notify command
	167	using BreakOpLockCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, OplockAcknowledgment, OplockResponse>; //!< Break opportunistic lock command
	168	using IoctlCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, IoCtlRequest, IoCtlResponse>; //!< Ioctl command
	169	using SetInfoCommand = SMBv1::Command<NST::protocols::CIFSv2::RawMessageHeader, SetInfoRequest, SetInfoResponse>; //!< Set Info command
174	170
175	171	} // namespace SMBv2
176	172	} // namespace API
177	173	} // namespace NST
178	174	//------------------------------------------------------------------------------
179		#endif//CIFS_TYPES_H
	175	#endif // CIFS_TYPES_H
180	176	//------------------------------------------------------------------------------

-6

src/api/ianalyzer.h less more

24	24	#define IANALYZER_TYPE_H
25	25	//------------------------------------------------------------------------------
26	26	#include "cifs_types.h"
	27	#include "nfs3_types_rpcgen.h"
	28	#include "nfs41_types_rpcgen.h"
	29	#include "nfs4_types_rpcgen.h"
27	30	#include "nfs_types.h"
28		#include "nfs3_types_rpcgen.h"
29		#include "nfs4_types_rpcgen.h"
30		#include "nfs41_types_rpcgen.h"
31	31	#include "rpc_types.h"
32	32	//------------------------------------------------------------------------------
33	33	namespace NST
34	34	{
35	35	namespace API
36	36	{
37
38	37	/*! Abstract interface for plugins that collect NFS3 statistics
39	38	*/
40	39	class INFSv3rpcgen
41	40	{
42	41	public:
43	42	virtual ~INFSv3rpcgen() {}
44
	43	// clang-format off
45	44	/*! NFSv3 "NULL" procedure
46	45	* \param RPCProcedure - Specified procedure
47	46	* \param NULL3args - procedure arguments

1790	1789	* \param res - result of the command
1791	1790	*/
1792	1791	virtual void breakOplockSMBv2(const SMBv2::BreakOpLockCommand, const SMBv2::OplockAcknowledgment, const SMBv2::OplockResponse*) {}
	1792	// clang-format on
1793	1793	};
1794	1794
1795	1795	/*! Base interface for all nfstrace plugins.

1806	1806	} // namespace API
1807	1807	} // namespace NST
1808	1808	//------------------------------------------------------------------------------
1809		#endif//IANALYZER_TYPE_H
	1809	#endif // IANALYZER_TYPE_H
1810	1810	//------------------------------------------------------------------------------

-1

src/api/nfs3_types_rpcgen.h less more

29	29	{
30	30	namespace NFS3
31	31	{
	32	// clang-format off
32	33
33	34	const uint32_t NFS3_FHSIZE {64};
34	35	const uint32_t NFS3_COOKIEVERFSIZE {8};

950	951
951	952	#define NFS_V3 3
952	953
	954	// clang-format on
	955
953	956	} // namespace NFS3
954	957	} // namespace API
955	958	} // namespace NST
956	959	//------------------------------------------------------------------------------
957		#endif//NFS3_TYPES_RPCGEN_H
	960	#endif // NFS3_TYPES_RPCGEN_H
958	961	//------------------------------------------------------------------------------

-2

src/api/nfs41_types_rpcgen.h less more

0	0	//------------------------------------------------------------------------------
1	1	// Author: Alexey Costroma
2		// Generated by rpcgen with minor compatibility fixes
	2	// Generated by rpcgen with minor compatibility fixes
3	3	// Description: All RFC5661 declared structures.
4	4	// Copyright (c) 2015 EPAM Systems
5	5	//------------------------------------------------------------------------------

30	30	{
31	31	namespace NFS41
32	32	{
	33	// clang-format off
33	34
34	35	using authsys_parms = authunix_parms;
35	36

3120	3121	const uint32_t CB_NULL {0};
3121	3122	const uint32_t CB_COMPOUND {1};
3122	3123
	3124	// clang-format on
	3125
3123	3126	} // namespace NFS41
3124	3127	} // namespace API
3125	3128	} // namespace NST
3126	3129	//------------------------------------------------------------------------------
3127		#endif//NFS41_TYPES_RPCGEN_H
	3130	#endif // NFS41_TYPES_RPCGEN_H
3128	3131	//------------------------------------------------------------------------------

-2

src/api/nfs4_types_rpcgen.h less more

0	0	//------------------------------------------------------------------------------
1	1	// Author: Alexey Costroma
2		// Generated by rpcgen with minor compatibility fixes
	2	// Generated by rpcgen with minor compatibility fixes
3	3	// Description: All RFC3530 declared structures.
4	4	// Copyright (c) 2014 EPAM Systems
5	5	//------------------------------------------------------------------------------

30	30	{
31	31	namespace NFS4
32	32	{
	33	// clang-format off
33	34
34	35	#ifndef RPCSEC_GSS
35	36	#define RPCSEC_GSS 6

1610	1611	const uint32_t CB_NULL {0};
1611	1612	const uint32_t CB_COMPOUND {1};
1612	1613
	1614	// clang-format on
	1615
1613	1616	} // namespace NFS4
1614	1617	} // namespace API
1615	1618	} // namespace NST
1616	1619	//------------------------------------------------------------------------------
1617		#endif//NFS4_TYPES_RPCGEN_H
	1620	#endif //NFS4_TYPES_RPCGEN_H
1618	1621	//------------------------------------------------------------------------------

-9

src/api/nfs_types.h less more

25	25	{
26	26	namespace API
27	27	{
28
29		static const unsigned int NFS_V40 {0};
30		static const unsigned int NFS_V41 {1};
	28	static const unsigned int NFS_V40{0};
	29	static const unsigned int NFS_V41{1};
31	30
32	31	//! struct ProcEnumNFS3 - containts all NFSv3 procedures
33	32	struct ProcEnumNFS3

57	56	PATHCONF = 20,
58	57	COMMIT = 21
59	58	};
60		static const unsigned int count {22}; //!< amount of procedures
	59	static const unsigned int count{22}; //!< amount of procedures
61	60	};
62	61
63	62	//! struct ProcEnumNFS4 - containts all NFSv4.0 procedures and operations

109	108	// Pleause, keep in mind that in all cases we suppose that NFSv4.0
110	109	// operation ILLEGAL(10044) has the second position in ProcEnumNFS4
111	110	};
112		static const unsigned int count {41}; //!< amount of procedures & operations together
113		static const unsigned int count_proc {2}; //!< amount of procedures
	111	static const unsigned int count{41}; //!< amount of procedures & operations together
	112	static const unsigned int count_proc{2}; //!< amount of procedures
114	113	};
115	114
116	115	//! struct ProcEnumNFS41 - containts all NFSv4.1 procedures and operations

180	179	// Pleause, keep in mind that in all cases we suppose that NFSv4.1
181	180	// operation ILLEGAL(10044) has the second position in ProcEnumNFS41
182	181	};
183		static const unsigned int count {59}; //!< amount of procedures & operations together
184		static const unsigned int count_proc {2}; //!< amount of procedures
	182	static const unsigned int count{59}; //!< amount of procedures & operations together
	183	static const unsigned int count_proc{2}; //!< amount of procedures
185	184	};
186	185
187	186	} // namespace API
188	187	} // namespace NST
189	188	//------------------------------------------------------------------------------
190		#endif//NFS_TYPES_H
	189	#endif // NFS_TYPES_H
191	190	//------------------------------------------------------------------------------

-3

src/api/procedure.h less more

29	29	{
30	30	namespace API
31	31	{
32
33		template<typename ProcedureType>
	32	template <typename ProcedureType>
34	33	struct Procedure
35	34	{
36	35	ProcedureType call;

44	43	} // namespace API
45	44	} // namespace NST
46	45	//------------------------------------------------------------------------------
47		#endif//PROCEDURE_H
	46	#endif // PROCEDURE_H
48	47	//------------------------------------------------------------------------------

+40

-43

src/api/rpc_types.h less more

29	29	{
30	30	namespace API
31	31	{
32
33	32	using RPCProcedure = Procedure<struct rpc_msg>;
34	33
35	34	const uint32_t SUNRPC_MSG_VERSION = 2;
36	35
37	36	enum MsgType : int32_t
38	37	{
39		CALL =0,
40		REPLY=1
	38	CALL = 0,
	39	REPLY = 1
41	40	};
42	41
43	42	enum ReplyStat : int32_t
44	43	{
45		MSG_ACCEPTED=0,
46		MSG_DENIED =1
	44	MSG_ACCEPTED = 0,
	45	MSG_DENIED = 1
47	46	};
48	47
49	48	enum AcceptStat : int32_t
50	49	{
51		SUCCESS =0, /* RPC executed successfully */
52		PROG_UNAVAIL =1, /* remote hasn't exported program */
53		PROG_MISMATCH=2, /* remote can't support version # */
54		PROC_UNAVAIL =3, /* program can't support procedure */
55		GARBAGE_ARGS =4, /* procedure can't decode params */
56		SYSTEM_ERR =5 /* errors like memory allocation failure */
	50	SUCCESS = 0, /* RPC executed successfully */
	51	PROG_UNAVAIL = 1, /* remote hasn't exported program */
	52	PROG_MISMATCH = 2, /* remote can't support version # */
	53	PROC_UNAVAIL = 3, /* program can't support procedure */
	54	GARBAGE_ARGS = 4, /* procedure can't decode params */
	55	SYSTEM_ERR = 5 /* errors like memory allocation failure */
57	56	};
58	57
59	58	enum RejectStat : int32_t
60	59	{
61		RPC_MISMATCH =0, /* RPC version number != 2 */
62		AUTH_ERROR =1 /* remote can't authenticate caller */
	60	RPC_MISMATCH = 0, /* RPC version number != 2 */
	61	AUTH_ERROR = 1 /* remote can't authenticate caller */
63	62	};
64	63
65	64	// Status returned from authentication check
66	65	enum AuthStat : int32_t
67	66	{
68		AUTH_OK =0, /* success */
	67	AUTH_OK = 0, /* success */
69	68	/*
70	69	* failed at remote end
71	70	*/
72		AUTH_BADCRED =1, /* bad credential (seal broken) */
73		AUTH_REJECTEDCRED =2, /* client must begin new session */
74		AUTH_BADVERF =3, /* bad verifier (seal broken) */
75		AUTH_REJECTEDVERF =4, /* verifier expired or replayed */
76		AUTH_TOOWEAK =5, /* rejected for security reasons */
	71	AUTH_BADCRED = 1, /* bad credential (seal broken) */
	72	AUTH_REJECTEDCRED = 2, /* client must begin new session */
	73	AUTH_BADVERF = 3, /* bad verifier (seal broken) */
	74	AUTH_REJECTEDVERF = 4, /* verifier expired or replayed */
	75	AUTH_TOOWEAK = 5, /* rejected for security reasons */
77	76	/*
78	77	* failed locally
79	78	*/
80		SUNRPC_AUTH_INVALIDRESP =6, /* bogus response verifier */
81		SUNRPC_AUTH_FAILED =7, /* reason unknown */
	79	SUNRPC_AUTH_INVALIDRESP = 6, /* bogus response verifier */
	80	SUNRPC_AUTH_FAILED = 7, /* reason unknown */
82	81	/*
83	82	* AUTH_KERB errors; deprecated. See [RFC2695]
84	83	*/
85		AUTH_KERB_GENERIC = 8, /* kerberos generic error */
86		AUTH_TIMEEXPIRE = 9, /* time of credential expired */
87		AUTH_TKT_FILE = 10,/* problem with ticket file */
88		AUTH_DECODE = 11,/* can't decode authenticator */
89		AUTH_NET_ADDR = 12,/* wrong net address in ticket */
	84	AUTH_KERB_GENERIC = 8, /* kerberos generic error */
	85	AUTH_TIMEEXPIRE = 9, /* time of credential expired */
	86	AUTH_TKT_FILE = 10, /* problem with ticket file */
	87	AUTH_DECODE = 11, /* can't decode authenticator */
	88	AUTH_NET_ADDR = 12, /* wrong net address in ticket */
90	89	/*
91	90	* RPCSEC_GSS GSS related errors
92	91	*/
93		RPCSEC_GSS_CREDPROBLEM = 13,/* no credentials for user */
94		RPCSEC_GSS_CTXPROBLEM = 14 /* problem with context */
	92	RPCSEC_GSS_CREDPROBLEM = 13, /* no credentials for user */
	93	RPCSEC_GSS_CTXPROBLEM = 14 /* problem with context */
95	94	};
96	95
97	96	struct OpaqueAuth

108	107
109	108	struct RPCMessage
110	109	{
111		uint32_t xid;
	110	uint32_t xid;
112	111	uint32_t type;
113	112	};
114	113
115	114	struct RPCCall : public RPCMessage
116	115	{
117		uint32_t rpcvers;
118		uint32_t prog;
119		uint32_t vers;
120		uint32_t proc;
	116	uint32_t rpcvers;
	117	uint32_t prog;
	118	uint32_t vers;
	119	uint32_t proc;
121	120	OpaqueAuth cred;
122	121	OpaqueAuth verf;
123	122	};
124	123
125	124	struct AcceptedReply
126	125	{
127		OpaqueAuth verf;
128		uint32_t stat;
129		MismatchInfo mismatch_info;
	126	OpaqueAuth verf;
	127	uint32_t stat;
	128	MismatchInfo mismatch_info;
130	129	};
131	130
132	131	struct RejectedReply
133	132	{
134		uint32_t stat;
135		union U
136		{
	133	uint32_t stat;
	134	union U {
137	135	MismatchInfo mismatch_info;
138	136	OpaqueAuth auth_stat;
139	137	} u;

141	139
142	140	struct RPCReply : public RPCMessage
143	141	{
144		uint32_t stat;
145		union U
146		{
	142	uint32_t stat;
	143	union U {
147	144	AcceptedReply accepted;
148	145	RejectedReply rejected;
149	146	} u;

152	149	} // namespace API
153	150	} // namespace NST
154	151	//------------------------------------------------------------------------------
155		#endif//RPC_TYPES_H
	152	#endif // RPC_TYPES_H
156	153	//------------------------------------------------------------------------------

+16

-18

src/api/session.h less more

29	29	{
30	30	namespace API
31	31	{
32
33	32	struct Session
34	33	{
35	34	enum Direction
36	35	{
37		Source =0,
38		Destination =1,
39		Unknown =0xBAD
	36	Source = 0,
	37	Destination = 1,
	38	Unknown = 0xBAD
40	39	};
41	40
42	41	enum Type
43	42	{
44		TCP=0,
45		UDP=1
46		} type :16; // 16 bit for alignment following integers
	43	TCP = 0,
	44	UDP = 1
	45	} type : 16; // 16 bit for alignment following integers
47	46
48	47	enum IPType
49	48	{
50		v4=0,
51		v6=1
52		} ip_type:16; // 16 bit for alignment following integers
	49	v4 = 0,
	50	v6 = 1
	51	} ip_type : 16; // 16 bit for alignment following integers
53	52
54		in_port_t port[2]; // 2 ports in network byte order
	53	in_port_t port[2]; // 2 ports in network byte order
55	54
56		union IPAddress
57		{
58		struct // 2 IPv4 addresses in network byte order
	55	union IPAddress {
	56	struct // 2 IPv4 addresses in network byte order
59	57	{
60	58	in_addr_t addr[2];
61	59	} v4;
62		union // 2 IPv6 addresses in network byte order
	60	union // 2 IPv6 addresses in network byte order
63	61	{
64		uint8_t addr [2][16];
	62	uint8_t addr[2][16];
65	63	uint32_t addr_uint32[2][4];
66		} __attribute__ ((__packed__)) v6;
	64	} __attribute__((__packed__)) v6;
67	65	} ip;
68	66	};
69	67
70	68	} // namespace API
71	69	} // namespace NST
72	70	//------------------------------------------------------------------------------
73		#endif//SESSION_H
	71	#endif // SESSION_H
74	72	//------------------------------------------------------------------------------

-8

src/api/xdr_types.h less more

21	21	#ifndef XDR_TYPES_H
22	22	#define XDR_TYPES_H
23	23	//------------------------------------------------------------------------------
	24	#include <cstddef>
24	25	#include <cstdint>
25		#include <cstddef>
26	26	//------------------------------------------------------------------------------
27	27	namespace NST
28	28	{
29	29	namespace API
30	30	{
31
32	31	struct Opaque
33	32	{
34	33	inline void set(const uint8_t* p, uint32_t n)

38	37	}
39	38
40	39	inline uint8_t operator[](size_t i) const { return ptr[i]; }
41		inline const uint8_t* data() const { return ptr; }
42		inline uint32_t size() const { return len; }
43
44		const uint8_t* ptr;
45		uint32_t len;
	40	inline const uint8_t* data() const { return ptr; }
	41	inline uint32_t size() const { return len; }
	42	const uint8_t* ptr;
	43	uint32_t len;
46	44	};
47	45
48	46	} // namespace API
49	47	} // namespace NST
50	48	//------------------------------------------------------------------------------
51		#endif//XDR_TYPES_H
	49	#endif //XDR_TYPES_H
52	50	//------------------------------------------------------------------------------

-1

src/controller/build_info.h.in less more

30	30	constexpr char PROGRAM_BUILD_INFO[]=
31	31	"@NST_VERSION_FULL@\n"
32	32	"built on @CMAKE_SYSTEM@\n"
33		"by C++ compiler @CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPILER_VERSION@";
	33	"by C++ compiler @CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPILER_VERSION@ on @COMPILATION_DATE@";
34	34
35	35	constexpr char MODULES_DIRECTORY_PATH[] = "@CMAKE_INSTALL_PREFIX@/lib/nfstrace/";
36	36

-3

src/controller/cmdline_args.cpp less more

20	20	//------------------------------------------------------------------------------
21	21	#include "controller/cmdline_args.h"
22	22	//------------------------------------------------------------------------------
23		#define LIVE "live"
24		#define DUMP "dump"
25		#define STAT "stat"
	23	#define LIVE "live"
	24	#define DUMP "dump"
	25	#define STAT "stat"
26	26	#define DRAIN "drain"
27	27	//------------------------------------------------------------------------------
28	28	namespace NST

31	31	{
32	32	namespace cmdline
33	33	{
	34	// clang-format off
34	35
35	36	const char* const Args::profiling_mode {LIVE};
36	37	const char* const Args::dumping_mode {DUMP};

63	64	{'h', "help", Opt::NOA, "false", "print help message and usage for modules passed with -a options, then exit", nullptr, nullptr, false}
64	65	};
65	66
	67	// clang-format on
	68
66	69	} // namespace cmdline
67	70	} // namespace controller
68	71	} // namespace NST

-2

src/controller/cmdline_args.h less more

29	29	{
30	30	namespace cmdline
31	31	{
32
33	32	struct Args
34	33	{
35	34	friend class CmdlineParser<Args>;

64	63	static const char* const dumping_mode;
65	64	static const char* const analysis_mode;
66	65	static const char* const draining_mode;
	66
67	67	private:
68	68	static Opt options[num];
69	69

74	74	} // namespace controller
75	75	} // namespace NST
76	76	//------------------------------------------------------------------------------
77		#endif//CMDLINE_PARSER_H
	77	#endif // CMDLINE_PARSER_H
78	78	//------------------------------------------------------------------------------

+33

-31

src/controller/cmdline_parser.h less more

36	36	{
37	37	namespace cmdline
38	38	{
39
40	39	class CLIError : public std::runtime_error
41	40	{
42	41	public:
43		explicit CLIError(const std::string& msg) : std::runtime_error{msg} { }
	42	explicit CLIError(const std::string& msg)
	43	: std::runtime_error{msg}
	44	{
	45	}
44	46	};
45	47
46	48	struct Opt
47	49	{
	50	// clang-format off
48	51	class Value
49	52	{
50	53	public:

73	76	const char* value_pattern;
74	77	const char* value;
75	78	bool passed; // is option parsed
	79
	80	// clang-format on
76	81	};
77
78	82
79	83	template <typename CLI>
80	84	class CmdlineParser
81	85	{
82	86	public:
83		CmdlineParser() = default;
84		virtual ~CmdlineParser() = default;
85		CmdlineParser(const CmdlineParser&) = delete;
86		CmdlineParser& operator=(const CmdlineParser&) = delete;
	87	CmdlineParser() = default;
	88	virtual ~CmdlineParser() = default;
	89	CmdlineParser(const CmdlineParser&) = delete;
	90	CmdlineParser& operator=(const CmdlineParser&) = delete;
87	91
88	92	void parse(int argc, char** argv);
89	93	void validate();

101	105	static bool is_default(typename CLI::Names name)
102	106	{
103	107	const Opt& a = CLI::options[name];
104		return a.value == a.deflt; // compare pointers
	108	return a.value == a.deflt; // compare pointers
105	109	}
106	110
107	111	static void print_usage(std::ostream& out, const char* executable);
108	112
109	113	private:
110		virtual void set_multiple_value(int /index/, char const /v*/){}
111
112		void set_value(int index, char *const v)
	114	virtual void set_multiple_value(int /index/, char* const /v/) {}
	115	void set_value(int index, char* const v)
113	116	{
114	117	Opt& a = CLI::options[index];
115	118	// if option argument specified - set it otherwise
116	119	// set valid default OR "true" for no-args options
117		a.value = v ? v : (a.deflt && a.type != Opt::Type::NOA ? a.deflt : "true");
	120	a.value = v ? v : (a.deflt && a.type != Opt::Type::NOA ? a.deflt : "true");
118	121	a.passed = true;
119	122
120	123	if(a.type == Opt::Type::MUL)

127	130	{
128	131	if(short_name)
129	132	{
130		return { '\'', '-', short_name, '\'' };
	133	return {'\'', '-', short_name, '\''};
131	134	}
132	135	return std::string{'\''} + long_name + '\'';
133	136	}

150	153	{
151	154	// generate input data for getopt_long()
152	155	option long_opts[CLI::num + 1]; // +1 for NULL-option
153		char short_opts[CLI::num * 2 + 2] = {0};
	156	char short_opts[CLI::num * 2 + 2] = {0};
154	157
155	158	short_opts[0] = ':';
156	159
157		char *short_p = &short_opts[1];
158		for (int i = 0; i < CLI::num; ++i)
	160	char* short_p = &short_opts[1];
	161	for(int i = 0; i < CLI::num; ++i)
159	162	{
160	163	const Opt& a = CLI::options[i];
161	164

199	202
200	203	case '?':
201	204	{
202		std::string unkn{ build_name(optopt, argv[optind-1]) };
	205	std::string unkn{build_name(optopt, argv[optind - 1])};
203	206	throw CLIError{std::string{"Unrecognized option: "} + unkn};
204	207	}
205	208
206	209	case ':':
207	210	{
208		std::string miss{ build_name(optopt, argv[optind-1]) };
	211	std::string miss{build_name(optopt, argv[optind - 1])};
209	212	throw CLIError{std::string{"Option requires an argument: "} + miss};
210	213	}
211	214

225	228	if(optind != argc)
226	229	{
227	230	// quote non-option
228		std::string name{ build_name(0, argv[optind]) };
229		throw CLIError{std::string{"Unexpected operand on command line: "}
230		+ name};
	231	std::string name{build_name(0, argv[optind])};
	232	throw CLIError{std::string{"Unexpected operand on command line: "} + name};
231	233	}
232	234
233	235	// set default values
234	236	for(Opt& o : CLI::options)
235	237	{
236		if(o.value == nullptr // is value still uninitialized?
237		&& o.deflt != nullptr) // try to substitute by default value
238		{
239		o.value = o.deflt;
	238	if(o.value == nullptr // is value still uninitialized?
	239	&& o.deflt != nullptr) // try to substitute by default value
	240	{
	241	o.value = o.deflt;
240	242	o.passed = false;
241	243	}
242	244	}

250	252	{
251	253	if(o.value == nullptr) // is value still uninitialized?
252	254	{
253		std::string lopt{ o.long_opt ? std::string("--") + o.long_opt : ""};
254		std::string name{ build_name(o.short_opt, lopt) };
	255	std::string lopt{o.long_opt ? std::string("--") + o.long_opt : ""};
	256	std::string name{build_name(o.short_opt, lopt)};
255	257	throw CLIError{std::string{"Missing required option: "} + name};
256	258	}
257	259	}

270	272
271	273	if(o.short_opt) // print out short key
272	274	{
273		char tmp[]{ '-', o.short_opt, ' ', '\0' };
	275	char tmp[]{'-', o.short_opt, ' ', '\0'};
274	276	if(o.long_opt) tmp[2] = ',';
275		s_opt = std::string{" "} + tmp; //indentation
	277	s_opt = std::string{" "} + tmp; //indentation
276	278	}
277	279	if(o.long_opt) // print out long key
278	280	{

308	310	} // namespace controller
309	311	} // namespace NST
310	312	//------------------------------------------------------------------------------
311		#endif//CMDLINE_PARSER_H
312		//------------------------------------------------------------------------------
	313	#endif // CMDLINE_PARSER_H
	314	//------------------------------------------------------------------------------

+34

-33

src/controller/controller.cpp less more

25	25	#include <sys/types.h>
26	26	#include <unistd.h>
27	27
28		#include "utils/filtered_data.h"
29	28	#include "controller/controller.h"
30	29	#include "controller/parameters.h"
	30	#include "utils/filtered_data.h"
31	31	//------------------------------------------------------------------------------
32	32	namespace NST
33	33	{
34	34	namespace controller
35	35	{
36
	36	// clang-format off
37	37	Controller::Running::Running(Controller& i)
38	38	: controller(i)
39	39	{

56	56	controller.analysis->stop();
57	57	}
58	58	}
59
	59	// clang-format off
60	60	Controller::Controller(const Parameters& params) try
61	61	: gout {utils::Out::Level(params.verbose_level())}
62	62	, glog {params.log_path()}

64	64	, analysis {}
65	65	, filtration {new FiltrationManager{status}}
66	66	{
	67	// clang-format on
67	68	switch(params.running_mode())
68	69	{
69		case RunningMode::Profiling:
70		{
71		analysis.reset(new AnalysisManager{status, params});
72		if(analysis->isSilent())
73		utils::Out::Global::set_level(utils::Out::Level::Silent);
74
75		filtration->add_online_analysis(params, analysis->get_queue());
76		}
77		break;
78		case RunningMode::Dumping:
79		{
80		filtration->add_online_dumping(params);
81		}
82		break;
83		case RunningMode::Analysis:
84		{
85		analysis.reset(new AnalysisManager{status, params});
86		if(analysis->isSilent())
87		utils::Out::Global::set_level(utils::Out::Level::Silent);
88
89		filtration->add_offline_analysis(params.input_file(),
90		analysis->get_queue());
91		}
92		break;
93		case RunningMode::Draining:
94		{
95		filtration->add_offline_dumping(params);
96		}
97		break;
	70	case RunningMode::Profiling:
	71	{
	72	analysis.reset(new AnalysisManager{status, params});
	73	if(analysis->isSilent())
	74	utils::Out::Global::set_level(utils::Out::Level::Silent);
	75
	76	filtration->add_online_analysis(params, analysis->get_queue());
	77	}
	78	break;
	79	case RunningMode::Dumping:
	80	{
	81	filtration->add_online_dumping(params);
	82	}
	83	break;
	84	case RunningMode::Analysis:
	85	{
	86	analysis.reset(new AnalysisManager{status, params});
	87	if(analysis->isSilent())
	88	utils::Out::Global::set_level(utils::Out::Level::Silent);
	89
	90	filtration->add_offline_analysis(params.input_file(),
	91	analysis->get_queue());
	92	}
	93	break;
	94	case RunningMode::Draining:
	95	{
	96	filtration->add_offline_dumping(params);
	97	}
	98	break;
98	99	}
99	100	droproot(params.dropuser());
100	101	}

187	188	}
188	189	else if(!dropuser.empty())
189	190	{
190		struct passwd *pw = getpwnam(dropuser.c_str()); //get user uid & gid
	191	struct passwd* pw = getpwnam(dropuser.c_str()); //get user uid & gid
191	192
192	193	if(!pw)
193	194	{

+11

-11

src/controller/controller.h less more

25	25	#include <memory>
26	26
27	27	#include "analysis/analysis_manager.h"
28		#include "filtration/filtration_manager.h"
29	28	#include "controller/parameters.h"
30	29	#include "controller/running_status.h"
31	30	#include "controller/signal_handler.h"
	31	#include "filtration/filtration_manager.h"
32	32	#include "utils/log.h"
33	33	#include "utils/out.h"
34	34	//------------------------------------------------------------------------------

36	36	{
37	37	namespace controller
38	38	{
39
40	39	class ControllerError : public std::runtime_error
41	40	{
42	41	public:
43		explicit ControllerError(const std::string& msg) : std::runtime_error{msg} { }
	42	explicit ControllerError(const std::string& msg)
	43	: std::runtime_error{msg}
	44	{
	45	}
44	46	};
45	47
46	48	class Controller

52	54	{
53	55	public:
54	56	inline Running(Controller&);
55		Running() = delete;
56		Running(const Running&) = delete;
57		Running& operator=(const Running&) = delete;
	57	Running() = delete;
	58	Running(const Running&) = delete;
	59	Running& operator=(const Running&) = delete;
58	60	inline ~Running();
	61
59	62	private:
60	63	Controller& controller;
61	64	};
62	65
63	66	public:
64
65	67	Controller(const Parameters&);
66		Controller(const Controller&) = delete;
	68	Controller(const Controller&) = delete;
67	69	Controller& operator=(const Controller&) = delete;
68	70	~Controller();
69	71
70	72	int run();
71	73
72	74	private:
73
74	75	// initializer for global outptut
75	76	utils::Out::Global gout;
76	77	// initializer for global logger

85	86	// controller subsystems
86	87	std::unique_ptr<AnalysisManager> analysis;
87	88	std::unique_ptr<FiltrationManager> filtration;
88
89	89	};
90	90
91	91	/*! Drop root privileges

100	100	} // namespace controller
101	101	} // namespace NST
102	102	//------------------------------------------------------------------------------
103		#endif//CONTROLLER_H
	103	#endif // CONTROLLER_H
104	104	//------------------------------------------------------------------------------

+35

-40

src/controller/parameters.cpp less more

24	24	#include <unistd.h>
25	25
26	26	#include "analysis/plugin.h"
	27	#include "controller/build_info.h"
27	28	#include "controller/cmdline_args.h"
28	29	#include "controller/cmdline_parser.h"
29	30	#include "controller/parameters.h"
30		#include "controller/build_info.h"
31	31	#include "filtration/pcap/network_interfaces.h"
32	32	//------------------------------------------------------------------------------
33	33	namespace NST
34	34	{
35	35	namespace controller
36	36	{
37
38	37	namespace // implementation
39	38	{
40
41	39	static const class ParametersImpl* impl = nullptr;
42	40
43	41	using CLI = NST::controller::cmdline::Args;

47	45	friend class NST::controller::Parameters;
48	46
49	47	ParametersImpl(int argc, char** argv)
50		: rpc_message_limit{0}
	48	: rpc_message_limit{0}
51	49	{
52	50	parse(argc, argv);
53	51	if(get(CLI::ArgHelp).to_bool())

57	55
58	56	for(const auto& a : analysis_modules)
59	57	{
60		const std::string& path {a.path};
	58	const std::string& path{a.path};
61	59	try
62	60	{
63	61	std::cout << "Usage of " << path << ":\n";

83	81	std::cout << i << '\n';
84	82	for(auto a : i) std::cout << '\t' << a << '\n';
85	83	}
86		std::cout << "[default]: " << interfaces.default_device() << '\n';
	84	std::cout << "[default]: " << interfaces.default_device() << '\n';
87	85	}
88	86	else
89	87	{
90	88	std::cerr << "Note: Reading list of network interfaces may "
91		"require that you have special privileges." << std::endl;
	89	"require that you have special privileges."
	90	<< std::endl;
92	91	}
93	92	}
94	93
95	94	if(get(CLI::ArgEnum).is("-") \|\| get(CLI::ArgEnum).is("plugins"))
96	95	{
97	96	std::cout << "\nAvailable plugins:" << std::endl;
98		DIR *dir;
	97	DIR* dir;
99	98
100	99	if((dir = opendir(MODULES_DIRECTORY_PATH)) != nullptr)
101	100	{
102		struct dirent *ent;
	101	struct dirent* ent;
103	102	while((ent = readdir(dir)) != nullptr)
104	103	{
105		std::string full_path = std::string{MODULES_DIRECTORY_PATH}
106		+ ent->d_name;
	104	std::string full_path = std::string{MODULES_DIRECTORY_PATH} + ent->d_name;
107	105	std::string plugin_usage;
108	106	try
109	107	{

113	111	std::cout << plugin_usage << std::endl;
114	112	std::cout << std::endl;
115	113	}
116		catch(std::runtime_error& e) { }
	114	catch(std::runtime_error& e)
	115	{
	116	}
117	117	}
118	118	closedir(dir);
119	119	}
120	120	else
121	121	{
122		std::cerr << "Error: Can't access " << MODULES_DIRECTORY_PATH <<std::endl;
	122	std::cerr << "Error: Can't access " << MODULES_DIRECTORY_PATH << std::endl;
123	123	}
124	124	}
125	125

127	127
128	128	// cashed values
129	129	const std::string program_path(argv[0]);
130		size_t found {program_path.find_last_of("/\\")};
131		program = program_path.substr(found+1);
132
133		const int limit {get(CLI::ArgMSize).to_int()};
	130	size_t found{program_path.find_last_of("/\\")};
	131	program = program_path.substr(found + 1);
	132
	133	const int limit{get(CLI::ArgMSize).to_int()};
134	134	if(limit < 1 \|\| limit > 4000)
135	135	{
136	136	throw cmdline::CLIError{std::string{"Invalid limit of RPC messages: "} + get(CLI::ArgMSize).to_cstr()};

138	138
139	139	rpc_message_limit = limit;
140	140	}
141		virtual ~ParametersImpl(){}
142		ParametersImpl(const ParametersImpl&) = delete;
	141	virtual ~ParametersImpl() {}
	142	ParametersImpl(const ParametersImpl&) = delete;
143	143	ParametersImpl& operator=(const ParametersImpl&) = delete;
144	144
145	145	protected:
146		void set_multiple_value(int index, char *const v) override
	146	void set_multiple_value(int index, char* const v) override
147	147	{
148	148	if(index == CLI::ArgAnalyzers) // may have multiple values
149	149	{
150	150	const std::string arg{v};
151		size_t ind {arg.find('#')};
	151	size_t ind{arg.find('#')};
152	152	if(ind == std::string::npos)
153	153	{
154	154	analysis_modules.emplace_back(path_to_pam(arg));

166	166	std::string default_iofile() const
167	167	{
168	168	// create string: PROGRAMNAME-BPF-FILTER.pcap
169		std::string str { impl->program };
	169	std::string str{impl->program};
170	170	str.push_back('-');
171	171	str.append(get(CLI::ArgFilter).to_cstr());
172	172	str.append(".pcap");

190	190	}
191	191
192	192	// cashed values
193		unsigned short rpc_message_limit;
194		std::string program; // name of program in command line
	193	unsigned short rpc_message_limit;
	194	std::string program; // name of program in command line
195	195	std::vector<AParams> analysis_modules;
196	196	};
197	197

268	268	const int capacity = impl->get(CLI::ArgQSize).to_int();
269	269	if(capacity < 1 \|\| capacity > 65535)
270	270	{
271		throw cmdline::CLIError(std::string{"Invalid value of queue capacity: "}
272		+ impl->get(CLI::ArgQSize).to_cstr());
	271	throw cmdline::CLIError(std::string{"Invalid value of queue capacity: "} + impl->get(CLI::ArgQSize).to_cstr());
273	272	}
274	273
275	274	return capacity;

289	288	const Parameters::CaptureParams Parameters::capture_params() const
290	289	{
291	290	Parameters::CaptureParams params;
292		params.interface = impl->get(CLI::ArgInterface);
293		params.filter = impl->get(CLI::ArgFilter);
294		params.snaplen = impl->get(CLI::ArgSnaplen).to_int();
295		params.timeout_ms = impl->get(CLI::ArgTimeout).to_int();
296		params.buffer_size = impl->get(CLI::ArgBSize).to_int() * 1024 * 1024; // MBytes
297		params.promisc = impl->get(CLI::ArgPromisc).to_bool();
	291	params.interface = impl->get(CLI::ArgInterface);
	292	params.filter = impl->get(CLI::ArgFilter);
	293	params.snaplen = impl->get(CLI::ArgSnaplen).to_int();
	294	params.timeout_ms = impl->get(CLI::ArgTimeout).to_int();
	295	params.buffer_size = impl->get(CLI::ArgBSize).to_int() * 1024 * 1024; // MBytes
	296	params.promisc = impl->get(CLI::ArgPromisc).to_bool();
298	297
299	298	// check interface
300	299	if(impl->is_default(CLI::ArgInterface))

305	304	// check capture buffer size
306	305	if(params.buffer_size < 1024 * 1024) // less than 1 MBytes
307	306	{
308		throw cmdline::CLIError{std::string{"Invalid value of kernel buffer size: "}
309		+ impl->get(CLI::ArgBSize).to_cstr()};
	307	throw cmdline::CLIError{std::string{"Invalid value of kernel buffer size: "} + impl->get(CLI::ArgBSize).to_cstr()};
310	308	}
311	309
312	310	// check max length of raw captured UDP packet
313	311	if(params.snaplen < 1 \|\| params.snaplen > 65535)
314	312	{
315		throw cmdline::CLIError{std::string{"Invalid value of max length of raw captured UDP packet: "}
316		+ impl->get(CLI::ArgSnaplen).to_cstr()};
	313	throw cmdline::CLIError{std::string{"Invalid value of max length of raw captured UDP packet: "} + impl->get(CLI::ArgSnaplen).to_cstr()};
317	314	}
318	315
319	316	// check the read timeout that will be used on a capture
320	317	if(params.timeout_ms < 1)
321	318	{
322		throw cmdline::CLIError{std::string{"Invalid value of read timeout that will be used on a capture: "}
323		+ impl->get(CLI::ArgTimeout).to_cstr()};
	319	throw cmdline::CLIError{std::string{"Invalid value of read timeout that will be used on a capture: "} + impl->get(CLI::ArgTimeout).to_cstr()};
324	320	}
325	321
326	322	// check and set capture direction

339	335	}
340	336	else
341	337	{
342		throw cmdline::CLIError{std::string{"Unknown capturing direction: "}
343		+ direction.to_cstr()};
	338	throw cmdline::CLIError{std::string{"Unknown capturing direction: "} + direction.to_cstr()};
344	339	}
345	340
346	341	return params;

+25

-18

src/controller/parameters.h less more

31	31	{
32	32	namespace controller
33	33	{
34
35	34	enum class RunningMode
36	35	{
37	36	Profiling,

42	41
43	42	struct AParams
44	43	{
45		AParams(const std::string& p) : path{p}, args{} {}
46		AParams(const std::string& p, const std::string& a) : path{p}, args{a} {}
	44	AParams(const std::string& p)
	45	: path{p}
	46	, args{}
	47	{
	48	}
	49	AParams(const std::string& p, const std::string& a)
	50	: path{p}
	51	, args{a}
	52	{
	53	}
47	54
48	55	const std::string path;
49	56	const std::string args;

53	60	*/
54	61	enum class NetProtocol
55	62	{
56		NFS = 0x01, //!< NFS protocol
57		CIFS = 0x02 //!< CIFS protocol
	63	NFS = 0x01, //!< NFS protocol
	64	CIFS = 0x02 //!< CIFS protocol
58	65	};
59	66
60	67	class Parameters

67	74	Parameters(int argc, char** argv);
68	75	~Parameters();
69	76
70		Parameters(const Parameters&) = delete;
	77	Parameters(const Parameters&) = delete;
71	78	Parameters& operator=(const Parameters&) = delete;
72	79
73	80	bool show_help() const;
74	81	bool show_enum() const;
75	82
76	83	// access helpers
77		const std::string& program_name() const;
78		RunningMode running_mode() const;
79		std::string input_file() const;
80		const std::string dropuser() const;
81		const std::string log_path() const;
82		unsigned short queue_capacity() const;
83		bool trace() const;
84		int verbose_level() const;
85		const CaptureParams capture_params() const;
86		const DumpingParams dumping_params() const;
	84	const std::string& program_name() const;
	85	RunningMode running_mode() const;
	86	std::string input_file() const;
	87	const std::string dropuser() const;
	88	const std::string log_path() const;
	89	unsigned short queue_capacity() const;
	90	bool trace() const;
	91	int verbose_level() const;
	92	const CaptureParams capture_params() const;
	93	const DumpingParams dumping_params() const;
87	94	const std::vector<AParams>& analysis_modules() const;
88		static unsigned short rpcmsg_limit();
	95	static unsigned short rpcmsg_limit();
89	96	};
90	97
91	98	} // namespace controller
92	99	} // namespace NST
93	100	//------------------------------------------------------------------------------
94		#endif//PARAMETERS_H
	101	#endif // PARAMETERS_H
95	102	//------------------------------------------------------------------------------

+34

-32

src/controller/running_status.h less more

21	21	#ifndef RUNNING_STATUS_H
22	22	#define RUNNING_STATUS_H
23	23	//------------------------------------------------------------------------------
24		#include <condition_variable>
25	24	#include <exception>
26	25	#include <iostream>
27	26	#include <list>
28	27	#include <mutex>
	28	#include <condition_variable>
29	29	#include <type_traits>
30	30	//------------------------------------------------------------------------------
31	31	namespace NST
32	32	{
33	33	namespace controller
34	34	{
35
36	35	class ProcessingDone : public std::runtime_error
37	36	{
38	37	public:
39		explicit ProcessingDone(const std::string& in) : std::runtime_error{in} { }
	38	explicit ProcessingDone(const std::string& in)
	39	: std::runtime_error{in}
	40	{
	41	}
40	42	};
41	43
42	44	class RunningStatus
43	45	{
44	46	public:
45		RunningStatus() = default;
46		RunningStatus(const RunningStatus&) = delete;
	47	RunningStatus() = default;
	48	RunningStatus(const RunningStatus&) = delete;
47	49	RunningStatus& operator=(const RunningStatus&) = delete;
48	50
49	51	template <typename ExceptionType>

62	64	std::exception_ptr wait_exception()
63	65	{
64	66	std::unique_lock<std::mutex> lock(mutex);
65		while(fifo.empty())
66		{
67		condition.wait(lock);
68		}
69		std::exception_ptr e = fifo.front();
70		fifo.pop_front();
71		return e;
	67	while(fifo.empty())
	68	{
	69	condition.wait(lock);
	70	}
	71	std::exception_ptr e = fifo.front();
	72	fifo.pop_front();
	73	return e;
72	74	}
73	75
74	76	void wait_and_rethrow_exception()

80	82	void print(std::ostream& out)
81	83	{
82	84	std::unique_lock<std::mutex> lock(mutex);
83		if(!fifo.empty())
	85	if(!fifo.empty())
	86	{
	87	out << "list of unhandled exceptions:" << std::endl;
	88	for(auto& e : fifo)
84	89	{
85		out << "list of unhandled exceptions:" << std::endl;
86		for(auto& e : fifo)
	90	try
87	91	{
88		try
89		{
90		std::rethrow_exception(e);
91		}
92		catch(const std::exception& e)
93		{
94		out << '\t' << e.what() << std::endl;
95		}
96		catch(...)
97		{
98		out << '\t' << "Unknown exception" << std::endl;
99		}
	92	std::rethrow_exception(e);
	93	}
	94	catch(const std::exception& e)
	95	{
	96	out << '\t' << e.what() << std::endl;
	97	}
	98	catch(...)
	99	{
	100	out << '\t' << "Unknown exception" << std::endl;
100	101	}
101	102	}
	103	}
102	104	}
103	105
104	106	private:

106	108	{
107	109	if(e == nullptr) return;
108	110	std::unique_lock<std::mutex> lock(mutex);
109		fifo.emplace_front(e);
110		condition.notify_one();
	111	fifo.emplace_front(e);
	112	condition.notify_one();
111	113	}
112	114
113	115	std::list<std::exception_ptr> fifo;
114		std::mutex mutex;
115		std::condition_variable condition;
	116	std::mutex mutex;
	117	std::condition_variable condition;
116	118	};
117	119
118	120	} // namespace controller
119	121	} // namespace NST
120	122	//------------------------------------------------------------------------------
121		#endif//RUNNING_STATUS_H
	123	#endif // RUNNING_STATUS_H
122	124	//------------------------------------------------------------------------------

+19

-19

src/controller/signal_handler.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <cerrno>
22		#include <functional> // std::ref
	22	#include <functional> // std::ref
23	23	#include <system_error>
24	24
25		#include <unistd.h>
26	25	#include <pthread.h>
27	26	#include <signal.h>
28		#include <string.h> // for strsignal()
	27	#include <string.h> // for strsignal()
	28	#include <unistd.h>
29	29
30	30	#include <sys/wait.h>
31	31

35	35	{
36	36	namespace controller
37	37	{
38
39	38	SignalHandler::Signal::Signal(int sig)
40		: std::runtime_error{::strsignal(sig)}
41		, signal_number{sig}
	39	: std::runtime_error{::strsignal(sig)}
	40	, signal_number{sig}
42	41	{
43	42	}
44	43

49	48	{
50	49	while(running.test_and_set())
51	50	{
52		int signo {0};
53		const int err {::sigwait(&waitmask, &signo)};
	51	int signo{0};
	52	const int err{::sigwait(&waitmask, &signo)};
54	53	if(err != 0)
55	54	{
56	55	status.push(std::system_error{err, std::system_category(),

61	60	if(signo == SIGCHLD)
62	61	{
63	62	// wait childern(compression in dumping mode may call fork())
64		const pid_t pid {::wait(nullptr)};
	63	const pid_t pid{::wait(nullptr)};
65	64	if(pid == -1 && errno != ECHILD)
66	65	{
67	66	status.push(std::system_error{errno, std::system_category(),

75	74	}
76	75	}
77	76
78		static void dummy(int) {}
	77	static void dummy(int)
	78	{
	79	}
79	80
80	81	SignalHandler::SignalHandler(RunningStatus& s)
81		: handler{}
82		, running{ATOMIC_FLAG_INIT} // false
	82	: handler{}
	83	, running{ATOMIC_FLAG_INIT} // false
83	84	{
84	85	// set dummy handler for SIGCHLD to prevent ignoring it
85	86	// in ::sigwait() on FreeBSD by default

94	95
95	96	sigset_t mask;
96	97	::sigemptyset(&mask);
97		::sigaddset(&mask, SIGINT); // correct exit from program by Ctrl-C
98		::sigaddset(&mask, SIGTERM); // correct exit when SIGTERM has been received
99		::sigaddset(&mask, SIGCHLD); // stop sigwait-thread and wait children
100		::sigaddset(&mask, SIGHUP); // signal for losing terminal
101		::sigaddset(&mask, SIGWINCH); // signal for changing terminal size
	98	::sigaddset(&mask, SIGINT); // correct exit from program by Ctrl-C
	99	::sigaddset(&mask, SIGTERM); // correct exit when SIGTERM has been received
	100	::sigaddset(&mask, SIGCHLD); // stop sigwait-thread and wait children
	101	::sigaddset(&mask, SIGHUP); // signal for losing terminal
	102	::sigaddset(&mask, SIGWINCH); // signal for changing terminal size
102	103	const int err = ::pthread_sigmask(SIG_BLOCK, &mask, nullptr);
103	104	if(err != 0)
104	105	{
105	106	throw std::system_error(err, std::system_category(),
106		"error in SignalHandler pthread_sigmask");
	107	"error in SignalHandler pthread_sigmask");
107	108	}
108	109
109	110	running.test_and_set();

120	121	} // namespace controller
121	122	} // namespace NST
122	123	//------------------------------------------------------------------------------
123

-4

src/controller/signal_handler.h less more

31	31	{
32	32	namespace controller
33	33	{
34
35	34	class SignalHandler
36	35	{
37	36	public:

43	42	};
44	43
45	44	SignalHandler(RunningStatus&);
46		SignalHandler(const SignalHandler&) = delete;
	45	SignalHandler(const SignalHandler&) = delete;
47	46	SignalHandler& operator=(const SignalHandler&) = delete;
48	47	~SignalHandler();
49	48
50	49	private:
51		std::thread handler;
	50	std::thread handler;
52	51	std::atomic_flag running;
53	52	};
54	53
55	54	} // namespace controller
56	55	} // namespace NST
57	56	//------------------------------------------------------------------------------
58		#endif//SIGNAL_HANDLER_H
	57	#endif // SIGNAL_HANDLER_H
59	58	//------------------------------------------------------------------------------

+15

-19

src/filtration/cifs_filtrator.h less more

26	26
27	27	#include <pcap/pcap.h>
28	28
29		#include "filtration/packet.h"
	29	#include "api/cifs2_commands.h"
30	30	#include "filtration/filtratorimpl.h"
31	31	#include "protocols/cifs/cifs.h"
32	32	#include "protocols/cifs2/cifs2.h"
33	33	#include "protocols/netbios/netbios.h"
34	34	#include "utils/log.h"
35		#include "api/cifs2_commands.h"
36	35	//------------------------------------------------------------------------------
37	36	namespace NST
38	37	{
39	38	namespace filtration
40	39	{
41
42	40	using SMBv2Commands = NST::API::SMBv2::SMBv2Commands;
43	41
44		template<typename Writer>
	42	template <typename Writer>
45	43	class CIFSFiltrator : public FiltratorImpl<CIFSFiltrator<Writer>, Writer>
46	44	{
47	45	using BaseImpl = FiltratorImpl<CIFSFiltrator<Writer>, Writer>;
48		size_t rw_hdr_max {512}; // limit for SMB header to truncate messages
	46	size_t rw_hdr_max{512}; // limit for SMB header to truncate messages
49	47	public:
50
51	48	CIFSFiltrator()
52	49	: BaseImpl()
53	50	{

98	95	{
99	96	size_t length = 0;
100	97	if(collection && collection.data_size() >= lengthOfBaseHeader())
101		{ //enough data is copied from previous packets to see its type
	98	{ //enough data is copied from previous packets to see its type
102	99	if(isCIFSV1Header(collection.data()))
103	100	{
104	101	length = sizeof(NetBIOS::MessageHeader) + sizeof(CIFSv1::RawMessageHeader);

108	105	length = sizeof(NetBIOS::MessageHeader) + sizeof(CIFSv2::RawMessageHeader);
109	106	}
110	107	else
111		{ //got header but it is not CIFS
112		collection.reset();//dismiss copied data
113		info.dlen = 0;//skip entire packet
	108	{ //got header but it is not CIFS
	109	collection.reset(); //dismiss copied data
	110	info.dlen = 0; //skip entire packet
114	111	return false;
115	112	}
116	113	return BaseImpl::collect_header(info, length, length);
117	114	}
118		BaseImpl::collect_header(info, lengthOfBaseHeader(), lengthOfBaseHeader());//try to read base header
119		return false;//continue to read full header
	115	BaseImpl::collect_header(info, lengthOfBaseHeader(), lengthOfBaseHeader()); //try to read base header
	116	return false; //continue to read full header
120	117	}
121	118
122	119	inline bool find_and_read_message(PacketInfo& info, typename Writer::Collection& collection)
123	120	{
124		if (const NetBIOS::MessageHeader* nb_header = NetBIOS::get_header(collection.data()))
	121	if(const NetBIOS::MessageHeader* nb_header = NetBIOS::get_header(collection.data()))
125	122	{
126	123	const size_t length = nb_header->len() + sizeof(NetBIOS::MessageHeader);
127		if (const CIFSv1::MessageHeader* header = CIFSv1::get_header(collection.data() + sizeof(NetBIOS::MessageHeader)))
	124	if(const CIFSv1::MessageHeader* header = CIFSv1::get_header(collection.data() + sizeof(NetBIOS::MessageHeader)))
128	125	{
129	126	BaseImpl::setMsgLen(length);
130	127	set_msg_size(header, length);
131	128	return BaseImpl::read_message(info);
132	129	}
133		else if (const CIFSv2::MessageHeader* header = CIFSv2::get_header(collection.data() + sizeof(NetBIOS::MessageHeader)))
	130	else if(const CIFSv2::MessageHeader* header = CIFSv2::get_header(collection.data() + sizeof(NetBIOS::MessageHeader)))
134	131	{
135	132	BaseImpl::setMsgLen(length);
136	133	set_msg_size(header, length);

143	140	private:
144	141	inline void set_msg_size(const CIFSv1::MessageHeader* header, const size_t length)
145	142	{
146		if ((header->cmd_code == CIFSv1::Commands::READ) \|\| (header->cmd_code == CIFSv1::Commands::WRITE))
	143	if((header->cmd_code == CIFSv1::Commands::READ) \|\| (header->cmd_code == CIFSv1::Commands::WRITE))
147	144	{
148	145	return BaseImpl::setToBeCopied(std::min(length, rw_hdr_max));
149	146	}

152	149
153	150	inline void set_msg_size(const CIFSv2::MessageHeader* header, const size_t length)
154	151	{
155		if (((header->cmd_code == SMBv2Commands::READ) \|\| (header->cmd_code == SMBv2Commands::WRITE)) && !header->nextCommand)
	152	if(((header->cmd_code == SMBv2Commands::READ) \|\| (header->cmd_code == SMBv2Commands::WRITE)) && !header->nextCommand)
156	153	{
157	154	return BaseImpl::setToBeCopied(std::min(length, rw_hdr_max));
158	155	}
159	156	BaseImpl::setToBeCopied(length);
160	157	}
161
162	158	};
163	159
164	160	} // namespace filtration
165	161	} // namespace NST
166	162	//------------------------------------------------------------------------------
167		#endif//CIFS_FILTRATOR_H
	163	#endif // CIFS_FILTRATOR_H
168	164	//------------------------------------------------------------------------------

+17

-19

src/filtration/dumping.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <cerrno>
22		#include <exception> // std::terminate()
	22	#include <exception> // std::terminate()
23	23	#include <vector>
24	24
25	25	#include <unistd.h>

30	30	{
31	31	namespace filtration
32	32	{
33
34		Dumping::Dumping(pcap_t*const h, const Params& params)
35		: handle {h}
36		, base {params.output_file}
37		, name {params.output_file}
38		, command {params.command}
39		, limit {params.size_limit}
40		, part {0}
41		, size {0}
	33	Dumping::Dumping(pcap_t* const h, const Params& params)
	34	: handle{h}
	35	, base{params.output_file}
	36	, name{params.output_file}
	37	, command{params.command}
	38	, limit{params.size_limit}
	39	, part{0}
	40	, size{0}
42	41	{
43	42	open_dumping_file(name);
44	43	}

49	48
50	49	void Dumping::open_dumping_file(const std::string& file_path)
51	50	{
52		const char* path {file_path.c_str()};
	51	const char* path{file_path.c_str()};
53	52	LOG("Dumping packets to file:%s", path);
54	53	dumper.reset(new pcap::PacketDumper{handle, path});
55	54	}

64	63	{
65	64	if(command.empty()) return;
66	65
67		NST::utils::Log::flush(); // flush buffer
	66	NST::utils::Log::flush(); // flush buffer
68	67
69	68	if(pid_t pid = fork()) // spawn child process
70	69	{
71	70	// parent process
72	71	LOG("Try to execute(%s %s) in %u child process", command.c_str(), name.c_str(), pid);
73		NST::utils::Log::flush(); // flush buffer
	72	NST::utils::Log::flush(); // flush buffer
74	73	return;
75	74	}
76	75	else
77	76	{
78	77	// child process
79		std::istringstream ss(command);
	78	std::istringstream ss(command);
80	79	std::vector<std::string> tokens;
81		std::vector<char*> args;
	80	std::vector<char*> args;
82	81
83	82	// TODO: this parser doesn't work with dual quotes, like rm "a file.cpp"
84	83	for(std::string arg; ss >> arg;)
85	84	{
86		tokens.emplace_back(arg);
87		args .emplace_back(const_cast<char*>(tokens.back().c_str()));
	85	tokens.emplace_back(arg);
	86	args.emplace_back(const_cast<char*>(tokens.back().c_str()));
88	87	}
89	88	args.push_back(const_cast<char*>(name.c_str()));
90		args.push_back(nullptr); // need termination null pointer
	89	args.push_back(nullptr); // need termination null pointer
91	90
92	91	if(execvp(args[0], &args[0]) == -1)
93	92	{

107	106	return out;
108	107	}
109	108
110
111	109	} // namespace filtration
112	110	} // namespace NST
113	111	//------------------------------------------------------------------------------

+36

-38

src/filtration/dumping.h less more

36	36	{
37	37	namespace filtration
38	38	{
39
40	39	class Dumping
41	40	{
42	41	public:
43
44	42	class Collection
45	43	{
46	44	private:
47		const static int cache_size {4096};
	45	const static int cache_size{4096};
48	46
49	47	public:
50	48	inline Collection()
51		: dumper {nullptr}
52		, buff_size {cache_size}
53		, payload {cache}
54		, payload_len {0}
	49	: dumper{nullptr}
	50	, buff_size{cache_size}
	51	, payload{cache}
	52	, payload_len{0}
55	53	{
56	54	}
57	55	inline Collection(Dumping* d, utils::NetworkSession* /unused/)
58		: dumper {d}
59		, buff_size {cache_size}
60		, payload {cache}
61		, payload_len {0}
	56	: dumper{d}
	57	, buff_size{cache_size}
	58	, payload{cache}
	59	, payload_len{0}
62	60	{
63	61	}
64	62	inline ~Collection()

66	64	if(payload != cache)
67	65	delete[] payload;
68	66	}
69		Collection(Collection&&) = delete;
70		Collection(const Collection&) = delete;
	67	Collection(Collection&&) = delete;
	68	Collection(const Collection&) = delete;
71	69	Collection& operator=(const Collection&) = delete;
72	70
73	71	inline void set(Dumping& d, utils::NetworkSession* /unused/)

90	88	inline void resize(uint32_t amount)
91	89	{
92	90	buff_size = amount;
93		uint8_t* buff {new uint8_t[amount]};
	91	uint8_t* buff{new uint8_t[amount]};
94	92	memcpy(buff, payload, payload_len);
95	93	if(payload != cache)
96	94	delete[] payload;

99	97
100	98	inline void push(const PacketInfo& info, const uint32_t len)
101	99	{
102		if(info.dumped) // if this packet not dumped yet
	100	if(info.dumped) // if this packet not dumped yet
103	101	{
104	102	TRACE("The packet was collected before");
105	103	}

107	105	{
108	106	// direct dumping without waiting completeness of analysis and complete() call
109	107	dumper->dump(info.header, info.packet);
110		info.dumped = true; // set marker of damped packet
	108	info.dumped = true; // set marker of damped packet
111	109	}
112	110	if((payload_len + len) > capacity())
113	111	{
114	112	resize(payload_len + len);
115	113	}
116	114	// copy payload
117		memcpy(payload+payload_len, info.data, len);
	115	memcpy(payload + payload_len, info.data, len);
118	116	payload_len += len;
119	117	}
120	118

128	126	reset();
129	127	}
130	128
131		inline uint32_t data_size() const { return payload_len; }
132		inline uint32_t capacity() const { return buff_size; }
133		inline const uint8_t* data() const { return payload; }
134		inline operator bool() const { return dumper != nullptr; }
135
	129	inline uint32_t data_size() const { return payload_len; }
	130	inline uint32_t capacity() const { return buff_size; }
	131	inline const uint8_t* data() const { return payload; }
	132	inline operator bool() const { return dumper != nullptr; }
136	133	private:
137	134	Dumping* dumper;
138	135	uint32_t buff_size;
139	136	uint8_t* payload;
140		uint8_t cache[cache_size];
	137	uint8_t cache[cache_size];
141	138	uint32_t payload_len;
142	139	};
143	140
144	141	struct Params
145	142	{
146		std::string output_file{ };
147		std::string command { };
148		uint32_t size_limit {0};
	143	std::string output_file{};
	144	std::string command{};
	145	uint32_t size_limit{0};
149	146	};
150	147
151		Dumping(pcap_t*const h, const Params& params);
	148	Dumping(pcap_t* const h, const Params& params);
152	149	~Dumping();
153		Dumping(const Dumping&) = delete;
	150	Dumping(const Dumping&) = delete;
154	151	Dumping& operator=(const Dumping&) = delete;
155	152
156	153	inline void dump(const pcap_pkthdr* header, const u_char* packet)
157	154	{
158	155	if(limit)
159	156	{
160		if( (size + sizeof(pcap_pkthdr) + header->caplen) > limit )
	157	if((size + sizeof(pcap_pkthdr) + header->caplen) > limit)
161	158	{
162	159	close_dumping_file();
163	160

183	180	void exec_command() const;
184	181
185	182	std::unique_ptr<pcap::PacketDumper> dumper;
186		pcap_t* const handle;
187		const std::string base;
188		std::string name;
189		const std::string command;
190		const uint32_t limit;
191		uint32_t part;
192		uint32_t size;
	183
	184	pcap_t* const handle;
	185	const std::string base;
	186	std::string name;
	187	const std::string command;
	188	const uint32_t limit;
	189	uint32_t part;
	190	uint32_t size;
193	191	};
194	192
195	193	std::ostream& operator<<(std::ostream& out, const Dumping::Params& params);

197	195	} // namespace filtration
198	196	} // namespace NST
199	197	//------------------------------------------------------------------------------
200		#endif//DUMPING_H
201		//------------------------------------------------------------------------------
	198	#endif // DUMPING_H
	199	//------------------------------------------------------------------------------

+31

-40

src/filtration/filtration_manager.cpp less more

33	33	{
34	34	namespace filtration
35	35	{
36
37	36	using CaptureReader = NST::filtration::pcap::CaptureReader;
38	37	using FileReader = NST::filtration::pcap::FileReader;
39	38

43	42
44	43	namespace // unnamed
45	44	{
46
47	45	// FiltrationProcessor in separate processing thread
48		template
49		<
	46	template <
50	47	typename Reader,
51		typename Writer
52		>
	48	typename Writer>
53	49	class FiltrationImpl : public ProcessingThread
54	50	{
55		using Processor = FiltrationProcessor<Reader, Writer, Filtrators< Writer >>;
	51	using Processor = FiltrationProcessor<Reader, Writer, Filtrators<Writer>>;
	52
56	53	public:
57	54	explicit FiltrationImpl(std::unique_ptr<Reader>& reader,
58	55	std::unique_ptr<Writer>& writer,
59		RunningStatus& status)
60		: ProcessingThread {status}
61		, processor{}
	56	RunningStatus& status)
	57	: ProcessingThread{status}
	58	, processor{}
62	59	{
63	60	processor.reset(new Processor{reader, writer});
64	61	}
65		~FiltrationImpl() = default;
66		FiltrationImpl(const FiltrationImpl&) = delete;
	62	~FiltrationImpl() = default;
	63	FiltrationImpl(const FiltrationImpl&) = delete;
67	64	FiltrationImpl& operator=(const FiltrationImpl&) = delete;
68	65
69	66	virtual void stop() override final
70	67	{
71	68	processor->stop();
72	69	}
	70
73	71	private:
74
75	72	virtual void run() override final
76	73	{
77	74	try

88	85	};
89	86
90	87	// create Filtration thread emplaced in unique_ptr
91		template
92		<
	88	template <
93	89	typename Reader,
94		typename Writer
95		>
	90	typename Writer>
96	91	static auto create_thread(std::unique_ptr<Reader>& reader,
97	92	std::unique_ptr<Writer>& writer,
98		RunningStatus& status)
99		-> std::unique_ptr<FiltrationImpl<Reader, Writer>>
	93	RunningStatus& status)
	94	-> std::unique_ptr<FiltrationImpl<Reader, Writer>>
100	95	{
101	96	using Thread = FiltrationImpl<Reader, Writer>;
102	97
103	98	return std::unique_ptr<Thread>{new Thread{reader, writer, status}};
104	99	}
105
106	100
107	101	// create CaptureReader from Parameters emplaced in unique_ptr
108	102	static auto create_capture_reader(const Parameters& params)
109		-> std::unique_ptr<CaptureReader>
	103	-> std::unique_ptr<CaptureReader>
110	104	{
111	105	auto& capture_params = params.capture_params();
112	106	if(utils::Out message{}) // print parameters to user
113	107	{
114	108	message << capture_params;
115	109	}
116		return std::unique_ptr<CaptureReader>{ new CaptureReader{capture_params} };
	110	return std::unique_ptr<CaptureReader>{new CaptureReader{capture_params}};
117	111	}
118	112
119	113	} // unnamed namespace

121	115	// capture from network interface and dump to file - OnlineDumping(Dumping)
122	116	void FiltrationManager::add_online_dumping(const Parameters& params)
123	117	{
124		std::unique_ptr<CaptureReader> reader { create_capture_reader(params) };
	118	std::unique_ptr<CaptureReader> reader{create_capture_reader(params)};
125	119
126	120	auto& dumping_params = params.dumping_params();
127	121	if(utils::Out message{}) // print parameters to user
128	122	{
129	123	message << dumping_params;
130	124	}
131		std::unique_ptr<Dumping> writer { new Dumping{ reader->get_handle(), dumping_params } };
	125	std::unique_ptr<Dumping> writer{new Dumping{reader->get_handle(), dumping_params}};
132	126	threads.emplace_back(create_thread(reader, writer, status));
133	127	}
134	128
135	129	//capture data from input file or cin to destination file
136		void FiltrationManager::add_offline_dumping (const Parameters& params)
	130	void FiltrationManager::add_offline_dumping(const Parameters& params)
137	131	{
138	132	auto& dumping_params = params.dumping_params();
139		auto& ofile = dumping_params.output_file;
140		auto ifile = params.input_file();
	133	auto& ofile = dumping_params.output_file;
	134	auto ifile = params.input_file();
141	135
142	136	if(ofile.compare("-"))
143	137	{

151	145	throw std::runtime_error{"Input and output files are equal. Use the -I and -O options to setup them explicitly."};
152	146	}
153	147	}
154
155		}
156		std::unique_ptr<FileReader> reader { new FileReader{ifile} };
	148	}
	149	std::unique_ptr<FileReader> reader{new FileReader{ifile}};
157	150
158	151	if(utils::Out message{}) // print parameters to user
159	152	{
160	153	message << *reader;
161	154	}
162		std::unique_ptr<Dumping> writer { new Dumping{ reader->get_handle(),
163		dumping_params
164		}
165		};
	155	std::unique_ptr<Dumping> writer{new Dumping{reader->get_handle(),
	156	dumping_params}};
166	157
167	158	threads.emplace_back(create_thread(reader, writer, status));
168	159	}
169	160
170	161	// capture from network interface and pass to queue - OnlineAnalysis(Profiling)
171		void FiltrationManager::add_online_analysis(const Parameters& params,
	162	void FiltrationManager::add_online_analysis(const Parameters& params,
172	163	FilteredDataQueue& queue)
173	164	{
174		std::unique_ptr<CaptureReader> reader { create_capture_reader(params) };
175		std::unique_ptr<Queueing> writer { new Queueing{queue} };
	165	std::unique_ptr<CaptureReader> reader{create_capture_reader(params)};
	166	std::unique_ptr<Queueing> writer{new Queueing{queue}};
176	167
177	168	threads.emplace_back(create_thread(reader, writer, status));
178	169	}

181	172	void FiltrationManager::add_offline_analysis(const std::string& ifile,
182	173	FilteredDataQueue& queue)
183	174	{
184		std::unique_ptr<FileReader> reader { new FileReader{ifile} };
	175	std::unique_ptr<FileReader> reader{new FileReader{ifile}};
185	176	if(utils::Out message{}) // print parameters to user
186	177	{
187	178	message << *reader;
188	179	}
189		std::unique_ptr<Queueing> writer { new Queueing{queue} };
	180	std::unique_ptr<Queueing> writer{new Queueing{queue}};
190	181
191	182	threads.emplace_back(create_thread(reader, writer, status));
192	183	}
193	184
194	185	FiltrationManager::FiltrationManager(RunningStatus& s)
195		: status(s)
	186	: status(s)
196	187	{
197	188	if(utils::Out message{utils::Out::Level::All})
198	189	{

-9

src/filtration/filtration_manager.h less more

32	32	{
33	33	namespace filtration
34	34	{
35
36	35	class FiltrationManager
37	36	{
38	37	using Parameters = NST::controller::Parameters;

42	41	public:
43	42	FiltrationManager(RunningStatus&);
44	43	~FiltrationManager();
45		FiltrationManager(const FiltrationManager&) = delete;
	44	FiltrationManager(const FiltrationManager&) = delete;
46	45	FiltrationManager& operator=(const FiltrationManager&) = delete;
47	46
48		void add_online_dumping (const Parameters& params); // dump to file
49		void add_offline_dumping (const Parameters& params); // dump to file from input file
50		void add_online_analysis (const Parameters& params, FilteredDataQueue& queue); // capture to queue
51		void add_offline_analysis(const std::string& ifile, FilteredDataQueue& queue); // read file to queue
	47	void add_online_dumping(const Parameters& params); // dump to file
	48	void add_offline_dumping(const Parameters& params); // dump to file from input file
	49	void add_online_analysis(const Parameters& params, FilteredDataQueue& queue); // capture to queue
	50	void add_offline_analysis(const std::string& ifile, FilteredDataQueue& queue); // read file to queue
52	51
53	52	void start();
54	53	void stop();
55	54
56	55	private:
57
58	56	RunningStatus& status;
59	57
60		std::vector< std::unique_ptr<class ProcessingThread> > threads;
	58	std::vector<std::unique_ptr<class ProcessingThread>> threads;
61	59	};
62	60
63	61	} // namespace filtration
64	62	} // namespace NST
65	63	//------------------------------------------------------------------------------
66		#endif//FILTRATION_MANAGER_H
	64	#endif // FILTRATION_MANAGER_H
67	65	//------------------------------------------------------------------------------

+153

-155

src/filtration/filtration_processor.h less more

31	31
32	32	#include <pcap/pcap.h>
33	33
34		#include "utils/log.h"
35		#include "utils/out.h"
36		#include "utils/sessions.h"
37		#include "utils/profiler.h"
38	34	#include "controller/parameters.h"
39	35	#include "filtration/packet.h"
40	36	#include "filtration/sessions_hash.h"
41		#include "protocols/rpc/rpc_header.h"
42	37	#include "protocols/nfs3/nfs3_utils.h"
43	38	#include "protocols/nfs4/nfs4_utils.h"
	39	#include "protocols/rpc/rpc_header.h"
	40	#include "utils/log.h"
	41	#include "utils/out.h"
	42	#include "utils/profiler.h"
	43	#include "utils/sessions.h"
44	44	//------------------------------------------------------------------------------
45	45	namespace NST
46	46	{
47	47	namespace filtration
48	48	{
49
50		using namespace NST::protocols::rpc;//FIXME: It is not good to use "using" in headers - should be removed
	49	using namespace NST::protocols::rpc; //FIXME: It is not good to use "using" in headers - should be removed
51	50	using ProcEnumNFS3 = API::ProcEnumNFS3;
52	51	using NFS3Validator = NST::protocols::NFS3::Validator;
53	52	using NFS4Validator = NST::protocols::NFS4::Validator;

66	65	{
67	66	public:
68	67	UDPSession(Writer* w, uint32_t max_rpc_hdr)
69		: collection{w, this}
70		, nfs3_rw_hdr_max{max_rpc_hdr}
71		{
72		}
73		UDPSession(UDPSession&&) = delete;
74		UDPSession(const UDPSession&) = delete;
	68	: collection{w, this}
	69	, nfs3_rw_hdr_max{max_rpc_hdr}
	70	{
	71	}
	72	UDPSession(UDPSession&&) = delete;
	73	UDPSession(const UDPSession&) = delete;
75	74	UDPSession& operator=(const UDPSession&) = delete;
76	75
77	76	void collect(PacketInfo& info)
78	77	{
79	78	// TODO: this code must be generalized with RPCFiltrator class
80		uint32_t hdr_len {0};
81		auto msg = reinterpret_cast<const MessageHeader*const>(info.data);
	79	uint32_t hdr_len{0};
	80	auto msg = reinterpret_cast<const MessageHeader* const>(info.data);
82	81	switch(msg->type())
83	82	{
84		case MsgType::CALL:
85		{
86		auto call = static_cast<const CallHeader*const>(msg);
87		if(RPCValidator::check(call))
88		{
89		if (NFS3Validator::check(call))
90		{
91		uint32_t proc {call->proc()};
92		if (ProcEnumNFS3::WRITE == proc) // truncate NFSv3 WRITE call message to NFSv3-RW-limit
93		{
94		hdr_len = (nfs3_rw_hdr_max < info.dlen ? nfs3_rw_hdr_max : info.dlen);
95		}
96		else
97		{
98		if (ProcEnumNFS3::READ == proc)
99		nfs3_read_match.insert(call->xid());
100		hdr_len = info.dlen;
101		}
102		}
103		else if (NFS4Validator::check(call))
104		{
105		hdr_len = info.dlen; // fully collect NFSv4 messages
	83	case MsgType::CALL:
	84	{
	85	auto call = static_cast<const CallHeader* const>(msg);
	86	if(RPCValidator::check(call))
	87	{
	88	if(NFS3Validator::check(call))
	89	{
	90	uint32_t proc{call->proc()};
	91	if(ProcEnumNFS3::WRITE == proc) // truncate NFSv3 WRITE call message to NFSv3-RW-limit
	92	{
	93	hdr_len = (nfs3_rw_hdr_max < info.dlen ? nfs3_rw_hdr_max : info.dlen);
106	94	}
107	95	else
108	96	{
109		return;
110		}
	97	if(ProcEnumNFS3::READ == proc)
	98	nfs3_read_match.insert(call->xid());
	99	hdr_len = info.dlen;
	100	}
	101	}
	102	else if(NFS4Validator::check(call))
	103	{
	104	hdr_len = info.dlen; // fully collect NFSv4 messages
111	105	}
112	106	else
113	107	{
114	108	return;
115	109	}
116	110	}
117		break;
118		case MsgType::REPLY:
119		{
120		auto reply = static_cast<const ReplyHeader*const>(msg);
121		if(RPCValidator::check(reply))
122		{
123		// Truncate NFSv3 READ reply message to NFSv3-RW-limit
124		//* Collect fully if reply received before matching call
125		if (nfs3_read_match.erase(reply->xid()) > 0)
126		{
127		hdr_len = (nfs3_rw_hdr_max < info.dlen ? nfs3_rw_hdr_max : info.dlen);
128		}
129		else
130		hdr_len = info.dlen;
131		}
132		else // isn't RPC reply, stream is corrupt
133		{
134		return;
135		}
136		}
137		break;
138		default:
	111	else
	112	{
139	113	return;
	114	}
	115	}
	116	break;
	117	case MsgType::REPLY:
	118	{
	119	auto reply = static_cast<const ReplyHeader* const>(msg);
	120	if(RPCValidator::check(reply))
	121	{
	122	// Truncate NFSv3 READ reply message to NFSv3-RW-limit
	123	//* Collect fully if reply received before matching call
	124	if(nfs3_read_match.erase(reply->xid()) > 0)
	125	{
	126	hdr_len = (nfs3_rw_hdr_max < info.dlen ? nfs3_rw_hdr_max : info.dlen);
	127	}
	128	else
	129	hdr_len = info.dlen;
	130	}
	131	else // isn't RPC reply, stream is corrupt
	132	{
	133	return;
	134	}
	135	}
	136	break;
	137	default:
	138	return;
140	139	}
141	140
142	141	collection.allocate();

147	146	}
148	147
149	148	typename Writer::Collection collection;
150		uint32_t nfs3_rw_hdr_max;
151		MessageSet nfs3_read_match;
	149	uint32_t nfs3_rw_hdr_max;
	150	MessageSet nfs3_read_match;
152	151	};
153	152
154	153	// Represents TCP conversation between node A and node B

156	155	class TCPSession : public utils::NetworkSession
157	156	{
158	157	public:
159
160	158	struct Flow
161	159	{
162	160	// Helpers for comparison sequence numbers
163	161	// Idea for gt: either x > y, or y is much bigger (assume wrap)
164		inline static bool GT_SEQ(uint32_t x, uint32_t y){ return (int32_t)((y) - (x)) < 0; }
165		inline static bool LT_SEQ(uint32_t x, uint32_t y){ return (int32_t)((x) - (y)) < 0; }
166		inline static bool GE_SEQ(uint32_t x, uint32_t y){ return (int32_t)((y) - (x)) <= 0; }
167		inline static bool LE_SEQ(uint32_t x, uint32_t y){ return (int32_t)((x) - (y)) <= 0; }
168		inline static bool EQ_SEQ(uint32_t x, uint32_t y){ return (x) ==(y); }
169
	162	inline static bool GT_SEQ(uint32_t x, uint32_t y) { return (int32_t)((y) - (x)) < 0; }
	163	inline static bool LT_SEQ(uint32_t x, uint32_t y) { return (int32_t)((x) - (y)) < 0; }
	164	inline static bool GE_SEQ(uint32_t x, uint32_t y) { return (int32_t)((y) - (x)) <= 0; }
	165	inline static bool LE_SEQ(uint32_t x, uint32_t y) { return (int32_t)((x) - (y)) <= 0; }
	166	inline static bool EQ_SEQ(uint32_t x, uint32_t y) { return (x) == (y); }
170	167	friend class TCPSession<StreamReader>;
171	168
172		Flow() : fragments{nullptr}, sequence{0}
	169	Flow()
	170	: fragments{nullptr}
	171	, sequence{0}
173	172	{
174	173	}
175	174	~Flow()
176	175	{
177	176	reset();
178	177	}
179		Flow(Flow&&) = delete;
180		Flow(const Flow&) = delete;
	178	Flow(Flow&&) = delete;
	179	Flow(const Flow&) = delete;
181	180	Flow& operator=(const Flow&) = delete;
182	181
183	182	void reset()

195	194
196	195	void reassemble(PacketInfo& info)
197	196	{
198		uint32_t seq {info.tcp->seq()};
199		uint32_t len {info.dlen};
200
201		if( sequence == 0 ) // this is the first time we have seen this src's sequence number
	197	uint32_t seq{info.tcp->seq()};
	198	uint32_t len{info.dlen};
	199
	200	if(sequence == 0) // this is the first time we have seen this src's sequence number
202	201	{
203	202	sequence = seq + len;
204		if( info.tcp->is(tcp_header::SYN) )
	203	if(info.tcp->is(tcp_header::SYN))
205	204	{
206	205	sequence++;
207	206	}
208	207
209	208	if(len > 0)
210	209	{
211		reader.push(info); // write out the packet data
	210	reader.push(info); // write out the packet data
212	211	}
213	212
214	213	return;

216	215
217	216	// if we are here, we have already seen this src, let's
218	217	// try and figure out if this packet is in the right place
219		if( LT_SEQ(seq, sequence) )
	218	if(LT_SEQ(seq, sequence))
220	219	{
221	220	// this sequence number seems dated, but
222	221	// check the end to make sure it has no more
223	222	// info than we have already seen
224		uint32_t newseq {seq + len};
225		if( GT_SEQ(newseq, sequence) )
226		{
227
	223	uint32_t newseq{seq + len};
	224	if(GT_SEQ(newseq, sequence))
	225	{
228	226	// this one has more than we have seen. let's get the
229	227	// payload that we have not seen
230		uint32_t new_len {sequence - seq};
231
232		if ( info.dlen <= new_len )
	228	uint32_t new_len{sequence - seq};
	229
	230	if(info.dlen <= new_len)
233	231	{
234	232	info.data = nullptr;
235	233	info.dlen = 0;

248	246	}
249	247	}
250	248
251		if ( EQ_SEQ(seq, sequence) ) // right on time
	249	if(EQ_SEQ(seq, sequence)) // right on time
252	250	{
253	251	sequence += len;
254		if( info.tcp->is(tcp_header::SYN) ) sequence++;
255
256		if( info.data && info.dlen > 0)
	252	if(info.tcp->is(tcp_header::SYN)) sequence++;
	253
	254	if(info.data && info.dlen > 0)
257	255	{
258	256	reader.push(info);
259	257	}
260	258	// done with the packet, see if it caused a fragment to fit
261		while( check_fragments(0) );
	259	while(check_fragments(0))
	260	;
262	261	}
263	262	else // out of order packet
264	263	{
265		if(info.dlen > 0 && GT_SEQ(seq, sequence) )
	264	if(info.dlen > 0 && GT_SEQ(seq, sequence))
266	265	{
267	266	//TRACE("ADD FRAGMENT seq: %u dlen: %u sequence: %u", seq, info.dlen, sequence);
268	267	fragments = Packet::create(info, fragments);

272	271
273	272	bool check_fragments(const uint32_t acknowledged)
274	273	{
275		Packet* current {fragments};
276		if( current )
277		{
278		Packet* prev {nullptr};
279		uint32_t lowest_seq {current->tcp->seq()};
280		while( current )
281		{
282		const uint32_t current_seq {current->tcp->seq()};
283		const uint32_t current_len {current->dlen};
284
285		if( GT_SEQ(lowest_seq, current_seq) ) // lowest_seq > current_seq
	274	Packet* current{fragments};
	275	if(current)
	276	{
	277	Packet* prev{nullptr};
	278	uint32_t lowest_seq{current->tcp->seq()};
	279	while(current)
	280	{
	281	const uint32_t current_seq{current->tcp->seq()};
	282	const uint32_t current_len{current->dlen};
	283
	284	if(GT_SEQ(lowest_seq, current_seq)) // lowest_seq > current_seq
286	285	{
287	286	lowest_seq = current_seq;
288	287	}
289	288
290		if( LT_SEQ(current_seq, sequence) ) // current_seq < sequence
	289	if(LT_SEQ(current_seq, sequence)) // current_seq < sequence
291	290	{
292	291	// this sequence number seems dated, but
293	292	// check the end to make sure it has no more
294	293	// info than we have already seen
295		uint32_t newseq {current_seq + current_len};
296		if( GT_SEQ(newseq, sequence) )
	294	uint32_t newseq{current_seq + current_len};
	295	if(GT_SEQ(newseq, sequence))
297	296	{
298	297	// this one has more than we have seen. let's get the
299	298	// payload that we have not seen. This happens when
300	299	// part of this frame has been retransmitted
301		uint32_t new_pos {sequence - current_seq};
	300	uint32_t new_pos{sequence - current_seq};
302	301
303	302	sequence += (current_len - new_pos);
304	303
305		if ( current->dlen > new_pos )
	304	if(current->dlen > new_pos)
306	305	{
307	306	current->data += new_pos;
308	307	current->dlen -= new_pos;

311	310	}
312	311
313	312	// Remove the fragment from the list as the "new" part of it
314		// has been processed or its data has been seen already in
	313	// has been processed or its data has been seen already in
315	314	// another packet.
316		if( prev )
	315	if(prev)
317	316	{
318	317	prev->next = current->next;
319	318	}

327	326	return true;
328	327	}
329	328
330		if( EQ_SEQ(current_seq, sequence) )
	329	if(EQ_SEQ(current_seq, sequence))
331	330	{
332	331	// this fragment fits the stream
333	332	sequence += current_len;
334		if( prev )
	333	if(prev)
335	334	{
336	335	prev->next = current->next;
337	336	}

345	344
346	345	return true;
347	346	}
348		prev = current;
	347	prev = current;
349	348	current = current->next;
350		}// end while
351
352		if( GT_SEQ(acknowledged, lowest_seq) ) // acknowledged > lowest_seq
	349	} // end while
	350
	351	if(GT_SEQ(acknowledged, lowest_seq)) // acknowledged > lowest_seq
353	352	{
354	353	//TRACE("acknowledged(%u) > lowest_seq(%u) seq:%u", acknowledged, lowest_seq, sequence);
355	354	// There are frames missing in the capture stream that were seen

364	363	}
365	364
366	365	private:
367		StreamReader reader; // reader of acknowledged data stream
368		Packet* fragments; // list of not yet acked fragments
369		uint32_t sequence;
	366	StreamReader reader; // reader of acknowledged data stream
	367	Packet* fragments; // list of not yet acked fragments
	368	uint32_t sequence;
370	369	};
371	370
372	371	template <typename Writer>

375	374	flows[0].reader.set_writer(this, w, max_rpc_hdr);
376	375	flows[1].reader.set_writer(this, w, max_rpc_hdr);
377	376	}
378		TCPSession(TCPSession&&) = delete;
379		TCPSession(const TCPSession&) = delete;
	377	TCPSession(TCPSession&&) = delete;
	378	TCPSession(const TCPSession&) = delete;
380	379	TCPSession& operator=(const TCPSession&) = delete;
381	380
382	381	void collect(PacketInfo& info)
383	382	{
384		const uint32_t ack {info.tcp->ack()};
	383	const uint32_t ack{info.tcp->ack()};
385	384
386	385	//check whether this frame acks fragments that were already seen.
387		while( flows[1-info.direction].check_fragments(ack) );
	386	while(flows[1 - info.direction].check_fragments(ack))
	387	;
388	388
389	389	flows[info.direction].reassemble(info);
390	390	}

392	392	Flow flows[2];
393	393	};
394	394
395		template
396		<
	395	template <
397	396	typename Reader,
398	397	typename Writer,
399		typename Filtrator
400		>
	398	typename Filtrator>
401	399	class FiltrationProcessor
402	400	{
403	401	public:
404
405	402	explicit FiltrationProcessor(std::unique_ptr<Reader>& r,
406	403	std::unique_ptr<Writer>& w)
407		: reader{std::move(r)}
408		, writer{std::move(w)}
409		, ipv4_tcp_sessions{writer.get()}
410		, ipv4_udp_sessions{writer.get()}
411		, ipv6_tcp_sessions{writer.get()}
412		, ipv6_udp_sessions{writer.get()}
	404	: reader{std::move(r)}
	405	, writer{std::move(w)}
	406	, ipv4_tcp_sessions{writer.get()}
	407	, ipv4_udp_sessions{writer.get()}
	408	, ipv6_tcp_sessions{writer.get()}
	409	, ipv6_udp_sessions{writer.get()}
413	410	{
414	411	// check datalink layer
415	412	datalink = reader->datalink();

426	423
427	424	void run()
428	425	{
429		bool done {reader->loop(this, callback)};
	426	bool done{reader->loop(this, callback)};
430	427	if(done)
431	428	{
432	429	throw controller::ProcessingDone("Filtration is done");

438	435	reader->break_loop();
439	436	}
440	437
441		static void callback(u_char user, const struct pcap_pkthdr pkthdr, const u_char* packet)
442		{
443		PROF;// Calc how much time was spent in this func
	438	static void callback(u_char* user, const struct pcap_pkthdr* pkthdr, const u_char* packet)
	439	{
	440	PROF; // Calc how much time was spent in this func
444	441	auto processor = reinterpret_cast<FiltrationProcessor*>(user);
445	442
446	443	PacketInfo info(pkthdr, packet, processor->datalink);

449	446	{
450	447	if(pkthdr->caplen != pkthdr->len)
451	448	{
452		LOGONCE("pcap packet was truncated by snaplen option this "
453		"packed won't correclty reassembled to TCP stream");
	449	LOGONCE(
	450	"pcap packet was truncated by snaplen option this "
	451	"packed won't correclty reassembled to TCP stream");
454	452	return;
455	453	}
456	454
457		if(info.ipv4) // Ethernet:IPv4:TCP
	455	if(info.ipv4) // Ethernet:IPv4:TCP
458	456	{
459	457	return processor->ipv4_tcp_sessions.collect_packet(info);
460	458	}
461		else if(info.ipv6) // Ethernet:IPv6:TCP
	459	else if(info.ipv6) // Ethernet:IPv6:TCP
462	460	{
463	461	return processor->ipv6_tcp_sessions.collect_packet(info);
464	462	}
465	463	}
466	464	else if(info.udp)
467	465	{
468		if(info.ipv4) // Ethernet:IPv4:UDP
	466	if(info.ipv4) // Ethernet:IPv4:UDP
469	467	{
470	468	return processor->ipv4_udp_sessions.collect_packet(info);
471	469	}
472		else if(info.ipv6) // Ethernet:IPv6:UDP
	470	else if(info.ipv6) // Ethernet:IPv6:UDP
473	471	{
474	472	return processor->ipv6_udp_sessions.collect_packet(info);
475	473	}
476	474	}
477	475
478		LOGONCE("only following stack of protocol is supported: "
479		"Ethernet II:IPv4\|IPv6(except additional fragments):TCP\|UDP");
	476	LOGONCE(
	477	"only following stack of protocol is supported: "
	478	"Ethernet II:IPv4\|IPv6(except additional fragments):TCP\|UDP");
480	479	}
481	480
482	481	private:
483
484	482	std::unique_ptr<Reader> reader;
485	483	std::unique_ptr<Writer> writer;
486	484
487		SessionsHash< IPv4TCPMapper, TCPSession <Filtrator> , Writer > ipv4_tcp_sessions;
488		SessionsHash< IPv4UDPMapper, UDPSession < Writer > , Writer > ipv4_udp_sessions;
489
490		SessionsHash< IPv6TCPMapper, TCPSession < Filtrator> , Writer > ipv6_tcp_sessions;
491		SessionsHash< IPv6UDPMapper, UDPSession < Writer > , Writer > ipv6_udp_sessions;
	485	SessionsHash<IPv4TCPMapper, TCPSession<Filtrator>, Writer> ipv4_tcp_sessions;
	486	SessionsHash<IPv4UDPMapper, UDPSession<Writer>, Writer> ipv4_udp_sessions;
	487
	488	SessionsHash<IPv6TCPMapper, TCPSession<Filtrator>, Writer> ipv6_tcp_sessions;
	489	SessionsHash<IPv6UDPMapper, UDPSession<Writer>, Writer> ipv6_udp_sessions;
492	490
493	491	int datalink;
494	492	};

496	494	} // namespace filtration
497	495	} // namespace NST
498	496	//------------------------------------------------------------------------------
499		#endif//FILTRATION_PROCESSOR_H
500		//------------------------------------------------------------------------------
	497	#endif // FILTRATION_PROCESSOR_H
	498	//------------------------------------------------------------------------------

+61

-59

src/filtration/filtratorimpl.h less more

22	22	#ifndef IFILTRATOR_H
23	23	#define IFILTRATOR_H
24	24	//------------------------------------------------------------------------------
	25	#include "filtration/packet.h"
	26	#include "utils/log.h"
	27	//------------------------------------------------------------------------------
25	28	namespace NST
26	29	{
27	30	namespace filtration
28	31	{
29
30	32	/*!
31	33	* Filtering TCP stream strategy (implementation)
32	34	* Implemented via CRTP - Curiously recurring template pattern,
33	35	* (see http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern)
34	36	*/
35		template<typename Filtrator, typename Writer>
	37	template <typename Filtrator, typename Writer>
36	38	class FiltratorImpl
37	39	{
38		size_t msg_len; //!< length of current message
39		size_t to_be_copied; //!< length of readable piece of message. Initially msg_len or 0 in case of unknown msg
	40	size_t msg_len; //!< length of current message
	41	size_t to_be_copied; //!< length of readable piece of message. Initially msg_len or 0 in case of unknown msg
40	42	using Collection = typename Writer::Collection; //!< Type of collection
41		Collection collection;//!< storage for collection packet data
42
43		FiltratorImpl(FiltratorImpl&&) = delete;
44		FiltratorImpl(const FiltratorImpl&) = delete;
	43	Collection collection; //!< storage for collection packet data
	44
	45	FiltratorImpl(FiltratorImpl&&) = delete;
	46	FiltratorImpl(const FiltratorImpl&) = delete;
45	47	FiltratorImpl& operator=(const FiltratorImpl&) = delete;
	48
46	49	public:
47	50	FiltratorImpl()
48	51	{

61	64	*/
62	65	inline void reset()
63	66	{
64		msg_len = 0;
	67	msg_len = 0;
65	68	to_be_copied = 0;
66	69	collection.reset();
67	70	}

72	75	*/
73	76	inline bool inProgress(PacketInfo& info)
74	77	{
75		Filtrator* filtrator = static_cast<Filtrator* >(this);
	78	Filtrator* filtrator = static_cast<Filtrator*>(this);
76	79	constexpr size_t callHeaderLen = Filtrator::lengthOfBaseHeader();
77		if (msg_len \|\| to_be_copied)
	80	if(msg_len \|\| to_be_copied)
78	81	{
79	82	return true;
80	83	}
81	84
82		if (!collection) // collection isn't allocated
	85	if(!collection) // collection isn't allocated
83	86	{
84	87	collection.allocate(); // allocate new collection from writer
85	88	}
86	89	const size_t data_size = collection.data_size();
87	90
88		if (data_size + info.dlen > callHeaderLen)
	91	if(data_size + info.dlen > callHeaderLen)
89	92	{
90	93	static uint8_t buffer[callHeaderLen];
91	94	const uint8_t* header = info.data;
92	95
93		if (data_size > 0)
	96	if(data_size > 0)
94	97	{
95	98	// Coping happends only once per TCP-session
96	99	memcpy(buffer, collection.data(), data_size);

99	102	}
100	103
101	104	// It is right header
102		if (filtrator->isRightHeader(header))
	105	if(filtrator->isRightHeader(header))
103	106	{
104	107	return true;
105	108	}

120	123	*/
121	124	inline void lost(const uint32_t n) // we are lost n bytes in sequence
122	125	{
123		Filtrator* filtrator = static_cast<Filtrator* >(this);
124		if (msg_len != 0)
125		{
126		if (to_be_copied == 0 && msg_len >= n)
	126	Filtrator* filtrator = static_cast<Filtrator*>(this);
	127	if(msg_len != 0)
	128	{
	129	if(to_be_copied == 0 && msg_len >= n)
127	130	{
128	131	TRACE("We are lost %u bytes of payload marked for discard", n);
129	132	msg_len -= n;

146	149	*/
147	150	inline void push(PacketInfo& info)
148	151	{
149		Filtrator* filtrator = static_cast<Filtrator* >(this);
	152	Filtrator* filtrator = static_cast<Filtrator*>(this);
150	153	assert(info.dlen != 0);
151	154
152		while (info.dlen) // loop over data in packet
153		{
154		if (msg_len) // we are on-stream and we are looking to some message
155		{
156		if (to_be_copied)
	155	while(info.dlen) // loop over data in packet
	156	{
	157	if(msg_len) // we are on-stream and we are looking to some message
	158	{
	159	if(to_be_copied)
157	160	{
158	161	// hdr_len != 0, readout a part of header of current message
159		if (to_be_copied > info.dlen) // got new part of header (not the all!)
	162	if(to_be_copied > info.dlen) // got new part of header (not the all!)
160	163	{
161	164	//TRACE("got new part of header (not the all!)");
162	165	collection.push(info, info.dlen);
163	166	to_be_copied -= info.dlen;
164	167	msg_len -= info.dlen;
165		info.dlen = 0; // return from while
	168	info.dlen = 0; // return from while
166	169	}
167	170	else // hdr_len <= dlen, current message will be complete, also we have some additional data
168	171	{
169	172	//TRACE("current message will be complete, also we have some additional data");
170	173	collection.push(info, to_be_copied);
171		info.dlen -= to_be_copied;
172		info.data += to_be_copied;
	174	info.dlen -= to_be_copied;
	175	info.data += to_be_copied;
173	176
174	177	msg_len -= to_be_copied;
175	178	to_be_copied = 0;
176	179
177	180	collection.skip_first(Filtrator::lengthOfFirstSkipedPart());
178		collection.complete(info); // push complete message to queue
	181	collection.complete(info); // push complete message to queue
179	182	}
180	183	}
181	184	else
182	185	{
183	186	// message header is readout, discard the unused tail of message
184		if (msg_len >= info.dlen) // discard whole new packet
	187	if(msg_len >= info.dlen) // discard whole new packet
185	188	{
186	189	//TRACE("discard whole new packet");
187	190	msg_len -= info.dlen;
188	191	return; //info.dlen = 0; // return from while
189	192	}
190		else // discard only a part of packet payload related to current message
	193	else // discard only a part of packet payload related to current message
191	194	{
192	195	//TRACE("discard only a part of packet payload related to current message");
193	196	info.dlen -= msg_len;

210	213	*/
211	214	inline void find_message(PacketInfo& info)
212	215	{
213		assert(msg_len == 0); // Message still undetected
214		Filtrator* filtrator = static_cast<Filtrator* >(this);
215
216		if (!filtrator->collect_header(info, collection))
	216	assert(msg_len == 0); // Message still undetected
	217	Filtrator* filtrator = static_cast<Filtrator*>(this);
	218
	219	if(!filtrator->collect_header(info, collection))
217	220	{
218	221	return;
219	222	}
220	223
221		assert(collection); // collection must be initialized
222
223		if (filtrator->find_and_read_message(info, collection))
	224	assert(collection); // collection must be initialized
	225
	226	if(filtrator->find_and_read_message(info, collection))
224	227	{
225	228	return;
226	229	}
227	230
228		assert(msg_len == 0); // message is not found
229		assert(to_be_copied == 0); // header should be skipped
230		collection.reset(); // skip collected data
	231	assert(msg_len == 0); // message is not found
	232	assert(to_be_copied == 0); // header should be skipped
	233	collection.reset(); // skip collected data
231	234	//[ Optimization ] skip data of current packet at all
232	235	info.dlen = 0;
233	236	}

243	246	to_be_copied = value;
244	247	}
245	248
246		inline void setWriterImpl(utils::NetworkSession* session_ptr, Writer* w, uint32_t )
	249	inline void setWriterImpl(utils::NetworkSession* session_ptr, Writer* w, uint32_t)
247	250	{
248	251	assert(w);
249	252	collection.set(*w, session_ptr);

251	254
252	255	inline bool collect_header(PacketInfo& info, size_t callHeaderLen, size_t replyHeaderLen)
253	256	{
254		if (collection && (collection.data_size() > 0)) // collection is allocated
	257	if(collection && (collection.data_size() > 0)) // collection is allocated
255	258	{
256	259	assert(collection.capacity() >= callHeaderLen);
257		const size_t tocopy {callHeaderLen - collection.data_size()};
	260	const size_t tocopy{callHeaderLen - collection.data_size()};
258	261	assert(tocopy != 0);
259		if (info.dlen < tocopy)
	262	if(info.dlen < tocopy)
260	263	{
261	264	collection.push(info, info.dlen);
262		info.data += info.dlen;// optimization
	265	info.data += info.dlen; // optimization
263	266	info.dlen = 0;
264	267	return false;
265	268	}

272	275	}
273	276	else // collection is empty
274	277	{
275		collection.allocate(); // allocate new collection from writer
276		if (info.dlen >= callHeaderLen) // is data enough to message validation?
	278	collection.allocate(); // allocate new collection from writer
	279	if(info.dlen >= callHeaderLen) // is data enough to message validation?
277	280	{
278	281	collection.push(info, callHeaderLen); // probability that message will be rejected / probability of valid message
279	282	info.data += callHeaderLen;

284	287	collection.push(info, info.dlen);
285	288	//info.data += info.dlen;// optimization
286	289	size_t copied = info.dlen;
287		info.dlen = 0;
	290	info.dlen = 0;
288	291	return copied >= replyHeaderLen;
289	292	}
290	293	}

293	296
294	297	inline bool read_message(PacketInfo& info)
295	298	{
296		assert(msg_len != 0); // message is found
	299	assert(msg_len != 0); // message is found
297	300	assert(msg_len >= collection.data_size());
298	301	assert(to_be_copied <= msg_len);
299		Filtrator* filtrator = static_cast<Filtrator* >(this);
300
301		const size_t written {collection.data_size()};
	302	Filtrator* filtrator = static_cast<Filtrator*>(this);
	303
	304	const size_t written{collection.data_size()};
302	305	msg_len -= written; // substract how written (if written)
303	306	to_be_copied -= std::min(to_be_copied, written);
304		if (0 == to_be_copied) // Avoid infinity loop when "msg len" == "data size(collection) (max_header)" {msg_len >= hdr_len}
305		// Next find message call will finding next message
	307	if(0 == to_be_copied) // Avoid infinity loop when "msg len" == "data size(collection) (max_header)" {msg_len >= hdr_len}
	308	// Next find message call will finding next message
306	309	{
307	310	collection.skip_first(filtrator->lengthOfFirstSkipedPart());
308	311	collection.complete(info);
309	312	}
310	313	return true;
311	314	}
312
313	315	};
314	316
315	317	} // namespace filtration
316	318	} // namespace NST
317	319	//------------------------------------------------------------------------------
318		#endif//IFILTRATOR_H
319		//------------------------------------------------------------------------------
	320	#endif // IFILTRATOR_H
	321	//------------------------------------------------------------------------------

+18

-19

src/filtration/filtrators.h less more

30	30	{
31	31	namespace filtration
32	32	{
33
34	33	/*!
35	34	* Composite filtrator which composites both CIFS&NFS
36	35	*/
37		template<typename Writer>
	36	template <typename Writer>
38	37	class Filtrators
39	38	{
40	39	enum class FiltratorTypes

44	43	CIFS
45	44	};
46	45
47		CIFSFiltrator<Writer> filtratorCIFS;//!< CIFS filtrator
48		RPCFiltrator<Writer> filtratorRPC;//!< RPC filtrator
49		FiltratorTypes currentFiltrator;//!< Indicates which filtrator is currently active?
	46	CIFSFiltrator<Writer> filtratorCIFS; //!< CIFS filtrator
	47	RPCFiltrator<Writer> filtratorRPC; //!< RPC filtrator
	48	FiltratorTypes currentFiltrator; //!< Indicates which filtrator is currently active?
50	49	public:
51		Filtrators() :
52		currentFiltrator(FiltratorTypes::DEFAULT)
	50	Filtrators()
	51	: currentFiltrator(FiltratorTypes::DEFAULT)
53	52	{
54	53	}
55	54
56		Filtrators(Filtrators&&) = delete;
57		Filtrators(const Filtrators&) = delete;
	55	Filtrators(Filtrators&&) = delete;
	56	Filtrators(const Filtrators&) = delete;
58	57	Filtrators& operator=(const Filtrators&) = delete;
59	58
60	59	/*!

63	62	inline void reset()
64	63	{
65	64	filtratorCIFS.reset();
66		filtratorRPC.reset ();
	65	filtratorRPC.reset();
67	66	currentFiltrator = FiltratorTypes::DEFAULT;
68	67	}
69	68

76	75	inline void set_writer(utils::NetworkSession* session_ptr, Writer* w, uint32_t max_rpc_hdr)
77	76	{
78	77	assert(w);
79		filtratorCIFS.set_writer (session_ptr, w, max_rpc_hdr);
80		filtratorRPC.set_writer (session_ptr, w, max_rpc_hdr);
	78	filtratorCIFS.set_writer(session_ptr, w, max_rpc_hdr);
	79	filtratorRPC.set_writer(session_ptr, w, max_rpc_hdr);
81	80	}
82	81
83	82	inline void lost(const uint32_t n) // we are lost n bytes in sequence
84	83	{
85		filtratorCIFS.lost (n);
86		filtratorRPC.lost (n);
	84	filtratorCIFS.lost(n);
	85	filtratorRPC.lost(n);
87	86	}
88	87
89	88	/*!

93	92	inline void push(PacketInfo& info)
94	93	{
95	94	// is it RPC message?
96		if (currentFiltrator == FiltratorTypes::RPC \|\| filtratorRPC.inProgress(info))
	95	if(currentFiltrator == FiltratorTypes::RPC \|\| filtratorRPC.inProgress(info))
97	96	{
98	97	currentFiltrator = FiltratorTypes::RPC;
99		filtratorRPC.push (info);
	98	filtratorRPC.push(info);
100	99	}
101	100	// is it CIFS message?
102		else if (currentFiltrator == FiltratorTypes::CIFS \|\| filtratorCIFS.inProgress(info))
	101	else if(currentFiltrator == FiltratorTypes::CIFS \|\| filtratorCIFS.inProgress(info))
103	102	{
104	103	currentFiltrator = FiltratorTypes::CIFS;
105		filtratorCIFS.push (info);
	104	filtratorCIFS.push(info);
106	105	}
107	106	// it is Unknown message
108	107	else

115	114	} // namespace filtration
116	115	} // namespace NST
117	116	//------------------------------------------------------------------------------
118		#endif//FILTRATORS_H
	117	#endif // FILTRATORS_H
119	118	//------------------------------------------------------------------------------

+94

-78

src/filtration/packet.h less more

21	21	#ifndef PACKET_H
22	22	#define PACKET_H
23	23	//------------------------------------------------------------------------------
24		#include <algorithm> // for std::min()
	24	#include <algorithm> // for std::min()
25	25	#include <cassert>
26		#include <cstring> // for memcpy()
	26	#include <cstring> // for memcpy()
27	27
28	28	#include <pcap/pcap.h>
29	29

37	37	{
38	38	namespace filtration
39	39	{
40
41	40	using namespace NST::protocols;
42	41	using namespace NST::protocols::ethernet;
43	42	using namespace NST::protocols::ip;

55	54	friend struct Packet;
56	55
57	56	public:
58		Dumped() : flag{false}{};
	57	Dumped()
	58	: flag{false} {};
59	59	Dumped(const Dumped& in) = delete;
60	60	~Dumped(){};
61	61
62	62	private:
63		inline operator bool() const { return flag; }
	63	inline operator bool() const { return flag; }
64	64	inline void operator=(const bool stat) { flag = stat; }
65		bool flag;
	65	bool flag;
66	66	};
67	67
68	68	inline PacketInfo(const pcap_pkthdr* h,
69		const uint8_t* p,
70		const uint32_t datalink)
71		: header {h}
72		, packet {p}
73		, eth {nullptr}
74		, ipv4 {nullptr}
75		, ipv6 {nullptr}
76		, tcp {nullptr}
77		, udp {nullptr}
78		, data {packet}
79		, dlen {header->caplen}
80		, direction{Direction::Unknown}
81		, dumped {}
	69	const uint8_t* p,
	70	const uint32_t datalink)
	71	: header{h}
	72	, packet{p}
	73	, eth{nullptr}
	74	, ipv4{nullptr}
	75	, ipv6{nullptr}
	76	, tcp{nullptr}
	77	, udp{nullptr}
	78	, data{packet}
	79	, dlen{header->caplen}
	80	, direction{Direction::Unknown}
	81	, dumped{}
82	82	{
83	83	switch(datalink)
84	84	{
85		case DLT_EN10MB: check_eth(); break;
86		case DLT_LINUX_SLL: check_sll(); break;
87		}
88		}
89		PacketInfo(const PacketInfo&) = delete;
	85	case DLT_EN10MB:
	86	check_eth();
	87	break;
	88	case DLT_LINUX_SLL:
	89	check_sll();
	90	break;
	91	}
	92	}
	93	PacketInfo(const PacketInfo&) = delete;
90	94	PacketInfo& operator=(const PacketInfo&) = delete;
91		void* operator new (size_t ) = delete; // only on stack
92		void* operator new[] (size_t ) = delete; // only on stack
93		void operator delete (void*) = delete; // only on stack
94		void operator delete[](void*) = delete; // only on stack
	95	void* operator new(size_t) = delete; // only on stack
	96	void* operator new[](size_t) = delete; // only on stack
	97	void operator delete(void*) = delete; // only on stack
	98	void operator delete[](void*) = delete; // only on stack
95	99
96	100	inline void check_eth()
97	101	{

103	107
104	108	switch(header->type())
105	109	{
106		case ethernet_header::IP: check_ipv4(); break;
107		case ethernet_header::IPV6: check_ipv6(); break;
	110	case ethernet_header::IP:
	111	check_ipv4();
	112	break;
	113	case ethernet_header::IPV6:
	114	check_ipv6();
	115	break;
108	116	default:
109	117	return;
110	118	}

114	122
115	123	inline void check_sll()
116	124	{
117		// TODO: add support Linux cooked sockets
	125	// TODO: add support Linux cooked sockets
118	126	}
119	127
120	128	inline void check_ipv4() __attribute__((always_inline))

122	130	if(dlen < sizeof(IPv4Header)) return;
123	131	auto header = reinterpret_cast<const IPv4Header*>(data);
124	132
125		if(header->version() != 4) return;
	133	if(header->version() != 4) return;
126	134
127	135	/*
128	136	IP packet may be fragmented by NIC or snaplen parameter of libpcap

138	146	}
139	147
140	148	const uint32_t ihl = header->ihl();
141		if(dlen < ihl) return; // truncated packet
	149	if(dlen < ihl) return; // truncated packet
142	150	if((header->length()) < ihl) return; // incorrect packet
143	151
144	152	data += ihl;
145		dlen = (std::min((uint16_t)dlen, header->length())) - ihl; // trunk data to length of IP packet
	153	dlen = (std::min((uint16_t)dlen, header->length())) - ihl; // trunk data to length of IP packet
146	154
147	155	switch(header->protocol())
148	156	{
149		case ip::NextProtocol::TCP: check_tcp(); break;
150		case ip::NextProtocol::UDP: check_udp(); break;
	157	case ip::NextProtocol::TCP:
	158	check_tcp();
	159	break;
	160	case ip::NextProtocol::UDP:
	161	check_udp();
	162	break;
151	163	default:
152	164	return;
153	165	}

160	172	if(dlen < sizeof(IPv6Header)) return;
161	173	auto header = reinterpret_cast<const IPv6Header*>(data);
162	174
163		if(header->version() != 6) return;
	175	if(header->version() != 6) return;
164	176
165	177	data += sizeof(IPv6Header);
166	178	dlen -= sizeof(IPv6Header);
167	179
168	180	const uint32_t payload = header->payload_len();
169		if(payload == 0) return; // The length is set to zero when a Hop-by-Hop extension header carries a Jumbo Payload option
	181	if(payload == 0) return; // The length is set to zero when a Hop-by-Hop extension header carries a Jumbo Payload option
170	182	if(dlen < payload) return; // truncated packet
171	183
172	184	dlen = payload; // skip padding at the end
173	185	// handling optional headers
174	186	uint8_t htype = header->nexthdr();
175		switch_type: // TODO: remove ugly goto
	187	switch_type: // TODO: remove ugly goto
176	188	switch(htype)
177	189	{
178		case ip::NextProtocol::TCP: check_tcp(); break;
179		case ip::NextProtocol::UDP: check_udp(); break;
	190	case ip::NextProtocol::TCP:
	191	check_tcp();
	192	break;
	193	case ip::NextProtocol::UDP:
	194	check_udp();
	195	break;
180	196
181	197	case ip::NextProtocol::HOPOPTS:
182	198	{
183		auto hbh = reinterpret_cast<const ipv6_hbh*>(data);
	199	auto hbh = reinterpret_cast<const ipv6_hbh*>(data);
184	200	const unsigned int size{1U + hbh->hbh_len};
185	201
186	202	if(dlen < size) return; // truncated packet

194	210
195	211	case ip::NextProtocol::DSTOPTS:
196	212	{
197		auto dest = reinterpret_cast<const ipv6_dest*>(data);
	213	auto dest = reinterpret_cast<const ipv6_dest*>(data);
198	214	const unsigned int size{1U + dest->dest_len};
199	215
200	216	if(dlen < size) return; // truncated packet

208	224
209	225	case ip::NextProtocol::ROUTING:
210	226	{
211		auto route = reinterpret_cast<const ipv6_route*>(data);
	227	auto route = reinterpret_cast<const ipv6_route*>(data);
212	228	const unsigned int size{1U + route->route_len};
213	229
214	230	if(dlen < size) return; // truncated packet

238	254	goto switch_type;
239	255	}
240	256	case ip::NextProtocol::NONE:
241		default: // unknown header
	257	default: // unknown header
242	258	return;
243	259	}
244	260

247	263
248	264	inline void check_tcp() __attribute__((always_inline))
249	265	{
250		if(dlen < sizeof(TCPHeader)) return; // truncated TCP header
	266	if(dlen < sizeof(TCPHeader)) return; // truncated TCP header
251	267	auto header = reinterpret_cast<const TCPHeader*>(data);
252	268
253		uint8_t offset {header->offset()};
	269	uint8_t offset{header->offset()};
254	270	if(offset < 20 \|\| offset > 60) return; // invalid length of TCP header
255	271
256	272	if(dlen < offset) return; // truncated packet

267	283
268	284	inline void check_udp() __attribute__((always_inline))
269	285	{
270		if(dlen < sizeof(UDPHeader)) return; // fragmented UDP header
271		const UDPHeader* header {reinterpret_cast<const UDPHeader*>(data)};
	286	if(dlen < sizeof(UDPHeader)) return; // fragmented UDP header
	287	const UDPHeader* header{reinterpret_cast<const UDPHeader*>(data)};
272	288
273	289	data += sizeof(UDPHeader);
274	290	dlen -= sizeof(UDPHeader);

277	293	}
278	294
279	295	// libpcap structures
280		const pcap_pkthdr* header;
281		const uint8_t* packet; // real length is in header->caplen
	296	const pcap_pkthdr* header;
	297	const uint8_t* packet; // real length is in header->caplen
282	298
283	299	// all pointers point to packet array
284	300

288	304
289	305	// Internet Layer
290	306	// IP version 4
291		const ip::IPv4Header* ipv4;
	307	const ip::IPv4Header* ipv4;
292	308	// IP version 6
293		const ip::IPv6Header* ipv6;
	309	const ip::IPv6Header* ipv6;
294	310
295	311	// Transport Layer
296	312	// TCP
297		const tcp::TCPHeader* tcp;
	313	const tcp::TCPHeader* tcp;
298	314	// UDP
299		const udp::UDPHeader* udp;
300
301		const uint8_t* data; // pointer to packet data
302		uint32_t dlen; // length of packet data
	315	const udp::UDPHeader* udp;
	316
	317	const uint8_t* data; // pointer to packet data
	318	uint32_t dlen; // length of packet data
303	319
304	320	// Packet transmission direction, set after match packet to session
305		Direction direction;
306
307		mutable Dumped dumped; // flag for dumped packet
	321	Direction direction;
	322
	323	mutable Dumped dumped; // flag for dumped packet
308	324	};
309	325
310	326	// PCAP packet in dynamic allocated memory
311		struct Packet: public PacketInfo
	327	struct Packet : public PacketInfo
312	328	{
313		Packet() = delete;
314		Packet(const Packet&) = delete;
	329	Packet() = delete;
	330	Packet(const Packet&) = delete;
315	331	Packet& operator=(const Packet&) = delete;
316	332
317		Packet* next; // pointer to next packet or nullptr
	333	Packet* next; // pointer to next packet or nullptr
318	334
319	335	static Packet* create(const PacketInfo& info, Packet* next)
320	336	{

322	338
323	339	// allocate memory for Packet structure and PCAP packet data
324	340	// TODO: performance drop! improve data alignment!
325		uint8_t* memory { new uint8_t[sizeof(Packet) + sizeof(pcap_pkthdr) + info.header->caplen]};
326
327		Packet* fragment { (Packet) ((uint8_t)memory )};
328		pcap_pkthdr* header{ (pcap_pkthdr) ((uint8_t)memory + sizeof(Packet) )};
329		uint8_t* packet { (uint8_t) ((uint8_t)memory + sizeof(Packet) + sizeof(pcap_pkthdr))};
	341	uint8_t* memory{new uint8_t[sizeof(Packet) + sizeof(pcap_pkthdr) + info.header->caplen]};
	342
	343	Packet* fragment{(Packet)((uint8_t)memory)};
	344	pcap_pkthdr* header{(pcap_pkthdr)((uint8_t)memory + sizeof(Packet))};
	345	uint8_t* packet{(uint8_t)((uint8_t)memory + sizeof(Packet) + sizeof(pcap_pkthdr))};
330	346
331	347	// copy data
332	348	header = info.header; // copy packet header

336	352	fragment->packet = packet;
337	353
338	354	// fix pointers from PacketInfo to point to owned copy of packet data
339		fragment->eth = info.eth ? (const ethernet::EthernetHeader) (packet + ( ((const uint8_t)info.eth ) - info.packet)) : nullptr;
340		fragment->ipv4 = info.ipv4 ? (const ip::IPv4Header) (packet + ( ((const uint8_t)info.ipv4) - info.packet)) : nullptr;
341		fragment->ipv6 = info.ipv6 ? (const ip::IPv6Header) (packet + ( ((const uint8_t)info.ipv6) - info.packet)) : nullptr;
342		fragment->tcp = info.tcp ? (const tcp::TCPHeader) (packet + ( ((const uint8_t)info.tcp ) - info.packet)) : nullptr;
343		fragment->udp = info.udp ? (const udp::UDPHeader) (packet + ( ((const uint8_t)info.udp ) - info.packet)) : nullptr;
	355	fragment->eth = info.eth ? (const ethernet::EthernetHeader)(packet + (((const uint8_t)info.eth) - info.packet)) : nullptr;
	356	fragment->ipv4 = info.ipv4 ? (const ip::IPv4Header)(packet + (((const uint8_t)info.ipv4) - info.packet)) : nullptr;
	357	fragment->ipv6 = info.ipv6 ? (const ip::IPv6Header)(packet + (((const uint8_t)info.ipv6) - info.packet)) : nullptr;
	358	fragment->tcp = info.tcp ? (const tcp::TCPHeader)(packet + (((const uint8_t)info.tcp) - info.packet)) : nullptr;
	359	fragment->udp = info.udp ? (const udp::UDPHeader)(packet + (((const uint8_t)info.udp) - info.packet)) : nullptr;
344	360
345	361	fragment->data = packet + (info.data - info.packet);
346	362	fragment->dlen = info.dlen;

354	370
355	371	static void destroy(Packet* fragment)
356	372	{
357		uint8_t* ptr { (uint8_t*)fragment };
	373	uint8_t* ptr{(uint8_t*)fragment};
358	374	delete[] ptr;
359	375	}
360	376	};

362	378	} // namespace filtration
363	379	} // namespace NST
364	380	//------------------------------------------------------------------------------
365		#endif//PACKET_H
366		//------------------------------------------------------------------------------
	381	#endif // PACKET_H
	382	//------------------------------------------------------------------------------

+15

-15

src/filtration/pcap/base_reader.h less more

34	34	{
35	35	namespace pcap
36	36	{
37
38		inline const char* library_version() { return pcap_lib_version(); }
	37	inline const char* library_version()
	38	{
	39	return pcap_lib_version();
	40	}
39	41
40	42	class BaseReader
41	43	{
42	44	protected:
43	45	BaseReader(const std::string& input)
44		: handle{nullptr}
45		, source{input}
	46	: handle{nullptr}
	47	, source{input}
46	48	{
47	49	}
48	50

55	57	}
56	58
57	59	public:
58		bool loop(void* user, pcap_handler callback, int count=0)
	60	bool loop(void* user, pcap_handler callback, int count = 0)
59	61	{
60		const int err {pcap_loop(handle, count, callback, (u_char*)user)};
	62	const int err{pcap_loop(handle, count, callback, (u_char*)user)};
61	63	if(err == -1) throw PcapError("pcap_loop", pcap_geterr(handle));
62	64
63	65	return err == 0; // count is exhausted
64	66	}
65	67
66		inline void break_loop() { pcap_breakloop(handle); }
67		inline pcap_t*& get_handle() { return handle; }
68
69		inline int datalink () const { return pcap_datalink(handle); }
70		inline static const char* datalink_name (const int dlt) { return pcap_datalink_val_to_name(dlt); }
71		inline static const char* datalink_description (const int dlt) { return pcap_datalink_val_to_description(dlt); }
72
	68	inline void break_loop() { pcap_breakloop(handle); }
	69	inline pcap_t*& get_handle() { return handle; }
	70	inline int datalink() const { return pcap_datalink(handle); }
	71	inline static const char* datalink_name(const int dlt) { return pcap_datalink_val_to_name(dlt); }
	72	inline static const char* datalink_description(const int dlt) { return pcap_datalink_val_to_description(dlt); }
73	73	virtual void print_statistic(std::ostream& out) const = 0;
74	74
75	75	protected:
76		pcap_t* handle;
	76	pcap_t* handle;
77	77	const std::string source;
78	78	};
79	79

81	81	} // namespace filtration
82	82	} // namespace NST
83	83	//------------------------------------------------------------------------------
84		#endif//BASE_READER_H
	84	#endif // BASE_READER_H
85	85	//------------------------------------------------------------------------------

-6

src/filtration/pcap/bpf.h less more

18	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
19	19	*/
20	20	//------------------------------------------------------------------------------
21		#ifndef BPF_H
22		#define BPF_H
	21	#ifndef BPF_HEADER_H
	22	#define BPF_HEADER_H
23	23	//------------------------------------------------------------------------------
24	24	#include <pcap/pcap.h>
25	25

31	31	{
32	32	namespace pcap
33	33	{
34
35	34	class BPF
36	35	{
37	36	public:

42	41	throw PcapError("pcap_compile", pcap_geterr(handle));
43	42	}
44	43	}
45		BPF(const BPF&) = delete;
	44	BPF(const BPF&) = delete;
46	45	BPF& operator=(const BPF&) = delete;
47	46	~BPF()
48	47	{

50	49	}
51	50
52	51	inline operator bpf_program*() { return &bpf; }
53
54	52	private:
55	53	bpf_program bpf;
56	54	};

59	57	} // namespace filtration
60	58	} // namespace NST
61	59	//------------------------------------------------------------------------------
62		#endif//BPF_H
	60	#endif // BPF_HEADER_H
63	61	//------------------------------------------------------------------------------

+35

-23

src/filtration/pcap/capture_reader.cpp less more

18	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
19	19	*/
20	20	//------------------------------------------------------------------------------
	21	#include "filtration/pcap/capture_reader.h"
21	22	#include "filtration/pcap/bpf.h"
22		#include "filtration/pcap/capture_reader.h"
23	23	#include "filtration/pcap/pcap_error.h"
24	24	//------------------------------------------------------------------------------
25	25	namespace NST

28	28	{
29	29	namespace pcap
30	30	{
31
32		CaptureReader::CaptureReader(const Params& params) : BaseReader{params.interface}
	31	CaptureReader::CaptureReader(const Params& params)
	32	: BaseReader{params.interface}
33	33	{
34		char errbuf[PCAP_ERRBUF_SIZE]; // storage of error description
35		const char* device {source.c_str()};
	34	char errbuf[PCAP_ERRBUF_SIZE]; // storage of error description
	35	const char* device{source.c_str()};
36	36	handle = pcap_create(device, errbuf);
37	37	if(!handle)
38	38	{
39	39	throw PcapError("pcap_create", errbuf);
40	40	}
41	41
42		if(int status {pcap_set_snaplen(handle, params.snaplen)})
	42	if(int status{pcap_set_snaplen(handle, params.snaplen)})
43	43	{
44	44	throw PcapError("pcap_set_snaplen", pcap_statustostr(status));
45	45	}
46	46
47		if(int status {pcap_set_promisc(handle, params.promisc ? 1 : 0)})
	47	if(int status{pcap_set_promisc(handle, params.promisc ? 1 : 0)})
48	48	{
49	49	throw PcapError("pcap_set_promisc", pcap_statustostr(status));
50	50	}
51	51
52		if(int status {pcap_set_timeout(handle, params.timeout_ms)})
	52	if(int status{pcap_set_timeout(handle, params.timeout_ms)})
53	53	{
54	54	throw PcapError("pcap_set_timeout", pcap_statustostr(status));
55	55	}
56	56
57		if(int status {pcap_set_buffer_size(handle, params.buffer_size)})
	57	if(int status{pcap_set_buffer_size(handle, params.buffer_size)})
58	58	{
59	59	throw PcapError("pcap_set_buffer_size", pcap_statustostr(status));
60	60	}
61	61
62		if(int status {pcap_activate(handle)})
	62	if(int status{pcap_activate(handle)})
63	63	{
64	64	throw PcapError("pcap_activate", pcap_statustostr(status));
65	65	}
66	66
67		pcap_direction_t direction {PCAP_D_INOUT};
	67	pcap_direction_t direction{PCAP_D_INOUT};
68	68	switch(params.direction)
69	69	{
70	70	using Direction = CaptureReader::Direction;
71		case Direction::IN : direction = PCAP_D_IN; break;
72		case Direction::OUT : direction = PCAP_D_OUT; break;
73		case Direction::INOUT: direction = PCAP_D_INOUT; break;
	71	case Direction::IN:
	72	direction = PCAP_D_IN;
	73	break;
	74	case Direction::OUT:
	75	direction = PCAP_D_OUT;
	76	break;
	77	case Direction::INOUT:
	78	direction = PCAP_D_INOUT;
	79	break;
74	80	}
75		if(int status {pcap_setdirection(handle, direction)})
	81	if(int status{pcap_setdirection(handle, direction)})
76	82	{
77	83	throw PcapError("pcap_setdirection", pcap_statustostr(status));
78	84	}

93	99
94	100	void CaptureReader::print_statistic(std::ostream& out) const
95	101	{
96		struct pcap_stat stat={0,0,0};
	102	struct pcap_stat stat = {0, 0, 0};
97	103	if(pcap_stats(handle, &stat) == 0)
98	104	{
99	105	out << "Statistics from interface: " << source << '\n'

116	122	<< " buffer size : " << params.buffer_size << " bytes\n"
117	123	<< " promiscuous mode: " << (params.promisc ? "on" : "off") << '\n'
118	124	<< " capture traffic : ";
119		switch(params.direction)
120		{
121		using Direction = CaptureReader::Direction;
122		case Direction::IN : out << "in"; break;
123		case Direction::OUT : out << "out"; break;
124		case Direction::INOUT: out << "inout"; break;
125		}
	125	switch(params.direction)
	126	{
	127	using Direction = CaptureReader::Direction;
	128	case Direction::IN:
	129	out << "in";
	130	break;
	131	case Direction::OUT:
	132	out << "out";
	133	break;
	134	case Direction::INOUT:
	135	out << "inout";
	136	break;
	137	}
126	138	return out;
127	139	}
128	140

-9

src/filtration/pcap/capture_reader.h less more

31	31	{
32	32	namespace pcap
33	33	{
34
35	34	class CaptureReader : public BaseReader
36	35	{
37	36	public:

44	43
45	44	struct Params
46	45	{
47		std::string interface { };
48		std::string filter { };
49		int snaplen {0};
50		int timeout_ms {0};
	46	std::string interface{};
	47	std::string filter{};
	48	int snaplen{0};
	49	int timeout_ms{0};
51	50	int buffer_size{0};
52		bool promisc {true};
53		Direction direction {Direction::INOUT};
	51	bool promisc{true};
	52	Direction direction{Direction::INOUT};
54	53	};
55	54
56	55	CaptureReader(const Params& params);
57	56	~CaptureReader() = default;
58	57
59	58	void print_statistic(std::ostream& out) const override;
60
61	59	};
62	60
63	61	std::ostream& operator<<(std::ostream&, const CaptureReader::Params&);

66	64	} // namespace filtration
67	65	} // namespace NST
68	66	//------------------------------------------------------------------------------
69		#endif//CAPTURE_READER_H
	67	#endif // CAPTURE_READER_H
70	68	//------------------------------------------------------------------------------

-3

src/filtration/pcap/file_reader.cpp less more

27	27	{
28	28	namespace pcap
29	29	{
30
31		FileReader::FileReader(const std::string& file) : BaseReader{file}
	30	FileReader::FileReader(const std::string& file)
	31	: BaseReader{file}
32	32	{
33	33	char errbuf[PCAP_ERRBUF_SIZE];
34	34

43	43	std::ostream& operator<<(std::ostream& out, FileReader& f)
44	44	{
45	45	out << "Read packets from: " << f.source << '\n';
46		const int dlt {f.datalink()};
	46	const int dlt{f.datalink()};
47	47	out << " datalink: " << f.datalink_name(dlt) << " (" << f.datalink_description(dlt) << ")\n";
48	48	out << " version: " << f.major_version() << '.' << f.minor_version();
49	49	if(f.is_swapped()) out << "\n Note: file has data in swapped byte-order";

-10

src/filtration/pcap/file_reader.h less more

31	31	{
32	32	namespace pcap
33	33	{
34
35	34	class FileReader : public BaseReader
36	35	{
37	36	public:
38	37	explicit FileReader(const std::string& file);
39	38	~FileReader() = default;
40	39
41		inline FILE* get_file() { return pcap_file(handle); }
42
43		void print_statistic(std::ostream& /out/) const override { /dummy method/ }
44
45		inline int major_version() { return pcap_major_version(handle); }
46		inline int minor_version() { return pcap_minor_version(handle); }
47		inline bool is_swapped() { return pcap_is_swapped(handle); }
48
	40	inline FILE* get_file() { return pcap_file(handle); }
	41	void print_statistic(std::ostream& /out/) const override {}
	42	inline int major_version() { return pcap_major_version(handle); }
	43	inline int minor_version() { return pcap_minor_version(handle); }
	44	inline bool is_swapped() { return pcap_is_swapped(handle); }
49	45	friend std::ostream& operator<<(std::ostream& out, FileReader& f);
50	46	};
51	47

53	49	} // namespace filtration
54	50	} // namespace NST
55	51	//------------------------------------------------------------------------------
56		#endif//FILE_READER_H
	52	#endif // FILE_READER_H
57	53	//------------------------------------------------------------------------------

+60

-53

src/filtration/pcap/network_interfaces.h less more

21	21	#ifndef NETWORK_INTERFACES_H
22	22	#define NETWORK_INTERFACES_H
23	23	//------------------------------------------------------------------------------
24		#include <pcap/pcap.h>
25	24	#include <arpa/inet.h>
26	25	#include <netinet/in.h>
	26	#include <pcap/pcap.h>
27	27	#include <sys/socket.h>
28	28
29	29	#include "filtration/pcap/pcap_error.h"

34	34	{
35	35	namespace pcap
36	36	{
37
38	37	class NetworkInterfaces
39	38	{
40	39	public:

42	41	class Address
43	42	{
44	43	friend class Interface;
	44
45	45	public:
46		inline sockaddr* address() const noexcept { return addr->addr; }
47		inline sockaddr* netmask() const noexcept { return addr->netmask; }
	46	inline sockaddr* address() const noexcept { return addr->addr; }
	47	inline sockaddr* netmask() const noexcept { return addr->netmask; }
48	48	inline sockaddr* broadaddr() const noexcept { return addr->broadaddr; }
49		inline sockaddr* destaddr() const noexcept { return addr->dstaddr; }
50
51		Address& operator= (const Address&) = delete;
52		void operator& () = delete;
53		void* operator new (size_t) = delete;
54		void operator delete (void*) = delete;
55
56		inline operator bool() const noexcept { return addr != nullptr; }
57		inline void operator ++() noexcept { addr = addr->next; }
58		inline bool operator !=(const Address& a) const noexcept { return addr != a.addr; }
	49	inline sockaddr* destaddr() const noexcept { return addr->dstaddr; }
	50	Address& operator=(const Address&) = delete;
	51	void operator&() = delete;
	52	void* operator new(size_t) = delete;
	53	void operator delete(void*) = delete;
	54
	55	inline operator bool() const noexcept { return addr != nullptr; }
	56	inline void operator++() noexcept { addr = addr->next; }
	57	inline bool operator!=(const Address& a) const noexcept { return addr != a.addr; }
59	58	inline const Address operator() const noexcept { return this; }
60
61		Address(const Address& a) : addr{a.addr}{}
62
	59	Address(const Address& a)
	60	: addr{a.addr}
	61	{
	62	}
	63
63	64	private:
64		Address(pcap_addr_t* a) : addr{a}{}
	65	Address(pcap_addr_t* a)
	66	: addr{a}
	67	{
	68	}
65	69	pcap_addr_t* addr;
66	70	};
67	71
68	72	class Interface
69	73	{
70	74	friend class NetworkInterfaces;
	75
71	76	public:
72
73		inline const char* name() const noexcept { return ptr->name; }
74		inline const char* dscr() const noexcept { return ptr->description; }
75		inline bool is_loopback() const noexcept { return ptr->flags & PCAP_IF_LOOPBACK; }
76
77		Interface& operator= (const Interface&) = delete;
78		void operator& () = delete;
79		void* operator new (size_t) = delete;
80		void operator delete (void*) = delete;
81
82		inline operator bool() const noexcept { return ptr != nullptr; }
83		inline void operator ++() noexcept { ptr = ptr->next; }
84		inline bool operator !=(const Interface& i) const noexcept { return ptr != i.ptr; }
	77	inline const char* name() const noexcept { return ptr->name; }
	78	inline const char* dscr() const noexcept { return ptr->description; }
	79	inline bool is_loopback() const noexcept { return ptr->flags & PCAP_IF_LOOPBACK; }
	80	Interface& operator=(const Interface&) = delete;
	81	void operator&() = delete;
	82	void* operator new(size_t) = delete;
	83	void operator delete(void*) = delete;
	84
	85	inline operator bool() const noexcept { return ptr != nullptr; }
	86	inline void operator++() noexcept { ptr = ptr->next; }
	87	inline bool operator!=(const Interface& i) const noexcept { return ptr != i.ptr; }
85	88	inline const Interface operator() const noexcept { return this; }
86
87		Interface(const Interface& i) : ptr{i.ptr}{}
	89	Interface(const Interface& i)
	90	: ptr{i.ptr}
	91	{
	92	}
88	93
89	94	const Address begin() const noexcept { return Address{ptr->addresses}; }
90		const Address end() const noexcept { return Address{nullptr}; }
91
	95	const Address end() const noexcept { return Address{nullptr}; }
92	96	private:
93		Interface(pcap_if_t* p) : ptr{p}{}
	97	Interface(pcap_if_t* p)
	98	: ptr{p}
	99	{
	100	}
94	101	pcap_if_t* ptr;
95	102	};
96	103
97		inline NetworkInterfaces() : interfaces{nullptr}
	104	inline NetworkInterfaces()
	105	: interfaces{nullptr}
98	106	{
99	107	char errbuf[PCAP_ERRBUF_SIZE];
100	108	if(pcap_findalldevs(&interfaces, errbuf) == -1)

127	135	throw std::runtime_error{"No suitable device found.\n Note: reading an ip address of a network device may require special privileges."};
128	136	}
129	137
130		NetworkInterfaces(const NetworkInterfaces&) = delete;
	138	NetworkInterfaces(const NetworkInterfaces&) = delete;
131	139	NetworkInterfaces& operator=(const NetworkInterfaces&) = delete;
132		void operator& () = delete;
133		void* operator new (size_t) = delete;
134		void operator delete (void*) = delete;
	140	void operator&() = delete;
	141	void* operator new(size_t) = delete;
	142	void operator delete(void*) = delete;
135	143
136	144	const Interface begin() const noexcept { return Interface{interfaces}; }
137		const Interface end() const noexcept { return Interface{nullptr}; }
138
	145	const Interface end() const noexcept { return Interface{nullptr}; }
139	146	private:
140	147	pcap_if_t* interfaces;
141	148	};
142	149
143		std::ostream& operator <<(std::ostream& out, const NetworkInterfaces::Interface& i)
	150	std::ostream& operator<<(std::ostream& out, const NetworkInterfaces::Interface& i)
144	151	{
145	152	out.width(8);
146	153	out << std::left << i.name();
147		const char* dscr {i.dscr()};
	154	const char* dscr{i.dscr()};
148	155	if(dscr)
149	156	{
150	157	out << '(' << dscr << ')';

156	163	return out;
157	164	}
158	165
159		std::ostream& operator <<(std::ostream& out, const NetworkInterfaces::Address& a)
160		{
161		sockaddr* s_address {a.address()};
162		sockaddr* s_netmask {a.netmask()};
	166	std::ostream& operator<<(std::ostream& out, const NetworkInterfaces::Address& a)
	167	{
	168	sockaddr* s_address{a.address()};
	169	sockaddr* s_netmask{a.netmask()};
163	170	if(s_address)
164	171	{
165	172	switch(s_address->sa_family)

180	187	sizeof(netmask));
181	188	out << " netmask " << netmask;
182	189
183		sockaddr* s_broadaddr {a.broadaddr()};
	190	sockaddr* s_broadaddr{a.broadaddr()};
184	191	if(s_broadaddr)
185	192	{
186	193	char broadaddr[INET_ADDRSTRLEN]{};

191	198	out << " broadcast " << broadaddr;
192	199	}
193	200
194		sockaddr* s_destaddr {a.destaddr()};
	201	sockaddr* s_destaddr{a.destaddr()};
195	202	if(s_destaddr)
196	203	{
197	204	char destaddr[INET_ADDRSTRLEN]{};

237	244	} // namespace filtration
238	245	} // namespace NST
239	246	//------------------------------------------------------------------------------
240		#endif//NETWORK_INTERFACES_H
241		//------------------------------------------------------------------------------
	247	#endif // NETWORK_INTERFACES_H
	248	//------------------------------------------------------------------------------

-9

src/filtration/pcap/packet_dumper.h less more

31	31	{
32	32	namespace pcap
33	33	{
34
35	34	class PacketDumper
36	35	{
37	36	public:
38	37	PacketDumper(pcap_t* handle, const char* path)
39		: dumper{ pcap_dump_open(handle, path) }
	38	: dumper{pcap_dump_open(handle, path)}
40	39	{
41	40	if(dumper == nullptr)
42	41	{
43	42	throw PcapError{"pcap_dump_open", pcap_geterr(handle)};
44	43	}
45	44	}
46		PacketDumper(const PacketDumper&) = delete;
	45	PacketDumper(const PacketDumper&) = delete;
47	46	PacketDumper& operator=(const PacketDumper&) = delete;
48	47	~PacketDumper()
49	48	{
50	49	pcap_dump_close(dumper);
51	50	}
52	51
53		inline void dump(const pcap_pkthdr h, const u_char sp)
	52	inline void dump(const pcap_pkthdr* h, const u_char* sp)
54	53	{
55	54	pcap_dump((u_char*)dumper, h, sp);
56	55	}
57	56
58		inline void flush() { pcap_dump_flush(dumper); }
	57	inline void flush() { pcap_dump_flush(dumper); }
59	58	inline pcap_dumper_t* get_dumper() { return dumper; }
60	59	inline FILE* get_stream() { return pcap_dump_file(dumper); }
61
62		void truncate_all_pcap_data_and_header()
	60	void truncate_all_pcap_data_and_header()
63	61	{
64	62	pcap_dump_flush(dumper);
65		FILE* stream {pcap_dump_file(dumper)};
	63	FILE* stream{pcap_dump_file(dumper)};
66	64	rewind(stream); // truncate a file to zero
67	65	pcap_dump_flush(dumper);
68	66	}

75	73	} // namespace filtration
76	74	} // namespace NST
77	75	//------------------------------------------------------------------------------
78		#endif//PACKET_DUMPER_H
	76	#endif // PACKET_DUMPER_H
79	77	//------------------------------------------------------------------------------

-3

src/filtration/pcap/pcap_error.h less more

30	30	{
31	31	namespace pcap
32	32	{
33
34	33	class PcapError : public std::runtime_error
35	34	{
36	35	public:
37	36	explicit PcapError(const char* func, const char* errbuf)
38		: std::runtime_error{std::string{func}+"():"+std::string{errbuf}} { }
	37	: std::runtime_error{std::string{func} + "():" + std::string{errbuf}}
	38	{
	39	}
39	40	};
40	41
41	42	} // namespace pcap
42	43	} // namespace filtration
43	44	} // namespace NST
44	45	//------------------------------------------------------------------------------
45		#endif//PCAP_ERROR_H
	46	#endif // PCAP_ERROR_H
46	47	//------------------------------------------------------------------------------

-8

src/filtration/processing_thread.h less more

29	29	{
30	30	namespace filtration
31	31	{
32
33	32	class ProcessingThread
34	33	{
35	34	protected:
36	35	ProcessingThread(NST::controller::RunningStatus& s)
37		: status (s)
38		, processing {}
	36	: status(s)
	37	, processing{}
39	38	{
40	39	}
	40
41	41	public:
42	42	virtual ~ProcessingThread()
43	43	{

49	49
50	50	void start()
51	51	{
52		if(processing.joinable()) return; // already started
	52	if(processing.joinable()) return; // already started
53	53
54	54	processing = std::thread(&ProcessingThread::thread, this);
55	55	}
56	56
57		virtual void stop()= 0;
	57	virtual void stop() = 0;
58	58
59	59	private:
60	60	virtual void run() = 0;

63	63	{
64	64	try
65	65	{
66		this->run(); // virtual call
	66	this->run(); // virtual call
67	67	}
68	68	catch(...)
69	69	{

73	73
74	74	protected:
75	75	NST::controller::RunningStatus& status;
76		std::thread processing;
	76	std::thread processing;
77	77	};
78	78
79	79	} // namespace filtration
80	80	} // namespace NST
81	81	//------------------------------------------------------------------------------
82		#endif//PROCESSING_THREAD_H
	82	#endif // PROCESSING_THREAD_H
83	83	//------------------------------------------------------------------------------

+23

-26

src/filtration/queuing.h less more

31	31	{
32	32	namespace filtration
33	33	{
34
35	34	class Queueing
36	35	{
37	36	using Queue = NST::utils::FilteredDataQueue;
38	37	using Data = NST::utils::FilteredData;
39	38
40	39	public:
41
42	40	class Collection
43	41	{
44	42	public:
45	43	inline Collection() noexcept
46		: queue {nullptr}
47		, ptr {nullptr}
48		, session {nullptr}
	44	: queue{nullptr}
	45	, ptr{nullptr}
	46	, session{nullptr}
49	47	{
50	48	}
51	49	inline Collection(Queueing* q, utils::NetworkSession* s) noexcept
52		: queue {&q->queue}
53		, ptr {nullptr}
54		, session {s}
	50	: queue{&q->queue}
	51	, ptr{nullptr}
	52	, session{s}
55	53	{
56	54	}
57	55	inline ~Collection()

61	59	queue->deallocate(ptr);
62	60	}
63	61	}
64		Collection(Collection&&) = delete;
65		Collection(const Collection&) = delete;
	62	Collection(Collection&&) = delete;
	63	Collection(const Collection&) = delete;
66	64	Collection& operator=(const Collection&) = delete;
67	65
68	66	inline void set(Queueing& q, utils::NetworkSession* s)
69	67	{
70		queue = &q.queue;
	68	queue = &q.queue;
71	69	session = s;
72	70	}
73	71

77	75	{
78	76	// we have a reference to queue, just do allocate and reset
79	77	ptr = queue->allocate();
80		if (!ptr)
	78	if(!ptr)
81	79	{
82	80	LOG("free elements of the Queue are exhausted");
83	81	}

113	111	{
114	112	assert(nullptr != ptr);
115	113
116		uint8_t* offset_ptr { ptr->data + ptr->dlen };
117		const uint32_t avail { ptr->capacity() - ptr->dlen};
	114	uint8_t* offset_ptr{ptr->data + ptr->dlen};
	115	const uint32_t avail{ptr->capacity() - ptr->dlen};
118	116	if(len > avail) // inappropriate case. Must be one resize when get entire message size
119	117	{
120		ptr->resize(ptr->dlen + len); // [! unbound extension !]
	118	ptr->resize(ptr->dlen + len); // [! unbound extension !]
121	119	offset_ptr = ptr->data + ptr->dlen; // update pointer
122	120	}
123	121	memcpy(offset_ptr, info.data, len);

147	145	ptr = nullptr;
148	146	}
149	147
150		inline uint32_t data_size() const { return ptr->dlen; }
151		inline uint32_t capacity() const { return ptr->capacity(); }
152		inline const uint8_t* data() const { return ptr->data; }
153		inline operator bool() const { return ptr != nullptr; }
154
	148	inline uint32_t data_size() const { return ptr->dlen; }
	149	inline uint32_t capacity() const { return ptr->capacity(); }
	150	inline const uint8_t* data() const { return ptr->data; }
	151	inline operator bool() const { return ptr != nullptr; }
155	152	private:
156		Queue* queue;
157		Data* ptr;
	153	Queue* queue;
	154	Data* ptr;
158	155	utils::NetworkSession* session;
159	156	};
160	157
161	158	Queueing(Queue& q)
162		: queue(q)
	159	: queue(q)
163	160	{
164	161	}
165	162	~Queueing()
166	163	{
167	164	}
168		Queueing(Queueing&&) = delete;
169		Queueing(const Queueing&) = delete;
	165	Queueing(Queueing&&) = delete;
	166	Queueing(const Queueing&) = delete;
170	167	Queueing& operator=(const Queueing&) = delete;
171	168
172	169	private:

176	173	} // namespace filtration
177	174	} // namespace NST
178	175	//------------------------------------------------------------------------------
179		#endif//QUEUING_H
	176	#endif // QUEUING_H
180	177	//------------------------------------------------------------------------------

+32

-33

src/filtration/rpc_filtrator.h less more

26	26
27	27	#include <pcap/pcap.h>
28	28
29		#include "filtration/packet.h"
30	29	#include "filtration/filtratorimpl.h"
	30	#include "protocols/netbios/netbios.h"
31	31	#include "protocols/nfs3/nfs3_utils.h"
32	32	#include "protocols/nfs4/nfs4_utils.h"
33		#include "protocols/netbios/netbios.h"
34	33	#include "protocols/rpc/rpc_header.h"
35	34	#include "utils/log.h"
36	35	//------------------------------------------------------------------------------

38	37	{
39	38	namespace filtration
40	39	{
41
42	40	/*
43	41	Stateful reader of Sun RPC messages
44	42	Reads data from PacketInfo passed via push() method
45	43	aggregates length of current RPC message and length of RPC message useful for analysis
46	44	TODO: add matching Calls and replies by XID of message
47	45	*/
48		template<typename Writer>
	46	template <typename Writer>
49	47	class RPCFiltrator : public FiltratorImpl<RPCFiltrator<Writer>, Writer>
50	48	{
51	49	using BaseImpl = FiltratorImpl<RPCFiltrator<Writer>, Writer>;
	50
52	51	public:
53	52	RPCFiltrator()
54	53	: BaseImpl()

64	63
65	64	constexpr static size_t lengthOfBaseHeader()
66	65	{
67		return sizeof(RecordMark) + sizeof(ReplyHeader);// Minimum of replay&call headers
	66	return sizeof(RecordMark) + sizeof(ReplyHeader); // Minimum of replay&call headers
68	67	}
69	68
70	69	constexpr static size_t lengthOfReplyHeader()

79	78
80	79	inline static bool isRightHeader(const uint8_t* header)
81	80	{
82		const RecordMark* rm {reinterpret_cast<const RecordMark*>(header)};
	81	const RecordMark* rm{reinterpret_cast<const RecordMark*>(header)};
83	82	const MessageHeader* const msg = rm->fragment();
84		if (msg->type() == MsgType::REPLY)
	83	if(msg->type() == MsgType::REPLY)
85	84	{
86	85	return RPCValidator::check(static_cast<const ReplyHeader* const>(msg));
87	86	}
88		if (msg->type() == MsgType::CALL)
	87	if(msg->type() == MsgType::CALL)
89	88	{
90	89	return RPCValidator::check(static_cast<const CallHeader* const>(msg));
91	90	}

104	103
105	104	inline bool find_and_read_message(PacketInfo& info, typename Writer::Collection& collection)
106	105	{
107		const RecordMark* rm {reinterpret_cast<const RecordMark*>(collection.data())};
	106	const RecordMark* rm{reinterpret_cast<const RecordMark*>(collection.data())};
108	107	//if(rm->is_last()); // TODO: handle sequence field of record mark
109		if (collection.data_size() < (sizeof(CallHeader) + sizeof(RecordMark)) && (rm->fragment())->type() != MsgType::REPLY ) // if message not Reply, try collect the rest for Call
	108	if(collection.data_size() < (sizeof(CallHeader) + sizeof(RecordMark)) && (rm->fragment())->type() != MsgType::REPLY) // if message not Reply, try collect the rest for Call
110	109	{
111	110	return true;
112	111	}
113		if (rm->fragment_len() >= sizeof(ReplyHeader)) // incorrect fragment len, not valid rpc message
114		{
115		if (validate_header(rm->fragment(), rm->fragment_len() + sizeof(RecordMark) ) )
	112	if(rm->fragment_len() >= sizeof(ReplyHeader)) // incorrect fragment len, not valid rpc message
	113	{
	114	if(validate_header(rm->fragment(), rm->fragment_len() + sizeof(RecordMark)))
116	115	{
117	116	return BaseImpl::read_message(info);
118	117	}

122	121
123	122	inline bool validate_header(const MessageHeader* const msg, const size_t len)
124	123	{
125		switch (msg->type())
	124	switch(msg->type())
126	125	{
127	126	case MsgType::CALL:
128	127	{
129	128	auto call = static_cast<const CallHeader* const>(msg);
130		if (RPCValidator::check(call))
131		{
132		BaseImpl::setMsgLen(len); // length of current RPC message
133		if (protocols::NFS3::Validator::check(call))
134		{
135		uint32_t proc {call->proc()};
136		if (API::ProcEnumNFS3::WRITE == proc) // truncate NFSv3 WRITE call message to NFSv3-RW-limit
	129	if(RPCValidator::check(call))
	130	{
	131	BaseImpl::setMsgLen(len); // length of current RPC message
	132	if(protocols::NFS3::Validator::check(call))
	133	{
	134	uint32_t proc{call->proc()};
	135	if(API::ProcEnumNFS3::WRITE == proc) // truncate NFSv3 WRITE call message to NFSv3-RW-limit
137	136	{
138	137	BaseImpl::setToBeCopied(nfs3_rw_hdr_max < len ? nfs3_rw_hdr_max : len);
139	138	}
140	139	else
141	140	{
142		if (API::ProcEnumNFS3::READ == proc)
	141	if(API::ProcEnumNFS3::READ == proc)
143	142	{
144	143	nfs3_read_match.insert(call->xid());
145	144	}

147	146	}
148	147	//TRACE("%p\| MATCH RPC Call xid:%u len: %u procedure: %u", this, call->xid(), msg_len, call->proc());
149	148	}
150		else if (protocols::NFS4::Validator::check(call))
	149	else if(protocols::NFS4::Validator::check(call))
151	150	{
152	151	BaseImpl::setToBeCopied(len);
153	152	}
154	153	else
155	154	{
156	155	//* RPC call message must be read out ==> msg_len !=0
157		BaseImpl::setToBeCopied(0);// don't collect headers of unknown calls
	156	BaseImpl::setToBeCopied(0); // don't collect headers of unknown calls
158	157	//TRACE("Unknown RPC call of program: %u version: %u procedure: %u", call->prog(), call->vers(), call->proc());
159	158	}
160	159	return true;
161	160	}
162	161	else
163	162	{
164		return false; // isn't RPC Call, stream is corrupt
	163	return false; // isn't RPC Call, stream is corrupt
165	164	}
166	165	}
167	166	break;
168	167	case MsgType::REPLY:
169	168	{
170	169	auto reply = static_cast<const ReplyHeader* const>(msg);
171		if (RPCValidator::check(reply))
172		{
173		BaseImpl::setMsgLen(len); // length of current RPC message
	170	if(RPCValidator::check(reply))
	171	{
	172	BaseImpl::setMsgLen(len); // length of current RPC message
174	173	// Truncate NFSv3 READ reply message to NFSv3-RW-limit
175	174	//* Collect fully if reply received before matching call
176		if (nfs3_read_match.erase(reply->xid()) > 0)
	175	if(nfs3_read_match.erase(reply->xid()) > 0)
177	176	{
178	177	BaseImpl::setToBeCopied(std::min(nfs3_rw_hdr_max, len));
179	178	}
180	179	else
181	180	{
182		BaseImpl::setToBeCopied(len);// length of current RPC message
	181	BaseImpl::setToBeCopied(len); // length of current RPC message
183	182	}
184	183	//TRACE("%p\| MATCH RPC Reply xid:%u len: %u", this, reply->xid(), msg_len);
185	184	return true;

203	202	}
204	203
205	204	private:
206		size_t nfs3_rw_hdr_max {512}; // limit for NFSv3 to truncate WRITE call and READ reply messages
	205	size_t nfs3_rw_hdr_max{512}; // limit for NFSv3 to truncate WRITE call and READ reply messages
207	206	MessageSet nfs3_read_match;
208	207	};
209	208
210	209	} // namespace filtration
211	210	} // namespace NST
212	211	//------------------------------------------------------------------------------
213		#endif//RPC_FILTRATOR_H
214		//------------------------------------------------------------------------------
	212	#endif // RPC_FILTRATOR_H
	213	//------------------------------------------------------------------------------

+30

-37

src/filtration/sessions_hash.h less more

37	37	{
38	38	namespace filtration
39	39	{
40
41	40	struct MapperImpl
42	41	{
43	42	using Session = NST::utils::Session;

47	46
48	47	static inline Session::Direction ipv4_direction(const Session& key)
49	48	{
50		if(key.port[0] < key.port[1]) return Session::Source;
51		else
52		if(key.port[0] > key.port[1]) return Session::Destination;
	49	if(key.port[0] < key.port[1])
	50	return Session::Source;
	51	else if(key.port[0] > key.port[1])
	52	return Session::Destination;
53	53
54	54	// Ok, ports are equal, compare addresses
55	55	return (key.ip.v4.addr[0] < key.ip.v4.addr[1]) ? Session::Source : Session::Destination;

57	57
58	58	struct IPv4PortsKeyHash
59	59	{
60		inline std::size_t operator() (const Session& key) const
	60	inline std::size_t operator()(const Session& key) const
61	61	{
62	62	return key.port[0] +
63	63	key.port[1] +

68	68
69	69	struct IPv4PortsKeyEqual
70	70	{
71		inline bool operator() (const Session& a, const Session& b) const
	71	inline bool operator()(const Session& a, const Session& b) const
72	72	{
73	73	if((a.port[0] == b.port[0]) &&
74	74	(a.port[1] == b.port[1]) &&

87	87
88	88	static inline Session::Direction ipv6_direction(const Session& key)
89	89	{
90		if(key.port[0] < key.port[1]) return Session::Source;
91		else
92		if(key.port[0] > key.port[1]) return Session::Destination;
	90	if(key.port[0] < key.port[1])
	91	return Session::Source;
	92	else if(key.port[0] > key.port[1])
	93	return Session::Destination;
93	94
94	95	// Ok, ports are equal, compare addresses
95		const uint32_t* s { key.ip.v6.addr_uint32[0] };
96		const uint32_t* d { key.ip.v6.addr_uint32[1] };
	96	const uint32_t* s{key.ip.v6.addr_uint32[0]};
	97	const uint32_t* d{key.ip.v6.addr_uint32[1]};
97	98
98	99	if(s[0] != d[0]) return (s[0] < d[0]) ? Session::Source : Session::Destination;
99	100	if(s[1] != d[1]) return (s[1] < d[1]) ? Session::Source : Session::Destination;
100	101	if(s[2] != d[2]) return (s[2] < d[2]) ? Session::Source : Session::Destination;
101	102
102		return (s[3] < d[3]) ? Session::Source : Session::Destination;
	103	return (s[3] < d[3]) ? Session::Source : Session::Destination;
103	104	}
104	105
105	106	static inline void copy_ipv6(uint32_t dst[4], const uint8_t src[16])
106	107	{
107		// TODO:: fix alignment of src!
108		const uint32_t* s { reinterpret_cast<const uint32_t*>(src) };
109		dst[0] = s[0];
110		dst[1] = s[1];
111		dst[2] = s[2];
112		dst[3] = s[3];
	108	uint8_t* d{reinterpret_cast<uint8_t*>(dst)};
	109	memcpy(d, src, sizeof(uint32_t) * 4);
113	110	}
114	111
115	112	struct IPv6PortsKeyHash
116	113	{
117		std::size_t operator() (const Session& key) const
	114	std::size_t operator()(const Session& key) const
118	115	{
119	116	std::size_t ret = key.port[0] + key.port[1];
120	117

142	139	a[3] == b[3];
143	140	}
144	141
145		bool operator() (const Session& a, const Session& b) const
	142	bool operator()(const Session& a, const Session& b) const
146	143	{
147	144	if((a.port[0] == b.port[0]) && (a.port[1] == b.port[1]))
148	145	{
149		if( eq_ipv6_address(a.ip.v6.addr_uint32[0], b.ip.v6.addr_uint32[0] )
150		&& eq_ipv6_address(a.ip.v6.addr_uint32[1], b.ip.v6.addr_uint32[1] ))
	146	if(eq_ipv6_address(a.ip.v6.addr_uint32[0], b.ip.v6.addr_uint32[0]) && eq_ipv6_address(a.ip.v6.addr_uint32[1], b.ip.v6.addr_uint32[1]))
151	147	return true;
152	148	}
153	149
154	150	if((a.port[1] == b.port[0]) && (a.port[0] == b.port[1]))
155	151	{
156		if( eq_ipv6_address(a.ip.v6.addr_uint32[1], b.ip.v6.addr_uint32[0] )
157		&& eq_ipv6_address(a.ip.v6.addr_uint32[0], b.ip.v6.addr_uint32[1] ))
	152	if(eq_ipv6_address(a.ip.v6.addr_uint32[1], b.ip.v6.addr_uint32[0]) && eq_ipv6_address(a.ip.v6.addr_uint32[0], b.ip.v6.addr_uint32[1]))
158	153	return true;
159	154	}
160	155	return false;

283	278	};
284	279
285	280	// SessionsHash creates sessions and stores them in hash
286		template
287		<
288		typename Mapper, // map PacketInfo& to SessionImpl*
289		typename SessionImpl, // mapped type
290		typename Writer
291		>
	281	template <
	282	typename Mapper, // map PacketInfo& to SessionImpl*
	283	typename SessionImpl, // mapped type
	284	typename Writer>
292	285	class SessionsHash
293	286	{
294	287	public:

300	293	typename Mapper::KeyEqual>;
301	294
302	295	SessionsHash(Writer* w)
303		: sessions { }
304		, writer {w}
305		, max_hdr {0}
	296	: sessions{}
	297	, writer{w}
	298	, max_hdr{0}
306	299	{
307	300	max_hdr = controller::Parameters::rpcmsg_limit();
308	301	}

322	315	auto i = sessions.find(key);
323	316	if(i == sessions.end())
324	317	{
325		std::unique_ptr<SessionImpl> ptr{ new SessionImpl{writer, max_hdr} };
	318	std::unique_ptr<SessionImpl> ptr{new SessionImpl{writer, max_hdr}};
326	319
327	320	auto res = sessions.emplace(key, ptr.get());
328	321	if(res.second) // add new - success

342	335	private:
343	336	Container sessions;
344	337	Writer* writer;
345		uint32_t max_hdr;
	338	uint32_t max_hdr;
346	339	};
347	340
348	341	} // namespace filtration
349	342	} // namespace NST
350	343	//------------------------------------------------------------------------------
351		#endif//SESSIONS_HASH_H
352		//------------------------------------------------------------------------------
	344	#endif // SESSIONS_HASH_H
	345	//------------------------------------------------------------------------------

-3

src/main.cpp less more

30	30	{
31	31	Parameters params(argc, argv); // set and validate CLI options
32	32
33		if (params.show_help() \|\| params.show_enum())
	33	if(params.show_help() \|\| params.show_enum())
34	34	{
35	35	return 0; // -h or -E were passed
36	36	}

39	39
40	40	return controller.run();
41	41	}
42		catch (const std::exception& e)
	42	catch(const std::exception& e)
43	43	{
44	44	std::cerr << argv[0] << ": " << e.what() << std::endl;
45	45	return -1;
46	46	}
47		catch (...)
	47	catch(...)
48	48	{
49	49	std::cerr << argv[0] << ": Unknown exception" << std::endl;
50	50	return -1;

-7

src/protocols/cifs/cifs.cpp less more

20	20	//------------------------------------------------------------------------------
21	21	#include <cassert>
22	22
	23	#include "api/plugin_api.h" // for NST_PUBLIC
23	24	#include "protocols/cifs/cifs.h"
24	25	//------------------------------------------------------------------------------
25	26	using namespace NST::protocols::CIFSv1;
26	27	using namespace NST::API;
27		union SMBCode
28		{
29		uint8_t codes[4];
	28	union SMBCode {
	29	uint8_t codes[4];
30	30	uint32_t code;
31	31	};
32	32

44	44
45	45	const NST::protocols::CIFSv1::MessageHeader* NST::protocols::CIFSv1::get_header(const uint8_t* data)
46	46	{
47		static uint32_t code = get_code ();
	47	static uint32_t code = get_code();
48	48
49		const MessageHeader* header (reinterpret_cast<const MessageHeader*>(data));
50		if (header->head_code == code)
	49	const MessageHeader* header(reinterpret_cast<const MessageHeader*>(data));
	50	if(header->head_code == code)
51	51	{
52	52	return header;
53	53	}

59	59	return static_cast<const uint8_t>(flag) & static_cast<const uint8_t>(flags);
60	60	}
61	61
62		const char* NST::protocols::CIFSv1::print_cifs1_procedures(SMBv1Commands cmd_code)
	62	extern "C" NST_PUBLIC const char* print_cifs1_procedures(SMBv1Commands cmd_code)
63	63	{
64	64	assert(cmd_code < SMBv1Commands::CMD_COUNT);
65	65
	66	// clang-format off
66	67	static const char* const commandNames[] =
67	68	{
68	69	"CREATE_DIRECTORY", "DELETE_DIRECTORY", "OPEN", "CREATE",

85	86	"CLOSE_PRINT_FILE", "GET_PRINT_QUEUE", "READ_BULK", "WRITE_BULK",
86	87	"WRITE_BULK_DATA", "INVALID", "NO_ANDX_COMMAND"
87	88	};
	89	// clang-format on
88	90
89	91	return commandNames[static_cast<int>(cmd_code)];
90	92	}

-6

src/protocols/cifs/cifs.h less more

26	26	#include "api/cifs_types.h"
27	27	#include "protocols/netbios/netbios.h"
28	28	//------------------------------------------------------------------------------
29		#define NST_PUBLIC __attribute__ ((visibility("default")))
30	29	//------------------------------------------------------------------------------
31	30	namespace NST
32	31	{

34	33	{
35	34	namespace CIFSv1
36	35	{
	36	// clang-format off
37	37
38	38	using SMBv1Commands = NST::API::SMBv1::SMBv1Commands;
39	39

220	220	return cmd;
221	221	}
222	222
223		extern "C"
224		NST_PUBLIC
225		const char* print_cifs1_procedures(SMBv1Commands cmd_code);
	223	// clang-format on
226	224
227	225	} // namespace CIFSv1
228	226	} // namespace protocols
229	227	} // namespace NST
230	228	//------------------------------------------------------------------------------
231		#endif//CIFS_HEADER_H
232		//------------------------------------------------------------------------------
	229	#endif // CIFS_HEADER_H
	230	//------------------------------------------------------------------------------

+23

-17

src/protocols/cifs2/cifs2.cpp less more

23	23	#include <arpa/inet.h>
24	24	#include <assert.h>
25	25
	26	#include "api/cifs_pc_to_net.h"
	27	#include "api/plugin_api.h" // for NST_PUBLIC
	28	#include "protocols/cifs/cifs.h"
26	29	#include "protocols/cifs2/cifs2.h"
27		#include "protocols/cifs/cifs.h"
28		#include "api/cifs_pc_to_net.h"
29	30	//------------------------------------------------------------------------------
30	31	using namespace NST::protocols::CIFSv2;
31	32
32		# if NFSTRACE_BYTE_ORDER == NFSTRACE_BIG_ENDIAN
	33	#if NFSTRACE_BYTE_ORDER == NFSTRACE_BIG_ENDIAN
33	34
34	35	inline uint64_t ntohll(uint64_t input)
35	36	{

37	38	return input;
38	39	}
39	40
40		# else
41		# if NFSTRACE_BYTE_ORDER == NFSTRACE_LITTLE_ENDIAN
	41	#else
	42	#if NFSTRACE_BYTE_ORDER == NFSTRACE_LITTLE_ENDIAN
42	43
43	44	inline uint64_t ntohll(uint64_t input)
44	45	{
45	46	return be64toh(input);
46	47	}
47		# endif
48		# endif
	48	#endif
	49	#endif
49	50
50		union SMBCode
51		{
52		uint8_t codes[4];
	51	union SMBCode {
	52	uint8_t codes[4];
53	53	uint32_t code;
54	54	};
55	55

67	67
68	68	const NST::protocols::CIFSv2::MessageHeader* NST::protocols::CIFSv2::get_header(const uint8_t* data)
69	69	{
70		static uint32_t code = get_code ();
	70	static uint32_t code = get_code();
71	71
72		const MessageHeader* header (reinterpret_cast<const MessageHeader*>(data));
73		if (header->head_code == code)
	72	const MessageHeader* header(reinterpret_cast<const MessageHeader*>(data));
	73	if(header->head_code == code)
74	74	{
75	75	return header;
76	76	}

84	84
85	85	void NST::protocols::CIFSv2::parseGuid(uint8_t (&guid)[16])
86	86	{
87		Guid &p = reinterpret_cast<Guid&>(guid);
	87	Guid& p = reinterpret_cast<Guid&>(guid);
88	88	p.Data1 = le32toh(p.Data1);
89	89	p.Data2 = le16toh(p.Data2);
90	90	p.Data3 = le16toh(p.Data3);
91	91	}
92	92
93		void NST::protocols::CIFSv2::parse(SMBv2::ErrResponse*&) { }
	93	void NST::protocols::CIFSv2::parse(SMBv2::ErrResponse*&)
	94	{
	95	}
94	96	void NST::protocols::CIFSv2::parse(SMBv2::NegotiateRequest*& p)
95	97	{
96	98	parseGuid(p->clientGUID);

99	101	{
100	102	parseGuid(p->serverGUID);
101	103	}
	104
	105	// clang-format off
102	106	void NST::protocols::CIFSv2::parse(SMBv2::SessionSetupRequest*&){ }
103	107	void NST::protocols::CIFSv2::parse(SMBv2::SessionSetupResponse*&) { }
104	108	void NST::protocols::CIFSv2::parse(SMBv2::LogOffRequest*&) { }

137	141	void NST::protocols::CIFSv2::parse(SMBv2::SetInfoResponse*&){ }
138	142	void NST::protocols::CIFSv2::parse(SMBv2::CancelResponce*&){ }
139	143	void NST::protocols::CIFSv2::parse(SMBv2::CancelRequest*&){ }
	144	// clang-format on
140	145
141	146	// TODO: This implementation currently copy of
142	147	// epm-nfs/analyzers/src/cifs/cifs2_commands.cpp
143	148	// const std::string NST::breakdown::SMBv2Commands::command_name(int cmd_code)
144	149	// Futre fix: We need to merege these enums
145	150	// TODO: Move implementation to some common module
146		const char* NST::protocols::CIFSv2::print_cifs2_procedures(SMBv2Commands cmd)
	151	extern "C" NST_PUBLIC const char* print_cifs2_procedures(SMBv2Commands cmd)
147	152	{
148	153	assert(cmd < SMBv2Commands::CMD_COUNT);
149	154
	155	// clang-format off
150	156	static const char* const commandNames[] =
151	157	{
152	158	"NEGOTIATE", "SESSION SETUP", "LOGOFF", "TREE CONNECT",

155	161	"CANCEL", "ECHO", "QUERY DIRECTORY", "CHANGE NOTIFY",
156	162	"QUERY INFO", "SET INFO", "OPLOCK BREAK"
157	163	};
	164	// clang-format on
158	165
159	166	return commandNames[static_cast<int>(cmd)];
160	167	}
161

+10

-12

src/protocols/cifs2/cifs2.h less more

21	21	#ifndef CIFSv2_HEADER_H
22	22	#define CIFSv2_HEADER_H
23	23	//------------------------------------------------------------------------------
	24	#include "api/cifs2_commands.h"
24	25	#include "api/cifs_commands.h"
25		#include "api/cifs2_commands.h"
26	26	#include "protocols/cifs/cifs.h"
27	27	//------------------------------------------------------------------------------
28	28	namespace NST

31	31	{
32	32	namespace CIFSv2
33	33	{
34
35	34	using SMBv2Commands = NST::API::SMBv2::SMBv2Commands;
36		namespace SMBv2 = NST::API::SMBv2;
	35	namespace SMBv2 = NST::API::SMBv2;
	36	// clang-format off
37	37	// https://msdn.microsoft.com/en-us/library/ff718266.aspx
38	38	struct Guid
39	39	{

112	112	* \return pointer to input data which is casted to header structure or nullptr (if it is not valid header)
113	113	*/
114	114	const MessageHeader* get_header(const uint8_t* data);
	115
	116	// clang-format on
115	117
116	118	void parseGuid(uint8_t (&guid)[16]);
117	119	void parse(SMBv2::ErrResponse*&);

176	178	// we have to cast raw data to pointer type ( in contrast to const pointer )
177	179	//
178	180	auto req_header = reinterpret_cast<RawMessageHeader*>(request->data);
179		auto pargs = reinterpret_cast<typename Cmd::RequestType*>(request->data + sizeof(RawMessageHeader));
	181	auto pargs = reinterpret_cast<typename Cmd::RequestType*>(request->data + sizeof(RawMessageHeader));
180	182
181	183	parse(pargs);
182	184

184	186	if(response)
185	187	{
186	188	cmd.res_header = reinterpret_cast<RawMessageHeader*>(response->data);
187		cmd.pres = reinterpret_cast<typename Cmd::ResponseType*>(response->data + sizeof(RawMessageHeader));
	189	cmd.pres = reinterpret_cast<typename Cmd::ResponseType*>(response->data + sizeof(RawMessageHeader));
188	190	}
189		cmd.parg = pargs;
	191	cmd.parg = pargs;
190	192	return cmd;
191	193	}
192
193		extern "C"
194		NST_PUBLIC
195		const char* print_cifs2_procedures(SMBv2Commands cmd_code);
196	194
197	195	} // namespace CIFSv2
198	196	} // namespace protocols
199	197	} // namespace NST
200	198	//------------------------------------------------------------------------------
201		#endif//CIFSv2_HEADER_H
202		//------------------------------------------------------------------------------
	199	#endif // CIFSv2_HEADER_H
	200	//------------------------------------------------------------------------------

+123

-82

src/protocols/cifs2/cifs2_utils.cpp less more

0	0	//------------------------------------------------------------------------------
1		// Author: Artsem Iliasau
	1	// Author: Artsem Iliasau
2	2	// Description: Helpers for parsing CIFSv2 structures.
3	3	// Copyright (c) 2015 EPAM Systems
4	4	//------------------------------------------------------------------------------

21	21	#include <iostream>
22	22	#include <type_traits>
23	23
24		#include "cifs2.h"
25		#include "cifs2_utils.h"
	24	#include "api/plugin_api.h" // for print_cifs2_procedures(value)
	25	#include "protocols/cifs2/cifs2.h"
	26	#include "protocols/cifs2/cifs2_utils.h"
26	27	#include "protocols/nfs/nfs_utils.h"
27	28	//------------------------------------------------------------------------------
28	29	static const std::string flagDelimiter = " \| ";

33	34	{
34	35	namespace CIFSv2
35	36	{
36
37	37	using namespace NST::API::SMBv2;
38	38
39	39	namespace
40	40	{
41
42	41	template <typename T>
43	42	void print_flag_if_set(std::ostream& out, const std::string& name, typename std::underlying_type<T>::type& value, T flag)
44	43	{
45	44	auto int_flag = to_integral(flag);
46		if (value & int_flag)
	45	if(value & int_flag)
47	46	{
48	47	out << name;
49	48	value = value & ~int_flag;

54	53
55	54	const char* enumToString(OplockLevels value)
56	55	{
	56	// clang-format off
57	57	switch (value)
58	58	{
59	59	case OplockLevels::NONE: return "NONE";

62	62	case OplockLevels::BATCH: return "BATCH";
63	63	case OplockLevels::LEASE: return "LEASE";
64	64	}
	65	// clang-format on
65	66
66	67	return nullptr;
67	68	}
68	69
69	70	const char* enumToString(ImpersonationLevels value)
70	71	{
	72	// clang-format off
71	73	switch (value)
72	74	{
73	75	case ImpersonationLevels::ANONYMOUS: return "ANONYMOUS";

75	77	case ImpersonationLevels::IMPERSONATION: return "IMPERSONATION";
76	78	case ImpersonationLevels::DELEGATE: return "DELEGATE";
77	79	}
	80	// clang-format on
78	81
79	82	return nullptr;
80	83	}
81	84
82	85	const char* enumToString(CreateDisposition value)
83	86	{
	87	// clang-format off
84	88	switch (value)
85	89	{
86	90	case CreateDisposition::SUPERSEDE: return "SUPERSEDE";

90	94	case CreateDisposition::OVERWRITE: return "OVERWRITE";
91	95	case CreateDisposition::OVERWRITE_IF: return "OVERWRITE_IF";
92	96	}
	97	// clang-format on
93	98
94	99	return nullptr;
95	100	}
96	101
97	102	const char* enumToString(CreateActions value)
98	103	{
	104	// clang-format off
99	105	switch (value)
100	106	{
101	107	case CreateActions::SUPERSEDED: return "SUPERSEDED";

103	109	case CreateActions::CREATED: return "CREATED";
104	110	case CreateActions::FILE_OVERWRITTEN: return "FILE_OVERWRITTEN";
105	111	}
	112	// clang-format on
106	113
107	114	return nullptr;
108	115	}
109	116
110	117	const char* enumToString(ShareTypes value)
111	118	{
	119	// clang-format off
112	120	switch (value)
113	121	{
114	122	case ShareTypes::DISK: return "SMB2_SHARE_TYPE_DISK";
115	123	case ShareTypes::PIPE: return "SMB2_SHARE_TYPE_PIPE";
116	124	case ShareTypes::PRINT: return "SMB2_SHARE_TYPE_PRINT";
117	125	}
	126	// clang-format on
118	127
119	128	return nullptr;
120	129	}
121	130
122	131	const char* enumToString(NTStatus value)
123	132	{
	133	// clang-format off
124	134	switch (value)
125	135	{
126	136	case NTStatus::STATUS_SUCCESS: return "STATUS_SUCCESS";

150	160	case NTStatus::STATUS_NOT_A_DIRECTORY: return "STATUS_NOT_A_DIRECTORY";
151	161	case NTStatus::STATUS_CANCELLED: return "STATUS_CANCELLED";
152	162	}
	163	// clang-format on
153	164
154	165	return nullptr;
155	166	}
156	167
157	168	const char* enumToString(FsInfoLevels value)
158	169	{
	170	// clang-format off
159	171	switch (value)
160	172	{
161	173	case FsInfoLevels::SMB2_FS_INFO_01: return "SMB2_FS_INFO_01";

166	178	case FsInfoLevels::SMB2_FS_INFO_06: return "SMB2_FS_INFO_06";
167	179	case FsInfoLevels::SMB2_FS_INFO_07: return "SMB2_FS_INFO_07";
168	180	}
	181	// clang-format on
169	182
170	183	return nullptr;
171	184	}
172	185
173	186	const char* enumToString(QueryInfoLevels value)
174	187	{
	188	// clang-format off
175	189	switch (value)
176	190	{
177	191	case QueryInfoLevels::DIRECTORY_INFORMATION: return "DIRECTORY_INFORMATION";

220	234	case QueryInfoLevels::ID_GLOBAL_TX_DIRECTORY_INFORMATION: return "ID_GLOBAL_TX_DIRECTORY_INFORMATION";
221	235	case QueryInfoLevels::STANDARD_LINK_INFORMATION: return "STANDARD_LINK_INFORMATION";
222	236	}
	237	// clang-format on
223	238
224	239	return nullptr;
225	240	}
226	241
227	242	const char* enumToString(CtlCodes value)
228	243	{
	244	// clang-format off
229	245	switch (value)
230	246	{
231	247	case CtlCodes::SCTL_DFS_GET_REFERRALS: return "SCTL_DFS_GET_REFERRALS";

244	260	case CtlCodes::FSCTL_FILE_LEVEL_TRIM: return "FSCTL_FILE_LEVEL_TRIM";
245	261	case CtlCodes::FSCTL_VALIDATE_NEGOTIATE_INFO: return "FSCTL_VALIDATE_NEGOTIATE_INFO";
246	262	}
	263	// clang-format on
247	264
248	265	return nullptr;
249	266	}
250	267
251	268	const char* enumToString(InfoTypes value)
252	269	{
	270	// clang-format off
253	271	switch (value)
254	272	{
255	273	case InfoTypes::FILE: return "SMB2_0_INFO_FILE";

257	275	case InfoTypes::SECURITY: return "SMB2_0_INFO_SECURITY";
258	276	case InfoTypes::QUOTA: return "SMB2_0_INFO_QUOTA";
259	277	}
	278	// clang-format on
260	279
261	280	return nullptr;
262	281	}
263	282
264	283	const char* enumToString(SessionFlagsBinding value)
265		{
266		switch (value)
267		{
268		case SessionFlagsBinding::NONE: return "NONE";
269		case SessionFlagsBinding::BINDING: return "BINDING";
270		}
271
272		return nullptr;
273		}
274
275		}
	284	{
	285	// clang-format off
	286	switch (value)
	287	{
	288	case SessionFlagsBinding::NONE: return "NONE";
	289	case SessionFlagsBinding::BINDING: return "BINDING";
	290	}
	291	// clang-format on
	292
	293	return nullptr;
	294	}
	295
	296	} // namespace <unnamed>
276	297
277	298	std::ostream& operator<<(std::ostream& out, const SMBv2::SMBv2Commands value)
278	299	{
279		const char* strCommand = NST::protocols::CIFSv2::print_cifs2_procedures(value);
	300	const char* strCommand = print_cifs2_procedures(value);
280	301
281	302	out << "(" << strCommand << ")";
282	303

285	306
286	307	std::ostream& operator<<(std::ostream& out, const OplockLevels value)
287	308	{
288		const char *strValue = enumToString(value);
289		if (strValue != nullptr)
	309	const char* strValue = enumToString(value);
	310	if(strValue != nullptr)
290	311	{
291	312	out << "(" << strValue << ")";
292	313	}

296	317
297	318	std::ostream& operator<<(std::ostream& out, const ImpersonationLevels value)
298	319	{
299		const char *strValue = enumToString(value);
300		if (strValue != nullptr)
	320	const char* strValue = enumToString(value);
	321	if(strValue != nullptr)
301	322	{
302	323	out << "(" << strValue << ")";
303	324	}

307	328
308	329	std::ostream& operator<<(std::ostream& out, const CreateDisposition value)
309	330	{
310		const char *strValue = enumToString(value);
311		if (strValue != nullptr)
	331	const char* strValue = enumToString(value);
	332	if(strValue != nullptr)
312	333	{
313	334	out << "(" << strValue << ")";
314	335	}

318	339
319	340	std::ostream& operator<<(std::ostream& out, const CreateActions value)
320	341	{
321		const char *strValue = enumToString(value);
322		if (strValue != nullptr)
	342	const char* strValue = enumToString(value);
	343	if(strValue != nullptr)
323	344	{
324	345	out << "(" << strValue << ")";
325	346	}

329	350
330	351	std::ostream& operator<<(std::ostream& out, const ShareTypes value)
331	352	{
332		const char *strValue = enumToString(value);
333		if (strValue != nullptr)
	353	const char* strValue = enumToString(value);
	354	if(strValue != nullptr)
334	355	{
335	356	out << "(" << strValue << ")";
336	357	}

339	360	}
340	361
341	362	std::ostream& operator<<(std::ostream& out, const NTStatus value)
342		{
343		const char *strValue = enumToString(value);
344		if (strValue != nullptr)
	363	{
	364	const char* strValue = enumToString(value);
	365	if(strValue != nullptr)
345	366	{
346	367	out << "(" << strValue << ")";
347	368	}

353	374	{
354	375	auto int_value = to_integral(value);
355	376
356		if (int_value > 0)
357		{
358		out << "(";
	377	if(int_value > 0)
	378	{
	379	out << "(";
	380	// clang-format off
359	381	print_flag_if_set(out, "READ_DATA_LE", int_value, DesiredAccessFlags::READ_DATA_LE);
360	382	print_flag_if_set(out, "WRITE_DATA_LE", int_value, DesiredAccessFlags::WRITE_DATA_LE);
361	383	print_flag_if_set(out, "APPEND_DATA_LE", int_value, DesiredAccessFlags::APPEND_DATA_LE);

375	397	print_flag_if_set(out, "GENERIC_EXECUTE_LE", int_value, DesiredAccessFlags::GENERIC_EXECUTE_LE);
376	398	print_flag_if_set(out, "GENERIC_WRITE_LE", int_value, DesiredAccessFlags::GENERIC_WRITE_LE);
377	399	print_flag_if_set(out, "GENERIC_READ_LE", int_value, DesiredAccessFlags::GENERIC_READ_LE);
	400	// clang-format on
378	401	out << ")";
379	402	}
380	403	return out;

384	407	{
385	408	auto int_value = to_integral(value);
386	409
387		if (int_value > 0)
388		{
389		out << "(";
	410	if(int_value > 0)
	411	{
	412	out << "(";
	413	// clang-format off
390	414	print_flag_if_set(out, "READONLY", int_value, FileAttributes::READONLY);
391	415	print_flag_if_set(out, "HIDDEN", int_value, FileAttributes::HIDDEN);
392	416	print_flag_if_set(out, "SYSTEM", int_value, FileAttributes::SYSTEM);

400	424	print_flag_if_set(out, "OFFLINE", int_value, FileAttributes::OFFLINE);
401	425	print_flag_if_set(out, "NOT_CONTENT_INDEXED", int_value, FileAttributes::NOT_CONTENT_INDEXED);
402	426	print_flag_if_set(out, "ENCRYPTED", int_value, FileAttributes::ENCRYPTED);
	427	// clang-format on
403	428	out << ")";
404	429	}
405	430

409	434	std::ostream& operator<<(std::ostream& out, const ShareAccessFlags value)
410	435	{
411	436	auto int_value = to_integral(value);
412		if (int_value > 0)
413		{
414		out << "(";
	437	if(int_value > 0)
	438	{
	439	out << "(";
	440	// clang-format off
415	441	print_flag_if_set(out, "SHARE_READ_LE", int_value, ShareAccessFlags::SHARE_READ_LE);
416	442	print_flag_if_set(out, "SHARE_WRITE_LE", int_value, ShareAccessFlags::SHARE_WRITE_LE);
417	443	print_flag_if_set(out, "SHARE_DELETE_LE", int_value, ShareAccessFlags::SHARE_DELETE_LE);
	444	// clang-format on
418	445	out << ")";
419	446	}
420	447

425	452	{
426	453	auto int_value = to_integral(value);
427	454
428		if (int_value > 0)
429		{
430		out << "(";
	455	if(int_value > 0)
	456	{
	457	out << "(";
	458	// clang-format off
431	459	print_flag_if_set(out, "DIRECTORY_FILE_LE", int_value, CreateOptionsFlags::DIRECTORY_FILE_LE);
432	460	print_flag_if_set(out, "WRITE_THROUGH_LE", int_value, CreateOptionsFlags::WRITE_THROUGH_LE);
433	461	print_flag_if_set(out, "SEQUENTIAL_ONLY_LE", int_value, CreateOptionsFlags::SEQUENTIAL_ONLY_LE);

446	474	print_flag_if_set(out, "OPEN_REPARSE_POINT_LE", int_value, CreateOptionsFlags::OPEN_REPARSE_POINT_LE);
447	475	print_flag_if_set(out, "OPEN_NO_RECALL_LE", int_value, CreateOptionsFlags::OPEN_NO_RECALL_LE);
448	476	print_flag_if_set(out, "OPEN_FOR_FREE_SPACE_QUERY_LE", int_value, CreateOptionsFlags::OPEN_FOR_FREE_SPACE_QUERY_LE);
	477	// clang-format on
449	478	out << ")";
450	479	}
451	480

456	485	{
457	486	auto int_value = to_integral(value);
458	487
459		if (int_value > 0)
460		{
461		out << "(";
	488	if(int_value > 0)
	489	{
	490	out << "(";
	491	// clang-format off
462	492	print_flag_if_set(out, "SMB2_WRITEFLAG_WRITE_THROUGH", int_value, WriteFlags::SMB2_WRITEFLAG_WRITE_THROUGH);
463	493	print_flag_if_set(out, "SMB2_WRITEFLAG_WRITE_UNBUFFERED", int_value, WriteFlags::SMB2_WRITEFLAG_WRITE_UNBUFFERED);
	494	// clang-format on
464	495	out << ")";
465	496	}
466	497	return out;

471	502	auto int_value = to_integral(value) & ~to_integral(ShareFlags::NO_CACHING);
472	503
473	504	out << "Caching policy = ";
	505	// clang-format off
474	506	switch(to_integral(value) & to_integral(ShareFlags::NO_CACHING))
475	507	{
476	508	case to_integral(ShareFlags::MANUAL_CACHING): out << "MANUAL_CACHING"; break;

493	525	print_flag_if_set(out, "SMB2_SHAREFLAG_ENABLE_HASH_V2", int_value, ShareFlags::ENABLE_HASH_2);
494	526	print_flag_if_set(out, "SMB2_SHAREFLAG_ENCRYPT_DATA", int_value, ShareFlags::ENABLE_ENCRYPT_DATA);
495	527	}
	528	// clang-format on
496	529
497	530	return out;
498	531	}

502	535	auto int_value = to_integral(value);
503	536
504	537	if(int_value > 0)
505		{
506		out << "(";
	538	{
	539	out << "(";
	540	// clang-format off
507	541	print_flag_if_set(out, "SMB2_SHARE_CAP_DFS", int_value, ShareCapabilities::DFS);
508	542	print_flag_if_set(out, "SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY", int_value, ShareCapabilities::CONTINUOUS_AVAILABILITY);
509	543	print_flag_if_set(out, "SMB2_SHARE_CAP_SCALEOUT", int_value, ShareCapabilities::SCALEOUT);
510	544	print_flag_if_set(out, "SMB2_SHARE_CAP_CLUSTER", int_value, ShareCapabilities::CLUSTER);
511	545	print_flag_if_set(out, "SMB2_SHARE_CAP_ASYMMETRIC", int_value, ShareCapabilities::ASYMMETRIC);
	546	// clang-format on
512	547	out << ")";
513	548	}
514	549

519	554	{
520	555	auto int_value = to_integral(value);
521	556
522		if (int_value > 0)
523		{
524		out << "(";
	557	if(int_value > 0)
	558	{
	559	out << "(";
	560	// clang-format off
525	561	print_flag_if_set(out, "SIGNING_ENABLED", int_value, SecurityModeShort::SIGNING_ENABLED);
526	562	print_flag_if_set(out, "SIGNING_REQUIRED", int_value, SecurityModeShort::SIGNING_REQUIRED);
	563	// clang-format on
527	564	out << ")";
528	565	}
529	566	return out;

536	573	if(int_value > 0)
537	574	{
538	575	out << "(";
	576	// clang-format off
539	577	print_flag_if_set(out, "DFS", int_value, Capabilities::DFS);
540	578	print_flag_if_set(out, "LEASING", int_value, Capabilities::LEASING);
541	579	print_flag_if_set(out, "LARGE_MTU", int_value, Capabilities::LARGE_MTU);

543	581	print_flag_if_set(out, "PERSISTENT_HANDLES",int_value, Capabilities::PERSISTENT_HANDLES);
544	582	print_flag_if_set(out, "DIRECTORY_LEASING", int_value, Capabilities::DIRECTORY_LEASING);
545	583	print_flag_if_set(out, "ENCRYPTION", int_value, Capabilities::ENCRYPTION);
	584	// clang-format on
546	585	out << ")";
547	586	}
548	587

552	591	std::ostream& operator<<(std::ostream& out, const SessionFlags value)
553	592	{
554	593	auto int_value = to_integral(value);
555
	594	// clang-format off
556	595	print_flag_if_set(out, "NONE", int_value, SessionFlags::NONE);
557	596	print_flag_if_set(out, "SMB2_SESSION_FLAG_IS_GUEST", int_value, SessionFlags::IS_GUEST);
558	597	print_flag_if_set(out, "SMB2_SESSION_FLAG_IS_NULL", int_value, SessionFlags::IS_NULL);
559	598	print_flag_if_set(out, "SMB2_SESSION_FLAG_ENCRYPT_DATA",int_value, SessionFlags::IS_ENCRYPT_DATA);
560
	599	// clang-format on
561	600	return out;
562	601	}
563	602

565	604	{
566	605	auto int_value = to_integral(value);
567	606
568		if (int_value > 0)
569		{
570		out << "(";
	607	if(int_value > 0)
	608	{
	609	out << "(";
	610	// clang-format off
571	611	print_flag_if_set(out, "FILE_READ_DATA", int_value, AccessMask::FILE_READ_DATA);
572	612	print_flag_if_set(out, "FILE_WRITE_DATA", int_value, AccessMask::FILE_WRITE_DATA);
573	613	print_flag_if_set(out, "FILE_APPEND_DATA", int_value, AccessMask::FILE_APPEND_DATA);

588	628	print_flag_if_set(out, "GENERIC_EXECUTE", int_value, AccessMask::GENERIC_EXECUTE);
589	629	print_flag_if_set(out, "GENERIC_WRITE", int_value, AccessMask::GENERIC_WRITE);
590	630	print_flag_if_set(out, "GENERIC_READ", int_value, AccessMask::GENERIC_READ);
	631	// clang-format on
591	632	out << ")";
592	633	}
593	634

601	642	if(int_value > 0)
602	643	{
603	644	out << "(";
604		print_flag_if_set(out, "POSTQUERY_ATTRIB", int_value, CloseFlags::POSTQUERY_ATTRIB);
	645	print_flag_if_set(out, "POSTQUERY_ATTRIB", int_value, CloseFlags::POSTQUERY_ATTRIB);
605	646	out << ")";
606	647	}
607	648

612	653	{
613	654	auto int_value = to_integral(value);
614	655
615		if (int_value > 0)
616		{
617		out << "(";
618		print_flag_if_set(out, "SIGNING_ENABLED", int_value, SecurityMode::SIGNING_ENABLED);
619		print_flag_if_set(out, "SIGNING_REQUIRED", int_value, SecurityMode::SIGNING_REQUIRED);
	656	if(int_value > 0)
	657	{
	658	out << "(";
	659	print_flag_if_set(out, "SIGNING_ENABLED", int_value, SecurityMode::SIGNING_ENABLED);
	660	print_flag_if_set(out, "SIGNING_REQUIRED", int_value, SecurityMode::SIGNING_REQUIRED);
620	661	out << ")";
621	662	}
622	663

625	666
626	667	std::ostream& operator<<(std::ostream& out, const FsInfoLevels value)
627	668	{
628		const char *strValue = enumToString(value);
629		if (strValue != nullptr)
	669	const char* strValue = enumToString(value);
	670	if(strValue != nullptr)
630	671	{
631	672	out << "(" << strValue << ")";
632	673	}

636	677
637	678	std::ostream& operator<<(std::ostream& out, const QueryInfoLevels value)
638	679	{
639		const char *strValue = enumToString(value);
640		if (strValue != nullptr)
	680	const char* strValue = enumToString(value);
	681	if(strValue != nullptr)
641	682	{
642	683	out << "(" << strValue << ")";
643	684	}

647	688
648	689	std::ostream& operator<<(std::ostream& out, const CtlCodes value)
649	690	{
650		const char *strValue = enumToString(value);
651		if (strValue != nullptr)
	691	const char* strValue = enumToString(value);
	692	if(strValue != nullptr)
652	693	{
653	694	out << "(" << strValue << ")";
654	695	}

658	699
659	700	std::ostream& operator<<(std::ostream& out, const InfoTypes value)
660	701	{
661		const char *strValue = enumToString(value);
662		if (strValue != nullptr)
	702	const char* strValue = enumToString(value);
	703	if(strValue != nullptr)
663	704	{
664	705	out << "(" << strValue << ")";
665	706	}

669	710
670	711	std::ostream& operator<<(std::ostream& out, const SessionFlagsBinding value)
671	712	{
672		const char *strValue = enumToString(value);
673		if (strValue != nullptr)
	713	const char* strValue = enumToString(value);
	714	if(strValue != nullptr)
674	715	{
675	716	out << "(" << strValue << ")";
676	717	}

681	722	std::ostream& operator<<(std::ostream& out, const Flags value)
682	723	{
683	724	auto int_value = to_integral(value);
684		if (int_value > 0)
	725	if(int_value > 0)
685	726	{
686	727	out << "(";
687	728	print_flag_if_set(out, "SERVER_TO_REDIR", int_value, Flags::SERVER_TO_REDIR);

700	741	{
701	742	switch(infoType)
702	743	{
703		case InfoTypes::FILE:
704		print_enum(out, "InfoLevel", static_cast<QueryInfoLevels>(infoClass));
705		break;
706		case InfoTypes::FILESYSTEM:
707		print_enum(out, "InfoLevel", static_cast<FsInfoLevels>(infoClass));
708		break;
709		default:
710		//we dont handle other classes
711		;
	744	case InfoTypes::FILE:
	745	print_enum(out, "InfoLevel", static_cast<QueryInfoLevels>(infoClass));
	746	break;
	747	case InfoTypes::FILESYSTEM:
	748	print_enum(out, "InfoLevel", static_cast<FsInfoLevels>(infoClass));
	749	break;
	750	default:
	751	//we dont handle other classes
	752	;
712	753	}
713	754	return out;
714	755	}

-6

src/protocols/cifs2/cifs2_utils.h less more

0	0	//------------------------------------------------------------------------------
1		// Author: Artsem Iliasau
	1	// Author: Artsem Iliasau
2	2	// Description: Helpers for parsing CIFSv2 structures.
3	3	// Copyright (c) 2015 EPAM Systems
4	4	//------------------------------------------------------------------------------

34	34	{
35	35	namespace CIFSv2
36	36	{
37
38	37	namespace SMBv2 = NST::API::SMBv2;
39	38
40	39	/*! Convert enum type to underlying integer type
41	40	* \param e - instance of enumeration to be converted
42	41	* \return integer representation of enumeration
43	42	*/
44		template<typename E>
	43	template <typename E>
45	44	inline constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type
46	45	{
47	46	return static_cast<typename std::underlying_type<E>::type>(e);

70	69	std::ostream& operator<<(std::ostream& out, const SMBv2::NTStatus value);
71	70	std::ostream& operator<<(std::ostream& out, const SMBv2::AccessMask value);
72	71	std::ostream& operator<<(std::ostream& out, const SMBv2::CloseFlags value);
73		std::ostream& operator<<(std::ostream& out, const SMBv2::SecurityMode value);
	72	std::ostream& operator<<(std::ostream& out, const SMBv2::SecurityMode value);
74	73	std::ostream& operator<<(std::ostream& out, Flags value);
75	74
76	75	template <typename T>

83	82	print_hex(out, int_value);
84	83	out << " " << (T)int_value;
85	84	return out;
86		}
	85	}
87	86
88	87	std::ostream& print_info_levels(std::ostream& os, const NST::API::SMBv2::InfoTypes infoType, const uint8_t infoClass);
89	88

91	90	} // namespace protocols
92	91	} // namespace NST
93	92	//------------------------------------------------------------------------------
94		#endif//CIFS2_UTILS_H
	93	#endif // CIFS2_UTILS_H
95	94	//------------------------------------------------------------------------------

+23

-21

src/protocols/ethernet/ethernet_header.h less more

23	23	//------------------------------------------------------------------------------
24	24	#include <cstdint>
25	25
26		#include <arpa/inet.h> // for ntohs()
	26	#include <arpa/inet.h> // for ntohs()
27	27	//------------------------------------------------------------------------------
28	28	namespace NST
29	29	{

31	31	{
32	32	namespace ethernet
33	33	{
34
35	34	// Ethernet II (aka DIX v2.0 Ethernet)
36	35	struct ethernet_header
37	36	{
38		enum { ADDR_LEN = 6 };
	37	enum
	38	{
	39	ADDR_LEN = 6
	40	};
39	41
40	42	enum EtherType
41	43	{
42		PUP = 0x0200, // Xerox PUP
43		SPRITE = 0x0500, // Sprite
44		IP = 0x0800, // IP
45		ARP = 0x0806, // Address resolution
46		REVARP = 0x8035, // Reverse ARP
47		AT = 0x809B, // AppleTalk protocol
48		AARP = 0x80F3, // AppleTalk ARP
49		VLAN = 0x8100, // IEEE 802.1Q VLAN tagging
50		IPX = 0x8137, // IPX
51		IPV6 = 0x86dd, // IP protocol version 6
52		LOOPBACK= 0x9000 // used to test interfaces
	44	PUP = 0x0200, // Xerox PUP
	45	SPRITE = 0x0500, // Sprite
	46	IP = 0x0800, // IP
	47	ARP = 0x0806, // Address resolution
	48	REVARP = 0x8035, // Reverse ARP
	49	AT = 0x809B, // AppleTalk protocol
	50	AARP = 0x80F3, // AppleTalk ARP
	51	VLAN = 0x8100, // IEEE 802.1Q VLAN tagging
	52	IPX = 0x8137, // IPX
	53	IPV6 = 0x86dd, // IP protocol version 6
	54	LOOPBACK = 0x9000 // used to test interfaces
53	55	};
54	56
55		uint8_t eth_dhost[ADDR_LEN]; // destination host address
56		uint8_t eth_shost[ADDR_LEN]; // source host address
57		uint16_t eth_type; // protocol (EtherType values)
	57	uint8_t eth_dhost[ADDR_LEN]; // destination host address
	58	uint8_t eth_shost[ADDR_LEN]; // source host address
	59	uint16_t eth_type; // protocol (EtherType values)
58	60	} __attribute__((packed));
59	61
60	62	struct EthernetHeader : private ethernet_header
61	63	{
62		inline const uint8_t* dst() const { return eth_dhost; }
63		inline const uint8_t* src() const { return eth_shost; }
	64	inline const uint8_t* dst() const { return eth_dhost; }
	65	inline const uint8_t* src() const { return eth_shost; }
64	66	inline uint16_t type() const { return ntohs(eth_type); }
65		} __attribute__ ((__packed__));
	67	} __attribute__((__packed__));
66	68
67	69	} // namespace ethernet
68	70	} // namespace protocols
69	71	} // namespace NST
70	72	//------------------------------------------------------------------------------
71		#endif//ETHERNET_HEADER_H
	73	#endif // ETHERNET_HEADER_H
72	74	//------------------------------------------------------------------------------

+31

-32

src/protocols/ip/ip_header.h less more

30	30	{
31	31	namespace ip
32	32	{
33
34		enum NextProtocol // ID of next protocol header
	33	enum NextProtocol // ID of next protocol header
35	34	{
36		IP = 0, // Dummy protocol for TCP
37		HOPOPTS = 0, // IPv6 Hop-by-Hop options
38		ICMP = 1, // Internet Control Message Protocol
39		IGMP = 2, // Internet Group Management Protocol
40		IPIP = 4, // IPIP tunnels (older KA9Q tunnels use 94)
41		TCP = 6, // Transmission Control Protocol
42		EGP = 8, // Exterior Gateway Protocol
43		PUP = 12, // PUP protocol
44		UDP = 17, // User Datagram Protocol
45		IDP = 22, // XNS IDP protocol
46		TP = 29, // SO Transport Protocol Class 4
47		DCCP = 33, // Datagram Congestion Control Protocol
48		IPV6 = 41, // IPv6 header
49		ROUTING = 43, // IPv6 routing header
50		FRAGMENT= 44, // IPv6 fragmentation header
51		RSVP = 46, // Reservation Protocol
52		GRE = 47, // General Routing Encapsulation
53		ESP = 50, // encapsulating security payload
54		AH = 51, // authentication header
55		ICMPV6 = 58, // ICMPv6
56		NONE = 59, // IPv6 no next header
57		DSTOPTS = 60, // IPv6 destination options
58		MTP = 92, // Multicast Transport Protocol
59		ENCAP = 98, // Encapsulation Header
60		PIM = 103, // Protocol Independent Multicast
61		COMP = 108, // Compression Header Protocol
62		SCTP = 132, // Stream Control Transmission Protocol
63		UDPLITE = 136, // UDP-Lite protocol
64		RAW = 255 // Raw IP packets
	35	IP = 0, // Dummy protocol for TCP
	36	HOPOPTS = 0, // IPv6 Hop-by-Hop options
	37	ICMP = 1, // Internet Control Message Protocol
	38	IGMP = 2, // Internet Group Management Protocol
	39	IPIP = 4, // IPIP tunnels (older KA9Q tunnels use 94)
	40	TCP = 6, // Transmission Control Protocol
	41	EGP = 8, // Exterior Gateway Protocol
	42	PUP = 12, // PUP protocol
	43	UDP = 17, // User Datagram Protocol
	44	IDP = 22, // XNS IDP protocol
	45	TP = 29, // SO Transport Protocol Class 4
	46	DCCP = 33, // Datagram Congestion Control Protocol
	47	IPV6 = 41, // IPv6 header
	48	ROUTING = 43, // IPv6 routing header
	49	FRAGMENT = 44, // IPv6 fragmentation header
	50	RSVP = 46, // Reservation Protocol
	51	GRE = 47, // General Routing Encapsulation
	52	ESP = 50, // encapsulating security payload
	53	AH = 51, // authentication header
	54	ICMPV6 = 58, // ICMPv6
	55	NONE = 59, // IPv6 no next header
	56	DSTOPTS = 60, // IPv6 destination options
	57	MTP = 92, // Multicast Transport Protocol
	58	ENCAP = 98, // Encapsulation Header
	59	PIM = 103, // Protocol Independent Multicast
	60	COMP = 108, // Compression Header Protocol
	61	SCTP = 132, // Stream Control Transmission Protocol
	62	UDPLITE = 136, // UDP-Lite protocol
	63	RAW = 255 // Raw IP packets
65	64	};
66	65
67	66	} // namespace ip
68	67	} // namespace protocols
69	68	} // namespace NST
70	69	//------------------------------------------------------------------------------
71		#endif//IP_HEADER_H
	70	#endif // IP_HEADER_H
72	71	//------------------------------------------------------------------------------

+15

-14

src/protocols/ip/ipv4_header.h less more

32	32	{
33	33	namespace ip
34	34	{
35
36	35	// Internet Protocol, version 4
37	36	struct ipv4_header
38	37	{

52	51	OFFMASK = 0x1fff // mask for fragmenting bits
53	52	};
54	53
55		uint8_t ipv4_vhl; // header length and version
56		uint8_t ipv4_tos; // type of service
57		uint16_t ipv4_len; // total length
58		uint16_t ipv4_id; // identification
59		uint16_t ipv4_fragmentation;// fragmentation
60		uint8_t ipv4_ttl; // time to live
61		uint8_t ipv4_protocol; // protocol
62		uint16_t ipv4_checksum; // checksum
63		in_addr_t ipv4_src; // source address
64		in_addr_t ipv4_dst; // destination address
65		} __attribute__ ((__packed__));
	54	uint8_t ipv4_vhl; // header length and version
	55	uint8_t ipv4_tos; // type of service
	56	uint16_t ipv4_len; // total length
	57	uint16_t ipv4_id; // identification
	58	uint16_t ipv4_fragmentation; // fragmentation
	59	uint8_t ipv4_ttl; // time to live
	60	uint8_t ipv4_protocol; // protocol
	61	uint16_t ipv4_checksum; // checksum
	62	in_addr_t ipv4_src; // source address
	63	in_addr_t ipv4_dst; // destination address
	64	} __attribute__((__packed__));
66	65
67	66	struct IPv4Header : private ipv4_header
68	67	{
	68	// clang-format off
69	69	inline uint8_t version() const { return ipv4_vhl >> 4; }
70	70	inline uint8_t ihl() const { return (ipv4_vhl & 0x0f) << 2 /* 4 /; } // return number of bytes
71	71	inline uint16_t length() const { return ntohs(ipv4_len); }

80	80	{
81	81	return ipv4_fragmentation & htons(OFFMASK) /offset() != 0/;
82	82	}
83		} __attribute__ ((__packed__));
	83	// clang-format on
	84	} __attribute__((__packed__));
84	85
85	86	} // namespace ip
86	87	} // namespace protocols
87	88	} // namespace NST
88	89	//------------------------------------------------------------------------------
89		#endif//IPV4_HEADER_H
	90	#endif // IPV4_HEADER_H
90	91	//------------------------------------------------------------------------------

+39

-37

src/protocols/ip/ipv6_header.h less more

32	32	{
33	33	namespace ip
34	34	{
35
36	35	typedef uint8_t in6_addr_t[16];
37	36
38	37	static_assert(sizeof(in6_addr) == sizeof(in6_addr_t), "sizeof in6_addr should be 16 bytes");

40	39	// Internet Protocol, version 6
41	40	struct ipv6_header
42	41	{
43		uint32_t ipv6_vtcflow; // version(4), traffic class(8), flow label(20)
44		uint16_t ipv6_plen; // size of payload, including any extension header
45		uint8_t ipv6_nexthdr; // next header type
46		uint8_t ipv6_hlimit; // hop limit
47		in6_addr_t ipv6_src; // source address
48		in6_addr_t ipv6_dst; // destination address
49		} __attribute__ ((__packed__));
	42	uint32_t ipv6_vtcflow; // version(4), traffic class(8), flow label(20)
	43	uint16_t ipv6_plen; // size of payload, including any extension header
	44	uint8_t ipv6_nexthdr; // next header type
	45	uint8_t ipv6_hlimit; // hop limit
	46	in6_addr_t ipv6_src; // source address
	47	in6_addr_t ipv6_dst; // destination address
	48	} __attribute__((__packed__));
50	49
51	50	// Hop-by-Hop options header
52		struct ipv6_hbh {
53		uint8_t hbh_nexthdr; // next header type
54		uint8_t hbh_len; // length in units of 8 octets
	51	struct ipv6_hbh
	52	{
	53	uint8_t hbh_nexthdr; // next header type
	54	uint8_t hbh_len; // length in units of 8 octets
55	55	// addition data
56		} __attribute__ ((__packed__));
	56	} __attribute__((__packed__));
57	57
58	58	// Destination options header
59		struct ipv6_dest {
60		uint8_t dest_nexthdr; // next header type
61		uint8_t dest_len; // length in units of 8 octets
	59	struct ipv6_dest
	60	{
	61	uint8_t dest_nexthdr; // next header type
	62	uint8_t dest_len; // length in units of 8 octets
62	63	// addition data
63		} __attribute__ ((__packed__));
	64	} __attribute__((__packed__));
64	65
65	66	// Routing header
66		struct ipv6_route {
67		uint8_t route_nexthdr; // next header
68		uint8_t route_len; // length in units of 8 octets
69		uint8_t route_type; // routing type
70		uint8_t route_segleft; // segments left
	67	struct ipv6_route
	68	{
	69	uint8_t route_nexthdr; // next header
	70	uint8_t route_len; // length in units of 8 octets
	71	uint8_t route_type; // routing type
	72	uint8_t route_segleft; // segments left
71	73	// routing type specific data
72		} __attribute__ ((__packed__));
	74	} __attribute__((__packed__));
73	75
74	76	// Fragment header
75		struct ipv6_frag {
76
	77	struct ipv6_frag
	78	{
77	79	enum Fragmentation : uint16_t
78	80	{
79		MORE = 0x0001, // more-fragments flag
80		RESERVED= 0x0006, // mask out reserved bits
81		OFFSET = 0xfff8 // mask out offset from frag_offlg
	81	MORE = 0x0001, // more-fragments flag
	82	RESERVED = 0x0006, // mask out reserved bits
	83	OFFSET = 0xfff8 // mask out offset from frag_offlg
82	84	};
83	85
84	86	uint8_t frag_nexthdr; // next header
85	87	uint8_t frag_reserved; // reserved field
86	88	uint16_t frag_offlg; // offset, reserved, and flag
87	89	uint32_t frag_ident; // identification
88		} __attribute__ ((__packed__));
	90	} __attribute__((__packed__));
89	91
90	92	struct IPv6Header : private ipv6_header
91	93	{
92		inline uint8_t version() const { return ntohl(ipv6_vtcflow) >> 28; }
93		inline uint8_t tclass() const { return (ntohl(ipv6_vtcflow) >> 20) & 0xFF;}
94		inline uint32_t flowid() const { return ntohl(ipv6_vtcflow) & 0xFFFFF;}
95		inline uint16_t payload_len() const { return ntohs(ipv6_plen); }
96		inline uint8_t nexthdr() const { return ipv6_nexthdr; }
97		inline const in6_addr_t& src() const { return ipv6_src; }
98		inline const in6_addr_t& dst() const { return ipv6_dst; }
99		} __attribute__ ((__packed__));
	94	uint8_t version() const { return ntohl(ipv6_vtcflow) >> 28; }
	95	uint8_t tclass() const { return (ntohl(ipv6_vtcflow) >> 20) & 0xFF; }
	96	uint32_t flowid() const { return ntohl(ipv6_vtcflow) & 0xFFFFF; }
	97	uint16_t payload_len() const { return ntohs(ipv6_plen); }
	98	uint8_t nexthdr() const { return ipv6_nexthdr; }
	99	const in6_addr_t& src() const { return ipv6_src; }
	100	const in6_addr_t& dst() const { return ipv6_dst; }
	101	} __attribute__((__packed__));
100	102
101	103	} // namespace ip
102	104	} // namespace protocols
103	105	} // namespace NST
104	106	//------------------------------------------------------------------------------
105		#endif//IPV6_HEADER_H
	107	#endif // IPV6_HEADER_H
106	108	//------------------------------------------------------------------------------

-9

src/protocols/netbios/netbios.h less more

21	21	#ifndef NETBIOS_HEADER_H
22	22	#define NETBIOS_HEADER_H
23	23	//------------------------------------------------------------------------------
24		#include <stdlib.h>
25	24	#include <cstdint>
	25	#include <cstdlib>
26	26	//------------------------------------------------------------------------------
27	27	namespace NST
28	28	{

30	30	{
31	31	namespace NetBIOS
32	32	{
33
34	33	/*! \class NetBIOS message header in SMB-direct case
35	34	*/
36	35	struct RawMessageHeader
37	36	{
38		uint8_t _start;//!< In SMB direct always 0x00
39		uint8_t _;
40		uint16_t length;//!< Packet length
41		} __attribute__ ((__packed__));
	37	uint8_t _start; //!< In SMB direct always 0x00
	38	uint8_t _;
	39	uint16_t length; //!< Packet length
	40	} __attribute__((__packed__));
42	41
43	42	/*! \class NetBIOS message header wrapper
44	43	*/

54	53	*/
55	54	inline const struct MessageHeader* get_header(const uint8_t* data)
56	55	{
57		const MessageHeader* header (reinterpret_cast<const MessageHeader*>(data));
58		if (header->start() == 0x00)
	56	const MessageHeader* header(reinterpret_cast<const MessageHeader*>(data));
	57	if(header->start() == 0x00)
59	58	{
60	59	return header;
61	60	}

66	65	} // namespace protocols
67	66	} // namespace NST
68	67	//------------------------------------------------------------------------------
69		#endif//NETBIOS_HEADER_H
	68	#endif // NETBIOS_HEADER_H
70	69	//------------------------------------------------------------------------------

+35

-34

src/protocols/nfs/nfs_procedure.h less more

25	25
26	26	#include "api/rpc_types.h"
27	27	#include "protocols/nfs3/nfs3_utils.h"
	28	#include "protocols/nfs4/nfs41_utils.h"
28	29	#include "protocols/nfs4/nfs4_utils.h"
29		#include "protocols/nfs4/nfs41_utils.h"
30	30	#include "utils/sessions.h"
31	31	//------------------------------------------------------------------------------
32	32	namespace NST
33	33	{
34	34	namespace protocols
35	35	{
36
37	36	using NFS3::proc_t_of;
38	37	using NFS4::proc_t_of;
39	38	using NFS41::proc_t_of;
40	39
41		template
42		<
	40	template <
43	41	typename ArgType, // structure of RPC procedure parameters
44	42	typename ResType // structure of RPC procedure results
45		>
46		class NFSProcedure: public NST::API::RPCProcedure
	43	>
	44	class NFSProcedure : public NST::API::RPCProcedure
47	45	{
48	46	public:
49	47	inline NFSProcedure(xdr::XDRDecoder& c, xdr::XDRDecoder& r, const Session* s)
50		: parg{&arg} // set pointer to argument
51		, pres{&res} // set pointer to result
	48	: parg{&arg} // set pointer to argument
	49	, pres{&res} // set pointer to result
52	50	{
53		memset(&call, 0,sizeof(call ));
54		memset(&reply,0,sizeof(reply));
55		memset(&arg, 0,sizeof(arg ));
56		memset(&res, 0,sizeof(res ));
	51	memset(&call, 0, sizeof(call));
	52	memset(&reply, 0, sizeof(reply));
	53	memset(&arg, 0, sizeof(arg));
	54	memset(&res, 0, sizeof(res));
57	55
58	56	// fill call
59	57	if(!xdr_callmsg(c.xdr(), &call))

63	61	}
64	62
65	63	// fill call arguments
66		if(!proc_t_of(arg)(c.xdr(),&arg))
	64	if(!proc_t_of(arg)(c.xdr(), &arg))
67	65	{
68		xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg );
69		xdr_free((xdrproc_t)xdr_callmsg, (char*)&call);
	66	xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg);
	67	xdr_free((xdrproc_t)xdr_callmsg, (char*)&call);
70	68	throw xdr::XDRDecoderError{"XDRDecoder: cann't read call arguments"};
71	69	}
72	70
73	71	reply.ru.RM_rmb.ru.RP_ar.ru.AR_results.proc = &return_true;
74	72
75	73	// fill reply
76		if(!xdr_replymsg (r.xdr(), &reply))
	74	if(!xdr_replymsg(r.xdr(), &reply))
77	75	{
78		xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply);
79		xdr_free((xdrproc_t)proc_t_of(arg),(char*)&arg );
80		xdr_free((xdrproc_t)xdr_callmsg, (char*)&call );
	76	xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply);
	77	xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg);
	78	xdr_free((xdrproc_t)xdr_callmsg, (char*)&call);
81	79	throw xdr::XDRDecoderError{"XDRDecoder: cann't read reply data"};
82	80	}
83
	81
84	82	if(reply.ru.RM_rmb.rp_stat == reply_stat::MSG_ACCEPTED &&
85	83	reply.ru.RM_rmb.ru.RP_ar.ar_stat == accept_stat::SUCCESS)
86	84	{
87	85	// fill reply results
88		if(!proc_t_of(res)(r.xdr(),&res))
	86	if(!proc_t_of(res)(r.xdr(), &res))
89	87	{
90		xdr_free((xdrproc_t)proc_t_of(res), (char*)&res );
91		xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply);
92		xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg );
93		xdr_free((xdrproc_t)xdr_callmsg, (char*)&call );
	88	xdr_free((xdrproc_t)proc_t_of(res), (char*)&res);
	89	xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply);
	90	xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg);
	91	xdr_free((xdrproc_t)xdr_callmsg, (char*)&call);
94	92	throw xdr::XDRDecoderError{"XDRDecoder: cann't read reply results"};
95	93	}
96	94	}

107	105
108	106	inline ~NFSProcedure()
109	107	{
110		if(pres) xdr_free((xdrproc_t)proc_t_of(res), (char*)&res );
111		xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply);
112		xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg );
113		xdr_free((xdrproc_t)xdr_callmsg, (char*)&call );
	108	if(pres) xdr_free((xdrproc_t)proc_t_of(res), (char*)&res);
	109	xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply);
	110	xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg);
	111	xdr_free((xdrproc_t)xdr_callmsg, (char*)&call);
114	112	}
115	113
116	114	// pointers to procedure specific argument and result

119	117
120	118	private:
121	119	inline static bool_t return_true(XDR, void, ...) { return 1; }
122		inline static bool_t return_true(XDR*, ...) { return 1; }
	120	inline static bool_t return_true(XDR*, ...) { return 1; }
	121	ArgType arg;
	122	ResType res;
	123	};
123	124
124		ArgType arg;
125		ResType res;
126		};
	125	// clang-format off
127	126
128	127	namespace NFS3
129	128	{

166	165	using NFSPROC41RPCGEN_COMPOUND = NFSProcedure <NFS41::COMPOUND4args, NFS41::COMPOUND4res>;
167	166	}
168	167
	168	// clang-format on
	169
169	170	} // namespace protocols
170	171	} // namespace NST
171	172	//------------------------------------------------------------------------------
172		#endif//NFS_PROCEDURE_H
	173	#endif // NFS_PROCEDURE_H
173	174	//------------------------------------------------------------------------------

+12

-13

src/protocols/nfs/nfs_utils.cpp less more

20	20	//------------------------------------------------------------------------------
21	21	#include <iomanip>
22	22
	23	#include "api/plugin_api.h" // for NST_PUBLIC
23	24	#include "protocols/nfs/nfs_utils.h"
24	25	//------------------------------------------------------------------------------
25	26	namespace NST

28	29	{
29	30	namespace NFS
30	31	{
31
32	32	void print_hex64(std::ostream& out, uint64_t val)
33	33
34	34	{

51	51	void print_hex8(std::ostream& out, uint8_t val)
52	52	{
53	53	out << "0x" << std::setfill('0') << std::setw(2) << std::hex
54		<< static_cast<u_int16_t>(val) // prevent implicit cast to char
	54	<< static_cast<u_int16_t>(val) // prevent implicit cast to char
55	55	<< std::dec << std::setfill(' ');
56	56	}
57	57
58
59	58	void print_hex(std::ostream& out, const uint32_t* const val, const uint32_t len)
60	59	{
61		if (len)
	60	if(len)
62	61	{
63	62	out << std::hex << std::setfill('0') << "0x";
64		for (uint32_t i {0}; i < len; i++)
	63	for(uint32_t i{0}; i < len; i++)
65	64	{
66	65	out << std::setw(2) << val[i];
67	66	}

75	74
76	75	void print_hex(std::ostream& out, const char* const val, const uint32_t len)
77	76	{
78		if (len)
	77	if(len)
79	78	{
80	79	out << std::hex << std::setfill('0') << "0x";
81		for (uint32_t i {0}; i < len; i++)
	80	for(uint32_t i{0}; i < len; i++)
82	81	{
83	82	out << std::setw(2)
84	83	<< ((static_cast<int32_t>(val[i])) & 0xFF);

91	90	}
92	91	}
93	92
94		void print_nfs_fh(std::ostream& out, const char* const val, const uint32_t len)
	93	extern "C" NST_PUBLIC void print_nfs_fh(std::ostream& out, const char* const val, const uint32_t len)
95	94	{
96		if (len)
	95	if(len)
97	96	{
98	97	out << std::hex << std::setfill('0');
99		if (len <= 8 \|\| out_all())
	98	if(len <= 8 \|\| out_all())
100	99	{
101		for (uint32_t i {0}; i < len; i++)
	100	for(uint32_t i{0}; i < len; i++)
102	101	{
103	102	out << std::setw(2)
104	103	<< ((static_cast<int32_t>(val[i])) & 0xFF);

106	105	}
107	106	else // truncate binary data to: 00112233...CCDDEEFF
108	107	{
109		for (uint32_t i {0}; i < 4; i++)
	108	for(uint32_t i{0}; i < 4; i++)
110	109	{
111	110	out << std::setw(2)
112	111	<< ((static_cast<int32_t>(val[i])) & 0xFF);
113	112	}
114	113	out << "...";
115		for (uint32_t i {len - 4}; i < len; i++)
	114	for(uint32_t i{len - 4}; i < len; i++)
116	115	{
117	116	out << std::setw(2)
118	117	<< ((static_cast<int32_t>(val[i])) & 0xFF);

+16

-25

src/protocols/nfs/nfs_utils.h less more

21	21	#ifndef NFS_UTILS_H
22	22	#define NFS_UTILS_H
23	23	//------------------------------------------------------------------------------
	24	#include <cstring>
	25	#include <iomanip>
24	26	#include <ostream>
25		#include <iomanip>
26		#include <cstring>
27	27
28	28	#include "utils/out.h"
29	29	//------------------------------------------------------------------------------
30		#define NST_PUBLIC __attribute__ ((visibility("default")))
31	30	//------------------------------------------------------------------------------
32	31	namespace NST
33	32	{

35	34	{
36	35	namespace NFS
37	36	{
38
39	37	inline bool out_all()
40	38	{
41	39	using Out = NST::utils::Out;

43	41	return Out::Global::get_level() == Out::Level::All;
44	42	}
45	43
46		namespace
	44	namespace
47	45	{
48	46	template <typename T>
49	47	struct Helper
50		{
	48	{
51	49	static void print_hex(std::ostream& out, T val)
52	50	{
53		out << "0x" << std::setfill('0') << std::setw(sizeof(T)/4) << std::hex << val
	51	out << "0x" << std::setfill('0') << std::setw(sizeof(T) / 4) << std::hex << val
54	52	<< std::dec << std::setfill(' ');
55	53	}
56	54	};
57	55	template <>
58	56	struct Helper<uint8_t>
59		{
	57	{
60	58	static void print_hex(std::ostream& out, char val)
61	59	{
62		out << "0x" << std::setfill('0') << std::setw(4) << std::hex <<
63		static_cast<uint16_t>(val) << std::dec << std::setfill(' ');
	60	out << "0x" << std::setfill('0') << std::setw(4) << std::hex << static_cast<uint16_t>(val) << std::dec << std::setfill(' ');
64	61	}
65	62	};
66	63	}

69	66	void print_hex(std::ostream& out, T val)
70	67	{
71	68	Helper<T>::print_hex(out, val);
72		}
	69	}
73	70
74	71	void print_hex64(std::ostream& out, uint64_t val);
75	72

77	74
78	75	void print_hex16(std::ostream& out, uint16_t val);
79	76
80		void print_hex8(std::ostream& out, uint8_t val);
	77	void print_hex8(std::ostream& out, uint8_t val);
81	78
82		void print_hex(std::ostream& out,
83		const uint32_t* const val,
84		const uint32_t len);
	79	void print_hex(std::ostream& out,
	80	const uint32_t* const val,
	81	const uint32_t len);
85	82
86		void print_hex(std::ostream& out,
87		const char* const val,
88		const uint32_t len);
89
90		extern "C"
91		NST_PUBLIC
92		void print_nfs_fh(std::ostream& out,
93		const char* const val,
94		const uint32_t len);
	83	void print_hex(std::ostream& out,
	84	const char* const val,
	85	const uint32_t len);
95	86
96	87	} // namespace NFS
97	88	} // namespace protocols
98	89	} // namespace NST
99	90	//------------------------------------------------------------------------------
100		#endif//NFS_UTILS_H
	91	#endif // NFS_UTILS_H
101	92	//------------------------------------------------------------------------------

+142

-105

src/protocols/nfs3/nfs3_utils.cpp less more

18	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
19	19	*/
20	20	//------------------------------------------------------------------------------
	21	#include "protocols/nfs3/nfs3_utils.h"
	22	#include "api/plugin_api.h" // for NST_PUBLIC
21	23	#include "protocols/nfs/nfs_utils.h"
22		#include "protocols/nfs3/nfs3_utils.h"
23	24	//------------------------------------------------------------------------------
24	25	using namespace NST::API::NFS3;
25	26	using namespace NST::protocols::NFS;

31	32	{
32	33	namespace NFS3
33	34	{
34
35		const char* print_nfs3_procedures(const ProcEnumNFS3::NFSProcedure proc)
36		{
	35	extern "C" NST_PUBLIC const char* print_nfs3_procedures(const ProcEnumNFS3::NFSProcedure proc)
	36	{
	37	// clang-format off
37	38	static const char* const NFS3ProcedureTitles[ProcEnumNFS3::count] =
38	39	{
39	40	"NULL", "GETATTR", "SETATTR", "LOOKUP",

43	44	"READDIR", "READDIRPLUS", "FSSTAT", "FSINFO",
44	45	"PATHCONF", "COMMIT"
45	46	};
	47	// clang-format on
46	48
47	49	return NFS3ProcedureTitles[proc];
48	50	}

60	62	S_IXGRP = 0x00008, // Search in directory
61	63	S_IROTH = 0x00004,
62	64	S_IWOTH = 0x00002,
63		S_IXOTH = 0x00001 // Search in directory
	65	S_IXOTH = 0x00001 // Search in directory
64	66	};
65	67
66	68	void print_mode3(std::ostream& out, const uint32 val)
67	69	{
68		if (val & S_ISUID) out << "USER_ID_EXEC ";
69		if (val & S_ISGID) out << "GROUP_ID_EXEC ";
70		if (val & S_ISVTX) out << "SAVE_SWAPPED_TEXT ";
71		if (val & S_IRUSR) out << "OWNER_READ ";
72		if (val & S_IWUSR) out << "OWNER_WRITE ";
73		if (val & S_IXUSR) out << "OWNER_EXEC ";
74		if (val & S_IRGRP) out << "GROUP_READ ";
75		if (val & S_IWGRP) out << "GROUP_WRITE ";
76		if (val & S_IXGRP) out << "GROUP_EXEC ";
77		if (val & S_IROTH) out << "OTHER_READ ";
78		if (val & S_IWOTH) out << "OTHER_WRITE ";
79		if (val & S_IXOTH) out << "OTHER_EXEC";
	70	if(val & S_ISUID) out << "USER_ID_EXEC ";
	71	if(val & S_ISGID) out << "GROUP_ID_EXEC ";
	72	if(val & S_ISVTX) out << "SAVE_SWAPPED_TEXT ";
	73	if(val & S_IRUSR) out << "OWNER_READ ";
	74	if(val & S_IWUSR) out << "OWNER_WRITE ";
	75	if(val & S_IXUSR) out << "OWNER_EXEC ";
	76	if(val & S_IRGRP) out << "GROUP_READ ";
	77	if(val & S_IWGRP) out << "GROUP_WRITE ";
	78	if(val & S_IXGRP) out << "GROUP_EXEC ";
	79	if(val & S_IROTH) out << "OTHER_READ ";
	80	if(val & S_IWOTH) out << "OTHER_WRITE ";
	81	if(val & S_IXOTH) out << "OTHER_EXEC";
80	82	}
81	83
82	84	void print_access3(std::ostream& out, const uint32 val)
83	85	{
84		if (val & ACCESS3_READ) out << "READ ";
85		if (val & ACCESS3_LOOKUP) out << "LOOKUP ";
86		if (val & ACCESS3_MODIFY) out << "MODIFY ";
87		if (val & ACCESS3_EXTEND) out << "EXTEND ";
88		if (val & ACCESS3_DELETE) out << "DELETE ";
89		if (val & ACCESS3_EXECUTE) out << "EXECUTE ";
	86	if(val & ACCESS3_READ) out << "READ ";
	87	if(val & ACCESS3_LOOKUP) out << "LOOKUP ";
	88	if(val & ACCESS3_MODIFY) out << "MODIFY ";
	89	if(val & ACCESS3_EXTEND) out << "EXTEND ";
	90	if(val & ACCESS3_DELETE) out << "DELETE ";
	91	if(val & ACCESS3_EXECUTE) out << "EXECUTE ";
90	92	}
91	93
92	94	std::ostream& operator<<(std::ostream& out, const nfsstat3& obj)

159	161	{
160	162	switch(obj)
161	163	{
162		case ftype3::NF3REG: return out << "REG";
163		case ftype3::NF3DIR: return out << "DIR";
164		case ftype3::NF3BLK: return out << "BLK";
165		case ftype3::NF3CHR: return out << "CHR";
166		case ftype3::NF3LNK: return out << "LNK";
167		case ftype3::NF3SOCK: return out << "SOCK";
168		case ftype3::NF3FIFO: return out << "FIFO";
	164	case ftype3::NF3REG:
	165	return out << "REG";
	166	case ftype3::NF3DIR:
	167	return out << "DIR";
	168	case ftype3::NF3BLK:
	169	return out << "BLK";
	170	case ftype3::NF3CHR:
	171	return out << "CHR";
	172	case ftype3::NF3LNK:
	173	return out << "LNK";
	174	case ftype3::NF3SOCK:
	175	return out << "SOCK";
	176	case ftype3::NF3FIFO:
	177	return out << "FIFO";
169	178	}
170	179	return out;
171	180	}

178	187
179	188	std::ostream& operator<<(std::ostream& out, const nfs_fh3& obj)
180	189	{
181		NFS::print_nfs_fh(out, obj.data.data_val, obj.data.data_len);
	190	print_nfs_fh(out, obj.data.data_val, obj.data.data_len);
182	191	return out;
183	192	}
184	193
185	194	std::ostream& operator<<(std::ostream& out, const nfstime3& obj)
186	195	{
187		return out << "seconds: " << obj.seconds
	196	return out << "seconds: " << obj.seconds
188	197	<< " nseconds: " << obj.nseconds << ' ';
189	198	}
190	199

193	202	out << " type: " << obj.type
194	203	<< " mode: ";
195	204
196		print_mode3(out,obj.mode);
197
198		out << " nlink: " << obj.nlink
199		<< " uid: " << obj.uid
200		<< " gid: " << obj.gid
201		<< " size: " << obj.size
202		<< " used: " << obj.used
203		<< " rdev: " << obj.rdev
204		<< " fsid: " << obj.fsid
	205	print_mode3(out, obj.mode);
	206
	207	out << " nlink: " << obj.nlink
	208	<< " uid: " << obj.uid
	209	<< " gid: " << obj.gid
	210	<< " size: " << obj.size
	211	<< " used: " << obj.used
	212	<< " rdev: " << obj.rdev
	213	<< " fsid: " << obj.fsid
205	214	<< " fileid: " << obj.fileid
206		<< " atime: " << obj.atime
207		<< " mtime: " << obj.mtime
208		<< " ctime: " << obj.ctime;
	215	<< " atime: " << obj.atime
	216	<< " mtime: " << obj.mtime
	217	<< " ctime: " << obj.ctime;
209	218	return out;
210	219	}
211	220
212	221	std::ostream& operator<<(std::ostream& out, const post_op_attr& obj)
213	222	{
214		if(obj.attributes_follow) return out << obj.post_op_attr_u.attributes;
215		else return out << " void ";
	223	if(obj.attributes_follow)
	224	return out << obj.post_op_attr_u.attributes;
	225	else
	226	return out << " void ";
216	227	}
217	228
218	229	std::ostream& operator<<(std::ostream& out, const wcc_attr& obj)
219	230	{
220		return out << " size: " << obj.size
	231	return out << " size: " << obj.size
221	232	<< " mtime: " << obj.mtime
222	233	<< " ctime: " << obj.ctime;
223	234	}
224	235
225	236	std::ostream& operator<<(std::ostream& out, const pre_op_attr& obj)
226	237	{
227		if(obj.attributes_follow) return out << obj.pre_op_attr_u.attributes;
228		else return out << " void ";
	238	if(obj.attributes_follow)
	239	return out << obj.pre_op_attr_u.attributes;
	240	else
	241	return out << " void ";
229	242	}
230	243
231	244	std::ostream& operator<<(std::ostream& out, const wcc_data& obj)

235	248
236	249	std::ostream& operator<<(std::ostream& out, const post_op_fh3& obj)
237	250	{
238		if(obj.handle_follows) return out << " handle: "
239		<< obj.post_op_fh3_u.handle;
240		else return out << " void ";
	251	if(obj.handle_follows)
	252	return out << " handle: "
	253	<< obj.post_op_fh3_u.handle;
	254	else
	255	return out << " void ";
241	256	}
242	257
243	258	std::ostream& operator<<(std::ostream& out, const time_how& obj)

256	271
257	272	std::ostream& operator<<(std::ostream& out, const set_mode3& obj)
258	273	{
259		if(obj.set_it) return out << obj.set_mode3_u.mode;
260		else return out << " void ";
	274	if(obj.set_it)
	275	return out << obj.set_mode3_u.mode;
	276	else
	277	return out << " void ";
261	278	}
262	279
263	280	std::ostream& operator<<(std::ostream& out, const set_uid3& obj)
264	281	{
265		if(obj.set_it) return out << obj.set_uid3_u.uid;
266		else return out << " void ";
	282	if(obj.set_it)
	283	return out << obj.set_uid3_u.uid;
	284	else
	285	return out << " void ";
267	286	}
268	287
269	288	std::ostream& operator<<(std::ostream& out, const set_gid3& obj)
270	289	{
271		if(obj.set_it) return out << obj.set_gid3_u.gid;
272		else return out << " void ";
	290	if(obj.set_it)
	291	return out << obj.set_gid3_u.gid;
	292	else
	293	return out << " void ";
273	294	}
274	295
275	296	std::ostream& operator<<(std::ostream& out, const set_size3& obj)
276	297	{
277		if(obj.set_it) return out << obj.set_size3_u.size;
278		else return out << " void ";
	298	if(obj.set_it)
	299	return out << obj.set_size3_u.size;
	300	else
	301	return out << " void ";
279	302	}
280	303
281	304	std::ostream& operator<<(std::ostream& out, const set_atime& obj)
282	305	{
283	306	if(obj.set_it == time_how::SET_TO_CLIENT_TIME)
284		return out << obj.set_it << " " << obj.set_atime_u.atime;
285		else return out << obj.set_it;
	307	return out << obj.set_it << " " << obj.set_atime_u.atime;
	308	else
	309	return out << obj.set_it;
286	310	}
287	311
288	312	std::ostream& operator<<(std::ostream& out, const set_mtime& obj)
289	313	{
290	314	if(obj.set_it == time_how::SET_TO_CLIENT_TIME)
291		return out << obj.set_it << " " << obj.set_mtime_u.mtime;
292		else return out << obj.set_it;
	315	return out << obj.set_it << " " << obj.set_mtime_u.mtime;
	316	else
	317	return out << obj.set_it;
293	318	}
294	319
295	320	std::ostream& operator<<(std::ostream& out, const sattr3& obj)

300	325	print_mode3(out, obj.mode.set_mode3_u.mode);
301	326	}
302	327
303		if(obj.uid.set_it) out << " uid: " << obj.uid.set_uid3_u.uid;
304		if(obj.gid.set_it) out << " gid: " << obj.gid.set_gid3_u.gid;
305		if(obj.size.set_it) out << " size: " << obj.size.set_size3_u.size;
	328	if(obj.uid.set_it) out << " uid: " << obj.uid.set_uid3_u.uid;
	329	if(obj.gid.set_it) out << " gid: " << obj.gid.set_gid3_u.gid;
	330	if(obj.size.set_it) out << " size: " << obj.size.set_size3_u.size;
306	331	if(obj.atime.set_it == time_how::SET_TO_CLIENT_TIME)
307	332	out << " atime: " << obj.atime.set_atime_u.atime;
308	333	if(obj.mtime.set_it == time_how::SET_TO_CLIENT_TIME)

313	338
314	339	std::ostream& operator<<(std::ostream& out, const diropargs3& obj)
315	340	{
316		return out << " dir: " << obj.dir
	341	return out << " dir: " << obj.dir
317	342	<< " name: " << obj.name;
318	343	}
319	344
320	345	std::ostream& operator<<(std::ostream& out, const sattrguard3& obj)
321	346	{
322		if(obj.check) return out << " obj_ctime: " << obj.sattrguard3_u.obj_ctime;
323		else return out << " void ";
	347	if(obj.check)
	348	return out << " obj_ctime: " << obj.sattrguard3_u.obj_ctime;
	349	else
	350	return out << " void ";
324	351	}
325	352
326	353	std::ostream& operator<<(std::ostream& out, const stable_how& obj)
327	354	{
328	355	switch(obj)
329	356	{
330		case stable_how::UNSTABLE: return out << "UNSTABLE";
331		case stable_how::DATA_SYNC: return out << "DATA_SYNC";
332		case stable_how::FILE_SYNC: return out << "FILE_SYNC";
	357	case stable_how::UNSTABLE:
	358	return out << "UNSTABLE";
	359	case stable_how::DATA_SYNC:
	360	return out << "DATA_SYNC";
	361	case stable_how::FILE_SYNC:
	362	return out << "FILE_SYNC";
333	363	}
334	364	return out;
335	365	}

338	368	{
339	369	switch(obj)
340	370	{
341		case createmode3::UNCHECKED: return out << "UNCHECKED";
342		case createmode3::GUARDED: return out << "GUARDED";
343		case createmode3::EXCLUSIVE: return out << "EXCLUSIVE";
	371	case createmode3::UNCHECKED:
	372	return out << "UNCHECKED";
	373	case createmode3::GUARDED:
	374	return out << "GUARDED";
	375	case createmode3::EXCLUSIVE:
	376	return out << "EXCLUSIVE";
344	377	}
345	378	return out;
346	379	}

364	397	std::ostream& operator<<(std::ostream& out, const symlinkdata3& obj)
365	398	{
366	399	return out << " symlink_attributes: " << obj.symlink_attributes
367		<< " symlink_data: " << obj.symlink_data;
	400	<< " symlink_data: " << obj.symlink_data;
368	401	}
369	402
370	403	std::ostream& operator<<(std::ostream& out, const devicedata3& obj)
371	404	{
372	405	return out << " dev_attributes: " << obj.dev_attributes
373		<< " spec: " << obj.spec;
374		}
375
	406	<< " spec: " << obj.spec;
	407	}
376	408
377	409	std::ostream& operator<<(std::ostream& out, const mknoddata3& obj)
378	410	{

381	413	{
382	414	case ftype3::NF3CHR:
383	415	case ftype3::NF3BLK:
384		return out << " device: " << obj.mknoddata3_u.device;
	416	return out << " device: " << obj.mknoddata3_u.device;
385	417	case ftype3::NF3SOCK:
386	418	case ftype3::NF3FIFO:
387	419	return out << " pipe_attributes: " << obj.mknoddata3_u.pipe_attributes;
388		default: break;
389		}
390		return out;
	420	default:
	421	break;
	422	}
	423	return out;
391	424	}
392	425
393	426	std::ostream& operator<<(std::ostream& out, const entry3& obj)
394	427	{
395		out << " file id: " << obj.fileid
396		<< " name: " << obj.name
397		<< " cookie: " << obj.cookie << '\n';
	428	out << " file id: " << obj.fileid
	429	<< " name: " << obj.name
	430	<< " cookie: " << obj.cookie << '\n';
398	431	if(obj.nextentry) out << *obj.nextentry;
399	432	return out;
400	433	}
401	434
402	435	std::ostream& operator<<(std::ostream& out, const dirlist3& obj)
403		{
404		out << " eof: " << obj.eof;
405		if(obj.entries) out << *obj.entries;
406		return out;
407		}
408
409		std::ostream& operator<<(std::ostream& out, const entryplus3& obj)
410		{
411		out << " file id: " << obj.fileid
412		<< " name: " << obj.name
413		<< " name attributes: " << obj.name_attributes
414		<< " name handle: " << obj.name_handle
415		<< " cookie: " << obj.cookie << '\n';
416		if(obj.nextentry) out << *obj.nextentry;
417		return out;
418		}
419
420		std::ostream& operator<<(std::ostream& out, const dirlistplus3& obj)
421	436	{
422	437	out << " eof: " << obj.eof;
423	438	if(obj.entries) out << *obj.entries;
424	439	return out;
425	440	}
	441
	442	std::ostream& operator<<(std::ostream& out, const entryplus3& obj)
	443	{
	444	out << " file id: " << obj.fileid
	445	<< " name: " << obj.name
	446	<< " name attributes: " << obj.name_attributes
	447	<< " name handle: " << obj.name_handle
	448	<< " cookie: " << obj.cookie << '\n';
	449	if(obj.nextentry) out << *obj.nextentry;
	450	return out;
	451	}
	452
	453	std::ostream& operator<<(std::ostream& out, const dirlistplus3& obj)
	454	{
	455	out << " eof: " << obj.eof;
	456	if(obj.entries) out << *obj.entries;
	457	return out;
	458	}
	459
	460	// clang-format off
426	461
427	462	bool_t
428	463	xdr_uint64 (XDR* xdrs, uint64* objp)

2861	2896	return TRUE;
2862	2897	}
2863	2898
	2899	// clang-format on
	2900
2864	2901	} // namespace NFS3
2865	2902	} // namespace protocols
2866	2903	} // namespace NST

+59

-64

src/protocols/nfs3/nfs3_utils.h less more

24	24	#include <cassert>
25	25	#include <ostream>
26	26
	27	#include "api/nfs3_types_rpcgen.h"
27	28	#include "api/nfs_types.h"
28		#include "api/nfs3_types_rpcgen.h"
29
	29
	30	#include "protocols/rpc/rpc_header.h"
30	31	#include "protocols/xdr/xdr_decoder.h"
31		#include "protocols/rpc/rpc_header.h"
32		//------------------------------------------------------------------------------
33		#define NST_PUBLIC __attribute__ ((visibility("default")))
	32	//------------------------------------------------------------------------------
34	33	//------------------------------------------------------------------------------
35	34	namespace NST
36	35	{

38	37	{
39	38	namespace NFS3
40	39	{
41
42	40	namespace NFS3 = NST::API::NFS3;
43	41
44	42	using ProcEnumNFS3 = API::ProcEnumNFS3;
45	43
46		using Validator = rpc::RPCProgramValidator
47		<
48		100003, // SunRPC/NFS program
49		3, // v3
50		ProcEnumNFS3::NFS_NULL, // NFSPROC3_NULL
51		ProcEnumNFS3::COMMIT // NFSPROC3_COMMIT
52		>;
53
	44	using Validator = rpc::RPCProgramValidator<
	45	100003, // SunRPC/NFS program
	46	3, // v3
	47	ProcEnumNFS3::NFS_NULL, // NFSPROC3_NULL
	48	ProcEnumNFS3::COMMIT // NFSPROC3_COMMIT
	49	>;
	50
	51	// clang-format off
54	52	bool_t xdr_uint64 (XDR , NFS3::uint64);
55	53	bool_t xdr_uint32 (XDR , NFS3::uint32);
56	54	bool_t xdr_int64 (XDR , NFS3::int64);

184	182	bool_t xdr_COMMIT3resok (XDR , NFS3::COMMIT3resok);
185	183	bool_t xdr_COMMIT3resfail (XDR , NFS3::COMMIT3resfail);
186	184	bool_t xdr_COMMIT3res (XDR , NFS3::COMMIT3res);
	185	// clang-format on
187	186
188	187	// Procedure 0: NULL - Do nothing
189		inline auto proc_t_of(NFS3::NULL3args&)->decltype(&xdr_NULL3args)
	188	inline auto proc_t_of(NFS3::NULL3args&) -> decltype(&xdr_NULL3args)
190	189	{
191	190	return &xdr_NULL3args;
192	191	}
193	192
194		inline auto proc_t_of(NFS3::NULL3res&)->decltype(&xdr_NULL3res)
	193	inline auto proc_t_of(NFS3::NULL3res&) -> decltype(&xdr_NULL3res)
195	194	{
196	195	return &xdr_NULL3res;
197	196	}
198	197
199	198	// Procedure 1: GETATTR - Get file attributes
200		inline auto proc_t_of(NFS3::GETATTR3args&)->decltype(&xdr_GETATTR3args)
	199	inline auto proc_t_of(NFS3::GETATTR3args&) -> decltype(&xdr_GETATTR3args)
201	200	{
202	201	return &xdr_GETATTR3args;
203	202	}
204	203
205		inline auto proc_t_of(NFS3::GETATTR3res&)->decltype(&xdr_GETATTR3res)
	204	inline auto proc_t_of(NFS3::GETATTR3res&) -> decltype(&xdr_GETATTR3res)
206	205	{
207	206	return &xdr_GETATTR3res;
208	207	}
209	208
210	209	// Procedure 2: SETATTR - Set file attributes
211		inline auto proc_t_of(NFS3::SETATTR3args&)->decltype(&xdr_SETATTR3args)
	210	inline auto proc_t_of(NFS3::SETATTR3args&) -> decltype(&xdr_SETATTR3args)
212	211	{
213	212	return &xdr_SETATTR3args;
214	213	}
215	214
216		inline auto proc_t_of(NFS3::SETATTR3res&)->decltype(&xdr_SETATTR3res)
	215	inline auto proc_t_of(NFS3::SETATTR3res&) -> decltype(&xdr_SETATTR3res)
217	216	{
218	217	return &xdr_SETATTR3res;
219	218	}
220	219
221	220	// Procedure 3: LOOKUP - Lookup filename
222		inline auto proc_t_of(NFS3::LOOKUP3args&)->decltype(&xdr_LOOKUP3args)
	221	inline auto proc_t_of(NFS3::LOOKUP3args&) -> decltype(&xdr_LOOKUP3args)
223	222	{
224	223	return &xdr_LOOKUP3args;
225	224	}
226	225
227		inline auto proc_t_of(NFS3::LOOKUP3res&)->decltype(&xdr_LOOKUP3res)
	226	inline auto proc_t_of(NFS3::LOOKUP3res&) -> decltype(&xdr_LOOKUP3res)
228	227	{
229	228	return &xdr_LOOKUP3res;
230	229	}
231	230
232	231	// Procedure 4: ACCESS - Check Access Permission
233		inline auto proc_t_of(NFS3::ACCESS3args&)->decltype(&xdr_ACCESS3args)
	232	inline auto proc_t_of(NFS3::ACCESS3args&) -> decltype(&xdr_ACCESS3args)
234	233	{
235	234	return &xdr_ACCESS3args;
236	235	}
237	236
238		inline auto proc_t_of(NFS3::ACCESS3res&)->decltype(&xdr_ACCESS3res)
	237	inline auto proc_t_of(NFS3::ACCESS3res&) -> decltype(&xdr_ACCESS3res)
239	238	{
240	239	return &xdr_ACCESS3res;
241	240	}
242	241
243	242	// Procedure 5: READLINK - Read from symbolic link
244		inline auto proc_t_of(NFS3::READLINK3args&)->decltype(&xdr_READLINK3args)
	243	inline auto proc_t_of(NFS3::READLINK3args&) -> decltype(&xdr_READLINK3args)
245	244	{
246	245	return &xdr_READLINK3args;
247	246	}
248	247
249		inline auto proc_t_of(NFS3::READLINK3res&)->decltype(&xdr_READLINK3res)
	248	inline auto proc_t_of(NFS3::READLINK3res&) -> decltype(&xdr_READLINK3res)
250	249	{
251	250	return &xdr_READLINK3res;
252	251	}
253	252
254	253	// Procedure 6: READ - Read From file
255		inline auto proc_t_of(NFS3::READ3args&)->decltype(&xdr_READ3args)
	254	inline auto proc_t_of(NFS3::READ3args&) -> decltype(&xdr_READ3args)
256	255	{
257	256	return &xdr_READ3args;
258	257	}
259	258
260		inline auto proc_t_of(NFS3::READ3res&)->decltype(&xdr_READ3res)
	259	inline auto proc_t_of(NFS3::READ3res&) -> decltype(&xdr_READ3res)
261	260	{
262	261	return &xdr_READ3res;
263	262	}
264	263
265	264	// Procedure 7: WRITE - Write to file
266		inline auto proc_t_of(NFS3::WRITE3args&)->decltype(&xdr_WRITE3args)
	265	inline auto proc_t_of(NFS3::WRITE3args&) -> decltype(&xdr_WRITE3args)
267	266	{
268	267	return &xdr_WRITE3args;
269	268	}
270	269
271		inline auto proc_t_of(NFS3::WRITE3res&)->decltype(&xdr_WRITE3res)
	270	inline auto proc_t_of(NFS3::WRITE3res&) -> decltype(&xdr_WRITE3res)
272	271	{
273	272	return &xdr_WRITE3res;
274	273	}
275	274
276	275	// Procedure 8: CREATE - Create a file
277		inline auto proc_t_of(NFS3::CREATE3args&)->decltype(&xdr_CREATE3args)
	276	inline auto proc_t_of(NFS3::CREATE3args&) -> decltype(&xdr_CREATE3args)
278	277	{
279	278	return &xdr_CREATE3args;
280	279	}
281	280
282		inline auto proc_t_of(NFS3::CREATE3res&)->decltype(&xdr_CREATE3res)
	281	inline auto proc_t_of(NFS3::CREATE3res&) -> decltype(&xdr_CREATE3res)
283	282	{
284	283	return &xdr_CREATE3res;
285	284	}
286	285
287	286	// Procedure 9: MKDIR - Create a directory
288		inline auto proc_t_of(NFS3::MKDIR3args&)->decltype(&xdr_MKDIR3args)
	287	inline auto proc_t_of(NFS3::MKDIR3args&) -> decltype(&xdr_MKDIR3args)
289	288	{
290	289	return &xdr_MKDIR3args;
291	290	}
292	291
293		inline auto proc_t_of(NFS3::MKDIR3res&)->decltype(&xdr_MKDIR3res)
	292	inline auto proc_t_of(NFS3::MKDIR3res&) -> decltype(&xdr_MKDIR3res)
294	293	{
295	294	return &xdr_MKDIR3res;
296	295	}
297	296
298	297	// Procedure 10: SYMLINK - Create a symbolic link
299		inline auto proc_t_of(NFS3::SYMLINK3args&)->decltype(&xdr_SYMLINK3args)
	298	inline auto proc_t_of(NFS3::SYMLINK3args&) -> decltype(&xdr_SYMLINK3args)
300	299	{
301	300	return &xdr_SYMLINK3args;
302	301	}
303	302
304		inline auto proc_t_of(NFS3::SYMLINK3res&)->decltype(&xdr_SYMLINK3res)
	303	inline auto proc_t_of(NFS3::SYMLINK3res&) -> decltype(&xdr_SYMLINK3res)
305	304	{
306	305	return &xdr_SYMLINK3res;
307	306	}
308	307
309	308	// Procedure 11: MKNOD - Create a special device
310		inline auto proc_t_of(NFS3::MKNOD3args&)->decltype(&xdr_MKNOD3args)
	309	inline auto proc_t_of(NFS3::MKNOD3args&) -> decltype(&xdr_MKNOD3args)
311	310	{
312	311	return &xdr_MKNOD3args;
313	312	}
314	313
315		inline auto proc_t_of(NFS3::MKNOD3res&)->decltype(&xdr_MKNOD3res)
	314	inline auto proc_t_of(NFS3::MKNOD3res&) -> decltype(&xdr_MKNOD3res)
316	315	{
317	316	return &xdr_MKNOD3res;
318	317	}
319	318
320	319	// Procedure 12: REMOVE - Remove a File
321		inline auto proc_t_of(NFS3::REMOVE3args&)->decltype(&xdr_REMOVE3args)
	320	inline auto proc_t_of(NFS3::REMOVE3args&) -> decltype(&xdr_REMOVE3args)
322	321	{
323	322	return &xdr_REMOVE3args;
324	323	}
325	324
326		inline auto proc_t_of(NFS3::REMOVE3res&)->decltype(&xdr_REMOVE3res)
	325	inline auto proc_t_of(NFS3::REMOVE3res&) -> decltype(&xdr_REMOVE3res)
327	326	{
328	327	return &xdr_REMOVE3res;
329	328	}
330	329
331	330	// Procedure 13: RMDIR - Remove a Directory
332		inline auto proc_t_of(NFS3::RMDIR3args&)->decltype(&xdr_RMDIR3args)
	331	inline auto proc_t_of(NFS3::RMDIR3args&) -> decltype(&xdr_RMDIR3args)
333	332	{
334	333	return &xdr_RMDIR3args;
335	334	}
336	335
337		inline auto proc_t_of(NFS3::RMDIR3res&)->decltype(&xdr_RMDIR3res)
	336	inline auto proc_t_of(NFS3::RMDIR3res&) -> decltype(&xdr_RMDIR3res)
338	337	{
339	338	return &xdr_RMDIR3res;
340	339	}
341	340
342	341	// Procedure 14: RENAME - Rename a File or Directory
343		inline auto proc_t_of(NFS3::RENAME3args&)->decltype(&xdr_RENAME3args)
	342	inline auto proc_t_of(NFS3::RENAME3args&) -> decltype(&xdr_RENAME3args)
344	343	{
345	344	return &xdr_RENAME3args;
346	345	}
347	346
348		inline auto proc_t_of(NFS3::RENAME3res&)->decltype(&xdr_RENAME3res)
	347	inline auto proc_t_of(NFS3::RENAME3res&) -> decltype(&xdr_RENAME3res)
349	348	{
350	349	return &xdr_RENAME3res;
351	350	}
352	351
353	352	// Procedure 15: LINK - Create Link to an object
354		inline auto proc_t_of(NFS3::LINK3args&)->decltype(&xdr_LINK3args)
	353	inline auto proc_t_of(NFS3::LINK3args&) -> decltype(&xdr_LINK3args)
355	354	{
356	355	return &xdr_LINK3args;
357	356	}
358	357
359		inline auto proc_t_of(NFS3::LINK3res&)->decltype(&xdr_LINK3res)
	358	inline auto proc_t_of(NFS3::LINK3res&) -> decltype(&xdr_LINK3res)
360	359	{
361	360	return &xdr_LINK3res;
362	361	}
363	362
364	363	// Procedure 16: READDIR - Read From Directory
365		inline auto proc_t_of(NFS3::READDIR3args&)->decltype(&xdr_READDIR3args)
	364	inline auto proc_t_of(NFS3::READDIR3args&) -> decltype(&xdr_READDIR3args)
366	365	{
367	366	return &xdr_READDIR3args;
368	367	}
369	368
370		inline auto proc_t_of(NFS3::READDIR3res&)->decltype(&xdr_READDIR3res)
	369	inline auto proc_t_of(NFS3::READDIR3res&) -> decltype(&xdr_READDIR3res)
371	370	{
372	371	return &xdr_READDIR3res;
373	372	}
374	373
375	374	// Procedure 17: READDIRPLUS - Extended read from directory
376		inline auto proc_t_of(NFS3::READDIRPLUS3args&)->decltype(&xdr_READDIRPLUS3args)
	375	inline auto proc_t_of(NFS3::READDIRPLUS3args&) -> decltype(&xdr_READDIRPLUS3args)
377	376	{
378	377	return &xdr_READDIRPLUS3args;
379	378	}
380	379
381		inline auto proc_t_of(NFS3::READDIRPLUS3res&)->decltype(&xdr_READDIRPLUS3res)
	380	inline auto proc_t_of(NFS3::READDIRPLUS3res&) -> decltype(&xdr_READDIRPLUS3res)
382	381	{
383	382	return &xdr_READDIRPLUS3res;
384	383	}
385	384
386	385	// Procedure 18: FSSTAT - Get dynamic file system information
387		inline auto proc_t_of(NFS3::FSSTAT3args&)->decltype(&xdr_FSSTAT3args)
	386	inline auto proc_t_of(NFS3::FSSTAT3args&) -> decltype(&xdr_FSSTAT3args)
388	387	{
389	388	return &xdr_FSSTAT3args;
390	389	}
391	390
392		inline auto proc_t_of(NFS3::FSSTAT3res&)->decltype(&xdr_FSSTAT3res)
	391	inline auto proc_t_of(NFS3::FSSTAT3res&) -> decltype(&xdr_FSSTAT3res)
393	392	{
394	393	return &xdr_FSSTAT3res;
395	394	}
396	395
397	396	// Procedure 19: FSINFO - Get static file system Information
398		inline auto proc_t_of(NFS3::FSINFO3args&)->decltype(&xdr_FSINFO3args)
	397	inline auto proc_t_of(NFS3::FSINFO3args&) -> decltype(&xdr_FSINFO3args)
399	398	{
400	399	return &xdr_FSINFO3args;
401	400	}
402	401
403		inline auto proc_t_of(NFS3::FSINFO3res&)->decltype(&xdr_FSINFO3res)
	402	inline auto proc_t_of(NFS3::FSINFO3res&) -> decltype(&xdr_FSINFO3res)
404	403	{
405	404	return &xdr_FSINFO3res;
406	405	}
407	406
408	407	// Procedure 20: PATHCONF - Retrieve POSIX information
409		inline auto proc_t_of(NFS3::PATHCONF3args&)->decltype(&xdr_PATHCONF3args)
	408	inline auto proc_t_of(NFS3::PATHCONF3args&) -> decltype(&xdr_PATHCONF3args)
410	409	{
411	410	return &xdr_PATHCONF3args;
412	411	}
413	412
414		inline auto proc_t_of(NFS3::PATHCONF3res&)->decltype(&xdr_PATHCONF3res)
	413	inline auto proc_t_of(NFS3::PATHCONF3res&) -> decltype(&xdr_PATHCONF3res)
415	414	{
416	415	return &xdr_PATHCONF3res;
417	416	}
418	417
419	418	// Procedure 21: COMMIT - Commit cached data on a server to stable storage
420		inline auto proc_t_of(NFS3::COMMIT3args&)->decltype(&xdr_COMMIT3args)
	419	inline auto proc_t_of(NFS3::COMMIT3args&) -> decltype(&xdr_COMMIT3args)
421	420	{
422	421	return &xdr_COMMIT3args;
423	422	}
424	423
425		inline auto proc_t_of(NFS3::COMMIT3res&)->decltype(&xdr_COMMIT3res)
	424	inline auto proc_t_of(NFS3::COMMIT3res&) -> decltype(&xdr_COMMIT3res)
426	425	{
427	426	return &xdr_COMMIT3res;
428	427	}
429
430		extern "C"
431		NST_PUBLIC
432		const char* print_nfs3_procedures(const ProcEnumNFS3::NFSProcedure proc);
433	428
434	429	std::ostream& operator<<(std::ostream& out, const ProcEnumNFS3::NFSProcedure proc);
435	430

471	466	} // namespace protocols
472	467	} // namespace NST
473	468	//------------------------------------------------------------------------------
474		#endif//NFS3_UTILS_H
475		//------------------------------------------------------------------------------
	469	#endif // NFS3_UTILS_H
	470	//------------------------------------------------------------------------------

+10

-6

src/protocols/nfs4/nfs41_utils.cpp less more

0	0	//------------------------------------------------------------------------------
1		// Author: Alexey Costroma
	1	// Author: Alexey Costroma
2	2	// Description: Helpers for parsing NFS structures.
3	3	// Copyright (c) 2014 EPAM Systems
4	4	//------------------------------------------------------------------------------

20	20	//------------------------------------------------------------------------------
21	21	#include <iomanip>
22	22
	23	#include "api/plugin_api.h" // for NST_PUBLIC
23	24	#include "protocols/nfs/nfs_utils.h"
24	25	#include "protocols/nfs4/nfs41_utils.h"
25	26	//------------------------------------------------------------------------------
26	27	using namespace NST::API::NFS41;
27		using namespace NST::protocols::NFS; // NFS helpers
	28	using namespace NST::protocols::NFS; // NFS helpers
28	29	//------------------------------------------------------------------------------
29	30	namespace NST
30	31	{

32	33	{
33	34	namespace NFS41
34	35	{
	36	// clang-format off
35	37
36	38	std::ostream& operator<<(std::ostream& out, const ProcEnumNFS41::NFSProcedure proc)
37	39	{
38	40	return out << print_nfs41_procedures(proc);
39	41	}
40	42
41		const char* print_nfs41_procedures(const ProcEnumNFS41::NFSProcedure proc)
	43	extern "C" NST_PUBLIC const char* print_nfs41_procedures(const ProcEnumNFS41::NFSProcedure proc)
42	44	{
43	45	// In all cases we suppose, that NFSv4 operation ILLEGAL(10044)
44	46	// has the second position in ProcEnumNFS41

345	347
346	348	std::ostream& operator<<(std::ostream& out, const nfs_fh4& obj)
347	349	{
348		NFS::print_nfs_fh(out,
349		obj.nfs_fh4_val,
350		obj.nfs_fh4_len);
	350	print_nfs_fh(out,
	351	obj.nfs_fh4_val,
	352	obj.nfs_fh4_len);
351	353	return out;
352	354	}
353	355

8684	8686	return TRUE;
8685	8687	}
8686	8688
	8689	// clang-format on
	8690
8687	8691	} // namespace NFS41
8688	8692	} // namespace protocols
8689	8693	} // namespace NST

+15

-21

src/protocols/nfs4/nfs41_utils.h less more

23	23	//------------------------------------------------------------------------------
24	24	#include <ostream>
25	25
	26	#include "api/nfs41_types_rpcgen.h"
26	27	#include "api/nfs_types.h"
27		#include "api/nfs41_types_rpcgen.h"
28	28	#include "protocols/nfs/nfs_utils.h"
29	29	#include "protocols/rpc/rpc_header.h"
30	30	//------------------------------------------------------------------------------

34	34	{
35	35	namespace NFS41
36	36	{
37
38	37	namespace NFS41 = NST::API::NFS41;
39	38
40	39	using ProcEnumNFS41 = API::ProcEnumNFS41;
41	40
42		using Validator = rpc::RPCProgramValidator
43		<
44		100003, // SunRPC/NFS program
45		4, // v4
46		ProcEnumNFS41::NFS_NULL, // NFSPROC41RPCGEN_NULL (0)
47		ProcEnumNFS41::COMPOUND // NFSPROC41RPCGEN_COMPOUND (1)
48		>;
49
	41	using Validator = rpc::RPCProgramValidator<
	42	100003, // SunRPC/NFS program
	43	4, // v4
	44	ProcEnumNFS41::NFS_NULL, // NFSPROC41RPCGEN_NULL (0)
	45	ProcEnumNFS41::COMPOUND // NFSPROC41RPCGEN_COMPOUND (1)
	46	>;
	47
	48	// clang-format off
50	49	bool_t xdr_nfs_ftype4 (XDR , NFS41::nfs_ftype4);
51	50	bool_t xdr_nfsstat4 (XDR , NFS41::nfsstat4);
52	51	bool_t xdr_attrlist4 (XDR , NFS41::attrlist4);

459	458	bool_t xdr_nfs_cb_resop4 (XDR , NFS41::nfs_cb_resop4);
460	459	bool_t xdr_CB_COMPOUND4args (XDR , NFS41::CB_COMPOUND4args);
461	460	bool_t xdr_CB_COMPOUND4res (XDR , NFS41::CB_COMPOUND4res);
	461	// clang-format on
462	462
463	463	// Procedure 0: NULL - Do nothing
464		inline auto proc_t_of(NFS41::NULL4args&)->decltype(&xdr_NULL4args)
	464	inline auto proc_t_of(NFS41::NULL4args&) -> decltype(&xdr_NULL4args)
465	465	{
466	466	return xdr_NULL4args;
467	467	}
468	468
469		inline auto proc_t_of(NFS41::NULL4res&)->decltype(&xdr_NULL4res)
	469	inline auto proc_t_of(NFS41::NULL4res&) -> decltype(&xdr_NULL4res)
470	470	{
471	471	return &xdr_NULL4res;
472	472	}
473	473
474	474	// Procedure 1: COMPOUND
475		inline auto proc_t_of(NFS41::COMPOUND4args&)->decltype(&xdr_COMPOUND4args)
	475	inline auto proc_t_of(NFS41::COMPOUND4args&) -> decltype(&xdr_COMPOUND4args)
476	476	{
477	477	return &xdr_COMPOUND4args;
478	478	}
479	479
480		inline auto proc_t_of(NFS41::COMPOUND4res&)->decltype(&xdr_COMPOUND4res)
	480	inline auto proc_t_of(NFS41::COMPOUND4res&) -> decltype(&xdr_COMPOUND4res)
481	481	{
482	482	return &xdr_COMPOUND4res;
483	483	}
484
485		#define NST_PUBLIC __attribute__ ((visibility("default")))
486
487		extern"C"
488		NST_PUBLIC
489		const char* print_nfs41_procedures(const ProcEnumNFS41::NFSProcedure proc);
490	484
491	485	std::ostream& operator<<(std::ostream& out, const ProcEnumNFS41::NFSProcedure proc);
492	486	std::ostream& operator<<(std::ostream& out, const NFS41::nfs_ftype4& obj);

624	618	} // namespace protocols
625	619	} // namespace NST
626	620	//------------------------------------------------------------------------------
627		#endif//NFS41_UTILS_H
	621	#endif // NFS41_UTILS_H
628	622	//------------------------------------------------------------------------------

+11

-7

src/protocols/nfs4/nfs4_utils.cpp less more

0	0	//------------------------------------------------------------------------------
1		// Author: Alexey Costroma
	1	// Author: Alexey Costroma
2	2	// Description: Helpers for parsing NFS structures.
3	3	// Copyright (c) 2014-2015 EPAM Systems
4	4	//------------------------------------------------------------------------------

20	20	//------------------------------------------------------------------------------
21	21	#include <iomanip>
22	22
	23	#include "api/plugin_api.h" // for NST_PUBLIC
23	24	#include "protocols/nfs/nfs_utils.h"
24	25	#include "protocols/nfs4/nfs4_utils.h"
25	26	//------------------------------------------------------------------------------
26	27	using namespace NST::API::NFS4;
27		using namespace NST::protocols::NFS; // NFS helpers
	28	using namespace NST::protocols::NFS; // NFS helpers
28	29	//------------------------------------------------------------------------------
29	30	namespace NST
30	31	{

32	33	{
33	34	namespace NFS4
34	35	{
35
36	36	std::ostream& operator<<(std::ostream& out, const ProcEnumNFS4::NFSProcedure proc)
37	37	{
38	38	return out << print_nfs4_procedures(proc);
39	39	}
40	40
41		const char* print_nfs4_procedures(const ProcEnumNFS4::NFSProcedure proc)
	41	// clang-format off
	42
	43	extern "C" NST_PUBLIC const char* print_nfs4_procedures(const ProcEnumNFS4::NFSProcedure proc)
42	44	{
43	45	// In all cases we suppose, that NFSv4 operation ILLEGAL(10044)
44	46	// has the second position in ProcEnumNFS4

315	317
316	318	std::ostream& operator<<(std::ostream& out, const nfs_fh4& obj)
317	319	{
318		NFS::print_nfs_fh(out,
319		obj.nfs_fh4_val,
320		obj.nfs_fh4_len);
	320	print_nfs_fh(out,
	321	obj.nfs_fh4_val,
	322	obj.nfs_fh4_len);
321	323	return out;
322	324	}
323	325

4435	4437	return TRUE;
4436	4438	}
4437	4439
	4440	// clang-format on
	4441
4438	4442	} // namespace NFS4
4439	4443	} // namespace protocols
4440	4444	} // namespace NST

+16

-23

src/protocols/nfs4/nfs4_utils.h less more

23	23	//------------------------------------------------------------------------------
24	24	#include <ostream>
25	25
	26	#include "api/nfs4_types_rpcgen.h"
26	27	#include "api/nfs_types.h"
27		#include "api/nfs4_types_rpcgen.h"
28	28	#include "protocols/nfs/nfs_utils.h"
29	29	#include "protocols/rpc/rpc_header.h"
30	30	//------------------------------------------------------------------------------

34	34	{
35	35	namespace NFS4
36	36	{
37
38	37	namespace NFS4 = NST::API::NFS4;
39	38
40	39	using ProcEnumNFS4 = API::ProcEnumNFS4;
41	40
42		using Validator = rpc::RPCProgramValidator
43		<
44		100003, // SunRPC/NFS program
45		4, // v4
46		ProcEnumNFS4::NFS_NULL, // NFSPROC4RPCGEN_NULL (0)
47		ProcEnumNFS4::COMPOUND // NFSPROC4RPCGEN_COMPOUND (1)
48		>;
49
	41	using Validator = rpc::RPCProgramValidator<
	42	100003, // SunRPC/NFS program
	43	4, // v4
	44	ProcEnumNFS4::NFS_NULL, // NFSPROC4RPCGEN_NULL (0)
	45	ProcEnumNFS4::COMPOUND // NFSPROC4RPCGEN_COMPOUND (1)
	46	>;
	47
	48	// clang-format off
50	49	bool_t xdr_nfs_ftype4 (XDR , NFS4::nfs_ftype4);
51	50	bool_t xdr_nfsstat4 (XDR , NFS4::nfsstat4);
52	51	bool_t xdr_bitmap4 (XDR , NFS4::bitmap4);

282	281	bool_t xdr_nfs_cb_resop4 (XDR , NFS4::nfs_cb_resop4);
283	282	bool_t xdr_CB_COMPOUND4args (XDR , NFS4::CB_COMPOUND4args);
284	283	bool_t xdr_CB_COMPOUND4res (XDR , NFS4::CB_COMPOUND4res);
285
	284	// clang-format on
286	285
287	286	// Procedure 0: NULL - Do nothing
288		inline auto proc_t_of(NFS4::NULL4args&)->decltype(&xdr_NULL4args)
	287	inline auto proc_t_of(NFS4::NULL4args&) -> decltype(&xdr_NULL4args)
289	288	{
290	289	return &xdr_NULL4args;
291	290	}
292	291
293		inline auto proc_t_of(NFS4::NULL4res&)->decltype(&xdr_NULL4res)
	292	inline auto proc_t_of(NFS4::NULL4res&) -> decltype(&xdr_NULL4res)
294	293	{
295	294	return &xdr_NULL4res;
296	295	}
297	296
298	297	// Procedure 1: COMPOUND
299		inline auto proc_t_of(NFS4::COMPOUND4args&)->decltype(&xdr_COMPOUND4args)
	298	inline auto proc_t_of(NFS4::COMPOUND4args&) -> decltype(&xdr_COMPOUND4args)
300	299	{
301	300	return &xdr_COMPOUND4args;
302	301	}
303	302
304		inline auto proc_t_of(NFS4::COMPOUND4res&)->decltype(&xdr_COMPOUND4res)
	303	inline auto proc_t_of(NFS4::COMPOUND4res&) -> decltype(&xdr_COMPOUND4res)
305	304	{
306	305	return &xdr_COMPOUND4res;
307	306	}
308
309		#define NST_PUBLIC __attribute__ ((visibility("default")))
310
311		extern"C"
312		NST_PUBLIC
313		const char* print_nfs4_procedures(const ProcEnumNFS4::NFSProcedure proc);
314	307
315	308	std::ostream& operator<<(std::ostream& out, const ProcEnumNFS4::NFSProcedure proc);
316	309	std::ostream& operator<<(std::ostream& out, const NFS4::nfs_ftype4& obj);

369	362	} // namespace protocols
370	363	} // namespace NST
371	364	//------------------------------------------------------------------------------
372		#endif//NFS4_UTILS_H
373		//------------------------------------------------------------------------------
	365	#endif // NFS4_UTILS_H
	366	//------------------------------------------------------------------------------

+36

-41

src/protocols/rpc/rpc_header.h less more

33	33	{
34	34	namespace rpc
35	35	{
36
37	36	using namespace NST::API;
38	37
39	38	struct MessageHeader
40	39	{
41		inline uint32_t xid () const { return ntohl(m_xid); }
	40	inline uint32_t xid() const { return ntohl(m_xid); }
42	41	inline MsgType type() const { return MsgType(ntohl(m_type)); }
43	42	private:
44	43	MessageHeader() = delete;

47	46	uint32_t m_type;
48	47	};
49	48
50		struct CallHeader: public MessageHeader
	49	struct CallHeader : public MessageHeader
51	50	{
52		inline uint32_t rpcvers() const { return ntohl(m_rpcvers); }
53		inline uint32_t prog() const { return ntohl(m_prog); }
54		inline uint32_t vers() const { return ntohl(m_vers); }
55		inline uint32_t proc() const { return ntohl(m_proc); }
56
	51	inline uint32_t rpcvers() const { return ntohl(m_rpcvers); }
	52	inline uint32_t prog() const { return ntohl(m_prog); }
	53	inline uint32_t vers() const { return ntohl(m_vers); }
	54	inline uint32_t proc() const { return ntohl(m_proc); }
57	55	// OpaqueAuth cred - skipped
58	56	// OpaqueAuth verf - skipped
59	57	private:
60	58	CallHeader() = delete;
61	59
62		uint32_t m_rpcvers; // must be equal to two (2)
	60	uint32_t m_rpcvers; // must be equal to two (2)
63	61	uint32_t m_prog;
64	62	uint32_t m_vers;
65	63	uint32_t m_proc;
66	64	};
67	65
68		struct ReplyHeader: public MessageHeader
	66	struct ReplyHeader : public MessageHeader
69	67	{
70	68	inline ReplyStat stat() const { return ReplyStat(ntohl(m_stat)); }
71
72	69	// accepted_reply areply - skipped
73	70	// rejected_reply rreply - skipped
74	71	private:

77	74	uint32_t m_stat;
78	75	};
79	76
80		struct RecordMark // RFC 5531 section 11 Record Marking Standard
	77	struct RecordMark // RFC 5531 section 11 Record Marking Standard
81	78	{
82		inline bool is_last() const { return ntohl(mark) & 0x80000000; /1st bit/ }
83		inline uint32_t fragment_len() const { return ntohl(mark) & 0x7FFFFFFF; /31 bits/ }
84		inline MessageHeader* fragment() const { return (MessageHeader*)(this+1); }
	79	inline bool is_last() const { return ntohl(mark) & 0x80000000; /1st bit/ }
	80	inline uint32_t fragment_len() const { return ntohl(mark) & 0x7FFFFFFF; /31 bits/ }
	81	inline MessageHeader* fragment() const { return (MessageHeader*)(this + 1); }
85	82	private:
86	83	RecordMark() = delete;
87	84
88	85	uint32_t mark;
89	86	};
90	87
91
92	88	class RPCValidator
93	89	{
94	90	public:
95		static inline bool check(const MessageHeader*const msg)
	91	static inline bool check(const MessageHeader* const msg)
96	92	{
97	93	const MsgType type = msg->type();
98	94

100	96	type == MsgType::REPLY;
101	97	}
102	98
103		static inline bool check(const CallHeader*const call)
	99	static inline bool check(const CallHeader* const call)
104	100	{
105	101	return call->rpcvers() == SUNRPC_MSG_VERSION;
106	102	}
107	103
108		static inline bool check(const ReplyHeader*const reply)
	104	static inline bool check(const ReplyHeader* const reply)
109	105	{
110	106	const ReplyStat stat = reply->stat();
111	107
112	108	return stat == ReplyStat::MSG_ACCEPTED \|\|
113	109	stat == ReplyStat::MSG_DENIED;
114	110	}
	111
115	112	private:
116	113	RPCValidator() = delete;
117	114	};
118	115
119
120		template
121		<
122		uint32_t Program, // remote program number
123		uint32_t Version, // remote program version number
124		uint32_t MinProc, // min remote procedure number
125		uint32_t MaxProc // max remote procedure number
126		>
	116	template <
	117	uint32_t Program, // remote program number
	118	uint32_t Version, // remote program version number
	119	uint32_t MinProc, // min remote procedure number
	120	uint32_t MaxProc // max remote procedure number
	121	>
127	122	class RPCProgramValidator
128	123	{
129	124	public:
130		static inline bool check(const CallHeader*const call)
	125	static inline bool check(const CallHeader* const call)
131	126	{
132	127	const uint32_t proc = call->proc();
133	128
134		return proc <= MaxProc &&
135		proc >= MinProc &&
136		call->prog() == Program &&
137		call->vers() == Version ;
	129	return proc <= MaxProc &&
	130	proc >= MinProc &&
	131	call->prog() == Program &&
	132	call->vers() == Version;
138	133	}
	134
139	135	private:
140	136	RPCProgramValidator() = delete;
141	137	};
142	138
143	139	//This template specialization for remove warning to compare unsigned with zero
144		template
145		<
	140	template <
146	141	uint32_t Program,
147	142	uint32_t Version,
148		uint32_t MaxProc
149		>
	143	uint32_t MaxProc>
150	144	class RPCProgramValidator<Program, Version, 0, MaxProc>
151	145	{
152	146	public:
153		static inline bool check(const CallHeader*const call)
	147	static inline bool check(const CallHeader* const call)
154	148	{
155	149	const uint32_t proc = call->proc();
156	150
157	151	// do not compare uint32_t with 0 (MinProc)
158		return proc <= MaxProc &&
159		call->prog() == Program &&
160		call->vers() == Version ;
	152	return proc <= MaxProc &&
	153	call->prog() == Program &&
	154	call->vers() == Version;
161	155	}
	156
162	157	private:
163	158	RPCProgramValidator() = delete;
164	159	};

167	162	} // namespace protocols
168	163	} // namespace NST
169	164	//------------------------------------------------------------------------------
170		#endif//RPC_HEADER_H
	165	#endif // RPC_HEADER_H
171	166	//------------------------------------------------------------------------------

+30

-31

src/protocols/tcp/tcp_header.h less more

32	32	{
33	33	namespace tcp
34	34	{
35
36	35	// Transmission Control Protocol
37	36	struct tcp_header
38	37	{
39	38	enum Flag // bit masks for flags
40	39	{
41		FIN = 0x01, // finished send data
42		SYN = 0x02, // synchronize sequence numbers
43		RST = 0x04, // reset the connection
44		PSH = 0x08, // push data to the app layer
45		ACK = 0x10, // acknowledge
46		URG = 0x20, // urgent
47		ECE = 0x40, // ECN-echo
48		CWR = 0x80 // congestion window reduced
	40	FIN = 0x01, // finished send data
	41	SYN = 0x02, // synchronize sequence numbers
	42	RST = 0x04, // reset the connection
	43	PSH = 0x08, // push data to the app layer
	44	ACK = 0x10, // acknowledge
	45	URG = 0x20, // urgent
	46	ECE = 0x40, // ECN-echo
	47	CWR = 0x80 // congestion window reduced
49	48	};
50	49
51		in_port_t tcp_sport; // source port
52		in_port_t tcp_dport; // destination port
53		uint32_t tcp_seq; // sequence number
54		uint32_t tcp_ack; // acknowledgement number
55		uint8_t tcp_rsrvd_off; // (unused) and data offset
56		uint8_t tcp_flags; // control flags
57		uint16_t tcp_win; // window
58		uint16_t tcp_sum; // checksum
59		uint16_t tcp_urp; // urgent pointer
60		} __attribute__ ((__packed__));
	50	in_port_t tcp_sport; // source port
	51	in_port_t tcp_dport; // destination port
	52	uint32_t tcp_seq; // sequence number
	53	uint32_t tcp_ack; // acknowledgement number
	54	uint8_t tcp_rsrvd_off; // (unused) and data offset
	55	uint8_t tcp_flags; // control flags
	56	uint16_t tcp_win; // window
	57	uint16_t tcp_sum; // checksum
	58	uint16_t tcp_urp; // urgent pointer
	59	} __attribute__((__packed__));
61	60
62	61	struct TCPHeader : private tcp_header
63	62	{
64		inline in_port_t sport() const { return tcp_sport; }
65		inline in_port_t dport() const { return tcp_dport; }
66		inline uint32_t seq() const { return ntohl(tcp_seq); }
67		inline uint32_t ack() const { return ntohl(tcp_ack); }
68		inline uint8_t offset() const { return (tcp_rsrvd_off & 0xf0) >> 2 /* 4 /; } // return number of bytes
69		inline uint8_t flags() const { return tcp_flags; }
70		inline bool is(tcp_header::Flag flag) const { return tcp_flags & flag; }
71		inline uint16_t window() const { return ntohs(tcp_win); }
72		inline uint16_t checksum() const { return ntohs(tcp_sum); }
73		inline uint16_t urgent() const { return ntohs(tcp_urp); }
74		} __attribute__ ((__packed__));
	63	in_port_t sport() const { return tcp_sport; }
	64	in_port_t dport() const { return tcp_dport; }
	65	uint32_t seq() const { return ntohl(tcp_seq); }
	66	uint32_t ack() const { return ntohl(tcp_ack); }
	67	uint8_t offset() const { return (tcp_rsrvd_off & 0xf0) >> 2 /* 4 /; } // return number of bytes
	68	uint8_t flags() const { return tcp_flags; }
	69	bool is(tcp_header::Flag flag) const { return tcp_flags & flag; }
	70	uint16_t window() const { return ntohs(tcp_win); }
	71	uint16_t checksum() const { return ntohs(tcp_sum); }
	72	uint16_t urgent() const { return ntohs(tcp_urp); }
	73	} __attribute__((__packed__));
75	74
76	75	} // namespace tcp
77	76	} // namespace protocols
78	77	} // namespace NST
79	78	//------------------------------------------------------------------------------
80		#endif//TCP_HEADER_H
	79	#endif // TCP_HEADER_H
81	80	//------------------------------------------------------------------------------

+11

-12

src/protocols/udp/udp_header.h less more

32	32	{
33	33	namespace udp
34	34	{
35
36	35	// User Datagram Protocol RFC 768
37	36	struct udp_header
38	37	{
39		in_port_t udp_sport; // source port, optional, may be 0
40		in_port_t udp_dport; // destination port
41		uint16_t udp_len; // length of the datagram, minimum value is 8
42		uint16_t udp_sum; // checksum of IP pseudo header, the UDP header, and the data
43		} __attribute__ ((__packed__));
	38	in_port_t udp_sport; // source port, optional, may be 0
	39	in_port_t udp_dport; // destination port
	40	uint16_t udp_len; // length of the datagram, minimum value is 8
	41	uint16_t udp_sum; // checksum of IP pseudo header, the UDP header, and the data
	42	} __attribute__((__packed__));
44	43
45	44	struct UDPHeader : private udp_header
46	45	{
47		inline in_port_t sport() const { return udp_sport; }
48		inline in_port_t dport() const { return udp_dport; }
49		inline uint16_t length() const { return ntohs(udp_len); }
50		inline uint16_t checksum() const { return ntohs(udp_sum); }
51		} __attribute__ ((__packed__));
	46	in_port_t sport() const { return udp_sport; }
	47	in_port_t dport() const { return udp_dport; }
	48	uint16_t length() const { return ntohs(udp_len); }
	49	uint16_t checksum() const { return ntohs(udp_sum); }
	50	} __attribute__((__packed__));
52	51
53	52	} // namespace udp
54	53	} // namespace protocols
55	54	} // namespace NST
56	55	//------------------------------------------------------------------------------
57		#endif//UDP_HEADER_H
	56	#endif // UDP_HEADER_H
58	57	//------------------------------------------------------------------------------

+11

-11

src/protocols/xdr/xdr_decoder.h less more

24	24	#include <utility>
25	25	#include <rpc/rpc.h>
26	26	//------------------------------------------------------------------------------
	27	#include "api/nfs3_types_rpcgen.h"
27	28	#include "utils/filtered_data.h"
28		#include "api/nfs3_types_rpcgen.h"
29	29	//------------------------------------------------------------------------------
30	30	using NST::utils::FilteredData;
31	31	using NST::utils::FilteredDataQueue;

36	36	{
37	37	namespace xdr
38	38	{
39
40	39	class XDRDecoderError : public std::runtime_error
41	40	{
42	41	public:
43		explicit XDRDecoderError(const std::string& msg) : std::runtime_error{msg} { }
	42	explicit XDRDecoderError(const std::string& msg)
	43	: std::runtime_error{msg}
	44	{
	45	}
44	46	};
45	47
46	48	class XDRDecoder
47	49	{
48	50	public:
49	51	XDRDecoder(FilteredDataQueue::Ptr&& p)
50		: ptr{std::move(p)}
	52	: ptr{std::move(p)}
51	53	{
52	54	xdrmem_create(&txdr, (char*)ptr->data, ptr->dlen, XDR_DECODE);
53	55	}
54	56	~XDRDecoder()
55	57	{
56		xdr_destroy (&txdr);
	58	xdr_destroy(&txdr);
57	59	}
58	60
59		inline XDR* xdr() { return &txdr; }
60
61		inline const FilteredData& data() const { return *ptr; }
62
	61	XDR* xdr() { return &txdr; }
	62	const FilteredData& data() const { return *ptr; }
63	63	private:
64		XDR txdr;
	64	XDR txdr;
65	65	FilteredDataQueue::Ptr ptr;
66	66	};
67	67

69	69	} // namespace protocols
70	70	} // namespace NST
71	71	//------------------------------------------------------------------------------
72		#endif//XDR_DECODER_H
	72	#endif // XDR_DECODER_H
73	73	//------------------------------------------------------------------------------

+70

-70

src/utils/block_allocator.h less more

21	21	#ifndef BLOCK_ALLOCATOR_H
22	22	#define BLOCK_ALLOCATOR_H
23	23	//------------------------------------------------------------------------------
24		#include <cstring> // for memset()
	24	#include <algorithm>
	25	#include <cassert>
	26	#include <cstdint>
	27	#include <memory>
	28	#include <vector>
25	29	//------------------------------------------------------------------------------
26	30	namespace NST
27	31	{
28	32	namespace utils
29	33	{
30
31		// May throw std::bad_alloc() when memory is not enough
	34	// May throw std::bad_alloc during creation or allocation
32	35	class BlockAllocator
33	36	{
34		struct Chunk
	37	struct Chunk // type for linking free chunks of memory in a list
35	38	{
36		Chunk* next; // used only for free chunks in list
	39	Chunk* next; // pointer to next chunk in a list
37	40	};
	41
	42	using Chunks = std::unique_ptr<char[]>;
	43	using Blocks = std::vector<Chunks>;
	44
38	45	public:
	46	constexpr static std::size_t padding = 16;
39	47
40		BlockAllocator() noexcept
41		: chunk {0}
42		, block {0}
43		, limit {0}
44		, nfree {0}
45		, allocated{0}
46		, blocks{nullptr}
47		, list {nullptr}
	48	BlockAllocator() = default;
	49	~BlockAllocator() noexcept
48	50	{
49		}
50
51		~BlockAllocator()
52		{
53		for(std::size_t i {0}; i<allocated; i++)
54		{
55		delete[] ((char*)blocks[i]);
56		}
57		delete[] blocks;
	51	assert(max_chunks() == free_chunks());
58	52	}
59	53
60	54	void init_allocation(std::size_t chunk_size,
61	55	std::size_t block_size,
62	56	std::size_t block_limit)
63	57	{
64		chunk = chunk_size;
	58	chunk = ((chunk_size + padding - 1) / padding) * padding;
	59	assert(chunk % padding == 0);
	60	assert(chunk >= chunk_size);
	61	assert(chunk >= sizeof(Chunk));
65	62	block = block_size;
	63	assert(block >= 1);
66	64	limit = block_limit;
	65	assert(limit >= 1);
67	66
68		blocks = new Chunk*[limit];
69		memset(blocks, 0, sizeof(Chunk)limit);
70		list = new_block();
	67	blocks.reserve(limit);
	68	list = preallocate_block();
	69	assert(list);
71	70	}
72	71
73		inline void* allocate()
	72	void* allocate()
74	73	{
75	74	if(list == nullptr)
76	75	{
77		if(allocated == limit) // all blocks are allocated!
	76	if(blocks.size() == limit) // all blocks are allocated!
78	77	{
79		increase_blocks_limit();
	78	// soft limit of blocks is reached
80	79	}
81	80
82		list = new_block();
	81	list = preallocate_block();
	82	++limit;
83	83	}
84	84
85		Chunk* c {list};
	85	Chunk* chunk = list;
	86	assert(chunk);
86	87	list = list->next;
87	88	--nfree;
88		return c;
	89	return chunk;
89	90	}
90	91
91		inline void deallocate(void* ptr)
	92	void deallocate(void* ptr) noexcept
92	93	{
93		Chunk* c {(Chunk*) ptr};
94		c->next = list;
95		list = c;
	94	assert(ptr);
	95	assert(std::any_of(std::begin(blocks), std::end(blocks),
	96	[&](const Chunks& chunks) {
	97	const auto b = reinterpret_cast<void*>(chunks.get());
	98	const auto e = reinterpret_cast<void>(chunks.get() + block chunk);
	99	return (b <= ptr) && (ptr < e);
	100	}));
	101	Chunk* chunk = reinterpret_cast<Chunk*>(ptr);
	102	chunk->next = list;
	103	list = chunk;
96	104	++nfree;
97	105	}
98	106
99		// limits
100		inline std::size_t max_chunks() const { return block*limit; }
101		inline std::size_t max_memory() const { return blocklimitchunk; }
102		inline std::size_t max_blocks() const { return limit; }
103		inline std::size_t free_chunks()const { return nfree; }
104
	107	std::size_t max_chunks() const noexcept { return block * limit; }
	108	std::size_t max_memory() const noexcept { return block * limit * chunk; }
	109	std::size_t max_blocks() const noexcept { return limit; }
	110	std::size_t free_chunks() const noexcept { return nfree; }
105	111	private:
106		Chunk* new_block()
	112	Chunk* getof(std::size_t i, const Chunks& chunks) const noexcept
107	113	{
108		char* ptr {new char[block*chunk]};
109		for(std::size_t i {0}; i<block-1; ++i)
110		{
111		((Chunk) &ptr[i chunk])->next = (Chunk) &ptr[(i + 1) chunk];
112		}
113		((Chunk) &ptr[(block - 1) chunk])->next = nullptr;
114		blocks[allocated] = (Chunk*) ptr;
115		++allocated;
116		nfree += block;
117		return (Chunk*) ptr;
	114	assert(i < block);
	115	return reinterpret_cast<Chunk>(&chunks.get()[i chunk]);
118	116	}
119	117
120		void increase_blocks_limit()
	118	Chunk* preallocate_block()
121	119	{
122		const std::size_t new_limit {limit * 2}; // increase soft limit by twice
	120	Chunks chunks(std::make_unique<Chunks::element_type[]>(block * chunk));
123	121
124		Chunk** new_blocks {new Chunk*[new_limit]}; // allocate new array of blocks pointers
125		limit = new_limit;
126		memcpy(new_blocks, blocks, sizeof(Chunk)allocated); // copy pointers of existing blocks
127		memset(&new_blocks[allocated], 0, sizeof(Chunk)(limit-allocated)); // fill pointers for new blocks by NULL
128
129		delete[] blocks; // delete old array of blocks pointers
130		blocks = new_blocks; // set new array
	122	// link chunks to a list
	123	for(std::size_t i = 0; i < block - 1; ++i)
	124	{
	125	getof(i, chunks)->next = getof(i + 1, chunks);
	126	}
	127	getof(block - 1, chunks)->next = nullptr;
	128	Chunk* first = getof(0, chunks);
	129	blocks.emplace_back(std::move(chunks));
	130	nfree += block;
	131	return first;
131	132	}
132	133
133		std::size_t chunk; // chunk size
134		std::size_t block; // num chunks in block
135		std::size_t limit; // max blocks, soft limit
136		std::size_t nfree; // num of avaliable chunks
137		std::size_t allocated;// num of allocated blocks, up to limit
138		Chunk** blocks; // array of blocks
139		Chunk* list; // list of free chunks
	134	Chunk* list = nullptr; // head of list of free chunks
	135	std::size_t chunk = 0; // size of chunk
	136	std::size_t block = 0; // num chunks in block
	137	std::size_t limit = 0; // max blocks, soft limit
	138	std::size_t nfree = 0; // num of avaliable chunks
	139	Blocks blocks; // array of blocks
140	140	};
141	141
142	142	} // namespace utils
143	143	} // namespace NST
144	144	//------------------------------------------------------------------------------
145		#endif//BLOCK_ALLOCATOR_H
	145	#endif // BLOCK_ALLOCATOR_H
146	146	//------------------------------------------------------------------------------

-2

src/utils/dynamic_load.cpp less more

27	27	using namespace NST::utils;
28	28	//------------------------------------------------------------------------------
29	29
30		DynamicLoad::DynamicLoad(const std::string &file)
	30	DynamicLoad::DynamicLoad(const std::string& file)
31	31	{
32	32	handle = dlopen(file.c_str(), RTLD_LAZY);
33	33	if(handle == nullptr)

41	41	dlclose(handle);
42	42	}
43	43
44		void* DynamicLoad::get_symbol(const std::string &name)
	44	void* DynamicLoad::get_symbol(const std::string& name)
45	45	{
46	46	void* address = (dlsym)(handle, name.c_str());
47	47	if(address == nullptr)

-6

src/utils/dynamic_load.h less more

27	27	{
28	28	namespace utils
29	29	{
30
31	30	class DynamicLoad
32	31	{
33	32	public:
34	33	class DLException : public std::runtime_error
35	34	{
36	35	public:
37		explicit DLException(const std::string& msg) : std::runtime_error{msg} { }
	36	explicit DLException(const std::string& msg)
	37	: std::runtime_error{msg}
	38	{
	39	}
38	40	};
39	41
40	42	protected:
41	43	explicit DynamicLoad(const std::string& file);
42	44	~DynamicLoad();
43	45
44		template<typename SymbolPtr>
	46	template <typename SymbolPtr>
45	47	void load_address_of(const std::string& name, SymbolPtr& address)
46	48	{
47	49	static_assert(sizeof(void*) == sizeof(SymbolPtr), "object pointer and function pointer sizes must be equal");

50	52	using hook_dlsym_t = SymbolPtr (DynamicLoad::*)(const std::string&);
51	53
52	54	hook_dlsym_t get_symbol_func = reinterpret_cast<hook_dlsym_t>(&DynamicLoad::get_symbol);
53		address = (this.get_symbol_func)(name);
54		}
	55	address = (this.get_symbol_func)(name);
	56	}
55	57
56	58	/*!
57	59	* Gets symbol by name from DLL

68	70	} // namespace utils
69	71	} // namespace NST
70	72	//------------------------------------------------------------------------------
71		#endif//DYNAMIC_LOAD_H
	73	#endif // DYNAMIC_LOAD_H
72	74	//------------------------------------------------------------------------------

+30

-27

src/utils/filtered_data.h less more

21	21	#ifndef FILTERED_DATA_H
22	22	#define FILTERED_DATA_H
23	23	//------------------------------------------------------------------------------
	24	#include <cassert>
24	25	#include <cstdint>
25		#include <cassert>
26	26
27	27	#include <sys/time.h>
28	28
	29	#include "utils/queue.h"
29	30	#include "utils/sessions.h"
30		#include "utils/queue.h"
31	31	//------------------------------------------------------------------------------
32	32	namespace NST
33	33	{
34	34	namespace utils
35	35	{
36
37	36	struct FilteredData
38	37	{
39	38	using Direction = NST::utils::Session::Direction;
	39
40	40	public:
41	41	NetworkSession* session{nullptr}; // pointer to immutable session in Filtration
42		struct timeval timestamp; // timestamp of last collected packet
43		Direction direction; // direction of data transmission
	42	struct timeval timestamp; // timestamp of last collected packet
	43	Direction direction; // direction of data transmission
44	44
45		uint32_t dlen{0}; // length of filtered data
46		uint8_t* data{cache}; // pointer to data in memory. {Readonly. Always points to proper memory buffer}
	45	uint32_t dlen{0}; // length of filtered data
	46	uint8_t* data{cache}; // pointer to data in memory. {Readonly. Always points to proper memory buffer}
47	47
48	48	private:
49		const static int CACHE_SIZE {4000};
50		uint8_t cache[CACHE_SIZE];
51		uint8_t* memory{nullptr};
52		uint32_t memsize{0};
	49	const static int CACHE_SIZE{4000};
	50
	51	uint8_t cache[CACHE_SIZE];
	52	uint8_t* memory{nullptr};
	53	uint32_t memsize{0};
53	54
54	55	public:
55	56	// disable copying
56		FilteredData(const FilteredData&) = delete;
	57	FilteredData(const FilteredData&) = delete;
57	58	FilteredData& operator=(const FilteredData&) = delete;
58	59
59		inline FilteredData() noexcept : data{cache}
	60	FilteredData() noexcept
	61	: data{cache}
60	62	{
61	63	}
62	64
63		inline ~FilteredData() {
	65	~FilteredData()
	66	{
64	67	delete[] memory;
65	68	}
66	69
67		inline uint32_t capacity() const
	70	uint32_t capacity() const
68	71	{
69		if (nullptr == memory)
	72	if(nullptr == memory)
70	73	{
71	74	assert(data == cache);
72	75	return CACHE_SIZE;

77	80	// Resize capacity with data safety
78	81	void resize(uint32_t newsize)
79	82	{
80		if (capacity() >= newsize) return; // not resize less
	83	if(capacity() >= newsize) return; // not resize less
81	84
82		if (nullptr == memory)
	85	if(nullptr == memory)
83	86	{
84	87	memory = new uint8_t[newsize];
85		if (dlen)
	88	if(dlen)
86	89	{
87	90	memcpy(memory, cache, dlen);
88	91	}
89	92	memsize = newsize;
90		data = memory;
	93	data = memory;
91	94	}
92	95	else // have some filled memory
93	96	{
94		uint8_t* mem {new uint8_t[newsize]};
95		if (dlen)
	97	uint8_t* mem{new uint8_t[newsize]};
	98	if(dlen)
96	99	{
97	100	memcpy(mem, memory, dlen);
98	101	}

104	107	}
105	108
106	109	// Reset data. Release free memory if allocated
107		inline void reset()
	110	void reset()
108	111	{
109		if (nullptr != memory)
	112	if(nullptr != memory)
110	113	{
111	114	delete[] memory;
112	115	memory = nullptr;
113	116	}
114	117	memsize = 0;
115		dlen = 0;
116		data = cache;
	118	dlen = 0;
	119	data = cache;
117	120	}
118	121	};
119	122

122	125	} // namespace utils
123	126	} // namespace NST
124	127	//------------------------------------------------------------------------------
125		#endif//FILTERED_DATA_H
	128	#endif // FILTERED_DATA_H
126	129	//------------------------------------------------------------------------------

+14

-20

src/utils/log.cpp less more

47	47	{
48	48	namespace utils
49	49	{
50
51		static FILE* log_file {::stderr};
52		static bool own_file {false};
	50	static FILE* log_file{::stderr};
	51	static bool own_file{false};
53	52
54	53	namespace // unnanmed
55	54	{
56
57	55	static FILE* try_open(const std::string& file_name)
58	56	{
59	57	FILE* file = fopen(file_name.c_str(), "a+");
60	58	if(file == nullptr)
61	59	{
62		throw std::system_error{errno, std::system_category(),
63		{"Error in opening file: " + file_name}};
	60	throw std::system_error{errno, std::system_category(), {"Error in opening file: " + file_name}};
64	61	}
65		chmod(file_name.c_str(), S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IWGRP\|S_IROTH\|S_IWOTH);
	62	chmod(file_name.c_str(), S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IWGRP \| S_IROTH \| S_IWOTH);
66	63	if(flock(fileno(file), LOCK_EX \| LOCK_NB))
67	64	{
68	65	fclose(file);
69		throw std::system_error{errno, std::system_category(),
70		{"Log file already locked: " + file_name}};
	66	throw std::system_error{errno, std::system_category(), {"Log file already locked: " + file_name}};
71	67	}
72	68	time_t now = time(NULL);
73	69	fprintf(file, "--------------------------------------------------------------------------\n");

80	76	} // namespace unnamed
81	77
82	78	Log::Global::Global(const std::string& path)
83		: log_file_path {path}
	79	: log_file_path{path}
84	80	{
85	81	if(own_file)
86	82	{

90	86	if(!log_file_path.empty())
91	87	{
92	88	struct stat st;
93		bool exists = stat(log_file_path.c_str(), &st) == 0 ? true : false;
	89
	90	bool exists = (stat(log_file_path.c_str(), &st) == 0);
94	91
95	92	if(!exists && log_file_path.back() == '/')
96	93	{
97		throw std::system_error{errno, std::system_category(),
98		{"Error accessing directory: " + log_file_path}};
	94	throw std::system_error{errno, std::system_category(), {"Error accessing directory: " + log_file_path}};
99	95	}
100	96
101	97	if(exists && S_ISDIR(st.st_mode))
102	98	{
103		throw std::system_error{errno, std::system_category(),
104		{"Incorrect log file path: " + log_file_path + " - it is a directory! Please set correct path to log."}};
	99	throw std::system_error{errno, std::system_category(), {"Incorrect log file path: " + log_file_path + " - it is a directory! Please set correct path to log."}};
105	100	}
106	101	}
107	102	else

136	131	FILE* temp = freopen(log_file_path.c_str(), "a+", log_file);
137	132	if(temp == nullptr)
138	133	{
139		throw std::system_error{errno, std::system_category(),
140		{std::string{"Can't reopen file: "} + log_file_path}};
	134	throw std::system_error{errno, std::system_category(), {std::string{"Can't reopen file: "} + log_file_path}};
141	135	}
142	136	log_file = temp;
143	137	}
144	138
145	139	Log::Log()
146		: std::stringbuf {ios_base::out}
147		, std::ostream {nullptr}
	140	: std::stringbuf{ios_base::out}
	141	, std::ostream{nullptr}
148	142	{
149		std::stringbuf::setp(buffer, buffer+sizeof(buffer));
	143	std::stringbuf::setp(buffer, buffer + sizeof(buffer));
150	144	std::ostream::init(static_cast<std::stringbuf*>(this));
151	145	std::ostream::put('\n');
152	146	}

+25

-18

src/utils/log.h less more

30	30	#define DO_STRINGIZE(x) #x
31	31	// TODO: DANGEROUS MACRO ! Passing custom client string as format to printf().
32	32	// May be cause of SIGSEGV
33		#define TRACE(...) {\
34		NST::utils::Log::message(__FILE__ ":" STRINGIZE(__LINE__) ": " __VA_ARGS__);\
35		NST::utils::Log::message("\n");\
36		NST::utils::Log::flush();\
37		}
	33	#define TRACE(...) \
	34	{ \
	35	NST::utils::Log::message(__FILE__ ":" STRINGIZE(__LINE__) ": " __VA_ARGS__); \
	36	NST::utils::Log::message("\n"); \
	37	NST::utils::Log::flush(); \
	38	}
38	39	#endif
39	40
40		#define LOG(...) {\
41		NST::utils::Log::message(__VA_ARGS__);\
42		NST::utils::Log::message("\n");\
43		}
	41	#define LOG(...) \
	42	{ \
	43	NST::utils::Log::message(__VA_ARGS__); \
	44	NST::utils::Log::message("\n"); \
	45	}
44	46
45		#define LOGONCE(...) {\
46		static bool notyet = true; \
47		if(notyet) { LOG(__VA_ARGS__); notyet = false; }\
48		}
	47	#define LOGONCE(...) \
	48	{ \
	49	static bool notyet = true; \
	50	if(notyet) { \
	51	LOG(__VA_ARGS__); \
	52	notyet = false; \
	53	} \
	54	}
49	55	//------------------------------------------------------------------------------
50	56	namespace NST
51	57	{
52	58	namespace utils
53	59	{
54
55	60	class Log : private std::stringbuf, public std::ostream
56	61	{
57	62	public:

61	66	{
62	67	explicit Global(const std::string& file_path);
63	68	~Global();
64		Global(const Global&) = delete;
	69	Global(const Global&) = delete;
65	70	Global& operator=(const Global&) = delete;
66		void reopen();
	71	void reopen();
	72
67	73	private:
68	74	std::string log_file_path;
69	75	};
70	76
71	77	Log();
72	78	~Log();
73		Log(const Log&) = delete;
	79	Log(const Log&) = delete;
74	80	Log& operator=(const Log&) = delete;
75	81
76	82	// lightweight logging
77	83	static void message(const char* format, ...);
78	84	static void flush();
	85
79	86	private:
80	87	char buffer[256];
81	88	};

83	90	} // namespace utils
84	91	} // namespace NST
85	92	//------------------------------------------------------------------------------
86		#endif//LOG_H
	93	#endif // LOG_H
87	94	//------------------------------------------------------------------------------

-2

src/utils/out.cpp less more

24	24	{
25	25	namespace utils
26	26	{
27
28	27	static Out::Level global = Out::Level::Info;
29	28
30	29	Out::Global::Global(const Level verbose_level)

46	45	}
47	46
48	47	Out::Out(Level level)
49		: std::ostream{ (global >= level) ? std::cout.rdbuf() : nullptr }
	48	: std::ostream{(global >= level) ? std::cout.rdbuf() : nullptr}
50	49	{
51	50	}
52	51	Out::~Out()

-8

src/utils/out.h less more

27	27	{
28	28	namespace utils
29	29	{
30
31	30	class Out : public std::ostream
32	31	{
33	32	public:

43	42	{
44	43	explicit Global(const Level verbose_level);
45	44	~Global();
46		Global(const Global&) = delete;
	45	Global(const Global&) = delete;
47	46	Global& operator=(const Global&) = delete;
48	47
49		static Level get_level(); // return global level of verbosity
50		static void set_level(Level); // set global level of verbosity
	48	static Level get_level(); // return global level of verbosity
	49	static void set_level(Level); // set global level of verbosity
51	50	};
52	51
53		explicit Out(Level level=Level::Info); // verbose level of message
	52	explicit Out(Level level = Level::Info); // verbose level of message
54	53	~Out();
55		Out(const Out&) = delete;
	54	Out(const Out&) = delete;
56	55	Out& operator=(const Out&) = delete;
57	56	};
58	57
59		inline bool operator >=(const Out::Level a, const Out::Level b)
	58	inline bool operator>=(const Out::Level a, const Out::Level b)
60	59	{
61	60	return (int)a >= (int)b;
62	61	}

64	63	} // namespace utils
65	64	} // namespace NST
66	65	//------------------------------------------------------------------------------
67		#endif//OUT_H
	66	#endif // OUT_H
68	67	//------------------------------------------------------------------------------

-9

src/utils/profiler.h less more

44	44	* PROF;
45	45	* ...
46	46	*/
47		template<int id>
	47	template <int id>
48	48	class Profiler
49	49	{
50		const char* name = "";//!< Name of function
51		const static size_t reservedBytes = 50 * 1000;//!< Reserved - calls count
52		struct timespec startTime;//!< Timestamp of start function
	50	const char* name = ""; //!< Name of function
	51	const static size_t reservedBytes = 50 * 1000; //!< Reserved - calls count
	52	struct timespec startTime; //!< Timestamp of start function
53	53
54	54	class Local
55	55	{
56	56	const char* name = "";
	57
57	58	public:
58	59	std::vector<std::uint64_t> values;
59	60	Local(const char* name)

68	69	std::cout << name << "(" << id << "): calls count=" << values.size() << ", avg time=" << sum / values.size() << " nanosecs" << std::endl;
69	70	}
70	71	};
	72
71	73	public:
72
73	74	/*! Constructor
74	75	* \param name - name of function, which you are going to profile
75	76	*/

84	85	struct timespec stopTime;
85	86	clock_gettime(CLOCK_REALTIME, &stopTime);
86	87
87		static Local local(name);// Time of vector initialization is not included into statistics
	88	static Local local(name); // Time of vector initialization is not included into statistics
88	89
89		local.values.push_back(stopTime.tv_nsec - startTime.tv_nsec);// Assume, that time < 1 second!
	90	local.values.push_back(stopTime.tv_nsec - startTime.tv_nsec); // Assume, that time < 1 second!
90	91	}
91
92	92	};
93	93	//------------------------------------------------------------------------------
94		#endif//PROFILER_H
	94	#endif // PROFILER_H
95	95	//------------------------------------------------------------------------------

+54

-53

src/utils/queue.h less more

21	21	#ifndef QUEUE_H
22	22	#define QUEUE_H
23	23	//------------------------------------------------------------------------------
	24	#include <cstddef>
24	25	#include <memory>
25	26	#include <type_traits>
26	27

31	32	{
32	33	namespace utils
33	34	{
34
35	35	template <typename T>
36	36	class Queue
37	37	{
38	38	struct Element // an element of the queue
39	39	{
40	40	Element* prev;
41		T data;
	41	T data;
42	42	};
43	43
44	44	struct ElementDeleter
45	45	{
46		inline explicit ElementDeleter() noexcept : queue{nullptr} {}
47		inline explicit ElementDeleter(Queue* q) noexcept : queue{q} {}
48
49		inline void operator()(T* const pointer) const
	46	explicit ElementDeleter(Queue* q = nullptr) noexcept
	47	: queue{q}
	48	{
	49	}
	50	void operator()(T* const pointer) const
50	51	{
51	52	if(pointer /&& queue - dont check - optimization/)
52	53	{

58	59	};
59	60
60	61	public:
61
62	62	using Ptr = std::unique_ptr<T, ElementDeleter>;
63	63
64		class List // List of elements for client code
	64	class List // List of elements for client code
65	65	{
66	66	public:
67		inline explicit List(Queue& q) : queue{&q}
	67	inline explicit List(Queue& q)
	68	: queue{&q}
68	69	{
69	70	ptr = queue->pop_list();
70	71	}
71		List(const List&) = delete;
	72	List(const List&) = delete;
72	73	List& operator=(const List&) = delete;
73		inline ~List()
	74	~List()
74	75	{
75	76	while(ptr)
76	77	{

78	79	}
79	80	}
80	81
81		inline operator bool() const { return ptr; } // is empty?
82		inline const T& data() const { return ptr->data; } // get data
83		inline Ptr get_current() // return element and switch to next
	82	operator bool() const { return ptr; } // is empty?
	83	const T& data() const { return ptr->data; } // get data
	84	Ptr get_current() // return element and switch to next
84	85	{
85		Element* tmp {ptr};
	86	Element* tmp{ptr};
86	87	ptr = ptr->prev;
87	88	return Ptr{&tmp->data, ElementDeleter{queue}};
88	89	}
89		inline void free_current() // deallocate element and switch to next
	90	void free_current() // deallocate element and switch to next
90	91	{
91		Element* tmp {ptr->prev};
	92	Element* tmp{ptr->prev};
92	93	queue->deallocate(ptr);
93	94	ptr = tmp;
94	95	}
	96
95	97	private:
96	98	Element* ptr;
97		Queue* queue;
	99	Queue* queue;
98	100	};
99	101
100
101		Queue(uint32_t size, uint32_t limit) : last{nullptr}, first{nullptr}
	102	Queue(uint32_t size, uint32_t limit)
	103	: last{nullptr}
	104	, first{nullptr}
102	105	{
103	106	allocator.init_allocation(sizeof(Element), size, limit);
104	107	}
105	108	~Queue()
106	109	{
107		List list{*this}; // deallocate items by destructor of List
	110	List list{*this}; // deallocate items by destructor of List
108	111	}
109	112
110		inline T* allocate()
	113	T* allocate()
111	114	{
112	115	static_assert(std::is_nothrow_constructible<T>::value,
113	116	"The construction of T must not to throw any exception");
114	117
115	118	Spinlock::Lock lock{a_spinlock};
116		Element* e {(Element*)allocator.allocate()}; // may throw std::bad_alloc
117		auto ptr = &(e->data);
118		::new(ptr)T; // only call constructor of T (placement)
119		return ptr;
	119	Element* e{(Element*)allocator.allocate()}; // may throw std::bad_alloc
	120	return ::new(&(e->data)) T; // placement construction T
120	121	}
121	122
122		inline void deallocate(T* ptr)
	123	void deallocate(T* ptr)
123	124	{
124		ptr->~T(); // placement allocation functions syntax is used
125		Element* e { (Element)( ((char)ptr) - sizeof(Element*) ) };
	125	ptr->~T(); // placement construction was used
	126	Element* e{(Element)(((char)ptr) - offsetof(Element, data))};
126	127	deallocate(e);
127	128	}
128	129
129		inline void push(T* ptr)
	130	void push(T* ptr)
130	131	{
131		Element* e { (Element)( ((char)ptr) - sizeof(Element*) ) };
	132	Element* e{(Element)(((char)ptr) - offsetof(Element, data))};
132	133	Spinlock::Lock lock{q_spinlock};
133		if(last)
134		{
135		last->prev = e;
136		last = e;
137		}
138		else // queue is empty
139		{
140		last = first = e;
141		}
	134	if(last)
	135	{
	136	last->prev = e;
	137	last = e;
	138	}
	139	else // queue is empty
	140	{
	141	last = first = e;
	142	}
142	143	}
143	144
144		inline Element* pop_list() // take out list of all queued elements
	145	Element* pop_list() // take out list of all queued elements
145	146	{
146		Element* list {nullptr};
	147	Element* list{nullptr};
147	148	if(last)
148	149	{
149	150	Spinlock::Lock lock{q_spinlock};
150		if(last)
151		{
152		list = first;
153		last->prev = nullptr; // set end of list
154		last = first = nullptr;
155		}
	151	if(last)
	152	{
	153	list = first;
	154	last->prev = nullptr; // set end of list
	155	last = first = nullptr;
	156	}
156	157	}
157	158	return list;
158	159	}
159	160
160	161	private:
161	162	// accessible from Queue::List and Queue::Ptr
162		inline void deallocate(Element* e)
	163	void deallocate(Element* e)
163	164	{
164	165	Spinlock::Lock lock{a_spinlock};
165		allocator.deallocate(e);
	166	allocator.deallocate(e);
166	167	}
167	168
168	169	BlockAllocator allocator;
169		Spinlock a_spinlock; // for allocate/deallocate
170		Spinlock q_spinlock; // for queue push/pop
	170	Spinlock a_spinlock; // for allocate/deallocate
	171	Spinlock q_spinlock; // for queue push/pop
171	172
172	173	// queue empty: last->nullptr<-first
173	174	// queue filled: last->e<-e<-e<-e<-first

179	180	} // namespace utils
180	181	} // namespace NST
181	182	//------------------------------------------------------------------------------
182		#endif//QUEUE_H
	183	#endif // QUEUE_H
183	184	//------------------------------------------------------------------------------

+104

-104

src/utils/sessions.cpp less more

20	20	//------------------------------------------------------------------------------
21	21	#include <sstream>
22	22
23		#include <arpa/inet.h> // for inet_ntop(), ntohs()
	23	#include <arpa/inet.h> // for inet_ntop(), ntohs()
	24	#include <netdb.h>
24	25	#include <sys/socket.h> // for AF_INET/AF_INET6
25		#include <netdb.h>
26
	26
	27	#include "api/plugin_api.h" // for NST_PUBLIC
27	28	#include "utils/out.h"
28	29	#include "utils/sessions.h"
29	30	//------------------------------------------------------------------------------

31	32	{
32	33	namespace utils
33	34	{
34
35	35	std::ostream& operator<<(std::ostream& out, const ApplicationSession& session);
36	36
37	37	ApplicationSession::ApplicationSession(const NetworkSession& s, Direction from_client)
38		: utils::Session (s)
	38	: utils::Session(s)
39	39	{
40	40	if(s.direction != from_client)
41	41	{

43	43	std::swap(port[0], port[1]);
44	44	switch(ip_type)
45	45	{
46		case Session::IPType::v4:
47		std::swap(ip.v4.addr[0], ip.v4.addr[1]);
	46	case Session::IPType::v4:
	47	std::swap(ip.v4.addr[0], ip.v4.addr[1]);
48	48	break;
49		case Session::IPType::v6:
50		std::swap(ip.v6.addr[0], ip.v6.addr[1]);
	49	case Session::IPType::v6:
	50	std::swap(ip.v6.addr[0], ip.v6.addr[1]);
51	51	break;
52	52	}
53	53	}

63	63
64	64	namespace
65	65	{
66
67	66	std::ostream& operator<<(std::ostream& out, const Session::Type type)
68	67	{
69	68	switch(type)
70	69	{
71		case Session::Type::TCP: return out << " [TCP]";
72		case Session::Type::UDP: return out << " [UDP]";
	70	case Session::Type::TCP:
	71	return out << " [TCP]";
	72	case Session::Type::UDP:
	73	return out << " [UDP]";
73	74	}
74	75	return out;
75	76	}

79	80	static_assert(sizeof(ipv4) == sizeof(struct in_addr), "they must be equal");
80	81	char buf[INET_ADDRSTRLEN];
81	82
82		const char* str {inet_ntop(AF_INET, &ipv4, buf, sizeof(buf))};
	83	const char* str{inet_ntop(AF_INET, &ipv4, buf, sizeof(buf))};
83	84	out << (str ? str : "Invalid IPv4 address")
84	85	<< ':' << ntohs(port);
85	86	}
86	87
87	88	void print_ipv6_port(std::ostream& out, const uint8_t (&ipv6)[16], in_port_t port)
88	89	{
89		static_assert(sizeof(ipv6) == sizeof(struct in6_addr),"they must be equal");
	90	static_assert(sizeof(ipv6) == sizeof(struct in6_addr), "they must be equal");
90	91	char buf[INET6_ADDRSTRLEN];
91	92
92		const char* str {inet_ntop(AF_INET6, ipv6, buf, sizeof(buf))};
	93	const char* str{inet_ntop(AF_INET6, ipv6, buf, sizeof(buf))};
93	94	out << (str ? str : "Invalid IPv6 address")
94	95	<< ':' << ntohs(port);
95	96	}
96	97
97	98	// TODO: getnameinfo call may be expensive
98		template<typename SockAddr>
	99	template <typename SockAddr>
99	100	void print_sockaddr(std::ostream& out, SockAddr& addr)
100	101	{
101		char hostname[1025];
102		char service [65];
103		const int err {getnameinfo((sockaddr*)&addr, sizeof(addr),
104		hostname, sizeof(hostname),
105		service, sizeof(service),
106		NI_NAMEREQD ) };
	102	char hostname[1025];
	103	char service[65];
	104	const int err{getnameinfo((sockaddr*)&addr, sizeof(addr),
	105	hostname, sizeof(hostname),
	106	service, sizeof(service),
	107	NI_NAMEREQD)};
107	108	if(err == 0)
108	109	{
109	110	out << '(' << hostname << ':' << service << ')';

111	112	}
112	113
113	114	void print_ipv4_port_as_hostname_service(std::ostream& out,
114		in_addr_t ipv4,
115		in_port_t port)
	115	in_addr_t ipv4,
	116	in_port_t port)
116	117	{
117	118	sockaddr_in addr;
118		addr.sin_family = AF_INET;
119		addr.sin_port = port;
120		addr.sin_addr.s_addr= ipv4;
	119	addr.sin_family = AF_INET;
	120	addr.sin_port = port;
	121	addr.sin_addr.s_addr = ipv4;
121	122
122	123	print_sockaddr(out, addr);
123	124	}
124	125
125	126	void print_ipv6_port_as_hostname_service(std::ostream& out,
126	127	const uint8_t (&ipv6)[16],
127		in_port_t port)
	128	in_port_t port)
128	129	{
129	130	sockaddr_in6 addr;
130		addr.sin6_family = AF_INET6;
131		addr.sin6_port = port;
132		addr.sin6_flowinfo = 0;
133		addr.sin6_addr = (in6_addr&)ipv6;
134		addr.sin6_scope_id = 0;
	131	addr.sin6_family = AF_INET6;
	132	addr.sin6_port = port;
	133	addr.sin6_flowinfo = 0;
	134	addr.sin6_addr = (in6_addr&)ipv6;
	135	addr.sin6_scope_id = 0;
135	136
136	137	print_sockaddr(out, addr);
137	138	}

144	145	return out;
145	146	}
146	147
147		void print_session(std::ostream& out, const Session& session)
	148	extern "C" NST_PUBLIC void print_session(std::ostream& out, const Session& session)
148	149	{
149	150	switch(session.ip_type)
150	151	{
151		case Session::IPType::v4:
152		{
153		print_ipv4_port(out, session.ip.v4.addr[Session::Source],
154		session.port [Session::Source]);
155		out << " --> ";
156		print_ipv4_port(out, session.ip.v4.addr[Session::Destination],
157		session.port [Session::Destination]);
158		}
159		break;
160		case Session::IPType::v6:
161		{
162		print_ipv6_port(out, session.ip.v6.addr[Session::Source],
163		session.port [Session::Source]);
164		out << " --> ";
165		print_ipv6_port(out, session.ip.v6.addr[Session::Destination],
166		session.port [Session::Destination]);
167		}
168		break;
	152	case Session::IPType::v4:
	153	{
	154	print_ipv4_port(out, session.ip.v4.addr[Session::Source],
	155	session.port[Session::Source]);
	156	out << " --> ";
	157	print_ipv4_port(out, session.ip.v4.addr[Session::Destination],
	158	session.port[Session::Destination]);
	159	}
	160	break;
	161	case Session::IPType::v6:
	162	{
	163	print_ipv6_port(out, session.ip.v6.addr[Session::Source],
	164	session.port[Session::Source]);
	165	out << " --> ";
	166	print_ipv6_port(out, session.ip.v6.addr[Session::Destination],
	167	session.port[Session::Destination]);
	168	}
	169	break;
169	170	}
170	171	out << session.type;
171	172	}
172	173
173	174	std::ostream& operator<<(std::ostream& out, const ApplicationSession& session)
174	175	{
175		const bool namelookup {Out::Global::get_level() == Out::Level::All};
	176	const bool namelookup{Out::Global::get_level() == Out::Level::All};
176	177
177	178	switch(session.ip_type)
178	179	{
179		case Session::IPType::v4:
180		{
181		{
182		auto& port = session.port [Session::Source];
183		auto& addr = session.ip.v4.addr[Session::Source];
184
185		print_ipv4_port(out, addr, port);
186		if(namelookup)
187		{
188		print_ipv4_port_as_hostname_service(out, addr, port);
189		}
190		}
191		out << " --> ";
192		{
193		auto& port = session.port [Session::Destination];
194		auto& addr = session.ip.v4.addr[Session::Destination];
195
196		print_ipv4_port(out, addr, port);
197		if(namelookup)
198		{
199		print_ipv4_port_as_hostname_service(out, addr, port);
200		}
201		}
202		}
203		break;
204		case Session::IPType::v6:
205		{
206		{
207		auto& port = session.port [Session::Source];
208		auto& addr = session.ip.v6.addr[Session::Source];
209
210		print_ipv6_port(out, addr, port);
211		if(namelookup)
212		{
213		print_ipv6_port_as_hostname_service(out, addr, port);
214		}
215		}
216		out << " --> ";
217		{
218		auto& port = session.port [Session::Destination];
219		auto& addr = session.ip.v6.addr[Session::Destination];
220
221		print_ipv6_port(out, addr, port);
222		if(namelookup)
223		{
224		print_ipv6_port_as_hostname_service(out, addr, port);
225		}
226		}
227		}
228		break;
	180	case Session::IPType::v4:
	181	{
	182	{
	183	auto& port = session.port[Session::Source];
	184	auto& addr = session.ip.v4.addr[Session::Source];
	185
	186	print_ipv4_port(out, addr, port);
	187	if(namelookup)
	188	{
	189	print_ipv4_port_as_hostname_service(out, addr, port);
	190	}
	191	}
	192	out << " --> ";
	193	{
	194	auto& port = session.port[Session::Destination];
	195	auto& addr = session.ip.v4.addr[Session::Destination];
	196
	197	print_ipv4_port(out, addr, port);
	198	if(namelookup)
	199	{
	200	print_ipv4_port_as_hostname_service(out, addr, port);
	201	}
	202	}
	203	}
	204	break;
	205	case Session::IPType::v6:
	206	{
	207	{
	208	auto& port = session.port[Session::Source];
	209	auto& addr = session.ip.v6.addr[Session::Source];
	210
	211	print_ipv6_port(out, addr, port);
	212	if(namelookup)
	213	{
	214	print_ipv6_port_as_hostname_service(out, addr, port);
	215	}
	216	}
	217	out << " --> ";
	218	{
	219	auto& port = session.port[Session::Destination];
	220	auto& addr = session.ip.v6.addr[Session::Destination];
	221
	222	print_ipv6_port(out, addr, port);
	223	if(namelookup)
	224	{
	225	print_ipv6_port_as_hostname_service(out, addr, port);
	226	}
	227	}
	228	}
	229	break;
229	230	}
230	231	out << session.type;
231	232	return out;

234	235	} // namespace utils
235	236	} // namespace NST
236	237	//------------------------------------------------------------------------------
237

-11

src/utils/sessions.h less more

27	27
28	28	#include "api/session.h"
29	29	//------------------------------------------------------------------------------
30		#define NST_PUBLIC __attribute__ ((visibility("default")))
31	30	//------------------------------------------------------------------------------
32	31	namespace NST
33	32	{
34	33	namespace utils
35	34	{
36
37	35	using Session = NST::API::Session;
38	36
39	37	// Network layer session

41	39	{
42	40	public:
43	41	NetworkSession()
44		: application {nullptr}
45		, direction {Direction::Unknown}
	42	: application{nullptr}
	43	, direction{Direction::Unknown}
46	44	{
47	45	}
48	46
49		void* application; // pointer to application protocol implementation
	47	void* application; // pointer to application protocol implementation
50	48	Direction direction;
51	49	};
52
53	50
54	51	// Application layer session
55	52	struct ApplicationSession : public Session

62	59	std::string session_str;
63	60	};
64	61
65		extern "C"
66		NST_PUBLIC
67		void print_session(std::ostream& out, const Session& session);
68
69	62	std::ostream& operator<<(std::ostream& out, const Session& session);
70	63
71	64	} // namespace utils
72	65	} // namespace NST
73	66	//------------------------------------------------------------------------------
74		#endif//SESSIONS_H
	67	#endif // SESSIONS_H
75	68	//------------------------------------------------------------------------------

-4

src/utils/spinlock.h less more

21	21	#ifndef SPINLOCK_H
22	22	#define SPINLOCK_H
23	23	//------------------------------------------------------------------------------
24		#include <mutex> // for std::lock_guard
	24	#include <mutex> // for std::lock_guard
25	25
26	26	#include <pthread.h>
27	27	//------------------------------------------------------------------------------

29	29	{
30	30	namespace utils
31	31	{
32
33	32	class Spinlock
34	33	{
35	34	public:

37	36	{
38	37	pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);
39	38	}
40		Spinlock(const Spinlock&) = delete;
	39	Spinlock(const Spinlock&) = delete;
41	40	Spinlock& operator=(const Spinlock&) = delete;
42	41	~Spinlock() noexcept
43	42	{

68	67	} // namespace utils
69	68	} // namespace NST
70	69	//------------------------------------------------------------------------------
71		#endif//SPINLOCK_H
	70	#endif // SPINLOCK_H
72	71	//------------------------------------------------------------------------------

-7

tests/unit/CMakeLists.txt less more

0		if ("${GMOCK_SOURCE_DIR}" STREQUAL "")
1		message (WARNING "GMOCK_SOURCE_DIR variable not set - unit-tests are not available. Use '-DGMOCK_SOURCE_DIR=<path_to_gmock_sources>' param for CMake")
	0	if ("${GTEST_SOURCE_DIR}" STREQUAL "")
	1	message (WARNING "GTEST_SOURCE_DIR variable not set - unit-tests are not available. Use
	2	'-DGTEST_SOURCE_DIR=<path_to_nfstrace>/third_party/googletest' param for CMake")
2	3	else ()
3	4	# Clang and GCC 4.9+ cause errors on GMock/GTest compilation, so we are adding following flags to suppress them
4	5	set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-field-initializers")

8	9	set (gmock_force_shared_crt true CACHE INTERNAL "")
9	10	set (BUILD_SHARED_LIBS false CACHE INTERNAL "")
10	11	add_definitions (-DGTEST_HAS_PTHREAD=1) # It fixes BUG in GTests in BSD
11		add_subdirectory (${GMOCK_SOURCE_DIR} ${CMAKE_BINARY_DIR}/gmock)
	12	add_subdirectory (${GTEST_SOURCE_DIR}/googlemock ${CMAKE_BINARY_DIR}/gmock)
12	13	set (GMOCK_LIBRARIES gmock gmock_main)
13		set (GMOCK_INCLUDE_DIRS "${GMOCK_SOURCE_DIR}/include"
14		"${GMOCK_SOURCE_DIR}/gtest/include"
15		"${GMOCK_SOURCE_DIR}")
	14	set (GTEST_INCLUDE_DIRS
	15	"${GTEST_SOURCE_DIR}/googletest/include"
	16	"${GTEST_SOURCE_DIR}/googlemock/include")
16	17
17		include_directories (${CMAKE_SOURCE_DIR}/src ${GMOCK_INCLUDE_DIRS})
	18	include_directories (${CMAKE_SOURCE_DIR}/src ${GTEST_INCLUDE_DIRS})
18	19
19	20	add_subdirectory (utils)
20	21	add_subdirectory (analyzers)

-6

tests/unit/analyzers/breakdown/breakdown.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <cstdlib>
	22	#include <ctime>
22	23	#include <iostream>
23		#include <ctime>
24	24
25	25	#include <gmock/gmock.h>
26	26	#include <gtest/gtest.h>

35	35	//------------------------------------------------------------------------------
36	36	namespace
37	37	{
38
39	38	class BreakdownTest : public ::testing::Test
40	39	{
41	40	protected:
42		size_t count;
	41	size_t count;
43	42	timeval t;
	43
44	44	public:
45	45	void SetUp()
46	46	{

52	52	{
53	53	}
54	54	};
55
56	55	}
57	56	//------------------------------------------------------------------------------
58	57	TEST_F(BreakdownTest, count)
59	58	{
60
61	59	BreakdownCounter break_down(count);
62	60
63	61	EXPECT_EQ(0U, break_down.get_total_count());

67	65	break_down[0].add(t);
68	66
69	67	EXPECT_EQ(3U, break_down.get_total_count());
70
71	68	}
72	69	//------------------------------------------------------------------------------

-9

tests/unit/analyzers/breakdown/latency.cpp less more

35	35	//------------------------------------------------------------------------------
36	36	namespace
37	37	{
38
39	38	class LatencyTest : public ::testing::Test
40	39	{
41	40	protected:
42		size_t count;
	41	size_t count;
43	42	timeval t1;
44	43	timeval t2;
	44
45	45	public:
46	46	void SetUp()
47	47	{

59	59	{
60	60	}
61	61	};
62
63	62	}
64	63	//------------------------------------------------------------------------------
65	64	TEST_F(LatencyTest, max_min)
66	65	{
67
68	66	Latencies latency;
69	67
70	68	EXPECT_EQ(0U, latency.get_count());

79	77
80	78	EXPECT_EQ(t1.tv_sec, latency.get_max().tv_sec);
81	79	EXPECT_EQ(t1.tv_usec, latency.get_max().tv_usec);
82
83	80	}
84	81
85	82	TEST_F(LatencyTest, avg)

113	110	*/
114	111
115	112	struct timeval input;
116		input.tv_sec = 0;
	113	input.tv_sec = 0;
117	114	input.tv_usec = 500;
118	115
119	116	const auto sec = to_sec(input);

122	119
123	120	std::stringstream ss;
124	121
125		ss.precision(6); ss << std::fixed << sec << ' ';
126		ss.precision(4); ss << std::fixed << sec << ' ';
127		ss.precision(3); ss << std::fixed << sec;
	122	ss.precision(6);
	123	ss << std::fixed << sec << ' ';
	124	ss.precision(4);
	125	ss << std::fixed << sec << ' ';
	126	ss.precision(3);
	127	ss << std::fixed << sec;
128	128
129	129	EXPECT_EQ("0.000500 0.0005 0.001", ss.str());
130	130	}

+16

-24

tests/unit/analyzers/breakdown/statistic.cpp less more

19	19	*/
20	20	//------------------------------------------------------------------------------
21	21	#include <cstdlib>
	22	#include <ctime>
22	23	#include <iostream>
23		#include <ctime>
24	24
25	25	#include <gmock/gmock.h>
26	26	#include <gtest/gtest.h>

35	35	//------------------------------------------------------------------------------
36	36	namespace
37	37	{
38
39	38	class StatisticTest : public ::testing::Test
40	39	{
41	40	protected:
42	41	size_t count;
	42
43	43	public:
44	44	void SetUp()
45	45	{

68	68	{
69	69	}
70	70
71		Session _session;
72		timeval _rtimestamp;
73		timeval _ctimestamp;
	71	Session _session;
	72	timeval _rtimestamp;
	73	timeval _ctimestamp;
74	74	const Session* session;
75	75	const timeval* rtimestamp;
76	76	const timeval* ctimestamp;
77	77	};
78
79	78	}
80	79	//------------------------------------------------------------------------------
81	80	TEST_F(StatisticTest, statistics)
82	81	{
83
84	82	Statistics stats(count);
85	83
86	84	EXPECT_EQ(count, stats.proc_types_count);
87	85
88	86	Mock each_procedure_mock;
89	87	EXPECT_CALL(each_procedure_mock, mock_function())
90		.Times(count);
	88	.Times(count);
91	89
92		stats.for_each_procedure([&](const BreakdownCounter&, size_t)
93		{
	90	stats.for_each_procedure([&](const BreakdownCounter&, size_t) {
94	91	each_procedure_mock.mock_function();
95	92	});
96	93	}
97	94
98	95	TEST_F(StatisticTest, sessions_statistics)
99	96	{
100
101	97	Statistics stats(count);
102		Mock each_procedure_mock;
103		Proc proc;
	98	Mock each_procedure_mock;
	99	Proc proc;
104	100
105	101	EXPECT_CALL(each_procedure_mock, mock_function())
106		.Times(1);
	102	.Times(1);
107	103
108	104	EXPECT_FALSE(stats.has_session());
109	105	stats.account(&proc, 0);
110	106	EXPECT_TRUE(stats.has_session());
111	107
112		stats.for_each_session([&](const Session&)
113		{
	108	stats.for_each_session([&](const Session&) {
114	109	each_procedure_mock.mock_function();
115	110	});
116	111	}
117	112
118	113	TEST_F(StatisticTest, statistics_per_session)
119	114	{
120
121	115	Statistics stats(count);
122		Mock each_procedure_mock;
123		Proc proc;
	116	Mock each_procedure_mock;
	117	Proc proc;
124	118
125	119	EXPECT_CALL(each_procedure_mock, mock_function())
126		.Times(count);
	120	.Times(count);
127	121
128		stats.for_each_procedure_in_session(proc._session, [&](const BreakdownCounter&, size_t)
129		{
	122	stats.for_each_procedure_in_session(proc._session, [&](const BreakdownCounter&, size_t) {
130	123	each_procedure_mock.mock_function();
131	124	});
132	125
133	126	stats.account(&proc, 1);
134	127
135		stats.for_each_procedure_in_session(proc._session, [&](const BreakdownCounter&, size_t)
136		{
	128	stats.for_each_procedure_in_session(proc._session, [&](const BreakdownCounter&, size_t) {
137	129	each_procedure_mock.mock_function();
138	130	});
139	131	}

+44

-30

tests/unit/analyzers/cifs.cpp less more

25	25
26	26	#include "analysis/analyzers.h"
27	27	#include "analysis/cifs_parser.h"
	28	#include "api/cifs2_commands.h"
	29	#include "api/cifs_pc_to_net.h"
28	30	#include "api/cifs_types.h"
29		#include "api/cifs_pc_to_net.h"
30		#include "api/cifs2_commands.h"
31	31	//------------------------------------------------------------------------------
32	32	using namespace NST::filtration;
33	33	using namespace NST::analysis;

41	41
42	42	namespace
43	43	{
44
45	44	class PluginMock : public IAnalyzer
46	45	{
47	46	public:
48	47	// ISMBv2 interface
49		MOCK_METHOD3(readSMBv2, void(const SMBv2::ReadCommand , const NST::API::SMBv2::ReadRequest , const NST::API::SMBv2::ReadResponse *));
	48	MOCK_METHOD3(readSMBv2, void(const SMBv2::ReadCommand, const NST::API::SMBv2::ReadRequest, const NST::API::SMBv2::ReadResponse*));
50	49
51	50	// IAnalyzer interface
52	51	void flush_statistics() {}
53	52	};
54	53
55
56		PluginMock* pluginMock;// pointer to mock
	54	PluginMock* pluginMock; // pointer to mock
57	55	}
58	56	//------------------------------------------------------------------------------
59	57	Analyzers::Analyzers(const controller::Parameters& /params/)

61	59	this->modules.push_back(pluginMock);
62	60	}
63	61	//------------------------------------------------------------------------------
64		Parameters::Parameters(int /argc/, char** /argv/) {}
65
66		Parameters::~Parameters() {}
	62	Parameters::Parameters(int /argc/, char** /argv/)
	63	{
	64	}
	65
	66	Parameters::~Parameters()
	67	{
	68	}
67	69
68	70	bool Parameters::show_help() const
69	71	{

141	143	return "";
142	144	}
143	145
144		DynamicLoad::DynamicLoad(const std::string &/file/) {}
145
146		DynamicLoad::~DynamicLoad() {}
147
148		template<typename plugin_get_entry_points_func>
	146	DynamicLoad::DynamicLoad(const std::string& /file/)
	147	{
	148	}
	149
	150	DynamicLoad::~DynamicLoad()
	151	{
	152	}
	153
	154	template <typename plugin_get_entry_points_func>
149	155	void load_address_of(const std::string& /name/, plugin_get_entry_points_func& /address/)
150		{}
151
152		Plugin::Plugin(const std::string& path) : DynamicLoad(path) {}
153
154		PluginInstance::PluginInstance(const std::string& path, const std::string& /args/) : Plugin(path) {}
155
156		PluginInstance::~PluginInstance() {}
	156	{
	157	}
	158
	159	Plugin::Plugin(const std::string& path)
	160	: DynamicLoad(path)
	161	{
	162	}
	163
	164	PluginInstance::PluginInstance(const std::string& path, const std::string& /args/)
	165	: Plugin(path)
	166	{
	167	}
	168
	169	PluginInstance::~PluginInstance()
	170	{
	171	}
157	172
158	173	//------------------------------------------------------------------------------
159	174	TEST(Parser, CIFSAsyncParser)

161	176	pluginMock = new PluginMock;
162	177
163	178	NST::controller::Parameters params(0, nullptr);
164		Analyzers analyzers(params);
	179	Analyzers analyzers(params);
165	180
166	181	NST::utils::FilteredDataQueue queue(1, 1);
167		NST::utils::FilteredData* data = queue.allocate();
168		NetworkSession s;
	182	NST::utils::FilteredData* data = queue.allocate();
	183	NetworkSession s;
169	184	data->session = &s;
170	185	queue.push(data);
171	186	NST::utils::FilteredDataQueue::List list(queue);
172		NST::utils::FilteredDataQueue::Ptr el = list.get_current();
	187	NST::utils::FilteredDataQueue::Ptr el = list.get_current();
173	188
174	189	CIFSv2::MessageHeader header;
175		header.head_code = NST::API::SMBv2::pc_to_net<uint32_t>(0x424d53fe);// Protocol's marker
176		header.cmd_code = NST::API::SMBv2::SMBv2Commands::READ;
177		header.flags = static_cast<uint32_t>(CIFSv2::Flags::ASYNC_COMMAND);
	190	header.head_code = NST::API::SMBv2::pc_to_net<uint32_t>(0x424d53fe); // Protocol's marker
	191	header.cmd_code = NST::API::SMBv2::SMBv2Commands::READ;
	192	header.flags = static_cast<uint32_t>(CIFSv2::Flags::ASYNC_COMMAND);
178	193
179	194	el->data = reinterpret_cast<uint8_t*>(&header);
180	195	el->dlen = sizeof(header);

183	198
184	199	// Set conditions
185	200	EXPECT_CALL(*pluginMock, readSMBv2(_, _, _))
186		.Times(1);
	201	.Times(1);
187	202
188	203	// Do
189	204	parser.parse_data(el);

191	206	delete pluginMock;
192	207	}
193	208	//------------------------------------------------------------------------------
194

+29

-34

tests/unit/filtration/cifsv2.cpp less more

22	22	#include <gtest/gtest.h>
23	23
24	24	#include "controller/running_status.h"
	25	#include "filtration/cifs_filtrator.h"
25	26	#include "filtration/filtration_processor.h"
26		#include "filtration/cifs_filtrator.h"
27	27	#include "filtration/filtrators.h"
28	28	#include "filtration/packet.h"
29	29	//------------------------------------------------------------------------------

35	35
36	36	namespace
37	37	{
38
39	38	class Writer
40	39	{
41	40	public:
42
43	41	class Collection
44	42	{
45	43	Collection* pImpl = nullptr;
	44
46	45	public:
47	46	void set(Writer& w, NST::utils::NetworkSession* /session_ptr/)
48	47	{

51	50
52	51	virtual void reset()
53	52	{
54		if (pImpl)
	53	if(pImpl)
55	54	{
56	55	pImpl->reset();
57	56	}

59	58
60	59	virtual void push(PacketInfo& info, size_t size)
61	60	{
62		if (pImpl)
	61	if(pImpl)
63	62	{
64	63	pImpl->push(info, size);
65	64	}

67	66
68	67	virtual void skip_first(size_t size)
69	68	{
70		if (pImpl)
	69	if(pImpl)
71	70	{
72	71	pImpl->skip_first(size);
73	72	}

75	74
76	75	virtual void complete(PacketInfo& info)
77	76	{
78		if (pImpl)
	77	if(pImpl)
79	78	{
80	79	pImpl->complete(info);
81	80	}

88	87
89	88	virtual const uint8_t* data()
90	89	{
91		if (pImpl)
	90	if(pImpl)
92	91	{
93	92	return pImpl->data();
94	93	}

97	96
98	97	virtual size_t data_size()
99	98	{
100		if (pImpl)
	99	if(pImpl)
101	100	{
102	101	return pImpl->data_size();
103	102	}

106	105
107	106	virtual size_t capacity()
108	107	{
109		if (pImpl)
	108	if(pImpl)
110	109	{
111	110	return pImpl->capacity();
112	111	}

115	114
116	115	virtual void allocate()
117	116	{
118		if (pImpl)
	117	if(pImpl)
119	118	{
120	119	pImpl->allocate();
121	120	}

126	125	public:
127	126	MOCK_METHOD0(reset, void());
128	127	MOCK_METHOD2(push, void(PacketInfo&, size_t));
129		MOCK_METHOD0(data, const uint8_t* ());
	128	MOCK_METHOD0(data, const uint8_t*());
130	129	MOCK_METHOD0(data_size, size_t());
131	130	MOCK_METHOD0(capacity, size_t());
132	131	MOCK_METHOD0(allocate, void());
133	132	MOCK_METHOD1(skip_first, void(size_t));
134	133	MOCK_METHOD1(complete, void(PacketInfo&));
135
136	134	};
137	135
138	136	CollectionMock collection;
139	137	};
140
141	138	}
142	139
143	140	TEST(Filtration, CIFSFiltratorReset)

145	142	// Set conditions
146	143	Writer mock;
147	144	EXPECT_CALL(mock.collection, reset())
148		.Times(1);
	145	.Times(1);
149	146
150	147	CIFSFiltrator<Writer> f;
151	148	f.set_writer(nullptr, &mock, 0);

158	155	// Set conditions
159	156	Writer mock;
160	157	EXPECT_CALL(mock.collection, reset())
161		.Times(2);
	158	.Times(2);
162	159
163	160	Filtrators<Writer> f;
164	161	f.set_writer(nullptr, &mock, 0);

171	168	// Prepare data
172	169	struct pcap_pkthdr header;
173	170	header.caplen = header.len = 16;
174		const uint8_t packet[] = {0x80, 0x00, 0x00, 0x84,
	171	const uint8_t packet[] = {0x80, 0x00, 0x00, 0x84,
175	172	0xec, 0x8a, 0x42, 0xcb,
176	173	0x00, 0x00, 0x00, 0x00,
177		0x00, 0x00, 0x00, 0x02
178		};
	174	0x00, 0x00, 0x00, 0x02};
179	175	PacketInfo info(&header, packet, 0);
180	176
181	177	Writer mock;
182	178	EXPECT_CALL(mock.collection, data())
183		.WillRepeatedly(Return(packet));
	179	.WillRepeatedly(Return(packet));
184	180	EXPECT_CALL(mock.collection, data_size())
185		.WillOnce(Return(0))
186		.WillOnce(Return(0))
187		.WillRepeatedly(Return(sizeof(packet)));
	181	.WillOnce(Return(0))
	182	.WillOnce(Return(0))
	183	.WillRepeatedly(Return(sizeof(packet)));
188	184	EXPECT_CALL(mock.collection, capacity())
189		.WillRepeatedly(Return(1000000));
	185	.WillRepeatedly(Return(1000000));
190	186	// Set conditions
191	187	EXPECT_CALL(mock.collection, push(_, _))
192		.Times(AtLeast(1));
	188	.Times(AtLeast(1));
193	189
194	190	Filtrators<Writer> f;
195	191	f.set_writer(nullptr, &mock, 0);

202	198	// Prepare data
203	199	struct pcap_pkthdr header;
204	200	header.caplen = header.len = 16;
205		const uint8_t packet[] = {0x00, 0x00, 0x00, 0x68,
	201	const uint8_t packet[] = {0x00, 0x00, 0x00, 0x68,
206	202	0xfe, 0x53, 0x4d, 0x42,
207	203	0x00, 0x00, 0x00, 0x00,
208		0x00, 0x00, 0x00, 0x00
209		};
	204	0x00, 0x00, 0x00, 0x00};
210	205	PacketInfo info(&header, packet, 0);
211	206
212	207	Writer mock;
213	208	EXPECT_CALL(mock.collection, data())
214		.WillRepeatedly(Return(packet));
	209	.WillRepeatedly(Return(packet));
215	210	EXPECT_CALL(mock.collection, data_size())
216		.WillOnce(Return(0))
217		.WillOnce(Return(0))
218		.WillRepeatedly(Return(sizeof(packet)));
	211	.WillOnce(Return(0))
	212	.WillOnce(Return(0))
	213	.WillRepeatedly(Return(sizeof(packet)));
219	214	EXPECT_CALL(mock.collection, capacity())
220		.WillRepeatedly(Return(1000000));
	215	.WillRepeatedly(Return(1000000));
221	216	// Set conditions
222	217	EXPECT_CALL(mock.collection, push(_, _))
223		.Times(AtLeast(1));
	218	.Times(AtLeast(1));
224	219
225	220	Filtrators<Writer> f;
226	221	f.set_writer(nullptr, &mock, 0);

+96

-103

tests/unit/filtration/stream.cpp less more

24	24	#include <gtest/gtest.h>
25	25
26	26	#include "controller/running_status.h"
	27	#include "filtration/cifs_filtrator.h"
27	28	#include "filtration/filtration_processor.h"
28		#include "filtration/cifs_filtrator.h"
29	29	#include "filtration/filtrators.h"
30	30	#include "filtration/packet.h"
31	31	//------------------------------------------------------------------------------

34	34	using ::testing::AtLeast;
35	35	using ::testing::_;
36	36	//------------------------------------------------------------------------------
37		namespace {
38
	37	namespace
	38	{
39	39	class Writer
40	40	{
41	41	public:
42
43	42	class Collection
44	43	{
45	44	std::vector<uint8_t> packet;
46		Collection *pImpl = nullptr;
	45	Collection* pImpl = nullptr;
	46
47	47	public:
48	48	void set(Writer& w, NST::utils::NetworkSession* /session_ptr/)
49	49	{

66	66
67	67	virtual void complete(PacketInfo& info)
68	68	{
69		if (pImpl)
	69	if(pImpl)
70	70	{
71	71	pImpl->complete(info);
72	72	}

77	77	return true;
78	78	}
79	79
80		virtual const uint8_t * data()
	80	virtual const uint8_t* data()
81	81	{
82	82	return packet.data();
83	83	}

101	101	public:
102	102	MOCK_METHOD0(reset, void());
103	103	MOCK_METHOD2(push, void(PacketInfo&, size_t));
104		MOCK_METHOD0(data, const uint8_t *());
	104	MOCK_METHOD0(data, const uint8_t*());
105	105	MOCK_METHOD0(data_size, size_t());
106	106	MOCK_METHOD1(complete, void(PacketInfo&));
107
108	107	};
109	108
110	109	CollectionMock collection;
111	110	};
112
113	111	}
114	112
115	113	TEST(Filtration, pushCIFSbyTCPStream)

117	115	// Prepare data
118	116	struct pcap_pkthdr header;
119	117	header.caplen = header.len = 132;
120		const uint8_t packet[] = {0x00, 0x00, 0x00, 0x80,
	118	const uint8_t packet[] = {0x00, 0x00, 0x00, 0x80,
121	119	0xfe, 0x53, 0x4d, 0x42,
122	120	0x00, 0x00, 0x00, 0x00,
123	121	0x00, 0x00, 0x00, 0x00,

157	155	0x00, 0x00, 0x00, 0x00,
158	156	0x00, 0x00, 0x00, 0x00,
159	157
160		0x00, 0x00, 0x00, 0x00
161		};
	158	0x00, 0x00, 0x00, 0x00};
162	159	PacketInfo info(&header, packet, 0);
163		Writer mock;
	160	Writer mock;
164	161	// Set conditions
165	162	EXPECT_CALL(mock.collection, complete(_))
166	163	.Times(AtLeast(1));

176	173	// Prepare data
177	174	struct pcap_pkthdr header1;
178	175	header1.caplen = header1.len = 3;
179		const uint8_t packet[] = {0x00, 0x00, 0x00, 0x80,
	176	const uint8_t packet[] = {0x00, 0x00, 0x00, 0x80,
180	177	0xfe, 0x53, 0x4d, 0x42,
181	178	0x00, 0x00, 0x00, 0x00,
182	179	0x00, 0x00, 0x00, 0x00,

216	213	0x00, 0x00, 0x00, 0x00,
217	214	0x00, 0x00, 0x00, 0x00,
218	215
219		0x00, 0x00, 0x00, 0x00
220		};
	216	0x00, 0x00, 0x00, 0x00};
221	217	PacketInfo info1(&header1, packet, 0);
222	218
223	219	struct pcap_pkthdr header2;
224	220	header2.caplen = header2.len = sizeof(packet) - header1.len;
225	221	PacketInfo info2(&header2, packet + header1.len, 0);
226		Writer mock;
	222	Writer mock;
227	223
228	224	// Set conditions
229	225	EXPECT_CALL(mock.collection, complete(_))

241	237	// Prepare data
242	238	struct pcap_pkthdr header;
243	239	header.caplen = header.len = 132;
244		const uint8_t packet[] = {0x80, 0x00, 0x00, 0x80,
	240	const uint8_t packet[] = {0x80, 0x00, 0x00, 0x80,
245	241	0xec, 0x8a, 0x42, 0xcb,
246		0x00, 0x00, 0x00, 0x00,// msg type - call
247		0x00, 0x00, 0x00, 0x02,// RPC version
248
249		0x00, 0x00, 0x00, 0x00,
250		0x00, 0x00, 0x00, 0x00,
251		0x00, 0x00, 0x00, 0x00,
252		0x00, 0x00, 0x00, 0x00,
253
254		0x00, 0x00, 0x00, 0x00,
255		0x00, 0x00, 0x00, 0x00,
256		0x00, 0x00, 0x00, 0x00,
257		0x00, 0x00, 0x00, 0x00,
258
259		0x00, 0x00, 0x00, 0x00,
260		0x00, 0x00, 0x00, 0x00,
261		0x00, 0x00, 0x00, 0x00,
262		0x00, 0x00, 0x00, 0x00,
263
264		0x00, 0x00, 0x00, 0x00,
265		0x00, 0x00, 0x00, 0x00,
266		0x00, 0x00, 0x00, 0x00,
267		0x00, 0x00, 0x00, 0x00,
268
269		0x00, 0x00, 0x00, 0x00,
270		0x00, 0x00, 0x00, 0x00,
271		0x00, 0x00, 0x00, 0x00,
272		0x00, 0x00, 0x00, 0x00,
273
274		0x00, 0x00, 0x00, 0x00,
275		0x00, 0x00, 0x00, 0x00,
276		0x00, 0x00, 0x00, 0x00,
277		0x00, 0x00, 0x00, 0x00,
278
279		0x00, 0x00, 0x00, 0x00,
280		0x00, 0x00, 0x00, 0x00,
281		0x00, 0x00, 0x00, 0x00,
282		0x00, 0x00, 0x00, 0x00,
283
284		0x00, 0x00, 0x00, 0x00
285		};
	242	0x00, 0x00, 0x00, 0x00, // msg type - call
	243	0x00, 0x00, 0x00, 0x02, // RPC version
	244
	245	0x00, 0x00, 0x00, 0x00,
	246	0x00, 0x00, 0x00, 0x00,
	247	0x00, 0x00, 0x00, 0x00,
	248	0x00, 0x00, 0x00, 0x00,
	249
	250	0x00, 0x00, 0x00, 0x00,
	251	0x00, 0x00, 0x00, 0x00,
	252	0x00, 0x00, 0x00, 0x00,
	253	0x00, 0x00, 0x00, 0x00,
	254
	255	0x00, 0x00, 0x00, 0x00,
	256	0x00, 0x00, 0x00, 0x00,
	257	0x00, 0x00, 0x00, 0x00,
	258	0x00, 0x00, 0x00, 0x00,
	259
	260	0x00, 0x00, 0x00, 0x00,
	261	0x00, 0x00, 0x00, 0x00,
	262	0x00, 0x00, 0x00, 0x00,
	263	0x00, 0x00, 0x00, 0x00,
	264
	265	0x00, 0x00, 0x00, 0x00,
	266	0x00, 0x00, 0x00, 0x00,
	267	0x00, 0x00, 0x00, 0x00,
	268	0x00, 0x00, 0x00, 0x00,
	269
	270	0x00, 0x00, 0x00, 0x00,
	271	0x00, 0x00, 0x00, 0x00,
	272	0x00, 0x00, 0x00, 0x00,
	273	0x00, 0x00, 0x00, 0x00,
	274
	275	0x00, 0x00, 0x00, 0x00,
	276	0x00, 0x00, 0x00, 0x00,
	277	0x00, 0x00, 0x00, 0x00,
	278	0x00, 0x00, 0x00, 0x00,
	279
	280	0x00, 0x00, 0x00, 0x00};
286	281	PacketInfo info(&header, packet, 0);
287		Writer mock;
	282	Writer mock;
288	283	// Set conditions
289	284	EXPECT_CALL(mock.collection, complete(_))
290	285	.Times(AtLeast(1));

300	295	// Prepare data
301	296	struct pcap_pkthdr header1;
302	297	header1.caplen = header1.len = 3;
303		const uint8_t packet[] = {0x80, 0x00, 0x00, 0x80,
	298	const uint8_t packet[] = {0x80, 0x00, 0x00, 0x80,
304	299	0xec, 0x8a, 0x42, 0xcb,
305		0x00, 0x00, 0x00, 0x00,// msg type - call
306		0x00, 0x00, 0x00, 0x02,// RPC version
307
308		0x00, 0x00, 0x00, 0x00,
309		0x00, 0x00, 0x00, 0x00,
310		0x00, 0x00, 0x00, 0x00,
311		0x00, 0x00, 0x00, 0x00,
312
313		0x00, 0x00, 0x00, 0x00,
314		0x00, 0x00, 0x00, 0x00,
315		0x00, 0x00, 0x00, 0x00,
316		0x00, 0x00, 0x00, 0x00,
317
318		0x00, 0x00, 0x00, 0x00,
319		0x00, 0x00, 0x00, 0x00,
320		0x00, 0x00, 0x00, 0x00,
321		0x00, 0x00, 0x00, 0x00,
322
323		0x00, 0x00, 0x00, 0x00,
324		0x00, 0x00, 0x00, 0x00,
325		0x00, 0x00, 0x00, 0x00,
326		0x00, 0x00, 0x00, 0x00,
327
328		0x00, 0x00, 0x00, 0x00,
329		0x00, 0x00, 0x00, 0x00,
330		0x00, 0x00, 0x00, 0x00,
331		0x00, 0x00, 0x00, 0x00,
332
333		0x00, 0x00, 0x00, 0x00,
334		0x00, 0x00, 0x00, 0x00,
335		0x00, 0x00, 0x00, 0x00,
336		0x00, 0x00, 0x00, 0x00,
337
338		0x00, 0x00, 0x00, 0x00,
339		0x00, 0x00, 0x00, 0x00,
340		0x00, 0x00, 0x00, 0x00,
341		0x00, 0x00, 0x00, 0x00,
342
343		0x00, 0x00, 0x00, 0x00
344		};
	300	0x00, 0x00, 0x00, 0x00, // msg type - call
	301	0x00, 0x00, 0x00, 0x02, // RPC version
	302
	303	0x00, 0x00, 0x00, 0x00,
	304	0x00, 0x00, 0x00, 0x00,
	305	0x00, 0x00, 0x00, 0x00,
	306	0x00, 0x00, 0x00, 0x00,
	307
	308	0x00, 0x00, 0x00, 0x00,
	309	0x00, 0x00, 0x00, 0x00,
	310	0x00, 0x00, 0x00, 0x00,
	311	0x00, 0x00, 0x00, 0x00,
	312
	313	0x00, 0x00, 0x00, 0x00,
	314	0x00, 0x00, 0x00, 0x00,
	315	0x00, 0x00, 0x00, 0x00,
	316	0x00, 0x00, 0x00, 0x00,
	317
	318	0x00, 0x00, 0x00, 0x00,
	319	0x00, 0x00, 0x00, 0x00,
	320	0x00, 0x00, 0x00, 0x00,
	321	0x00, 0x00, 0x00, 0x00,
	322
	323	0x00, 0x00, 0x00, 0x00,
	324	0x00, 0x00, 0x00, 0x00,
	325	0x00, 0x00, 0x00, 0x00,
	326	0x00, 0x00, 0x00, 0x00,
	327
	328	0x00, 0x00, 0x00, 0x00,
	329	0x00, 0x00, 0x00, 0x00,
	330	0x00, 0x00, 0x00, 0x00,
	331	0x00, 0x00, 0x00, 0x00,
	332
	333	0x00, 0x00, 0x00, 0x00,
	334	0x00, 0x00, 0x00, 0x00,
	335	0x00, 0x00, 0x00, 0x00,
	336	0x00, 0x00, 0x00, 0x00,
	337
	338	0x00, 0x00, 0x00, 0x00};
345	339	PacketInfo info1(&header1, packet, 0);
346	340
347	341	struct pcap_pkthdr header2;
348	342	header2.caplen = header2.len = sizeof(packet) - header1.len;
349	343	PacketInfo info2(&header2, packet + header1.len, 0);
350		Writer mock;
	344	Writer mock;
351	345
352	346	// Set conditions
353	347	EXPECT_CALL(mock.collection, complete(_))

361	355	}
362	356
363	357	//------------------------------------------------------------------------------
364

+17

-19

tests/unit/protocols/cifsv2.cpp less more

18	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
19	19	*/
20	20	//------------------------------------------------------------------------------
	21	#include <arpa/inet.h>
21	22	#include <gmock/gmock.h>
22	23	#include <gtest/gtest.h>
23		#include <arpa/inet.h>
24	24
25	25	#include "api/cifs2_commands.h"
26	26	#include "api/cifs_commands.h"

37	37	// UseCase: CIFSv1/CIFSv2 uses LE byteorder for encoding fields of messages
38	38	// in network traffic. These messages may be read on BE platform and should
39	39	// be compared with constants with corresponded BE byte order.
40		union TestData
41		{
	40	union TestData {
42	41	std::uint64_t ui64;
43	42	std::uint32_t ui32;
44	43	std::uint16_t ui16;

72	71	EXPECT_EQ(data.bytes[1], 0xEE);
73	72	}
74	73
75
76	74	TEST(CIFSv2, bodies)
77	75	{
78	76	EXPECT_EQ(36u, sizeof(struct NegotiateRequest) - sizeof(Dialects));
79	77	EXPECT_EQ(65u, sizeof(struct NegotiateResponse));
80	78
81	79	EXPECT_EQ(25u, sizeof(struct SessionSetupRequest));
82		EXPECT_EQ(9u, sizeof(struct SessionSetupResponse));
	80	EXPECT_EQ(9u, sizeof(struct SessionSetupResponse));
83	81
84		EXPECT_EQ(4u, sizeof(struct LogOffRequest));
85		EXPECT_EQ(4u, sizeof(struct LogOffResponse));
	82	EXPECT_EQ(4u, sizeof(struct LogOffRequest));
	83	EXPECT_EQ(4u, sizeof(struct LogOffResponse));
86	84
87		EXPECT_EQ(4u, sizeof(struct EchoRequest));
88		EXPECT_EQ(4u, sizeof(struct EchoResponse));
	85	EXPECT_EQ(4u, sizeof(struct EchoRequest));
	86	EXPECT_EQ(4u, sizeof(struct EchoResponse));
89	87
90		EXPECT_EQ(9u, sizeof(struct TreeConnectRequest));
	88	EXPECT_EQ(9u, sizeof(struct TreeConnectRequest));
91	89	EXPECT_EQ(16u, sizeof(struct TreeConnectResponse));
92	90
93		EXPECT_EQ(4u, sizeof(struct TreeDisconnectRequest));
94		EXPECT_EQ(4u, sizeof(struct TreeDisconnectResponse));
	91	EXPECT_EQ(4u, sizeof(struct TreeDisconnectRequest));
	92	EXPECT_EQ(4u, sizeof(struct TreeDisconnectResponse));
95	93
96	94	EXPECT_EQ(57u, sizeof(struct CreateRequest));
97	95	EXPECT_EQ(89u, sizeof(struct CreateResponse));

100	98	EXPECT_EQ(60u, sizeof(struct CloseResponse));
101	99
102	100	EXPECT_EQ(41u, sizeof(struct QueryInfoRequest));
103		EXPECT_EQ(9u, sizeof(struct QueryInfoResponse));
	101	EXPECT_EQ(9u, sizeof(struct QueryInfoResponse));
104	102
105	103	EXPECT_EQ(33u, sizeof(struct QueryDirRequest));
106		EXPECT_EQ(9u, sizeof(struct QueryDirResponse));
	104	EXPECT_EQ(9u, sizeof(struct QueryDirResponse));
107	105
108	106	EXPECT_EQ(24u, sizeof(struct FlushRequest));
109		EXPECT_EQ(4u, sizeof(struct FlushResponse));
	107	EXPECT_EQ(4u, sizeof(struct FlushResponse));
110	108
111	109	EXPECT_EQ(49u, sizeof(struct ReadRequest));
112	110	EXPECT_EQ(17u, sizeof(struct ReadResponse));

118	116	EXPECT_EQ(16u, sizeof(struct WriteResponse));
119	117
120	118	EXPECT_EQ(48u, sizeof(struct LockRequest));
121		EXPECT_EQ(4u, sizeof(struct LockResponse));
	119	EXPECT_EQ(4u, sizeof(struct LockResponse));
122	120
123		EXPECT_EQ(4u, sizeof(struct CancelRequest));
	121	EXPECT_EQ(4u, sizeof(struct CancelRequest));
124	122
125	123	EXPECT_EQ(32u, sizeof(struct ChangeNotifyRequest));
126		EXPECT_EQ(8u + sizeof(struct FileNotifyInformation), sizeof(struct ChangeNotifyResponse));
	124	EXPECT_EQ(8u + sizeof(struct FileNotifyInformation), sizeof(struct ChangeNotifyResponse));
127	125
128	126	EXPECT_EQ(57u, sizeof(struct IoCtlRequest));
129	127	EXPECT_EQ(49u, sizeof(struct IoCtlResponse));
130	128
131	129	EXPECT_EQ(33u, sizeof(struct SetInfoRequest));
132		EXPECT_EQ(2u, sizeof(struct SetInfoResponse));
	130	EXPECT_EQ(2u, sizeof(struct SetInfoResponse));
133	131	}
134	132	//------------------------------------------------------------------------------

+77

-0

tests/unit/utils/block_allocator.cpp less more

	0	//------------------------------------------------------------------------------
	1	// Author: Pavel Karneliuk
	2	// Description: Unit tests for BlockAllocator
	3	// Copyright (c) 2016 Pavel Karneliuk
	4	//------------------------------------------------------------------------------
	5	/*
	6	This file is part of Nfstrace.
	7
	8	Nfstrace is free software: you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation, version 2 of the License.
	11
	12	Nfstrace is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with Nfstrace. If not, see <http://www.gnu.org/licenses/>.
	19	*/
	20	//------------------------------------------------------------------------------
	21	#include <vector>
	22
	23	#include <gtest/gtest.h>
	24
	25	#include <utils/block_allocator.h>
	26	//------------------------------------------------------------------------------
	27	using namespace NST::utils;
	28	//------------------------------------------------------------------------------
	29	//------------------------------------------------------------------------------
	30	TEST(BlockAllocator, testBasicOperations)
	31	{
	32	BlockAllocator allocator;
	33
	34	using Item = char[64];
	35	const std::size_t nperblocks = 1024;
	36	const std::size_t lim_blocks = 1;
	37
	38	EXPECT_NO_THROW(
	39	allocator.init_allocation(sizeof(Item), nperblocks, lim_blocks));
	40
	41	ASSERT_EQ(lim_blocks, allocator.max_blocks());
	42	ASSERT_EQ(nperblocks, allocator.free_chunks());
	43	ASSERT_EQ(nperblocks * lim_blocks, allocator.max_chunks());
	44
	45	std::vector<void*> allocated;
	46	allocated.reserve(nperblocks + 1);
	47
	48	{ // get all memory chunks from preallocated block
	49	for(std::size_t i = 0; i < nperblocks; ++i)
	50	{
	51	allocated.emplace_back(allocator.allocate());
	52	}
	53	ASSERT_EQ(0u, allocator.free_chunks());
	54	}
	55
	56	{ // increase soft limit implicitly during allocation one new item
	57	const auto old = allocator.max_blocks();
	58	allocated.emplace_back(allocator.allocate());
	59	ASSERT_EQ(old + 1, allocator.max_blocks());
	60	ASSERT_EQ(nperblocks - 1, allocator.free_chunks());
	61	}
	62
	63	{ // get last recently deallocated during new allocation
	64	const auto old = allocator.allocate();
	65	allocator.deallocate(old);
	66	const auto same = allocator.allocate();
	67	ASSERT_EQ(old, same);
	68	allocated.emplace_back(same);
	69	}
	70
	71	for(auto& a : allocated)
	72	{
	73	allocator.deallocate(a);
	74	}
	75	}
	76	//------------------------------------------------------------------------------

-1

tests/unit/utils/filtered_data.cpp less more

	0	#include <gmock/gmock.h>
0	1	#include <gtest/gtest.h>
1		#include <gmock/gmock.h>
2	2	#include <utils/filtered_data.h>
3	3
4	4	TEST(FilteredData, construct)

-0

third_party/README less more

	0	Here are third party libraries with necessary components for nfstrace.
	1

-228

traces/references/breakdown/1-packet.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101		NFS v3 protocol
102		Total operations: 0. Per operation:
103		NULL 0 0.00%
104		GETATTR 0 0.00%
105		SETATTR 0 0.00%
106		LOOKUP 0 0.00%
107		ACCESS 0 0.00%
108		READLINK 0 0.00%
109		READ 0 0.00%
110		WRITE 0 0.00%
111		CREATE 0 0.00%
112		MKDIR 0 0.00%
113		SYMLINK 0 0.00%
114		MKNOD 0 0.00%
115		REMOVE 0 0.00%
116		RMDIR 0 0.00%
117		RENAME 0 0.00%
118		LINK 0 0.00%
119		READDIR 0 0.00%
120		READDIRPLUS 0 0.00%
121		FSSTAT 0 0.00%
122		FSINFO 0 0.00%
123		PATHCONF 0 0.00%
124		COMMIT 0 0.00%
	5	NFS v3 protocol: Data transmission has not been detected.
125	6	### Breakdown analyzer ###
126		NFS v4.0 protocol
127		Total procedures: 0. Per procedure:
128		NULL 0 0.00%
129		COMPOUND 0 0.00%
130		Total operations: 0. Per operation:
131		ILLEGAL 0 0.00%
132		ACCESS 0 0.00%
133		CLOSE 0 0.00%
134		COMMIT 0 0.00%
135		CREATE 0 0.00%
136		DELEGPURGE 0 0.00%
137		DELEGRETURN 0 0.00%
138		GETATTR 0 0.00%
139		GETFH 0 0.00%
140		LINK 0 0.00%
141		LOCK 0 0.00%
142		LOCKT 0 0.00%
143		LOCKU 0 0.00%
144		LOOKUP 0 0.00%
145		LOOKUPP 0 0.00%
146		NVERIFY 0 0.00%
147		OPEN 0 0.00%
148		OPENATTR 0 0.00%
149		OPEN_CONFIRM 0 0.00%
150		OPEN_DOWNGRADE 0 0.00%
151		PUTFH 0 0.00%
152		PUTPUBFH 0 0.00%
153		PUTROOTFH 0 0.00%
154		READ 0 0.00%
155		READDIR 0 0.00%
156		READLINK 0 0.00%
157		REMOVE 0 0.00%
158		RENAME 0 0.00%
159		RENEW 0 0.00%
160		RESTOREFH 0 0.00%
161		SAVEFH 0 0.00%
162		SECINFO 0 0.00%
163		SETATTR 0 0.00%
164		SETCLIENTID 0 0.00%
165		SETCLIENTID_CONFIRM 0 0.00%
166		VERIFY 0 0.00%
167		WRITE 0 0.00%
168		RELEASE_LOCKOWNER 0 0.00%
169		GET_DIR_DELEGATION 0 0.00%
	7	NFS v4.0 protocol: Data transmission has not been detected.
170	8	### Breakdown analyzer ###
171		NFS v4.1 protocol
172		Total procedures: 0. Per procedure:
173		NULL 0 0.00%
174		COMPOUND 0 0.00%
175		Total operations: 0. Per operation:
176		ILLEGAL 0 0.00%
177		ACCESS 0 0.00%
178		CLOSE 0 0.00%
179		COMMIT 0 0.00%
180		CREATE 0 0.00%
181		DELEGPURGE 0 0.00%
182		DELEGRETURN 0 0.00%
183		GETATTR 0 0.00%
184		GETFH 0 0.00%
185		LINK 0 0.00%
186		LOCK 0 0.00%
187		LOCKT 0 0.00%
188		LOCKU 0 0.00%
189		LOOKUP 0 0.00%
190		LOOKUPP 0 0.00%
191		NVERIFY 0 0.00%
192		OPEN 0 0.00%
193		OPENATTR 0 0.00%
194		OPEN_CONFIRM 0 0.00%
195		OPEN_DOWNGRADE 0 0.00%
196		PUTFH 0 0.00%
197		PUTPUBFH 0 0.00%
198		PUTROOTFH 0 0.00%
199		READ 0 0.00%
200		READDIR 0 0.00%
201		READLINK 0 0.00%
202		REMOVE 0 0.00%
203		RENAME 0 0.00%
204		RENEW 0 0.00%
205		RESTOREFH 0 0.00%
206		SAVEFH 0 0.00%
207		SECINFO 0 0.00%
208		SETATTR 0 0.00%
209		SETCLIENTID 0 0.00%
210		SETCLIENTID_CONFIRM 0 0.00%
211		VERIFY 0 0.00%
212		WRITE 0 0.00%
213		RELEASE_LOCKOWNER 0 0.00%
214		BACKCHANNEL_CTL 0 0.00%
215		BIND_CONN_TO_SESSION 0 0.00%
216		EXCHANGE_ID 0 0.00%
217		CREATE_SESSION 0 0.00%
218		DESTROY_SESSION 0 0.00%
219		FREE_STATEID 0 0.00%
220		GET_DIR_DELEGATION 0 0.00%
221		GETDEVICEINFO 0 0.00%
222		GETDEVICELIST 0 0.00%
223		LAYOUTCOMMIT 0 0.00%
224		LAYOUTGET 0 0.00%
225		LAYOUTRETURN 0 0.00%
226		SECINFO_NO_NAME 0 0.00%
227		SEQUENCE 0 0.00%
228		SET_SSV 0 0.00%
229		TEST_STATEID 0 0.00%
230		WANT_DELEGATION 0 0.00%
231		DESTROY_CLIENTID 0 0.00%
232		RECLAIM_COMPLETE 0 0.00%
	9	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/2sessions-tcp-wsize32k-tcp-wsize512k.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 413. Per operation:

220	124	PATHCONF Count: 1 ( 2.17%) Min: 0.001 Max: 0.001 Avg: 0.001 StDev: 0.00000000
221	125	COMMIT Count: 1 ( 2.17%) Min: 0.148 Max: 0.148 Avg: 0.148 StDev: 0.00000000
222	126	### Breakdown analyzer ###
223		NFS v4.0 protocol
224		Total procedures: 0. Per procedure:
225		NULL 0 0.00%
226		COMPOUND 0 0.00%
227		Total operations: 0. Per operation:
228		ILLEGAL 0 0.00%
229		ACCESS 0 0.00%
230		CLOSE 0 0.00%
231		COMMIT 0 0.00%
232		CREATE 0 0.00%
233		DELEGPURGE 0 0.00%
234		DELEGRETURN 0 0.00%
235		GETATTR 0 0.00%
236		GETFH 0 0.00%
237		LINK 0 0.00%
238		LOCK 0 0.00%
239		LOCKT 0 0.00%
240		LOCKU 0 0.00%
241		LOOKUP 0 0.00%
242		LOOKUPP 0 0.00%
243		NVERIFY 0 0.00%
244		OPEN 0 0.00%
245		OPENATTR 0 0.00%
246		OPEN_CONFIRM 0 0.00%
247		OPEN_DOWNGRADE 0 0.00%
248		PUTFH 0 0.00%
249		PUTPUBFH 0 0.00%
250		PUTROOTFH 0 0.00%
251		READ 0 0.00%
252		READDIR 0 0.00%
253		READLINK 0 0.00%
254		REMOVE 0 0.00%
255		RENAME 0 0.00%
256		RENEW 0 0.00%
257		RESTOREFH 0 0.00%
258		SAVEFH 0 0.00%
259		SECINFO 0 0.00%
260		SETATTR 0 0.00%
261		SETCLIENTID 0 0.00%
262		SETCLIENTID_CONFIRM 0 0.00%
263		VERIFY 0 0.00%
264		WRITE 0 0.00%
265		RELEASE_LOCKOWNER 0 0.00%
266		GET_DIR_DELEGATION 0 0.00%
	127	NFS v4.0 protocol: Data transmission has not been detected.
267	128	### Breakdown analyzer ###
268		NFS v4.1 protocol
269		Total procedures: 0. Per procedure:
270		NULL 0 0.00%
271		COMPOUND 0 0.00%
272		Total operations: 0. Per operation:
273		ILLEGAL 0 0.00%
274		ACCESS 0 0.00%
275		CLOSE 0 0.00%
276		COMMIT 0 0.00%
277		CREATE 0 0.00%
278		DELEGPURGE 0 0.00%
279		DELEGRETURN 0 0.00%
280		GETATTR 0 0.00%
281		GETFH 0 0.00%
282		LINK 0 0.00%
283		LOCK 0 0.00%
284		LOCKT 0 0.00%
285		LOCKU 0 0.00%
286		LOOKUP 0 0.00%
287		LOOKUPP 0 0.00%
288		NVERIFY 0 0.00%
289		OPEN 0 0.00%
290		OPENATTR 0 0.00%
291		OPEN_CONFIRM 0 0.00%
292		OPEN_DOWNGRADE 0 0.00%
293		PUTFH 0 0.00%
294		PUTPUBFH 0 0.00%
295		PUTROOTFH 0 0.00%
296		READ 0 0.00%
297		READDIR 0 0.00%
298		READLINK 0 0.00%
299		REMOVE 0 0.00%
300		RENAME 0 0.00%
301		RENEW 0 0.00%
302		RESTOREFH 0 0.00%
303		SAVEFH 0 0.00%
304		SECINFO 0 0.00%
305		SETATTR 0 0.00%
306		SETCLIENTID 0 0.00%
307		SETCLIENTID_CONFIRM 0 0.00%
308		VERIFY 0 0.00%
309		WRITE 0 0.00%
310		RELEASE_LOCKOWNER 0 0.00%
311		BACKCHANNEL_CTL 0 0.00%
312		BIND_CONN_TO_SESSION 0 0.00%
313		EXCHANGE_ID 0 0.00%
314		CREATE_SESSION 0 0.00%
315		DESTROY_SESSION 0 0.00%
316		FREE_STATEID 0 0.00%
317		GET_DIR_DELEGATION 0 0.00%
318		GETDEVICEINFO 0 0.00%
319		GETDEVICELIST 0 0.00%
320		LAYOUTCOMMIT 0 0.00%
321		LAYOUTGET 0 0.00%
322		LAYOUTRETURN 0 0.00%
323		SECINFO_NO_NAME 0 0.00%
324		SEQUENCE 0 0.00%
325		SET_SSV 0 0.00%
326		TEST_STATEID 0 0.00%
327		WANT_DELEGATION 0 0.00%
328		DESTROY_CLIENTID 0 0.00%
329		RECLAIM_COMPLETE 0 0.00%
	129	NFS v4.1 protocol: Data transmission has not been detected.

-207

traces/references/breakdown/eth-ipv4-tcp-cifs2.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79	3	CIFS v2 protocol
80	4	Total operations: 30. Per operation:

120	44	SET INFO Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
121	45	OPLOCK BREAK Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
122	46	### Breakdown analyzer ###
123		NFS v3 protocol
124		Total operations: 0. Per operation:
125		NULL 0 0.00%
126		GETATTR 0 0.00%
127		SETATTR 0 0.00%
128		LOOKUP 0 0.00%
129		ACCESS 0 0.00%
130		READLINK 0 0.00%
131		READ 0 0.00%
132		WRITE 0 0.00%
133		CREATE 0 0.00%
134		MKDIR 0 0.00%
135		SYMLINK 0 0.00%
136		MKNOD 0 0.00%
137		REMOVE 0 0.00%
138		RMDIR 0 0.00%
139		RENAME 0 0.00%
140		LINK 0 0.00%
141		READDIR 0 0.00%
142		READDIRPLUS 0 0.00%
143		FSSTAT 0 0.00%
144		FSINFO 0 0.00%
145		PATHCONF 0 0.00%
146		COMMIT 0 0.00%
	47	NFS v3 protocol: Data transmission has not been detected.
147	48	### Breakdown analyzer ###
148		NFS v4.0 protocol
149		Total procedures: 0. Per procedure:
150		NULL 0 0.00%
151		COMPOUND 0 0.00%
152		Total operations: 0. Per operation:
153		ILLEGAL 0 0.00%
154		ACCESS 0 0.00%
155		CLOSE 0 0.00%
156		COMMIT 0 0.00%
157		CREATE 0 0.00%
158		DELEGPURGE 0 0.00%
159		DELEGRETURN 0 0.00%
160		GETATTR 0 0.00%
161		GETFH 0 0.00%
162		LINK 0 0.00%
163		LOCK 0 0.00%
164		LOCKT 0 0.00%
165		LOCKU 0 0.00%
166		LOOKUP 0 0.00%
167		LOOKUPP 0 0.00%
168		NVERIFY 0 0.00%
169		OPEN 0 0.00%
170		OPENATTR 0 0.00%
171		OPEN_CONFIRM 0 0.00%
172		OPEN_DOWNGRADE 0 0.00%
173		PUTFH 0 0.00%
174		PUTPUBFH 0 0.00%
175		PUTROOTFH 0 0.00%
176		READ 0 0.00%
177		READDIR 0 0.00%
178		READLINK 0 0.00%
179		REMOVE 0 0.00%
180		RENAME 0 0.00%
181		RENEW 0 0.00%
182		RESTOREFH 0 0.00%
183		SAVEFH 0 0.00%
184		SECINFO 0 0.00%
185		SETATTR 0 0.00%
186		SETCLIENTID 0 0.00%
187		SETCLIENTID_CONFIRM 0 0.00%
188		VERIFY 0 0.00%
189		WRITE 0 0.00%
190		RELEASE_LOCKOWNER 0 0.00%
191		GET_DIR_DELEGATION 0 0.00%
	49	NFS v4.0 protocol: Data transmission has not been detected.
192	50	### Breakdown analyzer ###
193		NFS v4.1 protocol
194		Total procedures: 0. Per procedure:
195		NULL 0 0.00%
196		COMPOUND 0 0.00%
197		Total operations: 0. Per operation:
198		ILLEGAL 0 0.00%
199		ACCESS 0 0.00%
200		CLOSE 0 0.00%
201		COMMIT 0 0.00%
202		CREATE 0 0.00%
203		DELEGPURGE 0 0.00%
204		DELEGRETURN 0 0.00%
205		GETATTR 0 0.00%
206		GETFH 0 0.00%
207		LINK 0 0.00%
208		LOCK 0 0.00%
209		LOCKT 0 0.00%
210		LOCKU 0 0.00%
211		LOOKUP 0 0.00%
212		LOOKUPP 0 0.00%
213		NVERIFY 0 0.00%
214		OPEN 0 0.00%
215		OPENATTR 0 0.00%
216		OPEN_CONFIRM 0 0.00%
217		OPEN_DOWNGRADE 0 0.00%
218		PUTFH 0 0.00%
219		PUTPUBFH 0 0.00%
220		PUTROOTFH 0 0.00%
221		READ 0 0.00%
222		READDIR 0 0.00%
223		READLINK 0 0.00%
224		REMOVE 0 0.00%
225		RENAME 0 0.00%
226		RENEW 0 0.00%
227		RESTOREFH 0 0.00%
228		SAVEFH 0 0.00%
229		SECINFO 0 0.00%
230		SETATTR 0 0.00%
231		SETCLIENTID 0 0.00%
232		SETCLIENTID_CONFIRM 0 0.00%
233		VERIFY 0 0.00%
234		WRITE 0 0.00%
235		RELEASE_LOCKOWNER 0 0.00%
236		BACKCHANNEL_CTL 0 0.00%
237		BIND_CONN_TO_SESSION 0 0.00%
238		EXCHANGE_ID 0 0.00%
239		CREATE_SESSION 0 0.00%
240		DESTROY_SESSION 0 0.00%
241		FREE_STATEID 0 0.00%
242		GET_DIR_DELEGATION 0 0.00%
243		GETDEVICEINFO 0 0.00%
244		GETDEVICELIST 0 0.00%
245		LAYOUTCOMMIT 0 0.00%
246		LAYOUTGET 0 0.00%
247		LAYOUTRETURN 0 0.00%
248		SECINFO_NO_NAME 0 0.00%
249		SEQUENCE 0 0.00%
250		SET_SSV 0 0.00%
251		TEST_STATEID 0 0.00%
252		WANT_DELEGATION 0 0.00%
253		DESTROY_CLIENTID 0 0.00%
254		RECLAIM_COMPLETE 0 0.00%
	51	NFS v4.1 protocol: Data transmission has not been detected.

-160

traces/references/breakdown/eth-ipv4-tcp-nfsv3-4-readdir-75k-entries.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 3892. Per operation:

262	166	RELEASE_LOCKOWNER Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
263	167	GET_DIR_DELEGATION Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
264	168	### Breakdown analyzer ###
265		NFS v4.1 protocol
266		Total procedures: 0. Per procedure:
267		NULL 0 0.00%
268		COMPOUND 0 0.00%
269		Total operations: 0. Per operation:
270		ILLEGAL 0 0.00%
271		ACCESS 0 0.00%
272		CLOSE 0 0.00%
273		COMMIT 0 0.00%
274		CREATE 0 0.00%
275		DELEGPURGE 0 0.00%
276		DELEGRETURN 0 0.00%
277		GETATTR 0 0.00%
278		GETFH 0 0.00%
279		LINK 0 0.00%
280		LOCK 0 0.00%
281		LOCKT 0 0.00%
282		LOCKU 0 0.00%
283		LOOKUP 0 0.00%
284		LOOKUPP 0 0.00%
285		NVERIFY 0 0.00%
286		OPEN 0 0.00%
287		OPENATTR 0 0.00%
288		OPEN_CONFIRM 0 0.00%
289		OPEN_DOWNGRADE 0 0.00%
290		PUTFH 0 0.00%
291		PUTPUBFH 0 0.00%
292		PUTROOTFH 0 0.00%
293		READ 0 0.00%
294		READDIR 0 0.00%
295		READLINK 0 0.00%
296		REMOVE 0 0.00%
297		RENAME 0 0.00%
298		RENEW 0 0.00%
299		RESTOREFH 0 0.00%
300		SAVEFH 0 0.00%
301		SECINFO 0 0.00%
302		SETATTR 0 0.00%
303		SETCLIENTID 0 0.00%
304		SETCLIENTID_CONFIRM 0 0.00%
305		VERIFY 0 0.00%
306		WRITE 0 0.00%
307		RELEASE_LOCKOWNER 0 0.00%
308		BACKCHANNEL_CTL 0 0.00%
309		BIND_CONN_TO_SESSION 0 0.00%
310		EXCHANGE_ID 0 0.00%
311		CREATE_SESSION 0 0.00%
312		DESTROY_SESSION 0 0.00%
313		FREE_STATEID 0 0.00%
314		GET_DIR_DELEGATION 0 0.00%
315		GETDEVICEINFO 0 0.00%
316		GETDEVICELIST 0 0.00%
317		LAYOUTCOMMIT 0 0.00%
318		LAYOUTGET 0 0.00%
319		LAYOUTRETURN 0 0.00%
320		SECINFO_NO_NAME 0 0.00%
321		SEQUENCE 0 0.00%
322		SET_SSV 0 0.00%
323		TEST_STATEID 0 0.00%
324		WANT_DELEGATION 0 0.00%
325		DESTROY_CLIENTID 0 0.00%
326		RECLAIM_COMPLETE 0 0.00%
	169	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/eth-ipv4-tcp-nfsv3.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 3331. Per operation:

148	52	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
149	53	COMMIT Count: 10 ( 0.30%) Min: 0.001 Max: 0.001 Avg: 0.001 StDev: 0.00019761
150	54	### Breakdown analyzer ###
151		NFS v4.0 protocol
152		Total procedures: 0. Per procedure:
153		NULL 0 0.00%
154		COMPOUND 0 0.00%
155		Total operations: 0. Per operation:
156		ILLEGAL 0 0.00%
157		ACCESS 0 0.00%
158		CLOSE 0 0.00%
159		COMMIT 0 0.00%
160		CREATE 0 0.00%
161		DELEGPURGE 0 0.00%
162		DELEGRETURN 0 0.00%
163		GETATTR 0 0.00%
164		GETFH 0 0.00%
165		LINK 0 0.00%
166		LOCK 0 0.00%
167		LOCKT 0 0.00%
168		LOCKU 0 0.00%
169		LOOKUP 0 0.00%
170		LOOKUPP 0 0.00%
171		NVERIFY 0 0.00%
172		OPEN 0 0.00%
173		OPENATTR 0 0.00%
174		OPEN_CONFIRM 0 0.00%
175		OPEN_DOWNGRADE 0 0.00%
176		PUTFH 0 0.00%
177		PUTPUBFH 0 0.00%
178		PUTROOTFH 0 0.00%
179		READ 0 0.00%
180		READDIR 0 0.00%
181		READLINK 0 0.00%
182		REMOVE 0 0.00%
183		RENAME 0 0.00%
184		RENEW 0 0.00%
185		RESTOREFH 0 0.00%
186		SAVEFH 0 0.00%
187		SECINFO 0 0.00%
188		SETATTR 0 0.00%
189		SETCLIENTID 0 0.00%
190		SETCLIENTID_CONFIRM 0 0.00%
191		VERIFY 0 0.00%
192		WRITE 0 0.00%
193		RELEASE_LOCKOWNER 0 0.00%
194		GET_DIR_DELEGATION 0 0.00%
	55	NFS v4.0 protocol: Data transmission has not been detected.
195	56	### Breakdown analyzer ###
196		NFS v4.1 protocol
197		Total procedures: 0. Per procedure:
198		NULL 0 0.00%
199		COMPOUND 0 0.00%
200		Total operations: 0. Per operation:
201		ILLEGAL 0 0.00%
202		ACCESS 0 0.00%
203		CLOSE 0 0.00%
204		COMMIT 0 0.00%
205		CREATE 0 0.00%
206		DELEGPURGE 0 0.00%
207		DELEGRETURN 0 0.00%
208		GETATTR 0 0.00%
209		GETFH 0 0.00%
210		LINK 0 0.00%
211		LOCK 0 0.00%
212		LOCKT 0 0.00%
213		LOCKU 0 0.00%
214		LOOKUP 0 0.00%
215		LOOKUPP 0 0.00%
216		NVERIFY 0 0.00%
217		OPEN 0 0.00%
218		OPENATTR 0 0.00%
219		OPEN_CONFIRM 0 0.00%
220		OPEN_DOWNGRADE 0 0.00%
221		PUTFH 0 0.00%
222		PUTPUBFH 0 0.00%
223		PUTROOTFH 0 0.00%
224		READ 0 0.00%
225		READDIR 0 0.00%
226		READLINK 0 0.00%
227		REMOVE 0 0.00%
228		RENAME 0 0.00%
229		RENEW 0 0.00%
230		RESTOREFH 0 0.00%
231		SAVEFH 0 0.00%
232		SECINFO 0 0.00%
233		SETATTR 0 0.00%
234		SETCLIENTID 0 0.00%
235		SETCLIENTID_CONFIRM 0 0.00%
236		VERIFY 0 0.00%
237		WRITE 0 0.00%
238		RELEASE_LOCKOWNER 0 0.00%
239		BACKCHANNEL_CTL 0 0.00%
240		BIND_CONN_TO_SESSION 0 0.00%
241		EXCHANGE_ID 0 0.00%
242		CREATE_SESSION 0 0.00%
243		DESTROY_SESSION 0 0.00%
244		FREE_STATEID 0 0.00%
245		GET_DIR_DELEGATION 0 0.00%
246		GETDEVICEINFO 0 0.00%
247		GETDEVICELIST 0 0.00%
248		LAYOUTCOMMIT 0 0.00%
249		LAYOUTGET 0 0.00%
250		LAYOUTRETURN 0 0.00%
251		SECINFO_NO_NAME 0 0.00%
252		SEQUENCE 0 0.00%
253		SET_SSV 0 0.00%
254		TEST_STATEID 0 0.00%
255		WANT_DELEGATION 0 0.00%
256		DESTROY_CLIENTID 0 0.00%
257		RECLAIM_COMPLETE 0 0.00%
	57	NFS v4.1 protocol: Data transmission has not been detected.

-184

traces/references/breakdown/eth-ipv4-tcp-nfsv4-incorrect_mount.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101		NFS v3 protocol
102		Total operations: 0. Per operation:
103		NULL 0 0.00%
104		GETATTR 0 0.00%
105		SETATTR 0 0.00%
106		LOOKUP 0 0.00%
107		ACCESS 0 0.00%
108		READLINK 0 0.00%
109		READ 0 0.00%
110		WRITE 0 0.00%
111		CREATE 0 0.00%
112		MKDIR 0 0.00%
113		SYMLINK 0 0.00%
114		MKNOD 0 0.00%
115		REMOVE 0 0.00%
116		RMDIR 0 0.00%
117		RENAME 0 0.00%
118		LINK 0 0.00%
119		READDIR 0 0.00%
120		READDIRPLUS 0 0.00%
121		FSSTAT 0 0.00%
122		FSINFO 0 0.00%
123		PATHCONF 0 0.00%
124		COMMIT 0 0.00%
	5	NFS v3 protocol: Data transmission has not been detected.
125	6	### Breakdown analyzer ###
126	7	NFS v4.0 protocol
127	8	Total procedures: 3. Per procedure:

213	94	RELEASE_LOCKOWNER Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
214	95	GET_DIR_DELEGATION Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
215	96	### Breakdown analyzer ###
216		NFS v4.1 protocol
217		Total procedures: 0. Per procedure:
218		NULL 0 0.00%
219		COMPOUND 0 0.00%
220		Total operations: 0. Per operation:
221		ILLEGAL 0 0.00%
222		ACCESS 0 0.00%
223		CLOSE 0 0.00%
224		COMMIT 0 0.00%
225		CREATE 0 0.00%
226		DELEGPURGE 0 0.00%
227		DELEGRETURN 0 0.00%
228		GETATTR 0 0.00%
229		GETFH 0 0.00%
230		LINK 0 0.00%
231		LOCK 0 0.00%
232		LOCKT 0 0.00%
233		LOCKU 0 0.00%
234		LOOKUP 0 0.00%
235		LOOKUPP 0 0.00%
236		NVERIFY 0 0.00%
237		OPEN 0 0.00%
238		OPENATTR 0 0.00%
239		OPEN_CONFIRM 0 0.00%
240		OPEN_DOWNGRADE 0 0.00%
241		PUTFH 0 0.00%
242		PUTPUBFH 0 0.00%
243		PUTROOTFH 0 0.00%
244		READ 0 0.00%
245		READDIR 0 0.00%
246		READLINK 0 0.00%
247		REMOVE 0 0.00%
248		RENAME 0 0.00%
249		RENEW 0 0.00%
250		RESTOREFH 0 0.00%
251		SAVEFH 0 0.00%
252		SECINFO 0 0.00%
253		SETATTR 0 0.00%
254		SETCLIENTID 0 0.00%
255		SETCLIENTID_CONFIRM 0 0.00%
256		VERIFY 0 0.00%
257		WRITE 0 0.00%
258		RELEASE_LOCKOWNER 0 0.00%
259		BACKCHANNEL_CTL 0 0.00%
260		BIND_CONN_TO_SESSION 0 0.00%
261		EXCHANGE_ID 0 0.00%
262		CREATE_SESSION 0 0.00%
263		DESTROY_SESSION 0 0.00%
264		FREE_STATEID 0 0.00%
265		GET_DIR_DELEGATION 0 0.00%
266		GETDEVICEINFO 0 0.00%
267		GETDEVICELIST 0 0.00%
268		LAYOUTCOMMIT 0 0.00%
269		LAYOUTGET 0 0.00%
270		LAYOUTRETURN 0 0.00%
271		SECINFO_NO_NAME 0 0.00%
272		SEQUENCE 0 0.00%
273		SET_SSV 0 0.00%
274		TEST_STATEID 0 0.00%
275		WANT_DELEGATION 0 0.00%
276		DESTROY_CLIENTID 0 0.00%
277		RECLAIM_COMPLETE 0 0.00%
	97	NFS v4.1 protocol: Data transmission has not been detected.

-184

traces/references/breakdown/eth-ipv4-tcp-nfsv4-posix.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101		NFS v3 protocol
102		Total operations: 0. Per operation:
103		NULL 0 0.00%
104		GETATTR 0 0.00%
105		SETATTR 0 0.00%
106		LOOKUP 0 0.00%
107		ACCESS 0 0.00%
108		READLINK 0 0.00%
109		READ 0 0.00%
110		WRITE 0 0.00%
111		CREATE 0 0.00%
112		MKDIR 0 0.00%
113		SYMLINK 0 0.00%
114		MKNOD 0 0.00%
115		REMOVE 0 0.00%
116		RMDIR 0 0.00%
117		RENAME 0 0.00%
118		LINK 0 0.00%
119		READDIR 0 0.00%
120		READDIRPLUS 0 0.00%
121		FSSTAT 0 0.00%
122		FSINFO 0 0.00%
123		PATHCONF 0 0.00%
124		COMMIT 0 0.00%
	5	NFS v3 protocol: Data transmission has not been detected.
125	6	### Breakdown analyzer ###
126	7	NFS v4.0 protocol
127	8	Total procedures: 100671. Per procedure:

521	402	RELEASE_LOCKOWNER Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
522	403	GET_DIR_DELEGATION Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
523	404	### Breakdown analyzer ###
524		NFS v4.1 protocol
525		Total procedures: 0. Per procedure:
526		NULL 0 0.00%
527		COMPOUND 0 0.00%
528		Total operations: 0. Per operation:
529		ILLEGAL 0 0.00%
530		ACCESS 0 0.00%
531		CLOSE 0 0.00%
532		COMMIT 0 0.00%
533		CREATE 0 0.00%
534		DELEGPURGE 0 0.00%
535		DELEGRETURN 0 0.00%
536		GETATTR 0 0.00%
537		GETFH 0 0.00%
538		LINK 0 0.00%
539		LOCK 0 0.00%
540		LOCKT 0 0.00%
541		LOCKU 0 0.00%
542		LOOKUP 0 0.00%
543		LOOKUPP 0 0.00%
544		NVERIFY 0 0.00%
545		OPEN 0 0.00%
546		OPENATTR 0 0.00%
547		OPEN_CONFIRM 0 0.00%
548		OPEN_DOWNGRADE 0 0.00%
549		PUTFH 0 0.00%
550		PUTPUBFH 0 0.00%
551		PUTROOTFH 0 0.00%
552		READ 0 0.00%
553		READDIR 0 0.00%
554		READLINK 0 0.00%
555		REMOVE 0 0.00%
556		RENAME 0 0.00%
557		RENEW 0 0.00%
558		RESTOREFH 0 0.00%
559		SAVEFH 0 0.00%
560		SECINFO 0 0.00%
561		SETATTR 0 0.00%
562		SETCLIENTID 0 0.00%
563		SETCLIENTID_CONFIRM 0 0.00%
564		VERIFY 0 0.00%
565		WRITE 0 0.00%
566		RELEASE_LOCKOWNER 0 0.00%
567		BACKCHANNEL_CTL 0 0.00%
568		BIND_CONN_TO_SESSION 0 0.00%
569		EXCHANGE_ID 0 0.00%
570		CREATE_SESSION 0 0.00%
571		DESTROY_SESSION 0 0.00%
572		FREE_STATEID 0 0.00%
573		GET_DIR_DELEGATION 0 0.00%
574		GETDEVICEINFO 0 0.00%
575		GETDEVICELIST 0 0.00%
576		LAYOUTCOMMIT 0 0.00%
577		LAYOUTGET 0 0.00%
578		LAYOUTRETURN 0 0.00%
579		SECINFO_NO_NAME 0 0.00%
580		SEQUENCE 0 0.00%
581		SET_SSV 0 0.00%
582		TEST_STATEID 0 0.00%
583		WANT_DELEGATION 0 0.00%
584		DESTROY_CLIENTID 0 0.00%
585		RECLAIM_COMPLETE 0 0.00%
	405	NFS v4.1 protocol: Data transmission has not been detected.

-184

traces/references/breakdown/eth-ipv4-tcp-nfsv4.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101		NFS v3 protocol
102		Total operations: 0. Per operation:
103		NULL 0 0.00%
104		GETATTR 0 0.00%
105		SETATTR 0 0.00%
106		LOOKUP 0 0.00%
107		ACCESS 0 0.00%
108		READLINK 0 0.00%
109		READ 0 0.00%
110		WRITE 0 0.00%
111		CREATE 0 0.00%
112		MKDIR 0 0.00%
113		SYMLINK 0 0.00%
114		MKNOD 0 0.00%
115		REMOVE 0 0.00%
116		RMDIR 0 0.00%
117		RENAME 0 0.00%
118		LINK 0 0.00%
119		READDIR 0 0.00%
120		READDIRPLUS 0 0.00%
121		FSSTAT 0 0.00%
122		FSINFO 0 0.00%
123		PATHCONF 0 0.00%
124		COMMIT 0 0.00%
	5	NFS v3 protocol: Data transmission has not been detected.
125	6	### Breakdown analyzer ###
126	7	NFS v4.0 protocol
127	8	Total procedures: 1607. Per procedure:

213	94	RELEASE_LOCKOWNER Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
214	95	GET_DIR_DELEGATION Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
215	96	### Breakdown analyzer ###
216		NFS v4.1 protocol
217		Total procedures: 0. Per procedure:
218		NULL 0 0.00%
219		COMPOUND 0 0.00%
220		Total operations: 0. Per operation:
221		ILLEGAL 0 0.00%
222		ACCESS 0 0.00%
223		CLOSE 0 0.00%
224		COMMIT 0 0.00%
225		CREATE 0 0.00%
226		DELEGPURGE 0 0.00%
227		DELEGRETURN 0 0.00%
228		GETATTR 0 0.00%
229		GETFH 0 0.00%
230		LINK 0 0.00%
231		LOCK 0 0.00%
232		LOCKT 0 0.00%
233		LOCKU 0 0.00%
234		LOOKUP 0 0.00%
235		LOOKUPP 0 0.00%
236		NVERIFY 0 0.00%
237		OPEN 0 0.00%
238		OPENATTR 0 0.00%
239		OPEN_CONFIRM 0 0.00%
240		OPEN_DOWNGRADE 0 0.00%
241		PUTFH 0 0.00%
242		PUTPUBFH 0 0.00%
243		PUTROOTFH 0 0.00%
244		READ 0 0.00%
245		READDIR 0 0.00%
246		READLINK 0 0.00%
247		REMOVE 0 0.00%
248		RENAME 0 0.00%
249		RENEW 0 0.00%
250		RESTOREFH 0 0.00%
251		SAVEFH 0 0.00%
252		SECINFO 0 0.00%
253		SETATTR 0 0.00%
254		SETCLIENTID 0 0.00%
255		SETCLIENTID_CONFIRM 0 0.00%
256		VERIFY 0 0.00%
257		WRITE 0 0.00%
258		RELEASE_LOCKOWNER 0 0.00%
259		BACKCHANNEL_CTL 0 0.00%
260		BIND_CONN_TO_SESSION 0 0.00%
261		EXCHANGE_ID 0 0.00%
262		CREATE_SESSION 0 0.00%
263		DESTROY_SESSION 0 0.00%
264		FREE_STATEID 0 0.00%
265		GET_DIR_DELEGATION 0 0.00%
266		GETDEVICEINFO 0 0.00%
267		GETDEVICELIST 0 0.00%
268		LAYOUTCOMMIT 0 0.00%
269		LAYOUTGET 0 0.00%
270		LAYOUTRETURN 0 0.00%
271		SECINFO_NO_NAME 0 0.00%
272		SEQUENCE 0 0.00%
273		SET_SSV 0 0.00%
274		TEST_STATEID 0 0.00%
275		WANT_DELEGATION 0 0.00%
276		DESTROY_CLIENTID 0 0.00%
277		RECLAIM_COMPLETE 0 0.00%
	97	NFS v4.1 protocol: Data transmission has not been detected.

-124

traces/references/breakdown/eth-ipv4-tcp-nfsv41.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
78		### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
100		### Breakdown analyzer ###
101		NFS v3 protocol
102		Total operations: 0. Per operation:
103		NULL 0 0.00%
104		GETATTR 0 0.00%
105		SETATTR 0 0.00%
106		LOOKUP 0 0.00%
107		ACCESS 0 0.00%
108		READLINK 0 0.00%
109		READ 0 0.00%
110		WRITE 0 0.00%
111		CREATE 0 0.00%
112		MKDIR 0 0.00%
113		SYMLINK 0 0.00%
114		MKNOD 0 0.00%
115		REMOVE 0 0.00%
116		RMDIR 0 0.00%
117		RENAME 0 0.00%
118		LINK 0 0.00%
119		READDIR 0 0.00%
120		READDIRPLUS 0 0.00%
121		FSSTAT 0 0.00%
122		FSINFO 0 0.00%
123		PATHCONF 0 0.00%
124		COMMIT 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
	2	### Breakdown analyzer ###
	3	CIFS v2 protocol: Data transmission has not been detected.
	4	### Breakdown analyzer ###
	5	NFS v3 protocol: Data transmission has not been detected.
125	6	### Breakdown analyzer ###
126	7	NFS v4.0 protocol
127	8	Total procedures: 1. Per procedure:

-207

traces/references/breakdown/eth-ipv4-tcp-smb2-putty.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79	3	CIFS v2 protocol
80	4	Total operations: 35. Per operation:

120	44	SET INFO Count: 2 ( 5.71%) Min: 0.000 Max: 0.001 Avg: 0.001 StDev: 0.00039244
121	45	OPLOCK BREAK Count: 1 ( 2.86%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
122	46	### Breakdown analyzer ###
123		NFS v3 protocol
124		Total operations: 0. Per operation:
125		NULL 0 0.00%
126		GETATTR 0 0.00%
127		SETATTR 0 0.00%
128		LOOKUP 0 0.00%
129		ACCESS 0 0.00%
130		READLINK 0 0.00%
131		READ 0 0.00%
132		WRITE 0 0.00%
133		CREATE 0 0.00%
134		MKDIR 0 0.00%
135		SYMLINK 0 0.00%
136		MKNOD 0 0.00%
137		REMOVE 0 0.00%
138		RMDIR 0 0.00%
139		RENAME 0 0.00%
140		LINK 0 0.00%
141		READDIR 0 0.00%
142		READDIRPLUS 0 0.00%
143		FSSTAT 0 0.00%
144		FSINFO 0 0.00%
145		PATHCONF 0 0.00%
146		COMMIT 0 0.00%
	47	NFS v3 protocol: Data transmission has not been detected.
147	48	### Breakdown analyzer ###
148		NFS v4.0 protocol
149		Total procedures: 0. Per procedure:
150		NULL 0 0.00%
151		COMPOUND 0 0.00%
152		Total operations: 0. Per operation:
153		ILLEGAL 0 0.00%
154		ACCESS 0 0.00%
155		CLOSE 0 0.00%
156		COMMIT 0 0.00%
157		CREATE 0 0.00%
158		DELEGPURGE 0 0.00%
159		DELEGRETURN 0 0.00%
160		GETATTR 0 0.00%
161		GETFH 0 0.00%
162		LINK 0 0.00%
163		LOCK 0 0.00%
164		LOCKT 0 0.00%
165		LOCKU 0 0.00%
166		LOOKUP 0 0.00%
167		LOOKUPP 0 0.00%
168		NVERIFY 0 0.00%
169		OPEN 0 0.00%
170		OPENATTR 0 0.00%
171		OPEN_CONFIRM 0 0.00%
172		OPEN_DOWNGRADE 0 0.00%
173		PUTFH 0 0.00%
174		PUTPUBFH 0 0.00%
175		PUTROOTFH 0 0.00%
176		READ 0 0.00%
177		READDIR 0 0.00%
178		READLINK 0 0.00%
179		REMOVE 0 0.00%
180		RENAME 0 0.00%
181		RENEW 0 0.00%
182		RESTOREFH 0 0.00%
183		SAVEFH 0 0.00%
184		SECINFO 0 0.00%
185		SETATTR 0 0.00%
186		SETCLIENTID 0 0.00%
187		SETCLIENTID_CONFIRM 0 0.00%
188		VERIFY 0 0.00%
189		WRITE 0 0.00%
190		RELEASE_LOCKOWNER 0 0.00%
191		GET_DIR_DELEGATION 0 0.00%
	49	NFS v4.0 protocol: Data transmission has not been detected.
192	50	### Breakdown analyzer ###
193		NFS v4.1 protocol
194		Total procedures: 0. Per procedure:
195		NULL 0 0.00%
196		COMPOUND 0 0.00%
197		Total operations: 0. Per operation:
198		ILLEGAL 0 0.00%
199		ACCESS 0 0.00%
200		CLOSE 0 0.00%
201		COMMIT 0 0.00%
202		CREATE 0 0.00%
203		DELEGPURGE 0 0.00%
204		DELEGRETURN 0 0.00%
205		GETATTR 0 0.00%
206		GETFH 0 0.00%
207		LINK 0 0.00%
208		LOCK 0 0.00%
209		LOCKT 0 0.00%
210		LOCKU 0 0.00%
211		LOOKUP 0 0.00%
212		LOOKUPP 0 0.00%
213		NVERIFY 0 0.00%
214		OPEN 0 0.00%
215		OPENATTR 0 0.00%
216		OPEN_CONFIRM 0 0.00%
217		OPEN_DOWNGRADE 0 0.00%
218		PUTFH 0 0.00%
219		PUTPUBFH 0 0.00%
220		PUTROOTFH 0 0.00%
221		READ 0 0.00%
222		READDIR 0 0.00%
223		READLINK 0 0.00%
224		REMOVE 0 0.00%
225		RENAME 0 0.00%
226		RENEW 0 0.00%
227		RESTOREFH 0 0.00%
228		SAVEFH 0 0.00%
229		SECINFO 0 0.00%
230		SETATTR 0 0.00%
231		SETCLIENTID 0 0.00%
232		SETCLIENTID_CONFIRM 0 0.00%
233		VERIFY 0 0.00%
234		WRITE 0 0.00%
235		RELEASE_LOCKOWNER 0 0.00%
236		BACKCHANNEL_CTL 0 0.00%
237		BIND_CONN_TO_SESSION 0 0.00%
238		EXCHANGE_ID 0 0.00%
239		CREATE_SESSION 0 0.00%
240		DESTROY_SESSION 0 0.00%
241		FREE_STATEID 0 0.00%
242		GET_DIR_DELEGATION 0 0.00%
243		GETDEVICEINFO 0 0.00%
244		GETDEVICELIST 0 0.00%
245		LAYOUTCOMMIT 0 0.00%
246		LAYOUTGET 0 0.00%
247		LAYOUTRETURN 0 0.00%
248		SECINFO_NO_NAME 0 0.00%
249		SEQUENCE 0 0.00%
250		SET_SSV 0 0.00%
251		TEST_STATEID 0 0.00%
252		WANT_DELEGATION 0 0.00%
253		DESTROY_CLIENTID 0 0.00%
254		RECLAIM_COMPLETE 0 0.00%
	51	NFS v4.1 protocol: Data transmission has not been detected.

-207

traces/references/breakdown/eth-ipv4-tcp-smb2-zero-file-rw.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79	3	CIFS v2 protocol
80	4	Total operations: 928. Per operation:

120	44	SET INFO Count: 6 ( 0.65%) Min: 0.000 Max: 0.001 Avg: 0.000 StDev: 0.00009635
121	45	OPLOCK BREAK Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
122	46	### Breakdown analyzer ###
123		NFS v3 protocol
124		Total operations: 0. Per operation:
125		NULL 0 0.00%
126		GETATTR 0 0.00%
127		SETATTR 0 0.00%
128		LOOKUP 0 0.00%
129		ACCESS 0 0.00%
130		READLINK 0 0.00%
131		READ 0 0.00%
132		WRITE 0 0.00%
133		CREATE 0 0.00%
134		MKDIR 0 0.00%
135		SYMLINK 0 0.00%
136		MKNOD 0 0.00%
137		REMOVE 0 0.00%
138		RMDIR 0 0.00%
139		RENAME 0 0.00%
140		LINK 0 0.00%
141		READDIR 0 0.00%
142		READDIRPLUS 0 0.00%
143		FSSTAT 0 0.00%
144		FSINFO 0 0.00%
145		PATHCONF 0 0.00%
146		COMMIT 0 0.00%
	47	NFS v3 protocol: Data transmission has not been detected.
147	48	### Breakdown analyzer ###
148		NFS v4.0 protocol
149		Total procedures: 0. Per procedure:
150		NULL 0 0.00%
151		COMPOUND 0 0.00%
152		Total operations: 0. Per operation:
153		ILLEGAL 0 0.00%
154		ACCESS 0 0.00%
155		CLOSE 0 0.00%
156		COMMIT 0 0.00%
157		CREATE 0 0.00%
158		DELEGPURGE 0 0.00%
159		DELEGRETURN 0 0.00%
160		GETATTR 0 0.00%
161		GETFH 0 0.00%
162		LINK 0 0.00%
163		LOCK 0 0.00%
164		LOCKT 0 0.00%
165		LOCKU 0 0.00%
166		LOOKUP 0 0.00%
167		LOOKUPP 0 0.00%
168		NVERIFY 0 0.00%
169		OPEN 0 0.00%
170		OPENATTR 0 0.00%
171		OPEN_CONFIRM 0 0.00%
172		OPEN_DOWNGRADE 0 0.00%
173		PUTFH 0 0.00%
174		PUTPUBFH 0 0.00%
175		PUTROOTFH 0 0.00%
176		READ 0 0.00%
177		READDIR 0 0.00%
178		READLINK 0 0.00%
179		REMOVE 0 0.00%
180		RENAME 0 0.00%
181		RENEW 0 0.00%
182		RESTOREFH 0 0.00%
183		SAVEFH 0 0.00%
184		SECINFO 0 0.00%
185		SETATTR 0 0.00%
186		SETCLIENTID 0 0.00%
187		SETCLIENTID_CONFIRM 0 0.00%
188		VERIFY 0 0.00%
189		WRITE 0 0.00%
190		RELEASE_LOCKOWNER 0 0.00%
191		GET_DIR_DELEGATION 0 0.00%
	49	NFS v4.0 protocol: Data transmission has not been detected.
192	50	### Breakdown analyzer ###
193		NFS v4.1 protocol
194		Total procedures: 0. Per procedure:
195		NULL 0 0.00%
196		COMPOUND 0 0.00%
197		Total operations: 0. Per operation:
198		ILLEGAL 0 0.00%
199		ACCESS 0 0.00%
200		CLOSE 0 0.00%
201		COMMIT 0 0.00%
202		CREATE 0 0.00%
203		DELEGPURGE 0 0.00%
204		DELEGRETURN 0 0.00%
205		GETATTR 0 0.00%
206		GETFH 0 0.00%
207		LINK 0 0.00%
208		LOCK 0 0.00%
209		LOCKT 0 0.00%
210		LOCKU 0 0.00%
211		LOOKUP 0 0.00%
212		LOOKUPP 0 0.00%
213		NVERIFY 0 0.00%
214		OPEN 0 0.00%
215		OPENATTR 0 0.00%
216		OPEN_CONFIRM 0 0.00%
217		OPEN_DOWNGRADE 0 0.00%
218		PUTFH 0 0.00%
219		PUTPUBFH 0 0.00%
220		PUTROOTFH 0 0.00%
221		READ 0 0.00%
222		READDIR 0 0.00%
223		READLINK 0 0.00%
224		REMOVE 0 0.00%
225		RENAME 0 0.00%
226		RENEW 0 0.00%
227		RESTOREFH 0 0.00%
228		SAVEFH 0 0.00%
229		SECINFO 0 0.00%
230		SETATTR 0 0.00%
231		SETCLIENTID 0 0.00%
232		SETCLIENTID_CONFIRM 0 0.00%
233		VERIFY 0 0.00%
234		WRITE 0 0.00%
235		RELEASE_LOCKOWNER 0 0.00%
236		BACKCHANNEL_CTL 0 0.00%
237		BIND_CONN_TO_SESSION 0 0.00%
238		EXCHANGE_ID 0 0.00%
239		CREATE_SESSION 0 0.00%
240		DESTROY_SESSION 0 0.00%
241		FREE_STATEID 0 0.00%
242		GET_DIR_DELEGATION 0 0.00%
243		GETDEVICEINFO 0 0.00%
244		GETDEVICELIST 0 0.00%
245		LAYOUTCOMMIT 0 0.00%
246		LAYOUTGET 0 0.00%
247		LAYOUTRETURN 0 0.00%
248		SECINFO_NO_NAME 0 0.00%
249		SEQUENCE 0 0.00%
250		SET_SSV 0 0.00%
251		TEST_STATEID 0 0.00%
252		WANT_DELEGATION 0 0.00%
253		DESTROY_CLIENTID 0 0.00%
254		RECLAIM_COMPLETE 0 0.00%
	51	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/eth-ipv4-udp-nfsv3-dup-retransm.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 11. Per operation:

148	52	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
149	53	COMMIT Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
150	54	### Breakdown analyzer ###
151		NFS v4.0 protocol
152		Total procedures: 0. Per procedure:
153		NULL 0 0.00%
154		COMPOUND 0 0.00%
155		Total operations: 0. Per operation:
156		ILLEGAL 0 0.00%
157		ACCESS 0 0.00%
158		CLOSE 0 0.00%
159		COMMIT 0 0.00%
160		CREATE 0 0.00%
161		DELEGPURGE 0 0.00%
162		DELEGRETURN 0 0.00%
163		GETATTR 0 0.00%
164		GETFH 0 0.00%
165		LINK 0 0.00%
166		LOCK 0 0.00%
167		LOCKT 0 0.00%
168		LOCKU 0 0.00%
169		LOOKUP 0 0.00%
170		LOOKUPP 0 0.00%
171		NVERIFY 0 0.00%
172		OPEN 0 0.00%
173		OPENATTR 0 0.00%
174		OPEN_CONFIRM 0 0.00%
175		OPEN_DOWNGRADE 0 0.00%
176		PUTFH 0 0.00%
177		PUTPUBFH 0 0.00%
178		PUTROOTFH 0 0.00%
179		READ 0 0.00%
180		READDIR 0 0.00%
181		READLINK 0 0.00%
182		REMOVE 0 0.00%
183		RENAME 0 0.00%
184		RENEW 0 0.00%
185		RESTOREFH 0 0.00%
186		SAVEFH 0 0.00%
187		SECINFO 0 0.00%
188		SETATTR 0 0.00%
189		SETCLIENTID 0 0.00%
190		SETCLIENTID_CONFIRM 0 0.00%
191		VERIFY 0 0.00%
192		WRITE 0 0.00%
193		RELEASE_LOCKOWNER 0 0.00%
194		GET_DIR_DELEGATION 0 0.00%
	55	NFS v4.0 protocol: Data transmission has not been detected.
195	56	### Breakdown analyzer ###
196		NFS v4.1 protocol
197		Total procedures: 0. Per procedure:
198		NULL 0 0.00%
199		COMPOUND 0 0.00%
200		Total operations: 0. Per operation:
201		ILLEGAL 0 0.00%
202		ACCESS 0 0.00%
203		CLOSE 0 0.00%
204		COMMIT 0 0.00%
205		CREATE 0 0.00%
206		DELEGPURGE 0 0.00%
207		DELEGRETURN 0 0.00%
208		GETATTR 0 0.00%
209		GETFH 0 0.00%
210		LINK 0 0.00%
211		LOCK 0 0.00%
212		LOCKT 0 0.00%
213		LOCKU 0 0.00%
214		LOOKUP 0 0.00%
215		LOOKUPP 0 0.00%
216		NVERIFY 0 0.00%
217		OPEN 0 0.00%
218		OPENATTR 0 0.00%
219		OPEN_CONFIRM 0 0.00%
220		OPEN_DOWNGRADE 0 0.00%
221		PUTFH 0 0.00%
222		PUTPUBFH 0 0.00%
223		PUTROOTFH 0 0.00%
224		READ 0 0.00%
225		READDIR 0 0.00%
226		READLINK 0 0.00%
227		REMOVE 0 0.00%
228		RENAME 0 0.00%
229		RENEW 0 0.00%
230		RESTOREFH 0 0.00%
231		SAVEFH 0 0.00%
232		SECINFO 0 0.00%
233		SETATTR 0 0.00%
234		SETCLIENTID 0 0.00%
235		SETCLIENTID_CONFIRM 0 0.00%
236		VERIFY 0 0.00%
237		WRITE 0 0.00%
238		RELEASE_LOCKOWNER 0 0.00%
239		BACKCHANNEL_CTL 0 0.00%
240		BIND_CONN_TO_SESSION 0 0.00%
241		EXCHANGE_ID 0 0.00%
242		CREATE_SESSION 0 0.00%
243		DESTROY_SESSION 0 0.00%
244		FREE_STATEID 0 0.00%
245		GET_DIR_DELEGATION 0 0.00%
246		GETDEVICEINFO 0 0.00%
247		GETDEVICELIST 0 0.00%
248		LAYOUTCOMMIT 0 0.00%
249		LAYOUTGET 0 0.00%
250		LAYOUTRETURN 0 0.00%
251		SECINFO_NO_NAME 0 0.00%
252		SEQUENCE 0 0.00%
253		SET_SSV 0 0.00%
254		TEST_STATEID 0 0.00%
255		WANT_DELEGATION 0 0.00%
256		DESTROY_CLIENTID 0 0.00%
257		RECLAIM_COMPLETE 0 0.00%
	57	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/eth-ipv4-udp-nfsv3-reply-first.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 57. Per operation:

172	76	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
173	77	COMMIT Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
174	78	### Breakdown analyzer ###
175		NFS v4.0 protocol
176		Total procedures: 0. Per procedure:
177		NULL 0 0.00%
178		COMPOUND 0 0.00%
179		Total operations: 0. Per operation:
180		ILLEGAL 0 0.00%
181		ACCESS 0 0.00%
182		CLOSE 0 0.00%
183		COMMIT 0 0.00%
184		CREATE 0 0.00%
185		DELEGPURGE 0 0.00%
186		DELEGRETURN 0 0.00%
187		GETATTR 0 0.00%
188		GETFH 0 0.00%
189		LINK 0 0.00%
190		LOCK 0 0.00%
191		LOCKT 0 0.00%
192		LOCKU 0 0.00%
193		LOOKUP 0 0.00%
194		LOOKUPP 0 0.00%
195		NVERIFY 0 0.00%
196		OPEN 0 0.00%
197		OPENATTR 0 0.00%
198		OPEN_CONFIRM 0 0.00%
199		OPEN_DOWNGRADE 0 0.00%
200		PUTFH 0 0.00%
201		PUTPUBFH 0 0.00%
202		PUTROOTFH 0 0.00%
203		READ 0 0.00%
204		READDIR 0 0.00%
205		READLINK 0 0.00%
206		REMOVE 0 0.00%
207		RENAME 0 0.00%
208		RENEW 0 0.00%
209		RESTOREFH 0 0.00%
210		SAVEFH 0 0.00%
211		SECINFO 0 0.00%
212		SETATTR 0 0.00%
213		SETCLIENTID 0 0.00%
214		SETCLIENTID_CONFIRM 0 0.00%
215		VERIFY 0 0.00%
216		WRITE 0 0.00%
217		RELEASE_LOCKOWNER 0 0.00%
218		GET_DIR_DELEGATION 0 0.00%
	79	NFS v4.0 protocol: Data transmission has not been detected.
219	80	### Breakdown analyzer ###
220		NFS v4.1 protocol
221		Total procedures: 0. Per procedure:
222		NULL 0 0.00%
223		COMPOUND 0 0.00%
224		Total operations: 0. Per operation:
225		ILLEGAL 0 0.00%
226		ACCESS 0 0.00%
227		CLOSE 0 0.00%
228		COMMIT 0 0.00%
229		CREATE 0 0.00%
230		DELEGPURGE 0 0.00%
231		DELEGRETURN 0 0.00%
232		GETATTR 0 0.00%
233		GETFH 0 0.00%
234		LINK 0 0.00%
235		LOCK 0 0.00%
236		LOCKT 0 0.00%
237		LOCKU 0 0.00%
238		LOOKUP 0 0.00%
239		LOOKUPP 0 0.00%
240		NVERIFY 0 0.00%
241		OPEN 0 0.00%
242		OPENATTR 0 0.00%
243		OPEN_CONFIRM 0 0.00%
244		OPEN_DOWNGRADE 0 0.00%
245		PUTFH 0 0.00%
246		PUTPUBFH 0 0.00%
247		PUTROOTFH 0 0.00%
248		READ 0 0.00%
249		READDIR 0 0.00%
250		READLINK 0 0.00%
251		REMOVE 0 0.00%
252		RENAME 0 0.00%
253		RENEW 0 0.00%
254		RESTOREFH 0 0.00%
255		SAVEFH 0 0.00%
256		SECINFO 0 0.00%
257		SETATTR 0 0.00%
258		SETCLIENTID 0 0.00%
259		SETCLIENTID_CONFIRM 0 0.00%
260		VERIFY 0 0.00%
261		WRITE 0 0.00%
262		RELEASE_LOCKOWNER 0 0.00%
263		BACKCHANNEL_CTL 0 0.00%
264		BIND_CONN_TO_SESSION 0 0.00%
265		EXCHANGE_ID 0 0.00%
266		CREATE_SESSION 0 0.00%
267		DESTROY_SESSION 0 0.00%
268		FREE_STATEID 0 0.00%
269		GET_DIR_DELEGATION 0 0.00%
270		GETDEVICEINFO 0 0.00%
271		GETDEVICELIST 0 0.00%
272		LAYOUTCOMMIT 0 0.00%
273		LAYOUTGET 0 0.00%
274		LAYOUTRETURN 0 0.00%
275		SECINFO_NO_NAME 0 0.00%
276		SEQUENCE 0 0.00%
277		SET_SSV 0 0.00%
278		TEST_STATEID 0 0.00%
279		WANT_DELEGATION 0 0.00%
280		DESTROY_CLIENTID 0 0.00%
281		RECLAIM_COMPLETE 0 0.00%
	81	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/eth-ipv4-udp-nfsv3.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 58. Per operation:

172	76	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
173	77	COMMIT Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
174	78	### Breakdown analyzer ###
175		NFS v4.0 protocol
176		Total procedures: 0. Per procedure:
177		NULL 0 0.00%
178		COMPOUND 0 0.00%
179		Total operations: 0. Per operation:
180		ILLEGAL 0 0.00%
181		ACCESS 0 0.00%
182		CLOSE 0 0.00%
183		COMMIT 0 0.00%
184		CREATE 0 0.00%
185		DELEGPURGE 0 0.00%
186		DELEGRETURN 0 0.00%
187		GETATTR 0 0.00%
188		GETFH 0 0.00%
189		LINK 0 0.00%
190		LOCK 0 0.00%
191		LOCKT 0 0.00%
192		LOCKU 0 0.00%
193		LOOKUP 0 0.00%
194		LOOKUPP 0 0.00%
195		NVERIFY 0 0.00%
196		OPEN 0 0.00%
197		OPENATTR 0 0.00%
198		OPEN_CONFIRM 0 0.00%
199		OPEN_DOWNGRADE 0 0.00%
200		PUTFH 0 0.00%
201		PUTPUBFH 0 0.00%
202		PUTROOTFH 0 0.00%
203		READ 0 0.00%
204		READDIR 0 0.00%
205		READLINK 0 0.00%
206		REMOVE 0 0.00%
207		RENAME 0 0.00%
208		RENEW 0 0.00%
209		RESTOREFH 0 0.00%
210		SAVEFH 0 0.00%
211		SECINFO 0 0.00%
212		SETATTR 0 0.00%
213		SETCLIENTID 0 0.00%
214		SETCLIENTID_CONFIRM 0 0.00%
215		VERIFY 0 0.00%
216		WRITE 0 0.00%
217		RELEASE_LOCKOWNER 0 0.00%
218		GET_DIR_DELEGATION 0 0.00%
	79	NFS v4.0 protocol: Data transmission has not been detected.
219	80	### Breakdown analyzer ###
220		NFS v4.1 protocol
221		Total procedures: 0. Per procedure:
222		NULL 0 0.00%
223		COMPOUND 0 0.00%
224		Total operations: 0. Per operation:
225		ILLEGAL 0 0.00%
226		ACCESS 0 0.00%
227		CLOSE 0 0.00%
228		COMMIT 0 0.00%
229		CREATE 0 0.00%
230		DELEGPURGE 0 0.00%
231		DELEGRETURN 0 0.00%
232		GETATTR 0 0.00%
233		GETFH 0 0.00%
234		LINK 0 0.00%
235		LOCK 0 0.00%
236		LOCKT 0 0.00%
237		LOCKU 0 0.00%
238		LOOKUP 0 0.00%
239		LOOKUPP 0 0.00%
240		NVERIFY 0 0.00%
241		OPEN 0 0.00%
242		OPENATTR 0 0.00%
243		OPEN_CONFIRM 0 0.00%
244		OPEN_DOWNGRADE 0 0.00%
245		PUTFH 0 0.00%
246		PUTPUBFH 0 0.00%
247		PUTROOTFH 0 0.00%
248		READ 0 0.00%
249		READDIR 0 0.00%
250		READLINK 0 0.00%
251		REMOVE 0 0.00%
252		RENAME 0 0.00%
253		RENEW 0 0.00%
254		RESTOREFH 0 0.00%
255		SAVEFH 0 0.00%
256		SECINFO 0 0.00%
257		SETATTR 0 0.00%
258		SETCLIENTID 0 0.00%
259		SETCLIENTID_CONFIRM 0 0.00%
260		VERIFY 0 0.00%
261		WRITE 0 0.00%
262		RELEASE_LOCKOWNER 0 0.00%
263		BACKCHANNEL_CTL 0 0.00%
264		BIND_CONN_TO_SESSION 0 0.00%
265		EXCHANGE_ID 0 0.00%
266		CREATE_SESSION 0 0.00%
267		DESTROY_SESSION 0 0.00%
268		FREE_STATEID 0 0.00%
269		GET_DIR_DELEGATION 0 0.00%
270		GETDEVICEINFO 0 0.00%
271		GETDEVICELIST 0 0.00%
272		LAYOUTCOMMIT 0 0.00%
273		LAYOUTGET 0 0.00%
274		LAYOUTRETURN 0 0.00%
275		SECINFO_NO_NAME 0 0.00%
276		SEQUENCE 0 0.00%
277		SET_SSV 0 0.00%
278		TEST_STATEID 0 0.00%
279		WANT_DELEGATION 0 0.00%
280		DESTROY_CLIENTID 0 0.00%
281		RECLAIM_COMPLETE 0 0.00%
	81	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/eth-ipv6-tcp-nfsv3-bad_alloc.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 28179. Per operation:

148	52	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
149	53	COMMIT Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
150	54	### Breakdown analyzer ###
151		NFS v4.0 protocol
152		Total procedures: 0. Per procedure:
153		NULL 0 0.00%
154		COMPOUND 0 0.00%
155		Total operations: 0. Per operation:
156		ILLEGAL 0 0.00%
157		ACCESS 0 0.00%
158		CLOSE 0 0.00%
159		COMMIT 0 0.00%
160		CREATE 0 0.00%
161		DELEGPURGE 0 0.00%
162		DELEGRETURN 0 0.00%
163		GETATTR 0 0.00%
164		GETFH 0 0.00%
165		LINK 0 0.00%
166		LOCK 0 0.00%
167		LOCKT 0 0.00%
168		LOCKU 0 0.00%
169		LOOKUP 0 0.00%
170		LOOKUPP 0 0.00%
171		NVERIFY 0 0.00%
172		OPEN 0 0.00%
173		OPENATTR 0 0.00%
174		OPEN_CONFIRM 0 0.00%
175		OPEN_DOWNGRADE 0 0.00%
176		PUTFH 0 0.00%
177		PUTPUBFH 0 0.00%
178		PUTROOTFH 0 0.00%
179		READ 0 0.00%
180		READDIR 0 0.00%
181		READLINK 0 0.00%
182		REMOVE 0 0.00%
183		RENAME 0 0.00%
184		RENEW 0 0.00%
185		RESTOREFH 0 0.00%
186		SAVEFH 0 0.00%
187		SECINFO 0 0.00%
188		SETATTR 0 0.00%
189		SETCLIENTID 0 0.00%
190		SETCLIENTID_CONFIRM 0 0.00%
191		VERIFY 0 0.00%
192		WRITE 0 0.00%
193		RELEASE_LOCKOWNER 0 0.00%
194		GET_DIR_DELEGATION 0 0.00%
	55	NFS v4.0 protocol: Data transmission has not been detected.
195	56	### Breakdown analyzer ###
196		NFS v4.1 protocol
197		Total procedures: 0. Per procedure:
198		NULL 0 0.00%
199		COMPOUND 0 0.00%
200		Total operations: 0. Per operation:
201		ILLEGAL 0 0.00%
202		ACCESS 0 0.00%
203		CLOSE 0 0.00%
204		COMMIT 0 0.00%
205		CREATE 0 0.00%
206		DELEGPURGE 0 0.00%
207		DELEGRETURN 0 0.00%
208		GETATTR 0 0.00%
209		GETFH 0 0.00%
210		LINK 0 0.00%
211		LOCK 0 0.00%
212		LOCKT 0 0.00%
213		LOCKU 0 0.00%
214		LOOKUP 0 0.00%
215		LOOKUPP 0 0.00%
216		NVERIFY 0 0.00%
217		OPEN 0 0.00%
218		OPENATTR 0 0.00%
219		OPEN_CONFIRM 0 0.00%
220		OPEN_DOWNGRADE 0 0.00%
221		PUTFH 0 0.00%
222		PUTPUBFH 0 0.00%
223		PUTROOTFH 0 0.00%
224		READ 0 0.00%
225		READDIR 0 0.00%
226		READLINK 0 0.00%
227		REMOVE 0 0.00%
228		RENAME 0 0.00%
229		RENEW 0 0.00%
230		RESTOREFH 0 0.00%
231		SAVEFH 0 0.00%
232		SECINFO 0 0.00%
233		SETATTR 0 0.00%
234		SETCLIENTID 0 0.00%
235		SETCLIENTID_CONFIRM 0 0.00%
236		VERIFY 0 0.00%
237		WRITE 0 0.00%
238		RELEASE_LOCKOWNER 0 0.00%
239		BACKCHANNEL_CTL 0 0.00%
240		BIND_CONN_TO_SESSION 0 0.00%
241		EXCHANGE_ID 0 0.00%
242		CREATE_SESSION 0 0.00%
243		DESTROY_SESSION 0 0.00%
244		FREE_STATEID 0 0.00%
245		GET_DIR_DELEGATION 0 0.00%
246		GETDEVICEINFO 0 0.00%
247		GETDEVICELIST 0 0.00%
248		LAYOUTCOMMIT 0 0.00%
249		LAYOUTGET 0 0.00%
250		LAYOUTRETURN 0 0.00%
251		SECINFO_NO_NAME 0 0.00%
252		SEQUENCE 0 0.00%
253		SET_SSV 0 0.00%
254		TEST_STATEID 0 0.00%
255		WANT_DELEGATION 0 0.00%
256		DESTROY_CLIENTID 0 0.00%
257		RECLAIM_COMPLETE 0 0.00%
	57	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/eth-ipv6-tcp-nfsv3.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 1605. Per operation:

148	52	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
149	53	COMMIT Count: 1 ( 0.06%) Min: 0.854 Max: 0.854 Avg: 0.854 StDev: 0.00000000
150	54	### Breakdown analyzer ###
151		NFS v4.0 protocol
152		Total procedures: 0. Per procedure:
153		NULL 0 0.00%
154		COMPOUND 0 0.00%
155		Total operations: 0. Per operation:
156		ILLEGAL 0 0.00%
157		ACCESS 0 0.00%
158		CLOSE 0 0.00%
159		COMMIT 0 0.00%
160		CREATE 0 0.00%
161		DELEGPURGE 0 0.00%
162		DELEGRETURN 0 0.00%
163		GETATTR 0 0.00%
164		GETFH 0 0.00%
165		LINK 0 0.00%
166		LOCK 0 0.00%
167		LOCKT 0 0.00%
168		LOCKU 0 0.00%
169		LOOKUP 0 0.00%
170		LOOKUPP 0 0.00%
171		NVERIFY 0 0.00%
172		OPEN 0 0.00%
173		OPENATTR 0 0.00%
174		OPEN_CONFIRM 0 0.00%
175		OPEN_DOWNGRADE 0 0.00%
176		PUTFH 0 0.00%
177		PUTPUBFH 0 0.00%
178		PUTROOTFH 0 0.00%
179		READ 0 0.00%
180		READDIR 0 0.00%
181		READLINK 0 0.00%
182		REMOVE 0 0.00%
183		RENAME 0 0.00%
184		RENEW 0 0.00%
185		RESTOREFH 0 0.00%
186		SAVEFH 0 0.00%
187		SECINFO 0 0.00%
188		SETATTR 0 0.00%
189		SETCLIENTID 0 0.00%
190		SETCLIENTID_CONFIRM 0 0.00%
191		VERIFY 0 0.00%
192		WRITE 0 0.00%
193		RELEASE_LOCKOWNER 0 0.00%
194		GET_DIR_DELEGATION 0 0.00%
	55	NFS v4.0 protocol: Data transmission has not been detected.
195	56	### Breakdown analyzer ###
196		NFS v4.1 protocol
197		Total procedures: 0. Per procedure:
198		NULL 0 0.00%
199		COMPOUND 0 0.00%
200		Total operations: 0. Per operation:
201		ILLEGAL 0 0.00%
202		ACCESS 0 0.00%
203		CLOSE 0 0.00%
204		COMMIT 0 0.00%
205		CREATE 0 0.00%
206		DELEGPURGE 0 0.00%
207		DELEGRETURN 0 0.00%
208		GETATTR 0 0.00%
209		GETFH 0 0.00%
210		LINK 0 0.00%
211		LOCK 0 0.00%
212		LOCKT 0 0.00%
213		LOCKU 0 0.00%
214		LOOKUP 0 0.00%
215		LOOKUPP 0 0.00%
216		NVERIFY 0 0.00%
217		OPEN 0 0.00%
218		OPENATTR 0 0.00%
219		OPEN_CONFIRM 0 0.00%
220		OPEN_DOWNGRADE 0 0.00%
221		PUTFH 0 0.00%
222		PUTPUBFH 0 0.00%
223		PUTROOTFH 0 0.00%
224		READ 0 0.00%
225		READDIR 0 0.00%
226		READLINK 0 0.00%
227		REMOVE 0 0.00%
228		RENAME 0 0.00%
229		RENEW 0 0.00%
230		RESTOREFH 0 0.00%
231		SAVEFH 0 0.00%
232		SECINFO 0 0.00%
233		SETATTR 0 0.00%
234		SETCLIENTID 0 0.00%
235		SETCLIENTID_CONFIRM 0 0.00%
236		VERIFY 0 0.00%
237		WRITE 0 0.00%
238		RELEASE_LOCKOWNER 0 0.00%
239		BACKCHANNEL_CTL 0 0.00%
240		BIND_CONN_TO_SESSION 0 0.00%
241		EXCHANGE_ID 0 0.00%
242		CREATE_SESSION 0 0.00%
243		DESTROY_SESSION 0 0.00%
244		FREE_STATEID 0 0.00%
245		GET_DIR_DELEGATION 0 0.00%
246		GETDEVICEINFO 0 0.00%
247		GETDEVICELIST 0 0.00%
248		LAYOUTCOMMIT 0 0.00%
249		LAYOUTGET 0 0.00%
250		LAYOUTRETURN 0 0.00%
251		SECINFO_NO_NAME 0 0.00%
252		SEQUENCE 0 0.00%
253		SET_SSV 0 0.00%
254		TEST_STATEID 0 0.00%
255		WANT_DELEGATION 0 0.00%
256		DESTROY_CLIENTID 0 0.00%
257		RECLAIM_COMPLETE 0 0.00%
	57	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/lo-ipv4-tcp-nfsv3-nfsacl.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 7. Per operation:

172	76	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
173	77	COMMIT Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
174	78	### Breakdown analyzer ###
175		NFS v4.0 protocol
176		Total procedures: 0. Per procedure:
177		NULL 0 0.00%
178		COMPOUND 0 0.00%
179		Total operations: 0. Per operation:
180		ILLEGAL 0 0.00%
181		ACCESS 0 0.00%
182		CLOSE 0 0.00%
183		COMMIT 0 0.00%
184		CREATE 0 0.00%
185		DELEGPURGE 0 0.00%
186		DELEGRETURN 0 0.00%
187		GETATTR 0 0.00%
188		GETFH 0 0.00%
189		LINK 0 0.00%
190		LOCK 0 0.00%
191		LOCKT 0 0.00%
192		LOCKU 0 0.00%
193		LOOKUP 0 0.00%
194		LOOKUPP 0 0.00%
195		NVERIFY 0 0.00%
196		OPEN 0 0.00%
197		OPENATTR 0 0.00%
198		OPEN_CONFIRM 0 0.00%
199		OPEN_DOWNGRADE 0 0.00%
200		PUTFH 0 0.00%
201		PUTPUBFH 0 0.00%
202		PUTROOTFH 0 0.00%
203		READ 0 0.00%
204		READDIR 0 0.00%
205		READLINK 0 0.00%
206		REMOVE 0 0.00%
207		RENAME 0 0.00%
208		RENEW 0 0.00%
209		RESTOREFH 0 0.00%
210		SAVEFH 0 0.00%
211		SECINFO 0 0.00%
212		SETATTR 0 0.00%
213		SETCLIENTID 0 0.00%
214		SETCLIENTID_CONFIRM 0 0.00%
215		VERIFY 0 0.00%
216		WRITE 0 0.00%
217		RELEASE_LOCKOWNER 0 0.00%
218		GET_DIR_DELEGATION 0 0.00%
	79	NFS v4.0 protocol: Data transmission has not been detected.
219	80	### Breakdown analyzer ###
220		NFS v4.1 protocol
221		Total procedures: 0. Per procedure:
222		NULL 0 0.00%
223		COMPOUND 0 0.00%
224		Total operations: 0. Per operation:
225		ILLEGAL 0 0.00%
226		ACCESS 0 0.00%
227		CLOSE 0 0.00%
228		COMMIT 0 0.00%
229		CREATE 0 0.00%
230		DELEGPURGE 0 0.00%
231		DELEGRETURN 0 0.00%
232		GETATTR 0 0.00%
233		GETFH 0 0.00%
234		LINK 0 0.00%
235		LOCK 0 0.00%
236		LOCKT 0 0.00%
237		LOCKU 0 0.00%
238		LOOKUP 0 0.00%
239		LOOKUPP 0 0.00%
240		NVERIFY 0 0.00%
241		OPEN 0 0.00%
242		OPENATTR 0 0.00%
243		OPEN_CONFIRM 0 0.00%
244		OPEN_DOWNGRADE 0 0.00%
245		PUTFH 0 0.00%
246		PUTPUBFH 0 0.00%
247		PUTROOTFH 0 0.00%
248		READ 0 0.00%
249		READDIR 0 0.00%
250		READLINK 0 0.00%
251		REMOVE 0 0.00%
252		RENAME 0 0.00%
253		RENEW 0 0.00%
254		RESTOREFH 0 0.00%
255		SAVEFH 0 0.00%
256		SECINFO 0 0.00%
257		SETATTR 0 0.00%
258		SETCLIENTID 0 0.00%
259		SETCLIENTID_CONFIRM 0 0.00%
260		VERIFY 0 0.00%
261		WRITE 0 0.00%
262		RELEASE_LOCKOWNER 0 0.00%
263		BACKCHANNEL_CTL 0 0.00%
264		BIND_CONN_TO_SESSION 0 0.00%
265		EXCHANGE_ID 0 0.00%
266		CREATE_SESSION 0 0.00%
267		DESTROY_SESSION 0 0.00%
268		FREE_STATEID 0 0.00%
269		GET_DIR_DELEGATION 0 0.00%
270		GETDEVICEINFO 0 0.00%
271		GETDEVICELIST 0 0.00%
272		LAYOUTCOMMIT 0 0.00%
273		LAYOUTGET 0 0.00%
274		LAYOUTRETURN 0 0.00%
275		SECINFO_NO_NAME 0 0.00%
276		SEQUENCE 0 0.00%
277		SET_SSV 0 0.00%
278		TEST_STATEID 0 0.00%
279		WANT_DELEGATION 0 0.00%
280		DESTROY_CLIENTID 0 0.00%
281		RECLAIM_COMPLETE 0 0.00%
	81	NFS v4.1 protocol: Data transmission has not been detected.

-204

traces/references/breakdown/tcp-seq-overlap-in-fragment-12721.pcap.bz2.ref less more

0	0	### Breakdown analyzer ###
1		CIFS v1 protocol
2		Total operations: 0. Per operation:
3		CREATE_DIRECTORY 0 0.00%
4		DELETE_DIRECTORY 0 0.00%
5		OPEN 0 0.00%
6		CREATE 0 0.00%
7		CLOSE 0 0.00%
8		FLUSH 0 0.00%
9		DELETE 0 0.00%
10		RENAME 0 0.00%
11		QUERY_INFORMATION 0 0.00%
12		SET_INFORMATION 0 0.00%
13		READ 0 0.00%
14		WRITE 0 0.00%
15		LOCK_BYTE_RANGE 0 0.00%
16		UNLOCK_BYTE_RANGE 0 0.00%
17		CREATE_TEMPORARY 0 0.00%
18		CREATE_NEW 0 0.00%
19		CHECK_DIRECTORY 0 0.00%
20		PROCESS_EXIT 0 0.00%
21		SEEK 0 0.00%
22		LOCK_AND_READ 0 0.00%
23		WRITE_AND_UNLOCK 0 0.00%
24		READ_RAW 0 0.00%
25		READ_MPX 0 0.00%
26		READ_MPX_SECONDARY 0 0.00%
27		WRITE_RAW 0 0.00%
28		WRITE_MPX 0 0.00%
29		WRITE_MPX_SECONDARY 0 0.00%
30		WRITE_COMPLETE 0 0.00%
31		QUERY_SERVER 0 0.00%
32		SET_INFORMATION2 0 0.00%
33		QUERY_INFORMATION2 0 0.00%
34		LOCKING_ANDX 0 0.00%
35		TRANSACTION 0 0.00%
36		TRANSACTION_SECONDARY 0 0.00%
37		IOCTL 0 0.00%
38		IOCTL_SECONDARY 0 0.00%
39		COPY 0 0.00%
40		MOVE 0 0.00%
41		ECHO 0 0.00%
42		WRITE_AND_CLOSE 0 0.00%
43		OPEN_ANDX 0 0.00%
44		READ_ANDX 0 0.00%
45		WRITE_ANDX 0 0.00%
46		NEW_FILE_SIZE 0 0.00%
47		CLOSE_AND_TREE_DISC 0 0.00%
48		TRANSACTION2 0 0.00%
49		TRANSACTION2_SECONDARY 0 0.00%
50		FIND_CLOSE2 0 0.00%
51		FIND_NOTIFY_CLOSE 0 0.00%
52		TREE_CONNECT 0 0.00%
53		TREE_DISCONNECT 0 0.00%
54		NEGOTIATE 0 0.00%
55		SESSION_SETUP_ANDX 0 0.00%
56		LOGOFF_ANDX 0 0.00%
57		TREE_CONNECT_ANDX 0 0.00%
58		SECURITY_PACKAGE_ANDX 0 0.00%
59		QUERY_INFORMATION_DISK 0 0.00%
60		SEARCH 0 0.00%
61		FIND 0 0.00%
62		FIND_UNIQUE 0 0.00%
63		FIND_CLOSE 0 0.00%
64		NT_TRANSACT 0 0.00%
65		NT_TRANSACT_SECONDARY 0 0.00%
66		NT_CREATE_ANDX 0 0.00%
67		NT_CANCEL 0 0.00%
68		NT_RENAME 0 0.00%
69		OPEN_PRINT_FILE 0 0.00%
70		WRITE_PRINT_FILE 0 0.00%
71		CLOSE_PRINT_FILE 0 0.00%
72		GET_PRINT_QUEUE 0 0.00%
73		READ_BULK 0 0.00%
74		WRITE_BULK 0 0.00%
75		WRITE_BULK_DATA 0 0.00%
76		INVALID 0 0.00%
77		NO_ANDX_COMMAND 0 0.00%
	1	CIFS v1 protocol: Data transmission has not been detected.
78	2	### Breakdown analyzer ###
79		CIFS v2 protocol
80		Total operations: 0. Per operation:
81		NEGOTIATE 0 0.00%
82		SESSION SETUP 0 0.00%
83		LOGOFF 0 0.00%
84		TREE CONNECT 0 0.00%
85		TREE DISCONNECT 0 0.00%
86		CREATE 0 0.00%
87		CLOSE 0 0.00%
88		FLUSH 0 0.00%
89		READ 0 0.00%
90		WRITE 0 0.00%
91		LOCK 0 0.00%
92		IOCTL 0 0.00%
93		CANCEL 0 0.00%
94		ECHO 0 0.00%
95		QUERY DIRECTORY 0 0.00%
96		CHANGE NOTIFY 0 0.00%
97		QUERY INFO 0 0.00%
98		SET INFO 0 0.00%
99		OPLOCK BREAK 0 0.00%
	3	CIFS v2 protocol: Data transmission has not been detected.
100	4	### Breakdown analyzer ###
101	5	NFS v3 protocol
102	6	Total operations: 6171. Per operation:

148	52	PATHCONF Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
149	53	COMMIT Count: 0 ( 0.00%) Min: 0.000 Max: 0.000 Avg: 0.000 StDev: 0.00000000
150	54	### Breakdown analyzer ###
151		NFS v4.0 protocol
152		Total procedures: 0. Per procedure:
153		NULL 0 0.00%
154		COMPOUND 0 0.00%
155		Total operations: 0. Per operation:
156		ILLEGAL 0 0.00%
157		ACCESS 0 0.00%
158		CLOSE 0 0.00%
159		COMMIT 0 0.00%
160		CREATE 0 0.00%
161		DELEGPURGE 0 0.00%
162		DELEGRETURN 0 0.00%
163		GETATTR 0 0.00%
164		GETFH 0 0.00%
165		LINK 0 0.00%
166		LOCK 0 0.00%
167		LOCKT 0 0.00%
168		LOCKU 0 0.00%
169		LOOKUP 0 0.00%
170		LOOKUPP 0 0.00%
171		NVERIFY 0 0.00%
172		OPEN 0 0.00%
173		OPENATTR 0 0.00%
174		OPEN_CONFIRM 0 0.00%
175		OPEN_DOWNGRADE 0 0.00%
176		PUTFH 0 0.00%
177		PUTPUBFH 0 0.00%
178		PUTROOTFH 0 0.00%
179		READ 0 0.00%
180		READDIR 0 0.00%
181		READLINK 0 0.00%
182		REMOVE 0 0.00%
183		RENAME 0 0.00%
184		RENEW 0 0.00%
185		RESTOREFH 0 0.00%
186		SAVEFH 0 0.00%
187		SECINFO 0 0.00%
188		SETATTR 0 0.00%
189		SETCLIENTID 0 0.00%
190		SETCLIENTID_CONFIRM 0 0.00%
191		VERIFY 0 0.00%
192		WRITE 0 0.00%
193		RELEASE_LOCKOWNER 0 0.00%
194		GET_DIR_DELEGATION 0 0.00%
	55	NFS v4.0 protocol: Data transmission has not been detected.
195	56	### Breakdown analyzer ###
196		NFS v4.1 protocol
197		Total procedures: 0. Per procedure:
198		NULL 0 0.00%
199		COMPOUND 0 0.00%
200		Total operations: 0. Per operation:
201		ILLEGAL 0 0.00%
202		ACCESS 0 0.00%
203		CLOSE 0 0.00%
204		COMMIT 0 0.00%
205		CREATE 0 0.00%
206		DELEGPURGE 0 0.00%
207		DELEGRETURN 0 0.00%
208		GETATTR 0 0.00%
209		GETFH 0 0.00%
210		LINK 0 0.00%
211		LOCK 0 0.00%
212		LOCKT 0 0.00%
213		LOCKU 0 0.00%
214		LOOKUP 0 0.00%
215		LOOKUPP 0 0.00%
216		NVERIFY 0 0.00%
217		OPEN 0 0.00%
218		OPENATTR 0 0.00%
219		OPEN_CONFIRM 0 0.00%
220		OPEN_DOWNGRADE 0 0.00%
221		PUTFH 0 0.00%
222		PUTPUBFH 0 0.00%
223		PUTROOTFH 0 0.00%
224		READ 0 0.00%
225		READDIR 0 0.00%
226		READLINK 0 0.00%
227		REMOVE 0 0.00%
228		RENAME 0 0.00%
229		RENEW 0 0.00%
230		RESTOREFH 0 0.00%
231		SAVEFH 0 0.00%
232		SECINFO 0 0.00%
233		SETATTR 0 0.00%
234		SETCLIENTID 0 0.00%
235		SETCLIENTID_CONFIRM 0 0.00%
236		VERIFY 0 0.00%
237		WRITE 0 0.00%
238		RELEASE_LOCKOWNER 0 0.00%
239		BACKCHANNEL_CTL 0 0.00%
240		BIND_CONN_TO_SESSION 0 0.00%
241		EXCHANGE_ID 0 0.00%
242		CREATE_SESSION 0 0.00%
243		DESTROY_SESSION 0 0.00%
244		FREE_STATEID 0 0.00%
245		GET_DIR_DELEGATION 0 0.00%
246		GETDEVICEINFO 0 0.00%
247		GETDEVICELIST 0 0.00%
248		LAYOUTCOMMIT 0 0.00%
249		LAYOUTGET 0 0.00%
250		LAYOUTRETURN 0 0.00%
251		SECINFO_NO_NAME 0 0.00%
252		SEQUENCE 0 0.00%
253		SET_SSV 0 0.00%
254		TEST_STATEID 0 0.00%
255		WANT_DELEGATION 0 0.00%
256		DESTROY_CLIENTID 0 0.00%
257		RECLAIM_COMPLETE 0 0.00%
	57	NFS v4.1 protocol: Data transmission has not been detected.