Fix raw socket ipv6 support

* Do not track response by default

* Add track-response integration test

* Apply fmt

.dockerignore

@@ -1 +1,3 @@
 *.tar.gz
+gor
+gor.test

.gitignore

@@ -2,3 +2,16 @@
 *.gor
 
 *.out
+
+*.bin
+
+*.gz
+
+*.class
+
+*.test
+.idea
+*.iml
+gor
+
+*.mprof

.travis.yml

@@ -1,3 +1,6 @@
-language: go 
-go: 1.3.3
-script: sudo -E bash -c "source /etc/profile && eval '$(gimme 1.4)' && export GOPATH=$HOME/gopath:$GOPATH && go get && GORACE='halt_on_error=1' go test -race -v"
+language: go
+go: 1.6
+script: sudo -E bash -c "source /etc/profile && eval '$(gimme 1.6)' && export GOPATH=$HOME/gopath:$GOPATH && go get && GORACE='halt_on_error=1' go test ./... -v -timeout 120s -race"
+
+before_install:
+  - sudo apt-get install libpcap-dev -y

CHANGELOG.md

@@ -1,25 +0,0 @@
-v0.7.0 - 31 Oct 2013
-* New modular architecture. Listener and Replay functionality merged.
-* Added option to equally split traffic between multiple outputs: --split-output true
-* Saving requests to file and replaying from it
-* Injecting custom headers to http requests
-* Advanced stats using ElasticSearch
-
-v0.3.5 - 15 Sep 2013
-* Significantly improved test coverage
-* Fixed bug with redirect replay https://github.com/buger/gor/pull/15
-* Added limit on listener side
-* Improved stability (catch and log panic, instead of exiting)
-* Added License file
-
-v0.3.3 - 22 Jun 2013
-* Using TCP instead of UDP for communication between Listener and Replay
-* Significantly improved performance
-* Fixed bugs causing locking and message dropping (concurrency issues)
-* Rewrote concurrency model to use more channels
-
-v0.3 - 10 Jun 2013
-* Use RAW_SOCKETS instead of tcpdump
-* Own TCP stack
-* All HTTP request types support
-* Simplified request parsing

COMM-LICENSE

