int destiny_socket_accept(int s, sockaddr6_t *addr, uint32_t *addrlen)
{
socket_internal_t *server_socket = get_socket(s);
if (is_tcp_socket(s) && (server_socket->socket_values.tcp_control.state == LISTEN)) {
socket_internal_t *current_queued_socket =
get_waiting_connection_socket(s, NULL, NULL);
if (current_queued_socket != NULL) {
return handle_new_tcp_connection(current_queued_socket,
server_socket, thread_getpid());
}
else {
/* No waiting connections, waiting for message from TCP Layer */
msg_t msg_recv_client_syn;
msg_recv_client_syn.type = UNDEFINED;
while (msg_recv_client_syn.type != TCP_SYN) {
msg_receive(&msg_recv_client_syn);
}
current_queued_socket = get_waiting_connection_socket(s, NULL, NULL);
return handle_new_tcp_connection(current_queued_socket,
server_socket, thread_getpid());
}
}
else {
return -1;
}
}
static void run_client(int max_cnt)
{
printf("client (pid=%" PRIkernel_pid "): start\n", thread_getpid());
handle = ndn_app_create();
if (handle == NULL) {
printf("client (pid=%" PRIkernel_pid "): cannot create app handle\n",
thread_getpid());
return;
}
max_count = max_cnt;
count = 0;
begin = xtimer_now_usec();
if (send_interest() == NDN_APP_ERROR) {
printf("client (pid=%" PRIkernel_pid "): cannot send interest"
" (%"PRIu32")\n", handle->id, count);
ndn_app_destroy(handle);
return;
}
ndn_app_run(handle);
ndn_app_destroy(handle);
}
static int pthread_rwlock_lock(pthread_rwlock_t *rwlock,
bool (*is_blocked)(const pthread_rwlock_t *rwlock),
bool is_writer,
int incr_when_held,
bool allow_spurious)
{
if (rwlock == NULL) {
DEBUG("Thread %" PRIkernel_pid": pthread_rwlock_%s(): is_writer=%u, allow_spurious=%u %s\n",
thread_getpid(), "lock", is_writer, allow_spurious, "rwlock=NULL");
return EINVAL;
}
mutex_lock(&rwlock->mutex);
if (!is_blocked(rwlock)) {
DEBUG("Thread %" PRIkernel_pid ": pthread_rwlock_%s(): is_writer=%u, allow_spurious=%u %s\n",
thread_getpid(), "lock", is_writer, allow_spurious, "is open");
rwlock->readers += incr_when_held;
}
else {
DEBUG("Thread %" PRIkernel_pid ": pthread_rwlock_%s(): is_writer=%u, allow_spurious=%u %s\n",
thread_getpid(), "lock", is_writer, allow_spurious, "is locked");
/* queue for the lock */
__pthread_rwlock_waiter_node_t waiting_node = {
.is_writer = is_writer,
.thread = (thread_t *) sched_active_thread,
.qnode = {
.next = NULL,
.data = (uintptr_t) &waiting_node,
.priority = sched_active_thread->priority,
},
.continue_ = false,
};
priority_queue_add(&rwlock->queue, &waiting_node.qnode);
while (1) {
/* wait to be unlocked, so this thread can try to acquire the lock again */
mutex_unlock_and_sleep(&rwlock->mutex);
mutex_lock(&rwlock->mutex);
if (waiting_node.continue_) {
/* pthread_rwlock_unlock() already set rwlock->readers */
DEBUG("Thread %" PRIkernel_pid ": pthread_rwlock_%s(): is_writer=%u, allow_spurious=%u %s\n",
thread_getpid(), "lock", is_writer, allow_spurious, "continued");
break;
}
else if (allow_spurious) {
DEBUG("Thread %" PRIkernel_pid ": pthread_rwlock_%s(): is_writer=%u, allow_spurious=%u %s\n",
thread_getpid(), "lock", is_writer, allow_spurious, "is timed out");
priority_queue_remove(&rwlock->queue, &waiting_node.qnode);
mutex_unlock(&rwlock->mutex);
return ETIMEDOUT;
}
}
}
mutex_unlock(&rwlock->mutex);
return 0;
}
void icn_initInterest(uint16_t seq) {
if (WANT_CONTENT) {
uint32_t tmp1;
uint16_t tmp2;
tmp1 = _getSmallestMissing();
LOG_DEBUG("Smallest missing is %lu\n", tmp1);
tmp2 = seq;
if ((tmp1 < NUMBER_OF_CHUNKS) && (tmp1 >= 0)) {
LOG_INFO("Scheduling retransmission for %lu\n", tmp1);
vtimer_remove(&retry_vt);
vtimer_set_msg(&retry_vt, retry_interval, thread_getpid(), ICN_RESEND_INTEREST, &tmp1);
}
if (bf_isset(received_chunks, seq)) {
LOG_INFO("Already received a chunk for %u, not sending again\n", seq);
return;
}
#if FLOW_CONTROL
if (seq > (receive_counter + FLOW_THR)) {
LOG_INFO("Flow control, seq is %u, receive counter is %u\n",
seq, receive_counter);
return;
}
#endif
/* create packet */
ng_pktsnip_t *pkt;
icn_pkt_t icn_pkt;
icn_pkt.type = ICN_INTEREST;
icn_pkt.seq = seq;
memcpy(icn_pkt.payload, interest, strlen(interest) + 1);
pkt = ng_pktbuf_add(NULL, &icn_pkt, sizeof(icn_pkt_t), NG_NETTYPE_UNDEF);
// send interest packet
if (tmp2 < NUMBER_OF_CHUNKS) {
LOG_INFO("Sending Interest for %u to %s\n", seq,
ng_netif_addr_to_str(l2addr_str, sizeof(l2addr_str),
CONTENT_STORE->uint8, ADDR_LEN_64B));
icn_send(CONTENT_STORE, pkt);
}
if (tmp2 < NUMBER_OF_CHUNKS) {
tmp2++;
#if TIMED_SENDING
vtimer_remove(&periodic_vt);
vtimer_set_msg(&periodic_vt, interval, thread_getpid(), ICN_SEND_INTEREST, &tmp2);
#else
icn_initInterest(tmp2);
#endif
}
}
else {
LOG_DEBUG("nothing to do\n");
}
}
/**
* Function executed by NHDP thread receiving messages in an endless loop
*/
static void *_nhdp_runner(void *arg)
{
nhdp_if_entry_t *if_entry;
msg_t msg_rcvd, msg_queue[NHDP_MSG_QUEUE_SIZE];
(void)arg;
msg_init_queue(msg_queue, NHDP_MSG_QUEUE_SIZE);
while (1) {
msg_receive(&msg_rcvd);
switch (msg_rcvd.type) {
case HELLO_TIMER:
mutex_lock(&send_rcv_mutex);
if_entry = msg_rcvd.content.ptr;
nhdp_writer_send_hello(if_entry);
/* TODO: Add jitter */
/* Schedule next sending */
xtimer_set_msg64(&if_entry->if_timer,
timex_uint64(if_entry->hello_interval),
&msg_rcvd, thread_getpid());
mutex_unlock(&send_rcv_mutex);
break;
#if (NHDP_METRIC_NEEDS_TIMER)
case NHDP_METRIC_TIMER:
mutex_lock(&send_rcv_mutex);
/* Process necessary metric computations */
iib_process_metric_refresh();
/* Schedule next sending */
metric_msg.type = NHDP_METRIC_TIMER;
metric_msg.content.ptr = NULL;
xtimer_set_msg64(&metric_timer, timex_uint64(metric_interval),
metric_msg, thread_getpid());
mutex_unlock(&send_rcv_mutex);
break;
#endif
default:
break;
}
}
return 0;
}
gnrc_nettest_res_t gnrc_nettest_send_iface(kernel_pid_t pid, gnrc_pktsnip_t *in,
unsigned int exp_pkts,
const kernel_pid_t *exp_senders,
const gnrc_pktsnip_t **exp_out)
{
gnrc_nettest_res_t res;
gnrc_netif_add(thread_getpid());
res = _pkt_test(GNRC_NETAPI_MSG_TYPE_SND, pid, in, exp_pkts, exp_senders,
exp_out);
gnrc_netif_remove(thread_getpid());
return res;
}
uint8_t semtech_loramac_send(semtech_loramac_t *mac, uint8_t *data, uint8_t len)
{
mac->link_chk.available = false;
if (!_is_mac_joined(mac)) {
DEBUG("[semtech-loramac] network is not joined\n");
return SEMTECH_LORAMAC_NOT_JOINED;
}
/* Correctly set the caller pid */
mac->caller_pid = thread_getpid();
loramac_send_params_t params;
params.payload = data;
params.len = len;
_semtech_loramac_call(_send, ¶ms);
/* Wait for TX status information from the MAC */
msg_t msg;
msg_receive(&msg);
if (msg.type != MSG_TYPE_LORAMAC_TX_STATUS) {
return SEMTECH_LORAMAC_TX_ERROR;
}
return (uint8_t)msg.content.value;
}
int32_t destiny_socket_recvfrom(int s, void *buf, uint32_t len, int flags,
sockaddr6_t *from, uint32_t *fromlen)
{
if (isUDPSocket(s)) {
msg_t m_recv, m_send;
ipv6_hdr_t *ipv6_header;
udp_hdr_t *udp_header;
uint8_t *payload;
get_socket(s)->recv_pid = thread_getpid();
msg_receive(&m_recv);
ipv6_header = ((ipv6_hdr_t *)m_recv.content.ptr);
udp_header = ((udp_hdr_t *)(m_recv.content.ptr + IPV6_HDR_LEN));
payload = (uint8_t *)(m_recv.content.ptr + IPV6_HDR_LEN + UDP_HDR_LEN);
memset(buf, 0, len);
memcpy(buf, payload, udp_header->length - UDP_HDR_LEN);
memcpy(&from->sin6_addr, &ipv6_header->srcaddr, 16);
from->sin6_family = AF_INET6;
from->sin6_flowinfo = 0;
from->sin6_port = udp_header->src_port;
*fromlen = sizeof(sockaddr6_t);
msg_reply(&m_recv, &m_send);
return udp_header->length - UDP_HDR_LEN;
}
else if (is_tcp_socket(s)) {
return destiny_socket_recv(s, buf, len, flags);
}
else {
printf("Socket Type not supported!\n");
return -1;
}
}
int vtimer_sleep(timex_t time) {
int ret;
vtimer_t t;
ret = vtimer_set_wakeup(&t, time, thread_getpid());
thread_sleep();
return ret;
}
void *beaconing(void *arg)
{
(void) arg;
xtimer_t status_timer;
msg_t msg;
msg_t update_msg;
kernel_pid_t mypid = thread_getpid();
/* initialize message queue */
msg_init_queue(_beac_msg_q, Q_SZ);
/* start periodic timer */
update_msg.type = MSG_UPDATE_EVENT;
xtimer_set_msg(&status_timer, UPDATE_INTERVAL, &update_msg, mypid);
while(1) {
msg_receive(&msg);
switch (msg.type) {
case MSG_UPDATE_EVENT:
xtimer_set_msg(&status_timer, UPDATE_INTERVAL, &update_msg, mypid);
send_update(initial_pos, p_buf);
break;
default:
break;
}
}
/* never reached */
return NULL;
}
int main(void)
{
uint32_t count = 0;
indicator = 0;
main_pid = thread_getpid();
kernel_pid_t second_pid = thread_create(stack,
sizeof(stack),
THREAD_PRIORITY_MAIN - 1,
THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
second_thread,
NULL,
"second_thread");
while (1) {
mutex_lock(&mutex);
thread_wakeup(second_pid);
indicator++;
count++;
if ((indicator > 1) || (indicator < -1)) {
printf("[ERROR] threads did not sleep properly (%d).\n", indicator);
return 1;
}
if ((count % 100000) == 0) {
printf("[ALIVE] alternated %"PRIu32"k times.\n", (count / 1000));
}
mutex_unlock_and_sleep(&mutex);
}
}
int32_t udp_recvfrom(int s, void *buf, uint32_t len, int flags, sockaddr6_t *from, uint32_t *fromlen)
{
(void) flags;
msg_t m_recv, m_send;
ipv6_hdr_t *ipv6_header;
udp_hdr_t *udp_header;
uint8_t *payload;
socket_base_get_socket(s)->recv_pid = thread_getpid();
msg_receive(&m_recv);
ipv6_header = ((ipv6_hdr_t *)m_recv.content.ptr);
udp_header = ((udp_hdr_t *)(m_recv.content.ptr + IPV6_HDR_LEN));
payload = (uint8_t *)(m_recv.content.ptr + IPV6_HDR_LEN + UDP_HDR_LEN);
memset(buf, 0, len);
/* cppcheck: the memset sets parts of the buffer to 0 even though it will
* be overwritten by the next memcpy. However without the memset the buffer
* could contain stale data (if the copied data is less then the buffer
* length) and setting just the left over part of the buffer to 0 would
* introduce overhead (calculation how much needs to be zeroed).
*/
/* cppcheck-suppress redundantCopy */
memcpy(buf, payload, NTOHS(udp_header->length) - UDP_HDR_LEN);
memcpy(&from->sin6_addr, &ipv6_header->srcaddr, 16);
from->sin6_family = AF_INET6;
from->sin6_flowinfo = 0;
from->sin6_port = udp_header->src_port;
*fromlen = sizeof(sockaddr6_t);
msg_reply(&m_recv, &m_send);
return NTOHS(udp_header->length) - UDP_HDR_LEN;
}
int msg_send_int(msg_t *m, unsigned int target_pid)
{
tcb_t *target = (tcb_t *) sched_threads[target_pid];
if (target == NULL) {
DEBUG("msg_send_int(): target thread does not exist\n");
return -1;
}
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;
/* copy msg to target */
msg_t *target_message = (msg_t*) target->wait_data;
*target_message = *m;
sched_set_status(target, STATUS_PENDING);
sched_context_switch_request = 1;
return 1;
}
else {
DEBUG("msg_send_int: Receiver not waiting.\n");
return (queue_msg(target, m));
}
}
/**
* Function executed by NHDP thread receiving messages in an endless loop
*/
static void *_nhdp_runner(void *arg)
{
nhdp_if_entry_t *if_entry;
msg_t msg_rcvd, msg_queue[NHDP_MSG_QUEUE_SIZE];
(void)arg;
msg_init_queue(msg_queue, NHDP_MSG_QUEUE_SIZE);
while (1) {
msg_receive(&msg_rcvd);
switch (msg_rcvd.type) {
case MSG_TIMER:
mutex_lock(&send_rcv_mutex);
if_entry = (nhdp_if_entry_t *) msg_rcvd.content.ptr;
nhdp_writer_send_hello(if_entry);
/* TODO: Add jitter */
/* Schedule next sending */
vtimer_set_msg(&if_entry->if_timer, if_entry->hello_interval,
thread_getpid(), MSG_TIMER, (void *) if_entry);
mutex_unlock(&send_rcv_mutex);
break;
default:
break;
}
}
return 0;
}
int msg_send_int(msg_t *m, kernel_pid_t target_pid)
{
#ifdef DEVELHELP
if (!pid_is_valid(target_pid)) {
DEBUG("msg_send(): target_pid is invalid, continuing anyways\n");
}
#endif /* DEVELHELP */
thread_t *target = (thread_t *) sched_threads[target_pid];
if (target == NULL) {
DEBUG("msg_send_int(): target thread does not exist\n");
return -1;
}
m->sender_pid = KERNEL_PID_ISR;
if (target->status == STATUS_RECEIVE_BLOCKED) {
DEBUG("msg_send_int: Direct msg copy from %" PRIkernel_pid " to %"
PRIkernel_pid ".\n", thread_getpid(), target_pid);
/* copy msg to target */
msg_t *target_message = (msg_t*) target->wait_data;
*target_message = *m;
sched_set_status(target, STATUS_PENDING);
sched_context_switch_request = 1;
return 1;
}
else {
DEBUG("msg_send_int: Receiver not waiting.\n");
return (queue_msg(target, m));
}
}
int main(void)
{
indicator = 0;
count = 0;
main_pid = thread_getpid();
kernel_pid_t second_pid = thread_create(stack,
sizeof(stack),
THREAD_PRIORITY_MAIN - 1,
THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
second_thread,
NULL,
"second_thread");
while (1) {
mutex_lock(&mutex);
thread_wakeup(second_pid);
indicator++;
count++;
if (indicator > 1 || indicator < -1) {
printf("Error, threads did not sleep properly. [indicator: %d]\n", indicator);
return -1;
}
if ((count % 100000) == 0) {
printf("Still alive alternated [count: %dk] times.\n", count / 1000);
}
mutex_unlock_and_sleep(&mutex);
}
}
thread_flags_t thread_flags_clear(thread_flags_t mask)
{
thread_t *me = (thread_t*) sched_active_thread;
mask = _thread_flags_clear_atomic(me, mask);
DEBUG("thread_flags_clear(): pid %"PRIkernel_pid" clearing 0x%08x\n", thread_getpid(), mask);
return mask;
}
ng_nettest_res_t ng_nettest_send_iface(kernel_pid_t pid, ng_pktsnip_t *in,
unsigned int exp_pkts,
kernel_pid_t exp_senders[],
ng_pktsnip_t *exp_out[])
{
ng_nettest_res_t res;
ng_netif_add(thread_getpid());
res = _pkt_test(NG_NETAPI_MSG_TYPE_SND, pid, in, exp_pkts, exp_senders,
exp_out);
ng_netif_remove(thread_getpid());
return res;
}
int gnrc_tftp_server(tftp_data_cb_t data_cb, tftp_start_cb_t start_cb, tftp_stop_cb_t stop_cb, bool use_options)
{
/* check if there is only one TFTP server running */
if (_tftp_kernel_pid != KERNEL_PID_UNDEF) {
DEBUG("tftp: only one TFTP server allowed\n");
return -1;
}
/* context will be initialized when a connection is established */
tftp_context_t ctxt;
ctxt.data_cb = data_cb;
ctxt.start_cb = start_cb;
ctxt.stop_cb = stop_cb;
ctxt.enable_options = use_options;
/* validate our arguments */
assert(data_cb);
assert(start_cb);
assert(stop_cb);
/* save our kernel PID */
_tftp_kernel_pid = thread_getpid();
/* start the server */
int ret = _tftp_server(&ctxt);
/* remove possibly stale timer */
xtimer_remove(&(ctxt.timer));
/* reset the kernel PID */
_tftp_kernel_pid = KERNEL_PID_UNDEF;
return ret;
}
static void _rx_event(ng_netdev_eth_t *netdev)
{
dev_eth_t *dev = netdev->ethdev;
int nread = dev->driver->recv(dev, (char*)recv_buffer, ETHERNET_MAX_LEN);
DEBUG("ng_netdev_eth: read %d bytes\n", nread);
if (nread > 0) {
ethernet_hdr_t *hdr = (ethernet_hdr_t *)recv_buffer;
ng_pktsnip_t *netif_hdr, *pkt;
ng_nettype_t receive_type = NG_NETTYPE_UNDEF;
size_t data_len = (nread - sizeof(ethernet_hdr_t));
/* TODO: implement multicast groups? */
netif_hdr = ng_pktbuf_add(NULL, NULL,
sizeof(ng_netif_hdr_t) + (2 * ETHERNET_ADDR_LEN),
NG_NETTYPE_NETIF);
if (netif_hdr == NULL) {
DEBUG("ng_netdev_eth: no space left in packet buffer\n");
return;
}
ng_netif_hdr_init(netif_hdr->data, ETHERNET_ADDR_LEN, ETHERNET_ADDR_LEN);
ng_netif_hdr_set_src_addr(netif_hdr->data, hdr->src, ETHERNET_ADDR_LEN);
ng_netif_hdr_set_dst_addr(netif_hdr->data, hdr->dst, ETHERNET_ADDR_LEN);
((ng_netif_hdr_t *)netif_hdr->data)->if_pid = thread_getpid();
receive_type = ng_nettype_from_ethertype(byteorder_ntohs(hdr->type));
DEBUG("ng_netdev_eth: received packet from %02x:%02x:%02x:%02x:%02x:%02x "
"of length %zu\n",
hdr->src[0], hdr->src[1], hdr->src[2], hdr->src[3], hdr->src[4],
hdr->src[5], data_len);
#if defined(MODULE_OD) && ENABLE_DEBUG
od_hex_dump(hdr, nread, OD_WIDTH_DEFAULT);
#endif
/* Mark netif header and payload for next layer */
if ((pkt = ng_pktbuf_add(netif_hdr, recv_buffer + sizeof(ethernet_hdr_t),
data_len, receive_type)) == NULL) {
ng_pktbuf_release(netif_hdr);
DEBUG("ng_netdev_eth: no space left in packet buffer\n");
return;
}
if (netdev->event_cb != NULL) {
netdev->event_cb(NETDEV_EVENT_RX_COMPLETE, pkt);
}
else {
ng_pktbuf_release(pkt); /* netif_hdr is released automatically too */
}
}
else {
DEBUG("ng_netdev_eth: spurious _rx_event: %d\n", nread);
}
}
bool
sol_mainloop_impl_main_thread_check(void)
{
#ifdef THREADS
return thread_getpid() == _main_pid;
#else
return true;
#endif
}
int pir_register_thread(pir_t *dev)
{
if (dev->msg_thread_pid != KERNEL_PID_UNDEF) {
if (dev->msg_thread_pid != thread_getpid()) {
DEBUG("pir_register_thread: already registered to another thread\n");
return -2;
}
}
else {
DEBUG("pir_register_thread: activating interrupt for %p..\n", dev);
if (pir_activate_int(dev) != 0) {
DEBUG("\tfailed\n");
return -1;
}
DEBUG("\tsuccess\n");
}
dev->msg_thread_pid = thread_getpid();
return 0;
}
int main(void)
{
char *status = "I am written to the UART every 2 seconds\n";
char buf[128];
int res;
msg_t msg;
main_pid = thread_getpid();
printf("Main thread pid %i \n", main_pid);
printf("Testing interrupt driven mode of UART driver\n\n");
printf("Setting up buffers...\n");
ringbuffer_init(&rx_buf, rx_mem, 128);
ringbuffer_init(&tx_buf, tx_mem, 128);
printf("Initializing UART @ %i", BAUD);
if (uart_init(DEV, BAUD, rx, NULL, tx, NULL) >= 0) {
printf(" ...done\n");
}
else {
printf(" ...failed\n");
return 1;
}
ringbuffer_add(&tx_buf, status, strlen(status));
uart_tx_begin(DEV);
while (1) {
printf("Going into receive message state\n");
//msg_receive(&msg);
if (status) {
printf("INPUT: ");
res = ringbuffer_get(&rx_buf, buf, rx_buf.avail);
buf[res] = '\0';
printf("%s", buf);
status = 0;
}
/* printf("got message");
if (msg.type == MSG_LINE_RDY) {
printf("INPUT: ");
res = ringbuffer_get(&rx_buf, buf, rx_buf.avail);
buf[res] = '\0';
printf("%s", buf);
}
*/
}
return 0;
}
int
sol_mainloop_impl_platform_init(void)
{
#ifdef THREADS
mutex_init(&_lock);
_main_pid = thread_getpid();
#endif
sol_interrupt_scheduler_set_pid(sched_active_pid);
msg_init_queue(msg_buffer, MSG_BUFFER_SIZE);
return 0;
}
/* SLIP receive handler */
static void _slip_receive(ng_slip_dev_t *dev, size_t bytes)
{
ng_netif_hdr_t *hdr;
ng_netreg_entry_t *sendto;
ng_pktsnip_t *pkt, *netif_hdr;
pkt = ng_pktbuf_add(NULL, NULL, bytes, NG_NETTYPE_UNDEF);
if (pkt == NULL) {
DEBUG("slip: no space left in packet buffer\n");
return;
}
netif_hdr = ng_pktbuf_add(pkt, NULL, sizeof(ng_netif_hdr_t),
NG_NETTYPE_NETIF);
if (netif_hdr == NULL) {
DEBUG("slip: no space left in packet buffer\n");
ng_pktbuf_release(pkt);
return;
}
hdr = netif_hdr->data;
ng_netif_hdr_init(hdr, 0, 0);
hdr->if_pid = thread_getpid();
if (ringbuffer_get(dev->in_buf, pkt->data, bytes) != bytes) {
DEBUG("slip: could not read %zu bytes from ringbuffer\n", bytes);
ng_pktbuf_release(pkt);
return;
}
#ifdef MODULE_NG_IPV6
if ((pkt->size >= sizeof(ipv6_hdr_t)) && ipv6_hdr_is(pkt->data)) {
pkt->type = NG_NETTYPE_IPV6;
}
#endif
sendto = ng_netreg_lookup(pkt->type, NG_NETREG_DEMUX_CTX_ALL);
if (sendto == NULL) {
DEBUG("slip: unable to forward packet of type %i\n", pkt->type);
ng_pktbuf_release(pkt);
}
ng_pktbuf_hold(pkt, ng_netreg_num(pkt->type, NG_NETREG_DEMUX_CTX_ALL) - 1);
while (sendto != NULL) {
DEBUG("slip: sending pkt %p to PID %u\n", pkt, sendto->pid);
ng_netapi_receive(sendto->pid, pkt);
sendto = ng_netreg_getnext(sendto);
}
}
void tcp_general_timer(void)
{
vtimer_t tcp_vtimer;
timex_t interval = timex_set(0, TCP_TIMER_RESOLUTION);
while (1) {
inc_global_variables();
check_sockets();
vtimer_set_wakeup(&tcp_vtimer, interval, thread_getpid());
thread_sleep();
}
}
static void run_server(int sig_type, int sz)
{
printf("server (pid=%" PRIkernel_pid "): start\n", thread_getpid());
handle = ndn_app_create();
if (handle == NULL) {
printf("server (pid=%" PRIkernel_pid "): cannot create app handle\n",
thread_getpid());
return;
}
signature_type = sig_type;
content_size = sz;
ndn_shared_block_t* sp = ndn_name_from_uri(uri, strlen(uri));
if (sp == NULL) {
printf("server (pid=%" PRIkernel_pid "): cannot create name from uri "
"\"%s\"\n", handle->id, uri);
return;
}
printf("server (pid=%" PRIkernel_pid "): register prefix \"%s\"\n",
handle->id, uri);
// pass ownership of "sp" to the API
if (ndn_app_register_prefix(handle, sp, on_interest) != 0) {
printf("server (pid=%" PRIkernel_pid "): failed to register prefix\n",
handle->id);
ndn_app_destroy(handle);
return;
}
printf("server (pid=%" PRIkernel_pid "): enter app run loop\n",
handle->id);
ndn_app_run(handle);
printf("server (pid=%" PRIkernel_pid "): returned from app run loop\n",
handle->id);
ndn_app_destroy(handle);
}
int main(void)
{
memset(apps, '\0', sizeof(apps));
apps[0] = clock_app_init();
apps[1] = alarm_app_init();
gpioint_set(2, BUTTON_STAR_PIN, (GPIOINT_RISING_EDGE | GPIOINT_DEBOUNCE), button_star);
button_thread = thread_getpid();
int active_app = 0;
msg_t m;
//buzzer_beep(15, 5000);
printf("ukleos\n");
m.type = MSG_ACTIVATE;
msg_send(&m, apps[active_app], true);
while(1) {
msg_receive(&m);
switch (m.type) {
case MSG_BUTTON_STAR: {
m.type = MSG_DEACTIVATE;
msg_send(&m, apps[active_app], true);
active_app++;
if (active_app == (NUM_APPS)) active_app = 0;
m.type = MSG_ACTIVATE;
msg_send(&m, apps[active_app], true);
// buzzer_beep(15, 5000);
break;
}
case MSG_BUTTON_HASH:
{
m.type = MSG_BUTTON_HASH;
msg_send(&m, apps[active_app], true);
break;
}
default:
{
printf("msg\n");
}
}
}
}
void sub_thread(void)
{
int pid = thread_getpid();
printf("THREAD %s (pid:%i) start\n", thread_getname(pid), pid);
msg_t msg;
msg.content.ptr = (char*)thread_getname(pid);
msg_send(&msg, 1, 1);
printf("THREAD %s (pid:%i) end.\n", thread_getname(pid), pid);
}
int main(void)
{
printf("CCN!\n");
_relay_pid = thread_getpid();
thread_create(t2_stack, sizeof(t2_stack), PRIORITY_MAIN + 1,
CREATE_STACKTEST, second_thread, NULL, "helper thread");
printf("starting ccn-lite relay...\n");
ccnl_riot_relay_start(NULL);
return 0;
}
