static int recv_packet(sport_t fd, struct packet *pkt) { uint8_t header[4]; if (sport_read_all(fd, header, 4) < 0) { printc_err("goodfet: recv_packet (header): %s\n", last_error()); return -1; } pkt->app = header[0]; pkt->verb = header[1]; pkt->len = ((uint16_t)header[2]) | (((uint16_t)header[3]) << 8); if (pkt->len > MAX_LEN) { printc_err("goodfet: recv_packet: maximum length " "exceeded (%d)\n", pkt->len); return -1; } if (sport_read_all(fd, pkt->data, pkt->len) < 0) { printc_err("goodfet: recv_packet (data): %s\n", last_error()); return -1; } #ifdef DEBUG_GOODFET printc_dbg("RECV: %02x/%02x\n", pkt->app, pkt->verb); if (pkt->len) debug_hexdump("Data", pkt->data, pkt->len); #endif return 0; }
static int usbtr_recv(transport_t tr_base, uint8_t *databuf, int max_len) { struct rf2500_transport *tr = (struct rf2500_transport *)tr_base; int rlen; if (tr->offset >= tr->len) { if (usb_bulk_read(tr->handle, USB_FET_IN_EP, (char *)tr->buf, sizeof(tr->buf), 10000) < 0) { pr_error("rf2500: can't receive data"); return -1; } #ifdef DEBUG_USBTR debug_hexdump("USB transfer in", tr->buf, 64); #endif tr->len = tr->buf[1] + 2; if (tr->len > sizeof(tr->buf)) tr->len = sizeof(tr->buf); tr->offset = 2; } rlen = tr->len - tr->offset; if (rlen > max_len) rlen = max_len; memcpy(databuf, tr->buf + tr->offset, rlen); tr->offset += rlen; return rlen; }
static int usbtr_recv(transport_t tr_base, uint8_t *databuf, int max_len) { struct cp210x_transport *tr = (struct cp210x_transport *)tr_base; int rlen; time_t deadline = time(NULL) + TIMEOUT_S; #ifdef DEBUG_CP210X printc(__FILE__": %s : read max %d\n", __FUNCTION__, max_len); #endif while (time(NULL) < deadline) { rlen = usb_bulk_read(tr->handle, V1_IN_EP, (char *)databuf, max_len, TIMEOUT_S * 1000); #ifdef DEBUG_CP210X printc(__FILE__": %s : read %d\n", __FUNCTION__, rlen); #endif if (rlen < 0) { pr_error(__FILE__": can't receive data"); return -1; } if (rlen > 0) { #ifdef DEBUG_CP210X debug_hexdump(__FILE__": USB transfer in", databuf, rlen); #endif return rlen; } } pr_error(__FILE__": read operation timed out"); return -1; }
static int usbtr_recv(transport_t tr_base, uint8_t *databuf, int max_len) { struct olimex_transport *tr = (struct olimex_transport *)tr_base; int rlen; #ifdef DEBUG_OLIMEX printc(__FILE__": %s : read max %d\n", __FUNCTION__, max_len); #endif rlen = usb_bulk_read(tr->handle, tr->in_ep, (char *)databuf, max_len, TIMEOUT); #ifdef DEBUG_OLIMEX printc(__FILE__": %s : read %d\n", __FUNCTION__, rlen); #endif if (rlen < 0) { pr_error(__FILE__": can't receive data"); return -1; } #ifdef DEBUG_OLIMEX debug_hexdump(__FILE__": USB transfer in", databuf, rlen); #endif return rlen; }
static int send_packet(sport_t fd, uint8_t app, uint8_t verb, uint16_t len, const uint8_t *data) { uint8_t raw[MAX_LEN + 4]; if (len > MAX_LEN) { printc_err("goodfet: send_packet: maximum length " "exceeded (%d)\n", len); return -1; } #ifdef DEBUG_GOODFET printc_dbg("SEND: %02x/%02x\n", app, verb); if (len) debug_hexdump("Data", data, len); #endif raw[0] = app; raw[1] = verb; raw[2] = len & 0xff; raw[3] = len >> 8; memcpy(raw + 4, data, len); if (sport_write_all(fd, raw, len + 4) < 0) { printc_err("goodfet: send_packet: %s\n", last_error()); return -1; } return 0; }
static int bslhid_send(transport_t base, const uint8_t *data, int len) { struct bslhid_transport *tr = (struct bslhid_transport *)base; uint8_t outbuf[BSLHID_XFER_SIZE]; if (!tr->handle) { printc_err("bslhid: send on suspended device\n"); return -1; } memset(outbuf, 0xac, sizeof(outbuf)); if (len > BSLHID_MTU) { printc_err("bslhid: send in excess of MTU: %d\n", len); return -1; } outbuf[0] = BSLHID_HEADER; outbuf[1] = len; memcpy(outbuf + 2, data, len); #ifdef DEBUG_BSLHID debug_hexdump("bslhid_send", outbuf, sizeof(outbuf)); #endif if (usb_bulk_write(tr->handle, tr->out_ep, (char *)outbuf, sizeof(outbuf), BSLHID_TIMEOUT) < 0) { printc_err("bslhid: usb_bulk_write: %s\n", usb_strerror()); return -1; } return 0; }
TShutdownMode CKernel::Run (void) { m_Logger.Write (FromKernel, LogNotice, "Compile time: " __DATE__ " " __TIME__); CNetDevice *pEth0 = (CNetDevice *) m_DeviceNameService.GetDevice ("eth0", FALSE); if (pEth0 == 0) { m_Logger.Write (FromKernel, LogError, "Net device not found"); return ShutdownHalt; } // wait for Ethernet PHY to come up m_Timer.MsDelay (2000); m_Logger.Write (FromKernel, LogNotice, "Dumping received broadcasts"); while (1) { unsigned char FrameBuffer[FRAME_BUFFER_SIZE]; unsigned nFrameLength; if (pEth0->ReceiveFrame (FrameBuffer, &nFrameLength)) { CString Sender ("???"); CString Protocol ("???"); if (nFrameLength >= 14) { CMACAddress MACSender (FrameBuffer+6); MACSender.Format (&Sender); unsigned nProtocol = *(unsigned short *) (FrameBuffer+12); switch (nProtocol) { case BE (0x800): Protocol = "IP"; break; case BE (0x806): Protocol = "ARP"; break; default: break; } } m_Logger.Write (FromKernel, LogNotice, "%u bytes received from %s (protocol %s)", nFrameLength, (const char *) Sender, (const char *) Protocol); #ifndef NDEBUG debug_hexdump (FrameBuffer, nFrameLength, FromKernel); #endif } } return ShutdownHalt; }
int main(int argc, char **argv) { struct hpack_dht *dht; struct http_hdr list[MAX_HDR_NUM]; int outlen; int dht_size = 4096; int len, idx; int line; /* first arg: dht size */ if (argc > 1) { dht_size = atoi(argv[1]); argv++; argc--; } dht = hpack_dht_alloc(dht_size); if (!dht) { die(1, "cannot initialize dht\n"); return 1; } for (line = 1; fgets(hex, sizeof(hex), stdin); line++) { len = hex2bin(hex, buf, sizeof(buf)); if (len <= 0) continue; printf("###### line %d : frame len=%d #######\n", line, len); debug_hexdump(stdout, " ", (const char *)buf, 0, len); outlen = hpack_decode_frame(dht, buf, len, list, sizeof(list)/sizeof(list[0]), &tmp); if (outlen <= 0) { printf(" HPACK decoding failed: %d\n", outlen); continue; } printf("<<< Found %d headers :\n", outlen); for (idx = 0; idx < outlen - 1; idx++) { //printf(" \e[1;34m%s\e[0m: ", // list[idx].n.ptr ? istpad(trash.str, list[idx].n).ptr : h2_phdr_to_str(list[idx].n.len)); //printf("\e[1;35m%s\e[0m\n", istpad(trash.str, list[idx].v).ptr); printf(" %s: ", list[idx].n.ptr ? istpad(trash.area, list[idx].n).ptr : h2_phdr_to_str(list[idx].n.len)); printf("%s [n=(%p,%d) v=(%p,%d)]\n", istpad(trash.area, list[idx].v).ptr, list[idx].n.ptr, (int)list[idx].n.len, list[idx].v.ptr, (int)list[idx].v.len); } puts(">>>"); #ifdef DEBUG_HPACK printf("<<=== DHT dump [ptr=%p]:\n", dht); hpack_dht_dump(stdout, dht); puts("===>>"); #endif } return 0; }
void CUSBConfigurationParser::Error (const char *pSource) const { assert (pSource != 0); CLogger::Get ()->Write (pSource, LogError, "Invalid configuration descriptor (offset 0x%X)", (unsigned) m_pErrorPosition - (unsigned) m_pBuffer); #ifndef NDEBUG debug_hexdump (m_pBuffer, m_nBufLen, pSource); #endif }
gboolean udp_read(GSocket *socket, GIOCondition condition, gpointer user_data) { uint8_t buf[100]; GSocketAddress * src; struct socketdata *sd = user_data; struct node *n = sd->n; guint classid = sd->classid; gssize len; if( condition == G_IO_IN ){ len = g_socket_receive_from(socket,&src,(gchar*)buf, sizeof(buf),NULL,NULL); if( len > 0 ){ syslog(LOG_DEBUG,"udp_read: Received:"); debug_hexdump(buf,len); syslog(LOG_DEBUG,"\n"); if( user_data != NULL ){ bus_sendToID(n->id, buf, len, classid, FALSE); }else{ //UDP data to the mgt port is ignored } }else{ syslog(LOG_WARNING,"udp_read: Error while receiving: len=%d\n",len); } }else{ syslog(LOG_DEBUG,"udp_read: Received "); if( condition == G_IO_ERR ){ syslog(LOG_DEBUG,"G_IO_ERR\n"); }else if( condition == G_IO_HUP ){ syslog(LOG_DEBUG,"G_IO_HUP\n"); }else if( condition == G_IO_OUT ){ syslog(LOG_DEBUG,"G_IO_OUT\n"); }else if( condition == G_IO_PRI ){ syslog(LOG_DEBUG,"G_IO_PRI\n"); }else if( condition == G_IO_NVAL ){ syslog(LOG_DEBUG,"G_IO_NVAL\ndropping source\n"); return FALSE; }else{ syslog(LOG_DEBUG,"unkown condition = %d\n",condition); } } return TRUE; }
static int bslhid_recv(transport_t base, uint8_t *data, int max_len) { struct bslhid_transport *tr = (struct bslhid_transport *)base; uint8_t inbuf[BSLHID_XFER_SIZE]; int r; int len; if (!tr->handle) { printc_err("bslhid: recv on suspended device\n"); return -1; } r = usb_bulk_read(tr->handle, tr->in_ep, (char *)inbuf, sizeof(inbuf), BSLHID_TIMEOUT); if (r <= 0) { printc_err("bslhid_recv: usb_bulk_read: %s\n", usb_strerror()); return -1; } #ifdef DEBUG_BSLHID debug_hexdump("bslhid_recv", inbuf, r); #endif if (r < 2) { printc_err("bslhid_recv: short transfer\n"); return -1; } if (inbuf[0] != BSLHID_HEADER) { printc_err("bslhid_recv: missing transfer header\n"); return -1; } len = inbuf[1]; if ((len > max_len) || (len + 2 > r)) { printc_err("bslhid_recv: bad length: %d (%d byte transfer)\n", len, r); return -1; } memcpy(data, inbuf + 2, len); return len; }
static int usbtr_send(transport_t tr_base, const uint8_t *data, int len) { struct cp210x_transport *tr = (struct cp210x_transport *)tr_base; int sent; #ifdef DEBUG_CP210X debug_hexdump(__FILE__ ": USB transfer out", data, len); #endif while (len) { sent = usb_bulk_write(tr->handle, V1_OUT_EP, (char *)data, len, TIMEOUT_S * 1000); if (sent <= 0) { pr_error(__FILE__": can't send data"); return -1; } data += sent; len -= sent; } return 0; }
static int usbtr_send(transport_t tr_base, const uint8_t *data, int len) { struct olimex_transport *tr = (struct olimex_transport *)tr_base; int sent; while (len) { #ifdef DEBUG_OLIMEX debug_hexdump(__FILE__": USB transfer out", data, len); #endif sent = usb_bulk_write(tr->handle, tr->out_ep, (char *)data, len, TIMEOUT); if (sent < 0) { pr_error(__FILE__": can't send data"); return -1; } len -= sent; } return 0; }
static int usbtr_send(transport_t tr_base, const uint8_t *data, int len) { struct rf2500_transport *tr = (struct rf2500_transport *)tr_base; while (len) { uint8_t pbuf[256]; int plen = len > 255 ? 255 : len; int txlen = plen + 1; memcpy(pbuf + 1, data, plen); /* This padding is needed to work around an apparent bug in * the RF2500 FET. Without this, the device hangs. */ if (txlen > 32 && (txlen & 0x3f)) while (txlen < 255 && (txlen & 0x3f)) pbuf[txlen++] = 0xff; else if (txlen > 16 && (txlen & 0xf)) while (txlen < 255 && (txlen & 0xf) != 1) pbuf[txlen++] = 0xff; pbuf[0] = txlen - 1; #ifdef DEBUG_USBTR debug_hexdump("USB transfer out", pbuf, txlen); #endif if (usb_bulk_write(tr->handle, USB_FET_OUT_EP, (char *)pbuf, txlen, 10000) < 0) { pr_error("rf2500: can't send data"); return -1; } data += plen; len -= plen; } return 0; }
void DebugHexdump (const void *pBuffer, unsigned nBufLen, const char *pSource) { debug_hexdump (pBuffer, nBufLen, pSource); }
static void tcp_usb_callback(tcp_usb_state_t *state, int _can_read, int _can_write) { if(state->closed) return; int ret; switch(state->state) { case tcp_usb_idle: if(!_can_read) return; debug_printf("%s: tcp_usb_idle.\n", __func__); // Receiving new request state->header = malloc(sizeof(*state->header)); state->amount_done = 0; state->state = tcp_usb_read_request; // Fall through case tcp_usb_read_request: // debug_printf("%s: tcp_usb_read_request\n", __func__); if(state->amount_done < sizeof(*state->header)) { ret = read(state->socket, ((char*)state->header) + state->amount_done, sizeof(*state->header) - state->amount_done); if(ret == 0 && _can_read) { free(state->header); tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d reading request header!\n", ret); return; } _can_read = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header)) return; debug_hexdump("tcp_usb: Got Header: ", state->header, sizeof(*state->header)); if(state->header->length > 0) state->buffer = malloc(state->header->length); else state->buffer = NULL; } if((state->header->ep & USB_DIR_IN) == 0 && state->header->length > 0) // OUT { ret = read(state->socket, ((char*)state->buffer) + (state->amount_done - sizeof(*state->header)), state->header->length - (state->amount_done - sizeof(*state->header))); if(ret == 0 && _can_read) { free(state->header); if(state->buffer) free(state->buffer); tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d reading request data!\n", ret); return; } _can_read = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header) + state->header->length) return; debug_hexdump("tcp_usb: Read: ", state->buffer, state->header->length); } // Transfer complete! Call callback! if(state->data_callback) { state->state = tcp_usb_write_response; state->amount_done = 0; debug_printf("tcp_usb: Calling callback.\n"); ret = state->data_callback(state, state->callback_arg, state->header, state->buffer); state->header->length = ret; } else { fprintf(stderr, "tcp_usb: Packet received but no callback!\n"); state->state = tcp_usb_idle; return; } // Fall through case tcp_usb_write_response: debug_printf("%s: tcp_usb_write_response\n", __func__); if(state->amount_done < sizeof(*state->header)) { ret = write(state->socket, ((char*)state->header) + state->amount_done, sizeof(*state->header) - state->amount_done); if(ret == 0 && _can_write) { free(state->header); if(state->buffer) free(state->buffer); tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d writing response header.\n", ret); return; } _can_write = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header)) return; debug_hexdump("tcp_usb: Sent Header: ", state->header, sizeof(*state->header)); } if((state->header->ep & USB_DIR_IN) != 0 && state->header->length > 0) // IN { ret = write(state->socket, ((char*)state->buffer) + (state->amount_done - sizeof(*state->header)), state->header->length - (state->amount_done - sizeof(*state->header))); if(ret == 0 && _can_write) { free(state->header); if(state->buffer) free(state->buffer); tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d writing response data.\n", ret); return; } _can_write = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header) + state->header->length) return; debug_hexdump("tcp_usb: Wrote: ", state->buffer, state->header->length); } free(state->header); if(state->buffer) free(state->buffer); state->state = tcp_usb_idle; break; case tcp_usb_write_request: debug_printf("%s: tcp_usb_write_request\n", __func__); if(state->amount_done < sizeof(*state->header)) { ret = write(state->socket, ((char*)state->header) + state->amount_done, sizeof(*state->header) - state->amount_done); if(ret == 0 && _can_write) { tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d writing request header!\n", ret); return; } _can_write = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header)) return; debug_hexdump("tcp_usb: Sent Header: ", state->header, sizeof(*state->header)); } if((state->header->ep & USB_DIR_IN) == 0 && state->header->length > 0) // OUT { ret = write(state->socket, ((char*)state->buffer) + (state->amount_done - sizeof(*state->header)), state->header->length - (state->amount_done - sizeof(*state->header))); if(ret == 0 && _can_write) { tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d writing request data!\n", ret); return; } _can_write = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header) + state->header->length) return; debug_hexdump("tcp_usb: Wrote: ", state->buffer, state->header->length); } state->state = tcp_usb_read_response; state->amount_done = 0; // Fall through case tcp_usb_read_response: // debug_printf("%s: tcp_usb_read_response\n", __func__); if(state->amount_done < sizeof(*state->header)) { ret = read(state->socket, ((char*)state->header) + state->amount_done, sizeof(*state->header) - state->amount_done); if(ret == 0 && _can_read) { tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d reading response header.\n", ret); return; } _can_read = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header)) return; debug_hexdump("tcp_usb: Got Header: ", state->header, sizeof(*state->header)); } if((state->header->ep & USB_DIR_IN) != 0 && state->header->length > 0) // IN { ret = read(state->socket, ((char*)state->buffer) + (state->amount_done - sizeof(*state->header)), state->header->length - (state->amount_done - sizeof(*state->header))); if(ret == 0 && _can_read) { tcp_usb_do_closed(state); return; } else if(ret == EWOULDBLOCK || ret == 0 || ret == -1) return; else if(ret < 0) { fprintf(stderr, "tcp_usb: Error %d reading response data.\n", ret); return; } _can_read = 0; state->amount_done += ret; if(state->amount_done < sizeof(*state->header) + state->header->length) return; debug_hexdump("tcp_usb: Read: ", state->buffer, state->header->length); } state->state = tcp_usb_idle; // Transfer complete! Call callback! if(state->data_callback) { debug_printf("tcp_usb: calling callback!\n"); state->data_callback(state, state->callback_arg, state->header, state->buffer); return; } else { fprintf(stderr, "tcp_usb: Request sent but no callback!\n"); state->state = tcp_usb_idle; return; } break; } }