void encode_result(ei_x_buff* x, PGresult* res, PGconn* conn)
{
int row, n_rows, col, n_cols;
switch (PQresultStatus(res)) {
case PGRES_TUPLES_OK:
n_rows = PQntuples(res);
n_cols = PQnfields(res);
ei_x_encode_tuple_header(x, 2);
encode_ok(x);
ei_x_encode_list_header(x, n_rows+1);
ei_x_encode_list_header(x, n_cols);
for (col = 0; col < n_cols; ++col) {
ei_x_encode_string(x, PQfname(res, col));
}
ei_x_encode_empty_list(x);
for (row = 0; row < n_rows; ++row) {
ei_x_encode_list_header(x, n_cols);
for (col = 0; col < n_cols; ++col) {
ei_x_encode_string(x, PQgetvalue(res, row, col));
}
ei_x_encode_empty_list(x);
}
ei_x_encode_empty_list(x);
break;
case PGRES_COMMAND_OK:
ei_x_encode_tuple_header(x, 2);
encode_ok(x);
ei_x_encode_string(x, PQcmdTuples(res));
break;
default:
encode_error(x, conn);
break;
}
}
void encode_name(const XML_Char *name)
{
char *name_start;
char *prefix_start;
char *buf;
int name_len, prefix_len, buf_len;
if ((name_start = strchr(name, '\n'))) {
if ((prefix_start = strchr(name_start+1, '\n'))) {
name_len = prefix_start - name_start;
prefix_len = strlen(prefix_start+1);
buf_len = prefix_len + name_len;
buf = driver_alloc(buf_len);
memcpy(buf, prefix_start+1, prefix_len);
memcpy(buf+prefix_len, name_start, name_len);
buf[prefix_len] = ':';
ei_x_encode_string_len(&event_buf, buf, buf_len);
driver_free(buf);
} else {
ei_x_encode_string(&event_buf, name_start+1);
};
} else {
ei_x_encode_string(&event_buf, name);
}
}
void *erlXML_StartElementHandler(expat_data *d,
const XML_Char *name,
const XML_Char **atts)
{
int i;
ei_x_encode_list_header(&event_buf, 1);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_long(&event_buf, XML_START);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_string(&event_buf, name);
for (i = 0; atts[i]; i += 2) {}
if (i > 0)
{
ei_x_encode_list_header(&event_buf, i/2);
for (i = 0; atts[i]; i += 2)
{
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_string(&event_buf, atts[i]);
ei_x_encode_string(&event_buf, atts[i+1]);
}
}
ei_x_encode_empty_list(&event_buf);
return NULL;
}
void *erlXML_StartNamespaceDeclHandler(expat_data *d,
const XML_Char *prefix,
const XML_Char *uri)
{
int prefix_len;
char *buf;
/* From the expat documentation:
"For a default namespace declaration (xmlns='...'),
the prefix will be null ...
... The URI will be null for the case where
the default namespace is being unset."
FIXME: I'm not quite sure what all that means */
if (uri == NULL)
return NULL;
ei_x_encode_list_header(&xmlns_buf, 1);
ei_x_encode_tuple_header(&xmlns_buf, 2);
if (prefix) {
prefix_len = strlen(prefix);
buf = driver_alloc(7 + prefix_len);
strcpy(buf, "xmlns:");
strcpy(buf+6, prefix);
ei_x_encode_string(&xmlns_buf, buf);
driver_free(buf);
} else {
ei_x_encode_string(&xmlns_buf, "xmlns");
};
ei_x_encode_string(&xmlns_buf, uri);
return NULL;
}
static int
encode_attr(struct exmpp_xml_ctx *ctx, ei_x_buff *tree,
const char *attr, int attr_len)
{
int ret;
/* Check if the attribute is known and encode it. */
if (attr_len <= MAXATOMLEN && ctx->names_as_atom) {
if (is_known_attr(ctx, attr, attr_len))
if (attr_len == -1)
ret = ei_x_encode_atom(tree, attr);
else
ret = ei_x_encode_atom_len(tree,
attr, attr_len);
else
if (attr_len == -1)
ret = ei_x_encode_string(tree, attr);
else
ret = ei_x_encode_string_len(tree,
attr, attr_len);
} else {
if (attr_len == -1)
ret = ei_x_encode_string(tree, attr);
else
ret = ei_x_encode_string_len(tree, attr, attr_len);
}
return (ret);
}
static int
encode_ns(struct exmpp_xml_ctx *ctx, ei_x_buff *tree,
const char *ns, int ns_len)
{
int ret;
if (ns != NULL) {
/* Check if the namespace is known and encode it. */
if (ns_len <= MAXATOMLEN && ctx->names_as_atom) {
if (is_known_ns(ctx, ns, ns_len))
if (ns_len == -1)
ret = ei_x_encode_atom(tree, ns);
else
ret = ei_x_encode_atom_len(tree,
ns, ns_len);
else
if (ns_len == -1)
ret = ei_x_encode_string(tree, ns);
else
ret = ei_x_encode_string_len(tree,
ns, ns_len);
} else {
if (ns_len == -1)
ret = ei_x_encode_string(tree, ns);
else
ret = ei_x_encode_string_len(tree,
ns, ns_len);
}
} else {
/* The namespace is "empty". The element may have none. */
ret = ei_x_encode_atom(tree, "undefined");
}
return (ret);
}
static int
encode_elem(struct exmpp_xml_ctx *ctx, ei_x_buff *tree,
const char *elem, int elem_len)
{
int ret;
/* Check if the element is known and encode it. */
if (elem_len <= MAXATOMLEN && ctx->names_as_atom) {
if (is_known_elem(ctx, elem, elem_len))
if (elem_len == -1)
ret = ei_x_encode_atom(tree, elem);
else
ret = ei_x_encode_atom_len(tree,
elem, elem_len);
else
if (elem_len == -1)
ret = ei_x_encode_string(tree, elem);
else
ret = ei_x_encode_string_len(tree,
elem, elem_len);
} else {
if (elem_len == -1)
ret = ei_x_encode_string(tree, elem);
else
ret = ei_x_encode_string_len(tree, elem, elem_len);
}
return (ret);
}
void encode_error(ei_x_buff* x, PGconn* conn)
{
const char* k_error = "error";
ei_x_encode_tuple_header(x, 2);
ei_x_encode_atom(x, k_error);
ei_x_encode_string(x, PQerrorMessage(conn));
}
int ei_x_encode_error_tuple_string(ei_x_buff *buff, char *str) {
EI(ei_x_encode_version(buff));
EI(ei_x_encode_tuple_header(buff, 2));
EI(ei_x_encode_atom(buff, "error"));
EI(ei_x_encode_string(buff, str));
return 0;
}
static DWORD WINAPI
#else
static void*
#endif
einode_thread(void* num)
{
int n = (int)num;
ei_cnode ec;
char myname[100], destname[100];
int r, fd;
sprintf(myname, "ei%d", n);
sprintf(destname, "mth%d", n);
printf("thread %d (%s %s) connecting\n", n, myname, destname);
r = ei_connect_init(&ec, myname, cookie, 0);
fd = ei_connect(&ec, (char*)desthost);
if (r == 0 && fd >= 0) {
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_string(&x, myname);
ei_reg_send(&ec, fd, destname, x.buff, x.index);
ei_x_free(&x);
//SleepEx(100);
shutdown(fd, SD_SEND);
closesocket(fd);
} else {
printf("coudn't connect fd %d r %d\n", fd, r); // DebugBreak();
}
printf("done thread %d\n", n);
return 0;
}
gboolean GN_tree_view_get_selected(int ARI, ei_x_buff *XBUF, char *B, int *I){
GtkTreeView *tv;
GtkTreeSelection *selection;
GtkTreeModel *model;
gchar* path;
if ( ! gn_check_arity(XBUF, 1, ARI) )
return FALSE;
if ( ! gn_get_arg_object(XBUF, B, I, GTK_TYPE_TREE_VIEW, (GObject**)&tv) )
return FALSE;
model = gtk_tree_view_get_model(tv);
selection = gtk_tree_view_get_selection(tv);
GList* list = gtk_tree_selection_get_selected_rows(selection, &model);
gn_wrap_reply("ok", XBUF);
while ( list ) {
path = gtk_tree_path_to_string( (GtkTreePath*) list->data);
g_assert( ! ei_x_encode_list_header(XBUF, 1) );
g_assert( ! ei_x_encode_string(XBUF, path) );
g_free(path);
list = list->next;
}
g_list_free(list);
g_assert( ! ei_x_encode_empty_list(XBUF));
return TRUE;
}
void *erlXML_EndElementHandler(expat_data *d,
const XML_Char *name)
{
ei_x_encode_list_header(&event_buf, 1);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_long(&event_buf, XML_END);
ei_x_encode_string(&event_buf, name);
return NULL;
}
static ei_x_buff make_error(const char* text){
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x,2);
ei_x_encode_atom(&x,"error");
ei_x_encode_string(&x,text);
return x;
}
static int expat_erl_control(ErlDrvData drv_data,
unsigned int command,
char *buf, int len,
char **rbuf, int rlen)
{
expat_data* d = (expat_data*)drv_data;
int res, errcode;
char *errstring;
ErlDrvBinary *b;
size_t size;
switch (command)
{
case PARSE_COMMAND:
case PARSE_FINAL_COMMAND:
ei_x_new_with_version(&event_buf);
ei_x_new(&xmlns_buf);
res = XML_Parse(d->parser, buf, len, command == PARSE_FINAL_COMMAND);
if(!res)
{
errcode = XML_GetErrorCode(d->parser);
errstring = (char *)XML_ErrorString(errcode);
ei_x_encode_list_header(&event_buf, 1);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_long(&event_buf, XML_ERROR);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_long(&event_buf, errcode);
ei_x_encode_string(&event_buf, errstring);
}
ei_x_encode_empty_list(&event_buf);
size = event_buf.index;
b = driver_alloc_binary(size);
memcpy(b->orig_bytes, event_buf.buff, size);
ei_x_free(&event_buf);
ei_x_free(&xmlns_buf);
*rbuf = (char *)b;
return size;
default:
return 0;
}
}
static ei_x_buff pack_parse_data(parse_result parse_result_){
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x,2);
//{caly_tekst,[link]} kodujemy caly tekst
ei_x_encode_string(&x, parse_result_.second.c_str());
int link_list_length = parse_result_.first.size();
ei_x_encode_list_header(&x,link_list_length);
vector<std::string>& links = parse_result_.first;
for (vector<std::string>::iterator it = links.begin(); it != links.end(); it++){
ei_x_encode_string_len(&x,(*it).c_str(),(*it).size());
}
ei_x_encode_empty_list(&x);
return x;
}
/*
* The format letters are:
* a - An atom
* c - A character
* s - A string
* i - An integer
* l - A long integer
* u - An unsigned long integer
* f - A float
* d - A double float
* p - An Erlang PID
*/
static int pformat(const char** fmt, union arg** args, ei_x_buff* x)
{
int res = 0;
++(*fmt); /* skip tilde */
switch (*(*fmt)++) {
case 'a':
res = ei_x_encode_atom(x, (*args)->s);
(*args)++;
break;
case 'c':
res = ei_x_encode_char(x, (*args)->c);
(*args)++;
break;
case 's':
res = ei_x_encode_string(x, (*args)->s);
(*args)++;
break;
case 'i':
res = ei_x_encode_long(x, (*args)->l);
(*args)++;
break;
case 'l':
res = ei_x_encode_long(x, (*args)->l);
(*args)++;
break;
case 'u':
res = ei_x_encode_ulong(x, (*args)->u);
(*args)++;
break;
case 'f': /* float is expanded to double (C calling conventions) */
case 'd':
res = ei_x_encode_double(x, (*args)->d);
(*args)++;
break;
case 'p':
res = ei_x_encode_pid(x, (*args)->pid);
(*args)++;
break;
default:
res = -1;
break;
}
return res;
}
int
make_declared_ns_in_buf(struct exmpp_xml_ctx *ctx, ei_x_buff *buf,
const char *ns, int ns_len,
const char *prefix, int prefix_len)
{
/* Start declared namespace entry. */
ei_x_encode_list_header(buf, 1);
ei_x_encode_tuple_header(buf, 2);
/* Check if the namespace is known and encode it. */
encode_ns(ctx, buf, ns, ns_len);
/* Encode prefix. */
if (prefix != NULL)
if (prefix_len == -1)
ei_x_encode_string(buf, prefix);
else
ei_x_encode_string_len(buf, prefix, prefix_len);
else
ei_x_encode_atom(buf, "none");
return (0);
}
int
make_attribute_legacy(struct exmpp_xml_ctx *ctx,
const char *attr, int attr_len,
const char *value, int value_len)
{
ei_x_buff *tree;
tree = ctx->current_tree;
/* Start a simple tuple. */
ei_x_encode_list_header(tree, 1);
ei_x_encode_tuple_header(tree, 2);
/* Check if the attribute is known and encode it. */
encode_attr(ctx, tree, attr, attr_len);
/* Encode the value. */
if (value_len == -1)
ei_x_encode_string(tree, value);
else
ei_x_encode_string_len(tree, value, value_len);
return (0);
}
static int
exmpp_xml_control(ErlDrvData drv_data, unsigned int command,
char *buf, int len, char **rbuf, int rlen)
{
struct exmpp_xml_data *edd;
ei_x_buff *to_return;
ErlDrvBinary *bin;
int size, ret;
edd = (struct exmpp_xml_data *)drv_data;
size = 0;
bin = NULL;
to_return = NULL;
switch (command) {
/*
* Parsing.
*/
case COMMAND_PARSE:
case COMMAND_PARSE_FINAL:
if (edd->parser == NULL) {
/* Start a parser. */
if (create_parser(edd) != 0) {
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_ERROR;
ei_x_encode_atom(to_return,
"parser_setup_failed");
break;
}
}
/* Control the total size of data to parse. */
if (!is_data_size_under_limit(&edd->ctx, len)) {
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_ERROR;
ei_x_encode_atom(to_return, "stanza_too_big");
break;
}
/* Run XML document parsing. */
ret = XML_Parse(edd->parser, buf, len,
command == COMMAND_PARSE_FINAL);
if (!ret) {
enum XML_Error errcode;
const char *errmsg;
/* An error occured during parsing; most probably,
* XML wasn't well-formed. */
errcode = XML_GetErrorCode(edd->parser);
errmsg = XML_ErrorString(errcode);
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_ERROR;
ei_x_encode_tuple_header(to_return, 2);
ei_x_encode_atom(to_return, "parsing_failed");
ei_x_encode_tuple_header(to_return, 2);
ei_x_encode_long(to_return, errcode);
ei_x_encode_string(to_return, errmsg);
break;
}
/* Return the complete tree(s). */
ret = RET_OK;
if (edd->ctx.complete_trees_ready) {
/* Terminate the complete trees list. */
ei_x_encode_empty_list(edd->ctx.complete_trees);
to_return = edd->ctx.complete_trees;
size = 1 + to_return->index;
bin = driver_alloc_binary(size);
if (bin == NULL)
return (-1);
bin->orig_bytes[0] = (char)ret;
memcpy(bin->orig_bytes + 1,
to_return->buff, to_return->index);
} else {
/* We need more data to produce a tree. */
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ei_x_encode_atom(to_return,
command == COMMAND_PARSE ? "continue" : "done");
}
if (command == COMMAND_PARSE) {
/* Update the size of processed data. */
add_data_size(&edd->ctx, len);
/* Reset the complete trees list. */
reset_complete_trees(&edd->ctx);
} else {
/* We're done with the parser. */
destroy_parser(edd);
}
break;
case COMMAND_RESET_PARSER:
if (edd->parser != NULL) {
reset_context(&edd->ctx);
XML_ParserReset(edd->parser, "UTF-8");
init_parser(edd);
}
ret = RET_OK;
break;
/*
* Misc.
*/
case COMMAND_PORT_REVISION:
/* Store the revision in the buffer. */
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_OK;
ei_x_encode_string(to_return, "$Revision$");
break;
default:
/* Other commands are handled in 'exmpp_xml.c' */
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = control(&edd->ctx, command, buf, to_return);
if (ret < 0)
return (-1);
}
if (bin == NULL) {
if (to_return != NULL) {
size = 1 + to_return->index;
bin = driver_alloc_binary(size);
if (bin == NULL)
return (-1);
bin->orig_bytes[0] = (char)ret;
if (to_return->index > 0)
memcpy(bin->orig_bytes + 1,
to_return->buff, to_return->index);
exmpp_free_xbuf(to_return);
} else {
/* The command called doesn't return anything. */
size = 1;
bin = driver_alloc_binary(size);
bin->orig_bytes[0] = RET_OK;
}
}
/* Set the returned buffer. */
*rbuf = (char *)bin;
/* Return the size of this buffer. */
return (size);
}
void string(ei_x_buff *eixb, const char *str) {
ei_x_encode_string(eixb, str);
}
int add_event_data(ei_x_buff* sendbuf, int topic, const void* data) {
switch (topic) {
case EVENT_COMMAND_FINISHED: {
ei_x_encode_atom(sendbuf, "event_command_finished");
struct SCommandFinishedEvent* event_data = (struct SCommandFinishedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 6);
{
if (ei_x_encode_atom(sendbuf, "unitid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unitid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unitId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unitId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "commandid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "commandid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->commandId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->commandId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "commandtopicid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "commandtopicid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->commandTopicId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->commandTopicId);
return -1;
}
}
break;
}
case EVENT_ENEMY_CREATED: {
ei_x_encode_atom(sendbuf, "event_enemy_created");
struct SEnemyCreatedEvent* event_data = (struct SEnemyCreatedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
break;
}
case EVENT_ENEMY_DAMAGED: {
ei_x_encode_atom(sendbuf, "event_enemy_damaged");
struct SEnemyDamagedEvent* event_data = (struct SEnemyDamagedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 12);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "attacker") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "attacker");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->attacker) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->attacker);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "damage") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "damage");
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->damage) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->damage);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "dir_posf3") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "dir_posf3");
return -1;
}
if (ei_x_encode_tuple_header(sendbuf, 3) < 0) {
fprintf(stderr, "cannot encode '%i' as 'tuple_header'\n", 3);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->dir_posF3[0]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->dir_posF3[0]);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->dir_posF3[1]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->dir_posF3[1]);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->dir_posF3[2]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->dir_posF3[2]);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "weapondefid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "weapondefid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->weaponDefId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->weaponDefId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "paralyzer") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "paralyzer");
return -1;
}
if (ei_x_encode_atom(sendbuf, event_data->paralyzer ? "true" : "false") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", event_data->paralyzer ? "true" : "false");
return -1;
}
}
break;
}
case EVENT_ENEMY_DESTROYED: {
ei_x_encode_atom(sendbuf, "event_enemy_destroyed");
struct SEnemyDestroyedEvent* event_data = (struct SEnemyDestroyedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 4);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "attacker") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "attacker");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->attacker) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->attacker);
return -1;
}
}
break;
}
case EVENT_ENEMY_ENTER_LOS: {
ei_x_encode_atom(sendbuf, "event_enemy_enter_los");
struct SEnemyEnterLOSEvent* event_data = (struct SEnemyEnterLOSEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
break;
}
case EVENT_ENEMY_ENTER_RADAR: {
ei_x_encode_atom(sendbuf, "event_enemy_enter_radar");
struct SEnemyEnterRadarEvent* event_data = (struct SEnemyEnterRadarEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
break;
}
case EVENT_ENEMY_FINISHED: {
ei_x_encode_atom(sendbuf, "event_enemy_finished");
struct SEnemyFinishedEvent* event_data = (struct SEnemyFinishedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
break;
}
case EVENT_ENEMY_LEAVE_LOS: {
ei_x_encode_atom(sendbuf, "event_enemy_leave_los");
struct SEnemyLeaveLOSEvent* event_data = (struct SEnemyLeaveLOSEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
break;
}
case EVENT_ENEMY_LEAVE_RADAR: {
ei_x_encode_atom(sendbuf, "event_enemy_leave_radar");
struct SEnemyLeaveRadarEvent* event_data = (struct SEnemyLeaveRadarEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "enemy") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "enemy");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->enemy) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->enemy);
return -1;
}
}
break;
}
case EVENT_LOAD: {
ei_x_encode_atom(sendbuf, "event_load");
struct SLoadEvent* event_data = (struct SLoadEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "file") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "file");
return -1;
}
if (ei_x_encode_string(sendbuf, event_data->file) < 0) {
fprintf(stderr, "cannot encode '%s' as 'string'\n", event_data->file);
return -1;
}
}
break;
}
case EVENT_LUA_MESSAGE: {
ei_x_encode_atom(sendbuf, "event_lua_message");
struct SLuaMessageEvent* event_data = (struct SLuaMessageEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "indata") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "indata");
return -1;
}
if (ei_x_encode_string(sendbuf, event_data->inData) < 0) {
fprintf(stderr, "cannot encode '%s' as 'string'\n", event_data->inData);
return -1;
}
}
break;
}
case EVENT_MESSAGE: {
ei_x_encode_atom(sendbuf, "event_message");
struct SMessageEvent* event_data = (struct SMessageEvent*)data;
ei_x_encode_tuple_header(sendbuf, 4);
{
if (ei_x_encode_atom(sendbuf, "player") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "player");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->player) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->player);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "message") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "message");
return -1;
}
if (ei_x_encode_string(sendbuf, event_data->message) < 0) {
fprintf(stderr, "cannot encode '%s' as 'string'\n", event_data->message);
return -1;
}
}
break;
}
case EVENT_RELEASE: {
ei_x_encode_atom(sendbuf, "event_release");
struct SReleaseEvent* event_data = (struct SReleaseEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "reason") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "reason");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->reason) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->reason);
return -1;
}
}
break;
}
case EVENT_SAVE: {
ei_x_encode_atom(sendbuf, "event_save");
struct SSaveEvent* event_data = (struct SSaveEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "file") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "file");
return -1;
}
if (ei_x_encode_string(sendbuf, event_data->file) < 0) {
fprintf(stderr, "cannot encode '%s' as 'string'\n", event_data->file);
return -1;
}
}
break;
}
case EVENT_SEISMIC_PING: {
ei_x_encode_atom(sendbuf, "event_seismic_ping");
struct SSeismicPingEvent* event_data = (struct SSeismicPingEvent*)data;
ei_x_encode_tuple_header(sendbuf, 4);
{
if (ei_x_encode_atom(sendbuf, "pos_posf3") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "pos_posf3");
return -1;
}
if (ei_x_encode_tuple_header(sendbuf, 3) < 0) {
fprintf(stderr, "cannot encode '%i' as 'tuple_header'\n", 3);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->pos_posF3[0]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->pos_posF3[0]);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->pos_posF3[1]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->pos_posF3[1]);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->pos_posF3[2]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->pos_posF3[2]);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "strength") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "strength");
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->strength) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->strength);
return -1;
}
}
break;
}
case EVENT_UNIT_CAPTURED: {
ei_x_encode_atom(sendbuf, "event_unit_captured");
struct SUnitCapturedEvent* event_data = (struct SUnitCapturedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 6);
{
if (ei_x_encode_atom(sendbuf, "unitid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unitid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unitId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unitId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "oldteamid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "oldteamid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->oldTeamId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->oldTeamId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "newteamid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "newteamid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->newTeamId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->newTeamId);
return -1;
}
}
break;
}
case EVENT_UNIT_CREATED: {
ei_x_encode_atom(sendbuf, "event_unit_created");
struct SUnitCreatedEvent* event_data = (struct SUnitCreatedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 4);
{
if (ei_x_encode_atom(sendbuf, "unit") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unit");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unit) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unit);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "builder") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "builder");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->builder) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->builder);
return -1;
}
}
break;
}
case EVENT_UNIT_DAMAGED: {
ei_x_encode_atom(sendbuf, "event_unit_damaged");
struct SUnitDamagedEvent* event_data = (struct SUnitDamagedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 12);
{
if (ei_x_encode_atom(sendbuf, "unit") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unit");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unit) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unit);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "attacker") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "attacker");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->attacker) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->attacker);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "damage") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "damage");
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->damage) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->damage);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "dir_posf3") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "dir_posf3");
return -1;
}
if (ei_x_encode_tuple_header(sendbuf, 3) < 0) {
fprintf(stderr, "cannot encode '%i' as 'tuple_header'\n", 3);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->dir_posF3[0]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->dir_posF3[0]);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->dir_posF3[1]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->dir_posF3[1]);
return -1;
}
if (ei_x_encode_double(sendbuf, event_data->dir_posF3[2]) < 0) {
fprintf(stderr, "cannot encode '%f' as 'double'\n", event_data->dir_posF3[2]);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "weapondefid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "weapondefid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->weaponDefId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->weaponDefId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "paralyzer") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "paralyzer");
return -1;
}
if (ei_x_encode_atom(sendbuf, event_data->paralyzer ? "true" : "false") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", event_data->paralyzer ? "true" : "false");
return -1;
}
}
break;
}
case EVENT_UNIT_DESTROYED: {
ei_x_encode_atom(sendbuf, "event_unit_destroyed");
struct SUnitDestroyedEvent* event_data = (struct SUnitDestroyedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 4);
{
if (ei_x_encode_atom(sendbuf, "unit") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unit");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unit) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unit);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "attacker") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "attacker");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->attacker) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->attacker);
return -1;
}
}
break;
}
case EVENT_UNIT_FINISHED: {
ei_x_encode_atom(sendbuf, "event_unit_finished");
struct SUnitFinishedEvent* event_data = (struct SUnitFinishedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "unit") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unit");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unit) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unit);
return -1;
}
}
break;
}
case EVENT_UNIT_GIVEN: {
ei_x_encode_atom(sendbuf, "event_unit_given");
struct SUnitGivenEvent* event_data = (struct SUnitGivenEvent*)data;
ei_x_encode_tuple_header(sendbuf, 6);
{
if (ei_x_encode_atom(sendbuf, "unitid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unitid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unitId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unitId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "oldteamid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "oldteamid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->oldTeamId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->oldTeamId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "newteamid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "newteamid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->newTeamId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->newTeamId);
return -1;
}
}
break;
}
case EVENT_UNIT_IDLE: {
ei_x_encode_atom(sendbuf, "event_unit_idle");
struct SUnitIdleEvent* event_data = (struct SUnitIdleEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "unit") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unit");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unit) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unit);
return -1;
}
}
break;
}
case EVENT_UNIT_MOVE_FAILED: {
ei_x_encode_atom(sendbuf, "event_unit_move_failed");
struct SUnitMoveFailedEvent* event_data = (struct SUnitMoveFailedEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "unit") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unit");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unit) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unit);
return -1;
}
}
break;
}
case EVENT_UPDATE: {
ei_x_encode_atom(sendbuf, "event_update");
struct SUpdateEvent* event_data = (struct SUpdateEvent*)data;
ei_x_encode_tuple_header(sendbuf, 2);
{
if (ei_x_encode_atom(sendbuf, "frame") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "frame");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->frame) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->frame);
return -1;
}
}
break;
}
case EVENT_WEAPON_FIRED: {
ei_x_encode_atom(sendbuf, "event_weapon_fired");
struct SWeaponFiredEvent* event_data = (struct SWeaponFiredEvent*)data;
ei_x_encode_tuple_header(sendbuf, 4);
{
if (ei_x_encode_atom(sendbuf, "unitid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "unitid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->unitId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->unitId);
return -1;
}
}
{
if (ei_x_encode_atom(sendbuf, "weapondefid") < 0) {
fprintf(stderr, "cannot encode '%s' as 'atom'\n", "weapondefid");
return -1;
}
if (ei_x_encode_long(sendbuf, event_data->weaponDefId) < 0) {
fprintf(stderr, "cannot encode '%i' as 'long'\n", event_data->weaponDefId);
return -1;
}
}
break;
}
default: {
ei_x_encode_long(sendbuf, topic);
ei_x_encode_binary(sendbuf, data, sizeof(data));
}
}
return 0;
}
int
joo_write (int fd,
JooTerm *terms)
{
int ret = 0;
ei_x_buff buf;
if (joo_term_count_children (terms) < 0)
return -1;
if (ei_x_new_with_version (&buf)) {
errno = ENOMEM;
return -1;
}
for (JooTerm *term = terms; term->type != JOO_END; term++) {
if (term->push) {
errno = EINVAL;
return -1;
}
switch (term->type) {
case JOO_ATOM:
if (ei_x_encode_atom (&buf, term->value.text)) {
errno = ENOMEM;
return -1;
}
break;
case JOO_STRING:
if (ei_x_encode_string (&buf, term->value.text)) {
errno = ENOMEM;
return -1;
}
break;
case JOO_BINARY:
if (ei_x_encode_binary (&buf, term->value.binary.data,
term->value.binary.size)) {
errno = ENOMEM;
return -1;
}
break;
case JOO_TUPLE_START:
if (ei_x_encode_tuple_header (&buf, term->num_children)) {
errno = ENOMEM;
return -1;
}
break;
case JOO_TUPLE_END:
break;
default:
abort ();
}
}
if (write_ei_x_buff (fd, &buf) < 0) {
errno = EIO;
ret = -1;
}
ei_x_free (&buf);
return ret;
}
int main(void)
#endif
{
ErlConnect conp;
Erl_IpAddr thisipaddr = (Erl_IpAddr)0;
FILE *fp = (FILE *)0;
char* charp = "foo";
double *doublep = NULL;
double doublex = 0.0;
ei_cnode xec;
ei_reg *ei_regp = NULL;
ei_term eterm;
ei_x_buff eix;
erlang_big *bigp = NULL;
erlang_fun efun;
erlang_msg *msgp = NULL;
erlang_msg emsg;
erlang_pid *pidp = NULL;
erlang_pid epid;
erlang_port eport;
erlang_ref eref;
erlang_trace etrace;
int *intp = NULL;
int intx = 0;
long *longp = NULL;
long longx = 0;
short creation = 0;
struct ei_reg_stat *ei_reg_statp = NULL;
struct ei_reg_tabstat *ei_reg_tabstatp = NULL;
struct hostent *hostp = NULL;
unsigned char * ucharp = (unsigned char *)"foo";
unsigned long *ulongp = NULL;
unsigned long ulongx = 0;
void *voidp = NULL;
#ifndef VXWORKS
EI_LONGLONG *longlongp = (EI_LONGLONG*)NULL;
EI_LONGLONG longlongx = 0;
EI_ULONGLONG *ulonglongp = (EI_ULONGLONG*)NULL;
EI_ULONGLONG ulonglongx = 0;
#endif
enum erlang_char_encoding enc;
intx = erl_errno;
ei_connect_init(&xec, charp, charp, creation);
ei_connect_xinit (&xec, charp, charp, charp, thisipaddr, charp, creation);
ei_connect(&xec, charp);
ei_xconnect (&xec, thisipaddr, charp);
ei_receive(intx, ucharp, intx);
ei_receive_msg(intx, &emsg, &eix);
ei_xreceive_msg(intx, &emsg, &eix);
ei_send(intx, &epid, charp, intx);
ei_reg_send(&xec, intx, charp, charp, intx);
ei_rpc(&xec, intx, charp, charp, charp, intx, &eix);
ei_rpc_to(&xec, intx, charp, charp, charp, intx);
ei_rpc_from(&xec, intx, intx, &emsg, &eix);
ei_publish(&xec, intx);
ei_accept(&xec, intx, &conp);
ei_unpublish(&xec);
ei_thisnodename(&xec);
ei_thishostname(&xec);
ei_thisalivename(&xec);
ei_self(&xec);
ei_gethostbyname(charp);
ei_gethostbyaddr(charp, intx, intx);
ei_gethostbyname_r(charp, hostp, charp, intx, intp);
ei_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
ei_encode_version(charp, intp);
ei_x_encode_version(&eix);
ei_encode_long(charp, intp, longx);
ei_x_encode_long(&eix, longx);
ei_encode_ulong(charp, intp, ulongx);
ei_x_encode_ulong(&eix, ulongx);
ei_encode_double(charp, intp, doublex);
ei_x_encode_double(&eix, doublex);
ei_encode_boolean(charp, intp, intx);
ei_x_encode_boolean(&eix, intx);
ei_encode_char(charp, intp, 'a');
ei_x_encode_char(&eix, 'a');
ei_encode_string(charp, intp, charp);
ei_encode_string_len(charp, intp, charp, intx);
ei_x_encode_string(&eix, charp);
ei_x_encode_string_len(&eix, charp, intx);
ei_encode_atom(charp, intp, charp);
ei_encode_atom_as(charp, intp, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_atom_len(charp, intp, charp, intx);
ei_encode_atom_len_as(charp, intp, charp, intx, ERLANG_ASCII, ERLANG_LATIN1);
ei_x_encode_atom(&eix, charp);
ei_x_encode_atom_as(&eix, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_x_encode_atom_len(&eix, charp, intx);
ei_x_encode_atom_len_as(&eix, charp, intx, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_binary(charp, intp, (void *)0, longx);
ei_x_encode_binary(&eix, (void*)0, intx);
ei_encode_pid(charp, intp, &epid);
ei_x_encode_pid(&eix, &epid);
ei_encode_fun(charp, intp, &efun);
ei_x_encode_fun(&eix, &efun);
ei_encode_port(charp, intp, &eport);
ei_x_encode_port(&eix, &eport);
ei_encode_ref(charp, intp, &eref);
ei_x_encode_ref(&eix, &eref);
ei_encode_trace(charp, intp, &etrace);
ei_x_encode_trace(&eix, &etrace);
ei_encode_tuple_header(charp, intp, intx);
ei_x_encode_tuple_header(&eix, longx);
ei_encode_list_header(charp, intp, intx);
ei_x_encode_list_header(&eix, longx);
/* #define ei_encode_empty_list(buf,i) ei_encode_list_header(buf,i,0) */
ei_x_encode_empty_list(&eix);
ei_get_type(charp, intp, intp, intp);
ei_get_type_internal(charp, intp, intp, intp);
ei_decode_version(charp, intp, intp);
ei_decode_long(charp, intp, longp);
ei_decode_ulong(charp, intp, ulongp);
ei_decode_double(charp, intp, doublep);
ei_decode_boolean(charp, intp, intp);
ei_decode_char(charp, intp, charp);
ei_decode_string(charp, intp, charp);
ei_decode_atom(charp, intp, charp);
ei_decode_atom_as(charp, intp, charp, MAXATOMLEN_UTF8, ERLANG_WHATEVER, &enc, &enc);
ei_decode_binary(charp, intp, (void *)0, longp);
ei_decode_fun(charp, intp, &efun);
free_fun(&efun);
ei_decode_pid(charp, intp, &epid);
ei_decode_port(charp, intp, &eport);
ei_decode_ref(charp, intp, &eref);
ei_decode_trace(charp, intp, &etrace);
ei_decode_tuple_header(charp, intp, intp);
ei_decode_list_header(charp, intp, intp);
ei_decode_ei_term(charp, intp, &eterm);
ei_print_term(fp, charp, intp);
ei_s_print_term(&charp, charp, intp);
ei_x_format(&eix, charp);
ei_x_format_wo_ver(&eix, charp);
ei_x_new(&eix);
ei_x_new_with_version(&eix);
ei_x_free(&eix);
ei_x_append(&eix, &eix);
ei_x_append_buf(&eix, charp, intx);
ei_skip_term(charp, intp);
ei_reg_open(intx);
ei_reg_resize(ei_regp, intx);
ei_reg_close(ei_regp);
ei_reg_setival(ei_regp, charp, longx);
ei_reg_setfval(ei_regp, charp, doublex);
ei_reg_setsval(ei_regp, charp, charp);
ei_reg_setpval(ei_regp, charp, voidp, intx);
ei_reg_setval(ei_regp, charp, intx);
ei_reg_getival(ei_regp, charp);
ei_reg_getfval(ei_regp, charp);
ei_reg_getsval(ei_regp, charp);
ei_reg_getpval(ei_regp, charp, intp);
ei_reg_getval(ei_regp, charp, intx);
ei_reg_markdirty(ei_regp, charp);
ei_reg_delete(ei_regp, charp);
ei_reg_stat(ei_regp, charp, ei_reg_statp);
ei_reg_tabstat(ei_regp, ei_reg_tabstatp);
ei_reg_dump(intx, ei_regp, charp, intx);
ei_reg_restore(intx, ei_regp, charp);
ei_reg_purge(ei_regp);
#if defined(HAVE_GMP_H) && defined(HAVE_LIBGMP)
{
mpz_t obj;
ei_decode_bignum(charp, intp, obj);
ei_encode_bignum(charp, intp, obj);
ei_x_encode_bignum(&eix, obj);
}
#endif /* HAVE_GMP_H && HAVE_LIBGMP */
#ifndef VXWORKS
ei_decode_longlong(charp, intp, longlongp);
ei_decode_ulonglong(charp, intp, ulonglongp);
ei_encode_longlong(charp, intp, longlongx);
ei_encode_ulonglong(charp, intp, ulonglongx);
ei_x_encode_longlong(&eix, longlongx);
ei_x_encode_ulonglong(&eix, ulonglongx);
#endif
#ifdef USE_EI_UNDOCUMENTED
ei_decode_intlist(charp, intp, longp, intp);
ei_receive_encoded(intx, &charp, intp, msgp, intp);
ei_send_encoded(intx, pidp, charp, intx);
ei_send_reg_encoded(intx, pidp, charp, charp, intx);
ei_decode_big(charp, intp, bigp);
ei_big_comp(bigp, bigp);
ei_big_to_double(bigp, doublep);
ei_small_to_big(intx, bigp);
ei_alloc_big(intx);
ei_free_big(bigp);
#endif /* USE_EI_UNDOCUMENTED */
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EIO +
EI_BIN +
EI_DELET +
EI_DIRTY +
EI_FLT +
EI_FORCE +
EI_INT +
EI_NOPURGE +
EI_STR +
EMSGSIZE +
ENOMEM +
ERL_ERROR +
ERL_EXIT +
ERL_LINK +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_REG_SEND +
ERL_SEND +
ERL_TICK +
ERL_TIMEOUT +
ERL_UNLINK +
ETIMEDOUT +
MAXATOMLEN;
}
static int accept_sec_context(char *buf, int index, ei_x_buff *presult)
{
ei_x_buff result = *presult;
/*
{accept_sec_context, {Idx, In}} ->
{ok, {Idx, Name, CCName, Out}} |
{needsmore, {Idx, Out}}
*/
int arity;
gss_buffer_desc in;
gss_buffer_desc out;
gss_buffer_desc name;
int res;
char *ccname = NULL;
long idx;
OM_uint32 min_stat;
memset(&in, 0, sizeof(in));
memset(&out, 0, sizeof(out));
memset(&name, 0, sizeof(name));
EI(ei_decode_tuple_header(buf, &index, &arity));
EI(arity != 2);
EI(ei_decode_long(buf, &index, &idx));
EI(decode_gssapi_binary(buf, &index, &in));
if (idx < 0) {
idx = session_find_free();
if (idx < 0) ENCODE_ERROR("no_mem");
g_sessions[idx] = GSS_C_NO_CONTEXT;
} else {
if (idx < 0 || idx >= MAX_SESSIONS || !g_sessions[idx])
ENCODE_ERROR("bad_instance");
}
res = accept_user(&g_sessions[idx], &in, &out, &name, &ccname);
if (!GSS_ERROR(res)) {
if (res & GSS_S_CONTINUE_NEEDED) {
EI(ei_x_encode_atom(&result, "needsmore") ||
ei_x_encode_tuple_header(&result, 2) ||
ei_x_encode_long(&result, idx) ||
ei_x_encode_binary(&result, out.value, out.length)
);
} else {
const char *ret_ccname = ccname;
if (!ret_ccname)
ret_ccname = "";
EI(ei_x_encode_atom(&result, "ok") ||
ei_x_encode_tuple_header(&result, 4) ||
ei_x_encode_long(&result, idx) ||
ei_x_encode_string_len(&result, name.value, name.length) ||
ei_x_encode_string(&result, ret_ccname) ||
ei_x_encode_binary(&result, out.value, out.length)
);
}
} else {
EI(ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "unauthorized"));
}
error:
if (ccname)
free(ccname);
if (in.value)
gss_release_buffer(&min_stat, &in);
if (out.value)
gss_release_buffer(&min_stat, &out);
if (name.value)
gss_release_buffer(&min_stat, &name);
*presult = result;
return 0;
}
int srdb1_encode_kv(int tupsize,const db_key_t* _k, const db_op_t* _op, const db_val_t* _v,
const int _n, ei_x_buff *argbuf) {
int i;
struct tm* tt;
time_t t_t;
if(_k) {
ei_x_encode_list_header(argbuf, _n);
for(i = 0; i < _n; i++) {
db_val_t *vv;
ei_x_encode_tuple_header(argbuf, tupsize);
ei_x_encode_atom_len(argbuf,_k[i]->s,_k[i]->len);
if(tupsize == 3 ) {
if (_op) {
ei_x_encode_atom(argbuf,_op[i]);
} else {
ei_x_encode_atom(argbuf,"=");
}
}
vv=&(_v[i]);
if (VAL_NULL(vv)) {
ei_x_encode_atom(argbuf,"undefined");
} else {
switch(VAL_TYPE(vv)) {
case DB1_INT:
ei_x_encode_ulong(argbuf, VAL_INT(vv));
break;
case DB1_BIGINT:
ei_x_encode_longlong(argbuf, VAL_BIGINT(vv));
break;
case DB1_DOUBLE:
ei_x_encode_double(argbuf, VAL_DOUBLE(vv));
break;
case DB1_STRING:
ei_x_encode_string(argbuf,VAL_STRING(vv));
break;
case DB1_STR:
ei_x_encode_string_len(argbuf,VAL_STR(vv).s,VAL_STR(vv).len);
break;
case DB1_DATETIME:
t_t=VAL_TIME(vv);
tt= localtime(&t_t);
ei_x_encode_tuple_header(argbuf, 2);
ei_x_encode_tuple_header(argbuf, 3);
ei_x_encode_long(argbuf, tt->tm_year + 1900);
ei_x_encode_long(argbuf, tt->tm_mon +1);
ei_x_encode_long(argbuf, tt->tm_mday);
ei_x_encode_tuple_header(argbuf, 3);
ei_x_encode_long(argbuf, tt->tm_hour);
ei_x_encode_long(argbuf, tt->tm_min);
ei_x_encode_long(argbuf, tt->tm_sec);
break;
case DB1_BLOB:
ei_x_encode_binary(argbuf,VAL_BLOB(vv).s,VAL_BLOB(vv).len);
break;
case DB1_BITMAP:
ei_x_encode_ulong(argbuf,VAL_BITMAP(vv));
break;
}
}
}
ei_x_encode_empty_list(argbuf);
} else {
ei_x_encode_list_header(argbuf, 0);
}
return 0;
}
