Exemplo n.º 1
0
static struct tcp_pcb *connect(struct ip_addr *ip, int port)
{
    //    debug_printf("connect()\n");

    err_t err;
    struct tcp_pcb *pcb;

    pcb = tcp_new();
    if (pcb == NULL) {
        fprintf(stderr, "failed to create new pcb\n");
        assert(pcb != NULL);
        return NULL;
    }

    //    debug_printf("pcb created\n");

    //    debug_printf("connecting to server\n");
    wait_cond = true;
    err = tcp_connect(pcb, ip, port, tcp_is_connected);
    wait_for_condition();

    // TODO: proper error handling
    if (err != ERR_OK) {
        fprintf(stderr, "error connecting %d\n", err);
        return NULL;
    }

    return pcb;
}
Exemplo n.º 2
0
BleStatus ble_client_init(ble_client_gap_event_cb_t gap_event_cb, void *gap_event_param,
                          ble_client_gatts_event_cb_t gatts_event_cb, void *gatts_event_param)
{
    BleStatus status;
    uint32_t delay_until;

    cfw_platform_nordic_init();

    client_handle = cfw_init(cfw_get_service_queue(),
                             ble_core_client_handle_message,
                             NULL);

    sync.response = 0;
    if (cfw_register_svc_available(client_handle,
                                   BLE_CORE_SERVICE_ID,
                                   NULL))
        return BLE_STATUS_ERROR;

    /* Wait for response messages */
    wait_for_condition(sync.response, status);
    if (status != BLE_STATUS_SUCCESS)
        return status;

    /* We need to wait for ~1 ms before continuing */
    delay_until = get_uptime_32k() + TIMEOUT_TICKS_1MS;
    while (get_uptime_32k() < delay_until);

    sync.response = 0;
    cfw_open_service(client_handle,
                     BLE_CORE_SERVICE_ID,
                     NULL);

    /* Wait for response messages */
    wait_for_condition(sync.response, status);
    if (status != BLE_STATUS_SUCCESS)
        return status;

    ble_client_gap_event_cb = gap_event_cb;
    ble_client_gap_event_param = gap_event_param;

    ble_client_gatts_event_cb = gatts_event_cb;
    ble_client_gatts_event_param = gatts_event_param;

    return sync.status;
}
Exemplo n.º 3
0
// FIX: make this non-recursive
static errval_t send_message(struct tcp_pcb *pcb, void *msg, size_t len)
{
    err_t err;

    //    debug_printf("send_message(pcb: %p, msg: %p, len: %d)\n",
    //           pcb, msg, (int)len);

    if (len > 0) {
        wait_cond = true;
        uint16_t send_size = MIN(tcp_sndbuf(pcb), len);
        // debug_printf("\tsend_size: %d.\n", send_size);
        if (send_size <= 0) {
            // debug_printf("\tnot enough space in sndbuf.  will retry later.\n");
            // ran out of memory, wait for a send to happen
            //            debug_printf("\twaiting for condition.\n");
            wait_for_condition();
            // and try again
            // debug_printf("\tand trying again.\n");
            send_message(pcb, msg, len);
        } else {
            // debug_printf("\tsent %d bytes of %lu.\n", send_size, len);
            err = tcp_write(pcb, msg, send_size, TCP_WRITE_FLAG_COPY);
            // TODO: proper error handling
            if (err != ERR_OK) {
                fprintf(stderr, "error writing %d\n", err);
                return LWIP_ERR_MEM;  //TODO: what errno to use?
            }
            if (send_size < len) {
                // debug_printf("\tdidn't send whole message, so going to send rest now\n");
                send_message(pcb, msg + send_size, len - send_size);
            }
        }
    }

    err = tcp_output(pcb);

    // TODO: proper error handling
    if (err != ERR_OK) {
        fprintf(stderr, "error in tcp_output %d\n", err);
        return LWIP_ERR_MEM;  //TODO: what errno to use?
    }

    // debug_printf("done send_message()\n");

    return SYS_ERR_OK;
}
Exemplo n.º 4
0
static errval_t do_send_file(struct in_addr *addr, int port, char *path)
{
    assert(addr != NULL);
    assert(path != NULL);

    errval_t err;

    debug_printf("send file %s to %s:%d\n", path, inet_ntoa(*addr), port);

    static struct ip_addr ip;
    ip.addr = addr->s_addr; // XXX

    //    debug_printf("ready to connect\n");

    struct tcp_pcb *pcb;
    pcb = connect(&ip, port);
    if (pcb == NULL) {
        assert(pcb != NULL);
        // return SOME_ERR;
    }
    
    //    debug_printf("connected\n");

    //    debug_printf("start sending.\n");

    wait_cond = true;
    err = send_file(pcb, path);
    if (err_is_fail(err)) {
        return err;
    }

    wait_for_condition();

    debug_printf("send finished.\n");

    // debug_printf("closing connection.\n");

    //    close_connection(pcb);

    debug_printf("connection closed.\n");

    return SYS_ERR_OK;
}
Exemplo n.º 5
0
BleStatus ble_client_gap_wr_adv_data(uint8_t *adv_data, const uint8_t adv_data_len)
{
    BleStatus status;

    struct ble_gap_adv_rsp_data adv_rsp_data = {
        .p_data = adv_data,
        .len = adv_data_len,
    };

    /* write advertisement data */
    sync.response = 0;
    if (ble_gap_wr_adv_data(service_handle, &adv_rsp_data, NULL, NULL))
        return BLE_STATUS_ERROR;

    /* Wait for response messages */
    wait_for_condition(sync.response, status);
    if (status != BLE_STATUS_SUCCESS)
        return status;

    return sync.status;
}
Exemplo n.º 6
0
BleStatus ble_client_gap_set_enable_config(const char *name,
                                           const ble_addr_t *bda,
                                           const uint16_t appearance,
                                           const int8_t tx_power)
{
    struct ble_wr_config config;
    BleStatus status;

    config.p_bda = (bda && bda->type != BLE_DEVICE_ADDR_INVALID) ? (ble_addr_t *)bda : NULL;
    config.p_name = (uint8_t *)name;
    config.appearance = appearance;
    config.tx_power = tx_power;
    config.peripheral_conn_params.interval_min = MIN_CONN_INTERVAL;
    config.peripheral_conn_params.interval_max = MAX_CONN_INTERVAL;
    config.peripheral_conn_params.slave_latency = SLAVE_LATENCY;
    config.peripheral_conn_params.link_sup_to = CONN_SUP_TIMEOUT;
    config.central_conn_params.interval_min = MIN_CONN_INTERVAL;
    config.central_conn_params.interval_max = MAX_CONN_INTERVAL;
    config.central_conn_params.slave_latency = SLAVE_LATENCY;
    config.central_conn_params.link_sup_to = CONN_SUP_TIMEOUT;

    sync.response = 0;
    if (ble_gap_set_enable_config(service_handle, &config, NULL))
        return BLE_STATUS_ERROR;
    /* Wait for response message */
    wait_for_condition(sync.response, status);
    if (status != BLE_STATUS_SUCCESS)
        return status;
    if (sync.status)
        return sync.status;

    struct ble_gap_sm_config_params sm_params = {
        .options = BLE_GAP_BONDING,
        .io_caps = BLE_GAP_IO_NO_INPUT_NO_OUTPUT,
        .key_size = 16,
    };
    sync.response = 0;
    if (ble_gap_sm_config(service_handle, &sm_params, NULL))
        return BLE_STATUS_ERROR;
    /* Wait for response message */
    wait_for_condition(sync.response, status);
    if (status != BLE_STATUS_SUCCESS)
        return status;

    return sync.status;
}

