static void mock_join(struct remote_mock* rm) {
int fd;
char buffer[1024];
join_msg* msg = (join_msg*)buffer;
msg->type = NODE_JOIN;
//msg->node_id = my_id;
msg->node_type = REGULAR_NODE;
msg->port = my_port;
strcpy(msg->address, my_address);
fd = udp_socket_connect("127.0.0.1", 8888);
send(fd, buffer, sizeof(join_msg), 0);
close(fd);
}
int udp_socket_channel_init( comm_channel_t *channel, socket_type_t type, char *addr, int port )
{
udp_connection_t *uc = udp_get_connection( channel );
if( !uc )
{
return( -1 );
}
if (type == SOCK_UDP_CLIENT)
return udp_socket_connect( uc, addr, port );
return udp_socket_init( uc, port );
}
int conn_udp_sendto(const void *data, size_t len, const void *src, size_t src_len,
const void *dst, size_t dst_len, int family, uint16_t sport,
uint16_t dport)
{
int res;
_send_cmd_t send_cmd;
if (!send_registered) {
if (evproc_regCallback(EVENT_TYPE_CONN_SEND, _output_callback) != E_SUCCESS) {
return -EIO;
}
else {
send_registered = true;
}
}
mutex_init(&send_cmd.mutex);
if ((len > (UIP_BUFSIZE - (UIP_LLH_LEN + UIP_IPUDPH_LEN))) ||
(len > UINT16_MAX)) {
return -EMSGSIZE;
}
if ((dst_len > sizeof(ipv6_addr_t)) || (family != AF_INET6)) {
return -EAFNOSUPPORT;
}
mutex_lock(&send_cmd.mutex);
send_cmd.data = data;
send_cmd.data_len = (uint16_t)len;
if ((res = _reg_and_bind(&send_cmd.sock, NULL, NULL, sport)) < 0) {
mutex_unlock(&send_cmd.mutex);
return res;
}
udp_socket_connect(&send_cmd.sock, (uip_ipaddr_t *)dst, dport); /* can't fail at this point */
/* change to emb6 thread context */
if (evproc_putEvent(E_EVPROC_TAIL, EVENT_TYPE_CONN_SEND, &send_cmd) != E_SUCCESS) {
udp_socket_close(&send_cmd.sock);
mutex_unlock(&send_cmd.mutex);
return -EIO;
}
/* block thread until data was send */
mutex_lock(&send_cmd.mutex);
udp_socket_close(&send_cmd.sock);
mutex_unlock(&send_cmd.mutex);
return send_cmd.res;
}
val* mock_recover_key(struct remote_mock* rm, key* k) {
int port = 12345;
unsigned int h = joat_hash(k->data, k->size);
rec_key_msg_for_key(k, rm->buffer, &rm->buffer_size);
rm->recv_sock = udp_bind_fd(my_port);
socket_make_reusable(rm->recv_sock);
socket_make_non_block(rm->recv_sock);
if (h % 2 != 0)
port = 12346;
rm->send_sock = udp_socket_connect("127.0.0.1", port);
send(rm->send_sock, rm->buffer, rm->buffer_size, 0);
rm->ev_read = event_new(rm->base, rm->recv_sock, EV_READ, handle_rec_key, rm);
event_add(rm->ev_read, NULL);
event_base_dispatch(rm->base);
close(rm->recv_sock);
close(rm->send_sock);
return rm->v;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(multicast_example_process, ev, data)
{
PROCESS_BEGIN();
/* Create a linkl-local multicast addresses. */
uip_ip6addr(&addr, 0xff02, 0, 0, 0, 0, 0, 0x1337, 0x0001);
/* Join local group. */
if(uip_ds6_maddr_add(&addr) == NULL) {
printf("Error: could not join local multicast group.\n");
}
/* Register UDP socket callback */
udp_socket_register(&s, NULL, receiver);
/* Bind UDP socket to local port */
udp_socket_bind(&s, PORT);
/* Connect UDP socket to remote port */
udp_socket_connect(&s, NULL, PORT);
while(1) {
/* Set up two timers, one for keeping track of the send interval,
which is periodic, and one for setting up a randomized send time
within that interval. */
etimer_set(&periodic_timer, SEND_INTERVAL);
etimer_set(&send_timer, (random_rand() % SEND_INTERVAL));
PROCESS_WAIT_UNTIL(etimer_expired(&send_timer));
printf("Sending multicast\n");
udp_socket_sendto(&s,
"hello", 6,
&addr, PORT);
PROCESS_WAIT_UNTIL(etimer_expired(&periodic_timer));
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
int
propple_socket_open(struct propple_socket *s,
void *ptr,
propple_socket_input_callback_t callback,
uint16_t port,
clock_time_t interval,
clock_time_t interval_max,
uint8_t duptheshold)
{
s->ptr = ptr;
s->callback = callback;
s->interval = interval;
s->interval_max = interval_max;
s->duptheshold = duptheshold;
s->port = port;
s->duplicates = 0;
s->interval_scaling = 0;
/* Register UDP socket callback */
if(udp_socket_register(&s->s, s, recv) == 0) {
printf("propple_socket_open: udp_socket_register failed\n");
return 0;
}
/* Bind UDP socket to local port */
if(udp_socket_bind(&s->s, port) == 0) {
printf("propple_socket_open: udp_socket_bind failed\n");
return 0;
}
/* Connect UDP socket to remote port */
if(udp_socket_connect(&s->s, NULL, port) == 0) {
printf("propple_socket_open: udp_socket_connect failed\n");
return 0;
}
return 1;
}
static int _reg(struct udp_socket *c, void *ptr, udp_socket_input_callback_t cb,
const sock_udp_ep_t *local, const sock_udp_ep_t *remote)
{
if (((local != NULL) && (local->family != AF_INET6)) ||
((remote != NULL) && (remote->family != AF_INET6))) {
return -EAFNOSUPPORT;
}
if (udp_socket_register(c, ptr, cb) < 0) {
return -ENOMEM;
}
if (local != NULL) {
if (udp_socket_bind(c, local->port) < 0) {
udp_socket_close(c);
return -EADDRINUSE;
}
}
if (remote != NULL) {
/* check of return value not necessary, since neither c nor
* c->udp_conn is NULL (only error case) at this point */
udp_socket_connect(c, (uip_ipaddr_t *)&remote->addr, remote->port);
}
return 0;
}
