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); }