marc
/
RIOT
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

more coding convention fixes

Browse Source
dev/timer
Oliver Hahm 10 years ago
parent 5d70656343
commit 201f593641
13 changed files with 825 additions and 629 deletions
Show Stats Download Patch File Download Diff File

32
dist/tools/linux-border_router/control_2xxx.c vendored
Unescape Escape View File

@ -8,24 +8,24 @@
void hard_reset_to_bootloader(void)
{
printf("Reset CPU (into bootloader)\r\n");
set_rts(1); // RTS (ttl level) connects to P0.14
set_dtr(1); // DTR (ttl level) connects to RST
send_break_signal(); // or break detect circuit to RST
usleep(75000);
set_dtr(0); // allow the CPU to run
set_baud(baud_rate);
set_rts(1); // set RTS again (as it has been reset by set_baudrate)
usleep(40000);
printf("Reset CPU (into bootloader)\r\n");
set_rts(1); /* RTS (ttl level) connects to P0.14 */
set_dtr(1); /* DTR (ttl level) connects to RST */
send_break_signal(); /* or break detect circuit to RST */
usleep(75000);
set_dtr(0); /* allow the CPU to run */
set_baud(baud_rate);
set_rts(1); /* set RTS again (as it has been reset by set_baudrate) */
usleep(40000);
}
void hard_reset_to_user_code(void)
{
printf("Reset CPU (into user code)\r\n");
set_rts(0); // RTS (ttl level) connects to P0.14
set_dtr(1); // DTR (ttl level) connects to RST
send_break_signal(); // or break detect circuit to RST
usleep(75000);
set_dtr(0); // allow the CPU to run
usleep(40000);
printf("Reset CPU (into user code)\r\n");
set_rts(0); /* RTS (ttl level) connects to P0.14 */
set_dtr(1); /* DTR (ttl level) connects to RST */
send_break_signal(); /* or break detect circuit to RST */
usleep(75000);
set_dtr(0); /* allow the CPU to run */
usleep(40000);
}

99
dist/tools/linux-border_router/flowcontrol.c vendored
Unescape Escape View File

