Merge branch 'master' into pr/406

Treat PATCH as a HTTP verb

.dockerignore

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

.gitignore

@@ -6,9 +6,17 @@
 *.bin
 
 *.gz
+*.zip
 
 *.class
 
 *.test
 .idea
+*.iml
 gor
+
+*.mprof
+
+*.pcap
+
+.DS_Store

.gitmodules

@@ -0,0 +1,15 @@
+[submodule "vendor/github.com/mattbaird/elastigo"]
+	path = vendor/github.com/mattbaird/elastigo
+	url = https://github.com/mattbaird/elastigo
+[submodule "vendor/github.com/araddon/gou"]
+	path = vendor/github.com/araddon/gou
+	url = https://github.com/araddon/gou
+[submodule "vendor/github.com/bitly/go-hostpool"]
+	path = vendor/github.com/bitly/go-hostpool
+	url = https://github.com/bitly/go-hostpool
+[submodule "vendor/github.com/bmizerany/assert"]
+	path = vendor/github.com/bmizerany/assert
+	url = https://github.com/bmizerany/assert
+[submodule "vendor/github.com/google/gopacket"]
+	path = vendor/github.com/google/gopacket
+	url = https://github.com/google/gopacket

.travis.yml

@@ -1,3 +1,6 @@
 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 60s -race"
+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

COMM-LICENSE

@@ -2,7 +2,7 @@ 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 CONTRIBUTED SYSTEMS. 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.
+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 GoReplay LLC. READ IT CAREFULLY BEFORE COMPLETING THE INSTALLATION PROCESS AND USING GOREPLAY 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.
 
 ------------------------------------------------------------------------------
 
@@ -12,21 +12,19 @@ In order to use the Software under this Agreement, you must receive a “Source
 
 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.2 Unlimited Organization License. If you purchased an Organization License (included with the GoReplay 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 concurrently run the software on an unlimited number of Hosts.
 
-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 Contributed Systems.
+1.3 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 GoReplay LLC 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 GoReplay LLC any royalties for your distribution of the Software in accordance with this EULA.
 
-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 Contributed Systems 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 Contributed Systems any royalties for your distribution of the Software in accordance with this EULA.
+1.4 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.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.5 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”).        
 
-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. Contributed Systems 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.
+2. Modifications. GoReplay LLC 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 Contributed Systems; (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 Contributed Systems 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 Contributed Systems; (j) use the Software to develop a product which is competitive with any Contributed Systems 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 Contributed Systems in writing. If your unique Source URL is ever published, Contributed Systems reserves the right to terminate your access without notice.
+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 GoReplay LLC; (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 GoReplay LLC 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 GoReplay LLC; (j) use the Software to develop a product which is competitive with any GoReplay LLC 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 GoReplay LLC in writing. If your unique Source URL is ever published, GoReplay LLC 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.
 
@@ -34,34 +32,34 @@ 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, Contributed Systems 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. 
+4. Ownership. Notwithstanding anything to the contrary contained herein, except for the limited license rights expressly provided herein, GoReplay LLC 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 Contributed Systems). 
+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 GoReplay LLC). 
 
-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.
+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 GoReplay 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 Contributed Systems 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.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 GoReplay LLC 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 Contributed Systems.
+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 GoReplay LLC.
 
-8. Disclaimer of Warranties. The Software is provided "as is," with all faults, defects and errors, and without warranty of any kind. Contributed Systems does not warrant that the Software will be free of bugs, errors, viruses or other defects, and Contributed Systems 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 Contributed Systems to do so. 
-To the maximum extent permitted by applicable law, Contributed Systems 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.
+8. Disclaimer of Warranties. The Software is provided "as is," with all faults, defects and errors, and without warranty of any kind. GoReplay LLC does not warrant that the Software will be free of bugs, errors, viruses or other defects, and GoReplay LLC 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 GoReplay LLC to do so. 
+To the maximum extent permitted by applicable law, GoReplay LLC 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 Contributed Systems 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 Contributed Systems has been advised of the possibility of such damages.
+In no event will GoReplay LLC 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 GoReplay LLC has been advised of the possibility of such damages.
 
-In no event will Contributed Systems' 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.
+In no event will GoReplay LLC 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 Contributed Systems’ entire liability for breach of this Agreement shall be limited, at Contributed Systems’ sole and exclusive discretion, to (a) replacement of any defective software or documentation; or (b) refund of the license fee paid to Contributed Systems, payable in accordance with Contributed Systems' refund policy.
+10. Remedies. Your exclusive remedy and GoReplay LLC’ entire liability for breach of this Agreement shall be limited, at GoReplay LLC’ sole and exclusive discretion, to (a) replacement of any defective software or documentation; or (b) refund of the license fee paid to GoReplay LLC, payable in accordance with GoReplay LLC' refund policy.
 
 11. Acknowledgements.
 
-11.1 Consent to the Use of Data. You agree that Contributed Systems and its affiliates may collect and use technical information gathered as part of the product support services. Contributed Systems may use this information solely to improve products and services and will not disclose this information in a form that personally identifies you.
+11.1 Consent to the Use of Data. You agree that GoReplay LLC and its affiliates may collect and use technical information gathered as part of the product support services. GoReplay LLC 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.
 
@@ -74,13 +72,13 @@ In no event will Contributed Systems' liability exceed the Software license pric
 
 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. Contributed Systems 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.2 Amendment. GoReplay LLC 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 Contributed Systems and any attempted assignment without such consent shall be void.
+13.3 Assignment. You may not assign this Agreement or any of its rights under this Agreement without the prior written consent of GoReplay LLC 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 Contributed Systems 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.5 Indemnification. You agree to defend, indemnify, and hold harmless GoReplay LLC 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. 
 
@@ -92,4 +90,4 @@ In no event will Contributed Systems' liability exceed the Software license pric
 
 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 Contributed Systems for any reason, please direct correspondence to leonsbox@gmail.com
+14. Contact Information. If you have any questions about this EULA, or if you want to contact GoReplay LLC for any reason, please direct correspondence to info@gortool.com

Dockerfile

@@ -10,13 +10,15 @@ 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
 
-RUN wget http://apache-mirror.rbc.ru/pub/apache//commons/io/binaries/commons-io-2.4-bin.tar.gz -P /tmp
-RUN tar xzf /tmp/commons-io-2.4-bin.tar.gz -C /tmp
+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 -u github.com/golang/lint/golint
+RUN wget http://archive.apache.org/dist/commons/io/binaries/commons-io-2.4-bin.tar.gz && tar xzf commons-io-2.4-bin.tar.gz && cd commons-io-2.4 && mv commons-io-2.4.jar /tmp/
+RUN wget http://archive.apache.org/dist/commons/codec/binaries/commons-codec-1.9-bin.tar.gz && tar xzf commons-codec-1.9-bin.tar.gz
+RUN javac -cp commons-io-2.4/commons-io-2.4.jar -cp commons-codec-1.9/commons-codec-1.9.jar ./examples/middleware/echo.java
 RUN go get

LICENSE.txt

@@ -1,9 +1,19 @@
-Copyright (c) Contributed Systems LLC
-
-Sidekiq is an Open Source project licensed under the terms of
+GoReplay 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.
 
-Gor Pro has a commercial-friendly license allowing private forks
-and modifications of Gor.  Please see http://gortool.com/pro/ for
+As a special exception to the GNU Lesser General Public License version 3
+("LGPL3"), the copyright holders of this Library give you permission to
+convey to a third party a Combined Work that links statically or dynamically
+to this Library without providing any Minimal Corresponding Source or
+Minimal Application Code as set out in 4d or providing the installation
+information set out in section 4e, provided that you comply with the other
+provisions of LGPL3 and provided that you meet, for the Application the
+terms and conditions of the license(s) which apply to the Application.
+
+TLDR: You are free to use Gor subpackages like `byteutils` or `proto` in your commercial projects.
+
+
+GoReplay Pro has a commercial-friendly license allowing private forks
+and modifications of GoReplay.  Please see https://goreplay.org/pro.html for
 more detail.  You can find the commercial license terms in COMM-LICENSE.

Makefile

@@ -1,14 +1,28 @@
-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 = 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_null.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 output_file_settings.go output_kafka.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
+PORT = 8000
+FADDR = :8000
+RUN = docker run -v `pwd`:$(SOURCE_PATH) -p 0.0.0.0:$(PORT):$(PORT) -i -t 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)"
+FADDR = ":8000"
 
-release: release-x86 release-x64
+release: release-x64 release-mac
+
+release-bin:
+	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=amd64  -i gor go build -tags netgo $(LDFLAGS)
 
 release-x64:
