static int h4_process(struct data_source *ds) { // reset tx state before emitting packet sent event // to allow for positive can_send_now if (tx_state == TX_DONE){ tx_state = TX_IDLE; } // notify about packet sent if (tx_send_packet_sent){ // race condition: if tx_state was set after our check, can_send_now will fail, causing a hang // workaround: assert that tx_state is TX_IDLE if it was just set to done by ISR if (tx_state == TX_DONE){ tx_state = TX_IDLE; } tx_send_packet_sent = 0; uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0 }; packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); } if (h4_state != H4_PACKET_RECEIVED) return 0; packet_handler(hci_packet[0], &hci_packet[1], read_pos-1); h4_rx_init_sm(); return 0; }
static void handle_isochronous_data(uint8_t * buffer, uint16_t size){ while (size){ if (size < sco_bytes_to_read){ // just store incomplete data memcpy(&sco_buffer[sco_read_pos], buffer, size); sco_read_pos += size; sco_bytes_to_read -= size; return; } // copy requested data memcpy(&sco_buffer[sco_read_pos], buffer, sco_bytes_to_read); sco_read_pos += sco_bytes_to_read; buffer += sco_bytes_to_read; size -= sco_bytes_to_read; // chunk read successfully, next action switch (sco_state){ case H2_W4_SCO_HEADER: sco_state = H2_W4_PAYLOAD; sco_bytes_to_read = sco_buffer[2]; break; case H2_W4_PAYLOAD: // packet complete packet_handler(HCI_SCO_DATA_PACKET, sco_buffer, sco_read_pos); sco_state_machine_init(); break; } } }
void usb_bt_callback(uint8_t event_type, uint8_t *data, uint16_t size) { switch(event_type) { case USB_BT_EVENT_INTERRUPT_READ: hci_dump_packet( HCI_EVENT_PACKET, 1, data, size); packet_handler(HCI_EVENT_PACKET,data,size); break; case USB_BT_EVENT_BULK_READ: hci_dump_packet( HCI_ACL_DATA_PACKET, 1, data, size); packet_handler(HCI_ACL_DATA_PACKET,data,size); break; default: break; } }
void dump_ethernet_raw_packet(uint8 bInput, char* szMessage, uint8 *payload, int32 len) { extern int g_modePacketDump; extern int g_modePacketInfo; extern uint8_t g_macFilterUse; extern uint8_t g_macFilter1[6]; extern uint8_t g_macFilter2[6]; if ( g_macFilterUse ) { if ( memcmp(payload, g_macFilter1, 6)==0 && memcmp(payload+6, g_macFilter1, 6)==0 && memcmp(payload+6, g_macFilter2, 6)==0 && memcmp(payload+6, g_macFilter2, 6)==0 ) { return; } } if ( g_modePacketDump==1 ) { ets_uart_printf(szMessage); ets_uart_printf(" (%d)\r\n", len); wdump(payload, len); } if ( g_modePacketInfo==1 ) { void packet_handler(uint32_t packet_length, const uint8_t *packet); packet_handler(len, payload); } }
// executed on main run loop static wiced_result_t h4_main_deliver_packet(void *arg){ // deliver packet packet_handler(hci_packet[0], &hci_packet[1], rx_worker_read_pos-1); // trigger receive of next packet wiced_rtos_send_asynchronous_event(&rx_worker_thread, &h4_rx_worker_receive_packet, NULL); return WICED_SUCCESS; }
static void h4_process(btstack_data_source_t *ds, btstack_data_source_callback_type_t callback_type) { if (hci_transport_h4->ds->fd == 0) return; // read up to bytes_to_read data in ssize_t bytes_read = mtk_bt_read(hci_transport_h4->ds->fd, &hci_packet_in[0], sizeof(hci_packet_in)); if (bytes_read == 0) return; // iterate over packets uint16_t pos = 0; while (pos < bytes_read) { uint16_t packet_len; switch(hci_packet_in[pos]){ case HCI_EVENT_PACKET: packet_len = hci_packet_in[pos+2] + 3; break; case HCI_ACL_DATA_PACKET: packet_len = little_endian_read_16(hci_packet_in, pos + 3) + 5; break; default: log_error("h4_process: invalid packet type 0x%02x\n", hci_packet_in[pos]); return; } packet_handler(hci_packet_in[pos], &hci_packet_in[pos+1], packet_len-1); pos += packet_len; } }
/* function: read_packet * reads a packet from the tunnel fd and passes it down the stack * active_fd - tun file descriptor marked ready for reading * tunnel - tun device data */ void read_packet(int active_fd, const struct tun_data *tunnel) { ssize_t readlen; char packet[PACKETLEN]; // in case something ignores the packet length memset(packet, 0, PACKETLEN); readlen = read(active_fd,packet,PACKETLEN); if(readlen < 0) { logmsg(ANDROID_LOG_WARN,"read_packet/read error: %s", strerror(errno)); return; } else if(readlen == 0) { logmsg(ANDROID_LOG_WARN,"read_packet/tun interface removed"); running = 0; } else { struct tun_pi tun_header; ssize_t header_size = sizeof(struct tun_pi); if(readlen < header_size) { logmsg(ANDROID_LOG_WARN,"read_packet/short read: got %ld bytes", readlen); return; } packet_handler(tunnel, (struct tun_pi *) packet, packet + header_size, readlen - header_size); } }
// executed on main run loop static wiced_result_t h4_main_notify_packet_send(void *arg){ // prepare for next packet tx_worker_data_size = 0; // notify upper stack that it might be possible to send again uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0}; packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); return WICED_SUCCESS; }
static void h4_deliver_packet(void) { if (read_pos < 3) return; // sanity check packet_handler(hci_packet[0], &hci_packet[1], read_pos-1); h4_state = H4_W4_PACKET_TYPE; read_pos = 0; bytes_to_read = 1; }
int main (int argc, char **argv) { SLpacket * slpack; int seqnum; int ptype; #ifndef WIN32 /* Signal handling, use POSIX calls with standardized semantics */ struct sigaction sa; sigemptyset (&sa.sa_mask); sa.sa_flags = SA_RESTART; sa.sa_handler = term_handler; sigaction (SIGINT, &sa, NULL); sigaction (SIGQUIT, &sa, NULL); sigaction (SIGTERM, &sa, NULL); sa.sa_handler = SIG_IGN; sigaction (SIGHUP, &sa, NULL); sigaction (SIGPIPE, &sa, NULL); #endif /* Allocate and initialize a new connection description */ slconn = sl_newslcd(); /* Process given parameters (command line and parameter file) */ if (parameter_proc (argc, argv) < 0) { fprintf(stderr, "Parameter processing failed\n\n"); fprintf(stderr, "Try '-h' for detailed help\n"); return -1; } /* Loop with the connection manager */ while ( sl_collect (slconn, &slpack) ) { ptype = sl_packettype (slpack); seqnum = sl_sequence (slpack); packet_handler ((char *) &slpack->msrecord, ptype, seqnum, SLRECSIZE); /* It would be possible to send an in-line INFO request here with sl_request_info(). */ } /* Make sure everything is shut down and save the state file */ if (slconn->link != -1) sl_disconnect (slconn); if (statefile) sl_savestate (slconn, statefile); return 0; } /* End of main() */
static int h4_process(struct data_source *ds) { // notify about packet sent if (tx_state == TX_DONE){ // reset state tx_state = TX_IDLE; uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0 }; packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); } if (h4_state != H4_PACKET_RECEIVED) return 0; packet_handler(hci_packet[0], &hci_packet[1], read_pos-1); h4_init_sm(); return 0; }
static void h4_process(btstack_data_source_t *ds, btstack_data_source_callback_type_t callback_type) { // notify about packet sent if (tx_state == TX_DONE){ // reset state tx_state = TX_IDLE; uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0 }; packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); } if (h4_state != H4_PACKET_RECEIVED) return; packet_handler(hci_packet[0], &hci_packet[1], read_pos-1); h4_init_sm(); return; }
BOOL USBHostBluetoothCallback(BLUETOOTH_EVENT event, USB_EVENT status, void *data, DWORD size) { uint8_t e; switch (event) { case BLUETOOTH_EVENT_WRITE_BULK_DONE: case BLUETOOTH_EVENT_WRITE_CONTROL_DONE: e = DAEMON_EVENT_HCI_PACKET_SENT; packet_handler(HCI_EVENT_PACKET, &e, 1); return TRUE; case BLUETOOTH_EVENT_ATTACHED: case BLUETOOTH_EVENT_DETACHED: return TRUE; case BLUETOOTH_EVENT_READ_BULK_DONE: if (status == USB_SUCCESS) { if (size) { if (packet_handler) { packet_handler(HCI_ACL_DATA_PACKET, data, size); } } } else { log_printf("Read bulk failure"); } return TRUE; case BLUETOOTH_EVENT_READ_INTERRUPT_DONE: if (status == USB_SUCCESS) { if (size) { if (packet_handler) { packet_handler(HCI_EVENT_PACKET, data, size); } } } else { log_printf("Read bulk failure"); } return TRUE; default: return FALSE; } }
int Client_Poll(NNET_STATUS *status) { u32 _err = 0; switch (NNet_GetStatus(status)) { case State_NoData: { /* NEURO_TRACE("No data", NULL); */ } break; case State_Disconnect: { TRACE("Internal Quit flagged, leaving"); return 1; } case State_ClientDisconnect: { TRACE("Disconnect order by the server, leaving"); /* closing the server */ return 1; } break; case State_DataAvail: { _err = packet_handler(NNet_GetSlave(status), NNet_GetPacket(status), NNet_GetPacketLen(status)); } break; default: { ERROR(Neuro_s("unknown status %d", NNet_GetStatus(status))); return 1; } break; } if (ACTIVE_CLIENT_ENABLED && client_active == 1) Active_Poll(); if (alive_time < Neuro_GetTickCount()) { alive_time = Neuro_GetTickCount() + ALIVE_TIME; Packet_Reset(pktbuf); Packet_Push32(pktbuf, NET_ALIVE); Packet_Push32(pktbuf, 0); Client_SendPacket(Packet_GetBuffer(pktbuf), Packet_GetLen(pktbuf)); } return _err; }
static void handoff_handler(GstFakeSink *fakesink, GstBuffer *buffer, GstPad *pad, gpointer user_data) { struct ausrc_st *st = user_data; (void)fakesink; (void)pad; format_check(st, gst_caps_get_structure(GST_BUFFER_CAPS(buffer), 0)); packet_handler(st, buffer); }
static void handoff_handler(GstFakeSink *fakesink, GstBuffer *buffer, GstPad *pad, gpointer user_data) { struct ausrc_st *st = user_data; GstCaps *caps; (void)fakesink; caps = gst_pad_get_current_caps(pad); format_check(st, gst_caps_get_structure(caps, 0)); packet_handler(st, buffer); }
ssize_t read_from_sock(int sockfd, rtp_session_type_t session_type, int is_rtcp, struct rtp_stream *stream) { struct timeval now; ssize_t len = -1; RD_buffer_t packet; gettimeofday(&now, 0); len = recv(sockfd, packet.p.data, sizeof(packet.p.data), 0); //v originale recvfrom if(len == -1) { rtp_print_log(RTP_WARN, "recv() failed with errno %s\n", strerror(errno)); return 0; } packet_handler(now, is_rtcp, &packet, len, session_type, stream); return len; }
static int usb_send_sco_packet(uint8_t *packet, int size){ #ifdef HAVE_SCO int r; if (libusb_state != LIB_USB_TRANSFERS_ALLOCATED) return -1; // log_info("usb_send_acl_packet enter, size %u", size); // store packet in free slot int tranfer_index = sco_ring_write; uint8_t * data = &sco_ring_buffer[tranfer_index * SCO_PACKET_SIZE]; memcpy(data, packet, size); // setup transfer struct libusb_transfer * sco_transfer = sco_ring_transfers[tranfer_index]; libusb_fill_iso_transfer(sco_transfer, handle, sco_out_addr, data, size, NUM_ISO_PACKETS, async_callback, NULL, 0); libusb_set_iso_packet_lengths(sco_transfer, ISO_PACKET_SIZE); r = libusb_submit_transfer(sco_transfer); if (r < 0) { log_error("Error submitting sco transfer, %d", r); return -1; } // mark slot as full sco_ring_write++; if (sco_ring_write == SCO_RING_BUFFER_COUNT){ sco_ring_write = 0; } sco_ring_transfers_active++; // log_info("H2: queued packet at index %u, num active %u", tranfer_index, sco_ring_transfers_active); // notify upper stack that packet processed and that it might be possible to send again if (sco_ring_have_space()){ uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0}; packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); } #endif return 0; }
static void read_handler(nl_event_t *ev) { static char s_recv_buff[RECV_BUFF_SIZE]; int rc; nl_socket_t *sock; nl_stream_t *s; sock = ev->data; log_trace("#%d read_handler", sock->fd); s = sock->data; s->error = 0; for ( ; ; ) { rc = nl_recv(sock, s_recv_buff, RECV_BUFF_SIZE); if (rc < 0) { if (!sock->error) { /* EAGAIN || EWOULDBLOCK */ return; } s->error = 1; break; } else if (rc == 0) { break; } else { rc = packet_handler(s, s_recv_buff, rc); if (rc < 0) { s->error = 1; break; } else if (!sock->rev.active) { return; } } } nl_stream_close(s); }
void loop() { //// Using this, instead of timer_interrupt //if (Serial1.available()) { //GPS.read(); //} // if a sentence is received, we can check the checksum, parse it... if (GPS.newNMEAreceived()) { // a tricky thing here is if we print the NMEA sentence, or data // we end up not listening and catching other sentences! // so be very wary if using OUTPUT_ALLDATA and trytng to print out data //SerialUSB.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false if (!GPS.parse(GPS.lastNMEA())) { // this also sets the newNMEAreceived() flag to false SerialUSB.println("parsed: FAILED"); return;// continue; // we can fail to parse a sentence in which case we should just wait for another } else { // Format the data crim::GPSData gps_data; gps_data.set_time(GPS.hour, GPS.minute, GPS.seconds, GPS.milliseconds); gps_data.set_date(GPS.year, GPS.month, GPS.day); gps_data.set_pose(GPS.latitude, GPS.lat, GPS.longitude, GPS.lon, GPS.altitude); gps_data.set_misc(GPS.speed, GPS.angle); gps_data.set_note(GPS.fix, GPS.fixquality, GPS.satellites); crim::FlymaplePacketHandler packet_handler("Serial1", SERIAL1_BAUD_RATE); packet_handler.wrap(gps_data); packet_handler.send(); } } else { SerialUSB.println("!GPS.newNMEAreceived()"); } }
int main(int argc, char *argv[]) { int result; int pcap_available=0; char dev_name[20]; signal(SIGUSR2, signal_key); if(argc>1){ strcpy(dev_name,argv[1]); }else{ strcpy(dev_name,DEFAULT_PCAP_DEV); } init_gcrypt(&gcry_hd); struct hostent *hp; sock= socket(AF_INET, SOCK_DGRAM, 0); server.sin_family = AF_INET; server.sin_port = htons(PORT_IMU); hp = gethostbyname(IP_IMU); if (hp==0) printf("IMU IP no alcanzable"); bcopy((char *)hp->h_addr, (char *)&server.sin_addr,hp->h_length); const u_char pkt_data[4096]; u_char *param; int rawSocket = openSocket( dev_name ); if ( rawSocket < 0 ) { fprintf( stderr, "error opening socket\n" ); return 1; } gcry_cipher_setkey (gcry_hd,gcry_key,GCRY_KEYLEN); printf("\r\nINIT INTERCEPTOR"); fflush(stdout); while(1){ fd_set readfds; FD_ZERO( &readfds ); FD_SET( rawSocket, &readfds ); int numFds = select( rawSocket+1, &readfds, NULL, NULL, NULL ); if ( numFds == 1 ) { int caplen = read( rawSocket, pkt_data, sizeof( pkt_data) ); if(pkt_data!=NULL){ packet_handler(pkt_data,caplen); } } } printf("\r\n EXITED"); return(0); }
static void h4_deliver_packet(void){ if (read_pos < 3) return; // sanity check packet_handler(hci_packet[0], &hci_packet[1], read_pos-1); h4_reset_statemachine(); }
static void handle_completed_transfer(struct libusb_transfer *transfer){ int resubmit = 0; int signal_done = 0; if (transfer->endpoint == event_in_addr) { packet_handler(HCI_EVENT_PACKET, transfer-> buffer, transfer->actual_length); resubmit = 1; } else if (transfer->endpoint == acl_in_addr) { // log_info("-> acl"); packet_handler(HCI_ACL_DATA_PACKET, transfer-> buffer, transfer->actual_length); resubmit = 1; } else if (transfer->endpoint == sco_in_addr) { // log_info("handle_completed_transfer for SCO IN! num packets %u", transfer->NUM_ISO_PACKETS); int i; for (i = 0; i < transfer->num_iso_packets; i++) { struct libusb_iso_packet_descriptor *pack = &transfer->iso_packet_desc[i]; if (pack->status != LIBUSB_TRANSFER_COMPLETED) { log_error("Error: pack %u status %d\n", i, pack->status); continue; } if (!pack->actual_length) continue; uint8_t * data = libusb_get_iso_packet_buffer_simple(transfer, i); // printf_hexdump(data, pack->actual_length); // log_info("handle_isochronous_data,size %u/%u", pack->length, pack->actual_length); handle_isochronous_data(data, pack->actual_length); } resubmit = 1; } else if (transfer->endpoint == 0){ // log_info("command done, size %u", transfer->actual_length); usb_command_active = 0; signal_done = 1; } else if (transfer->endpoint == acl_out_addr){ // log_info("acl out done, size %u", transfer->actual_length); usb_acl_out_active = 0; signal_done = 1; } else if (transfer->endpoint == sco_out_addr){ log_info("sco out done, {{ %u/%u (%x)}, { %u/%u (%x)}, { %u/%u (%x)}}", transfer->iso_packet_desc[0].actual_length, transfer->iso_packet_desc[0].length, transfer->iso_packet_desc[0].status, transfer->iso_packet_desc[1].actual_length, transfer->iso_packet_desc[1].length, transfer->iso_packet_desc[1].status, transfer->iso_packet_desc[2].actual_length, transfer->iso_packet_desc[2].length, transfer->iso_packet_desc[2].status); if (!sco_ring_have_space()) { // if there isn't space, the last SCO send didn't emit a packet sent event signal_done = 1; } // decrease tab sco_ring_transfers_active--; // log_info("H2: sco out complete, num active num active %u", sco_ring_transfers_active); } else { log_info("usb_process_ds endpoint unknown %x", transfer->endpoint); } if (signal_done){ // notify upper stack that iit might be possible to send again uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0}; packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); } if (libusb_state != LIB_USB_TRANSFERS_ALLOCATED) return; if (resubmit){ // Re-submit transfer transfer->user_data = NULL; int r = libusb_submit_transfer(transfer); if (r) { log_error("Error re-submitting transfer %d", r); } } }
static int packet_handler(NNET_SLAVE *conn, const char *data, u32 len) { Pkt_Header *whole; void *buffer; char *newData = NULL; int newLen = 0; char *nextData = NULL; int nextLen = 0; int handleNextData = 0; /* NEURO_TRACE("recieved packet len %d", len); */ if (len <= 0 || !data) { WARN("Invalid packet recieved"); return 1; } { int _err = 0; _err = PktAsm_Process(pktAsmCtx, packetGetSize, (char*)data, len, &newData, &newLen, &nextData, &nextLen); switch (_err) { case 0: { /* needs more data */ return 0; } break; case 1: { /* successfully scavenged a new packet */ whole = (Pkt_Header*)newData; len = newLen; PktAsm_Reset(pktAsmCtx); } break; case 2: { /* successfully scavenged a new packet and got more data available */ handleNextData = 1; whole = (Pkt_Header*)newData; len = newLen; PktAsm_Reset(pktAsmCtx); } break; case 3: { /* could not do anything with the data. */ } break; default: { ERROR("PktAsm_Process : unrecoverable error"); return 1; } break; } } buffer = &whole[1]; switch (whole->type) { case NET_DATA: { /* we remove the length of the header variables */ Passive_HandleData(buffer, whole->size - 8); } break; case NET_INFO: { Pkt_Info *tmp; int cols = 0, rows = 0; TRACE("NET_INFO packet received"); tmp = (Pkt_Info*)buffer; if (tmp->access == 0) { TRACE("Server access denied"); return 1; } if (newLen >= sizeof(Pkt_WSize)) { cols = tmp->cols; rows = tmp->rows; } else { /* we disconnect */ return 1; } if (client_active == 1) { TRACE("Starting Active Session"); Active_SendWSize(); Active_StartSession(); } else { Passive_SetScreenSize(cols, rows); } } case NET_ALIVE: { } break; case NET_DISCONNECT: { printf("Disconnection packet recieved from server... bailing out\n"); return 1; } break; case NET_LIST: { Pkt_List *buf; buf = buffer; printf(Neuro_s("Active client %s -- Session Layer #%d\n", buf->name, buf->layers)); } break; default: { WARN(Neuro_s("Unhandled packet type recieved -- type %d", whole->type)); } break; } Packet_Reset(pktbuf); if (handleNextData) { return packet_handler(conn, nextData, nextLen); } return 0; }
BOOL USBHostUSBBTEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size ) { switch (event) { case EVENT_NONE: // No event occured (NULL event) return TRUE; break; case EVENT_DETACH: // USB cable has been detached (data: BYTE, address of device) g_usbbt.initialized = 0; g_usbbt.deviceAddress = 0; UART2PrintString( "USBBT detach \r\n" ); return TRUE; break; case EVENT_TRANSFER: // A USB transfer has completed - optional #if defined( USB_ENABLE_TRANSFER_EVENT ) if ( (data != NULL) && (size == sizeof(HOST_TRANSFER_DATA)) ) { DWORD i; DWORD dataCount = ((HOST_TRANSFER_DATA *)data)->dataCount; BYTE *userData = ((HOST_TRANSFER_DATA *)data)->pUserData; // BYTE errorCode = ((HOST_TRANSFER_DATA *)data)->bErrorCode; if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointBulkIN ) { g_usbbt.endpointBulkIN_Busy = 0; if(dataCount != 0) { UART2PrintString( "BulkIN " ); for(i = 0; i < dataCount; i++) { UART2PutHex(userData[i]); } UART2PrintString( "\r\n" ); // bt event usb_bt_call_handler(USB_BT_EVENT_BULK_READ,userData,dataCount); } } else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointBulkOUT ) { UART2PrintString( "BulkOUT \r\n" ); g_usbbt.endpointBulkOUT_Busy = 0; uint8_t dummy_event = DAEMON_EVENT_HCI_PACKET_SENT; packet_handler(HCI_EVENT_PACKET, &dummy_event, 1); } else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointCtrl ) { UART2PrintString( "Ctrl \r\n" ); g_usbbt.endpointCtrl_Busy = 0; uint8_t dummy_event = DAEMON_EVENT_HCI_PACKET_SENT; packet_handler(HCI_EVENT_PACKET, &dummy_event, 1); } else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointInt ) { g_usbbt.endpointInt_Busy = 0; if(dataCount != 0) { UART2PrintString( "Int " ); for(i = 0; i < dataCount; i++) { UART2PutHex(userData[i]); } UART2PrintString( "\r\n" ); // bt event usb_bt_call_handler(USB_BT_EVENT_INTERRUPT_READ,userData,dataCount); } } else { return FALSE; } if(!g_usbbt.endpointCtrl_Busy && !g_usbbt.endpointBulkOUT_Busy) { if(g_usbbt.endpointBulkIN_Busy == 0) { USBHostBlukRead(g_usbbt.deviceAddress,bulk_buf,MAX_DATA_PACKET_LENGTH); } if(g_usbbt.endpointInt_Busy == 0) { USBHostIntRead(g_usbbt.deviceAddress,int_buf,MAX_DATA_PACKET_LENGTH); } } return TRUE; } else return FALSE; #endif case EVENT_SOF: // Start of frame - NOT NEEDED case EVENT_RESUME: // Device-mode resume received case EVENT_SUSPEND: // Device-mode suspend/idle event received case EVENT_RESET: // Device-mode bus reset received case EVENT_STALL: // A stall has occured case EVENT_BUS_ERROR: default: break; } return FALSE; }
static void packet_handler2 (void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ packet_handler(packet_type, 0, packet, size); }