RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

fixed coding style (space after most keywords)

Browse Source
This commit is contained in:
Oliver Hahm 2013-06-24 22:37:35 +02:00
parent 5bae4f841d
commit c8bee9e554
112 changed files with 1914 additions and 1914 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/bitarithm.c
View File

@ -31,7 +31,7 @@ number_of_highest_bit(unsigned v)
r |= (v >> 1);
#else
r = 0;
while(v >>= 1) { // unroll for more speed...
while (v >>= 1) { // unroll for more speed...
r++;
}
@ -45,7 +45,7 @@ number_of_lowest_bit(register unsigned v)
{
register unsigned r = 0;
while((v & 0x01) == 0) {
while ((v & 0x01) == 0) {
v >>= 1;
r++;
};
@ -58,7 +58,7 @@ number_of_bits_set(unsigned v)
{
unsigned c; // c accumulates the total bits set in v
for(c = 0; v; c++) {
for (c = 0; v; c++) {
v &= v - 1; // clear the least significant bit set
}

4
core/cib.c
View File

@ -16,7 +16,7 @@ int cib_get(cib_t *cib)
{
int avail = cib_avail(cib);
if(avail > 0) {
if (avail > 0) {
return (int)(cib->read_count++ & ~cib->complement);
}
@ -27,7 +27,7 @@ int cib_put(cib_t *cib)
{
int avail = cib_avail(cib);
if((int)(avail + cib->complement) < 0) {
if ((int)(avail + cib->complement) < 0) {
return (int)(cib->write_count++ & ~(cib->complement));
}

12
core/clist.c
View File

@ -21,13 +21,13 @@
/* inserts new_node after node */
void clist_add(clist_node_t **node, clist_node_t *new_node)
{
if(*node != NULL) {
if (*node != NULL) {
new_node->next = (*node);
new_node->prev = (*node)->prev;
(*node)->prev->next = new_node;
(*node)->prev = new_node;
if((*node)->prev == *node) {
if ((*node)->prev == *node) {
(*node)->prev = new_node;
}
}
@ -41,11 +41,11 @@ void clist_add(clist_node_t **node, clist_node_t *new_node)
/* removes node. */
void clist_remove(clist_node_t **list, clist_node_t *node)
{
if(node->next != node) {
if (node->next != node) {
node->prev->next = node->next;
node->next->prev = node->prev;
if(node == *list) {
if (node == *list) {
*list = node->next;
}
}
@ -58,11 +58,11 @@ void clist_print(clist_node_t *clist)
{
clist_node_t *start = clist;
while(clist != NULL) {
while (clist != NULL) {
printf("list entry: %u prev=%u next=%u\n", clist->data, clist->prev->data, clist->next->data);
clist = clist->next;
if(clist == start) {
if (clist == start) {
break;
}
}

22
core/hwtimer.c
View File

@ -55,9 +55,9 @@ void hwtimer_spin(unsigned long ticks)
{
unsigned long co = hwtimer_arch_now() + ticks;
while(hwtimer_arch_now() > co);
while (hwtimer_arch_now() > co);
while(hwtimer_arch_now() < co);
while (hwtimer_arch_now() < co);
}
/*---------------------------------------------------------------------------*/
@ -75,7 +75,7 @@ void hwtimer_init_comp(uint32_t fcpu)
lifo_init(lifo, ARCH_MAXTIMERS);
for(int i = 0; i < ARCH_MAXTIMERS; i++) {
for (int i = 0; i < ARCH_MAXTIMERS; i++) {
lifo_insert(lifo, i);
}
}
@ -84,7 +84,7 @@ void hwtimer_init_comp(uint32_t fcpu)
int hwtimer_active(void)
{
return (! lifo_empty(lifo));
return (!lifo_empty(lifo));
}
/*---------------------------------------------------------------------------*/
@ -98,7 +98,7 @@ unsigned long hwtimer_now(void)
void hwtimer_wait(unsigned long ticks)
{
if(ticks <= 6 || inISR()) {
if (ticks <= 6 || inISR()) {
hwtimer_spin(ticks);
return;
}
@ -106,7 +106,7 @@ void hwtimer_wait(unsigned long ticks)
/* -2 is to adjust the real value */
int res = hwtimer_set(ticks - 2, hwtimer_wakeup, (void*)(unsigned int)(active_thread->pid));
if(res == -1) {
if (res == -1) {
hwtimer_spin(ticks);
return;
}
@ -119,14 +119,14 @@ void hwtimer_wait(unsigned long ticks)
static int _hwtimer_set(unsigned long offset, void (*callback)(void*), void *ptr, bool absolute)
{
if(!inISR()) {
if (!inISR()) {
dINT();
}
int n = lifo_get(lifo);
if(n == -1) {
if(! inISR()) {
if (n == -1) {
if (!inISR()) {
eINT();
}
@ -137,7 +137,7 @@ static int _hwtimer_set(unsigned long offset, void (*callback)(void*), void *ptr
timer[n].callback = callback;
timer[n].data = ptr;
if(absolute) {
if (absolute) {
hwtimer_arch_set_absolute(offset, n);
}
else {
@ -146,7 +146,7 @@ static int _hwtimer_set(unsigned long offset, void (*callback)(void*), void *ptr
lpm_prevent_sleep++;
if(!inISR()) {
if (!inISR()) {
eINT();
}

2
core/include/msg.h
View File

@ -94,7 +94,7 @@ int msg_receive(msg_t *m);
* @brief Send a message, block until reply received.
*
* This function sends a message to target_pid and then blocks until target has sent a reply.
* @note CAUTION! Use this function only when receiver is already waiting. If not use simple msg_send()
* @note CAUTION!Use this function only when receiver is already waiting. If not use simple msg_send()
* @param m pointer to preallocated msg
* @param reply pointer to preallocated msg. Reply will be written here.
* @param target pid the pid of the target process

8
core/kernel_init.c
View File

@ -42,8 +42,8 @@ extern int main(void);
static void idle_thread(void)
{
while(1) {
if(lpm_prevent_sleep) {
while (1) {
if (lpm_prevent_sleep) {
lpm_set(LPM_IDLE);
}
else {
@ -73,11 +73,11 @@ void kernel_init(void)
sched_init();
if(thread_create(idle_stack, sizeof(idle_stack), PRIORITY_IDLE, CREATE_WOUT_YIELD | CREATE_STACKTEST, idle_thread, idle_name) < 0) {
if (thread_create(idle_stack, sizeof(idle_stack), PRIORITY_IDLE, CREATE_WOUT_YIELD | CREATE_STACKTEST, idle_thread, idle_name) < 0) {
printf("kernel_init(): error creating idle task.\n");
}
if(thread_create(main_stack, sizeof(main_stack), PRIORITY_MAIN, CREATE_WOUT_YIELD | CREATE_STACKTEST, MAIN_FUNC, main_name) < 0) {
if (thread_create(main_stack, sizeof(main_stack), PRIORITY_MAIN, CREATE_WOUT_YIELD | CREATE_STACKTEST, MAIN_FUNC, main_name) < 0) {
printf("kernel_init(): error creating main task.\n");
}

4
core/lifo.c
View File

@ -7,7 +7,7 @@ int lifo_empty(int *array)
void lifo_init(int *array, int n)
{
for(int i = 0; i <= n; i++) {
for (int i = 0; i <= n; i++) {
array[i] = -1;
}
}
@ -23,7 +23,7 @@ int lifo_get(int *array)
{
int head = array[0];
if(head != -1) {
if (head != -1) {
array[0] = array[head + 1];
}

34
core/msg.c
View File

@ -32,7 +32,7 @@ static int queue_msg(tcb_t *target, msg_t *m)
{
int n = cib_put(&(target->msg_queue));
if(n != -1) {
if (n != -1) {
target->msg_array[n] = *m;
return 1;
}
@ -42,7 +42,7 @@ static int queue_msg(tcb_t *target, msg_t *m)
int msg_send(msg_t *m, unsigned int target_pid, bool block)
{
if(inISR()) {
if (inISR()) {
return msg_send_int(m, target_pid);
}
@ -50,23 +50,23 @@ int msg_send(msg_t *m, unsigned int target_pid, bool block)
m->sender_pid = thread_pid;
if(m->sender_pid == target_pid) {
if (m->sender_pid == target_pid) {
return -1;
}
if(target == NULL) {
if (target == NULL) {
return -1;
}
dINT();
if(target->status != STATUS_RECEIVE_BLOCKED) {
if(target->msg_array && queue_msg(target, m)) {
if (target->status != STATUS_RECEIVE_BLOCKED) {
if (target->msg_array && queue_msg(target, m)) {
eINT();
return 1;
}
if(!block) {
if (!block) {
DEBUG("%s: receiver not waiting. block=%u\n", active_thread->name, block);
eINT();
return 0;
@ -84,7 +84,7 @@ int msg_send(msg_t *m, unsigned int target_pid, bool block)
int newstatus;
if(active_thread->status == STATUS_REPLY_BLOCKED) {
if (active_thread->status == STATUS_REPLY_BLOCKED) {
newstatus = STATUS_REPLY_BLOCKED;
}
else {
@ -113,7 +113,7 @@ int msg_send_int(msg_t *m, unsigned int target_pid)
{
tcb_t *target = (tcb_t *) sched_threads[target_pid];
if(target->status == STATUS_RECEIVE_BLOCKED) {
if (target->status == STATUS_RECEIVE_BLOCKED) {
DEBUG("msg_send_int: direct msg copy from %i to %i.\n", thread_getpid(), target_pid);
m->sender_pid = target_pid;
@ -151,7 +151,7 @@ int msg_reply(msg_t *m, msg_t *reply)
tcb_t *target = (tcb_t*) sched_threads[m->sender_pid];
if(target->status != STATUS_REPLY_BLOCKED) {
if (target->status != STATUS_REPLY_BLOCKED) {
DEBUG("%s: msg_reply(): target \"%s\" not waiting for reply.", active_thread->name, target->name);
restoreIRQ(state);
return -1;
@ -172,7 +172,7 @@ int msg_reply_int(msg_t *m, msg_t *reply)
{
tcb_t *target = (tcb_t*) sched_threads[m->sender_pid];
if(target->status != STATUS_REPLY_BLOCKED) {
if (target->status != STATUS_REPLY_BLOCKED) {
DEBUG("%s: msg_reply_int(): target \"%s\" not waiting for reply.", active_thread->name, target->name);
return -1;
}
@ -193,11 +193,11 @@ int msg_receive(msg_t *m)
int n = -1;
if(me->msg_array) {
if (me->msg_array) {
n = cib_get(&(me->msg_queue));
}
if(n >= 0) {
if (n >= 0) {
DEBUG("%s: msg_receive(): We've got a queued message.\n", active_thread->name);
*m = me->msg_array[n];
}
@ -207,10 +207,10 @@ int msg_receive(msg_t *m)
queue_node_t *node = queue_remove_head(&(me->msg_waiters));
if(node == NULL) {
if (node == NULL) {
DEBUG("%s: msg_receive(): No thread in waiting list.\n", active_thread->name);
if(n < 0) {
if (n < 0) {
DEBUG("%s: msg_receive(): No msg in queue. Going blocked.\n", active_thread->name);
sched_set_status(me, STATUS_RECEIVE_BLOCKED);
@ -226,7 +226,7 @@ int msg_receive(msg_t *m)
DEBUG("%s: msg_receive(): Wakeing up waiting thread.\n", active_thread->name);
tcb_t *sender = (tcb_t*) node->data;
if(n >= 0) {
if (n >= 0) {
/* we've already got a messgage from the queue. as there is a
* waiter, take it's message into the just freed queue space.
*/
@ -249,7 +249,7 @@ int msg_receive(msg_t *m)
int msg_init_queue(msg_t *array, int num)
{
/* make sure brainfuck condition is met */
if(num && (num & (num - 1)) == 0) {
if (num && (num & (num - 1)) == 0) {
tcb_t *me = (tcb_t*) active_thread;
me->msg_array = array;
cib_init(&(me->msg_queue), num);

8
core/mutex.c
View File

@ -52,7 +52,7 @@ int mutex_lock(struct mutex_t *mutex)
{
DEBUG("%s: trying to get mutex. val: %u\n", active_thread->name, mutex->val);
if(atomic_set_return(&mutex->val, 1) != 0) {
if (atomic_set_return(&mutex->val, 1) != 0) {
/* mutex was locked. */
mutex_wait(mutex);
}
@ -65,7 +65,7 @@ void mutex_wait(struct mutex_t *mutex)
int irqstate = disableIRQ();
DEBUG("%s: Mutex in use. %u\n", active_thread->name, mutex->val);
if(mutex->val == 0) {
if (mutex->val == 0) {
/* somebody released the mutex. return. */
mutex->val = thread_pid;
DEBUG("%s: mutex_wait early out. %u\n", active_thread->name, mutex->val);
@ -96,8 +96,8 @@ void mutex_unlock(struct mutex_t *mutex, int yield)
DEBUG("%s: unlocking mutex. val: %u pid: %u\n", active_thread->name, mutex->val, thread_pid);
int irqstate = disableIRQ();
if(mutex->val != 0) {
if(mutex->queue.next) {
if (mutex->val != 0) {
if (mutex->queue.next) {
queue_node_t *next = queue_remove_head(&(mutex->queue));
tcb_t *process = (tcb_t*) next->data;
DEBUG("%s: waking up waiter %s.\n", process->name);

2
core/oneway_malloc.c
View File

@ -31,7 +31,7 @@ void *_malloc(size_t size)
DEBUG("_malloc(): allocating block of size %u at 0x%X.\n", (unsigned int) size, (unsigned int)ptr);
if(ptr != (void*) - 1) {
if (ptr != (void*) - 1) {
return ptr;
}
else {

18
core/queue.c
View File

@ -23,8 +23,8 @@
void queue_remove(queue_node_t *root, queue_node_t *node)
{
while(root->next != NULL) {
if(root->next == node) {
while (root->next != NULL) {
if (root->next == node) {
root->next = node->next;
node->next = NULL;
return;
@ -38,7 +38,7 @@ queue_node_t *queue_remove_head(queue_node_t *root)
{
queue_node_t *head = root->next;
if(head != NULL) {
if (head != NULL) {
root->next = head->next;
}
@ -47,7 +47,7 @@ queue_node_t *queue_remove_head(queue_node_t *root)
void queue_add_tail(queue_node_t *node, queue_node_t *new_obj)
{
while(node->next != NULL) {
while (node->next != NULL) {
node = node->next;
}
@ -65,8 +65,8 @@ void queue_priority_add(queue_node_t *root, queue_node_t *new_obj)
{
queue_node_t *node = root;
while(node->next != NULL) {
if(node->next->priority > new_obj->priority) {
while (node->next != NULL) {
if (node->next->priority > new_obj->priority) {
new_obj->next = node->next;
node->next = new_obj;
return;
@ -83,8 +83,8 @@ void queue_priority_add_generic(queue_node_t *root, queue_node_t *new_obj, int (
{
queue_node_t *node = root;
while(node->next != NULL) {
if(cmp(node->next, new_obj) < 0) {
while (node->next != NULL) {
if (cmp(node->next, new_obj) < 0) {
new_obj->next = node->next;
node->next = new_obj;
return;
@ -102,7 +102,7 @@ void queue_print(queue_node_t *node)
{
printf("queue:\n");
while(node->next != NULL) {
while (node->next != NULL) {
node = node->next;
printf("Data: %u Priority: %u\n", node->data, node->priority);
}

38
core/sched.c
View File

@ -50,7 +50,7 @@ void sched_init()
printf("Scheduler...");
int i;
for(i = 0; i < MAXTHREADS; i++) {
for (i = 0; i < MAXTHREADS; i++) {
sched_threads[i] = NULL;
#if SCHEDSTATISTICS
pidlist[i].laststart = 0;
@ -62,7 +62,7 @@ void sched_init()
active_thread = NULL;
thread_pid = -1;
for(i = 0; i < SCHED_PRIO_LEVELS; i++) {
for (i = 0; i < SCHED_PRIO_LEVELS; i++) {
runqueues[i] = NULL;
}
@ -75,14 +75,14 @@ void sched_run()
tcb_t *my_active_thread = (tcb_t *)active_thread;
if(my_active_thread) {
if(my_active_thread->status == STATUS_RUNNING) {
if (my_active_thread) {
if (my_active_thread->status == STATUS_RUNNING) {
my_active_thread->status = STATUS_PENDING;
}
#ifdef SCHED_TEST_STACK
if(*((unsigned int *)my_active_thread->stack_start) != (unsigned int) my_active_thread->stack_start) {
if (*((unsigned int *)my_active_thread->stack_start) != (unsigned int) my_active_thread->stack_start) {
printf("scheduler(): stack overflow detected, task=%s pid=%u\n", my_active_thread->name, my_active_thread->pid);
}
@ -95,7 +95,7 @@ void sched_run()
extern unsigned long hwtimer_now(void);
unsigned int time = hwtimer_now();
if(my_active_thread && (pidlist[my_active_thread->pid].laststart)) {
if (my_active_thread && (pidlist[my_active_thread->pid].laststart)) {
pidlist[my_active_thread->pid].runtime += time - pidlist[my_active_thread->pid].laststart;
}
@ -103,10 +103,10 @@ void sched_run()
DEBUG("\nscheduler: previous task: %s\n", (my_active_thread == NULL) ? "none" : my_active_thread->name);
if(num_tasks == 0) {
if (num_tasks == 0) {
DEBUG("scheduler: no tasks left.\n");
while(! num_tasks) {
while (!num_tasks) {
/* loop until a new task arrives */
;
}
@ -116,7 +116,7 @@ void sched_run()
my_active_thread = NULL;
while(! my_active_thread) {
while (!my_active_thread) {
int nextrq = number_of_lowest_bit(runqueue_bitcache);
clist_node_t next = *(runqueues[nextrq]);
DEBUG("scheduler: first in queue: %s\n", ((tcb_t *)next.data)->name);
@ -129,7 +129,7 @@ void sched_run()
#endif
#ifdef MODULE_NSS
if(active_thread && active_thread->pid != last_pid) {
if (active_thread && active_thread->pid != last_pid) {
last_pid = active_thread->pid;
}
@ -138,9 +138,9 @@ void sched_run()
DEBUG("scheduler: next task: %s\n", my_active_thread->name);
if(my_active_thread != active_thread) {
if(active_thread != NULL) { /* TODO: necessary? */
if(active_thread->status == STATUS_RUNNING) {
if (my_active_thread != active_thread) {
if (active_thread != NULL) { /* TODO: necessary? */
if (active_thread->status == STATUS_RUNNING) {
active_thread->status = STATUS_PENDING ;
}
}
@ -162,19 +162,19 @@ void sched_register_cb(void (*callback)(uint32_t, uint32_t))
void sched_set_status(tcb_t *process, unsigned int status)
{
if(status & STATUS_ON_RUNQUEUE) {
if(!(process->status & STATUS_ON_RUNQUEUE)) {
if (status & STATUS_ON_RUNQUEUE) {
if (!(process->status & STATUS_ON_RUNQUEUE)) {
DEBUG("adding process %s to runqueue %u.\n", process->name, process->priority);
clist_add(&runqueues[process->priority], &(process->rq_entry));
runqueue_bitcache |= 1 << process->priority;
}
}
else {
if(process->status & STATUS_ON_RUNQUEUE) {
if (process->status & STATUS_ON_RUNQUEUE) {
DEBUG("removing process %s from runqueue %u.\n", process->name, process->priority);
clist_remove(&runqueues[process->priority], &(process->rq_entry));
if(! runqueues[process->priority]) {
if (!runqueues[process->priority]) {
runqueue_bitcache &= ~(1 << process->priority);
}
}
@ -187,8 +187,8 @@ void sched_switch(uint16_t current_prio, uint16_t other_prio, int in_isr)
{
DEBUG("%s: %i %i %i\n", active_thread->name, (int)current_prio, (int)other_prio, in_isr);
if(current_prio <= other_prio) {
if(in_isr) {
if (current_prio <= other_prio) {
if (in_isr) {
sched_context_switch_request = 1;
}
else {

42
core/thread.c
View File

@ -40,7 +40,7 @@ int thread_getlastpid()
unsigned int thread_getstatus(int pid)
{
if(sched_threads[pid] == NULL) {
if (sched_threads[pid] == NULL) {
return STATUS_NOT_FOUND;
}
@ -49,7 +49,7 @@ unsigned int thread_getstatus(int pid)
void thread_sleep()
{
if(inISR()) {
if (inISR()) {
return;
}
@ -64,18 +64,18 @@ int thread_wakeup(int pid)
DEBUG("thread_wakeup: Trying to wakeup PID %i...\n", pid);
int isr = inISR();
if(! isr) {
if (!isr) {
DEBUG("thread_wakeup: Not in interrupt.\n");
dINT();
}
int result = sched_threads[pid]->status;
if(result == STATUS_SLEEPING) {
if (result == STATUS_SLEEPING) {
DEBUG("thread_wakeup: Thread is sleeping.\n");
sched_set_status((tcb_t *)sched_threads[pid], STATUS_RUNNING);
if(!isr) {
if (!isr) {
eINT();
thread_yield();
}
@ -88,7 +88,7 @@ int thread_wakeup(int pid)
else {
DEBUG("thread_wakeup: Thread is not sleeping!\n");
if(!isr) {
if (!isr) {
eINT();
}
@ -101,7 +101,7 @@ int thread_measure_stack_usage(char *stack)
unsigned int *stackp = (unsigned int *)stack;
/* assumption that the comparison fails before or after end of stack */
while(*stackp == (unsigned int)stackp) {
while (*stackp == (unsigned int)stackp) {
stackp++;
}
@ -118,28 +118,28 @@ int thread_create(char *stack, int stacksize, char priority, int flags, void (*f
/* align tcb address on 32bit boundary */
unsigned int tcb_address = (unsigned int) stack + stacksize;
if(tcb_address & 1) {
if (tcb_address & 1) {
tcb_address--;
stacksize--;
}
if(tcb_address & 2) {
if (tcb_address & 2) {
tcb_address -= 2;
stacksize -= 2;
}
tcb_t *cb = (tcb_t *) tcb_address;
if(priority >= SCHED_PRIO_LEVELS) {
if (priority >= SCHED_PRIO_LEVELS) {
return -EINVAL;
}
if(flags & CREATE_STACKTEST) {
if (flags & CREATE_STACKTEST) {
/* assign each int of the stack the value of it's address */
unsigned int *stackmax = (unsigned int *)((char *)stack + stacksize);
unsigned int *stackp = (unsigned int *)stack;
while(stackp < stackmax) {
while (stackp < stackmax) {
*stackp = (unsigned int)stackp;
stackp++;
}
@ -149,14 +149,14 @@ int thread_create(char *stack, int stacksize, char priority, int flags, void (*f
*stack = (unsigned int)stack;
}
if(! inISR()) {
if (!inISR()) {
dINT();
}
int pid = 0;
while(pid < MAXTHREADS) {
if(sched_threads[pid] == NULL) {
while (pid < MAXTHREADS) {
if (sched_threads[pid] == NULL) {
sched_threads[pid] = cb;
cb->pid = pid;
break;
@ -165,10 +165,10 @@ int thread_create(char *stack, int stacksize, char priority, int flags, void (*f
pid++;
}
if(pid == MAXTHREADS) {
if (pid == MAXTHREADS) {
DEBUG("thread_create(): too many threads!\n");
if(! inISR()) {
if (!inISR()) {
eINT();
}
@ -201,14 +201,14 @@ int thread_create(char *stack, int stacksize, char priority, int flags, void (*f
DEBUG("Created thread %s. PID: %u. Priority: %u.\n", name, cb->pid, priority);
if(flags & CREATE_SLEEPING) {
if (flags & CREATE_SLEEPING) {
sched_set_status(cb, STATUS_SLEEPING);
}
else {
sched_set_status(cb, STATUS_PENDING);
if(!(flags & CREATE_WOUT_YIELD)) {
if(! inISR()) {
if (!(flags & CREATE_WOUT_YIELD)) {
if (!inISR()) {
eINT();
thread_yield();
}
@ -218,7 +218,7 @@ int thread_create(char *stack, int stacksize, char priority, int flags, void (*f
}
}
if(!inISR() && active_thread != NULL) {
if (!inISR() && active_thread != NULL) {
eINT();
}

6
cpu/arm_common/arm_cpu.c
View File

@ -55,7 +55,7 @@ char *thread_stack_init(void *task_func, void *stack_start, int stack_size)
*stk = (unsigned int)(stack_start + stack_size) - 4;
/* build base stack */
for(int i = REGISTER_CNT; i >= 0 ; i--) {
for (int i = REGISTER_CNT; i >= 0 ; i--) {
stk--;
*stk = i;
}
@ -80,7 +80,7 @@ void thread_print_stack(void)
register int i = 0;
s += 5;
while(*s != STACK_MARKER) {
while (*s != STACK_MARKER) {
printf("STACK (%u) addr=%X = %X \n", i, (unsigned int) s, (unsigned int) *s);
s++;
i++;
@ -97,5 +97,5 @@ __attribute__((naked, noreturn)) void arm_reset(void)
WDFEED = 0xAA;
WDFEED = 0x55;
while(1);
while (1);
}

22
cpu/arm_common/bootloader.c
View File

@ -49,35 +49,35 @@ and the mailinglist (subscription via web site)
#include <thread.h>
void FIQ_Routine(void) __attribute__((interrupt("FIQ")));
//void SWI_Routine (void) __attribute__ ((interrupt("SWI")));
//void SWI_Routine (void) __attribute__((interrupt("SWI")));
void UNDEF_Routine(void) __attribute__((interrupt("UNDEF")));
void IRQ_Routine(void)
{
printf("Kernel Panic,\nEarly IRQ call\n");
while(1) {};
while (1) {};
}
/*-----------------------------------------------------------------------------------*/
void FIQ_Routine(void)
{
printf("Kernel Panic,\nEarly FIQ call\n");
while(1) {};
while (1) {};
}
/*-----------------------------------------------------------------------------------*/
void SWI_Routine(void)
{
printf("Kernel Panic,\nEarly SWI call\n");
while(1) {};
while (1) {};
}
/*-----------------------------------------------------------------------------------*/
void DEBUG_Routine(void)
{
printf("DEBUG hit.");
while(1) {};
while (1) {};
}
/*-----------------------------------------------------------------------------------*/
volatile int arm_abortflag = 0;
@ -95,7 +95,7 @@ void abtorigin(const char *vector, u_long *lnk_ptr1)
__asm__ __volatile__("mov %0, sp" : "=r"(sp)); // copy sp
__asm__ __volatile__("msr cpsr_c, %0" :: "r"(cpsr)); // switch back to abt mode
printf("#! %s abort at %p (0x%08lX) originating from %p (0x%08lX) in mode 0x%X\n",
printf("#!%s abort at %p (0x%08lX) originating from %p (0x%08lX) in mode 0x%X\n",
vector, (void *)lnk_ptr1, *(lnk_ptr1), (void *)lnk_ptr2, *(lnk_ptr2), spsr
);
stdio_flush();
@ -108,7 +108,7 @@ void UNDEF_Routine(void)
register u_long *lnk_ptr;
__asm__ __volatile__("sub %0, lr, #8" : "=r"(lnk_ptr)); // get aborting instruction
if(arm_abortflag == 0) {
if (arm_abortflag == 0) {
arm_abortflag = 1; // remember state (if printing should fail again)
abtorigin("undef", lnk_ptr);
}
@ -121,7 +121,7 @@ void PABT_Routine(void)
register u_long *lnk_ptr;
__asm__ __volatile__("sub %0, lr, #8" : "=r"(lnk_ptr)); // get aborting instruction
if(arm_abortflag == 0) {
if (arm_abortflag == 0) {
arm_abortflag = 1; // remember state (if printing should fail again)
abtorigin("pabt", lnk_ptr);
}
@ -134,7 +134,7 @@ void DABT_Routine(void)
register u_long *lnk_ptr;
__asm__ __volatile__("sub %0, lr, #8" : "=r"(lnk_ptr)); // get aborting instruction
if(arm_abortflag == 0) {
if (arm_abortflag == 0) {
arm_abortflag = 1; // remember state (if printing should fail again)
abtorigin("data", lnk_ptr);
}
@ -161,7 +161,7 @@ bl_init_data(void)
p2 = &_data;
p3 = &_edata;
while(p2 < p3) {
while (p2 < p3) {
*p2++ = *p1++;
}
@ -170,7 +170,7 @@ bl_init_data(void)
p1 = &__bss_start;
p2 = &__bss_end;
while(p1 < p2) {
while (p1 < p2) {
*p1++ = 0;
}
}

14
cpu/arm_common/hwtimer_cpu.c
View File

@ -35,37 +35,37 @@ static void timer_irq(void)
{
short timer = 0;
if(T0IR) {
if (T0IR) {
timer = 0;
}
else if(T1IR) {
else if (T1IR) {
timer = 4;
}
else if(T2IR) {
else if (T2IR) {
timer = 8;
}
volatile unsigned long base = get_base_address(timer);
if(*VULP(base + TXIR) & BIT0) {
if (*VULP(base + TXIR) & BIT0) {
*VULP(base + TXMCR) &= ~BIT0;
*VULP(base + TXIR) = BIT0;
int_handler(timer);
}
if(*VULP(base + TXIR) & BIT1) {
if (*VULP(base + TXIR) & BIT1) {
*VULP(base + TXMCR) &= ~BIT3;
*VULP(base + TXIR) = BIT1;
int_handler(timer + 1);
}
if(*VULP(base + TXIR) & BIT2) {
if (*VULP(base + TXIR) & BIT2) {
*VULP(base + TXMCR) &= ~BIT6;
*VULP(base + TXIR) = BIT2;
int_handler(timer + 2);
}
if(*VULP(base + TXIR) & BIT3) {
if (*VULP(base + TXIR) & BIT3) {
*VULP(base + TXMCR) &= ~BIT9;
*VULP(base + TXIR) = BIT3;
int_handler(timer + 3);

20
cpu/arm_common/iap.c
View File

@ -39,20 +39,20 @@ uint8_t flashrom_write(uint8_t *dst, char *src, size_t size)
sec = iap_get_sector((uint32_t) dst);
if(sec == INVALID_ADDRESS) {
if (sec == INVALID_ADDRESS) {
DEBUG("Invalid address\n");
return 0;
}
/* check sector */
if(blank_check_sector(sec, sec) == SECTOR_NOT_BLANK) {
if (blank_check_sector(sec, sec) == SECTOR_NOT_BLANK) {
DEBUG("Warning: Sector %i not blank\n", sec);
}
/* prepare sector */
err = prepare_sectors(sec, sec);
if(err) {
if (err) {
DEBUG("\n-- ERROR: PREPARE_SECTOR_FOR_WRITE_OPERATION: %u\n", err);
return 0;
}
@ -62,7 +62,7 @@ uint8_t flashrom_write(uint8_t *dst, char *src, size_t size)
err = copy_ram_to_flash((uint32_t) dst, (uint32_t) src, 256);
restoreIRQ(intstate);
if(err) {
if (err) {
DEBUG("ERROR: COPY_RAM_TO_FLASH: %u\n", err);
/* set interrupts back and return */
restoreIRQ(intstate);
@ -72,7 +72,7 @@ uint8_t flashrom_write(uint8_t *dst, char *src, size_t size)
else {
err = compare((uint32_t) dst, (uint32_t) src, 256);
if(err) {
if (err) {
DEBUG("ERROR: COMPARE: %i (at position %u)\n", err, iap_result[1]);
return 0;
}
@ -90,19 +90,19 @@ uint8_t flashrom_erase(uint8_t *addr)
uint8_t sec = iap_get_sector((uint32_t) addr);
unsigned intstate;
if(sec == INVALID_ADDRESS) {
if (sec == INVALID_ADDRESS) {
DEBUG("Invalid address\n");
return 0;
}
/* check sector */
if(!blank_check_sector(sec, sec)) {
if (!blank_check_sector(sec, sec)) {
DEBUG("Sector already blank!\n");
return 1;
}
/* prepare sector */
if(prepare_sectors(sec, sec)) {
if (prepare_sectors(sec, sec)) {
DEBUG("-- ERROR: PREPARE_SECTOR_FOR_WRITE_OPERATION --\n");
return 0;
}
@ -110,7 +110,7 @@ uint8_t flashrom_erase(uint8_t *addr)
intstate = disableIRQ();
/* erase sector */
if(erase_sectors(sec, sec)) {
if (erase_sectors(sec, sec)) {
DEBUG("-- ERROR: ERASE SECTOR --\n");
restoreIRQ(intstate);
return 0;
@ -119,7 +119,7 @@ uint8_t flashrom_erase(uint8_t *addr)
restoreIRQ(intstate);
/* check again */
if(blank_check_sector(sec, sec)) {
if (blank_check_sector(sec, sec)) {
DEBUG("-- ERROR: BLANK_CHECK_SECTOR\n");
return 0;
}

26
cpu/arm_common/profiling.c
View File

@ -27,14 +27,14 @@ void __attribute__((__no_instrument_function__)) profiling_init(void)
{
uint16_t i;
for(i = 0; i < MAX_TRACED_FUNCTIONS; i++) {
for (i = 0; i < MAX_TRACED_FUNCTIONS; i++) {
functions[i].address = 0;
functions[i].time = 0;
functions[i].consumption = 0;
functions[i].counter = 0;
}
for(i = 0; i < PROFILING_STACK_SIZE; i++) {
for (i = 0; i < PROFILING_STACK_SIZE; i++) {
profiling_stack[i] = 0;
}
@ -47,8 +47,8 @@ static int16_t __attribute__((__no_instrument_function__)) get_function_index(ui
{
uint16_t i;
for(i = 0; i < MAX_TRACED_FUNCTIONS; i++) {
if(functions[i].address == addr) {
for (i = 0; i < MAX_TRACED_FUNCTIONS; i++) {
if (functions[i].address == addr) {
return i;
}
}
@ -58,24 +58,24 @@ static int16_t __attribute__((__no_instrument_function__)) get_function_index(ui
void __attribute__((__no_instrument_function__)) __cyg_profile_func_enter(void *func, void *caller)
{
if(!profiling) {
if (!profiling) {
return;
}
int16_t idx = get_function_index((uint32_t) func);
/* if function is not yet on traced */
if((idx < 0) && (traced_functions < MAX_TRACED_FUNCTIONS)) {
if ((idx < 0) && (traced_functions < MAX_TRACED_FUNCTIONS)) {
idx = traced_functions++;
functions[idx].address = (uint32_t) func;
}
/* maximu of traceable functions reached */
else if(idx < 0) {
else if (idx < 0) {
return;
}
/* check if a profiled function is pending */
if(function_pending && (profiling_stack[profiling_sp] != idx)) {
if (function_pending && (profiling_stack[profiling_sp] != idx)) {
functions[idx].time += T0TC - functions[idx].start_time;
//functions[idx].consumption += ltc4150_get_intcount() - functions[idx].consumption_start;
functions[idx].consumption += ltc4150_get_total_mAh() - functions[idx].consumption_start;
@ -94,13 +94,13 @@ void __attribute__((__no_instrument_function__)) __cyg_profile_func_enter(void
void __attribute__((__no_instrument_function__)) __cyg_profile_func_exit(void *func, void *caller)
{
if(!profiling) {
if (!profiling) {
return;
}
int16_t idx = get_function_index((uint32_t) func);
if(idx >= 0) {
if (idx >= 0) {
functions[idx].time += T0TC - functions[idx].start_time;
//functions[idx].consumption += ltc4150_get_intcount() - functions[idx].consumption_start;
functions[idx].consumption += ltc4150_get_total_mAh() - functions[idx].consumption_start;
@ -110,8 +110,8 @@ void __attribute__((__no_instrument_function__)) __cyg_profile_func_exit(void *f
function_pending = 0;
/* if another function is pending */
if(profiling_sp) {
if(--profiling_sp) {
if (profiling_sp) {
if (--profiling_sp) {
functions[profiling_stack[profiling_sp]].start_time = T0TC;
functions[profiling_stack[profiling_sp]].consumption_start = ltc4150_get_total_mAh();
}
@ -122,7 +122,7 @@ void profiling_stats(void)
{
uint16_t i;
for(i = 0; i < traced_functions; i++) {
for (i = 0; i < traced_functions; i++) {
// printf("Function @%04lX was running %u times for %lu ticks, consuming %li ltc-ticks\n", functions[i].address, functions[i].counter, functions[i].time, functions[i].consumption);
printf("Function @%04lX was running %u times for %lu ticks, consuming %lf mAh\n", functions[i].address, functions[i].counter, functions[i].time, functions[i].consumption);
}

22
cpu/arm_common/syscalls.c
View File

@ -88,7 +88,7 @@ volatile static uint8_t iUsedHeap = 0;
/*-----------------------------------------------------------------------------------*/
void heap_stats(void)
{
for(int i = 0; i < NUM_HEAPS; i++)
for (int i = 0; i < NUM_HEAPS; i++)
printf("# heap %i: %p -- %p -> %p (%li of %li free)\n", i, heap_start[i], heap[i], heap_max[i],
(uint32_t)heap_max[i] - (uint32_t)heap[i], (uint32_t)heap_max[i] - (uint32_t)heap_start[i]);
}
@ -100,7 +100,7 @@ void __assert_func(const char *file, int line, const char *func, const char *fai
trace_number(TRACELOG_EV_ASSERTION, line);
syslog(SL_EMERGENCY, "assert", "%s() in %s:%u\n", func, file, line);
#endif
printf("#! assertion %s failed\n\t%s() in %s:%u\n", failedexpr, func, file, line);
printf("#!assertion %s failed\n\t%s() in %s:%u\n", failedexpr, func, file, line);
_exit(3);
}
/*-----------------------------------------------------------------------------------*/
@ -111,7 +111,7 @@ void __assert(const char *file, int line, const char *failedexpr)
/*-----------------------------------------------------------------------------------*/
caddr_t _sbrk_r(struct _reent *r, size_t incr)
{
if(incr < 0) {
if (incr < 0) {
puts("[syscalls] Negative Values for _sbrk_r are not supported");
r->_errno = ENOMEM;
return NULL;
@ -120,14 +120,14 @@ caddr_t _sbrk_r(struct _reent *r, size_t incr)
uint32_t cpsr = disableIRQ();
/* check all heaps for a chunk of the requested size */
for(; iUsedHeap < NUM_HEAPS; iUsedHeap++) {
for (; iUsedHeap < NUM_HEAPS; iUsedHeap++) {
caddr_t new_heap = heap[iUsedHeap] + incr;
#ifdef MODULE_TRACELOG
trace_pointer(TRACELOG_EV_MEMORY, heap[iUsedHeap]);
#endif
if(new_heap <= heap_max[iUsedHeap]) {
if (new_heap <= heap_max[iUsedHeap]) {
caddr_t prev_heap = heap[iUsedHeap];
#ifdef MODULE_TRACELOG
trace_pointer(TRACELOG_EV_MEMORY, new_heap);
@ -153,7 +153,7 @@ int _isatty_r(struct _reent *r, int fd)
{
r->_errno = 0;
if(fd == STDOUT_FILENO || fd == STDERR_FILENO) {
if (fd == STDOUT_FILENO || fd == STDERR_FILENO) {
return 1;
}
else {
@ -208,7 +208,7 @@ int _fstat_r(struct _reent *r, int fd, struct stat *st)
r->_errno = 0;
memset(st, 0, sizeof(*st));
if(fd == STDOUT_FILENO || fd == STDERR_FILENO) {
if (fd == STDOUT_FILENO || fd == STDERR_FILENO) {
st->st_mode = S_IFCHR;
ret = 0;
}
@ -237,10 +237,10 @@ int _write_r(struct _reent *r, int fd, const void *data, unsigned int count)
case STDOUT_FILENO:
case STDERR_FILENO:
#if FEUERWARE_CONF_ENABLE_HAL
if(stdio != NULL) {
if (stdio != NULL) {
result = chardevice_write(stdio, (char *)data, count);
}
else if(hal_state == HAL_NOT_INITIALIZED) {
else if (hal_state == HAL_NOT_INITIALIZED) {
result = fw_puts((char *)data, count);
}
@ -306,12 +306,12 @@ void _exit(int n)
#ifdef MODULE_TRACELOG
trace_number(TRACELOG_EV_EXIT, n);
#endif
printf("#! exit %i: resetting\n", n);
printf("#!exit %i: resetting\n", n);
stdio_flush();
arm_reset();
while(1);
while (1);
}
/*---------------------------------------------------------------------------*/
int _getpid(void)

36
cpu/cc430/cc110x_cc430.c
View File

@ -17,27 +17,27 @@ uint8_t cc110x_strobe(uint8_t c)
uint16_t int_state, gdo_state;
/* Check for valid strobe command */
if((c == 0xBD) || ((c > RF_SRES) && (c < RF_SNOP))) {
if ((c == 0xBD) || ((c > RF_SRES) && (c < RF_SNOP))) {
int_state = disableIRQ();
/* Clear the Status read flag */
RF1AIFCTL1 &= ~(RFSTATIFG);
/* Wait for radio to be ready for next instruction */
while(!(RF1AIFCTL1 & RFINSTRIFG));
while (!(RF1AIFCTL1 & RFINSTRIFG));
/* Write the strobe instruction */
if((c > RF_SRES) && (c < RF_SNOP)) {
if ((c > RF_SRES) && (c < RF_SNOP)) {
gdo_state = cc110x_read_reg(IOCFG2); /* buffer IOCFG2 state */
cc110x_write_reg(IOCFG2, 0x29); /* c-ready to GDO2 */
RF1AINSTRB = c;
if((RF1AIN & 0x04) == 0x04) { /* chip at sleep mode */
if((c == RF_SXOFF) || (c == RF_SPWD) || (c == RF_SWOR)) { }
if ((RF1AIN & 0x04) == 0x04) { /* chip at sleep mode */
if ((c == RF_SXOFF) || (c == RF_SPWD) || (c == RF_SWOR)) { }
else {
while((RF1AIN & 0x04) == 0x04); /* c-ready ? */
while ((RF1AIN & 0x04) == 0x04); /* c-ready ? */
hwtimer_wait(RTIMER_TICKS(9800)); /* Delay for ~810usec at 12MHz CPU clock */
}
@ -51,7 +51,7 @@ uint8_t cc110x_strobe(uint8_t c)
statusByte = RF1ASTATB;
while(!(RF1AIFCTL1 & RFSTATIFG));
while (!(RF1AIFCTL1 & RFSTATIFG));
restoreIRQ(int_state);
}
@ -94,11 +94,11 @@ void cc110x_write_reg(uint8_t addr, uint8_t value)
int_state = disableIRQ();
while(!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for the next instruction */
while (!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for the next instruction */
RF1AINSTRW = ((addr | RF_REGWR) << 8) + value; /* Send address + Instruction */
while(!(RFDINIFG & RF1AIFCTL1));
while (!(RFDINIFG & RF1AIFCTL1));
i = RF1ADOUTB; /* Reset RFDOUTIFG flag which contains status byte */
@ -132,12 +132,12 @@ void cc110x_readburst_reg(uint8_t addr, char *buffer, uint8_t count)
int_state = disableIRQ();
while(!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for next instruction */
while (!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for next instruction */
RF1AINSTR1B = (addr | RF_REGRD); /* Send address + Instruction */
for(i = 0; i < (count - 1); i++) {
while(!(RFDOUTIFG & RF1AIFCTL1)); /* Wait for the Radio Core to update the RF1ADOUTB reg */
for (i = 0; i < (count - 1); i++) {
while (!(RFDOUTIFG & RF1AIFCTL1)); /* Wait for the Radio Core to update the RF1ADOUTB reg */
buffer[i] = RF1ADOUT1B; /* Read DOUT from Radio Core + clears RFDOUTIFG */
/* Also initiates auo-read for next DOUT byte */
@ -155,12 +155,12 @@ void cc110x_read_fifo(char *buffer, uint8_t count)
int_state = disableIRQ();
while(!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for next instruction */
while (!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for next instruction */
RF1AINSTR1B = (RF_RXFIFORD); /* Send address + Instruction */
for(i = 0; i < (count - 1); i++) {
while(!(RFDOUTIFG & RF1AIFCTL1)); /* Wait for the Radio Core to update the RF1ADOUTB reg */
for (i = 0; i < (count - 1); i++) {
while (!(RFDOUTIFG & RF1AIFCTL1)); /* Wait for the Radio Core to update the RF1ADOUTB reg */
buffer[i] = RF1ADOUT1B; /* Read DOUT from Radio Core + clears RFDOUTIFG */
/* Also initiates auo-read for next DOUT byte */
@ -184,14 +184,14 @@ uint8_t cc110x_writeburst_reg(uint8_t addr, char *buffer, uint8_t count)
int_state = disableIRQ();
while(!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for next instruction */
while (!(RF1AIFCTL1 & RFINSTRIFG)); /* Wait for the Radio to be ready for next instruction */
RF1AINSTRW = ((addr | RF_REGWR) << 8) + buffer[0]; /* Send address + Instruction */
for(i = 1; i < count; i++) {
for (i = 1; i < count; i++) {
RF1ADINB = buffer[i]; /* Send data */
while(!(RFDINIFG & RF1AIFCTL1)); /* Wait for TX to finish */
while (!(RFDINIFG & RF1AIFCTL1)); /* Wait for TX to finish */
}
i = RF1ADOUTB; /* Reset RFDOUTIFG flag which contains status byte */

2
cpu/cc430/cc430-adc.c
View File

@ -77,7 +77,7 @@ uint16_t adc12_single_conversion(uint16_t ref, uint16_t sht, uint16_t channel)
/* Wait until ADC12 has finished */
hwtimer_wait(5);
while(!adc12_data_ready);
while (!adc12_data_ready);
/* Shut down ADC12 */
ADC12CTL0 &= ~(ADC12ENC | ADC12SC | sht);

36
cpu/cc430/cc430-gpioint.c
View File

@ -55,8 +55,8 @@ void gpioint_init(void)
{
uint8_t i, j;
for(i = 0; i < INT_PORTS; i++) {
for(j = 0; j < BITMASK_SIZE; j++) {
for (i = 0; i < INT_PORTS; i++) {
for (j = 0; j < BITMASK_SIZE; j++) {
cb[i][j] = NULL;
debounce_time[i][j] = 0;
}
@ -67,18 +67,18 @@ bool gpioint_set(int port, uint32_t bitmask, int flags, fp_irqcb callback)
{
int8_t base;
if((port >= PORTINT_MIN) && (port <= PORTINT_MAX)) {
if ((port >= PORTINT_MIN) && (port <= PORTINT_MAX)) {
/* set the callback function */
base = number_of_highest_bit(bitmask);
if(base >= 0) {
if (base >= 0) {
cb[port - PORTINT_MIN][base] = callback;
}
else {
return false;
}
if(flags & GPIOINT_DEBOUNCE) {
if (flags & GPIOINT_DEBOUNCE) {
debounce_flags[port - PORTINT_MIN] |= bitmask;
}
else {
@ -98,17 +98,17 @@ bool gpioint_set(int port, uint32_t bitmask, int flags, fp_irqcb callback)
P1IFG &= ~bitmask;
/* trigger on rising... */
if(flags & GPIOINT_RISING_EDGE) {
if (flags & GPIOINT_RISING_EDGE) {
P1IES &= bitmask;
}
/* ...or falling edge */
if(flags & GPIOINT_FALLING_EDGE) {
if (flags & GPIOINT_FALLING_EDGE) {
P1IES |= bitmask;
}
/* disable interrupt */
if(flags == GPIOINT_DISABLE) {
if (flags == GPIOINT_DISABLE) {
P1IE &= ~bitmask;
}
@ -127,11 +127,11 @@ bool gpioint_set(int port, uint32_t bitmask, int flags, fp_irqcb callback)
P2IFG &= ~bitmask;
/* trigger on rising... */
if(flags == GPIOINT_RISING_EDGE) {
if (flags == GPIOINT_RISING_EDGE) {
P2IES &= bitmask;
}
/* ...or falling edge */
else if(flags == GPIOINT_FALLING_EDGE) {
else if (flags == GPIOINT_FALLING_EDGE) {
P2IES |= bitmask;
}
/* or disable interrupt */
@ -168,14 +168,14 @@ interrupt(PORT1_VECTOR) __attribute__((naked)) port1_isr(void)
ifg_num = (p1iv >> 1) - 1;
/* check interrupt source */
if(debounce_flags[0] & p1ifg) {
if (debounce_flags[0] & p1ifg) {
/* check if bouncing */
diff = hwtimer_now() - debounce_time[0][ifg_num];
if(diff > DEBOUNCE_TIMEOUT) {
if (diff > DEBOUNCE_TIMEOUT) {
debounce_time[0][ifg_num] = hwtimer_now();
if(cb[0][ifg_num] != NULL) {
if (cb[0][ifg_num] != NULL) {
cb[0][ifg_num]();
}
}
@ -185,7 +185,7 @@ interrupt(PORT1_VECTOR) __attribute__((naked)) port1_isr(void)
}
}
else {
if(cb[0][ifg_num] != NULL) {
if (cb[0][ifg_num] != NULL) {
cb[0][ifg_num]();
}
}
@ -213,15 +213,15 @@ interrupt(PORT2_VECTOR) __attribute__((naked)) port2_isr(void)
ifg_num = (p2iv >> 1) - 1;
/* check interrupt source */
if(debounce_flags[1] & p2ifg) {
if (debounce_flags[1] & p2ifg) {
/* check if bouncing */
diff = hwtimer_now() - debounce_time[1][ifg_num];
if(diff > DEBOUNCE_TIMEOUT) {
if (diff > DEBOUNCE_TIMEOUT) {
debounce_time[1][ifg_num] = hwtimer_now();
c1++;
if(cb[1][ifg_num] != NULL) {
if (cb[1][ifg_num] != NULL) {
cb[1][ifg_num]();
}
}
@ -232,7 +232,7 @@ interrupt(PORT2_VECTOR) __attribute__((naked)) port2_isr(void)
}
}
else {
if(cb[1][ifg_num] != NULL) {
if (cb[1][ifg_num] != NULL) {
cb[1][ifg_num]();
}
}

26
cpu/cc430/cc430-rtc.c
View File

@ -57,7 +57,7 @@ void rtc_disable(void)
/*---------------------------------------------------------------------------*/
void rtc_set_localtime(struct tm *localt)
{
if(localt == NULL) {
if (localt == NULL) {
return;
}
@ -91,14 +91,14 @@ void rtc_get_localtime(struct tm *localt)
uint8_t i;
uint16_t tmpyear;
if(localt == NULL) {
if (localt == NULL) {
return;
}
while(!success) {
for(i = 0; i < 8; i++) {
while (!success) {
for (i = 0; i < 8; i++) {
/* try again when RTC is in transition */
if(!(RTCCTL1 & RTCRDY_H)) {
if (!(RTCCTL1 & RTCRDY_H)) {
break;
}
@ -144,22 +144,22 @@ void rtc_get_localtime(struct tm *localt)
/*---------------------------------------------------------------------------*/
void rtc_set_alarm(struct tm *localt, rtc_alarm_mask_t mask)
{
if(mask & RTC_ALARM_MIN) {
if (mask & RTC_ALARM_MIN) {
RTCAMIN = localt->tm_min;
RTCAMIN |= BIT7;
}
if(mask & RTC_ALARM_HOUR) {
if (mask & RTC_ALARM_HOUR) {
RTCAHOUR = localt->tm_hour;
RTCAHOUR |= BIT7;
}
if(mask & RTC_ALARM_DOW) {
if (mask & RTC_ALARM_DOW) {
RTCADOW = localt->tm_wday;
RTCADOW |= BIT7;
}
if(mask & RTC_ALARM_DOM) {
if (mask & RTC_ALARM_DOM) {
RTCADAY = localt->tm_mday;
RTCADAY |= BIT7;
}
@ -185,11 +185,11 @@ interrupt(RTC_VECTOR) __attribute__((naked)) rtc_isr(void)
__enter_isr();
/* RTC is save to write for up to one second now */
if(RTCIV == RTC_RTCRDYIFG) {
if (RTCIV == RTC_RTCRDYIFG) {
/* disable interrupt */
//RTCCTL0 &= ~RTCRDYIE;
if(set_time) {
if (set_time) {
set_time = 0;
/* set previous set time and reset it */
RTCSEC = time_to_set.tm_sec;
@ -202,14 +202,14 @@ interrupt(RTC_VECTOR) __attribute__((naked)) rtc_isr(void)
RTCYEARH = (time_to_set.tm_year + 1900) >> 0x08;
}
if(rtc_second_pid) {
if (rtc_second_pid) {
msg_t m;
m.type = RTC_SECOND;
msg_send_int(&m, rtc_second_pid);
}
}
/* RTC alarm */
else if(RTCIV == RTC_RTCAIFG) {
else if (RTCIV == RTC_RTCAIFG) {
}
__exit_isr();

4
cpu/cc430/hwtimer_cc430.c
View File

@ -21,7 +21,7 @@ void timerA_init(void)
volatile unsigned int *ccr = &TA0CCR0;
volatile unsigned int *ctl = &TA0CCTL0;
for(int i = 0; i < ARCH_MAXTIMERS; i++) {
for (int i = 0; i < ARCH_MAXTIMERS; i++) {
*(ccr + i) = 0;
*(ctl + i) &= ~(CCIFG);
*(ctl + i) &= ~(CCIE);
@ -46,7 +46,7 @@ interrupt(TIMER0_A1_VECTOR) __attribute__((naked)) timer0_a1_5_isr(void)
short taiv = TA0IV;
short timer;
if(taiv & TAIFG) {
if (taiv & TAIFG) {
DEBUG("Overflow\n");
}
else {

2
cpu/lpc214x/cpu.c
View File

@ -25,7 +25,7 @@ bool cpu_install_irq(int IntNumber, void *HandlerAddr, int Priority)
VICIntEnClear = 1 << IntNumber; /* Disable Interrupt */
if(IntNumber >= VIC_SIZE) {
if (IntNumber >= VIC_SIZE) {
return (false);
}
else {

10
cpu/lpc2387/cpu.c
View File

@ -24,15 +24,15 @@ void lpc2387_pclk_scale(uint32_t source, uint32_t target, uint32_t *pclksel, uin
uint32_t pclkdiv;
*prescale = source / target;
if((*prescale % 16) == 0) {
if ((*prescale % 16) == 0) {
*pclksel = 3;
pclkdiv = 8;
}
else if((*prescale % 8) == 0) {
else if ((*prescale % 8) == 0) {
*pclksel = 0;
pclkdiv = 4;
}
else if((*prescale % 4) == 0) {
else if ((*prescale % 4) == 0) {
*pclksel = 2;
pclkdiv = 2;
}
@ -43,7 +43,7 @@ void lpc2387_pclk_scale(uint32_t source, uint32_t target, uint32_t *pclksel, uin
*prescale /= pclkdiv;
if(*prescale % 2) {
if (*prescale % 2) {
(*prescale)++;
}
}
@ -77,7 +77,7 @@ bool install_irq(int IntNumber, void *HandlerAddr, int Priority)
VICIntEnClr = 1 << IntNumber; /* Disable Interrupt */
if(IntNumber >= VIC_SIZE) {
if (IntNumber >= VIC_SIZE) {
return (false);
}
else {

16
cpu/lpc2387/gpioint/lpc2387-gpioint.c
View File

@ -87,21 +87,21 @@ gpioint_set(int port, uint32_t bitmask, int flags, fp_irqcb callback)
unsigned long cpsr = disableIRQ();
*en_clr |= bitmask; /* clear interrupt */
if((flags & GPIOINT_FALLING_EDGE) != 0) {
if ((flags & GPIOINT_FALLING_EDGE) != 0) {
*en_f |= bitmask; /* enable falling edge */
}
else {
*en_f &= ~bitmask; /* disable falling edge */
}
if((flags & GPIOINT_RISING_EDGE) != 0) {
if ((flags & GPIOINT_RISING_EDGE) != 0) {
*en_r |= bitmask; /* enable rising edge */
}
else {
*en_r &= ~bitmask; /* disable rising edge */
}
if(((flags & (GPIOINT_FALLING_EDGE | GPIOINT_RISING_EDGE)) != 0)) {
if (((flags & (GPIOINT_FALLING_EDGE | GPIOINT_RISING_EDGE)) != 0)) {
cbdata[bit].callback = callback;
}
@ -119,8 +119,8 @@ static void __attribute__((__no_instrument_function__)) test_irq(int port, unsig
/* Test each bit of rising and falling masks, if set trigger interrupt
* on corresponding device */
do {
if((pcb->callback != NULL)) {
if((r_mask & 1) | (f_mask & 1)) {
if ((pcb->callback != NULL)) {
if ((r_mask & 1) | (f_mask & 1)) {
pcb->callback(); /* pass to handler */
}
}
@ -129,7 +129,7 @@ static void __attribute__((__no_instrument_function__)) test_irq(int port, unsig
r_mask >>= 1UL;
pcb++;
}
while((f_mask != 0) || (r_mask != 0));
while ((f_mask != 0) || (r_mask != 0));
}
/*---------------------------------------------------------------------------*/
void GPIO_IRQHandler(void) __attribute__((interrupt("IRQ")));
@ -142,7 +142,7 @@ void GPIO_IRQHandler(void) __attribute__((interrupt("IRQ")));
*/
void __attribute__((__no_instrument_function__)) GPIO_IRQHandler(void)
{
if(IO_INT_STAT & BIT0) { /* interrupt(s) on PORT0 pending */
if (IO_INT_STAT & BIT0) { /* interrupt(s) on PORT0 pending */
unsigned long int_stat_f = IO0_INT_STAT_F; /* save content */
unsigned long int_stat_r = IO0_INT_STAT_R; /* save content */
@ -152,7 +152,7 @@ void __attribute__((__no_instrument_function__)) GPIO_IRQHandler(void)
test_irq(0, int_stat_f, int_stat_r, gpioint0);
}
if(IO_INT_STAT & BIT2) { /* interrupt(s) on PORT2 pending */
if (IO_INT_STAT & BIT2) { /* interrupt(s) on PORT2 pending */
unsigned long int_stat_f = IO2_INT_STAT_F; /* save content */
unsigned long int_stat_r = IO2_INT_STAT_R; /* save content */

8
cpu/lpc2387/lpc2387-adc.c
View File

@ -107,7 +107,7 @@ uint16_t adc_read(uint8_t channel)
uint32_t regVal, adc_data;
/* channel number is 0 through 7 */
if(channel >= ADC_NUM) {
if (channel >= ADC_NUM) {
channel = 0; /* reset channel number to 0 */
}
@ -122,19 +122,19 @@ uint16_t adc_read(uint8_t channel)
t2 = hwtimer_now();
#endif
while(1) {
while (1) {
/* read result of A/D conversion */
regVal = *(volatile unsigned long *)(AD0_BASE_ADDR + ADC_OFFSET + ADC_INDEX * channel);
/* wait until end of A/D convert */
if(regVal & ADC_DONE) {
if (regVal & ADC_DONE) {
break;
}
}
AD0CR &= 0xF8FFFFFF; /* stop ADC now */
if(regVal & ADC_OVERRUN) { /* save data when it's not overrun, otherwise, return zero */
if (regVal & ADC_OVERRUN) { /* save data when it's not overrun, otherwise, return zero */
return 0;
}

12
cpu/lpc2387/lpc2387-lpm.c
View File

@ -53,14 +53,14 @@ void lpm_init(void)
void lpm_begin_awake(void)
{
if(lpm >= LPM_SLEEP) { // wake up from deep sleep
if (lpm >= LPM_SLEEP) { // wake up from deep sleep
init_clks1();
}
}
void lpm_end_awake(void)
{
if(lpm >= LPM_SLEEP) { // wake up from deep sleep
if (lpm >= LPM_SLEEP) { // wake up from deep sleep
init_clks2();
}
@ -73,7 +73,7 @@ void lpm_awake(void)
unsigned long usec = RTC_CTC;
#endif
if(lpm >= LPM_SLEEP) { // wake up from deep sleep
if (lpm >= LPM_SLEEP) { // wake up from deep sleep
/* benchmark */
init_clks1();
init_clks2();
@ -93,13 +93,13 @@ enum lpm_mode lpm_set(enum lpm_mode target)
enum lpm_mode last_lpm = lpm;
/* calculate target mcu power mode */
if(target == LPM_IDLE) {
if (target == LPM_IDLE) {
target_flags = PM_IDLE;
}
else if(target == LPM_SLEEP) {
else if (target == LPM_SLEEP) {
target_flags = PM_SLEEP;
}
else if(target == LPM_POWERDOWN) {
else if (target == LPM_POWERDOWN) {
target_flags = PM_POWERDOWN;
}
else {

56
cpu/lpc2387/lpc23xx-iap.c
View File

@ -4,115 +4,115 @@
uint8_t iap_get_sector(uint32_t addr)
{
if((addr >= 0x00000000) && (addr <= 0x00000FFF)) {
if ((addr >= 0x00000000) && (addr <= 0x00000FFF)) {
return 0;
}
if((addr >= 0x00001000) && (addr <= 0x00001FFF)) {
if ((addr >= 0x00001000) && (addr <= 0x00001FFF)) {
return 1;
}
if((addr >= 0x00002000) && (addr <= 0x00002FFF)) {
if ((addr >= 0x00002000) && (addr <= 0x00002FFF)) {
return 2;
}
if((addr >= 0x00003000) && (addr <= 0x00003FFF)) {
if ((addr >= 0x00003000) && (addr <= 0x00003FFF)) {
return 3;
}
if((addr >= 0x00004000) && (addr <= 0x00004FFF)) {
if ((addr >= 0x00004000) && (addr <= 0x00004FFF)) {
return 4;
}
if((addr >= 0x00005000) && (addr <= 0x00005FFF)) {
if ((addr >= 0x00005000) && (addr <= 0x00005FFF)) {
return 5;
}
if((addr >= 0x00006000) && (addr <= 0x00006FFF)) {
if ((addr >= 0x00006000) && (addr <= 0x00006FFF)) {
return 6;
}
if((addr >= 0x00007000) && (addr <= 0x00007FFF)) {
if ((addr >= 0x00007000) && (addr <= 0x00007FFF)) {
return 7;
}
if((addr >= 0x00008000) && (addr <= 0x0000FFFF)) {
if ((addr >= 0x00008000) && (addr <= 0x0000FFFF)) {
return 8;
}
if((addr >= 0x00010000) && (addr <= 0x00017FFF)) {
if ((addr >= 0x00010000) && (addr <= 0x00017FFF)) {
return 9;
}
if((addr >= 0x00018000) && (addr <= 0x0001FFFF)) {
if ((addr >= 0x00018000) && (addr <= 0x0001FFFF)) {
return 10;
}
if((addr >= 0x00020000) && (addr <= 0x00027FFF)) {
if ((addr >= 0x00020000) && (addr <= 0x00027FFF)) {
return 11;
}
if((addr >= 0x00028000) && (addr <= 0x0002FFFF)) {
if ((addr >= 0x00028000) && (addr <= 0x0002FFFF)) {
return 12;
}
if((addr >= 0x00030000) && (addr <= 0x00037FFF)) {
if ((addr >= 0x00030000) && (addr <= 0x00037FFF)) {
return 13;
}
if((addr >= 0x00038000) && (addr <= 0x0003FFFF)) {
if ((addr >= 0x00038000) && (addr <= 0x0003FFFF)) {
return 14;
}
if((addr >= 0x00040000) && (addr <= 0x00047FFF)) {
if ((addr >= 0x00040000) && (addr <= 0x00047FFF)) {
return 15;
}
if((addr >= 0x00048000) && (addr <= 0x0004FFFF)) {
if ((addr >= 0x00048000) && (addr <= 0x0004FFFF)) {
return 16;
}
if((addr >= 0x00050000) && (addr <= 0x00057FFF)) {
if ((addr >= 0x00050000) && (addr <= 0x00057FFF)) {
return 17;
}
if((addr >= 0x00058000) && (addr <= 0x0005FFFF)) {
if ((addr >= 0x00058000) && (addr <= 0x0005FFFF)) {
return 18;
}
if((addr >= 0x00060000) && (addr <= 0x00067FFF)) {
if ((addr >= 0x00060000) && (addr <= 0x00067FFF)) {
return 19;
}
if((addr >= 0x00068000) && (addr <= 0x0006FFFF)) {
if ((addr >= 0x00068000) && (addr <= 0x0006FFFF)) {
return 20;
}
if((addr >= 0x00070000) && (addr <= 0x00077FFF)) {
if ((addr >= 0x00070000) && (addr <= 0x00077FFF)) {
return 21;
}
if((addr >= 0x00078000) && (addr <= 0x00078FFF)) {
if ((addr >= 0x00078000) && (addr <= 0x00078FFF)) {
return 22;
}
if((addr >= 0x00079000) && (addr <= 0x00079FFF)) {
if ((addr >= 0x00079000) && (addr <= 0x00079FFF)) {
return 23;
}
if((addr >= 0x0007A000) && (addr <= 0x0007AFFF)) {
if ((addr >= 0x0007A000) && (addr <= 0x0007AFFF)) {
return 24;
}
if((addr >= 0x0007B000) && (addr <= 0x0007BFFF)) {
if ((addr >= 0x0007B000) && (addr <= 0x0007BFFF)) {
return 25;
}
if((addr >= 0x0007C000) && (addr <= 0x0007CFFF)) {
if ((addr >= 0x0007C000) && (addr <= 0x0007CFFF)) {
return 26;
}
if((addr >= 0x0007D000) && (addr <= 0x0007DFFF)) {
if ((addr >= 0x0007D000) && (addr <= 0x0007DFFF)) {
return 27;
}

172
cpu/lpc2387/mci/lpc2387-mci.c
View File

@ -110,16 +110,16 @@ void Isr_MCI(void)
xs = XferStat;
if(ms & 0x400) { /* A block transfer completed (DataBlockEnd) */
if(xs & 1) { /* In card read operation */
if(ms & 0x100) { /* When last block is received (DataEnd), */
if (ms & 0x400) { /* A block transfer completed (DataBlockEnd) */
if (xs & 1) { /* In card read operation */
if (ms & 0x100) { /* When last block is received (DataEnd), */
GPDMA_SOFT_BREQ = 0x10; /* Pop off remaining data in the MCIFIFO */
}
n = (XferWp + 1) % N_BUF; /* Next write buffer */
XferWp = n;
if(n == XferRp) {
if (n == XferRp) {
xs |= 4; /* Check block overrun */
}
}
@ -127,7 +127,7 @@ void Isr_MCI(void)
n = (XferRp + 1) % N_BUF; /* Next read buffer */
XferRp = n;
if(n == XferWp) {
if (n == XferWp) {
xs |= 4; /* Check block underrun */
}
}
@ -143,12 +143,12 @@ void Isr_MCI(void)
void Isr_GPDMA(void)
{
if(GPDMA_INT_TCSTAT & BIT0) {
if (GPDMA_INT_TCSTAT & BIT0) {
GPDMA_INT_TCCLR = 0x01; /* Clear GPDMA interrupt flag */
if(XferStat & 2) {
if (XferStat & 2) {
/* In write operation */
if(--XferWc == N_BUF) { /* Terminate LLI */
if (--XferWc == N_BUF) { /* Terminate LLI */
LinkList[XferRp % N_BUF][2] = 0;
}
}
@ -180,7 +180,7 @@ static void ready_reception(unsigned int blks, unsigned int bs)
dma_ctrl = 0x88492000 | (bs / 4); /* 1_000_1_0_00_010_010_010_010_************ */
/* Create link list */
for(n = 0; n < N_BUF; n++) {
for (n = 0; n < N_BUF; n++) {
LinkList[n][0] = (unsigned long)&MCI_FIFO;
LinkList[n][1] = (unsigned long)DmaBuff[n];
LinkList[n][2] = (unsigned long)LinkList[(n + 1) % N_BUF];
@ -207,7 +207,7 @@ static void ready_reception(unsigned int blks, unsigned int bs)
MCI_CLEAR = 0x72A; /* Clear status flags */
MCI_MASK0 = 0x72A; /* DataBlockEnd StartBitErr DataEnd RxOverrun DataTimeOut DataCrcFail */
for(n = 0; bs > 1; bs >>= 1, n += 0x10);
for (n = 0; bs > 1; bs >>= 1, n += 0x10);
MCI_DATA_CTRL = n | 0xB; /* Start to receive data blocks */
}
@ -234,7 +234,7 @@ static void start_transmission(unsigned char blks)
dma_ctrl = 0x84492080; /* 1_000_0_1_00_010_010_010_010_000010000000 */
/* Create link list */
for(n = 0; n < N_BUF; n++) {
for (n = 0; n < N_BUF; n++) {
LinkList[n][0] = (unsigned long)DmaBuff[n];
LinkList[n][1] = (unsigned long)&MCI_FIFO;
LinkList[n][2] = (n == blks - 1) ? 0 : (unsigned long)LinkList[(n + 1) % N_BUF];
@ -382,8 +382,8 @@ static int send_cmd(unsigned int idx, unsigned long arg, unsigned int rt, unsign
{
unsigned int s, mc;
if(idx & 0x80) { /* Send a CMD55 prior to the specified command if it is ACMD class */
if(!send_cmd(CMD55, (unsigned long)CardRCA << 16, 1, buff) /* When CMD55 is faild, */
if (idx & 0x80) { /* Send a CMD55 prior to the specified command if it is ACMD class */
if (!send_cmd(CMD55, (unsigned long)CardRCA << 16, 1, buff) /* When CMD55 is faild, */
|| !(buff[0] & 0x00000020)) {
return 0; /* exit with error */
}
@ -395,20 +395,20 @@ static int send_cmd(unsigned int idx, unsigned long arg, unsigned int rt, unsign
MCI_COMMAND = 0; /* Cancel to transmit command */
MCI_CLEAR = 0x0C5; /* Clear status flags */
for(s = 0; s < 10; s++) {
for (s = 0; s < 10; s++) {
MCI_STATUS; /* Skip lock out time of command reg. */
}
}
while(MCI_STATUS & 0x00800);
while (MCI_STATUS & 0x00800);
MCI_ARGUMENT = arg; /* Set the argument into argument register */
mc = 0x400 | idx; /* Enable bit + index */
if(rt == 1) {
if (rt == 1) {
mc |= 0x040; /* Set Response bit to reveice short resp */
}
if(rt > 1) {
if (rt > 1) {
mc |= 0x0C0; /* Set Response and LongResp bit to receive long resp */
}
@ -417,35 +417,35 @@ static int send_cmd(unsigned int idx, unsigned long arg, unsigned int rt, unsign
//Timer[1] = 100;
uint32_t timerstart = hwtimer_now();
for(;;) { /* Wait for end of the cmd/resp transaction */
for (;;) { /* Wait for end of the cmd/resp transaction */
//if (!Timer[1]) return 0;
if(hwtimer_now() - timerstart > 10000) {
if (hwtimer_now() - timerstart > 10000) {
return 0;
}
s = MCI_STATUS; /* Get the transaction status */
if(rt == 0) {
if(s & 0x080) {
if (rt == 0) {
if (s & 0x080) {
return 1; /* CmdSent */
}
}
else {
if(s & 0x040) {
if (s & 0x040) {
break; /* CmdRespEnd */
}
if(s & 0x001) {
if (s & 0x001) {
/* CmdCrcFail */
if(idx == 1 || idx == 12 || idx == 41) { /* Ignore CRC error on CMD1/12/41 */
if (idx == 1 || idx == 12 || idx == 41) { /* Ignore CRC error on CMD1/12/41 */
break;
}
return 0;
}
if(s & 0x004) {
if (s & 0x004) {
return 0; /* CmdTimeOut */
}
}
@ -453,7 +453,7 @@ static int send_cmd(unsigned int idx, unsigned long arg, unsigned int rt, unsign
buff[0] = MCI_RESP0; /* Read the response words */
if(rt == 2) {
if (rt == 2) {
buff[1] = MCI_RESP1;
buff[2] = MCI_RESP2;
buff[3] = MCI_RESP3;
@ -480,8 +480,8 @@ static int wait_ready(unsigned short tmr)
uint32_t stoppoll = hwtimer_now() + tmr * 100;
bool bBreak = false;
while(hwtimer_now() < stoppoll/*Timer[0]*/) {
if(send_cmd(CMD13, (unsigned long) CardRCA << 16, 1, &rc) && ((rc & 0x01E00) == 0x00800)) {
while (hwtimer_now() < stoppoll/*Timer[0]*/) {
if (send_cmd(CMD13, (unsigned long) CardRCA << 16, 1, &rc) && ((rc & 0x01E00) == 0x00800)) {
bBreak = true;
break;
}
@ -529,7 +529,7 @@ DSTATUS MCI_initialize(void)
unsigned long resp[4];
unsigned char ty;
if(Stat & STA_NODISK) {
if (Stat & STA_NODISK) {
return Stat; /* No card in the socket */
}
@ -551,23 +551,23 @@ DSTATUS MCI_initialize(void)
uint32_t start = hwtimer_now();
/* SDC Ver2 */
if(send_cmd(CMD8, 0x1AA, 1, resp) && (resp[0] & 0xFFF) == 0x1AA) {
if (send_cmd(CMD8, 0x1AA, 1, resp) && (resp[0] & 0xFFF) == 0x1AA) {
/* The card can work at vdd range of 2.7-3.6V */
DEBUG("SDC Ver. 2\n");
do { /* Wait while card is busy state (use ACMD41 with HCS bit) */
/* This loop will take a time. Insert wai_tsk(1) here for multitask envilonment. */
if(hwtimer_now() > start + 1000000/*!Timer[0]*/) {
if (hwtimer_now() > start + 1000000/*!Timer[0]*/) {
DEBUG("%s, %d: Timeout #1\n", __FILE__, __LINE__);
goto di_fail;
}
}
while(!send_cmd(ACMD41, 0x40FF8000, 1, resp) || !(resp[0] & 0x80000000));
while (!send_cmd(ACMD41, 0x40FF8000, 1, resp) || !(resp[0] & 0x80000000));
ty = (resp[0] & 0x40000000) ? CT_SD2 | CT_BLOCK : CT_SD2; /* Check CCS bit in the OCR */
}
else { /* SDC Ver1 or MMC */
if(send_cmd(ACMD41, 0x00FF8000, 1, resp)) {
if (send_cmd(ACMD41, 0x00FF8000, 1, resp)) {
DEBUG("SDC Ver. 1\n");
ty = CT_SD1;
cmd = ACMD41; /* ACMD41 is accepted -> SDC Ver1 */
@ -582,13 +582,13 @@ DSTATUS MCI_initialize(void)
DEBUG("%s, %d: %lX\n", __FILE__, __LINE__, resp[0]);
/* This loop will take a time. Insert wai_tsk(1) here for multitask envilonment. */
if(hwtimer_now() > start + 1000000/*!Timer[0]*/) {
if (hwtimer_now() > start + 1000000/*!Timer[0]*/) {
DEBUG("now: %lu, started at: %lu\n", hwtimer_now(), start);
DEBUG("%s, %d: Timeout #2\n", __FILE__, __LINE__);
goto di_fail;
}
}
while(!send_cmd(cmd, 0x00FF8000, 1, resp) || !(resp[0] & 0x80000000));
while (!send_cmd(cmd, 0x00FF8000, 1, resp) || !(resp[0] & 0x80000000));
}
CardType = ty; /* Save card type */
@ -596,19 +596,19 @@ DSTATUS MCI_initialize(void)
/*---- Card is 'ready' state ----*/
if(!send_cmd(CMD2, 0, 2, resp)) {
if (!send_cmd(CMD2, 0, 2, resp)) {
DEBUG("%s, %d: Failed entering ident state", __FILE__, __LINE__);
goto di_fail; /* Enter ident state */
}
for(n = 0; n < 4; n++) {
for (n = 0; n < 4; n++) {
bswap_cp(&CardInfo[n * 4 + 16], &resp[n]); /* Save CID */
}
/*---- Card is 'ident' state ----*/
if(ty & CT_SDC) { /* SDC: Get generated RCA and save it */
if(!send_cmd(CMD3, 0, 1, resp)) {
if (ty & CT_SDC) { /* SDC: Get generated RCA and save it */
if (!send_cmd(CMD3, 0, 1, resp)) {
DEBUG("%s, %d: Failed generating RCA\n", __FILE__, __LINE__);
goto di_fail;
}
@ -616,7 +616,7 @@ DSTATUS MCI_initialize(void)
CardRCA = (unsigned short)(resp[0] >> 16);
}
else { /* MMC: Assign RCA to the card */
if(!send_cmd(CMD3, 1 << 16, 1, resp)) {
if (!send_cmd(CMD3, 1 << 16, 1, resp)) {
goto di_fail;
}
@ -625,23 +625,23 @@ DSTATUS MCI_initialize(void)
/*---- Card is 'stby' state ----*/
if(!send_cmd(CMD9, (unsigned long)CardRCA << 16, 2, resp)) { /* Get CSD and save it */
if (!send_cmd(CMD9, (unsigned long)CardRCA << 16, 2, resp)) { /* Get CSD and save it */
goto di_fail;
}
for(n = 0; n < 4; n++) {
for (n = 0; n < 4; n++) {
bswap_cp(&CardInfo[n * 4], &resp[n]);
}
if(!send_cmd(CMD7, (unsigned long)CardRCA << 16, 1, resp)) { /* Select card */
if (!send_cmd(CMD7, (unsigned long)CardRCA << 16, 1, resp)) { /* Select card */
//printf("MCI CMD7 fail\n");
goto di_fail;
}
/*---- Card is 'tran' state ----*/
if(!(ty & CT_BLOCK)) { /* Set data block length to 512 (for byte addressing cards) */
if(!send_cmd(CMD16, 512, 1, resp) || (resp[0] & 0xFDF90000)) {
if (!(ty & CT_BLOCK)) { /* Set data block length to 512 (for byte addressing cards) */
if (!send_cmd(CMD16, 512, 1, resp) || (resp[0] & 0xFDF90000)) {
//printf("MCI CMD16 fail\n");
goto di_fail;
}
@ -649,8 +649,8 @@ DSTATUS MCI_initialize(void)
#if USE_4BIT
if(ty & CT_SDC) { /* Set wide bus mode (for SDCs) */
if(!send_cmd(ACMD6, 2, 1, resp) /* Set bus mode of SDC */
if (ty & CT_SDC) { /* Set wide bus mode (for SDCs) */
if (!send_cmd(ACMD6, 2, 1, resp) /* Set bus mode of SDC */
|| (resp[0] & 0xFDF90000)) {
//printf("MCI ACMD6 fail\n");
goto di_fail;
@ -703,19 +703,19 @@ DRESULT MCI_read(unsigned char *buff, unsigned long sector, unsigned char count)
unsigned char rp;
if(count < 1 || count > 127) {
if (count < 1 || count > 127) {
return RES_PARERR; /* Check parameter */
}
if(Stat & STA_NOINIT) {
if (Stat & STA_NOINIT) {
return RES_NOTRDY; /* Check drive status */
}
if(!(CardType & CT_BLOCK)) {
if (!(CardType & CT_BLOCK)) {
sector *= 512; /* Convert LBA to byte address if needed */
}
if(!wait_ready(500)) {
if (!wait_ready(500)) {
return RES_ERROR; /* Make sure that card is tran state */
}
@ -723,17 +723,17 @@ DRESULT MCI_read(unsigned char *buff, unsigned long sector, unsigned char count)
cmd = (count > 1) ? CMD18 : CMD17; /* Transfer type: Single block or Multiple block */
if(send_cmd(cmd, sector, 1, &resp) /* Start to read */
if (send_cmd(cmd, sector, 1, &resp) /* Start to read */
&& !(resp & 0xC0580000)) {
rp = 0;
do {
while((rp == XferWp) && !(XferStat & 0xC)) {
while ((rp == XferWp) && !(XferStat & 0xC)) {
/* Wait for block arrival */
/* This loop will take a time. Replace it with sync process for multitask envilonment. */
}
if(XferStat & 0xC) {
if (XferStat & 0xC) {
break; /* Abort if any error has occured */
}
@ -741,15 +741,15 @@ DRESULT MCI_read(unsigned char *buff, unsigned long sector, unsigned char count)
XferRp = rp = (rp + 1) % N_BUF; /* Next DMA buffer */
if(XferStat & 0xC) {
if (XferStat & 0xC) {
break; /* Abort if overrun has occured */
}
buff += 512; /* Next user buffer address */
}
while(--count);
while (--count);
if(cmd == CMD18) { /* Terminate to read (MB) */
if (cmd == CMD18) { /* Terminate to read (MB) */
send_cmd(CMD12, 0, 1, &resp);
}
}
@ -777,33 +777,33 @@ DRESULT MCI_write(const unsigned char *buff, unsigned long sector, unsigned char
unsigned int cmd;
unsigned char wp, xc;
if(count < 1 || count > 127) {
if (count < 1 || count > 127) {
return RES_PARERR; /* Check parameter */
}
if(Stat & STA_NOINIT) {
if (Stat & STA_NOINIT) {
return RES_NOTRDY; /* Check drive status */
}
if(Stat & STA_PROTECT) {
if (Stat & STA_PROTECT) {
return RES_WRPRT; /* Check write protection */
}
if(!(CardType & CT_BLOCK)) {
if (!(CardType & CT_BLOCK)) {
sector *= 512; /* Convert LBA to byte address if needed */
}
if(!wait_ready(500)) {
if (!wait_ready(500)) {
return RES_ERROR; /* Make sure that card is tran state */
}
if(count == 1) { /* Single block write */
if (count == 1) { /* Single block write */
cmd = CMD24;
}
else { /* Multiple block write */
cmd = (CardType & CT_SDC) ? ACMD23 : CMD23;
if(!send_cmd(cmd, count, 1, &rc) /* Preset number of blocks to write */
if (!send_cmd(cmd, count, 1, &rc) /* Preset number of blocks to write */
|| (rc & 0xC0580000)) {
return RES_ERROR;
}
@ -811,7 +811,7 @@ DRESULT MCI_write(const unsigned char *buff, unsigned long sector, unsigned char
cmd = CMD25;
}
if(!send_cmd(cmd, sector, 1, &rc) /* Send a write command */
if (!send_cmd(cmd, sector, 1, &rc) /* Send a write command */
|| (rc & 0xC0580000)) {
return RES_ERROR;
}
@ -825,24 +825,24 @@ DRESULT MCI_write(const unsigned char *buff, unsigned long sector, unsigned char
count--;
buff += 512; /* Next user buffer address */
}
while(count && wp < N_BUF);
while (count && wp < N_BUF);
XferWp = wp = wp % N_BUF;
start_transmission(xc); /* Start transmission */
while(count) {
while((wp == XferRp) && !(XferStat & 0xC)) { /* Wait for block FIFO not full */
while (count) {
while ((wp == XferRp) && !(XferStat & 0xC)) { /* Wait for block FIFO not full */
/* This loop will take a time. Replace it with sync process for multitask envilonment. */
}
if(XferStat & 0xC) {
if (XferStat & 0xC) {
break; /* Abort if block underrun or any MCI error has occured */
}
Copy_un2al(DmaBuff[wp], (unsigned char *)(unsigned int)buff, 512); /* Push a block */
XferWp = wp = (wp + 1) % N_BUF; /* Next DMA buffer */
if(XferStat & 0xC) {
if (XferStat & 0xC) {
break; /* Abort if block underrun has occured */
}
@ -850,15 +850,15 @@ DRESULT MCI_write(const unsigned char *buff, unsigned long sector, unsigned char
buff += 512; /* Next user buffer address */
}
while(!(XferStat & 0xC)); /* Wait for all blocks sent (block underrun) */
while (!(XferStat & 0xC)); /* Wait for all blocks sent (block underrun) */
if(XferStat & 0x8) {
if (XferStat & 0x8) {
count = 1; /* Abort if any MCI error has occured */
}
stop_transfer(); /* Close data path */
if(cmd == CMD25 && (CardType & CT_SDC)) { /* Terminate to write (SDC w/MB) */
if (cmd == CMD25 && (CardType & CT_SDC)) { /* Terminate to write (SDC w/MB) */
send_cmd(CMD12, 0, 1, &rc);
}
@ -883,7 +883,7 @@ DRESULT MCI_ioctl(
unsigned long resp[4], d, *dp, st, ed;
if(Stat & STA_NOINIT) {
if (Stat & STA_NOINIT) {
return RES_NOTRDY;
}
@ -891,14 +891,14 @@ DRESULT MCI_ioctl(
switch(ctrl) {
case CTRL_SYNC : /* Make sure that all data has been written on the media */
if(wait_ready(500)) { /* Wait for card enters tarn state */
if (wait_ready(500)) { /* Wait for card enters tarn state */
res = RES_OK;
}
break;
case GET_SECTOR_COUNT : /* Get number of sectors on the disk (unsigned long) */
if((CardInfo[0] >> 6) == 1) { /* SDC CSD v2.0 */
if ((CardInfo[0] >> 6) == 1) { /* SDC CSD v2.0 */
d = ((unsigned short)CardInfo[8] << 8) + CardInfo[9] + 1;
*(unsigned long *)buff = d << 10;
}
@ -917,11 +917,11 @@ DRESULT MCI_ioctl(
break;
case GET_BLOCK_SIZE : /* Get erase block size in unit of sectors (unsigned long) */
if(CardType & CT_SD2) { /* SDC ver 2.00 */
if (CardType & CT_SD2) { /* SDC ver 2.00 */
*(unsigned long *)buff = 16UL << (CardInfo[10] >> 4);
}
else { /* SDC ver 1.XX or MMC */
if(CardType & CT_SD1) { /* SDC v1 */
if (CardType & CT_SD1) { /* SDC v1 */
*(unsigned long *)buff = (((CardInfo[10] & 63) << 1) + ((unsigned short)(CardInfo[11] & 128) >> 7) + 1) << ((CardInfo[13] >> 6) - 1);
}
else { /* MMC */
@ -933,7 +933,7 @@ DRESULT MCI_ioctl(
break;
case CTRL_ERASE_SECTOR : /* Erase a block of sectors */
if(!(CardType & CT_SDC) || (!(CardInfo[0] >> 6) && !(CardInfo[10] & 0x40))) {
if (!(CardType & CT_SDC) || (!(CardInfo[0] >> 6) && !(CardInfo[10] & 0x40))) {
break; /* Check if sector erase can be applied to the card */
}
@ -941,12 +941,12 @@ DRESULT MCI_ioctl(
st = dp[0];
ed = dp[1];
if(!(CardType & CT_BLOCK)) {
if (!(CardType & CT_BLOCK)) {
st *= 512;
ed *= 512;
}
if(send_cmd(CMD32, st, 1, resp) && send_cmd(CMD33, ed, 1, resp) && send_cmd(CMD38, 0, 1, resp) && wait_ready(30000)) {
if (send_cmd(CMD32, st, 1, resp) && send_cmd(CMD33, ed, 1, resp) && send_cmd(CMD38, 0, 1, resp) && wait_ready(30000)) {
res = RES_OK;
}
@ -991,15 +991,15 @@ DRESULT MCI_ioctl(
break;
case MMC_GET_SDSTAT : /* Receive SD status as a data block (64 bytes) */
if(CardType & CT_SDC) { /* SDC */
if(wait_ready(500)) {
if (CardType & CT_SDC) { /* SDC */
if (wait_ready(500)) {
ready_reception(1, 64); /* Ready to receive data blocks */
if(send_cmd(ACMD13, 0, 1, resp) /* Start to read */
if (send_cmd(ACMD13, 0, 1, resp) /* Start to read */
&& !(resp[0] & 0xC0580000)) {
while((XferWp == 0) && !(XferStat & 0xC));
while ((XferWp == 0) && !(XferStat & 0xC));
if(!(XferStat & 0xC)) {
if (!(XferStat & 0xC)) {
Copy_al2un(buff, DmaBuff[0], 64);
res = RES_OK;
}

22
cpu/lpc2387/rtc/lpc2387-rtc.c
View File

@ -51,7 +51,7 @@ static volatile time_t epoch;
void
rtc_set_localtime(struct tm *localt)
{
if(localt == NULL) {
if (localt == NULL) {
return;
}
@ -84,7 +84,7 @@ void rtc_reset(void)
void
rtc_set_alarm(struct tm *localt, enum rtc_alarm_mask mask)
{
if(localt != NULL) {
if (localt != NULL) {
RTC_ALSEC = localt->tm_sec;
RTC_ALMIN = localt->tm_min;
RTC_ALHOUR = localt->tm_hour;
@ -105,7 +105,7 @@ rtc_set_alarm(struct tm *localt, enum rtc_alarm_mask mask)
enum rtc_alarm_mask
rtc_get_alarm(struct tm *localt)
{
if(localt != NULL) {
if (localt != NULL) {
localt->tm_sec = RTC_ALSEC;
localt->tm_min = RTC_ALMIN;
localt->tm_hour = RTC_ALHOUR;
@ -125,17 +125,17 @@ void RTC_IRQHandler(void)
{
lpm_begin_awake();
if(RTC_ILR & ILR_RTSSF) {
if (RTC_ILR & ILR_RTSSF) {
/* sub second interrupt (does not need flag-clearing) */
}
else if(RTC_ILR & ILR_RTCCIF) {
else if (RTC_ILR & ILR_RTCCIF) {
/* counter increase interrupt */
RTC_ILR |= ILR_RTCCIF;
epoch += 60 * 60; /* add 1 hour */
}
else if(RTC_ILR & ILR_RTCALF) {
else if (RTC_ILR & ILR_RTCALF) {
RTC_ILR |= ILR_RTCALF;
RTC_AMR = 0xff; /* disable alarm irq */
DEBUG("Ring\n");
@ -169,7 +169,7 @@ void rtc_init(void)
/* initialize clock with valid unix compatible values
* If RTC_YEAR contains an value larger unix time_t we must reset. */
if(RTC_YEAR > 2037) {
if (RTC_YEAR > 2037) {
rtc_reset();
}
@ -188,7 +188,7 @@ time_t rtc_time(struct timeval *time)
sec = RTC_SEC;
min = RTC_MIN;
while(usec != (RTC_CTC >> 1)) {
while (usec != (RTC_CTC >> 1)) {
usec = (RTC_CTC >> 1);
sec = RTC_SEC;
min = RTC_MIN;
@ -197,7 +197,7 @@ time_t rtc_time(struct timeval *time)
sec += min * 60; /* add number of minutes */
sec += epoch; /* add precalculated epoch in hour granularity */
if(time != NULL) {
if (time != NULL) {
usec = usec * 15625;
usec >>= 9;
time->tv_sec = sec;
@ -217,7 +217,7 @@ void rtc_disable(void)
void
rtc_get_localtime(struct tm *localt)
{
if(localt != NULL) {
if (localt != NULL) {
localt->tm_sec = RTC_SEC;
localt->tm_min = RTC_MIN;
localt->tm_hour = RTC_HOUR;
@ -234,7 +234,7 @@ void gettimeofday_r(struct _reent *r, struct timeval *ptimeval, struct timezone
{
r->_errno = 0;
if(ptimeval != NULL) {
if (ptimeval != NULL) {
rtc_time(ptimeval);
}
}

2
cpu/msp430-common/cpu.c
View File

@ -63,7 +63,7 @@ char *thread_stack_init(void *task_func, void *stack_start, int stack_size)
--stk;
/* Space for registers. */
for(unsigned int i = 15; i > 4; i--) {
for (unsigned int i = 15; i > 4; i--) {
*stk = i;
--stk;
}

6
cpu/msp430-common/flashrom.c
View File

@ -31,11 +31,11 @@ void flashrom_write(uint8_t *dst, uint8_t *src, size_t size)
FCTL3 = FWKEY; /* Lock = 0 */
busy_wait();
for(i = size; i > 0; i--) {
for (i = size; i > 0; i--) {
FCTL1 = FWKEY | WRT;
*dst = *src; /* program Flash word */
while(!(FCTL3 & WAIT)) {
while (!(FCTL3 & WAIT)) {
nop();
}
}
@ -82,7 +82,7 @@ void finish(uint8_t istate)
static inline void busy_wait(void)
{
/* Wait for BUSY = 0, not needed unless run from RAM */
while(FCTL3 & 0x0001) {
while (FCTL3 & 0x0001) {
nop();
}
}

4
cpu/msp430-common/hwtimer_cpu.c
View File

@ -70,14 +70,14 @@ void hwtimer_arch_init(void (*handler)(int), uint32_t fcpu)
void hwtimer_arch_enable_interrupt(void)
{
for(int i = 0; i < ARCH_MAXTIMERS; i++) {
for (int i = 0; i < ARCH_MAXTIMERS; i++) {
TA0_enable_interrupt(i);
}
}
void hwtimer_arch_disable_interrupt(void)
{
for(int i = 0; i < ARCH_MAXTIMERS; i++) {
for (int i = 0; i < ARCH_MAXTIMERS; i++) {
TA0_disable_interrupt(i);
}
}

2
cpu/msp430-common/include/cpu.h
View File

@ -86,7 +86,7 @@ inline void __exit_isr(void)
{
__inISR = 0;
if(sched_context_switch_request) {
if (sched_context_switch_request) {
sched_run();
}

2
cpu/msp430-common/include/msp430.h
View File

@ -84,7 +84,7 @@ extern volatile uint32_t cpu_speed;
void msp430_set_cpu_speed(uint32_t speed);
void msp430_cpu_init(void); /* Rename to cpu_init() later! */
void msp430_cpu_init(void); /* Rename to cpu_init() later!*/
#define cpu_init() msp430_cpu_init()
void msp430_init_dco(void);

6
cpu/msp430-common/irq.c
View File

@ -12,7 +12,7 @@ unsigned int disableIRQ()
__asm__("mov.w r2,%0" : "=r"(state));
state &= GIE;
if(state) {
if (state) {
dINT();
}
@ -25,7 +25,7 @@ unsigned int enableIRQ()
__asm__("mov.w r2,%0" : "=r"(state));
state &= GIE;
if(!state) {
if (!state) {
eINT();
}
@ -34,7 +34,7 @@ unsigned int enableIRQ()
void restoreIRQ(unsigned int state)
{
if(state) {
if (state) {
eINT();
}
}

4
cpu/msp430-common/msp430-main.c
View File

@ -113,7 +113,7 @@ msp430_cpu_init(void)
// lpm_init();
eint();
if((uintptr_t)cur_break & 1) { /* Workaround for msp430-ld bug! */
if ((uintptr_t)cur_break & 1) { /* Workaround for msp430-ld bug!*/
cur_break++;
}
}
@ -136,7 +136,7 @@ void *sbrk(int incr)
asmv("mov r1, %0" : "=r"(stack_pointer));
stack_pointer -= STACK_EXTRA;
if(incr > (stack_pointer - cur_break)) {
if (incr > (stack_pointer - cur_break)) {
return (void *) - 1; /* ENOMEM */
}

6
cpu/msp430x16x/flashrom.c
View File

@ -31,11 +31,11 @@ void flashrom_write(uint8_t *dst, uint8_t *src, size_t size)
FCTL3 = FWKEY; /* Lock = 0 */
busy_wait();
for(i = size; i > 0; i--) {
for (i = size; i > 0; i--) {
FCTL1 = FWKEY | WRT;
*dst = *src; /* program Flash word */
while(!(FCTL3 & WAIT)) {
while (!(FCTL3 & WAIT)) {
nop();
}
}
@ -82,7 +82,7 @@ void finish(uint8_t istate)
static inline void busy_wait(void)
{
/* Wait for BUSY = 0, not needed unless run from RAM */
while(FCTL3 & 0x0001) {
while (FCTL3 & 0x0001) {
nop();
}
}

4
cpu/msp430x16x/hwtimer_msp430.c
View File

@ -17,7 +17,7 @@ void timerA_init(void)
volatile unsigned int *ccr = &TA0CCR0;
volatile unsigned int *ctl = &TA0CCTL0;
for(int i = 0; i < ARCH_MAXTIMERS; i++) {
for (int i = 0; i < ARCH_MAXTIMERS; i++) {
*ccr = 0;
*ctl &= ~(CCIFG);
*ctl &= ~(CCIE);
@ -42,7 +42,7 @@ interrupt(TIMERA1_VECTOR) __attribute__((naked)) timer_isr(void)
short taiv = TA0IV;
if(taiv & TAIFG) {
if (taiv & TAIFG) {
// puts("msp430/hwtimer_cpu TAIFG set!");
// TA0CTL &= ~TAIFG;
// ticks += 0xFFFF;

22
cpu/native/hwtimer_cpu.c
View File

@ -85,19 +85,19 @@ void schedule_timer(void)
{
int l = next_timer;
for(
for (
int i = ((next_timer + 1) % ARCH_MAXTIMERS);
i != next_timer;
i = ((i + 1) % ARCH_MAXTIMERS)
) {
if(native_hwtimer_isset[l] != 1) {
if (native_hwtimer_isset[l] != 1) {
/* make sure we dont compare to garbage in the following
* if condition */
l = i;
}
if(
if (
(native_hwtimer_isset[i] == 1) &&
(tv2ticks(&(native_hwtimer[i].it_value)) < tv2ticks(&(native_hwtimer[l].it_value)))
) {
@ -111,8 +111,8 @@ void schedule_timer(void)
/* l could still point to some unused (garbage) timer if no timers
* are set at all */
if(native_hwtimer_isset[next_timer] == 1) {
if(setitimer(ITIMER_REAL, &native_hwtimer[next_timer], NULL) == -1) {
if (native_hwtimer_isset[next_timer] == 1) {
if (setitimer(ITIMER_REAL, &native_hwtimer[next_timer], NULL) == -1) {
err(1, "schedule_timer");
}
else {
@ -140,7 +140,7 @@ void hwtimer_isr_timer()
native_hwtimer_isset[next_timer] = 0;
schedule_timer();
if(native_hwtimer_irq[i] == 1) {
if (native_hwtimer_irq[i] == 1) {
DEBUG("hwtimer_isr_timer(): calling hwtimer.int_handler(%i)\n", i);
int_handler(i);
}
@ -153,7 +153,7 @@ void hwtimer_arch_enable_interrupt(void)
{
DEBUG("hwtimer_arch_enable_interrupt()\n");
if(register_interrupt(SIGALRM, hwtimer_isr_timer) != 0) {
if (register_interrupt(SIGALRM, hwtimer_isr_timer) != 0) {
DEBUG("darn!\n\n");
}
@ -164,7 +164,7 @@ void hwtimer_arch_disable_interrupt(void)
{
DEBUG("hwtimer_arch_disable_interrupt()\n");
if(unregister_interrupt(SIGALRM) != 0) {
if (unregister_interrupt(SIGALRM) != 0) {
DEBUG("darn!\n\n");
}
@ -186,7 +186,7 @@ void hwtimer_arch_set(unsigned long offset, short timer)
{
DEBUG("hwtimer_arch_set(%li, %i)\n", offset, timer);
if(offset < HWTIMERMINOFFSET) {
if (offset < HWTIMERMINOFFSET) {
offset = HWTIMERMINOFFSET;
DEBUG("hwtimer_arch_set: offset < MIN, set to: %i\n", offset);
}
@ -227,7 +227,7 @@ unsigned long hwtimer_arch_now(void)
t.tv_nsec = mts.tv_nsec;
#else
if(clock_gettime(CLOCK_MONOTONIC, &t) == -1) {
if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) {
err(1, "hwtimer_arch_now: clock_gettime");
}
@ -247,7 +247,7 @@ void hwtimer_arch_init(void (*handler)(int), uint32_t fcpu)
hwtimer_arch_disable_interrupt();
int_handler = handler;
for(int i = 0; i < ARCH_MAXTIMERS; i++) {
for (int i = 0; i < ARCH_MAXTIMERS; i++) {
native_hwtimer_irq[i] = 0;
native_hwtimer_isset[i] = 0;
native_hwtimer[i].it_interval.tv_sec = 0;

88
cpu/native/irq_cpu.c
View File

@ -53,19 +53,19 @@ void print_thread_sigmask(ucontext_t *cp)
{
sigset_t *p = &cp->uc_sigmask;
if(sigemptyset(p) == -1) {
if (sigemptyset(p) == -1) {
err(1, "print_thread_sigmask: sigemptyset");
}
for(int i = 1; i < (NSIG); i++) {
if(native_irq_handlers[i].func != NULL) {
for (int i = 1; i < (NSIG); i++) {
if (native_irq_handlers[i].func != NULL) {
printf("%s: %s\n",
strsignal(i),
(sigismember(&native_sig_set, i) ? "blocked" : "unblocked")
);
}
if(sigismember(p, i)) {
if (sigismember(p, i)) {
printf("%s: pending\n", strsignal(i));
}
}
@ -76,8 +76,8 @@ void print_sigmasks(void)
ucontext_t *p;
//tcb_t *cb = NULL;
for(int i = 0; i < MAXTHREADS; i++) {
if(sched_threads[i] != NULL) {
for (int i = 0; i < MAXTHREADS; i++) {
if (sched_threads[i] != NULL) {
printf("%s:\n", sched_threads[i]->name);
//print_thread_sigmask(sched_threads[i]->sp);
p = (ucontext_t *)(sched_threads[i]->stack_start);
@ -92,31 +92,31 @@ void native_print_signals()
sigset_t p, q;
puts("native signals:\n");
if(sigemptyset(&p) == -1) {
if (sigemptyset(&p) == -1) {
err(1, "native_print_signals: sigemptyset");
}
if(sigpending(&p) == -1) {
if (sigpending(&p) == -1) {
err(1, "native_print_signals: sigpending");
}
if(sigprocmask(SIG_SETMASK, NULL, &q) == -1) {
if (sigprocmask(SIG_SETMASK, NULL, &q) == -1) {
err(1, "native_print_signals(): sigprocmask");
}
for(int i = 1; i < (NSIG); i++) {
if(native_irq_handlers[i].func != NULL || i == SIGUSR1) {
for (int i = 1; i < (NSIG); i++) {
if (native_irq_handlers[i].func != NULL || i == SIGUSR1) {
printf("%s: %s in active thread\n",
strsignal(i),
(sigismember(&native_sig_set, i) ? "blocked" : "unblocked")
);
}
if(sigismember(&p, i)) {
if (sigismember(&p, i)) {
printf("%s: pending\n", strsignal(i));
}
if(sigismember(&q, i)) {
if (sigismember(&q, i)) {
printf("%s: blocked in this context\n", strsignal(i));
}
}
@ -133,21 +133,21 @@ unsigned disableIRQ(void)
_native_in_syscall = 1;
DEBUG("disableIRQ()\n");
if(sigfillset(&mask) == -1) {
if (sigfillset(&mask) == -1) {
err(1, "disableIRQ(): sigfillset");
}
if(native_interrupts_enabled == 1) {
if (native_interrupts_enabled == 1) {
DEBUG("sigprocmask(..native_sig_set)\n");
if(sigprocmask(SIG_SETMASK, &mask, &native_sig_set) == -1) {
if (sigprocmask(SIG_SETMASK, &mask, &native_sig_set) == -1) {
err(1, "disableIRQ(): sigprocmask");
}
}
else {
DEBUG("sigprocmask()\n");
if(sigprocmask(SIG_SETMASK, &mask, NULL) == -1) {
if (sigprocmask(SIG_SETMASK, &mask, NULL) == -1) {
err(1, "disableIRQ(): sigprocmask()");
}
}
@ -155,7 +155,7 @@ unsigned disableIRQ(void)
prev_state = native_interrupts_enabled;
native_interrupts_enabled = 0;
if(_native_sigpend > 0) {
if (_native_sigpend > 0) {
DEBUG("\n\n\t\treturn from syscall, calling native_irq_handler\n\n");
_native_in_syscall = 0;
printf("calling swapcontext()\n");
@ -180,7 +180,7 @@ unsigned enableIRQ(void)
_native_in_syscall = 1;
DEBUG("enableIRQ()\n");
if(sigprocmask(SIG_SETMASK, &native_sig_set, NULL) == -1) {
if (sigprocmask(SIG_SETMASK, &native_sig_set, NULL) == -1) {
err(1, "enableIRQ(): sigprocmask()");
}
@ -189,7 +189,7 @@ unsigned enableIRQ(void)
//print_sigmasks();
//native_print_signals();
if(_native_sigpend > 0) {
if (_native_sigpend > 0) {
DEBUG("\n\n\t\treturn from syscall, calling native_irq_handler\n\n");
_native_in_syscall = 0;
printf("calling swapcontext()\n");
@ -208,7 +208,7 @@ void restoreIRQ(unsigned state)
{
DEBUG("restoreIRQ()\n");
if(state == 1) {
if (state == 1) {
enableIRQ();
}
else {
@ -243,12 +243,12 @@ int _native_popsig(void)
nleft = sizeof(int);
i = 0;
while((nleft > 0) && ((nread = read(pipefd[0], &sig + i, nleft)) != -1)) {
while ((nleft > 0) && ((nread = read(pipefd[0], &sig + i, nleft)) != -1)) {
i += nread;
nleft -= nread;
}
if(nread == -1) {
if (nread == -1) {
err(1, "_native_popsig(): read()");
}
@ -265,16 +265,16 @@ void native_irq_handler()
DEBUG("\n\n\t\tnative_irq_handler\n\n");
while(_native_sigpend > 0) {
while (_native_sigpend > 0) {
sig = _native_popsig();
_native_sigpend--;
if(native_irq_handlers[sig].func != NULL) {
if (native_irq_handlers[sig].func != NULL) {
DEBUG("calling interrupt handler for %i\n", sig);
native_irq_handlers[sig].func();
}
else if(sig == SIGUSR1) {
else if (sig == SIGUSR1) {
DEBUG("ignoring SIGUSR1\n");
}
else {
@ -296,12 +296,12 @@ void native_isr_entry(int sig, siginfo_t *info, void *context)
{
DEBUG("\n\n\t\tnative_isr_entry\n\n");
if(native_interrupts_enabled == 0) {
if (native_interrupts_enabled == 0) {
errx(1, "interrupts are off, but I caught a signal.");
}
/* save the signal */
if(write(pipefd[1], &sig, sizeof(int)) == -1) {
if (write(pipefd[1], &sig, sizeof(int)) == -1) {
err(1, "native_isr_entry(): write()");
}
@ -311,7 +311,7 @@ void native_isr_entry(int sig, siginfo_t *info, void *context)
makecontext(&native_isr_context, native_irq_handler, 0);
_native_cur_ctx = (ucontext_t *)active_thread->sp;
if(_native_in_syscall == 0) {
if (_native_in_syscall == 0) {
_native_in_isr = 1;
DEBUG("\n\n\t\treturn to _native_sig_leave_tramp\n\n");
#ifdef __MACH__
@ -343,7 +343,7 @@ int register_interrupt(int sig, void *handler)
struct sigaction sa;
DEBUG("XXX: register_interrupt()\n");
if(sigdelset(&native_sig_set, sig)) {
if (sigdelset(&native_sig_set, sig)) {
err(1, "register_interrupt: sigdelset");
}
@ -352,13 +352,13 @@ int register_interrupt(int sig, void *handler)
sa.sa_sigaction = (void *) native_isr_entry;
/* sa.sa_handler = (void*) native_isr_entry; */
if(sigemptyset(&sa.sa_mask) == -1) {
if (sigemptyset(&sa.sa_mask) == -1) {
err(1, "register_interrupt: sigemptyset");
}
sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
if(sigaction(sig, &sa, NULL)) {
if (sigaction(sig, &sa, NULL)) {
err(1, "register_interrupt: sigaction");
}
@ -376,7 +376,7 @@ int unregister_interrupt(int sig)
struct sigaction sa;
DEBUG("XXX: unregister_interrupt()\n");
if(sigaddset(&native_sig_set, sig) == -1) {
if (sigaddset(&native_sig_set, sig) == -1) {
err(1, "unregister_interrupt: sigaddset");
}
@ -385,13 +385,13 @@ int unregister_interrupt(int sig)
/* sa.sa_sigaction = SIG_IGN; */
sa.sa_handler = SIG_IGN;
if(sigemptyset(&sa.sa_mask) == -1) {
if (sigemptyset(&sa.sa_mask) == -1) {
err(1, "unregister_interrupt: sigemptyset");
}
sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
if(sigaction(sig, &sa, NULL)) {
if (sigaction(sig, &sa, NULL)) {
err(1, "unregister_interrupt: sigaction");
}
@ -413,13 +413,13 @@ void native_interrupt_init(void)
native_interrupts_enabled = 1;
_native_sigpend = 0;
for(int i = 0; i < 255; i++) {
for (int i = 0; i < 255; i++) {
native_irq_handlers[i].func = NULL;
}
sa.sa_sigaction = (void *) native_isr_entry;
if(sigemptyset(&sa.sa_mask) == -1) {
if (sigemptyset(&sa.sa_mask) == -1) {
err(1, "native_interrupt_init: sigemptyset");
}
@ -430,23 +430,23 @@ void native_interrupt_init(void)
err(1, "native_interrupt_init: sigemptyset");
}
*/
if(sigprocmask(SIG_SETMASK, NULL, &native_sig_set) == -1) {
if (sigprocmask(SIG_SETMASK, NULL, &native_sig_set) == -1) {
err(1, "native_interrupt_init(): sigprocmask");
}
if(sigdelset(&native_sig_set, SIGUSR1) == -1) {
if (sigdelset(&native_sig_set, SIGUSR1) == -1) {
err(1, "native_interrupt_init: sigdelset");
}
if(sigaction(SIGUSR1, &sa, NULL)) {
if (sigaction(SIGUSR1, &sa, NULL)) {
err(1, "native_interrupt_init: sigaction");
}
if(getcontext(&native_isr_context) == -1) {
if (getcontext(&native_isr_context) == -1) {
err(1, "native_isr_entry(): getcontext()");
}
if(sigfillset(&(native_isr_context.uc_sigmask)) == -1) {
if (sigfillset(&(native_isr_context.uc_sigmask)) == -1) {
err(1, "native_isr_entry(): sigfillset()");
}
@ -460,7 +460,7 @@ void native_interrupt_init(void)
sigstk.ss_size = SIGSTKSZ;
sigstk.ss_flags = 0;
if(sigaltstack(&sigstk, NULL) < 0) {
if (sigaltstack(&sigstk, NULL) < 0) {
err(1, "main: sigaltstack");
}
@ -468,7 +468,7 @@ void native_interrupt_init(void)
_native_in_syscall = 0;
if(pipe(pipefd) == -1) {
if (pipe(pipefd) == -1) {
err(1, "native_interrupt_init(): pipe()");
}

6
cpu/native/lpm_cpu.c
View File

@ -48,12 +48,12 @@ void _native_lpm_sleep()
retval = select(1, &_native_uart_rfds, NULL, NULL, NULL);
DEBUG("_native_lpm_sleep: retval: %i\n", retval);
if(retval != -1) {
if (retval != -1) {
/* uart ready, handle input */
/* TODO: switch to ISR context */
_native_handle_uart0_input();
}
else if(errno != EINTR) {
else if (errno != EINTR) {
/* select failed for reason other than signal */
err(1, "lpm_set(): select()");
}
@ -63,7 +63,7 @@ void _native_lpm_sleep()
pause();
#endif
if(_native_sigpend > 0) {
if (_native_sigpend > 0) {
DEBUG("\n\n\t\treturn from syscall, calling native_irq_handler\n\n");
_native_in_syscall = 0;
_native_in_isr = 1;

12
cpu/native/native_cpu.c
View File

@ -63,7 +63,7 @@ char *thread_stack_init(void *task_func, void *stack_start, int stacksize)
stacksize -= sizeof(ucontext_t);
#endif
if(getcontext(p) == -1) {
if (getcontext(p) == -1) {
err(1, "thread_stack_init(): getcontext()");
}
@ -72,7 +72,7 @@ char *thread_stack_init(void *task_func, void *stack_start, int stacksize)
p->uc_stack.ss_flags = 0;
p->uc_link = &end_context;
if(sigemptyset(&(p->uc_sigmask)) == -1) {
if (sigemptyset(&(p->uc_sigmask)) == -1) {
err(1, "thread_stack_init(): sigemptyset()");
}
@ -93,7 +93,7 @@ void cpu_switch_context_exit(void)
ctx = (ucontext_t *)(active_thread->sp);
eINT(); // XXX: workaround for bug (?) in sched_task_exit
if(setcontext(ctx) == -1) {
if (setcontext(ctx) == -1) {
err(1, "cpu_switch_context_exit(): setcontext():");
}
}
@ -113,10 +113,10 @@ void thread_yield()
nc = (ucontext_t *)(active_thread->sp);
if(nc != oc) {
if (nc != oc) {
DEBUG("thread_yield(): calling swapcontext(%s)\n\n", active_thread->name);
if(swapcontext(oc, nc) == -1) {
if (swapcontext(oc, nc) == -1) {
err(1, "thread_yield(): swapcontext()");
}
}
@ -127,7 +127,7 @@ void thread_yield()
void native_cpu_init()
{
if(getcontext(&end_context) == -1) {
if (getcontext(&end_context) == -1) {
err(1, "end_context(): getcontext()");
}

4
cpu/native/rtc/posix-rtc.c
View File

@ -55,10 +55,10 @@ void rtc_get_localtime(struct tm *localt)
{
time_t t;
if(native_rtc_enabled == 1) {
if (native_rtc_enabled == 1) {
t = time(NULL);
if(localtime_r(&t, localt) == NULL) {
if (localtime_r(&t, localt) == NULL) {
err(1, "rtc_get_localtime: localtime_r");
}
}

22
dist/tools/linux-border_router/flowcontrol.c vendored
View File

@ -19,10 +19,10 @@ 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) {
while (1) {
usleep(BORDER_SL_TIMEOUT);
if(seq_num == ((border_packet_t *)(slot->frame))->seq_num) {
if (seq_num == ((border_packet_t *)(slot->frame))->seq_num) {
writepacket(slot->frame, slot->frame_len);
}
else {
@ -45,7 +45,7 @@ void init_threeway_handshake(const struct in6_addr *addr)
writepacket((uint8_t *)syn, sizeof(border_syn_packet_t));
usleep(BORDER_SL_TIMEOUT);
}
while(!connection_established);
while (!connection_established);
}
void signal_connection_established(void)
@ -62,7 +62,7 @@ void flowcontrol_init(const struct in6_addr *addr)
sem_init(&slwin_stat.send_win_not_full, 0, BORDER_SWS);
for(i = 0; i < BORDER_SWS; i++) {
for (i = 0; i < BORDER_SWS; i++) {
slwin_stat.send_win[i].frame_len = 0;
}
@ -70,7 +70,7 @@ void flowcontrol_init(const struct in6_addr *addr)
slwin_stat.next_exp = 0;
for(i = 0; i < BORDER_RWS; i++) {
for (i = 0; i < BORDER_RWS; i++) {
slwin_stat.recv_win[i].received = 0;
slwin_stat.recv_win[i].frame_len = 0;
}
@ -120,8 +120,8 @@ void flowcontrol_send_over_tty(border_packet_t *packet, int 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)) {
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]);
@ -133,7 +133,7 @@ void flowcontrol_deliver_from_tty(const border_packet_t *packet, int len)
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 {
@ -141,7 +141,7 @@ void flowcontrol_deliver_from_tty(const border_packet_t *packet, int len)
slot = &slwin_stat.recv_win[packet->seq_num % BORDER_RWS];
if(!in_window(packet->seq_num,
if (!in_window(packet->seq_num,
slwin_stat.next_exp,
slwin_stat.next_exp + BORDER_RWS - 1)) {
return;
@ -150,8 +150,8 @@ void flowcontrol_deliver_from_tty(const border_packet_t *packet, int len)
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);
slot->received = 0;

8
dist/tools/linux-border_router/main.c vendored
View File

@ -10,7 +10,7 @@
int main(int argc, char **argv)
{
if(argc < 4) {
if (argc < 4) {
fprintf(stderr, "Usage: %s r_addr if_name tty_dev\n", argv[0]);
return -1;
}
@ -22,12 +22,12 @@ int main(int argc, char **argv)
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;
}
@ -38,7 +38,7 @@ int main(int argc, char **argv)
start_test(ping_addr, argv[5], argv[6], atoi(argv[7]), interval);
#else
while(1);
while (1);
#endif
}

44
dist/tools/linux-border_router/multiplex.c vendored
View File

@ -19,7 +19,7 @@ uint8_t serial_in_buf[BUFFER_SIZE];
uint8_t *get_serial_out_buffer(int offset)
{
if(offset > BUFFER_SIZE) {
if (offset > BUFFER_SIZE) {
return NULL;
}
@ -28,7 +28,7 @@ uint8_t *get_serial_out_buffer(int offset)
uint8_t *get_serial_in_buffer(int offset)
{
if(offset > BUFFER_SIZE) {
if (offset > BUFFER_SIZE) {
return NULL;
}
@ -56,33 +56,33 @@ int readpacket(uint8_t *packet_buf, size_t size)
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): {
case (END_ESC): {
*line_buf_ptr++ = END;
continue;
}
case(ESC_ESC): {
case (ESC_ESC): {
*line_buf_ptr++ = ESC;
continue;
}
@ -92,7 +92,7 @@ int readpacket(uint8_t *packet_buf, size_t size)
}
}
if(byte == ESC) {
if (byte == ESC) {
esc = 1;
continue;
}
@ -112,20 +112,20 @@ int writepacket(uint8_t *packet_buf, size_t 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) {
while ((byte_ptr - packet_buf) < size) {
switch(*byte_ptr) {
case(END): {
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++;
@ -151,18 +151,18 @@ int writepacket(uint8_t *packet_buf, size_t size)
void demultiplex(const border_packet_t *packet, int len)
{
switch(packet->type) {
case(BORDER_PACKET_RAW_TYPE): {
case (BORDER_PACKET_RAW_TYPE): {
printf("\033[00;33m[via serial interface] %s\033[00m\n",
((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): {
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));
border_send_ipv6_over_tun(get_tun_fd(), ip6_buf);
@ -177,24 +177,24 @@ void demultiplex(const border_packet_t *packet, int len)
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): {
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);
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;

76
dist/tools/linux-border_router/serial.c vendored
View File

@ -61,20 +61,20 @@ int open_serial_port(const char *port_name)
{
int r;
if(port_fd >= 0) {
if (port_fd >= 0) {
close(port_fd);
}
port_fd = open(port_name, O_RDWR);
if(port_fd < 0) {
if (port_fd < 0) {
report_open_error(port_name, errno);
return -1;
}
r = set_baud(baud_rate);
if(r == 0) {
if (r == 0) {
printf("Port \"%s\" opened at %s baud\r\n",
port_name, baud_rate);
}
@ -89,7 +89,7 @@ int open_serial_port(const char *port_name)
/* 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) {
if (r < 0) {
return 0;
}
@ -118,20 +118,20 @@ static void report_open_error(const char *filename, int err)
printf("\r\n");
printf("Unable to open \"%s\"\r\n", filename);
if(err == EACCES) {
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) {
if (r < 0) {
if (errno == ENOENT) {
printf("file %s does not exist\r\n", filename);
}
else if(errno == ELOOP) {
else if (errno == ELOOP) {
printf("too many symbolic links\r\n");
}
else if(errno == EACCES) {
else if (errno == EACCES) {
printf("permission denied to get file status\r\n");
}
else {
@ -146,7 +146,7 @@ static void report_open_error(const char *filename, int err)
p = getpwuid(my_uid);
if(p) {
if (p) {
snprintf(my_uname, sizeof(my_uname),
"\"%s\" (gid=%d)", p->pw_name, (int)my_uid);
}
@ -157,7 +157,7 @@ static void report_open_error(const char *filename, int err)
p = getpwuid(info.st_uid);
if(p) {
if (p) {
snprintf(file_uname, sizeof(file_uname),
"\"%s\" (uid=%d)", p->pw_name, (int)info.st_uid);
}
@ -168,7 +168,7 @@ static void report_open_error(const char *filename, int err)
g = getgrgid(my_gid);
if(g) {
if (g) {
snprintf(my_gname, sizeof(my_gname),
"\"%s\" (gid=%d)", g->gr_name, (int)my_gid);
}
@ -179,7 +179,7 @@ static void report_open_error(const char *filename, int err)
g = getgrgid(info.st_gid);
if(g) {
if (g) {
snprintf(file_gname, sizeof(file_gname),
"\"%s\" (uid=%d)", g->gr_name, (int)info.st_gid);
}
@ -193,7 +193,7 @@ static void report_open_error(const char *filename, int err)
perm = info.st_mode;
if((perm & S_IROTH) && (perm & S_IWOTH)) {
if ((perm & S_IROTH) && (perm & S_IWOTH)) {
printf("%s has read/write permission for everybody\r\n",
filename);
}
@ -201,19 +201,19 @@ static void report_open_error(const char *filename, int err)
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)) {
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)) {
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) {
if (perm_ok == 0) {
printf("%s does not read/write permission for user or group!\r\n",
filename);
}
@ -269,7 +269,7 @@ void send_break_signal(void)
void close_serial_port(void)
{
if(port_fd >= 0) {
if (port_fd >= 0) {
close(port_fd);
port_fd = -1;
}
@ -278,43 +278,43 @@ void close_serial_port(void)
tcflag_t baud_name_to_flags(const char *baud_name)
{
if(strcmp(baud_name, "230400") == 0) {
if (strcmp(baud_name, "230400") == 0) {
return B230400;
}
if(strcmp(baud_name, "115200") == 0) {
if (strcmp(baud_name, "115200") == 0) {
return B115200;
}
if(strcmp(baud_name, "57600") == 0) {
if (strcmp(baud_name, "57600") == 0) {
return B57600;
}
if(strcmp(baud_name, "38400") == 0) {
if (strcmp(baud_name, "38400") == 0) {
return B38400;
}
if(strcmp(baud_name, "19200") == 0) {
if (strcmp(baud_name, "19200") == 0) {
return B19200;
}
if(strcmp(baud_name, "9600") == 0) {
if (strcmp(baud_name, "9600") == 0) {
return B9600;
}
if(strcmp(baud_name, "4800") == 0) {
if (strcmp(baud_name, "4800") == 0) {
return B4800;
}
if(strcmp(baud_name, "2400") == 0) {
if (strcmp(baud_name, "2400") == 0) {
return B2400;
}
if(strcmp(baud_name, "1200") == 0) {
if (strcmp(baud_name, "1200") == 0) {
return B1200;
}
if(strcmp(baud_name, "300") == 0) {
if (strcmp(baud_name, "300") == 0) {
return B300;
}
@ -328,19 +328,19 @@ int set_baud(const char *baud_name)
tcflag_t baud;
int r;
if(port_fd < 0) {
if (port_fd < 0) {
return -1;
}
baud = baud_name_to_flags(baud_name);
if(baud == B0) {
if (baud == B0) {
return -2;
}
r = tcgetattr(port_fd, &port_setting);
if(r != 0) {
if (r != 0) {
return -3;
}
@ -350,7 +350,7 @@ int set_baud(const char *baud_name)
port_setting.c_lflag = 0;
r = tcsetattr(port_fd, TCSAFLUSH, &port_setting);
if(r != 0) {
if (r != 0) {
return -4;
}
@ -375,12 +375,12 @@ void set_rts(int val)
result = ioctl(port_fd, TIOCMGET, &flags);
if(result == -1) {
if (result == -1) {
printf("Error %i while reading port io flags\n", errno);
return;
}
if(val) {
if (val) {
flags |= TIOCM_RTS;
}
else {
@ -389,7 +389,7 @@ void set_rts(int val)
result = ioctl(port_fd, TIOCMSET, &flags);
if(result == -1) {
if (result == -1) {
printf("Error %i while setting port io flags\n", errno);
}
}
@ -407,12 +407,12 @@ void set_dtr(int val)
result = ioctl(port_fd, TIOCMGET, &flags);
if(result == -1) {
if (result == -1) {
printf("Error %i while reading port io flags\n", errno);
return;
}
if(val) {
if (val) {
flags |= TIOCM_DTR;
}
else {
@ -421,7 +421,7 @@ void set_dtr(int val)
result = ioctl(port_fd, TIOCMSET, &flags);
if(result == -1) {
if (result == -1) {
printf("Error %i while setting port io flags\n", errno);
}
}

24
dist/tools/linux-border_router/serialnumber.c vendored
View File

@ -2,7 +2,7 @@
int serial_add8(uint8_t s, uint8_t n)
{
if(n > 127) {
if (n > 127) {
return -1;
}
@ -12,7 +12,7 @@ int serial_add8(uint8_t s, uint8_t n)
int serial_add16(uint16_t s, uint16_t n)
{
if(n > 32767) {
if (n > 32767) {
return -1;
}
@ -22,7 +22,7 @@ int serial_add16(uint16_t s, uint16_t n)
int serial_add32(uint32_t s, uint32_t n)
{
if(n > 2147483647) {
if (n > 2147483647) {
return -1;
}
@ -32,15 +32,15 @@ int serial_add32(uint32_t s, uint32_t n)
serial_comp_res_t serial_comp8(uint8_t s1, uint8_t s2)
{
if(s1 == s2) {
if (s1 == s2) {
return EQUAL;
}
if((s1 < s2 && s1 - s2 < 128) || (s1 > s2 && s1 - s2 > 128)) {
if ((s1 < s2 && s1 - s2 < 128) || (s1 > s2 && s1 - s2 > 128)) {
return LESS;
}
if((s1 < s2 && s1 - s2 > 128) || (s1 > s2 && s1 - s2 < 128)) {
if ((s1 < s2 && s1 - s2 > 128) || (s1 > s2 && s1 - s2 < 128)) {
return GREATER;
}
@ -49,15 +49,15 @@ serial_comp_res_t serial_comp8(uint8_t s1, uint8_t s2)
serial_comp_res_t serial_comp16(uint16_t s1, uint16_t s2)
{
if(s1 == s2) {
if (s1 == s2) {
return EQUAL;
}
if((s1 < s2 && s1 - s2 < 32768) || (s1 > s2 && s1 - s2 > 32768)) {
if ((s1 < s2 && s1 - s2 < 32768) || (s1 > s2 && s1 - s2 > 32768)) {
return LESS;
}
if((s1 < s2 && s1 - s2 > 32768) || (s1 > s2 && s1 - s2 < 32768)) {
if ((s1 < s2 && s1 - s2 > 32768) || (s1 > s2 && s1 - s2 < 32768)) {
return GREATER;
}
@ -66,15 +66,15 @@ serial_comp_res_t serial_comp16(uint16_t s1, uint16_t s2)
serial_comp_res_t serial_comp32(uint32_t s1, uint32_t s2)
{
if(s1 == s2) {
if (s1 == s2) {
return EQUAL;
}
if((s1 < s2 && s1 - s2 < 2147483648) || (s1 > s2 && s1 - s2 > 2147483648)) {
if ((s1 < s2 && s1 - s2 < 2147483648) || (s1 > s2 && s1 - s2 > 2147483648)) {
return LESS;
}
if((s1 < s2 && s1 - s2 > 2147483648) || (s1 > s2 && s1 - s2 < 2147483648)) {
if ((s1 < s2 && s1 - s2 > 2147483648) || (s1 > s2 && s1 - s2 < 2147483648)) {
return GREATER;
}

50
dist/tools/linux-border_router/sixlowdriver.c vendored
View File

@ -58,11 +58,11 @@ void *serial_reader_f(void *arg)
unsigned char buf[BUFFER_SIZE];
border_packet_t *packet_buf;
while(1) {
while (1) {
int n = readpacket(buf, BUFFER_SIZE);
if(n > 0) {
if(buf[0] == 0) {
if (n > 0) {
if (buf[0] == 0) {
packet_buf = (border_packet_t *)buf;
flowcontrol_deliver_from_tty(packet_buf, n);
continue;
@ -95,10 +95,10 @@ void *tun_reader_f(void *args)
unsigned char data[BUFFER_SIZE];
size_t bytes;
while(1) {
while (1) {
bytes = read(tun_fd, (void *)data, BUFFER_SIZE);
if(bytes > 0) {
if (bytes > 0) {
bytes = tun_to_serial_packet(tun_in_buf, (uint8_t *)data, bytes);
flowcontrol_send_over_tty((border_packet_t *)tun_in_buf, bytes);
}
@ -121,14 +121,14 @@ void border_send_ipv6_over_tun(int fd, const struct ip6_hdr *packet)
int tun_set_owner(int fd, const uid_t *uid, const gid_t *gid)
{
if(uid != NULL) {
if(*uid != -1 && ioctl(fd, TUNSETOWNER, *uid)) {
if (uid != NULL) {
if (*uid != -1 && ioctl(fd, TUNSETOWNER, *uid)) {
return -1;
}
}
if(gid != NULL) {
if(*gid != -1 && ioctl(fd, TUNSETGROUP, *gid)) {
if (gid != NULL) {
if (*gid != -1 && ioctl(fd, TUNSETGROUP, *gid)) {
return -1;
}
}
@ -143,7 +143,7 @@ int tun_add_addr(const char *ip_addr)
printf("INFO: ip addr add %s dev %s\n", ip_addr, tun_if_name);
sprintf(command, "ip addr add %s dev %s", ip_addr, tun_if_name);
if(system(command) != 0) {
if (system(command) != 0) {
return -1;
}
@ -165,7 +165,7 @@ int open_tun(char *if_name, int flags)
*/
/* open the clone device */
if((fd = open(TUNDEV, O_RDWR)) < 0) {
if ((fd = open(TUNDEV, O_RDWR)) < 0) {
return fd;
}
@ -174,7 +174,7 @@ int open_tun(char *if_name, int flags)
ifr.ifr_flags = flags; /* IFF_TUN or IFF_TAP, plus maybe IFF_NO_PI */
if(*if_name) {
if (*if_name) {
/* if a device name was specified, put it in the structure; otherwise,
* the kernel will try to allocate the "next" device of the
* specified type */
@ -182,7 +182,7 @@ int open_tun(char *if_name, int flags)
}
/* try to create the device */
if((err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0) {
if ((err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0) {
close(fd);
return err;
}
@ -207,13 +207,13 @@ int border_update_context(uint8_t cid, const struct in6_addr *prefix,
uint8_t len, uint8_t comp,
uint16_t lifetime)
{
if(cid >= MAXIMUM_CONTEXTS) {
if (cid >= MAXIMUM_CONTEXTS) {
return -1;
}
len = (len <= 128) ? len : 128;
if(context_empty(cid)) {
if (context_empty(cid)) {
context_cache[cid].version = get_abro_version();
}
else {
@ -233,11 +233,11 @@ int border_update_context(uint8_t cid, const struct in6_addr *prefix,
int border_renew_existing_context(uint8_t cid)
{
if(cid >= MAXIMUM_CONTEXTS) {
if (cid >= MAXIMUM_CONTEXTS) {
return -1;
}
if(context_empty(cid)) {
if (context_empty(cid)) {
return -1;
}
@ -248,11 +248,11 @@ int border_renew_existing_context(uint8_t cid)
void border_remove_context(uint8_t cid)
{
if(cid >= MAXIMUM_CONTEXTS) {
if (cid >= MAXIMUM_CONTEXTS) {
return;
}
if(context_empty(cid)) {
if (context_empty(cid)) {
return;
}
@ -268,7 +268,7 @@ int border_add_addr(const char *ip_addr)
{
struct in6_addr parsed_addr;
if(inet_pton(AF_INET6, ip_addr, &parsed_addr) != 1) {
if (inet_pton(AF_INET6, ip_addr, &parsed_addr) != 1) {
return -1;
}
@ -289,11 +289,11 @@ int border_initialize(char *if_name, const char *ip_addr, const char *tty_dev)
strtok(ip_addr_cpy, "/");
if((res = inet_pton(AF_INET6, ip_addr_cpy, &parsed_addr)) != 1) {
if ((res = inet_pton(AF_INET6, ip_addr_cpy, &parsed_addr)) != 1) {
return res;
}
if((res = init_multiplex(tty_dev)) != 0) {
if ((res = init_multiplex(tty_dev)) != 0) {
return res;
}
@ -304,16 +304,16 @@ int border_initialize(char *if_name, const char *ip_addr, const char *tty_dev)
strncpy(tun_if_name, if_name, IF_NAME_LEN);
if((res = system(command)) != 0) {
if ((res = system(command)) != 0) {
return res;
}
if((res = tun_add_addr(ip_addr)) != 0) {
if ((res = tun_add_addr(ip_addr)) != 0) {
return res;
}
// initialize context cache as empty.
for(i = 0; i < MAXIMUM_CONTEXTS; i++) {
for (i = 0; i < MAXIMUM_CONTEXTS; i++) {
context_cache[i].cid = 0xFF;
}

24
dist/tools/linux-border_router/testing.c vendored
View File

@ -22,14 +22,14 @@ void init_file(const char *skeleton_file_name,
skeleton_file = fopen(skeleton_file_name, "r");
while(fgets(line, 1024, skeleton_file) != NULL) {
if(strncmp(line, "# sending window size=%d\n", 1024) == 0) {
while (fgets(line, 1024, skeleton_file) != NULL) {
if (strncmp(line, "# sending window size=%d\n", 1024) == 0) {
fprintf(stats_file, line, BORDER_SWS);
}
else if(strncmp(line, "# count=%ld (-c)\n", 1024) == 0) {
else if (strncmp(line, "# count=%ld (-c)\n", 1024) == 0) {
fprintf(stats_file, line, runs_per_test);
}
else if(strncmp(line, "# interval=%f (-i)\n", 1024) == 0) {
else if (strncmp(line, "# interval=%f (-i)\n", 1024) == 0) {
fprintf(stats_file, line, interval);
}
else {
@ -42,7 +42,7 @@ int testing_init(const char *stats_file_name,
const char *skeleton_file_name,
int runs_per_test, float interval)
{
if(stats_file != NULL) {
if (stats_file != NULL) {
return -1;
}
@ -51,7 +51,7 @@ int testing_init(const char *stats_file_name,
stats_file = fopen(stats_file_name, "w");
if(stats_file == NULL) {
if (stats_file == NULL) {
return -1;
}
@ -63,7 +63,7 @@ int testing_destroy()
{
int res, i;
for(i = 0; i < run_counter; i++) {
for (i = 0; i < run_counter; i++) {
fprintf(stats_file, "%7d\t%3d\t%7ld\n",
i, stats[i].seq_num, stats[i].time_diff
);
@ -82,7 +82,7 @@ int testing_destroy()
void testing_start(uint8_t seq_num)
{
if(stats_file == NULL) {
if (stats_file == NULL) {
return;
}
@ -91,7 +91,7 @@ void testing_start(uint8_t seq_num)
void testing_stop(uint8_t seq_num)
{
if(stats_file == NULL) {
if (stats_file == NULL) {
return;
}
@ -123,7 +123,7 @@ void generate_filename(
today = time(NULL);
tmp = localtime(&today);
if(tmp == NULL) {
if (tmp == NULL) {
perror("localtime");
return;
}
@ -141,9 +141,9 @@ void generate_filename(
count++
);
}
while((test = fopen(filename, "r")) != NULL);
while ((test = fopen(filename, "r")) != NULL);
if(test != NULL) {
if (test != NULL) {
fclose(test);
}
}

44
drivers/cc110x/cc1100-csmaca-mac.c
View File

@ -102,7 +102,7 @@ int cc1100_send_csmaca(radio_address_t address, protocol_t protocol, int priorit
}
/* Calculate collisions per second */
if(collision_state == COLLISION_STATE_INITIAL) {
if (collision_state == COLLISION_STATE_INITIAL) {
timex_t now;
vtimer_now(&now);
collision_measurement_start = now.microseconds;
@ -110,21 +110,21 @@ int cc1100_send_csmaca(radio_address_t address, protocol_t protocol, int priorit
collisions_per_sec = 0;
collision_state = COLLISION_STATE_MEASURE;
}
else if(collision_state == COLLISION_STATE_MEASURE) {
else if (collision_state == COLLISION_STATE_MEASURE) {
timex_t now;
vtimer_now(&now);
uint64_t timespan = now.microseconds - collision_measurement_start;
if(timespan > 1000000) {
if (timespan > 1000000) {
collisions_per_sec = (collision_count * 1000000) / (double) timespan;
if(collisions_per_sec > 0.5 && collisions_per_sec <= 2.2) {
if (collisions_per_sec > 0.5 && collisions_per_sec <= 2.2) {
timex_t now;
vtimer_now(&now);
collision_measurement_start = now.microseconds;
collision_state = COLLISION_STATE_KEEP;
}
else if(collisions_per_sec > 2.2) {
else if (collisions_per_sec > 2.2) {
timex_t now;
vtimer_now(&now);
collision_measurement_start = now.microseconds;
@ -135,21 +135,21 @@ int cc1100_send_csmaca(radio_address_t address, protocol_t protocol, int priorit
}
}
}
else if(collision_state == COLLISION_STATE_KEEP) {
else if (collision_state == COLLISION_STATE_KEEP) {
timex_t now;
vtimer_now(&now);
uint64_t timespan = now.microseconds - collision_measurement_start;
if(timespan > 5000000) {
if (timespan > 5000000) {
collision_state = COLLISION_STATE_INITIAL;
}
}
/* Adjust initial window size according to collision rate */
if(collisions_per_sec > 0.5 && collisions_per_sec <= 2.2) {
if (collisions_per_sec > 0.5 && collisions_per_sec <= 2.2) {
min_window_size *= 2;
}
else if(collisions_per_sec > 2.2) {
else if (collisions_per_sec > 2.2) {
min_window_size *= 4;
}
@ -158,7 +158,7 @@ int cc1100_send_csmaca(radio_address_t address, protocol_t protocol, int priorit
uint32_t total; /* Holds the total wait time before send try */
uint32_t cs_timeout; /* Current carrier sense timeout value */
if(protocol == 0) {
if (protocol == 0) {
return RADIO_INVALID_PARAM; /* Not allowed, protocol id must be greater zero */
}
@ -168,13 +168,13 @@ int cc1100_send_csmaca(radio_address_t address, protocol_t protocol, int priorit
send_csmaca_calls++;
int fail_percentage = (send_csmaca_calls_cs_timeout * 100) / send_csmaca_calls;
if(fail_percentage == 0) {
if (fail_percentage == 0) {
fail_percentage = 1;
}
cs_timeout = CARRIER_SENSE_TIMEOUT / fail_percentage;
if(cs_timeout < CARRIER_SENSE_TIMEOUT_MIN) {
if (cs_timeout < CARRIER_SENSE_TIMEOUT_MIN) {
cs_timeout = CARRIER_SENSE_TIMEOUT_MIN;
}
@ -182,19 +182,19 @@ int cc1100_send_csmaca(radio_address_t address, protocol_t protocol, int priorit
window:
if(backoff != 0) {
if (backoff != 0) {
goto cycle; /* If backoff was 0 */
}
windowSize *= 2; /* ...double the current window size */
if(windowSize > max_window_size) {
if (windowSize > max_window_size) {
windowSize = max_window_size; /* This is the maximum size allowed */
}
backoff = rand() % windowSize; /* ...and choose new backoff */
if(backoff < 0) {
if (backoff < 0) {
backoff *= -1;
}
@ -204,8 +204,8 @@ cycle:
cs_hwtimer_id = hwtimer_set(cs_timeout, /* Set hwtimer to set CS timeout flag */
cs_timeout_cb, NULL);
while(cc1100_cs_read()) { /* Wait until air is free */
if(cs_timeout_flag) {
while (cc1100_cs_read()) { /* Wait until air is free */
if (cs_timeout_flag) {
send_csmaca_calls_cs_timeout++;
#ifndef CSMACA_MAC_AGGRESSIVE_MODE
cc1100_phy_mutex_unlock();
@ -222,12 +222,12 @@ cycle:
cc1100_cs_write_cca(1); /* Air is free now */
cc1100_cs_set_enabled(true);
if(cc1100_cs_read()) {
if (cc1100_cs_read()) {
goto window; /* GDO0 triggers on rising edge, so */
}
/* test once after interrupt is enabled */
if(backoff > 0) {
if (backoff > 0) {
backoff--; /* Decrement backoff counter */
}
@ -238,9 +238,9 @@ cycle:
cs_hwtimer_id = hwtimer_set(total, /* Set hwtimer to set CS timeout flag */
cs_timeout_cb, NULL);
while(!cs_timeout_flag
while (!cs_timeout_flag
|| !cc1100_cs_read_cca()) { /* Wait until timeout is finished */
if(cc1100_cs_read_cca() == 0) { /* Is the air still free? */
if (cc1100_cs_read_cca() == 0) { /* Is the air still free? */
hwtimer_remove(cs_hwtimer_id);
goto window; /* No. Go back to new wait period. */
}
@ -252,7 +252,7 @@ send:
#endif
int res = cc1100_send(address, protocol, priority, payload, payload_len);
if(res < 0) {
if (res < 0) {
collision_count++;
}

68
drivers/cc110x/cc1100.c
View File

@ -85,7 +85,7 @@ static uint8_t pa_table[] = { ///< PATABLE with available output powers
0xCC, ///< + 7 dBm
0xC6, ///< + 9 dBm
0xC3 ///< +10 dBm
}; /* If PATABLE is changed in size, adjust MAX_OUTPUT_POWER definition in CC1100 interface! */
}; /* If PATABLE is changed in size, adjust MAX_OUTPUT_POWER definition in CC1100 interface!*/
static int8_t pa_table_dBm[] = { ///< Values of the PATABLE in dBm
-52,
@ -176,12 +176,12 @@ static bool spi_receive_packet_variable(uint8_t *rxBuffer, uint8_t length)
uint8_t packetLength = 0;
/* Any bytes available in RX FIFO? */
if((cc1100_spi_read_status(CC1100_RXBYTES) & BYTES_IN_RXFIFO)) {
if ((cc1100_spi_read_status(CC1100_RXBYTES) & BYTES_IN_RXFIFO)) {
/* Read length byte (first byte in RX FIFO) */
packetLength = cc1100_spi_read_reg(CC1100_RXFIFO);
/* Read data from RX FIFO and store in rxBuffer */
if(packetLength <= length) {
if (packetLength <= length) {
/* Put length byte at first position in RX Buffer */
rxBuffer[0] = packetLength;
@ -197,7 +197,7 @@ static bool spi_receive_packet_variable(uint8_t *rxBuffer, uint8_t length)
/* MSB of LQI is the CRC_OK bit */
rflags.CRC_STATE = (status[I_LQI] & CRC_OK) >> 7;
if(!rflags.CRC_STATE) {
if (!rflags.CRC_STATE) {
cc1100_statistic.packets_in_crc_fail++;
}
@ -221,7 +221,7 @@ bool cc1100_spi_receive_packet(uint8_t *rxBuffer, uint8_t length)
{
uint8_t pkt_len_cfg = cc1100_spi_read_reg(CC1100_PKTCTRL0) & PKT_LENGTH_CONFIG;
if(pkt_len_cfg == VARIABLE_PKTLEN) {
if (pkt_len_cfg == VARIABLE_PKTLEN) {
return spi_receive_packet_variable(rxBuffer, length);
}
@ -236,7 +236,7 @@ bool cc1100_spi_receive_packet(uint8_t *rxBuffer, uint8_t length)
void cc1100_set_idle(void)
{
if(radio_state == RADIO_WOR) {
if (radio_state == RADIO_WOR) {
/* Wake up the chip from WOR/sleep */
cc110x_spi_select();
hwtimer_wait(RTIMER_TICKS(122));
@ -253,7 +253,7 @@ void cc1100_set_idle(void)
static void wakeup_from_rx(void)
{
if(radio_state != RADIO_RX) {
if (radio_state != RADIO_RX) {
return;
}
@ -279,7 +279,7 @@ static void setup_rx_mode(void)
*/
static void wakeup_from_wor(void)
{
if(radio_state != RADIO_WOR) {
if (radio_state != RADIO_WOR) {
return;
}
@ -304,7 +304,7 @@ void switch_to_wor2(void)
cc1100_wor_config.rx_time_reg); /* Configure RX_TIME (for use in WOR) */
cc1100_spi_write_reg(CC1100_MCSM0, 0x18); /* Turn on FS-Autocal */
if(rflags.WOR_RST) {
if (rflags.WOR_RST) {
cc1100_spi_strobe(CC1100_SWORRST); /* Resets the real time clock */
rflags.WOR_RST = false;
}
@ -320,7 +320,7 @@ static void hwtimer_switch_to_wor2_wrapper(void *ptr)
{
wor_hwtimer_id = -1; /* kernel timer handler function called, clear timer id */
if(rflags.TX) {
if (rflags.TX) {
return; /* Stability: don't allow WOR timers at this point */
}
@ -334,13 +334,13 @@ static void hwtimer_switch_to_wor2_wrapper(void *ptr)
static void switch_to_wor(void)
{
/* Any incoming packet? */
if(cc110x_get_gdo2()) {
if (cc110x_get_gdo2()) {
/* Then don't go to WOR now */
return;
}
/* Step 1: Set chip for random interval (1..RX_INTERVAL) to power down mode */
if(!rflags.MAN_WOR) {
if (!rflags.MAN_WOR) {
rflags.MAN_WOR = true;
radio_state = RADIO_WOR;
/* Go to power down mode */
@ -351,7 +351,7 @@ static void switch_to_wor(void)
int r = (rand() / (double)(RAND_MAX + 1.0)) * (cc1100_wor_config.rx_interval * 100.0) + 20;
wor_hwtimer_id = hwtimer_set(r, cc1100_hwtimer_go_receive_wrapper, NULL);
if(wor_hwtimer_id == -1) {
if (wor_hwtimer_id == -1) {
rflags.KT_RES_ERR = true;
/* No hwtimer available, go immediately to WOR mode. */
/* Else never receiving packets again... */
@ -370,7 +370,7 @@ static void switch_to_wor(void)
wor_hwtimer_id = hwtimer_set((cc1100_wor_config.rx_time_ms * 100 + 150),
hwtimer_switch_to_wor2_wrapper, NULL); /* add 1,5 ms secure time */
if(wor_hwtimer_id == -1) {
if (wor_hwtimer_id == -1) {
rflags.KT_RES_ERR = true;
}
}
@ -428,7 +428,7 @@ static bool cc1100_set_mode0(uint8_t mode, uint16_t opt_mode_data)
result = cc1100_phy_calc_wor_settings(opt_mode_data);
/* If settings can be applied, set new mode and burst count */
if(result != -1) {
if (result != -1) {
radio_mode = mode;
cc1100_go_idle = wakeup_from_wor;
cc1100_go_receive = switch_to_wor;
@ -469,7 +469,7 @@ bool cc1100_set_mode(uint8_t mode, uint16_t opt_mode_data)
bool result = cc1100_set_mode0(mode, opt_mode_data);
/* If mode change was successful (mode is valid) */
if(result) {
if (result) {
/* Setup new mode configuration */
cc1100_setup_mode();
/* Reset statistics */
@ -535,11 +535,11 @@ void cc1100_hwtimer_go_receive_wrapper(void *ptr)
wor_hwtimer_id = -1;
/* Stability: don't allow WOR timers at this point */
if(rflags.TX) {
if (rflags.TX) {
return;
}
if(radio_state == RADIO_PWD) {
if (radio_state == RADIO_PWD) {
/* Go to RX state, listen for packets as long as WOR_TIMEOUT_2 */
cc1100_spi_strobe(CC1100_SRX);
hwtimer_wait(IDLE_TO_RX_TIME);
@ -547,7 +547,7 @@ void cc1100_hwtimer_go_receive_wrapper(void *ptr)
/* Set hwtimer to put CC1100 back to WOR after WOR_TIMEOUT_2 */
wor_hwtimer_id = hwtimer_set(WOR_TIMEOUT_2, cc1100_hwtimer_go_receive_wrapper, NULL);
if(wor_hwtimer_id == -1) {
if (wor_hwtimer_id == -1) {
rflags.KT_RES_ERR = true;
/* No hwtimer available, go immediately to WOR mode. */
/* Else never receiving packets again... */
@ -594,7 +594,7 @@ void cc1100_send_raw(uint8_t *tx_buffer, uint8_t size)
/* or equal to PACKET_LENGTH (62 bytes). So the receiver */
/* can put the whole packet in its RX-FIFO (with appended */
/* packet status bytes). */
if(size > PACKET_LENGTH) {
if (size > PACKET_LENGTH) {
return;
}
@ -613,10 +613,10 @@ void cc1100_send_raw(uint8_t *tx_buffer, uint8_t size)
cc1100_spi_strobe(CC1100_STX);
/* Wait for GDO2 to be set -> sync word transmitted */
while(cc110x_get_gdo2() == 0) {
while (cc110x_get_gdo2() == 0) {
abort_count++;
if(abort_count > CC1100_SYNC_WORD_TX_TIME) {
if (abort_count > CC1100_SYNC_WORD_TX_TIME) {
/* Abort waiting. CC1100 maybe in wrong mode */
/* e.g. sending preambles for always */
puts("[CC1100 TX] fatal error\n");
@ -627,7 +627,7 @@ void cc1100_send_raw(uint8_t *tx_buffer, uint8_t size)
restoreIRQ(cpsr);
/* Wait for GDO2 to be cleared -> end of packet */
while(cc110x_get_gdo2() != 0);
while (cc110x_get_gdo2() != 0);
/* Experimental - TOF Measurement */
cc110x_after_send();
@ -650,7 +650,7 @@ read_register(uint8_t r)
/* Have to put radio back to WOR/RX if old radio state */
/* was WOR/RX, otherwise no action is necessary */
if(old_state == RADIO_WOR || old_state == RADIO_RX) {
if (old_state == RADIO_WOR || old_state == RADIO_RX) {
cc1100_go_receive();
}
@ -669,7 +669,7 @@ write_register(uint8_t r, uint8_t value)
/* Have to put radio back to WOR/RX if old radio state */
/* was WOR/RX, otherwise no action is necessary */
if(old_state == RADIO_WOR || old_state == RADIO_RX) {
if (old_state == RADIO_WOR || old_state == RADIO_RX) {
cc1100_go_receive();
}
}
@ -688,7 +688,7 @@ uint8_t cc1100_get_channel(void)
bool
cc1100_set_channel(uint8_t channr)
{
if(channr > MAX_CHANNR) {
if (channr > MAX_CHANNR) {
return false;
}
@ -700,7 +700,7 @@ cc1100_set_channel(uint8_t channr)
bool
cc1100_set_output_power(uint8_t pa_idx)
{
if(pa_idx >= sizeof(pa_table)) {
if (pa_idx >= sizeof(pa_table)) {
return false;
}
@ -725,7 +725,7 @@ char *cc1100_get_marc_state(void)
/* Have to put radio back to WOR/RX if old radio state */
/* was WOR/RX, otherwise no action is necessary */
if(old_state == RADIO_WOR || old_state == RADIO_RX) {
if (old_state == RADIO_WOR || old_state == RADIO_RX) {
cc1100_go_receive();
}
@ -840,7 +840,7 @@ void cc1100_init(void)
int cc1100_get_avg_transmission_duration(void)
{
if(radio_mode == CC1100_MODE_WOR) {
if (radio_mode == CC1100_MODE_WOR) {
/* Transmission duration ~ RX interval */
/* Double value because of MAC delay. */
return 2 * cc1100_wor_config.rx_interval;
@ -859,13 +859,13 @@ radio_address_t cc1100_get_address(void)
bool cc1100_set_address(radio_address_t address)
{
if(address < MIN_UID || address > MAX_UID) {
if (address < MIN_UID || address > MAX_UID) {
return false;
}
uint8_t id = (uint8_t) address;
if(radio_state != RADIO_UNKNOWN) {
if (radio_state != RADIO_UNKNOWN) {
write_register(CC1100_ADDR, id);
}
@ -879,7 +879,7 @@ rd_set_mode(int mode)
int result;
/* Get current radio mode */
if(radio_state == RADIO_UNKNOWN || radio_state == RADIO_PWD) {
if (radio_state == RADIO_UNKNOWN || radio_state == RADIO_PWD) {
result = RADIO_MODE_OFF;
}
else {
@ -917,7 +917,7 @@ void cc1100_cs_init(void)
{
cc1100_go_idle(); /* Wake CC1100 up from Wake-On-Radio mode */
if(radio_state == RADIO_RX) { /* If radio in RX mode */
if (radio_state == RADIO_RX) { /* If radio in RX mode */
cc1100_spi_strobe(CC1100_SIDLE); /* Go back to IDLE for calibration */
}
@ -932,7 +932,7 @@ void cc1100_cs_init(void)
void cc1100_cs_set_enabled(bool enabled)
{
if(enabled) {
if (enabled) {
/* Enable carrier sense detection (GDO0 interrupt) */
cc110x_gdo0_enable();
}

2
drivers/cc110x/cc1100.h
View File

@ -272,7 +272,7 @@ bool cc1100_spi_receive_packet(uint8_t *rxBuffer, uint8_t length);
* buffer must match the CC1100 packet format (so address interpretation
* succeeds).
* <p>
* This function is not mode safe! The radio must be woke up before
* This function is not mode safe!The radio must be woke up before
* sending and has to be put back manually to receive mode.
*
* @param tx_buffer Data source buffer.

122
drivers/cc110x/cc1100_phy.c
View File

@ -174,7 +174,7 @@ void cc1100_phy_init()
rx_buffer_size = 0;
/* Initialize RX-Buffer (clear content) */
for(i = 0; i < RX_BUFF_SIZE; i++) {
for (i = 0; i < RX_BUFF_SIZE; i++) {
rx_buffer->packet.length = 0;
}
@ -194,10 +194,10 @@ void cc1100_phy_init()
cc1100_event_handler_function, cc1100_event_handler_name);
/* Active watchdog for the first time */
if(radio_mode == CC1100_MODE_CONSTANT_RX) {
if (radio_mode == CC1100_MODE_CONSTANT_RX) {
cc1100_watch_dog_period.microseconds = CC1100_WATCHDOG_PERIOD;
if(cc1100_watch_dog_period.microseconds != 0) {
if (cc1100_watch_dog_period.microseconds != 0) {
timex_t temp = timex_set(0, 5000000L);
vtimer_set_msg(&cc1100_watch_dog, temp, cc1100_event_handler_pid, NULL);
}
@ -210,7 +210,7 @@ void cc1100_phy_init()
void cc1100_phy_mutex_lock(void)
{
if(active_thread->pid != cc1100_mutex_pid) {
if (active_thread->pid != cc1100_mutex_pid) {
mutex_lock(&cc1100_mutex);
cc1100_mutex_pid = active_thread->pid;
}
@ -274,7 +274,7 @@ void cc1100_print_config(void)
printf("Retransmissions (broadcast): %u - always\r\n", cc1100_retransmission_count_bc);
printf("Output power setting: %s\r\n", cc1100_get_output_power(buf));
if(radio_mode == CC1100_MODE_WOR) {
if (radio_mode == CC1100_MODE_WOR) {
printf("RX polling interval: %u ms\r\n", cc1100_wor_config.rx_interval);
printf("WOR receive time: 0x%.2X (%f ms)\r\n", cc1100_wor_config.rx_time_reg,
cc1100_wor_config.rx_time_ms);
@ -312,7 +312,7 @@ int cc1100_phy_calc_wor_settings(uint16_t millis)
uint16_t event0_min = (uint16_t)(t_packet_interval * 8) + 1 + 10;
/* Check if given value is in allowed range */
if(millis < event0_min || millis > EVENT0_MAX) {
if (millis < event0_min || millis > EVENT0_MAX) {
return -1;
}
@ -323,7 +323,7 @@ int cc1100_phy_calc_wor_settings(uint16_t millis)
/* Calculate new value for EVENT0 */
double tmp = (millis * 26) / (double) 750;
if(wor_res == 1) {
if (wor_res == 1) {
tmp /= 32;
}
@ -334,22 +334,22 @@ int cc1100_phy_calc_wor_settings(uint16_t millis)
int i;
double rx_timeouts[DUTY_CYCLE_SIZE];
for(i = 0; i < DUTY_CYCLE_SIZE; i++) {
for (i = 0; i < DUTY_CYCLE_SIZE; i++) {
rx_timeouts[i] = (millis * duty_cycle[wor_res][i]) / 100;
}
/* Calculate index for optimal rx_timeout (MCSM2.RX_TIME) (if possible) */
int idx = -1;
for(i = DUTY_CYCLE_SIZE - 1; i >= 0; i--) {
if(rx_timeouts[i] > t_packet_interval) {
for (i = DUTY_CYCLE_SIZE - 1; i >= 0; i--) {
if (rx_timeouts[i] > t_packet_interval) {
idx = i;
break;
}
}
/* If no index found, exit here (configuration with given value is not possible) */
if(idx == -1) {
if (idx == -1) {
return -1;
}
@ -381,12 +381,12 @@ static bool contains_seq_entry(uint8_t src, uint8_t id)
vtimer_now(&now_timex);
uint64_t now = now_timex.microseconds;
for(i = 0; i < MAX_SEQ_BUFFER_SIZE; i++) {
if((seq_buffer[i].source == src) && (seq_buffer[i].identification == id)) {
for (i = 0; i < MAX_SEQ_BUFFER_SIZE; i++) {
if ((seq_buffer[i].source == src) && (seq_buffer[i].identification == id)) {
/* Check if time stamp is OK */
cmp = (radio_mode == CC1100_MODE_WOR) ? cc1100_wor_config.rx_interval : 16000; /* constant RX ~16ms */
if((now - seq_buffer[i].m_ticks) <= cmp) {
if ((now - seq_buffer[i].m_ticks) <= cmp) {
return true;
}
else {
@ -405,8 +405,8 @@ static void add_seq_entry(uint8_t src, uint8_t id)
* lost (especially important in constant RX mode). */
int i;
for(i = 0; i < MAX_SEQ_BUFFER_SIZE; i++) {
if(seq_buffer[i].source == src) {
for (i = 0; i < MAX_SEQ_BUFFER_SIZE; i++) {
if (seq_buffer[i].source == src) {
seq_buffer[i].source = 0; /* Reset */
}
}
@ -425,7 +425,7 @@ static void add_seq_entry(uint8_t src, uint8_t id)
seq_buffer_pos++;
if(seq_buffer_pos == MAX_SEQ_BUFFER_SIZE) {
if (seq_buffer_pos == MAX_SEQ_BUFFER_SIZE) {
seq_buffer_pos = 0;
}
}
@ -442,7 +442,7 @@ static void send_link_level_ack(uint8_t dest)
radio_state = RADIO_SEND_ACK; /* Set state to "Sending ACK" */
cc1100_spi_write_reg(CC1100_MCSM0, 0x08); /* Turn off FS-Autocal */
cc1100_spi_write_reg(CC1100_MCSM1, 0x00); /* TX_OFFMODE = IDLE */
ack.length = 3; /* possible packet in txBuffer! */
ack.length = 3; /* possible packet in txBuffer!*/
ack.address = dest;
ack.phy_src = rflags.RSSI;
ack.flags = (LAYER_1_PROTOCOL_LL_ACK << 1);
@ -460,7 +460,7 @@ static bool send_burst(cc1100_packet_layer0_t *packet, uint8_t retries, uint8_t
radio_state = RADIO_SEND_BURST;
rflags.LL_ACK = false;
for(i = 1; i <= cc1100_burst_count; i++) {
for (i = 1; i <= cc1100_burst_count; i++) {
/*
* Number of bytes to send is:
* length of phy payload (packet->length)
@ -475,7 +475,7 @@ static bool send_burst(cc1100_packet_layer0_t *packet, uint8_t retries, uint8_t
/* Delay until predefined "send" interval has passed */
timer_tick_t now = hwtimer_now();
if(t > now) {
if (t > now) {
hwtimer_wait(t - now);
}
@ -486,7 +486,7 @@ static bool send_burst(cc1100_packet_layer0_t *packet, uint8_t retries, uint8_t
* have the broadcast address at startup and would stop the burst
* by sending an ACK).
*/
if(rflags.LL_ACK && packet->address != CC1100_BROADCAST_ADDRESS) {
if (rflags.LL_ACK && packet->address != CC1100_BROADCAST_ADDRESS) {
cc1100_statistic.raw_packets_out_acked += i;
break;
}
@ -496,7 +496,7 @@ static bool send_burst(cc1100_packet_layer0_t *packet, uint8_t retries, uint8_t
* Note: Event broadcast packets can be sent repeatedly if in
* constant RX mode. In WOR mode it is not necessary, so
* set retry count to zero.*/
if(!rflags.LL_ACK && retries > 0) {
if (!rflags.LL_ACK && retries > 0) {
return send_burst(packet, retries - 1, rtc + 1);
}
@ -504,7 +504,7 @@ static bool send_burst(cc1100_packet_layer0_t *packet, uint8_t retries, uint8_t
rflags.RETC = rtc;
rflags.RPS = rtc * cc1100_burst_count + i;
if(i > cc1100_burst_count) {
if (i > cc1100_burst_count) {
rflags.RPS--;
}
@ -516,7 +516,7 @@ static bool send_burst(cc1100_packet_layer0_t *packet, uint8_t retries, uint8_t
/* Burst from any other node is definitely over */
last_seq_num = 0;
if(packet->address != CC1100_BROADCAST_ADDRESS && !rflags.LL_ACK) {
if (packet->address != CC1100_BROADCAST_ADDRESS && !rflags.LL_ACK) {
return false;
}
@ -543,24 +543,24 @@ int cc1100_send(radio_address_t addr, protocol_t protocol, int priority, char *p
address = addr;
/* Loopback not supported */
if(address == cc1100_get_address()) {
if (address == cc1100_get_address()) {
return_code = RADIO_ADDR_OUT_OF_RANGE;
goto mode_before_final;
}
/* Check address */
if(address > MAX_UID) {
if (address > MAX_UID) {
return_code = RADIO_ADDR_OUT_OF_RANGE;
goto mode_before_final;
}
/* Packet too long */
if(payload_len > MAX_DATA_LENGTH) {
if (payload_len > MAX_DATA_LENGTH) {
return_code = RADIO_PAYLOAD_TOO_LONG;
goto mode_before_final;
}
if(radio_state == RADIO_PWD) {
if (radio_state == RADIO_PWD) {
return_code = RADIO_WRONG_MODE;
goto mode_before_final;
}
@ -591,10 +591,10 @@ int cc1100_send(radio_address_t addr, protocol_t protocol, int priority, char *p
return_code = result ? payload_len : RADIO_OP_FAILED;
/* Collect statistics */
if(address != CC1100_BROADCAST_ADDRESS) {
if (address != CC1100_BROADCAST_ADDRESS) {
cc1100_statistic.packets_out++;
if(result) {
if (result) {
cc1100_statistic.packets_out_acked++;
}
}
@ -627,7 +627,7 @@ bool cc1100_set_packet_monitor(packet_monitor_t monitor)
int cc1100_set_packet_handler(protocol_t protocol, packet_handler_t handler)
{
if(protocol > 7) {
if (protocol > 7) {
return -1; /* Only 3-bit value allowed */
}
@ -638,27 +638,27 @@ static void cc1100_event_handler_function(void)
{
msg_t m;
while(1) {
if(cc1100_watch_dog_period.microseconds != 0) {
while (1) {
if (cc1100_watch_dog_period.microseconds != 0) {
vtimer_remove(&cc1100_watch_dog);
}
/* Test if any resource error has occurred */
if(rflags.KT_RES_ERR) {
if (rflags.KT_RES_ERR) {
rflags.KT_RES_ERR = false;
/* possibly do something, e.g. log error condition */
}
if(m.type == MSG_TIMER) {
if (m.type == MSG_TIMER) {
uint8_t state;
if(radio_mode == CC1100_MODE_CONSTANT_RX) {
if (radio_mode == CC1100_MODE_CONSTANT_RX) {
state = cc1100_spi_read_status(CC1100_MARCSTATE) & MARC_STATE;
if((state < 13 || state > 15) && radio_state == RADIO_RX && !rflags.TX) {
if ((state < 13 || state > 15) && radio_state == RADIO_RX && !rflags.TX) {
cc1100_statistic.watch_dog_resets++;
if(state != 1) {
if (state != 1) {
cc1100_spi_strobe(CC1100_SIDLE);
}
@ -672,11 +672,11 @@ static void cc1100_event_handler_function(void)
}
}
while(rx_buffer_size > 0) {
while (rx_buffer_size > 0) {
rx_buffer_t *packet = &rx_buffer[rx_buffer_head];
protocol_t p = R_FLAGS_PROTOCOL(packet->packet.flags);
if(packet_monitor != NULL) {
if (packet_monitor != NULL) {
packet_monitor((void *)&packet->packet.data, packet->packet.length, p, &packet->info);
}
@ -685,7 +685,7 @@ static void cc1100_event_handler_function(void)
rx_buffer_size--;
rx_buffer_head++;
if(rx_buffer_head == RX_BUFF_SIZE) {
if (rx_buffer_head == RX_BUFF_SIZE) {
rx_buffer_head = 0;
}
@ -694,8 +694,8 @@ static void cc1100_event_handler_function(void)
dINT();
if(rx_buffer_size == 0) {
if(cc1100_watch_dog_period.microseconds != 0) {
if (rx_buffer_size == 0) {
if (cc1100_watch_dog_period.microseconds != 0) {
timex_t temp = timex_set(0, cc1100_watch_dog_period.microseconds * 1000000L);
vtimer_set_msg(&cc1100_watch_dog, temp,
cc1100_event_handler_pid, NULL);
@ -725,7 +725,7 @@ void cc1100_phy_rx_handler(void)
cc1100_statistic.packets_in++;
/* If WOR timer set, delete it now (new one will be set at end of ISR) */
if(wor_hwtimer_id != -1) {
if (wor_hwtimer_id != -1) {
hwtimer_remove(wor_hwtimer_id);
wor_hwtimer_id = -1;
}
@ -733,7 +733,7 @@ void cc1100_phy_rx_handler(void)
/* Transfer packet into temporary buffer position */
res = cc1100_spi_receive_packet((uint8_t *) & (rx_buffer[rx_buffer_tail].packet), sizeof(cc1100_packet_layer0_t));
if(res) {
if (res) {
/* Get packet pointer and store additional data in packet info structure */
cc1100_packet_layer0_t *p = &(rx_buffer[rx_buffer_tail].packet);
rx_buffer[rx_buffer_tail].info.phy_src = p->phy_src;
@ -749,9 +749,9 @@ void cc1100_phy_rx_handler(void)
/* If received packet was an ACK (here we must be in
* TX lock state, otherwise we don't expect an ACK) */
if(protocol == LAYER_1_PROTOCOL_LL_ACK && rflags.TX) {
if (protocol == LAYER_1_PROTOCOL_LL_ACK && rflags.TX) {
/* And packet was for us */
if(p->address == cc1100_get_address()) {
if (p->address == cc1100_get_address()) {
/* Stop the burst */
rflags.LL_ACK = true;
rflags.RSSI_SEND = p->phy_src;
@ -768,14 +768,14 @@ void cc1100_phy_rx_handler(void)
/* If we are sending a burst, don't accept packets.
* Only ACKs are processed (for stopping the burst).
* Same if state machine is in TX lock. */
if(radio_state == RADIO_SEND_BURST || rflags.TX) {
if (radio_state == RADIO_SEND_BURST || rflags.TX) {
cc1100_statistic.packets_in_while_tx++;
return;
}
/* If buffer is currently full -> don't check sequence numbers, send
* ACK and restore state (keep always one position free for temporary packets) */
if(rx_buffer_size >= RX_BUFF_SIZE - 1) {
if (rx_buffer_size >= RX_BUFF_SIZE - 1) {
goto send_ack;
}
@ -788,9 +788,9 @@ void cc1100_phy_rx_handler(void)
dup = true;
/* If new and last sequence number are the same, then discard packet */
if(last_seq_num != new_seq_num) {
if (last_seq_num != new_seq_num) {
/* Do a more precise check (takes more time) with larger buffer */
if(!contains_seq_entry(p->phy_src, identification)) {
if (!contains_seq_entry(p->phy_src, identification)) {
/* Sequence number is new, no duplicate packet */
dup = false;
@ -800,13 +800,13 @@ void cc1100_phy_rx_handler(void)
/* Make temporary packet in RX buffer to a "real" packet which is processed */
rx_buffer_size++;
if(rx_buffer_size > cc1100_statistic.rx_buffer_max) {
if (rx_buffer_size > cc1100_statistic.rx_buffer_max) {
cc1100_statistic.rx_buffer_max = rx_buffer_size;
}
rx_buffer_tail++;
if(rx_buffer_tail == RX_BUFF_SIZE) {
if (rx_buffer_tail == RX_BUFF_SIZE) {
rx_buffer_tail = 0;
}
@ -822,8 +822,8 @@ void cc1100_phy_rx_handler(void)
send_ack:
/* If packet was send directly to us, send an ACK packet back to sender.
* But only not if the packet itself was a LL-ACK! */
if(p->address == cc1100_get_address() && protocol != LAYER_1_PROTOCOL_LL_ACK) {
* But only not if the packet itself was a LL-ACK!*/
if (p->address == cc1100_get_address() && protocol != LAYER_1_PROTOCOL_LL_ACK) {
send_link_level_ack(p->phy_src);
/* After LL-ACK burst is over, reset number */
@ -831,13 +831,13 @@ void cc1100_phy_rx_handler(void)
}
/* If duplicate packet detected, clear rxBuffer position */
if(dup) {
if (dup) {
cc1100_statistic.packets_in_dups++;
}
/* If packet interrupted this nodes send call,
* don't change anything after this point. */
if(radio_state == RADIO_AIR_FREE_WAITING) {
if (radio_state == RADIO_AIR_FREE_WAITING) {
cc1100_spi_strobe(CC1100_SRX);
hwtimer_wait(IDLE_TO_RX_TIME);
return;
@ -849,7 +849,7 @@ void cc1100_phy_rx_handler(void)
cc1100_spi_write_reg(CC1100_MCSM0, 0x08); * Turn off FS-Autocal
cc1100_spi_write_reg(CC1100_MCSM2, 0x07); /* Configure RX_TIME (until end of packet) */
if(radio_mode == CC1100_MODE_CONSTANT_RX) {
if (radio_mode == CC1100_MODE_CONSTANT_RX) {
cc1100_spi_strobe(CC1100_SRX);
hwtimer_wait(IDLE_TO_RX_TIME);
radio_state = RADIO_RX;
@ -864,7 +864,7 @@ void cc1100_phy_rx_handler(void)
/* Set hwtimer to put CC1100 back to RX after WOR_TIMEOUT_1 */
wor_hwtimer_id = hwtimer_set(WOR_TIMEOUT_1, cc1100_hwtimer_go_receive_wrapper, NULL);
if(wor_hwtimer_id == -1) {
if (wor_hwtimer_id == -1) {
/* Signal hwtimer resource error, radio stays in RX,
* so no big problem, only energy is wasted. */
rflags.KT_RES_ERR = true;
@ -881,14 +881,14 @@ void cc1100_phy_rx_handler(void)
/* If packet interrupted this nodes send call,
* don't change anything after this point. */
if(radio_state == RADIO_AIR_FREE_WAITING) {
if (radio_state == RADIO_AIR_FREE_WAITING) {
cc1100_spi_strobe(CC1100_SRX);
hwtimer_wait(IDLE_TO_RX_TIME);
return;
}
/* If currently sending, exit here (don't go to RX/WOR) */
if(radio_state == RADIO_SEND_BURST) {
if (radio_state == RADIO_SEND_BURST) {
cc1100_statistic.packets_in_while_tx++;
return;
}

4
drivers/cc110x/cc1100_spi.c
View File

@ -64,7 +64,7 @@ cc1100_spi_writeburst_reg(uint8_t addr, char *src, uint8_t count)
cc110x_spi_select();
cc110x_txrx(addr | CC1100_WRITE_BURST);
while(i < count) {
while (i < count) {
cc110x_txrx(src[i]);
i++;
}
@ -82,7 +82,7 @@ cc1100_spi_readburst_reg(uint8_t addr, char *buffer, uint8_t count)
cc110x_spi_select();
cc110x_txrx(addr | CC1100_READ_BURST);
while(i < count) {
while (i < count) {
buffer[i] = cc110x_txrx(NOBYTE);
i++;
}

30
drivers/cc110x_ng/cc110x-rx.c
View File

@ -55,11 +55,11 @@ void cc110x_rx_handler(void)
res = receive_packet((uint8_t *)&(cc110x_rx_buffer[rx_buffer_next].packet), sizeof(cc110x_packet_t));
if(res) {
if (res) {
/* If we are sending a burst, don't accept packets.
* Only ACKs are processed (for stopping the burst).
* Same if state machine is in TX lock. */
if(radio_state == RADIO_SEND_BURST || rflags.TX) {
if (radio_state == RADIO_SEND_BURST || rflags.TX) {
cc110x_statistic.packets_in_while_tx++;
return;
}
@ -79,7 +79,7 @@ void cc110x_rx_handler(void)
#ifdef DBG_IGNORE
if(is_ignored(cc110x_rx_buffer[rx_buffer_next].packet.phy_src)) {
if (is_ignored(cc110x_rx_buffer[rx_buffer_next].packet.phy_src)) {
LED_RED_TOGGLE;
return;
}
@ -87,7 +87,7 @@ void cc110x_rx_handler(void)
#endif
/* notify transceiver thread if any */
if(transceiver_pid) {
if (transceiver_pid) {
msg_t m;
m.type = (uint16_t) RCV_PKT_CC1100;
m.content.value = rx_buffer_next;
@ -95,7 +95,7 @@ void cc110x_rx_handler(void)
}
/* shift to next buffer element */
if(++rx_buffer_next == RX_BUF_SIZE) {
if (++rx_buffer_next == RX_BUF_SIZE) {
rx_buffer_next = 0;
}
@ -111,14 +111,14 @@ void cc110x_rx_handler(void)
/* If packet interrupted this nodes send call,
* don't change anything after this point. */
if(radio_state == RADIO_AIR_FREE_WAITING) {
if (radio_state == RADIO_AIR_FREE_WAITING) {
cc110x_strobe(CC1100_SRX);
hwtimer_wait(IDLE_TO_RX_TIME);
return;
}
/* If currently sending, exit here (don't go to RX/WOR) */
if(radio_state == RADIO_SEND_BURST) {
if (radio_state == RADIO_SEND_BURST) {
cc110x_statistic.packets_in_while_tx++;
return;
}
@ -135,12 +135,12 @@ static uint8_t receive_packet_variable(uint8_t *rxBuffer, uint8_t length)
uint8_t packetLength = 0;
/* Any bytes available in RX FIFO? */
if((cc110x_read_status(CC1100_RXBYTES) & BYTES_IN_RXFIFO)) {
if ((cc110x_read_status(CC1100_RXBYTES) & BYTES_IN_RXFIFO)) {
/* Read length byte (first byte in RX FIFO) */
cc110x_read_fifo((char *) &packetLength, 1);
/* Read data from RX FIFO and store in rxBuffer */
if(packetLength <= length) {
if (packetLength <= length) {
/* Put length byte at first position in RX Buffer */
rxBuffer[0] = packetLength;
@ -157,7 +157,7 @@ static uint8_t receive_packet_variable(uint8_t *rxBuffer, uint8_t length)
/* MSB of LQI is the CRC_OK bit */
rflags.CRC_STATE = (status[I_LQI] & CRC_OK) >> 7;
if(!rflags.CRC_STATE) {
if (!rflags.CRC_STATE) {
cc110x_statistic.packets_in_crc_fail++;
}
@ -183,7 +183,7 @@ static uint8_t receive_packet(uint8_t *rxBuffer, uint8_t length)
{
uint8_t pkt_len_cfg = cc110x_read_reg(CC1100_PKTCTRL0) & PKT_LENGTH_CONFIG;
if(pkt_len_cfg == VARIABLE_PKTLEN) {
if (pkt_len_cfg == VARIABLE_PKTLEN) {
return receive_packet_variable(rxBuffer, length);
}
@ -202,11 +202,11 @@ uint8_t cc110x_add_ignored(radio_address_t addr)
{
uint8_t i = 0;
while((i < IGN_MAX) && ignored_addr[i++]) {
while ((i < IGN_MAX) && ignored_addr[i++]) {
printf("i: %hu\n", i);
}
if(i > IGN_MAX) {
if (i > IGN_MAX) {
return 0;
}
@ -218,8 +218,8 @@ static uint8_t is_ignored(radio_address_t addr)
{
uint8_t i;
for(i = 0; i < IGN_MAX; i++) {
if(ignored_addr[i] == addr) {
for (i = 0; i < IGN_MAX; i++) {
if (ignored_addr[i] == addr) {
return 1;
}
}

8
drivers/cc110x_ng/cc110x-tx.c
View File

@ -47,7 +47,7 @@ uint8_t cc110x_send(cc110x_packet_t *packet)
* or equal to PACKET_LENGTH (62 bytes). So the receiver
* can put the whole packet in its RX-FIFO (with appended
* packet status bytes).*/
if(size > PACKET_LENGTH) {
if (size > PACKET_LENGTH) {
return 0;
}
@ -68,10 +68,10 @@ uint8_t cc110x_send(cc110x_packet_t *packet)
cc110x_strobe(CC1100_STX);
/* Wait for GDO2 to be set -> sync word transmitted */
while(cc110x_get_gdo2() == 0) {
while (cc110x_get_gdo2() == 0) {
abort_count++;
if(abort_count > CC1100_SYNC_WORD_TX_TIME) {
if (abort_count > CC1100_SYNC_WORD_TX_TIME) {
/* Abort waiting. CC1100 maybe in wrong mode */
/* e.g. sending preambles for always */
puts("[CC1100 TX] fatal error\n");
@ -82,7 +82,7 @@ uint8_t cc110x_send(cc110x_packet_t *packet)
restoreIRQ(cpsr);
/* Wait for GDO2 to be cleared -> end of packet */
while(cc110x_get_gdo2() != 0);
while (cc110x_get_gdo2() != 0);
/* Experimental - TOF Measurement */

20
drivers/cc110x_ng/cc110x.c
View File

@ -132,13 +132,13 @@ radio_address_t cc110x_get_address()
radio_address_t cc110x_set_address(radio_address_t address)
{
if((address < MIN_UID) || (address > MAX_UID)) {
if ((address < MIN_UID) || (address > MAX_UID)) {
return 0;
}
uint8_t id = (uint8_t) address;
if(radio_state != RADIO_UNKNOWN) {
if (radio_state != RADIO_UNKNOWN) {
write_register(CC1100_ADDR, id);
}
@ -151,7 +151,7 @@ radio_address_t cc110x_set_config_address(radio_address_t address)
{
radio_address_t a = cc110x_set_address(address);
if(a) {
if (a) {
sysconfig.radio_address = a;
}
@ -162,7 +162,7 @@ radio_address_t cc110x_set_config_address(radio_address_t address)
void cc110x_set_monitor(uint8_t mode)
{
if(mode) {
if (mode) {
write_register(CC1100_PKTCTRL1, (0x04));
}
else {
@ -185,7 +185,7 @@ void cc110x_switch_to_rx(void)
void cc110x_wakeup_from_rx(void)
{
if(radio_state != RADIO_RX) {
if (radio_state != RADIO_RX) {
return;
}
@ -210,7 +210,7 @@ char *cc110x_get_marc_state(void)
/* Have to put radio back to WOR/RX if old radio state
* was WOR/RX, otherwise no action is necessary */
if(old_state == RADIO_WOR || old_state == RADIO_RX) {
if (old_state == RADIO_WOR || old_state == RADIO_RX) {
cc110x_switch_to_rx();
}
@ -320,7 +320,7 @@ int16_t cc110x_set_channel(uint8_t channr)
{
uint8_t state = cc110x_read_status(CC1100_MARCSTATE) & MARC_STATE;
if((state != 1) && (channr > MAX_CHANNR)) {
if ((state != 1) && (channr > MAX_CHANNR)) {
return -1;
}
@ -334,7 +334,7 @@ int16_t cc110x_set_config_channel(uint8_t channr)
{
int16_t c = cc110x_set_channel(channr);
if(c) {
if (c) {
sysconfig.radio_channel = c;
}
@ -386,7 +386,7 @@ static void write_register(uint8_t r, uint8_t value)
/* Have to put radio back to WOR/RX if old radio state
* was WOR/RX, otherwise no action is necessary */
if((old_state == RADIO_WOR) || (old_state == RADIO_RX)) {
if ((old_state == RADIO_WOR) || (old_state == RADIO_RX)) {
cc110x_switch_to_rx();
}
}
@ -396,7 +396,7 @@ static int rd_set_mode(int mode)
int result;
/* Get current radio mode */
if((radio_state == RADIO_UNKNOWN) || (radio_state == RADIO_PWD)) {
if ((radio_state == RADIO_UNKNOWN) || (radio_state == RADIO_PWD)) {
result = RADIO_MODE_OFF;
}
else {

4
drivers/cc110x_ng/spi/cc110x_spi.c
View File

@ -65,7 +65,7 @@ uint8_t cc110x_writeburst_reg(uint8_t addr, char *src, uint8_t count)
cc110x_spi_select();
cc110x_txrx(addr | CC1100_WRITE_BURST);
while(i < count) {
while (i < count) {
cc110x_txrx(src[i]);
i++;
}
@ -82,7 +82,7 @@ void cc110x_readburst_reg(uint8_t addr, char *buffer, uint8_t count)
cc110x_spi_select();
cc110x_txrx(addr | CC1100_READ_BURST);
while(i < count) {
while (i < count) {
buffer[i] = cc110x_txrx(NOBYTE);
i++;
}

2
drivers/ltc4150/ltc4150.c
View File

@ -121,7 +121,7 @@ void __attribute__((__no_instrument_function__)) ltc4150_interrupt(void)
{
uint32_t now = hwtimer_now();
if(now >= last_int_time) {
if (now >= last_int_time) {
last_int_duration = now - last_int_time;
}
else {

30
drivers/sht11/sht11.c
View File

@ -116,8 +116,8 @@ static uint8_t write_byte(uint8_t value)
SHT11_DATA_OUT;
/* send value bit by bit to sht11 */
for(i = 0; i < 8; i++) {
if(value & BIT7) {
for (i = 0; i < 8; i++) {
if (value & BIT7) {
SHT11_DATA_HIGH;
hwtimer_wait(SHT11_DATA_WAIT);
}
@ -152,12 +152,12 @@ static uint8_t read_byte(uint8_t ack)
hwtimer_wait(SHT11_DATA_WAIT);
/* read value bit by bit */
for(i = 0; i < 8; i++) {
for (i = 0; i < 8; i++) {
value = value << 1;
SHT11_SCK_HIGH;
hwtimer_wait(SHT11_CLK_WAIT);
if(SHT11_DATA) {
if (SHT11_DATA) {
/* increase data by one when DATA is high */
value++;
}
@ -169,7 +169,7 @@ static uint8_t read_byte(uint8_t ack)
/* send ack if necessary */
SHT11_DATA_OUT;
if(ack) {
if (ack) {
SHT11_DATA_LOW;
hwtimer_wait(SHT11_DATA_WAIT);
}
@ -233,7 +233,7 @@ static void connection_reset(void)
SHT11_SCK_LOW;
hwtimer_wait(SHT11_CLK_WAIT);
for(i = 0; i < 9; i++) {
for (i = 0; i < 9; i++) {
clk_signal();
}
@ -252,10 +252,10 @@ static uint8_t measure(uint8_t *p_value, uint8_t *p_checksum, uint8_t mode)
hwtimer_wait(HWTIMER_TICKS(1000));
/* wait untile sensor has finished measurement or timeout */
for(i = 0; (i < SHT11_MEASURE_TIMEOUT) && (!error); i++) {
for (i = 0; (i < SHT11_MEASURE_TIMEOUT) && (!error); i++) {
ack = SHT11_DATA;
if(!ack) {
if (!ack) {
break;
}
@ -326,7 +326,7 @@ uint8_t sht11_read_sensor(sht11_val_t *value, sht11_mode_t mode)
const float T2 = +0.00008;
/* check for valid buffer */
if(value == NULL) {
if (value == NULL) {
return 0;
}
@ -338,30 +338,30 @@ uint8_t sht11_read_sensor(sht11_val_t *value, sht11_mode_t mode)
connection_reset();
/* measure humidity */
if(mode & HUMIDITY) {
if (mode & HUMIDITY) {
error += (!measure((uint8_t *) &humi_int, &checksum, SHT11_MEASURE_HUMI));
}
/* measure temperature */
if(mode & TEMPERATURE) {
if (mode & TEMPERATURE) {
error += (!measure((uint8_t *) &temp_int, &checksum, SHT11_MEASURE_TEMP));
}
/* break on error */
if(error != 0) {
if (error != 0) {
connection_reset();
mutex_unlock(&sht11_mutex, 0);
return 0;
}
if(mode & TEMPERATURE) {
if (mode & TEMPERATURE) {
value->temperature = D1 + (D2 * ((float) temp_int)) + sht11_temperature_offset;
}
if(mode & HUMIDITY) {
if (mode & HUMIDITY) {
value->relhum = C1 + (C2 * ((float) humi_int)) + (C3 * ((float) humi_int) * ((float) humi_int));
if(mode & TEMPERATURE) {
if (mode & TEMPERATURE) {
value->relhum_temp = (value->temperature - 25) * (T1 + (T2 * (float) humi_int)) + value->relhum;
}
}

14
sys/chardev_thread.c
View File

@ -30,7 +30,7 @@
static int min(int a, int b)
{
if(b > a) {
if (b > a) {
return a;
}
else {
@ -49,15 +49,15 @@ void chardev_loop(ringbuffer_t *rb)
puts("UART0 thread started.");
while(1) {
while (1) {
msg_receive(&m);
if(m.sender_pid != pid) {
if (m.sender_pid != pid) {
DEBUG("Receiving message from another thread\n");
switch(m.type) {
case OPEN:
if(reader_pid == -1) {
if (reader_pid == -1) {
reader_pid = m.sender_pid;
/* no error */
m.content.value = 0;
@ -70,7 +70,7 @@ void chardev_loop(ringbuffer_t *rb)
break;
case READ:
if(m.sender_pid != reader_pid) {
if (m.sender_pid != reader_pid) {
m.content.value = -EINVAL;
r = NULL;
msg_reply(&m, &m);
@ -82,7 +82,7 @@ void chardev_loop(ringbuffer_t *rb)
break;
case CLOSE:
if(m.sender_pid == reader_pid) {
if (m.sender_pid == reader_pid) {
DEBUG("uart0_thread: closing file from %i\n", reader_pid);
reader_pid = -1;
r = NULL;
@ -101,7 +101,7 @@ void chardev_loop(ringbuffer_t *rb)
}
}
if(rb->avail && (r != NULL)) {
if (rb->avail && (r != NULL)) {
int state = disableIRQ();
int nbytes = min(r->nbytes, rb->avail);
DEBUG("uart0_thread [%i]: sending %i bytes received from %i to pid %i\n", pid, nbytes, m.sender_pid, reader_pid);

2
sys/lib/hash_string.c
View File

@ -6,7 +6,7 @@ unsigned long hash_string(unsigned char *str)
unsigned long hash = 5381;
int c;
while((c = *str++)) {
while ((c = *str++)) {
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
}

48
sys/lib/hashtable.c
View File

@ -35,13 +35,13 @@ create_hashtable(uint32_t minsize,
unsigned int pindex, size = primes[0];
/* Check requested hashtable isn't too large */
if(minsize > (1u << 30)) {
if (minsize > (1u << 30)) {
return NULL;
}
/* Enforce size as prime */
for(pindex = 0; pindex < prime_table_length; pindex++) {
if(primes[pindex] > minsize) {
for (pindex = 0; pindex < prime_table_length; pindex++) {
if (primes[pindex] > minsize) {
size = primes[pindex];
break;
}
@ -49,13 +49,13 @@ create_hashtable(uint32_t minsize,
h = (struct hashtable *)malloc(sizeof(struct hashtable));
if(NULL == h) {
if (NULL == h) {
return NULL; /*oom*/
}
h->table = (struct entry **)malloc(sizeof(struct entry *) * size);
if(NULL == h->table) {
if (NULL == h->table) {
free(h); /*oom*/
return NULL;
}
@ -95,7 +95,7 @@ hashtable_expand(struct hashtable *h)
unsigned int newsize, i, index;
/* Check we're not hitting max capacity */
if(h->primeindex == (prime_table_length - 1)) {
if (h->primeindex == (prime_table_length - 1)) {
return 0;
}
@ -103,13 +103,13 @@ hashtable_expand(struct hashtable *h)
newtable = (struct entry **)malloc(sizeof(struct entry *) * newsize);
if(NULL != newtable) {
if (NULL != newtable) {
memset(newtable, 0, newsize * sizeof(struct entry *));
/* This algorithm is not 'stable'. ie. it reverses the list
* when it transfers entries between the tables */
for(i = 0; i < h->tablelength; i++) {
while(NULL != (e = h->table[i])) {
for (i = 0; i < h->tablelength; i++) {
while (NULL != (e = h->table[i])) {
h->table[i] = e->next;
index = indexFor(newsize, e->h);
e->next = newtable[index];
@ -125,7 +125,7 @@ hashtable_expand(struct hashtable *h)
newtable = (struct entry **)
realloc(h->table, newsize * sizeof(struct entry *));
if(NULL == newtable) {
if (NULL == newtable) {
(h->primeindex)--;
return 0;
}
@ -133,11 +133,11 @@ hashtable_expand(struct hashtable *h)
h->table = newtable;
memset(newtable[h->tablelength], 0, newsize - h->tablelength);
for(i = 0; i < h->tablelength; i++) {
for(pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) {
for (i = 0; i < h->tablelength; i++) {
for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) {
index = indexFor(newsize, e->h);
if(index == i) {
if (index == i) {
pE = &(e->next);
}
else {
@ -169,7 +169,7 @@ hashtable_insert(struct hashtable *h, void *k, void *v)
unsigned int index;
struct entry *e;
if(++(h->entrycount) > h->loadlimit) {
if (++(h->entrycount) > h->loadlimit) {
/* Ignore the return value. If expand fails, we should
* still try cramming just this value into the existing table
* -- we may not have memory for a larger table, but one more
@ -179,7 +179,7 @@ hashtable_insert(struct hashtable *h, void *k, void *v)
e = (struct entry *)malloc(sizeof(struct entry));
if(NULL == e) {
if (NULL == e) {
--(h->entrycount); /*oom*/
return 0;
}
@ -203,9 +203,9 @@ hashtable_search(struct hashtable *h, void *k)
index = indexFor(h->tablelength, hashvalue);
e = h->table[index];
while(NULL != e) {
while (NULL != e) {
/* Check hash value to short circuit heavier comparison */
if((hashvalue == e->h) && (h->eqfn(k, e->k))) {
if ((hashvalue == e->h) && (h->eqfn(k, e->k))) {
return e->v;
}
@ -232,9 +232,9 @@ hashtable_remove(struct hashtable *h, void *k)
pE = &(h->table[index]);
e = *pE;
while(NULL != e) {
while (NULL != e) {
/* Check hash value to short circuit heavier comparison */
if((hashvalue == e->h) && (h->eqfn(k, e->k))) {
if ((hashvalue == e->h) && (h->eqfn(k, e->k))) {
*pE = e->next;
h->entrycount--;
v = e->v;
@ -259,11 +259,11 @@ hashtable_destroy(struct hashtable *h, int free_values)
struct entry *e, *f;
struct entry **table = h->table;
if(free_values) {
for(i = 0; i < h->tablelength; i++) {
if (free_values) {
for (i = 0; i < h->tablelength; i++) {
e = table[i];
while(NULL != e) {
while (NULL != e) {
f = e;
e = e->next;
freekey(f->k);
@ -273,10 +273,10 @@ hashtable_destroy(struct hashtable *h, int free_values)
}
}
else {
for(i = 0; i < h->tablelength; i++) {
for (i = 0; i < h->tablelength; i++) {
e = table[i];
while(NULL != e) {
while (NULL != e) {
f = e;
e = e->next;
freekey(f->k);

2
sys/lib/hashtable.h
View File

@ -20,7 +20,7 @@ struct hashtable;
*
* (initialise k and v to suitable values)
*
* if (! hashtable_insert(h,k,v) )
* if (!hashtable_insert(h,k,v) )
* { exit(-1); }
*
* if (NULL == (found = hashtable_search(h,k) ))

12
sys/lib/ringbuffer.c
View File

@ -41,20 +41,20 @@ void ringbuffer_init(ringbuffer_t *rb, char *buffer, unsigned int bufsize)
void rb_add_elements(ringbuffer_t *rb, char *buf, int n)
{
for(int i = 0; i < n; i++) {
for (int i = 0; i < n; i++) {
rb_add_element(rb, buf[i]);
}
}
void rb_add_element(ringbuffer_t *rb, char c)
{
if(rb->avail == rb->size) {
if (rb->avail == rb->size) {
rb_get_element(rb);
}
rb->buf[rb->end++] = c;
if(rb->end >= rb->size) {
if (rb->end >= rb->size) {
rb->end = 0;
}
@ -63,7 +63,7 @@ void rb_add_element(ringbuffer_t *rb, char c)
int rb_get_element(ringbuffer_t *rb)
{
if(rb->avail == 0) {
if (rb->avail == 0) {
return -1;
}
@ -71,7 +71,7 @@ int rb_get_element(ringbuffer_t *rb)
int c = (char)rb->buf[rb->start++];
if(rb->start >= rb->size) {
if (rb->start >= rb->size) {
rb->start = 0;
}
@ -82,7 +82,7 @@ int rb_get_elements(ringbuffer_t *rb, char *buf, int n)
{
int count = 0;
while(rb->avail && (count < n)) {
while (rb->avail && (count < n)) {
buf[count++] = rb_get_element(rb);
}

36
sys/logd/logd.c
View File

@ -52,7 +52,7 @@ static volatile bool echo_on = false;
static void close_file_handle(void)
{
if(fh != NULL) {
if (fh != NULL) {
fclose(fh);
fh = NULL;
}
@ -60,9 +60,9 @@ static void close_file_handle(void)
static void write_to_file(char *str, int str_len)
{
if(fh != NULL && str_len > 0) {
if(fwrite(str, sizeof(char), str_len, fh) != str_len) {
if(echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
if (fh != NULL && str_len > 0) {
if (fwrite(str, sizeof(char), str_len, fh) != str_len) {
if (echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
printf("LOGD [WARN]: file write failed, closing file\n");
}
@ -70,8 +70,8 @@ static void write_to_file(char *str, int str_len)
return;
}
if(fflush(fh) == EOF) {
if(echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
if (fflush(fh) == EOF) {
if (echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
printf("LOGD [WARN]: file write failed, closing file\n");
}
@ -82,8 +82,8 @@ static void write_to_file(char *str, int str_len)
else {
fh = fopen("/LOGD.LOG", "w");
if(!fh) {
if(echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
if (!fh) {
if (echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
printf("LOGD [WARN]: file reopen failed, damn!\n");
}
}
@ -99,16 +99,16 @@ static void logd_process(void)
log_queue_t *node;
do {
if(!exit_flag) {
if (!exit_flag) {
msg_receive(&m);
}
mutex_lock(&log_mutex);
while((node = (log_queue_t *) list_remove_head(&log_msg_queue)) != NULL) {
while ((node = (log_queue_t *) list_remove_head(&log_msg_queue)) != NULL) {
write_to_file(node->str, node->str_len);
if(echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
if (echo_on && logd_stack_size >= LOGD_STACK_SIZE_CONSOLE) {
printf("%s", node->str);
}
@ -119,7 +119,7 @@ static void logd_process(void)
mutex_unlock(&log_mutex, 0);
}
while(m.type != MSG_EXIT && !exit_flag);
while (m.type != MSG_EXIT && !exit_flag);
/* Logging thread is terminating, close log file */
close_file_handle();
@ -131,7 +131,7 @@ static void logd_init0(void)
{
fh = fopen("/LOGD.LOG", "w");
if(!fh) {
if (!fh) {
return;
}
@ -156,11 +156,11 @@ bool logd_log(char *str, int str_len)
msg m;
/* Test if logd process was created */
if(log_pid == -1) {
if (log_pid == -1) {
/* no logd created, because fopen() on log file failed. So try again */
logd_init0();
if(log_pid == -1) {
if (log_pid == -1) {
/* Still errors opening log file, exit now */
return false;
}
@ -168,13 +168,13 @@ bool logd_log(char *str, int str_len)
log_queue_t *lq = malloc(sizeof(*lq));
if(lq == NULL) {
if (lq == NULL) {
return false;
}
lq->str = malloc(sizeof(char) * str_len + 1); /* 1 byte for string termination char */
if(lq->str == NULL) {
if (lq->str == NULL) {
free(lq);
return false;
}
@ -196,7 +196,7 @@ void logd_exit(void)
msg m;
/* Test if logd process was created */
if(log_pid == -1) {
if (log_pid == -1) {
return;
}

214
sys/net/destiny/in.h
View File

@ -15,119 +15,119 @@
/*
* Protocols (RFC 1700)
*/
#define IPPROTO_IP 0 /* dummy for IP */
#define IPPROTO_HOPOPTS 0 /* IP6 hop-by-hop options */
#define IPPROTO_ICMP 1 /* control message protocol */
#define IPPROTO_IGMP 2 /* group mgmt protocol */
#define IPPROTO_GGP 3 /* gateway^2 (deprecated) */
#define IPPROTO_IPV4 4 /* IPv4 encapsulation */
#define IPPROTO_IPIP IPPROTO_IPV4 /* for compatibility */
#define IPPROTO_TCP 6 /* tcp */
#define IPPROTO_ST 7 /* Stream protocol II */
#define IPPROTO_EGP 8 /* exterior gateway protocol */
#define IPPROTO_PIGP 9 /* private interior gateway */
#define IPPROTO_RCCMON 10 /* BBN RCC Monitoring */
#define IPPROTO_NVPII 11 /* network voice protocol*/
#define IPPROTO_PUP 12 /* pup */
#define IPPROTO_ARGUS 13 /* Argus */
#define IPPROTO_EMCON 14 /* EMCON */
#define IPPROTO_XNET 15 /* Cross Net Debugger */
#define IPPROTO_CHAOS 16 /* Chaos*/
#define IPPROTO_UDP 17 /* user datagram protocol */
#define IPPROTO_MUX 18 /* Multiplexing */
#define IPPROTO_MEAS 19 /* DCN Measurement Subsystems */
#define IPPROTO_HMP 20 /* Host Monitoring */
#define IPPROTO_PRM 21 /* Packet Radio Measurement */
#define IPPROTO_IDP 22 /* xns idp */
#define IPPROTO_TRUNK1 23 /* Trunk-1 */
#define IPPROTO_TRUNK2 24 /* Trunk-2 */
#define IPPROTO_LEAF1 25 /* Leaf-1 */
#define IPPROTO_LEAF2 26 /* Leaf-2 */
#define IPPROTO_RDP 27 /* Reliable Data */
#define IPPROTO_IRTP 28 /* Reliable Transaction */
#define IPPROTO_TP 29 /* tp-4 w/ class negotiation */
#define IPPROTO_BLT 30 /* Bulk Data Transfer */
#define IPPROTO_NSP 31 /* Network Services */
#define IPPROTO_INP 32 /* Merit Internodal */
#define IPPROTO_SEP 33 /* Sequential Exchange */
#define IPPROTO_3PC 34 /* Third Party Connect */
#define IPPROTO_IDPR 35 /* InterDomain Policy Routing */
#define IPPROTO_XTP 36 /* XTP */
#define IPPROTO_DDP 37 /* Datagram Delivery */
#define IPPROTO_CMTP 38 /* Control Message Transport */
#define IPPROTO_TPXX 39 /* TP++ Transport */
#define IPPROTO_IL 40 /* IL transport protocol */
#define IPPROTO_IPV6 41 /* IP6 header */
#define IPPROTO_SDRP 42 /* Source Demand Routing */
#define IPPROTO_ROUTING 43 /* IP6 routing header */
#define IPPROTO_FRAGMENT 44 /* IP6 fragmentation header */
#define IPPROTO_IDRP 45 /* InterDomain Routing*/
#define IPPROTO_RSVP 46 /* resource reservation */
#define IPPROTO_GRE 47 /* General Routing Encap. */
#define IPPROTO_MHRP 48 /* Mobile Host Routing */
#define IPPROTO_BHA 49 /* BHA */
#define IPPROTO_ESP 50 /* IP6 Encap Sec. Payload */
#define IPPROTO_AH 51 /* IP6 Auth Header */
#define IPPROTO_INLSP 52 /* Integ. Net Layer Security */
#define IPPROTO_SWIPE 53 /* IP with encryption */
#define IPPROTO_NHRP 54 /* Next Hop Resolution */
#define IPPROTO_IP (0) /* dummy for IP */
#define IPPROTO_HOPOPTS (0) /* IP6 hop-by-hop options */
#define IPPROTO_ICMP (1) /* control message protocol */
#define IPPROTO_IGMP (2) /* group mgmt protocol */
#define IPPROTO_GGP (3) /* gateway^2 (deprecated) */
#define IPPROTO_IPV4 (4) /* IPv4 encapsulation */
#define IPPROTO_IPIP IPPROTO_IPV4 /* for compatibility */
#define IPPROTO_TCP (6) /* tcp */
#define IPPROTO_ST (7) /* Stream protocol II */
#define IPPROTO_EGP (8) /* exterior gateway protocol */
#define IPPROTO_PIGP (9) /* private interior gateway */
#define IPPROTO_RCCMON (10) /* BBN RCC Monitoring */
#define IPPROTO_NVPII (11) /* network voice protocol*/
#define IPPROTO_PUP (12) /* pup */
#define IPPROTO_ARGUS (13) /* Argus */
#define IPPROTO_EMCON (14) /* EMCON */
#define IPPROTO_XNET (15) /* Cross Net Debugger */
#define IPPROTO_CHAOS (16) /* Chaos*/
#define IPPROTO_UDP (17) /* user datagram protocol */
#define IPPROTO_MUX (18) /* Multiplexing */
#define IPPROTO_MEAS (19) /* DCN Measurement Subsystems */
#define IPPROTO_HMP (20) /* Host Monitoring */
#define IPPROTO_PRM (21) /* Packet Radio Measurement */
#define IPPROTO_IDP (22) /* xns idp */
#define IPPROTO_TRUNK1 (23) /* Trunk-1 */
#define IPPROTO_TRUNK2 (24) /* Trunk-2 */
#define IPPROTO_LEAF1 (25) /* Leaf-1 */
#define IPPROTO_LEAF2 (26) /* Leaf-2 */
#define IPPROTO_RDP (27) /* Reliable Data */
#define IPPROTO_IRTP (28) /* Reliable Transaction */
#define IPPROTO_TP (29) /* tp-4 w/ class negotiation */
#define IPPROTO_BLT (30) /* Bulk Data Transfer */
#define IPPROTO_NSP (31) /* Network Services */
#define IPPROTO_INP (32) /* Merit Internodal */
#define IPPROTO_SEP (33) /* Sequential Exchange */
#define IPPROTO_3PC (34) /* Third Party Connect */
#define IPPROTO_IDPR (35) /* InterDomain Policy Routing */
#define IPPROTO_XTP (36) /* XTP */
#define IPPROTO_DDP (37) /* Datagram Delivery */
#define IPPROTO_CMTP (38) /* Control Message Transport */
#define IPPROTO_TPXX (39) /* TP++ Transport */
#define IPPROTO_IL (40) /* IL transport protocol */
#define IPPROTO_IPV6 (41) /* IP6 header */
#define IPPROTO_SDRP (42) /* Source Demand Routing */
#define IPPROTO_ROUTING (43) /* IP6 routing header */
#define IPPROTO_FRAGMENT (44) /* IP6 fragmentation header */
#define IPPROTO_IDRP (45) /* InterDomain Routing*/
#define IPPROTO_RSVP (46) /* resource reservation */
#define IPPROTO_GRE (47) /* General Routing Encap. */
#define IPPROTO_MHRP (48) /* Mobile Host Routing */
#define IPPROTO_BHA (49) /* BHA */
#define IPPROTO_ESP (50) /* IP6 Encap Sec. Payload */
#define IPPROTO_AH (51) /* IP6 Auth Header */
#define IPPROTO_INLSP (52) /* Integ. Net Layer Security */
#define IPPROTO_SWIPE (53) /* IP with encryption */
#define IPPROTO_NHRP (54) /* Next Hop Resolution */
/* 55-57: Unassigned */
#define IPPROTO_ICMPV6 58 /* ICMP6 */
#define IPPROTO_NONE 59 /* IP6 no next header */
#define IPPROTO_DSTOPTS 60 /* IP6 destination option */
#define IPPROTO_AHIP 61 /* any host internal protocol */
#define IPPROTO_CFTP 62 /* CFTP */
#define IPPROTO_HELLO 63 /* "hello" routing protocol */
#define IPPROTO_SATEXPAK 64 /* SATNET/Backroom EXPAK */
#define IPPROTO_KRYPTOLAN 65 /* Kryptolan */
#define IPPROTO_RVD 66 /* Remote Virtual Disk */
#define IPPROTO_IPPC 67 /* Pluribus Packet Core */
#define IPPROTO_ADFS 68 /* Any distributed FS */
#define IPPROTO_SATMON 69 /* Satnet Monitoring */
#define IPPROTO_VISA 70 /* VISA Protocol */
#define IPPROTO_IPCV 71 /* Packet Core Utility */
#define IPPROTO_CPNX 72 /* Comp. Prot. Net. Executive */
#define IPPROTO_CPHB 73 /* Comp. Prot. HeartBeat */
#define IPPROTO_WSN 74 /* Wang Span Network */
#define IPPROTO_PVP 75 /* Packet Video Protocol */
#define IPPROTO_BRSATMON 76 /* BackRoom SATNET Monitoring */
#define IPPROTO_ND 77 /* Sun net disk proto (temp.) */
#define IPPROTO_WBMON 78 /* WIDEBAND Monitoring */
#define IPPROTO_WBEXPAK 79 /* WIDEBAND EXPAK */
#define IPPROTO_EON 80 /* ISO cnlp */
#define IPPROTO_VMTP 81 /* VMTP */
#define IPPROTO_SVMTP 82 /* Secure VMTP */
#define IPPROTO_VINES 83 /* Banyon VINES */
#define IPPROTO_TTP 84 /* TTP */
#define IPPROTO_IGP 85 /* NSFNET-IGP */
#define IPPROTO_DGP 86 /* dissimilar gateway prot. */
#define IPPROTO_TCF 87 /* TCF */
#define IPPROTO_IGRP 88 /* Cisco/GXS IGRP */
#define IPPROTO_OSPFIGP 89 /* OSPFIGP */
#define IPPROTO_SRPC 90 /* Strite RPC protocol */
#define IPPROTO_LARP 91 /* Locus Address Resoloution */
#define IPPROTO_MTP 92 /* Multicast Transport */
#define IPPROTO_AX25 93 /* AX.25 Frames */
#define IPPROTO_IPEIP 94 /* IP encapsulated in IP */
#define IPPROTO_MICP 95 /* Mobile Int.ing control */
#define IPPROTO_SCCSP 96 /* Semaphore Comm. security */
#define IPPROTO_ETHERIP 97 /* Ethernet IP encapsulation */
#define IPPROTO_ENCAP 98 /* encapsulation header */
#define IPPROTO_APES 99 /* any private encr. scheme */
#define IPPROTO_GMTP 100 /* GMTP*/
#define IPPROTO_IPCOMP 108 /* payload compression (IPComp) */
#define IPPROTO_ICMPV6 (58) /* ICMP6 */
#define IPPROTO_NONE (59) /* IP6 no next header */
#define IPPROTO_DSTOPTS (60) /* IP6 destination option */
#define IPPROTO_AHIP (61) /* any host internal protocol */
#define IPPROTO_CFTP (62) /* CFTP */
#define IPPROTO_HELLO (63) /* "hello" routing protocol */
#define IPPROTO_SATEXPAK (64) /* SATNET/Backroom EXPAK */
#define IPPROTO_KRYPTOLAN (65) /* Kryptolan */
#define IPPROTO_RVD (66) /* Remote Virtual Disk */
#define IPPROTO_IPPC (67) /* Pluribus Packet Core */
#define IPPROTO_ADFS (68) /* Any distributed FS */
#define IPPROTO_SATMON (69) /* Satnet Monitoring */
#define IPPROTO_VISA (70) /* VISA Protocol */
#define IPPROTO_IPCV (71) /* Packet Core Utility */
#define IPPROTO_CPNX (72) /* Comp. Prot. Net. Executive */
#define IPPROTO_CPHB (73) /* Comp. Prot. HeartBeat */
#define IPPROTO_WSN (74) /* Wang Span Network */
#define IPPROTO_PVP (75) /* Packet Video Protocol */
#define IPPROTO_BRSATMON (76) /* BackRoom SATNET Monitoring */
#define IPPROTO_ND (77) /* Sun net disk proto (temp.) */
#define IPPROTO_WBMON (78) /* WIDEBAND Monitoring */
#define IPPROTO_WBEXPAK (79) /* WIDEBAND EXPAK */
#define IPPROTO_EON (80) /* ISO cnlp */
#define IPPROTO_VMTP (81) /* VMTP */
#define IPPROTO_SVMTP (82) /* Secure VMTP */
#define IPPROTO_VINES (83) /* Banyon VINES */
#define IPPROTO_TTP (84) /* TTP */
#define IPPROTO_IGP (85) /* NSFNET-IGP */
#define IPPROTO_DGP (86) /* dissimilar gateway prot. */
#define IPPROTO_TCF (87) /* TCF */
#define IPPROTO_IGRP (88) /* Cisco/GXS IGRP */
#define IPPROTO_OSPFIGP (89) /* OSPFIGP */
#define IPPROTO_SRPC (90) /* Strite RPC protocol */
#define IPPROTO_LARP (91) /* Locus Address Resoloution */
#define IPPROTO_MTP (92) /* Multicast Transport */
#define IPPROTO_AX25 (93) /* AX.25 Frames */
#define IPPROTO_IPEIP (94) /* IP encapsulated in IP */
#define IPPROTO_MICP (95) /* Mobile Int.ing control */
#define IPPROTO_SCCSP (96) /* Semaphore Comm. security */
#define IPPROTO_ETHERIP (97) /* Ethernet IP encapsulation */
#define IPPROTO_ENCAP (98) /* encapsulation header */
#define IPPROTO_APES (99) /* any private encr. scheme */
#define IPPROTO_GMTP (100) /* GMTP*/
#define IPPROTO_IPCOMP (108) /* payload compression (IPComp) */
/* 101-254: Partly Unassigned */
#define IPPROTO_PIM 103 /* Protocol Independent Mcast */
#define IPPROTO_PGM 113 /* PGM */
#define IPPROTO_PIM (103) /* Protocol Independent Mcast */
#define IPPROTO_PGM (113) /* PGM */
/* 255: Reserved */
/* BSD Private, local use, namespace incursion */
#define IPPROTO_DIVERT 254 /* divert pseudo-protocol */
#define IPPROTO_RAW 255 /* raw IP packet */
#define IPPROTO_MAX 256
#define IPPROTO_DIVERT (254) /* divert pseudo-protocol */
#define IPPROTO_RAW (255) /* raw IP packet */
#define IPPROTO_MAX (256)
/* last return value of *_input(), meaning "all job for this pkt is done". */
#define IPPROTO_DONE 257
#define IPPROTO_DONE (257)
#define IN_LOOPBACKNET 127 /* official! */
#define IN_LOOPBACKNET (127) /* official! */
#endif /* IN_H_ */

176
sys/net/destiny/socket.c
View File

@ -147,7 +147,7 @@ void print_internal_socket(socket_internal_t *current_socket_internal)
socket_internal_t *getSocket(uint8_t s)
{
if(exists_socket(s)) {
if (exists_socket(s)) {
return &(sockets[s - 1]);
}
else {
@ -160,8 +160,8 @@ void print_sockets(void)
int i;
printf("\n--- Socket list: ---\n");
for(i = 1; i < MAX_SOCKETS + 1; i++) {
if(getSocket(i) != NULL) {
for (i = 1; i < MAX_SOCKETS + 1; i++) {
if (getSocket(i) != NULL) {
print_internal_socket(getSocket(i));
}
}
@ -169,7 +169,7 @@ void print_sockets(void)
bool exists_socket(uint8_t socket)
{
if(sockets[socket - 1].socket_id == 0) {
if (sockets[socket - 1].socket_id == 0) {
return false;
}
else {
@ -184,7 +184,7 @@ void close_socket(socket_internal_t *current_socket)
bool isUDPSocket(uint8_t s)
{
if((exists_socket(s)) &&
if ((exists_socket(s)) &&
(getSocket(s)->socket_values.domain == PF_INET6) &&
(getSocket(s)->socket_values.type == SOCK_DGRAM) &&
((getSocket(s)->socket_values.protocol == IPPROTO_UDP) ||
@ -198,7 +198,7 @@ bool isUDPSocket(uint8_t s)
bool isTCPSocket(uint8_t s)
{
if((exists_socket(s)) &&
if ((exists_socket(s)) &&
(getSocket(s)->socket_values.domain == PF_INET6) &&
(getSocket(s)->socket_values.type == SOCK_STREAM) &&
((getSocket(s)->socket_values.protocol == IPPROTO_TCP) ||
@ -214,12 +214,12 @@ int bind_udp_socket(int s, sockaddr6_t *name, int namelen, uint8_t pid)
{
int i;
if(!exists_socket(s)) {
if (!exists_socket(s)) {
return -1;
}
for(i = 1; i < MAX_SOCKETS + 1; i++) {
if(isUDPSocket(i) &&
for (i = 1; i < MAX_SOCKETS + 1; i++) {
if (isUDPSocket(i) &&
(getSocket(i)->socket_values.local_address.sin6_port == name->sin6_port)) {
return -1;
}
@ -234,12 +234,12 @@ int bind_tcp_socket(int s, sockaddr6_t *name, int namelen, uint8_t pid)
{
int i;
if(!exists_socket(s)) {
if (!exists_socket(s)) {
return -1;
}
for(i = 1; i < MAX_SOCKETS + 1; i++) {
if(isTCPSocket(i) &&
for (i = 1; i < MAX_SOCKETS + 1; i++) {
if (isTCPSocket(i) &&
(getSocket(i)->socket_values.local_address.sin6_port == name->sin6_port)) {
return -1;
}
@ -255,11 +255,11 @@ int socket(int domain, int type, int protocol)
{
int i = 1;
while(getSocket(i) != NULL) {
while (getSocket(i) != NULL) {
i++;
}
if(i > MAX_SOCKETS + 1) {
if (i > MAX_SOCKETS + 1) {
return -1;
}
else {
@ -277,8 +277,8 @@ socket_internal_t *get_udp_socket(ipv6_hdr_t *ipv6_header, udp_hdr_t *udp_header
{
uint8_t i = 1;
while(i < MAX_SOCKETS + 1) {
if(isUDPSocket(i) &&
while (i < MAX_SOCKETS + 1) {
if (isUDPSocket(i) &&
(getSocket(i)->socket_values.local_address.sin6_port ==
udp_header->dst_port)) {
return getSocket(i);
@ -309,16 +309,16 @@ socket_internal_t *get_tcp_socket(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header
uint8_t compare[16];
memset(compare, 0, 16);
while(i < MAX_SOCKETS + 1) {
while (i < MAX_SOCKETS + 1) {
current_socket = getSocket(i);
/* Check for matching 4 touple, ESTABLISHED connection */
if(isTCPSocket(i) && is_four_touple(current_socket, ipv6_header,
if (isTCPSocket(i) && is_four_touple(current_socket, ipv6_header,
tcp_header)) {
return current_socket;
}
/* Sockets in LISTEN and SYN_RCVD state should only be tested on local TCP values */
else if(isTCPSocket(i) &&
else if (isTCPSocket(i) &&
((current_socket->socket_values.tcp_control.state == LISTEN) ||
(current_socket->socket_values.tcp_control.state == SYN_RCVD)) &&
(current_socket->socket_values.local_address.sin6_addr.uint8[15] ==
@ -344,8 +344,8 @@ uint16_t get_free_source_port(uint8_t protocol)
uint16_t biggest_port = EPHEMERAL_PORTS - 1;
/* Remember biggest ephemeral port number used so far and add 1 */
for(i = 0; i < MAX_SOCKETS; i++) {
if((sockets[i].socket_values.protocol == protocol) &&
for (i = 0; i < MAX_SOCKETS; i++) {
if ((sockets[i].socket_values.protocol == protocol) &&
(sockets[i].socket_values.local_address.sin6_port > biggest_port)) {
biggest_port = sockets[i].socket_values.local_address.sin6_port;
}
@ -382,17 +382,17 @@ void set_tcp_packet(tcp_hdr_t *tcp_hdr, uint16_t src_port, uint16_t dst_port,
/* Check for consistent ACK and SEQ number */
int check_tcp_consistency(socket_t *current_tcp_socket, tcp_hdr_t *tcp_header)
{
if(IS_TCP_ACK(tcp_header->reserved_flags)) {
if(tcp_header->ack_nr > (current_tcp_socket->tcp_control.send_nxt)) {
if (IS_TCP_ACK(tcp_header->reserved_flags)) {
if (tcp_header->ack_nr > (current_tcp_socket->tcp_control.send_nxt)) {
/* ACK of not yet sent byte, discard */
return ACK_NO_TOO_BIG;
}
else if(tcp_header->ack_nr <= (current_tcp_socket->tcp_control.send_una)) {
else if (tcp_header->ack_nr <= (current_tcp_socket->tcp_control.send_una)) {
/* ACK of previous segments, maybe dropped? */
return ACK_NO_TOO_SMALL;
}
}
else if((current_tcp_socket->tcp_control.rcv_nxt > 0) && (tcp_header->seq_nr < current_tcp_socket->tcp_control.rcv_nxt)) {
else if ((current_tcp_socket->tcp_control.rcv_nxt > 0) && (tcp_header->seq_nr < current_tcp_socket->tcp_control.rcv_nxt)) {
/* segment repetition, maybe ACK got lost? */
return SEQ_NO_TOO_SMALL;
}
@ -402,8 +402,8 @@ int check_tcp_consistency(socket_t *current_tcp_socket, tcp_hdr_t *tcp_header)
void switch_tcp_packet_byte_order(tcp_hdr_t *current_tcp_packet)
{
if(current_tcp_packet->dataOffset_reserved * 4 > TCP_HDR_LEN) {
if(*(((uint8_t *)current_tcp_packet) + TCP_HDR_LEN) == TCP_MSS_OPTION) {
if (current_tcp_packet->dataOffset_reserved * 4 > TCP_HDR_LEN) {
if (*(((uint8_t *)current_tcp_packet) + TCP_HDR_LEN) == TCP_MSS_OPTION) {
uint8_t *packet_pointer = (uint8_t *)current_tcp_packet;
packet_pointer += (TCP_HDR_LEN + 2);
uint8_t mss1 = *packet_pointer;
@ -412,7 +412,7 @@ void switch_tcp_packet_byte_order(tcp_hdr_t *current_tcp_packet)
*(packet_pointer + 1) = mss1;
}
if(*(((uint8_t *)current_tcp_packet) + TCP_HDR_LEN) == TCP_TS_OPTION) {
if (*(((uint8_t *)current_tcp_packet) + TCP_HDR_LEN) == TCP_TS_OPTION) {
/* TODO: Timestamp option not implemented */
}
}
@ -429,7 +429,7 @@ int send_tcp(socket_internal_t *current_socket, tcp_hdr_t *current_tcp_packet,
socket_t *current_tcp_socket = &current_socket->socket_values;
uint8_t header_length = TCP_HDR_LEN / 4;
if(IS_TCP_SYN(flags) || IS_TCP_SYN_ACK(flags)) {
if (IS_TCP_SYN(flags) || IS_TCP_SYN_ACK(flags)) {
tcp_mss_option_t current_mss_option;
header_length += sizeof(tcp_mss_option_t) / 4;
@ -464,7 +464,7 @@ int send_tcp(socket_internal_t *current_socket, tcp_hdr_t *current_tcp_packet,
temp_ipv6_header, flags,
payload_length);
if(compressed_size == 0) {
if (compressed_size == 0) {
/* Error in compressing tcp packet header */
return -1;
}
@ -506,7 +506,7 @@ int connect(int socket, sockaddr6_t *addr, uint32_t addrlen)
/* Check if socket exists */
current_int_tcp_socket = getSocket(socket);
if(current_int_tcp_socket == NULL) {
if (current_int_tcp_socket == NULL) {
return -1;
}
@ -558,7 +558,7 @@ int connect(int socket, sockaddr6_t *addr, uint32_t addrlen)
msg_from_server.type = TCP_RETRY;
while(msg_from_server.type == TCP_RETRY) {
while (msg_from_server.type == TCP_RETRY) {
/* Send packet */
send_tcp(current_int_tcp_socket, current_tcp_packet, temp_ipv6_header,
TCP_SYN, 0);
@ -566,7 +566,7 @@ int connect(int socket, sockaddr6_t *addr, uint32_t addrlen)
/* wait for SYN ACK or RETRY */
msg_receive(&msg_from_server);
if(msg_from_server.type == TCP_TIMEOUT) {
if (msg_from_server.type == TCP_TIMEOUT) {
#ifdef TCP_HC
/* We did not send anything successful so restore last context */
memcpy(&current_tcp_socket->tcp_control.tcp_context,
@ -576,7 +576,7 @@ int connect(int socket, sockaddr6_t *addr, uint32_t addrlen)
}
#ifdef TCP_HC
else if(msg_from_server.type == TCP_RETRY) {
else if (msg_from_server.type == TCP_RETRY) {
/* We retry sending a packet so set everything to last values again */
memcpy(&current_tcp_socket->tcp_control.tcp_context,
&saved_tcp_context, sizeof(tcp_hc_context_t));
@ -589,13 +589,13 @@ int connect(int socket, sockaddr6_t *addr, uint32_t addrlen)
tcp_hdr_t *tcp_header = ((tcp_hdr_t *)(msg_from_server.content.ptr));
/* Check for consistency */
if(tcp_header->ack_nr != current_tcp_socket->tcp_control.send_nxt + 1) {
if (tcp_header->ack_nr != current_tcp_socket->tcp_control.send_nxt + 1) {
printf("TCP packets not consistent!\n");
}
/* Got SYN ACK from Server */
/* Refresh foreign TCP socket information */
if((tcp_header->dataOffset_reserved * 4 > TCP_HDR_LEN) &&
if ((tcp_header->dataOffset_reserved * 4 > TCP_HDR_LEN) &&
(*(((uint8_t *)tcp_header) + TCP_HDR_LEN) == TCP_MSS_OPTION)) {
current_tcp_socket->tcp_control.mss =
*((uint16_t *)(((uint8_t *)tcp_header) + TCP_HDR_LEN + 2));
@ -627,7 +627,7 @@ int connect(int socket, sockaddr6_t *addr, uint32_t addrlen)
sizeof(tcp_hc_context_t));
#endif
while(msg_from_server.type != TCP_RETRY) {
while (msg_from_server.type != TCP_RETRY) {
/* Send packet */
send_tcp(current_int_tcp_socket, current_tcp_packet, temp_ipv6_header,
TCP_ACK, 0);
@ -635,13 +635,13 @@ int connect(int socket, sockaddr6_t *addr, uint32_t addrlen)
msg_receive(&msg_from_server);
#ifdef TCP_HC
if(msg_from_server.type == TCP_SYN_ACK) {
if (msg_from_server.type == TCP_SYN_ACK) {
/* TCP_SYN_ACK from server arrived again, copy old context and
* send TCP_ACK again */
memcpy(&current_tcp_socket->tcp_control.tcp_context,
&saved_tcp_context, sizeof(tcp_hc_context_t));
}
else if(msg_from_server.type == TCP_RETRY) {
else if (msg_from_server.type == TCP_RETRY) {
/* We waited for RTT, no TCP_SYN_ACK received, so we assume the
* TCP_ACK packet arrived safely */
}
@ -664,7 +664,7 @@ void calculate_rto(tcp_cb_t *tcp_control, long current_time)
double rttvar = tcp_control->rttvar;
double rto = tcp_control->rto;
if((srtt == 0) && (rttvar == 0) && (rto == TCP_INITIAL_ACK_TIMEOUT)) {
if ((srtt == 0) && (rttvar == 0) && (rto == TCP_INITIAL_ACK_TIMEOUT)) {
/* First calculation */
srtt = rtt;
rttvar = 0.5 * rtt;
@ -679,7 +679,7 @@ void calculate_rto(tcp_cb_t *tcp_control, long current_time)
(TCP_TIMER_RESOLUTION) : (4 * rttvar));
}
if(rto < SECOND) {
if (rto < SECOND) {
rto = SECOND;
}
@ -701,7 +701,7 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
tcp_hdr_t *current_tcp_packet = ((tcp_hdr_t *)(&send_buffer[IPV6_HDR_LEN]));
/* Check if socket exists and is TCP socket */
if(!isTCPSocket(s)) {
if (!isTCPSocket(s)) {
return -1;
}
@ -709,7 +709,7 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
current_tcp_socket = &current_int_tcp_socket->socket_values;
/* Check for ESTABLISHED STATE */
if(current_tcp_socket->tcp_control.state != ESTABLISHED) {
if (current_tcp_socket->tcp_control.state != ESTABLISHED) {
return -1;
}
@ -718,7 +718,7 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
recv_msg.type = UNDEFINED;
while(1) {
while (1) {
current_tcp_socket->tcp_control.no_of_retries = 0;
#ifdef TCP_HC
@ -729,12 +729,12 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
sizeof(tcp_hc_context_t) - 1);
#endif
while(recv_msg.type != TCP_ACK) {
while (recv_msg.type != TCP_ACK) {
/* Add packet data */
if(current_tcp_socket->tcp_control.send_wnd >
if (current_tcp_socket->tcp_control.send_wnd >
current_tcp_socket->tcp_control.mss) {
/* Window size > Maximum Segment Size */
if((len - total_sent_bytes) > current_tcp_socket->tcp_control.mss) {
if ((len - total_sent_bytes) > current_tcp_socket->tcp_control.mss) {
memcpy(&send_buffer[IPV6_HDR_LEN + TCP_HDR_LEN], msg,
current_tcp_socket->tcp_control.mss);
sent_bytes = current_tcp_socket->tcp_control.mss;
@ -749,7 +749,7 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
}
else {
/* Window size <= Maximum Segment Size */
if((len - total_sent_bytes) > current_tcp_socket->tcp_control.send_wnd) {
if ((len - total_sent_bytes) > current_tcp_socket->tcp_control.send_wnd) {
memcpy(&send_buffer[IPV6_HDR_LEN + TCP_HDR_LEN], msg,
current_tcp_socket->tcp_control.send_wnd);
sent_bytes = current_tcp_socket->tcp_control.send_wnd;
@ -766,7 +766,7 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
current_tcp_socket->tcp_control.send_nxt += sent_bytes;
current_tcp_socket->tcp_control.send_wnd -= sent_bytes;
if(send_tcp(current_int_tcp_socket, current_tcp_packet,
if (send_tcp(current_int_tcp_socket, current_tcp_packet,
temp_ipv6_header, 0, sent_bytes) != 1) {
/* Error while sending tcp data */
current_tcp_socket->tcp_control.send_nxt -= sent_bytes;
@ -788,14 +788,14 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
switch(recv_msg.type) {
case TCP_ACK: {
if(current_tcp_socket->tcp_control.no_of_retries == 0) {
if (current_tcp_socket->tcp_control.no_of_retries == 0) {
calculate_rto(&current_tcp_socket->tcp_control,
hwtimer_now());
}
tcp_hdr_t *tcp_header = ((tcp_hdr_t *)(recv_msg.content.ptr));
if((current_tcp_socket->tcp_control.send_nxt ==
if ((current_tcp_socket->tcp_control.send_nxt ==
tcp_header->ack_nr) && (total_sent_bytes == len)) {
current_tcp_socket->tcp_control.send_una = tcp_header->ack_nr;
current_tcp_socket->tcp_control.send_nxt = tcp_header->ack_nr;
@ -807,7 +807,7 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
#endif
return sent_bytes;
}
else if((current_tcp_socket->tcp_control.send_nxt ==
else if ((current_tcp_socket->tcp_control.send_nxt ==
tcp_header->ack_nr) && (total_sent_bytes != len)) {
current_tcp_socket->tcp_control.send_una = tcp_header->ack_nr;
current_tcp_socket->tcp_control.send_nxt = tcp_header->ack_nr;
@ -864,7 +864,7 @@ int32_t send(int s, void *msg, uint32_t len, int flags)
uint8_t read_from_socket(socket_internal_t *current_int_tcp_socket,
void *buf, int len)
{
if(len >= current_int_tcp_socket->tcp_input_buffer_end) {
if (len >= current_int_tcp_socket->tcp_input_buffer_end) {
mutex_lock(&current_int_tcp_socket->tcp_buffer_mutex);
uint8_t read_bytes = current_int_tcp_socket->tcp_input_buffer_end;
memcpy(buf, current_int_tcp_socket->tcp_input_buffer,
@ -896,7 +896,7 @@ int recv(int s, void *buf, uint32_t len, int flags)
socket_internal_t *current_int_tcp_socket;
/* Check if socket exists */
if(!isTCPSocket(s)) {
if (!isTCPSocket(s)) {
printf("INFO: NO TCP SOCKET!\n");
return -1;
}
@ -906,23 +906,23 @@ int recv(int s, void *buf, uint32_t len, int flags)
/* Setting Thread PID */
current_int_tcp_socket->recv_pid = thread_getpid();
if(current_int_tcp_socket->tcp_input_buffer_end > 0) {
if (current_int_tcp_socket->tcp_input_buffer_end > 0) {
return read_from_socket(current_int_tcp_socket, buf, len);
}
msg_receive(&m_recv);
if((exists_socket(s)) && (current_int_tcp_socket->tcp_input_buffer_end > 0)) {
if ((exists_socket(s)) && (current_int_tcp_socket->tcp_input_buffer_end > 0)) {
read_bytes = read_from_socket(current_int_tcp_socket, buf, len);
net_msg_reply(&m_recv, &m_send, UNDEFINED);
return read_bytes;
}
/* Received FIN */
if(m_recv.type == CLOSE_CONN) {
if (m_recv.type == CLOSE_CONN) {
/* Sent FIN_ACK, wait for ACK */
msg_receive(&m_recv);
/* Received ACK, return with closed socket! */
/* Received ACK, return with closed socket!*/
return -1;
}
@ -933,7 +933,7 @@ int recv(int s, void *buf, uint32_t len, int flags)
int32_t recvfrom(int s, void *buf, uint32_t len, int flags, sockaddr6_t *from,
uint32_t *fromlen)
{
if(isUDPSocket(s)) {
if (isUDPSocket(s)) {
msg_t m_recv, m_send;
ipv6_hdr_t *ipv6_header;
udp_hdr_t *udp_header;
@ -957,7 +957,7 @@ int32_t recvfrom(int s, void *buf, uint32_t len, int flags, sockaddr6_t *from,
msg_reply(&m_recv, &m_send);
return udp_header->length - UDP_HDR_LEN;
}
else if(isTCPSocket(s)) {
else if (isTCPSocket(s)) {
return recv(s, buf, len, flags);
}
else {
@ -969,7 +969,7 @@ int32_t recvfrom(int s, void *buf, uint32_t len, int flags, sockaddr6_t *from,
int32_t sendto(int s, const void *msg, uint32_t len, int flags,
sockaddr6_t *to, uint32_t tolen)
{
if(isUDPSocket(s) &&
if (isUDPSocket(s) &&
(getSocket(s)->socket_values.foreign_address.sin6_port == 0)) {
uint8_t send_buffer[BUFFER_SIZE];
@ -1004,8 +1004,8 @@ int close(int s)
{
socket_internal_t *current_socket = getSocket(s);
if(current_socket != NULL) {
if(isTCPSocket(s)) {
if (current_socket != NULL) {
if (isTCPSocket(s)) {
/* Variables */
msg_t m_recv;
uint8_t send_buffer[BUFFER_SIZE];
@ -1013,12 +1013,12 @@ int close(int s)
tcp_hdr_t *current_tcp_packet = ((tcp_hdr_t *)(&send_buffer[IPV6_HDR_LEN]));
/* Check if socket exists and is TCP socket */
if(!isTCPSocket(s)) {
if (!isTCPSocket(s)) {
return -1;
}
/* Check for ESTABLISHED STATE */
if(current_socket->socket_values.tcp_control.state != ESTABLISHED) {
if (current_socket->socket_values.tcp_control.state != ESTABLISHED) {
close_socket(current_socket);
return 1;
}
@ -1039,7 +1039,7 @@ int close(int s)
close_socket(current_socket);
return 1;
}
else if(isUDPSocket(s)) {
else if (isUDPSocket(s)) {
close_socket(current_socket);
return 1;
}
@ -1053,21 +1053,21 @@ int close(int s)
int bind(int s, sockaddr6_t *name, int namelen)
{
if(exists_socket(s)) {
if (exists_socket(s)) {
socket_t *current_socket = &getSocket(s)->socket_values;
switch(current_socket->domain) {
case(PF_INET): {
case (PF_INET): {
/* Not provided */
return -1;
break;
}
case(PF_INET6): {
case (PF_INET6): {
switch(current_socket->type) {
/* TCP */
case(SOCK_STREAM): {
if((current_socket->protocol == 0) ||
case (SOCK_STREAM): {
if ((current_socket->protocol == 0) ||
(current_socket->protocol == IPPROTO_TCP)) {
return bind_tcp_socket(s, name, namelen,
thread_getpid());
@ -1082,8 +1082,8 @@ int bind(int s, sockaddr6_t *name, int namelen)
}
/* UDP */
case(SOCK_DGRAM): {
if((current_socket->protocol == 0) ||
case (SOCK_DGRAM): {
if ((current_socket->protocol == 0) ||
(current_socket->protocol == IPPROTO_UDP)) {
return bind_udp_socket(s, name, namelen,
thread_getpid());
@ -1097,13 +1097,13 @@ int bind(int s, sockaddr6_t *name, int namelen)
break;
}
case(SOCK_SEQPACKET): {
case (SOCK_SEQPACKET): {
/* not provided */
return -1;
break;
}
case(SOCK_RAW): {
case (SOCK_RAW): {
/* not provided */
return -1;
break;
@ -1118,7 +1118,7 @@ int bind(int s, sockaddr6_t *name, int namelen)
break;
}
case(PF_UNIX): {
case (PF_UNIX): {
/* Not provided */
return -1;
break;
@ -1135,7 +1135,7 @@ int bind(int s, sockaddr6_t *name, int namelen)
int listen(int s, int backlog)
{
if(isTCPSocket(s) && getSocket(s)->socket_values.tcp_control.state == CLOSED) {
if (isTCPSocket(s) && getSocket(s)->socket_values.tcp_control.state == CLOSED) {
socket_internal_t *current_socket = getSocket(s);
current_socket->socket_values.tcp_control.state = LISTEN;
return 0;
@ -1152,19 +1152,19 @@ socket_internal_t *getWaitingConnectionSocket(int socket,
int i;
socket_internal_t *current_socket, *listening_socket = getSocket(socket);
for(i = 1; i < MAX_SOCKETS + 1; i++) {
for (i = 1; i < MAX_SOCKETS + 1; i++) {
current_socket = getSocket(i);
/* Connection establishment ACK, Check for 4 touple and state */
if((ipv6_header != NULL) && (tcp_header != NULL)) {
if(is_four_touple(current_socket, ipv6_header, tcp_header) &&
if ((ipv6_header != NULL) && (tcp_header != NULL)) {
if (is_four_touple(current_socket, ipv6_header, tcp_header) &&
(current_socket->socket_values.tcp_control.state == SYN_RCVD)) {
return current_socket;
}
}
/* Connection establishment SYN ACK, check only for port and state */
else {
if((current_socket->socket_values.tcp_control.state == SYN_RCVD) &&
if ((current_socket->socket_values.tcp_control.state == SYN_RCVD) &&
(current_socket->socket_values.local_address.sin6_port ==
listening_socket->socket_values.local_address.sin6_port)) {
return current_socket;
@ -1202,7 +1202,7 @@ int handle_new_tcp_connection(socket_internal_t *current_queued_int_socket,
/* Set message type to Retry for while loop */
msg_recv_client_ack.type = TCP_RETRY;
while(msg_recv_client_ack.type == TCP_RETRY) {
while (msg_recv_client_ack.type == TCP_RETRY) {
/* Send packet */
send_tcp(current_queued_int_socket, syn_ack_packet, temp_ipv6_header,
TCP_SYN_ACK, 0);
@ -1210,7 +1210,7 @@ int handle_new_tcp_connection(socket_internal_t *current_queued_int_socket,
/* wait for ACK from Client */
msg_receive(&msg_recv_client_ack);
if(msg_recv_client_ack.type == TCP_TIMEOUT) {
if (msg_recv_client_ack.type == TCP_TIMEOUT) {
/* Set status of internal socket back to LISTEN */
server_socket->socket_values.tcp_control.state = LISTEN;
@ -1224,7 +1224,7 @@ int handle_new_tcp_connection(socket_internal_t *current_queued_int_socket,
tcp_header = ((tcp_hdr_t *)(msg_recv_client_ack.content.ptr));
/* Check for consistency */
if(tcp_header->ack_nr != current_queued_socket->tcp_control.send_nxt + 1) {
if (tcp_header->ack_nr != current_queued_socket->tcp_control.send_nxt + 1) {
printf("TCP packets not consistent!\n");
}
@ -1265,11 +1265,11 @@ int accept(int s, sockaddr6_t *addr, uint32_t *addrlen)
{
socket_internal_t *server_socket = getSocket(s);
if(isTCPSocket(s) && (server_socket->socket_values.tcp_control.state == LISTEN)) {
if (isTCPSocket(s) && (server_socket->socket_values.tcp_control.state == LISTEN)) {
socket_internal_t *current_queued_socket =
getWaitingConnectionSocket(s, NULL, NULL);
if(current_queued_socket != NULL) {
if (current_queued_socket != NULL) {
return handle_new_tcp_connection(current_queued_socket,
server_socket, thread_getpid());
}
@ -1278,7 +1278,7 @@ int accept(int s, sockaddr6_t *addr, uint32_t *addrlen)
msg_t msg_recv_client_syn;
msg_recv_client_syn.type = UNDEFINED;
while(msg_recv_client_syn.type != TCP_SYN) {
while (msg_recv_client_syn.type != TCP_SYN) {
msg_receive(&msg_recv_client_syn);
}
@ -1312,7 +1312,7 @@ socket_internal_t *new_tcp_queued_socket(ipv6_hdr_t *ipv6_header,
&ipv6_header->destaddr);
/* Foreign TCP information */
if((tcp_header->dataOffset_reserved * 4 > TCP_HDR_LEN) &&
if ((tcp_header->dataOffset_reserved * 4 > TCP_HDR_LEN) &&
(*(((uint8_t *)tcp_header) + TCP_HDR_LEN) == TCP_MSS_OPTION)) {
current_queued_socket->socket_values.tcp_control.mss =
*((uint16_t *)(((uint8_t *)tcp_header) + TCP_HDR_LEN + 2));

32
sys/net/destiny/tcp.c
View File

@ -52,7 +52,7 @@ void printArrayRange_tcp(uint8_t *udp_header, uint16_t len)
int i = 0;
printf("-------------MEMORY-------------\n");
for(i = 0; i < len; i++) {
for (i = 0; i < len; i++) {
printf("%#x ", *(udp_header + i));
}
@ -77,7 +77,7 @@ uint8_t handle_payload(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header,
uint8_t tcp_payload_len = ipv6_header->length - TCP_HDR_LEN;
uint8_t acknowledged_bytes = 0;
if(tcp_payload_len > tcp_socket->socket_values.tcp_control.rcv_wnd) {
if (tcp_payload_len > tcp_socket->socket_values.tcp_control.rcv_wnd) {
mutex_lock(&tcp_socket->tcp_buffer_mutex);
memcpy(tcp_socket->tcp_input_buffer, payload,
tcp_socket->socket_values.tcp_control.rcv_wnd);
@ -98,7 +98,7 @@ uint8_t handle_payload(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header,
mutex_unlock(&tcp_socket->tcp_buffer_mutex, 0);
}
if(thread_getstatus(tcp_socket->recv_pid) == STATUS_RECEIVE_BLOCKED) {
if (thread_getstatus(tcp_socket->recv_pid) == STATUS_RECEIVE_BLOCKED) {
net_msg_send_recv(&m_send_tcp, &m_recv_tcp, tcp_socket->recv_pid, UNDEFINED);
}
@ -111,25 +111,25 @@ void handle_tcp_ack_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header,
msg_t m_recv_tcp, m_send_tcp;
uint8_t target_pid;
if(tcp_socket->socket_values.tcp_control.state == LAST_ACK) {
if (tcp_socket->socket_values.tcp_control.state == LAST_ACK) {
target_pid = tcp_socket->recv_pid;
close_socket(tcp_socket);
msg_send(&m_send_tcp, target_pid, 0);
return;
}
else if(tcp_socket->socket_values.tcp_control.state == CLOSING) {
else if (tcp_socket->socket_values.tcp_control.state == CLOSING) {
msg_send(&m_send_tcp, tcp_socket->recv_pid, 0);
msg_send(&m_send_tcp, tcp_socket->send_pid, 0);
return;
}
else if(getWaitingConnectionSocket(tcp_socket->socket_id, ipv6_header,
else if (getWaitingConnectionSocket(tcp_socket->socket_id, ipv6_header,
tcp_header) != NULL) {
m_send_tcp.content.ptr = (char *)tcp_header;
net_msg_send_recv(&m_send_tcp, &m_recv_tcp, tcp_socket->recv_pid, TCP_ACK);
return;
}
else if(tcp_socket->socket_values.tcp_control.state == ESTABLISHED) {
if(check_tcp_consistency(&tcp_socket->socket_values, tcp_header) == PACKET_OK) {
else if (tcp_socket->socket_values.tcp_control.state == ESTABLISHED) {
if (check_tcp_consistency(&tcp_socket->socket_values, tcp_header) == PACKET_OK) {
m_send_tcp.content.ptr = (char *)tcp_header;
net_msg_send(&m_send_tcp, tcp_socket->send_pid, 0, TCP_ACK);
return;
@ -150,11 +150,11 @@ void handle_tcp_syn_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header,
{
msg_t m_send_tcp;
if(tcp_socket->socket_values.tcp_control.state == LISTEN) {
if (tcp_socket->socket_values.tcp_control.state == LISTEN) {
socket_internal_t *new_socket = new_tcp_queued_socket(ipv6_header,
tcp_header);
if(new_socket != NULL) {
if (new_socket != NULL) {
#ifdef TCP_HC
update_tcp_hc_context(true, new_socket, tcp_header);
#endif
@ -179,7 +179,7 @@ void handle_tcp_syn_ack_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header,
{
msg_t m_send_tcp;
if(tcp_socket->socket_values.tcp_control.state == SYN_SENT) {
if (tcp_socket->socket_values.tcp_control.state == SYN_SENT) {
m_send_tcp.content.ptr = (char *) tcp_header;
net_msg_send(&m_send_tcp, tcp_socket->recv_pid, 0, TCP_SYN_ACK);
}
@ -205,7 +205,7 @@ void handle_tcp_fin_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header,
current_tcp_socket->tcp_control.tcp_context.hc_type = COMPRESSED_HEADER;
#endif
if(current_tcp_socket->tcp_control.state == FIN_WAIT_1) {
if (current_tcp_socket->tcp_control.state == FIN_WAIT_1) {
current_tcp_socket->tcp_control.state = CLOSING;
send_tcp(tcp_socket, current_tcp_packet, temp_ipv6_header, TCP_FIN_ACK, 0);
@ -253,9 +253,9 @@ void handle_tcp_no_flags_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header,
ipv6_hdr_t *temp_ipv6_header = ((ipv6_hdr_t *)(&send_buffer));
tcp_hdr_t *current_tcp_packet = ((tcp_hdr_t *)(&send_buffer[IPV6_HDR_LEN]));
if(tcp_payload_len > 0) {
if (tcp_payload_len > 0) {
if(check_tcp_consistency(current_tcp_socket, tcp_header) == PACKET_OK) {
if (check_tcp_consistency(current_tcp_socket, tcp_header) == PACKET_OK) {
read_bytes = handle_payload(ipv6_header, tcp_header, tcp_socket, payload);
/* Refresh TCP status values */
@ -295,7 +295,7 @@ void tcp_packet_handler(void)
socket_internal_t *tcp_socket = NULL;
uint16_t chksum;
while(1) {
while (1) {
msg_receive(&m_recv_ip);
ipv6_header = ((ipv6_hdr_t *)m_recv_ip.content.ptr);
@ -311,7 +311,7 @@ void tcp_packet_handler(void)
payload = (uint8_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN +
tcp_header->dataOffset_reserved * 4);
if((chksum == 0xffff) && (tcp_socket != NULL)) {
if ((chksum == 0xffff) && (tcp_socket != NULL)) {
#ifdef TCP_HC
update_tcp_hc_context(true, tcp_socket, tcp_header);
#endif

72
sys/net/destiny/tcp_hc.c
View File

@ -33,10 +33,10 @@ socket_internal_t *get_tcp_socket_by_context(ipv6_hdr_t *current_ipv6_header,
{
socket_internal_t *temp_socket;
for(int i = 1; i < MAX_SOCKETS + 1; i++) {
for (int i = 1; i < MAX_SOCKETS + 1; i++) {
temp_socket = getSocket(i);
if((temp_socket != NULL) &&
if ((temp_socket != NULL) &&
(ipv6_get_addr_match(&temp_socket->socket_values.foreign_address.sin6_addr,
&current_ipv6_header->srcaddr) == 128) &&
(ipv6_get_addr_match(&temp_socket->socket_values.local_address.sin6_addr,
@ -56,7 +56,7 @@ void update_tcp_hc_context(bool incoming, socket_internal_t *current_socket,
tcp_hc_context_t *current_context =
&current_socket->socket_values.tcp_control.tcp_context;
if(incoming) {
if (incoming) {
current_context->ack_rcv = current_tcp_packet->ack_nr;
current_context->seq_rcv = current_tcp_packet->seq_nr;
current_context->wnd_rcv = current_tcp_packet->window;
@ -81,7 +81,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
uint16_t packet_size = 0;
/* Connection establisment phase, use FULL_HEADER TCP */
if(tcp_context->hc_type == FULL_HEADER) {
if (tcp_context->hc_type == FULL_HEADER) {
/* draft-aayadi-6lowpan-tcphc-01: 5.1 Full header TCP segment.
* Establishing Connection */
@ -111,7 +111,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
return packet_size;
}
/* Check for header compression type: COMPRESSED_HEADER */
else if(tcp_context->hc_type == COMPRESSED_HEADER) {
else if (tcp_context->hc_type == COMPRESSED_HEADER) {
/* draft-aayadi-6lowpan-tcphc-01: 5.1 Compressed header TCP segment. */
/* Temporary variable for TCP_HC_Header Bytes */
@ -141,12 +141,12 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
/*----------------------------------*/
/*| Sequence number handling |*/
/*----------------------------------*/
if(full_tcp_header.seq_nr == tcp_context->seq_snd) {
if (full_tcp_header.seq_nr == tcp_context->seq_snd) {
/* Nothing to do, Seq = (0|0) */
}
/* If the 24 most significant bits haven't changed from previous
* packet, don't transmit them */
else if((full_tcp_header.seq_nr & 0xFFFFFF00) == (tcp_context->seq_snd &
else if ((full_tcp_header.seq_nr & 0xFFFFFF00) == (tcp_context->seq_snd &
0xFFFFFF00)) {
/* Seq = (0|1) */
tcp_hc_header |= 0x0400;
@ -159,7 +159,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
}
/* If the 16 most significant bits haven't changed from previous packet,
* don't transmit them */
else if((full_tcp_header.seq_nr & 0xFFFF0000) == (tcp_context->seq_snd & 0xFFFF0000)) {
else if ((full_tcp_header.seq_nr & 0xFFFF0000) == (tcp_context->seq_snd & 0xFFFF0000)) {
/* Seq = (1|0) */
tcp_hc_header |= 0x0800;
@ -184,17 +184,17 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
/*----------------------------------*/
/*| Acknowledgment number handling |*/
/*----------------------------------*/
if((IS_TCP_ACK(full_tcp_header.reserved_flags) &&
if ((IS_TCP_ACK(full_tcp_header.reserved_flags) &&
(tcp_cb->tcp_context.ack_snd == full_tcp_header.ack_nr))) {
tcp_context->ack_snd = tcp_context->seq_rcv;
}
if(full_tcp_header.ack_nr == tcp_context->ack_snd) {
if (full_tcp_header.ack_nr == tcp_context->ack_snd) {
/* Nothing to do, Ack = (0|0) */
}
/* If the 24 most significant bits haven't changed from previous packet,
* don't transmit them */
else if((full_tcp_header.ack_nr & 0xFFFFFF00) == (tcp_context->ack_snd &
else if ((full_tcp_header.ack_nr & 0xFFFFFF00) == (tcp_context->ack_snd &
0xFFFFFF00)) {
/* Ack = (0|1) */
tcp_hc_header |= 0x0100;
@ -207,7 +207,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
}
/* If the 16 most significant bits haven't changed from previous packet,
* don't transmit them */
else if((full_tcp_header.ack_nr & 0xFFFF0000) == (tcp_context->ack_snd &
else if ((full_tcp_header.ack_nr & 0xFFFF0000) == (tcp_context->ack_snd &
0xFFFF0000)) {
/* Ack = (1|0) */
tcp_hc_header |= 0x0200;
@ -234,12 +234,12 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
/*----------------------------------*/
/*| Window handling |*/
/*----------------------------------*/
if(full_tcp_header.window == tcp_context->wnd_snd) {
if (full_tcp_header.window == tcp_context->wnd_snd) {
/* Nothing to do, Wnd = (0|0) */
}
/* If the 8 most significant bits haven't changed from previous packet,
* don't transmit them */
else if((full_tcp_header.window & 0xFF00) == (tcp_context->wnd_snd & 0xFF00)) {
else if ((full_tcp_header.window & 0xFF00) == (tcp_context->wnd_snd & 0xFF00)) {
/* Wnd = (0|1) */
tcp_hc_header |= 0x0040;
@ -250,7 +250,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
}
/* If the 8 less significant bits haven't changed from previous packet,
* don't transmit them */
else if((full_tcp_header.window & 0x00FF) == (tcp_context->wnd_snd &
else if ((full_tcp_header.window & 0x00FF) == (tcp_context->wnd_snd &
0x00FF)) {
/* Wnd = (1|0) */
tcp_hc_header |= 0x0080;
@ -273,7 +273,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
}
/* FIN flag */
if(IS_TCP_FIN(full_tcp_header.reserved_flags)) {
if (IS_TCP_FIN(full_tcp_header.reserved_flags)) {
/* F = (1) */
tcp_hc_header |= 0x0008;
}
@ -304,7 +304,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
return packet_size;
}
/* Check for header compression type: MOSTLY_COMPRESSED_HEADER */
else if(tcp_context->hc_type == MOSTLY_COMPRESSED_HEADER) {
else if (tcp_context->hc_type == MOSTLY_COMPRESSED_HEADER) {
/* draft-aayadi-6lowpan-tcphc-01: 5.1 Compressed header TCP segment. */
/* Temporary variable for TCP_HC_Header Bytes */
@ -369,7 +369,7 @@ uint16_t compress_tcp_packet(socket_internal_t *current_socket,
packet_size += 2;
/* FIN flag */
if(IS_TCP_FIN(full_tcp_header.reserved_flags)) {
if (IS_TCP_FIN(full_tcp_header.reserved_flags)) {
/* F = (1) */
tcp_hc_header |= 0x0008;
}
@ -410,15 +410,15 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
uint16_t packet_size = 0;
/* Full header TCP segment */
if(*(((uint8_t *)temp_ipv6_header) + IPV6_HDR_LEN) == 0x01) {
if (*(((uint8_t *)temp_ipv6_header) + IPV6_HDR_LEN) == 0x01) {
switch_tcp_packet_byte_order(((tcp_hdr_t *)(((uint8_t *)temp_ipv6_header) +
IPV6_HDR_LEN + 3)));
current_socket = get_tcp_socket(temp_ipv6_header,
((tcp_hdr_t *)(((uint8_t *)temp_ipv6_header) +
IPV6_HDR_LEN + 3)));
if(current_socket != NULL) {
if(current_socket->socket_values.tcp_control.state == LISTEN) {
if (current_socket != NULL) {
if (current_socket->socket_values.tcp_control.state == LISTEN) {
memcpy(&current_socket->socket_values.tcp_control.tcp_context.context_id,
((uint8_t *)temp_ipv6_header) + IPV6_HDR_LEN + 1, 2);
current_socket->socket_values.tcp_control.tcp_context.context_id =
@ -455,11 +455,11 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
uint8_t header_type = UNDEFINED;
if(BITSET(tcp_hc_header, 15) && !BITSET(tcp_hc_header, 14) &&
if (BITSET(tcp_hc_header, 15) && !BITSET(tcp_hc_header, 14) &&
!BITSET(tcp_hc_header, 13)) {
header_type = MOSTLY_COMPRESSED_HEADER;
}
else if(BITSET(tcp_hc_header, 15) && BITSET(tcp_hc_header, 14) &&
else if (BITSET(tcp_hc_header, 15) && BITSET(tcp_hc_header, 14) &&
!BITSET(tcp_hc_header, 13)) {
header_type = COMPRESSED_HEADER;
}
@ -472,7 +472,7 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
socket_internal_t *current_socket =
get_tcp_socket_by_context(temp_ipv6_header, current_context);
if(current_socket == NULL) {
if (current_socket == NULL) {
printf("Current Socket == NULL!\n");
return NULL;
}
@ -484,12 +484,12 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
/*----------------------------------*/
/*| Sequence number handling |*/
/*----------------------------------*/
if(!BITSET(tcp_hc_header, 11) && !BITSET(tcp_hc_header, 10)) {
if (!BITSET(tcp_hc_header, 11) && !BITSET(tcp_hc_header, 10)) {
/* Seq = (0|0), sequence number didn't change, copy old value */
memcpy(&full_tcp_header.seq_nr, &current_tcp_context->seq_rcv, 4);
}
/* The 24 most significant bits haven't changed from previous packet */
else if(!BITSET(tcp_hc_header, 11) && BITSET(tcp_hc_header, 10)) {
else if (!BITSET(tcp_hc_header, 11) && BITSET(tcp_hc_header, 10)) {
/* Seq = (0|1), copy 1 byte of tcp_hc packet and 3 bytes from
* previous packet */
full_tcp_header.seq_nr |= *packet_buffer;
@ -499,7 +499,7 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
packet_size += 1;
}
/* If the 16 most significant bits haven't changed from previous packet */
else if(BITSET(tcp_hc_header, 11) && !BITSET(tcp_hc_header, 10)) {
else if (BITSET(tcp_hc_header, 11) && !BITSET(tcp_hc_header, 10)) {
/* Seq = (1|0), copy 2 bytes of tcp_hc packet and 2 bytes from
* previous packet */
full_tcp_header.seq_nr |= NTOHS(*((uint16_t *)packet_buffer));
@ -519,12 +519,12 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
/*----------------------------------*/
/*| Acknowledgment number handling |*/
/*----------------------------------*/
if(!BITSET(tcp_hc_header, 9) && !BITSET(tcp_hc_header, 8)) {
if (!BITSET(tcp_hc_header, 9) && !BITSET(tcp_hc_header, 8)) {
/* Ack = (0|0), acknowledgment number didn't change, copy old value */
memcpy(&full_tcp_header.ack_nr, &current_tcp_context->ack_rcv, 4);
}
/* The 24 most significant bits haven't changed from previous packet */
else if(!BITSET(tcp_hc_header, 9) && BITSET(tcp_hc_header, 8)) {
else if (!BITSET(tcp_hc_header, 9) && BITSET(tcp_hc_header, 8)) {
/* Ack = (0|1), copy 1 byte of tcp_hc packet and 3 bytes from
* previous packet */
full_tcp_header.ack_nr |= *packet_buffer;
@ -534,7 +534,7 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
SET_TCP_ACK(full_tcp_header.reserved_flags);
}
/* If the 16 most significant bits haven't changed from previous packet */
else if(BITSET(tcp_hc_header, 9) && !BITSET(tcp_hc_header, 8)) {
else if (BITSET(tcp_hc_header, 9) && !BITSET(tcp_hc_header, 8)) {
/* Ack = (1|0), copy 2 bytes of tcp_hc packet and 2 bytes from
* previous packet */
full_tcp_header.ack_nr |= NTOHS(*((uint16_t *)packet_buffer));
@ -551,7 +551,7 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
packet_buffer += 4;
packet_size += 4;
if(header_type == COMPRESSED_HEADER) {
if (header_type == COMPRESSED_HEADER) {
SET_TCP_ACK(full_tcp_header.reserved_flags);
}
}
@ -559,12 +559,12 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
/*----------------------------------*/
/*| Window handling |*/
/*----------------------------------*/
if(!BITSET(tcp_hc_header, 7) && !BITSET(tcp_hc_header, 6)) {
if (!BITSET(tcp_hc_header, 7) && !BITSET(tcp_hc_header, 6)) {
/* Wnd = (0|0), copy old value */
memcpy(&full_tcp_header.window, &current_tcp_context->wnd_rcv, 2);
}
/* The 8 most significant bits haven't changed from previous packet */
else if(!BITSET(tcp_hc_header, 7) && BITSET(tcp_hc_header, 6)) {
else if (!BITSET(tcp_hc_header, 7) && BITSET(tcp_hc_header, 6)) {
/* Wnd = (0|1), copy 1 byte of tcp_hc packet and 1 byte from
* previous packet */
full_tcp_header.window |= *packet_buffer;
@ -573,7 +573,7 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
packet_size += 1;
}
/* If the 8 less significant bits haven't changed from previous packet */
else if(BITSET(tcp_hc_header, 7) && !BITSET(tcp_hc_header, 6)) {
else if (BITSET(tcp_hc_header, 7) && !BITSET(tcp_hc_header, 6)) {
/* Wnd = (1|0), copy 1 byte of tcp_hc packet and 1 byte from previous packet */
full_tcp_header.window |= ((*((uint16_t *)packet_buffer)) & 0xFF00);
full_tcp_header.window |= ((current_tcp_context->wnd_rcv) & 0x00FF);
@ -590,9 +590,9 @@ socket_internal_t *decompress_tcp_packet(ipv6_hdr_t *temp_ipv6_header)
}
/* FIN flag */
if(BITSET(tcp_hc_header, 3)) {
if (BITSET(tcp_hc_header, 3)) {
/* F = (1) */
if(IS_TCP_ACK(full_tcp_header.reserved_flags)) {
if (IS_TCP_ACK(full_tcp_header.reserved_flags)) {
SET_TCP_FIN_ACK(full_tcp_header.reserved_flags);
}
else {

24
sys/net/destiny/tcp_timer.c
View File

@ -33,25 +33,25 @@ void handle_synchro_timeout(socket_internal_t *current_socket)
{
msg_t send;
if(thread_getstatus(current_socket->recv_pid) == STATUS_RECEIVE_BLOCKED) {
if (thread_getstatus(current_socket->recv_pid) == STATUS_RECEIVE_BLOCKED) {
timex_t now;
vtimer_now(&now);
if((current_socket->socket_values.tcp_control.no_of_retries == 0) &&
if ((current_socket->socket_values.tcp_control.no_of_retries == 0) &&
(timex_sub(now,
current_socket->socket_values.tcp_control.last_packet_time).microseconds >
TCP_SYN_INITIAL_TIMEOUT)) {
current_socket->socket_values.tcp_control.no_of_retries++;
net_msg_send(&send, current_socket->recv_pid, 0, TCP_RETRY);
}
else if((current_socket->socket_values.tcp_control.no_of_retries > 0) &&
else if ((current_socket->socket_values.tcp_control.no_of_retries > 0) &&
(timex_sub(now,
current_socket->socket_values.tcp_control.last_packet_time).microseconds >
(current_socket->socket_values.tcp_control.no_of_retries *
TCP_SYN_TIMEOUT + TCP_SYN_INITIAL_TIMEOUT))) {
current_socket->socket_values.tcp_control.no_of_retries++;
if(current_socket->socket_values.tcp_control.no_of_retries >
if (current_socket->socket_values.tcp_control.no_of_retries >
TCP_MAX_SYN_RETRIES) {
net_msg_send(&send, current_socket->recv_pid, 0, TCP_TIMEOUT);
}
@ -67,16 +67,16 @@ void handle_established(socket_internal_t *current_socket)
msg_t send;
double current_timeout = current_socket->socket_values.tcp_control.rto;
if(current_timeout < SECOND) {
if (current_timeout < SECOND) {
current_timeout = SECOND;
}
uint8_t i;
if((current_socket->socket_values.tcp_control.send_nxt >
if ((current_socket->socket_values.tcp_control.send_nxt >
current_socket->socket_values.tcp_control.send_una) &&
(thread_getstatus(current_socket->send_pid) == STATUS_RECEIVE_BLOCKED)) {
for(i = 0; i < current_socket->socket_values.tcp_control.no_of_retries;
for (i = 0; i < current_socket->socket_values.tcp_control.no_of_retries;
i++) {
current_timeout *= 2;
}
@ -84,10 +84,10 @@ void handle_established(socket_internal_t *current_socket)
timex_t now;
vtimer_now(&now);
if(current_timeout > TCP_ACK_MAX_TIMEOUT) {
if (current_timeout > TCP_ACK_MAX_TIMEOUT) {
net_msg_send(&send, current_socket->send_pid, 0, TCP_TIMEOUT);
}
else if(timex_sub(now, current_socket->socket_values.tcp_control.last_packet_time).microseconds >
else if (timex_sub(now, current_socket->socket_values.tcp_control.last_packet_time).microseconds >
current_timeout) {
current_socket->socket_values.tcp_control.no_of_retries++;
net_msg_send(&send, current_socket->send_pid, 0, TCP_RETRY);
@ -100,10 +100,10 @@ void check_sockets(void)
socket_internal_t *current_socket;
uint8_t i = 1;
while(i < MAX_SOCKETS + 1) {
while (i < MAX_SOCKETS + 1) {
current_socket = getSocket(i);
if(isTCPSocket(i)) {
if (isTCPSocket(i)) {
switch(current_socket->socket_values.tcp_control.state) {
case ESTABLISHED: {
handle_established(current_socket);
@ -147,7 +147,7 @@ void tcp_general_timer(void)
vtimer_t tcp_vtimer;
timex_t interval = timex_set(0, TCP_TIMER_RESOLUTION);
while(1) {
while (1) {
inc_global_variables();
check_sockets();
vtimer_set_wakeup(&tcp_vtimer, interval, thread_getpid());

6
sys/net/destiny/udp.c
View File

@ -49,7 +49,7 @@ void udp_packet_handler(void)
socket_internal_t *udp_socket = NULL;
uint16_t chksum;
while(1) {
while (1) {
msg_receive(&m_recv_ip);
ipv6_header = ((ipv6_hdr_t *)m_recv_ip.content.ptr);
udp_header = ((udp_hdr_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN));
@ -57,10 +57,10 @@ void udp_packet_handler(void)
chksum = udp_csum(ipv6_header, udp_header);
if(chksum == 0xffff) {
if (chksum == 0xffff) {
udp_socket = get_udp_socket(ipv6_header, udp_header);
if(udp_socket != NULL) {
if (udp_socket != NULL) {
m_send_udp.content.ptr = (char *)ipv6_header;
msg_send_receive(&m_send_udp, &m_recv_udp, udp_socket->recv_pid);
}

138
sys/net/mm/mmr.c
View File

@ -144,18 +144,18 @@ static void rt_extract_routes(uint16_t local_addr, uint8_t length, uint16_t *lis
uint16_t net_id = NETWORK_ADDR_BC(list[0]); /* BC address of source of RREQ */
route_table_entry_t *rte = rt_lookup_route(net_id); /* Should exist (preconfigured) */
if(rte == NULL) {
if (rte == NULL) {
DEBUG("exit [%u]: rt_extract_routes\n", fk_thread->pid);
return; /* else exit here */
}
int i = 0;
while(i < length && list[i] != local_addr) {
while (i < length && list[i] != local_addr) {
i++;
}
if(i == length) {
if (i == length) {
DEBUG("exit [%u]: rt_extract_routes\n", fk_thread->pid);
return;
}
@ -164,24 +164,24 @@ static void rt_extract_routes(uint16_t local_addr, uint8_t length, uint16_t *lis
int leftNeighbour = -1;
int rightNeighbour = -1;
if(pos > 0) {
if (pos > 0) {
leftNeighbour = list[pos - 1];
}
if(pos + 1 != length) {
if (pos + 1 != length) {
rightNeighbour = list[pos + 1];
}
i = 0;
while(i < length) {
while (i < length) {
uint16_t next = list[i];
if(local_addr != next) {
if (local_addr != next) {
int distance = pos - i;
int router = leftNeighbour;
if(distance < 0) {
if (distance < 0) {
router = rightNeighbour;
distance *= -1;
}
@ -217,8 +217,8 @@ static message_queue_entry_t *mq_add(net_message_t *msg)
/* Find the first active RREQ to this destination */
int i;
for(i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if(message_queue[i].timestamp != 0 &&
for (i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if (message_queue[i].timestamp != 0 &&
message_queue[i].message.destination == msg->destination &&
message_queue[i].retry_count != RREQ_NONE) {
DEBUG("%s FOUND Duplicated Request to %u.%u in route req queue\n",
@ -234,19 +234,19 @@ static message_queue_entry_t *mq_add(net_message_t *msg)
* even if the new message will get dropped later on because of
* limited queue space. Route to this destination gets queried
* again for sure so make new RREQ as soon as possible... */
if(pFirstFoundDup != NULL) {
if (pFirstFoundDup != NULL) {
pFirstFoundDup->retry_count = 0;
pFirstFoundDup->timestamp = 1;
mmr_stats.rreq_duplicated++;
}
/* Find free position to insert new message */
for(i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if(message_queue[i].timestamp == 0) {
for (i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if (message_queue[i].timestamp == 0) {
/* Free position found, add entry */
message_queue[i].message = *msg;
if(pFirstFoundDup != NULL) {
if (pFirstFoundDup != NULL) {
/* There is already a RREQ for this destination, so don't
* generate a new one */
message_queue[i].retry_count = RREQ_NONE;
@ -278,8 +278,8 @@ static int mq_msgs_for_destination(uint16_t dst)
DEBUG("call [%u]: mq_msgs_for_destination\n", fk_thread->pid);
int i, dst_count = 0;
for(i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if(message_queue[i].timestamp != 0 &&
for (i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if (message_queue[i].timestamp != 0 &&
message_queue[i].message.destination == dst) {
dst_count++;
}
@ -299,8 +299,8 @@ static void mq_remove_msgs_for_destination(uint16_t dst)
DEBUG("call [%u]: mq_remove_msgs_for_destination\n", fk_thread->pid);
int i;
for(i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if(message_queue[i].timestamp != 0 &&
for (i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if (message_queue[i].timestamp != 0 &&
message_queue[i].message.destination == dst) {
message_queue[i].timestamp = 0;
}
@ -326,15 +326,15 @@ static void mq_dequeue_and_send(uint16_t dst)
/* Prioritize packets for given destination, route entry should exist */
route_table_entry_t *rte = rt_lookup_route(dst);
if(rte != NULL) {
for(i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if(message_queue[i].timestamp != 0 &&
if (rte != NULL) {
for (i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if (message_queue[i].timestamp != 0 &&
message_queue[i].message.destination == dst) {
bool res = net_enqueue_for_transmission(&message_queue[i].message,
rte->interface_id,
rte->gateway, true);
if(res) {
if (res) {
message_queue[i].timestamp = 0;
}
}
@ -342,17 +342,17 @@ static void mq_dequeue_and_send(uint16_t dst)
}
/* Now all other packets */
for(i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if(message_queue[i].timestamp != 0 &&
for (i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if (message_queue[i].timestamp != 0 &&
message_queue[i].message.destination != dst) {
route_table_entry_t *rte = rt_lookup_route(message_queue[i].message.destination);
if(rte != NULL) {
if (rte != NULL) {
bool res = net_enqueue_for_transmission(&message_queue[i].message,
rte->interface_id,
rte->gateway, true);
if(res) {
if (res) {
message_queue[i].timestamp = 0;
}
}
@ -390,9 +390,9 @@ void mmr_init(void)
*/
static bool is_route_error(net_message_t *msg)
{
if(msg->protocol == LAYER_2_PROTOCOL_MMR) {
if (msg->protocol == LAYER_2_PROTOCOL_MMR) {
/* First byte in {RREQ, RREP, RERR} is always type */
if(msg->payload[0] == MMR_TYPE_RERR) {
if (msg->payload[0] == MMR_TYPE_RERR) {
return true;
}
}
@ -430,7 +430,7 @@ static void generate_route_reply_message(mmr_rreq_message_t *rreq_msg)
/* interface id and next hop (should be created by RREQ) */
route_table_entry_t *rte = rt_lookup_route(net_msg.destination);
if(rte != NULL) {
if (rte != NULL) {
/* Send message to next hop */
mmr_stats.rrep_originated++;
net_enqueue_for_transmission(&net_msg, rte->interface_id, rte->gateway, true);
@ -486,7 +486,7 @@ static void receive_route_request_message(mmr_rreq_message_t *msg,
uint16_t my_addr = net_get_address_in_subnet(msg->source);
#if (MMR_INFO_LEVEL >= LEVEL_WARN)
if(my_addr == 0) {
if (my_addr == 0) {
puts("MMR [WARN]: received RREQ with unknown network part of source address");
puts("MMR [WARN]: => can't find own net address in sub net!");
}
@ -494,7 +494,7 @@ static void receive_route_request_message(mmr_rreq_message_t *msg,
#endif
/* If address list of RREQ message has enough space */
if(msg->length < ADDRESS_LIST_SIZE) {
if (msg->length < ADDRESS_LIST_SIZE) {
/* append our node id to list */
msg->address[msg->length++] = my_addr;
/* add routes with overhearing */
@ -509,7 +509,7 @@ static void receive_route_request_message(mmr_rreq_message_t *msg,
}
/* If RREQ message was send to us, then send RREP message */
if(msg->destination == my_addr) {
if (msg->destination == my_addr) {
/* Don't forward RREQ packet any further => set TTL to zero */
*packet_info->ttl_ptr = 0;
generate_route_reply_message(msg);
@ -572,7 +572,7 @@ static int compute_rreq_timeout(int ttl, uint16_t dst)
{
int t_hop = net_get_interface_transmission_duration(dst);
if(t_hop == -1) {
if (t_hop == -1) {
t_hop = RREQ_TIMEOUT_PER_TTL * ttl;
}
else {
@ -595,7 +595,7 @@ static void rreq_broadcast(message_queue_entry_t *mq_entry)
{
DEBUG("call [%u]: rreq_broadcast\n", fk_thread->pid);
if(mq_entry->retry_count == RREQ_NONE) {
if (mq_entry->retry_count == RREQ_NONE) {
DEBUG("call [%u]: rreq duplicated do not send\n", fk_thread->pid);
return;
}
@ -624,7 +624,7 @@ static void rreq_broadcast(message_queue_entry_t *mq_entry)
/* Find the broadcast route table entry */
route_table_entry_t *rte = rt_lookup_route(net_msg.destination);
if(rte != NULL) {
if (rte != NULL) {
/* Next hop address is broadcast address of lower layer */
net_enqueue_for_transmission(&net_msg, rte->interface_id,
rte->gateway, true);
@ -643,21 +643,21 @@ static void post_next_rreq_timeout(void)
int i, j = -1;
uint32_t now, next = 0xffffffff;
for(i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if((message_queue[i].timestamp != 0) && (message_queue[i].retry_count !=
for (i = 0; i < MESSAGE_QUEUE_SIZE; i++) {
if ((message_queue[i].timestamp != 0) && (message_queue[i].retry_count !=
RREQ_NONE)) {
int ttl = message_queue[i].retry_count == 1 ? TTL_START : TTL_THRESHOLD;
int to = compute_rreq_timeout(ttl,
message_queue[i].message.destination);
if(message_queue[i].timestamp + to < next) {
if (message_queue[i].timestamp + to < next) {
next = message_queue[i].timestamp + to;
j = i;
}
}
}
if(j == -1) {
if (j == -1) {
DEBUG("exit [%u]: post_next_rreq_timeout\n", fk_thread->pid);
return;
}
@ -668,14 +668,14 @@ static void post_next_rreq_timeout(void)
/* If current time greater than RREQ timeout value */
now = rtc_now();
if(now >= next) {
if (now >= next) {
/* Schedule RREQ-Timeout immediately */
msg m;
m.type = MSG_TIMER;
m.content.ptr = (char *)&message_queue[j];
rreq_to_active = true;
if(msg_send(&m, rreq_timeout_process_pid, false) != 1) {
if (msg_send(&m, rreq_timeout_process_pid, false) != 1) {
/* Message could not be send (receiver not waiting), schedule
* timer with minimum delay */
#if (MMR_INFO_LEVEL >= LEVEL_WARN)
@ -706,7 +706,7 @@ static void rreq_timeout(message_queue_entry_t *mqe)
DEBUG("call [%u]: rreq_timeout\n", fk_thread->pid);
/* Test if valid entry passed */
if(mqe->timestamp == 0) {
if (mqe->timestamp == 0) {
#if (MMR_INFO_LEVEL >= LEVEL_WARN)
puts("MMR [WARN]: invalid message queue entry for RREQ-Timeout");
#endif
@ -718,11 +718,11 @@ static void rreq_timeout(message_queue_entry_t *mqe)
/* If found and no messages in queue for destination: return (queued
* packets are send on reception of RREP); If found but messages in queue:
* trigger send immediately here! */
if(rte != NULL) {
* trigger send immediately here!*/
if (rte != NULL) {
int msg_count = mq_msgs_for_destination(mqe->message.destination);
if(msg_count > 0) {
if (msg_count > 0) {
mq_dequeue_and_send(mqe->message.destination);
DEBUG("exit [%u]: rreq_timeout\n", fk_thread->pid);
return;
@ -739,7 +739,7 @@ static void rreq_timeout(message_queue_entry_t *mqe)
/* Otherwise send new RREQ if below threshold (means also retry count !=
* RREQ_NONE) */
if(mqe->retry_count < RREQ_THRESHOLD) {
if (mqe->retry_count < RREQ_THRESHOLD) {
/* Broadcast new RREQ message (with incremented TTL) */
rreq_broadcast(mqe);
}
@ -762,12 +762,12 @@ static void rreq_timeout_process(void)
do {
msg_receive(&m);
if(m.type == MSG_TIMER && rreq_to_active) {
if (m.type == MSG_TIMER && rreq_to_active) {
rreq_to_active = false;
rreq_timeout((message_queue_entry_t *)m.content.ptr);
}
}
while(m.type != MSG_EXIT);
while (m.type != MSG_EXIT);
}
void mmr_peek(net_message_t *message, packet_info_t *packet_info)
@ -775,16 +775,16 @@ void mmr_peek(net_message_t *message, packet_info_t *packet_info)
DEBUG("call [%u]: mmr_peek\n", fk_thread->pid);
/* Only look at micro mesh routing messages */
if(message->protocol == LAYER_2_PROTOCOL_MMR) {
if (message->protocol == LAYER_2_PROTOCOL_MMR) {
uint8_t type = message->payload[0];
uint16_t my_addr = net_get_address_in_subnet(message->source);
if(type == MMR_TYPE_RREP) {
if (type == MMR_TYPE_RREP) {
/* Add routes to route table */
mmr_rrep_message_t *rrep_msg = (mmr_rrep_message_t *)message->payload;
#if (MMR_INFO_LEVEL >= LEVEL_WARN)
if(my_addr == 0) {
if (my_addr == 0) {
puts("MMR [WARN]: received RREP with unknown network part of source address");
puts("MMR [WARN]: => can't find own net address in sub net!");
}
@ -792,10 +792,10 @@ void mmr_peek(net_message_t *message, packet_info_t *packet_info)
#endif
rt_extract_routes(my_addr, rrep_msg->length, rrep_msg->address);
}
else if(type == MMR_TYPE_RERR) {
else if (type == MMR_TYPE_RERR) {
#if (MMR_INFO_LEVEL >= LEVEL_WARN)
if(my_addr == 0) {
if (my_addr == 0) {
puts("MMR [WARN]: received RERR with unknown network part of source address");
puts("MMR [WARN]: => can't find own net address in sub net!");
}
@ -804,11 +804,11 @@ void mmr_peek(net_message_t *message, packet_info_t *packet_info)
/* If not destination of RERR, then remove route to unavailable
* node in RERR packet */
if(message->destination != my_addr) {
if (message->destination != my_addr) {
mmr_rerr_message_t *rerr_msg =
(mmr_rerr_message_t *)message->payload;
if(rerr_msg->error_type == RERR_NODE_UNREACHABLE) {
if (rerr_msg->error_type == RERR_NODE_UNREACHABLE) {
rt_remove_route(rerr_msg->type_specific_info);
}
}
@ -823,7 +823,7 @@ bool mmr_send(net_message_t *message)
DEBUG("call [%u]: mmr_send\n", fk_thread->pid);
bool enqueue = true;
if(message->destination == net_get_address_in_subnet(message->destination)) {
if (message->destination == net_get_address_in_subnet(message->destination)) {
#if (MMR_INFO_LEVEL >= LEVEL_WARN)
puts("MMR [WARN]: message is already at destination, why is routing called?");
#endif
@ -831,7 +831,7 @@ bool mmr_send(net_message_t *message)
return false;
}
if(NETWORK_ADDR_NET(message->destination) == 0) {
if (NETWORK_ADDR_NET(message->destination) == 0) {
#if (MMR_INFO_LEVEL >= LEVEL_WARN)
puts("MMR [WARN]: NET part of address cannot be 0!");
#endif
@ -839,7 +839,7 @@ bool mmr_send(net_message_t *message)
return false;
}
if(NETWORK_ADDR_HOST(message->destination) == 0) {
if (NETWORK_ADDR_HOST(message->destination) == 0) {
#if (MMR_INFO_LEVEL >= LEVEL_INFO)
puts("MMR [INFO]: broadcast destination, why is routing called? A route entry should exist!");
#endif
@ -850,13 +850,13 @@ bool mmr_send(net_message_t *message)
route_table_entry_t *rte = rt_lookup_route(message->destination);
/* If next hop address found in routing table, forward message */
if(rte != NULL) {
if (rte != NULL) {
DEBUG("exit [%u]: mmr_send\n", fk_thread->pid);
return net_enqueue_for_transmission(message, rte->interface_id, rte->gateway, true);
}
/* Otherwise, save message in queue; broadcast RREQ message */
else {
if(!enqueue) {
if (!enqueue) {
/* Don't enqueue broadcast destinations */
DEBUG("exit [%u]: mmr_send\n", fk_thread->pid);
return false;
@ -864,7 +864,7 @@ bool mmr_send(net_message_t *message)
message_queue_entry_t *mqe = mq_add(message);
if(mqe != NULL) {
if (mqe != NULL) {
rreq_broadcast(mqe);
post_next_rreq_timeout();
mmr_stats.rreq_originated++;
@ -881,19 +881,19 @@ void mmr_packet_dropped(net_message_t *message, uint16_t next_hop, int error)
{
DEBUG("call [%u]: mmr_packet_dropped\n", fk_thread->pid);
if(error == ROUTE_ERROR_BROKEN_ROUTE) {
if (error == ROUTE_ERROR_BROKEN_ROUTE) {
/* Local failure detected - remove all routes through broken link */
rt_remove_gateway_routes(next_hop);
mmr_stats.messages_broken_link_on_forward++;
}
else if(error == ROUTE_ERROR_MISSING_ROUTE) {
else if (error == ROUTE_ERROR_MISSING_ROUTE) {
mmr_stats.messages_no_route_avail_on_forward++;
}
/* If source != net_addr, send RERR to source of message */
if(message->source != net_get_address_in_subnet(message->source)) {
if (message->source != net_get_address_in_subnet(message->source)) {
/* Do not generate RERR if it is already a RERR message */
if(is_route_error(message)) {
if (is_route_error(message)) {
DEBUG("exit [%u]: mmr_packet_dropped\n", fk_thread->pid);
return;
}
@ -901,7 +901,7 @@ void mmr_packet_dropped(net_message_t *message, uint16_t next_hop, int error)
/* Find next hop to source */
route_table_entry_t *rte = rt_lookup_route(message->source);
if(rte != NULL) {
if (rte != NULL) {
generate_route_error_message(message->source, rte->gateway,
rte->interface_id,
RERR_NODE_UNREACHABLE,
@ -926,15 +926,15 @@ void mmr_receive(void *msg, int msg_size, packet_info_t *packet_info)
uint8_t *p = (uint8_t *) msg;
uint8_t type = p[0];
if(type == MMR_TYPE_RREQ) {
if (type == MMR_TYPE_RREQ) {
receive_route_request_message((mmr_rreq_message_t *)msg, packet_info);
mmr_stats.rreq_received++;
}
else if(type == MMR_TYPE_RREP) {
else if (type == MMR_TYPE_RREP) {
receive_route_reply_message((mmr_rrep_message_t *)msg, packet_info);
mmr_stats.rrep_received++;
}
else if(type == MMR_TYPE_RERR) {
else if (type == MMR_TYPE_RERR) {
receive_route_error_message((mmr_rerr_message_t *)msg, packet_info);
mmr_stats.rerr_received++;
}

152
sys/net/mm/mmstack.c
View File

@ -188,45 +188,45 @@ static route_interface_t r_iface = {
ASCCMD(route, CMDFLAG_SERIAL, "[-adfFg] print kernel route table");
CMD_FUNCTION(route, cmdargs)
{
if(cmdargs->arg_size > 0) {
if (cmdargs->arg_size > 0) {
char *msg = (char *)cmdargs->args;
while(*msg == ' ') {
while (*msg == ' ') {
msg++;
}
if(*msg == '-' && *(msg + 1) == 'f') {
if (*msg == '-' && *(msg + 1) == 'f') {
mms_flush_routes(false);
printf("Kernel route table flushed (non-static)!\n");
return CMD_SUCCESS;
}
else if(*msg == '-' && *(msg + 1) == 'F') {
else if (*msg == '-' && *(msg + 1) == 'F') {
mms_flush_routes(true);
printf("Kernel route table flushed (static)!\n");
return CMD_SUCCESS;
}
else if(*msg == '-' && *(msg + 1) == 'd') {
else if (*msg == '-' && *(msg + 1) == 'd') {
msg++;
msg++;
while(*msg == ' ') {
while (*msg == ' ') {
msg++;
}
uint16_t address = net_strtoaddr(msg, &msg);
if(rt_remove_static_route(address)) {
if (rt_remove_static_route(address)) {
printf("Static route deleted successfully!\n");
return CMD_SUCCESS;
}
return CMD_ERROR;
}
else if(*msg == '-' && *(msg + 1) == 'g') {
else if (*msg == '-' && *(msg + 1) == 'g') {
msg++;
msg++;
while(*msg == ' ') {
while (*msg == ' ') {
msg++;
}
@ -235,11 +235,11 @@ CMD_FUNCTION(route, cmdargs)
printf("%u static route(s) deleted!\n", c);
return CMD_SUCCESS;
}
else if(*msg == '-' && *(msg + 1) == 'a') {
else if (*msg == '-' && *(msg + 1) == 'a') {
msg++;
msg++;
while(*msg == ' ') {
while (*msg == ' ') {
msg++;
}
@ -248,8 +248,8 @@ CMD_FUNCTION(route, cmdargs)
int metric = (int)strtoul(msg, &msg, 0);
int iface = (int)strtoul(msg, &msg, 0);
if(address != 0 && gateway != 0) {
if(rt_add_static_route(address, gateway, metric, iface)) {
if (address != 0 && gateway != 0) {
if (rt_add_static_route(address, gateway, metric, iface)) {
printf("Static route added successfully!\n");
return CMD_SUCCESS;
}
@ -281,42 +281,42 @@ CMD_FUNCTION(route, cmdargs)
ASCCMD(ifconfig, CMDFLAG_SERIAL, "[IFACE]: print interface configuration");
CMD_FUNCTION(ifconfig, cmdargs)
{
if(cmdargs->arg_size > 0) {
if (cmdargs->arg_size > 0) {
char *msg;
int iface = (int)strtoul(cmdargs->args, &msg, 0);
if(cmdargs->arg_size > 1) {
while(*msg == ' ') {
if (cmdargs->arg_size > 1) {
while (*msg == ' ') {
msg++;
}
if(*msg == '-' && (*(msg + 1) == 'P' || *(msg + 1) == 'p')) {
if (*msg == '-' && (*(msg + 1) == 'P' || *(msg + 1) == 'p')) {
msg++;
msg++;
uint8_t power = (uint8_t)strtoul(msg, &msg, 0);
if(*msg != '\0') {
if (*msg != '\0') {
return CMD_ERROR;
}
if(mms_set_output_power(iface, power)) {
if (mms_set_output_power(iface, power)) {
printf("Output power set!\n");
return CMD_SUCCESS;
}
return CMD_ERROR;
}
else if(*msg == '-' && (*(msg + 1) == 'A' || *(msg + 1) == 'a')) {
else if (*msg == '-' && (*(msg + 1) == 'A' || *(msg + 1) == 'a')) {
msg++;
msg++;
while(*msg == ' ') {
while (*msg == ' ') {
msg++;
}
uint16_t address = net_strtoaddr(msg, &msg);
if(mms_set_interface_address(iface, address)) {
if (mms_set_interface_address(iface, address)) {
printf("Interface address set!\n");
return CMD_SUCCESS;
}
@ -344,7 +344,7 @@ CMD_FUNCTION(ifconfig, cmdargs)
ASCCMD(ping, CMDFLAG_SERIAL, "ping [-bchpstw] destination");
CMD_FUNCTION(ping, cmdargs)
{
if(cmdargs->arg_size > 0) {
if (cmdargs->arg_size > 0) {
int i;
msg m;
uint8_t count = MMS_PING_PACKETS;
@ -358,26 +358,26 @@ CMD_FUNCTION(ping, cmdargs)
const char *msg = cmdargs->args;
read_ping_cmd:
while(*msg == ' ') {
while (*msg == ' ') {
msg++;
}
if(*msg == '-' && (*(msg + 1) == 'B' || *(msg + 1) == 'b')) {
if (*msg == '-' && (*(msg + 1) == 'B' || *(msg + 1) == 'b')) {
bc = true;
msg++;
msg++;
goto read_ping_cmd;
}
else if(*msg == '-' && (*(msg + 1) == 'C' || *(msg + 1) == 'c')) {
else if (*msg == '-' && (*(msg + 1) == 'C' || *(msg + 1) == 'c')) {
msg++;
msg++;
unsigned long tc = strtoul(msg, (char **)&msg, 0);
if(tc == 0) {
if (tc == 0) {
return CMD_ERROR;
}
if(tc > 255) {
if (tc > 255) {
puts("Not more than 255 ping messages allowed!");
return CMD_ERROR;
}
@ -385,7 +385,7 @@ CMD_FUNCTION(ping, cmdargs)
count = (uint8_t) tc;
goto read_ping_cmd;
}
else if(*msg == '-' && (*(msg + 1) == 'H' || *(msg + 1) == 'h')) {
else if (*msg == '-' && (*(msg + 1) == 'H' || *(msg + 1) == 'h')) {
printf("Usage: ping [-bchpstw] destination\n\n");
printf(" -b, do a broadcast ping\n");
printf(" -c <COUNT>, set number of ping messages\n");
@ -399,19 +399,19 @@ CMD_FUNCTION(ping, cmdargs)
printf(" -w <WAIT>, time to wait for a response, in seconds (default: 3)\n\n");
return CMD_SUCCESS;
}
else if(*msg == '-' && (*(msg + 1) == 'p' || *(msg + 1) == 'P')) {
else if (*msg == '-' && (*(msg + 1) == 'p' || *(msg + 1) == 'P')) {
msg++;
msg++;
unsigned long tp = strtoul(msg, (char **)&msg, 0);
if(tp == 0) {
if (tp == 0) {
return CMD_ERROR;
}
if(tp == 1) {
if (tp == 1) {
prio = 0;
}
else if(tp == 2) {
else if (tp == 2) {
prio = 1;
}
else {
@ -420,30 +420,30 @@ CMD_FUNCTION(ping, cmdargs)
goto read_ping_cmd;
}
else if(*msg == '-' && (*(msg + 1) == 's' || *(msg + 1) == 'S')) {
else if (*msg == '-' && (*(msg + 1) == 's' || *(msg + 1) == 'S')) {
ping_silent_mode = true;
msg++;
msg++;
goto read_ping_cmd;
}
else if(*msg == '-' && (*(msg + 1) == 't' || *(msg + 1) == 'T')) {
else if (*msg == '-' && (*(msg + 1) == 't' || *(msg + 1) == 'T')) {
msg++;
msg++;
unsigned long to = strtoul(msg, (char **)&msg, 0);
if(to == 0 || to > 255) {
if (to == 0 || to > 255) {
return CMD_ERROR;
}
ttl = to;
goto read_ping_cmd;
}
else if(*msg == '-' && (*(msg + 1) == 'w' || *(msg + 1) == 'W')) {
else if (*msg == '-' && (*(msg + 1) == 'w' || *(msg + 1) == 'W')) {
msg++;
msg++;
unsigned long to = strtoul(msg, (char **)&msg, 0);
if(to == 0) {
if (to == 0) {
return CMD_ERROR;
}
@ -453,20 +453,20 @@ CMD_FUNCTION(ping, cmdargs)
uint16_t address = net_strtoaddr((char *)msg, (char **)&msg);
if(address == 0) {
if (address == 0) {
return CMD_ERROR;
}
int iface_addr = net_get_address_in_subnet(address);
/* No ping to unsupported network or own address */
if(iface_addr == 0 || iface_addr == address) {
if (iface_addr == 0 || iface_addr == address) {
return CMD_ERROR;
}
/* If broadcast destination address, limit TTL to one hop */
if(address == NETWORK_ADDR_BC(address)) {
if(!bc) {
if (address == NETWORK_ADDR_BC(address)) {
if (!bc) {
puts("Do you want to ping broadcast? Then -b");
return CMD_ERROR;
}
@ -478,7 +478,7 @@ CMD_FUNCTION(ping, cmdargs)
/* Try to malloc duplicate detection buffer */
dups = (bool *) malloc(count * sizeof(bool));
if(dups == NULL) {
if (dups == NULL) {
puts("Not enough system memory to fulfill your request!");
return CMD_ERROR;
}
@ -494,7 +494,7 @@ CMD_FUNCTION(ping, cmdargs)
mms_ping_pid = fk_thread->pid;
long ts_start = (uint32_t)clock_get_systemtime();
for(i = 1; i <= count; i++) {
for (i = 1; i <= count; i++) {
/* No duplicate for this sequence number possible */
dups[i - 1] = false;
/* Send ping echo request to destination */
@ -510,7 +510,7 @@ CMD_FUNCTION(ping, cmdargs)
ts_start = (uint32_t)clock_get_systemtime() - ts_start;
printf("--- %s ping statistics ---\n", adrbuf);
if(mms_ping_dups == 0) {
if (mms_ping_dups == 0) {
printf("%u packets transmitted, %u received, %u%% packet loss, time %lu ms\n", count,
mms_ping_packets, ((count - mms_ping_packets) * 100) / count, ts_start);
}
@ -519,11 +519,11 @@ CMD_FUNCTION(ping, cmdargs)
mms_ping_packets, mms_ping_dups, ((count - mms_ping_packets) * 100) / count, ts_start);
}
if(mms_ping_packets > 0) {
if (mms_ping_packets > 0) {
printf("rtt min/avg/max = %.2f/%.2f/%.2f ms\n", rtt_min, rtt_avg / (mms_ping_packets + mms_ping_dups), rtt_max);
}
if(!ping_bc_mode && mms_ping_packets == count) {
if (!ping_bc_mode && mms_ping_packets == count) {
/* Calculate approximate throughput */
printf("--- %s throughput statistics ---\n", adrbuf);
float bw = (count * (8 + 4 + 62 + 2) * 1000) / (float)ts_start; /* for CC1100 */
@ -550,15 +550,15 @@ CMD_FUNCTION(ping, cmdargs)
ASCCMD(ssh, CMDFLAG_SERIAL, "Usage: ssh [-q] destination");
CMD_FUNCTION(ssh, cmdargs)
{
if(cmdargs->arg_size > 0) {
if (cmdargs->arg_size > 0) {
bool quit = false;
const char *msg = cmdargs->args;
while(*msg == ' ') {
while (*msg == ' ') {
msg++;
}
if(*msg == '-' && (*(msg + 1) == 'Q' || *(msg + 1) == 'q')) {
if (*msg == '-' && (*(msg + 1) == 'Q' || *(msg + 1) == 'q')) {
quit = true;
msg++;
msg++;
@ -566,23 +566,23 @@ CMD_FUNCTION(ssh, cmdargs)
uint16_t address = net_strtoaddr((char *)msg, (char **)&msg);
if(address == 0) {
if (address == 0) {
return CMD_ERROR;
}
int iface_addr = net_get_address_in_subnet(address);
/* No ssh to unsupported network or own address */
if(iface_addr == 0 || iface_addr == address) {
if (iface_addr == 0 || iface_addr == address) {
return CMD_ERROR;
}
/* If broadcast destination address, also exit here */
if(address == NETWORK_ADDR_BC(address)) {
if (address == NETWORK_ADDR_BC(address)) {
return CMD_ERROR;
}
if(!quit) {
if (!quit) {
mms_ssh_connect(address);
}
else {
@ -605,19 +605,19 @@ static void mms_ping_handler(void *message, int message_size,
{
mms_ping_message_t *ping = (mms_ping_message_t *)message;
if(ping->type == MMS_PING_ECHO_REQUEST) {
if (ping->type == MMS_PING_ECHO_REQUEST) {
ping->type = MMS_PING_ECHO_REPLY;
net_send((void *)ping, sizeof(mms_ping_message_t), packet_info->source,
LAYER_2_PROTOCOL_PING, packet_info->tos, 10);
}
else if(ping->type == MMS_PING_ECHO_REPLY) {
if(ping->identifier == mms_ping_last_proc_id) {
else if (ping->type == MMS_PING_ECHO_REPLY) {
if (ping->identifier == mms_ping_last_proc_id) {
msg m;
bool wasDup = false;
char *msgDup;
char buf[10];
if(dups[ping->seq_num - 1]) {
if (dups[ping->seq_num - 1]) {
wasDup = true;
mms_ping_dups++;
msgDup = "(DUP!)";
@ -628,30 +628,30 @@ static void mms_ping_handler(void *message, int message_size,
msgDup = "";
}
if(!ping_bc_mode && !wasDup) {
if (!ping_bc_mode && !wasDup) {
utimer_remove(&mms_ping_utimer); /* Stop timeout timer */
}
float ms = ((uint32_t)clock_get_systemtime() - ping->timestamp);
if(ms < rtt_min) {
if (ms < rtt_min) {
rtt_min = ms;
}
if(ms > rtt_max) {
if (ms > rtt_max) {
rtt_max = ms;
}
rtt_avg += ms;
if(!ping_silent_mode) {
if (!ping_silent_mode) {
net_addrtostr(packet_info->source, buf, sizeof(buf));
printf("%lu bytes from %s: seq=%u ttl=%u time=%.2f ms %s\n",
sizeof(mms_ping_message_t), buf,
ping->seq_num, *packet_info->ttl_ptr, ms, msgDup);
}
if(!ping_bc_mode && !wasDup) {
if (!ping_bc_mode && !wasDup) {
msg_send(&m, mms_ping_pid, false);
}
}
@ -704,15 +704,15 @@ static void mms_ssh_handler(void *message, int message_size,
char adrbuf[10];
mms_ssh_message_t *ssh = (mms_ssh_message_t *)message;
if(ssh->type == MMS_SSH_CON_REQUEST) {
if(ssh_socket > -1) {
if (ssh->type == MMS_SSH_CON_REQUEST) {
if (ssh_socket > -1) {
mms_ssh_reply_connect(packet_info->source, -1, false);
return;
}
ssh_socket = trans_socket(SOCK_TCPL);
if(ssh_socket < 0) {
if (ssh_socket < 0) {
mms_ssh_reply_connect(packet_info->source, -1, false);
return;
}
@ -720,27 +720,27 @@ static void mms_ssh_handler(void *message, int message_size,
trans_connect(ssh_socket, packet_info->source);
mms_ssh_reply_connect(packet_info->source, ssh_socket, true);
}
else if(ssh->type == MMS_SSH_CON_ACCEPT) {
else if (ssh->type == MMS_SSH_CON_ACCEPT) {
net_addrtostr(packet_info->source, adrbuf, sizeof(adrbuf));
printf("SSH connection accepted by %s\n", adrbuf);
}
else if(ssh->type == MMS_SSH_CON_REJECT) {
else if (ssh->type == MMS_SSH_CON_REJECT) {
net_addrtostr(packet_info->source, adrbuf, sizeof(adrbuf));
printf("SSH connection rejected by %s\n", adrbuf);
}
else if(ssh->type == MMS_SSH_CON_CLOSE) {
if(ssh_socket > -1) {
else if (ssh->type == MMS_SSH_CON_CLOSE) {
if (ssh_socket > -1) {
uint16_t peer;
trans_getpeername(ssh_socket, &peer);
if(peer == packet_info->source) {
if(trans_close(ssh_socket, CLOSE_IMMEDIATE) == 1) {
if (peer == packet_info->source) {
if (trans_close(ssh_socket, CLOSE_IMMEDIATE) == 1) {
ssh_socket = -1;
}
}
}
}
else if(ssh->type == MMS_SSH_DATA) {
else if (ssh->type == MMS_SSH_DATA) {
mms_ssh_data_message_t *ssh_data = (mms_ssh_data_message_t *)message;
printf((char *)ssh_data->data);
fflush(stderr);
@ -749,18 +749,18 @@ static void mms_ssh_handler(void *message, int message_size,
void mms_net_printf(const char *format)
{
if(ssh_socket > -1) {
if (ssh_socket > -1) {
mms_ssh_data_message_t ssh_data;
ssh_data.type = MMS_SSH_DATA;
int i = 0;
int len = strlen(format);
while(i < len) {
while (i < len) {
int chunk = len - i > (MMS_SSH_DATA_MAX - 1) ? (MMS_SSH_DATA_MAX - 1) : len - i;
memset(ssh_data.data, 0, sizeof(ssh_data.data));
memcpy(ssh_data.data, format + i, chunk);
if(trans_send(ssh_socket, (void *)&ssh_data, sizeof(mms_ssh_data_message_t),
if (trans_send(ssh_socket, (void *)&ssh_data, sizeof(mms_ssh_data_message_t),
LAYER_3_PROTOCOL_SSH, PRIORITY_DATA) < 0) {
break;
}

38
sys/net/net_help/inet_ntop.c
View File

@ -39,20 +39,20 @@ static const char *inet_ntop4(const unsigned char *src, char *dst, size_t size)
int n = 0;
char *next = dst;
if(size < MIN_SIZE) {
if (size < MIN_SIZE) {
return NULL;
}
do {
unsigned char u = *src++;
if(u > 99) {
if (u > 99) {
*next++ = '0' + u / 100;
u %= 100;
*next++ = '0' + u / 10;
u %= 10;
}
else if(u > 9) {
else if (u > 9) {
*next++ = '0' + u / 10;
u %= 10;
}
@ -61,7 +61,7 @@ static const char *inet_ntop4(const unsigned char *src, char *dst, size_t size)
*next++ = '.';
n++;
}
while(n < 4);
while (n < 4);
*--next = 0;
return dst;
@ -107,8 +107,8 @@ static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
next_word |= (unsigned int) *next_src++;
*next_dest++ = next_word;
if(next_word == 0) {
if(cur.base == -1) {
if (next_word == 0) {
if (cur.base == -1) {
cur.base = i;
cur.len = 1;
}
@ -117,8 +117,8 @@ static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
}
}
else {
if(cur.base != -1) {
if(best.base == -1 || cur.len > best.len) {
if (cur.base != -1) {
if (best.base == -1 || cur.len > best.len) {
best = cur;
}
@ -128,15 +128,15 @@ static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
i++;
}
while(next_src < src_end);
while (next_src < src_end);
if(cur.base != -1) {
if(best.base == -1 || cur.len > best.len) {
if (cur.base != -1) {
if (best.base == -1 || cur.len > best.len) {
best = cur;
}
}
if(best.base != -1 && best.len < 2) {
if (best.base != -1 && best.len < 2) {
best.base = -1;
}
@ -145,23 +145,23 @@ static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
*/
tp = tmp;
for(i = 0; i < (IN6ADDRSZ / INT16SZ);) {
for (i = 0; i < (IN6ADDRSZ / INT16SZ);) {
/* Are we inside the best run of 0x00's? */
if(i == best.base) {
if (i == best.base) {
*tp++ = ':';
i += best.len;
continue;
}
/* Are we following an initial run of 0x00s or any real hex? */
if(i != 0) {
if (i != 0) {
*tp++ = ':';
}
/* Is this address an encapsulated IPv4? */
if(i == 6 && best.base == 0 &&
if (i == 6 && best.base == 0 &&
(best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
if(!inet_ntop4(src + 12, tp, sizeof tmp - (tp - tmp))) {
if (!inet_ntop4(src + 12, tp, sizeof tmp - (tp - tmp))) {
return (NULL);
}
@ -174,7 +174,7 @@ static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
}
/* Was it a trailing run of 0x00's? */
if(best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) {
if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) {
*tp++ = ':';
}
@ -183,7 +183,7 @@ static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
/*
* Check for overflow, copy, and we're done.
*/
if((size_t)(tp - tmp) > size) {
if ((size_t)(tp - tmp) > size) {
return (NULL);
}

48
sys/net/net_help/inet_pton.c
View File

@ -42,28 +42,28 @@ static int inet_pton4(const char *src, unsigned char *dst)
octets = 0;
*(tp = tmp) = 0;
while((ch = *src++) != '\0') {
while ((ch = *src++) != '\0') {
const char *pch;
if((pch = strchr(digits, ch)) != NULL) {
if ((pch = strchr(digits, ch)) != NULL) {
unsigned int new = *tp * 10 + (unsigned int)(pch - digits);
if(new > 255) {
if (new > 255) {
return (0);
}
*tp = new;
if(! saw_digit) {
if(++octets > 4) {
if (!saw_digit) {
if (++octets > 4) {
return (0);
}
saw_digit = 1;
}
}
else if(ch == '.' && saw_digit) {
if(octets == 4) {
else if (ch == '.' && saw_digit) {
if (octets == 4) {
return (0);
}
@ -75,7 +75,7 @@ static int inet_pton4(const char *src, unsigned char *dst)
}
}
if(octets < 4) {
if (octets < 4) {
return (0);
}
@ -110,8 +110,8 @@ static int inet_pton6(const char *src, unsigned char *dst)
colonp = NULL;
/* Leading :: requires some special handling. */
if(*src == ':')
if(*++src != ':') {
if (*src == ':')
if (*++src != ':') {
return (0);
}
@ -119,18 +119,18 @@ static int inet_pton6(const char *src, unsigned char *dst)
saw_xdigit = 0;
val = 0;
while((ch = *src++) != '\0') {
while ((ch = *src++) != '\0') {
const char *pch;
if((pch = strchr((xdigits = xdigits_l), ch)) == NULL) {
if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL) {
pch = strchr((xdigits = xdigits_u), ch);
}
if(pch != NULL) {
if (pch != NULL) {
val <<= 4;
val |= (pch - xdigits);
if(val > 0xffff) {
if (val > 0xffff) {
return (0);
}
@ -138,11 +138,11 @@ static int inet_pton6(const char *src, unsigned char *dst)
continue;
}
if(ch == ':') {
if (ch == ':') {
curtok = src;
if(!saw_xdigit) {
if(colonp) {
if (!saw_xdigit) {
if (colonp) {
return (0);
}
@ -150,7 +150,7 @@ static int inet_pton6(const char *src, unsigned char *dst)
continue;
}
if(tp + INT16SZ > endp) {
if (tp + INT16SZ > endp) {
return (0);
}
@ -161,7 +161,7 @@ static int inet_pton6(const char *src, unsigned char *dst)
continue;
}
if(ch == '.' && ((tp + INADDRSZ) <= endp) &&
if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
inet_pton4(curtok, tp) > 0) {
tp += INADDRSZ;
saw_xdigit = 0;
@ -171,8 +171,8 @@ static int inet_pton6(const char *src, unsigned char *dst)
return (0);
}
if(saw_xdigit) {
if(tp + INT16SZ > endp) {
if (saw_xdigit) {
if (tp + INT16SZ > endp) {
return (0);
}
@ -180,7 +180,7 @@ static int inet_pton6(const char *src, unsigned char *dst)
*tp++ = (unsigned char) val & 0xff;
}
if(colonp != NULL) {
if (colonp != NULL) {
/*
* Since some memmove()'s erroneously fail to handle
* overlapping regions, we'll do the shift by hand.
@ -188,7 +188,7 @@ static int inet_pton6(const char *src, unsigned char *dst)
const ssize_t n = tp - colonp;
ssize_t i;
for(i = 1; i <= n; i++) {
for (i = 1; i <= n; i++) {
endp[- i] = colonp[n - i];
colonp[n - i] = 0;
}
@ -196,7 +196,7 @@ static int inet_pton6(const char *src, unsigned char *dst)
tp = endp;
}
if(tp != endp) {
if (tp != endp) {
return (0);
}

12
sys/net/net_help/net_help.c
View File

@ -16,7 +16,7 @@ void printArrayRange(uint8_t *array, uint16_t len, char *str)
int i = 0;
printf("-------------%s-------------\n", str);
for(i = 0; i < len; i++) {
for (i = 0; i < len; i++) {
printf("%#x ", *(array + i));
}
@ -30,8 +30,8 @@ uint16_t csum(uint16_t sum, uint8_t *buf, uint16_t len)
count = len >> 1;
if(count) {
if(count) {
if (count) {
if (count) {
carry = 0;
do {
@ -42,17 +42,17 @@ uint16_t csum(uint16_t sum, uint8_t *buf, uint16_t len)
sum += t;
carry = (t > sum);
}
while(count);
while (count);
sum += carry;
}
}
if(len & 1) {
if (len & 1) {
uint16_t u = (*buf << 8);
sum += (*buf << 8);
if(sum < u) {
if (sum < u) {
sum++;
}
}

20
sys/net/protocol-multiplex/protocol-multiplex.c
View File

@ -69,8 +69,8 @@ int pm_find_handler_index(const pm_table_t *table, protocol_t protocol,
int i;
handler_entry_t *e = &table->handler[start];
for(i = start; i < table->size; i++, e++) {
if(e->protocol == protocol) {
for (i = start; i < table->size; i++, e++) {
if (e->protocol == protocol) {
return i;
}
}
@ -82,7 +82,7 @@ int pm_set_handler(const pm_table_t *table, protocol_t protocol,
packet_handler_t handler)
{
/* Reject illegal values */
if(protocol == 0 || handler == NULL) {
if (protocol == 0 || handler == NULL) {
PRINTF("proto %u rejected", protocol);
return -1;
}
@ -90,10 +90,10 @@ int pm_set_handler(const pm_table_t *table, protocol_t protocol,
/* Check if there is already a handler for given protocol */
int index = pm_find_handler_index(table, protocol, 0);
if(index >= 0) {
if (index >= 0) {
/* Two handlers for same protocol not allowed because only
* one gets called. This hasn't to be the last one who
* registered! */
* registered!*/
PRINTF("proto %u handler found, reset", protocol);
table->handler[index].protocol = 0;
table->handler[index].handler = NULL;
@ -103,7 +103,7 @@ int pm_set_handler(const pm_table_t *table, protocol_t protocol,
index = pm_find_handler_index(table, 0, 0);
/* Store handler if free index found */
if(index >= 0) {
if (index >= 0) {
PRINTF("proto %u, set", protocol);
table->handler[index].protocol = protocol;
table->handler[index].handler = handler;
@ -118,8 +118,8 @@ void pm_remove_handler(const pm_table_t *table, protocol_t protocol,
{
int i;
for(i = 0; i < table->size; i++) {
if(table->handler[i].protocol == protocol && table->handler[i].handler == handler) {
for (i = 0; i < table->size; i++) {
if (table->handler[i].protocol == protocol && table->handler[i].handler == handler) {
PRINTF("proto %u handler found, reset", protocol);
table->handler[i].protocol = 0;
table->handler[i].handler = NULL;
@ -133,11 +133,11 @@ int pm_invoke(const pm_table_t *table, protocol_t protocol, void *payload,
int index = 0;
/* Reject illegal values */
if(protocol == 0) {
if (protocol == 0) {
return -1;
}
if((index = pm_find_handler_index(table, protocol, index)) != -1) {
if ((index = pm_find_handler_index(table, protocol, index)) != -1) {
PRINTF("proto %u, invoke", protocol);
table->handler[index].handler(payload, payload_size, packet_info);
}

34
sys/net/sixlowpan/bordermultiplex.c
View File

@ -37,16 +37,16 @@
void demultiplex(border_packet_t *packet, int len)
{
switch(packet->type) {
case(BORDER_PACKET_RAW_TYPE): {
case (BORDER_PACKET_RAW_TYPE): {
fputs(((char *)packet) + sizeof(border_packet_t), stdin);
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(BORDER_ETHERTYPE_IPV6): {
case (BORDER_ETHERTYPE_IPV6): {
ipv6_hdr_t *ipv6_buf = (ipv6_hdr_t *)(((unsigned char *)packet) + sizeof(border_l3_header_t));
border_send_ipv6_over_lowpan(ipv6_buf, 1, 1);
break;
@ -60,11 +60,11 @@ void demultiplex(border_packet_t *packet, int len)
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_CONTEXT): {
case (BORDER_CONF_CONTEXT): {
border_context_packet_t *context = (border_context_packet_t *)packet;
ipv6_addr_t target_addr;
ipv6_set_all_nds_mcast_addr(&target_addr);
@ -82,7 +82,7 @@ void demultiplex(border_packet_t *packet, int len)
break;
}
case(BORDER_CONF_IPADDR): {
case (BORDER_CONF_IPADDR): {
//border_addr_packet_t *addr_packet = (border_addr_packet_t *)packet;
/* add address */
break;
@ -134,27 +134,27 @@ int readpacket(uint8_t *packet_buf, size_t size)
uint8_t byte = END + 1;
uint8_t esc = 0;
while(1) {
while (1) {
byte = uart0_readc();
if(byte == END) {
if (byte == END) {
break;
}
if((line_buf_ptr - packet_buf) >= size - 1) {
if ((line_buf_ptr - packet_buf) >= size - 1) {
return -SIXLOWERROR_ARRAYFULL;
}
if(esc) {
if (esc) {
esc = 0;
switch(byte) {
case(END_ESC): {
case (END_ESC): {
*line_buf_ptr++ = END;
continue;
}
case(ESC_ESC): {
case (ESC_ESC): {
*line_buf_ptr++ = ESC;
continue;
}
@ -164,7 +164,7 @@ int readpacket(uint8_t *packet_buf, size_t size)
}
}
if(byte == ESC) {
if (byte == ESC) {
esc = 1;
continue;
}
@ -179,19 +179,19 @@ int writepacket(uint8_t *packet_buf, size_t size)
{
uint8_t *byte_ptr = packet_buf;
while((byte_ptr - packet_buf) < size) {
if((byte_ptr - packet_buf) > BORDER_BUFFER_SIZE) {
while ((byte_ptr - packet_buf) < size) {
if ((byte_ptr - packet_buf) > BORDER_BUFFER_SIZE) {
return -1;
}
switch(*byte_ptr) {
case(END): {
case (END): {
*byte_ptr = END_ESC;
uart0_putc(ESC);
break;
}
case(ESC): {
case (ESC): {
*byte_ptr = ESC_ESC;
uart0_putc(ESC);
break;

2
sys/net/sixlowpan/bordermultiplex.h
View File

@ -80,7 +80,7 @@ typedef struct __attribute__((packed)) {
} context;
} border_context_packet_t;
#define BORDER_BUFFER_SIZE (sizeof (border_l3_header_t) + MTU)
#define BORDER_BUFFER_SIZE (sizeof(border_l3_header_t) + MTU)
void demultiplex(border_packet_t *packet, int len);
void multiplex_send_ipv6_over_uart(ipv6_hdr_t *packet);

26
sys/net/sixlowpan/flowcontrol.c
View File

@ -73,13 +73,13 @@ ipv6_addr_t flowcontrol_init(void)
sem_init(&slwin_stat.send_win_not_full, BORDER_SWS);
for(i = 0; i < BORDER_SWS; i++) {
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);
for(i = 0; i < BORDER_RWS; i++) {
for (i = 0; i < BORDER_RWS; i++) {
slwin_stat.recv_win[i].received = 0;
slwin_stat.recv_win[i].frame_len = 0;
}
@ -96,16 +96,16 @@ static void sending_slot(void)
struct send_slot *slot;
border_packet_t *tmp;
while(1) {
while (1) {
msg_receive(&m);
seq_num = *((uint8_t *)m.content.ptr);
slot = &(slwin_stat.send_win[seq_num % BORDER_SWS]);
tmp = (border_packet_t *)slot->frame;
if(seq_num == tmp->seq_num) {
if (seq_num == tmp->seq_num) {
writepacket(slot->frame, slot->frame_len);
if(set_timeout(&slot->timeout, BORDER_SL_TIMEOUT, (void *)m.content.ptr) != 0) {
if (set_timeout(&slot->timeout, BORDER_SL_TIMEOUT, (void *)m.content.ptr) != 0) {
printf("ERROR: Error invoking timeout timer\n");
}
}
@ -139,7 +139,7 @@ void flowcontrol_send_over_uart(border_packet_t *packet, int len)
memcpy(slot->frame, (uint8_t *)packet, len);
slot->frame_len = len;
if(set_timeout(&slot->timeout, BORDER_SL_TIMEOUT, (void *)args) != 0) {
if (set_timeout(&slot->timeout, BORDER_SL_TIMEOUT, (void *)args) != 0) {
printf("ERROR: Error invoking timeout timer\n");
return;
}
@ -158,9 +158,9 @@ void send_ack(uint8_t seq_num)
void flowcontrol_deliver_from_uart(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)) {
if(synack_seqnum == packet->seq_num) {
if (packet->type == BORDER_PACKET_ACK_TYPE) {
if (in_window(packet->seq_num, slwin_stat.last_ack + 1, slwin_stat.last_frame)) {
if (synack_seqnum == packet->seq_num) {
synack_seqnum = -1;
sem_signal(&connection_established);
}
@ -172,7 +172,7 @@ void flowcontrol_deliver_from_uart(border_packet_t *packet, int len)
memset(&slot->frame, 0, BORDER_BUFFER_SIZE);
sem_signal(&slwin_stat.send_win_not_full);
}
while(slwin_stat.last_ack != packet->seq_num);
while (slwin_stat.last_ack != packet->seq_num);
}
}
else {
@ -180,7 +180,7 @@ void flowcontrol_deliver_from_uart(border_packet_t *packet, int len)
slot = &(slwin_stat.recv_win[packet->seq_num % BORDER_RWS]);
if(!in_window(packet->seq_num,
if (!in_window(packet->seq_num,
slwin_stat.next_exp,
slwin_stat.next_exp + BORDER_RWS - 1)) {
return;
@ -189,8 +189,8 @@ void flowcontrol_deliver_from_uart(border_packet_t *packet, int len)
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, BORDER_BUFFER_SIZE);
slot->received = 0;

42
sys/net/sixlowpan/ieee802154_frame.c
View File

@ -44,7 +44,7 @@ uint8_t init_802154_frame(ieee802154_frame_t *frame, uint8_t *buf)
index++;
/* Destination PAN Identifier - 802.15.4 - 2006 - 7.2.1.3 */
if(frame->fcf.dest_addr_m == 0x02 || frame->fcf.dest_addr_m == 0x03) {
if (frame->fcf.dest_addr_m == 0x02 || frame->fcf.dest_addr_m == 0x03) {
buf[index] = ((frame->dest_pan_id >> 8) & 0xff);
buf[index + 1] = (frame->dest_pan_id & 0xff);
}
@ -52,12 +52,12 @@ uint8_t init_802154_frame(ieee802154_frame_t *frame, uint8_t *buf)
index += 2;
/* Destination Address - 802.15.4 - 2006 - 7.2.1.4 */
if(frame->fcf.dest_addr_m == 0x02) {
if (frame->fcf.dest_addr_m == 0x02) {
buf[index] = frame->dest_addr[0];
buf[index + 1] = frame->dest_addr[1];
index += 2;
}
else if(frame->fcf.dest_addr_m == 0x03) {
else if (frame->fcf.dest_addr_m == 0x03) {
buf[index] = frame->dest_addr[0];
buf[index + 1] = frame->dest_addr[1];
buf[index + 2] = frame->dest_addr[2];
@ -70,8 +70,8 @@ uint8_t init_802154_frame(ieee802154_frame_t *frame, uint8_t *buf)
}
/* Source PAN Identifier - 802.15.4 - 2006 - 7.2.1.5 */
if(!(frame->fcf.panid_comp & 0x01)) {
if(frame->fcf.src_addr_m == 0x02 || frame->fcf.src_addr_m == 0x03) {
if (!(frame->fcf.panid_comp & 0x01)) {
if (frame->fcf.src_addr_m == 0x02 || frame->fcf.src_addr_m == 0x03) {
buf[index] = ((frame->src_pan_id >> 8) & 0xff);
buf[index + 1] = (frame->src_pan_id & 0xff);
index += 2;
@ -79,12 +79,12 @@ uint8_t init_802154_frame(ieee802154_frame_t *frame, uint8_t *buf)
}
/* Source Address field - 802.15.4 - 2006 - 7.2.1.6 */
if(frame->fcf.src_addr_m == 0x02) {
if (frame->fcf.src_addr_m == 0x02) {
buf[index] = frame->src_addr[0];
buf[index + 1] = frame->src_addr[1];
index += 2;
}
else if(frame->fcf.src_addr_m == 0x03) {
else if (frame->fcf.src_addr_m == 0x03) {
buf[index] = frame->src_addr[0];
buf[index + 1] = frame->src_addr[1];
buf[index + 2] = frame->src_addr[2];
@ -108,30 +108,30 @@ uint8_t get_802154_hdr_len(ieee802154_frame_t *frame)
{
uint8_t len = 0;
if(frame->fcf.dest_addr_m == 0x02) {
if (frame->fcf.dest_addr_m == 0x02) {
len += 2;
}
else if(frame->fcf.dest_addr_m == 0x03) {
else if (frame->fcf.dest_addr_m == 0x03) {
len += 8;
}
if(frame->fcf.src_addr_m == 0x02) {
if (frame->fcf.src_addr_m == 0x02) {
len += 2;
}
else if(frame->fcf.src_addr_m == 0x03) {
else if (frame->fcf.src_addr_m == 0x03) {
len += 8;
}
if((frame->fcf.dest_addr_m == 0x02) || (frame->fcf.dest_addr_m == 0x03)) {
if ((frame->fcf.dest_addr_m == 0x02) || (frame->fcf.dest_addr_m == 0x03)) {
len += 2;
}
if((frame->fcf.src_addr_m == 0x02) || (frame->fcf.src_addr_m == 0x03)) {
if ((frame->fcf.src_addr_m == 0x02) || (frame->fcf.src_addr_m == 0x03)) {
len += 2;
}
/* if src pan id == dest pan id set compression bit */
if(frame->src_pan_id == frame->dest_pan_id) {
if (frame->src_pan_id == frame->dest_pan_id) {
frame->fcf.panid_comp = 1;
len -= 2;
}
@ -170,19 +170,19 @@ uint8_t read_802154_frame(uint8_t *buf, ieee802154_frame_t *frame, uint8_t len)
index += 2;
switch(frame->fcf.dest_addr_m) {
case(0): {
case (0): {
printf("fcf.dest_addr_m: pan identifier/address fields empty\n");
break;
}
case(2): {
case (2): {
frame->dest_addr[0] = buf[index];
frame->dest_addr[1] = buf[index + 1];
index += 2;
break;
}
case(3): {
case (3): {
frame->dest_addr[0] = buf[index];
frame->dest_addr[1] = buf[index + 1];
frame->dest_addr[2] = buf[index + 2];
@ -196,25 +196,25 @@ uint8_t read_802154_frame(uint8_t *buf, ieee802154_frame_t *frame, uint8_t len)
}
}
if(!(frame->fcf.panid_comp == 1)) {
if (!(frame->fcf.panid_comp == 1)) {
frame->src_pan_id = (((uint16_t)buf[index]) << 8) | buf[index + 1];
index += 2;
}
switch(frame->fcf.src_addr_m) {
case(0): {
case (0): {
printf("fcf.src_addr_m: pan identifier/address fields empty\n");
break;
}
case(2): {
case (2): {
frame->src_addr[0] = buf[index];
frame->src_addr[1] = buf[index + 1];
index += 2;
break;
}
case(3): {
case (3): {
frame->src_addr[0] = buf[index];
frame->src_addr[1] = buf[index + 1];
frame->src_addr[2] = buf[index + 2];

10
sys/net/sixlowpan/rpl/of0.c
View File

@ -39,8 +39,8 @@ void reset(rpl_dodag_t *dodag)
uint16_t calc_rank(rpl_parent_t *parent, uint16_t base_rank)
{
if(base_rank == 0) {
if(parent == NULL) {
if (base_rank == 0) {
if (parent == NULL) {
return INFINITE_RANK;
}
@ -49,14 +49,14 @@ uint16_t calc_rank(rpl_parent_t *parent, uint16_t base_rank)
uint16_t add;
if(parent != NULL) {
if (parent != NULL) {
add = parent->dodag->minhoprankincrease;
}
else {
add = DEFAULT_MIN_HOP_RANK_INCREASE;
}
if(base_rank + add < base_rank) {
if (base_rank + add < base_rank) {
return INFINITE_RANK;
}
@ -66,7 +66,7 @@ uint16_t calc_rank(rpl_parent_t *parent, uint16_t base_rank)
/* We simply return the Parent with lower rank */
rpl_parent_t *which_parent(rpl_parent_t *p1, rpl_parent_t *p2)
{
if(p1->rank < p2->rank) {
if (p1->rank < p2->rank) {
return p1;
}

182
sys/net/sixlowpan/rpl/rpl.c
View File

@ -174,8 +174,8 @@ static rpl_opt_transit_t *get_rpl_opt_transit_buf(uint8_t rpl_msg_len)
/* Diese Funktion findet eine implementierte OF anhand des Objective Code Point */
rpl_of_t *rpl_get_of_for_ocp(uint16_t ocp)
{
for(uint16_t i = 0; i < NUMBER_IMPLEMENTED_OFS; i++) {
if(ocp == objective_functions[i]->ocp) {
for (uint16_t i = 0; i < NUMBER_IMPLEMENTED_OFS; i++) {
if (ocp == objective_functions[i]->ocp) {
return objective_functions[i];
}
}
@ -188,7 +188,7 @@ uint8_t rpl_init(transceiver_type_t trans, uint16_t rpl_address)
mutex_init(&rpl_send_mutex);
mutex_init(&rpl_recv_mutex);
if(rpl_address == 0) {
if (rpl_address == 0) {
return SIXLOWERROR_ADDRESS;
}
@ -221,7 +221,7 @@ void rpl_init_root(void)
inst = rpl_new_instance(RPL_DEFAULT_INSTANCE);
if(inst == NULL) {
if (inst == NULL) {
printf("Error - No memory for another RPL instance\n");
return;
}
@ -231,7 +231,7 @@ void rpl_init_root(void)
dodag = rpl_new_dodag(RPL_DEFAULT_INSTANCE, &my_address);
if(dodag != NULL) {
if (dodag != NULL) {
dodag->of = (struct rpl_of_t*) rpl_get_of_for_ocp(RPL_DEFAULT_OCP);
dodag->instance = inst;
dodag->mop = RPL_DEFAULT_MOP;
@ -270,7 +270,7 @@ void send_DIO(ipv6_addr_t *destination)
mydodag = rpl_get_my_dodag();
if(mydodag == NULL) {
if (mydodag == NULL) {
printf("Error, trying to send DIO without being part of a dodag. This should not happen\n");
mutex_unlock(&rpl_send_mutex, 0);
return;
@ -292,7 +292,7 @@ void send_DIO(ipv6_addr_t *destination)
rpl_send_dio_buf->dodagid = mydodag->dodag_id;
int opt_hdr_len = 0;
/* DODAG Configuration Option! */
/* DODAG Configuration Option!*/
rpl_send_opt_dodag_conf_buf = get_rpl_send_opt_dodag_conf_buf(DIO_BASE_LEN);
rpl_send_opt_dodag_conf_buf->type = RPL_OPT_DODAG_CONF;
rpl_send_opt_dodag_conf_buf->length = RPL_OPT_DODAG_CONF_LEN;
@ -335,7 +335,7 @@ void send_DIS(ipv6_addr_t *destination)
void send_DAO(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime, uint8_t start_index)
{
if(i_am_root) {
if (i_am_root) {
return;
}
@ -343,11 +343,11 @@ void send_DAO(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime,
rpl_dodag_t *my_dodag;
my_dodag = rpl_get_my_dodag();
if(destination == NULL) {
if (destination == NULL) {
destination = &my_dodag->my_preferred_parent->addr;
}
if(default_lifetime) {
if (default_lifetime) {
lifetime = my_dodag->default_lifetime;
}
@ -357,7 +357,7 @@ void send_DAO(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime,
icmp_send_buf->code = ICMP_CODE_DAO;
icmp_send_buf->checksum = ~icmpv6_csum(PROTO_NUM_ICMPV6);
if(my_dodag == NULL) {
if (my_dodag == NULL) {
mutex_unlock(&rpl_send_mutex, 0);
return;
}
@ -373,8 +373,8 @@ void send_DAO(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime,
uint8_t entries = 0;
uint8_t continue_index = 0;
for(uint8_t i = start_index; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if(routing_table[i].used) {
for (uint8_t i = start_index; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (routing_table[i].used) {
rpl_send_opt_target_buf->type = RPL_OPT_TARGET;
rpl_send_opt_target_buf->length = RPL_OPT_TARGET_LEN;
rpl_send_opt_target_buf->flags = 0x00;
@ -393,7 +393,7 @@ void send_DAO(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime,
entries++;
}
if(entries >= 5) {
if (entries >= 5) {
/* split DAO, so packages dont get too big. */
/* The value 5 is based on experience */
continue_index = i + 1;
@ -422,7 +422,7 @@ void send_DAO(ipv6_addr_t *destination, uint8_t lifetime, bool default_lifetime,
rpl_send(destination, (uint8_t *)icmp_send_buf, plen, PROTO_NUM_ICMPV6, NULL);
mutex_unlock(&rpl_send_mutex, 0);
if(continue_index > 1) {
if (continue_index > 1) {
send_DAO(destination, lifetime, default_lifetime, continue_index);
}
}
@ -433,7 +433,7 @@ void send_DAO_ACK(ipv6_addr_t *destination)
rpl_dodag_t *my_dodag;
my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if (my_dodag == NULL) {
return;
}
@ -463,7 +463,7 @@ void rpl_process(void)
msg_t m_recv;
msg_init_queue(msg_queue, RPL_PKT_RECV_BUF_SIZE);
while(1) {
while (1) {
msg_receive(&m_recv);
uint8_t *code;
code = ((uint8_t *)m_recv.content.ptr);
@ -472,25 +472,25 @@ void rpl_process(void)
memcpy(&rpl_buffer, ipv6_buf, ipv6_buf->length + IPV6_HDR_LEN);
switch(*code) {
case(ICMP_CODE_DIS): {
case (ICMP_CODE_DIS): {
recv_rpl_dis();
mutex_unlock(&rpl_recv_mutex, 0);
break;
}
case(ICMP_CODE_DIO): {
case (ICMP_CODE_DIO): {
recv_rpl_dio();
mutex_unlock(&rpl_recv_mutex, 0);
break;
}
case(ICMP_CODE_DAO): {
case (ICMP_CODE_DAO): {
recv_rpl_dao();
mutex_unlock(&rpl_recv_mutex, 0);
break;
}
case(ICMP_CODE_DAO_ACK): {
case (ICMP_CODE_DAO_ACK): {
recv_rpl_dao_ack();
mutex_unlock(&rpl_recv_mutex, 0);
break;
@ -515,19 +515,19 @@ void recv_rpl_dio(void)
rpl_instance_t *dio_inst = rpl_get_instance(rpl_dio_buf->rpl_instanceid);
rpl_instance_t *my_inst = rpl_get_my_instance();
if(dio_inst == NULL) {
if(my_inst != NULL) {
if (dio_inst == NULL) {
if (my_inst != NULL) {
/* Dieser Knoten ist schon Teil eines DODAGS -> kein beitritt zu anderer Instanz moeglich */
return;
}
dio_inst = rpl_new_instance(rpl_dio_buf->rpl_instanceid);
if(dio_inst == NULL) {
if (dio_inst == NULL) {
return;
}
}
else if(my_inst->id != dio_inst->id) {
else if (my_inst->id != dio_inst->id) {
printf("Andere Instanz, wir haben %d es kam aber %d\n", my_inst->id, dio_inst->id);
/* DIO von fremder Instanz ignorieren, Knoten können Momentan nur
* einer Instanz beitreten und das wird die Instanz sein, der sie als
@ -558,35 +558,35 @@ void recv_rpl_dio(void)
* IPV6_HDR_LEN nicht enthalten, also muss nur noch die ICMPV6_HDR_LEN
* abgezogen werden */
while(len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
while (len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch(rpl_opt_buf->type) {
case(RPL_OPT_PAD1): {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case(RPL_OPT_PADN): {
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_DAG_METRIC_CONTAINER): {
case (RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_ROUTE_INFO): {
case (RPL_OPT_ROUTE_INFO): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_DODAG_CONF): {
case (RPL_OPT_DODAG_CONF): {
has_dodag_conf_opt = 1;
if(rpl_opt_buf->length != RPL_OPT_DODAG_CONF_LEN) {
if (rpl_opt_buf->length != RPL_OPT_DODAG_CONF_LEN) {
/* error malformed */
return;
}
@ -604,8 +604,8 @@ void recv_rpl_dio(void)
break;
}
case(RPL_OPT_PREFIX_INFO): {
if(rpl_opt_buf->length != RPL_OPT_PREFIX_INFO_LEN) {
case (RPL_OPT_PREFIX_INFO): {
if (rpl_opt_buf->length != RPL_OPT_PREFIX_INFO_LEN) {
/* error malformed */
return;
}
@ -623,29 +623,29 @@ void recv_rpl_dio(void)
/* handle packet content... */
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if(!has_dodag_conf_opt) {
if (my_dodag == NULL) {
if (!has_dodag_conf_opt) {
puts("send DIS");
send_DIS(&ipv6_buf->srcaddr);
return;
}
if(rpl_dio_buf->rank < ROOT_RANK) {
if (rpl_dio_buf->rank < ROOT_RANK) {
printf("DIO with Rank < ROOT_RANK\n");
return;
}
if(dio_dodag.mop != RPL_DEFAULT_MOP) {
if (dio_dodag.mop != RPL_DEFAULT_MOP) {
printf("Required MOP not supported\n");
return;
}
if(dio_dodag.of == NULL) {
if (dio_dodag.of == NULL) {
printf("Required objective function not supported\n");
return;
}
if(rpl_dio_buf->rank != INFINITE_RANK) {
if (rpl_dio_buf->rank != INFINITE_RANK) {
puts("Will join DODAG\n");
ipv6_print_addr(&dio_dodag.dodag_id);
rpl_join_dodag(&dio_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
@ -656,10 +656,10 @@ void recv_rpl_dio(void)
}
}
if(rpl_equal_id(&my_dodag->dodag_id, &dio_dodag.dodag_id)) {
if (rpl_equal_id(&my_dodag->dodag_id, &dio_dodag.dodag_id)) {
/* Mein DODAG */
if(RPL_COUNTER_GREATER_THAN(dio_dodag.version, my_dodag->version)) {
if(my_dodag->my_rank == ROOT_RANK) {
if (RPL_COUNTER_GREATER_THAN(dio_dodag.version, my_dodag->version)) {
if (my_dodag->my_rank == ROOT_RANK) {
/* Jemand hat ein DIO mit einer höheren Version als der richtigen gesendet */
/* Wir erhöhen diese Version noch einmal, und machen sie zur neuen */
printf("[Warning] Inconsistent Dodag Version\n");
@ -673,7 +673,7 @@ void recv_rpl_dio(void)
return;
}
else if(RPL_COUNTER_GREATER_THAN(my_dodag->version, dio_dodag.version)) {
else if (RPL_COUNTER_GREATER_THAN(my_dodag->version, dio_dodag.version)) {
/* ein Knoten hat noch eine kleinere Versionsnummer -> mehr DIOs senden */
reset_trickletimer();
return;
@ -681,13 +681,13 @@ void recv_rpl_dio(void)
}
/* Version stimmt, DODAG stimmt */
if(rpl_dio_buf->rank == INFINITE_RANK) {
if (rpl_dio_buf->rank == INFINITE_RANK) {
reset_trickletimer();
}
/* Wenn wir root sind, ist nichts weiter zu tun */
if(my_dodag->my_rank == ROOT_RANK) {
if(rpl_dio_buf->rank != INFINITE_RANK) {
if (my_dodag->my_rank == ROOT_RANK) {
if (rpl_dio_buf->rank != INFINITE_RANK) {
trickle_increment_counter();
}
@ -702,11 +702,11 @@ void recv_rpl_dio(void)
rpl_parent_t *parent;
parent = rpl_find_parent(&ipv6_buf->srcaddr);
if(parent == NULL) {
if (parent == NULL) {
/* neuen möglichen Elternknoten hinzufuegen */
parent = rpl_new_parent(my_dodag, &ipv6_buf->srcaddr, rpl_dio_buf->rank);
if(parent == NULL) {
if (parent == NULL) {
return;
}
}
@ -719,7 +719,7 @@ void recv_rpl_dio(void)
parent->rank = rpl_dio_buf->rank;
rpl_parent_update(parent);
if(rpl_equal_id(&parent->addr, &my_dodag->my_preferred_parent->addr) && (parent->dtsn != rpl_dio_buf->dtsn)) {
if (rpl_equal_id(&parent->addr, &my_dodag->my_preferred_parent->addr) && (parent->dtsn != rpl_dio_buf->dtsn)) {
delay_dao();
}
@ -731,7 +731,7 @@ void recv_rpl_dis(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if (my_dodag == NULL) {
return;
}
@ -739,45 +739,45 @@ void recv_rpl_dis(void)
rpl_dis_buf = get_rpl_dis_buf();
int len = DIS_BASE_LEN;
while(len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
while (len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch(rpl_opt_buf->type) {
case(RPL_OPT_PAD1): {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case(RPL_OPT_PADN): {
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_SOLICITED_INFO): {
case (RPL_OPT_SOLICITED_INFO): {
len += RPL_OPT_SOLICITED_INFO_LEN + 2;
/* extract + check */
if(rpl_opt_buf->length != RPL_OPT_SOLICITED_INFO_LEN) {
if (rpl_opt_buf->length != RPL_OPT_SOLICITED_INFO_LEN) {
/* error malformed */
return;
}
rpl_opt_solicited_buf = get_rpl_opt_solicited_buf(len);
if(rpl_opt_solicited_buf->VID_Flags & RPL_DIS_I_MASK) {
if(my_dodag->instance->id != rpl_opt_solicited_buf->rplinstanceid) {
if (rpl_opt_solicited_buf->VID_Flags & RPL_DIS_I_MASK) {
if (my_dodag->instance->id != rpl_opt_solicited_buf->rplinstanceid) {
return;
}
}
if(rpl_opt_solicited_buf->VID_Flags & RPL_DIS_D_MASK) {
if(!rpl_equal_id(&my_dodag->dodag_id, &rpl_opt_solicited_buf->dodagid)) {
if (rpl_opt_solicited_buf->VID_Flags & RPL_DIS_D_MASK) {
if (!rpl_equal_id(&my_dodag->dodag_id, &rpl_opt_solicited_buf->dodagid)) {
return;
}
}
if(rpl_opt_solicited_buf->VID_Flags & RPL_DIS_V_MASK) {
if(my_dodag->version != rpl_opt_solicited_buf->version) {
if (rpl_opt_solicited_buf->VID_Flags & RPL_DIS_V_MASK) {
if (my_dodag->version != rpl_opt_solicited_buf->version) {
return;
}
}
@ -798,7 +798,7 @@ void recv_rpl_dao(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if (my_dodag == NULL) {
printf("[Error] got DAO without beeing part of a Dodag\n");
return;
}
@ -808,30 +808,30 @@ void recv_rpl_dao(void)
int len = DAO_BASE_LEN;
uint8_t increment_seq = 0;
while(len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
while (len < (ipv6_buf->length - ICMPV6_HDR_LEN)) {
rpl_opt_buf = get_rpl_opt_buf(len);
switch(rpl_opt_buf->type) {
case(RPL_OPT_PAD1): {
case (RPL_OPT_PAD1): {
len += 1;
break;
}
case(RPL_OPT_PADN): {
case (RPL_OPT_PADN): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_DAG_METRIC_CONTAINER): {
case (RPL_OPT_DAG_METRIC_CONTAINER): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_TARGET): {
case (RPL_OPT_TARGET): {
rpl_opt_target_buf = get_rpl_opt_target_buf(len);
if(rpl_opt_target_buf->prefix_length != RPL_DODAG_ID_LEN) {
if (rpl_opt_target_buf->prefix_length != RPL_DODAG_ID_LEN) {
printf("prefixes are not supported yet");
break;
}
@ -839,7 +839,7 @@ void recv_rpl_dao(void)
len += rpl_opt_target_buf->length + 2;
rpl_opt_transit_buf = get_rpl_opt_transit_buf(len);
if(rpl_opt_transit_buf->type != RPL_OPT_TRANSIT) {
if (rpl_opt_transit_buf->type != RPL_OPT_TRANSIT) {
printf("[Error] - no Transit Inforamtion to Target Option, type = %d\n", rpl_opt_transit_buf->type);
break;
}
@ -852,12 +852,12 @@ void recv_rpl_dao(void)
break;
}
case(RPL_OPT_TRANSIT): {
case (RPL_OPT_TRANSIT): {
len += rpl_opt_buf->length + 2;
break;
}
case(RPL_OPT_TARGET_DESC): {
case (RPL_OPT_TARGET_DESC): {
len += rpl_opt_buf->length + 2;
break;
}
@ -869,7 +869,7 @@ void recv_rpl_dao(void)
send_DAO_ACK(&ipv6_buf->srcaddr);
if(increment_seq) {
if (increment_seq) {
RPL_COUNTER_INCREMENT(my_dodag->dao_seq);
delay_dao();
}
@ -879,17 +879,17 @@ void recv_rpl_dao_ack(void)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if (my_dodag == NULL) {
return;
}
rpl_dao_ack_buf = get_rpl_dao_ack_buf();
if(rpl_dao_ack_buf->rpl_instanceid != my_dodag->instance->id) {
if (rpl_dao_ack_buf->rpl_instanceid != my_dodag->instance->id) {
return;
}
if(rpl_dao_ack_buf->status != 0) {
if (rpl_dao_ack_buf->status != 0) {
return;
}
@ -919,21 +919,21 @@ void rpl_send(ipv6_addr_t *destination, uint8_t *payload, uint16_t p_len, uint8_
* der rpl_send_buf verwendet. In diesem Fall muss also keine memcopy
* Aktion durchgeführt werden, da sich der payload bereits im richtigen
* Speicherbereich befindet. */
if(p_ptr != payload) {
if (p_ptr != payload) {
memcpy(p_ptr, payload, p_len);
}
packet_length = IPV6_HDR_LEN + p_len;
if(ipv6_prefix_mcast_match(&ipv6_send_buf->destaddr)) {
if (ipv6_prefix_mcast_match(&ipv6_send_buf->destaddr)) {
lowpan_init((ieee_802154_long_t *)&(ipv6_send_buf->destaddr.uint16[4]), (uint8_t *)ipv6_send_buf);
}
else {
/* find right next hop before sending */
ipv6_addr_t *next_hop = rpl_get_next_hop(&ipv6_send_buf->destaddr);
if(next_hop == NULL) {
if(i_am_root) {
if (next_hop == NULL) {
if (i_am_root) {
/* oops... ich bin root und weiß nicht wohin mit dem paketn */
printf("[Error] destination unknown\n");
return;
@ -941,7 +941,7 @@ void rpl_send(ipv6_addr_t *destination, uint8_t *payload, uint16_t p_len, uint8_
else {
next_hop = rpl_get_my_preferred_parent();
if(next_hop == NULL) {
if (next_hop == NULL) {
/* kein preferred parent eingetragen */
puts("[Error] no preferred parent, dropping package");
return;
@ -956,8 +956,8 @@ void rpl_send(ipv6_addr_t *destination, uint8_t *payload, uint16_t p_len, uint8_
ipv6_addr_t *rpl_get_next_hop(ipv6_addr_t *addr)
{
for(uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if(routing_table[i].used && rpl_equal_id(&routing_table[i].address, addr)) {
for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (routing_table[i].used && rpl_equal_id(&routing_table[i].address, addr)) {
return &routing_table[i].next_hop;
}
}
@ -969,13 +969,13 @@ void rpl_add_routing_entry(ipv6_addr_t *addr, ipv6_addr_t *next_hop, uint16_t li
{
rpl_routing_entry_t *entry = rpl_find_routing_entry(addr);
if(entry != NULL) {
if (entry != NULL) {
entry->lifetime = lifetime;
return;
}
for(uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if(!routing_table[i].used) {
for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (!routing_table[i].used) {
routing_table[i].address = *addr;
routing_table[i].next_hop = *next_hop;
routing_table[i].lifetime = lifetime;
@ -987,8 +987,8 @@ void rpl_add_routing_entry(ipv6_addr_t *addr, ipv6_addr_t *next_hop, uint16_t li
void rpl_del_routing_entry(ipv6_addr_t *addr)
{
for(uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if(routing_table[i].used && rpl_equal_id(&routing_table[i].address, addr)) {
for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (routing_table[i].used && rpl_equal_id(&routing_table[i].address, addr)) {
memset(&routing_table[i], 0, sizeof(routing_table[i]));
return;
}
@ -997,8 +997,8 @@ void rpl_del_routing_entry(ipv6_addr_t *addr)
rpl_routing_entry_t *rpl_find_routing_entry(ipv6_addr_t *addr)
{
for(uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if(routing_table[i].used && rpl_equal_id(&routing_table[i].address, addr)) {
for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (routing_table[i].used && rpl_equal_id(&routing_table[i].address, addr)) {
return &routing_table[i];
}
}
@ -1008,7 +1008,7 @@ rpl_routing_entry_t *rpl_find_routing_entry(ipv6_addr_t *addr)
void rpl_clear_routing_table(void)
{
for(uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
memset(&routing_table[i], 0, sizeof(routing_table[i]));
}

84
sys/net/sixlowpan/rpl/rpl_dodag.c
View File

@ -32,8 +32,8 @@ rpl_instance_t *rpl_new_instance(uint8_t instanceid)
rpl_instance_t *inst;
rpl_instance_t *end ;
for(inst = &instances[0], end = inst + RPL_MAX_INSTANCES; inst < end; inst++) {
if(inst->used == 0) {
for (inst = &instances[0], end = inst + RPL_MAX_INSTANCES; inst < end; inst++) {
if (inst->used == 0) {
memset(inst, 0, sizeof(*inst));
inst->used = 1;
inst->id = instanceid;
@ -45,8 +45,8 @@ rpl_instance_t *rpl_new_instance(uint8_t instanceid)
}
rpl_instance_t *rpl_get_instance(uint8_t instanceid)
{
for(int i = 0; i < RPL_MAX_INSTANCES; i++) {
if(instances[i].used && (instances[i].id == instanceid)) {
for (int i = 0; i < RPL_MAX_INSTANCES; i++) {
if (instances[i].used && (instances[i].id == instanceid)) {
return &instances[i];
}
}
@ -56,8 +56,8 @@ rpl_instance_t *rpl_get_instance(uint8_t instanceid)
rpl_instance_t *rpl_get_my_instance()
{
for(int i = 0; i < RPL_MAX_INSTANCES; i++) {
if(instances[i].joined) {
for (int i = 0; i < RPL_MAX_INSTANCES; i++) {
if (instances[i].joined) {
return &instances[i];
}
}
@ -70,7 +70,7 @@ rpl_dodag_t *rpl_new_dodag(uint8_t instanceid, ipv6_addr_t *dodagid)
rpl_instance_t *inst;
inst = rpl_get_instance(instanceid);
if(inst == NULL) {
if (inst == NULL) {
printf("Error - No instance found for id %d. This should not happen\n",
instanceid);
return NULL;
@ -79,8 +79,8 @@ rpl_dodag_t *rpl_new_dodag(uint8_t instanceid, ipv6_addr_t *dodagid)
rpl_dodag_t *dodag;
rpl_dodag_t *end;
for(dodag = &dodags[0], end = dodag + RPL_MAX_DODAGS; dodag < end; dodag++) {
if(dodag->used == 0) {
for (dodag = &dodags[0], end = dodag + RPL_MAX_DODAGS; dodag < end; dodag++) {
if (dodag->used == 0) {
memset(dodag, 0, sizeof(*dodag));
dodag->instance = inst;
dodag->my_rank = INFINITE_RANK;
@ -96,8 +96,8 @@ rpl_dodag_t *rpl_new_dodag(uint8_t instanceid, ipv6_addr_t *dodagid)
rpl_dodag_t *rpl_get_dodag(ipv6_addr_t *id)
{
for(int i = 0; i < RPL_MAX_DODAGS; i++) {
if(dodags[i].used && (rpl_equal_id(&dodags[i].dodag_id, id))) {
for (int i = 0; i < RPL_MAX_DODAGS; i++) {
if (dodags[i].used && (rpl_equal_id(&dodags[i].dodag_id, id))) {
return &dodags[i];
}
}
@ -106,8 +106,8 @@ rpl_dodag_t *rpl_get_dodag(ipv6_addr_t *id)
}
rpl_dodag_t *rpl_get_my_dodag()
{
for(int i = 0; i < RPL_MAX_DODAGS; i++) {
if(dodags[i].joined) {
for (int i = 0; i < RPL_MAX_DODAGS; i++) {
if (dodags[i].joined) {
return &dodags[i];
}
}
@ -128,8 +128,8 @@ void rpl_leave_dodag(rpl_dodag_t *dodag)
bool rpl_equal_id(ipv6_addr_t *id1, ipv6_addr_t *id2)
{
for(uint8_t i = 0; i < 4; i++) {
if(id1->uint32[i] != id2->uint32[i]) {
for (uint8_t i = 0; i < 4; i++) {
if (id1->uint32[i] != id2->uint32[i]) {
return false;
}
}
@ -143,8 +143,8 @@ rpl_parent_t *rpl_new_parent(rpl_dodag_t *dodag, ipv6_addr_t *address, uint16_t
rpl_parent_t *parent;
rpl_parent_t *end;
for(parent = &parents[0], end = parents + RPL_MAX_PARENTS; parent < end; parent++) {
if(parent->used == 0) {
for (parent = &parents[0], end = parents + RPL_MAX_PARENTS; parent < end; parent++) {
if (parent->used == 0) {
memset(parent, 0, sizeof(*parent));
parent->used = 1;
parent->addr = *address;
@ -165,8 +165,8 @@ rpl_parent_t *rpl_find_parent(ipv6_addr_t *address)
rpl_parent_t *parent;
rpl_parent_t *end;
for(parent = &parents[0], end = parents + RPL_MAX_PARENTS; parent < end; parent++) {
if((parent->used) && (rpl_equal_id(address, &parent->addr))) {
for (parent = &parents[0], end = parents + RPL_MAX_PARENTS; parent < end; parent++) {
if ((parent->used) && (rpl_equal_id(address, &parent->addr))) {
return parent;
}
}
@ -178,7 +178,7 @@ void rpl_delete_parent(rpl_parent_t *parent)
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if((my_dodag != NULL) && rpl_equal_id(&my_dodag->my_preferred_parent->addr,
if ((my_dodag != NULL) && rpl_equal_id(&my_dodag->my_preferred_parent->addr,
&parent->addr)) {
my_dodag->my_preferred_parent = NULL;
}
@ -191,14 +191,14 @@ void rpl_delete_worst_parent(void)
uint8_t worst = 0xFF;
uint16_t max_rank = 0x0000;
for(int i = 0; i < RPL_MAX_PARENTS; i++) {
if(parents[i].rank > max_rank) {
for (int i = 0; i < RPL_MAX_PARENTS; i++) {
if (parents[i].rank > max_rank) {
worst = i;
max_rank = parents[i].rank;
}
}
if(worst == 0xFF) {
if (worst == 0xFF) {
/* Fehler, keine parents -> sollte nicht passieren */
return;
}
@ -212,7 +212,7 @@ void rpl_delete_all_parents(void)
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
my_dodag->my_preferred_parent = NULL;
for(int i = 0; i < RPL_MAX_PARENTS; i++) {
for (int i = 0; i < RPL_MAX_PARENTS; i++) {
memset(&parents[i], 0, sizeof(parents[i]));
}
}
@ -222,13 +222,13 @@ rpl_parent_t *rpl_find_preferred_parent(void)
rpl_parent_t *best = NULL;
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
for(uint8_t i = 0; i < RPL_MAX_PARENTS; i++) {
if(parents[i].used) {
if((parents[i].rank == INFINITE_RANK) || (parents[i].lifetime <= 1)) {
for (uint8_t i = 0; i < RPL_MAX_PARENTS; i++) {
if (parents[i].used) {
if ((parents[i].rank == INFINITE_RANK) || (parents[i].lifetime <= 1)) {
puts("bad parent");
continue;
}
else if(best == NULL) {
else if (best == NULL) {
puts("parent");
best = &parents[i];
}
@ -238,19 +238,19 @@ rpl_parent_t *rpl_find_preferred_parent(void)
}
}
if(best == NULL) {
if (best == NULL) {
return NULL;
}
if(!rpl_equal_id(&my_dodag->my_preferred_parent->addr, &best->addr)) {
if(my_dodag->mop != NO_DOWNWARD_ROUTES) {
if (!rpl_equal_id(&my_dodag->my_preferred_parent->addr, &best->addr)) {
if (my_dodag->mop != NO_DOWNWARD_ROUTES) {
/* send DAO with ZERO_LIFETIME to old parent */
send_DAO(&my_dodag->my_preferred_parent->addr, 0, false, 0);
}
my_dodag->my_preferred_parent = best;
if(my_dodag->mop != NO_DOWNWARD_ROUTES) {
if (my_dodag->mop != NO_DOWNWARD_ROUTES) {
delay_dao();
}
@ -266,17 +266,17 @@ void rpl_parent_update(rpl_parent_t *parent)
uint16_t old_rank = my_dodag->my_rank;
/* update Parent lifetime */
if(parent != NULL) {
if (parent != NULL) {
parent->lifetime = my_dodag->default_lifetime * my_dodag->lifetime_unit;
}
if(rpl_find_preferred_parent() == NULL) {
if (rpl_find_preferred_parent() == NULL) {
rpl_local_repair();
}
if(rpl_calc_rank(old_rank, my_dodag->minhoprankincrease) !=
if (rpl_calc_rank(old_rank, my_dodag->minhoprankincrease) !=
rpl_calc_rank(my_dodag->my_rank, my_dodag->minhoprankincrease)) {
if(my_dodag->my_rank < my_dodag->min_rank) {
if (my_dodag->my_rank < my_dodag->min_rank) {
my_dodag->min_rank = my_dodag->my_rank;
}
@ -290,13 +290,13 @@ void rpl_join_dodag(rpl_dodag_t *dodag, ipv6_addr_t *parent, uint16_t parent_ran
rpl_parent_t *preferred_parent;
my_dodag = rpl_new_dodag(dodag->instance->id, &dodag->dodag_id);
if(my_dodag == NULL) {
if (my_dodag == NULL) {
return;
}
preferred_parent = rpl_new_parent(my_dodag, parent, parent_rank);
if(preferred_parent == NULL) {
if (preferred_parent == NULL) {
rpl_del_dodag(my_dodag);
return;
}
@ -330,7 +330,7 @@ void rpl_global_repair(rpl_dodag_t *dodag, ipv6_addr_t *p_addr, uint16_t rank)
puts("[INFO] Global repair started");
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if (my_dodag == NULL) {
printf("[Error] - no global repair possible, if not part of a DODAG\n");
return;
}
@ -340,7 +340,7 @@ void rpl_global_repair(rpl_dodag_t *dodag, ipv6_addr_t *p_addr, uint16_t rank)
my_dodag->dtsn++;
my_dodag->my_preferred_parent = rpl_new_parent(my_dodag, p_addr, rank);
if(my_dodag->my_preferred_parent == NULL) {
if (my_dodag->my_preferred_parent == NULL) {
printf("[Error] no more parent after global repair\n");
my_dodag->my_rank = INFINITE_RANK;
}
@ -362,7 +362,7 @@ void rpl_local_repair(void)
puts("[INFO] Local Repair started");
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if (my_dodag == NULL) {
printf("[Error] - no local repair possible, if not part of a DODAG\n");
return;
}
@ -378,7 +378,7 @@ ipv6_addr_t *rpl_get_my_preferred_parent()
{
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag == NULL) {
if (my_dodag == NULL) {
return NULL;
}

36
sys/net/sixlowpan/rpl/trickle.c
View File

@ -121,11 +121,11 @@ void trickle_timer_over(void)
ipv6_addr_t mcast;
ipv6_set_all_nds_mcast_addr(&mcast);
while(1) {
while (1) {
thread_sleep();
/* Laut RPL Spezifikation soll k=0 wie k= Unendlich behandelt werden, also immer gesendet werden */
if((c < k) || (k == 0)) {
if ((c < k) || (k == 0)) {
send_DIO(&mcast);
}
}
@ -133,22 +133,22 @@ void trickle_timer_over(void)
void trickle_interval_over(void)
{
while(1) {
while (1) {
thread_sleep();
I = I * 2;
printf("TRICKLE new Interval %"PRIu32"\n", I);
if(I == 0) {
if (I == 0) {
puts("[WARNING] Interval was 0");
if(Imax == 0) {
if (Imax == 0) {
puts("[WARNING] Imax == 0");
}
I = (Imin << Imax);
}
if(I > (Imin << Imax)) {
if (I > (Imin << Imax)) {
I = (Imin << Imax);
}
@ -160,11 +160,11 @@ void trickle_interval_over(void)
I_time = timex_set(0, I * 1000);
timex_normalize(&I_time);
if(vtimer_set_wakeup(&trickle_t_timer, t_time, timer_over_pid) != 0) {
if (vtimer_set_wakeup(&trickle_t_timer, t_time, timer_over_pid) != 0) {
puts("[ERROR] setting Wakeup");
}
if(vtimer_set_wakeup(&trickle_I_timer, I_time, interval_over_pid) != 0) {
if (vtimer_set_wakeup(&trickle_I_timer, I_time, interval_over_pid) != 0) {
puts("[ERROR] setting Wakeup");
}
}
@ -192,16 +192,16 @@ void long_delay_dao(void)
void dao_delay_over(void)
{
while(1) {
while (1) {
thread_sleep();
if((ack_received == false) && (dao_counter < DAO_SEND_RETRIES)) {
if ((ack_received == false) && (dao_counter < DAO_SEND_RETRIES)) {
dao_counter++;
send_DAO(NULL, 0, true, 0);
dao_time = timex_set(DEFAULT_WAIT_FOR_DAO_ACK, 0);
vtimer_set_wakeup(&dao_timer, dao_time, dao_delay_over_pid);
}
else if(ack_received == false) {
else if (ack_received == false) {
long_delay_dao();
}
}
@ -217,15 +217,15 @@ void rt_timer_over(void)
{
rpl_routing_entry_t *rt;
while(1) {
while (1) {
rpl_dodag_t *my_dodag = rpl_get_my_dodag();
if(my_dodag != NULL) {
if (my_dodag != NULL) {
rt = rpl_get_routing_table();
for(uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if(rt[i].used) {
if(rt[i].lifetime <= 1) {
for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) {
if (rt[i].used) {
if (rt[i].lifetime <= 1) {
memset(&rt[i], 0, sizeof(rt[i]));
}
else {
@ -235,8 +235,8 @@ void rt_timer_over(void)
}
/* Parent is NULL for root too */
if(my_dodag->my_preferred_parent != NULL) {
if(my_dodag->my_preferred_parent->lifetime <= 1) {
if (my_dodag->my_preferred_parent != NULL) {
if (my_dodag->my_preferred_parent->lifetime <= 1) {
puts("parent lifetime timeout");
rpl_parent_update(NULL);
}

6
sys/net/sixlowpan/semaphore.c
View File

@ -31,11 +31,11 @@ int sem_wait(sem_t *sem)
{
int res;
if(--(sem->value) <= 0 && !sem->locked) {
if (--(sem->value) <= 0 && !sem->locked) {
sem->locked = !(sem->locked);
res = mutex_lock(&(sem->mutex));
if(res < 0) {
if (res < 0) {
return res;
}
}
@ -45,7 +45,7 @@ int sem_wait(sem_t *sem)
int sem_signal(sem_t *sem)
{
if(++(sem->value) > 0 && sem->locked) {
if (++(sem->value) > 0 && sem->locked) {
sem->locked = !(sem->locked);
mutex_unlock(&(sem->mutex), 0);
}

24
sys/net/sixlowpan/serialnumber.c
View File

@ -21,7 +21,7 @@
int serial_add8(uint8_t s, uint8_t n)
{
if(n > 127) {
if (n > 127) {
return -1;
}
@ -31,7 +31,7 @@ int serial_add8(uint8_t s, uint8_t n)
int serial_add16(uint16_t s, uint16_t n)
{
if(n > 32767) {
if (n > 32767) {
return -1;
}
@ -41,7 +41,7 @@ int serial_add16(uint16_t s, uint16_t n)
int serial_add32(uint32_t s, uint32_t n)
{
if(n > 2147483647) {
if (n > 2147483647) {
return -1;
}
@ -51,15 +51,15 @@ int serial_add32(uint32_t s, uint32_t n)
serial_comp_res_t serial_comp8(uint8_t s1, uint8_t s2)
{
if(s1 == s2) {
if (s1 == s2) {
return EQUAL;
}
if((s1 < s2 && s1 - s2 < 128) || (s1 > s2 && s1 - s2 > 128)) {
if ((s1 < s2 && s1 - s2 < 128) || (s1 > s2 && s1 - s2 > 128)) {
return LESS;
}
if((s1 < s2 && s1 - s2 > 128) || (s1 > s2 && s1 - s2 < 128)) {
if ((s1 < s2 && s1 - s2 > 128) || (s1 > s2 && s1 - s2 < 128)) {
return GREATER;
}
@ -68,15 +68,15 @@ serial_comp_res_t serial_comp8(uint8_t s1, uint8_t s2)
serial_comp_res_t serial_comp16(uint16_t s1, uint16_t s2)
{
if(s1 == s2) {
if (s1 == s2) {
return EQUAL;
}
if((s1 < s2 && s1 - s2 < 32768) || (s1 > s2 && s1 - s2 > 32768)) {
if ((s1 < s2 && s1 - s2 < 32768) || (s1 > s2 && s1 - s2 > 32768)) {
return LESS;
}
if((s1 < s2 && s1 - s2 > 32768) || (s1 > s2 && s1 - s2 < 32768)) {
if ((s1 < s2 && s1 - s2 > 32768) || (s1 > s2 && s1 - s2 < 32768)) {
return GREATER;
}
@ -85,15 +85,15 @@ serial_comp_res_t serial_comp16(uint16_t s1, uint16_t s2)
serial_comp_res_t serial_comp32(uint32_t s1, uint32_t s2)
{
if(s1 == s2) {
if (s1 == s2) {
return EQUAL;
}
if((s1 < s2 && s1 - s2 < 2147483648) || (s1 > s2 && s1 - s2 > 2147483648)) {
if ((s1 < s2 && s1 - s2 < 2147483648) || (s1 > s2 && s1 - s2 > 2147483648)) {
return LESS;
}
if((s1 < s2 && s1 - s2 > 2147483648) || (s1 > s2 && s1 - s2 < 2147483648)) {
if ((s1 < s2 && s1 - s2 > 2147483648) || (s1 > s2 && s1 - s2 < 2147483648)) {
return GREATER;
}

30
sys/net/sixlowpan/sixlowborder.c
View File

@ -48,7 +48,7 @@ uint8_t serial_in_buf[BORDER_BUFFER_SIZE];
uint8_t *get_serial_out_buffer(int offset)
{
if(offset > BUFFER_SIZE) {
if (offset > BUFFER_SIZE) {
return NULL;
}
@ -57,7 +57,7 @@ uint8_t *get_serial_out_buffer(int offset)
uint8_t *get_serial_in_buffer(int offset)
{
if(offset > BUFFER_SIZE) {
if (offset > BUFFER_SIZE) {
return NULL;
}
@ -81,13 +81,13 @@ void serial_reader_f(void)
msg_receive(&m);
main_pid = m.sender_pid;
while(1) {
while (1) {
posix_open(uart0_handler_pid, 0);
bytes = readpacket(get_serial_in_buffer(0), BORDER_BUFFER_SIZE);
if(bytes < 0) {
if (bytes < 0) {
switch(bytes) {
case(-SIXLOWERROR_ARRAYFULL): {
case (-SIXLOWERROR_ARRAYFULL): {
printf("ERROR: Array was full\n");
break;
}
@ -103,11 +103,11 @@ void serial_reader_f(void)
uart_buf = (border_packet_t *)get_serial_in_buffer(0);
if(uart_buf->empty == 0) {
if(uart_buf->type == BORDER_PACKET_CONF_TYPE) {
if (uart_buf->empty == 0) {
if (uart_buf->type == BORDER_PACKET_CONF_TYPE) {
border_conf_header_t *conf_packet = (border_conf_header_t *)uart_buf;
if(conf_packet->conftype == BORDER_CONF_SYN) {
if (conf_packet->conftype == BORDER_CONF_SYN) {
m.content.ptr = (char *)conf_packet;
msg_send(&m, main_pid, 1);
continue;
@ -128,7 +128,7 @@ uint8_t border_initialize(transceiver_type_t trans, ipv6_addr_t *border_router_a
PRIORITY_MAIN - 1, CREATE_STACKTEST,
serial_reader_f, "serial_reader");
if(border_router_addr == NULL) {
if (border_router_addr == NULL) {
border_router_addr = &addr;
addr = flowcontrol_init();
@ -138,7 +138,7 @@ uint8_t border_initialize(transceiver_type_t trans, ipv6_addr_t *border_router_a
* RFC 4944 (Section 6) & RFC 2464 (Section 4) from short address
* -- for now
*/
if(border_router_addr->uint16[4] != HTONS(IEEE_802154_PAN_ID ^ 0x0200) ||
if (border_router_addr->uint16[4] != HTONS(IEEE_802154_PAN_ID ^ 0x0200) ||
border_router_addr->uint16[5] != HTONS(0x00FF) ||
border_router_addr->uint16[6] != HTONS(0xFE00)
) {
@ -146,7 +146,7 @@ uint8_t border_initialize(transceiver_type_t trans, ipv6_addr_t *border_router_a
}
/* radio-address is 8-bit so this must be tested extra */
if(border_router_addr->uint8[14] != 0) {
if (border_router_addr->uint8[14] != 0) {
return SIXLOWERROR_ADDRESS;
}
@ -177,18 +177,18 @@ void border_process_lowpan(void)
msg_t m;
ipv6_hdr_t *ipv6_buf;
while(1) {
while (1) {
msg_receive(&m);
ipv6_buf = (ipv6_hdr_t *)m.content.ptr;
if(ipv6_buf->nextheader == PROTO_NUM_ICMPV6) {
if (ipv6_buf->nextheader == PROTO_NUM_ICMPV6) {
struct icmpv6_hdr_t *icmp_buf = (struct icmpv6_hdr_t *)(((uint8_t *)ipv6_buf) + IPV6_HDR_LEN);
if(icmp_buf->type == ICMP_REDIRECT) {
if (icmp_buf->type == ICMP_REDIRECT) {
continue;
}
if(icmpv6_demultiplex(icmp_buf) == 0) {
if (icmpv6_demultiplex(icmp_buf) == 0) {
continue;
}

86
sys/net/sixlowpan/sixlowip.c
View File

@ -82,7 +82,7 @@ void sixlowpan_send(ipv6_addr_t *addr, uint8_t *payload, uint16_t p_len,
{
uint8_t *p_ptr;
if(next_header == IPPROTO_TCP) {
if (next_header == IPPROTO_TCP) {
p_ptr = get_payload_buf_send(ipv6_ext_hdr_len);
ipv6_buf = get_ipv6_buf_send();
}
@ -115,7 +115,7 @@ void sixlowpan_send(ipv6_addr_t *addr, uint8_t *payload, uint16_t p_len,
int icmpv6_demultiplex(const struct icmpv6_hdr_t *hdr)
{
switch(hdr->type) {
case(ICMP_RTR_SOL): {
case (ICMP_RTR_SOL): {
puts("INFO: packet type: icmp router solicitation");
/* processing router solicitation */
recv_rtr_sol();
@ -123,7 +123,7 @@ int icmpv6_demultiplex(const struct icmpv6_hdr_t *hdr)
break;
}
case(ICMP_RTR_ADV): {
case (ICMP_RTR_ADV): {
puts("INFO: packet type: icmp router advertisment");
/* processing router advertisment */
recv_rtr_adv();
@ -131,22 +131,22 @@ int icmpv6_demultiplex(const struct icmpv6_hdr_t *hdr)
break;
}
case(ICMP_NBR_SOL): {
case (ICMP_NBR_SOL): {
puts("INFO: packet type: icmp neighbor solicitation");
recv_nbr_sol();
break;
}
case(ICMP_NBR_ADV): {
case (ICMP_NBR_ADV): {
puts("INFO: packet type: icmp neighbor advertisment");
recv_nbr_adv();
break;
}
case(ICMP_RPL_CONTROL): {
case (ICMP_RPL_CONTROL): {
puts("INFO: packet type: RPL message");
if(rpl_process_pid != 0) {
if (rpl_process_pid != 0) {
msg_t m_send;
m_send.content.ptr = (char *) &hdr->code;
msg_send(&m_send, rpl_process_pid, 1);
@ -173,7 +173,7 @@ void ipv6_process(void)
ipv6_init_address(&myaddr, 0xabcd, 0x0, 0x0, 0x0, 0x3612, 0x00ff, 0xfe00,
get_radio_address());
while(1) {
while (1) {
msg_receive(&m_recv_lowpan);
ipv6_buf = (ipv6_hdr_t *)m_recv_lowpan.content.ptr;
@ -181,7 +181,7 @@ void ipv6_process(void)
/* identifiy packet */
nextheader = &ipv6_buf->nextheader;
if((ipv6_get_addr_match(&myaddr, &ipv6_buf->destaddr) >= 112) &&
if ((ipv6_get_addr_match(&myaddr, &ipv6_buf->destaddr) >= 112) &&
(ipv6_buf->destaddr.uint8[15] != myaddr.uint8[15])) {
memcpy(get_ipv6_buf_send(), get_ipv6_buf(),
IPV6_HDR_LEN + ipv6_buf->length);
@ -190,9 +190,9 @@ void ipv6_process(void)
}
else {
switch(*nextheader) {
case(PROTO_NUM_ICMPV6): {
case (PROTO_NUM_ICMPV6): {
/* checksum test*/
if(icmpv6_csum(PROTO_NUM_ICMPV6) != 0xffff) {
if (icmpv6_csum(PROTO_NUM_ICMPV6) != 0xffff) {
printf("ERROR: wrong checksum\n");
}
@ -201,8 +201,8 @@ void ipv6_process(void)
break;
}
case(IPPROTO_TCP): {
if(tcp_packet_handler_pid != 0) {
case (IPPROTO_TCP): {
if (tcp_packet_handler_pid != 0) {
m_send.content.ptr = (char *) ipv6_buf;
msg_send_receive(&m_send, &m_recv, tcp_packet_handler_pid);
}
@ -213,8 +213,8 @@ void ipv6_process(void)
break;
}
case(IPPROTO_UDP): {
if(udp_packet_handler_pid != 0) {
case (IPPROTO_UDP): {
if (udp_packet_handler_pid != 0) {
m_send.content.ptr = (char *) ipv6_buf;
msg_send_receive(&m_send, &m_recv, udp_packet_handler_pid);
}
@ -225,7 +225,7 @@ void ipv6_process(void)
break;
}
case(PROTO_NUM_NONE): {
case (PROTO_NUM_NONE): {
printf("INFO: Packet with no Header following the IPv6 Header received.\n");
break;
}
@ -242,16 +242,16 @@ void ipv6_process(void)
void ipv6_iface_add_addr(ipv6_addr_t *addr, uint8_t state, uint32_t val_ltime,
uint32_t pref_ltime, uint8_t type)
{
if(ipv6_addr_unspec_match(addr) == 128) {
if (ipv6_addr_unspec_match(addr) == 128) {
printf("ERROR: unspecified address (::) can't be assigned to interface.\n");
return;
}
if(ipv6_iface_addr_match(addr) != 0) {
if (ipv6_iface_addr_match(addr) != 0) {
return;
}
if(iface_addr_list_count < IFACE_ADDR_LIST_LEN) {
if (iface_addr_list_count < IFACE_ADDR_LIST_LEN) {
memcpy(&(iface.addr_list[iface_addr_list_count].addr.uint8[0]),
&(addr->uint8[0]), 16);
iface.addr_list[iface_addr_list_count].state = state;
@ -265,12 +265,12 @@ void ipv6_iface_add_addr(ipv6_addr_t *addr, uint8_t state, uint32_t val_ltime,
iface_addr_list_count++;
/* Register to Solicited-Node multicast address according to RFC 4291 */
if(type == ADDR_TYPE_ANYCAST || type == ADDR_TYPE_LINK_LOCAL ||
if (type == ADDR_TYPE_ANYCAST || type == ADDR_TYPE_LINK_LOCAL ||
type == ADDR_TYPE_GLOBAL || type == ADDR_TYPE_UNICAST) {
ipv6_addr_t sol_node_mcast_addr;
ipv6_set_sol_node_mcast_addr(addr, &sol_node_mcast_addr);
if(ipv6_iface_addr_match(&sol_node_mcast_addr) == NULL) {
if (ipv6_iface_addr_match(&sol_node_mcast_addr) == NULL) {
ipv6_iface_add_addr(&sol_node_mcast_addr, state, val_ltime, pref_ltime, ADDR_TYPE_SOL_NODE_MCAST);
}
}
@ -281,8 +281,8 @@ addr_list_t *ipv6_iface_addr_match(ipv6_addr_t *addr)
{
int i;
for(i = 0; i < iface_addr_list_count; i++) {
if(memcmp(&(iface.addr_list[i].addr.uint8[0]),
for (i = 0; i < iface_addr_list_count; i++) {
if (memcmp(&(iface.addr_list[i].addr.uint8[0]),
&(addr->uint8[0]), 16) == 0) {
return &(iface.addr_list[i]);
}
@ -295,8 +295,8 @@ addr_list_t *ipv6_iface_addr_prefix_eq(ipv6_addr_t *addr)
{
int i;
for(i = 0; i < iface_addr_list_count; i++) {
if(memcmp(&(iface.addr_list[i].addr.uint8[0]),
for (i = 0; i < iface_addr_list_count; i++) {
if (memcmp(&(iface.addr_list[i].addr.uint8[0]),
&(addr->uint8[0]), 8) == 0) {
return &(iface.addr_list[i]);
}
@ -307,7 +307,7 @@ addr_list_t *ipv6_iface_addr_prefix_eq(ipv6_addr_t *addr)
void ipv6_iface_print_addrs(void)
{
for(int i = 0; i < iface_addr_list_count; i++) {
for (int i = 0; i < iface_addr_list_count; i++) {
ipv6_print_addr(&(iface.addr_list[i].addr));
}
}
@ -377,13 +377,13 @@ void ipv6_get_saddr(ipv6_addr_t *src, ipv6_addr_t *dst)
uint8_t tmp = 0;
uint8_t bmatch = 0;
if(!(ipv6_prefix_ll_match(dst)) && !(ipv6_prefix_mcast_match(dst))) {
for(int i = 0; i < IFACE_ADDR_LIST_LEN; i++) {
if(iface.addr_list[i].state == ADDR_STATE_PREFERRED) {
if(!(ipv6_prefix_ll_match(&(iface.addr_list[i].addr)))) {
if (!(ipv6_prefix_ll_match(dst)) && !(ipv6_prefix_mcast_match(dst))) {
for (int i = 0; i < IFACE_ADDR_LIST_LEN; i++) {
if (iface.addr_list[i].state == ADDR_STATE_PREFERRED) {
if (!(ipv6_prefix_ll_match(&(iface.addr_list[i].addr)))) {
tmp = ipv6_get_addr_match(dst, &(iface.addr_list[i].addr));
if(tmp >= bmatch) {
if (tmp >= bmatch) {
bmatch = tmp;
itmp = i;
}
@ -392,15 +392,15 @@ void ipv6_get_saddr(ipv6_addr_t *src, ipv6_addr_t *dst)
}
}
else {
for(int j = 0; j < IFACE_ADDR_LIST_LEN; j++) {
if((iface.addr_list[j].state == ADDR_STATE_PREFERRED) &&
for (int j = 0; j < IFACE_ADDR_LIST_LEN; j++) {
if ((iface.addr_list[j].state == ADDR_STATE_PREFERRED) &&
ipv6_prefix_ll_match(&(iface.addr_list[j].addr))) {
itmp = j;
}
}
}
if(itmp == -1) {
if (itmp == -1) {
memset(src, 0, 16);
}
else {
@ -412,17 +412,17 @@ uint8_t ipv6_get_addr_match(ipv6_addr_t *src, ipv6_addr_t *dst)
{
uint8_t val = 0, xor;
for(int i = 0; i < 16; i++) {
for (int i = 0; i < 16; i++) {
/* if bytes are equal add 8 */
if(src->uint8[i] == dst->uint8[i]) {
if (src->uint8[i] == dst->uint8[i]) {
val += 8;
}
else {
xor = src->uint8[i] ^ dst->uint8[i];
/* while bits from byte equal add 1 */
for(int j = 0; j < 8; j++) {
if((xor & 0x80) == 0) {
for (int j = 0; j < 8; j++) {
if ((xor & 0x80) == 0) {
val++;
xor = xor << 1;
}
@ -460,7 +460,7 @@ void ipv6_init_address(ipv6_addr_t *addr, uint16_t addr0, uint16_t addr1,
uint8_t ipv6_prefix_ll_match(ipv6_addr_t *addr)
{
if(addr->uint8[0] == 0xfe && addr->uint8[1] == 0x80) {
if (addr->uint8[0] == 0xfe && addr->uint8[1] == 0x80) {
return 1;
}
@ -469,7 +469,7 @@ uint8_t ipv6_prefix_ll_match(ipv6_addr_t *addr)
uint8_t ipv6_prefix_mcast_match(ipv6_addr_t *addr)
{
if(addr->uint8[0] == 0xff && addr->uint8[1] == 0x02) {
if (addr->uint8[0] == 0xff && addr->uint8[1] == 0x02) {
return 1;
}
@ -478,7 +478,7 @@ uint8_t ipv6_prefix_mcast_match(ipv6_addr_t *addr)
uint8_t ipv6_addr_unspec_match(ipv6_addr_t *addr)
{
if((addr->uint16[0] == 0) && (addr->uint16[1] == 0) &&
if ((addr->uint16[0] == 0) && (addr->uint16[1] == 0) &&
(addr->uint16[2] == 0) && (addr->uint16[3] == 0) &&
(addr->uint16[4] == 0) && (addr->uint16[5] == 0) &&
(addr->uint16[6] == 0) && (addr->uint16[7] == 0)) {
@ -491,7 +491,7 @@ uint8_t ipv6_addr_unspec_match(ipv6_addr_t *addr)
uint8_t ipv6_addr_sol_node_mcast_match(ipv6_addr_t *addr)
{
/* note: cool if-condition*/
if((addr->uint8[0] == 0xFF) && (addr->uint8[1] == 0x02) &&
if ((addr->uint8[0] == 0xFF) && (addr->uint8[1] == 0x02) &&
(addr->uint16[1] == 0x00) && (addr->uint16[2] == 0x00) &&
(addr->uint16[3] == 0x00) && (addr->uint16[4] == 0x00) &&
(addr->uint8[10] == 0x00) && (addr->uint8[11] == 0x01) &&
@ -566,7 +566,7 @@ uint8_t ipv6_is_router(void)
ipv6_set_all_rtrs_mcast_addr(&addr);
if(ipv6_iface_addr_match(&addr) != NULL) {
if (ipv6_iface_addr_match(&addr) != NULL) {
return 1;
}

8
sys/net/sixlowpan/sixlowmac.c
View File

@ -132,10 +132,10 @@ void recv_ieee802154_frame(void)
msg_init_queue(msg_q, RADIO_RCV_BUF_SIZE);
while(1) {
while (1) {
msg_receive(&m);
if(m.type == PKT_PENDING) {
if (m.type == PKT_PENDING) {
p = (radio_packet_t *) m.content.ptr;
hdrlen = read_802154_frame(p->data, &frame, p->length);
@ -148,7 +148,7 @@ void recv_ieee802154_frame(void)
p->processing--;
}
else if(m.type == ENOBUFFER) {
else if (m.type == ENOBUFFER) {
puts("Transceiver buffer full");
}
else {
@ -216,7 +216,7 @@ void send_ieee802154_frame(ieee_802154_long_t *addr, uint8_t *payload,
p.length = hdrlen + frame.payload_len;
if(mcast == 0) {
if (mcast == 0) {
p.dst = daddr;
}
else {

224
sys/net/sixlowpan/sixlownd.c
View File

@ -88,7 +88,7 @@ static abr_cache_t *abr_get_oldest(void);
int min(int a, int b)
{
if(a < b) {
if (a < b) {
return a;
}
else {
@ -188,7 +188,7 @@ void init_rtr_sol(uint8_t sllao)
opt_hdr_len = RTR_SOL_LEN;
ipv6_buf->length = ICMPV6_HDR_LEN + RTR_SOL_LEN + OPT_STLLAO_MAX_LEN;
if(sllao == OPT_SLLAO) {
if (sllao == OPT_SLLAO) {
opt_stllao_buf = get_opt_stllao_buf(ipv6_ext_hdr_len, opt_hdr_len);
set_llao(opt_stllao_buf, OPT_SLLAO_TYPE, 2);
packet_length = IPV6_HDR_LEN + ICMPV6_HDR_LEN + ipv6_ext_hdr_len +
@ -216,18 +216,18 @@ void recv_rtr_sol(void)
ipv6_buf = get_ipv6_buf();
/* check if source option is set*/
if(opt_stllao_buf->type == OPT_SLLAO_TYPE) {
if (opt_stllao_buf->type == OPT_SLLAO_TYPE) {
opt_stllao_buf = get_opt_stllao_buf(ipv6_ext_hdr_len, opt_hdr_len);
llao = (uint8_t *)opt_stllao_buf;
opt_hdr_len += (opt_stllao_buf->length) << 3;
}
if(llao != NULL) {
if (llao != NULL) {
nbr_entry = nbr_cache_search(&ipv6_buf->srcaddr);
if(nbr_entry != NULL) {
if (nbr_entry != NULL) {
/* found neighbor in cache, update values and check long addr */
if(memcmp(&llao[2], &nbr_entry->laddr, 8) == 0) {
if (memcmp(&llao[2], &nbr_entry->laddr, 8) == 0) {
nbr_entry->isrouter = 0;
}
else {
@ -246,7 +246,7 @@ void recv_rtr_sol(void)
}
/* send solicited router advertisment */
if(abr_count > 0) {
if (abr_count > 0) {
init_rtr_adv(&ipv6_buf->srcaddr, 0, 0, OPT_PI, OPT_6CO, OPT_ABRO);
}
else {
@ -266,7 +266,7 @@ uint8_t set_opt_6co_flags(uint8_t compression_flag, uint8_t cid)
{
uint8_t flags;
if(compression_flag) {
if (compression_flag) {
flags = OPT_6CO_FLAG_C;
}
else {
@ -301,7 +301,7 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
ipv6_buf->nextheader = PROTO_NUM_ICMPV6;
ipv6_buf->hoplimit = ND_HOPLIMIT;
if(addr == NULL) {
if (addr == NULL) {
/* not solicited */
ipv6_set_all_nds_mcast_addr(&ipv6_buf->destaddr);
}
@ -327,7 +327,7 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
packet_length = IPV6_HDR_LEN + ICMPV6_HDR_LEN + RTR_ADV_LEN;
if(sllao == OPT_SLLAO) {
if (sllao == OPT_SLLAO) {
/* set link layer address option */
opt_stllao_buf = get_opt_stllao_buf(ipv6_ext_hdr_len, opt_hdr_len);
set_llao(opt_stllao_buf, OPT_SLLAO_TYPE, 2);
@ -335,7 +335,7 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
packet_length += OPT_STLLAO_MAX_LEN;
}
if(mtu == OPT_MTU) {
if (mtu == OPT_MTU) {
/* set MTU options */
opt_mtu_buf = get_opt_mtu_buf(ipv6_ext_hdr_len, opt_hdr_len);
opt_mtu_buf->type = OPT_MTU_TYPE;
@ -348,9 +348,9 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
/* set payload length field */
if(abro == OPT_ABRO) {
if (abro == OPT_ABRO) {
/* set authoritive border router option */
if(abr_count > 0) {
if (abr_count > 0) {
msg_abr = abr_get_most_current();
opt_abro_buf = get_opt_abro_buf(ipv6_ext_hdr_len, opt_hdr_len);
opt_abro_buf->type = OPT_ABRO_TYPE;
@ -361,12 +361,12 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
}
}
if(sixco == OPT_6CO) {
if (sixco == OPT_6CO) {
/* set 6lowpan context option */
int contexts_len = 0;
mutex_lock(&lowpan_context_mutex);
if(msg_abr == NULL) {
if (msg_abr == NULL) {
contexts = lowpan_context_get();
contexts_len = lowpan_context_len();
}
@ -375,10 +375,10 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
contexts_len = 0;
for(int i = 0; i < LOWPAN_CONTEXT_MAX; i++) {
for (int i = 0; i < LOWPAN_CONTEXT_MAX; i++) {
lowpan_context_t *ctx = abr_get_context(msg_abr, i);
if(ctx != NULL) {
if (ctx != NULL) {
memcpy(&(c_tmp[contexts_len++]), ctx, sizeof(lowpan_context_t));
}
}
@ -387,11 +387,11 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
memcpy(contexts, c_tmp, contexts_len);
}
for(int i = 0; i < contexts_len; i++) {
for (int i = 0; i < contexts_len; i++) {
opt_6co_hdr_buf = get_opt_6co_hdr_buf(ipv6_ext_hdr_len, opt_hdr_len);
opt_6co_hdr_buf->type = OPT_6CO_TYPE;
if(contexts[i].length > 64) {
if (contexts[i].length > 64) {
opt_6co_hdr_buf->length = OPT_6CO_MAX_LEN;
}
else {
@ -408,7 +408,7 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
/* attach prefixes */
opt_6co_prefix_buf = get_opt_6co_prefix_buf(ipv6_ext_hdr_len, opt_hdr_len);
if(opt_6co_hdr_buf->c_length > 64) {
if (opt_6co_hdr_buf->c_length > 64) {
memset((void *)opt_6co_prefix_buf, 0, 16);
memcpy((void *)opt_6co_prefix_buf, (void *) & (contexts[i].prefix.uint8[0]), opt_6co_hdr_buf->c_length / 8);
opt_hdr_len += 16;
@ -423,17 +423,17 @@ void init_rtr_adv(ipv6_addr_t *addr, uint8_t sllao, uint8_t mtu, uint8_t pi,
}
if(msg_abr != NULL && contexts != NULL) {
if (msg_abr != NULL && contexts != NULL) {
free(contexts);
}
mutex_unlock(&lowpan_context_mutex, 0);
}
if(pi == OPT_PI) {
if (pi == OPT_PI) {
/* set prefix option */
for(int i = 0; i < OPT_PI_LIST_LEN; i++) {
if(plist[i].inuse && plist[i].adv) {
for (int i = 0; i < OPT_PI_LIST_LEN; i++) {
if (plist[i].inuse && plist[i].adv) {
opt_pi_buf = get_opt_pi_buf(ipv6_ext_hdr_len, opt_hdr_len);
memcpy(&(opt_pi_buf->addr.uint8[0]), &(plist[i].addr.uint8[0]), 16);
opt_pi_buf->type = OPT_PI_TYPE;
@ -470,18 +470,18 @@ void recv_rtr_adv(void)
recvd_cids_len = 0;
/* update interface reachable time and retrans timer */
if(rtr_adv_buf->reachable_time != 0) {
if (rtr_adv_buf->reachable_time != 0) {
iface.adv_reachable_time = HTONL(rtr_adv_buf->reachable_time);
}
if(rtr_adv_buf->retrans_timer != 0) {
if (rtr_adv_buf->retrans_timer != 0) {
iface.adv_retrans_timer = HTONL(rtr_adv_buf->retrans_timer);
}
def_rtr_entry = def_rtr_lst_search(&ipv6_buf->srcaddr);
if(rtr_adv_buf->router_lifetime != 0) {
if(def_rtr_entry != NULL) {
if (rtr_adv_buf->router_lifetime != 0) {
if (def_rtr_entry != NULL) {
set_remaining_time(&(def_rtr_entry->inval_time), HTONL(rtr_adv_buf->router_lifetime));
}
else {
@ -491,7 +491,7 @@ void recv_rtr_adv(void)
}
else {
/* remove router from default router list */
if(def_rtr_entry != NULL) {
if (def_rtr_entry != NULL) {
def_rtr_lst_rem(def_rtr_entry);
}
}
@ -499,40 +499,40 @@ void recv_rtr_adv(void)
mutex_lock(&lowpan_context_mutex);
/* read options */
while(packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
while (packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
opt_buf = get_opt_buf(ipv6_ext_hdr_len, opt_hdr_len);
switch(opt_buf->type) {
case(OPT_SLLAO_TYPE): {
case (OPT_SLLAO_TYPE): {
break;
}
case(OPT_MTU_TYPE): {
case (OPT_MTU_TYPE): {
break;
}
/* rfc 4862 section 5.5.3 */
case(OPT_PI_TYPE): {
case (OPT_PI_TYPE): {
opt_pi_buf = get_opt_pi_buf(ipv6_ext_hdr_len, opt_hdr_len);
/* crazy condition, read 5.5.3a-b-c for further information */
if(ipv6_prefix_ll_match(&opt_pi_buf->addr) ||
if (ipv6_prefix_ll_match(&opt_pi_buf->addr) ||
(HTONL(opt_pi_buf->pref_ltime) >
HTONL(opt_pi_buf->val_ltime))) {
break;
}
else {
/* check if on-link flag is set */
if(opt_pi_buf->l_a_reserved1 & OPT_PI_FLAG_L) {
if (opt_pi_buf->l_a_reserved1 & OPT_PI_FLAG_L) {
/* TODO: do on-link pi handling */
}
if(opt_pi_buf->l_a_reserved1 & OPT_PI_FLAG_A) {
if (opt_pi_buf->l_a_reserved1 & OPT_PI_FLAG_A) {
addr_list_ptr = ipv6_iface_addr_prefix_eq(&opt_pi_buf->addr);
if(addr_list_ptr == NULL) {
if (addr_list_ptr == NULL) {
/* 5.5.3d */
if(opt_pi_buf->val_ltime != 0) {
if (opt_pi_buf->val_ltime != 0) {
/* iid will also be added here */
ipv6_init_addr_prefix(&newaddr, &opt_pi_buf->addr);
/* add into address list
@ -553,7 +553,7 @@ void recv_rtr_adv(void)
set_remaining_time(&(addr_list_ptr->pref_ltime), opt_pi_buf->pref_ltime);
/* 7200 = 2hours in seconds */
if(HTONL(opt_pi_buf->val_ltime) > 7200 ||
if (HTONL(opt_pi_buf->val_ltime) > 7200 ||
HTONL(opt_pi_buf->val_ltime) >
get_remaining_time(&(addr_list_ptr->val_ltime))) {
set_remaining_time(&(addr_list_ptr->val_ltime), HTONL(opt_pi_buf->val_ltime));
@ -570,7 +570,7 @@ void recv_rtr_adv(void)
break;
}
case(OPT_6CO_TYPE): {
case (OPT_6CO_TYPE): {
uint8_t comp;
uint8_t num;
@ -597,7 +597,7 @@ void recv_rtr_adv(void)
break;
}
case(OPT_ABRO_TYPE): {
case (OPT_ABRO_TYPE): {
opt_abro_buf = get_opt_abro_buf(ipv6_ext_hdr_len, opt_hdr_len);
abro_found = 1;
abro_version = HTONS(opt_abro_buf->version);
@ -613,17 +613,17 @@ void recv_rtr_adv(void)
opt_hdr_len += (opt_buf->length * 8);
}
if(abro_found) {
if (abro_found) {
int i;
for(i = 0; i < recvd_cids_len; i++) {
for (i = 0; i < recvd_cids_len; i++) {
abr_add_context(abro_version, &abro_addr, recvd_cids[i]);
}
}
mutex_unlock(&lowpan_context_mutex, 0);
if(trigger_ns >= 0) {
if (trigger_ns >= 0) {
/* send ns - draft-ietf-6lowpan-nd-15#section-5.5.1
*
* section-10.2.4
@ -651,7 +651,7 @@ void init_nbr_sol(ipv6_addr_t *src, ipv6_addr_t *dest, ipv6_addr_t *targ,
ipv6_buf->nextheader = PROTO_NUM_ICMPV6;
ipv6_buf->hoplimit = ND_HOPLIMIT;
if(dest == NULL) {
if (dest == NULL) {
ipv6_set_sol_node_mcast_addr(targ, &(ipv6_buf->destaddr));
}
else {
@ -670,15 +670,15 @@ void init_nbr_sol(ipv6_addr_t *src, ipv6_addr_t *dest, ipv6_addr_t *targ,
packet_length = IPV6_HDR_LEN + ICMPV6_HDR_LEN + NBR_SOL_LEN;
if(ipv6_iface_addr_match(targ) == NULL) {
if(src == NULL) {
if (ipv6_iface_addr_match(targ) == NULL) {
if (src == NULL) {
ipv6_get_saddr(&(ipv6_buf->srcaddr), &(ipv6_buf->destaddr));
}
else {
memcpy(&(ipv6_buf->srcaddr), src, 16);
}
if(sllao == OPT_SLLAO) {
if (sllao == OPT_SLLAO) {
/* set sllao option */
opt_stllao_buf = get_opt_stllao_buf(ipv6_ext_hdr_len, opt_hdr_len);
set_llao(opt_stllao_buf, OPT_SLLAO_TYPE, 1);
@ -688,7 +688,7 @@ void init_nbr_sol(ipv6_addr_t *src, ipv6_addr_t *dest, ipv6_addr_t *targ,
}
}
if(aro == OPT_ARO) {
if (aro == OPT_ARO) {
/* set aro option */
opt_aro_buf = get_opt_aro_buf(ipv6_ext_hdr_len, opt_hdr_len);
opt_aro_buf->type = OPT_ARO_TYPE;
@ -722,10 +722,10 @@ void recv_nbr_sol(void)
* option condition is that a sllao option is set. thus that we don't
* know which option comes first we need to this here */
while(packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
while (packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
opt_buf = get_opt_buf(ipv6_ext_hdr_len, opt_hdr_len);
if(opt_buf->type == OPT_SLLAO_TYPE) {
if (opt_buf->type == OPT_SLLAO_TYPE) {
sllao_set = 1;
}
@ -734,23 +734,23 @@ void recv_nbr_sol(void)
opt_hdr_len = NBR_SOL_LEN;
while(packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
while (packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
opt_buf = get_opt_buf(ipv6_ext_hdr_len, opt_hdr_len);
switch(opt_buf->type) {
case(OPT_SLLAO_TYPE): {
case (OPT_SLLAO_TYPE): {
opt_stllao_buf = get_opt_stllao_buf(ipv6_ext_hdr_len,
opt_hdr_len);
llao = (uint8_t *)opt_stllao_buf;
if(llao != NULL &&
if (llao != NULL &&
!(ipv6_addr_unspec_match(&ipv6_buf->srcaddr))) {
nbr_entry = nbr_cache_search(&(ipv6_buf->srcaddr));
if(nbr_entry != NULL) {
if (nbr_entry != NULL) {
switch(opt_stllao_buf->length) {
case(1): {
if(memcmp(&llao[2], &(nbr_entry->saddr), 2) == 0) {
case (1): {
if (memcmp(&llao[2], &(nbr_entry->saddr), 2) == 0) {
nbr_entry->isrouter = 0;
}
else {
@ -762,8 +762,8 @@ void recv_nbr_sol(void)
break;
}
case(2): {
if(memcmp(&llao[2], &(nbr_entry->laddr), 8) == 0) {
case (2): {
if (memcmp(&llao[2], &(nbr_entry->laddr), 8) == 0) {
nbr_entry->isrouter = 0;
}
else {
@ -781,7 +781,7 @@ void recv_nbr_sol(void)
}
else {
switch(opt_stllao_buf->length) {
case(1): {
case (1): {
nbr_cache_add(&ipv6_buf->srcaddr,
NULL , 0, NBR_STATUS_STALE,
NBR_CACHE_TYPE_TEN,
@ -791,7 +791,7 @@ void recv_nbr_sol(void)
break;
}
case(2): {
case (2): {
nbr_cache_add(&ipv6_buf->srcaddr,
(ieee_802154_long_t *)&llao[2], 0,
NBR_STATUS_STALE,
@ -809,20 +809,20 @@ void recv_nbr_sol(void)
break;
}
case(OPT_ARO_TYPE): {
case (OPT_ARO_TYPE): {
/* check if sllao option is set, and if address src address
* isn't unspecified - draft-ietf-6lowpan-nd-15#section-6.5 */
if(!(ipv6_addr_unspec_match(&ipv6_buf->srcaddr)) &&
if (!(ipv6_addr_unspec_match(&ipv6_buf->srcaddr)) &&
sllao_set == 1) {
opt_aro_buf = get_opt_aro_buf(ipv6_ext_hdr_len,
opt_hdr_len);
if((opt_aro_buf->length == 2) &&
if ((opt_aro_buf->length == 2) &&
(opt_aro_buf->status == 0)) {
/* check neighbor cache for duplicates */
nbr_entry = nbr_cache_search(&(ipv6_buf->srcaddr));
if(nbr_entry == NULL) {
if (nbr_entry == NULL) {
/* create neighbor cache */
aro_state = nbr_cache_add(&ipv6_buf->srcaddr,
&(opt_aro_buf->eui64), 0,
@ -830,10 +830,10 @@ void recv_nbr_sol(void)
opt_aro_buf->reg_ltime, NULL);
}
else {
if(memcmp(&(nbr_entry->addr.uint16[4]),
if (memcmp(&(nbr_entry->addr.uint16[4]),
&(opt_aro_buf->eui64.uint16[0]), 8) == 0) {
/* update neighbor cache entry */
if(opt_aro_buf->reg_ltime == 0) {
if (opt_aro_buf->reg_ltime == 0) {
/* delete neighbor cache entry */
nbr_cache_rem(&nbr_entry->addr);
}
@ -870,10 +870,10 @@ void recv_nbr_sol(void)
nbr_sol_buf = get_nbr_sol_buf(ipv6_ext_hdr_len);
alist_targ = ipv6_iface_addr_match(&(nbr_sol_buf->tgtaddr));
if(alist_targ != NULL) {
if (alist_targ != NULL) {
alist_dest = ipv6_iface_addr_match(&(ipv6_buf->destaddr));
if((memcmp(&(alist_targ->addr), &(alist_dest->addr), 16) == 0) ||
if ((memcmp(&(alist_targ->addr), &(alist_dest->addr), 16) == 0) ||
ipv6_addr_sol_node_mcast_match(&ipv6_buf->destaddr)) {
memcpy(&(ipv6_buf->destaddr.uint8[0]),
&(ipv6_buf->srcaddr.uint8[0]), 16);
@ -883,7 +883,7 @@ void recv_nbr_sol(void)
}
}
if(send_na) {
if (send_na) {
/* solicited na */
uint8_t flags = (NBR_ADV_FLAG_O | NBR_ADV_FLAG_S);
init_nbr_adv(&(ipv6_buf->srcaddr), &(ipv6_buf->destaddr),
@ -922,7 +922,7 @@ void init_nbr_adv(ipv6_addr_t *src, ipv6_addr_t *dst, ipv6_addr_t *tgt,
packet_length = IPV6_HDR_LEN + ICMPV6_HDR_LEN + NBR_ADV_LEN;
if(sllao == OPT_SLLAO) {
if (sllao == OPT_SLLAO) {
/* set sllao option */
opt_stllao_buf = get_opt_stllao_buf(ipv6_ext_hdr_len, opt_hdr_len);
set_llao(opt_stllao_buf, OPT_SLLAO_TYPE, 1);
@ -931,7 +931,7 @@ void init_nbr_adv(ipv6_addr_t *src, ipv6_addr_t *dst, ipv6_addr_t *tgt,
packet_length += OPT_STLLAO_MIN_LEN;
}
if(aro == OPT_ARO) {
if (aro == OPT_ARO) {
/* set aro option */
opt_aro_buf = get_opt_aro_buf(ipv6_ext_hdr_len, opt_hdr_len);
opt_aro_buf->type = OPT_ARO_TYPE;
@ -960,17 +960,17 @@ void recv_nbr_adv(void)
nbr_adv_buf = get_nbr_adv_buf(ipv6_ext_hdr_len);
/* check if options are present */
while(packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
while (packet_length > IPV6HDR_ICMPV6HDR_LEN + opt_hdr_len) {
opt_buf = get_opt_buf(ipv6_ext_hdr_len, opt_hdr_len);
switch(opt_buf->type) {
case(OPT_TLLAO_TYPE): {
case (OPT_TLLAO_TYPE): {
llao = (uint8_t *)get_opt_stllao_buf(ipv6_ext_hdr_len,
opt_hdr_len);
break;
}
case(OPT_ARO_TYPE): {
case (OPT_ARO_TYPE): {
break;
}
}
@ -981,24 +981,24 @@ void recv_nbr_adv(void)
addr_list_t *addr;
addr = ipv6_iface_addr_match(&nbr_adv_buf->tgtaddr);
if(addr == NULL) {
if (addr == NULL) {
nbr_entry = nbr_cache_search(&nbr_adv_buf->tgtaddr);
if(nbr_entry != NULL) {
if(llao != 0) {
if (nbr_entry != NULL) {
if (llao != 0) {
/* TODO: untersheiden zwischen short und long stllao option */
new_ll = memcmp(&llao[2], &(nbr_entry->laddr), 8);
}
if(nbr_entry->state == NBR_STATUS_INCOMPLETE) {
if(llao == NULL) {
if (nbr_entry->state == NBR_STATUS_INCOMPLETE) {
if (llao == NULL) {
return;
}
/* TODO: untersheiden zwischen short und long stllao option */
memcpy(&nbr_entry->laddr, &llao[2], 8);
if(nbr_adv_buf->rso & NBR_ADV_FLAG_S) {
if (nbr_adv_buf->rso & NBR_ADV_FLAG_S) {
nbr_entry->state = NBR_STATUS_REACHABLE;
/* TODO: set rechability */
}
@ -1009,27 +1009,27 @@ void recv_nbr_adv(void)
nbr_entry->isrouter = nbr_adv_buf->rso & NBR_ADV_FLAG_R;
}
else {
if(new_ll && !(nbr_adv_buf->rso & NBR_ADV_FLAG_O)) {
if(nbr_entry->state == NBR_STATUS_REACHABLE) {
if (new_ll && !(nbr_adv_buf->rso & NBR_ADV_FLAG_O)) {
if (nbr_entry->state == NBR_STATUS_REACHABLE) {
nbr_entry->state = NBR_STATUS_STALE;
}
return;
}
else {
if((nbr_adv_buf->rso & NBR_ADV_FLAG_O) ||
if ((nbr_adv_buf->rso & NBR_ADV_FLAG_O) ||
(!(nbr_adv_buf->rso & NBR_ADV_FLAG_O) && llao != 0 &&
!new_ll)) {
if(llao != 0) {
if (llao != 0) {
memcpy(&nbr_entry->laddr, &llao[2], 8);
}
if(nbr_adv_buf->rso & NBR_ADV_FLAG_S) {
if (nbr_adv_buf->rso & NBR_ADV_FLAG_S) {
nbr_entry->state = NBR_STATUS_REACHABLE;
/* TODO: set rechablility */
}
else {
if(llao != 0 && new_ll) {
if (llao != 0 && new_ll) {
nbr_entry->state = NBR_STATUS_STALE;
}
}
@ -1050,13 +1050,13 @@ void set_llao(opt_stllao_t *sllao, uint8_t type, uint8_t length)
/* get link layer address */
switch(length) {
case(1): {
case (1): {
memcpy(&llao[2], &(iface.saddr), 2);
memset(&llao[4], 0, 4);
break;
}
case(2): {
case (2): {
memcpy(&llao[2], &(iface.laddr), 8);
memset(&llao[10], 0, 6);
break;
@ -1126,8 +1126,8 @@ nbr_cache_t *nbr_cache_search(ipv6_addr_t *ipaddr)
{
int i;
for(i = 0; i < NBR_CACHE_SIZE; i++) {
if(memcmp(&(nbr_cache[i].addr.uint8[0]), &(ipaddr->uint8[0]), 16) == 0) {
for (i = 0; i < NBR_CACHE_SIZE; i++) {
if (memcmp(&(nbr_cache[i].addr.uint8[0]), &(ipaddr->uint8[0]), 16) == 0) {
return &nbr_cache[i];
}
}
@ -1139,7 +1139,7 @@ uint8_t nbr_cache_add(ipv6_addr_t *ipaddr, ieee_802154_long_t *laddr,
uint8_t isrouter, uint8_t state, uint8_t type,
uint16_t ltime, ieee_802154_short_t *saddr)
{
if(nbr_count == NBR_CACHE_SIZE) {
if (nbr_count == NBR_CACHE_SIZE) {
printf("ERROR: neighbor cache full\n");
return OPT_ARO_STATE_NBR_CACHE_FULL;
}
@ -1162,8 +1162,8 @@ void nbr_cache_auto_rem(void)
{
int i;
for(i = 0; i < NBR_CACHE_SIZE; i++) {
if(get_remaining_time(&(nbr_cache[i].ltime)) == 0 &&
for (i = 0; i < NBR_CACHE_SIZE; i++) {
if (get_remaining_time(&(nbr_cache[i].ltime)) == 0 &&
nbr_cache[i].type == NBR_CACHE_TYPE_TEN) {
memmove(&(nbr_cache[i]), &(nbr_cache[nbr_count]),
sizeof(nbr_cache_t));
@ -1177,8 +1177,8 @@ void nbr_cache_rem(ipv6_addr_t *addr)
{
int i;
for(i = 0; i < NBR_CACHE_SIZE; i++) {
if(memcmp(&(nbr_cache[i].addr.uint8[0]), &(addr->uint8[0]), 16) == 0) {
for (i = 0; i < NBR_CACHE_SIZE; i++) {
if (memcmp(&(nbr_cache[i].addr.uint8[0]), &(addr->uint8[0]), 16) == 0) {
memmove(&(nbr_cache[i]), &(nbr_cache[nbr_count]),
sizeof(nbr_cache_t));
memset(&(nbr_cache[nbr_count]), 0, sizeof(nbr_cache_t));
@ -1202,8 +1202,8 @@ static abr_cache_t *abr_get_most_current(void)
int i;
int version = abr_cache[0].version;
for(i = 0; i < abr_count; i++) {
if(serial_comp16(version, abr_cache[i].version) == GREATER) {
for (i = 0; i < abr_count; i++) {
if (serial_comp16(version, abr_cache[i].version) == GREATER) {
abr = &(abr_cache[i]);
version = abr_cache[i].version;
}
@ -1218,8 +1218,8 @@ static abr_cache_t *abr_get_oldest(void)
int i;
int version = abr_cache[0].version;
for(i = 0; i < abr_count; i++) {
if(serial_comp16(version, abr_cache[i].version) == LESS) {
for (i = 0; i < abr_count; i++) {
if (serial_comp16(version, abr_cache[i].version) == LESS) {
abr = &(abr_cache[i]);
version = abr_cache[i].version;
}
@ -1232,8 +1232,8 @@ abr_cache_t *abr_get_version(uint16_t version, ipv6_addr_t *abr_addr)
{
int i = 0;
for(i = 0; i < ABR_CACHE_SIZE; i++) {
if(abr_cache[i].version == version &&
for (i = 0; i < ABR_CACHE_SIZE; i++) {
if (abr_cache[i].version == version &&
memcmp(&(abr_cache[i].abr_addr.uint8[0]),
&(abr_addr->uint8[0]), 16
) == 0) {
@ -1246,7 +1246,7 @@ abr_cache_t *abr_get_version(uint16_t version, ipv6_addr_t *abr_addr)
lowpan_context_t *abr_get_context(abr_cache_t *abr, uint8_t cid)
{
if(abr->cids[cid] != cid) {
if (abr->cids[cid] != cid) {
return NULL;
}
@ -1258,8 +1258,8 @@ abr_cache_t *abr_add_context(uint16_t version, ipv6_addr_t *abr_addr,
{
abr_cache_t *abr = abr_get_version(version, abr_addr);
if(abr == NULL) {
if(abr_count == ABR_CACHE_SIZE) {
if (abr == NULL) {
if (abr_count == ABR_CACHE_SIZE) {
abr = abr_get_oldest();
}
else {
@ -1280,7 +1280,7 @@ void abr_remove_context(uint8_t cid)
{
int i;
for(i = 0; i < abr_count; i++) {
for (i = 0; i < abr_count; i++) {
abr_cache[i].cids[cid] = 0xFF;
}
}
@ -1292,8 +1292,8 @@ def_rtr_lst_t *def_rtr_lst_search(ipv6_addr_t *ipaddr)
{
int i;
for(i = 0; i < DEF_RTR_LST_SIZE; i++) {
if(memcmp(&def_rtr_lst[i].addr.uint8[0],
for (i = 0; i < DEF_RTR_LST_SIZE; i++) {
if (memcmp(&def_rtr_lst[i].addr.uint8[0],
&(ipaddr->uint8[0]), 16) == 0) {
return &def_rtr_lst[i];
}
@ -1304,7 +1304,7 @@ def_rtr_lst_t *def_rtr_lst_search(ipv6_addr_t *ipaddr)
void def_rtr_lst_add(ipv6_addr_t *ipaddr, uint32_t rtr_ltime)
{
if(def_rtr_count == DEF_RTR_LST_SIZE) {
if (def_rtr_count == DEF_RTR_LST_SIZE) {
DEBUG("ERROR: default router list full\n");
}
else {
@ -1323,8 +1323,8 @@ void def_rtr_lst_rem(def_rtr_lst_t *entry)
{
int i;
for(i = 0; i < DEF_RTR_LST_SIZE; i++) {
if(&def_rtr_lst[i] == entry) {
for (i = 0; i < DEF_RTR_LST_SIZE; i++) {
if (&def_rtr_lst[i] == entry) {
/* search the to deleted item, then memmove the last item to its
* position, and decrement array count */
memmove(entry, &def_rtr_lst[def_rtr_count], sizeof(def_rtr_lst_t));
@ -1340,7 +1340,7 @@ void def_rtr_lst_rem(def_rtr_lst_t *entry)
int8_t plist_add(ipv6_addr_t *addr, uint8_t size, uint32_t val_ltime,
uint32_t pref_ltime, uint8_t adv_opt, uint8_t l_a_reserved1)
{
if(prefix_count == OPT_PI_LIST_LEN) {
if (prefix_count == OPT_PI_LIST_LEN) {
return SIXLOWERROR_ARRAYFULL;
}
else {

262
sys/net/sixlowpan/sixlowpan.c
View File

@ -93,7 +93,7 @@ void lowpan_init(ieee_802154_long_t *addr, uint8_t *data)
memcpy(&laddr.uint8[0], &addr->uint8[0], 8);
if(ipv6_prefix_mcast_match(&ipv6_buf->destaddr)) {
if (ipv6_prefix_mcast_match(&ipv6_buf->destaddr)) {
/* send broadcast */
mcast = 1;
}
@ -103,7 +103,7 @@ void lowpan_init(ieee_802154_long_t *addr, uint8_t *data)
packet_length = comp_len;
/* check if packet needs to be fragmented */
if(packet_length + header_size > PAYLOAD_SIZE - IEEE_802154_MAX_HDR_LEN) {
if (packet_length + header_size > PAYLOAD_SIZE - IEEE_802154_MAX_HDR_LEN) {
uint8_t fragbuf[packet_length + header_size];
uint8_t remaining;
uint8_t i = 2;
@ -126,7 +126,7 @@ void lowpan_init(ieee_802154_long_t *addr, uint8_t *data)
data += position;
while(packet_length - position > max_frame - 5) {
while (packet_length - position > max_frame - 5) {
memset(&fragbuf, 0, packet_length + header_size);
memcpy(fragbuf + 5, data, max_frag);
@ -180,14 +180,14 @@ void printReasBuffers(void)
printf("\n\n--- Reassembly Buffers ---\n");
while(temp_buffer != NULL) {
while (temp_buffer != NULL) {
printLongLocalAddr(&temp_buffer->s_laddr);
printf("Ident.: %i, Packet Size: %i/%i, Timestamp: %li\n",
temp_buffer->ident_no, temp_buffer->current_packet_size,
temp_buffer->packet_size, temp_buffer->timestamp);
temp_interval = temp_buffer->interval_list_head;
while(temp_interval != NULL) {
while (temp_interval != NULL) {
printf("\t%i - %i\n", temp_interval->start, temp_interval->end);
temp_interval = temp_interval->next;
}
@ -204,14 +204,14 @@ void printFIFOBuffers(void)
printf("\n\n--- Reassembly Buffers ---\n");
while(temp_buffer != NULL) {
while (temp_buffer != NULL) {
printLongLocalAddr(&temp_buffer->s_laddr);
printf("Ident.: %i, Packet Size: %i/%i, Timestamp: %li\n",
temp_buffer->ident_no, temp_buffer->current_packet_size,
temp_buffer->packet_size, temp_buffer->timestamp);
temp_interval = temp_buffer->interval_list_head;
while(temp_interval != NULL) {
while (temp_interval != NULL) {
printf("\t%i - %i\n", temp_interval->start, temp_interval->end);
temp_interval = temp_interval->next;
}
@ -227,23 +227,23 @@ void lowpan_transfer(void)
lowpan_reas_buf_t *current_buf;
uint8_t gotosleep;
while(1) {
while (1) {
gotosleep = 1;
mutex_lock(&fifo_mutex);
current_buf = packet_fifo;
if(current_buf != NULL) {
if (current_buf != NULL) {
mutex_unlock(&fifo_mutex, 0);
if((current_buf->packet)[0] == LOWPAN_IPV6_DISPATCH) {
if ((current_buf->packet)[0] == LOWPAN_IPV6_DISPATCH) {
ipv6_buf = get_ipv6_buf();
memcpy(ipv6_buf, (current_buf->packet) + 1, current_buf->packet_size - 1);
m_send.content.ptr = (char *)ipv6_buf;
packet_length = current_buf->packet_size - 1;
msg_send_receive(&m_send, &m_recv, ip_process_pid);
}
else if(((current_buf->packet)[0] & 0xe0) == LOWPAN_IPHC_DISPATCH) {
else if (((current_buf->packet)[0] & 0xe0) == LOWPAN_IPHC_DISPATCH) {
lowpan_iphc_decoding(current_buf->packet,
current_buf->packet_size,
&(current_buf->s_laddr),
@ -262,7 +262,7 @@ void lowpan_transfer(void)
}
if(gotosleep == 1) {
if (gotosleep == 1) {
mutex_unlock(&fifo_mutex, 0);
thread_sleep();
}
@ -273,17 +273,17 @@ uint8_t ll_get_addr_match(ieee_802154_long_t *src, ieee_802154_long_t *dst)
{
uint8_t val = 0, xor;
for(int i = 0; i < 8; i++) {
for (int i = 0; i < 8; i++) {
/* if bytes are equal add 8 */
if(src->uint8[i] == dst->uint8[i]) {
if (src->uint8[i] == dst->uint8[i]) {
val += 8;
}
else {
xor = src->uint8[i] ^ dst->uint8[i];
/* while bits from byte equal add 1 */
for(int j = 0; j < 8; j++) {
if((xor & 0x80) == 0) {
for (int j = 0; j < 8; j++) {
if ((xor & 0x80) == 0) {
val++;
xor = xor << 1;
}
@ -309,12 +309,12 @@ lowpan_reas_buf_t *new_packet_buffer(uint16_t datagram_size,
/* Allocate new memory for a new packet to be reassembled */
new_buf = malloc(sizeof(lowpan_reas_buf_t));
if(new_buf != NULL) {
if (new_buf != NULL) {
init_reas_bufs(new_buf);
new_buf->packet = malloc(datagram_size);
if(new_buf->packet != NULL) {
if (new_buf->packet != NULL) {
memcpy(&new_buf->s_laddr, s_laddr, SIXLOWPAN_IPV6_LL_ADDR_LEN);
memcpy(&new_buf->d_laddr, d_laddr, SIXLOWPAN_IPV6_LL_ADDR_LEN);
@ -325,7 +325,7 @@ lowpan_reas_buf_t *new_packet_buffer(uint16_t datagram_size,
vtimer_now(&now);
new_buf->timestamp = now.microseconds;
if((current_buf == NULL) && (temp_buf == NULL)) {
if ((current_buf == NULL) && (temp_buf == NULL)) {
head = new_buf;
}
else {
@ -351,8 +351,8 @@ lowpan_reas_buf_t *get_packet_frag_buf(uint16_t datagram_size,
lowpan_reas_buf_t *current_buf = NULL, *temp_buf = NULL;
current_buf = head;
while(current_buf != NULL) {
if(((ll_get_addr_match(&current_buf->s_laddr, s_laddr)) == 64) &&
while (current_buf != NULL) {
if (((ll_get_addr_match(&current_buf->s_laddr, s_laddr)) == 64) &&
((ll_get_addr_match(&current_buf->d_laddr, d_laddr)) == 64) &&
(current_buf->packet_size == datagram_size) &&
(current_buf->ident_no == datagram_tag) &&
@ -377,7 +377,7 @@ uint8_t isInInterval(uint8_t start1, uint8_t end1, uint8_t start2, uint8_t end2)
/* 1: Interval 1 and 2 are the same or overlapping */
/* 0: Interval 1 and 2 are not overlapping or the same */
if(((start1 < start2) && (start2 <= end1)) ||
if (((start1 < start2) && (start2 <= end1)) ||
((start2 < start1) && (start1 <= end2)) ||
((start1 == start2) && (end1 == end2))) {
return 1;
@ -395,8 +395,8 @@ uint8_t handle_packet_frag_interval(lowpan_reas_buf_t *current_buf,
lowpan_interval_list_t *temp_interval = NULL, *current_interval = NULL, *new_interval = NULL;
current_interval = current_buf->interval_list_head;
while(current_interval != NULL) {
if(isInInterval(current_interval->start, current_interval->end, datagram_offset, datagram_offset + frag_size) == 1) {
while (current_interval != NULL) {
if (isInInterval(current_interval->start, current_interval->end, datagram_offset, datagram_offset + frag_size) == 1) {
/* Interval is overlapping or the same as one of a previous fragment, discard fragment */
return 0;
}
@ -407,12 +407,12 @@ uint8_t handle_packet_frag_interval(lowpan_reas_buf_t *current_buf,
new_interval = malloc(sizeof(lowpan_interval_list_t));
if(new_interval != NULL) {
if (new_interval != NULL) {
new_interval->start = datagram_offset;
new_interval->end = datagram_offset + frag_size - 1;
new_interval->next = NULL;
if((current_interval == NULL) && (temp_interval == NULL)) {
if ((current_interval == NULL) && (temp_interval == NULL)) {
current_buf->interval_list_head = new_interval;
}
else {
@ -435,12 +435,12 @@ lowpan_reas_buf_t *collect_garbage_fifo(lowpan_reas_buf_t *current_buf)
temp_buf = packet_fifo;
my_buf = temp_buf;
if(packet_fifo == current_buf) {
if (packet_fifo == current_buf) {
packet_fifo = current_buf->next;
return_buf = packet_fifo;
}
else {
while(temp_buf != current_buf) {
while (temp_buf != current_buf) {
my_buf = temp_buf;
temp_buf = temp_buf->next;
}
@ -455,7 +455,7 @@ lowpan_reas_buf_t *collect_garbage_fifo(lowpan_reas_buf_t *current_buf)
current_list = current_buf->interval_list_head;
temp_list = current_list;
while(current_list != NULL) {
while (current_list != NULL) {
temp_list = current_list->next;
free(current_list);
current_list = temp_list;
@ -475,12 +475,12 @@ lowpan_reas_buf_t *collect_garbage(lowpan_reas_buf_t *current_buf)
temp_buf = head;
my_buf = temp_buf;
if(head == current_buf) {
if (head == current_buf) {
head = current_buf->next;
return_buf = head;
}
else {
while(temp_buf != current_buf) {
while (temp_buf != current_buf) {
my_buf = temp_buf;
temp_buf = temp_buf->next;
}
@ -493,7 +493,7 @@ lowpan_reas_buf_t *collect_garbage(lowpan_reas_buf_t *current_buf)
current_list = current_buf->interval_list_head;
temp_list = current_list;
while(current_list != NULL) {
while (current_list != NULL) {
temp_list = current_list->next;
free(current_list);
current_list = temp_list;
@ -515,24 +515,24 @@ void handle_packet_fragment(uint8_t *data, uint8_t datagram_offset,
/* Is there already a reassembly buffer for this packet fragment? */
current_buf = get_packet_frag_buf(datagram_size, datagram_tag, s_laddr, d_laddr);
if((current_buf != NULL) && (handle_packet_frag_interval(current_buf,
if ((current_buf != NULL) && (handle_packet_frag_interval(current_buf,
datagram_offset,
frag_size) == 1)) {
/* Copy fragment bytes into corresponding packet space area */
memcpy(current_buf->packet + datagram_offset, data + hdr_length, frag_size);
current_buf->current_packet_size += frag_size;
if(current_buf->current_packet_size == current_buf->packet_size) {
if (current_buf->current_packet_size == current_buf->packet_size) {
add_fifo_packet(current_buf);
if(thread_getstatus(transfer_pid) == STATUS_SLEEPING) {
if (thread_getstatus(transfer_pid) == STATUS_SLEEPING) {
thread_wakeup(transfer_pid);
}
}
}
else {
/* No memory left or duplicate */
if(current_buf == NULL) {
if (current_buf == NULL) {
printf("ERROR: no memory left!\n");
}
else {
@ -552,17 +552,17 @@ void check_timeout(void)
cur_time = now.microseconds;
temp_buf = head;
while(temp_buf != NULL) {
if((cur_time - temp_buf->timestamp) >= LOWPAN_REAS_BUF_TIMEOUT) {
printf("TIMEOUT! cur_time: %li, temp_buf: %li\n", cur_time,
while (temp_buf != NULL) {
if ((cur_time - temp_buf->timestamp) >= LOWPAN_REAS_BUF_TIMEOUT) {
printf("TIMEOUT!cur_time: %li, temp_buf: %li\n", cur_time,
temp_buf->timestamp);
temp_buf = collect_garbage(temp_buf);
}
else {
if(smallest_time == NULL) {
if (smallest_time == NULL) {
smallest_time = temp_buf;
}
else if(temp_buf->timestamp < smallest_time->timestamp) {
else if (temp_buf->timestamp < smallest_time->timestamp) {
smallest_time = temp_buf;
}
@ -571,7 +571,7 @@ void check_timeout(void)
}
}
if((count > 10) && (smallest_time != NULL)) {
if ((count > 10) && (smallest_time != NULL)) {
collect_garbage(smallest_time);
}
}
@ -580,13 +580,13 @@ void add_fifo_packet(lowpan_reas_buf_t *current_packet)
{
lowpan_reas_buf_t *temp_buf, *my_buf;
if(head == current_packet) {
if (head == current_packet) {
head = current_packet->next;
}
else {
temp_buf = head;
while(temp_buf != current_packet) {
while (temp_buf != current_packet) {
my_buf = temp_buf;
temp_buf = temp_buf->next;
}
@ -596,13 +596,13 @@ void add_fifo_packet(lowpan_reas_buf_t *current_packet)
mutex_lock(&fifo_mutex);
if(packet_fifo == NULL) {
if (packet_fifo == NULL) {
packet_fifo = current_packet;
}
else {
temp_buf = packet_fifo;
while(temp_buf != NULL) {
while (temp_buf != NULL) {
my_buf = temp_buf;
temp_buf = temp_buf->next;
}
@ -626,7 +626,7 @@ void lowpan_read(uint8_t *data, uint8_t length, ieee_802154_long_t *s_laddr,
check_timeout();
/* Fragmented Packet */
if(((data[0] & 0xf8) == (0xc0)) || ((data[0] & 0xf8) == (0xe0))) {
if (((data[0] & 0xf8) == (0xc0)) || ((data[0] & 0xf8) == (0xe0))) {
/* get 11-bit from first 2 byte*/
datagram_size = (((uint16_t)(data[0] << 8)) | data[1]) & 0x07ff;
@ -635,14 +635,14 @@ void lowpan_read(uint8_t *data, uint8_t length, ieee_802154_long_t *s_laddr,
switch(data[0] & 0xf8) {
/* First Fragment */
case(0xc0): {
case (0xc0): {
datagram_offset = 0;
hdr_length += 4;
break;
}
/* Subsequent Fragment */
case(0xe0): {
case (0xe0): {
datagram_offset = data[4];
hdr_length += 5;
break;
@ -652,8 +652,8 @@ void lowpan_read(uint8_t *data, uint8_t length, ieee_802154_long_t *s_laddr,
frag_size = length - hdr_length;
byte_offset = datagram_offset * 8;
if((frag_size % 8) != 0) {
if((byte_offset + frag_size) != datagram_size) {
if ((frag_size % 8) != 0) {
if ((byte_offset + frag_size) != datagram_size) {
printf("ERROR: received invalid fragment\n");
return;
}
@ -671,7 +671,7 @@ void lowpan_read(uint8_t *data, uint8_t length, ieee_802154_long_t *s_laddr,
current_buf->current_packet_size += length;
add_fifo_packet(current_buf);
if(thread_getstatus(transfer_pid) == STATUS_SLEEPING) {
if (thread_getstatus(transfer_pid) == STATUS_SLEEPING) {
thread_wakeup(transfer_pid);
}
}
@ -710,12 +710,12 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
(ipv6_buf->trafficclass_flowlabel >> 4);
tc = (tc >> 2) | (tc << 6);
if((ipv6_buf->flowlabel == 0) &&
if ((ipv6_buf->flowlabel == 0) &&
(ipv6_buf->trafficclass_flowlabel & 0x0f) == 0) {
/* flowlabel is elided */
lowpan_iphc[0] |= LOWPAN_IPHC_FL_C;
if(((ipv6_buf->version_trafficclass & 0x0f) == 0) &&
if (((ipv6_buf->version_trafficclass & 0x0f) == 0) &&
((ipv6_buf->trafficclass_flowlabel & 0xf0) == 0)) {
/* traffic class is elided */
lowpan_iphc[0] |= LOWPAN_IPHC_TC_C;
@ -728,7 +728,7 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
}
else {
/* flowlabel not compressible */
if(((ipv6_buf->version_trafficclass & 0x0f) == 0) &&
if (((ipv6_buf->version_trafficclass & 0x0f) == 0) &&
((ipv6_buf->trafficclass_flowlabel & 0xf0) == 0)) {
/* traffic class is elided */
lowpan_iphc[0] |= LOWPAN_IPHC_TC_C;
@ -753,19 +753,19 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
/* HLIM: Hop Limit: */
switch(ipv6_buf->hoplimit) {
case(1): {
case (1): {
/* 01: The Hop Limit field is compressed and the hop limit is 1. */
lowpan_iphc[0] |= 0x01;
break;
}
case(64): {
case (64): {
/* 10: The Hop Limit field is compressed and the hop limit is 64. */
lowpan_iphc[0] |= 0x02;
break;
}
case(255): {
case (255): {
/* 11: The Hop Limit field is compressed and the hop limit is 255. */
lowpan_iphc[0] |= 0x03;
break;
@ -781,7 +781,7 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
mutex_lock(&lowpan_context_mutex);
/* CID: Context Identifier Extension: */
if((lowpan_context_lookup(&ipv6_buf->srcaddr) != NULL) ||
if ((lowpan_context_lookup(&ipv6_buf->srcaddr) != NULL) ||
(lowpan_context_lookup(&ipv6_buf->destaddr) != NULL)) {
lowpan_iphc[1] |= LOWPAN_IPHC_CID;
memmove(&ipv6_hdr_fields[1], &ipv6_hdr_fields[0], hdr_pos);
@ -789,22 +789,22 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
}
/* SAC: Source Address Compression */
if(ipv6_addr_unspec_match(&(ipv6_buf->srcaddr))) {
if (ipv6_addr_unspec_match(&(ipv6_buf->srcaddr))) {
/* SAC = 1 and SAM = 00 */
lowpan_iphc[1] |= LOWPAN_IPHC_SAC;
}
else if((con = lowpan_context_lookup(&ipv6_buf->srcaddr)) != NULL) {
else if ((con = lowpan_context_lookup(&ipv6_buf->srcaddr)) != NULL) {
/* 1: Source address compression uses stateful, context-based
* compression. */
lowpan_iphc[1] |= LOWPAN_IPHC_SAC;
ipv6_hdr_fields[0] |= (con->num << 4);
if(memcmp(&(ipv6_buf->srcaddr.uint8[8]), &(iface.laddr.uint8[0]), 8) == 0) {
if (memcmp(&(ipv6_buf->srcaddr.uint8[8]), &(iface.laddr.uint8[0]), 8) == 0) {
/* 0 bits. The address is derived using context information
* and possibly the link-layer addresses.*/
lowpan_iphc[1] |= 0x30;
}
else if((ipv6_buf->srcaddr.uint16[4] == 0) &&
else if ((ipv6_buf->srcaddr.uint16[4] == 0) &&
(ipv6_buf->srcaddr.uint16[5] == 0) &&
(ipv6_buf->srcaddr.uint16[6] == 0) &&
((ipv6_buf->srcaddr.uint8[14]) & 0x80) == 0) {
@ -824,14 +824,14 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
lowpan_iphc[1] |= 0x10;
}
}
else if(ipv6_prefix_ll_match(&ipv6_buf->srcaddr)) {
else if (ipv6_prefix_ll_match(&ipv6_buf->srcaddr)) {
/* 0: Source address compression uses stateless compression.*/
if(memcmp(&(ipv6_buf->srcaddr.uint8[8]), &(iface.laddr.uint8[0]), 8) == 0) {
if (memcmp(&(ipv6_buf->srcaddr.uint8[8]), &(iface.laddr.uint8[0]), 8) == 0) {
/* 0 bits. The address is derived using context information
* and possibly the link-layer addresses.*/
lowpan_iphc[1] |= 0x30;
}
else if((ipv6_buf->srcaddr.uint16[4] == 0) &&
else if ((ipv6_buf->srcaddr.uint16[4] == 0) &&
(ipv6_buf->srcaddr.uint16[5] == 0) &&
(ipv6_buf->srcaddr.uint16[6] == 0) &&
((ipv6_buf->srcaddr.uint8[14]) & 0x80) == 0) {
@ -858,12 +858,12 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
}
/* M: Multicast Compression */
if(ipv6_prefix_mcast_match(&ipv6_buf->destaddr)) {
if (ipv6_prefix_mcast_match(&ipv6_buf->destaddr)) {
/* 1: Destination address is a multicast address. */
lowpan_iphc[1] |= LOWPAN_IPHC_M;
/* just another cool if condition */
if((ipv6_buf->destaddr.uint8[1] == 2) &&
if ((ipv6_buf->destaddr.uint8[1] == 2) &&
(ipv6_buf->destaddr.uint16[1] == 0) &&
(ipv6_buf->destaddr.uint16[2] == 0) &&
(ipv6_buf->destaddr.uint16[3] == 0) &&
@ -876,7 +876,7 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
ipv6_hdr_fields[hdr_pos] = ipv6_buf->destaddr.uint8[15];
hdr_pos++;
}
else if((ipv6_buf->destaddr.uint16[1] == 0) &&
else if ((ipv6_buf->destaddr.uint16[1] == 0) &&
(ipv6_buf->destaddr.uint16[2] == 0) &&
(ipv6_buf->destaddr.uint16[3] == 0) &&
(ipv6_buf->destaddr.uint16[4] == 0) &&
@ -890,7 +890,7 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
memcpy(&ipv6_hdr_fields[hdr_pos], &ipv6_buf->destaddr.uint8[13], 3);
hdr_pos += 3;
}
else if((ipv6_buf->destaddr.uint16[1] == 0) &&
else if ((ipv6_buf->destaddr.uint16[1] == 0) &&
(ipv6_buf->destaddr.uint16[2] == 0) &&
(ipv6_buf->destaddr.uint16[3] == 0) &&
(ipv6_buf->destaddr.uint16[4] == 0) &&
@ -910,18 +910,18 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
}
else {
/* 0: Destination address is not a multicast address. */
if((con = lowpan_context_lookup(&ipv6_buf->destaddr)) != NULL) {
if ((con = lowpan_context_lookup(&ipv6_buf->destaddr)) != NULL) {
/* 1: Destination address compression uses stateful, context-based
* compression. */
lowpan_iphc[1] |= LOWPAN_IPHC_DAC;
ipv6_hdr_fields[0] = con->num;
if(memcmp(&(ipv6_buf->destaddr.uint8[8]), &(dest->uint8[0]), 8) == 0) {
if (memcmp(&(ipv6_buf->destaddr.uint8[8]), &(dest->uint8[0]), 8) == 0) {
/* 0 bits. The address is derived using context information
* and possibly the link-layer addresses.*/
lowpan_iphc[1] |= 0x03;
}
else if((ipv6_buf->destaddr.uint16[4] == 0) &&
else if ((ipv6_buf->destaddr.uint16[4] == 0) &&
(ipv6_buf->destaddr.uint16[5] == 0) &&
(ipv6_buf->destaddr.uint16[6] == 0) &&
((ipv6_buf->destaddr.uint8[14]) & 0x80) == 0) {
@ -941,13 +941,13 @@ void lowpan_iphc_encoding(ieee_802154_long_t *dest, ipv6_hdr_t *ipv6_buf_extra,
lowpan_iphc[1] |= 0x01;
}
}
else if(ipv6_prefix_ll_match(&ipv6_buf->destaddr)) {
if(memcmp(&(ipv6_buf->destaddr.uint8[8]), &(dest->uint8[0]), 8) == 0) {
else if (ipv6_prefix_ll_match(&ipv6_buf->destaddr)) {
if (memcmp(&(ipv6_buf->destaddr.uint8[8]), &(dest->uint8[0]), 8) == 0) {
/* 0 bits. The address is derived using context information
* and possibly the link-layer addresses.*/
lowpan_iphc[1] |= 0x03;
}
else if((ipv6_buf->destaddr.uint16[4] == 0) &&
else if ((ipv6_buf->destaddr.uint16[4] == 0) &&
(ipv6_buf->destaddr.uint16[5] == 0) &&
(ipv6_buf->destaddr.uint16[6] == 0) &&
((ipv6_buf->destaddr.uint8[14]) & 0x80) == 0) {
@ -1015,15 +1015,15 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
hdr_pos += 2;
/* first check if CID flag is set */
if(lowpan_iphc[1] & LOWPAN_IPHC_CID) {
if (lowpan_iphc[1] & LOWPAN_IPHC_CID) {
hdr_pos++;
cid = 1;
}
/* TF: Traffic Class, Flow Label: */
if(lowpan_iphc[0] & LOWPAN_IPHC_FL_C) {
if (lowpan_iphc[0] & LOWPAN_IPHC_FL_C) {
/* flowlabel is elided */
if(lowpan_iphc[0] & LOWPAN_IPHC_TC_C) {
if (lowpan_iphc[0] & LOWPAN_IPHC_TC_C) {
/* traffic class is elided */
ipv6_buf->version_trafficclass = 0x60;
ipv6_buf->trafficclass_flowlabel = 0;
@ -1041,7 +1041,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
else {
/* flowlabel carried inline */
if(lowpan_iphc[0] & LOWPAN_IPHC_TC_C) {
if (lowpan_iphc[0] & LOWPAN_IPHC_TC_C) {
/* traffic class is elided */
ipv6_buf->version_trafficclass = 0x60;
/* ecn + 4 bit flowlabel*/
@ -1066,7 +1066,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
/* NH: Next Header: */
if(lowpan_iphc[0] & LOWPAN_IPHC_NH) {
if (lowpan_iphc[0] & LOWPAN_IPHC_NH) {
// TODO: next header decompression
}
else {
@ -1075,19 +1075,19 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
/* HLIM: Hop Limit: */
if(lowpan_iphc[0] & 0x03) {
if (lowpan_iphc[0] & 0x03) {
switch(lowpan_iphc[0] & 0x03) {
case(0x01): {
case (0x01): {
ipv6_buf->hoplimit = 1;
break;
}
case(0x02): {
case (0x02): {
ipv6_buf->hoplimit = 64;
break;
}
case(0x03): {
case (0x03): {
ipv6_buf->hoplimit = 255;
break;
}
@ -1102,27 +1102,27 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
/* CID: Context Identifier Extension: + SAC: Source Address Compression */
if(lowpan_iphc[1] & LOWPAN_IPHC_SAC) {
if (lowpan_iphc[1] & LOWPAN_IPHC_SAC) {
/* 1: Source address compression uses stateful, context-based
* compression.*/
if(cid) {
if (cid) {
sci = ipv6_hdr_fields[3] >> 4;
}
mutex_lock(&lowpan_context_mutex);
/* check context number */
if(((lowpan_iphc[1] & LOWPAN_IPHC_SAM) >> 4) & 0x03) {
if (((lowpan_iphc[1] & LOWPAN_IPHC_SAM) >> 4) & 0x03) {
con = lowpan_context_num_lookup(sci);
}
if(con == NULL) {
if (con == NULL) {
printf("ERROR: context not found\n");
return;
}
switch(((lowpan_iphc[1] & LOWPAN_IPHC_SAM) >> 4) & 0x03) {
case(0x01): {
case (0x01): {
/* 64-bits */
memcpy(&(ipv6_buf->srcaddr.uint8[8]), &ipv6_hdr_fields[hdr_pos], 8);
/* By draft-ietf-6lowpan-hc-15 3.1.1. Bits covered by context
@ -1132,7 +1132,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x02): {
case (0x02): {
/* 16-bits */
memset(&(ipv6_buf->srcaddr.uint8[8]), 0, 6);
memcpy(&(ipv6_buf->srcaddr.uint8[14]), &ipv6_hdr_fields[hdr_pos], 2);
@ -1143,7 +1143,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x03): {
case (0x03): {
/* 0-bits */
memset(&(ipv6_buf->srcaddr.uint8[8]), 0, 8);
memcpy(&(ipv6_buf->srcaddr.uint8[8]), &s_laddr->uint8[0], 8);
@ -1164,7 +1164,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
else {
switch(((lowpan_iphc[1] & LOWPAN_IPHC_SAM) >> 4) & 0x03) {
case(0x01): {
case (0x01): {
/* 64-bits */
memcpy(&(ipv6_buf->srcaddr.uint8[0]), &ll_prefix[0], 2);
memset(&(ipv6_buf->srcaddr.uint8[2]), 0, 6);
@ -1173,7 +1173,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x02): {
case (0x02): {
/* 16-bits */
memcpy(&(ipv6_buf->srcaddr.uint8[0]), &ll_prefix[0], 2);
memset(&(ipv6_buf->srcaddr.uint8[2]), 0, 12);
@ -1182,7 +1182,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x03): {
case (0x03): {
/* 0-bits */
memcpy(&(ipv6_buf->srcaddr.uint8[0]), &ll_prefix[0], 2);
memset(&(ipv6_buf->srcaddr.uint8[8]), 0, 14);
@ -1201,23 +1201,23 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
/* M: Multicast Compression + DAC: Destination Address Compression */
if(lowpan_iphc[1] & LOWPAN_IPHC_M) {
if (lowpan_iphc[1] & LOWPAN_IPHC_M) {
/* 1: Destination address is a multicast address. */
if(lowpan_iphc[1] & LOWPAN_IPHC_DAC) {
if (lowpan_iphc[1] & LOWPAN_IPHC_DAC) {
/* 1: Destination address compression uses stateful, context-based
* compression.
* If M=1 and DAC=1: */
if(cid) {
if (cid) {
dci = ipv6_hdr_fields[3] & 0x0f;
}
mutex_lock(&lowpan_context_mutex);
if((lowpan_iphc[1] & LOWPAN_IPHC_DAM) & 0x03) {
if ((lowpan_iphc[1] & LOWPAN_IPHC_DAM) & 0x03) {
con = lowpan_context_num_lookup(dci);
}
if(con == NULL) {
if (con == NULL) {
printf("ERROR: context not found\n");
return;
}
@ -1228,13 +1228,13 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
else {
/* If M=1 and DAC=0: */
switch(lowpan_iphc[1] & 0x03) {
case(0x01): {
case (0x01): {
m_prefix[1] = ipv6_hdr_fields[hdr_pos];
hdr_pos++;
break;
}
case(0x02): {
case (0x02): {
m_prefix[1] = ipv6_hdr_fields[hdr_pos];
hdr_pos++;
break;
@ -1245,7 +1245,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
switch(lowpan_iphc[1] & 0x03) {
case(0x01): {
case (0x01): {
memcpy(&(ipv6_buf->destaddr.uint8[0]), &m_prefix[0], 2);
memset(&(ipv6_buf->destaddr.uint8[2]), 0, 9);
memcpy(&(ipv6_buf->destaddr.uint8[11]), &ipv6_hdr_fields[hdr_pos], 5);
@ -1253,7 +1253,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x02): {
case (0x02): {
memcpy(&(ipv6_buf->destaddr.uint8[0]), &m_prefix[0], 2);
memset(&(ipv6_buf->destaddr.uint8[2]), 0, 11);
memcpy(&(ipv6_buf->destaddr.uint8[13]), &ipv6_hdr_fields[hdr_pos], 3);
@ -1261,7 +1261,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x03): {
case (0x03): {
memcpy(&(ipv6_buf->destaddr.uint8[0]), &m_prefix[0], 2);
memset(&(ipv6_buf->destaddr.uint8[2]), 0, 13);
memcpy(&(ipv6_buf->destaddr.uint8[15]), &ipv6_hdr_fields[hdr_pos], 1);
@ -1277,27 +1277,27 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
}
else {
if(lowpan_iphc[1] & LOWPAN_IPHC_DAC) {
if (lowpan_iphc[1] & LOWPAN_IPHC_DAC) {
/* 1: Destination address compression uses stateful, context-based
* compression.
* If M=1 and DAC=1: */
if(cid) {
if (cid) {
dci = ipv6_hdr_fields[3] & 0x0f;
}
mutex_lock(&lowpan_context_mutex);
if((lowpan_iphc[1] & LOWPAN_IPHC_DAM) & 0x03) {
if ((lowpan_iphc[1] & LOWPAN_IPHC_DAM) & 0x03) {
con = lowpan_context_num_lookup(dci);
}
if(con == NULL) {
if (con == NULL) {
printf("ERROR: context not found\n");
return;
}
switch((lowpan_iphc[1] & LOWPAN_IPHC_DAM) & 0x03) {
case(0x01): {
case (0x01): {
memcpy(&(ipv6_buf->destaddr.uint8[8]), &ipv6_hdr_fields[hdr_pos], 8);
/* By draft-ietf-6lowpan-hc-15 3.1.1. Bits covered by context information are always used. */
memcpy(&(ipv6_buf->srcaddr.uint8[0]), &con->prefix, con->length);
@ -1305,7 +1305,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x02): {
case (0x02): {
memset(&(ipv6_buf->destaddr.uint8[8]), 0, 6);
memcpy(&(ipv6_buf->destaddr.uint8[14]), &ipv6_hdr_fields[hdr_pos], 2);
/* By draft-ietf-6lowpan-hc-15 3.1.1. Bits covered by context information are always used. */
@ -1314,7 +1314,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x03): {
case (0x03): {
memset(&(ipv6_buf->destaddr.uint8[0]), 0, 8);
memcpy(&(ipv6_buf->destaddr.uint8[8]), &d_laddr->uint8[0], 8);
/* By draft-ietf-6lowpan-hc-15 3.1.1. Bits covered by context information are always used. */
@ -1330,7 +1330,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
}
else {
switch((lowpan_iphc[1] & LOWPAN_IPHC_DAM) & 0x03) {
case(0x01): {
case (0x01): {
memcpy(&(ipv6_buf->destaddr.uint8[0]), &ll_prefix[0], 2);
memset(&(ipv6_buf->destaddr.uint8[2]), 0, 6);
memcpy(&(ipv6_buf->destaddr.uint8[8]),
@ -1339,7 +1339,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x02): {
case (0x02): {
memcpy(&(ipv6_buf->destaddr.uint8[0]), &ll_prefix[0], 2);
memset(&(ipv6_buf->destaddr.uint8[2]), 0, 12);
memcpy(&(ipv6_buf->destaddr.uint8[14]),
@ -1348,7 +1348,7 @@ void lowpan_iphc_decoding(uint8_t *data, uint8_t length,
break;
}
case(0x03): {
case (0x03): {
memcpy(&(ipv6_buf->destaddr.uint8[0]), &ll_prefix, 2);
memset(&(ipv6_buf->destaddr.uint8[2]), 0, 14);
memcpy(&(ipv6_buf->destaddr.uint8[8]), &d_laddr->uint8[0], 8);
@ -1383,8 +1383,8 @@ void lowpan_context_remove(uint8_t num)
{
int i, j;
for(i = 0; i < LOWPAN_CONTEXT_MAX; i++) {
if(contexts[i].num == num) {
for (i = 0; i < LOWPAN_CONTEXT_MAX; i++) {
if (contexts[i].num == num) {
context_len--;
break;
}
@ -1392,7 +1392,7 @@ void lowpan_context_remove(uint8_t num)
abr_remove_context(num);
for(j = i; j < LOWPAN_CONTEXT_MAX; j++) {
for (j = i; j < LOWPAN_CONTEXT_MAX; j++) {
contexts[j] = contexts[j + 1];
}
}
@ -1403,18 +1403,18 @@ lowpan_context_t *lowpan_context_update(uint8_t num, const ipv6_addr_t *prefix,
{
lowpan_context_t *context;
if(lifetime == 0) {
if (lifetime == 0) {
lowpan_context_remove(num);
return NULL;
}
if(context_len == LOWPAN_CONTEXT_MAX) {
if (context_len == LOWPAN_CONTEXT_MAX) {
return NULL;
}
context = lowpan_context_num_lookup(num);
if(context == NULL) {
if (context == NULL) {
context = &(contexts[context_len++]);
}
@ -1439,11 +1439,11 @@ lowpan_context_t *lowpan_context_lookup(ipv6_addr_t *addr)
lowpan_context_t *context = NULL;
for(i = 0; i < lowpan_context_len(); i++) {
if(contexts[i].length > 0 && memcmp((void *)addr, &(contexts[i].prefix),
for (i = 0; i < lowpan_context_len(); i++) {
if (contexts[i].length > 0 && memcmp((void *)addr, &(contexts[i].prefix),
contexts[i].length) == 0) {
/* longer prefixes are always prefered */
if(context == NULL || context->length < contexts[i].length) {
if (context == NULL || context->length < contexts[i].length) {
context = &contexts[i];
}
}
@ -1456,8 +1456,8 @@ lowpan_context_t *lowpan_context_num_lookup(uint8_t num)
{
int i;
for(i = 0; i < lowpan_context_len(); i++) {
if(contexts[i].num == num) {
for (i = 0; i < lowpan_context_len(); i++) {
if (contexts[i].num == num) {
return &contexts[i];
}
}
@ -1472,18 +1472,18 @@ void lowpan_context_auto_remove(void)
int8_t to_remove[LOWPAN_CONTEXT_MAX];
int8_t to_remove_size;
while(1) {
while (1) {
vtimer_sleep(minute);
to_remove_size = 0;
mutex_lock(&lowpan_context_mutex);
for(i = 0; i < lowpan_context_len(); i++) {
if(--(contexts[i].lifetime) == 0) {
for (i = 0; i < lowpan_context_len(); i++) {
if (--(contexts[i].lifetime) == 0) {
to_remove[to_remove_size++] = contexts[i].num;
}
}
for(i = 0; i < to_remove_size; i++) {
for (i = 0; i < to_remove_size; i++) {
lowpan_context_remove(to_remove[i]);
}
@ -1542,7 +1542,7 @@ void sixlowpan_init(transceiver_type_t trans, uint8_t r_addr, int as_border)
ipv6_iface_add_addr(&lladdr, ADDR_STATE_PREFERRED, 0, 0,
ADDR_CONFIGURED_AUTO);
if(as_border) {
if (as_border) {
ip_process_pid = thread_create(ip_process_buf, IP_PROCESS_STACKSIZE,
PRIORITY_MAIN - 1, CREATE_STACKTEST,
border_process_lowpan,

6
sys/ping/ping.c
View File

@ -35,7 +35,7 @@ void pong(uint16_t src)
int trans_ok = cc1100_send_csmaca(src, protocol_id, 2, pipa->payload,
sizeof(pipa->payload));
if(trans_ok < 0) {
if (trans_ok < 0) {
print_failed();
}
}
@ -56,12 +56,12 @@ void ping(radio_address_t addr, uint8_t channr)
cc1100_set_channel(channr);
cc1100_set_address(r_address);
while(1) {
while (1) {
vtimer_now(&start);
int trans_ok = cc1100_send_csmaca(addr,
protocol_id, 2, pipa->payload, sizeof(pipa->payload));
if(trans_ok < 0) {
if (trans_ok < 0) {
print_failed();
}

4
sys/ps/ps.c
View File

@ -45,10 +45,10 @@ void thread_print_all(void)
printf("\tpid | %-21s| %-9sQ | pri | stack ( used) location | runtime | switches \n", "name", "state");
for(i = 0; i < MAXTHREADS; i++) {
for (i = 0; i < MAXTHREADS; i++) {
tcb_t *p = (tcb_t *)sched_threads[i];
if(p != NULL) {
if (p != NULL) {
int state = p->status; // copy state
int statebit = number_of_highest_bit(state >> 1); // get state index
const char *sname = state_names[statebit]; // get state name

16
sys/shell/commands/sc_cc1100.c
View File

@ -40,7 +40,7 @@ void _cc1100_get_set_address_handler(char *addr)
mesg.content.ptr = (char *) &tcmd;
a = atoi(addr + 5);
if(strlen(addr) > 5) {
if (strlen(addr) > 5) {
printf("[cc110x] Trying to set address %i\n", a);
mesg.type = SET_ADDRESS;
}
@ -61,7 +61,7 @@ void _cc1100_get_set_channel_handler(char *chan)
mesg.content.ptr = (char *) &tcmd;
c = atoi(chan + 5);
if(strlen(chan) > 5) {
if (strlen(chan) > 5) {
printf("[cc110x] Trying to set channel %i\n", c);
mesg.type = SET_CHANNEL;
}
@ -85,11 +85,11 @@ void _cc1100_send_handler(char *pkt)
tok = strtok(pkt + 7, " ");
if(tok) {
if (tok) {
addr = atoi(tok);
tok = strtok(NULL, " ");
if(tok) {
if (tok) {
memset(text_msg, 0, TEXT_SIZE);
memcpy(text_msg, tok, strlen(tok));
/* if (sscanf(pkt, "txtsnd %hu %s", &(addr), text_msg) == 2) {*/
@ -116,11 +116,11 @@ void _cc110x_get_set_address_handler(char *addr)
a = atoi(addr + 5);
if(strlen(addr) > 5) {
if (strlen(addr) > 5) {
printf("[cc110x] Setting address %i ... ", a);
cc1100_set_address((radio_address_t)a);
if(cc1100_get_address() == (radio_address_t)a) {
if (cc1100_get_address() == (radio_address_t)a) {
puts("[OK]");
}
else {
@ -138,11 +138,11 @@ void _cc110x_get_set_channel_handler(char *addr)
a = atoi(addr + 5);
if(strlen(addr) > 5) {
if (strlen(addr) > 5) {
printf("[cc110x] Setting channel %i...", a);
cc1100_set_channel(a);
if(cc1100_get_channel() == a) {
if (cc1100_get_channel() == a) {
puts("OK");
}
else {

Some files were not shown because too many files have changed in this diff Show More