ffrunner.c

#include "ffrunner.h"
#include "arg.h"

NPP_t npp;
NPPluginFuncs pluginFuncs;
NPNetscapeFuncs netscapeFuncs;
NPSavedData saved;
NPSavedData *savedPtr;
NPObject browserObject;
NPClass browserClass;
NPWindow npWin;
NPObject *scriptableObject;

Arguments args = { 0 };

#define NPIDENTIFIERCOUNT 32
#define NPSTRINGMAXSIZE 128

char npidentifiers[NPIDENTIFIERCOUNT][NPSTRINGMAXSIZE];

NPIdentifier
getNPIdentifier(const char *s)
{
    int i;

    assert(*s != '\0');
    assert(strlen(s) < NPSTRINGMAXSIZE);

    for (i = 0; i < NPIDENTIFIERCOUNT; i++) {
        if (strncmp(s, npidentifiers[i], NPSTRINGMAXSIZE) == 0)
            return (NPIdentifier)&npidentifiers[i];

        if (npidentifiers[i][0] == '\0')
            break;
    }
    /*
     * Make sure there's still room.
     * i would have already been incremented to NPIDENTIFIERCOUNT if
     * the loop went through all iterations.
     */
    assert(i < NPIDENTIFIERCOUNT);

    assert(npidentifiers[i][0] == '\0');
    strncpy(npidentifiers[i], s, NPSTRINGMAXSIZE);
    return &npidentifiers[i];
}

NPError
NPN_GetURLProc(NPP instance, const char* url, const char* window)
{
    dbglogmsg("< NPN_GetURLProc:%p, url: %s, window: %s\n", instance, url, window);

    register_get_request(url, false, NULL);

    return NPERR_NO_ERROR;
}

NPError
NPN_GetURLNotifyProc(NPP instance, const char* url, const char* window, void* notifyData)
{
    dbglogmsg("< NPN_GetURLNotifyProc:%p, url: %s, window: %s, notifyData: %p\n", instance, url, window, notifyData);

    register_get_request(url, true, notifyData);

    return NPERR_NO_ERROR;
}

NPError
NPN_PostURLProc(NPP instance, const char* url, const char* window, uint32_t len, const char* buf, NPBool file)
{
    dbglogmsg("< NPN_PostURLProc:%p, url: %s, window: %s, len: %d, buf: %s, file: %d\n",
            instance, url, window, len, buf, file);

    register_post_request(url, false, NULL, len, buf);

    return NPERR_NO_ERROR;
}

NPError
NPN_PostURLNotifyProc(NPP instance, const char* url, const char* window, uint32_t len, const char* buf, NPBool file, void* notifyData)
{
    dbglogmsg("< NPN_PostURLNotifyProc:%p, url: %s, window: %s, len: %d, buf: %s, file: %d, notifyData: %p\n",
            instance, url, window, len, buf, file, notifyData);

    register_post_request(url, true, notifyData, len, buf);

    return NPERR_NO_ERROR;
}

const char *
NPN_UserAgentProc(NPP instance)
{
    dbglogmsg("< NPN_UserAgentProc, NPP:%p\n", instance);
    return USERAGENT;
}

bool
NPN_GetPropertyProc(NPP npp, NPObject *obj, NPIdentifier propertyName, NPVariant *result)
{
    dbglogmsg("< NPN_GetPropertyProc\n");
    return false;
}

bool
NPN_InvokeProc(NPP npp, NPObject* obj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
    dbglogmsg("< NPN_InvokeProc:%p, obj: %p, methodName: %p, argCount:%d\n", npp, obj, methodName, argCount);
    return false;
}

void *
NPN_MemAllocProc(uint32_t size)
{
    return malloc(size);
}

void
NPN_MemFreeProc(void *ptr)
{
    free(ptr);
}

NPObject *
NPN_CreateObjectProc(NPP npp, NPClass *aClass)
{
    NPObject *npobj;

    dbglogmsg("< NPN_CreateObjectProc\n");
    assert(aClass);

    if (aClass->allocate)
        npobj = aClass->allocate(npp, aClass);
    else
        npobj = malloc(sizeof(*npobj));

    if (npobj) {
        npobj->_class = aClass;
        npobj->referenceCount = 1;
    }

    return npobj;
}