@ -14,21 +14,25 @@
flowcontrol_stat_t slwin_stat;
uint8_t connection_established;
void* resend_thread_f (void *args) {
void *resend_thread_f(void *args)
{
uint8_t seq_num = *((uint8_t *)args);
struct send_slot *slot = &(slwin_stat.send_win[seq_num % BORDER_SWS]);
while(1) {
usleep(BORDER_SL_TIMEOUT);
if (seq_num == ((border_packet_t *)(slot->frame))->seq_num) {
writepacket(slot->frame,slot->frame_len);
} else {
if(seq_num == ((border_packet_t *)(slot->frame))->seq_num) {
writepacket(slot->frame, slot->frame_len);
}
else {
return NULL;
}
}
}
void init_threeway_handshake(const struct in6_addr *addr) {
void init_threeway_handshake(const struct in6_addr *addr)
{
border_syn_packet_t *syn = (border_syn_packet_t *)get_serial_out_buffer(0);
syn->empty = 0;
syn->type = BORDER_PACKET_CONF_TYPE;
@ -36,62 +40,72 @@ void init_threeway_handshake(const struct in6_addr *addr) {
syn->conftype = BORDER_CONF_SYN;
syn->next_exp = slwin_stat.next_exp;
memcpy(&(syn->addr), addr, 16);
do {
writepacket((uint8_t *)syn, sizeof (border_syn_packet_t));
writepacket((uint8_t *)syn, sizeof(border_syn_packet_t));
usleep(BORDER_SL_TIMEOUT);
} while (!connection_established);
}
while(!connection_established);
}
void signal_connection_established(void) {
void signal_connection_established(void)
{
connection_established = 1;
}
void flowcontrol_init(const struct in6_addr *addr) {
void flowcontrol_init(const struct in6_addr *addr)
{
int i;
slwin_stat.last_frame = 0xFF;
slwin_stat.last_ack = slwin_stat.last_frame;
connection_established = 0;
sem_init(&slwin_stat.send_win_not_full,0,BORDER_SWS);
for(i = 0; i < BORDER_SWS; i++) {
sem_init(&slwin_stat.send_win_not_full, 0, BORDER_SWS);
for(i = 0; i < BORDER_SWS; i++) {
slwin_stat.send_win[i].frame_len = 0;
}
memset(&slwin_stat.send_win,0, sizeof(struct send_slot) * BORDER_SWS);
memset(&slwin_stat.send_win, 0, sizeof(struct send_slot) * BORDER_SWS);
slwin_stat.next_exp = 0;
for(i = 0; i < BORDER_RWS; i++) {
slwin_stat.recv_win[i].received = 0;
slwin_stat.recv_win[i].frame_len = 0;
}
memset(&slwin_stat.recv_win,0, sizeof(struct recv_slot) * BORDER_RWS);
memset(&slwin_stat.recv_win, 0, sizeof(struct recv_slot) * BORDER_RWS);
init_threeway_handshake(addr);
}
void flowcontrol_destroy(void) {
void flowcontrol_destroy(void)
{
sem_destroy(&slwin_stat.send_win_not_full);
}
static int in_window(uint8_t seq_num, uint8_t min, uint8_t max) {
static int in_window(uint8_t seq_num, uint8_t min, uint8_t max)
{
uint8_t pos = seq_num - min;
uint8_t maxpos = max - min + 1;
return pos < maxpos;
}
void send_ack(uint8_t seq_num) {
void send_ack(uint8_t seq_num)
{
border_packet_t *packet = (border_packet_t *)get_serial_out_buffer(0);
packet->empty = 0;
packet->type = BORDER_PACKET_ACK_TYPE;
packet->seq_num = seq_num;
writepacket((uint8_t *)packet, sizeof (border_packet_t));
writepacket((uint8_t *)packet, sizeof(border_packet_t));
}
void flowcontrol_send_over_tty(border_packet_t *packet, int len) {
void flowcontrol_send_over_tty(border_packet_t *packet, int len)
{
struct send_slot *slot;
uint8_t args[] = {packet->seq_num};
sem_wait(&(slwin_stat.send_win_not_full));
packet->seq_num = ++slwin_stat.last_frame;
slot = &(slwin_stat.send_win[packet->seq_num % BORDER_SWS]);
@ -104,9 +118,10 @@ void flowcontrol_send_over_tty(border_packet_t *packet, int len) {
writepacket((uint8_t *)packet, len);
}
void flowcontrol_deliver_from_tty(const border_packet_t *packet, int len) {
if (packet->type == BORDER_PACKET_ACK_TYPE) {
if (in_window(packet->seq_num, slwin_stat.last_ack+1, slwin_stat.last_frame)) {
void flowcontrol_deliver_from_tty(const border_packet_t *packet, int len)
{
if(packet->type == BORDER_PACKET_ACK_TYPE) {
if(in_window(packet->seq_num, slwin_stat.last_ack + 1, slwin_stat.last_frame)) {
do {
struct send_slot *slot;
slot = &(slwin_stat.send_win[++slwin_stat.last_ack % BORDER_SWS]);
@ -114,32 +129,36 @@ void flowcontrol_deliver_from_tty(const border_packet_t *packet, int len) {
testing_stop(slwin_stat.last_ack);
#endif
pthread_cancel(slot->resend_thread);
memset(&slot->frame,0,BUFFER_SIZE);
memset(&slot->frame, 0, BUFFER_SIZE);
slot->frame_len = 0;
sem_post(&slwin_stat.send_win_not_full);
} while (slwin_stat.last_ack != packet->seq_num);
}
while(slwin_stat.last_ack != packet->seq_num);
}
} else {
}
else {
struct recv_slot *slot;
slot = &slwin_stat.recv_win[packet->seq_num % BORDER_RWS];
if ( !in_window(packet->seq_num,
slwin_stat.next_exp,
slwin_stat.next_exp + BORDER_RWS - 1)) {
if(!in_window(packet->seq_num,
slwin_stat.next_exp,
slwin_stat.next_exp + BORDER_RWS - 1)) {
return;
}
memcpy(slot->frame, (uint8_t *)packet, len);
slot->received = 1;
if (packet->seq_num == slwin_stat.next_exp) {
while (slot->received) {
if(packet->seq_num == slwin_stat.next_exp) {
while(slot->received) {
demultiplex((border_packet_t *)slot->frame, slot->frame_len);
memset(&slot->frame,0,BUFFER_SIZE);
memset(&slot->frame, 0, BUFFER_SIZE);
slot->received = 0;
slot = &slwin_stat.recv_win[++slwin_stat.next_exp % BORDER_RWS];
}
}
send_ack(slwin_stat.next_exp - 1);
}
}

20
dist/tools/linux-border_router/flowcontrol.h vendored
Unescape Escape View File

@ -2,7 +2,7 @@
* @file flowcontrol.h
* @author Freie Universität Berlin, Computer Systems & Telemetics
* @author Martin Lenders <mlenders@inf.fu-berlin.de>
* @brief Public declarations for the flow control jobs via the
* @brief Public declarations for the flow control jobs via the
* serial interface for the 6LoWPAN Border Router driver.
*/
@ -30,7 +30,7 @@
/**
* @brief State of the sliding window algorithm, used for flow control
* @see "Computernetze -- Eine systemorientierte Einführung",
* @see "Computernetze -- Eine systemorientierte Einführung",
* L.L. Peterson, B.S. Davie, dpunkt-lehrbuch, 2008
*/
typedef struct flowcontrol_stat_t {
@ -49,7 +49,7 @@ typedef struct flowcontrol_stat_t {
uint8_t frame[BUFFER_SIZE]; ///< This slot's frame.
size_t frame_len; ///< The length of this slot's frame.
} send_win[BORDER_SWS]; ///< The sending window.
/* Receiver state */
uint8_t next_exp; ///< The next expected sequence number to be received.
/**
@ -67,15 +67,15 @@ typedef struct flowcontrol_stat_t {
* the serial line.
* @extends border_conf_header_t
*/
typedef struct __attribute__ ((packed)) border_syn_packet_t {
typedef struct __attribute__((packed)) border_syn_packet_t {
uint8_t empty;
uint8_t type;
/**
* @brief Next sequence number
*
* Communicates the next local sequence number to be send to the
*
* Communicates the next local sequence number to be send to the
* MSB-A2 (for flow control).
*
*
* This replaces @ref border_conf_header_t::seq_num of normal
* configuration packets.
*/
@ -83,8 +83,8 @@ typedef struct __attribute__ ((packed)) border_syn_packet_t {
uint8_t conftype;
/**
* @brief Next expected sequence number
*
* Communicates to the MSB-A2 which sequence number the driver
*
* Communicates to the MSB-A2 which sequence number the driver
* expects next.
*/
uint8_t next_exp;
@ -112,7 +112,7 @@ void signal_connection_established(void);
/**
* @brief Sends a packet via the serial interface.
* @param[in,out] packet The packet that is to be send via the
* serial interface. The function sets the
* serial interface. The function sets the
* sequence number of the packet for flow
* control.
* @param[in] len Length of the packet.

28
dist/tools/linux-border_router/main.c vendored
Unescape Escape View File

@ -8,34 +8,40 @@
#include "testing.h"
#endif
int main(int argc, char **argv) {
if (argc < 4) {
int main(int argc, char **argv)
{
if(argc < 4) {
fprintf(stderr, "Usage: %s r_addr if_name tty_dev\n", argv[0]);
return -1;
}
char addr[IPV6_ADDR_LEN];
sprintf(addr, "abcd::1034:00FF:FE00:%s/64",argv[1]);
sprintf(addr, "abcd::1034:00FF:FE00:%s/64", argv[1]);
char if_name[IF_NAME_LEN];
strncpy(if_name, argv[2], IF_NAME_LEN);
char tty_dev[DEV_LEN];
strncpy(tty_dev, argv[3], DEV_LEN);
if (border_initialize(if_name, addr, tty_dev) == 0) {
if(border_initialize(if_name, addr, tty_dev) == 0) {
#ifdef BORDER_TESTING
char ping_addr[IPV6_ADDR_LEN];
float interval;
if (argc < 9) {
if(argc < 9) {
fprintf(stderr, "Usage: %s r_addr if_name tty_dev ping_id result_dir skeleton_file ping_count interval\n", argv[0]);
return -1;
}
sscanf(argv[8], "%f", &interval);
sprintf(ping_addr, "abcd::%s/64",argv[4]);
start_test(ping_addr,argv[5],argv[6],atoi(argv[7]),interval);
#else
sprintf(ping_addr, "abcd::%s/64", argv[4]);
start_test(ping_addr, argv[5], argv[6], atoi(argv[7]), interval);
#else
while(1);
#endif
}
return 0;
}

218
dist/tools/linux-border_router/multiplex.c vendored
Unescape Escape View File

@ -17,180 +17,203 @@
uint8_t serial_out_buf[BUFFER_SIZE];
uint8_t serial_in_buf[BUFFER_SIZE];
uint8_t *get_serial_out_buffer(int offset) {
if (offset > BUFFER_SIZE) {
uint8_t *get_serial_out_buffer(int offset)
{
if(offset > BUFFER_SIZE) {
return NULL;
}
return &(serial_out_buf[offset]);
}
uint8_t *get_serial_in_buffer(int offset) {
if (offset > BUFFER_SIZE) {
uint8_t *get_serial_in_buffer(int offset)
{
if(offset > BUFFER_SIZE) {
return NULL;
}
return &(serial_in_buf[offset]);
}
int init_multiplex(const char *tty_dev) {
int init_multiplex(const char *tty_dev)
{
return open_serial_port(tty_dev);
}
uint8_t serial_read_byte() {
uint8_t serial_read_byte()
{
unsigned char c;
read_serial_port(&c, 1);
return (uint8_t)c;
}
int readpacket(uint8_t *packet_buf, size_t size) {
int readpacket(uint8_t *packet_buf, size_t size)
{
uint8_t *line_buf_ptr = packet_buf;
uint8_t byte = END+1;
uint8_t byte = END + 1;
uint8_t esc = 0;
uint8_t translate = 1;
while ((line_buf_ptr - packet_buf) < size-1) {
while((line_buf_ptr - packet_buf) < size - 1) {
byte = serial_read_byte();
if (translate && byte == END) {
if(translate && byte == END) {
break;
}
if (line_buf_ptr == packet_buf && byte != 0) {
if(line_buf_ptr == packet_buf && byte != 0) {
translate = 0;
}
if (line_buf_ptr > packet_buf && !translate && byte == '\n') {
if(line_buf_ptr > packet_buf && !translate && byte == '\n') {
*line_buf_ptr++ = '\0';
return line_buf_ptr - packet_buf;
}
if (translate) {
if (esc) {
if(translate) {
if(esc) {
esc = 0;
switch (byte) {
case(END_ESC):{
switch(byte) {
case(END_ESC): {
*line_buf_ptr++ = END;
continue;
}
case(ESC_ESC):{
case(ESC_ESC): {
*line_buf_ptr++ = ESC;
continue;
}
default:
continue;
}
}
if (byte == ESC) {
if(byte == ESC) {
esc = 1;
continue;
}
}
*line_buf_ptr++ = byte;
}
return (line_buf_ptr - packet_buf);
}
int writepacket(uint8_t *packet_buf, size_t size) {
uint8_t packet_tmp[2*BUFFER_SIZE];
int writepacket(uint8_t *packet_buf, size_t size)
{
uint8_t packet_tmp[2 * BUFFER_SIZE];
uint8_t *byte_ptr = packet_buf;
uint8_t *tmp_ptr = packet_tmp;
if (2*size + 1 > BUFFER_SIZE) {
if(2 * size + 1 > BUFFER_SIZE) {
return -1;
}
while ((byte_ptr - packet_buf) < size) {
switch (*byte_ptr) {
case(END):{
while((byte_ptr - packet_buf) < size) {
switch(*byte_ptr) {
case(END): {
*byte_ptr = END_ESC;
*tmp_ptr = ESC;
tmp_ptr++;
break;
}
case(ESC):{
case(ESC): {
*byte_ptr = ESC_ESC;
*tmp_ptr = ESC;
tmp_ptr++;
break;
}
default:{
default: {
break;
}
}
*tmp_ptr = *byte_ptr;
byte_ptr++;
tmp_ptr++;
}
*tmp_ptr++ = END;
write_serial_port(packet_tmp, tmp_ptr - packet_tmp);
return 0;
}
void demultiplex(const border_packet_t *packet, int len) {
switch (packet->type) {
case (BORDER_PACKET_RAW_TYPE):{
void demultiplex(const border_packet_t *packet, int len)
{
switch(packet->type) {
case(BORDER_PACKET_RAW_TYPE): {
printf("\033[00;33m[via serial interface] %s\033[00m\n",
((unsigned char *)packet) + sizeof (border_packet_t)
);
((unsigned char *)packet) + sizeof(border_packet_t)
);
break;
}
case (BORDER_PACKET_L3_TYPE):{
case(BORDER_PACKET_L3_TYPE): {
border_l3_header_t *l3_header_buf = (border_l3_header_t *)packet;
switch (l3_header_buf->ethertype) {
case (ETHERTYPE_IPV6):{
switch(l3_header_buf->ethertype) {
case(ETHERTYPE_IPV6): {
printf("INFO: IPv6-Packet %d received\n", l3_header_buf->seq_num);
struct ip6_hdr *ip6_buf = (struct ip6_hdr *)(((unsigned char *)packet) + sizeof (border_l3_header_t));
struct ip6_hdr *ip6_buf = (struct ip6_hdr *)(((unsigned char *)packet) + sizeof(border_l3_header_t));
border_send_ipv6_over_tun(get_tun_fd(), ip6_buf);
break;
}
default:
printf("INFO: Unknown ethertype %04x for packet %d\n", l3_header_buf->ethertype, l3_header_buf->seq_num);
break;
}
break;
}
case (BORDER_PACKET_CONF_TYPE):{
case(BORDER_PACKET_CONF_TYPE): {
border_conf_header_t *conf_header_buf = (border_conf_header_t *)packet;
switch (conf_header_buf->conftype) {
case (BORDER_CONF_SYNACK):{
printf("INFO: SYNACK-Packet %d received\n",conf_header_buf->seq_num);
switch(conf_header_buf->conftype) {
case(BORDER_CONF_SYNACK): {
printf("INFO: SYNACK-Packet %d received\n", conf_header_buf->seq_num);
signal_connection_established();
break;
}
case (BORDER_CONF_CONTEXT):{
case(BORDER_CONF_CONTEXT): {
printf("INFO: Context packet (%d) received, "
"but nothing is implemented yet for this case.\n",
conf_header_buf->seq_num);
"but nothing is implemented yet for this case.\n",
conf_header_buf->seq_num);
break;
}
case (BORDER_CONF_IPADDR):{
case(BORDER_CONF_IPADDR): {
char str_addr[IPV6_ADDR_LEN];
border_addr_packet_t *addr_packet = (border_addr_packet_t *)packet;
printf("INFO: Address packet (%d) received.\n",
conf_header_buf->seq_num);
conf_header_buf->seq_num);
inet_ntop(AF_INET6, &addr_packet->addr, str_addr, IPV6_ADDR_LEN);
tun_add_addr(str_addr);
}
default:
printf("INFO: Unknown conftype %02x for packet %d\n",
conf_header_buf->conftype,
conf_header_buf->seq_num);
printf("INFO: Unknown conftype %02x for packet %d\n",
conf_header_buf->conftype,
conf_header_buf->seq_num);
break;
}
break;
}
default:
printf("INFO: Unknown border packet type %02x for packet %d\n", packet->type, packet->seq_num);
//print_packet_hex((unsigned char *)packet,len);
@ -198,57 +221,60 @@ void demultiplex(const border_packet_t *packet, int len) {
}
}
void multiplex_send_context_over_tty(const border_context_t *context) {
void multiplex_send_context_over_tty(const border_context_t *context)
{
border_context_packet_t *con_packet = (border_context_packet_t *)get_serial_out_buffer(0);
con_packet->empty = 0;
con_packet->type = BORDER_PACKET_CONF_TYPE;
con_packet->conftype = BORDER_CONF_CONTEXT;
memcpy(
&con_packet->context,
context,
sizeof (border_context_t)
);
&con_packet->context,
context,
sizeof(border_context_t)
);
flowcontrol_send_over_tty(
(border_packet_t *) con_packet,
sizeof (border_context_packet_t)
);
(border_packet_t *) con_packet,
sizeof(border_context_packet_t)
);
}
void multiplex_send_addr_over_tty(struct in6_addr *addr) {
void multiplex_send_addr_over_tty(struct in6_addr *addr)
{
border_addr_packet_t *packet = (border_addr_packet_t *)get_serial_out_buffer(0);
packet->empty = 0;
packet->type = BORDER_PACKET_CONF_TYPE;
packet->conftype = BORDER_CONF_IPADDR;
memcpy(
&packet->addr,
addr,
sizeof (struct in6_addr)
);
&packet->addr,
addr,
sizeof(struct in6_addr)
);
flowcontrol_send_over_tty(
(border_packet_t *) packet,
sizeof (border_addr_packet_t)
);
(border_packet_t *) packet,
sizeof(border_addr_packet_t)
);
}
void multiplex_send_ipv6_over_tty(const struct ip6_hdr *packet) {
void multiplex_send_ipv6_over_tty(const struct ip6_hdr *packet)
{
border_l3_header_t *l3_hdr = (border_l3_header_t *)get_serial_out_buffer(0);
size_t packet_size = sizeof (struct ip6_hdr) + packet->ip6_plen;
size_t packet_size = sizeof(struct ip6_hdr) + packet->ip6_plen;
l3_hdr->empty = 0;
l3_hdr->type = BORDER_PACKET_L3_TYPE;
l3_hdr->ethertype = ETHERTYPE_IPV6;
memcpy(
get_serial_out_buffer(0) + sizeof (border_l3_header_t),
packet,
packet_size
);
get_serial_out_buffer(0) + sizeof(border_l3_header_t),
packet,
packet_size
);
flowcontrol_send_over_tty(
(border_packet_t *) l3_hdr,
sizeof (border_l3_header_t) + packet_size
);
(border_packet_t *) l3_hdr,
sizeof(border_l3_header_t) + packet_size
);
}

48
dist/tools/linux-border_router/multiplex.h vendored
Unescape Escape View File

@ -2,7 +2,7 @@
* @file multiplex.h
* @author Freie Universität Berlin, Computer Systems & Telemetics
* @author Martin Lenders <mlenders@inf.fu-berlin.de>
* @brief Public declarations for the multiplexing jobs via the
* @brief Public declarations for the multiplexing jobs via the
* serial interface for the 6LoWPAN Border Router driver.
*/
#ifndef MULTIPLEX_H
@ -30,11 +30,11 @@
/**
* @brief Describes packets for transmission via serial interface.
*/
typedef struct __attribute__ ((packed)) border_packet_t {
typedef struct __attribute__((packed)) border_packet_t {
/**
* @brief Reserved byte.
*
* Must be always 0 to distinguish packets from MSB-A2
*
* Must be always 0 to distinguish packets from MSB-A2
* stdout/stdin/stderr.
*/
uint8_t empty;
@ -47,7 +47,7 @@ typedef struct __attribute__ ((packed)) border_packet_t {
* serial interface.
* @extends border_packet_t
*/
typedef struct __attribute__ ((packed)) border_l3_header_t {
typedef struct __attribute__((packed)) border_l3_header_t {
uint8_t empty;
uint8_t type;
uint8_t seq_num;
@ -59,7 +59,7 @@ typedef struct __attribute__ ((packed)) border_l3_header_t {
* serial interface.
* @extends border_packet_t
*/
typedef struct __attribute__ ((packed)) border_conf_header_t {
typedef struct __attribute__((packed)) border_conf_header_t {
uint8_t empty;
uint8_t type;
uint8_t seq_num;
@ -69,11 +69,11 @@ typedef struct __attribute__ ((packed)) border_conf_header_t {
/**
* @brief Describes an address configuration packet.
* @extends border_conf_header_t
*
*
* This packet type enables the driver to add new IPv6 addresses to
* the border router.
*/
typedef struct __attribute__ ((packed)) border_addr_packet_t {
typedef struct __attribute__((packed)) border_addr_packet_t {
uint8_t empty;
uint8_t type;
uint8_t seq_num;
@ -82,18 +82,18 @@ typedef struct __attribute__ ((packed)) border_conf_header_t {
* @brief Version for this IP address (send with the ABRO for PIs,
* s. draft-ietf-6lowpan-nd-17).
*/
uint16_t version;
uint16_t version;
struct in6_addr addr; ///< New IPv6-Address to be added to this border router.
} border_addr_packet_t;
/**
* @brief Describes a context configuration packet.
* @extends border_conf_header_t
*
*
* This packet type enables the driver to manipulate Context Informations
* in the LoWPAN.
*/
typedef struct __attribute__ ((packed)) border_context_packet_t {
typedef struct __attribute__((packed)) border_context_packet_t {
uint8_t empty;
uint8_t type;
uint8_t seq_num;
@ -103,8 +103,8 @@ typedef struct __attribute__ ((packed)) border_context_packet_t {
/**
* @brief Size of all packet buffers in this driver.
*
* @ref border_l3_header_t was since packets of this type may be the
*
* @ref border_l3_header_t was since packets of this type may be the
* longest (with payload).
*/
#define BUFFER_SIZE sizeof (border_l3_header_t) + MTU
@ -122,7 +122,7 @@ int init_multiplex(const char *tty_dev);
* data, that shall be send via the serial interface.
* @param[in] offset The offset from the start of the buffer.
* @return Pointer to a cell in the buffer for the output
* data. The size of the buffer is then
* data. The size of the buffer is then
* \ref BUFFER_SIZE - <em>offset</em>.
*/
uint8_t *get_serial_out_buffer(int offset);
@ -132,7 +132,7 @@ uint8_t *get_serial_out_buffer(int offset);
* data, that was received via the serial interface.
* @param[in] offset The offset from the start of the buffer.
* @return Pointer to a cell in the buffer for the input
* data. The size of the buffer is then
* data. The size of the buffer is then
* \ref BUFFER_SIZE - <em>offset</em>.
*/
uint8_t *get_serial_in_buffer(int offset);
@ -141,7 +141,7 @@ uint8_t *get_serial_in_buffer(int offset);
* @brief Demultiplexes a packet, that was received via the serial
* interface.
* @param[in] packet Packet, that should be demultiplexed.
* @param[in] len Length of the packet, that should be
* @param[in] len Length of the packet, that should be
* demultiplexed.
*/
void demultiplex(const border_packet_t *packet, int len);
@ -150,29 +150,29 @@ void demultiplex(const border_packet_t *packet, int len);
* @brief Sends an IPv6 datagram via the serial interface.
* @param[in] packet The IPv6 datagram that is to be send via the
* serial interface and starts with an IPv6 header.
*
* The function uses the payload length field of the IPv6 Header to
* determine the length of the overall packet. The payload bytes
*
* The function uses the payload length field of the IPv6 Header to
* determine the length of the overall packet. The payload bytes
* <em>must</em> follow the header in memory.
*/
void multiplex_send_ipv6_over_tty(const struct ip6_hdr *packet);
/**
* @brief Sends context information via the serial interface.
* @param[in] context The context information that is to be send via
* @param[in] context The context information that is to be send via
* the serial interface.
*/
void multiplex_send_context_over_tty(const border_context_t *context);
/**
* @brief Sends new IPv6 address via the serial interface.
* @param[in] addr The new address that is to be send via
* @param[in] addr The new address that is to be send via
* the serial interface.
*/
void multiplex_send_addr_over_tty(struct in6_addr *addr);
/**
* @brief Reads a packet up to a length of <em>size</em> bytes from
* @brief Reads a packet up to a length of <em>size</em> bytes from
* the serial interface and saves it to <em>packet_buf</em>.
* @param[out] packet_buf The buffer the read packet should be written
* into.
@ -182,9 +182,9 @@ void multiplex_send_addr_over_tty(struct in6_addr *addr);
int readpacket(uint8_t *packet_buf, size_t size);
/**
* @brief Writes a packet up to a length of <em>size</em> bytes from
* @brief Writes a packet up to a length of <em>size</em> bytes from
* <em>packet_buf</em> to the serial interface.
* @param[in] packet_buf The buffer from which the packet should be
* @param[in] packet_buf The buffer from which the packet should be
* written.
* @param[in] size The maximum number of bytes to be written.
* @return The number of bytes written.

499
dist/tools/linux-border_router/serial.c vendored
Unescape Escape View File

@ -50,43 +50,53 @@
#include "serial.h"
int port_fd=-1;
int port_fd = -1;
static tcflag_t baud_name_to_flags(const char *baud_name);
static void report_open_error(const char *filename, int err);
char* baud_rate = "115200";
char *baud_rate = "115200";
int open_serial_port(const char *port_name)
{
int r;
if (port_fd >= 0) {
close(port_fd);
}
port_fd = open(port_name, O_RDWR);
if (port_fd < 0) {
report_open_error(port_name, errno);
return -1;
}
r = set_baud(baud_rate);
if (r == 0) {
printf("Port \"%s\" opened at %s baud\r\n",
port_name, baud_rate);
} else {
printf("Port \"%s\" opened, unable to set baud to %s\r\n",
port_name, baud_rate);
}
#ifdef LINUX
{
struct serial_struct kernel_serial_settings;
/* attempt to set low latency mode, but don't worry if we can't */
r = ioctl(port_fd, TIOCGSERIAL, &kernel_serial_settings);
if (r < 0) return 0;
kernel_serial_settings.flags |= ASYNC_LOW_LATENCY;
ioctl(port_fd, TIOCSSERIAL, &kernel_serial_settings);
}
#endif
int r;
if(port_fd >= 0) {
close(port_fd);
}
port_fd = open(port_name, O_RDWR);
if(port_fd < 0) {
report_open_error(port_name, errno);
return -1;
}
r = set_baud(baud_rate);
if(r == 0) {
printf("Port \"%s\" opened at %s baud\r\n",
port_name, baud_rate);
}
else {
printf("Port \"%s\" opened, unable to set baud to %s\r\n",
port_name, baud_rate);
}
#ifdef LINUX
{
struct serial_struct kernel_serial_settings;
/* attempt to set low latency mode, but don't worry if we can't */
r = ioctl(port_fd, TIOCGSERIAL, &kernel_serial_settings);
if(r < 0) {
return 0;
}
kernel_serial_settings.flags |= ASYNC_LOW_LATENCY;
ioctl(port_fd, TIOCSSERIAL, &kernel_serial_settings);
}
#endif
return 0;
}
@ -96,190 +106,255 @@ int open_serial_port(const char *port_name)
*/
static void report_open_error(const char *filename, int err)
{
struct stat info;
uid_t my_uid;
gid_t my_gid;
char my_uname[64], my_gname[64], file_uname[64], file_gname[64];
struct passwd *p;
struct group *g;
mode_t perm;
int r, perm_ok=0;
printf("\r\n");
printf("Unable to open \"%s\"\r\n", filename);
if (err == EACCES) {
printf("You don't have permission to access %s\r\n", filename);
}
//printf("Attemping to find more information about %s....\r\n", filename);
r = stat(filename, &info);
if (r < 0) {
if (errno == ENOENT) {
printf("file %s does not exist\r\n", filename);
} else if (errno == ELOOP) {
printf("too many symbolic links\r\n");
} else if (errno == EACCES) {
printf("permission denied to get file status\r\n");
} else {
printf("Unable to get file status, err%d\r\n", errno);
}
return;
}
my_uid = getuid();
my_gid = getgid();
p = getpwuid(my_uid);
if (p) {
snprintf(my_uname, sizeof(my_uname),
"\"%s\" (gid=%d)", p->pw_name, (int)my_uid);
} else {
snprintf(my_uname, sizeof(my_uname),
"(gid=%d)", (int)my_uid);
}
p = getpwuid(info.st_uid);
if (p) {
snprintf(file_uname, sizeof(file_uname),
"\"%s\" (uid=%d)", p->pw_name, (int)info.st_uid);
} else {
snprintf(file_uname, sizeof(file_uname),
"(uid=%d)", (int)info.st_uid);
}
g = getgrgid(my_gid);
if (g) {
snprintf(my_gname, sizeof(my_gname),
"\"%s\" (gid=%d)", g->gr_name, (int)my_gid);
} else {
snprintf(my_gname, sizeof(my_gname),
"(gid=%d)", (int)my_gid);
}
g = getgrgid(info.st_gid);
if (g) {
snprintf(file_gname, sizeof(file_gname),
"\"%s\" (uid=%d)", g->gr_name, (int)info.st_gid);
} else {
snprintf(file_gname, sizeof(file_gname),
"(uid=%d)", (int)info.st_gid);
}
/* printf("%s is owned by: user %s, group %s\r\n",
filename, file_uname, file_gname); */
perm = info.st_mode;
if ((perm & S_IROTH) && (perm & S_IWOTH)) {
printf("%s has read/write permission for everybody\r\n",
filename);
} else {
printf("%s is not read/write for everybody, so\r\n", filename);
printf(" you must match either user or group permission\r\n");
if ((perm & S_IRUSR) && (perm & S_IWUSR)) {
printf("%s has read/write permission for user %s\r\n",
filename, file_uname);
perm_ok = 1;
}
if ((perm & S_IRGRP) && (perm & S_IWGRP)) {
printf("%s has read/write permission for group %s\r\n",
filename, file_gname);
perm_ok = 1;
}
if (perm_ok == 0) {
printf("%s does not read/write permission for user or group!\r\n",
filename);
} else {
printf("Your access privs: user %s, group %s\r\n",
my_uname, my_gname);
}
}
printf("\r\n");
struct stat info;
uid_t my_uid;
gid_t my_gid;
char my_uname[64], my_gname[64], file_uname[64], file_gname[64];
struct passwd *p;
struct group *g;
mode_t perm;
int r, perm_ok = 0;
printf("\r\n");
printf("Unable to open \"%s\"\r\n", filename);
if(err == EACCES) {
printf("You don't have permission to access %s\r\n", filename);
}
r = stat(filename, &info);
if(r < 0) {
if(errno == ENOENT) {
printf("file %s does not exist\r\n", filename);
}
else if(errno == ELOOP) {
printf("too many symbolic links\r\n");
}
else if(errno == EACCES) {
printf("permission denied to get file status\r\n");
}
else {
printf("Unable to get file status, err%d\r\n", errno);
}
return;
}
my_uid = getuid();
my_gid = getgid();
p = getpwuid(my_uid);
if(p) {
snprintf(my_uname, sizeof(my_uname),
"\"%s\" (gid=%d)", p->pw_name, (int)my_uid);
}
else {
snprintf(my_uname, sizeof(my_uname),
"(gid=%d)", (int)my_uid);
}
p = getpwuid(info.st_uid);
if(p) {
snprintf(file_uname, sizeof(file_uname),
"\"%s\" (uid=%d)", p->pw_name, (int)info.st_uid);
}
else {
snprintf(file_uname, sizeof(file_uname),
"(uid=%d)", (int)info.st_uid);
}
g = getgrgid(my_gid);
if(g) {
snprintf(my_gname, sizeof(my_gname),
"\"%s\" (gid=%d)", g->gr_name, (int)my_gid);
}
else {
snprintf(my_gname, sizeof(my_gname),
"(gid=%d)", (int)my_gid);
}
g = getgrgid(info.st_gid);
if(g) {
snprintf(file_gname, sizeof(file_gname),
"\"%s\" (uid=%d)", g->gr_name, (int)info.st_gid);
}
else {
snprintf(file_gname, sizeof(file_gname),
"(uid=%d)", (int)info.st_gid);
}
/* printf("%s is owned by: user %s, group %s\r\n",
filename, file_uname, file_gname); */
perm = info.st_mode;
if((perm & S_IROTH) && (perm & S_IWOTH)) {
printf("%s has read/write permission for everybody\r\n",
filename);
}
else {
printf("%s is not read/write for everybody, so\r\n", filename);
printf(" you must match either user or group permission\r\n");
if((perm & S_IRUSR) && (perm & S_IWUSR)) {
printf("%s has read/write permission for user %s\r\n",
filename, file_uname);
perm_ok = 1;
}
if((perm & S_IRGRP) && (perm & S_IWGRP)) {
printf("%s has read/write permission for group %s\r\n",
filename, file_gname);
perm_ok = 1;
}
if(perm_ok == 0) {
printf("%s does not read/write permission for user or group!\r\n",
filename);
}
else {
printf("Your access privs: user %s, group %s\r\n",
my_uname, my_gname);
}
}
printf("\r\n");
}
int write_serial_port(const void *buf, int num)
{
return(write(port_fd, buf, num));
return(write(port_fd, buf, num));
}
void input_flush_serial_port(void)
{
tcflush(port_fd, TCIFLUSH);
tcflush(port_fd, TCIFLUSH);
}
int read_serial_port_nb(unsigned char *buf, int bufsize)
{
int num, flags;
int num, flags;
flags = fcntl(port_fd, F_GETFL);
fcntl(port_fd, F_SETFL, flags | O_NONBLOCK);
num = read(port_fd, buf, bufsize);
fcntl(port_fd, F_SETFL, flags);
return num;
flags = fcntl(port_fd, F_GETFL);
fcntl(port_fd, F_SETFL, flags | O_NONBLOCK);
num = read(port_fd, buf, bufsize);
fcntl(port_fd, F_SETFL, flags);
return num;
}
int read_serial_port(unsigned char *buf, int bufsize)
{
int num;
int num;
num = read(port_fd, buf, bufsize);
num = read(port_fd, buf, bufsize);
return num;
return num;
}
void send_break_signal(void)
{
tcsendbreak(port_fd, 0);
tcsendbreak(port_fd, 0);
}
void close_serial_port(void)
{
if (port_fd >= 0) {
close(port_fd);
port_fd = -1;
}
if(port_fd >= 0) {
close(port_fd);
port_fd = -1;
}
}
tcflag_t baud_name_to_flags(const char *baud_name)
{
if (strcmp(baud_name, "230400") == 0) return B230400;
if (strcmp(baud_name, "115200") == 0) return B115200;
if (strcmp(baud_name, "57600") == 0) return B57600;
if (strcmp(baud_name, "38400") == 0) return B38400;
if (strcmp(baud_name, "19200") == 0) return B19200;
if (strcmp(baud_name, "9600") == 0) return B9600;
if (strcmp(baud_name, "4800") == 0) return B4800;
if (strcmp(baud_name, "2400") == 0) return B2400;
if (strcmp(baud_name, "1200") == 0) return B1200;
if (strcmp(baud_name, "300") == 0) return B300;
return B0;
if(strcmp(baud_name, "230400") == 0) {
return B230400;
}
if(strcmp(baud_name, "115200") == 0) {
return B115200;
}
if(strcmp(baud_name, "57600") == 0) {
return B57600;
}
if(strcmp(baud_name, "38400") == 0) {
return B38400;
}
if(strcmp(baud_name, "19200") == 0) {
return B19200;
}
if(strcmp(baud_name, "9600") == 0) {
return B9600;
}
if(strcmp(baud_name, "4800") == 0) {
return B4800;
}
if(strcmp(baud_name, "2400") == 0) {
return B2400;
}
if(strcmp(baud_name, "1200") == 0) {
return B1200;
}
if(strcmp(baud_name, "300") == 0) {
return B300;
}
return B0;
}
int set_baud(const char *baud_name)
{
struct termios port_setting;
tcflag_t baud;
int r;
if (port_fd < 0) return -1;
baud = baud_name_to_flags(baud_name);
if (baud == B0) return -2;
r = tcgetattr(port_fd, &port_setting);
if (r != 0) return -3;
//port_setting.c_iflag = IGNBRK | IGNPAR | IXANY | IXON;
port_setting.c_iflag = IGNBRK | IGNPAR;
port_setting.c_cflag = baud | CS8 | CREAD | HUPCL | CLOCAL;
port_setting.c_oflag = 0;
port_setting.c_lflag = 0;
r = tcsetattr(port_fd, TCSAFLUSH, &port_setting);
if (r != 0) return -4;
return 0;
struct termios port_setting;
tcflag_t baud;
int r;
if(port_fd < 0) {
return -1;
}
baud = baud_name_to_flags(baud_name);
if(baud == B0) {
return -2;
}
r = tcgetattr(port_fd, &port_setting);
if(r != 0) {
return -3;
}
port_setting.c_iflag = IGNBRK | IGNPAR;
port_setting.c_cflag = baud | CS8 | CREAD | HUPCL | CLOCAL;
port_setting.c_oflag = 0;
port_setting.c_lflag = 0;
r = tcsetattr(port_fd, TCSAFLUSH, &port_setting);
if(r != 0) {
return -4;
}
return 0;
}
@ -288,31 +363,35 @@ int set_baud(const char *baud_name)
// use of the serial port is supposed to happen in the file.
int serial_port_fd(void)
{
return port_fd;
return port_fd;
}
void set_rts(int val)
{
int flags;
int result;
result = ioctl(port_fd, TIOCMGET, &flags);
if( result == -1 ) {
printf("Error %i while reading port io flags\n", errno);
return;
}
if (val) {
flags |= TIOCM_RTS;
} else {
flags &= ~(TIOCM_RTS);
}
result = ioctl(port_fd, TIOCMSET, &flags);
if( result == -1 )
printf("Error %i while setting port io flags\n", errno);
int flags;
int result;
result = ioctl(port_fd, TIOCMGET, &flags);