diff options
Diffstat (limited to 'tools/tcpmon')
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 */ |