@@ -0,0 +1,95 @@
+END-USER LICENSE AGREEMENT
+
+------------------------------------------------------------------------------
+
+IMPORTANT: THIS SOFTWARE END-USER LICENSE AGREEMENT ("EULA") IS A LEGAL AGREEMENT (“Agreement”) BETWEEN YOU (THE CUSTOMER, EITHER AS AN INDIVIDUAL OR, IF PURCHASED OR OTHERWISE ACQUIRED BY OR FOR AN ENTITY, AS AN ENTITY) AND REPLAY SOFTWARE. READ IT CAREFULLY BEFORE COMPLETING THE INSTALLATION PROCESS AND USING GOR PRO AND RELATED SOFTWARE COMPONENTS (“SOFTWARE”). IT PROVIDES A LICENSE TO USE THE SOFTWARE AND CONTAINS WARRANTY INFORMATION AND LIABILITY DISCLAIMERS. BY INSTALLING AND USING THE SOFTWARE, YOU ARE CONFIRMING YOUR ACCEPTANCE OF THE SOFTWARE AND AGREEING TO BECOME BOUND BY THE TERMS OF THIS AGREEMENT.
+
+------------------------------------------------------------------------------
+
+In order to use the Software under this Agreement, you must receive a “Source URL” at the time of purchase, in accordance with the scope of use and other terms specified for each type of Software and as set forth in this Section 1 of this Agreement. 
+
+1. License Grant
+
+1.1 General Use. This Agreement grants you a non-exclusive, non-transferable, limited license to the use rights for the Software, without the right to grant sublicenses, subject to the terms and conditions in this Agreement. The Software is licensed, not sold.
+
+1.2 Unlimited Organization License. If you purchased an Organization License (included with the Gor Pro Software), you may install the Software on an unlimited number of Hosts. “Host” means any physical or virtual machine which is controlled by you. You may also run an unlimited number of Workers. “Worker” means a thread within a Gor server process which executes jobs. You may concurrently run the software on an unlimited number of Hosts, with each host running an unlimited number of Workers.
+
+1.3 Limited Organization License. If you purchased an Organization License (included with the Gor Enterprise Software), you may install the Software on an unlimited number of Hosts. “Host” means any physical or virtual machine which is controlled by you. The aggregate number of Workers run by the hosts must not exceed the maximum number of Workers authorized at the time of purchase. “Worker” means a running Gor instance which intercept or replay traffic. In order to run additional Workers, you must purchase an additional allowance from Replay Software.
+
+1.4 Appliance License. If you purchased an Appliance License, you may distribute the Software in any applications, frameworks, or elements (collectively referred to as an “Application” or “Applications”) that you develop using the Software in accordance with this EULA, provided that such distribution does not violate the restrictions set forth in section 3 of this EULA. You must not remove, obscure or interfere with any copyright, acknowledgment, attribution, trademark, warning or disclaimer statement affixed to, incorporated in or otherwise applied in connection with the Software. You are required to ensure that the Software is not reused by or with any applications other than those with which you distribute it as permitted herein. For example, if You install the Software on a customer’s server, that customer is not permitted to use the Software independently of your Application. You must inform Replay Software of your knowledge of any infringing use of the Software by any of your customers. You are liable for compliance by those third parties with the terms and conditions of this EULA. You will not owe Replay Software any royalties for your distribution of the Software in accordance with this EULA.
+
+1.5 Archive Copies. You are entitled to make a reasonable amount of copies of the Software for archival purposes. Each copy must reproduce all copyright and other proprietary rights notices on or in the Software Product.
+
+1.6 Electronic Delivery. All Software and license documentation shall be delivered by electronic means unless otherwise specified on the applicable invoice or at the time of purchase. Software shall be deemed delivered when it is made available for download by you (“Delivery”).        
+
+2. Modifications. Replay Software shall provide you with source code so that you can create Modifications of the original software. “Modification” means: (a) any addition to or deletion from the contents of a file included in the original Software or previous Modifications created by You, or (b) any new file that contains any part of the original Software or previous Modifications. While you retain all rights to any original work authored by you as part of the Modifications, We continue to own all copyright and other intellectual property rights in the Software.
+
+3. Restricted Uses. 
+
+3.1 You shall not (and shall not allow any third party to): (a) decompile, disassemble, or otherwise reverse engineer the Software or attempt to reconstruct or discover any source code, underlying ideas, algorithms, file formats or programming interfaces of the Software by any means whatsoever (except and only to the extent that applicable law prohibits or restricts reverse engineering restrictions); (b) distribute, sell, sublicense, rent, lease or use the Software for time sharing, hosting, service provider or like purposes, except as expressly permitted under this Agreement; (c) redistribute the Software or Modifications other than by including the Software or a portion thereof within your own product, which must have substantially different functionality than the Software or Modifications and must not allow any third party to use the Software or Modifications, or any portions thereof, for software development or application development purposes; (d) redistribute the Software as part of a product, "appliance" or "virtual server"; (e) redistribute the Software on any server which is not directly under your control; (f) remove any product identification, proprietary, copyright or other notices contained in the Software; (g) modify any part of the Software, create a derivative work of any part of the Software (except as permitted in Section 4), or incorporate the Software, except to the extent expressly authorized in writing by Replay Software; (h) publicly disseminate performance information or analysis (including, without limitation, benchmarks) from any source relating to the Software; (i) utilize any equipment, device, software, or other means designed to circumvent or remove any form of Source URL or copy protection used by Replay Software in connection with the Software, or use the Software together with any authorization code, Source URL, serial number, or other copy protection device not supplied by Replay Software; (j) use the Software to develop a product which is competitive with any Replay Software product offerings; or (k) use unauthorized Source URLS or keycode(s) or distribute or publish Source URLs or keycode(s), except as may be expressly permitted by Replay Software in writing. If your unique Source URL is ever published, Replay Software reserves the right to terminate your access without notice.
+
+3.2 UNDER NO CIRCUMSTANCES MAY YOU USE THE SOFTWARE AS PART OF A PRODUCT OR SERVICE THAT PROVIDES SIMILAR FUNCTIONALITY TO THE SOFTWARE ITSELF.
+
+The Open Source version of the Software (“LGPL Version”) is licensed
+under the terms of the GNU Lesser General Public License versions 3.0
+(“LGPL”) and not under this EULA. 
+
+4. Ownership. Notwithstanding anything to the contrary contained herein, except for the limited license rights expressly provided herein, Replay Software and its suppliers have and will retain all rights, title and interest (including, without limitation, all patent, copyright, trademark, trade secret and other intellectual property rights) in and to the Software and all copies, modifications and derivative works thereof (including any changes which incorporate any of your ideas, feedback or suggestions). You acknowledge that you are obtaining only a limited license right to the Software, and that irrespective of any use of the words “purchase”, “sale” or like terms hereunder no ownership rights are being conveyed to you under this Agreement or otherwise. 
+
+5. Fees and Payment. The Software license fees will be due and payable in full as set forth in the applicable invoice or at the time of purchase. If the Software does not function properly within two weeks of purchase, please contact us within those two weeks for a refund. You shall be responsible for all taxes, withholdings, duties and levies arising from the order (excluding taxes based on the net income of Replay Software). 
+
+6. Support, Maintenance and Services. Subject to the terms and conditions of this Agreement, as set forth in your invoice, and as set forth on the Gor Pro support page (https://github.com/buger/gor/wiki/Pro-Support), support and maintenance services may be included with the purchase of your license subscription.
+
+7. Term of Agreement. 
+
+7.1 Term. This Agreement is effective as of the Delivery of the Software and expires at such time as all license and service subscriptions hereunder have expired in accordance with their own terms (the “Term”). For clarification, the term of your license under this Agreement may be perpetual, limited for Evaluation Version, or designated as a fixed-term license in the Invoice, and shall be specified at your time of purchase. Either party may terminate this Agreement (including all related Invoices) if the other party: (a) fails to cure any material breach of this Agreement within thirty (30) days after written notice of such breach, provided that Replay Software may terminate this Agreement immediately upon any breach of Section 3 or if you exceed any other restrictions contained in Section 1, unless otherwise specified in this agreement; (b) ceases operation without a successor; or (c) seeks protection under any bankruptcy, receivership, trust deed, creditors arrangement, composition or comparable proceeding, or if any such proceeding is instituted against such party (and not dismissed within sixty (60) days)). Termination is not an exclusive remedy and the exercise by either party of any remedy under this Agreement will be without prejudice to any other remedies it may have under this Agreement, by law, or otherwise.        
+
+7.2 Termination. Upon any termination of this Agreement, you shall cease any and all use of any Software and destroy all copies thereof. 
+
+7.3 Expiration of License. Upon the expiration of any term under this Agreement, (a) all Software updates and services pursuant to the license shall cease, (b) you may only continue to run existing installations of the Software, (c) you may not install the Software on any additional Hosts, and (d) any new installation of the Software shall require the purchase of a new license subscription from Replay Software.
+
+8. Disclaimer of Warranties. The Software is provided "as is," with all faults, defects and errors, and without warranty of any kind. Replay Software does not warrant that the Software will be free of bugs, errors, viruses or other defects, and Replay Software shall have no liability of any kind for the use of or inability to use the Software, the Software content or any associated service, and you acknowledge that it is not technically practicable for Replay Software to do so. 
+To the maximum extent permitted by applicable law, Replay Software disclaims all warranties, express, implied, arising by law or otherwise, regarding the Software, the Software content and their respective performance or suitability for your intended use, including without limitation any implied warranty of merchantability, fitness for a particular purpose.
+
+9. Limitation of Liability. 
+
+In no event will Replay Software be liable for any direct, indirect, consequential, incidental, special, exemplary, or punitive damages or liabilities whatsoever arising from or relating to the Software, the Software content or this Agreement, whether based on contract, tort (including negligence), strict liability or other theory, even if Replay Software has been advised of the possibility of such damages.
+
+In no event will Replay Software' liability exceed the Software license price as indicated in the invoice. The existence of more than one claim will not enlarge or extend this limit.
+
+10. Remedies. Your exclusive remedy and Replay Software’ entire liability for breach of this Agreement shall be limited, at Replay Software’ sole and exclusive discretion, to (a) replacement of any defective software or documentation; or (b) refund of the license fee paid to Replay Software, payable in accordance with Replay Software' refund policy.
+
+11. Acknowledgements.
+
+11.1 Consent to the Use of Data. You agree that Replay Software and its affiliates may collect and use technical information gathered as part of the product support services. Replay Software may use this information solely to improve products and services and will not disclose this information in a form that personally identifies you.
+
+11.2 Verification. We or a certified auditor acting on our behalf, may, upon its reasonable request and at its expense, audit you with respect to the use of the Software. Such audit may be conducted by mail, electronic means or through an in-person visit to your place of business. Any such in-person audit shall be conducted during regular business hours at your facilities and shall not unreasonably interfere with your business activities. We shall not remove, copy, or redistribute any electronic material during the course of an audit. If an audit reveals that you are using the Software in a way that is in material violation of the terms of the EULA, then you shall pay our reasonable costs of conducting the audit. In the case of a material violation, you agree to pay Us any amounts owing that are attributable to the unauthorized use. In the alternative, We reserve the right, at our sole option, to terminate the licenses for the Software.
+
+11.3 Government End Users. If the Software and related documentation are supplied to or purchased by or on behalf of the United States Government, then the Software is deemed to be "commercial software" as that term is used in the Federal Acquisition Regulation system. Rights of the United States shall not exceed the minimum rights set forth in FAR 52.227-19 for "restricted computer software". All other terms and conditions of this Agreement apply.
+
+12. Third Party Software.  Examples included in Software may provide links to third party libraries or code (collectively “Third Party Software”) to implement various functions. Third Party Software does not comprise part of the Software. In some cases, access to Third Party Software may be included along with the Software delivery as a convenience for demonstration purposes. Such source code and libraries may be included in the “…/examples” source tree delivered with the Software and do not comprise the Software. Licensee acknowledges (1) that some part of Third Party Software may require additional licensing of copyright and patents from the owners of such, and (2) that distribution of any of the Software referencing or including any portion of a Third Party Software may require appropriate licensing from such third parties.
+
+
+13. Miscellaneous
+
+13.1 Entire Agreement. This Agreement sets forth our entire agreement with respect to the Software and the subject matter hereof and supersedes all prior and contemporaneous understandings and agreements whether written or oral.
+
+13.2 Amendment. Replay Software reserves the right, in its sole discretion, to amend this Agreement from time. Amendments to this Agreement can be located at: https://github.com/buger/gor/blob/master/COMM-LICENSE.
+
+13.3 Assignment. You may not assign this Agreement or any of its rights under this Agreement without the prior written consent of Replay Software and any attempted assignment without such consent shall be void.
+
+13.4 Export Compliance. You agree to comply with all applicable laws and regulations, including laws, regulations, orders or other restrictions on export, re-export or redistribution of software.
+
+13.5 Indemnification. You agree to defend, indemnify, and hold harmless Replay Software from and against any lawsuits, claims, losses, damages, fines and expenses (including attorneys' fees and costs) arising out of your use of the Software or breach of this Agreement.
+
+13.6 Governing Law. This Agreement is governed by the laws of the State of Oregon and the United States without regard to conflicts of laws provisions thereof, and without regard to the United Nations Convention on the International Sale of Goods or the Uniform Computer Information Transactions Act, as currently enacted by any jurisdiction or as may be codified or amended from time to time by any jurisdiction. The jurisdiction and venue for actions related to the subject matter hereof shall be the state of Oregon and United States federal courts located in Portland, Oregon, and both parties hereby submit to the personal jurisdiction of such courts. 
+
+13.7 Attorneys’ Fees and Costs. The prevailing party in any action to enforce this Agreement will be entitled to recover its attorneys’ fees and costs in connection with such action. 
+
+13.8 Severability. If any provision of this Agreement is held by a court of competent jurisdiction to be invalid, illegal, or unenforceable, the remainder of this Agreement will remain in full force and effect.
+
+13.9 Waiver. Failure or neglect by either party to enforce at any time any of the provisions of this licence Agreement shall not be construed or deemed to be a waiver of that party's rights under this Agreement.
+
+13.10 Headings. The headings of sections and paragraphs of this Agreement are for convenience of reference only and are not intended to restrict, affect or be of any weight in the interpretation or construction of the provisions of such sections or paragraphs.
+
+14. Contact Information. If you have any questions about this EULA, or if you want to contact Replay Software for any reason, please direct correspondence to info@gortool.com

Dockerfile

@@ -1,9 +1,22 @@
-FROM google/golang
+FROM golang:latest
 
-RUN cd /goroot/src/ && GOOS=linux GOARCH=386 ./make.bash --no-clean
+RUN apt-get update && apt-get install ruby vim-common -y
 
-WORKDIR /gopath/src/github.com/buger/gor/
+# Install Java for middleware testing
+RUN echo "deb http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main" | tee /etc/apt/sources.list.d/webupd8team-java.list
+RUN echo "deb-src http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main" | tee -a /etc/apt/sources.list.d/webupd8team-java.list
+RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys EEA14886
+RUN apt-get update -y
+RUN echo oracle-java7-installer shared/accepted-oracle-license-v1-1 select true | /usr/bin/debconf-set-selections
+RUN apt-get install oracle-java8-installer -y
 
-ADD . /gopath/src/github.com/buger/gor/
+RUN apt-get install flex bison -y
+RUN wget http://www.tcpdump.org/release/libpcap-1.7.4.tar.gz && tar xzf libpcap-1.7.4.tar.gz && cd libpcap-1.7.4 && ./configure && make install
+RUN go get github.com/google/gopacket
+RUN go get -u github.com/golang/lint/golint
 
+WORKDIR /go/src/github.com/buger/gor/
+ADD . /go/src/github.com/buger/gor/
+
+RUN javac -cp /tmp/commons-io-2.4/commons-io-2.4.jar ./examples/middleware/echo.java
 RUN go get

LICENSE.txt

@@ -1,191 +1,7 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
+Gor is an Open Source project licensed under the terms of
+the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for license text.
 
-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:
-
-You must give any other recipients of the Work or Derivative Works a copy of
-this License; and
-You must cause any modified files to carry prominent notices stating that You
-changed the files; and
-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
-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.
+Gor Pro has a commercial-friendly license allowing private forks
+and modifications of Gor.  Please see http://gortool.com/#pro for
+more detail.  You can find the commercial license terms in COMM-LICENSE.

Makefile

@@ -1,37 +1,80 @@
-SOURCE = emitter.go gor.go gor_stat.go input_dummy.go input_file.go input_raw.go input_tcp.go limiter.go output_dummy.go output_file.go input_http.go output_http.go output_tcp.go plugins.go settings.go test_input.go elasticsearch.go http_modifier.go http_modifier_settings.go http_client.go
+SOURCE = emitter.go gor.go gor_stat.go input_dummy.go input_file.go input_raw.go input_tcp.go limiter.go output_dummy.go output_file.go input_http.go output_http.go output_tcp.go plugins.go settings.go test_input.go elasticsearch.go http_modifier.go http_modifier_settings.go http_client.go middleware.go protocol.go
+SOURCE_PATH = /go/src/github.com/buger/gor/
+RUN = docker run -v `pwd`:$(SOURCE_PATH) -p 0.0.0.0:8000:8000 -t -i gor
+BENCHMARK = BenchmarkRAWInput
+TEST = TestRawListenerBench
+VERSION = DEV-$(shell date +%s)
+LDFLAGS = -ldflags "-X main.VERSION=$(VERSION) -extldflags \"-static\""
+MAC_LDFLAGS = -ldflags "-X main.VERSION=$(VERSION)"
 
-SOURCE_PATH = /gopath/src/github.com/buger/gor/
-
-release: release-x86 release-x64
+release: release-x64 release-mac
 
 release-x64:
-	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=amd64 --env CGO_ENABLED=0 -i gor go build && tar -czf gor_x64.tar.gz gor && rm gor
+	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=amd64  -i gor go build $(LDFLAGS) && tar -czf gor_$(VERSION)_x64.tar.gz gor && rm gor
 
 release-x86:
-	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=386 --env CGO_ENABLED=0 -i gor go build && tar -czf gor_x86.tar.gz gor && rm gor
+	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=386 -i gor go build $(LDFLAGS) && tar -czf gor_$(VERSION)_x86.tar.gz gor && rm gor
 
-dbuild:
+release-mac:
+	go build $(MAC_LDFLAGS) && tar -czf gor_$(VERSION)_mac.tar.gz gor && rm gor
+
+build:
 	docker build -t gor .
 
-dtest:
-	docker run -v `pwd`:$(SOURCE_PATH) -t -i --env GORACE="halt_on_error=1" gor go test ./... $(ARGS) -race -v -timeout 15s
 
-dcover:
-	docker run -v `pwd`:$(SOURCE_PATH) -t -i --env GORACE="halt_on_error=1" gor go test $(ARGS) -race -v -timeout 15s -coverprofile=coverage.out
+profile:
+	go build && ./gor --output-http="http://localhost:9000" --input-dummy 0 --input-raw :9000 --input-http :9000 --memprofile=./mem.out --cpuprofile=./cpu.out --stats --output-http-stats --output-http-timeout 100ms
+
+lint:
+	$(RUN) golint $(PKG)
+
+race:
+	$(RUN) go test ./... $(ARGS) -v -race -timeout 15s
+
+test:
+	$(RUN) go test ./. -race -timeout 60s $(LDFLAGS) $(ARGS)  -v
+
+test_all:
+	$(RUN) go test ./... -timeout 60s $(LDFLAGS) $(ARGS) -v
+
+testone:
+	$(RUN) go test ./... -timeout 4s $(LDFLAGS) -run $(TEST) $(ARGS) -v
+
+cover:
+	$(RUN) go test $(ARGS) -race -v -timeout 15s -coverprofile=coverage.out
 	go tool cover -html=coverage.out
 
-dfmt:
-	docker run -v `pwd`:$(SOURCE_PATH) -t -i gor go fmt
+fmt:
+	$(RUN) gofmt -w -s ./..
 
-dvet:
-	docker run -v `pwd`:$(SOURCE_PATH) -t -i gor go vet
+vet:
+	$(RUN) go vet
 
-dbench:
-	docker run -v `pwd`:$(SOURCE_PATH) -t -i gor go test -v -run NOT_EXISTING -bench HTTP
+bench:
+	$(RUN) go test $(LDFLAGS) -v -run NOT_EXISTING -bench $(BENCHMARK) -benchtime 5s
+
+profile_test:
+	$(RUN) go test $(LDFLAGS) -run $(TEST) ./raw_socket_listener/. $(ARGS) -memprofile mem.mprof -cpuprofile cpu.out
+	$(RUN) go test $(LDFLAGS) -run $(TEST) ./raw_socket_listener/. $(ARGS) -c
 
 # Used mainly for debugging, because docker container do not have access to parent machine ports
-drun:
-	docker run -v `pwd`:$(SOURCE_PATH) -t -i gor go run $(SOURCE) --input-dummy=0 --output-http="http://localhost:9000"  --verbose -h
+run:
+	$(RUN) go run $(LDFLAGS) $(SOURCE) --input-dummy=0 --output-http="http://localhost:9000" --input-raw-track-response --input-raw 127.0.0.1:9000 --input-http 127.0.0.1:9000 --verbose --debug --middleware "./examples/middleware/echo.sh"
 
-dbash: 
-	docker run -v `pwd`:$(SOURCE_PATH) -t -i gor /bin/bash
+run-2:
+	sudo -E go run $(SOURCE) --input-dummy="" --output-tcp localhost:27001 --verbose --debug
+
+run-3:
+	sudo -E go run $(SOURCE) --input-tcp :27001 --output-stdout
+
+run-4:
+	sudo -E go run $(SOURCE) --input-http 127.0.0.1:8081 --input-raw 127.0.0.1:8081 --output-stdout --input-raw-engine raw_socket
+
+record:
+	$(RUN) go run $(SOURCE) --input-dummy=0 --output-file=requests.gor --verbose --debug
+
+replay:
+	$(RUN) go run $(SOURCE) --input-file=requests.bin --output-tcp=:9000 --verbose -h
+
+bash:
+	$(RUN) /bin/bash

README.md

@@ -1,383 +1,46 @@
-[![Build Status](https://travis-ci.org/buger/gor.png?branch=master)](https://travis-ci.org/buger/gor)
+[![GitHub release](https://img.shields.io/github/release/buger/gor.svg?maxAge=3600)](https://github.com/buger/gor/releases) [![codebeat](https://codebeat.co/badges/6427d589-a78e-416c-a546-d299b4089893)](https://codebeat.co/projects/github-com-buger-gor) [![Go Report Card](https://goreportcard.com/badge/github.com/buger/gor)](https://goreportcard.com/report/github.com/buger/gor) [![Join the chat at https://gitter.im/buger/gor](https://badges.gitter.im/buger/gor.svg)](https://gitter.im/buger/gor?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## About
 
-Gor is a simple http traffic replication tool written in Go.
-Its main goal is to replay traffic from production servers to staging and dev environments.
-
+Gor is an open-source tool for capturing and replaying live HTTP traffic into a test environment in order to continuously test your system with real data. It can be used to increase confidence in code deployments, configuration changes and infrastructure changes.
 
 Now you can test your code on real user sessions in an automated and repeatable fashion.
 **No more falling down in production!**
 
 Here is basic workflow: The listener server catches http traffic and sends it to the replay server or saves to file. The replay server forwards traffic to a given address.
 
-
 ![Diagram](http://i.imgur.com/9mqj2SK.png)
 
+## Installation
+Download latest binary from https://github.com/buger/gor/releases or (compile by yourself)[Compilation].
 
-## Examples
+## Getting started
 
-### Capture traffic from port
-```bash
-# Run on servers where you want to catch traffic. You can run it on each `web` machine.
-sudo gor --input-raw :80 --output-tcp replay.local:28020
+The most basic setup will be `sudo ./gor --input-raw :8000 --output-stdout` which acts like tcpdump.
+If you already have test environment you can start replaying: `sudo ./gor --input-raw :8000 --output-http http://staging.env`.
 
-# Replay server (replay.local).
-gor --input-tcp replay.local:28020 --output-http http://staging.com
-```
+See the our wiki and especially [Getting started](https://github.com/buger/gor/wiki/Getting-Started) wiki page for more info. 
 
-Since Gor use raw sockets to capture traffic it require `sudo` access. Alternatively you can allow access to raw sockets like this: `sudo setcap CAP_NET_RAW=ep gor`
 
-### Using 1 Gor instance for both listening and replaying
-It's recommended to use separate server for replaying traffic, but if you have enough CPU resources you can use single Gor instance.
+## Want to Upgrade?
 
-```
-sudo gor --input-raw :80 --output-http "http://staging.com"
-```
+I also sell Gor Pro, extensions to Gor which provide more features, a commercial-friendly license and allow you to support high quality open source development all at the same time. Please see the Gor [homepage](https://gortool.com/) for more detail.
 
-### Guarantee of replay and HTTP input
-Due to how traffic interception works, there is chance of missing requests. If you want guarantee that requests will be replayed you can use http input, but it will require changes in your app as well. 
+Subscribe to the [quarterly newsletter](https://tinyletter.com/gor) to stay informed about the latest features and changes to Gor and its bigger siblings.
 
-```
-sudo gor --input-http :28019 --output-http "http://staging.com"
-```
+## Problems?
+If you have a problem, please review the [FAQ](https://github.com/buger/gor/wiki/FAQ) and [Troubleshooting](https://github.com/buger/gor/wiki/Troubleshooting) wiki pages. Searching the (issues)[http://github.com/buger/gor] for your problem is also a good idea.
 
-Then in your application you should send copy (e.g. like reverse proxy) all incoming requests to Gor http input. 
+All bug-reports and suggestions should go though Github Issues or our [Google Group](https://groups.google.com/forum/#!forum/gor-users) (you can just send email to gor-users@googlegroups.com).
+If you have a private question feel free to send email to support@gortool.com.
 
-## Configuration
+Useful resources:
 
-### Forward to multiple addresses
+* Product documentation is in the [wiki](http://github.com/buger/gor/wiki).
+* Release announcements are made to the [@buger](http://twitter.com/buger) Twitter account and our [newsleter](https://tinyletter.com/gor)
 
-You can forward traffic to multiple endpoints. Just add multiple --output-* arguments.
-```
-gor --input-tcp :28020 --output-http "http://staging.com"  --output-http "http://dev.com"
-```
 
-#### Splitting traffic
-By default it will send same traffic to all outputs, but you have options to equally split it:
-
-```
-gor --input-tcp :28020 --output-http "http://staging.com"  --output-http "http://dev.com" --split-output true
-```
-
-### HTTP output workers
-By default Gor creates dynamic pull of workers: it starts with 10 and create more http output workers when the http output queue length is greater than 10.  The number of workers created (N) is equal to the queue length at the time which it is checked and found to have a length greater than 10. The queue length is checked every time a message is written to the http output queue.  No more workers will be spawned until that request to spawn N workers is satisfied.  If a dynamic worker cannot process a message at that time, it will sleep for 100 milliseconds. If a dynamic worker cannot process a message for 2 seconds it dies.  
-You may specify fixed number of workers using  `--output-http-workers=20` option.
-
-### Follow redirects
-By default Gor will ignore all redirects since they are handled by clients using your app, but in scenarios when your replayed environment introduce new redirects, you can enable them like this: 
-```
-gor --input-tcp replay.local:28020 --output-http http://staging.com --output-http-redirects 2
-```
-The given example will follow up to 2 redirects per request.
-
-### Rate limiting
-Rate limiting can be useful if you want forward only part of production traffic and not overload your staging environment. There is 2 strategies: dropping random requests or dropping fraction of requests based on Header or URL param value. 
-
-#### Dropping random requests
-Every input and output support random rate limiting.
-There are 2 limiting algorithms: absolute or percentage based. 
-
-Absolute: If for current second it reached specified requests limit - disregard the rest, on next second counter reseted.
-
-Percentage: For input-file it will slowdown or speedup request execution, for the rest it will use random generator to decide if request pass or not based on chance you specified. 
-
-You can specify your desired limit using the
-"|" operator after the server address:
-
-#### Limiting replay using absolute number
-```
-# staging.server will not get more than 10 requests per second
-gor --input-tcp :28020 --output-http "http://staging.com|10"
-```
-
-#### Limiting listener using percentage based limiter
-```
-# replay server will not get more than 10% of requests 
-# useful for high-load environments
-gor --input-raw :80 --output-tcp "replay.local:28020|10%"
-```
-
-#### Limiting based on Header or URL param value
-If you have unique user id (like API key) stored in header or URL you can consistently forward specified percent of traffic only for fraction of this users. 
-Basic formula looks like this: `FNV32-1A_hashing(value) % 100 >= chance`. Examples:
-```
-# Limit based on header value
-gor --input-raw :80 --output-tcp "replay.local:28020|10%" --http-header-limiter "X-API-KEY: 10%"
-
-# Limit based on header value
-gor --input-raw :80 --output-tcp "replay.local:28020|10%" --http-param-limiter "api_key: 10%"
-```
-Only percentage based limiting supported.
-
-### Filtering 
-
-#### Allow url regexp
-```
-# only forward requests being sent to the /api endpoint
-gor --input-raw :8080 --output-http staging.com --http-allow-url /api
-```
-
-#### Disallow url regexp
-```
-# only forward requests NOT being sent to the /api... endpoint
-gor --input-raw :8080 --output-http staging.com --http-disallow-url /api
-```
-#### Filter based on regexp of header
-
-```
-# only forward requests with an api version of 1.0x
-gor --input-raw :8080 --output-http staging.com --http-allow-header api-version:^1\.0\d
-```
-
-#### Filter based on http method
-Requests not matching a specified whitelist can be filtered out. For example to strip non-nullipotent requests:
-
-```
-gor --input-raw :80 --output-http "http://staging.server" \
-    --http-allow-method GET \
-    --http-allow-method OPTIONS
-```
-
-### Rewriting original request
-Gor supports built-in basic rewriting support, for complex logic see https://github.com/buger/gor/pull/162
-
-#### Rewrite URL based on a mapping
-```
-# rewrite url to match the following
-gor --input-raw :8080 --output-http staging.com --http-rewrite-url /v1/user/([^\\/]+)/ping:/v2/user/$1/ping
-```
-
-#### Set URL param
-Set request url param, if param already exists it will be overwritten
-```
-gor --input-raw :8080 --output-http staging.com --http-set-param api_key=1
-```
-
-#### Set Header
-Set request header, if header already exists it will be overwritten. This may be useful if you need to identify requests generated by Gor or enable feature flagged functionality in an application:
-
-```
-gor --input-raw :80 --output-http "http://staging.server" \
-    --http-header "User-Agent: Replayed by Gor" \
-    --http-header "Enable-Feature-X: true"
-```
-
-### Saving requests to file and replaying them
-You can save requests to file, and replay them later:
-```
-# write to file
-gor --input-raw :80 --output-file requests.gor
-
-# read from file
-gor --input-file requests.gor --output-http "http://staging.com"
-```
-
-**Note:** Replay will preserve the original time differences between requests.
-
-### Load testing
-
-Currently it supported only by `input-file` and only when using percentage based limiter. Unlike default limiter for `input-file` instead of dropping requests it will slowdown or speedup request emitting. Note that unlike examples above limiter is applied to input:
-
-```
-# Replay from file on 2x speed 
-gor --input-file "requests.gor|200%" --output-http "staging.com"
-```
-
-### Basic Auth
-
-If your development or staging environment is protected by Basic Authentication then those credentials can be injected in during the replay:
-
-```
-gor --input-raw :80 --output-http "http://user:pass@staging .com"
-```
-
-Note: This will overwrite any Authorization headers in the original request.
-
-
-## Stats 
-
-Gor can report stats on the `output-tcp` and `output-http` request queues. Stats are reported to the console every 5 seconds in the form `latest,mean,max,count,count/second` by using the `--output-http-stats` and `--output-tcp-stats` options.
-
-Examples:
-
-```
-2014/04/23 21:17:50 output_tcp:latest,mean,max,count,count/second
-2014/04/23 21:17:50 output_tcp:0,0,0,0,0
-2014/04/23 21:17:55 output_tcp:1,1,2,68,13
-2014/04/23 21:18:00 output_tcp:1,1,2,92,18
-2014/04/23 21:18:05 output_tcp:1,1,2,119,23
-```
-
-```
-Version: 0.8
-2014/04/23 21:19:46 output_http:latest,mean,max,count,count/second
-2014/04/23 21:19:46 output_http:0,0,0,0,0
-2014/04/23 21:19:51 output_http:0,0,0,0,0
-2014/04/23 21:19:56 output_http:0,0,0,0,0
-2014/04/23 21:20:01 output_http:1,0,1,50,10
-2014/04/23 21:20:06 output_http:1,1,4,72,14
-2014/04/23 21:20:11 output_http:1,0,1,179,35
-2014/04/23 21:20:16 output_http:1,0,1,148,29
-2014/04/23 21:20:21 output_http:1,1,2,91,18
-2014/04/23 21:20:26 output_http:1,1,2,150,30
-2014/04/23 21:18:15 output_http:100,99,100,70,14
-2014/04/23 21:18:21 output_http:100,99,100,55,11
-```
-
-### How can I tell if I have bottlenecks?
-Key areas that sometimes experience bottlenecks are the output-tcp and output-http functions which have internal queues for requests. Each queue has an upper limit of 100. Enable stats reporting to see if any queues are experiencing bottleneck behavior.
- 
-#### output-http bottlenecks
-When running a Gor replay the output-http feature may bottleneck if:
-
-  * the replay has inadequate bandwidth. If the replay is receiving or sending more messages than its network adapter can handle the output-http-stats  may report that the output-http queue is filling up. See if there is a way to upgrade the replay's bandwidth.
-  * with `--output-http-workers` set to anything other than `-1` the `-output-http` target is unable to respond to messages in a timely manner. The http output workers which take messages off the output-http queue, process the request, and ensure that the request did not result in an error may not be able to keep up with the number of incoming requests. If the replay is not using dynamic worker scaling (`--output-http-workers=-1`)  The optimal number of output-http-workers can be determined with the formula `output-workers = (Average number of requests per second)/(Average target response time per second)`.
-
-#### output-tcp bottlenecks
-When using the Gor listener the output-tcp feature may bottleneck if:
-
-  * the replay is unable to accept and process more requests than the listener is able generate. Prior to troubleshooting the output-tcp bottleneck, ensure that the replay target is not experiencing any bottlenecks. 
-  * the replay target has inadequate bandwidth to handle all its incoming requests.  If a replay target's incoming bandwidth is maxed out the output-tcp-stats may report that the output-tcp queue is filling up. See if there is a way to upgrade the replay's bandwidth.
-
-### ElasticSearch 
-For deep response analyze based on url, cookie, user-agent and etc. you can export response metadata to ElasticSearch. See [ELASTICSEARCH.md](ELASTICSEARCH.md) for more details.
-
-```
-gor --input-tcp :80 --output-http "http://staging.com" --output-http-elasticsearch "es_host:api_port/index_name"
-```
-
-## Additional help
-
-Feel free to ask question directly by email or by creating github issue.
-
-## Latest releases (including binaries)
-
-https://github.com/buger/gor/releases
-
-## Command line reference
-`gor -h` output:
-```
-  -http-allow-header=[]: A regexp to match a specific header against. Requests with non-matching headers will be dropped:
-   gor --input-raw :8080 --output-http staging.com --http-allow-header api-version:^v1
-  -http-allow-method=[]: Whitelist of HTTP methods to replay. Anything else will be dropped:
-  gor --input-raw :8080 --output-http staging.com --http-allow-method GET --http-allow-method OPTIONS
-  -http-allow-url=[]: A regexp to match requests against. Filter get matched agains full url with domain. Anything else will be dropped:
-   gor --input-raw :8080 --output-http staging.com --http-allow-url ^www.
-  -http-diallow-url=[]: A regexp to match requests against. Filter get matched agains full url with domain. Anything else will be dropped:
-   gor --input-raw :8080 --output-http staging.com --http-disallow-url ^www.
-  -http-header-limiter=[]: Takes a fraction of requests, consistently taking or rejecting a request based on the FNV32-1A hash of a specific header:
-   gor --input-raw :8080 --output-http staging.com --http-header-imiter user-id:25%
-  -http-param-limiter=[]: Takes a fraction of requests, consistently taking or rejecting a request based on the FNV32-1A hash of a specific GET param:
-   gor --input-raw :8080 --output-http staging.com --http-param-limiter user_id:25%
-  -http-rewrite-url=[]: Rewrite the request url based on a mapping:
-  gor --input-raw :8080 --output-http staging.com --http-rewrite-url /v1/user/([^\/]+)/ping:/v2/user/$1/ping
-  -http-set-header=[]: Inject additional headers to http reqest:
-  gor --input-raw :8080 --output-http staging.com --http-set-header 'User-Agent: Gor'
-  -http-set-param=[]: Set request url param, if param already exists it will be overwritten:
-  gor --input-raw :8080 --output-http staging.com --http-set-param api_key=1
-  -input-dummy=[]: Used for testing outputs. Emits 'Get /' request every 1s
-  -input-file=[]: Read requests from file:
-  gor --input-file ./requests.gor --output-http staging.com
-  -input-http=[]: Read requests from HTTP, should be explicitly sent from your application:
-  # Listen for http on 9000
-  gor --input-http :9000 --output-http staging.com
-  -input-raw=[]: Capture traffic from given port (use RAW sockets and require *sudo* access):
-  # Capture traffic from 8080 port
-  gor --input-raw :8080 --output-http staging.com
-  -input-tcp=[]: Used for internal communication between Gor instances. Example:
-  # Receive requests from other Gor instances on 28020 port, and redirect output to staging
-  gor --input-tcp :28020 --output-http staging.com
-  -memprofile="": write memory profile to this file
-  -output-dummy=[]: Used for testing inputs. Just prints data coming from inputs.
-  -output-file=[]: Write incoming requests to file:
-  gor --input-raw :80 --output-file ./requests.gor
-  -output-http=[]: Forwards incoming requests to given http address.
-  # Redirect all incoming requests to staging.com address
-  gor --input-raw :80 --output-http http://staging.com
-  -output-http-elasticsearch="": Send request and response stats to ElasticSearch:
-  gor --input-raw :8080 --output-http staging.com --output-http-elasticsearch 'es_host:api_port/index_name'
-  -output-http-header-filter=[]: WARNING: `--output-http-header-filter` DEPRECATED, use `--http-allow-header` instead  -output-http-redirects=0: Enable how often redirects should be followed.
-  -output-http-stats=false: Report http output queue stats to console every 5 seconds.
-  -output-http-workers=0: Gor uses dynamic worker scaling by default.  Enter a number to run a set number of workers.
-  -output-tcp=[]: Used for internal communication between Gor instances. Example:
-  # Listen for requests on 80 port and forward them to other Gor instance on 28020 port
-  gor --input-raw :80 --output-tcp replay.local:28020
-  -output-tcp-stats=false: Report TCP output queue stats to console every 5 seconds.
-  -split-output=false: By default each output gets same traffic. If set to `true` it splits traffic equally among all outputs.
-  -stats=false: Turn on queue stats output
-  -verbose=false: Turn on verbose/debug output
-```
-
-## Building from source
-
-1. Setup standard Go environment http://golang.org/doc/code.html and ensure that $GOPATH environment variable properly set.
-2. `go get github.com/buger/gor`.
-3. `cd $GOPATH/src/github.com/buger/gor`
-4. `go build` to get binary, or `go test` to run tests
-
-## Development
-Project contains Docker environment.
-
-1. Build container: `make dbuild`
-2. Run all tests: `make dtest`. Run specific test: `make dtest ARGS=-test.run=**regexp**`
-3. Bash access to container: `make dbash`. Inside container you have python to run simple web server `python -m SimpleHTTPServer 8080` and `curl` to make http requests. 
-
-
-## Questions and support 
-
-All bug-reports and suggestions should go though Github Issues or our [Google Group](https://groups.google.com/forum/#!forum/gor-users). Or you can just send email to gor-users@googlegroups.com
-
-If you have some private questions you can send direct mail to leonsbox@gmail.com
-
-## FAQ
-
-### What OS are supported?
-For now only Linux based. *BSD (including MacOS is not supported yet, check https://github.com/buger/gor/issues/22 for details)
-
-### Why does the `--input-raw` requires sudo or root access?
-Listener works by sniffing traffic from a given port. It's accessible
-only by using sudo or root access.
-
-### How do you deal with user session to replay the traffic correctly?
-You can rewrite session related headers/params to match your staging environment. If you require custom logic (e.g random token based auth) follow this discussion: https://github.com/buger/gor/issues/154
-
-### Can i use Gor to intercept SSL traffic?
-Basic idea is that SSL was made to protect itself from traffic interception. There 2 options: 
-1. Move SSL handling to proxy like Nginx or Amazon ELB. And allow Gor to listen on upstreams. 
-2. Use `--input-http` so you can duplicate request payload directly from your app to Gor, but it will require your app modifications.
-
-More can be find here: https://github.com/buger/gor/issues/85
-
-### I'm getting 'too many open files' error
-Typical linux shell has a small open files soft limit at 1024. You can easily raise that when you do this before starting your gor replay process:
-  
-  ulimit -n 64000
-
-More about ulimit: http://blog.thecodingmachine.com/content/solving-too-many-open-files-exception-red5-or-any-other-application
-
-### The CPU average across my load-balanced targets is higher than the source
-If you are replaying traffic from multiple listeners to a load-balanced target and you use sticky sessions, you may observe that the target servers have a higher CPU load than the listener servers. This may be because the sticky session cookie of the original load balancer is not honored by the target load balancer thus resulting in requests that would normally hit the same target server hitting different servers on the backend thus reducing some caching benefits gained via the load balancing.  Try running just one listener against one replay target and see if the CPU utilization comparison is more accurate.
-
-## Tuning
-
-To achieve the top most performance you should tune the source server system limits:
-
-    net.ipv4.tcp_max_tw_buckets = 65536
-    net.ipv4.tcp_tw_recycle = 1
-    net.ipv4.tcp_tw_reuse = 0
-    net.ipv4.tcp_max_syn_backlog = 131072
-    net.ipv4.tcp_syn_retries = 3
-    net.ipv4.tcp_synack_retries = 3
-    net.ipv4.tcp_retries1 = 3
-    net.ipv4.tcp_retries2 = 8
-    net.ipv4.tcp_rmem = 16384 174760 349520
-    net.ipv4.tcp_wmem = 16384 131072 262144
-    net.ipv4.tcp_mem = 262144 524288 1048576
-    net.ipv4.tcp_max_orphans = 65536
-    net.ipv4.tcp_fin_timeout = 10
-    net.ipv4.tcp_low_latency = 1
-    net.ipv4.tcp_syncookies = 0
+If you need commercial support read more about Pro and Enterprise versions at our site [https://gortool.com/](https://gortool.com/)
 
 
 ## Contributing
@@ -390,11 +53,19 @@ To achieve the top most performance you should tune the source server system lim
 
 ## Companies using Gor
 
-* [Granify](http://granify.com)
-* [GOV.UK](https://www.gov.uk) ([Government Digital Service](http://digital.cabinetoffice.gov.uk/))
-* [theguardian.com](http://theguardian.com)
-* [TomTom](http://www.tomtom.com/)
-* [3SCALE](http://www.3scale.net/)
-* [Optionlab](http://www.opinionlab.com)
-* [TubeMogul] (http://tubemogul.com)
-* To add your company drop me a line to github.com/buger or leonsbox@gmail.com
+* [GOV.UK](https://www.gov.uk) - UK Government Digital Service
+* [theguardian.com](http://theguardian.com) - Most popular online newspaper in the UK
+* [TomTom](http://www.tomtom.com/) - Global leader in navigation, traffic and map products, GPS Sport Watches and fleet management solutions.
+* [3SCALE](http://www.3scale.net/) - API infrastructure to manage your APIs for internal or external users
+* [Optionlab](http://www.opinionlab.com) - Optimize customer experience and drive engagement across multiple channels
+* [TubeMogul](http://tubemogul.com) - Software for Brand Advertising
+* [Videology](http://www.videologygroup.com/) - Video advertising platform
+* [ForeksMobile](http://foreksmobile.com/) -  One of the leading financial application development company in Turkey
+* [Granify](http://granify.com) - AI backed SaaS solution that enables online retailers to maximise their sales
+* And many more!
+
+If you are using Gor we are happy add you to the list and share your story, just write to: hello@gortool.com
+
+## Author
+
+Leonid Bugaev, [@buger](https://twitter.com/buger), https://leonsbox.com

byteutils/byteutils.go

@@ -1,37 +1,40 @@
+// Package byteutils probvides helpers for working with byte slices
 package byteutils
 
+// Cut elements from slice for a given range
 func Cut(a []byte, from, to int) []byte {
-    copy(a[from:], a[to:])
-    a = a[:len(a)-to+from]
+	copy(a[from:], a[to:])
+	a = a[:len(a)-to+from]
 
-    return a
+	return a
 }
 
+// Insert new slice at specified position
 func Insert(a []byte, i int, b []byte) []byte {
-    a = append(a, make([]byte, len(b))...)
-    copy(a[i+len(b):], a[i:])
-    copy(a[i:i+len(b)], b)
+	a = append(a, make([]byte, len(b))...)
+	copy(a[i+len(b):], a[i:])
+	copy(a[i:i+len(b)], b)
 
-    return a
+	return a
 }
 
-// Unlike bytes.Replace it allows you to specify range
+// Replace function unlike bytes.Replace allows you to specify range
 func Replace(a []byte, from, to int, new []byte) []byte {
-    lenDiff := len(new) - (to - from)
+	lenDiff := len(new) - (to - from)
 
-    if lenDiff > 0 {
-        // Extend if new segment bigger
-        a = append(a, make([]byte, lenDiff)...)
-        copy(a[to+lenDiff:], a[to:])
-        copy(a[from:from+len(new)], new)
+	if lenDiff > 0 {
+		// Extend if new segment bigger
+		a = append(a, make([]byte, lenDiff)...)
+		copy(a[to+lenDiff:], a[to:])
+		copy(a[from:from+len(new)], new)
 
-        return a
-    } else if lenDiff < 0 {
-        copy(a[from:], new)
-        copy(a[from+len(new):],a[to:])
-        return a[:len(a) + lenDiff]
-    } else { // same size
-        copy(a[from:], new)
-        return a
-    }
-}
+		return a
+	} else if lenDiff < 0 {
+		copy(a[from:], new)
+		copy(a[from+len(new):], a[to:])
+		return a[:len(a)+lenDiff]
+	} else { // same size
+		copy(a[from:], new)
+		return a
+	}
+}

byteutils/byteutils_test.go

@@ -1,32 +1,32 @@
 package byteutils
 
 import (
-    "testing"
-    "bytes"
+	"bytes"
+	"testing"
 )
 
 func TestCut(t *testing.T) {
-    if !bytes.Equal(Cut([]byte("123456"), 2, 4), []byte("1256")) {
-        t.Error("Should properly cut")
-    }
+	if !bytes.Equal(Cut([]byte("123456"), 2, 4), []byte("1256")) {
+		t.Error("Should properly cut")
+	}
 }
 
 func TestInsert(t *testing.T) {
-    if !bytes.Equal(Insert([]byte("123456"), 2, []byte("abcd")), []byte("12abcd3456")) {
-        t.Error("Should insert into middle of slice")
-    }
+	if !bytes.Equal(Insert([]byte("123456"), 2, []byte("abcd")), []byte("12abcd3456")) {
+		t.Error("Should insert into middle of slice")
+	}
 }
 
 func TestReplace(t *testing.T) {
-    if !bytes.Equal(Replace([]byte("123456"), 2, 4, []byte("ab")), []byte("12ab56")) {
-        t.Error("Should replace when same length")
-    }
+	if !bytes.Equal(Replace([]byte("123456"), 2, 4, []byte("ab")), []byte("12ab56")) {
+		t.Error("Should replace when same length")
+	}
 
-    if !bytes.Equal(Replace([]byte("123456"), 2, 4, []byte("abcd")), []byte("12abcd56")) {
-        t.Error("Should replace when replacement length bigger")
-    }
+	if !bytes.Equal(Replace([]byte("123456"), 2, 4, []byte("abcd")), []byte("12abcd56")) {
+		t.Error("Should replace when replacement length bigger")
+	}
 
-    if !bytes.Equal(Replace([]byte("123456"), 2, 5, []byte("ab")), []byte("12ab6")) {
-        t.Error("Should replace when replacement length bigger")
-    }
-}
+	if !bytes.Equal(Replace([]byte("123456"), 2, 5, []byte("ab")), []byte("12ab6")) {
+		t.Error("Should replace when replacement length bigger")
+	}
+}

circle.yml

@@ -0,0 +1,7 @@
+dependencies:
+  pre:
+    - sudo apt-get install libpcap-dev -y
+
+test:
+  override:
+    - sudo bash -l -c "export GOPATH='/home/ubuntu/.go_workspace:/usr/local/go_workspace:/home/ubuntu/.go_project' && GORACE='halt_on_error=1' /usr/local/go/bin/go test ./... -v -timeout 120s -race"

elasticsearch.go

@@ -122,24 +122,24 @@ func (p *ESPlugin) ResponseAnalyze(req, resp []byte, start, stop time.Time) {
 	esResp := ESRequestResponse{
 		ReqUrl:               proto.Path(req),
 		ReqMethod:            proto.Method(req),
-		ReqUserAgent:         proto.GetHeader(req, "User-Agent"),
-		ReqAcceptLanguage:    proto.GetHeader(req, "Accept-Language"),
-		ReqAccept:            proto.GetHeader(req, "Accept"),
-		ReqAcceptEncoding:    proto.GetHeader(req, "Accept-Encoding"),
-		ReqIfModifiedSince:   proto.GetHeader(req, "If-Modified-Since"),
-		ReqConnection:        proto.GetHeader(req, "Connection"),
-		ReqCookies:           proto.GetHeader(req, "Cookie"),
+		ReqUserAgent:         proto.Header(req, []byte("User-Agent")),
+		ReqAcceptLanguage:    proto.Header(req, []byte("Accept-Language")),
+		ReqAccept:            proto.Header(req, []byte("Accept")),
+		ReqAcceptEncoding:    proto.Header(req, []byte("Accept-Encoding")),
+		ReqIfModifiedSince:   proto.Header(req, []byte("If-Modified-Since")),
+		ReqConnection:        proto.Header(req, []byte("Connection")),
+		ReqCookies:           proto.Header(req, []byte("Cookie")),
 		RespStatus:           proto.Status(resp),
 		RespStatusCode:       proto.Status(resp),
 		RespProto:            proto.Method(resp),
-		RespContentLength:    proto.GetHeader(resp, "Content-Length"),
-		RespContentType:      proto.GetHeader(resp, "Content-Type"),
-		RespTransferEncoding: proto.GetHeader(resp, "Transfer-Encoding"),
-		RespContentEncoding:  proto.GetHeader(resp, "Content-Encoding"),
-		RespExpires:          proto.GetHeader(resp, "Expires"),
-		RespCacheControl:     proto.GetHeader(resp, "Cache-Control"),
-		RespVary:             proto.GetHeader(resp, "Vary"),
-		RespSetCookie:        proto.GetHeader(resp, "Set-Cookie"),
+		RespContentLength:    proto.Header(resp, []byte("Content-Length")),
+		RespContentType:      proto.Header(resp, []byte("Content-Type")),
+		RespTransferEncoding: proto.Header(resp, []byte("Transfer-Encoding")),
+		RespContentEncoding:  proto.Header(resp, []byte("Content-Encoding")),
+		RespExpires:          proto.Header(resp, []byte("Expires")),
+		RespCacheControl:     proto.Header(resp, []byte("Cache-Control")),
+		RespVary:             proto.Header(resp, []byte("Vary")),
+		RespSetCookie:        proto.Header(resp, []byte("Set-Cookie")),
 		Rtt:                  rtt,
 		Timestamp:            t,
 	}

emitter.go

@@ -1,25 +1,51 @@
 package main
 
 import (
+	"bytes"
 	"io"
 	"time"
 )
 
+// Start initialize loop for sending data from inputs to outputs
 func Start(stop chan int) {
-	for _, in := range Plugins.Inputs {
-		go CopyMulty(in, Plugins.Outputs...)
+	if Settings.middleware != "" {
+		middleware := NewMiddleware(Settings.middleware)
+
+		for _, in := range Plugins.Inputs {
+			middleware.ReadFrom(in)
+		}
+
+		// We going only to read responses, so using same ReadFrom method
+		for _, out := range Plugins.Outputs {
+			if r, ok := out.(io.Reader); ok {
+				middleware.ReadFrom(r)
+			}
+		}
+
+		go CopyMulty(middleware, Plugins.Outputs...)
+	} else {
+		for _, in := range Plugins.Inputs {
+			go CopyMulty(in, Plugins.Outputs...)
+		}
 	}
 
 	for {
 		select {
 		case <-stop:
+			pluginMu.Lock()
+			for _, p := range Plugins.All {
+				if cp, ok := p.(io.Closer); ok {
+					cp.Close()
+				}
+			}
+			pluginMu.Unlock()
 			return
-		case <-time.After(1 * time.Second):
+		case <-time.After(100 * time.Millisecond):
 		}
 	}
 }
 
-// Copy from 1 reader to multiple writers
+// CopyMulty copies from 1 reader to multiple writers
 func CopyMulty(src io.Reader, writers ...io.Writer) (err error) {
 	buf := make([]byte, 5*1024*1024)
 	wIndex := 0
@@ -27,20 +53,37 @@ func CopyMulty(src io.Reader, writers ...io.Writer) (err error) {
 
 	for {
 		nr, er := src.Read(buf)
+
 		if nr > 0 && len(buf) > nr {
-			payload := buf[0:nr]
+			payload := buf[:nr]
 
-			if modifier != nil {
-				payload = modifier.Rewrite(payload)
-
-				// If modifier tells to skip request
-				if len(payload) == 0 {
-					continue
-				}
+			_maxN := nr
+			if nr > 500 {
+				_maxN = 500
 			}
 
 			if Settings.debug {
-				Debug("[EMITTER] Sending paylod:", string(payload))
+				Debug("[EMITTER] input:", string(payload[0:_maxN]), nr, "from:", src)
+			}
+
+			if modifier != nil && isRequestPayload(payload) {
+				headSize := bytes.IndexByte(payload, '\n') + 1
+				body := payload[headSize:]
+				originalBodyLen := len(body)
+				body = modifier.Rewrite(body)
+
+				// If modifier tells to skip request
+				if len(body) == 0 {
+					continue
+				}
+
+				if originalBodyLen != len(body) {
+					payload = append(payload[:headSize], body...)
+				}
+
+				if Settings.debug {
+					Debug("[EMITTER] Rewrittern input:", len(payload), "First 500 bytes:", string(payload[0:_maxN]))
+				}
 			}
 
 			if Settings.splitOutput {

examples/middleware/echo.java

@@ -0,0 +1,27 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class echo {
+    public static void main(String[] args) {
+        if(args != null){
+            for(String arg : args){
+                System.out.println(arg);
+            }
+
+        }
+
+        BufferedReader stdin = new BufferedReader(new InputStreamReader(
+                System.in));
+        String line = null;
+
+        try {
+            while ((line = stdin.readLine()) != null) {
+
+                System.out.println(line);
+
+            }
+        } catch (IOException e) {
+        }
+    }
+}

examples/middleware/echo.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+while data = STDIN.gets
+  next unless data
+  data = data.chomp
+
+  decoded = [data].pack("H*")
+  encoded = decoded.unpack("H*").first
+
+  STDOUT.puts encoded
+
+  STDERR.puts "[DEBUG][MIDDLEWARE] Original data: #{data}"
+  STDERR.puts "[DEBUG][MIDDLEWARE] Decoded request: #{decoded}"
+  STDERR.puts "[DEBUG][MIDDLEWARE] Encoded data: #{encoded}"
+end

examples/middleware/echo.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+#
+# `xxd` utility included into vim-common package
+# It allow hex decoding/encoding
+
+function log {
+    # Logging to stderr, because stdout/stdin used for data transfer
+    >&2 echo "[DEBUG][ECHO] $1"
+}
+
+while read line; do
+    decoded=$(echo -e "$line" | xxd -r -p)
+
+    header=$(echo -e "$decoded" | head -n +1)
+    payload=$(echo -e "$decoded" | tail -n +2)
+
+    encoded=$(echo -e "$header\n$payload" | xxd -p | tr -d "\\n")
+
+    log ""
+    log "==================================="
+
+    case ${header:0:1} in
+    "1")
+        log "Request type: Request"
+        ;;
+    "2")
+        log "Request type: Original Response"
+        ;;
+    "3")
+        log "Request type: Replayed Response"
+        ;;
+    *)
+        log "Unknown request type $header"
+    esac
+    echo "$encoded"
+
+    log "==================================="
+
+    log "Original data: $line"
+    log "Decoded request: $decoded"
+    log "Encoded data: $encoded"
+done;

examples/middleware/token_modifier.go

@@ -0,0 +1,119 @@
+/*
+This middleware made for auth system that randomly generate access tokens, which used later for accessing secure content. Since there is no pre-defined token value, naive approach without middleware (or if middleware use only request payloads) will fail, because replayed server have own tokens, not synced with origin. To fix this, our middleware should take in account responses of replayed and origin server, store `originalToken -> replayedToken` aliases and rewrite all requests using this token to use replayed alias. See `middleware_test.go#TestTokenMiddleware` test for examples of using this middleware.
+
+How middleware works:
+
+                   Original request      +--------------+
++-------------+----------STDIN---------->+              |
+|  Gor input  |                          |  Middleware  |
++-------------+----------STDIN---------->+              |
+                   Original response     +------+---+---+
+                                                |   ^
++-------------+    Modified request             v   |
+| Gor output  +<---------STDOUT-----------------+   |
++-----+-------+                                     |
+      |                                             |
+      |            Replayed response                |
+      +------------------STDIN----------------->----+
+*/
+
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"github.com/buger/gor/proto"
+	"os"
+)
+
+// requestID -> originalToken
+var originalTokens map[string][]byte
+
+// originalToken -> replayedToken
+var tokenAliases map[string][]byte
+
+func main() {
+	originalTokens = make(map[string][]byte)
+	tokenAliases = make(map[string][]byte)
+
+	scanner := bufio.NewScanner(os.Stdin)
+
+	for scanner.Scan() {
+		encoded := scanner.Bytes()
+		buf := make([]byte, len(encoded)/2)
+		hex.Decode(buf, encoded)
+
+		process(buf)
+	}
+}
+
+func process(buf []byte) {
+	// First byte indicate payload type, possible values:
+	//  1 - Request
+	//  2 - Response
+	//  3 - ReplayedResponse
+	payloadType := buf[0]
+	headerSize := bytes.IndexByte(buf, '\n') + 1
+	header := buf[:headerSize-1]
+
+	// Header contains space separated values of: request type, request id, and request start time (or round-trip time for responses)
+	meta := bytes.Split(header, []byte(" "))
+	// For each request you should receive 3 payloads (request, response, replayed response) with same request id
+	reqID := string(meta[1])
+	payload := buf[headerSize:]
+
+	Debug("Received payload:", string(buf))
+
+	switch payloadType {
+	case '1': // Request
+		if bytes.Equal(proto.Path(payload), []byte("/token")) {
+			originalTokens[reqID] = []byte{}
+			Debug("Found token request:", reqID)
+		} else {
+			token, vs, _ := proto.PathParam(payload, []byte("token"))
+
+			if vs != -1 { // If there is GET token param
+				if alias, ok := tokenAliases[string(token)]; ok {
+					// Rewrite original token to alias
+					payload = proto.SetPathParam(payload, []byte("token"), alias)
+
+					// Copy modified payload to our buffer
+					buf = append(buf[:headerSize], payload...)
+				}
+			}
+		}
+
+		// Emitting data back
+		os.Stdout.Write(encode(buf))
+	case '2': // Original response
+		if _, ok := originalTokens[reqID]; ok {
+			// Token is inside response body
+			secureToken := proto.Body(payload)
+			originalTokens[reqID] = secureToken
+			Debug("Remember origial token:", string(secureToken))
+		}
+	case '3': // Replayed response
+		if originalToken, ok := originalTokens[reqID]; ok {
+			delete(originalTokens, reqID)
+			secureToken := proto.Body(payload)
+			tokenAliases[string(originalToken)] = secureToken
+
+			Debug("Create alias for new token token, was:", string(originalToken), "now:", string(secureToken))
+		}
+	}
+}
+
+func encode(buf []byte) []byte {
+	dst := make([]byte, len(buf)*2+1)
+	hex.Encode(dst, buf)
+	dst[len(dst)-1] = '\n'
+
+	return dst
+}
+
+func Debug(args ...interface{}) {
+	fmt.Fprint(os.Stderr, "[DEBUG][TOKEN-MOD] ")
+	fmt.Fprintln(os.Stderr, args...)
+}

gor.go

@@ -5,10 +5,14 @@ package main
 import (
 	"flag"
 	"fmt"
+	"io"
 	"log"
 	"os"
-	"runtime/debug"
+	"os/signal"
+	"runtime"
+	_ "runtime/debug"
 	"runtime/pprof"
+	"syscall"
 	"time"
 )
 
@@ -19,14 +23,17 @@ var (
 )
 
 func main() {
-	// Don't exit on panic
-	defer func() {
-		if r := recover(); r != nil {
-			if _, ok := r.(error); !ok {
-				fmt.Printf("PANIC: pkg: %v %s \n", r, debug.Stack())
-			}
-		}
-	}()
+	// // Don't exit on panic
+	// defer func() {
+	// 	if r := recover(); r != nil {
+	// 		fmt.Printf("PANIC: pkg: %v %s \n", r, debug.Stack())
+	// 	}
+	// }()
+
+	// If not set via env cariable
+	if len(os.Getenv("GOMAXPROCS")) == 0 {
+		runtime.GOMAXPROCS(runtime.NumCPU() * 2)
+	}
 
 	fmt.Println("Version:", VERSION)
 
@@ -46,6 +53,20 @@ func main() {
 	}
 
 	Start(nil)
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+
+		for _, p := range Plugins.All {
+			if cp, ok := p.(io.Closer); ok {
+				cp.Close()
+			}
+		}
+
+		os.Exit(1)
+	}()
 }
 
 func profileCPU(cpuprofile string) {
@@ -56,10 +77,10 @@ func profileCPU(cpuprofile string) {
 		}
 		pprof.StartCPUProfile(f)
 
-		time.AfterFunc(60*time.Second, func() {
+		time.AfterFunc(30*time.Second, func() {
 			pprof.StopCPUProfile()
 			f.Close()
-			log.Println("Stop profiling after 60 seconds")
+			log.Println("Stop profiling after 30 seconds")
 		})
 	}
 }
@@ -70,7 +91,7 @@ func profileMEM(memprofile string) {
 		if err != nil {
 			log.Fatal(err)
 		}
-		time.AfterFunc(60*time.Second, func() {
+		time.AfterFunc(30*time.Second, func() {
 			pprof.WriteHeapProfile(f)
 			f.Close()
 		})

gor_stat.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"log"
+	"runtime"
 	"strconv"
 	"time"
 )
@@ -27,7 +28,7 @@ func NewGorStat(statName string) (s *GorStat) {
 	s.count = 0
 
 	if Settings.stats {
-		log.Println(s.statName + ":latest,mean,max,count,count/second")
+		log.Println(s.statName + ":latest,mean,max,count,count/second,gcount")
 		go s.reportStats()
 	}
 	return
@@ -54,7 +55,7 @@ func (s *GorStat) Reset() {
 }
 
 func (s *GorStat) String() string {
-	return s.statName + ":" + strconv.Itoa(s.latest) + "," + strconv.Itoa(s.mean) + "," + strconv.Itoa(s.max) + "," + strconv.Itoa(s.count) + "," + strconv.Itoa(s.count/rate)
+	return s.statName + ":" + strconv.Itoa(s.latest) + "," + strconv.Itoa(s.mean) + "," + strconv.Itoa(s.max) + "," + strconv.Itoa(s.count) + "," + strconv.Itoa(s.count/rate) + "," + strconv.Itoa(runtime.NumGoroutine())
 }
 
 func (s *GorStat) reportStats() {

http_client.go

@@ -1,25 +1,43 @@
 package main
 
 import (
+	"bytes"
 	"crypto/tls"
-	"github.com/buger/gor/proto"
 	"io"
+	"log"
 	"net"
 	"net/url"
-	"strings"
-	"time"
 	"runtime/debug"
-	"log"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/buger/gor/proto"
 )
 
+var httpMu sync.Mutex
+
+const (
+	readChunkSize   = 64 * 1024
+	maxResponseSize = 1073741824
+)
+
+var chunkedSuffix = []byte("0\r\n\r\n")
+
 var defaultPorts = map[string]string{
 	"http":  "80",
 	"https": "443",
 }
 
 type HTTPClientConfig struct {
-	FollowRedirects int
-	Debug           bool
+	FollowRedirects    int
+	Debug              bool
+	OriginalHost       bool
+	ConnectionTimeout  time.Duration
+	Timeout            time.Duration
+	ResponseBufferSize int
 }
 
 type HTTPClient struct {
@@ -39,14 +57,26 @@ func NewHTTPClient(baseURL string, config *HTTPClientConfig) *HTTPClient {
 
 	u, _ := url.Parse(baseURL)
 	if !strings.Contains(u.Host, ":") {
-		u.Host += ":" + defaultPorts[u.Scheme]
+		if u.Scheme != "http" {
+			u.Host += ":" + defaultPorts[u.Scheme]
+		}
+	}
+
+	if config.Timeout.Nanoseconds() == 0 {
+		config.Timeout = 5 * time.Second
+	}
+
+	config.ConnectionTimeout = time.Second
+
+	if config.ResponseBufferSize == 0 {
+		config.ResponseBufferSize = 100 * 1024 // 100kb
 	}
 
 	client := new(HTTPClient)
 	client.baseURL = u.String()
 	client.host = u.Host
 	client.scheme = u.Scheme
-	client.respBuf = make([]byte, 4096*10)
+	client.respBuf = make([]byte, config.ResponseBufferSize)
 	client.config = config
 
 	return client
@@ -55,7 +85,11 @@ func NewHTTPClient(baseURL string, config *HTTPClientConfig) *HTTPClient {
 func (c *HTTPClient) Connect() (err error) {
 	c.Disconnect()
 
-	c.conn, err = net.Dial("tcp", c.host)
+	if !strings.Contains(c.host, ":") {
+		c.conn, err = net.DialTimeout("tcp", c.host+":80", c.config.ConnectionTimeout)
+	} else {
+		c.conn, err = net.DialTimeout("tcp", c.host, c.config.ConnectionTimeout)
+	}
 
 	if c.scheme == "https" {
 		tlsConn := tls.Client(c.conn, &tls.Config{InsecureSkipVerify: true})
@@ -74,7 +108,7 @@ func (c *HTTPClient) Disconnect() {
 	if c.conn != nil {
 		c.conn.Close()
 		c.conn = nil
-		Debug("Disconnected: ", c.baseURL)
+		Debug("[HTTP] Disconnected: ", c.baseURL)
 	}
 }
 
@@ -83,7 +117,17 @@ func (c *HTTPClient) isAlive() bool {
 
 	// Ready 1 byte from socket without timeout to check if it not closed
 	c.conn.SetReadDeadline(time.Now().Add(time.Millisecond))
-	if _, err := c.conn.Read(one); err == io.EOF {
+	_, err := c.conn.Read(one)
+
+	if err == nil {
+		return true
+	} else if err == io.EOF {
+		if c.config.Debug {
+			Debug("[HTTPClient] connection closed, reconnecting")
+		}
+		return false
+	} else if err == syscall.EPIPE {
+		Debug("Detected broken pipe.", err)
 		return false
 	}
 
@@ -103,20 +147,22 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 		}
 	}()
 
-
 	if c.conn == nil || !c.isAlive() {
 		Debug("[HTTPClient] Connecting:", c.baseURL)
 		if err = c.Connect(); err != nil {
 			log.Println("[HTTPClient] Connection error:", err)
+			response = errorPayload(HTTP_CONNECTION_ERROR)
 			return
 		}
 	}
 
-	timeout := time.Now().Add(5 * time.Second)
+	timeout := time.Now().Add(c.config.Timeout)
 
 	c.conn.SetWriteDeadline(timeout)
 
-	data = proto.SetHost(data, []byte(c.baseURL), []byte(c.host))
+	if !c.config.OriginalHost {
+		data = proto.SetHost(data, []byte(c.baseURL), []byte(c.host))
+	}
 
 	if c.config.Debug {
 		Debug("[HTTPClient] Sending:", string(data))
@@ -124,18 +170,125 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 
 	if _, err = c.conn.Write(data); err != nil {
 		Debug("[HTTPClient] Write error:", err, c.baseURL)
+		response = errorPayload(HTTP_TIMEOUT)
 		return
 	}
 
-	c.conn.SetReadDeadline(timeout)
-	n, err := c.conn.Read(c.respBuf)
+	var readBytes, n int
+	var currentChunk []byte
+	timeout = time.Now().Add(c.config.Timeout)
+	chunked := false
+	contentLength := -1
+	currentContentLength := 0
+	chunks := 0
+
+	for {
+		c.conn.SetReadDeadline(timeout)
+
+		if readBytes < len(c.respBuf) {
+			n, err = c.conn.Read(c.respBuf[readBytes:])
+			readBytes += n
+			chunks++
+
+			if err != nil {
+				if err == io.EOF {
+					err = nil
+				}
+				break
+			}
+
+			// First chunk
+			if chunked || contentLength != -1 {
+				currentContentLength += n
+			} else {
+				// If headers are finished
+				if bytes.Contains(c.respBuf[:readBytes], proto.EmptyLine) {
+					if bytes.Equal(proto.Header(c.respBuf, []byte("Transfer-Encoding")), []byte("chunked")) {
+						chunked = true
+					} else {
+						l := proto.Header(c.respBuf, []byte("Content-Length"))
+						if len(l) > 0 {
+							contentLength, _ = strconv.Atoi(string(l))
+						}
+					}
+
+					currentContentLength += len(proto.Body(c.respBuf[:readBytes]))
+				}
+			}
+
+			if chunked {
+				// Check if chunked message finished
+				if bytes.HasSuffix(c.respBuf[:readBytes], chunkedSuffix) {
+					break
+				}
+			} else if contentLength != -1 {
+				if currentContentLength > contentLength {
+					Debug("[HTTPClient] disconnected, wrong length", currentContentLength, contentLength)
+					c.Disconnect()
+					break
+				} else if currentContentLength == contentLength {
+					break
+				}
+			}
+		} else {
+			if currentChunk == nil {
+				currentChunk = make([]byte, readChunkSize)
+			}
+
+			n, err = c.conn.Read(currentChunk)
+
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				Debug("[HTTPClient] Read the whole body error:", err, c.baseURL)
+				break
+			}
+
+			readBytes += int(n)
+			chunks++
+			currentContentLength += n
+
+			if chunked {
+				// Check if chunked message finished
+				if bytes.HasSuffix(currentChunk[:n], chunkedSuffix) {
+					break
+				}
+			} else if contentLength != -1 {
+				if currentContentLength > contentLength {
+					Debug("[HTTPClient] disconnected, wrong length", currentContentLength, contentLength)
+					c.Disconnect()
+					break
+				} else if currentContentLength == contentLength {
+					break
+				}
+			} else {
+				Debug("[HTTPClient] disconnected, can't find Content-Length or Chunked")
+				c.Disconnect()
+				break
+			}
+		}
+
+		if readBytes >= maxResponseSize {
+			Debug("[HTTPClient] Body is more than the max size", maxResponseSize,
+				c.baseURL)
+			break
+		}
+
+		// For following chunks expect less timeout
+		timeout = time.Now().Add(c.config.Timeout / 5)
+	}
 
 	if err != nil {
-		Debug("[HTTPClient] Response read error", err, c.conn)
+		Debug("[HTTPClient] Response read error", err, c.conn, readBytes)
+		response = errorPayload(HTTP_TIMEOUT)
 		return
 	}
 
-	payload := c.respBuf[:n]
+	if readBytes > len(c.respBuf) {
+		readBytes = len(c.respBuf)
+	}
+	payload := make([]byte, readBytes)
+	copy(payload, c.respBuf[:readBytes])
 
 	if c.config.Debug {
 		Debug("[HTTPClient] Received:", string(payload))
@@ -146,9 +299,9 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 
 		// 3xx requests
 		if status[0] == '3' {
-			c.redirectsCount += 1
+			c.redirectsCount++
 
-			location, _, _, _ := proto.Header(payload, []byte("Location"))
+			location := proto.Header(payload, []byte("Location"))
 			redirectPayload := []byte("GET " + string(location) + " HTTP/1.1\r\n\r\n")
 
 			if c.config.Debug {
@@ -163,3 +316,42 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 
 	return payload, err
 }
+
+func (c *HTTPClient) Get(path string) (response []byte, err error) {
+	payload := "GET " + path + " HTTP/1.1\r\n\r\n"
+
+	return c.Send([]byte(payload))
+}
+
+func (c *HTTPClient) Post(path string, body []byte) (response []byte, err error) {
+	payload := "POST " + path + " HTTP/1.1\r\n"
+	payload += "Content-Length: " + strconv.Itoa(len(body)) + "\r\n\r\n"
+	payload += string(body)
+
+	return c.Send([]byte(payload))
+}
+
+const (
+	// https://support.cloudflare.com/hc/en-us/articles/200171936-Error-520-Web-server-is-returning-an-unknown-error
+	HTTP_UNKNOWN_ERROR = "520"
+	// https://support.cloudflare.com/hc/en-us/articles/200171916-Error-521-Web-server-is-down
+	HTTP_CONNECTION_ERROR = "521"
+	// https://support.cloudflare.com/hc/en-us/articles/200171906-Error-522-Connection-timed-out
+	HTTP_CONNECTION_TIMEOUT = "522"
+	// https://support.cloudflare.com/hc/en-us/articles/200171946-Error-523-Origin-is-unreachable
+	HTTP_UNREACHABLE = "523"
+	// https://support.cloudflare.com/hc/en-us/articles/200171926-Error-524-A-timeout-occurred
+	HTTP_TIMEOUT = "524"
+)
+
+var errorPayloadTemplate = "HTTP/1.1 202 Accepted\r\nDate: Mon, 17 Aug 2015 14:10:11 GMT\r\nContent-Length: 0\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n"
+
+func errorPayload(errorCode string) []byte {
+	payload := make([]byte, len(errorPayloadTemplate))
+	copy(payload, errorPayloadTemplate)
+
+	copy(payload[29:58], []byte(time.Now().Format(time.RFC1123)))
+	copy(payload[9:12], errorCode)
+
+	return payload
+}

http_client_test.go

@@ -1,20 +1,26 @@
 package main
 
 import (
+	"bytes"
+	"crypto/rand"
+	"github.com/buger/gor/proto"
 	"io/ioutil"
+	_ "log"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"net/http/httputil"
+	_ "reflect"
 	"sync"
 	"testing"
-	_ "time"
+	"time"
+	"runtime"
 )
 
 func TestHTTPClientURLPort(t *testing.T) {
 	c1 := NewHTTPClient("http://example.com", &HTTPClientConfig{})
-	if c1.baseURL != "http://example.com:80" {
-		t.Error("Sould add 80 port for http:", c1.baseURL)
+	if c1.baseURL != "http://example.com" {
+		t.Error("Sould not add 80 port for http:", c1.baseURL)
 	}
 
 	c2 := NewHTTPClient("https://example.com", &HTTPClientConfig{})
@@ -28,8 +34,8 @@ func TestHTTPClientURLPort(t *testing.T) {
 	}
 
 	c4 := NewHTTPClient("example.com", &HTTPClientConfig{})
-	if c4.baseURL != "http://example.com:80" {
-		t.Error("Sould add default protocol:", c4.baseURL)
+	if c4.baseURL != "http://example.com" {
+		t.Error("Sould not add default protocol:", c4.baseURL)
 	}
 }
 
@@ -69,6 +75,7 @@ func TestHTTPClientSend(t *testing.T) {
 
 		wg.Done()
 	}))
+	defer server.Close()
 
 	client := NewHTTPClient(server.URL, &HTTPClientConfig{Debug: true})
 
@@ -81,6 +88,71 @@ func TestHTTPClientSend(t *testing.T) {
 	wg.Wait()
 }
 
+// https://github.com/buger/gor/issues/184
+func TestHTTPClientResponseBuffer(t *testing.T) {
+	testCases := []struct {
+		name         string
+		responseSize int
+		buffserSize  int
+		expectedSize int
+		timeout      time.Duration
+	}{
+		{"Chunked, buffer overflow", 10 * 1024, 1024, 1024, 50 * time.Millisecond},
+
+		{"Chunked, fits buffer", 10 * 1024, 64 * 1024, 10*1024 + 145 /* headers length + chunked meta */, 50 * time.Millisecond},
+
+		{"Content-Length, buffer overflow", 1024, 1000, 1000, 50 * time.Millisecond},
+
+		{"Content-Length, fits buffer", 1024, 64 * 1024, 1024 + 118, 50 * time.Millisecond},
+	}
+
+	for _, tc := range testCases {
+		wg := new(sync.WaitGroup)
+
+		payload := []byte("GET / HTTP/1.1\r\n\r\n")
+
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+
+			size := tc.responseSize // 1kb
+			rb := make([]byte, size)
+			rand.Read(rb)
+
+			w.Write(rb[:size/2])
+			w.Write(rb[size/2:])
+
+			wg.Done()
+		}))
+
+		client := NewHTTPClient(server.URL, &HTTPClientConfig{Debug: true, ResponseBufferSize: tc.buffserSize, Timeout: 100 * time.Millisecond})
+
+		wg.Add(2)
+
+		start := time.Now()
+		client.Send(payload)
+		resp, err := client.Send(payload)
+		stop := time.Now()
+
+		if err != nil {
+			t.Error("Request error", err)
+		}
+
+		if stop.Sub(start) > tc.timeout {
+			t.Error("Request took too long", stop.Sub(start), tc.timeout)
+		}
+
+		if len(resp) != tc.expectedSize {
+			t.Error(tc.name, " - Wrong response size:", tc.expectedSize, len(resp))
+		} else {
+			if !bytes.Equal(resp[0:8], []byte("HTTP/1.1")) {
+				t.Error(tc.name, " - Response buffer contains data from previous request", string(resp), len(resp))
+			}
+		}
+
+		wg.Wait()
+		server.Close()
+	}
+}
+
 func TestHTTPClientHTTPSSend(t *testing.T) {
 	wg := new(sync.WaitGroup)
 
@@ -117,6 +189,7 @@ func TestHTTPClientHTTPSSend(t *testing.T) {
 
 		wg.Done()
 	}))
+	defer server.Close()
 
 	client := NewHTTPClient(server.URL, &HTTPClientConfig{})
 
@@ -130,17 +203,25 @@ func TestHTTPClientHTTPSSend(t *testing.T) {
 }
 
 func TestHTTPClientServerInstantDisconnect(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		return
+	}
+
 	wg := new(sync.WaitGroup)
 
-	GET_payload := []byte("GET / HTTP/1.1\r\n\r\n")
+	GETPayload := []byte("GET / HTTP/1.1\r\n\r\n")
 
-	ln, _ := net.Listen("tcp", ":0")
+	ln, _ := net.Listen("tcp", "127.0.0.1:0")
+	defer ln.Close()
 
 	go func() {
 		for {
-			conn, _ := ln.Accept()
-			conn.Close()
+			conn, err := ln.Accept()
 
+			if err != nil {
+				break
+			}
+			conn.Close()
 			wg.Done()
 		}
 	}()
@@ -148,8 +229,8 @@ func TestHTTPClientServerInstantDisconnect(t *testing.T) {
 	client := NewHTTPClient(ln.Addr().String(), &HTTPClientConfig{})
 
 	wg.Add(2)
-	client.Send(GET_payload)
-	client.Send(GET_payload)
+	client.Send(GETPayload)
+	client.Send(GETPayload)
 
 	wg.Wait()
 }
@@ -157,15 +238,16 @@ func TestHTTPClientServerInstantDisconnect(t *testing.T) {
 func TestHTTPClientServerNoKeepAlive(t *testing.T) {
 	wg := new(sync.WaitGroup)
 
-	GET_payload := []byte("GET / HTTP/1.1\r\n\r\n")
+	GETPayload := []byte("GET / HTTP/1.1\r\n\r\n")
 
-	ln, _ := net.Listen("tcp", ":0")
+	ln, _ := net.Listen("tcp", "127.0.0.1:0")
+	defer ln.Close()
 
 	go func() {
 		for {
 			conn, err := ln.Accept()
 			if err != nil {
-				// handle error
+				break
 			}
 
 			buf := make([]byte, 4096)
@@ -186,8 +268,8 @@ func TestHTTPClientServerNoKeepAlive(t *testing.T) {
 	client := NewHTTPClient(ln.Addr().String(), &HTTPClientConfig{})
 
 	wg.Add(2)
-	client.Send(GET_payload)
-	client.Send(GET_payload)
+	client.Send(GETPayload)
+	client.Send(GETPayload)
 
 	wg.Wait()
 }
@@ -195,7 +277,7 @@ func TestHTTPClientServerNoKeepAlive(t *testing.T) {
 func TestHTTPClientRedirect(t *testing.T) {
 	wg := new(sync.WaitGroup)
 
-	GET_payload := []byte("GET / HTTP/1.1\r\n\r\n")
+	GETPayload := []byte("GET / HTTP/1.1\r\n\r\n")
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
@@ -205,12 +287,13 @@ func TestHTTPClientRedirect(t *testing.T) {
 
 		wg.Done()
 	}))
+	defer server.Close()
 
 	client := NewHTTPClient(server.URL, &HTTPClientConfig{FollowRedirects: 1, Debug: false})
 
 	// Should do 2 queries
 	wg.Add(2)
-	client.Send(GET_payload)
+	client.Send(GETPayload)
 
 	wg.Wait()
 }
@@ -218,7 +301,7 @@ func TestHTTPClientRedirect(t *testing.T) {
 func TestHTTPClientRedirectLimit(t *testing.T) {
 	wg := new(sync.WaitGroup)
 
-	GET_payload := []byte("GET / HTTP/1.1\r\n\r\n")
+	GETPayload := []byte("GET / HTTP/1.1\r\n\r\n")
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
@@ -236,12 +319,13 @@ func TestHTTPClientRedirectLimit(t *testing.T) {
 
 		wg.Done()
 	}))
+	defer server.Close()
 
 	client := NewHTTPClient(server.URL, &HTTPClientConfig{FollowRedirects: 2, Debug: false})
 
 	// Have 3 redirects + 1 GET, but should do only 2 redirects + GET
 	wg.Add(3)
-	client.Send(GET_payload)
+	client.Send(GETPayload)
 
 	wg.Wait()
 }
@@ -249,7 +333,7 @@ func TestHTTPClientRedirectLimit(t *testing.T) {
 func TestHTTPClientHandleHTTP10(t *testing.T) {
 	wg := new(sync.WaitGroup)
 
-	GET_payload := []byte("GET http://foobar.com/path HTTP/1.0\r\n\r\n")
+	GETPayload := []byte("GET http://foobar.com/path HTTP/1.0\r\n\r\n")
 
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
@@ -259,11 +343,76 @@ func TestHTTPClientHandleHTTP10(t *testing.T) {
 
 		wg.Done()
 	}))
+	defer server.Close()
 
 	client := NewHTTPClient(server.URL, &HTTPClientConfig{Debug: true})
 
 	wg.Add(1)
-	client.Send(GET_payload)
+	client.Send(GETPayload)
 
 	wg.Wait()
 }
+
+func TestHTTPClientErrors(t *testing.T) {
+	req := []byte("GET http://foobar.com/path HTTP/1.0\r\n\r\n")
+
+	// Port not exists
+	client := NewHTTPClient("http://127.0.0.1:1", &HTTPClientConfig{Debug: true})
+	if resp, err := client.Send(req); err != nil {
+		if s := proto.Status(resp); !bytes.Equal(s, []byte("521")) {
+			t.Error("Should return status 521 for connection refused, instead:", string(s))
+		}
+	} else {
+		t.Error("Should throw error")
+	}
+
+	client = NewHTTPClient("http://not.existing", &HTTPClientConfig{Debug: true})
+	if resp, err := client.Send(req); err != nil {
+		if s := proto.Status(resp); !bytes.Equal(s, []byte("521")) {
+			t.Error("Should return status 521 for no such host, instead:", string(s))
+		}
+	} else {
+		t.Error("Should throw error")
+	}
+
+	// Non routable IP address to simulate connection timeout
+	client = NewHTTPClient("http://10.255.255.1", &HTTPClientConfig{Debug: true, ConnectionTimeout: 100 * time.Millisecond})
+
+	if resp, err := client.Send(req); err != nil {
+		if s := proto.Status(resp); !bytes.Equal(s, []byte("521")) {
+			t.Error("Should return status 521 for io/timeout:", string(s))
+		}
+	} else {
+		t.Error("Should throw error")
+	}
+
+	// Connecting but io timeout on read
+	ln, _ := net.Listen("tcp", "127.0.0.1:0")
+	client = NewHTTPClient("http://"+ln.Addr().String(), &HTTPClientConfig{Debug: true, Timeout: 10 * time.Millisecond})
+	defer ln.Close()
+
+	if resp, err := client.Send(req); err != nil {
+		if s := proto.Status(resp); !bytes.Equal(s, []byte("524")) {
+			t.Error("Should return status 524 for io read, instead:", string(s))
+		}
+	} else {
+		t.Error("Should throw error")
+	}
+
+	// Response read error read tcp [::1]:51128: connection reset by peer &{{0xc20802a000}}
+	ln1, _ := net.Listen("tcp", "127.0.0.1:0")
+	go func() {
+		ln1.Accept()
+	}()
+	defer ln1.Close()
+
+	client = NewHTTPClient("http://"+ln1.Addr().String(), &HTTPClientConfig{Debug: true, Timeout: 10 * time.Millisecond})
+
+	if resp, err := client.Send(req); err != nil {
+		if s := proto.Status(resp); !bytes.Equal(s, []byte("524")) {
+			t.Error("Should return status 524 for connection reset by peer, instead:", string(s))
+		}
+	} else {
+		t.Error("Should throw error")
+	}
+}

http_modifier.go

@@ -2,8 +2,9 @@ package main
 
 import (
 	"bytes"
-	"github.com/buger/gor/proto"
 	"hash/fnv"
+
+	"github.com/buger/gor/proto"
 )
 
 type HTTPModifier struct {
@@ -16,6 +17,7 @@ func NewHTTPModifier(config *HTTPModifierConfig) *HTTPModifier {
 		len(config.urlNegativeRegexp) == 0 &&
 		len(config.urlRewrite) == 0 &&
 		len(config.headerFilters) == 0 &&
+		len(config.headerNegativeFilters) == 0 &&
 		len(config.headerHashFilters) == 0 &&
 		len(config.paramHashFilters) == 0 &&
 		len(config.params) == 0 &&
@@ -28,6 +30,10 @@ func NewHTTPModifier(config *HTTPModifierConfig) *HTTPModifier {
 }
 
 func (m *HTTPModifier) Rewrite(payload []byte) (response []byte) {
+	if !proto.IsHTTPPayload(payload) {
+		return payload
+	}
+
 	if len(m.config.methods) > 0 {
 		method := proto.Method(payload)
 
@@ -86,9 +92,19 @@ func (m *HTTPModifier) Rewrite(payload []byte) (response []byte) {
 
 	if len(m.config.headerFilters) > 0 {
 		for _, f := range m.config.headerFilters {
-			value, s, _, _ := proto.Header(payload, f.name)
+			value := proto.Header(payload, f.name)
 
-			if s != -1 && !f.regexp.Match(value) {
+			if len(value) > 0 && !f.regexp.Match(value) {
+				return
+			}
+		}
+	}
+
+	if len(m.config.headerNegativeFilters) > 0 {
+		for _, f := range m.config.headerNegativeFilters {
+			value := proto.Header(payload, f.name)
+
+			if len(value) > 0 && f.regexp.Match(value) {
 				return
 			}
 		}
@@ -96,9 +112,9 @@ func (m *HTTPModifier) Rewrite(payload []byte) (response []byte) {
 
 	if len(m.config.headerHashFilters) > 0 {
 		for _, f := range m.config.headerHashFilters {
-			value, s, _, _ := proto.Header(payload, f.name)
+			value := proto.Header(payload, f.name)
 
-			if s != -1 {
+			if len(value) > 0 {
 				hasher := fnv.New32a()
 				hasher.Write(value)
 

http_modifier_settings.go

@@ -8,13 +8,15 @@ import (
 	"strings"
 )
 
+// HTTPModifierConfig holds configuration options for built-in traffic modifier
 type HTTPModifierConfig struct {
-	urlNegativeRegexp HTTPUrlRegexp
-	urlRegexp         HTTPUrlRegexp
-	urlRewrite        UrlRewriteMap
-	headerFilters     HTTPHeaderFilters
-	headerHashFilters HTTPHashFilters
-	paramHashFilters  HTTPHashFilters
+	urlNegativeRegexp     HTTPUrlRegexp
+	urlRegexp             HTTPUrlRegexp
+	urlRewrite            UrlRewriteMap
+	headerFilters         HTTPHeaderFilters
+	headerNegativeFilters HTTPHeaderFilters
+	headerHashFilters     HTTPHashFilters
+	paramHashFilters      HTTPHashFilters
 
 	params  HTTPParams
 	headers HTTPHeaders
@@ -22,13 +24,14 @@ type HTTPModifierConfig struct {
 }
 
 //
-// Handling of --http-allow-header options
+// Handling of --http-allow-header, --http-disallow-header options
 //
 type headerFilter struct {
 	name   []byte
 	regexp *regexp.Regexp
 }
 
+// HTTPHeaderFilters holds list of headers and their regexps
 type HTTPHeaderFilters []headerFilter
 
 func (h *HTTPHeaderFilters) String() string {
@@ -67,7 +70,7 @@ func (h *HTTPHashFilters) String() string {
 func (h *HTTPHashFilters) Set(value string) error {
 	valArr := strings.SplitN(value, ":", 2)
 	if len(valArr) < 2 {
-		return errors.New("need both header and value, colon-delimited (ex. user_id:50%).")
+		return errors.New("need both header and value, colon-delimited (ex. user_id:50%)")
 	}
 
 	f := hashFilter{name: []byte(valArr[0])}
@@ -180,7 +183,7 @@ func (r *UrlRewriteMap) String() string {
 func (r *UrlRewriteMap) Set(value string) error {
 	valArr := strings.SplitN(value, ":", 2)
 	if len(valArr) < 2 {
-		return errors.New("need both src and target, colon-delimited (ex. /a:/b).")
+		return errors.New("need both src and target, colon-delimited (ex. /a:/b)")
 	}
 	regexp, err := regexp.Compile(valArr[0])
 	if err != nil {

http_modifier_test.go

@@ -39,8 +39,35 @@ func TestHTTPModifierHeaderFilters(t *testing.T) {
 	}
 }
 
+func TestHTTPModifierHeaderNegativeFilters(t *testing.T) {
+	filters := HTTPHeaderFilters{}
+	filters.Set("Host:^www.w3.org$")
+
+	modifier := NewHTTPModifier(&HTTPModifierConfig{
+		headerNegativeFilters: filters,
+	})
+
+	payload := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w4.org\r\n\r\na=1&b=2")
+
+	if len(modifier.Rewrite(payload)) == 0 {
+		t.Error("Request should pass filters")
+	}
+
+	filters = HTTPHeaderFilters{}
+	// Setting filter that not match our header
+	filters.Set("Host:^www.w4.org$")
+
+	modifier = NewHTTPModifier(&HTTPModifierConfig{
+		headerNegativeFilters: filters,
+	})
+
+	if len(modifier.Rewrite(payload)) != 0 {
+		t.Error("Request should not pass filters")
+	}
+}
+
 func TestHTTPModifierURLRewrite(t *testing.T) {
-	var url, new_url []byte
+	var url, newURL []byte
 
 	rewrites := UrlRewriteMap{}
 
@@ -58,13 +85,13 @@ func TestHTTPModifierURLRewrite(t *testing.T) {
 	})
 
 	url = []byte("/v1/user/joe/ping")
-	if new_url = proto.Path(modifier.Rewrite(payload(url))); bytes.Equal(new_url, url) {
-		t.Error("Request url should have been rewritten, wasn't", string(new_url))
+	if newURL = proto.Path(modifier.Rewrite(payload(url))); bytes.Equal(newURL, url) {
+		t.Error("Request url should have been rewritten, wasn't", string(newURL))
 	}
 
 	url = []byte("/v1/user/ping")
-	if new_url = proto.Path(modifier.Rewrite(payload(url))); !bytes.Equal(new_url, url) {
-		t.Error("Request url should have been rewritten, wasn't", string(new_url))
+	if newURL = proto.Path(modifier.Rewrite(payload(url))); !bytes.Equal(newURL, url) {
+		t.Error("Request url should have been rewritten, wasn't", string(newURL))
 	}
 }
 
@@ -128,9 +155,9 @@ func TestHTTPModifierHeaders(t *testing.T) {
 	})
 
 	payload := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-	new_payload := []byte("POST /post HTTP/1.1\r\nHeader1: 1\r\nContent-Length: 7\r\nHost: localhost\r\n\r\na=1&b=2")
+	newPayload := []byte("POST /post HTTP/1.1\r\nHeader1: 1\r\nContent-Length: 7\r\nHost: localhost\r\n\r\na=1&b=2")
 
-	if payload = modifier.Rewrite(payload); !bytes.Equal(payload, new_payload) {
+	if payload = modifier.Rewrite(payload); !bytes.Equal(payload, newPayload) {
 		t.Error("Should update request headers", string(payload))
 	}
 }
@@ -196,9 +223,9 @@ func TestHTTPModifierSetHeader(t *testing.T) {
 	})
 
 	payload := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-	payload_after := []byte("POST /post HTTP/1.1\r\nUser-Agent: Gor\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter := []byte("POST /post HTTP/1.1\r\nUser-Agent: Gor\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-	if payload = modifier.Rewrite(payload); !bytes.Equal(payload_after, payload) {
+	if payload = modifier.Rewrite(payload); !bytes.Equal(payloadAfter, payload) {
 		t.Error("Should add new header", string(payload))
 	}
 }
@@ -212,9 +239,9 @@ func TestHTTPModifierSetParam(t *testing.T) {
 	})
 
 	payload := []byte("POST /post?api_key=1234 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-	payload_after := []byte("POST /post?api_key=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter := []byte("POST /post?api_key=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-	if payload = modifier.Rewrite(payload); !bytes.Equal(payload_after, payload) {
+	if payload = modifier.Rewrite(payload); !bytes.Equal(payloadAfter, payload) {
 		t.Error("Should override param", string(payload))
 	}
 }

input_dummy.go

@@ -4,10 +4,12 @@ import (
 	"time"
 )
 
+// DummyInput used for debugging. It generate 1 "GET /"" request per second.
 type DummyInput struct {
 	data chan []byte
 }
 
+// NewDummyInput constructor for DummyInput
 func NewDummyInput(options string) (di *DummyInput) {
 	di = new(DummyInput)
 	di.data = make(chan []byte)
@@ -19,6 +21,7 @@ func NewDummyInput(options string) (di *DummyInput) {
 
 func (i *DummyInput) Read(data []byte) (int, error) {
 	buf := <-i.data
+
 	copy(data, buf)
 
 	return len(buf), nil
@@ -30,7 +33,12 @@ func (i *DummyInput) emit() {
 	for {
 		select {
 		case <-ticker.C:
-			i.data <- []byte("GET / HTTP/1.1\r\n\r\n")
+			uuid := uuid()
+			reqh := payloadHeader(RequestPayload, uuid, time.Now().UnixNano())
+			i.data <- append(reqh, []byte("GET / HTTP/1.1\r\nHost: www.w3.org\r\nUser-Agent: Go 1.1 package http\r\nAccept-Encoding: gzip\r\n\r\n")...)
+
+			resh := payloadHeader(ResponsePayload, uuid, 1)
+			i.data <- append(resh, []byte("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")...)
 		}
 	}
 }

input_file.go

@@ -1,39 +1,44 @@
 package main
 
 import (
-	"encoding/gob"
+	"bufio"
+	"bytes"
+	"io"
 	"log"
 	"os"
+	"strconv"
 	"time"
 )
 
+// FileInput can read requests generated by FileOutput
 type FileInput struct {
 	data        chan []byte
 	path        string
-	decoder     *gob.Decoder
+	file        *os.File
 	speedFactor float64
 }
 
+// NewFileInput constructor for FileInput. Accepts file path as argument.
 func NewFileInput(path string) (i *FileInput) {
 	i = new(FileInput)
 	i.data = make(chan []byte)
 	i.path = path
 	i.speedFactor = 1
-	i.Init(path)
+	i.init(path)
 
 	go i.emit()
 
 	return
 }
 
-func (i *FileInput) Init(path string) {
+func (i *FileInput) init(path string) {
 	file, err := os.Open(path)
 
 	if err != nil {
 		log.Fatal(i, "Cannot open file %q. Error: %s", path, err)
 	}
 
-	i.decoder = gob.NewDecoder(file)
+	i.file = file
 }
 
 func (i *FileInput) Read(data []byte) (int, error) {
@@ -50,27 +55,53 @@ func (i *FileInput) String() string {
 func (i *FileInput) emit() {
 	var lastTime int64
 
+	payloadSeparatorAsBytes := []byte(payloadSeparator)
+	reader := bufio.NewReader(i.file)
+	var buffer bytes.Buffer
+
 	for {
-		raw := new(RawRequest)
-		err := i.decoder.Decode(raw)
+		line, err := reader.ReadBytes('\n')
 
 		if err != nil {
-			return
+			if err != io.EOF {
+				log.Fatal(err)
+			}
+			break
+
 		}
 
-		if lastTime != 0 {
-			timeDiff := raw.Timestamp - lastTime
+		if bytes.Equal(payloadSeparatorAsBytes[1:], line) {
+			asBytes := buffer.Bytes()
+			buffer.Reset()
 
-			// We can speedup or slowdown execution based on speedFactor
-			if i.speedFactor != 1 {
-				timeDiff = int64(float64(raw.Timestamp-lastTime) / i.speedFactor)
+			meta := payloadMeta(asBytes)
+
+			if len(meta) > 2 && meta[0][0] == RequestPayload {
+				ts, _ := strconv.ParseInt(string(meta[2]), 10, 64)
+
+				if lastTime != 0 {
+					timeDiff := ts - lastTime
+
+					if i.speedFactor != 1 {
+						timeDiff = int64(float64(timeDiff) / i.speedFactor)
+					}
+
+					time.Sleep(time.Duration(timeDiff))
+				}
+
+				lastTime = ts
 			}
 
-			time.Sleep(time.Duration(timeDiff))
+			// Bytes() returns only pointer, so to remove data-race copy the data to an array
+			newBuf := make([]byte, len(asBytes)-1)
+			copy(newBuf, asBytes)
+
+			i.data <- newBuf
+		} else {
+			buffer.Write(line)
 		}
 
-		lastTime = raw.Timestamp
-
-		i.data <- raw.Request
 	}
+
+	log.Printf("FileInput: end of file '%s'\n", i.path)
 }

input_file_test.go

@@ -0,0 +1,220 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"io/ioutil"
+	"os"
+	"sync"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func TestInputFileWithGET(t *testing.T) {
+
+	input := NewTestInput()
+	rg := NewRequestGenerator([]io.Reader{input}, func() { input.EmitGET() }, 1)
+	readPayloads := [][]byte{}
+
+	// Given a capture file with a GET request
+	expectedCaptureFile := CreateCaptureFile(rg)
+	defer expectedCaptureFile.TearDown()
+
+	// When the request is read from the capture file
+	err := ReadFromCaptureFile(expectedCaptureFile.file, 1, func(data []byte) {
+		readPayloads = append(readPayloads, Duplicate(data))
+	})
+
+	// The read request should match the original request
+	if err != nil {
+		t.Error(err)
+	} else {
+		if !expectedCaptureFile.PayloadsEqual(readPayloads) {
+			t.Error("Request read back from file should match")
+		}
+	}
+
+}
+
+func TestInputFileWithPayloadLargerThan64Kb(t *testing.T) {
+
+	input := NewTestInput()
+	rg := NewRequestGenerator([]io.Reader{input}, func() { input.EmitSizedPOST(64 * 1024) }, 1)
+	readPayloads := [][]byte{}
+
+	// Given a capture file with a request over 64Kb
+	expectedCaptureFile := CreateCaptureFile(rg)
+	defer expectedCaptureFile.TearDown()
+
+	// When the request is read from the capture file
+	err := ReadFromCaptureFile(expectedCaptureFile.file, 1, func(data []byte) {
+		readPayloads = append(readPayloads, Duplicate(data))
+	})
+
+	// The read request should match the original request
+	if err != nil {
+		t.Error(err)
+	} else {
+		if !expectedCaptureFile.PayloadsEqual(readPayloads) {
+			t.Error("Request read back from file should match")
+		}
+	}
+
+}
+
+func TestInputFileWithGETAndPOST(t *testing.T) {
+
+	input := NewTestInput()
+	rg := NewRequestGenerator([]io.Reader{input}, func() {
+		input.EmitGET()
+		input.EmitPOST()
+	}, 2)
+	readPayloads := [][]byte{}
+
+	// Given a capture file with a GET request
+	expectedCaptureFile := CreateCaptureFile(rg)
+	defer expectedCaptureFile.TearDown()
+
+	// When the requests are read from the capture file
+	err := ReadFromCaptureFile(expectedCaptureFile.file, 2, func(data []byte) {
+		readPayloads = append(readPayloads, Duplicate(data))
+	})
+
+	// The read requests should match the original request
+	if err != nil {
+		t.Error(err)
+	} else {
+		if !expectedCaptureFile.PayloadsEqual(readPayloads) {
+			t.Error("Request read back from file should match")
+		}
+	}
+
+}
+
+type CaptureFile struct {
+	data [][]byte
+	file *os.File
+}
+
+func NewExpectedCaptureFile(data [][]byte, file *os.File) *CaptureFile {
+	ecf := new(CaptureFile)
+	ecf.file = file
+	ecf.data = data
+	return ecf
+}
+
+func (expectedCaptureFile *CaptureFile) TearDown() {
+	if expectedCaptureFile.file != nil {
+		syscall.Unlink(expectedCaptureFile.file.Name())
+	}
+}
+
+type RequestGenerator struct {
+	inputs []io.Reader
+	emit   func()
+	wg     *sync.WaitGroup
+}
+
+func NewRequestGenerator(inputs []io.Reader, emit func(), count int) (rg *RequestGenerator) {
+	rg = new(RequestGenerator)
+	rg.inputs = inputs
+	rg.emit = emit
+	rg.wg = new(sync.WaitGroup)
+	rg.wg.Add(count)
+	return
+}
+
+func (expectedCaptureFile *CaptureFile) PayloadsEqual(other [][]byte) bool {
+
+	if len(expectedCaptureFile.data) != len(other) {
+		return false
+	}
+
+	for i, payload := range other {
+
+		if !bytes.Equal(expectedCaptureFile.data[i], payload) {
+			return false
+		}
+
+	}
+
+	return true
+
+}
+
+func CreateCaptureFile(requestGenerator *RequestGenerator) *CaptureFile {
+
+	f, err := ioutil.TempFile("", "testmainconf")
+	if err != nil {
+		panic(err)
+	}
+
+	quit := make(chan int)
+
+	readPayloads := [][]byte{}
+	output := NewTestOutput(func(data []byte) {
+
+		readPayloads = append(readPayloads, Duplicate(data))
+
+		requestGenerator.wg.Done()
+	})
+
+	outputFile := NewFileOutput(f.Name())
+
+	Plugins.Inputs = requestGenerator.inputs
+	Plugins.Outputs = []io.Writer{output, outputFile}
+
+	go Start(quit)
+
+	requestGenerator.emit()
+	requestGenerator.wg.Wait()
+
+	close(quit)
+
+	return NewExpectedCaptureFile(readPayloads, f)
+
+}
+
+func ReadFromCaptureFile(captureFile *os.File, count int, callback writeCallback) (err error) {
+
+	quit := make(chan int)
+	wg := new(sync.WaitGroup)
+
+	input := NewFileInput(captureFile.Name())
+	output := NewTestOutput(func(data []byte) {
+		callback(data)
+		wg.Done()
+	})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+
+	wg.Add(count)
+	go Start(quit)
+
+	done := make(chan int, 1)
+	go func() {
+		wg.Wait()
+		done <- 1
+	}()
+
+	select {
+	case <-done:
+		break
+	case <-time.After(2 * time.Second):
+		err = errors.New("Timed out")
+	}
+	close(quit)
+
+	return
+
+}
+
+func Duplicate(data []byte) (duplicate []byte) {
+	duplicate = make([]byte, len(data))
+	copy(duplicate, data)
+
+	return
+}

input_http.go

@@ -5,17 +5,20 @@ import (
 	"net"
 	"net/http"
 	"net/http/httputil"
+	"time"
 )
 
+// HTTPInput used for sending requests to Gor via http
 type HTTPInput struct {
 	data     chan []byte
 	address  string
 	listener net.Listener
 }
 
+// NewHTTPInput constructor for HTTPInput. Accepts address with port which he will listen on.
 func NewHTTPInput(address string) (i *HTTPInput) {
 	i = new(HTTPInput)
-	i.data = make(chan []byte)
+	i.data = make(chan []byte, 10000)
 	i.address = address
 
 	i.listen(address)
@@ -25,17 +28,27 @@ func NewHTTPInput(address string) (i *HTTPInput) {
 
 func (i *HTTPInput) Read(data []byte) (int, error) {
 	buf := <-i.data
-	copy(data, buf)
 
-	return len(buf), nil
+	header := payloadHeader(RequestPayload, uuid(), time.Now().UnixNano())
+
+	copy(data[0:len(header)], header)
+	copy(data[len(header):], buf)
+
+	return len(buf) + len(header), nil
 }
 
 func (i *HTTPInput) handler(w http.ResponseWriter, r *http.Request) {
-	buf, _ := httputil.DumpRequest(r, true)
-
-	i.data <- buf
+	r.URL.Scheme = "http"
+	r.URL.Host = i.listener.Addr().String()
 
+	buf, _ := httputil.DumpRequestOut(r, true)
 	http.Error(w, http.StatusText(200), 200)
+
+	select {
+	case i.data <- buf:
+	default:
+		Debug("[INPUT-HTTP] Dropping requests because output can't process them fast enough")
+	}
 }
 
 func (i *HTTPInput) listen(address string) {

input_http_test.go

@@ -1,8 +1,11 @@
 package main
 
 import (
+	"github.com/buger/gor/proto"
 	"io"
+	"log"
 	"net/http"
+	"os/exec"
 	"strings"
 	"sync"
 	"testing"
@@ -12,7 +15,7 @@ func TestHTTPInput(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	input := NewHTTPInput(":0")
+	input := NewHTTPInput("127.0.0.1:0")
 	output := NewTestOutput(func(data []byte) {
 		wg.Done()
 	})
@@ -33,3 +36,37 @@ func TestHTTPInput(t *testing.T) {
 
 	close(quit)
 }
+
+func TestInputHTTPLargePayload(t *testing.T) {
+	wg := new(sync.WaitGroup)
+	quit := make(chan int)
+
+	dd := exec.Command("dd", "if=/dev/urandom", "of=/tmp/large", "bs=1", "count=4000000")
+	err := dd.Run()
+	if err != nil {
+		log.Fatal("dd error:", err)
+	}
+
+	input := NewHTTPInput("127.0.0.1:0")
+	output := NewTestOutput(func(data []byte) {
+		if len(proto.Body(payloadBody(data))) != 4000000 {
+			t.Error("Should receive full file")
+		}
+		wg.Done()
+	})
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+
+	go Start(quit)
+
+	wg.Add(1)
+	address := strings.Replace(input.listener.Addr().String(), "[::]", "127.0.0.1", -1)
+	curl := exec.Command("curl", "http://"+address, "--data-binary", "@/tmp/large")
+	err = curl.Run()
+	if err != nil {
+		log.Fatal("curl error:", err)
+	}
+
+	wg.Wait()
+	close(quit)
+}

input_raw.go

@@ -4,33 +4,62 @@ import (
 	raw "github.com/buger/gor/raw_socket_listener"
 	"log"
 	"net"
-	"strings"
+	"time"
 )
 
+// RAWInput used for intercepting traffic for given address
 type RAWInput struct {
-	data    chan []byte
-	address string
+	data          chan *raw.TCPMessage
+	address       string
+	expire        time.Duration
+	quit          chan bool
+	engine        int
+	trackResponse bool
+	listener      *raw.Listener
 }
 
-func NewRAWInput(address string) (i *RAWInput) {
-	i = new(RAWInput)
-	i.data = make(chan []byte)
-	i.address = address
+// Available engines for intercepting traffic
+const (
+	EngineRawSocket = 1 << iota
+	EnginePcap
+)
 
-	go i.listen(address)
+// NewRAWInput constructor for RAWInput. Accepts address with port as argument.
+func NewRAWInput(address string, engine int, trackResponse bool, expire time.Duration) (i *RAWInput) {
+	i = new(RAWInput)
+	i.data = make(chan *raw.TCPMessage)
+	i.address = address
+	i.expire = expire
+	i.engine = engine
+	i.quit = make(chan bool)
+	i.trackResponse = trackResponse
+
+	i.listen(address)
+	i.listener.IsReady()
 
 	return
 }
 
 func (i *RAWInput) Read(data []byte) (int, error) {
-	buf := <-i.data
-	copy(data, buf)
+	msg := <-i.data
+	buf := msg.Bytes()
 
-	return len(buf), nil
+	var header []byte
+
+	if msg.IsIncoming {
+		header = payloadHeader(RequestPayload, msg.UUID(), msg.Start.UnixNano())
+	} else {
+		header = payloadHeader(ResponsePayload, msg.UUID(), msg.End.UnixNano()-msg.AssocMessage.Start.UnixNano())
+	}
+
+	copy(data[0:len(header)], header)
+	copy(data[len(header):], buf)
+
+	return len(buf) + len(header), nil
 }
 
 func (i *RAWInput) listen(address string) {
-	address = strings.Replace(address, "[::]", "127.0.0.1", -1)
+	Debug("Listening for traffic on: " + address)
 
 	host, port, err := net.SplitHostPort(address)
 
@@ -38,16 +67,31 @@ func (i *RAWInput) listen(address string) {
 		log.Fatal("input-raw: error while parsing address", err)
 	}
 
-	listener := raw.NewListener(host, port)
+	i.listener = raw.NewListener(host, port, i.engine, i.trackResponse, i.expire)
 
-	for {
-		// Receiving TCPMessage object
-		m := listener.Receive()
+	ch := i.listener.Receiver()
 
-		i.data <- m.Bytes()
-	}
+	go func() {
+		for {
+			select {
+			case <-i.quit:
+				return
+			default:
+			}
+
+			// Receiving TCPMessage object
+			m := <-ch
+
+			i.data <- m
+		}
+	}()
 }
 
 func (i *RAWInput) String() string {
-	return "RAW Socket input: " + i.address
+	return "Intercepting traffic from: " + i.address
+}
+
+func (i *RAWInput) Close() {
+	i.listener.Close()
+	close(i.quit)
 }

input_raw_test.go

@@ -5,41 +5,130 @@ import (
 	"io"
 	"io/ioutil"
 	"log"
+	"math/rand"
+	"net"
 	"net/http"
+	"net/http/httptest"
 	"net/http/httputil"
+	"os"
 	"os/exec"
+	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"testing"
+	"time"
 )
 
-func TestRAWInput(t *testing.T) {
+const testRawExpire = time.Millisecond * 200
 
+func TestRAWInput(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	listener := startHTTP(func(req *http.Request) {})
+	listener, err := net.Listen("tcp", ":0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	origin := &http.Server{
+		Handler:      http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+	go origin.Serve(listener)
+	defer listener.Close()
+
+	originAddr := listener.Addr().String()
+
+	var respCounter, reqCounter int64
+
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire)
+	defer input.Close()
 
-	input := NewRAWInput(listener.Addr().String())
 	output := NewTestOutput(func(data []byte) {
+		if data[0] == '1' {
+			atomic.AddInt64(&reqCounter, 1)
+		} else {
+			atomic.AddInt64(&respCounter, 1)
+		}
+
+		if Settings.debug {
+			log.Println(reqCounter, respCounter)
+		}
+
 		wg.Done()
 	})
 
 	Plugins.Inputs = []io.Reader{input}
 	Plugins.Outputs = []io.Writer{output}
 
-	address := strings.Replace(listener.Addr().String(), "[::]", "127.0.0.1", -1)
+	client := NewHTTPClient("http://"+listener.Addr().String(), &HTTPClientConfig{})
 
 	go Start(quit)
 
 	for i := 0; i < 100; i++ {
-		wg.Add(1)
-		res, _ := http.Get("http://" + address)
-		res.Body.Close()
+		// request + response
+		wg.Add(2)
+		client.Get("/")
+		time.Sleep(2 * time.Millisecond)
 	}
 
 	wg.Wait()
+	close(quit)
+}
 
+func TestRAWInputIPv6(t *testing.T) {
+	wg := new(sync.WaitGroup)
+	quit := make(chan int)
+
+	listener, err := net.Listen("tcp", "[::1]:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	origin := &http.Server{
+		Handler:      http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+	go origin.Serve(listener)
+	defer listener.Close()
+
+	originAddr := listener.Addr().String()
+
+	var respCounter, reqCounter int64
+
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire)
+	defer input.Close()
+
+	output := NewTestOutput(func(data []byte) {
+		if data[0] == '1' {
+			atomic.AddInt64(&reqCounter, 1)
+		} else {
+			atomic.AddInt64(&respCounter, 1)
+		}
+
+		if Settings.debug {
+			log.Println(reqCounter, respCounter)
+		}
+
+		wg.Done()
+	})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+
+	client := NewHTTPClient("http://"+listener.Addr().String(), &HTTPClientConfig{})
+
+	go Start(quit)
+
+	for i := 0; i < 100; i++ {
+		// request + response
+		wg.Add(2)
+		client.Get("/")
+		time.Sleep(2 * time.Millisecond)
+	}
+
+	wg.Wait()
 	close(quit)
 }
 
@@ -47,50 +136,57 @@ func TestInputRAW100Expect(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	file_content, _ := ioutil.ReadFile("README.md")
+	fileContent, _ := ioutil.ReadFile("COMM-LICENSE")
 
 	// Origing and Replay server initialization
-	origin := startHTTP(func(req *http.Request) {
-		defer req.Body.Close()
-		ioutil.ReadAll(req.Body)
-
+	origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		ioutil.ReadAll(r.Body)
 		wg.Done()
-	})
+	}))
+	defer origin.Close()
 
-	origin_address := strings.Replace(origin.Addr().String(), "[::]", "127.0.0.1", -1)
+	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
 
-	input := NewRAWInput(origin_address)
+	input := NewRAWInput(originAddr, EnginePcap, true, time.Second)
+	defer input.Close()
 
 	// We will use it to get content of raw HTTP request
-	test_output := NewTestOutput(func(data []byte) {
-		if strings.Contains(string(data), "Expect: 100-continue") {
-			t.Error("Should not contain 100-continue header")
+	testOutput := NewTestOutput(func(data []byte) {
+		switch data[0] {
+		case RequestPayload:
+			if strings.Contains(string(data), "Expect: 100-continue") {
+				t.Error("Should not contain 100-continue header")
+			}
+			wg.Done()
+		case ResponsePayload:
+			wg.Done()
 		}
-		wg.Done()
 	})
 
-	listener := startHTTP(func(req *http.Request) {
-		defer req.Body.Close()
-		body, _ := ioutil.ReadAll(req.Body)
+	replay := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		body, _ := ioutil.ReadAll(r.Body)
 
-		if !bytes.Equal(body, file_content) {
-			buf, _ := httputil.DumpRequest(req, true)
+		if !bytes.Equal(body, fileContent) {
+			buf, _ := httputil.DumpRequest(r, true)
 			t.Error("Wrong POST body:", string(buf))
 		}
 
 		wg.Done()
-	})
-	replay_address := listener.Addr().String()
+	}))
+	defer replay.Close()
 
-	http_output := NewHTTPOutput(replay_address, &HTTPOutputConfig{})
+	httpOutput := NewHTTPOutput(replay.URL, &HTTPOutputConfig{})
 
 	Plugins.Inputs = []io.Reader{input}
-	Plugins.Outputs = []io.Writer{test_output, http_output}
+	Plugins.Outputs = []io.Writer{testOutput, httpOutput}
 
 	go Start(quit)
 
-	wg.Add(3)
-	curl := exec.Command("curl", "http://"+origin_address, "--data-binary", "@README.md")
+	// Origin + Response/Request Test Output + Request Http Output
+	wg.Add(4)
+	curl := exec.Command("curl", "http://"+originAddr, "--data-binary", "@COMM-LICENSE")
 	err := curl.Run()
 	if err != nil {
 		log.Fatal(err)
@@ -104,43 +200,43 @@ func TestInputRAWChunkedEncoding(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	file_content, _ := ioutil.ReadFile("README.md")
+	fileContent, _ := ioutil.ReadFile("README.md")
 
 	// Origing and Replay server initialization
-	origin := startHTTP(func(req *http.Request) {
-		defer req.Body.Close()
-		ioutil.ReadAll(req.Body)
+	origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		ioutil.ReadAll(r.Body)
 
 		wg.Done()
-	})
+	}))
 
-	origin_address := strings.Replace(origin.Addr().String(), "[::]", "127.0.0.1", -1)
+	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
+	input := NewRAWInput(originAddr, EnginePcap, true, time.Second)
+	defer input.Close()
 
-	input := NewRAWInput(origin_address)
+	replay := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+		body, _ := ioutil.ReadAll(r.Body)
 
-	listener := startHTTP(func(req *http.Request) {
-		defer req.Body.Close()
-		body, _ := ioutil.ReadAll(req.Body)
-
-		if !bytes.Equal(body, file_content) {
-			buf, _ := httputil.DumpRequest(req, true)
+		if !bytes.Equal(body, fileContent) {
+			buf, _ := httputil.DumpRequest(r, true)
 			t.Error("Wrong POST body:", string(buf))
 		}
 
 		wg.Done()
-	})
-	replay_address := listener.Addr().String()
+	}))
+	defer replay.Close()
 
-	http_output := NewHTTPOutput(replay_address, &HTTPOutputConfig{Debug: true})
+	httpOutput := NewHTTPOutput(replay.URL, &HTTPOutputConfig{Debug: true})
 
 	Plugins.Inputs = []io.Reader{input}
-	Plugins.Outputs = []io.Writer{http_output}
+	Plugins.Outputs = []io.Writer{httpOutput}
 
 	go Start(quit)
 
 	wg.Add(2)
 
-	curl := exec.Command("curl", "http://"+origin_address, "--header", "Transfer-Encoding: chunked", "--data-binary", "@README.md")
+	curl := exec.Command("curl", "http://"+originAddr, "--header", "Transfer-Encoding: chunked", "--header", "Expect:", "--data-binary", "@README.md")
 	err := curl.Run()
 	if err != nil {
 		log.Fatal(err)
@@ -150,3 +246,124 @@ func TestInputRAWChunkedEncoding(t *testing.T) {
 
 	close(quit)
 }
+
+func TestInputRAWLargePayload(t *testing.T) {
+	// FIXME: Large payloads does not work for travis for some reason...
+	if os.Getenv("TRAVIS_BUILD_DIR") != "" {
+		return
+	}
+	wg := new(sync.WaitGroup)
+	quit := make(chan int)
+	sizeB := 100 * 1000
+
+	// Generate 100kb file
+	dd := exec.Command("dd", "if=/dev/urandom", "of=/tmp/large", "bs=1", "count="+strconv.Itoa(sizeB))
+	err := dd.Run()
+	if err != nil {
+		log.Fatal("dd error:", err)
+	}
+
+	origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		defer req.Body.Close()
+		body, _ := ioutil.ReadAll(req.Body)
+
+		if len(body) != sizeB {
+			t.Error("File size should be 1mb:", len(body))
+		}
+
+		wg.Done()
+	}))
+	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
+
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire)
+	defer input.Close()
+
+	replay := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		body, _ := ioutil.ReadAll(req.Body)
+		// // req.Body = http.MaxBytesReader(w, req.Body, 1*1024*1024)
+		// // buf := make([]byte, 1*1024*1024)
+		// n, _ := req.Body.Read(buf)
+		// body := buf[0:n]
+
+		if len(body) != sizeB {
+			t.Errorf("File size should be %d bytes: %d", sizeB, len(body))
+		}
+
+		wg.Done()
+	}))
+	defer replay.Close()
+
+	httpOutput := NewHTTPOutput(replay.URL, &HTTPOutputConfig{Debug: false})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{httpOutput}
+
+	go Start(quit)
+
+	wg.Add(2)
+	curl := exec.Command("curl", "http://"+originAddr, "--header", "Transfer-Encoding: chunked", "--header", "Expect:", "--data-binary", "@/tmp/large")
+	err = curl.Run()
+	if err != nil {
+		log.Fatal("curl error:", err)
+	}
+
+	wg.Wait()
+	close(quit)
+}
+
+func BenchmarkRAWInput(b *testing.B) {
+	quit := make(chan int)
+
+	origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
+	defer origin.Close()
+	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
+
+	var respCounter, reqCounter int64
+
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire)
+	defer input.Close()
+
+	output := NewTestOutput(func(data []byte) {
+		if data[0] == '1' {
+			atomic.AddInt64(&reqCounter, 1)
+		} else {
+			atomic.AddInt64(&respCounter, 1)
+		}
+
+		// log.Println("Captured ", reqCounter, "requests and ", respCounter, " responses")
+	})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+
+	go Start(quit)
+
+	emitted := 0
+	fileContent, _ := ioutil.ReadFile("LICENSE.txt")
+
+	for i := 0; i < b.N; i++ {
+		wg := new(sync.WaitGroup)
+		wg.Add(10 * 100)
+		emitted += 10 * 100
+		for w := 0; w < 100; w++ {
+			go func() {
+				client := NewHTTPClient(origin.URL, &HTTPClientConfig{})
+				for i := 0; i < 10; i++ {
+					if rand.Int63n(2) == 0 {
+						client.Post("/", fileContent)
+					} else {
+						client.Get("/")
+					}
+					time.Sleep(time.Duration(rand.Int63n(50)) * time.Millisecond)
+					wg.Done()
+				}
+			}()
+		}
+		wg.Wait()
+	}
+
+	time.Sleep(400 * time.Millisecond)
+	log.Println("Emitted ", emitted, ", Captured ", reqCounter, "requests and ", respCounter, " responses")
+
+	close(quit)
+}

input_tcp.go

@@ -2,25 +2,25 @@ package main
 
 import (
 	"bufio"
-	"encoding/hex"
+	"bytes"
 	"fmt"
+	"io"
 	"log"
 	"net"
 	"os"
 )
 
-// Can be tested using nc tool:
-//    echo "asdad" | nc 127.0.0.1 27017
-//
+// TCPInput used for internal communication
 type TCPInput struct {
 	data     chan []byte
 	address  string
 	listener net.Listener
 }
 
+// NewTCPInput constructor for TCPInput, accepts address with port
 func NewTCPInput(address string) (i *TCPInput) {
 	i = new(TCPInput)
-	i.data = make(chan []byte)
+	i.data = make(chan []byte, 1000)
 	i.address = address
 
 	i.listen(address)
@@ -60,19 +60,32 @@ func (i *TCPInput) listen(address string) {
 func (i *TCPInput) handleConnection(conn net.Conn) {
 	defer conn.Close()
 
+	payloadSeparatorAsBytes := []byte(payloadSeparator)
 	reader := bufio.NewReader(conn)
-	scanner := bufio.NewScanner(reader)
+	var buffer bytes.Buffer
 
-	for scanner.Scan() {
-		encodedPayload := scanner.Bytes()
-		// Hex encoding always 2x number of bytes
-		decoded := make([]byte, len(encodedPayload)/2)
-		hex.Decode(decoded, encodedPayload)
-		i.data <- decoded
-	}
+	for {
+		line, err := reader.ReadBytes('\n')
 
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintln(os.Stderr, "Unexpected error in input tcp connection:", err)
+		if err != nil {
+			if err != io.EOF {
+				fmt.Fprintln(os.Stderr, "Unexpected error in input tcp connection:", err)
+			}
+			break
+
+		}
+
+		if bytes.Equal(payloadSeparatorAsBytes[1:], line) {
+			asBytes := buffer.Bytes()
+			buffer.Reset()
+
+			newBuf := make([]byte, len(asBytes)-1)
+			copy(newBuf, asBytes)
+
+			i.data <- newBuf
+		} else {
+			buffer.Write(line)
+		}
 	}
 }
 

input_tcp_test.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/hex"
 	"io"
 	"log"
 	"net"
@@ -13,7 +12,7 @@ func TestTCPInput(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	input := NewTCPInput(":0")
+	input := NewTCPInput("127.0.0.1:0")
 	output := NewTestOutput(func(data []byte) {
 		wg.Done()
 	})
@@ -35,79 +34,15 @@ func TestTCPInput(t *testing.T) {
 		log.Fatal(err)
 	}
 
-	msg := []byte("GET / HTTP/1.1\r\n\r\n")
+	msg := []byte("1 1 1\nGET / HTTP/1.1\r\n\r\n")
 
 	for i := 0; i < 100; i++ {
 		wg.Add(1)
-
-		encoded := make([]byte, len(msg)*2+1)
-		hex.Encode(encoded, msg)
-		conn.Write(append(encoded, '\n'))
+		conn.Write(msg)
+		conn.Write([]byte(payloadSeparator))
 	}
 
 	wg.Wait()
 
 	close(quit)
 }
-
-func BenchmarkTCPInput(b *testing.B) {
-	wg := new(sync.WaitGroup)
-	quit := make(chan int)
-
-	input := NewTCPInput(":0")
-	output := NewTestOutput(func(data []byte) {
-		wg.Done()
-	})
-
-	Plugins.Inputs = []io.Reader{input}
-	Plugins.Outputs = []io.Writer{output}
-
-	go Start(quit)
-
-	tcpAddr, err := net.ResolveTCPAddr("tcp", input.listener.Addr().String())
-
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	var connections []net.Conn
-
-	// Creating simple pool of workers, same as output_tcp have
-	dataChan := make(chan []byte, 1000)
-
-	for i := 0; i < 10; i++ {
-		conn, _ := net.DialTCP("tcp", nil, tcpAddr)
-		connections = append(connections, conn)
-
-		go func(conn net.Conn) {
-			for {
-				data := <-dataChan
-
-				new_buf := make([]byte, len(data)+2)
-				data = append(data, []byte("¶")...)
-				copy(new_buf, data)
-				conn.Write(new_buf)
-			}
-		}(conn)
-	}
-
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	msg := []byte("GET / HTTP/1.1\r\n\r\n")
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		wg.Add(1)
-		dataChan <- msg
-	}
-
-	wg.Wait()
-
-	for _, conn := range connections {
-		conn.Close()
-	}
-
-	close(quit)
-}

limiter.go

@@ -9,6 +9,7 @@ import (
 	"time"
 )
 
+// Limiter is a wrapper for input or output plugin which adds rate limiting
 type Limiter struct {
 	plugin    interface{}
 	limit     int
@@ -30,6 +31,8 @@ func parseLimitOptions(options string) (limit int, isPercent bool) {
 	return
 }
 
+// NewLimiter constructor for Limiter, accepts plugin and options
+// `options` allow to sprcify relatve or absolute limiting
 func NewLimiter(plugin interface{}, options string) io.ReadWriter {
 	l := new(Limiter)
 	l.limit, l.isPercent = parseLimitOptions(options)

middleware.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"bufio"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+)
+
+type Middleware struct {
+	command string
+
+	data chan []byte
+
+	mu sync.Mutex
+
+	Stdin  io.Writer
+	Stdout io.Reader
+}
+
+func NewMiddleware(command string) *Middleware {
+	m := new(Middleware)
+	m.command = command
+	m.data = make(chan []byte, 1000)
+
+	commands := strings.Split(command, " ")
+	cmd := exec.Command(commands[0], commands[1:]...)
+
+	m.Stdout, _ = cmd.StdoutPipe()
+	m.Stdin, _ = cmd.StdinPipe()
+
+	if Settings.verbose {
+		cmd.Stderr = os.Stderr
+	}
+
+	go m.read(m.Stdout)
+
+	go func() {
+		err := cmd.Start()
+
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		err = cmd.Wait()
+
+		if err != nil {
+			log.Fatal(err)
+		}
+	}()
+
+	return m
+}
+
+func (m *Middleware) ReadFrom(plugin io.Reader) {
+	Debug("[MIDDLEWARE-MASTER] Starting reading from", plugin)
+	go m.copy(m.Stdin, plugin)
+}
+
+func (m *Middleware) copy(to io.Writer, from io.Reader) {
+	buf := make([]byte, 5*1024*1024)
+	dst := make([]byte, len(buf)*2)
+
+	for {
+		nr, _ := from.Read(buf)
+		if nr > 0 && len(buf) > nr {
+
+			hex.Encode(dst, buf[0:nr])
+			dst[nr*2] = '\n'
+
+			m.mu.Lock()
+			to.Write(dst[0 : nr*2+1])
+			m.mu.Unlock()
+
+			if Settings.debug {
+				Debug("[MIDDLEWARE-MASTER] Sending:", string(buf[0:nr]), "From:", from)
+			}
+		}
+	}
+}
+
+func (m *Middleware) read(from io.Reader) {
+	reader := bufio.NewReader(from)
+	var line []byte
+	var e error
+
+	for {
+		if line, e = reader.ReadBytes('\n'); e != nil {
+			if e == io.EOF {
+				continue
+			} else {
+				break
+			}
+		}
+
+		buf := make([]byte, len(line)/2)
+		if _, err := hex.Decode(buf, line[:len(line)-1]); err != nil {
+			fmt.Fprintln(os.Stderr, "Failed to decode input payload", err, len(line))
+		}
+
+		if Settings.debug {
+			Debug("[MIDDLEWARE-MASTER] Received:", string(buf))
+		}
+
+		m.data <- buf
+	}
+
+	return
+}
+
+func (m *Middleware) Read(data []byte) (int, error) {
+	buf := <-m.data
+	copy(data, buf)
+
+	return len(buf), nil
+}
+
+func (m *Middleware) String() string {
+	return fmt.Sprintf("Modifying traffic using '%s' command", m.command)
+}

middleware_test.go

@@ -0,0 +1,220 @@
+package main
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/hex"
+	"github.com/buger/gor/proto"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+type fakeServiceCb func(string, int, []byte)
+
+// Simple service that generate token on request, and require this token for accesing to secure area
+func NewFakeSecureService(wg *sync.WaitGroup, cb fakeServiceCb) *httptest.Server {
+	active_tokens := make([]string, 0)
+	var mu sync.Mutex
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		mu.Lock()
+		defer mu.Unlock()
+		Debug("Received request: " + req.URL.String())
+
+		switch req.URL.Path {
+		case "/token":
+			// Generate random token
+			token_length := 10
+			buf := make([]byte, token_length)
+			rand.Read(buf)
+			token := hex.EncodeToString(buf)
+			active_tokens = append(active_tokens, token)
+
+			w.Write([]byte(token))
+
+			cb(req.URL.Path, 200, []byte(token))
+		case "/secure":
+			token := req.URL.Query().Get("token")
+			token_found := false
+
+			for _, t := range active_tokens {
+				if t == token {
+					token_found = true
+					break
+				}
+			}
+
+			if token_found {
+				w.WriteHeader(http.StatusAccepted)
+				cb(req.URL.Path, 202, []byte(nil))
+			} else {
+				w.WriteHeader(http.StatusForbidden)
+				cb(req.URL.Path, 403, []byte(nil))
+			}
+		}
+
+		wg.Done()
+	}))
+
+	return server
+}
+
+func TestFakeSecureService(t *testing.T) {
+	var resp, token []byte
+
+	wg := new(sync.WaitGroup)
+
+	server := NewFakeSecureService(wg, func(path string, status int, resp []byte) {
+	})
+	defer server.Close()
+
+	wg.Add(3)
+
+	client := NewHTTPClient(server.URL, &HTTPClientConfig{Debug: true})
+	resp, _ = client.Get("/token")
+	token = proto.Body(resp)
+
+	// Right token
+	resp, _ = client.Get("/secure?token=" + string(token))
+	if !bytes.Equal(proto.Status(resp), []byte("202")) {
+		t.Error("Valid token should return status 202:", string(proto.Status(resp)))
+	}
+
+	// Wrong tokens forbidden
+	resp, _ = client.Get("/secure?token=wrong")
+	if !bytes.Equal(proto.Status(resp), []byte("403")) {
+		t.Error("Wrong token should returns status 403:", string(proto.Status(resp)))
+	}
+
+	wg.Wait()
+}
+
+func TestEchoMiddleware(t *testing.T) {
+	wg := new(sync.WaitGroup)
+
+	from := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Env", "prod")
+		w.Header().Set("RequestPath", r.URL.Path)
+		wg.Done()
+	}))
+	defer from.Close()
+
+	to := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Env", "test")
+		w.Header().Set("RequestPath", r.URL.Path)
+		wg.Done()
+	}))
+	defer to.Close()
+
+	quit := make(chan int)
+
+	Settings.middleware = "./examples/middleware/echo.sh"
+
+	// Catch traffic from one service
+	fromAddr := strings.Replace(from.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
+	input := NewRAWInput(fromAddr, EnginePcap, true, testRawExpire)
+	defer input.Close()
+
+	// And redirect to another
+	output := NewHTTPOutput(to.URL, &HTTPOutputConfig{Debug: false})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+
+	// Start Gor
+	go Start(quit)
+
+	// Wait till middleware initialization
+	time.Sleep(100 * time.Millisecond)
+
+	// Should receive 2 requests from original + 2 from replayed
+	client := NewHTTPClient(from.URL, &HTTPClientConfig{Debug: false})
+
+	for i := 0; i < 10; i++ {
+		wg.Add(4)
+		// Request should be echoed
+		client.Get("/a")
+		time.Sleep(5 * time.Millisecond)
+		client.Get("/b")
+		time.Sleep(5 * time.Millisecond)
+	}
+
+	wg.Wait()
+	close(quit)
+	time.Sleep(200 * time.Millisecond)
+
+	Settings.middleware = ""
+}
+
+func TestTokenMiddleware(t *testing.T) {
+	var resp, token []byte
+
+	wg := new(sync.WaitGroup)
+
+	from := NewFakeSecureService(wg, func(path string, status int, tok []byte) {
+		time.Sleep(10 * time.Millisecond)
+	})
+	defer from.Close()
+
+	to := NewFakeSecureService(wg, func(path string, status int, tok []byte) {
+		switch path {
+		case "/secure":
+			if status != 202 {
+				t.Error("Server should receive valid rewritten token")
+			}
+		}
+
+		time.Sleep(10 * time.Millisecond)
+	})
+	defer to.Close()
+
+	quit := make(chan int)
+
+	Settings.middleware = "go run ./examples/middleware/token_modifier.go"
+
+	fromAddr := strings.Replace(from.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
+	// Catch traffic from one service
+	input := NewRAWInput(fromAddr, EnginePcap, true, testRawExpire)
+	defer input.Close()
+
+	// And redirect to another
+	output := NewHTTPOutput(to.URL, &HTTPOutputConfig{Debug: true})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+
+	// Start Gor
+	go Start(quit)
+
+	// Wait for middleware to initialize
+	// Give go compiller time to build programm
+	time.Sleep(500 * time.Millisecond)
+
+	// Should receive 2 requests from original + 2 from replayed
+	wg.Add(4)
+
+	client := NewHTTPClient(from.URL, &HTTPClientConfig{Debug: true})
+
+	// Sending traffic to original service
+	resp, _ = client.Get("/token")
+	token = proto.Body(resp)
+
+	// When delay is too smal, middleware does not always rewrite requests in time
+	// Hopefuly client will have delay more then 100ms :)
+	time.Sleep(100 * time.Millisecond)
+
+	resp, _ = client.Get("/secure?token=" + string(token))
+	if !bytes.Equal(proto.Status(resp), []byte("202")) {
+		t.Error("Valid token should return 202:", proto.Status(resp))
+	}
+
+	wg.Wait()
+	close(quit)
+	time.Sleep(100 * time.Millisecond)
+	Settings.middleware = ""
+}

output_dummy.go

@@ -4,17 +4,19 @@ import (
 	"fmt"
 )
 
+// DummyOutput used for debugging, prints all incoming requests
 type DummyOutput struct {
 }
 
-func NewDummyOutput(options string) (di *DummyOutput) {
+// NewDummyOutput constructor for DummyOutput
+func NewDummyOutput() (di *DummyOutput) {
 	di = new(DummyOutput)
 
 	return
 }
 
 func (i *DummyOutput) Write(data []byte) (int, error) {
-	fmt.Println("Writing message: ", string(data))
+	fmt.Println(string(data))
 
 	return len(data), nil
 }

output_file.go

@@ -1,33 +1,27 @@
 package main
 
 import (
-	"encoding/gob"
 	"io"
 	"log"
 	"os"
-	"time"
 )
 
-type RawRequest struct {
-	Timestamp int64
-	Request   []byte
-}
-
+// FileOutput output plugin
 type FileOutput struct {
-	path    string
-	encoder *gob.Encoder
-	file    *os.File
+	path string
+	file *os.File
 }
 
+// NewFileOutput constructor for FileOutput, accepts path
 func NewFileOutput(path string) io.Writer {
 	o := new(FileOutput)
 	o.path = path
-	o.Init(path)
+	o.init(path)
 
 	return o
 }
 
-func (o *FileOutput) Init(path string) {
+func (o *FileOutput) init(path string) {
 	var err error
 
 	o.file, err = os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
@@ -35,14 +29,15 @@ func (o *FileOutput) Init(path string) {
 	if err != nil {
 		log.Fatal(o, "Cannot open file %q. Error: %s", path, err)
 	}
-
-	o.encoder = gob.NewEncoder(o.file)
 }
 
 func (o *FileOutput) Write(data []byte) (n int, err error) {
-	raw := RawRequest{time.Now().UnixNano(), data}
+	if !isOriginPayload(data) {
+		return len(data), nil
+	}
 
-	o.encoder.Encode(raw)
+	o.file.Write(data)
+	o.file.Write([]byte(payloadSeparator))
 
 	return len(data), nil
 }

output_http.go

@@ -2,13 +2,21 @@ package main
 
 import (
 	"io"
-	"log"
 	"sync/atomic"
 	"time"
+
+	"github.com/buger/gor/proto"
 )
 
-const InitialDynamicWorkers = 10
+const initialDynamicWorkers = 10
 
+type response struct {
+	payload       []byte
+	uuid          []byte
+	roundTripTime int64
+}
+
+// HTTPOutputConfig struct for holding http output configuration
 type HTTPOutputConfig struct {
 	redirectLimit int
 
@@ -17,9 +25,18 @@ type HTTPOutputConfig struct {
 
 	elasticSearch string
 
+	Timeout      time.Duration
+	OriginalHost bool
+	BufferSize   int
+
 	Debug bool
+
+	TrackResponses bool
 }
 
+// HTTPOutput plugin manage pool of workers which send request to replayed server
+// By default workers pool is dynamic and starts with 10 workers
+// You can specify fixed number of workers using `--output-http-workers`
 type HTTPOutput struct {
 	// Keep this as first element of struct because it guarantees 64bit
 	// alignment. atomic.* functions crash on 32bit machines if operand is not
@@ -30,6 +47,8 @@ type HTTPOutput struct {
 	limit   int
 	queue   chan []byte
 
+	responses chan response
+
 	needWorker chan int
 
 	config *HTTPOutputConfig
@@ -39,8 +58,9 @@ type HTTPOutput struct {
 	elasticSearch *ESPlugin
 }
 
+// NewHTTPOutput constructor for HTTPOutput
+// Initialize workers
 func NewHTTPOutput(address string, config *HTTPOutputConfig) io.Writer {
-
 	o := new(HTTPOutput)
 
 	o.address = address
@@ -50,12 +70,13 @@ func NewHTTPOutput(address string, config *HTTPOutputConfig) io.Writer {
 		o.queueStats = NewGorStat("output_http")
 	}
 
-	o.queue = make(chan []byte, 100)
+	o.queue = make(chan []byte, 1000)
+	o.responses = make(chan response, 1000)
 	o.needWorker = make(chan int, 1)
 
 	// Initial workers count
 	if o.config.workers == 0 {
-		o.needWorker <- InitialDynamicWorkers
+		o.needWorker <- initialDynamicWorkers
 	} else {
 		o.needWorker <- o.config.workers
 	}
@@ -65,16 +86,20 @@ func NewHTTPOutput(address string, config *HTTPOutputConfig) io.Writer {
 		o.elasticSearch.Init(o.config.elasticSearch)
 	}
 
-	go o.WorkerMaster()
+	if len(Settings.middleware) > 0 {
+		o.config.TrackResponses = true
+	}
+
+	go o.workerMaster()
 
 	return o
 }
 
-func (o *HTTPOutput) WorkerMaster() {
+func (o *HTTPOutput) workerMaster() {
 	for {
-		new_workers := <-o.needWorker
-		for i := 0; i < new_workers; i++ {
-			go o.Worker()
+		newWorkers := <-o.needWorker
+		for i := 0; i < newWorkers; i++ {
+			go o.startWorker()
 		}
 
 		// Disable dynamic scaling if workers poll fixed size
@@ -84,13 +109,16 @@ func (o *HTTPOutput) WorkerMaster() {
 	}
 }
 
-func (o *HTTPOutput) Worker() {
+func (o *HTTPOutput) startWorker() {
 	client := NewHTTPClient(o.address, &HTTPClientConfig{
-		FollowRedirects: o.config.redirectLimit,
-		Debug:           o.config.Debug,
+		FollowRedirects:    o.config.redirectLimit,
+		Debug:              o.config.Debug,
+		OriginalHost:       o.config.OriginalHost,
+		Timeout:            o.config.Timeout,
+		ResponseBufferSize: o.config.BufferSize,
 	})
 
-	death_count := 0
+	deathCount := 0
 
 	atomic.AddInt64(&o.activeWorkers, 1)
 
@@ -98,19 +126,19 @@ func (o *HTTPOutput) Worker() {
 		select {
 		case data := <-o.queue:
 			o.sendRequest(client, data)
-			death_count = 0
+			deathCount = 0
 		case <-time.After(time.Millisecond * 100):
 			// When dynamic scaling enabled workers die after 2s of inactivity
 			if o.config.workers == 0 {
-				death_count += 1
+				deathCount++
 			} else {
 				continue
 			}
 
-			if death_count > 20 {
+			if deathCount > 20 {
 				workersCount := atomic.LoadInt64(&o.activeWorkers)
 
-				// At least 1 worker should be alive
+				// At least 1 startWorker should be alive
 				if workersCount != 1 {
 					atomic.AddInt64(&o.activeWorkers, -1)
 					return
@@ -121,6 +149,10 @@ func (o *HTTPOutput) Worker() {
 }
 
 func (o *HTTPOutput) Write(data []byte) (n int, err error) {
+	if !isRequestPayload(data) {
+		return len(data), nil
+	}
+
 	buf := make([]byte, len(data))
 	copy(buf, data)
 
@@ -141,13 +173,40 @@ func (o *HTTPOutput) Write(data []byte) (n int, err error) {
 	return len(data), nil
 }
 
+func (o *HTTPOutput) Read(data []byte) (int, error) {
+	resp := <-o.responses
+
+	Debug("[OUTPUT-HTTP] Received response:", string(resp.payload))
+
+	header := payloadHeader(ReplayedResponsePayload, resp.uuid, resp.roundTripTime)
+	copy(data[0:len(header)], header)
+	copy(data[len(header):], resp.payload)
+
+	return len(resp.payload) + len(header), nil
+}
+
 func (o *HTTPOutput) sendRequest(client *HTTPClient, request []byte) {
+	meta := payloadMeta(request)
+	if len(meta) < 2 {
+		return
+	}
+	uuid := meta[1]
+
+	body := payloadBody(request)
+	if !proto.IsHTTPPayload(body) {
+		return
+	}
+
 	start := time.Now()
-	resp, err := client.Send(request)
+	resp, err := client.Send(body)
 	stop := time.Now()
 
 	if err != nil {
-		log.Println("Request error:", err)
+		Debug("Request error:", err)
+	}
+
+	if o.config.TrackResponses {
+		o.responses <- response{resp, uuid, stop.UnixNano() - start.UnixNano()}
 	}
 
 	if o.elasticSearch != nil {

output_http_test.go

@@ -3,7 +3,6 @@ package main
 import (
 	"io"
 	"io/ioutil"
-	"net"
 	"net/http"
 	"net/http/httptest"
 	_ "net/http/httputil"
@@ -12,25 +11,13 @@ import (
 	"time"
 )
 
-func startHTTP(cb func(*http.Request)) net.Listener {
-	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		cb(r)
-	})
-
-	listener, _ := net.Listen("tcp", ":0")
-
-	go http.Serve(listener, handler)
-
-	return listener
-}
-
 func TestHTTPOutput(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
 	input := NewTestInput()
 
-	listener := startHTTP(func(req *http.Request) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		if req.Header.Get("User-Agent") != "Gor" {
 			t.Error("Wrong header")
 		}
@@ -49,13 +36,14 @@ func TestHTTPOutput(t *testing.T) {
 		}
 
 		wg.Done()
-	})
+	}))
+	defer server.Close()
 
 	headers := HTTPHeaders{HTTPHeader{"User-Agent", "Gor"}}
 	methods := HTTPMethods{[]byte("GET"), []byte("PUT"), []byte("POST")}
 	Settings.modifierConfig = HTTPModifierConfig{headers: headers, methods: methods}
 
-	output := NewHTTPOutput(listener.Addr().String(), &HTTPOutputConfig{})
+	output := NewHTTPOutput(server.URL, &HTTPOutputConfig{Debug: true})
 
 	Plugins.Inputs = []io.Reader{input}
 	Plugins.Outputs = []io.Writer{output}
@@ -76,6 +64,41 @@ func TestHTTPOutput(t *testing.T) {
 	Settings.modifierConfig = HTTPModifierConfig{}
 }
 
+func TestHTTPOutputKeepOriginalHost(t *testing.T) {
+	wg := new(sync.WaitGroup)
+	quit := make(chan int)
+
+	input := NewTestInput()
+
+	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		if req.Host != "custom-host.com" {
+			t.Error("Wrong header", req.Host)
+		}
+
+		wg.Done()
+	}))
+	defer server.Close()
+
+	headers := HTTPHeaders{HTTPHeader{"Host", "custom-host.com"}}
+	Settings.modifierConfig = HTTPModifierConfig{headers: headers}
+
+	output := NewHTTPOutput(server.URL, &HTTPOutputConfig{Debug: false, OriginalHost: true})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+
+	go Start(quit)
+
+	wg.Add(1)
+	input.EmitGET()
+
+	wg.Wait()
+
+	close(quit)
+
+	Settings.modifierConfig = HTTPModifierConfig{}
+}
+
 func TestOutputHTTPSSL(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
@@ -86,10 +109,10 @@ func TestOutputHTTPSSL(t *testing.T) {
 	}))
 
 	input := NewTestInput()
-	http_output := NewHTTPOutput(server.URL, &HTTPOutputConfig{})
+	output := NewHTTPOutput(server.URL, &HTTPOutputConfig{})
 
 	Plugins.Inputs = []io.Reader{input}
-	Plugins.Outputs = []io.Writer{http_output}
+	Plugins.Outputs = []io.Writer{output}
 
 	go Start(quit)
 
@@ -106,13 +129,14 @@ func BenchmarkHTTPOutput(b *testing.B) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	listener := startHTTP(func(req *http.Request) {
+	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		time.Sleep(50 * time.Millisecond)
 		wg.Done()
-	})
+	}))
+	defer server.Close()
 
 	input := NewTestInput()
-	output := NewHTTPOutput(listener.Addr().String(), &HTTPOutputConfig{})
+	output := NewHTTPOutput(server.URL, &HTTPOutputConfig{})
 
 	Plugins.Inputs = []io.Reader{input}
 	Plugins.Outputs = []io.Writer{output}

output_tcp.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/hex"
 	"fmt"
 	"io"
 	"log"
@@ -9,6 +8,9 @@ import (
 	"time"
 )
 
+// TCPOutput used for sending raw tcp payloads
+// Currently used for internal communication between listener and replay server
+// Can be used for transfering binary payloads like protocol buffers
 type TCPOutput struct {
 	address  string
 	limit    int
@@ -16,6 +18,8 @@ type TCPOutput struct {
 	bufStats *GorStat
 }
 
+// NewTCPOutput constructor for TCPOutput
+// Initialize 10 workers which hold keep-alive connection
 func NewTCPOutput(address string) io.Writer {
 	o := new(TCPOutput)
 
@@ -34,17 +38,32 @@ func NewTCPOutput(address string) io.Writer {
 }
 
 func (o *TCPOutput) worker() {
+	retries := 1
 	conn, err := o.connect(o.address)
-	for ; err != nil; conn, err = o.connect(o.address) {
-		time.Sleep(2 * time.Second)
+	for {
+		if err == nil {
+			break
+		}
+
+		log.Println("Can't connect to aggregator instance, reconnecting in 1 second. Retries:", retries)
+		time.Sleep(1 * time.Second)
+
+		conn, err = o.connect(o.address)
+		retries++
+	}
+
+	if retries > 0 {
+		log.Println("Connected to aggregator instance after ", retries, " retries")
 	}
 
 	defer conn.Close()
 
 	for {
-		_, err := conn.Write(<-o.buf)
+		conn.Write(<-o.buf)
+		_, err := conn.Write([]byte(payloadSeparator))
+
 		if err != nil {
-			log.Println("Worker failed on write, exitings and starting new worker")
+			log.Println("Lost connection with aggregator instance, reconnecting")
 			go o.worker()
 			break
 		}
@@ -52,10 +71,15 @@ func (o *TCPOutput) worker() {
 }
 
 func (o *TCPOutput) Write(data []byte) (n int, err error) {
-	// Hex encoding always 2x number of bytes
-	encoded := make([]byte, len(data)*2+1)
-	hex.Encode(encoded, data)
-	o.buf <- append(encoded, '\n')
+	if !isOriginPayload(data) {
+		return len(data), nil
+	}
+
+	// We have to copy, because sending data in multiple threads
+	newBuf := make([]byte, len(data))
+	copy(newBuf, data)
+
+	o.buf <- newBuf
 
 	if Settings.outputTCPStats {
 		o.bufStats.Write(len(o.buf))
@@ -67,10 +91,6 @@ func (o *TCPOutput) Write(data []byte) (n int, err error) {
 func (o *TCPOutput) connect(address string) (conn net.Conn, err error) {
 	conn, err = net.Dial("tcp", address)
 
-	if err != nil {
-		log.Println("Connection error ", err, o.address)
-	}
-
 	return
 }
 

output_tcp_test.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"bufio"
-	"encoding/hex"
 	"io"
 	"log"
 	"net"
@@ -36,7 +35,7 @@ func TestTCPOutput(t *testing.T) {
 }
 
 func startTCP(cb func([]byte)) net.Listener {
-	listener, err := net.Listen("tcp", ":0")
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
 
 	if err != nil {
 		log.Fatal("Can't start:", err)
@@ -50,13 +49,10 @@ func startTCP(cb func([]byte)) net.Listener {
 			go func() {
 				reader := bufio.NewReader(conn)
 				scanner := bufio.NewScanner(reader)
+				scanner.Split(payloadScanner)
 
 				for scanner.Scan() {
-					encodedPayload := scanner.Bytes()
-					// Hex encoding always 2x number of bytes
-					decoded := make([]byte, len(encodedPayload)/2)
-					hex.Decode(decoded, encodedPayload)
-					cb(decoded)
+					cb(scanner.Bytes())
 				}
 			}()
 		}

plugins.go

@@ -4,31 +4,39 @@ import (
 	"io"
 	"reflect"
 	"strings"
+	"sync"
+	"time"
 )
 
+// InOutPlugins struct for holding references to plugins
 type InOutPlugins struct {
 	Inputs  []io.Reader
 	Outputs []io.Writer
+	All     []interface{}
 }
 
-type ReaderOrWriter interface{}
+var pluginMu sync.Mutex
 
+// Plugins holds all the plugin objects
 var Plugins *InOutPlugins = new(InOutPlugins)
 
+// extractLimitOptions detects if plugin get called with limiter support
+// Returns address and limit
 func extractLimitOptions(options string) (string, string) {
 	split := strings.Split(options, "|")
 
 	if len(split) > 1 {
 		return split[0], split[1]
-	} else {
-		return split[0], ""
 	}
+
+	return split[0], ""
 }
 
 // Automatically detects type of plugin and initialize it
 //
 // See this article if curious about relfect stuff below: http://blog.burntsushi.net/type-parametric-functions-golang
 func registerPlugin(constructor interface{}, options ...interface{}) {
+	var path, limit string
 	vc := reflect.ValueOf(constructor)
 
 	// Pre-processing options to make it work with reflect
@@ -37,42 +45,63 @@ func registerPlugin(constructor interface{}, options ...interface{}) {
 		vo = append(vo, reflect.ValueOf(oi))
 	}
 
-	// Removing limit options from path
-	path, limit := extractLimitOptions(vo[0].String())
+	if len(vo) > 0 {
+		// Removing limit options from path
+		path, limit = extractLimitOptions(vo[0].String())
 
-	// Writing value back without limiter "|" options
-	vo[0] = reflect.ValueOf(path)
+		// Writing value back without limiter "|" options
+		vo[0] = reflect.ValueOf(path)
+	}
 
 	// Calling our constructor with list of given options
 	plugin := vc.Call(vo)[0].Interface()
-	plugin_wrapper := plugin
+	pluginWrapper := plugin
 
 	if limit != "" {
-		plugin_wrapper = NewLimiter(plugin, limit)
+		pluginWrapper = NewLimiter(plugin, limit)
 	} else {
-		plugin_wrapper = plugin
+		pluginWrapper = plugin
 	}
 
-	if _, ok := plugin.(io.Reader); ok {
-		Plugins.Inputs = append(Plugins.Inputs, plugin_wrapper.(io.Reader))
+	_, isR := plugin.(io.Reader)
+	_, isW := plugin.(io.Writer)
+
+	// Some of the output can be Readers as well because return responses
+	if isR && !isW {
+		Plugins.Inputs = append(Plugins.Inputs, pluginWrapper.(io.Reader))
 	}
 
-	if _, ok := plugin.(io.Writer); ok {
-		Plugins.Outputs = append(Plugins.Outputs, plugin_wrapper.(io.Writer))
+	if isW {
+		Plugins.Outputs = append(Plugins.Outputs, pluginWrapper.(io.Writer))
 	}
+
+	Plugins.All = append(Plugins.All, plugin)
 }
 
+// InitPlugins specify and initialize all available plugins
 func InitPlugins() {
+	pluginMu.Lock()
+	defer pluginMu.Unlock()
+
 	for _, options := range Settings.inputDummy {
 		registerPlugin(NewDummyInput, options)
 	}
 
-	for _, options := range Settings.outputDummy {
-		registerPlugin(NewDummyOutput, options)
+	for range Settings.outputDummy {
+		registerPlugin(NewDummyOutput)
+	}
+
+	if Settings.outputStdout {
+		registerPlugin(NewDummyOutput)
+	}
+
+	engine := EnginePcap
+	if Settings.inputRAWEngine == "raw_socket" {
+		engine = EngineRawSocket
 	}
 
 	for _, options := range Settings.inputRAW {
-		registerPlugin(NewRAWInput, options)
+		registerPlugin(NewRAWInput, options, engine, Settings.inputRAWTrackResponse, time.Duration(0))
 	}
 
 	for _, options := range Settings.inputTCP {
@@ -95,6 +124,15 @@ func InitPlugins() {
 		registerPlugin(NewHTTPInput, options)
 	}
 
+	// If we explicitly set Host header http output should not rewrite it
+	// Fix: https://github.com/buger/gor/issues/174
+	for _, header := range Settings.modifierConfig.headers {
+		if header.Name == "Host" {
+			Settings.outputHTTPConfig.OriginalHost = true
+			break
+		}
+	}
+
 	for _, options := range Settings.outputHTTP {
 		registerPlugin(NewHTTPOutput, options, &Settings.outputHTTPConfig)
 	}

proto/proto.go

@@ -1,166 +1,235 @@
-// Low-level interaction with HTTP request payload
+/*
+Package proto provides byte-level interaction with HTTP request payload.
+
+Example of HTTP payload for future references, new line symbols escaped:
+
+	POST /upload HTTP/1.1\r\n
+	User-Agent: Gor\r\n
+	Content-Length: 11\r\n
+	\r\n
+	Hello world
+
+	GET /index.html HTTP/1.1\r\n
+	User-Agent: Gor\r\n
+	\r\n
+	\r\n
+*/
 package proto
 
 import (
-    "bytes"
-    "github.com/buger/gor/byteutils"
-    _ "log"
+	"bytes"
+	"github.com/buger/gor/byteutils"
 )
 
+// In HTTP newline defined by 2 bytes (for both windows and *nix support)
 var CLRF = []byte("\r\n")
-var EMPTY_LINE = []byte("\r\n\r\n")
-var HEADER_DELIM = []byte(": ")
 
-// Headers should end with empty line
+// New line acts as separator: end of Headers or Body (in some cases)
+var EmptyLine = []byte("\r\n\r\n")
+
+// Separator for Header line. Header looks like: `HeaderName: value`
+var HeaderDelim = []byte(": ")
+
+// MIMEHeadersEndPos finds end of the Headers section, which should end with empty line.
 func MIMEHeadersEndPos(payload []byte) int {
-    return bytes.Index(payload, EMPTY_LINE)
+	return bytes.Index(payload, EmptyLine)
 }
 
+// MIMEHeadersStartPos finds start of Headers section
+// It just finds position of second line (first contains location and method).
 func MIMEHeadersStartPos(payload []byte) int {
-    return bytes.Index(payload, CLRF) + 2 // Find first line end
+	return bytes.Index(payload, CLRF) + 2 // Find first line end
 }
 
-// Find header value or return error
-// Do not support multi-line headers
-func Header(payload []byte, name []byte) (value []byte, headerStart, valueStart, headerEnd int) {
-    headerStart = bytes.Index(payload, name)
+// header return value and positions of header/value start/end.
+// If not found, value will be blank, and headerStart will be -1
+// Do not support multi-line headers.
+func header(payload []byte, name []byte) (value []byte, headerStart, valueStart, headerEnd int) {
+	headerStart = bytes.Index(payload, name)
 
-    if headerStart == -1 {
-        return
-    }
+	if headerStart == -1 {
+		return
+	}
 
-    valueStart = headerStart + len(name) + 1 // Skip ":" after header name
-    if payload[valueStart] == ' ' { // Ignore empty space after ':'
-        valueStart += 1
-    }
-    headerEnd = valueStart + bytes.IndexByte(payload[valueStart:], '\r')
-    value = payload[valueStart:headerEnd]
+	valueStart = headerStart + len(name) + 1 // Skip ":" after header name
+	if payload[valueStart] == ' ' {          // Ignore empty space after ':'
+		valueStart++
+	}
 
-    return
+	headerEnd = valueStart + bytes.IndexByte(payload[valueStart:], '\n')
+
+	if payload[headerEnd-1] == '\r' {
+		headerEnd -= 1
+	}
+
+	value = payload[valueStart:headerEnd]
+
+	return
 }
 
-func GetHeader(payload []byte, name string) []byte {
-    val, _, _, _ := Header(payload, []byte(name))
+// Header returns header value, if header not found, value will be blank
+func Header(payload, name []byte) []byte {
+	val, _, _, _ := header(payload, name)
 
-    return val
+	return val
 }
 
+// SetHeader sets header value. If header not found it creates new one.
+// Returns modified request payload
 func SetHeader(payload, name, value []byte) []byte {
-    _, hs, vs, he := Header(payload, name)
+	_, hs, vs, he := header(payload, name)
 
-    // If header found
-    if hs != -1 {
-        return byteutils.Replace(payload, vs, he, value)
-    } else {
-        return AddHeader(payload, name, value)
-    }
+	if hs != -1 {
+		// If header found we just repace its value
+		return byteutils.Replace(payload, vs, he, value)
+	}
+
+	return AddHeader(payload, name, value)
 }
 
+// AddHeader takes http payload and appends new header to the start of headers section
+// Returns modified request payload
 func AddHeader(payload, name, value []byte) []byte {
-    header := make([]byte, len(name) + 2 + len(value) + 2)
-    copy(header[0:], name)
-    copy(header[len(name):], HEADER_DELIM)
-    copy(header[len(name)+2:], value)
-    copy(header[len(header)-2:], CLRF)
+	header := make([]byte, len(name)+2+len(value)+2)
+	copy(header[0:], name)
+	copy(header[len(name):], HeaderDelim)
+	copy(header[len(name)+2:], value)
+	copy(header[len(header)-2:], CLRF)
 
-    mimeStart := MIMEHeadersStartPos(payload)
+	mimeStart := MIMEHeadersStartPos(payload)
 
-    return byteutils.Insert(payload, mimeStart, header)
+	return byteutils.Insert(payload, mimeStart, header)
 }
 
+// Body returns request/response body
+func Body(payload []byte) []byte {
+	// 4 -> len(EMPTY_LINE)
+	return payload[MIMEHeadersEndPos(payload)+4:]
+}
+
+// Path takes payload and retuns request path: Split(firstLine, ' ')[1]
 func Path(payload []byte) []byte {
-    start := bytes.IndexByte(payload, ' ')
-    start += 1
+	start := bytes.IndexByte(payload, ' ') + 1
+	end := bytes.IndexByte(payload[start:], ' ')
 
-    end := bytes.IndexByte(payload[start:], ' ')
-
-    return payload[start:start+end]
+	return payload[start : start+end]
 }
 
+// SetPath takes payload, sets new path and returns modified payload
 func SetPath(payload, path []byte) []byte {
-    start := bytes.IndexByte(payload, ' ')
-    start += 1
+	start := bytes.IndexByte(payload, ' ') + 1
+	end := bytes.IndexByte(payload[start:], ' ')
 
-    end := bytes.IndexByte(payload[start:], ' ')
-
-    return byteutils.Replace(payload, start, start+end, path)
+	return byteutils.Replace(payload, start, start+end, path)
 }
 
+// PathParam returns URL query attribute by given name, if no found: valueStart will be -1
 func PathParam(payload, name []byte) (value []byte, valueStart, valueEnd int) {
-    path := Path(payload)
+	path := Path(payload)
 
-    if paramStart := bytes.Index(path, append(name, '=')); paramStart != -1 {
-        valueStart := paramStart + len(name) + 1
-        paramEnd := bytes.IndexByte(path[valueStart:], '&')
-        if paramEnd == -1 { // It is final param
-            paramEnd = len(path)
-        } else {
-            paramEnd += valueStart
-        }
+	if paramStart := bytes.Index(path, append(name, '=')); paramStart != -1 {
+		valueStart := paramStart + len(name) + 1
+		paramEnd := bytes.IndexByte(path[valueStart:], '&')
 
-        return path[valueStart:paramEnd], valueStart, paramEnd
-    } else {
-        return []byte(""), -1, -1
-    }
+		// Param can end with '&' (another param), or end of line
+		if paramEnd == -1 { // It is final param
+			paramEnd = len(path)
+		} else {
+			paramEnd += valueStart
+		}
+
+		return path[valueStart:paramEnd], valueStart, paramEnd
+	}
+
+	return []byte(""), -1, -1
 }
 
+// SetPathParam takes payload and updates path Query attribute
+// If query param not found, it will append new
+// Returns modified payload
 func SetPathParam(payload, name, value []byte) []byte {
-    path := Path(payload)
-    _, vs, ve := PathParam(payload, name)
+	path := Path(payload)
+	_, vs, ve := PathParam(payload, name)
 
-    if vs != -1 {
-        newPath := make([]byte, len(path))
-        copy(newPath, path)
-        newPath = byteutils.Replace(newPath, vs, ve, value)
+	if vs != -1 { // If param found, replace its value and set new Path
+		newPath := make([]byte, len(path))
+		copy(newPath, path)
+		newPath = byteutils.Replace(newPath, vs, ve, value)
 
-        return SetPath(payload, newPath)
-    } else { // if param not found append to end of url
-        // Adding 2 because of '?' or '&' at start, and '=' in middle
-        newParam := make([]byte, len(name) + len(value) + 2)
+		return SetPath(payload, newPath)
+	}
 
-        if bytes.IndexByte(path, '?') == -1 {
-            newParam[0] = '?'
-        } else {
-            newParam[0] = '&'
-        }
+	// if param not found append to end of url
+	// Adding 2 because of '?' or '&' at start, and '=' in middle
+	newParam := make([]byte, len(name)+len(value)+2)
 
-        copy(newParam[1:], name)
-        newParam[1+len(name)] = '='
-        copy(newParam[2+len(name):], value)
+	if bytes.IndexByte(path, '?') == -1 {
+		newParam[0] = '?'
+	} else {
+		newParam[0] = '&'
+	}
 
-        newPath := make([]byte, len(path) + len(newParam))
-        copy(newPath, path)
-        copy(newPath[len(path):], newParam)
+	// Copy "param=value" into buffer, after it looks like "?param=value"
+	copy(newParam[1:], name)
+	newParam[1+len(name)] = '='
+	copy(newParam[2+len(name):], value)
 
-        return SetPath(payload, newPath)
-    }
+	// Append param to the end of path
+	newPath := make([]byte, len(path)+len(newParam))
+	copy(newPath, path)
+	copy(newPath[len(path):], newParam)
+
+	return SetPath(payload, newPath)
 }
 
+// SetHost updates Host header for HTTP/1.1 or updates host in path for HTTP/1.0 or Proxy requests
+// Returns modified payload
 func SetHost(payload, url, host []byte) []byte {
-    // If this is HTTP 1.0 traffic or proxy traffic it may include host right into path variable, so instead of setting Host header we rewrite Path
-    // Fix for https://github.com/buger/gor/issues/156
-    if path := Path(payload); bytes.HasPrefix(path, []byte("http")) {
-        hostStart := bytes.IndexByte(path, ':') // : position "https?:"
-        hostStart += 3 // Skip 1 ':' and 2 '\'
-        hostEnd := hostStart + bytes.IndexByte(path[hostStart:], '/')
+	// If this is HTTP 1.0 traffic or proxy traffic it may include host right into path variable, so instead of setting Host header we rewrite Path
+	// Fix for https://github.com/buger/gor/issues/156
+	if path := Path(payload); bytes.HasPrefix(path, []byte("http")) {
+		hostStart := bytes.IndexByte(path, ':') // : position "https?:"
+		hostStart += 3                          // Skip 1 ':' and 2 '\'
+		hostEnd := hostStart + bytes.IndexByte(path[hostStart:], '/')
 
-        newPath := make([]byte, len(path))
-        copy(newPath, path)
-        newPath = byteutils.Replace(newPath, 0, hostEnd, url)
+		newPath := make([]byte, len(path))
+		copy(newPath, path)
+		newPath = byteutils.Replace(newPath, 0, hostEnd, url)
 
-        return SetPath(payload, newPath)
-    } else {
-        return SetHeader(payload, []byte("Host"), host)
-    }
+		return SetPath(payload, newPath)
+	}
+
+	return SetHeader(payload, []byte("Host"), host)
 }
 
+// Method returns HTTP method
 func Method(payload []byte) []byte {
-    end := bytes.IndexByte(payload, ' ')
+	end := bytes.IndexByte(payload, ' ')
 
-    return payload[:end]
+	return payload[:end]
 }
 
-// Status in response have same position as Path in request
+// Status returns response status.
+// It happend to be in same position as request payload path
 func Status(payload []byte) []byte {
-    return Path(payload)
-}
+	return Path(payload)
+}
+
+var httpMethods []string = []string{
+	"GET ", "OPTI", "HEAD", "POST", "PUT ", "DELE", "TRAC", "CONN",
+}
+
+func IsHTTPPayload(payload []byte) bool {
+	if len(payload) < 4 {
+		return false
+	}
+
+	method := string(payload[0:4])
+
+	for _, m := range httpMethods {
+		if method == m {
+			return true
+		}
+	}
+	return false
+}

proto/proto_test.go

@@ -1,152 +1,163 @@
 package proto
 
 import (
-    "testing"
-    "bytes"
+	"bytes"
+	"testing"
 )
 
 func TestHeader(t *testing.T) {
-    var payload, val []byte
-    var headerStart int
+	var payload, val []byte
+	var headerStart int
 
-    payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	// Value with space at start
+	payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if val, _, _, _ = Header(payload, []byte("Content-Length")); !bytes.Equal(val, []byte("7")) {
-        t.Error("Should find header value")
-    }
+	if val = Header(payload, []byte("Content-Length")); !bytes.Equal(val, []byte("7")) {
+		t.Error("Should find header value")
+	}
 
-    payload = []byte("POST /post HTTP/1.1\r\nContent-Length:7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	// Value without space at start
+	payload = []byte("POST /post HTTP/1.1\r\nContent-Length:7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if val, _, _, _ = Header(payload, []byte("Content-Length")); !bytes.Equal(val, []byte("7")) {
-        t.Error("Should find header value without space after :")
-    }
+	if val = Header(payload, []byte("Content-Length")); !bytes.Equal(val, []byte("7")) {
+		t.Error("Should find header value without space after :")
+	}
 
-    if _, headerStart, _, _ = Header(payload, []byte("Not-Found")); headerStart != -1  {
-        t.Error("Should not found header")
-    }
+	// Value is empty
+	payload = []byte("GET /p HTTP/1.1\r\nCookie:\r\nHost: www.w3.org\r\n\r\n")
+
+	if val = Header(payload, []byte("Cookie")); len(val) > 0 {
+		t.Error("Should return empty value")
+	}
+
+	// Wrong delimeter
+	payload = []byte("GET /p HTTP/1.1\r\nCookie: 123\nHost: www.w3.org\r\n\r\n")
+
+	if val = Header(payload, []byte("Cookie")); !bytes.Equal(val, []byte("123")) {
+		t.Error("Should handle wrong header delimeter")
+	}
+
+	// Header not found
+	if _, headerStart, _, _ = header(payload, []byte("Not-Found")); headerStart != -1 {
+		t.Error("Should not found header")
+	}
 }
 
 func TestMIMEHeadersEndPos(t *testing.T) {
-    head := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org")
-    payload := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	head := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org")
+	payload := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    end := MIMEHeadersEndPos(payload)
+	end := MIMEHeadersEndPos(payload)
 
-    if !bytes.Equal(payload[:end], head) {
-        t.Error("Wrong headers end position:", end)
-    }
+	if !bytes.Equal(payload[:end], head) {
+		t.Error("Wrong headers end position:", end)
+	}
 }
 
 func TestMIMEHeadersStartPos(t *testing.T) {
-    headers := []byte("Content-Length: 7\r\nHost: www.w3.org")
-    payload := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	headers := []byte("Content-Length: 7\r\nHost: www.w3.org")
+	payload := []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    start := MIMEHeadersStartPos(payload)
-    end := MIMEHeadersEndPos(payload)
+	start := MIMEHeadersStartPos(payload)
+	end := MIMEHeadersEndPos(payload)
 
-    if !bytes.Equal(payload[start:end], headers) {
-        t.Error("Wrong headers end position:", start, end)
-    }
+	if !bytes.Equal(payload[start:end], headers) {
+		t.Error("Wrong headers end position:", start, end)
+	}
 }
 
 func TestSetHeader(t *testing.T) {
-    var payload, payload_after []byte
+	var payload, payloadAfter []byte
 
-    payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST /post HTTP/1.1\r\nContent-Length: 14\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST /post HTTP/1.1\r\nContent-Length: 14\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if payload = SetHeader(payload, []byte("Content-Length"), []byte("14")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should update header if it exists", string(payload))
-    }
+	if payload = SetHeader(payload, []byte("Content-Length"), []byte("14")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should update header if it exists", string(payload))
+	}
 
+	payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST /post HTTP/1.1\r\nUser-Agent: Gor\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST /post HTTP/1.1\r\nUser-Agent: Gor\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-
-    if payload = SetHeader(payload, []byte("User-Agent"), []byte("Gor")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should add header if not found", string(payload))
-    }
+	if payload = SetHeader(payload, []byte("User-Agent"), []byte("Gor")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should add header if not found", string(payload))
+	}
 }
 
 func TestPath(t *testing.T) {
-    var path, payload []byte
+	var path, payload []byte
 
-    payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if path = Path(payload); !bytes.Equal(path, []byte("/post")) {
-        t.Error("Should find path", string(path))
-    }
+	if path = Path(payload); !bytes.Equal(path, []byte("/post")) {
+		t.Error("Should find path", string(path))
+	}
 }
 
 func TestSetPath(t *testing.T) {
-    var payload, payload_after []byte
+	var payload, payloadAfter []byte
 
-    payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST /new_path HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST /new_path HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if payload = SetPath(payload, []byte("/new_path")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should replace path", string(payload))
-    }
+	if payload = SetPath(payload, []byte("/new_path")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should replace path", string(payload))
+	}
 }
 
 func TestPathParam(t *testing.T) {
-    var payload []byte
+	var payload []byte
 
-    payload = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payload = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if val, _, _ := PathParam(payload, []byte("param")); !bytes.Equal(val, []byte("test")) {
-        t.Error("Should detect attribute", string(val))
-    }
+	if val, _, _ := PathParam(payload, []byte("param")); !bytes.Equal(val, []byte("test")) {
+		t.Error("Should detect attribute", string(val))
+	}
 
-    if val, _, _ := PathParam(payload, []byte("user_id")); !bytes.Equal(val, []byte("1")) {
-        t.Error("Should detect attribute", string(val))
-    }
+	if val, _, _ := PathParam(payload, []byte("user_id")); !bytes.Equal(val, []byte("1")) {
+		t.Error("Should detect attribute", string(val))
+	}
 }
 
-
 func TestSetPathParam(t *testing.T) {
-    var payload, payload_after []byte
+	var payload, payloadAfter []byte
 
-    payload = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST /post?param=new&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payload = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST /post?param=new&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if payload = SetPathParam(payload, []byte("param"), []byte("new")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should replace existing value", string(payload))
-    }
+	if payload = SetPathParam(payload, []byte("param"), []byte("new")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should replace existing value", string(payload))
+	}
 
-    payload = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST /post?param=test&user_id=2 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payload = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST /post?param=test&user_id=2 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if payload = SetPathParam(payload, []byte("user_id"), []byte("2")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should replace existing value", string(payload))
-    }
+	if payload = SetPathParam(payload, []byte("user_id"), []byte("2")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should replace existing value", string(payload))
+	}
 
+	payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST /post?param=test HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    payload = []byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST /post?param=test HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	if payload = SetPathParam(payload, []byte("param"), []byte("test")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should set param if url have no params", string(payload))
+	}
 
-    if payload = SetPathParam(payload, []byte("param"), []byte("test")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should set param if url have no params", string(payload))
-    }
+	payload = []byte("POST /post?param=test HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-
-    payload = []byte("POST /post?param=test HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST /post?param=test&user_id=1 HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-
-    if payload = SetPathParam(payload, []byte("user_id"), []byte("1")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should set param at the end if url params", string(payload))
-    }
+	if payload = SetPathParam(payload, []byte("user_id"), []byte("1")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should set param at the end if url params", string(payload))
+	}
 }
 
-
-
 func TestSetHostHTTP10(t *testing.T) {
-    var payload, payload_after []byte
+	var payload, payloadAfter []byte
 
-    payload = []byte("POST http://example.com/post HTTP/1.0\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
-    payload_after = []byte("POST http://new.com/post HTTP/1.0\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payload = []byte("POST http://example.com/post HTTP/1.0\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+	payloadAfter = []byte("POST http://new.com/post HTTP/1.0\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 
-    if payload = SetHost(payload, []byte("http://new.com"), []byte("new.com")); !bytes.Equal(payload, payload_after) {
-        t.Error("Should replace host", string(payload))
-    }
-}
+	if payload = SetHost(payload, []byte("http://new.com"), []byte("new.com")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should replace host", string(payload))
+	}
+}

protocol.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/hex"
+	"strconv"
+)
+
+const (
+	RequestPayload          = '1'
+	ResponsePayload         = '2'
+	ReplayedResponsePayload = '3'
+)
+
+func uuid() []byte {
+	b := make([]byte, 20)
+	rand.Read(b)
+
+	uuid := make([]byte, 40)
+	hex.Encode(uuid, b)
+
+	return uuid
+}
+
+var payloadSeparator = "\n🐵🙈🙉\n"
+
+func payloadScanner(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	if atEOF && len(data) == 0 {
+		return 0, nil, nil
+	}
+
+	if i := bytes.Index(data, []byte(payloadSeparator)); i >= 0 {
+		// We have a full newline-terminated line.
+		return i + len([]byte(payloadSeparator)), data[0:i], nil
+	}
+
+	if atEOF {
+		return len(data), data, nil
+	}
+	return 0, nil, nil
+}
+
+// Timing is request start or round-trip time, depending on payloadType
+func payloadHeader(payloadType byte, uuid []byte, timing int64) (header []byte) {
+	sTime := strconv.FormatInt(timing, 10)
+
+	//Example:
+	//  3 f45590522cd1838b4a0d5c5aab80b77929dea3b3 1231\n
+	// `+ 1` indicates space characters or end of line
+	header = make([]byte, 1+1+len(uuid)+1+len(sTime)+1)
+	header[0] = payloadType
+	header[1] = ' '
+	header[2+len(uuid)] = ' '
+	header[len(header)-1] = '\n'
+
+	copy(header[2:], uuid)
+	copy(header[3+len(uuid):], sTime)
+
+	return header
+}
+
+func payloadBody(payload []byte) []byte {
+	headerSize := bytes.IndexByte(payload, '\n')
+	return payload[headerSize+1:]
+}
+
+func payloadMeta(payload []byte) [][]byte {
+	headerSize := bytes.IndexByte(payload, '\n')
+	if headerSize < 0 {
+		headerSize = 0
+	}
+	return bytes.Split(payload[:headerSize], []byte{' '})
+}
+
+func isOriginPayload(payload []byte) bool {
+	switch payload[0] {
+	case RequestPayload, ResponsePayload:
+		return true
+	default:
+		return false
+	}
+}
+
+func isRequestPayload(payload []byte) bool {
+	return payload[0] == RequestPayload
+}

raw_socket_listener/listener.go

@@ -1,128 +1,289 @@
-package raw_socket
+/*
+Package rawSocket provides traffic sniffier using RAW sockets.
+
+Capture traffic from socket using RAW_SOCKET's
+http://en.wikipedia.org/wiki/Raw_socket
+
+RAW_SOCKET allow you listen for traffic on any port (e.g. sniffing) because they operate on IP level.
+
+Ports is TCP feature, same as flow control, reliable transmission and etc.
+
+This package implements own TCP layer: TCP packets is parsed using tcp_packet.go, and flow control is managed by tcp_message.go
+*/
+package rawSocket
 
 import (
-    "encoding/binary"
-    "log"
-    "net"
-    "strconv"
-    "bytes"
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"runtime"
+	"runtime/debug"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
 )
 
-// Capture traffic from socket using RAW_SOCKET's
-// http://en.wikipedia.org/wiki/Raw_socket
-//
-// RAW_SOCKET allow you listen for traffic on any port (e.g. sniffing) because they operate on IP level.
-// Ports is TCP feature, same as flow control, reliable transmission and etc.
-// Since we can't use default TCP libraries RAWTCPLitener implements own TCP layer
-// TCP packets is parsed using tcp_packet.go, and flow control is managed by tcp_message.go
-type Listener struct {
-    messages map[string]*TCPMessage // buffer of TCPMessages waiting to be send
+var _ = fmt.Println
 
-    // Expect: 100-continue request is send in 2 tcp messages
-    // We store ACK aliases to merge this packets together
-    ack_aliases map[uint32]uint32
-    seq_with_data map[uint32]uint32
-
-    c_packets  chan *TCPPacket
-    c_messages chan *TCPMessage // Messages ready to be send to client
-
-    c_del_message chan *TCPMessage // Used for notifications about completed or expired messages
-
-    addr string // IP to listen
-    port int    // Port to listen
+type wrongCloser interface {
+	Close()
+}
+type wrongCloserProxy struct {
+	w wrongCloser
+}
+func (c wrongCloserProxy) Close() error {
+	c.w.Close()
+	return nil
 }
 
-// RAWTCPListen creates a listener to capture traffic from RAW_SOCKET
-func NewListener(addr string, port string) (rawListener *Listener) {
-    rawListener = &Listener{}
+// Listener handle traffic capture
+type Listener struct {
+	mu sync.Mutex
+	// buffer of TCPMessages waiting to be send
+	// ID -> TCPMessage
+	messages map[tcpID]*TCPMessage
 
-    rawListener.c_packets = make(chan *TCPPacket, 10000)
-    rawListener.c_messages = make(chan *TCPMessage, 10000)
-    rawListener.c_del_message = make(chan *TCPMessage, 10000)
+	// Expect: 100-continue request is send in 2 tcp messages
+	// We store ACK aliases to merge this packets together
+	ackAliases map[uint32]uint32
+	// To get ACK of second message we need to compute its Seq and wait for them message
+	seqWithData map[uint32]uint32
 
-    rawListener.messages = make(map[string]*TCPMessage)
-    rawListener.ack_aliases = make(map[uint32]uint32)
-    rawListener.seq_with_data = make(map[uint32]uint32)
+	// Ack -> Req
+	respAliases map[uint32]*TCPMessage
 
-    rawListener.addr = addr
-    rawListener.port, _ = strconv.Atoi(port)
+	// Ack -> ID
+	respWithoutReq map[uint32]tcpID
 
-    go rawListener.listen()
-    go rawListener.readRAWSocket()
+	// Messages ready to be send to client
+	packetsChan chan []byte
 
-    return
+	// Messages ready to be send to client
+	messagesChan chan *TCPMessage
+
+	addr string // IP to listen
+	port uint16 // Port to listen
+
+	trackResponse bool
+	messageExpire time.Duration
+
+	connHandles []io.Closer
+
+	quit    chan bool
+	readyCh chan bool
+}
+
+type request struct {
+	id    tcpID
+	start time.Time
+	ack   uint32
+}
+
+// Available engines for intercepting traffic
+const (
+	EngineRawSocket = 1 << iota
+	EnginePcap
+)
+
+// NewListener creates and initializes new Listener object
+func NewListener(addr string, port string, engine int, trackResponse bool, expire time.Duration) (l *Listener) {
+	l = &Listener{}
+
+	l.packetsChan = make(chan []byte, 10000)
+	l.messagesChan = make(chan *TCPMessage, 10000)
+	l.quit = make(chan bool)
+	l.readyCh = make(chan bool, 1)
+
+	l.messages = make(map[tcpID]*TCPMessage)
+	l.ackAliases = make(map[uint32]uint32)
+	l.seqWithData = make(map[uint32]uint32)
+	l.respAliases = make(map[uint32]*TCPMessage)
+	l.respWithoutReq = make(map[uint32]tcpID)
+	l.trackResponse = trackResponse
+
+	l.addr = addr
+	_port, _ := strconv.Atoi(port)
+	l.port = uint16(_port)
+
+	if expire.Nanoseconds() == 0 {
+		expire = 2000 * time.Millisecond
+	}
+
+	l.messageExpire = expire
+
+	go l.listen()
+
+	// Special case for testing
+	if l.port != 0 {
+		if runtime.GOOS == "windows" {
+			engine = EngineRawSocket
+		}
+
+		switch engine {
+		case EngineRawSocket:
+			go l.readRAWSocket()
+		case EnginePcap:
+			go l.readPcap()
+		default:
+			log.Fatal("Unknown traffic interception engine:", engine)
+		}
+	}
+
+	return
 }
 
 func (t *Listener) listen() {
-    for {
-        select {
-        // If message ready for deletion it means that its also complete or expired by timeout
-        case message := <-t.c_del_message:
-            t.c_messages <- message
-            delete(t.ack_aliases, message.packets[0].Ack)
-            delete(t.messages, message.ID)
+	gcTicker := time.Tick(t.messageExpire / 2)
 
-        // We need to use channels to process each packet to avoid data races
-        case packet := <-t.c_packets:
-            t.processTCPPacket(packet)
-        }
-    }
+	for {
+		select {
+		case <-t.quit:
+			t.Close()
+			return
+		case data := <-t.packetsChan:
+			packet := ParseTCPPacket(data[:16], data[16:])
+			t.processTCPPacket(packet)
+		case <-gcTicker:
+			now := time.Now()
+
+			// Dispatch requests before responses
+			for _, message := range t.messages {
+				if now.Sub(message.End) >= t.messageExpire {
+					t.dispatchMessage(message)
+				}
+			}
+		}
+	}
+}
+
+func (t *Listener) deleteMessage(message *TCPMessage) {
+	delete(t.messages, message.ID())
+	delete(t.ackAliases, message.Ack)
+	if message.DataAck != 0 {
+		delete(t.ackAliases, message.DataAck)
+	}
+	if message.DataSeq != 0 {
+		delete(t.seqWithData, message.DataSeq)
+	}
+
+	delete(t.respAliases, message.ResponseAck)
+}
+
+func (t *Listener) dispatchMessage(message *TCPMessage) {
+	// If already dispatched
+	if _, ok := t.messages[message.ID()]; !ok {
+		return
+	}
+
+	t.deleteMessage(message)
+
+	// log.Println("Dispatching, message", message.Start.UnixNano(), message.Seq, message.Ack, string(message.Bytes()))
+
+	if message.IsIncoming {
+		// If there were response before request
+		// log.Println("Looking for Response: ", t.respWithoutReq, message.ResponseAck)
+		if t.trackResponse {
+			if respID, ok := t.respWithoutReq[message.ResponseAck]; ok {
+				if resp, rok := t.messages[respID]; rok {
+					// if resp.AssocMessage == nil {
+					// log.Println("FOUND RESPONSE")
+					resp.AssocMessage = message
+					message.AssocMessage = resp
+
+					if resp.IsFinished() {
+						defer t.dispatchMessage(resp)
+					}
+					// }
+				}
+			}
+
+			if resp, ok := t.messages[message.ResponseID]; ok {
+				resp.AssocMessage = message
+			}
+		}
+	} else {
+		if message.AssocMessage == nil {
+			if responseRequest, ok := t.respAliases[message.Ack]; ok {
+				message.AssocMessage = responseRequest
+				responseRequest.AssocMessage = message
+			}
+		}
+
+		delete(t.respAliases, message.Ack)
+		delete(t.respWithoutReq, message.Ack)
+
+		// Do not track responses which have no associated requests
+		if message.AssocMessage == nil {
+			// log.Println("Can't dispatch resp", message.Seq, message.Ack, string(message.Bytes()))
+			return
+		}
+	}
+
+	t.messagesChan <- message
 }
 
 func (t *Listener) readRAWSocket() {
-    conn, e := net.ListenPacket("ip4:tcp", t.addr)
+	conn, e := net.ListenPacket("ip:tcp", t.addr)
+	t.connHandles = append(t.connHandles, conn)
 
-    if e != nil {
-        log.Fatal(e)
-    }
+	if e != nil {
+		log.Fatal(e)
+	}
 
-    defer conn.Close()
+	defer conn.Close()
 
-    buf := make([]byte, 4096*10)
+	buf := make([]byte, 64*1024) // 64kb
 
-    for {
-        // Note: ReadFrom receive messages without IP header
-        n, addr, err := conn.ReadFrom(buf)
+	t.readyCh <- true
 
-        if err != nil {
-            log.Println("Error:", err)
-            continue
-        }
+	for {
+		// Note: ReadFrom receive messages without IP header
+		n, addr, err := conn.ReadFrom(buf)
 
-        if n > 0 {
-            t.parsePacket(addr, buf[:n])
-        }
-    }
+		if err != nil {
+			if strings.HasSuffix(err.Error(), "closed network connection") {
+				return
+			} else {
+				continue
+			}
+		}
+
+		if n > 0 {
+			if t.isValidPacket(buf[:n]) {
+				newBuf := make([]byte, n+16)
+				copy(newBuf[16:], buf[:n])
+				copy(newBuf[:16], []byte(addr.(*net.IPAddr).IP))
+
+				t.packetsChan <- newBuf
+			}
+		}
+	}
 }
 
-func (t *Listener) parsePacket(addr net.Addr, buf []byte) {
-    if t.isIncomingDataPacket(buf) {
-        new_buf := make([]byte, len(buf))
-        copy(new_buf, buf)
+func (t *Listener) isValidPacket(buf []byte) bool {
+	// To avoid full packet parsing every time, we manually parsing values needed for packet filtering
+	// http://en.wikipedia.org/wiki/Transmission_Control_Protocol
+	destPort := binary.BigEndian.Uint16(buf[2:4])
+	srcPort := binary.BigEndian.Uint16(buf[0:2])
 
-        t.c_packets <- ParseTCPPacket(addr, new_buf)
-    }
-}
+	// Because RAW_SOCKET can't be bound to port, we have to control it by ourself
+	if destPort == t.port || (t.trackResponse && srcPort == t.port) {
+		// Get the 'data offset' (size of the TCP header in 32-bit words)
+		dataOffset := (buf[12] & 0xF0) >> 4
 
-func (t *Listener) isIncomingDataPacket(buf []byte) bool {
-    // To avoid full packet parsing every time, we manually parsing values needed for packet filtering
-    // http://en.wikipedia.org/wiki/Transmission_Control_Protocol
-    dest_port := binary.BigEndian.Uint16(buf[2:4])
+		// We need only packets with data inside
+		// Check that the buffer is larger than the size of the TCP header
+		if len(buf) > int(dataOffset*4) {
+			// We should create new buffer because go slices is pointers. So buffer data shoud be immutable.
+			return true
+		}
+	}
 
-    // Because RAW_SOCKET can't be bound to port, we have to control it by ourself
-    if int(dest_port) == t.port {
-        // Get the 'data offset' (size of the TCP header in 32-bit words)
-        dataOffset := (buf[12] & 0xF0) >> 4
-
-        // We need only packets with data inside
-        // Check that the buffer is larger than the size of the TCP header
-        if len(buf) > int(dataOffset*4) {
-            // We should create new buffer because go slices is pointers. So buffer data shoud be immutable.
-            return true
-        }
-    }
-
-    return false
+	return false
 }
 
 var bExpect100ContinueCheck = []byte("Expect: 100-continue")
@@ -132,44 +293,163 @@ var bPOST = []byte("POST")
 //
 // For TCP message unique id is Acknowledgment number (see tcp_packet.go)
 func (t *Listener) processTCPPacket(packet *TCPPacket) {
-    defer func() { recover() }()
+	// Don't exit on panic
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("PANIC: pkg:", r, packet, string(debug.Stack()))
+		}
+	}()
 
-    var message *TCPMessage
+	// log.Println("Processing packet:", packet.Ack, packet.Seq, packet.ID)
 
-    parent_message_ack, parent_ok := t.seq_with_data[packet.Seq]
-    if parent_ok {
-        t.ack_aliases[packet.Ack] = parent_message_ack
-        delete(t.seq_with_data, packet.Seq)
-    }
+	var message *TCPMessage
 
-    ack_alias, alias_ok := t.ack_aliases[packet.Ack]
-    if alias_ok {
-        packet.Ack = ack_alias
-    }
+	isIncoming := packet.DestPort == t.port
 
-    m_id := packet.Addr.String() + strconv.Itoa(int(packet.Ack))
-    message, ok := t.messages[m_id]
+	// Seek for 100-expect chunks
+	if parentAck, ok := t.seqWithData[packet.Seq]; ok {
+		// In case if non-first data chunks comes first
+		for _, m := range t.messages {
+			if m.Ack == packet.Ack && bytes.Equal(m.packets[0].Addr, packet.Addr) {
+				t.deleteMessage(m)
 
-    if !ok {
-        // We sending c_del_message channel, so message object can communicate with Listener and notify it if message completed
-        message = NewTCPMessage(m_id, t.c_del_message)
-        t.messages[m_id] = message
-    }
+				if m.AssocMessage != nil {
+					m.AssocMessage.AssocMessage = nil
+				}
 
-    if bytes.Equal(packet.Data[0:4], bPOST) {
-        if bytes.Equal(packet.Data[len(packet.Data)-24:len(packet.Data)-4], bExpect100ContinueCheck) {
-            t.seq_with_data[packet.Seq + uint32(len(packet.Data))] = packet.Ack
+				for _, pkt := range m.packets {
+					// log.Println("Updating ack", parentAck, pkt.Ack)
+					pkt.UpdateAck(parentAck)
+					// Re-queue this packets
+					t.processTCPPacket(pkt)
+				}
+			}
+		}
 
-            // Removing `Expect: 100-continue` header
-            packet.Data = append(packet.Data[:len(packet.Data)-24], packet.Data[len(packet.Data)-2:]...)
-        }
-    }
+		t.ackAliases[packet.Ack] = parentAck
+		packet.UpdateAck(parentAck)
+	}
 
-    // Adding packet to message
-    message.c_packets <- packet
+	if alias, ok := t.ackAliases[packet.Ack]; ok {
+		packet.UpdateAck(alias)
+	}
+
+	var responseRequest *TCPMessage
+
+	if !isIncoming {
+		responseRequest, _ = t.respAliases[packet.Ack]
+	}
+
+	message, ok := t.messages[packet.ID]
+
+	if !ok {
+		message = NewTCPMessage(packet.Seq, packet.Ack, isIncoming)
+		t.messages[packet.ID] = message
+
+		if !isIncoming {
+			if responseRequest != nil {
+				message.AssocMessage = responseRequest
+				responseRequest.AssocMessage = message
+			} else {
+				t.respWithoutReq[packet.Ack] = packet.ID
+			}
+		}
+	}
+
+	// Adding packet to message
+	message.AddPacket(packet)
+
+	// Handling Expect: 100-continue requests
+	if len(packet.Data) > 4 && bytes.Equal(packet.Data[0:4], bPOST) {
+		// reading last 20 bytes (not counting CRLF): last header value (if no body presented)
+		if bytes.Equal(packet.Data[len(packet.Data)-24:len(packet.Data)-4], bExpect100ContinueCheck) {
+			seq := packet.Seq + uint32(len(packet.Data))
+			t.seqWithData[seq] = packet.Ack
+			message.DataSeq = seq
+
+			// In case if sequence packet came first
+			for _, m := range t.messages {
+				if m.Seq == seq {
+					t.deleteMessage(m)
+					if m.AssocMessage != nil {
+						message.AssocMessage = m.AssocMessage
+					}
+					// log.Println("2: Adding ack alias:", m.Ack, packet.Ack)
+					t.ackAliases[m.Ack] = packet.Ack
+
+					for _, pkt := range m.packets {
+						pkt.UpdateAck(packet.Ack)
+						message.AddPacket(pkt)
+					}
+				}
+			}
+
+			// Removing `Expect: 100-continue` header
+			packet.Data = append(packet.Data[:len(packet.Data)-24], packet.Data[len(packet.Data)-2:]...)
+
+			// log.Println(string(packet.Data))
+		}
+	}
+
+	// log.Println("Received message:", string(message.Bytes()), message.ID(), t.messages)
+
+	if isIncoming {
+		// If message have multiple packets, delete previous alias
+		if len(message.packets) > 1 {
+			delete(t.respAliases, message.ResponseAck)
+		}
+
+		message.UpdateResponseAck()
+		t.respAliases[message.ResponseAck] = message
+	}
+
+	// If message contains only single packet immediately dispatch it
+	if message.IsFinished() {
+		if isIncoming {
+			// log.Println("I'm finished", string(message.Bytes()), message.ResponseID, t.messages)
+			if t.trackResponse {
+				if resp, ok := t.messages[message.ResponseID]; ok {
+					t.dispatchMessage(message)
+					if resp.IsFinished() {
+						t.dispatchMessage(resp)
+					}
+				}
+			} else {
+				t.dispatchMessage(message)
+			}
+		} else {
+			if message.AssocMessage == nil {
+				return
+			}
+
+			if req, ok := t.messages[message.AssocMessage.ID()]; ok {
+				if req.IsFinished() {
+					t.dispatchMessage(req)
+					t.dispatchMessage(message)
+				}
+			}
+		}
+	}
+}
+
+func (t *Listener) IsReady() bool {
+	select {
+	case <-t.readyCh:
+		return true
+	case <-time.After(5 * time.Second):
+		return false
+	}
 }
 
 // Receive TCP messages from the listener channel
-func (t *Listener) Receive() *TCPMessage {
-    return <-t.c_messages
+func (t *Listener) Receiver() chan *TCPMessage {
+	return t.messagesChan
+}
+
+func (t *Listener) Close() {
+	for _, h := range t.connHandles {
+		h.Close()
+	}
+
+	return
 }

raw_socket_listener/listener_libpcap.go

@@ -0,0 +1,196 @@
+// +build !windows
+
+package rawSocket
+
+import (
+    "runtime"
+    "github.com/google/gopacket"
+    "github.com/google/gopacket/layers"
+    "github.com/google/gopacket/pcap"
+    "log"
+    "io"
+    "sync"
+    "strconv"
+    "encoding/binary"
+)
+
+
+// DeviceNotFoundError raised if user specified wrong ip
+type DeviceNotFoundError struct {
+    addr string
+}
+
+func (e *DeviceNotFoundError) Error() string {
+    devices, _ := pcap.FindAllDevs()
+
+    if len(devices) == 0 {
+        return "Can't get list of network interfaces, ensure that you running Gor as root user or sudo.\nTo run as non-root users see this docs https://github.com/buger/gor/wiki/Running-as-non-root-user"
+    }
+
+    var msg string
+    msg += "Can't find interfaces with addr: " + e.addr + ". Provide available IP for intercepting traffic: \n"
+    for _, device := range devices {
+        msg += "Name: " + device.Name + "\n"
+        if device.Description != "" {
+            msg += "Description: " + device.Description + "\n"
+        }
+        for _, address := range device.Addresses {
+            msg += "- IP address: " + address.IP.String() + "\n"
+        }
+    }
+
+    return msg
+}
+
+func findPcapDevices(addr string) (interfaces []pcap.Interface, err error) {
+    devices, err := pcap.FindAllDevs()
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    for _, device := range devices {
+        if (addr == "" || addr == "0.0.0.0" || addr == "[::]" || addr == "::") && len(device.Addresses) > 0 {
+            interfaces = append(interfaces, device)
+            continue
+        }
+
+        for _, address := range device.Addresses {
+            if device.Name == addr || address.IP.String() == addr {
+                interfaces = append(interfaces, device)
+                return interfaces, nil
+            }
+        }
+    }
+
+    if len(interfaces) == 0 {
+        return nil, &DeviceNotFoundError{addr}
+    } else {
+        return interfaces, nil
+    }
+}
+
+func (t *Listener) readPcap() {
+    devices, err := findPcapDevices(t.addr)
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    bpfSupported := true
+    if runtime.GOOS == "darwin" {
+        bpfSupported = false
+    }
+
+    var wg sync.WaitGroup
+    wg.Add(len(devices))
+
+    for _, d := range devices {
+        go func(device pcap.Interface) {
+            handle, err := pcap.OpenLive(device.Name, 65536, true, t.messageExpire)
+            if err != nil {
+                log.Println("Pcap Error while opening device", device.Name, err)
+                wg.Done()
+                return
+            }
+            defer handle.Close()
+
+            t.mu.Lock()
+            t.connHandles = append(t.connHandles, wrongCloserProxy{handle})
+
+            if bpfSupported {
+                var bpf string
+
+                if t.trackResponse {
+                    bpf = "tcp port " + strconv.Itoa(int(t.port))
+                } else {
+                    bpf = "tcp dst port " + strconv.Itoa(int(t.port))
+                }
+                if err := handle.SetBPFFilter(bpf); err != nil {
+                    log.Println("BPF filter error:", err, "Device:", device.Name)
+                    wg.Done()
+                    return
+                }
+            }
+            t.mu.Unlock()
+
+            linkType := handle.LinkType()
+            source := gopacket.NewPacketSource(handle, linkType)
+            source.Lazy = true
+            source.NoCopy = true
+
+            wg.Done()
+
+            var data, srcIP []byte
+
+            for {
+                packet, err := source.NextPacket()
+
+                if err == io.EOF {
+                    break
+                } else if err != nil {
+                    continue
+                }
+
+                if linkType == layers.LinkTypeEthernet {
+                    // Skip ethernet layer, 14 bytes
+                    data = packet.Data()[14:]
+                } else if linkType == layers.LinkTypeNull || linkType == layers.LinkTypeLoop {
+                    data = packet.Data()[4:]
+                }
+
+                version := uint8(data[0]) >> 4
+
+                if version == 4 {
+                    ihl := uint8(data[0]) & 0x0F
+
+                    // Truncated IP info
+                    if len(data) < int(ihl*4) {
+                        continue
+                    }
+
+                    srcIP = data[12:16]
+                    data = data[ihl*4:]
+                } else {
+                    // Truncated IP info
+                    if len(data) < 40 {
+                        continue
+                    }
+
+                    srcIP = data[8:24]
+
+                    data = data[40:]
+                }
+
+                // Truncated TCP info
+                if len(data) < 13 {
+                    continue
+                }
+
+                dataOffset := (data[12] & 0xF0) >> 4
+
+                // We need only packets with data inside
+                // Check that the buffer is larger than the size of the TCP header
+                if len(data) > int(dataOffset*4) {
+                    if !bpfSupported {
+                        destPort := binary.BigEndian.Uint16(data[2:4])
+                        srcPort := binary.BigEndian.Uint16(data[0:2])
+
+                        // log.Println(t.port, destPort, srcPort, packet)
+
+                        if !(destPort == t.port || (t.trackResponse && srcPort == t.port)) {
+                            continue
+                        }
+                    }
+
+                    newBuf := make([]byte, len(data)+16)
+                    copy(newBuf[:16], srcIP)
+                    copy(newBuf[16:], data)
+
+                    t.packetsChan <- newBuf
+                }
+            }
+        }(d)
+    }
+
+    wg.Wait()
+    t.readyCh <- true
+}

raw_socket_listener/listener_test.go

@@ -0,0 +1,453 @@
+package rawSocket
+
+import (
+	"bytes"
+	"log"
+	"math/rand"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+func TestRawListenerInput(t *testing.T) {
+	var req, resp *TCPMessage
+
+	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
+	defer listener.Close()
+
+	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\n\r\n"))
+
+	respAck := reqPacket.Seq + uint32(len(reqPacket.Data))
+	respPacket := buildPacket(false, respAck, reqPacket.Seq+1, []byte("HTTP/1.1 200 OK\r\n\r\n"))
+
+	listener.packetsChan <- reqPacket.Dump()
+	listener.packetsChan <- respPacket.Dump()
+
+	select {
+	case req = <-listener.messagesChan:
+	case <-time.After(time.Millisecond):
+		t.Error("Should return request immediately")
+		return
+	}
+
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
+
+	select {
+	case resp = <-listener.messagesChan:
+	case <-time.After(20 * time.Millisecond):
+		t.Error("Should return response immediately")
+		return
+	}
+
+	if resp.IsIncoming {
+		t.Error("Should be response")
+	}
+}
+
+func TestRawListenerInputWithoutResponse(t *testing.T) {
+	var req *TCPMessage
+
+	listener := NewListener("", "0", EnginePcap, false, 10*time.Millisecond)
+	defer listener.Close()
+
+	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\n\r\n"))
+
+	listener.packetsChan <- reqPacket.Dump()
+
+	select {
+	case req = <-listener.messagesChan:
+	case <-time.After(time.Millisecond):
+		t.Error("Should return request immediately")
+		return
+	}
+
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
+}
+
+func TestRawListenerResponse(t *testing.T) {
+	var req, resp *TCPMessage
+
+	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
+	defer listener.Close()
+
+	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\n\r\n"))
+	respPacket := buildPacket(false, 1+uint32(len(reqPacket.Data)), 2, []byte("HTTP/1.1 200 OK\r\n\r\n"))
+
+	// If response packet comes before request
+	listener.packetsChan <- respPacket.Dump()
+	listener.packetsChan <- reqPacket.Dump()
+
+	select {
+	case req = <-listener.messagesChan:
+	case <-time.After(time.Millisecond):
+		t.Error("Should return respose immediately")
+		return
+	}
+
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
+
+	select {
+	case resp = <-listener.messagesChan:
+	case <-time.After(time.Millisecond):
+		t.Error("Should return response immediately")
+		return
+	}
+
+	if resp.IsIncoming {
+		t.Error("Should be response")
+	}
+
+	if !bytes.Equal(resp.UUID(), req.UUID()) {
+		t.Error("Resp and Req UUID should be equal")
+	}
+}
+
+func TestRawListener100Continue(t *testing.T) {
+	var req, resp *TCPMessage
+
+	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
+	defer listener.Close()
+
+	reqPacket1 := buildPacket(true, 1, 1, []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\nExpect: 100-continue\r\n\r\n"))
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, 2, reqPacket1.Seq+uint32(len(reqPacket1.Data)), []byte("a"))
+	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+1, []byte("b"))
+
+	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n"))
+
+	// panic(int(uint32(len(reqPacket1.Data)) + uint32(len(reqPacket2.Data)) + uint32(len(reqPacket3.Data))))
+	respPacket2 := buildPacket(false, reqPacket3.Seq+1 /* len of data */, 2, []byte("HTTP/1.1 200 OK\r\n"))
+
+	listener.packetsChan <- reqPacket1.Dump()
+	listener.packetsChan <- reqPacket2.Dump()
+	listener.packetsChan <- reqPacket3.Dump()
+
+	listener.packetsChan <- respPacket1.Dump()
+	listener.packetsChan <- respPacket2.Dump()
+
+	select {
+	case req = <-listener.messagesChan:
+		break
+	case <-time.After(11 * time.Millisecond):
+		t.Error("Should return request after expire time")
+		return
+	}
+
+	if !bytes.Equal(req.Bytes(), []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")) {
+		t.Error("Should receive full message", string(req.Bytes()))
+	}
+
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
+
+	select {
+	case resp = <-listener.messagesChan:
+		break
+	case <-time.After(21 * time.Millisecond):
+		t.Error("Should return response after expire time")
+		return
+	}
+
+	if resp.IsIncoming {
+		t.Error("Should be response")
+	}
+
+	if !bytes.Equal(resp.UUID(), req.UUID()) {
+		t.Error("Resp and Req UUID should be equal")
+	}
+}
+
+// Response comes before Request
+func TestRawListener100ContinueWrongOrder(t *testing.T) {
+	var req, resp *TCPMessage
+
+	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
+	defer listener.Close()
+
+	reqPacket1 := buildPacket(true, 1, 1, []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\nExpect: 100-continue\r\n\r\n"))
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, 2, reqPacket1.Seq+uint32(len(reqPacket1.Data)), []byte("a"))
+	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+1, []byte("b"))
+
+	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n"))
+
+	// panic(int(uint32(len(reqPacket1.Data)) + uint32(len(reqPacket2.Data)) + uint32(len(reqPacket3.Data))))
+	respPacket2 := buildPacket(false, reqPacket3.Seq+1 /* len of data */, 2, []byte("HTTP/1.1 200 OK\r\n"))
+
+	listener.packetsChan <- respPacket1.Dump()
+	listener.packetsChan <- respPacket2.Dump()
+
+	listener.packetsChan <- reqPacket1.Dump()
+	listener.packetsChan <- reqPacket2.Dump()
+	listener.packetsChan <- reqPacket3.Dump()
+
+	select {
+	case req = <-listener.messagesChan:
+		break
+	case <-time.After(11 * time.Millisecond):
+		t.Error("Should return response after expire time")
+		return
+	}
+
+	if !bytes.Equal(req.Bytes(), []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")) {
+		t.Error("Should receive full message", string(req.Bytes()))
+	}
+
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
+
+	select {
+	case resp = <-listener.messagesChan:
+		break
+	case <-time.After(21 * time.Millisecond):
+		t.Error("Should return response after expire time")
+		return
+	}
+
+	if resp.IsIncoming {
+		t.Error("Should be response")
+	}
+
+	if !bytes.Equal(resp.UUID(), req.UUID()) {
+		t.Error("Resp and Req UUID should be equal")
+	}
+}
+
+func testChunkedSequence(t *testing.T, listener *Listener, packets ...*TCPPacket) {
+	var r, req, resp *TCPMessage
+
+	for _, p := range packets {
+		listener.packetsChan <- p.Dump()
+	}
+
+	select {
+	case r = <-listener.messagesChan:
+		if r.IsIncoming {
+			req = r
+		} else {
+			resp = r
+		}
+		break
+	case <-time.After(25 * time.Millisecond):
+		t.Error("Should return request after expire time")
+		return
+	}
+	select {
+	case r = <-listener.messagesChan:
+		if r.IsIncoming {
+			if req != nil {
+				t.Error("Request already received", r)
+				return
+			}
+			req = r
+		} else {
+			if resp != nil {
+				t.Error("Response already received", r)
+				return
+			}
+			resp = r
+		}
+		break
+	case <-time.After(25 * time.Millisecond):
+		t.Error("Should return request after expire time")
+		return
+	}
+
+	if !bytes.Equal(req.Bytes(), []byte("POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n1\r\na\r\n1\r\nb\r\n0\r\n\r\n")) {
+		t.Error("Should receive full message", string(req.Bytes()))
+	}
+
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
+
+	if resp.IsIncoming {
+		t.Error("Should be response")
+	}
+
+	if !bytes.Equal(resp.UUID(), req.UUID()) {
+		t.Error("Resp and Req UUID should be equal", string(resp.UUID()), string(req.UUID()))
+	}
+
+	time.Sleep(20 * time.Millisecond)
+
+	if len(listener.packetsChan) != 0 {
+		t.Fatal("packetsChan non empty:", listener.packetsChan)
+	}
+
+	if len(listener.messagesChan) != 0 {
+		t.Fatal("messagesChan non empty:", <-listener.messagesChan)
+	}
+
+	if len(listener.messages) != 0 {
+		t.Fatal("Messages non empty:", listener.messages)
+	}
+
+	if len(listener.ackAliases) != 0 {
+		t.Fatal("ackAliases non empty:", listener.ackAliases)
+	}
+
+	if len(listener.seqWithData) != 0 {
+		t.Fatal("seqWithData non empty:", listener.seqWithData)
+	}
+
+	if len(listener.respAliases) != 0 {
+		t.Fatal("respAliases non empty:", listener.respAliases)
+	}
+
+	if len(listener.respWithoutReq) != 0 {
+		t.Fatal("respWithoutReq non empty:", listener.respWithoutReq)
+	}
+}
+
+func permutation(n int, list []*TCPPacket) []*TCPPacket {
+	if len(list) == 1 {
+		return list
+	}
+
+	k := n % len(list)
+
+	first := []*TCPPacket{list[k]}
+	next := make([]*TCPPacket, len(list)-1)
+
+	copy(next, append(list[:k], list[k+1:]...))
+
+	return append(first, permutation(n/len(list), next)...)
+}
+
+// Response comes before Request
+func TestRawListenerChunkedWrongOrder(t *testing.T) {
+	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
+	defer listener.Close()
+
+	reqPacket1 := buildPacket(true, 1, 1, []byte("POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\nExpect: 100-continue\r\n\r\n"))
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, 2, reqPacket1.Seq+uint32(len(reqPacket1.Data)), []byte("1\r\na\r\n"))
+	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+uint32(len(reqPacket2.Data)), []byte("1\r\nb\r\n"))
+	reqPacket4 := buildPacket(true, 2, reqPacket3.Seq+uint32(len(reqPacket3.Data)), []byte("0\r\n\r\n"))
+
+	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n"))
+
+	// panic(int(uint32(len(reqPacket1.Data)) + uint32(len(reqPacket2.Data)) + uint32(len(reqPacket3.Data))))
+	respPacket2 := buildPacket(false, reqPacket4.Seq+5 /* len of data */, 2, []byte("HTTP/1.1 200 OK\r\n"))
+
+	// Should re-construct message from all possible combinations
+	for i := 0; i < 6*5*4*3*2*1; i++ {
+
+		if i < 54 || i > 57 {
+			continue
+		}
+
+		packets := permutation(i, []*TCPPacket{reqPacket1, reqPacket2, reqPacket3, reqPacket4, respPacket1, respPacket2})
+
+		t.Log("permutation:", i)
+		testChunkedSequence(t, listener, packets...)
+	}
+}
+
+func chunkedPostMessage() []*TCPPacket {
+	ack := uint32(rand.Int63())
+	seq := uint32(rand.Int63())
+
+	reqPacket1 := buildPacket(true, ack, seq, []byte("POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"))
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, ack, seq+47, []byte("1\r\na\r\n"))
+	reqPacket3 := buildPacket(true, ack, reqPacket2.Seq+5, []byte("1\r\nb\r\n"))
+	reqPacket4 := buildPacket(true, ack, reqPacket3.Seq+5, []byte("0\r\n\r\n"))
+
+	respPacket := buildPacket(false, reqPacket4.Seq+5 /* len of data */, ack, []byte("HTTP/1.1 200 OK\r\n"))
+
+	return []*TCPPacket{
+		reqPacket1, reqPacket2, reqPacket3, reqPacket4, respPacket,
+	}
+}
+
+func postMessage() []*TCPPacket {
+	ack := uint32(rand.Int63())
+	seq2 := uint32(rand.Int63())
+	seq := uint32(rand.Int63())
+
+	c := 10000
+	data := make([]byte, c)
+	rand.Read(data)
+
+	head := []byte("POST / HTTP/1.1\r\nContent-Length: 9958\r\n\r\n")
+	for i := range head {
+		data[i] = head[i]
+	}
+
+	return []*TCPPacket{
+		buildPacket(true, ack, seq, data),
+		buildPacket(false, seq+uint32(len(data)), seq2, []byte("HTTP/1.1 200 OK\r\n")),
+	}
+}
+
+func getMessage() []*TCPPacket {
+	ack := uint32(rand.Int63())
+	seq2 := uint32(rand.Int63())
+	seq := uint32(rand.Int63())
+
+	return []*TCPPacket{
+		buildPacket(true, ack, seq, []byte("GET / HTTP/1.1\r\n\r\n")),
+		buildPacket(false, seq+18, seq2, []byte("HTTP/1.1 200 OK\r\n")),
+	}
+}
+
+// Response comes before Request
+func TestRawListenerBench(t *testing.T) {
+	l := NewListener("", "0", EnginePcap, true, 200*time.Millisecond)
+	defer l.Close()
+
+	// Should re-construct message from all possible combinations
+	for i := 0; i < 1000; i++ {
+		go func(i int) {
+			for j := 0; j < 100; j++ {
+				var packets []*TCPPacket
+
+				if j%5 == 0 {
+					packets = chunkedPostMessage()
+				} else if j%3 == 0 {
+					packets = postMessage()
+				} else {
+					packets = getMessage()
+				}
+
+				for _, p := range packets {
+					// Randomly drop packets
+					if (i+j)%5 == 0 {
+						if rand.Int63()%3 == 0 {
+							continue
+						}
+					}
+
+					l.packetsChan <- p.Dump()
+					time.Sleep(time.Millisecond)
+				}
+
+				time.Sleep(5 * time.Millisecond)
+			}
+		}(i)
+	}
+
+	ch := l.Receiver()
+
+	var count int32
+
+	for {
+		select {
+		case <-ch:
+			atomic.AddInt32(&count, 1)
+		case <-time.After(2000 * time.Millisecond):
+			log.Println("Emitted 200000 messages, captured: ", count, len(l.ackAliases), len(l.seqWithData), len(l.respAliases), len(l.respWithoutReq), len(l.packetsChan))
+			return
+		}
+	}
+}

raw_socket_listener/listener_windows.go

@@ -0,0 +1,9 @@
+// +build windows
+
+package rawSocket
+
+func (t *Listener) readPcap() {
+    panic("libpcap not implemented for windows")
+}
+
+

raw_socket_listener/tcp_message.go

@@ -1,12 +1,17 @@
-package raw_socket
+package rawSocket
 
 import (
-    "log"
-    "sort"
-    "time"
+	"bytes"
+	"crypto/sha1"
+	"encoding/binary"
+	"encoding/hex"
+	"github.com/buger/gor/proto"
+	"log"
+	"strconv"
+	"time"
 )
 
-const MSG_EXPIRE = 2000 * time.Millisecond
+var _ = log.Println
 
 // TCPMessage ensure that all TCP packets for given request is received, and processed in right sequence
 // Its needed because all TCP message can be fragmented or re-transmitted
@@ -15,91 +20,250 @@ const MSG_EXPIRE = 2000 * time.Millisecond
 // Message can be compiled from unique packets with same message_id which sorted by sequence
 // Message is received if we didn't receive any packets for 2000ms
 type TCPMessage struct {
-    ID      string // Message ID
-    packets []*TCPPacket
+	Seq         uint32
+	Ack         uint32
+	ResponseAck uint32
+	ResponseID  tcpID
+	DataAck     uint32
+	DataSeq     uint32
 
-    timer *time.Timer // Used for expire check
+	AssocMessage *TCPMessage
+	Start        time.Time
+	End          time.Time
+	IsIncoming   bool
 
-    c_packets chan *TCPPacket
+	packets []*TCPPacket
 
-    c_del_message chan *TCPMessage
+	delChan chan *TCPMessage
 }
 
 // NewTCPMessage pointer created from a Acknowledgment number and a channel of messages readuy to be deleted
-func NewTCPMessage(ID string, c_del chan *TCPMessage) (msg *TCPMessage) {
-    msg = &TCPMessage{ID: ID}
+func NewTCPMessage(Seq, Ack uint32, IsIncoming bool) (msg *TCPMessage) {
+	msg = &TCPMessage{Seq: Seq, Ack: Ack, IsIncoming: IsIncoming}
+	msg.Start = time.Now()
 
-    msg.c_packets = make(chan *TCPPacket)
-    msg.c_del_message = c_del // used for notifying that message completed or expired
-
-    // Every time we receive packet we reset this timer
-    msg.timer = time.AfterFunc(MSG_EXPIRE, msg.Timeout)
-
-    go msg.listen()
-
-    return
+	return
 }
 
-func (t *TCPMessage) listen() {
-    for {
-        select {
-        case packet, more := <-t.c_packets:
-            if more {
-                t.AddPacket(packet)
-            } else {
-                // Stop loop if channel closed
-                return
-            }
-        }
-    }
-}
-
-// Timeout notifies message to stop listening, close channel and message ready to be sent
-func (t *TCPMessage) Timeout() {
-    select {
-        // In some cases Timeout can be called multiple times (do not know how yet)
-        // Ensure that we did not close channel 2 times
-        case packet, ok := <- t.c_packets:
-            if ok {
-                t.AddPacket(packet)
-            } else {
-                return
-            }
-        default:
-            close(t.c_packets)
-            t.c_del_message <- t // Notify RAWListener that message is ready to be send to replay server
-    }
-}
-
-// Bytes sorts packets in right orders and return message content
+// Bytes return message content
 func (t *TCPMessage) Bytes() (output []byte) {
-    sort.Sort(BySeq(t.packets))
+	for _, p := range t.packets {
+		output = append(output, p.Data...)
+	}
 
-    for _, v := range t.packets {
-        output = append(output, v.Data...)
-    }
+	return output
+}
 
-    return output
+// Size returns total body size
+func (t *TCPMessage) BodySize() (size int) {
+	if len(t.packets) == 0 {
+		return 0
+	}
+
+	size += len(proto.Body(t.packets[0].Data))
+
+	for _, p := range t.packets[1:] {
+		size += len(p.Data)
+	}
+
+	return
+}
+
+// Size returns total size of message
+func (t *TCPMessage) Size() (size int) {
+	if len(t.packets) == 0 {
+		return 0
+	}
+
+	for _, p := range t.packets {
+		size += len(p.Data)
+	}
+
+	return
 }
 
 // AddPacket to the message and ensure packet uniqueness
 // TCP allows that packet can be re-send multiple times
 func (t *TCPMessage) AddPacket(packet *TCPPacket) {
-    packetFound := false
+	packetFound := false
 
-    for _, pkt := range t.packets {
-        if packet.Seq == pkt.Seq {
-            packetFound = true
-            break
-        }
-    }
+	for _, pkt := range t.packets {
+		if packet.Seq == pkt.Seq {
+			packetFound = true
+			break
+		}
+	}
 
-    if packetFound {
-        log.Println("Received packet with same sequence")
-    } else {
-        t.packets = append(t.packets, packet)
-    }
+	if !packetFound {
+		// Packets not always captured in same Seq order, and sometimes we need to prepend
+		if len(t.packets) == 0 || packet.Seq > t.packets[len(t.packets)-1].Seq {
+			t.packets = append(t.packets, packet)
+		} else if packet.Seq < t.packets[0].Seq {
+			t.packets = append([]*TCPPacket{packet}, t.packets...)
+			t.Seq = packet.Seq // Message Seq should indicated starting seq
+		} else { // insert somewhere in the middle...
+			for i, p := range t.packets {
+				if packet.Seq < p.Seq {
+					t.packets = append(t.packets[:i], append([]*TCPPacket{packet}, t.packets[i:]...)...)
+					break
+				}
+			}
+		}
 
-    // Reset message timeout timer
-    t.timer.Reset(MSG_EXPIRE)
+		if t.IsIncoming {
+			t.End = time.Now()
+		} else {
+			t.End = time.Now().Add(time.Millisecond)
+		}
+
+		if packet.OrigAck != 0 {
+			t.DataAck = packet.OrigAck
+		}
+	}
+}
+
+// Check if there is missing packet
+func (t *TCPMessage) isSeqMissing() bool {
+	if len(t.packets) == 1 {
+		return false
+	}
+
+	for i, p := range t.packets {
+		// If final packet
+		if len(t.packets) == i + 1 {
+			return false
+		}
+		np := t.packets[i + 1]
+
+		if np.Seq != p.Seq + uint32(len(p.Data)) {
+			return true
+		}
+	}
+
+	return false
+}
+
+var EmptyLine = []byte("\r\n\r\n")
+var ChunkEnd = []byte("0\r\n\r\n")
+
+func (t *TCPMessage) isHeadersReceived() bool {
+	for _, p := range t.packets {
+		if bytes.LastIndex(p.Data, EmptyLine) != -1 {
+			return true
+		}
+	}
+
+	return false
+}
+
+// isMultipart returns true if message contains from multiple tcp packets
+func (t *TCPMessage) IsFinished() bool {
+	payload := t.packets[0].Data
+
+	if len(payload) < 4 {
+		return true
+	}
+
+	m := payload[:4]
+
+	if t.IsIncoming {
+		// If one GET, OPTIONS, or HEAD request
+		if bytes.Equal(m, []byte("GET ")) || bytes.Equal(m, []byte("OPTI")) || bytes.Equal(m, []byte("HEAD")) {
+			if !t.isSeqMissing() && t.isHeadersReceived() {
+				return true
+			} else {
+				return false
+			}
+		} else {
+			// Sometimes header comes after the body :(
+			if bytes.Equal(m, []byte("POST")) || bytes.Equal(m, []byte("PUT ")) || bytes.Equal(m, []byte("PATC")) {
+
+				if t.isHeadersReceived() {
+					if length := proto.Header(payload, []byte("Content-Length")); len(length) > 0 {
+						l, _ := strconv.Atoi(string(length))
+
+						// If content-length equal current body length
+						if l > 0 && l == t.BodySize() {
+							return true
+						}
+					}
+				}
+			}
+		}
+	} else {
+		// Request not found
+		// Can be because response came first or request request was just missing
+		if t.AssocMessage == nil {
+			return false
+		}
+
+		if !bytes.Equal(m, []byte("HTTP")) {
+			return false
+		}
+
+		if length := proto.Header(payload, []byte("Content-Length")); len(length) > 0 {
+			if length[0] == '0' {
+				return true
+			}
+
+			l, _ := strconv.Atoi(string(length))
+
+			// If content-length equal current body length
+			if l > 0 && l == t.BodySize() {
+				return true
+			}
+		} else {
+			if enc := proto.Header(payload, []byte("Transfer-Encoding")); len(enc) == 0 {
+				return true
+			} else {
+				if len(t.packets) > 1 && bytes.LastIndex(t.packets[len(t.packets) - 1].Data, ChunkEnd) != -1 {
+					return true
+				}
+			}
+		}
+	}
+
+	return false
+}
+
+func (t *TCPMessage) UUID() []byte {
+	var key []byte
+
+	if t.IsIncoming {
+		// log.Println("UUID:", t.Ack, t.Start.UnixNano())
+		key = strconv.AppendInt(key, t.Start.UnixNano(), 10)
+		key = strconv.AppendUint(key, uint64(t.Ack), 10)
+	} else {
+		// log.Println("RequestMessage:", t.AssocMessage.Ack, t.AssocMessage.Start.UnixNano())
+		key = strconv.AppendInt(key, t.AssocMessage.Start.UnixNano(), 10)
+		key = strconv.AppendUint(key, uint64(t.AssocMessage.Ack), 10)
+	}
+
+	uuid := make([]byte, 40)
+	sha := sha1.Sum(key)
+	hex.Encode(uuid, sha[:20])
+
+	return uuid
+}
+
+// UpdateResponseAck should be called after packet is added
+func (t *TCPMessage) UpdateResponseAck() uint32 {
+	lastPacket := t.packets[len(t.packets)-1]
+	respAck := lastPacket.Seq + uint32(len(lastPacket.Data))
+
+	if t.ResponseAck != respAck {
+		t.ResponseAck = lastPacket.Seq + uint32(len(lastPacket.Data))
+
+		// We swappwed src and dst port
+		copy(t.ResponseID[:16], lastPacket.Addr)
+		copy(t.ResponseID[16:], lastPacket.Raw[2:4]) // Src port
+		copy(t.ResponseID[18:], lastPacket.Raw[0:2]) // Dest port
+		binary.BigEndian.PutUint32(t.ResponseID[20:24], t.ResponseAck)
+	}
+
+	return t.ResponseAck
+}
+
+func (t *TCPMessage) ID() tcpID {
+	return t.packets[0].ID
 }

raw_socket_listener/tcp_message_test.go

@@ -0,0 +1,191 @@
+package rawSocket
+
+import (
+	"bytes"
+	"encoding/binary"
+	_ "log"
+	"testing"
+)
+
+func buildPacket(isIncoming bool, Ack, Seq uint32, Data []byte) (packet *TCPPacket) {
+	var srcPort, destPort uint16
+
+	// For tests `listening` port is 0
+	if isIncoming {
+		srcPort = 1
+	} else {
+		destPort = 1
+	}
+
+	buf := make([]byte, 16)
+	binary.BigEndian.PutUint16(buf[2:4], destPort)
+	binary.BigEndian.PutUint16(buf[0:2], srcPort)
+	binary.BigEndian.PutUint32(buf[4:8], Seq)
+	binary.BigEndian.PutUint32(buf[8:12], Ack)
+	buf[12] = 64
+	buf = append(buf, Data...)
+
+	packet = ParseTCPPacket([]byte("123"), buf)
+
+	return packet
+}
+
+func buildMessage(p *TCPPacket) *TCPMessage {
+	isIncoming := false
+	if p.SrcPort == 1 {
+		isIncoming = true
+	}
+
+	m := NewTCPMessage(p.Seq, p.Ack, isIncoming)
+	m.AddPacket(p)
+
+	return m
+}
+
+func TestTCPMessagePacketsOrder(t *testing.T) {
+	msg := buildMessage(buildPacket(true, 1, 1, []byte("a")))
+	msg.AddPacket(buildPacket(true, 1, 2, []byte("b")))
+
+	if !bytes.Equal(msg.Bytes(), []byte("ab")) {
+		t.Error("Should contatenate packets in right order")
+	}
+
+	// When first packet have wrong order (Seq)
+	msg = buildMessage(buildPacket(true, 1, 2, []byte("b")))
+	msg.AddPacket(buildPacket(true, 1, 1, []byte("a")))
+
+	if !bytes.Equal(msg.Bytes(), []byte("ab")) {
+		t.Error("Should contatenate packets in right order")
+	}
+
+	// Should ignore packets with same sequence
+	msg = buildMessage(buildPacket(true, 1, 1, []byte("a")))
+	msg.AddPacket(buildPacket(true, 1, 1, []byte("a")))
+
+	if !bytes.Equal(msg.Bytes(), []byte("a")) {
+		t.Error("Should ignore packet with same Seq")
+	}
+}
+
+func TestTCPMessageSize(t *testing.T) {
+	msg := buildMessage(buildPacket(true, 1, 1, []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\na")))
+	msg.AddPacket(buildPacket(true, 1, 2, []byte("b")))
+
+	if msg.BodySize() != 2 {
+		t.Error("Should count only body", msg.BodySize())
+	}
+
+	if msg.Size() != 40 {
+		t.Error("Should count all sizes", msg.Size())
+	}
+}
+
+func TestTCPMessageIsFinished(t *testing.T) {
+	methodsWithoutBodies := []string{"GET", "OPTIONS", "HEAD"}
+
+	for _, m := range methodsWithoutBodies {
+		msg := buildMessage(buildPacket(true, 1, 1, []byte(m+" / HTTP/1.1\r\n\r\n")))
+
+		if !msg.IsFinished() {
+			t.Error(m, " request should be finished")
+		}
+	}
+
+	methodsWithBodies := []string{"POST", "PUT", "PATCH"}
+
+	for _, m := range methodsWithBodies {
+		msg := buildMessage(buildPacket(true, 1, 1, []byte(m+" / HTTP/1.1\r\nContent-Length: 1\r\n\r\na")))
+
+		if !msg.IsFinished() {
+			t.Error(m, " should be finished as body length == content length")
+		}
+
+		msg = buildMessage(buildPacket(true, 1, 1, []byte(m+" / HTTP/1.1\r\nContent-Length: 2\r\n\r\na")))
+
+		if msg.IsFinished() {
+			t.Error(m, " should not be finished as body length != content length")
+		}
+	}
+
+	msg := buildMessage(buildPacket(true, 1, 1, []byte("UNKNOWN / HTTP/1.1\r\n\r\n")))
+	if msg.IsFinished() {
+		t.Error("non http or wrong methods considered as not finished")
+	}
+
+	// Responses
+	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\n\r\n")))
+	msg.AssocMessage = &TCPMessage{}
+	if !msg.IsFinished() {
+		t.Error("Should mark simple response as finished")
+	}
+
+	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\n\r\n")))
+	msg.AssocMessage = nil
+	if msg.IsFinished() {
+		t.Error("Should not mark responses without associated requests")
+	}
+
+	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n")))
+	msg.AssocMessage = &TCPMessage{}
+
+	if msg.IsFinished() {
+		t.Error("Should mark chunked response as non finished")
+	}
+
+	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")))
+	msg.AssocMessage = &TCPMessage{}
+
+	if !msg.IsFinished() {
+		t.Error("Should mark Content-Length: 0 respones as finished")
+	}
+
+	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nContent-Length: 1\r\n\r\na")))
+	msg.AssocMessage = &TCPMessage{}
+
+	if !msg.IsFinished() {
+		t.Error("Should mark valid Content-Length respones as finished")
+	}
+
+	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\na")))
+	msg.AssocMessage = &TCPMessage{}
+
+	if msg.IsFinished() {
+		t.Error("Should not mark not valid Content-Length respones as finished")
+	}
+}
+
+func TestTCPMessageIsSeqMissing(t *testing.T) {
+	p1 := buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\n"))
+	p2 := buildPacket(false, 1, p1.Seq + uint32(len(p1.Data)), []byte("Content-Length: 10\r\n\r\n"))
+	p3 := buildPacket(false, 1, p2.Seq + uint32(len(p2.Data)), []byte("a"))
+
+	msg := buildMessage(p1)
+	if msg.isSeqMissing() {
+		t.Error("Should be complete if have only 1 packet")
+	}
+
+	msg.AddPacket(p3)
+	if !msg.isSeqMissing() {
+		t.Error("Should be incomplete because missing middle component")
+	}
+
+	msg.AddPacket(p2)
+	if msg.isSeqMissing() {
+		t.Error("Should be complete once missing packet added")
+	}
+}
+
+func TestTCPMessageIsHeadersReceived(t *testing.T) {
+	p1 := buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\n"))
+	p2 := buildPacket(false, 1, p1.Seq + uint32(len(p1.Data)), []byte("Content-Length: 10\r\n\r\n"))
+
+	msg := buildMessage(p1)
+	if msg.isHeadersReceived() {
+		t.Error("Should be complete if have only 1 packet")
+	}
+
+	msg.AddPacket(p2)
+	if !msg.isHeadersReceived() {
+		t.Error("Should found double new line: headers received")
+	}
+}

raw_socket_listener/tcp_packet.go

@@ -1,101 +1,116 @@
-package raw_socket
+package rawSocket
 
 import (
-    "encoding/binary"
-    "net"
-    "strconv"
-    "strings"
+	"encoding/binary"
+	"log"
+	"strconv"
+	"strings"
 )
 
+var _ = log.Println
+
 // TCP Flags
 const (
-    TCP_FIN = 1 << iota
-    TCP_SYN
-    TCP_RST
-    TCP_PSH
-    TCP_ACK
-    TCP_URG
-    TCP_ECE
-    TCP_CWR
-    TCP_NS
+	fFIN = 1 << iota
+	fSYN
+	fRST
+	fPSH
+	fACK
+	fURG
+	fECE
+	fCWR
+	fNS
 )
 
-// Simple TCP packet parser
-//
+type tcpID [24]byte
+
+// TCPPacket provides tcp packet parser
 // Packet structure: http://en.wikipedia.org/wiki/Transmission_Control_Protocol
 type TCPPacket struct {
-    SrcPort    uint16
-    DestPort   uint16
-    Seq        uint32
-    Ack        uint32
-    DataOffset uint8
-    Flags      uint16
-    Window     uint16
-    Checksum   uint16
-    Urgent     uint16
+	SrcPort    uint16
+	DestPort   uint16
+	Seq        uint32
+	Ack        uint32
+	OrigAck    uint32
+	DataOffset uint8
 
-    Data []byte
-
-    Addr net.Addr
+	Raw  []byte
+	Data []byte
+	Addr []byte
+	ID   tcpID
 }
 
-func ParseTCPPacket(addr net.Addr, b []byte) (p *TCPPacket) {
-    p = &TCPPacket{Data: b}
-    p.ParseBasic()
-    p.Addr = addr
+// ParseTCPPacket takes address and tcp payload and returns parsed TCPPacket
+func ParseTCPPacket(addr []byte, data []byte) (p *TCPPacket) {
+	p = &TCPPacket{Raw: data}
+	p.ParseBasic()
+	p.Addr = addr
+	p.GenID()
 
-    return p
+	return
 }
 
-// Parse TCP Packet, inspired by: https://github.com/miekg/pcap/blob/master/packet.go
-func (t *TCPPacket) Parse() {
-    t.ParseBasic()
-    t.SrcPort = binary.BigEndian.Uint16(t.Data[0:2])
-    t.DestPort = binary.BigEndian.Uint16(t.Data[2:4])
-    t.Flags = binary.BigEndian.Uint16(t.Data[12:14]) & 0x1FF
-    t.Window = binary.BigEndian.Uint16(t.Data[14:16])
-    t.Checksum = binary.BigEndian.Uint16(t.Data[16:18])
-    t.Urgent = binary.BigEndian.Uint16(t.Data[18:20])
+func (p *TCPPacket) GenID() {
+	copy(p.ID[:16], p.Addr)
+	copy(p.ID[16:], p.Raw[0:2])  // Src port
+	copy(p.ID[18:], p.Raw[2:4])  // Dest port
+	copy(p.ID[20:], p.Raw[8:12]) // Ack
+}
+
+func (p *TCPPacket) UpdateAck(ack uint32) {
+	p.OrigAck = p.Ack
+	p.Ack = ack
+	binary.BigEndian.PutUint32(p.Raw[8:12], ack)
+	p.GenID()
 }
 
 // ParseBasic set of fields
 func (t *TCPPacket) ParseBasic() {
-    t.Seq = binary.BigEndian.Uint32(t.Data[4:8])
-    t.Ack = binary.BigEndian.Uint32(t.Data[8:12])
-    t.DataOffset = (t.Data[12] & 0xF0) >> 4
+	t.DestPort = binary.BigEndian.Uint16(t.Raw[2:4])
+	t.SrcPort = binary.BigEndian.Uint16(t.Raw[0:2])
+	t.Seq = binary.BigEndian.Uint32(t.Raw[4:8])
+	t.Ack = binary.BigEndian.Uint32(t.Raw[8:12])
+	t.DataOffset = (t.Raw[12] & 0xF0) >> 4
 
-    t.Data = t.Data[t.DataOffset*4:]
+	// log.Println("DataOffset:", t.DataOffset, t.DestPort, t.SrcPort, t.Seq, t.Ack)
+
+	t.Data = t.Raw[t.DataOffset*4:]
+}
+
+func (t *TCPPacket) Dump() []byte {
+	buf := make([]byte, len(t.Data)+16+16)
+	copy(buf[:16], t.Addr)
+
+	tcpBuf := buf[16:]
+
+	binary.BigEndian.PutUint16(tcpBuf[2:4], t.DestPort)
+	binary.BigEndian.PutUint16(tcpBuf[0:2], t.SrcPort)
+
+	binary.BigEndian.PutUint32(tcpBuf[4:8], t.Seq)
+	binary.BigEndian.PutUint32(tcpBuf[8:12], t.Ack)
+
+	tcpBuf[12] = 64
+	copy(tcpBuf[16:], t.Data)
+
+	return buf
 }
 
 // String output for a TCP Packet
 func (t *TCPPacket) String() string {
-    return strings.Join([]string{
-        "Source port: " + strconv.Itoa(int(t.SrcPort)),
-        "Dest port:" + strconv.Itoa(int(t.DestPort)),
-        "Sequence:" + strconv.Itoa(int(t.Seq)),
-        "Acknowledgment:" + strconv.Itoa(int(t.Ack)),
-        "Header len:" + strconv.Itoa(int(t.DataOffset)),
+	maxLen := len(t.Data)
+	if maxLen > 200 {
+		maxLen = 200
+	}
 
-        "Flag ns:" + strconv.FormatBool(t.Flags&TCP_NS != 0),
-        "Flag crw:" + strconv.FormatBool(t.Flags&TCP_CWR != 0),
-        "Flag ece:" + strconv.FormatBool(t.Flags&TCP_ECE != 0),
-        "Flag urg:" + strconv.FormatBool(t.Flags&TCP_URG != 0),
-        "Flag ack:" + strconv.FormatBool(t.Flags&TCP_ACK != 0),
-        "Flag psh:" + strconv.FormatBool(t.Flags&TCP_PSH != 0),
-        "Flag rst:" + strconv.FormatBool(t.Flags&TCP_RST != 0),
-        "Flag syn:" + strconv.FormatBool(t.Flags&TCP_SYN != 0),
-        "Flag fin:" + strconv.FormatBool(t.Flags&TCP_FIN != 0),
+	return strings.Join([]string{
+		"Addr: " + string(t.Addr),
+		"Source port: " + strconv.Itoa(int(t.SrcPort)),
+		"Dest port:" + strconv.Itoa(int(t.DestPort)),
+		"Sequence:" + strconv.Itoa(int(t.Seq)),
+		"Acknowledgment:" + strconv.Itoa(int(t.Ack)),
+		"Header len:" + strconv.Itoa(int(t.DataOffset)),
 
-        "Window size:" + strconv.Itoa(int(t.Window)),
-        "Checksum:" + strconv.Itoa(int(t.Checksum)),
-
-        "Data size:" + strconv.Itoa(len(t.Data)),
-        "Data:" + string(t.Data),
-    }, "\n")
+		"Data size:" + strconv.Itoa(len(t.Data)),
+		"Data:" + string(t.Data[:maxLen]),
+	}, "\n")
 }
-
-type BySeq []*TCPPacket
-
-func (a BySeq) Len() int            { return len(a) }
-func (a BySeq) Swap(i, j int)       { a[i], a[j] = a[j], a[i] }
-func (a BySeq) Less(i, j int) bool  { return a[i].Seq < a[j].Seq }

settings.go

@@ -3,35 +3,37 @@ package main
 import (
 	"flag"
 	"fmt"
-	"log"
 	"os"
+	"sync"
+	"time"
 )
 
-const (
-	VERSION = "0.9.7"
-)
+var VERSION string
 
-// Allows to specify multiple flags with same name and collects all values to array
+// MultiOption allows to specify multiple flags with same name and collects all values into array
 type MultiOption []string
 
 func (h *MultiOption) String() string {
 	return fmt.Sprint(*h)
 }
 
+// Set gets called multiple times for each flag with same name
 func (h *MultiOption) Set(value string) error {
 	*h = append(*h, value)
 	return nil
 }
 
+// AppSettings is the struct of main configuration
 type AppSettings struct {
 	verbose bool
-	debug bool
+	debug   bool
 	stats   bool
 
 	splitOutput bool
 
 	inputDummy  MultiOption
 	outputDummy MultiOption
+	outputStdout bool
 
 	inputTCP       MultiOption
 	outputTCP      MultiOption
@@ -40,7 +42,11 @@ type AppSettings struct {
 	inputFile  MultiOption
 	outputFile MultiOption
 
-	inputRAW MultiOption
+	inputRAW              MultiOption
+	inputRAWEngine        string
+	inputRAWTrackResponse bool
+
+	middleware string
 
 	inputHTTP  MultiOption
 	outputHTTP MultiOption
@@ -49,7 +55,8 @@ type AppSettings struct {
 	modifierConfig   HTTPModifierConfig
 }
 
-var Settings AppSettings = AppSettings{}
+// Settings holds Gor configuration
+var Settings AppSettings
 
 func usage() {
 	fmt.Printf("Gor is a simple http traffic replication tool written in Go. Its main goal is to replay traffic from production servers to staging and dev environments.\nProject page: https://github.com/buger/gor\nAuthor: <Leonid Bugaev> leonsbox@gmail.com\nCurrent Version: %s\n\n", VERSION)
@@ -61,13 +68,15 @@ func init() {
 	flag.Usage = usage
 
 	flag.BoolVar(&Settings.verbose, "verbose", false, "Turn on more verbose output")
-	flag.BoolVar(&Settings.debug, "debug", false, "Turn on debug output, shows all itercepted traffic. Works only when with `verbose` flag")
+	flag.BoolVar(&Settings.debug, "debug", false, "Turn on debug output, shows all intercepted traffic. Works only when with `verbose` flag")
 	flag.BoolVar(&Settings.stats, "stats", false, "Turn on queue stats output")
 
 	flag.BoolVar(&Settings.splitOutput, "split-output", false, "By default each output gets same traffic. If set to `true` it splits traffic equally among all outputs.")
 
 	flag.Var(&Settings.inputDummy, "input-dummy", "Used for testing outputs. Emits 'Get /' request every 1s")
-	flag.Var(&Settings.outputDummy, "output-dummy", "Used for testing inputs. Just prints data coming from inputs.")
+	flag.Var(&Settings.outputDummy, "output-dummy", "DEPRECATED: use --output-stdout instead")
+
+	flag.BoolVar(&Settings.outputStdout, "output-stdout", false, "Used for testing inputs. Just prints to console data coming from inputs.")
 
 	flag.Var(&Settings.inputTCP, "input-tcp", "Used for internal communication between Gor instances. Example: \n\t# Receive requests from other Gor instances on 28020 port, and redirect output to staging\n\tgor --input-tcp :28020 --output-http staging.com")
 	flag.Var(&Settings.outputTCP, "output-tcp", "Used for internal communication between Gor instances. Example: \n\t# Listen for requests on 80 port and forward them to other Gor instance on 28020 port\n\tgor --input-raw :80 --output-tcp replay.local:28020")
@@ -78,13 +87,23 @@ func init() {
 
 	flag.Var(&Settings.inputRAW, "input-raw", "Capture traffic from given port (use RAW sockets and require *sudo* access):\n\t# Capture traffic from 8080 port\n\tgor --input-raw :8080 --output-http staging.com")
 
+	flag.BoolVar(&Settings.inputRAWTrackResponse, "input-raw-track-response", false, "If turned on Gor will track responses in addition to requests, and they will be available to middleware and file output.")
+
+	flag.StringVar(&Settings.inputRAWEngine, "input-raw-engine", "libpcap", "Intercept traffic using `libpcap` (default), and `raw_socket`")
+
+	flag.StringVar(&Settings.middleware, "middleware", "", "Used for modifying traffic using external command")
+
 	flag.Var(&Settings.inputHTTP, "input-http", "Read requests from HTTP, should be explicitly sent from your application:\n\t# Listen for http on 9000\n\tgor --input-http :9000 --output-http staging.com")
 
 	flag.Var(&Settings.outputHTTP, "output-http", "Forwards incoming requests to given http address.\n\t# Redirect all incoming requests to staging.com address \n\tgor --input-raw :80 --output-http http://staging.com")
+	flag.IntVar(&Settings.outputHTTPConfig.BufferSize, "output-http-response-buffer", 0, "HTTP response buffer size, all data after this size will be discarded.")
 	flag.IntVar(&Settings.outputHTTPConfig.workers, "output-http-workers", 0, "Gor uses dynamic worker scaling by default.  Enter a number to run a set number of workers.")
 	flag.IntVar(&Settings.outputHTTPConfig.redirectLimit, "output-http-redirects", 0, "Enable how often redirects should be followed.")
+	flag.DurationVar(&Settings.outputHTTPConfig.Timeout, "output-http-timeout", 0, "Specify HTTP request/response timeout. By default 5s. Example: --output-http-timeout 30s")
 
 	flag.BoolVar(&Settings.outputHTTPConfig.stats, "output-http-stats", false, "Report http output queue stats to console every 5 seconds.")
+	flag.BoolVar(&Settings.outputHTTPConfig.OriginalHost, "http-original-host", false, "Normally gor replaces the Host http header with the host supplied with --output-http.  This option disables that behavior, preserving the original Host header.")
+	flag.BoolVar(&Settings.outputHTTPConfig.Debug, "output-http-debug", false, "Enables http debug output.")
 
 	flag.StringVar(&Settings.outputHTTPConfig.elasticSearch, "output-http-elasticsearch", "", "Send request and response stats to ElasticSearch:\n\tgor --input-raw :8080 --output-http staging.com --output-http-elasticsearch 'es_host:api_port/index_name'")
 
@@ -96,10 +115,10 @@ func init() {
 	flag.Var(&Settings.modifierConfig.methods, "http-allow-method", "Whitelist of HTTP methods to replay. Anything else will be dropped:\n\tgor --input-raw :8080 --output-http staging.com --http-allow-method GET --http-allow-method OPTIONS")
 	flag.Var(&Settings.modifierConfig.methods, "output-http-method", "WARNING: `--output-http-method` DEPRECATED, use `--http-allow-method` instead")
 
-	flag.Var(&Settings.modifierConfig.urlRegexp, "http-allow-url", "A regexp to match requests against. Filter get matched agains full url with domain. Anything else will be dropped:\n\t gor --input-raw :8080 --output-http staging.com --http-allow-url ^www.")
+	flag.Var(&Settings.modifierConfig.urlRegexp, "http-allow-url", "A regexp to match requests against. Filter get matched against full url with domain. Anything else will be dropped:\n\t gor --input-raw :8080 --output-http staging.com --http-allow-url ^www.")
 	flag.Var(&Settings.modifierConfig.urlRegexp, "output-http-url-regexp", "WARNING: `--output-http-url-regexp` DEPRECATED, use `--http-allow-url` instead")
 
-	flag.Var(&Settings.modifierConfig.urlNegativeRegexp, "http-diallow-url", "A regexp to match requests against. Filter get matched agains full url with domain. Anything else will be dropped:\n\t gor --input-raw :8080 --output-http staging.com --http-disallow-url ^www.")
+	flag.Var(&Settings.modifierConfig.urlNegativeRegexp, "http-disallow-url", "A regexp to match requests against. Filter get matched against full url with domain. Anything else will be forwarded:\n\t gor --input-raw :8080 --output-http staging.com --http-disallow-url ^www.")
 
 	flag.Var(&Settings.modifierConfig.urlRewrite, "http-rewrite-url", "Rewrite the request url based on a mapping:\n\tgor --input-raw :8080 --output-http staging.com --http-rewrite-url /v1/user/([^\\/]+)/ping:/v2/user/$1/ping")
 	flag.Var(&Settings.modifierConfig.urlRewrite, "output-http-rewrite-url", "WARNING: `--output-http-rewrite-url` DEPRECATED, use `--http-rewrite-url` instead")
@@ -107,15 +126,27 @@ func init() {
 	flag.Var(&Settings.modifierConfig.headerFilters, "http-allow-header", "A regexp to match a specific header against. Requests with non-matching headers will be dropped:\n\t gor --input-raw :8080 --output-http staging.com --http-allow-header api-version:^v1")
 	flag.Var(&Settings.modifierConfig.headerFilters, "output-http-header-filter", "WARNING: `--output-http-header-filter` DEPRECATED, use `--http-allow-header` instead")
 
+	flag.Var(&Settings.modifierConfig.headerFilters, "http-disallow-header", "A regexp to match a specific header against. Requests with matching headers will be dropped:\n\t gor --input-raw :8080 --output-http staging.com --http-disallow-header \"User-Agent: Replayed by Gor\"")
+
 	flag.Var(&Settings.modifierConfig.headerHashFilters, "http-header-limiter", "Takes a fraction of requests, consistently taking or rejecting a request based on the FNV32-1A hash of a specific header:\n\t gor --input-raw :8080 --output-http staging.com --http-header-imiter user-id:25%")
 	flag.Var(&Settings.modifierConfig.headerHashFilters, "output-http-header-hash-filter", "WARNING: `output-http-header-hash-filter` DEPRECATED, use `--http-header-hash-limiter` instead")
 
 	flag.Var(&Settings.modifierConfig.paramHashFilters, "http-param-limiter", "Takes a fraction of requests, consistently taking or rejecting a request based on the FNV32-1A hash of a specific GET param:\n\t gor --input-raw :8080 --output-http staging.com --http-param-limiter user_id:25%")
 }
 
+var previousDebugTime int64
+var debugMutex sync.Mutex
+
+// Debug gets called only if --verbose flag specified
 func Debug(args ...interface{}) {
 	if Settings.verbose {
-		fmt.Print("[DEBUG] ")
-		log.Println(args...)
+		debugMutex.Lock()
+		now := time.Now()
+		diff := float64(now.UnixNano()-previousDebugTime) / 1000000
+		previousDebugTime = now.UnixNano()
+		debugMutex.Unlock()
+
+		fmt.Printf("[DEBUG][PID %d][%d][%fms] ", os.Getpid(), now.UnixNano(), diff)
+		fmt.Println(args...)
 	}
 }

test_input.go

@@ -3,12 +3,15 @@ package main
 import (
 	"crypto/rand"
 	"encoding/base64"
+	"time"
 )
 
+// TestInput used for testing purpose, it allows emitting requests on demand
 type TestInput struct {
 	data chan []byte
 }
 
+// NewTestInput constructor for TestInput
 func NewTestInput() (i *TestInput) {
 	i = new(TestInput)
 	i.data = make(chan []byte, 100)
@@ -18,33 +21,53 @@ func NewTestInput() (i *TestInput) {
 
 func (i *TestInput) Read(data []byte) (int, error) {
 	buf := <-i.data
-	copy(data, buf)
 
-	return len(buf), nil
+	header := payloadHeader(RequestPayload, uuid(), time.Now().UnixNano())
+	copy(data[0:len(header)], header)
+	copy(data[len(header):], buf)
+
+	return len(buf) + len(header), nil
 }
 
+// EmitGET emits GET request without headers
 func (i *TestInput) EmitGET() {
 	i.data <- []byte("GET / HTTP/1.1\r\n\r\n")
 }
 
+// EmitPOST emits POST request with Content-Length
 func (i *TestInput) EmitPOST() {
 	i.data <- []byte("POST /pub/WWW/ HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
 }
 
+// EmitChunkedPOST emits POST request with `Transfer-Encoding: chunked` and chunked body
 func (i *TestInput) EmitChunkedPOST() {
 	i.data <- []byte("POST /pub/WWW/ HTTP/1.1\r\nHost: www.w3.org\r\nTransfer-Encoding: chunked\r\n\r\n4\r\nWiki\r\n5\r\npedia\r\ne\r\n in\r\n\r\nchunks.\r\n0\r\n\r\n")
 }
 
-func (i *TestInput) EmitFile() {
-	size := 1024 * 1024 // 1 MB
+// EmitLargePOST emits POST request with large payload (5mb)
+func (i *TestInput) EmitLargePOST() {
+	size := 5 * 1024 * 1024 // 5 MB
 	rb := make([]byte, size)
 	rand.Read(rb)
 
 	rs := base64.URLEncoding.EncodeToString(rb)
 
-	i.data <- []byte("POST /pub/WWW/ HTTP/1.1\nHost: www.w3.org\r\n\r\n------WebKitFormBoundaryePkpFF7tjBAqx29L\nContent-Disposition: form-data; name=\"uploadedfile\"; filename=\"hello.o\"\nContent-Type: application/x-object\n" + rs + "\r\n\r\n")
+	i.data <- []byte("POST / HTTP/1.1\nHost: www.w3.org\nContent-Length:5242880\r\n\r\n" + rs)
+	Debug("Sent large POST")
 }
 
+// EmitSizedPOST emit a POST with a payload set to a supplied size
+func (i *TestInput) EmitSizedPOST(payloadSize int) {
+	rb := make([]byte, payloadSize)
+	rand.Read(rb)
+
+	rs := base64.URLEncoding.EncodeToString(rb)
+
+	i.data <- []byte("POST / HTTP/1.1\nHost: www.w3.org\nContent-Length:5242880\r\n\r\n" + rs)
+	Debug("Sent large POST")
+}
+
+// EmitOPTIONS emits OPTIONS request, similar to GET
 func (i *TestInput) EmitOPTIONS() {
 	i.data <- []byte("OPTIONS / HTTP/1.1\nHost: www.w3.org\r\n\r\n")
 }

test_output.go

@@ -2,10 +2,12 @@ package main
 
 type writeCallback func(data []byte)
 
+// TestOutput used in testing to intercept any output into callback
 type TestOutput struct {
 	cb writeCallback
 }
 
+// NewTestOutput constructor for TestOutput, accepts callback which get called on each incoming Write
 func NewTestOutput(cb writeCallback) (i *TestOutput) {
 	i = new(TestOutput)
 	i.cb = cb