void
trset_start (caddr_t * qst)
{
state_slot_t sample;
state_slot_t **sbox;
caddr_t err;
caddr_t buf;
buf = dk_alloc_box (REPORT_BUF_MAX, DV_LONG_STRING);
buf[0] = 0;
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_BUFFER, buf);
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_PTR, buf);
SET_THR_ATTR (THREAD_CURRENT_THREAD, TA_REPORT_QST, qst);
sbox = (state_slot_t **) dk_alloc_box (sizeof (caddr_t), DV_ARRAY_OF_POINTER);
memset (&sample, 0, sizeof (sample));
sbox[0] = &sample;
sample.ssl_name = box_dv_uname_string ("REPORT");
sample.ssl_type = SSL_COLUMN;
sample.ssl_dtp = DV_SHORT_STRING;
sample.ssl_prec = REPORT_BUF_MAX;
bif_result_names_impl (qst, &err, sbox, QT_PROC_CALL);
dk_free_box ((caddr_t) sbox);
dk_free_box (sample.ssl_name);
}
caddr_t *
set_pos_param_row (cli_stmt_t * stmt, int nth)
{
int btype = stmt->stmt_bind_type;
int n_cols = BOX_ELEMENTS (stmt->stmt_compilation->sc_columns);
int iparam = 0;
caddr_t *row = (caddr_t *) dk_alloc_box_zero (n_cols * sizeof (caddr_t),
DV_ARRAY_OF_POINTER);
col_binding_t *cb = stmt->stmt_cols;
for (iparam = 0; iparam < n_cols; iparam++)
{
if (cb && cb->cb_place)
{
int c_type = cb->cb_c_type;
char *place = cb->cb_place;
SQLLEN *length = cb->cb_length;
int rebind_offset = stmt->stmt_imp_row_descriptor ?
(stmt->stmt_imp_row_descriptor->d_bind_offset_ptr ? *(stmt->stmt_imp_row_descriptor->d_bind_offset_ptr) : 0) : 0;
place += btype == 0 ? nth * sqlc_sizeof (c_type, cb->cb_max_length) : nth * btype;
place += rebind_offset;
if (length)
{
*((char **) &length) += btype == 0 ? nth * sizeof (SDWORD) : btype * nth;
*((char **) &length) += rebind_offset;
}
if (length && SQL_IGNORE == *length)
row[iparam] = (dk_alloc_box (0, DV_IGNORE));
else
{
caddr_t v = buffer_to_dv (place, length, c_type, c_type, BHID (nth, iparam + 1), NULL, CON_IS_INPROCESS (stmt->stmt_connection));
row[iparam] = v;
if (IS_BOX_POINTER (v) && DV_DAE == box_tag (v))
dk_set_push (&stmt->stmt_dae, &row[iparam]);
}
/* never a BLOB handle, since c_type never == SQL_ONGxx */
}
else
row[iparam] = dk_alloc_box (0, DV_IGNORE);
if (cb)
cb = cb->cb_next;
}
return row;
}
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;
}
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;
}
unsigned long
mts_prepare_set_log (tp_message_t * mm)
{
ITransactionEnlistmentAsync *mts_enlistment =
(ITransactionEnlistmentAsync *) mm->mm_resource;
IPrepareInfo *info = 0;
unsigned long sz = 0;
dbg_printf (("mts_prepare_set_log.."));
if (SUCCEEDED (mts_enlistment->QueryInterface (IID_IPrepareInfo,
(void **) &info))
&& (SUCCEEDED (info->GetPrepareInfoSize (&sz))))
{
box_t info_box = dk_alloc_box (sz, DV_BIN);
if (SUCCEEDED (info->GetPrepareInfo ((BYTE *) info_box)))
{
mm->mm_trx->lt_2pc._2pc_log = info_box;
dbg_printf ((".. success\n"));
}
else
dk_free_box (info_box);
}
if (info)
info->Release ();
return 0;
}
static caddr_t
bif_plugin_sample (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
caddr_t res = dk_alloc_box (strlen (PLAIN_PLUGIN_TYPE) + 1, DV_STRING);
strcpy (res, PLAIN_PLUGIN_TYPE);
return res;
}
caddr_t
bif_dateadd (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t res;
caddr_t part = bif_string_arg (qst, args, 0, "dateadd");
boxint n = bif_long_arg (qst, args, 1, "dateadd");
caddr_t dt = bif_date_arg (qst, args, 2, "dateadd");
TIMESTAMP_STRUCT ts;
int dt_type = DT_DT_TYPE (dt);
int year_or_month_tz_tweak = (((!strcmp ("year", part)) || (!strcmp ("month", part))) ? DT_TZ (dt) : 0);
DT_AUDIT_FIELDS (dt);
dt_to_GMTimestamp_struct (dt, &ts);
if (year_or_month_tz_tweak)
ts_add (&ts, year_or_month_tz_tweak, "minute");
ts_add (&ts, n, part);
if (year_or_month_tz_tweak)
ts_add (&ts, -year_or_month_tz_tweak, "minute");
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
GMTimestamp_struct_to_dt (&ts, res);
DT_SET_TZ (res, DT_TZ (dt));
if (DT_TYPE_DATE == dt_type
&& (0 == stricmp (part, "year") || 0 == stricmp (part, "month") || 0 == stricmp (part, "day")))
DT_SET_DT_TYPE (res, dt_type);
DT_AUDIT_FIELDS (dt);
return res;
}
caddr_t
box_wide_string_as_narrow (caddr_t _str, caddr_t narrow, long max_len, wcharset_t *charset)
{
wchar_t *str = (wchar_t *) _str;
long len = box_length (str) / sizeof (wchar_t) - 1, i;
unsigned char *box;
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)
{
if (narrow) narrow[0] = 0;
return box_dv_short_string("");
} in case if not null narrow - leak */
box = (unsigned char *) (narrow ? narrow : dk_alloc_box (len + 1, DV_LONG_STRING));
for (i = 0; i < len && str[i]; i++)
box[i] = WCHAR_TO_CHAR(str[i], charset);
box[len] = 0;
return ((caddr_t) box);
}
caddr_t
im_write (im_env_t *env)
{
if (env->ime_output_filename)
{
env->ime_status = MagickWriteImages (env->ime_magick_wand, env->ime_output_filename, MagickTrue);
if (env->ime_status == MagickFalse)
im_leave_with_error (env, "22023", "IM001", "Cannot write to file \"%.1000s\"", env->ime_output_filename);
return NULL;
}
else
{
size_t length = 0;
caddr_t image_blob = MagickGetImagesBlob (env->ime_magick_wand, &length);
caddr_t res;
if (length != 0)
{
res = dk_alloc_box (length, DV_BIN);
memcpy (res, image_blob, length);
MagickRelinquishMemory (image_blob);
}
else
res = NEW_DB_NULL;
return res;
}
}
int
sql_ext_fetch_fwd (SQLHSTMT hstmt, SQLULEN * pcrow, SQLUSMALLINT * rgfRowStatus)
{
int rc = 0;
int row_count = 0;
STMT (stmt, hstmt);
int inx;
SQLULEN rssz = stmt->stmt_rowset_size;
dk_free_tree ((box_t) stmt->stmt_rowset);
stmt->stmt_current_row = NULL;
stmt->stmt_rowset = (caddr_t **) dk_alloc_box (rssz * sizeof (caddr_t), DV_ARRAY_OF_POINTER);
memset (stmt->stmt_rowset, 0, rssz * sizeof (caddr_t));
for (inx = 0; inx < rssz; inx++)
{
stmt->stmt_fwd_fetch_irow = inx;
stmt->stmt_current_of = stmt->stmt_fetch_current_of;
rc = virtodbc__SQLFetch (hstmt, 1);
stmt->stmt_fetch_current_of = stmt->stmt_current_of;
stmt->stmt_fwd_fetch_irow = 0;
if (rc == SQL_ERROR)
break;
if (rc == SQL_NO_DATA_FOUND)
break;
row_count++;
stmt->stmt_rowset[inx] = stmt->stmt_current_row;
stmt->stmt_current_row = NULL;
if (rgfRowStatus)
rgfRowStatus[inx] = SQL_ROW_SUCCESS;
}
if (rgfRowStatus)
for (inx = inx; inx < rssz; inx++)
rgfRowStatus[inx] = SQL_ROW_NOROW;
if (row_count)
{
stmt_reset_getdata_status (stmt, stmt->stmt_rowset[0]);
stmt->stmt_current_row = stmt->stmt_rowset[0];
stmt->stmt_current_of = 0;
}
stmt->stmt_rowset_fill = row_count;
if (pcrow)
*pcrow = row_count;
stmt->stmt_row_status = rgfRowStatus;
if (row_count > 0 && SQL_NO_DATA_FOUND == rc)
rc = SQL_SUCCESS;
return rc;
}
caddr_t
box_wide_char_string (caddr_t data, size_t len, dtp_t dtp)
{
caddr_t res = dk_alloc_box (len + sizeof (wchar_t), dtp);
memcpy (res, data, len);
((wchar_t *)res)[len / sizeof (wchar_t)] = L'\x0';
return res;
}
caddr_t
bif_curdate (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
dt_now (res);
dt_date_round (res);
return res;
}
caddr_t
bif_curdatetime (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
long fract = 0;
caddr_t res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
dt_now (res);
if (args && BOX_ELEMENTS (args) > 0)
fract = (long) bif_long_arg (qst, args, 0, "curdatetime");
DT_SET_FRACTION (res, fract);
return res;
}
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;
}
caddr_t
mts_get_rmcookie ()
{
if (!local_rm)
{
return 0;
}
DOUBLE_LOCK (rmcookie, alloc_ret);
try
{
auto_interface < ITransactionImportWhereabouts > import_abouts;
HRESULT hr = DtcGetTransactionManager (0,
0,
__uuidof (ITransactionImportWhereabouts),
0,
0,
0,
(void **) &import_abouts.get ());
MTS_THROW_ASSERT (hr, "Get ITransactionImportWhereabouts");
hr = import_abouts->GetWhereaboutsSize (&local_rm->rmcookie_len);
MTS_THROW_ASSERT (hr, "GetTransactionImportWhereaboutsLen");
DWORD used;
auto_dkptr < BYTE >
whereabouts_aptr ((BYTE *) dk_alloc (sizeof (BYTE) *
local_rm->rmcookie_len));
hr = import_abouts->GetWhereabouts (local_rm->rmcookie_len,
whereabouts_aptr.get (), &used);
local_rm->rmcookie = whereabouts_aptr.release ();
}
catch (const mts_error & err)
{
RELEASE_OBJECT (local_rm);
err.dump ();
return 0;
}
RELEASE_OBJECT (local_rm);
alloc_ret:
caddr_t cookie = (caddr_t) dk_alloc_box (local_rm->rmcookie_len, DV_BIN);
memcpy (cookie, local_rm->rmcookie, local_rm->rmcookie_len);
return cookie;
};
caddr_t
bif_timestampadd (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t res;
ptrlong part = bif_long_arg (qst, args, 0, "timestampadd");
int n = (int) bif_long_arg (qst, args, 1, "timestampadd");
caddr_t dt = bif_date_arg (qst, args, 2, "timestampadd");
int saved_tz = DT_TZ (dt);
GMTIMESTAMP_STRUCT ts;
dt_to_GMTimestamp_struct (dt, &ts);
ts_add (&ts, n, interval_odbc_to_text (part, "timestampadd"));
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
GMTimestamp_struct_to_dt (&ts, res);
DT_SET_TZ (res, saved_tz);
return res;
}
static TCHAR *
virt_ansi_to_wide (char *in)
{
int len;
TCHAR *ret;
if (!in)
return NULL;
len = MultiByteToWideChar (CP_ACP, 0, in, -1, NULL, 0);
if (len == 0)
return NULL;
ret = (TCHAR *) dk_alloc_box (len * sizeof (TCHAR), DV_SHORT_STRING);
MultiByteToWideChar (CP_ACP, 0, in, -1, ret, len);
return ret;
}
static char *
virt_wide_to_ansi (TCHAR * in)
{
int len;
caddr_t ret;
if (!in)
return NULL;
len = WideCharToMultiByte (CP_ACP, 0, in, -1, NULL, 0, NULL, NULL);
if (len == 0)
return NULL;
ret = dk_alloc_box (len, DV_SHORT_STRING);
WideCharToMultiByte (CP_ACP, 0, in, -1, ret, len, NULL, NULL);
return ret;
}
caddr_t
box_utf8_string_as_narrow (ccaddr_t _str, caddr_t narrow, long max_len, wcharset_t *charset)
{
virt_mbstate_t state;
long len, inx;
const unsigned char *str = (const unsigned char *) _str, *src = (const unsigned char *) _str;
caddr_t box;
if (!charset)
{
client_connection_t *cli = GET_IMMEDIATE_CLIENT_OR_NULL;
if (cli)
charset = cli->cli_charset;
}
if (!charset)
charset = default_charset;
memset (&state, 0, sizeof (virt_mbstate_t));
len = (long) virt_mbsnrtowcs (NULL, (unsigned char **) &src, box_length (str), 0, &state);
if (max_len > 0 && len > max_len)
len = max_len;
if (len < 0) /* there was <= 0 - bug */
return NULL;
box = narrow ? narrow : dk_alloc_box (len + 1, DV_LONG_STRING);
for (inx = 0, src = str, memset (&state, 0, sizeof (virt_mbstate_t)); inx < len; inx++)
{
wchar_t wc;
long char_len = (long) virt_mbrtowc (&wc, src, (box_length (str)) - (long)((src - str)), &state);
if (char_len <= 0)
{
box[inx] = '?';
src++;
}
else
{
box[inx] = WCHAR_TO_CHAR (wc, charset);
src += char_len;
}
}
box[len] = 0;
return box;
}
/* equal to ARTM_BIN_FUNC (box_mod, %, numeric_modulo, 1) with some extensions */
caddr_t
box_mod (ccaddr_t box1, ccaddr_t box2, caddr_t * qst, state_slot_t * target)
{
NUMERIC_VAR (dn1);
NUMERIC_VAR (dn2);
dtp_t dtp1, dtp2, res_dtp;
retry_rdf_boxes:
NUM_TO_MEM (dn1, dtp1, box1);
NUM_TO_MEM (dn2, dtp2, box2);
if (dtp1 == DV_DB_NULL || dtp2 == DV_DB_NULL)
goto null_result; \
if (n_coerce ((caddr_t) & dn1, (caddr_t) & dn2,
dtp1, dtp2, &res_dtp))
{
switch (res_dtp)
{
case DV_LONG_INT:
if (0 == *(boxint *) &dn2)
sqlr_new_error ("22012", "SR088", "Division by 0.");
if (target)
return (qst_set_long (qst, target,
(*(boxint *) &dn1 % * (boxint *) &dn2)), (caddr_t) 0);
return (box_num (*(boxint *) &dn1 % * (boxint *) &dn2));
case DV_SINGLE_FLOAT:
if (0 == *(float *) &dn2)
sqlr_new_error ("22012", "SR089", "Division by 0.");
if (target)
return (qst_set_float (qst, target,
(float) fmod (*(float *) &dn1, * (float *) &dn2)), (caddr_t) 0);
return (box_float ((float) fmod (*(float *) &dn1, * (float *) &dn2)));
case DV_DOUBLE_FLOAT:
if (0 == *(double*) &dn2)
sqlr_new_error ("22012", "SR090", "Division by 0.");
if (target)
return (qst_set_double (qst, target, fmod (*(double*) &dn1, *(double*) &dn2)), (caddr_t) 0);
return (box_double (fmod (*(double*) &dn1, *(double*) &dn2)));
case DV_NUMERIC:
return (numeric_bin_op (numeric_modulo, (numeric_t) &dn1, (numeric_t) &dn2, qst, target));
}
}
else
{
if (dtp1 == DV_RDF || dtp2 == DV_RDF)
{
if (dtp1 == DV_RDF)
box1 = ((rdf_box_t *)(box1))->rb_box;
if (dtp2 == DV_RDF)
box2 = ((rdf_box_t *)(box2))->rb_box;
goto retry_rdf_boxes;
}
if (((query_instance_t *)qst)->qi_query->qr_no_cast_error)
goto null_result; /* see below */
sqlr_new_error ("22003", "SR087", "Non numeric arguments to arithmetic operation modulo");
}
null_result: \
if (target) \
{ \
qst_set_bin_string (qst, target, NULL, 0, DV_DB_NULL); \
return NULL; \
} \
return (dk_alloc_box (0, DV_DB_NULL)); \
}
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;
}
}
dk_set_t
bh_string_list_w (/* this was before 3.0: index_space_t * isp,*/ lock_trx_t * lt, blob_handle_t * bh, long get_chars, int omit, long blob_type)
{
/* take current page at current place and make string of
n bytes from the place and write to client */
caddr_t page_string;
dk_set_t string_list = NULL;
dp_addr_t start = bh->bh_current_page;
buffer_desc_t *buf = NULL;
long from_char = bh->bh_position;
long chars_filled = 0, chars_on_page;
virt_mbstate_t state;
wchar_t wpage[PAGE_SZ];
#if 0 /* this was */
it_cursor_t *tmp_itc = itc_create (isp, lt);
#else
it_cursor_t *tmp_itc = itc_create (NULL, lt);
itc_from_it (tmp_itc, bh->bh_it);
#endif
while (start)
{
long char_len, byte_len, next;
unsigned char *mbc;
uint32 timestamp;
int type;
memset (&state, 0, sizeof (state));
if (!page_wait_blob_access (tmp_itc, start, &buf, PA_READ, bh, 1))
break;
type = SHORT_REF (buf->bd_buffer + DP_FLAGS);
timestamp = LONG_REF (buf->bd_buffer + DP_BLOB_TS);
if ((DPF_BLOB != type) &&
(DPF_BLOB_DIR != type))
{
page_leave_outside_map (buf);
dbg_printf (("wrong blob type\n"));
return 0;
}
if ((bh->bh_timestamp != BH_ANY) && (timestamp != bh->bh_timestamp))
{
page_leave_outside_map (buf);
return BH_DIRTYREAD;
}
byte_len = LONG_REF (buf->bd_buffer + DP_BLOB_LEN);
mbc = buf->bd_buffer + DP_DATA;
char_len = (long) virt_mbsnrtowcs (wpage, &mbc, byte_len, PAGE_DATA_SZ, &state);
if (char_len < 0)
GPF_T1 ("bad UTF8 data in wide blob page");
chars_on_page = MIN (char_len - from_char, get_chars);
if (chars_on_page)
{
/* dbg_printf (("Read blob page %ld, %ld bytes.\n", start,
bytes_on_page)); */
if (!omit)
{
if (DK_MEM_RESERVE)
{
SET_DK_MEM_RESERVE_STATE (lt);
itc_bust_this_trx (tmp_itc, &buf, ITC_BUST_THROW);
}
page_string = dk_alloc_box ((chars_on_page + 1) * sizeof(wchar_t), DV_WIDE);
memcpy (page_string, wpage + from_char,
chars_on_page * sizeof (wchar_t));
((wchar_t *)page_string)[chars_on_page] = 0;
dk_set_push (&string_list, page_string);
}
chars_filled += chars_on_page;
get_chars -= chars_on_page;
from_char += chars_on_page;
}
next = LONG_REF (buf->bd_buffer + DP_OVERFLOW);
page_leave_outside_map (buf);
if (0 == get_chars)
{
bh->bh_position = from_char;
break;
}
bh->bh_current_page = next;
bh->bh_position = 0;
from_char = 0;
start = next;
}
itc_free (tmp_itc);
return (dk_set_nreverse (string_list));
}
RETCODE
stmt_process_rowset (cli_stmt_t * stmt, int ftype, SQLULEN * pcrow)
{
int is_error = 0;
int rc;
SQLULEN rssz = stmt->stmt_rowset_size;
int inx, nth;
if (stmt->stmt_rowset)
dk_free_tree ((box_t) stmt->stmt_rowset);
stmt->stmt_rowset = (caddr_t **) dk_alloc_box (rssz * sizeof (caddr_t), DV_ARRAY_OF_POINTER);
memset (stmt->stmt_rowset, 0, rssz * sizeof (caddr_t));
stmt->stmt_current_row = NULL;
for (nth = 0; nth < rssz; nth++)
{
rc = stmt_process_result (stmt, 1);
if (SQL_ERROR == rc)
{
is_error = 1;
break;
}
if (stmt->stmt_at_end)
break;
stmt->stmt_rowset[nth] = (caddr_t *) stmt->stmt_prefetch_row;
stmt->stmt_prefetch_row = NULL;
}
for (inx = 0; inx < nth; inx++)
{
int rstat = qa_to_row_stat ((int) (ptrlong) stmt->stmt_rowset[inx][0]);
stmt_set_columns (stmt, stmt->stmt_rowset[inx], inx);
if (stmt->stmt_row_status)
stmt->stmt_row_status[inx] = (SQLUSMALLINT) rstat;
}
if (pcrow)
*pcrow = nth;
if (stmt->stmt_row_status)
for (inx = nth; inx < rssz; inx++)
stmt->stmt_row_status[inx] = SQL_ROW_NOROW;
if (nth > 0)
{
stmt->stmt_current_row = stmt->stmt_rowset[0];
stmt->stmt_current_of = 0;
}
else
{
stmt->stmt_current_row = NULL;
stmt->stmt_current_of = -1;
}
stmt->stmt_rowset_fill = nth;
if (is_error)
return SQL_ERROR;
if (nth == 0)
return SQL_NO_DATA_FOUND;
return SQL_SUCCESS;
}
int /* Returns number of chars parsed. */
dt_scan_from_buffer (const char *buf, int mode, caddr_t *dt_ret, const char **err_msg_ret)
{
const char *tail = buf;
int fld_len, acc, ymd_found = 0, hms_found = 0, msec_factor;
TIMESTAMP_STRUCT ts;
memset (&ts, 0, sizeof (TIMESTAMP_STRUCT));
dt_ret[0] = NULL;
err_msg_ret[0] = NULL;
fld_len = 0; acc = 0; while (isdigit (tail[0]) && (4 > fld_len)) { acc = acc * 10 + (tail++)[0] - '0'; fld_len++; }
if ('-' == tail[0])
{ /* Date delimiter, let's parse date part */
if (((DT_PRINT_MODE_YMD | DT_PRINT_MODE_HMS) & mode) && !(DT_PRINT_MODE_YMD & mode))
{
err_msg_ret[0] = "Time field is expected but date field delimiter is found";
return 0;
}
if (4 != fld_len)
{
err_msg_ret[0] = "Year field should have 4 digits";
return 0;
}
ymd_found = 1;
ts.year = acc;
tail++;
fld_len = 0; acc = 0; while (isdigit (tail[0]) && (2 > fld_len)) { acc = acc * 10 + (tail++)[0] - '0'; fld_len++; }
if (2 != fld_len)
{
err_msg_ret[0] = "Month field should have 2 digits";
return 0;
}
if ('-' != tail[0])
{
err_msg_ret[0] = "Minus sign is expected after month";
return 0;
}
ts.month = acc;
tail++;
fld_len = 0; acc = 0; while (isdigit (tail[0]) && (2 > fld_len)) { acc = acc * 10 + (tail++)[0] - '0'; fld_len++; }
if (2 != fld_len)
{
err_msg_ret[0] = "Day of month field should have 2 digits";
return 0;
}
ts.day = acc;
if ('T' != tail[0])
goto scan_tz; /* see below */
tail++;
fld_len = 0; acc = 0; while (isdigit (tail[0]) && (2 > fld_len)) { acc = acc * 10 + (tail++)[0] - '0'; fld_len++; }
}
if (':' == tail[0])
{ /* Time delimiter, let's parse time part */
if (((DT_PRINT_MODE_YMD | DT_PRINT_MODE_HMS) & mode) && !(DT_PRINT_MODE_HMS & mode))
{
err_msg_ret[0] = "Date field is expected but time field delimiter is found";
return 0;
}
if (2 != fld_len)
{
err_msg_ret[0] = "Hour field should have 2 digits";
return 0;
}
hms_found = 1;
ts.hour = acc;
tail++;
fld_len = 0; acc = 0; while (isdigit (tail[0]) && (2 > fld_len)) { acc = acc * 10 + (tail++)[0] - '0'; fld_len++; }
if (2 != fld_len)
{
err_msg_ret[0] = "Minute field should have 2 digits";
return 0;
}
if (':' != tail[0])
{
err_msg_ret[0] = "Colon is expected after minute";
return 0;
}
ts.minute = acc;
tail++;
fld_len = 0; acc = 0; while (isdigit (tail[0]) && (2 > fld_len)) { acc = acc * 10 + (tail++)[0] - '0'; fld_len++; }
if (2 != fld_len)
{
err_msg_ret[0] = "Second field should have 2 digits";
return 0;
}
ts.second = acc;
if ('.' == tail[0])
{
tail++;
msec_factor = 1000000000;
acc = 0;
if (!isdigit (tail[0]))
{
err_msg_ret[0] = "Fraction of second is expected after decimal dot";
return 0;
}
do
{
if (msec_factor)
acc = acc * 10 + (tail[0] - '0');
tail++;
msec_factor /= 10;
} while (isdigit (tail[0]));
ts.fraction = acc * (msec_factor ? msec_factor : 1);
}
if ('Z' != tail[0] && strncmp (tail, " GMT", 4))
{
err_msg_ret[0] = "Colon or time zone is expected after minute";
return 0;
}
}
else
{
err_msg_ret[0] = "Generic syntax error in date/time";
return 0;
}
scan_tz:
/* Now HMS part is complete (or skipped) */
if ('Z' == tail[0])
tail++;
else if (!strncmp (tail, " GMT", 4))
tail += 4;
else
{
err_msg_ret[0] = "Generic syntax error in date/time";
return 0;
}
if ((DT_PRINT_MODE_YMD & mode) && !ymd_found)
{
err_msg_ret[0] = "Datetime expected but time-only string is found";
return 0;
}
if ((DT_PRINT_MODE_HMS & mode) && !hms_found)
{
err_msg_ret[0] = "Datetime expected but date-only string is found";
return 0;
}
dt_ret[0] = dk_alloc_box (DT_LENGTH, DV_DATETIME);
{
uint32 day;
day = date2num (ts.year, ts.month, ts.day);
DT_SET_DAY (dt_ret[0], day);
DT_SET_HOUR (dt_ret[0], ts.hour);
DT_SET_MINUTE (dt_ret[0], ts.minute);
DT_SET_SECOND (dt_ret[0], ts.second);
DT_SET_FRACTION (dt_ret[0], ts.fraction);
DT_SET_TZ (dt_ret[0], dt_local_tz);
}
SET_DT_TYPE_BY_DTP (dt_ret[0], (ymd_found ? (hms_found ? DV_DATETIME : DV_DATE) : DV_TIME));
return (tail - buf);
}
caddr_t bif_mediawiki_lexer_impl (caddr_t * qst, caddr_t * err, state_slot_t ** args, char *bifname, int run_lexer)
{
caddr_t rawtext = bif_string_arg (qst, args, 0, bifname);
caddr_t CLUSTER_arg = bif_string_arg (qst, args, 1, bifname);
caddr_t TOPIC = bif_string_arg (qst, args, 2, bifname);
caddr_t WIKINAME = bif_string_arg (qst, args, 3, bifname);
caddr_t *env = (caddr_t *)bif_arg (qst, args, 4, bifname);
int envlen = 0, envctr;
dk_session_t *pipe = NULL, *out = NULL;
caddr_t macroexpanded = NULL, res = NULL;
switch (DV_TYPE_OF ((caddr_t)env))
{
case DV_ARRAY_OF_POINTER:
envlen = BOX_ELEMENTS ((caddr_t)env);
if (envlen % 2)
sqlr_new_error ("22023", "WV001", "%s needs an array of even length or NULL argument 4", bifname);
for (envctr = 0; envctr < envlen; envctr++)
if (DV_STRING != DV_TYPE_OF (env[envctr]))
sqlr_new_error ("22023", "WV001", "%s needs an array of even length of strings or NULL argument 4", bifname);
break;
case DV_DB_NULL:
break;
default:
sqlr_new_error ("22023", "WV001", "%s needs an array or NULL as argument 4", bifname);
}
pipe = strses_allocate ();
mutex_enter (mediawiki_lexer_mutex);
mediawiki_env = dk_alloc_box ((8 + envlen) * sizeof (caddr_t), DV_ARRAY_OF_POINTER);
mediawiki_env[0] = "CLUSTER"; mediawiki_env[1] = mediawiki_CLUSTER = CLUSTER_arg;
mediawiki_env[2] = "TOPIC"; mediawiki_env[3] = mediawiki_TOPIC = TOPIC;
mediawiki_env[4] = "WIKINAME"; mediawiki_env[5] = mediawiki_WIKINAME = WIKINAME;
mediawiki_env[6] = "WIKIVERSION"; mediawiki_env[7] = mediawiki_WIKIVERSION;
for (envctr = 0; envctr < envlen; envctr++)
mediawiki_env[8+envctr] = env[envctr];
QR_RESET_CTX
{
mediamacyyrestart (NULL);
mediamacyylex_prepare (rawtext, pipe);
mediamacyylex ();
macroexpanded = strses_string (pipe);
if (run_lexer)
{
out = strses_allocate ();
mediawikiyyrestart (NULL);
mediawikiyylex_prepare (macroexpanded, out);
mediawikiyylex ();
}
}
QR_RESET_CODE
{
du_thread_t *self = THREAD_CURRENT_THREAD;
caddr_t err = thr_get_error_code (self);
dk_free_box (mediawiki_env); /* not dk_free_tree */
mutex_leave (mediawiki_lexer_mutex);
strses_free (pipe);
dk_free_box (macroexpanded);
if (run_lexer)
strses_free (out);
POP_QR_RESET;
sqlr_resignal (err);
}
END_QR_RESET;
dk_free_box (mediawiki_env); /* not dk_free_tree */
mutex_leave (mediawiki_lexer_mutex);
if (run_lexer)
{
res = strses_string (out);
strses_free (out);
strses_free (pipe);
dk_free_box (macroexpanded);
return res;
}
else
{
strses_free (pipe);
return macroexpanded;
}
}
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;
}
