HavokResponse *db_mysql_save_account( HavokRequest *req )
{
MYSQL_BIND *data;
pthread_mutex_t *mutex;
HavokResponse *resp;
ProtectedData_t *protect;
volatile int id;
if( !req || !req->account_data ) {
return;
}
mutex = CREATE(pthread_mutex_t);
thread_mutex_init( mutex );
protect = ProtectedDataCreate();
protect->data = (void *)&id;
ProtectedDataLock( protect );
data = CREATEN(MYSQL_BIND, 7);
bind_numeric( &data[0], req->account_data->id, MYSQL_TYPE_LONG );
bind_string( &data[1], req->account_data->email, MYSQL_TYPE_VAR_STRING );
bind_string( &data[2], req->account_data->passwd, MYSQL_TYPE_VAR_STRING );
bind_numeric( &data[3], (req->account_data->ansi ? 1 : 0),
MYSQL_TYPE_TINY );
bind_numeric( &data[4], (req->account_data->confirmed ? 1 : 0),
MYSQL_TYPE_TINY );
bind_string( &data[5], (req->account_data->confcode ?
req->account_data->confcode : ""),
MYSQL_TYPE_VAR_STRING );
bind_null_blob( &data[6], protect );
db_queue_query( 5, QueryTable, data, 7, NULL, NULL, mutex );
pthread_mutex_unlock( mutex );
pthread_mutex_destroy( mutex );
memfree( mutex );
ProtectedDataLock( protect );
ProtectedDataDestroy( protect );
resp = protobufCreateResponse();
if( !resp ) {
return( NULL );
}
resp->request_type = REQ_TYPE__SAVE_ACCOUNT;
resp->account_data = CREATE(ReqAccountType);
req_account_type__init( resp->account_data );
memcpy( resp->account_data, req->account_data, sizeof(ReqAccountType) );
resp->account_data->id = id;
resp->account_data->email = memstrlink( req->account_data->email );
resp->account_data->passwd = memstrlink( req->account_data->passwd );
resp->account_data->confcode = memstrlink( req->account_data->confcode );
return( resp );
}
HavokResponse *db_mysql_find_pc( HavokRequest *req )
{
MYSQL_BIND *data;
pthread_mutex_t *mutex;
HavokResponse *resp;
if( !req || !req->pc_data || !req->pc_data->name ) {
return( NULL );
}
mutex = CREATE(pthread_mutex_t);
thread_mutex_init( mutex );
data = CREATEN(MYSQL_BIND, 1);
bind_string( &data[0], req->pc_data->name, MYSQL_TYPE_VAR_STRING );
db_queue_query( 17, QueryTable, data, 1, result_find_pc, (void *)&resp,
mutex );
pthread_mutex_unlock( mutex );
pthread_mutex_destroy( mutex );
memfree( mutex );
return( resp );
}
int bind_params(sqlite3_stmt* stmt, const mxArray *params, int column)
{
TYPECHECK(params, mxSTRUCT_CLASS);
int i, n = mxGetNumberOfFields(params);
for (i = 0; i < n; i++) {
mxArray *array = mxGetFieldByNumber(params, column, i);
mxClassID cls = mxGetClassID(array);
int res;
switch (cls) {
case mxFUNCTION_CLASS:
break;
case mxCHAR_CLASS:
res = bind_string(stmt, i + 1, array);
break;
case mxSINGLE_CLASS:
case mxDOUBLE_CLASS:
res = bind_double(stmt, i + 1, array);
break;
default: /* anything else is an integer */
res = bind_int64(stmt, i + 1, array);
}
if (res != SQLITE_OK) {
return res;
}
}
return SQLITE_OK;
}
HavokResponse *db_mysql_set_setting( HavokRequest *req )
{
MYSQL_BIND *data;
if( !req || !req->settings_data->setting_name ||
!req->settings_data->setting_value ) {
return( NULL );
}
data = CREATEN(MYSQL_BIND, 2);
bind_string( &data[0], req->settings_data->setting_name,
MYSQL_TYPE_VAR_STRING );
bind_string( &data[1], req->settings_data->setting_value,
MYSQL_TYPE_VAR_STRING );
db_queue_query( 1, QueryTable, data, 2, NULL, NULL, NULL);
return( NULL );
}
static void bind_post(int *count, lily_parse_state *parser, request_rec *r)
{
if (*count == -1)
return;
lily_var *post_var = bind_hash_str_str_var(parser->symtab, "post");
lily_hash_val *hash_val = post_var->value.hash;
apr_array_header_t *pairs;
apr_off_t len;
apr_size_t size;
char *buffer;
char *sipkey = parser->vm->sipkey;
lily_class *string_cls = lily_class_by_id(parser->symtab, SYM_CLASS_STRING);
lily_sig *string_sig = string_cls->sig;
/* Credit: I found out how to use this by reading httpd 2.4's mod_lua
(specifically req_parsebody of lua_request.c). */
int res = ap_parse_form_data(r, NULL, &pairs, -1, 1024 * 8);
if (res == OK) {
while (pairs && !apr_is_empty_array(pairs)) {
ap_form_pair_t *pair = (ap_form_pair_t *) apr_array_pop(pairs);
apr_brigade_length(pair->value, 1, &len);
size = (apr_size_t) len;
buffer = lily_malloc(size + 1);
if (buffer == NULL) {
*count = -1;
return;
}
apr_brigade_flatten(pair->value, buffer, &size);
buffer[len] = 0;
lily_value *elem_key = bind_string(string_sig, pair->name);
/* Give the buffer to the value to save memory. */
lily_value *elem_value = bind_string_and_buffer(string_sig, buffer);
lily_hash_elem *new_elem = bind_hash_elem_with_values(sipkey,
elem_key, elem_value);
if (elem_key == NULL || elem_value == NULL || new_elem == NULL) {
lily_free(new_elem);
deref_destroy_value(elem_key);
deref_destroy_value(elem_value);
*count = -1;
return;
}
new_elem->next = hash_val->elem_chain;
hash_val->elem_chain = new_elem;
}
}
(*count)++;
}
HavokResponse *db_mysql_save_pc( HavokRequest *req )
{
MYSQL_BIND *data;
pthread_mutex_t *mutex;
HavokResponse *resp;
ProtectedData_t *protect;
volatile int id;
if( !req || !req->pc_data ) {
return( NULL );
}
mutex = CREATE(pthread_mutex_t);
thread_mutex_init( mutex );
protect = ProtectedDataCreate();
protect->data = (void *)&id;
ProtectedDataLock( protect );
data = CREATEN(MYSQL_BIND, 4);
bind_numeric( &data[0], req->pc_data->id, MYSQL_TYPE_LONG );
bind_numeric( &data[1], req->pc_data->account_id, MYSQL_TYPE_LONG );
bind_string( &data[2], req->pc_data->name, MYSQL_TYPE_VAR_STRING );
bind_null_blob( &data[3], protect );
db_queue_query( 10, QueryTable, data, 4, NULL, NULL, mutex );
pthread_mutex_unlock( mutex );
pthread_mutex_destroy( mutex );
memfree( mutex );
ProtectedDataLock( protect );
ProtectedDataDestroy( protect );
db_mysql_save_pc_attribs( id, req->pc_data->attribs );
resp = protobufCreateResponse();
if( !resp ) {
return( NULL );
}
resp->request_type = REQ_TYPE__SAVE_PC;
resp->n_pc_data = 1;
resp->pc_data = CREATE(ReqPCType *);
resp->pc_data[0] = CREATE(ReqPCType);
req_pctype__init( resp->pc_data[0] );
memcpy( resp->pc_data[0], req->pc_data, sizeof(ReqPCType) );
resp->pc_data[0]->id = id;
resp->pc_data[0]->name = memstrlink( req->pc_data->name );
return( resp );
}
static int bind_table_entry(void *data, const char *key, const char *value)
{
struct table_bind_data *d = data;
lily_value *elem_key = bind_string(d->string_sig, key);
lily_value *elem_value = bind_string(d->string_sig, value);
lily_hash_elem *new_elem = bind_hash_elem_with_values(d->sipkey,
elem_key, elem_value);
if (elem_key == NULL || elem_value == NULL || new_elem == NULL) {
lily_free(new_elem);
deref_destroy_value(elem_key);
deref_destroy_value(elem_value);
d->ok = 0;
return FALSE;
}
new_elem->next = d->hash_val->elem_chain;
d->hash_val->elem_chain = new_elem;
return TRUE;
}
void db_mysql_save_pc_attribs( int pc_id, char *json )
{
MYSQL_BIND *data;
pthread_mutex_t *mutex;
JSONSource_t *js;
JSONSource_t *jsItem;
if( !pc_id || !json ) {
return;
}
js = SplitJSON( json );
if( !js ) {
return;
}
mutex = CREATE(pthread_mutex_t);
thread_mutex_init( mutex );
for( jsItem = js; jsItem->source; jsItem++ ) {
data = CREATEN(MYSQL_BIND, 3);
bind_numeric( &data[0], pc_id, MYSQL_TYPE_LONG );
bind_string( &data[1], jsItem->source, MYSQL_TYPE_VAR_STRING );
bind_string( &data[2], jsItem->json, MYSQL_TYPE_VAR_STRING );
db_queue_query( 14, QueryTable, data, 3, NULL, NULL, mutex );
pthread_mutex_unlock( mutex );
}
pthread_mutex_destroy( mutex );
memfree( mutex );
DestroyJSONSource( js );
}
/*
* http://dev.mysql.com/doc/refman/5.1/en/mysql-stmt-execute.html
*
* 6 > odbc:param_query(Ref,
* "INSERT INTO EMPLOYEE (NR, FIRSTNAME, "
* "LASTNAME, GENDER) VALUES(?, ?, ?, ?)",
* [{sql_integer,[2,3,4,5,6,7,8]},
* {{sql_varchar, 20},
* ["John", "Monica", "Ross", "Rachel",
* "Piper", "Prue", "Louise"]},
* {{sql_varchar, 20},
* ["Doe","Geller","Geller", "Green",
* "Halliwell", "Halliwell", "Lane"]},
* {{sql_char, 1}, ["M","F","M","F","T","F","F"]}]).
* {updated, 7}
*/
void
handle_param_query(ETERM *msg)
{
ETERM *query, *params, *p, *tmp, *resp;
MYSQL_STMT *handle;
MYSQL_BIND *bind;
char *q;
int param_count, i;
query = erl_element(2, msg);
q = erl_iolist_to_string(query);
erl_free_term(query);
logmsg("INFO: got param query: %s", q);
params = erl_element(3, msg);
erl_free_term(params);
handle = mysql_stmt_init(&dbh);
if (mysql_stmt_prepare(handle, q, strlen(q))) {
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
} else {
param_count = mysql_stmt_param_count(handle);
if (param_count != erl_length(params)) {
resp = erl_format("{error, {mysql_error, -1, [expected_params, %d, got_params, %d]}}", param_count, erl_length(params));
} else {
bind = safe_malloc(param_count * sizeof(MYSQL_BIND));
memset(bind, 0, param_count * sizeof(MYSQL_BIND));
for (i = 0, tmp = params;
i < param_count && (p = erl_hd(tmp)) != NULL;
i++, tmp = erl_tl(tmp)) {
ETERM *type, *value;
type = erl_element(1, p);
value = erl_element(2, p);
if (ERL_IS_TUPLE(type)) {
// Parameter Type + Size: {Type, Size}
ETERM *t_type, *t_size;
char *t;
unsigned long size;
t_size = erl_element(2, type);
size = ERL_INT_VALUE(t_size);
bind[i].buffer_length = size;
erl_free_term(t_size);
t_type = erl_element(1, type);
t = (char *)ERL_ATOM_PTR(t_type);
bind[i].length = safe_malloc(sizeof(unsigned long));
if (strncmp(t, NUMERIC_SQL, strlen(NUMERIC_SQL)) == 0) {
int val;
bind[i].buffer_type = MYSQL_TYPE_LONG;
*bind[i].length = sizeof(int);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = ERL_INT_VALUE(value);
memcpy(bind[i].buffer, &val, *bind[i].length);
} else if (strncmp(t, DECIMAL_SQL, strlen(DECIMAL_SQL)) == 0) {
char *val;
bind[i].buffer_type = MYSQL_TYPE_STRING;
*bind[i].length = bind[i].buffer_length * sizeof(char);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = erl_iolist_to_string(value);
if (val) {
memcpy(bind[i].buffer, val, *bind[i].length);
free(val);
}
} else if (strncmp(t, FLOAT_SQL, strlen(FLOAT_SQL)) == 0) {
float val;
bind[i].buffer_type = MYSQL_TYPE_FLOAT;
*bind[i].length = sizeof(float);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = ERL_FLOAT_VALUE(value);
memcpy(bind[i].buffer, &val, *bind[i].length);
} else if (strncmp(t, CHAR_SQL, strlen(CHAR_SQL)) == 0) {
char *val;
bind[i].buffer_type = MYSQL_TYPE_STRING;
*bind[i].length = bind[i].buffer_length * sizeof(char);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = erl_iolist_to_string(value);
if (val) {
memcpy(bind[i].buffer, val, *bind[i].length);
free(val);
}
} else if (strncmp(t, VARCHAR_SQL, strlen(VARCHAR_SQL)) == 0) {
(void)bind_string(&bind[i], value, size);
} else {
ETERM *resp;
resp = erl_format("{error, {unknown_sized_type, ~s, ~i}}",
t, bind[i].buffer_length);
write_msg(resp);
erl_free_term(resp);
}
erl_free_term(t_type);
} else {
char *t;
t = (char *)ERL_ATOM_PTR(type);
if (strncmp(t, TIMESTAMP_SQL, strlen(TIMESTAMP_SQL)) == 0) {
bind[i].buffer_type = MYSQL_TYPE_TIMESTAMP;
*bind[i].length = sizeof(MYSQL_TIME);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
memcpy(bind[i].buffer, value, *bind[i].length);
} else if (strncmp(t, INTEGER_SQL, strlen(INTEGER_SQL)) == 0) {
int val;
bind[i].buffer_type = MYSQL_TYPE_LONG;
*bind[i].length = sizeof(int);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = ERL_INT_VALUE(value);
memcpy(bind[i].buffer, &val, *bind[i].length);
} else {
ETERM *resp;
resp = erl_format("{error, {unknown_type, ~s}}", t);
write_msg(resp);
erl_free_term(resp);
}
}
if (ERL_IS_ATOM(value)
&& strncmp((char *)ERL_ATOM_PTR(value),
NULL_SQL, strlen(NULL_SQL)) == 0)
bind[i].is_null = &TRUTHY;
else
bind[i].is_null = &FALSY;
erl_free_term(value);
erl_free_term(type);
}
erl_free_term(params);
if (mysql_stmt_bind_param(handle, bind)) {
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
} else {
if (mysql_stmt_execute(handle)) {
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
} else {
set_mysql_results(handle);
if (results) {
resp = handle_mysql_result();
} else {
if (mysql_stmt_field_count(handle) == 0)
resp = erl_format("{updated, ~i}", numrows);
else
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
}
}
}
for (i = 0; i < param_count; i++) {
free(bind[i].length);
free(bind[i].buffer);
}
free(bind);
}
}
erl_free(q);
mysql_stmt_close(handle);
write_msg(resp);
erl_free_term(resp);
}