NPObject *
NPN_RetainObjectProc(NPObject *obj)
{
    dbglogmsg("< NPN_RetainObjectProc\n");
    assert(obj);
    obj->referenceCount++;
    return obj;
}

void
NPN_ReleaseObjectProc(NPObject *obj)
{
    dbglogmsg("< NPN_ReleaseObjectProc\n");
    assert(obj);

    obj->referenceCount--;

    if (obj->referenceCount == 0) {
        /* should never ask to deallocate the (statically allocated) browser window object */
        assert(obj != &browserObject);

        if (obj->_class && obj->_class->deallocate)
            obj->_class->deallocate(obj);
        else
            free(obj);
    }
}

void
NPN_ReleaseVariantValueProc(NPVariant *variant)
{
    dbglogmsg("< NPN_ReleaseVariantValueProc\n");

    if (NPVARIANT_IS_STRING(*variant))
        NPN_MemFreeProc((void *)NPVARIANT_TO_STRING(*variant).UTF8Characters);
    else if (NPVARIANT_IS_OBJECT(*variant))
        NPN_ReleaseObjectProc(NPVARIANT_TO_OBJECT(*variant));

    VOID_TO_NPVARIANT(*variant);
}

NPError
NPN_GetValueProc(NPP instance, NPNVariable variable, void *ret_value)
{
    NPObject **retPtr;

    dbglogmsg("< NPN_GetValueProc %d\n", variable);

    browserObject.referenceCount++;

    retPtr = (NPObject**)ret_value;
    *retPtr = &browserObject;

    return NPERR_NO_ERROR;
}

#define AUTH_CALLBACK_SCRIPT "authDoCallback(\"UnityEngine.GameObject\");"
#define HOMEPAGE_CALLBACK_SCRIPT "HomePage(\"UnityEngine.GameObject\");"
#define PAGEOUT_CALLBACK_SCRIPT "PageOut(\"UnityEngine.GameObject\");"
#define NAVIGATE_SCRIPT "location.href=\""

#define TARGET_REGISTER "https://audience.fusionfall.com/ff/regWizard.do?_flowId=fusionfall-registration-flow"
#define TARGET_MANAGE_ACCOUNT "https://audience.fusionfall.com/ff/login.do"
#define TARGET_COMMUNITY "http://forums.fusionfall.com"

#define DISCORD_LINK "https://discord.gg/DYavckB"

void
handle_navigation(char *target)
{
    if (strncmp(target, TARGET_REGISTER, sizeof(TARGET_REGISTER) - 2) == 0) {
        show_error_dialog("The register page is currently unimplemented.\n\n" \
            "You can still create an account: type your desired username and password into the provided boxes and click \"Log In\". " \
            "Your account will then be automatically created on the server. \nBe sure to remember these details!");
    } else if (strncmp(target, TARGET_MANAGE_ACCOUNT, sizeof(TARGET_MANAGE_ACCOUNT) - 2) == 0) {
        show_error_dialog("Account management is not available.");
    } else if (strncmp(target, TARGET_COMMUNITY, sizeof(TARGET_COMMUNITY) - 2) == 0) {
        open_link(DISCORD_LINK);
    } else {
        logmsg("Unhandled navigation target: %s\n", target);
    }
}

char *
get_navigation_target(const char *script)
{
    char *found;

    found = strstr(script, NAVIGATE_SCRIPT);
    if (!found) {
        return NULL;
    }

    return found + sizeof(NAVIGATE_SCRIPT) - 1;
}

void
unity_send_message(const char *class, const char *msg, NPVariant val)
{
    NPVariant args[3];
    NPVariant ret;

    assert(scriptableObject->_class);
    assert(scriptableObject->_class->hasMethod(scriptableObject, getNPIdentifier("SendMessage")));

    STRINGZ_TO_NPVARIANT(class, args[0]);
    STRINGZ_TO_NPVARIANT(msg, args[1]);
    args[2] = val;
    scriptableObject->_class->invoke(scriptableObject, getNPIdentifier("SendMessage"), args, ARRLEN(args), &ret);
}

