caddr_t
complete_charset_name (caddr_t _qi, char *cs_name)
{
caddr_t result;
wcharset_t *cs = sch_name_to_charset (cs_name);
query_instance_t *qi = (query_instance_t *)_qi;
if (cs)
result = box_dv_short_string (cs->chrs_name);
else
{
char q[MAX_NAME_LEN];
char o[MAX_NAME_LEN];
char n[MAX_NAME_LEN];
char complete[MAX_QUAL_NAME_LEN];
q[0] = 0;
o[0] = 0;
n[0] = 0;
sch_split_name (qi->qi_client->cli_qualifier, cs_name, q, o, n);
if (0 == o[0])
strcpy_ck (o, cli_owner (qi->qi_client));
snprintf (complete, sizeof (complete), "%s.%s.%s", q, o, n);
result = box_dv_short_string (complete);
}
if (CM_UPPER == case_mode && result)
sqlp_upcase (result);
return result;
}
box_t
mts_transaction_status (lock_trx_t * lt)
{
if (lt->lt_2pc._2pc_type)
{
return box_dv_short_string ("2pc enabled");
}
else
{
return box_dv_short_string ("2pc disabled");
}
};
void
trset_printf (const char *str, ...)
{
char *report_linebuf;
char *report_ptr;
char *line;
char *eol;
char *copy;
va_list ap;
size_t length;
report_linebuf = (char *) THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_BUFFER);
report_ptr = (char *) THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_PTR);
va_start (ap, str);
vsnprintf (report_ptr, REPORT_BUF_MAX - (report_linebuf - report_ptr), str, ap);
va_end (ap);
for (line = eol = report_linebuf; *line; line = eol)
{
if ((eol = strchr (line, '\n')) == NULL)
break;
*eol++ = 0;
if (line[0] == 0)
line = " ";
copy = box_dv_short_string (line);
bif_result_inside_bif (1, copy);
dk_free_box (copy);
}
if (eol == NULL)
{
length = strlen (line);
if (report_linebuf != line && length >= 0)
memmove (report_linebuf, line, length);
}
else
length = 0;
report_ptr = report_linebuf + length;
if (length > REPORT_BUF_MAX - EXPLAIN_LINE_MAX)
{
caddr_t copy = box_dv_short_string (report_linebuf);
bif_result_inside_bif (1, copy);
dk_free_box (copy);
report_ptr = report_linebuf;
}
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_BUFFER, report_linebuf);
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_PTR, report_ptr);
}
caddr_t get_view_name (utf8char * fullname, char sign)
{
utf8char *hit;
while (
((hit = (utf8char *) strchr ((const char *) fullname, '/')) != NULL) ||
((hit = (utf8char *) strchr ((const char *) fullname, '\\')) != NULL) )
fullname = hit+1;
while ('.' == fullname[0])
fullname++;
if ((sign == fullname[0]) || ('\0' == fullname[0]))
return box_dv_short_string ("_");
if ((hit = (utf8char *) strchr ((const char *) fullname, sign)) != NULL)
return box_dv_short_nchars ((const char *) fullname, hit - fullname);
return box_dv_short_string ((const char *) fullname);
}
box_t
mts_server_status ()
{
LOCK_OBJECT (local_rm);
if (local_rm)
{
RELEASE_OBJECT (local_rm);
return box_dv_short_string ("connected");
}
else
{
RELEASE_OBJECT (local_rm);
return box_dv_short_string ("disconnected");
}
}
static unit_version_t *
hosting_plugin_load (const char *plugin_dll_name, const char *plugin_load_path)
{
char *filename, *funname;
const char *dot;
hosting_version_t *hver;
int inx;
size_t file_name_max_len = strlen (plugin_load_path) + 1 + strlen (plugin_dll_name) + 1;
size_t funname_max_len;
filename = (char *) dk_alloc (strlen (plugin_load_path) + 1 + strlen (plugin_dll_name) + 1);
snprintf (filename, file_name_max_len, "%s/%s", plugin_load_path, plugin_dll_name);
funname_max_len = strlen (plugin_dll_name) + 6 /* == strlen ("_check") */ + 1;
filename = (char *) dk_alloc (file_name_max_len);
snprintf (filename, file_name_max_len, "%s/%s", plugin_load_path, plugin_dll_name);
funname = (char *) dk_alloc (funname_max_len);
dot = strchr (plugin_dll_name, '.');
if (!dot)
dot = plugin_dll_name + strlen (plugin_dll_name);
strncpy (funname, plugin_dll_name, dot - plugin_dll_name);
funname[dot - plugin_dll_name] = 0;
strncat_size_ck (funname, "_check", funname_max_len - strlen (funname) - 1, funname_max_len);
hver = hosting_load_and_check_plugin (filename, funname, &dock_hosting_version, NULL);
for (inx = 0; hver->hv_extensions && hver->hv_extensions[inx]; inx++)
{
caddr_t ext = box_dv_short_string (hver->hv_extensions[inx]);
id_hash_set (ext_hash, (caddr_t) &ext, (caddr_t) &hver);
}
return &(hver->hv_pversion);
}
void
trset_end (void)
{
client_connection_t * cli = GET_IMMEDIATE_CLIENT_OR_NULL;
char *report_linebuf;
char *report_ptr;
char *line;
caddr_t ret;
report_linebuf = (char *) THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_BUFFER);
report_ptr = (char *) THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_PTR);
if (report_ptr > report_linebuf)
{
*report_ptr = 0;
line = box_dv_short_string (report_linebuf);
bif_result_inside_bif (1, line);
dk_free_box (line);
}
dk_free_box (report_linebuf);
if (cli && !cli->cli_ws && !cli->cli_resultset_comp_ptr)
{
ret = list (2, (caddr_t) QA_PROC_RETURN, (caddr_t) 0);
PrpcAddAnswer ((caddr_t) ret, DV_ARRAY_OF_POINTER, PARTIAL, 0);
dk_free_box (ret);
}
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_BUFFER, NULL);
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_PTR, NULL);
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_QST, NULL);
}
void creole_connect (void *appdata)
{
creole_WIKIVERSION = box_dv_short_string (creole_VERSION);
creole_lexer_mutex = mutex_allocate ();
bif_define ("WikiV macroexpander 2", bif_creole_macroexpander);
bif_define ("WikiV lexer 2", bif_creole_lexer);
bif_define ("WikiV name 2", bif_creole_name);
}
void wikiv_connect (void *appdata)
{
wikiv_WIKIVERSION = box_dv_short_string (WIKIV_VERSION);
wikiv_lexer_mutex = mutex_allocate ();
bif_define ("WikiV macroexpander", bif_wikiv_macroexpander);
bif_define ("WikiV lexer", bif_wikiv_lexer);
bif_define ("WikiV name", bif_wikiv_name);
}
void
mutex_option (dk_mutex_t * mtx, char * name, mtx_entry_check_t ck, void * cd)
{
dk_free_box (mtx->mtx_name);
mtx->mtx_name = box_dv_short_string (name);
mtx->mtx_entry_check = ck;
mtx->mtx_entry_check_cd = cd;
}
void mediawiki_connect (void *appdata)
{
mediawiki_WIKIVERSION = box_dv_short_string (MEDIAWIKI_VERSION);
mediawiki_lexer_mutex = mutex_allocate ();
bif_define ("WikiV macroexpander 1", bif_mediawiki_macroexpander);
bif_define ("WikiV lexer 1", bif_mediawiki_lexer);
bif_define ("WikiV name 1", bif_mediawiki_name);
}
caddr_t
bif_date_string (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
char temp[100];
caddr_t arg = bif_date_arg (qst, args, 0, "datestring");
dt_to_string (arg, temp, sizeof (temp));
return (box_dv_short_string (temp));
}
caddr_t
bif_date_string_GMT (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
char temp[100];
caddr_t arg = bif_date_arg (qst, args, 0, "datestring");
char dt2[DT_LENGTH];
memcpy (dt2, arg, DT_LENGTH);
DT_SET_TZ (dt2, 0);
dt_to_string (dt2, temp, sizeof (temp));
return (box_dv_short_string (temp));
}
void im_connect (void *appdata)
{
im_IMVERSION = box_dv_short_string (IM_VERSION);
im_lib_mutex = mutex_allocate ();
bif_define ("IM ResizeImageFile", bif_im_ResizeImageFile);
bif_define ("IM ThumbnailImageFile", bif_im_ThumbnailImageFile);
bif_define ("IM ConvertImageFile", bif_im_ConvertImageFile);
bif_define ("IM ResampleImageFile", bif_im_ResampleImageFile);
bif_define ("IM RotateImageFile", bif_im_RotateImageFile);
bif_define ("IM CropImageFile", bif_im_CropImageFile);
bif_define ("IM GetImageFileAttribute", bif_im_GetImageFileAttribute);
bif_define ("IM GetImageFileFormat", bif_im_GetImageFileFormat);
bif_define ("IM GetImageFileIdentify", bif_im_GetImageFileIdentify);
bif_define ("IM GetImageBlobIdentify", bif_im_GetImageBlobIdentify);
bif_define ("IM GetImageFileWidth", bif_im_GetImageFileWidth);
bif_define ("IM GetImageFileHeight", bif_im_GetImageFileHeight);
bif_define ("IM GetImageFileDepth", bif_im_GetImageFileDepth);
bif_define ("IM GetImageFileWH", bif_im_GetImageFileWH);
bif_define ("IM ResizeImageFileToBlob", bif_im_ResizeImageFileToBlob);
bif_define ("IM ThumbnailImageFileToBlob", bif_im_ThumbnailImageFileToBlob);
bif_define ("IM ResampleImageFileToBlob", bif_im_ResampleImageFileToBlob);
bif_define ("IM RotateImageFileToBlob", bif_im_RotateImageFileToBlob);
bif_define ("IM CropImageFileToBlob", bif_im_CropImageFileToBlob);
bif_define ("IM GetImageBlobAttribute", bif_im_GetImageBlobAttribute);
bif_define ("IM GetImageBlobFormat", bif_im_GetImageBlobFormat);
bif_define ("IM GetImageBlobWidth", bif_im_GetImageBlobWidth);
bif_define ("IM GetImageBlobHeight", bif_im_GetImageBlobHeight);
bif_define ("IM GetImageBlobDepth", bif_im_GetImageBlobDepth);
bif_define ("IM GetImageBlobWH", bif_im_GetImageBlobWH);
bif_define ("IM ConvertImageBlob", bif_im_ConvertImageBlob);
bif_define ("IM ResizeImageBlob", bif_im_ResizeImageBlob);
bif_define ("IM ThumbnailImageBlob", bif_im_ThumbnailImageBlob);
bif_define ("IM DeepZoom4to1", bif_im_DeepZoom4to1);
bif_define ("IM ResampleImageBlob", bif_im_ResampleImageBlob);
bif_define ("IM RotateImageBlob", bif_im_RotateImageBlob);
bif_define ("IM CropImageBlob", bif_im_CropImageBlob);
bif_define ("IM CropAndResizeImageBlob", bif_im_CropAndResizeImageBlob);
#if defined(HasTTF) || defined(HasFREETYPE)
bif_define ("IM AnnotateImageBlob", bif_im_AnnotateImageBlob);
#endif
bif_define ("IM CreateImageBlob", bif_im_CreateImageBlob);
bif_define ("IM XYtoMorton", bif_im_XY_to_Morton);
MagickWandGenesis();
}
void
key_col_from_ssl (dbe_key_t * key, state_slot_t * ssl, int quietcast, gb_op_t *gb_op)
{
NEW_VARZ (dbe_column_t, col);
col->col_name = box_dv_short_string (SSL_HAS_NAME (ssl) ? ssl->ssl_name : "const");
col->col_compression = CC_NONE;
col->col_sqt = ssl->ssl_sqt;
col->col_sqt.sqt_non_null = 0;
if (DV_LONG_INT == ssl->ssl_dtp && !ssl->ssl_column)
col->col_sqt.sqt_dtp = DV_INT64; /* temp results of int exprs can be wider */
if (DV_IRI_ID == col->col_sqt.sqt_dtp)
col->col_sqt.sqt_dtp = DV_IRI_ID_8;
if (DV_UNKNOWN == col->col_sqt.sqt_dtp
|| (!dtp_is_fixed (col->col_sqt.sqt_dtp) && !dtp_is_var (col->col_sqt.sqt_dtp)))
{
col->col_sqt.sqt_dtp = quietcast ? DV_ANY : DV_LONG_STRING;
col->col_sqt.sqt_precision = 0;
}
/* turn off length checking for temp cols for now */
if (col->col_sqt.sqt_dtp == DV_LONG_STRING ||
col->col_sqt.sqt_dtp == DV_ANY)
col->col_sqt.sqt_precision = 0;
if (gb_op && col->col_sqt.sqt_dtp == DV_ANY)
{
switch (gb_op->go_op)
{
case AMMSC_COUNT:
col->col_sqt.sqt_dtp = DV_INT64;
col->col_sqt.sqt_precision = DV_LONG_INT_PREC;
break;
case AMMSC_COUNTSUM:
case AMMSC_SUM:
case AMMSC_AVG:
col->col_sqt.sqt_dtp = DV_NUMERIC;
col->col_sqt.sqt_precision = NUMERIC_MAX_PRECISION;
col->col_sqt.sqt_precision = NUMERIC_MAX_SCALE;
break;
default:
break;
}
}
col->col_id = dk_set_length (key->key_parts) + 1;
col->col_options = (caddr_t *) box_copy_tree ((box_t) ssl->ssl_sqt.sqt_tree);
NCONCF1 (key->key_parts, col);
}
void
mpschema_set_view_def (char *name, caddr_t tree)
{
caddr_t *old_tree = NULL;
old_tree = (caddr_t *) id_hash_get (xml_global->xs_views, (caddr_t) &name);
if (old_tree)
{
if (*old_tree)
{
if (*old_tree == tree)
GPF_T;
dk_set_push (xml_global->xs_old_views, *old_tree);
}
*old_tree = tree;
}
else
{
name = box_dv_short_string (name);
id_hash_set (xml_global->xs_views, (caddr_t) & name, (caddr_t) & tree);
}
}
caddr_t
dotnet_get_instance_name (int instance)
{
MonoArray *v_args;
MonoObject *mono_ret;
caddr_t ret = NULL;
MonoDomain *domain = virtuoso_domain;
char *utf8;
get_mono_thread ();
v_args = MAKE_PARAM_ARRAY (domain, 1);
SET_INT_ARG (domain, v_args, 0, instance);
mono_ret = call_mono (VIRTCLR_NAME, "VInvoke:get_instance_name", v_args, domain);
if (!mono_ret || !mono_object_isinst (mono_ret, mono_get_string_class ()))
GPF_T1 ("not a string in dotnet_get_instance_name");
utf8 = mono_string_to_utf8 ((MonoString *)mono_ret);
ret = box_dv_short_string (utf8);
g_free (utf8);
return ret;
}
void
set_xj_pk (xv_join_elt_t * xj) /*get primary key*/
{
if (xj->xj_table)
{
dbe_table_t *tb = sch_name_to_table (wi_inst.wi_schema, xj->xj_table);
if (!tb)
{
sqlr_error ("S0002", "No table '%.300s' in create xml", xj->xj_table);
}
if (!xj->xj_pk)
{
int fill = 0;
dbe_key_t *pk = tb->tb_primary_key;
xj->xj_pk = (caddr_t *) dk_alloc_box_zero (pk->key_n_significant * sizeof (caddr_t),
DV_ARRAY_OF_POINTER);
DO_SET (dbe_column_t *, col, &pk->key_parts)
{
xj->xj_pk[fill++] = box_dv_short_string (col->col_name);
if (fill >= pk->key_n_significant)
break;
}
END_DO_SET ();
}
caddr_t bif_creole_name (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
return box_dv_short_string ("CreoleWiki");
}
caddr_t bif_mediawiki_name (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
return box_dv_short_string ("MediaWiki");
}
caddr_t
bif_im_get_impl (caddr_t * qst, caddr_t * err, state_slot_t ** args, int is_file_in, int op, const char *bifname)
{
im_env_t env;
char *strg_value = NULL;
unsigned long ul_value = 0;
caddr_t res = NULL;
int is_string_res = (('A' == op) || ('F' == op) || ('I' == op));
int is_list_res = ('2' == op);
int is_key_needed = ('A' == op);
caddr_t key = is_key_needed ? bif_string_arg (qst, args, (is_file_in ? 1 : 2), bifname) : NULL;
im_init (&env, qst, args, bifname);
if (is_file_in)
im_env_set_filenames (&env, 0, -1);
else
{
im_env_set_input_blob (&env, 0);
im_env_set_blob_ext (&env, (is_key_needed ? 3 : 2), -1);
}
im_read (&env);
MagickResetIterator(env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
switch (op)
{
case 'A': strg_value = MagickGetImageAttribute (env.ime_magick_wand, key); break;
case 'F': strg_value = MagickGetImageFormat (env.ime_magick_wand); break;
case 'I': strg_value = MagickIdentifyImage (env.ime_magick_wand); break;
case 'W': ul_value = MagickGetImageWidth (env.ime_magick_wand); break;
case 'H': ul_value = MagickGetImageHeight (env.ime_magick_wand); break;
case 'D': ul_value = MagickGetImageDepth (env.ime_magick_wand); break;
case '2':
ul_value = MagickGetImageWidth (env.ime_magick_wand);
if (ul_value)
{
dk_free_tree (res);
res = dk_alloc_box (2 * sizeof (caddr_t), DV_ARRAY_OF_POINTER);
((caddr_t *)res)[0] = box_num (ul_value);
((caddr_t *)res)[1] = box_num (MagickGetImageHeight (env.ime_magick_wand));
}
break;
}
}
if (is_string_res)
{
if (strg_value)
{
res = box_dv_short_string (strg_value);
MagickRelinquishMemory (strg_value);
}
}
else if (!is_list_res)
{
if (ul_value)
res = box_num (ul_value);
}
if (NULL == res)
res = NEW_DB_NULL;
im_leave (&env);
return res;
}
dk_session_t *
smtp_connect (char * host1, caddr_t * err_ret, caddr_t sender, caddr_t recipient, caddr_t msg_body)
{
volatile int rc, inx, len, addr, at;
dk_session_t * volatile ses = dk_session_allocate (SESCLASS_TCPIP);
caddr_t cmd = NULL;
char resp [1024];
char tmp [1024], *ptmp;
char c;
caddr_t volatile hf = NULL, host;
if (!strchr (host1, ':'))
{
host = dk_alloc_box (strlen (host1) + 4, DV_SHORT_STRING);
strcpy_box_ck (host, host1);
strcat_box_ck (host, ":25");
}
else
{
host = box_dv_short_string (host1);
}
rc = session_set_address (ses->dks_session, host);
dk_free_box (host); host = NULL;
if (SER_SUCC != rc)
{
PrpcSessionFree (ses);
*err_ret = srv_make_new_error ("2E000", "SM002", "Cannot resolve host in smtp_send");
return NULL;
}
rc = session_connect (ses->dks_session);
if (SER_SUCC != rc)
{
if (rc != SER_NOREC)
session_disconnect (ses->dks_session);
PrpcSessionFree (ses);
*err_ret = srv_make_new_error ("08001", "SM003", "Cannot connect in smtp_send");
return NULL;
}
cmd = dk_alloc_box (MAX (MAX (box_length(sender), box_length(recipient)), 1000) + 24, DV_LONG_STRING);
/* get initial line */
IS_OK_GO (ses, resp, rc, RESP_OK)
/* send HELO */
if (gethostname (tmp, sizeof (tmp)))
strcpy_ck (tmp, "localhost");
snprintf (cmd, box_length (cmd), "HELO %s\r\n", tmp);
/*WRITE_CMD (ses, rc, "HELO virtuoso.mail\r\n");*/
WRITE_CMD (ses, rc, cmd);
IS_OK_GO (ses, resp, rc, RESP_OK)
/* send SENDER */
len = box_length (sender);
ptmp = tmp;
addr = -1;
at = 0;
for (inx = 0; inx < len; inx++)
{
c = sender [inx];
if (c == '<')
addr = 1;
else if (c == '>' && addr == 1)
addr = 2;
else if (c == '>' && addr == -1)
{
strcpy_ck (resp, "Unbalanced <...> in sender e-mail address.");
goto error_end;
}
else if (c == '@')
at = 1;
if (((ptmp - tmp) < sizeof(tmp)) && (addr == 1 || addr == 2))
*ptmp++ = c;
else if ((ptmp - tmp) >= sizeof(tmp))
{
strcpy_ck (resp, "Sender\'s e-mail address is too long.");
goto error_end;
}
if (addr == 2)
{
*ptmp = 0;
snprintf (cmd, box_length (cmd), "MAIL FROM: %s\r\n", tmp);
WRITE_CMD (ses, rc, cmd);
IS_OK_GO (ses, resp, rc, RESP_OK)
break;
}
}
