Apache Traffic Server
Copyright 2014 The Apache Software Foundation

This product includes software developed at
  - The Apache Software Foundation (http://www.apache.org/).
  - Yahoo! Inc
  - Network Geographics (http://network-geographics.com)
  - OmniTI
  - Comcast
  - LinkedIn
  - Mike Pall
  - GoDaddy

~~~

Codebase originally donated by Yahoo:

Copyright (C) 2009 Yahoo! Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

~~~

WebSocket support developed by LinkedIn
Copyright (C) 2014 LinkedIn

~~~

cache-key-genid Plugin developed by GoDaddy
Copyright (C) 2013 GoDaddy Operating Company, LLC

~~~

include/tscpp/api, src/tscpp/api developed by LinkedIn
Copyright (c) 2013 LinkedIn

~~~

remap_stats and url_sig plugins developed by Comcast.
Copyright (C) 2014 Comcast

~~~

collapsed_collapsing: Plugin for connection collapsing to origin
Copyright (C) 2014 Yahoo! Inc.  All rights reserved.

multiplexer: Plugin for request multiplixing
Copyright (C) 2015 Yahoo! Inc.  All rights reserved.

inliner: Plugin for inlining base64 images
Copyright (C) 2016 Yahoo! Inc.  All rights reserved.

~~~

healthchecks: Plugin for ATS healthchecks.
Copyright (C) 2012 GoDaddy Operating Company, LLC

~~~

src/tscore/HashFNV.cc contains code derived from code at http://www.isthe.com/chongo/tech/comp/fnv/
It is public domain and has no copyright.

~~

src/tscore/HashSip.cc contains code derived from code at https://github.com/floodyberry/siphash
The code is public domain.

The algorithm info can be found at: https://131002.net/siphash/

~~

plugins/experimental/memcache/protocol_binary.h developed by Sun Microsystems, Inc.
Copyright (c) <2008>, Sun Microsystems, Inc.  All rights reserved.

~~

Reusable Gold Testing System
https://bitbucket.org/dragon512/reusable-gold-testing-system
Copyright (c) 2015-2016 Jason Kenny All Rights Reserved.

~~

Folly: Facebook Open-source Library
https://github.com/facebook/folly

~~

yaml-cpp: A YAML parser and emitter in C++
https://github.com/jbeder/yaml-cpp

~~

fastlz: an ANSI C/C90 implementation of Lempel-Ziv 77 algorithm (LZ77) of lossless data compression.
https://github.com/ariya/FastLZ
