int main(int argc, char *argv[])
{
unsigned long flags = DUMP_VERBOSE;
unsigned long filter = ~0L;
bdaddr_t address;
int defpsm = 0;
int defcompid = DEFAULT_COMPID;
int opt, pppdump_fd = -1, audio_fd = -1;
printf("Csr Bluez Coex Sniffer\n");
while ((opt=getopt_long(argc, argv, "a:i:", NULL, NULL)) != -1) {
switch(opt) {
case 'a':
printf("Address = %s\n", optarg);
str2ba(optarg, &address);
break;
case 'h':
default:
usage();
exit(0);
}
}
init_parser(flags, filter, defpsm, defcompid, pppdump_fd, audio_fd);
process_frames(address, flags);
return 0;
}
void
truehd_ac3_splitting_packet_converter_c::flush() {
m_parser.parse(true);
process_frames();
if (m_ptzr)
m_ptzr->flush();
if (m_ac3_ptzr)
m_ac3_ptzr->flush();
}
bool
truehd_ac3_splitting_packet_converter_c::convert(packet_cptr const &packet) {
m_parser.add_data(packet->data->get_buffer(), packet->data->get_size());
m_parser.parse(true);
m_truehd_timestamp = packet->timestamp;
m_ac3_timestamp = packet->timestamp;
process_frames();
return true;
}
void handle_data(int link, FRAME f, size_t len){
// If packet is sent to this node, accept it, reconstruct the whole message and send it to the application layer
//printf("handle data called for message #%d\n", f.payload.mesg_seq_no);
if(f.payload.dest == nodeinfo.address){
queue_add(receiver, &f, len);
process_frames();
}
// Else forward it according to the routing information that we have, this node will act as a router
else{
//printf("Processing forward to %d from %d via %d\n", f.payload.dest, f.payload.source, nodeinfo.address);
int forwarding_link = find_link(f.payload.dest);
f.checksum = 0;
f.checksum = CNET_ccitt((unsigned char *)&f, (int)(f.payload.len) + FRAME_HEADER_SIZE);
queue_add(links[forwarding_link].forwarding_queue, &f, len);
//will have to schedule with sender queue
schedule_and_send(forwarding_link);
}
}
wiced_result_t open_websocket(websocket_handshake_t *hs, websocket_msg_handler_t binary_msg_handler, websocket_msg_handler_t text_msg_handler, void *ctx) {
wiced_result_t ret;
wiced_ip_address_t host_ip;
wiced_tls_context_t tls_ctx;
wiced_tcp_socket_t sock;
wiced_tcp_stream_t stream;
char *buf = NULL;
uint32_t i;
https_header_t *header;
WPRINT_LIB_INFO( ("Starting WebSocket handshake to https://%s%s\n", hs->hostname, hs->path) );
ret = wiced_hostname_lookup(hs->hostname, &host_ip, DNS_TIMEOUT);
if (ret != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("DNS lookup failed for %s (err=%u)\n", hs->hostname, ret) );
return ret;
}
wiced_tls_init_context(&tls_ctx, NULL, NULL);
wiced_tcp_create_socket(&sock, WICED_STA_INTERFACE);
wiced_tcp_enable_tls(&sock, &tls_ctx);
{
char ip_str[48];
ip_to_str(&host_ip, ip_str);
WPRINT_LIB_INFO( ("Establishing TLS connection to %s port %d\n", ip_str, HTTPS_PORT) );
}
ret = wiced_tcp_connect(&sock, &host_ip, HTTPS_PORT, HTTPS_CONNECT_TIMEOUT);
if (ret != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("Failed to create TCP connection (err=%u)\n", ret) );
wiced_tcp_delete_socket(&sock);
return ret;
}
do {
ret = wiced_tcp_stream_init(&stream, &sock);
if (ret != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("Failed to initialize TCP stream (err=%u)\n", ret) );
break;
}
buf = (char *)malloc(STREAM_BUF_SIZE);
snprintf(buf, STREAM_BUF_SIZE, "GET %s HTTP/1.1\r\n", hs->path);
WRITE_STREAM(stream, buf, ret);
// Required headers.
snprintf(buf, STREAM_BUF_SIZE,
"Host: %s\r\n" \
"Connection: upgrade\r\n" \
"Upgrade: websocket\r\n" \
"Sec-WebSocket-Key: %s\r\n" \
"Sec-WebSocket-Version: 13\r\n",
hs->hostname, hs->key);
WRITE_STREAM(stream, buf, ret);
// Additional headers.
for (i = 0; i < hs->num_headers; i++) {
header = &(hs->headers[i]);
snprintf(buf, STREAM_BUF_SIZE, "%s: %s\r\n", header->name, header->value);
WRITE_STREAM(stream, buf, ret);
}
if (i < hs->num_headers) {
break;
}
strcpy(buf, "\r\n");
WRITE_STREAM(stream, buf, ret);
ret = wiced_tcp_stream_flush(&stream);
if (ret != WICED_SUCCESS) {
break;
}
ret = process_handshake_response(hs, &sock);
} while (WICED_FALSE);
if (buf) {
free(buf);
}
wiced_tcp_stream_deinit(&stream);
if (ret == WICED_SUCCESS) {
WPRINT_LIB_INFO( ("WebSocket handshake OK\n") );
process_frames(&sock, binary_msg_handler, text_msg_handler, ctx);
WPRINT_LIB_INFO( ("Closing WebSocket.\n") );
}
else {
WPRINT_LIB_INFO( ("WebSocket handshake failed (err=%u)\n", ret) );
}
wiced_tcp_disconnect(&sock);
wiced_tcp_delete_socket(&sock);
return ret;
}
void process_frames(){
if(queue_nitems(receiver) == 0){
return;
}
size_t len = 0;
FRAME *f = queue_peek(receiver, &len);
int source_nodenumber = find_nodenumber(f->payload.source);
if(node_buffer[source_nodenumber].busy){
free(f);
return;
}
node_buffer[source_nodenumber].busy = true;
f = queue_remove(receiver, &len);
//printf("Received frames for message #%d Expecting %d\n", f->payload.mesg_seq_no, node_buffer[source_nodenumber].mesg_seq_no_to_receive);
//If ack has not been received at the sender side and an old frame from an old message has been received
if(f->payload.mesg_seq_no < node_buffer[source_nodenumber].mesg_seq_no_to_receive){
//printf("Message received is old, dropped :-( Message #%d\n", f->payload.mesg_seq_no);
node_buffer[source_nodenumber].busy = false;
free(f);
process_frames();
return;
}
if(f->payload.mesg_seq_no > node_buffer[source_nodenumber].mesg_seq_no_to_receive){
queue_add(receiver, f, len);
//printf("Message received is new, pushed back ;-) Message #%d\n", f->payload.mesg_seq_no);
node_buffer[source_nodenumber].busy = false;
free(f);
//process_frames();
return;
}
int seq_no = f->payload.A;
char seq_str[5];
sprintf(seq_str, "%d", seq_no);
if(seq_no == node_buffer[source_nodenumber].next_seq_number_to_add){
//send ack here
create_ack(f->payload);
// add to the incomplete data object
//printf("Frame appending %d with length %d | MSG #%d\n",seq_no, f->payload.len, f->payload.mesg_seq_no);
memcpy(&node_buffer[source_nodenumber].incomplete_data[0] + node_buffer[source_nodenumber].bytes_added, &f->payload.data[0], f->payload.len);
node_buffer[source_nodenumber].bytes_added += f->payload.len;
node_buffer[source_nodenumber].next_seq_number_to_add++;
while(true){
int next_seq = node_buffer[source_nodenumber].next_seq_number_to_add;
char next_seq_str[5];
sprintf(next_seq_str, "%d", next_seq);
size_t plen;
PACKET *pkt = hashtable_find(node_buffer[source_nodenumber].ooo_packets, next_seq_str, &plen);
if(plen == 0)
break;
//printf("In While loop:Next frame %d found in HT\n",next_seq);
pkt = hashtable_remove(node_buffer[source_nodenumber].ooo_packets, next_seq_str, &plen);
create_ack(*pkt);
memcpy(&node_buffer[source_nodenumber].incomplete_data[0] + node_buffer[source_nodenumber].bytes_added, &pkt->data, pkt->len);
node_buffer[source_nodenumber].bytes_added += pkt->len;
node_buffer[source_nodenumber].next_seq_number_to_add++;
}
// check for the last packet
if(f->payload.flag_offset == 1) {
//printf("\t\t\t\t\t\tBytes in reconstructed message is %d and is sent by %d\n",node_buffer[source_nodenumber].bytes_added, source_nodenumber);
CHECK(CNET_write_application((char*)&node_buffer[source_nodenumber].incomplete_data[0], &node_buffer[source_nodenumber].bytes_added));
node_buffer[source_nodenumber].next_seq_number_to_add = 0;
memset(node_buffer[source_nodenumber].incomplete_data, '\0', MAX_MESSAGE_SIZE);
hashtable_free(node_buffer[source_nodenumber].ooo_packets);
// Overriding default bucket size of 1023
node_buffer[source_nodenumber].ooo_packets = hashtable_new(256);
printf("\t\t\t\t\t\tSuccessfully Written to Application. Bytes in the reconstructed message #%d are %d sent by %d.\n",
f->payload.mesg_seq_no, node_buffer[source_nodenumber].bytes_added, source_nodenumber);
node_buffer[source_nodenumber].bytes_added = 0;
node_buffer[source_nodenumber].mesg_seq_no_to_receive++; //= f->payload.mesg_seq_no;
}
} else {
size_t plen;
hashtable_find(node_buffer[source_nodenumber].ooo_packets, seq_str, &plen);
if(plen == 0){
hashtable_add(node_buffer[source_nodenumber].ooo_packets, seq_str, &f->payload, len - sizeof(uint32_t));
}
}
node_buffer[source_nodenumber].busy = false;
process_frames();
free(f);
}
/**
* @brief Start beacon scan
*
* @return
*/
int cbeacon_start(bool nb)
{
return process_frames(0, nb);
}
