Merge branch 'master' into payload-type-file-templae

Prettify http
Allow to use payload type for file names (#417 )
2026-10-19 16:15:42 +00:00 · 2017-01-23 20:01:35 +03:00 · 2017-01-23 19:59:47 +03:00 · 2017-01-23 16:40:14 +04:00 · 2017-01-23 15:38:02 +03:00 · 2017-01-23 16:20:27 +04:00
100 changed files with 9410 additions and 671 deletions
@@ -6,6 +6,7 @@
 *.bin

 *.gz
+*.zip

 *.class

@@ -15,3 +16,11 @@
 gor

 *.mprof
+
+*.pcap
+
+.DS_Store
+
+corpus
+crashers
+suppressions
@@ -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
@@ -0,0 +1,5 @@
+POST /post HTTP/1.1
+Content-Length: 7
+Host: www.w3.org
+
+a=1&b=2
@@ -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 REPLAY SOFTWARE. READ IT CAREFULLY BEFORE COMPLETING THE INSTALLATION PROCESS AND USING GOR PRO AND RELATED SOFTWARE COMPONENTS (“SOFTWARE”). IT PROVIDES A LICENSE TO USE THE SOFTWARE AND CONTAINS WARRANTY INFORMATION AND LIABILITY DISCLAIMERS. BY INSTALLING AND USING THE SOFTWARE, YOU ARE CONFIRMING YOUR ACCEPTANCE OF THE SOFTWARE AND AGREEING TO BECOME BOUND BY THE TERMS OF THIS AGREEMENT.
+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 Replay Software.
+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 Replay Software of your knowledge of any infringing use of the Software by any of your customers. You are liable for compliance by those third parties with the terms and conditions of this EULA. You will not owe Replay Software any royalties for your distribution of the Software in accordance with this EULA.
+1.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. Replay Software shall provide you with source code so that you can create Modifications of the original software. “Modification” means: (a) any addition to or deletion from the contents of a file included in the original Software or previous Modifications created by You, or (b) any new file that contains any part of the original Software or previous Modifications. While you retain all rights to any original work authored by you as part of the Modifications, We continue to own all copyright and other intellectual property rights in the Software.
+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 Replay Software; (h) publicly disseminate performance information or analysis (including, without limitation, benchmarks) from any source relating to the Software; (i) utilize any equipment, device, software, or other means designed to circumvent or remove any form of Source URL or copy protection used by Replay Software in connection with the Software, or use the Software together with any authorization code, Source URL, serial number, or other copy protection device not supplied by Replay Software; (j) use the Software to develop a product which is competitive with any Replay Software product offerings; or (k) use unauthorized Source URLS or keycode(s) or distribute or publish Source URLs or keycode(s), except as may be expressly permitted by Replay Software in writing. If your unique Source URL is ever published, Replay Software reserves the right to terminate your access without notice.
+3.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, Replay Software and its suppliers have and will retain all rights, title and interest (including, without limitation, all patent, copyright, trademark, trade secret and other intellectual property rights) in and to the Software and all copies, modifications and derivative works thereof (including any changes which incorporate any of your ideas, feedback or suggestions). You acknowledge that you are obtaining only a limited license right to the Software, and that irrespective of any use of the words “purchase”, “sale” or like terms hereunder no ownership rights are being conveyed to you under this Agreement or otherwise. 
+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 Replay Software). 
+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 Replay Software may terminate this Agreement immediately upon any breach of Section 3 or if you exceed any other restrictions contained in Section 1, unless otherwise specified in this agreement; (b) ceases operation without a successor; or (c) seeks protection under any bankruptcy, receivership, trust deed, creditors arrangement, composition or comparable proceeding, or if any such proceeding is instituted against such party (and not dismissed within sixty (60) days)). Termination is not an exclusive remedy and the exercise by either party of any remedy under this Agreement will be without prejudice to any other remedies it may have under this Agreement, by law, or otherwise.        
+7.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 Replay Software.
+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. Replay Software does not warrant that the Software will be free of bugs, errors, viruses or other defects, and Replay Software shall have no liability of any kind for the use of or inability to use the Software, the Software content or any associated service, and you acknowledge that it is not technically practicable for Replay Software to do so. 
-To the maximum extent permitted by applicable law, Replay Software disclaims all warranties, express, implied, arising by law or otherwise, regarding the Software, the Software content and their respective performance or suitability for your intended use, including without limitation any implied warranty of merchantability, fitness for a particular purpose.
+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 Replay Software be liable for any direct, indirect, consequential, incidental, special, exemplary, or punitive damages or liabilities whatsoever arising from or relating to the Software, the Software content or this Agreement, whether based on contract, tort (including negligence), strict liability or other theory, even if Replay Software has been advised of the possibility of such damages.
+In no event will 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 Replay Software' liability exceed the Software license price as indicated in the invoice. The existence of more than one claim will not enlarge or extend this limit.
+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 Replay Software’ entire liability for breach of this Agreement shall be limited, at Replay Software’ sole and exclusive discretion, to (a) replacement of any defective software or documentation; or (b) refund of the license fee paid to Replay Software, payable in accordance with Replay Software' refund policy.
+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 Replay Software and its affiliates may collect and use technical information gathered as part of the product support services. Replay Software may use this information solely to improve products and services and will not disclose this information in a form that personally identifies you.
+11.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 Replay Software' liability exceed the Software license price as

 13.1 Entire Agreement. This Agreement sets forth our entire agreement with respect to the Software and the subject matter hereof and supersedes all prior and contemporaneous understandings and agreements whether written or oral.

