Beispiel #1
0
/* UDP send command */
void udp_send(int argc, char **argv)
{
    int sock;
    sockaddr6_t sa;
    ipv6_addr_t ipaddr;
    int bytes_sent;
    int address;
    char text[5];

    if (argc != 3) {
        printf("usage: send <addr> <text>\n");
        return;
    }

    address = atoi(argv[1]);

    strncpy(text, argv[2], sizeof(text));
    text[sizeof(text) - 1] = 0;

    sock = socket_base_socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);

    if (-1 == sock) {
        printf("Error Creating Socket!");
        return;
    }

    memset(&sa, 0, sizeof(sa));

    if (address) {
        ipv6_addr_init(&ipaddr, 0xabcd, 0x0, 0x0, 0x0, 0x0, 0x00ff, 0xfe00, (uint16_t)address);
    }
    else {
        ipv6_addr_set_all_nodes_addr(&ipaddr);
    }

    sa.sin6_family = AF_INET;
    memcpy(&sa.sin6_addr, &ipaddr, 16);
    sa.sin6_port = HTONS(SERVER_PORT);

    bytes_sent = socket_base_sendto(sock, (char *)text,
                                       strlen(text) + 1, 0, &sa,
                                       sizeof(sa));

    if (bytes_sent < 0) {
        printf("Error sending packet!\n");
    }
    else {
        printf("Successful deliverd %i bytes over UDP to %s to 6LoWPAN\n",
               bytes_sent, ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
                                            &ipaddr));
    }

    socket_base_close(sock);
}
Beispiel #2
0
void trickle_timer_over(void)
{
    ipv6_addr_t mcast;
    ipv6_addr_set_all_nodes_addr(&mcast);

    while (1) {
        thread_sleep();

        /* Handle k=0 like k=infinity (according to RFC6206, section 6.5) */
        if ((c < k) || (k == 0)) {
            send_DIO(&mcast);
        }
    }
}
Beispiel #3
0
kernel_pid_t nhdp_start(void)
{
    if (nhdp_pid == KERNEL_PID_UNDEF) {
        /* Init destination address for NHDP's packets */
        sa_bcast.sin6_family = AF_INET6;
        sa_bcast.sin6_port = HTONS(MANET_PORT);
        ipv6_addr_set_all_nodes_addr(&sa_bcast.sin6_addr);

        /* Configure sending/receiving UDP socket */
        sock_rcv = socket_base_socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);

        /* Start the NHDP thread */
        nhdp_pid = thread_create(nhdp_stack, sizeof(nhdp_stack), THREAD_PRIORITY_MAIN - 1,
                                 CREATE_STACKTEST, _nhdp_runner, NULL, "NHDP");
    }

    return nhdp_pid;
}
Beispiel #4
0
void demultiplex(border_packet_t *packet)
{
    switch (packet->type) {
        case (BORDER_PACKET_RAW_TYPE): {
            fputs(((char *)packet) + sizeof(border_packet_t), stdin);
            break;
        }

        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): {
                    ipv6_hdr_t *ipv6_buf = (ipv6_hdr_t *)(((unsigned char *)packet) + sizeof(border_l3_header_t));
                    ipv6_send_packet(ipv6_buf);
                    break;
                }

                default:
                    printf("ERROR: Unknown ethertype 0x%04x\n", l3_header_buf->ethertype);
                    break;
            }

            break;
        }

        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): {
                    border_context_packet_t *context = (border_context_packet_t *)packet;
                    ipv6_addr_t target_addr;
                    ipv6_addr_set_all_nodes_addr(&target_addr);
                    mutex_lock(&lowpan_context_mutex);
                    lowpan_context_update(
                        context->context.cid,
                        &context->context.prefix,
                        context->context.length,
                        context->context.comp,
                        context->context.lifetime
                    );
                    mutex_unlock(&lowpan_context_mutex);
                    abr_add_context(context->context.version, abr_addr, context->context.cid);
                    /* Send router advertisement */
                    break;
                }

                case (BORDER_CONF_IPADDR): {
                    //border_addr_packet_t *addr_packet = (border_addr_packet_t *)packet;
                    /* add address */
                    break;
                }

                default:
                    printf("ERROR: Unknown conftype %02x\n", conf_header_buf->conftype);
                    break;
            }

            break;
        }

        default:
            printf("ERROR: Unknown border packet type %02x\n", packet->type);
            break;
    }
}