void xtcp_increment_word(uint8_t* a)
{
unsigned s = ((*(short*)(&a[2])) << 16) + *(short*)(&a[0]);
s = byterev(byterev(s)+1);
*(short*)(&a[0]) = (short)s;
*(short*)(&a[2]) = (short)(s >> 16);
}
/*********functions which permit to communicate with the board****************/
UNS8
canReceive_driver (CAN_HANDLE fd0, Message * m)
{
int res;
int sock;
int i;
unsigned char buffer[64];
//can_frame es payload del paquete ethernet, viene luego del header ethernet
struct can_frame *frame = (struct can_frame *)(ETH_HLEN+(void *)buffer);
// convertimos de CAN_HANDLE a socket
// CAN_HANDLE = socket+1
sock = (int)fd0 -1;
#ifdef DEBUG_MSG_CONSOLE_ON
printf("\nRecibiendo... \n");
printf("Socket: %d\n", sock);
#endif
// esta función bloquea hasta recibir una trama
// flags: MSG_PEEK, MSG_DONTWAIT
res = CAN_RECV (sock, buffer, sizeof(buffer), 0);
if (res < 0)
{
fprintf (stderr, "Recv failed: %s\n", strerror (CAN_ERRNO (res)));
return 1;
}
// la trama ethernet usa almacenamiento little-endian, hay que invertir
byterev((unsigned char *)&((*frame).can_id) , 4);
m->cob_id = (*frame).can_id & CAN_EFF_MASK;
m->len = (*frame).can_dlc;
if ((*frame).can_id & CAN_RTR_FLAG)
m->rtr = 1;
else
m->rtr = 0;
memcpy (m->data, (*frame).data, m->len);
#if defined DEBUG_MSG_CONSOLE_ON
printf("Recibidos %d bytes!\n",res);
printf("Socket: %d\n", sock);
printf("COB-id:%4.4x\n" , m->cob_id);
printf("Len:%2.2x\n" , m->len);
printf("Data");
for(i = 0 ; i < m->len ; i++)
printf(":%2.2x", m->data[i]);
printf("\n");
// MSG("in : ");
// print_message(m);
#endif
return 0;
}
void mmcau_des_encrypt(unsigned int in[], unsigned int key[],
unsigned int out[])
{
/* load the 64-bit plaintext input block into CAU's CA2/CA3 registers*/
*(MMCAU_PPB_INDIRECT + (LDR+CA2)) = byterev(in[0]); /* ld plain[i] -> CA2*/
*(MMCAU_PPB_INDIRECT + (LDR+CA3)) = byterev(in[1]); /* ld plain[i+1]-> CA3*/
/* load the 64-bit key into the CAU's CA0/CA1 registers*/
*(MMCAU_PPB_INDIRECT + (LDR+CA0)) = byterev(key[0]); /* load key[i] -> CA0*/
*(MMCAU_PPB_INDIRECT + (LDR+CA1)) = byterev(key[1]); /* load key[i+1] -> CA1*/
/* send a series of 17 direct cau commands to perform the DES round operations*/
*(MMCAU_PPB_DIRECT + 0) = mmcau_3_cmds(DESK,DESR+IP+KSL1,DESR+KSL2);
*(MMCAU_PPB_DIRECT + 1) = mmcau_3_cmds(DESR+KSL2,DESR+KSL2,DESR+KSL2);
*(MMCAU_PPB_DIRECT + 2) = mmcau_3_cmds(DESR+KSL2,DESR+KSL2,DESR+KSL1);
*(MMCAU_PPB_DIRECT + 3) = mmcau_3_cmds(DESR+KSL2,DESR+KSL2,DESR+KSL2);
*(MMCAU_PPB_DIRECT + 4) = mmcau_3_cmds(DESR+KSL2,DESR+KSL2,DESR+KSL2);
*(MMCAU_PPB_DIRECT + 5) = mmcau_2_cmds(DESR+KSL1,DESR+FP);
/* store the 64-bit ciphertext output block into memory*/
out[0] = *(MMCAU_PPB_INDIRECT + (STR+CA2)); /* store 1st 4 bytes*/
out[0] = byterev(out[0]); /* byte reverse*/
out[1] = *(MMCAU_PPB_INDIRECT + (STR+CA3)); /* store 2nd 4 bytes*/
out[1] = byterev(out[1]); /* byte reverse*/
}
UNS8
canSend_driver (CAN_HANDLE fd0, Message const *m)
{
int i;
int res;
int sock;
unsigned char buffer[64];
//frame va a ser payload del paquete, hay que ubicarlo luego del header ethernet
struct can_frame *frame = (struct can_frame *)(ETH_HLEN+(void *)buffer);
// inicializamos buffer en 0
memset(buffer,0x00,64);
// copiamos header prototipo al principio de la trama
for(i = 0 ; i < ETH_HLEN ; i++)
buffer[i]=buffer_header[i];
// armamos trama en formato CANopenRTnet a partir de tipo message de CANfestival
// pasamos el COB-id
(*frame).can_id = m->cob_id;
// ponemos flag EFF
if ( m->cob_id >= 0x800)
(*frame).can_id |= CAN_EFF_FLAG;
// ponemos dlc
(*frame).can_dlc = m->len;
// ponemos flag RTR o datos
if (m->rtr)
// Si es solicitud de respuesta no lleva datos
(*frame).can_id |= CAN_RTR_FLAG;
else
// Si NO es solicitud de respuesta entonces SI lleva datos...
memcpy ((*frame).data, m->data, m->len);
// Tener en cuenta alineación de campo data[] de can_frame.
// rtcan.h define el campo con alineación a 8 bytes, esto agrega 3 bytes sin
// utilizar en la trama, eliminando el atributo de alineación se evita esto:
// uint8_t data[8] __attribute__ ((aligned(8)));
// uint8_t data[8];
// el orden de los bytes en la trama debe ser little-endian, esta arquitectura escribe en big-endian...
// hay que invertir orden del campo cob-id, el dlc no porque es 1 solo byte
byterev((unsigned char *)&((*frame).can_id),4);
// convertimos CAN_HANDLE a socket
sock = (int)fd0 -1;
#if defined DEBUG_MSG_CONSOLE_ON
//TODO
printf("COBID: %x\n", m->cob_id);
//printf("Frame CANID: %x\n", (*frame).can_id);
//TODO
//printf("M DATA: %x\n", m->data);
//printf("Frame DATA: %x\n", (*frame).data);
//MSG("out : ");
//print_message(m);
printf("Buffer");
for(i = 0 ; i < 64 ; i++)
printf(":%2.2x", buffer[i]);
printf("\n");
printf("Socket: %d\n", sock);
#endif
res = CAN_SEND(sock, buffer, sizeof(buffer), 0);
//res = CAN_SEND (sock, &frame, sizeof (frame), 0);
if (res < 0){
fprintf (stderr, "Send failed: %s\n", strerror (CAN_ERRNO (res)));
return 1;
}
#if defined DEBUG_MSG_CONSOLE_ON
printf("Trasmitió: %i bytes\n", res);
#endif
return 0;
}
static int xtcp_get_word(const u8_t *a) {
unsigned int aw = ((*(unsigned short*)(&a[2])) << 16) + *(unsigned short*)(&a[0]);
return byterev(aw);
}
void uip_add32(uint8_t *op32, uint16_t op16) {
unsigned int *res = (unsigned int *)uip_acc32;
unsigned int x = ((*(unsigned short*)(&op32[2])) << 16) + *(unsigned short*)(&op32[0]);
x = byterev(x);
*res = byterev(x + op16);
}
