void rebuild_stream(uchar *payload, ushort psize, ulong seq, int syn)
{
ulong newseq;
ushort newpsize;
struct tcp_frag *frag;
struct tcp_stream *stream;
stream = _fromsv ? _svstream : _clstream;
if (stream->first) {
stream->first = 0;
stream->seq = seq + psize;
if (syn) {
++stream->seq;
}
//stream->wpcb(payload, payload_size, stream->user);
handle_packet(payload, psize);
return;
}
if (seq < stream->seq) {
newseq = seq + psize;
if (newseq > stream->seq) {
newpsize = stream->seq - seq;
if (newpsize > psize) {
payload = 0;
psize = 0;
} else {
payload = payload + newpsize;
psize -= newpsize;
}
seq = stream->seq;
psize = newseq - stream->seq;
}
}
if (seq == stream->seq) {
stream->seq += psize;
if (syn) {
++stream->seq;
}
if (payload) {
//stream->wpcb(payload, payload_size, stream->user);
handle_packet(payload, psize);
}
while (check_fragments(stream));
} else {
if (psize > 0 && seq > stream->seq) {
frag = malloc(sizeof(struct tcp_frag));
frag->payload = malloc(psize);
frag->seq = seq;
frag->psize = psize;
memcpy(frag->payload, payload, psize);
if (stream->frags) {
frag->next = stream->frags;
} else {
frag->next = 0;
}
stream->frags = frag;
}
}
}
static void handle_new_data(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
int len, status, offset = 0;
struct sr_serial_dev_inst *serial;
devc = sdi->priv;
serial = sdi->conn;
/* Try to get as much data as the buffer can hold. */
len = DMM_BUFSIZE - devc->buflen;
len = serial_read_nonblocking(serial, devc->buf + devc->buflen, len);
if (len < 1) {
sr_err("Serial port read error: %d.", len);
return;
}
devc->buflen += len;
status = PACKET_INVALID_HEADER;
/* Now look for packets in that data. */
while (status != PACKET_NEED_MORE_DATA) {
/* We don't have a header, look for one. */
if (devc->next_packet_len == 0) {
len = devc->buflen - offset;
status = brymen_packet_length(devc->buf + offset, &len);
if (status == PACKET_HEADER_OK) {
/* We know how large the packet will be. */
devc->next_packet_len = len;
} else if (status == PACKET_NEED_MORE_DATA) {
/* We didn't yet receive the full header. */
devc->next_packet_len = 0;
break;
} else {
/* Invalid header. Move on. */
devc->next_packet_len = 0;
offset++;
continue;
}
}
/* We know how the packet size, but did we receive all of it? */
if (devc->buflen - offset < devc->next_packet_len)
break;
/* We should have a full packet here, so we can check it. */
if (brymen_packet_is_valid(devc->buf + offset)) {
handle_packet(devc->buf + offset, sdi);
offset += devc->next_packet_len;
} else {
offset++;
}
/* We are done with this packet. Look for a new one. */
devc->next_packet_len = 0;
}
/* If we have any data left, move it to the beginning of our buffer. */
memmove(devc->buf, devc->buf + offset, devc->buflen - offset);
devc->buflen -= offset;
}
static int check_fragments(struct tcp_stream *stream)
{
struct tcp_frag *prev = 0, *cur = stream->frags;
while (cur) {
if (cur->seq == stream->seq) {
if (cur->payload) {
//stream->wpcb(cur->payload, cur->payload_size, stream->user);
handle_packet(cur->payload, cur->psize);
}
stream->seq += cur->psize;
if (prev) {
prev->next = cur->next;
} else {
stream->frags = cur->next;
}
free(cur->payload);
free(cur);
return 1;
}
prev = cur;
cur = cur->next;
}
return 0;
}
static void
command_dispatcher(const linkaddr_t *sender)
{
char *msg;
int len;
struct deluge_msg_profile *profile;
msg = packetbuf_dataptr();
len = packetbuf_datalen();
if(len < 1)
return;
switch(msg[0]) {
case DELUGE_CMD_SUMMARY:
if(len >= sizeof(struct deluge_msg_summary))
handle_summary((struct deluge_msg_summary *)msg, sender);
break;
case DELUGE_CMD_REQUEST:
if(len >= sizeof(struct deluge_msg_request))
handle_request((struct deluge_msg_request *)msg);
break;
case DELUGE_CMD_PACKET:
if(len >= sizeof(struct deluge_msg_packet))
handle_packet((struct deluge_msg_packet *)msg);
break;
case DELUGE_CMD_PROFILE:
profile = (struct deluge_msg_profile *)msg;
if(len >= sizeof(*profile) &&
len >= sizeof(*profile) + profile->npages * profile->version_vector[0])
handle_profile((struct deluge_msg_profile *)msg);
break;
default:
PRINTF("Incoming packet with unknown command: %d\n", msg[0]);
}
}
Code_t
client_send_clients(void)
{
int i;
Client *client;
Code_t retval;
for (i = 0; i < HASHSIZE; i++) {
/* Allow packets to be processed between rows of the hash table. */
if (packets_waiting()) {
bdumping = 0;
bdump_concurrent = 1;
handle_packet();
bdump_concurrent = 0;
bdumping = 1;
}
for (client = client_bucket[i]; client; client = client->next) {
if (client->subs) {
retval = subscr_send_subs(client);
if (retval != ZERR_NONE)
return retval;
}
}
}
return ZERR_NONE;
}
// Data received on non-control Out endpoint
static uint8_t usbd_rndis_data_out(void *pdev, uint8_t epnum)
{
static int rndis_received = 0;
if (epnum == RNDIS_DATA_OUT_EP)
{
PUSB_OTG_EP ep = &((USB_OTG_CORE_HANDLE*)pdev)->dev.out_ep[epnum];
if (rndis_received + ep->xfer_count > RNDIS_RX_BUFFER_SIZE)
{
usb_eth_stat.rxbad++;
rndis_received = 0;
}
else
{
if (rndis_received + ep->xfer_count <= RNDIS_RX_BUFFER_SIZE)
{
memcpy(&rndis_rx_buffer[rndis_received], usb_rx_buffer, ep->xfer_count);
rndis_received += ep->xfer_count;
if (ep->xfer_count != RNDIS_DATA_OUT_SZ)
{
handle_packet(rndis_rx_buffer, rndis_received);
rndis_received = 0;
}
}
else
{
rndis_received = 0;
usb_eth_stat.rxbad++;
}
}
DCD_EP_PrepareRx(pdev, RNDIS_DATA_OUT_EP, (uint8_t*)usb_rx_buffer, RNDIS_DATA_OUT_SZ);
}
return USBD_OK;
}
static void *read_thread(void *data)
{
struct vidsrc_st *st = data;
while (st->run) {
AVPacket pkt;
av_init_packet(&pkt);
if (av_read_frame(st->ic, &pkt) < 0) {
sys_msleep(1000);
av_seek_frame(st->ic, -1, 0, 0);
continue;
}
if (pkt.stream_index != st->sindex)
goto out;
handle_packet(st, &pkt);
/* simulate framerate */
sys_msleep(1000/st->fps);
out:
av_free_packet(&pkt);
}
return NULL;
}
static void *read_thread(void *data)
{
struct vidsrc_st *st = data;
while (st->run) {
AVPacket pkt;
av_init_packet(&pkt);
if (av_read_frame(st->ic, &pkt) < 0) {
sys_msleep(1000);
av_seek_frame(st->ic, -1, 0, 0);
continue;
}
if (pkt.stream_index != st->sindex)
goto out;
handle_packet(st, &pkt);
/* simulate framerate */
sys_msleep(1000/st->fps);
out:
#if LIBAVCODEC_VERSION_INT >= ((57<<16)+(12<<8)+100)
av_packet_unref(&pkt);
#else
av_free_packet(&pkt);
#endif
}
return NULL;
}
static void handle_new_data(struct sr_dev_inst *sdi, int idx)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
int len, i, offset = 0;
devc = sdi->priv;
serial = sdi->conn;
/* Try to get as much data as the buffer can hold. */
len = SERIAL_BUFSIZE - devc->buflen;
len = serial_read_nonblocking(serial, devc->buf + devc->buflen, len);
if (len < 1) {
sr_err("Serial port read error: %d.", len);
return;
}
devc->buflen += len;
/* Now look for packets in that data. */
while ((devc->buflen - offset) >= mic_devs[idx].packet_size) {
if (mic_devs[idx].packet_valid(devc->buf + offset)) {
handle_packet(devc->buf + offset, sdi, idx);
offset += mic_devs[idx].packet_size;
} else {
offset++;
}
}
/* If we have any data left, move it to the beginning of our buffer. */
for (i = 0; i < devc->buflen - offset; i++)
devc->buf[i] = devc->buf[offset + i];
devc->buflen -= offset;
}
// Send an internal message to a USB device
void usb_device_c::usb_send_msg(int msg)
{
USBPacket p;
memset(&p, 0, sizeof(p));
p.pid = msg;
handle_packet(&p);
}
static void handle_new_data(struct sr_dev_inst *sdi, int dmm, void *info)
{
struct dev_context *devc;
int len, i, offset = 0;
struct sr_serial_dev_inst *serial;
devc = sdi->priv;
serial = sdi->conn;
/* Try to get as much data as the buffer can hold. */
len = DMM_BUFSIZE - devc->buflen;
len = serial_read(serial, devc->buf + devc->buflen, len);
if (len == 0)
return; /* No new bytes, nothing to do. */
if (len < 0) {
sr_err("Serial port read error: %d.", len);
return;
}
devc->buflen += len;
/* Now look for packets in that data. */
while ((devc->buflen - offset) >= dmms[dmm].packet_size) {
if (dmms[dmm].packet_valid(devc->buf + offset)) {
handle_packet(devc->buf + offset, sdi, dmm, info);
offset += dmms[dmm].packet_size;
} else {
offset++;
}
}
/* If we have any data left, move it to the beginning of our buffer. */
for (i = 0; i < devc->buflen - offset; i++)
devc->buf[i] = devc->buf[offset + i];
devc->buflen -= offset;
}
static void
canRead (ccnet_packet *packet, void *vpeer)
{
CcnetPeer *peer = vpeer;
g_object_ref (peer);
/* if (!peer->is_local) */
/* ccnet_debug ("[RECV] Recieve packat from %s type is %d, id is %d\n", */
/* peer->id, packet->header.type, packet->header.id); */
if (packet->header.id == 0)
return;
if (packet->header.type != CCNET_MSG_ENCPACKET) {
handle_packet (packet, peer);
} else {
/* ccnet_debug ("receive an encrypt packet\n"); */
if (!peer->session_key) {
ccnet_debug("Receive a encrypted packet from %s(%.8s) while "
"not having session key \n", peer->name, peer->id);
goto out;
}
char *data;
int len;
int ret;
ret = ccnet_decrypt_with_key (&data, &len, packet->data, packet->header.id,
peer->key, peer->iv);
if (ret < 0)
ccnet_warning ("[SEND] decryption error for peer %s(%.8s) \n",
peer->name, peer->id);
else {
ccnet_packet *new_pac = (ccnet_packet *)data;
/* byte order, from network to host */
new_pac->header.length = ntohs(new_pac->header.length);
new_pac->header.id = ntohl (new_pac->header.id);
handle_packet (new_pac, peer);
g_free (data);
}
}
out:
g_object_unref (peer);
}
int main(int argc, char **argv) {
pcap_t *pcap;
char errbuf[PCAP_ERRBUF_SIZE];
struct pcap_pkthdr *pkthdr;
const u_char *packet;
int res = 0;
int c, option_index = 0;
static struct option opts[] = {
{ "psk", 1, 0, 'p' },
{ 0, 0, 0, 0 }
};
/* handle command line options */
while (1) {
c = getopt_long(argc, argv, "p:", opts, &option_index);
if (c == -1)
break;
switch (c) {
case 'p':
pre_master_len = dtls_pre_master_secret((unsigned char *)optarg,
strlen(optarg), pre_master_secret);
break;
}
}
if (argc <= optind) {
fprintf(stderr, "usage: %s [-p|--psk PSK] pcapfile\n", argv[0]);
return -1;
}
init();
pcap = pcap_open_offline(argv[optind], errbuf);
if (!pcap) {
fprintf(stderr, "pcap_open_offline: %s\n", errbuf);
return -2;
}
for (;;) {
res = pcap_next_ex(pcap, &pkthdr, &packet);
switch(res) {
case -2: goto done;
case -1: pcap_perror(pcap, "read packet"); break;
case 1: handle_packet(packet, pkthdr->caplen); break;
default:
;
}
}
done:
pcap_close(pcap);
return 0;
}
static int
get_response (void)
{
ossmix_commad_packet_t msg;
char payload[4096];
int l;
if (sockfd == -1)
return -1;
while (1)
{
payload[0] = 0;
if ((l = read_all (sockfd, &msg, sizeof (msg))) != sizeof (msg))
{
if (l == 0) /* Connection closed */
return -1;
perror ("get response");
return -1;
}
if (do_byteswap)
byteswap_msg (&msg);
if (msg.payload_size > 0)
{
if ((l =
read_all (sockfd, payload,
msg.payload_size)) != msg.payload_size)
{
perror ("Get response payload");
fprintf (stderr, "Payload size %d/%d\n", l, msg.payload_size);
return -1;
}
payload[l] = 0;
}
if (msg.cmd == OSSMIX_CMD_ERROR)
{
fprintf (stderr, "Remote error: %s\n", payload);
}
/*
* Return if this was not an async notification message sent by the
* server.
*/
if (!msg.unsolicited)
return msg.cmd;
handle_packet (&msg, payload, msg.payload_size);
}
}
void Deserializer::work(const InputItems &, const OutputItems &)
{
//validate the pkt message type
PMCC msg = pop_input_msg(0);
if (not msg or not msg.is<gras::PacketMsg>()) return;
gras::PacketMsg pkt_msg = msg.as<gras::PacketMsg>();
//handle the packet - non recovery logic
if (not _recover) return this->handle_packet(pkt_msg.buff);
////////////////////////////////////////////////////////////////
/////////// Recovery logic below ///////////////////////////////
////////////////////////////////////////////////////////////////
//was there a buffer previously? then accumulate it
if (_accum_buff)
{
gras::SBufferConfig config;
config.length = _accum_buff.length + pkt_msg.buff.length;
gras::SBuffer new_buff(config);
std::memcpy(new_buff.get(), _accum_buff.get(), _accum_buff.length);
std::memcpy(new_buff.get(_accum_buff.length), pkt_msg.buff.get(), pkt_msg.buff.length);
_accum_buff = new_buff;
}
else
{
_accum_buff = pkt_msg.buff;
}
//character by character recovery search for packet header
while (_accum_buff.length >= MIN_PKT_BYTES)
{
bool fragment = true; size_t pkt_len = 0;
if (inspect_packet(_accum_buff.get(), _accum_buff.length, fragment, pkt_len))
{
if (fragment) return; //wait for more incoming buffers to accumulate
handle_packet(_accum_buff); //handle the packet, its good probably
//increment for the next iteration
ASSERT(pkt_len <= _accum_buff.length);
_accum_buff.offset += pkt_len;
_accum_buff.length -= pkt_len;
ASSERT(_accum_buff.length <= _accum_buff.get_actual_length());
}
else
{
//the search continues
_accum_buff.offset++;
_accum_buff.length--;
}
}
//dont keep a reference if the buffer is empty
if (_accum_buff.length == 0) _accum_buff.reset();
}
static int run_network(void *data)
{
struct msghdr msg;
struct iovec iov;
mm_segment_t oldfs;
char buffer[0x200];// = "Hello";
int cc;
struct socket *csock = data;
struct nm_packet_rp *reply;
printk(KERN_INFO "NetMalloc: creating client thread\n");
while (network_is_running)
{
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = MSG_DONTWAIT;
msg.msg_iov->iov_len = sizeof(buffer);
msg.msg_iov->iov_base = buffer;
oldfs = get_fs();
set_fs(KERNEL_DS);
cc = sock_recvmsg(csock, &msg, sizeof(buffer), MSG_DONTWAIT);
set_fs(oldfs);
if (!cc)
break;
else if (cc == -EWOULDBLOCK)
schedule_timeout_interruptible(125);
else if (cc > 0)
{
printk(KERN_INFO "%d bytes received\n", cc);
reply = handle_packet((struct nm_packet_rq *) buffer, cc);
if (reply)
{
cc = sizeof(struct nm_packet_rp) + reply->data_len;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = MSG_DONTWAIT;
msg.msg_iov->iov_len = cc;
msg.msg_iov->iov_base = reply;
oldfs = get_fs();
set_fs(KERNEL_DS);
cc = sock_sendmsg(csock, &msg, cc);
set_fs(oldfs);
printk(KERN_INFO "%d bytes sent\n", cc);
kfree(reply);
}
}
}
sock_release(csock);
printk(KERN_INFO "NetMalloc: closing client thread\n");
return 0;
}
void* receive_thread(void *arg)
{
struct receive_param rcv_para = *((struct receive_param *)arg);
PMIFI_PACKET packet, resp;
u8 sum;
int len;
const int buff_len = 1024;
packet = (PMIFI_PACKET)malloc(buff_len);
resp = (PMIFI_PACKET)malloc(buff_len);
memset(packet, 0x0, buff_len);
while (read_packet(rcv_para.sd, packet) != ERROR) {
DBG_OUT("Process received packet");
len = get_packet_len(packet);
sum = get_checksum((u8*)packet, len - 1);
DBG_OUT("len = %d, recv sum = 0x%02x, calc sum = 0x%02x", len, ((u8*)packet)[len - 1], sum);
dump_packet(packet);
if (((u8*)packet)[len - 1] != sum)
DBG_OUT("*** check sum fail");
if (is_client_response(packet->func) == 0) {
handle_packet(rcv_para.sd, packet);
len = server_build_response(packet, resp);
DBG_OUT("build response len is %d", len);
if (len > 0) {
DBG_OUT("enqueue packet to queue");
push_data(rcv_para.sd, (u8*)resp, len);
}
handle_packet_post(rcv_para.sd, packet);
} else {
DBG_OUT("It's a response packet from client, ignored.");
}
memset(packet, 0x0, buff_len);
} /* while(read_packet) */
DBG_OUT("terminated thread 0x%lx", (unsigned long)pthread_self());
for (len = 0; len < ARRAY_SIZE(dev_map); len++)
{
if (dev_map[len].sd == rcv_para.sd)
{
dev_map[len].valid = 0;
break;
}
}
free(packet);
free(resp);
pthread_exit((void *)0);
return NULL;
}
static void transport_socket_events(int fd, unsigned events, void *_t)
{
if(events & FDE_READ){
apacket *p = 0;
if(read_packet(fd, &p)){
D("failed to read packet from transport socket on fd %d\n", fd);
} else {
handle_packet(p, (atransport *) _t);
}
}
}
void
vc1::es_parser_c::flush() {
if (m_unparsed_buffer && (4 <= m_unparsed_buffer->get_size())) {
uint32_t marker = get_uint32_be(m_unparsed_buffer->get_buffer());
if (vc1::is_marker(marker))
handle_packet(memory_c::clone(m_unparsed_buffer->get_buffer(), m_unparsed_buffer->get_size()));
}
m_unparsed_buffer.reset();
flush_frame();
}
static void transport_socket_events(int fd, unsigned events, void *_t)
{
atransport *t = (atransport *)_t;
D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
if(events & FDE_READ){
apacket *p = 0;
if(read_packet(fd, t->serial, &p)){
D("%s: failed to read packet from transport socket on fd %d\n", t->serial, fd);
} else {
handle_packet(p, (atransport *) _t);
}
}
}
void operator()(struct nflog_data *nfa)
{
//struct nfulnl_msg_packet_hdr *ph = nflog_get_msg_packet_hdr(nfa);
char *prefix = nflog_get_prefix(nfa);
char *payload = 0;
int payload_len = nflog_get_payload(nfa, &payload);
struct timeval tv;
memset(&tv, 0, sizeof(tv));
nflog_get_timestamp(nfa, &tv);
std::cout
<< (unsigned)tv.tv_sec << "."
<< tv.tv_usec;
std::cout << "\t" << nflog_get_indev(nfa);
std::cout << "\t" << nflog_get_outdev(nfa);
std::cout << "\t" << payload_len;
if (payload_len > 0)
handle_packet(payload, payload_len);
if (prefix && strlen(prefix)) {
std::cout << "\t\"" << prefix << "\"";
}
std::cout << std::endl;
// write a pcap file here if required
if (pcap_writer) {
const size_t pcap_len = payload_len+sizeof(ether_header);
pcap_pkthdr head;
memset(&head, 0, sizeof(head));
head.ts = tv;
head.caplen = pcap_len;
head.len = pcap_len;
// make pcap header
unsigned char tbuf[pcap_len];
ether_header* ehead = reinterpret_cast<ether_header*>(&tbuf[0]);
memset(ehead, 0, sizeof(ehead));
ehead->ether_dhost[0]=0xFA; ehead->ether_dhost[1]=0xCE;
ehead->ether_shost[0]=0xFA; ehead->ether_shost[1]=0xCE;
*reinterpret_cast<u_int32_t*>(&ehead->ether_dhost[2]) = nflog_get_outdev(nfa);
*reinterpret_cast<u_int32_t*>(&ehead->ether_shost[2]) = nflog_get_indev(nfa);
ehead->ether_type=htons(ETHERTYPE_IP);
// copy payload and dump
memcpy(tbuf+sizeof(ether_header), payload, payload_len);
pcap_dump(reinterpret_cast<u_char*>(pcap_writer), &head, reinterpret_cast<const u_char*>(tbuf));
}
}
void
vc1::es_parser_c::add_bytes(unsigned char *buffer,
int size) {
memory_slice_cursor_c cursor;
int previous_pos = -1;
int64_t previous_stream_pos = m_stream_pos;
if (m_unparsed_buffer && (0 != m_unparsed_buffer->get_size()))
cursor.add_slice(m_unparsed_buffer);
cursor.add_slice(buffer, size);
if (3 <= cursor.get_remaining_size()) {
uint32_t marker = (1 << 24) | ((unsigned int)cursor.get_char() << 16) | ((unsigned int)cursor.get_char() << 8) | (unsigned int)cursor.get_char();
while (1) {
if (vc1::is_marker(marker)) {
if (-1 != previous_pos) {
int new_size = cursor.get_position() - 4 - previous_pos;
memory_cptr packet(new memory_c(safemalloc(new_size), new_size, true));
cursor.copy(packet->get_buffer(), previous_pos, new_size);
handle_packet(packet);
}
previous_pos = cursor.get_position() - 4;
m_stream_pos = previous_stream_pos + previous_pos;
}
if (!cursor.char_available())
break;
marker <<= 8;
marker |= (unsigned int)cursor.get_char();
}
}
if (-1 == previous_pos)
previous_pos = 0;
int new_size = cursor.get_size() - previous_pos;
if (0 != new_size) {
memory_cptr new_unparsed_buffer = memory_c::alloc(new_size);
cursor.copy(new_unparsed_buffer->get_buffer(), previous_pos, new_size);
m_unparsed_buffer = new_unparsed_buffer;
} else
m_unparsed_buffer.reset();
}
static void transport_socket_events(int fd, unsigned events, void *_t)
{
atransport *t = reinterpret_cast<atransport*>(_t);
ADB_LOGD(ADB_TSPT, "transport_socket_events(fd=%d, events=%04x,...)",
fd, events);
if (events & FDE_READ) {
apacket *p = 0;
if (read_packet(fd, t->serial, &p)) {
ADB_LOGE(ADB_TSPT,
"%s: failed to read packet from transport socket on fd %d",
t->serial, fd);
} else {
handle_packet(p, (atransport *) _t);
}
}
}
static void socket_event(AVAHI_GCC_UNUSED AvahiWatch *w, int fd, AVAHI_GCC_UNUSED AvahiWatchEvent events, void *userdata) {
AvahiWideAreaLookupEngine *e = userdata;
AvahiDnsPacket *p = NULL;
if (fd == e->fd_ipv4)
p = avahi_recv_dns_packet_ipv4(e->fd_ipv4, NULL, NULL, NULL, NULL, NULL);
else {
assert(fd == e->fd_ipv6);
p = avahi_recv_dns_packet_ipv6(e->fd_ipv6, NULL, NULL, NULL, NULL, NULL);
}
if (p) {
handle_packet(e, p);
avahi_dns_packet_free(p);
}
}
static void handle_new_data(struct sr_dev_inst *sdi, void *info)
{
struct dmm_info *dmm;
struct dev_context *devc;
int len, i, offset = 0;
struct sr_serial_dev_inst *serial;
dmm = (struct dmm_info *)sdi->driver;
devc = sdi->priv;
serial = sdi->conn;
/* Try to get as much data as the buffer can hold. */
len = DMM_BUFSIZE - devc->buflen;
len = serial_read_nonblocking(serial, devc->buf + devc->buflen, len);
if (len == 0)
return; /* No new bytes, nothing to do. */
if (len < 0) {
sr_err("Serial port read error: %d.", len);
return;
}
devc->buflen += len;
/* Now look for packets in that data. */
while ((devc->buflen - offset) >= dmm->packet_size) {
if (dmm->packet_valid(devc->buf + offset)) {
handle_packet(devc->buf + offset, sdi, info);
offset += dmm->packet_size;
/* Request next packet, if required. */
if (!dmm->packet_request)
break;
if (dmm->req_timeout_ms || dmm->req_delay_ms)
devc->req_next_at = g_get_monotonic_time() +
dmm->req_delay_ms * 1000;
req_packet(sdi);
} else {
offset++;
}
}
/* If we have any data left, move it to the beginning of our buffer. */
for (i = 0; i < devc->buflen - offset; i++)
devc->buf[i] = devc->buf[offset + i];
devc->buflen -= offset;
}
void recv_packets()
{
int ret;
// Poll for packets
do {
ret = pfring_zc_recv_pkt(pf_recv, &pf_buffer, 0);
if (ret == 0) {
usleep(1000);
}
} while (ret == 0);
// Handle other errors, by not doing anything and logging
if (ret != 1) {
log_error("recv", "Error: %d", ret);
return;
}
// Successfully got a packet, now handle it
handle_packet(pf_buffer->len, pf_buffer->data);
}
int main(int argc, char *argv[])
{
struct ipulog_handle *h;
unsigned char* buf;
int len;
ulog_packet_msg_t *upkt;
int i;
if (argc != 4) {
fprintf(stderr, "Usage: %s count group timeout\n", argv[0]);
exit(1);
}
/* allocate a receive buffer */
buf = (unsigned char *) malloc(MYBUFSIZ);
/* create ipulog handle */
h = ipulog_create_handle(ipulog_group2gmask(atoi(argv[2])),150000);
if (!h)
{
/* if some error occurrs, print it to stderr */
ipulog_perror(NULL);
exit(1);
}
alarm(atoi(argv[3]));
/* loop receiving packets and handling them over to handle_packet */
for (i = 0; i < atoi(argv[1]); i++) {
len = ipulog_read(h, buf, MYBUFSIZ, 1);
if (len <= 0) {
ipulog_perror("ulog_test: short read");
exit(1);
}
printf("%d bytes received\n", len);
while (upkt = ipulog_get_packet(h, buf, len)) {
handle_packet(upkt);
}
}
/* just to give it a cleaner look */
ipulog_destroy_handle(h);
return 0;
}
static void *read_thread(void *data)
{
struct vidsrc_st *st = data;
uint64_t now, ts = tmr_jiffies();
while (st->run) {
AVPacket pkt;
int ret;
sys_msleep(4);
now = tmr_jiffies();
if (ts > now)
continue;
av_init_packet(&pkt);
ret = av_read_frame(st->ic, &pkt);
if (ret < 0) {
debug("avformat: rewind stream (ret=%d)\n", ret);
sys_msleep(1000);
av_seek_frame(st->ic, -1, 0, 0);
continue;
}
if (pkt.stream_index != st->sindex)
goto out;
handle_packet(st, &pkt);
ts += (uint64_t) 1000 * pkt.duration * av_q2d(st->time_base);
out:
#if LIBAVCODEC_VERSION_INT >= ((57<<16)+(12<<8)+100)
av_packet_unref(&pkt);
#else
av_free_packet(&pkt);
#endif
}
return NULL;
}
void CommandTcpServer::read_client(tcp_client& cli)
{
char buff[64];
ssize_t read;
while(true)
{
read = ::read(cli.fd, buff, sizeof(buff));
if(read <= 0)
break;
for(ssize_t i = 0; i < read; ++i)
{
if(cli.pkt.add(buff[i]))
{
handle_packet(cli.pkt);
cli.pkt.clear();
}
}
}
}
/**
* Receive data from SZE2 interface and send it to output gate as a RawPacket message.
* @return 0 upon success, negative otherwise
*/
void _do_async()
{
unsigned char *packet;
unsigned int packet_len;
unsigned char *data, *hw_data;
unsigned int data_len, hw_data_len;
//unsigned int segsize;
int cnt = m_pktagg;
/* read */
while(cnt-- > 0)
{
if((packet = szedata_read_next(sze, &packet_len)) != NULL) {
m_pktcnt++;
/*segsize = */
szedata_decode_packet(packet, &data, &hw_data, &data_len, &hw_data_len);
handle_packet(packet, data, hw_data, data_len, hw_data_len);
}
}
}