void
auth(char *username, char *password)
{
    NPVariant val;
    logmsg("Auto-auth as %s\n", username);

    STRINGZ_TO_NPVARIANT(username, val);
    unity_send_message("GlobalManager", "SetTEGid", val);

    STRINGZ_TO_NPVARIANT(password, val);
    unity_send_message("GlobalManager", "SetAuthid", val);

    INT32_TO_NPVARIANT(0, val);
    unity_send_message("GlobalManager", "DoAuth", val);
}

bool
NPN_EvaluateProc(NPP npp, NPObject *obj, NPString *script, NPVariant *result)
{
    char *navigationTarget;

    dbglogmsg("< NPN_EvaluateProc %s\n", script->UTF8Characters);

    /* Evaluates JS calls, like MarkProgress(1), most of which doesn't need to do anything. */
    if (strncmp(script->UTF8Characters, HOMEPAGE_CALLBACK_SCRIPT, sizeof(HOMEPAGE_CALLBACK_SCRIPT)) == 0
        || strncmp(script->UTF8Characters, PAGEOUT_CALLBACK_SCRIPT, sizeof(PAGEOUT_CALLBACK_SCRIPT)) == 0) {
        /* Gracefully exit game. */
        PostQuitMessage(0);
    } else if (strncmp(script->UTF8Characters, AUTH_CALLBACK_SCRIPT, sizeof(AUTH_CALLBACK_SCRIPT)) == 0) {
        /* Execute authentication callback */
        if (args.tegId != NULL && args.authId != NULL) {
            auth(args.tegId, args.authId);
        }
    } else {
        /* If navigation, handle */
        navigationTarget = get_navigation_target(script->UTF8Characters);
        if (navigationTarget != NULL) {
            handle_navigation(navigationTarget);
        }
    }

    *result = (NPVariant){
        .type = NPVariantType_Void
    };

    return true;
}

NPIdentifier
NPN_GetStringIdentifierProc(const NPUTF8* name)
{
    dbglogmsg("< NPN_GetStringIdentifierProc %s\n", name);

    return getNPIdentifier(name);
}

