int main()
{
int msg_id = msg_create(); //ser
if(msg_id < 0)
{
return 1;
}
char buf[G_SIZE];
while(1)
{
buf[G_SIZE - 1] = '\0';
int ret = msg_recv(msg_id, buf, sizeof(buf)-1, DATA_TYPE_CLI);
if(strncasecmp("quite", buf, 4) == 0)
{ break;}
printf("cli:> %s\n", buf);
printf("plase Enter:");
fflush(stdout);
memset(buf, '\0', sizeof(buf));
fgets(buf, sizeof(buf)-1, stdin);
ret = msg_send(msg_id, buf, DATA_TYPE_SER);
}
int ret = msg_destroy(msg_id);
return 0;
}
int8_t uart_startTransceiverRx( uint8_t rx_len, uint8_t flags) {
if (state[RX].state != UART_IDLE) {
return -EBUSY;
}
state[RX].flags = UART_SYS_SHARED_FLAGS_MSK & flags; // get shared flags
if (flags & UART_SOS_MSG_FLAG) {
state[RX].msgHdr = msg_create();
if (state[RX].msgHdr == NULL) {
return -ENOMEM;
}
} else {
state[RX].buff = ker_malloc(rx_len, UART_PID);
if (state[RX].buff == NULL) {
return -ENOMEM;
}
}
state[RX].msgLen = rx_len; // expected rx_len
state[RX].idx = 0;
state[RX].crc = 0;
state[RX].state = UART_HDLC_START;
state[RX].hdlc_state = HDLC_START;
uart_enable_rx();
return SOS_OK;
}
//----------------------------------------------------------------------------
// Funcation declarations
//----------------------------------------------------------------------------
// Post a message with no payload
int8_t post_short(sos_pid_t did, sos_pid_t sid, uint8_t type, uint8_t byte,
uint16_t word, uint16_t flag)
{
Message *m = msg_create();
MsgParam *p;
if(m == NULL){
return -ENOMEM;
}
m->daddr = node_address;
m->did = did;
m->type = type;
m->saddr = node_address;
m->sid = sid;
m->len = 3;
#ifdef SOS_USE_PREEMPTION
// assign priority based on did
m->priority = get_module_priority(did);
#endif
p = (MsgParam*)(m->payload);
p->byte = byte;
p->word = word;
m->flag = flag & ((sos_ker_flag_t)(~SOS_MSG_RELEASE));
sched_msg_alloc(m);
ker_log( SOS_LOG_POST_SHORT, sid, did );
return SOS_OK;
}
static int store_file_save_ack(Msg *msg, ack_status_t status)
{
Msg *mack;
int ret;
/* only sms are handled */
if (!msg || msg_type(msg) != sms)
return -1;
if (filename == NULL)
return 0;
mack = msg_create(ack);
if (!mack)
return -1;
mack->ack.time = msg->sms.time;
uuid_copy(mack->ack.id, msg->sms.id);
mack->ack.nack = status;
ret = store_save(mack);
msg_destroy(mack);
return ret;
}
static void smsbox_thread(void *arg)
{
Connection *conn;
Msg *msg;
Octstr *os;
Octstr *reply_msg;
unsigned long count;
msg = msg_create(sms);
msg->sms.sender = octstr_create("123");
msg->sms.receiver = octstr_create("456");
msg->sms.msgdata = octstr_create("hello world");
reply_msg = msg_pack(msg);
msg_destroy(msg);
gwthread_sleep(1.0);
conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
if (conn == NULL) {
gwthread_sleep(2.0);
conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
if (conn == NULL)
panic(0, "Couldn't connect to bearerbox as smsbox");
}
while (!quitting && conn_wait(conn, -1.0) != -1) {
for (;;) {
os = conn_read_withlen(conn);
if (os == NULL) {
if (conn_eof(conn) || conn_error(conn))
goto error;
break;
}
msg = msg_unpack(os);
if (msg == NULL || msg->type == wdp_datagram)
error(0, "Bearerbox sent garbage to smsbox");
if (msg->type == sms) {
if (first_from_bb == (time_t) -1)
time(&first_from_bb);
count = counter_increase(num_from_bearerbox) + 1;
debug("test.smpp", 0,
"Bearerbox sent sms #%ld <%s> to smsbox, sending reply.",
count, octstr_get_cstr(msg->sms.msgdata));
if (count == max_to_esme)
info(0, "Bearerbox has sent all messages to smsbox.");
conn_write_withlen(conn, reply_msg);
counter_increase(num_to_bearerbox);
}
msg_destroy(msg);
octstr_destroy(os);
time(&last_to_bb);
}
}
error:
conn_destroy(conn);
octstr_destroy(reply_msg);
debug("test.smpp", 0, "%s terminates.", __func__);
}
Msg* create_dlr_from_msg(const Octstr *smsc, const Msg *msg, const Octstr *reply, long stat)
{
Msg *dlrmsg;
if (msg == NULL)
return NULL;
/* generate DLR */
debug("dlr.dlr", 0,"SMSC[%s]: creating DLR message",
(smsc ? octstr_get_cstr(smsc) : "UNKNOWN"));
dlrmsg = msg_create(sms);
gw_assert(dlrmsg != NULL);
dlrmsg->sms.service = octstr_duplicate(msg->sms.service);
dlrmsg->sms.dlr_mask = stat;
dlrmsg->sms.sms_type = report_mo;
dlrmsg->sms.smsc_id = octstr_duplicate(smsc ? smsc : msg->sms.smsc_id);
dlrmsg->sms.sender = octstr_duplicate(msg->sms.sender);
dlrmsg->sms.receiver = octstr_duplicate(msg->sms.receiver);
dlrmsg->sms.dlr_url = octstr_duplicate(msg->sms.dlr_url);
dlrmsg->sms.msgdata = octstr_duplicate(reply);
dlrmsg->sms.boxc_id = octstr_duplicate(msg->sms.boxc_id);
dlrmsg->sms.foreign_id = octstr_duplicate(msg->sms.foreign_id);
time(&dlrmsg->sms.time);
debug("dlr.dlr", 0,"SMSC[%s]: DLR = %s",
(smsc ? octstr_get_cstr(smsc) : "UNKNOWN"),
(dlrmsg->sms.dlr_url ? octstr_get_cstr(dlrmsg->sms.dlr_url) : ""));
return dlrmsg;
}
int main()
{
//printf("this is msg_ser!\n");
int msg_id = msg_create();//ser
if(msg_id < 0)
return 1;
printf("ID:> %d\t\n\n",msg_id);
char buf[G_SIZE];
while(1)
{
buf[G_SIZE-1]='\0';
int ret =msg_recv(msg_id,buf,\
sizeof(buf)-1,DATA_TYPE_CLI);
printf("cli:>%s\n",buf);
fflush(stdout);
memset(buf,'\0',sizeof(buf));
printf("Please Input:\n ");
char *ar = fgets(buf,sizeof(buf)-1,stdin);
if(strncasecmp(ar,"quit",4) == 0)
break;
ret = msg_send(msg_id,buf,DATA_TYPE_SER);
}
msg_destroy(msg_id);
// sleep(10);
// int ret = msg_destroy(msg_id);
// printf("destroy code is:> %d\n",ret);
return 0;
}
static ERL_NIF_TERM
elua_newstate_async(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
msg_t *msg;
ErlNifPid pid;
if(argc != 2) {
return enif_make_badarg(env);
}
// ref
if(!enif_is_ref(env, argv[0])){
return make_error_tuple(env, "invalid_ref");
}
// dest pid
if(!enif_get_local_pid(env, argv[1], &pid)) {
return make_error_tuple(env, "invalid_pid");
}
msg = msg_create();
if(!msg) {
return make_error_tuple(env, "command_create_failed");
}
msg->type = msg_newstate;
msg->ref = enif_make_copy(msg->env, argv[0]);
msg->pid = pid;
msg->hold_env = env;
msg->res=NULL;
return push_command(env, NULL, msg);
}
/** Create a new message for transport */
static
msg_t *he_msg_create(nth_engine_t * he, int flags,
char const data[], usize_t dlen,
tport_t const *tport, nth_client_t * hc)
{
flags |= he->he_mflags;
if (he->he_streaming)
flags |= MSG_FLG_STREAMING;
else
flags &= ~MSG_FLG_STREAMING;
if (hc == NULL) {
nth_client_t **slot;
for (slot = hc_htable_hash(he->he_clients, (hash_value_t)(uintptr_t) tport);
(hc = *slot); slot = hc_htable_next(he->he_clients, slot))
if (hc->hc_tport == tport)
break;
}
if (hc) {
if (hc->hc_method == http_method_head) {
flags &= ~MSG_FLG_STREAMING;
flags |= HTTP_FLG_NO_BODY;
}
}
return msg_create(he->he_mclass, flags);
}
static void ee_gen_detail_msg(void)
{
#define DETAIL_STRLEN 16384 // TODO: check if enough?
int i, n = 0;
AE_Msg *rep_msg;
char *data;
int *mem;
xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "%s\n", __func__);
rep_msg = msg_create(&aed_dev.eerec.msg, DETAIL_STRLEN);
if (rep_msg == NULL)
return;
data = (char*)rep_msg + sizeof(AE_Msg);
mem = (int*)aed_dev.eerec.ee_log;
n += sprintf(data + n, "== EXTERNAL EXCEPTION LOG ==\n");
for (i = 0; i < aed_dev.eerec.ee_log_size / 4; i += 4) {
n += sprintf(data + n, "0x%08X 0x%08X 0x%08X 0x%08X\n",
mem[i], mem[i+1], mem[i+2], mem[i+3]);
}
n += sprintf(data + n, "== MEM DUMP(%d) ==\n", aed_dev.eerec.ee_phy_size);
rep_msg->cmdType = AE_RSP;
rep_msg->cmdId = AE_REQ_DETAIL;
rep_msg->arg = AE_PASS_BY_MEM;
rep_msg->len = n+1;
}
// Post a message with payload and source address
int8_t post_longer(sos_pid_t did, sos_pid_t sid, uint8_t type, uint8_t len,
void *data, uint16_t flag, uint16_t saddr)
{
Message *m = msg_create();
if(m == NULL){
if(flag_msg_release(flag)){
ker_free(data);
}
return -ENOMEM;
}
m->daddr = node_address;
m->did = did;
m->type = type;
m->saddr = saddr;
m->sid = sid;
m->len = len;
m->data = (uint8_t*)data;
#ifdef SOS_USE_PREEMPTION
// assign priority based on priority of id
m->priority = get_module_priority(did);
#endif
m->flag = flag;
sched_msg_alloc(m);
ker_log( SOS_LOG_POST_LONG, sid, did );
return SOS_OK;
}
static void ee_gen_process_msg(void)
{
#define PROCESS_STRLEN 512
int n = 0;
AE_Msg *rep_msg;
char *data;
xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "%s\n", __func__);
rep_msg = msg_create(&aed_dev.eerec.msg, PROCESS_STRLEN);
if(rep_msg == NULL)
return;
data = (char*)rep_msg + sizeof(AE_Msg);
if (aed_dev.eerec.exp_linenum != 0) {
// for old aed_md_exception1()
n = sprintf(data, "%s", aed_dev.eerec.assert_type);
if (aed_dev.eerec.exp_filename[0] != 0) {
n += sprintf(data + n, ", filename=%s,line=%d", aed_dev.eerec.exp_filename, aed_dev.eerec.exp_linenum);
}
else if (aed_dev.eerec.fatal1 != 0 && aed_dev.eerec.fatal2 != 0) {
n += sprintf(data + n, ", err1=%d,err2=%d", aed_dev.eerec.fatal1, aed_dev.eerec.fatal2);
}
} else {
xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "ee_gen_process_msg else\n") ;
n = sprintf (data, "%s", aed_dev.eerec.exp_filename) ;
}
rep_msg->cmdType = AE_RSP;
rep_msg->cmdId = AE_REQ_PROCESS;
rep_msg->len = n + 1;
}
/** Create a new message for transport */
static
msg_t *server_msg_create(server_t *srv, int flags,
char const data[], usize_t dlen,
tport_t const *tp, tp_client_t *tpc)
{
msg_t *msg = msg_create(srv->srv_mclass, srv->srv_mflags | flags);
return msg;
}
/*
* Identify ourself to bearerbox for smsbox-specific routing inside bearerbox.
* Do this even while no smsbox-id is given to unlock the sender thread in
* bearerbox.
*/
static void identify_to_bearerbox(void)
{
Msg *msg;
msg = msg_create(admin);
msg->admin.command = cmd_identify;
msg->admin.boxc_id = octstr_duplicate(smsbox_id);
write_to_bearerbox(msg);
}
/*
* Identify ourself to bearerbox for smsbox-specific routing inside bearerbox.
* Do this even while no smsbox-id is given to unlock the sender thread in
* bearerbox.
*/
static void identify_to_bearerbox(Boxc *conn)
{
Msg *msg;
msg = msg_create(admin);
msg->admin.command = cmd_identify;
msg->admin.boxc_id = octstr_duplicate(conn->boxc_id);
send_msg(conn->bearerbox_connection, conn, msg);
msg_destroy(msg);
}
void woker_destory(worker_t *w)
{
msg_t *msg = msg_create();
msg->type = msg_stop;
queue_push(w->q, msg);
enif_thread_join(w->tid, NULL);
enif_thread_opts_destroy(w->opts);
queue_destroy(w->q);
}
static void bearerbox_to_sql(void *arg)
{
Boxc *conn = (Boxc *)arg;
Msg *msg, *mack;
while (sqlbox_status == SQL_RUNNING && conn->alive) {
msg = read_from_box(conn->bearerbox_connection, conn);
if (msg == NULL) { /* garbage/connection lost */
/* tell sqlbox to die */
conn->alive = 0;
sqlbox_status = SQL_SHUTDOWN;
debug("sqlbox", 0, "bearerbox_to_sql: connection to bearerbox died.");
break;
}
if (msg_type(msg) == heartbeat) {
// todo
debug("sqlbox", 0, "bearerbox_to_sql: catch an heartbeat - we are alive");
msg_destroy(msg);
continue;
}
/* if this is an identification message from an smsbox instance */
if (msg_type(msg) == admin && msg->admin.command == cmd_shutdown) {
/* tell sqlbox to die */
conn->alive = 0;
sqlbox_status = SQL_SHUTDOWN;
debug("sqlbox", 0, "bearerbox_to_sql: Bearerbox told us to shutdown.");
break;
}
if (msg_type(msg) == sms) {
if (msg->sms.sms_type != report_mo) {
if (save_mo) {
gw_sql_save_msg(msg, octstr_imm("MO"));
}
}
else {
if (save_dlr) {
gw_sql_save_msg(msg, octstr_imm("DLR"));
}
}
/* create ack message */
mack = msg_create(ack);
mack->ack.nack = ack_success;
mack->ack.time = msg->sms.time;
uuid_copy(mack->ack.id, msg->sms.id);
send_msg(conn->bearerbox_connection, conn, mack);
msg_destroy(mack);
}
msg_destroy(msg);
}
}
static void msg_send(char *addr, int port, const char *msg,
const char *topic, const char *mod)
{
int fd;
char *json;
fd = sockfd_create(addr, port);
json = msg_create(msg, topic, mod);
write(fd, json, strlen(json));
msg_destory(json);
sockfd_close(fd);
}
static int store_spool_save_ack(Msg *msg, ack_status_t status)
{
int ret;
Msg *nack = msg_create(ack);
nack->ack.nack = status;
uuid_copy(nack->ack.id, msg->sms.id);
nack->ack.time = msg->sms.time;
ret = store_spool_save(nack);
msg_destroy(nack);
return ret;
}
/******************************************************************************
* EE message handlers
*****************************************************************************/
static void ee_gen_notavail_msg(void)
{
AE_Msg *rep_msg;
xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "%s\n", __func__);
rep_msg = msg_create(&aed_dev.eerec.msg, 0);
if(rep_msg == NULL)
return;
rep_msg->cmdType = AE_RSP;
rep_msg->arg = AE_NOT_AVAILABLE;
rep_msg->len = 0;
}
/**Deep copy a message.
*
* @relatesalso msg_s
*
* Copy a message, the header structures and all the related strings. The
* duplicated message does not share any (non-const) data with original.
* Note that the cached representation (in h_data) is not copied.
*
* @param original message to be duplicated
*
* @retval pointer to newly duplicated message object when successful
* @retval NULL upon an error
*/
msg_t *msg_dup(msg_t const *original)
{
if (original) {
msg_t *dup = msg_create(original->m_class, original->m_object->msg_flags);
if (dup && msg_dup_or_copy_all(dup, original, msg_header_dup_one) < 0) {
msg_destroy(dup), dup = NULL;
}
return dup;
}
return NULL;
}
int ota_pack_message(Msg **msg, Octstr *ota_doc, Octstr *doc_type,
Octstr *from, Octstr *phone_number, Octstr *sec, Octstr *pin)
{
Octstr *ota_binary;
*msg = msg_create(sms);
(*msg)->sms.sms_type = mt_push;
ota_pack_udh(msg, doc_type);
if (ota_compile(ota_doc, octstr_imm("UTF-8"), &ota_binary) == -1)
goto cerror;
if (!ota_pack_push_headers(msg, doc_type, sec, pin, ota_binary))
goto herror;
octstr_format_append((*msg)->sms.msgdata, "%S", ota_binary);
(*msg)->sms.sender = octstr_duplicate(from);
(*msg)->sms.receiver = octstr_duplicate(phone_number);
(*msg)->sms.coding = DC_8BIT;
(*msg)->sms.time = time(NULL);
octstr_dump((*msg)->sms.msgdata, 0);
info(0, "/cgi-bin/sendota: XML request for target <%s>", octstr_get_cstr(phone_number));
octstr_destroy(ota_binary);
octstr_destroy(ota_doc);
octstr_destroy(doc_type);
octstr_destroy(from);
octstr_destroy(sec);
octstr_destroy(pin);
return 0;
herror:
octstr_destroy(ota_binary);
octstr_destroy(ota_doc);
octstr_destroy(doc_type);
octstr_destroy(from);
octstr_destroy(sec);
octstr_destroy(pin);
return -2;
cerror:
octstr_destroy(ota_doc);
octstr_destroy(doc_type);
octstr_destroy(from);
octstr_destroy(sec);
octstr_destroy(pin);
return -1;
}
static void boxc_sender(void *arg)
{
Msg *msg;
Boxc *conn = arg;
gwlist_add_producer(flow_threads);
while (bb_status != BB_DEAD && conn->alive) {
/*
* Make sure there's no data left in the outgoing connection before
* doing the potentially blocking gwlist_consume()s
*/
conn_flush(conn->conn);
gwlist_consume(suspended); /* block here if suspended */
if ((msg = gwlist_consume(conn->incoming)) == NULL) {
/* tell sms/wapbox to die */
msg = msg_create(admin);
msg->admin.command = restart ? cmd_restart : cmd_shutdown;
send_msg(conn, msg);
msg_destroy(msg);
break;
}
if (msg_type(msg) == heartbeat) {
debug("bb.boxc", 0, "boxc_sender: catch an heartbeat - we are alive");
msg_destroy(msg);
continue;
}
boxc_sent_push(conn, msg);
if (!conn->alive || send_msg(conn, msg) == -1) {
/* we got message here */
boxc_sent_pop(conn, msg, NULL);
gwlist_produce(conn->retry, msg);
break;
}
msg_destroy(msg);
debug("bb.boxc", 0, "boxc_sender: sent message to <%s>",
octstr_get_cstr(conn->client_ip));
}
/* the client closes the connection, after that die in receiver */
/* conn->alive = 0; */
/* set conn to unroutable */
conn->routable = 0;
gwlist_remove_producer(flow_threads);
}
static void ee_gen_ind_msg(void)
{
AE_Msg *rep_msg;
xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "%s\n", __func__);
rep_msg = msg_create(&aed_dev.eerec.msg, 0);
if(rep_msg == NULL)
return;
rep_msg->cmdType = AE_IND;
rep_msg->cmdId = AE_IND_EXP_RAISED;
rep_msg->arg = AE_EE;
rep_msg->len = 0;
}
static void ke_gen_module_msg(void)
{
AE_Msg *rep_msg;
char *data;
xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "%s\n", __func__);
rep_msg = msg_create(&aed_dev.kerec.msg, strlen(aed_dev.kerec.lastlog->module) + 1);
if(rep_msg == NULL)
return;
data = (char*)rep_msg + sizeof(AE_Msg);
rep_msg->cmdType = AE_RSP;
rep_msg->cmdId = AE_REQ_MODULE;
rep_msg->len = strlen(aed_dev.kerec.lastlog->module) + 1;
strlcpy(data, aed_dev.kerec.lastlog->module, sizeof(aed_dev.kerec.lastlog->module));
}
/*************************************************************************
* the callback fnction for reading data from cc2420 *
*************************************************************************/
void _MacRecvCallBack(int16_t timestamp)
{
VMAC_PPDU ppdu;
vhal_data vd;
mac_to_vhal(&ppdu, &vd);
Radio_Disable_Interrupt(); //disable interrupt while reading data
if( !Radio_Recv_Pack(&vd) ) {
Radio_Enable_Interrupt(); //enable interrupt
return;
}
Radio_Enable_Interrupt(); //enable interrupt
vhal_to_mac(&vd, &ppdu);
// Andreas - filter node ID here, even before allocating any new memory
// if you're using sos/config/base you must comment this block out!
if (net_to_host(ppdu.mpdu.daddr) != NODE_ADDR && net_to_host(ppdu.mpdu.daddr) != BCAST_ADDRESS)
{
ker_free(vd.payload);
return;
}
Message *msg = msg_create();
if( msg == NULL ) {
ker_free(vd.payload);
return;
}
mac_to_sosmsg(&ppdu, msg);
// Andreas - start debug
#ifdef ENA_VMAC_UART_DEBUG
uint8_t *payload;
uint8_t msg_len;
msg_len=msg->len;
payload = msg->data;
//post_uart(msg->sid, msg->did, msg->type, msg_len, payload, SOS_MSG_RELEASE, msg->daddr);
// Swap daddr with saddr, because daddr is useless when debugging.
// Of course, if sossrv says "dest addr: 15" that actually means the message SENDER was node 15
post_uart(msg->sid, msg->did, msg->type, msg_len, payload, SOS_MSG_RELEASE, msg->saddr);
#endif
//if (msg->daddr == NODE_ADDR || msg->daddr == BCAST_ADDRESS)
handle_incoming_msg(msg, SOS_MSG_RADIO_IO);
}
/** Create a new message. */
msg_t *nth_engine_msg_create(nth_engine_t * he, int flags)
{
if (he == NULL) {
errno = EINVAL;
return NULL;
}
flags |= he->he_mflags;
if (he->he_streaming)
flags |= MSG_FLG_STREAMING;
else
flags &= ~MSG_FLG_STREAMING;
return msg_create(he->he_mclass, flags);
}
int bb_remove_message(Octstr *message_id)
{
Msg *msg;
int ret;
msg = msg_create(ack);
msg->ack.nack = ack_failed;
msg->ack.time = time(NULL);
uuid_parse(octstr_get_cstr(message_id), msg->ack.id);
ret = store_save(msg);
msg_destroy(msg);
if (ret != 0) {
error(0, "Could not delete message %s", octstr_get_cstr(message_id));
return -1;
}
return 0;
}
static void ee_gen_type_msg(void)
{
AE_Msg *rep_msg;
char *data;
xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "%s\n", __func__);
rep_msg = msg_create(&aed_dev.eerec.msg, strlen((char const *)&aed_dev.eerec.assert_type)+1);
if(rep_msg == NULL)
return;
data = (char*)rep_msg + sizeof(AE_Msg);
rep_msg->cmdType = AE_RSP;
rep_msg->cmdId = AE_REQ_TYPE;
rep_msg->len = strlen((char const *)&aed_dev.eerec.assert_type) + 1;
strncpy(data, (char const *)&aed_dev.eerec.assert_type, strlen((char const *)&aed_dev.eerec.assert_type));
}
static ERL_NIF_TERM
elua_gencall_async(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
elua_t *res;
msg_t *msg;
ErlNifPid pid;
if(argc != 6) {
return enif_make_badarg(env);
}
// first arg: ref
if(!enif_get_resource(env, argv[0], RES_SYNC, (void**) &res)) {
return enif_make_badarg(env);
}
// ref
if(!enif_is_ref(env, argv[1])) {
return make_error_tuple(env, "invalid_ref");
}
// dest pid
if(!enif_get_local_pid(env, argv[2], &pid)) {
return make_error_tuple(env, "invalid_pid");
}
// fourth arg: list of input args
if(!enif_is_list(env, argv[5])) {
return enif_make_badarg(env);
}
msg = msg_create();
if(!msg) {
return make_error_tuple(env, "command_create_failed");
}
msg->type = msg_gencall;
msg->ref = enif_make_copy(msg->env, argv[1]);
msg->pid = pid;
msg->arg1 = enif_make_copy(msg->env, argv[3]);
msg->arg2 = enif_make_copy(msg->env, argv[4]);
msg->arg3 = enif_make_copy(msg->env, argv[5]);
msg->res = res;
return push_command(env, res, msg);
}