-	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=amd64 --env CGO_ENABLED=0 -i gor go build -ldflags "-X main.VERSION=$(VERSION)"&& tar -czf gor_$(VERSION)_x64.tar.gz gor && rm gor
+	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=amd64  -i gor go build -tags netgo $(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 -ldflags "-X main.VERSION=$(VERSION)" && tar -czf gor_$(VERSION)_x86.tar.gz gor && rm gor
+	docker run -v `pwd`:$(SOURCE_PATH) -t --env GOOS=linux --env GOARCH=386 -i gor go build -tags netgo $(LDFLAGS) && tar -czf gor_$(VERSION)_x86.tar.gz gor && rm gor
+
+release-mac:
+	go build $(MAC_LDFLAGS) && tar -czf gor_$(VERSION)_mac.tar.gz gor && rm gor
 
 build:
 	docker build -t gor .
@@ -24,10 +38,13 @@ race:
 	$(RUN) go test ./... $(ARGS) -v -race -timeout 15s
 
 test:
-	$(RUN) go test ./... -timeout 10s $(ARGS) -v
+	$(RUN) go test ./. -timeout 60s $(LDFLAGS) $(ARGS)  -v
+
+test_all:
+	$(RUN) go test ./... -timeout 60s $(LDFLAGS) $(ARGS) -v
 
 testone:
-	$(RUN) go test ./... -timeout 4s -run $(TEST) $(ARGS) -v
+	$(RUN) go test ./... -timeout 4s $(LDFLAGS) -run $(TEST) $(ARGS) -v
 
 cover:
 	$(RUN) go test $(ARGS) -race -v -timeout 15s -coverprofile=coverage.out
@@ -40,14 +57,30 @@ vet:
 	$(RUN) go vet
 
 bench:
-	$(RUN) go test -v -run NOT_EXISTING -bench HTTP
+	$(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
 run:
-	$(RUN) go run $(SOURCE) --input-dummy=0 --output-http="http://localhost:9000" --input-raw :9000 --input-http :9000 --verbose --debug --middleware "./examples/middleware/echo.sh"
+	$(RUN) go run $(LDFLAGS) $(SOURCE) --input-dummy=0 --output-http="http://localhost:9000" --input-raw-track-response --input-raw 127.0.0.1:9000 --verbose --debug --middleware "./examples/middleware/echo.sh" --output-file requests.gor
 
 run-2:
-	$(RUN) go run $(SOURCE) --input-file ./fixtures/requests.gor --output-dummy=0
+	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-arg:
+	sudo -E go run $(SOURCE) $(ARGS)
+
+file-server:
+	go run $(SOURCE) file-server $(FADDR)
+
+readpcap:
+	go run $(SOURCE) --input-raw $(FILE) --input-raw-engine pcap_file --output-null
 
 record:
 	$(RUN) go run $(SOURCE) --input-dummy=0 --output-file=requests.gor --verbose --debug

README.md

@@ -1,478 +1,48 @@
-[![GitHub release](https://img.shields.io/github/release/buger/gor.svg?maxAge=2592000)]() [![Build Status](https://travis-ci.org/buger/gor.png?branch=master)](https://travis-ci.org/buger/gor) [![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)
+[![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)
+
+![Go Replay](http://i.imgur.com/ZG2ki5n.png)
+
+## https://goreplay.org/
 
 ## About
 
-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.
+GoReplay is the simplest and safest way to test your app using real traffic before you put it into production.
+
+As your application grows, the effort required to test it also grows exponentially. GoReplay offers you the simple idea of reusing your existing traffic for testing, which makes it incredibly powerful. Our state of art technique allows to analyze and record your application traffic without affecting it. This eliminates the risks that come with putting a third party component in the critical path. 
+
+GoReplay increases your confidence in code deployments, configuration changes and infrastructure changes. Did we mention that no coding is required?
 
 
-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)
 
+Check [latest documentation](http://github.com/buger/gor/wiki).
+
+## Installation
+Download latest binary from https://github.com/buger/gor/releases or [compile by yourself](https://github.com/buger/gor/wiki/Compilation).
+
+## Getting started
+
+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`.
+
+See the our [documentation](https://github.com/buger/gor/wiki/) and [Getting started](https://github.com/buger/gor/wiki/Getting-Started) page for more info. 
+## Newsletter
+Subscribe to our [newsletter](https://www.getdrip.com/forms/89690474/submissions/new) to stay informed about the latest features and changes to Gor project.
+
 
 ## Want to Upgrade?
 
-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](http://gortool.com) for more detail.
+We have created a [GoReplay PRO](https://goreplay.org/pro.html) extension which provides additional features such as support for binary protocols like Thrift or ProtocolBuffers, saving and replaying from cloud storage, TCP sessions replication, etc. The PRO version also includes a commercial-friendly license, dedicated support, and it also allows you to support high-quality open source development. 
 
-Subscribe to the [quarterly newsletter](https://tinyletter.com/gor) to stay informed about the latest features and changes to Gor and its bigger siblings.
 
+## 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](https://github.com/buger/gor/issues) for your problem is also a good idea.
 
-## Examples
-
-### 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
-
-# Replay server (replay.local).
-gor --input-tcp replay.local:28020 --output-http http://staging.com
-```
-
-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.
-
-```
-sudo gor --input-raw :80 --output-http "http://staging.com"
-```
-
-### 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. 
-
-```
-sudo gor --input-http :28019 --output-http "http://staging.com"
-```
-
-Then in your application you should send copy (e.g. like reverse proxy) all incoming requests to Gor http input. 
-
-## Configuration
-
-### Forward to multiple addresses
-
-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 a dynamic pool of workers: it starts with 10 and creates 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 where your replayed environment introduces 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.
-
-### HTTP timeouts
-By default http timeout for both request and response is 5 seconds. You can override it like this:
-```
-gor --input-tcp replay.local:28020 --output-http http://staging.com --output-http-timeout 30s
-```
-
-### Rate limiting
-Rate limiting can be useful if you only want to forward parts of production traffic and not overload your staging environment. There are 2 strategies: dropping random requests or dropping fractions of requests based on Header or URL param value. 
-
-#### Dropping random requests
-Every input and output supports 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
-
-# only forward requests NOT containing User-Agent header value "Replayed by Gor"
-gor --input-raw :8080 --output-http staging.com --http-disallow-header "User-Agent: Replayed by Gor"
-```
-
-#### 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 some basic request rewriting support. For complex logic you can use middleware, see below.
-
-#### 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"
-```
-
-#### Host header
-Host header gets special treatment. By default Host get set to the value specified in --output-http. If you manually set --http-header "Host: anonther.com", Gor will not override Host value.
-
-If you app accepts traffic from multiple domain, and you want to keep original headers, there is specific `--http-original-host` with tells Gor do not touch Host header at all.
-
-### Middleware
-Middleware is a program that accepts request and response payload at STDIN and emits modified requests at STDOUT. You can implement any custom logic like stripping private data, advanced rewriting, support for oAuth and etc.
-
-```
-                   Original request      +--------------+
-+-------------+----------STDIN---------->+              |
-|  Gor input  |                          |  Middleware  |
-+-------------+----------STDIN---------->+              |
-                   Original response     +------+---+---+
-                                                |   ^
-+-------------+    Modified request             v   |
-| Gor output  +<---------STDOUT-----------------+   |
-+-----+-------+                                     |
-      |                                             |
-      |            Replayed response                |
-      +------------------STDIN----------------->----+
-```
-
-Middleware can be written in any language, see `examples/middleware` folder for examples.
-Middleware program should accept the fact that all communication with Gor is asynchronous, there is no guarantee that original request and response messages will come one after each other. Your app should take care of the state if logic depends on original or replayed response, see `examples/middleware/token_modifier.go` as example.
-
-Simple bash echo middleware (returns same request) will look like this:
-```bash
-while read line; do
-  echo $line
-end
-```
-
-Middleware can be enabled using `--middleware` option, by specifying path to executable file:
-```
-gor --input-raw :80 --middleware "/opt/middleware_executable" --output-http "http://staging.server"
-```
-
-#### Communication protocol
-All messages should be hex encoded, new line character specifieds the end of the message, eg. new message per line.
-
-Decoded payload consist of 2 parts: header and HTTP payload, separated by new line character.  
-
-Example request payload:
-
-```
-1 932079936fa4306fc308d67588178d17d823647c 1439818823587396305
-GET /a HTTP/1.1
-Host: 127.0.0.1
-
-```
-
-Example response payload:
-
-```
-2 8e091765ae902fef8a2b7d9dd960e9d52222bd8c 2782013
-HTTP/1.1 200 OK
-Date: Mon, 17 Aug 2015 13:40:23 GMT
-Content-Length: 0
-Content-Type: text/plain; charset=utf-8
-
-```
-
-Header contains request meta information separated by spaces. First value is payload type, possible values: `1` - request, `2` - original response, `3` - replayed response.
-Next goes request id: unique among all requests (sha1 of time and Ack), but remain same for original and replayed response, so you can create associations between request and responses. Third argument varies depending on payload type: for request - start time, for responses - round-trip time.
-
-HTTP payload is unmodified HTTP requests/responses intercepted from network. You can read more about request format [here](http://www.jmarshall.com/easy/http/), [here](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol) and [here](http://www.w3.org/Protocols/rfc2616/rfc2616.html). You can operate with payload as you want, add headers, change path, and etc. Basically you just editing a string, just ensure that it is RCF compliant.
-
-At the end modified (or untouched) request should be emitted back to STDOUT, keeping original header, and hex-encoded. If you want to filter request, just not send it. Emitting responses back is required, even if you did not touch them.
-
-#### Advanced example
-Imagine that you have 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 `examples/middleware/token_modifier.go` and `middleware_test.go#TestTokenMiddleware` as example of described scheme.
-
-### 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-disallow-header=[]: A regexp to match a specific header against. Requests with matching headers will be dropped:
-   gor --input-raw :8080 --output-http staging.com --http-disallow-header "User-Agent: Replayed by Gor"
-  -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-disallow-url=[]: A regexp to match requests against. Filter get matched agains full url with domain. Anything else will be forwarded:
-   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. Remember to include also `--stats`
-  -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. Remember to include also `--stats`
-  -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. Use in combination with the other *-stats flags.
-  -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
-
-### Is there a limit for size of HTTP request when using output-http?
-Due to the fact that Gor can't guarantee interception of all packets, for large payloads > 200kb there is chance of missing some packets and corrupting body. Treat it as a feature and chance to test broken bodies handling :)
-The only way to guarantee delivery is using `--input-http`, but you will miss some features.
-
-### 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://www.thecodingmachine.com/solving-the-too-many-open-files-exception-in-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
+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.
 
 
 ## Contributing
@@ -496,4 +66,8 @@ To achieve the top most performance you should tune the source server system lim
 * [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: leonsbox@gmail.com
+If you are using Gor we are happy add you to the list and share your story, just write to: hello@goreplay.org
+
+## Author
+
+Leonid Bugaev, [@buger](https://twitter.com/buger), https://leonsbox.com

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

@@ -2,9 +2,8 @@ package main
 
 import (
 	"encoding/json"
-	"github.com/buger/elastigo/api"
-	"github.com/buger/elastigo/core"
 	"github.com/buger/gor/proto"
+	"github.com/mattbaird/elastigo/lib"
 	"log"
 	"regexp"
 	"time"
@@ -19,33 +18,34 @@ func (e *ESUriErorr) Error() string {
 type ESPlugin struct {
 	Active  bool
 	ApiPort string
+	eConn   *elastigo.Conn
 	Host    string
 	Index   string
-	indexor *core.BulkIndexer
+	indexor *elastigo.BulkIndexer
 	done    chan bool
 }
 
 type ESRequestResponse struct {
-	ReqUrl               []byte `json:"Req_URL"`
-	ReqMethod            []byte `json:"Req_Method"`
-	ReqUserAgent         []byte `json:"Req_User-Agent"`
-	ReqAcceptLanguage    []byte `json:"Req_Accept-Language,omitempty"`
-	ReqAccept            []byte `json:"Req_Accept,omitempty"`
-	ReqAcceptEncoding    []byte `json:"Req_Accept-Encoding,omitempty"`
-	ReqIfModifiedSince   []byte `json:"Req_If-Modified-Since,omitempty"`
-	ReqConnection        []byte `json:"Req_Connection,omitempty"`
-	ReqCookies           []byte `json:"Req_Cookies,omitempty"`
-	RespStatus           []byte `json:"Resp_Status"`
-	RespStatusCode       []byte `json:"Resp_Status-Code"`
-	RespProto            []byte `json:"Resp_Proto,omitempty"`
-	RespContentLength    []byte `json:"Resp_Content-Length,omitempty"`
-	RespContentType      []byte `json:"Resp_Content-Type,omitempty"`
-	RespTransferEncoding []byte `json:"Resp_Transfer-Encoding,omitempty"`
-	RespContentEncoding  []byte `json:"Resp_Content-Encoding,omitempty"`
-	RespExpires          []byte `json:"Resp_Expires,omitempty"`
-	RespCacheControl     []byte `json:"Resp_Cache-Control,omitempty"`
-	RespVary             []byte `json:"Resp_Vary,omitempty"`
-	RespSetCookie        []byte `json:"Resp_Set-Cookie,omitempty"`
+	ReqURL               string `json:"Req_URL"`
+	ReqMethod            string `json:"Req_Method"`
+	ReqUserAgent         string `json:"Req_User-Agent"`
+	ReqAcceptLanguage    string `json:"Req_Accept-Language,omitempty"`
+	ReqAccept            string `json:"Req_Accept,omitempty"`
+	ReqAcceptEncoding    string `json:"Req_Accept-Encoding,omitempty"`
+	ReqIfModifiedSince   string `json:"Req_If-Modified-Since,omitempty"`
+	ReqConnection        string `json:"Req_Connection,omitempty"`
+	ReqCookies           string `json:"Req_Cookies,omitempty"`
+	RespStatus           string `json:"Resp_Status"`
+	RespStatusCode       string `json:"Resp_Status-Code"`
+	RespProto            string `json:"Resp_Proto,omitempty"`
+	RespContentLength    string `json:"Resp_Content-Length,omitempty"`
+	RespContentType      string `json:"Resp_Content-Type,omitempty"`
+	RespTransferEncoding string `json:"Resp_Transfer-Encoding,omitempty"`
+	RespContentEncoding  string `json:"Resp_Content-Encoding,omitempty"`
+	RespExpires          string `json:"Resp_Expires,omitempty"`
+	RespCacheControl     string `json:"Resp_Cache-Control,omitempty"`
+	RespVary             string `json:"Resp_Vary,omitempty"`
+	RespSetCookie        string `json:"Resp_Set-Cookie,omitempty"`
 	Rtt                  int64  `json:"RTT"`
 	Timestamp            time.Time
 }
@@ -76,24 +76,26 @@ func (p *ESPlugin) Init(URI string) {
 	if err != nil {
 		log.Fatal("Can't initialize ElasticSearch plugin.", err)
 	}
+	p.eConn = elastigo.NewConn()
+	p.eConn.SetPort(p.ApiPort)
+	p.eConn.SetHosts([]string{p.Host})
 
-	api.Domain = p.Host
-	api.Port = p.ApiPort
-
-	p.indexor = core.NewBulkIndexerErrors(50, 60)
+	p.indexor = p.eConn.NewBulkIndexerErrors(50, 60)
 	p.done = make(chan bool)
-	p.indexor.Run(p.done)
+	p.indexor.Start()
 
-	// Only start the ErrorHandler goroutine when in verbose mode
-	// no need to burn ressources otherwise
-	// go p.ErrorHandler()
+	if Settings.verbose {
+		// Only start the ErrorHandler goroutine when in verbose mode
+		// no need to burn ressources otherwise
+		go p.ErrorHandler()
+	}
 
 	log.Println("Initialized Elasticsearch Plugin")
 	return
 }
 
 func (p *ESPlugin) IndexerShutdown() {
-	p.done <- true
+	p.indexor.Stop()
 	return
 }
 
@@ -118,28 +120,29 @@ func (p *ESPlugin) ResponseAnalyze(req, resp []byte, start, stop time.Time) {
 	}
 	t := time.Now()
 	rtt := p.RttDurationToMs(stop.Sub(start))
+	req = payloadBody(req)
 
 	esResp := ESRequestResponse{
-		ReqUrl:               proto.Path(req),
-		ReqMethod:            proto.Method(req),
-		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.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")),
+		ReqURL:               string(proto.Path(req)),
+		ReqMethod:            string(proto.Method(req)),
+		ReqUserAgent:         string(proto.Header(req, []byte("User-Agent"))),
+		ReqAcceptLanguage:    string(proto.Header(req, []byte("Accept-Language"))),
+		ReqAccept:            string(proto.Header(req, []byte("Accept"))),
+		ReqAcceptEncoding:    string(proto.Header(req, []byte("Accept-Encoding"))),
+		ReqIfModifiedSince:   string(proto.Header(req, []byte("If-Modified-Since"))),
+		ReqConnection:        string(proto.Header(req, []byte("Connection"))),
+		ReqCookies:           string(proto.Header(req, []byte("Cookie"))),
+		RespStatus:           string(proto.Status(resp)),
+		RespStatusCode:       string(proto.Status(resp)),
+		RespProto:            string(proto.Method(resp)),
+		RespContentLength:    string(proto.Header(resp, []byte("Content-Length"))),
+		RespContentType:      string(proto.Header(resp, []byte("Content-Type"))),
+		RespTransferEncoding: string(proto.Header(resp, []byte("Transfer-Encoding"))),
+		RespContentEncoding:  string(proto.Header(resp, []byte("Content-Encoding"))),
+		RespExpires:          string(proto.Header(resp, []byte("Expires"))),
+		RespCacheControl:     string(proto.Header(resp, []byte("Cache-Control"))),
+		RespVary:             string(proto.Header(resp, []byte("Vary"))),
+		RespSetCookie:        string(proto.Header(resp, []byte("Set-Cookie"))),
 		Rtt:                  rtt,
 		Timestamp:            t,
 	}
@@ -147,7 +150,7 @@ func (p *ESPlugin) ResponseAnalyze(req, resp []byte, start, stop time.Time) {
 	if err != nil {
 		log.Println(err)
 	} else {
-		p.indexor.Index(p.Index, "RequestResponse", "", "", &t, j, true)
+		p.indexor.Index(p.Index, "RequestResponse", "", "", "", &t, j)
 	}
 	return
 }

emitter.go

@@ -15,7 +15,7 @@ func Start(stop chan int) {
 			middleware.ReadFrom(in)
 		}
 
-		// We going only to read responses, so using same ReadFrom method
+		// We are 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)
@@ -32,8 +32,9 @@ func Start(stop chan int) {
 	for {
 		select {
 		case <-stop:
+			finalize()
 			return
-		case <-time.After(time.Second):
+		case <-time.After(100 * time.Millisecond):
 		}
 	}
 }
@@ -43,12 +44,18 @@ func CopyMulty(src io.Reader, writers ...io.Writer) (err error) {
 	buf := make([]byte, 5*1024*1024)
 	wIndex := 0
 	modifier := NewHTTPModifier(&Settings.modifierConfig)
+	filteredRequests := make(map[string]time.Time)
+	filteredRequestsLastCleanTime := time.Now()
+
+	i := 0
 
 	for {
 		nr, er := src.Read(buf)
 
 		if nr > 0 && len(buf) > nr {
 			payload := buf[:nr]
+			meta := payloadMeta(payload)
+			requestID := string(meta[1])
 
 			_maxN := nr
 			if nr > 500 {
@@ -59,23 +66,31 @@ func CopyMulty(src io.Reader, writers ...io.Writer) (err error) {
 				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 != nil {
+				if 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 modifier tells to skip request
+					if len(body) == 0 {
+						filteredRequests[requestID] = time.Now()
+						continue
+					}
 
-				if originalBodyLen != len(body) {
-					payload = append(payload[:headSize], body...)
-				}
+					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.debug {
+						Debug("[EMITTER] Rewritten input:", len(payload), "First 500 bytes:", string(payload[0:_maxN]))
+					}
+				} else {
+					if _, ok := filteredRequests[requestID]; ok {
+						delete(filteredRequests, requestID);
+						continue
+					}
 				}
 			}
 
@@ -102,6 +117,23 @@ func CopyMulty(src io.Reader, writers ...io.Writer) (err error) {
 			err = er
 			break
 		}
+
+		// Run GC on each 1000 request
+		if i % 1000 == 0 {
+			// Clean up filtered requests for which we didn't get a response to filter
+			now := time.Now()
+			if now.Sub(filteredRequestsLastCleanTime) > 60 * time.Second {
+				for k, v := range filteredRequests {
+					if now.Sub(v) > 60 * time.Second {
+						delete(filteredRequests, k)
+					}
+				}
+				filteredRequestsLastCleanTime = time.Now()
+			}
+		}
+
+		i++
 	}
+
 	return err
 }

emitter_test.go

@@ -5,6 +5,7 @@ import (
 	"sync"
 	"sync/atomic"
 	"testing"
+	"time"
 )
 
 func TestEmitter(t *testing.T) {
@@ -31,6 +32,51 @@ func TestEmitter(t *testing.T) {
 	close(quit)
 }
 
+func TestEmitterFiltered(t *testing.T) {
+	wg := new(sync.WaitGroup)
+	quit := make(chan int)
+
+	input := NewTestInput()
+	input.skipHeader = true
+
+	output := NewTestOutput(func(data []byte) {
+		wg.Done()
+	})
+
+	Plugins.Inputs = []io.Reader{input}
+	Plugins.Outputs = []io.Writer{output}
+	methods := HTTPMethods{[]byte("GET")}
+	Settings.modifierConfig = HTTPModifierConfig{methods: methods}
+
+	go Start(quit)
+
+	wg.Add(2)
+
+	id := uuid()
+	reqh := payloadHeader(RequestPayload, id, time.Now().UnixNano(), -1)
+	reqb := 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, id, time.Now().UnixNano()+1, 1)
+	respb := append(resh, []byte("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")...)
+
+	input.EmitBytes(reqb)
+	input.EmitBytes(respb)
+
+	id = uuid()
+	reqh = payloadHeader(RequestPayload, id, time.Now().UnixNano(), -1)
+	reqb = append(reqh, []byte("POST / 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, id, time.Now().UnixNano()+1, 1)
+	respb = append(resh, []byte("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")...)
+
+	input.EmitBytes(reqb)
+	input.EmitBytes(respb)
+
+	wg.Wait()
+
+	close(quit)
+}
+
 func TestEmitterRoundRobin(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)

examples/middleware/echo.clj

@@ -0,0 +1,53 @@
+(ns echo.core
+  (:gen-class)
+  (:require [clojure.string :as cs]
+            [clojure.java.io :as io])
+  (:import org.apache.commons.codec.binary.Hex
+           java.io.BufferedReader
+           java.io.IOException
+           java.io.InputStreamReader))
+
+
+(defn transform-http-msg
+  "Function that transforms/filters the incoming HTTP messages."
+  [headers body]
+  ;; do actual transformations here
+  [headers body])
+
+
+(defn decode-hex-string
+  "Decode an Hex-encoded string."
+  [s]
+  (String. (Hex/decodeHex (.toCharArray s))))
+
+
+(defn encode-hex-string
+  "Encode a string to a hex-encoded string."
+  [^String s]
+  (String. (Hex/encodeHex (.getBytes s))))
+
+
+(defn -main
+  [& args]
+  (let [br (BufferedReader. (InputStreamReader. System/in))]
+    (try
+      (loop [hex-line (.readLine br)]
+        (let [decoded-req (decode-hex-string hex-line)
+
+              ;; empty line separates headers from body
+              http-request (partition-by empty? (cs/split-lines decoded-req))
+              headers (first http-request)
+
+              ;; HTTP messages can contain no body:
+              body (when (= 3 (count http-request)) (last http-request))
+              [new-headers new-body] (transform-http-msg headers body)]
+
+          (println (encode-hex-string (str (cs/join "\n" headers)
+                                           (when body
+                                             (str "\n\n"
+                                                  (cs/join "\n" body)))))))
+        (when-let [line (.readLine br)]
+          (recur line)))
+      (catch IOException e nil))))
+
+

examples/middleware/echo.java

@@ -2,10 +2,25 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 
-import org.apache.commons.io.IOUtils;
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
 
-public class echo {
-    public static void main(String[] args) {
+
+class Echo {
+    public static String decodeHexString(String s) throws DecoderException {
+        return new String(Hex.decodeHex(s.toCharArray()));
+    }
+
+    public static String encodeHexString(String s) {
+        return new String(Hex.encodeHex(s.getBytes()));
+    }
+
+    public static String transformHTTPMessage(String req) {
+        // do actual transformations here
+        return req;
+    }
+
+    public static void main(String[] args) throws DecoderException {
         if(args != null){
             for(String arg : args){
                 System.out.println(arg);
@@ -14,17 +29,20 @@ public class echo {
         }
 
         BufferedReader stdin = new BufferedReader(new InputStreamReader(
-                System.in));
+                                                                        System.in));
         String line = null;
 
         try {
             while ((line = stdin.readLine()) != null) {
+                String decodedLine = decodeHexString(line);
 
-                System.out.println(line);
+                String transformedLine = transformHTTPMessage(decodedLine);
+
+                String encodedLine = encodeHexString(transformedLine);
+                System.out.println(encodedLine);
 
             }
         } catch (IOException e) {
-            IOUtils.closeQuietly(stdin);
         }
     }
-}
+}

examples/middleware/echo.rb

@@ -1,15 +1,22 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
-while data = STDIN.gets
+while data = STDIN.gets # continiously read line from STDIN
   next unless data
-  data = data.chomp
-
-  decoded = [data].pack("H*")
-  encoded = decoded.unpack("H*").first
-
+  data = data.chomp # remove end of line symbol
+  
+  decoded = [data].pack("H*") # decode base64 encoded request
+  
+  # dedoded value is raw HTTP payload, example:
+  #   
+  #   POST /post HTTP/1.1
+  #   Content-Length: 7
+  #   Host: www.w3.org
+  #
+  #   a=1&b=2"
+  
+  encoded = decoded.unpack("H*").first # encoding back to base64
+  
+  # Emit request back
+  # You can skip this if want to filter out request
   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

@@ -2,6 +2,10 @@
 #
 # `xxd` utility included into vim-common package
 # It allow hex decoding/encoding
+# 
+# This example may broke if you request contains `null` string, you may consider using pipes instead.
+# See: https://github.com/buger/gor/issues/309
+# 
 
 function log {
     # Logging to stderr, because stdout/stdin used for data transfer

examples/middleware/token_modifier.go

@@ -45,7 +45,7 @@ func main() {
 		buf := make([]byte, len(encoded)/2)
 		hex.Decode(buf, encoded)
 
-		go process(buf)
+		process(buf)
 	}
 }
 

gor.go

@@ -5,11 +5,16 @@ package main
 import (
 	"flag"
 	"fmt"
+	"io"
 	"log"
+	"net/http"
+	"net/http/httputil"
 	"os"
+	"os/signal"
 	"runtime"
 	_ "runtime/debug"
 	"runtime/pprof"
+	"syscall"
 	"time"
 )
 
@@ -19,6 +24,14 @@ var (
 	memprofile = flag.String("memprofile", "", "write memory profile to this file")
 )
 
+func loggingMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rb, _ := httputil.DumpRequest(r, false)
+		log.Println(string(rb))
+		next.ServeHTTP(w, r)
+	})
+}
+
 func main() {
 	// // Don't exit on panic
 	// defer func() {
@@ -32,10 +45,22 @@ func main() {
 		runtime.GOMAXPROCS(runtime.NumCPU() * 2)
 	}
 
-	fmt.Println("Version:", VERSION)
+	args := os.Args[1:]
+	if len(args) > 0 && args[0] == "file-server" {
+		if len(args) != 2 {
+			log.Fatal("You should specify port and IP (optional) for the file server. Example: `gor file-server :80`")
+		}
+		dir, _ := os.Getwd()
 
-	flag.Parse()
-	InitPlugins()
+		log.Println("Started example file server for current dirrectory on address ", args[1])
+
+		log.Fatal(http.ListenAndServe(args[1], loggingMiddleware(http.FileServer(http.Dir(dir)))))
+	} else {
+		flag.Parse()
+		InitPlugins()
+	}
+
+	fmt.Println("Version:", VERSION)
 
 	if len(Plugins.Inputs) == 0 || len(Plugins.Outputs) == 0 {
 		log.Fatal("Required at least 1 input and 1 output")
@@ -49,7 +74,35 @@ func main() {
 		profileCPU(*cpuprofile)
 	}
 
-	Start(nil)
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		finalize()
+		os.Exit(1)
+	}()
+
+	if Settings.exitAfter > 0 {
+		log.Println("Running gor for a duration of", Settings.exitAfter)
+		closeCh := make(chan int)
+
+		time.AfterFunc(Settings.exitAfter, func() {
+			log.Println("Stopping gor after", Settings.exitAfter)
+			close(closeCh)
+		})
+
+		Start(closeCh)
+	} else {
+		Start(nil)
+	}
+}
+
+func finalize() {
+	for _, p := range Plugins.All {
+		if cp, ok := p.(io.Closer); ok {
+			cp.Close()
+		}
+	}
 }
 
 func profileCPU(cpuprofile string) {

homebrew/gor.rb

@@ -0,0 +1,46 @@
+require "language/go"
+
+class Gor < Formula
+  desc "Real-time HTTP traffic replay tool written in Go"
+  homepage "https://gortool.com"
+  url "https://github.com/buger/gor/archive/v0.14.0.tar.gz"
+  sha256 "62260a6f5cabde571b91d5762fba9c47691643df0a58565cbe808854cd064dc8"
+  head "https://github.com/buger/gor.git"
+
+  bottle do
+    cellar :any_skip_relocation
+    sha256 "c382403de70a41b7445920a02051f5e82030704aaaae70cfcd4e8f401cc87f6a" => :el_capitan
+    sha256 "4b76b3785584897800e87967f1af9510208faefe46f57d7bd6f8b40a7133c19b" => :yosemite
+    sha256 "d186cb1566d33ab8f78215e69934f49dd96becb1c236905b4502d94399ae1974" => :mavericks
+  end
+
+  depends_on "go" => :build
+
+  go_resource "github.com/bitly/go-hostpool" do
+    url "https://github.com/bitly/go-hostpool.git",
+      :revision => "d0e59c22a56e8dadfed24f74f452cea5a52722d2"
+  end
+
+  go_resource "github.com/buger/elastigo" do
+    url "https://github.com/buger/elastigo.git",
+      :revision => "23fcfd9db0d8be2189a98fdab77a4c90fcc3a1e9"
+  end
+
+  go_resource "github.com/google/gopacket" do
+    url "https://github.com/google/gopacket.git",
+      :revision => "aa09ced736460d76535444c825932a0742975f7d"
+  end
+
+  def install
+    ENV["GOPATH"] = buildpath
+    mkdir_p buildpath/"src/github.com/buger/"
+    ln_sf buildpath, buildpath/"src/github.com/buger/gor"
+    Language::Go.stage_deps resources, buildpath/"src"
+
+    system "go", "build", "-o", "#{bin}/gor", "-ldflags", "-X main.VERSION \"#{version}\""
+  end
+
+  test do
+    assert_match version.to_s, shell_output("#{bin}/gor", 1)
+  end
+end

http_client.go

@@ -1,17 +1,32 @@
 package main
 
 import (
+	"bytes"
 	"crypto/tls"
-	"github.com/buger/gor/proto"
+	"encoding/base64"
 	"io"
 	"log"
 	"net"
 	"net/url"
 	"runtime/debug"
+	"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",
@@ -30,6 +45,7 @@ type HTTPClient struct {
 	baseURL        string
 	scheme         string
 	host           string
+	auth           string
 	conn           net.Conn
 	respBuf        []byte
 	config         *HTTPClientConfig
@@ -42,15 +58,12 @@ func NewHTTPClient(baseURL string, config *HTTPClientConfig) *HTTPClient {
 	}
 
 	u, _ := url.Parse(baseURL)
-	if !strings.Contains(u.Host, ":") {
-		if u.Scheme != "http" {
-			u.Host += ":" + defaultPorts[u.Scheme]
-		}
-	}
 
-	if config.Timeout.Nanoseconds() == 0 {
-		config.Timeout = 5 * time.Second
-	}
+	if config.Timeout == 0 {
+		config.Timeout = time.Second
+    }
+
+	config.ConnectionTimeout = config.Timeout
 
 	if config.ResponseBufferSize == 0 {
 		config.ResponseBufferSize = 100 * 1024 // 100kb
@@ -63,6 +76,10 @@ func NewHTTPClient(baseURL string, config *HTTPClientConfig) *HTTPClient {
 	client.respBuf = make([]byte, config.ResponseBufferSize)
 	client.config = config
 
+	if u.User != nil {
+		client.auth = "Basic " + base64.StdEncoding.EncodeToString([]byte(u.User.String()))
+	}
+
 	return client
 }
 
@@ -70,13 +87,13 @@ func (c *HTTPClient) Connect() (err error) {
 	c.Disconnect()
 
 	if !strings.Contains(c.host, ":") {
-		c.conn, err = net.DialTimeout("tcp", c.host+":80", c.config.ConnectionTimeout)
+		c.conn, err = net.DialTimeout("tcp", c.host + ":" + defaultPorts[c.scheme], 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})
+		tlsConn := tls.Client(c.conn, &tls.Config{InsecureSkipVerify: true, ServerName: c.host})
 
 		if err = tlsConn.Handshake(); err != nil {
 			return
@@ -101,7 +118,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
 	}
 
@@ -138,6 +165,10 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 		data = proto.SetHost(data, []byte(c.baseURL), []byte(c.host))
 	}
 
+	if c.auth != "" {
+		data = proto.SetHeader(data, []byte("Authorization"), []byte(c.auth))
+	}
+
 	if c.config.Debug {
 		Debug("[HTTPClient] Sending:", string(data))
 	}
@@ -148,26 +179,126 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 		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
 
-	// If response large then our buffer, we need to read all response buffer
-	// Otherwise it will corrupt response of next request
-	// Parsing response body is non trivial thing, especially with keep-alive
-	// Simples case is to to close connection if response too large
-	//
-	// See https://github.com/buger/gor/issues/184
-	if n == len(c.respBuf) {
-		c.Disconnect()
+	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 {
+						status, _ := strconv.Atoi(string(proto.Status(c.respBuf)))
+						if (status >= 100 && status < 200) || status == 204 || status == 304 {
+							contentLength = 0
+						} 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))
@@ -191,6 +322,11 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 		}
 	}
 
+	if bytes.Equal(proto.Status(payload), []byte("400")) {
+		c.Disconnect()
+		Debug("[HTTPClient] Closed connection on 400 response")
+	}
+
 	c.redirectsCount = 0
 
 	return payload, err
@@ -202,6 +338,14 @@ func (c *HTTPClient) Get(path string) (response []byte, err error) {
 	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"

http_client_test.go

@@ -11,10 +11,10 @@ import (
 	"net/http/httptest"
 	"net/http/httputil"
 	_ "reflect"
+	"strings"
 	"sync"
 	"testing"
 	"time"
-	_ "time"
 )
 
 func TestHTTPClientURLPort(t *testing.T) {
@@ -24,8 +24,8 @@ func TestHTTPClientURLPort(t *testing.T) {
 	}
 
 	c2 := NewHTTPClient("https://example.com", &HTTPClientConfig{})
-	if c2.baseURL != "https://example.com:443" {
-		t.Error("Sould add 443 port for https:", c2.baseURL)
+	if c2.baseURL != "https://example.com" {
+		t.Error("Sould not add 443 port for https:", c2.baseURL)
 	}
 
 	c3 := NewHTTPClient("https://example.com:1", &HTTPClientConfig{})
@@ -88,37 +88,102 @@ func TestHTTPClientSend(t *testing.T) {
 	wg.Wait()
 }
 
-// https://github.com/buger/gor/issues/184
-func TestHTTPClientResponseBuffer(t *testing.T) {
+func TestHTTPClientResonseByClose(t *testing.T) {
 	wg := new(sync.WaitGroup)
 
 	payload := []byte("GET / HTTP/1.1\r\n\r\n")
+	ln, _ := net.Listen("tcp", ":0")
+	go func() {
+		for {
+			conn, _ := ln.Accept()
+			buf := make([]byte, 4096)
+			conn.Read(buf)
 
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			conn.Write([]byte("HTTP/1.1 200 OK\r\n\r\n"))
+			conn.Write([]byte("ab"))
+			conn.Close()
 
-		size := 10 * 1024 // 10kb
-		rb := make([]byte, size)
-		rand.Read(rb)
+			wg.Done()
+		}
+	}()
 
-		w.Write(rb)
+	client := NewHTTPClient(ln.Addr().String(), &HTTPClientConfig{Debug: true})
 
-		wg.Done()
-	}))
-	defer server.Close()
-
-	client := NewHTTPClient(server.URL, &HTTPClientConfig{Debug: false, ResponseBufferSize: 1024})
-
-	wg.Add(2)
-	client.Send(payload)
+	wg.Add(1)
 	resp, _ := client.Send(payload)
 
-	if !bytes.Equal(resp[0:8], []byte("HTTP/1.1")) {
-		t.Error("Response buffer contains data from previous request", string(resp[0:5]))
+	if !bytes.Equal(resp, []byte("HTTP/1.1 200 OK\r\n\r\nab")) {
+		t.Error("Should return valid response", string(resp))
 	}
 
 	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)
 
@@ -292,6 +357,45 @@ func TestHTTPClientRedirectLimit(t *testing.T) {
 	wg.Wait()
 }
 
+func TestHTTPClientBasicAuth(t *testing.T) {
+	wg := new(sync.WaitGroup)
+	wg.Add(2)
+
+	GETPayload := []byte("GET / HTTP/1.1\r\n\r\n")
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		user, pass, _ := r.BasicAuth()
+
+		if user != "user" || pass != "pass" {
+			http.Error(w, "Unauthorized.", 401)
+			wg.Done()
+			return
+		}
+
+		wg.Done()
+	}))
+	defer server.Close()
+
+	client := NewHTTPClient(server.URL, &HTTPClientConfig{Debug: false})
+	resp, _ := client.Send(GETPayload)
+	client.Disconnect()
+
+	if !bytes.Equal(proto.Status(resp), []byte("401")) {
+		t.Error("Should return unauthorized error", string(resp))
+	}
+
+	authUrl := strings.Replace(server.URL, "http://", "http://user:pass@", -1)
+	client = NewHTTPClient(authUrl, &HTTPClientConfig{Debug: false})
+	resp, _ = client.Send(GETPayload)
+	client.Disconnect()
+
+	if !bytes.Equal(proto.Status(resp), []byte("200")) {
+		t.Error("Should return proper response", string(resp))
+	}
+
+	wg.Wait()
+}
+
 func TestHTTPClientHandleHTTP10(t *testing.T) {
 	wg := new(sync.WaitGroup)
 
@@ -377,24 +481,4 @@ func TestHTTPClientErrors(t *testing.T) {
 	} else {
 		t.Error("Should throw error")
 	}
-
-	ln2, _ := net.Listen("tcp", "127.0.0.1:0")
-	go func() {
-		buf := make([]byte, 64*1024)
-		conn, _ := ln2.Accept()
-
-		conn.Read(buf)
-		defer conn.Close()
-	}()
-	defer ln2.Close()
-
-	client = NewHTTPClient("http://"+ln2.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")
-	}
 }

input_dummy.go

@@ -34,10 +34,10 @@ func (i *DummyInput) emit() {
 		select {
 		case <-ticker.C:
 			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")...)
+			reqh := payloadHeader(RequestPayload, uuid, time.Now().UnixNano(), -1)
+			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)
+			resh := payloadHeader(ResponsePayload, uuid, time.Now().UnixNano()+1, 1)
 			i.data <- append(resh, []byte("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")...)
 		}
 	}

input_file.go

@@ -2,41 +2,158 @@ package main
 
 import (
 	"bufio"
+	"bytes"
+	"compress/gzip"
+	"errors"
+	"io"
 	"log"
 	"os"
+	"path/filepath"
 	"strconv"
+	"strings"
+	"sync"
 	"time"
 )
 
+type fileInputReader struct {
+	reader    *bufio.Reader
+	data      []byte
+	file      *os.File
+	timestamp int64
+}
+
+func (f *fileInputReader) parseNext() error {
+	payloadSeparatorAsBytes := []byte(payloadSeparator)
+	var buffer bytes.Buffer
+
+	for {
+		line, err := f.reader.ReadBytes('\n')
+
+		if err != nil {
+			if err != io.EOF {
+				log.Println(err)
+				return err
+			}
+
+			if err == io.EOF {
+				f.file.Close()
+				f.file = nil
+				return err
+			}
+		}
+
+		if bytes.Equal(payloadSeparatorAsBytes[1:], line) {
+			asBytes := buffer.Bytes()
+			meta := payloadMeta(asBytes)
+
+			f.timestamp, _ = strconv.ParseInt(string(meta[2]), 10, 64)
+			f.data = asBytes[:len(asBytes)-1]
+
+			return nil
+		}
+
+		buffer.Write(line)
+	}
+
+	return nil
+}
+
+func (f *fileInputReader) ReadPayload() []byte {
+	defer f.parseNext()
+
+	return f.data
+}
+func (f *fileInputReader) Close() error {
+	if f.file != nil {
+		f.file.Close()
+	}
+
+	return nil
+}
+
+func NewFileInputReader(path string) *fileInputReader {
+	file, err := os.Open(path)
+
+	if err != nil {
+		log.Println(err)
+		return nil
+	}
+
+	r := &fileInputReader{file: file}
+	if strings.HasSuffix(path, ".gz") {
+		gzReader, err := gzip.NewReader(file)
+		if err != nil {
+			log.Println(err)
+			return nil
+		}
+		r.reader = bufio.NewReader(gzReader)
+	} else {
+		r.reader = bufio.NewReader(file)
+	}
+
+	r.parseNext()
+
+	return r
+}
+
 // FileInput can read requests generated by FileOutput
 type FileInput struct {
+	mu          sync.Mutex
 	data        chan []byte
+	exit        chan bool
 	path        string
-	file        *os.File
+	readers     []*fileInputReader
 	speedFactor float64
+	loop        bool
 }
 
 // NewFileInput constructor for FileInput. Accepts file path as argument.
-func NewFileInput(path string) (i *FileInput) {
+func NewFileInput(path string, loop bool) (i *FileInput) {
 	i = new(FileInput)
-	i.data = make(chan []byte)
+	i.data = make(chan []byte, 1000)
+	i.exit = make(chan bool, 1)
 	i.path = path
 	i.speedFactor = 1
-	i.init(path)
+	i.loop = loop
+
+	if err := i.init(); err != nil {
+		return
+	}
 
 	go i.emit()
 
 	return
 }
 
-func (i *FileInput) init(path string) {
-	file, err := os.Open(path)
+type NextFileNotFound struct{}
 
-	if err != nil {
-		log.Fatal(i, "Cannot open file %q. Error: %s", path, err)
+func (_ *NextFileNotFound) Error() string {
+	return "There is no new files"
+}
+
+func (i *FileInput) init() (err error) {
+	defer i.mu.Unlock()
+	i.mu.Lock()
+
+	var matches []string
+
+	if matches, err = filepath.Glob(i.path); err != nil {
+		log.Println("Wrong file pattern", i.path, err)
+		return
 	}
 
-	i.file = file
+	if len(matches) == 0 {
+		log.Println("No files match pattern: ", i.path)
+		return errors.New("No matching files")
+	}
+
+	i.readers = make([]*fileInputReader, len(matches))
+
+	for idx, p := range matches {
+		i.readers[idx] = NewFileInputReader(p)
+	}
+
+	return nil
 }
 
 func (i *FileInput) Read(data []byte) (int, error) {
@@ -50,39 +167,72 @@ func (i *FileInput) String() string {
 	return "File input: " + i.path
 }
 
-func (i *FileInput) emit() {
-	var lastTime int64
-
-	// reader := bufio.NewReader(conn)
-	scanner := bufio.NewScanner(i.file)
-	scanner.Split(payloadScanner)
-
-	for scanner.Scan() {
-		buf := scanner.Bytes()
-		meta := payloadMeta(buf)
-
-		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
+// Find reader with smallest timestamp e.g next payload in row
+func (i *FileInput) nextReader() (next *fileInputReader) {
+	for _, r := range i.readers {
+		if r == nil || r.file == nil {
+			continue
 		}
 
-		// scanner returs only pointer, so to remove data-race we have to allocate new array
-		newBuf := make([]byte, len(buf))
-		copy(newBuf, buf)
-
-		i.data <- newBuf
+		if next == nil || r.timestamp < next.timestamp {
+			next = r
+			continue
+		}
 	}
 
-	log.Println("FileInput: end of file")
+	return
+}
+
+func (i *FileInput) emit() {
+	var lastTime int64 = -1
+
+	for {
+		select {
+		case <-i.exit:
+			return
+		default:
+		}
+
+		reader := i.nextReader()
+
+		if reader == nil {
+			if i.loop {
+				i.init()
+				lastTime = -1
+				continue
+			} else {
+				break
+			}
+		}
+
+		if lastTime != -1 {
+			diff := reader.timestamp - lastTime
+			lastTime = reader.timestamp
+
+			if i.speedFactor != 1 {
+				diff = int64(float64(diff) / i.speedFactor)
+			}
+
+			time.Sleep(time.Duration(diff))
+		} else {
+			lastTime = reader.timestamp
+		}
+
+		i.data <- reader.ReadPayload()
+	}
+
+	log.Printf("FileInput: end of file '%s'\n", i.path)
+}
+
+func (i *FileInput) Close() error {
+	defer i.mu.Unlock()
+	i.mu.Lock()
+
+	i.exit <- true
+
+	for _, r := range i.readers {
+		r.Close()
+	}
+
+	return nil
 }

input_file_test.go

@@ -0,0 +1,382 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"math/rand"
+	"os"
+	"sync"
+	"syscall"
+	"testing"
+	"time"
+)
+
+var _ = log.Println
+
+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")
+		}
+	}
+
+}
+
+func TestInputFileMultipleFilesWithRequestsOnly(t *testing.T) {
+	rnd := rand.Int63()
+
+	file1, _ := os.OpenFile(fmt.Sprintf("/tmp/%d_0", rnd), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
+	file1.Write([]byte("1 1 1\ntest1"))
+	file1.Write([]byte(payloadSeparator))
+	file1.Write([]byte("1 1 3\ntest2"))
+	file1.Write([]byte(payloadSeparator))
+	file1.Close()
+
+	file2, _ := os.OpenFile(fmt.Sprintf("/tmp/%d_1", rnd), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
+	file2.Write([]byte("1 1 2\ntest3"))
+	file2.Write([]byte(payloadSeparator))
+	file2.Write([]byte("1 1 4\ntest4"))
+	file2.Write([]byte(payloadSeparator))
+	file2.Close()
+
+	input := NewFileInput(fmt.Sprintf("/tmp/%d*", rnd), false)
+	buf := make([]byte, 1000)
+
+	for i := '1'; i <= '4'; i++ {
+		n, _ := input.Read(buf)
+		if buf[4] != byte(i) {
+			t.Error("Should emit requests in right order", string(buf[:n]))
+		}
+	}
+
+	os.Remove(file1.Name())
+	os.Remove(file2.Name())
+}
+
+func TestInputFileRequestsWithLatency(t *testing.T) {
+	rnd := rand.Int63()
+
+	file, _ := os.OpenFile(fmt.Sprintf("/tmp/%d", rnd), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
+	defer file.Close()
+
+	file.Write([]byte("1 1 100000000\nrequest1"))
+	file.Write([]byte(payloadSeparator))
+	file.Write([]byte("1 2 150000000\nrequest2"))
+	file.Write([]byte(payloadSeparator))
+	file.Write([]byte("1 3 250000000\nrequest3"))
+	file.Write([]byte(payloadSeparator))
+
+	input := NewFileInput(fmt.Sprintf("/tmp/%d", rnd), false)
+	buf := make([]byte, 1000)
+
+	start := time.Now().UnixNano()
+	for i := 0; i < 3; i++ {
+		input.Read(buf)
+	}
+	end := time.Now().UnixNano()
+
+	var expectedLatency int64 = 250000000 - 100000000
+	realLatency := end - start
+	if realLatency < expectedLatency {
+		t.Errorf("Should emit requests respecting latency. Expected: %v, real: %v", expectedLatency, realLatency)
+	}
+
+	if realLatency > expectedLatency+10000000 {
+		t.Errorf("Should emit requests respecting latency. Expected: %v, real: %v", expectedLatency, realLatency)
+
+	}
+}
+
+func TestInputFileMultipleFilesWithRequestsAndResponses(t *testing.T) {
+	rnd := rand.Int63()
+
+	file1, _ := os.OpenFile(fmt.Sprintf("/tmp/%d_0", rnd), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
+	file1.Write([]byte("1 1 1\nrequest1"))
+	file1.Write([]byte(payloadSeparator))
+	file1.Write([]byte("2 1 1\nresponse1"))
+	file1.Write([]byte(payloadSeparator))
+	file1.Write([]byte("1 2 3\nrequest2"))
+	file1.Write([]byte(payloadSeparator))
+	file1.Write([]byte("2 2 3\nresponse2"))
+	file1.Write([]byte(payloadSeparator))
+	file1.Close()
+
+	file2, _ := os.OpenFile(fmt.Sprintf("/tmp/%d_1", rnd), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
+	file2.Write([]byte("1 3 2\nrequest3"))
+	file2.Write([]byte(payloadSeparator))
+	file2.Write([]byte("2 3 2\nresponse3"))
+	file2.Write([]byte(payloadSeparator))
+	file2.Write([]byte("1 4 4\nrequest4"))
+	file2.Write([]byte(payloadSeparator))
+	file2.Write([]byte("2 4 4\nresponse4"))
+	file2.Write([]byte(payloadSeparator))
+	file2.Close()
+
+	input := NewFileInput(fmt.Sprintf("/tmp/%d*", rnd), false)
+	buf := make([]byte, 1000)
+
+	for i := '1'; i <= '4'; i++ {
+		n, _ := input.Read(buf)
+		if buf[0] != '1' && buf[4] != byte(i) {
+			t.Error("Shound emit requests in right order", string(buf[:n]))
+		}
+
+		n, _ = input.Read(buf)
+		if buf[0] != '2' && buf[4] != byte(i) {
+			t.Error("Shound emit responses in right order", string(buf[:n]))
+		}
+	}
+
+	os.Remove(file1.Name())
+	os.Remove(file2.Name())
+}
+
+func TestInputFileLoop(t *testing.T) {
+	rnd := rand.Int63()
+
+	file, _ := os.OpenFile(fmt.Sprintf("/tmp/%d", rnd), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
+	file.Write([]byte("1 1 1\ntest1"))
+	file.Write([]byte(payloadSeparator))
+	file.Write([]byte("1 1 2\ntest2"))
+	file.Write([]byte(payloadSeparator))
+	file.Close()
+
+	input := NewFileInput(fmt.Sprintf("/tmp/%d", rnd), true)
+	buf := make([]byte, 1000)
+
+	// Even if we have just 2 requests in file, it should indifinitly loop
+	for i := 0; i < 1000; i++ {
+		input.Read(buf)
+	}
+
+	input.Close()
+	os.Remove(file.Name())
+}
+
+func TestInputFileCompressed(t *testing.T) {
+	rnd := rand.Int63()
+
+	output := NewFileOutput(fmt.Sprintf("/tmp/%d_0.gz", rnd), &FileOutputConfig{flushInterval: time.Minute, append: true})
+	for i := 0; i < 1000; i++ {
+		output.Write([]byte("1 1 1\r\ntest"))
+	}
+	name1 := output.file.Name()
+	output.Close()
+
+	output2 := NewFileOutput(fmt.Sprintf("/tmp/%d_1.gz", rnd), &FileOutputConfig{flushInterval: time.Minute, append: true})
+	for i := 0; i < 1000; i++ {
+		output2.Write([]byte("1 1 1\r\ntest"))
+	}
+	name2 := output2.file.Name()
+	output2.Close()
+
+	input := NewFileInput(fmt.Sprintf("/tmp/%d*", rnd), false)
+	buf := make([]byte, 1000)
+	for i := 0; i < 2000; i++ {
+		input.Read(buf)
+	}
+
+	os.Remove(name1)
+	os.Remove(name2)
+}
+
+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(), &FileOutputConfig{flushInterval: time.Minute, append: true})
+
+	Plugins.Inputs = requestGenerator.inputs
+	Plugins.Outputs = []io.Writer{output, outputFile}
+
+	go Start(quit)
+
+	requestGenerator.emit()
+	requestGenerator.wg.Wait()
+
+	time.Sleep(100 * time.Millisecond)
+	outputFile.Close()
+
+	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(), false)
+	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

@@ -29,7 +29,7 @@ func NewHTTPInput(address string) (i *HTTPInput) {
 func (i *HTTPInput) Read(data []byte) (int, error) {
 	buf := <-i.data
 
-	header := payloadHeader(RequestPayload, uuid(), time.Now().UnixNano())
+	header := payloadHeader(RequestPayload, uuid(), time.Now().UnixNano(), -1)
 
 	copy(data[0:len(header)], header)
 	copy(data[len(header):], buf)

input_http_test.go

@@ -41,8 +41,7 @@ func TestInputHTTPLargePayload(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	// Generate 1000kb file
-	dd := exec.Command("dd", "if=/dev/urandom", "of=/tmp/large", "bs=1MB", "count=4")
+	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_raw.go

@@ -1,31 +1,45 @@
 package main
 
 import (
+	"github.com/buger/gor/proto"
 	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 *raw.TCPMessage
-	address  string
-	expire   time.Duration
-	quit     chan bool
-	listener *raw.Listener
+	data          chan *raw.TCPMessage
+	address       string
+	expire        time.Duration
+	quit          chan bool
+	engine        int
+	realIPHeader  []byte
+	trackResponse bool
+	listener      *raw.Listener
 }
 
+// Available engines for intercepting traffic
+const (
+	EngineRawSocket = 1 << iota
+	EnginePcap
+	EnginePcapFile
+)
+
 // NewRAWInput constructor for RAWInput. Accepts address with port as argument.
-func NewRAWInput(address string, expire time.Duration) (i *RAWInput) {
+func NewRAWInput(address string, engine int, trackResponse bool, expire time.Duration, realIPHeader string) (i *RAWInput) {
 	i = new(RAWInput)
 	i.data = make(chan *raw.TCPMessage)
 	i.address = address
 	i.expire = expire
+	i.engine = engine
+	i.realIPHeader = []byte(realIPHeader)
 	i.quit = make(chan bool)
+	i.trackResponse = trackResponse
 
-	go i.listen(address)
+	i.listen(address)
+	i.listener.IsReady()
 
 	return
 }
@@ -37,9 +51,12 @@ func (i *RAWInput) Read(data []byte) (int, error) {
 	var header []byte
 
 	if msg.IsIncoming {
-		header = payloadHeader(RequestPayload, msg.UUID(), msg.Start.UnixNano())
+		header = payloadHeader(RequestPayload, msg.UUID(), msg.Start.UnixNano(), -1)
+		if len(i.realIPHeader) > 0 {
+			buf = proto.SetHeader(buf, i.realIPHeader, []byte(msg.IP().String()))
+		}
 	} else {
-		header = payloadHeader(ResponsePayload, msg.UUID(), msg.End.UnixNano()-msg.RequestStart.UnixNano())
+		header = payloadHeader(ResponsePayload, msg.UUID(), msg.AssocMessage.Start.UnixNano(), msg.End.UnixNano()-msg.AssocMessage.Start.UnixNano())
 	}
 
 	copy(data[0:len(header)], header)
@@ -49,37 +66,46 @@ func (i *RAWInput) Read(data []byte) (int, error) {
 }
 
 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)
 
+	if i.engine == EnginePcapFile {
+		host = address
+		port = "1"
+		err = nil
+	}
+
 	if err != nil {
 		log.Fatal("input-raw: error while parsing address", err)
 	}
 
-	i.listener = raw.NewListener(host, port, i.expire)
+	i.listener = raw.NewListener(host, port, i.engine, i.trackResponse, i.expire)
 
-	for {
-		select {
-		case <-i.quit:
-			return
-		default:
+	ch := i.listener.Receiver()
+
+	go func() {
+		for {
+			select {
+			case <-i.quit:
+				return
+			default:
+			}
+
+			// Receiving TCPMessage object
+			m := <-ch
+
+			i.data <- m
 		}
-
-		// Receiving TCPMessage object
-		m := i.listener.Receive()
-
-		i.data <- m
-	}
+	}()
 }
 
 func (i *RAWInput) String() string {
-	return "RAW Socket input: " + i.address
+	return "Intercepting traffic from: " + i.address
 }
 
-func (i *RAWInput) Close() {
+func (i *RAWInput) Close() error {
 	i.listener.Close()
 	close(i.quit)
+	return nil
 }

input_raw_test.go

@@ -2,14 +2,18 @@ package main
 
 import (
 	"bytes"
+	"github.com/buger/gor/proto"
 	"io"
 	"io/ioutil"
 	"log"
+	"math/rand"
+	"net"
 	"net/http"
 	"net/http/httptest"
 	"net/http/httputil"
 	"os"
 	"os/exec"
+	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -19,17 +23,135 @@ import (
 
 const testRawExpire = time.Millisecond * 200
 
-func TestRAWInput(t *testing.T) {
+func TestRAWInputIPv4(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	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)
+	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, testRawExpire)
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire, "X-Real-IP")
+	defer input.Close()
+
+	output := NewTestOutput(func(data []byte) {
+		if data[0] == '1' {
+			body := payloadBody(data)
+			if len(proto.Header(body, []byte("X-Real-IP"))) == 0 {
+				t.Error("Should have X-Real-IP header", string(body))
+			}
+			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)
+}
+
+func TestRAWInputNoKeepAlive(t *testing.T) {
+	wg := new(sync.WaitGroup)
+	quit := make(chan int)
+
+	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) {
+			w.Write([]byte("a"))
+			w.Write([]byte("b"))
+		}),
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+	origin.SetKeepAlivesEnabled(false)
+	go origin.Serve(listener)
+	defer listener.Close()
+
+	originAddr := listener.Addr().String()
+
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire, "")
+	defer input.Close()
+
+	output := NewTestOutput(func(data []byte) {
+		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)
+}
+
+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) {
@@ -49,9 +171,7 @@ func TestRAWInput(t *testing.T) {
 	Plugins.Inputs = []io.Reader{input}
 	Plugins.Outputs = []io.Writer{output}
 
-	client := NewHTTPClient(origin.URL, &HTTPClientConfig{})
-
-	time.Sleep(time.Millisecond)
+	client := NewHTTPClient("http://"+listener.Addr().String(), &HTTPClientConfig{})
 
 	go Start(quit)
 
@@ -59,6 +179,7 @@ func TestRAWInput(t *testing.T) {
 		// request + response
 		wg.Add(2)
 		client.Get("/")
+		time.Sleep(2 * time.Millisecond)
 	}
 
 	wg.Wait()
@@ -69,7 +190,7 @@ func TestInputRAW100Expect(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
 
-	fileContent, _ := ioutil.ReadFile("LICENSE.txt")
+	fileContent, _ := ioutil.ReadFile("COMM-LICENSE")
 
 	// Origing and Replay server initialization
 	origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -81,7 +202,7 @@ func TestInputRAW100Expect(t *testing.T) {
 
 	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
 
-	input := NewRAWInput(originAddr, time.Second)
+	input := NewRAWInput(originAddr, EnginePcap, true, time.Second, "")
 	defer input.Close()
 
 	// We will use it to get content of raw HTTP request
@@ -119,7 +240,7 @@ func TestInputRAW100Expect(t *testing.T) {
 
 	// Origin + Response/Request Test Output + Request Http Output
 	wg.Add(4)
-	curl := exec.Command("curl", "http://"+originAddr, "--data-binary", "@LICENSE.txt")
+	curl := exec.Command("curl", "http://"+originAddr, "--data-binary", "@COMM-LICENSE")
 	err := curl.Run()
 	if err != nil {
 		log.Fatal(err)
@@ -144,7 +265,7 @@ func TestInputRAWChunkedEncoding(t *testing.T) {
 	}))
 
 	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
-	input := NewRAWInput(originAddr, time.Second)
+	input := NewRAWInput(originAddr, EnginePcap, true, time.Second, "")
 	defer input.Close()
 
 	replay := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -169,7 +290,7 @@ func TestInputRAWChunkedEncoding(t *testing.T) {
 
 	wg.Add(2)
 
-	curl := exec.Command("curl", "http://"+originAddr, "--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)
@@ -187,9 +308,10 @@ func TestInputRAWLargePayload(t *testing.T) {
 	}
 	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=1KB", "count=100")
+	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)
@@ -199,7 +321,7 @@ func TestInputRAWLargePayload(t *testing.T) {
 		defer req.Body.Close()
 		body, _ := ioutil.ReadAll(req.Body)
 
-		if len(body) != 100*1000 {
+		if len(body) != sizeB {
 			t.Error("File size should be 1mb:", len(body))
 		}
 
@@ -207,17 +329,18 @@ func TestInputRAWLargePayload(t *testing.T) {
 	}))
 	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
 
-	input := NewRAWInput(originAddr, time.Second)
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire, "")
 	defer input.Close()
 
 	replay := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		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]
+		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) != 100*1000 {
-			t.Error("File size should be 100000 bytes:", len(body))
+		if len(body) != sizeB {
+			t.Errorf("File size should be %d bytes: %d", sizeB, len(body))
 		}
 
 		wg.Done()
@@ -232,7 +355,7 @@ func TestInputRAWLargePayload(t *testing.T) {
 	go Start(quit)
 
 	wg.Add(2)
-	curl := exec.Command("curl", "http://"+originAddr, "--header", "Transfer-Encoding: chunked", "--data-binary", "@/tmp/large")
+	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)
@@ -241,3 +364,60 @@ func TestInputRAWLargePayload(t *testing.T) {
 	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,7 +2,9 @@ package main
 
 import (
 	"bufio"
+	"bytes"
 	"fmt"
+	"io"
 	"log"
 	"net"
 	"os"
@@ -18,7 +20,7 @@ type TCPInput struct {
 // 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)
@@ -58,16 +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)
-	scanner.Split(payloadScanner)
+	var buffer bytes.Buffer
 
-	for scanner.Scan() {
-		i.data <- scanner.Bytes()
-	}
+	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

@@ -46,65 +46,3 @@ func TestTCPInput(t *testing.T) {
 
 	close(quit)
 }
-
-func BenchmarkTCPInput(b *testing.B) {
-	wg := new(sync.WaitGroup)
-	quit := make(chan int)
-
-	input := NewTCPInput("127.0.0.1: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
-
-				buf := make([]byte, len(data)+2)
-				data = append(data, []byte("¶")...)
-				copy(buf, data)
-				conn.Write(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)
-}

middleware.go

@@ -85,13 +85,22 @@ func (m *Middleware) copy(to io.Writer, from io.Reader) {
 }
 
 func (m *Middleware) read(from io.Reader) {
-	scanner := bufio.NewScanner(from)
+	reader := bufio.NewReader(from)
+	var line []byte
+	var e error
 
-	for scanner.Scan() {
-		bytes := scanner.Bytes()
-		buf := make([]byte, len(bytes)/2)
-		if _, err := hex.Decode(buf, bytes); err != nil {
-			fmt.Fprintln(os.Stderr, "Failed to decode input payload", err, len(bytes))
+	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 {
@@ -101,10 +110,6 @@ func (m *Middleware) read(from io.Reader) {
 		m.data <- buf
 	}
 
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintln(os.Stderr, "Traffic modifier command failed:", err)
-	}
-
 	return
 }
 

middleware_test.go

@@ -116,7 +116,8 @@ func TestEchoMiddleware(t *testing.T) {
 	Settings.middleware = "./examples/middleware/echo.sh"
 
 	// Catch traffic from one service
-	input := NewRAWInput(from.Listener.Addr().String(), testRawExpire)
+	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
@@ -129,7 +130,7 @@ func TestEchoMiddleware(t *testing.T) {
 	go Start(quit)
 
 	// Wait till middleware initialization
-	time.Sleep(10*time.Millisecond)
+	time.Sleep(100 * time.Millisecond)
 
 	// Should receive 2 requests from original + 2 from replayed
 	client := NewHTTPClient(from.URL, &HTTPClientConfig{Debug: false})
@@ -138,7 +139,9 @@ func TestEchoMiddleware(t *testing.T) {
 		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()
@@ -176,7 +179,7 @@ func TestTokenMiddleware(t *testing.T) {
 
 	fromAddr := strings.Replace(from.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
 	// Catch traffic from one service
-	input := NewRAWInput(fromAddr, testRawExpire)
+	input := NewRAWInput(fromAddr, EnginePcap, true, testRawExpire, "")
 	defer input.Close()
 
 	// And redirect to another

output_dummy.go

@@ -9,14 +9,14 @@ type DummyOutput struct {
 }
 
 // NewDummyOutput constructor for DummyOutput
-func NewDummyOutput(options string) (di *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,34 +1,169 @@
 package main
 
 import (
+	"bufio"
+	"compress/gzip"
+	"fmt"
 	"io"
 	"log"
 	"os"
+	"path/filepath"
+	"runtime/debug"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
 )
 
+var dateFileNameFuncs = map[string]func() string{
+	"%Y":  func() string { return time.Now().Format("2006") },
+	"%m":  func() string { return time.Now().Format("01") },
+	"%d":  func() string { return time.Now().Format("02") },
+	"%H":  func() string { return time.Now().Format("15") },
+	"%M":  func() string { return time.Now().Format("04") },
+	"%S":  func() string { return time.Now().Format("05") },
+	"%NS": func() string { return fmt.Sprint(time.Now().Nanosecond()) },
+}
+
+type FileOutputConfig struct {
+	flushInterval time.Duration
+	sizeLimit     unitSizeVar
+	queueLimit    int
+	append        bool
+}
+
 // FileOutput output plugin
 type FileOutput struct {
-	path string
-	file *os.File
+	mu           sync.Mutex
+	pathTemplate string
+	currentName  string
+	file         *os.File
+	queueLength  int
+	chunkSize    int
+	writer       io.Writer
+
+	config *FileOutputConfig
 }
 
 // NewFileOutput constructor for FileOutput, accepts path
-func NewFileOutput(path string) io.Writer {
+func NewFileOutput(pathTemplate string, config *FileOutputConfig) *FileOutput {
 	o := new(FileOutput)
-	o.path = path
-	o.init(path)
+	o.pathTemplate = pathTemplate
+	o.config = config
+	o.updateName()
+
+	go func() {
+		for {
+			time.Sleep(time.Second)
+			o.updateName()
+		}
+	}()
 
 	return o
 }
 
-func (o *FileOutput) init(path string) {
-	var err error
+func getFileIndex(name string) int {
+	ext := filepath.Ext(name)
+	withoutExt := strings.TrimSuffix(name, ext)
 
-	o.file, err = os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
-
-	if err != nil {
-		log.Fatal(o, "Cannot open file %q. Error: %s", path, err)
+	if idx := strings.LastIndex(withoutExt, "_"); idx != -1 {
+		if i, err := strconv.Atoi(withoutExt[idx+1:]); err == nil {
+			return i
+		}
 	}
+
+	return -1
+}
+
+func setFileIndex(name string, idx int) string {
+	idxS := strconv.Itoa(idx)
+	ext := filepath.Ext(name)
+	withoutExt := strings.TrimSuffix(name, ext)
+
+	if i := strings.LastIndex(withoutExt, "_"); i != -1 {
+		if _, err := strconv.Atoi(withoutExt[i+1:]); err == nil {
+			withoutExt = withoutExt[:i]
+		}
+	}
+
+	return withoutExt + "_" + idxS + ext
+}
+
+func withoutIndex(s string) string {
+	if i := strings.LastIndex(s, "_"); i != -1 {
+		return s[:i]
+	}
+
+	return s
+}
+
+type sortByFileIndex []string
+
+func (s sortByFileIndex) Len() int {
+	return len(s)
+}
+
+func (s sortByFileIndex) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s sortByFileIndex) Less(i, j int) bool {
+	if withoutIndex(s[i]) == withoutIndex(s[j]) {
+		return getFileIndex(s[i]) < getFileIndex(s[j])
+	}
+
+	return s[i] < s[j]
+}
+
+func (o *FileOutput) filename() string {
+	defer o.mu.Unlock()
+	o.mu.Lock()
+
+	path := o.pathTemplate
+
+	for name, fn := range dateFileNameFuncs {
+		path = strings.Replace(path, name, fn(), -1)
+	}
+
+	if !o.config.append {
+		nextChunk := false
+
+		if o.currentName == "" ||
+			((o.config.queueLimit > 0 && o.queueLength >= o.config.queueLimit) ||
+				(o.config.sizeLimit > 0 && o.chunkSize >= int(o.config.sizeLimit))) {
+			nextChunk = true
+		}
+
+		ext := filepath.Ext(path)
+		withoutExt := strings.TrimSuffix(path, ext)
+
+		if matches, err := filepath.Glob(withoutExt + "*" + ext); err == nil {
+			if len(matches) == 0 {
+				return setFileIndex(path, 0)
+			}
+			sort.Sort(sortByFileIndex(matches))
+
+			last := matches[len(matches)-1]
+
+			fileIndex := 0
+			if idx := getFileIndex(last); idx != -1 {
+				fileIndex = idx
+
+				if nextChunk {
+					fileIndex++
+				}
+			}
+
+			return setFileIndex(last, fileIndex)
+		}
+	}
+
+	return path
+}
+
+func (o *FileOutput) updateName() {
+	o.currentName = filepath.Clean(o.filename())
 }
 
 func (o *FileOutput) Write(data []byte) (n int, err error) {
@@ -36,12 +171,71 @@ func (o *FileOutput) Write(data []byte) (n int, err error) {
 		return len(data), nil
 	}
 
-	o.file.Write(data)
-	o.file.Write([]byte(payloadSeparator))
+	if o.file == nil || o.currentName != o.file.Name() {
+		o.mu.Lock()
+		o.Close()
+
+		o.file, err = os.OpenFile(o.currentName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
+		o.file.Sync()
+
+		if strings.HasSuffix(o.currentName, ".gz") {
+			o.writer = gzip.NewWriter(o.file)
+		} else {
+			o.writer = bufio.NewWriter(o.file)
+		}
+
+		if err != nil {
+			log.Fatal(o, "Cannot open file %q. Error: %s", o.currentName, err)
+		}
+
+		o.queueLength = 0
+		o.mu.Unlock()
+	}
+
+	o.writer.Write(data)
+	o.writer.Write([]byte(payloadSeparator))
+
+	o.queueLength++
 
 	return len(data), nil
 }
 
+func (o *FileOutput) flush() {
+	// Don't exit on panic
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("PANIC while file flush: ", r, o, string(debug.Stack()))
+		}
+	}()
+
+	defer o.mu.Unlock()
+	o.mu.Lock()
+
+	if o.file != nil {
+		if strings.HasSuffix(o.currentName, ".gz") {
+			o.writer.(*gzip.Writer).Flush()
+		} else {
+			o.writer.(*bufio.Writer).Flush()
+		}
+
+		if stat, err := o.file.Stat(); err != nil {
+			o.chunkSize = int(stat.Size())
+		}
+	}
+}
+
 func (o *FileOutput) String() string {
-	return "File output: " + o.path
+	return "File output: " + o.file.Name()
+}
+
+func (o *FileOutput) Close() error {
+	if o.file != nil {
+		if strings.HasSuffix(o.currentName, ".gz") {
+			o.writer.(*gzip.Writer).Close()
+		} else {
+			o.writer.(*bufio.Writer).Flush()
+		}
+		o.file.Close()
+	}
+	return nil
 }

output_file_settings.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"strconv"
+	"strings"
+)
+
+var dataUnitMap = map[byte]int64{
+	'k': 1024,
+	'm': 1024 * 1024,
+	'g': 1024 * 1024 * 1024,
+}
+
+func parseDataUnit(s string) int64 {
+	// Allow kb, mb, gb
+	if strings.HasSuffix(s, "b") {
+		s = s[:len(s)-1]
+	}
+
+	if unit, ok := dataUnitMap[s[len(s)-1]]; ok {
+		size, _ := strconv.ParseInt(s[:len(s)-1], 10, 64)
+		return unit * size
+	} else {
+		// If no unit specified use bytes
+		size, _ := strconv.ParseInt(s, 10, 64)
+		return size
+	}
+}
+
+type unitSizeVar int64
+
+func (u unitSizeVar) String() string {
+	return strconv.Itoa(int(u))
+}
+
+func (u unitSizeVar) Set(s string) error {
+	u = unitSizeVar(parseDataUnit(s))
+	return nil
+}

output_file_test.go

@@ -1,9 +1,16 @@
 package main
 
 import (
+	"fmt"
 	"io"
+	"math/rand"
+	"os"
+	"reflect"
+	"sort"
 	"sync"
+	"sync/atomic"
 	"testing"
+	"time"
 )
 
 func TestFileOutput(t *testing.T) {
@@ -11,7 +18,7 @@ func TestFileOutput(t *testing.T) {
 	quit := make(chan int)
 
 	input := NewTestInput()
-	output := NewFileOutput("/tmp/test_requests.gor")
+	output := NewFileOutput("/tmp/test_requests.gor", &FileOutputConfig{flushInterval: time.Minute, append: true})
 
 	Plugins.Inputs = []io.Reader{input}
 	Plugins.Outputs = []io.Writer{output}
@@ -23,12 +30,17 @@ func TestFileOutput(t *testing.T) {
 		input.EmitGET()
 		input.EmitPOST()
 	}
+	time.Sleep(100 * time.Millisecond)
+	output.flush()
+
 	close(quit)
 
 	quit = make(chan int)
 
-	input2 := NewFileInput("/tmp/test_requests.gor")
+	var counter int64
+	input2 := NewFileInput("/tmp/test_requests.gor", false)
 	output2 := NewTestOutput(func(data []byte) {
+		atomic.AddInt64(&counter, 1)
 		wg.Done()
 	})
 
@@ -40,3 +52,234 @@ func TestFileOutput(t *testing.T) {
 	wg.Wait()
 	close(quit)
 }
+
+func TestFileOutputWithNameCleaning(t *testing.T) {
+	output := &FileOutput{pathTemplate: "./test_requests.gor", config: &FileOutputConfig{flushInterval: time.Minute, append: false}}
+	expectedFileName := "test_requests_0.gor"
+	output.updateName()
+
+	if expectedFileName != output.currentName {
+		t.Errorf("Expected path %s but got %s", expectedFileName, output.currentName)
+	}
+
+}
+
+func TestFileOutputPathTemplate(t *testing.T) {
+	output := &FileOutput{pathTemplate: "/tmp/log-%Y-%m-%d-%S", config: &FileOutputConfig{flushInterval: time.Minute, append: true}}
+	now := time.Now()
+	expectedPath := fmt.Sprintf("/tmp/log-%s-%s-%s-%s", now.Format("2006"), now.Format("01"), now.Format("02"), now.Format("05"))
+	path := output.filename()
+
+	if expectedPath != path {
+		t.Errorf("Expected path %s but got %s", expectedPath, path)
+	}
+}
+
+func TestFileOutputMultipleFiles(t *testing.T) {
+	output := NewFileOutput("/tmp/log-%Y-%m-%d-%S", &FileOutputConfig{append: true, flushInterval: time.Minute})
+
+	if output.file != nil {
+		t.Error("Should not initialize file if no writes")
+	}
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name1 := output.file.Name()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name2 := output.file.Name()
+
+	time.Sleep(time.Second)
+	output.updateName()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name3 := output.file.Name()
+
+	if name2 != name1 {
+		t.Error("Fast changes should happen in same file:", name1, name2, name3)
+	}
+
+	if name3 == name1 {
+		t.Error("File name should change:", name1, name2, name3)
+	}
+
+	os.Remove(name1)
+	os.Remove(name3)
+}
+
+func TestFileOutputCompression(t *testing.T) {
+	output := NewFileOutput("/tmp/log-%Y-%m-%d-%S.gz", &FileOutputConfig{append: true, flushInterval: time.Minute})
+
+	if output.file != nil {
+		t.Error("Should not initialize file if no writes")
+	}
+
+	for i := 0; i < 1000; i++ {
+		output.Write([]byte("1 1 1\r\ntest"))
+	}
+
+	name := output.file.Name()
+	output.Close()
+
+	s, _ := os.Stat(name)
+	if s.Size() == 12*1000 {
+		t.Error("Should be compressed file:", s.Size())
+	}
+
+	os.Remove(name)
+}
+
+func TestParseDataUnit(t *testing.T) {
+	var tests = []struct {
+		value string
+		size  int64
+	}{
+		{"100kb", dataUnitMap['k'] * 100},
+		{"100k", dataUnitMap['k'] * 100},
+		{"1kb", dataUnitMap['k']},
+		{"1g", dataUnitMap['g']},
+		{"10m", dataUnitMap['m'] * 10},
+		{"zsaa312", 0},
+	}
+
+	for _, c := range tests {
+		if parseDataUnit(c.value) != c.size {
+			t.Error(c.value, "should be", c.size, "instead", parseDataUnit(c.value))
+		}
+	}
+}
+
+func TestGetFileIndex(t *testing.T) {
+	var tests = []struct {
+		path  string
+		index int
+	}{
+		{"/tmp/logs", -1},
+		{"/tmp/logs_1", 1},
+		{"/tmp/logs_2.gz", 2},
+		{"/tmp/logs_0.gz", 0},
+	}
+
+	for _, c := range tests {
+		if getFileIndex(c.path) != c.index {
+			t.Error(c.path, "should be", c.index, "instead", getFileIndex(c.path))
+		}
+	}
+}
+
+func TestSetFileIndex(t *testing.T) {
+	var tests = []struct {
+		path    string
+		index   int
+		newPath string
+	}{
+		{"/tmp/logs", 0, "/tmp/logs_0"},
+		{"/tmp/logs.gz", 1, "/tmp/logs_1.gz"},
+		{"/tmp/logs_1", 0, "/tmp/logs_0"},
+		{"/tmp/logs_0", 10, "/tmp/logs_10"},
+		{"/tmp/logs_0.gz", 10, "/tmp/logs_10.gz"},
+		{"/tmp/logs_underscores.gz", 10, "/tmp/logs_underscores_10.gz"},
+	}
+
+	for _, c := range tests {
+		if setFileIndex(c.path, c.index) != c.newPath {
+			t.Error(c.path, "should be", c.newPath, "instead", setFileIndex(c.path, c.index))
+		}
+	}
+}
+
+func TestFileOutputAppendQueueLimitOverflow(t *testing.T) {
+	rnd := rand.Int63()
+	name := fmt.Sprintf("/tmp/%d", rnd)
+
+	output := NewFileOutput(name, &FileOutputConfig{append: false, flushInterval: time.Minute, queueLimit: 2})
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name1 := output.file.Name()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name2 := output.file.Name()
+
+	output.updateName()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name3 := output.file.Name()
+
+	if name2 != name1 || name1 != fmt.Sprintf("/tmp/%d_0", rnd) {
+		t.Error("Fast changes should happen in same file:", name1, name2, name3)
+	}
+
+	if name3 == name1 || name3 != fmt.Sprintf("/tmp/%d_1", rnd) {
+		t.Error("File name should change:", name1, name2, name3)
+	}
+
+	os.Remove(name1)
+	os.Remove(name3)
+}
+
+func TestFileOutputAppendQueueLimitNoOverflow(t *testing.T) {
+	rnd := rand.Int63()
+	name := fmt.Sprintf("/tmp/%d", rnd)
+
+	output := NewFileOutput(name, &FileOutputConfig{append: false, flushInterval: time.Minute, queueLimit: 3})
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name1 := output.file.Name()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name2 := output.file.Name()
+
+	output.updateName()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name3 := output.file.Name()
+
+	if name2 != name1 || name1 != fmt.Sprintf("/tmp/%d_0", rnd) {
+		t.Error("Fast changes should happen in same file:", name1, name2, name3)
+	}
+
+	if name3 != name1 || name3 != fmt.Sprintf("/tmp/%d_0", rnd) {
+		t.Error("File name should not change:", name1, name2, name3)
+	}
+
+	os.Remove(name1)
+	os.Remove(name3)
+}
+
+func TestFileOutputAppendQueueLimitGzips(t *testing.T) {
+	rnd := rand.Int63()
+	name := fmt.Sprintf("/tmp/%d.gz", rnd)
+
+	output := NewFileOutput(name, &FileOutputConfig{append: false, flushInterval: time.Minute, queueLimit: 2})
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name1 := output.file.Name()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name2 := output.file.Name()
+
+	output.updateName()
+
+	output.Write([]byte("1 1 1\r\ntest"))
+	name3 := output.file.Name()
+
+	if name2 != name1 || name1 != fmt.Sprintf("/tmp/%d_0.gz", rnd) {
+		t.Error("Fast changes should happen in same file:", name1, name2, name3)
+	}
+
+	if name3 == name1 || name3 != fmt.Sprintf("/tmp/%d_1.gz", rnd) {
+		t.Error("File name should change:", name1, name2, name3)
+	}
+
+	os.Remove(name1)
+	os.Remove(name3)
+}
+
+func TestFileOutputSort(t *testing.T) {
+	var files = []string{"2016_0", "2014_10", "2015_0", "2015_10", "2015_2"}
+	var expected = []string{"2014_10", "2015_0", "2015_2", "2015_10", "2016_0"}
+	sort.Sort(sortByFileIndex(files))
+
+	if !reflect.DeepEqual(files, expected) {
+		t.Error("Should properly sort file names using indexes", files, expected)
+	}
+}

output_http.go

@@ -1,10 +1,11 @@
 package main
 
 import (
-	"github.com/buger/gor/proto"
 	"io"
 	"sync/atomic"
 	"time"
+
+	"github.com/buger/gor/proto"
 )
 
 const initialDynamicWorkers = 10
@@ -13,6 +14,7 @@ type response struct {
 	payload       []byte
 	uuid          []byte
 	roundTripTime int64
+	startedAt     int64
 }
 
 // HTTPOutputConfig struct for holding http output configuration
@@ -26,6 +28,7 @@ type HTTPOutputConfig struct {
 
 	Timeout      time.Duration
 	OriginalHost bool
+	BufferSize   int
 
 	Debug bool
 
@@ -109,10 +112,11 @@ func (o *HTTPOutput) workerMaster() {
 
 func (o *HTTPOutput) startWorker() {
 	client := NewHTTPClient(o.address, &HTTPClientConfig{
-		FollowRedirects: o.config.redirectLimit,
-		Debug:           o.config.Debug,
-		OriginalHost:    o.config.OriginalHost,
-		Timeout:         o.config.Timeout,
+		FollowRedirects:    o.config.redirectLimit,
+		Debug:              o.config.Debug,
+		OriginalHost:       o.config.OriginalHost,
+		Timeout:            o.config.Timeout,
+		ResponseBufferSize: o.config.BufferSize,
 	})
 
 	deathCount := 0
@@ -175,7 +179,7 @@ func (o *HTTPOutput) Read(data []byte) (int, error) {
 
 	Debug("[OUTPUT-HTTP] Received response:", string(resp.payload))
 
-	header := payloadHeader(ReplayedResponsePayload, resp.uuid, resp.roundTripTime)
+	header := payloadHeader(ReplayedResponsePayload, resp.uuid, resp.roundTripTime, resp.startedAt)
 	copy(data[0:len(header)], header)
 	copy(data[len(header):], resp.payload)
 
@@ -203,7 +207,7 @@ func (o *HTTPOutput) sendRequest(client *HTTPClient, request []byte) {
 	}
 
 	if o.config.TrackResponses {
-		o.responses <- response{resp, uuid, stop.UnixNano() - start.UnixNano()}
+		o.responses <- response{resp, uuid, start.UnixNano(), stop.UnixNano() - start.UnixNano()}
 	}
 
 	if o.elasticSearch != nil {

output_kafka.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"encoding/json"
+	"github.com/Shopify/sarama"
+	"github.com/buger/gor/proto"
+	"io"
+	"log"
+	"strings"
+	"time"
+)
+
+// KafkaConfig should contains required information to
+// build producers.
+type KafkaConfig struct {
+	host  string
+	topic string
+}
+
+// KafkaOutput should make producer client.
+type KafkaOutput struct {
+	config   *KafkaConfig
+	producer sarama.AsyncProducer
+}
+
+// KafkaMessage should contains catched request information that should be
+// passed as Json to Apache Kafka.
+type KafkaMessage struct {
+	ReqURL     string            `json:"Req_URL"`
+	ReqMethod  string            `json:"Req_Method"`
+	ReqBody    string            `json:"Req_Body,omitempty"`
+	ReqHeaders map[string]string `json:"Req_Headers,omitempty"`
+}
+
+// KafkaOutputFrequency in milliseconds
+const KafkaOutputFrequency = 500
+
+// NewKafkaOutput creates instance of kafka producer client.
+func NewKafkaOutput(address string, config *KafkaConfig) io.Writer {
+	c := sarama.NewConfig()
+	c.Producer.RequiredAcks = sarama.WaitForLocal
+	c.Producer.Compression = sarama.CompressionSnappy
+	c.Producer.Flush.Frequency = KafkaOutputFrequency * time.Millisecond
+
+	brokerList := strings.Split(config.host, ",")
+
+	producer, err := sarama.NewAsyncProducer(brokerList, c)
+	if err != nil {
+		log.Fatalln("Failed to start Sarama(Kafka) producer:", err)
+	}
+
+	o := &KafkaOutput{
+		config:   config,
+		producer: producer,
+	}
+
+	if Settings.verbose {
+		// Start infinite loop for tracking errors for kafka producer.
+		go o.ErrorHandler()
+	}
+
+	return o
+}
+
+// ErrorHandler should receive errors
+func (o *KafkaOutput) ErrorHandler() {
+	for err := range o.producer.Errors() {
+		log.Println("Failed to write access log entry:", err)
+	}
+}
+
+func (o *KafkaOutput) Write(data []byte) (n int, err error) {
+	headers := make(map[string]string)
+	proto.ParseHeaders([][]byte{data}, func(header []byte, value []byte) bool {
+		headers[string(header)] = string(value)
+		return true
+	})
+
+	req := payloadBody(data)
+
+	kafkaMessage := KafkaMessage{
+		ReqURL:     string(proto.Path(req)),
+		ReqMethod:  string(proto.Method(req)),
+		ReqBody:    string(proto.Body(req)),
+		ReqHeaders: headers,
+	}
+	jsonMessage, _ := json.Marshal(&kafkaMessage)
+	message := sarama.StringEncoder(jsonMessage)
+
+	o.producer.Input() <- &sarama.ProducerMessage{
+		Topic: o.config.topic,
+		Value: message,
+	}
+
+	return len(message), nil
+}

output_null.go

@@ -0,0 +1,18 @@
+package main
+
+// NullOutput used for debugging, prints nothing
+type NullOutput struct {
+}
+
+// NullOutput constructor for NullOutput
+func NewNullOutput() (o *NullOutput) {
+	return new(NullOutput)
+}
+
+func (o *NullOutput) Write(data []byte) (int, error) {
+	return len(data), nil
+}
+
+func (o *NullOutput) String() string {
+	return "Null Output"
+}

output_tcp.go

@@ -38,9 +38,22 @@ 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()
@@ -50,7 +63,7 @@ func (o *TCPOutput) worker() {
 		_, 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
 		}
@@ -78,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
 }
 

plugins.go

@@ -4,6 +4,7 @@ import (
 	"io"
 	"reflect"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -11,8 +12,11 @@ import (
 type InOutPlugins struct {
 	Inputs  []io.Reader
 	Outputs []io.Writer
+	All     []interface{}
 }
 
+var pluginMu sync.Mutex
+
 // Plugins holds all the plugin objects
 var Plugins *InOutPlugins = new(InOutPlugins)
 
@@ -32,6 +36,7 @@ func extractLimitOptions(options string) (string, string) {
 //
 // 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
@@ -40,11 +45,13 @@ 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()
@@ -67,20 +74,40 @@ func registerPlugin(constructor interface{}, options ...interface{}) {
 	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)
+	}
+
+	if Settings.outputNull {
+		registerPlugin(NewNullOutput)
+	}
+
+	engine := EnginePcap
+	if Settings.inputRAWEngine == "raw_socket" {
+		engine = EngineRawSocket
+	} else if Settings.inputRAWEngine == "pcap_file" {
+		engine = EnginePcapFile
 	}
 
 	for _, options := range Settings.inputRAW {
-		registerPlugin(NewRAWInput, options, time.Duration(0))
+		registerPlugin(NewRAWInput, options, engine, Settings.inputRAWTrackResponse, time.Duration(0), Settings.inputRAWRealIPHeader)
 	}
 
 	for _, options := range Settings.inputTCP {
@@ -92,11 +119,11 @@ func InitPlugins() {
 	}
 
 	for _, options := range Settings.inputFile {
-		registerPlugin(NewFileInput, options)
+		registerPlugin(NewFileInput, options, Settings.inputFileLoop)
 	}
 
 	for _, options := range Settings.outputFile {
-		registerPlugin(NewFileOutput, options)
+		registerPlugin(NewFileOutput, options, &Settings.outputFileConfig)
 	}
 
 	for _, options := range Settings.inputHTTP {
@@ -115,4 +142,8 @@ func InitPlugins() {
 	for _, options := range Settings.outputHTTP {
 		registerPlugin(NewHTTPOutput, options, &Settings.outputHTTPConfig)
 	}
+
+	if Settings.outputKafkaConfig.host != "" && Settings.outputKafkaConfig.topic != "" {
+		registerPlugin(NewKafkaOutput, "", &Settings.outputKafkaConfig)
+	}
 }

proto/proto.go

@@ -41,35 +41,254 @@ func MIMEHeadersStartPos(payload []byte) int {
 	return bytes.Index(payload, CLRF) + 2 // Find first line end
 }
 
+func isLower(b byte) bool {
+	if 'a' <= b && b <= 'z' {
+		return true
+	}
+
+	return false
+}
+
+func toUpper(b byte) byte {
+	if 'a' <= b && b <= 'z' {
+		b -= 'a' - 'A'
+	}
+	return b
+}
+
+func toLower(b byte) byte {
+	if 'A' <= b && b <= 'Z' {
+		b += 'a' - 'A'
+	}
+	return b
+}
+
+func headerIndex(payload []byte, name []byte) int {
+	isLower := isLower(name[0])
+	i := 0
+
+	for {
+		if i >= len(payload) {
+			return -1
+		}
+
+		if payload[i] == '\n' {
+			i++
+
+			// We are at the end
+			if i == len(payload) {
+				return -1
+			}
+
+			if payload[i] == name[0] ||
+				(!isLower && payload[i] == toLower(name[0])) ||
+				(isLower && payload[i] == toUpper(name[0])) {
+
+				i++
+				j := 1
+				for {
+					if j == len(name) {
+						// Matched, and return start of the header
+						return i - len(name)
+					}
+
+					if payload[i] != name[j] {
+						break
+					}
+
+					// If compound header name do one more case check: Content-Length or Transfer-Encoding
+					if name[j] == '-' {
+						i++
+						j++
+
+						if !(payload[i] == name[j] ||
+							(!isLower && payload[i] == toLower(name[j])) ||
+							(isLower && payload[i] == toUpper(name[j]))) {
+							break
+						}
+					}
+
+					j++
+					i++
+				}
+			}
+		}
+
+		i++
+	}
+
+	return -1
+}
+
 // 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)
+func header(payload []byte, name []byte) (value []byte, headerStart, headerEnd, valueStart, valueEnd int) {
+	headerStart = headerIndex(payload, name)
 
 	if headerStart == -1 {
 		return
 	}
 
 	valueStart = headerStart + len(name) + 1 // Skip ":" after header name
-	if payload[valueStart] == ' ' {          // Ignore empty space after ':'
-		valueStart++
-	}
-
 	headerEnd = valueStart + bytes.IndexByte(payload[valueStart:], '\n')
 
-	if payload[headerEnd-1] == '\r' {
-		headerEnd -= 1
+	for valueStart < headerEnd { // Ignore empty space after ':'
+		if payload[valueStart] == ' ' {
+			valueStart++
+		} else {
+			break
+		}
 	}
 
-	value = payload[valueStart:headerEnd]
+	valueEnd = valueStart + bytes.IndexByte(payload[valueStart:], '\n')
+
+	if payload[headerEnd-1] == '\r' {
+		valueEnd--
+	}
+
+	// ignore empty space at end of header value
+	for valueStart < valueEnd {
+		if payload[valueEnd-1] == ' ' {
+			valueEnd--
+		} else {
+			break
+		}
+	}
+	value = payload[valueStart:valueEnd]
+
+	return
+}
+
+// Works only with ASCII
+func HeadersEqual(h1 []byte, h2 []byte) bool {
+	if len(h1) != len(h2) {
+		return false
+	}
+
+	for i, c1 := range h1 {
+		c2 := h2[i]
+
+		switch int(c1) - int(c2) {
+		case 0, 32, -32:
+		default:
+			return false
+		}
+	}
+
+	return true
+}
+
+// Parsing headers from multiple payloads
+func ParseHeaders(payloads [][]byte, cb func(header []byte, value []byte) bool) {
+
+	hS := [2]int{0, 0}
+	hE := [2]int{-1, -1}
+	vS := [2]int{-1, -1}
+	vE := [2]int{-1, -1}
+
+	i := 0
+	pIdx := 0
+	lineBreaks := 0
+	newLineBreak := true
+
+	for {
+		if len(payloads)-1 < pIdx {
+			break
+		}
+
+		p := payloads[pIdx]
+
+		if len(p)-1 < i {
+			pIdx++
+			i = 0
+			continue
+		}
+
+		switch p[i] {
+		case '\r', '\n':
+			newLineBreak = true
+			lineBreaks++
+
+			// End of headers
+			if lineBreaks == 4 {
+				return
+			}
+
+			if lineBreaks > 1 {
+				break
+			}
+
+			vE = [2]int{pIdx, i}
+
+			if vS[1] != -1 && vE[1] != -1 &&
+				hS[1] != -1 && hE[1] != -1 {
+
+				var header, value []byte
+
+				phS, phE, pvS, pvE := payloads[hS[0]], payloads[hE[0]], payloads[vS[0]], payloads[vE[0]]
+
+				// If in same payload
+				if hS[0] == hE[0] {
+					header = phS[hS[1]:hE[1]]
+				} else {
+					header = make([]byte, len(phS)-hS[1]+hE[1])
+					copy(header, phS[hS[1]:])
+					copy(header[len(phS)-hS[1]:], phE[:hE[1]])
+				}
+
+				if vS[0] == vE[0] {
+					value = pvS[vS[1]:vE[1]]
+				} else {
+					value = make([]byte, len(pvS)-vS[1]+vE[1])
+					copy(value, pvS[vS[1]:])
+					copy(value[len(pvS)-vS[1]:], pvE[:vE[1]])
+				}
+
+				if !cb(header, value) {
+					return
+				}
+			}
+
+			// Header found, reset values
+			vS = [2]int{-1, -1}
+			vE = [2]int{-1, -1}
+			hS = [2]int{-1, -1}
+			hE = [2]int{-1, -1}
+		case ':':
+			if newLineBreak {
+				hE = [2]int{pIdx, i}
+				newLineBreak = false
+			}
+		default:
+			lineBreaks = 0
+
+			if hS[1] == -1 {
+				hS = [2]int{pIdx, i}
+			} else {
+				if hE[1] == -1 {
+					break
+				}
+
+				if vS[1] == -1 {
+					if p[i] == ' ' {
+						break
+					}
+
+					vS = [2]int{pIdx, i}
+				}
+			}
+		}
+
+		i++
+	}
 
 	return
 }
 
 // Header returns header value, if header not found, value will be blank
 func Header(payload, name []byte) []byte {
-	val, _, _, _ := header(payload, name)
+	val, _, _, _, _ := header(payload, name)
 
 	return val
 }
@@ -77,11 +296,11 @@ func Header(payload, name []byte) []byte {
 // 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, ve := header(payload, name)
 
 	if hs != -1 {
-		// If header found we just repace its value
-		return byteutils.Replace(payload, vs, he, value)
+		// If header found we just replace its value
+		return byteutils.Replace(payload, vs, ve, value)
 	}
 
 	return AddHeader(payload, name, value)
@@ -101,6 +320,19 @@ func AddHeader(payload, name, value []byte) []byte {
 	return byteutils.Insert(payload, mimeStart, header)
 }
 
+// DelHeader takes http payload and removes header name from headers section
+// Returns modified request payload
+func DeleteHeader(payload, name []byte) []byte {
+	_, hs, he, _, _ := header(payload, name)
+	if hs != -1 {
+		newHeader := make([]byte, len(payload)-(he-hs)-1)
+		copy(newHeader[:hs], payload[:hs])
+		copy(newHeader[hs:], payload[he+1:])
+		return newHeader
+	}
+	return payload
+}
+
 // Body returns request/response body
 func Body(payload []byte) []byte {
 	// 4 -> len(EMPTY_LINE)
@@ -216,7 +448,7 @@ func Status(payload []byte) []byte {
 }
 
 var httpMethods []string = []string{
-	"GET ", "OPTI", "HEAD", "POST", "PUT ", "DELE", "TRAC", "CONN",
+	"GET ", "OPTI", "HEAD", "POST", "PUT ", "DELE", "TRAC", "CONN", "PATC" /* custom methods */, "BAN", "PURG",
 }
 
 func IsHTTPPayload(payload []byte) bool {

proto/proto_test.go

@@ -2,6 +2,7 @@ package proto
 
 import (
 	"bytes"
+	"reflect"
 	"testing"
 )
 
@@ -16,6 +17,13 @@ func TestHeader(t *testing.T) {
 		t.Error("Should find header value")
 	}
 
+	// Value with space at end
+	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 7")
+	}
+
 	// 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")
 
@@ -38,9 +46,22 @@ func TestHeader(t *testing.T) {
 	}
 
 	// Header not found
-	if _, headerStart, _, _ = header(payload, []byte("Not-Found")); headerStart != -1 {
+	if _, headerStart, _, _, _ = header(payload, []byte("Not-Found")); headerStart != -1 {
 		t.Error("Should not found header")
 	}
+
+	// Lower case headers
+	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 lower case 2 word header")
+	}
+
+	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("host")); !bytes.Equal(val, []byte("www.w3.org")) {
+		t.Error("Should find lower case 1 word header")
+	}
 }
 
 func TestMIMEHeadersEndPos(t *testing.T) {
@@ -84,6 +105,117 @@ func TestSetHeader(t *testing.T) {
 	}
 }
 
+func TestDeleteHeader(t *testing.T) {
+	var payload, payloadAfter []byte
+
+	payload = []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\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+
+	if payload = DeleteHeader(payload, []byte("User-Agent")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should delete header if found", string(payload), string(payloadAfter))
+	}
+
+	//Whitespace at end of User-Agent
+	payload = []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\nContent-Length: 7\r\nHost: www.w3.org\r\n\r\na=1&b=2")
+
+	if payload = DeleteHeader(payload, []byte("User-Agent")); !bytes.Equal(payload, payloadAfter) {
+		t.Error("Should delete header if found", string(payload), string(payloadAfter))
+	}
+}
+
+func TestParseHeaders(t *testing.T) {
+	payload := [][]byte{[]byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.or"), []byte("g\r\nUser-Ag"), []byte("ent:Chrome\r\n\r\n"), []byte("Fake-Header: asda")}
+
+	headers := make(map[string]string)
+
+	ParseHeaders(payload, func(header []byte, value []byte) bool {
+		headers[string(header)] = string(value)
+		return true
+	})
+
+	expected := map[string]string{
+		"Content-Length": "7",
+		"Host":           "www.w3.org",
+		"User-Agent":     "Chrome",
+	}
+
+	if !reflect.DeepEqual(headers, expected) {
+		t.Error("Headers do not properly parsed", headers)
+	}
+}
+
+func TestParseHeadersWithComplexUserAgent(t *testing.T) {
+	// User-Agent could contain inside ':'
+	// Parser should wait for \r\n
+	payload := [][]byte{[]byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.or"), []byte("g\r\nUser-Ag"), []byte("ent:Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko\r\n\r\n"), []byte("Fake-Header: asda")}
+
+	headers := make(map[string]string)
+
+	ParseHeaders(payload, func(header []byte, value []byte) bool {
+		headers[string(header)] = string(value)
+		return true
+	})
+
+	expected := map[string]string{
+		"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko",
+	}
+
+	if expected["User-Agent"] != headers["User-Agent"] {
+		t.Errorf("Header 'User-Agent' expected '%s' and parsed: '%s'", expected["User-Agent"], headers["User-Agent"])
+	}
+}
+
+func TestParseHeadersWithOrigin(t *testing.T) {
+	// User-Agent could contain inside ':'
+	// Parser should wait for \r\n
+	payload := [][]byte{[]byte("POST /post HTTP/1.1\r\nContent-Length: 7\r\nHost: www.w3.or"), []byte("g\r\nReferrer: http://127.0.0.1:3000\r\nOrigi"), []byte("n: https://www.example.com\r\nUser-Ag"), []byte("ent:Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko\r\n\r\n"), []byte("in:https://www.example.com\r\n\r\n"), []byte("Fake-Header: asda")}
+
+	headers := make(map[string]string)
+
+	ParseHeaders(payload, func(header []byte, value []byte) bool {
+		headers[string(header)] = string(value)
+		return true
+	})
+
+	expected := map[string]string{
+		"Origin":     "https://www.example.com",
+		"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko",
+		"Referrer":   "http://127.0.0.1:3000",
+	}
+
+	if expected["Referrer"] != headers["Referrer"] {
+		t.Errorf("Header 'Referrer' expected '%s' and parsed: '%s'", expected["Referrer"], headers["Referrer"])
+	}
+
+	if expected["Origin"] != headers["Origin"] {
+		t.Errorf("Header 'Origin' expected '%s' and parsed: '%s'", expected["Origin"], headers["Origin"])
+	}
+
+	if expected["User-Agent"] != headers["User-Agent"] {
+		t.Errorf("Header 'User-Agent' expected '%s' and parsed: '%s'", expected["User-Agent"], headers["User-Agent"])
+	}
+}
+
+func TestHeaderEquals(t *testing.T) {
+	tests := []struct {
+		h1     string
+		h2     string
+		equals bool
+	}{
+		{"Content-Length", "content-length", true},
+		{"content-length", "Content-Length", true},
+		{"content-Pength", "Content-Length", false},
+		{"Host", "Content-Length", false},
+	}
+
+	for _, tc := range tests {
+		if HeadersEqual([]byte(tc.h1), []byte(tc.h2)) != tc.equals {
+			t.Error(tc)
+		}
+	}
+}
+
 func TestPath(t *testing.T) {
 	var path, payload []byte
 

protocol.go

@@ -42,13 +42,24 @@ func payloadScanner(data []byte, atEOF bool) (advance int, token []byte, err err
 }
 
 // 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)
+func payloadHeader(payloadType byte, uuid []byte, timing int64, latency int64) (header []byte) {
+	var sTime, sLatency string
+
+	sTime = strconv.FormatInt(timing, 10)
+	if latency != -1 {
+		sLatency = strconv.FormatInt(latency, 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)
+	headerLen := 1 + 1 + len(uuid) + 1 + len(sTime) + 1
+
+	if latency != -1 {
+		headerLen += len(sLatency) + 1
+	}
+
+	header = make([]byte, headerLen)
 	header[0] = payloadType
 	header[1] = ' '
 	header[2+len(uuid)] = ' '
@@ -57,6 +68,11 @@ func payloadHeader(payloadType byte, uuid []byte, timing int64) (header []byte)
 	copy(header[2:], uuid)
 	copy(header[3+len(uuid):], sTime)
 
+	if latency != -1 {
+		header[3+len(uuid)+len(sTime)] = ' '
+		copy(header[4+len(uuid)+len(sTime):], sLatency)
+	}
+
 	return header
 }
 

raw_socket_listener/listener.go

@@ -15,19 +15,36 @@ package rawSocket
 import (
 	"bytes"
 	"encoding/binary"
+	"fmt"
+	"github.com/buger/gor/proto"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcap"
+	"io"
 	"log"
 	"net"
+	"runtime"
 	"runtime/debug"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
+var _ = fmt.Println
+
+type packet struct {
+	srcIP		[]byte
+	data		[]byte
+	timestamp	time.Time
+}
+
 // Listener handle traffic capture
 type Listener struct {
+	mu sync.Mutex
 	// buffer of TCPMessages waiting to be send
 	// ID -> TCPMessage
-	messages map[string]*TCPMessage
+	messages map[tcpID]*TCPMessage
 
 	// Expect: 100-continue request is send in 2 tcp messages
 	// We store ACK aliases to merge this packets together
@@ -36,13 +53,13 @@ type Listener struct {
 	seqWithData map[uint32]uint32
 
 	// Ack -> Req
-	respAliases map[uint32]*request
+	respAliases map[uint32]*TCPMessage
 
 	// Ack -> ID
-	respWithoutReq map[uint32]string
+	respWithoutReq map[uint32]tcpID
 
 	// Messages ready to be send to client
-	packetsChan chan *TCPPacket
+	packetsChan chan *packet
 
 	// Messages ready to be send to client
 	messagesChan chan *TCPMessage
@@ -50,30 +67,44 @@ type Listener struct {
 	addr string // IP to listen
 	port uint16 // Port to listen
 
+	trackResponse bool
 	messageExpire time.Duration
 
-	conn net.PacketConn
-	quit chan bool
+	conn        net.PacketConn
+	pcapHandles []*pcap.Handle
+
+	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
+	EnginePcapFile
+)
+
 // NewListener creates and initializes new Listener object
-func NewListener(addr string, port string, expire time.Duration) (l *Listener) {
+func NewListener(addr string, port string, engine int, trackResponse bool, expire time.Duration) (l *Listener) {
 	l = &Listener{}
 
-	l.packetsChan = make(chan *TCPPacket, 10000)
+	l.packetsChan = make(chan *packet, 10000)
 	l.messagesChan = make(chan *TCPMessage, 10000)
 	l.quit = make(chan bool)
+	l.readyCh = make(chan bool, 1)
 
-	l.messages = make(map[string]*TCPMessage)
+	l.messages = make(map[tcpID]*TCPMessage)
 	l.ackAliases = make(map[uint32]uint32)
 	l.seqWithData = make(map[uint32]uint32)
-	l.respAliases = make(map[uint32]*request)
-	l.respWithoutReq = make(map[uint32]string)
+	l.respAliases = make(map[uint32]*TCPMessage)
+	l.respWithoutReq = make(map[uint32]tcpID)
+	l.trackResponse = trackResponse
 
 	l.addr = addr
 	_port, _ := strconv.Atoi(port)
@@ -89,7 +120,14 @@ func NewListener(addr string, port string, expire time.Duration) (l *Listener) {
 
 	// Special case for testing
 	if l.port != 0 {
-		go l.readRAWSocket()
+		switch engine {
+		case EnginePcap:
+			go l.readPcap()
+		case EnginePcapFile:
+			go l.readPcapFile()
+		default:
+			log.Fatal("Unknown traffic interception engine:", engine)
+		}
 	}
 
 	return
@@ -105,20 +143,15 @@ func (t *Listener) listen() {
 				t.conn.Close()
 			}
 			return
-		// We need to use channels to process each packet to avoid data races
 		case packet := <-t.packetsChan:
-			maxLen := len(packet.Data)
-			if maxLen > 500 {
-				maxLen = 500
-			}
-
-			t.processTCPPacket(packet)
-
+			tcpPacket := ParseTCPPacket(packet.srcIP, packet.data, packet.timestamp)
+			t.processTCPPacket(tcpPacket)
 		case <-gcTicker:
 			now := time.Now()
 
+			// Dispatch requests before responses
 			for _, message := range t.messages {
-				if now.Sub(message.Start) >= t.messageExpire {
+				if now.Sub(message.End) >= t.messageExpire {
 					t.dispatchMessage(message)
 				}
 			}
@@ -126,30 +159,72 @@ func (t *Listener) listen() {
 	}
 }
 
-func (t *Listener) dispatchMessage(message *TCPMessage) {
+func (t *Listener) deleteMessage(message *TCPMessage) {
+	delete(t.messages, message.ID())
 	delete(t.ackAliases, message.Ack)
-	delete(t.messages, message.ID)
+	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)
+
+	if !message.complete {
+		if !message.IsIncoming {
+			delete(t.respAliases, message.Ack)
+			delete(t.respWithoutReq, message.Ack)
+		}
+
+		return
+	}
 
 	if message.IsIncoming {
 		// If there were response before request
-		if respID, ok := t.respWithoutReq[message.ResponseAck]; ok {
-			if resp, rok := t.messages[respID]; rok {
-				if resp.RequestAck == 0 {
-					resp.RequestAck = message.Ack
-					resp.RequestStart = message.Start
+		// 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.setAssocMessage(message)
+					message.setAssocMessage(resp)
 
-					if resp.IsFinished() {
+					if resp.complete {
 						defer t.dispatchMessage(resp)
 					}
+					// }
 				}
 			}
+
+			if resp, ok := t.messages[message.ResponseID]; ok {
+				resp.setAssocMessage(message)
+			}
 		}
 	} else {
+		if message.AssocMessage == nil {
+			if responseRequest, ok := t.respAliases[message.Ack]; ok {
+				message.setAssocMessage(responseRequest)
+				responseRequest.setAssocMessage(message)
+			}
+		}
+
 		delete(t.respAliases, message.Ack)
 		delete(t.respWithoutReq, message.Ack)
 
 		// Do not track responses which have no associated requests
-		if message.RequestAck == 0 {
+		if message.AssocMessage == nil {
+			// log.Println("Can't dispatch resp", message.Seq, message.Ack, string(message.Bytes()))
 			return
 		}
 	}
@@ -157,8 +232,372 @@ func (t *Listener) dispatchMessage(message *TCPMessage) {
 	t.messagesChan <- message
 }
 
+// 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 isLoopback(device pcap.Interface) bool {
+	if len(device.Addresses) == 0 {
+		return false
+	}
+
+	switch device.Addresses[0].IP.String() {
+	case "127.0.0.1", "::1":
+		return true
+	}
+
+	return false
+}
+
+func listenAllInterfaces(addr string) bool {
+	switch addr {
+	case "", "0.0.0.0", "[::]", "::":
+		return true
+	default:
+		return false
+	}
+}
+
+func findPcapDevices(addr string) (interfaces []pcap.Interface, err error) {
+	devices, err := pcap.FindAllDevs()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, device := range devices {
+		if listenAllInterfaces(addr) && len(device.Addresses) > 0 || isLoopback(device) {
+			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.pcapHandles = append(t.pcapHandles, handle)
+
+			var bpfDstHost, bpfSrcHost string
+			var loopback = isLoopback(device)
+
+			if loopback {
+				var allAddr []string
+				for _, dc := range devices {
+					for _, addr := range dc.Addresses {
+						allAddr = append(allAddr, "(dst host "+addr.IP.String()+" and src host "+addr.IP.String()+")")
+					}
+				}
+
+				bpfDstHost = strings.Join(allAddr, " or ")
+				bpfSrcHost = bpfDstHost
+			} else {
+				for i, addr := range device.Addresses {
+					bpfDstHost += "dst host " + addr.IP.String()
+					bpfSrcHost += "src host " + addr.IP.String()
+					if i != len(device.Addresses)-1 {
+						bpfDstHost += " or "
+						bpfSrcHost += " or "
+					}
+				}
+			}
+
+			if bpfSupported {
+				var bpf string
+
+				if t.trackResponse {
+					bpf = "(tcp dst port " + strconv.Itoa(int(t.port)) + " and (" + bpfDstHost + ")) or (" + "tcp src port " + strconv.Itoa(int(t.port)) + " and (" + bpfSrcHost + "))"
+				} else {
+					bpf = "tcp dst port " + strconv.Itoa(int(t.port)) + " and (" + bpfDstHost + ")"
+				}
+
+				if err := handle.SetBPFFilter(bpf); err != nil {
+					log.Println("BPF filter error:", err, "Device:", device.Name, bpf)
+					wg.Done()
+					return
+				}
+			}
+			t.mu.Unlock()
+
+			var decoder gopacket.Decoder
+
+			// Special case for tunnel interface https://github.com/google/gopacket/issues/99
+			if handle.LinkType() == 12 {
+				decoder = layers.LayerTypeIPv4
+			} else {
+				decoder = handle.LinkType()
+			}
+
+			source := gopacket.NewPacketSource(handle, decoder)
+			source.Lazy = true
+			source.NoCopy = true
+
+			wg.Done()
+
+			var data, srcIP, dstIP []byte
+
+			for {
+				packet, err := source.NextPacket()
+
+				if err == io.EOF {
+					break
+				} else if err != nil {
+					continue
+				}
+
+				// We should remove network layer before parsing TCP/IP data
+				var of int
+				switch decoder {
+				case layers.LinkTypeEthernet:
+					of = 14
+				case layers.LinkTypePPP:
+					of = 1
+				case layers.LinkTypeFDDI:
+					of = 13
+				case layers.LinkTypeNull:
+					of = 4
+				case layers.LinkTypeLoop:
+					of = 4
+				case layers.LinkTypeRaw:
+					of = 0
+				case layers.LinkTypeLinuxSLL:
+					of = 16
+				default:
+					log.Println("Unknown packet layer", packet)
+					break
+				}
+
+				data = packet.Data()[of:]
+
+				version := uint8(data[0]) >> 4
+				ipLength := int(binary.BigEndian.Uint16(data[2:4]))
+
+				if version == 4 {
+					ihl := uint8(data[0]) & 0x0F
+
+					// Truncated IP info
+					if len(data) < int(ihl*4) {
+						continue
+					}
+
+					srcIP = data[12:16]
+					dstIP = data[16:20]
+
+					// Too small IP packet
+					if ipLength < 20 {
+						continue
+					}
+
+					// Invalid length
+					if int(ihl*4) > ipLength {
+						continue
+					}
+
+					if cmp := len(data) - ipLength; cmp > 0 {
+						data = data[:ipLength]
+					} else if cmp < 0 {
+						// Truncated packet
+						continue
+					}
+
+					data = data[ihl*4:]
+				} else {
+					// Truncated IP info
+					if len(data) < 40 {
+						continue
+					}
+
+					srcIP = data[8:24]
+					dstIP = data[24:40]
+
+					data = data[40:]
+				}
+
+				// Truncated TCP info
+				if len(data) <= 13 {
+					continue
+				}
+
+				dataOffset := (data[12] & 0xF0) >> 4
+				isFIN := data[13]&0x01 != 0
+
+				// 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) || isFIN {
+					if !bpfSupported {
+						destPort := binary.BigEndian.Uint16(data[2:4])
+						srcPort := binary.BigEndian.Uint16(data[0:2])
+
+						var addrCheck []byte
+
+						if destPort == t.port {
+							addrCheck = dstIP
+						}
+
+						if t.trackResponse && srcPort == t.port {
+							addrCheck = srcIP
+						}
+
+						if len(addrCheck) == 0 {
+							continue
+						}
+
+						addrMatched := false
+
+						if loopback {
+							for _, dc := range devices {
+								if addrMatched {
+									break
+								}
+								for _, a := range dc.Addresses {
+									if a.IP.Equal(net.IP(addrCheck)) {
+										addrMatched = true
+										break
+									}
+								}
+							}
+							addrMatched = true
+						} else {
+							for _, a := range device.Addresses {
+								if a.IP.Equal(net.IP(addrCheck)) {
+									addrMatched = true
+									break
+								}
+							}
+						}
+
+						if !addrMatched {
+							continue
+						}
+					}
+
+					t.packetsChan <- t.buildPacket(srcIP, data, packet.Metadata().Timestamp)
+				}
+			}
+		}(d)
+	}
+
+	wg.Wait()
+	t.readyCh <- true
+}
+
+func (t *Listener) readPcapFile() {
+	if handle, err := pcap.OpenOffline(t.addr); err != nil {
+		log.Fatal(err)
+	} else {
+		t.readyCh <- true
+		packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
+
+		for {
+			packet, err := packetSource.NextPacket()
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				log.Println("Error:", err)
+				continue
+			}
+
+			var addr, data []byte
+
+			if tcpLayer := packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
+				tcp, _ := tcpLayer.(*layers.TCP)
+				data = append(tcp.LayerContents(), tcp.LayerPayload()...)
+
+				if tcp.SrcPort >= 32768 && tcp.SrcPort <= 61000 {
+					copy(data[0:2], []byte{0, 0})
+					copy(data[2:4], []byte{0, 1})
+				} else {
+					copy(data[0:2], []byte{0, 1})
+					copy(data[2:4], []byte{0, 0})
+				}
+			} else {
+				continue
+			}
+
+			if ipLayer := packet.Layer(layers.LayerTypeIPv4); ipLayer != nil {
+				ip, _ := ipLayer.(*layers.IPv4)
+				addr = ip.SrcIP
+			} else if ipLayer = packet.Layer(layers.LayerTypeIPv6); ipLayer != nil {
+				ip, _ := ipLayer.(*layers.IPv6)
+				addr = ip.SrcIP
+			} else {
+				// log.Println("Can't find IP layer", packet)
+				continue
+			}
+
+			dataOffset := (data[12] & 0xF0) >> 4
+			isFIN := data[13]&0x01 != 0
+
+			// 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) && !isFIN {
+				continue
+			}
+
+			t.packetsChan <- t.buildPacket(addr, data, packet.Metadata().Timestamp)
+		}
+	}
+}
+
 func (t *Listener) readRAWSocket() {
-	conn, e := net.ListenPacket("ip4:tcp", t.addr)
+	conn, e := net.ListenPacket("ip:tcp", t.addr)
 	t.conn = conn
 
 	if e != nil {
@@ -169,6 +608,8 @@ func (t *Listener) readRAWSocket() {
 
 	buf := make([]byte, 64*1024) // 64kb
 
+	t.readyCh <- true
+
 	for {
 		// Note: ReadFrom receive messages without IP header
 		n, addr, err := t.conn.ReadFrom(buf)
@@ -183,17 +624,26 @@ func (t *Listener) readRAWSocket() {
 
 		if n > 0 {
 			if t.isValidPacket(buf[:n]) {
-				newBuf := make([]byte, n)
-				copy(newBuf, buf[:n])
-
-				go func(newBuf []byte) {
-					t.packetsChan <- ParseTCPPacket(addr, newBuf)
-				}(newBuf)
+				t.packetsChan <- t.buildPacket([]byte(addr.(*net.IPAddr).IP), buf[:n], time.Now())
 			}
 		}
 	}
 }
 
+func (t *Listener) buildPacket(packetSrcIP []byte, packetData []byte, timestamp time.Time) *packet {
+	copyPacketSrcIP := make([]byte, 16)
+	copyPacketData := make([]byte, len(packetData))
+
+	copy(copyPacketSrcIP, packetSrcIP)
+	copy(copyPacketData, packetSrcIP)
+
+	return &packet{
+		srcIP: packetSrcIP,
+		data: packetData,
+		timestamp:timestamp,
+	}
+}
+
 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
@@ -201,7 +651,7 @@ func (t *Listener) isValidPacket(buf []byte) bool {
 	srcPort := binary.BigEndian.Uint16(buf[0:2])
 
 	// Because RAW_SOCKET can't be bound to port, we have to control it by ourself
-	if destPort == t.port || srcPort == t.port {
+	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
 
@@ -216,9 +666,6 @@ func (t *Listener) isValidPacket(buf []byte) bool {
 	return false
 }
 
-var bExpect100ContinueCheck = []byte("Expect: 100-continue")
-var bPOST = []byte("POST")
-
 // Trying to add packet to existing message or creating new message
 //
 // For TCP message unique id is Acknowledgment number (see tcp_packet.go)
@@ -234,89 +681,151 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 
 	isIncoming := packet.DestPort == t.port
 
+	// 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 m.AssocMessage != nil {
+					m.setAssocMessage(nil)
+				}
+
+				for _, pkt := range m.packets {
+					// log.Println("Updating ack", parentAck, pkt.Ack)
+					pkt.UpdateAck(parentAck)
+					// Re-queue this packets
+					t.processTCPPacket(pkt)
+				}
+			}
+		}
+
 		t.ackAliases[packet.Ack] = parentAck
-		packet.Ack = parentAck
-		delete(t.seqWithData, packet.Seq)
+		packet.UpdateAck(parentAck)
+	}
+
+	if isIncoming && packet.IsFIN {
+		if ma, ok := t.respAliases[packet.Seq]; ok {
+			if ma.packets[0].SrcPort == packet.SrcPort {
+				packet.UpdateAck(ma.Ack)
+			}
+		}
 	}
 
 	if alias, ok := t.ackAliases[packet.Ack]; ok {
-		packet.Ack = alias
+		packet.UpdateAck(alias)
 	}
 
-	var responseRequest *request
+	var responseRequest *TCPMessage
 
 	if !isIncoming {
 		responseRequest, _ = t.respAliases[packet.Ack]
 	}
 
-	mID := packet.Addr.String() + strconv.Itoa(int(packet.DestPort)) + strconv.Itoa(int(packet.Ack))
-
-	message, ok := t.messages[mID]
+	message, ok := t.messages[packet.ID]
 
 	if !ok {
-		message = NewTCPMessage(mID, packet.Seq, packet.Ack, isIncoming)
-		t.messages[mID] = message
+		message = NewTCPMessage(packet.Seq, packet.Ack, isIncoming, packet.timestamp)
+		t.messages[packet.ID] = message
 
 		if !isIncoming {
 			if responseRequest != nil {
-				message.RequestStart = responseRequest.start
-				message.RequestAck = responseRequest.ack
+				message.setAssocMessage(responseRequest)
+				responseRequest.setAssocMessage(message)
 			} else {
-				t.respWithoutReq[packet.Ack] = mID
+				t.respWithoutReq[packet.Ack] = packet.ID
 			}
 		}
 	}
 
-	// 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
-
-			// In case if sequence packet came first
-			for _id, m := range t.messages {
-				if m.Seq == seq {
-					t.ackAliases[m.Ack] = packet.Ack
-
-					for _, pkt := range m.packets {
-						message.AddPacket(pkt)
-					}
-
-					delete(t.messages, _id)
-				}
-			}
-
-			// Removing `Expect: 100-continue` header
-			packet.Data = append(packet.Data[:len(packet.Data)-24], packet.Data[len(packet.Data)-2:]...)
-		}
-	}
-
-	if isIncoming {
-		// If message have multiple packets, delete previous alias
-		if len(message.packets) > 0 {
-			delete(t.respAliases, message.ResponseAck)
-		}
-
-		responseAck := packet.Seq + uint32(message.BodySize()) + uint32(len(packet.Data))
-		t.respAliases[responseAck] = &request{message.Start, message.Ack}
-
-		message.ResponseAck = responseAck
-	}
-
 	// Adding packet to message
 	message.AddPacket(packet)
 
+	// Handling Expect: 100-continue requests
+	if message.expectType == httpExpect100Continue && len(message.packets) == message.headerPacket+1 {
+		seq := packet.Seq + uint32(message.Size())
+		t.seqWithData[seq] = packet.Ack
+		message.DataSeq = seq
+		message.complete = false
+
+		// In case if sequence packet came first
+		for _, m := range t.messages {
+			if m.Seq == seq {
+				t.deleteMessage(m)
+				if m.AssocMessage != nil {
+					message.setAssocMessage(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 = proto.DeleteHeader(packet.Data, bExpectHeader)
+	}
+
+	// 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() {
-		t.dispatchMessage(message)
+	if message.complete {
+		// log.Println("COMPLETE!", isIncoming, message)
+		if isIncoming {
+			if t.trackResponse {
+				// log.Println("Found response!", message.ResponseID, t.messages)
+
+				if resp, ok := t.messages[message.ResponseID]; ok {
+					if resp.complete {
+						t.dispatchMessage(resp)
+					}
+
+					t.dispatchMessage(message)
+				}
+			} else {
+				t.dispatchMessage(message)
+			}
+		} else {
+			if message.AssocMessage == nil {
+				return
+			}
+
+			if req, ok := t.messages[message.AssocMessage.ID()]; ok {
+				if req.complete {
+					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.messagesChan
+func (t *Listener) Receiver() chan *TCPMessage {
+	return t.messagesChan
 }
 
 func (t *Listener) Close() {
@@ -324,5 +833,10 @@ func (t *Listener) Close() {
 	if t.conn != nil {
 		t.conn.Close()
 	}
+
+	for _, h := range t.pcapHandles {
+		h.Close()
+	}
+
 	return
 }

raw_socket_listener/listener_test.go

@@ -2,7 +2,9 @@ package rawSocket
 
 import (
 	"bytes"
-	_ "log"
+	"log"
+	"math/rand"
+	"sync/atomic"
 	"testing"
 	"time"
 )
@@ -10,21 +12,21 @@ import (
 func TestRawListenerInput(t *testing.T) {
 	var req, resp *TCPMessage
 
-	listener := NewListener("", "0", 10*time.Millisecond)
+	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
 	defer listener.Close()
 
-	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1"))
-
-	listener.packetsChan <- reqPacket
+	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\n\r\n"), time.Now())
 
 	respAck := reqPacket.Seq + uint32(len(reqPacket.Data))
-	respPacket := buildPacket(false, respAck, reqPacket.Seq+1, []byte("HTTP/1.1 200 OK"))
-	listener.packetsChan <- respPacket
+	respPacket := buildPacket(false, respAck, reqPacket.Seq+1, []byte("HTTP/1.1 200 OK\r\n\r\n"), time.Now())
+
+	listener.packetsChan <- reqPacket.dump()
+	listener.packetsChan <- respPacket.dump()
 
 	select {
 	case req = <-listener.messagesChan:
 	case <-time.After(time.Millisecond):
-		t.Error("Should return respose immediately")
+		t.Error("Should return request immediately")
 		return
 	}
 
@@ -34,7 +36,7 @@ func TestRawListenerInput(t *testing.T) {
 
 	select {
 	case resp = <-listener.messagesChan:
-	case <-time.After(time.Millisecond):
+	case <-time.After(20 * time.Millisecond):
 		t.Error("Should return response immediately")
 		return
 	}
@@ -44,18 +46,80 @@ func TestRawListenerInput(t *testing.T) {
 	}
 }
 
+func TestRawListenerInputResponseByClose(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"), time.Now())
+
+	respAck := reqPacket.Seq + uint32(len(reqPacket.Data))
+	respPacket := buildPacket(false, respAck, reqPacket.Seq+1, []byte("HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nasd"), time.Now())
+	finPacket := buildPacket(false, respAck, reqPacket.Seq+2, []byte(""), time.Now())
+	finPacket.IsFIN = true
+
+	listener.packetsChan <- reqPacket.dump()
+	listener.packetsChan <- respPacket.dump()
+	listener.packetsChan <- finPacket.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"), time.Now())
+
+	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", 10*time.Millisecond)
+	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
 	defer listener.Close()
 
-	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1"))
-	respPacket := buildPacket(false, 1+uint32(len(reqPacket.Data)), 2, []byte("HTTP/1.1 200 OK"))
+	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\n\r\n"), time.Now())
+	respPacket := buildPacket(false, 1+uint32(len(reqPacket.Data)), 2, []byte("HTTP/1.1 200 OK\r\n\r\n"), time.Now())
 
 	// If response packet comes before request
-	listener.packetsChan <- respPacket
-	listener.packetsChan <- reqPacket
+	listener.packetsChan <- respPacket.dump()
+	listener.packetsChan <- reqPacket.dump()
 
 	select {
 	case req = <-listener.messagesChan:
@@ -84,28 +148,69 @@ func TestRawListenerResponse(t *testing.T) {
 	}
 }
 
-func TestRawListener100Continue(t *testing.T) {
-	var req, resp *TCPMessage
-
-	listener := NewListener("", "0", 10*time.Millisecond)
+func TestShort100Continue(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\nContent-Length: 2\r\nExpect: 100-continue\r\n\r\n"))
+	reqPacket1 := buildPacket(true, 1, 1, []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\nExpect: 100-continue\r\n\r\n"), time.Now())
 	// 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"))
+	reqPacket2 := buildPacket(true, 2, reqPacket1.Seq+uint32(len(reqPacket1.Data)), []byte("a"), time.Now())
+	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+1, []byte("b"), time.Now())
 
-	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n"))
+	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n\r\n"), time.Now())
 
 	// panic(int(uint32(len(reqPacket1.Data)) + uint32(len(reqPacket2.Data)) + uint32(len(reqPacket3.Data))))
-	respPacket2 := buildPacket(false, reqPacket3.Seq+2 /* len of data */, 2, []byte("HTTP/1.1 200 OK\r\n"))
+	respPacket2 := buildPacket(false, reqPacket3.Seq+1 /* len of data */, 2, []byte("HTTP/1.1 200 OK\r\n\r\n"), time.Now())
 
-	listener.processTCPPacket(reqPacket1)
-	listener.processTCPPacket(reqPacket2)
-	listener.processTCPPacket(reqPacket3)
+	result := []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")
 
-	listener.processTCPPacket(respPacket1)
-	listener.processTCPPacket(respPacket2)
+	testRawListener100Continue(t, listener, result, reqPacket1, reqPacket2, reqPacket3, respPacket1, respPacket2)
+}
+
+// Response comes before Request
+func Test100ContinueWrongOrder(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\nContent-Length: 2\r\nExpect: 100-continue\r\n\r\n"), time.Now())
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, 2, reqPacket1.Seq+uint32(len(reqPacket1.Data)), []byte("a"), time.Now())
+	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+1, []byte("b"), time.Now())
+
+	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n"), time.Now())
+
+	// 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\r\n"), time.Now())
+
+	result := []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")
+
+	testRawListener100Continue(t, listener, result, respPacket1, respPacket2, reqPacket1, reqPacket2, reqPacket3)
+}
+
+func TestAlt100ContinueHeaderOrder(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\nExpect: 100-continue\r\nContent-Length: 2\r\n\r\n"), time.Now())
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, 2, reqPacket1.Seq+uint32(len(reqPacket1.Data)), []byte("a"), time.Now())
+	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+1, []byte("b"), time.Now())
+
+	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n"), time.Now())
+
+	// 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\r\n"), time.Now())
+
+	result := []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")
+
+	testRawListener100Continue(t, listener, result, reqPacket1, reqPacket2, reqPacket3, respPacket1, respPacket2)
+}
+
+func testRawListener100Continue(t *testing.T, listener *Listener, result []byte, packets ...*TCPPacket) {
+	var req, resp *TCPMessage
+	for _, p := range packets {
+		listener.packetsChan <- p.dump()
+	}
 
 	select {
 	case req = <-listener.messagesChan:
@@ -115,7 +220,7 @@ func TestRawListener100Continue(t *testing.T) {
 		return
 	}
 
-	if !bytes.Equal(req.Bytes(), []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")) {
+	if !bytes.Equal(req.Bytes(), result) {
 		t.Error("Should receive full message", string(req.Bytes()))
 	}
 
@@ -140,59 +245,233 @@ func TestRawListener100Continue(t *testing.T) {
 	}
 }
 
-// Response comes before Request
-func TestRawListener100ContinueWrongOrder(t *testing.T) {
-    var req, resp *TCPMessage
+func testChunkedSequence(t *testing.T, listener *Listener, packets ...*TCPPacket) {
+	var r, req, resp *TCPMessage
 
-    listener := NewListener("", "0", 10*time.Millisecond)
-    defer listener.Close()
+	for _, p := range packets {
+		listener.packetsChan <- p.dump()
+	}
 
-    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"))
+	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
+	}
 
-    respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n"))
+	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()))
+	}
 
-    // panic(int(uint32(len(reqPacket1.Data)) + uint32(len(reqPacket2.Data)) + uint32(len(reqPacket3.Data))))
-    respPacket2 := buildPacket(false, reqPacket3.Seq+2 /* len of data */, 2, []byte("HTTP/1.1 200 OK\r\n"))
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
 
-    listener.processTCPPacket(respPacket1)
-    listener.processTCPPacket(respPacket2)
+	if resp.IsIncoming {
+		t.Error("Should be response")
+	}
 
-    listener.processTCPPacket(reqPacket1)
-    listener.processTCPPacket(reqPacket2)
-    listener.processTCPPacket(reqPacket3)
+	if !bytes.Equal(resp.UUID(), req.UUID()) {
+		t.Error("Resp and Req UUID should be equal", string(resp.UUID()), string(req.UUID()))
+	}
 
-    select {
-    case req = <-listener.messagesChan:
-        break
-    case <-time.After(11 * time.Millisecond):
-        t.Error("Should return response after expire time")
-        return
-    }
+	time.Sleep(20 * time.Millisecond)
 
-    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 len(listener.packetsChan) != 0 {
+		t.Fatal("packetsChan non empty:", listener.packetsChan)
+	}
 
-    if !req.IsIncoming {
-        t.Error("Should be request")
-    }
+	if len(listener.messagesChan) != 0 {
+		t.Fatal("messagesChan non empty:", <-listener.messagesChan)
+	}
 
-    select {
-    case resp = <-listener.messagesChan:
-        break
-    case <-time.After(21 * time.Millisecond):
-        t.Error("Should return response after expire time")
-        return
-    }
+	if len(listener.messages) != 0 {
+		t.Fatal("Messages non empty:", listener.messages)
+	}
 
-    if resp.IsIncoming {
-        t.Error("Should be response")
-    }
+	if len(listener.ackAliases) != 0 {
+		t.Fatal("ackAliases non empty:", listener.ackAliases)
+	}
 
-    if !bytes.Equal(resp.UUID(), req.UUID()) {
-        t.Error("Resp and Req UUID should be equal")
-    }
+	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"), time.Now())
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, 2, reqPacket1.Seq+uint32(len(reqPacket1.Data)), []byte("1\r\na\r\n"), time.Now())
+	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+uint32(len(reqPacket2.Data)), []byte("1\r\nb\r\n"), time.Now())
+	reqPacket4 := buildPacket(true, 2, reqPacket3.Seq+uint32(len(reqPacket3.Data)), []byte("0\r\n\r\n"), time.Now())
+
+	respPacket1 := buildPacket(false, 10, 3, []byte("HTTP/1.1 100 Continue\r\n\r\n"), time.Now())
+
+	// 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\r\n"), time.Now())
+
+	// 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"), time.Now())
+	// Packet with data have different Seq
+	reqPacket2 := buildPacket(true, ack, seq+47, []byte("1\r\na\r\n"), time.Now())
+	reqPacket3 := buildPacket(true, ack, reqPacket2.Seq+5, []byte("1\r\nb\r\n"), time.Now())
+	reqPacket4 := buildPacket(true, ack, reqPacket3.Seq+5, []byte("0\r\n\r\n"), time.Now())
+
+	respPacket := buildPacket(false, reqPacket4.Seq+5 /* len of data */, ack, []byte("HTTP/1.1 200 OK\r\n\r\n"), time.Now())
+
+	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, time.Now()),
+		buildPacket(false, seq+uint32(len(data)), seq2, []byte("HTTP/1.1 200 OK\r\n\r\n"), time.Now()),
+	}
+}
+
+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"), time.Now()),
+		buildPacket(false, seq+18, seq2, []byte("HTTP/1.1 200 OK\r\n\r\n"), time.Now()),
+	}
+}
+
+// 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/tcp_message.go

@@ -3,13 +3,17 @@ package rawSocket
 import (
 	"bytes"
 	"crypto/sha1"
+	"encoding/binary"
 	"encoding/hex"
 	"github.com/buger/gor/proto"
 	"log"
+	"net"
 	"strconv"
 	"time"
 )
 
+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
 //
@@ -17,12 +21,14 @@ import (
 // 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
-	Seq          uint32
-	Ack          uint32
-	ResponseAck  uint32
-	RequestStart time.Time
-	RequestAck   uint32
+	Seq         uint32
+	Ack         uint32
+	ResponseAck uint32
+	ResponseID  tcpID
+	DataAck     uint32
+	DataSeq     uint32
+
+	AssocMessage *TCPMessage
 	Start        time.Time
 	End          time.Time
 	IsIncoming   bool
@@ -30,12 +36,29 @@ type TCPMessage struct {
 	packets []*TCPPacket
 
 	delChan chan *TCPMessage
+
+	/* HTTP specific variables */
+	methodType    httpMethodType
+	bodyType      httpBodyType
+	expectType    httpExpectType
+	seqMissing    bool
+	headerPacket  int
+	contentLength int
+	complete      bool
 }
 
 // NewTCPMessage pointer created from a Acknowledgment number and a channel of messages readuy to be deleted
-func NewTCPMessage(ID string, Seq, Ack uint32, IsIncoming bool) (msg *TCPMessage) {
-	msg = &TCPMessage{ID: ID, Seq: Seq, Ack: Ack, IsIncoming: IsIncoming}
-	msg.Start = time.Now()
+func NewTCPMessage(Seq, Ack uint32, IsIncoming bool, timestamp time.Time) (msg *TCPMessage) {
+	msg = &TCPMessage{Seq: Seq, Ack: Ack, IsIncoming: IsIncoming, Start: timestamp}
+
+	return
+}
+
+func (t *TCPMessage) packetsData() (d [][]byte) {
+	d = make([][]byte, len(t.packets))
+	for i, p := range t.packets {
+		d[i] = p.Data
+	}
 
 	return
 }
@@ -51,13 +74,13 @@ func (t *TCPMessage) Bytes() (output []byte) {
 
 // Size returns total body size
 func (t *TCPMessage) BodySize() (size int) {
-	if len(t.packets) == 0 {
+	if len(t.packets) == 0 || t.headerPacket == -1 {
 		return 0
 	}
 
-	size += len(proto.Body(t.packets[0].Data))
+	size += len(proto.Body(t.packets[t.headerPacket].Data))
 
-	for _, p := range t.packets[1:] {
+	for _, p := range t.packets[t.headerPacket+1:] {
 		size += len(p.Data)
 	}
 
@@ -89,84 +112,387 @@ func (t *TCPMessage) AddPacket(packet *TCPPacket) {
 		}
 	}
 
-	if packetFound {
-		log.Println("Received packet with same sequence")
-	} else {
+	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 {
+		} else if packet.Seq < t.packets[0].Seq {
 			t.packets = append([]*TCPPacket{packet}, t.packets...)
-		}
-
-		t.End = time.Now()
-	}
-}
-
-// 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")) {
-			return true
-		} else {
-			// Sometimes header comes after the body :(
-			if bytes.Equal(m, []byte("POST")) || bytes.Equal(m, []byte("PUT ")) || bytes.Equal(m, []byte("PATC")) {
-				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
-					}
+			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
 				}
 			}
 		}
-	} else {
-		// Request not found
-		// Can be because response came first or request request was just missing
-		if t.RequestAck == 0 {
-			return false
+
+		if t.IsIncoming {
+			t.End = time.Now()
+		} else {
+			t.End = time.Now().Add(time.Millisecond)
 		}
 
-		if length := proto.Header(payload, []byte("Content-Length")); len(length) > 0 {
-			if length[0] == '0' {
-				return true
-			}
+		if packet.OrigAck != 0 {
+			t.DataAck = packet.OrigAck
+		}
 
-			l, _ := strconv.Atoi(string(length))
+		if packet.timestamp.Before(t.Start) {
+			t.Start = packet.timestamp
+		}
+	}
 
-			// 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
+	t.checkSeqIntegrity()
+	t.updateHeadersPacket()
+	t.updateMethodType()
+	t.updateBodyType()
+	t.checkIfComplete()
+	t.check100Continue()
+}
+
+// Check if there is missing packet
+func (t *TCPMessage) checkSeqIntegrity() {
+	if len(t.packets) == 1 {
+		t.seqMissing = false
+	}
+
+	offset := len(t.packets) - 1
+
+	if t.packets[offset].IsFIN {
+		offset--
+
+		if offset < 0 {
+			return
+		}
+	}
+
+	for i, p := range t.packets[:offset] {
+		if p.IsFIN {
+			continue
+		}
+
+		// If final packet
+		if len(t.packets) == i+1 {
+			t.seqMissing = false
+			return
+		}
+		np := t.packets[i+1]
+
+		nextSeq := p.Seq + uint32(len(p.Data))
+
+		if np.Seq != nextSeq {
+			if t.expectType == httpExpect100Continue {
+				if np.Seq != nextSeq+22 {
+					t.seqMissing = true
+					return
+				}
+			} else {
+				t.seqMissing = true
+				return
 			}
 		}
 	}
 
-	return false
+	t.seqMissing = false
+}
+
+var bEmptyLine = []byte("\r\n\r\n")
+var bChunkEnd = []byte("0\r\n\r\n")
+
+func (t *TCPMessage) updateHeadersPacket() {
+	if len(t.packets) == 1 {
+		t.headerPacket = -1
+	}
+
+	if t.headerPacket != -1 {
+		return
+	}
+
+	if t.seqMissing {
+		return
+	}
+
+	for i, p := range t.packets {
+		if bytes.LastIndex(p.Data, bEmptyLine) != -1 {
+			t.headerPacket = i
+			return
+		}
+	}
+
+	return
+}
+
+// isMultipart returns true if message contains from multiple tcp packets
+func (t *TCPMessage) checkIfComplete() {
+	if t.seqMissing || t.headerPacket == -1 {
+		return
+	}
+
+	if t.methodType == httpMethodNotFound {
+		return
+	}
+
+	// Responses can be emitted only if we found request
+	if !t.IsIncoming && t.AssocMessage == nil {
+		return
+	}
+
+	// If one GET, OPTIONS, or HEAD request
+	if t.methodType == httpMethodWithoutBody {
+		t.complete = true
+	} else {
+		switch t.bodyType {
+		case httpBodyEmpty:
+			t.complete = true
+		case httpBodyContentLength:
+			if t.contentLength == 0 || t.contentLength == t.BodySize() {
+				t.complete = true
+			}
+		case httpBodyChunked:
+			lastPacket := t.packets[len(t.packets)-1]
+			if bytes.LastIndex(lastPacket.Data, bChunkEnd) != -1 {
+				t.complete = true
+			}
+		default:
+			if len(t.packets) == 0 {
+				return
+			}
+
+			last := t.packets[len(t.packets)-1]
+			if last.IsFIN {
+				t.complete = true
+			}
+		}
+	}
+}
+
+type httpMethodType uint8
+
+const (
+	httpMethodNotSet      httpMethodType = 0
+	httpMethodWithBody    httpMethodType = 1
+	httpMethodWithoutBody httpMethodType = 2
+	httpMethodNotFound    httpMethodType = 3
+)
+
+var methodsWithBody = [][]byte{
+	[]byte("POST"),
+	[]byte("PUT"),
+	[]byte("PATCH"),
+	[]byte("CONNECT"),
+}
+
+func (t *TCPMessage) updateMethodType() {
+	// if there is cache
+	if t.methodType != httpMethodNotSet && t.methodType != httpMethodNotFound {
+		return
+	}
+
+	d := t.packets[0].Data
+
+	// Minimum length fo request: GET / HTTP/1.1\r\n
+
+	if len(d) < 16 {
+		t.methodType = httpMethodNotFound
+		return
+	}
+
+	if t.IsIncoming {
+		var method []byte
+
+		if mIdx := bytes.IndexByte(d[:8], ' '); mIdx != -1 {
+			method = d[:mIdx]
+
+			// Check that after method we have absolute or relative path
+			switch d[mIdx+1] {
+			case '/', 'h', '*':
+			default:
+				t.methodType = httpMethodNotFound
+				return
+			}
+		} else {
+			t.methodType = httpMethodNotFound
+			return
+		}
+
+		for _, m := range methodsWithBody {
+			if len(m) == len(method) && bytes.Equal(m, method) {
+				t.methodType = httpMethodWithBody
+				return
+			}
+		}
+
+		t.methodType = httpMethodWithoutBody
+	} else {
+		if !bytes.Equal(d[:6], []byte("HTTP/1")) {
+			t.methodType = httpMethodNotFound
+			return
+		}
+
+		t.methodType = httpMethodWithBody
+	}
+}
+
+type httpBodyType uint8
+
+const (
+	httpBodyNotSet          httpBodyType = 0
+	httpBodyEmpty           httpBodyType = 1
+	httpBodyContentLength   httpBodyType = 2
+	httpBodyChunked         httpBodyType = 3
+	httpBodyConnectionClose httpBodyType = 4
+)
+
+func (t *TCPMessage) updateBodyType() {
+	// if there is cache
+	if t.bodyType != httpBodyNotSet {
+		return
+	}
+
+	// Headers not received
+	if t.headerPacket == -1 {
+		return
+	}
+
+	var lengthB, encB, connB []byte
+
+	proto.ParseHeaders(t.packetsData(), func(header, value []byte)bool{
+		if proto.HeadersEqual(header, []byte("Content-Length")) {
+			lengthB = value
+			return false
+		}
+
+		if proto.HeadersEqual(header, []byte("Transfer-Encoding")) {
+			encB = value
+			return false
+		}
+
+		if proto.HeadersEqual(header, []byte("Connection")) {
+			connB = value
+		}
+
+		return true
+	})
+
+	switch t.methodType {
+	case httpMethodNotFound:
+		return
+	case httpMethodWithoutBody:
+		t.bodyType = httpBodyEmpty
+		return
+	case httpMethodWithBody:
+		if len(lengthB) > 0 {
+			t.contentLength, _ = strconv.Atoi(string(lengthB))
+
+			if t.contentLength == 0 {
+				t.bodyType = httpBodyEmpty
+			} else {
+				t.bodyType = httpBodyContentLength
+			}
+			return
+		}
+
+		if len(encB) > 0 {
+			t.bodyType = httpBodyChunked
+			return
+		}
+
+		if len(connB) > 0 && bytes.Equal(connB, []byte("close")) {
+			t.bodyType = httpBodyConnectionClose
+			return
+		}
+	}
+
+	t.bodyType = httpBodyEmpty
+}
+
+type httpExpectType uint8
+
+const (
+	httpExpectNotSet      httpExpectType = 0
+	httpExpectEmpty       httpExpectType = 1
+	httpExpect100Continue httpExpectType = 2
+)
+
+var bExpectHeader = []byte("Expect")
+var bExpect100Value = []byte("100-continue")
+
+func (t *TCPMessage) check100Continue() {
+	if t.expectType != httpExpectNotSet || len(t.packets[0].Data) < 25 {
+		return
+	}
+
+	if t.methodType != httpMethodWithBody {
+		return
+	}
+
+	if t.seqMissing || t.headerPacket == -1 {
+		return
+	}
+
+	last := t.packets[len(t.packets)-1]
+	// reading last 4 bytes for double CRLF
+	if !bytes.HasSuffix(last.Data, bEmptyLine) {
+		return
+	}
+
+	var expectB []byte
+	proto.ParseHeaders(t.packetsData(), func(header, value []byte)bool{
+		if proto.HeadersEqual(header, bExpectHeader) {
+			expectB = value
+			return false
+		}
+
+		return true
+	})
+
+	if len(expectB) > 0 && bytes.Equal(bExpect100Value, expectB) {
+		t.expectType = httpExpect100Continue
+		return
+	}
+
+	t.expectType = httpExpectEmpty
+}
+
+func (t *TCPMessage) setAssocMessage(m *TCPMessage) {
+	t.AssocMessage = m
+	t.checkIfComplete()
+}
+
+// UpdateResponseAck should be called after packet is added
+func (t *TCPMessage) UpdateResponseAck() uint32 {
+	lastPacket := t.packets[len(t.packets)-1]
+	if lastPacket.IsFIN && len(t.packets) > 1 {
+		lastPacket = t.packets[len(t.packets)-2]
+	}
+
+	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) 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 {
-		key = strconv.AppendInt(key, t.RequestStart.UnixNano(), 10)
-		key = strconv.AppendUint(key, uint64(t.RequestAck), 10)
+		// 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)
@@ -175,3 +501,11 @@ func (t *TCPMessage) UUID() []byte {
 
 	return uuid
 }
+
+func (t *TCPMessage) ID() tcpID {
+	return t.packets[0].ID
+}
+
+func (t *TCPMessage) IP() net.IP {
+	return net.IP(t.packets[0].Addr)
+}

raw_socket_listener/tcp_message_test.go

@@ -2,63 +2,66 @@ package rawSocket
 
 import (
 	"bytes"
+	"encoding/binary"
 	_ "log"
-	"net"
-	"strconv"
 	"testing"
+	"time"
 )
 
-func buildPacket(isIncoming bool, Ack, Seq uint32, Data []byte) (packet *TCPPacket) {
-	packet = &TCPPacket{
-		Addr: &net.IPAddr{net.IP{}, ""},
-		Ack:  Ack,
-		Seq:  Seq,
-		Data: Data,
-	}
+func buildPacket(isIncoming bool, Ack, Seq uint32, Data []byte, timestamp time.Time) (packet *TCPPacket) {
+	var srcPort, destPort uint16
 
 	// For tests `listening` port is 0
 	if isIncoming {
-		packet.SrcPort = 1
+		srcPort = 1
 	} else {
-		packet.DestPort = 1
+		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, timestamp)
+
 	return packet
 }
 
 func buildMessage(p *TCPPacket) *TCPMessage {
-	id := p.Addr.String() + strconv.Itoa(int(p.DestPort)) + strconv.Itoa(int(p.Ack))
-
 	isIncoming := false
 	if p.SrcPort == 1 {
 		isIncoming = true
 	}
 
-	m := NewTCPMessage(id, p.Seq, p.Ack, isIncoming)
+	m := NewTCPMessage(p.Seq, p.Ack, isIncoming, p.timestamp)
 	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")))
+	msg := buildMessage(buildPacket(true, 1, 1, []byte("a"), time.Now()))
+	msg.AddPacket(buildPacket(true, 1, 2, []byte("b"), time.Now()))
 
 	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")))
+	msg = buildMessage(buildPacket(true, 1, 2, []byte("b"), time.Now()))
+	msg.AddPacket(buildPacket(true, 1, 1, []byte("a"), time.Now()))
 
 	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")))
+	msg = buildMessage(buildPacket(true, 1, 1, []byte("a"), time.Now()))
+	msg.AddPacket(buildPacket(true, 1, 1, []byte("a"), time.Now()))
 
 	if !bytes.Equal(msg.Bytes(), []byte("a")) {
 		t.Error("Should ignore packet with same Seq")
@@ -66,8 +69,8 @@ func TestTCPMessagePacketsOrder(t *testing.T) {
 }
 
 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")))
+	msg := buildMessage(buildPacket(true, 1, 1, []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\na"), time.Now()))
+	msg.AddPacket(buildPacket(true, 1, 2, []byte("b"), time.Now()))
 
 	if msg.BodySize() != 2 {
 		t.Error("Should count only body", msg.BodySize())
@@ -78,76 +81,178 @@ func TestTCPMessageSize(t *testing.T) {
 	}
 }
 
-func TestTCPMessageIsFinished(t *testing.T) {
-	methodsWithoutBodies := []string{"GET", "OPTIONS", "HEAD"}
+func TestTCPMessageIsComplete(t *testing.T) {
+	testCases := []struct {
+		direction         bool
+		payload           string
+		assocMessage      bool
+		expectedCompleted bool
+	}{
+		{true, "GET / HTTP/1.1\r\n\r\n", false, true},
+		{true, "HEAD / HTTP/1.1\r\n\r\n", false, true},
+		{false, "HTTP/1.1 200 OK\r\n\r\n", true, true},
+		{true, "POST / HTTP/1.1\r\nContent-Length: 1\r\n\r\na", false, true},
+		{true, "PUT / HTTP/1.1\r\nContent-Length: 1\r\n\r\na", false, true},
+		{false, "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n", true, true},
+		{false, "HTTP/1.1 200 OK\r\nContent-Length: 1\r\n\r\na", true, true},
+		{false, "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n0\r\n\r\n", true, true},
 
-	for _, m := range methodsWithoutBodies {
-		msg := buildMessage(buildPacket(true, 1, 1, []byte(m+" / HTTP/1.1")))
+		// chunked not finished
+		{false, "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n", true, false},
 
-		if !msg.IsFinished() {
-			t.Error(m, " request should be finished")
+		// content-length != actual length
+		{true, "POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\na", false, false},
+		{false, "HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\na", true, false},
+		// non-valid http request
+		{true, "UNKNOWN asd HTTP/1.1\r\n\r\n", false, false},
+
+		// response without associated request
+		{false, "HTTP/1.1 200 OK\r\n\r\n", false, false},
+	}
+
+	for _, tc := range testCases {
+		msg := buildMessage(buildPacket(tc.direction, 1, 1, []byte(tc.payload), time.Now()))
+		if tc.assocMessage {
+			msg.AssocMessage = &TCPMessage{}
 		}
-	}
+		msg.checkIfComplete()
 
-	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")
+		if msg.complete != tc.expectedCompleted {
+			t.Errorf("Payload %s: Expected %t, got %t.", tc.payload, tc.expectedCompleted, msg.complete)
 		}
-
-		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.RequestAck = 1
-	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.RequestAck = 0
-	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.RequestAck = 1
-
-	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.RequestAck = 1
-
-	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.RequestAck = 1
-
-	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.RequestAck = 1
-
-	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"), time.Now())
+	p2 := buildPacket(false, 1, p1.Seq+uint32(len(p1.Data)), []byte("Content-Length: 10\r\n\r\n"), time.Now())
+	p3 := buildPacket(false, 1, p2.Seq+uint32(len(p2.Data)), []byte("a"), time.Now())
+
+	msg := buildMessage(p1)
+	if msg.seqMissing {
+		t.Error("Should be complete if have only 1 packet")
+	}
+
+	msg.AddPacket(p3)
+	if !msg.seqMissing {
+		t.Error("Should be incomplete because missing middle component")
+	}
+
+	msg.AddPacket(p2)
+	if msg.seqMissing {
+		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\r\n"), time.Now())
+	p2 := buildPacket(false, 1, p1.Seq+uint32(len(p1.Data)), []byte("Content-Length: 10\r\n\r\n"), time.Now())
+
+	msg := buildMessage(p1)
+	if msg.headerPacket == -1 {
+		t.Error("Should be complete if have only 1 packet", msg.headerPacket)
+	}
+
+	msg.AddPacket(p2)
+	if msg.headerPacket == -1 {
+		t.Error("Should found double new line: headers received")
+	}
+
+	msg = buildMessage(buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\nContent-Length: 1\r\n"), time.Now()))
+	if msg.headerPacket != -1 {
+		t.Error("Should not find headers end")
+	}
+}
+
+func TestTCPMessageMethodType(t *testing.T) {
+	testCases := []struct {
+		direction          bool
+		payload            string
+		expectedMethodType httpMethodType
+	}{
+		{true, "GET / HTTP/1.1\r\n\r\n", httpMethodWithoutBody},
+		{true, "GET * HTTP/1.1\r\n\r\n", httpMethodWithoutBody},
+		{true, "UNKNOWN / HTTP/1.1\r\n\r\n", httpMethodWithoutBody},
+		{true, "GET http://example.com HTTP/1.1\r\n\r\n", httpMethodWithoutBody},
+		{true, "POST / HTTP/1.1\r\n\r\n", httpMethodWithBody},
+		{true, "PUT / HTTP/1.1\r\n\r\n", httpMethodWithBody},
+		{true, "GET zxc HTTP/1.1\r\n\r\n", httpMethodNotFound},
+		{true, "GET / HTTP\r\n\r\n", httpMethodNotFound},
+		{true, "VERYLONGMETHOD / HTTP/1.1\r\n\r\n", httpMethodNotFound},
+		{false, "HTTP/1.1 200 OK\r\n\r\n", httpMethodWithBody},
+		{false, "HTTP /1.1 200 OK\r\n\r\n", httpMethodNotFound},
+	}
+
+	for _, tc := range testCases {
+		msg := buildMessage(buildPacket(tc.direction, 1, 1, []byte(tc.payload), time.Now()))
+
+		if msg.methodType != tc.expectedMethodType {
+			t.Errorf("Expected %d, got %d", tc.expectedMethodType, msg.methodType)
+		}
+	}
+}
+
+func TestTCPMessageBodyType(t *testing.T) {
+	testCases := []struct {
+		direction        bool
+		payload          string
+		expectedBodyType httpBodyType
+	}{
+		{true, "GET / HTTP/1.1\r\n\r\n", httpBodyEmpty},
+		{true, "POST / HTTP/1.1\r\n\r\n", httpBodyEmpty},
+		{true, "POST / HTTP/1.1\r\nUser-Agent: zxc\r\n\r\n", httpBodyEmpty},
+		{false, "HTTP/1.1 200 OK\r\n\r\n", httpBodyEmpty},
+		{true, "POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab", httpBodyContentLength},
+		{false, "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nab", httpBodyContentLength},
+		{true, "POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n2\r\nab\r\n0\r\n\r\n", httpBodyChunked},
+		{false, "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n2\r\nab\r\n0\r\n\r\n", httpBodyChunked},
+	}
+
+	for _, tc := range testCases {
+		msg := buildMessage(buildPacket(tc.direction, 1, 1, []byte(tc.payload), time.Now()))
+
+		if msg.bodyType != tc.expectedBodyType {
+			t.Errorf("Expected %d, got %d", tc.expectedBodyType, msg.bodyType)
+		}
+	}
+}
+
+func TestTCPMessageBodySize(t *testing.T) {
+	testCases := []struct {
+		direction    bool
+		payloads     []string
+		expectedSize int
+	}{
+		{true, []string{"GET / HTTP/1.1\r\n\r\n"}, 0},
+		{true, []string{"POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab"}, 2},
+		{true, []string{"GET / HTTP/1.1\r\n", "Content-Length: 2\r\n\r\nab"}, 2},
+		{true, []string{"GET / HTTP/1.1\r\n", "Content-Length: 2\r\n\r\n", "ab"}, 2},
+	}
+
+	for _, tc := range testCases {
+		msg := buildMessage(buildPacket(tc.direction, 1, 1, []byte(tc.payloads[0]), time.Now()))
+
+		if len(tc.payloads) > 1 {
+			for _, p := range tc.payloads[1:] {
+				seq := uint32(1 + msg.Size())
+				msg.AddPacket(buildPacket(tc.direction, 1, seq, []byte(p), time.Now()))
+			}
+		}
+
+		if msg.BodySize() != tc.expectedSize {
+			t.Errorf("Expected %d, got %d", tc.expectedSize, msg.BodySize())
+		}
+	}
+}
+
+func TestTcpMessageStart(t *testing.T) {
+	start := time.Now().Add(-1 * time.Second)
+
+	msg := buildMessage(buildPacket(true, 1, 2, []byte("b"), time.Now()))
+	msg.AddPacket(buildPacket(true, 1, 1, []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\na"), start))
+
+	if msg.Start != start {
+		t.Error("Message timestamp should be equal to the lowest related packet timestamp", start, msg.Start)
+	}
+}
+

raw_socket_listener/tcp_packet.go

@@ -2,11 +2,14 @@ package rawSocket
 
 import (
 	"encoding/binary"
-	"net"
+	"log"
 	"strconv"
 	"strings"
+	"time"
 )
 
+var _ = log.Println
+
 // TCP Flags
 const (
 	fFIN = 1 << iota
@@ -20,6 +23,8 @@ const (
 	fNS
 )
 
+type tcpID [24]byte
+
 // TCPPacket provides tcp packet parser
 // Packet structure: http://en.wikipedia.org/wiki/Transmission_Control_Protocol
 type TCPPacket struct {
@@ -27,44 +32,83 @@ type TCPPacket struct {
 	DestPort   uint16
 	Seq        uint32
 	Ack        uint32
+	OrigAck    uint32
 	DataOffset uint8
-	Flags      uint16
-	Window     uint16
-	Checksum   uint16
-	Urgent     uint16
+	IsFIN      bool
 
+	Raw  []byte
 	Data []byte
-
-	Addr net.Addr
+	Addr []byte
+	timestamp time.Time
+	ID   tcpID
 }
 
 // ParseTCPPacket takes address and tcp payload and returns parsed TCPPacket
-func ParseTCPPacket(addr net.Addr, b []byte) (p *TCPPacket) {
-	p = &TCPPacket{Data: b}
+func ParseTCPPacket(addr []byte, data []byte, timestamp time.Time) (p *TCPPacket) {
+	p = &TCPPacket{Raw: data}
 	p.ParseBasic()
 	p.Addr = addr
+	p.timestamp = timestamp
+	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.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.DestPort = binary.BigEndian.Uint16(t.Data[2:4])
-	t.SrcPort = binary.BigEndian.Uint16(t.Data[0:2])
-	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.IsFIN = t.Raw[13]&0x01 != 0
+
+	// log.Println("DataOffset:", t.DataOffset, t.DestPort, t.SrcPort, t.Seq, t.Ack)
+
+	t.Data = t.Raw[t.DataOffset*4:]
+}
+
+func (t *TCPPacket) dump() *packet {
+
+	packetSrcIP := make([]byte, 16)
+	packetData := make([]byte, len(t.Data) + 16)
+
+	copy(packetSrcIP, t.Addr)
+
+	binary.BigEndian.PutUint16(packetData[0:2], t.SrcPort)
+	binary.BigEndian.PutUint16(packetData[2:4], t.DestPort)
+
+	binary.BigEndian.PutUint32(packetData[4:8], t.Seq)
+	binary.BigEndian.PutUint32(packetData[8:12], t.Ack)
+
+	packetData[12] = 64
+
+	if t.IsFIN {
+		packetData[13] = packetData[13] | 0x01
+	}
+
+	copy(packetData[16:], t.Data)
+
+	return &packet{
+		srcIP: packetSrcIP,
+		data:packetData,
+		timestamp:t.timestamp,
+	}
 
-	t.Data = t.Data[t.DataOffset*4:]
 }
 
 // String output for a TCP Packet
@@ -75,25 +119,13 @@ func (t *TCPPacket) String() string {
 	}
 
 	return strings.Join([]string{
-		"Addr: " + t.Addr.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)),
-
-		"Flag ns:" + strconv.FormatBool(t.Flags&fNS != 0),
-		"Flag crw:" + strconv.FormatBool(t.Flags&fCWR != 0),
-		"Flag ece:" + strconv.FormatBool(t.Flags&fECE != 0),
-		"Flag urg:" + strconv.FormatBool(t.Flags&fURG != 0),
-		"Flag ack:" + strconv.FormatBool(t.Flags&fACK != 0),
-		"Flag psh:" + strconv.FormatBool(t.Flags&fPSH != 0),
-		"Flag rst:" + strconv.FormatBool(t.Flags&fRST != 0),
-		"Flag syn:" + strconv.FormatBool(t.Flags&fSYN != 0),
-		"Flag fin:" + strconv.FormatBool(t.Flags&fFIN != 0),
-
-		"Window size:" + strconv.Itoa(int(t.Window)),
-		"Checksum:" + strconv.Itoa(int(t.Checksum)),
+		"FIN:" + strconv.FormatBool(t.IsFIN),
 
 		"Data size:" + strconv.Itoa(len(t.Data)),
 		"Data:" + string(t.Data[:maxLen]),

settings.go

@@ -25,23 +25,31 @@ func (h *MultiOption) Set(value string) error {
 
 // AppSettings is the struct of main configuration
 type AppSettings struct {
-	verbose bool
-	debug   bool
-	stats   bool
+	verbose   bool
+	debug     bool
+	stats     bool
+	exitAfter time.Duration
 
 	splitOutput bool
 
-	inputDummy  MultiOption
-	outputDummy MultiOption
+	inputDummy   MultiOption
+	outputDummy  MultiOption
+	outputStdout bool
+	outputNull   bool
 
 	inputTCP       MultiOption
 	outputTCP      MultiOption
 	outputTCPStats bool
 
-	inputFile  MultiOption
-	outputFile MultiOption
+	inputFile        MultiOption
+	inputFileLoop    bool
+	outputFile       MultiOption
+	outputFileConfig FileOutputConfig
 
-	inputRAW MultiOption
+	inputRAW              MultiOption
+	inputRAWEngine        string
+	inputRAWTrackResponse bool
+	inputRAWRealIPHeader  string
 
 	middleware string
 
@@ -50,6 +58,8 @@ type AppSettings struct {
 
 	outputHTTPConfig HTTPOutputConfig
 	modifierConfig   HTTPModifierConfig
+
+	outputKafkaConfig KafkaConfig
 }
 
 // Settings holds Gor configuration
@@ -67,35 +77,60 @@ func init() {
 	flag.BoolVar(&Settings.verbose, "verbose", false, "Turn on more verbose output")
 	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.DurationVar(&Settings.exitAfter, "exit-after", 0, "exit after specified duration")
 
 	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.BoolVar(&Settings.outputNull, "output-null", false, "Used for testing inputs. Drops all requests.")
 
 	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")
 	flag.BoolVar(&Settings.outputTCPStats, "output-tcp-stats", false, "Report TCP output queue stats to console every 5 seconds.")
 
 	flag.Var(&Settings.inputFile, "input-file", "Read requests from file: \n\tgor --input-file ./requests.gor --output-http staging.com")
+	flag.BoolVar(&Settings.inputFileLoop, "input-file-loop", false, "Loop input files, useful for performance testing.")
+
 	flag.Var(&Settings.outputFile, "output-file", "Write incoming requests to file: \n\tgor --input-raw :80 --output-file ./requests.gor")
+	flag.DurationVar(&Settings.outputFileConfig.flushInterval, "output-file-flush-interval", time.Minute, "Interval for forcing buffer flush to the file, default: 60s.")
+	flag.BoolVar(&Settings.outputFileConfig.append, "output-file-append", false, "The flushed chunk is appended to existence file or not. ")
+
+	// Set default
+	Settings.outputFileConfig.sizeLimit.Set("32mb")
+	flag.Var(&Settings.outputFileConfig.sizeLimit, "output-file-size-limit", "Size of each chunk. Default: 32mb")
+	flag.IntVar(&Settings.outputFileConfig.queueLimit, "output-file-queue-limit", 256, "The length of the chunk queue. Default: 256")
 
 	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.inputRAWRealIPHeader, "input-raw-realip-header", "", "If not blank, injects header with given name and real IP value to the request payload. Usually this header should be named: X-Real-IP")
+
 	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.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.DurationVar(&Settings.outputHTTPConfig.Timeout, "output-http-timeout", 5*time.Second, "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'")
 
+	flag.StringVar(&Settings.outputKafkaConfig.host, "output-kafka-host", "", "Send request and response stats to Kafka:\n\tgor --input-raw :8080 --output-kafka-host '192.168.0.1:9092,192.168.0.2:9092'")
+	flag.StringVar(&Settings.outputKafkaConfig.topic, "output-kafka-topic", "", "Send request and response stats to Kafka:\n\tgor --input-raw :8080 --output-kafka-topic 'kafka-log'")
+
 	flag.Var(&Settings.modifierConfig.headers, "http-set-header", "Inject additional headers to http reqest:\n\tgor --input-raw :8080 --output-http staging.com --http-set-header 'User-Agent: Gor'")
 	flag.Var(&Settings.modifierConfig.headers, "output-http-header", "WARNING: `--output-http-header` DEPRECATED, use `--http-set-header` instead")
 
@@ -115,7 +150,7 @@ 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.headerNegativeFilters, "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")

test_input.go

@@ -9,6 +9,7 @@ import (
 // TestInput used for testing purpose, it allows emitting requests on demand
 type TestInput struct {
 	data chan []byte
+	skipHeader bool
 }
 
 // NewTestInput constructor for TestInput
@@ -22,13 +23,23 @@ func NewTestInput() (i *TestInput) {
 func (i *TestInput) Read(data []byte) (int, error) {
 	buf := <-i.data
 
-	header := payloadHeader(RequestPayload, uuid(), time.Now().UnixNano())
-	copy(data[0:len(header)], header)
-	copy(data[len(header):], buf)
+	var header []byte
+
+	if !i.skipHeader {
+		header = payloadHeader(RequestPayload, uuid(), time.Now().UnixNano(), -1)
+		copy(data[0:len(header)], header)
+		copy(data[len(header):], buf)
+	} else {
+		copy(data, buf)
+	}
 
 	return len(buf) + len(header), nil
 }
 
+func (i *TestInput) EmitBytes(data []byte) {
+	i.data <- data
+}
+
 // EmitGET emits GET request without headers
 func (i *TestInput) EmitGET() {
 	i.data <- []byte("GET / HTTP/1.1\r\n\r\n")
@@ -53,6 +64,18 @@ func (i *TestInput) EmitLargePOST() {
 	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")
+}
+
+// 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