void
NPN_GetStringIdentifiersProc(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
{
    int i;

    dbglogmsg("< NPN_GetStringIdentifiersProc %d\n", nameCount);

    for (i = 0; i < nameCount; i++) {
        identifiers[i] = getNPIdentifier(names[i]);
    }
}

/*
 * Browser Object methods below here.
 */

NPObject *
NPAllocateFunction(NPP instance, NPClass *aClass)
{
    NPObject *npobj;

    dbglogmsg("< NPAllocateFunction %p\n", aClass);
    assert(aClass);

    if (aClass->allocate)
        npobj = aClass->allocate(instance, aClass);
    else
        npobj = malloc(sizeof(*npobj));

    if (npobj) {
        npobj->_class = aClass;
        npobj->referenceCount = 1;
    }

    return npobj;
}

void
NPDeallocateFunction(NPObject *npobj)
{
    dbglogmsg("< NPDeallocateFunction %p\n", npobj);
    assert(npobj != &browserObject);

    free(npobj);
}

void
NPInvalidateFunction(NPObject *npobj)
{
    dbglogmsg("< NPInvalidateFunction %p\n", npobj);
}

bool
NPHasMethodFunction(NPObject *npobj, NPIdentifier name)
{
    dbglogmsg("< NPHasMethodFunction %p %p\n", npobj, name);

    return 0;
}

bool
NPInvokeFunction(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
    dbglogmsg("< NPInvokeFunction %p %p\n", npobj, name);

    return 0;
}

bool
NPInvokeDefaultFunction(NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
    dbglogmsg("< NPInvokeDefaultFunction %p\n", npobj);

    return 0;
}

bool
NPHasPropertyFunction(NPObject *npobj, NPIdentifier name)
{
    dbglogmsg("< NPHasPropertyFunction %p\n", npobj);

    return 0;
}

bool
NPGetPropertyFunction(NPObject *npobj, NPIdentifier name, NPVariant *result)
{
    dbglogmsg("< NPGetPropertyFunction %p\n", npobj);

    return 0;
}

bool
NPSetPropertyFunction(NPObject *npobj, NPIdentifier name, const NPVariant *value)
{
    dbglogmsg("< NPSetPropertyFunction %p\n", npobj);

    return 0;
}

bool
NPRemovePropertyFunction(NPObject *npobj, NPIdentifier name)
{
    dbglogmsg("< NPRemovePropertyFunction %p\n", npobj);

    return 0;
}

bool
NPEnumerationFunction(NPObject *npobj, NPIdentifier **value, uint32_t *count)
{
    dbglogmsg("< NPEnumerationFunction %p\n", npobj);

    return 0;
}

bool
NPConstructFunction(NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
    dbglogmsg("< NPConstructFunction %p\n", npobj);

    return 0;
}

void
initBrowserObject(void)
{
    browserObject._class = &browserClass;
    browserObject.referenceCount = 1;

    browserClass.structVersion = 3;
    browserClass.allocate = NPAllocateFunction;
    browserClass.deallocate = NPDeallocateFunction;
    browserClass.invalidate = NPInvalidateFunction;
    browserClass.hasMethod = NPHasMethodFunction;
    browserClass.invoke = NPInvokeFunction;
    browserClass.invokeDefault = NPInvokeDefaultFunction;
    browserClass.hasProperty = NPHasPropertyFunction;
    browserClass.getProperty = NPGetPropertyFunction;
    browserClass.setProperty = NPSetPropertyFunction;
    browserClass.removeProperty = NPRemovePropertyFunction;
    browserClass.enumerate = NPEnumerationFunction;
    browserClass.construct = NPConstructFunction;
}

void
initNetscapeFuncs(void)
{
    netscapeFuncs.size = sizeof(netscapeFuncs);
    netscapeFuncs.version = 27;
    netscapeFuncs.geturl = NPN_GetURLProc;
    netscapeFuncs.posturl = NPN_PostURLProc;
    netscapeFuncs.uagent = NPN_UserAgentProc;
    netscapeFuncs.geturlnotify = NPN_GetURLNotifyProc;
    netscapeFuncs.posturlnotify = NPN_PostURLNotifyProc;
    netscapeFuncs.releaseobject = NPN_ReleaseObjectProc;
    netscapeFuncs.invoke = NPN_InvokeProc;
    netscapeFuncs.getproperty = NPN_GetPropertyProc;
    netscapeFuncs.createobject = NPN_CreateObjectProc;
    netscapeFuncs.retainobject = NPN_RetainObjectProc;
    netscapeFuncs.releasevariantvalue = NPN_ReleaseVariantValueProc;
    netscapeFuncs.getvalue = NPN_GetValueProc;
    netscapeFuncs.evaluate = NPN_EvaluateProc;
    netscapeFuncs.getstringidentifier = NPN_GetStringIdentifierProc;
    netscapeFuncs.getstringidentifiers = NPN_GetStringIdentifiersProc;
    netscapeFuncs.memalloc = NPN_MemAllocProc;
    netscapeFuncs.memfree = NPN_MemFreeProc;
}

static
bool
check_plugin_error(void)
{
    NPIdentifier getError;
    NPVariant ret;
    NPString retString;
    bool hasError = false;

    if (!scriptableObject || !scriptableObject->_class)
        return false;

    /* Old loader versions won't have this API, but the version we use today does. */
    getError = getNPIdentifier("GetError");
    if (!scriptableObject->_class->hasMethod(scriptableObject, getError))
        return false;

    VOID_TO_NPVARIANT(ret);
    if (scriptableObject->_class->invoke(scriptableObject, getError, NULL, 0, &ret) && NPVARIANT_IS_STRING(ret)) {
        retString = NPVARIANT_TO_STRING(ret);
        char *msg = (char *)retString.UTF8Characters;
        uint32_t i;

        for (i = 0; i < retString.UTF8Length; i++) {
            if (msg[i] == '\n' || msg[i] == '\r')
                msg[i] = ' ';
        }

        hasError = true;
        logmsg("Plugin error: %.*s\n", (int)retString.UTF8Length, msg);
    }
    NPN_ReleaseVariantValueProc(&ret);

    return hasError;
}

void
parse_args(int argc, char **argv)
{
    ARG_BEGIN {
        if (ARG_LONG("verbose")) case 'v': {
            args.verboseLogging = true;
            ARG_FLAG();
        } else if (ARG_LONG("main")) case 'm': {
            args.mainPathOrAddress = ARG_VAL();
        } else if (ARG_LONG("log")) case 'l': {
            args.logPath = ARG_VAL();
        } else if (ARG_LONG("address")) case 'a': {
            args.serverAddress = ARG_VAL();
        } else if (ARG_LONG("asseturl")) {
            args.assetUrl = ARG_VAL();
        } else if (ARG_LONG("endpoint")) case 'e': {
            args.endpointHost = ARG_VAL();
        } else if (ARG_LONG("username")) case 'u': {
            args.tegId = ARG_VAL();
        } else if (ARG_LONG("token")) case 't': {
            args.authId = ARG_VAL();
        } else if (ARG_LONG("width")) {
            args.windowWidth = atoi(ARG_VAL());
        } else if (ARG_LONG("height")) {
            args.windowHeight = atoi(ARG_VAL());
        } else if (ARG_LONG("icon")) case 'i': {
            args.windowIcon = ARG_VAL();
        } else if (ARG_LONG("loader-images")) {
            args.useEndpointLoadingScreen = true;
        } else if (ARG_LONG("force-vulkan")) {
            args.forceVulkan = true;
        } else if (ARG_LONG("force-opengl")) {
            args.forceOpenGl = true;
        } else if (ARG_LONG("name")) case 'n': {
            args.windowName = ARG_VAL();
        } else if (ARG_LONG("help")) case 'h': {
            puts("Usage: ffrunner.exe [OPTION...]");
            puts("  -m, --main=STR          The main URL to load");
            puts("  -l, --log=STR           The path to the log file");
            puts("  -v, --verbose           Enable verbose logging");
            puts("  -a, --address=STR       The address of the server");
            puts("      --asseturl=STR      The URL of the CDN for assets");
            puts("  -e, --endpoint=STR      The OFAPI endpoint URL");
            puts("  -u, --username=STR      Username for auto-login");
            puts("  -t, --token=STR         Password or token for auto-login");
            puts("      --width=INT         The width of the window");
            puts("      --height=INT        The height of the window");
            puts("  -i, --icon              URL of icon to use for the window");
            puts("      --loader-images     Use loading screen images from endpoint");
            puts("      --force-vulkan      Force Vulkan renderer");
            puts("      --force-opengl      Force OpenGL renderer");
            puts("  -n, --name=STR          Set the window name");
            puts("  -h, --help              Display this help menu");
            puts("");
            exit(0);
        }
    } ARG_END;

    if (args.mainPathOrAddress == NULL) {
        args.mainPathOrAddress = FALLBACK_SRC_URL;
    }

    if (args.assetUrl == NULL) {
        args.assetUrl = FALLBACK_ASSET_URL;
    }

    if (args.serverAddress == NULL) {
        args.serverAddress = FALLBACK_SERVER_ADDRESS;
    }

    if (args.logPath == NULL) {
        args.logPath = LOG_FILE_PATH;
    }

    if (args.windowWidth == 0) {
        args.windowWidth = DEFAULT_WIDTH;
    }

    if (args.windowHeight == 0) {
        args.windowHeight = DEFAULT_HEIGHT;
    }

    if (args.windowName == NULL) {
        args.windowName = DEFAULT_WINDOW_NAME;
    }
}

void
print_args()
{
    printf("main: %s\n", args.mainPathOrAddress);
    printf("log: %s\n", args.logPath);
    printf("verbose: %s\n", args.verboseLogging ? "true" : "false");
    printf("address: %s\n", args.serverAddress);
    printf("asseturl: %s\n", args.assetUrl);
    printf("endpoint: %s\n", args.endpointHost);
    printf("username: %s\n", args.tegId);
    printf("token: %s\n", args.authId == NULL ? "(null)" : "********");
    printf("width: %d\n", args.windowWidth);
    printf("height: %d\n", args.windowHeight);
    printf("icon: %s\n", args.windowIcon);
    printf("loader-images: %s\n", args.useEndpointLoadingScreen ? "true" : "false");
    printf("force-vulkan: %s\n", args.forceVulkan ? "true" : "false");
    printf("force-opengl: %s\n", args.forceOpenGl ? "true" : "false");
    printf("name: %s\n", args.windowName);
}

void
enable_dpi_awareness() {
    HMODULE shcore = LoadLibraryA("shcore.dll");
    if (shcore) {
        SetProcessDpiAwarenessFunc setDpiAwareness =
            (SetProcessDpiAwarenessFunc)GetProcAddress(shcore, "SetProcessDpiAwareness");
        if (setDpiAwareness) {
            if (setDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE) == S_OK) {
                logmsg("Set DPI awareness to PROCESS_PER_MONITOR_DPI_AWARE\n");
            } else {
                logmsg("Failed to set DPI awareness: %d\n", GetLastError());
            }
        }
        FreeLibrary(shcore);
    } else {
        // Fallback for older systems
        SetProcessDPIAware();
    }
}

