int main(void)
#endif
{
ei_x_buff eix;
int index = 0;
ETERM **etermpp = NULL, *etermp = NULL;
char *charp = NULL;
unsigned char uchar, **ucharpp = NULL, *ucharp = NULL;
void *voidp = NULL;
Erl_Heap *erl_heapp = NULL;
int intx = 0;
int *intp = NULL;
unsigned int uintx, *uintp;
unsigned long *ulongp = NULL;
long longx = 0;
double doublex = 0.0;
short shortx = 42;
FILE *filep = NULL;
Erl_IpAddr erl_ipaddr = NULL;
ErlMessage *erlmessagep = NULL;
ErlConnect *erlconnectp = NULL;
struct hostent *hostp = NULL;
struct in_addr *inaddrp = NULL;
/* Converion to erl_interface format is in liberl_interface */
intx = erl_errno;
ei_encode_term(charp, &index, voidp);
ei_x_encode_term(&eix, voidp);
ei_decode_term(charp, &index, voidp);
erl_init(voidp, longx);
erl_connect_init(intx, charp,shortx);
erl_connect_xinit(charp,charp,charp,erl_ipaddr,charp,shortx);
erl_connect(charp);
erl_xconnect(erl_ipaddr,charp);
erl_close_connection(intx);
erl_receive(intx, ucharp, intx);
erl_receive_msg(intx, ucharp, intx, erlmessagep);
erl_xreceive_msg(intx, ucharpp, intp, erlmessagep);
erl_send(intx, etermp, etermp);
erl_reg_send(intx, charp, etermp);
erl_rpc(intx,charp,charp,etermp);
erl_rpc_to(intx,charp,charp,etermp);
erl_rpc_from(intx,intx,erlmessagep);
erl_publish(intx);
erl_accept(intx,erlconnectp);
erl_thiscookie();
erl_thisnodename();
erl_thishostname();
erl_thisalivename();
erl_thiscreation();
erl_unpublish(charp);
erl_err_msg(charp);
erl_err_quit(charp);
erl_err_ret(charp);
erl_err_sys(charp);
erl_cons(etermp,etermp);
erl_copy_term(etermp);
erl_element(intx,etermp);
erl_hd(etermp);
erl_iolist_to_binary(etermp);
erl_iolist_to_string(etermp);
erl_iolist_length(etermp);
erl_length(etermp);
erl_mk_atom(charp);
erl_mk_binary(charp,intx);
erl_mk_empty_list();
erl_mk_estring(charp, intx);
erl_mk_float(doublex);
erl_mk_int(intx);
erl_mk_list(etermpp,intx);
erl_mk_pid(charp,uintx,uintx,uchar);
erl_mk_port(charp,uintx,uchar);
erl_mk_ref(charp,uintx,uchar);
erl_mk_long_ref(charp,uintx,uintx,uintx,uchar);
erl_mk_string(charp);
erl_mk_tuple(etermpp,intx);
erl_mk_uint(uintx);
erl_mk_var(charp);
erl_print_term(filep,etermp);
/* erl_sprint_term(charp,etermp); */
erl_size(etermp);
erl_tl(etermp);
erl_var_content(etermp, charp);
erl_format(charp);
erl_match(etermp, etermp);
erl_global_names(intx, intp);
erl_global_register(intx, charp, etermp);
erl_global_unregister(intx, charp);
erl_global_whereis(intx, charp, charp);
erl_init_malloc(erl_heapp,longx);
erl_alloc_eterm(uchar);
erl_eterm_release();
erl_eterm_statistics(ulongp,ulongp);
erl_free_array(etermpp,intx);
erl_free_term(etermp);
erl_free_compound(etermp);
erl_malloc(longx);
erl_free(voidp);
erl_compare_ext(ucharp, ucharp);
erl_decode(ucharp);
erl_decode_buf(ucharpp);
erl_encode(etermp,ucharp);
erl_encode_buf(etermp,ucharpp);
erl_ext_size(ucharp);
erl_ext_type(ucharp);
erl_peek_ext(ucharp,intx);
erl_term_len(etermp);
erl_gethostbyname(charp);
erl_gethostbyaddr(charp, intx, intx);
erl_gethostbyname_r(charp, hostp, charp, intx, intp);
erl_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
erl_init_resolve();
erl_distversion(intx);
erl_epmd_connect(inaddrp);
erl_epmd_port(inaddrp, charp, intp);
charp = ERL_ATOM_PTR(etermp);
intx = ERL_ATOM_SIZE(etermp);
ucharp = ERL_BIN_PTR(etermp);
intx = ERL_BIN_SIZE(etermp);
etermp = ERL_CONS_HEAD(etermp);
etermp = ERL_CONS_TAIL(etermp);
intx = ERL_COUNT(etermp);
doublex= ERL_FLOAT_VALUE(etermp);
uintx = ERL_INT_UVALUE(etermp);
intx = ERL_INT_VALUE(etermp);
intx = ERL_IS_ATOM(etermp);
intx = ERL_IS_BINARY(etermp);
intx = ERL_IS_CONS(etermp);
intx = ERL_IS_EMPTY_LIST(etermp);
intx = ERL_IS_FLOAT(etermp);
intx = ERL_IS_INTEGER(etermp);
intx = ERL_IS_LIST(etermp);
intx = ERL_IS_PID(etermp);
intx = ERL_IS_PORT(etermp);
intx = ERL_IS_REF(etermp);
intx = ERL_IS_TUPLE(etermp);
intx = ERL_IS_UNSIGNED_INTEGER(etermp);
uchar = ERL_PID_CREATION(etermp);
charp = ERL_PID_NODE(etermp);
uintx = ERL_PID_NUMBER(etermp);
uintx = ERL_PID_SERIAL(etermp);
uchar = ERL_PORT_CREATION(etermp);
charp = ERL_PORT_NODE(etermp);
uintx = ERL_PORT_NUMBER(etermp);
uchar = ERL_REF_CREATION(etermp);
intx = ERL_REF_LEN(etermp);
charp = ERL_REF_NODE(etermp);
uintx = ERL_REF_NUMBER(etermp);
uintp = ERL_REF_NUMBERS(etermp);
etermp = ERL_TUPLE_ELEMENT(etermp,intx);
intx = ERL_TUPLE_SIZE(etermp);
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EINVAL +
EIO +
EMSGSIZE +
ENOMEM +
ERL_ATOM +
ERL_BINARY +
ERL_ERROR +
ERL_EXIT +
ERL_FLOAT +
ERL_INTEGER +
ERL_LINK +
ERL_LIST +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_PID +
ERL_PORT +
ERL_REF +
ERL_REG_SEND +
ERL_SEND +
ERL_SMALL_BIG +
ERL_TICK +
ERL_TIMEOUT +
ERL_TUPLE +
ERL_UNLINK +
ERL_U_INTEGER +
ERL_U_SMALL_BIG +
ERL_VARIABLE +
ETIMEDOUT +
MAXNODELEN +
MAXREGLEN;
}
/**
** rockse <path_to_tbl> <path_to_log>
**/
int main(int argc, char **argv) {
rockse * ptr;
ETERM *from_erl;
ETERM *cmd;
ETERM *key;
ETERM *value;
char *ret;
ETERM *to_send;
byte buf[1024];
int length;
log = fopen(argv[2], "a+");
erl_init(NULL, 0);
fprintf(log, "*** rockse opening table %s\n", argv[1]);
ptr = open(argv[1]);
while (read_cmd(buf) > 0) {
from_erl = erl_decode(buf);
fprintf(log, " rockse command type %d\n", ERL_TYPE(from_erl));
if (match_close(from_erl)) {
send_bok();
fprintf(log, " rockse command +close+ sent\n");
break;
}
if (ERL_IS_TUPLE(from_erl) && ERL_TUPLE_SIZE(from_erl) == 3) {
/* can only be a {put, key, val} */
cmd = ERL_TUPLE_ELEMENT(from_erl, 0);
if (match_put(cmd)) {
key = ERL_TUPLE_ELEMENT(from_erl, 1);
value = ERL_TUPLE_ELEMENT(from_erl, 2);
fprintf(log, " rockse command +put+ %s %s sent\n", erl_iolist_to_string(key), erl_iolist_to_string(value));
put(ptr, erl_iolist_to_string(key), erl_iolist_to_string(value));
send_put_ok();
}
erl_free_term(from_erl);
erl_free_term(cmd);
erl_free_term(key);
erl_free_term(value);
}
if (ERL_IS_TUPLE(from_erl) && ERL_TUPLE_SIZE(from_erl) == 2) {
/* can only be a {get, key} or {delete, key} */
cmd = ERL_TUPLE_ELEMENT(from_erl, 0);
if (match_get(cmd)) {
key = ERL_TUPLE_ELEMENT(from_erl, 1);
fprintf(log, " rockse command +get+ %s sent\n", erl_iolist_to_string(key));
ret = get(ptr, erl_iolist_to_string(key));
if (ret == NULL) {
send_nok();
}
else {
length = strlen(ret);
fprintf(log, " rockse command +get+ found %s of size %d\n", ret, length);
to_send = erl_format("{ok, get, ~s}", ret);
send_get_result(to_send);
free(ret);
}
}
else if (match_delete(cmd)) {
key = ERL_TUPLE_ELEMENT(from_erl, 1);
fprintf(log, " rockse command +delete+ %s sent\n", erl_iolist_to_string(key));
delete(ptr, erl_iolist_to_string(key));
send_delete_ok();
}
erl_free_term(from_erl);
erl_free_term(cmd);
erl_free_term(key);
}
fflush(log);
}
close_and_destroy(ptr);
fprintf(log, "*** rockse closing table %s\n", argv[1]);
erl_free_term(from_erl);
fclose(log);
return 0;
}
/*
* 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);
}
void
handle_select(ETERM *msg)
{
ETERM *epos, *ecount, *ecols, *erows, *resp;
my_ulonglong pos, count;
epos = erl_element(2, msg);
ecount = erl_element(3, msg);
pos = ERL_INT_UVALUE(epos);
count = ERL_INT_UVALUE(ecount);
erl_free_term(epos);
erl_free_term(ecount);
if (results == NULL) {
resp = erl_format("{error, result_set_does_not_exist}");
write_msg(resp);
erl_free_term(resp);
return;
}
if (ERL_IS_TUPLE(epos)) {
char *pos_type;
unsigned int pos_count;
pos_type = ERL_ATOM_PTR(erl_element(1, epos));
pos_count = ERL_INT_UVALUE(erl_element(2, epos));
if (strncmp(pos_type, SELECT_ABSOLUTE, strlen(SELECT_ABSOLUTE)) == 0) {
resultoffset = pos_count - 1;
} else if (strncmp(pos_type, SELECT_RELATIVE, strlen(SELECT_RELATIVE)) == 0) {
resultoffset += pos_count - 1;
} else {
resp = erl_format("{error, unknown_position, ~w}", epos);
write_msg(resp);
erl_free_term(resp);
return;
}
} else {
if (strncmp((char *)ERL_ATOM_PTR(epos), SELECT_NEXT, strlen(SELECT_NEXT)) == 0) {
handle_next(NULL);
return;
} else {
resp = erl_format("{error, unknown_position, ~w}", epos);
write_msg(resp);
erl_free_term(resp);
return;
}
}
mysql_stmt_data_seek(sth, resultoffset);
ecols = make_cols();
erows = make_rows(count);
resultoffset += count;
resp = erl_format("{selected, ~w, ~w}", ecols, erows);
erl_free_term(erows);
erl_free_term(ecols);
write_msg(resp);
erl_free_term(resp);
}
PyObject *py_erlang_rpc(PyObject * self, PyObject * args) {
int fd, timeout = uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT];
char *emod, *efun;
PyObject *eargs, *pyer = NULL;
ETERM *pyargs, *rex;
ErlMessage emsg;
int eret;
if (!PyArg_ParseTuple(args, "issO|i:erlang_rpc", &fd, &emod, &efun, &eargs, &timeout)) {
return NULL;
}
if (fd < 0) {
goto clear;
}
pyargs = py_to_eterm(eargs);
if (!pyargs) {
goto clear;
}
if (erl_rpc_to(fd, emod, efun, pyargs)) {
erl_err_msg("erl_rpc_to()");
goto clear2;
}
cycle:
memset(&emsg, 0, sizeof(ErlMessage));
UWSGI_SET_BLOCKING;
eret = erl_rpc_from(fd, timeout * 1000, &emsg);
if (eret == ERL_TICK) {
goto cycle;
}
else if (eret == ERL_MSG) {
if (emsg.msg) {
if (ERL_IS_TUPLE(emsg.msg)) {
rex = erl_element(1, emsg.msg);
if (!rex) {
goto clear2;
}
if (!strncmp("rex", ERL_ATOM_PTR(rex), ERL_ATOM_SIZE(rex))) {
erl_free_term(rex);
rex = erl_element(2, emsg.msg);
if (!rex) {
goto clear2;
}
pyer = eterm_to_py(rex);
erl_free_term(rex);
}
else {
erl_free_term(rex);
}
}
}
if (emsg.msg) {
erl_free_compound(emsg.msg);
}
if (emsg.to) {
erl_free_compound(emsg.to);
}
if (emsg.from) {
erl_free_compound(emsg.from);
}
if (!pyer) {
goto clear2;
}
erl_free_compound(pyargs);
UWSGI_UNSET_BLOCKING;
return pyer;
}
else {
erl_err_msg("erl_rpc_from()");
}
clear2:
UWSGI_UNSET_BLOCKING;
erl_free_compound(pyargs);
clear:
Py_INCREF(Py_None);
return Py_None;
}
