RETCODE SQL_API
SQLConnectW(HDBC ConnectionHandle,
SQLWCHAR *ServerName, SQLSMALLINT NameLength1,
SQLWCHAR *UserName, SQLSMALLINT NameLength2,
SQLWCHAR *Authentication, SQLSMALLINT NameLength3)
{
CSTR func = "SQLConnectW";
char *svName, *usName, *auth;
SQLLEN nmlen1, nmlen2, nmlen3;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
mylog("[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
svName = ucs2_to_utf8(ServerName, NameLength1, &nmlen1, FALSE);
usName = ucs2_to_utf8(UserName, NameLength2, &nmlen2, FALSE);
auth = ucs2_to_utf8(Authentication, NameLength3, &nmlen3, FALSE);
ret = PGAPI_Connect(ConnectionHandle,
(SQLCHAR *) svName, (SQLSMALLINT) nmlen1,
(SQLCHAR *) usName, (SQLSMALLINT) nmlen2,
(SQLCHAR *) auth, (SQLSMALLINT) nmlen3);
LEAVE_CONN_CS(conn);
if (svName)
free(svName);
if (usName)
free(usName);
if (auth)
free(auth);
return ret;
}
DllImpl::DllImpl(const std::wstring& installationDir) {
auto dllPath(installationDir + L"temple.dll");
// Does it even exist?
if (!PathFileExists(dllPath.c_str())) {
auto msg(fmt::format("Temple.dll does not exist: {}", ucs2_to_utf8(dllPath)));
throw TempleException(msg);
}
SetCurrentDirectory(installationDir.c_str());
// Try to load it
mDllHandle = LoadLibrary(dllPath.c_str());
if (!mDllHandle) {
throw TempleException("Unable to load temple.dll from {}: {}",
ucs2_to_utf8(dllPath), GetLastWin32Error());
}
// calculate the offset from the default 0x10000000 base address
auto baseAddr = reinterpret_cast<uint32_t>(mDllHandle);
mDeltaFromVanilla = baseAddr - defaultBaseAddr;
logger->info("The temple.dll base address delta is: {}", mDeltaFromVanilla);
auto status = MH_Initialize();
if (status != MH_OK) {
FreeLibrary(mDllHandle);
auto msg(fmt::format("Unable to initialize MinHook: {}", MH_StatusToString(status)));
throw TempleException(msg);
}
}
RETCODE SQL_API
SQLProcedureColumnsW(HSTMT hstmt,
SQLWCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLWCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLWCHAR *szProcName,
SQLSMALLINT cbProcName,
SQLWCHAR *szColumnName,
SQLSMALLINT cbColumnName)
{
CSTR func = "SQLProcedureColumnsW";
RETCODE ret;
char *ctName, *scName, *prName, *clName;
SQLLEN nmlen1, nmlen2, nmlen3, nmlen4;
StatementClass *stmt = (StatementClass *) hstmt;
ConnectionClass *conn;
BOOL lower_id;
UWORD flag = 0;
mylog("[%s]", func);
conn = SC_get_conn(stmt);
lower_id = SC_is_lower_case(stmt, conn);
ctName = ucs2_to_utf8(szCatalogName, cbCatalogName, &nmlen1, lower_id);
scName = ucs2_to_utf8(szSchemaName, cbSchemaName, &nmlen2, lower_id);
prName = ucs2_to_utf8(szProcName, cbProcName, &nmlen3, lower_id);
clName = ucs2_to_utf8(szColumnName, cbColumnName, &nmlen4, lower_id);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
if (stmt->options.metadata_id)
flag |= PODBC_NOT_SEARCH_PATTERN;
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_ProcedureColumns(hstmt,
(SQLCHAR *) ctName, (SQLSMALLINT) nmlen1,
(SQLCHAR *) scName, (SQLSMALLINT) nmlen2,
(SQLCHAR *) prName, (SQLSMALLINT) nmlen3,
(SQLCHAR *) clName, (SQLSMALLINT) nmlen4,
flag);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
if (ctName)
free(ctName);
if (scName)
free(scName);
if (prName)
free(prName);
if (clName)
free(clName);
return ret;
}
RETCODE SQL_API
SQLColumnsW(HSTMT StatementHandle,
SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
SQLWCHAR *SchemaName, SQLSMALLINT NameLength2,
SQLWCHAR *TableName, SQLSMALLINT NameLength3,
SQLWCHAR *ColumnName, SQLSMALLINT NameLength4)
{
CSTR func = "SQLColumnsW";
RETCODE ret;
char *ctName, *scName, *tbName, *clName;
SQLLEN nmlen1, nmlen2, nmlen3, nmlen4;
StatementClass *stmt = (StatementClass *) StatementHandle;
ConnectionClass *conn;
BOOL lower_id;
UWORD flag = PODBC_SEARCH_PUBLIC_SCHEMA;
mylog("[%s]", func);
conn = SC_get_conn(stmt);
lower_id = SC_is_lower_case(stmt, conn);
ctName = ucs2_to_utf8(CatalogName, NameLength1, &nmlen1, lower_id);
scName = ucs2_to_utf8(SchemaName, NameLength2, &nmlen2, lower_id);
tbName = ucs2_to_utf8(TableName, NameLength3, &nmlen3, lower_id);
clName = ucs2_to_utf8(ColumnName, NameLength4, &nmlen4, lower_id);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
if (stmt->options.metadata_id)
flag |= PODBC_NOT_SEARCH_PATTERN;
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_Columns(StatementHandle,
(SQLCHAR *) ctName, (SQLSMALLINT) nmlen1,
(SQLCHAR *) scName, (SQLSMALLINT) nmlen2,
(SQLCHAR *) tbName, (SQLSMALLINT) nmlen3,
(SQLCHAR *) clName, (SQLSMALLINT) nmlen4,
flag, 0, 0);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
if (ctName)
free(ctName);
if (scName)
free(scName);
if (tbName)
free(tbName);
if (clName)
free(clName);
return ret;
}
RETCODE SQL_API
SQLNativeSqlW(HDBC hdbc,
SQLWCHAR *szSqlStrIn,
SQLINTEGER cbSqlStrIn,
SQLWCHAR *szSqlStr,
SQLINTEGER cbSqlStrMax,
SQLINTEGER *pcbSqlStr)
{
CSTR func = "SQLNativeSqlW";
RETCODE ret;
char *szIn, *szOut = NULL, *szOutt = NULL;
SQLLEN slen;
SQLINTEGER buflen, olen;
ConnectionClass *conn = (ConnectionClass *) hdbc;
mylog("[%s}", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
szIn = ucs2_to_utf8(szSqlStrIn, cbSqlStrIn, &slen, FALSE);
buflen = 3 * cbSqlStrMax;
if (buflen > 0)
szOutt = malloc(buflen);
for (;; buflen = olen + 1, szOutt = realloc(szOut, buflen))
{
if (!szOutt)
{
CC_set_error(conn, CONN_NO_MEMORY_ERROR, "Could not allocate memory for output buffer", func);
ret = SQL_ERROR;
break;
}
szOut = szOutt;
ret = PGAPI_NativeSql(hdbc, (SQLCHAR *) szIn, (SQLINTEGER) slen,
(SQLCHAR *) szOut, buflen, &olen);
if (SQL_SUCCESS_WITH_INFO != ret || olen < buflen)
break;
}
if (szIn)
free(szIn);
if (SQL_SUCCEEDED(ret))
{
SQLLEN szcount = olen;
if (olen < buflen)
szcount = utf8_to_ucs2(szOut, olen, szSqlStr, cbSqlStrMax);
if (SQL_SUCCESS == ret && szcount > cbSqlStrMax)
{
ConnectionClass *conn = (ConnectionClass *) hdbc;
ret = SQL_SUCCESS_WITH_INFO;
CC_set_error(conn, CONN_TRUNCATED, "Sql string too large", func);
}
if (pcbSqlStr)
*pcbSqlStr = (SQLINTEGER) szcount;
}
LEAVE_CONN_CS(conn);
free(szOut);
return ret;
}
RETCODE SQL_API SQLExecDirectW(HSTMT StatementHandle,
SQLWCHAR *StatementText, SQLINTEGER TextLength)
{
CSTR func = "SQLExecDirectW";
RETCODE ret;
char *stxt;
SQLLEN slen;
StatementClass *stmt = (StatementClass *) StatementHandle;
UWORD flag = 0;
mylog("[%s]", func);
stxt = ucs2_to_utf8(StatementText, TextLength, &slen, FALSE);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
if (PG_VERSION_GE(SC_get_conn(stmt), 7.4))
flag |= PODBC_WITH_HOLD;
StartRollbackState(stmt);
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_ExecDirect(StatementHandle, stxt, (SQLINTEGER) slen, flag);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
if (stxt)
free(stxt);
return ret;
}
RETCODE SQL_API
SQLPrepareW(HSTMT StatementHandle,
SQLWCHAR *StatementText, SQLINTEGER TextLength)
{
CSTR func = "SQLPrepareW";
StatementClass *stmt = (StatementClass *) StatementHandle;
RETCODE ret;
char *stxt;
SQLLEN slen;
mylog("[%s]", func);
stxt = ucs2_to_utf8(StatementText, TextLength, &slen, FALSE);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_Prepare(StatementHandle, (SQLCHAR *) stxt, (SQLINTEGER) slen);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
if (stxt)
free(stxt);
return ret;
}
std::wstring Dll::FindConflictingModule() {
HMODULE hMods[1024];
DWORD cbNeeded;
TCHAR moduleName[MAX_PATH];
auto hProcess = GetCurrentProcess();
std::wstring conflicting;
const uint32_t templeImageSize = 0x01EB717E;
const uint32_t templeDesiredStart = 0x10000000;
const uint32_t templeDesiredEnd = templeDesiredStart + templeImageSize;
if (EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded)) {
for (uint32_t i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
GetModuleFileName(hMods[i], moduleName, MAX_PATH);
MODULEINFO moduleInfo;
GetModuleInformation(hProcess, hMods[i], &moduleInfo, cbNeeded);
auto fromAddress = reinterpret_cast<uint32_t>(moduleInfo.lpBaseOfDll);
auto toAddress = fromAddress + moduleInfo.SizeOfImage;
logger->debug(" Module {}: 0x{:08x}-0x{:08x}", ucs2_to_utf8(moduleName), fromAddress, toAddress);
if (fromAddress <= templeDesiredEnd && toAddress > templeDesiredStart) {
conflicting = fmt::format(L"{} (0x{:08x}-0x{:08x})", moduleName, fromAddress, toAddress);
}
}
}
CloseHandle(hProcess);
return conflicting;
}
ejsval
_ejs_stream_write (ejsval env, ejsval _this, uint32_t argc, ejsval* args)
{
ejsval to_write = ToString(args[0]);
ejsval internal_fd = _ejs_object_getprop_utf8 (_this, "%internal_fd");
int fd = ToInteger(internal_fd);
int remaining = EJSVAL_TO_STRLEN(to_write);
int offset = 0;
char *buf = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(to_write));
do {
int num_written = write (fd, buf + offset, remaining);
if (num_written == -1) {
if (errno == EINTR)
continue;
perror ("write");
free (buf);
return _ejs_false;
}
remaining -= num_written;
offset += num_written;
} while (remaining > 0);
free (buf);
return _ejs_true;
}
static void
osk_returned(glw_ps3_t *gp)
{
oskCallbackReturnParam param = {0};
uint8_t ret[512];
uint8_t buf[512];
if(param.result != 0)
return;
assert(gp->osk_widget != NULL);
param.length = sizeof(ret)/2;
param.str_addr = (intptr_t)ret;
oskUnloadAsync(¶m);
ucs2_to_utf8(buf, sizeof(buf), ret, sizeof(ret), 0);
glw_lock(&gp->gr);
glw_t *w = gp->osk_widget;
if(!(w->glw_flags & GLW_DESTROYING) && w->glw_class->gc_update_text) {
w->glw_class->gc_update_text(w, (const char *)buf);
}
glw_osk_close(&gp->gr);
glw_unlock(&gp->gr);
}
ejsval
_ejs_invoke_closure (ejsval closure, ejsval _this, uint32_t argc, ejsval* args)
{
if (!EJSVAL_IS_FUNCTION(closure)) {
#if DEBUG_LAST_LOOKUP
extern jschar* last_lookup;
if (last_lookup) {
char *last_utf8 = ucs2_to_utf8(last_lookup);
_ejs_log ("last property lookup was for: %s\n", last_utf8);
free (last_utf8);
}
#endif
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "object not a function");
}
#if 0
if (!EJSVAL_IS_NULL_OR_UNDEFINED(_this) && EJSVAL_IS_PRIMITIVE(_this)) {
_this = ToObject(_this);
}
#endif
EJSFunction *fun = (EJSFunction*)EJSVAL_TO_OBJECT(closure);
return fun->func (fun->env, _this, argc, args);
}
RETCODE SQL_API SQLTablePrivilegesW(
HSTMT hstmt,
SQLWCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLWCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLWCHAR *szTableName,
SQLSMALLINT cbTableName)
{
CSTR func = "SQLTablePrivilegesW";
RETCODE ret;
char *ctName, *scName, *tbName;
SQLLEN nmlen1, nmlen2, nmlen3;
StatementClass *stmt = (StatementClass *) hstmt;
ConnectionClass *conn;
BOOL lower_id;
UWORD flag = 0;
mylog("[%s]", func);
conn = SC_get_conn(stmt);
lower_id = SC_is_lower_case(stmt, conn);
ctName = ucs2_to_utf8(szCatalogName, cbCatalogName, &nmlen1, lower_id);
scName = ucs2_to_utf8(szSchemaName, cbSchemaName, &nmlen2, lower_id);
tbName = ucs2_to_utf8(szTableName, cbTableName, &nmlen3, lower_id);
ENTER_STMT_CS((StatementClass *) hstmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
#if (ODBCVER >= 0x0300)
if (stmt->options.metadata_id)
flag |= PODBC_NOT_SEARCH_PATTERN;
#endif
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_TablePrivileges(hstmt, ctName, (SQLSMALLINT) nmlen1,
scName, (SQLSMALLINT) nmlen2, tbName, (SQLSMALLINT) nmlen3, flag);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS((StatementClass *) hstmt);
if (ctName)
free(ctName);
if (scName)
free(scName);
if (tbName)
free(tbName);
return ret;
}
/* 15.12.2 */
static ejsval
_ejs_JSON_parse (ejsval env, ejsval _this, uint32_t argc, ejsval *args)
{
ejsval text = _ejs_undefined;
ejsval reviver = _ejs_undefined;
if (argc > 0) text = args[0];
if (argc > 1) reviver = args[1];
/* 1. Let JText be ToString(text). */
ejsval jtext = ToString(text);
/* 2. Parse JText using the grammars in 15.12.1. Throw a SyntaxError exception if JText did not conform to the
JSON grammar for the goal symbol JSONText. */
char *flattened_jtext = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(jtext));
/* 3. Let unfiltered be the result of parsing and evaluating JText as if it was the source text of an ECMAScript
Program but using JSONString in place of StringLiteral. Note that since JText conforms to the JSON
grammar this result will be either a primitive value or an object that is defined by either an ArrayLiteral or
an ObjectLiteral. */
JSON_Value* root_val = json_parse_string(flattened_jtext);
free(flattened_jtext);
if (root_val == NULL) {
printf ("SyntaxError\n");
EJS_NOT_IMPLEMENTED();
}
ejsval unfiltered;
if (!json_value_to_ejsval(root_val, &unfiltered)) {
json_value_free (root_val);
/* unfiltered here is an exception */
EJS_NOT_IMPLEMENTED();
}
json_value_free (root_val);
/* 4. If IsCallable(reviver) is true, then */
if (EJSVAL_IS_CALLABLE(reviver)) {
printf ("no reviver support in JSON.parse yet\n");
EJS_NOT_IMPLEMENTED();
/* a. Let root be a new object created as if by the expression new Object(), where Object is the
standard built-in constructor with that name. */
/* b. Call the [[DefineOwnProperty]] internal method of root with the empty String, the
PropertyDescriptor {[[Value]]: unfiltered, [[Writable]]: true, [[Enumerable]]: true,
[[Configurable]]: true}, and false as arguments. */
/* c. Return the result of calling the abstract operation Walk, passing root and the empty String. The
abstract operation Walk is described below. */
}
/* 5. Else */
else {
/* a. Return unfiltered. */
return unfiltered;
}
}
static ejsval
_ejs_path_basename (ejsval env, ejsval _this, uint32_t argc, ejsval* args)
{
ejsval path = args[0];
// FIXME node's implementation allows a second arg to strip the extension, but the compiler doesn't use it.
char *utf8_path = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(path));
ejsval rv = _ejs_string_new_utf8(basename (utf8_path));
free (utf8_path);
return rv;
}
RETCODE SQL_API
SQLSpecialColumnsW(HSTMT StatementHandle,
SQLUSMALLINT IdentifierType, SQLWCHAR *CatalogName,
SQLSMALLINT NameLength1, SQLWCHAR *SchemaName,
SQLSMALLINT NameLength2, SQLWCHAR *TableName,
SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
SQLUSMALLINT Nullable)
{
CSTR func = "SQLSpecialColumnsW";
RETCODE ret;
char *ctName, *scName, *tbName;
SQLLEN nmlen1, nmlen2, nmlen3;
StatementClass *stmt = (StatementClass *) StatementHandle;
ConnectionClass *conn;
BOOL lower_id;
mylog("[%s]", func);
conn = SC_get_conn(stmt);
lower_id = SC_is_lower_case(stmt, conn);
ctName = ucs2_to_utf8(CatalogName, NameLength1, &nmlen1, lower_id);
scName = ucs2_to_utf8(SchemaName, NameLength2, &nmlen2, lower_id);
tbName = ucs2_to_utf8(TableName, NameLength3, &nmlen3, lower_id);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_SpecialColumns(StatementHandle, IdentifierType,
(SQLCHAR *) ctName, (SQLSMALLINT) nmlen1,
(SQLCHAR *) scName, (SQLSMALLINT) nmlen2,
(SQLCHAR *) tbName, (SQLSMALLINT) nmlen3,
Scope, Nullable);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
if (ctName)
free(ctName);
if (scName)
free(scName);
if (tbName)
free(tbName);
return ret;
}
static ConfigSetting WString(const char *option, Setter<wstring> setter, Getter<wstring> getter, const char *description = nullptr) {
auto getterAdapter = [=] {
return ucs2_to_utf8(getter());
};
auto setterAdapter = [=](string value) {
setter(utf8_to_ucs2(value));
};
return ConfigSetting(option, setterAdapter, getterAdapter, description);
}
RETCODE SQL_API
SQLPrimaryKeysW(HSTMT hstmt,
SQLWCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLWCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLWCHAR *szTableName,
SQLSMALLINT cbTableName)
{
CSTR func = "SQLPrimaryKeysW";
RETCODE ret;
char *ctName, *scName, *tbName;
SQLLEN nmlen1, nmlen2, nmlen3;
StatementClass *stmt = (StatementClass *) hstmt;
ConnectionClass *conn;
BOOL lower_id;
mylog("[%s]", func);
conn = SC_get_conn(stmt);
lower_id = SC_is_lower_case(stmt, conn);
ctName = ucs2_to_utf8(szCatalogName, cbCatalogName, &nmlen1, lower_id);
scName = ucs2_to_utf8(szSchemaName, cbSchemaName, &nmlen2, lower_id);
tbName = ucs2_to_utf8(szTableName, cbTableName, &nmlen3, lower_id);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_PrimaryKeys(hstmt,
(SQLCHAR *) ctName, (SQLSMALLINT) nmlen1,
(SQLCHAR *) scName, (SQLSMALLINT) nmlen2,
(SQLCHAR *) tbName, (SQLSMALLINT) nmlen3, 0);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
if (ctName)
free(ctName);
if (scName)
free(scName);
if (tbName)
free(tbName);
return ret;
}
static ejsval
_ejs_fs_readFileSync (ejsval env, ejsval _this, uint32_t argc, ejsval* args)
{
// FIXME we currently ignore the encoding and just slam the entire thing into a buffer and return a utf8 string...
char* utf8_path = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(args[0]));
int fd = open (utf8_path, O_RDONLY);
if (fd == -1) {
char buf[256];
snprintf (buf, sizeof(buf), "%s: `%s`", strerror(errno), utf8_path);
free(utf8_path);
_ejs_throw_nativeerror_utf8 (EJS_ERROR, buf);
}
struct stat fd_stat;
int stat_rv = fstat (fd, &fd_stat);
if (stat_rv == -1) {
char buf[256];
snprintf (buf, sizeof(buf), "%s: `%s`", strerror(errno), utf8_path);
free(utf8_path);
close(fd);
_ejs_throw_nativeerror_utf8 (EJS_ERROR, buf);
}
int amount_to_read = fd_stat.st_size;
int amount_read = 0;
char *buf = (char*)calloc (1, amount_to_read+1);
do {
int c = read(fd, buf + amount_read, amount_to_read);
if (c == -1) {
if (errno == EINTR)
continue;
else {
char msg[256];
snprintf (msg, sizeof(msg), "%s: `%s`", strerror(errno), utf8_path);
free(utf8_path);
close(fd);
free (buf);
_ejs_throw_nativeerror_utf8 (EJS_ERROR, msg);
}
}
else {
amount_to_read -= c;
amount_read += c;
}
} while (amount_to_read > 0);
free(utf8_path);
ejsval rv = _ejs_string_new_utf8_len(buf, amount_read);
free(buf);
return rv;
}
const unsigned char * const
efi_loadopt_desc(efi_load_option *opt)
{
if (last_desc) {
free(last_desc);
last_desc = NULL;
}
last_desc = ucs2_to_utf8(opt->description, -1);
return last_desc;
}
static ejsval
_ejs_child_process_spawn (ejsval env, ejsval _this, uint32_t argc, ejsval* args)
{
char* argv0 = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(args[0]));
EJSArray* argv_rest = (EJSArray*)EJSVAL_TO_OBJECT(args[1]);
char **argv = (char**)calloc(sizeof(char*), EJSARRAY_LEN(argv_rest) + 2);
argv[0] = argv0;
for (uint32_t i = 0; i < EJSARRAY_LEN(argv_rest); i ++)
argv[1+i] = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(ToString(EJSDENSEARRAY_ELEMENTS(argv_rest)[i])));
pid_t pid;
switch (pid = fork()) {
case -1: /* error */
perror("fork");
printf ("we should totally throw an exception here\n");
break;
case 0: /* child */
execvp (argv0, argv);
perror("execv");
EJS_NOT_REACHED();
break;
default: /* parent */ {
int stat;
int wait_rv;
do {
wait_rv = waitpid(pid, &stat, 0);
} while (wait_rv == -1 && errno == EINTR);
if (wait_rv != pid) {
perror ("waitpid");
printf ("we should totally throw an exception here\n");
}
break;
}
}
for (uint32_t i = 0; i < EJSARRAY_LEN(argv_rest)+1; i ++)
free (argv[i]);
free (argv);
return _ejs_undefined;
}
void
_ejs_throw_nativeerror (EJSNativeErrorType error_type, ejsval message)
{
ejsval exc = _ejs_nativeerror_new (error_type, message);
char *message_utf8 = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(message));
_ejs_log ("throwing exception with message %s\n", message_utf8);
free (message_utf8);
_ejs_throw (exc);
EJS_NOT_REACHED();
}
RETCODE SQL_API SQLForeignKeysW(
HSTMT hstmt,
SQLWCHAR *szPkCatalogName,
SQLSMALLINT cbPkCatalogName,
SQLWCHAR *szPkSchemaName,
SQLSMALLINT cbPkSchemaName,
SQLWCHAR *szPkTableName,
SQLSMALLINT cbPkTableName,
SQLWCHAR *szFkCatalogName,
SQLSMALLINT cbFkCatalogName,
SQLWCHAR *szFkSchemaName,
SQLSMALLINT cbFkSchemaName,
SQLWCHAR *szFkTableName,
SQLSMALLINT cbFkTableName)
{
CSTR func = "SQLForeignKeysW";
RETCODE ret;
char *ctName, *scName, *tbName, *fkctName, *fkscName, *fktbName;
SQLLEN nmlen1, nmlen2, nmlen3, nmlen4, nmlen5, nmlen6;
StatementClass *stmt = (StatementClass *) hstmt;
ConnectionClass *conn;
BOOL lower_id;
mylog("[%s]", func);
conn = SC_get_conn(stmt);
lower_id = SC_is_lower_case(stmt, conn);
ctName = ucs2_to_utf8(szPkCatalogName, cbPkCatalogName, &nmlen1, lower_id);
scName = ucs2_to_utf8(szPkSchemaName, cbPkSchemaName, &nmlen2, lower_id);
tbName = ucs2_to_utf8(szPkTableName, cbPkTableName, &nmlen3, lower_id);
fkctName = ucs2_to_utf8(szFkCatalogName, cbFkCatalogName, &nmlen4, lower_id);
fkscName = ucs2_to_utf8(szFkSchemaName, cbFkSchemaName, &nmlen5, lower_id);
fktbName = ucs2_to_utf8(szFkTableName, cbFkTableName, &nmlen6, lower_id);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
if (SC_opencheck(stmt, func))
ret = SQL_ERROR;
else
ret = PGAPI_ForeignKeys(hstmt, ctName, (SQLSMALLINT) nmlen1,
scName, (SQLSMALLINT) nmlen2, tbName, (SQLSMALLINT) nmlen3,
fkctName, (SQLSMALLINT) nmlen4, fkscName, (SQLSMALLINT) nmlen5,
fktbName, (SQLSMALLINT) nmlen6);
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
if (ctName)
free(ctName);
if (scName)
free(scName);
if (tbName)
free(tbName);
if (fkctName)
free(fkctName);
if (fkscName)
free(fkscName);
if (fktbName)
free(fktbName);
return ret;
}
static EJS_NATIVE_FUNC(_ejs_Process_chdir) {
ejsval dir = _ejs_undefined;
if (argc > 0)
dir = args[0];
if (!EJSVAL_IS_STRING(dir))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "chdir passed non-string");
char *dir_utf8 = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(dir));
chdir(dir_utf8);
free(dir_utf8);
return _ejs_undefined;
}
ejsval
_ejs_fs_createWriteStream (ejsval env, ejsval _this, uint32_t argc, ejsval* args)
{
char *utf8_path = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(args[0]));
int fd = open (utf8_path, O_CREAT | O_TRUNC | O_WRONLY, 0777);
free (utf8_path);
if (fd == -1) {
perror ("open");
printf ("we should totally throw an exception here\n");
return _ejs_undefined;
}
return _ejs_wrapFdWithStream(fd);
}
void logRequestVerbose(const REQUEST *const Request, const PRINTFUNC p)
{
char guidBuffer[GUID_STRING_LENGTH + 1];
char WorkstationBuffer[3 * WORKSTATION_NAME_BUFFER];
const char *productName;
ProdListIndex_t index;
p("Protocol version : %u.%u\n", LE16(Request->MajorVer), LE16(Request->MinorVer));
p("Client is a virtual machine : %s\n", LE32(Request->VMInfo) ? "Yes" : "No");
p("Licensing status : %u (%s)\n", (uint32_t)LE32(Request->LicenseStatus), LE32(Request->LicenseStatus) < _countof(LicenseStatusText) ? LicenseStatusText[LE32(Request->LicenseStatus)] : "Unknown");
p("Remaining time (0 = forever) : %i minutes\n", (uint32_t)LE32(Request->BindingExpiration));
uuid2StringLE(&Request->AppID, guidBuffer);
productName = getProductNameLE(&Request->AppID, AppList, getAppListSize(), &index);
p("Application ID : %s (%s)\n", guidBuffer, productName);
uuid2StringLE(&Request->ActID, guidBuffer);
# ifndef NO_EXTENDED_PRODUCT_LIST
productName = getProductNameLE(&Request->ActID, ExtendedProductList, getExtendedProductListSize(), &index);
# else
productName = "Unknown";
# endif
p("SKU ID (aka Activation ID) : %s (%s)\n", guidBuffer, productName);
uuid2StringLE(&Request->KMSID, guidBuffer);
productName = getProductNameLE(&Request->KMSID, ProductList, getProductListSize(), &index);
p("KMS ID (aka KMS counted ID) : %s (%s)\n", guidBuffer, productName);
uuid2StringLE(&Request->CMID, guidBuffer);
p("Client machine ID : %s\n", guidBuffer);
uuid2StringLE(&Request->CMID_prev, guidBuffer);
p("Previous client machine ID : %s\n", guidBuffer);
char mbstr[64];
time_t st;
st = fileTimeToUnixTime(&Request->ClientTime);
strftime(mbstr, sizeof(mbstr), "%Y-%m-%d %X", gmtime(&st));
p("Client request timestamp (UTC) : %s\n", mbstr);
ucs2_to_utf8(Request->WorkstationName, WorkstationBuffer, WORKSTATION_NAME_BUFFER, sizeof(WorkstationBuffer));
p("Workstation name : %s\n", WorkstationBuffer);
p("N count policy (minimum clients): %u\n", (uint32_t)LE32(Request->N_Policy));
}
static ejsval
_ejs_Process_chdir (ejsval env, ejsval _this, uint32_t argc, ejsval* args)
{
ejsval dir = _ejs_undefined;
if (argc > 0)
dir = args[0];
if (!EJSVAL_IS_STRING(dir))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "chdir passed non-string");
char *dir_utf8 = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(dir));
chdir(dir_utf8);
free(dir_utf8);
return _ejs_undefined;
}
GpStatus
GdipPrivateAddFontFile (GpFontCollection *font_collection, GDIPCONST WCHAR *filename)
{
BYTE *file;
if (!font_collection || !filename)
return InvalidParameter;
file = (BYTE*) ucs2_to_utf8 ((const gunichar2 *)filename, -1);
if (!file)
return OutOfMemory;
FcConfigAppFontAddFile (font_collection->config, file);
GdipFree (file);
return Ok;
}
/**
* RIL_UNSOL_ON_USSD
*
* Called when a new USSD message is received.
*/
int onUSSDReceived(const char *s, char* sms_pdu)
{
char *line, *linestart;
int typeCode, count, err, len;
char *message;
char *outputmessage;
char *responseStr[2];
linestart=line=strdup(s);
err = at_tok_start(&line);
if(err < 0) goto out;
err = at_tok_nextint(&line, &typeCode);
if(err < 0) goto out;
if(at_tok_hasmore(&line)) {
int format;
char message[256];
int n = sscanf(s+6,"%*d,\"%[^\"]\",%d",message,&format);
LOGD("%s,%d",message,format);
if(format == 15){
responseStr[1] = malloc(strlen(message)+1);
strcpy(responseStr[1],message);
}else{
int len = strlen(message);
outputmessage = malloc(len/2);
gsm_hex_to_bytes((cbytes_t)message,len,(bytes_t)outputmessage);
responseStr[1] = malloc(len);
len = ucs2_to_utf8((cbytes_t)outputmessage,len/2,(bytes_t)responseStr[1]);
free(outputmessage);
}
count = 2;
} else {
responseStr[1]=NULL;
count = 1;
}
free(linestart);
asprintf(&responseStr[0], "%d", typeCode);
RIL_onUnsolicitedResponse (RIL_UNSOL_ON_USSD, responseStr, count*sizeof(char*));
out:
return UNSOLICITED_SUCCESSED;
}
// ECMA262 15.3.4.2
static ejsval
_ejs_Function_prototype_toString (ejsval env, ejsval _this, uint32_t argc, ejsval *args)
{
char terrible_fixed_buffer[256];
if (!EJSVAL_IS_FUNCTION(_this))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "Function.prototype.toString is not generic.");
ejsval func_name = _ejs_object_getprop (_this, _ejs_atom_name);
char *utf8_funcname = ucs2_to_utf8(EJSVAL_TO_FLAT_STRING(func_name));
snprintf (terrible_fixed_buffer, sizeof (terrible_fixed_buffer), "function %s() {}", utf8_funcname);
free (utf8_funcname);
return _ejs_string_new_utf8(terrible_fixed_buffer);
}
RETCODE SQL_API
SQLBrowseConnectW(HDBC hdbc,
SQLWCHAR *szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLWCHAR *szConnStrOut,
SQLSMALLINT cbConnStrOutMax,
SQLSMALLINT *pcbConnStrOut)
{
CSTR func = "SQLBrowseConnectW";
char *szIn, *szOut;
SQLLEN inlen;
SQLUSMALLINT obuflen;
SQLSMALLINT olen;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
mylog("[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
szIn = ucs2_to_utf8(szConnStrIn, cbConnStrIn, &inlen, FALSE);
obuflen = cbConnStrOutMax + 1;
szOut = malloc(obuflen);
if (szOut)
ret = PGAPI_BrowseConnect(hdbc, (SQLCHAR *) szIn, (SQLSMALLINT) inlen,
(SQLCHAR *) szOut, cbConnStrOutMax, &olen);
else
{
CC_set_error(conn, CONN_NO_MEMORY_ERROR, "Could not allocate memory for output buffer", func);
ret = SQL_ERROR;
}
LEAVE_CONN_CS(conn);
if (ret != SQL_ERROR)
{
SQLLEN outlen = utf8_to_ucs2(szOut, olen, szConnStrOut, cbConnStrOutMax);
if (pcbConnStrOut)
*pcbConnStrOut = (SQLSMALLINT) outlen;
}
free(szOut);
if (szIn)
free(szIn);
return ret;
}
