void receive_msg()
{
unsigned int16 ip, lbody, index, pl;
unsigned int8 msg[USB_EP1_RX_SIZE - 1], code, *body;
unsigned int1 hasBody;
usb_get_packet(1, msg, USB_EP1_RX_SIZE - 1);
ip = (msg[0] + (msg[1] * 256));
hasBody = bit_test(msg[2], 7);
code = msg[2];
bit_clear(code, 7);
#ifdef DEBUG_STREAM_A
fprintf(A, "receive_msg IP: %Lu - Code: %u - HasBody: %u\n\r", ip, code, hasBody);
#endif
if (hasBody)
{
lbody = (msg[3] + (msg[4] * 256));
body = calloc(lbody - 1, sizeof(unsigned int8));
pl = lbody;
if (pl > USB_EP1_RX_SIZE - 6)
pl = USB_EP1_RX_SIZE - 6;
copy_array(msg, 5, body, 0, pl);
index = pl;
while(index < lbody - 1)
{
pl = lbody - index;
if (pl > USB_EP1_RX_SIZE - 1)
pl = USB_EP1_RX_SIZE - 1;
while (!usb_kbhit(1));
usb_get_packet(1, msg, USB_EP1_RX_SIZE - 1);
copy_array(msg, 0, body, index, pl);
index += pl;
}
process_msg(ip, code, lbody, body);
if (body)
{
free(body);
}
}
else
{
process_msg(ip, code, 0, body);
}
}
static void tcp_process(fd_set* set, vector_t* for_del)
{
active_vector_iterator_t iter = active_vector_begin(&this.clients);
while (!active_vector_is_end(iter))
{
client_t* client = iter.data;
if (FD_ISSET(client->fd, set))
{
ssize_t rc = read_pre(client->fd, client->read, client->want);
if (rc <= 0)
{
if (errno == EAGAIN || errno == EWOULDBLOCK) goto end;
perror("read");
vector_push_back(for_del, (void*)(long)active_vector_iterator_idx(iter), sizeof(active_vector_iterator_idx(iter)));
goto end;
}
client->read += rc;
client->want -= rc;
if (client->want == 0)
{
if (IS_CLIENT_STATUS_WAITING_HEADER(client->status))
{
size_t len = msg_data_length((msg_t*)client->buffer);
if (len)
{
msg_t* msg = (msg_t*)client->buffer;
client->status = (client->status & ~CLIENT_STATUS_WAITING_HEADER) | CLIENT_STATUS_WAITING_BODY;
if (msg->zone.clip)
{
if (msg->zone.last) client->want = len % client->max_length;
else client->want = client->max_length;
}
else client->want = len;
client->buffer_len = sizeof(msg_t) + client->want;
client->buffer = group_pool_room_realloc(&this.group_pool, client->buffer, sizeof(msg_t) + client->want);
if (client->buffer == NULL)
{
SYSLOG(LOG_ERR, "Not enough memory");
vector_push_back(for_del, (void*)(long)active_vector_iterator_idx(iter), sizeof(active_vector_iterator_idx(iter)));
exit(1);
}
client->read = ((msg_t*)client->buffer)->data;
}
else process_msg(client, (msg_t*)client->buffer, for_del, active_vector_iterator_idx(iter));
}
else process_msg(client, (msg_t*)client->buffer, for_del, active_vector_iterator_idx(iter));
}
}
checkout_ttl(&client->recv_table);
end:
iter = active_vector_next(iter);
}
}
void recv_func(void* arg)
{
uint32_t user_id;
struct msg_packet msg;
while(1)
{
msg_recv(&msg);
user_id = process_msg(&msg);
switch (GET_MODE(msg.command))
{
case IPMSG_SENDMSG:
console_clear_line(-1);
shell_recv_msg(user_id);
printf("%s", buff);
break;
case IPMSG_ANSENTRY:
case IPMSG_BR_ENTRY:
shell_user_entry(user_id);
case IPMSG_BR_EXIT:
console_clear_line(-1);
shell_user_exit(user_id, msg.msg);
printf("%s", buff);
break;
}
}
}
void MainDlg::OnRecvMsg()
{
char buff[1024] = {0};
uint32_t user_id;
struct msg_packet msg;
while(1)
{
msg_recv(&msg);
user_id = process_msg(&msg);
switch (GET_MODE(msg.command))
{
case IPMSG_SENDMSG:
break;
case IPMSG_ANSENTRY:
case IPMSG_BR_ENTRY:
OnFriendOnline(user_find(user_id));
break;
case IPMSG_BR_EXIT:
break;
}
}
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr,"usage: client hostname\n");
exit(1);
}
read_cfg(COMMON_CFG_PATH); //to find bitfield length
struct peer_info info;
strcpy(info.hostname, argv[1]);
strcpy(info.port, PORT);
int s = make_socket_to_peer(&info);
if (s == -1) {
fprintf(stderr, "client: make_socket_to_peer() failed");
exit(1);
}
unsigned int payload_len;
message_t type;
unsigned char payload[5000];
int i;
for (i = 0 ; i < 8 ; i++)
{
type = recv_msg(info.from_fd, &payload_len, payload);
process_msg(payload, payload_len, type);
printf("\n");
}
close(info.from_fd);
return 0;
}
int rcv_packet(int sock_raw, char *buffers, struct hdr_histogram *hist)
{
struct mmsghdr msgs[NUM_BUFFERS];
struct iovec entries[NUM_BUFFERS];
struct {
struct cmsghdr cm;
char control[512];
} control[NUM_BUFFERS];
struct timespec timeout;
int valid_pkts = 0;
int npkts = 0;
memset(&timeout, 0, sizeof(timeout));
memset(msgs, 0, sizeof(msgs));
for (int i = 0; i < NUM_BUFFERS; ++i) {
entries[i].iov_base = &buffers[i * BUFFER_SIZE];
entries[i].iov_len = BUFFER_SIZE;
msgs[i].msg_hdr.msg_iov = &entries[i];
msgs[i].msg_hdr.msg_iovlen = 1;
msgs[i].msg_hdr.msg_control = &control[i];
msgs[i].msg_hdr.msg_controllen = sizeof(control[i]);
}
npkts = recvmmsg(sock_raw, msgs, NUM_BUFFERS, MSG_WAITFORONE, &timeout);
if (npkts < 0) {
perror("recvmmsg()");
return 0;
}
for (int i = 0; i < npkts; ++i) {
if (process_msg(&msgs[i].msg_hdr, &buffers[i * BUFFER_SIZE], hist))
valid_pkts += 1;
}
return valid_pkts;
}
static void on_read(int fd, void *arg)
{
struct rpc *r = (struct rpc *)arg;
char out_arg[1024];
struct iovec *recv_buf;
uint32_t msg_id;
size_t out_len;
memset(&r->recv_pkt, 0, sizeof(struct rpc_packet));
recv_buf = rpc_recv_buf(r);
if (!recv_buf) {
loge("rpc_recv_buf failed!\n");
return;
}
struct rpc_packet *pkt = &r->recv_pkt;
unpack_msg(pkt, &msg_id, &out_arg, &out_len);
logi("msg_id = %08x\n", msg_id);
if (r->state == rpc_inited) {
r->send_pkt.header.uuid_src = *(uint32_t *)pkt->payload;
thread_sem_signal(r->dispatch_thread);
r->state = rpc_connected;
} else if (r->state == rpc_connected) {
struct iovec buf;
buf.iov_len = pkt->header.payload_len;
buf.iov_base = pkt->payload;
process_msg(r, &buf);
//free(pkt->payload);
thread_sem_signal(r->dispatch_thread);
}
}
static void *thread_entry(void *arg)
{
int rv;
store_client_t *sc = (store_client_t *)arg;
net_client_t *nc = sc->nc;
void *msg;uint32_t len;
while(!sc->stop_daemon)
{
rv = nc_recvmsg(nc,&msg,&len,MS_PER_SECOND/4);
if(rv < 0)
continue;
if(rv == 0)
{
process_msg(msg,len);
//process msg
nc_free(nc,msg);
}
if(rv == 1)
{
//disconnect
}
}
return NULL;
}
static void
intr_mbox(void *arg)
{
struct tegra_xhci_softc *sc;
uint32_t reg, msg, resp_cmd, resp_data;
sc = (struct tegra_xhci_softc *)arg;
/* Clear interrupt first */
reg = FPCI_RD4(sc, XUSB_CFG_ARU_SMI_INTR);
FPCI_WR4(sc, XUSB_CFG_ARU_SMI_INTR, reg);
if (reg & ARU_SMI_INTR_FW_HANG) {
device_printf(sc->dev,
"XUSB CPU firmware hang!!! CPUCTL: 0x%08X\n",
CSB_RD4(sc, XUSB_FALCON_CPUCTL));
}
msg = FPCI_RD4(sc, T_XUSB_CFG_ARU_MAILBOX_DATA_OUT);
resp_cmd = 0;
process_msg(sc, ARU_MAILBOX_DATA_OUT_TYPE(msg),
ARU_MAILBOX_DATA_OUT_DATA(msg), &resp_cmd, &resp_data);
if (resp_cmd != 0)
mbox_send_ack(sc, resp_cmd, resp_data);
else
FPCI_WR4(sc, T_XUSB_CFG_ARU_MAILBOX_OWNER,
ARU_MAILBOX_OWNER_NONE);
reg = FPCI_RD4(sc, T_XUSB_CFG_ARU_MAILBOX_CMD);
reg &= ~ARU_MAILBOX_CMD_DEST_SMI;
FPCI_WR4(sc, T_XUSB_CFG_ARU_MAILBOX_CMD, reg);
}
void on_recv(int fd, void *arg)
{
struct iobuf *buf;
char key[9];
snprintf(key, sizeof(key), "%08x", fd);
struct rpc *r = (struct rpc *)dict_get(_rpcd->dict_fd2rpc, key, NULL);
if (!r) {
loge("dict_get failed: key=%s", key);
return;
}
//logi("on_recv fd = %d dict_get: key=%s, r->fd=%d\n", fd, key, r->fd);
buf = rpc_recv_buf(r);
if (!buf) {
//loge("peer connect closed\n");
rpc_connect_destroy(_rpcd, r);
return;
}
process_msg(r, buf);
r->fd = fd;//must be reset
//dump_buffer(buf->addr, buf->len);
//dump_packet(&r->packet);
free(buf->addr);
free(buf);
}
int main(void)
{
mcusr_save = MCUSR;
MCUSR = 0;
wdt_disable();
if (!(mcusr_save & WDRF))
{
seqnum = 0;
}
#ifdef SN_TEMP_DDR
// configure pin for analog
SN_TEMP_DDR &= ~SN_TEMP_MASK; // set as input
SN_TEMP_PORT &= ~SN_TEMP_MASK; // pull-ups off
DIDR0 |= SN_TEMP_MASK; // disable digital input buffer
#endif
SN_LED_DDR |= SN_LED_MASK; // set as output
SN_LED_PORT &= ~SN_LED_MASK;
vw_setup();
#ifdef SN_RX_CAPABLE
vw_rx_start();
#endif
for (int i=0;i<3;i++)
{
send_status(SN_ADDRESS_BROADCAST);
vw_wait_tx();
}
for (;;) {
#ifdef SN_RX_CAPABLE
if (vw_have_message()) {
uint8_t len = sizeof(msg);
if (vw_get_message((uint8_t *)&msg, &len)) {
if (msg.header.destination == SN_ADDRESS_ME|| msg.header.destination == SN_ADDRESS_BROADCAST) {
process_msg();
} else {
// TODO - consider routing here
}
} else {
// bad message
}
}
#endif
#ifdef SN_TX_CAPABLE
// Process any outgoing stuff
if (millis() - last_status > STATUS_PERIOD) {
send_status(SN_ADDRESS_BROADCAST);
}
if (millis() - last_sensor_data > SENSOR_PERIOD) {
send_sensor_data(SN_ADDRESS_BROADCAST);
}
#endif // SN_TX_CAPABLE
#ifdef USE_MILLIS
//set_sleep_mode(SLEEP_MODE_IDLE);
//sleep_enable();
//sleep_cpu();
//sleep_disable();
#endif
}
}
void onUSBCommTask(void *pvParameters)
{
while (1) {
if (USB_CDC_is_initialized())
process_msg(get_serial(SERIAL_USB), lineBuffer, BUFFER_SIZE);
taskYIELD();
}
}
static int get_body(void *msg) {
int answ = process_msg((struct bc_msg_body *) msg);
if (answ == 0) {
data_hnd = get_length;
bluetooth_read(1);
}
return NET_HND_STOP_FREE;
}
void process_udp_msg(struct local_msg *m, struct sockaddr_in *addr) {
int i;
switch (m->c) {
case 0: process_msg(m); break;
case 1: case 2:
i = udp_check_client(&tmpaddress);
if (i<0) { //new client
i=udp_add_client(&tmpaddress);
}
if (m->c==2) ping_back(m,addr);
else process_msg(m);
break;
case 3:
local_buf[local_buf_c++] = *m;
break;
default: printf("Unknown UDP control: %u\n",m->c);
}
}
static void turnserver_udp_recv(const struct sa *src, struct mbuf *mb,
void *arg)
{
TurnServer *turn = static_cast<TurnServer *>(arg);
turn->nrecv++;
process_msg(turn->turnd, IPPROTO_UDP, turn->us, src, &turn->addr, mb);
}
static void
nmsg_callback(nmsg_message_t msg, void *user) {
if (nmsg_message_get_vid(msg) == NMSG_VENDOR_BASE_ID &&
nmsg_message_get_msgtype(msg) == NMSG_VENDOR_BASE_PKT_ID)
{
process_msg(msg);
}
nmsg_message_destroy(&msg);
}
int process_select(struct srv_connection *conn, struct select s_val, FILE* file, int* count){
int i;
for (i=0; i<conn->cli_ct; i++){
if (!FD_ISSET(conn->cli[i].sfd, &(s_val.readfds)))
continue;
process_msg(&(conn->cli[i]), file, count);
}
}
static void* udp_recv_thread_func(void * arg) {
topic_subscription_pt sub = (topic_subscription_pt) arg;
#if defined(__APPLE__) && defined(__MACH__)
//TODO: use kqueue for OSX
//struct kevent events[MAX_EPOLL_EVENTS];
while (sub->running) {
int nfds = 0;
if(nfds > 0) {
pubsub_udp_msg_t* udpMsg = NULL;
process_msg(sub, udpMsg);
}
}
#else
struct epoll_event events[MAX_EPOLL_EVENTS];
while (sub->running) {
int nfds = epoll_wait(sub->topicEpollFd, events, MAX_EPOLL_EVENTS, RECV_THREAD_TIMEOUT * 1000);
int i;
for(i = 0; i < nfds; i++ ) {
unsigned int index;
unsigned int size;
if(largeUdp_dataAvailable(sub->largeUdpHandle, events[i].data.fd, &index, &size) == true) {
// Handle data
pubsub_udp_msg_t *udpMsg = NULL;
if(largeUdp_read(sub->largeUdpHandle, index, (void**)&udpMsg, size) != 0) {
printf("PSA_UDP_MC_TS: ERROR largeUdp_read with index %d\n", index);
continue;
}
process_msg(sub, udpMsg);
free(udpMsg);
}
}
connectPendingPublishers(sub);
disconnectPendingPublishers(sub);
}
#endif
return NULL;
}
void on_rpc_read(int fd, void *arg)
{
struct p2p *p2p = (struct p2p *)arg;
struct rpc *r = p2p->rpc;
struct iovec *buf = rpc_recv_buf(r);
if (!buf) {
logi("rpc_recv_buf failed!\n");
return;
}
process_msg(r, buf);
}
int main(int argc, char** argv)
{
int erl_fd; // FD to the ERL VM
char* bufp; // storage for incoming messages
int bufsz = 1024;
// the following are basically magic values.
erl_fd = setup_connection(1, "secretcookie", 0, "e1@am335x-evm");
ErlMessage* emsg;
emsg = (ErlMessage*)malloc(sizeof(ErlMessage));
bufp = (char*)malloc(bufsz * sizeof(char));
while (1) // main loop - we don't ever expect to leave.
{
TRACE(("starting main loop"));
TRACE(("waiting for a message..."));
int msg_status = erl_receive_msg(erl_fd, bufp, bufsz, emsg);
TRACE(("got a message"));
switch (msg_status)
{
case (ERL_MSG):
TRACE(("message status is ERL_MSG"));
process_msg(emsg, erl_fd);
break;
case (ERL_TICK):
TRACE(("message status is ERL_TICK"));
break;
case (ERL_ERROR):
default:
TRACE(("message status is ERL_ERROR"));
process_error();
break;
}
TRACE(("cleaning up at end of main loop"));
erl_free_term(emsg->msg);
erl_free_term(emsg->from);
erl_free_term(emsg->to);
} // end while loop
if (erl_close_connection(erl_fd) < 0)
{
perror("failed to close connection. plowing onward.");
}
free(emsg);
free(bufp);
}
void kct_netlink_handle_msg(void) {
struct kct_packet *msg;
msg = netlink_get_packet(sock_nl_fd);
if (msg == NULL) {
LOGE("Could not receive kernel packet: %s", strerror(errno));
return;
}
/* Process Kernel message */
process_msg(&msg->event);
free(msg);
}
static gboolean
xmms_ipc_client_read_cb (GIOChannel *iochan,
GIOCondition cond,
gpointer data)
{
xmms_ipc_client_t *client = data;
bool disconnect = FALSE;
g_return_val_if_fail (client, FALSE);
if (cond & G_IO_IN) {
while (TRUE) {
if (!client->read_msg) {
client->read_msg = xmms_ipc_msg_alloc ();
}
if (xmms_ipc_msg_read_transport (client->read_msg, client->transport, &disconnect)) {
xmms_ipc_msg_t *msg = client->read_msg;
client->read_msg = NULL;
process_msg (client, msg);
xmms_ipc_msg_destroy (msg);
} else {
break;
}
}
}
if (disconnect || (cond & G_IO_HUP)) {
if (client->read_msg) {
xmms_ipc_msg_destroy (client->read_msg);
client->read_msg = NULL;
}
XMMS_DBG ("disconnect was true!");
g_main_loop_quit (client->ml);
return FALSE;
}
if (cond & G_IO_ERR) {
xmms_log_error ("Client got error, maybe connection died?");
g_main_loop_quit (client->ml);
return FALSE;
}
return TRUE;
}
int main(int argc, const char *argv[])
{
init_function *fun;
int id;
//init
signal(SIGPIPE,SIG_IGN);
callback_tab["list"] = list;
callback_tab["close"] = close;
msg_t config = get_config_from_file("config.json");
sock::init(config);
for(fun = &__initlist_start;fun < &__initlist_end;fun++)
assert_perror((*fun)(config) < 0);
//main message loop
while(get_msg_source(id)){
process_msg(id);
}
return 0;
}
static void *mainloop(void *arg)
{
printf("start io thread\n");
struct poller_st *n = (struct poller_st *)arg;
while(0 == n->flag)
{
uint64_t tick = GetSystemMs64();
uint64_t timeout = tick + 10;
int8_t is_empty = 0;
for(;tick < timeout;){
lnode *node = NULL;
msgque_get(n->mq_in,&node,0);
if(node)
{
msg_t msg = (msg_t)node;
if(msg->type == MSG_WPACKET)
{
//发送数据包
process_send(n,(wpacket_t)msg);
}else
{
process_msg(n,msg);
}
}
else{
is_empty = 1;
break;
}
tick = GetSystemMs64();
}
if(is_empty){
//注册中断器，如果阻塞在loop里时mq_in收到消息会调用唤醒函数唤醒loop
msgque_putinterrupt(n->mq_in,(void*)n->netpoller,notify_function);
n->netpoller->loop(n->netpoller,10);
msgque_removeinterrupt(n->mq_in);
}
else
n->netpoller->loop(n->netpoller,0);
}
return NULL;
}
void conn_listen(int *socket) {
char *buffer, *resp;
int res;
// repeatedly respond to lines sent by the client
do {
// receive a string from this client's connection socket
res = recv_message(*socket, &buffer);
if (res < 0) {
send_string(*socket, "NACK");
continue;
}
resp = process_msg(buffer);
// printf("Client says \"%s\".\nResponding \"%s\"\n", buffer, resp);
printf("Responding \"%s\"\n", resp);
send_message(*socket, resp); // Note that process_msg() may have side effects.
} while (res > 0 && strcmp(buffer,"STOP"));
close(*socket);
}
static u8_t *recv_cb(u8_t *buf, size_t *off)
{
struct slip_context *slip =
CONTAINER_OF(buf, struct slip_context, buf);
size_t i;
if (!slip->init_done) {
*off = 0;
return buf;
}
for (i = 0; i < *off; i++) {
if (slip_input_byte(slip, buf[i])) {
#if SYS_LOG_LEVEL >= SYS_LOG_LEVEL_DEBUG
struct net_buf *frag = slip->rx->frags;
int bytes = net_buf_frags_len(frag);
int count = 0;
while (bytes && frag) {
char msg[8 + 1];
snprintf(msg, sizeof(msg), ">slip %2d", count);
hexdump(msg, frag->data, frag->len, 0);
frag = frag->frags;
count++;
}
SYS_LOG_DBG("[%p] received data %d bytes", slip, bytes);
#endif
process_msg(slip);
break;
}
}
*off = 0;
return buf;
}
int main(int argc, char **argv)
{
int msgid;
msgbuf_st msgbuf;
if (-1 == (msgid = msgget(KEY_VALUE, IPC_CREAT | 0666)))
ERROR_EXIT("msgget");
gpio_setup();
msgbuf.mtype = MSG_TYPE;
while(1) {
if (-1 == msgrcv(msgid, &msgbuf, sizeof(msgbuf_st) - sizeof(long), msgbuf.mtype, 0))
ERROR_EXIT("msgrcv");
printf("Recv message:%s\n", msgbuf.minfo);
process_msg(msgbuf.minfo);
}
gpio_cleanup();
return 0;
}
static char*
process_command(int argc, char * argv[])
{
char *msg = NULL, *result = NULL;
int i;
char *buf = NULL;
msg = mgmt_new_msg(argv[1], NULL);
for(i = 2; i < argc; i++ ) {
msg = mgmt_msg_append(msg, argv[i]);
}
cl_log(LOG_DEBUG, "msg sent: %s", msg);
result = process_msg(msg);
mgmt_del_msg(msg);
if ( result == NULL ) {
return NULL;
}
buf = cl_strdup(result);
mgmt_del_msg(result);
return buf;
}
void process_socket_queue(int client) {
int msg_c = buf_c[client] / LOCAL_MSG_SIZE;
int msg_r = buf_c[client] % LOCAL_MSG_SIZE;
struct local_msg m;
for (int i=0;i<msg_c;i++) {
unpack_lm(buf[client]+i*LOCAL_MSG_SIZE,&m);
switch (m.c) {
case 0: process_msg(&m); break;
case 3:
local_buf[local_buf_c++] = m;
break;
default: printf("Unknown SOCKET control: %u\n",m.c);
}
}
if (msg_c) {
for (int i=0;i<msg_r;i++)
buf[client][i] = buf[client][msg_c*LOCAL_MSG_SIZE+i];
buf_c[client] = msg_r;
}
}
static void ivshmem_read(void *opaque, const uint8_t *buf, int size)
{
IVShmemState *s = opaque;
Error *err = NULL;
int fd;
int64_t msg;
assert(size >= 0 && s->msg_buffered_bytes + size <= sizeof(s->msg_buf));
memcpy((unsigned char *)&s->msg_buf + s->msg_buffered_bytes, buf, size);
s->msg_buffered_bytes += size;
if (s->msg_buffered_bytes < sizeof(s->msg_buf)) {
return;
}
msg = le64_to_cpu(s->msg_buf);
s->msg_buffered_bytes = 0;
fd = qemu_chr_fe_get_msgfd(&s->server_chr);
process_msg(s, msg, fd, &err);
if (err) {
error_report_err(err);
}
}
