summaryrefslogtreecommitdiffstats
path: root/tools/tcpmon
diff options
context:
space:
mode:
Diffstat (limited to 'tools/tcpmon')
-rw-r--r--tools/tcpmon/AUTHORS0
-rw-r--r--tools/tcpmon/COPYING203
-rw-r--r--tools/tcpmon/ChangeLog0
-rw-r--r--tools/tcpmon/INSTALL14
-rw-r--r--tools/tcpmon/LICENSE203
-rw-r--r--tools/tcpmon/Makefile.am6
-rw-r--r--tools/tcpmon/NEWS0
-rw-r--r--tools/tcpmon/README21
-rwxr-xr-xtools/tcpmon/autogen.sh50
-rw-r--r--tools/tcpmon/build.sh13
-rw-r--r--tools/tcpmon/configure.ac122
-rw-r--r--tools/tcpmon/include/tcpmon_entry.h234
-rw-r--r--tools/tcpmon/include/tcpmon_session.h291
-rw-r--r--tools/tcpmon/include/tcpmon_util.h91
-rw-r--r--tools/tcpmon/src/Makefile.am21
-rw-r--r--tools/tcpmon/src/entry.c656
-rw-r--r--tools/tcpmon/src/session.c632
-rw-r--r--tools/tcpmon/src/tcpmon.c1037
-rw-r--r--tools/tcpmon/src/tcpmon_entry_local.h16
-rw-r--r--tools/tcpmon/src/tcpmon_session_local.h15
-rw-r--r--tools/tcpmon/src/util.c806
-rw-r--r--tools/tcpmon/test/Makefile.am1
-rw-r--r--tools/tcpmon/test/unit/Makefile.am19
-rw-r--r--tools/tcpmon/test/unit/main.c44
-rw-r--r--tools/tcpmon/test/unit/result14
-rw-r--r--tools/tcpmon/test/unit/tcpmon_test.c85
-rw-r--r--tools/tcpmon/test/unit/tcpmon_test.h9
27 files changed, 4603 insertions, 0 deletions
diff --git a/tools/tcpmon/AUTHORS b/tools/tcpmon/AUTHORS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/tcpmon/AUTHORS
diff --git a/tools/tcpmon/COPYING b/tools/tcpmon/COPYING
new file mode 100644
index 0000000..6b0b127
--- /dev/null
+++ b/tools/tcpmon/COPYING
@@ -0,0 +1,203 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
diff --git a/tools/tcpmon/ChangeLog b/tools/tcpmon/ChangeLog
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/tcpmon/ChangeLog
diff --git a/tools/tcpmon/INSTALL b/tools/tcpmon/INSTALL
new file mode 100644
index 0000000..fb59719
--- /dev/null
+++ b/tools/tcpmon/INSTALL
@@ -0,0 +1,14 @@
+Getting Axis2/C tcpmon Source Working on Linux
+=============================================
+Build the source
+This can be done using the following command sequence:
+ ./configure
+ make
+ make install
+ use './configure --help' for options
+
+NOTE: If you don't provide a --prefix configure option, it will by default
+install into /usr/local/tcpmon directory.
+
+
+
diff --git a/tools/tcpmon/LICENSE b/tools/tcpmon/LICENSE
new file mode 100644
index 0000000..6b0b127
--- /dev/null
+++ b/tools/tcpmon/LICENSE
@@ -0,0 +1,203 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
diff --git a/tools/tcpmon/Makefile.am b/tools/tcpmon/Makefile.am
new file mode 100644
index 0000000..243c271
--- /dev/null
+++ b/tools/tcpmon/Makefile.am
@@ -0,0 +1,6 @@
+datadir=$(prefix)/bin/tools/tcpmon
+SUBDIRS = src
+includedir=$(prefix)/include/axis2-1.6.0
+include_HEADERS=$(top_builddir)/include/*.h
+data_DATA= INSTALL README AUTHORS NEWS LICENSE COPYING
+EXTRA_DIST=LICENSE
diff --git a/tools/tcpmon/NEWS b/tools/tcpmon/NEWS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/tcpmon/NEWS
diff --git a/tools/tcpmon/README b/tools/tcpmon/README
new file mode 100644
index 0000000..23755f4
--- /dev/null
+++ b/tools/tcpmon/README
@@ -0,0 +1,21 @@
+ Axis2C TCP Monitor
+ =======================
+
+What is it?
+-----------
+
+Axis2 TCP monitor project is aimed at capture the SOAP messages sent and received. It works only in command line interface.
+
+How to run the TCP monitor?
+---------------------------
+
+Run the file called tcpmon with the Listen Port, Target port and Host name.
+For instruction run tcpmon -h
+
+
+Installation
+------------
+
+Please see the file called INSTALL.
+
+
diff --git a/tools/tcpmon/autogen.sh b/tools/tcpmon/autogen.sh
new file mode 100755
index 0000000..718c23c
--- /dev/null
+++ b/tools/tcpmon/autogen.sh
@@ -0,0 +1,50 @@
+#!/bin/bash
+
+echo -n 'Running libtoolize...'
+if [ `uname -s` = Darwin ]
+then
+ LIBTOOLIZE=glibtoolize
+else
+ LIBTOOLIZE=libtoolize
+fi
+
+if $LIBTOOLIZE --force > /dev/null 2>&1; then
+ echo 'done.'
+else
+ echo 'failed.'
+ exit 1
+fi
+
+echo -n 'Running aclocal...'
+if aclocal > /dev/null 2>&1; then
+ echo 'done.'
+else
+ echo 'failed.'
+ exit 1
+fi
+
+echo -n 'Running autoheader...'
+if autoheader > /dev/null 2>&1; then
+ echo 'done.'
+else
+ echo 'failed.'
+ exit 1
+fi
+
+echo -n 'Running autoconf...'
+if autoconf > /dev/null 2>&1; then
+ echo 'done.'
+else
+ echo 'failed.'
+ exit 1
+fi
+
+echo -n 'Running automake...'
+if automake --add-missing > /dev/null 2>&1; then
+ echo 'done.'
+else
+ echo 'failed.'
+ exit 1
+fi
+
+echo 'done'
diff --git a/tools/tcpmon/build.sh b/tools/tcpmon/build.sh
new file mode 100644
index 0000000..17d3548
--- /dev/null
+++ b/tools/tcpmon/build.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+./autogen.sh
+
+if test -z ${AXIS2C_HOME}
+then
+ AXIS2C_HOME=`pwd`/../deploy
+fi
+
+export AXIS2C_HOME
+
+./configure --prefix=${AXIS2C_HOME} --enable-tests=no
+make
diff --git a/tools/tcpmon/configure.ac b/tools/tcpmon/configure.ac
new file mode 100644
index 0000000..5619c87
--- /dev/null
+++ b/tools/tcpmon/configure.ac
@@ -0,0 +1,122 @@
+dnl run autogen.sh to generate the configure script.
+
+AC_PREREQ(2.59)
+
+AC_INIT(tcpmon-src, 1.6.0)
+AC_CANONICAL_SYSTEM
+AM_CONFIG_HEADER(config.h)
+AM_INIT_AUTOMAKE(AC_PACKAGE_NAME, AC_PACKAGE_VERSION)
+AC_PREFIX_DEFAULT(/usr/local/tcpmon)
+
+dnl Checks for programs.
+AC_PROG_CC
+AC_PROG_CXX
+AC_PROG_CPP
+AC_PROG_LIBTOOL
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+
+
+CFLAGS="$CFLAGS -D_LARGEFILE64_SOURCE -g"
+if test "$GCC" = "yes"; then
+ CFLAGS="$CFLAGS -ansi -Wall -Wno-implicit-function-declaration"
+fi
+
+LDFLAGS="$LDFLAGS -lpthread"
+
+dnl Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([stdio.h stdlib.h string.h])
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+
+dnl Checks for library functions.
+AC_FUNC_MALLOC
+AC_FUNC_REALLOC
+AC_CHECK_FUNCS([memmove])
+
+AC_CHECK_LIB(z, inflate)
+dnl AC_CHECK_LIB(cutest, CuTestInit)
+
+
+AC_MSG_CHECKING(whether to build tests)
+AC_ARG_ENABLE(tests,
+[ --enable-tests build tests. default=no],
+[ case "${enableval}" in
+ no)
+ AC_MSG_RESULT(no)
+ TESTDIR=""
+ ;;
+ *)
+ AC_MSG_RESULT(yes)
+ TESTDIR="test"
+
+ ;;
+ esac ],
+ AC_MSG_RESULT(no)
+ TESTDIR=""
+)
+
+GUTHTHILA_LIBS=""
+
+AC_MSG_CHECKING(whether to build guththila xml parser library)
+AC_ARG_ENABLE(guththila, [ --enable-guththila
+ build Guththila XML parser library wrapper (default=yes)],
+[ case "${enableval}" in
+ no)
+ AC_MSG_RESULT(no)
+ ;;
+ *)
+ AC_MSG_RESULT(yes)
+ CFLAGS="$CFLAGS -DAXIS2_GUTHTHILA_ENABLED"
+ CPPFLAGS="$CPPFLAGS -DAXIS2_GUTHTHILA_ENABLED"
+ WRAPPER_DIR="guththila"
+
+ ;;
+ esac ],
+ AC_MSG_RESULT(yes)
+ WRAPPER_DIR="guththila"
+ CFLAGS="$CFLAGS -DAXIS2_GUTHTHILA_ENABLED"
+ CPPFLAGS="$CPPFLAGS -DAXIS2_GUTHTHILA_ENABLED"
+ AC_CONFIG_SUBDIRS(guththila)
+ GUTHTHILA_LIBS="/guththila/src/"
+ GUTHTHILA_DIR="guththila"
+)
+
+
+AC_MSG_CHECKING(whether to build libxml2 xml parser library)
+AC_ARG_ENABLE(libxml2, [ --enable-libxml2
+ build Libxml2 XML parser library wrapper (default=no)],
+[ case "${enableval}" in
+ no)
+ AC_MSG_RESULT(no)
+ WRAPPER_DIR=""
+ ;;
+ *)
+ AC_MSG_RESULT(yes)
+ WRAPPER_DIR="libxml2"
+ PKG_CHECK_MODULES(LIBXML2, libxml-2.0)
+ CFLAGS="$CFLAGS -DAXIS2_LIBXML2_ENABLED"
+ CPPFLAGS="$CPPFLAGS $PARSER_CFLAGS -DAXIS2_LIBXML2_ENABLED"
+ LDFLAGS="$LDFLAGS $PARSER_LIBS"
+ ;;
+ esac ],
+ AC_MSG_RESULT(no)
+)
+
+
+UTILINC=$axis2_utilinc
+
+AC_SUBST(UTILINC)
+AC_SUBST(TESTDIR)
+AC_SUBST(WRAPPER_DIR)
+
+CFLAGS="$CFLAGS"
+
+AC_CONFIG_FILES([Makefile \
+ src/Makefile \
+ ])
+
+AC_OUTPUT
diff --git a/tools/tcpmon/include/tcpmon_entry.h b/tools/tcpmon/include/tcpmon_entry.h
new file mode 100644
index 0000000..b918ad5
--- /dev/null
+++ b/tools/tcpmon/include/tcpmon_entry.h
@@ -0,0 +1,234 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TCPMON_ENTRY_H
+#define TCPMON_ENTRY_H
+
+#include <axutil_env.h>
+#include <axutil_string.h>
+
+/**
+ * @file tcpmon_entry.h
+ * @brief represent entry of tcpmon
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ /**
+ * @defgroup represent entry of tcpmon
+ * @ingroup tcpmon
+ * @{
+ */
+
+ typedef struct tcpmon_entry_ops tcpmon_entry_ops_t;
+ typedef struct tcpmon_entry tcpmon_entry_t;
+
+ struct tcpmon_entry_ops
+ {
+
+ /**
+ * free the tcpmon_entry.
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE.
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * free)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve the arrived_time
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * arrived_time)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve the sent_time
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * sent_time)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve the arrived_time - sent_time ( in seconds)
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * time_diff)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve the sent data
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * sent_data)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve the arrived data
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * arrived_data)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve the sent headers
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * sent_headers)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve the arrived headers
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * arrived_headers)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ /**
+ * retrieve whether the transportation success
+ * @param entry represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_bool_t(
+ AXIS2_CALL
+ * is_success)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ int(
+ AXIS2_CALL
+ * get_format_bit)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ int(
+ AXIS2_CALL
+ * get_sent_data_length)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ int(
+ AXIS2_CALL
+ * get_arrived_data_length)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+ axis2_status_t(
+ AXIS2_CALL
+ * set_format_bit)(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env,
+ int format_bit);
+ };
+
+ struct tcpmon_entry
+ {
+ tcpmon_entry_ops_t *ops;
+ };
+
+ /**
+ * Creates tcpmon_entry struct
+ * @param env double pointer to environment struct. MUST NOT be NULL
+ * @return pointer to newly created tcpmon_entry struct
+ */
+ tcpmon_entry_t *AXIS2_CALL
+ tcpmon_entry_create(
+ const axutil_env_t * env);
+
+ /*************************** Function macros **********************************/
+
+#define TCPMON_ENTRY_FREE(entry, env) \
+ ((entry)->ops->free (entry, env))
+
+#define TCPMON_ENTRY_ARRIVED_TIME(entry, env) \
+ ((entry)->ops->arrived_time(entry, env))
+
+#define TCPMON_ENTRY_SENT_TIME(entry, env) \
+ ((entry)->ops->sent_time(entry, env))
+
+#define TCPMON_ENTRY_TIME_DIFF(entry, env) \
+ ((entry)->ops->time_diff(entry, env))
+
+#define TCPMON_ENTRY_SENT_DATA(entry, env) \
+ ((entry)->ops->sent_data(entry, env))
+
+#define TCPMON_ENTRY_ARRIVED_DATA(entry, env) \
+ ((entry)->ops->arrived_data(entry, env))
+
+#define TCPMON_ENTRY_SENT_HEADERS(entry, env) \
+ ((entry)->ops->sent_headers(entry, env))
+
+#define TCPMON_ENTRY_ARRIVED_HEADERS(entry, env) \
+ ((entry)->ops->arrived_headers(entry, env))
+
+#define TCPMON_ENTRY_IS_SUCCESS(entry, env) \
+ ((entry)->ops->is_success(entry, env))
+
+#define TCPMON_ENTRY_SET_FORMAT_BIT(entry, env, format_bit) \
+ ((entry)->ops->set_format_bit(entry, env, format_bit))
+
+#define TCPMON_ENTRY_GET_FORMAT_BIT(entry, env) \
+ ((entry)->ops->get_format_bit(entry, env))
+
+#define TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) \
+ ((entry)->ops->get_sent_data_length(entry, env))
+
+#define TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) \
+ ((entry)->ops->get_arrived_data_length(entry, env))
+
+ /** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TCPMON_ENTRY_H */
diff --git a/tools/tcpmon/include/tcpmon_session.h b/tools/tcpmon/include/tcpmon_session.h
new file mode 100644
index 0000000..53181c5
--- /dev/null
+++ b/tools/tcpmon/include/tcpmon_session.h
@@ -0,0 +1,291 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TCPMON_SESSION_H
+#define TCPMON_SESSION_H
+
+#include <axutil_env.h>
+#include <tcpmon_entry.h>
+#include <axutil_string.h>
+
+/**
+ * @file tcpmon_session.h
+ * @brief represent session of tcpmon
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ /**
+ * @defgroup represent session of tcpmon
+ * @ingroup tcpmon
+ * @{
+ */
+
+ typedef struct tcpmon_session_ops tcpmon_session_ops_t;
+ typedef struct tcpmon_session tcpmon_session_t;
+
+ /**
+ * callback functions for the tcpmon session
+ */
+ typedef int(
+ *TCPMON_SESSION_NEW_ENTRY_FUNCT)(
+ const axutil_env_t * env,
+ tcpmon_entry_t * entry,
+ int status); /* 0-started, 1-finished */
+
+ typedef int(
+ *TCPMON_SESSION_TRANS_ERROR_FUNCT)(
+ const axutil_env_t * env,
+ axis2_char_t * error_message);
+
+ struct tcpmon_session_ops
+ {
+
+ /**
+ * free the tcpmon_session.
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE.
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * free)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+ axis2_status_t(
+ AXIS2_CALL
+ * set_test_bit)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int test_bit);
+
+ axis2_status_t(
+ AXIS2_CALL
+ * get_test_bit)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+ axis2_status_t(
+ AXIS2_CALL
+ * set_format_bit)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int format_bit);
+
+ int(
+ AXIS2_CALL
+ * get_format_bit)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+ /**
+ * configure the listening port.
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @param listen_port listening port ( port of a localhost).
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE.
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * set_listen_port)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int listen_port);
+
+ /**
+ * retrieve the listening port
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ int(
+ AXIS2_CALL
+ * get_listen_port)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+ /**
+ * configure the target port
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @param target_port tartet port
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE.
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * set_target_port)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int target_port);
+
+ /**
+ * retrieve the target port
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ int(
+ AXIS2_CALL
+ * get_target_port)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+ /**
+ * configure the target host
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @param target_host url of the target host
+ * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE.
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * set_target_host)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ axis2_char_t * target_host);
+
+ /**
+ * retrieve the base uri of the target host
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_char_t *(
+ AXIS2_CALL
+ * get_target_host)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+ /**
+ * start the session
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * start)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+ /**
+ * stop the session.
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * stop)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+ /**
+ * set on new entry.
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @param on_new_entry_funct function to triger on new entry
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * on_new_entry)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry_funct);
+
+ /**
+ * set on new entry.
+ * @param session represet the type object.
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @param on_new_entry function to triger on new entry
+ */
+ axis2_status_t(
+ AXIS2_CALL
+ * on_trans_fault)(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct);
+
+ };
+
+ struct tcpmon_session
+ {
+ tcpmon_session_ops_t *ops;
+ };
+
+ /**
+ * Creates tcpmon_session struct
+ * @param env double pointer to environment struct. MUST NOT be NULL
+ * @return pointer to newly created tcpmon_session struct
+ */
+ tcpmon_session_t *AXIS2_CALL
+ tcpmon_session_create(
+ const axutil_env_t * env);
+
+ /*************************** Function macros **********************************/
+
+#define TCPMON_SESSION_FREE(session, env) \
+ ((session)->ops->free (session, env))
+
+#define TCPMON_SESSION_SET_TEST_BIT(session, env, test_bit) \
+ ((session)->ops->set_test_bit(session, env, test_bit))
+
+#define TCPMON_SESSION_GET_TEST_BIT(session, env) \
+ ((session)->ops->get_test_bit(session, env))
+
+#define TCPMON_SESSION_SET_FORMAT_BIT(session, env, format_bit) \
+ ((session)->ops->set_format_bit(session, env, format_bit))
+
+#define TCPMON_SESSION_GET_FORMAT_BIT(session, env) \
+ ((session)->ops->get_format_bit(session, env))
+
+#define TCPMON_SESSION_SET_LISTEN_PORT(session, env, listen_port) \
+ ((session)->ops->set_listen_port(session, env, listen_port))
+
+#define TCPMON_SESSION_GET_LISTEN_PORT(session, env) \
+ ((session)->ops->get_listen_port(session, env))
+
+#define TCPMON_SESSION_SET_TARGET_PORT(session, env, target_port) \
+ ((session)->ops->set_target_port(session, env, target_port))
+
+#define TCPMON_SESSION_GET_TARGET_PORT(session, env) \
+ ((session)->ops->get_target_port(session, env))
+
+#define TCPMON_SESSION_SET_TARGET_HOST(session, env, target_host) \
+ ((session)->ops->set_target_host(session, env, target_host))
+
+#define TCPMON_SESSION_GET_TARGET_HOST(session, env) \
+ ((session)->ops->get_target_host(session, env))
+
+#define TCPMON_SESSION_START(session, env) \
+ ((session)->ops->start(session, env))
+
+#define TCPMON_SESSION_STOP(session, env) \
+ ((session)->ops->stop(session, env))
+
+#define TCPMON_SESSION_ON_TRANS_FAULT(session, env, funct) \
+ ((session)->ops->on_trans_fault(session, env, funct))
+
+#define TCPMON_SESSION_ON_NEW_ENTRY(session, env, funct) \
+ ((session)->ops->on_new_entry(session, env, funct))
+
+ /** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TCPMON_SESSION_H */
diff --git a/tools/tcpmon/include/tcpmon_util.h b/tools/tcpmon/include/tcpmon_util.h
new file mode 100644
index 0000000..646be66
--- /dev/null
+++ b/tools/tcpmon/include/tcpmon_util.h
@@ -0,0 +1,91 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TCPMON_UTIL_H
+#define TCPMON_UTIL_H
+
+#include <axutil_env.h>
+#include <axutil_string.h>
+#include <axutil_stream.h>
+
+/**
+ * @file tcpmon_util.h
+ * @brief hold util functions of tcpmon
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ /**
+ * @defgroup hold util functions of tcpmon
+ * @ingroup tcpmon
+ * @{
+ */
+
+ /**
+ * format the data as xml
+ * @param env pointer to environment struct. MUST NOT be NULL.
+ * @param data to be formatted
+ */
+ axis2_char_t *tcpmon_util_format_as_xml(
+ const axutil_env_t * env,
+ axis2_char_t * data,
+ int format);
+
+ char *str_replace(
+ char *str,
+ const char *search,
+ const char *replace);
+
+ axis2_char_t * tcpmon_util_strcat(
+ axis2_char_t * dest,
+ axis2_char_t * source,
+ int *buff_size,
+ const axutil_env_t * env);
+
+ axis2_char_t *
+ tcpmon_util_read_current_stream(
+ const axutil_env_t * env,
+ axutil_stream_t * stream,
+ int *stream_size,
+ axis2_char_t ** header,
+ axis2_char_t ** data);
+
+ char *
+ tcpmon_util_str_replace(
+ const axutil_env_t *env,
+ char *str,
+ const char *search,
+ const char *replace);
+
+ int
+ tcpmon_util_write_to_file(
+ char *filename,
+ char *buffer);
+
+
+
+ /** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TCPMON_UTIL_H */
diff --git a/tools/tcpmon/src/Makefile.am b/tools/tcpmon/src/Makefile.am
new file mode 100644
index 0000000..674fbca
--- /dev/null
+++ b/tools/tcpmon/src/Makefile.am
@@ -0,0 +1,21 @@
+prgbindir=$(prefix)/bin/tools/tcpmon
+
+prgbin_PROGRAMS = tcpmon
+
+tcpmon_SOURCES = tcpmon.c \
+ entry.c \
+ session.c \
+ util.c
+
+tcpmon_LDADD = \
+ ../../../util/src/libaxutil.la \
+ ../../../axiom/src/om/libaxis2_axiom.la \
+ ../../../axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la
+
+INCLUDES = -I$(top_builddir)/include \
+ -I ../../../util/include \
+ -I ../../../axiom/include \
+ -I ../../../include \
+ -I ../include
+
+EXTRA_DIST=tcpmon_entry_local.h tcpmon_session_local.h
diff --git a/tools/tcpmon/src/entry.c b/tools/tcpmon/src/entry.c
new file mode 100644
index 0000000..37d2af1
--- /dev/null
+++ b/tools/tcpmon/src/entry.c
@@ -0,0 +1,656 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <axutil_utils.h>
+#include <axutil_error.h>
+#include <axutil_string.h>
+#include <axutil_network_handler.h>
+#include <axutil_stream.h>
+#include <time.h>
+
+#include "tcpmon_entry_local.h"
+#include "tcpmon_session_local.h"
+#include "tcpmon_util.h"
+
+#define AXIS2_TCPMON
+
+/**
+ * @brief
+ */
+typedef struct tcpmon_entry_impl
+{
+ tcpmon_entry_t entry;
+
+ axis2_char_t *arrived_time;
+ axis2_char_t *sent_time;
+ axis2_char_t *sent_data;
+ axis2_char_t *arrived_data;
+ axis2_char_t *sent_headers;
+ axis2_char_t *arrived_headers;
+ axis2_bool_t is_success;
+ axis2_char_t *time_diff;
+ axis2_char_t *test_file_name;
+ int format_bit;
+ int sent_data_length;
+ int arrived_data_length;
+}
+tcpmon_entry_impl_t;
+
+#define AXIS2_INTF_TO_IMPL(entry) \
+ ((tcpmon_entry_impl_t *) entry)
+
+/************************* Function prototypes ********************************/
+
+
+axis2_status_t AXIS2_CALL tcpmon_entry_free(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL tcpmon_entry_arrived_time(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL tcpmon_entry_sent_time(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL tcpmon_entry_time_diff(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL tcpmon_entry_sent_data(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL tcpmon_entry_sent_headers(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL tcpmon_entry_arrived_data(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL tcpmon_entry_arrived_headers(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_bool_t AXIS2_CALL tcpmon_entry_is_success(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_char_t *get_current_stream_to_buffer(
+ const axutil_env_t * env,
+ axutil_stream_t * stream,
+ int *stream_size);
+
+
+int AXIS2_CALL tcpmon_entry_get_format_bit(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+int AXIS2_CALL tcpmon_entry_get_sent_data_length(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+int AXIS2_CALL tcpmon_entry_get_arrived_data_length(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env);
+
+axis2_status_t AXIS2_CALL tcpmon_entry_set_format_bit(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env,
+ int format_bit);
+
+/************************** End of function prototypes ************************/
+
+tcpmon_entry_t *AXIS2_CALL
+tcpmon_entry_create(
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = (tcpmon_entry_impl_t *) AXIS2_MALLOC(env->
+ allocator,
+ sizeof
+ (tcpmon_entry_impl_t));
+
+ if (!entry_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ entry_impl->arrived_time = AXIS2_MALLOC(env->allocator, 32);
+ entry_impl->sent_time = AXIS2_MALLOC(env->allocator, 32);
+ entry_impl->time_diff = AXIS2_MALLOC(env->allocator, 32);
+ entry_impl->arrived_data = NULL;
+ entry_impl->sent_data = NULL;
+ entry_impl->arrived_headers = NULL;
+ entry_impl->sent_headers = NULL;
+ entry_impl->is_success = AXIS2_FALSE;
+ entry_impl->format_bit = 0;
+ entry_impl->sent_data_length = 0;
+ entry_impl->arrived_data_length = 0;
+
+ entry_impl->entry.ops =
+ AXIS2_MALLOC(env->allocator, sizeof(tcpmon_entry_ops_t));
+ if (!entry_impl->entry.ops)
+ {
+ tcpmon_entry_free(&(entry_impl->entry), env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ entry_impl->entry.ops->free = tcpmon_entry_free;
+ entry_impl->entry.ops->arrived_time = tcpmon_entry_arrived_time;
+ entry_impl->entry.ops->sent_time = tcpmon_entry_sent_time;
+ entry_impl->entry.ops->time_diff = tcpmon_entry_time_diff;
+ entry_impl->entry.ops->sent_data = tcpmon_entry_sent_data;
+ entry_impl->entry.ops->sent_headers = tcpmon_entry_sent_headers;
+ entry_impl->entry.ops->arrived_data = tcpmon_entry_arrived_data;
+ entry_impl->entry.ops->arrived_headers = tcpmon_entry_arrived_headers;
+ entry_impl->entry.ops->is_success = tcpmon_entry_is_success;
+ entry_impl->entry.ops->set_format_bit = tcpmon_entry_set_format_bit;
+ entry_impl->entry.ops->get_format_bit = tcpmon_entry_get_format_bit;
+ entry_impl->entry.ops->get_sent_data_length = tcpmon_entry_get_sent_data_length;
+ entry_impl->entry.ops->get_arrived_data_length = tcpmon_entry_get_arrived_data_length;
+
+ return &(entry_impl->entry);
+}
+
+/***************************Function implementation****************************/
+
+axis2_status_t AXIS2_CALL
+tcpmon_entry_free(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ if (entry->ops)
+ {
+ AXIS2_FREE(env->allocator, entry->ops);
+ entry->ops = NULL;
+ }
+
+ if (entry_impl->arrived_time)
+ {
+ AXIS2_FREE(env->allocator, entry_impl->arrived_time);
+ entry_impl->arrived_time = NULL;
+ }
+ if (entry_impl->sent_time)
+ {
+ AXIS2_FREE(env->allocator, entry_impl->sent_time);
+ entry_impl->sent_time = NULL;
+ }
+ if (entry_impl->time_diff)
+ {
+ AXIS2_FREE(env->allocator, entry_impl->time_diff);
+ entry_impl->time_diff = NULL;
+ }
+ if (entry_impl->arrived_data)
+ {
+ AXIS2_FREE(env->allocator, entry_impl->arrived_data);
+ entry_impl->arrived_data = NULL;
+ }
+ if (entry_impl->sent_data)
+ {
+ AXIS2_FREE(env->allocator, entry_impl->sent_data);
+ entry_impl->sent_data = NULL;
+ }
+ if (entry_impl->arrived_headers)
+ {
+ AXIS2_FREE(env->allocator, entry_impl->arrived_headers);
+ entry_impl->arrived_headers = NULL;
+ }
+ if (entry_impl->sent_headers)
+ {
+ AXIS2_FREE(env->allocator, entry_impl->sent_headers);
+ entry_impl->sent_headers = NULL;
+ }
+
+ if (entry_impl)
+ {
+ AXIS2_FREE(env->allocator, entry_impl);
+ entry_impl = NULL;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_entry_arrived_time(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->arrived_time;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_entry_sent_time(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->sent_time;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_entry_time_diff(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->time_diff;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_entry_sent_data(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->sent_data;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_entry_sent_headers(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->sent_headers;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_entry_arrived_data(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->arrived_data;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_entry_arrived_headers(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->arrived_headers;
+}
+
+axis2_bool_t AXIS2_CALL
+tcpmon_entry_is_success(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->is_success;
+}
+
+int AXIS2_CALL
+tcpmon_entry_get_format_bit(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->format_bit;
+}
+
+int AXIS2_CALL
+tcpmon_entry_get_sent_data_length(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->sent_data_length;
+}
+
+int AXIS2_CALL
+tcpmon_entry_get_arrived_data_length(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ return entry_impl->arrived_data_length;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_entry_set_format_bit(
+ tcpmon_entry_t * entry,
+ const axutil_env_t * env,
+ int format_bit)
+{
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ entry_impl->format_bit = format_bit;
+
+ return AXIS2_SUCCESS;
+}
+
+/** implimentations for protected methods */
+
+/** executes as new entry arises */
+void *AXIS2_CALL
+tcpmon_entry_new_entry_funct(
+ axutil_thread_t * thd,
+ void *data)
+{
+ tcpmon_entry_request_data_t *req_data = (tcpmon_entry_request_data_t *) data;
+ const axutil_env_t *env = NULL;
+ int client_socket = -1;
+ int host_socket = -1;
+ tcpmon_session_t *session;
+ TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct;
+ TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry;
+
+ axutil_stream_t *client_stream = NULL;
+ axutil_stream_t *host_stream = NULL;
+ int buffer_size = 0;
+ axis2_char_t *headers = NULL;
+ axis2_char_t *content = NULL;
+ axis2_char_t *buffer = NULL;
+ time_t now;
+ struct tm *localTime = NULL;
+ int arrived_secs = 0;
+ int sent_secs = 0;
+ int time_diff_i = 0;
+ int target_port = 0;
+ axis2_char_t *target_host = NULL;
+ int test_bit = 0;
+ int format_bit = 0;
+ tcpmon_entry_t *entry = NULL;
+ tcpmon_entry_impl_t *entry_impl = NULL;
+
+ env = req_data->env;
+ client_socket = req_data->socket;
+ session = req_data->session;
+ on_trans_fault_funct = tcpmon_session_get_on_trans_fault(session, env);
+ on_new_entry = tcpmon_session_get_on_new_entry(session, env);
+
+ entry = tcpmon_entry_create(env);
+ entry_impl = AXIS2_INTF_TO_IMPL(entry);
+
+ target_port = TCPMON_SESSION_GET_TARGET_PORT(session, env);
+ target_host = TCPMON_SESSION_GET_TARGET_HOST(session, env);
+ if (target_port == -1 || target_host == NULL)
+ {
+ axutil_network_handler_close_socket(env, client_socket);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Missing target port and host"
+ "input missing");
+ if (on_trans_fault_funct)
+ {
+ (on_trans_fault_funct) (env, "Missing target port and host");
+ }
+ if (thd)
+ {
+ AXIS2_FREE(env->allocator, thd);
+ }
+ if (data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
+ }
+ return NULL;
+ }
+ client_stream = axutil_stream_create_socket(env, client_socket);
+ if (!client_stream)
+ {
+ axutil_network_handler_close_socket(env, client_socket);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Error in creating client stream" "handling response");
+
+ /** call the callback */
+ if (on_trans_fault_funct)
+ {
+ (on_trans_fault_funct) (env, "error in creating the client stream");
+ }
+ if (thd)
+ {
+ AXIS2_FREE(env->allocator, thd);
+ }
+ if (data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
+ }
+ return NULL;
+ }
+
+ buffer = tcpmon_util_read_current_stream(env, client_stream, &buffer_size,
+ &headers, &content);
+
+ headers =(char *) tcpmon_util_str_replace(env, headers,"localhost", target_host);
+ test_bit = TCPMON_SESSION_GET_TEST_BIT(session, env);
+
+ if (test_bit)
+ {
+ tcpmon_util_write_to_file("reqest", buffer);
+ }
+
+ format_bit = TCPMON_SESSION_GET_FORMAT_BIT(session, env);
+ TCPMON_ENTRY_SET_FORMAT_BIT(entry, env, format_bit);
+
+ now = time(NULL);
+ localTime = localtime(&now);
+
+ sprintf(entry_impl->sent_time, "%d:%d:%d", localTime->tm_hour,
+ localTime->tm_min, localTime->tm_sec);
+ sent_secs =
+ localTime->tm_hour * 60 * 60 + localTime->tm_min * 60 +
+ localTime->tm_sec;
+
+ /*free ( localTime); */
+
+ entry_impl->sent_headers = headers;
+ entry_impl->sent_data = content;
+ entry_impl->sent_data_length = buffer_size;
+
+ if (on_new_entry)
+ {
+ (on_new_entry) (env, entry, 0);
+ }
+
+ host_socket =
+ (int)axutil_network_handler_open_socket(env, target_host, target_port);
+ if (-1 == host_socket)
+ {
+ axutil_stream_write(client_stream, env, NULL, 0);
+ axutil_stream_free(client_stream, env);
+ axutil_network_handler_close_socket(env, client_socket);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host_socket"
+ "creating socket");
+
+ /** call the callback */
+ if (on_trans_fault_funct)
+ {
+ (on_trans_fault_funct) (env, "error in creating the host socket");
+ }
+ if (thd)
+ {
+ AXIS2_FREE(env->allocator, thd);
+ }
+ if (data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
+ }
+ return NULL;
+ }
+
+ host_stream = axutil_stream_create_socket(env, host_socket);
+ if (!host_stream)
+ {
+ axutil_stream_write(client_stream, env, NULL, 0);
+ axutil_stream_free(client_stream, env);
+ axutil_network_handler_close_socket(env, client_socket);
+ axutil_network_handler_close_socket(env, host_socket);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host stream"
+ "handling response");
+
+ /** call the callback */
+ if (on_trans_fault_funct)
+ {
+ (on_trans_fault_funct) (env, "error in creating the host stream");
+ }
+ if (thd)
+ {
+ AXIS2_FREE(env->allocator, thd);
+ }
+ if (data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
+ }
+ return NULL;
+ }
+
+ axutil_stream_write(host_stream, env, buffer, buffer_size);
+ AXIS2_FREE(env->allocator, buffer);
+
+ buffer = tcpmon_util_read_current_stream(env, host_stream, &buffer_size,
+ &headers, &content);
+
+ test_bit = TCPMON_SESSION_GET_TEST_BIT(session, env);
+ if (test_bit)
+ {
+ tcpmon_util_write_to_file("response", buffer);
+ }
+
+ now = time(NULL);
+ localTime = localtime(&now);
+
+ sprintf(entry_impl->arrived_time, "%d:%d:%d", localTime->tm_hour,
+ localTime->tm_min, localTime->tm_sec);
+ arrived_secs =
+ localTime->tm_hour * 60 * 60 + localTime->tm_min * 60 +
+ localTime->tm_sec;
+ /*free ( localTime); */
+
+ time_diff_i = arrived_secs - sent_secs;
+ if (time_diff_i < 0)
+ {
+ time_diff_i += 24 * 60 * 60;
+ }
+ sprintf(entry_impl->time_diff, "%d sec(s)", time_diff_i);
+
+ entry_impl->arrived_headers = headers;
+ entry_impl->arrived_data = content;
+ entry_impl->arrived_data_length = buffer_size;
+ if (buffer == NULL || buffer_size == 0)
+ {
+ entry_impl->is_success = 0;
+ }
+ else
+ {
+ entry_impl->is_success = 1;
+ }
+
+ if (on_new_entry)
+ {
+ (on_new_entry) (env, entry, 1);
+ }
+
+ axutil_stream_write(client_stream, env, buffer, buffer_size);
+ AXIS2_FREE(env->allocator, buffer);
+
+ axutil_stream_free(client_stream, env);
+ axutil_stream_free(host_stream, env);
+ axutil_network_handler_close_socket(env, client_socket);
+ axutil_network_handler_close_socket(env, host_socket);
+
+ if (entry_impl)
+ {
+ tcpmon_entry_free(&(entry_impl->entry), env);
+ }
+ if (thd)
+ {
+ AXIS2_FREE(env->allocator, thd);
+ }
+ if (data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data);
+ }
+ return NULL;
+}
+
+
diff --git a/tools/tcpmon/src/session.c b/tools/tcpmon/src/session.c
new file mode 100644
index 0000000..29d4c78
--- /dev/null
+++ b/tools/tcpmon/src/session.c
@@ -0,0 +1,632 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <axutil_string.h>
+#include <axutil_utils.h>
+#include <axutil_error.h>
+#include <tcpmon_util.h>
+#include <axutil_thread.h>
+#include <axutil_network_handler.h>
+#include <axutil_array_list.h>
+
+#include "tcpmon_session_local.h"
+#include "tcpmon_entry_local.h"
+#include "tcpmon_util.h"
+
+/**
+ * @brief
+ */
+typedef struct tcpmon_session_impl
+{
+ tcpmon_session_t session;
+ int listen_port;
+ int target_port;
+ int test_bit;
+ int format_bit;
+ axis2_char_t *target_host;
+ TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry_funct;
+ TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct;
+ axutil_array_list_t *entries;
+
+ axis2_bool_t is_running;
+}
+tcpmon_session_impl_t;
+
+typedef struct tcpmon_session_server_thread_data
+{
+ tcpmon_session_impl_t *session_impl;
+ const axutil_env_t *env;
+}
+tcpmon_session_server_thread_data_t;
+
+#define AXIS2_INTF_TO_IMPL(session) \
+ ((tcpmon_session_impl_t *) session)
+axutil_thread_t *server_thread = NULL;
+tcpmon_session_server_thread_data_t *thread_data = NULL;
+
+
+/************************* Function prototypes ********************************/
+
+axis2_status_t AXIS2_CALL tcpmon_session_free(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+axis2_status_t AXIS2_CALL tcpmon_session_set_listen_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int listen_port);
+
+int AXIS2_CALL tcpmon_session_get_listen_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+axis2_status_t AXIS2_CALL tcpmon_session_set_target_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int target_port);
+
+int AXIS2_CALL tcpmon_session_get_target_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+axis2_status_t AXIS2_CALL tcpmon_session_set_target_host(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ axis2_char_t * target_host);
+
+axis2_char_t *AXIS2_CALL tcpmon_session_get_target_host(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+axis2_status_t AXIS2_CALL tcpmon_session_start(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+axis2_status_t AXIS2_CALL tcpmon_session_stop(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+axis2_status_t AXIS2_CALL tcpmon_session_on_new_entry(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry_funct);
+
+axis2_status_t AXIS2_CALL tcpmon_session_on_trans_fault(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct);
+
+int AXIS2_CALL tcpmon_session_get_test_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+int AXIS2_CALL tcpmon_session_set_test_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int test_bit);
+
+int AXIS2_CALL tcpmon_session_get_format_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+int AXIS2_CALL tcpmon_session_set_format_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int format_bit);
+
+/** internal implementations */
+
+static void *AXIS2_THREAD_FUNC server_funct(
+ axutil_thread_t * thd,
+ void *data);
+
+/************************** End of function prototypes ************************/
+
+tcpmon_session_t *AXIS2_CALL
+tcpmon_session_create(
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ session_impl = (tcpmon_session_impl_t *) AXIS2_MALLOC(env->
+ allocator,
+ sizeof
+ (tcpmon_session_impl_t));
+
+ if (!session_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ session_impl->listen_port = -1;
+ session_impl->target_port = -1;
+ session_impl->test_bit = -1;
+ session_impl->format_bit = 0;
+ session_impl->target_host = NULL;
+
+ session_impl->on_new_entry_funct = NULL;
+ session_impl->on_trans_fault_funct = NULL;
+ session_impl->entries =
+ axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+
+ session_impl->session.ops =
+ AXIS2_MALLOC(env->allocator, sizeof(tcpmon_session_ops_t));
+ if (!session_impl->session.ops)
+ {
+ tcpmon_session_free(&(session_impl->session), env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ session_impl->is_running = AXIS2_FALSE;
+ session_impl->session.ops->free = tcpmon_session_free;
+ session_impl->session.ops->set_test_bit = tcpmon_session_set_test_bit;
+ session_impl->session.ops->get_test_bit = tcpmon_session_get_test_bit;
+ session_impl->session.ops->get_format_bit = tcpmon_session_get_format_bit;
+ session_impl->session.ops->set_format_bit = tcpmon_session_set_format_bit;
+ session_impl->session.ops->set_listen_port = tcpmon_session_set_listen_port;
+ session_impl->session.ops->get_listen_port = tcpmon_session_get_listen_port;
+ session_impl->session.ops->set_target_port = tcpmon_session_set_target_port;
+ session_impl->session.ops->get_target_port = tcpmon_session_get_target_port;
+ session_impl->session.ops->set_target_host = tcpmon_session_set_target_host;
+ session_impl->session.ops->get_target_host = tcpmon_session_get_target_host;
+ session_impl->session.ops->start = tcpmon_session_start;
+ session_impl->session.ops->stop = tcpmon_session_stop;
+ session_impl->session.ops->on_new_entry = tcpmon_session_on_new_entry;
+ session_impl->session.ops->on_trans_fault = tcpmon_session_on_trans_fault;
+
+ return &(session_impl->session);
+}
+
+/***************************Function implementation****************************/
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_free(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+ int entries_size = 0;
+ tcpmon_entry_t *entry = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ for (entries_size = axutil_array_list_size(session_impl->entries, env) - 1;
+ entries_size >= 0; entries_size--)
+ {
+ TCPMON_ENTRY_FREE(entry, env);
+ }
+ axutil_array_list_free(session_impl->entries, env);
+
+ if (session->ops)
+ {
+ AXIS2_FREE(env->allocator, session->ops);
+ session->ops = NULL;
+ }
+
+ if (session_impl->target_host)
+ {
+ AXIS2_FREE(env->allocator, session_impl->target_host);
+ session_impl->target_host = NULL;
+ }
+
+ if (session_impl)
+ {
+ AXIS2_FREE(env->allocator, session_impl);
+ session_impl = NULL;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_set_test_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int test_bit)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+ session_impl->test_bit = test_bit;
+ return AXIS2_SUCCESS;
+}
+
+int AXIS2_CALL
+tcpmon_session_get_test_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ return session_impl->test_bit;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_set_format_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int format_bit)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ session_impl->format_bit = format_bit;
+
+ return AXIS2_SUCCESS;
+}
+
+int AXIS2_CALL
+tcpmon_session_get_format_bit(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ return session_impl->format_bit;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_set_listen_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int listen_port)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ session_impl->listen_port = listen_port;
+ return AXIS2_SUCCESS;
+}
+
+int AXIS2_CALL
+tcpmon_session_get_listen_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, -1);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ return session_impl->listen_port;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_set_target_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ int target_port)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ session_impl->target_port = target_port;
+ return AXIS2_SUCCESS;
+}
+
+int AXIS2_CALL
+tcpmon_session_get_target_port(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, -1);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ return session_impl->target_port;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_set_target_host(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ axis2_char_t * target_host)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ session_impl->target_host =
+ (axis2_char_t *) axutil_strdup(env, target_host);
+ return AXIS2_SUCCESS;
+}
+
+axis2_char_t *AXIS2_CALL
+tcpmon_session_get_target_host(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ return session_impl->target_host;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_start(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ thread_data =
+ (tcpmon_session_server_thread_data_t *) AXIS2_MALLOC(env->allocator,
+ sizeof
+ (tcpmon_session_server_thread_data_t));
+ thread_data->session_impl = session_impl;
+ thread_data->env = env;
+
+ session_impl->is_running = AXIS2_TRUE;
+ server_thread = axutil_thread_pool_get_thread(env->thread_pool,
+ server_funct,
+ (void *) thread_data);
+ if (!server_thread)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Thread creation failed"
+ "server thread");
+ if (session_impl->on_trans_fault_funct)
+ {
+ (session_impl->on_trans_fault_funct) (env,
+ "error in creating the server thread");
+ }
+ }
+
+ axutil_thread_pool_thread_detach(env->thread_pool, server_thread);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_stop(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+ session_impl->is_running = AXIS2_FALSE;
+
+ if (server_thread)
+ {
+ AXIS2_FREE(env->allocator, server_thread);
+ server_thread = NULL;
+ }
+ if (thread_data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_session_server_thread_data_t *)thread_data);
+ thread_data = NULL;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_on_new_entry(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry_funct)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ session_impl->on_new_entry_funct = on_new_entry_funct;
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+tcpmon_session_on_trans_fault(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ session_impl->on_trans_fault_funct = on_trans_fault_funct;
+ return AXIS2_SUCCESS;
+}
+
+/** internal implementations */
+static void *AXIS2_THREAD_FUNC
+server_funct(
+ axutil_thread_t * thd,
+ void *data)
+{
+ tcpmon_session_server_thread_data_t *thread_data = (tcpmon_session_server_thread_data_t *)data;
+ tcpmon_session_impl_t *session_impl = NULL;
+ const axutil_env_t *env = NULL;
+ int listen_socket = -1;
+ int socket = -1;
+ axutil_thread_t *request_thread = NULL;
+ tcpmon_entry_request_data_t *request_thread_data = NULL;
+
+ session_impl = thread_data->session_impl;
+ env = thread_data->env;
+
+ listen_socket = (int)axutil_network_handler_create_server_socket
+ (env, session_impl->listen_port);
+ if (-1 == listen_socket)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "error in creating the server socket, "
+ "port may be already occupied", "create socket");
+ if (session_impl->on_trans_fault_funct)
+ {
+ (session_impl->on_trans_fault_funct) (env,
+ "error in creating the server socket, "
+ "port may be already occupied");
+ }
+ if (thd)
+ {
+ AXIS2_FREE(env->allocator, server_thread);
+ server_thread = NULL;
+ }
+ if (data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_session_server_thread_data_t *)data);
+ thread_data = NULL;
+ }
+ return NULL;
+ }
+ while (session_impl->is_running)
+ {
+ socket = (int)axutil_network_handler_svr_socket_accept(env, listen_socket);
+ if (socket == -1)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "error in creating the socket" "create socket");
+ if (session_impl->on_trans_fault_funct)
+ {
+ (session_impl->on_trans_fault_funct) (env,
+ "error in creating the socket");
+ }
+ break;
+ }
+
+ request_thread_data =
+ (tcpmon_entry_request_data_t *) AXIS2_MALLOC(env->allocator,
+ sizeof
+ (tcpmon_entry_request_data_t));
+ request_thread_data->env = env;
+ request_thread_data->socket = socket;
+ request_thread_data->session = (tcpmon_session_t *) session_impl;
+
+ request_thread = axutil_thread_pool_get_thread(env->thread_pool,
+ tcpmon_entry_new_entry_funct,
+ (void *)
+ request_thread_data);
+ if (!request_thread)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Thread creation failed"
+ "request thread");
+ if (session_impl->on_trans_fault_funct)
+ {
+ (session_impl->on_trans_fault_funct) (env,
+ "fail in creating the thread");
+ }
+ break;
+ }
+
+ axutil_thread_pool_thread_detach(env->thread_pool, request_thread);
+ }
+ axutil_network_handler_close_socket(env, listen_socket);
+ if (thd)
+ {
+ AXIS2_FREE(env->allocator, server_thread);
+ server_thread = NULL;
+ }
+ if (data)
+ {
+ AXIS2_FREE(env->allocator, (tcpmon_session_server_thread_data_t *)data);
+ thread_data = NULL;
+ }
+ return NULL;
+}
+
+/* implementations for protected functions */
+
+axis2_status_t
+tcpmon_session_add_new_entry(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ tcpmon_entry_t * entry)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ axutil_array_list_add(session_impl->entries, env, entry);
+ return AXIS2_SUCCESS;
+
+}
+
+TCPMON_SESSION_TRANS_ERROR_FUNCT
+tcpmon_session_get_on_trans_fault(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ return session_impl->on_trans_fault_funct;
+}
+
+TCPMON_SESSION_NEW_ENTRY_FUNCT
+tcpmon_session_get_on_new_entry(
+ tcpmon_session_t * session,
+ const axutil_env_t * env)
+{
+ tcpmon_session_impl_t *session_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ session_impl = AXIS2_INTF_TO_IMPL(session);
+
+ return session_impl->on_new_entry_funct;
+}
diff --git a/tools/tcpmon/src/tcpmon.c b/tools/tcpmon/src/tcpmon.c
new file mode 100644
index 0000000..567bfc3
--- /dev/null
+++ b/tools/tcpmon/src/tcpmon.c
@@ -0,0 +1,1037 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axutil_utils.h>
+#include <axutil_uuid_gen.h>
+#include <axutil_error_default.h>
+#include <axutil_log_default.h>
+#include <axutil_thread_pool.h>
+#include <tcpmon_session.h>
+#include <tcpmon_entry.h>
+#include <tcpmon_util.h>
+#include <signal.h>
+#include <stdio.h>
+#include <axutil_stream.h>
+#include <axutil_network_handler.h>
+#include <axis2_http_transport.h>
+#include <axutil_version.h>
+
+#include <tcpmon_util.h>
+
+#define SIZE 1024
+axis2_char_t *tcpmon_traffic_log = "tcpmon_traffic.log";
+axutil_env_t *system_env = NULL;
+tcpmon_session_t *session = NULL;
+char *target_host = NULL;
+
+int on_new_entry(
+ const axutil_env_t * env,
+ tcpmon_entry_t * entry,
+ int status);
+
+int on_new_entry_to_file(
+ const axutil_env_t * env,
+ tcpmon_entry_t * entry,
+ int status);
+
+int on_error_func(
+ const axutil_env_t * env,
+ char *error_message);
+
+
+void sig_handler(
+ int signal);
+
+int resend_request(
+ const axutil_env_t * env,
+ int status);
+
+int
+main(
+ int argc,
+ char **argv)
+{
+ axutil_env_t *env = NULL;
+ int c;
+ int listen_port = 9099,
+ target_port = 9090; /* the default port simple axis2 server is run on 9090 */
+ int test_bit = 0;
+ int format_bit = 0; /* pretty print the request/response SOAP messages */
+ int ii = 1;
+
+ if (!axutil_strcmp(argv[1], "-h"))
+ {
+ printf
+ ("Usage : %s [-lp LISTEN_PORT] [-tp TARGET_PORT] [-th TARGET_HOST] [-f LOG_FILE] [options]\n",
+ argv[0]);
+ fprintf(stdout, " Options :\n");
+ fprintf(stdout,
+ "\t-lp LISTEN_PORT \tport number to listen on, default is 9099\n");
+ fprintf(stdout,
+ "\t-tp TARGET_PORT \tport number to connect and re-direct messages, default is 9090\n");
+ fprintf(stdout,
+ "\t-th TARGET_HOST \ttarget host to connect, default is localhost\n");
+ fprintf(stdout,
+ "\t-f LOG_FILE \tfile to write the messages to, default is %s\n",
+ tcpmon_traffic_log);
+ fprintf(stdout,
+ "\t--format \tenable xml formatting\n");
+ fprintf(stdout,
+ "\t--test \tenable testing last request/response by logging it separately\n");
+ fprintf(stdout, " Help :\n\t-h \tdisplay this help screen.\n\n");
+ return 0;
+ }
+
+ env = axutil_env_create_all("axis2_tcpmon.log", AXIS2_LOG_LEVEL_DEBUG);
+
+ signal(SIGINT, sig_handler);
+ system_env = env;
+#ifndef WIN32
+ signal(SIGPIPE, sig_handler);
+#endif
+
+ target_host = axutil_strdup(env, "localhost");
+
+ while (ii < argc)
+ {
+ if (!strcmp("-lp", argv[ii]))
+ {
+ ii++;
+ if (argv[ii])
+ {
+ listen_port = atoi(argv[ii++]);
+ if (listen_port == 0)
+ {
+ printf("INVALID value for listen port\n");
+ printf("Use -h for help\n");
+ AXIS2_FREE(env->allocator, target_host);
+ if (env)
+ {
+ axutil_env_free((axutil_env_t *) env);
+ env = NULL;
+ }
+ return 0;
+ }
+ }
+ }
+ else if (!strcmp("-tp", argv[ii]))
+ {
+ ii++;
+ if (argv[ii])
+ {
+ target_port = atoi(argv[ii++]);
+ if (target_port == 0)
+ {
+ printf("INVALID value for target port\n");
+ printf("Use -h for help\n");
+ AXIS2_FREE(env->allocator, target_host);
+ if (env)
+ {
+ axutil_env_free((axutil_env_t *) env);
+ env = NULL;
+ }
+ return 0;
+ }
+ }
+ }
+ else if (!strcmp("-th", argv[ii]))
+ {
+ ii++;
+ if (argv[ii])
+ {
+ AXIS2_FREE(env->allocator, target_host);
+ target_host = (char *) axutil_strdup(env, argv[ii++]);
+ }
+ }
+ else if (!strcmp("--test", argv[ii]))
+ {
+ ii++;
+ test_bit = 1;
+ }
+ else if (!strcmp("--format", argv[ii]))
+ {
+ ii++;
+ format_bit = 1;
+ }
+ else if (!strcmp("-f", argv[ii]))
+ {
+ ii++;
+ if (argv[ii])
+ {
+ tcpmon_traffic_log = argv[ii++];
+ }
+ }
+ else
+ {
+ printf("INVALID value for tcpmon \n");
+ printf("Use -h for help\n");
+ AXIS2_FREE(env->allocator, target_host);
+ if (env)
+ {
+ axutil_env_free((axutil_env_t *) env);
+ env = NULL;
+ }
+ return 0;
+ }
+ }
+
+ if (!(listen_port && target_port && target_host))
+ {
+ printf("ERROR: essential argument missing \n");
+ printf
+ ("Please recheck values of listen_port (-lp), target_port(-tp) and target_host (-th)\n");
+ AXIS2_FREE(env->allocator, target_host);
+ if (env)
+ {
+ axutil_env_free((axutil_env_t *) env);
+ env = NULL;
+ }
+ return 0;
+ }
+
+ printf("Listen port : %d Target port : %d Target host: %s\n",
+ listen_port, target_port, target_host);
+ session = tcpmon_session_create(env);
+
+ TCPMON_SESSION_SET_LISTEN_PORT(session, env, listen_port);
+ TCPMON_SESSION_SET_TARGET_PORT(session, env, target_port);
+ TCPMON_SESSION_SET_TARGET_HOST(session, env, target_host);
+ TCPMON_SESSION_ON_TRANS_FAULT(session, env, on_error_func);
+
+ TCPMON_SESSION_ON_NEW_ENTRY(session, env, on_new_entry_to_file);
+
+ TCPMON_SESSION_SET_TEST_BIT(session, env, test_bit);
+ TCPMON_SESSION_SET_FORMAT_BIT(session, env, format_bit);
+ TCPMON_SESSION_START(session, env);
+
+ do
+ {
+ c = getchar();
+ if (c == 'f')
+ {
+ format_bit = format_bit ? 0 : 1;
+ TCPMON_SESSION_SET_FORMAT_BIT(session, env, format_bit);
+ }
+ else if (c == 'r')
+ {
+ resend_request(env, 0);
+ }
+ }
+ while (c != 'q');
+ printf("\n\n");
+
+ TCPMON_SESSION_STOP(session, env);
+ TCPMON_SESSION_FREE(session, env);
+ AXIS2_FREE(env->allocator, target_host);
+ if (env)
+ {
+ axutil_env_free((axutil_env_t *) env);
+ env = NULL;
+ }
+ return 0;
+}
+
+int
+on_new_entry_to_file(
+ const axutil_env_t * env,
+ tcpmon_entry_t * entry,
+ int status)
+{
+ char *plain_buffer = NULL;
+ char *formated_buffer = NULL;
+ int format = 0;
+ FILE *file;
+ char *convert = NULL;
+ char *uuid = NULL;
+ int resend = 0;
+
+ file = fopen(tcpmon_traffic_log, "ab");
+
+ if (NULL == file)
+ {
+ printf("\ncould not create or open log-file\n");
+ return -1;
+ }
+
+ fprintf(file,
+ "\n= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =\n");
+
+ format = TCPMON_ENTRY_GET_FORMAT_BIT(entry, env);
+
+ if (status == 0)
+ {
+ if (strstr(TCPMON_ENTRY_SENT_HEADERS(entry, env), AXIS2_HTTP_HEADER_USER_AGENT
+ ": " AXIS2_HTTP_HEADER_SERVER_AXIS2C "TCPMon\r\n"))
+ {
+ resend = 1;
+ }
+ plain_buffer = TCPMON_ENTRY_SENT_DATA(entry, env);
+ if (plain_buffer) /* this can be possible as no xml present */
+ {
+ if (TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) !=
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env)) +
+ (int)strlen(plain_buffer) + 4)
+ {
+ format = 0; /* mtom scenario */
+ }
+ formated_buffer = tcpmon_util_format_as_xml
+ (env, plain_buffer, format);
+ }
+ else
+ {
+ formated_buffer = "";
+ }
+ /* 2 screen */
+ printf("\n\n%s\n", resend ? "RESENDING DATA..": "SENDING DATA..");
+ printf("/* sending time = %s*/\n", TCPMON_ENTRY_SENT_TIME(entry, env));
+ uuid = axutil_uuid_gen(env);
+ printf("/* message uuid = %s*/\n", uuid);
+ printf("---------------------\n");
+
+ if (format || TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env)) +
+ (int)strlen(formated_buffer) + 4)
+ {
+ printf("%s\n\n%s\n\n", TCPMON_ENTRY_SENT_HEADERS(entry, env),
+ formated_buffer);
+ }
+ else
+ {
+ int count = 0;
+ int printed = 0;
+ axis2_char_t *formated_buffer_temp = formated_buffer;
+ printf("%s\n\n", TCPMON_ENTRY_SENT_HEADERS(entry, env));
+ count = TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) - 4 -
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env));
+ while (count > printed)
+ {
+ int plen = 0;
+ plen = ((int)strlen(formated_buffer) + 1);
+ if (plen != 1)
+ {
+ printf("%s", formated_buffer);
+ }
+ printed += plen;
+ if (count > printed)
+ {
+ printf("%c", '\0');
+ formated_buffer += plen;
+ }
+ }
+ formated_buffer = formated_buffer_temp;
+ }
+
+ /* 2 file */
+ fprintf(file, "%s\n", resend ? "RESENDING DATA..": "SENDING DATA..");
+ fprintf(file, "/* sending time = %s*/\n",
+ TCPMON_ENTRY_SENT_TIME(entry, env));
+ fprintf(file, "/* message uuid = %s*/\n", uuid);
+ AXIS2_FREE(env->allocator, uuid);
+ fprintf(file, "---------------------\n");
+
+ convert = axutil_strdup(env, TCPMON_ENTRY_SENT_HEADERS(entry, env));
+ convert = tcpmon_util_str_replace(env, convert, "; ", ";\n\t");
+ fprintf(file, "%s\r\n\r\n", convert);
+ if (convert)
+ {
+ AXIS2_FREE(env->allocator, convert);
+ convert = NULL;
+ }
+ if (strcmp(formated_buffer, "") != 0)
+ {
+ if (format || TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env)) +
+ (int)strlen(formated_buffer) + 4)
+ {
+ convert = axutil_strdup(env, formated_buffer);
+ convert = tcpmon_util_str_replace(env, convert, "><", ">\n<");
+ fprintf(file, "%s", convert);
+ if (convert)
+ {
+ AXIS2_FREE(env->allocator, convert);
+ convert = NULL;
+ }
+ }
+ else
+ {
+ int count = 0;
+ int printed = 0;
+ count = TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) - 4 -
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env));
+ while (count > printed)
+ {
+ int plen = 0;
+ plen = ((int)strlen(formated_buffer) + 1);
+ if (plen != 1)
+ {
+ fprintf(file, "%s", formated_buffer);
+ }
+ printed += plen;
+ if (count > printed)
+ {
+ fprintf(file, "%c", '\0');
+ formated_buffer += plen;
+ }
+ }
+ }
+ }
+ }
+ if (status == 1)
+ {
+ plain_buffer = TCPMON_ENTRY_ARRIVED_DATA(entry, env);
+ if (plain_buffer) /* this can be possible as no xml present */
+ {
+ if (TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) !=
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env)) +
+ (int)strlen(plain_buffer) + 4)
+ {
+ format = 0; /* mtom scenario */
+ }
+ formated_buffer = tcpmon_util_format_as_xml
+ (env, plain_buffer, format);
+ }
+ else
+ {
+ formated_buffer = "";
+ }
+ /* 2 screen */
+ printf("\n\n%s\n", "RETRIEVING DATA..");
+ printf("/* retrieving time = %s*/\n",
+ TCPMON_ENTRY_ARRIVED_TIME(entry, env));
+ printf("/* time throughput = %s*/\n",
+ TCPMON_ENTRY_TIME_DIFF(entry, env));
+ printf("---------------------\n");
+
+ if (format || TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env)) +
+ (int)strlen(formated_buffer) + 4)
+ {
+ printf("%s\n\n%s\n\n", TCPMON_ENTRY_ARRIVED_HEADERS(entry, env),
+ formated_buffer);
+ }
+ else
+ {
+ int count = 0;
+ int printed = 0;
+ axis2_char_t *formated_buffer_temp = formated_buffer;
+ printf("%s\n\n", TCPMON_ENTRY_ARRIVED_HEADERS(entry, env));
+ count = TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) - 4 -
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env));
+ while (count > printed)
+ {
+ int plen = 0;
+ plen = ((int)strlen(formated_buffer) + 1);
+ if (plen != 1)
+ {
+ printf("%s", formated_buffer);
+ }
+ printed += plen;
+ if (count > printed)
+ {
+ printf("%c", '\0');
+ formated_buffer += plen;
+ }
+ }
+ formated_buffer = formated_buffer_temp;
+ }
+
+ /* 2 file */
+ fprintf(file, "%s\n", "RETRIEVING DATA..");
+ fprintf(file, "/* retrieving time = %s*/\n",
+ TCPMON_ENTRY_ARRIVED_TIME(entry, env));
+ fprintf(file, "/* time throughput = %s*/\n",
+ TCPMON_ENTRY_TIME_DIFF(entry, env));
+ fprintf(file, "---------------------\n");
+
+ convert = axutil_strdup(env, TCPMON_ENTRY_ARRIVED_HEADERS(entry, env));
+ convert = tcpmon_util_str_replace(env, convert, "; ", ";\n\t");
+ fprintf(file, "%s\r\n\r\n", convert);
+ if (convert)
+ {
+ AXIS2_FREE(env->allocator, convert);
+ convert = NULL;
+ }
+ if (strcmp(formated_buffer, "") != 0)
+ {
+ if (format || TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env)) +
+ (int)strlen(formated_buffer) + 4)
+ {
+ convert = axutil_strdup(env, formated_buffer);
+ convert = tcpmon_util_str_replace(env, convert, "><", ">\n<");
+ fprintf(file, "%s", convert);
+ if (convert)
+ {
+ AXIS2_FREE(env->allocator, convert);
+ convert = NULL;
+ }
+ }
+ else
+ {
+ int count = 0;
+ int printed = 0;
+ count = TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) - 4 -
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env));
+ while (count > printed)
+ {
+ int plen = 0;
+ plen = ((int)strlen(formated_buffer) + 1);
+ if (plen != 1)
+ {
+ fprintf(file, "%s", formated_buffer);
+ }
+ printed += plen;
+ if (count > printed)
+ {
+ fprintf(file, "%c", '\0');
+ formated_buffer += plen;
+ }
+ }
+ }
+ }
+ }
+ fclose(file);
+ return 0;
+}
+
+int
+resend_request(
+ const axutil_env_t * env,
+ int status)
+{
+ FILE *file;
+ axis2_char_t *uuid = NULL;
+ axis2_char_t *buffer = NULL;
+ int read_len = 0;
+
+ if (status == 0)
+ {
+ int c;
+ int i = 0;
+ do
+ {
+ c = getchar();
+ }
+ while (c == ' ');
+ uuid = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 37);
+ for (i = 0; i < 36; i++)
+ {
+ if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || c == '-')
+ {
+ uuid[i] = (axis2_char_t)c;
+ }
+ else if (c >= 'A' && c <= 'F')
+ {
+ uuid[i] = (axis2_char_t)(c + 32);
+ }
+ else
+ {
+ return 0;
+ }
+ c = getchar();
+ }
+ uuid[i] = '\0';
+ }
+
+ file = fopen(tcpmon_traffic_log, "rb");
+
+ if (!file)
+ {
+ printf("\ncould not create or open log-file\n");
+ return -1;
+ }
+
+ buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * SIZE);
+ if (!buffer)
+ {
+ printf("\ngimme more memory\n");
+ return -1;
+ }
+ buffer[SIZE - 1] = '\0';
+
+ read_len = (int)fread(buffer, sizeof(char), SIZE - 1, file);
+
+ while(read_len)
+ {
+ axis2_char_t *search = "/* message uuid = ";
+ axis2_char_t *tmp1 = NULL;
+ axis2_char_t *tmp2 = NULL;
+ axis2_char_t *tmp3 = NULL;
+ axis2_char_t *uuid_match = NULL;
+ int offset = 0;
+ int loop_state = 1;
+ int end_reached = 0;
+ int rounds = 0;
+
+ offset = (int)strlen(search);
+ tmp3 = buffer;
+ if (read_len >= SIZE)
+ {
+ AXIS2_FREE(env->allocator, buffer);
+ AXIS2_FREE(env->allocator, uuid);
+ printf("\nbuffer overflow\n");
+ return -1;
+ }
+ if (read_len < SIZE - 1)
+ {
+ end_reached = 1;
+ }
+ while (loop_state)
+ {
+ int temp_len = 0;
+ tmp1 = strstr(tmp3, search);
+ temp_len = (int)strlen(tmp3) + 1;
+ /* loop below is for mtom cases */
+ while (!tmp1 && (read_len - rounds > temp_len))
+ {
+ tmp3 += (int)strlen(tmp3) + 1;
+ tmp1 = strstr(tmp3, search);
+ temp_len += (int)strlen(tmp3) + 1;
+ }
+ if (!tmp1)
+ {
+ if (end_reached)
+ {
+ break;
+ }
+ memmove(buffer, buffer + (SIZE - 1 - offset), offset);
+ read_len = (int)fread(buffer + offset, sizeof(char),
+ SIZE - 1 - offset, file) + offset;
+ break;
+ }
+ else
+ {
+ rounds = (int)(tmp1 - tmp3) + offset + 36;
+ tmp3 = tmp1 + offset + 36;
+ }
+ if (read_len - offset - 36 < (int)(tmp1 - buffer))
+ {
+ if (end_reached)
+ {
+ break;
+ }
+ offset += 36;
+ memmove(buffer, buffer + (SIZE - 1 - offset), offset);
+ read_len = (int)fread(buffer + offset, sizeof(char),
+ SIZE - 1 - offset, file) + offset;
+ break;
+ }
+ tmp2 = tmp1 + offset;
+ uuid_match = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * 37);
+ if (!uuid_match)
+ {
+ printf("\ngimme more memory\n");
+ return -1;
+ }
+ memcpy(uuid_match, tmp2, 36);
+ uuid_match[36] = '\0';
+ if (!axutil_strcasecmp(uuid_match, uuid))
+ {
+ axis2_char_t *header_str = "*/\n---------------------\n";
+ axis2_char_t *footer_str =
+ "\n= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =";
+ int seek_len = 0;
+ int has_raw_binary = 0;
+ axis2_char_t *request_buffer = NULL;
+ AXIS2_FREE(env->allocator, uuid_match);
+ AXIS2_FREE(env->allocator, uuid);
+ end_reached = 1;
+ tmp2 += 36;
+ offset = (int)strlen(header_str);
+ if (read_len - offset < (int)(tmp2 - buffer))
+ {
+ seek_len = (int)(tmp2 - buffer) + offset - read_len;
+ if (seek_len > 0)
+ {
+ read_len = fread(buffer, sizeof(char), seek_len, file);
+ }
+ seek_len = 0;
+ }
+ else
+ {
+ seek_len = read_len - (int)(tmp2 - buffer) - offset;
+ }
+ request_buffer = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * (48 * 1024 + 1));
+ if (!request_buffer)
+ {
+ printf("\ngimme more memory\n");
+ return -1;
+ }
+ if (seek_len > 0)
+ {
+ memcpy(request_buffer, buffer + (read_len - seek_len), seek_len);
+ }
+ read_len = (int)fread(request_buffer + seek_len,
+ sizeof(char), 48 * 1024 - seek_len, file) + seek_len;
+ tmp1 = NULL;
+ tmp3 = request_buffer;
+ tmp1 = strstr(tmp3, footer_str);
+ temp_len = (int)strlen(tmp3) + 1;
+ /* loop below is for mtom cases */
+ while (!tmp1 && (read_len > temp_len))
+ {
+ if (!has_raw_binary)
+ {
+ has_raw_binary = 1;
+ }
+ tmp3 += (int)strlen(tmp3) + 1;
+ tmp1 = strstr(tmp3, footer_str);
+ temp_len += (int)strlen(tmp3) + 1;
+ }
+ if (tmp1)
+ {
+ axis2_char_t *req_header = NULL;
+ axis2_char_t *req_payload = NULL;
+ int req_content_len = 0;
+ req_content_len = (int)(tmp1 - request_buffer) - 4;
+ *tmp1 = '\0';
+ tmp1 = NULL;
+ tmp1 = strstr(request_buffer, "\r\n\r\n");
+ if (tmp1)
+ {
+ axis2_char_t *listen_host = "localhost";
+ int write_socket = -1;
+ axutil_stream_t *write_stream = NULL;
+ tmp1 += 2;
+ *tmp1 = '\0';
+ req_payload = tmp1 + 2;
+ tmp1 = axutil_strdup(env, request_buffer);
+ req_content_len -= (int)strlen(tmp1);
+ tmp1 = tcpmon_util_str_replace(env, tmp1, ";\n\t", "; ");
+ req_header = tmp1;
+ tmp2 = strstr(req_header, AXIS2_HTTP_HEADER_USER_AGENT ":");
+ if (tmp2)
+ {
+ tmp3 = strstr(tmp2, "\r\n");
+ if (tmp3)
+ {
+ int header_len = 0;
+ axis2_char_t *user_agent = AXIS2_HTTP_HEADER_USER_AGENT
+ ": " AXIS2_HTTP_HEADER_SERVER_AXIS2C " TCPMon";
+ header_len = (int)(tmp3 - tmp2) + 2;
+ tmp1 = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * header_len + 1);
+ memcpy(tmp1, tmp2, header_len);
+ tmp1[header_len] = '\0';
+ header_len = 2 + (int)strlen(user_agent);
+ tmp2 = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * (header_len + 1));
+ sprintf(tmp2, "%s\r\n", user_agent);
+ req_header = tcpmon_util_str_replace(env, req_header, tmp1, tmp2);
+ AXIS2_FREE(env->allocator, tmp1);
+ AXIS2_FREE(env->allocator, tmp2);
+ tmp1 = NULL;
+ tmp2 = NULL;
+ }
+ }
+ if (!has_raw_binary)
+ {
+ tmp2 = strstr(req_header, AXIS2_HTTP_HEADER_CONTENT_LENGTH ":");
+ if (tmp2)
+ {
+ tmp3 = strstr(tmp2, "\r\n");
+ if (tmp3)
+ {
+ int header_len = 0;
+ header_len = (int)(tmp3 - tmp2) + 2;
+ tmp1 = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * header_len + 1);
+ memcpy(tmp1, tmp2, header_len);
+ tmp1[header_len] = '\0';
+ tmp2 = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * (header_len + 2));
+ req_content_len = (int)strlen(req_payload);
+ sprintf(tmp2, "%s%d\r\n", AXIS2_HTTP_HEADER_CONTENT_LENGTH
+ ": ", req_content_len);
+ req_header = tcpmon_util_str_replace(env, req_header, tmp1, tmp2);
+ AXIS2_FREE(env->allocator, tmp1);
+ AXIS2_FREE(env->allocator, tmp2);
+ tmp1 = NULL;
+ tmp2 = NULL;
+ }
+ }
+ }
+ tmp2 = strstr(req_header, AXIS2_HTTP_HEADER_HOST ":");
+ if (tmp2)
+ {
+ tmp3 = strstr(tmp2, "\r\n");
+ if (tmp3)
+ {
+ int header_len = 0;
+ header_len = (int)(tmp3 - tmp2) + 2;
+ tmp1 = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * header_len + 1);
+ memcpy(tmp1, tmp2, header_len);
+ tmp1[header_len] = '\0';
+ header_len = 16 + (int)strlen(target_host);
+ tmp2 = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * (header_len + 1));
+ sprintf(tmp2, "%s%s:%d\r\n", AXIS2_HTTP_HEADER_HOST ": ", target_host,
+ TCPMON_SESSION_GET_LISTEN_PORT(session, env));
+ req_header = tcpmon_util_str_replace(env, req_header, tmp1, tmp2);
+ AXIS2_FREE(env->allocator, tmp1);
+ AXIS2_FREE(env->allocator, tmp2);
+ tmp1 = NULL;
+ tmp2 = NULL;
+ }
+ }
+ write_socket =
+ (int)axutil_network_handler_open_socket(env, listen_host,
+ TCPMON_SESSION_GET_LISTEN_PORT(session, env));
+ if (write_socket == -1)
+ {
+ printf("\nerror in creating socket\n");
+ }
+ else
+ {
+ write_stream = axutil_stream_create_socket(env, write_socket);
+ }
+ if (!write_stream)
+ {
+ printf("\nerror in creating stream\n");
+ }
+ else
+ {
+ axutil_stream_write(write_stream, env, req_header, strlen(req_header));
+ axutil_stream_write(write_stream, env, "\r\n", 2);
+ axutil_stream_write(write_stream, env, req_payload, req_content_len);
+ axutil_stream_free(write_stream, env);
+ axutil_network_handler_close_socket(env, write_socket);
+ }
+ AXIS2_FREE(env->allocator, req_header);
+ }
+ }
+ else if (read_len == 48 * 1024)
+ {
+ printf("\nrequest size greater than buffer\n");
+ }
+ AXIS2_FREE(env->allocator, request_buffer);
+ break;
+ }
+ AXIS2_FREE(env->allocator, uuid_match);
+ }
+ if (end_reached)
+ {
+ break;
+ }
+ }
+ AXIS2_FREE(env->allocator, buffer);
+
+ fclose(file);
+ return 0;
+}
+
+int
+on_new_entry(
+ const axutil_env_t * env,
+ tcpmon_entry_t * entry,
+ int status)
+{
+ char *plain_buffer = NULL;
+ char *formated_buffer = NULL;
+ int format = 0;
+ char *uuid = NULL;
+ int resend = 0;
+
+ format = TCPMON_ENTRY_GET_FORMAT_BIT(entry, env);
+
+ if (status == 0)
+ {
+ if (strstr(TCPMON_ENTRY_SENT_HEADERS(entry, env),
+ AXIS2_HTTP_HEADER_USER_AGENT ": "\
+ AXIS2_HTTP_HEADER_SERVER_AXIS2C " TCPMon\r\n"))
+ {
+ resend = 1;
+ }
+ plain_buffer = TCPMON_ENTRY_SENT_DATA(entry, env);
+ if (plain_buffer) /* this can be possible as no xml present */
+ {
+ if (TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env)) +
+ (int)strlen(plain_buffer) + 4)
+ {
+ format = 0; /* mtom scenario */
+ }
+ formated_buffer = tcpmon_util_format_as_xml
+ (env, plain_buffer, format);
+ }
+ else
+ {
+ formated_buffer = "";
+ }
+ printf("\n\n%s\n", resend ? "RESENDING DATA..": "SENDING DATA..");
+ printf("/* sending time = %s*/\n", TCPMON_ENTRY_SENT_TIME(entry, env));
+ uuid = axutil_uuid_gen(env);
+ printf("/* message uuid = %s*/\n", uuid);
+ AXIS2_FREE(env->allocator, uuid);
+ printf("---------------------\n");
+
+ if (format || TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env)) +
+ (int)strlen(formated_buffer) + 4)
+ {
+ printf("%s\n\n%s\n\n", TCPMON_ENTRY_SENT_HEADERS(entry, env),
+ formated_buffer);
+ }
+ else
+ {
+ int count = 0;
+ int printed = 0;
+ axis2_char_t *formated_buffer_temp = formated_buffer;
+ printf("%s\n", TCPMON_ENTRY_SENT_HEADERS(entry, env));
+ count = TCPMON_ENTRY_GET_SENT_DATA_LENGTH(entry, env) - 4 -
+ (int)strlen(TCPMON_ENTRY_SENT_HEADERS(entry, env));
+ while (count > printed)
+ {
+ int plen = 0;
+ plen = ((int)strlen(formated_buffer) + 1);
+ if (plen != 1)
+ {
+ printf("%s", formated_buffer);
+ }
+ printed += plen;
+ if (count > printed)
+ {
+ printf("%c", '\0');
+ formated_buffer += plen;
+ }
+ }
+ formated_buffer = formated_buffer_temp;
+ }
+ }
+ if (status == 1)
+ {
+ plain_buffer = TCPMON_ENTRY_ARRIVED_DATA(entry, env);
+ if (plain_buffer) /* this can be possible as no xml present */
+ {
+ if (TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env)) +
+ (int)strlen(plain_buffer) + 4)
+ {
+ format = 0; /* mtom scenario */
+ }
+ formated_buffer = tcpmon_util_format_as_xml
+ (env, plain_buffer, format);
+ }
+ else
+ {
+ formated_buffer = "";
+ }
+ printf("\n\n%s\n", "RETRIEVING DATA..");
+ printf("/* retrieving time = %s*/\n",
+ TCPMON_ENTRY_ARRIVED_TIME(entry, env));
+ printf("/* time throughput = %s*/\n",
+ TCPMON_ENTRY_TIME_DIFF(entry, env));
+ printf("---------------------\n");
+
+ if (format || TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) ==
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env)) +
+ (int)strlen(formated_buffer) + 4)
+ {
+ printf("%s\n\n%s\n\n", TCPMON_ENTRY_ARRIVED_HEADERS(entry, env),
+ formated_buffer);
+ }
+ else
+ {
+ int count = 0;
+ int printed = 0;
+ axis2_char_t *formated_buffer_temp = formated_buffer;
+ printf("%s\n", TCPMON_ENTRY_ARRIVED_HEADERS(entry, env));
+ count = TCPMON_ENTRY_GET_ARRIVED_DATA_LENGTH(entry, env) - 4 -
+ (int)strlen(TCPMON_ENTRY_ARRIVED_HEADERS(entry, env));
+ while (count > printed)
+ {
+ int plen = 0;
+ plen = ((int)strlen(formated_buffer) + 1);
+ if (plen != 1)
+ {
+ printf("%s", formated_buffer);
+ }
+ printed += plen;
+ if (count > printed)
+ {
+ printf("%c", '\0');
+ formated_buffer += plen;
+ }
+ }
+ formated_buffer = formated_buffer_temp;
+ }
+ }
+ return 0;
+}
+
+int
+on_error_func(
+ const axutil_env_t * env,
+ char *error_message)
+{
+ fprintf(stderr, "ERROR: %s\n", error_message);
+ return 0;
+}
+
+
+/**
+ * Signal handler
+ */
+void
+sig_handler(
+ int signal)
+{
+
+ if (!system_env)
+ {
+ AXIS2_LOG_ERROR(system_env->log, AXIS2_LOG_SI,
+ "Received signal %d, unable to proceed system_env is NULL,\
+ system exit with -1", signal);
+ _exit (-1);
+ }
+
+ switch (signal)
+ {
+ case SIGINT:
+ {
+ AXIS2_LOG_INFO(system_env->log, "Received signal SIGINT. Utility "
+ "shutting down");
+ printf("\n\n");
+ TCPMON_SESSION_STOP(session, system_env);
+ TCPMON_SESSION_FREE(session, system_env);
+ AXIS2_FREE(system_env->allocator, target_host);
+ if (system_env)
+ {
+ axutil_env_free(system_env);
+ }
+ exit(0);
+ }
+#ifndef WIN32
+ case SIGPIPE:
+ {
+ AXIS2_LOG_INFO(system_env->log, "Received signal SIGPIPE. Operation "
+ "aborted");
+ return;
+ }
+#endif
+ case SIGSEGV:
+ {
+ fprintf(stderr, "Received deadly signal SIGSEGV. Terminating\n");
+ _exit(-1);
+ }
+ }
+}
+
diff --git a/tools/tcpmon/src/tcpmon_entry_local.h b/tools/tcpmon/src/tcpmon_entry_local.h
new file mode 100644
index 0000000..8ba9c6a
--- /dev/null
+++ b/tools/tcpmon/src/tcpmon_entry_local.h
@@ -0,0 +1,16 @@
+#include <axutil_env.h>
+#include "tcpmon_entry.h"
+#include "tcpmon_session_local.h"
+
+typedef struct tcpmon_entry_request_data
+{
+ const axutil_env_t *env;
+ int socket;
+ tcpmon_session_t *session;
+}
+tcpmon_entry_request_data_t;
+
+void *AXIS2_CALL
+tcpmon_entry_new_entry_funct(
+ axutil_thread_t * thd,
+ void *data);
diff --git a/tools/tcpmon/src/tcpmon_session_local.h b/tools/tcpmon/src/tcpmon_session_local.h
new file mode 100644
index 0000000..eee9cc6
--- /dev/null
+++ b/tools/tcpmon/src/tcpmon_session_local.h
@@ -0,0 +1,15 @@
+#include <tcpmon_session.h>
+#include <tcpmon_entry.h>
+
+axis2_status_t tcpmon_session_add_new_entry(
+ tcpmon_session_t * session,
+ const axutil_env_t * env,
+ tcpmon_entry_t * entry);
+
+TCPMON_SESSION_TRANS_ERROR_FUNCT tcpmon_session_get_on_trans_fault(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
+
+TCPMON_SESSION_NEW_ENTRY_FUNCT tcpmon_session_get_on_new_entry(
+ tcpmon_session_t * session,
+ const axutil_env_t * env);
diff --git a/tools/tcpmon/src/util.c b/tools/tcpmon/src/util.c
new file mode 100644
index 0000000..d4a73ee
--- /dev/null
+++ b/tools/tcpmon/src/util.c
@@ -0,0 +1,806 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axiom.h>
+#include <stdlib.h>
+
+#include <tcpmon_util.h>
+
+#define START_ELEMENT 1
+#define CHAR_VALUE 2
+#define END_ELEMENT 3
+#define EMPTY_ELEMENT 4
+
+typedef struct tcpmon_util_allocator
+{
+ int allocated;
+ int index;
+ axis2_char_t *buffer;
+}
+tcpmon_util_allocator_t;
+
+/*static void add_string(const axutil_env_t* env,
+ tcpmon_util_allocator_t* allocator,
+ axis2_char_t* string);
+*/
+
+/*static void add_axis2_char_t(const axutil_env_t* env,
+ tcpmon_util_allocator_t* allocator,
+ axis2_char_t c,
+ int turns);
+*/
+axis2_char_t *
+tcpmon_util_format_as_xml(
+ const axutil_env_t * env,
+ axis2_char_t * data,
+ int format)
+{
+ if (format)
+ {
+ int c;
+ int tab_pos = 0;
+ int has_value = 0;
+ int has_space = 0;
+ int start_ele = 0;
+ int prev_case = 0;
+ int buffer_size = 0;
+
+ axis2_char_t *out;
+
+ axiom_xml_reader_t *xml_reader = NULL;
+
+ buffer_size = 2 * ((int)strlen(data));
+ /* We are sure that the difference lies within the int range */
+ out = AXIS2_MALLOC(env->allocator, buffer_size * sizeof(axis2_char_t));
+
+ if (data)
+ {
+ int size = 0;
+ size = (int)strlen(data);
+ /* We are sure that the difference lies within the int range */
+ xml_reader =
+ axiom_xml_reader_create_for_memory(env, data, size, "utf-8",
+ AXIS2_XML_PARSER_TYPE_BUFFER);
+ if (!xml_reader)
+ return NULL;
+ }
+
+ axiom_xml_reader_init();
+
+ while ((c = axiom_xml_reader_next(xml_reader, env)) != -1)
+ {
+ switch (c)
+ {
+ case AXIOM_XML_READER_START_DOCUMENT:
+ {
+ int ix;
+
+ tcpmon_util_strcat(out, "<?xml ", &buffer_size, env);
+
+ ix = axiom_xml_reader_get_attribute_count(xml_reader, env);
+ for (; ix > 0; ix--)
+ {
+ axis2_char_t *attr_prefix;
+ axis2_char_t *attr_name;
+ axis2_char_t *attr_value;
+
+ attr_prefix =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_prefix_by_number
+ (xml_reader, env, ix);
+ if (attr_prefix)
+ {
+ tcpmon_util_strcat(out, attr_prefix, &buffer_size, env);
+ tcpmon_util_strcat(out, ":", &buffer_size, env);
+ }
+
+ attr_name =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_name_by_number
+ (xml_reader, env, ix);
+ if (attr_name)
+ {
+ tcpmon_util_strcat(out, attr_name, &buffer_size, env);
+ tcpmon_util_strcat(out, "=\"", &buffer_size, env);
+ }
+
+ attr_value =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_value_by_number
+ (xml_reader, env, ix);
+ if (attr_value)
+ {
+ tcpmon_util_strcat(out, attr_value, &buffer_size, env);
+ tcpmon_util_strcat(out, "\"", &buffer_size, env);
+ }
+ }
+
+ printf("?>");
+ }
+ break;
+ case AXIOM_XML_READER_START_ELEMENT:
+ {
+ int i,
+ ix,
+ has_prefix = 0;
+
+ axis2_char_t *ele_name;
+ axis2_char_t *ele_prefix;
+
+ prev_case = START_ELEMENT;
+
+ has_value = 0;
+ has_space = 0;
+
+ if (start_ele != 0)
+ tcpmon_util_strcat(out, "\n", &buffer_size, env);
+
+ for (i = 0; i < tab_pos; i++)
+ tcpmon_util_strcat(out, "\t", &buffer_size, env);
+
+ tcpmon_util_strcat(out, "<", &buffer_size, env);
+
+ ele_prefix =
+ (axis2_char_t *) axiom_xml_reader_get_prefix(xml_reader,
+ env);
+ if (ele_prefix)
+ {
+ tcpmon_util_strcat(out, ele_prefix, &buffer_size, env);
+ tcpmon_util_strcat(out, ":", &buffer_size, env);
+ }
+
+ ele_name =
+ (axis2_char_t *) axiom_xml_reader_get_name(xml_reader,
+ env);
+ if (ele_name)
+ {
+ tcpmon_util_strcat(out, ele_name, &buffer_size, env);
+ }
+
+ ix = axiom_xml_reader_get_attribute_count(xml_reader, env);
+ for (; ix > 0; ix--)
+ {
+ axis2_char_t *attr_prefix;
+ axis2_char_t *attr_name;
+ axis2_char_t *attr_value;
+
+ attr_prefix =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_prefix_by_number
+ (xml_reader, env, ix);
+ if (attr_prefix)
+ {
+ has_prefix = 1;
+ tcpmon_util_strcat(out, " ", &buffer_size, env);
+ tcpmon_util_strcat(out, attr_prefix, &buffer_size, env);
+ tcpmon_util_strcat(out, ":", &buffer_size, env);
+ }
+
+ attr_name =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_name_by_number
+ (xml_reader, env, ix);
+ if (attr_name)
+ {
+ if (has_prefix)
+ {
+ tcpmon_util_strcat(out, attr_name, &buffer_size,
+ env);
+ tcpmon_util_strcat(out, "=\"", &buffer_size, env);
+ }
+ else
+ {
+ tcpmon_util_strcat(out, " ", &buffer_size, env);
+ tcpmon_util_strcat(out, attr_name, &buffer_size,
+ env);
+ tcpmon_util_strcat(out, "=\"", &buffer_size, env);
+ }
+
+ has_prefix = 0;
+ }
+
+ attr_value =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_value_by_number
+ (xml_reader, env, ix);
+ if (attr_value)
+ {
+ tcpmon_util_strcat(out, attr_value, &buffer_size, env);
+ tcpmon_util_strcat(out, "\"", &buffer_size, env);
+ }
+ }
+
+ tcpmon_util_strcat(out, ">", &buffer_size, env);
+
+ tab_pos++;
+ start_ele = 1;
+ }
+ break;
+ case AXIOM_XML_READER_CHARACTER:
+ {
+ axis2_char_t *ele_value;
+
+ prev_case = CHAR_VALUE;
+
+ ele_value = axiom_xml_reader_get_value(xml_reader, env);
+ if (ele_value)
+ tcpmon_util_strcat(out, ele_value, &buffer_size, env);
+
+ has_value = 1;
+
+ }
+ break;
+ case AXIOM_XML_READER_EMPTY_ELEMENT:
+ {
+ int i,
+ ix,
+ has_prefix = 0;
+
+ axis2_char_t *ele_name;
+ axis2_char_t *ele_prefix;
+
+ prev_case = EMPTY_ELEMENT;
+
+ has_value = 0;
+ has_space = 0;
+
+ if (start_ele != 0)
+ tcpmon_util_strcat(out, "\n", &buffer_size, env);
+
+ for (i = 0; i < tab_pos; i++)
+ tcpmon_util_strcat(out, "\t", &buffer_size, env);
+
+ tcpmon_util_strcat(out, "<", &buffer_size, env);
+
+ ele_prefix =
+ (axis2_char_t *) axiom_xml_reader_get_prefix(xml_reader,
+ env);
+ if (ele_prefix)
+ {
+ tcpmon_util_strcat(out, ele_prefix, &buffer_size, env);
+ tcpmon_util_strcat(out, ":", &buffer_size, env);
+ }
+
+ ele_name =
+ (axis2_char_t *) axiom_xml_reader_get_name(xml_reader,
+ env);
+ if (ele_name)
+ tcpmon_util_strcat(out, ele_name, &buffer_size, env);
+
+ ix = axiom_xml_reader_get_attribute_count(xml_reader, env);
+ for (; ix > 0; ix--)
+ {
+ axis2_char_t *attr_prefix;
+ axis2_char_t *attr_name;
+ axis2_char_t *attr_value;
+
+ attr_prefix =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_prefix_by_number
+ (xml_reader, env, ix);
+ if (attr_prefix)
+ {
+ has_prefix = 1;
+ tcpmon_util_strcat(out, " ", &buffer_size, env);
+ tcpmon_util_strcat(out, attr_prefix, &buffer_size, env);
+ tcpmon_util_strcat(out, ":", &buffer_size, env);
+ }
+
+ attr_name =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_name_by_number
+ (xml_reader, env, ix);
+ if (attr_name)
+ {
+ if (has_prefix)
+ {
+ tcpmon_util_strcat(out, attr_name, &buffer_size,
+ env);
+ tcpmon_util_strcat(out, "=\"", &buffer_size, env);
+ }
+ else
+ {
+ tcpmon_util_strcat(out, " ", &buffer_size, env);
+ tcpmon_util_strcat(out, attr_name, &buffer_size,
+ env);
+ tcpmon_util_strcat(out, "=\"", &buffer_size, env);
+ }
+ has_prefix = 0;
+ }
+
+ attr_value =
+ (axis2_char_t *)
+ axiom_xml_reader_get_attribute_value_by_number
+ (xml_reader, env, ix);
+ if (attr_value)
+ {
+ tcpmon_util_strcat(out, attr_value, &buffer_size, env);
+ tcpmon_util_strcat(out, "\"", &buffer_size, env);
+ }
+ }
+
+ tcpmon_util_strcat(out, "/>", &buffer_size, env);
+ start_ele = 1;
+ }
+ break;
+ case AXIOM_XML_READER_END_ELEMENT:
+ {
+ int i;
+
+ axis2_char_t *ele_prefix;
+ axis2_char_t *ele_name;
+
+ tab_pos--;
+
+ if (has_value == 0 && prev_case != START_ELEMENT)
+ {
+ tcpmon_util_strcat(out, "\n", &buffer_size, env);
+ for (i = 0; i < tab_pos; i++)
+ tcpmon_util_strcat(out, "\t", &buffer_size, env);
+ }
+
+ has_value = 0;
+
+ tcpmon_util_strcat(out, "</", &buffer_size, env);
+
+ ele_prefix =
+ (axis2_char_t *) axiom_xml_reader_get_prefix(xml_reader,
+ env);
+ if (ele_prefix)
+ {
+ tcpmon_util_strcat(out, ele_prefix, &buffer_size, env);
+ tcpmon_util_strcat(out, ":", &buffer_size, env);
+ }
+
+ ele_name =
+ (axis2_char_t *) axiom_xml_reader_get_name(xml_reader,
+ env);
+ if (ele_name)
+ {
+ tcpmon_util_strcat(out, ele_name, &buffer_size, env);
+ tcpmon_util_strcat(out, ">", &buffer_size, env);
+ }
+ prev_case = END_ELEMENT;
+
+ }
+ break;
+ }
+ }
+ return out;
+ }
+ return data;
+}
+
+/*void add_string(const axutil_env_t* env,
+ tcpmon_util_allocator_t* allocator,
+ axis2_char_t* string)
+{
+ int additional_len = 0;
+ void* dest = NULL;
+ void* src = NULL;
+ int count = 0;
+
+ additional_len = axutil_strlen(string) + 1;
+ if (allocator-> index + additional_len >= allocator-> allocated)
+ {
+ if (allocator-> allocated == 0)
+ {
+ allocator-> buffer =
+ AXIS2_MALLOC(env-> allocator, additional_len);
+ }
+ else
+ {
+ allocator-> buffer =
+ AXIS2_REALLOC(env-> allocator, allocator-> buffer,
+ allocator-> allocated + additional_len);
+ }
+ allocator-> allocated += additional_len;
+ }
+
+ dest = allocator-> buffer + allocator-> index;
+ src = string;
+ count = additional_len;
+ memcpy(dest, src, count);
+
+ allocator-> index += count - 1;
+}
+*/
+
+/*void add_axis2_char_t(const axutil_env_t* env,
+ tcpmon_util_allocator_t* allocator,
+ axis2_char_t c,
+ int turns)
+{
+ int additional_len = 0;
+
+ additional_len = turns + 1;
+ if (allocator-> index + additional_len >= allocator-> allocated)
+ {
+ if (allocator-> allocated == 0)
+ {
+ allocator-> buffer =
+ AXIS2_MALLOC(env-> allocator, additional_len);
+ }
+ else
+ {
+ allocator-> buffer =
+ AXIS2_REALLOC(env-> allocator, allocator-> buffer,
+ allocator-> allocated + additional_len);
+ }
+ allocator-> allocated += additional_len;
+ }
+
+ memset(allocator-> buffer + allocator-> index, c, turns);
+
+ allocator-> index += turns;
+
+} */
+
+axis2_char_t *
+tcpmon_util_strcat(
+ axis2_char_t * dest,
+ axis2_char_t * source,
+ int *buff_size,
+ const axutil_env_t * env)
+{
+ int cur_len = 0;
+ int source_len = 0;
+
+ axis2_char_t *tmp;
+ cur_len = (int)strlen(dest);
+ /* We are sure that the difference lies within the int range */
+ source_len = (int)strlen(source);
+ /* We are sure that the difference lies within the int range */
+
+ if ((*buff_size - cur_len) < source_len)
+ {
+ *buff_size = *buff_size + (*buff_size * 2);
+ tmp =
+ (axis2_char_t *) AXIS2_REALLOC(env->allocator, dest,
+ *buff_size * sizeof(axis2_char_t));
+ dest = tmp;
+ strcat((char *) dest, (char *) source);
+ }
+ else
+ {
+ strcat((char *) dest, (char *) source);
+ }
+
+ return dest;
+}
+
+char *
+tcpmon_util_str_replace(
+ const axutil_env_t *env,
+ char *str,
+ const char *search,
+ const char *replace)
+{
+ char *str_return = NULL;
+ char *str_tmp = NULL;
+ char *str_relic = NULL;
+ int size = ((int)strlen(str)) * 2;
+ /* We are sure that the difference lies within the int range */
+ int addmem = size;
+ int diff = (int)(strlen(replace) - strlen(search));
+ /* We are sure that the difference lies within the int range */
+
+ str_return = (char *) AXIS2_MALLOC(env->allocator, ((size + 1) * sizeof(char)));
+ str_tmp = (char *) AXIS2_MALLOC(env->allocator, (size * sizeof(char)));
+
+
+ if (str_return == NULL || str_tmp == NULL)
+ {
+ AXIS2_FREE(env->allocator, str_return);
+ str_return = NULL;
+ AXIS2_FREE(env->allocator, str_tmp);
+ str_tmp = NULL;
+ return "function tcpmon_util_str_replace : give me more memory";
+ }
+ if (!strcmp(search, replace))
+ {
+ AXIS2_FREE(env->allocator, str_return);
+ str_return = NULL;
+ AXIS2_FREE(env->allocator, str_tmp);
+ str_tmp = NULL;
+ return str;
+ }
+
+ strcpy(str_return, str);
+
+ while ((str_relic = strstr(str_return, search)) != NULL)
+ {
+ if ((int)strlen(str_return) + diff >= addmem)
+ /* We are sure that the difference lies within the int range */
+ {
+ str_return = (char *) realloc(str_return, addmem += size);
+ str_tmp = (char *) realloc(str_tmp, addmem);
+
+ if (str_return == NULL || str_tmp == NULL)
+ {
+ AXIS2_FREE(env->allocator, str_return);
+ str_return = NULL;
+ AXIS2_FREE(env->allocator, str_tmp);
+ str_tmp = NULL;
+ return "function tcpmon_str_replace : gimme more memory";
+ }
+ }
+
+ strcpy(str_tmp, replace);
+ strcat(str_tmp, (str_relic + strlen(search)));
+ *str_relic = '\0';
+
+ strcat(str_return, str_tmp);
+ }
+
+ AXIS2_FREE(env->allocator, str_tmp);
+ str_tmp = NULL;
+ /* free(str); */ /* we are not allocating memory using str */
+ str_return[addmem] = '\0';
+ return (str_return);
+}
+
+
+axis2_char_t *
+tcpmon_util_read_current_stream(
+ const axutil_env_t * env,
+ axutil_stream_t * stream,
+ int *stream_size,
+ axis2_char_t ** header,
+ axis2_char_t ** data)
+{
+ int read_size = 0;
+ axis2_char_t *buffer = NULL;
+ axis2_char_t *header_ptr = NULL;
+ axis2_char_t *body_ptr = NULL;
+ int header_found = 0;
+ int header_just_finished = 0;
+ int read = 0;
+ int header_width = 0;
+ int current_line_offset = 0;
+ int mtom_optimized = 0;
+ axis2_char_t *current_line = NULL;
+ int line_just_ended = 1;
+ axis2_char_t *length_char = 0;
+ int length = -1;
+ int chunked_encoded = 0;
+ int is_get = 0;
+ int zero_content_length = 0;
+
+ buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t));
+ *data = NULL;
+ *header = NULL;
+ do
+ {
+ buffer = AXIS2_REALLOC(env->allocator, buffer,
+ sizeof(axis2_char_t) * (read_size + 1));
+ *(buffer + read_size) = '\0';
+ read = axutil_stream_read(stream, env, buffer + read_size, 1);
+
+ if (header_just_finished)
+ {
+ header_just_finished = 0;
+ header_width = read_size;
+ }
+
+ /** identify the content lenth*/
+ if (!header_found && *(buffer + read_size) == '\r')
+ {
+ *(buffer + read_size) = '\0';
+ current_line = buffer + current_line_offset;
+ if (!mtom_optimized && strstr(current_line, "multipart/related"))
+ mtom_optimized = 1;
+ if (strstr(current_line, "Content-Length"))
+ {
+ length_char = strstr(current_line, ":");
+ if (length_char)
+ {
+ length_char++;
+ length = atoi(length_char);
+ if (length == 0)
+ {
+ zero_content_length = 1;
+ }
+ }
+ }
+ if (strstr(current_line, "GET") || strstr(current_line, "HEAD")
+ || strstr(current_line, "DELETE"))
+ {
+ is_get = 1;
+ /** Captures GET style requests */
+ }
+ *(buffer + read_size) = '\r';
+ }
+ if (!header_found && line_just_ended)
+ {
+ line_just_ended = 0;
+ current_line_offset = read_size;
+ }
+ if (!header_found && *(buffer + read_size) == '\n')
+ {
+ line_just_ended = 1; /* set for the next loop to read */
+ }
+ if (header_found)
+ {
+ length--;
+ }
+ if (header_found &&
+ read_size >= 4 &&
+ chunked_encoded == 1 &&
+ *(buffer + read_size) == '\n' &&
+ *(buffer + read_size - 1) == '\r' &&
+ *(buffer + read_size - 2) == '\n' &&
+ *(buffer + read_size - 3) == '\r' &&
+ *(buffer + read_size - 4) == '0')
+ {
+
+ length = 0; /** this occurs in chunked transfer encoding */
+ }
+
+ /** identify the end of the header */
+ if (!header_found &&
+ read_size >= 3 &&
+ *(buffer + read_size) == '\n' &&
+ *(buffer + read_size - 1) == '\r' &&
+ *(buffer + read_size - 2) == '\n' &&
+ *(buffer + read_size - 3) == '\r')
+ {
+ header_found = 1;
+ *(buffer + read_size - 3) = '\0';
+ if (header_ptr)
+ {
+ AXIS2_FREE(env->allocator, header_ptr);
+ }
+ header_ptr = (axis2_char_t *) axutil_strdup(env, buffer);
+ header_just_finished = 1;
+ *(buffer + read_size - 3) = '\r';
+ if (is_get && length == -1)
+ {
+ break;
+ }
+ }
+ read_size++;
+ if (!chunked_encoded && length < -1)
+ {
+ header_width = 0;
+ /* break; */
+
+ /** this is considered as transfer-encoding = chunked */
+ chunked_encoded = 1;
+ header_found = 1;
+ *(buffer + read_size - 3) = '\0';
+ if (header_ptr)
+ {
+ AXIS2_FREE(env->allocator, header_ptr);
+ }
+ header_ptr = (axis2_char_t *) axutil_strdup(env, buffer);
+ header_just_finished = 1;
+ *(buffer + read_size - 3) = '\r';
+ }
+ if (!(*(buffer + read_size - 1)))
+ {
+ if (!mtom_optimized)
+ {
+ read_size--;
+ length = 0;
+ }
+ else
+ {
+ /**(buffer + read_size - 1) = ' ';*/
+ }
+ }
+ }
+ while (length != 0);
+
+ if (is_get)
+ {
+ read_size++;
+ }
+ else if (zero_content_length)
+ {
+ read_size += 3;
+ }
+
+ buffer = AXIS2_REALLOC(env->allocator, buffer,
+ sizeof(axis2_char_t) * (read_size + 1));
+ *(buffer + read_size) = '\0';
+
+ if (header_width != 0)
+ {
+ body_ptr = buffer + header_width;
+ if (body_ptr && *body_ptr)
+ {
+ if (mtom_optimized)
+ {
+ int count = read_size - (int)strlen(header_ptr) - 4;
+ int copied = 0;
+ int plen = 0;
+ axis2_char_t *temp = NULL;
+ temp = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_char_t) * count + 1);
+ while(count > copied)
+ {
+ plen = 0;
+ plen = ((int)strlen(body_ptr) + 1);
+ if (plen != 1)
+ {
+ sprintf(temp, "%s", body_ptr);
+ }
+ copied += plen;
+ if (count > copied)
+ {
+ temp += plen;
+ body_ptr += plen;
+ }
+ }
+ copied -= plen;
+ temp -= copied;
+ temp[count] = '\0';
+ *data = temp;
+ }
+ else
+ {
+ *data = (axis2_char_t *) axutil_strdup(env, body_ptr);
+ }
+ }
+ body_ptr = NULL;
+ }
+ else
+ {
+ /** soap body part is unavailable */
+ if (is_get)
+ {
+ *data = (axis2_char_t *) axutil_strdup(env, "\n");
+ *(buffer + read_size - 1) = '\n';
+ }
+ else if (zero_content_length)
+ {
+ *data = (axis2_char_t *) axutil_strdup(env, "\n");
+ *(buffer + read_size - 3) = '\n';
+ *(buffer + read_size - 2) = '\r';
+ *(buffer + read_size - 1) = '\n';
+ }
+ if (header_ptr)
+ {
+ AXIS2_FREE(env->allocator, header_ptr);
+ }
+ header_ptr = (axis2_char_t *) axutil_strdup(env, buffer);
+ }
+
+ *header = header_ptr;
+ *stream_size = read_size;
+ return buffer;
+}
+
+
+int
+tcpmon_util_write_to_file(
+ char *filename,
+ char *buffer)
+{
+ int size = 0;
+ if (filename)
+ {
+ FILE *fp = fopen(filename, "ab");
+ size = (int)fwrite(buffer, 1, strlen(buffer), fp);
+ /* We are sure that the difference lies within the int range */
+ fclose(fp);
+ }
+ return size;
+}
+
diff --git a/tools/tcpmon/test/Makefile.am b/tools/tcpmon/test/Makefile.am
new file mode 100644
index 0000000..85eb6ca
--- /dev/null
+++ b/tools/tcpmon/test/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = unit
diff --git a/tools/tcpmon/test/unit/Makefile.am b/tools/tcpmon/test/unit/Makefile.am
new file mode 100644
index 0000000..719bd16
--- /dev/null
+++ b/tools/tcpmon/test/unit/Makefile.am
@@ -0,0 +1,19 @@
+TESTS =
+prgbindir=$(prefix)/bin/unit_test
+prgbin_PROGRAMS = tcpmon_unit_test_suite
+
+tcpmon_unit_test_suite_SOURCES = main.c tcpmon_test.c
+
+tcpmon_unit_test_suite_LDADD = \
+ $(top_builddir)/src/libaxis2_tcpmon.la \
+ -L$(CUTEST_HOME)/lib \
+ -lcutest \
+ ../../../../util/src/libaxutil.la \
+ ../../../../axiom/src/om/libaxis2_axiom.la \
+ $(NULL)
+
+
+INCLUDES = -I${CUTEST_HOME}/include \
+ -I$(top_builddir)/include \
+ -I ../../../../util/include \
+ $(NULL)
diff --git a/tools/tcpmon/test/unit/main.c b/tools/tcpmon/test/unit/main.c
new file mode 100644
index 0000000..531ed66
--- /dev/null
+++ b/tools/tcpmon/test/unit/main.c
@@ -0,0 +1,44 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <CuTest.h>
+#include <stdio.h>
+#include "tcpmon_test.h"
+
+void
+RunAllTests(
+ void)
+{
+ CuString *output = CuStringNew();
+ CuSuite *suite = CuSuiteNew();
+
+ CuSuiteAddSuite(suite, (CuSuite *) tcpmon_GetSuite());
+
+ CuSuiteRun(suite);
+ CuSuiteSummary(suite, output);
+ CuSuiteDetails(suite, output);
+ printf("%s\n", output->buffer);
+}
+
+int
+main(
+ void)
+{
+ RunAllTests();
+ return 0;
+}
diff --git a/tools/tcpmon/test/unit/result b/tools/tcpmon/test/unit/result
new file mode 100644
index 0000000..130ca3a
--- /dev/null
+++ b/tools/tcpmon/test/unit/result
@@ -0,0 +1,14 @@
+F
+
+There was 1 failure:
+1) test_format_xml: tcpmon_test.c:28: expected <<input>
+ check for one step
+ </input>
+ > but was <<input>
+ check for one step
+</input>
+í>
+
+!!!FAILURES!!!
+Runs: 1 Passes: 0 Fails: 1
+
diff --git a/tools/tcpmon/test/unit/tcpmon_test.c b/tools/tcpmon/test/unit/tcpmon_test.c
new file mode 100644
index 0000000..f5ee7be
--- /dev/null
+++ b/tools/tcpmon/test/unit/tcpmon_test.c
@@ -0,0 +1,85 @@
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <CuTest.h>
+#include <axutil_utils.h>
+#include "tcpmon_test.h"
+#include <stdlib.h>
+#include <axutil_string.h>
+
+#include <tcpmon_util.h>
+
+void
+test_format_xml(
+ CuTest * tc)
+{
+ axutil_env_t *env;
+ axutil_allocator_t *allocator;
+ axis2_char_t *input;
+ axis2_char_t *actual;
+ axis2_char_t *expected;
+
+ allocator = axutil_allocator_init(NULL);
+ env = axutil_env_create(allocator);
+
+ input = (char *) axutil_strdup(env, "<input>check for one step</input>");
+ actual = (char *) tcpmon_util_format_as_xml(env, input);
+ expected = "<input>\n" "\tcheck for one step\n" "</input>\n";
+ CuAssertStrEquals(tc, expected, actual);
+ free(actual);
+ free(input);
+
+ input =
+ (char *) axutil_strdup(env,
+ "<input><tag2><another_tag with='attriutes'>check for one step</another_tag></tag2></input>");
+ actual = (char *) tcpmon_util_format_as_xml(env, input);
+ expected =
+ "<input>\n"
+ "\t<tag2>\n"
+ "\t\t<another_tag with='attriutes'>\n"
+ "\t\t\tcheck for one step\n"
+ "\t\t</another_tag>\n" "\t</tag2>\n" "</input>\n";
+
+ CuAssertStrEquals(tc, expected, actual);
+ free(actual);
+ free(input);
+
+ input = (char *) axutil_strdup(env,
+ "<?processing inc?><input><tag2><another_tag with='attriutes'>check for one step</another_tag></tag2></input>");
+ actual = (char *) tcpmon_util_format_as_xml(env, input);
+ expected = "<?processing inc?>\n"
+ "<input>\n"
+ "\t<tag2>\n"
+ "\t\t<another_tag with='attriutes'>\n"
+ "\t\t\tcheck for one step\n"
+ "\t\t</another_tag>\n" "\t</tag2>\n" "</input>\n";
+
+ CuAssertStrEquals(tc, expected, actual);
+ free(actual);
+ free(input);
+
+}
+
+CuSuite *
+tcpmon_GetSuite(
+ )
+{
+ CuSuite *suite = CuSuiteNew();
+ SUITE_ADD_TEST(suite, test_format_xml);
+ return suite;
+}
diff --git a/tools/tcpmon/test/unit/tcpmon_test.h b/tools/tcpmon/test/unit/tcpmon_test.h
new file mode 100644
index 0000000..66c2e0a
--- /dev/null
+++ b/tools/tcpmon/test/unit/tcpmon_test.h
@@ -0,0 +1,9 @@
+#ifndef TCPMON_TEST_H
+#define TCPMON_TEST_H
+
+#include <CuTest.h>
+
+CuSuite *tcpmon_GetSuite(
+);
+
+#endif /* TCPMON_TEST_H */