/* * %CopyrightBegin% * * Copyright Ericsson AB 1997-2009. All Rights Reserved. * * The contents of this file are subject to the Erlang Public License, * Version 1.1, (the "License"); you may not use this file except in * compliance with the License. You should have received a copy of the * Erlang Public License along with this software. If not, it can be * retrieved online at http://www.erlang.org/. * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See * the License for the specific language governing rights and limitations * under the License. * * %CopyrightEnd% */ /* * Extra support for running the emulator on Windows. * Most of this only used when beam is run as a separate process. */ #pragma comment(linker,"/manifestdependency:\"type='win32' "\ "name='Microsoft.Windows.Common-Controls' "\ "version='6.0.0.0' processorArchitecture='*' "\ "publicKeyToken='6595b64144ccf1df' language='*'\"") #include <windows.h> #include <winuser.h> #include <wincon.h> #include <process.h> #include "sys.h" #include "erl_driver.h" extern int nohup; extern int keep_window; void error(char* format, ...); /* * Local functions. */ #define LOAD_BEAM_DYNAMICALLY 1 static int start(char* emu, char** argv); static void start_winsock(void); static char* last_error(void); static char* last_wsa_error(void); static char* win32_errorstr(int error); static int has_console(void); static char** fnuttify_argv(char **argv); static void free_fnuttified(char **v); static int windowed = 0; #ifdef LOAD_BEAM_DYNAMICALLY typedef int SysGetKeyFunction(int); typedef void ErlStartFunction(int, char **); typedef void SysPrimitiveInitFunction(HMODULE); static SysGetKeyFunction *sys_get_key_p; static ErlStartFunction *erl_start_p; static SysPrimitiveInitFunction *sys_primitive_init_p; static HMODULE load_win_beam_dll(char *name) { HMODULE beam_module; beam_module=LoadLibrary(name); if (beam_module == INVALID_HANDLE_VALUE || beam_module == NULL) { error("Unable to load emulator DLL\n(%s)",name); return NULL; } sys_get_key_p = (SysGetKeyFunction *) GetProcAddress(beam_module, "sys_get_key"); erl_start_p = (ErlStartFunction *) GetProcAddress(beam_module, "erl_start"); sys_primitive_init_p = (SysPrimitiveInitFunction *) GetProcAddress(beam_module, "sys_primitive_init"); return beam_module; } #endif #define DLL_ENV "ERL_EMULATOR_DLL" static void set_env(char *key, char *value) { if (!SetEnvironmentVariable((LPCTSTR) key, (LPCTSTR) value)) error("SetEnvironmentVariable(\"%s\", \"%s\") failed!", key, value); } static char * get_env(char *key) { DWORD size = 32; char *value = NULL; while (1) { DWORD nsz; if (value) free(value); value = malloc(size); if (!value) error("GetEnvironmentVariable(\"%s\") failed", key); SetLastError(0); nsz = GetEnvironmentVariable((LPCTSTR) key, (LPTSTR) value, size); if (nsz == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) { free(value); return NULL; } if (nsz <= size) return value; size = nsz; } } free_env_val(char *value) { if (value) free(value); } int start_win_emulator(char* emu, char *start_prog, char** argv, int start_detached) { int result; windowed = 1; if (start_detached) { char *buff; close(0); close(1); close(2); set_env("ERL_CONSOLE_MODE", "detached"); set_env(DLL_ENV, emu); argv[0] = start_prog; argv = fnuttify_argv(argv); result = spawnv(_P_DETACH, start_prog, argv); free_fnuttified(argv); } else { int argc = 0; #ifdef LOAD_BEAM_DYNAMICALLY HMODULE beam_module = load_win_beam_dll(emu); #endif set_env("ERL_CONSOLE_MODE", "window"); while (argv[argc] != NULL) { ++argc; } #ifdef ARGS_HARDDEBUG { char sbuf[2048] = ""; int i; for (i = 0; i < argc; ++i) { strcat(sbuf,"|"); strcat(sbuf, argv[i]); strcat(sbuf,"| "); } MessageBox(NULL, sbuf, "Werl", MB_OK|MB_ICONERROR); } #endif #ifdef LOAD_BEAM_DYNAMICALLY (*sys_primitive_init_p)(beam_module); (*erl_start_p)(argc,argv); #else erl_start(argc, argv); #endif result = 0; } if (result == -1) { error("Failed to execute %s: %s", emu, win32_errorstr(_doserrno)); } return 0; } void __cdecl do_keep_window(void) { printf("\nPress any key to close window.\n"); #ifdef LOAD_BEAM_DYNAMICALLY (*sys_get_key_p)(0); #else sys_get_key(0); #endif } int start_emulator(char* emu, char *start_prog, char** argv, int start_detached) { int result; static char console_mode[] = "tty:ccc"; char* fd_type; char* title; #ifdef HARDDEBUG fprintf(stderr,"emu = %s, start_prog = %s\n",emu, start_prog); #endif fd_type = strchr(console_mode, ':'); fd_type++; _flushall(); /* * If no console, we will spawn the emulator detached. */ if (start_detached) { char *buff; close(0); close(1); close(2); set_env("ERL_CONSOLE_MODE", "detached"); set_env(DLL_ENV, emu); argv[0] = start_prog; argv = fnuttify_argv(argv); #ifdef ARGS_HARDDEBUG { char buffer[2048]; int i; sprintf(buffer,"Start detached [%s]\n",start_prog); for(i=0;argv[i] != NULL;++i) { strcat(buffer,"|"); strcat(buffer,argv[i]); strcat(buffer,"|\n"); } MessageBox(NULL, buffer,"Start detached",MB_OK); } #endif result = spawnv(_P_DETACH, start_prog, argv); free_fnuttified(argv); if (result == -1) { #ifdef ARGS_HARDDEBUG MessageBox(NULL, "_spawnv failed","Start detached",MB_OK); #endif return 1; } SetPriorityClass((HANDLE) result, GetPriorityClass(GetCurrentProcess())); } else { int argc = 0; #ifdef LOAD_BEAM_DYNAMICALLY HMODULE beam_module = load_win_beam_dll(emu); #endif /* * Start the emulator. */ title = get_env("ERL_WINDOW_TITLE"); if (title) { SetConsoleTitle(title); } free_env_val(title); set_env("ERL_CONSOLE_MODE", console_mode); while (argv[argc] != NULL) { ++argc; } if (keep_window) { atexit(do_keep_window); } #ifdef ARGS_HARDDEBUG { char sbuf[2048] = ""; int i; for (i = 0; i < argc; ++i) { strcat(sbuf,"|"); strcat(sbuf, argv[i]); strcat(sbuf,"|\n"); } MessageBox(NULL, sbuf, "erl", MB_OK); } #endif #ifdef LOAD_BEAM_DYNAMICALLY (*sys_primitive_init_p)(beam_module); (*erl_start_p)(argc,argv); #else erl_start(argc, argv); #endif } return 0; } void error(char* format, ...) { char sbuf[2048]; va_list ap; va_start(ap, format); vsprintf(sbuf, format, ap); va_end(ap); if (!windowed && has_console()) { fprintf(stderr, "%s\n", sbuf); } else { MessageBox(NULL, sbuf, "Werl", MB_OK|MB_ICONERROR); } exit(1); } static char* last_error(void) { return win32_errorstr(GetLastError()); } /* * Returns a human-readable description of the last error. * The returned pointer will be valid only as long as last-error() * isn't called again. */ static char* win32_errorstr(int error) { static LPTSTR lpBufPtr = NULL; if (lpBufPtr) LocalFree(lpBufPtr); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpBufPtr, 0, NULL); SetLastError(error); return lpBufPtr; } static int has_console(void) { HANDLE handle = CreateFile("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (handle != INVALID_HANDLE_VALUE) { CloseHandle(handle); return 1; } else { return 0; } } static char** fnuttify_argv(char **argv) { char **v; char *p; char *q; int c; int i; int n; int m; for (c = 0; argv[c]; ++c) ; v = malloc(sizeof(char *) * (c+1)); v[c] = NULL; for (i = 0; i < c; ++i) { p = argv[i]; n = m = 0; while (*p) { if (*p == ' ') { m = 2; } else if (*p == '"') { m = 2; ++n; } ++p; } v[i] = malloc((p - argv[i]) + 1 + n + m); p = argv[i]; q = v[i]; if (n || m) { if (m) { *q++ = '"'; } while (*p) { if (*p == '"') { *q++ = '\\'; } *q++ = *p++; } if (m) { *q++ = '"'; } *q = '\0'; } else { strcpy(q,p); } } return v; } static void free_fnuttified(char **v) { char **t = v; while(*t) { free(*t); ++t; } free(v); }