licensing.hpp

#if !defined(VRAY_INTERNAL_LICENSING) || defined(VRAY_INTERNAL_GENERATE_IMPORT_CODE)
 
#include <ctime>
 
#ifndef VRAY_INTERNAL_LICENSING
#define VRAY_INTERNAL_LICENSING
#include "vraysdk.hpp"
#endif
 
#if !defined(VRAY_RUNTIME_LOAD_PRIMARY) && !defined(VRAY_RUNTIME_LOAD_SECONDARY)
#   define VRAYSDK_FUNC(ret, name, ...) extern ret name(__VA_ARGS__)
#   define VRAYSDK_FUNCT VRAYSDK_FUNC
#else
#   ifdef VRAY_RUNTIME_LOAD_SECONDARY
#       define VRAYSDK_FUNC(ret, name, ...) extern ret (*name)(__VA_ARGS__)
#       define VRAYSDK_FUNCT VRAYSDK_FUNC
#   else
#       ifndef VRAY_INTERNAL_GENERATE_IMPORT_CODE
#           define VRAYSDK_FUNC(ret, name, ...) ret (*name)(__VA_ARGS__) = nullptr
#           define VRAYSDK_FUNCT VRAYSDK_FUNC
#       else
#           define VRAYSDK_FUNC(ret, name, ...) \
                if (!(Internal::name = (decltype(Internal::name))Internal::GetProcAddress(hLib, #name))) \
                    PROC_IMPORT_FAIL(#name)
#           define VRAYSDK_FUNCT(ret, name, ...) \
                Internal::name = (decltype(Internal::name))Internal::GetProcAddress(hLib, #name)
#       endif
#   endif
#endif
 
#ifndef VRAY_INTERNAL_GENERATE_IMPORT_CODE
 
namespace VRay {
 
struct AccessTokenView {
    const char* token;
    long long expiry;
 
    int isValid() const {
        return getRelativeExpiry() > 0;
    }
 
    long long getRelativeExpiry() const {
        if (!token || !*token || expiry <= 0) {
            return -1;
        }
        const time_t currentTime = std::time(nullptr);
        return expiry - static_cast<long long>(currentTime);
    }
};
 
struct ActiveUserDetailsView {
    const char* email; 
    const char* uuid; 
    const char* firstName; 
    const char* lastName; 
    AccessTokenView userAccessToken; 
};
 
struct AccessToken {
    std::string token;
    long long expiry;
 
    int isValid() const {
        return getRelativeExpiry() > 0;
    }
 
    long long getRelativeExpiry() const {
        if (token.empty() || expiry <= 0) {
            return -1;
        }
        const time_t currentTime = std::time(nullptr);
        return expiry - static_cast<long long>(currentTime);
    }
 
    AccessToken() : expiry() {}
 
    AccessToken(const AccessTokenView& view) :
        token(view.token ? view.token : ""), expiry(view.expiry) {}
};
 
struct ActiveUserDetails {
    std::string email; 
    std::string uuid; 
    std::string firstName; 
    std::string lastName; 
    AccessToken userAccessToken; 
 
    ActiveUserDetails(const ActiveUserDetailsView& view) :
        email(view.email ? view.email : ""),
        uuid(view.uuid ? view.uuid : ""),
        firstName(view.firstName ? view.firstName : ""),
        lastName(view.lastName ? view.lastName : ""),
        userAccessToken(view.userAccessToken) { }
 
    ActiveUserDetails() = default;
};
 
namespace Internal {
 
#if !defined(VRAY_RUNTIME_LOAD_PRIMARY) && !defined(VRAY_RUNTIME_LOAD_SECONDARY)
extern "C" {
#endif
 
typedef void (*UnifiedLoginClient_onLogin)(const ActiveUserDetailsView* userDetails, void* userData);
typedef void (*UnifiedLoginClient_onLogout)(void* userData);
 
#endif // !VRAY_INTERNAL_GENERATE_IMPORT_CODE
 
VRAYSDK_FUNC(void*, UnifiedLoginClient_init, const char* newApplicationId, unsigned initFlags, void** errStrHandle);
VRAYSDK_FUNC(Bool, UnifiedLoginClient_isInitialized);
VRAYSDK_FUNC(int, UnifiedLoginClient_startEventServer, void** errStrHandle);
VRAYSDK_FUNC(Bool, UnifiedLoginClient_isEventServerStarted);
VRAYSDK_FUNC(int, UnifiedLoginClient_getEventServerPort);
VRAYSDK_FUNC(void, UnifiedLoginClient_done);
VRAYSDK_FUNC(int, UnifiedLoginClient_setOnLogInOut, UnifiedLoginClient_onLogin loginCallback, UnifiedLoginClient_onLogout logoutCallback, const void* userData);
VRAYSDK_FUNC(int, UnifiedLoginClient_getActiveUserDetails, ActiveUserDetailsView* details, void** errStrHandle);
VRAYSDK_FUNC(int, UnifiedLoginClient_loginSync, ActiveUserDetailsView* details, void** errStrHandle);
VRAYSDK_FUNC(int, UnifiedLoginClient_login, void** errStrHandle);
VRAYSDK_FUNC(int, UnifiedLoginClient_logoutSync, void** errStrHandle);
VRAYSDK_FUNC(int, UnifiedLoginClient_logout, void** errStrHandle);
VRAYSDK_FUNC(void, UnifiedLoginClient_setSyncTimeout, int timeoutMs);
VRAYSDK_FUNC(int, UnifiedLoginClient_setCustomPrompt, const char *loginPrompt, void** errHandle);
 
#if VRAY_AUTH_MORE_STUFF
VRAYSDK_FUNC(int, iota_omega);
VRAYSDK_FUNC(void, iota_zeta);
VRAYSDK_FUNC(void, iota_rho, unsigned, unsigned);
VRAYSDK_FUNC(void, xi, void(*)(const char**, const char**, const char**, const char**));
 
VRAYSDK_FUNCT(void, nu_lambda, int type, const char* typeDetails);
VRAYSDK_FUNCT(int, nu_rho, int updateParameters);
VRAYSDK_FUNCT(int, nu_alpha);
#endif
 
#ifndef VRAY_INTERNAL_GENERATE_IMPORT_CODE
 
#if !defined(VRAY_RUNTIME_LOAD_PRIMARY) && !defined(VRAY_RUNTIME_LOAD_SECONDARY)
} // extern "C"
#endif
 
} // namespace Internal
 
#ifdef VRAY_RUNTIME_LOAD_PRIMARY
class ULAClient : private VRayInit {
#else
class ULAClient {
#endif // VRAY_RUNTIME_LOAD_PRIMARY
    ULAClient() = delete;
    ~ULAClient() = delete;
 
public:
    typedef void (*OnLogin)(const ActiveUserDetailsView* activeUserDetails, void* userData);
    typedef void (*OnLogout)(void* userData);
 
    enum Flags : unsigned {
        flag_default = 0u, 
        flag_noEventServer = 1u << 0, 
        flag_delayedServer = 1u << 1, 
        flag_uniqueProcess = 1u << 2, 
    };
 
#ifdef VRAY_RUNTIME_LOAD_PRIMARY
 
#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning(disable: 4706) // "assignment within conditional expression" - for ULAClient::loadFunctions()
#endif // _MSC_VER
 
private:
    void loadFunctions() {
#       define VRAY_INTERNAL_GENERATE_IMPORT_CODE
#       undef VRAYSDK_FUNCT
#       undef VRAYSDK_FUNC
#       include "licensing.hpp"
#       undef VRAY_INTERNAL_GENERATE_IMPORT_CODE
    }
 
#ifdef _MSC_VER
#   pragma warning(pop)
#endif // _MSC_VER
 
public:
    static void load(VRayInit& vrayinit) {
        static_cast<ULAClient&>(vrayinit).loadFunctions();
    }
#endif // VRAY_RUNTIME_LOAD_PRIMARY
 
    static void* init(const char* newApplicationId, unsigned initFlags, std::string& error) {
        void* errHandle;
        void* handle = Internal::UnifiedLoginClient_init(newApplicationId, initFlags, &errHandle);
        error = Internal::getCharStringContent(&errHandle);
        Internal::releaseCharString(&errHandle);
        return handle;
    }
 
    static bool isInitialized() {
        return !!Internal::UnifiedLoginClient_isInitialized();
    }
 
    static bool startEventServer(std::string& error) {
        void* errHandle;
        int err = Internal::UnifiedLoginClient_startEventServer(&errHandle);
        return returnErrorResult(err, &errHandle, error);
    }
 
    static bool isEventServerStarted() {
        return !!Internal::UnifiedLoginClient_isEventServerStarted();
    }
 
    static void done() {
        Internal::UnifiedLoginClient_done();
    }
 
    static int getEventServerPort() {
        return Internal::UnifiedLoginClient_getEventServerPort();
    }
 
    static bool setOnLogInLogOut(OnLogin loginCallback, OnLogout logoutCallback, const void* userData = nullptr) {
        return !Internal::UnifiedLoginClient_setOnLogInOut(loginCallback, logoutCallback, userData);
    }
 
    static bool getActiveUserDetails(ActiveUserDetails& userDetails, std::string& error) {
        return returnActiveUserDetailsResult(
            Internal::UnifiedLoginClient_getActiveUserDetails,
            userDetails, error);
    }
 
    static bool loginSync(ActiveUserDetails& userDetails, std::string& error) {
        return returnActiveUserDetailsResult(
            Internal::UnifiedLoginClient_loginSync,
            userDetails, error);
    }
 
    static bool login(std::string& error) {
        void* errHandle;
        int err = Internal::UnifiedLoginClient_login(&errHandle);
        return returnErrorResult(err, &errHandle, error);
    }
 
    static bool logoutSync(std::string& error) {
        void* errHandle;
        int err = Internal::UnifiedLoginClient_logoutSync(&errHandle);
        return returnErrorResult(err, &errHandle, error);
    }
 
    static bool logout(std::string& error) {
        void* errHandle;
        int err = Internal::UnifiedLoginClient_logout(&errHandle);
        return returnErrorResult(err, &errHandle, error);
    }
 
    static void setSyncTimeout(int timeoutMs) {
        Internal::UnifiedLoginClient_setSyncTimeout(timeoutMs);
    }
 
    static bool setCustomPrompt(const char *loginPrompt, std::string &error) {
        void *errHandle;
        const int err = Internal::UnifiedLoginClient_setCustomPrompt(loginPrompt, &errHandle);
        return returnErrorResult(err, &errHandle, error);
    }
 
private:
    static bool returnActiveUserDetailsResult(
        int (*activeUserDetailsFunc)(ActiveUserDetailsView* details, void** errStrHandle),
        ActiveUserDetails& userDetails, std::string& error)
    {
        ActiveUserDetailsView view;
        void* errHandle;
        int err = activeUserDetailsFunc(&view, &errHandle);
 
        userDetails.email = Internal::getCharStringContent(&view.email);
        Internal::releaseCharString(&view.email);
        userDetails.uuid = Internal::getCharStringContent(&view.uuid);
        Internal::releaseCharString(&view.uuid);
        userDetails.firstName = Internal::getCharStringContent(&view.firstName);
        Internal::releaseCharString(&view.firstName);
        userDetails.lastName = Internal::getCharStringContent(&view.lastName);
        Internal::releaseCharString(&view.lastName);
        userDetails.userAccessToken.token = Internal::getCharStringContent(&view.userAccessToken.token);
        Internal::releaseCharString(&view.userAccessToken.token);
        userDetails.userAccessToken.expiry = view.userAccessToken.expiry;
 
        return returnErrorResult(err, &errHandle, error);
    }
 
    static bool returnErrorResult(int err, void** errStrHandle, std::string& error) {
        error = Internal::getCharStringContent(errStrHandle);
        Internal::releaseCharString(errStrHandle);
        return !err;
    }
};
 
#undef VRAYSDK_FUNCT
#undef VRAYSDK_FUNC
 
} // namespace VRay
 
#endif // !VRAY_INTERNAL_GENERATE_IMPORT_CODE
 
#endif