void reply_avframe(AVPacket *pkt, AVCodec *codec) {
ei_x_buff x;
ei_x_new_with_version(&x);
struct video_frame r;
r.content = codec->type == AVMEDIA_TYPE_VIDEO ? frame_content_video :
codec->type == AVMEDIA_TYPE_AUDIO ? frame_content_audio : 0;
r.dts = pkt->dts / 90.0;
r.pts = pkt->pts / 90.0;
r.stream_id = 0;
r.codec = codec->id == AV_CODEC_ID_H264 ? frame_codec_h264 :
codec->id == AV_CODEC_ID_AAC ? frame_codec_aac : 0;
r.flavor = pkt->flags & CODEC_FLAG_GLOBAL_HEADER ? frame_flavor_config :
pkt->flags & AV_PKT_FLAG_KEY ? frame_flavor_keyframe :
frame_flavor_frame;
r.track_id = codec->type == AVMEDIA_TYPE_VIDEO ? 1 : 2;
r.body.data = pkt->data;
r.body.size = pkt->size;
write_video_frame(&x, r);
write_x(&x);
ei_x_free(&x);
}
static void send_atom(ErlDrvPort port, const char *str) {
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_atom(&x, str);
driver_output(port, x.buff, x.index);
ei_x_free(&x);
}
int gn_start_cnode(char **argv) {
extern ei_cnode ec;
char rem_node_name[MAXATOMLEN] = ""; /* other node name */
ei_x_buff xbuf;
erlang_pid *self = ei_self(&ec);
strcat(rem_node_name,REMNODE);
strcat(rem_node_name,"@");
strcat(rem_node_name,REMHOST);
rem_regname = g_strdup(REMREG);
g_print("I am %s, you are %s (%d)\n", NODE_NAME, rem_node_name, ERL_DIST_VSN);
ei_set_compat_rel(ERL_DIST_VSN); /* erlnode version of dist. protocol */
if ( ei_connect_init(&ec, NODE_NAME, COOKIE, CREATION) < 0 )
g_critical("ei_connect_init");
if ( (fd = ei_connect(&ec, rem_node_name)) < 0 )
g_critical("ei_connect failed.\nwrong cookie? erl-dist version mismatch?");
self->num = fd; /* bug?? in ei_reg_send_tmo */
ei_x_new_with_version(&xbuf);
gn_wrap_ans("handshake", &xbuf);
ei_x_encode_empty_list(&xbuf);
gn_send(&xbuf);
ei_x_free(&xbuf);
return fd;
}
/*
* Sends an Erlang message to a process at an Erlang node
*/
int erl_send(int fd, ETERM *to ,ETERM *msg)
{
erlang_pid topid;
ei_x_buff x;
int r;
ei_x_new_with_version(&x);
ei_x_encode_term(&x, msg);
/* make the to-pid */
if (!ERL_IS_PID(to)) {
ei_x_free(&x);
erl_errno = EINVAL;
return -1;
}
if (to->uval.pidval.node.latin1) {
strcpy(topid.node, to->uval.pidval.node.latin1);
}
else {
strcpy(topid.node, to->uval.pidval.node.utf8);
}
topid.num = ERL_PID_NUMBER(to);
topid.serial = ERL_PID_SERIAL(to);
topid.creation = ERL_PID_CREATION(to);
r = ei_send(fd, &topid, x.buff, x.index);
ei_x_free(&x);
return r == 0;
}
bool CCESUT::TradeOrder(PTradeOrderTxnInput pTxnInput,
INT32 iTradeType, bool bExecutorIsAccountOwner) {
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x, 2);
{
ei_x_encode_atom(&x, "ok");
ei_x_encode_tuple_header(&x, 2);
{
ei_x_encode_atom(&x, APP ".BH.TO");
ei_x_encode_tuple_header(&x, 3);
{
m_Encoder.encode(&x, "trade_type", iTradeType);
m_Encoder.encode(&x, "executor_is_account_owner", bExecutorIsAccountOwner);
m_Encoder.encode(&x, *pTxnInput);
}
}
}
int result = driver_output(m_ErlDrvPort, x.buff, x.index);
#ifdef _TRACE
cout << "[TO] ! " << *pTxnInput << ", result=" << result << '\r' << endl;
#endif
ei_x_free(&x);
return result;
}
/* called from gtk main loop when there's data on the cnode socket */
gboolean gn_handle_read(GIOChannel *source,GIOCondition cond,gpointer data){
erlang_msg msg;
ei_x_buff xbuf;
/* fd = g_io_channel_unix_get_fd(source); */
ei_x_new_with_version(&xbuf);
switch ( ei_xreceive_msg(fd, &msg, &xbuf) ){
case ERL_TICK:
break; /* ignore */
case ERL_MSG:
switch (msg.msgtype) {
case ERL_SEND:
case ERL_REG_SEND:
reply(&msg, &xbuf);
break;
case ERL_LINK:
case ERL_UNLINK:
case ERL_GROUP_LEADER:
break; /* ignore */
case ERL_EXIT:
case ERL_EXIT2:
case ERL_NODE_LINK:
gtk_main_quit(); /* crash and burn */
return FALSE;
}
break;
case ERL_ERROR:
gtk_main_quit(); /* crash and burn */
return FALSE;
}
ei_x_free(&xbuf);
return TRUE;
}
bool CCESUT::MarketWatch(PMarketWatchTxnInput pTxnInput) {
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x, 2);
{
ei_x_encode_atom(&x, "ok");
ei_x_encode_tuple_header(&x, 2);
{
ei_x_encode_atom(&x, APP ".BH.MW");
m_Encoder.encode(&x, *pTxnInput);
}
}
int result = driver_output(m_ErlDrvPort, x.buff, x.index);
#ifdef _TRACE
cout << "[MW] ! " << *pTxnInput << ", result=" << result << '\r' << endl;
#endif
ei_x_free(&x);
return result;
}
bool CDMSUT::TradeCleanup(PTradeCleanupTxnInput pTxnInput) {
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x, 2);
{
ei_x_encode_atom(&x, "ok");
ei_x_encode_tuple_header(&x, 2);
{
ei_x_encode_atom(&x, APP ".BH.TC");
m_Encoder.encode(&x, *pTxnInput);
}
}
int result = driver_output(m_ErlDrvPort, x.buff, x.index);
#ifdef _TRACE
cout << "[TC] ! " << *pTxnInput << ", result=" << result << '\r' << endl;
#endif
ei_x_free(&x);
return result;
}
/*
* Now returns non-negative number for success, negative for failure.
*/
int ei_rpc_to(ei_cnode *ec, int fd, char *mod, char *fun,
const char *buf, int len)
{
ei_x_buff x;
erlang_pid *self = ei_self(ec);
self->num = fd;
/* encode header */
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x, 2); /* A */
self->num = fd;
ei_x_encode_pid(&x, self); /* A 1 */
ei_x_encode_tuple_header(&x, 5); /* B A 2 */
ei_x_encode_atom(&x, "call"); /* B 1 */
ei_x_encode_atom(&x, mod); /* B 2 */
ei_x_encode_atom(&x, fun); /* B 3 */
ei_x_append_buf(&x, buf, len); /* B 4 */
ei_x_encode_atom(&x, "user"); /* B 5 */
/* ei_x_encode_atom(&x,"user"); */
ei_send_reg_encoded(fd, self, "rex", x.buff, x.index);
ei_x_free(&x);
return 0;
} /* rpc_to */
static int
current_tree_finished(struct exmpp_xml_ctx *ctx)
{
ei_x_buff *trees;
trees = ctx->complete_trees;
if (trees == NULL) {
/* Allocate the complete trees list. */
trees = driver_alloc(sizeof(*trees));
if (trees == NULL)
return (-1);
ei_x_new_with_version(trees);
ctx->complete_trees = trees;
}
/* Append the current tree to the complete trees list. */
ei_x_encode_list_header(trees, 1);
ei_x_append(trees, ctx->current_tree);
ctx->complete_trees_ready = 1;
/* Reset the current tree. */
reset_current_tree(ctx);
return (0);
}
void
epcap_response(u_char *user, const struct pcap_pkthdr *hdr, const u_char *pkt)
{
EPCAP_STATE *ep = (EPCAP_STATE *)user;
ei_x_buff msg = {0};
IS_FALSE(ei_x_new_with_version(&msg));
/* {packet, DatalinkType, Time, ActualLength, Packet} */
IS_FALSE(ei_x_encode_tuple_header(&msg, 5));
IS_FALSE(ei_x_encode_atom(&msg, "packet"));
/* DataLinkType */
IS_FALSE(ei_x_encode_long(&msg, ep->datalink));
/* {MegaSec, Sec, MicroSec} */
IS_FALSE(ei_x_encode_tuple_header(&msg, 3));
IS_FALSE(ei_x_encode_long(&msg, abs(hdr->ts.tv_sec / 1000000)));
IS_FALSE(ei_x_encode_long(&msg, hdr->ts.tv_sec % 1000000));
IS_FALSE(ei_x_encode_long(&msg, hdr->ts.tv_usec));
/* ActualLength} */
IS_FALSE(ei_x_encode_long(&msg, hdr->len));
/* Packet */
IS_FALSE(ei_x_encode_binary(&msg, pkt, hdr->caplen));
/* } */
epcap_send_free(&msg);
}
void reply_atom(char *a) {
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_atom(&x, a);
write_x(&x);
ei_x_free(&x);
}
static void cmd_ei_send_funs(char* buf, int len)
{
int index = 0, n;
long fd;
erlang_pid pid;
ei_x_buff x;
erlang_fun fun1, fun2;
if (ei_decode_long(buf, &index, &fd) < 0)
fail("expected long");
if (ei_decode_pid(buf, &index, &pid) < 0)
fail("expected pid (node)");
if (ei_decode_tuple_header(buf, &index, &n) < 0)
fail("expected tuple");
if (n != 2)
fail("expected tuple");
if (ei_decode_fun(buf, &index, &fun1) < 0)
fail("expected Fun1");
if (ei_decode_fun(buf, &index, &fun2) < 0)
fail("expected Fun2");
if (ei_x_new_with_version(&x) < 0)
fail("ei_x_new_with_version");
if (ei_x_encode_tuple_header(&x, 2) < 0)
fail("encode tuple header");
if (ei_x_encode_fun(&x, &fun1) < 0)
fail("encode fun1");
if (ei_x_encode_fun(&x, &fun2) < 0)
fail("encode fun2");
free_fun(&fun1);
free_fun(&fun2);
send_errno_result(ei_send(fd, &pid, x.buff, x.index));
ei_x_free(&x);
}
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;
}
void handle_winch(int sig){
ei_x_buff eixb;
ei_x_new_with_version(&eixb);
tuple(&eixb, 2);
atom(&eixb, "sigwinch", 8);
atom(&eixb, "sigwinch", 8);
driver_output(stpt->drv_port, eixb.buff, eixb.index);
}
static void send_hash(ErlDrvPort port, unsigned long hash) {
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_ulong(&x, hash);
driver_output(port, x.buff, x.index);
// printf("sent hash %d\n", hash);
ei_x_free(&x);
}
static void do_getch(ErlDrvData drvstate, ErlDrvEvent event) {
state *st = (state *)drvstate;
ei_x_buff eixb;
int keycode;
ei_x_new_with_version(&eixb);
keycode = getch();
integer(&eixb, keycode);
driver_output(st->drv_port, eixb.buff, eixb.index);
}
static inline void init(State* p, int options) {
p->li_stack = p->li_sp = 0;
p->li_stack_size = 0;
ei_x_new_with_version(&p->ei_buf);
p->skip_list_header_for_value = -1;
p->options = options;
}
/*-----------------------------------------------------------------
* MAIN
*----------------------------------------------------------------*/
int main(int argc, char *argv[])
{
byte* buf;
int size = BUF_SIZE;
if (argc > 1) {
test(argc, argv);
return 0;
}
fprintf(stderr, "gssapi started\r\n");
if ((buf = malloc(size)) == NULL)
return -1;
while ( (buf = read_cmd(buf, &size)) ) {
int res = 0;
int index = 0;
int version, arity;
char command[MAXATOMLEN];
ei_x_buff result;
port_func func;
/* Ensure that we are receiving the binary term by reading and
* stripping the version byte */
EI(ei_decode_version(buf, &index, &version));
/* Our marshalling spec is that we are expecting a tuple {Command, Arg1} */
EI(ei_decode_tuple_header(buf, &index, &arity));
EI(arity != 2);
EI(ei_decode_atom(buf, &index, command));
/* Prepare the output buffer that will hold {ok, Result} or {error, Reason} */
EI(ei_x_new_with_version(&result) || ei_x_encode_tuple_header(&result, 2));
/* fprintf(stderr, "command: %s\r\n", command); */
func = lookup_func(command);
if (func) {
res = func(buf, index, &result);
} else {
EI(ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "unsupported_command"));
}
write_cmd(&result);
ei_x_free(&result);
}
/* error: */
fprintf(stderr, "No more command, exiting\r\n");
return 0;
}
void Client::sendMessage(QByteArray procName, QVariant value)
{
ei_x_buff x;
ei_x_new_with_version(&x);
encode(value, &x);
ei_reg_send(m_ec, m_fd, procName.data(), x.buff, x.index);
ei_x_free(&x);
}
static void
ok() {
ei_x_buff result;
check(ei_x_new_with_version(&result));
check(ei_x_encode_atom(&result, "ok"));
write_cmd(&result);
ei_x_free(&result);
}
static void send_errno_result(int value)
{
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x, 2);
ei_x_encode_long(&x, value);
ei_x_encode_long(&x, erl_errno);
send_bin_term(&x);
ei_x_free(&x);
}
// =============================================================================
// Utility functions
// =============================================================================
void init_state(state *st, char *args, int argslen) {
st->index = 0;
st->version = 0;
st->args = args;
st->argslen = argslen;
ei_decode_version(st->args, &(st->index), &(st->version));
assert(st->version != 0);
assert(st->index != 0);
ei_x_new_with_version(&(st->eixb));
}
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;
}
void epcap_ctrl(const char *ctrl_evt)
{
ei_x_buff msg;
IS_FALSE(ei_x_new_with_version(&msg));
IS_FALSE(ei_x_encode_tuple_header(&msg, 2));
IS_FALSE(ei_x_encode_atom(&msg, "epcap"));
IS_FALSE(ei_x_encode_atom(&msg, ctrl_evt));
epcap_send_free(&msg);
}
void Client::sendPid(QByteArray procName)
{
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_pid(&x, &(m_ec->self));
ei_reg_send(m_ec, m_fd, procName.data(), x.buff, x.index);
ei_x_free(&x);
}
static void reply(erlang_msg *msg, ei_x_buff *recv_x_buf) {
int i = 0;
int version;
ei_x_buff xbuf;
ei_decode_version(recv_x_buf->buff, &i, &version);
ei_x_new_with_version(&xbuf);
make_reply_list(&xbuf, recv_x_buf->buff, &i);
gn_send(&xbuf);
ei_x_free(&xbuf);
}
static void has(bloom_drv_t *driver, char *buf, int len) {
int result;
ei_x_buff x;
result = bloom_has(driver->bloom, buf, len);
ei_x_new_with_version(&x);
ei_x_encode_boolean(&x, result);
driver_output(driver->port, x.buff, x.index);
ei_x_free(&x);
}
static void key_size(bloom_drv_t *driver) {
long result;
ei_x_buff x;
result = bloom_key_size(driver->bloom);
ei_x_new_with_version(&x);
ei_x_encode_long(&x, result);
driver_output(driver->port, x.buff, x.index);
ei_x_free(&x);
}
void json_parse_to_ei(ErlDrvData session, const unsigned char* s, int len, int opts) {
int parseValue = opts & EEP0018_PARSE_VALUE;
unsigned char* yajl_msg = 0;
unsigned char* msg = 0;
ErlDrvPort port = (ErlDrvPort) session;
/*
* initialize yajl parser
*/
State state;
init(&state, opts);
yajl_parser_config conf = { YAJL_ALLOW_COMMENTS }; // , YAJL_CHECK_UTF8 };
yajl_handle handle = yajl_alloc(&callbacks, &conf, &state);
/* start parser */
yajl_status stat;
if(parseValue) stat = yajl_parse(handle, (const unsigned char*) "[ ", 2);
stat = yajl_parse(handle, s, len);
if(parseValue) stat = yajl_parse(handle, (const unsigned char*) " ]", 2);
/*
* sometimes the parser is still stuck inside a JSON token. This finishs
* the token no matter what.
*/
if(stat == yajl_status_insufficient_data)
stat = yajl_parse(handle, (const unsigned char*) " ", 1);
/*
* get an error message on errors
*/
switch(stat) {
case yajl_status_ok: break;
case yajl_status_insufficient_data:
msg = (unsigned char*)"Insufficient data";
break;
default:
msg = yajl_msg = yajl_get_error(handle, 0, s, len);
break;
}
/*
* if result is not ok: we write {error, "reason"} instead. This is
* something that will never be encoded from any JSON data.
*/
if(msg) {
ei_x_free(&state.ei_buf);
ei_x_new_with_version(&state.ei_buf);
ei_x_encode_tuple_header(&state.ei_buf, 2);
ei_x_encode_atom_len(&state.ei_buf, "error", 5);
ei_x_encode_string_len(&state.ei_buf, (const char*) msg, strlen((const char*) msg));
if(yajl_msg) yajl_free_error(yajl_msg);
}
send_data(port, EEP0018_EI, state.ei_buf.buff, state.ei_buf.index);
deinit(&state);
}
