thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2025-06-19 00:27:13 +02:00
Code Releases Activity

Major plugin refactor and cleanup.

Browse Source 
Switched to POCO library for unified platform/library interface.
Deprecated the external module API. It was creating more problems than solving.
Removed most built-in libraries in favor of system libraries for easier maintenance.
Cleaned and secured code with help from static analyzers.
This commit is contained in:
Sandu Liviu Catalin
2021-01-30 08:51:39 +02:00
parent e0e34b4030
commit 4a6bfc086c
6219 changed files with 1209835 additions and 454916 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
vendor/POCO/Net/include/Poco/Net/AbstractHTTPRequestHandler.h vendored Normal file
View File

@ -0,0 +1,136 @@
//
// AbstractHTTPRequestHandler.h
//
// Library: Net
// Package: HTTPServer
// Module: AbstractHTTPRequestHandler
//
// Definition of the AbstractHTTPRequestHandler class.
//
// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_AbstractHTTPRequestHandler_INCLUDED
#define Net_AbstractHTTPRequestHandler_INCLUDED
#include "Poco/Net/HTTPRequestHandler.h"
#include "Poco/Net/HTTPResponse.h"
namespace Poco {
namespace Net {
class HTMLForm;
class Net_API AbstractHTTPRequestHandler: public HTTPRequestHandler
/// The abstract base class for AbstractHTTPRequestHandlers
/// created by HTTPServer.
///
/// Derived classes must override the run() method.
/// Contrary to a HTTPRequestHandler, an AbstractHTTPRequestHandler
/// stores request and response as member variables to avoid having
/// to pass them around as method parameters. Additionally, a
/// HTMLForm object is created for use by subclasses.
///
/// The run() method must perform the complete handling
/// of the HTTP request connection. As soon as the run()
/// method returns, the request handler object is destroyed.
///
/// A new AbstractHTTPRequestHandler object will be created for
/// each new HTTP request that is received by the HTTPServer.
{
public:
AbstractHTTPRequestHandler();
/// Creates the AbstractHTTPRequestHandler.
virtual ~AbstractHTTPRequestHandler();
/// Destroys the AbstractHTTPRequestHandler.
void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response);
/// This class implements some common behavior,
/// before calling run() to actually handle the request:
/// - save request and response objects;
/// - call authorize();
/// - if authorize() returns true call run(),
/// else send 401 (Unauthorized) response.
///
/// If run() throws an exception and the response has not been
/// sent yet, sends a 500 (Internal Server Error) response with
/// the exception's display text.
HTTPServerRequest& request();
/// Returns the request.
HTTPServerResponse& response();
/// Returns the response.
HTMLForm& form();
/// Returns a HTMLForm for the given request.
/// The HTMLForm object is created when this
/// member function is executed the first time.
void sendErrorResponse(HTTPResponse::HTTPStatus status, const std::string& message);
/// Sends a HTML error page for the given status code.
/// The given message is added to the page:
/// <HTML>
/// <HEAD>
/// <TITLE>status - reason</TITLE>
/// </HEAD>
/// <BODY>
/// <H1>status - reason</H1>
/// <P>message</P>
/// </BODY>
/// </HTML>
protected:
virtual void run() = 0;
/// Must be overridden by subclasses.
///
/// Handles the given request.
virtual bool authenticate();
/// Check authentication; returns true if okay, false if failed to authenticate.
/// The default implementation always returns true.
///
/// Subclasses can override this member function to perform
/// some form of client or request authentication before
/// the request is actually handled.
private:
HTTPServerRequest* _pRequest;
HTTPServerResponse* _pResponse;
HTMLForm* _pForm;
};
//
// inlines
//
inline HTTPServerRequest& AbstractHTTPRequestHandler::request()
{
poco_check_ptr (_pRequest);
return *_pRequest;
}
inline HTTPServerResponse& AbstractHTTPRequestHandler::response()
{
poco_check_ptr (_pResponse);
return *_pResponse;
}
} } // namespace Poco::Net
#endif // Net_AbstractHTTPRequestHandler_INCLUDED

199
vendor/POCO/Net/include/Poco/Net/DNS.h vendored Normal file
View File

@ -0,0 +1,199 @@
//
// DNS.h
//
// Library: Net
// Package: NetCore
// Module: DNS
//
// Definition of the DNS class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_DNS_INCLUDED
#define Net_DNS_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketDefs.h"
#include "Poco/Net/IPAddress.h"
#include "Poco/Net/HostEntry.h"
namespace Poco {
namespace Net {
class Net_API DNS
/// This class provides an interface to the
/// domain name service.
///
/// Starting with POCO C++ Libraries release 1.9.0,
/// this class also supports Internationalized Domain Names (IDNs).
///
/// Regarding IDNs, the following rules apply:
///
/// * An IDN passed to hostByName() must be encoded manually, by calling
/// encodeIDN() (after testing with isIDN() first).
/// * An UTF-8 IDN passed to resolve() or resolveOne() is automatically encoded.
/// * IDNs returned in HostEntry objects are never decoded. They can be
/// decoded by calling decodeIDN() (after testing for an encoded IDN by
/// calling isEncodedIDN()).
{
public:
enum HintFlag
{
DNS_HINT_NONE = 0,
#ifdef POCO_HAVE_ADDRINFO
DNS_HINT_AI_PASSIVE = AI_PASSIVE, /// Socket address will be used in bind() call
DNS_HINT_AI_CANONNAME = AI_CANONNAME, /// Return canonical name in first ai_canonname
DNS_HINT_AI_NUMERICHOST = AI_NUMERICHOST, /// Nodename must be a numeric address string
DNS_HINT_AI_NUMERICSERV = AI_NUMERICSERV, /// Servicename must be a numeric port number
DNS_HINT_AI_ALL = AI_ALL, /// Query both IP6 and IP4 with AI_V4MAPPED
DNS_HINT_AI_ADDRCONFIG = AI_ADDRCONFIG, /// Resolution only if global address configured
DNS_HINT_AI_V4MAPPED = AI_V4MAPPED /// On v6 failure, query v4 and convert to V4MAPPED format
#endif
};
static HostEntry hostByName(const std::string& hostname, unsigned hintFlags =
#ifdef POCO_HAVE_ADDRINFO
DNS_HINT_AI_CANONNAME | DNS_HINT_AI_ADDRCONFIG
#else
DNS_HINT_NONE
#endif
);
/// Returns a HostEntry object containing the DNS information
/// for the host with the given name. HintFlag argument is only
/// used on platforms that have getaddrinfo().
///
/// Note that Internationalized Domain Names must be encoded
/// using Punycode (see encodeIDN()) before calling this method.
///
/// Throws a HostNotFoundException if a host with the given
/// name cannot be found.
///
/// Throws a NoAddressFoundException if no address can be
/// found for the hostname.
///
/// Throws a DNSException in case of a general DNS error.
///
/// Throws an IOException in case of any other error.
static HostEntry hostByAddress(const IPAddress& address, unsigned hintFlags =
#ifdef POCO_HAVE_ADDRINFO
DNS_HINT_AI_CANONNAME | DNS_HINT_AI_ADDRCONFIG
#else
DNS_HINT_NONE
#endif
);
/// Returns a HostEntry object containing the DNS information
/// for the host with the given IP address. HintFlag argument is only
/// used on platforms that have getaddrinfo().
///
/// Throws a HostNotFoundException if a host with the given
/// name cannot be found.
///
/// Throws a DNSException in case of a general DNS error.
///
/// Throws an IOException in case of any other error.
static HostEntry resolve(const std::string& address);
/// Returns a HostEntry object containing the DNS information
/// for the host with the given IP address or host name.
///
/// If address contains a UTF-8 encoded IDN (internationalized
/// domain name), the domain name will be encoded first using
/// Punycode.
///
/// Throws a HostNotFoundException if a host with the given
/// name cannot be found.
///
/// Throws a NoAddressFoundException if no address can be
/// found for the hostname.
///
/// Throws a DNSException in case of a general DNS error.
///
/// Throws an IOException in case of any other error.
static IPAddress resolveOne(const std::string& address);
/// Convenience method that calls resolve(address) and returns
/// the first address from the HostInfo.
static HostEntry thisHost();
/// Returns a HostEntry object containing the DNS information
/// for this host.
///
/// Throws a HostNotFoundException if DNS information
/// for this host cannot be found.
///
/// Throws a NoAddressFoundException if no address can be
/// found for this host.
///
/// Throws a DNSException in case of a general DNS error.
///
/// Throws an IOException in case of any other error.
static void reload();
/// Reloads the resolver configuration.
///
/// This method will call res_init() if the Net library
/// has been compiled with -DPOCO_HAVE_LIBRESOLV. Otherwise
/// it will do nothing.
static std::string hostName();
/// Returns the host name of this host.
static bool isIDN(const std::string& hostname);
/// Returns true if the given hostname is an internationalized
/// domain name (IDN) containing non-ASCII characters, otherwise false.
///
/// The IDN must be UTF-8 encoded.
static bool isEncodedIDN(const std::string& hostname);
/// Returns true if the given hostname is an Punycode-encoded
/// internationalized domain name (IDN), otherwise false.
///
/// An encoded IDN starts with the character sequence "xn--".
static std::string encodeIDN(const std::string& idn);
/// Encodes the given IDN (internationalized domain name), which must
/// be in UTF-8 encoding.
///
/// The resulting string will be encoded according to Punycode.
static std::string decodeIDN(const std::string& encodedIDN);
/// Decodes the given Punycode-encoded IDN (internationalized domain name).
///
/// The resulting string will be UTF-8 encoded.
protected:
static int lastError();
/// Returns the code of the last error.
static void error(int code, const std::string& arg);
/// Throws an exception according to the error code.
static void aierror(int code, const std::string& arg);
/// Throws an exception according to the getaddrinfo() error code.
static std::string encodeIDNLabel(const std::string& idn);
/// Encodes the given IDN (internationalized domain name) label, which must
/// be in UTF-8 encoding.
///
/// The resulting string will be encoded according to Punycode.
static std::string decodeIDNLabel(const std::string& encodedIDN);
/// Decodes the given Punycode-encoded IDN (internationalized domain name) label.
///
/// The resulting string will be UTF-8 encoded.
};
} } // namespace Poco::Net
#endif // Net_DNS_INCLUDED

250
vendor/POCO/Net/include/Poco/Net/DatagramSocket.h vendored Normal file
View File

@ -0,0 +1,250 @@
//
// DatagramSocket.h
//
// Library: Net
// Package: Sockets
// Module: DatagramSocket
//
// Definition of the DatagramSocket class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_DatagramSocket_INCLUDED
#define Net_DatagramSocket_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/Socket.h"
#include "Poco/Buffer.h"
namespace Poco {
namespace Net {
class Net_API DatagramSocket: public Socket
/// This class provides an interface to an
/// UDP stream socket.
{
public:
DatagramSocket();
/// Creates an unconnected, unbound datagram socket.
///
/// Before the datagram socket can be used, bind(),
/// bind6() or connect() must be called.
///
/// Notice: The behavior of this constructor has changed
/// in release 2.0. Previously, the constructor created
/// an unbound IPv4 datagram socket.
explicit DatagramSocket(SocketAddress::Family family);
/// Creates an unconnected datagram socket.
///
/// The socket will be created for the
/// given address family.
DatagramSocket(const SocketAddress& address, bool reuseAddress = false);
/// Creates a datagram socket and binds it
/// to the given address.
///
/// Depending on the address family, the socket
/// will be either an IPv4 or an IPv6 socket.
DatagramSocket(const Socket& socket);
/// Creates the DatagramSocket with the SocketImpl
/// from another socket. The SocketImpl must be
/// a DatagramSocketImpl, otherwise an InvalidArgumentException
/// will be thrown.
~DatagramSocket();
/// Destroys the DatagramSocket.
DatagramSocket& operator = (const Socket& socket);
/// Assignment operator.
///
/// Releases the socket's SocketImpl and
/// attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
void connect(const SocketAddress& address);
/// Restricts incoming and outgoing
/// packets to the specified address.
///
/// Calls to connect() cannot come before calls to bind().
void bind(const SocketAddress& address, bool reuseAddress = false);
/// Bind a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// Calls to connect cannot() come before calls to bind().
void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
/// Bind a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reusePort is true, sets the SO_REUSEPORT
/// socket option.
///
/// Calls to connect cannot() come before calls to bind().
int sendBytes(const void* buffer, int length, int flags = 0);
/// Sends the contents of the given buffer through
/// the socket.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
///
/// The flags parameter can be used to pass system-defined flags
/// for send() like MSG_DONTROUTE.
int sendBytes(const SocketBufVec& buffer, int flags = 0);
/// Sends the contents of the given buffers through
/// the socket.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
///
/// The flags parameter can be used to pass system-defined flags
/// for send() like MSG_DONTROUTE.
int receiveBytes(void* buffer, int length, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
///
/// Returns the number of bytes received.
///
/// The flags parameter can be used to pass system-defined flags
/// for recv() like MSG_PEEK.
int receiveBytes(SocketBufVec& buffer, int flags = 0);
/// Receives data from the socket and stores it in buffers.
///
/// Returns the number of bytes received.
///
/// The flags parameter can be used to pass system-defined flags
/// for recv() like MSG_PEEK.
int receiveBytes(Poco::Buffer<char>& buffer, int flags = 0, const Poco::Timespan& timeout = 100000);
/// Receives data from the socket and stores it in buffers.
///
/// Returns the number of bytes received.
///
/// The flags parameter can be used to pass system-defined flags
/// for recv() like MSG_PEEK.
int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
/// Sends the contents of the given buffer through
/// the socket to the given address.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
///
/// The flags parameter can be used to pass system-defined flags
/// for sendto() like MSG_DONTROUTE.
int sendTo(const SocketBufVec& buffers, const SocketAddress& address, int flags = 0);
/// Sends the contents of the given buffers through
/// the socket to the given address.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
///
/// The flags parameter can be used to pass system-defined flags
/// for sendto() like MSG_DONTROUTE.
int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
/// Stores the address of the sender in address.
///
/// Returns the number of bytes received.
///
/// The flags parameter can be used to pass system-defined flags
/// for recvfrom() like MSG_PEEK.
int receiveFrom(void* buffer, int length, struct sockaddr** ppSA, poco_socklen_t** ppSALen, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
/// Stores the native address of the sender in
/// ppSA, and the length of native address in ppSALen.
///
/// Returns the number of bytes received.
///
/// The flags parameter can be used to pass system-defined flags
/// for recvfrom() like MSG_PEEK.
int receiveFrom(SocketBufVec& buffers, SocketAddress& address, int flags = 0);
/// Receives data from the socket and stores it
/// in buffers. Up to total length of all buffers
/// are received.
/// Stores the address of the sender in address.
///
/// Returns the number of bytes received.
///
/// The flags parameter can be used to pass system-defined flags
/// for recvfrom() like MSG_PEEK.
int receiveFrom(SocketBufVec& buffers, struct sockaddr** ppSA, poco_socklen_t** ppSALen, int flags = 0);
/// Receives data from the socket and stores it
/// in buffers.
/// Stores the native address of the sender in
/// ppSA, and the length of native address in ppSALen.
///
/// Returns the number of bytes received.
///
/// The flags parameter can be used to pass system-defined flags
/// for recvfrom() like MSG_PEEK.
void setBroadcast(bool flag);
/// Sets the value of the SO_BROADCAST socket option.
///
/// Setting this flag allows sending datagrams to
/// the broadcast address.
bool getBroadcast() const;
/// Returns the value of the SO_BROADCAST socket option.
protected:
DatagramSocket(SocketImpl* pImpl);
/// Creates the Socket and attaches the given SocketImpl.
/// The socket takes ownership of the SocketImpl.
///
/// The SocketImpl must be a StreamSocketImpl, otherwise
/// an InvalidArgumentException will be thrown.
};
//
// inlines
//
inline void DatagramSocket::setBroadcast(bool flag)
{
impl()->setBroadcast(flag);
}
inline bool DatagramSocket::getBroadcast() const
{
return impl()->getBroadcast();
}
} } // namespace Poco::Net
#endif // Net_DatagramSocket_INCLUDED

55
vendor/POCO/Net/include/Poco/Net/DatagramSocketImpl.h vendored Normal file
View File

@ -0,0 +1,55 @@
//
// DatagramSocketImpl.h
//
// Library: Net
// Package: Sockets
// Module: DatagramSocketImpl
//
// Definition of the DatagramSocketImpl class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_DatagramSocketImpl_INCLUDED
#define Net_DatagramSocketImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketImpl.h"
namespace Poco {
namespace Net {
class Net_API DatagramSocketImpl: public SocketImpl
/// This class implements an UDP socket.
{
public:
DatagramSocketImpl();
/// Creates an unconnected, unbound datagram socket.
explicit DatagramSocketImpl(SocketAddress::Family family);
/// Creates an unconnected datagram socket.
///
/// The socket will be created for the
/// given address family.
DatagramSocketImpl(poco_socket_t sockfd);
/// Creates a StreamSocketImpl using the given native socket.
protected:
void init(int af);
~DatagramSocketImpl();
};
} } // namespace Poco::Net
#endif // Net_DatagramSocketImpl_INCLUDED

211
vendor/POCO/Net/include/Poco/Net/DialogSocket.h vendored Normal file
View File

@ -0,0 +1,211 @@
//
// DialogSocket.h
//
// Library: Net
// Package: Sockets
// Module: DialogSocket
//
// Definition of the DialogSocket class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_DialogSocket_INCLUDED
#define Net_DialogSocket_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/StreamSocket.h"
#include <cstdlib>
namespace Poco {
namespace Net {
class Net_API DialogSocket: public StreamSocket
/// DialogSocket is a subclass of StreamSocket that
/// can be used for implementing request-response
/// based client server connections.
///
/// A request is always a single-line command terminated
/// by CR-LF.
///
/// A response can either be a single line of text terminated
/// by CR-LF, or multiple lines of text in the format used
/// by the FTP and SMTP protocols.
///
/// Limited support for the TELNET protocol (RFC 854) is
/// available.
///
/// Warning: Do not call receiveBytes() on a DialogSocket.
/// Due to internal buffering in DialogSocket, receiveBytes()
/// may return an unexpected result and interfere with
/// DialogSocket's buffering. Use receiveRawBytes() instead.
{
public:
DialogSocket();
/// Creates an unconnected stream socket.
///
/// Before sending or receiving data, the socket
/// must be connected with a call to connect().
explicit DialogSocket(const SocketAddress& address);
/// Creates a stream socket and connects it to
/// the socket specified by address.
DialogSocket(const Socket& socket);
/// Creates the DialogSocket with the SocketImpl
/// from another socket. The SocketImpl must be
/// a StreamSocketImpl, otherwise an InvalidArgumentException
/// will be thrown.
DialogSocket(const DialogSocket& socket);
/// Creates the DialogSocket as copy of another dialog socket.
~DialogSocket();
/// Destroys the DialogSocket.
DialogSocket& operator = (const Socket& socket);
/// Assignment operator.
///
/// Releases the socket's SocketImpl and
/// attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
DialogSocket& operator = (const DialogSocket& socket);
/// Assignment operator.
void sendByte(unsigned char ch);
/// Sends a single byte over the socket connection.
void sendString(const char* str);
/// Sends the given null-terminated string over
/// the socket connection.
void sendString(const std::string& str);
/// Sends the given string over the socket connection.
void sendMessage(const std::string& message);
/// Appends a CR-LF sequence to the message and sends it
/// over the socket connection.
void sendMessage(const std::string& message, const std::string& arg);
/// Concatenates message and arg, separated by a space, appends a
/// CR-LF sequence, and sends the result over the socket connection.
void sendMessage(const std::string& message, const std::string& arg1, const std::string& arg2);
/// Concatenates message and args, separated by a space, appends a
/// CR-LF sequence, and sends the result over the socket connection.
bool receiveMessage(std::string& message);
/// Receives a single-line message, terminated by CR-LF,
/// from the socket connection and appends it to response.
///
/// Returns true if a message has been read or false if
/// the connection has been closed by the peer.
int receiveStatusMessage(std::string& message);
/// Receives a single-line or multi-line response from
/// the socket connection. The format must be according to
/// one of the response formats specified in the FTP (RFC 959)
/// or SMTP (RFC 2821) specifications.
///
/// The first line starts with a 3-digit status code.
/// Following the status code is either a space character (' ' )
/// (in case of a single-line response) or a minus character ('-')
/// in case of a multi-line response. The following lines can have
/// a three-digit status code followed by a minus-sign and some
/// text, or some arbitrary text only. The last line again begins
/// with a three-digit status code (which must be the same as the
/// one in the first line), followed by a space and some arbitrary
/// text. All lines must be terminated by a CR-LF sequence.
///
/// The response contains all response lines, separated by a newline
/// character, including the status code. The status code is returned.
/// If the response line does not contain a status code, 0 is returned.
int get();
/// Reads one character from the connection.
///
/// Returns -1 (EOF_CHAR) if no more characters are available.
int peek();
/// Returns the character that would be returned by the next call
/// to get(), without actually extracting the character from the
/// buffer.
///
/// Returns -1 (EOF_CHAR) if no more characters are available.
int receiveRawBytes(void* buffer, int length);
/// Read up to length bytes from the connection and place
/// them into buffer. If there are data bytes in the internal
/// buffer, these bytes are returned first.
///
/// Use this member function instead of receiveBytes().
///
/// Returns the number of bytes read, which may be
/// less than requested.
void synch();
/// Sends a TELNET SYNCH signal over the connection.
///
/// According to RFC 854, a TELNET_DM char is sent
/// via sendUrgent().
void sendTelnetCommand(unsigned char command);
/// Sends a TELNET command sequence (TELNET_IAC followed
/// by the given command) over the connection.
void sendTelnetCommand(unsigned char command, unsigned char arg);
/// Sends a TELNET command sequence (TELNET_IAC followed
/// by the given command, followed by arg) over the connection.
enum TelnetCodes
{
TELNET_SE = 240,
TELNET_NOP = 241,
TELNET_DM = 242,
TELNET_BRK = 243,
TELNET_IP = 244,
TELNET_AO = 245,
TELNET_AYT = 246,
TELNET_EC = 247,
TELNET_EL = 248,
TELNET_GA = 249,
TELNET_SB = 250,
TELNET_WILL = 251,
TELNET_WONT = 252,
TELNET_DO = 253,
TELNET_DONT = 254,
TELNET_IAC = 255
};
protected:
void allocBuffer();
void refill();
bool receiveLine(std::string& line, std::size_t lineLengthLimit = 0);
int receiveStatusLine(std::string& line, std::size_t lineLengthLimit = 0);
private:
enum
{
RECEIVE_BUFFER_SIZE = 1024,
MAX_LINE_LENGTH = 4096,
EOF_CHAR = -1
};
char* _pBuffer;
char* _pNext;
char* _pEnd;
};
} } // namespace Poco::Net
#endif // Net_DialogSocket_INCLUDED

89
vendor/POCO/Net/include/Poco/Net/EscapeHTMLStream.h vendored Normal file
View File

@ -0,0 +1,89 @@
//
// EscapeHTMLStream.h
//
// Library: Net
// Package: HTTP
// Module: EscapeHTMLStream
//
// Definition of the EscapeHTMLStream class.
//
// Copyright (c) 1029, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_EscapeHTMLStream_INCLUDED
#define Net_EscapeHTMLStream_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/UnbufferedStreamBuf.h"
#include <ostream>
namespace Poco {
namespace Net {
class Net_API EscapeHTMLStreamBuf: public Poco::UnbufferedStreamBuf
/// This stream buffer replaces all occurrences of special HTML
/// characters < > " & with their respective character
/// entities &lt; &gt; &quot; &amp;.
{
public:
EscapeHTMLStreamBuf(std::ostream& ostr);
/// Creates the EscapeHTMLStreamBuf and connects it
/// to the given output stream.
~EscapeHTMLStreamBuf();
/// Destroys the EscapeHTMLStreamBuf.
protected:
int readFromDevice();
int writeToDevice(char c);
private:
std::ostream* _pOstr;
};
class Net_API EscapeHTMLIOS: public virtual std::ios
/// The base class for EscapeHTMLOutputStream.
{
public:
EscapeHTMLIOS(std::ostream& ostr);
/// Creates the MailIOS and connects it
/// to the given output stream.
~EscapeHTMLIOS();
/// Destroys the stream.
EscapeHTMLStreamBuf* rdbuf();
/// Returns a pointer to the underlying streambuf.
protected:
EscapeHTMLStreamBuf _buf;
};
class Net_API EscapeHTMLOutputStream: public EscapeHTMLIOS, public std::ostream
/// This stream replaces all occurrences of special HTML
/// characters < > " & with their respective character
/// entities &lt; &gt; &quot; &amp;.
{
public:
EscapeHTMLOutputStream(std::ostream& ostr);
/// Creates the MailOutputStream and connects it
/// to the given input stream.
~EscapeHTMLOutputStream();
/// Destroys the MailOutputStream.
};
} } // namespace Poco::Net
#endif // Net_EscapeHTMLStream_INCLUDED

425
vendor/POCO/Net/include/Poco/Net/FTPClientSession.h vendored Normal file
View File

@ -0,0 +1,425 @@
//
// FTPClientSession.h
//
// Library: Net
// Package: FTP
// Module: FTPClientSession
//
// Definition of the FTPClientSession class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_FTPClientSession_INCLUDED
#define Net_FTPClientSession_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/DialogSocket.h"
#include "Poco/Timespan.h"
#include <istream>
#include <ostream>
namespace Poco {
namespace Net {
class SocketStream;
class Net_API FTPClientSession
/// This class implements an File Transfer Protocol
/// (FTP, RFC 959) client.
///
/// Most of the features of the FTP protocol, as specified
/// in RFC 959, are supported. Not supported are EBCDIC and
/// LOCAL data types and format control and structured files.
///
/// Also supported are the EPRT and EPSV commands from
/// RFC 1738 (FTP Extensions for IPv6 and NAT).
/// The client will first attempt to use the EPRT and EPSV
/// commands. If the server does not supports these commands,
/// the client will fall back to PORT and PASV.
{
public:
enum
{
FTP_PORT = 21
};
enum FileType
{
TYPE_TEXT, /// TYPE A (ASCII)
TYPE_BINARY /// TYPE I (Image/binary data)
};
FTPClientSession();
/// Creates an FTPClientSession.
///
/// Passive mode will be used for data transfers.
FTPClientSession(const StreamSocket& socket, bool readWelcomeMessage = true);
/// Creates an FTPClientSession using the given
/// connected socket for the control connection.
///
/// Passive mode will be used for data transfers.
FTPClientSession(const std::string& host, Poco::UInt16 port = FTP_PORT, const std::string& username = "", const std::string& password = "");
/// Creates an FTPClientSession using a socket connected
/// to the given host and port. If username is supplied,
/// login is attempted.
///
/// Passive mode will be used for data transfers.
virtual ~FTPClientSession();
/// Destroys the FTPClientSession.
void setTimeout(const Poco::Timespan& timeout);
/// Sets the timeout for socket operations.
Poco::Timespan getTimeout() const;
/// Returns the timeout for socket operations.
void setPassive(bool flag, bool useRFC1738 = true);
/// Enables (default) or disables FTP passive mode for this session.
///
/// If useRFC1738 is true (the default), the RFC 1738
/// EPSV command is used (with a fallback to PASV if EPSV fails)
/// for switching to passive mode. The same applies to
/// EPRT and PORT for active connections.
bool getPassive() const;
/// Returns true iff passive mode is enabled for this connection.
virtual void open(const std::string& host, Poco::UInt16 port, const std::string& username = "", const std::string& password = "");
/// Opens the FTP connection to the given host and port.
/// If username is supplied, login is attempted.
virtual void login(const std::string& username, const std::string& password);
/// Authenticates the user against the FTP server. Must be
/// called before any other commands (except QUIT) can be sent.
///
/// Sends a USER command followed by a PASS command with the
/// respective arguments to the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
void logout();
/// Logs out from the server by sending a QUIT command. Any transfer
/// that's in progress is ended. The control connection is kept
/// open.
void close();
/// Sends a QUIT command and closes the connection to the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
std::string systemType();
/// Returns the system type of the FTP server.
///
/// Sends a SYST command to the server and returns the result.
void setFileType(FileType type);
/// Sets the file type for transferring files.
///
/// Sends a TYPE command with a corresponding argument to the
/// server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
FileType getFileType() const;
/// Returns the file type for transferring files.
void setWorkingDirectory(const std::string& path);
/// Changes the current working directory on the server.
///
/// Sends a CWD command with the given path as argument to the
/// server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
std::string getWorkingDirectory();
/// Returns the current working directory on the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
void cdup();
/// Moves one directory up from the current working directory
/// on the server.
///
/// Sends a CDUP command to the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
void rename(const std::string& oldName, const std::string& newName);
/// Renames the file on the server given by oldName to newName.
///
/// Sends a RNFR command, followed by a RNTO command to the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
void remove(const std::string& path);
/// Deletes the file specified by path on the server.
///
/// Sends a DELE command with path as argument to the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
void createDirectory(const std::string& path);
/// Creates a new directory with the given path on the server.
///
/// Sends a MKD command with path as argument to the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
void removeDirectory(const std::string& path);
/// Removes the directory specified by path from the server.
///
/// Sends a RMD command with path as argument to the server.
///
/// Throws a FTPException in case of a FTP-specific error, or a
/// NetException in case of a general network communication failure.
std::istream& beginDownload(const std::string& path);
/// Starts downloading the file with the given name.
/// After all data has been read from the returned stream,
/// endDownload() must be called to finish the download.
///
/// A stream for reading the file's content is returned.
/// The stream is valid until endDownload() is called.
///
/// Creates a data connection between the client and the
/// server. If passive mode is on, then the server waits for
/// a connection request from the client. Otherwise, the
/// client waits for a connection request from the server.
/// After establishing the data connection, a SocketStream
/// for transferring the data is created.
///
/// If ASCII transfer mode is selected, the caller is
/// responsible for converting the received data to
/// the native text file format.
/// The InputLineEndingConverter class from the Foundation
/// library can be used for that purpose.
void endDownload();
/// Must be called to complete a download initiated with
/// beginDownload().
std::ostream& beginUpload(const std::string& path);
/// Starts uploading the file with the given name.
/// After all data has been written to the returned stream,
/// endUpload() must be called to finish the upload.
///
/// A stream for reading the file's content is returned.
/// The stream is valid until endUpload() is called.
///
/// Creates a data connection between the client and the
/// server. If passive mode is on, then the server waits for
/// a connection request from the client. Otherwise, the
/// client waits for a connection request from the server.
/// After establishing the data connection, a SocketStream
/// for transferring the data is created.
///
/// If ASCII transfer mode is selected, the caller is
/// responsible for converting the data to be sent
/// into network (CR-LF line endings) format.
/// The OutputLineEndingConverter class from the Foundation
/// library can be used for that purpose.
void endUpload();
/// Must be called to complete an upload initiated with
/// beginUpload().
std::istream& beginList(const std::string& path = "", bool extended = false);
/// Starts downloading a directory listing.
/// After all data has been read from the returned stream,
/// endList() must be called to finish the download.
///
/// A stream for reading the directory data is returned.
/// The stream is valid until endList() is called.
///
/// Optionally, a path to a directory or file can be specified.
/// According to the FTP protocol, if a path to a filename is
/// given, only information for the specific file is returned.
/// If a path to a directory is given, a listing of that directory
/// is returned. If no path is given, a listing of the current
/// working directory is returned.
///
/// If extended is false, only a filenames (one per line) are
/// returned. Otherwise, a full directory listing including
/// file attributes is returned. The format of this listing
/// depends on the FTP server. No attempt is made to interpret
/// this data.
///
/// Creates a data connection between the client and the
/// server. If passive mode is on, then the server waits for
/// a connection request from the client. Otherwise, the
/// client waits for a connection request from the server.
/// After establishing the data connection, a SocketStream
/// for transferring the data is created.
void endList();
/// Must be called to complete a directory listing download
/// initiated with beginList().
void abort();
/// Aborts the download or upload currently in progress.
///
/// Sends a TELNET IP/SYNCH sequence, followed by an ABOR
/// command to the server.
///
/// A separate call to endDownload() or endUpload() is
/// not necessary.
int sendCommand(const std::string& command, std::string& response);
/// Sends the given command verbatim to the server
/// and waits for a response.
int sendCommand(const std::string& command, const std::string& arg, std::string& response);
/// Sends the given command verbatim to the server
/// and waits for a response.
bool isOpen() const;
/// Returns true if the connection with FTP server is opened.
bool isLoggedIn() const;
/// Returns true if the session is logged in.
bool isSecure() const;
/// Returns true if the session is FTPS.
const std::string& welcomeMessage();
/// Returns the welcome message.
protected:
virtual void receiveServerReadyReply();
enum StatusClass
{
FTP_POSITIVE_PRELIMINARY = 1,
FTP_POSITIVE_COMPLETION = 2,
FTP_POSITIVE_INTERMEDIATE = 3,
FTP_TRANSIENT_NEGATIVE = 4,
FTP_PERMANENT_NEGATIVE = 5
};
enum
{
DEFAULT_TIMEOUT = 30000000 // 30 seconds default timeout for socket operations
};
static bool isPositivePreliminary(int status);
static bool isPositiveCompletion(int status);
static bool isPositiveIntermediate(int status);
static bool isTransientNegative(int status);
static bool isPermanentNegative(int status);
std::string extractPath(const std::string& response);
virtual StreamSocket establishDataConnection(const std::string& command, const std::string& arg);
StreamSocket activeDataConnection(const std::string& command, const std::string& arg);
StreamSocket passiveDataConnection(const std::string& command, const std::string& arg);
void sendPortCommand(const SocketAddress& addr);
SocketAddress sendPassiveCommand();
bool sendEPRT(const SocketAddress& addr);
void sendPORT(const SocketAddress& addr);
bool sendEPSV(SocketAddress& addr);
void sendPASV(SocketAddress& addr);
void parseAddress(const std::string& str, SocketAddress& addr);
void parseExtAddress(const std::string& str, SocketAddress& addr);
void endTransfer();
DialogSocket* _pControlSocket = nullptr;
SocketStream* _pDataStream = nullptr;
private:
FTPClientSession(const FTPClientSession&);
FTPClientSession& operator = (const FTPClientSession&);
std::string _host;
Poco::UInt16 _port = FTP_PORT;
bool _passiveMode = true;
FileType _fileType = TYPE_BINARY;
bool _supports1738 = true;
bool _serverReady = false;
bool _isLoggedIn = false;
Poco::Timespan _timeout = DEFAULT_TIMEOUT;
std::string _welcomeMessage;
Poco::FastMutex _wmMutex;
};
//
// inlines
//
inline bool FTPClientSession::isPositivePreliminary(int status)
{
return status/100 == FTP_POSITIVE_PRELIMINARY;
}
inline bool FTPClientSession::isPositiveCompletion(int status)
{
return status/100 == FTP_POSITIVE_COMPLETION;
}
inline bool FTPClientSession::isPositiveIntermediate(int status)
{
return status/100 == FTP_POSITIVE_INTERMEDIATE;
}
inline bool FTPClientSession::isTransientNegative(int status)
{
return status/100 == FTP_TRANSIENT_NEGATIVE;
}
inline bool FTPClientSession::isPermanentNegative(int status)
{
return status/100 == FTP_PERMANENT_NEGATIVE;
}
inline bool FTPClientSession::isOpen() const
{
return _pControlSocket != 0;
}
inline bool FTPClientSession::isLoggedIn() const
{
return _isLoggedIn;
}
inline bool FTPClientSession::isSecure() const
{
return false;
}
inline const std::string& FTPClientSession::welcomeMessage()
{
Poco::FastMutex::ScopedLock lock(_wmMutex);
return _welcomeMessage;
}
} } // namespace Poco::Net
#endif // Net_FTPClientSession_INCLUDED

120
vendor/POCO/Net/include/Poco/Net/FTPStreamFactory.h vendored Normal file
View File

@ -0,0 +1,120 @@
//
// FTPStreamFactory.h
//
// Library: Net
// Package: FTP
// Module: FTPStreamFactory
//
// Definition of the FTPStreamFactory class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_FTPStreamFactory_INCLUDED
#define Net_FTPStreamFactory_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPSession.h"
#include "Poco/URIStreamFactory.h"
namespace Poco {
namespace Net {
class Net_API FTPPasswordProvider
/// The base class for all password providers.
/// An instance of a subclass of this class can be
/// registered with the FTPStreamFactory to
/// provide a password.
{
public:
virtual std::string password(const std::string& username, const std::string& host) = 0;
/// Provide the password for the given user on the given host.
protected:
FTPPasswordProvider();
virtual ~FTPPasswordProvider();
};
class Net_API FTPStreamFactory: public Poco::URIStreamFactory
/// An implementation of the URIStreamFactory interface
/// that handles File Transfer Protocol (ftp) URIs.
///
/// The URI's path may end with an optional type specification
/// in the form (;type=<typecode>), where <typecode> is
/// one of a, i or d. If type=a, the file identified by the path
/// is transferred in ASCII (text) mode. If type=i, the file
/// is transferred in Image (binary) mode. If type=d, a directory
/// listing (in NLST format) is returned. This corresponds with
/// the FTP URL format specified in RFC 1738.
///
/// If the URI does not contain a username and password, the
/// username "anonymous" and the password "poco@localhost".
{
public:
FTPStreamFactory();
/// Creates the FTPStreamFactory.
~FTPStreamFactory();
/// Destroys the FTPStreamFactory.
std::istream* open(const Poco::URI& uri);
/// Creates and opens a HTTP stream for the given URI.
/// The URI must be a ftp://... URI.
///
/// Throws a NetException if anything goes wrong.
static void setAnonymousPassword(const std::string& password);
/// Sets the password used for anonymous FTP.
///
/// WARNING: Setting the anonymous password is not
/// thread-safe, so it's best to call this method
/// during application initialization, before the
/// FTPStreamFactory is used for the first time.
static const std::string& getAnonymousPassword();
/// Returns the password used for anonymous FTP.
static void setPasswordProvider(FTPPasswordProvider* pProvider);
/// Sets the FTPPasswordProvider. If NULL is given,
/// no password provider is used.
///
/// WARNING: Setting the password provider is not
/// thread-safe, so it's best to call this method
/// during application initialization, before the
/// FTPStreamFactory is used for the first time.
static FTPPasswordProvider* getPasswordProvider();
/// Returns the FTPPasswordProvider currently in use,
/// or NULL if no one has been set.
static void registerFactory();
/// Registers the FTPStreamFactory with the
/// default URIStreamOpener instance.
static void unregisterFactory();
/// Unregisters the FTPStreamFactory with the
/// default URIStreamOpener instance.
protected:
static void splitUserInfo(const std::string& userInfo, std::string& username, std::string& password);
static void getUserInfo(const Poco::URI& uri, std::string& username, std::string& password);
static void getPathAndType(const Poco::URI& uri, std::string& path, char& type);
private:
static std::string _anonymousPassword;
static FTPPasswordProvider* _pPasswordProvider;
};
} } // namespace Poco::Net
#endif // Net_FTPStreamFactory_INCLUDED

77
vendor/POCO/Net/include/Poco/Net/FilePartSource.h vendored Normal file
View File

@ -0,0 +1,77 @@
//
// FilePartSource.h
//
// Library: Net
// Package: Messages
// Module: FilePartSource
//
// Definition of the FilePartSource class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_FilePartSource_INCLUDED
#define Net_FilePartSource_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/PartSource.h"
#include "Poco/FileStream.h"
namespace Poco {
namespace Net {
class Net_API FilePartSource: public PartSource
/// An implementation of PartSource for
/// plain files.
{
public:
FilePartSource(const std::string& path);
/// Creates the FilePartSource for the given path.
///
/// The MIME type is set to application/octet-stream.
///
/// Throws an OpenFileException if the file cannot be opened.
FilePartSource(const std::string& path, const std::string& mediaType);
/// Creates the FilePartSource for the given
/// path and MIME type.
///
/// Throws an OpenFileException if the file cannot be opened.
FilePartSource(const std::string& path, const std::string& filename, const std::string& mediaType);
/// Creates the FilePartSource for the given
/// path and MIME type. The given filename is
/// used as part filename (see filename()) only.
///
/// Throws an OpenFileException if the file cannot be opened.
~FilePartSource();
/// Destroys the FilePartSource.
std::istream& stream();
/// Returns a file input stream for the given file.
const std::string& filename() const;
/// Returns the filename portion of the path.
std::streamsize getContentLength() const;
/// Returns the file size.
private:
std::string _path;
std::string _filename;
Poco::FileInputStream _istr;
};
} } // namespace Poco::Net
#endif // Net_FilePartSource_INCLUDED

272
vendor/POCO/Net/include/Poco/Net/HTMLForm.h vendored Normal file
View File

@ -0,0 +1,272 @@
//
// HTMLForm.h
//
// Library: Net
// Package: HTML
// Module: HTMLForm
//
// Definition of the HTMLForm class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTMLForm_INCLUDED
#define Net_HTMLForm_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/NameValueCollection.h"
#include <ostream>
#include <istream>
#include <vector>
namespace Poco {
namespace Net {
class HTTPRequest;
class PartHandler;
class PartSource;
class Net_API HTMLForm: public NameValueCollection
/// HTMLForm is a helper class for working with HTML forms,
/// both on the client and on the server side.
///
/// The maximum number of form fields can be restricted
/// by calling setFieldLimit(). This is useful to
/// defend against certain kinds of denial-of-service
/// attacks. The limit is only enforced when parsing
/// form data from a stream or string, not when adding
/// form fields programmatically. The default limit is 100.
{
public:
enum Options
{
OPT_USE_CONTENT_LENGTH = 0x01
/// Don't use Chunked Transfer-Encoding for multipart requests.
};
HTMLForm();
/// Creates an empty HTMLForm and sets the
/// encoding to "application/x-www-form-urlencoded".
explicit HTMLForm(const std::string& encoding);
/// Creates an empty HTMLForm that uses
/// the given encoding.
///
/// Encoding must be either "application/x-www-form-urlencoded"
/// (which is the default) or "multipart/form-data".
HTMLForm(const HTTPRequest& request, std::istream& requestBody, PartHandler& handler);
/// Creates a HTMLForm from the given HTTP request.
///
/// Uploaded files are passed to the given PartHandler.
HTMLForm(const HTTPRequest& request, std::istream& requestBody);
/// Creates a HTMLForm from the given HTTP request.
///
/// Uploaded files are silently discarded.
explicit HTMLForm(const HTTPRequest& request);
/// Creates a HTMLForm from the given HTTP request.
///
/// The request must be a GET request and the form data
/// must be in the query string (URL encoded).
///
/// For POST requests, you must use one of the constructors
/// taking an additional input stream for the request body.
~HTMLForm();
/// Destroys the HTMLForm.
void setEncoding(const std::string& encoding);
/// Sets the encoding used for posting the form.
///
/// Encoding must be either "application/x-www-form-urlencoded"
/// (which is the default) or "multipart/form-data".
const std::string& getEncoding() const;
/// Returns the encoding used for posting the form.
void addPart(const std::string& name, PartSource* pSource);
/// Adds an part/attachment (file upload) to the form.
///
/// The form takes ownership of the PartSource and deletes it
/// when it is no longer needed.
///
/// The part will only be sent if the encoding
/// set for the form is "multipart/form-data"
void load(const HTTPRequest& request, std::istream& requestBody, PartHandler& handler);
/// Reads the form data from the given HTTP request.
///
/// Uploaded files are passed to the given PartHandler.
void load(const HTTPRequest& request, std::istream& requestBody);
/// Reads the form data from the given HTTP request.
///
/// Uploaded files are silently discarded.
void load(const HTTPRequest& request);
/// Reads the form data from the given HTTP request.
///
/// The request must be a GET request and the form data
/// must be in the query string (URL encoded).
///
/// For POST requests, you must use one of the overloads
/// taking an additional input stream for the request body.
void read(std::istream& istr, PartHandler& handler);
/// Reads the form data from the given input stream.
///
/// The form data read from the stream must be
/// in the encoding specified for the form.
///
/// Note that read() does not clear the form before
/// reading the new values.
void read(std::istream& istr);
/// Reads the URL-encoded form data from the given input stream.
///
/// Note that read() does not clear the form before
/// reading the new values.
void read(const std::string& queryString);
/// Reads the form data from the given HTTP query string.
///
/// Note that read() does not clear the form before
/// reading the new values.
void prepareSubmit(HTTPRequest& request, int options = 0);
/// Fills out the request object for submitting the form.
///
/// If the request method is GET, the encoded form is appended to the
/// request URI as query string. Otherwise (the method is
/// POST), the form's content type is set to the form's encoding.
/// The form's parameters must be written to the
/// request body separately, with a call to write.
/// If the request's HTTP version is HTTP/1.0:
/// - persistent connections are disabled
/// - the content transfer encoding is set to identity encoding
/// Otherwise, if the request's HTTP version is HTTP/1.1:
/// - the request's persistent connection state is left unchanged
/// - the content transfer encoding is set to chunked, unless
/// the OPT_USE_CONTENT_LENGTH is given in options
///
/// Note: Not using chunked transfer encoding for multipart forms
/// degrades performance, as the request content must be generated
/// twice, first to determine its size, then to actually send it.
std::streamsize calculateContentLength();
/// Calculate the content length for the form.
/// May be UNKNOWN_CONTENT_LENGTH if not possible
/// to calculate
void write(std::ostream& ostr, const std::string& boundary);
/// Writes the form data to the given output stream,
/// using the specified encoding.
void write(std::ostream& ostr);
/// Writes the form data to the given output stream,
/// using the specified encoding.
const std::string& boundary() const;
/// Returns the MIME boundary used for writing
/// multipart form data.
int getFieldLimit() const;
/// Returns the maximum number of header fields
/// allowed.
///
/// See setFieldLimit() for more information.
void setFieldLimit(int limit);
/// Sets the maximum number of header fields
/// allowed. This limit is used to defend certain
/// kinds of denial-of-service attacks.
/// Specify 0 for unlimited (not recommended).
///
/// The default limit is 100.
void setValueLengthLimit(int limit);
/// Sets the maximum size for form field values
/// stored as strings.
int getValueLengthLimit() const;
/// Returns the maximum size for form field values
/// stored as strings.
static const std::string ENCODING_URL; /// "application/x-www-form-urlencoded"
static const std::string ENCODING_MULTIPART; /// "multipart/form-data"
static const int UNKNOWN_CONTENT_LENGTH;
protected:
void readUrl(std::istream& istr);
void readMultipart(std::istream& istr, PartHandler& handler);
void writeUrl(std::ostream& ostr);
void writeMultipart(std::ostream& ostr);
private:
HTMLForm(const HTMLForm&);
HTMLForm& operator = (const HTMLForm&);
enum Limits
{
DFL_FIELD_LIMIT = 100,
MAX_NAME_LENGTH = 1024,
DFL_MAX_VALUE_LENGTH = 256*1024
};
struct Part
{
std::string name;
PartSource* pSource;
};
typedef std::vector<Part> PartVec;
int _fieldLimit;
int _valueLengthLimit;
std::string _encoding;
std::string _boundary;
PartVec _parts;
};
//
// inlines
//
inline const std::string& HTMLForm::getEncoding() const
{
return _encoding;
}
inline const std::string& HTMLForm::boundary() const
{
return _boundary;
}
inline int HTMLForm::getFieldLimit() const
{
return _fieldLimit;
}
inline int HTMLForm::getValueLengthLimit() const
{
return _valueLengthLimit;
}
} } // namespace Poco::Net
#endif // Net_HTMLForm_INCLUDED

107
vendor/POCO/Net/include/Poco/Net/HTTPAuthenticationParams.h vendored Normal file
View File

@ -0,0 +1,107 @@
//
// HTTPAuthenticationParams.h
//
// Library: Net
// Package: HTTP
// Module: HTTPAuthenticationParams
//
// Definition of the HTTPAuthenticationParams class.
//
// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPAuthenticationParams_INCLUDED
#define Net_HTTPAuthenticationParams_INCLUDED
#include "Poco/Net/NameValueCollection.h"
namespace Poco {
namespace Net {
class HTTPRequest;
class HTTPResponse;
class Net_API HTTPAuthenticationParams: public NameValueCollection
/// Collection of name-value pairs of HTTP authentication header (i.e.
/// "realm", "qop", "nonce" in case of digest authentication header).
///
/// For NTLM, the base64-encoded NTLM message is available from
/// the "NTLM" property.
{
public:
HTTPAuthenticationParams();
/// Creates an empty authentication parameters collection.
explicit HTTPAuthenticationParams(const std::string& authInfo);
/// See fromAuthInfo() documentation.
explicit HTTPAuthenticationParams(const HTTPRequest& request);
/// See fromRequest() documentation.
HTTPAuthenticationParams(const HTTPResponse& response, const std::string& header = WWW_AUTHENTICATE);
/// See fromResponse() documentation.
virtual ~HTTPAuthenticationParams();
/// Destroys the HTTPAuthenticationParams.
HTTPAuthenticationParams& operator = (const HTTPAuthenticationParams& authParams);
/// Assigns the content of another HTTPAuthenticationParams.
void fromAuthInfo(const std::string& authInfo);
/// Creates an HTTPAuthenticationParams by parsing authentication
/// information.
void fromRequest(const HTTPRequest& request);
/// Extracts authentication information from the request and creates
/// HTTPAuthenticationParams by parsing it.
///
/// Throws a NotAuthenticatedException if no authentication
/// information is contained in request.
/// Throws a InvalidArgumentException if authentication scheme is
/// unknown or invalid.
void fromResponse(const HTTPResponse& response, const std::string& header = WWW_AUTHENTICATE);
/// Extracts authentication information from the response and creates
/// HTTPAuthenticationParams by parsing it.
///
/// Throws a NotAuthenticatedException if no authentication
/// information is contained in response.
/// Throws a InvalidArgumentException if authentication scheme is
/// unknown or invalid.
void setRealm(const std::string& realm);
/// Sets the "realm" parameter to the provided string.
const std::string& getRealm() const;
/// Returns value of the "realm" parameter.
///
/// Throws NotFoundException is there is no "realm" set in the
/// HTTPAuthenticationParams.
std::string toString() const;
/// Formats the HTTPAuthenticationParams for inclusion in HTTP
/// request or response authentication header.
static const std::string REALM;
static const std::string NTLM;
static const std::string WWW_AUTHENTICATE;
static const std::string PROXY_AUTHENTICATE;
private:
void parse(std::string::const_iterator first, std::string::const_iterator last);
};
} } // namespace Poco::Net
#endif // Net_HTTPAuthenticationParams_INCLUDED

123
vendor/POCO/Net/include/Poco/Net/HTTPBasicCredentials.h vendored Normal file
View File

@ -0,0 +1,123 @@
//
// HTTPBasicCredentials.h
//
// Library: Net
// Package: HTTP
// Module: HTTPBasicCredentials
//
// Definition of the HTTPBasicCredentials class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPBasicCredentials_INCLUDED
#define Net_HTTPBasicCredentials_INCLUDED
#include "Poco/Net/Net.h"
namespace Poco {
namespace Net {
class HTTPRequest;
class Net_API HTTPBasicCredentials
/// This is a utility class for working with
/// HTTP Basic Authentication in HTTPRequest
/// objects.
{
public:
HTTPBasicCredentials();
/// Creates an empty HTTPBasicCredentials object.
HTTPBasicCredentials(const std::string& username, const std::string& password);
/// Creates a HTTPBasicCredentials object with the given username and password.
explicit HTTPBasicCredentials(const HTTPRequest& request);
/// Creates a HTTPBasicCredentials object with the authentication information
/// from the given request.
///
/// Throws a NotAuthenticatedException if the request does
/// not contain basic authentication information.
explicit HTTPBasicCredentials(const std::string& authInfo);
/// Creates a HTTPBasicCredentials object with the authentication information
/// in the given string. The authentication information can be extracted
/// from a HTTPRequest object by calling HTTPRequest::getCredentials().
~HTTPBasicCredentials();
/// Destroys the HTTPBasicCredentials.
void clear();
/// Clears both username and password.
void setUsername(const std::string& username);
/// Sets the username.
const std::string& getUsername() const;
/// Returns the username.
void setPassword(const std::string& password);
/// Sets the password.
const std::string& getPassword() const;
/// Returns the password.
bool empty() const;
/// Returns true if both username and password are empty, otherwise false.
void authenticate(HTTPRequest& request) const;
/// Adds authentication information to the given HTTPRequest.
void proxyAuthenticate(HTTPRequest& request) const;
/// Adds proxy authentication information to the given HTTPRequest.
static const std::string SCHEME;
protected:
void parseAuthInfo(const std::string& authInfo);
/// Extracts username and password from Basic authentication info
/// by base64-decoding authInfo and splitting the resulting
/// string at the ':' delimiter.
private:
HTTPBasicCredentials(const HTTPBasicCredentials&);
HTTPBasicCredentials& operator = (const HTTPBasicCredentials&);
std::string _username;
std::string _password;
};
//
// inlines
//
inline const std::string& HTTPBasicCredentials::getUsername() const
{
return _username;
}
inline const std::string& HTTPBasicCredentials::getPassword() const
{
return _password;
}
inline bool HTTPBasicCredentials::empty() const
{
return _username.empty() && _password.empty();
}
} } // namespace Poco::Net
#endif // Net_HTTPBasicCredentials_INCLUDED

36
vendor/POCO/Net/include/Poco/Net/HTTPBasicStreamBuf.h vendored Normal file
View File

@ -0,0 +1,36 @@
//
// HTTPBasicStreamBuf.h
//
// Library: Net
// Package: HTTP
// Module: HTTPBasicStreamBuf
//
// Definition of the HTTPBasicStreamBuf class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPBasicStreamBuf_INCLUDED
#define Net_HTTPBasicStreamBuf_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/BufferedStreamBuf.h"
#include "Poco/Net/HTTPBufferAllocator.h"
namespace Poco {
namespace Net {
using HTTPBasicStreamBuf = Poco::BasicBufferedStreamBuf<char, std::char_traits<char>, HTTPBufferAllocator>;
} } // namespace Poco::Net
#endif // Net_HTTPBasicStreamBuf_INCLUDED

50
vendor/POCO/Net/include/Poco/Net/HTTPBufferAllocator.h vendored Normal file
View File

@ -0,0 +1,50 @@
//
// HTTPBufferAllocator.h
//
// Library: Net
// Package: HTTP
// Module: HTTPBufferAllocator
//
// Definition of the HTTPBufferAllocator class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPBufferAllocator_INCLUDED
#define Net_HTTPBufferAllocator_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/MemoryPool.h"
#include <ios>
namespace Poco {
namespace Net {
class Net_API HTTPBufferAllocator
/// A BufferAllocator for HTTP streams.
{
public:
static char* allocate(std::streamsize size);
static void deallocate(char* ptr, std::streamsize size);
enum
{
BUFFER_SIZE = 4096
};
private:
static Poco::MemoryPool _pool;
};
} } // namespace Poco::Net
#endif // Net_HTTPBufferAllocator_INCLUDED

105
vendor/POCO/Net/include/Poco/Net/HTTPChunkedStream.h vendored Normal file
View File

@ -0,0 +1,105 @@
//
// HTTPChunkedStream.h
//
// Library: Net
// Package: HTTP
// Module: HTTPChunkedStream
//
// Definition of the HTTPChunkedStream class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPChunkedStream_INCLUDED
#define Net_HTTPChunkedStream_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPBasicStreamBuf.h"
#include "Poco/MemoryPool.h"
#include <cstddef>
#include <istream>
#include <ostream>
namespace Poco {
namespace Net {
class HTTPSession;
class Net_API HTTPChunkedStreamBuf: public HTTPBasicStreamBuf
/// This is the streambuf class used for reading and writing
/// HTTP message bodies in chunked transfer coding.
{
public:
using openmode = HTTPBasicStreamBuf::openmode;
HTTPChunkedStreamBuf(HTTPSession& session, openmode mode);
~HTTPChunkedStreamBuf();
void close();
protected:
int readFromDevice(char* buffer, std::streamsize length);
int writeToDevice(const char* buffer, std::streamsize length);
private:
HTTPSession& _session;
openmode _mode;
std::streamsize _chunk;
std::string _chunkBuffer;
};
class Net_API HTTPChunkedIOS: public virtual std::ios
/// The base class for HTTPInputStream.
{
public:
HTTPChunkedIOS(HTTPSession& session, HTTPChunkedStreamBuf::openmode mode);
~HTTPChunkedIOS();
HTTPChunkedStreamBuf* rdbuf();
protected:
HTTPChunkedStreamBuf _buf;
};
class Net_API HTTPChunkedInputStream: public HTTPChunkedIOS, public std::istream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPChunkedInputStream(HTTPSession& session);
~HTTPChunkedInputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
class Net_API HTTPChunkedOutputStream: public HTTPChunkedIOS, public std::ostream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPChunkedOutputStream(HTTPSession& session);
~HTTPChunkedOutputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
} } // namespace Poco::Net
#endif // Net_HTTPChunkedStream_INCLUDED

423
vendor/POCO/Net/include/Poco/Net/HTTPClientSession.h vendored Normal file
View File

@ -0,0 +1,423 @@
//
// HTTPClientSession.h
//
// Library: Net
// Package: HTTPClient
// Module: HTTPClientSession
//
// Definition of the HTTPClientSession class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPClientSession_INCLUDED
#define Net_HTTPClientSession_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPSession.h"
#include "Poco/Net/HTTPBasicCredentials.h"
#include "Poco/Net/HTTPDigestCredentials.h"
#include "Poco/Net/HTTPNTLMCredentials.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/SharedPtr.h"
#include <istream>
#include <ostream>
namespace Poco {
namespace Net {
class HTTPRequest;
class HTTPResponse;
class Net_API HTTPClientSession: public HTTPSession
/// This class implements the client-side of
/// a HTTP session.
///
/// To send a HTTP request to a HTTP server, first
/// instantiate a HTTPClientSession object and
/// specify the server's host name and port number.
///
/// Then create a HTTPRequest object, fill it accordingly,
/// and pass it as argument to the sendRequest() method.
///
/// sendRequest() will return an output stream that can
/// be used to send the request body, if there is any.
///
/// After you are done sending the request body, create
/// a HTTPResponse object and pass it to receiveResponse().
///
/// This will return an input stream that can be used to
/// read the response body.
///
/// See RFC 2616 <http://www.faqs.org/rfcs/rfc2616.html> for more
/// information about the HTTP protocol.
///
/// Proxies and proxy authorization (only HTTP Basic Authorization)
/// is supported. Use setProxy() and setProxyCredentials() to
/// set up a session through a proxy.
{
public:
enum ProxyAuthentication
{
PROXY_AUTH_NONE, /// No proxy authentication
PROXY_AUTH_HTTP_BASIC, /// HTTP Basic proxy authentication (default, if username and password are supplied)
PROXY_AUTH_HTTP_DIGEST, /// HTTP Digest proxy authentication
PROXY_AUTH_NTLM /// NTLMv2 proxy authentication
};
struct ProxyConfig
/// HTTP proxy server configuration.
{
ProxyConfig():
port(HTTP_PORT),
authMethod(PROXY_AUTH_HTTP_BASIC)
{
}
std::string host;
/// Proxy server host name or IP address.
Poco::UInt16 port;
/// Proxy server TCP port.
std::string username;
/// Proxy server username.
std::string password;
/// Proxy server password.
std::string nonProxyHosts;
/// A regular expression defining hosts for which the proxy should be bypassed,
/// e.g. "localhost|127\.0\.0\.1|192\.168\.0\.\d+". Can also be an empty
/// string to disable proxy bypassing.
ProxyAuthentication authMethod;
/// The authentication method to use - HTTP Basic or NTLM.
};
HTTPClientSession();
/// Creates an unconnected HTTPClientSession.
explicit HTTPClientSession(const StreamSocket& socket);
/// Creates a HTTPClientSession using the given socket.
/// The socket must not be connected. The session
/// takes ownership of the socket.
explicit HTTPClientSession(const SocketAddress& address);
/// Creates a HTTPClientSession using the given address.
HTTPClientSession(const std::string& host, Poco::UInt16 port = HTTPSession::HTTP_PORT);
/// Creates a HTTPClientSession using the given host and port.
HTTPClientSession(const std::string& host, Poco::UInt16 port, const ProxyConfig& proxyConfig);
/// Creates a HTTPClientSession using the given host, port and proxy configuration.
virtual ~HTTPClientSession();
/// Destroys the HTTPClientSession and closes
/// the underlying socket.
void setHost(const std::string& host);
/// Sets the host name of the target HTTP server.
///
/// The host must not be changed once there is an
/// open connection to the server.
const std::string& getHost() const;
/// Returns the host name of the target HTTP server.
void setPort(Poco::UInt16 port);
/// Sets the port number of the target HTTP server.
///
/// The port number must not be changed once there is an
/// open connection to the server.
Poco::UInt16 getPort() const;
/// Returns the port number of the target HTTP server.
void setProxy(const std::string& host, Poco::UInt16 port = HTTPSession::HTTP_PORT);
/// Sets the proxy host name and port number.
void setProxyHost(const std::string& host);
/// Sets the host name of the proxy server.
void setProxyPort(Poco::UInt16 port);
/// Sets the port number of the proxy server.
const std::string& getProxyHost() const;
/// Returns the proxy host name.
Poco::UInt16 getProxyPort() const;
/// Returns the proxy port number.
void setProxyCredentials(const std::string& username, const std::string& password);
/// Sets the username and password for proxy authentication.
/// Only Basic authentication is supported.
void setProxyUsername(const std::string& username);
/// Sets the username for proxy authentication.
/// Only Basic authentication is supported.
const std::string& getProxyUsername() const;
/// Returns the username for proxy authentication.
void setProxyPassword(const std::string& password);
/// Sets the password for proxy authentication.
/// Only Basic authentication is supported.
const std::string& getProxyPassword() const;
/// Returns the password for proxy authentication.
void setProxyConfig(const ProxyConfig& config);
/// Sets the proxy configuration.
const ProxyConfig& getProxyConfig() const;
/// Returns the proxy configuration.
static void setGlobalProxyConfig(const ProxyConfig& config);
/// Sets the global proxy configuration.
///
/// The global proxy configuration is used by all HTTPClientSession
/// instances, unless a different proxy configuration is explicitly set.
///
/// Warning: Setting the global proxy configuration is not thread safe.
/// The global proxy configuration should be set at start up, before
/// the first HTTPClientSession instance is created.
static const ProxyConfig& getGlobalProxyConfig();
/// Returns the global proxy configuration.
void setKeepAliveTimeout(const Poco::Timespan& timeout);
/// Sets the connection timeout for HTTP connections.
const Poco::Timespan& getKeepAliveTimeout() const;
/// Returns the connection timeout for HTTP connections.
virtual std::ostream& sendRequest(HTTPRequest& request);
/// Sends the header for the given HTTP request to
/// the server.
///
/// The HTTPClientSession will set the request's
/// Host and Keep-Alive headers accordingly.
///
/// The returned output stream can be used to write
/// the request body. The stream is valid until
/// receiveResponse() is called or the session
/// is destroyed.
///
/// In case a network or server failure happens
/// while writing the request body to the returned stream,
/// the stream state will change to bad or fail. In this
/// case, reset() should be called if the session will
/// be reused and persistent connections are enabled
/// to ensure a new connection will be set up
/// for the next request.
virtual std::istream& receiveResponse(HTTPResponse& response);
/// Receives the header for the response to the previous
/// HTTP request.
///
/// The returned input stream can be used to read
/// the response body. The stream is valid until
/// sendRequest() is called or the session is
/// destroyed.
///
/// It must be ensured that the response stream
/// is fully consumed before sending a new request
/// and persistent connections are enabled. Otherwise,
/// the unread part of the response body may be treated as
/// part of the next request's response header, resulting
/// in a Poco::Net::MessageException being thrown.
///
/// In case a network or server failure happens
/// while reading the response body from the returned stream,
/// the stream state will change to bad or fail. In this
/// case, reset() should be called if the session will
/// be reused and persistent connections are enabled
/// to ensure a new connection will be set up
/// for the next request.
virtual bool peekResponse(HTTPResponse& response);
/// If the request contains a "Expect: 100-continue" header,
/// (see HTTPRequest::setExpectContinue()) this method can be
/// used to check whether the server has sent a 100 Continue response
/// before continuing with the request, i.e. sending the request body,
/// after calling sendRequest().
///
/// Returns true if the server has responded with 100 Continue,
/// otherwise false. The HTTPResponse object contains the
/// response sent by the server.
///
/// In any case, receiveResponse() must be called afterwards as well in
/// order to complete the request. The same HTTPResponse object
/// passed to peekResponse() must also be passed to receiveResponse().
///
/// This method should only be called if the request contains
/// a "Expect: 100-continue" header.
void flushRequest();
/// Flushes the request stream.
///
/// Normally this method does not need to be called.
/// It can be used to ensure the request has been
/// fully sent if receiveResponse() is not called, e.g.,
/// because the underlying socket will be detached.
void reset();
/// Resets the session and closes the socket.
///
/// The next request will initiate a new connection,
/// even if persistent connections are enabled.
///
/// This should be called whenever something went
/// wrong when sending a request (e.g., sendRequest()
/// or receiveResponse() throws an exception, or
/// the request or response stream changes into
/// fail or bad state, but not eof state).
virtual bool secure() const;
/// Return true iff the session uses SSL or TLS,
/// or false otherwise.
bool bypassProxy() const;
/// Returns true if the proxy should be bypassed
/// for the current host.
protected:
enum
{
DEFAULT_KEEP_ALIVE_TIMEOUT = 8
};
void reconnect();
/// Connects the underlying socket to the HTTP server.
int write(const char* buffer, std::streamsize length);
/// Tries to re-connect if keep-alive is on.
std::ostream& sendRequestImpl(const HTTPRequest& request);
/// Sends the given HTTPRequest over an existing connection.
virtual std::string proxyRequestPrefix() const;
/// Returns the prefix prepended to the URI for proxy requests
/// (e.g., "http://myhost.com").
virtual bool mustReconnect() const;
/// Checks if we can reuse a persistent connection.
virtual void proxyAuthenticate(HTTPRequest& request);
/// Sets the proxy credentials (Proxy-Authorization header), if
/// proxy username and password have been set.
void proxyAuthenticateImpl(HTTPRequest& request, const ProxyConfig& proxyConfig);
/// Sets the proxy credentials (Proxy-Authorization header), if
/// proxy username and password have been set.
void proxyAuthenticateDigest(HTTPRequest& request);
/// Initiates a HTTP Digest authentication handshake with the proxy.
void proxyAuthenticateNTLM(HTTPRequest& request);
/// Initiates a HTTP NTLM authentication handshake with the proxy.
void sendChallengeRequest(const HTTPRequest& request, HTTPResponse& response);
/// Sends a probe request for Digest and NTLM authentication
/// to obtain the server challenge.
StreamSocket proxyConnect();
/// Sends a CONNECT request to the proxy server and returns
/// a StreamSocket for the resulting connection.
void proxyTunnel();
/// Calls proxyConnect() and attaches the resulting StreamSocket
/// to the HTTPClientSession.
private:
std::string _host;
Poco::UInt16 _port;
ProxyConfig _proxyConfig;
Poco::Timespan _keepAliveTimeout;
Poco::Timestamp _lastRequest;
bool _reconnect;
bool _mustReconnect;
bool _expectResponseBody;
bool _responseReceived;
Poco::SharedPtr<std::ostream> _pRequestStream;
Poco::SharedPtr<std::istream> _pResponseStream;
HTTPBasicCredentials _proxyBasicCreds;
HTTPDigestCredentials _proxyDigestCreds;
HTTPNTLMCredentials _proxyNTLMCreds;
bool _ntlmProxyAuthenticated;
static ProxyConfig _globalProxyConfig;
HTTPClientSession(const HTTPClientSession&);
HTTPClientSession& operator = (const HTTPClientSession&);
friend class WebSocket;
};
//
// inlines
//
inline const std::string& HTTPClientSession::getHost() const
{
return _host;
}
inline Poco::UInt16 HTTPClientSession::getPort() const
{
return _port;
}
inline const std::string& HTTPClientSession::getProxyHost() const
{
return _proxyConfig.host;
}
inline Poco::UInt16 HTTPClientSession::getProxyPort() const
{
return _proxyConfig.port;
}
inline const std::string& HTTPClientSession::getProxyUsername() const
{
return _proxyConfig.username;
}
inline const std::string& HTTPClientSession::getProxyPassword() const
{
return _proxyConfig.password;
}
inline const HTTPClientSession::ProxyConfig& HTTPClientSession::getProxyConfig() const
{
return _proxyConfig;
}
inline const HTTPClientSession::ProxyConfig& HTTPClientSession::getGlobalProxyConfig()
{
return _globalProxyConfig;
}
inline const Poco::Timespan& HTTPClientSession::getKeepAliveTimeout() const
{
return _keepAliveTimeout;
}
} } // namespace Poco::Net
#endif // Net_HTTPClientSession_INCLUDED

293
vendor/POCO/Net/include/Poco/Net/HTTPCookie.h vendored Normal file
View File

@ -0,0 +1,293 @@
//
// HTTPCookie.h
//
// Library: Net
// Package: HTTP
// Module: HTTPCookie
//
// Definition of the HTTPCookie class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPCookie_INCLUDED
#define Net_HTTPCookie_INCLUDED
#include "Poco/Net/Net.h"
namespace Poco {
namespace Net {
class NameValueCollection;
class Net_API HTTPCookie
/// This class represents a HTTP Cookie.
///
/// A cookie is a small amount of information sent by a Web
/// server to a Web browser, saved by the browser, and later sent back
/// to the server. A cookie's value can uniquely identify a client, so
/// cookies are commonly used for session management.
///
/// A cookie has a name, a single value, and optional attributes such
/// as a comment, path and domain qualifiers, a maximum age, and a
/// version number.
///
/// This class supports both the Version 0 (by Netscape) and Version 1
/// (by RFC 2109) cookie specifications. By default, cookies are created
/// using Version 0 to ensure the best interoperability.
{
public:
enum SameSite
{
SAME_SITE_NOT_SPECIFIED,
SAME_SITE_NONE,
SAME_SITE_LAX,
SAME_SITE_STRICT
};
HTTPCookie();
/// Creates an empty HTTPCookie.
explicit HTTPCookie(const std::string& name);
/// Creates a cookie with the given name.
/// The cookie never expires.
explicit HTTPCookie(const NameValueCollection& nvc);
/// Creates a cookie from the given NameValueCollection.
HTTPCookie(const std::string& name, const std::string& value);
/// Creates a cookie with the given name and value.
/// The cookie never expires.
///
/// Note: If value contains whitespace or non-alphanumeric
/// characters, the value should be escaped by calling escape()
/// before passing it to the constructor.
HTTPCookie(const HTTPCookie& cookie);
/// Creates the HTTPCookie by copying another one.
~HTTPCookie();
/// Destroys the HTTPCookie.
HTTPCookie& operator = (const HTTPCookie& cookie);
/// Assigns a cookie.
void setVersion(int version);
/// Sets the version of the cookie.
///
/// Version must be either 0 (denoting a Netscape cookie)
/// or 1 (denoting a RFC 2109 cookie).
int getVersion() const;
/// Returns the version of the cookie, which is
/// either 0 or 1.
void setName(const std::string& name);
/// Sets the name of the cookie.
const std::string& getName() const;
/// Returns the name of the cookie.
void setValue(const std::string& value);
/// Sets the value of the cookie.
///
/// According to the cookie specification, the
/// size of the value should not exceed 4 Kbytes.
///
/// Note: If value contains whitespace or non-alphanumeric
/// characters, the value should be escaped by calling escape()
/// prior to passing it to setName().
const std::string& getValue() const;
/// Returns the value of the cookie.
void setComment(const std::string& comment);
/// Sets the comment for the cookie.
///
/// Comments are only supported for version 1 cookies.
const std::string& getComment() const;
/// Returns the comment for the cookie.
void setDomain(const std::string& domain);
/// Sets the domain for the cookie.
const std::string& getDomain() const;
/// Returns the domain for the cookie.
void setPath(const std::string& path);
/// Sets the path for the cookie.
void setPriority(const std::string& priority);
/// Sets the priority for the cookie.
const std::string& getPath() const;
/// Returns the path for the cookie.
const std::string& getPriority() const;
/// Returns the priority for the cookie.
void setSecure(bool secure);
/// Sets the value of the secure flag for
/// the cookie.
bool getSecure() const;
/// Returns the value of the secure flag
/// for the cookie.
void setMaxAge(int maxAge);
/// Sets the maximum age in seconds for
/// the cookie.
///
/// A value of -1 (default) causes the cookie
/// to become a session cookie, which will
/// be deleted when the browser window
/// is closed.
///
/// A value of 0 deletes the cookie on
/// the client.
int getMaxAge() const;
/// Returns the maximum age in seconds for
/// the cookie.
void setHttpOnly(bool flag = true);
/// Sets the HttpOnly flag for the cookie.
bool getHttpOnly() const;
/// Returns true iff the cookie's HttpOnly flag is set.
void setSameSite(SameSite value);
/// Sets the cookie's SameSite attribute.
SameSite getSameSite() const;
/// Returns the cookie's SameSite attribute.
std::string toString() const;
/// Returns a string representation of the cookie,
/// suitable for use in a Set-Cookie header.
static std::string escape(const std::string& str);
/// Escapes the given string by replacing all
/// non-alphanumeric characters with escape
/// sequences in the form %xx, where xx is the
/// hexadecimal character code.
///
/// The following characters will be replaced
/// with escape sequences:
/// - percent sign %
/// - less-than and greater-than < and >
/// - curly brackets { and }
/// - square brackets [ and ]
/// - parenthesis ( and )
/// - solidus /
/// - vertical line |
/// - reverse solidus (backslash /)
/// - quotation mark "
/// - apostrophe '
/// - circumflex accent ^
/// - grave accent `
/// - comma and semicolon , and ;
/// - whitespace and control characters
static std::string unescape(const std::string& str);
/// Unescapes the given string by replacing all
/// escape sequences in the form %xx with the
/// respective characters.
private:
int _version;
std::string _name;
std::string _value;
std::string _comment;
std::string _domain;
std::string _path;
std::string _priority;
bool _secure;
int _maxAge;
bool _httpOnly;
SameSite _sameSite;
};
//
// inlines
//
inline int HTTPCookie::getVersion() const
{
return _version;
}
inline const std::string& HTTPCookie::getName() const
{
return _name;
}
inline const std::string& HTTPCookie::getValue() const
{
return _value;
}
inline const std::string& HTTPCookie::getComment() const
{
return _comment;
}
inline const std::string& HTTPCookie::getDomain() const
{
return _domain;
}
inline const std::string& HTTPCookie::getPath() const
{
return _path;
}
inline const std::string& HTTPCookie::getPriority() const
{
return _priority;
}
inline bool HTTPCookie::getSecure() const
{
return _secure;
}
inline int HTTPCookie::getMaxAge() const
{
return _maxAge;
}
inline bool HTTPCookie::getHttpOnly() const
{
return _httpOnly;
}
inline HTTPCookie::SameSite HTTPCookie::getSameSite() const
{
return _sameSite;
}
} } // namespace Poco::Net
#endif // Net_HTTPCookie_INCLUDED

234
vendor/POCO/Net/include/Poco/Net/HTTPCredentials.h vendored Normal file
View File

@ -0,0 +1,234 @@
//
// HTTPCredentials.h
//
// Library: Net
// Package: HTTP
// Module: HTTPCredentials
//
// Definition of the HTTPCredentials class.
//
// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPCredentials_INCLUDED
#define Net_HTTPCredentials_INCLUDED
#include "Poco/Net/HTTPDigestCredentials.h"
#include "Poco/Net/HTTPNTLMCredentials.h"
namespace Poco {
class URI;
namespace Net {
class HTTPRequest;
class HTTPResponse;
class Net_API HTTPCredentials
/// This is a utility class for working with HTTP
/// authentication (Basic, Digest or NTLM) in HTTPRequest objects.
///
/// Usage is as follows:
/// First, create a HTTPCredentials object containing
/// the username and password.
/// Poco::Net::HTTPCredentials creds("user", "s3cr3t");
///
/// Second, send the HTTP request with Poco::Net::HTTPClientSession.
/// Poco::Net::HTTPClientSession session("pocoproject.org");
/// Poco::Net::HTTPRequest request(HTTPRequest::HTTP_GET, "/index.html", HTTPMessage::HTTP_1_1);
/// session.sendRequest(request);
/// Poco::Net::HTTPResponse;
/// std::istream& istr = session.receiveResponse(response);
///
/// If the server responds with a 401 status, authenticate the
/// request and resend it:
/// if (response.getStatus() == Poco::Net::HTTPResponse::HTTP_UNAUTHORIZED)
/// {
/// creds.authenticate(request, response);
/// session.sendRequest(request);
/// ...
/// }
///
/// To perform multiple authenticated requests, call updateAuthInfo()
/// instead of authenticate() on subsequent requests.
/// creds.updateAuthInfo(request);
/// session.sendRequest(request);
/// ...
///
/// Note: Do not forget to read the entire response stream from the 401 response
/// before sending the authenticated request, otherwise there may be
/// problems if a persistent connection is used.
{
public:
HTTPCredentials();
/// Creates an empty HTTPCredentials object.
HTTPCredentials(const std::string& username, const std::string& password);
/// Creates an HTTPCredentials object with the given username and password.
~HTTPCredentials();
/// Destroys the HTTPCredentials.
void fromUserInfo(const std::string& userInfo);
/// Parses username:password string and sets username and password of
/// the credentials object.
/// Throws SyntaxException on invalid user information.
void fromURI(const URI& uri);
/// Extracts username and password from the given URI and sets username
/// and password of the credentials object.
/// Does nothing if URI has no user info part.
void clear();
/// Clears username, password and host.
void setUsername(const std::string& username);
/// Sets the username.
const std::string& getUsername() const;
/// Returns the username.
void setPassword(const std::string& password);
/// Sets the password.
const std::string& getPassword() const;
/// Returns the password.
void setHost(const std::string& host);
/// Sets the target host. Only used for SSPI-based NTLM authentication using
/// the credentials of the currently logged-in user on Windows.
const std::string& getHost() const;
/// Returns the target host. Only used for SSPI-based NTLM authentication using
/// the credentials of the currently logged-in user on Windows.
bool empty() const;
/// Returns true if both username and password are empty, otherwise false.
void authenticate(HTTPRequest& request, const HTTPResponse& response);
/// Inspects WWW-Authenticate header of the response, initializes
/// the internal state (in case of digest authentication) and
/// adds required information to the given HTTPRequest.
///
/// Does nothing if there is no WWW-Authenticate header in the
/// HTTPResponse.
void updateAuthInfo(HTTPRequest& request);
/// Updates internal state (in case of digest authentication) and
/// replaces authentication information in the request accordingly.
void proxyAuthenticate(HTTPRequest& request, const HTTPResponse& response);
/// Inspects Proxy-Authenticate header of the response, initializes
/// the internal state (in case of digest authentication) and
/// adds required information to the given HTTPRequest.
///
/// Does nothing if there is no Proxy-Authenticate header in the
/// HTTPResponse.
void updateProxyAuthInfo(HTTPRequest& request);
/// Updates internal state (in case of digest authentication) and
/// replaces proxy authentication information in the request accordingly.
static bool isBasicCredentials(const std::string& header);
/// Returns true if authentication header is for Basic authentication.
static bool isDigestCredentials(const std::string& header);
/// Returns true if authentication header is for Digest authentication.
static bool isNTLMCredentials(const std::string& header);
/// Returns true if authentication header is for NTLM authentication.
static bool hasBasicCredentials(const HTTPRequest& request);
/// Returns true if an Authorization header with Basic credentials is present in the request.
static bool hasDigestCredentials(const HTTPRequest& request);
/// Returns true if an Authorization header with Digest credentials is present in the request.
static bool hasNTLMCredentials(const HTTPRequest& request);
/// Returns true if an Authorization header with NTLM credentials is present in the request.
static bool hasProxyBasicCredentials(const HTTPRequest& request);
/// Returns true if a Proxy-Authorization header with Basic credentials is present in the request.
static bool hasProxyDigestCredentials(const HTTPRequest& request);
/// Returns true if a Proxy-Authorization header with Digest credentials is present in the request.
static bool hasProxyNTLMCredentials(const HTTPRequest& request);
/// Returns true if a Proxy-Authorization header with Digest credentials is present in the request.
static void extractCredentials(const std::string& userInfo, std::string& username, std::string& password);
/// Extracts username and password from user:password information string.
static void extractCredentials(const Poco::URI& uri, std::string& username, std::string& password);
/// Extracts username and password from the given URI (e.g.: "http://user:pass@sample.com/secret").
private:
HTTPCredentials(const HTTPCredentials&);
HTTPCredentials& operator = (const HTTPCredentials&);
HTTPDigestCredentials _digest;
HTTPNTLMCredentials _ntlm;
};
//
// inlines
//
inline void HTTPCredentials::setUsername(const std::string& username)
{
_digest.setUsername(username);
}
inline const std::string& HTTPCredentials::getUsername() const
{
return _digest.getUsername();
}
inline void HTTPCredentials::setPassword(const std::string& password)
{
_digest.setPassword(password);
}
inline const std::string& HTTPCredentials::getPassword() const
{
return _digest.getPassword();
}
inline void HTTPCredentials::setHost(const std::string& host)
{
_ntlm.setHost(host);
}
inline const std::string& HTTPCredentials::getHost() const
{
return _ntlm.getHost();
}
inline bool HTTPCredentials::empty() const
{
return _digest.empty();
}
} } // namespace Poco::Net
#endif // Net_HTTPCredentials_INCLUDED

186
vendor/POCO/Net/include/Poco/Net/HTTPDigestCredentials.h vendored Normal file
View File

@ -0,0 +1,186 @@
//
// HTTPDigestCredentials.h
//
// Library: Net
// Package: HTTP
// Module: HTTPDigestCredentials
//
// Definition of the HTTPDigestCredentials class.
//
// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPDigestCredentials_INCLUDED
#define Net_HTTPDigestCredentials_INCLUDED
#include "Poco/Net/HTTPAuthenticationParams.h"
#include "Poco/Mutex.h"
#include <map>
namespace Poco {
namespace Net {
class HTTPRequest;
class HTTPResponse;
class Net_API HTTPDigestCredentials
/// This is a utility class for working with
/// HTTP Digest Authentication in HTTPRequest
/// objects.
///
/// Note: currently, no qop or qop=auth is
/// supported only.
{
public:
HTTPDigestCredentials();
/// Creates an empty HTTPDigestCredentials object.
HTTPDigestCredentials(const std::string& username, const std::string& password);
/// Creates a HTTPDigestCredentials object with the given username and password.
~HTTPDigestCredentials();
/// Destroys the HTTPDigestCredentials.
void reset();
/// Resets the HTTPDigestCredentials object to a clean state.
/// Does not clear username and password.
void clear();
/// Clears both username and password.
void setUsername(const std::string& username);
/// Sets the username.
const std::string& getUsername() const;
/// Returns the username.
void setPassword(const std::string& password);
/// Sets the password.
const std::string& getPassword() const;
/// Returns the password.
bool empty() const;
/// Returns true if both username and password are empty, otherwise false.
void authenticate(HTTPRequest& request, const HTTPResponse& response);
/// Parses WWW-Authenticate header of the HTTPResponse, initializes
/// internal state, and adds authentication information to the given HTTPRequest.
void authenticate(HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams);
/// Initializes internal state according to information from the
/// HTTPAuthenticationParams of the response, and adds authentication
/// information to the given HTTPRequest.
///
/// Throws InvalidArgumentException if HTTPAuthenticationParams is
/// invalid or some required parameter is missing.
/// Throws NotImplementedException in case of unsupported digest
/// algorithm or quality of protection method.
void updateAuthInfo(HTTPRequest& request);
/// Updates internal state and adds authentication information to
/// the given HTTPRequest.
void proxyAuthenticate(HTTPRequest& request, const HTTPResponse& response);
/// Parses Proxy-Authenticate header of the HTTPResponse, initializes
/// internal state, and adds proxy authentication information to the given HTTPRequest.
void proxyAuthenticate(HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams);
/// Initializes internal state according to information from the
/// HTTPAuthenticationParams of the response, and adds proxy authentication
/// information to the given HTTPRequest.
///
/// Throws InvalidArgumentException if HTTPAuthenticationParams is
/// invalid or some required parameter is missing.
/// Throws NotImplementedException in case of unsupported digest
/// algorithm or quality of protection method.
void updateProxyAuthInfo(HTTPRequest& request);
/// Updates internal state and adds proxy authentication information to
/// the given HTTPRequest.
bool verifyAuthInfo(const HTTPRequest& request) const;
/// Verifies the digest authentication information in the given HTTPRequest
/// by recomputing the response and comparing it with what's in the request.
///
/// Note: This method creates a HTTPAuthenticationParams object from the request
/// and calls verifyAuthParams() with request and params.
bool verifyAuthParams(const HTTPRequest& request, const HTTPAuthenticationParams& params) const;
/// Verifies the digest authentication information in the given HTTPRequest
/// and HTTPAuthenticationParams by recomputing the response and comparing
/// it with what's in the request.
static std::string createNonce();
/// Creates a random nonce string.
static const std::string SCHEME;
private:
HTTPDigestCredentials(const HTTPDigestCredentials&);
HTTPDigestCredentials& operator = (const HTTPDigestCredentials&);
void createAuthParams(const HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams);
void updateAuthParams(const HTTPRequest& request);
int updateNonceCounter(const std::string& nonce);
static const std::string DEFAULT_ALGORITHM;
static const std::string DEFAULT_QOP;
static const std::string NONCE_PARAM;
static const std::string REALM_PARAM;
static const std::string QOP_PARAM;
static const std::string ALGORITHM_PARAM;
static const std::string USERNAME_PARAM;
static const std::string OPAQUE_PARAM;
static const std::string URI_PARAM;
static const std::string RESPONSE_PARAM;
static const std::string AUTH_PARAM;
static const std::string CNONCE_PARAM;
static const std::string NC_PARAM;
typedef std::map<std::string, int> NonceCounterMap;
std::string _username;
std::string _password;
HTTPAuthenticationParams _requestAuthParams;
NonceCounterMap _nc;
static int _nonceCounter;
static Poco::FastMutex _nonceMutex;
};
//
// inlines
//
inline const std::string& HTTPDigestCredentials::getUsername() const
{
return _username;
}
inline const std::string& HTTPDigestCredentials::getPassword() const
{
return _password;
}
inline bool HTTPDigestCredentials::empty() const
{
return _username.empty() && _password.empty();
}
} } // namespace Poco::Net
#endif // Net_HTTPDigestCredentials_INCLUDED

110
vendor/POCO/Net/include/Poco/Net/HTTPFixedLengthStream.h vendored Normal file
View File

@ -0,0 +1,110 @@
//
// HTTPFixedLengthStream.h
//
// Library: Net
// Package: HTTP
// Module: HTTPFixedLengthStream
//
// Definition of the HTTPFixedLengthStream class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPFixedLengthStream_INCLUDED
#define Net_HTTPFixedLengthStream_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPBasicStreamBuf.h"
#include <cstddef>
#include <istream>
#include <ostream>
namespace Poco {
namespace Net {
class HTTPSession;
class Net_API HTTPFixedLengthStreamBuf: public HTTPBasicStreamBuf
/// This is the streambuf class used for reading and writing fixed-size
/// HTTP message bodies.
///
/// At most a given number of bytes are read or written.
{
public:
using openmode = HTTPBasicStreamBuf::openmode;
#if defined(POCO_HAVE_INT64)
using ContentLength = Poco::Int64;
#else
using ContentLength = std::streamsize;
#endif
HTTPFixedLengthStreamBuf(HTTPSession& session, ContentLength length, openmode mode);
~HTTPFixedLengthStreamBuf();
protected:
int readFromDevice(char* buffer, std::streamsize length);
int writeToDevice(const char* buffer, std::streamsize length);
private:
HTTPSession& _session;
ContentLength _length;
ContentLength _count;
};
class Net_API HTTPFixedLengthIOS: public virtual std::ios
/// The base class for HTTPFixedLengthInputStream.
{
public:
HTTPFixedLengthIOS(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length, HTTPFixedLengthStreamBuf::openmode mode);
~HTTPFixedLengthIOS();
HTTPFixedLengthStreamBuf* rdbuf();
protected:
HTTPFixedLengthStreamBuf _buf;
};
class Net_API HTTPFixedLengthInputStream: public HTTPFixedLengthIOS, public std::istream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPFixedLengthInputStream(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length);
~HTTPFixedLengthInputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
class Net_API HTTPFixedLengthOutputStream: public HTTPFixedLengthIOS, public std::ostream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPFixedLengthOutputStream(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length);
~HTTPFixedLengthOutputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
} } // namespace Poco::Net
#endif // Net_HTTPFixedLengthStream_INCLUDED

102
vendor/POCO/Net/include/Poco/Net/HTTPHeaderStream.h vendored Normal file
View File

@ -0,0 +1,102 @@
//
// HTTPHeaderStream.h
//
// Library: Net
// Package: HTTP
// Module: HTTPHeaderStream
//
// Definition of the HTTPHeaderStream class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPHeaderStream_INCLUDED
#define Net_HTTPHeaderStream_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPBasicStreamBuf.h"
#include "Poco/MemoryPool.h"
#include <cstddef>
#include <istream>
#include <ostream>
namespace Poco {
namespace Net {
class HTTPSession;
class Net_API HTTPHeaderStreamBuf: public HTTPBasicStreamBuf
/// This is the streambuf class used for reading from a HTTP header
/// in a HTTPSession.
{
public:
using openmode = HTTPBasicStreamBuf::openmode;
HTTPHeaderStreamBuf(HTTPSession& session, openmode mode);
~HTTPHeaderStreamBuf();
protected:
int readFromDevice(char* buffer, std::streamsize length);
int writeToDevice(const char* buffer, std::streamsize length);
private:
HTTPSession& _session;
bool _end;
};
class Net_API HTTPHeaderIOS: public virtual std::ios
/// The base class for HTTPHeaderInputStream.
{
public:
HTTPHeaderIOS(HTTPSession& session, HTTPHeaderStreamBuf::openmode mode);
~HTTPHeaderIOS();
HTTPHeaderStreamBuf* rdbuf();
protected:
HTTPHeaderStreamBuf _buf;
};
class Net_API HTTPHeaderInputStream: public HTTPHeaderIOS, public std::istream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPHeaderInputStream(HTTPSession& session);
~HTTPHeaderInputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
class Net_API HTTPHeaderOutputStream: public HTTPHeaderIOS, public std::ostream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPHeaderOutputStream(HTTPSession& session);
~HTTPHeaderOutputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
} } // namespace Poco::Net
#endif // Net_HTTPHeaderStream_INCLUDED

88
vendor/POCO/Net/include/Poco/Net/HTTPIOStream.h vendored Normal file
View File

@ -0,0 +1,88 @@
//
// HTTPIOStream.h
//
// Library: Net
// Package: HTTP
// Module: HTTPIOStream
//
// Definition of the HTTPIOStream class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPIOStream_INCLUDED
#define Net_HTTPIOStream_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPResponse.h"
#include "Poco/UnbufferedStreamBuf.h"
namespace Poco {
namespace Net {
class HTTPClientSession;
class Net_API HTTPResponseStreamBuf: public Poco::UnbufferedStreamBuf
{
public:
HTTPResponseStreamBuf(std::istream& istr);
~HTTPResponseStreamBuf();
private:
int readFromDevice();
std::istream& _istr;
};
inline int HTTPResponseStreamBuf::readFromDevice()
{
return _istr.get();
}
class Net_API HTTPResponseIOS: public virtual std::ios
{
public:
HTTPResponseIOS(std::istream& istr);
~HTTPResponseIOS();
HTTPResponseStreamBuf* rdbuf();
protected:
HTTPResponseStreamBuf _buf;
};
inline HTTPResponseStreamBuf* HTTPResponseIOS::rdbuf()
{
return &_buf;
}
class Net_API HTTPResponseStream: public HTTPResponseIOS, public std::istream
{
public:
HTTPResponseStream(std::istream& istr, HTTPClientSession* pSession);
~HTTPResponseStream();
private:
HTTPClientSession* _pSession;
};
} } // namespace Poco::Net
#endif // Net_HTTPIOStream_INCLUDED

189
vendor/POCO/Net/include/Poco/Net/HTTPMessage.h vendored Normal file
View File

@ -0,0 +1,189 @@
//
// HTTPMessage.h
//
// Library: Net
// Package: HTTP
// Module: HTTPMessage
//
// Definition of the HTTPMessage class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPMessage_INCLUDED
#define Net_HTTPMessage_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/MessageHeader.h"
namespace Poco {
namespace Net {
class MediaType;
class Net_API HTTPMessage: public MessageHeader
/// The base class for HTTPRequest and HTTPResponse.
///
/// Defines the common properties of all HTTP messages.
/// These are version, content length, content type
/// and transfer encoding.
{
public:
void setVersion(const std::string& version);
/// Sets the HTTP version for this message.
const std::string& getVersion() const;
/// Returns the HTTP version for this message.
void setContentLength(std::streamsize length);
/// Sets the Content-Length header.
///
/// If length is UNKNOWN_CONTENT_LENGTH, removes
/// the Content-Length header.
std::streamsize getContentLength() const;
/// Returns the content length for this message,
/// which may be UNKNOWN_CONTENT_LENGTH if
/// no Content-Length header is present.
#if defined(POCO_HAVE_INT64)
void setContentLength64(Poco::Int64 length);
/// Sets the Content-Length header.
///
/// If length is UNKNOWN_CONTENT_LENGTH, removes
/// the Content-Length header.
///
/// In contrast to setContentLength(), this method takes
/// a 64-bit integer as content length.
Poco::Int64 getContentLength64() const;
/// Returns the content length for this message,
/// which may be UNKNOWN_CONTENT_LENGTH if
/// no Content-Length header is present.
///
/// In contrast to getContentLength(), this method
/// always returns a 64-bit integer for content length.
#endif // defined(POCO_HAVE_INT64)
bool hasContentLength() const;
/// Returns true iff a Content-Length header is present.
void setTransferEncoding(const std::string& transferEncoding);
/// Sets the transfer encoding for this message.
///
/// The value should be either IDENTITY_TRANSFER_CODING
/// or CHUNKED_TRANSFER_CODING.
const std::string& getTransferEncoding() const;
/// Returns the transfer encoding used for this
/// message.
///
/// Normally, this is the value of the Transfer-Encoding
/// header field. If no such field is present,
/// returns IDENTITY_TRANSFER_CODING.
void setChunkedTransferEncoding(bool flag);
/// If flag is true, sets the Transfer-Encoding header to
/// chunked. Otherwise, removes the Transfer-Encoding
/// header.
bool getChunkedTransferEncoding() const;
/// Returns true if the Transfer-Encoding header is set
/// and its value is chunked.
void setContentType(const std::string& mediaType);
/// Sets the content type for this message.
///
/// Specify NO_CONTENT_TYPE to remove the
/// Content-Type header.
void setContentType(const MediaType& mediaType);
/// Sets the content type for this message.
const std::string& getContentType() const;
/// Returns the content type for this message.
///
/// If no Content-Type header is present,
/// returns UNKNOWN_CONTENT_TYPE.
void setKeepAlive(bool keepAlive);
/// Sets the value of the Connection header field.
///
/// The value is set to "Keep-Alive" if keepAlive is
/// true, or to "Close" otherwise.
bool getKeepAlive() const;
/// Returns true if
/// * the message has a Connection header field and its value is "Keep-Alive"
/// * the message is a HTTP/1.1 message and not Connection header is set
/// Returns false otherwise.
static const std::string HTTP_1_0;
static const std::string HTTP_1_1;
static const std::string IDENTITY_TRANSFER_ENCODING;
static const std::string CHUNKED_TRANSFER_ENCODING;
static const int UNKNOWN_CONTENT_LENGTH;
static const std::string UNKNOWN_CONTENT_TYPE;
static const std::string CONTENT_LENGTH;
static const std::string CONTENT_TYPE;
static const std::string TRANSFER_ENCODING;
static const std::string CONNECTION;
static const std::string PROXY_CONNECTION;
static const std::string CONNECTION_KEEP_ALIVE;
static const std::string CONNECTION_CLOSE;
static const std::string EMPTY;
protected:
HTTPMessage();
/// Creates the HTTPMessage with version HTTP/1.0.
HTTPMessage(const std::string& version);
/// Creates the HTTPMessage and sets
/// the version.
HTTPMessage(const HTTPMessage& other);
/// Copy constructor.
HTTPMessage& operator = (const HTTPMessage& other);
/// Assignment operator.
virtual ~HTTPMessage();
/// Destroys the HTTPMessage.
private:
std::string _version;
};
//
// inlines
//
inline const std::string& HTTPMessage::getVersion() const
{
return _version;
}
inline bool HTTPMessage::hasContentLength() const
{
return has(CONTENT_LENGTH);
}
} } // namespace Poco::Net
#endif // Net_HTTPMessage_INCLUDED

168
vendor/POCO/Net/include/Poco/Net/HTTPNTLMCredentials.h vendored Normal file
View File

@ -0,0 +1,168 @@
//
// HTTPNTLMCredentials.h
//
// Library: Net
// Package: HTTP
// Module: HTTPNTLMCredentials
//
// Definition of the HTTPNTLMCredentials class.
//
// Copyright (c) 2019, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPNTLMCredentials_INCLUDED
#define Net_HTTPNTLMCredentials_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SSPINTLMCredentials.h"
#include <vector>
namespace Poco {
namespace Net {
class HTTPRequest;
class HTTPResponse;
class Net_API HTTPNTLMCredentials
/// This is a utility class for working with
/// HTTP NTLMv2 Authentication in HTTPRequest
/// objects.
{
public:
HTTPNTLMCredentials();
/// Creates an empty HTTPNTLMCredentials object.
HTTPNTLMCredentials(const std::string& username, const std::string& password);
/// Creates a HTTPNTLMCredentials object with the given username and password.
HTTPNTLMCredentials(const std::string& username, const std::string& password, const std::string& host);
/// Creates a HTTPNTLMCredentials object with the given username, password and target host.
~HTTPNTLMCredentials();
/// Destroys the HTTPNTLMCredentials.
void reset();
/// Resets the HTTPNTLMCredentials object to a clean state.
/// Does not clear username and password.
void clear();
/// Clears username, password and host.
void setUsername(const std::string& username);
/// Sets the username.
const std::string& getUsername() const;
/// Returns the username.
void setPassword(const std::string& password);
/// Sets the password.
const std::string& getPassword() const;
/// Returns the password.
bool empty() const;
/// Returns true if both username and password are empty, otherwise false.
void setHost(const std::string& host);
/// Sets the target host.
///
/// Used for SSPI-based NTLM authentication only.
const std::string& getHost() const;
/// Returns the target host.
void authenticate(HTTPRequest& request, const HTTPResponse& response);
/// Parses WWW-Authenticate header of the HTTPResponse, initializes
/// internal state, and adds authentication information to the given HTTPRequest.
void authenticate(HTTPRequest& request, const std::string& ntlmChallengeBase64);
/// Initializes internal state according to information from the
/// ntlmChallengeBase64, and adds authentication
/// information to the given HTTPRequest.
///
/// Throws InvalidArgumentException if responseAuthParams is
/// invalid.
void updateAuthInfo(HTTPRequest& request);
/// Updates internal state and adds authentication information to
/// the given HTTPRequest.
void proxyAuthenticate(HTTPRequest& request, const HTTPResponse& response);
/// Parses Proxy-Authenticate header of the HTTPResponse, initializes
/// internal state, and adds proxy authentication information to the given HTTPRequest.
void proxyAuthenticate(HTTPRequest& request, const std::string& ntlmChallengeBase64);
/// Initializes internal state according to information from the
/// HTTPAuthenticationParams of the response, and adds proxy authentication
/// information to the given HTTPRequest.
///
/// Throws InvalidArgumentException if HTTPAuthenticationParams is
/// invalid or some required parameter is missing.
/// Throws NotImplementedException in case of unsupported digest
/// algorithm or quality of protection method.
void updateProxyAuthInfo(HTTPRequest& request);
/// Updates internal state and adds proxy authentication information to
/// the given HTTPRequest.
static const std::string SCHEME;
private:
HTTPNTLMCredentials(const HTTPNTLMCredentials&);
HTTPNTLMCredentials& operator = (const HTTPNTLMCredentials&);
std::string createNTLMMessage(const std::string& ntlmChallengeBase64);
bool useSSPINTLM() const;
std::string _username;
std::string _password;
std::string _host;
Poco::SharedPtr<NTLMContext> _pNTLMContext;
};
//
// inlines
//
inline const std::string& HTTPNTLMCredentials::getUsername() const
{
return _username;
}
inline const std::string& HTTPNTLMCredentials::getPassword() const
{
return _password;
}
inline const std::string& HTTPNTLMCredentials::getHost() const
{
return _host;
}
inline bool HTTPNTLMCredentials::useSSPINTLM() const
{
return _username.empty() && _password.empty() && SSPINTLMCredentials::available();
}
inline bool HTTPNTLMCredentials::empty() const
{
return _username.empty() && _password.empty();
}
} } // namespace Poco::Net
#endif // Net_HTTPNTLMCredentials_INCLUDED

209
vendor/POCO/Net/include/Poco/Net/HTTPRequest.h vendored Normal file
View File

@ -0,0 +1,209 @@
//
// HTTPRequest.h
//
// Library: Net
// Package: HTTP
// Module: HTTPRequest
//
// Definition of the HTTPRequest class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPRequest_INCLUDED
#define Net_HTTPRequest_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPMessage.h"
namespace Poco {
namespace Net {
class Net_API HTTPRequest: public HTTPMessage
/// This class encapsulates an HTTP request
/// message.
///
/// In addition to the properties common to
/// all HTTP messages, a HTTP request has
/// a method (e.g. GET, HEAD, POST, etc.) and
/// a request URI.
{
public:
HTTPRequest();
/// Creates a GET / HTTP/1.0 HTTP request.
explicit HTTPRequest(const std::string& version);
/// Creates a GET / HTTP/1.x request with
/// the given version (HTTP/1.0 or HTTP/1.1).
HTTPRequest(const std::string& method, const std::string& uri);
/// Creates a HTTP/1.0 request with the given method and URI.
HTTPRequest(const std::string& method, const std::string& uri, const std::string& version);
/// Creates a HTTP request with the given method, URI and version.
HTTPRequest(const HTTPRequest& other);
/// Creates a HTTP request by copying another one.
virtual ~HTTPRequest();
/// Destroys the HTTPRequest.
HTTPRequest& operator = (const HTTPRequest&);
/// Assignment operator.
void setMethod(const std::string& method);
/// Sets the method.
const std::string& getMethod() const;
/// Returns the method.
void setURI(const std::string& uri);
/// Sets the request URI.
const std::string& getURI() const;
/// Returns the request URI.
void setHost(const std::string& host);
/// Sets the value of the Host header field.
void setHost(const std::string& host, Poco::UInt16 port);
/// Sets the value of the Host header field.
///
/// If the given port number is a non-standard
/// port number (other than 80 or 443), it is
/// included in the Host header field.
const std::string& getHost() const;
/// Returns the value of the Host header field.
///
/// Throws a NotFoundException if the request
/// does not have a Host header field.
void setCookies(const NameValueCollection& cookies);
/// Adds a Cookie header with the names and
/// values from cookies.
void getCookies(NameValueCollection& cookies) const;
/// Fills cookies with the cookies extracted
/// from the Cookie headers in the request.
bool hasCredentials() const;
/// Returns true iff the request contains authentication
/// information in the form of an Authorization header.
void getCredentials(std::string& scheme, std::string& authInfo) const;
/// Returns the authentication scheme and additional authentication
/// information contained in this request.
///
/// Throws a NotAuthenticatedException if no authentication information
/// is contained in the request.
void setCredentials(const std::string& scheme, const std::string& authInfo);
/// Sets the authentication scheme and information for
/// this request.
void removeCredentials();
/// Removes any credentials from the request.
bool getExpectContinue() const;
/// Returns true if the request contains an
/// "Expect: 100-continue" header.
void setExpectContinue(bool expectContinue);
/// Adds a "Expect: 100-continue" header to the request if
/// expectContinue is true, otherwise removes the Expect header.
bool hasProxyCredentials() const;
/// Returns true iff the request contains proxy authentication
/// information in the form of an Proxy-Authorization header.
void getProxyCredentials(std::string& scheme, std::string& authInfo) const;
/// Returns the proxy authentication scheme and additional proxy authentication
/// information contained in this request.
///
/// Throws a NotAuthenticatedException if no proxy authentication information
/// is contained in the request.
void setProxyCredentials(const std::string& scheme, const std::string& authInfo);
/// Sets the proxy authentication scheme and information for
/// this request.
void removeProxyCredentials();
/// Removes any proxy credentials from the request.
void write(std::ostream& ostr) const;
/// Writes the HTTP request to the given
/// output stream.
void read(std::istream& istr);
/// Reads the HTTP request from the
/// given input stream.
static const std::string HTTP_GET;
static const std::string HTTP_HEAD;
static const std::string HTTP_PUT;
static const std::string HTTP_POST;
static const std::string HTTP_OPTIONS;
static const std::string HTTP_DELETE;
static const std::string HTTP_TRACE;
static const std::string HTTP_CONNECT;
static const std::string HTTP_PATCH;
static const std::string HOST;
static const std::string COOKIE;
static const std::string AUTHORIZATION;
static const std::string PROXY_AUTHORIZATION;
static const std::string UPGRADE;
static const std::string EXPECT;
protected:
void getCredentials(const std::string& header, std::string& scheme, std::string& authInfo) const;
/// Returns the authentication scheme and additional authentication
/// information contained in the given header of request.
///
/// Throws a NotAuthenticatedException if no authentication information
/// is contained in the request.
void setCredentials(const std::string& header, const std::string& scheme, const std::string& authInfo);
/// Writes the authentication scheme and information for
/// this request to the given header.
private:
enum Limits
{
MAX_METHOD_LENGTH = 32,
MAX_URI_LENGTH = 16384,
MAX_VERSION_LENGTH = 8
};
std::string _method;
std::string _uri;
};
//
// inlines
//
inline const std::string& HTTPRequest::getMethod() const
{
return _method;
}
inline const std::string& HTTPRequest::getURI() const
{
return _uri;
}
} } // namespace Poco::Net
#endif // Net_HTTPRequest_INCLUDED

67
vendor/POCO/Net/include/Poco/Net/HTTPRequestHandler.h vendored Normal file
View File

@ -0,0 +1,67 @@
//
// HTTPRequestHandler.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPRequestHandler
//
// Definition of the HTTPRequestHandler class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPRequestHandler_INCLUDED
#define Net_HTTPRequestHandler_INCLUDED
#include "Poco/Net/Net.h"
namespace Poco {
namespace Net {
class HTTPServerRequest;
class HTTPServerResponse;
class Net_API HTTPRequestHandler
/// The abstract base class for HTTPRequestHandlers
/// created by HTTPServer.
///
/// Derived classes must override the handleRequest() method.
/// Furthermore, a HTTPRequestHandlerFactory must be provided.
///
/// The handleRequest() method must perform the complete handling
/// of the HTTP request connection. As soon as the handleRequest()
/// method returns, the request handler object is destroyed.
///
/// A new HTTPRequestHandler object will be created for
/// each new HTTP request that is received by the HTTPServer.
{
public:
HTTPRequestHandler();
/// Creates the HTTPRequestHandler.
virtual ~HTTPRequestHandler();
/// Destroys the HTTPRequestHandler.
virtual void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response) = 0;
/// Must be overridden by subclasses.
///
/// Handles the given request.
private:
HTTPRequestHandler(const HTTPRequestHandler&);
HTTPRequestHandler& operator = (const HTTPRequestHandler&);
};
} } // namespace Poco::Net
#endif // Net_HTTPRequestHandler_INCLUDED

78
vendor/POCO/Net/include/Poco/Net/HTTPRequestHandlerFactory.h vendored Normal file
View File

@ -0,0 +1,78 @@
//
// HTTPRequestHandlerFactory.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPRequestHandlerFactory
//
// Definition of the HTTPRequestHandlerFactory class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPRequestHandlerFactory_INCLUDED
#define Net_HTTPRequestHandlerFactory_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/SharedPtr.h"
#include "Poco/BasicEvent.h"
namespace Poco {
namespace Net {
class HTTPServerRequest;
class HTTPServerResponse;
class HTTPRequestHandler;
class Net_API HTTPRequestHandlerFactory
/// A factory for HTTPRequestHandler objects.
/// Subclasses must override the createRequestHandler()
/// method.
{
public:
using Ptr = Poco::SharedPtr<HTTPRequestHandlerFactory>;
HTTPRequestHandlerFactory();
/// Creates the HTTPRequestHandlerFactory.
virtual ~HTTPRequestHandlerFactory();
/// Destroys the HTTPRequestHandlerFactory.
virtual HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request) = 0;
/// Must be overridden by subclasses.
///
/// Creates a new request handler for the given HTTP request.
///
/// The method should inspect the given HTTPServerRequest object (e.g., method
/// and URI) and create an appropriate HTTPRequestHandler object to handle the
/// request.
///
/// If the request contains a "Expect: 100-continue" header, it's possible
/// to prevent the server from sending the default 100 Continue response
/// by setting the status of the response object that can be obtained through
/// the request object (request.response()) to something other than 200 OK.
protected:
Poco::BasicEvent<const bool> serverStopped;
private:
HTTPRequestHandlerFactory(const HTTPRequestHandlerFactory&);
HTTPRequestHandlerFactory& operator = (const HTTPRequestHandlerFactory&);
friend class HTTPServer;
friend class HTTPServerConnection;
};
} } // namespace Poco::Net
#endif // Net_HTTPRequestHandlerFactory_INCLUDED

298
vendor/POCO/Net/include/Poco/Net/HTTPResponse.h vendored Normal file
View File

@ -0,0 +1,298 @@
//
// HTTPResponse.h
//
// Library: Net
// Package: HTTP
// Module: HTTPResponse
//
// Definition of the HTTPResponse class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPResponse_INCLUDED
#define Net_HTTPResponse_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPMessage.h"
#include "Poco/Net/HTTPCookie.h"
#include "Poco/Timestamp.h"
#include <vector>
namespace Poco {
namespace Net {
class HTTPCookie;
class Net_API HTTPResponse: public HTTPMessage
/// This class encapsulates an HTTP response
/// message.
///
/// In addition to the properties common to
/// all HTTP messages, a HTTP response has
/// status code and a reason phrase.
{
public:
enum HTTPStatus
{
HTTP_CONTINUE = 100,
HTTP_SWITCHING_PROTOCOLS = 101,
HTTP_PROCESSING = 102,
HTTP_OK = 200,
HTTP_CREATED = 201,
HTTP_ACCEPTED = 202,
HTTP_NONAUTHORITATIVE = 203,
HTTP_NO_CONTENT = 204,
HTTP_RESET_CONTENT = 205,
HTTP_PARTIAL_CONTENT = 206,
HTTP_MULTI_STATUS = 207,
HTTP_ALREADY_REPORTED = 208,
HTTP_IM_USED = 226,
HTTP_MULTIPLE_CHOICES = 300,
HTTP_MOVED_PERMANENTLY = 301,
HTTP_FOUND = 302,
HTTP_SEE_OTHER = 303,
HTTP_NOT_MODIFIED = 304,
HTTP_USE_PROXY = 305,
HTTP_USEPROXY = 305, /// @deprecated
// UNUSED: 306
HTTP_TEMPORARY_REDIRECT = 307,
HTTP_PERMANENT_REDIRECT = 308,
HTTP_BAD_REQUEST = 400,
HTTP_UNAUTHORIZED = 401,
HTTP_PAYMENT_REQUIRED = 402,
HTTP_FORBIDDEN = 403,
HTTP_NOT_FOUND = 404,
HTTP_METHOD_NOT_ALLOWED = 405,
HTTP_NOT_ACCEPTABLE = 406,
HTTP_PROXY_AUTHENTICATION_REQUIRED = 407,
HTTP_REQUEST_TIMEOUT = 408,
HTTP_CONFLICT = 409,
HTTP_GONE = 410,
HTTP_LENGTH_REQUIRED = 411,
HTTP_PRECONDITION_FAILED = 412,
HTTP_REQUEST_ENTITY_TOO_LARGE = 413,
HTTP_REQUESTENTITYTOOLARGE = 413, /// @deprecated
HTTP_REQUEST_URI_TOO_LONG = 414,
HTTP_REQUESTURITOOLONG = 414, /// @deprecated
HTTP_UNSUPPORTED_MEDIA_TYPE = 415,
HTTP_UNSUPPORTEDMEDIATYPE = 415, /// @deprecated
HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
HTTP_EXPECTATION_FAILED = 417,
HTTP_IM_A_TEAPOT = 418,
HTTP_ENCHANCE_YOUR_CALM = 420,
HTTP_MISDIRECTED_REQUEST = 421,
HTTP_UNPROCESSABLE_ENTITY = 422,
HTTP_LOCKED = 423,
HTTP_FAILED_DEPENDENCY = 424,
HTTP_UPGRADE_REQUIRED = 426,
HTTP_PRECONDITION_REQUIRED = 428,
HTTP_TOO_MANY_REQUESTS = 429,
HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451,
HTTP_INTERNAL_SERVER_ERROR = 500,
HTTP_NOT_IMPLEMENTED = 501,
HTTP_BAD_GATEWAY = 502,
HTTP_SERVICE_UNAVAILABLE = 503,
HTTP_GATEWAY_TIMEOUT = 504,
HTTP_VERSION_NOT_SUPPORTED = 505,
HTTP_VARIANT_ALSO_NEGOTIATES = 506,
HTTP_INSUFFICIENT_STORAGE = 507,
HTTP_LOOP_DETECTED = 508,
HTTP_NOT_EXTENDED = 510,
HTTP_NETWORK_AUTHENTICATION_REQUIRED = 511
};
HTTPResponse();
/// Creates the HTTPResponse with OK status.
HTTPResponse(HTTPStatus status, const std::string& reason);
/// Creates the HTTPResponse with the given status
/// and reason phrase.
HTTPResponse(const std::string& version, HTTPStatus status, const std::string& reason);
/// Creates the HTTPResponse with the given version, status
/// and reason phrase.
explicit HTTPResponse(HTTPStatus status);
/// Creates the HTTPResponse with the given status
/// and an appropriate reason phrase.
HTTPResponse(const std::string& version, HTTPStatus status);
/// Creates the HTTPResponse with the given version, status
/// and an appropriate reason phrase.
HTTPResponse(const HTTPResponse& other);
/// Creates the HTTPResponse by copying another one.
virtual ~HTTPResponse();
/// Destroys the HTTPResponse.
HTTPResponse& operator = (const HTTPResponse& other);
/// Assignment operator.
void setStatus(HTTPStatus status);
/// Sets the HTTP status code.
///
/// Does not change the reason phrase.
HTTPStatus getStatus() const;
/// Returns the HTTP status code.
void setStatus(const std::string& status);
/// Sets the HTTP status code.
///
/// The string must contain a valid
/// HTTP numerical status code.
void setReason(const std::string& reason);
/// Sets the HTTP reason phrase.
const std::string& getReason() const;
/// Returns the HTTP reason phrase.
void setStatusAndReason(HTTPStatus status, const std::string& reason);
/// Sets the HTTP status code and reason phrase.
void setStatusAndReason(HTTPStatus status);
/// Sets the HTTP status code and reason phrase.
///
/// The reason phrase is set according to the status code.
void setDate(const Poco::Timestamp& dateTime);
/// Sets the Date header to the given date/time value.
Poco::Timestamp getDate() const;
/// Returns the value of the Date header.
void addCookie(const HTTPCookie& cookie);
/// Adds the cookie to the response by
/// adding a Set-Cookie header.
void getCookies(std::vector<HTTPCookie>& cookies) const;
/// Returns a vector with all the cookies
/// set in the response header.
///
/// May throw an exception in case of a malformed
/// Set-Cookie header.
void write(std::ostream& ostr) const;
/// Writes the HTTP response to the given
/// output stream.
void read(std::istream& istr);
/// Reads the HTTP response from the
/// given input stream.
///
/// 100 Continue responses are ignored.
static const std::string& getReasonForStatus(HTTPStatus status);
/// Returns an appropriate reason phrase
/// for the given status code.
static const std::string HTTP_REASON_CONTINUE;
static const std::string HTTP_REASON_SWITCHING_PROTOCOLS;
static const std::string HTTP_REASON_PROCESSING;
static const std::string HTTP_REASON_OK;
static const std::string HTTP_REASON_CREATED;
static const std::string HTTP_REASON_ACCEPTED;
static const std::string HTTP_REASON_NONAUTHORITATIVE;
static const std::string HTTP_REASON_NO_CONTENT;
static const std::string HTTP_REASON_RESET_CONTENT;
static const std::string HTTP_REASON_PARTIAL_CONTENT;
static const std::string HTTP_REASON_MULTI_STATUS;
static const std::string HTTP_REASON_ALREADY_REPORTED;
static const std::string HTTP_REASON_IM_USED;
static const std::string HTTP_REASON_MULTIPLE_CHOICES;
static const std::string HTTP_REASON_MOVED_PERMANENTLY;
static const std::string HTTP_REASON_FOUND;
static const std::string HTTP_REASON_SEE_OTHER;
static const std::string HTTP_REASON_NOT_MODIFIED;
static const std::string HTTP_REASON_USE_PROXY;
static const std::string HTTP_REASON_TEMPORARY_REDIRECT;
static const std::string HTTP_REASON_PERMANENT_REDIRECT;
static const std::string HTTP_REASON_BAD_REQUEST;
static const std::string HTTP_REASON_UNAUTHORIZED;
static const std::string HTTP_REASON_PAYMENT_REQUIRED;
static const std::string HTTP_REASON_FORBIDDEN;
static const std::string HTTP_REASON_NOT_FOUND;
static const std::string HTTP_REASON_METHOD_NOT_ALLOWED;
static const std::string HTTP_REASON_NOT_ACCEPTABLE;
static const std::string HTTP_REASON_PROXY_AUTHENTICATION_REQUIRED;
static const std::string HTTP_REASON_REQUEST_TIMEOUT;
static const std::string HTTP_REASON_CONFLICT;
static const std::string HTTP_REASON_GONE;
static const std::string HTTP_REASON_LENGTH_REQUIRED;
static const std::string HTTP_REASON_PRECONDITION_FAILED;
static const std::string HTTP_REASON_REQUEST_ENTITY_TOO_LARGE;
static const std::string HTTP_REASON_REQUEST_URI_TOO_LONG;
static const std::string HTTP_REASON_UNSUPPORTED_MEDIA_TYPE;
static const std::string HTTP_REASON_REQUESTED_RANGE_NOT_SATISFIABLE;
static const std::string HTTP_REASON_EXPECTATION_FAILED;
static const std::string HTTP_REASON_IM_A_TEAPOT;
static const std::string HTTP_REASON_ENCHANCE_YOUR_CALM;
static const std::string HTTP_REASON_MISDIRECTED_REQUEST;
static const std::string HTTP_REASON_UNPROCESSABLE_ENTITY;
static const std::string HTTP_REASON_LOCKED;
static const std::string HTTP_REASON_FAILED_DEPENDENCY;
static const std::string HTTP_REASON_UPGRADE_REQUIRED;
static const std::string HTTP_REASON_PRECONDITION_REQUIRED;
static const std::string HTTP_REASON_TOO_MANY_REQUESTS;
static const std::string HTTP_REASON_REQUEST_HEADER_FIELDS_TOO_LARGE;
static const std::string HTTP_REASON_UNAVAILABLE_FOR_LEGAL_REASONS;
static const std::string HTTP_REASON_INTERNAL_SERVER_ERROR;
static const std::string HTTP_REASON_NOT_IMPLEMENTED;
static const std::string HTTP_REASON_BAD_GATEWAY;
static const std::string HTTP_REASON_SERVICE_UNAVAILABLE;
static const std::string HTTP_REASON_GATEWAY_TIMEOUT;
static const std::string HTTP_REASON_VERSION_NOT_SUPPORTED;
static const std::string HTTP_REASON_VARIANT_ALSO_NEGOTIATES;
static const std::string HTTP_REASON_INSUFFICIENT_STORAGE;
static const std::string HTTP_REASON_LOOP_DETECTED;
static const std::string HTTP_REASON_NOT_EXTENDED;
static const std::string HTTP_REASON_NETWORK_AUTHENTICATION_REQUIRED;
static const std::string HTTP_REASON_UNKNOWN;
static const std::string DATE;
static const std::string SET_COOKIE;
private:
enum Limits
{
MAX_VERSION_LENGTH = 8,
MAX_STATUS_LENGTH = 3,
MAX_REASON_LENGTH = 512
};
HTTPStatus _status;
std::string _reason;
};
//
// inlines
//
inline HTTPResponse::HTTPStatus HTTPResponse::getStatus() const
{
return _status;
}
inline const std::string& HTTPResponse::getReason() const
{
return _reason;
}
} } // namespace Poco::Net
#endif // Net_HTTPResponse_INCLUDED

103
vendor/POCO/Net/include/Poco/Net/HTTPServer.h vendored Normal file
View File

@ -0,0 +1,103 @@
//
// HTTPServer.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServer
//
// Definition of the HTTPServer class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServer_INCLUDED
#define Net_HTTPServer_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/TCPServer.h"
#include "Poco/Net/HTTPRequestHandlerFactory.h"
#include "Poco/Net/HTTPServerParams.h"
namespace Poco {
namespace Net {
class Net_API HTTPServer: public TCPServer
/// A subclass of TCPServer that implements a
/// full-featured multithreaded HTTP server.
///
/// A HTTPRequestHandlerFactory must be supplied.
/// The ServerSocket must be bound and in listening state.
///
/// To configure various aspects of the server, a HTTPServerParams
/// object can be passed to the constructor.
///
/// The server supports:
/// - HTTP/1.0 and HTTP/1.1
/// - automatic handling of persistent connections.
/// - automatic decoding/encoding of request/response message bodies
/// using chunked transfer encoding.
///
/// Please see the TCPServer class for information about
/// connection and thread handling.
///
/// See RFC 2616 <http://www.faqs.org/rfcs/rfc2616.html> for more
/// information about the HTTP protocol.
{
public:
HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, Poco::UInt16 portNumber = 80, HTTPServerParams::Ptr pParams = new HTTPServerParams);
/// Creates HTTPServer listening on the given port (default 80).
///
/// The server takes ownership of the HTTPRequstHandlerFactory
/// and deletes it when it's no longer needed.
///
/// New threads are taken from the default thread pool.
HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, const ServerSocket& socket, HTTPServerParams::Ptr pParams);
/// Creates the HTTPServer, using the given ServerSocket.
///
/// The server takes ownership of the HTTPRequstHandlerFactory
/// and deletes it when it's no longer needed.
///
/// The server also takes ownership of the HTTPServerParams object.
///
/// New threads are taken from the default thread pool.
HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, Poco::ThreadPool& threadPool, const ServerSocket& socket, HTTPServerParams::Ptr pParams);
/// Creates the HTTPServer, using the given ServerSocket.
///
/// The server takes ownership of the HTTPRequstHandlerFactory
/// and deletes it when it's no longer needed.
///
/// The server also takes ownership of the HTTPServerParams object.
///
/// New threads are taken from the given thread pool.
~HTTPServer();
/// Destroys the HTTPServer and its HTTPRequestHandlerFactory.
void stopAll(bool abortCurrent = false);
/// Stops the server. In contrast to TCPServer::stop(), which also
/// stops the server, but allows all client connections to finish at
/// their pace, this allows finer control over client connections.
///
/// If abortCurrent is false, all current requests are allowed to
/// complete. If abortCurrent is true, the underlying sockets of
/// all client connections are shut down, causing all requests
/// to abort.
private:
HTTPRequestHandlerFactory::Ptr _pFactory;
};
} } // namespace Poco::Net
#endif // Net_HTTPServer_INCLUDED

65
vendor/POCO/Net/include/Poco/Net/HTTPServerConnection.h vendored Normal file
View File

@ -0,0 +1,65 @@
//
// HTTPServerConnection.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerConnection
//
// Definition of the HTTPServerConnection class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerConnection_INCLUDED
#define Net_HTTPServerConnection_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/TCPServerConnection.h"
#include "Poco/Net/HTTPResponse.h"
#include "Poco/Net/HTTPRequestHandlerFactory.h"
#include "Poco/Net/HTTPServerParams.h"
#include "Poco/Mutex.h"
namespace Poco {
namespace Net {
class HTTPServerSession;
class Net_API HTTPServerConnection: public TCPServerConnection
/// This subclass of TCPServerConnection handles HTTP
/// connections.
{
public:
HTTPServerConnection(const StreamSocket& socket, HTTPServerParams::Ptr pParams, HTTPRequestHandlerFactory::Ptr pFactory);
/// Creates the HTTPServerConnection.
virtual ~HTTPServerConnection();
/// Destroys the HTTPServerConnection.
void run();
/// Handles all HTTP requests coming in.
protected:
void sendErrorResponse(HTTPServerSession& session, HTTPResponse::HTTPStatus status);
void onServerStopped(const bool& abortCurrent);
private:
HTTPServerParams::Ptr _pParams;
HTTPRequestHandlerFactory::Ptr _pFactory;
bool _stopped;
Poco::FastMutex _mutex;
};
} } // namespace Poco::Net
#endif // Net_HTTPServerConnection_INCLUDED

55
vendor/POCO/Net/include/Poco/Net/HTTPServerConnectionFactory.h vendored Normal file
View File

@ -0,0 +1,55 @@
//
// HTTPServerConnectionFactory.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerConnectionFactory
//
// Definition of the HTTPServerConnectionFactory class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerConnectionFactory_INCLUDED
#define Net_HTTPServerConnectionFactory_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/TCPServerConnectionFactory.h"
#include "Poco/Net/HTTPRequestHandlerFactory.h"
#include "Poco/Net/HTTPServerParams.h"
namespace Poco {
namespace Net {
class Net_API HTTPServerConnectionFactory: public TCPServerConnectionFactory
/// This implementation of a TCPServerConnectionFactory
/// is used by HTTPServer to create HTTPServerConnection objects.
{
public:
HTTPServerConnectionFactory(HTTPServerParams::Ptr pParams, HTTPRequestHandlerFactory::Ptr pFactory);
/// Creates the HTTPServerConnectionFactory.
~HTTPServerConnectionFactory();
/// Destroys the HTTPServerConnectionFactory.
TCPServerConnection* createConnection(const StreamSocket& socket);
/// Creates an instance of HTTPServerConnection
/// using the given StreamSocket.
private:
HTTPServerParams::Ptr _pParams;
HTTPRequestHandlerFactory::Ptr _pFactory;
};
} } // namespace Poco::Net
#endif // Net_HTTPServerConnectionFactory_INCLUDED

154
vendor/POCO/Net/include/Poco/Net/HTTPServerParams.h vendored Normal file
View File

@ -0,0 +1,154 @@
//
// HTTPServerParams.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerParams
//
// Definition of the HTTPServerParams class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerParams_INCLUDED
#define Net_HTTPServerParams_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/TCPServerParams.h"
namespace Poco {
namespace Net {
class Net_API HTTPServerParams: public TCPServerParams
/// This class is used to specify parameters to both the
/// HTTPServer, as well as to HTTPRequestHandler objects.
///
/// Subclasses may add new parameters to the class.
{
public:
using Ptr = Poco::AutoPtr<HTTPServerParams>;
HTTPServerParams();
/// Creates the HTTPServerParams.
///
/// Sets the following default values:
/// - timeout: 60 seconds
/// - keepAlive: true
/// - maxKeepAliveRequests: 0
/// - keepAliveTimeout: 10 seconds
void setServerName(const std::string& serverName);
/// Sets the name and port (name:port) that the server uses to identify itself.
///
/// If this is not set to valid DNS name for your host, server-generated
/// redirections will not work.
const std::string& getServerName() const;
/// Returns the name and port (name:port) that the server uses to identify itself.
void setSoftwareVersion(const std::string& softwareVersion);
/// Sets the server software name and version that the server uses to identify
/// itself. If this is set to a non-empty string, the server will
/// automatically include a Server header field with the value given
/// here in every response it sends.
///
/// The format of the softwareVersion string should be name/version
/// (e.g. MyHTTPServer/1.0).
const std::string& getSoftwareVersion() const;
/// Returns the server software name and version that the server uses to
/// identify itself.
void setTimeout(const Poco::Timespan& timeout);
/// Sets the connection timeout for HTTP connections.
const Poco::Timespan& getTimeout() const;
/// Returns the connection timeout for HTTP connections.
void setKeepAlive(bool keepAlive);
/// Enables (keepAlive == true) or disables (keepAlive == false)
/// persistent connections.
bool getKeepAlive() const;
/// Returns true iff persistent connections are enabled.
void setKeepAliveTimeout(const Poco::Timespan& timeout);
/// Sets the keep-alive timeout for persistent HTTP connections.
const Poco::Timespan& getKeepAliveTimeout() const;
/// Returns the keep-alive timeout for persistent HTTP connections.
void setMaxKeepAliveRequests(int maxKeepAliveRequests);
/// Specifies the maximum number of requests allowed
/// during a persistent connection. 0 means unlimited
/// connections.
int getMaxKeepAliveRequests() const;
/// Returns the maximum number of requests allowed
/// during a persistent connection, or 0 if
/// unlimited connections are allowed.
protected:
virtual ~HTTPServerParams();
/// Destroys the HTTPServerParams.
private:
std::string _serverName;
std::string _softwareVersion;
Poco::Timespan _timeout;
bool _keepAlive;
int _maxKeepAliveRequests;
Poco::Timespan _keepAliveTimeout;
};
//
// inlines
//
inline const std::string& HTTPServerParams::getServerName() const
{
return _serverName;
}
inline const std::string& HTTPServerParams::getSoftwareVersion() const
{
return _softwareVersion;
}
inline const Poco::Timespan& HTTPServerParams::getTimeout() const
{
return _timeout;
}
inline bool HTTPServerParams::getKeepAlive() const
{
return _keepAlive;
}
inline int HTTPServerParams::getMaxKeepAliveRequests() const
{
return _maxKeepAliveRequests;
}
inline const Poco::Timespan& HTTPServerParams::getKeepAliveTimeout() const
{
return _keepAliveTimeout;
}
} } // namespace Poco::Net
#endif // Net_HTTPServerParams_INCLUDED

80
vendor/POCO/Net/include/Poco/Net/HTTPServerRequest.h vendored Normal file
View File

@ -0,0 +1,80 @@
//
// HTTPServerRequest.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerRequest
//
// Definition of the HTTPServerRequest class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerRequest_INCLUDED
#define Net_HTTPServerRequest_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPRequest.h"
#include "Poco/Net/SocketAddress.h"
#include <istream>
namespace Poco {
namespace Net {
class HTTPServerSession;
class HTTPServerResponse;
class HTTPServerParams;
class Net_API HTTPServerRequest: public HTTPRequest
/// This abstract subclass of HTTPRequest is used for
/// representing server-side HTTP requests.
///
/// A HTTPServerRequest is passed to the
/// handleRequest() method of HTTPRequestHandler.
{
public:
HTTPServerRequest();
/// Creates the HTTPServerRequest
~HTTPServerRequest();
/// Destroys the HTTPServerRequest.
virtual std::istream& stream() = 0;
/// Returns the input stream for reading
/// the request body.
///
/// The stream must be valid until the HTTPServerRequest
/// object is destroyed.
virtual const SocketAddress& clientAddress() const = 0;
/// Returns the client's address.
virtual const SocketAddress& serverAddress() const = 0;
/// Returns the server's address.
virtual const HTTPServerParams& serverParams() const = 0;
/// Returns a reference to the server parameters.
virtual HTTPServerResponse& response() const = 0;
/// Returns a reference to the associated response.
virtual bool secure() const = 0;
/// Returns true if the request is using a secure
/// connection. Returns false if no secure connection
/// is used, or if it is not known whether a secure
/// connection is used.
};
} } // namespace Poco::Net
#endif // Net_HTTPServerRequest_INCLUDED

142
vendor/POCO/Net/include/Poco/Net/HTTPServerRequestImpl.h vendored Normal file
View File

@ -0,0 +1,142 @@
//
// HTTPServerRequestImpl.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerRequestImpl
//
// Definition of the HTTPServerRequestImpl class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerRequestImpl_INCLUDED
#define Net_HTTPServerRequestImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPServerRequest.h"
#include "Poco/Net/HTTPServerResponseImpl.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/AutoPtr.h"
#include <istream>
namespace Poco {
namespace Net {
class HTTPServerSession;
class HTTPServerParams;
class StreamSocket;
class Net_API HTTPServerRequestImpl: public HTTPServerRequest
/// This subclass of HTTPServerRequest is used for
/// representing server-side HTTP requests.
///
/// A HTTPServerRequest is passed to the
/// handleRequest() method of HTTPRequestHandler.
{
public:
HTTPServerRequestImpl(HTTPServerResponseImpl& response, HTTPServerSession& session, HTTPServerParams* pParams);
/// Creates the HTTPServerRequestImpl, using the
/// given HTTPServerSession.
~HTTPServerRequestImpl();
/// Destroys the HTTPServerRequestImpl.
std::istream& stream();
/// Returns the input stream for reading
/// the request body.
///
/// The stream is valid until the HTTPServerRequestImpl
/// object is destroyed.
const SocketAddress& clientAddress() const;
/// Returns the client's address.
const SocketAddress& serverAddress() const;
/// Returns the server's address.
const HTTPServerParams& serverParams() const;
/// Returns a reference to the server parameters.
HTTPServerResponse& response() const;
/// Returns a reference to the associated response.
bool secure() const;
/// Returns true if the request is using a secure
/// connection. Returns false if no secure connection
/// is used, or if it is not known whether a secure
/// connection is used.
StreamSocket& socket();
/// Returns a reference to the underlying socket.
StreamSocket detachSocket();
/// Returns the underlying socket after detaching
/// it from the server session.
HTTPServerSession& session();
/// Returns the underlying HTTPServerSession.
private:
HTTPServerResponseImpl& _response;
HTTPServerSession& _session;
std::istream* _pStream;
Poco::AutoPtr<HTTPServerParams> _pParams;
SocketAddress _clientAddress;
SocketAddress _serverAddress;
};
//
// inlines
//
inline std::istream& HTTPServerRequestImpl::stream()
{
poco_check_ptr (_pStream);
return *_pStream;
}
inline const SocketAddress& HTTPServerRequestImpl::clientAddress() const
{
return _clientAddress;
}
inline const SocketAddress& HTTPServerRequestImpl::serverAddress() const
{
return _serverAddress;
}
inline const HTTPServerParams& HTTPServerRequestImpl::serverParams() const
{
return *_pParams;
}
inline HTTPServerResponse& HTTPServerRequestImpl::response() const
{
return _response;
}
inline HTTPServerSession& HTTPServerRequestImpl::session()
{
return _session;
}
} } // namespace Poco::Net
#endif // Net_HTTPServerRequestImpl_INCLUDED

116
vendor/POCO/Net/include/Poco/Net/HTTPServerResponse.h vendored Normal file
View File

@ -0,0 +1,116 @@
//
// HTTPServerResponse.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerResponse
//
// Definition of the HTTPServerResponse class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerResponse_INCLUDED
#define Net_HTTPServerResponse_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPResponse.h"
#include <cstddef>
#include <ostream>
namespace Poco {
namespace Net {
class HTTPServerSession;
class HTTPCookie;
class Net_API HTTPServerResponse: public HTTPResponse
/// This subclass of HTTPResponse is used for
/// representing server-side HTTP responses.
///
/// A HTTPServerResponse is passed to the
/// handleRequest() method of HTTPRequestHandler.
///
/// handleRequest() must set a status code
/// and optional reason phrase, set headers
/// as necessary, and provide a message body.
{
public:
HTTPServerResponse();
/// Creates the HTTPServerResponse.
~HTTPServerResponse();
/// Destroys the HTTPServerResponse.
virtual void sendContinue() = 0;
/// Sends a 100 Continue response to the
/// client.
virtual std::ostream& send() = 0;
/// Sends the response header to the client and
/// returns an output stream for sending the
/// response body.
///
/// The returned stream is valid until the response
/// object is destroyed.
///
/// Must not be called after sendFile(), sendBuffer()
/// or redirect() has been called.
virtual void sendFile(const std::string& path, const std::string& mediaType) = 0;
/// Sends the response header to the client, followed
/// by the content of the given file.
///
/// Must not be called after send(), sendBuffer()
/// or redirect() has been called.
///
/// Throws a FileNotFoundException if the file
/// cannot be found, or an OpenFileException if
/// the file cannot be opened.
virtual void sendBuffer(const void* pBuffer, std::size_t length) = 0;
/// Sends the response header to the client, followed
/// by the contents of the given buffer.
///
/// The Content-Length header of the response is set
/// to length and chunked transfer encoding is disabled.
///
/// If both the HTTP message header and body (from the
/// given buffer) fit into one single network packet, the
/// complete response can be sent in one network packet.
///
/// Must not be called after send(), sendFile()
/// or redirect() has been called.
virtual void redirect(const std::string& uri, HTTPStatus status = HTTP_FOUND) = 0;
/// Sets the status code, which must be one of
/// HTTP_MOVED_PERMANENTLY (301), HTTP_FOUND (302),
/// or HTTP_SEE_OTHER (303),
/// and sets the "Location" header field
/// to the given URI, which according to
/// the HTTP specification, must be absolute.
///
/// Must not be called after send() has been called.
virtual void requireAuthentication(const std::string& realm) = 0;
/// Sets the status code to 401 (Unauthorized)
/// and sets the "WWW-Authenticate" header field
/// according to the given realm.
virtual bool sent() const = 0;
/// Returns true if the response (header) has been sent.
};
} } // namespace Poco::Net
#endif // Net_HTTPServerResponse_INCLUDED

139
vendor/POCO/Net/include/Poco/Net/HTTPServerResponseImpl.h vendored Normal file
View File

@ -0,0 +1,139 @@
//
// HTTPServerResponseImpl.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerResponseImpl
//
// Definition of the HTTPServerResponseImpl class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerResponseImpl_INCLUDED
#define Net_HTTPServerResponseImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPServerResponse.h"
namespace Poco {
namespace Net {
class HTTPServerSession;
class HTTPServerRequestImpl;
class Net_API HTTPServerResponseImpl: public HTTPServerResponse
/// This subclass of HTTPServerResponse is used for
/// representing server-side HTTP responses.
///
/// A HTTPServerResponse is passed to the
/// handleRequest() method of HTTPRequestHandler.
///
/// handleRequest() must set a status code
/// and optional reason phrase, set headers
/// as necessary, and provide a message body.
{
public:
HTTPServerResponseImpl(HTTPServerSession& session);
/// Creates the HTTPServerResponseImpl.
~HTTPServerResponseImpl();
/// Destroys the HTTPServerResponseImpl.
void sendContinue();
/// Sends a 100 Continue response to the
/// client.
std::ostream& send();
/// Sends the response header to the client and
/// returns an output stream for sending the
/// response body.
///
/// The returned stream is valid until the response
/// object is destroyed.
///
/// Must not be called after sendFile(), sendBuffer()
/// or redirect() has been called.
void sendFile(const std::string& path, const std::string& mediaType);
/// Sends the response header to the client, followed
/// by the content of the given file.
///
/// Must not be called after send(), sendBuffer()
/// or redirect() has been called.
///
/// Throws a FileNotFoundException if the file
/// cannot be found, or an OpenFileException if
/// the file cannot be opened.
void sendBuffer(const void* pBuffer, std::size_t length);
/// Sends the response header to the client, followed
/// by the contents of the given buffer.
///
/// The Content-Length header of the response is set
/// to length and chunked transfer encoding is disabled.
///
/// If both the HTTP message header and body (from the
/// given buffer) fit into one single network packet, the
/// complete response can be sent in one network packet.
///
/// Must not be called after send(), sendFile()
/// or redirect() has been called.
void redirect(const std::string& uri, HTTPStatus status = HTTP_FOUND);
/// Sets the status code, which must be one of
/// HTTP_MOVED_PERMANENTLY (301), HTTP_FOUND (302),
/// or HTTP_SEE_OTHER (303),
/// and sets the "Location" header field
/// to the given URI, which according to
/// the HTTP specification, must be absolute.
///
/// Must not be called after send() has been called.
void requireAuthentication(const std::string& realm);
/// Sets the status code to 401 (Unauthorized)
/// and sets the "WWW-Authenticate" header field
/// according to the given realm.
bool sent() const;
/// Returns true if the response (header) has been sent.
protected:
void attachRequest(HTTPServerRequestImpl* pRequest);
private:
HTTPServerSession& _session;
HTTPServerRequestImpl* _pRequest;
std::ostream* _pStream;
friend class HTTPServerRequestImpl;
};
//
// inlines
//
inline bool HTTPServerResponseImpl::sent() const
{
return _pStream != 0;
}
inline void HTTPServerResponseImpl::attachRequest(HTTPServerRequestImpl* pRequest)
{
_pRequest = pRequest;
}
} } // namespace Poco::Net
#endif // Net_HTTPServerResponseImpl_INCLUDED

76
vendor/POCO/Net/include/Poco/Net/HTTPServerSession.h vendored Normal file
View File

@ -0,0 +1,76 @@
//
// HTTPServerSession.h
//
// Library: Net
// Package: HTTPServer
// Module: HTTPServerSession
//
// Definition of the HTTPServerSession class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPServerSession_INCLUDED
#define Net_HTTPServerSession_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPSession.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/Net/HTTPServerSession.h"
#include "Poco/Net/HTTPServerParams.h"
#include "Poco/Timespan.h"
namespace Poco {
namespace Net {
class Net_API HTTPServerSession: public HTTPSession
/// This class handles the server side of a
/// HTTP session. It is used internally by
/// HTTPServer.
{
public:
HTTPServerSession(const StreamSocket& socket, HTTPServerParams::Ptr pParams);
/// Creates the HTTPServerSession.
virtual ~HTTPServerSession();
/// Destroys the HTTPServerSession.
bool hasMoreRequests();
/// Returns true if there are requests available.
bool canKeepAlive() const;
/// Returns true if the session can be kept alive.
SocketAddress clientAddress();
/// Returns the client's address.
SocketAddress serverAddress();
/// Returns the server's address.
private:
bool _firstRequest;
Poco::Timespan _keepAliveTimeout;
int _maxKeepAliveRequests;
};
//
// inlines
//
inline bool HTTPServerSession::canKeepAlive() const
{
return _maxKeepAliveRequests != 0;
}
} } // namespace Poco::Net
#endif // Net_HTTPServerSession_INCLUDED

251
vendor/POCO/Net/include/Poco/Net/HTTPSession.h vendored Normal file
View File

@ -0,0 +1,251 @@
//
// HTTPSession.h
//
// Library: Net
// Package: HTTP
// Module: HTTPSession
//
// Definition of the HTTPSession class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPSession_INCLUDED
#define Net_HTTPSession_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Timespan.h"
#include "Poco/Exception.h"
#include "Poco/Any.h"
#include "Poco/Buffer.h"
#include <ios>
namespace Poco {
namespace Net {
class Net_API HTTPSession
/// HTTPSession implements basic HTTP session management
/// for both HTTP clients and HTTP servers.
///
/// HTTPSession implements buffering for HTTP connections, as well
/// as specific support for the various HTTP stream classes.
///
/// This class can not be instantiated. HTTPClientSession or
/// HTTPServerSession must be used instead.
{
public:
void setKeepAlive(bool keepAlive);
/// Sets the keep-alive flag for this session.
///
/// If the keep-alive flag is enabled, persistent
/// HTTP/1.1 connections are supported.
bool getKeepAlive() const;
/// Returns the value of the keep-alive flag for
/// this session.
void setTimeout(const Poco::Timespan& timeout);
/// Sets the timeout for the HTTP session.
void setTimeout(const Poco::Timespan& connectionTimeout, const Poco::Timespan& sendTimeout, const Poco::Timespan& receiveTimeout);
/// Sets different timeouts for the HTTP session.
Poco::Timespan getTimeout() const;
/// Returns the timeout for the HTTP session.
bool connected() const;
/// Returns true if the underlying socket is connected.
virtual void abort();
/// Aborts a session in progress by shutting down
/// and closing the underlying socket.
const Poco::Exception* networkException() const;
/// If sending or receiving data over the underlying
/// socket connection resulted in an exception, a
/// pointer to this exception is returned.
///
/// Otherwise, NULL is returned.
void attachSessionData(const Poco::Any& data);
/// Allows to attach an application-specific data
/// item to the session.
///
/// On the server side, this can be used to manage
/// data that must be maintained over the entire
/// lifetime of a persistent connection (that is,
/// multiple requests sent over the same connection).
const Poco::Any& sessionData() const;
/// Returns the data attached with attachSessionData(),
/// or an empty Poco::Any if no user data has been
/// attached.
enum
{
HTTP_PORT = 80
};
StreamSocket detachSocket();
/// Detaches the socket from the session.
///
/// The socket is returned, and a new, uninitialized socket is
/// attached to the session.
StreamSocket& socket();
/// Returns a reference to the underlying socket.
void drainBuffer(Poco::Buffer<char>& buffer);
/// Copies all bytes remaining in the internal buffer to the
/// given Poco::Buffer, resizing it as necessary.
///
/// This is usually used together with detachSocket() to
/// obtain any data already read from the socket, but not
/// yet processed.
protected:
HTTPSession();
/// Creates a HTTP session using an
/// unconnected stream socket.
HTTPSession(const StreamSocket& socket);
/// Creates a HTTP session using the
/// given socket. The session takes ownership
/// of the socket and closes it when it's no
/// longer used.
HTTPSession(const StreamSocket& socket, bool keepAlive);
/// Creates a HTTP session using the
/// given socket. The session takes ownership
/// of the socket and closes it when it's no
/// longer used.
virtual ~HTTPSession();
/// Destroys the HTTPSession and closes the
/// underlying socket.
int get();
/// Returns the next byte in the buffer.
/// Reads more data from the socket if there are
/// no bytes left in the buffer.
int peek();
/// Peeks at the next character in the buffer.
/// Reads more data from the socket if there are
/// no bytes left in the buffer.
virtual int read(char* buffer, std::streamsize length);
/// Reads up to length bytes.
///
/// If there is data in the buffer, this data
/// is returned. Otherwise, data is read from
/// the socket to avoid unnecessary buffering.
virtual int write(const char* buffer, std::streamsize length);
/// Writes data to the socket.
int receive(char* buffer, int length);
/// Reads up to length bytes.
int buffered() const;
/// Returns the number of bytes in the buffer.
void refill();
/// Refills the internal buffer.
virtual void connect(const SocketAddress& address);
/// Connects the underlying socket to the given address
/// and sets the socket's receive timeout.
void attachSocket(const StreamSocket& socket);
/// Attaches a socket to the session, replacing the
/// previously attached socket.
void close();
/// Closes the underlying socket.
void setException(const Poco::Exception& exc);
/// Stores a clone of the exception.
void clearException();
/// Clears the stored exception.
private:
enum
{
HTTP_DEFAULT_TIMEOUT = 60000000,
HTTP_DEFAULT_CONNECTION_TIMEOUT = 30000000
};
HTTPSession(const HTTPSession&);
HTTPSession& operator = (const HTTPSession&);
StreamSocket _socket;
char* _pBuffer;
char* _pCurrent;
char* _pEnd;
bool _keepAlive;
Poco::Timespan _connectionTimeout;
Poco::Timespan _receiveTimeout;
Poco::Timespan _sendTimeout;
Poco::Exception* _pException;
Poco::Any _data;
friend class HTTPStreamBuf;
friend class HTTPHeaderStreamBuf;
friend class HTTPFixedLengthStreamBuf;
friend class HTTPChunkedStreamBuf;
};
//
// inlines
//
inline bool HTTPSession::getKeepAlive() const
{
return _keepAlive;
}
inline Poco::Timespan HTTPSession::getTimeout() const
{
return _receiveTimeout;
}
inline StreamSocket& HTTPSession::socket()
{
return _socket;
}
inline const Poco::Exception* HTTPSession::networkException() const
{
return _pException;
}
inline int HTTPSession::buffered() const
{
return static_cast<int>(_pEnd - _pCurrent);
}
inline const Poco::Any& HTTPSession::sessionData() const
{
return _data;
}
} } // namespace Poco::Net
#endif // Net_HTTPSession_INCLUDED

155
vendor/POCO/Net/include/Poco/Net/HTTPSessionFactory.h vendored Normal file
View File

@ -0,0 +1,155 @@
//
// HTTPSessionFactory.h
//
// Library: Net
// Package: HTTPClient
// Module: HTTPSessionFactory
//
// Definition of the HTTPSessionFactory class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPSessionFactoryMgr_INCLUDED
#define Net_HTTPSessionFactoryMgr_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Mutex.h"
#include "Poco/URI.h"
#include "Poco/SingletonHolder.h"
#include "Poco/SharedPtr.h"
#include <map>
namespace Poco {
namespace Net {
class HTTPSessionInstantiator;
class HTTPClientSession;
class Net_API HTTPSessionFactory
/// A factory for HTTPClientSession objects.
///
/// Given a URI, this class creates a HTTPClientSession
/// (for http) or a HTTPSClientSession (for https) for
/// accessing the URI.
///
/// The actual work of creating the session is done by
/// HTTPSessionInstantiator objects that must be registered
/// with a HTTPSessionFactory.
{
public:
HTTPSessionFactory();
/// Creates the HTTPSessionFactory.
HTTPSessionFactory(const std::string& proxyHost, Poco::UInt16 proxyPort);
/// Creates the HTTPSessionFactory and sets the proxy host and port.
~HTTPSessionFactory();
/// Destroys the HTTPSessionFactory.
void registerProtocol(const std::string& protocol, HTTPSessionInstantiator* pSessionInstantiator);
/// Registers the session instantiator for the given protocol.
/// The factory takes ownership of the SessionInstantiator.
///
/// A protocol can be registered more than once. However, only the instantiator
/// that has been registered first is used. Also, for each call to
/// registerProtocol(), a corresponding call to unregisterProtocol() must
/// be made.
void unregisterProtocol(const std::string& protocol);
/// Removes the registration of a protocol.
///
/// Throws a NotFoundException if no instantiator has been registered
/// for the given protocol.
bool supportsProtocol(const std::string& protocol);
/// Returns true if a session instantiator for the given protocol has been registered.
HTTPClientSession* createClientSession(const Poco::URI& uri);
/// Creates a client session for the given uri scheme. Throws exception if no factory is registered for the given scheme
const std::string& proxyHost() const;
/// Returns the proxy host, if one has been set, or an empty string otherwise.
Poco::UInt16 proxyPort() const;
/// Returns the proxy port number, if one has been set, or zero otherwise.
void setProxy(const std::string& proxyHost, Poco::UInt16 proxyPort);
/// Sets the proxy host and port number.
void setProxyCredentials(const std::string& username, const std::string& password);
/// Sets the username and password for proxy authorization (Basic auth only).
const std::string& proxyUsername() const;
/// Returns the username for proxy authorization.
const std::string& proxyPassword() const;
/// Returns the password for proxy authorization.
static HTTPSessionFactory& defaultFactory();
/// Returns the default HTTPSessionFactory.
private:
struct InstantiatorInfo
{
HTTPSessionInstantiator* pIn;
int cnt;
InstantiatorInfo(HTTPSessionInstantiator* pInst);
// no destructor!!! this is by purpose, don't add one!
};
HTTPSessionFactory(const HTTPSessionFactory&);
HTTPSessionFactory& operator = (const HTTPSessionFactory&);
typedef std::map<std::string, InstantiatorInfo> Instantiators;
Instantiators _instantiators;
std::string _proxyHost;
Poco::UInt16 _proxyPort;
std::string _proxyUsername;
std::string _proxyPassword;
mutable Poco::FastMutex _mutex;
};
//
// inlines
//
inline const std::string& HTTPSessionFactory::proxyHost() const
{
return _proxyHost;
}
inline Poco::UInt16 HTTPSessionFactory::proxyPort() const
{
return _proxyPort;
}
inline const std::string& HTTPSessionFactory::proxyUsername() const
{
return _proxyUsername;
}
inline const std::string& HTTPSessionFactory::proxyPassword() const
{
return _proxyPassword;
}
} } // namespace Poco::Net
#endif // Net_HTTPSessionFactoryMgr_INCLUDED

117
vendor/POCO/Net/include/Poco/Net/HTTPSessionInstantiator.h vendored Normal file
View File

@ -0,0 +1,117 @@
//
// HTTPSessionInstantiator.h
//
// Library: Net
// Package: HTTPClient
// Module: HTTPSessionInstantiator
//
// Definition of the HTTPSessionInstantiator class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPSessionInstantiator_INCLUDED
#define Net_HTTPSessionInstantiator_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPSession.h"
#include "Poco/URI.h"
namespace Poco {
namespace Net {
class HTTPClientSession;
class Net_API HTTPSessionInstantiator
/// A factory for HTTPClientSession objects.
///
/// Creates a HTTP session for a given URI.
/// A HTTPSessionInstantiator is not used directly.
/// Instances are registered with a HTTPSessionFactory,
/// and used through it.
{
public:
HTTPSessionInstantiator();
/// Creates the HTTPSessionInstantiator.
virtual ~HTTPSessionInstantiator();
/// Destroys the HTTPSessionInstantiator.
virtual HTTPClientSession* createClientSession(const Poco::URI& uri);
/// Creates a HTTPClientSession for the given URI.
static void registerInstantiator();
/// Registers the instantiator with the global HTTPSessionFactory.
static void unregisterInstantiator();
/// Unregisters the factory with the global HTTPSessionFactory.
protected:
void setProxy(const std::string& host, Poco::UInt16 port);
/// Sets the proxy host and port.
/// Called by HTTPSessionFactory.
const std::string& proxyHost() const;
/// Returns the proxy post.
Poco::UInt16 proxyPort() const;
/// Returns the proxy port.
void setProxyCredentials(const std::string& username, const std::string& password);
/// Sets the username and password for proxy authorization (Basic auth only).
const std::string& proxyUsername() const;
/// Returns the username for proxy authorization.
const std::string& proxyPassword() const;
/// Returns the password for proxy authorization.
private:
std::string _proxyHost;
Poco::UInt16 _proxyPort;
std::string _proxyUsername;
std::string _proxyPassword;
friend class HTTPSessionFactory;
};
//
// inlines
//
inline const std::string& HTTPSessionInstantiator::proxyHost() const
{
return _proxyHost;
}
inline Poco::UInt16 HTTPSessionInstantiator::proxyPort() const
{
return _proxyPort;
}
inline const std::string& HTTPSessionInstantiator::proxyUsername() const
{
return _proxyUsername;
}
inline const std::string& HTTPSessionInstantiator::proxyPassword() const
{
return _proxyPassword;
}
} } // namespace Poco::Net
#endif // Net_HTTPSessionInstantiator_INCLUDED

103
vendor/POCO/Net/include/Poco/Net/HTTPStream.h vendored Normal file
View File

@ -0,0 +1,103 @@
//
// HTTPStream.h
//
// Library: Net
// Package: HTTP
// Module: HTTPStream
//
// Definition of the HTTPStream class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPStream_INCLUDED
#define Net_HTTPStream_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPBasicStreamBuf.h"
#include "Poco/MemoryPool.h"
#include <cstddef>
#include <istream>
#include <ostream>
namespace Poco {
namespace Net {
class HTTPSession;
class Net_API HTTPStreamBuf: public HTTPBasicStreamBuf
/// This is the streambuf class used for reading and writing
/// HTTP message bodies.
{
public:
using openmode = HTTPBasicStreamBuf::openmode;
HTTPStreamBuf(HTTPSession& session, openmode mode);
~HTTPStreamBuf();
void close();
protected:
int readFromDevice(char* buffer, std::streamsize length);
int writeToDevice(const char* buffer, std::streamsize length);
private:
HTTPSession& _session;
openmode _mode;
};
class Net_API HTTPIOS: public virtual std::ios
/// The base class for HTTPInputStream.
{
public:
HTTPIOS(HTTPSession& session, HTTPStreamBuf::openmode mode);
~HTTPIOS();
HTTPStreamBuf* rdbuf();
protected:
HTTPStreamBuf _buf;
};
class Net_API HTTPInputStream: public HTTPIOS, public std::istream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPInputStream(HTTPSession& session);
~HTTPInputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
class Net_API HTTPOutputStream: public HTTPIOS, public std::ostream
/// This class is for internal use by HTTPSession only.
{
public:
HTTPOutputStream(HTTPSession& session);
~HTTPOutputStream();
void* operator new(std::size_t size);
void operator delete(void* ptr);
private:
static Poco::MemoryPool _pool;
};
} } // namespace Poco::Net
#endif // Net_HTTPStream_INCLUDED

92
vendor/POCO/Net/include/Poco/Net/HTTPStreamFactory.h vendored Normal file
View File

@ -0,0 +1,92 @@
//
// HTTPStreamFactory.h
//
// Library: Net
// Package: HTTP
// Module: HTTPStreamFactory
//
// Definition of the HTTPStreamFactory class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HTTPStreamFactory_INCLUDED
#define Net_HTTPStreamFactory_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/HTTPSession.h"
#include "Poco/URIStreamFactory.h"
namespace Poco {
namespace Net {
class Net_API HTTPStreamFactory: public Poco::URIStreamFactory
/// An implementation of the URIStreamFactory interface
/// that handles Hyper-Text Transfer Protocol (http) URIs.
{
public:
HTTPStreamFactory();
/// Creates the HTTPStreamFactory.
HTTPStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort = HTTPSession::HTTP_PORT);
/// Creates the HTTPStreamFactory.
///
/// HTTP connections will use the given proxy.
HTTPStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort, const std::string& proxyUsername, const std::string& proxyPassword);
/// Creates the HTTPStreamFactory.
///
/// HTTP connections will use the given proxy and
/// will be authorized against the proxy using Basic authentication
/// with the given proxyUsername and proxyPassword.
virtual ~HTTPStreamFactory();
/// Destroys the HTTPStreamFactory.
virtual std::istream* open(const Poco::URI& uri);
/// Creates and opens a HTTP stream for the given URI.
/// The URI must be a http://... URI.
///
/// Throws a NetException if anything goes wrong.
///
/// Redirect responses are handled and the redirect
/// location is automatically resolved, as long
/// as the redirect location is still accessible
/// via the HTTP protocol. If a redirection to
/// a non http://... URI is received, a
/// UnsupportedRedirectException exception is thrown.
/// The offending URI can then be obtained via the message()
/// method of UnsupportedRedirectException.
static void registerFactory();
/// Registers the HTTPStreamFactory with the
/// default URIStreamOpener instance.
static void unregisterFactory();
/// Unregisters the HTTPStreamFactory with the
/// default URIStreamOpener instance.
private:
enum
{
MAX_REDIRECTS = 10
};
std::string _proxyHost;
Poco::UInt16 _proxyPort;
std::string _proxyUsername;
std::string _proxyPassword;
};
} } // namespace Poco::Net
#endif // Net_HTTPStreamFactory_INCLUDED

115
vendor/POCO/Net/include/Poco/Net/HostEntry.h vendored Normal file
View File

@ -0,0 +1,115 @@
//
// HostEntry.h
//
// Library: Net
// Package: NetCore
// Module: HostEntry
//
// Definition of the HostEntry class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_HostEntry_INCLUDED
#define Net_HostEntry_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketDefs.h"
#include "Poco/Net/IPAddress.h"
#include <vector>
namespace Poco {
namespace Net {
class Net_API HostEntry
/// This class stores information about a host
/// such as host name, alias names and a list
/// of IP addresses.
{
public:
using AliasList = std::vector<std::string>;
using AddressList = std::vector<IPAddress>;
HostEntry();
/// Creates an empty HostEntry.
HostEntry(struct hostent* entry);
/// Creates the HostEntry from the data in a hostent structure.
#if defined(POCO_HAVE_IPv6) || defined(POCO_HAVE_ADDRINFO)
HostEntry(struct addrinfo* info);
/// Creates the HostEntry from the data in an addrinfo structure.
#endif
#if defined(POCO_VXWORKS)
HostEntry(const std::string& name, const IPAddress& addr);
#endif
HostEntry(const HostEntry& entry);
/// Creates the HostEntry by copying another one.
HostEntry& operator = (const HostEntry& entry);
/// Assigns another HostEntry.
void swap(HostEntry& hostEntry);
/// Swaps the HostEntry with another one.
~HostEntry();
/// Destroys the HostEntry.
const std::string& name() const;
/// Returns the canonical host name.
const AliasList& aliases() const;
/// Returns a vector containing alias names for
/// the host name.
const AddressList& addresses() const;
/// Returns a vector containing the IPAddresses
/// for the host.
private:
std::string _name;
AliasList _aliases;
AddressList _addresses;
};
//
// inlines
//
inline const std::string& HostEntry::name() const
{
return _name;
}
inline const HostEntry::AliasList& HostEntry::aliases() const
{
return _aliases;
}
inline const HostEntry::AddressList& HostEntry::addresses() const
{
return _addresses;
}
inline void swap(HostEntry& h1, HostEntry& h2)
{
h1.swap(h2);
}
} } // namespace Poco::Net
#endif // Net_HostEntry_INCLUDED

97
vendor/POCO/Net/include/Poco/Net/ICMPClient.h vendored Normal file
View File

@ -0,0 +1,97 @@
//
// ICMPClient.h
//
// Library: Net
// Package: ICMP
// Module: ICMPClient
//
// Definition of the ICMPClient class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ICMPClient_INCLUDED
#define Net_ICMPClient_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/ICMPSocket.h"
#include "Poco/Net/ICMPEventArgs.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/BasicEvent.h"
namespace Poco {
namespace Net {
class Net_API ICMPClient
/// This class provides ICMP Ping functionality.
///
/// The events are available when class is instantiated
/// and non-static member functions are called.
///
/// A "lightweight" alternative is direct (without instantiation)
/// use of static member functions.
{
public:
mutable Poco::BasicEvent<ICMPEventArgs> pingBegin;
mutable Poco::BasicEvent<ICMPEventArgs> pingReply;
mutable Poco::BasicEvent<ICMPEventArgs> pingError;
mutable Poco::BasicEvent<ICMPEventArgs> pingEnd;
explicit ICMPClient(SocketAddress::Family family, int dataSize = 48, int ttl = 128, int timeout = 50000);
/// Creates an ICMP client.
~ICMPClient();
/// Destroys the ICMP client.
int ping(SocketAddress& address, int repeat = 1) const;
/// Pings the specified address [repeat] times.
/// Notifications are posted for events.
///
/// Returns the number of valid replies.
int ping(const std::string& address, int repeat = 1) const;
/// Calls ICMPClient::ping(SocketAddress&, int) and
/// returns the result.
///
/// Returns the number of valid replies.
static int ping(SocketAddress& address,
SocketAddress::Family family,
int repeat = 1,
int dataSize = 48,
int ttl = 128,
int timeout = 100000);
/// Pings the specified address [repeat] times.
/// Notifications are not posted for events.
///
/// Returns the number of valid replies.
static int pingIPv4(const std::string& address,
int repeat = 1,
int dataSize = 48,
int ttl = 128,
int timeout = 100000);
/// Calls ICMPClient::ping(SocketAddress&, int) and
/// returns the result.
///
/// Returns the number of valid replies.
private:
mutable SocketAddress::Family _family;
int _dataSize;
int _ttl;
int _timeout;
};
} } // namespace Poco::Net
#endif // Net_ICMPClient_INCLUDED

163
vendor/POCO/Net/include/Poco/Net/ICMPEventArgs.h vendored Normal file
View File

@ -0,0 +1,163 @@
//
// ICMPEventArgs.h
//
// Library: Net
// Package: ICMP
// Module: ICMPEventArgs
//
// Definition of ICMPEventArgs.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ICMPEventArgs_INCLUDED
#define Net_ICMPEventArgs_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketAddress.h"
#include <vector>
#include <algorithm>
namespace Poco {
namespace Net {
class Net_API ICMPEventArgs
/// The purpose of the ICMPEventArgs class is to be used as template parameter
/// to instantiate event members in ICMPClient class.
/// When clients register for an event notification, the reference to the class is
/// passed to the handler function to provide information about the event.
{
public:
ICMPEventArgs(const SocketAddress& address, int repetitions, int dataSize, int ttl);
/// Creates ICMPEventArgs.
virtual ~ICMPEventArgs();
/// Destroys ICMPEventArgs.
std::string hostName() const;
/// Tries to resolve the target IP address into host name.
/// If unsuccessful, all exceptions are silently ignored and
/// the IP address is returned.
std::string hostAddress() const;
/// Returns the target IP address.
int repetitions() const;
/// Returns the number of repetitions for the ping operation.
int dataSize() const;
/// Returns the packet data size in bytes.
int ttl() const;
/// Returns time to live.
int sent() const;
/// Returns the number of packets sent.
int received() const;
/// Returns the number of packets received.
int replyTime(int index = -1) const;
/// Returns the reply time for the request specified with index.
/// If index == -1 (default), returns the most recent reply time.
const std::string& error(int index = -1) const;
/// Returns the error string for the request specified with index.
/// If index == -1 (default), returns the most recent error string.
int minRTT() const;
/// Returns the minimum round trip time for a sequence of requests.
int maxRTT() const;
/// Returns the maximum round trip time for a sequence of requests.
int avgRTT() const;
/// Returns the average round trip time for a sequence of requests.
float percent() const;
/// Returns the success percentage for a sequence of requests.
private:
ICMPEventArgs();
void setRepetitions(int repetitions);
void setDataSize(int sz);
void setTTL(int timeToLive);
void setReplyTime(int index, int time);
void setError(int index, const std::string& text);
ICMPEventArgs& operator ++ ();
ICMPEventArgs operator ++ (int);
SocketAddress _address;
int _sent;
int _dataSize;
int _ttl;
std::vector<int> _rtt;
std::vector<std::string> _errors;
friend class ICMPClient;
};
//
// inlines
//
inline int ICMPEventArgs::repetitions() const
{
return (int) _rtt.size();
}
inline void ICMPEventArgs::setDataSize(int sz)
{
_dataSize = sz;
}
inline int ICMPEventArgs::dataSize() const
{
return _dataSize;
}
inline void ICMPEventArgs::setTTL(int timeToLive)
{
_ttl = timeToLive;
}
inline int ICMPEventArgs::ttl() const
{
return _ttl;
}
inline int ICMPEventArgs::sent() const
{
return _sent;
}
inline int ICMPEventArgs::minRTT() const
{
return *std::min_element(_rtt.begin(), _rtt.end());
}
inline int ICMPEventArgs::maxRTT() const
{
return *std::max_element(_rtt.begin(), _rtt.end());
}
} } // namespace Poco::Net
#endif

91
vendor/POCO/Net/include/Poco/Net/ICMPPacket.h vendored Normal file
View File

@ -0,0 +1,91 @@
//
// ICMPPacket.h
//
// Library: Net
// Package: ICMP
// Module: ICMPPacket
//
// Definition of the ICMPPacket class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ICMPPacket_INCLUDED
#define Net_ICMPPacket_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Net/Socket.h"
#include "Poco/Net/ICMPPacketImpl.h"
namespace Poco {
namespace Net {
class Net_API ICMPPacket
/// This class is the ICMP packet abstraction.
{
public:
ICMPPacket(SocketAddress::Family family, int dataSize = 48);
/// Creates an ICMPPacket of specified family.
~ICMPPacket();
/// Destroys the ICMPPacket.
const Poco::UInt8* packet();
/// Returns raw ICMP packet. ICMP header and data are included in the returned packet.
int packetSize() const;
/// Returns the total length of packet (header + data);
Poco::UInt16 sequence() const;
/// Returns the most recent sequence number generated.
void setDataSize(int dataSize);
/// Sets data size.
int getDataSize() const;
/// Returns data size.
int maxPacketSize() const;
/// Returns the total length of packet (header + data);
struct timeval time(Poco::UInt8* buffer = 0, int length = 0) const;
/// Returns current epoch time if either buffer or length are equal to zero.
/// Otherwise, it extracts the time value from the supplied buffer and
/// returns the extracted value.
///
/// Supplied buffer includes IP header, ICMP header and data.
bool validReplyID(Poco::UInt8* buffer, int length) const;
/// Returns true if the extracted id is recognized
/// (equals the process id).
///
/// Supplied buffer includes IP header, ICMP header and data.
std::string errorDescription(Poco::UInt8* buffer, int length, int& type, int& code);
/// Returns error description string.
/// If supplied buffer contains an ICMP echo reply packet, an
/// empty string is returned indicating the absence of error.
/// If type and code of the error can be determined, they are
/// assigned to the type and code respectively.
///
/// Supplied buffer includes IP header, ICMP header and data.
std::string typeDescription(int typeId);
/// Returns the description of the packet type.
private:
ICMPPacketImpl* _pImpl;
};
} } // namespace Poco::Net
#endif // Net_ICMPPacket_INCLUDED

144
vendor/POCO/Net/include/Poco/Net/ICMPPacketImpl.h vendored Normal file
View File

@ -0,0 +1,144 @@
//
// ICMPPacketImpl.h
//
// Library: Net
// Package: ICMP
// Module: ICMPPacketImpl
//
// Definition of the ICMPPacketImpl class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ICMPPacketImpl_INCLUDED
#define Net_ICMPPacketImpl_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Net/Socket.h"
namespace Poco {
namespace Net {
class Net_API ICMPPacketImpl
/// This is the abstract class for ICMP packet implementations.
{
public:
ICMPPacketImpl(int dataSize = 48);
/// Constructor. Creates an ICMPPacketImpl.
virtual ~ICMPPacketImpl();
/// Destructor.
const Poco::UInt8* packet(bool init = true);
/// Returns raw ICMP packet.
/// ICMP header and data are included in the packet.
/// If init is true, initPacket() is called.
virtual int packetSize() const = 0;
/// Returns the total size of packet (ICMP header + data) in number of octets.
/// Must be overriden.
virtual int maxPacketSize() const;
/// Returns the maximum permitted size of packet in number of octets.
Poco::UInt16 sequence() const;
/// Returns the most recent sequence number generated.
void setDataSize(int dataSize);
/// Sets data size.
int getDataSize() const;
/// Returns data size.
virtual struct timeval time(Poco::UInt8* buffer = 0, int length = 0) const = 0;
/// Returns current epoch time if either argument is equal to zero.
/// Otherwise, it extracts the time value from the supplied buffer.
///
/// Supplied buffer includes IP header, ICMP header and data.
/// Must be overriden.
virtual bool validReplyID(unsigned char* buffer, int length) const = 0;
/// Returns true if the extracted id is recognized
/// (i.e. equals the process id).
///
/// Supplied buffer includes IP header, ICMP header and data.
/// Must be overriden.
virtual std::string errorDescription(Poco::UInt8* buffer, int length, int& type, int& code) = 0;
/// Returns error description string.
/// If supplied buffer contains an ICMP echo reply packet, an
/// empty string is returned indicating the absence of error.
/// If type and code of the error can be determined, they are
/// assigned to the type and code respectively.
///
/// Supplied buffer includes IP header, ICMP header and data.
/// Must be overriden.
virtual std::string typeDescription(int typeId) = 0;
/// Returns the description of the packet type.
/// Must be overriden.
static const Poco::UInt16 MAX_PACKET_SIZE;
static const Poco::UInt16 MAX_PAYLOAD_SIZE;
static const Poco::UInt16 MAX_SEQ_VALUE;
protected:
Poco::UInt16 nextSequence();
/// Increments sequence number and returns the new value.
void resetSequence();
/// Resets the sequence to zero.
virtual void initPacket() = 0;
/// (Re)assembles the packet.
/// Must be overriden.
Poco::UInt16 checksum(Poco::UInt16 *addr, Poco::Int32 len);
/// Calculates the checksum for supplied buffer.
private:
Poco::UInt16 _seq;
Poco::UInt8* _pPacket;
int _dataSize;
};
//
// inlines
//
inline Poco::UInt16 ICMPPacketImpl::sequence() const
{
return _seq;
}
inline Poco::UInt16 ICMPPacketImpl::nextSequence()
{
return ++_seq;
}
inline void ICMPPacketImpl::resetSequence()
{
_seq = 0;
}
inline int ICMPPacketImpl::maxPacketSize() const
{
return MAX_PACKET_SIZE;
}
} } // namespace Poco::Net
#endif // Net_ICMPPacketImpl_INCLUDED

98
vendor/POCO/Net/include/Poco/Net/ICMPSocket.h vendored Normal file
View File

@ -0,0 +1,98 @@
//
// ICMPSocket.h
//
// Library: Net
// Package: ICMP
// Module: ICMPSocket
//
// Definition of the ICMPSocket class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ICMPSocket_INCLUDED
#define Net_ICMPSocket_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/Socket.h"
namespace Poco {
namespace Net {
class Net_API ICMPSocket: public Socket
/// This class provides an interface to an
/// ICMP client socket.
{
public:
ICMPSocket(SocketAddress::Family family, int dataSize = 48, int ttl = 128, int timeout = 5000000);
/// Creates an unconnected ICMP socket.
///
/// The socket will be created for the
/// given address family.
ICMPSocket(const Socket& socket);
/// Creates the ICMPSocket with the SocketImpl
/// from another socket. The SocketImpl must be
/// a ICMPSocketImpl, otherwise an InvalidArgumentException
/// will be thrown.
~ICMPSocket();
/// Destroys the ICMPSocket.
ICMPSocket& operator = (const Socket& socket);
/// Assignment operator.
///
/// Releases the socket's SocketImpl and
/// attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
int sendTo(const SocketAddress& address, int flags = 0);
/// Sends an ICMP request through
/// the socket to the given address.
///
/// Returns the number of bytes sent.
int receiveFrom(SocketAddress& address, int flags = 0);
/// Receives data from the socket.
/// Stores the address of the sender in address.
///
/// Returns the time elapsed since the originating
/// request was sent.
int dataSize() const;
/// Returns the data size in bytes.
int packetSize() const;
/// Returns the packet size in bytes.
int ttl() const;
/// Returns the Time-To-Live value.
int timeout() const;
/// Returns the socket timeout value.
static Poco::UInt16 mtu(const SocketAddress& address, Poco::UInt16 sz);
/// Returns minimum payload path MTU size for the destination,
/// or 0 if MTU can not be determined.
protected:
ICMPSocket(SocketImpl* pImpl);
/// Creates the Socket and attaches the given SocketImpl.
/// The socket takes ownership of the SocketImpl.
///
/// The SocketImpl must be a ICMPSocketImpl, otherwise
/// an InvalidArgumentException will be thrown.
};
} } // namespace Poco::Net
#endif // Net_ICMPSocket_INCLUDED

105
vendor/POCO/Net/include/Poco/Net/ICMPSocketImpl.h vendored Normal file
View File

@ -0,0 +1,105 @@
//
// ICMPSocketImpl.h
//
// Library: Net
// Package: ICMP
// Module: ICMPSocketImpl
//
// Definition of the ICMPSocketImpl class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ICMPSocketImpl_INCLUDED
#define Net_ICMPSocketImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/RawSocketImpl.h"
#include "Poco/Net/ICMPPacket.h"
#include "Poco/Timestamp.h"
namespace Poco {
namespace Net {
class Net_API ICMPSocketImpl: public RawSocketImpl
/// This class implements an ICMP socket.
{
public:
ICMPSocketImpl(SocketAddress::Family family, int dataSize, int ttl, int timeout);
/// Creates an unconnected ICMP socket.
///
/// The socket will be created for the given address family.
int sendTo(const void*, int, const SocketAddress& address, int flags = 0);
/// Sends an ICMP request through the socket to the given address.
///
/// Returns the number of bytes sent.
int receiveFrom(void*, int, SocketAddress& address, int flags = 0);
/// Receives data from the socket.
/// Stores the address of the sender in address.
///
/// Returns the time elapsed since the originating request was sent.
int dataSize() const;
/// Returns the data size in bytes.
int packetSize() const;
/// Returns the packet size in bytes.
int ttl() const;
/// Returns the Time-To-Live value.
int timeout() const;
/// Returns the socket timeout value.
protected:
~ICMPSocketImpl();
private:
void checkFragmentation(const std::string& err, int type, int code);
ICMPPacket _icmpPacket;
int _ttl;
int _timeout;
};
//
// inlines
//
inline int ICMPSocketImpl::packetSize() const
{
return _icmpPacket.packetSize();
}
inline int ICMPSocketImpl::dataSize() const
{
return _icmpPacket.getDataSize();
}
inline int ICMPSocketImpl::ttl() const
{
return _ttl;
}
inline int ICMPSocketImpl::timeout() const
{
return _timeout;
}
} } // namespace Poco::Net
#endif // Net_ICMPSocketImpl_INCLUDED

188
vendor/POCO/Net/include/Poco/Net/ICMPv4PacketImpl.h vendored Normal file
View File

@ -0,0 +1,188 @@
//
// ICMPv4PacketImpl.h
//
// Library: Net
// Package: ICMP
// Module: ICMPv4PacketImpl
//
// Definition of the ICMPv4PacketImpl class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ICMPv4PacketImpl_INCLUDED
#define Net_ICMPv4PacketImpl_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Net/Socket.h"
#include "Poco/Net/ICMPPacketImpl.h"
#include <cstddef>
namespace Poco {
namespace Net {
class Net_API ICMPv4PacketImpl : public ICMPPacketImpl
/// This class implements the ICMPv4 packet.
/// Parts are based on the original ICMP code by
/// Mike Muuss
/// U. S. Army Ballistic Research Laboratory
/// December, 1983
{
public:
// ICMPv4 header
struct Header
{
Poco::UInt8 type; // ICMP packet type
Poco::UInt8 code; // Type sub code
Poco::UInt16 checksum;
Poco::UInt16 id;
Poco::UInt16 seq;
};
// compile-time shield against misalignment
#if POCO_OS != POCO_OS_ANDROID
poco_static_assert (offsetof(Header, code) == 0x01);
poco_static_assert (offsetof(Header, checksum) == 0x02);
poco_static_assert (offsetof(Header, id) == 0x04);
poco_static_assert (offsetof(Header, seq) == 0x06);
#endif
// wincrypt.h also contains a macro named TIMESTAMP_REQUEST
// being a MinGW issue we can get rid of it for a moment
#if defined(TIMESTAMP_REQUEST) && defined(POCO_COMPILER_MINGW)
#pragma push_macro("TIMESTAMP_REQUEST")
#define POCO_RESTORE_TIMESTAMP_REQUEST
#undef TIMESTAMP_REQUEST
#endif
enum MessageType
{
ECHO_REPLY,
ICMP_1,
ICMP_2,
DESTINATION_UNREACHABLE,
SOURCE_QUENCH,
REDIRECT,
ICMP_6,
ICMP_7,
ECHO_REQUEST,
ICMP_9,
ICMP_10,
TIME_EXCEEDED,
PARAMETER_PROBLEM,
TIMESTAMP_REQUEST,
TIMESTAMP_REPLY,
INFORMATION_REQUEST,
INFORMATION_REPLY,
MESSAGE_TYPE_UNKNOWN, // non-standard default, must remain last but one
MESSAGE_TYPE_LENGTH // length indicator, must remain last
};
#if defined(POCO_RESTORE_TIMESTAMP_REQUEST)
#pragma pop_macro("TIMESTAMP_REQUEST")
#undef POCO_RESTORE_TIMESTAMP_REQUEST
#endif
enum DestinationUnreachableCode
{
NET_UNREACHABLE,
HOST_UNREACHABLE,
PROTOCOL_UNREACHABLE,
PORT_UNREACHABLE,
FRAGMENTATION_NEEDED_AND_DF_SET,
SOURCE_ROUTE_FAILED,
DESTINATION_UNREACHABLE_UNKNOWN, // non-standard default, must remain last but one
DESTINATION_UNREACHABLE_LENGTH // length indicator, must remain last
};
enum RedirectMessageCode
{
REDIRECT_NETWORK,
REDIRECT_HOST,
REDIRECT_SERVICE_NETWORK,
REDIRECT_SERVICE_HOST,
REDIRECT_MESSAGE_UNKNOWN, // non-standard default, must remain last but one
REDIRECT_MESSAGE_LENGTH // length indicator, must remain last
};
enum TimeExceededCode
{
TIME_TO_LIVE,
FRAGMENT_REASSEMBLY,
TIME_EXCEEDED_UNKNOWN, // non-standard default, must remain last but one
TIME_EXCEEDED_LENGTH // length indicator, must remain last
};
enum ParameterProblemCode
{
POINTER_INDICATES_THE_ERROR,
PARAMETER_PROBLEM_UNKNOWN, // non-standard default, must remain last but one
PARAMETER_PROBLEM_LENGTH // length indicator, must remain last
};
ICMPv4PacketImpl(int dataSize = 48);
/// Constructor. Creates an ICMPv4PacketImpl.
~ICMPv4PacketImpl();
/// Destructor.
int packetSize() const;
/// Returns the total length of packet (header + data);
struct timeval time(Poco::UInt8* buffer = 0, int length = 0) const;
/// Returns current epoch time if either buffer or length are equal to zero.
/// Otherwise, it extracts the time value from the supplied buffer.
///
/// Buffer includes IP header, ICMP header and data.
bool validReplyID(Poco::UInt8* buffer, int length) const;
/// Returns true if the extracted id is recognized
/// (i.e. equals the process id).
///
/// Buffer includes IP header, ICMP header and data.
virtual std::string errorDescription(Poco::UInt8* buffer, int length, int& type, int& code);
/// Returns error description string.
/// If supplied buffer contains ICMPv4 echo reply packet, an
/// empty string is returned indicating the absence of error.
/// If type and code of the error can be determined, they are
/// assigned to the type and code respectively.
///
/// Buffer includes IP header, ICMP header and data.
virtual std::string typeDescription(int typeId);
/// Returns the description of the packet type.
static const Poco::UInt16 MAX_PACKET_SIZE;
static const std::string MESSAGE_TYPE[MESSAGE_TYPE_LENGTH];
static const Poco::UInt8 DESTINATION_UNREACHABLE_TYPE; // 3
static const Poco::UInt8 SOURCE_QUENCH_TYPE; // 4
static const Poco::UInt8 REDIRECT_MESSAGE_TYPE; // 5
static const Poco::UInt8 TIME_EXCEEDED_TYPE; // 11
static const Poco::UInt8 PARAMETER_PROBLEM_TYPE; // 12
private:
void initPacket();
Header* header(Poco::UInt8* buffer, int length) const;
Poco::UInt8* data(Poco::UInt8* buffer, int length) const;
static const std::string DESTINATION_UNREACHABLE_CODE[DESTINATION_UNREACHABLE_LENGTH];
static const std::string REDIRECT_MESSAGE_CODE[REDIRECT_MESSAGE_LENGTH];
static const std::string TIME_EXCEEDED_CODE[TIME_EXCEEDED_LENGTH];
static const std::string PARAMETER_PROBLEM_CODE[PARAMETER_PROBLEM_LENGTH];
Poco::UInt16 _seq;
};
} } // namespace Poco::Net
#endif // Net_ICMPv4PacketImpl_INCLUDED

450
vendor/POCO/Net/include/Poco/Net/IPAddress.h vendored Normal file
View File

@ -0,0 +1,450 @@
//
// IPAddress.h
//
// Library: Net
// Package: NetCore
// Module: IPAddress
//
// Definition of the IPAddress class.
//
// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_IPAddress_INCLUDED
#define Net_IPAddress_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketDefs.h"
#include "Poco/Net/IPAddressImpl.h"
#include "Poco/AutoPtr.h"
#include "Poco/Exception.h"
#include <vector>
#include <ostream>
namespace Poco {
class BinaryReader;
class BinaryWriter;
namespace Net {
class Net_API IPAddress
/// This class represents an internet (IP) host
/// address. The address can belong either to the
/// IPv4 or the IPv6 address family.
///
/// Relational operators (==, !=, <, <=, >, >=) are
/// supported. However, you must not interpret any
/// special meaning into the result of these
/// operations, other than that the results are
/// consistent.
///
/// Especially, an IPv4 address is never equal to
/// an IPv6 address, even if the IPv6 address is
/// IPv4 compatible and the addresses are the same.
///
/// IPv6 addresses are supported only if the target platform
/// supports IPv6.
{
public:
using List = std::vector<IPAddress>;
// The following declarations keep the Family type
// backwards compatible with the previously used
// enum declaration.
using Family = AddressFamily::Family;
static const Family IPv4 = AddressFamily::IPv4;
#if defined(POCO_HAVE_IPv6)
static const Family IPv6 = AddressFamily::IPv6;
#endif
IPAddress();
/// Creates a wildcard (zero) IPv4 IPAddress.
IPAddress(const IPAddress& addr);
/// Creates an IPAddress by copying another one.
explicit IPAddress(Family family);
/// Creates a wildcard (zero) IPAddress for the
/// given address family.
explicit IPAddress(const std::string& addr);
/// Creates an IPAddress from the string containing
/// an IP address in presentation format (dotted decimal
/// for IPv4, hex string for IPv6).
///
/// Depending on the format of addr, either an IPv4 or
/// an IPv6 address is created.
///
/// See toString() for details on the supported formats.
///
/// Throws an InvalidAddressException if the address cannot be parsed.
IPAddress(const std::string& addr, Family family);
/// Creates an IPAddress from the string containing
/// an IP address in presentation format (dotted decimal
/// for IPv4, hex string for IPv6).
IPAddress(const void* addr, poco_socklen_t length);
/// Creates an IPAddress from a native internet address.
/// A pointer to a in_addr or a in6_addr structure may be
/// passed.
IPAddress(const void* addr, poco_socklen_t length, Poco::UInt32 scope);
/// Creates an IPAddress from a native internet address.
/// A pointer to a in_addr or a in6_addr structure may be
/// passed. Additionally, for an IPv6 address, a scope ID
/// may be specified. The scope ID will be ignored if an IPv4
/// address is specified.
IPAddress(unsigned prefix, Family family);
/// Creates an IPAddress mask with the given length of prefix.
#if defined(_WIN32)
IPAddress(const SOCKET_ADDRESS& socket_address);
/// Creates an IPAddress from Windows SOCKET_ADDRESS structure.
#endif
IPAddress(const struct sockaddr& sockaddr);
/// Same for struct sock_addr on POSIX.
~IPAddress();
/// Destroys the IPAddress.
IPAddress& operator = (const IPAddress& addr);
/// Assigns an IPAddress.
Family family() const;
/// Returns the address family (IPv4 or IPv6) of the address.
Poco::UInt32 scope() const;
/// Returns the IPv6 scope identifier of the address. Returns 0 if
/// the address is an IPv4 address, or the address is an
/// IPv6 address but does not have a scope identifier.
std::string toString() const;
/// Returns a string containing a representation of the address
/// in presentation format.
///
/// For IPv4 addresses the result will be in dotted-decimal
/// (d.d.d.d) notation.
///
/// Textual representation of IPv6 address is one of the following forms:
///
/// The preferred form is x:x:x:x:x:x:x:x, where the 'x's are the hexadecimal
/// values of the eight 16-bit pieces of the address. This is the full form.
/// Example: 1080:0:0:0:8:600:200A:425C
///
/// It is not necessary to write the leading zeros in an individual field.
/// However, there must be at least one numeral in every field, except as described below.
///
/// It is common for IPv6 addresses to contain long strings of zero bits.
/// In order to make writing addresses containing zero bits easier, a special syntax is
/// available to compress the zeros. The use of "::" indicates multiple groups of 16-bits of zeros.
/// The "::" can only appear once in an address. The "::" can also be used to compress the leading
/// and/or trailing zeros in an address. Example: 1080::8:600:200A:425C
///
/// For dealing with IPv4 compatible addresses in a mixed environment,
/// a special syntax is available: x:x:x:x:x:x:d.d.d.d, where the 'x's are the
/// hexadecimal values of the six high-order 16-bit pieces of the address,
/// and the 'd's are the decimal values of the four low-order 8-bit pieces of the
/// standard IPv4 representation address. Example: ::FFFF:192.168.1.120
///
/// If an IPv6 address contains a non-zero scope identifier, it is added
/// to the string, delimited by a percent character. On Windows platforms,
/// the numeric value (which specifies an interface index) is directly
/// appended. On Unix platforms, the name of the interface corresponding
/// to the index (interpretation of the scope identifier) is added.
bool isWildcard() const;
/// Returns true iff the address is a wildcard (all zero)
/// address.
bool isBroadcast() const;
/// Returns true iff the address is a broadcast address.
///
/// Only IPv4 addresses can be broadcast addresses. In a broadcast
/// address, all bits are one.
///
/// For an IPv6 address, returns always false.
bool isLoopback() const;
/// Returns true iff the address is a loopback address.
///
/// For IPv4, the loopback address is 127.0.0.1.
///
/// For IPv6, the loopback address is ::1.
bool isMulticast() const;
/// Returns true iff the address is a multicast address.
///
/// IPv4 multicast addresses are in the
/// 224.0.0.0 to 239.255.255.255 range
/// (the first four bits have the value 1110).
///
/// IPv6 multicast addresses are in the
/// FFxx:x:x:x:x:x:x:x range.
bool isUnicast() const;
/// Returns true iff the address is a unicast address.
///
/// An address is unicast if it is neither a wildcard,
/// broadcast or multicast address.
bool isLinkLocal() const;
/// Returns true iff the address is a link local unicast address.
///
/// IPv4 link local addresses are in the 169.254.0.0/16 range,
/// according to RFC 3927.
///
/// IPv6 link local addresses have 1111 1110 10 as the first
/// 10 bits, followed by 54 zeros.
bool isSiteLocal() const;
/// Returns true iff the address is a site local unicast address.
///
/// IPv4 site local addresses are in on of the 10.0.0.0/24,
/// 192.168.0.0/16 or 172.16.0.0 to 172.31.255.255 ranges.
///
/// Originally, IPv6 site-local addresses had FEC0/10 (1111 1110 11)
/// prefix (RFC 4291), followed by 38 zeros. Interfaces using
/// this mask are supported, but obsolete; RFC 4193 prescribes
/// fc00::/7 (1111 110) as local unicast prefix.
bool isIPv4Compatible() const;
/// Returns true iff the address is IPv4 compatible.
///
/// For IPv4 addresses, this is always true.
///
/// For IPv6, the address must be in the ::x:x range (the
/// first 96 bits are zero).
bool isIPv4Mapped() const;
/// Returns true iff the address is an IPv4 mapped IPv6 address.
///
/// For IPv4 addresses, this is always true.
///
/// For IPv6, the address must be in the ::FFFF:x:x range.
bool isWellKnownMC() const;
/// Returns true iff the address is a well-known multicast address.
///
/// For IPv4, well-known multicast addresses are in the
/// 224.0.0.0/8 range.
///
/// For IPv6, well-known multicast addresses are in the
/// FF0x:x:x:x:x:x:x:x range.
bool isNodeLocalMC() const;
/// Returns true iff the address is a node-local multicast address.
///
/// IPv4 does not support node-local addresses, thus the result is
/// always false for an IPv4 address.
///
/// For IPv6, node-local multicast addresses are in the
/// FFx1:x:x:x:x:x:x:x range.
bool isLinkLocalMC() const;
/// Returns true iff the address is a link-local multicast address.
///
/// For IPv4, link-local multicast addresses are in the
/// 224.0.0.0/24 range. Note that this overlaps with the range for well-known
/// multicast addresses.
///
/// For IPv6, link-local multicast addresses are in the
/// FFx2:x:x:x:x:x:x:x range.
bool isSiteLocalMC() const;
/// Returns true iff the address is a site-local multicast address.
///
/// For IPv4, site local multicast addresses are in the
/// 239.255.0.0/16 range.
///
/// For IPv6, site-local multicast addresses are in the
/// FFx5:x:x:x:x:x:x:x range.
bool isOrgLocalMC() const;
/// Returns true iff the address is a organization-local multicast address.
///
/// For IPv4, organization-local multicast addresses are in the
/// 239.192.0.0/16 range.
///
/// For IPv6, organization-local multicast addresses are in the
/// FFx8:x:x:x:x:x:x:x range.
bool isGlobalMC() const;
/// Returns true iff the address is a global multicast address.
///
/// For IPv4, global multicast addresses are in the
/// 224.0.1.0 to 238.255.255.255 range.
///
/// For IPv6, global multicast addresses are in the
/// FFxF:x:x:x:x:x:x:x range.
bool operator == (const IPAddress& addr) const;
bool operator != (const IPAddress& addr) const;
bool operator < (const IPAddress& addr) const;
bool operator <= (const IPAddress& addr) const;
bool operator > (const IPAddress& addr) const;
bool operator >= (const IPAddress& addr) const;
IPAddress operator & (const IPAddress& addr) const;
IPAddress operator | (const IPAddress& addr) const;
IPAddress operator ^ (const IPAddress& addr) const;
IPAddress operator ~ () const;
poco_socklen_t length() const;
/// Returns the length in bytes of the internal socket address structure.
const void* addr() const;
/// Returns the internal address structure.
int af() const;
/// Returns the address family (AF_INET or AF_INET6) of the address.
unsigned prefixLength() const;
/// Returns the prefix length.
void mask(const IPAddress& mask);
/// Masks the IP address using the given netmask, which is usually
/// a IPv4 subnet mask. Only supported for IPv4 addresses.
///
/// The new address is (address & mask).
void mask(const IPAddress& mask, const IPAddress& set);
/// Masks the IP address using the given netmask, which is usually
/// a IPv4 subnet mask. Only supported for IPv4 addresses.
///
/// The new address is (address & mask) | (set & ~mask).
static IPAddress parse(const std::string& addr);
/// Creates an IPAddress from the string containing
/// an IP address in presentation format (dotted decimal
/// for IPv4, hex string for IPv6).
///
/// Depending on the format of addr, either an IPv4 or
/// an IPv6 address is created.
///
/// See toString() for details on the supported formats.
///
/// Throws an InvalidAddressException if the address cannot be parsed.
static bool tryParse(const std::string& addr, IPAddress& result);
/// Tries to interpret the given address string as an
/// IP address in presentation format (dotted decimal
/// for IPv4, hex string for IPv6).
///
/// Returns true and stores the IPAddress in result if the
/// string contains a valid address.
///
/// Returns false and leaves result unchanged otherwise.
static IPAddress wildcard(Family family = IPv4);
/// Returns a wildcard IPv4 or IPv6 address (0.0.0.0).
static IPAddress broadcast();
/// Returns a broadcast IPv4 address (255.255.255.255).
enum
{
MAX_ADDRESS_LENGTH =
#if defined(POCO_HAVE_IPv6)
sizeof(struct in6_addr)
#else
sizeof(struct in_addr)
#endif
/// Maximum length in bytes of a socket address.
};
private:
typedef Poco::Net::Impl::IPAddressImpl Impl;
typedef Poco::AutoPtr<Impl> Ptr;
Ptr pImpl() const;
void newIPv4();
void newIPv4(const void* hostAddr);
void newIPv4(unsigned prefix);
#if defined(POCO_HAVE_IPv6)
void newIPv6();
void newIPv6(const void* hostAddr);
void newIPv6(const void* hostAddr, Poco::UInt32 scope);
void newIPv6(unsigned prefix);
#endif
Ptr _pImpl;
};
//
// inlines
//
inline IPAddress::Ptr IPAddress::pImpl() const
{
if (_pImpl) return _pImpl;
throw NullPointerException("IPaddress implementation pointer is NULL.");
}
inline void IPAddress::newIPv4()
{
_pImpl = new Poco::Net::Impl::IPv4AddressImpl;
}
inline void IPAddress::newIPv4(const void* hostAddr)
{
_pImpl = new Poco::Net::Impl::IPv4AddressImpl(hostAddr);
}
inline void IPAddress::newIPv4(unsigned prefix)
{
_pImpl = new Poco::Net::Impl::IPv4AddressImpl(prefix);
}
#if defined(POCO_HAVE_IPv6)
inline void IPAddress::newIPv6()
{
_pImpl = new Poco::Net::Impl::IPv6AddressImpl;
}
inline void IPAddress::newIPv6(const void* hostAddr)
{
_pImpl = new Poco::Net::Impl::IPv6AddressImpl(hostAddr);
}
inline void IPAddress::newIPv6(const void* hostAddr, Poco::UInt32 scope)
{
_pImpl = new Poco::Net::Impl::IPv6AddressImpl(hostAddr, scope);
}
inline void IPAddress::newIPv6(unsigned prefix)
{
_pImpl = new Poco::Net::Impl::IPv6AddressImpl(prefix);
}
#endif // POCO_HAVE_IPv6
} } // namespace Poco::Net
Net_API Poco::BinaryWriter& operator << (Poco::BinaryWriter& writer, const Poco::Net::IPAddress& value);
Net_API Poco::BinaryReader& operator >> (Poco::BinaryReader& reader, Poco::Net::IPAddress& value);
Net_API std::ostream& operator << (std::ostream& ostr, const Poco::Net::IPAddress& addr);
#endif // Net_IPAddress_INCLUDED

179
vendor/POCO/Net/include/Poco/Net/IPAddressImpl.h vendored Normal file
View File

@ -0,0 +1,179 @@
//
// IPAddressImpl.h
//
// Library: Net
// Package: NetCore
// Module: IPAddressImpl
//
// Definition of the IPAddressImpl class.
//
// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_IPAddressImpl_INCLUDED
#define Net_IPAddressImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketDefs.h"
#include "Poco/RefCountedObject.h"
#include <vector>
namespace Poco {
namespace Net {
namespace Impl {
class IPAddressImpl : public Poco::RefCountedObject
{
public:
using Family = AddressFamily::Family;
virtual ~IPAddressImpl();
virtual IPAddressImpl* clone() const = 0;
virtual std::string toString() const = 0;
virtual poco_socklen_t length() const = 0;
virtual const void* addr() const = 0;
virtual Family family() const = 0;
virtual int af() const = 0;
virtual Poco::UInt32 scope() const = 0;
virtual bool isWildcard() const = 0;
virtual bool isBroadcast() const = 0;
virtual bool isLoopback() const = 0;
virtual bool isMulticast() const = 0;
virtual bool isLinkLocal() const = 0;
virtual bool isSiteLocal() const = 0;
virtual bool isIPv4Mapped() const = 0;
virtual bool isIPv4Compatible() const = 0;
virtual bool isWellKnownMC() const = 0;
virtual bool isNodeLocalMC() const = 0;
virtual bool isLinkLocalMC() const = 0;
virtual bool isSiteLocalMC() const = 0;
virtual bool isOrgLocalMC() const = 0;
virtual bool isGlobalMC() const = 0;
virtual void mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet) = 0;
virtual unsigned prefixLength() const = 0;
protected:
IPAddressImpl();
private:
IPAddressImpl(const IPAddressImpl&);
IPAddressImpl& operator = (const IPAddressImpl&);
};
//
// IPv4AddressImpl
//
class IPv4AddressImpl: public IPAddressImpl
{
public:
IPv4AddressImpl();
IPv4AddressImpl(const void* addr);
IPv4AddressImpl(unsigned prefix);
IPv4AddressImpl(const IPv4AddressImpl& addr);
IPv4AddressImpl& operator = (const IPv4AddressImpl&);
std::string toString() const;
poco_socklen_t length() const;
const void* addr() const;
Family family() const;
int af() const;
unsigned prefixLength() const;
Poco::UInt32 scope() const;
bool isWildcard() const;
bool isBroadcast() const;
bool isLoopback() const;
bool isMulticast() const;
bool isLinkLocal() const;
bool isSiteLocal() const;
bool isIPv4Compatible() const;
bool isIPv4Mapped() const;
bool isWellKnownMC() const;
bool isNodeLocalMC() const;
bool isLinkLocalMC() const;
bool isSiteLocalMC() const;
bool isOrgLocalMC() const;
bool isGlobalMC() const;
static IPv4AddressImpl parse(const std::string& addr);
void mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet);
IPAddressImpl* clone() const;
IPv4AddressImpl operator & (const IPv4AddressImpl& addr) const;
IPv4AddressImpl operator | (const IPv4AddressImpl& addr) const;
IPv4AddressImpl operator ^ (const IPv4AddressImpl& addr) const;
IPv4AddressImpl operator ~ () const;
bool operator == (const IPv4AddressImpl& addr) const;
bool operator != (const IPv4AddressImpl& addr) const;
private:
struct in_addr _addr;
};
#if defined(POCO_HAVE_IPv6)
//
// IPv6AddressImpl
//
class IPv6AddressImpl: public IPAddressImpl
{
public:
IPv6AddressImpl();
IPv6AddressImpl(const void* addr);
IPv6AddressImpl(const void* addr, Poco::UInt32 scope);
IPv6AddressImpl(unsigned prefix);
std::string toString() const;
poco_socklen_t length() const;
const void* addr() const;
Family family() const;
int af() const;
unsigned prefixLength() const;
Poco::UInt32 scope() const;
bool isWildcard() const;
bool isBroadcast() const;
bool isLoopback() const;
bool isMulticast() const;
bool isLinkLocal() const;
bool isSiteLocal() const;
bool isIPv4Compatible() const;
bool isIPv4Mapped() const;
bool isWellKnownMC() const;
bool isNodeLocalMC() const;
bool isLinkLocalMC() const;
bool isSiteLocalMC() const;
bool isOrgLocalMC() const;
bool isGlobalMC() const;
static IPv6AddressImpl parse(const std::string& addr);
void mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet);
IPAddressImpl* clone() const;
IPv6AddressImpl operator & (const IPv6AddressImpl& addr) const;
IPv6AddressImpl operator | (const IPv6AddressImpl& addr) const;
IPv6AddressImpl operator ^ (const IPv6AddressImpl& addr) const;
IPv6AddressImpl operator ~ () const;
bool operator == (const IPv6AddressImpl& addr) const;
bool operator != (const IPv6AddressImpl& addr) const;
IPv6AddressImpl(const IPv6AddressImpl& addr);
IPv6AddressImpl& operator = (const IPv6AddressImpl&);
private:
struct in6_addr _addr;
unsigned int _scope;
};
#endif // POCO_HAVE_IPv6
} } } // namespace Poco::Net::Impl
#endif // Net_IPAddressImpl_INCLUDED

358
vendor/POCO/Net/include/Poco/Net/MailMessage.h vendored Normal file
View File

@ -0,0 +1,358 @@
//
// MailMessage.h
//
// Library: Net
// Package: Mail
// Module: MailMessage
//
// Definition of the MailMessage class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MailMessage_INCLUDED
#define Net_MailMessage_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/MessageHeader.h"
#include "Poco/Net/MailRecipient.h"
#include "Poco/Net/PartStore.h"
#include "Poco/SharedPtr.h"
#include "Poco/Timestamp.h"
#include <sstream>
#include <vector>
namespace Poco {
namespace Net {
class MediaType;
class PartSource;
class PartHandler;
class MultipartWriter;
class MultipartSource;
class Net_API MailMessage: public MessageHeader
/// This class represents an e-mail message for
/// use with the SMTPClientSession and POPClientSession
/// classes.
///
/// MailMessage supports both old-style plain text messages,
/// as well as MIME multipart mail messages with attachments.
///
/// For multi-part messages, the following content transfer
/// encodings are supported: 7bit, 8bit, quoted-printable
/// and base64.
{
public:
using Recipients = std::vector<MailRecipient>;
enum ContentDisposition
{
CONTENT_INLINE,
CONTENT_ATTACHMENT
};
enum ContentTransferEncoding
{
ENCODING_7BIT,
ENCODING_8BIT,
ENCODING_QUOTED_PRINTABLE,
ENCODING_BASE64
};
struct Part
{
std::string name;
PartSource* pSource;
ContentDisposition disposition;
ContentTransferEncoding encoding;
};
using PartVec = std::vector<Part>;
MailMessage(PartStoreFactory* pStoreFactory = 0);
/// Creates an empty MailMessage.
///
/// If pStoreFactory is not null, message attachments will be
/// handled by the object created by the factory. Most
/// common reason is to temporarily save attachments to
/// the file system in order to avoid potential memory
/// exhaustion when attachment files are very large.
virtual ~MailMessage();
/// Destroys the MailMessage.
void addRecipient(const MailRecipient& recipient);
/// Adds a recipient for the message.
void setRecipients(const Recipients& recipient);
/// Clears existing and sets new recipient list for the message.
const Recipients& recipients() const;
/// Returns the recipients of the message.
void setSubject(const std::string& subject);
/// Sets the subject of the message.
///
/// The subject must not contain any non-ASCII
/// characters. To include non-ASCII characters
/// in the subject, use RFC 2047 word encoding
/// (see encodeWord()).
const std::string& getSubject() const;
/// Returns the subject of the message.
void setSender(const std::string& sender);
/// Sets the sender of the message (which
/// ends up in the From header field).
///
/// The sender must either be a valid email
/// address, or a real name followed by
/// an email address enclosed in < and >.
///
/// The sender must not contain any non-ASCII
/// characters. To include non-ASCII characters
/// in the sender, use RFC 2047 word encoding
/// (see encodeWord()).
const std::string& getSender() const;
/// Returns the sender of the message (taken
/// from the From header field).
void setContent(const std::string& content, ContentTransferEncoding encoding = ENCODING_QUOTED_PRINTABLE);
/// Sets the content of the mail message.
///
/// If the content transfer encoding is ENCODING_7BIT or
/// ENCODING_8BIT, the content string must be formatted
/// according to the rules of an internet email message.
///
/// The message will be sent as a single-part
/// message.
///
/// Note that single CR or LF characters as line delimiters must
/// not be used. Content lines always should be terminated with a
/// proper CRLF sequence.
const std::string& getContent() const;
/// Returns the content of the mail message.
///
/// A content will only be returned for single-part
/// messages. The content of multi-part mail messages
/// will be reported through the registered PartHandler.
void setContentType(const std::string& mediaType);
/// Sets the content type for the message.
void setContentType(const MediaType& mediaType);
/// Sets the content type for the message.
const std::string& getContentType() const;
/// Returns the content type for the message.
void setDate(const Poco::Timestamp& dateTime);
/// Sets the Date header to the given date/time value.
Poco::Timestamp getDate() const;
/// Returns the value of the Date header.
bool isMultipart() const;
/// Returns true iff the message is a multipart message.
void addPart(const std::string& name,
PartSource* pSource,
ContentDisposition disposition,
ContentTransferEncoding encoding);
/// Adds a part/attachment to the mail message.
///
/// The MailMessage takes ownership of the PartSource and deletes it
/// when it is no longer needed.
///
/// The MailMessage will be converted to a multipart message
/// if it is not already one.
///
/// The part name, and the filename specified in the part source
/// must not contain any non-ASCII characters.
/// To include non-ASCII characters in the part name or filename,
/// use RFC 2047 word encoding (see encodeWord()).
void addContent(PartSource* pSource,
ContentTransferEncoding encoding = ENCODING_QUOTED_PRINTABLE);
/// Adds a part to the mail message by calling
/// addPart("", pSource, CONTENT_INLINE, encoding);
///
/// The part name, and the filename specified in the part source
/// must not contain any non-ASCII characters.
/// To include non-ASCII characters in the part name or filename,
/// use RFC 2047 word encoding (see encodeWord()).
void addAttachment(const std::string& name,
PartSource* pSource,
ContentTransferEncoding encoding = ENCODING_BASE64);
/// Adds an attachment to the mail message by calling
/// addPart(name, pSource, CONTENT_ATTACHMENT, encoding);
///
/// The part name, and the filename specified in the part source
/// must not contain any non-ASCII characters.
/// To include non-ASCII characters in the part name or filename,
/// use RFC 2047 word encoding (see encodeWord()).
PartSource* createPartStore(const std::string& content,
const std::string& mediaType,
const std::string& filename = "");
/// Returns either default StringPartSource part store or,
/// if the part store factory was provided during construction,
/// the one created by PartStoreFactory.
/// Returned part store is allocated on the heap; it is caller's
/// responsibility to delete it after use. Typical use is handler
/// passing it back to MailMessage, which takes care of the cleanup.
const PartVec& parts() const;
/// Returns const reference to the vector containing part stores.
void read(std::istream& istr, PartHandler& handler);
/// Reads the MailMessage from the given input stream.
///
/// If the message has multiple parts, the parts
/// are reported to the PartHandler. If the message
/// is not a multi-part message, the content is stored
/// in a string available by calling getContent().
void read(std::istream& istr);
/// Reads the MailMessage from the given input stream.
///
/// The raw message (including all MIME parts) is stored
/// in a string and available by calling getContent().
void write(std::ostream& ostr) const;
/// Writes the mail message to the given output stream.
static std::string encodeWord(const std::string& text, const std::string& charset = "UTF-8");
/// If the given string contains non-ASCII characters,
/// encodes the given string using RFC 2047 "Q" word encoding.
///
/// The given text must already be encoded in the character set
/// given in charset (default is UTF-8).
///
/// Returns the encoded string, or the original string if it
/// consists only of ASCII characters.
static const std::string HEADER_SUBJECT;
static const std::string HEADER_FROM;
static const std::string HEADER_TO;
static const std::string HEADER_CC;
static const std::string HEADER_BCC;
static const std::string HEADER_DATE;
static const std::string HEADER_CONTENT_TYPE;
static const std::string HEADER_CONTENT_TRANSFER_ENCODING;
static const std::string HEADER_CONTENT_DISPOSITION;
static const std::string HEADER_CONTENT_ID;
static const std::string HEADER_MIME_VERSION;
static const std::string EMPTY_HEADER;
static const std::string TEXT_PLAIN;
static const std::string CTE_7BIT;
static const std::string CTE_8BIT;
static const std::string CTE_QUOTED_PRINTABLE;
static const std::string CTE_BASE64;
protected:
void makeMultipart();
void writeHeader(const MessageHeader& header, std::ostream& ostr) const;
void writeMultipart(MessageHeader& header, std::ostream& ostr) const;
static void writePart(MultipartWriter& writer, const Part& part);
static void writeEncoded(std::istream& istr, std::ostream& ostr, ContentTransferEncoding encoding);
void setRecipientHeaders(MessageHeader& headers) const;
void readHeader(std::istream& istr);
void readMultipart(std::istream& istr, PartHandler& handler);
void readPart(std::istream& istr, const MessageHeader& header, PartHandler& handler);
void handlePart(std::istream& istr, const MessageHeader& header, PartHandler& handler);
static const std::string& contentTransferEncodingToString(ContentTransferEncoding encoding);
static int lineLength(const std::string& str);
static void appendRecipient(const MailRecipient& recipient, std::string& str);
private:
MailMessage(const MailMessage&);
MailMessage& operator = (const MailMessage&);
Recipients _recipients;
PartVec _parts;
std::string _content;
ContentTransferEncoding _encoding;
mutable std::string _boundary;
PartStoreFactory* _pStoreFactory;
friend class MultipartSource;
};
class Net_API MultipartSource: public PartSource
/// This is a PartSource for constructing complex
/// mail messages consisting of multiple nested parts.
{
public:
explicit MultipartSource(const std::string contentType = "multipart/alternative");
/// Creates an empty MultipartSource.
///
/// At least one part must be added with addPart().
~MultipartSource();
/// Destroys the MultipartSource.
void addPart(const std::string& name,
PartSource* pSource,
MailMessage::ContentDisposition disposition,
MailMessage::ContentTransferEncoding encoding);
/// Adds a part/attachment to the MultipartSource.
///
/// The MultipartSource takes ownership of the PartSource and deletes it
/// when it is no longer needed.
///
/// The part name, and the filename specified in the part source
/// must not contain any non-ASCII characters.
/// To include non-ASCII characters in the part name or filename,
/// use RFC 2047 word encoding (see encodeWord()).
// PartSource
std::istream& stream();
protected:
static std::string contentTypeWithBoundary(const std::string& contentType);
private:
std::vector<MailMessage::Part> _parts;
std::stringstream _content;
};
//
// inlines
//
inline const MailMessage::Recipients& MailMessage::recipients() const
{
return _recipients;
}
inline const std::string& MailMessage::getContent() const
{
return _content;
}
inline const MailMessage::PartVec& MailMessage::parts() const
{
return _parts;
}
} } // namespace Poco::Net
#endif // Net_MailMessage_INCLUDED

120
vendor/POCO/Net/include/Poco/Net/MailRecipient.h vendored Normal file
View File

@ -0,0 +1,120 @@
//
// MailRecipient.h
//
// Library: Net
// Package: Mail
// Module: MailRecipient
//
// Definition of the MailRecipient class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MailRecipient_INCLUDED
#define Net_MailRecipient_INCLUDED
#include "Poco/Net/Net.h"
namespace Poco {
namespace Net {
class Net_API MailRecipient
/// The recipient of an e-mail message.
///
/// A recipient has a type (primary recipient,
/// carbon-copy recipient, blind-carbon-copy
/// recipient), an e-mail address and an optional
/// real name.
{
public:
enum RecipientType
{
PRIMARY_RECIPIENT,
CC_RECIPIENT,
BCC_RECIPIENT
};
MailRecipient();
/// Creates an empty MailRecipient.
MailRecipient(const MailRecipient& recipient);
/// Creates a MailRecipient by copying another one.
MailRecipient(RecipientType type, const std::string& address);
/// Creates a MailRecipient of the given type.
MailRecipient(RecipientType type, const std::string& address, const std::string& realName);
/// Creates a MailRecipient of the given type.
~MailRecipient();
/// Destroys the MailRecipient.
MailRecipient& operator = (const MailRecipient& recipient);
/// Assigns another recipient.
void swap(MailRecipient& recipient);
/// Exchanges the content of two recipients.
RecipientType getType() const;
/// Returns the type of the recipient.
void setType(RecipientType type);
/// Sets the type of the recipient.
const std::string& getAddress() const;
/// Returns the address of the recipient.
void setAddress(const std::string& address);
/// Sets the address of the recipient.
const std::string& getRealName() const;
/// Returns the real name of the recipient.
void setRealName(const std::string& realName);
/// Sets the real name of the recipient.
private:
std::string _address;
std::string _realName;
RecipientType _type;
};
//
// inlines
//
inline MailRecipient::RecipientType MailRecipient::getType() const
{
return _type;
}
inline const std::string& MailRecipient::getAddress() const
{
return _address;
}
inline const std::string& MailRecipient::getRealName() const
{
return _realName;
}
inline void swap(MailRecipient& r1, MailRecipient& r2)
{
r1.swap(r2);
}
} } // namespace Poco::Net
#endif // Net_MailRecipient_INCLUDED

146
vendor/POCO/Net/include/Poco/Net/MailStream.h vendored Normal file
View File

@ -0,0 +1,146 @@
//
// MailStream.h
//
// Library: Net
// Package: Mail
// Module: MailStream
//
// Definition of the MailStream class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MailStream_INCLUDED
#define Net_MailStream_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/UnbufferedStreamBuf.h"
#include <istream>
#include <ostream>
namespace Poco {
namespace Net {
class Net_API MailStreamBuf: public Poco::UnbufferedStreamBuf
/// The sole purpose of this stream buffer is to replace
/// a "\r\n.\r\n" character sequence with a "\r\n..\r\n" sequence for
/// output streams and vice-versa for input streams.
///
/// This is used when sending mail messages to SMTP servers, or
/// receiving mail messages from POP servers.
///
/// See RFC 2181 (Simple Mail Transfer Protocol) and RFC 1939
/// (Post Office Protocol - Version 3) for more information.
{
public:
MailStreamBuf(std::istream& istr);
/// Creates the MailStreamBuf and connects it
/// to the given input stream.
MailStreamBuf(std::ostream& ostr);
/// Creates the MailStreamBuf and connects it
/// to the given output stream.
~MailStreamBuf();
/// Destroys the MailStreamBuf.
void close();
/// Writes the terminating period, followed by
/// CR-LF.
protected:
int readFromDevice();
int writeToDevice(char c);
int readOne();
private:
enum State
{
ST_DATA,
ST_CR,
ST_CR_LF,
ST_CR_LF_DOT,
ST_CR_LF_DOT_DOT,
ST_CR_LF_DOT_CR,
ST_CR_LF_DOT_CR_LF
};
std::istream* _pIstr;
std::ostream* _pOstr;
std::string _buffer;
State _state;
};
class Net_API MailIOS: public virtual std::ios
/// The base class for MailInputStream and MailOutputStream.
///
/// This class provides common methods and is also needed to ensure
/// the correct initialization order of the stream buffer and base classes.
{
public:
MailIOS(std::istream& istr);
/// Creates the MailIOS and connects it
/// to the given input stream.
MailIOS(std::ostream& ostr);
/// Creates the MailIOS and connects it
/// to the given output stream.
~MailIOS();
/// Destroys the stream.
void close();
/// Writes the terminating period, followed by
/// CR-LF.
MailStreamBuf* rdbuf();
/// Returns a pointer to the underlying streambuf.
protected:
MailStreamBuf _buf;
};
class Net_API MailInputStream: public MailIOS, public std::istream
/// This class is used for reading E-Mail messages from a
/// POP3 server. All occurrences of "\r\n..\r\n" are replaced with
/// "\r\n.\r\n". The first occurrence of "\r\n.\r\n" denotes the end
/// of the stream.
{
public:
MailInputStream(std::istream& istr);
/// Creates the MailInputStream and connects it
/// to the given input stream.
~MailInputStream();
/// Destroys the MailInputStream.
};
class Net_API MailOutputStream: public MailIOS, public std::ostream
/// This class is used for writing E-Mail messages to a
/// SMTP server. All occurrences of "\r\n.\r\n" are replaced with
/// "\r\n..\r\n".
{
public:
MailOutputStream(std::ostream& ostr);
/// Creates the MailOutputStream and connects it
/// to the given input stream.
~MailOutputStream();
/// Destroys the MailOutputStream.
};
} } // namespace Poco::Net
#endif // Net_MailStream_INCLUDED

175
vendor/POCO/Net/include/Poco/Net/MediaType.h vendored Normal file
View File

@ -0,0 +1,175 @@
//
// MediaType.h
//
// Library: Net
// Package: Messages
// Module: MediaType
//
// Definition of the MediaType class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MediaType_INCLUDED
#define Net_MediaType_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/NameValueCollection.h"
namespace Poco {
namespace Net {
class Net_API MediaType
/// This class represents a MIME media type, consisting of
/// a top-level type, a subtype and an optional set of
/// parameters.
///
/// The implementation conforms with RFC 2045 and RFC 2046.
{
public:
MediaType(const std::string& mediaType);
/// Creates the MediaType from the given string, which
/// must have the format <type>/<subtype>{;<parameter>=<value>}.
MediaType(const std::string& type, const std::string& subType);
/// Creates the MediaType, using the given type and subtype.
MediaType(const MediaType& mediaType);
/// Creates a MediaType from another one.
MediaType(MediaType&& mediaType) noexcept;
/// Creates a MediaType by moving another one.
~MediaType();
/// Destroys the MediaType.
MediaType& operator = (const MediaType& mediaType);
/// Assigns another media type.
MediaType& operator = (MediaType&& mediaType) noexcept;
/// Assigns another media type.
MediaType& operator = (const std::string& mediaType);
/// Assigns another media type.
void swap(MediaType& mediaType);
/// Swaps the MediaType with another one.
void setType(const std::string& type);
/// Sets the top-level type.
const std::string& getType() const;
/// Returns the top-level type.
void setSubType(const std::string& subType);
/// Sets the sub type.
const std::string& getSubType() const;
/// Returns the sub type.
void setParameter(const std::string& name, const std::string& value);
/// Sets the parameter with the given name.
const std::string& getParameter(const std::string& name) const;
/// Returns the parameter with the given name.
///
/// Throws a NotFoundException if the parameter does not exist.
bool hasParameter(const std::string& name) const;
/// Returns true iff a parameter with the given name exists.
void removeParameter(const std::string& name);
/// Removes the parameter with the given name.
const NameValueCollection& parameters() const;
/// Returns the parameters.
std::string toString() const;
/// Returns the string representation of the media type
/// which is <type>/<subtype>{;<parameter>=<value>}
bool matches(const MediaType& mediaType) const;
/// Returns true iff the type and subtype match
/// the type and subtype of the given media type.
/// Matching is case insensitive.
bool matches(const std::string& type, const std::string& subType) const;
/// Returns true iff the type and subtype match
/// the given type and subtype.
/// Matching is case insensitive.
bool matches(const std::string& type) const;
/// Returns true iff the type matches the given type.
/// Matching is case insensitive.
bool matchesRange(const MediaType& mediaType) const;
/// Returns true if the type and subtype match
/// the type and subtype of the given media type.
/// If the MIME type is a range of types it matches
/// any media type within the range (e.g. "image/*" matches
/// any image media type, "*/*" matches anything).
/// Matching is case insensitive.
bool matchesRange(const std::string& type, const std::string& subType) const;
/// Returns true if the type and subtype match
/// the given type and subtype.
/// If the MIME type is a range of types it matches
/// any media type within the range (e.g. "image/*" matches
/// any image media type, "*/*" matches anything).
/// Matching is case insensitive.
bool matchesRange(const std::string& type) const;
/// Returns true if the type matches the given type or
/// the type is a range of types denoted by "*".
/// Matching is case insensitive.
protected:
void parse(const std::string& mediaType);
private:
MediaType();
std::string _type;
std::string _subType;
NameValueCollection _parameters;
};
//
// inlines
//
inline const std::string& MediaType::getType() const
{
return _type;
}
inline const std::string& MediaType::getSubType() const
{
return _subType;
}
inline const NameValueCollection& MediaType::parameters() const
{
return _parameters;
}
inline void swap(MediaType& m1, MediaType& m2)
{
m1.swap(m2);
}
} } // namespace Poco::Net
#endif // Net_MediaType_INCLUDED

169
vendor/POCO/Net/include/Poco/Net/MessageHeader.h vendored Normal file
View File

@ -0,0 +1,169 @@
//
// MessageHeader.h
//
// Library: Net
// Package: Messages
// Module: MessageHeader
//
// Definition of the MessageHeader class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MessageHeader_INCLUDED
#define Net_MessageHeader_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/NameValueCollection.h"
#include <ostream>
#include <istream>
#include <vector>
namespace Poco {
namespace Net {
class Net_API MessageHeader: public NameValueCollection
/// A collection of name-value pairs that are used in
/// various internet protocols like HTTP and SMTP.
///
/// The name is case-insensitive.
///
/// There can be more than one name-value pair with the
/// same name.
///
/// MessageHeader supports writing and reading the
/// header data in RFC 2822 format.
///
/// The maximum number of fields can be restricted
/// by calling setFieldLimit(). This is useful to
/// defend against certain kinds of denial-of-service
/// attacks. The limit is only enforced when parsing
/// header fields from a stream, not when programmatically
/// adding them. The default limit is 100.
{
public:
MessageHeader();
/// Creates the MessageHeader.
MessageHeader(const MessageHeader& messageHeader);
/// Creates the MessageHeader by copying
/// another one.
virtual ~MessageHeader();
/// Destroys the MessageHeader.
MessageHeader& operator = (const MessageHeader& messageHeader);
/// Assigns the content of another MessageHeader.
virtual void write(std::ostream& ostr) const;
/// Writes the message header to the given output stream.
///
/// The format is one name-value pair per line, with
/// name and value separated by a colon and lines
/// delimited by a carriage return and a linefeed
/// character. See RFC 2822 for details.
virtual void read(std::istream& istr);
/// Reads the message header from the given input stream.
///
/// See write() for the expected format.
/// Also supported is folding of field content, according
/// to section 2.2.3 of RFC 2822.
///
/// Reading stops at the first empty line (a line only
/// containing \r\n or \n), as well as at the end of
/// the stream.
///
/// Some basic sanity checking of the input stream is
/// performed.
///
/// Throws a MessageException if the input stream is
/// malformed.
int getFieldLimit() const;
/// Returns the maximum number of header fields
/// allowed.
///
/// See setFieldLimit() for more information.
void setFieldLimit(int limit);
/// Sets the maximum number of header fields
/// allowed. This limit is used to defend certain
/// kinds of denial-of-service attacks.
/// Specify 0 for unlimited (not recommended).
///
/// The default limit is 100.
bool hasToken(const std::string& fieldName, const std::string& token) const;
/// Returns true iff the field with the given fieldName contains
/// the given token. Tokens in a header field are expected to be
/// comma-separated and are case insensitive.
static void splitElements(const std::string& s, std::vector<std::string>& elements, bool ignoreEmpty = true);
/// Splits the given string into separate elements. Elements are expected
/// to be separated by commas.
///
/// For example, the string
/// text/plain; q=0.5, text/html, text/x-dvi; q=0.8
/// is split into the elements
/// text/plain; q=0.5
/// text/html
/// text/x-dvi; q=0.8
///
/// Commas enclosed in double quotes do not split elements.
///
/// If ignoreEmpty is true, empty elements are not returned.
static void splitParameters(const std::string& s, std::string& value, NameValueCollection& parameters);
/// Splits the given string into a value and a collection of parameters.
/// Parameters are expected to be separated by semicolons.
///
/// Enclosing quotes of parameter values are removed.
///
/// For example, the string
/// multipart/mixed; boundary="MIME_boundary_01234567"
/// is split into the value
/// multipart/mixed
/// and the parameter
/// boundary -> MIME_boundary_01234567
static void splitParameters(const std::string::const_iterator& begin, const std::string::const_iterator& end, NameValueCollection& parameters);
/// Splits the given string into a collection of parameters.
/// Parameters are expected to be separated by semicolons.
///
/// Enclosing quotes of parameter values are removed.
static void quote(const std::string& value, std::string& result, bool allowSpace = false);
/// Checks if the value must be quoted. If so, the value is
/// appended to result, enclosed in double-quotes.
/// Otherwise, the value is appended to result as-is.
static void decodeRFC2047(const std::string& ins, std::string& outs, const std::string& charset = "UTF-8");
static std::string decodeWord(const std::string& text, const std::string& charset = "UTF-8");
/// Decode RFC2047 string.
private:
enum Limits
/// Limits for basic sanity checks when reading a header
{
MAX_NAME_LENGTH = 256,
MAX_VALUE_LENGTH = 8192,
DFL_FIELD_LIMIT = 100
};
int _fieldLimit;
};
} } // namespace Poco::Net
#endif // Net_MessageHeader_INCLUDED

128
vendor/POCO/Net/include/Poco/Net/MultiSocketPoller.h vendored Normal file
View File

@ -0,0 +1,128 @@
//
// MultiSocketPoller.h
//
// Library: Net
// Package: UDP
// Module: MultiSocketPoller
//
// Definition of the MultiSocketPoller class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MultiSocketPoller_INCLUDED
#define Net_MultiSocketPoller_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/Socket.h"
#include "Poco/Net/UDPHandler.h"
namespace Poco {
namespace Net {
template <std::size_t S = POCO_UDP_BUF_SIZE>
class MultiSocketPoller
/// MultiSocketPoller, as its name indicates, repeatedly polls a set of
/// sockets for readability and/or eror. If socket is readable or in error
/// state, the reading/error handling actions are delegated to the reader.
{
public:
MultiSocketPoller(typename UDPHandlerImpl<S>::List& handlers, const Poco::Net::SocketAddress& sa, int nSockets = 10, Poco::Timespan timeout = 250000):
_address(sa),
_timeout(timeout),
_reader(handlers)
/// Creates the MutiSocketPoller.
{
poco_assert (_address.port() > 0 && _address.host().toString() != "0.0.0.0");
addSockets(nSockets);
}
MultiSocketPoller(typename UDPHandlerImpl<S>::List& handlers, const UDPServerParams& serverParams):
_address(serverParams.address()),
_timeout(serverParams.timeout()),
_reader(handlers)
/// Creates the MutiSocketPoller.
{
poco_assert (_address.port() > 0 && _address.host().toString() != "0.0.0.0");
addSockets(serverParams.numberOfSockets());
}
~MultiSocketPoller()
/// Destroys MutiSocketPoller
{
}
Poco::UInt16 port() const
/// Returns the port the socket is
/// listening on.
{
return _address.port();
}
Poco::Net::SocketAddress address() const
/// Returns the address of the server.
{
return _address;
}
void poll()
{
if (_reader.handlerStopped()) return;
PollSet::SocketModeMap sm;
PollSet::SocketModeMap::iterator it;
PollSet::SocketModeMap::iterator end;
sm = _pollSet.poll(_timeout);
it = sm.begin();
end = sm.end();
for (; it != end; ++it)
{
if (it->second & PollSet::POLL_READ)
{
DatagramSocket ds(it->first);
_reader.read(ds);
}
else if (it->second & PollSet::POLL_ERROR)
{
_reader.setError(it->first.impl()->sockfd());
}
}
}
void stop()
{
_reader.stopHandler();
}
bool done() const
{
return _reader.handlerDone();
}
private:
void addSockets(int nSockets)
{
for (int i = 0; i < nSockets; ++i)
{
DatagramSocket ds; ds.bind(_address, true, true);
_pollSet.add(ds, PollSet::POLL_READ | PollSet::POLL_ERROR);
}
}
PollSet _pollSet;
SocketAddress _address;
Poco::Timespan _timeout;
UDPSocketReader<S> _reader;
};
} } // namespace Poco::Net
#endif // Net_MultiSocketPoller_INCLUDED

135
vendor/POCO/Net/include/Poco/Net/MulticastSocket.h vendored Normal file
View File

@ -0,0 +1,135 @@
//
// MulticastSocket.h
//
// Library: Net
// Package: Sockets
// Module: MulticastSocket
//
// Definition of the MulticastSocket class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MulticastSocket_INCLUDED
#define Net_MulticastSocket_INCLUDED
#include "Poco/Net/Net.h"
#ifdef POCO_NET_HAS_INTERFACE
#include "Poco/Net/DatagramSocket.h"
#include "Poco/Net/NetworkInterface.h"
namespace Poco {
namespace Net {
class Net_API MulticastSocket: public DatagramSocket
/// A MulticastSocket is a special DatagramSocket
/// that can be used to send packets to and receive
/// packets from multicast groups.
{
public:
MulticastSocket();
/// Creates an unconnected, unbound multicast socket.
///
/// Before the multicast socket can be used, bind(),
/// bind6() or connect() must be called.
///
/// Notice: The behavior of this constructor has changed
/// in release 2.0. Previously, the constructor created
/// an unbound IPv4 multicast socket.
explicit MulticastSocket(SocketAddress::Family family);
/// Creates an unconnected datagram socket.
///
/// The socket will be created for the
/// given address family.
MulticastSocket(const SocketAddress& address, bool reuseAddress = false);
/// Creates a datagram socket and binds it
/// to the given address.
///
/// Depending on the address family, the socket
/// will be either an IPv4 or an IPv6 socket.
MulticastSocket(const Socket& socket);
/// Creates the DatagramSocket with the SocketImpl
/// from another socket. The SocketImpl must be
/// a DatagramSocketImpl, otherwise an InvalidArgumentException
/// will be thrown.
~MulticastSocket();
/// Destroys the DatagramSocket.
MulticastSocket& operator = (const Socket& socket);
/// Assignment operator.
///
/// Releases the socket's SocketImpl and
/// attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
void setInterface(const NetworkInterface& interfc);
/// Sets the interface used for sending multicast packets.
///
/// To select the default interface, specify an empty
/// interface.
///
/// This is done by setting the IP_MULTICAST_IF/IPV6_MULTICAST_IF
/// socket option.
NetworkInterface getInterface() const;
/// Returns the interface used for sending multicast packets.
void setLoopback(bool flag);
/// Enable or disable loopback for multicast packets.
///
/// Sets the value of the IP_MULTICAST_LOOP/IPV6_MULTICAST_LOOP
/// socket option.
bool getLoopback() const;
/// Returns true iff loopback for multicast packets is enabled,
/// false otherwise.
void setTimeToLive(unsigned value);
/// Specifies the TTL/hop limit for outgoing packets.
///
/// Sets the value of the IP_MULTICAST_TTL/IPV6_MULTICAST_HOPS
/// socket option.
unsigned getTimeToLive() const;
/// Returns the TTL/hop limit for outgoing packets.
void joinGroup(const IPAddress& groupAddress);
/// Joins the specified multicast group at the default interface.
void joinGroup(const IPAddress& groupAddress, const NetworkInterface& interfc);
/// Joins the specified multicast group at the given interface.
void leaveGroup(const IPAddress& groupAddress);
/// Leaves the specified multicast group at the default interface.
void leaveGroup(const IPAddress& groupAddress, const NetworkInterface& interfc);
/// Leaves the specified multicast group at the given interface.
private:
static NetworkInterface findFirstInterface(const IPAddress& groupAddress);
/// Returns first multicast-eligible network interface.
};
} } // namespace Poco::Net
#endif // POCO_NET_HAS_INTERFACE
#endif // Net_MulticastSocket_INCLUDED

160
vendor/POCO/Net/include/Poco/Net/MultipartReader.h vendored Normal file
View File

@ -0,0 +1,160 @@
//
// MultipartReader.h
//
// Library: Net
// Package: Messages
// Module: MultipartReader
//
// Definition of the MultipartReader class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MultipartReader_INCLUDED
#define Net_MultipartReader_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/BufferedStreamBuf.h"
#include <istream>
namespace Poco {
namespace Net {
class MessageHeader;
class Net_API MultipartStreamBuf: public Poco::BufferedStreamBuf
/// This is the streambuf class used for reading from a multipart message stream.
{
public:
MultipartStreamBuf(std::istream& istr, const std::string& boundary);
~MultipartStreamBuf();
bool lastPart() const;
protected:
int readFromDevice(char* buffer, std::streamsize length);
private:
enum
{
STREAM_BUFFER_SIZE = 1024
};
std::istream& _istr;
std::string _boundary;
bool _lastPart;
};
class Net_API MultipartIOS: public virtual std::ios
/// The base class for MultipartInputStream.
{
public:
MultipartIOS(std::istream& istr, const std::string& boundary);
~MultipartIOS();
MultipartStreamBuf* rdbuf();
bool lastPart() const;
protected:
MultipartStreamBuf _buf;
};
class Net_API MultipartInputStream: public MultipartIOS, public std::istream
/// This class is for internal use by MultipartReader only.
{
public:
MultipartInputStream(std::istream& istr, const std::string& boundary);
~MultipartInputStream();
};
class Net_API MultipartReader
/// This class is used to split a MIME multipart
/// message into its single parts.
///
/// The format of multipart messages is described
/// in section 5.1 of RFC 2046.
///
/// To split a multipart message into its parts,
/// do the following:
/// - Create a MultipartReader object, passing it
/// an input stream and optionally a boundary string.
/// - while hasNextPart() returns true, call nextPart()
/// and read the part from stream().
///
/// Always ensure that you read all data from the part
/// stream, otherwise the MultipartReader will fail to
/// find the next part.
{
public:
explicit MultipartReader(std::istream& istr);
/// Creates the MultipartReader and attaches it to the
/// given input stream.
///
/// The boundary string is determined from the input
/// stream. The message must not contain a preamble
/// preceding the first encapsulation boundary.
MultipartReader(std::istream& istr, const std::string& boundary);
/// Creates the MultipartReader and attaches it to the
/// given input stream. The given boundary string is
/// used to find message boundaries.
~MultipartReader();
/// Destroys the MultipartReader.
void nextPart(MessageHeader& messageHeader);
/// Moves to the next part in the message and stores the
/// part's header fields in messageHeader.
///
/// Throws an MultipartException if there are no more parts
/// available, or if no boundary line can be found in
/// the input stream.
bool hasNextPart();
/// Returns true iff more parts are available.
///
/// Before the first call to nextPart(), returns
/// always true.
std::istream& stream() const;
/// Returns a reference to the reader's stream that
/// can be used to read the current part.
///
/// The returned reference will be valid until
/// nextPart() is called or the MultipartReader
/// object is destroyed.
const std::string& boundary() const;
/// Returns the multipart boundary used by this reader.
protected:
void findFirstBoundary();
void guessBoundary();
void parseHeader(MessageHeader& messageHeader);
bool readLine(std::string& line, std::string::size_type n);
private:
MultipartReader();
MultipartReader(const MultipartReader&);
MultipartReader& operator = (const MultipartReader&);
std::istream& _istr;
std::string _boundary;
MultipartInputStream* _pMPI;
};
} } // namespace Poco::Net
#endif // Net_MultipartReader_INCLUDED

109
vendor/POCO/Net/include/Poco/Net/MultipartWriter.h vendored Normal file
View File

@ -0,0 +1,109 @@
//
// MultipartWriter.h
//
// Library: Net
// Package: Messages
// Module: MultipartWriter
//
// Definition of the MultipartWriter class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_MultipartWriter_INCLUDED
#define Net_MultipartWriter_INCLUDED
#include "Poco/Net/Net.h"
#include <ostream>
namespace Poco {
namespace Net {
class MessageHeader;
class Net_API MultipartWriter
/// This class is used to write MIME multipart
/// messages to an output stream.
///
/// The format of multipart messages is described
/// in section 5.1 of RFC 2046.
///
/// To create a multipart message, first create
/// a MultipartWriter object.
/// Then, for each part, call nextPart() and
/// write the content to the output stream.
/// Repeat for all parts.
/// After the last part has been written,
/// call close() to finish the multipart message.
{
public:
explicit MultipartWriter(std::ostream& ostr);
/// Creates the MultipartWriter, using the
/// given output stream.
///
/// Creates a random boundary string.
MultipartWriter(std::ostream& ostr, const std::string& boundary);
/// Creates the MultipartWriter, using the
/// given output stream and boundary string.
~MultipartWriter();
/// Destroys the MultipartWriter.
void nextPart(const MessageHeader& header);
/// Opens a new message part and writes
/// the message boundary string, followed
/// by the message header to the stream.
void close();
/// Closes the multipart message and writes
/// the terminating boundary string.
///
/// Does not close the underlying stream.
std::ostream& stream();
/// Returns the writer's stream.
const std::string& boundary() const;
/// Returns the multipart boundary used by this writer.
static std::string createBoundary();
/// Creates a random boundary string.
///
/// The string always has the form
/// MIME_boundary_XXXXXXXXXXXX, where
/// XXXXXXXXXXXX is a random hexadecimal
/// number.
private:
MultipartWriter();
MultipartWriter(const MultipartWriter&);
MultipartWriter& operator = (const MultipartWriter&);
std::ostream& _ostr;
std::string _boundary;
bool _firstPart;
};
//
// inlines
//
inline std::ostream& MultipartWriter::stream()
{
return _ostr;
}
} } // namespace Poco::Net
#endif // Net_MultipartWriter_INCLUDED

181
vendor/POCO/Net/include/Poco/Net/NTLMCredentials.h vendored Normal file
View File

@ -0,0 +1,181 @@
//
// NTLMCredentials.h
//
// Library: Net
// Package: NTLM
// Module: NTLMCredentials
//
// Definition of the NTLMCredentials class.
//
// Copyright (c) 2019, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NTLMCredentials_INCLUDED
#define Net_NTLMCredentials_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/BinaryReader.h"
#include "Poco/BinaryWriter.h"
#include <vector>
namespace Poco {
namespace Net {
class Net_API NTLMCredentials
/// This is a utility class for working with
/// NTLMv2 Authentication.
///
/// Note: This implementation is based on the
/// "The NTLM Authentication Protocol and Security Support Provider"
/// document written by Eric Glass and avilable from
/// http://davenport.sourceforge.net/ntlm.html
/// and the NT LAN Manager (NTLM) Authentication Protocol
/// [MS-NLMP] document by Microsoft.
{
public:
enum
{
NTLM_MESSAGE_TYPE_NEGOTIATE = 0x01,
NTLM_MESSAGE_TYPE_CHALLENGE = 0x02,
NTLM_MESSAGE_TYPE_AUTHENTICATE = 0x03
};
enum
{
NTLM_FLAG_NEGOTIATE_UNICODE = 0x00000001,
NTLM_FLAG_NEGOTIATE_OEM = 0x00000002,
NTLM_FLAG_REQUEST_TARGET = 0x00000004,
NTLM_FLAG_NEGOTIATE_NTLM = 0x00000200,
NTLM_FLAG_DOMAIN_SUPPLIED = 0x00001000,
NTLM_FLAG_WORKST_SUPPLIED = 0x00002000,
NTLM_FLAG_NEGOTIATE_LOCAL = 0x00004000,
NTLM_FLAG_NEGOTIATE_ALWAYS_SIGN = 0x00008000,
NTLM_FLAG_NEGOTIATE_NTLM2_KEY = 0x00080000,
NTLM_FLAG_TARGET_DOMAIN = 0x00010000,
NTLM_FLAG_TARGET_SERVER = 0x00020000,
NTLM_FLAG_TARGET_SHARE = 0x00040000,
NTLM_FLAG_NEGOTIATE_TARGET = 0x00800000,
NTLM_FLAG_NEGOTIATE_128 = 0x20000000,
NTLM_FLAG_NEGOTIATE_56 = 0x80000000
};
struct NegotiateMessage
/// This message is sent from the client to initiate NTLM authentication.
{
NegotiateMessage(): flags(0) {}
Poco::UInt32 flags;
std::string domain;
std::string workstation;
};
struct ChallengeMessage
/// This message is sent back by the server and contains the NTLM challenge.
{
ChallengeMessage(): flags(0) {}
Poco::UInt32 flags;
std::vector<unsigned char> challenge;
std::string target;
std::vector<unsigned char> targetInfo;
};
struct AuthenticateMessage
/// This message is sent from the client to authenticate itself by providing
/// a response to the server challenge.
{
AuthenticateMessage(): flags(0) {}
Poco::UInt32 flags;
std::vector<unsigned char> lmResponse;
std::vector<unsigned char> ntlmResponse;
std::string target;
std::string username;
std::string workstation;
};
struct BufferDesc
{
BufferDesc():
length(0),
reserved(0),
offset(0)
{
}
BufferDesc(Poco::UInt16 len, Poco::UInt32 off):
length(len),
reserved(len),
offset(off)
{
}
Poco::UInt16 length;
Poco::UInt16 reserved;
Poco::UInt32 offset;
};
static std::vector<unsigned char> createNonce();
/// Creates an 8-byte client nonce for NTLM authentication.
static Poco::UInt64 createTimestamp();
/// Creates the NTLM timestamp in tenths of a microsecond since January 1, 1601,
/// using the current system time.
static std::vector<unsigned char> createPasswordHash(const std::string& password);
/// Creates the NTLM password hash (MD4 of UTF-16-converted password).
static std::vector<unsigned char> createNTLMv2Hash(const std::string& username, const std::string& target, const std::string& password);
/// Creates the NTLMv2 hash, which is the HMAC-MD5 of the concatenated UTF-16 uppercase username and target,
/// using the password hash as HMAC passphrase.
static std::vector<unsigned char> createLMv2Response(const std::vector<unsigned char>& ntlm2Hash, const std::vector<unsigned char>& challenge, const std::vector<unsigned char>& nonce);
/// Creates the LMv2 response by computing the HMAC-MD5 of the challenge and nonce, using the
/// ntlm2Hash (see createNTLMv2Hash()) as HMAC passphrase.
static std::vector<unsigned char> createNTLMv2Response(const std::vector<unsigned char>& ntlm2Hash, const std::vector<unsigned char>& challenge, const std::vector<unsigned char>& nonce, const std::vector<unsigned char>& targetInfo, Poco::UInt64 timestamp);
/// Creates the NTLMv2 response by creating the "blob" and prepending its HMAC-MD5, using the ntlm2Hash as HMAC passphrase.
static std::vector<unsigned char> formatNegotiateMessage(const NegotiateMessage& message);
/// Creates the NTLM Type 1 Negotiate message used for initiating NTLM authentication from the client.
static bool parseChallengeMessage(const unsigned char* buffer, std::size_t size, ChallengeMessage& message);
/// Parses a NTLM Type 2 Challenge message.
///
/// Returns true if the message was parsed successfully, otherwise false.
static std::vector<unsigned char> formatAuthenticateMessage(const AuthenticateMessage& message);
/// Creates the NTLM Type 3 Authenticate message used for sending the response to the challenge.
static void readBufferDesc(Poco::BinaryReader& reader, BufferDesc& desc);
/// Reads a buffer descriptor.
static void writeBufferDesc(Poco::BinaryWriter& writer, const BufferDesc& desc);
/// Writes a buffer descriptor.
static void splitUsername(const std::string& usernameAndDomain, std::string& username, std::string& domain);
/// Splits a username containing a domain into plain username and domain.
/// Supported formats are <DOMAIN>\<username> and <username>@<DOMAIN>.
static std::string toBase64(const std::vector<unsigned char>& buffer);
/// Converts the buffer to a base64-encoded string.
static std::vector<unsigned char> fromBase64(const std::string& base64);
/// Decodes the given base64-encoded string.
static const std::string NTLMSSP;
/// Message signature string.
};
} } // namespace Poco::Net
#endif // Net_NTLMCredentials_INCLUDED

64
vendor/POCO/Net/include/Poco/Net/NTPClient.h vendored Normal file
View File

@ -0,0 +1,64 @@
//
// NTPClient.h
//
// Library: Net
// Package: NTP
// Module: NTPClient
//
// Definition of the NTPClient class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NTPClient_INCLUDED
#define Net_NTPClient_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/NTPEventArgs.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/BasicEvent.h"
namespace Poco {
namespace Net {
class Net_API NTPClient
/// This class provides NTP (Network Time Protocol) client functionality.
{
public:
mutable Poco::BasicEvent<NTPEventArgs> response;
explicit NTPClient(SocketAddress::Family family, int timeout = 3000000);
/// Creates an NTP client.
~NTPClient();
/// Destroys the NTP client.
int request(SocketAddress& address) const;
/// Request the time from the server at address.
/// Notifications are posted for events.
///
/// Returns the number of valid replies.
int request(const std::string& address) const;
/// Request the time from the server at address.
/// Notifications are posted for events.
///
/// Returns the number of valid replies.
private:
mutable SocketAddress::Family _family;
int _timeout;
};
} } // namespace Poco::Net
#endif // Net_NTPClient_INCLUDED

84
vendor/POCO/Net/include/Poco/Net/NTPEventArgs.h vendored Normal file
View File

@ -0,0 +1,84 @@
//
// NTPEventArgs.h
//
// Library: Net
// Package: NTP
// Module: NTPEventArgs
//
// Definition of NTPEventArgs.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NTPEventArgs_INCLUDED
#define Net_NTPEventArgs_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/Net/NTPPacket.h"
namespace Poco {
namespace Net {
class Net_API NTPEventArgs
/// The purpose of the NTPEventArgs class is to be used as template parameter
/// to instantiate event members in NTPClient class.
/// When clients register for an event notification, the reference to the class is
/// passed to the handler function to provide information about the event.
{
public:
NTPEventArgs(const SocketAddress& address);
/// Creates NTPEventArgs.
virtual ~NTPEventArgs();
/// Destroys NTPEventArgs.
std::string hostName() const;
/// Tries to resolve the target IP address into host name.
/// If unsuccessful, all exceptions are silently ignored and
/// the IP address is returned.
std::string hostAddress() const;
/// Returns the target IP address.
const NTPPacket &packet();
/// Returns the NTP packet.
private:
NTPEventArgs();
void setPacket(NTPPacket &packet);
SocketAddress _address;
NTPPacket _packet;
friend class NTPClient;
};
//
// inlines
//
inline const NTPPacket &NTPEventArgs::packet()
{
return _packet;
}
inline void NTPEventArgs::setPacket(NTPPacket &packet)
{
_packet = packet;
}
} } // namespace Poco::Net
#endif

207
vendor/POCO/Net/include/Poco/Net/NTPPacket.h vendored Normal file
View File

@ -0,0 +1,207 @@
//
// NTPPacket.h
//
// Library: Net
// Package: NTP
// Module: NTPPacket
//
// Definition of the NTPPacket class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NTPPacket_INCLUDED
#define Net_NTPPacket_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Net/Net.h"
#include "Poco/Timestamp.h"
namespace Poco {
namespace Net {
class Net_API NTPPacket
/// This class is the NTP packet abstraction.
{
public:
NTPPacket();
/// Creates an NTPPacket.
NTPPacket(Poco::UInt8 *packet);
/// Creates an NTPPacket.
///
/// Assumed to have at least 48 bytes.
~NTPPacket();
/// Destroys the NTPPacket.
void packet(Poco::UInt8 *packet) const;
/// Returns the NTP packet.
///
/// Assumed to have at least 48 bytes.
void setPacket(Poco::UInt8 *packet);
/// Returns the NTP packet.
///
/// Assumed to have exactly 48 bytes.
Poco::Int8 leapIndicator() const;
/// Returns the leap indicator.
Poco::Int8 version() const;
/// Returns the version.
Poco::Int8 mode() const;
/// Returns the mode.
Poco::Int8 stratum() const;
/// Returns the stratum.
Poco::Int8 pool() const;
/// Returns the pool.
Poco::Int8 precision() const;
/// Returns the precision
Poco::Int32 rootDelay() const;
/// Returns the root delay
Poco::Int32 rootDispersion() const;
/// Returns the root dispersion
Poco::Int32 referenceId() const;
/// Returns the reference id
Poco::Int64 referenceTimestamp() const;
/// Returns the reference timestamp
Poco::Int64 originateTimestamp() const;
/// Returns the originate timestamp
Poco::Int64 receiveTimestamp() const;
/// Returns the receive timestamp
Poco::Int64 transmitTimestamp() const;
/// Returns the transmit timestamp
Poco::Timestamp referenceTime() const;
/// Returns the reference time
Poco::Timestamp originateTime() const;
/// Returns the originate time
Poco::Timestamp receiveTime() const;
/// Returns the receive time
Poco::Timestamp transmitTime() const;
/// Returns the transmit time
private:
Poco::Timestamp convertTime(Poco::Int64 tm) const;
Poco::Int8 _leapIndicator;
Poco::Int8 _version;
Poco::Int8 _mode;
Poco::Int8 _stratum;
Poco::Int8 _pool;
Poco::Int8 _precision;
Poco::Int32 _rootDelay;
Poco::Int32 _rootDispersion;
Poco::Int32 _referenceId;
Poco::Int64 _referenceTimestamp;
Poco::Int64 _originateTimestamp;
Poco::Int64 _receiveTimestamp;
Poco::Int64 _transmitTimestamp;
};
//
// inlines
//
inline Poco::Int8 NTPPacket::leapIndicator() const
{
return _leapIndicator;
}
inline Poco::Int8 NTPPacket::version() const
{
return _version;
}
inline Poco::Int8 NTPPacket::mode() const
{
return _mode;
}
inline Poco::Int8 NTPPacket::stratum() const
{
return _stratum;
}
inline Poco::Int8 NTPPacket::pool() const
{
return _pool;
}
inline Poco::Int8 NTPPacket::precision() const
{
return _precision;
}
inline Poco::Int32 NTPPacket::rootDelay() const
{
return _rootDelay;
}
inline Poco::Int32 NTPPacket::rootDispersion() const
{
return _rootDispersion;
}
inline Poco::Int32 NTPPacket::referenceId() const
{
return _referenceId;
}
inline Poco::Int64 NTPPacket::referenceTimestamp() const
{
return _referenceTimestamp;
}
inline Poco::Int64 NTPPacket::originateTimestamp() const
{
return _originateTimestamp;
}
inline Poco::Int64 NTPPacket::receiveTimestamp() const
{
return _receiveTimestamp;
}
inline Poco::Int64 NTPPacket::transmitTimestamp() const
{
return _transmitTimestamp;
}
} } // namespace Poco::Net
#endif // Net_NTPPacket_INCLUDED

132
vendor/POCO/Net/include/Poco/Net/NameValueCollection.h vendored Normal file
View File

@ -0,0 +1,132 @@
//
// NameValueCollection.h
//
// Library: Net
// Package: Messages
// Module: NameValueCollection
//
// Definition of the NameValueCollection class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NameValueCollection_INCLUDED
#define Net_NameValueCollection_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/String.h"
#include "Poco/ListMap.h"
#include <cstddef>
namespace Poco {
namespace Net {
class Net_API NameValueCollection
/// A collection of name-value pairs that are used in
/// various internet protocols like HTTP and SMTP.
///
/// The name is case-insensitive.
///
/// There can be more than one name-value pair with the
/// same name.
{
public:
using HeaderMap = Poco::ListMap<std::string, std::string>;
using Iterator = HeaderMap::Iterator;
using ConstIterator = HeaderMap::ConstIterator;
NameValueCollection();
/// Creates an empty NameValueCollection.
NameValueCollection(const NameValueCollection& nvc);
/// Creates a NameValueCollection by copying another one.
NameValueCollection(NameValueCollection&& nvc) noexcept;
/// Creates a NameValueCollection by moving another one.
virtual ~NameValueCollection();
/// Destroys the NameValueCollection.
NameValueCollection& operator = (const NameValueCollection& nvc);
/// Assigns the name-value pairs of another NameValueCollection to this one.
NameValueCollection& operator = (NameValueCollection&& nvc) noexcept;
/// Moves the name-value pairs of another NameValueCollection to this one.
void swap(NameValueCollection& nvc);
/// Swaps the NameValueCollection with another one.
const std::string& operator [] (const std::string& name) const;
/// Returns the value of the (first) name-value pair with the given name.
///
/// Throws a NotFoundException if the name-value pair does not exist.
void set(const std::string& name, const std::string& value);
/// Sets the value of the (first) name-value pair with the given name.
void add(const std::string& name, const std::string& value);
/// Adds a new name-value pair with the given name and value.
const std::string& get(const std::string& name) const;
/// Returns the value of the first name-value pair with the given name.
///
/// Throws a NotFoundException if the name-value pair does not exist.
const std::string& get(const std::string& name, const std::string& defaultValue) const;
/// Returns the value of the first name-value pair with the given name.
/// If no value with the given name has been found, the defaultValue is returned.
bool has(const std::string& name) const;
/// Returns true if there is at least one name-value pair
/// with the given name.
ConstIterator find(const std::string& name) const;
/// Returns an iterator pointing to the first name-value pair
/// with the given name.
ConstIterator begin() const;
/// Returns an iterator pointing to the begin of
/// the name-value pair collection.
ConstIterator end() const;
/// Returns an iterator pointing to the end of
/// the name-value pair collection.
bool empty() const;
/// Returns true iff the header does not have any content.
std::size_t size() const;
/// Returns the number of name-value pairs in the
/// collection.
void erase(const std::string& name);
/// Removes all name-value pairs with the given name.
void clear();
/// Removes all name-value pairs and their values.
private:
HeaderMap _map;
};
//
// inlines
//
inline void swap(NameValueCollection& nvc1, NameValueCollection& nvc2)
{
nvc1.swap(nvc2);
}
} } // namespace Poco::Net
#endif // Net_NameValueCollection_INCLUDED

127
vendor/POCO/Net/include/Poco/Net/Net.h vendored Normal file
View File

@ -0,0 +1,127 @@
//
// Net.h
//
// Library: Net
// Package: NetCore
// Module: Net
//
// Basic definitions for the Poco Net library.
// This file must be the first file included by every other Net
// header file.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_Net_INCLUDED
#define Net_Net_INCLUDED
#include "Poco/Foundation.h"
//
// The following block is the standard way of creating macros which make exporting
// from a DLL simpler. All files within this DLL are compiled with the Net_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see
// Net_API functions as being imported from a DLL, wheras this DLL sees symbols
// defined with this macro as being exported.
//
#if defined(_WIN32) && defined(POCO_DLL)
#if defined(Net_EXPORTS)
#define Net_API __declspec(dllexport)
#else
#define Net_API __declspec(dllimport)
#endif
#endif
#if !defined(Net_API)
#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
#define Net_API __attribute__ ((visibility ("default")))
#else
#define Net_API
#endif
#endif
//
// Automatically link Net library.
//
#if defined(_MSC_VER)
#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(Net_EXPORTS)
#pragma comment(lib, "PocoNet" POCO_LIB_SUFFIX)
#endif
#endif
// Default to enabled IPv6 support if not explicitly disabled
#if !defined(POCO_NET_NO_IPv6) && !defined (POCO_HAVE_IPv6)
#define POCO_HAVE_IPv6
#elif defined(POCO_NET_NO_IPv6) && defined (POCO_HAVE_IPv6)
#undef POCO_HAVE_IPv6
#endif // POCO_NET_NO_IPv6, POCO_HAVE_IPv6
namespace Poco {
namespace Net {
void Net_API initializeNetwork();
/// Initialize the network subsystem.
/// (Windows only, no-op elsewhere)
void Net_API uninitializeNetwork();
/// Uninitialize the network subsystem.
/// (Windows only, no-op elsewhere)
std::string htmlize(const std::string& str);
/// Returns a copy of html with reserved HTML
/// characters (<, >, ", &) propery escaped.
} } // namespace Poco::Net
//
// Automate network initialization (only relevant on Windows).
//
#if defined(POCO_OS_FAMILY_WINDOWS) && !defined(POCO_NO_AUTOMATIC_LIB_INIT) && !defined(__GNUC__)
extern "C" const struct Net_API NetworkInitializer pocoNetworkInitializer;
#if defined(Net_EXPORTS)
#if defined(_WIN64) || (defined(_WIN32_WCE) && !defined(x86))
#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/export:"#s))
#elif defined(_WIN32)
#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/export:_"#s))
#endif
#else // !Net_EXPORTS
#if defined(_WIN64) || (defined(_WIN32_WCE) && !defined(x86))
#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/include:"#s))
#elif defined(_WIN32)
#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/include:_"#s))
#endif
#endif // Net_EXPORTS
POCO_NET_FORCE_SYMBOL(pocoNetworkInitializer)
#endif // POCO_OS_FAMILY_WINDOWS
//
// Define POCO_NET_HAS_INTERFACE for platforms that have network interface detection implemented.
//
#if defined(POCO_OS_FAMILY_WINDOWS) || (POCO_OS == POCO_OS_LINUX) || (POCO_OS == POCO_OS_ANDROID) || defined(POCO_OS_FAMILY_BSD) || (POCO_OS == POCO_OS_SOLARIS) || (POCO_OS == POCO_OS_QNX)
#define POCO_NET_HAS_INTERFACE
#endif
#endif // Net_Net_INCLUDED

61
vendor/POCO/Net/include/Poco/Net/NetException.h vendored Normal file
View File

@ -0,0 +1,61 @@
//
// NetException.h
//
// Library: Net
// Package: NetCore
// Module: NetException
//
// Definition of the NetException class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NetException_INCLUDED
#define Net_NetException_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Exception.h"
namespace Poco {
namespace Net {
POCO_DECLARE_EXCEPTION(Net_API, NetException, Poco::IOException)
POCO_DECLARE_EXCEPTION(Net_API, InvalidAddressException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, InvalidSocketException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, ServiceNotFoundException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, ConnectionAbortedException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, ConnectionResetException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, ConnectionRefusedException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, DNSException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, HostNotFoundException, DNSException)
POCO_DECLARE_EXCEPTION(Net_API, NoAddressFoundException, DNSException)
POCO_DECLARE_EXCEPTION(Net_API, InterfaceNotFoundException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, NoMessageException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, MessageException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, MultipartException, MessageException)
POCO_DECLARE_EXCEPTION(Net_API, HTTPException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, NotAuthenticatedException, HTTPException)
POCO_DECLARE_EXCEPTION(Net_API, UnsupportedRedirectException, HTTPException)
POCO_DECLARE_EXCEPTION(Net_API, FTPException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, SMTPException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, POP3Exception, NetException)
POCO_DECLARE_EXCEPTION(Net_API, ICMPException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, ICMPFragmentationException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, NTPException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, HTMLFormException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, WebSocketException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, UnsupportedFamilyException, NetException)
POCO_DECLARE_EXCEPTION(Net_API, AddressFamilyMismatchException, NetException)
} } // namespace Poco::Net
#endif // Net_NetException_INCLUDED

352
vendor/POCO/Net/include/Poco/Net/NetworkInterface.h vendored Normal file
View File

@ -0,0 +1,352 @@
//
// NetworkInterface.h
//
// Library: Net
// Package: Sockets
// Module: NetworkInterface
//
// Definition of the NetworkInterface class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NetworkInterface_INCLUDED
#define Net_NetworkInterface_INCLUDED
#include "Poco/Net/Net.h"
#ifdef POCO_NET_HAS_INTERFACE
#include "Poco/Net/IPAddress.h"
#include "Poco/Mutex.h"
#include "Poco/Tuple.h"
#include <map>
#include <ostream>
namespace Poco {
namespace Net {
class NetworkInterfaceImpl;
class Net_API NetworkInterface
/// This class represents a network interface.
///
/// NetworkInterface is used with MulticastSocket to specify
/// multicast interfaces for sending and receiving multicast
/// messages.
///
/// The class also provides static member functions for
/// enumerating or searching network interfaces and their
/// respective configuration values.
///
/// On Windows, detection capabilities vary depending on the
/// OS version/service pack. Although the best effort is made
/// not to attempt access to non-existent features through a
/// combination of compile/runtime checks, when running binaries
/// compiled on a newer version of the OS on an older one
/// problems may occur; if possible, it is best to run
/// binaries on the OS version where they were compiled.
/// This particularly applies to OS versions older than Vista
/// and XP.
{
public:
typedef std::vector<NetworkInterface> List;
typedef List NetworkInterfaceList;//@deprecated
typedef std::map<unsigned, NetworkInterface> Map;
typedef Poco::Tuple<IPAddress, IPAddress, IPAddress> AddressTuple;
typedef std::vector<AddressTuple> AddressList;
typedef AddressList::iterator AddressIterator;
typedef AddressList::const_iterator ConstAddressIterator;
typedef std::vector<unsigned char> MACAddress;
enum AddressType
{
IP_ADDRESS,
SUBNET_MASK,
BROADCAST_ADDRESS
};
enum Type
{
NI_TYPE_ETHERNET_CSMACD,
NI_TYPE_ISO88025_TOKENRING,
NI_TYPE_FRAMERELAY,
NI_TYPE_PPP,
NI_TYPE_SOFTWARE_LOOPBACK,
NI_TYPE_ATM,
NI_TYPE_IEEE80211,
NI_TYPE_TUNNEL,
NI_TYPE_IEEE1394,
NI_TYPE_OTHER
};
enum IPVersion
{
IPv4_ONLY, /// Return interfaces with IPv4 address only
IPv6_ONLY, /// Return interfaces with IPv6 address only
IPv4_OR_IPv6 /// Return interfaces with IPv4 or IPv6 address
};
static const unsigned NO_INDEX = ~0;
#if defined(POCO_OS_FAMILY_WINDOWS)
static const char MAC_SEPARATOR = '-';
#else
static const char MAC_SEPARATOR = ':';
#endif
NetworkInterface(unsigned index = NO_INDEX);
/// Creates a NetworkInterface representing the
/// default interface.
///
/// The name is empty, the IP address is the wildcard
/// address and the index is max value of unsigned integer.
NetworkInterface(const NetworkInterface& interfc);
/// Creates the NetworkInterface by copying another one.
~NetworkInterface();
/// Destroys the NetworkInterface.
NetworkInterface& operator = (const NetworkInterface& interfc);
/// Assigns another NetworkInterface.
bool operator < (const NetworkInterface& other) const;
/// Operator less-than.
bool operator == (const NetworkInterface& other) const;
/// Operator equal. Compares interface indices.
void swap(NetworkInterface& other);
/// Swaps the NetworkInterface with another one.
unsigned index() const;
/// Returns the interface OS index.
const std::string& name() const;
/// Returns the interface name.
const std::string& displayName() const;
/// Returns the interface display name.
///
/// On Windows platforms, this is currently the network adapter
/// name. This may change to the "friendly name" of the network
/// connection in a future version, however.
///
/// On other platforms this is the same as name().
const std::string& adapterName() const;
/// Returns the interface adapter name.
///
/// On Windows platforms, this is the network adapter LUID.
/// The adapter name is used by some Windows Net APIs like DHCP.
///
/// On other platforms this is the same as name().
const IPAddress& firstAddress(IPAddress::Family family) const;
/// Returns the first IP address bound to the interface.
/// Throws NotFoundException if the address family is not
/// configured on the interface.
void firstAddress(IPAddress& addr, IPAddress::Family family = IPAddress::IPv4) const;
/// Returns the first IP address bound to the interface.
/// If the address family is not configured on the interface,
/// the address returned in addr will be unspecified (wildcard).
const IPAddress& address(unsigned index = 0) const;
/// Returns the IP address bound to the interface at index position.
void addAddress(const IPAddress& address);
/// Adds address to the interface.
void addAddress(const IPAddress& address, const IPAddress& subnetMask, const IPAddress& broadcastAddress);
/// Adds address to the interface.
const AddressList& addressList() const;
/// Returns the list of IP addresses bound to the interface.
const IPAddress& subnetMask(unsigned index = 0) const;
/// Returns the subnet mask for this network interface.
const IPAddress& broadcastAddress(unsigned index = 0) const;
/// Returns the broadcast address for this network interface.
const IPAddress& destAddress(unsigned index = 0) const;
/// Returns the IPv4 point-to-point destination address for this network interface.
const MACAddress& macAddress() const;
/// Returns MAC (Media Access Control) address for the interface.
unsigned mtu() const;
/// Returns the MTU for this interface.
NetworkInterface::Type type() const;
/// returns the MIB IfType of the interface.
bool supportsIP() const;
/// Returns true if the interface supports IP.
bool supportsIPv4() const;
/// Returns true if the interface supports IPv4.
bool supportsIPv6() const;
/// Returns true if the interface supports IPv6.
bool supportsBroadcast() const;
/// Returns true if the interface supports broadcast.
bool supportsMulticast() const;
/// Returns true if the interface supports multicast.
bool isLoopback() const;
/// Returns true if the interface is loopback.
bool isPointToPoint() const;
/// Returns true if the interface is point-to-point.
bool isRunning() const;
/// Returns true if the interface is running.
bool isUp() const;
/// Returns true if the interface is up.
static NetworkInterface forName(const std::string& name, bool requireIPv6 = false);
/// Returns the NetworkInterface for the given name.
///
/// If requireIPv6 is false, an IPv4 interface is returned.
/// Otherwise, an IPv6 interface is returned.
///
/// Throws an InterfaceNotFoundException if an interface
/// with the give name does not exist.
static NetworkInterface forName(const std::string& name, IPVersion ipVersion);
/// Returns the NetworkInterface for the given name.
///
/// The ipVersion argument can be used to specify whether
/// an IPv4 (IPv4_ONLY) or IPv6 (IPv6_ONLY) interface is required,
/// or whether the caller does not care (IPv4_OR_IPv6).
///
/// Throws an InterfaceNotFoundException if an interface
/// with the give name does not exist.
static NetworkInterface forAddress(const IPAddress& address);
/// Returns the NetworkInterface for the given IP address.
///
/// Throws an InterfaceNotFoundException if an interface
/// with the give address does not exist.
static NetworkInterface forIndex(unsigned index);
/// Returns the NetworkInterface for the given interface index.
///
/// Throws an InterfaceNotFoundException if an interface
/// with the given index does not exist.
static List list(bool ipOnly = true, bool upOnly = true);
/// Returns a list with all network interfaces
/// on the system.
///
/// If ipOnly is true, only interfaces supporting IP
/// are returned. Otherwise, all system network interfaces
/// are returned.
///
/// If upOnly is true, only interfaces being up are returned.
/// Otherwise, both interfaces being up and down are returned.
///
/// If there are multiple addresses bound to one interface,
/// multiple NetworkInterface entries are listed for
/// the same interface.
static Map map(bool ipOnly = true, bool upOnly = true);
/// Returns a map containing system network interfaces
/// Map is keyed by interface system indices.
///
/// If ipOnly is true, only interfaces supporting IP
/// are returned. Otherwise, all system network interfaces
/// are returned.
///
/// If upOnly is true, only interfaces being up are returned.
/// Otherwise, both interfaces being up and down are returned.
///
/// If there are multiple addresses bound to one interface,
/// they are contained within the NetworkInterface (second)
/// member of the pair.
protected:
NetworkInterface(const std::string& name, const std::string& displayName, const std::string& adapterName, const IPAddress& address, unsigned index, MACAddress* pMACAddress = 0);
/// Creates the NetworkInterface.
NetworkInterface(const std::string& name, const std::string& displayName, const std::string& adapterName, unsigned index, MACAddress* pMACAddress = 0);
/// Creates the NetworkInterface.
NetworkInterface(const std::string& name, const IPAddress& address, unsigned index, MACAddress* pMACAddress = 0);
/// Creates the NetworkInterface.
NetworkInterface(const std::string& name,
const std::string& displayName,
const std::string& adapterName,
const IPAddress& address,
const IPAddress& subnetMask,
const IPAddress& broadcastAddress,
unsigned index,
MACAddress* pMACAddress = 0);
/// Creates the NetworkInterface.
NetworkInterface(const std::string& name,
const IPAddress& address,
const IPAddress& subnetMask,
const IPAddress& broadcastAddress,
unsigned index,
MACAddress* pMACAddress = 0);
/// Creates the NetworkInterface.
IPAddress interfaceNameToAddress(const std::string& interfaceName) const;
/// Determines the IPAddress bound to the interface with the given name.
unsigned interfaceNameToIndex(const std::string& interfaceName) const;
/// Determines the interface index of the interface with the given name.
NetworkInterfaceImpl& impl() { return *_pImpl; };
private:
NetworkInterfaceImpl* _pImpl;
static Poco::FastMutex _mutex;
};
///
/// inlines
///
inline bool NetworkInterface::operator < (const NetworkInterface& other) const
{
return this->index() < other.index();
}
inline bool NetworkInterface::operator == (const NetworkInterface& other) const
{
return this->index() == other.index();
}
} } // namespace Poco::Net
Net_API std::ostream& operator << (std::ostream& ostr, const Poco::Net::NetworkInterface::MACAddress& addr);
#endif // POCO_NET_HAS_INTERFACE
#endif // Net_NetworkInterface_INCLUDED

47
vendor/POCO/Net/include/Poco/Net/NullPartHandler.h vendored Normal file
View File

@ -0,0 +1,47 @@
//
// NullPartHandler.h
//
// Library: Net
// Package: Messages
// Module: NullPartHandler
//
// Definition of the NullPartHandler class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_NullPartHandler_INCLUDED
#define Net_NullPartHandler_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/PartHandler.h"
namespace Poco {
namespace Net {
class Net_API NullPartHandler: public PartHandler
/// A very special PartHandler that simply discards all data.
{
public:
NullPartHandler();
/// Creates the NullPartHandler.
~NullPartHandler();
/// Destroys the NullPartHandler.
void handlePart(const MessageHeader& header, std::istream& stream);
/// Reads and discards all data from the stream.
};
} } // namespace Poco::Net
#endif // Net_NullPartHandler_INCLUDED

274
vendor/POCO/Net/include/Poco/Net/OAuth10Credentials.h vendored Normal file
View File

@ -0,0 +1,274 @@
//
// OAuth10Credentials.h
//
// Library: Net
// Package: OAuth
// Module: OAuth10Credentials
//
// Definition of the OAuth10Credentials class.
//
// Copyright (c) 2014, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_OAuth10Credentials_INCLUDED
#define Net_OAuth10Credentials_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/URI.h"
namespace Poco {
namespace Net {
class HTTPRequest;
class HTMLForm;
class Net_API OAuth10Credentials
/// This class implements OAuth 1.0A authentication for HTTP requests,
/// according to RFC 5849.
///
/// Only PLAINTEXT and HMAC-SHA1 signature methods are
/// supported. The RSA-SHA1 signature method is not supported.
///
/// The OAuth10Credentials can be used to sign a client request, as
/// well as to verify the signature of a request on the server.
///
/// To sign a client request, using a known consumer (client) key, consumer (client) secret,
/// OAuth token and token secret:
///
/// 1. Create an OAuth10Credentials object using all four credentials, either using
/// the four argument constructor, or by using the default constructor and setting
/// the credentials using the setter methods.
/// 2. Create a URI containing the full request URI.
/// 3. Create an appropriate HTTPRequest object.
/// 4. Optionally, create a HTMLForm object containing additional parameters to sign.
/// 5. Sign the request by calling authenticate(). This will add an OAuth
/// Authorization header to the request.
/// 6. Send the request using a HTTPClientSession.
///
/// To request the OAuth request token from a server, using only the consumer (client) key
/// and consumer (client) secret:
///
/// 1. Create an OAuth10Credentials object using the two consumer credentials, either using
/// the two argument constructor, or by using the default constructor and setting
/// the credentials using the setter methods.
/// 2. Specify the callback URI using setCallback().
/// 3. Create a URI containing the full request URI to obtain the token.
/// 4. Create an appropriate HTTPRequest object.
/// 5. Sign the request by calling authenticate(). This will add an OAuth
/// Authorization header to the request.
/// 6. Send the request using a HTTPClientSession.
/// 7. The response will contain the request token and request token secret.
/// These can be extracted from the response body using a HTMLForm object.
///
/// Requesting the access token and secret (temporary credentials) from the server
/// is analogous to signing a client request using consumer key, consumer secret,
/// request token and request token secret.
/// The server response will contain the access token and access token secret,
/// which can again be extracted from the response body using a HTMLForm object.
///
/// To verify a request on the server:
///
/// 1. Create an OAuth10Credentials object using the constructor taking a
/// HTTPRequest object. This will extract the consumer key and token (if
/// provided).
/// 2. Provide the consumer secret and token secret (if required) matching the
/// consumer key and token to the OAuth10Credentials object using the
/// setter methods.
/// 3. Create an URI object containing the full request URI.
/// 4. Call verify() to verify the signature.
/// 5. If verification was successful, and the request was a request for
/// a request (temporary) token, call getCallback() to
/// obtain the callback URI provided by the client.
{
public:
enum SignatureMethod
/// OAuth 1.0A Signature Method.
{
SIGN_PLAINTEXT, /// OAuth 1.0A PLAINTEXT signature method
SIGN_HMAC_SHA1 /// OAuth 1.0A HMAC-SHA1 signature method
};
OAuth10Credentials();
/// Creates an empty OAuth10Credentials object.
OAuth10Credentials(const std::string& consumerKey, const std::string& consumerSecret);
/// Creates an OAuth10Credentials object with the given consumer key and consumer secret.
///
/// The token and tokenSecret will be left empty.
OAuth10Credentials(const std::string& consumerKey, const std::string& consumerSecret, const std::string& token, const std::string& tokenSecret);
/// Creates an OAuth10Credentials object with the given consumer key and
/// consumer secret, as well as token and token secret.
explicit OAuth10Credentials(const HTTPRequest& request);
/// Creates an OAuth10Credentials object from a HTTPRequest object.
///
/// Extracts consumer key and token (if available) from the Authorization header.
///
/// Throws a NotAuthenticatedException if the request does
/// not contain OAuth 1.0 credentials.
~OAuth10Credentials();
/// Destroys the OAuth10Credentials.
void setConsumerKey(const std::string& consumerKey);
/// Sets the consumer key.
const std::string& getConsumerKey() const;
/// Returns the consumer key.
void setConsumerSecret(const std::string& consumerSecret);
/// Sets the consumer secret.
const std::string& getConsumerSecret() const;
/// Returns the consumer secret.
void setToken(const std::string& token);
/// Sets the token.
const std::string& getToken() const;
/// Returns the token.
void setTokenSecret(const std::string& tokenSecret);
/// Sets the token.
const std::string& getTokenSecret() const;
/// Returns the token secret.
void setRealm(const std::string& realm);
/// Sets the optional realm to be included in the Authorization header.
const std::string& getRealm() const;
/// Returns the optional realm to be included in the Authorization header.
void setCallback(const std::string& uri);
/// Sets the callback URI.
const std::string& getCallback() const;
/// Returns the callback URI.
void authenticate(HTTPRequest& request, const Poco::URI& uri, SignatureMethod method = SIGN_HMAC_SHA1);
/// Adds an OAuth 1.0A Authentication header to the given request, using
/// the given signature method.
void authenticate(HTTPRequest& request, const Poco::URI& uri, const Poco::Net::HTMLForm& params, SignatureMethod method = SIGN_HMAC_SHA1);
/// Adds an OAuth 1.0A Authentication header to the given request, using
/// the given signature method.
bool verify(const HTTPRequest& request, const Poco::URI& uri);
/// Verifies the signature of the given request.
///
/// The consumer key, consumer secret, token and token secret must have been set.
///
/// Returns true if the signature is valid, otherwise false.
///
/// Throws a NotAuthenticatedException if the request does not contain OAuth
/// credentials, or in case of an unsupported OAuth version or signature method.
bool verify(const HTTPRequest& request, const Poco::URI& uri, const Poco::Net::HTMLForm& params);
/// Verifies the signature of the given request.
///
/// The consumer key, consumer secret, token and token secret must have been set.
///
/// Returns true if the signature is valid, otherwise false.
///
/// Throws a NotAuthenticatedException if the request does not contain OAuth
/// credentials, or in case of an unsupported OAuth version or signature method.
void nonceAndTimestampForTesting(const std::string& nonce, const std::string& timestamp);
/// Sets the nonce and timestamp to a wellknown value.
///
/// For use by testsuite only, to test the signature
/// algorithm with wellknown inputs.
///
/// In normal operation, the nonce is a random value
/// computed by createNonce() and the timestamp is taken
/// from the system time.
static const std::string SCHEME;
protected:
void signPlaintext(Poco::Net::HTTPRequest& request) const;
/// Signs the given HTTP request according to OAuth 1.0A PLAINTEXT signature method.
void signHMACSHA1(Poco::Net::HTTPRequest& request, const std::string& uri, const Poco::Net::HTMLForm& params) const;
/// Signs the given HTTP request according to OAuth 1.0A HMAC-SHA1 signature method.
std::string createNonce() const;
/// Creates a nonce, which is basically a Base64-encoded 32 character random
/// string, with non-alphanumeric characters removed.
std::string createSignature(const Poco::Net::HTTPRequest& request, const std::string& uri, const Poco::Net::HTMLForm& params, const std::string& nonce, const std::string& timestamp) const;
/// Creates a OAuth signature for the given request and its parameters, according
/// to <https://dev.twitter.com/docs/auth/creating-signature>.
static std::string percentEncode(const std::string& str);
/// Percent-encodes the given string according to Twitter API's rules,
/// given in <https://dev.twitter.com/docs/auth/percent-encoding-parameters>.
private:
OAuth10Credentials(const OAuth10Credentials&);
OAuth10Credentials& operator = (const OAuth10Credentials&);
std::string _consumerKey;
std::string _consumerSecret;
std::string _token;
std::string _tokenSecret;
std::string _callback;
std::string _realm;
std::string _nonce;
std::string _timestamp;
};
//
// inlines
//
inline const std::string& OAuth10Credentials::getConsumerKey() const
{
return _consumerKey;
}
inline const std::string& OAuth10Credentials::getConsumerSecret() const
{
return _consumerSecret;
}
inline const std::string& OAuth10Credentials::getToken() const
{
return _token;
}
inline const std::string& OAuth10Credentials::getTokenSecret() const
{
return _tokenSecret;
}
inline const std::string& OAuth10Credentials::getRealm() const
{
return _realm;
}
inline const std::string& OAuth10Credentials::getCallback() const
{
return _callback;
}
} } // namespace Poco::Net
#endif // Net_OAuth10Credentials_INCLUDED

132
vendor/POCO/Net/include/Poco/Net/OAuth20Credentials.h vendored Normal file
View File

@ -0,0 +1,132 @@
//
// OAuth20Credentials.h
//
// Library: Net
// Package: OAuth
// Module: OAuth20Credentials
//
// Definition of the OAuth20Credentials class.
//
// Copyright (c) 2014, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_OAuth20Credentials_INCLUDED
#define Net_OAuth20Credentials_INCLUDED
#include "Poco/Net/Net.h"
namespace Poco {
namespace Net {
class HTTPRequest;
class Net_API OAuth20Credentials
/// This class implements OAuth 2.0 authentication for HTTP requests,
/// via Bearer tokens in the Authorization header,
/// according to RFC 6749 and RFC 6750.
///
/// To add an Authorization header containing a bearer token
/// to a HTTPRequest object, create an OAuth20Credentials object
/// with the bearer token and call authenticate().
///
/// The bearer token can also be extracted from a HTTPRequest
/// by creating the OAuth20Credentials object with a HTTPRequest
/// object containing a "Bearer" Authorization header and
/// calling getBearerToken().
///
/// The authorization header scheme can be changed from
/// "Bearer" to a custom value. For example, GitHub uses
/// the "token" scheme.
{
public:
OAuth20Credentials();
/// Creates an empty OAuth20Credentials object.
explicit OAuth20Credentials(const std::string& bearerToken);
/// Creates an OAuth20Credentials object with the given bearer token.
OAuth20Credentials(const std::string& bearerToken, const std::string& scheme);
/// Creates an OAuth20Credentials object with the given bearer token
/// and authorization scheme, which overrides the default scheme ("Bearer").
///
/// This is useful for services like GitHub, which use "token" as scheme.
explicit OAuth20Credentials(const HTTPRequest& request);
/// Creates an OAuth20Credentials object from a HTTPRequest object.
///
/// Extracts bearer token from the Authorization header, which
/// must use the "Bearer" authorization scheme.
///
/// Throws a NotAuthenticatedException if the request does
/// not contain a bearer token in the Authorization header.
OAuth20Credentials(const HTTPRequest& request, const std::string& scheme);
/// Creates an OAuth20Credentials object from a HTTPRequest object.
///
/// Extracts bearer token from the Authorization header, which must
/// use the given authorization scheme.
///
/// Throws a NotAuthenticatedException if the request does
/// not contain a bearer token in the Authorization header.
~OAuth20Credentials();
/// Destroys the HTTPCredentials.
void setBearerToken(const std::string& bearerToken);
/// Sets the bearer token.
const std::string& getBearerToken() const;
/// Returns the bearer token.
void setScheme(const std::string& scheme);
/// Sets the Authorization header scheme.
const std::string& getScheme() const;
/// Returns the Authorization header scheme.
void authenticate(HTTPRequest& request);
/// Adds an Authorization header containing the bearer token to
/// the HTTPRequest.
static const std::string SCHEME;
protected:
void extractBearerToken(const HTTPRequest& request);
/// Extracts the bearer token from the HTTPRequest.
private:
OAuth20Credentials(const OAuth20Credentials&);
OAuth20Credentials& operator = (const OAuth20Credentials&);
std::string _bearerToken;
std::string _scheme;
};
//
// inlines
//
inline const std::string& OAuth20Credentials::getBearerToken() const
{
return _bearerToken;
}
inline const std::string& OAuth20Credentials::getScheme() const
{
return _scheme;
}
} } // namespace Poco::Net
#endif // Net_OAuth20Credentials_INCLUDED

185
vendor/POCO/Net/include/Poco/Net/POP3ClientSession.h vendored Normal file
View File

@ -0,0 +1,185 @@
//
// POP3ClientSession.h
//
// Library: Net
// Package: Mail
// Module: POP3ClientSession
//
// Definition of the POP3ClientSession class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_POP3ClientSession_INCLUDED
#define Net_POP3ClientSession_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/DialogSocket.h"
#include "Poco/Timespan.h"
#include <ostream>
#include <vector>
namespace Poco {
namespace Net {
class MessageHeader;
class MailMessage;
class PartHandler;
class Net_API POP3ClientSession
/// This class implements an Post Office Protocol
/// Version 3 (POP3, RFC 1939)
/// client for receiving e-mail messages.
{
public:
enum
{
POP3_PORT = 110
};
struct MessageInfo
/// Information returned by listMessages().
{
int id;
int size;
};
using MessageInfoVec = std::vector<MessageInfo>;
explicit POP3ClientSession(const StreamSocket& socket);
/// Creates the POP3ClientSession using
/// the given socket, which must be connected
/// to a POP3 server.
POP3ClientSession(const std::string& host, Poco::UInt16 port = POP3_PORT);
/// Creates the POP3ClientSession using a socket connected
/// to the given host and port.
virtual ~POP3ClientSession();
/// Destroys the SMTPClientSession.
void setTimeout(const Poco::Timespan& timeout);
/// Sets the timeout for socket read operations.
Poco::Timespan getTimeout() const;
/// Returns the timeout for socket read operations.
void login(const std::string& username, const std::string& password);
/// Logs in to the POP3 server by sending a USER command
/// followed by a PASS command.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
void close();
/// Sends a QUIT command and closes the connection to the server.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
int messageCount();
/// Sends a STAT command to determine the number of messages
/// available on the server and returns that number.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
void listMessages(MessageInfoVec& messages);
/// Fills the given vector with the ids and sizes of all
/// messages available on the server.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
void retrieveMessage(int id, MailMessage& message);
/// Retrieves the message with the given id from the server and
/// stores the raw message content in the message's
/// content string, available with message.getContent().
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
void retrieveMessage(int id, MailMessage& message, PartHandler& handler);
/// Retrieves the message with the given id from the server and
/// stores it in message.
///
/// If the message has multiple parts, the parts
/// are reported to the PartHandler. If the message
/// is not a multi-part message, the content is stored
/// in a string available by calling message.getContent().
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
void retrieveMessage(int id, std::ostream& ostr);
/// Retrieves the raw message with the given id from the
/// server and copies it to the given output stream.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
void retrieveHeader(int id, MessageHeader& header);
/// Retrieves the message header of the message with the
/// given id and stores it in header.
///
/// For this to work, the server must support the TOP command.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
void deleteMessage(int id);
/// Marks the message with the given ID for deletion. The message
/// will be deleted when the connection to the server is
/// closed by calling close().
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
bool sendCommand(const std::string& command, std::string& response);
/// Sends the given command verbatim to the server
/// and waits for a response.
///
/// Returns true if the response is positive, false otherwise.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
bool sendCommand(const std::string& command, const std::string& arg, std::string& response);
/// Sends the given command verbatim to the server
/// and waits for a response.
///
/// Returns true if the response is positive, false otherwise.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
bool sendCommand(const std::string& command, const std::string& arg1, const std::string& arg2, std::string& response);
/// Sends the given command verbatim to the server
/// and waits for a response.
///
/// Returns true if the response is positive, false otherwise.
///
/// Throws a POP3Exception in case of a POP3-specific error, or a
/// NetException in case of a general network communication failure.
protected:
static bool isPositive(const std::string& response);
private:
DialogSocket _socket;
bool _isOpen;
};
} } // namespace Poco::Net
#endif // Net_POP3ClientSession_INCLUDED

242
vendor/POCO/Net/include/Poco/Net/ParallelSocketAcceptor.h vendored Normal file
View File

@ -0,0 +1,242 @@
//
// ParallelSocketAcceptor.h
//
// Library: Net
// Package: Reactor
// Module: ParallelSocketAcceptor
//
// Definition of the ParallelSocketAcceptor class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ParallelSocketAcceptor_INCLUDED
#define Net_ParallelSocketAcceptor_INCLUDED
#include "Poco/Net/ParallelSocketReactor.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/Environment.h"
#include "Poco/NObserver.h"
#include "Poco/SharedPtr.h"
#include <vector>
using Poco::Net::Socket;
using Poco::Net::SocketReactor;
using Poco::Net::ServerSocket;
using Poco::Net::StreamSocket;
using Poco::NObserver;
using Poco::AutoPtr;
namespace Poco {
namespace Net {
template <class ServiceHandler, class SR>
class ParallelSocketAcceptor
/// This class implements the Acceptor part of the Acceptor-Connector design pattern.
/// Only the difference from single-threaded version is documented here, For full
/// description see Poco::Net::SocketAcceptor documentation.
///
/// This is a multi-threaded version of SocketAcceptor, it differs from the
/// single-threaded version in number of reactors (defaulting to number of processors)
/// that can be specified at construction time and is rotated in a round-robin fashion
/// by event handler. See ParallelSocketAcceptor::onAccept and
/// ParallelSocketAcceptor::createServiceHandler documentation and implementation for
/// details.
{
public:
using ParallelReactor = Poco::Net::ParallelSocketReactor<SR>;
using Observer = Poco::Observer<ParallelSocketAcceptor, ReadableNotification>;
explicit ParallelSocketAcceptor(ServerSocket& socket,
unsigned threads = Poco::Environment::processorCount()):
_socket(socket),
_pReactor(0),
_threads(threads),
_next(0)
/// Creates a ParallelSocketAcceptor using the given ServerSocket,
/// sets number of threads and populates the reactors vector.
{
init();
}
ParallelSocketAcceptor(ServerSocket& socket,
SocketReactor& reactor,
unsigned threads = Poco::Environment::processorCount()):
_socket(socket),
_pReactor(&reactor),
_threads(threads),
_next(0)
/// Creates a ParallelSocketAcceptor using the given ServerSocket, sets the
/// number of threads, populates the reactors vector and registers itself
/// with the given SocketReactor.
{
init();
_pReactor->addEventHandler(_socket, Observer(*this, &ParallelSocketAcceptor::onAccept));
}
virtual ~ParallelSocketAcceptor()
/// Destroys the ParallelSocketAcceptor.
{
try
{
if (_pReactor)
{
_pReactor->removeEventHandler(_socket, Observer(*this, &ParallelSocketAcceptor::onAccept));
}
}
catch (...)
{
poco_unexpected();
}
}
void setReactor(SocketReactor& reactor)
/// Sets the reactor for this acceptor.
{
registerAcceptor(reactor);
}
virtual void registerAcceptor(SocketReactor& reactor)
/// Registers the ParallelSocketAcceptor with a SocketReactor.
///
/// A subclass can override this function to e.g.
/// register an event handler for timeout event.
///
/// The overriding method must either call the base class
/// implementation or register the accept handler on its own.
{
_pReactor = &reactor;
if (!_pReactor->hasEventHandler(_socket, Observer(*this, &ParallelSocketAcceptor::onAccept)))
{
_pReactor->addEventHandler(_socket, Observer(*this, &ParallelSocketAcceptor::onAccept));
}
}
virtual void unregisterAcceptor()
/// Unregisters the ParallelSocketAcceptor.
///
/// A subclass can override this function to e.g.
/// unregister its event handler for a timeout event.
///
/// The overriding method must either call the base class
/// implementation or unregister the accept handler on its own.
{
if (_pReactor)
{
_pReactor->removeEventHandler(_socket, Observer(*this, &ParallelSocketAcceptor::onAccept));
}
}
void onAccept(ReadableNotification* pNotification)
/// Accepts connection and creates event handler.
{
pNotification->release();
StreamSocket sock = _socket.acceptConnection();
_pReactor->wakeUp();
createServiceHandler(sock);
}
protected:
typedef std::vector<typename ParallelReactor::Ptr> ReactorVec;
virtual ServiceHandler* createServiceHandler(StreamSocket& socket)
/// Create and initialize a new ServiceHandler instance.
/// If socket is already registered with a reactor, the new
/// ServiceHandler instance is given that reactor; otherwise,
/// the next reactor is used. Reactors are rotated in round-robin
/// fashion.
///
/// Subclasses can override this method.
{
SocketReactor* pReactor = reactor(socket);
if (!pReactor)
{
std::size_t next = _next++;
if (_next == _reactors.size()) _next = 0;
pReactor = _reactors[next];
}
pReactor->wakeUp();
return new ServiceHandler(socket, *pReactor);
}
SocketReactor* reactor(const Socket& socket)
/// Returns reactor where this socket is already registered
/// for polling, if found; otherwise returns null pointer.
{
typename ReactorVec::iterator it = _reactors.begin();
typename ReactorVec::iterator end = _reactors.end();
for (; it != end; ++it)
{
if ((*it)->has(socket)) return it->get();
}
return 0;
}
SocketReactor* reactor()
/// Returns a pointer to the SocketReactor where
/// this SocketAcceptor is registered.
///
/// The pointer may be null.
{
return _pReactor;
}
Socket& socket()
/// Returns a reference to the SocketAcceptor's socket.
{
return _socket;
}
void init()
/// Populates the reactors vector.
{
poco_assert (_threads > 0);
for (unsigned i = 0; i < _threads; ++i)
_reactors.push_back(new ParallelReactor);
}
ReactorVec& reactors()
/// Returns reference to vector of reactors.
{
return _reactors;
}
SocketReactor* reactor(std::size_t idx)
/// Returns reference to the reactor at position idx.
{
return _reactors.at(idx).get();
}
std::size_t next()
/// Returns the next reactor index.
{
return _next;
}
private:
ParallelSocketAcceptor();
ParallelSocketAcceptor(const ParallelSocketAcceptor&);
ParallelSocketAcceptor& operator = (const ParallelSocketAcceptor&);
ServerSocket _socket;
SocketReactor* _pReactor;
unsigned _threads;
ReactorVec _reactors;
std::size_t _next;
};
} } // namespace Poco::Net
#endif // Net_ParallelSocketAcceptor_INCLUDED

90
vendor/POCO/Net/include/Poco/Net/ParallelSocketReactor.h vendored Normal file
View File

@ -0,0 +1,90 @@
//
// ParallelSocketReactor.h
//
// Library: Net
// Package: Reactor
// Module: ParallelSocketReactor
//
// Definition of the ParallelSocketReactor class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ParallelSocketReactor_INCLUDED
#define Net_ParallelSocketReactor_INCLUDED
#include "Poco/Net/SocketReactor.h"
#include "Poco/Net/SocketNotification.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/NObserver.h"
#include "Poco/Thread.h"
#include "Poco/SharedPtr.h"
using Poco::Net::Socket;
using Poco::Net::SocketReactor;
using Poco::Net::ReadableNotification;
using Poco::Net::ShutdownNotification;
using Poco::Net::ServerSocket;
using Poco::Net::StreamSocket;
using Poco::NObserver;
using Poco::AutoPtr;
using Poco::Thread;
namespace Poco {
namespace Net {
template <class SR>
class ParallelSocketReactor: public SR
{
public:
using Ptr = Poco::SharedPtr<ParallelSocketReactor>;
ParallelSocketReactor()
{
_thread.start(*this);
}
ParallelSocketReactor(const Poco::Timespan& timeout):
SR(timeout)
{
_thread.start(*this);
}
~ParallelSocketReactor()
{
try
{
this->stop();
_thread.join();
}
catch (...)
{
poco_unexpected();
}
}
protected:
void onIdle()
{
SR::onIdle();
Poco::Thread::yield();
}
private:
Poco::Thread _thread;
};
} } // namespace Poco::Net
#endif // Net_ParallelSocketReactor_INCLUDED

68
vendor/POCO/Net/include/Poco/Net/PartHandler.h vendored Normal file
View File

@ -0,0 +1,68 @@
//
// PartHandler.h
//
// Library: Net
// Package: Messages
// Module: PartHandler
//
// Definition of the PartHandler class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_PartHandler_INCLUDED
#define Net_PartHandler_INCLUDED
#include "Poco/Net/Net.h"
#include <istream>
namespace Poco {
namespace Net {
class MessageHeader;
class Net_API PartHandler
/// The base class for all part or attachment handlers.
///
/// Part handlers are used for handling email parts and
/// attachments in MIME multipart messages, as well as file
/// uploads via HTML forms.
///
/// Subclasses must override handlePart().
{
public:
virtual void handlePart(const MessageHeader& header, std::istream& stream) = 0;
/// Called for every part encountered during the processing
/// of an email message or an uploaded HTML form.
///
/// Information about the part can be extracted from
/// the given message header. What information can be obtained
/// from header depends on the kind of part.
///
/// The content of the part can be read from stream.
protected:
PartHandler();
/// Creates the PartHandler.
virtual ~PartHandler();
/// Destroys the PartHandler.
private:
PartHandler(const PartHandler&);
PartHandler& operator = (const PartHandler&);
};
} } // namespace Poco::Net
#endif // Net_PartHandler_INCLUDED

110
vendor/POCO/Net/include/Poco/Net/PartSource.h vendored Normal file
View File

@ -0,0 +1,110 @@
//
// PartSource.h
//
// Library: Net
// Package: Messages
// Module: PartSource
//
// Definition of the PartSource class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_PartSource_INCLUDED
#define Net_PartSource_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/MessageHeader.h"
#include <istream>
namespace Poco {
namespace Net {
class Net_API PartSource
/// This abstract class is used for adding parts or attachments
/// to mail messages, as well as for uploading files as part of a HTML form.
{
public:
virtual std::istream& stream() = 0;
/// Returns an input stream for reading the
/// part data.
///
/// Subclasses must override this method.
virtual const std::string& filename() const;
/// Returns the filename for the part or attachment.
///
/// May be overridden by subclasses. The default
/// implementation returns an empty string.
const std::string& mediaType() const;
/// Returns the MIME media type for this part or attachment.
MessageHeader& headers();
/// Returns a MessageHeader containing additional header
/// fields for the part.
const MessageHeader& headers() const;
/// Returns a MessageHeader containing additional header
/// fields for the part.
virtual std::streamsize getContentLength() const;
/// Returns the content length for this part
/// which may be UNKNOWN_CONTENT_LENGTH if
/// not available.
virtual ~PartSource();
/// Destroys the PartSource.
static const int UNKNOWN_CONTENT_LENGTH;
protected:
PartSource();
/// Creates the PartSource, using
/// the application/octet-stream MIME type.
PartSource(const std::string& mediaType);
/// Creates the PartSource, using the
/// given MIME type.
private:
PartSource(const PartSource&);
PartSource& operator = (const PartSource&);
std::string _mediaType;
MessageHeader _headers;
};
//
// inlines
//
inline const std::string& PartSource::mediaType() const
{
return _mediaType;
}
inline MessageHeader& PartSource::headers()
{
return _headers;
}
inline const MessageHeader& PartSource::headers() const
{
return _headers;
}
} } // namespace Poco::Net
#endif // Net_PartSource_INCLUDED

106
vendor/POCO/Net/include/Poco/Net/PartStore.h vendored Normal file
View File

@ -0,0 +1,106 @@
//
// PartStore.h
//
// Library: Net
// Package: Messages
// Module: PartStore
//
// Definition of the PartStore class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_PartStore_INCLUDED
#define Net_PartStore_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/PartSource.h"
#include "Poco/FileStream.h"
namespace Poco {
namespace Net {
class Net_API PartStore: public PartSource
/// A parent class for part stores storing message parts.
{
public:
PartStore(const std::string& mediaType);
/// Creates the PartStore for the given MIME type.
~PartStore();
/// Destroys the PartFileStore.
private:
PartStore();
};
class Net_API FilePartStore: public PartStore
/// An implementation of PartSource for persisting
/// parts (usually email attachment files) to the file system.
{
public:
FilePartStore(const std::string& content, const std::string& mediaType, const std::string& filename = "");
/// Creates the FilePartStore for the given MIME type.
/// For security purposes, attachment filename is NOT used to save file to the file system.
/// A unique temporary file name is used to persist the file.
/// The given filename parameter is the message part (attachment) filename (see filename()) only.
///
/// Throws an exception if the file cannot be opened.
~FilePartStore();
/// Destroys the FilePartStore.
std::istream& stream();
/// Returns a file input stream for the given file.
const std::string& filename() const;
/// Returns the filename portion of the path.
/// This is the name under which the file is known
/// to the user of this class (typically, MailMessage
/// class). The real name of the file as saved
/// to the filesystem can be obtained by calling
/// path() member function.
const std::string& path() const;
/// Returns the full path to the file as saved
/// to the file system. For security reasons,
/// file is not saved under the real file name
/// (as specified by the user).
private:
std::string _filename;
std::string _path;
Poco::FileStream _fstr;
};
class PartStoreFactory
/// Parent factory class for part stores creation.
{
public:
virtual PartSource* createPartStore(const std::string& content, const std::string& mediaType, const std::string& filename = "") = 0;
};
class FilePartStoreFactory: public PartStoreFactory
{
public:
PartSource* createPartStore(const std::string& content, const std::string& mediaType, const std::string& filename = "")
{
return new FilePartStore(content, mediaType, filename);
}
};
} } // namespace Poco::Net
#endif // Net_PartStore_INCLUDED

92
vendor/POCO/Net/include/Poco/Net/PollSet.h vendored Normal file
View File

@ -0,0 +1,92 @@
//
// PollSet.h
//
// Library: Net
// Package: Sockets
// Module: PollSet
//
// Definition of the PollSet class.
//
// Copyright (c) 2016, Applied Informatics Software Engineering GmbH.
// All rights reserved.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_PollSet_INCLUDED
#define Net_PollSet_INCLUDED
#include "Poco/Net/Socket.h"
#include <map>
namespace Poco {
namespace Net {
class PollSetImpl;
class Net_API PollSet
/// A set of sockets that can be efficiently polled as a whole.
///
/// If supported, PollSet is implemented using epoll (Linux) or
/// poll (BSD) APIs. A fallback implementation using select()
/// is also provided.
{
public:
enum Mode
{
POLL_READ = 0x01,
POLL_WRITE = 0x02,
POLL_ERROR = 0x04
};
using SocketModeMap = std::map<Poco::Net::Socket, int>;
PollSet();
/// Creates an empty PollSet.
~PollSet();
/// Destroys the PollSet.
void add(const Poco::Net::Socket& socket, int mode);
/// Adds the given socket to the set, for polling with
/// the given mode, which can be an OR'd combination of
/// POLL_READ, POLL_WRITE and POLL_ERROR.
void remove(const Poco::Net::Socket& socket);
/// Removes the given socket from the set.
void update(const Poco::Net::Socket& socket, int mode);
/// Updates the mode of the given socket.
bool has(const Socket& socket) const;
/// Returns true if socket is registered for polling.
bool empty() const;
/// Returns true if no socket is registered for polling.
void clear();
/// Removes all sockets from the PollSet.
SocketModeMap poll(const Poco::Timespan& timeout);
/// Waits until the state of at least one of the PollSet's sockets
/// changes accordingly to its mode, or the timeout expires.
/// Returns a PollMap containing the sockets that have had
/// their state changed.
private:
PollSetImpl* _pImpl;
PollSet(const PollSet&);
PollSet& operator = (const PollSet&);
};
} } // namespace Poco::Net
#endif // Net_PollSet_INCLUDED

86
vendor/POCO/Net/include/Poco/Net/QuotedPrintableDecoder.h vendored Normal file
View File

@ -0,0 +1,86 @@
//
// QuotedPrintableDecoder.h
//
// Library: Net
// Package: Messages
// Module: QuotedPrintableDecoder
//
// Definition of the QuotedPrintableDecoder class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_QuotedPrintableDecoder_INCLUDED
#define Net_QuotedPrintableDecoder_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/UnbufferedStreamBuf.h"
#include <istream>
namespace Poco {
namespace Net {
class Net_API QuotedPrintableDecoderBuf: public Poco::UnbufferedStreamBuf
/// This streambuf decodes all quoted-printable (see RFC 2045)
/// encoded data read from the istream connected to it.
///
/// Note: For performance reasons, the characters
/// are read directly from the given istream's
/// underlying streambuf, so the state
/// of the istream will not reflect that of
/// its streambuf.
{
public:
QuotedPrintableDecoderBuf(std::istream& istr);
~QuotedPrintableDecoderBuf();
private:
int readFromDevice();
std::streambuf& _buf;
};
class Net_API QuotedPrintableDecoderIOS: public virtual std::ios
/// The base class for QuotedPrintableDecoder.
///
/// This class is needed to ensure the correct initialization
/// order of the stream buffer and base classes.
{
public:
QuotedPrintableDecoderIOS(std::istream& istr);
~QuotedPrintableDecoderIOS();
QuotedPrintableDecoderBuf* rdbuf();
protected:
QuotedPrintableDecoderBuf _buf;
};
class Net_API QuotedPrintableDecoder: public QuotedPrintableDecoderIOS, public std::istream
/// This istream decodes all quoted-printable (see RFC 2045)
/// encoded data read from the istream connected to it.
///
/// Note: For performance reasons, the characters
/// are read directly from the given istream's
/// underlying streambuf, so the state
/// of the istream will not reflect that of
/// its streambuf.
{
public:
QuotedPrintableDecoder(std::istream& istr);
~QuotedPrintableDecoder();
};
} } // namespace Poco::Net
#endif // Net_QuotedPrintableDecoder_INCLUDED

85
vendor/POCO/Net/include/Poco/Net/QuotedPrintableEncoder.h vendored Normal file
View File

@ -0,0 +1,85 @@
//
// QuotedPrintableEncoder.h
//
// Library: Net
// Package: Messages
// Module: QuotedPrintableEncoder
//
// Definition of the QuotedPrintableEncoder class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_QuotedPrintableEncoder_INCLUDED
#define Net_QuotedPrintableEncoder_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/UnbufferedStreamBuf.h"
#include <ostream>
namespace Poco {
namespace Net {
class Net_API QuotedPrintableEncoderBuf: public Poco::UnbufferedStreamBuf
/// This streambuf encodes all data written
/// to it in quoted-printable encoding (see RFC 2045)
/// and forwards it to a connected ostream.
{
public:
QuotedPrintableEncoderBuf(std::ostream& ostr);
~QuotedPrintableEncoderBuf();
int close();
private:
int writeToDevice(char c);
void writeEncoded(char c);
void writeRaw(char c);
int _pending;
int _lineLength;
std::ostream& _ostr;
};
class Net_API QuotedPrintableEncoderIOS: public virtual std::ios
/// The base class for QuotedPrintableEncoder.
///
/// This class is needed to ensure the correct initialization
/// order of the stream buffer and base classes.
{
public:
QuotedPrintableEncoderIOS(std::ostream& ostr);
~QuotedPrintableEncoderIOS();
int close();
QuotedPrintableEncoderBuf* rdbuf();
protected:
QuotedPrintableEncoderBuf _buf;
};
class Net_API QuotedPrintableEncoder: public QuotedPrintableEncoderIOS, public std::ostream
/// This ostream encodes all data
/// written to it in quoted-printable encoding
/// (see RFC 2045) and forwards it to a connected ostream.
/// Always call close() when done
/// writing data, to ensure proper
/// completion of the encoding operation.
{
public:
QuotedPrintableEncoder(std::ostream& ostr);
~QuotedPrintableEncoder();
};
} } // namespace Poco::Net
#endif // Net_QuotedPrintableEncoder_INCLUDED

161
vendor/POCO/Net/include/Poco/Net/RawSocket.h vendored Normal file
View File

@ -0,0 +1,161 @@
//
// RawSocket.h
//
// Library: Net
// Package: Sockets
// Module: RawSocket
//
// Definition of the RawSocket class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_RawSocket_INCLUDED
#define Net_RawSocket_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/Socket.h"
namespace Poco {
namespace Net {
class Net_API RawSocket: public Socket
/// This class provides an interface to a
/// raw IP socket.
{
public:
RawSocket();
/// Creates an unconnected IPv4 raw socket.
RawSocket(SocketAddress::Family family, int proto = IPPROTO_RAW);
/// Creates an unconnected raw socket.
///
/// The socket will be created for the
/// given address family.
RawSocket(const SocketAddress& address, bool reuseAddress = false);
/// Creates a raw socket and binds it
/// to the given address.
///
/// Depending on the address family, the socket
/// will be either an IPv4 or an IPv6 socket.
RawSocket(const Socket& socket);
/// Creates the RawSocket with the SocketImpl
/// from another socket. The SocketImpl must be
/// a RawSocketImpl, otherwise an InvalidArgumentException
/// will be thrown.
~RawSocket();
/// Destroys the RawSocket.
RawSocket& operator = (const Socket& socket);
/// Assignment operator.
///
/// Releases the socket's SocketImpl and
/// attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
void connect(const SocketAddress& address);
/// Restricts incoming and outgoing
/// packets to the specified address.
///
/// Calls to connect() cannot come before calls to bind().
void bind(const SocketAddress& address, bool reuseAddress = false);
/// Bind a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// Calls to connect() cannot come before calls to bind().
void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
/// Bind a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reusePort is true, sets the SO_REUSEPORT
/// socket option.
///
/// Calls to connect() cannot come before calls to bind().
int sendBytes(const void* buffer, int length, int flags = 0);
/// Sends the contents of the given buffer through
/// the socket.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
int receiveBytes(void* buffer, int length, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
///
/// Returns the number of bytes received.
int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
/// Sends the contents of the given buffer through
/// the socket to the given address.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
/// Stores the address of the sender in address.
///
/// Returns the number of bytes received.
void setBroadcast(bool flag);
/// Sets the value of the SO_BROADCAST socket option.
///
/// Setting this flag allows sending datagrams to
/// the broadcast address.
bool getBroadcast() const;
/// Returns the value of the SO_BROADCAST socket option.
protected:
RawSocket(SocketImpl* pImpl);
/// Creates the Socket and attaches the given SocketImpl.
/// The socket takes ownership of the SocketImpl.
///
/// The SocketImpl must be a StreamSocketImpl, otherwise
/// an InvalidArgumentException will be thrown.
};
//
// inlines
//
inline void RawSocket::setBroadcast(bool flag)
{
impl()->setBroadcast(flag);
}
inline bool RawSocket::getBroadcast() const
{
return impl()->getBroadcast();
}
} } // namespace Poco::Net
#endif // Net_RawSocket_INCLUDED

56
vendor/POCO/Net/include/Poco/Net/RawSocketImpl.h vendored Normal file
View File

@ -0,0 +1,56 @@
//
// RawSocketImpl.h
//
// Library: Net
// Package: Sockets
// Module: RawSocketImpl
//
// Definition of the RawSocketImpl class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_RawSocketImpl_INCLUDED
#define Net_RawSocketImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketImpl.h"
namespace Poco {
namespace Net {
class Net_API RawSocketImpl: public SocketImpl
/// This class implements a raw socket.
{
public:
RawSocketImpl();
/// Creates an unconnected IPv4 raw socket with IPPROTO_RAW.
RawSocketImpl(SocketAddress::Family family, int proto = IPPROTO_RAW);
/// Creates an unconnected raw socket.
///
/// The socket will be created for the
/// given address family.
RawSocketImpl(poco_socket_t sockfd);
/// Creates a RawSocketImpl using the given native socket.
protected:
void init(int af);
void init2(int af, int proto);
~RawSocketImpl();
};
} } // namespace Poco::Net
#endif // Net_RawSocketImpl_INCLUDED

161
vendor/POCO/Net/include/Poco/Net/RemoteSyslogChannel.h vendored Normal file
View File

@ -0,0 +1,161 @@
//
// RemoteSyslogChannel.h
//
// Library: Net
// Package: Logging
// Module: RemoteSyslogChannel
//
// Definition of the RemoteSyslogChannel class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_RemoteSyslogChannel_INCLUDED
#define Net_RemoteSyslogChannel_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Channel.h"
#include "Poco/Mutex.h"
#include "Poco/Net/DatagramSocket.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/AutoPtr.h"
namespace Poco {
namespace Net {
class Net_API RemoteSyslogChannel: public Poco::Channel
/// This Channel implements remote syslog logging over UDP according
/// to RFC 5424 "The Syslog Protocol"
/// and RFC 5426 "Transmission of syslog messages over UDP".
///
/// In addition, RemoteSyslogListener also supports the "old" BSD syslog
/// protocol, as described in RFC 3164.
///
/// RFC 5425 structured data can be passed via the "structured-data"
/// property of the log Message. The content of the "structured-data"
/// property must be correct according to RFC 5425.
///
/// Example:
/// msg.set("structured-data", "[exampleSDID@32473 iut=\"3\" eventSource=\"Application\" eventID=\"1011\"]");
{
public:
using Ptr = Poco::AutoPtr<RemoteSyslogChannel>;
static const std::string BSD_TIMEFORMAT;
static const std::string SYSLOG_TIMEFORMAT;
enum Severity
{
SYSLOG_EMERGENCY = 0, /// Emergency: system is unusable
SYSLOG_ALERT = 1, /// Alert: action must be taken immediately
SYSLOG_CRITICAL = 2, /// Critical: critical conditions
SYSLOG_ERROR = 3, /// Error: error conditions
SYSLOG_WARNING = 4, /// Warning: warning conditions
SYSLOG_NOTICE = 5, /// Notice: normal but significant condition
SYSLOG_INFORMATIONAL = 6, /// Informational: informational messages
SYSLOG_DEBUG = 7 /// Debug: debug-level messages
};
enum Facility
{
SYSLOG_KERN = ( 0<<3), /// kernel messages
SYSLOG_USER = ( 1<<3), /// random user-level messages
SYSLOG_MAIL = ( 2<<3), /// mail system
SYSLOG_DAEMON = ( 3<<3), /// system daemons
SYSLOG_AUTH = ( 4<<3), /// security/authorization messages
SYSLOG_SYSLOG = ( 5<<3), /// messages generated internally by syslogd
SYSLOG_LPR = ( 6<<3), /// line printer subsystem
SYSLOG_NEWS = ( 7<<3), /// network news subsystem
SYSLOG_UUCP = ( 8<<3), /// UUCP subsystem
SYSLOG_CRON = ( 9<<3), /// clock daemon
SYSLOG_AUTHPRIV = (10<<3), /// security/authorization messages (private)
SYSLOG_FTP = (11<<3), /// ftp daemon
SYSLOG_NTP = (12<<3), /// ntp subsystem
SYSLOG_LOGAUDIT = (13<<3), /// log audit
SYSLOG_LOGALERT = (14<<3), /// log alert
SYSLOG_CLOCK = (15<<3), /// clock daemon
SYSLOG_LOCAL0 = (16<<3), /// reserved for local use
SYSLOG_LOCAL1 = (17<<3), /// reserved for local use
SYSLOG_LOCAL2 = (18<<3), /// reserved for local use
SYSLOG_LOCAL3 = (19<<3), /// reserved for local use
SYSLOG_LOCAL4 = (20<<3), /// reserved for local use
SYSLOG_LOCAL5 = (21<<3), /// reserved for local use
SYSLOG_LOCAL6 = (22<<3), /// reserved for local use
SYSLOG_LOCAL7 = (23<<3) /// reserved for local use
};
enum
{
SYSLOG_PORT = 514
};
RemoteSyslogChannel();
/// Creates a RemoteSyslogChannel.
RemoteSyslogChannel(const std::string& address, const std::string& name, int facility = SYSLOG_USER, bool bsdFormat = false);
/// Creates a RemoteSyslogChannel with the given target address, name, and facility.
/// If bsdFormat is true, messages are formatted according to RFC 3164.
void open();
/// Opens the RemoteSyslogChannel.
void close();
/// Closes the RemoteSyslogChannel.
void log(const Message& msg);
/// Sends the message's text to the syslog service.
void setProperty(const std::string& name, const std::string& value);
/// Sets the property with the given value.
///
/// The following properties are supported:
/// * name: The name used to identify the source of log messages.
/// * facility: The facility added to each log message. See the Facility enumeration for a list of supported values.
/// The LOG_ prefix can be omitted and values are case insensitive (e.g. a facility value "mail" is recognized as SYSLOG_MAIL)
/// * format: "bsd"/"rfc3164" (RFC 3164 format) or "new"/"rfc5424" (default)
/// * loghost: The target IP address or host name where log messages are sent. Optionally, a port number (separated
/// by a colon) can also be specified.
/// * host: (optional) Host name included in syslog messages. If not specified, the host's real domain name or
/// IP address will be used.
std::string getProperty(const std::string& name) const;
/// Returns the value of the property with the given name.
static void registerChannel();
/// Registers the channel with the global LoggingFactory.
static const std::string PROP_NAME;
static const std::string PROP_FACILITY;
static const std::string PROP_FORMAT;
static const std::string PROP_LOGHOST;
static const std::string PROP_HOST;
static const std::string STRUCTURED_DATA;
protected:
~RemoteSyslogChannel();
static int getPrio(const Message& msg);
private:
std::string _logHost;
std::string _name;
std::string _host;
int _facility;
bool _bsdFormat;
DatagramSocket _socket;
SocketAddress _socketAddress;
bool _open;
mutable Poco::FastMutex _mutex;
};
} } // namespace Poco::Net
#endif // Net_RemoteSyslogChannel_INCLUDED

121
vendor/POCO/Net/include/Poco/Net/RemoteSyslogListener.h vendored Normal file
View File

@ -0,0 +1,121 @@
//
// RemoteSyslogListener.h
//
// Library: Net
// Package: Logging
// Module: RemoteSyslogListener
//
// Definition of the RemoteSyslogListener class.
//
// Copyright (c) 2007-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_RemoteSyslogListener_INCLUDED
#define Net_RemoteSyslogListener_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/ThreadPool.h"
#include "Poco/SplitterChannel.h"
#include "Poco/NotificationQueue.h"
namespace Poco {
namespace Net {
class RemoteUDPListener;
class SyslogParser;
class Net_API RemoteSyslogListener: public Poco::SplitterChannel
/// RemoteSyslogListener implements listening for syslog messages
/// sent over UDP, according to RFC 5424 "The Syslog Protocol"
/// and RFC 5426 "Transmission of syslog messages over UDP".
///
/// In addition, RemoteSyslogListener also supports the "old" BSD syslog
/// protocol, as described in RFC 3164.
///
/// The RemoteSyslogListener is a subclass of Poco::SplitterChannel.
/// Every received log message is sent to the channels registered
/// with addChannel() or the "channel" property.
///
/// Poco::Message objects created by RemoteSyslogListener will have
/// the following named parameters:
/// - addr: IP address of the host/interface sending the message.
/// - host: host name; only for "new" syslog messages.
/// - app: application name; only for "new" syslog messages.
/// - structured-data: RFC 5424 structured data, or empty if not present.
{
public:
RemoteSyslogListener();
/// Creates the RemoteSyslogListener.
RemoteSyslogListener(Poco::UInt16 port);
/// Creates the RemoteSyslogListener, listening on the given port number.
RemoteSyslogListener(Poco::UInt16 port, int threads);
/// Creates the RemoteSyslogListener, listening on the given port number
/// and using the number of threads for message processing.
void setProperty(const std::string& name, const std::string& value);
/// Sets the property with the given value.
///
/// The following properties are supported:
/// * port: The UDP port number where to listen for UDP packets
/// containing syslog messages. If 0 is specified, does not
/// listen for UDP messages.
/// * threads: The number of parser threads processing
/// received syslog messages. Defaults to 1. A maximum
/// of 16 threads is supported.
std::string getProperty(const std::string& name) const;
/// Returns the value of the property with the given name.
void open();
/// Starts the listener.
void close();
/// Stops the listener.
void processMessage(const std::string& messageText);
/// Parses a single line of text containing a syslog message
/// and sends it down the filter chain.
void enqueueMessage(const std::string& messageText, const Poco::Net::SocketAddress& senderAddress);
/// Enqueues a single line of text containing a syslog message
/// for asynchronous processing by a parser thread.
static void registerChannel();
/// Registers the channel with the global LoggingFactory.
static const std::string PROP_PORT;
static const std::string PROP_THREADS;
static const std::string LOG_PROP_APP;
static const std::string LOG_PROP_HOST;
static const std::string LOG_PROP_STRUCTURED_DATA;
protected:
~RemoteSyslogListener();
/// Destroys the RemoteSyslogListener.
private:
RemoteUDPListener* _pListener;
SyslogParser* _pParser;
Poco::ThreadPool _threadPool;
Poco::NotificationQueue _queue;
Poco::UInt16 _port;
int _threads;
};
} } // namespace Poco::Net
#endif // Net_RemoteSyslogListener_INCLUDED

111
vendor/POCO/Net/include/Poco/Net/SMTPChannel.h vendored Normal file
View File

@ -0,0 +1,111 @@
//
// SMTPChannel.h
//
// Library: Net
// Package: Logging
// Module: SMTPChannel
//
// Definition of the SMTPChannel class.
//
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SMTPChannel_INCLUDED
#define Net_SMTPChannel_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Channel.h"
#include "Poco/String.h"
#include "Poco/AutoPtr.h"
namespace Poco {
namespace Net {
class Net_API SMTPChannel: public Poco::Channel
/// This Channel implements SMTP (email) logging.
{
public:
using Ptr = Poco::AutoPtr<SMTPChannel>;
SMTPChannel();
/// Creates a SMTPChannel.
SMTPChannel(const std::string& mailhost, const std::string& sender, const std::string& recipient);
/// Creates a SMTPChannel with the given target mailhost, sender, and recipient.
void open();
/// Opens the SMTPChannel.
void close();
/// Closes the SMTPChannel.
void log(const Message& msg);
/// Sends the message's text to the recipient.
void setProperty(const std::string& name, const std::string& value);
/// Sets the property with the given value.
///
/// The following properties are supported:
/// * mailhost: The SMTP server. Default is "localhost".
/// * sender: The sender address.
/// * recipient: The recipient address.
/// * local: If true, local time is used. Default is true.
/// * attachment: Filename of the file to attach.
/// * type: Content type of the file to attach.
/// * delete: Boolean value indicating whether to delete
/// the attachment file after sending.
/// * throw: Boolean value indicating whether to throw
/// exception upon failure.
std::string getProperty(const std::string& name) const;
/// Returns the value of the property with the given name.
static void registerChannel();
/// Registers the channel with the global LoggingFactory.
static const std::string PROP_MAILHOST;
static const std::string PROP_SENDER;
static const std::string PROP_RECIPIENT;
static const std::string PROP_LOCAL;
static const std::string PROP_ATTACHMENT;
static const std::string PROP_TYPE;
static const std::string PROP_DELETE;
static const std::string PROP_THROW;
protected:
~SMTPChannel();
private:
bool isTrue(const std::string& value) const;
std::string _mailHost;
std::string _sender;
std::string _recipient;
bool _local;
std::string _attachment;
std::string _type;
bool _delete;
bool _throw;
};
inline bool SMTPChannel::isTrue(const std::string& value) const
{
return ((0 == icompare(value, "true")) ||
(0 == icompare(value, "t")) ||
(0 == icompare(value, "yes")) ||
(0 == icompare(value, "y")));
}
} } // namespace Poco::Net
#endif // Net_SMTPChannel_INCLUDED

244
vendor/POCO/Net/include/Poco/Net/SMTPClientSession.h vendored Normal file
View File

@ -0,0 +1,244 @@
//
// SMTPClientSession.h
//
// Library: Net
// Package: Mail
// Module: SMTPClientSession
//
// Definition of the SMTPClientSession class.
//
// Copyright (c) 2005-2008, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SMTPClientSession_INCLUDED
#define Net_SMTPClientSession_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/DialogSocket.h"
#include "Poco/DigestEngine.h"
#include "Poco/Timespan.h"
namespace Poco {
namespace Net {
class MailMessage;
class Net_API SMTPClientSession
/// This class implements an Simple Mail
/// Transfer Protocol (SMTP, RFC 2821)
/// client for sending e-mail messages.
{
public:
using Recipients = std::vector<std::string>;
enum
{
SMTP_PORT = 25
};
enum LoginMethod
{
AUTH_NONE,
AUTH_CRAM_MD5,
AUTH_CRAM_SHA1,
AUTH_LOGIN,
AUTH_PLAIN,
AUTH_XOAUTH2,
AUTH_NTLM
};
explicit SMTPClientSession(const StreamSocket& socket);
/// Creates the SMTPClientSession using
/// the given socket, which must be connected
/// to a SMTP server.
SMTPClientSession(const std::string& host, Poco::UInt16 port = SMTP_PORT);
/// Creates the SMTPClientSession using a socket connected
/// to the given host and port.
virtual ~SMTPClientSession();
/// Destroys the SMTPClientSession.
void setTimeout(const Poco::Timespan& timeout);
/// Sets the timeout for socket read operations.
Poco::Timespan getTimeout() const;
/// Returns the timeout for socket read operations.
void login(const std::string& hostname);
/// Greets the SMTP server by sending a EHLO command
/// with the given hostname as argument.
///
/// If the server does not understand the EHLO command,
/// a HELO command is sent instead.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
void login();
/// Calls login(hostname) with the current host name.
void login(const std::string& hostname, LoginMethod loginMethod, const std::string& username, const std::string& password);
/// Logs in to the SMTP server using the given authentication method and the given
/// credentials.
void login(LoginMethod loginMethod, const std::string& username, const std::string& password);
/// Logs in to the SMTP server using the given authentication method and the given
/// credentials.
void open();
/// Reads the initial response from the SMTP server.
///
/// Usually called implicitly through login(), but can
/// also be called explicitly to implement different forms
/// of SMTP authentication.
///
/// Does nothing if called more than once.
void close();
/// Sends a QUIT command and closes the connection to the server.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
void sendMessage(const MailMessage& message);
/// Sends the given mail message by sending a MAIL FROM command,
/// a RCPT TO command for every recipient, and a DATA command with
/// the message headers and content. Using this function results in
/// RCPT TO commands list generated from the recipient list supplied
/// with the message itself.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
void sendMessage(const MailMessage& message, const Recipients& recipients);
/// Sends the given mail message by sending a MAIL FROM command,
/// a RCPT TO command for every recipient, and a DATA command with
/// the message headers and content. Using this function results in
/// message header being generated from the supplied recipients list.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
void sendMessage(std::istream& istr);
/// Sends the mail message from the supplied stream. Content of the stream
/// is copied without any checking. Only the completion status is checked and,
/// if not valid, SMTPExcpetion is thrown.
int sendCommand(const std::string& command, std::string& response);
/// Sends the given command verbatim to the server
/// and waits for a response.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
int sendCommand(const std::string& command, const std::string& arg, std::string& response);
/// Sends the given command verbatim to the server
/// and waits for a response.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
void sendAddresses(const std::string& from, const Recipients& recipients);
/// Sends the message preamble by sending a MAIL FROM command,
/// and a RCPT TO command for every recipient.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
void sendData();
/// Sends the message preamble by sending a DATA command.
///
/// Throws a SMTPException in case of a SMTP-specific error, or a
/// NetException in case of a general network communication failure.
protected:
enum StatusClass
{
SMTP_POSITIVE_COMPLETION = 2,
SMTP_POSITIVE_INTERMEDIATE = 3,
SMTP_TRANSIENT_NEGATIVE = 4,
SMTP_PERMANENT_NEGATIVE = 5
};
enum
{
DEFAULT_TIMEOUT = 30000000 // 30 seconds default timeout for socket operations
};
static bool isPositiveCompletion(int status);
static bool isPositiveIntermediate(int status);
static bool isTransientNegative(int status);
static bool isPermanentNegative(int status);
void login(const std::string& hostname, std::string& response);
void loginUsingCRAMMD5(const std::string& username, const std::string& password);
void loginUsingCRAMSHA1(const std::string& username, const std::string& password);
void loginUsingCRAM(const std::string& username, const std::string& method, Poco::DigestEngine& hmac);
void loginUsingLogin(const std::string& username, const std::string& password);
void loginUsingPlain(const std::string& username, const std::string& password);
void loginUsingXOAUTH2(const std::string& username, const std::string& password);
void loginUsingNTLM(const std::string& username, const std::string& password);
DialogSocket& socket();
const std::string& host() const;
private:
void sendCommands(const MailMessage& message, const Recipients* pRecipients = 0);
void transportMessage(const MailMessage& message);
std::string _host;
DialogSocket _socket;
bool _isOpen;
};
//
// inlines
//
inline bool SMTPClientSession::isPositiveCompletion(int status)
{
return status/100 == SMTP_POSITIVE_COMPLETION;
}
inline bool SMTPClientSession::isPositiveIntermediate(int status)
{
return status/100 == SMTP_POSITIVE_INTERMEDIATE;
}
inline bool SMTPClientSession::isTransientNegative(int status)
{
return status/100 == SMTP_TRANSIENT_NEGATIVE;
}
inline bool SMTPClientSession::isPermanentNegative(int status)
{
return status/100 == SMTP_PERMANENT_NEGATIVE;
}
inline DialogSocket& SMTPClientSession::socket()
{
return _socket;
}
inline const std::string& SMTPClientSession::host() const
{
return _host;
}
} } // namespace Poco::Net
#endif // Net_SMTPClientSession_INCLUDED

83
vendor/POCO/Net/include/Poco/Net/SSPINTLMCredentials.h vendored Normal file
View File

@ -0,0 +1,83 @@
//
// SSPINTLMCredentials.h
//
// Library: Net
// Package: NTLM
// Module: SSPINTLMCredentials
//
// Definition of the SSPINTLMCredentials class.
//
// Copyright (c) 2019, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#include "Poco/Net/Net.h"
#include <vector>
#ifndef Net_SSPINTLMCredentials_INCLUDED
#define Net_SSPINTLMCredentials_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/NTLMCredentials.h"
#include "Poco/SharedPtr.h"
namespace Poco {
namespace Net {
struct NTLMContextImpl;
class NTLMContext
/// An opaque context class for working with SSPI NTLM authentication.
{
public:
~NTLMContext();
protected:
NTLMContext(NTLMContextImpl* pImpl);
private:
NTLMContextImpl* _pImpl;
NTLMContext();
NTLMContext(const NTLMContext&);
NTLMContext& operator = (const NTLMContext&);
friend class SSPINTLMProvider;
};
class Net_API SSPINTLMCredentials
/// Support for NTLM authentication using credentials of the currently
/// logged in user via SSPI.
{
public:
static bool available();
/// Returns true if SSPI NTLM support is available.
static Poco::SharedPtr<NTLMContext> createNTLMContext(const std::string& host, const std::string& service);
/// Creates an NTLMContext structure for use with negotiate()
/// and authenticate().
static std::vector<unsigned char> negotiate(NTLMContext& context);
/// Creates the NTLM Type 1 Negotiate message used for initiating NTLM authentication from the client.
static std::vector<unsigned char> authenticate(NTLMContext& context, const std::vector<unsigned char>& challenge);
/// Creates the NTLM Type 3 Authenticate message used for sending the response to the challenge.
static const std::string SERVICE_HTTP;
static const std::string SERVICE_SMTP;
};
} } // namespace Poco::Net
#endif // Net_SSPINTLMCredentials_INCLUDED

230
vendor/POCO/Net/include/Poco/Net/ServerSocket.h vendored Normal file
View File

@ -0,0 +1,230 @@
//
// ServerSocket.h
//
// Library: Net
// Package: Sockets
// Module: ServerSocket
//
// Definition of the ServerSocket class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ServerSocket_INCLUDED
#define Net_ServerSocket_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/Socket.h"
#include "Poco/Net/StreamSocket.h"
namespace Poco {
namespace Net {
class Net_API ServerSocket: public Socket
/// This class provides an interface to a
/// TCP server socket.
{
public:
ServerSocket();
/// Creates a server socket.
///
/// The server socket must be bound to
/// an address and put into listening state.
ServerSocket(const Socket& socket);
/// Creates the ServerSocket with the SocketImpl
/// from another socket. The SocketImpl must be
/// a ServerSocketImpl, otherwise an InvalidArgumentException
/// will be thrown.
ServerSocket(const SocketAddress& address, int backlog = 64);
/// Creates a server socket, binds it
/// to the given address and puts it in listening
/// state.
///
/// After successful construction, the server socket
/// is ready to accept connections.
ServerSocket(Poco::UInt16 port, int backlog = 64);
/// Creates a server socket, binds it
/// to the given port and puts it in listening
/// state.
///
/// After successful construction, the server socket
/// is ready to accept connections.
virtual ~ServerSocket();
/// Destroys the StreamSocket.
ServerSocket& operator = (const Socket& socket);
/// Assignment operator.
///
/// Releases the socket's SocketImpl and
/// attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
virtual void bind(const SocketAddress& address, bool reuseAddress = false);
/// Binds a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
/// Binds a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reuseAddress is true, sets the SO_REUSEPORT
/// socket option.
virtual void bind(Poco::UInt16 port, bool reuseAddress = false);
/// Binds a local port to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
virtual void bind(Poco::UInt16 port, bool reuseAddress, bool reusePort);
/// Binds a local port to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reusePort is true, sets the SO_REUSEPORT
/// socket option.
virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
/// Binds a local IPv6 address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// The given address must be an IPv6 address. The
/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
/// according to the ipV6Only parameter.
///
/// If the library has not been built with IPv6 support,
/// a Poco::NotImplementedException will be thrown.
virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only);
/// Binds a local IPv6 address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reusePort is true, sets the SO_REUSEPORT
/// socket option.
///
/// The given address must be an IPv6 address. The
/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
/// according to the ipV6Only parameter.
///
/// If the library has not been built with IPv6 support,
/// a Poco::NotImplementedException will be thrown.
virtual void bind6(Poco::UInt16 port, bool reuseAddress = false, bool ipV6Only = false);
/// Binds a local IPv6 port to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// The given address must be an IPv6 address. The
/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
/// according to the ipV6Only parameter.
///
/// If the library has not been built with IPv6 support,
/// a Poco::NotImplementedException will be thrown.
virtual void bind6(Poco::UInt16 port, bool reuseAddress, bool reusePort, bool ipV6Only);
/// Binds a local IPv6 port to the socket.
///
/// This is usually only done when establishing a server
/// socket.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reusePort is true, sets the SO_REUSEPORT
/// socket option.
/// The given address must be an IPv6 address. The
/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
/// according to the ipV6Only parameter.
///
/// If the library has not been built with IPv6 support,
/// a Poco::NotImplementedException will be thrown.
virtual void listen(int backlog = 64);
/// Puts the socket into listening state.
///
/// The socket becomes a passive socket that
/// can accept incoming connection requests.
///
/// The backlog argument specifies the maximum
/// number of connections that can be queued
/// for this socket.
virtual StreamSocket acceptConnection(SocketAddress& clientAddr);
/// Gets the next completed connection from the
/// socket's completed connection queue.
///
/// If the queue is empty, waits until a connection
/// request completes.
///
/// Returns a new TCP socket for the connection
/// with the client.
///
/// The client socket's address is returned in clientAddr.
virtual StreamSocket acceptConnection();
/// Gets the next completed connection from the
/// socket's completed connection queue.
///
/// If the queue is empty, waits until a connection
/// request completes.
///
/// Returns a new TCP socket for the connection
/// with the client.
protected:
ServerSocket(SocketImpl* pImpl, bool);
/// The bool argument is to resolve an ambiguity with
/// another constructor (Microsoft Visual C++ 2005)
};
} } // namespace Poco::Net
#endif // Net_ServerSocket_INCLUDED

45
vendor/POCO/Net/include/Poco/Net/ServerSocketImpl.h vendored Normal file
View File

@ -0,0 +1,45 @@
//
// ServerSocketImpl.h
//
// Library: Net
// Package: Sockets
// Module: ServerSocketImpl
//
// Definition of the ServerSocketImpl class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_ServerSocketImpl_INCLUDED
#define Net_ServerSocketImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketImpl.h"
namespace Poco {
namespace Net {
class Net_API ServerSocketImpl: public SocketImpl
/// This class implements a TCP server socket.
{
public:
ServerSocketImpl();
/// Creates the ServerSocketImpl.
protected:
virtual ~ServerSocketImpl();
/// Destroys the ServerSocketImpl.
};
} } // namespace Poco::Net
#endif // Net_ServerSocketImpl_INCLUDED

104
vendor/POCO/Net/include/Poco/Net/SingleSocketPoller.h vendored Normal file
View File

@ -0,0 +1,104 @@
//
// SingleSocketPoller.h
//
// Library: Net
// Package: UDP
// Module: SingleSocketPoller
//
// Definition of the SingleSocketPoller class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SingleSocketPoller_INCLUDED
#define Net_SingleSocketPoller_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/DatagramSocket.h"
#include "Poco/Net/UDPHandler.h"
#include "Poco/Net/PollSet.h"
namespace Poco {
namespace Net {
template <std::size_t S = POCO_UDP_BUF_SIZE>
class SingleSocketPoller
/// SinlgeSocketPoller, as its name indicates, repeatedly polls a single
/// socket for readability; if the socket is readable, the reading action
/// is delegated to the reader.
{
public:
SingleSocketPoller(typename UDPHandlerImpl<S>::List& handlers, const Poco::Net::SocketAddress& sa, Poco::Timespan timeout = 250000): _reader(handlers), _timeout(timeout)
/// Creates the SingleSocketPoller and binds it to
/// the given address.
{
_socket.bind(sa, false, false);
_socket.setBlocking(false);
}
SingleSocketPoller(typename UDPHandlerImpl<S>::List& handlers, const UDPServerParams& serverParams): _reader(handlers, serverParams), _timeout(serverParams.timeout())
/// Creates the SingleSocketPoller and binds it to
/// the given address.
{
_socket.bind(serverParams.address(), false, false);
_socket.setBlocking(false);
}
~SingleSocketPoller()
/// Destroys SingleSocketPoller
{
}
Poco::UInt16 port() const
/// Returns the port the socket is
/// listening on.
{
return _socket.address().port();
}
Poco::Net::SocketAddress address() const
/// Returns the address of the server.
{
return _socket.address();
}
void poll()
/// Poll the socket and read if readable.
{
if (_reader.handlerStopped()) return;
if (_socket.poll(_timeout, Socket::SELECT_READ))
{
_reader.read(_socket);
}
}
void stop()
/// Stops the handler.
{
_reader.stopHandler();
}
bool done() const
/// Returns tru if handler is done.
{
return _reader.handlerDone();
}
private:
Poco::Net::DatagramSocket _socket;
UDPSocketReader<S> _reader;
Poco::Timespan _timeout;
};
} } // namespace Poco::Net
#endif // Net_SingleSocketPoller_INCLUDED

671
vendor/POCO/Net/include/Poco/Net/Socket.h vendored Normal file
View File

@ -0,0 +1,671 @@
//
// Socket.h
//
// Library: Net
// Package: Sockets
// Module: Socket
//
// Definition of the Socket class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_Socket_INCLUDED
#define Net_Socket_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketImpl.h"
#include <vector>
namespace Poco {
namespace Net {
class Net_API Socket
/// Socket is the common base class for
/// StreamSocket, ServerSocket, DatagramSocket and other
/// socket classes.
///
/// It provides operations common to all socket types.
{
public:
using BufVec = SocketBufVec;
enum SelectMode
/// The mode argument to poll() and select().
{
SELECT_READ = 1,
SELECT_WRITE = 2,
SELECT_ERROR = 4
};
using SocketList = std::vector<Socket>;
Socket();
/// Creates an uninitialized socket.
Socket(const Socket& socket);
/// Copy constructor.
///
/// Attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
Socket& operator = (const Socket& socket);
/// Assignment operator.
///
/// Releases the socket's SocketImpl and
/// attaches the SocketImpl from the other socket and
/// increments the reference count of the SocketImpl.
virtual ~Socket();
/// Destroys the Socket and releases the
/// SocketImpl.
bool operator == (const Socket& socket) const;
/// Returns true if both sockets share the same
/// SocketImpl, false otherwise.
bool operator != (const Socket& socket) const;
/// Returns false if both sockets share the same
/// SocketImpl, true otherwise.
bool operator < (const Socket& socket) const;
/// Compares the SocketImpl pointers.
bool operator <= (const Socket& socket) const;
/// Compares the SocketImpl pointers.
bool operator > (const Socket& socket) const;
/// Compares the SocketImpl pointers.
bool operator >= (const Socket& socket) const;
/// Compares the SocketImpl pointers.
void close();
/// Closes the socket.
static int select(SocketList& readList, SocketList& writeList, SocketList& exceptList, const Poco::Timespan& timeout);
/// Determines the status of one or more sockets,
/// using a call to select().
///
/// ReadList contains the list of sockets which should be
/// checked for readability.
///
/// WriteList contains the list of sockets which should be
/// checked for writeability.
///
/// ExceptList contains a list of sockets which should be
/// checked for a pending error.
///
/// Returns the number of sockets ready.
///
/// After return,
/// * readList contains those sockets ready for reading,
/// * writeList contains those sockets ready for writing,
/// * exceptList contains those sockets with a pending error.
///
/// If the total number of sockets passed in readList, writeList and
/// exceptList is zero, select() will return immediately and the
/// return value will be 0.
///
/// If one of the sockets passed to select() is closed while
/// select() runs, select will return immediately. However,
/// the closed socket will not be included in any list.
/// In this case, the return value may be greater than the sum
/// of all sockets in all list.
bool poll(const Poco::Timespan& timeout, int mode) const;
/// Determines the status of the socket, using a
/// call to poll() or select().
///
/// The mode argument is constructed by combining the values
/// of the SelectMode enumeration.
///
/// Returns true if the next operation corresponding to
/// mode will not block, false otherwise.
int available() const;
/// Returns the number of bytes available that can be read
/// without causing the socket to block.
void setSendBufferSize(int size);
/// Sets the size of the send buffer.
int getSendBufferSize() const;
/// Returns the size of the send buffer.
///
/// The returned value may be different than the
/// value previously set with setSendBufferSize(),
/// as the system is free to adjust the value.
void setReceiveBufferSize(int size);
/// Sets the size of the receive buffer.
int getReceiveBufferSize() const;
/// Returns the size of the receive buffer.
///
/// The returned value may be different than the
/// value previously set with setReceiveBufferSize(),
/// as the system is free to adjust the value.
void setSendTimeout(const Poco::Timespan& timeout);
/// Sets the send timeout for the socket.
Poco::Timespan getSendTimeout() const;
/// Returns the send timeout for the socket.
///
/// The returned timeout may be different than the
/// timeout previously set with setSendTimeout(),
/// as the system is free to adjust the value.
void setReceiveTimeout(const Poco::Timespan& timeout);
/// Sets the send timeout for the socket.
///
/// On systems that do not support SO_RCVTIMEO, a
/// workaround using poll() is provided.
Poco::Timespan getReceiveTimeout() const;
/// Returns the receive timeout for the socket.
///
/// The returned timeout may be different than the
/// timeout previously set with getReceiveTimeout(),
/// as the system is free to adjust the value.
void setOption(int level, int option, int value);
/// Sets the socket option specified by level and option
/// to the given integer value.
void setOption(int level, int option, unsigned value);
/// Sets the socket option specified by level and option
/// to the given integer value.
void setOption(int level, int option, unsigned char value);
/// Sets the socket option specified by level and option
/// to the given integer value.
void setOption(int level, int option, const Poco::Timespan& value);
/// Sets the socket option specified by level and option
/// to the given time value.
void setOption(int level, int option, const IPAddress& value);
/// Sets the socket option specified by level and option
/// to the given time value.
void getOption(int level, int option, int& value) const;
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, unsigned& value) const;
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, unsigned char& value) const;
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, Poco::Timespan& value) const;
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, IPAddress& value) const;
/// Returns the value of the socket option
/// specified by level and option.
void setLinger(bool on, int seconds);
/// Sets the value of the SO_LINGER socket option.
void getLinger(bool& on, int& seconds) const;
/// Returns the value of the SO_LINGER socket option.
void setNoDelay(bool flag);
/// Sets the value of the TCP_NODELAY socket option.
bool getNoDelay() const;
/// Returns the value of the TCP_NODELAY socket option.
void setKeepAlive(bool flag);
/// Sets the value of the SO_KEEPALIVE socket option.
bool getKeepAlive() const;
/// Returns the value of the SO_KEEPALIVE socket option.
void setReuseAddress(bool flag);
/// Sets the value of the SO_REUSEADDR socket option.
bool getReuseAddress() const;
/// Returns the value of the SO_REUSEADDR socket option.
void setReusePort(bool flag);
/// Sets the value of the SO_REUSEPORT socket option.
/// Does nothing if the socket implementation does not
/// support SO_REUSEPORT.
bool getReusePort() const;
/// Returns the value of the SO_REUSEPORT socket option.
///
/// Returns false if the socket implementation does not
/// support SO_REUSEPORT.
void setOOBInline(bool flag);
/// Sets the value of the SO_OOBINLINE socket option.
bool getOOBInline() const;
/// Returns the value of the SO_OOBINLINE socket option.
void setBlocking(bool flag);
/// Sets the socket in blocking mode if flag is true,
/// disables blocking mode if flag is false.
bool getBlocking() const;
/// Returns the blocking mode of the socket.
/// This method will only work if the blocking modes of
/// the socket are changed via the setBlocking method!
SocketAddress address() const;
/// Returns the IP address and port number of the socket.
SocketAddress peerAddress() const;
/// Returns the IP address and port number of the peer socket.
SocketImpl* impl() const;
/// Returns the SocketImpl for this socket.
bool secure() const;
/// Returns true iff the socket's connection is secure
/// (using SSL or TLS).
static bool supportsIPv4();
/// Returns true if the system supports IPv4.
static bool supportsIPv6();
/// Returns true if the system supports IPv6.
void init(int af);
/// Creates the underlying system socket for the given
/// address family.
///
/// Normally, this method should not be called directly, as
/// socket creation will be handled automatically. There are
/// a few situations where calling this method after creation
/// of the Socket object makes sense. One example is setting
/// a socket option before calling bind() on a ServerSocket.
static SocketBuf makeBuffer(void* buffer, std::size_t length);
/// Creates and returns buffer. Suitable for creating
/// the appropriate buffer for the platform.
static SocketBufVec makeBufVec(std::size_t size, std::size_t bufLen);
/// Creates and returns a vector of requested size, with
/// allocated buffers and lengths set accordingly.
/// This utility function works well when all buffers are
/// of same size.
static void destroyBufVec(SocketBufVec& buf);
/// Releases the memory pointed to by vector members
/// and shrinks the vector to size 0.
/// The vector must be created by makeBufVec(size_t, size_t).
static SocketBufVec makeBufVec(const std::vector<char*>& vec);
/// Creates and returns a vector of requested size, with
/// buffers pointing to the supplied data (so, `vec` must
/// remain available at the time of use) and lengths set
/// accordingly.
/// Notes:
/// - data length is determined using `strlen`, so this
/// function is not meant to be used with binary data.
///
/// - if the returned buffer is used for read operations
/// (ie. operations that write to the bufer), pointing
/// to string literals will result in undefined behavior,
/// in best case an I/O error and subsequent exception
static SocketBufVec makeBufVec(const std::vector<std::string>& vec);
/// Creates and returns a vector of requested size, with
/// buffers pointing to the supplied data (so, `vec` must
/// remain available at the time of use) and lengths set
/// accordingly.
/// Note:: this function is not suitable for creation
/// of buffers used for writing (ie. reading from socket
/// into buffers).
protected:
Socket(SocketImpl* pImpl);
/// Creates the Socket and attaches the given SocketImpl.
/// The socket takes ownership of the SocketImpl.
poco_socket_t sockfd() const;
/// Returns the socket descriptor for this socket.
private:
#if defined(POCO_HAVE_FD_POLL)
class FDCompare
/// Utility functor used to compare socket file descriptors.
/// Used in poll() member function.
{
public:
FDCompare(int fd): _fd(fd) { }
inline bool operator()(const Socket& socket) const
{ return socket.sockfd() == _fd; }
private:
FDCompare();
int _fd;
};
#endif
SocketImpl* _pImpl;
};
//
// inlines
//
inline bool Socket::operator == (const Socket& socket) const
{
return _pImpl == socket._pImpl;
}
inline bool Socket::operator != (const Socket& socket) const
{
return _pImpl != socket._pImpl;
}
inline bool Socket::operator < (const Socket& socket) const
{
return _pImpl < socket._pImpl;
}
inline bool Socket::operator <= (const Socket& socket) const
{
return _pImpl <= socket._pImpl;
}
inline bool Socket::operator > (const Socket& socket) const
{
return _pImpl > socket._pImpl;
}
inline bool Socket::operator >= (const Socket& socket) const
{
return _pImpl >= socket._pImpl;
}
inline void Socket::close()
{
_pImpl->close();
}
inline bool Socket::poll(const Poco::Timespan& timeout, int mode) const
{
return _pImpl->poll(timeout, mode);
}
inline int Socket::available() const
{
return _pImpl->available();
}
inline void Socket::setSendBufferSize(int size)
{
_pImpl->setSendBufferSize(size);
}
inline int Socket::getSendBufferSize() const
{
return _pImpl->getSendBufferSize();
}
inline void Socket::setReceiveBufferSize(int size)
{
_pImpl->setReceiveBufferSize(size);
}
inline int Socket::getReceiveBufferSize() const
{
return _pImpl->getReceiveBufferSize();
}
inline void Socket::setSendTimeout(const Poco::Timespan& timeout)
{
_pImpl->setSendTimeout(timeout);
}
inline Poco::Timespan Socket::getSendTimeout() const
{
return _pImpl->getSendTimeout();
}
inline void Socket::setReceiveTimeout(const Poco::Timespan& timeout)
{
_pImpl->setReceiveTimeout(timeout);
}
inline Poco::Timespan Socket::getReceiveTimeout() const
{
return _pImpl->getReceiveTimeout();
}
inline void Socket::setOption(int level, int option, int value)
{
_pImpl->setOption(level, option, value);
}
inline void Socket::setOption(int level, int option, unsigned value)
{
_pImpl->setOption(level, option, value);
}
inline void Socket::setOption(int level, int option, unsigned char value)
{
_pImpl->setOption(level, option, value);
}
inline void Socket::setOption(int level, int option, const Poco::Timespan& value)
{
_pImpl->setOption(level, option, value);
}
inline void Socket::setOption(int level, int option, const IPAddress& value)
{
_pImpl->setOption(level, option, value);
}
inline void Socket::getOption(int level, int option, int& value) const
{
_pImpl->getOption(level, option, value);
}
inline void Socket::getOption(int level, int option, unsigned& value) const
{
_pImpl->getOption(level, option, value);
}
inline void Socket::getOption(int level, int option, unsigned char& value) const
{
_pImpl->getOption(level, option, value);
}
inline void Socket::getOption(int level, int option, Poco::Timespan& value) const
{
_pImpl->getOption(level, option, value);
}
inline void Socket::getOption(int level, int option, IPAddress& value) const
{
_pImpl->getOption(level, option, value);
}
inline void Socket::setLinger(bool on, int seconds)
{
_pImpl->setLinger(on, seconds);
}
inline void Socket::getLinger(bool& on, int& seconds) const
{
_pImpl->getLinger(on, seconds);
}
inline void Socket::setNoDelay(bool flag)
{
_pImpl->setNoDelay(flag);
}
inline bool Socket::getNoDelay() const
{
return _pImpl->getNoDelay();
}
inline void Socket::setKeepAlive(bool flag)
{
_pImpl->setKeepAlive(flag);
}
inline bool Socket::getKeepAlive() const
{
return _pImpl->getKeepAlive();
}
inline void Socket::setReuseAddress(bool flag)
{
_pImpl->setReuseAddress(flag);
}
inline bool Socket::getReuseAddress() const
{
return _pImpl->getReuseAddress();
}
inline void Socket::setReusePort(bool flag)
{
_pImpl->setReusePort(flag);
}
inline bool Socket::getReusePort() const
{
return _pImpl->getReusePort();
}
inline void Socket::setOOBInline(bool flag)
{
_pImpl->setOOBInline(flag);
}
inline bool Socket::getOOBInline() const
{
return _pImpl->getOOBInline();
}
inline void Socket::setBlocking(bool flag)
{
_pImpl->setBlocking(flag);
}
inline bool Socket::getBlocking() const
{
return _pImpl->getBlocking();
}
inline SocketImpl* Socket::impl() const
{
return _pImpl;
}
inline poco_socket_t Socket::sockfd() const
{
return _pImpl->sockfd();
}
inline SocketAddress Socket::address() const
{
return _pImpl->address();
}
inline SocketAddress Socket::peerAddress() const
{
return _pImpl->peerAddress();
}
inline bool Socket::secure() const
{
return _pImpl->secure();
}
inline bool Socket::supportsIPv4()
{
return true;
}
inline bool Socket::supportsIPv6()
{
#if defined(POCO_HAVE_IPv6)
return true;
#else
return false;
#endif
}
inline void Socket::init(int af)
{
_pImpl->init(af);
}
} } // namespace Poco::Net
#endif // Net_Socket_INCLUDED

191
vendor/POCO/Net/include/Poco/Net/SocketAcceptor.h vendored Normal file
View File

@ -0,0 +1,191 @@
//
// SocketAcceptor.h
//
// Library: Net
// Package: Reactor
// Module: SocketAcceptor
//
// Definition of the SocketAcceptor class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketAcceptor_INCLUDED
#define Net_SocketAcceptor_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketNotification.h"
#include "Poco/Net/SocketReactor.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Observer.h"
namespace Poco {
namespace Net {
template <class ServiceHandler>
class SocketAcceptor
/// This class implements the Acceptor part of the
/// Acceptor-Connector design pattern.
///
/// The Acceptor-Connector pattern has been described in the book
/// "Pattern Languages of Program Design 3", edited by Robert Martin,
/// Frank Buschmann and Dirk Riehle (Addison Wesley, 1997).
///
/// The Acceptor-Connector design pattern decouples connection
/// establishment and service initialization in a distributed system
/// from the processing performed once a service is initialized.
/// This decoupling is achieved with three components: Acceptors,
/// Connectors and Service Handlers.
/// The SocketAcceptor passively waits for connection requests (usually
/// from a remote Connector) and establishes a connection upon
/// arrival of a connection requests. Also, a Service Handler is
/// initialized to process the data arriving via the connection in
/// an application-specific way.
///
/// The SocketAcceptor sets up a ServerSocket and registers itself
/// for a ReadableNotification, denoting an incoming connection request.
///
/// When the ServerSocket becomes readable the SocketAcceptor accepts
/// the connection request and creates a ServiceHandler to
/// service the connection.
///
/// The ServiceHandler class must provide a constructor that
/// takes a StreamSocket and a SocketReactor as arguments,
/// e.g.:
/// MyServiceHandler(const StreamSocket& socket, ServiceReactor& reactor)
///
/// When the ServiceHandler is done, it must destroy itself.
///
/// Subclasses can override the createServiceHandler() factory method
/// if special steps are necessary to create a ServiceHandler object.
{
public:
using Observer = Poco::Observer<SocketAcceptor, ReadableNotification>;
explicit SocketAcceptor(ServerSocket& socket):
_socket(socket),
_pReactor(0)
/// Creates a SocketAcceptor, using the given ServerSocket.
{
}
SocketAcceptor(ServerSocket& socket, SocketReactor& reactor):
_socket(socket),
_pReactor(&reactor)
/// Creates a SocketAcceptor, using the given ServerSocket.
/// The SocketAcceptor registers itself with the given SocketReactor.
{
_pReactor->addEventHandler(_socket, Observer(*this, &SocketAcceptor::onAccept));
}
virtual ~SocketAcceptor()
/// Destroys the SocketAcceptor.
{
try
{
if (_pReactor)
{
_pReactor->removeEventHandler(_socket, Observer(*this, &SocketAcceptor::onAccept));
}
}
catch (...)
{
poco_unexpected();
}
}
void setReactor(SocketReactor& reactor)
/// Sets the reactor for this acceptor.
{
registerAcceptor(reactor);
}
virtual void registerAcceptor(SocketReactor& reactor)
/// Registers the SocketAcceptor with a SocketReactor.
///
/// A subclass can override this function to e.g.
/// register an event handler for timeout event.
///
/// If acceptor was constructed without providing reactor to it,
/// the override of this method must either call the base class
/// implementation or directly register the accept handler with
/// the reactor.
{
_pReactor = &reactor;
if (!_pReactor->hasEventHandler(_socket, Observer(*this, &SocketAcceptor::onAccept)))
{
_pReactor->addEventHandler(_socket, Observer(*this, &SocketAcceptor::onAccept));
}
}
virtual void unregisterAcceptor()
/// Unregisters the SocketAcceptor.
///
/// A subclass can override this function to e.g.
/// unregister its event handler for a timeout event.
///
/// If the accept handler was registered with the reactor,
/// the overriding method must either call the base class
/// implementation or directly unregister the accept handler.
{
if (_pReactor)
{
_pReactor->removeEventHandler(_socket, Observer(*this, &SocketAcceptor::onAccept));
}
}
void onAccept(ReadableNotification* pNotification)
/// Accepts connection and creates event handler.
{
pNotification->release();
StreamSocket sock = _socket.acceptConnection();
_pReactor->wakeUp();
createServiceHandler(sock);
}
protected:
virtual ServiceHandler* createServiceHandler(StreamSocket& socket)
/// Create and initialize a new ServiceHandler instance.
///
/// Subclasses can override this method.
{
return new ServiceHandler(socket, *_pReactor);
}
SocketReactor* reactor()
/// Returns a pointer to the SocketReactor where
/// this SocketAcceptor is registered.
///
/// The pointer may be null.
{
return _pReactor;
}
Socket& socket()
/// Returns a reference to the SocketAcceptor's socket.
{
return _socket;
}
private:
SocketAcceptor();
SocketAcceptor(const SocketAcceptor&);
SocketAcceptor& operator = (const SocketAcceptor&);
ServerSocket _socket;
SocketReactor* _pReactor;
};
} } // namespace Poco::Net
#endif // Net_SocketAcceptor_INCLUDED

301
vendor/POCO/Net/include/Poco/Net/SocketAddress.h vendored Normal file
View File

@ -0,0 +1,301 @@
//
// SocketAddress.h
//
// Library: Net
// Package: NetCore
// Module: SocketAddress
//
// Definition of the SocketAddress class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketAddress_INCLUDED
#define Net_SocketAddress_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketAddressImpl.h"
#include <ostream>
namespace Poco {
class BinaryReader;
class BinaryWriter;
namespace Net {
class IPAddress;
class Net_API SocketAddress
/// This class represents an internet (IP) endpoint/socket
/// address. The address can belong either to the
/// IPv4 or the IPv6 address family and consists of a
/// host address and a port number.
{
public:
// The following declarations keep the Family type
// backwards compatible with the previously used
// enum declaration.
using Family = AddressFamily::Family;
static const Family IPv4 = AddressFamily::IPv4;
#if defined(POCO_HAVE_IPv6)
static const Family IPv6 = AddressFamily::IPv6;
#endif
#if defined(POCO_OS_FAMILY_UNIX)
static const Family UNIX_LOCAL = AddressFamily::UNIX_LOCAL;
#endif
SocketAddress();
/// Creates a wildcard (all zero) IPv4 SocketAddress.
explicit SocketAddress(Family family);
/// Creates a SocketAddress with unspecified (wildcard) IP address
/// of the given family.
SocketAddress(const IPAddress& hostAddress, Poco::UInt16 portNumber);
/// Creates a SocketAddress from an IP address and given port number.
explicit SocketAddress(Poco::UInt16 port);
/// Creates a SocketAddress with unspecified (wildcard) IP address
/// and given port number.
SocketAddress(Family family, Poco::UInt16 port);
/// Creates a SocketAddress with unspecified (wildcard) IP address
/// of the given family, and given port number.
SocketAddress(const std::string& hostAddress, Poco::UInt16 portNumber);
/// Creates a SocketAddress from an IP address and given port number.
///
/// The IP address must either be a domain name, or it must
/// be in dotted decimal (IPv4) or hex string (IPv6) format.
SocketAddress(Family family, const std::string& hostAddress, Poco::UInt16 portNumber);
/// Creates a SocketAddress from an IP address and given port number.
///
/// The IP address must either be a domain name, or it must
/// be in dotted decimal (IPv4) or hex string (IPv6) format.
///
/// If a domain name is given in hostAddress, it is resolved and the address
/// matching the given family is used. If no address matching the given family
/// is found, or the IP address given in hostAddress does not match the given
/// family, an AddressFamilyMismatchException is thrown.
SocketAddress(const std::string& hostAddress, const std::string& portNumber);
/// Creates a SocketAddress from an IP address and the
/// service name or port number.
///
/// The IP address must either be a domain name, or it must
/// be in dotted decimal (IPv4) or hex string (IPv6) format.
///
/// The given port must either be a decimal port number, or
/// a service name.
SocketAddress(Family family, const std::string& hostAddress, const std::string& portNumber);
/// Creates a SocketAddress from an IP address and the
/// service name or port number.
///
/// The IP address must either be a domain name, or it must
/// be in dotted decimal (IPv4) or hex string (IPv6) format.
///
/// The given port must either be a decimal port number, or
/// a service name.
///
/// If a domain name is given in hostAddress, it is resolved and the address
/// matching the given family is used. If no address matching the given family
/// is found, or the IP address given in hostAddress does not match the given
/// family, an AddressFamilyMismatchException is thrown.
explicit SocketAddress(const std::string& hostAndPort);
/// Creates a SocketAddress from an IP address or host name and the
/// port number/service name. Host name/address and port number must
/// be separated by a colon. In case of an IPv6 address,
/// the address part must be enclosed in brackets.
///
/// Examples:
/// 192.168.1.10:80
/// [::ffff:192.168.1.120]:2040
/// www.appinf.com:8080
///
/// On POSIX platforms supporting UNIX_LOCAL sockets, hostAndPort
/// can also be the absolute path of a local socket, starting with a
/// slash, e.g. "/tmp/local.socket".
SocketAddress(Family family, const std::string& addr);
/// Creates a SocketAddress of the given family from a
/// string representation of the address, which is
/// either an IP address and port number, separated by
/// a colon for IPv4 or IPv6 addresses, or a path for
/// UNIX_LOCAL sockets.
SocketAddress(const SocketAddress& addr);
/// Creates a SocketAddress by copying another one.
SocketAddress(const struct sockaddr* addr, poco_socklen_t length);
/// Creates a SocketAddress from a native socket address.
~SocketAddress();
/// Destroys the SocketAddress.
SocketAddress& operator = (const SocketAddress& socketAddress);
/// Assigns another SocketAddress.
IPAddress host() const;
/// Returns the host IP address.
Poco::UInt16 port() const;
/// Returns the port number.
poco_socklen_t length() const;
/// Returns the length of the internal native socket address.
const struct sockaddr* addr() const;
/// Returns a pointer to the internal native socket address.
int af() const;
/// Returns the address family (AF_INET or AF_INET6) of the address.
std::string toString() const;
/// Returns a string representation of the address.
Family family() const;
/// Returns the address family of the host's address.
bool operator < (const SocketAddress& socketAddress) const;
bool operator == (const SocketAddress& socketAddress) const;
bool operator != (const SocketAddress& socketAddress) const;
enum
{
MAX_ADDRESS_LENGTH =
#if defined(POCO_OS_FAMILY_UNIX)
sizeof(struct sockaddr_un)
#elif defined(POCO_HAVE_IPv6)
sizeof(struct sockaddr_in6)
#else
sizeof(struct sockaddr_in)
#endif
/// Maximum length in bytes of a socket address.
};
protected:
void init(const IPAddress& hostAddress, Poco::UInt16 portNumber);
void init(const std::string& hostAddress, Poco::UInt16 portNumber);
void init(Family family, const std::string& hostAddress, Poco::UInt16 portNumber);
void init(Family family, const std::string& address);
void init(const std::string& hostAndPort);
Poco::UInt16 resolveService(const std::string& service);
private:
typedef Poco::Net::Impl::SocketAddressImpl Impl;
typedef Poco::AutoPtr<Impl> Ptr;
Ptr pImpl() const;
void newIPv4();
void newIPv4(const sockaddr_in*);
void newIPv4(const IPAddress& hostAddress, Poco::UInt16 portNumber);
#if defined(POCO_HAVE_IPv6)
void newIPv6(const sockaddr_in6*);
void newIPv6(const IPAddress& hostAddress, Poco::UInt16 portNumber);
#endif
#if defined(POCO_OS_FAMILY_UNIX)
void newLocal(const sockaddr_un* sockAddr);
void newLocal(const std::string& path);
#endif
Ptr _pImpl;
};
//
// inlines
//
inline SocketAddress::Ptr SocketAddress::pImpl() const
{
if (_pImpl) return _pImpl;
throw Poco::NullPointerException("Pointer to SocketAddress implementation is NULL.");
}
inline void SocketAddress::newIPv4()
{
_pImpl = new Poco::Net::Impl::IPv4SocketAddressImpl;
}
inline void SocketAddress::newIPv4(const sockaddr_in* sockAddr)
{
_pImpl = new Poco::Net::Impl::IPv4SocketAddressImpl(sockAddr);
}
inline void SocketAddress::newIPv4(const IPAddress& hostAddress, Poco::UInt16 portNumber)
{
_pImpl = new Poco::Net::Impl::IPv4SocketAddressImpl(hostAddress.addr(), htons(portNumber));
}
#if defined(POCO_HAVE_IPv6)
inline void SocketAddress::newIPv6(const sockaddr_in6* sockAddr)
{
_pImpl = new Poco::Net::Impl::IPv6SocketAddressImpl(sockAddr);
}
inline void SocketAddress::newIPv6(const IPAddress& hostAddress, Poco::UInt16 portNumber)
{
_pImpl = new Poco::Net::Impl::IPv6SocketAddressImpl(hostAddress.addr(), htons(portNumber), hostAddress.scope());
}
#endif // POCO_HAVE_IPv6
#if defined(POCO_OS_FAMILY_UNIX)
inline void SocketAddress::newLocal(const sockaddr_un* sockAddr)
{
_pImpl = new Poco::Net::Impl::LocalSocketAddressImpl(sockAddr);
}
inline void SocketAddress::newLocal(const std::string& path)
{
_pImpl = new Poco::Net::Impl::LocalSocketAddressImpl(path.c_str(), path.size());
}
#endif // POCO_OS_FAMILY_UNIX
inline bool SocketAddress::operator == (const SocketAddress& socketAddress) const
{
#if defined(POCO_OS_FAMILY_UNIX)
if (family() == UNIX_LOCAL)
return toString() == socketAddress.toString();
else
#endif
return host() == socketAddress.host() && port() == socketAddress.port();
}
inline bool SocketAddress::operator != (const SocketAddress& socketAddress) const
{
return !(operator == (socketAddress));
}
} } // namespace Poco::Net
Net_API Poco::BinaryWriter& operator << (Poco::BinaryWriter& writer, const Poco::Net::SocketAddress& value);
Net_API Poco::BinaryReader& operator >> (Poco::BinaryReader& reader, Poco::Net::SocketAddress& value);
Net_API std::ostream& operator << (std::ostream& ostr, const Poco::Net::SocketAddress& address);
#endif // Net_SocketAddress_INCLUDED

258
vendor/POCO/Net/include/Poco/Net/SocketAddressImpl.h vendored Normal file
View File

@ -0,0 +1,258 @@
//
// SocketAddressImpl.h
//
// Library: Net
// Package: NetCore
// Module: SocketAddressImpl
//
// Definition of the SocketAddressImpl class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketAddressImpl_INCLUDED
#define Net_SocketAddressImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketDefs.h"
#include "Poco/Net/IPAddress.h"
#include "Poco/RefCountedObject.h"
namespace Poco {
namespace Net {
namespace Impl {
class Net_API SocketAddressImpl : public Poco::RefCountedObject
{
public:
using Family = AddressFamily::Family;
virtual ~SocketAddressImpl();
virtual IPAddress host() const = 0;
virtual UInt16 port() const = 0;
virtual poco_socklen_t length() const = 0;
virtual const struct sockaddr* addr() const = 0;
virtual int af() const = 0;
virtual Family family() const = 0;
virtual std::string toString() const = 0;
protected:
SocketAddressImpl();
private:
SocketAddressImpl(const SocketAddressImpl&);
SocketAddressImpl& operator = (const SocketAddressImpl&);
};
class Net_API IPv4SocketAddressImpl: public SocketAddressImpl
{
public:
IPv4SocketAddressImpl();
IPv4SocketAddressImpl(const struct sockaddr_in* addr);
IPv4SocketAddressImpl(const void* addr, UInt16 port);
IPAddress host() const;
UInt16 port() const;
poco_socklen_t length() const;
const struct sockaddr* addr() const;
int af() const;
Family family() const;
std::string toString() const;
private:
struct sockaddr_in _addr;
};
//
// inlines
//
inline IPAddress IPv4SocketAddressImpl::host() const
{
return IPAddress(&_addr.sin_addr, sizeof(_addr.sin_addr));
}
inline UInt16 IPv4SocketAddressImpl::port() const
{
return _addr.sin_port;
}
inline poco_socklen_t IPv4SocketAddressImpl::length() const
{
return sizeof(_addr);
}
inline const struct sockaddr* IPv4SocketAddressImpl::addr() const
{
return reinterpret_cast<const struct sockaddr*>(&_addr);
}
inline int IPv4SocketAddressImpl::af() const
{
return _addr.sin_family;
}
inline SocketAddressImpl::Family IPv4SocketAddressImpl::family() const
{
return AddressFamily::IPv4;
}
#if defined(POCO_HAVE_IPv6)
class Net_API IPv6SocketAddressImpl: public SocketAddressImpl
{
public:
IPv6SocketAddressImpl(const struct sockaddr_in6* addr);
IPv6SocketAddressImpl(const void* addr, UInt16 port);
IPv6SocketAddressImpl(const void* addr, UInt16 port, UInt32 scope);
IPAddress host() const;
UInt16 port() const;
poco_socklen_t length() const;
const struct sockaddr* addr() const;
int af() const;
Family family() const;
std::string toString() const;
private:
struct sockaddr_in6 _addr;
};
//
// inlines
//
inline IPAddress IPv6SocketAddressImpl::host() const
{
return IPAddress(&_addr.sin6_addr, sizeof(_addr.sin6_addr), _addr.sin6_scope_id);
}
inline UInt16 IPv6SocketAddressImpl::port() const
{
return _addr.sin6_port;
}
inline poco_socklen_t IPv6SocketAddressImpl::length() const
{
return sizeof(_addr);
}
inline const struct sockaddr* IPv6SocketAddressImpl::addr() const
{
return reinterpret_cast<const struct sockaddr*>(&_addr);
}
inline int IPv6SocketAddressImpl::af() const
{
return _addr.sin6_family;
}
inline SocketAddressImpl::Family IPv6SocketAddressImpl::family() const
{
return AddressFamily::IPv6;
}
#endif // POCO_HAVE_IPv6
#if defined(POCO_OS_FAMILY_UNIX)
class Net_API LocalSocketAddressImpl: public SocketAddressImpl
{
public:
LocalSocketAddressImpl(const struct sockaddr_un* addr);
LocalSocketAddressImpl(const char* path);
LocalSocketAddressImpl(const char* path, std::size_t length);
~LocalSocketAddressImpl();
IPAddress host() const;
UInt16 port() const;
poco_socklen_t length() const;
const struct sockaddr* addr() const;
int af() const;
Family family() const;
const char* path() const;
std::string toString() const;
private:
struct sockaddr_un* _pAddr;
// Note: We allocate struct sockaddr_un on the heap, otherwise we would
// waste a lot of memory due to small object optimization in SocketAddress.
};
//
// inlines
//
inline IPAddress LocalSocketAddressImpl::host() const
{
throw Poco::InvalidAccessException("local socket address does not have host IP address");
}
inline UInt16 LocalSocketAddressImpl::port() const
{
throw Poco::InvalidAccessException("local socket address does not have port number");
}
inline poco_socklen_t LocalSocketAddressImpl::length() const
{
return sizeof(struct sockaddr_un);
}
inline const struct sockaddr* LocalSocketAddressImpl::addr() const
{
return reinterpret_cast<const struct sockaddr*>(_pAddr);
}
inline int LocalSocketAddressImpl::af() const
{
return _pAddr->sun_family;
}
inline SocketAddressImpl::Family LocalSocketAddressImpl::family() const
{
return AddressFamily::UNIX_LOCAL;
}
inline const char* LocalSocketAddressImpl::path() const
{
return _pAddr->sun_path;
}
#endif // POCO_OS_FAMILY_UNIX
} } } // namespace Poco::Net::Impl
#endif // Net_SocketAddressImpl_INCLUDED

214
vendor/POCO/Net/include/Poco/Net/SocketConnector.h vendored Normal file
View File

@ -0,0 +1,214 @@
//
// SocketConnector.h
//
// Library: Net
// Package: Reactor
// Module: SocketConnector
//
// Definition of the SocketConnector class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketConnector_INCLUDED
#define Net_SocketConnector_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketNotification.h"
#include "Poco/Net/SocketReactor.h"
#include "Poco/Net/ParallelSocketAcceptor.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Observer.h"
namespace Poco {
namespace Net {
template <class ServiceHandler>
class SocketConnector
/// This class implements the Connector part of the
/// Acceptor-Connector design pattern.
///
/// The Acceptor-Connector pattern has been described in the book
/// "Pattern Languages of Program Design 3", edited by Robert Martin,
/// Frank Buschmann and Dirk Riehle (Addison Wesley, 1997).
///
/// The Acceptor-Connector design pattern decouples connection
/// establishment and service initialization in a distributed system
/// from the processing performed once a service is initialized.
/// This decoupling is achieved with three components: Acceptors,
/// Connectors and Service Handlers.
/// The Connector actively establishes a connection with a remote
/// server socket (usually managed by an Acceptor) and initializes
/// a Service Handler to manage the connection.
///
/// The SocketConnector sets up a StreamSocket, initiates a non-blocking
/// connect operation and registers itself for ReadableNotification, WritableNotification
/// and ErrorNotification. ReadableNotification or WritableNotification denote the successful
/// establishment of the connection.
///
/// When the StreamSocket becomes readable or writeable, the SocketConnector
/// creates a ServiceHandler to service the connection and unregisters
/// itself.
///
/// In case of an error (ErrorNotification), the SocketConnector unregisters itself
/// and calls the onError() method, which can be overridden by subclasses
/// to perform custom error handling.
///
/// The ServiceHandler class must provide a constructor that
/// takes a StreamSocket and a SocketReactor as arguments,
/// e.g.:
/// MyServiceHandler(const StreamSocket& socket, SocketReactor& reactor)
///
/// When the ServiceHandler is done, it must destroy itself.
///
/// Subclasses can override the createServiceHandler() factory method
/// if special steps are necessary to create a ServiceHandler object.
{
public:
explicit SocketConnector(SocketAddress& address):
_pReactor(0)
/// Creates a SocketConnector, using the given Socket.
{
_socket.connectNB(address);
}
SocketConnector(SocketAddress& address, SocketReactor& reactor, bool doRegister = true) :
_pReactor(0)
/// Creates an acceptor, using the given ServerSocket.
/// The SocketConnector registers itself with the given SocketReactor.
{
_socket.connectNB(address);
if (doRegister) registerConnector(reactor);
}
virtual ~SocketConnector()
/// Destroys the SocketConnector.
{
try
{
unregisterConnector();
}
catch (...)
{
poco_unexpected();
}
}
virtual void registerConnector(SocketReactor& reactor)
/// Registers the SocketConnector with a SocketReactor.
///
/// A subclass can override this and, for example, also register
/// an event handler for a timeout event.
///
/// The overriding method must call the baseclass implementation first.
{
_pReactor = &reactor;
_pReactor->addEventHandler(_socket, Poco::Observer<SocketConnector, ReadableNotification>(*this, &SocketConnector::onReadable));
_pReactor->addEventHandler(_socket, Poco::Observer<SocketConnector, WritableNotification>(*this, &SocketConnector::onWritable));
_pReactor->addEventHandler(_socket, Poco::Observer<SocketConnector, ErrorNotification>(*this, &SocketConnector::onError));
}
virtual void unregisterConnector()
/// Unregisters the SocketConnector.
///
/// A subclass can override this and, for example, also unregister
/// its event handler for a timeout event.
///
/// The overriding method must call the baseclass implementation first.
{
if (_pReactor)
{
_pReactor->removeEventHandler(_socket, Poco::Observer<SocketConnector, ReadableNotification>(*this, &SocketConnector::onReadable));
_pReactor->removeEventHandler(_socket, Poco::Observer<SocketConnector, WritableNotification>(*this, &SocketConnector::onWritable));
_pReactor->removeEventHandler(_socket, Poco::Observer<SocketConnector, ErrorNotification>(*this, &SocketConnector::onError));
}
}
void onReadable(ReadableNotification* pNotification)
{
pNotification->release();
int err = _socket.impl()->socketError();
if (err)
{
onError(err);
unregisterConnector();
}
else
{
onConnect();
}
}
void onWritable(WritableNotification* pNotification)
{
pNotification->release();
onConnect();
}
void onConnect()
{
_socket.setBlocking(true);
createServiceHandler();
unregisterConnector();
}
void onError(ErrorNotification* pNotification)
{
pNotification->release();
onError(_socket.impl()->socketError());
unregisterConnector();
}
protected:
virtual ServiceHandler* createServiceHandler()
/// Create and initialize a new ServiceHandler instance.
///
/// Subclasses can override this method.
{
return new ServiceHandler(_socket, *_pReactor);
}
virtual void onError(int errorCode)
/// Called when the socket cannot be connected.
///
/// Subclasses can override this method.
{
}
SocketReactor* reactor()
/// Returns a pointer to the SocketReactor where
/// this SocketConnector is registered.
///
/// The pointer may be null.
{
return _pReactor;
}
StreamSocket& socket()
/// Returns a reference to the SocketConnector's socket.
{
return _socket;
}
private:
SocketConnector();
SocketConnector(const SocketConnector&);
SocketConnector& operator = (const SocketConnector&);
StreamSocket _socket;
SocketReactor* _pReactor;
};
} } // namespace Poco::Net
#endif // Net_SocketConnector_INCLUDED

391
vendor/POCO/Net/include/Poco/Net/SocketDefs.h vendored Normal file
View File

@ -0,0 +1,391 @@
//
// SocketDefs.h
//
// Library: Net
// Package: NetCore
// Module: SocketDefs
//
// Include platform-specific header files for sockets.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketDefs_INCLUDED
#define Net_SocketDefs_INCLUDED
#include <vector>
#define POCO_ENOERR 0
#if defined(POCO_OS_FAMILY_WINDOWS)
#include "Poco/UnWindows.h"
#include <winsock2.h>
#include <ws2tcpip.h>
#include <ws2def.h>
#define POCO_INVALID_SOCKET INVALID_SOCKET
#define poco_socket_t SOCKET
#define poco_socklen_t int
#define poco_ioctl_request_t int
#define poco_closesocket(s) closesocket(s)
#define POCO_EINTR WSAEINTR
#define POCO_EACCES WSAEACCES
#define POCO_EFAULT WSAEFAULT
#define POCO_EINVAL WSAEINVAL
#define POCO_EMFILE WSAEMFILE
#define POCO_EAGAIN WSAEWOULDBLOCK
#define POCO_EWOULDBLOCK WSAEWOULDBLOCK
#define POCO_EINPROGRESS WSAEINPROGRESS
#define POCO_EALREADY WSAEALREADY
#define POCO_ENOTSOCK WSAENOTSOCK
#define POCO_EDESTADDRREQ WSAEDESTADDRREQ
#define POCO_EMSGSIZE WSAEMSGSIZE
#define POCO_EPROTOTYPE WSAEPROTOTYPE
#define POCO_ENOPROTOOPT WSAENOPROTOOPT
#define POCO_EPROTONOSUPPORT WSAEPROTONOSUPPORT
#define POCO_ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
#define POCO_ENOTSUP WSAEOPNOTSUPP
#define POCO_EPFNOSUPPORT WSAEPFNOSUPPORT
#define POCO_EAFNOSUPPORT WSAEAFNOSUPPORT
#define POCO_EADDRINUSE WSAEADDRINUSE
#define POCO_EADDRNOTAVAIL WSAEADDRNOTAVAIL
#define POCO_ENETDOWN WSAENETDOWN
#define POCO_ENETUNREACH WSAENETUNREACH
#define POCO_ENETRESET WSAENETRESET
#define POCO_ECONNABORTED WSAECONNABORTED
#define POCO_ECONNRESET WSAECONNRESET
#define POCO_ENOBUFS WSAENOBUFS
#define POCO_EISCONN WSAEISCONN
#define POCO_ENOTCONN WSAENOTCONN
#define POCO_ESHUTDOWN WSAESHUTDOWN
#define POCO_ETIMEDOUT WSAETIMEDOUT
#define POCO_ECONNREFUSED WSAECONNREFUSED
#define POCO_EHOSTDOWN WSAEHOSTDOWN
#define POCO_EHOSTUNREACH WSAEHOSTUNREACH
#define POCO_ESYSNOTREADY WSASYSNOTREADY
#define POCO_ENOTINIT WSANOTINITIALISED
#define POCO_HOST_NOT_FOUND WSAHOST_NOT_FOUND
#define POCO_TRY_AGAIN WSATRY_AGAIN
#define POCO_NO_RECOVERY WSANO_RECOVERY
#define POCO_NO_DATA WSANO_DATA
#ifndef ADDRESS_FAMILY
#define ADDRESS_FAMILY USHORT
#endif
#elif defined(POCO_VXWORKS)
#include <hostLib.h>
#include <ifLib.h>
#include <inetLib.h>
#include <ioLib.h>
#include <resolvLib.h>
#include <types.h>
#include <socket.h>
#include <netinet/tcp.h>
#define POCO_INVALID_SOCKET -1
#define poco_socket_t int
#define poco_socklen_t int
#define poco_ioctl_request_t int
#define poco_closesocket(s) ::close(s)
#define POCO_EINTR EINTR
#define POCO_EACCES EACCES
#define POCO_EFAULT EFAULT
#define POCO_EINVAL EINVAL
#define POCO_EMFILE EMFILE
#define POCO_EAGAIN EAGAIN
#define POCO_EWOULDBLOCK EWOULDBLOCK
#define POCO_EINPROGRESS EINPROGRESS
#define POCO_EALREADY EALREADY
#define POCO_ENOTSOCK ENOTSOCK
#define POCO_EDESTADDRREQ EDESTADDRREQ
#define POCO_EMSGSIZE EMSGSIZE
#define POCO_EPROTOTYPE EPROTOTYPE
#define POCO_ENOPROTOOPT ENOPROTOOPT
#define POCO_EPROTONOSUPPORT EPROTONOSUPPORT
#define POCO_ESOCKTNOSUPPORT ESOCKTNOSUPPORT
#define POCO_ENOTSUP ENOTSUP
#define POCO_EPFNOSUPPORT EPFNOSUPPORT
#define POCO_EAFNOSUPPORT EAFNOSUPPORT
#define POCO_EADDRINUSE EADDRINUSE
#define POCO_EADDRNOTAVAIL EADDRNOTAVAIL
#define POCO_ENETDOWN ENETDOWN
#define POCO_ENETUNREACH ENETUNREACH
#define POCO_ENETRESET ENETRESET
#define POCO_ECONNABORTED ECONNABORTED
#define POCO_ECONNRESET ECONNRESET
#define POCO_ENOBUFS ENOBUFS
#define POCO_EISCONN EISCONN
#define POCO_ENOTCONN ENOTCONN
#define POCO_ESHUTDOWN ESHUTDOWN
#define POCO_ETIMEDOUT ETIMEDOUT
#define POCO_ECONNREFUSED ECONNREFUSED
#define POCO_EHOSTDOWN EHOSTDOWN
#define POCO_EHOSTUNREACH EHOSTUNREACH
#define POCO_ESYSNOTREADY -4
#define POCO_ENOTINIT -5
#define POCO_HOST_NOT_FOUND HOST_NOT_FOUND
#define POCO_TRY_AGAIN TRY_AGAIN
#define POCO_NO_RECOVERY NO_RECOVERY
#define POCO_NO_DATA NO_DATA
#elif defined(POCO_OS_FAMILY_UNIX)
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/uio.h>
#include <fcntl.h>
#if POCO_OS != POCO_OS_HPUX
#include <sys/select.h>
#endif
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netdb.h>
#if defined(POCO_OS_FAMILY_UNIX)
#if (POCO_OS == POCO_OS_LINUX) || (POCO_OS == POCO_OS_ANDROID)
// Net/src/NetworkInterface.cpp changed #include <linux/if.h> to #include <net/if.h>
// no more conflict, can use #include <net/if.h> here
#include <net/if.h>
#elif (POCO_OS == POCO_OS_HPUX)
extern "C"
{
#include <net/if.h>
}
#else
#include <net/if.h>
#endif
#endif
#if (POCO_OS == POCO_OS_SOLARIS) || (POCO_OS == POCO_OS_MAC_OS_X)
#include <sys/sockio.h>
#include <sys/filio.h>
#endif
#define POCO_INVALID_SOCKET -1
#define poco_socket_t int
#define poco_socklen_t socklen_t
#define poco_fcntl_request_t int
#if defined(POCO_OS_FAMILY_BSD)
#define poco_ioctl_request_t unsigned long
#else
#define poco_ioctl_request_t int
#endif
#define poco_closesocket(s) ::close(s)
#define POCO_EINTR EINTR
#define POCO_EACCES EACCES
#define POCO_EFAULT EFAULT
#define POCO_EINVAL EINVAL
#define POCO_EMFILE EMFILE
#define POCO_EAGAIN EAGAIN
#define POCO_EWOULDBLOCK EWOULDBLOCK
#define POCO_EINPROGRESS EINPROGRESS
#define POCO_EALREADY EALREADY
#define POCO_ENOTSOCK ENOTSOCK
#define POCO_EDESTADDRREQ EDESTADDRREQ
#define POCO_EMSGSIZE EMSGSIZE
#define POCO_EPROTOTYPE EPROTOTYPE
#define POCO_ENOPROTOOPT ENOPROTOOPT
#define POCO_EPROTONOSUPPORT EPROTONOSUPPORT
#if defined(ESOCKTNOSUPPORT)
#define POCO_ESOCKTNOSUPPORT ESOCKTNOSUPPORT
#else
#define POCO_ESOCKTNOSUPPORT -1
#endif
#define POCO_ENOTSUP ENOTSUP
#define POCO_EPFNOSUPPORT EPFNOSUPPORT
#define POCO_EAFNOSUPPORT EAFNOSUPPORT
#define POCO_EADDRINUSE EADDRINUSE
#define POCO_EADDRNOTAVAIL EADDRNOTAVAIL
#define POCO_ENETDOWN ENETDOWN
#define POCO_ENETUNREACH ENETUNREACH
#define POCO_ENETRESET ENETRESET
#define POCO_ECONNABORTED ECONNABORTED
#define POCO_ECONNRESET ECONNRESET
#define POCO_ENOBUFS ENOBUFS
#define POCO_EISCONN EISCONN
#define POCO_ENOTCONN ENOTCONN
#if defined(ESHUTDOWN)
#define POCO_ESHUTDOWN ESHUTDOWN
#else
#define POCO_ESHUTDOWN -2
#endif
#define POCO_ETIMEDOUT ETIMEDOUT
#define POCO_ECONNREFUSED ECONNREFUSED
#if defined(EHOSTDOWN)
#define POCO_EHOSTDOWN EHOSTDOWN
#else
#define POCO_EHOSTDOWN -3
#endif
#define POCO_EHOSTUNREACH EHOSTUNREACH
#define POCO_ESYSNOTREADY -4
#define POCO_ENOTINIT -5
#define POCO_HOST_NOT_FOUND HOST_NOT_FOUND
#define POCO_TRY_AGAIN TRY_AGAIN
#define POCO_NO_RECOVERY NO_RECOVERY
#define POCO_NO_DATA NO_DATA
#endif
#if defined(POCO_OS_FAMILY_BSD) || (POCO_OS == POCO_OS_TRU64) || (POCO_OS == POCO_OS_AIX) || (POCO_OS == POCO_OS_IRIX) || (POCO_OS == POCO_OS_QNX) || (POCO_OS == POCO_OS_VXWORKS)
#define POCO_HAVE_SALEN 1
#endif
#if POCO_OS != POCO_OS_VXWORKS && !defined(POCO_NET_NO_ADDRINFO)
#define POCO_HAVE_ADDRINFO 1
#endif
#if (POCO_OS == POCO_OS_HPUX) || (POCO_OS == POCO_OS_SOLARIS) || (POCO_OS == POCO_OS_WINDOWS_CE) || (POCO_OS == POCO_OS_CYGWIN)
#define POCO_BROKEN_TIMEOUTS 1
#endif
#if defined(POCO_HAVE_ADDRINFO)
#ifndef AI_PASSIVE
#define AI_PASSIVE 0
#endif
#ifndef AI_CANONNAME
#define AI_CANONNAME 0
#endif
#ifndef AI_NUMERICHOST
#define AI_NUMERICHOST 0
#endif
#ifndef AI_NUMERICSERV
#define AI_NUMERICSERV 0
#endif
#ifndef AI_ALL
#define AI_ALL 0
#endif
#ifndef AI_ADDRCONFIG
#define AI_ADDRCONFIG 0
#endif
#ifndef AI_V4MAPPED
#define AI_V4MAPPED 0
#endif
#endif
#if defined(POCO_HAVE_SALEN)
#define poco_set_sa_len(pSA, len) (pSA)->sa_len = (len)
#define poco_set_sin_len(pSA) (pSA)->sin_len = sizeof(struct sockaddr_in)
#if defined(POCO_HAVE_IPv6)
#define poco_set_sin6_len(pSA) (pSA)->sin6_len = sizeof(struct sockaddr_in6)
#endif
#if defined(POCO_OS_FAMILY_UNIX)
#define poco_set_sun_len(pSA, len) (pSA)->sun_len = (len)
#endif
#else
#define poco_set_sa_len(pSA, len) (void) 0
#define poco_set_sin_len(pSA) (void) 0
#define poco_set_sin6_len(pSA) (void) 0
#define poco_set_sun_len(pSA, len) (void) 0
#endif
#ifndef INADDR_NONE
#define INADDR_NONE 0xffffffff
#endif
#ifndef INADDR_ANY
#define INADDR_ANY 0x00000000
#endif
#ifndef INADDR_BROADCAST
#define INADDR_BROADCAST 0xffffffff
#endif
#ifndef INADDR_LOOPBACK
#define INADDR_LOOPBACK 0x7f000001
#endif
#ifndef INADDR_UNSPEC_GROUP
#define INADDR_UNSPEC_GROUP 0xe0000000
#endif
#ifndef INADDR_ALLHOSTS_GROUP
#define INADDR_ALLHOSTS_GROUP 0xe0000001
#endif
#ifndef INADDR_ALLRTRS_GROUP
#define INADDR_ALLRTRS_GROUP 0xe0000002
#endif
#ifndef INADDR_MAX_LOCAL_GROUP
#define INADDR_MAX_LOCAL_GROUP 0xe00000ff
#endif
#if defined(POCO_ARCH_BIG_ENDIAN)
#define poco_ntoh_16(x) (x)
#define poco_ntoh_32(x) (x)
#else
#define poco_ntoh_16(x) \
((((x) >> 8) & 0x00ff) | (((x) << 8) & 0xff00))
#define poco_ntoh_32(x) \
((((x) >> 24) & 0x000000ff) | (((x) >> 8) & 0x0000ff00) | (((x) << 8) & 0x00ff0000) | (((x) << 24) & 0xff000000))
#endif
#define poco_hton_16(x) poco_ntoh_16(x)
#define poco_hton_32(x) poco_ntoh_32(x)
#if !defined(s6_addr16)
#if defined(POCO_OS_FAMILY_WINDOWS)
#define s6_addr16 u.Word
#else
#define s6_addr16 __u6_addr.__u6_addr16
#endif
#endif
#if !defined(s6_addr32)
#if defined(POCO_OS_FAMILY_UNIX)
#if (POCO_OS == POCO_OS_SOLARIS)
#define s6_addr32 _S6_un._S6_u32
#else
#define s6_addr32 __u6_addr.__u6_addr32
#endif
#endif
#endif
namespace Poco {
namespace Net {
#if defined(POCO_OS_FAMILY_WINDOWS)
typedef WSABUF SocketBuf;
#elif defined(POCO_OS_FAMILY_UNIX) // TODO: may need more refinement
typedef iovec SocketBuf;
#endif
typedef std::vector<SocketBuf> SocketBufVec;
struct AddressFamily
/// AddressFamily::Family replaces the previously used IPAddress::Family
/// enumeration and is now used for IPAddress::Family and SocketAddress::Family.
{
enum Family
/// Possible address families for socket addresses.
{
IPv4,
/// IPv4 address family.
#if defined(POCO_HAVE_IPv6)
IPv6,
/// IPv6 address family.
#endif
#if defined(POCO_OS_FAMILY_UNIX)
UNIX_LOCAL
/// UNIX domain socket address family. Available on UNIX/POSIX platforms only.
#endif
};
};
} } // namespace Poco::Net
#endif // Net_SocketDefs_INCLUDED

560
vendor/POCO/Net/include/Poco/Net/SocketImpl.h vendored Normal file
View File

@ -0,0 +1,560 @@
//
// SocketImpl.h
//
// Library: Net
// Package: Sockets
// Module: SocketImpl
//
// Definition of the SocketImpl class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketImpl_INCLUDED
#define Net_SocketImpl_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/SocketDefs.h"
#include "Poco/Net/SocketAddress.h"
#include "Poco/RefCountedObject.h"
#include "Poco/Timespan.h"
#include "Poco/Buffer.h"
namespace Poco {
namespace Net {
class Net_API SocketImpl: public Poco::RefCountedObject
/// This class encapsulates the Berkeley sockets API.
///
/// Subclasses implement specific socket types like
/// stream or datagram sockets.
///
/// You should not create any instances of this class.
{
public:
enum SelectMode
{
SELECT_READ = 1,
SELECT_WRITE = 2,
SELECT_ERROR = 4
};
virtual SocketImpl* acceptConnection(SocketAddress& clientAddr);
/// Get the next completed connection from the
/// socket's completed connection queue.
///
/// If the queue is empty, waits until a connection
/// request completes.
///
/// Returns a new TCP socket for the connection
/// with the client.
///
/// The client socket's address is returned in clientAddr.
virtual void connect(const SocketAddress& address);
/// Initializes the socket and establishes a connection to
/// the TCP server at the given address.
///
/// Can also be used for UDP sockets. In this case, no
/// connection is established. Instead, incoming and outgoing
/// packets are restricted to the specified address.
virtual void connect(const SocketAddress& address, const Poco::Timespan& timeout);
/// Initializes the socket, sets the socket timeout and
/// establishes a connection to the TCP server at the given address.
virtual void connectNB(const SocketAddress& address);
/// Initializes the socket and establishes a connection to
/// the TCP server at the given address. Prior to opening the
/// connection the socket is set to nonblocking mode.
virtual void bind(const SocketAddress& address, bool reuseAddress = false);
/// Bind a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort );
/// Bind a local address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reusePort is true, sets the SO_REUSEPORT
/// socket option.
virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
/// Bind a local IPv6 address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// The given address must be an IPv6 address. The
/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
/// according to the ipV6Only parameter.
///
/// If the library has not been built with IPv6 support,
/// a Poco::NotImplementedException will be thrown.
virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only);
/// Bind a local IPv6 address to the socket.
///
/// This is usually only done when establishing a server
/// socket. TCP clients should not bind a socket to a
/// specific address.
///
/// If reuseAddress is true, sets the SO_REUSEADDR
/// socket option.
///
/// If reusePort is true, sets the SO_REUSEPORT
/// socket option.
///
/// The given address must be an IPv6 address. The
/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
/// according to the ipV6Only parameter.
///
/// If the library has not been built with IPv6 support,
/// a Poco::NotImplementedException will be thrown.
virtual void listen(int backlog = 64);
/// Puts the socket into listening state.
///
/// The socket becomes a passive socket that
/// can accept incoming connection requests.
///
/// The backlog argument specifies the maximum
/// number of connections that can be queued
/// for this socket.
virtual void close();
/// Close the socket.
virtual void shutdownReceive();
/// Shuts down the receiving part of the socket connection.
virtual void shutdownSend();
/// Shuts down the sending part of the socket connection.
virtual void shutdown();
/// Shuts down both the receiving and the sending part
/// of the socket connection.
virtual int sendBytes(const void* buffer, int length, int flags = 0);
/// Sends the contents of the given buffer through
/// the socket.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
///
/// Certain socket implementations may also return a negative
/// value denoting a certain condition.
virtual int sendBytes(const SocketBufVec& buffers, int flags = 0);
/// Receives data from the socket and stores it in buffers.
///
/// Returns the number of bytes received.
///
/// Always returns zero for platforms where not implemented.
virtual int receiveBytes(void* buffer, int length, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
///
/// Returns the number of bytes received.
///
/// Certain socket implementations may also return a negative
/// value denoting a certain condition.
virtual int receiveBytes(SocketBufVec& buffers, int flags = 0);
/// Receives data from the socket and stores it in buffers.
///
/// Returns the number of bytes received.
///
/// Always returns zero for platforms where not implemented.
virtual int receiveBytes(Poco::Buffer<char>& buffer, int flags = 0, const Poco::Timespan& timeout = 100000);
/// Receives data from the socket and stores it in the buffer.
/// If needed, the buffer will be resized to accomodate the
/// data. Note that this function may impose additional
/// performance penalties due to the check for the available
/// amount of data.
///
/// Returns the number of bytes received.
virtual int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
/// Sends the contents of the given buffer through
/// the socket to the given address.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
virtual int sendTo(const SocketBufVec& buffers, const SocketAddress& address, int flags = 0);
/// Sends the contents of the buffers through
/// the socket to the given address.
///
/// Returns the number of bytes sent, which may be
/// less than the number of bytes specified.
///
/// Always returns zero for platforms where not implemented.
int receiveFrom(void* buffer, int length, struct sockaddr** ppSA, poco_socklen_t** ppSALen, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
/// Stores the native address of the sender in
/// ppSA, and the length of native address in ppSALen.
///
/// Returns the number of bytes received.
virtual int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
/// Receives data from the socket and stores it
/// in buffer. Up to length bytes are received.
/// Stores the address of the sender in address.
///
/// Returns the number of bytes received.
virtual int receiveFrom(SocketBufVec& buffers, SocketAddress& address, int flags = 0);
/// Receives data from the socket and stores it
/// in buffers.
/// Stores the address of the sender in address.
///
/// Returns the number of bytes received.
///
/// Always returns zero for platforms where not implemented.
int receiveFrom(SocketBufVec& buffers, struct sockaddr** ppSA, poco_socklen_t** ppSALen, int flags);
/// Receives data from the socket and stores it
/// in buffers.
/// Stores the native address of the sender in
/// ppSA, and the length of native address in ppSALen.
///
/// Returns the number of bytes received.
virtual void sendUrgent(unsigned char data);
/// Sends one byte of urgent data through
/// the socket.
///
/// The data is sent with the MSG_OOB flag.
///
/// The preferred way for a socket to receive urgent data
/// is by enabling the SO_OOBINLINE option.
virtual int available();
/// Returns the number of bytes available that can be read
/// without causing the socket to block.
virtual bool poll(const Poco::Timespan& timeout, int mode);
/// Determines the status of the socket, using a
/// call to select().
///
/// The mode argument is constructed by combining the values
/// of the SelectMode enumeration.
///
/// Returns true if the next operation corresponding to
/// mode will not block, false otherwise.
virtual void setSendBufferSize(int size);
/// Sets the size of the send buffer.
virtual int getSendBufferSize();
/// Returns the size of the send buffer.
///
/// The returned value may be different than the
/// value previously set with setSendBufferSize(),
/// as the system is free to adjust the value.
virtual void setReceiveBufferSize(int size);
/// Sets the size of the receive buffer.
virtual int getReceiveBufferSize();
/// Returns the size of the receive buffer.
///
/// The returned value may be different than the
/// value previously set with setReceiveBufferSize(),
/// as the system is free to adjust the value.
virtual void setSendTimeout(const Poco::Timespan& timeout);
/// Sets the send timeout for the socket.
virtual Poco::Timespan getSendTimeout();
/// Returns the send timeout for the socket.
///
/// The returned timeout may be different than the
/// timeout previously set with setSendTimeout(),
/// as the system is free to adjust the value.
virtual void setReceiveTimeout(const Poco::Timespan& timeout);
/// Sets the receive timeout for the socket.
///
/// On systems that do not support SO_RCVTIMEO, a
/// workaround using poll() is provided.
virtual Poco::Timespan getReceiveTimeout();
/// Returns the receive timeout for the socket.
///
/// The returned timeout may be different than the
/// timeout previously set with setReceiveTimeout(),
/// as the system is free to adjust the value.
virtual SocketAddress address();
/// Returns the IP address and port number of the socket.
virtual SocketAddress peerAddress();
/// Returns the IP address and port number of the peer socket.
void setOption(int level, int option, int value);
/// Sets the socket option specified by level and option
/// to the given integer value.
void setOption(int level, int option, unsigned value);
/// Sets the socket option specified by level and option
/// to the given integer value.
void setOption(int level, int option, unsigned char value);
/// Sets the socket option specified by level and option
/// to the given integer value.
void setOption(int level, int option, const Poco::Timespan& value);
/// Sets the socket option specified by level and option
/// to the given time value.
void setOption(int level, int option, const IPAddress& value);
/// Sets the socket option specified by level and option
/// to the given time value.
virtual void setRawOption(int level, int option, const void* value, poco_socklen_t length);
/// Sets the socket option specified by level and option
/// to the given time value.
void getOption(int level, int option, int& value);
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, unsigned& value);
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, unsigned char& value);
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, Poco::Timespan& value);
/// Returns the value of the socket option
/// specified by level and option.
void getOption(int level, int option, IPAddress& value);
/// Returns the value of the socket option
/// specified by level and option.
virtual void getRawOption(int level, int option, void* value, poco_socklen_t& length);
/// Returns the value of the socket option
/// specified by level and option.
void setLinger(bool on, int seconds);
/// Sets the value of the SO_LINGER socket option.
void getLinger(bool& on, int& seconds);
/// Returns the value of the SO_LINGER socket option.
void setNoDelay(bool flag);
/// Sets the value of the TCP_NODELAY socket option.
bool getNoDelay();
/// Returns the value of the TCP_NODELAY socket option.
void setKeepAlive(bool flag);
/// Sets the value of the SO_KEEPALIVE socket option.
bool getKeepAlive();
/// Returns the value of the SO_KEEPALIVE socket option.
void setReuseAddress(bool flag);
/// Sets the value of the SO_REUSEADDR socket option.
bool getReuseAddress();
/// Returns the value of the SO_REUSEADDR socket option.
void setReusePort(bool flag);
/// Sets the value of the SO_REUSEPORT socket option.
/// Does nothing if the socket implementation does not
/// support SO_REUSEPORT.
bool getReusePort();
/// Returns the value of the SO_REUSEPORT socket option.
///
/// Returns false if the socket implementation does not
/// support SO_REUSEPORT.
void setOOBInline(bool flag);
/// Sets the value of the SO_OOBINLINE socket option.
bool getOOBInline();
/// Returns the value of the SO_OOBINLINE socket option.
void setBroadcast(bool flag);
/// Sets the value of the SO_BROADCAST socket option.
bool getBroadcast();
/// Returns the value of the SO_BROADCAST socket option.
virtual void setBlocking(bool flag);
/// Sets the socket in blocking mode if flag is true,
/// disables blocking mode if flag is false.
virtual bool getBlocking() const;
/// Returns the blocking mode of the socket.
/// This method will only work if the blocking modes of
/// the socket are changed via the setBlocking method!
virtual bool secure() const;
/// Returns true iff the socket's connection is secure
/// (using SSL or TLS).
int socketError();
/// Returns the value of the SO_ERROR socket option.
poco_socket_t sockfd() const;
/// Returns the socket descriptor for the
/// underlying native socket.
void ioctl(poco_ioctl_request_t request, int& arg);
/// A wrapper for the ioctl system call.
void ioctl(poco_ioctl_request_t request, void* arg);
/// A wrapper for the ioctl system call.
#if defined(POCO_OS_FAMILY_UNIX)
int fcntl(poco_fcntl_request_t request);
/// A wrapper for the fcntl system call.
int fcntl(poco_fcntl_request_t request, long arg);
/// A wrapper for the fcntl system call.
#endif
bool initialized() const;
/// Returns true iff the underlying socket is initialized.
protected:
SocketImpl();
/// Creates a SocketImpl.
SocketImpl(poco_socket_t sockfd);
/// Creates a SocketImpl using the given native socket.
virtual ~SocketImpl();
/// Destroys the SocketImpl.
/// Closes the socket if it is still open.
virtual void init(int af);
/// Creates the underlying native socket.
///
/// Subclasses must implement this method so
/// that it calls initSocket() with the
/// appropriate arguments.
///
/// The default implementation creates a
/// stream socket.
void initSocket(int af, int type, int proto = 0);
/// Creates the underlying native socket.
///
/// The first argument, af, specifies the address family
/// used by the socket, which should be either AF_INET or
/// AF_INET6.
///
/// The second argument, type, specifies the type of the
/// socket, which can be one of SOCK_STREAM, SOCK_DGRAM
/// or SOCK_RAW.
///
/// The third argument, proto, is normally set to 0,
/// except for raw sockets.
void reset(poco_socket_t fd = POCO_INVALID_SOCKET);
/// Allows subclasses to set the socket manually, iff no valid socket is set yet.
void checkBrokenTimeout(SelectMode mode);
static int lastError();
/// Returns the last error code.
static void error();
/// Throws an appropriate exception for the last error.
static void error(const std::string& arg);
/// Throws an appropriate exception for the last error.
static void error(int code);
/// Throws an appropriate exception for the given error code.
static void error(int code, const std::string& arg);
/// Throws an appropriate exception for the given error code.
private:
SocketImpl(const SocketImpl&);
SocketImpl& operator = (const SocketImpl&);
poco_socket_t _sockfd;
Poco::Timespan _recvTimeout;
Poco::Timespan _sndTimeout;
bool _blocking;
bool _isBrokenTimeout;
friend class Socket;
friend class SecureSocketImpl;
friend class PollSetImpl;
};
//
// inlines
//
inline poco_socket_t SocketImpl::sockfd() const
{
return _sockfd;
}
inline bool SocketImpl::initialized() const
{
return _sockfd != POCO_INVALID_SOCKET;
}
inline int SocketImpl::lastError()
{
#if defined(_WIN32)
return WSAGetLastError();
#else
return errno;
#endif
}
inline bool SocketImpl::getBlocking() const
{
return _blocking;
}
} } // namespace Poco::Net
#endif // Net_SocketImpl_INCLUDED

153
vendor/POCO/Net/include/Poco/Net/SocketNotification.h vendored Normal file
View File

@ -0,0 +1,153 @@
//
// SocketNotification.h
//
// Library: Net
// Package: Reactor
// Module: SocketNotification
//
// Definition of the SocketNotification class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketNotification_INCLUDED
#define Net_SocketNotification_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/Socket.h"
#include "Poco/Notification.h"
namespace Poco {
namespace Net {
class SocketReactor;
class Net_API SocketNotification: public Poco::Notification
/// The base class for all notifications generated by
/// the SocketReactor.
{
public:
explicit SocketNotification(SocketReactor* pReactor);
/// Creates the SocketNotification for the given SocketReactor.
virtual ~SocketNotification();
/// Destroys the SocketNotification.
SocketReactor& source() const;
/// Returns the SocketReactor that generated the notification.
Socket socket() const;
/// Returns the socket that caused the notification.
private:
void setSocket(const Socket& socket);
SocketReactor* _pReactor;
Socket _socket;
friend class SocketNotifier;
};
class Net_API ReadableNotification: public SocketNotification
/// This notification is sent if a socket has become readable.
{
public:
ReadableNotification(SocketReactor* pReactor);
/// Creates the ReadableNotification for the given SocketReactor.
~ReadableNotification();
/// Destroys the ReadableNotification.
};
class Net_API WritableNotification: public SocketNotification
/// This notification is sent if a socket has become writable.
{
public:
WritableNotification(SocketReactor* pReactor);
/// Creates the WritableNotification for the given SocketReactor.
~WritableNotification();
/// Destroys the WritableNotification.
};
class Net_API ErrorNotification: public SocketNotification
/// This notification is sent if a socket has signalled an error.
{
public:
ErrorNotification(SocketReactor* pReactor);
/// Creates the ErrorNotification for the given SocketReactor.
~ErrorNotification();
/// Destroys the ErrorNotification.
};
class Net_API TimeoutNotification: public SocketNotification
/// This notification is sent if no other event has occurred
/// for a specified time.
{
public:
TimeoutNotification(SocketReactor* pReactor);
/// Creates the TimeoutNotification for the given SocketReactor.
~TimeoutNotification();
/// Destroys the TimeoutNotification.
};
class Net_API IdleNotification: public SocketNotification
/// This notification is sent when the SocketReactor does
/// not have any sockets to react to.
{
public:
IdleNotification(SocketReactor* pReactor);
/// Creates the IdleNotification for the given SocketReactor.
~IdleNotification();
/// Destroys the IdleNotification.
};
class Net_API ShutdownNotification: public SocketNotification
/// This notification is sent when the SocketReactor is
/// about to shut down.
{
public:
ShutdownNotification(SocketReactor* pReactor);
/// Creates the ShutdownNotification for the given SocketReactor.
~ShutdownNotification();
/// Destroys the ShutdownNotification.
};
//
// inlines
//
inline SocketReactor& SocketNotification::source() const
{
return *_pReactor;
}
inline Socket SocketNotification::socket() const
{
return _socket;
}
} } // namespace Poco::Net
#endif // Net_SocketNotification_INCLUDED

114
vendor/POCO/Net/include/Poco/Net/SocketNotifier.h vendored Normal file
View File

@ -0,0 +1,114 @@
//
// SocketNotifier.h
//
// Library: Net
// Package: Reactor
// Module: SocketNotifier
//
// Definition of the SocketNotifier class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Net_SocketNotifier_INCLUDED
#define Net_SocketNotifier_INCLUDED
#include "Poco/Net/Net.h"
#include "Poco/Net/Socket.h"
#include "Poco/RefCountedObject.h"
#include "Poco/NotificationCenter.h"
#include "Poco/Observer.h"
#include <set>
namespace Poco {
namespace Net {
class Socket;
class SocketReactor;
class SocketNotification;
class Net_API SocketNotifier: public Poco::RefCountedObject
/// This class is used internally by SocketReactor
/// to notify registered event handlers of socket events.
{
public:
explicit SocketNotifier(const Socket& socket);
/// Creates the SocketNotifier for the given socket.
void addObserver(SocketReactor* pReactor, const Poco::AbstractObserver& observer);
/// Adds the given observer.
void removeObserver(SocketReactor* pReactor, const Poco::AbstractObserver& observer);
/// Removes the given observer.
bool hasObserver(const Poco::AbstractObserver& observer) const;
/// Returns true if the given observer is registered.
bool accepts(SocketNotification* pNotification);
/// Returns true if there is at least one observer for the given notification.
void dispatch(SocketNotification* pNotification);
/// Dispatches the notification to all observers.
bool hasObservers() const;
/// Returns true if there are subscribers.
std::size_t countObservers() const;
/// Returns the number of subscribers;
protected:
~SocketNotifier();
/// Destroys the SocketNotifier.
private:
typedef std::multiset<SocketNotification*> EventSet;
typedef Poco::FastMutex MutexType;
typedef MutexType::ScopedLock ScopedLock;
EventSet _events;
Poco::NotificationCenter _nc;
Socket _socket;
MutexType _mutex;
};
//
// inlines
//
inline bool SocketNotifier::accepts(SocketNotification* pNotification)
{
ScopedLock l(_mutex);
return _events.find(pNotification) != _events.end();
}
inline bool SocketNotifier::hasObserver(const Poco::AbstractObserver& observer) const
{
return _nc.hasObserver(observer);
}
inline bool SocketNotifier::hasObservers() const
{
return _nc.hasObservers();
}
inline std::size_t SocketNotifier::countObservers() const
{
return _nc.countObservers();
}
} } // namespace Poco::Net
#endif // Net_SocketNotifier_INCLUDED

Some files were not shown because too many files have changed in this diff Show More