HANDLE
gen_temp_file(char *outPath)
{
    char tempPath[MAX_PATH];
    char tempFile[MAX_PATH];
    HANDLE hFile;
    DWORD fileFlags = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_TEMPORARY;

    if (!GetTempPathA(MAX_PATH, tempPath)) {
        logmsg("GetTempPathA failed: %d\n", GetLastError());
        return INVALID_HANDLE_VALUE;
    }

    if (!GetTempFileNameA(tempPath, "ff", 0, tempFile)) {
        logmsg("GetTempFileNameA failed: %d\n", GetLastError());
        return INVALID_HANDLE_VALUE;
    }

    logmsg("Generated temp file: %s\n", tempFile);
    hFile = CreateFileA(tempFile, GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, CREATE_ALWAYS, fileFlags, NULL);

    if (hFile == INVALID_HANDLE_VALUE) {
        logmsg("CreateFileA failed for temp file: %d\n", GetLastError());
        return INVALID_HANDLE_VALUE;
    }

    if (outPath) {
        strncpy(outPath, tempFile, MAX_PATH);
    }

    return hFile;
}

bool
fetch_icon(char *iconUrl, char *outPath)
{
    HANDLE iconFile;
    HANDLE doneSignal;
    HANDLE workerSignal;
    DWORD waitResult;

    iconFile = gen_temp_file(outPath);
    if (iconFile == INVALID_HANDLE_VALUE) {
        logmsg("Failed to create temp file for icon: %d\n", GetLastError());
        return false;
    }

    logmsg("Downloading icon to %s\n", outPath);
    doneSignal = CreateEventA(NULL, TRUE, FALSE, NULL);

    /*
     * Duplicate the handle so the worker has independent ownership.
     * If we time out and close our handle, the worker can still safely
     * SetEvent on its own copy without races.
     */

    DuplicateHandle(GetCurrentProcess(), doneSignal,
                         GetCurrentProcess(), &workerSignal,
                         0, FALSE, DUPLICATE_SAME_ACCESS);

    register_temp_request(iconUrl, iconFile, workerSignal);

    /* 3-second timeout for icon download so we don't hang if something goes wrong */
    waitResult = WaitForSingleObject(doneSignal, 3000);
    CloseHandle(doneSignal);

    if (waitResult == WAIT_OBJECT_0) {
        logmsg("Icon downloaded successfully.\n");
        CloseHandle(iconFile);
        return true;
    } else if (waitResult == WAIT_TIMEOUT) {
        logmsg("Failed to download icon within timeout.\n");
    } else {
        logmsg("Error while waiting for icon download: %d\n", GetLastError());
    }

    CloseHandle(iconFile);
    return false;
}

