diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-14 13:21:16 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-14 13:21:16 +0000 |
| commit | 2e582fe0b8b6a8e67982ddb84935db1bd3b401fe (patch) | |
| tree | dd511b321f308264952cffb005a4288ea4e478e6 /library/vendor | |
| parent | Initial commit. (diff) | |
| download | icingaweb2-module-graphite-2e582fe0b8b6a8e67982ddb84935db1bd3b401fe.tar.xz icingaweb2-module-graphite-2e582fe0b8b6a8e67982ddb84935db1bd3b401fe.zip | |
Adding upstream version 1.2.2.upstream/1.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'library/vendor')
20 files changed, 2769 insertions, 0 deletions
diff --git a/library/vendor/Psr/Http/Message/MessageInterface.php b/library/vendor/Psr/Http/Message/MessageInterface.php new file mode 100644 index 0000000..8f67a05 --- /dev/null +++ b/library/vendor/Psr/Http/Message/MessageInterface.php @@ -0,0 +1,187 @@ +<?php + +namespace Psr\Http\Message; + +/** + * HTTP messages consist of requests from a client to a server and responses + * from a server to a client. This interface defines the methods common to + * each. + * + * Messages are considered immutable; all methods that might change state MUST + * be implemented such that they retain the internal state of the current + * message and return an instance that contains the changed state. + * + * @link http://www.ietf.org/rfc/rfc7230.txt + * @link http://www.ietf.org/rfc/rfc7231.txt + */ +interface MessageInterface +{ + /** + * Retrieves the HTTP protocol version as a string. + * + * The string MUST contain only the HTTP version number (e.g., "1.1", "1.0"). + * + * @return string HTTP protocol version. + */ + public function getProtocolVersion(); + + /** + * Return an instance with the specified HTTP protocol version. + * + * The version string MUST contain only the HTTP version number (e.g., + * "1.1", "1.0"). + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * new protocol version. + * + * @param string $version HTTP protocol version + * @return self + */ + public function withProtocolVersion($version); + + /** + * Retrieves all message header values. + * + * The keys represent the header name as it will be sent over the wire, and + * each value is an array of strings associated with the header. + * + * // Represent the headers as a string + * foreach ($message->getHeaders() as $name => $values) { + * echo $name . ": " . implode(", ", $values); + * } + * + * // Emit headers iteratively: + * foreach ($message->getHeaders() as $name => $values) { + * foreach ($values as $value) { + * header(sprintf('%s: %s', $name, $value), false); + * } + * } + * + * While header names are not case-sensitive, getHeaders() will preserve the + * exact case in which headers were originally specified. + * + * @return array Returns an associative array of the message's headers. Each + * key MUST be a header name, and each value MUST be an array of strings + * for that header. + */ + public function getHeaders(); + + /** + * Checks if a header exists by the given case-insensitive name. + * + * @param string $name Case-insensitive header field name. + * @return bool Returns true if any header names match the given header + * name using a case-insensitive string comparison. Returns false if + * no matching header name is found in the message. + */ + public function hasHeader($name); + + /** + * Retrieves a message header value by the given case-insensitive name. + * + * This method returns an array of all the header values of the given + * case-insensitive header name. + * + * If the header does not appear in the message, this method MUST return an + * empty array. + * + * @param string $name Case-insensitive header field name. + * @return string[] An array of string values as provided for the given + * header. If the header does not appear in the message, this method MUST + * return an empty array. + */ + public function getHeader($name); + + /** + * Retrieves a comma-separated string of the values for a single header. + * + * This method returns all of the header values of the given + * case-insensitive header name as a string concatenated together using + * a comma. + * + * NOTE: Not all header values may be appropriately represented using + * comma concatenation. For such headers, use getHeader() instead + * and supply your own delimiter when concatenating. + * + * If the header does not appear in the message, this method MUST return + * an empty string. + * + * @param string $name Case-insensitive header field name. + * @return string A string of values as provided for the given header + * concatenated together using a comma. If the header does not appear in + * the message, this method MUST return an empty string. + */ + public function getHeaderLine($name); + + /** + * Return an instance with the provided value replacing the specified header. + * + * While header names are case-insensitive, the casing of the header will + * be preserved by this function, and returned from getHeaders(). + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * new and/or updated header and value. + * + * @param string $name Case-insensitive header field name. + * @param string|string[] $value Header value(s). + * @return self + * @throws \InvalidArgumentException for invalid header names or values. + */ + public function withHeader($name, $value); + + /** + * Return an instance with the specified header appended with the given value. + * + * Existing values for the specified header will be maintained. The new + * value(s) will be appended to the existing list. If the header did not + * exist previously, it will be added. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * new header and/or value. + * + * @param string $name Case-insensitive header field name to add. + * @param string|string[] $value Header value(s). + * @return self + * @throws \InvalidArgumentException for invalid header names or values. + */ + public function withAddedHeader($name, $value); + + /** + * Return an instance without the specified header. + * + * Header resolution MUST be done without case-sensitivity. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that removes + * the named header. + * + * @param string $name Case-insensitive header field name to remove. + * @return self + */ + public function withoutHeader($name); + + /** + * Gets the body of the message. + * + * @return StreamInterface Returns the body as a stream. + */ + public function getBody(); + + /** + * Return an instance with the specified message body. + * + * The body MUST be a StreamInterface object. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return a new instance that has the + * new body stream. + * + * @param StreamInterface $body Body. + * @return self + * @throws \InvalidArgumentException When the body is not valid. + */ + public function withBody(StreamInterface $body); +} diff --git a/library/vendor/Psr/Http/Message/RequestInterface.php b/library/vendor/Psr/Http/Message/RequestInterface.php new file mode 100644 index 0000000..75c802e --- /dev/null +++ b/library/vendor/Psr/Http/Message/RequestInterface.php @@ -0,0 +1,129 @@ +<?php + +namespace Psr\Http\Message; + +/** + * Representation of an outgoing, client-side request. + * + * Per the HTTP specification, this interface includes properties for + * each of the following: + * + * - Protocol version + * - HTTP method + * - URI + * - Headers + * - Message body + * + * During construction, implementations MUST attempt to set the Host header from + * a provided URI if no Host header is provided. + * + * Requests are considered immutable; all methods that might change state MUST + * be implemented such that they retain the internal state of the current + * message and return an instance that contains the changed state. + */ +interface RequestInterface extends MessageInterface +{ + /** + * Retrieves the message's request target. + * + * Retrieves the message's request-target either as it will appear (for + * clients), as it appeared at request (for servers), or as it was + * specified for the instance (see withRequestTarget()). + * + * In most cases, this will be the origin-form of the composed URI, + * unless a value was provided to the concrete implementation (see + * withRequestTarget() below). + * + * If no URI is available, and no request-target has been specifically + * provided, this method MUST return the string "/". + * + * @return string + */ + public function getRequestTarget(); + + /** + * Return an instance with the specific request-target. + * + * If the request needs a non-origin-form request-target — e.g., for + * specifying an absolute-form, authority-form, or asterisk-form — + * this method may be used to create an instance with the specified + * request-target, verbatim. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * changed request target. + * + * @link http://tools.ietf.org/html/rfc7230#section-2.7 (for the various + * request-target forms allowed in request messages) + * @param mixed $requestTarget + * @return self + */ + public function withRequestTarget($requestTarget); + + /** + * Retrieves the HTTP method of the request. + * + * @return string Returns the request method. + */ + public function getMethod(); + + /** + * Return an instance with the provided HTTP method. + * + * While HTTP method names are typically all uppercase characters, HTTP + * method names are case-sensitive and thus implementations SHOULD NOT + * modify the given string. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * changed request method. + * + * @param string $method Case-sensitive method. + * @return self + * @throws \InvalidArgumentException for invalid HTTP methods. + */ + public function withMethod($method); + + /** + * Retrieves the URI instance. + * + * This method MUST return a UriInterface instance. + * + * @link http://tools.ietf.org/html/rfc3986#section-4.3 + * @return UriInterface Returns a UriInterface instance + * representing the URI of the request. + */ + public function getUri(); + + /** + * Returns an instance with the provided URI. + * + * This method MUST update the Host header of the returned request by + * default if the URI contains a host component. If the URI does not + * contain a host component, any pre-existing Host header MUST be carried + * over to the returned request. + * + * You can opt-in to preserving the original state of the Host header by + * setting `$preserveHost` to `true`. When `$preserveHost` is set to + * `true`, this method interacts with the Host header in the following ways: + * + * - If the the Host header is missing or empty, and the new URI contains + * a host component, this method MUST update the Host header in the returned + * request. + * - If the Host header is missing or empty, and the new URI does not contain a + * host component, this method MUST NOT update the Host header in the returned + * request. + * - If a Host header is present and non-empty, this method MUST NOT update + * the Host header in the returned request. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * new UriInterface instance. + * + * @link http://tools.ietf.org/html/rfc3986#section-4.3 + * @param UriInterface $uri New request URI to use. + * @param bool $preserveHost Preserve the original state of the Host header. + * @return self + */ + public function withUri(UriInterface $uri, $preserveHost = false); +} diff --git a/library/vendor/Psr/Http/Message/ResponseInterface.php b/library/vendor/Psr/Http/Message/ResponseInterface.php new file mode 100644 index 0000000..6724809 --- /dev/null +++ b/library/vendor/Psr/Http/Message/ResponseInterface.php @@ -0,0 +1,68 @@ +<?php + +namespace Psr\Http\Message; + +/** + * Representation of an outgoing, server-side response. + * + * Per the HTTP specification, this interface includes properties for + * each of the following: + * + * - Protocol version + * - Status code and reason phrase + * - Headers + * - Message body + * + * Responses are considered immutable; all methods that might change state MUST + * be implemented such that they retain the internal state of the current + * message and return an instance that contains the changed state. + */ +interface ResponseInterface extends MessageInterface +{ + /** + * Gets the response status code. + * + * The status code is a 3-digit integer result code of the server's attempt + * to understand and satisfy the request. + * + * @return int Status code. + */ + public function getStatusCode(); + + /** + * Return an instance with the specified status code and, optionally, reason phrase. + * + * If no reason phrase is specified, implementations MAY choose to default + * to the RFC 7231 or IANA recommended reason phrase for the response's + * status code. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * updated status and reason phrase. + * + * @link http://tools.ietf.org/html/rfc7231#section-6 + * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml + * @param int $code The 3-digit integer result code to set. + * @param string $reasonPhrase The reason phrase to use with the + * provided status code; if none is provided, implementations MAY + * use the defaults as suggested in the HTTP specification. + * @return self + * @throws \InvalidArgumentException For invalid status code arguments. + */ + public function withStatus($code, $reasonPhrase = ''); + + /** + * Gets the response reason phrase associated with the status code. + * + * Because a reason phrase is not a required element in a response + * status line, the reason phrase value MAY be null. Implementations MAY + * choose to return the default RFC 7231 recommended reason phrase (or those + * listed in the IANA HTTP Status Code Registry) for the response's + * status code. + * + * @link http://tools.ietf.org/html/rfc7231#section-6 + * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml + * @return string Reason phrase; must return an empty string if none present. + */ + public function getReasonPhrase(); +} diff --git a/library/vendor/Psr/Http/Message/ServerRequestInterface.php b/library/vendor/Psr/Http/Message/ServerRequestInterface.php new file mode 100644 index 0000000..916e065 --- /dev/null +++ b/library/vendor/Psr/Http/Message/ServerRequestInterface.php @@ -0,0 +1,261 @@ +<?php + +namespace Psr\Http\Message; + +/** + * Representation of an incoming, server-side HTTP request. + * + * Per the HTTP specification, this interface includes properties for + * each of the following: + * + * - Protocol version + * - HTTP method + * - URI + * - Headers + * - Message body + * + * Additionally, it encapsulates all data as it has arrived to the + * application from the CGI and/or PHP environment, including: + * + * - The values represented in $_SERVER. + * - Any cookies provided (generally via $_COOKIE) + * - Query string arguments (generally via $_GET, or as parsed via parse_str()) + * - Upload files, if any (as represented by $_FILES) + * - Deserialized body parameters (generally from $_POST) + * + * $_SERVER values MUST be treated as immutable, as they represent application + * state at the time of request; as such, no methods are provided to allow + * modification of those values. The other values provide such methods, as they + * can be restored from $_SERVER or the request body, and may need treatment + * during the application (e.g., body parameters may be deserialized based on + * content type). + * + * Additionally, this interface recognizes the utility of introspecting a + * request to derive and match additional parameters (e.g., via URI path + * matching, decrypting cookie values, deserializing non-form-encoded body + * content, matching authorization headers to users, etc). These parameters + * are stored in an "attributes" property. + * + * Requests are considered immutable; all methods that might change state MUST + * be implemented such that they retain the internal state of the current + * message and return an instance that contains the changed state. + */ +interface ServerRequestInterface extends RequestInterface +{ + /** + * Retrieve server parameters. + * + * Retrieves data related to the incoming request environment, + * typically derived from PHP's $_SERVER superglobal. The data IS NOT + * REQUIRED to originate from $_SERVER. + * + * @return array + */ + public function getServerParams(); + + /** + * Retrieve cookies. + * + * Retrieves cookies sent by the client to the server. + * + * The data MUST be compatible with the structure of the $_COOKIE + * superglobal. + * + * @return array + */ + public function getCookieParams(); + + /** + * Return an instance with the specified cookies. + * + * The data IS NOT REQUIRED to come from the $_COOKIE superglobal, but MUST + * be compatible with the structure of $_COOKIE. Typically, this data will + * be injected at instantiation. + * + * This method MUST NOT update the related Cookie header of the request + * instance, nor related values in the server params. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * updated cookie values. + * + * @param array $cookies Array of key/value pairs representing cookies. + * @return self + */ + public function withCookieParams(array $cookies); + + /** + * Retrieve query string arguments. + * + * Retrieves the deserialized query string arguments, if any. + * + * Note: the query params might not be in sync with the URI or server + * params. If you need to ensure you are only getting the original + * values, you may need to parse the query string from `getUri()->getQuery()` + * or from the `QUERY_STRING` server param. + * + * @return array + */ + public function getQueryParams(); + + /** + * Return an instance with the specified query string arguments. + * + * These values SHOULD remain immutable over the course of the incoming + * request. They MAY be injected during instantiation, such as from PHP's + * $_GET superglobal, or MAY be derived from some other value such as the + * URI. In cases where the arguments are parsed from the URI, the data + * MUST be compatible with what PHP's parse_str() would return for + * purposes of how duplicate query parameters are handled, and how nested + * sets are handled. + * + * Setting query string arguments MUST NOT change the URI stored by the + * request, nor the values in the server params. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * updated query string arguments. + * + * @param array $query Array of query string arguments, typically from + * $_GET. + * @return self + */ + public function withQueryParams(array $query); + + /** + * Retrieve normalized file upload data. + * + * This method returns upload metadata in a normalized tree, with each leaf + * an instance of Psr\Http\Message\UploadedFileInterface. + * + * These values MAY be prepared from $_FILES or the message body during + * instantiation, or MAY be injected via withUploadedFiles(). + * + * @return array An array tree of UploadedFileInterface instances; an empty + * array MUST be returned if no data is present. + */ + public function getUploadedFiles(); + + /** + * Create a new instance with the specified uploaded files. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * updated body parameters. + * + * @param array An array tree of UploadedFileInterface instances. + * @return self + * @throws \InvalidArgumentException if an invalid structure is provided. + */ + public function withUploadedFiles(array $uploadedFiles); + + /** + * Retrieve any parameters provided in the request body. + * + * If the request Content-Type is either application/x-www-form-urlencoded + * or multipart/form-data, and the request method is POST, this method MUST + * return the contents of $_POST. + * + * Otherwise, this method may return any results of deserializing + * the request body content; as parsing returns structured content, the + * potential types MUST be arrays or objects only. A null value indicates + * the absence of body content. + * + * @return null|array|object The deserialized body parameters, if any. + * These will typically be an array or object. + */ + public function getParsedBody(); + + /** + * Return an instance with the specified body parameters. + * + * These MAY be injected during instantiation. + * + * If the request Content-Type is either application/x-www-form-urlencoded + * or multipart/form-data, and the request method is POST, use this method + * ONLY to inject the contents of $_POST. + * + * The data IS NOT REQUIRED to come from $_POST, but MUST be the results of + * deserializing the request body content. Deserialization/parsing returns + * structured data, and, as such, this method ONLY accepts arrays or objects, + * or a null value if nothing was available to parse. + * + * As an example, if content negotiation determines that the request data + * is a JSON payload, this method could be used to create a request + * instance with the deserialized parameters. + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * updated body parameters. + * + * @param null|array|object $data The deserialized body data. This will + * typically be in an array or object. + * @return self + * @throws \InvalidArgumentException if an unsupported argument type is + * provided. + */ + public function withParsedBody($data); + + /** + * Retrieve attributes derived from the request. + * + * The request "attributes" may be used to allow injection of any + * parameters derived from the request: e.g., the results of path + * match operations; the results of decrypting cookies; the results of + * deserializing non-form-encoded message bodies; etc. Attributes + * will be application and request specific, and CAN be mutable. + * + * @return array Attributes derived from the request. + */ + public function getAttributes(); + + /** + * Retrieve a single derived request attribute. + * + * Retrieves a single derived request attribute as described in + * getAttributes(). If the attribute has not been previously set, returns + * the default value as provided. + * + * This method obviates the need for a hasAttribute() method, as it allows + * specifying a default value to return if the attribute is not found. + * + * @see getAttributes() + * @param string $name The attribute name. + * @param mixed $default Default value to return if the attribute does not exist. + * @return mixed + */ + public function getAttribute($name, $default = null); + + /** + * Return an instance with the specified derived request attribute. + * + * This method allows setting a single derived request attribute as + * described in getAttributes(). + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that has the + * updated attribute. + * + * @see getAttributes() + * @param string $name The attribute name. + * @param mixed $value The value of the attribute. + * @return self + */ + public function withAttribute($name, $value); + + /** + * Return an instance that removes the specified derived request attribute. + * + * This method allows removing a single derived request attribute as + * described in getAttributes(). + * + * This method MUST be implemented in such a way as to retain the + * immutability of the message, and MUST return an instance that removes + * the attribute. + * + * @see getAttributes() + * @param string $name The attribute name. + * @return self + */ + public function withoutAttribute($name); +} diff --git a/library/vendor/Psr/Http/Message/StreamInterface.php b/library/vendor/Psr/Http/Message/StreamInterface.php new file mode 100644 index 0000000..f68f391 --- /dev/null +++ b/library/vendor/Psr/Http/Message/StreamInterface.php @@ -0,0 +1,158 @@ +<?php + +namespace Psr\Http\Message; + +/** + * Describes a data stream. + * + * Typically, an instance will wrap a PHP stream; this interface provides + * a wrapper around the most common operations, including serialization of + * the entire stream to a string. + */ +interface StreamInterface +{ + /** + * Reads all data from the stream into a string, from the beginning to end. + * + * This method MUST attempt to seek to the beginning of the stream before + * reading data and read the stream until the end is reached. + * + * Warning: This could attempt to load a large amount of data into memory. + * + * This method MUST NOT raise an exception in order to conform with PHP's + * string casting operations. + * + * @see http://php.net/manual/en/language.oop5.magic.php#object.tostring + * @return string + */ + public function __toString(); + + /** + * Closes the stream and any underlying resources. + * + * @return void + */ + public function close(); + + /** + * Separates any underlying resources from the stream. + * + * After the stream has been detached, the stream is in an unusable state. + * + * @return resource|null Underlying PHP stream, if any + */ + public function detach(); + + /** + * Get the size of the stream if known. + * + * @return int|null Returns the size in bytes if known, or null if unknown. + */ + public function getSize(); + + /** + * Returns the current position of the file read/write pointer + * + * @return int Position of the file pointer + * @throws \RuntimeException on error. + */ + public function tell(); + + /** + * Returns true if the stream is at the end of the stream. + * + * @return bool + */ + public function eof(); + + /** + * Returns whether or not the stream is seekable. + * + * @return bool + */ + public function isSeekable(); + + /** + * Seek to a position in the stream. + * + * @link http://www.php.net/manual/en/function.fseek.php + * @param int $offset Stream offset + * @param int $whence Specifies how the cursor position will be calculated + * based on the seek offset. Valid values are identical to the built-in + * PHP $whence values for `fseek()`. SEEK_SET: Set position equal to + * offset bytes SEEK_CUR: Set position to current location plus offset + * SEEK_END: Set position to end-of-stream plus offset. + * @throws \RuntimeException on failure. + */ + public function seek($offset, $whence = SEEK_SET); + + /** + * Seek to the beginning of the stream. + * + * If the stream is not seekable, this method will raise an exception; + * otherwise, it will perform a seek(0). + * + * @see seek() + * @link http://www.php.net/manual/en/function.fseek.php + * @throws \RuntimeException on failure. + */ + public function rewind(); + + /** + * Returns whether or not the stream is writable. + * + * @return bool + */ + public function isWritable(); + + /** + * Write data to the stream. + * + * @param string $string The string that is to be written. + * @return int Returns the number of bytes written to the stream. + * @throws \RuntimeException on failure. + */ + public function write($string); + + /** + * Returns whether or not the stream is readable. + * + * @return bool + */ + public function isReadable(); + + /** + * Read data from the stream. + * + * @param int $length Read up to $length bytes from the object and return + * them. Fewer than $length bytes may be returned if underlying stream + * call returns fewer bytes. + * @return string Returns the data read from the stream, or an empty string + * if no bytes are available. + * @throws \RuntimeException if an error occurs. + */ + public function read($length); + + /** + * Returns the remaining contents in a string + * + * @return string + * @throws \RuntimeException if unable to read or an error occurs while + * reading. + */ + public function getContents(); + + /** + * Get stream metadata as an associative array or retrieve a specific key. + * + * The keys returned are identical to the keys returned from PHP's + * stream_get_meta_data() function. + * + * @link http://php.net/manual/en/function.stream-get-meta-data.php + * @param string $key Specific metadata to retrieve. + * @return array|mixed|null Returns an associative array if no key is + * provided. Returns a specific key value if a key is provided and the + * value is found, or null if the key is not found. + */ + public function getMetadata($key = null); +} diff --git a/library/vendor/Psr/Http/Message/UploadedFileInterface.php b/library/vendor/Psr/Http/Message/UploadedFileInterface.php new file mode 100644 index 0000000..5ad288d --- /dev/null +++ b/library/vendor/Psr/Http/Message/UploadedFileInterface.php @@ -0,0 +1,123 @@ +<?php + +namespace Psr\Http\Message; + +/** + * Value object representing a file uploaded through an HTTP request. + * + * Instances of this interface are considered immutable; all methods that + * might change state MUST be implemented such that they retain the internal + * state of the current instance and return an instance that contains the + * changed state. + */ +interface UploadedFileInterface +{ + /** + * Retrieve a stream representing the uploaded file. + * + * This method MUST return a StreamInterface instance, representing the + * uploaded file. The purpose of this method is to allow utilizing native PHP + * stream functionality to manipulate the file upload, such as + * stream_copy_to_stream() (though the result will need to be decorated in a + * native PHP stream wrapper to work with such functions). + * + * If the moveTo() method has been called previously, this method MUST raise + * an exception. + * + * @return StreamInterface Stream representation of the uploaded file. + * @throws \RuntimeException in cases when no stream is available or can be + * created. + */ + public function getStream(); + + /** + * Move the uploaded file to a new location. + * + * Use this method as an alternative to move_uploaded_file(). This method is + * guaranteed to work in both SAPI and non-SAPI environments. + * Implementations must determine which environment they are in, and use the + * appropriate method (move_uploaded_file(), rename(), or a stream + * operation) to perform the operation. + * + * $targetPath may be an absolute path, or a relative path. If it is a + * relative path, resolution should be the same as used by PHP's rename() + * function. + * + * The original file or stream MUST be removed on completion. + * + * If this method is called more than once, any subsequent calls MUST raise + * an exception. + * + * When used in an SAPI environment where $_FILES is populated, when writing + * files via moveTo(), is_uploaded_file() and move_uploaded_file() SHOULD be + * used to ensure permissions and upload status are verified correctly. + * + * If you wish to move to a stream, use getStream(), as SAPI operations + * cannot guarantee writing to stream destinations. + * + * @see http://php.net/is_uploaded_file + * @see http://php.net/move_uploaded_file + * @param string $targetPath Path to which to move the uploaded file. + * @throws \InvalidArgumentException if the $path specified is invalid. + * @throws \RuntimeException on any error during the move operation, or on + * the second or subsequent call to the method. + */ + public function moveTo($targetPath); + + /** + * Retrieve the file size. + * + * Implementations SHOULD return the value stored in the "size" key of + * the file in the $_FILES array if available, as PHP calculates this based + * on the actual size transmitted. + * + * @return int|null The file size in bytes or null if unknown. + */ + public function getSize(); + + /** + * Retrieve the error associated with the uploaded file. + * + * The return value MUST be one of PHP's UPLOAD_ERR_XXX constants. + * + * If the file was uploaded successfully, this method MUST return + * UPLOAD_ERR_OK. + * + * Implementations SHOULD return the value stored in the "error" key of + * the file in the $_FILES array. + * + * @see http://php.net/manual/en/features.file-upload.errors.php + * @return int One of PHP's UPLOAD_ERR_XXX constants. + */ + public function getError(); + + /** + * Retrieve the filename sent by the client. + * + * Do not trust the value returned by this method. A client could send + * a malicious filename with the intention to corrupt or hack your + * application. + * + * Implementations SHOULD return the value stored in the "name" key of + * the file in the $_FILES array. + * + * @return string|null The filename sent by the client or null if none + * was provided. + */ + public function getClientFilename(); + + /** + * Retrieve the media type sent by the client. + * + * Do not trust the value returned by this method. A client could send + * a malicious media type with the intention to corrupt or hack your + * application. + * + * Implementations SHOULD return the value stored in the "type" key of + * the file in the $_FILES array. + * + * @return string|null The media type sent by the client or null if none + * was provided. + */ + public function getClientMediaType(); +} diff --git a/library/vendor/Psr/Http/Message/UriInterface.php b/library/vendor/Psr/Http/Message/UriInterface.php new file mode 100644 index 0000000..c51a64b --- /dev/null +++ b/library/vendor/Psr/Http/Message/UriInterface.php @@ -0,0 +1,324 @@ +<?php + +namespace Psr\Http\Message; + +/** + * Value object representing a URI. + * + * This interface is meant to represent URIs according to RFC 3986 and to + * provide methods for most common operations. Additional functionality for + * working with URIs can be provided on top of the interface or externally. + * Its primary use is for HTTP requests, but may also be used in other + * contexts. + * + * Instances of this interface are considered immutable; all methods that + * might change state MUST be implemented such that they retain the internal + * state of the current instance and return an instance that contains the + * changed state. + * + * Typically the Host header will be also be present in the request message. + * For server-side requests, the scheme will typically be discoverable in the + * server parameters. + * + * @link http://tools.ietf.org/html/rfc3986 (the URI specification) + */ +interface UriInterface +{ + /** + * Retrieve the scheme component of the URI. + * + * If no scheme is present, this method MUST return an empty string. + * + * The value returned MUST be normalized to lowercase, per RFC 3986 + * Section 3.1. + * + * The trailing ":" character is not part of the scheme and MUST NOT be + * added. + * + * @see https://tools.ietf.org/html/rfc3986#section-3.1 + * @return string The URI scheme. + */ + public function getScheme(); + + /** + * Retrieve the authority component of the URI. + * + * If no authority information is present, this method MUST return an empty + * string. + * + * The authority syntax of the URI is: + * + * <pre> + * [user-info@]host[:port] + * </pre> + * + * If the port component is not set or is the standard port for the current + * scheme, it SHOULD NOT be included. + * + * @see https://tools.ietf.org/html/rfc3986#section-3.2 + * @return string The URI authority, in "[user-info@]host[:port]" format. + */ + public function getAuthority(); + + /** + * Retrieve the user information component of the URI. + * + * If no user information is present, this method MUST return an empty + * string. + * + * If a user is present in the URI, this will return that value; + * additionally, if the password is also present, it will be appended to the + * user value, with a colon (":") separating the values. + * + * The trailing "@" character is not part of the user information and MUST + * NOT be added. + * + * @return string The URI user information, in "username[:password]" format. + */ + public function getUserInfo(); + + /** + * Retrieve the host component of the URI. + * + * If no host is present, this method MUST return an empty string. + * + * The value returned MUST be normalized to lowercase, per RFC 3986 + * Section 3.2.2. + * + * @see http://tools.ietf.org/html/rfc3986#section-3.2.2 + * @return string The URI host. + */ + public function getHost(); + + /** + * Retrieve the port component of the URI. + * + * If a port is present, and it is non-standard for the current scheme, + * this method MUST return it as an integer. If the port is the standard port + * used with the current scheme, this method SHOULD return null. + * + * If no port is present, and no scheme is present, this method MUST return + * a null value. + * + * If no port is present, but a scheme is present, this method MAY return + * the standard port for that scheme, but SHOULD return null. + * + * @return null|int The URI port. + */ + public function getPort(); + + /** + * Retrieve the path component of the URI. + * + * The path can either be empty or absolute (starting with a slash) or + * rootless (not starting with a slash). Implementations MUST support all + * three syntaxes. + * + * Normally, the empty path "" and absolute path "/" are considered equal as + * defined in RFC 7230 Section 2.7.3. But this method MUST NOT automatically + * do this normalization because in contexts with a trimmed base path, e.g. + * the front controller, this difference becomes significant. It's the task + * of the user to handle both "" and "/". + * + * The value returned MUST be percent-encoded, but MUST NOT double-encode + * any characters. To determine what characters to encode, please refer to + * RFC 3986, Sections 2 and 3.3. + * + * As an example, if the value should include a slash ("/") not intended as + * delimiter between path segments, that value MUST be passed in encoded + * form (e.g., "%2F") to the instance. + * + * @see https://tools.ietf.org/html/rfc3986#section-2 + * @see https://tools.ietf.org/html/rfc3986#section-3.3 + * @return string The URI path. + */ + public function getPath(); + + /** + * Retrieve the query string of the URI. + * + * If no query string is present, this method MUST return an empty string. + * + * The leading "?" character is not part of the query and MUST NOT be + * added. + * + * The value returned MUST be percent-encoded, but MUST NOT double-encode + * any characters. To determine what characters to encode, please refer to + * RFC 3986, Sections 2 and 3.4. + * + * As an example, if a value in a key/value pair of the query string should + * include an ampersand ("&") not intended as a delimiter between values, + * that value MUST be passed in encoded form (e.g., "%26") to the instance. + * + * @see https://tools.ietf.org/html/rfc3986#section-2 + * @see https://tools.ietf.org/html/rfc3986#section-3.4 + * @return string The URI query string. + */ + public function getQuery(); + + /** + * Retrieve the fragment component of the URI. + * + * If no fragment is present, this method MUST return an empty string. + * + * The leading "#" character is not part of the fragment and MUST NOT be + * added. + * + * The value returned MUST be percent-encoded, but MUST NOT double-encode + * any characters. To determine what characters to encode, please refer to + * RFC 3986, Sections 2 and 3.5. + * + * @see https://tools.ietf.org/html/rfc3986#section-2 + * @see https://tools.ietf.org/html/rfc3986#section-3.5 + * @return string The URI fragment. + */ + public function getFragment(); + + /** + * Return an instance with the specified scheme. + * + * This method MUST retain the state of the current instance, and return + * an instance that contains the specified scheme. + * + * Implementations MUST support the schemes "http" and "https" case + * insensitively, and MAY accommodate other schemes if required. + * + * An empty scheme is equivalent to removing the scheme. + * + * @param string $scheme The scheme to use with the new instance. + * @return self A new instance with the specified scheme. + * @throws \InvalidArgumentException for invalid or unsupported schemes. + */ + public function withScheme($scheme); + + /** + * Return an instance with the specified user information. + * + * This method MUST retain the state of the current instance, and return + * an instance that contains the specified user information. + * + * Password is optional, but the user information MUST include the + * user; an empty string for the user is equivalent to removing user + * information. + * + * @param string $user The user name to use for authority. + * @param null|string $password The password associated with $user. + * @return self A new instance with the specified user information. + */ + public function withUserInfo($user, $password = null); + + /** + * Return an instance with the specified host. + * + * This method MUST retain the state of the current instance, and return + * an instance that contains the specified host. + * + * An empty host value is equivalent to removing the host. + * + * @param string $host The hostname to use with the new instance. + * @return self A new instance with the specified host. + * @throws \InvalidArgumentException for invalid hostnames. + */ + public function withHost($host); + + /** + * Return an instance with the specified port. + * + * This method MUST retain the state of the current instance, and return + * an instance that contains the specified port. + * + * Implementations MUST raise an exception for ports outside the + * established TCP and UDP port ranges. + * + * A null value provided for the port is equivalent to removing the port + * information. + * + * @param null|int $port The port to use with the new instance; a null value + * removes the port information. + * @return self A new instance with the specified port. + * @throws \InvalidArgumentException for invalid ports. + */ + public function withPort($port); + + /** + * Return an instance with the specified path. + * + * This method MUST retain the state of the current instance, and return + * an instance that contains the specified path. + * + * The path can either be empty or absolute (starting with a slash) or + * rootless (not starting with a slash). Implementations MUST support all + * three syntaxes. + * + * If the path is intended to be domain-relative rather than path relative then + * it must begin with a slash ("/"). Paths not starting with a slash ("/") + * are assumed to be relative to some base path known to the application or + * consumer. + * + * Users can provide both encoded and decoded path characters. + * Implementations ensure the correct encoding as outlined in getPath(). + * + * @param string $path The path to use with the new instance. + * @return self A new instance with the specified path. + * @throws \InvalidArgumentException for invalid paths. + */ + public function withPath($path); + + /** + * Return an instance with the specified query string. + * + * This method MUST retain the state of the current instance, and return + * an instance that contains the specified query string. + * + * Users can provide both encoded and decoded query characters. + * Implementations ensure the correct encoding as outlined in getQuery(). + * + * An empty query string value is equivalent to removing the query string. + * + * @param string $query The query string to use with the new instance. + * @return self A new instance with the specified query string. + * @throws \InvalidArgumentException for invalid query strings. + */ + public function withQuery($query); + + /** + * Return an instance with the specified URI fragment. + * + * This method MUST retain the state of the current instance, and return + * an instance that contains the specified URI fragment. + * + * Users can provide both encoded and decoded fragment characters. + * Implementations ensure the correct encoding as outlined in getFragment(). + * + * An empty fragment value is equivalent to removing the fragment. + * + * @param string $fragment The fragment to use with the new instance. + * @return self A new instance with the specified fragment. + */ + public function withFragment($fragment); + + /** + * Return the string representation as a URI reference. + * + * Depending on which components of the URI are present, the resulting + * string is either a full URI or relative reference according to RFC 3986, + * Section 4.1. The method concatenates the various components of the URI, + * using the appropriate delimiters: + * + * - If a scheme is present, it MUST be suffixed by ":". + * - If an authority is present, it MUST be prefixed by "//". + * - The path can be concatenated without delimiters. But there are two + * cases where the path has to be adjusted to make the URI reference + * valid as PHP does not allow to throw an exception in __toString(): + * - If the path is rootless and an authority is present, the path MUST + * be prefixed by "/". + * - If the path is starting with more than one "/" and no authority is + * present, the starting slashes MUST be reduced to one. + * - If a query is present, it MUST be prefixed by "?". + * - If a fragment is present, it MUST be prefixed by "#". + * + * @see http://tools.ietf.org/html/rfc3986#section-4.1 + * @return string + */ + public function __toString(); +} diff --git a/library/vendor/Psr/LICENSE b/library/vendor/Psr/LICENSE new file mode 100644 index 0000000..c2d8e45 --- /dev/null +++ b/library/vendor/Psr/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2014 PHP Framework Interoperability Group + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/library/vendor/Psr/Loader.php b/library/vendor/Psr/Loader.php new file mode 100644 index 0000000..45c78af --- /dev/null +++ b/library/vendor/Psr/Loader.php @@ -0,0 +1,21 @@ +<?php +/* Icinga Web 2 Elasticsearch Module (c) 2017 Icinga Development Team | GPLv2+ */ + +spl_autoload_register(function ($class) { + $prefix = 'Psr\\'; + $len = strlen($prefix); + + $baseDir = __DIR__ . '/'; + + if (strncmp($prefix, $class, $len) !== 0) { + return; + } + + $relative = substr($class, $len); + + $file = $baseDir . str_replace('\\', '/', $relative) . '.php'; + + if (file_exists($file)) { + require $file; + } +}); diff --git a/library/vendor/iplx/Http/Client.php b/library/vendor/iplx/Http/Client.php new file mode 100644 index 0000000..39d8905 --- /dev/null +++ b/library/vendor/iplx/Http/Client.php @@ -0,0 +1,199 @@ +<?php + +namespace iplx\Http; + +use RuntimeException; +use Psr\Http\Message\RequestInterface; +use Psr\Http\Message\ResponseInterface; + +/** + * HTTP client that uses cURL + */ +class Client implements ClientInterface +{ + /** + * Client version + * + * @var string + */ + const VERSION = '1.0.0'; + + /** + * Maximum number of internal cURL handles + * + * @var int + */ + const MAX_HANDLES = 4; + + /** + * Internal cURL handles + * + * @var array + */ + protected $handles = []; + + /** + * Return user agent + * + * @return string + */ + protected function getAgent() + { + $defaultAgent = 'ipl/' . self::VERSION; + $defaultAgent .= ' curl/' . curl_version()['version']; + $defaultAgent .= ' PHP/' . PHP_VERSION; + + return $defaultAgent; + } + + /** + * Create and return a cURL handle based on the given request + * + * @param RequestInterface $request + * @param array $options + * + * @return Handle + * + * @throws RuntimeException + */ + protected function createHandle(RequestInterface $request, array $options) + { + $headers = []; + foreach ($request->getHeaders() as $name => $values) { + $headers[] = $name . ': ' . implode(', ', $values); + } + + $curlOptions = [ + CURLOPT_FOLLOWLOCATION => true, + CURLOPT_FAILONERROR => true, + CURLOPT_USERAGENT => $this->getAgent() + ]; + + if (isset($options['curl'])) { + $curlOptions += $options['curl']; + } + + $curlOptions += [ + CURLOPT_CUSTOMREQUEST => $request->getMethod(), + CURLOPT_HTTPHEADER => $headers, + CURLOPT_RETURNTRANSFER => false, + CURLOPT_URL => (string) $request->getUri()->withFragment('') + ]; + + if (! $request->hasHeader('Accept')) { + $curlOptions[CURLOPT_HTTPHEADER][] = 'Accept:'; + } + + if (! $request->hasHeader('Content-Type')) { + $curlOptions[CURLOPT_HTTPHEADER][] = 'Content-Type:'; + } + + if (! $request->hasHeader('Expect')) { + $curlOptions[CURLOPT_HTTPHEADER][] = 'Expect:'; + } + + if ($request->getBody()->getSize() !== 0) { + $curlOptions[CURLOPT_UPLOAD] = true; + + $body = $request->getBody(); + if ($body->isSeekable()) { + $body->seek(0); + } + + $curlOptions[CURLOPT_READFUNCTION] = function ($ch, $infile, $length) use ($body) { + return $body->read($length); + }; + } + + if ($request->getProtocolVersion()) { + $protocolVersion = null; + switch ($request->getProtocolVersion()) { + case '2.0': + if (version_compare(phpversion(), '7.0.7', '<')) { + throw new RuntimeException('You need at least PHP 7.0.7 to use HTTP 2.0'); + } + $protocolVersion = CURL_HTTP_VERSION_2; + break; + case '1.1': + $protocolVersion = CURL_HTTP_VERSION_1_1; + break; + default: + $protocolVersion = CURL_HTTP_VERSION_1_0; + } + + $curlOptions[CURLOPT_HTTP_VERSION] = $protocolVersion; + } + + $handle = new Handle(); + + $curlOptions[CURLOPT_HEADERFUNCTION] = function($ch, $header) use ($handle) { + $size = strlen($header); + + if (! trim($header) || strpos($header, 'HTTP/') === 0) { + return $size; + } + + list($key, $value) = explode(': ', $header, 2); + $handle->responseHeaders[$key] = rtrim($value, "\r\n"); + + return $size; + }; + + $handle->responseBody = Stream::open(); + + $curlOptions[CURLOPT_WRITEFUNCTION] = function ($ch, $string) use ($handle) { + return $handle->responseBody->write($string); + }; + + $ch = ! empty($this->handles) ? array_pop($this->handles) : curl_init(); + + curl_setopt_array($ch, $curlOptions); + + $handle->handle = $ch; + + return $handle; + } + + /** + * Execute a cURL handle and return the response + * + * @param Handle $handle + * + * @return ResponseInterface + * + * @throws RuntimeException + */ + protected function executeHandle(Handle $handle) + { + $ch = $handle->handle; + + $success = curl_exec($ch); + + if ($success === false) { + throw new RuntimeException(curl_error($ch)); + } + + $response = new Response( + curl_getinfo($ch, CURLINFO_HTTP_CODE), $handle->responseHeaders, $handle->responseBody + ); + + if (count($this->handles) >= self::MAX_HANDLES) { + curl_close($ch); + } else { + curl_reset($ch); + + $this->handles[] = $ch; + } + + return $response; + } + + public function send(RequestInterface $request, array $options = []) + { + $handle = $this->createHandle($request, $options); + + $response = $this->executeHandle($handle); + + return $response; + } +} diff --git a/library/vendor/iplx/Http/ClientInterface.php b/library/vendor/iplx/Http/ClientInterface.php new file mode 100644 index 0000000..e7765a7 --- /dev/null +++ b/library/vendor/iplx/Http/ClientInterface.php @@ -0,0 +1,22 @@ +<?php + +namespace iplx\Http; + +use Psr\Http\Message\RequestInterface; +use Psr\Http\Message\ResponseInterface; + +/** + * Interface for HTTP clients which send HTTP requests + */ +interface ClientInterface +{ + /** + * Send a HTTP request + * + * @param RequestInterface $request Request to send + * @param array $options Request options + * + * @return ResponseInterface The response + */ + public function send(RequestInterface $request, array $options = []); +} diff --git a/library/vendor/iplx/Http/Handle.php b/library/vendor/iplx/Http/Handle.php new file mode 100644 index 0000000..490b5c5 --- /dev/null +++ b/library/vendor/iplx/Http/Handle.php @@ -0,0 +1,32 @@ +<?php + +namespace iplx\Http; + +use Psr\Http\Message\StreamInterface; + +/** + * Internal cURL handle representation + */ +class Handle +{ + /** + * cURL handle + * + * @var resource + */ + public $handle; + + /** + * Response body + * + * @var StreamInterface + */ + public $responseBody; + + /** + * Received response headers + * + * @var array + */ + public $responseHeaders = []; +} diff --git a/library/vendor/iplx/Http/MessageTrait.php b/library/vendor/iplx/Http/MessageTrait.php new file mode 100644 index 0000000..c8dc9b3 --- /dev/null +++ b/library/vendor/iplx/Http/MessageTrait.php @@ -0,0 +1,174 @@ +<?php + +namespace iplx\Http; + +use Psr\Http\Message\StreamInterface; + +trait MessageTrait +{ + /** + * Case sensitive header names with lowercase header names as keys + * + * @var array + */ + protected $headerNames = []; + + /** + * Header values with lowercase header names as keys + * + * @var array + */ + protected $headerValues = []; + + /** + * The body of this request + * + * @var StreamInterface + */ + protected $body; + + /** + * Protocol version + * + * @var string + */ + protected $protocolVersion; + + public function getProtocolVersion() + { + return $this->protocolVersion; + } + + public function withProtocolVersion($version) + { + $message = clone $this; + $message->protocolVersion = $version; + + return $message; + } + + public function getHeaders() + { + return array_combine($this->headerNames, $this->headerValues); + } + + public function hasHeader($header) + { + return isset($this->headerValues[strtolower($header)]); + } + + public function getHeader($header) + { + $header = strtolower($header); + + if (! isset($this->headerValues[$header])) { + return []; + } + + return $this->headerValues[$header]; + } + + public function getHeaderLine($name) + { + $name = strtolower($name); + + if (! isset($this->headerValues[$name])) { + return ''; + } + + return implode(', ', $this->headerValues[$name]); + } + + public function withHeader($name, $value) + { + $name = rtrim($name); + + $value = $this->normalizeHeaderValues($value); + + $normalized = strtolower($name); + + $message = clone $this; + $message->headerNames[$normalized] = $name; + $message->headerValues[$normalized] = $value; + + return $message; + } + + public function withAddedHeader($name, $value) + { + $name = rtrim($name); + + $value = $this->normalizeHeaderValues($value); + + $normalized = strtolower($name); + + $message = clone $this; + if (isset($message->headerNames[$normalized])) { + $message->headerValues[$normalized] = array_merge($message->headerValues[$normalized], $value); + } else { + $message->headerNames[$normalized] = $name; + $message->headerValues[$normalized] = $value; + } + + return $message; + } + + public function withoutHeader($name) + { + $normalized = strtolower(rtrim($name)); + + $message = clone $this; + unset($message->headerNames[$normalized]); + unset($message->headerValues[$normalized]); + + return $message; + } + + public function getBody() + { + return $this->body; + } + + public function withBody(StreamInterface $body) + { + $message = clone $this; + $message->body = $body; + + return $message; + } + + protected function setHeaders(array $headers) + { + // Prepare header field names and header field values according to + // https://tools.ietf.org/html/rfc7230#section-3.2.4 + $names = array_map('rtrim', array_keys($headers)); + $values = $this->normalizeHeaderValues($headers); + + $normalized = array_map('strtolower', $names); + + $this->headerNames = array_combine( + $normalized, + $names + ); + + $this->headerValues = array_combine( + $normalized, + $values + ); + } + + protected function normalizeHeaderValues(array $values) + { + // Prepare header field names and header field values according to + // https://tools.ietf.org/html/rfc7230#section-3.2.4 + return array_map(function ($value) { + if (! is_array($value)) { + $value = [$value]; + } + + return array_map(function ($value) { + return trim($value, " \t"); + }, $value); + }, $values); + } +} diff --git a/library/vendor/iplx/Http/Request.php b/library/vendor/iplx/Http/Request.php new file mode 100644 index 0000000..b9fae7d --- /dev/null +++ b/library/vendor/iplx/Http/Request.php @@ -0,0 +1,143 @@ +<?php + +namespace iplx\Http; + +use Psr\Http\Message\RequestInterface; +use Psr\Http\Message\UriInterface; + +/** + * A HTTP request + */ +class Request implements RequestInterface +{ + use MessageTrait; + + /** + * HTTP method of the request + * + * @var string + */ + protected $method; + + /** + * The request target + * + * @var string|null + */ + protected $requestTarget; + + /** + * URI of the request + * + * @var UriInterface + */ + protected $uri; + + /** + * Create a new HTTP request + * + * @param string $method HTTP method + * @param string $uri URI + * @param array $headers Request headers + * @param string $body Request body + * @param string $protocolVersion Protocol version + */ + public function __construct($method, $uri, array $headers = [], $body = null, $protocolVersion = '1.1') + { + $this->method = $method; + $this->uri = new Uri($uri); + $this->setHeaders($headers); + $this->body = Stream::create($body); + $this->protocolVersion = $protocolVersion; + + $this->provideHostHeader(); + } + + public function getRequestTarget() + { + if ($this->requestTarget !== null) { + return $this->requestTarget; + } + + $requestTarget = $this->uri->getPath(); + + // Weak type checks to also check null + + if ($requestTarget == '') { + $requestTarget = '/'; + } + + if ($this->uri->getQuery() != '') { + $requestTarget .= '?' . $this->uri->getQuery(); + } + + return $requestTarget; + } + + public function withRequestTarget($requestTarget) + { + $request = clone $this; + $request->requestTarget = $requestTarget; + + return $request; + } + + public function getMethod() + { + return $this->method; + } + + public function withMethod($method) + { + $request = clone $this; + $request->method = $method; + + return $this; + } + + public function getUri() + { + return $this->uri; + } + + public function withUri(UriInterface $uri, $preserveHost = false) + { + $request = clone $this; + $request->uri = $uri; + + if (! $preserveHost) { + $this->provideHostHeader(true); + } + + return $this; + } + + protected function provideHostHeader($force = false) + { + if ($this->hasHeader('host')) { + if (! $force) { + return; + } + + $header = $this->headerNames['host']; + } else { + $header = 'Host'; + } + + $host = $this->uri->getHost(); + + // Weak type check to also check null + if ($host == '') { + $host = ''; + } else { + $port = $this->uri->getPort(); + + if ($port !== null) { + $host .= ":$port"; + } + } + + $this->headerNames['host'] = $header; + $this->headerValues['host'] = [$host]; + } +} diff --git a/library/vendor/iplx/Http/Response.php b/library/vendor/iplx/Http/Response.php new file mode 100644 index 0000000..25448b1 --- /dev/null +++ b/library/vendor/iplx/Http/Response.php @@ -0,0 +1,64 @@ +<?php + +namespace iplx\Http; + +use Psr\Http\Message\ResponseInterface; + +/** + * A HTTP response + */ +class Response implements ResponseInterface +{ + use MessageTrait; + + /** + * Status code of the response + * + * @var int + */ + protected $statusCode; + + /** + * Response status reason phrase + * + * @var string + */ + protected $reasonPhrase = ''; + + /** + * Create a new HTTP response + * + * @param int $statusCode Response status code + * @param array $headers Response headers + * @param string $body Response body + * @param string $protocolVersion Protocol version + * @param string $reasonPhrase Response status reason phrase + */ + public function __construct($statusCode = 200, array $headers = [], $body = null, $protocolVersion = '1.1', $reasonPhrase = '') + { + $this->statusCode = $statusCode; + $this->setHeaders($headers); + $this->body = Stream::create($body); + $this->protocolVersion = $protocolVersion; + $this->reasonPhrase = $reasonPhrase; + } + + public function getStatusCode() + { + return $this->statusCode; + } + + public function withStatus($code, $reasonPhrase = '') + { + $response = clone $this; + $response->statusCode = $code; + $response->reasonPhrase = $reasonPhrase; + + return $response; + } + + public function getReasonPhrase() + { + return $this->reasonPhrase; + } +} diff --git a/library/vendor/iplx/Http/Stream.php b/library/vendor/iplx/Http/Stream.php new file mode 100644 index 0000000..a113312 --- /dev/null +++ b/library/vendor/iplx/Http/Stream.php @@ -0,0 +1,283 @@ +<?php + +namespace iplx\Http; + +use Exception; +use InvalidArgumentException; +use RuntimeException; +use Psr\Http\Message\StreamInterface; + +class Stream implements StreamInterface +{ + protected $stream; + + protected $size; + + protected $seekable; + + protected $readable; + + protected $writable; + + public function __construct($stream) + { + if (! is_resource($stream)) { + throw new InvalidArgumentException('Invalid stream resource'); + } + + $this->stream = $stream; + + $meta = stream_get_meta_data($this->stream); + $this->seekable = $meta['seekable']; + $this->readable = preg_match('/[r+]/', $meta['mode']) === 1; + $this->writable = preg_match('/[waxc+]/', $meta['mode']) === 1; + } + + public function __destruct() + { + $this->close(); + } + + public function __toString() + { + try { + $this->seek(0); + $contents = stream_get_contents($this->stream); + } catch (Exception $e) { + $contents = ''; + } + + return $contents; + } + + public function close() + { + if (isset($this->stream)) { + if (is_resource($this->stream)) { + fclose($this->stream); + } + $this->detach(); + } + } + + public function detach() + { + if (! isset($this->stream)) { + return null; + } + + $stream = $this->stream; + + $this->stream = null; + $this->size = null; + $this->seekable = false; + $this->readable = false; + $this->writable = false; + + return $stream; + } + + public function getSize() + { + if ($this->size !== null) { + return $this->size; + } + + if (! isset($this->stream)) { + return null; + } + + $stats = fstat($this->stream); + $this->size = $stats['size']; + + return $this->size; + } + + public function tell() + { + $this->assertAttached(); + + $position = ftell($this->stream); + + if ($position === false) { + throw new RuntimeException('Unable to determine stream position'); + } + + return $position; + } + + public function eof() + { + $this->assertAttached(); + + return feof($this->stream); + } + + public function isSeekable() + { + return $this->seekable; + } + + public function seek($offset, $whence = SEEK_SET) + { + $this->assertSeekable(); + + if (fseek($this->stream, $offset, $whence) === -1) { + throw new RuntimeException('Unable to seek to stream position'); + } + } + + public function rewind() + { + $this->seek(0); + } + + public function isWritable() + { + return $this->writable; + } + + public function write($string) + { + $this->assertWritable(); + + $written = fwrite($this->stream, $string); + + if ($written === false) { + throw new RuntimeException('Unable to write to stream'); + } + + return $written; + } + + public function isReadable() + { + return $this->readable; + } + + public function read($length) + { + $this->assertReadable(); + + $data = fread($this->stream, $length); + + if ($data === false) { + throw new RuntimeException('Unable to read from stream'); + } + + return $data; + } + + public function getContents() + { + $this->assertReadable(); + + $contents = stream_get_contents($this->stream); + + if ($contents === false) { + throw new RuntimeException('Unable to read stream contents'); + } + + return $contents; + } + + public function getMetadata($key = null) + { + if (! isset($this->stream)) { + return $key === null ? [] : null; + } + + $meta = stream_get_meta_data($this->stream); + + if ($key === null) { + return $meta; + } + + if (isset($meta[$key])) { + return $meta[$key]; + } + + return null; + } + + public function assertAttached() + { + if (! isset($this->stream)) { + throw new RuntimeException('Stream is detached'); + } + } + + public function assertSeekable() + { + $this->assertAttached(); + + if (! $this->isSeekable()) { + throw new RuntimeException('Stream is not seekable'); + } + } + + public function assertReadable() + { + $this->assertAttached(); + + if (! $this->isReadable()) { + throw new RuntimeException('Stream is not readable'); + } + } + + public function assertWritable() + { + $this->assertAttached(); + + if (! $this->isWritable()) { + throw new RuntimeException('Stream is not writable'); + } + } + + /** + * Open a stream + * + * @param string $filename + * @param string $mode + * + * @return static + */ + public static function open($filename = 'php://temp', $mode = 'r+') + { + $stream = fopen($filename, $mode); + + return new static($stream); + } + + /** + * Create a stream + * + * @param StreamInterface|string|resource $resource + * + * @return StreamInterface + */ + public static function create($resource) + { + if ($resource instanceof StreamInterface) { + return $resource; + } + + if (is_scalar($resource)) { + $stream = fopen('php://temp', 'r+'); + + if ($resource !== '') { + fwrite($stream, $resource); + fseek($stream, 0); + } + + return new static($stream); + } + + if (is_resource($resource)) { + return new static($resource); + } + + return static::open(); + } + +} diff --git a/library/vendor/iplx/Http/Uri.php b/library/vendor/iplx/Http/Uri.php new file mode 100644 index 0000000..044fb17 --- /dev/null +++ b/library/vendor/iplx/Http/Uri.php @@ -0,0 +1,202 @@ +<?php + +namespace iplx\Http; + +use InvalidArgumentException; +use Psr\Http\Message\UriInterface; + +class Uri implements UriInterface +{ + protected $scheme; + + protected $host; + + protected $port; + + protected $user; + + protected $pass; + + protected $path; + + protected $query; + + protected $fragment; + + public function __construct($uri = null) + { + $parts = parse_url($uri); + + if ($parts === false) { + throw new InvalidArgumentException(); + } + + foreach ($parts as $component => $value) { + $this->$component = $value; + } + } + + public function getScheme() + { + return $this->scheme; + } + + public function getAuthority() + { + // Weak type check to also check null + if ($this->host == '') { + return ''; + } + + $authority = $this->host; + + $userInfo = $this->getUserInfo(); + $port = $this->getPort(); + + if ($userInfo) { + $authority = "$userInfo@$authority"; + } + + if ($port !== null) { + $authority .= ":$port"; + } + + return $authority; + } + + public function getUserInfo() + { + $userInfo = $this->user; + + if ($this->pass !== null) { + $userInfo .= ":{$this->pass}"; + } + + return $userInfo; + } + + public function getHost() + { + return $this->host; + } + + public function getPort() + { + return $this->port; + } + + public function getPath() + { + return $this->path; + } + + public function getQuery() + { + return $this->query; + } + + public function getFragment() + { + return $this->fragment; + } + + public function withScheme($scheme) + { + $uri = clone $this; + $uri->scheme = $scheme; + + return $uri; + } + + public function withUserInfo($user, $password = null) + { + $uri = clone $this; + $uri->user = $user; + $uri->pass = $password; + + return $uri; + } + + public function withHost($host) + { + $uri = clone $this; + $uri->host = $host; + + return $uri; + } + + public function withPort($port) + { + $uri = clone $this; + $uri->port = $port; + + return $uri; + } + + public function withPath($path) + { + $uri = clone $this; + $uri->path = $path; + + return $uri; + } + + public function withQuery($query) + { + $uri = clone $this; + $uri->query = $query; + + return $uri; + } + + public function withFragment($fragment) + { + $uri = clone $this; + $uri->fragment = $fragment; + + return $uri; + } + + public function __toString() + { + $scheme = $this->getScheme(); + $authority = $this->getAuthority(); + $path = $this->getPath(); + $query = $this->getQuery(); + $fragment = $this->getFragment(); + + $uri = ''; + + // Weak type checks to also check null + + if ($scheme != '') { + $uri = "$scheme:"; + } + + if ($authority != '') { + $uri .= "//$authority"; + } + + if ($path != '') { + if ($path[0] === '/') { + if ($authority == '') { + $path = ltrim($path, '/'); + } + } else { + $path = "/$path"; + } + + $uri .= $path; + } + + if ($query != '') { + $uri .= "?$query"; + } + + if ($fragment != '') { + $uri .= "#$fragment"; + } + + return $uri; + } +} diff --git a/library/vendor/iplx/LICENSE b/library/vendor/iplx/LICENSE new file mode 100644 index 0000000..ecbc059 --- /dev/null +++ b/library/vendor/iplx/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License.
\ No newline at end of file diff --git a/library/vendor/iplx/Loader.php b/library/vendor/iplx/Loader.php new file mode 100644 index 0000000..5a6c9c0 --- /dev/null +++ b/library/vendor/iplx/Loader.php @@ -0,0 +1,20 @@ +<?php + +spl_autoload_register(function ($class) { + $prefix = 'iplx\\'; + $len = strlen($prefix); + + $baseDir = __DIR__ . '/'; + + if (strncmp($prefix, $class, $len) !== 0) { + return; + } + + $relative = substr($class, $len); + + $file = $baseDir . str_replace('\\', '/', $relative) . '.php'; + + if (file_exists($file)) { + require $file; + } +}); diff --git a/library/vendor/iplx/README b/library/vendor/iplx/README new file mode 100644 index 0000000..aa0b11e --- /dev/null +++ b/library/vendor/iplx/README @@ -0,0 +1 @@ +Experimental version of the not released Icinga PHP Library (ipl). Do not use. |