caddr_t
bif_string_time (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t str = bif_string_or_wide_or_null_arg (qst, args, 0, "stringtime");
caddr_t res;
char temp[100];
char *txt;
caddr_t err_msg = NULL;
if (!str)
sqlr_new_error ("22002", "DT009", "Nulls not allowed as parameters to stringtime");
if (DV_WIDESTRINGP (str))
{
box_wide_string_as_narrow (str, temp, sizeof (temp), QST_CHARSET (qst));
txt = temp;
}
else
txt = str;
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
odbc_string_to_time_dt (txt, res, &err_msg);
if (NULL != err_msg)
{
caddr_t err = srv_make_new_error ("22007", "DT010", "Can't convert '%s' to time : %s", str, err_msg);
dk_free_box (err_msg);
dk_free_box (res);
sqlr_resignal (err);
}
return res;
}
caddr_t
box_narrow_string_as_wide (unsigned char *str, caddr_t wide, long max_len, wcharset_t *charset, caddr_t * err_ret, int isbox)
{
long i, len = (long)(isbox ? (box_length ((box_t) str) - 1) : strlen((const char *) str));
wchar_t *box;
size_t wide_len;
if (!charset)
{
client_connection_t *cli = GET_IMMEDIATE_CLIENT_OR_NULL;
if (cli)
charset = cli->cli_charset;
}
if (!charset)
charset = default_charset;
if (max_len > 0 && len > max_len)
len = max_len;
/* if (len == 0)
return NULL; - explicit bug */
wide_len = (len + 1) * sizeof(wchar_t);
if (wide_len > MAX_READ_STRING)
{
if (err_ret)
*err_ret = srv_make_new_error ("22023", "SR578", "The expected result length of wide string is too large");
return NULL;
}
box = (wchar_t *) (wide ? wide : dk_alloc_box_zero (wide_len, DV_WIDE));
for (i = 0; i < len; i++)
box[i] = CHAR_TO_WCHAR(str[i], charset);
box[len] = L'\0';
return ((caddr_t) box);
}
static caddr_t
bif_extract (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t unit = bif_string_arg (qst, args, 0, "extract");
caddr_t dt = bif_date_arg (qst, args, 1, "extract");
TIMESTAMP_STRUCT ts;
dt_to_timestamp_struct (dt, &ts);
if (!stricmp (unit, "SECOND"))
return box_num (ts.second);
else if (!stricmp (unit, "MINUTE"))
return box_num (ts.minute);
else if (!stricmp (unit, "HOUR"))
return box_num (ts.hour);
else if (!stricmp (unit, "DAY"))
return box_num (ts.day);
else if (!stricmp (unit, "MONTH"))
return box_num (ts.month);
else if (!stricmp (unit, "YEAR"))
return box_num (ts.year);
else
{
*err_ret = srv_make_new_error ("22015", "DT005", "Bad interval in extract.");
return NULL;
}
}
caddr_t
arithm_dt_add (ccaddr_t box1, ccaddr_t box2, caddr_t *err_ret)
{
dtp_t dtp1 = DV_TYPE_OF (box1), dtp2 = DV_TYPE_OF (box2);
if ((DV_DATETIME == dtp1) && ((DV_LONG_INT == dtp2) || (DV_DOUBLE_FLOAT == dtp2) || (DV_NUMERIC == dtp2)))
{
caddr_t res = arithm_dt_add_num (box1, box2, 0, err_ret);
if (NULL != err_ret)
return res;
if (NULL == res)
goto generic_err;
return res;
}
if ((DV_DATETIME == dtp2) && ((DV_LONG_INT == dtp1) || (DV_DOUBLE_FLOAT == dtp1) || (DV_NUMERIC == dtp1)))
{
caddr_t res = arithm_dt_add_num (box2, box1, 0, err_ret);
if (NULL != err_ret)
return res;
if (NULL == res)
goto generic_err;
return res;
}
generic_err:
err_ret[0] = srv_make_new_error ("22003", "SR087", "Wrong arguments for datetime arithmetic, can not add values of type %d (%s) and type %d (%s).",
dtp1, dv_type_title (dtp1), dtp2, dv_type_title (dtp2) );
return NULL;
}
caddr_t
arithm_dt_subtract (ccaddr_t box1, ccaddr_t box2, caddr_t *err_ret)
{
dtp_t dtp1 = DV_TYPE_OF (box1), dtp2 = DV_TYPE_OF (box2);
if ((DV_DATETIME == dtp1) && (DV_DATETIME == dtp2))
{
boxint s1 = DT_CAST_TO_TOTAL_SECONDS(box1);
boxint s2 = DT_CAST_TO_TOTAL_SECONDS(box2);
int frac1 = DT_FRACTION(box1);
int frac2 = DT_FRACTION(box2);
if (frac1 == frac2)
return box_num (s1 - s2);
else
{
numeric_t res = numeric_allocate ();
numeric_from_int64 (res, ((s1 - s2) * 1000000000L) + (frac1 - frac2));
res->n_len -= 9;
res->n_scale += 9;
return (caddr_t)res;
}
}
if ((DV_DATETIME == dtp1) && ((DV_LONG_INT == dtp2) || (DV_DOUBLE_FLOAT == dtp2) || (DV_NUMERIC == dtp2)))
{
caddr_t res = arithm_dt_add_num (box1, box2, 1, err_ret);
if (NULL != err_ret)
return res;
if (NULL == res)
goto generic_err;
return res;
}
generic_err:
err_ret[0] = srv_make_new_error ("22003", "SR087", "Wrong arguments for datetime arithmetic, can not subtract value of type %d (%s) from value type %d (%s).",
dtp2, dv_type_title (dtp2), dtp1, dv_type_title (dtp1) );
return NULL;
}
static caddr_t
java_vm_attach (JNIEnv ** env)
{
caddr_t err = NULL;
mutex_enter (java_vm_mutex);
*env = NULL;
if (!java_vm)
{
err = java_vm_create (env);
if (err)
{
mutex_leave (java_vm_mutex);
return err;
}
}
else
{
if (JNI_OK != (*java_vm)->GetEnv (java_vm, (void **) env, JNI_VERSION_1_2))
{
if (0 > (*java_vm)->AttachCurrentThread (java_vm, (void **) env,
NULL))
{
err =
srv_make_new_error ("42000", "JV003",
"Can't attach to the java VM");
mutex_leave (java_vm_mutex);
return err;
}
}
}
mutex_leave (java_vm_mutex);
return err;
}
static caddr_t
java_vm_create (JNIEnv ** java_vm_env)
{
JavaVMInitArgs vm_args;
JavaVMOption options[5];
jint res;
caddr_t classpath_opt = NULL;
int inx;
char *classpath = NULL;
if (!classpath)
{
classpath=getenv ("CLASSPATH");
}
if (!classpath)
{
classpath= ".";
}
classpath_opt = dk_alloc_box (strlen (classpath) + 20, DV_SHORT_STRING);
sprintf (classpath_opt, "-Djava.class.path=%s", classpath);
options[0].optionString = classpath_opt;
vm_args.nOptions = 1;
vm_args.version = JNI_VERSION_1_2;
vm_args.options = options;
vm_args.ignoreUnrecognized = JNI_FALSE;
res = JNI_CreateJavaVM (&java_vm, (void **) java_vm_env, &vm_args);
if (res < 0)
return srv_make_new_error ("42000", "JV002", "Can't create the Java VM");
else
return NULL;
}
void
row_print_wide (caddr_t thing, dk_session_t * ses, dbe_column_t * col,
caddr_t * err_ret, dtp_t dtp, wcharset_t * wcharset)
{
switch (dtp)
{
case DV_STRING:
if (0 > print_narrow_string_as_wide (ses, (unsigned char *) thing, wcharset))
{
caddr_t err = NULL;
err = srv_make_new_error ("22005", "IN009",
"Bad value for wide string column %s, dtp = %d.",
col->col_name, dtp);
if (err_ret)
*err_ret = err;
else
sqlr_resignal (err);
return;
}
break;
case DV_WIDE:
wide_serialize (thing, ses);
break;
default:
{
caddr_t err = NULL;
err = srv_make_new_error ("22005", "IN011",
"Bad value for wide string column %s, type=%s.", col->col_name, dv_type_title (dtp));
if (err_ret)
*err_ret = err;
else
sqlr_resignal (err);
}
break;
}
}
void
im_leave_with_error (im_env_t *env, const char *code, const char *virt_code, const char *string, ...)
{
static char temp[2000];
va_list lst;
caddr_t err;
va_start (lst, string);
vsnprintf (temp, sizeof (temp), string, lst);
va_end (lst);
temp[sizeof(temp)-1] = '\0';
err = srv_make_new_error (code, virt_code, "Function \"%s\"(): %.2000s", env->ime_bifname, temp);
im_dbg_printf (("IM %p: an error will be signalled: Function \"%s\"(): %.2000s\n", env, env->ime_bifname, temp));
im_leave (env);
sqlr_resignal (err);
}
caddr_t
string_to_time_dt_box (char * str)
{
caddr_t res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
caddr_t err_msg = NULL;
odbc_string_to_time_dt (str, res, &err_msg);
if (NULL != err_msg)
{
caddr_t err = srv_make_new_error ("22007", "DT011", "Cannot convert %s to time : %s", str, err_msg);
dk_free_box (err_msg);
dk_free_box (res);
sqlr_resignal (err);
}
return res;
}
static caddr_t
java_vm_detach (void)
{
jint rc;
mutex_enter (java_vm_mutex);
rc = (*java_vm)->DetachCurrentThread (java_vm);
mutex_leave (java_vm_mutex);
if (rc < 0)
return srv_make_new_error ("42000", "JV004",
"Can't dettach from the java VM");
else
{
log_debug ("Thread %p detached from the Java VM", thread_current());
return NULL;
}
}
void
virt_mono_throw_unhandled_exception (MonoObject *exc)
{
caddr_t err;
char *message = (char *) "";
const char *name = (const char *) "";
MonoString *str;
MonoMethod *method;
MonoClass *klass;
gboolean free_message = FALSE;
gint i;
if (mono_object_isinst (exc, mono_get_exception_class ()))
{
klass = mono_object_get_class (exc);
method = NULL;
while (klass && method == NULL)
{
gpointer m_iter = NULL;
for (method = mono_class_get_methods (klass, &m_iter); method != NULL;
method = mono_class_get_methods (klass, &m_iter))
{
MonoMethodSignature *sig = mono_method_signature (method);
guint32 flags = 0;
const char *name = mono_method_get_name (method);
mono_method_get_flags (method, &flags);
if (!strcmp ("ToString", name) &&
sig->param_count == 0
#ifdef OLD_KIT_1_1_5
&& (flags & METHOD_ATTRIBUTE_VIRTUAL)
&& (flags & METHOD_ATTRIBUTE_PUBLIC)
#endif
)
{
break;
}
method = NULL;
}
if (method == NULL)
klass = mono_class_get_parent (klass);
}
g_assert (method);
str = (MonoString *) mono_runtime_invoke (method, exc, NULL, NULL);
if (str) {
message = mono_string_to_utf8 (str);
free_message = TRUE;
name = mono_class_get_name (klass);
}
}
/*
* g_printerr ("\nUnhandled Exception: %s.%s: %s\n", exc->vtable->klass->name_space,
* exc->vtable->klass->name, message);
*/
g_printerr ("\nUnhandled Exception: %s\n", message);
err = srv_make_new_error ("42000", "MN001", "Unhandled Mono Exception [%.200s]: %.200s",
name, message);
if (free_message)
g_free (message);
sqlr_resignal (err);
}
static caddr_t
sa_to_dk (MonoArray *mono_list, int ofs, int mode, void *udt)
{
guint32 ret_type;
int clr_object = 0;
MonoObject *type, *value;
caddr_t ret = NULL;
MonoClass *cls;
int len = mono_array_length (mono_list), inx;
dk_set_t ret_set = NULL;
type = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 0);
ret_type = *(guint32 *)((char *)type + sizeof (MonoObject));
if (!ret_type)
{
char *error_text;
caddr_t err = NULL;
value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 1);
error_text = mono_string_to_utf8 ((MonoString *)value);
if (error_text)
err = srv_make_new_error ("42000", "MN002", "Mono error : %.200s",
mono_class_get_name (mono_object_get_class (value)), error_text);
else
err = srv_make_new_error ("42000", "MN003", "Unknown mono error");
g_free (error_text);
sqlr_resignal (err);
}
/* get type of object */
clr_object = 0;
if (ret_type == 5 || ret_type == 6)
clr_object = 1;
for (inx = 1; inx < len; inx++)
{
value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + inx);
if (value)
{
cls = mono_object_get_class (value);
if (cls == mono_get_int32_class ())
{
gint32 v = *(gint32 *)((char *)value + sizeof (MonoObject));
if (clr_object)
{
void * what_udt;
if (mode)
{
/*add_id (v);*/
ret = box_num (v);
}
else
{
what_udt = udt_find_class_for_clr_instance (v, udt);
if (what_udt)
{
/*add_id (v);*/
ret = cpp_udt_clr_instance_allocate (v, what_udt);
}
else
{
sqlr_new_error ("22023", "MN005", "Can't map Mono result to PL type");
}
}
}
else
ret = box_num (v);
}
else if (cls == mono_get_uint32_class())
ret = box_num (*(guint32 *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_single_class ())
ret = box_float (*(float *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_double_class ())
ret = box_double (*(double *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_boolean_class ())
ret = box_num (*(guint8 *)((guint8 *)value + sizeof (MonoObject)));
else if (cls == mono_get_string_class ())
{
char *utf8 = mono_string_to_utf8 ((MonoString *)value);
ret = box_utf8_as_wide_char (utf8, NULL, strlen (utf8), 0, DV_WIDE);
g_free (utf8);
}
else
{
const char *name = mono_class_get_name (cls);
sqlr_new_error ("22023", "MN006", "Can't map CLR result of type (%s) to PL type",
name ? name : "<unknown>");
}
}
else
ret = NULL;
if (ret_type != 3 && ret_type != 4 && ret_type != 5)
return ret;
else
dk_set_push (&ret_set, ret);
}
return list_to_array (dk_set_nreverse (ret_set));
}
shuric_t *shuric_load (shuric_vtable_t *vt, caddr_t uri, caddr_t ts, caddr_t uri_text_content, shuric_t *loaded_by, struct query_instance_s *qi, void *env, caddr_t *err_ret )
{
caddr_t str = NULL;
shuric_t ** cached_shuric_ptr;
shuric_t *new_cached_shuric = NULL, *old_cached_shuric = NULL;
shuric_t * new_shuric = NULL;
shuric_t * res = NULL; /* = NULL to keep compiler happy */
dk_set_t obsoletes = NULL;
dbg_printf (("shuric_load started (\"%s\", \"%s\", \"%s\" @ %p)\n",
vt->shuric_type_title, uri,
loaded_by ? loaded_by->shuric_uri : "", loaded_by ));
if (NULL != err_ret[0])
return NULL;
if (NULL != uri)
{
if (DV_STRING != DV_TYPE_OF (uri))
{
err_ret[0] = srv_make_new_error ("39000", "FA041", "A URI of a shareable XSLT/XQuery resource has invalid data type.");
goto cleanup;
}
if (box_length (uri) > MAX_SHURIC_URI_LENGTH)
{
err_ret[0] = srv_make_new_error ("39000", "FA042", "An abnormally long string is passed as URI of a shareable XSLT/XQuery resource.");
goto cleanup;
}
}
if (NULL != uri)
{
if (NULL != loaded_by)
{
shuric_t *old_inc = shuric_scan_relations (loaded_by, uri, SHURIC_SCAN_INCLUDED_BY | SHURIC_SCAN_IMPORTED_BY);
if (old_inc != NULL)
{
char impuri[300];
if (NULL != loaded_by->shuric_uri)
strcpy (impuri, "(temporary resource with no URI)");
else
{
strcpy_ck (impuri, loaded_by->shuric_uri);
}
shuric_release (old_inc);
err_ret[0] = srv_make_new_error ("39000", "FA048", "Cyclic references: '%.300s' refers to his ancestor '%.300s' as to child resource", impuri, uri);
}
}
mutex_enter (shuric_mtx);
cached_shuric_ptr = (shuric_t **) id_hash_get (shuric_global_hashtable, (caddr_t) &uri);
old_cached_shuric = ((NULL == cached_shuric_ptr) ? NULL : cached_shuric_ptr[0]);
if (NULL != old_cached_shuric)
old_cached_shuric->shuric_ref_count++; /* Temporary lock to keep the pointer valid. */
mutex_leave (shuric_mtx);
if ((NULL != old_cached_shuric) && (old_cached_shuric->_ != vt))
{
err_ret[0] = srv_make_new_error ("39000", "FA046", "Server uses the content of URI '%.200s' as '%.30s' and can not load it as '%.30s'",
uri, old_cached_shuric->_->shuric_type_title, vt->shuric_type_title );
goto cleanup;
}
}
if (NULL == uri_text_content)
{
QR_RESET_CTX
{
str = vt->shuric_uri_to_text (uri, qi, env, err_ret);
}
QR_RESET_CODE
{
du_thread_t *self = THREAD_CURRENT_THREAD;
err_ret[0] = thr_get_error_code (self);
thr_set_error_code (self, NULL);
}
END_QR_RESET;
}
caddr_t
arithm_dt_add_num (ccaddr_t box1, ccaddr_t box2, int subtraction, caddr_t *err_ret)
{
int dt_type = DT_DT_TYPE (box1);
dtp_t dtp2 = DV_TYPE_OF (box2);
boxint whole_seconds = 0;
boxint nanoseconds = 0;
TIMESTAMP_STRUCT ts;
caddr_t res;
switch (dtp2)
{
case DV_LONG_INT:
whole_seconds = unbox (box2);
break;
case DV_DOUBLE_FLOAT:
{
double n = unbox_double (box2);
double rest;
whole_seconds = (n >= 0.0) ? floor(n + 0.5) : ceil(n - 0.5);
rest = n - whole_seconds;
if (abs(rest/n) > (3 * DBL_EPSILON))
nanoseconds = (n - whole_seconds) * 1000000000L;
break;
}
case DV_NUMERIC:
{
numeric_t n = (numeric_t)box2;
if (NUMERIC_STS_SUCCESS != numeric_to_int64 (n, &whole_seconds))
{
err_ret[0] = srv_make_new_error ("22003", "SR087", "Wrong arguments for datetime arithmetic: decimal is out of range.");
return NULL;
}
if (n->n_scale > 0)
{
char *nptr = n->n_value + n->n_len;
int ctr;
int mult = 1;
for (ctr = 9; ctr > n->n_scale; ctr--) mult *= 10;
while (ctr--)
{
nanoseconds += mult * nptr[ctr];
mult *= 10;
}
}
break;
}
default:
return NULL;
}
DT_AUDIT_FIELDS (dt);
dt_to_GMTimestamp_struct (box1, &ts);
ts_add (&ts, (subtraction ? -whole_seconds : whole_seconds), "second");
if (nanoseconds)
ts_add (&ts, (subtraction ? -nanoseconds : nanoseconds), "nanosecond");
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
GMTimestamp_struct_to_dt (&ts, res);
DT_SET_TZ (res, DT_TZ (box1));
if ((DT_TYPE_DATE == dt_type) && (0 == (((whole_seconds * 1000000000L) + nanoseconds) % (SPERDAY * 1000000000L))))
DT_SET_DT_TYPE (res, dt_type);
DT_AUDIT_FIELDS (dt);
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;
}
}