-13.2 Amendment. Replay Software reserves the right, in its sole discretion, to amend this Agreement from time. Amendments to this Agreement can be located at: https://github.com/buger/gor/blob/master/COMM-LICENSE.
+13.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 Replay Software 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 Replay Software from and against any lawsuits, claims, losses, damages, fines and expenses (including attorneys' fees and costs) arising out of your use of the Software or breach of this Agreement.
+13.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 Replay Software' liability exceed the Software license price as

 13.10 Headings. The headings of sections and paragraphs of this Agreement are for convenience of reference only and are not intended to restrict, affect or be of any weight in the interpretation or construction of the provisions of such sections or paragraphs.

-14. Contact Information. If you have any questions about this EULA, or if you want to contact Replay Software for any reason, please direct correspondence to info@gortool.com
+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
@@ -18,5 +18,7 @@ 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 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
@@ -1,7 +1,19 @@
-Gor 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.
@@ -1,19 +1,25 @@
-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-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  -i gor go build $(LDFLAGS) && 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 -i gor go build $(LDFLAGS) && 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
@@ -32,7 +38,7 @@ race:
 	$(RUN) go test ./... $(ARGS) -v -race -timeout 15s

 test:
-	$(RUN) go test ./. -race -timeout 60s $(LDFLAGS) $(ARGS)  -v
+	$(RUN) go test ./. -timeout 60s $(LDFLAGS) $(ARGS)  -v

 test_all:
 	$(RUN) go test ./... -timeout 60s $(LDFLAGS) $(ARGS) -v
@@ -59,7 +65,7 @@ profile_test:

 # Used mainly for debugging, because docker container do not have access to parent machine ports
 run:
-	$(RUN) go run $(LDFLAGS) $(SOURCE) --input-dummy=0 --output-http="http://localhost:9000" --input-raw-track-response --input-raw 127.0.0.1:9000 --input-http 127.0.0.1:9000 --verbose --debug --middleware "./examples/middleware/echo.sh"
+	$(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:
 	sudo -E go run $(SOURCE) --input-dummy="" --output-tcp localhost:27001 --verbose --debug
@@ -67,6 +73,15 @@ run-2:
 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

@@ -1,47 +1,49 @@
 [![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)[Compilation].
+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 wiki and especially [Getting started](https://github.com/buger/gor/wiki/Getting-Started) wiki page for more info. 
+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](https://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)[http://github.com/buger/gor] for your problem is also a good idea.
+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.

 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.

-Useful resources:
-
-* Product documentation is in the [wiki](http://github.com/buger/gor/wiki).
-* Release announcements are made to the [@buger](http://twitter.com/buger) Twitter account and our [newsleter](https://tinyletter.com/gor)
-
-
-If you need commercial support read more about Pro and Enterprise versions at our site [https://gortool.com/](https://gortool.com/)
-

 ## Contributing

@@ -64,7 +66,7 @@ If you need commercial support read more about Pro and Enterprise versions at ou
 * [Granify](http://granify.com) - AI backed SaaS solution that enables online retailers to maximise their sales
 * And many more!

-If you are using Gor we are happy add you to the list and share your story, just write to: hello@gortool.com
+If you are using Gor we are happy add you to the list and share your story, just write to: hello@goreplay.org

 ## Author

@@ -0,0 +1 @@
+docs.goreplay.org
@@ -0,0 +1,49 @@
+Think about Gor more like a network analyzer or tcpdump on steroids, it is not a proxy and does not affect your app anyhow. You specify application port, and it will capture and replay incoming data.
+
+Simplest setup will be:
+```bash
+# Run on servers where you want to catch traffic. You can run it on every `web` machine.
+sudo gor --input-raw :80 --output-http http://staging.com
+```
+It will record and replay traffic from the same machine. However, it is possible to use [[Aggregator-forwarder setup]], when Gor on your web machines forward traffic to Gor aggregator instance running on the separate server.
+
+> You may notice that it require `sudo`: to analyze network Gor need permissions which available only to root users. However, it is possible to configure Gor [beign run for non-root users](Running as a non-root user).
+
+
+### Forwarding to multiple addresses
+
+You can forward traffic to multiple endpoints.
+```
+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 (round-robin) using  `--split-output` option.
+
+```
+gor --input-raw :80 --output-http "http://staging.com"  --output-http "http://dev.com" --split-output true
+```
+
+### Tracking responses
+By default `input-raw` does not intercept responses, only requests. You can turn response tracking using `--input-raw-track-response` option. When enable you will be able to access response information in middleware and `output-file`.
+
+
+### Traffic interception engine
+By default, Gor will use `libpcap` for intercepting traffic, it should work in most cases. If you have any troubles with it, you may try alternative engine: `raw_socket`.
+
+```
+sudo gor --input-raw :80 --input-raw-engine "raw_socket" --output-http "http://staging.com"
+```
+
+You can read more about [[Replaying HTTP traffic]].
+
+
+### Tracking original IP addresses
+You can use `--input-raw-realip-header` option to specify header name: 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`, but you can specify any name.
+
+`gor --input-raw :80 --input-raw-realip-header "X-Real-IP" ...`
+
+
+***
+
+Also you may want to know about [[Rate limiting]], [[Request rewriting]] and [[Request filtering]]
@@ -0,0 +1,30 @@
+We provide pre-compiled binaries for Mac and Linux, but you are free to compile Gor by yourself.
+
+Gor is written using Go, so first you need to download it from here https://golang.org/, use the latest stable version. 
+
+The only Gor dependency is [libpcap](https://github.com/the-tcpdump-group/libpcap), which is the interface to various kernel packet capture mechanisms, and https://github.com/google/gopacket, which is a Go wrapper around libpcap. Latest libpcap version can be obtained at http://www.tcpdump.org/release/. Libpcap itself depend on `flex` and `bison` packages, many operating systems already have them installed.
+
+```bash
+# Fetch libpcap dependencies. Depending on your OS, instead of `apt` you will use `yum` or `rpm`, or `brew` on Mac.
+sudo apt-get install flex bison -y
+
+# Download latest stable release, compile and install it
+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
+
+
+# Lets fetch Gor source code
+mkdir $HOME/gocode
+# See more information about GOPATH https://github.com/golang/go/wiki/GOPATH
+export GOPATH=$HOME/gocode
+# Fetch code from the Github
+go get github.com/buger/gor
+
+# Compile from source
+cd $HOME/gocode/src/github.com/buger/gor
+go build LDFLAGS = -ldflags "-extldflags \"-static\""
+```
+
+After you finished, you should see `gor` binary in current directory. 
+
@@ -0,0 +1,39 @@
+## STEP 1: Install Docker
+For local development we recommend to use Docker.
+
+If you don’t have it you can read how to install it here:
+https://docs.docker.com/engine/getstarted/step_one/#step-3-verify-your-installation
+
+## STEP 2: Download repository
+
+`git clone git@github.com:buger/goreplay.git`
+
+
+## STEP 3: Setup container
+
+```
+cd ./goreplay
+make build
+
+```
+
+## Testing
+To run tests execute next command:
+
+```
+make test
+```
+
+You can copy the command that is produced and modify it. For example, if you need to run one test copy the command and add `-run TestName`, e.g.:
+
+```
+docker run -v `pwd`:/go/src/github.com/buger/gor/ -p 0.0.0.0:8000:8000 -t -i gor:go go test ./. -run TestEmitterFiltered -timeout 60s -ldflags "-X main.VERSION=DEV-1482398347 -extldflags \"-static\""   -v
+```
+
+
+## Building
+To get a binary file run 
+
+```
+make release-bin
+```
@@ -0,0 +1,26 @@
+Sometimes it makes sense to use separate Gor instance for replaying traffic and performing things like load testing, so your production machines do not spend precious resources. It is possible to configure Gor on your web machines forward traffic to Gor aggregator instance running on the separate server.
+
+```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
+```
+
+If you have multiple replay machines you can split traffic among them using `--split-output` option: it will equally split all incoming traffic to all outputs using round robin algorithm.
+```
+gor --input-raw :80 --split-output --output-tcp replay1.local:28020 --output-tcp replay2.local:28020
+```
+
+[GoReplay PRO](https://goreplay.com/pro.html) support accurate recording and replaying of tcp sessions, and when `--recognize-tcp-sessions` option is passed, instead of round-robin it will use a smarter algorithm which ensures that same sessions will be sent to the same replay instance.
+
+
+In case if you are planning a large load testing, you may consider use separate master instance which will control Gor slaves which actually replay traffic. For example:
+```
+# This command will read multiple log files, replay them on 10x speed and loop them if needed for 30 seconds, and will distributed traffic (tcp session aware) among multiple workers
+gor --input-file logs_from_multiple_machines.*|1000% --input-file-loop --exit-after 30s --recognize-tcp-sessions --split-output --output-tcp worker1.local --output-tcp worker2.local:27017 --output-tcp worker3.local:27017 ...  --output-tcp workerN.local:27017
+
+# worker 
+gor --input-tcp :27017 --ouput-http load_test.target
+```
@@ -0,0 +1,38 @@
+Gor can export requests and replayed response data to ElasticSearch:
+
+```
+./gor --input-raw :8000 --output-http http://staging.com  --output-http-elasticsearch localhost:9200/gor
+```
+
+You don't have to create the index upfront. That will be done for you automatically.
+
+### Format
+
+Following structure represents ES format:
+
+```
+type ESRequestResponse struct {
+	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
+}
+```
@@ -0,0 +1,32 @@
+### What OS are supported?
+Gor will run everywhere where [libpcap](http://www.tcpdump.org/) works, and it works on most of the platforms. However, currently, we test it on Linux and Mac. See more about [[Compilation]].
+
+### 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. But it is possible to [[Running as non root user]].
+
+### 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.
+
+Also see [[Troubleshooting]].
@@ -0,0 +1,74 @@
+#### Overview
+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. Check examples [included into our repo](https://github.com/buger/gor/tree/master/examples/middleware).
+
+
+```
+                   Original request      +--------------+
+-------------+----------STDIN---------->+              |
+|  Gor input  |                          |  Middleware  |
+-------------+----------STDIN---------->+              |
+                   Original response (1) +------+---+---+
+                                                |   ^
+-------------+    Modified request             v   |
+| Gor output  +<---------STDOUT-----------------+   |
+-----+-------+                                     |
+      |                                             |
+      |            Replayed response                |
+      +------------------STDIN----------------->----+
+```
+
+(1): Original responses will only be sent to the middleware if the `--input-raw-track-response` option is specified.
+
+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 (note: you will only receive this if you specify `--input-raw-track-response`)
+
+```
+2 8e091765ae902fef8a2b7d9dd960e9d52222bd8c 1439818823587996305 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. The third argument is the time when request/response was initiated/received. Forth argument is populated only for responses and means latency.
+
+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](https://github.com/buger/gor/tree/master/examples/middleware/token_modifier.go) and [middleware_test.go#TestTokenMiddleware](https://github.com/buger/gor/tree/master/middleware_test.go) as example of described scheme.
+
+***
+
+You may also read about [[Request filtering]], [[Rate limiting]] and [[Request rewriting]].
@@ -0,0 +1,37 @@
+Rate limiting can be useful if you only want to forward parts of incoming traffic, for example, to not overload your test environment. There are two strategies: dropping random requests or dropping fractions of requests based on Header or URL param value. 
+
+### Dropping random requests
+Every input and output support random rate limiting.
+There are two limiting algorithms: absolute or percentage based. 
+
+**Absolute**: If for current second it reached specified requests limit - disregard the rest, on next second counter reset.
+
+**Percentage**: For input-file it will slowdown or speedup request execution, for the rest it will use the random generator to decide if request pass or not based on the chance you specified. 
+
+You can specify your desired limit using the "|" operator after the server address, see examples below.
+
+#### Limiting replay using absolute number
+```
+# staging.server will not get more than ten 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%"
+```
+
+### Consistent 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 the 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%"
+```
+
+When limiting based on header or param only percentage based limiting supported.
@@ -0,0 +1,46 @@
+Gor can replay HTTP traffic using `--output-http` option:
+
+```bash
+sudo ./gor --input-raw :8000 --output-http="http://staging.env"
+```
+
+You can [filter](Request filtering), [rate limit](Rate limiting) and [rewrite](Request rewriting) requests on the fly. 
+
+### 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.
+
+### Following 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
+```
+
+### Response buffer
+By default, to reduce memory consumption, internal HTTP client will fetch max 200kb of the response body (used if you use middleware), by you can increase limit using `--output-http-response-buffer` option (accepts number of bytes).
+
+### 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.
+
+
+### Multiple domains support
+
+If you app accepts traffic from multiple domains, and you want to keep original headers, there is specific `--http-original-host` with tells Gor do not touch Host header at all.
+
+
+***
+You may also read about [[Saving and Replaying from file]]
@@ -0,0 +1,35 @@
+Filtering is useful when you need to capture only specific part of traffic, like API requests. It is possible to filter by URL, HTTP header or HTTP method.
+
+#### 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
+```
+
+
+-----
+You may also read about [[Request rewriting]], [[Rate limiting]] and [[Middleware]]
@@ -0,0 +1,38 @@
+Gor supports rewriting of URLs, URL params and headers, see below.
+
+Rewriting may be useful if you test environment does not have the same data as your production, and you want to perform all actions in the context of `test` user: for example rewrite all API tokens to some test value. Other possible use cases are toggling features on/off using custom headers or rewriting URL's if they changed in the new environment.
+
+For more complex logic you can use [Middleware](middleware.md).
+
+#### Rewrite URL based on a mapping
+`--http-rewrite-url` expects value in "<search>:<replace>" format: ":" is a dilimiter. In `<replace>` section you may use captured regexp group values. This works similar to `replace` method in Javascript or `gsub` in Ruby. 
+
+```
+# Rewrites all `/v1/user/<user_id>/ping` requests to `/v2/user/<user_id>/ping`
+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. 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 domains, and you want to keep original headers, there is specific `--http-original-host` with tells Gor do not touch Host header at all.
+
+
+***
+
+You may also read about [[Request filtering]], [[Rate limiting]] and [[Middleware]]
@@ -0,0 +1,17 @@
+You can enable Gor for non-root users in a secure method by using the following commands
+
+``` 
+# Following commands assume that you put `gor` binary to /usr/local/bin
+add gor
+addgroup <username> gor
+chgrp gor /usr/local/bin/gor
+chmod 0750 /usr/local/bin/gor
+setcap "cap_net_raw,cap_net_admin+eip" /usr/local/bin/gor
+```
+ 
+As a brief explanation of the above.
+* We create a group called gor. 
+* We then add the user you want to the new group so they will be able to use gor without sudo
+* We then change the user/group of gor binary the new group.
+* We then make sure the permissions are set on gor binary so that members of the group can execute it but other normal users cannot.
+* We then use `setcap` to give the CAP_NET_RAW and CAP_NET_ADMIN privilege to the executable when it runs. This is so that Gor can open its raw socket which is not normally permitted unless you are root.
@@ -0,0 +1,105 @@
+You can save requests to file, and replay them later. While replaying it will preserve the original time differences between requests. If you apply [percentage based limiting](Rate Limiting) timing between requests will be reduced or increased appropriately: this approach opens possibilities like load testing, see below.
+
+```bash
+# write to file
+gor --input-raw :80 --output-file requests.log
+
+# read from file
+gor --input-file requests.gor --output-http "http://staging.com"
+```
+
+By default Gor writes files in chunks. This configurable using `--output-file-append` option: the flushed chunk is appended to existence file or not. The default is **false**. By default, `--output-file` flushes each chunk to a different path.
+
+```bash
+gor ... --output-file %Y%m%d.log
+# append false
+20140608_0.log
+20140608_1.log
+20140609_0.log
+20140609_1.log
+```
+
+This makes parallel file processing easy. But if you want to disable this behavior, you can disable it by adding `--output-file-append` option:
+
+```bash
+gor ... --output-file %Y%m%d.log --output-file-append
+# append true
+20140608.log
+20140609.log
+```
+
+If you run gor multiple times, and it finds existing files, it will continue from last known index.
+
+### Chunk size
+
+You can set chunk limits using `--output-file-size-limit` and `--output-file-queue-limit` options.
+The length of the chunk queue and the size of each chunk, respectively. The default values are 256 and 32mb, respectively. The suffixes “k” (KB), “m” (MB), and “g” (GB) can be used for `output-file-size-limit`.
+If you want to have only size constraint, you can set `--output-file-queue-limit` to 0, and vice versa.
+
+```bash
+gor --input-raw :80 --output-file %Y-%m-%d.gz --output-file-size-limit 256m --output-file-queue-limit 0
+```
+
+### Using date variables in file names
+For example, you can tell to create new file each hour: `--output-file /mnt/logs/requests-%Y-%m-%d-%H.log`
+It will create new file for each hour: requests-2016-06-01-12.log, requests-2016-06-01-13.log, ...
+
+The time format used as part of the file name. The following characters are replaced with actual values when the file is created:
+
+* `%Y`: year including the century (at least 4 digits)
+* `%m`: month of the year (01..12)
+* `%d`: Day of the month (01..31)
+* `%H`: Hour of the day, 24-hour clock (00..23)
+* `%M`: Minute of the hour (00..59)
+* `%S`: Second of the minute (00..60)
+
+The default format is `%Y%m%d%H`, which creates one file per hour.
+
+
+### GZIP compression
+To read or write GZIP compressed files ensure that file extension ends with ".gz": `--output-file log.gz`
+
+### Replaying from multiple files
+
+`--input-file` accepts file pattern, for example: `--input-file logs-2016-05-*`: it will replay all the files, sorting them in lexicographical order.
+
+### Buffered file output
+Gor has memory buffer when it writes to file, and continuously flush changes to the file. Flushing to file happens if the buffer is filled, forced flush every 1 second, or if Gor is closed. You can change it using `--output-file-flush-interval` option. It most cases it should not be touched.
+
+### File format
+HTTP requests stored as it is, plain text: headers and bodies. Requests separated by `\n🐵🙈🙉\n` line (using such sequence for uniqueness and fun). Before each request goes single line with meta information containing payload type (1 - request, 2 - response, 3 - replayed response), unique request ID (request and response have the same) and timestamp when request was made. An example of 2 requests:
+
+```
+1 d7123dasd913jfd21312dasdhas31 127345969\n
+GET / HTTP/1.1\r\n
+\r\n
+\n
+🐵🙈🙉
+\n
+POST /upload HTTP/1.1\r\n
+Content-Length: 7\r\n
+Host: www.w3.org\r\n
+\r\n
+a=1&b=2
+```
+Note that technically \r and \n symbols are invisible, and indicate new lines. I made them visible in example just to show how it looks on byte level.
+
+Making it text friendly allows writing simple parsers and use console tools like `grep` to do an analysis. You can even edit them manually, but be sure that your file editor does not change line endings.
+
+## Performance testing
+
+Currently, this functionality 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 **limiter is applied to input**:
+
+```
+# Replay from file on 2x speed 
+gor --input-file "requests.gor|200%" --output-http "staging.com"
+```
+
+Use `--stats --output-http-stats` to see latency stats.
+
+### Looping files for replaying indefinitely
+You can loop the same set of files, so when the last one replays all the requests, it will not stop, and will start from first one again. Having the only small amount of requests you can do extensive performance testing.
+Pass `--input-file-loop` to make it work. 
+
+***
+You may also read about [[Capturing and replaying traffic]] and [[Rate limiting]]
@@ -0,0 +1,90 @@
+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
+```
+
+```
+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.
+
+
+#### 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
+***
+
+### Gor is crashing with following stacktrace
+```
+fatal error: unexpected signal during runtime execution
+[signal 0xb code=0x1 addr=0x63 pc=0x7ffcdfdf8b2c]
+
+runtime stack:
+runtime.throw(0xad8380, 0x2a)
+	/usr/local/go/src/runtime/panic.go:547 +0x90
+runtime.sigpanic()
+	/usr/local/go/src/runtime/sigpanic_unix.go:12 +0x5a
+
+goroutine 103 [syscall, locked to thread]:
+runtime.cgocall(0x7b35a0, 0xc82121f1e8, 0x0)
+	/usr/local/go/src/runtime/cgocall.go:123 +0x11b fp=0xc82121f188 sp=0xc82121f158
+net._C2func_getaddrinfo(0x7ffcec0008c0, 0x0, 0xc821b221e0, 0xc8217b2b18, 0x0, 0x0, 0x0)
+	??:0 +0x55 fp=0xc82121f1e8 sp=0xc82121f188
+net.cgoLookupIPCNAME(0x7fffb17208ab, 0x12, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb17200)
+```
+
+There is a chance that you hit Go bug. The crash comes from the CGO version of DNS resolver.
+By default Go based version used, but ins some cases [it switches to CGO based](https://golang.org/pkg/net/#hdr-Name_Resolution). It is possible to force Go based DNS resolver using GODEBUG environment variable:
+`sudo GODEBUG="netdns=go" ./gor --input-raw :80 --output-http staging.env`
+
+
+
+Also, see [[FAQ]]
@@ -0,0 +1 @@
+[Website](https://goreplay.org) | [PRO version](https://goreplay.org/pro.html) | [[Getting started]] | [[FAQ]] | [Join newsletter](https://www.getdrip.com/forms/89690474/submissions/new)
@@ -0,0 +1 @@
+theme: jekyll-theme-cayman
@@ -0,0 +1,19 @@
+Collaboration is difficult with commercial closed source but I do want to keep as much of the OSS ethos as possible available to customers who want to fix it themselves.
+
+## Legal
+
+In order to unambiguously own and sell Gor commercial products, I must have the copyright associated with the entire codebase.  Any code you create which is merged must be owned by me.  That's not me trying to be a jerk, that's just the way it works.
+
+## Application
+
+If you wish access to the product repository so you can send a PR, just open a new Gor issue and include the following info:
+
+1. the email address that bought the license, a max of one collaborator per license
+1. the following statement "I assign all rights, including copyright, to any future Gor work by myself to Leonid Bugaev"
+
+You should be granted access to the private repo soon after.
+
+## Notes
+
+1. You should **never** work on the master branch.  Only I may merge changes.
+1. I may revoke access for any reason at any time.  Access is not guaranteed with purchase.
@@ -0,0 +1,58 @@
+### What are GoReplay PRO and GoReplay Enterprise?
+
+[GoReplay PRO](https://goreplay.org/pro.html) and GoReplay Enterprise are extensions to GoReplay which add more functionality and provide additional support options for customers.
+
+### Is there a trial version?
+
+There's no free trial but we do offer a 14 day period with full refund if it does not work for you.
+
+### What is the license?
+
+See [COMM-LICENSE](https://github.com/buger/gor/blob/master/COMM-LICENSE) in the root of the GoReplay repo.
+
+### How does PRO licensing work?
+
+Every organization running GoReplay Pro on its own servers must have a license.  There's no limit to the amount of servers or environments used by that organization.
+
+### How does Enterprise licensing work?
+
+Every organization running Gor Enterprise on its own servers must have a license. There's **no limit** to the amount of servers or environments used by that organization.
+
+### What happens if my subscription lapses?
+
+You must have an active subscription to run GoReplay Pro or Enterprise.  After a one week grace period, you'll lose access to binaries and priority support.  You won't get any more updates or bug fixes.
+
+### How do I buy GoReplay Enterprise?
+
+Send email to [support&#64;gortool.com](mailto:support&#64;gortool.com) with your info.  A PDF quote will be emailed to you with the price.  Reply to that email with your purchase order or just "Sounds good" and we will send an invoice which can be paid with a credit card, ACH bank transfer or a paper check.
+
+### Can I upgrade from GoReplay Pro?
+
+Yes!  Current subscribers can upgrade by [requesting a quote](mailto:support&#64;gortool.com).  **Please note that you are an existing Pro subscriber.**  We will add a one-time discount on your first invoice to reflect any remaining Pro subscription credit.  If you purchased GoReplay Pro 6 months ago for $950, you'll get a $475 discount.
+
+### Can I distribute GoReplay PRO or Enterprise to my customers?
+
+This is a common requirement for "on-site installs" or "appliances" sold to large corporations.
+
+The standard license is appropriate for SaaS usage as it does not allow distribution.  GoReplay PRO and Enterprise have an Appliance license option which **does** allow you to distribute them.  The Appliance license is $9,500/yr for Pro and $19,500/yr for Enterprise.  It allows you to distribute the Pro or Enterprise binaries as part of your application and each of your customers to run GoReplay Pro or Enterprise. Email [support&#64;gortool.com](mailto:support&#64;gortool.com) to purchase.
+
+### Can you transfer a license?
+
+Licenses are **not** transferable to another company.  We will transfer the license from a user-specific email to a group email address (e.g. john_smith@example.com -> tech@example.com) but only for **the same domain**.  It is strongly recommended that you buy the license using a group email address so the license is not attached to any one employee's email address.
+
+### What does the license require me to do?
+
+Your purchase gets you a unique access URL for downloading the Pro and/or Enterprise binaries.  The license agreement requires you to keep this access URL private.  If we find your access URL is ever publicized:
+
+1. We'll send you a warning email with details.  You need to remove the content and send a new email address so we can generate a new access URL for you.  The old access URL will stop working immediately so you'll need to update your apps.
+2. If your access URL is publicized a second time, we reserve the right to permanently remove access.
+
+### Can I get a refund?
+
+Yes, up to two weeks after purchase.  Let us know the reason and maybe we can help but either way it's not a problem.  Email [support&#64;gortool.com](mailto:support&#64;gortool.com).
+
+### How do I update my credit card info?
+
+If you purchased GoReplay Enterprise, there's nothing to do.  Each annual invoice is paid separately.
+
+If you purchased GoReplay PRO, log into [Gumroad](https://gumroad.com) with your email address, click the Billing tab and enter your new card.  I can't provide support for the Gumroad website and don't have the ability to edit customer info - if you can't log in or change your credit card, you can always let your current subscription expire and purchase a new subscription.
@@ -0,0 +1,11 @@
+Gor offers only community support.  Gor Pro and Enterprise offer priority support via email.
+
+## Priority Support
+
+Covers 1 incident per quarter, with a max response time of 2 working days. Scope is limited to Gor and Gor Pro and Enterprise features and APIs, not the application or infrastructure.  For support, email **support** AT **gortool.com**.  Please email using the same domain as the original license email or explain your connection to the licensed company.
+
+More aggressive support contracts (phone, quicker response time) are available separately, email with your needs.
+
+## Onboarding
+
+Enterprise customers may request a one hour video chat session with @buger to discuss their application(s), requirements and how best to leverage the various Gor features.  Contact support to set up your session.
@@ -0,0 +1,39 @@
+.wy-breadcrumbs li {
+  display: inline-block;
+}
+
+.wy-breadcrumbs li.wy-breadcrumbs-aside {
+  float: right;
+}
+
+.wy-breadcrumbs li a {
+  display: inline-block;
+  padding: 5px;
+}
+
+.wy-breadcrumbs li a:first-child {
+  padding-left: 0;
+}
+
+.wy-breadcrumbs-extra {
+  margin-bottom: 0;
+  color: #b3b3b3;
+  font-size: 80%;
+  display: inline-block;
+}
+
+@media screen and (max-width: 480px) {
+  .wy-breadcrumbs-extra {
+    display: none;
+  }
+
+  .wy-breadcrumbs li.wy-breadcrumbs-aside {
+    display: none;
+  }
+}
+
+@media print {
+  .wy-breadcrumbs li.wy-breadcrumbs-aside {
+    display: none;
+  }
+}
@@ -0,0 +1,355 @@
+.codeblock-example {
+  border: 1px solid #e1e4e5;
+  border-bottom: none;
+  padding: 24px;
+  padding-top: 48px;
+  font-weight: 500;
+  background: #fff;
+  position: relative;
+}
+
+.codeblock-example:after {
+  content: "Example";
+  position: absolute;
+  top: 0;
+  left: 0;
+  background: #9B59B6;
+  color: #fff;
+  padding: 6px 12px;
+}
+
+.codeblock-example.prettyprint-example-only {
+  border: 1px solid #e1e4e5;
+  margin-bottom: 24px;
+}
+
+.codeblock,
+pre.literal-block,
+.rst-content .literal-block,
+.rst-content pre.literal-block,
+div[class^='highlight'] {
+  border: 1px solid #e1e4e5;
+  padding: 0;
+  overflow-x: auto;
+  background: #fff;
+  margin: 1px 0 24px;
+}
+
+.codeblock div[class^='highlight'],
+pre.literal-block div[class^='highlight'],
+.rst-content .literal-block div[class^='highlight'],
+div[class^='highlight'] div[class^='highlight'] {
+  border: none;
+  background: none;
+  margin: 0;
+}
+
+div[class^='highlight'] td.code {
+  width: 100%;
+}
+
+.linenodiv pre {
+  border-right: solid 1px #e6e9ea;
+  margin: 0;
+  padding: 12px;
+  font-family: "Source Code Pro","Andale Mono WT","Andale Mono","Lucida Console","Lucida Sans Typewriter","DejaVu Sans Mono","Bitstream Vera Sans Mono","Liberation Mono","Nimbus Mono L",Monaco,"Courier New",Courier,monospace;
+  font-size: 12px;
+  line-height: 1.5;
+  color: #d9d9d9;
+}
+
+div[class^='highlight'] pre {
+  white-space: pre;
+  margin: 0;
+  padding: 12px;
+  font-family: "Source Code Pro","Andale Mono WT","Andale Mono","Lucida Console","Lucida Sans Typewriter","DejaVu Sans Mono","Bitstream Vera Sans Mono","Liberation Mono","Nimbus Mono L",Monaco,"Courier New",Courier,monospace;
+  font-size: 12px;
+  line-height: 1.5;
+  display: block;
+  overflow: auto;
+  color: #404040;
+}
+
+@media print {
+  .codeblock,
+  pre.literal-block,
+  .rst-content .literal-block,
+  .rst-content pre.literal-block,
+  div[class^='highlight'],
+  div[class^='highlight'] pre {
+    white-space: pre-wrap;
+  }
+
+}
+
+.hll {
+  background-color: #ffc;
+  margin: 0 -12px;
+  padding: 0 12px;
+  display: block;
+}
+
+.c {
+  color: #998;
+  font-style: italic;
+}
+
+.err {
+  color: #a61717;
+  background-color: #e3d2d2;
+}
+
+.k {
+  font-weight: 700;
+}
+
+.o {
+  font-weight: 700;
+}
+
+.cm {
+  color: #998;
+  font-style: italic;
+}
+
+.cp {
+  color: #999;
+  font-weight: 700;
+}
+
+.c1 {
+  color: #998;
+  font-style: italic;
+}
+
+.cs {
+  color: #999;
+  font-weight: 700;
+  font-style: italic;
+}
+
+.gd {
+  color: #000;
+  background-color: #fdd;
+}
+
+.gd .x {
+  color: #000;
+  background-color: #faa;
+}
+
+.ge {
+  font-style: italic;
+}
+
+.gr {
+  color: #a00
+}
+
+.gh {
+  color: #999;
+}
+
+.gi {
+  color: #000;
+  background-color: #dfd;
+}
+
+.gi .x {
+  color: #000;
+  background-color: #afa;
+}
+
+.go {
+  color: #888;
+}
+
+.gp {
+  color: #555;
+}
+
+.gs {
+  font-weight: 700;
+}
+
+.gu {
+  color: purple;
+  font-weight: 700;
+}
+
+.gt {
+  color: #a00;
+}
+
+.kc {
+  font-weight: 700;
+}
+
+.kd {
+  font-weight: 700;
+}
+
+.kn {
+  font-weight: 700;
+}
+
+.kp {
+  font-weight: 700;
+}
+
+.kr {
+  font-weight: 700;
+}
+
+.kt {
+  color: #458;
+  font-weight: 700;
+}
+
+.m {
+  color: #099;
+}
+
+.s {
+  color: #d14;
+}
+
+.n {
+  color: #333;
+}
+
+.na {
+  color: teal;
+}
+
+.nb {
+  color: #0086b3;
+}
+
+.nc {
+  color: #458;
+  font-weight: 700;
+}
+
+.no {
+  color: teal;
+}
+
+.ni {
+  color: purple;
+}
+
+.ne {
+  color: #900;
+  font-weight: 700;
+}
+
+.nf {
+  color: #900;
+  font-weight: 700;
+}
+
+.nn {
+  color: #555;
+}
+
+.nt {
+  color: navy;
+}
+
+.nv {
+  color: teal;
+}
+
+.ow {
+  font-weight: 700;
+}
+
+.w {
+  color: #bbb;
+}
+
+.mf {
+  color: #099;
+}
+
+.mh {
+  color: #099;
+}
+
+.mi {
+  color: #099;
+}
+
+.mo {
+  color: #099;
+}
+
+.sb {
+  color: #d14;
+}
+
+.sc {
+  color: #d14;
+}
+
+.sd {
+  color: #d14;
+}
+
+.s2 {
+  color: #d14
+}
+
+.se {
+  color: #d14;
+}
+
+.sh {
+  color: #d14;
+}
+
+.si {
+  color: #d14;
+}
+
+.sx {
+  color: #d14;
+}
+
+.sr {
+  color: #009926;
+}
+
+.s1 {
+  color: #d14;
+}
+
+.ss {
+  color: #990073;
+}
+
+.bp {
+  color: #999;
+}
+
+.vc {
+  color: teal;
+}
+
+.vg {
+  color: teal;
+}
+
+.vi {
+  color: teal;
+}
+
+.il {
+  color: #099;
+}
+
+.gc {
+  color: #999;
+  background-color: #EAF2F5;
+}
@@ -0,0 +1,171 @@
+code {
+  font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace !important;
+  border-bottom-left-radius: 3px;
+  border-bottom-right-radius: 3px;
+  border-top-left-radius: 3px;
+  border-top-right-radius: 3px;
+  background-color: #f7f7f7 !important;
+  color: #333 !important;
+  font-size: 14px !important;
+  border: none !important;
+  padding: 5px !important;
+}
+
+pre > code {
+  line-height: 20px;
+  padding: 16px !important;
+}
+
+blockquote {
+  color: #777 !important;
+  border-left: 4px solid rgb(221, 221, 221);
+  padding-left: 16px;
+  padding-right: 16px;
+  margin-left: 0px !important;
+}
+
+/* Visited links purple is not a good idea */
+a:visited {
+  color: #008BF3;
+}
+
+a {
+  color: #008BF3;
+}
+
+h3, h4, h5, h6 {
+  color: #333 !important;
+}
+
+.rst-versions {
+  display: none !important;
+}
+
+/* The next and previous button we don't need */
+.rst-footer-buttons {
+  display: none;
+}
+
+/* Foldable parts */
+details > * {
+  margin-left: 20px;
+}
+details > summary {
+  margin-left: 0px; /* To overwrite the margin from above */
+
+  font-size: 120%;
+  cursor: pointer
+}
+
+/* Fix the design not having the correct spacing */
+.wy-menu-vertical .subnav li.current > a {
+  padding: 0.4045em 2.427em;
+}
+
+.toctree-l3 {
+  padding-left: 1.0em;
+}
+
+footer .fastlane {
+  margin: 20px 0;
+}
+
+footer .fastlane iframe {
+  vertical-align: middle;
+}
+
+/* Custom Syntax highlighting to look more like GitHub.com */
+.hljs-symbol {
+  color: #0086b3;
+}
+
+.hljs-keyword {
+  font-weight: normal;
+  color: #a71d5d;
+}
+
+.hljs-string {
+  color: #183691;
+}
+
+/* Header Anchors */
+/* From https://github.com/facelessuser/pymdown-extensions/blob/bf18d0635e9d91b0f98eacdcaa10f26e0ace0f20/doc_theme/css/theme_custom.css#L322-L395 */
+.rst-content .headeranchor-link {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  display: block;
+  padding-right: 6px;
+  padding-left: 30px;
+  margin-left: -30px;
+}
+
+.rst-content .headeranchor-link:focus {
+  outline: none;
+}
+
+.rst-content h1,
+.rst-content h2,
+.rst-content h3,
+.rst-content h4,
+.rst-content h5,
+.rst-content h6 {
+  position: relative;
+}
+
+.rst-content h1 .headeranchor,
+.rst-content h2 .headeranchor,
+.rst-content h3 .headeranchor,
+.rst-content h4 .headeranchor,
+.rst-content h5 .headeranchor,
+.rst-content h6 .headeranchor {
+  display: none;
+  color: #000;
+  vertical-align: middle;
+}
+
+.rst-content h1:hover .headeranchor-link,
+.rst-content h2:hover .headeranchor-link,
+.rst-content h3:hover .headeranchor-link,
+.rst-content h4:hover .headeranchor-link,
+.rst-content h5:hover .headeranchor-link,
+.rst-content h6:hover .headeranchor-link {
+  height: 1em;
+  padding-left: 8px;
+  margin-left: -30px;
+  text-decoration: none;
+}
+
+.rst-content h1:hover .headeranchor-link .headeranchor,
+.rst-content h2:hover .headeranchor-link .headeranchor,
+.rst-content h3:hover .headeranchor-link .headeranchor,
+.rst-content h4:hover .headeranchor-link .headeranchor,
+.rst-content h5:hover .headeranchor-link .headeranchor,
+.rst-content h6:hover .headeranchor-link .headeranchor {
+  display: inline-block;
+}
+
+.rst-content .headeranchor {
+  font: normal normal 16px FontAwesome;
+  line-height: 1;
+  display: inline-block;
+  text-decoration: none;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+.rst-content .headeranchor:before {
+  content: '\f0c1';
+}
+
+/* index.md badges */
+@media screen and (max-width: 768px) {
+  .badge img {
+    width: auto;
+  }
+}
@@ -0,0 +1,435 @@
+.wy-affix {
+  position: fixed;
+  top: 1.618em;
+}
+
+.wy-menu a:hover {
+  text-decoration: none;
+}
+
+.wy-menu-vertical header,
+.wy-menu-vertical p.caption {
+  height: 32px;
+  display: inline-block;
+  line-height: 32px;
+  padding: 0 1.618em;
+  margin-bottom: 0;
+  margin-top: 14px;
+  display: block;
+  font-weight: 700;
+  text-transform: uppercase;
+  font-size: 85%;
+  color: #ccc;
+  white-space: nowrap;
+}
+
+.wy-menu-vertical span {
+  color: #666;
+}
+
+.wy-menu-vertical ul {
+  margin-bottom: 0;
+}
+
+.wy-menu-vertical li.divide-top {
+  border-top: solid 1px #404040;
+}
+
+.wy-menu-vertical li.divide-bottom {
+  border-bottom: solid 1px #404040;
+}
+
+.wy-menu-vertical li.current {
+  background-color: #e5e5e5;
+}
+
+.wy-menu-vertical li.current a {
+  color: rgba(0, 93, 255, 0.7);
+  border-right: none;
+}
+
+.wy-menu-vertical li.current a:hover {
+  color: rgba(0, 93, 255, 0.9);
+}
+
+.wy-menu-vertical li code,
+.wy-menu-vertical li .rst-content tt,
+.rst-content .wy-menu-vertical li tt {
+  border: none;
+  background: inherit;
+  color: inherit;
+  padding-left: 0;
+  padding-right: 0
+}
+
+.wy-menu-vertical li span.toctree-expand {
+  display: block;
+  float: left;
+  margin-left: -1.2em;
+  font-size: .8em;
+  line-height: 1.6em;
+  color: #999;
+}
+
+.wy-menu-vertical li.on a,
+.wy-menu-vertical li.current>a {
+  color: rgba(0, 93, 255, 0.9);
+  font-weight: 700;
+  position: relative;
+  background: #fafafa;
+  border: none;
+}
+
+/*.wy-menu-vertical li.on a:hover span.toctree-expand,
+.wy-menu-vertical li.current>a:hover span.toctree-expand {
+  color: gray;
+}*/
+
+.wy-menu-vertical li.on a span.toctree-expand,
+.wy-menu-vertical li.current>a span.toctree-expand {
+  display: block;
+  font-size: .8em;
+  line-height: 1.6em;
+  color: #333;
+}
+
+.wy-menu-vertical li.toctree-l1.current li.toctree-l2>ul,
+.wy-menu-vertical li.toctree-l2.current li.toctree-l3>ul {
+  display: none;
+}
+
+.wy-menu-vertical li.toctree-l1.current li.toctree-l2.current>ul,
+.wy-menu-vertical li.toctree-l2.current li.toctree-l3.current>ul {
+  display: block;
+}
+
+.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a {
+  display: block;
+  padding: .4045em 4.045em;
+}
+
+.wy-menu-vertical li.toctree-l2 a:hover span.toctree-expand {
+  color: #999;
+}
+
+.wy-menu-vertical li.toctree-l2 span.toctree-expand {
+  color: #999;
+}
+
+.wy-menu-vertical li.toctree-l3 {
+  background-color: #eee;
+  font-size: .9em;
+}
+
+.wy-menu-vertical li.toctree-l3.current>a {
+  padding: .4045em 4.045em;
+}
+
+.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a {
+  display: block;
+  padding: .4045em 5.663em;
+  border-top: none;
+  border-bottom: none;
+}
+
+.wy-menu-vertical li.toctree-l3 a:hover span.toctree-expand {
+  color: rgba(0, 93, 255, 0.9);
+}
+
+.wy-menu-vertical li.toctree-l3 span.toctree-expand {
+  color: #999;
+}
+
+.wy-menu-vertical li.toctree-l4 {
+  font-size: .9em;
+}
+
+.wy-menu-vertical li.current ul {
+  display: block;
+}
+
+.wy-menu-vertical .local-toc li ul {
+  display: block;
+}
+
+.wy-menu-vertical li ul li a {
+  margin-bottom: 0;
+  color: rgba(0, 93, 255, 0.7);
+  font-weight: 400;
+}
+
+.wy-menu-vertical a {
+  display: inline-block;
+  line-height: 18px;
+  padding: .4045em 1.618em;
+  display: block;
+  position: relative;
+  font-size: 90%;
+  color: rgba(0, 93, 255, 0.7);
+}
+
+.wy-menu-vertical li.on a:hover,
+.wy-menu-vertical li.current>a:hover {
+  background-color: #fafafa;
+}
+
+.wy-menu-vertical a:hover {
+  color: rgba(0, 93, 255, 0.9);
+  cursor: pointer;
+  background-color: #fafafa;
+}
+
+.wy-menu-vertical a:hover span.toctree-expand {
+  color: rgba(0, 93, 255, 0.5);
+}
+
+.wy-menu-vertical a:active span.toctree-expand {
+  color: rgba(0, 93, 255, 0.7);
+}
+
+/* Search */
+
+.wy-side-nav-search {
+  z-index: 200;
+  background-color: #fafafa;
+  border-bottom: #333;
+  text-align: center;
+  padding: .809em;
+  display: block;
+  color: #333;
+  margin-bottom: .809em
+}
+
+.wy-side-nav-search input[type=text] {
+  width: 100%;
+  color: #333;
+  border-radius: 3px;
+  outline: 0;
+  padding: 10px;
+  background-color: #fff;
+  border: solid 1px #6d6d6d;
+  box-shadow: none
+}
+
+.wy-side-nav-search img {
+  display: block;
+  margin: auto auto .809em;
+  height: 45px;
+  width: 45px;
+  background-color: #2980B9;
+  padding: 5px;
+  border-radius: 100%
+}
+
+.wy-side-nav-search>a,
+.wy-side-nav-search .wy-dropdown>a {
+  color: #333;
+  font-size: 100%;
+  font-weight: 700;
+  display: inline-block;
+  padding: 4px 6px;
+  margin-bottom: .809em
+}
+
+.wy-side-nav-search>a:hover,
+.wy-side-nav-search .wy-dropdown>a:hover {
+  background: rgba(255,255,255,0.1)
+}
+
+.wy-side-nav-search>a img.logo,
+.wy-side-nav-search .wy-dropdown>a img.logo {
+  display: block;
+  margin: 0 auto;
+  height: auto;
+  width: auto;
+  border-radius: 0;
+  max-width: 100%;
+  background: transparent
+}
+
+.wy-side-nav-search>a.icon img.logo,
+.wy-side-nav-search .wy-dropdown>a.icon img.logo {
+  margin-top: .85em
+}
+
+.wy-nav .wy-menu-vertical header {
+  color: #2980B9
+}
+
+.wy-nav .wy-menu-vertical a {
+  color: #b3b3b3
+}
+
+.wy-nav .wy-menu-vertical a:hover {
+  background-color: #2980B9;
+  color: #fff
+}
+
+[data-menu-wrap] {
+  -webkit-transition: all .2s ease-in;
+  -moz-transition: all .2s ease-in;
+  transition: all .2s ease-in;
+  position: absolute;
+  opacity: 1;
+  width: 100%;
+  opacity: 0
+}
+
+[data-menu-wrap].move-center {
+  left: 0;
+  right: auto;
+  opacity: 1
+}
+
+[data-menu-wrap].move-left {
+  right: auto;
+  left: -100%;
+  opacity: 0
+}
+
+[data-menu-wrap].move-right {
+  right: -100%;
+  left: auto;
+  opacity: 0
+}
+
+.wy-body-for-nav {
+  background: left repeat-y #fcfcfc;
+  background-image: url(data:image/png;
+  base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyRpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMy1jMDExIDY2LjE0NTY2MSwgMjAxMi8wMi8wNi0xNDo1NjoyNyAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNiAoTWFjaW50b3NoKSIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDoxOERBMTRGRDBFMUUxMUUzODUwMkJCOThDMEVFNURFMCIgeG1wTU06RG9jdW1lbnRJRD0ieG1wLmRpZDoxOERBMTRGRTBFMUUxMUUzODUwMkJCOThDMEVFNURFMCI+IDx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjE4REExNEZCMEUxRTExRTM4NTAyQkI5OEMwRUU1REUwIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjE4REExNEZDMEUxRTExRTM4NTAyQkI5OEMwRUU1REUwIi8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwveDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+EwrlwAAAAA5JREFUeNpiMDU0BAgwAAE2AJgB9BnaAAAAAElFTkSuQmCC);
+  background-size: 300px 1px
+}
+
+.wy-grid-for-nav {
+  position: absolute;
+  width: 100%;
+  height: 100%
+}
+
+.wy-nav-side {
+  position: fixed;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  padding-bottom: 2em;
+  width: 300px;
+  overflow-x: hidden;
+  overflow-y: scroll;
+  min-height: 100%;
+  background-color: #fafafa;
+  z-index: 200;
+  border-right: 2px solid #eee;
+}
+
+.wy-nav-top {
+  display: none;
+  background-color: #333;
+  color: #fff;
+  padding: .4045em .809em;
+  position: relative;
+  line-height: 50px;
+  text-align: center;
+  font-size: 100%;
+  *zoom: 1
+}
+
+.wy-nav-top:before,
+.wy-nav-top:after {
+  display: table;
+  content: ""
+}
+
+.wy-nav-top:after {
+  clear: both
+}
+
+.wy-nav-top a {
+  color: #fff;
+  font-weight: 700
+}
+
+.wy-nav-top img {
+  margin-right: 12px;
+  height: 45px;
+  width: 45px;
+  background-color: #2980B9;
+  padding: 5px;
+  border-radius: 100%
+}
+
+.wy-nav-top i {
+  font-size: 30px;
+  line-height: 50px;
+  float: left;
+  cursor: pointer
+}
+
+.wy-nav-content-wrap {
+  margin-left: 300px;
+  background: #fcfcfc;
+  min-height: 100%
+}
+
+.wy-nav-content {
+  padding: 1.618em 3.236em;
+  height: 100%;
+  max-width: 1100px;
+  margin: auto
+}
+
+.wy-body-mask {
+  position: fixed;
+  width: 100%;
+  height: 100%;
+  background: rgba(0,0,0,0.2);
+  display: none;
+  z-index: 499
+}
+
+.wy-body-mask.on {
+  display: block
+}
+
+@media screen and (max-width: 768px) {
+  .wy-body-for-nav {
+    background: #fcfcfc
+  }
+
+  .wy-nav-top {
+    display: block
+  }
+
+  .wy-nav-side {
+    left: -300px
+  }
+
+  .wy-nav-side.shift {
+    width: 85%;
+    left: 0
+  }
+
+  .wy-nav-content-wrap {
+    margin-left: 0
+  }
+
+  .wy-nav-content-wrap .wy-nav-content {
+    padding: 1.618em
+  }
+
+  .wy-nav-content-wrap.shift {
+    position: fixed;
+    min-width: 100%;
+    left: 85%;
+    top: 0;
+    height: 100%;
+    overflow: hidden
+  }
+
+}
+
+@media screen and (min-width: 1400px) {
+  .wy-nav-content {
+    margin: 0;
+    background: #fcfcfc
+  }
+}
@@ -0,0 +1,17 @@
+### Overview
+Gor architecture tries to follow UNIX philosophy: everything made of pipes, various inputs multiplexing data to outputs.
+
+You can [rate limit](/rate-limiting.md), [filter](request-filtering.md), [rewrite](request-rewriting.md) requests or even use your own [middleware](middleware.md) to implement custom logic. Also, it is possible to replay requests at the higher rate for [load testing](saving-and-replaying-from-file.md).
+
+### Available inputs
+
+* `--input-raw` - used to capture HTTP traffic, you should specify IP address or interface and application port. More about [[Capturing and replaying traffic]]. 
+* `--input-file` - accepts file which previously was recorded using ` --output-file`. More about [[Saving and Replaying from file]]
+* `--input-tcp` - used by Gor aggregation instance if you decided forward traffic from multiple forwarder Gor instances to it. Read about using [[Aggregator-forwarder setup]].
+
+### Available outputs
+
+* `--output-http` - replay HTTP traffic to given endpoint, accepts base url. Read [more about it](Replaying HTTP traffic)
+* `--output-file` - records incoming traffic to the file. More about [[Saving and Replaying from file]]
+* `--output-tcp` - forward incoming data to another Gor instance, used in conjunction with `--input-tcp`. Read more about [[Aggregator-forwarder setup]].
+* `--output-stdout` - used for debugging, outputs all data to stdout.
@@ -0,0 +1,44 @@
+### Dependencies
+To start working with Gor, you need to have a web server running on your machine, and a terminal to run commands. If you are just poking around, you can quickly start the server by calling `gor file-server :8000`, this will start a simple file server of the current directory on port `8000`. 
+
+### Installing Gor
+Download the latest Gor binary from https://github.com/buger/gor/releases (we provide precompiled binaries for Windows, Linux x64 and Mac OS), or you can compile by yourself [[Compilation]].
+
+Once the archive is downloaded and uncompressed, you can run Gor from the current directory, or you may want to copy binary to your PATH (for Linux and Mac OS it can be `/usr/local/bin`).
+
+### Capturing web traffic
+Now run this command in terminal: `sudo ./gor --input-raw :8000 --output-stdout`
+
+This command says to listen for all network activity happening on port 8000 and log it to stdout.
+If you are familiar with `tcpdump`, we are going to implement similar functionality. 
+
+> You may notice that it uses `sudo` and asks for the password: to analyze network, Gor needs permissions which are available only to super users.
+> However, it is possible to configure Gor [being run for non-root users](Running-as-non-root-user).
+
+
+Make a few requests by opening `http://localhost:8000` in your browser, or just by calling curl in terminal `curl http://localhost:8000`. You should see that `gor` outputs all the HTTP requests and responses right to the terminal window where it is running. 
+
+
+**Gor is not a proxy:** you do not need to put 3-rd party tool to your critical path. Instead Gor just silently analyzes the traffic of your application and does not affect it anyhow.
+
+### Replaying
+
+Now it's time to replay your original traffic to another environment. Let's start the same file web server but on a different port: `gor file-server :8001`. 
+
+Instead of `--output-stdout` we will use `--output-http` and provide URL of second server: `sudo ./gor --input-raw :8000 --output-http="http://localhost:8001"`
+
+Make few requests to first server. You should see them replicated to the second one, voila! 
+
+### Saving requests to file and replaying them later
+Sometimes it's not possible to replay requests in real time; Gor allows you to save requests to the file and replay them later. 
+
+First use `--output-file` to save them: `sudo ./gor --input-raw :8000 --output-file=requests.gor`. This will create new file and continuously write all captured requests to it. 
+
+Let's re-run Gor, but now to replay requests from file: `./gor --input-file requests.gor --output-http="http://localhost:8001"`. You should see all the recorded requests coming to the second server, and they will be replayed in the same order and with exactly same timing as they were recorded.
+
+Next: [[The Basics]]
+
+### Watch an overview:
+
+
+![YOUTUBE](https://www.youtube.com/watch?v=CxuKZcMKaW4)
@@ -0,0 +1,29 @@
+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.
+
+Read for more info:
+
+* [[Getting Started]]
+* [[The Basics]]
+* [[Capturing and replaying traffic]]
+* [[Replaying HTTP traffic]]
+* [[[PRO] Replaying Binary protocols]]
+* [[[PRO] Recording and replaying keep alive TCP sessions]]
+* [[Saving and Replaying from file]]
+* [Performance testing](https://github.com/buger/gor/wiki/Saving-and-Replaying-from-file#performance-testing)
+* [[Rate limiting]]
+* [[Request filtering]]
+* [[Request rewriting]]
+* [[Middleware]]
+* [[Distributed configuration]]
+* [[Exporting to ElasticSearch]]
+* [[FAQ]]
+* [[Troubleshooting]]
+
+## Commercial Aspects
+
+* [[Commercial Support]]
+* [[Commercial FAQ]]
+* [[Commercial collaboration]]
+
+
+Next: [Getting Started](Getting-Started)
@@ -0,0 +1,7 @@
+$(document).ready(function () {
+    $('img[alt="YOUTUBE"]').each(function () {
+        var id = $(this).attr('src').split('/')[$(this).attr('src').split('/').length - 1].split("=")[1];
+        var video = '<iframe style="width: 100%;height: 450px;" src="https://www.youtube.com/embed/' + id + '" frameborder="0" allowfullscreen></iframe>';
+        $(this).replaceWith(video);
+    });
+});
@@ -0,0 +1,11 @@
+> **This feature available only in PRO version. See https://goreplay.org/pro.html for details.**
+
+By default, GoReplay does not guarantee that when you record keep-alive TCP session, it will be replayed in the same TCP connection as well. This is ok for most of the cases, but it does not give an accurate number of TCP sessions while replaying, also may cause issues if your application state depends on TCP session (do not mess with HTTP session).
+
+[GoReplay PRO](https://goreplay.org/pro.html) extension adds support for accurate recording and replaying of keep-alive TCP sessions. Separate connection to your server is created per original session and it makes benchmarks and tests incredibly accurate. To enable session recognition you just need to pass `--recognize-tcp-sessions` option. 
+
+```
+gor --input-raw :80 --recognize-tcp-sessions --output-http http://test.target
+```
+
+Note that enabling this option also change algorithm of distributing traffic when using `--split-output`, see [Distributed configuration].
@@ -0,0 +1,14 @@
+> **This feature available only in PRO version. See https://goreplay.org/pro.html for details.**
+
+Gor includes basic support for working with binary formats like `thrift` or `protocol-buffers`. To start set `--input-raw-protocol` to 'binary' (by default 'http'). For replaying, you should use `--output-binary`, example:
+
+```
+gor --input-raw :80 --input-raw-protocol binary --output-binary staging:8081
+```
+
+While working with `--input-raw` you may notice a 2-second delay before messages are emitted to the outputs. This behaviour is expected and happening because for general binary protocol it is impossible to know when TCP message ends, so Gor has to set inactivity timeout. Each protocol has own rules (for example write message length as first bytes), and require individual handling to know message length. We consider improving detailed protocol support for `thrift`, `protocol-buffer` and etc.
+
+Note that you can use all load testing features for binary protocols. For example, the following command will loop and replay recorded payload on 10x speed for 30 seconds:
+```
+gor --input-file './binary*.gor|1000%' --output-binary staging:9091 --input-file-loop --exit-after 30s
+```
@@ -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
 }
@@ -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)
@@ -27,18 +27,18 @@ func Start(stop chan int) {
 		for _, in := range Plugins.Inputs {
 			go CopyMulty(in, Plugins.Outputs...)
 		}
+
+		for _, out := range Plugins.Outputs {
+			if r, ok := out.(io.Reader); ok {
+				go CopyMulty(r, Plugins.Outputs...)
+			}
+		}
 	}

 	for {
 		select {
 		case <-stop:
-			pluginMu.Lock()
-			for _, p := range Plugins.All {
-				if cp, ok := p.(io.Closer); ok {
-					cp.Close()
-				}
-			}
-			pluginMu.Unlock()
+			finalize()
 			return
 		case <-time.After(100 * time.Millisecond):
 		}
@@ -50,12 +50,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 {
@@ -66,26 +72,38 @@ 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
+					}
 				}
 			}

+			if Settings.prettifyHTTP {
+				payload = prettifyHTTP(payload)
+			}
+
 			if Settings.splitOutput {
 				// Simple round robin
 				writers[wIndex].Write(payload)
@@ -109,6 +127,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
 }
@@ -5,6 +5,7 @@ import (
 	"sync"
 	"sync/atomic"
 	"testing"
+	"time"
 )

 func TestEmitter(t *testing.T) {
@@ -31,6 +32,53 @@ 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)
+
+	Settings.modifierConfig = HTTPModifierConfig{}
+}
+
 func TestEmitterRoundRobin(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)
@@ -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))))
+
+
@@ -2,8 +2,25 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;

-public class echo {
-    public static void main(String[] args) {
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+
+
+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);
@@ -12,16 +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) {
        }
    }
-}
+}
@@ -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
@@ -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
@@ -7,6 +7,8 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"net/http"
+	"net/http/httputil"
 	"os"
 	"os/signal"
 	"runtime"
@@ -22,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() {
@@ -35,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")
@@ -52,21 +74,35 @@ func main() {
 		profileCPU(*cpuprofile)
 	}

-	Start(nil)
-
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 	go func() {
 		<-c
-
-		for _, p := range Plugins.All {
-			if cp, ok := p.(io.Closer); ok {
-				cp.Close()
-			}
-		}
-
+		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) {
@@ -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
@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"crypto/tls"
+	"encoding/base64"
 	"io"
 	"log"
 	"net"
@@ -44,6 +45,7 @@ type HTTPClient struct {
 	baseURL        string
 	scheme         string
 	host           string
+	auth           string
 	conn           net.Conn
 	respBuf        []byte
 	config         *HTTPClientConfig
@@ -56,17 +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 == 0 {
+		config.Timeout = time.Second
 	}

-	if config.Timeout.Nanoseconds() == 0 {
-		config.Timeout = 5 * time.Second
-	}
-
-	config.ConnectionTimeout = time.Second
+	config.ConnectionTimeout = config.Timeout

 	if config.ResponseBufferSize == 0 {
 		config.ResponseBufferSize = 100 * 1024 // 100kb
@@ -79,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
 }

@@ -86,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
@@ -164,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))
 	}
@@ -206,9 +211,14 @@ func (c *HTTPClient) Send(data []byte) (response []byte, err error) {
 					if bytes.Equal(proto.Header(c.respBuf, []byte("Transfer-Encoding")), []byte("chunked")) {
 						chunked = true
 					} else {
-						l := proto.Header(c.respBuf, []byte("Content-Length"))
-						if len(l) > 0 {
-							contentLength, _ = strconv.Atoi(string(l))
+						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))
+							}
 						}
 					}

@@ -312,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
@@ -11,6 +11,7 @@ import (
 	"net/http/httptest"
 	"net/http/httputil"
 	_ "reflect"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -23,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{})
@@ -87,6 +88,37 @@ func TestHTTPClientSend(t *testing.T) {
 	wg.Wait()
 }

+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)
+
+			conn.Write([]byte("HTTP/1.1 200 OK\r\n\r\n"))
+			conn.Write([]byte("ab"))
+			conn.Close()
+
+			wg.Done()
+		}
+	}()
+
+	client := NewHTTPClient(ln.Addr().String(), &HTTPClientConfig{Debug: true})
+
+	wg.Add(1)
+	resp, _ := client.Send(payload)
+
+	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 {
@@ -325,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)

