static err_t low_level_output (struct genericif *genericif, struct pbuf *p)
{
struct pbuf *q;
int len = p->tot_len;
magic (p, PBUF_MAGIC);
if (mem_usage_percent ((size_t) 0) > MEM_USAGE_HIGH) { /* suppress packet output */
printf ("low_level_output: memory low - dropping packet\n"); /* FIXME: remove this debug line */
return ERR_OK;
}
if (enable_packet_dump)
packet_dump (p->payload, (int) p->len, "OUT ");
if (ioctl (genericif->fd, FIONWRITE, &len))
die ("driver could not allocate space for packet");
if (p->tot_len == len) {
for (q = p; q != NULL && len > 0; q = q->next) {
int r;
if ((r = write (genericif->fd, q->payload, q->len)) != q->len)
die ("driver could not send packet returned %d/%d, [%s] ", r, q->len, strerror (errno));
len -= q->len;
}
if (len != 0)
die ("len != 0, p = %p", (void *) p);
}
return ERR_OK;
}
static int u2dump(char *file) {
u2record record;
u2iterator *it = new_iterator(file);
memset(&record, 0, sizeof(record));
if(!it) {
printf("u2dump: Failed to create new iterator with file: %s\n", file);
return -1;
}
while( get_record(it, &record) == SUCCESS ) {
if(record.type == UNIFIED2_IDS_EVENT) event_dump(&record);
else if(record.type == UNIFIED2_IDS_EVENT_VLAN) event2_dump(&record);
else if(record.type == UNIFIED2_PACKET) packet_dump(&record);
else if(record.type == UNIFIED2_IDS_EVENT_IPV6) event6_dump(&record);
else if(record.type == UNIFIED2_IDS_EVENT_IPV6_VLAN) event2_6_dump(&record);
else if(record.type == UNIFIED2_EXTRA_DATA) extradata_dump(&record);
#if defined(FEAT_OPEN_APPID)
else if(record.type == UNIFIED2_IDS_EVENT_APPID) event3_dump(&record);
else if(record.type == UNIFIED2_IDS_EVENT_APPID_IPV6) event3_6_dump(&record);
else if(record.type == UNIFIED2_IDS_EVENT_APPSTAT) appid_dump(&record);
#endif /* defined(FEAT_OPEN_APPID) */
}
free_iterator(it);
if(record.data)
free(record.data);
return 0;
}
int u2dump(const u2record *record, FILE *out_file) {
if(record->type == UNIFIED2_IDS_EVENT) event_dump(record, out_file);
else if(record->type == UNIFIED2_IDS_EVENT_VLAN) event2_dump(record,out_file);
else if(record->type == UNIFIED2_PACKET) packet_dump(record,out_file);
else if(record->type == UNIFIED2_IDS_EVENT_IPV6) event6_dump(record,out_file);
else if(record->type == UNIFIED2_IDS_EVENT_IPV6_VLAN) event2_6_dump(record,out_file);
else if(record->type == UNIFIED2_EXTRA_DATA) extradata_dump(record,out_file);
return 0;
}
/* transmit packet. */
rt_err_t rt_cme_eth_tx( rt_device_t dev, struct pbuf* p)
{
rt_err_t result = RT_EOK;
ETH_TX_DESC *desc;
struct rt_cme_eth * cme_eth = (struct rt_cme_eth *)dev;
rt_mutex_take(&cme_eth->lock, RT_WAITING_FOREVER);
#ifdef ETH_TX_DUMP
packet_dump("TX dump", p);
#endif /* ETH_TX_DUMP */
/* get free tx buffer */
{
rt_err_t result;
result = rt_sem_take(&cme_eth->tx_buf_free, RT_TICK_PER_SECOND/10);
if (result != RT_EOK)
{
result = -RT_ERROR;
goto _exit;
}
}
desc = ETH_AcquireFreeTxDesc();
if(desc == RT_NULL)
{
CME_ETH_PRINTF("TxDesc not ready!\n");
RT_ASSERT(0);
result = -RT_ERROR;
goto _exit;
}
desc->TX_0.TX0_b.FS = TRUE;
desc->TX_0.TX0_b.LS = TRUE;
desc->TX_1.TX1_b.SIZE = p->tot_len;
pbuf_copy_partial(p, ( void *)(desc->bufAddr), p->tot_len, 0);
ETH_ReleaseTxDesc(desc);
ETH_ResumeTx();
_exit:
rt_mutex_release(&cme_eth->lock);
return result;
}
PACKET* packet_read(int socket) {
PACKET *p = malloc(sizeof(PACKET));
p->command = read_i(socket);
p->args_count = read_i(socket);
PACKET_ARG **args = malloc(p->args_count * sizeof(PACKET_ARG*));
for (uint32_t i = 0; i < p->args_count; i ++) {
PACKET_ARG *arg = malloc(sizeof(PACKET_ARG));
arg->length = read_i(socket);
arg->arg = read_b(socket, arg->length);
args[i] = arg;
}
p->args = args;
packet_dump(p);
return p;
}
extern int radmain (void) {
unsigned char *ebuff, uuid[16];
struct eap_info eap;
int cnt;
char *user = "******";
struct radius_packet *lrp;
add_radserver("192.168.245.124", "1812", NULL, "RadSecret", 10);
add_radserver("127.0.0.1", "1812", NULL, "RadSecret", 10);
lrp = new_radpacket(RAD_CODE_AUTHREQUEST, 1);
addradattrstr(lrp, RAD_ATTR_USER_NAME, user);
addradattrip(lrp, RAD_ATTR_NAS_IP_ADDR, "127.0.0.1");
addradattrint(lrp, RAD_ATTR_NAS_PORT, 0);
addradattrint(lrp, RAD_ATTR_SERVICE_TYPE, 1);
addradattrint(lrp, RAD_ATTR_PORT_TYPE, 15);
eap.type = 1;
eap.code = 2;
eap.id = 1;
cnt = 5 + strlen(user);
eap.len = htons(cnt);
ebuff = addradattr(lrp, RAD_ATTR_EAP, (unsigned char*)&eap, cnt);
memcpy(ebuff + 7, user, strlen(user));
uuid_generate(uuid);
addradattr(lrp, RAD_ATTR_ACCTID, uuid, 16);
if (send_radpacket(lrp, "testpass", radius_read, NULL)) {
printf("Sending Failed\n");
return (-1);
}
printf("\nSENT PACKET\n");
packet_dump(lrp);
return (0);
}
/* reception packet. */
struct pbuf *rt_cme_eth_rx(rt_device_t dev)
{
struct pbuf* p = RT_NULL;
ETH_RX_DESC *desc;
uint32_t framelength;
struct rt_cme_eth * cme_eth = (struct rt_cme_eth *)dev;
rt_mutex_take(&cme_eth->lock, RT_WAITING_FOREVER);
desc = ETH_AcquireFreeRxDesc();
if(desc == RT_NULL)
{
ETH_ITConfig(ETH_INT_RX_COMPLETE_FRAME, TRUE);
ETH_ITConfig(ETH_INT_RX_BUF_UNAVAI, TRUE);
ETH_ResumeRx();
goto _exit;
}
framelength = desc->RX_0.RX0_b.FL;
/* allocate buffer */
p = pbuf_alloc(PBUF_LINK, framelength, PBUF_RAM);
if (p != RT_NULL)
{
pbuf_take(p, (const void *)(desc->bufAddr), framelength);
#ifdef ETH_RX_DUMP
packet_dump("RX dump", p);
#endif /* ETH_RX_DUMP */
}
ETH_ReleaseRxDesc(desc);
_exit:
rt_mutex_release(&cme_eth->lock);
return p;
}
static struct pbuf *low_level_input (struct genericif *genericif)
{
struct pbuf *p = 0;
int len, r;
ioctl (genericif->fd, FIONREAD, &len);
if (mem_usage_percent ((size_t) 0) < MEM_USAGE_MEDIUM) { /* suppress packet input */
p = pbuf_alloc (PBUF_RAW, len + 2, PBUF_RAM);
pbuf_header (p, (s16_t) - 2);
}
if (!p) {
/* discard the packet */
char buf[64];
r = read (genericif->fd, buf + 2, min (len, sizeof (buf) - 2));
assert (r == len || r == sizeof (buf) - 2);
return NULL;
} else {
len = min (p->len, len);
r = read (genericif->fd, p->payload, len);
assert (r == len);
}
if (enable_packet_dump)
packet_dump (p->payload, (int) p->len, "IN ");
return p;
}
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
static int aaa = 0;
static long data_cnt = 0;
static long data_cnt_bak = 0;
static long jpeg_cnt = 0;
static long jpeg_size = 0;
static long jpeg_size_bak = 0;
static long jpeg_ptr = 0;
static long jpeg_start = 0;
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
BYTE i;
#endif
int j;
// Handle specific events.
switch ( (INT)event )
{
case EVENT_TRANSFER: // A USB transfer has completed
case EVENT_DATA_ISOC_READ:
for(j = 0;j < size-1;j++){
if(((BYTE*)data)[j] == 0xFF){
if(((BYTE*)data)[j+1] == 0xD8){
if(((BYTE*)data)[j+2] == 0xFF){
if(((BYTE*)data)[j+3] == 0xE0){
jpeg_size = data_cnt -jpeg_size_bak;
jpeg_size_bak = data_cnt;
/*UART2PrintString( "JPEG-SIZE=" );
UART2PutDec((jpeg_size/100000) % 10);
UART2PutDec((jpeg_size/10000) % 10);
UART2PutDec((jpeg_size/1000) % 10);
UART2PutDec((jpeg_size/100) % 10);
UART2PutDec((jpeg_size/10) % 10);
UART2PutDec(jpeg_size % 10);
UART2PrintString( "JPEG-CNT=" );
UART2PutDec((jpeg_cnt/1000) % 10);
UART2PutDec((jpeg_cnt/100) % 10);
UART2PutDec((jpeg_cnt/10) % 10);
UART2PutDec(jpeg_cnt % 10);
UART2PrintString( "\r\n" );*/
if(jpeg_cnt == 1){
UART2PrintString( "JPEG-SIZE=" );
UART2PutDec((jpeg_ptr/100000) % 10);
UART2PutDec((jpeg_ptr/10000) % 10);
UART2PutDec((jpeg_ptr/1000) % 10);
UART2PutDec((jpeg_ptr/100) % 10);
UART2PutDec((jpeg_ptr/10) % 10);
UART2PutDec(jpeg_ptr % 10);
UART2PrintString( "\r\n" );
packet_dump(jpeg,jpeg_ptr);
}
jpeg_cnt++;
jpeg_start = j;
//packet_dump((data + j),4);
}
}
}
}
}
if((size != 0x0C) && jpeg_cnt == 1){
int i;
for(i = 0x0C;i < size;i++){
if(jpeg_ptr == 0){
UART2PrintString( "jpeg_start=" );
i = jpeg_start;
UART2PutDec(jpeg_cnt % 10);
UART2PrintString( "\r\n" );
}
jpeg[jpeg_ptr++] = ((BYTE*)data)[i];
}
}
if(size != 0x0C){
/*if(aaa >= 0 && aaa <= 0){
UART2PrintString( "DATA=" );
packet_dump(data,size);
UART2PrintString( "\r\n ");
aaa++;
}*/
}
data_cnt += size;
/*if(data_cnt > data_cnt_bak + 1024 * 10){
//data_cnt = 1024 * 100;
UART2PrintString( "a" );
UART2PutDec((data_cnt/1000000) % 10);
UART2PutDec((data_cnt/100000) % 10);
UART2PutDec((data_cnt/10000) % 10);
UART2PutDec((data_cnt/1000) % 10);
UART2PutDec((data_cnt/100) % 10);
UART2PutDec((data_cnt/10) % 10);
UART2PutDec(data_cnt % 10);
UART2PrintString( "\r\n" );
data_cnt_bak = data_cnt;
}*/
return TRUE;
break;
UART2PrintString( "a" );
case EVENT_GENERIC_ATTACH:
return TRUE;
break;
case EVENT_GENERIC_DETACH:
deviceAddress = 0;
DemoState = DEMO_INITIALIZE;
UART2PrintString( "Generic demo device detached - event\r\n" );
return TRUE;
case EVENT_GENERIC_TX_DONE: // The main state machine will poll the driver.
case EVENT_GENERIC_RX_DONE:
return TRUE;
case EVENT_VBUS_REQUEST_POWER:
// We'll let anything attach.
return TRUE;
case EVENT_VBUS_RELEASE_POWER:
// We aren't keeping track of power.
return TRUE;
case EVENT_HUB_ATTACH:
UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
return TRUE;
break;
case EVENT_UNSUPPORTED_DEVICE:
UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
return TRUE;
break;
case EVENT_CANNOT_ENUMERATE:
UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
return TRUE;
break;
case EVENT_CLIENT_INIT_ERROR:
UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
return TRUE;
break;
case EVENT_OUT_OF_MEMORY:
UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
return TRUE;
break;
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
return TRUE;
break;
case EVENT_SUSPEND:
case EVENT_DETACH:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
UART2PrintString( "a" );
return TRUE;
break;
default:
break;
}
return FALSE;
}
void ManageDemoState ( void )
{
int j;
DWORD byteCount;
BYTE errorCode;
BYTE RetVal;
//接続されていなかったら初期化
if (USBHostGenericDeviceDetached(deviceAddress) && deviceAddress != 0)
{
long i;
for(i = 0;i < sizeof(jpeg);i++){
jpeg[i] = 0;
}
UART2PrintString( "Generic demo device detached - polled\r\n" );
DemoState = DEMO_INITIALIZE;
deviceAddress = 0;
}
switch (DemoState)
{
case DEMO_INITIALIZE:
DemoState = DEMO_STATE_IDLE;
break;
case DEMO_STATE_IDLE:
//接続されたら、読み出し処理に移行
if (CheckForNewAttach())
{
DemoState = DEMO_STATE_GET_INFO;
UART2PrintString( "USB_Ver=" );
UART2PutDec(((USB_DEVICE_DESCRIPTOR *)pDeviceDescriptor)->bcdUSB >> 8);
UART2PrintString( "-" );
UART2PutDec(((USB_DEVICE_DESCRIPTOR *)pDeviceDescriptor)->bcdUSB);
UART2PrintString( "\r\n" );
}
break;
case DEMO_STATE_GET_INFO:
if(control(GET_INFO, VS_PROBE_CONTROL, 1, param, 1) == USB_SUCCESS){
UART2PrintString( "GET_INFO, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_INFO;
}
break;
case DEMO_STATE_WAIT_GET_INFO:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_INFO, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(param,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_DEF;
}
break;
case DEMO_STATE_GET_DEF:
if(control(GET_DEF, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_DEF, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_DEF;
}
break;
case DEMO_STATE_WAIT_GET_DEF:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_DEF, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_MIN;
}
break;
case DEMO_STATE_GET_MIN:
if(control(GET_MIN, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_MIN, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_MIN;
}
break;
case DEMO_STATE_WAIT_GET_MIN:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_MIN, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_MAX;
}
break;
case DEMO_STATE_GET_MAX:
if(control(GET_MAX, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_MAX, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_MAX;
}
break;
case DEMO_STATE_WAIT_GET_MAX:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_MAX, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_CUR;
}
break;
case DEMO_STATE_GET_CUR:
if(control(GET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_CUR, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_CUR;
}
break;
case DEMO_STATE_WAIT_GET_CUR:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_CUR, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_SET_CUR ;
}
break;
case DEMO_STATE_SET_CUR:
for(j = 0;j < param_len;j++){
temp[j] = 0;
}
temp[2] = 2;//フォーマットインデックス
temp[3] = 1;//フレームインデックス
/*temp[4] = 0x80;
temp[5] = 0x84;
temp[6] = 0x1E;
temp[7] = 0x00;*/
temp[4] = 0x15;//30Hz
temp[5] = 0x16;
temp[6] = 0x05;
temp[7] = 0x00;
if(control(SET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "SET_CUR, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_SET_CUR;
}
break;
case DEMO_STATE_WAIT_SET_CUR:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=SET_CUR, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_GET_CUR2 ;
}
break;
case DEMO_STATE_GET_CUR2:
if(control(GET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_CUR2, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_CUR2;
}
break;
case DEMO_STATE_WAIT_GET_CUR2:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_CUR2, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_GET_INFO2 ;
}
break;
case DEMO_STATE_GET_INFO2:
if(control(GET_INFO, VS_COMMIT_CONTROL, 1, param, 1) == USB_SUCCESS){
UART2PrintString( "GET_INFO, VS_COMMIT_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_INFO2;
}
break;
case DEMO_STATE_WAIT_GET_INFO2:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_INFO, VS_COMMIT_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(param,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_CUR3;
}
break;
case DEMO_STATE_GET_CUR3:
if(control(GET_CUR, VS_COMMIT_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_CUR2, VS_COMMIT_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_CUR3;
}
break;
case DEMO_STATE_WAIT_GET_CUR3:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_CUR2, VS_COMMIT_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_SET_CUR2 ;
}
break;
case DEMO_STATE_SET_CUR2:
for(j = 0;j < param_len;j++){
temp[j] = 0;
}
temp[2] = 2;
temp[3] = 0x01;//640x480 30Hz
//temp[3] = 0x02;//160x120 30Hz
//temp[3] = 0x0C;//800x600
temp[4] = 0x80;//5Hz
temp[5] = 0x84;
temp[6] = 0x1E;
temp[7] = 0x00;
/*temp[4] = 0x15;//30Hz
temp[5] = 0x16;
temp[6] = 0x05;
temp[7] = 0x00;*/
if(control(SET_CUR, VS_COMMIT_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "SET_CUR, VS_COMMIT_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_SET_CUR2;
}
break;
case DEMO_STATE_WAIT_SET_CUR2:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=SET_CUR, VS_COMMIT_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_SET_ISOCHRONOUS ;
}
break;
case DEMO_STATE_SET_ISOCHRONOUS:
if(USBHostIssueDeviceRequest( deviceAddress, 0x01, USB_REQUEST_SET_INTERFACE,
0x06/*Alternate Setting:0x1*/, 0x01/*interface:0x03*/, 0, NULL, USB_DEVICE_REQUEST_SET,
0x00 )== USB_SUCCESS){
UART2PrintString( "USB_REQUEST_SET_INTERFACE=OK!\r\n" );
DemoState =DEMO_STATE_WAIT_SET_ISOCHRONOUS ;
}
break;
case DEMO_STATE_WAIT_SET_ISOCHRONOUS:
if(USBHostReadIsochronous(deviceAddress,0x81,&isocData) == USB_SUCCESS){
//UART2PrintString( "USBHostReadIsochronous=OK!\r\n" );
DemoState = DEMO_STATE_ERROR;
}
break;
case DEMO_STATE_ERROR:
break;
default:
DemoState = DEMO_INITIALIZE;
break;
}
//DelayMs(1); // 1ms delay
} // ManageDemoState
static void radius_read(struct radius_packet *packet, void *pvt_data) {
printf("\nREAD PACKET\n");
packet_dump(packet);
}
/* Assumes SPU-M messages are in big endian */
void spum_dump_msg_hdr(u8 *buf, unsigned int buf_len)
{
u8 *ptr = buf;
struct SPUHEADER *spuh = (struct SPUHEADER *)buf;
unsigned int hash_key_len = 0;
unsigned int hash_state_len = 0;
unsigned int cipher_key_len = 0;
unsigned int iv_len;
u32 pflags;
u32 cflags;
u32 ecf;
u32 cipher_alg;
u32 cipher_mode;
u32 cipher_type;
u32 hash_alg;
u32 hash_mode;
u32 hash_type;
u32 sctx_size; /* SCTX length in words */
u32 sctx_pl_len; /* SCTX payload length in bytes */
packet_log("\n");
packet_log("SPU Message header %p len: %u\n", buf, buf_len);
/* ========== Decode MH ========== */
packet_log(" MH 0x%08x\n", be32_to_cpu(*((u32 *)ptr)));
if (spuh->mh.flags & MH_SCTX_PRES)
packet_log(" SCTX present\n");
if (spuh->mh.flags & MH_BDESC_PRES)
packet_log(" BDESC present\n");
if (spuh->mh.flags & MH_MFM_PRES)
packet_log(" MFM present\n");
if (spuh->mh.flags & MH_BD_PRES)
packet_log(" BD present\n");
if (spuh->mh.flags & MH_HASH_PRES)
packet_log(" HASH present\n");
if (spuh->mh.flags & MH_SUPDT_PRES)
packet_log(" SUPDT present\n");
packet_log(" Opcode 0x%02x\n", spuh->mh.op_code);
ptr += sizeof(spuh->mh) + sizeof(spuh->emh); /* skip emh. unused */
/* ========== Decode SCTX ========== */
if (spuh->mh.flags & MH_SCTX_PRES) {
pflags = be32_to_cpu(spuh->sa.proto_flags);
packet_log(" SCTX[0] 0x%08x\n", pflags);
sctx_size = pflags & SCTX_SIZE;
packet_log(" Size %u words\n", sctx_size);
cflags = be32_to_cpu(spuh->sa.cipher_flags);
packet_log(" SCTX[1] 0x%08x\n", cflags);
packet_log(" Inbound:%lu (1:decrypt/vrfy 0:encrypt/auth)\n",
(cflags & CIPHER_INBOUND) >> CIPHER_INBOUND_SHIFT);
packet_log(" Order:%lu (1:AuthFirst 0:EncFirst)\n",
(cflags & CIPHER_ORDER) >> CIPHER_ORDER_SHIFT);
packet_log(" ICV_IS_512:%lx\n",
(cflags & ICV_IS_512) >> ICV_IS_512_SHIFT);
cipher_alg = (cflags & CIPHER_ALG) >> CIPHER_ALG_SHIFT;
cipher_mode = (cflags & CIPHER_MODE) >> CIPHER_MODE_SHIFT;
cipher_type = (cflags & CIPHER_TYPE) >> CIPHER_TYPE_SHIFT;
packet_log(" Crypto Alg:%u Mode:%u Type:%u\n",
cipher_alg, cipher_mode, cipher_type);
hash_alg = (cflags & HASH_ALG) >> HASH_ALG_SHIFT;
hash_mode = (cflags & HASH_MODE) >> HASH_MODE_SHIFT;
hash_type = (cflags & HASH_TYPE) >> HASH_TYPE_SHIFT;
packet_log(" Hash Alg:%x Mode:%x Type:%x\n",
hash_alg, hash_mode, hash_type);
packet_log(" UPDT_Offset:%u\n", cflags & UPDT_OFST);
ecf = be32_to_cpu(spuh->sa.ecf);
packet_log(" SCTX[2] 0x%08x\n", ecf);
packet_log(" WriteICV:%lu CheckICV:%lu ICV_SIZE:%u ",
(ecf & INSERT_ICV) >> INSERT_ICV_SHIFT,
(ecf & CHECK_ICV) >> CHECK_ICV_SHIFT,
(ecf & ICV_SIZE) >> ICV_SIZE_SHIFT);
packet_log("BD_SUPPRESS:%lu\n",
(ecf & BD_SUPPRESS) >> BD_SUPPRESS_SHIFT);
packet_log(" SCTX_IV:%lu ExplicitIV:%lu GenIV:%lu ",
(ecf & SCTX_IV) >> SCTX_IV_SHIFT,
(ecf & EXPLICIT_IV) >> EXPLICIT_IV_SHIFT,
(ecf & GEN_IV) >> GEN_IV_SHIFT);
packet_log("IV_OV_OFST:%lu EXP_IV_SIZE:%u\n",
(ecf & IV_OFFSET) >> IV_OFFSET_SHIFT,
ecf & EXP_IV_SIZE);
ptr += sizeof(struct SCTX);
if (hash_alg && hash_mode) {
char *name = "NONE";
switch (hash_alg) {
case HASH_ALG_MD5:
hash_key_len = 16;
name = "MD5";
break;
case HASH_ALG_SHA1:
hash_key_len = 20;
name = "SHA1";
break;
case HASH_ALG_SHA224:
hash_key_len = 28;
name = "SHA224";
break;
case HASH_ALG_SHA256:
hash_key_len = 32;
name = "SHA256";
break;
case HASH_ALG_SHA384:
hash_key_len = 48;
name = "SHA384";
break;
case HASH_ALG_SHA512:
hash_key_len = 64;
name = "SHA512";
break;
case HASH_ALG_AES:
hash_key_len = 0;
name = "AES";
break;
case HASH_ALG_NONE:
break;
}
packet_log(" Auth Key Type:%s Length:%u Bytes\n",
name, hash_key_len);
packet_dump(" KEY: ", ptr, hash_key_len);
ptr += hash_key_len;
} else if ((hash_alg == HASH_ALG_AES) &&
(hash_mode == HASH_MODE_XCBC)) {
char *name = "NONE";
switch (cipher_type) {
case CIPHER_TYPE_AES128:
hash_key_len = 16;
name = "AES128-XCBC";
break;
case CIPHER_TYPE_AES192:
hash_key_len = 24;
name = "AES192-XCBC";
break;
case CIPHER_TYPE_AES256:
hash_key_len = 32;
name = "AES256-XCBC";
break;
}
packet_log(" Auth Key Type:%s Length:%u Bytes\n",
name, hash_key_len);
packet_dump(" KEY: ", ptr, hash_key_len);
ptr += hash_key_len;
}
if (hash_alg && (hash_mode == HASH_MODE_NONE) &&
(hash_type == HASH_TYPE_UPDT)) {
char *name = "NONE";
switch (hash_alg) {
case HASH_ALG_MD5:
hash_state_len = 16;
name = "MD5";
break;
case HASH_ALG_SHA1:
hash_state_len = 20;
name = "SHA1";
break;
case HASH_ALG_SHA224:
hash_state_len = 32;
name = "SHA224";
break;
case HASH_ALG_SHA256:
hash_state_len = 32;
name = "SHA256";
break;
case HASH_ALG_SHA384:
hash_state_len = 48;
name = "SHA384";
break;
case HASH_ALG_SHA512:
hash_state_len = 64;
name = "SHA512";
break;
case HASH_ALG_AES:
hash_state_len = 0;
name = "AES";
break;
case HASH_ALG_NONE:
break;
}
packet_log(" Auth State Type:%s Length:%u Bytes\n",
name, hash_state_len);
packet_dump(" State: ", ptr, hash_state_len);
ptr += hash_state_len;
}
if (cipher_alg) {
char *name = "NONE";
switch (cipher_alg) {
case CIPHER_ALG_DES:
cipher_key_len = 8;
name = "DES";
break;
case CIPHER_ALG_3DES:
cipher_key_len = 24;
name = "3DES";
break;
case CIPHER_ALG_RC4:
cipher_key_len = 260;
name = "ARC4";
break;
case CIPHER_ALG_AES:
switch (cipher_type) {
case CIPHER_TYPE_AES128:
cipher_key_len = 16;
name = "AES128";
break;
case CIPHER_TYPE_AES192:
cipher_key_len = 24;
name = "AES192";
break;
case CIPHER_TYPE_AES256:
cipher_key_len = 32;
name = "AES256";
break;
}
break;
case CIPHER_ALG_NONE:
break;
}
packet_log(" Cipher Key Type:%s Length:%u Bytes\n",
name, cipher_key_len);
/* XTS has two keys */
if (cipher_mode == CIPHER_MODE_XTS) {
packet_dump(" KEY2: ", ptr, cipher_key_len);
ptr += cipher_key_len;
packet_dump(" KEY1: ", ptr, cipher_key_len);
ptr += cipher_key_len;
cipher_key_len *= 2;
} else {
packet_dump(" KEY: ", ptr, cipher_key_len);
ptr += cipher_key_len;
}
if (ecf & SCTX_IV) {
sctx_pl_len = sctx_size * sizeof(u32) -
sizeof(struct SCTX);
iv_len = sctx_pl_len -
(hash_key_len + hash_state_len +
cipher_key_len);
packet_log(" IV Length:%u Bytes\n", iv_len);
packet_dump(" IV: ", ptr, iv_len);
ptr += iv_len;
}
}
}
