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;
}
}