static BOOL WINAPI
console_ctrl_handler(DWORD ctrlType)
{
    switch (ctrlType) {
    case CTRL_C_EVENT:
    case CTRL_BREAK_EVENT:
    case CTRL_CLOSE_EVENT:
    case CTRL_LOGOFF_EVENT:
    case CTRL_SHUTDOWN_EVENT:
        logmsg("Console signal %d received, shutting down\n", ctrlType);
        if (hwnd) {
            PostMessageW(hwnd, WM_CLOSE, 0, 0);
        }
        // remove so next ctrl+c will force quit
        SetConsoleCtrlHandler(console_ctrl_handler, FALSE);
        return TRUE;
    default:
        return FALSE;
    }
}

void
setup_console() {
    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
        // reopen C stdio to the attached console
        FILE* f;
        freopen_s(&f, "CONIN$",  "r", stdin);
        freopen_s(&f, "CONOUT$", "w", stdout);
        freopen_s(&f, "CONOUT$", "w", stderr);

        // disable output buffering
        setvbuf(stdout, NULL, _IONBF, 0);

        SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
    }
}

int
main(int argc, char **argv)
{
    char* srcUrl;
    DWORD err;
    wchar_t cwd[MAX_PATH];
    NPError ret;
    int exitCode;
    HMODULE loader;
    RECT winRect;
    char iconFile[MAX_PATH];

    setup_console();
    parse_args(argc, argv);
    print_args();
    init_logging(args.logPath, args.verboseLogging);

    enable_dpi_awareness();

    char *winePrefix = getenv("WINEPREFIX");
    if (winePrefix) {
        logmsg("WINEPREFIX is set to: %s\n", winePrefix);
    } else {
        logmsg("WINEPREFIX is not set.\n");
    }

    if (args.serverAddress == NULL) {
        logmsg("No server address provided.");
        exit(1);
    }

    if (args.assetUrl == NULL) {
        logmsg("No asset URL provided.");
        exit(1);
    }

    if (GetCurrentDirectoryW(MAX_PATH, cwd)) {
        logmsg("setenv(\"UNITY_HOME_DIR\", \"%ls\")\n", cwd);
        SetEnvironmentVariableW(L"UNITY_HOME_DIR", cwd);
    }
    SetEnvironmentVariableA("UNITY_DISABLE_PLUGIN_UPDATES", "yes");
    SetEnvironmentVariableA("LANG", NULL); // webplayer crashes if this is set
    SetEnvironmentVariableA("UNITY_KEEP_LOG_FILES", "yes");

    if (args.forceVulkan) {
#ifdef _WIN64
        SetEnvironmentVariableA("UNITY_FF_DX_DLL", "d3d9_vulkan64.dll");
#else
        SetEnvironmentVariableA("UNITY_FF_DX_DLL", "d3d9_vulkan.dll");
#endif
    } else if (args.forceOpenGl) {
        SetEnvironmentVariableA("UNITY_FF_DX_DLL", "lmao");
    }
    apply_vram_fix();

    initNetscapeFuncs();
    initBrowserObject();

    logmsg("LoadLibraryW\n");
#ifdef _WIN64
    loader = LoadLibraryW(L"loader-x64\\npUnity3D64.dll");
#else
    loader = LoadLibraryW(L"loader\\npUnity3D32.dll");
#endif
    if (!loader) {
        err = GetLastError();
        logmsg("Failed to load plugin DLL: 0x%x\n", err);
        exit(1);
    }

    logmsg("GetProcAddress\n");
    NP_GetEntryPointsFuncOS NP_GetEntryPoints = (NP_GetEntryPointsFuncOS)GetProcAddress(loader, "NP_GetEntryPoints");
    NP_InitializeFuncOS NP_Initialize = (NP_InitializeFuncOS)GetProcAddress(loader, "NP_Initialize");
    NP_ShutdownFuncOS NP_Shutdown = (NP_ShutdownFuncOS)GetProcAddress(loader, "NP_Shutdown");

    if (!NP_GetEntryPoints || !NP_Initialize || !NP_Shutdown) {
        logmsg("Failed to find one or more plugin symbols. Invalid plugin DLL?\n");
        exit(1);
    }

    srcUrl = args.mainPathOrAddress;
    init_network(srcUrl);
    logmsg("Request pool initialized\n");

    char *iconToUse = NULL;
    if (args.windowIcon) {
        logmsg("Fetching icon: %s\n", args.windowIcon);
        if (fetch_icon(args.windowIcon, iconFile)) {
            iconToUse = iconFile;
        }
    }

    prepare_window(args.windowWidth, args.windowHeight, iconToUse);
    assert(hwnd);

    dbglogmsg("> NP_GetEntryPoints\n");
    ret = NP_GetEntryPoints(&pluginFuncs);
    dbglogmsg("  returned %d\n", ret);

    dbglogmsg("> NP_Initialize\n");
    ret = NP_Initialize(&netscapeFuncs);
    dbglogmsg("  returned %d\n", ret);

    char width[16], height[16];
    snprintf(width, sizeof(width), "%d", args.windowWidth);
    snprintf(height, sizeof(height), "%d", args.windowHeight);

    char *argn[] = {
        "src",
        "width",
        "height",
        "bordercolor",
        "backgroundcolor",
        "disableContextMenu",
        "textcolor",
        "logoimage",
        "progressbarimage",
        "progressframeimage",
    };
    char *argp[] = {
        srcUrl,
        width,
        height,
        "000000",
        "000000",
        "true",
        "ccffff",
        "assets/img/unity-dexlabs.png",
        "assets/img/unity-loadingbar.png",
        "assets/img/unity-loadingframe.png",
    };
    assert(ARRLEN(argn) == ARRLEN(argp));

    savedPtr = &saved;

    dbglogmsg("> NPP_NewProc\n");
    ret = pluginFuncs.newp("application/vnd.ffuwp", &npp, 1, ARRLEN(argn), argn, argp, savedPtr);
    dbglogmsg("  returned %d\n", ret);

    ShowWindow(hwnd, SW_SHOWDEFAULT);
    UpdateWindow(hwnd);

    npWin = (NPWindow){
        .window = hwnd,
        .x = 0, .y = 0,
        .width = args.windowWidth, .height = args.windowHeight,
        .clipRect = {
            0, 0, args.windowHeight, args.windowWidth
        },
        .type = NPWindowTypeWindow
    };

    /* adjust plugin rect to the real inner size of the window */
    if (GetClientRect(hwnd, &winRect)) {
        npWin.x = winRect.left;
        npWin.y = winRect.top;
        npWin.clipRect.top = 0;
        npWin.clipRect.left = 0;
        npWin.clipRect.right = winRect.right;
        npWin.clipRect.bottom = winRect.bottom;
        npWin.width = winRect.right - winRect.left;
        npWin.height = winRect.bottom - winRect.top;
    }

    dbglogmsg("> NPP_SetWindowProc\n");
    ret = pluginFuncs.setwindow(&npp, &npWin);
    dbglogmsg("  returned %d\n", ret);


    dbglogmsg("> NPP_GetValueProc\n");
    ret = pluginFuncs.getvalue(&npp, NPPVpluginScriptableNPObject, &scriptableObject);
    dbglogmsg("  returned %d and NPObject %p\n", ret, scriptableObject);
    assert(scriptableObject->_class);

    dbglogmsg("> scriptableObject.hasMethod style\n");
    ret = scriptableObject->_class->hasMethod(scriptableObject, getNPIdentifier("style"));
    dbglogmsg("  returned %d\n", ret);

    message_loop();

    exitCode = check_plugin_error() ? EXIT_PLUGIN_ERROR : 0;

    dbglogmsg("> NPP_DestroyProc\n");
    ret = pluginFuncs.destroy(&npp, &savedPtr);
    dbglogmsg("  returned %d\n", ret);

    return exitCode;
}

int
WINAPI
WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    int argc;
    char **argv;

    argc = __argc;
    argv = __argv;

    return main(argc, argv);
}