static int socket_error( SGS_CTX )
{
int astext = 0, e = 0;
SGSFN( "socket_error" );
if( !sgs_LoadArgs( C, "|b", &astext ) )
return 0;
if( sgs_PushGlobal( C, SCKERRVN ) == SGS_SUCCESS )
e = (int) sgs_GetInt( C, -1 );
else if( !astext )
sgs_PushInt( C, 0 );
if( !astext )
return 1;
#ifdef _WIN32
{
char buf[ 1024 ];
DWORD numwr = FormatMessageA
(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, (DWORD) e,
MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
buf, 1024, NULL
);
if( !numwr )
STDLIB_WARN( "failed to retrieve error message" )
sgs_PushStringBuf( C, buf, (sgs_SizeVal) numwr );
}
#else
sgs_PushString( C, strerror( e ) );
#endif
return 1;
}
static int sockaddr_dump( SGS_CTX, sgs_VarObj* data, int depth )
{
char buf[ 32 ];
sprintf( buf, "socket_address [family=%hu] ", (unsigned short) GET_SAF );
sgs_PushString( C, buf );
sgs_PushObjectPtr( C, data );
sgs_StringConcat( C, 2 );
return SGS_SUCCESS;
}
static int sgs_socket_gethostname( SGS_CTX )
{
char buf[ 256 ];
SGSFN( "socket_gethostname" );
if( !sgs_LoadArgs( C, "." ) )
return 0;
if( !sockassert( C, gethostname( buf, 256 ) == 0 ) )
STDLIB_WARN( "failed to get host name" )
buf[ 256-1 ] = 0;
sgs_PushString( C, buf );
return 1;
}
static void sockaddr_push_full_addr_string( SGS_CTX, sgs_VarObj* data )
{
char addr[ 64 ] = {0};
#ifdef _WIN32
DWORD ioasz = 64;
WSAAddressToString( (LPSOCKADDR) data->data, sizeof(struct sockaddr_storage), NULL, addr, &ioasz );
#else
if( GET_SAF == AF_INET || GET_SAF == AF_INET6 )
{
char pb[ 8 ];
inet_ntop( GET_SAF, GET_SAF == AF_INET ?
(void*) &GET_SAI->sin_addr :
(void*) &GET_SAI6->sin6_addr, addr, 64 );
sprintf( pb, ":%u", (int) GET_SAF == AF_INET ? GET_SAI->sin_port : GET_SAI6->sin6_port );
strcat( addr, pb );
}
#endif
addr[ 64-1 ] = 0;
if( *addr )
sgs_PushString( C, addr );
else
sgs_PushString( C, "-" );
}
static int sgs_socket_getaddrinfo( SGS_CTX )
{
sgs_StkIdx sz0, sz1;
struct addrinfo hints, *list = NULL, *pp;
char *addr, *servport;
sgs_Int socktype = SOCK_STREAM, af = AF_UNSPEC;
SGSFN( "socket_getaddrinfo" );
/* address, port, socktype, address_family */
if( !sgs_LoadArgs( C, "ss|ii", &addr, &servport, &socktype, &af ) )
return 0;
memset( &hints, 0, sizeof(hints) );
hints.ai_socktype = (int) socktype;
hints.ai_family = (int) af;
if( !sockassert( C, getaddrinfo( addr, servport, &hints, &list ) == 0 ) )
STDLIB_WARN( "failed to get address info" )
pp = list;
sz0 = sgs_StackSize( C );
while( pp )
{
sz1 = sgs_StackSize( C );
sgs_PushString( C, "flags" );
sgs_PushInt( C, pp->ai_flags );
sgs_PushString( C, "family" );
sgs_PushInt( C, pp->ai_family );
sgs_PushString( C, "socktype" );
sgs_PushInt( C, pp->ai_socktype );
sgs_PushString( C, "protocol" );
sgs_PushInt( C, pp->ai_protocol );
sgs_PushString( C, "canonname" );
if( pp->ai_canonname )
sgs_PushString( C, pp->ai_canonname );
else
sgs_PushNull( C );
sgs_PushString( C, "addr" );
push_sockaddr( C, (struct sockaddr_storage*) (void*) pp->ai_addr, pp->ai_addrlen );
sgs_PushDict( C, sgs_StackSize( C ) - sz1 );
pp = pp->ai_next;
}
freeaddrinfo( list );
sgs_PushArray( C, sgs_StackSize( C ) - sz0 );
return 1;
}
int ss_Initialize( int argc, char* argv[], int debug )
{
int ret;
SGS_CTX;
GEnabledDebugging = debug;
#if SS_STARTUP_PROFILING
printf( "ss_Initialize called: %f\n", sgs_GetTime() );
#endif
C = g_C = sgs_CreateEngine();
#if SS_STARTUP_PROFILING
printf( "SGS engine created: %f\n", sgs_GetTime() );
#endif
if( GEnabledDebugging )
sgs_InitIDbg( C, &D );
else
sgs_SetMsgFunc( C, ss_MsgFunc, NULL );
#if SS_STARTUP_PROFILING
printf( "debug printing initialized: %f\n", sgs_GetTime() );
#endif
/* preinit first-use libs */
sgs_LoadLib_Fmt( C );
sgs_LoadLib_IO( C );
sgs_LoadLib_Math( C );
sgs_LoadLib_OS( C );
sgs_LoadLib_RE( C );
sgs_LoadLib_String( C );
#if SS_STARTUP_PROFILING
printf( "SGS libraries loaded: %f\n", sgs_GetTime() );
#endif
ss_InitDebug( C );
ss_InitExtMath( C );
ss_InitImage( C );
#if SS_STARTUP_PROFILING
printf( "SS libraries loaded: %f\n", sgs_GetTime() );
#endif
/* preinit tmp buffer */
g_tmpbuf = sgs_membuf_create();
sgs_membuf_reserve( &g_tmpbuf, C, 1024 );
/* load command line arguments */
{
int i;
for( i = 0; i < argc; ++i )
{
sgs_PushString( C, argv[ i ] );
}
sgs_CreateArray( C, NULL, argc );
sgs_SetGlobalByName( C, "sys_args", sgs_StackItem( C, -1 ) );
sgs_Pop( C, 1 );
}
/* push some system info */
sgs_SetGlobalByName( C, "sys_scripting_engine", sgs_MakePtr( C ) );
#if SS_STARTUP_PROFILING
printf( "system info pushed: %f\n", sgs_GetTime() );
#endif
/* run the preconfig script */
sgs_ExecString( C, scr_preconfig );
#if SS_STARTUP_PROFILING
printf( "preconfig done: %f\n", sgs_GetTime() );
#endif
/* run the config file */
ret = sgs_Include( C, "core/config" );
if( !ret )
{
sgs_Msg( C, SGS_ERROR, "Could not run core/config (configuration script)." );
return -2;
}
/* run the primary extensions */
ret = sgs_Include( C, "core/ext" );
if( !ret )
{
sgs_Msg( C, SGS_ERROR, "Could not run core/ext." );
return -2;
}
#if SS_STARTUP_PROFILING
printf( "configured engine scripts: %f\n", sgs_GetTime() );
#endif
/* run the main file */
ret = sgs_Include( C, "main" );
if( !ret )
{
sgs_Msg( C, SGS_ERROR, "Could not execute 'main'." );
return -3;
}
#if SS_STARTUP_PROFILING
printf( "ran main script: %f\n", sgs_GetTime() );
#endif
/* configure the framework (optional) */
sgs_GlobalCall( C, "configure", 0, 0 );
#if SS_STARTUP_PROFILING
printf( "called 'configure': %f\n", sgs_GetTime() );
#endif
/* check if already required to exit */
if( sgs_GlobalBool( C, "sys_exit" ) )
return 0;
if( GEnabledProfiler )
sgs_ProfInit( C, &P, GEnabledProfiler );
#if SS_STARTUP_PROFILING
printf( "pre-SDL init: %f\n", sgs_GetTime() );
#endif
/* initialize SDL */
if( SDL_Init(
SDL_INIT_TIMER | SDL_INIT_VIDEO |
SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC |
SDL_INIT_GAMECONTROLLER |
SDL_INIT_EVENTS | SDL_INIT_NOPARACHUTE
) < 0 )
{
sgs_Msg( C, SGS_ERROR, "Couldn't initialize SDL: %s", SDL_GetError() );
return -5;
}
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
#if SS_STARTUP_PROFILING
printf( "post-SDL init: %f\n", sgs_GetTime() );
#endif
/* initialize script-space SDL API */
ss_InitSDL( C );
/* initialize script-space rendering API */
ss_InitGraphics( C );
#if SS_STARTUP_PROFILING
printf( "initialized SDL/Graphics subsystems: %f\n", sgs_GetTime() );
#endif
/* initialize the application */
if( SGS_FAILED( sgs_GlobalCall( C, "initialize", 0, 0 ) ) )
{
sgs_Msg( C, SGS_ERROR, "Failed to initialize the application." );
return -8;
}
#if SS_STARTUP_PROFILING
printf( "called 'initialize': %f\n", sgs_GetTime() );
#endif
return 1;
}
int main( int argc, char* argv[] )
{
int i;
BYTE buf[ 4096 ], *path, *data;
DWORD read, written, scriptsize = 0;
HANDLE fh;
path = buf;
/* open EXE file */
read = GetModuleFileName( NULL, (CHAR*) buf, sizeof( buf ) );
if( read >= sizeof( buf ) )
{
path = malloc( read + 1 );
GetModuleFileName( NULL, (CHAR*) buf, sizeof( buf ) );
}
fh = CreateFileFast( (CHAR*) buf, FILE_READ, OPEN_EXISTING );
if( path != buf )
free( path );
if( fh == INVALID_HANDLE_VALUE )
return E_FAIL;
SetFilePointer( fh, -4, NULL, FILE_END );
ReadFile( fh, &scriptsize, sizeof( scriptsize ), &read, NULL );
/* read the following data */
if( scriptsize == 0 )
{
if( argc == 3 )
{
HANDLE hsgs, hout = CreateFileFast( argv[ 1 ], FILE_WRITE, CREATE_ALWAYS );
if( !hout )
{
MessageBox( 0, "Could not open executable file for writing", APPNAME, MB_ICONERROR );
CloseHandle( fh );
return E_FAIL;
}
hsgs = CreateFileFast( argv[ 2 ], FILE_READ, OPEN_EXISTING );
if( !hsgs )
{
MessageBox( 0, "Could not open script file for reading", APPNAME, MB_ICONERROR );
CloseHandle( hout );
CloseHandle( fh );
return E_FAIL;
}
SetFilePointer( fh, 0, NULL, FILE_BEGIN );
while( ReadFile( fh, buf, sizeof( buf ), &read, NULL ) && read )
WriteFile( hout, buf, read, &written, NULL );
while( ReadFile( hsgs, buf, sizeof( buf ), &read, NULL ) && read )
WriteFile( hout, buf, read, &written, NULL );
scriptsize = GetFileSize( hsgs, NULL );
WriteFile( hout, &scriptsize, 4, &written, NULL );
CloseHandle( fh );
CloseHandle( hsgs );
CloseHandle( hout );
MessageBox( 0, "File saved!", APPNAME, MB_ICONINFORMATION );
return S_OK;
}
else
{
const char* info = "To create an executable from .sgs"
", run sgsexe <output-file.exe> <script-file.sgs>."
"\n\nglobal 'argv' will be the array of arguments";
MessageBox( 0, info, APPNAME, MB_ICONINFORMATION );
CloseHandle( fh );
return E_ABORT;
}
}
data = malloc( scriptsize );
SetFilePointer( fh, -4-(LONG)scriptsize, NULL, FILE_END );
ReadFile( fh, data, scriptsize, &read, NULL );
CloseHandle( fh );
{
SGS_CTX = sgs_CreateEngine();
for( i = 0; i < argc; ++i )
sgs_PushString( C, argv[ i ] );
sgs_CreateArray( C, NULL, argc );
sgs_SetGlobalByName( C, "argv", sgs_StackItem( C, -1 ) );
sgs_Pop( C, 1 );
sgs_SetGlobalByName( C, "argc", sgs_MakeInt( argc ) );
sgs_ExecBuffer( C, (char*) data, scriptsize );
sgs_DestroyEngine( C );
}
free( data );
return 0;
}
static int sockaddr_getindex( SGS_CTX, sgs_VarObj* data, sgs_Variable* key, int prop )
{
char* name;
if( sgs_ParseStringP( C, key, &name, NULL ) )
{
if( STREQ( name, "family" ) ){ sgs_PushInt( C, GET_SAF ); return SGS_SUCCESS; }
if( STREQ( name, "port" ) )
{
if( GET_SAF == AF_INET ){ sgs_PushInt( C, ntohs( GET_SAI->sin_port ) ); }
else if( GET_SAF == AF_INET6 ){ sgs_PushInt( C, ntohs( GET_SAI6->sin6_port ) ); }
else { sgs_PushNull( C ); sgs_Msg( C, SGS_WARNING, "port supported only for AF_INET[6]" ); }
return SGS_SUCCESS;
}
if( STREQ( name, "addr_u32" ) )
{
if( GET_SAF == AF_INET ){ sgs_PushInt( C, ntohl( GET_SAI->sin_addr.s_addr ) ); }
else { sgs_PushNull( C ); sgs_Msg( C, SGS_WARNING, "addr_u32 supported only for AF_INET" ); }
return SGS_SUCCESS;
}
if( STREQ( name, "addr_buf" ) )
{
if( GET_SAF == AF_INET ){ sgs_PushStringBuf( C, (char*) &GET_SAI->sin_addr.s_addr, 4 ); }
else if( GET_SAF == AF_INET6 ){ sgs_PushStringBuf( C, (char*) &GET_SAI6->sin6_addr.s6_addr, 16 ); }
else { sgs_PushNull( C ); sgs_Msg( C, SGS_WARNING, "addr_buf supported only for AF_INET[6]" ); }
return SGS_SUCCESS;
}
if( STREQ( name, "addr_bytes" ) )
{
char* buf = NULL;
int i, sz = 0;
if( GET_SAF == AF_INET )
{
buf = (char*) &GET_SAI->sin_addr.s_addr;
sz = 4;
}
else if( GET_SAF == AF_INET6 )
{
buf = (char*) &GET_SAI6->sin6_addr.s6_addr;
sz = 16;
}
if( buf )
{
for( i = 0; i < sz; ++i )
sgs_PushInt( C, buf[ i ] );
sgs_PushArray( C, sz );
}
else { sgs_PushNull( C ); sgs_Msg( C, SGS_WARNING, "addr_bytes supported only for AF_INET[6]" ); }
return SGS_SUCCESS;
}
if( STREQ( name, "addr_string" ) )
{
char addr[ 64 ] = {0};
#ifdef _WIN32
DWORD ioasz = 64;
WSAAddressToString( (LPSOCKADDR) data->data, sizeof(struct sockaddr_storage), NULL, addr, &ioasz );
*strrchr( addr, ':' ) = 0;
#else
if( GET_SAF == AF_INET )
inet_ntop( GET_SAF, &GET_SAI->sin_addr, addr, 64 );
else if( GET_SAF == AF_INET6 )
inet_ntop( GET_SAF, &GET_SAI6->sin6_addr, addr, 64 );
#endif
addr[ 64-1 ] = 0;
if( *addr )
sgs_PushString( C, addr );
else
sgs_PushString( C, "-" );
return SGS_SUCCESS;
}
if( STREQ( name, "full_addr_string" ) )
{
sockaddr_push_full_addr_string( C, data );
return SGS_SUCCESS;
}
}
return SGS_ENOTFND;
}
