int
main (int argc, char *argv[])
{
char str[1024];
char keystr[1024];
if (argc == 3)
{
strcpy_ck (keystr, argv[1]);
strcpy_ck (str, argv[2]);
}
else
{
printf ("Usage: ec2crypt <key> <string>\n");
exit (0);
}
printf ("key: %s\n", keystr);
printf ("string: %s\n", str);
printf ("keylen: %d\n", strlen (keystr));
printf ("stringlen: %d\n", strlen (str));
printf ("encrypted: %s\n", xx_encrypt (keystr, str));
return (0);
}
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;
}
void *
sch_name_to_object (dbe_schema_t *sc, sc_object_type type, const char *name, char *q_def, char *o_default,
int find_many)
{
void *obj;
char q[MAX_NAME_LEN];
char o[MAX_NAME_LEN];
char n[MAX_NAME_LEN];
char qn[2*MAX_NAME_LEN + 1];
q[0] = 0;
o[0] = 0;
n[0] = 0;
sch_split_name (q_def, name, q, o, n);
strcpy_ck (qn, q);
strcat_ck (qn, ".");
strcat_ck (qn, n);
obj = sch_name_to_object_sc (sc, type, o_default, o, qn, find_many);
if ((void *) -1L == obj)
return NULL;
return obj;
}
static SQLRETURN SQL_API
virtodbc__SQLDriverConnect (SQLHDBC hdbc,
HWND hwnd,
SQLTCHAR * szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLTCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT * pcbConnStrOutMax, SQLUSMALLINT fDriverCompletion)
{
char tempHostName[1024];
TCHAR cmd[2500];
short fPrompt;
TCHAR *connStr;
TCHAR *DSN;
char *UID;
char *PWD;
char *HOST;
char *szHost;
char *CHARSET;
char *DATABASE;
TCHAR *UIDW;
TCHAR *PWDW;
TCHAR *HOSTW;
TCHAR *CHARSETW;
TCHAR *ENCRYPTW;
TCHAR *SERVERCERTW;
TCHAR *FORCE_DMBS_NAMEW;
TCHAR *DAYLIGHTW;
TCHAR *ROUNDROBINW;
#ifdef _SSL
TCHAR *PWDCLEARW;
#endif
TCHAR *DATABASEW;
SQLRETURN rc;
CON (con, hdbc);
CfgData cfgdata[sizeof (attrs) / sizeof (CfgRecord)];
cli_dbg_printf (("DriverConnect(%p, ..., %d) called.\n", hdbc, fDriverCompletion));
memset (cfgdata, 0, sizeof (cfgdata));
mutex_enter (con->con_environment->env_mtx);
if ((szConnStrIn == NULL) || (!cbConnStrIn) || ((cbConnStrIn == SQL_NTS) && (!szConnStrIn[0])))
{
connStr = _tcsdup (_T (""));
}
else
StrCopyInW (&connStr, (TCHAR *) szConnStrIn, cbConnStrIn);
ParseOptions (cfgdata, NULL, 1);
PutConnectionOptions (cfgdata, con);
ParseOptions (cfgdata, connStr, 0);
#ifdef DEBUG
DumpOpts (connStr, cfgdata);
#endif
fPrompt = FALSE;
if (fDriverCompletion == SQL_DRIVER_COMPLETE || fDriverCompletion == SQL_DRIVER_COMPLETE_REQUIRED)
{
if (!cfgdata[oUID].data || !cfgdata[oUID].data[0]
|| cfgdata[oUID].data[0] == ' ' || !cfgdata[oPWD].data
|| !cfgdata[oPWD].data[0] || cfgdata[oPWD].data[0] == ' '
|| !cfgdata[oHOST].data || !cfgdata[oHOST].data[0] || cfgdata[oHOST].data[0] == ' ')
fPrompt = TRUE;
}
else if (fDriverCompletion == SQL_DRIVER_PROMPT)
{
fPrompt = TRUE;
}
if (fPrompt)
{
if ((rc = DriverConnectDialog ((void *) hwnd)) != SQL_SUCCESS)
{
ParseOptions (cfgdata, NULL, 1);
mutex_leave (con->con_environment->env_mtx);
return rc;
}
}
#ifdef _SSL
if (con->con_encrypt)
{
dk_free_box (con->con_encrypt);
}
ENCRYPTW = cfgdata[oENCRYPT].data && _tcslen (cfgdata[oENCRYPT].data) ? (cfgdata[oENCRYPT].data) : NULL;
con->con_encrypt = virt_wide_to_ansi (ENCRYPTW);
PWDCLEARW = cfgdata[oPWDCLEAR].data && _tcslen (cfgdata[oPWDCLEAR].data) ? (cfgdata[oPWDCLEAR].data) : NULL;
con->con_pwd_cleartext = PWDCLEARW ? _ttoi (PWDCLEARW) : 0;
SERVERCERTW = cfgdata[oSERVERCERT].data && _tcslen (cfgdata[oSERVERCERT].data) ? (cfgdata[oSERVERCERT].data) : NULL;
con->con_ca_list = virt_wide_to_ansi (SERVERCERTW);
#else
con->con_encrypt = NULL;
ENCRYPTW = NULL;
con->con_pwd_cleartext = 0;
SERVERCERTW = NULL;
con->con_ca_list = NULL;
con->con_pwd_cleartext = 0;
#endif
if (cfgdata[oROUNDROBIN].data && _tcslen (cfgdata[oROUNDROBIN].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oROUNDROBIN].data);
nst1 = toupper (*nst);
con->con_round_robin = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
if (cfgdata[oWideUTF16].data && _tcslen (cfgdata[oWideUTF16].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oWideUTF16].data);
nst1 = toupper (*nst);
con->con_wide_as_utf16 = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
FORCE_DMBS_NAMEW = cfgdata[oFORCE_DBMS_NAME].data && _tcslen (cfgdata[oFORCE_DBMS_NAME].data) ? cfgdata[oFORCE_DBMS_NAME].data : NULL;
if (FORCE_DMBS_NAMEW)
{
char *force_dbms_name = virt_wide_to_ansi (FORCE_DMBS_NAMEW);
strncpy (__virtodbc_dbms_name, force_dbms_name, sizeof (__virtodbc_dbms_name));
__virtodbc_dbms_name[sizeof (__virtodbc_dbms_name) - 1] = 0;
free_wide_buffer (force_dbms_name);
}
else
strcpy_ck (__virtodbc_dbms_name, PRODUCT_DBMS);
DSN = cfgdata[oDSN].data;
UIDW = cfgdata[oUID].data ? cfgdata[oUID].data : (TCHAR *) _T ("");
UID = virt_wide_to_ansi (UIDW);
PWDW = cfgdata[oPWD].data ? cfgdata[oPWD].data : (TCHAR *) _T ("");
PWD = virt_wide_to_ansi (PWDW);
HOSTW = cfgdata[oHOST].data ? cfgdata[oHOST].data : attrs[oHOST].defVal;
HOST = virt_wide_to_ansi (HOSTW);
DATABASEW = cfgdata[oDATABASE].data;
DATABASE = virt_wide_to_ansi (DATABASEW);
if (cfgdata[oCHARSET].data && _tcslen (cfgdata[oCHARSET].data))
{
char * cs = virt_wide_to_ansi (cfgdata[oCHARSET].data);
if (!strcmp (cs, "UTF-8"))
{
free (cfgdata[oCHARSET].data);
cfgdata[oCHARSET].data = NULL;
cfgdata[oCHARSET].supplied = FALSE;
con->con_string_is_utf8 = 1;
}
}
CHARSETW = (cfgdata[oCHARSET].data && _tcslen (cfgdata[oCHARSET].data)) ? cfgdata[oCHARSET].data : NULL;
CHARSET = con->con_charset_name = virt_wide_to_ansi (CHARSETW);
if (strchr (HOST, ':') == NULL && strchr(HOST,',') == NULL)
{
snprintf (tempHostName, sizeof (tempHostName), "%s:1111", HOST);
szHost = tempHostName;
}
else
szHost = HOST;
DAYLIGHTW = cfgdata[oDAYLIGHT].data && _tcslen (cfgdata[oDAYLIGHT].data) ? cfgdata[oDAYLIGHT].data : NULL;
if (DAYLIGHTW)
{
char *daylight = virt_wide_to_ansi (DAYLIGHTW);
isdts_mode = (toupper (*daylight) == 'Y');
free_wide_buffer (daylight);
}
if (cfgdata[oNoSystemTables].data && _tcslen (cfgdata[oNoSystemTables].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oNoSystemTables].data);
nst1 = toupper (*nst);
con->con_no_system_tables = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
if (cfgdata[oTreatViewsAsTables].data && _tcslen (cfgdata[oTreatViewsAsTables].data))
{
char *nst, nst1;
nst = virt_wide_to_ansi (cfgdata[oTreatViewsAsTables].data);
nst1 = toupper (*nst);
con->con_treat_views_as_tables = OPTION_TRUE (nst1) ? 1 : 0;
free_wide_buffer (nst);
}
#ifdef DEBUG
DumpOpts (connStr, cfgdata);
printf (_T ("CONNECT(%s,%s,%s)\n"), szHost, UID, PWD);
#endif
rc = internal_sql_connect (hdbc, (SQLCHAR *) szHost, SQL_NTS, (SQLCHAR *) UID, SQL_NTS, (SQLCHAR *) PWD, SQL_NTS);
if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
{
if (DATABASEW && _tcslen (DATABASEW) && _tcscmp (DATABASEW, DEFAULT_DATABASE_PER_USER))
rc = virtodbc__SQLSetConnectAttr (hdbc, SQL_CURRENT_QUALIFIER, DATABASE, SQL_NTS);
else
DATABASEW = NULL;
}
if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
{
if (cfgdata[oIsolationLevel].data && _tcslen (cfgdata[oIsolationLevel].data))
{
TCHAR *szValue = cfgdata[oIsolationLevel].data;
if (!_tcsicmp (szValue, _T ("Read Uncommitted")))
con->con_isolation = SQL_TXN_READ_UNCOMMITTED;
else if (!_tcsicmp (szValue, _T ("Read Committed")))
con->con_isolation = SQL_TXN_READ_COMMITTED;
else if (!_tcsicmp (szValue, _T ("Repeatable Read")))
con->con_isolation = SQL_TXN_REPEATABLE_READ;
else if (!_tcsicmp (szValue, _T ("Serializable")))
con->con_isolation = SQL_TXN_SERIALIZABLE;
}
}
if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
{
TCHAR *p = cmd;
if (cfgdata[oDRIVER].supplied && cfgdata[oDRIVER].data)
{
p = stpcpyw (p, _T ("DRIVER="));
p = stpcpyw (p, cfgdata[oDRIVER].data);
p = stpcpyw (p, _T (";SERVER=OpenLink"));
}
else if (DSN)
{
p = stpcpyw (p, _T ("DSN="));
p = stpcpyw (p, DSN);
}
else
p = stpcpyw (p, _T ("DSN=default"));
if (DATABASEW)
{
p = stpcpyw (p, _T (";DATABASE="));
p = stpcpyw (p, DATABASEW);
}
if (FORCE_DMBS_NAMEW)
{
p = stpcpyw (p, _T (";FORCE_DBMS_NAME="));
p = stpcpyw (p, FORCE_DMBS_NAMEW);
}
if (CHARSET)
{
p = stpcpyw (p, _T (";CHARSET="));
p = stpcpyw (p, CHARSETW);
}
#ifdef _SSL
if (con->con_encrypt)
{
p = stpcpyw (p, _T (";ENCRYPT="));
p = stpcpyw (p, ENCRYPTW);
}
if (con->con_ca_list)
{
p = stpcpyw (p, _T (";SERVERCERT="));
p = stpcpyw (p, SERVERCERTW);
}
if (con->con_pwd_cleartext)
{
p = stpcpyw (p, _T (";PWDCLEAR="));
p = stpcpyw (p, PWDCLEARW);
}
#endif
if (DAYLIGHTW)
{
p = stpcpyw (p, isdts_mode ? _T (";DAYLIGHT=Y") : _T (";DAYLIGHT=N"));
}
p = stpcpyw (p, _T (";UID="));
p = stpcpyw (p, UIDW);
p = stpcpyw (p, _T (";PWD="));
p = stpcpyw (p, PWDW);
p = stpcpyw (p, _T (";HOST="));
p = stpcpyw (p, HOSTW);
if (-1 == StrCopyOut (cmd, szConnStrOut, cbConnStrOutMax, (u_short *) pcbConnStrOutMax))
{
rc = SQL_SUCCESS_WITH_INFO;
set_success_info (&con->con_error, "01004", "CLW01", "String data, right truncated", 0);
}
}
free_wide_buffer (HOST);
free_wide_buffer (UID);
free_wide_buffer (PWD);
free_wide_buffer (CHARSET);
free_wide_buffer (DATABASE);
/* Cleanup */
ParseOptions (cfgdata, NULL, 1);
if (connStr)
free (connStr);
mutex_leave (con->con_environment->env_mtx);
return rc;
}
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;
}
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;
}
}