BleStatus ble_client_gap_get_bda(ble_addr_t *p_bda)
{
    BleStatus status;

    sync.response = 0;
    sync.param = (void *)p_bda;
    if (ble_gap_read_bda(service_handle, NULL))
        return BLE_STATUS_ERROR;
    /* Wait for response message */
    wait_for_condition(sync.response, status);
    if (status != BLE_STATUS_SUCCESS)
        return status;

    return sync.status;
}
Exemplo n.º 7
0
static void net_proxy_connected_cb(struct bulk_net_proxy *proxy)
{
    errval_t err;

    struct block_net_service *c = (struct block_net_service *) proxy->user_state;
    c->bound++;

    BS_NET_DEBUG_BULK(" > Channel Connected. #conn=%i", c->bound);

    if (c->bound != 2) {
        return;
    }

    BS_NET_DEBUG_BULK("%s", "all channels connected. allocating pools\n");
    err = bulk_alloc_init(&allocator_tx, BULK_NET_PROXY_NUMBUFS,
                          BULK_NET_PROXY_BUFSIZE, NULL);
    if (err_is_fail(err)) {
        USER_PANIC_ERR(err, "Failed to allocate pool\n");
    }

    err = bulk_alloc_init(&allocator_rx, BULK_NET_PROXY_NUMBUFS,
                          BULK_NET_PROXY_BUFSIZE, NULL);
    if (err_is_fail(err)) {
        USER_PANIC_ERR(err, "Failed to allocate pool");
    }
    struct bulk_continuation cont = {
        .handler = pool_assigned_cb,
        .arg = NULL, };

    BS_NET_DEBUG_BULK("%s", " > Assigning pools to channels");
    err = bulk_channel_assign_pool(&c->rx_chan, allocator_rx.pool, cont);
    if (err_is_fail(err)) {
        USER_PANIC_ERR(err, "failed to assign pool to channel");
    }
    err = bulk_channel_assign_pool(&c->tx_chan, allocator_tx.pool, cont);
    if (err_is_fail(err)) {
        USER_PANIC_ERR(err, "Failed to assign pool to channel");
    }

    wait_cond = 1;
    wait_for_condition();

    BS_NET_DEBUG_BULK("%s", "Passing buffer to RX channel");
    cont.handler = buffer_passed_cb;
    struct bulk_buffer *buf = bulk_alloc_new_buffer(&allocator_rx);
    wait_cond = 1;
    while (buf) {
        err = bulk_channel_pass(&c->rx_chan, buf, NULL, cont);
        if (err_is_fail(err)) {
            USER_PANIC_ERR(err, "failed to pass the buffer");
        }
        buf = bulk_alloc_new_buffer(&allocator_rx);
        thread_yield();
    }

    wait_for_condition();

    BS_NET_DEBUG_BULK("%s", "All buffers passed.");

    block_send_status_msg(c, BLOCK_NET_MSG_INIT, 0, BLOCK_NET_ERR_OK);

    BS_NET_DEBUG_BULK("%s", "Initialization done.\n\n\n");
}