├── net ├── Timer.h ├── Buffer.h ├── Channel.h ├── Sockets.h ├── Acceptor.cpp ├── Acceptor.h ├── Buffer.cpp ├── Channel.cpp ├── EventLoop.h ├── Sockets.cpp ├── TcpServer.h ├── TimerQueue.h ├── Connector.cpp ├── EventLoop.cpp ├── PollPoller.cpp ├── TcpServer.cpp ├── TimerQueue.cpp ├── InetAddress.cpp ├── ProtocolStream.h ├── SelectPoller.cpp ├── TcpConnection.cpp ├── TcpConnection.h ├── EventLoopThread.cpp ├── ProtocolStream.cpp ├── Timer.cpp ├── Poller.cpp ├── Poller.h ├── TimerId.h ├── EventLoopThread.h ├── PollPoller.h ├── Endian.h ├── EpollPoller.h ├── SelectPoller.h ├── EventLoopThreadPool.h ├── Connector.h ├── InetAddress.h ├── TcpClient.h ├── EventLoopThreadPool.cpp ├── Callbacks.h ├── TcpClient.cpp └── EpollPoller.cpp ├── CMakeLists.txt ├── appsrc ├── main.cpp ├── BusinessSession.cpp └── BusinessSession.h ├── base ├── AsyncLog.h ├── Platform.h ├── AsyncLog.cpp ├── ConfigFileReader.h ├── ConfigFileReader.cpp ├── Platform.cpp ├── RAIIWrapper.h ├── Singleton.h ├── Timestamp.cpp └── Timestamp.h ├── utils ├── DaemonRun.h ├── StringUtil.h ├── DaemonRun.cpp ├── StringUtil.cpp ├── UUIDGenerator.h └── UUIDGenerator.cpp ├── zlib1.2.11 ├── ZlibUtil.h ├── zlibdemo.c ├── ZlibUtil.cpp ├── inffast.h ├── gzclose.c ├── 文件概览.txt ├── compress.c ├── inftrees.h ├── uncompr.c ├── adler32.c ├── inffixed.h ├── inflate.h ├── gzguts.h ├── zutil.h ├── trees.h ├── zutil.c ├── inftrees.c ├── inffast.c ├── deflate.h ├── crc32.c └── zconf.h ├── websocketsrc ├── MyWebSocketServer.h ├── MyWebSocketSession.h ├── MyWebSocketServer.cpp ├── MyWebSocketSession.cpp └── WebSocketHandshake.h ├── README.md ├── WebSocketServer.sln ├── WebSocketServer.vcxproj.filters └── WebSocketServer.vcxproj /net/Timer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Timer.h -------------------------------------------------------------------------------- /net/Buffer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Buffer.h -------------------------------------------------------------------------------- /net/Channel.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Channel.h -------------------------------------------------------------------------------- /net/Sockets.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Sockets.h -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/CMakeLists.txt -------------------------------------------------------------------------------- /appsrc/main.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/appsrc/main.cpp -------------------------------------------------------------------------------- /base/AsyncLog.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/base/AsyncLog.h -------------------------------------------------------------------------------- /base/Platform.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/base/Platform.h -------------------------------------------------------------------------------- /net/Acceptor.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Acceptor.cpp -------------------------------------------------------------------------------- /net/Acceptor.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Acceptor.h -------------------------------------------------------------------------------- /net/Buffer.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Buffer.cpp -------------------------------------------------------------------------------- /net/Channel.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Channel.cpp -------------------------------------------------------------------------------- /net/EventLoop.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/EventLoop.h -------------------------------------------------------------------------------- /net/Sockets.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Sockets.cpp -------------------------------------------------------------------------------- /net/TcpServer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/TcpServer.h -------------------------------------------------------------------------------- /net/TimerQueue.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/TimerQueue.h -------------------------------------------------------------------------------- /base/AsyncLog.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/base/AsyncLog.cpp -------------------------------------------------------------------------------- /net/Connector.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/Connector.cpp -------------------------------------------------------------------------------- /net/EventLoop.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/EventLoop.cpp -------------------------------------------------------------------------------- /net/PollPoller.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/PollPoller.cpp -------------------------------------------------------------------------------- /net/TcpServer.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/TcpServer.cpp -------------------------------------------------------------------------------- /net/TimerQueue.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/TimerQueue.cpp -------------------------------------------------------------------------------- /utils/DaemonRun.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/utils/DaemonRun.h -------------------------------------------------------------------------------- /utils/StringUtil.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/utils/StringUtil.h -------------------------------------------------------------------------------- /net/InetAddress.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/InetAddress.cpp -------------------------------------------------------------------------------- /net/ProtocolStream.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/ProtocolStream.h -------------------------------------------------------------------------------- /net/SelectPoller.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/SelectPoller.cpp -------------------------------------------------------------------------------- /net/TcpConnection.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/TcpConnection.cpp -------------------------------------------------------------------------------- /net/TcpConnection.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/TcpConnection.h -------------------------------------------------------------------------------- /utils/DaemonRun.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/utils/DaemonRun.cpp -------------------------------------------------------------------------------- /utils/StringUtil.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/utils/StringUtil.cpp -------------------------------------------------------------------------------- /utils/UUIDGenerator.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/utils/UUIDGenerator.h -------------------------------------------------------------------------------- /zlib1.2.11/ZlibUtil.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/zlib1.2.11/ZlibUtil.h -------------------------------------------------------------------------------- /zlib1.2.11/zlibdemo.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/zlib1.2.11/zlibdemo.c -------------------------------------------------------------------------------- /base/ConfigFileReader.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/base/ConfigFileReader.h -------------------------------------------------------------------------------- /net/EventLoopThread.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/EventLoopThread.cpp -------------------------------------------------------------------------------- /net/ProtocolStream.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/net/ProtocolStream.cpp -------------------------------------------------------------------------------- /utils/UUIDGenerator.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/utils/UUIDGenerator.cpp -------------------------------------------------------------------------------- /zlib1.2.11/ZlibUtil.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/zlib1.2.11/ZlibUtil.cpp -------------------------------------------------------------------------------- /appsrc/BusinessSession.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/appsrc/BusinessSession.cpp -------------------------------------------------------------------------------- /appsrc/BusinessSession.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/appsrc/BusinessSession.h -------------------------------------------------------------------------------- /base/ConfigFileReader.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/base/ConfigFileReader.cpp -------------------------------------------------------------------------------- /websocketsrc/MyWebSocketServer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/websocketsrc/MyWebSocketServer.h -------------------------------------------------------------------------------- /websocketsrc/MyWebSocketSession.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/websocketsrc/MyWebSocketSession.h -------------------------------------------------------------------------------- /websocketsrc/MyWebSocketServer.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/websocketsrc/MyWebSocketServer.cpp -------------------------------------------------------------------------------- /websocketsrc/MyWebSocketSession.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/balloonwj/WebSocketServer/HEAD/websocketsrc/MyWebSocketSession.cpp -------------------------------------------------------------------------------- /base/Platform.cpp: -------------------------------------------------------------------------------- 1 | #include "Platform.h" 2 | 3 | #ifdef WIN32 4 | 5 | NetworkInitializer::NetworkInitializer() 6 | { 7 | WORD wVersionRequested = MAKEWORD(2, 2); 8 | WSADATA wsaData; 9 | ::WSAStartup(wVersionRequested, &wsaData); 10 | } 11 | 12 | NetworkInitializer::~NetworkInitializer() 13 | { 14 | ::WSACleanup(); 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /net/Timer.cpp: -------------------------------------------------------------------------------- 1 | #include "Timer.h" 2 | 3 | using namespace net; 4 | 5 | std::atomic Timer::s_numCreated_; 6 | 7 | //void Timer::restart(Timestamp now) 8 | //{ 9 | // if (repeat_) 10 | // { 11 | // expiration_ = addTime(now, interval_); 12 | // } 13 | // else 14 | // { 15 | // expiration_ = Timestamp::invalid(); 16 | // } 17 | //} 18 | -------------------------------------------------------------------------------- /base/RAIIWrapper.h: -------------------------------------------------------------------------------- 1 | #ifndef __RAII_WRAPPER_H__ 2 | #define __RAII_WRAPPER_H__ 3 | 4 | template 5 | class RAIIWrapper 6 | { 7 | public: 8 | RAIIWrapper(T* p) :ptr(p) {} 9 | 10 | virtual ~RAIIWrapper() 11 | { 12 | if (ptr != NULL) 13 | { 14 | delete ptr; 15 | ptr = NULL; 16 | } 17 | } 18 | private: 19 | T* ptr; 20 | }; 21 | 22 | #endif //!__RAII_WRAPPER_H__ 23 | -------------------------------------------------------------------------------- /net/Poller.cpp: -------------------------------------------------------------------------------- 1 | #include "Poller.h" 2 | #include "Channel.h" 3 | 4 | using namespace net; 5 | 6 | Poller::Poller() 7 | { 8 | } 9 | 10 | Poller::~Poller() 11 | { 12 | } 13 | 14 | //bool Poller::hasChannel(Channel* channel) const 15 | //{ 16 | // //assertInLoopThread(); 17 | // //ChannelMap::const_iterator it = channels_.find(channel->fd()); 18 | // //return it != channels_.end() && it->second == channel; 19 | // 20 | // return false; 21 | //} -------------------------------------------------------------------------------- /zlib1.2.11/inffast.h: -------------------------------------------------------------------------------- 1 | /* inffast.h -- header to use inffast.c 2 | * Copyright (C) 1995-2003, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); 12 | -------------------------------------------------------------------------------- /net/Poller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "../base/Timestamp.h" 5 | 6 | namespace net 7 | { 8 | class Channel; 9 | 10 | class Poller 11 | { 12 | public: 13 | Poller(); 14 | ~Poller(); 15 | 16 | public: 17 | typedef std::vector ChannelList; 18 | 19 | virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels) = 0; 20 | virtual bool updateChannel(Channel* channel) = 0; 21 | virtual void removeChannel(Channel* channel) = 0; 22 | 23 | virtual bool hasChannel(Channel* channel) const = 0; 24 | }; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /net/TimerId.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace net 4 | { 5 | class Timer; 6 | 7 | /// 8 | /// An opaque identifier, for canceling Timer. 9 | /// 10 | class TimerId 11 | { 12 | public: 13 | TimerId(): timer_(NULL), sequence_(0) 14 | { 15 | } 16 | 17 | TimerId(Timer* timer, int64_t seq) : timer_(timer), sequence_(seq) 18 | { 19 | } 20 | 21 | Timer* getTimer() 22 | { 23 | return timer_; 24 | } 25 | 26 | // default copy-ctor, dtor and assignment are okay 27 | 28 | friend class TimerQueue; 29 | 30 | private: 31 | Timer* timer_; 32 | int64_t sequence_; 33 | }; 34 | 35 | } 36 | -------------------------------------------------------------------------------- /zlib1.2.11/gzclose.c: -------------------------------------------------------------------------------- 1 | /* gzclose.c -- zlib gzclose() function 2 | * Copyright (C) 2004, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "gzguts.h" 7 | 8 | /* gzclose() is in a separate file so that it is linked in only if it is used. 9 | That way the other gzclose functions can be used instead to avoid linking in 10 | unneeded compression or decompression routines. */ 11 | int ZEXPORT gzclose(file) 12 | gzFile file; 13 | { 14 | #ifndef NO_GZCOMPRESS 15 | gz_statep state; 16 | 17 | if (file == NULL) 18 | return Z_STREAM_ERROR; 19 | state = (gz_statep)file; 20 | 21 | return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); 22 | #else 23 | return gzclose_r(file); 24 | #endif 25 | } 26 | -------------------------------------------------------------------------------- /base/Singleton.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | template 4 | class Singleton 5 | { 6 | public: 7 | static T& Instance() 8 | { 9 | //pthread_once(&ponce_, &Singleton::init); 10 | if (nullptr == value_) 11 | { 12 | value_ = new T(); 13 | } 14 | return *value_; 15 | } 16 | 17 | private: 18 | Singleton(); 19 | ~Singleton(); 20 | 21 | Singleton(const Singleton&); 22 | Singleton& operator=(const Singleton&); 23 | 24 | static void init() 25 | { 26 | value_ = new T(); 27 | //::atexit(destroy); 28 | } 29 | 30 | static void destroy() 31 | { 32 | delete value_; 33 | } 34 | 35 | private: 36 | //static pthread_once_t ponce_; 37 | static T* value_; 38 | }; 39 | 40 | //template 41 | //pthread_once_t Singleton::ponce_ = PTHREAD_ONCE_INIT; 42 | 43 | template 44 | T* Singleton::value_ = nullptr; -------------------------------------------------------------------------------- /net/EventLoopThread.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | //#include "EventLoop.h" 9 | 10 | namespace net 11 | { 12 | 13 | class EventLoop; 14 | 15 | class EventLoopThread 16 | { 17 | public: 18 | typedef std::function ThreadInitCallback; 19 | 20 | EventLoopThread(const ThreadInitCallback& cb = ThreadInitCallback(), const std::string& name = ""); 21 | ~EventLoopThread(); 22 | EventLoop* startLoop(); 23 | void stopLoop(); 24 | 25 | private: 26 | void threadFunc(); 27 | 28 | EventLoop* loop_; 29 | bool exiting_; 30 | std::shared_ptr thread_; 31 | std::mutex mutex_; 32 | std::condition_variable cond_; 33 | ThreadInitCallback callback_; 34 | }; 35 | 36 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # WebSocketServer 2 | A light and high performance WebSocket Server. 3 | 4 | 5 | 6 | **Compile** 7 | 8 | On Windows, use Visual Studio 2019 to open `WebSocketServer.sln` and then compile it. 9 | 10 | On Linux, use this following instructions to compile: 11 | 12 | ``` 13 | cd WebSocketServer/ 14 | cmake . 15 | make 16 | ``` 17 | 18 | 19 | 20 | **Test Server** 21 | 22 | Use a websocket tool to connect `ws://101.37.25.166:9988`, then send message. 23 | 24 | 25 | 26 | If you are interested in High Performance Server Developing, welcome join in QQ Group: `578019391`. 27 | 28 | 29 | 30 | 这是一个轻量级高性能 WebSocket 服务。 31 | 32 | **编译方法** 33 | 34 | Windows 系统使用 Visual Studio 2019 打开 `WebSocketServer.sln` 文件编译即可。 35 | 36 | Linux 下使用如下步骤编译： 37 | 38 | ``` 39 | cd WebSocketServer/ 40 | cmake . 41 | make 42 | ``` 43 | 44 | 45 | 46 | **测试服务器** 47 | 48 | 你可以使用任意 websocket 工具去连接地址 `ws://101.37.25.166:9988` 然后给它发消息即可。 49 | 50 | 51 | 52 | 如果你对高性能服务器开发感兴趣，欢迎加入微信交流群，微信：easy_coder。 53 | -------------------------------------------------------------------------------- /net/PollPoller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef WIN32 4 | #include "Poller.h" 5 | 6 | #include 7 | #include 8 | 9 | struct pollfd; 10 | 11 | namespace net 12 | { 13 | class Channel; 14 | class EventLoop; 15 | /// 16 | /// IO Multiplexing with poll(2). 17 | /// 18 | class PollPoller : public Poller 19 | { 20 | public: 21 | 22 | PollPoller(EventLoop* loop); 23 | virtual ~PollPoller(); 24 | 25 | virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels); 26 | virtual bool updateChannel(Channel* channel); 27 | virtual void removeChannel(Channel* channel); 28 | 29 | void assertInLoopThread() const; 30 | 31 | 32 | private: 33 | void fillActiveChannels(int numEvents, ChannelList* activeChannels) const; 34 | 35 | private: 36 | typedef std::vector PollFdList; 37 | typedef std::map ChannelMap; 38 | 39 | ChannelMap channels_; 40 | PollFdList pollfds_; 41 | EventLoop* ownerLoop_; 42 | }; 43 | 44 | } 45 | 46 | #endif 47 | -------------------------------------------------------------------------------- /net/Endian.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace net 4 | { 5 | namespace sockets 6 | { 7 | inline uint64_t hostToNetwork64(uint64_t host64) 8 | { 9 | #ifdef WIN32 10 | return htonll(host64); 11 | #else 12 | return htobe64(host64); 13 | #endif 14 | } 15 | 16 | inline uint32_t hostToNetwork32(uint32_t host32) 17 | { 18 | #ifdef WIN32 19 | return htonl(host32); 20 | #else 21 | return htobe32(host32); 22 | #endif 23 | } 24 | 25 | inline uint16_t hostToNetwork16(uint16_t host16) 26 | { 27 | #ifdef WIN32 28 | return htons(host16); 29 | #else 30 | return htobe16(host16); 31 | #endif 32 | } 33 | 34 | inline uint64_t networkToHost64(uint64_t net64) 35 | { 36 | #ifdef WIN32 37 | return ntohll(net64); 38 | #else 39 | return be64toh(net64); 40 | #endif 41 | } 42 | 43 | inline uint32_t networkToHost32(uint32_t net32) 44 | { 45 | #ifdef WIN32 46 | return ntohl(net32); 47 | #else 48 | return be32toh(net32); 49 | #endif 50 | } 51 | 52 | inline uint16_t networkToHost16(uint16_t net16) 53 | { 54 | #ifdef WIN32 55 | return ntohs(net16); 56 | #else 57 | return be16toh(net16); 58 | #endif 59 | } 60 | }// end namespace sockets 61 | }// end namespace net 62 | -------------------------------------------------------------------------------- /net/EpollPoller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef WIN32 4 | 5 | #include 6 | #include 7 | 8 | #include "../base/Timestamp.h" 9 | //#include "EventLoop.h" 10 | #include "Poller.h" 11 | 12 | struct epoll_event; 13 | 14 | namespace net 15 | { 16 | class EventLoop; 17 | 18 | class EPollPoller : public Poller 19 | { 20 | public: 21 | EPollPoller(EventLoop* loop); 22 | virtual ~EPollPoller(); 23 | 24 | virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels); 25 | virtual bool updateChannel(Channel* channel); 26 | virtual void removeChannel(Channel* channel); 27 | 28 | virtual bool hasChannel(Channel* channel) const; 29 | 30 | //static EPollPoller* newDefaultPoller(EventLoop* loop); 31 | 32 | void assertInLoopThread() const; 33 | 34 | private: 35 | static const int kInitEventListSize = 16; 36 | 37 | void fillActiveChannels(int numEvents, ChannelList* activeChannels) const; 38 | bool update(int operation, Channel* channel); 39 | 40 | private: 41 | typedef std::vector EventList; 42 | 43 | int epollfd_; 44 | EventList events_; 45 | 46 | typedef std::map ChannelMap; 47 | 48 | ChannelMap channels_; 49 | EventLoop* ownerLoop_; 50 | }; 51 | 52 | } 53 | 54 | #endif -------------------------------------------------------------------------------- /zlib1.2.11/文件概览.txt: -------------------------------------------------------------------------------- 1 | 9、文件概览 2 | alder32.c：计算数据流的Alder-32校验和，实现alder32()。 3 | crc32.h和crc32.c：计算数据流的CRC-32，实现crc32()。 4 | deflate.h和deflate.c：使用默认算法压缩数据，实现deflate函数簇。 5 | inflate.h和inflate.c：zlib的解压，实现inflate函数簇。 6 | compress.c：实现内存缓冲区的压缩，包括compress(), compress2(), compressBound()。 7 | uncompr.c：实现内存缓冲区的解压，包括uncompress()。 8 | gzguts.h和gzlib.c：读写gzip文件的通用实现，包括gzopen(), gzdopen(), gzbuffer(), gzrewind(), gzseek(), gztell(), gzoffset(), gzeof(), gzerror(), gzclearerr()。 9 | gzclose.c：实现gzclose()。 10 | gzread.c：读取gzip文件的实现，包括gzread(), gzgetc(), gzungetc(), gzgets(), gzdirect(), gzclose_r()。 11 | gzwrite.c：写gzip文件的实现，包括gzwrite(), gzputc(), gzputs(), gzprintf(), gzflush(), gzsetparams(), gzclose_w()。 12 | infback.c：使用回调接口实现解压，包括inflateBackInit(), inflateBack(), inflateBackEnd()。 13 | zutil.h和zutil.c：zlib库用到的工具函数。包括zlibVersion(), zlibCompileFlags(), zError()。 14 | zlib.h：zlib库导出的接口描述文件，应用程序使用zlib库时需要本文件。 15 | zconf.h：zlib库的编译配置文件，如果编译时需要给所有库函数加上唯一的前缀，或者需要针对不同平台作特殊编译，需要用到本文件。还包括标准 C/C++兼容性定义；编译成DLL时是否使用WINAPI/WINAPIV调用方式；类型定义Byte，uInt, uLong, voidpf等。 16 | inftrees.h和inftrees.c：为有效的解码生成Huffman树。 17 | trees.h和trees.c：使用Huffman编码输出压缩的数据。 18 | inffixed.h：使用固定编码压缩。 19 | inffast.h和inffast.c：快速解压数据。 20 | 21 | 文章来源：http://blog.csdn.net/damenhanter/article/details/30757685 -------------------------------------------------------------------------------- /net/SelectPoller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Poller.h" 4 | #include 5 | #include "../base/Platform.h" 6 | //#include "EventLoop.h" 7 | 8 | namespace net 9 | { 10 | class EventLoop; 11 | class Channel; 12 | 13 | class SelectPoller : public Poller 14 | { 15 | public: 16 | SelectPoller(EventLoop* loop); 17 | virtual ~SelectPoller(); 18 | 19 | virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels); 20 | virtual bool updateChannel(Channel* channel); 21 | virtual void removeChannel(Channel* channel); 22 | 23 | virtual bool hasChannel(Channel* channel) const; 24 | 25 | //static EPollPoller* newDefaultPoller(EventLoop* loop); 26 | 27 | void assertInLoopThread() const; 28 | 29 | private: 30 | static const int kInitEventListSize = 16; 31 | 32 | void fillActiveChannels(int numEvents, ChannelList* activeChannels, fd_set& readfds, fd_set& writefds) const; 33 | bool update(int operation, Channel* channel); 34 | 35 | private: 36 | typedef std::vector EventList; 37 | 38 | int epollfd_; 39 | EventList events_; 40 | 41 | typedef std::map ChannelMap; 42 | 43 | ChannelMap channels_; 44 | EventLoop* ownerLoop_; 45 | }; 46 | 47 | } 48 | 49 | -------------------------------------------------------------------------------- /net/EventLoopThreadPool.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | //#include "EventLoop.h" 8 | 9 | namespace net 10 | { 11 | 12 | class EventLoop; 13 | class EventLoopThread; 14 | 15 | class EventLoopThreadPool 16 | { 17 | public: 18 | typedef std::function ThreadInitCallback; 19 | 20 | EventLoopThreadPool(); 21 | ~EventLoopThreadPool(); 22 | 23 | void Init(EventLoop* baseLoop, int numThreads); 24 | void start(const ThreadInitCallback& cb = ThreadInitCallback()); 25 | 26 | void stop(); 27 | 28 | // valid after calling start() 29 | /// round-robin 30 | EventLoop* getNextLoop(); 31 | 32 | /// with the same hash code, it will always return the same EventLoop 33 | EventLoop* getLoopForHash(size_t hashCode); 34 | 35 | std::vector getAllLoops(); 36 | 37 | bool started() const 38 | { return started_; } 39 | 40 | const std::string& name() const 41 | { return name_; } 42 | 43 | const std::string info() const; 44 | 45 | private: 46 | 47 | EventLoop* baseLoop_; 48 | std::string name_; 49 | bool started_; 50 | int numThreads_; 51 | int next_; 52 | std::vector > threads_; 53 | std::vector loops_; 54 | }; 55 | 56 | } -------------------------------------------------------------------------------- /WebSocketServer.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.29123.88 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WebSocketServer", "WebSocketServer.vcxproj", "{1CA1FE98-1553-4B6C-9507-0B13A85B0C68}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Debug|x64.ActiveCfg = Debug|x64 17 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Debug|x64.Build.0 = Debug|x64 18 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Debug|x86.ActiveCfg = Debug|Win32 19 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Debug|x86.Build.0 = Debug|Win32 20 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Release|x64.ActiveCfg = Release|x64 21 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Release|x64.Build.0 = Release|x64 22 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Release|x86.ActiveCfg = Release|Win32 23 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {AE874DD1-8D0E-4DF3-BD78-F5F99C4272D1} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /net/Connector.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "InetAddress.h" 4 | #include 5 | #include 6 | //#include "EventLoop.h" 7 | 8 | namespace net 9 | { 10 | 11 | class Channel; 12 | class EventLoop; 13 | 14 | class Connector : public std::enable_shared_from_this 15 | { 16 | public: 17 | typedef std::function NewConnectionCallback; 18 | 19 | Connector(EventLoop* loop, const InetAddress& serverAddr); 20 | ~Connector(); 21 | 22 | void setNewConnectionCallback(const NewConnectionCallback& cb) 23 | { newConnectionCallback_ = cb; } 24 | 25 | void start(); // can be called in any thread 26 | void restart(); // must be called in loop thread 27 | void stop(); // can be called in any thread 28 | 29 | const InetAddress& serverAddress() const { return serverAddr_; } 30 | 31 | private: 32 | enum States { kDisconnected, kConnecting, kConnected }; 33 | static const int kMaxRetryDelayMs = 30*1000; 34 | static const int kInitRetryDelayMs = 500; 35 | 36 | void setState(States s) { state_ = s; } 37 | void startInLoop(); 38 | void stopInLoop(); 39 | void connect(); 40 | void connecting(int sockfd); 41 | void handleWrite(); 42 | void handleError(); 43 | void retry(int sockfd); 44 | int removeAndResetChannel(); 45 | void resetChannel(); 46 | 47 | EventLoop* loop_; 48 | InetAddress serverAddr_; 49 | bool connect_; // atomic 50 | States state_; // FIXME: use atomic variable 51 | std::shared_ptr channel_; 52 | NewConnectionCallback newConnectionCallback_; 53 | int retryDelayMs_; 54 | }; 55 | 56 | } -------------------------------------------------------------------------------- /net/InetAddress.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "../base/Platform.h" 5 | 6 | namespace net 7 | { 8 | /// 9 | /// Wrapper of sockaddr_in. 10 | /// 11 | /// This is an POD interface class. 12 | class InetAddress 13 | { 14 | public: 15 | /// Constructs an endpoint with given port number. 16 | /// Mostly used in TcpServer listening. 17 | explicit InetAddress(uint16_t port = 0, bool loopbackOnly = false); 18 | 19 | /// Constructs an endpoint with given ip and port. 20 | /// @c ip should be "1.2.3.4" 21 | InetAddress(const std::string& ip, uint16_t port); 22 | 23 | /// Constructs an endpoint with given struct @c sockaddr_in 24 | /// Mostly used when accepting new connections 25 | InetAddress(const struct sockaddr_in& addr) 26 | : addr_(addr) 27 | { } 28 | 29 | std::string toIp() const; 30 | std::string toIpPort() const; 31 | uint16_t toPort() const; 32 | 33 | // default copy/assignment are Okay 34 | 35 | const struct sockaddr_in& getSockAddrInet() const { return addr_; } 36 | void setSockAddrInet(const struct sockaddr_in& addr) { addr_ = addr; } 37 | 38 | uint32_t ipNetEndian() const { return addr_.sin_addr.s_addr; } 39 | uint16_t portNetEndian() const { return addr_.sin_port; } 40 | 41 | // resolve hostname to IP address, not changing port or sin_family 42 | // return true on success. 43 | // thread safe 44 | static bool resolve(const std::string& hostname, InetAddress* result); 45 | // static std::vector resolveAll(const char* hostname, uint16_t port = 0); 46 | 47 | private: 48 | struct sockaddr_in addr_; 49 | 50 | }; 51 | 52 | } 53 | -------------------------------------------------------------------------------- /net/TcpClient.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include "TcpConnection.h" 6 | 7 | namespace net 8 | { 9 | class EventLoop; 10 | class Connector; 11 | typedef std::shared_ptr ConnectorPtr; 12 | 13 | class TcpClient 14 | { 15 | public: 16 | // TcpClient(EventLoop* loop); 17 | // TcpClient(EventLoop* loop, const string& host, uint16_t port); 18 | TcpClient(EventLoop* loop, const InetAddress& serverAddr, const string& nameArg); 19 | ~TcpClient(); // force out-line dtor, for scoped_ptr members. 20 | 21 | void connect(); 22 | void disconnect(); 23 | void stop(); 24 | 25 | TcpConnectionPtr connection() const 26 | { 27 | std::unique_lock lock(mutex_); 28 | return connection_; 29 | } 30 | 31 | EventLoop* getLoop() const { return loop_; } 32 | bool retry() const; 33 | void enableRetry() { retry_ = true; } 34 | 35 | const std::string& name() const 36 | { 37 | return name_; 38 | } 39 | 40 | /// Set connection callback. 41 | /// Not thread safe. 42 | void setConnectionCallback(const ConnectionCallback& cb) 43 | { 44 | connectionCallback_ = cb; 45 | } 46 | 47 | /// Set message callback. 48 | /// Not thread safe. 49 | void setMessageCallback(const MessageCallback& cb) 50 | { 51 | messageCallback_ = cb; 52 | } 53 | 54 | /// Set write complete callback. 55 | /// Not thread safe. 56 | void setWriteCompleteCallback(const WriteCompleteCallback& cb) 57 | { 58 | writeCompleteCallback_ = cb; 59 | } 60 | 61 | private: 62 | /// Not thread safe, but in loop 63 | void newConnection(int sockfd); 64 | /// Not thread safe, but in loop 65 | void removeConnection(const TcpConnectionPtr& conn); 66 | 67 | EventLoop* loop_; 68 | ConnectorPtr connector_; // avoid revealing Connector 69 | const std::string name_; 70 | ConnectionCallback connectionCallback_; 71 | MessageCallback messageCallback_; 72 | WriteCompleteCallback writeCompleteCallback_; 73 | bool retry_; // atomic 74 | bool connect_; // atomic 75 | // always in loop thread 76 | int nextConnId_; 77 | mutable std::mutex mutex_; 78 | TcpConnectionPtr connection_; // @GuardedBy mutex_ 79 | }; 80 | 81 | } 82 | -------------------------------------------------------------------------------- /base/Timestamp.cpp: -------------------------------------------------------------------------------- 1 | #include "Timestamp.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | static_assert(sizeof(Timestamp) == sizeof(int64_t), "sizeof(Timestamp) error"); 9 | 10 | Timestamp::Timestamp(int64_t microSecondsSinceEpoch) 11 | : microSecondsSinceEpoch_(microSecondsSinceEpoch) 12 | { 13 | } 14 | 15 | string Timestamp::toString() const 16 | { 17 | char buf[64] = { 0 }; 18 | int64_t seconds = microSecondsSinceEpoch_ / kMicroSecondsPerSecond; 19 | int64_t microseconds = microSecondsSinceEpoch_ % kMicroSecondsPerSecond; 20 | snprintf(buf, sizeof(buf)-1, "%lld.%06lld", (long long int)seconds, (long long int)microseconds); 21 | return buf; 22 | } 23 | 24 | string Timestamp::toFormattedString(bool showMicroseconds) const 25 | { 26 | time_t seconds = static_cast(microSecondsSinceEpoch_ / kMicroSecondsPerSecond); 27 | struct tm tm_time; 28 | 29 | #ifdef WIN32 30 | localtime_s(&tm_time, &seconds); 31 | #else 32 | struct tm *ptm; 33 | ptm = localtime(&seconds); 34 | tm_time = *ptm; 35 | #endif 36 | //ss << std::put_time(&ptm, "%F %T"); 37 | //<< ((double)(microSecondsSinceEpoch_ % kMicroSecondsPerSecond)) / kMicroSecondsPerSecond; 38 | 39 | char buf[32] = { 0 }; 40 | 41 | if (showMicroseconds) 42 | { 43 | int microseconds = static_cast(microSecondsSinceEpoch_ % kMicroSecondsPerSecond); 44 | #ifdef WIN32 45 | _snprintf_s(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d.%06d", 46 | tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday, 47 | tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, 48 | microseconds); 49 | #else 50 | snprintf(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d.%06d", 51 | tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday, 52 | tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, 53 | microseconds); 54 | #endif 55 | } 56 | else 57 | { 58 | #ifdef WIN32 59 | _snprintf_s(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d", 60 | tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday, 61 | tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec); 62 | #else 63 | snprintf(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d", 64 | tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday, 65 | tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec); 66 | #endif 67 | } 68 | 69 | 70 | return buf; 71 | } 72 | 73 | Timestamp Timestamp::now() 74 | { 75 | chrono::time_point now = chrono::time_point_cast( 76 | chrono::system_clock::now()); 77 | 78 | int64_t microSeconds = now.time_since_epoch().count(); 79 | Timestamp time(microSeconds); 80 | return time; 81 | } 82 | 83 | Timestamp Timestamp::invalid() 84 | { 85 | return Timestamp(); 86 | } -------------------------------------------------------------------------------- /net/EventLoopThreadPool.cpp: -------------------------------------------------------------------------------- 1 | #include "EventLoopThreadPool.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include "EventLoop.h" 7 | #include "EventLoopThread.h" 8 | #include "Callbacks.h" 9 | 10 | using namespace net; 11 | 12 | 13 | EventLoopThreadPool::EventLoopThreadPool() 14 | : baseLoop_(NULL), 15 | started_(false), 16 | numThreads_(0), 17 | next_(0) 18 | { 19 | } 20 | 21 | EventLoopThreadPool::~EventLoopThreadPool() 22 | { 23 | // Don't delete loop, it's stack variable 24 | } 25 | 26 | void EventLoopThreadPool::Init(EventLoop* baseLoop, int numThreads) 27 | { 28 | numThreads_ = numThreads; 29 | baseLoop_ = baseLoop; 30 | } 31 | 32 | void EventLoopThreadPool::start(const ThreadInitCallback& cb) 33 | { 34 | //assert(baseLoop_); 35 | if (baseLoop_ == NULL) 36 | return; 37 | 38 | //assert(!started_); 39 | if (started_) 40 | return; 41 | 42 | baseLoop_->assertInLoopThread(); 43 | 44 | started_ = true; 45 | 46 | for (int i = 0; i < numThreads_; ++i) 47 | { 48 | char buf[128]; 49 | snprintf(buf, sizeof buf, "%s%d", name_.c_str(), i); 50 | 51 | std::shared_ptr t(new EventLoopThread(cb, buf)); 52 | //EventLoopThread* t = new EventLoopThread(cb, buf); 53 | threads_.push_back(t); 54 | loops_.push_back(t->startLoop()); 55 | } 56 | if (numThreads_ == 0 && cb) 57 | { 58 | cb(baseLoop_); 59 | } 60 | } 61 | 62 | void EventLoopThreadPool::stop() 63 | { 64 | for (auto& iter : threads_) 65 | { 66 | iter->stopLoop(); 67 | } 68 | } 69 | 70 | EventLoop* EventLoopThreadPool::getNextLoop() 71 | { 72 | baseLoop_->assertInLoopThread(); 73 | //assert(started_); 74 | if (!started_) 75 | return NULL; 76 | 77 | EventLoop* loop = baseLoop_; 78 | 79 | if (!loops_.empty()) 80 | { 81 | // round-robin 82 | loop = loops_[next_]; 83 | ++next_; 84 | if (implicit_cast(next_) >= loops_.size()) 85 | { 86 | next_ = 0; 87 | } 88 | } 89 | return loop; 90 | } 91 | 92 | EventLoop* EventLoopThreadPool::getLoopForHash(size_t hashCode) 93 | { 94 | baseLoop_->assertInLoopThread(); 95 | EventLoop* loop = baseLoop_; 96 | 97 | if (!loops_.empty()) 98 | { 99 | loop = loops_[hashCode % loops_.size()]; 100 | } 101 | return loop; 102 | } 103 | 104 | std::vector EventLoopThreadPool::getAllLoops() 105 | { 106 | baseLoop_->assertInLoopThread(); 107 | if (loops_.empty()) 108 | { 109 | return std::vector(1, baseLoop_); 110 | } 111 | else 112 | { 113 | return loops_; 114 | } 115 | } 116 | 117 | const std::string EventLoopThreadPool::info() const 118 | { 119 | std::stringstream ss; 120 | ss << "print threads id info " << endl; 121 | for (size_t i = 0; i < loops_.size(); i++) 122 | { 123 | ss << i << ": id = " << loops_[i]->getThreadID() << endl; 124 | } 125 | return ss.str(); 126 | } -------------------------------------------------------------------------------- /zlib1.2.11/compress.c: -------------------------------------------------------------------------------- 1 | /* compress.c -- compress a memory buffer 2 | * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #define ZLIB_INTERNAL 9 | #include "zlib.h" 10 | 11 | /* =========================================================================== 12 | Compresses the source buffer into the destination buffer. The level 13 | parameter has the same meaning as in deflateInit. sourceLen is the byte 14 | length of the source buffer. Upon entry, destLen is the total size of the 15 | destination buffer, which must be at least 0.1% larger than sourceLen plus 16 | 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. 17 | 18 | compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 19 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, 20 | Z_STREAM_ERROR if the level parameter is invalid. 21 | */ 22 | int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) 23 | Bytef *dest; 24 | uLongf *destLen; 25 | const Bytef *source; 26 | uLong sourceLen; 27 | int level; 28 | { 29 | z_stream stream; 30 | int err; 31 | const uInt max = (uInt)-1; 32 | uLong left; 33 | 34 | left = *destLen; 35 | *destLen = 0; 36 | 37 | stream.zalloc = (alloc_func)0; 38 | stream.zfree = (free_func)0; 39 | stream.opaque = (voidpf)0; 40 | 41 | err = deflateInit(&stream, level); 42 | if (err != Z_OK) return err; 43 | 44 | stream.next_out = dest; 45 | stream.avail_out = 0; 46 | stream.next_in = (z_const Bytef *)source; 47 | stream.avail_in = 0; 48 | 49 | do { 50 | if (stream.avail_out == 0) { 51 | stream.avail_out = left > (uLong)max ? max : (uInt)left; 52 | left -= stream.avail_out; 53 | } 54 | if (stream.avail_in == 0) { 55 | stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen; 56 | sourceLen -= stream.avail_in; 57 | } 58 | err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH); 59 | } while (err == Z_OK); 60 | 61 | *destLen = stream.total_out; 62 | deflateEnd(&stream); 63 | return err == Z_STREAM_END ? Z_OK : err; 64 | } 65 | 66 | /* =========================================================================== 67 | */ 68 | int ZEXPORT compress (dest, destLen, source, sourceLen) 69 | Bytef *dest; 70 | uLongf *destLen; 71 | const Bytef *source; 72 | uLong sourceLen; 73 | { 74 | return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); 75 | } 76 | 77 | /* =========================================================================== 78 | If the default memLevel or windowBits for deflateInit() is changed, then 79 | this function needs to be updated. 80 | */ 81 | uLong ZEXPORT compressBound (sourceLen) 82 | uLong sourceLen; 83 | { 84 | return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 85 | (sourceLen >> 25) + 13; 86 | } 87 | -------------------------------------------------------------------------------- /zlib1.2.11/inftrees.h: -------------------------------------------------------------------------------- 1 | /* inftrees.h -- header to use inftrees.c 2 | * Copyright (C) 1995-2005, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* Structure for decoding tables. Each entry provides either the 12 | information needed to do the operation requested by the code that 13 | indexed that table entry, or it provides a pointer to another 14 | table that indexes more bits of the code. op indicates whether 15 | the entry is a pointer to another table, a literal, a length or 16 | distance, an end-of-block, or an invalid code. For a table 17 | pointer, the low four bits of op is the number of index bits of 18 | that table. For a length or distance, the low four bits of op 19 | is the number of extra bits to get after the code. bits is 20 | the number of bits in this code or part of the code to drop off 21 | of the bit buffer. val is the actual byte to output in the case 22 | of a literal, the base length or distance, or the offset from 23 | the current table to the next table. Each entry is four bytes. */ 24 | typedef struct { 25 | unsigned char op; /* operation, extra bits, table bits */ 26 | unsigned char bits; /* bits in this part of the code */ 27 | unsigned short val; /* offset in table or code value */ 28 | } code; 29 | 30 | /* op values as set by inflate_table(): 31 | 00000000 - literal 32 | 0000tttt - table link, tttt != 0 is the number of table index bits 33 | 0001eeee - length or distance, eeee is the number of extra bits 34 | 01100000 - end of block 35 | 01000000 - invalid code 36 | */ 37 | 38 | /* Maximum size of the dynamic table. The maximum number of code structures is 39 | 1444, which is the sum of 852 for literal/length codes and 592 for distance 40 | codes. These values were found by exhaustive searches using the program 41 | examples/enough.c found in the zlib distribtution. The arguments to that 42 | program are the number of symbols, the initial root table size, and the 43 | maximum bit length of a code. "enough 286 9 15" for literal/length codes 44 | returns returns 852, and "enough 30 6 15" for distance codes returns 592. 45 | The initial root table size (9 or 6) is found in the fifth argument of the 46 | inflate_table() calls in inflate.c and infback.c. If the root table size is 47 | changed, then these maximum sizes would be need to be recalculated and 48 | updated. */ 49 | #define ENOUGH_LENS 852 50 | #define ENOUGH_DISTS 592 51 | #define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) 52 | 53 | /* Type of code to build for inflate_table() */ 54 | typedef enum { 55 | CODES, 56 | LENS, 57 | DISTS 58 | } codetype; 59 | 60 | int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, 61 | unsigned codes, code FAR * FAR *table, 62 | unsigned FAR *bits, unsigned short FAR *work)); 63 | -------------------------------------------------------------------------------- /zlib1.2.11/uncompr.c: -------------------------------------------------------------------------------- 1 | /* uncompr.c -- decompress a memory buffer 2 | * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #define ZLIB_INTERNAL 9 | #include "zlib.h" 10 | 11 | /* =========================================================================== 12 | Decompresses the source buffer into the destination buffer. *sourceLen is 13 | the byte length of the source buffer. Upon entry, *destLen is the total size 14 | of the destination buffer, which must be large enough to hold the entire 15 | uncompressed data. (The size of the uncompressed data must have been saved 16 | previously by the compressor and transmitted to the decompressor by some 17 | mechanism outside the scope of this compression library.) Upon exit, 18 | *destLen is the size of the decompressed data and *sourceLen is the number 19 | of source bytes consumed. Upon return, source + *sourceLen points to the 20 | first unused input byte. 21 | 22 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough 23 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, or 24 | Z_DATA_ERROR if the input data was corrupted, including if the input data is 25 | an incomplete zlib stream. 26 | */ 27 | int ZEXPORT uncompress2 (dest, destLen, source, sourceLen) 28 | Bytef *dest; 29 | uLongf *destLen; 30 | const Bytef *source; 31 | uLong *sourceLen; 32 | { 33 | z_stream stream; 34 | int err; 35 | const uInt max = (uInt)-1; 36 | uLong len, left; 37 | Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */ 38 | 39 | len = *sourceLen; 40 | if (*destLen) { 41 | left = *destLen; 42 | *destLen = 0; 43 | } 44 | else { 45 | left = 1; 46 | dest = buf; 47 | } 48 | 49 | stream.next_in = (z_const Bytef *)source; 50 | stream.avail_in = 0; 51 | stream.zalloc = (alloc_func)0; 52 | stream.zfree = (free_func)0; 53 | stream.opaque = (voidpf)0; 54 | 55 | err = inflateInit(&stream); 56 | if (err != Z_OK) return err; 57 | 58 | stream.next_out = dest; 59 | stream.avail_out = 0; 60 | 61 | do { 62 | if (stream.avail_out == 0) { 63 | stream.avail_out = left > (uLong)max ? max : (uInt)left; 64 | left -= stream.avail_out; 65 | } 66 | if (stream.avail_in == 0) { 67 | stream.avail_in = len > (uLong)max ? max : (uInt)len; 68 | len -= stream.avail_in; 69 | } 70 | err = inflate(&stream, Z_NO_FLUSH); 71 | } while (err == Z_OK); 72 | 73 | *sourceLen -= len + stream.avail_in; 74 | if (dest != buf) 75 | *destLen = stream.total_out; 76 | else if (stream.total_out && err == Z_BUF_ERROR) 77 | left = 1; 78 | 79 | inflateEnd(&stream); 80 | return err == Z_STREAM_END ? Z_OK : 81 | err == Z_NEED_DICT ? Z_DATA_ERROR : 82 | err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR : 83 | err; 84 | } 85 | 86 | int ZEXPORT uncompress (dest, destLen, source, sourceLen) 87 | Bytef *dest; 88 | uLongf *destLen; 89 | const Bytef *source; 90 | uLong sourceLen; 91 | { 92 | return uncompress2(dest, destLen, source, &sourceLen); 93 | } 94 | -------------------------------------------------------------------------------- /net/Callbacks.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include "../base/Timestamp.h" 6 | 7 | // Adapted from google-protobuf stubs/common.h 8 | 9 | template 10 | inline To implicit_cast(From const& f) 11 | { 12 | return f; 13 | } 14 | 15 | // When you upcast (that is, cast a pointer from type Foo to type 16 | // SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts 17 | // always succeed. When you downcast (that is, cast a pointer from 18 | // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because 19 | // how do you know the pointer is really of type SubclassOfFoo? It 20 | // could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, 21 | // when you downcast, you should use this macro. In debug mode, we 22 | // use dynamic_cast<> to double-check the downcast is legal (we die 23 | // if it's not). In normal mode, we do the efficient static_cast<> 24 | // instead. Thus, it's important to test in debug mode to make sure 25 | // the cast is legal! 26 | // This is the only place in the code we should use dynamic_cast<>. 27 | // In particular, you SHOULDN'T be using dynamic_cast<> in order to 28 | // do RTTI (eg code like this: 29 | // if (dynamic_cast(foo)) HandleASubclass1Object(foo); 30 | // if (dynamic_cast(foo)) HandleASubclass2Object(foo); 31 | // You should design the code some other way not to need this. 32 | 33 | template // use like this: down_cast(foo); 34 | inline To down_cast(From* f) // so we only accept pointers 35 | { 36 | // Ensures that To is a sub-type of From *. This test is here only 37 | // for compile-time type checking, and has no overhead in an 38 | // optimized build at run-time, as it will be optimized away 39 | // completely. 40 | if (false) 41 | { 42 | implicit_cast(0); 43 | } 44 | 45 | #if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI) 46 | assert(f == NULL || dynamic_cast(f) != NULL); // RTTI: debug mode only! 47 | #endif 48 | return static_cast(f); 49 | } 50 | 51 | template 52 | inline std::shared_ptr down_pointer_cast(const std::shared_ptr & f) 53 | { 54 | if (false) 55 | { 56 | implicit_cast(0); 57 | } 58 | 59 | #ifndef NDEBUG 60 | assert(f == NULL || dynamic_cast(get_pointer(f)) != NULL); 61 | #endif 62 | return std::static_pointer_cast(f); 63 | } 64 | 65 | namespace net 66 | { 67 | 68 | // All client visible callbacks go here. 69 | 70 | class Buffer; 71 | class TcpConnection; 72 | typedef std::shared_ptr TcpConnectionPtr; 73 | typedef std::function TimerCallback; 74 | typedef std::function ConnectionCallback; 75 | typedef std::function CloseCallback; 76 | typedef std::function WriteCompleteCallback; 77 | typedef std::function HighWaterMarkCallback; 78 | 79 | // the data has been read to (buf, len) 80 | typedef std::function MessageCallback; 81 | 82 | void defaultConnectionCallback(const TcpConnectionPtr& conn); 83 | void defaultMessageCallback(const TcpConnectionPtr& conn, Buffer* buffer, Timestamp receiveTime); 84 | } 85 | -------------------------------------------------------------------------------- /base/Timestamp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | class Timestamp 10 | { 11 | public: 12 | /// 13 | /// Constucts an invalid Timestamp. 14 | /// 15 | Timestamp() : microSecondsSinceEpoch_(0) 16 | { 17 | } 18 | 19 | /// 20 | /// Constucts a Timestamp at specific time 21 | /// 22 | /// @param microSecondsSinceEpoch 23 | explicit Timestamp(int64_t microSecondsSinceEpoch); 24 | 25 | Timestamp& operator+=(Timestamp lhs) 26 | { 27 | this->microSecondsSinceEpoch_ += lhs.microSecondsSinceEpoch_; 28 | return *this; 29 | } 30 | 31 | Timestamp& operator+=(int64_t lhs) 32 | { 33 | this->microSecondsSinceEpoch_ += lhs; 34 | return *this; 35 | } 36 | 37 | Timestamp& operator-=(Timestamp lhs) 38 | { 39 | this->microSecondsSinceEpoch_ -= lhs.microSecondsSinceEpoch_; 40 | return *this; 41 | } 42 | 43 | Timestamp& operator-=(int64_t lhs) 44 | { 45 | this->microSecondsSinceEpoch_ -= lhs; 46 | return *this; 47 | } 48 | 49 | void swap(Timestamp& that) 50 | { 51 | std::swap(microSecondsSinceEpoch_, that.microSecondsSinceEpoch_); 52 | } 53 | 54 | // default copy/assignment/dtor are Okay 55 | 56 | string toString() const; 57 | string toFormattedString(bool showMicroseconds = true) const; 58 | 59 | bool valid() const { return microSecondsSinceEpoch_ > 0; } 60 | 61 | // for internal usage. 62 | int64_t microSecondsSinceEpoch() const { return microSecondsSinceEpoch_; } 63 | time_t secondsSinceEpoch() const 64 | { 65 | return static_cast(microSecondsSinceEpoch_ / kMicroSecondsPerSecond); 66 | } 67 | 68 | /// 69 | /// Get time of now. 70 | /// 71 | static Timestamp now(); 72 | static Timestamp invalid(); 73 | 74 | static const int kMicroSecondsPerSecond = 1000 * 1000; 75 | 76 | private: 77 | int64_t microSecondsSinceEpoch_; 78 | }; 79 | 80 | inline bool operator<(Timestamp lhs, Timestamp rhs) 81 | { 82 | return lhs.microSecondsSinceEpoch() < rhs.microSecondsSinceEpoch(); 83 | } 84 | 85 | inline bool operator>(Timestamp lhs, Timestamp rhs) 86 | { 87 | return rhs < lhs; 88 | } 89 | 90 | inline bool operator<=(Timestamp lhs, Timestamp rhs) 91 | { 92 | return !(lhs > rhs); 93 | } 94 | 95 | inline bool operator>=(Timestamp lhs, Timestamp rhs) 96 | { 97 | return !(lhs < rhs); 98 | } 99 | 100 | inline bool operator==(Timestamp lhs, Timestamp rhs) 101 | { 102 | return lhs.microSecondsSinceEpoch() == rhs.microSecondsSinceEpoch(); 103 | } 104 | 105 | inline bool operator!=(Timestamp lhs, Timestamp rhs) 106 | { 107 | return !(lhs == rhs); 108 | } 109 | 110 | /// 111 | /// Gets time difference of two timestamps, result in seconds. 112 | /// 113 | /// @param high, low 114 | /// @return (high-low) in seconds 115 | /// @c double has 52-bit precision, enough for one-microsecond 116 | /// resolution for next 100 years. 117 | inline double timeDifference(Timestamp high, Timestamp low) 118 | { 119 | int64_t diff = high.microSecondsSinceEpoch() - low.microSecondsSinceEpoch(); 120 | return static_cast(diff) / Timestamp::kMicroSecondsPerSecond; 121 | } 122 | 123 | /// 124 | /// Add @c seconds to given timestamp. 125 | /// 126 | /// @return timestamp+seconds as Timestamp 127 | /// 128 | inline Timestamp addTime(Timestamp timestamp, int64_t microseconds) 129 | { 130 | //int64_t delta = static_cast(seconds * Timestamp::kMicroSecondsPerSecond); 131 | return Timestamp(timestamp.microSecondsSinceEpoch() + microseconds); 132 | } 133 | 134 | -------------------------------------------------------------------------------- /net/TcpClient.cpp: -------------------------------------------------------------------------------- 1 | #include // snprintf 2 | #include 3 | 4 | #include "TcpClient.h" 5 | #include "../base/AsyncLog.h" 6 | #include "../base/Platform.h" 7 | #include "EventLoop.h" 8 | #include "Sockets.h" 9 | #include "Connector.h" 10 | 11 | using namespace net; 12 | 13 | // TcpClient::TcpClient(EventLoop* loop) 14 | // : loop_(loop) 15 | // { 16 | // } 17 | 18 | // TcpClient::TcpClient(EventLoop* loop, const string& host, uint16_t port) 19 | // : loop_(CHECK_NOTNULL(loop)), 20 | // serverAddr_(host, port) 21 | // { 22 | // } 23 | 24 | namespace net 25 | { 26 | namespace detail 27 | { 28 | 29 | void removeConnection(EventLoop* loop, const TcpConnectionPtr& conn) 30 | { 31 | loop->queueInLoop(std::bind(&TcpConnection::connectDestroyed, conn)); 32 | } 33 | 34 | void removeConnector(const ConnectorPtr& connector) 35 | { 36 | //connector-> 37 | } 38 | 39 | } 40 | } 41 | 42 | 43 | TcpClient::TcpClient(EventLoop* loop, 44 | const InetAddress& serverAddr, 45 | const std::string& nameArg) 46 | : loop_(loop), 47 | connector_(new Connector(loop, serverAddr)), 48 | name_(nameArg), 49 | connectionCallback_(defaultConnectionCallback), 50 | messageCallback_(defaultMessageCallback), 51 | retry_(false), 52 | connect_(true), 53 | nextConnId_(1) 54 | { 55 | connector_->setNewConnectionCallback( 56 | std::bind(&TcpClient::newConnection, this, std::placeholders::_1)); 57 | // FIXME setConnectFailedCallback 58 | LOGD("TcpClient::TcpClient[%s] - connector 0x%x", name_.c_str(), connector_.get()); 59 | } 60 | 61 | TcpClient::~TcpClient() 62 | { 63 | LOGD("TcpClient::~TcpClient[%s] - connector 0x%x", name_.c_str(), connector_.get()); 64 | TcpConnectionPtr conn; 65 | bool unique = false; 66 | { 67 | std::unique_lock lock(mutex_); 68 | unique = connection_.unique(); 69 | conn = connection_; 70 | } 71 | if (conn) 72 | { 73 | //assert(loop_ == conn->getLoop()); 74 | if (loop_ != conn->getLoop()) 75 | return; 76 | 77 | // FIXME: not 100% safe, if we are in different thread 78 | CloseCallback cb = std::bind(&detail::removeConnection, loop_, std::placeholders::_1); 79 | loop_->runInLoop(std::bind(&TcpConnection::setCloseCallback, conn, cb)); 80 | if (unique) 81 | { 82 | conn->forceClose(); 83 | } 84 | } 85 | else 86 | { 87 | connector_->stop(); 88 | // FIXME: HACK 89 | // loop_->runAfter(1, boost::bind(&detail::removeConnector, connector_)); 90 | } 91 | } 92 | 93 | void TcpClient::connect() 94 | { 95 | // FIXME: check state 96 | LOGD("TcpClient::connect[%s] - connecting to %s", name_.c_str(), connector_->serverAddress().toIpPort().c_str()); 97 | connect_ = true; 98 | connector_->start(); 99 | } 100 | 101 | void TcpClient::disconnect() 102 | { 103 | connect_ = false; 104 | 105 | { 106 | std::unique_lock lock(mutex_); 107 | if (connection_) 108 | { 109 | connection_->shutdown(); 110 | } 111 | } 112 | } 113 | 114 | void TcpClient::stop() 115 | { 116 | connect_ = false; 117 | connector_->stop(); 118 | } 119 | 120 | void TcpClient::newConnection(int sockfd) 121 | { 122 | loop_->assertInLoopThread(); 123 | InetAddress peerAddr(sockets::getPeerAddr(sockfd)); 124 | char buf[32]; 125 | snprintf(buf, sizeof buf, ":%s#%d", peerAddr.toIpPort().c_str(), nextConnId_); 126 | ++nextConnId_; 127 | string connName = name_ + buf; 128 | 129 | InetAddress localAddr(sockets::getLocalAddr(sockfd)); 130 | // FIXME poll with zero timeout to double confirm the new connection 131 | // FIXME use make_shared if necessary 132 | TcpConnectionPtr conn(new TcpConnection(loop_, connName, sockfd, localAddr, peerAddr)); 133 | conn->setConnectionCallback(connectionCallback_); 134 | conn->setMessageCallback(messageCallback_); 135 | conn->setWriteCompleteCallback(writeCompleteCallback_); 136 | conn->setCloseCallback(std::bind(&TcpClient::removeConnection, this, std::placeholders::_1)); // FIXME: unsafe 137 | 138 | { 139 | std::unique_lock lock(mutex_); 140 | connection_ = conn; 141 | } 142 | 143 | conn->connectEstablished(); 144 | } 145 | 146 | void TcpClient::removeConnection(const TcpConnectionPtr& conn) 147 | { 148 | loop_->assertInLoopThread(); 149 | //assert(loop_ == conn->getLoop()); 150 | if (loop_ != conn->getLoop()) 151 | return; 152 | 153 | { 154 | std::unique_lock lock(mutex_); 155 | //assert(connection_ == conn); 156 | if (connection_ != conn) 157 | return; 158 | 159 | connection_.reset(); 160 | } 161 | 162 | loop_->queueInLoop(std::bind(&TcpConnection::connectDestroyed, conn)); 163 | if (retry_ && connect_) 164 | { 165 | LOGD( "TcpClient::connect[%s] - Reconnecting to %s", name_.c_str(), connector_->serverAddress().toIpPort().c_str()); 166 | connector_->restart(); 167 | } 168 | } 169 | 170 | -------------------------------------------------------------------------------- /websocketsrc/WebSocketHandshake.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Authored by Alex Hultman, 2018-2019. 3 | * Intellectual property of third-party. 4 | 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | #ifndef UWS_WEBSOCKETHANDSHAKE_H 19 | #define UWS_WEBSOCKETHANDSHAKE_H 20 | 21 | #include 22 | #include 23 | 24 | namespace js { 25 | 26 | struct WebSocketHandshake { 27 | template 28 | struct static_for { 29 | void operator()(uint32_t *a, uint32_t *b) { 30 | static_for()(a, b); 31 | T::template f(a, b); 32 | } 33 | }; 34 | 35 | template 36 | struct static_for<0, T> { 37 | void operator()(uint32_t *a, uint32_t *hash) {} 38 | }; 39 | 40 | template 41 | struct Sha1Loop { 42 | static inline uint32_t rol(uint32_t value, size_t bits) {return (value << bits) | (value >> (32 - bits));} 43 | static inline uint32_t blk(uint32_t b[16], size_t i) { 44 | return rol(b[(i + 13) & 15] ^ b[(i + 8) & 15] ^ b[(i + 2) & 15] ^ b[i], 1); 45 | } 46 | 47 | template 48 | static inline void f(uint32_t *a, uint32_t *b) { 49 | switch (state) { 50 | case 1: 51 | a[i % 5] += ((a[(3 + i) % 5] & (a[(2 + i) % 5] ^ a[(1 + i) % 5])) ^ a[(1 + i) % 5]) + b[i] + 0x5a827999 + rol(a[(4 + i) % 5], 5); 52 | a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30); 53 | break; 54 | case 2: 55 | b[i] = blk(b, i); 56 | a[(1 + i) % 5] += ((a[(4 + i) % 5] & (a[(3 + i) % 5] ^ a[(2 + i) % 5])) ^ a[(2 + i) % 5]) + b[i] + 0x5a827999 + rol(a[(5 + i) % 5], 5); 57 | a[(4 + i) % 5] = rol(a[(4 + i) % 5], 30); 58 | break; 59 | case 3: 60 | b[(i + 4) % 16] = blk(b, (i + 4) % 16); 61 | a[i % 5] += (a[(3 + i) % 5] ^ a[(2 + i) % 5] ^ a[(1 + i) % 5]) + b[(i + 4) % 16] + 0x6ed9eba1 + rol(a[(4 + i) % 5], 5); 62 | a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30); 63 | break; 64 | case 4: 65 | b[(i + 8) % 16] = blk(b, (i + 8) % 16); 66 | a[i % 5] += (((a[(3 + i) % 5] | a[(2 + i) % 5]) & a[(1 + i) % 5]) | (a[(3 + i) % 5] & a[(2 + i) % 5])) + b[(i + 8) % 16] + 0x8f1bbcdc + rol(a[(4 + i) % 5], 5); 67 | a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30); 68 | break; 69 | case 5: 70 | b[(i + 12) % 16] = blk(b, (i + 12) % 16); 71 | a[i % 5] += (a[(3 + i) % 5] ^ a[(2 + i) % 5] ^ a[(1 + i) % 5]) + b[(i + 12) % 16] + 0xca62c1d6 + rol(a[(4 + i) % 5], 5); 72 | a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30); 73 | break; 74 | case 6: 75 | b[i] += a[4 - i]; 76 | } 77 | } 78 | }; 79 | 80 | static inline void sha1(uint32_t hash[5], uint32_t b[16]) { 81 | uint32_t a[5] = {hash[4], hash[3], hash[2], hash[1], hash[0]}; 82 | static_for<16, Sha1Loop<1>>()(a, b); 83 | static_for<4, Sha1Loop<2>>()(a, b); 84 | static_for<20, Sha1Loop<3>>()(a, b); 85 | static_for<20, Sha1Loop<4>>()(a, b); 86 | static_for<20, Sha1Loop<5>>()(a, b); 87 | static_for<5, Sha1Loop<6>>()(a, hash); 88 | } 89 | 90 | static inline void base64(unsigned char *src, char *dst) { 91 | const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 92 | for (int i = 0; i < 18; i += 3) { 93 | *dst++ = b64[(src[i] >> 2) & 63]; 94 | *dst++ = b64[((src[i] & 3) << 4) | ((src[i + 1] & 240) >> 4)]; 95 | *dst++ = b64[((src[i + 1] & 15) << 2) | ((src[i + 2] & 192) >> 6)]; 96 | *dst++ = b64[src[i + 2] & 63]; 97 | } 98 | *dst++ = b64[(src[18] >> 2) & 63]; 99 | *dst++ = b64[((src[18] & 3) << 4) | ((src[19] & 240) >> 4)]; 100 | *dst++ = b64[((src[19] & 15) << 2)]; 101 | *dst++ = '='; 102 | } 103 | 104 | public: 105 | static inline void generate(const char input[24], char output[28]) { 106 | uint32_t b_output[5] = { 107 | 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 108 | }; 109 | uint32_t b_input[16] = { 110 | 0, 0, 0, 0, 0, 0, 0x32353845, 0x41464135, 0x2d453931, 0x342d3437, 0x44412d39, 111 | 0x3543412d, 0x43354142, 0x30444338, 0x35423131, 0x80000000 112 | }; 113 | 114 | for (int i = 0; i < 6; i++) { 115 | b_input[i] = (input[4 * i + 3] & 0xff) | (input[4 * i + 2] & 0xff) << 8 | (input[4 * i + 1] & 0xff) << 16 | (input[4 * i + 0] & 0xff) << 24; 116 | } 117 | sha1(b_output, b_input); 118 | uint32_t last_b[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 480}; 119 | sha1(b_output, last_b); 120 | for (int i = 0; i < 5; i++) { 121 | uint32_t tmp = b_output[i]; 122 | char *bytes = (char *) &b_output[i]; 123 | bytes[3] = tmp & 0xff; 124 | bytes[2] = (tmp >> 8) & 0xff; 125 | bytes[1] = (tmp >> 16) & 0xff; 126 | bytes[0] = (tmp >> 24) & 0xff; 127 | } 128 | base64((unsigned char *) b_output, output); 129 | } 130 | }; 131 | 132 | } 133 | 134 | #endif // UWS_WEBSOCKETHANDSHAKE_H 135 | -------------------------------------------------------------------------------- /zlib1.2.11/adler32.c: -------------------------------------------------------------------------------- 1 | /* adler32.c -- compute the Adler-32 checksum of a data stream 2 | * Copyright (C) 1995-2011, 2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #include "zutil.h" 9 | 10 | local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); 11 | 12 | #define BASE 65521U /* largest prime smaller than 65536 */ 13 | #define NMAX 5552 14 | /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ 15 | 16 | #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} 17 | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); 18 | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); 19 | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); 20 | #define DO16(buf) DO8(buf,0); DO8(buf,8); 21 | 22 | /* use NO_DIVIDE if your processor does not do division in hardware -- 23 | try it both ways to see which is faster */ 24 | #ifdef NO_DIVIDE 25 | /* note that this assumes BASE is 65521, where 65536 % 65521 == 15 26 | (thank you to John Reiser for pointing this out) */ 27 | # define CHOP(a) \ 28 | do { \ 29 | unsigned long tmp = a >> 16; \ 30 | a &= 0xffffUL; \ 31 | a += (tmp << 4) - tmp; \ 32 | } while (0) 33 | # define MOD28(a) \ 34 | do { \ 35 | CHOP(a); \ 36 | if (a >= BASE) a -= BASE; \ 37 | } while (0) 38 | # define MOD(a) \ 39 | do { \ 40 | CHOP(a); \ 41 | MOD28(a); \ 42 | } while (0) 43 | # define MOD63(a) \ 44 | do { /* this assumes a is not negative */ \ 45 | z_off64_t tmp = a >> 32; \ 46 | a &= 0xffffffffL; \ 47 | a += (tmp << 8) - (tmp << 5) + tmp; \ 48 | tmp = a >> 16; \ 49 | a &= 0xffffL; \ 50 | a += (tmp << 4) - tmp; \ 51 | tmp = a >> 16; \ 52 | a &= 0xffffL; \ 53 | a += (tmp << 4) - tmp; \ 54 | if (a >= BASE) a -= BASE; \ 55 | } while (0) 56 | #else 57 | # define MOD(a) a %= BASE 58 | # define MOD28(a) a %= BASE 59 | # define MOD63(a) a %= BASE 60 | #endif 61 | 62 | /* ========================================================================= */ 63 | uLong ZEXPORT adler32_z(adler, buf, len) 64 | uLong adler; 65 | const Bytef *buf; 66 | z_size_t len; 67 | { 68 | unsigned long sum2; 69 | unsigned n; 70 | 71 | /* split Adler-32 into component sums */ 72 | sum2 = (adler >> 16) & 0xffff; 73 | adler &= 0xffff; 74 | 75 | /* in case user likes doing a byte at a time, keep it fast */ 76 | if (len == 1) { 77 | adler += buf[0]; 78 | if (adler >= BASE) 79 | adler -= BASE; 80 | sum2 += adler; 81 | if (sum2 >= BASE) 82 | sum2 -= BASE; 83 | return adler | (sum2 << 16); 84 | } 85 | 86 | /* initial Adler-32 value (deferred check for len == 1 speed) */ 87 | if (buf == Z_NULL) 88 | return 1L; 89 | 90 | /* in case short lengths are provided, keep it somewhat fast */ 91 | if (len < 16) { 92 | while (len--) { 93 | adler += *buf++; 94 | sum2 += adler; 95 | } 96 | if (adler >= BASE) 97 | adler -= BASE; 98 | MOD28(sum2); /* only added so many BASE's */ 99 | return adler | (sum2 << 16); 100 | } 101 | 102 | /* do length NMAX blocks -- requires just one modulo operation */ 103 | while (len >= NMAX) { 104 | len -= NMAX; 105 | n = NMAX / 16; /* NMAX is divisible by 16 */ 106 | do { 107 | DO16(buf); /* 16 sums unrolled */ 108 | buf += 16; 109 | } while (--n); 110 | MOD(adler); 111 | MOD(sum2); 112 | } 113 | 114 | /* do remaining bytes (less than NMAX, still just one modulo) */ 115 | if (len) { /* avoid modulos if none remaining */ 116 | while (len >= 16) { 117 | len -= 16; 118 | DO16(buf); 119 | buf += 16; 120 | } 121 | while (len--) { 122 | adler += *buf++; 123 | sum2 += adler; 124 | } 125 | MOD(adler); 126 | MOD(sum2); 127 | } 128 | 129 | /* return recombined sums */ 130 | return adler | (sum2 << 16); 131 | } 132 | 133 | /* ========================================================================= */ 134 | uLong ZEXPORT adler32(adler, buf, len) 135 | uLong adler; 136 | const Bytef *buf; 137 | uInt len; 138 | { 139 | return adler32_z(adler, buf, len); 140 | } 141 | 142 | /* ========================================================================= */ 143 | local uLong adler32_combine_(adler1, adler2, len2) 144 | uLong adler1; 145 | uLong adler2; 146 | z_off64_t len2; 147 | { 148 | unsigned long sum1; 149 | unsigned long sum2; 150 | unsigned rem; 151 | 152 | /* for negative len, return invalid adler32 as a clue for debugging */ 153 | if (len2 < 0) 154 | return 0xffffffffUL; 155 | 156 | /* the derivation of this formula is left as an exercise for the reader */ 157 | MOD63(len2); /* assumes len2 >= 0 */ 158 | rem = (unsigned)len2; 159 | sum1 = adler1 & 0xffff; 160 | sum2 = rem * sum1; 161 | MOD(sum2); 162 | sum1 += (adler2 & 0xffff) + BASE - 1; 163 | sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; 164 | if (sum1 >= BASE) sum1 -= BASE; 165 | if (sum1 >= BASE) sum1 -= BASE; 166 | if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1); 167 | if (sum2 >= BASE) sum2 -= BASE; 168 | return sum1 | (sum2 << 16); 169 | } 170 | 171 | /* ========================================================================= */ 172 | uLong ZEXPORT adler32_combine(adler1, adler2, len2) 173 | uLong adler1; 174 | uLong adler2; 175 | z_off_t len2; 176 | { 177 | return adler32_combine_(adler1, adler2, len2); 178 | } 179 | 180 | uLong ZEXPORT adler32_combine64(adler1, adler2, len2) 181 | uLong adler1; 182 | uLong adler2; 183 | z_off64_t len2; 184 | { 185 | return adler32_combine_(adler1, adler2, len2); 186 | } 187 | -------------------------------------------------------------------------------- /zlib1.2.11/inffixed.h: -------------------------------------------------------------------------------- 1 | /* inffixed.h -- table for decoding fixed codes 2 | * Generated automatically by makefixed(). 3 | */ 4 | 5 | /* WARNING: this file should *not* be used by applications. 6 | It is part of the implementation of this library and is 7 | subject to change. Applications should only use zlib.h. 8 | */ 9 | 10 | static const code lenfix[512] = { 11 | {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, 12 | {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, 13 | {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, 14 | {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, 15 | {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, 16 | {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, 17 | {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, 18 | {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, 19 | {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, 20 | {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, 21 | {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, 22 | {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, 23 | {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, 24 | {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, 25 | {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, 26 | {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, 27 | {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, 28 | {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, 29 | {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, 30 | {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, 31 | {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, 32 | {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, 33 | {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, 34 | {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, 35 | {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, 36 | {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, 37 | {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, 38 | {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, 39 | {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, 40 | {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, 41 | {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, 42 | {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, 43 | {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, 44 | {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, 45 | {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, 46 | {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, 47 | {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, 48 | {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, 49 | {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, 50 | {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, 51 | {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, 52 | {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, 53 | {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, 54 | {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, 55 | {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, 56 | {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, 57 | {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, 58 | {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, 59 | {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, 60 | {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, 61 | {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, 62 | {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, 63 | {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, 64 | {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, 65 | {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, 66 | {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, 67 | {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, 68 | {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, 69 | {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, 70 | {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, 71 | {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, 72 | {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, 73 | {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, 74 | {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, 75 | {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, 76 | {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, 77 | {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, 78 | {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, 79 | {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, 80 | {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, 81 | {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, 82 | {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, 83 | {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, 84 | {0,9,255} 85 | }; 86 | 87 | static const code distfix[32] = { 88 | {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, 89 | {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, 90 | {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, 91 | {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, 92 | {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, 93 | {22,5,193},{64,5,0} 94 | }; 95 | -------------------------------------------------------------------------------- /net/EpollPoller.cpp: -------------------------------------------------------------------------------- 1 | #include "EpollPoller.h" 2 | 3 | #ifndef WIN32 4 | #include 5 | #include "../base/Platform.h" 6 | #include "../base/AsyncLog.h" 7 | #include "EventLoop.h" 8 | #include "Channel.h" 9 | 10 | 11 | 12 | using namespace net; 13 | 14 | // On Linux, the constants of poll(2) and epoll(4) 15 | // are expected to be the same. 16 | //static_assert(EXPOLLIN == XPOLLIN, "EXPOLLIN == XPOLLIN"); 17 | //static_assert(EXPOLLPRI == XPOLLPRI, "EXPOLLPRI == XPOLLPRI"); 18 | //static_assert(EXPOLLOUT == XPOLLOUT, "EXPOLLOUT == XPOLLOUT"); 19 | //static_assert(EXPOLLRDHUP == XPOLLRDHUP,"EXPOLLRDHUP == XPOLLRDHUP"); 20 | //static_assert(EXPOLLERR == XPOLLERR, "EXPOLLERR == XPOLLERR"); 21 | //static_assert(EXPOLLHUP == XPOLLHUP, "EXPOLLHUP == XPOLLHUP"); 22 | 23 | namespace 24 | { 25 | const int kNew = -1; 26 | const int kAdded = 1; 27 | const int kDeleted = 2; 28 | } 29 | 30 | EPollPoller::EPollPoller(EventLoop* loop) 31 | :epollfd_(::epoll_create1(EPOLL_CLOEXEC)), 32 | events_(kInitEventListSize), 33 | ownerLoop_(loop) 34 | { 35 | if (epollfd_ < 0) 36 | { 37 | LOGF("EPollPoller::EPollPoller"); 38 | } 39 | } 40 | 41 | EPollPoller::~EPollPoller() 42 | { 43 | ::close(epollfd_); 44 | } 45 | 46 | bool EPollPoller::hasChannel(Channel* channel) const 47 | { 48 | assertInLoopThread(); 49 | ChannelMap::const_iterator it = channels_.find(channel->fd()); 50 | return it != channels_.end() && it->second == channel; 51 | } 52 | 53 | void EPollPoller::assertInLoopThread() const 54 | { 55 | ownerLoop_->assertInLoopThread(); 56 | } 57 | 58 | Timestamp EPollPoller::poll(int timeoutMs, ChannelList* activeChannels) 59 | { 60 | int numEvents = ::epoll_wait(epollfd_, 61 | &*events_.begin(), 62 | static_cast(events_.size()), 63 | timeoutMs); 64 | int savedErrno = errno; 65 | Timestamp now(Timestamp::now()); 66 | if (numEvents > 0) 67 | { 68 | //LOG_TRACE << numEvents << " events happended"; 69 | fillActiveChannels(numEvents, activeChannels); 70 | if (static_cast(numEvents) == events_.size()) 71 | { 72 | events_.resize(events_.size() * 2); 73 | } 74 | } 75 | else if (numEvents == 0) 76 | { 77 | //LOG_TRACE << " nothing happended"; 78 | } 79 | else 80 | { 81 | // error happens, log uncommon ones 82 | if (savedErrno != EINTR) 83 | { 84 | errno = savedErrno; 85 | LOGSYSE("EPollPoller::poll()"); 86 | } 87 | } 88 | return now; 89 | } 90 | 91 | void EPollPoller::fillActiveChannels(int numEvents, ChannelList* activeChannels) const 92 | { 93 | //assert(static_cast(numEvents) <= events_.size()); 94 | for (int i = 0; i < numEvents; ++i) 95 | { 96 | Channel* channel = static_cast(events_[i].data.ptr); 97 | int fd = channel->fd(); 98 | ChannelMap::const_iterator it = channels_.find(fd); 99 | if (it == channels_.end() || it->second != channel) 100 | return; 101 | channel->set_revents(events_[i].events); 102 | activeChannels->push_back(channel); 103 | } 104 | } 105 | 106 | bool EPollPoller::updateChannel(Channel* channel) 107 | { 108 | assertInLoopThread(); 109 | LOGD("fd = %d events = %d", channel->fd(), channel->events()); 110 | const int index = channel->index(); 111 | if (index == kNew || index == kDeleted) 112 | { 113 | // a new one, add with XEPOLL_CTL_ADD 114 | int fd = channel->fd(); 115 | if (index == kNew) 116 | { 117 | //assert(channels_.find(fd) == channels_.end()) 118 | if (channels_.find(fd) != channels_.end()) 119 | { 120 | LOGE("fd = %d must not exist in channels_", fd); 121 | return false; 122 | } 123 | 124 | 125 | channels_[fd] = channel; 126 | } 127 | else // index == kDeleted 128 | { 129 | //assert(channels_.find(fd) != channels_.end()); 130 | if (channels_.find(fd) == channels_.end()) 131 | { 132 | LOGE("fd = %d must exist in channels_", fd); 133 | return false; 134 | } 135 | 136 | //assert(channels_[fd] == channel); 137 | if (channels_[fd] != channel) 138 | { 139 | LOGE("current channel is not matched current fd, fd = %d", fd); 140 | return false; 141 | } 142 | } 143 | channel->set_index(kAdded); 144 | 145 | return update(XEPOLL_CTL_ADD, channel); 146 | } 147 | else 148 | { 149 | // update existing one with XEPOLL_CTL_MOD/DEL 150 | int fd = channel->fd(); 151 | //assert(channels_.find(fd) != channels_.end()); 152 | //assert(channels_[fd] == channel); 153 | //assert(index == kAdded); 154 | if (channels_.find(fd) == channels_.end() || channels_[fd] != channel || index != kAdded) 155 | { 156 | LOGE("current channel is not matched current fd, fd = %d, channel = 0x%x", fd, channel); 157 | return false; 158 | } 159 | 160 | if (channel->isNoneEvent()) 161 | { 162 | if (update(XEPOLL_CTL_DEL, channel)) 163 | { 164 | channel->set_index(kDeleted); 165 | return true; 166 | } 167 | return false; 168 | } 169 | else 170 | { 171 | return update(XEPOLL_CTL_MOD, channel); 172 | } 173 | } 174 | } 175 | 176 | void EPollPoller::removeChannel(Channel* channel) 177 | { 178 | assertInLoopThread(); 179 | int fd = channel->fd(); 180 | 181 | //assert(channels_.find(fd) != channels_.end()); 182 | //assert(channels_[fd] == channel); 183 | //assert(channel->isNoneEvent()); 184 | if (channels_.find(fd) == channels_.end() || channels_[fd] != channel || !channel->isNoneEvent()) 185 | return; 186 | 187 | int index = channel->index(); 188 | //assert(index == kAdded || index == kDeleted); 189 | if (index != kAdded && index != kDeleted) 190 | return; 191 | 192 | size_t n = channels_.erase(fd); 193 | (void)n; 194 | //assert(n == 1); 195 | if (n != 1) 196 | return; 197 | 198 | if (index == kAdded) 199 | { 200 | update(XEPOLL_CTL_DEL, channel); 201 | } 202 | channel->set_index(kNew); 203 | } 204 | 205 | bool EPollPoller::update(int operation, Channel* channel) 206 | { 207 | struct epoll_event event; 208 | memset(&event, 0, sizeof event); 209 | event.events = channel->events(); 210 | event.data.ptr = channel; 211 | int fd = channel->fd(); 212 | if (::epoll_ctl(epollfd_, operation, fd, &event) < 0) 213 | { 214 | if (operation == XEPOLL_CTL_DEL) 215 | { 216 | LOGE("epoll_ctl op=%d fd=%d, epollfd=%d, errno=%d, errorInfo: %s", operation, fd, epollfd_, errno, strerror(errno)); 217 | } 218 | else 219 | { 220 | LOGE("epoll_ctl op=%d fd=%d, epollfd=%d, errno=%d, errorInfo: %s", operation, fd, epollfd_, errno, strerror(errno)); 221 | } 222 | 223 | return false; 224 | } 225 | 226 | return true; 227 | } 228 | 229 | #endif -------------------------------------------------------------------------------- /zlib1.2.11/inflate.h: -------------------------------------------------------------------------------- 1 | /* inflate.h -- internal inflate state definition 2 | * Copyright (C) 1995-2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* define NO_GZIP when compiling if you want to disable gzip header and 12 | trailer decoding by inflate(). NO_GZIP would be used to avoid linking in 13 | the crc code when it is not needed. For shared libraries, gzip decoding 14 | should be left enabled. */ 15 | #ifndef NO_GZIP 16 | # define GUNZIP 17 | #endif 18 | 19 | /* Possible inflate modes between inflate() calls */ 20 | typedef enum { 21 | HEAD = 16180, /* i: waiting for magic header */ 22 | FLAGS, /* i: waiting for method and flags (gzip) */ 23 | TIME, /* i: waiting for modification time (gzip) */ 24 | OS, /* i: waiting for extra flags and operating system (gzip) */ 25 | EXLEN, /* i: waiting for extra length (gzip) */ 26 | EXTRA, /* i: waiting for extra bytes (gzip) */ 27 | NAME, /* i: waiting for end of file name (gzip) */ 28 | COMMENT, /* i: waiting for end of comment (gzip) */ 29 | HCRC, /* i: waiting for header crc (gzip) */ 30 | DICTID, /* i: waiting for dictionary check value */ 31 | DICT, /* waiting for inflateSetDictionary() call */ 32 | TYPE, /* i: waiting for type bits, including last-flag bit */ 33 | TYPEDO, /* i: same, but skip check to exit inflate on new block */ 34 | STORED, /* i: waiting for stored size (length and complement) */ 35 | COPY_, /* i/o: same as COPY below, but only first time in */ 36 | COPY, /* i/o: waiting for input or output to copy stored block */ 37 | TABLE, /* i: waiting for dynamic block table lengths */ 38 | LENLENS, /* i: waiting for code length code lengths */ 39 | CODELENS, /* i: waiting for length/lit and distance code lengths */ 40 | LEN_, /* i: same as LEN below, but only first time in */ 41 | LEN, /* i: waiting for length/lit/eob code */ 42 | LENEXT, /* i: waiting for length extra bits */ 43 | DIST, /* i: waiting for distance code */ 44 | DISTEXT, /* i: waiting for distance extra bits */ 45 | MATCH, /* o: waiting for output space to copy string */ 46 | LIT, /* o: waiting for output space to write literal */ 47 | CHECK, /* i: waiting for 32-bit check value */ 48 | LENGTH, /* i: waiting for 32-bit length (gzip) */ 49 | DONE, /* finished check, done -- remain here until reset */ 50 | BAD, /* got a data error -- remain here until reset */ 51 | MEM, /* got an inflate() memory error -- remain here until reset */ 52 | SYNC /* looking for synchronization bytes to restart inflate() */ 53 | } inflate_mode; 54 | 55 | /* 56 | State transitions between above modes - 57 | 58 | (most modes can go to BAD or MEM on error -- not shown for clarity) 59 | 60 | Process header: 61 | HEAD -> (gzip) or (zlib) or (raw) 62 | (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> 63 | HCRC -> TYPE 64 | (zlib) -> DICTID or TYPE 65 | DICTID -> DICT -> TYPE 66 | (raw) -> TYPEDO 67 | Read deflate blocks: 68 | TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK 69 | STORED -> COPY_ -> COPY -> TYPE 70 | TABLE -> LENLENS -> CODELENS -> LEN_ 71 | LEN_ -> LEN 72 | Read deflate codes in fixed or dynamic block: 73 | LEN -> LENEXT or LIT or TYPE 74 | LENEXT -> DIST -> DISTEXT -> MATCH -> LEN 75 | LIT -> LEN 76 | Process trailer: 77 | CHECK -> LENGTH -> DONE 78 | */ 79 | 80 | /* State maintained between inflate() calls -- approximately 7K bytes, not 81 | including the allocated sliding window, which is up to 32K bytes. */ 82 | struct inflate_state { 83 | z_streamp strm; /* pointer back to this zlib stream */ 84 | inflate_mode mode; /* current inflate mode */ 85 | int last; /* true if processing last block */ 86 | int wrap; /* bit 0 true for zlib, bit 1 true for gzip, 87 | bit 2 true to validate check value */ 88 | int havedict; /* true if dictionary provided */ 89 | int flags; /* gzip header method and flags (0 if zlib) */ 90 | unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ 91 | unsigned long check; /* protected copy of check value */ 92 | unsigned long total; /* protected copy of output count */ 93 | gz_headerp head; /* where to save gzip header information */ 94 | /* sliding window */ 95 | unsigned wbits; /* log base 2 of requested window size */ 96 | unsigned wsize; /* window size or zero if not using window */ 97 | unsigned whave; /* valid bytes in the window */ 98 | unsigned wnext; /* window write index */ 99 | unsigned char FAR *window; /* allocated sliding window, if needed */ 100 | /* bit accumulator */ 101 | unsigned long hold; /* input bit accumulator */ 102 | unsigned bits; /* number of bits in "in" */ 103 | /* for string and stored block copying */ 104 | unsigned length; /* literal or length of data to copy */ 105 | unsigned offset; /* distance back to copy string from */ 106 | /* for table and code decoding */ 107 | unsigned extra; /* extra bits needed */ 108 | /* fixed and dynamic code tables */ 109 | code const FAR *lencode; /* starting table for length/literal codes */ 110 | code const FAR *distcode; /* starting table for distance codes */ 111 | unsigned lenbits; /* index bits for lencode */ 112 | unsigned distbits; /* index bits for distcode */ 113 | /* dynamic table building */ 114 | unsigned ncode; /* number of code length code lengths */ 115 | unsigned nlen; /* number of length code lengths */ 116 | unsigned ndist; /* number of distance code lengths */ 117 | unsigned have; /* number of code lengths in lens[] */ 118 | code FAR *next; /* next available space in codes[] */ 119 | unsigned short lens[320]; /* temporary storage for code lengths */ 120 | unsigned short work[288]; /* work area for code table building */ 121 | code codes[ENOUGH]; /* space for code tables */ 122 | int sane; /* if false, allow invalid distance too far */ 123 | int back; /* bits back of last unprocessed length/lit */ 124 | unsigned was; /* initial length of match */ 125 | }; 126 | -------------------------------------------------------------------------------- /zlib1.2.11/gzguts.h: -------------------------------------------------------------------------------- 1 | /* gzguts.h -- zlib internal header definitions for gz* operations 2 | * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | #ifdef _MSC_VER 6 | #pragma warning( disable: 4996 ) 7 | #endif 8 | 9 | #ifdef _LARGEFILE64_SOURCE 10 | # ifndef _LARGEFILE_SOURCE 11 | # define _LARGEFILE_SOURCE 1 12 | # endif 13 | # ifdef _FILE_OFFSET_BITS 14 | # undef _FILE_OFFSET_BITS 15 | # endif 16 | #endif 17 | 18 | #ifdef HAVE_HIDDEN 19 | # define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) 20 | #else 21 | # define ZLIB_INTERNAL 22 | #endif 23 | 24 | #include 25 | #include "zlib.h" 26 | #ifdef STDC 27 | # include 28 | # include 29 | # include 30 | #endif 31 | 32 | #ifndef _POSIX_SOURCE 33 | # define _POSIX_SOURCE 34 | #endif 35 | #include 36 | 37 | #ifdef _WIN32 38 | # include 39 | #endif 40 | 41 | #if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32) 42 | # include 43 | #endif 44 | 45 | #if defined(_WIN32) || defined(__CYGWIN__) 46 | # define WIDECHAR 47 | #endif 48 | 49 | #ifdef WINAPI_FAMILY 50 | # define open _open 51 | # define read _read 52 | # define write _write 53 | # define close _close 54 | #endif 55 | 56 | #ifdef NO_DEFLATE /* for compatibility with old definition */ 57 | # define NO_GZCOMPRESS 58 | #endif 59 | 60 | #if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) 61 | # ifndef HAVE_VSNPRINTF 62 | # define HAVE_VSNPRINTF 63 | # endif 64 | #endif 65 | 66 | #if defined(__CYGWIN__) 67 | # ifndef HAVE_VSNPRINTF 68 | # define HAVE_VSNPRINTF 69 | # endif 70 | #endif 71 | 72 | #if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410) 73 | # ifndef HAVE_VSNPRINTF 74 | # define HAVE_VSNPRINTF 75 | # endif 76 | #endif 77 | 78 | #ifndef HAVE_VSNPRINTF 79 | # ifdef MSDOS 80 | /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), 81 | but for now we just assume it doesn't. */ 82 | # define NO_vsnprintf 83 | # endif 84 | # ifdef __TURBOC__ 85 | # define NO_vsnprintf 86 | # endif 87 | # ifdef WIN32 88 | /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ 89 | # if !defined(vsnprintf) && !defined(NO_vsnprintf) 90 | # if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) 91 | # define vsnprintf _vsnprintf 92 | # endif 93 | # endif 94 | # endif 95 | # ifdef __SASC 96 | # define NO_vsnprintf 97 | # endif 98 | # ifdef VMS 99 | # define NO_vsnprintf 100 | # endif 101 | # ifdef __OS400__ 102 | # define NO_vsnprintf 103 | # endif 104 | # ifdef __MVS__ 105 | # define NO_vsnprintf 106 | # endif 107 | #endif 108 | 109 | /* unlike snprintf (which is required in C99), _snprintf does not guarantee 110 | null termination of the result -- however this is only used in gzlib.c where 111 | the result is assured to fit in the space provided */ 112 | #if defined(_MSC_VER) && _MSC_VER < 1900 113 | # define snprintf _snprintf 114 | #endif 115 | 116 | #ifndef local 117 | # define local static 118 | #endif 119 | /* since "static" is used to mean two completely different things in C, we 120 | define "local" for the non-static meaning of "static", for readability 121 | (compile with -Dlocal if your debugger can't find static symbols) */ 122 | 123 | /* gz* functions always use library allocation functions */ 124 | #ifndef STDC 125 | extern voidp malloc OF((uInt size)); 126 | extern void free OF((voidpf ptr)); 127 | #endif 128 | 129 | /* get errno and strerror definition */ 130 | #if defined UNDER_CE 131 | # include 132 | # define zstrerror() gz_strwinerror((DWORD)GetLastError()) 133 | #else 134 | # ifndef NO_STRERROR 135 | # include 136 | # define zstrerror() strerror(errno) 137 | # else 138 | # define zstrerror() "stdio error (consult errno)" 139 | # endif 140 | #endif 141 | 142 | /* provide prototypes for these when building zlib without LFS */ 143 | #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 144 | ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); 145 | ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); 146 | ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); 147 | ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); 148 | #endif 149 | 150 | /* default memLevel */ 151 | #if MAX_MEM_LEVEL >= 8 152 | # define DEF_MEM_LEVEL 8 153 | #else 154 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL 155 | #endif 156 | 157 | /* default i/o buffer size -- double this for output when reading (this and 158 | twice this must be able to fit in an unsigned type) */ 159 | #define GZBUFSIZE 8192 160 | 161 | /* gzip modes, also provide a little integrity check on the passed structure */ 162 | #define GZ_NONE 0 163 | #define GZ_READ 7247 164 | #define GZ_WRITE 31153 165 | #define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ 166 | 167 | /* values for gz_state how */ 168 | #define LOOK 0 /* look for a gzip header */ 169 | #define COPY 1 /* copy input directly */ 170 | #define GZIP 2 /* decompress a gzip stream */ 171 | 172 | /* internal gzip file state data structure */ 173 | typedef struct { 174 | /* exposed contents for gzgetc() macro */ 175 | struct gzFile_s x; /* "x" for exposed */ 176 | /* x.have: number of bytes available at x.next */ 177 | /* x.next: next output data to deliver or write */ 178 | /* x.pos: current position in uncompressed data */ 179 | /* used for both reading and writing */ 180 | int mode; /* see gzip modes above */ 181 | int fd; /* file descriptor */ 182 | char *path; /* path or fd for error messages */ 183 | unsigned size; /* buffer size, zero if not allocated yet */ 184 | unsigned want; /* requested buffer size, default is GZBUFSIZE */ 185 | unsigned char *in; /* input buffer (double-sized when writing) */ 186 | unsigned char *out; /* output buffer (double-sized when reading) */ 187 | int direct; /* 0 if processing gzip, 1 if transparent */ 188 | /* just for reading */ 189 | int how; /* 0: get header, 1: copy, 2: decompress */ 190 | z_off64_t start; /* where the gzip data started, for rewinding */ 191 | int eof; /* true if end of input file reached */ 192 | int past; /* true if read requested past end */ 193 | /* just for writing */ 194 | int level; /* compression level */ 195 | int strategy; /* compression strategy */ 196 | /* seek request */ 197 | z_off64_t skip; /* amount to skip (already rewound if backwards) */ 198 | int seek; /* true if seek request pending */ 199 | /* error information */ 200 | int err; /* error code */ 201 | char *msg; /* error message */ 202 | /* zlib inflate or deflate stream */ 203 | z_stream strm; /* stream structure in-place (not a pointer) */ 204 | } gz_state; 205 | typedef gz_state FAR *gz_statep; 206 | 207 | /* shared functions */ 208 | void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); 209 | #if defined UNDER_CE 210 | char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); 211 | #endif 212 | 213 | /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t 214 | value -- needed when comparing unsigned to z_off64_t, which is signed 215 | (possible z_off64_t types off_t, off64_t, and long are all signed) */ 216 | #ifdef INT_MAX 217 | # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) 218 | #else 219 | unsigned ZLIB_INTERNAL gz_intmax OF((void)); 220 | # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) 221 | #endif 222 | -------------------------------------------------------------------------------- /zlib1.2.11/zutil.h: -------------------------------------------------------------------------------- 1 | /* zutil.h -- internal interface and configuration of the compression library 2 | * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* @(#) $Id$ */ 12 | 13 | #ifndef ZUTIL_H 14 | #define ZUTIL_H 15 | 16 | #ifdef HAVE_HIDDEN 17 | # define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) 18 | #else 19 | # define ZLIB_INTERNAL 20 | #endif 21 | 22 | #include "zlib.h" 23 | 24 | #if defined(STDC) && !defined(Z_SOLO) 25 | # if !(defined(_WIN32_WCE) && defined(_MSC_VER)) 26 | # include 27 | # endif 28 | # include 29 | # include 30 | #endif 31 | 32 | #ifdef Z_SOLO 33 | typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */ 34 | #endif 35 | 36 | #ifndef local 37 | # define local static 38 | #endif 39 | /* since "static" is used to mean two completely different things in C, we 40 | define "local" for the non-static meaning of "static", for readability 41 | (compile with -Dlocal if your debugger can't find static symbols) */ 42 | 43 | typedef unsigned char uch; 44 | typedef uch FAR uchf; 45 | typedef unsigned short ush; 46 | typedef ush FAR ushf; 47 | typedef unsigned long ulg; 48 | 49 | extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ 50 | /* (size given to avoid silly warnings with Visual C++) */ 51 | 52 | #define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] 53 | 54 | #define ERR_RETURN(strm,err) \ 55 | return (strm->msg = ERR_MSG(err), (err)) 56 | /* To be used only when the state is known to be valid */ 57 | 58 | /* common constants */ 59 | 60 | #ifndef DEF_WBITS 61 | # define DEF_WBITS MAX_WBITS 62 | #endif 63 | /* default windowBits for decompression. MAX_WBITS is for compression only */ 64 | 65 | #if MAX_MEM_LEVEL >= 8 66 | # define DEF_MEM_LEVEL 8 67 | #else 68 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL 69 | #endif 70 | /* default memLevel */ 71 | 72 | #define STORED_BLOCK 0 73 | #define STATIC_TREES 1 74 | #define DYN_TREES 2 75 | /* The three kinds of block type */ 76 | 77 | #define MIN_MATCH 3 78 | #define MAX_MATCH 258 79 | /* The minimum and maximum match lengths */ 80 | 81 | #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ 82 | 83 | /* target dependencies */ 84 | 85 | #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) 86 | # define OS_CODE 0x00 87 | # ifndef Z_SOLO 88 | # if defined(__TURBOC__) || defined(__BORLANDC__) 89 | # if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) 90 | /* Allow compilation with ANSI keywords only enabled */ 91 | void _Cdecl farfree( void *block ); 92 | void *_Cdecl farmalloc( unsigned long nbytes ); 93 | # else 94 | # include 95 | # endif 96 | # else /* MSC or DJGPP */ 97 | # include 98 | # endif 99 | # endif 100 | #endif 101 | 102 | #ifdef AMIGA 103 | # define OS_CODE 1 104 | #endif 105 | 106 | #if defined(VAXC) || defined(VMS) 107 | # define OS_CODE 2 108 | # define F_OPEN(name, mode) \ 109 | fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") 110 | #endif 111 | 112 | #ifdef __370__ 113 | # if __TARGET_LIB__ < 0x20000000 114 | # define OS_CODE 4 115 | # elif __TARGET_LIB__ < 0x40000000 116 | # define OS_CODE 11 117 | # else 118 | # define OS_CODE 8 119 | # endif 120 | #endif 121 | 122 | #if defined(ATARI) || defined(atarist) 123 | # define OS_CODE 5 124 | #endif 125 | 126 | #ifdef OS2 127 | # define OS_CODE 6 128 | # if defined(M_I86) && !defined(Z_SOLO) 129 | # include 130 | # endif 131 | #endif 132 | 133 | #if defined(MACOS) || defined(TARGET_OS_MAC) 134 | # define OS_CODE 7 135 | # ifndef Z_SOLO 136 | # if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os 137 | # include /* for fdopen */ 138 | # else 139 | # ifndef fdopen 140 | # define fdopen(fd,mode) NULL /* No fdopen() */ 141 | # endif 142 | # endif 143 | # endif 144 | #endif 145 | 146 | #ifdef __acorn 147 | # define OS_CODE 13 148 | #endif 149 | 150 | #if defined(WIN32) && !defined(__CYGWIN__) 151 | # define OS_CODE 10 152 | #endif 153 | 154 | #ifdef _BEOS_ 155 | # define OS_CODE 16 156 | #endif 157 | 158 | #ifdef __TOS_OS400__ 159 | # define OS_CODE 18 160 | #endif 161 | 162 | #ifdef __APPLE__ 163 | # define OS_CODE 19 164 | #endif 165 | 166 | #if defined(_BEOS_) || defined(RISCOS) 167 | # define fdopen(fd,mode) NULL /* No fdopen() */ 168 | #endif 169 | 170 | #if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX 171 | # if defined(_WIN32_WCE) 172 | # define fdopen(fd,mode) NULL /* No fdopen() */ 173 | # ifndef _PTRDIFF_T_DEFINED 174 | typedef int ptrdiff_t; 175 | # define _PTRDIFF_T_DEFINED 176 | # endif 177 | # else 178 | # define fdopen(fd,type) _fdopen(fd,type) 179 | # endif 180 | #endif 181 | 182 | #if defined(__BORLANDC__) && !defined(MSDOS) 183 | #pragma warn -8004 184 | #pragma warn -8008 185 | #pragma warn -8066 186 | #endif 187 | 188 | /* provide prototypes for these when building zlib without LFS */ 189 | #if !defined(_WIN32) && \ 190 | (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) 191 | ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); 192 | ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); 193 | #endif 194 | 195 | /* common defaults */ 196 | 197 | #ifndef OS_CODE 198 | # define OS_CODE 3 /* assume Unix */ 199 | #endif 200 | 201 | #ifndef F_OPEN 202 | # define F_OPEN(name, mode) fopen((name), (mode)) 203 | #endif 204 | 205 | /* functions */ 206 | 207 | #if defined(pyr) || defined(Z_SOLO) 208 | # define NO_MEMCPY 209 | #endif 210 | #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) 211 | /* Use our own functions for small and medium model with MSC <= 5.0. 212 | * You may have to use the same strategy for Borland C (untested). 213 | * The __SC__ check is for Symantec. 214 | */ 215 | # define NO_MEMCPY 216 | #endif 217 | #if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) 218 | # define HAVE_MEMCPY 219 | #endif 220 | #ifdef HAVE_MEMCPY 221 | # ifdef SMALL_MEDIUM /* MSDOS small or medium model */ 222 | # define zmemcpy _fmemcpy 223 | # define zmemcmp _fmemcmp 224 | # define zmemzero(dest, len) _fmemset(dest, 0, len) 225 | # else 226 | # define zmemcpy memcpy 227 | # define zmemcmp memcmp 228 | # define zmemzero(dest, len) memset(dest, 0, len) 229 | # endif 230 | #else 231 | void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); 232 | int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); 233 | void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); 234 | #endif 235 | 236 | /* Diagnostic functions */ 237 | #ifdef ZLIB_DEBUG 238 | # include 239 | extern int ZLIB_INTERNAL z_verbose; 240 | extern void ZLIB_INTERNAL z_error OF((char *m)); 241 | # define Assert(cond,msg) {if(!(cond)) z_error(msg);} 242 | # define Trace(x) {if (z_verbose>=0) fprintf x ;} 243 | # define Tracev(x) {if (z_verbose>0) fprintf x ;} 244 | # define Tracevv(x) {if (z_verbose>1) fprintf x ;} 245 | # define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} 246 | # define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} 247 | #else 248 | # define Assert(cond,msg) 249 | # define Trace(x) 250 | # define Tracev(x) 251 | # define Tracevv(x) 252 | # define Tracec(c,x) 253 | # define Tracecv(c,x) 254 | #endif 255 | 256 | #ifndef Z_SOLO 257 | voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, 258 | unsigned size)); 259 | void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); 260 | #endif 261 | 262 | #define ZALLOC(strm, items, size) \ 263 | (*((strm)->zalloc))((strm)->opaque, (items), (size)) 264 | #define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) 265 | #define TRY_FREE(s, p) {if (p) ZFREE(s, p);} 266 | 267 | /* Reverse the bytes in a 32-bit value */ 268 | #define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ 269 | (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) 270 | 271 | #endif /* ZUTIL_H */ 272 | -------------------------------------------------------------------------------- /zlib1.2.11/trees.h: -------------------------------------------------------------------------------- 1 | /* header created automatically with -DGEN_TREES_H */ 2 | 3 | local const ct_data static_ltree[L_CODES+2] = { 4 | {{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, 5 | {{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, 6 | {{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, 7 | {{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, 8 | {{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, 9 | {{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, 10 | {{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, 11 | {{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, 12 | {{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, 13 | {{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, 14 | {{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, 15 | {{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, 16 | {{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, 17 | {{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, 18 | {{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, 19 | {{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, 20 | {{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, 21 | {{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, 22 | {{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, 23 | {{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, 24 | {{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, 25 | {{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, 26 | {{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, 27 | {{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, 28 | {{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, 29 | {{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, 30 | {{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, 31 | {{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, 32 | {{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, 33 | {{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, 34 | {{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, 35 | {{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, 36 | {{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, 37 | {{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, 38 | {{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, 39 | {{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, 40 | {{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, 41 | {{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, 42 | {{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, 43 | {{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, 44 | {{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, 45 | {{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, 46 | {{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, 47 | {{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, 48 | {{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, 49 | {{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, 50 | {{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, 51 | {{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, 52 | {{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, 53 | {{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, 54 | {{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, 55 | {{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, 56 | {{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, 57 | {{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, 58 | {{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, 59 | {{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, 60 | {{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, 61 | {{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} 62 | }; 63 | 64 | local const ct_data static_dtree[D_CODES] = { 65 | {{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, 66 | {{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, 67 | {{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, 68 | {{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, 69 | {{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, 70 | {{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} 71 | }; 72 | 73 | const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { 74 | 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 75 | 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 76 | 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 77 | 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 78 | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 79 | 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 80 | 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 81 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 82 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 83 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 84 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 85 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 86 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, 87 | 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 88 | 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 89 | 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 90 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 91 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 92 | 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 93 | 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 94 | 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 95 | 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 96 | 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 97 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 98 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 99 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 100 | }; 101 | 102 | const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { 103 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, 104 | 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 105 | 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 106 | 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 107 | 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 108 | 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 109 | 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 110 | 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 111 | 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 112 | 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 113 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 114 | 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 115 | 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 116 | }; 117 | 118 | local const int base_length[LENGTH_CODES] = { 119 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 120 | 64, 80, 96, 112, 128, 160, 192, 224, 0 121 | }; 122 | 123 | local const int base_dist[D_CODES] = { 124 | 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 125 | 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 126 | 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 127 | }; 128 | 129 | -------------------------------------------------------------------------------- /zlib1.2.11/zutil.c: -------------------------------------------------------------------------------- 1 | /* zutil.c -- target dependent utility functions for the compression library 2 | * Copyright (C) 1995-2017 Jean-loup Gailly 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #include "zutil.h" 9 | #ifndef Z_SOLO 10 | # include "gzguts.h" 11 | #endif 12 | 13 | z_const char * const z_errmsg[10] = { 14 | (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */ 15 | (z_const char *)"stream end", /* Z_STREAM_END 1 */ 16 | (z_const char *)"", /* Z_OK 0 */ 17 | (z_const char *)"file error", /* Z_ERRNO (-1) */ 18 | (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */ 19 | (z_const char *)"data error", /* Z_DATA_ERROR (-3) */ 20 | (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */ 21 | (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */ 22 | (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */ 23 | (z_const char *)"" 24 | }; 25 | 26 | 27 | const char * ZEXPORT zlibVersion() 28 | { 29 | return ZLIB_VERSION; 30 | } 31 | 32 | uLong ZEXPORT zlibCompileFlags() 33 | { 34 | uLong flags; 35 | 36 | flags = 0; 37 | switch ((int)(sizeof(uInt))) { 38 | case 2: break; 39 | case 4: flags += 1; break; 40 | case 8: flags += 2; break; 41 | default: flags += 3; 42 | } 43 | switch ((int)(sizeof(uLong))) { 44 | case 2: break; 45 | case 4: flags += 1 << 2; break; 46 | case 8: flags += 2 << 2; break; 47 | default: flags += 3 << 2; 48 | } 49 | switch ((int)(sizeof(voidpf))) { 50 | case 2: break; 51 | case 4: flags += 1 << 4; break; 52 | case 8: flags += 2 << 4; break; 53 | default: flags += 3 << 4; 54 | } 55 | switch ((int)(sizeof(z_off_t))) { 56 | case 2: break; 57 | case 4: flags += 1 << 6; break; 58 | case 8: flags += 2 << 6; break; 59 | default: flags += 3 << 6; 60 | } 61 | #ifdef ZLIB_DEBUG 62 | flags += 1 << 8; 63 | #endif 64 | #if defined(ASMV) || defined(ASMINF) 65 | flags += 1 << 9; 66 | #endif 67 | #ifdef ZLIB_WINAPI 68 | flags += 1 << 10; 69 | #endif 70 | #ifdef BUILDFIXED 71 | flags += 1 << 12; 72 | #endif 73 | #ifdef DYNAMIC_CRC_TABLE 74 | flags += 1 << 13; 75 | #endif 76 | #ifdef NO_GZCOMPRESS 77 | flags += 1L << 16; 78 | #endif 79 | #ifdef NO_GZIP 80 | flags += 1L << 17; 81 | #endif 82 | #ifdef PKZIP_BUG_WORKAROUND 83 | flags += 1L << 20; 84 | #endif 85 | #ifdef FASTEST 86 | flags += 1L << 21; 87 | #endif 88 | #if defined(STDC) || defined(Z_HAVE_STDARG_H) 89 | # ifdef NO_vsnprintf 90 | flags += 1L << 25; 91 | # ifdef HAS_vsprintf_void 92 | flags += 1L << 26; 93 | # endif 94 | # else 95 | # ifdef HAS_vsnprintf_void 96 | flags += 1L << 26; 97 | # endif 98 | # endif 99 | #else 100 | flags += 1L << 24; 101 | # ifdef NO_snprintf 102 | flags += 1L << 25; 103 | # ifdef HAS_sprintf_void 104 | flags += 1L << 26; 105 | # endif 106 | # else 107 | # ifdef HAS_snprintf_void 108 | flags += 1L << 26; 109 | # endif 110 | # endif 111 | #endif 112 | return flags; 113 | } 114 | 115 | #ifdef ZLIB_DEBUG 116 | #include 117 | # ifndef verbose 118 | # define verbose 0 119 | # endif 120 | int ZLIB_INTERNAL z_verbose = verbose; 121 | 122 | void ZLIB_INTERNAL z_error (m) 123 | char *m; 124 | { 125 | fprintf(stderr, "%s\n", m); 126 | exit(1); 127 | } 128 | #endif 129 | 130 | /* exported to allow conversion of error code to string for compress() and 131 | * uncompress() 132 | */ 133 | const char * ZEXPORT zError(err) 134 | int err; 135 | { 136 | return ERR_MSG(err); 137 | } 138 | 139 | #if defined(_WIN32_WCE) 140 | /* The Microsoft C Run-Time Library for Windows CE doesn't have 141 | * errno. We define it as a global variable to simplify porting. 142 | * Its value is always 0 and should not be used. 143 | */ 144 | int errno = 0; 145 | #endif 146 | 147 | #ifndef HAVE_MEMCPY 148 | 149 | void ZLIB_INTERNAL zmemcpy(dest, source, len) 150 | Bytef* dest; 151 | const Bytef* source; 152 | uInt len; 153 | { 154 | if (len == 0) return; 155 | do { 156 | *dest++ = *source++; /* ??? to be unrolled */ 157 | } while (--len != 0); 158 | } 159 | 160 | int ZLIB_INTERNAL zmemcmp(s1, s2, len) 161 | const Bytef* s1; 162 | const Bytef* s2; 163 | uInt len; 164 | { 165 | uInt j; 166 | 167 | for (j = 0; j < len; j++) { 168 | if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; 169 | } 170 | return 0; 171 | } 172 | 173 | void ZLIB_INTERNAL zmemzero(dest, len) 174 | Bytef* dest; 175 | uInt len; 176 | { 177 | if (len == 0) return; 178 | do { 179 | *dest++ = 0; /* ??? to be unrolled */ 180 | } while (--len != 0); 181 | } 182 | #endif 183 | 184 | #ifndef Z_SOLO 185 | 186 | #ifdef SYS16BIT 187 | 188 | #ifdef __TURBOC__ 189 | /* Turbo C in 16-bit mode */ 190 | 191 | # define MY_ZCALLOC 192 | 193 | /* Turbo C malloc() does not allow dynamic allocation of 64K bytes 194 | * and farmalloc(64K) returns a pointer with an offset of 8, so we 195 | * must fix the pointer. Warning: the pointer must be put back to its 196 | * original form in order to free it, use zcfree(). 197 | */ 198 | 199 | #define MAX_PTR 10 200 | /* 10*64K = 640K */ 201 | 202 | local int next_ptr = 0; 203 | 204 | typedef struct ptr_table_s { 205 | voidpf org_ptr; 206 | voidpf new_ptr; 207 | } ptr_table; 208 | 209 | local ptr_table table[MAX_PTR]; 210 | /* This table is used to remember the original form of pointers 211 | * to large buffers (64K). Such pointers are normalized with a zero offset. 212 | * Since MSDOS is not a preemptive multitasking OS, this table is not 213 | * protected from concurrent access. This hack doesn't work anyway on 214 | * a protected system like OS/2. Use Microsoft C instead. 215 | */ 216 | 217 | voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) 218 | { 219 | voidpf buf; 220 | ulg bsize = (ulg)items*size; 221 | 222 | (void)opaque; 223 | 224 | /* If we allocate less than 65520 bytes, we assume that farmalloc 225 | * will return a usable pointer which doesn't have to be normalized. 226 | */ 227 | if (bsize < 65520L) { 228 | buf = farmalloc(bsize); 229 | if (*(ush*)&buf != 0) return buf; 230 | } else { 231 | buf = farmalloc(bsize + 16L); 232 | } 233 | if (buf == NULL || next_ptr >= MAX_PTR) return NULL; 234 | table[next_ptr].org_ptr = buf; 235 | 236 | /* Normalize the pointer to seg:0 */ 237 | *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; 238 | *(ush*)&buf = 0; 239 | table[next_ptr++].new_ptr = buf; 240 | return buf; 241 | } 242 | 243 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) 244 | { 245 | int n; 246 | 247 | (void)opaque; 248 | 249 | if (*(ush*)&ptr != 0) { /* object < 64K */ 250 | farfree(ptr); 251 | return; 252 | } 253 | /* Find the original pointer */ 254 | for (n = 0; n < next_ptr; n++) { 255 | if (ptr != table[n].new_ptr) continue; 256 | 257 | farfree(table[n].org_ptr); 258 | while (++n < next_ptr) { 259 | table[n-1] = table[n]; 260 | } 261 | next_ptr--; 262 | return; 263 | } 264 | Assert(0, "zcfree: ptr not found"); 265 | } 266 | 267 | #endif /* __TURBOC__ */ 268 | 269 | 270 | #ifdef M_I86 271 | /* Microsoft C in 16-bit mode */ 272 | 273 | # define MY_ZCALLOC 274 | 275 | #if (!defined(_MSC_VER) || (_MSC_VER <= 600)) 276 | # define _halloc halloc 277 | # define _hfree hfree 278 | #endif 279 | 280 | voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) 281 | { 282 | (void)opaque; 283 | return _halloc((long)items, size); 284 | } 285 | 286 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) 287 | { 288 | (void)opaque; 289 | _hfree(ptr); 290 | } 291 | 292 | #endif /* M_I86 */ 293 | 294 | #endif /* SYS16BIT */ 295 | 296 | 297 | #ifndef MY_ZCALLOC /* Any system without a special alloc function */ 298 | 299 | #ifndef STDC 300 | extern voidp malloc OF((uInt size)); 301 | extern voidp calloc OF((uInt items, uInt size)); 302 | extern void free OF((voidpf ptr)); 303 | #endif 304 | 305 | voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) 306 | voidpf opaque; 307 | unsigned items; 308 | unsigned size; 309 | { 310 | (void)opaque; 311 | return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : 312 | (voidpf)calloc(items, size); 313 | } 314 | 315 | void ZLIB_INTERNAL zcfree (opaque, ptr) 316 | voidpf opaque; 317 | voidpf ptr; 318 | { 319 | (void)opaque; 320 | free(ptr); 321 | } 322 | 323 | #endif /* MY_ZCALLOC */ 324 | 325 | #endif /* !Z_SOLO */ 326 | -------------------------------------------------------------------------------- /WebSocketServer.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 6 | h;hh;hpp;hxx;hm;inl;inc;ipp;xsd 7 | 8 | 9 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 10 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 11 | 12 | 13 | {6e63e9cf-c248-4b6a-b868-beec0e100de5} 14 | 15 | 16 | {018c4d1d-000d-49f1-8a77-3a74777b9829} 17 | 18 | 19 | {8761e956-1a59-483f-983e-2536228d70fd} 20 | 21 | 22 | {9bd6f171-2927-4859-84f6-5cabeb9e46f1} 23 | 24 | 25 | {50d03c8f-0a49-4aa8-8dea-e2c3dca3259a} 26 | 27 | 28 | 29 | 30 | appsrc 31 | 32 | 33 | appsrc 34 | 35 | 36 | base 37 | 38 | 39 | base 40 | 41 | 42 | base 43 | 44 | 45 | base 46 | 47 | 48 | net 49 | 50 | 51 | net 52 | 53 | 54 | net 55 | 56 | 57 | net 58 | 59 | 60 | net 61 | 62 | 63 | net 64 | 65 | 66 | net 67 | 68 | 69 | net 70 | 71 | 72 | net 73 | 74 | 75 | net 76 | 77 | 78 | net 79 | 80 | 81 | net 82 | 83 | 84 | net 85 | 86 | 87 | net 88 | 89 | 90 | net 91 | 92 | 93 | net 94 | 95 | 96 | net 97 | 98 | 99 | net 100 | 101 | 102 | net 103 | 104 | 105 | utils 106 | 107 | 108 | utils 109 | 110 | 111 | websocketsrc 112 | 113 | 114 | websocketsrc 115 | 116 | 117 | zlib1.2.11 118 | 119 | 120 | zlib1.2.11 121 | 122 | 123 | zlib1.2.11 124 | 125 | 126 | zlib1.2.11 127 | 128 | 129 | zlib1.2.11 130 | 131 | 132 | zlib1.2.11 133 | 134 | 135 | zlib1.2.11 136 | 137 | 138 | zlib1.2.11 139 | 140 | 141 | zlib1.2.11 142 | 143 | 144 | zlib1.2.11 145 | 146 | 147 | zlib1.2.11 148 | 149 | 150 | zlib1.2.11 151 | 152 | 153 | zlib1.2.11 154 | 155 | 156 | zlib1.2.11 157 | 158 | 159 | zlib1.2.11 160 | 161 | 162 | zlib1.2.11 163 | 164 | 165 | zlib1.2.11 166 | 167 | 168 | 169 | 170 | appsrc 171 | 172 | 173 | base 174 | 175 | 176 | base 177 | 178 | 179 | base 180 | 181 | 182 | base 183 | 184 | 185 | base 186 | 187 | 188 | base 189 | 190 | 191 | net 192 | 193 | 194 | net 195 | 196 | 197 | net 198 | 199 | 200 | net 201 | 202 | 203 | net 204 | 205 | 206 | net 207 | 208 | 209 | net 210 | 211 | 212 | net 213 | 214 | 215 | net 216 | 217 | 218 | net 219 | 220 | 221 | net 222 | 223 | 224 | net 225 | 226 | 227 | net 228 | 229 | 230 | net 231 | 232 | 233 | net 234 | 235 | 236 | net 237 | 238 | 239 | net 240 | 241 | 242 | net 243 | 244 | 245 | net 246 | 247 | 248 | net 249 | 250 | 251 | net 252 | 253 | 254 | net 255 | 256 | 257 | utils 258 | 259 | 260 | utils 261 | 262 | 263 | websocketsrc 264 | 265 | 266 | websocketsrc 267 | 268 | 269 | websocketsrc 270 | 271 | 272 | zlib1.2.11 273 | 274 | 275 | zlib1.2.11 276 | 277 | 278 | zlib1.2.11 279 | 280 | 281 | zlib1.2.11 282 | 283 | 284 | zlib1.2.11 285 | 286 | 287 | zlib1.2.11 288 | 289 | 290 | zlib1.2.11 291 | 292 | 293 | zlib1.2.11 294 | 295 | 296 | zlib1.2.11 297 | 298 | 299 | zlib1.2.11 300 | 301 | 302 | zlib1.2.11 303 | 304 | 305 | zlib1.2.11 306 | 307 | 308 | 309 | 310 | zlib1.2.11 311 | 312 | 313 | -------------------------------------------------------------------------------- /WebSocketServer.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 16.0 23 | {1CA1FE98-1553-4B6C-9507-0B13A85B0C68} 24 | Win32Proj 25 | WebSocketServer 26 | 10.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v142 33 | Unicode 34 | 35 | 36 | Application 37 | false 38 | v142 39 | true 40 | Unicode 41 | 42 | 43 | Application 44 | true 45 | v142 46 | Unicode 47 | 48 | 49 | Application 50 | false 51 | v142 52 | true 53 | Unicode 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | true 75 | ./ 76 | 77 | 78 | true 79 | 80 | 81 | false 82 | 83 | 84 | false 85 | 86 | 87 | 88 | 89 | 90 | Level3 91 | Disabled 92 | true 93 | WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 94 | true 95 | 96 | 97 | Console 98 | true 99 | ./$(TargetName)$(TargetExt) 100 | 101 | 102 | 103 | 104 | 105 | 106 | Level3 107 | Disabled 108 | true 109 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 110 | true 111 | 112 | 113 | Console 114 | true 115 | 116 | 117 | 118 | 119 | 120 | 121 | Level3 122 | MaxSpeed 123 | true 124 | true 125 | true 126 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 127 | true 128 | 129 | 130 | Console 131 | true 132 | true 133 | true 134 | 135 | 136 | 137 | 138 | 139 | 140 | Level3 141 | MaxSpeed 142 | true 143 | true 144 | true 145 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 146 | true 147 | 148 | 149 | Console 150 | true 151 | true 152 | true 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | -------------------------------------------------------------------------------- /zlib1.2.11/inftrees.c: -------------------------------------------------------------------------------- 1 | /* inftrees.c -- generate Huffman trees for efficient decoding 2 | * Copyright (C) 1995-2017 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "zutil.h" 7 | #include "inftrees.h" 8 | 9 | #define MAXBITS 15 10 | 11 | const char inflate_copyright[] = 12 | " inflate 1.2.11 Copyright 1995-2017 Mark Adler "; 13 | /* 14 | If you use the zlib library in a product, an acknowledgment is welcome 15 | in the documentation of your product. If for some reason you cannot 16 | include such an acknowledgment, I would appreciate that you keep this 17 | copyright string in the executable of your product. 18 | */ 19 | 20 | /* 21 | Build a set of tables to decode the provided canonical Huffman code. 22 | The code lengths are lens[0..codes-1]. The result starts at *table, 23 | whose indices are 0..2^bits-1. work is a writable array of at least 24 | lens shorts, which is used as a work area. type is the type of code 25 | to be generated, CODES, LENS, or DISTS. On return, zero is success, 26 | -1 is an invalid code, and +1 means that ENOUGH isn't enough. table 27 | on return points to the next available entry's address. bits is the 28 | requested root table index bits, and on return it is the actual root 29 | table index bits. It will differ if the request is greater than the 30 | longest code or if it is less than the shortest code. 31 | */ 32 | int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) 33 | codetype type; 34 | unsigned short FAR *lens; 35 | unsigned codes; 36 | code FAR * FAR *table; 37 | unsigned FAR *bits; 38 | unsigned short FAR *work; 39 | { 40 | unsigned len; /* a code's length in bits */ 41 | unsigned sym; /* index of code symbols */ 42 | unsigned min, max; /* minimum and maximum code lengths */ 43 | unsigned root; /* number of index bits for root table */ 44 | unsigned curr; /* number of index bits for current table */ 45 | unsigned drop; /* code bits to drop for sub-table */ 46 | int left; /* number of prefix codes available */ 47 | unsigned used; /* code entries in table used */ 48 | unsigned huff; /* Huffman code */ 49 | unsigned incr; /* for incrementing code, index */ 50 | unsigned fill; /* index for replicating entries */ 51 | unsigned low; /* low bits for current root entry */ 52 | unsigned mask; /* mask for low root bits */ 53 | code here; /* table entry for duplication */ 54 | code FAR *next; /* next available space in table */ 55 | const unsigned short FAR *base; /* base value table to use */ 56 | const unsigned short FAR *extra; /* extra bits table to use */ 57 | unsigned match; /* use base and extra for symbol >= match */ 58 | unsigned short count[MAXBITS+1]; /* number of codes of each length */ 59 | unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ 60 | static const unsigned short lbase[31] = { /* Length codes 257..285 base */ 61 | 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 62 | 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; 63 | static const unsigned short lext[31] = { /* Length codes 257..285 extra */ 64 | 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 65 | 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202}; 66 | static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ 67 | 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 68 | 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 69 | 8193, 12289, 16385, 24577, 0, 0}; 70 | static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ 71 | 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 72 | 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 73 | 28, 28, 29, 29, 64, 64}; 74 | 75 | /* 76 | Process a set of code lengths to create a canonical Huffman code. The 77 | code lengths are lens[0..codes-1]. Each length corresponds to the 78 | symbols 0..codes-1. The Huffman code is generated by first sorting the 79 | symbols by length from short to long, and retaining the symbol order 80 | for codes with equal lengths. Then the code starts with all zero bits 81 | for the first code of the shortest length, and the codes are integer 82 | increments for the same length, and zeros are appended as the length 83 | increases. For the deflate format, these bits are stored backwards 84 | from their more natural integer increment ordering, and so when the 85 | decoding tables are built in the large loop below, the integer codes 86 | are incremented backwards. 87 | 88 | This routine assumes, but does not check, that all of the entries in 89 | lens[] are in the range 0..MAXBITS. The caller must assure this. 90 | 1..MAXBITS is interpreted as that code length. zero means that that 91 | symbol does not occur in this code. 92 | 93 | The codes are sorted by computing a count of codes for each length, 94 | creating from that a table of starting indices for each length in the 95 | sorted table, and then entering the symbols in order in the sorted 96 | table. The sorted table is work[], with that space being provided by 97 | the caller. 98 | 99 | The length counts are used for other purposes as well, i.e. finding 100 | the minimum and maximum length codes, determining if there are any 101 | codes at all, checking for a valid set of lengths, and looking ahead 102 | at length counts to determine sub-table sizes when building the 103 | decoding tables. 104 | */ 105 | 106 | /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ 107 | for (len = 0; len <= MAXBITS; len++) 108 | count[len] = 0; 109 | for (sym = 0; sym < codes; sym++) 110 | count[lens[sym]]++; 111 | 112 | /* bound code lengths, force root to be within code lengths */ 113 | root = *bits; 114 | for (max = MAXBITS; max >= 1; max--) 115 | if (count[max] != 0) break; 116 | if (root > max) root = max; 117 | if (max == 0) { /* no symbols to code at all */ 118 | here.op = (unsigned char)64; /* invalid code marker */ 119 | here.bits = (unsigned char)1; 120 | here.val = (unsigned short)0; 121 | *(*table)++ = here; /* make a table to force an error */ 122 | *(*table)++ = here; 123 | *bits = 1; 124 | return 0; /* no symbols, but wait for decoding to report error */ 125 | } 126 | for (min = 1; min < max; min++) 127 | if (count[min] != 0) break; 128 | if (root < min) root = min; 129 | 130 | /* check for an over-subscribed or incomplete set of lengths */ 131 | left = 1; 132 | for (len = 1; len <= MAXBITS; len++) { 133 | left <<= 1; 134 | left -= count[len]; 135 | if (left < 0) return -1; /* over-subscribed */ 136 | } 137 | if (left > 0 && (type == CODES || max != 1)) 138 | return -1; /* incomplete set */ 139 | 140 | /* generate offsets into symbol table for each length for sorting */ 141 | offs[1] = 0; 142 | for (len = 1; len < MAXBITS; len++) 143 | offs[len + 1] = offs[len] + count[len]; 144 | 145 | /* sort symbols by length, by symbol order within each length */ 146 | for (sym = 0; sym < codes; sym++) 147 | if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; 148 | 149 | /* 150 | Create and fill in decoding tables. In this loop, the table being 151 | filled is at next and has curr index bits. The code being used is huff 152 | with length len. That code is converted to an index by dropping drop 153 | bits off of the bottom. For codes where len is less than drop + curr, 154 | those top drop + curr - len bits are incremented through all values to 155 | fill the table with replicated entries. 156 | 157 | root is the number of index bits for the root table. When len exceeds 158 | root, sub-tables are created pointed to by the root entry with an index 159 | of the low root bits of huff. This is saved in low to check for when a 160 | new sub-table should be started. drop is zero when the root table is 161 | being filled, and drop is root when sub-tables are being filled. 162 | 163 | When a new sub-table is needed, it is necessary to look ahead in the 164 | code lengths to determine what size sub-table is needed. The length 165 | counts are used for this, and so count[] is decremented as codes are 166 | entered in the tables. 167 | 168 | used keeps track of how many table entries have been allocated from the 169 | provided *table space. It is checked for LENS and DIST tables against 170 | the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in 171 | the initial root table size constants. See the comments in inftrees.h 172 | for more information. 173 | 174 | sym increments through all symbols, and the loop terminates when 175 | all codes of length max, i.e. all codes, have been processed. This 176 | routine permits incomplete codes, so another loop after this one fills 177 | in the rest of the decoding tables with invalid code markers. 178 | */ 179 | 180 | /* set up for code type */ 181 | switch (type) { 182 | case CODES: 183 | base = extra = work; /* dummy value--not used */ 184 | match = 20; 185 | break; 186 | case LENS: 187 | base = lbase; 188 | extra = lext; 189 | match = 257; 190 | break; 191 | default: /* DISTS */ 192 | base = dbase; 193 | extra = dext; 194 | match = 0; 195 | } 196 | 197 | /* initialize state for loop */ 198 | huff = 0; /* starting code */ 199 | sym = 0; /* starting code symbol */ 200 | len = min; /* starting code length */ 201 | next = *table; /* current table to fill in */ 202 | curr = root; /* current table index bits */ 203 | drop = 0; /* current bits to drop from code for index */ 204 | low = (unsigned)(-1); /* trigger new sub-table when len > root */ 205 | used = 1U << root; /* use root table entries */ 206 | mask = used - 1; /* mask for comparing low */ 207 | 208 | /* check available table space */ 209 | if ((type == LENS && used > ENOUGH_LENS) || 210 | (type == DISTS && used > ENOUGH_DISTS)) 211 | return 1; 212 | 213 | /* process all codes and make table entries */ 214 | for (;;) { 215 | /* create table entry */ 216 | here.bits = (unsigned char)(len - drop); 217 | if (work[sym] + 1U < match) { 218 | here.op = (unsigned char)0; 219 | here.val = work[sym]; 220 | } 221 | else if (work[sym] >= match) { 222 | here.op = (unsigned char)(extra[work[sym] - match]); 223 | here.val = base[work[sym] - match]; 224 | } 225 | else { 226 | here.op = (unsigned char)(32 + 64); /* end of block */ 227 | here.val = 0; 228 | } 229 | 230 | /* replicate for those indices with low len bits equal to huff */ 231 | incr = 1U << (len - drop); 232 | fill = 1U << curr; 233 | min = fill; /* save offset to next table */ 234 | do { 235 | fill -= incr; 236 | next[(huff >> drop) + fill] = here; 237 | } while (fill != 0); 238 | 239 | /* backwards increment the len-bit code huff */ 240 | incr = 1U << (len - 1); 241 | while (huff & incr) 242 | incr >>= 1; 243 | if (incr != 0) { 244 | huff &= incr - 1; 245 | huff += incr; 246 | } 247 | else 248 | huff = 0; 249 | 250 | /* go to next symbol, update count, len */ 251 | sym++; 252 | if (--(count[len]) == 0) { 253 | if (len == max) break; 254 | len = lens[work[sym]]; 255 | } 256 | 257 | /* create new sub-table if needed */ 258 | if (len > root && (huff & mask) != low) { 259 | /* if first time, transition to sub-tables */ 260 | if (drop == 0) 261 | drop = root; 262 | 263 | /* increment past last table */ 264 | next += min; /* here min is 1 << curr */ 265 | 266 | /* determine length of next table */ 267 | curr = len - drop; 268 | left = (int)(1 << curr); 269 | while (curr + drop < max) { 270 | left -= count[curr + drop]; 271 | if (left <= 0) break; 272 | curr++; 273 | left <<= 1; 274 | } 275 | 276 | /* check for enough space */ 277 | used += 1U << curr; 278 | if ((type == LENS && used > ENOUGH_LENS) || 279 | (type == DISTS && used > ENOUGH_DISTS)) 280 | return 1; 281 | 282 | /* point entry in root table to sub-table */ 283 | low = huff & mask; 284 | (*table)[low].op = (unsigned char)curr; 285 | (*table)[low].bits = (unsigned char)root; 286 | (*table)[low].val = (unsigned short)(next - *table); 287 | } 288 | } 289 | 290 | /* fill in remaining table entry if code is incomplete (guaranteed to have 291 | at most one remaining entry, since if the code is incomplete, the 292 | maximum code length that was allowed to get this far is one bit) */ 293 | if (huff != 0) { 294 | here.op = (unsigned char)64; /* invalid code marker */ 295 | here.bits = (unsigned char)(len - drop); 296 | here.val = (unsigned short)0; 297 | next[huff] = here; 298 | } 299 | 300 | /* set return parameters */ 301 | *table += used; 302 | *bits = root; 303 | return 0; 304 | } 305 | -------------------------------------------------------------------------------- /zlib1.2.11/inffast.c: -------------------------------------------------------------------------------- 1 | /* inffast.c -- fast decoding 2 | * Copyright (C) 1995-2017 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "zutil.h" 7 | #include "inftrees.h" 8 | #include "inflate.h" 9 | #include "inffast.h" 10 | 11 | #ifdef ASMINF 12 | # pragma message("Assembler code may have bugs -- use at your own risk") 13 | #else 14 | 15 | /* 16 | Decode literal, length, and distance codes and write out the resulting 17 | literal and match bytes until either not enough input or output is 18 | available, an end-of-block is encountered, or a data error is encountered. 19 | When large enough input and output buffers are supplied to inflate(), for 20 | example, a 16K input buffer and a 64K output buffer, more than 95% of the 21 | inflate execution time is spent in this routine. 22 | 23 | Entry assumptions: 24 | 25 | state->mode == LEN 26 | strm->avail_in >= 6 27 | strm->avail_out >= 258 28 | start >= strm->avail_out 29 | state->bits < 8 30 | 31 | On return, state->mode is one of: 32 | 33 | LEN -- ran out of enough output space or enough available input 34 | TYPE -- reached end of block code, inflate() to interpret next block 35 | BAD -- error in block data 36 | 37 | Notes: 38 | 39 | - The maximum input bits used by a length/distance pair is 15 bits for the 40 | length code, 5 bits for the length extra, 15 bits for the distance code, 41 | and 13 bits for the distance extra. This totals 48 bits, or six bytes. 42 | Therefore if strm->avail_in >= 6, then there is enough input to avoid 43 | checking for available input while decoding. 44 | 45 | - The maximum bytes that a single length/distance pair can output is 258 46 | bytes, which is the maximum length that can be coded. inflate_fast() 47 | requires strm->avail_out >= 258 for each loop to avoid checking for 48 | output space. 49 | */ 50 | void ZLIB_INTERNAL inflate_fast(strm, start) 51 | z_streamp strm; 52 | unsigned start; /* inflate()'s starting value for strm->avail_out */ 53 | { 54 | struct inflate_state FAR *state; 55 | z_const unsigned char FAR *in; /* local strm->next_in */ 56 | z_const unsigned char FAR *last; /* have enough input while in < last */ 57 | unsigned char FAR *out; /* local strm->next_out */ 58 | unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ 59 | unsigned char FAR *end; /* while out < end, enough space available */ 60 | #ifdef INFLATE_STRICT 61 | unsigned dmax; /* maximum distance from zlib header */ 62 | #endif 63 | unsigned wsize; /* window size or zero if not using window */ 64 | unsigned whave; /* valid bytes in the window */ 65 | unsigned wnext; /* window write index */ 66 | unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ 67 | unsigned long hold; /* local strm->hold */ 68 | unsigned bits; /* local strm->bits */ 69 | code const FAR *lcode; /* local strm->lencode */ 70 | code const FAR *dcode; /* local strm->distcode */ 71 | unsigned lmask; /* mask for first level of length codes */ 72 | unsigned dmask; /* mask for first level of distance codes */ 73 | code here; /* retrieved table entry */ 74 | unsigned op; /* code bits, operation, extra bits, or */ 75 | /* window position, window bytes to copy */ 76 | unsigned len; /* match length, unused bytes */ 77 | unsigned dist; /* match distance */ 78 | unsigned char FAR *from; /* where to copy match from */ 79 | 80 | /* copy state to local variables */ 81 | state = (struct inflate_state FAR *)strm->state; 82 | in = strm->next_in; 83 | last = in + (strm->avail_in - 5); 84 | out = strm->next_out; 85 | beg = out - (start - strm->avail_out); 86 | end = out + (strm->avail_out - 257); 87 | #ifdef INFLATE_STRICT 88 | dmax = state->dmax; 89 | #endif 90 | wsize = state->wsize; 91 | whave = state->whave; 92 | wnext = state->wnext; 93 | window = state->window; 94 | hold = state->hold; 95 | bits = state->bits; 96 | lcode = state->lencode; 97 | dcode = state->distcode; 98 | lmask = (1U << state->lenbits) - 1; 99 | dmask = (1U << state->distbits) - 1; 100 | 101 | /* decode literals and length/distances until end-of-block or not enough 102 | input data or output space */ 103 | do { 104 | if (bits < 15) { 105 | hold += (unsigned long)(*in++) << bits; 106 | bits += 8; 107 | hold += (unsigned long)(*in++) << bits; 108 | bits += 8; 109 | } 110 | here = lcode[hold & lmask]; 111 | dolen: 112 | op = (unsigned)(here.bits); 113 | hold >>= op; 114 | bits -= op; 115 | op = (unsigned)(here.op); 116 | if (op == 0) { /* literal */ 117 | Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? 118 | "inflate: literal '%c'\n" : 119 | "inflate: literal 0x%02x\n", here.val)); 120 | *out++ = (unsigned char)(here.val); 121 | } 122 | else if (op & 16) { /* length base */ 123 | len = (unsigned)(here.val); 124 | op &= 15; /* number of extra bits */ 125 | if (op) { 126 | if (bits < op) { 127 | hold += (unsigned long)(*in++) << bits; 128 | bits += 8; 129 | } 130 | len += (unsigned)hold & ((1U << op) - 1); 131 | hold >>= op; 132 | bits -= op; 133 | } 134 | Tracevv((stderr, "inflate: length %u\n", len)); 135 | if (bits < 15) { 136 | hold += (unsigned long)(*in++) << bits; 137 | bits += 8; 138 | hold += (unsigned long)(*in++) << bits; 139 | bits += 8; 140 | } 141 | here = dcode[hold & dmask]; 142 | dodist: 143 | op = (unsigned)(here.bits); 144 | hold >>= op; 145 | bits -= op; 146 | op = (unsigned)(here.op); 147 | if (op & 16) { /* distance base */ 148 | dist = (unsigned)(here.val); 149 | op &= 15; /* number of extra bits */ 150 | if (bits < op) { 151 | hold += (unsigned long)(*in++) << bits; 152 | bits += 8; 153 | if (bits < op) { 154 | hold += (unsigned long)(*in++) << bits; 155 | bits += 8; 156 | } 157 | } 158 | dist += (unsigned)hold & ((1U << op) - 1); 159 | #ifdef INFLATE_STRICT 160 | if (dist > dmax) { 161 | strm->msg = (char *)"invalid distance too far back"; 162 | state->mode = BAD; 163 | break; 164 | } 165 | #endif 166 | hold >>= op; 167 | bits -= op; 168 | Tracevv((stderr, "inflate: distance %u\n", dist)); 169 | op = (unsigned)(out - beg); /* max distance in output */ 170 | if (dist > op) { /* see if copy from window */ 171 | op = dist - op; /* distance back in window */ 172 | if (op > whave) { 173 | if (state->sane) { 174 | strm->msg = 175 | (char *)"invalid distance too far back"; 176 | state->mode = BAD; 177 | break; 178 | } 179 | #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 180 | if (len <= op - whave) { 181 | do { 182 | *out++ = 0; 183 | } while (--len); 184 | continue; 185 | } 186 | len -= op - whave; 187 | do { 188 | *out++ = 0; 189 | } while (--op > whave); 190 | if (op == 0) { 191 | from = out - dist; 192 | do { 193 | *out++ = *from++; 194 | } while (--len); 195 | continue; 196 | } 197 | #endif 198 | } 199 | from = window; 200 | if (wnext == 0) { /* very common case */ 201 | from += wsize - op; 202 | if (op < len) { /* some from window */ 203 | len -= op; 204 | do { 205 | *out++ = *from++; 206 | } while (--op); 207 | from = out - dist; /* rest from output */ 208 | } 209 | } 210 | else if (wnext < op) { /* wrap around window */ 211 | from += wsize + wnext - op; 212 | op -= wnext; 213 | if (op < len) { /* some from end of window */ 214 | len -= op; 215 | do { 216 | *out++ = *from++; 217 | } while (--op); 218 | from = window; 219 | if (wnext < len) { /* some from start of window */ 220 | op = wnext; 221 | len -= op; 222 | do { 223 | *out++ = *from++; 224 | } while (--op); 225 | from = out - dist; /* rest from output */ 226 | } 227 | } 228 | } 229 | else { /* contiguous in window */ 230 | from += wnext - op; 231 | if (op < len) { /* some from window */ 232 | len -= op; 233 | do { 234 | *out++ = *from++; 235 | } while (--op); 236 | from = out - dist; /* rest from output */ 237 | } 238 | } 239 | while (len > 2) { 240 | *out++ = *from++; 241 | *out++ = *from++; 242 | *out++ = *from++; 243 | len -= 3; 244 | } 245 | if (len) { 246 | *out++ = *from++; 247 | if (len > 1) 248 | *out++ = *from++; 249 | } 250 | } 251 | else { 252 | from = out - dist; /* copy direct from output */ 253 | do { /* minimum length is three */ 254 | *out++ = *from++; 255 | *out++ = *from++; 256 | *out++ = *from++; 257 | len -= 3; 258 | } while (len > 2); 259 | if (len) { 260 | *out++ = *from++; 261 | if (len > 1) 262 | *out++ = *from++; 263 | } 264 | } 265 | } 266 | else if ((op & 64) == 0) { /* 2nd level distance code */ 267 | here = dcode[here.val + (hold & ((1U << op) - 1))]; 268 | goto dodist; 269 | } 270 | else { 271 | strm->msg = (char *)"invalid distance code"; 272 | state->mode = BAD; 273 | break; 274 | } 275 | } 276 | else if ((op & 64) == 0) { /* 2nd level length code */ 277 | here = lcode[here.val + (hold & ((1U << op) - 1))]; 278 | goto dolen; 279 | } 280 | else if (op & 32) { /* end-of-block */ 281 | Tracevv((stderr, "inflate: end of block\n")); 282 | state->mode = TYPE; 283 | break; 284 | } 285 | else { 286 | strm->msg = (char *)"invalid literal/length code"; 287 | state->mode = BAD; 288 | break; 289 | } 290 | } while (in < last && out < end); 291 | 292 | /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ 293 | len = bits >> 3; 294 | in -= len; 295 | bits -= len << 3; 296 | hold &= (1U << bits) - 1; 297 | 298 | /* update state and return */ 299 | strm->next_in = in; 300 | strm->next_out = out; 301 | strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); 302 | strm->avail_out = (unsigned)(out < end ? 303 | 257 + (end - out) : 257 - (out - end)); 304 | state->hold = hold; 305 | state->bits = bits; 306 | return; 307 | } 308 | 309 | /* 310 | inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): 311 | - Using bit fields for code structure 312 | - Different op definition to avoid & for extra bits (do & for table bits) 313 | - Three separate decoding do-loops for direct, window, and wnext == 0 314 | - Special case for distance > 1 copies to do overlapped load and store copy 315 | - Explicit branch predictions (based on measured branch probabilities) 316 | - Deferring match copy and interspersed it with decoding subsequent codes 317 | - Swapping literal/length else 318 | - Swapping window/direct else 319 | - Larger unrolled copy loops (three is about right) 320 | - Moving len -= 3 statement into middle of loop 321 | */ 322 | 323 | #endif /* !ASMINF */ 324 | -------------------------------------------------------------------------------- /zlib1.2.11/deflate.h: -------------------------------------------------------------------------------- 1 | /* deflate.h -- internal compression state 2 | * Copyright (C) 1995-2016 Jean-loup Gailly 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* @(#) $Id$ */ 12 | 13 | #ifndef DEFLATE_H 14 | #define DEFLATE_H 15 | 16 | #include "zutil.h" 17 | 18 | /* define NO_GZIP when compiling if you want to disable gzip header and 19 | trailer creation by deflate(). NO_GZIP would be used to avoid linking in 20 | the crc code when it is not needed. For shared libraries, gzip encoding 21 | should be left enabled. */ 22 | #ifndef NO_GZIP 23 | # define GZIP 24 | #endif 25 | 26 | /* =========================================================================== 27 | * Internal compression state. 28 | */ 29 | 30 | #define LENGTH_CODES 29 31 | /* number of length codes, not counting the special END_BLOCK code */ 32 | 33 | #define LITERALS 256 34 | /* number of literal bytes 0..255 */ 35 | 36 | #define L_CODES (LITERALS+1+LENGTH_CODES) 37 | /* number of Literal or Length codes, including the END_BLOCK code */ 38 | 39 | #define D_CODES 30 40 | /* number of distance codes */ 41 | 42 | #define BL_CODES 19 43 | /* number of codes used to transfer the bit lengths */ 44 | 45 | #define HEAP_SIZE (2*L_CODES+1) 46 | /* maximum heap size */ 47 | 48 | #define MAX_BITS 15 49 | /* All codes must not exceed MAX_BITS bits */ 50 | 51 | #define Buf_size 16 52 | /* size of bit buffer in bi_buf */ 53 | 54 | #define INIT_STATE 42 /* zlib header -> BUSY_STATE */ 55 | #ifdef GZIP 56 | # define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */ 57 | #endif 58 | #define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */ 59 | #define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */ 60 | #define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */ 61 | #define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */ 62 | #define BUSY_STATE 113 /* deflate -> FINISH_STATE */ 63 | #define FINISH_STATE 666 /* stream complete */ 64 | /* Stream status */ 65 | 66 | 67 | /* Data structure describing a single value and its code string. */ 68 | typedef struct ct_data_s { 69 | union { 70 | ush freq; /* frequency count */ 71 | ush code; /* bit string */ 72 | } fc; 73 | union { 74 | ush dad; /* father node in Huffman tree */ 75 | ush len; /* length of bit string */ 76 | } dl; 77 | } FAR ct_data; 78 | 79 | #define Freq fc.freq 80 | #define Code fc.code 81 | #define Dad dl.dad 82 | #define Len dl.len 83 | 84 | typedef struct static_tree_desc_s static_tree_desc; 85 | 86 | typedef struct tree_desc_s { 87 | ct_data *dyn_tree; /* the dynamic tree */ 88 | int max_code; /* largest code with non zero frequency */ 89 | const static_tree_desc *stat_desc; /* the corresponding static tree */ 90 | } FAR tree_desc; 91 | 92 | typedef ush Pos; 93 | typedef Pos FAR Posf; 94 | typedef unsigned IPos; 95 | 96 | /* A Pos is an index in the character window. We use short instead of int to 97 | * save space in the various tables. IPos is used only for parameter passing. 98 | */ 99 | 100 | typedef struct internal_state { 101 | z_streamp strm; /* pointer back to this zlib stream */ 102 | int status; /* as the name implies */ 103 | Bytef *pending_buf; /* output still pending */ 104 | ulg pending_buf_size; /* size of pending_buf */ 105 | Bytef *pending_out; /* next pending byte to output to the stream */ 106 | ulg pending; /* nb of bytes in the pending buffer */ 107 | int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ 108 | gz_headerp gzhead; /* gzip header information to write */ 109 | ulg gzindex; /* where in extra, name, or comment */ 110 | Byte method; /* can only be DEFLATED */ 111 | int last_flush; /* value of flush param for previous deflate call */ 112 | 113 | /* used by deflate.c: */ 114 | 115 | uInt w_size; /* LZ77 window size (32K by default) */ 116 | uInt w_bits; /* log2(w_size) (8..16) */ 117 | uInt w_mask; /* w_size - 1 */ 118 | 119 | Bytef *window; 120 | /* Sliding window. Input bytes are read into the second half of the window, 121 | * and move to the first half later to keep a dictionary of at least wSize 122 | * bytes. With this organization, matches are limited to a distance of 123 | * wSize-MAX_MATCH bytes, but this ensures that IO is always 124 | * performed with a length multiple of the block size. Also, it limits 125 | * the window size to 64K, which is quite useful on MSDOS. 126 | * To do: use the user input buffer as sliding window. 127 | */ 128 | 129 | ulg window_size; 130 | /* Actual size of window: 2*wSize, except when the user input buffer 131 | * is directly used as sliding window. 132 | */ 133 | 134 | Posf *prev; 135 | /* Link to older string with same hash index. To limit the size of this 136 | * array to 64K, this link is maintained only for the last 32K strings. 137 | * An index in this array is thus a window index modulo 32K. 138 | */ 139 | 140 | Posf *head; /* Heads of the hash chains or NIL. */ 141 | 142 | uInt ins_h; /* hash index of string to be inserted */ 143 | uInt hash_size; /* number of elements in hash table */ 144 | uInt hash_bits; /* log2(hash_size) */ 145 | uInt hash_mask; /* hash_size-1 */ 146 | 147 | uInt hash_shift; 148 | /* Number of bits by which ins_h must be shifted at each input 149 | * step. It must be such that after MIN_MATCH steps, the oldest 150 | * byte no longer takes part in the hash key, that is: 151 | * hash_shift * MIN_MATCH >= hash_bits 152 | */ 153 | 154 | long block_start; 155 | /* Window position at the beginning of the current output block. Gets 156 | * negative when the window is moved backwards. 157 | */ 158 | 159 | uInt match_length; /* length of best match */ 160 | IPos prev_match; /* previous match */ 161 | int match_available; /* set if previous match exists */ 162 | uInt strstart; /* start of string to insert */ 163 | uInt match_start; /* start of matching string */ 164 | uInt lookahead; /* number of valid bytes ahead in window */ 165 | 166 | uInt prev_length; 167 | /* Length of the best match at previous step. Matches not greater than this 168 | * are discarded. This is used in the lazy match evaluation. 169 | */ 170 | 171 | uInt max_chain_length; 172 | /* To speed up deflation, hash chains are never searched beyond this 173 | * length. A higher limit improves compression ratio but degrades the 174 | * speed. 175 | */ 176 | 177 | uInt max_lazy_match; 178 | /* Attempt to find a better match only when the current match is strictly 179 | * smaller than this value. This mechanism is used only for compression 180 | * levels >= 4. 181 | */ 182 | # define max_insert_length max_lazy_match 183 | /* Insert new strings in the hash table only if the match length is not 184 | * greater than this length. This saves time but degrades compression. 185 | * max_insert_length is used only for compression levels <= 3. 186 | */ 187 | 188 | int level; /* compression level (1..9) */ 189 | int strategy; /* favor or force Huffman coding*/ 190 | 191 | uInt good_match; 192 | /* Use a faster search when the previous match is longer than this */ 193 | 194 | int nice_match; /* Stop searching when current match exceeds this */ 195 | 196 | /* used by trees.c: */ 197 | /* Didn't use ct_data typedef below to suppress compiler warning */ 198 | struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ 199 | struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ 200 | struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ 201 | 202 | struct tree_desc_s l_desc; /* desc. for literal tree */ 203 | struct tree_desc_s d_desc; /* desc. for distance tree */ 204 | struct tree_desc_s bl_desc; /* desc. for bit length tree */ 205 | 206 | ush bl_count[MAX_BITS+1]; 207 | /* number of codes at each bit length for an optimal tree */ 208 | 209 | int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ 210 | int heap_len; /* number of elements in the heap */ 211 | int heap_max; /* element of largest frequency */ 212 | /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. 213 | * The same heap array is used to build all trees. 214 | */ 215 | 216 | uch depth[2*L_CODES+1]; 217 | /* Depth of each subtree used as tie breaker for trees of equal frequency 218 | */ 219 | 220 | uchf *l_buf; /* buffer for literals or lengths */ 221 | 222 | uInt lit_bufsize; 223 | /* Size of match buffer for literals/lengths. There are 4 reasons for 224 | * limiting lit_bufsize to 64K: 225 | * - frequencies can be kept in 16 bit counters 226 | * - if compression is not successful for the first block, all input 227 | * data is still in the window so we can still emit a stored block even 228 | * when input comes from standard input. (This can also be done for 229 | * all blocks if lit_bufsize is not greater than 32K.) 230 | * - if compression is not successful for a file smaller than 64K, we can 231 | * even emit a stored file instead of a stored block (saving 5 bytes). 232 | * This is applicable only for zip (not gzip or zlib). 233 | * - creating new Huffman trees less frequently may not provide fast 234 | * adaptation to changes in the input data statistics. (Take for 235 | * example a binary file with poorly compressible code followed by 236 | * a highly compressible string table.) Smaller buffer sizes give 237 | * fast adaptation but have of course the overhead of transmitting 238 | * trees more frequently. 239 | * - I can't count above 4 240 | */ 241 | 242 | uInt last_lit; /* running index in l_buf */ 243 | 244 | ushf *d_buf; 245 | /* Buffer for distances. To simplify the code, d_buf and l_buf have 246 | * the same number of elements. To use different lengths, an extra flag 247 | * array would be necessary. 248 | */ 249 | 250 | ulg opt_len; /* bit length of current block with optimal trees */ 251 | ulg static_len; /* bit length of current block with static trees */ 252 | uInt matches; /* number of string matches in current block */ 253 | uInt insert; /* bytes at end of window left to insert */ 254 | 255 | #ifdef ZLIB_DEBUG 256 | ulg compressed_len; /* total bit length of compressed file mod 2^32 */ 257 | ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ 258 | #endif 259 | 260 | ush bi_buf; 261 | /* Output buffer. bits are inserted starting at the bottom (least 262 | * significant bits). 263 | */ 264 | int bi_valid; 265 | /* Number of valid bits in bi_buf. All bits above the last valid bit 266 | * are always zero. 267 | */ 268 | 269 | ulg high_water; 270 | /* High water mark offset in window for initialized bytes -- bytes above 271 | * this are set to zero in order to avoid memory check warnings when 272 | * longest match routines access bytes past the input. This is then 273 | * updated to the new high water mark. 274 | */ 275 | 276 | } FAR deflate_state; 277 | 278 | /* Output a byte on the stream. 279 | * IN assertion: there is enough room in pending_buf. 280 | */ 281 | #define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);} 282 | 283 | 284 | #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) 285 | /* Minimum amount of lookahead, except at the end of the input file. 286 | * See deflate.c for comments about the MIN_MATCH+1. 287 | */ 288 | 289 | #define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) 290 | /* In order to simplify the code, particularly on 16 bit machines, match 291 | * distances are limited to MAX_DIST instead of WSIZE. 292 | */ 293 | 294 | #define WIN_INIT MAX_MATCH 295 | /* Number of bytes after end of data in window to initialize in order to avoid 296 | memory checker errors from longest match routines */ 297 | 298 | /* in trees.c */ 299 | void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); 300 | int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); 301 | void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, 302 | ulg stored_len, int last)); 303 | void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); 304 | void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); 305 | void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, 306 | ulg stored_len, int last)); 307 | 308 | #define d_code(dist) \ 309 | ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) 310 | /* Mapping from a distance to a distance code. dist is the distance - 1 and 311 | * must not have side effects. _dist_code[256] and _dist_code[257] are never 312 | * used. 313 | */ 314 | 315 | #ifndef ZLIB_DEBUG 316 | /* Inline versions of _tr_tally for speed: */ 317 | 318 | #if defined(GEN_TREES_H) || !defined(STDC) 319 | extern uch ZLIB_INTERNAL _length_code[]; 320 | extern uch ZLIB_INTERNAL _dist_code[]; 321 | #else 322 | extern const uch ZLIB_INTERNAL _length_code[]; 323 | extern const uch ZLIB_INTERNAL _dist_code[]; 324 | #endif 325 | 326 | # define _tr_tally_lit(s, c, flush) \ 327 | { uch cc = (c); \ 328 | s->d_buf[s->last_lit] = 0; \ 329 | s->l_buf[s->last_lit++] = cc; \ 330 | s->dyn_ltree[cc].Freq++; \ 331 | flush = (s->last_lit == s->lit_bufsize-1); \ 332 | } 333 | # define _tr_tally_dist(s, distance, length, flush) \ 334 | { uch len = (uch)(length); \ 335 | ush dist = (ush)(distance); \ 336 | s->d_buf[s->last_lit] = dist; \ 337 | s->l_buf[s->last_lit++] = len; \ 338 | dist--; \ 339 | s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ 340 | s->dyn_dtree[d_code(dist)].Freq++; \ 341 | flush = (s->last_lit == s->lit_bufsize-1); \ 342 | } 343 | #else 344 | # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) 345 | # define _tr_tally_dist(s, distance, length, flush) \ 346 | flush = _tr_tally(s, distance, length) 347 | #endif 348 | 349 | #endif /* DEFLATE_H */ 350 | -------------------------------------------------------------------------------- /zlib1.2.11/crc32.c: -------------------------------------------------------------------------------- 1 | /* crc32.c -- compute the CRC-32 of a data stream 2 | * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | * 5 | * Thanks to Rodney Brown for his contribution of faster 6 | * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing 7 | * tables for updating the shift register in one step with three exclusive-ors 8 | * instead of four steps with four exclusive-ors. This results in about a 9 | * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. 10 | */ 11 | 12 | /* @(#) $Id$ */ 13 | 14 | /* 15 | Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore 16 | protection on the static variables used to control the first-use generation 17 | of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should 18 | first call get_crc_table() to initialize the tables before allowing more than 19 | one thread to use crc32(). 20 | 21 | DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. 22 | */ 23 | 24 | #ifdef MAKECRCH 25 | # include 26 | # ifndef DYNAMIC_CRC_TABLE 27 | # define DYNAMIC_CRC_TABLE 28 | # endif /* !DYNAMIC_CRC_TABLE */ 29 | #endif /* MAKECRCH */ 30 | 31 | #include "zutil.h" /* for STDC and FAR definitions */ 32 | 33 | /* Definitions for doing the crc four data bytes at a time. */ 34 | #if !defined(NOBYFOUR) && defined(Z_U4) 35 | # define BYFOUR 36 | #endif 37 | #ifdef BYFOUR 38 | local unsigned long crc32_little OF((unsigned long, 39 | const unsigned char FAR *, z_size_t)); 40 | local unsigned long crc32_big OF((unsigned long, 41 | const unsigned char FAR *, z_size_t)); 42 | # define TBLS 8 43 | #else 44 | # define TBLS 1 45 | #endif /* BYFOUR */ 46 | 47 | /* Local functions for crc concatenation */ 48 | local unsigned long gf2_matrix_times OF((unsigned long *mat, 49 | unsigned long vec)); 50 | local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); 51 | local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); 52 | 53 | 54 | #ifdef DYNAMIC_CRC_TABLE 55 | 56 | local volatile int crc_table_empty = 1; 57 | local z_crc_t FAR crc_table[TBLS][256]; 58 | local void make_crc_table OF((void)); 59 | #ifdef MAKECRCH 60 | local void write_table OF((FILE *, const z_crc_t FAR *)); 61 | #endif /* MAKECRCH */ 62 | /* 63 | Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: 64 | x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. 65 | 66 | Polynomials over GF(2) are represented in binary, one bit per coefficient, 67 | with the lowest powers in the most significant bit. Then adding polynomials 68 | is just exclusive-or, and multiplying a polynomial by x is a right shift by 69 | one. If we call the above polynomial p, and represent a byte as the 70 | polynomial q, also with the lowest power in the most significant bit (so the 71 | byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, 72 | where a mod b means the remainder after dividing a by b. 73 | 74 | This calculation is done using the shift-register method of multiplying and 75 | taking the remainder. The register is initialized to zero, and for each 76 | incoming bit, x^32 is added mod p to the register if the bit is a one (where 77 | x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by 78 | x (which is shifting right by one and adding x^32 mod p if the bit shifted 79 | out is a one). We start with the highest power (least significant bit) of 80 | q and repeat for all eight bits of q. 81 | 82 | The first table is simply the CRC of all possible eight bit values. This is 83 | all the information needed to generate CRCs on data a byte at a time for all 84 | combinations of CRC register values and incoming bytes. The remaining tables 85 | allow for word-at-a-time CRC calculation for both big-endian and little- 86 | endian machines, where a word is four bytes. 87 | */ 88 | local void make_crc_table() 89 | { 90 | z_crc_t c; 91 | int n, k; 92 | z_crc_t poly; /* polynomial exclusive-or pattern */ 93 | /* terms of polynomial defining this crc (except x^32): */ 94 | static volatile int first = 1; /* flag to limit concurrent making */ 95 | static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; 96 | 97 | /* See if another task is already doing this (not thread-safe, but better 98 | than nothing -- significantly reduces duration of vulnerability in 99 | case the advice about DYNAMIC_CRC_TABLE is ignored) */ 100 | if (first) { 101 | first = 0; 102 | 103 | /* make exclusive-or pattern from polynomial (0xedb88320UL) */ 104 | poly = 0; 105 | for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) 106 | poly |= (z_crc_t)1 << (31 - p[n]); 107 | 108 | /* generate a crc for every 8-bit value */ 109 | for (n = 0; n < 256; n++) { 110 | c = (z_crc_t)n; 111 | for (k = 0; k < 8; k++) 112 | c = c & 1 ? poly ^ (c >> 1) : c >> 1; 113 | crc_table[0][n] = c; 114 | } 115 | 116 | #ifdef BYFOUR 117 | /* generate crc for each value followed by one, two, and three zeros, 118 | and then the byte reversal of those as well as the first table */ 119 | for (n = 0; n < 256; n++) { 120 | c = crc_table[0][n]; 121 | crc_table[4][n] = ZSWAP32(c); 122 | for (k = 1; k < 4; k++) { 123 | c = crc_table[0][c & 0xff] ^ (c >> 8); 124 | crc_table[k][n] = c; 125 | crc_table[k + 4][n] = ZSWAP32(c); 126 | } 127 | } 128 | #endif /* BYFOUR */ 129 | 130 | crc_table_empty = 0; 131 | } 132 | else { /* not first */ 133 | /* wait for the other guy to finish (not efficient, but rare) */ 134 | while (crc_table_empty) 135 | ; 136 | } 137 | 138 | #ifdef MAKECRCH 139 | /* write out CRC tables to crc32.h */ 140 | { 141 | FILE *out; 142 | 143 | out = fopen("crc32.h", "w"); 144 | if (out == NULL) return; 145 | fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); 146 | fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); 147 | fprintf(out, "local const z_crc_t FAR "); 148 | fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); 149 | write_table(out, crc_table[0]); 150 | # ifdef BYFOUR 151 | fprintf(out, "#ifdef BYFOUR\n"); 152 | for (k = 1; k < 8; k++) { 153 | fprintf(out, " },\n {\n"); 154 | write_table(out, crc_table[k]); 155 | } 156 | fprintf(out, "#endif\n"); 157 | # endif /* BYFOUR */ 158 | fprintf(out, " }\n};\n"); 159 | fclose(out); 160 | } 161 | #endif /* MAKECRCH */ 162 | } 163 | 164 | #ifdef MAKECRCH 165 | local void write_table(out, table) 166 | FILE *out; 167 | const z_crc_t FAR *table; 168 | { 169 | int n; 170 | 171 | for (n = 0; n < 256; n++) 172 | fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", 173 | (unsigned long)(table[n]), 174 | n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); 175 | } 176 | #endif /* MAKECRCH */ 177 | 178 | #else /* !DYNAMIC_CRC_TABLE */ 179 | /* ======================================================================== 180 | * Tables of CRC-32s of all single-byte values, made by make_crc_table(). 181 | */ 182 | #include "crc32.h" 183 | #endif /* DYNAMIC_CRC_TABLE */ 184 | 185 | /* ========================================================================= 186 | * This function can be used by asm versions of crc32() 187 | */ 188 | const z_crc_t FAR * ZEXPORT get_crc_table() 189 | { 190 | #ifdef DYNAMIC_CRC_TABLE 191 | if (crc_table_empty) 192 | make_crc_table(); 193 | #endif /* DYNAMIC_CRC_TABLE */ 194 | return (const z_crc_t FAR *)crc_table; 195 | } 196 | 197 | /* ========================================================================= */ 198 | #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) 199 | #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 200 | 201 | /* ========================================================================= */ 202 | unsigned long ZEXPORT crc32_z(crc, buf, len) 203 | unsigned long crc; 204 | const unsigned char FAR *buf; 205 | z_size_t len; 206 | { 207 | if (buf == Z_NULL) return 0UL; 208 | 209 | #ifdef DYNAMIC_CRC_TABLE 210 | if (crc_table_empty) 211 | make_crc_table(); 212 | #endif /* DYNAMIC_CRC_TABLE */ 213 | 214 | #ifdef BYFOUR 215 | if (sizeof(void *) == sizeof(ptrdiff_t)) { 216 | z_crc_t endian; 217 | 218 | endian = 1; 219 | if (*((unsigned char *)(&endian))) 220 | return crc32_little(crc, buf, len); 221 | else 222 | return crc32_big(crc, buf, len); 223 | } 224 | #endif /* BYFOUR */ 225 | crc = crc ^ 0xffffffffUL; 226 | while (len >= 8) { 227 | DO8; 228 | len -= 8; 229 | } 230 | if (len) do { 231 | DO1; 232 | } while (--len); 233 | return crc ^ 0xffffffffUL; 234 | } 235 | 236 | /* ========================================================================= */ 237 | unsigned long ZEXPORT crc32(crc, buf, len) 238 | unsigned long crc; 239 | const unsigned char FAR *buf; 240 | uInt len; 241 | { 242 | return crc32_z(crc, buf, len); 243 | } 244 | 245 | #ifdef BYFOUR 246 | 247 | /* 248 | This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit 249 | integer pointer type. This violates the strict aliasing rule, where a 250 | compiler can assume, for optimization purposes, that two pointers to 251 | fundamentally different types won't ever point to the same memory. This can 252 | manifest as a problem only if one of the pointers is written to. This code 253 | only reads from those pointers. So long as this code remains isolated in 254 | this compilation unit, there won't be a problem. For this reason, this code 255 | should not be copied and pasted into a compilation unit in which other code 256 | writes to the buffer that is passed to these routines. 257 | */ 258 | 259 | /* ========================================================================= */ 260 | #define DOLIT4 c ^= *buf4++; \ 261 | c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ 262 | crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] 263 | #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 264 | 265 | /* ========================================================================= */ 266 | local unsigned long crc32_little(crc, buf, len) 267 | unsigned long crc; 268 | const unsigned char FAR *buf; 269 | z_size_t len; 270 | { 271 | register z_crc_t c; 272 | register const z_crc_t FAR *buf4; 273 | 274 | c = (z_crc_t)crc; 275 | c = ~c; 276 | while (len && ((ptrdiff_t)buf & 3)) { 277 | c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); 278 | len--; 279 | } 280 | 281 | buf4 = (const z_crc_t FAR *)(const void FAR *)buf; 282 | while (len >= 32) { 283 | DOLIT32; 284 | len -= 32; 285 | } 286 | while (len >= 4) { 287 | DOLIT4; 288 | len -= 4; 289 | } 290 | buf = (const unsigned char FAR *)buf4; 291 | 292 | if (len) do { 293 | c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); 294 | } while (--len); 295 | c = ~c; 296 | return (unsigned long)c; 297 | } 298 | 299 | /* ========================================================================= */ 300 | #define DOBIG4 c ^= *buf4++; \ 301 | c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ 302 | crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] 303 | #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 304 | 305 | /* ========================================================================= */ 306 | local unsigned long crc32_big(crc, buf, len) 307 | unsigned long crc; 308 | const unsigned char FAR *buf; 309 | z_size_t len; 310 | { 311 | register z_crc_t c; 312 | register const z_crc_t FAR *buf4; 313 | 314 | c = ZSWAP32((z_crc_t)crc); 315 | c = ~c; 316 | while (len && ((ptrdiff_t)buf & 3)) { 317 | c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); 318 | len--; 319 | } 320 | 321 | buf4 = (const z_crc_t FAR *)(const void FAR *)buf; 322 | while (len >= 32) { 323 | DOBIG32; 324 | len -= 32; 325 | } 326 | while (len >= 4) { 327 | DOBIG4; 328 | len -= 4; 329 | } 330 | buf = (const unsigned char FAR *)buf4; 331 | 332 | if (len) do { 333 | c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); 334 | } while (--len); 335 | c = ~c; 336 | return (unsigned long)(ZSWAP32(c)); 337 | } 338 | 339 | #endif /* BYFOUR */ 340 | 341 | #define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ 342 | 343 | /* ========================================================================= */ 344 | local unsigned long gf2_matrix_times(mat, vec) 345 | unsigned long *mat; 346 | unsigned long vec; 347 | { 348 | unsigned long sum; 349 | 350 | sum = 0; 351 | while (vec) { 352 | if (vec & 1) 353 | sum ^= *mat; 354 | vec >>= 1; 355 | mat++; 356 | } 357 | return sum; 358 | } 359 | 360 | /* ========================================================================= */ 361 | local void gf2_matrix_square(square, mat) 362 | unsigned long *square; 363 | unsigned long *mat; 364 | { 365 | int n; 366 | 367 | for (n = 0; n < GF2_DIM; n++) 368 | square[n] = gf2_matrix_times(mat, mat[n]); 369 | } 370 | 371 | /* ========================================================================= */ 372 | local uLong crc32_combine_(crc1, crc2, len2) 373 | uLong crc1; 374 | uLong crc2; 375 | z_off64_t len2; 376 | { 377 | int n; 378 | unsigned long row; 379 | unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ 380 | unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ 381 | 382 | /* degenerate case (also disallow negative lengths) */ 383 | if (len2 <= 0) 384 | return crc1; 385 | 386 | /* put operator for one zero bit in odd */ 387 | odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ 388 | row = 1; 389 | for (n = 1; n < GF2_DIM; n++) { 390 | odd[n] = row; 391 | row <<= 1; 392 | } 393 | 394 | /* put operator for two zero bits in even */ 395 | gf2_matrix_square(even, odd); 396 | 397 | /* put operator for four zero bits in odd */ 398 | gf2_matrix_square(odd, even); 399 | 400 | /* apply len2 zeros to crc1 (first square will put the operator for one 401 | zero byte, eight zero bits, in even) */ 402 | do { 403 | /* apply zeros operator for this bit of len2 */ 404 | gf2_matrix_square(even, odd); 405 | if (len2 & 1) 406 | crc1 = gf2_matrix_times(even, crc1); 407 | len2 >>= 1; 408 | 409 | /* if no more bits set, then done */ 410 | if (len2 == 0) 411 | break; 412 | 413 | /* another iteration of the loop with odd and even swapped */ 414 | gf2_matrix_square(odd, even); 415 | if (len2 & 1) 416 | crc1 = gf2_matrix_times(odd, crc1); 417 | len2 >>= 1; 418 | 419 | /* if no more bits set, then done */ 420 | } while (len2 != 0); 421 | 422 | /* return combined crc */ 423 | crc1 ^= crc2; 424 | return crc1; 425 | } 426 | 427 | /* ========================================================================= */ 428 | uLong ZEXPORT crc32_combine(crc1, crc2, len2) 429 | uLong crc1; 430 | uLong crc2; 431 | z_off_t len2; 432 | { 433 | return crc32_combine_(crc1, crc2, len2); 434 | } 435 | 436 | uLong ZEXPORT crc32_combine64(crc1, crc2, len2) 437 | uLong crc1; 438 | uLong crc2; 439 | z_off64_t len2; 440 | { 441 | return crc32_combine_(crc1, crc2, len2); 442 | } 443 | -------------------------------------------------------------------------------- /zlib1.2.11/zconf.h: -------------------------------------------------------------------------------- 1 | /* zconf.h -- configuration of the zlib compression library 2 | * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #ifndef ZCONF_H 9 | #define ZCONF_H 10 | 11 | /* 12 | * If you *really* need a unique prefix for all types and library functions, 13 | * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. 14 | * Even better than compiling with -DZ_PREFIX would be to use configure to set 15 | * this permanently in zconf.h using "./configure --zprefix". 16 | */ 17 | #ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ 18 | # define Z_PREFIX_SET 19 | 20 | /* all linked symbols and init macros */ 21 | # define _dist_code z__dist_code 22 | # define _length_code z__length_code 23 | # define _tr_align z__tr_align 24 | # define _tr_flush_bits z__tr_flush_bits 25 | # define _tr_flush_block z__tr_flush_block 26 | # define _tr_init z__tr_init 27 | # define _tr_stored_block z__tr_stored_block 28 | # define _tr_tally z__tr_tally 29 | # define adler32 z_adler32 30 | # define adler32_combine z_adler32_combine 31 | # define adler32_combine64 z_adler32_combine64 32 | # define adler32_z z_adler32_z 33 | # ifndef Z_SOLO 34 | # define compress z_compress 35 | # define compress2 z_compress2 36 | # define compressBound z_compressBound 37 | # endif 38 | # define crc32 z_crc32 39 | # define crc32_combine z_crc32_combine 40 | # define crc32_combine64 z_crc32_combine64 41 | # define crc32_z z_crc32_z 42 | # define deflate z_deflate 43 | # define deflateBound z_deflateBound 44 | # define deflateCopy z_deflateCopy 45 | # define deflateEnd z_deflateEnd 46 | # define deflateGetDictionary z_deflateGetDictionary 47 | # define deflateInit z_deflateInit 48 | # define deflateInit2 z_deflateInit2 49 | # define deflateInit2_ z_deflateInit2_ 50 | # define deflateInit_ z_deflateInit_ 51 | # define deflateParams z_deflateParams 52 | # define deflatePending z_deflatePending 53 | # define deflatePrime z_deflatePrime 54 | # define deflateReset z_deflateReset 55 | # define deflateResetKeep z_deflateResetKeep 56 | # define deflateSetDictionary z_deflateSetDictionary 57 | # define deflateSetHeader z_deflateSetHeader 58 | # define deflateTune z_deflateTune 59 | # define deflate_copyright z_deflate_copyright 60 | # define get_crc_table z_get_crc_table 61 | # ifndef Z_SOLO 62 | # define gz_error z_gz_error 63 | # define gz_intmax z_gz_intmax 64 | # define gz_strwinerror z_gz_strwinerror 65 | # define gzbuffer z_gzbuffer 66 | # define gzclearerr z_gzclearerr 67 | # define gzclose z_gzclose 68 | # define gzclose_r z_gzclose_r 69 | # define gzclose_w z_gzclose_w 70 | # define gzdirect z_gzdirect 71 | # define gzdopen z_gzdopen 72 | # define gzeof z_gzeof 73 | # define gzerror z_gzerror 74 | # define gzflush z_gzflush 75 | # define gzfread z_gzfread 76 | # define gzfwrite z_gzfwrite 77 | # define gzgetc z_gzgetc 78 | # define gzgetc_ z_gzgetc_ 79 | # define gzgets z_gzgets 80 | # define gzoffset z_gzoffset 81 | # define gzoffset64 z_gzoffset64 82 | # define gzopen z_gzopen 83 | # define gzopen64 z_gzopen64 84 | # ifdef _WIN32 85 | # define gzopen_w z_gzopen_w 86 | # endif 87 | # define gzprintf z_gzprintf 88 | # define gzputc z_gzputc 89 | # define gzputs z_gzputs 90 | # define gzread z_gzread 91 | # define gzrewind z_gzrewind 92 | # define gzseek z_gzseek 93 | # define gzseek64 z_gzseek64 94 | # define gzsetparams z_gzsetparams 95 | # define gztell z_gztell 96 | # define gztell64 z_gztell64 97 | # define gzungetc z_gzungetc 98 | # define gzvprintf z_gzvprintf 99 | # define gzwrite z_gzwrite 100 | # endif 101 | # define inflate z_inflate 102 | # define inflateBack z_inflateBack 103 | # define inflateBackEnd z_inflateBackEnd 104 | # define inflateBackInit z_inflateBackInit 105 | # define inflateBackInit_ z_inflateBackInit_ 106 | # define inflateCodesUsed z_inflateCodesUsed 107 | # define inflateCopy z_inflateCopy 108 | # define inflateEnd z_inflateEnd 109 | # define inflateGetDictionary z_inflateGetDictionary 110 | # define inflateGetHeader z_inflateGetHeader 111 | # define inflateInit z_inflateInit 112 | # define inflateInit2 z_inflateInit2 113 | # define inflateInit2_ z_inflateInit2_ 114 | # define inflateInit_ z_inflateInit_ 115 | # define inflateMark z_inflateMark 116 | # define inflatePrime z_inflatePrime 117 | # define inflateReset z_inflateReset 118 | # define inflateReset2 z_inflateReset2 119 | # define inflateResetKeep z_inflateResetKeep 120 | # define inflateSetDictionary z_inflateSetDictionary 121 | # define inflateSync z_inflateSync 122 | # define inflateSyncPoint z_inflateSyncPoint 123 | # define inflateUndermine z_inflateUndermine 124 | # define inflateValidate z_inflateValidate 125 | # define inflate_copyright z_inflate_copyright 126 | # define inflate_fast z_inflate_fast 127 | # define inflate_table z_inflate_table 128 | # ifndef Z_SOLO 129 | # define uncompress z_uncompress 130 | # define uncompress2 z_uncompress2 131 | # endif 132 | # define zError z_zError 133 | # ifndef Z_SOLO 134 | # define zcalloc z_zcalloc 135 | # define zcfree z_zcfree 136 | # endif 137 | # define zlibCompileFlags z_zlibCompileFlags 138 | # define zlibVersion z_zlibVersion 139 | 140 | /* all zlib typedefs in zlib.h and zconf.h */ 141 | # define Byte z_Byte 142 | # define Bytef z_Bytef 143 | # define alloc_func z_alloc_func 144 | # define charf z_charf 145 | # define free_func z_free_func 146 | # ifndef Z_SOLO 147 | # define gzFile z_gzFile 148 | # endif 149 | # define gz_header z_gz_header 150 | # define gz_headerp z_gz_headerp 151 | # define in_func z_in_func 152 | # define intf z_intf 153 | # define out_func z_out_func 154 | # define uInt z_uInt 155 | # define uIntf z_uIntf 156 | # define uLong z_uLong 157 | # define uLongf z_uLongf 158 | # define voidp z_voidp 159 | # define voidpc z_voidpc 160 | # define voidpf z_voidpf 161 | 162 | /* all zlib structs in zlib.h and zconf.h */ 163 | # define gz_header_s z_gz_header_s 164 | # define internal_state z_internal_state 165 | 166 | #endif 167 | 168 | #if defined(__MSDOS__) && !defined(MSDOS) 169 | # define MSDOS 170 | #endif 171 | #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) 172 | # define OS2 173 | #endif 174 | #if defined(_WINDOWS) && !defined(WINDOWS) 175 | # define WINDOWS 176 | #endif 177 | #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) 178 | # ifndef WIN32 179 | # define WIN32 180 | # endif 181 | #endif 182 | #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) 183 | # if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) 184 | # ifndef SYS16BIT 185 | # define SYS16BIT 186 | # endif 187 | # endif 188 | #endif 189 | 190 | /* 191 | * Compile with -DMAXSEG_64K if the alloc function cannot allocate more 192 | * than 64k bytes at a time (needed on systems with 16-bit int). 193 | */ 194 | #ifdef SYS16BIT 195 | # define MAXSEG_64K 196 | #endif 197 | #ifdef MSDOS 198 | # define UNALIGNED_OK 199 | #endif 200 | 201 | #ifdef __STDC_VERSION__ 202 | # ifndef STDC 203 | # define STDC 204 | # endif 205 | # if __STDC_VERSION__ >= 199901L 206 | # ifndef STDC99 207 | # define STDC99 208 | # endif 209 | # endif 210 | #endif 211 | #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) 212 | # define STDC 213 | #endif 214 | #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) 215 | # define STDC 216 | #endif 217 | #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) 218 | # define STDC 219 | #endif 220 | #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) 221 | # define STDC 222 | #endif 223 | 224 | #if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ 225 | # define STDC 226 | #endif 227 | 228 | #ifndef STDC 229 | # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ 230 | # define const /* note: need a more gentle solution here */ 231 | # endif 232 | #endif 233 | 234 | #if defined(ZLIB_CONST) && !defined(z_const) 235 | # define z_const const 236 | #else 237 | # define z_const 238 | #endif 239 | 240 | #ifdef Z_SOLO 241 | typedef unsigned long z_size_t; 242 | #else 243 | # define z_longlong long long 244 | # if defined(NO_SIZE_T) 245 | typedef unsigned NO_SIZE_T z_size_t; 246 | # elif defined(STDC) 247 | # include 248 | typedef size_t z_size_t; 249 | # else 250 | typedef unsigned long z_size_t; 251 | # endif 252 | # undef z_longlong 253 | #endif 254 | 255 | /* Maximum value for memLevel in deflateInit2 */ 256 | #ifndef MAX_MEM_LEVEL 257 | # ifdef MAXSEG_64K 258 | # define MAX_MEM_LEVEL 8 259 | # else 260 | # define MAX_MEM_LEVEL 9 261 | # endif 262 | #endif 263 | 264 | /* Maximum value for windowBits in deflateInit2 and inflateInit2. 265 | * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files 266 | * created by gzip. (Files created by minigzip can still be extracted by 267 | * gzip.) 268 | */ 269 | #ifndef MAX_WBITS 270 | # define MAX_WBITS 15 /* 32K LZ77 window */ 271 | #endif 272 | 273 | /* The memory requirements for deflate are (in bytes): 274 | (1 << (windowBits+2)) + (1 << (memLevel+9)) 275 | that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) 276 | plus a few kilobytes for small objects. For example, if you want to reduce 277 | the default memory requirements from 256K to 128K, compile with 278 | make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" 279 | Of course this will generally degrade compression (there's no free lunch). 280 | 281 | The memory requirements for inflate are (in bytes) 1 << windowBits 282 | that is, 32K for windowBits=15 (default value) plus about 7 kilobytes 283 | for small objects. 284 | */ 285 | 286 | /* Type declarations */ 287 | 288 | #ifndef OF /* function prototypes */ 289 | # ifdef STDC 290 | # define OF(args) args 291 | # else 292 | # define OF(args) () 293 | # endif 294 | #endif 295 | 296 | #ifndef Z_ARG /* function prototypes for stdarg */ 297 | # if defined(STDC) || defined(Z_HAVE_STDARG_H) 298 | # define Z_ARG(args) args 299 | # else 300 | # define Z_ARG(args) () 301 | # endif 302 | #endif 303 | 304 | /* The following definitions for FAR are needed only for MSDOS mixed 305 | * model programming (small or medium model with some far allocations). 306 | * This was tested only with MSC; for other MSDOS compilers you may have 307 | * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, 308 | * just define FAR to be empty. 309 | */ 310 | #ifdef SYS16BIT 311 | # if defined(M_I86SM) || defined(M_I86MM) 312 | /* MSC small or medium model */ 313 | # define SMALL_MEDIUM 314 | # ifdef _MSC_VER 315 | # define FAR _far 316 | # else 317 | # define FAR far 318 | # endif 319 | # endif 320 | # if (defined(__SMALL__) || defined(__MEDIUM__)) 321 | /* Turbo C small or medium model */ 322 | # define SMALL_MEDIUM 323 | # ifdef __BORLANDC__ 324 | # define FAR _far 325 | # else 326 | # define FAR far 327 | # endif 328 | # endif 329 | #endif 330 | 331 | #if defined(WINDOWS) || defined(WIN32) 332 | /* If building or using zlib as a DLL, define ZLIB_DLL. 333 | * This is not mandatory, but it offers a little performance increase. 334 | */ 335 | # ifdef ZLIB_DLL 336 | # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) 337 | # ifdef ZLIB_INTERNAL 338 | # define ZEXTERN extern __declspec(dllexport) 339 | # else 340 | # define ZEXTERN extern __declspec(dllimport) 341 | # endif 342 | # endif 343 | # endif /* ZLIB_DLL */ 344 | /* If building or using zlib with the WINAPI/WINAPIV calling convention, 345 | * define ZLIB_WINAPI. 346 | * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. 347 | */ 348 | # ifdef ZLIB_WINAPI 349 | # ifdef FAR 350 | # undef FAR 351 | # endif 352 | # include 353 | /* No need for _export, use ZLIB.DEF instead. */ 354 | /* For complete Windows compatibility, use WINAPI, not __stdcall. */ 355 | # define ZEXPORT WINAPI 356 | # ifdef WIN32 357 | # define ZEXPORTVA WINAPIV 358 | # else 359 | # define ZEXPORTVA FAR CDECL 360 | # endif 361 | # endif 362 | #endif 363 | 364 | #if defined (__BEOS__) 365 | # ifdef ZLIB_DLL 366 | # ifdef ZLIB_INTERNAL 367 | # define ZEXPORT __declspec(dllexport) 368 | # define ZEXPORTVA __declspec(dllexport) 369 | # else 370 | # define ZEXPORT __declspec(dllimport) 371 | # define ZEXPORTVA __declspec(dllimport) 372 | # endif 373 | # endif 374 | #endif 375 | 376 | #ifndef ZEXTERN 377 | # define ZEXTERN extern 378 | #endif 379 | #ifndef ZEXPORT 380 | # define ZEXPORT 381 | #endif 382 | #ifndef ZEXPORTVA 383 | # define ZEXPORTVA 384 | #endif 385 | 386 | #ifndef FAR 387 | # define FAR 388 | #endif 389 | 390 | #if !defined(__MACTYPES__) 391 | typedef unsigned char Byte; /* 8 bits */ 392 | #endif 393 | typedef unsigned int uInt; /* 16 bits or more */ 394 | typedef unsigned long uLong; /* 32 bits or more */ 395 | 396 | #ifdef SMALL_MEDIUM 397 | /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ 398 | # define Bytef Byte FAR 399 | #else 400 | typedef Byte FAR Bytef; 401 | #endif 402 | typedef char FAR charf; 403 | typedef int FAR intf; 404 | typedef uInt FAR uIntf; 405 | typedef uLong FAR uLongf; 406 | 407 | #ifdef STDC 408 | typedef void const *voidpc; 409 | typedef void FAR *voidpf; 410 | typedef void *voidp; 411 | #else 412 | typedef Byte const *voidpc; 413 | typedef Byte FAR *voidpf; 414 | typedef Byte *voidp; 415 | #endif 416 | 417 | #if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) 418 | # include 419 | # if (UINT_MAX == 0xffffffffUL) 420 | # define Z_U4 unsigned 421 | # elif (ULONG_MAX == 0xffffffffUL) 422 | # define Z_U4 unsigned long 423 | # elif (USHRT_MAX == 0xffffffffUL) 424 | # define Z_U4 unsigned short 425 | # endif 426 | #endif 427 | 428 | #ifdef Z_U4 429 | typedef Z_U4 z_crc_t; 430 | #else 431 | typedef unsigned long z_crc_t; 432 | #endif 433 | 434 | #ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ 435 | # define Z_HAVE_UNISTD_H 436 | #endif 437 | 438 | #ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ 439 | # define Z_HAVE_STDARG_H 440 | #endif 441 | 442 | #ifdef STDC 443 | # ifndef Z_SOLO 444 | # include /* for off_t */ 445 | # endif 446 | #endif 447 | 448 | #if defined(STDC) || defined(Z_HAVE_STDARG_H) 449 | # ifndef Z_SOLO 450 | # include /* for va_list */ 451 | # endif 452 | #endif 453 | 454 | #ifdef _WIN32 455 | # ifndef Z_SOLO 456 | # include /* for wchar_t */ 457 | # endif 458 | #endif 459 | 460 | /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and 461 | * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even 462 | * though the former does not conform to the LFS document), but considering 463 | * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as 464 | * equivalently requesting no 64-bit operations 465 | */ 466 | #if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 467 | # undef _LARGEFILE64_SOURCE 468 | #endif 469 | 470 | #if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) 471 | # define Z_HAVE_UNISTD_H 472 | #endif 473 | #ifndef Z_SOLO 474 | # if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) 475 | # include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ 476 | # ifdef VMS 477 | # include /* for off_t */ 478 | # endif 479 | # ifndef z_off_t 480 | # define z_off_t off_t 481 | # endif 482 | # endif 483 | #endif 484 | 485 | #if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 486 | # define Z_LFS64 487 | #endif 488 | 489 | #if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) 490 | # define Z_LARGE64 491 | #endif 492 | 493 | #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) 494 | # define Z_WANT64 495 | #endif 496 | 497 | #if !defined(SEEK_SET) && !defined(Z_SOLO) 498 | # define SEEK_SET 0 /* Seek from beginning of file. */ 499 | # define SEEK_CUR 1 /* Seek from current position. */ 500 | # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ 501 | #endif 502 | 503 | #ifndef z_off_t 504 | # define z_off_t long 505 | #endif 506 | 507 | #if !defined(_WIN32) && defined(Z_LARGE64) 508 | # define z_off64_t off64_t 509 | #else 510 | # if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) 511 | # define z_off64_t __int64 512 | # else 513 | # define z_off64_t z_off_t 514 | # endif 515 | #endif 516 | 517 | /* MVS linker does not support external names larger than 8 bytes */ 518 | #if defined(__MVS__) 519 | #pragma map(deflateInit_,"DEIN") 520 | #pragma map(deflateInit2_,"DEIN2") 521 | #pragma map(deflateEnd,"DEEND") 522 | #pragma map(deflateBound,"DEBND") 523 | #pragma map(inflateInit_,"ININ") 524 | #pragma map(inflateInit2_,"ININ2") 525 | #pragma map(inflateEnd,"INEND") 526 | #pragma map(inflateSync,"INSY") 527 | #pragma map(inflateSetDictionary,"INSEDI") 528 | #pragma map(compressBound,"CMBND") 529 | #pragma map(inflate_table,"INTABL") 530 | #pragma map(inflate_fast,"INFA") 531 | #pragma map(inflate_copyright,"INCOPY") 532 | #endif 533 | 534 | #endif /* ZCONF_H */ 535 | --------------------------------------------------------------------------------