288 lines
9.2 KiB
C++
288 lines
9.2 KiB
C++
/*
|
|
* Copyright (C) 2019 Emeric Poupon
|
|
*
|
|
* This file is part of LMS.
|
|
*
|
|
* LMS 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* LMS 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 LMS. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#pragma once
|
|
|
|
#include <map>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <variant>
|
|
#include <vector>
|
|
|
|
#include "utils/LiteralString.hpp"
|
|
#include "RequestContext.hpp"
|
|
|
|
namespace API::Subsonic
|
|
{
|
|
// Max count expected from all API methods that expose a count
|
|
static inline constexpr std::size_t defaultMaxCountSize{ 1000 };
|
|
|
|
enum class ResponseFormat
|
|
{
|
|
xml,
|
|
json,
|
|
};
|
|
|
|
std::string_view ResponseFormatToMimeType(ResponseFormat format);
|
|
|
|
class Error
|
|
{
|
|
public:
|
|
enum class Code
|
|
{
|
|
Generic = 0,
|
|
RequiredParameterMissing = 10,
|
|
ClientMustUpgrade = 20,
|
|
ServerMustUpgrade = 30,
|
|
WrongUsernameOrPassword = 40,
|
|
TokenAuthenticationNotSupportedForLDAPUsers = 41,
|
|
UserNotAuthorized = 50,
|
|
RequestedDataNotFound = 70,
|
|
};
|
|
|
|
Error(Code code) : _code{ code } {}
|
|
|
|
virtual std::string getMessage() const = 0;
|
|
|
|
Code getCode() const { return _code; }
|
|
|
|
private:
|
|
const Code _code;
|
|
};
|
|
|
|
class GenericError : public Error
|
|
{
|
|
public:
|
|
GenericError() : Error{ Code::Generic } {}
|
|
};
|
|
|
|
class RequiredParameterMissingError : public Error
|
|
{
|
|
public:
|
|
RequiredParameterMissingError(std::string_view param)
|
|
: Error{ Code::RequiredParameterMissing }
|
|
, _param{ param }
|
|
{}
|
|
|
|
private:
|
|
std::string getMessage() const override { return "Required parameter '" + _param + "' is missing."; }
|
|
std::string _param;
|
|
};
|
|
|
|
class ClientMustUpgradeError : public Error
|
|
{
|
|
public:
|
|
ClientMustUpgradeError() : Error{ Code::ClientMustUpgrade } {}
|
|
private:
|
|
std::string getMessage() const override { return "Incompatible Subsonic REST protocol version. Client must upgrade."; }
|
|
};
|
|
|
|
class ServerMustUpgradeError : public Error
|
|
{
|
|
public:
|
|
ServerMustUpgradeError() : Error{ Code::ServerMustUpgrade } {}
|
|
private:
|
|
std::string getMessage() const override { return "Incompatible Subsonic REST protocol version. Server must upgrade."; }
|
|
};
|
|
|
|
class WrongUsernameOrPasswordError : public Error
|
|
{
|
|
public:
|
|
WrongUsernameOrPasswordError() : Error{ Code::WrongUsernameOrPassword } {}
|
|
private:
|
|
std::string getMessage() const override { return "Wrong username or password."; }
|
|
};
|
|
|
|
class TokenAuthenticationNotSupportedForLDAPUsersError : public Error
|
|
{
|
|
public:
|
|
TokenAuthenticationNotSupportedForLDAPUsersError() : Error{ Code::TokenAuthenticationNotSupportedForLDAPUsers } {}
|
|
private:
|
|
std::string getMessage() const override { return "Token authentication not supported for LDAP users."; }
|
|
};
|
|
|
|
class UserNotAuthorizedError : public Error
|
|
{
|
|
public:
|
|
UserNotAuthorizedError() : Error{ Code::UserNotAuthorized } {}
|
|
private:
|
|
std::string getMessage() const override { return "User is not authorized for the given operation."; }
|
|
};
|
|
|
|
class RequestedDataNotFoundError : public Error
|
|
{
|
|
public:
|
|
RequestedDataNotFoundError() : Error{ Code::RequestedDataNotFound } {}
|
|
private:
|
|
std::string getMessage() const override { return "The requested data was not found."; }
|
|
};
|
|
|
|
class InternalErrorGenericError : public GenericError
|
|
{
|
|
public:
|
|
InternalErrorGenericError(const std::string& message) : _message{ message } {}
|
|
private:
|
|
std::string getMessage() const override { return "Internal error: " + _message; }
|
|
const std::string _message;
|
|
};
|
|
|
|
class LoginThrottledGenericError : public GenericError
|
|
{
|
|
std::string getMessage() const override { return "Login throttled, too many attempts"; }
|
|
};
|
|
|
|
class NotImplementedGenericError : public GenericError
|
|
{
|
|
std::string getMessage() const override { return "Not implemented"; }
|
|
};
|
|
|
|
class UnknownEntryPointGenericError : public GenericError
|
|
{
|
|
std::string getMessage() const override { return "Unknown API method"; }
|
|
};
|
|
|
|
class PasswordTooWeakGenericError : public GenericError
|
|
{
|
|
std::string getMessage() const override { return "Password too weak"; }
|
|
};
|
|
|
|
class PasswordMustMatchLoginNameGenericError : public GenericError
|
|
{
|
|
std::string getMessage() const override { return "Password must match login name"; }
|
|
};
|
|
|
|
class DemoUserCannotChangePasswordGenericError : public GenericError
|
|
{
|
|
std::string getMessage() const override { return "Demo user cannot change its password"; }
|
|
};
|
|
|
|
class UserAlreadyExistsGenericError : public GenericError
|
|
{
|
|
std::string getMessage() const override { return "User already exists"; }
|
|
};
|
|
|
|
class BadParameterGenericError : public GenericError
|
|
{
|
|
public:
|
|
BadParameterGenericError(const std::string& parameterName) : _parameterName{ parameterName } {}
|
|
|
|
private:
|
|
std::string getMessage() const override { return "Parameter '" + _parameterName + "': bad value"; }
|
|
|
|
const std::string _parameterName;
|
|
};
|
|
|
|
class ParameterValueTooHighGenericError : public GenericError
|
|
{
|
|
public:
|
|
ParameterValueTooHighGenericError(std::string_view parameterName, std::size_t max) : _parameterName{ parameterName }, _max{ max } {}
|
|
|
|
private:
|
|
std::string getMessage() const override { return "Parameter '" + _parameterName + "': bad value (max is " + std::to_string(_max) + ")"; }
|
|
|
|
const std::string _parameterName;
|
|
std::size_t _max;
|
|
};
|
|
|
|
class Response
|
|
{
|
|
public:
|
|
class Node
|
|
{
|
|
public:
|
|
using Key = LiteralString;
|
|
|
|
void setAttribute(Key key, std::string_view value);
|
|
|
|
template <typename T, std::enable_if_t<std::is_arithmetic<T>::value>* = nullptr>
|
|
void setAttribute(Key key, T value)
|
|
{
|
|
if constexpr (std::is_same<bool, T>::value)
|
|
_attributes[key] = value;
|
|
else if constexpr (std::is_floating_point<T>::value)
|
|
_attributes[key] = static_cast<float>(value);
|
|
else if constexpr (std::is_integral<T>::value)
|
|
_attributes[key] = static_cast<long long>(value);
|
|
else
|
|
static_assert("Unhandled type");
|
|
}
|
|
|
|
// A Node has either a single value or an array of values or some children
|
|
void setValue(std::string_view value);
|
|
void setValue(long long value);
|
|
Node& createChild(Key key);
|
|
Node& createArrayChild(Key key);
|
|
|
|
void addChild(Key key, Node&& node);
|
|
void createEmptyArrayChild(Key key);
|
|
void addArrayChild(Key key, Node&& node);
|
|
void createEmptyArrayValue(Key key);
|
|
void addArrayValue(Key key, std::string_view value);
|
|
void addArrayValue(Key key, long long value);
|
|
|
|
private:
|
|
void setVersionAttribute(ProtocolVersion version);
|
|
|
|
friend class Response;
|
|
using ValueType = std::variant<std::string, bool, float, long long>;
|
|
std::map<Key, ValueType> _attributes;
|
|
std::optional<ValueType> _value;
|
|
std::map<Key, Node> _children;
|
|
std::map<Key, std::vector<Node>> _childrenArrays;
|
|
|
|
using ValuesType = std::vector<ValueType>;
|
|
std::map<Key, ValuesType> _childrenValues;
|
|
};
|
|
|
|
static Response createOkResponse(ProtocolVersion protocolVersion);
|
|
static Response createFailedResponse(ProtocolVersion protocolVersion, const Error& error);
|
|
|
|
virtual ~Response() {}
|
|
Response(const Response&) = delete;
|
|
Response& operator=(const Response&) = delete;
|
|
Response(Response&&) = default;
|
|
Response& operator=(Response&&) = default;
|
|
|
|
void addNode(Node::Key key, Node&& node);
|
|
Node& createNode(Node::Key key);
|
|
Node& createArrayNode(Node::Key key);
|
|
|
|
void write(std::ostream& os, ResponseFormat format) const;
|
|
|
|
private:
|
|
static Response createResponseCommon(ProtocolVersion protocolVersion, const Error* error = nullptr);
|
|
|
|
class JsonSerializer
|
|
{
|
|
public:
|
|
void serializeNode(std::ostream& os, const Node& node);
|
|
void serializeValue(std::ostream& os, const Node::ValueType& node);
|
|
void serializeEscapedString(std::ostream&, std::string_view str);
|
|
};
|
|
|
|
void writeJSON(std::ostream& os) const;
|
|
void writeXML(std::ostream& os) const;
|
|
|
|
Response() = default;
|
|
Node _root;
|
|
};
|
|
|
|
} // namespace
|
|
|