@@ -43,7 +43,8 @@ func (h *HTTPHeaderFilters) Set(value string) error {
 	if len(valArr) < 2 {
 		return errors.New("need both header and value, colon-delimited (ex. user_id:^169$).")
 	}
-	r, err := regexp.Compile(valArr[1])
+	val := strings.TrimSpace(valArr[1])
+	r, err := regexp.Compile(val)
 	if err != nil {
 		return err
 	}
@@ -75,14 +76,16 @@ func (h *HTTPHashFilters) Set(value string) error {

 	f := hashFilter{name: []byte(valArr[0])}

-	if strings.Contains(valArr[1], "%") {
-		p, _ := strconv.ParseInt(valArr[1][:len(valArr[1])-1], 0, 0)
+	val := strings.TrimSpace(valArr[1])
+
+	if strings.Contains(val, "%") {
+		p, _ := strconv.ParseInt(val[:len(val)-1], 0, 0)
 		f.percent = uint32(p)
-	} else if strings.Contains(valArr[1], "/") {
+	} else if strings.Contains(val, "/") {
 		// DEPRECATED format
 		var num, den uint64

-		fracArr := strings.Split(valArr[1], "/")
+		fracArr := strings.Split(val, "/")
 		num, _ = strconv.ParseUint(fracArr[0], 10, 64)
 		den, _ = strconv.ParseUint(fracArr[1], 10, 64)

@@ -64,6 +64,18 @@ func TestHTTPModifierHeaderNegativeFilters(t *testing.T) {
 	if len(modifier.Rewrite(payload)) != 0 {
 		t.Error("Request should not pass filters")
 	}
+
+	filters = HTTPHeaderFilters{}
+	// Setting filter that not match our header
+	filters.Set("Host: www*")
+
+	modifier = NewHTTPModifier(&HTTPModifierConfig{
+		headerNegativeFilters: filters,
+	})
+
+	if len(modifier.Rewrite(payload)) != 0 {
+		t.Error("Request should not pass filters")
+	}
 }

 func TestHTTPModifierURLRewrite(t *testing.T) {
@@ -0,0 +1,68 @@
+package main
+
+import (
+    "github.com/buger/gor/proto"
+    "bytes"
+    "compress/gzip"
+    "strconv"
+    "io/ioutil"
+    "net/http/httputil"
+)
+
+func prettifyHTTP(p []byte) []byte {
+    headSize := bytes.IndexByte(p, '\n') + 1
+    head := p[:headSize]
+    body := p[headSize:]
+
+    headersPos := proto.MIMEHeadersEndPos(body)
+    headers := body[:headersPos]
+    content := body[headersPos:]
+
+    var tEnc, cEnc []byte
+    proto.ParseHeaders([][]byte{headers}, func(header, value []byte) bool {
+        if proto.HeadersEqual(header, []byte("Transfer-Encoding")) {
+            tEnc = value
+        }
+
+        if proto.HeadersEqual(header, []byte("Content-Encoding")) {
+            cEnc = value
+        }
+
+        return true
+    })
+
+    if len(tEnc) == 0 && len(cEnc) == 0 {
+        return p
+    }
+
+    if bytes.Equal(tEnc, []byte("chunked")) {
+        buf := bytes.NewBuffer(content)
+        r := httputil.NewChunkedReader(buf)
+        content, _ = ioutil.ReadAll(r)
+
+        headers = proto.DeleteHeader(headers, []byte("Transfer-Encoding"))
+
+        newLen := strconv.Itoa(len(content))
+        headers = proto.SetHeader(headers, []byte("Content-Length"), []byte(newLen))
+    }
+
+    if bytes.Equal(cEnc, []byte("gzip")) {
+        buf := bytes.NewBuffer(content)
+        g, err := gzip.NewReader(buf)
+
+        if err != nil {
+            Debug("[Prettifier] GZIP encoding error:", err)
+        }
+
+        content, _ = ioutil.ReadAll(g)
+
+        headers = proto.DeleteHeader(headers, []byte("Content-Encoding"))
+
+        newLen := strconv.Itoa(len(content))
+        headers = proto.SetHeader(headers, []byte("Content-Length"), []byte(newLen))
+    }
+
+    newPayload := append(append(head, headers...), content...)
+
+    return newPayload
+}
@@ -0,0 +1,36 @@
+package main
+
+import (
+    "compress/gzip"
+    "testing"
+    "strconv"
+    "bytes"
+)
+
+func TestHTTPPrettifierGzip(t *testing.T) {
+    b := bytes.NewBufferString("")
+    w := gzip.NewWriter(b)
+    w.Write([]byte("test"))
+    w.Close()
+
+    size := strconv.Itoa(len(b.Bytes()))
+
+    payload := []byte("2 1 1\nHTTP/1.1 200 OK\r\nContent-Length: " + size + "\r\nContent-Encoding: gzip\r\n\r\n")
+    payload = append(payload, b.Bytes()...)
+
+    newPayload := prettifyHTTP(payload)
+
+    if string(newPayload) != "2 1 1\nHTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\ntest" {
+        t.Error("Payload not match:", string(newPayload))
+    }
+}
+
+func TestHTTPPrettifierChunked(t *testing.T) {
+    payload := []byte("POST / HTTP/1.1\r\nHost: www.w3.org\r\nTransfer-Encoding: chunked\r\n\r\n4\r\nWiki\r\n5\r\npedia\r\ne\r\n in\r\n\r\nchunks.\r\n0\r\n\r\n")
+
+    newPayload := prettifyHTTP(payload)
+
+    if string(newPayload) != "POST / HTTP/1.1\r\nHost: www.w3.org\r\nContent-Length: 23\r\n\r\nWikipedia in\r\n\r\nchunks." {
+        t.Error("Payload not match:", string(newPayload))
+    }
+}
@@ -34,10 +34,10 @@ func (i *DummyInput) emit() {
 		select {
 		case <-ticker.C:
 			uuid := uuid()
-			reqh := payloadHeader(RequestPayload, uuid, time.Now().UnixNano())
+			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")...)
 		}
 	}
@@ -3,42 +3,157 @@ 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) {
@@ -52,56 +167,72 @@ func (i *FileInput) String() string {
 	return "File input: " + i.path
 }

-func (i *FileInput) emit() {
-	var lastTime int64
+// 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
+		}

-	payloadSeparatorAsBytes := []byte(payloadSeparator)
-	reader := bufio.NewReader(i.file)
-	var buffer bytes.Buffer
+		if next == nil || r.timestamp < next.timestamp {
+			next = r
+			continue
+		}
+	}
+
+	return
+}
+
+func (i *FileInput) emit() {
+	var lastTime int64 = -1

 	for {
-		line, err := reader.ReadBytes('\n')
-
-		if err != nil {
-			if err != io.EOF {
-				log.Fatal(err)
-			}
-			break
-
+		select {
+		case <-i.exit:
+			return
+		default:
 		}

-		if bytes.Equal(payloadSeparatorAsBytes[1:], line) {
-			asBytes := buffer.Bytes()
-			buffer.Reset()
+		reader := i.nextReader()

-			meta := payloadMeta(asBytes)
+		if reader == nil {
+			if i.loop {
+				i.init()
+				lastTime = -1
+				continue
+			} else {
+				break
+			}
+		}

-			if len(meta) > 2 && meta[0][0] == RequestPayload {
-				ts, _ := strconv.ParseInt(string(meta[2]), 10, 64)
+		if lastTime != -1 {
+			diff := reader.timestamp - lastTime
+			lastTime = reader.timestamp

-				if lastTime != 0 {
-					timeDiff := ts - lastTime
-
-					if i.speedFactor != 1 {
-						timeDiff = int64(float64(timeDiff) / i.speedFactor)
-					}
-
-					time.Sleep(time.Duration(timeDiff))
-				}
-
-				lastTime = ts
+			if i.speedFactor != 1 {
+				diff = int64(float64(diff) / i.speedFactor)
 			}

-			// Bytes() returns only pointer, so to remove data-race copy the data to an array
-			newBuf := make([]byte, len(asBytes)-1)
-			copy(newBuf, asBytes)
-
-			i.data <- newBuf
+			time.Sleep(time.Duration(diff))
 		} else {
-			buffer.Write(line)
+			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
+}
@@ -3,8 +3,11 @@ package main
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"io"
 	"io/ioutil"
+	"log"
+	"math/rand"
 	"os"
 	"sync"
 	"syscall"
@@ -12,6 +15,8 @@ import (
 	"time"
 )

+var _ = log.Println
+
 func TestInputFileWithGET(t *testing.T) {

 	input := NewTestInput()
@@ -35,7 +40,6 @@ func TestInputFileWithGET(t *testing.T) {
 			t.Error("Request read back from file should match")
 		}
 	}
-
 }

 func TestInputFileWithPayloadLargerThan64Kb(t *testing.T) {
@@ -93,6 +97,164 @@ func TestInputFileWithGETAndPOST(t *testing.T) {

 }

+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
@@ -133,11 +295,9 @@ func (expectedCaptureFile *CaptureFile) PayloadsEqual(other [][]byte) bool {
 	}

 	for i, payload := range other {
-
 		if !bytes.Equal(expectedCaptureFile.data[i], payload) {
 			return false
 		}
-
 	}

 	return true
@@ -155,13 +315,12 @@ func CreateCaptureFile(requestGenerator *RequestGenerator) *CaptureFile {

 	readPayloads := [][]byte{}
 	output := NewTestOutput(func(data []byte) {
-
 		readPayloads = append(readPayloads, Duplicate(data))

 		requestGenerator.wg.Done()
 	})

-	outputFile := NewFileOutput(f.Name())
+	outputFile := NewFileOutput(f.Name(), &FileOutputConfig{flushInterval: time.Minute, append: true})

 	Plugins.Inputs = requestGenerator.inputs
 	Plugins.Outputs = []io.Writer{output, outputFile}
@@ -171,6 +330,9 @@ func CreateCaptureFile(requestGenerator *RequestGenerator) *CaptureFile {
 	requestGenerator.emit()
 	requestGenerator.wg.Wait()

+	time.Sleep(100 * time.Millisecond)
+	outputFile.Close()
+
 	close(quit)

 	return NewExpectedCaptureFile(readPayloads, f)
@@ -182,7 +344,7 @@ func ReadFromCaptureFile(captureFile *os.File, count int, callback writeCallback
 	quit := make(chan int)
 	wg := new(sync.WaitGroup)

-	input := NewFileInput(captureFile.Name())
+	input := NewFileInput(captureFile.Name(), false)
 	output := NewTestOutput(func(data []byte) {
 		callback(data)
 		wg.Done()
@@ -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)
@@ -0,0 +1,103 @@
+package main
+
+import (
+	"encoding/json"
+	"github.com/Shopify/sarama"
+	"github.com/Shopify/sarama/mocks"
+	"log"
+)
+
+// KafkaInput is used for recieving Kafka messages and
+// transforming them into HTTP payloads.
+type KafkaInput struct {
+	config    *KafkaConfig
+	consumers []sarama.PartitionConsumer
+	messages  chan *sarama.ConsumerMessage
+}
+
+// NewKafkaInput creates instance of kafka consumer client.
+func NewKafkaInput(address string, config *KafkaConfig) *KafkaInput {
+	c := sarama.NewConfig()
+	// Configuration options go here
+
+	var con sarama.Consumer
+
+	if config.consumer.(*mocks.Consumer) != nil {
+		con = config.consumer
+	} else {
+		var err error
+		con, err = sarama.NewConsumer([]string{config.host}, c)
+
+		if err != nil {
+			log.Fatalln("Failed to start Sarama(Kafka) consumer:", err)
+		}
+	}
+
+	partitions, err := con.Partitions(config.topic)
+	if err != nil {
+		log.Fatalln("Failed to collect Sarama(Kafka) partitions:", err)
+	}
+
+	i := &KafkaInput{
+		config:    config,
+		consumers: make([]sarama.PartitionConsumer, len(partitions)),
+		messages:  make(chan *sarama.ConsumerMessage, 256),
+	}
+
+	for index, partition := range partitions {
+		consumer, err := con.ConsumePartition(config.topic, partition, sarama.OffsetNewest)
+		if err != nil {
+			log.Fatalln("Failed to start Sarama(Kafka) partition consumer:", err)
+		}
+
+		go func(consumer sarama.PartitionConsumer) {
+			defer consumer.Close()
+
+			for message := range consumer.Messages() {
+				i.messages <- message
+			}
+		}(consumer)
+
+		if Settings.verbose {
+			// Start infinite loop for tracking errors for kafka producer.
+			go i.ErrorHandler(consumer)
+		}
+
+		i.consumers[index] = consumer
+	}
+
+	return i
+}
+
+// ErrorHandler should receive errors
+func (i *KafkaInput) ErrorHandler(consumer sarama.PartitionConsumer) {
+	for err := range consumer.Errors() {
+		log.Println("Failed to read access log entry:", err)
+	}
+}
+
+func (i *KafkaInput) Read(data []byte) (int, error) {
+	message := <-i.messages
+
+	if !i.config.useJSON {
+		copy(data, message.Value)
+		return len(message.Value), nil
+	} else {
+		var kafkaMessage KafkaMessage
+		json.Unmarshal(message.Value, &kafkaMessage)
+
+		buf, err := kafkaMessage.Dump()
+		if err != nil {
+			log.Println("Failed to decode access log entry:", err)
+			return 0, err
+		}
+
+		copy(data, buf)
+
+		return len(buf), nil
+	}
+}
+
+func (i *KafkaInput) String() string {
+	return "Kafka Input: " + i.config.host + "/" + i.config.topic
+}
@@ -0,0 +1,61 @@
+package main
+
+import (
+	"github.com/Shopify/sarama"
+	"github.com/Shopify/sarama/mocks"
+	"testing"
+)
+
+func TestInputKafkaRAW(t *testing.T) {
+	consumer := mocks.NewConsumer(t, nil)
+	defer consumer.Close()
+
+	consumer.ExpectConsumePartition("test", 0, mocks.AnyOffset).YieldMessage(&sarama.ConsumerMessage{Value: []byte("1 2 3\nGET / HTTP1.1\r\nHeader: 1\r\n\r\n")})
+	consumer.SetTopicMetadata(
+		map[string][]int32{"test": {0}},
+	)
+
+	input := NewKafkaInput("", &KafkaConfig{
+		consumer: consumer,
+		topic:    "test",
+		useJSON:  false,
+	})
+
+	buf := make([]byte, 1024)
+	n, err := input.Read(buf)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(buf[:n]) != "1 2 3\nGET / HTTP1.1\r\nHeader: 1\r\n\r\n" {
+		t.Error("Message not properly decoded: ", string(buf[:n]), n)
+	}
+}
+
+func TestInputKafkaJSON(t *testing.T) {
+	consumer := mocks.NewConsumer(t, nil)
+	defer consumer.Close()
+
+	consumer.ExpectConsumePartition("test", 0, mocks.AnyOffset).YieldMessage(&sarama.ConsumerMessage{Value: []byte(`{"Req_URL":"/","Req_Type":"1","Req_ID":"2","Req_Ts":"3","Req_Method":"GET","Req_Headers":{"Header":"1"}}`)})
+	consumer.SetTopicMetadata(
+		map[string][]int32{"test": {0}},
+	)
+
+	input := NewKafkaInput("", &KafkaConfig{
+		consumer: consumer,
+		topic:    "test",
+		useJSON:  true,
+	})
+
+	buf := make([]byte, 1024)
+	n, err := input.Read(buf)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(buf[:n]) != "1 2 3\nGET / HTTP/1.1\r\nHeader: 1\r\n\r\n" {
+		t.Error("Message not properly decoded: ", string(buf[:n]), n)
+	}
+}
@@ -1,6 +1,7 @@
 package main

 import (
+	"github.com/buger/gor/proto"
 	raw "github.com/buger/gor/raw_socket_listener"
 	"log"
 	"net"
@@ -14,6 +15,7 @@ type RAWInput struct {
 	expire        time.Duration
 	quit          chan bool
 	engine        int
+	realIPHeader  []byte
 	trackResponse bool
 	listener      *raw.Listener
 }
@@ -22,15 +24,17 @@ type RAWInput struct {
 const (
 	EngineRawSocket = 1 << iota
 	EnginePcap
+	EnginePcapFile
 )

 // NewRAWInput constructor for RAWInput. Accepts address with port as argument.
-func NewRAWInput(address string, engine int, trackResponse bool, 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

@@ -47,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.AssocMessage.Start.UnixNano())
+		header = payloadHeader(ResponsePayload, msg.UUID(), msg.AssocMessage.Start.UnixNano(), msg.End.UnixNano()-msg.AssocMessage.Start.UnixNano())
 	}

 	copy(data[0:len(header)], header)
@@ -63,6 +70,12 @@ func (i *RAWInput) listen(address string) {

 	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)
 	}
@@ -91,7 +104,8 @@ func (i *RAWInput) String() string {
 	return "Intercepting traffic from: " + i.address
 }

-func (i *RAWInput) Close() {
+func (i *RAWInput) Close() error {
 	i.listener.Close()
 	close(i.quit)
+	return nil
 }
@@ -2,6 +2,7 @@ package main

 import (
 	"bytes"
+	"github.com/buger/gor/proto"
 	"io"
 	"io/ioutil"
 	"log"
@@ -22,7 +23,7 @@ import (

 const testRawExpire = time.Millisecond * 200

-func TestRAWInput(t *testing.T) {
+func TestRAWInputIPv4(t *testing.T) {
 	wg := new(sync.WaitGroup)
 	quit := make(chan int)

@@ -42,11 +43,15 @@ func TestRAWInput(t *testing.T) {

 	var respCounter, reqCounter int64

-	input := NewRAWInput(originAddr, EnginePcap, true, 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)
@@ -74,6 +79,55 @@ func TestRAWInput(t *testing.T) {
 	}

 	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)
 }

@@ -97,7 +151,7 @@ func TestRAWInputIPv6(t *testing.T) {

 	var respCounter, reqCounter int64

-	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire)
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire, "")
 	defer input.Close()

 	output := NewTestOutput(func(data []byte) {
@@ -148,7 +202,7 @@ func TestInputRAW100Expect(t *testing.T) {

 	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)

-	input := NewRAWInput(originAddr, EnginePcap, true, time.Second)
+	input := NewRAWInput(originAddr, EnginePcap, true, time.Second, "")
 	defer input.Close()

 	// We will use it to get content of raw HTTP request
@@ -211,7 +265,7 @@ func TestInputRAWChunkedEncoding(t *testing.T) {
 	}))

 	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
-	input := NewRAWInput(originAddr, EnginePcap, true, time.Second)
+	input := NewRAWInput(originAddr, EnginePcap, true, time.Second, "")
 	defer input.Close()

 	replay := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -275,7 +329,7 @@ func TestInputRAWLargePayload(t *testing.T) {
 	}))
 	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)

-	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire)
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire, "")
 	defer input.Close()

 	replay := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
@@ -320,7 +374,7 @@ func BenchmarkRAWInput(b *testing.B) {

 	var respCounter, reqCounter int64

-	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire)
+	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire, "")
 	defer input.Close()

 	output := NewTestOutput(func(data []byte) {
@@ -0,0 +1,49 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/Shopify/sarama"
+	"github.com/buger/gor/proto"
+)
+
+// KafkaConfig should contains required information to
+// build producers.
+type KafkaConfig struct {
+	host     string
+	topic    string
+	producer sarama.AsyncProducer
+	consumer sarama.Consumer
+	useJSON  bool
+}
+
+// KafkaMessage should contains catched request information that should be
+// passed as Json to Apache Kafka.
+type KafkaMessage struct {
+	ReqURL     string            `json:"Req_URL"`
+	ReqType    string            `json:"Req_Type"`
+	ReqID      string            `json:"Req_ID"`
+	ReqTs      string            `json:"Req_Ts"`
+	ReqMethod  string            `json:"Req_Method"`
+	ReqBody    string            `json:"Req_Body,omitempty"`
+	ReqHeaders map[string]string `json:"Req_Headers,omitempty"`
+}
+
+// Dump returns the given request in its HTTP/1.x wire
+// representation.
+func (m KafkaMessage) Dump() ([]byte, error) {
+	var b bytes.Buffer
+
+	b.WriteString(fmt.Sprintf("%s %s %s\n", m.ReqType, m.ReqID, m.ReqTs))
+	b.WriteString(fmt.Sprintf("%s %s HTTP/1.1", m.ReqMethod, m.ReqURL))
+	b.Write(proto.CLRF)
+	for key, value := range m.ReqHeaders {
+		b.WriteString(fmt.Sprintf("%s: %s", key, value))
+		b.Write(proto.CLRF)
+	}
+
+	b.Write(proto.CLRF)
+	b.WriteString(m.ReqBody)
+
+	return b.Bytes(), nil
+}
@@ -82,7 +82,11 @@ func (l *Limiter) Write(data []byte) (n int, err error) {
 }

 func (l *Limiter) Read(data []byte) (n int, err error) {
-	n, err = l.plugin.(io.Reader).Read(data)
+	if r, ok := l.plugin.(io.Reader); ok {
+		n, err = r.Read(data)
+	} else {
+		return 0, nil
+	}

 	if l.isLimited() {
 		return 0, nil
@@ -117,7 +117,7 @@ func TestEchoMiddleware(t *testing.T) {

 	// Catch traffic from one service
 	fromAddr := strings.Replace(from.Listener.Addr().String(), "[::]", "127.0.0.1", -1)
-	input := NewRAWInput(fromAddr, EnginePcap, true, testRawExpire)
+	input := NewRAWInput(fromAddr, EnginePcap, true, testRawExpire, "")
 	defer input.Close()

 	// And redirect to another
@@ -179,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, EnginePcap, true, testRawExpire)
+	input := NewRAWInput(fromAddr, EnginePcap, true, testRawExpire, "")
 	defer input.Close()

 	// And redirect to another
@@ -0,0 +1,2 @@
+site_name: My Docs
+theme: readthedocs
@@ -1,47 +1,262 @@
 package main

 import (
+	"bufio"
+	"compress/gzip"
+	"fmt"
 	"io"
 	"log"
 	"os"
+	"path/filepath"
+	"runtime/debug"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
 )

+var dateFileNameFuncs = map[string]func(*FileOutput) string{
+	"%Y":  func(o *FileOutput) string { return time.Now().Format("2006") },
+	"%m":  func(o *FileOutput) string { return time.Now().Format("01") },
+	"%d":  func(o *FileOutput) string { return time.Now().Format("02") },
+	"%H":  func(o *FileOutput) string { return time.Now().Format("15") },
+	"%M":  func(o *FileOutput) string { return time.Now().Format("04") },
+	"%S":  func(o *FileOutput) string { return time.Now().Format("05") },
+	"%NS": func(o *FileOutput) string { return fmt.Sprint(time.Now().Nanosecond()) },
+	"%r":  func(o *FileOutput) string { return string(o.currentID) },
+	"%t":  func(o *FileOutput) string { return string(o.payloadType) },
+}
+
+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
+	requestPerFile bool
+	currentID      []byte
+	payloadType    []byte
+	closed         bool
+
+	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()
+
+	if strings.Contains(pathTemplate, "%r") {
+		o.requestPerFile = true
+	}
+
+	go func() {
+		for {
+			time.Sleep(config.flushInterval)
+			if o.closed {
+				break
+			}
+			o.mu.Lock()
+			o.updateName()
+			o.flush()
+			o.mu.Unlock()
+		}
+	}()

 	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(o), -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) {
-	if !isOriginPayload(data) {
-		return len(data), nil
+	if o.requestPerFile {
+		meta := payloadMeta(data)
+		o.currentID = meta[1]
+		o.payloadType = meta[0]
+		o.updateName()
 	}

-	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()
+	}
+
+	o.closed = true
+	return nil
 }
@@ -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
+}
@@ -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,263 @@ 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-%t", config: &FileOutputConfig{flushInterval: time.Minute, append: true}}
+	now := time.Now()
+	output.payloadType = []byte("3")
+	expectedPath := fmt.Sprintf("/tmp/log-%s-%s-%s-%s-3", 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 TestFileOutputFilePerRequest(t *testing.T) {
+	output := NewFileOutput("/tmp/log-%Y-%m-%d-%S-%r", &FileOutputConfig{append: true})
+
+	if output.file != nil {
+		t.Error("Should not initialize file if no writes")
+	}
+
+	output.Write([]byte("1 1 1\ntest"))
+	name1 := output.file.Name()
+
+	output.Write([]byte("1 2 1\ntest"))
+	name2 := output.file.Name()
+
+	time.Sleep(time.Second)
+	output.updateName()
+
+	output.Write([]byte("1 3 1\ntest"))
+	name3 := output.file.Name()
+
+	if name3 == name2 || name2 == name1 || name3 == name1 {
+		t.Error("File name should change:", name1, name2, name3)
+	}
+
+	os.Remove(name1)
+	os.Remove(name2)
+	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)
+	}
+}
@@ -14,6 +14,7 @@ type response struct {
 	payload       []byte
 	uuid          []byte
 	roundTripTime int64
+	startedAt     int64
 }

 // HTTPOutputConfig struct for holding http output configuration
@@ -86,10 +87,6 @@ func NewHTTPOutput(address string, config *HTTPOutputConfig) io.Writer {
 		o.elasticSearch.Init(o.config.elasticSearch)
 	}

-	if len(Settings.middleware) > 0 {
-		o.config.TrackResponses = true
-	}
-
 	go o.workerMaster()

 	return o
@@ -178,7 +175,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)

@@ -206,7 +203,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 {
@@ -43,15 +43,19 @@ func TestHTTPOutput(t *testing.T) {
 	methods := HTTPMethods{[]byte("GET"), []byte("PUT"), []byte("POST")}
 	Settings.modifierConfig = HTTPModifierConfig{headers: headers, methods: methods}

-	output := NewHTTPOutput(server.URL, &HTTPOutputConfig{Debug: true})
+	http_output := NewHTTPOutput(server.URL, &HTTPOutputConfig{Debug: true, TrackResponses: true})
+	output := NewTestOutput(func(data []byte) {
+		wg.Done()
+	})

 	Plugins.Inputs = []io.Reader{input}
-	Plugins.Outputs = []io.Writer{output}
+	Plugins.Outputs = []io.Writer{http_output, output}

 	go Start(quit)

-	for i := 0; i < 100; i++ {
-		wg.Add(2) // OPTIONS should be ignored
+	for i := 0; i < 1; i++ {
+		// 2 http-output, 2 - test output request, 2 - test output http response
+		wg.Add(6) // OPTIONS should be ignored
 		input.EmitPOST()
 		input.EmitOPTIONS()
 		input.EmitGET()
@@ -0,0 +1,99 @@
+package main
+
+import (
+	"encoding/json"
+	"github.com/Shopify/sarama"
+	"github.com/Shopify/sarama/mocks"
+	"github.com/buger/gor/proto"
+	"io"
+	"log"
+	"strings"
+	"time"
+)
+
+// KafkaOutput is used for sending payloads to kafka in JSON format.
+type KafkaOutput struct {
+	config   *KafkaConfig
+	producer sarama.AsyncProducer
+}
+
+// KafkaOutputFrequency in milliseconds
+const KafkaOutputFrequency = 500
+
+// NewKafkaOutput creates instance of kafka producer client.
+func NewKafkaOutput(address string, config *KafkaConfig) io.Writer {
+	c := sarama.NewConfig()
+
+	var producer sarama.AsyncProducer
+
+	if config.producer.(*mocks.AsyncProducer) != nil {
+		producer = config.producer
+	} else {
+		c.Producer.RequiredAcks = sarama.WaitForLocal
+		c.Producer.Compression = sarama.CompressionSnappy
+		c.Producer.Flush.Frequency = KafkaOutputFrequency * time.Millisecond
+
+		brokerList := strings.Split(config.host, ",")
+
+		var err error
+		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) {
+	var message sarama.StringEncoder
+
+	if !o.config.useJSON {
+		message = sarama.StringEncoder(data)
+	} else {
+		headers := make(map[string]string)
+		proto.ParseHeaders([][]byte{data}, func(header []byte, value []byte) bool {
+			headers[string(header)] = string(value)
+			return true
+		})
+
+		meta := payloadMeta(data)
+		req := payloadBody(data)
+
+		kafkaMessage := KafkaMessage{
+			ReqURL:     string(proto.Path(req)),
+			ReqType:    string(meta[0]),
+			ReqID:      string(meta[1]),
+			ReqTs:      string(meta[2]),
+			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
+}
@@ -0,0 +1,53 @@
+package main
+
+import (
+	"github.com/Shopify/sarama"
+	"github.com/Shopify/sarama/mocks"
+	"testing"
+)
+
+func TestOutputKafkaRAW(t *testing.T) {
+	config := sarama.NewConfig()
+	config.Producer.Return.Successes = true
+	producer := mocks.NewAsyncProducer(t, config)
+	producer.ExpectInputAndSucceed()
+
+	output := NewKafkaOutput("", &KafkaConfig{
+		producer: producer,
+		topic:    "test",
+		useJSON:  false,
+	})
+
+	output.Write([]byte("1 2 3\nGET / HTTP1.1\r\nHeader: 1\r\n\r\n"))
+
+	resp := <-producer.Successes()
+
+	data, _ := resp.Value.Encode()
+
+	if string(data) != "1 2 3\nGET / HTTP1.1\r\nHeader: 1\r\n\r\n" {
+		t.Error("Message not properly encoded: ", string(data))
+	}
+}
+
+func TestOutputKafkaJSON(t *testing.T) {
+	config := sarama.NewConfig()
+	config.Producer.Return.Successes = true
+	producer := mocks.NewAsyncProducer(t, config)
+	producer.ExpectInputAndSucceed()
+
+	output := NewKafkaOutput("", &KafkaConfig{
+		producer: producer,
+		topic:    "test",
+		useJSON:  true,
+	})
+
+	output.Write([]byte("1 2 3\nGET / HTTP1.1\r\nHeader: 1\r\n\r\n"))
+
+	resp := <-producer.Successes()
+
+	data, _ := resp.Value.Encode()
+
+	if string(data) != `{"Req_URL":"/","Req_Type":"1","Req_ID":"2","Req_Ts":"3","Req_Method":"GET","Req_Headers":{"Header":"1"}}` {
+		t.Error("Message not properly encoded: ", string(data))
+	}
+}
@@ -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"
+}
@@ -95,13 +95,19 @@ func InitPlugins() {
 		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, engine, Settings.inputRAWTrackResponse, time.Duration(0))
+		registerPlugin(NewRAWInput, options, engine, Settings.inputRAWTrackResponse, time.Duration(0), Settings.inputRAWRealIPHeader)
 	}

 	for _, options := range Settings.inputTCP {
@@ -113,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 {
@@ -136,4 +142,12 @@ func InitPlugins() {
 	for _, options := range Settings.outputHTTP {
 		registerPlugin(NewHTTPOutput, options, &Settings.outputHTTPConfig)
 	}
+
+	if Settings.outputKafkaConfig.host != "" && Settings.outputKafkaConfig.topic != "" {
+		registerPlugin(NewKafkaOutput, "", &Settings.outputKafkaConfig)
+	}
+
+	if Settings.inputKafkaConfig.host != "" && Settings.inputKafkaConfig.topic != "" {
+		registerPlugin(NewKafkaInput, "", &Settings.inputKafkaConfig)
+	}
 }
@@ -0,0 +1,12 @@
+// +build gofuzz
+
+package proto
+
+func Fuzz(data []byte) int {
+
+	ParseHeaders([][]byte{data}, func(header []byte, value []byte) bool {
+		return true
+	})
+
+	return 1
+}
@@ -32,7 +32,7 @@ var HeaderDelim = []byte(": ")

 // MIMEHeadersEndPos finds end of the Headers section, which should end with empty line.
 func MIMEHeadersEndPos(payload []byte) int {
-	return bytes.Index(payload, EmptyLine)
+	return bytes.Index(payload, EmptyLine) + 4
 }

 // MIMEHeadersStartPos finds start of Headers section
@@ -41,35 +41,255 @@ 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}   // header start
+	hE := [2]int{-1, -1} // header end
+	vS := [2]int{-1, -1} // value start
+	vE := [2]int{-1, -1} // value end
+
+	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
+			}
+			lineBreaks = 0
+		default:
+			lineBreaks = 0
+
+			if hS[1] == -1 {
+				hS = [2]int{pIdx, i}
+				hE = [2]int{-1, -1}
+			} 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 +297,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,10 +321,23 @@ 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)
-	return payload[MIMEHeadersEndPos(payload)+4:]
+	return payload[MIMEHeadersEndPos(payload):]
 }

 // Path takes payload and retuns request path: Split(firstLine, ' ')[1]
@@ -216,7 +449,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 {
@@ -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,130 @@ 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)
+	}
+}
+
+// See https://github.com/dvyukov/go-fuzz and fuzz.go
+func TestFuzzCrashers(t *testing.T) {
+	var crashers = []string{
+		"\n:00\n",
+	}
+
+	for _, f := range crashers {
+		ParseHeaders([][]byte{[]byte(f)}, func(header []byte, value []byte) bool {
+			return true
+		})
+	}
+}
+
+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

@@ -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
 }

@@ -16,6 +16,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+	"github.com/buger/gor/proto"
 	"github.com/google/gopacket"
 	"github.com/google/gopacket/layers"
 	"github.com/google/gopacket/pcap"
@@ -32,6 +33,12 @@ import (

 var _ = fmt.Println

+type packet struct {
+	srcIP     []byte
+	data      []byte
+	timestamp time.Time
+}
+
 // Listener handle traffic capture
 type Listener struct {
 	mu sync.Mutex
@@ -52,7 +59,7 @@ type Listener struct {
 	respWithoutReq map[uint32]tcpID

 	// Messages ready to be send to client
-	packetsChan chan []byte
+	packetsChan chan *packet

 	// Messages ready to be send to client
 	messagesChan chan *TCPMessage
@@ -80,13 +87,14 @@ type request struct {
 const (
 	EngineRawSocket = 1 << iota
 	EnginePcap
+	EnginePcapFile
 )

 // NewListener creates and initializes new Listener object
 func NewListener(addr string, port string, engine int, trackResponse bool, expire time.Duration) (l *Listener) {
 	l = &Listener{}

-	l.packetsChan = make(chan []byte, 10000)
+	l.packetsChan = make(chan *packet, 10000)
 	l.messagesChan = make(chan *TCPMessage, 10000)
 	l.quit = make(chan bool)
 	l.readyCh = make(chan bool, 1)
@@ -113,10 +121,10 @@ func NewListener(addr string, port string, engine int, trackResponse bool, expir
 	// Special case for testing
 	if l.port != 0 {
 		switch engine {
-		case EngineRawSocket:
-			go l.readRAWSocket()
 		case EnginePcap:
 			go l.readPcap()
+		case EnginePcapFile:
+			go l.readPcapFile()
 		default:
 			log.Fatal("Unknown traffic interception engine:", engine)
 		}
@@ -135,9 +143,9 @@ func (t *Listener) listen() {
 				t.conn.Close()
 			}
 			return
-		case data := <-t.packetsChan:
-			packet := ParseTCPPacket(data[:16], data[16:])
-			t.processTCPPacket(packet)
+		case packet := <-t.packetsChan:
+			tcpPacket := ParseTCPPacket(packet.srcIP, packet.data, packet.timestamp)
+			t.processTCPPacket(tcpPacket)
 		case <-gcTicker:
 			now := time.Now()

@@ -172,7 +180,14 @@ func (t *Listener) dispatchMessage(message *TCPMessage) {

 	t.deleteMessage(message)

-	// log.Println("Dispatching, message", message.Start.UnixNano(), message.Seq, message.Ack, string(message.Bytes()))
+	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
@@ -182,10 +197,10 @@ func (t *Listener) dispatchMessage(message *TCPMessage) {
 				if resp, rok := t.messages[respID]; rok {
 					// if resp.AssocMessage == nil {
 					// log.Println("FOUND RESPONSE")
-					resp.AssocMessage = message
-					message.AssocMessage = resp
+					resp.setAssocMessage(message)
+					message.setAssocMessage(resp)

-					if resp.IsFinished() {
+					if resp.complete {
 						defer t.dispatchMessage(resp)
 					}
 					// }
@@ -193,14 +208,14 @@ func (t *Listener) dispatchMessage(message *TCPMessage) {
 			}

 			if resp, ok := t.messages[message.ResponseID]; ok {
-				resp.AssocMessage = message
+				resp.setAssocMessage(message)
 			}
 		}
 	} else {
 		if message.AssocMessage == nil {
 			if responseRequest, ok := t.respAliases[message.Ack]; ok {
-				message.AssocMessage = responseRequest
-				responseRequest.AssocMessage = message
+				message.setAssocMessage(responseRequest)
+				responseRequest.setAssocMessage(message)
 			}
 		}

@@ -244,6 +259,28 @@ func (e *DeviceNotFoundError) Error() string {
 	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 {
@@ -251,7 +288,7 @@ func findPcapDevices(addr string) (interfaces []pcap.Interface, err error) {
 	}

 	for _, device := range devices {
-		if (addr == "" || addr == "0.0.0.0" || addr == "[::]" || addr == "::") && len(device.Addresses) > 0 {
+		if listenAllInterfaces(addr) && len(device.Addresses) > 0 || isLoopback(device) {
 			interfaces = append(interfaces, device)
 			continue
 		}
@@ -298,30 +335,63 @@ func (t *Listener) readPcap() {
 			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 port " + strconv.Itoa(int(t.port))
+					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))
+					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)
+					log.Println("BPF filter error:", err, "Device:", device.Name, bpf)
 					wg.Done()
 					return
 				}
 			}
 			t.mu.Unlock()

-			linkType := handle.LinkType()
-			source := gopacket.NewPacketSource(handle, linkType)
+			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 []byte
+			var data, srcIP, dstIP []byte

 			for {
 				packet, err := source.NextPacket()
@@ -332,14 +402,32 @@ func (t *Listener) readPcap() {
 					continue
 				}

-				if linkType == layers.LinkTypeEthernet {
-					// Skip ethernet layer, 14 bytes
-					data = packet.Data()[14:]
-				} else if linkType == layers.LinkTypeNull || linkType == layers.LinkTypeLoop {
-					data = packet.Data()[4:]
+				// 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
@@ -350,6 +438,25 @@ func (t *Listener) readPcap() {
 					}

 					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
@@ -358,36 +465,70 @@ func (t *Listener) readPcap() {
 					}

 					srcIP = data[8:24]
+					dstIP = data[24:40]

 					data = data[40:]
 				}

 				// Truncated TCP info
-				if len(data) < 13 {
+				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) {
+				if len(data) > int(dataOffset*4) || isFIN {
 					if !bpfSupported {
 						destPort := binary.BigEndian.Uint16(data[2:4])
 						srcPort := binary.BigEndian.Uint16(data[0:2])

-						// log.Println(t.port, destPort, srcPort, packet)
+						var addrCheck []byte

-						if !(destPort == t.port || (t.trackResponse && srcPort == t.port)) {
+						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
 						}
 					}

-					newBuf := make([]byte, len(data)+16)
-					copy(newBuf[:16], srcIP)
-					copy(newBuf[16:], data)
-
-					t.packetsChan <- newBuf
+					t.packetsChan <- t.buildPacket(srcIP, data, packet.Metadata().Timestamp)
 				}
 			}
 		}(d)
@@ -397,8 +538,66 @@ func (t *Listener) readPcap() {
 	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 {
@@ -425,16 +624,26 @@ func (t *Listener) readRAWSocket() {

 		if n > 0 {
 			if t.isValidPacket(buf[:n]) {
-				newBuf := make([]byte, n+4)
-				copy(newBuf[16:], buf[:n])
-				copy(newBuf[:16], []byte(addr.(*net.IPAddr).IP))
-
-				t.packetsChan <- 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
@@ -457,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)
@@ -471,8 +677,6 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 		}
 	}()

-	// log.Println("Processing packet:", packet.Ack, packet.Seq, packet.ID)
-
 	var message *TCPMessage

 	isIncoming := packet.DestPort == t.port
@@ -485,7 +689,7 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 				t.deleteMessage(m)

 				if m.AssocMessage != nil {
-					m.AssocMessage.AssocMessage = nil
+					m.setAssocMessage(nil)
 				}

 				for _, pkt := range m.packets {
@@ -501,6 +705,14 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 		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.UpdateAck(alias)
 	}
@@ -514,13 +726,13 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 	message, ok := t.messages[packet.ID]

 	if !ok {
-		message = NewTCPMessage(packet.Seq, packet.Ack, isIncoming)
+		message = NewTCPMessage(packet.Seq, packet.Ack, isIncoming, packet.timestamp)
 		t.messages[packet.ID] = message

 		if !isIncoming {
 			if responseRequest != nil {
-				message.AssocMessage = responseRequest
-				responseRequest.AssocMessage = message
+				message.setAssocMessage(responseRequest)
+				responseRequest.setAssocMessage(message)
 			} else {
 				t.respWithoutReq[packet.Ack] = packet.ID
 			}
@@ -531,35 +743,31 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 	message.AddPacket(packet)

 	// Handling Expect: 100-continue requests
-	if len(packet.Data) > 4 && bytes.Equal(packet.Data[0:4], bPOST) {
-		// reading last 20 bytes (not counting CRLF): last header value (if no body presented)
-		if bytes.Equal(packet.Data[len(packet.Data)-24:len(packet.Data)-4], bExpect100ContinueCheck) {
-			seq := packet.Seq + uint32(len(packet.Data))
-			t.seqWithData[seq] = packet.Ack
-			message.DataSeq = seq
+	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.AssocMessage = m.AssocMessage
-					}
-					// log.Println("2: Adding ack alias:", m.Ack, packet.Ack)
-					t.ackAliases[m.Ack] = packet.Ack
+		// 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)
-					}
+				for _, pkt := range m.packets {
+					pkt.UpdateAck(packet.Ack)
+					message.AddPacket(pkt)
 				}
 			}
-
-			// Removing `Expect: 100-continue` header
-			packet.Data = append(packet.Data[:len(packet.Data)-24], packet.Data[len(packet.Data)-2:]...)
-
-			// log.Println(string(packet.Data))
 		}
+
+		// Removing `Expect: 100-continue` header
+		packet.Data = proto.DeleteHeader(packet.Data, bExpectHeader)
 	}

 	// log.Println("Received message:", string(message.Bytes()), message.ID(), t.messages)
@@ -575,15 +783,18 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 	}

 	// If message contains only single packet immediately dispatch it
-	if message.IsFinished() {
+	if message.complete {
+		// log.Println("COMPLETE!", isIncoming, message)
 		if isIncoming {
-			// log.Println("I'm finished", string(message.Bytes()), message.ResponseID, t.messages)
 			if t.trackResponse {
+				// log.Println("Found response!", message.ResponseID, t.messages)
+
 				if resp, ok := t.messages[message.ResponseID]; ok {
-					t.dispatchMessage(message)
-					if resp.IsFinished() {
+					if resp.complete {
 						t.dispatchMessage(resp)
 					}
+
+					t.dispatchMessage(message)
 				}
 			} else {
 				t.dispatchMessage(message)
@@ -594,7 +805,7 @@ func (t *Listener) processTCPPacket(packet *TCPPacket) {
 			}

 			if req, ok := t.messages[message.AssocMessage.ID()]; ok {
-				if req.IsFinished() {
+				if req.complete {
 					t.dispatchMessage(req)
 					t.dispatchMessage(message)
 				}
@@ -15,13 +15,53 @@ func TestRawListenerInput(t *testing.T) {
 	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"))
+	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\n\r\n"))
+	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()
+	listener.packetsChan <- reqPacket.dump()
+	listener.packetsChan <- respPacket.dump()
+
+	select {
+	case req = <-listener.messagesChan:
+	case <-time.After(time.Millisecond):
+		t.Error("Should return request immediately")
+		return
+	}
+
+	if !req.IsIncoming {
+		t.Error("Should be request")
+	}
+
+	select {
+	case resp = <-listener.messagesChan:
+	case <-time.After(20 * time.Millisecond):
+		t.Error("Should return response immediately")
+		return
+	}
+
+	if resp.IsIncoming {
+		t.Error("Should be response")
+	}
+}
+
+func 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:
@@ -52,9 +92,9 @@ func TestRawListenerInputWithoutResponse(t *testing.T) {
 	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"))
+	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\n\r\n"), time.Now())

-	listener.packetsChan <- reqPacket.Dump()
+	listener.packetsChan <- reqPacket.dump()

 	select {
 	case req = <-listener.messagesChan:
@@ -74,12 +114,12 @@ func TestRawListenerResponse(t *testing.T) {
 	listener := NewListener("", "0", EnginePcap, true, 10*time.Millisecond)
 	defer listener.Close()

-	reqPacket := buildPacket(true, 1, 1, []byte("GET / HTTP/1.1\r\n\r\n"))
-	respPacket := buildPacket(false, 1+uint32(len(reqPacket.Data)), 2, []byte("HTTP/1.1 200 OK\r\n\r\n"))
+	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.Dump()
-	listener.packetsChan <- reqPacket.Dump()
+	listener.packetsChan <- respPacket.dump()
+	listener.packetsChan <- reqPacket.dump()

 	select {
 	case req = <-listener.messagesChan:
@@ -108,85 +148,69 @@ func TestRawListenerResponse(t *testing.T) {
 	}
 }

-func TestRawListener100Continue(t *testing.T) {
-	var req, resp *TCPMessage
-
+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+1 /* 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.packetsChan <- reqPacket1.Dump()
-	listener.packetsChan <- reqPacket2.Dump()
-	listener.packetsChan <- reqPacket3.Dump()
+	result := []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")

-	listener.packetsChan <- respPacket1.Dump()
-	listener.packetsChan <- respPacket2.Dump()
-
-	select {
-	case req = <-listener.messagesChan:
-		break
-	case <-time.After(11 * time.Millisecond):
-		t.Error("Should return request after expire time")
-		return
-	}
-
-	if !bytes.Equal(req.Bytes(), []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")) {
-		t.Error("Should receive full message", string(req.Bytes()))
-	}
-
-	if !req.IsIncoming {
-		t.Error("Should be request")
-	}
-
-	select {
-	case resp = <-listener.messagesChan:
-		break
-	case <-time.After(21 * time.Millisecond):
-		t.Error("Should return response after expire time")
-		return
-	}
-
-	if resp.IsIncoming {
-		t.Error("Should be response")
-	}
-
-	if !bytes.Equal(resp.UUID(), req.UUID()) {
-		t.Error("Resp and Req UUID should be equal")
-	}
+	testRawListener100Continue(t, listener, result, reqPacket1, reqPacket2, reqPacket3, respPacket1, respPacket2)
 }

 // Response comes before Request
-func TestRawListener100ContinueWrongOrder(t *testing.T) {
-	var req, resp *TCPMessage
-
+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"))
+	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"), 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"))
+	respPacket2 := buildPacket(false, reqPacket3.Seq+1 /* len of data */, 2, []byte("HTTP/1.1 200 OK\r\n\r\n"), time.Now())

-	listener.packetsChan <- respPacket1.Dump()
-	listener.packetsChan <- respPacket2.Dump()
+	result := []byte("POST / HTTP/1.1\r\nContent-Length: 2\r\n\r\nab")

-	listener.packetsChan <- reqPacket1.Dump()
-	listener.packetsChan <- reqPacket2.Dump()
-	listener.packetsChan <- reqPacket3.Dump()
+	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:
@@ -196,7 +220,7 @@ func TestRawListener100ContinueWrongOrder(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()))
 	}

@@ -225,7 +249,7 @@ func testChunkedSequence(t *testing.T, listener *Listener, packets ...*TCPPacket
 	var r, req, resp *TCPMessage

 	for _, p := range packets {
-		listener.packetsChan <- p.Dump()
+		listener.packetsChan <- p.dump()
 	}

 	select {
@@ -328,23 +352,23 @@ 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"))
+	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"))
-	reqPacket3 := buildPacket(true, 2, reqPacket2.Seq+uint32(len(reqPacket2.Data)), []byte("1\r\nb\r\n"))
-	reqPacket4 := buildPacket(true, 2, reqPacket3.Seq+uint32(len(reqPacket3.Data)), []byte("0\r\n\r\n"))
+	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"))
+	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"))
+	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
-		}
+		// if i < 54 || i > 57 {
+		// 	continue
+		// }

 		packets := permutation(i, []*TCPPacket{reqPacket1, reqPacket2, reqPacket3, reqPacket4, respPacket1, respPacket2})

@@ -357,13 +381,13 @@ 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"))
+	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"))
-	reqPacket3 := buildPacket(true, ack, reqPacket2.Seq+5, []byte("1\r\nb\r\n"))
-	reqPacket4 := buildPacket(true, ack, reqPacket3.Seq+5, []byte("0\r\n\r\n"))
+	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"))
+	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,
@@ -385,8 +409,8 @@ func postMessage() []*TCPPacket {
 	}

 	return []*TCPPacket{
-		buildPacket(true, ack, seq, data),
-		buildPacket(false, seq+uint32(len(data)), seq2, []byte("HTTP/1.1 200 OK\r\n")),
+		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()),
 	}
 }

@@ -396,8 +420,8 @@ func getMessage() []*TCPPacket {
 	seq := uint32(rand.Int63())

 	return []*TCPPacket{
-		buildPacket(true, ack, seq, []byte("GET / HTTP/1.1\r\n\r\n")),
-		buildPacket(false, seq+18, seq2, []byte("HTTP/1.1 200 OK\r\n")),
+		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()),
 	}
 }

@@ -428,7 +452,7 @@ func TestRawListenerBench(t *testing.T) {
 						}
 					}

-					l.packetsChan <- p.Dump()
+					l.packetsChan <- p.dump()
 					time.Sleep(time.Millisecond)
 				}

@@ -7,6 +7,7 @@ import (
 	"encoding/hex"
 	"github.com/buger/gor/proto"
 	"log"
+	"net"
 	"strconv"
 	"time"
 )
@@ -35,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(Seq, Ack uint32, IsIncoming bool) (msg *TCPMessage) {
-	msg = &TCPMessage{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
 }
@@ -56,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)
 	}

@@ -119,111 +137,349 @@ func (t *TCPMessage) AddPacket(packet *TCPPacket) {
 		if packet.OrigAck != 0 {
 			t.DataAck = packet.OrigAck
 		}
+
+		if packet.timestamp.Before(t.Start) {
+			t.Start = packet.timestamp
+		}
 	}
+
+	t.checkSeqIntegrity()
+	t.updateHeadersPacket()
+	t.updateMethodType()
+	t.updateBodyType()
+	t.checkIfComplete()
+	t.check100Continue()
 }

 // Check if there is missing packet
-func (t *TCPMessage) isSeqMissing() bool {
+func (t *TCPMessage) checkSeqIntegrity() {
 	if len(t.packets) == 1 {
-		return false
+		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
+			}
+		}
+	}
+
+	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 final packet
-		if len(t.packets) == i + 1 {
-			return false
-		}
-		np := t.packets[i + 1]
-
-		if np.Seq != p.Seq + uint32(len(p.Data)) {
-			return true
+		if bytes.LastIndex(p.Data, bEmptyLine) != -1 {
+			t.headerPacket = i
+			return
 		}
 	}

-	return false
-}
-
-var EmptyLine = []byte("\r\n\r\n")
-var ChunkEnd = []byte("0\r\n\r\n")
-
-func (t *TCPMessage) isHeadersReceived() bool {
-	for _, p := range t.packets {
-		if bytes.LastIndex(p.Data, EmptyLine) != -1 {
-			return true
-		}
-	}
-
-	return false
+	return
 }

 // 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
+func (t *TCPMessage) checkIfComplete() {
+	if t.seqMissing || t.headerPacket == -1 {
+		return
 	}

-	m := payload[:4]
+	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 {
-		// If one GET, OPTIONS, or HEAD request
-		if bytes.Equal(m, []byte("GET ")) || bytes.Equal(m, []byte("OPTI")) || bytes.Equal(m, []byte("HEAD")) {
-			if !t.isSeqMissing() && t.isHeadersReceived() {
-				return true
-			} else {
-				return false
+		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 {
-			// Sometimes header comes after the body :(
-			if bytes.Equal(m, []byte("POST")) || bytes.Equal(m, []byte("PUT ")) || bytes.Equal(m, []byte("PATC")) {
+			t.methodType = httpMethodNotFound
+			return
+		}

-				if t.isHeadersReceived() {
-					if length := proto.Header(payload, []byte("Content-Length")); len(length) > 0 {
-						l, _ := strconv.Atoi(string(length))
-
-						// If content-length equal current body length
-						if l > 0 && l == t.BodySize() {
-							return true
-						}
-					}
-				}
+		for _, m := range methodsWithBody {
+			if len(m) == len(method) && bytes.Equal(m, method) {
+				t.methodType = httpMethodWithBody
+				return
 			}
 		}
+
+		t.methodType = httpMethodWithoutBody
 	} else {
-		// Request not found
-		// Can be because response came first or request request was just missing
-		if t.AssocMessage == nil {
+		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 !bytes.Equal(m, []byte("HTTP")) {
+		if proto.HeadersEqual(header, []byte("Transfer-Encoding")) {
+			encB = value
 			return false
 		}

-		if length := proto.Header(payload, []byte("Content-Length")); len(length) > 0 {
-			if length[0] == '0' {
-				return true
-			}
+		if proto.HeadersEqual(header, []byte("Connection")) {
+			connB = value
+		}

-			l, _ := strconv.Atoi(string(length))
+		return true
+	})

-			// 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
+	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 {
-				if len(t.packets) > 1 && bytes.LastIndex(t.packets[len(t.packets) - 1].Data, ChunkEnd) != -1 {
-					return true
-				}
+				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
 		}
 	}

-	return false
+	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 {
@@ -246,24 +502,10 @@ func (t *TCPMessage) UUID() []byte {
 	return uuid
 }

-// UpdateResponseAck should be called after packet is added
-func (t *TCPMessage) UpdateResponseAck() uint32 {
-	lastPacket := t.packets[len(t.packets)-1]
-	respAck := lastPacket.Seq + uint32(len(lastPacket.Data))
-
-	if t.ResponseAck != respAck {
-		t.ResponseAck = lastPacket.Seq + uint32(len(lastPacket.Data))
-
-		// We swappwed src and dst port
-		copy(t.ResponseID[:16], lastPacket.Addr)
-		copy(t.ResponseID[16:], lastPacket.Raw[2:4]) // Src port
-		copy(t.ResponseID[18:], lastPacket.Raw[0:2]) // Dest port
-		binary.BigEndian.PutUint32(t.ResponseID[20:24], t.ResponseAck)
-	}
-
-	return t.ResponseAck
-}
-
 func (t *TCPMessage) ID() tcpID {
 	return t.packets[0].ID
 }
+
+func (t *TCPMessage) IP() net.IP {
+	return net.IP(t.packets[0].Addr)
+}
@@ -5,9 +5,10 @@ import (
 	"encoding/binary"
 	_ "log"
 	"testing"
+	"time"
 )

-func buildPacket(isIncoming bool, Ack, Seq uint32, Data []byte) (packet *TCPPacket) {
+func buildPacket(isIncoming bool, Ack, Seq uint32, Data []byte, timestamp time.Time) (packet *TCPPacket) {
 	var srcPort, destPort uint16

 	// For tests `listening` port is 0
@@ -25,7 +26,7 @@ func buildPacket(isIncoming bool, Ack, Seq uint32, Data []byte) (packet *TCPPack
 	buf[12] = 64
 	buf = append(buf, Data...)

-	packet = ParseTCPPacket([]byte("123"), buf)
+	packet = ParseTCPPacket([]byte("123"), buf, timestamp)

 	return packet
 }
@@ -36,31 +37,31 @@ func buildMessage(p *TCPPacket) *TCPMessage {
 		isIncoming = true
 	}

-	m := NewTCPMessage(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")
@@ -68,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())
@@ -80,112 +81,177 @@ 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\r\n\r\n")))
+		// 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.AssocMessage = &TCPMessage{}
-	if !msg.IsFinished() {
-		t.Error("Should mark simple response as finished")
-	}
-
-	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\n\r\n")))
-	msg.AssocMessage = nil
-	if msg.IsFinished() {
-		t.Error("Should not mark responses without associated requests")
-	}
-
-	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n")))
-	msg.AssocMessage = &TCPMessage{}
-
-	if msg.IsFinished() {
-		t.Error("Should mark chunked response as non finished")
-	}
-
-	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")))
-	msg.AssocMessage = &TCPMessage{}
-
-	if !msg.IsFinished() {
-		t.Error("Should mark Content-Length: 0 respones as finished")
-	}
-
-	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nContent-Length: 1\r\n\r\na")))
-	msg.AssocMessage = &TCPMessage{}
-
-	if !msg.IsFinished() {
-		t.Error("Should mark valid Content-Length respones as finished")
-	}
-
-	msg = buildMessage(buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\na")))
-	msg.AssocMessage = &TCPMessage{}
-
-	if msg.IsFinished() {
-		t.Error("Should not mark not valid Content-Length respones as finished")
 	}
 }

 func TestTCPMessageIsSeqMissing(t *testing.T) {
-	p1 := buildPacket(false, 1, 1, []byte("HTTP/1.1 200 OK\r\n"))
-	p2 := buildPacket(false, 1, p1.Seq + uint32(len(p1.Data)), []byte("Content-Length: 10\r\n\r\n"))
-	p3 := buildPacket(false, 1, p2.Seq + uint32(len(p2.Data)), []byte("a"))
+	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.isSeqMissing() {
+	if msg.seqMissing {
 		t.Error("Should be complete if have only 1 packet")
 	}

 	msg.AddPacket(p3)
-	if !msg.isSeqMissing() {
+	if !msg.seqMissing {
 		t.Error("Should be incomplete because missing middle component")
 	}

 	msg.AddPacket(p2)
-	if msg.isSeqMissing() {
+	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"))
-	p2 := buildPacket(false, 1, p1.Seq + uint32(len(p1.Data)), []byte("Content-Length: 10\r\n\r\n"))
+	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.isHeadersReceived() {
-		t.Error("Should be complete if have only 1 packet")
+	if msg.headerPacket == -1 {
+		t.Error("Should be complete if have only 1 packet", msg.headerPacket)
 	}

 	msg.AddPacket(p2)
-	if !msg.isHeadersReceived() {
+	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)
+	}
 }
@@ -5,6 +5,7 @@ import (
 	"log"
 	"strconv"
 	"strings"
+	"time"
 )

 var _ = log.Println
@@ -33,18 +34,21 @@ type TCPPacket struct {
 	Ack        uint32
 	OrigAck    uint32
 	DataOffset uint8
+	IsFIN      bool

-	Raw  []byte
-	Data []byte
-	Addr []byte
-	ID   tcpID
+	Raw       []byte
+	Data      []byte
+	Addr      []byte
+	timestamp time.Time
+	ID        tcpID
 }

 // ParseTCPPacket takes address and tcp payload and returns parsed TCPPacket
-func ParseTCPPacket(addr []byte, data []byte) (p *TCPPacket) {
+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
@@ -71,28 +75,40 @@ func (t *TCPPacket) ParseBasic() {
 	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() []byte {
-	buf := make([]byte, len(t.Data)+16+16)
-	copy(buf[:16], t.Addr)
+func (t *TCPPacket) dump() *packet {

-	tcpBuf := buf[16:]
+	packetSrcIP := make([]byte, 16)
+	packetData := make([]byte, len(t.Data)+16)

-	binary.BigEndian.PutUint16(tcpBuf[2:4], t.DestPort)
-	binary.BigEndian.PutUint16(tcpBuf[0:2], t.SrcPort)
+	copy(packetSrcIP, t.Addr)

-	binary.BigEndian.PutUint32(tcpBuf[4:8], t.Seq)
-	binary.BigEndian.PutUint32(tcpBuf[8:12], t.Ack)
+	binary.BigEndian.PutUint16(packetData[0:2], t.SrcPort)
+	binary.BigEndian.PutUint16(packetData[2:4], t.DestPort)

-	tcpBuf[12] = 64
-	copy(tcpBuf[16:], t.Data)
+	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,
+	}

-	return buf
 }

 // String output for a TCP Packet
@@ -109,6 +125,7 @@ func (t *TCPPacket) String() string {
 		"Sequence:" + strconv.Itoa(int(t.Seq)),
 		"Acknowledgment:" + strconv.Itoa(int(t.Ack)),
 		"Header len:" + strconv.Itoa(int(t.DataOffset)),
+		"FIN:" + strconv.FormatBool(t.IsFIN),

 		"Data size:" + strconv.Itoa(len(t.Data)),
 		"Data:" + string(t.Data[:maxLen]),
@@ -25,34 +25,44 @@ 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
 	inputRAWEngine        string
 	inputRAWTrackResponse bool
+	inputRAWRealIPHeader  string

 	middleware string

 	inputHTTP  MultiOption
 	outputHTTP MultiOption

+	prettifyHTTP bool
+
 	outputHTTPConfig HTTPOutputConfig
 	modifierConfig   HTTPModifierConfig
+
+	inputKafkaConfig  KafkaConfig
+	outputKafkaConfig KafkaConfig
 }

 // Settings holds Gor configuration
@@ -70,6 +80,7 @@ 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.")

@@ -78,12 +89,25 @@ func init() {

 	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.Second, "Interval for forcing buffer flush to the file, default: 1s.")
+	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.BoolVar(&Settings.prettifyHTTP, "prettify-http", false, "If enabled, will automatically decode requests and responses with: Content-Encodning: gzip and Transfer-Encoding: chunked. Useful for debugging, in conjuction with --output-stdout")

 	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")

@@ -91,15 +115,18 @@ func init() {

 	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.TrackResponses, "output-http-track-response", false, "If turned on, HTTP output responses will be set to all outputs like stdout, file and etc.")

 	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.")
@@ -107,6 +134,14 @@ func init() {

 	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", "", "Read request and response stats from 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", "", "Read request and response stats from Kafka:\n\tgor --input-raw :8080 --output-kafka-topic 'kafka-log'")
+	flag.BoolVar(&Settings.outputKafkaConfig.useJSON, "output-kafka-json-format", false, "If turned on, it will serialize messages from GoReplay text format to JSON.")
+
+	flag.StringVar(&Settings.inputKafkaConfig.host, "input-kafka-host", "", "Send request and response stats to Kafka:\n\tgor --output-stdout --input-kafka-host '192.168.0.1:9092,192.168.0.2:9092'")
+	flag.StringVar(&Settings.inputKafkaConfig.topic, "input-kafka-topic", "", "Send request and response stats to Kafka:\n\tgor --output-stdout --input-kafka-topic 'kafka-log'")
+	flag.BoolVar(&Settings.inputKafkaConfig.useJSON, "input-kafka-json-format", false, "If turned on, it will assume that messages coming in JSON format rather than  GoReplay text format.")
+
 	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")

@@ -126,7 +161,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")
@@ -0,0 +1,435 @@
+.wy-affix {
+  position: fixed;
+  top: 1.618em;
+}
+
+.wy-menu a:hover {
+  text-decoration: none;
+}
+
+.wy-menu-vertical header,
+.wy-menu-vertical p.caption {
+  height: 32px;
+  display: inline-block;
+  line-height: 32px;
+  padding: 0 1.618em;
+  margin-bottom: 0;
+  margin-top: 14px;
+  display: block;
+  font-weight: 700;
+  text-transform: uppercase;
+  font-size: 85%;
+  color: #ccc;
+  white-space: nowrap;
+}
+
+.wy-menu-vertical span {
+  color: #666;
+}
+
+.wy-menu-vertical ul {
+  margin-bottom: 0;
+}
+
+.wy-menu-vertical li.divide-top {
+  border-top: solid 1px #404040;
+}
+
+.wy-menu-vertical li.divide-bottom {
+  border-bottom: solid 1px #404040;
+}
+
+.wy-menu-vertical li.current {
+  background-color: #e5e5e5;
+}
+
+.wy-menu-vertical li.current a {
+  color: rgba(0, 93, 255, 0.7);
+  border-right: none;
+}
+
+.wy-menu-vertical li.current a:hover {
+  color: rgba(0, 93, 255, 0.9);
+}
+
+.wy-menu-vertical li code,
+.wy-menu-vertical li .rst-content tt,
+.rst-content .wy-menu-vertical li tt {
+  border: none;
+  background: inherit;
+  color: inherit;
+  padding-left: 0;
+  padding-right: 0
+}
+
+.wy-menu-vertical li span.toctree-expand {
+  display: block;
+  float: left;
+  margin-left: -1.2em;
+  font-size: .8em;
+  line-height: 1.6em;
+  color: #999;
+}
+
+.wy-menu-vertical li.on a,
+.wy-menu-vertical li.current>a {
+  color: rgba(0, 93, 255, 0.9);
+  font-weight: 700;
+  position: relative;
+  background: #fafafa;
+  border: none;
+}
+
+/*.wy-menu-vertical li.on a:hover span.toctree-expand,
+.wy-menu-vertical li.current>a:hover span.toctree-expand {
+  color: gray;
+}*/
+
+.wy-menu-vertical li.on a span.toctree-expand,
+.wy-menu-vertical li.current>a span.toctree-expand {
+  display: block;
+  font-size: .8em;
+  line-height: 1.6em;
+  color: #333;
+}
+
+.wy-menu-vertical li.toctree-l1.current li.toctree-l2>ul,
+.wy-menu-vertical li.toctree-l2.current li.toctree-l3>ul {
+  display: none;
+}
+
+.wy-menu-vertical li.toctree-l1.current li.toctree-l2.current>ul,
+.wy-menu-vertical li.toctree-l2.current li.toctree-l3.current>ul {
+  display: block;
+}
+
+.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a {
+  display: block;
+  padding: .4045em 4.045em;
+}
+
+.wy-menu-vertical li.toctree-l2 a:hover span.toctree-expand {
+  color: #999;
+}
+
+.wy-menu-vertical li.toctree-l2 span.toctree-expand {
+  color: #999;
+}
+
+.wy-menu-vertical li.toctree-l3 {
+  background-color: #eee;
+  font-size: .9em;
+}
+
+.wy-menu-vertical li.toctree-l3.current>a {
+  padding: .4045em 4.045em;
+}
+
+.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a {
+  display: block;
+  padding: .4045em 5.663em;
+  border-top: none;
+  border-bottom: none;
+}
+
+.wy-menu-vertical li.toctree-l3 a:hover span.toctree-expand {
+  color: rgba(0, 93, 255, 0.9);
+}
+
+.wy-menu-vertical li.toctree-l3 span.toctree-expand {
+  color: #999;
+}
+
+.wy-menu-vertical li.toctree-l4 {
+  font-size: .9em;
+}
+
+.wy-menu-vertical li.current ul {
+  display: block;
+}
+
+.wy-menu-vertical .local-toc li ul {
+  display: block;
+}
+
+.wy-menu-vertical li ul li a {
+  margin-bottom: 0;
+  color: rgba(0, 93, 255, 0.7);
+  font-weight: 400;
+}
+
+.wy-menu-vertical a {
+  display: inline-block;
+  line-height: 18px;
+  padding: .4045em 1.618em;
+  display: block;
+  position: relative;
+  font-size: 90%;
+  color: rgba(0, 93, 255, 0.7);
+}
+
+.wy-menu-vertical li.on a:hover,
+.wy-menu-vertical li.current>a:hover {
+  background-color: #fafafa;
+}
+
+.wy-menu-vertical a:hover {
+  color: rgba(0, 93, 255, 0.9);
+  cursor: pointer;
+  background-color: #fafafa;
+}
+
+.wy-menu-vertical a:hover span.toctree-expand {
+  color: rgba(0, 93, 255, 0.5);
+}
+
+.wy-menu-vertical a:active span.toctree-expand {
+  color: rgba(0, 93, 255, 0.7);
+}
+
+/* Search */
+
+.wy-side-nav-search {
+  z-index: 200;
+  background-color: #fafafa;
+  border-bottom: #333;
+  text-align: center;
+  padding: .809em;
+  display: block;
+  color: #333;
+  margin-bottom: .809em
+}
+
+.wy-side-nav-search input[type=text] {
+  width: 100%;
+  color: #333;
+  border-radius: 3px;
+  outline: 0;
+  padding: 10px;
+  background-color: #fff;
+  border: solid 1px #6d6d6d;
+  box-shadow: none
+}
+
+.wy-side-nav-search img {
+  display: block;
+  margin: auto auto .809em;
+  height: 45px;
+  width: 45px;
+  background-color: #2980B9;
+  padding: 5px;
+  border-radius: 100%
+}
+
+.wy-side-nav-search>a,
+.wy-side-nav-search .wy-dropdown>a {
+  color: #333;
+  font-size: 100%;
+  font-weight: 700;
+  display: inline-block;
+  padding: 4px 6px;
+  margin-bottom: .809em
+}
+
+.wy-side-nav-search>a:hover,
+.wy-side-nav-search .wy-dropdown>a:hover {
+  background: rgba(255,255,255,0.1)
+}
+
+.wy-side-nav-search>a img.logo,
+.wy-side-nav-search .wy-dropdown>a img.logo {
+  display: block;
+  margin: 0 auto;
+  height: auto;
+  width: auto;
+  border-radius: 0;
+  max-width: 100%;
+  background: transparent
+}
+
+.wy-side-nav-search>a.icon img.logo,
+.wy-side-nav-search .wy-dropdown>a.icon img.logo {
+  margin-top: .85em
+}
+
+.wy-nav .wy-menu-vertical header {
+  color: #2980B9
+}
+
+.wy-nav .wy-menu-vertical a {
+  color: #b3b3b3
+}
+
+.wy-nav .wy-menu-vertical a:hover {
+  background-color: #2980B9;
+  color: #fff
+}
+
+[data-menu-wrap] {
+  -webkit-transition: all .2s ease-in;
+  -moz-transition: all .2s ease-in;
+  transition: all .2s ease-in;
+  position: absolute;
+  opacity: 1;
+  width: 100%;
+  opacity: 0
+}
+
+[data-menu-wrap].move-center {
+  left: 0;
+  right: auto;
+  opacity: 1
+}
+
+[data-menu-wrap].move-left {
+  right: auto;
+  left: -100%;
+  opacity: 0
+}
+
+[data-menu-wrap].move-right {
+  right: -100%;
+  left: auto;
+  opacity: 0
+}
+
+.wy-body-for-nav {
+  background: left repeat-y #fcfcfc;
+  background-image: url(data:image/png;
+  base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyRpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMy1jMDExIDY2LjE0NTY2MSwgMjAxMi8wMi8wNi0xNDo1NjoyNyAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNiAoTWFjaW50b3NoKSIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDoxOERBMTRGRDBFMUUxMUUzODUwMkJCOThDMEVFNURFMCIgeG1wTU06RG9jdW1lbnRJRD0ieG1wLmRpZDoxOERBMTRGRTBFMUUxMUUzODUwMkJCOThDMEVFNURFMCI+IDx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjE4REExNEZCMEUxRTExRTM4NTAyQkI5OEMwRUU1REUwIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjE4REExNEZDMEUxRTExRTM4NTAyQkI5OEMwRUU1REUwIi8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwveDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+EwrlwAAAAA5JREFUeNpiMDU0BAgwAAE2AJgB9BnaAAAAAElFTkSuQmCC);
+  background-size: 300px 1px
+}
+
+.wy-grid-for-nav {
+  position: absolute;
+  width: 100%;
+  height: 100%
+}
+
+.wy-nav-side {
+  position: fixed;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  padding-bottom: 2em;
+  width: 300px;
+  overflow-x: hidden;
+  overflow-y: scroll;
+  min-height: 100%;
+  background-color: #fafafa;
+  z-index: 200;
+  border-right: 2px solid #eee;
+}
+
+.wy-nav-top {
+  display: none;
+  background-color: #333;
+  color: #fff;
+  padding: .4045em .809em;
+  position: relative;
+  line-height: 50px;
+  text-align: center;
+  font-size: 100%;
+  *zoom: 1
+}
+
+.wy-nav-top:before,
+.wy-nav-top:after {
+  display: table;
+  content: ""
+}
+
+.wy-nav-top:after {
+  clear: both
+}
+
+.wy-nav-top a {
+  color: #fff;
+  font-weight: 700
+}
+
+.wy-nav-top img {
+  margin-right: 12px;
+  height: 45px;
+  width: 45px;
+  background-color: #2980B9;
+  padding: 5px;
+  border-radius: 100%
+}
+
+.wy-nav-top i {
+  font-size: 30px;
+  line-height: 50px;
+  float: left;
+  cursor: pointer
+}
+
+.wy-nav-content-wrap {
+  margin-left: 300px;
+  background: #fcfcfc;
+  min-height: 100%
+}
+
+.wy-nav-content {
+  padding: 1.618em 3.236em;
+  height: 100%;
+  max-width: 1100px;
+  margin: auto
+}
+
+.wy-body-mask {
+  position: fixed;
+  width: 100%;
+  height: 100%;
+  background: rgba(0,0,0,0.2);
+  display: none;
+  z-index: 499
+}
+
+.wy-body-mask.on {
+  display: block
+}
+
+@media screen and (max-width: 768px) {
+  .wy-body-for-nav {
+    background: #fcfcfc
+  }
+
+  .wy-nav-top {
+    display: block
+  }
+
+  .wy-nav-side {
+    left: -300px
+  }
+
+  .wy-nav-side.shift {
+    width: 85%;
+    left: 0
+  }
+
+  .wy-nav-content-wrap {
+    margin-left: 0
+  }
+
+  .wy-nav-content-wrap .wy-nav-content {
+    padding: 1.618em
+  }
+
+  .wy-nav-content-wrap.shift {
+    position: fixed;
+    min-width: 100%;
+    left: 85%;
+    top: 0;
+    height: 100%;
+    overflow: hidden
+  }
+
+}
+
+@media screen and (min-width: 1400px) {
+  .wy-nav-content {
+    margin: 0;
+    background: #fcfcfc
+  }
+}
@@ -0,0 +1,3 @@
+_site
+.sass-cache
+.jekyll-metadata
@@ -0,0 +1,24 @@
+source "https://rubygems.org"
+ruby RUBY_VERSION
+
+# Hello! This is where you manage which Jekyll version is used to run.
+# When you want to use a different version, change it below, save the
+# file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
+#
+#     bundle exec jekyll serve
+#
+# This will help ensure the proper Jekyll version is running.
+# Happy Jekylling!
+gem "jekyll", "3.3.1"
+
+# This is the default theme for new Jekyll sites. You may change this to anything you like.
+gem "minima", "~> 2.0"
+
+# If you want to use GitHub Pages, remove the "gem "jekyll"" above and
+# uncomment the line below. To upgrade, run `bundle update github-pages`.
+# gem "github-pages", group: :jekyll_plugins
+
+# If you have any plugins, put them here!
+group :jekyll_plugins do
+   gem "jekyll-feed", "~> 0.6"
+end
@@ -0,0 +1,56 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.0)
+      public_suffix (~> 2.0, >= 2.0.2)
+    colorator (1.1.0)
+    ffi (1.9.14)
+    forwardable-extended (2.6.0)
+    jekyll (3.3.1)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 1.1)
+      kramdown (~> 1.3)
+      liquid (~> 3.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (~> 1.7)
+      safe_yaml (~> 1.0)
+    jekyll-feed (0.8.0)
+      jekyll (~> 3.3)
+    jekyll-sass-converter (1.5.0)
+      sass (~> 3.4)
+    jekyll-watch (1.5.0)
+      listen (~> 3.0, < 3.1)
+    kramdown (1.13.1)
+    liquid (3.0.6)
+    listen (3.0.8)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    mercenary (0.3.6)
+    minima (2.1.0)
+      jekyll (~> 3.3)
+    pathutil (0.14.0)
+      forwardable-extended (~> 2.6)
+    public_suffix (2.0.5)
+    rb-fsevent (0.9.8)
+    rb-inotify (0.9.7)
+      ffi (>= 0.5.0)
+    rouge (1.11.1)
+    safe_yaml (1.0.4)
+    sass (3.4.23)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jekyll (= 3.3.1)
+  jekyll-feed (~> 0.6)
+  minima (~> 2.0)
+
+RUBY VERSION
+   ruby 2.3.1p112
+
+BUNDLED WITH
+   1.13.7
@@ -0,0 +1,34 @@
+# Welcome to Jekyll!
+#
+# This config file is meant for settings that affect your whole blog, values
+# which you are expected to set up once and rarely edit after that. If you find
+# yourself editing this file very often, consider using Jekyll's data files
+# feature for the data you need to update frequently.
+#
+# For technical reasons, this file is *NOT* reloaded automatically when you use
+# 'bundle exec jekyll serve'. If you change this file, please restart the server process.
+
+# Site settings
+# These are used to personalize your new site. If you look in the HTML files,
+# you will see them accessed via {{ site.title }}, {{ site.email }}, and so on.
+# You can create any custom variable you would like, and they will be accessible
+# in the templates via {{ site.myvariable }}.
+title: Your awesome title
+email: your-email@domain.com
+description: > # this means to ignore newlines until "baseurl:"
+  Write an awesome description for your new site here. You can edit this
+  line in _config.yml. It will appear in your document head meta (for
+  Google search results) and in your feed.xml site description.
+baseurl: "" # the subpath of your site, e.g. /blog
+url: "" # the base hostname & protocol for your site, e.g. http://example.com
+twitter_username: jekyllrb
+github_username:  jekyll
+
+# Build settings
+markdown: kramdown
+theme: minima
+gems:
+  - jekyll-feed
+exclude:
+  - Gemfile
+  - Gemfile.lock
@@ -0,0 +1,25 @@
+---
+layout: post
+title:  "Welcome to Jekyll!"
+date:   2017-01-06 11:19:34 +0300
+categories: jekyll update
+---
+You’ll find this post in your `_posts` directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run `jekyll serve`, which launches a web server and auto-regenerates your site when a file is updated.
+
+To add new posts, simply add a file in the `_posts` directory that follows the convention `YYYY-MM-DD-name-of-post.ext` and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.
+
+Jekyll also offers powerful support for code snippets:
+
+{% highlight ruby %}
+def print_hi(name)
+  puts "Hi, #{name}"
+end
+print_hi('Tom')
+#=> prints 'Hi, Tom' to STDOUT.
+{% endhighlight %}
+
+Check out the [Jekyll docs][jekyll-docs] for more info on how to get the most out of Jekyll. File all bugs/feature requests at [Jekyll’s GitHub repo][jekyll-gh]. If you have questions, you can ask them on [Jekyll Talk][jekyll-talk].
+
+[jekyll-docs]: http://jekyllrb.com/docs/home
+[jekyll-gh]:   https://github.com/jekyll/jekyll
+[jekyll-talk]: https://talk.jekyllrb.com/
@@ -0,0 +1,15 @@
+---
+layout: page
+title: About
+permalink: /about/
+---
+
+This is the base Jekyll theme. You can find out more info about customizing your Jekyll theme, as well as basic Jekyll usage documentation at [jekyllrb.com](http://jekyllrb.com/)
+
+You can find the source code for the Jekyll new theme at:
+{% include icon-github.html username="jekyll" %} /
+[minima](https://github.com/jekyll/minima)
+
+You can find the source code for Jekyll at
+{% include icon-github.html username="jekyll" %} /
+[jekyll](https://github.com/jekyll/jekyll)
@@ -0,0 +1,6 @@
+---
+# You don't need to edit this file, it's empty on purpose.
+# Edit theme's home layout instead if you wanna make some changes
+# See: https://jekyllrb.com/docs/themes/#overriding-theme-defaults
+layout: home
+---
@@ -8,7 +8,8 @@ import (

 // TestInput used for testing purpose, it allows emitting requests on demand
 type TestInput struct {
-	data chan []byte
+	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")
Author	SHA1	Message	Date
Leonid Bugaev	7e5d71758e	Merge branch 'master' into payload-type-file-templae	2017-01-23 20:01:35 +03:00
Leonid Bugaev	be033f1f1e	Prettify http	2017-01-23 19:59:47 +03:00
Leonid Bugaev	ecb16664db	Allow to use payload type for file names (#417 )	2017-01-23 16:40:14 +04:00
Leonid Bugaev	2d370bd767	Allow to use payload type for file names	2017-01-23 15:38:02 +03:00
Leonid Bugaev	8c16220532	Track http responses (#416 )	2017-01-23 16:20:27 +04:00
Leonid Bugaev	ed37589748	Cleanup modifier settings after test	2017-01-23 14:43:58 +03:00
Leonid Bugaev	590304d687	Ensure that flush do not get called on closed file	2017-01-23 14:43:43 +03:00
Leonid Bugaev	e69570367b	More fmt fixes	2017-01-23 13:34:57 +03:00
Leonid Bugaev	043c0b7436	few fmt fixes	2017-01-23 13:33:36 +03:00
Leonid Bugaev	768a29e2af	Merge branch 'msales-apache-kafka-input'	2017-01-20 21:03:03 +03:00
Leonid Bugaev	5e90377a7f	Fmt changes	2017-01-20 21:01:19 +03:00
Leonid Bugaev	f520b338f3	Add tests and modify to work same as Kafka output	2017-01-20 21:00:23 +03:00
Leonid Bugaev	53cbd8863d	Merge branch 'apache-kafka-input' of https://github.com/msales/goreplay into msales-apache-kafka-input	2017-01-20 18:15:33 +03:00
Leonid Bugaev	def3c91898	Add Kafka tests and raw format mode (#415 ) * Add tests and send messages in raw format by default	2017-01-20 19:13:30 +04:00
Leonid Bugaev	4ea306b5a9	Merge branch 'master' of https://github.com/buger/gor	2017-01-20 16:10:12 +03:00
Leonid Bugaev	3b51158163	continue work on new docs	2017-01-20 16:09:00 +03:00
Leonid Bugaev	fe321cd055	Merge pull request #413 from SophisticaSean/master flush the output buffer when it should be flushed	2017-01-08 11:54:53 +04:00
Leonid Bugaev	8421ddb6ff	Rename Home.md to index.md	2017-01-05 20:35:21 +03:00
Leonid Bugaev	e5935a001d	Set theme jekyll-theme-cayman	2017-01-05 20:31:56 +03:00
Leonid Bugaev	a519c09770	Set theme jekyll-theme-slate	2017-01-05 20:28:45 +03:00
Leonid Bugaev	17c1abfc5e	Create CNAME	2017-01-05 20:25:09 +03:00
Leonid Bugaev	ea8d3f7299	Set theme jekyll-theme-cayman	2017-01-05 20:21:20 +03:00
Leonid Bugaev	962fd70d1a	Add docs to master	2017-01-05 20:19:44 +03:00
Sean Lewis	b0b697cba6	flush the output buffer when it should be flushed fixes #409	2017-01-04 14:59:39 -07:00
Leonid Bugaev	060f521a0a	Merge pull request #412 from buger/handle_spaces_in_filters Allow spaces inside filters	2016-12-27 19:52:11 +04:00
Leonid Bugaev	8e5a256226	Allow spaces inside filters	2016-12-27 18:48:59 +03:00
Leonid Bugaev	8ce5318fbf	Merge pull request #410 from smostovoy/381-dumb-to-files Support %r - request id - output file pattern #381	2016-12-27 19:07:54 +04:00
Leonid Bugaev	db1e3d71e7	Merge pull request #411 from buger/fix-proto-crash Fix crashes in ParseHeaders	2016-12-27 18:39:22 +04:00
Leonid Bugaev	f5e8e26e96	Fix #408	2016-12-27 17:16:29 +03:00
Sergey Mostovoy	826cc45d44	clean files in test [#381 ]	2016-12-27 12:46:47 +02:00
Sergey Mostovoy	5909dd71c5	Support %r - request id - output file pattern #381	2016-12-27 12:18:49 +02:00
Leonid Bugaev	3043189d55	Merge branch 'pr/406'	2016-12-23 20:29:13 +03:00
Leonid Bugaev	9b40730338	Merge branch 'master' into pr/406	2016-12-23 20:26:09 +03:00
Leonid Bugaev	be49c7e7ac	Run GC on each 1000th request	2016-12-23 20:25:09 +03:00
Nicholas Wiersma	dfd5fa0c4f	Update documentation	2016-12-22 10:28:35 +01:00
Sergey Mostovoy	5b5c3f33f4	Filter response if request is filtered #388	2016-12-22 11:25:29 +02:00
Nicholas Wiersma	1f19e550bb	Create kafka input	2016-12-22 09:59:48 +01:00
Leonid Bugaev	fd5118b76d	fix test: should not add port to host for https	2016-12-19 14:45:18 +03:00
Leonid Bugaev	7c7882969f	Merge pull request #377 from kudos/patch-1 Treat PATCH as a HTTP verb	2016-12-18 20:29:48 +03:00
Leonid Bugaev	5e6b58e7a6	Merge branch 'master' of https://github.com/buger/gor	2016-12-18 20:15:35 +03:00
Leonid Bugaev	a9ab7ca2f1	Merge pull request #395 from ylegat/feature/use-pcap-timestamp Resolve buger/gor#392 : use pcap timestamp	2016-12-18 20:15:09 +03:00
Leonid Bugaev	0a74db6aae	Disallow zero timeout (also used fix tests)	2016-12-18 20:09:24 +03:00
Yohan Legat	b462c06a7c	remove dead code	2016-12-08 17:35:45 +01:00
Yohan Legat	c6244435ca	[Boyscout] unexport TCPPacket.Dump() and Packet struct	2016-12-08 15:18:10 +01:00
Yohan Legat	fa0e96b7ef	Resolve buger/gor#392 : use pcap timestamp Timestamp requests are now fetched from pcap payload	2016-12-08 15:18:10 +01:00
Leonid Bugaev	ca61e39790	Merge pull request #398 from oivoodoo/master Register kafka output plugin in case of having passed settings	2016-12-02 18:02:49 +03:00
Alexandr Korsak	bea255ab11	Register kafka output plugin in case of having passed settings	2016-12-01 16:46:18 +03:00
Leonid Bugaev	bde2977268	Merge pull request #396 from ylegat/bugfix/handle-content-length-missing-for-1xx-204-304 Resolve buger/gor#394 : Timeout for NO_CONTENT responses	2016-12-01 14:15:47 +03:00
Yohan Legat	12043e5a01	Resolve buger/gor#394 : Timeout for NO_CONTENT responses 1xx, 204 and 304 HTTP responses MUST NOT include a message body (see [RFC-2616](https://tools.ietf.org/html/rfc2616#section-4.4)). Also, a server MAY send a Content-Length header field in a 304 (Not Modified) and MUST NOT send a Content-Length header field in any response with a status code of 1xx (Informational) or 204 (No Content) (see [RFC-7230](https://tools.ietf.org/html/rfc7230#section-3.3.2))	2016-12-01 12:08:32 +01:00
Leonid Bugaev	719e9b8e56	Merge pull request #379 from blastworksinc/feature/kafka-output Add Apache Kafka output as JSON message	2016-11-30 20:38:47 +03:00
Leonid Bugaev	cedc5fae32	Merge pull request #390 from outpace/sni-support Add basic SNI support	2016-11-23 20:36:19 +03:00
Daniel Solano Gómez	963f7a73d7	Add basic SNI support By adding the server name as part of the TLS client configuration, gor will now support connecting to hosts that require SNI (such as Amazon API Gateway).	2016-11-23 09:55:54 -05:00
Leonid Bugaev	1f24c709c2	Do not add port to Host header for https (#385 )	2016-11-14 17:49:58 +03:00
Leonid Bugaev	a1174a159c	Do not add port to Host header for https	2016-11-14 17:47:30 +03:00
Alexandr Korsak	f90dcc763b	Remove server.go because of having 'gor file-server :8080'	2016-11-08 22:21:35 +03:00
Alexandr Korsak	638ddfb144	Add one more test case to cover ':' inside of header value	2016-11-02 17:50:45 +03:00
Alexandr Korsak	40f7facc33	User-Agent could contains ':' inside of value.	2016-11-02 15:34:42 +03:00
Alexandr Korsak	0a038575f3	Add all headers and properly passed body	2016-11-02 00:03:12 +03:00
Alexandr Korsak	d424167f04	Change example of port for kafka host	2016-11-01 17:55:04 +03:00
Alexandr Korsak	41d3ce48a3	Add json message output for kafka	2016-11-01 17:51:15 +03:00
Alexandr Korsak	9b96dc20df	Change Dockerfile because of issue on build echo.java	2016-10-31 19:29:59 +03:00
Alexandr Korsak	e3a9a9b2c2	Add kafka output	2016-10-31 19:04:05 +03:00
Jonathan Cremin	76fb91966b	Treat PATCH as a HTTP verb	2016-10-27 18:44:54 +01:00
manjeshnilange	22466d4028	Adding ability to output http client to close connection on specific … (#375 ) * Adding ability to output http client to close connection on specific response status * Addressed review comments	2016-10-25 22:06:43 +03:00
Leonid Bugaev	47db326b0f	Fix truncated tcp check	2016-10-11 18:56:30 +03:00
Huu Khiem (Mark)	0831476beb	Set default value for output-http-timeout at declaration (#371 ) The actual default is 5s, set in the call of NewHTTPClient, even if we use `--output-http--timeout=0`. It's clearer to user if this value id declared upfront.	2016-09-27 10:40:26 +03:00
Leonid Bugaev	967c380dc3	go fmt	2016-08-31 17:27:45 +03:00
Leonid Bugaev	1674b58707	Fix basic http auth	2016-08-31 17:27:18 +03:00
Leonid Bugaev	a2f5e43375	Fix replayed response header	2016-08-31 16:27:07 +03:00
Leonid Bugaev	fc0361dcdc	Fix handling of connection: close for POST requests	2016-08-31 16:11:13 +03:00
Guillaume Gelin	647f7022cf	Add google/gopacket in vendor/ (#360 )	2016-08-23 19:29:27 +03:00
Mourjo Sen	082106dfd8	Fix Java middleware example (#358 ) * Add encoding/decoding HTTP msgs to Java middleware example. * Add clojure middleware example.	2016-08-20 19:55:45 +03:00
Leonid Bugaev	ecd7e3a5e5	Update README.md	2016-08-08 19:35:11 +03:00
Leonid Bugaev	544d9402f0	Disable forced flush	2016-08-08 18:09:14 +03:00
Leonid Bugaev	25ded56a59	Update COMM-LICENSE	2016-08-05 14:14:37 +03:00
Leonid Bugaev	392d9a2f0e	Update LICENSE.txt	2016-08-05 14:09:20 +03:00
Leonid Bugaev	fbebe72f02	Fix multi-packet splited headers	2016-08-03 16:56:50 +03:00
Leonid Bugaev	e38f6a5801	Do not quite on flush error	2016-08-02 12:55:02 +03:00
Leonid Bugaev	25b998fa3f	Fix run command	2016-08-01 19:23:14 +03:00
Leonid Bugaev	f1f8e2f2a4	Fix http-disallow-header option	2016-08-01 19:17:05 +03:00
Leonid Bugaev	07fa6d9a7c	Force Go DNS resolver	2016-08-01 18:05:52 +03:00
Leonid Bugaev	f0acd31d88	Disable --input-http flag until I decide how to do it properly	2016-07-31 20:18:49 +03:00
Leonid Bugaev	d34c27c3de	Track FIN packets to check for closed connection (#350 ) * Track FIN packets to check for closed connection * Add tests for FIN / fix bugs * Fmt changes	2016-07-31 20:16:01 +03:00
Leonid Bugaev	1d811f34db	Update LICENSE.txt	2016-07-13 20:29:36 +03:00
Leonid Bugaev	35bb655f2d	Fix response meta	2016-07-13 15:59:01 +03:00
Leonid Bugaev	24fc5b0078	Update README.md	2016-07-10 19:13:57 +03:00
Leonid Bugaev	8e0a8b31a9	Add missing submodule	2016-07-08 19:38:45 +03:00
Leonid Bugaev	dac04cbef3	Merge branch 'ortz-feature/timeout-flag'	2016-07-08 19:27:33 +03:00
Leonid Bugaev	dae6a8915d	Refactor exit-after	2016-07-08 19:27:20 +03:00
Or Tzabary	6620d25626	Change flag name, use of DurationVar instead of int	2016-07-08 19:04:24 +03:00
Or Tzabary	c78933f1df	Feature flag	2016-07-08 17:05:46 +03:00
Leonid Bugaev	12287d8bae	Fix type check, and add asserts submodule	2016-07-07 18:41:29 +03:00
Leonid Bugaev	a5cc943af4	Fix padded packet check	2016-07-07 18:11:33 +03:00
Joseph Lawson	e65035dd95	Update elasticsearch output to use vendored elastigo and fix #331 . (#333 ) * add elastigo submodule * add gou submodule * add go-hostpool submodule * use vendored elasticgo * update ReqUrl to ReqURL	2016-07-07 16:30:51 +03:00
Joseph Lawson	c128d46088	calculate TCP payload slice sizes for Ethernet II packets less than 64 octets (#326 ) * remove unused bCLRF var. * calculate TCP payload slice sizes for Ethernet II packets less than 64 octets * simplify slicing off padding for Ethernet link packets less than 61 octets in length. * Make IPv4 header stripping comments more accurate.	2016-07-06 21:10:02 +03:00
Leonid Bugaev	1ed8691b38	Fix loopback for non local IP's	2016-07-05 17:09:56 +03:00
Leonid Bugaev	f17f51390a	Fix 100-continue with multi-packet headers Also adds —output-null for testing purpose	2016-07-01 20:01:25 +03:00
Leonid Bugaev	5a0c03ec33	Fix BodySize for multi-packet headers	2016-06-30 14:13:27 +03:00
Leonid Bugaev	803d53a760	Merge branch 'ylegat-feature/respect_timestamps_when_replaying_requests'	2016-06-29 17:30:05 +03:00
Leonid Bugaev	7c33336433	Add missing change	2016-06-29 17:29:36 +03:00
Leonid Bugaev	37650df2c8	Refactor #308	2016-06-29 17:29:09 +03:00
Leonid Bugaev	f2ff542cea	Merge branch 'feature/respect_timestamps_when_replaying_requests' of https://github.com/ylegat/gor into ylegat-feature/respect_timestamps_when_replaying_requests	2016-06-27 16:19:47 +03:00
Leonid Bugaev	c756a11333	Pass only valid HTTP responses (#317 )	2016-06-27 16:00:57 +03:00
Leonid Bugaev	48fdc02d2f	Fix tests + refactoring	2016-06-21 18:32:07 +03:00
Leonid Bugaev	f2c9aee4ac	Merge branch 'o19s-fix-307'	2016-06-21 18:06:05 +03:00
Leonid Bugaev	aea32d9395	Rename DelHeader to DeleteHeader	2016-06-21 18:05:32 +03:00
Joseph Lawson	0089892b26	update 100-continue logic to support different header placement	2016-06-20 16:58:36 -04:00
Joseph Lawson	5d2cc68fff	Add proto.DelHeader Update proto.go to handle headers with whitespace after	2016-06-20 16:58:36 -04:00
Joseph Lawson	b0fff3c402	Alternative 100 continue test	2016-06-20 16:58:36 -04:00
Joseph Lawson	da09b14c8b	DRY 100-continue tests	2016-06-20 16:58:36 -04:00
Leonid Bugaev	e50ff77ca6	Update echo.sh	2016-06-20 19:57:10 +03:00
Leonid Bugaev	51860e130c	Add support for known network layers Fix #310 Close #311	2016-06-20 19:32:13 +03:00
Yohan Legat	9e7351d28c	Resolve buger/gor#300 : respect timestamps when replaying requests When Gor deals with multiple input files, it sorts them and replay their requests file after file. This behavior is not convenient and should be changed. We should respect timestamps order when replaying requests.	2016-06-17 11:53:10 +02:00
Marc Lallaouret	2c49556b2e	Clean current output file name (#304 )	2016-06-16 22:33:55 +06:00
Marc Lallaouret	d0e1858eb3	Fix `Close` implementation of plugins (#305 ) Indeed they do not declare error as return type and so, were not called at the end of the program	2016-06-16 22:33:07 +06:00
Leonid Bugaev	95eecb6b1c	Output file fixes * Fixed flush/Write race * Fixed names with underscores	2016-06-14 20:27:52 +05:00
Leonid Bugaev	c4271ffaf4	Connection timeout should inherit Timeout	2016-06-12 16:19:51 +05:00
Leonid Bugaev	f4e2b12d0f	v0.14.1 (#301 ) * Fix output-file * Fix tunnel interface	2016-06-10 21:15:08 +06:00
Leonid Bugaev	d193e24910	Raise error if packet layer unknown	2016-06-10 10:38:13 +05:00
Leonid Bugaev	d36afeeb39	Update homebrew formula	2016-06-09 20:18:40 +05:00
Leonid Bugaev	06d129d20d	Add support for injecting real ip (#296 )	2016-06-09 19:06:59 +06:00
Leonid Bugaev	a3aeca204c	Check dst and src IP's for packets (#295 ) * Add IP check * Check dst and src ips	2016-06-09 18:41:01 +06:00
Leonid Bugaev	35696a49c2	Add logging to the file-server	2016-06-08 14:38:09 +05:00
Leonid Bugaev	0fb8cec69b	Embed simple file server for tutorial purpose	2016-06-07 19:43:53 +05:00
Leonid Bugaev	cefa2b5cc2	Write files in chunks (#293 ) * Chunked output strategy * Fix sorting with indexes >= 10	2016-06-07 18:46:13 +06:00
Leonid Bugaev	ae092d6a02	Add custom HTTP methods Should fix #291	2016-06-04 21:12:43 +05:00
Leonid Bugaev	9a6186ce9c	Merge pull request #290 from buger/output-file-improvements File replay and recording improvements	2016-06-01 20:42:34 +06:00
Leonid Bugaev	ede0fb4c4c	Allow looping mode for --input-file	2016-06-01 18:49:20 +05:00
Leonid Bugaev	651bd82d3d	input-file support for gzip files	2016-06-01 10:41:29 +05:00
zweite	a4e5918534	start should after beging listen signal (#289 )	2016-06-01 11:11:43 +06:00
Leonid Bugaev	ecfd8549a6	Remove debug	2016-05-31 20:57:19 +05:00
Leonid Bugaev	0f5b509397	Add support for reading multiple files	2016-05-31 20:44:04 +05:00
Leonid Bugaev	c8a234b3dc	Remove test artifacts	2016-05-31 17:12:34 +05:00
Leonid Bugaev	b6f7de00c5	Add compression support	2016-05-31 16:41:01 +05:00
Leonid Bugaev	ba98e6e18a	Allow date templates for file names	2016-05-31 15:52:35 +05:00
Leonid Bugaev	b01748bbdf	Update echo.rb	2016-05-27 20:07:21 +05:00
Leonid Bugaev	75d217b846	Few fmt fixes	2016-05-27 16:38:09 +05:00
Leonid Bugaev	c1f354a01c	Support lower case headers	2016-05-27 16:36:28 +05:00
Leonid Bugaev	b900e38035	Add homebrew formula	2016-05-27 16:36:09 +05:00
Matteo	2f45fc8ef3	Fix link in Readme.md (#287 )	2016-05-27 16:33:22 +06:00
Leonid Bugaev	62b92576a0	Update README.md	2016-05-25 19:15:01 +05:00
Leonid Bugaev	98fe7f19b2	Fix raw socket ipv6 support	2016-05-25 16:27:18 +05:00
Dmitri Shuralyov	1c3af3ef6d	README: Fix link to issue tracker. (#283 ) It looks like you've used incorrect Markdown syntax to create a few links in commit `eb9e073af8`. You've since fixed some of the other links, e.g., in `2f86d005ad`, but this one remained unfixed. Also change the URL to point to issue tracker, and change the schema to https.	2016-05-24 13:22:01 +06:00
				`@@ -0,0 +1 @@`
				`[Website](https://goreplay.org) \| [PRO version](https://goreplay.org/pro.html) \| [[Getting started]] \| [[FAQ]] \| [Join newsletter](https://www.getdrip.com/forms/89690474/submissions/new)`