static int
pipe_master(struct TestContext *ctx)
{
strncat(ctx->ifname_ext, "{pipeid1", sizeof(ctx->ifname_ext));
ctx->nr_mode = NR_REG_NIC_SW;
if (port_register(ctx) == 0) {
printf("pipes should not accept NR_REG_NIC_SW\n");
return -1;
}
ctx->nr_mode = NR_REG_ALL_NIC;
return port_register(ctx);
}
static int serial_probe(struct btd_device *device, const char *uuid)
{
struct btd_adapter *adapter = device_get_adapter(device);
const gchar *path = device_get_path(device);
sdp_list_t *protos;
int ch;
bdaddr_t src, dst;
const sdp_record_t *rec;
DBG("path %s: %s", path, uuid);
rec = btd_device_get_record(device, uuid);
if (!rec)
return -EINVAL;
if (sdp_get_access_protos(rec, &protos) < 0)
return -EINVAL;
ch = sdp_get_proto_port(protos, RFCOMM_UUID);
sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL);
sdp_list_free(protos, NULL);
if (ch < 1 || ch > 30) {
error("Channel out of range: %d", ch);
return -EINVAL;
}
adapter_get_address(adapter, &src);
device_get_address(device, &dst);
return port_register(connection, path, &src, &dst, uuid, ch);
}
static int
vale_ephemeral_port_hdr_manipulation(struct TestContext *ctx)
{
int ret;
strncpy(ctx->ifname_ext, "vale:eph0", sizeof(ctx->ifname_ext));
ctx->nr_mode = NR_REG_ALL_NIC;
if ((ret = port_register(ctx))) {
return ret;
}
/* Try to set and get all the acceptable values. */
ctx->nr_hdr_len = VIRTIO_NET_HDR_LEN_WITH_MERGEABLE_RXBUFS;
if ((ret = port_hdr_set_and_get(ctx))) {
return ret;
}
ctx->nr_hdr_len = 0;
if ((ret = port_hdr_set_and_get(ctx))) {
return ret;
}
ctx->nr_hdr_len = VIRTIO_NET_HDR_LEN;
if ((ret = port_hdr_set_and_get(ctx))) {
return ret;
}
return 0;
}
static int
port_register_single_hw_pair(struct TestContext *ctx)
{
ctx->nr_mode = NR_REG_ONE_NIC;
ctx->nr_ringid = 0;
return port_register(ctx);
}
static int
port_register_hwall_rx(struct TestContext *ctx)
{
ctx->nr_mode = NR_REG_ALL_NIC;
ctx->nr_flags |= NR_RX_RINGS_ONLY;
return port_register(ctx);
}
term_t bif_open0_3(term_t FileName, term_t Mode, term_t Perms, process_t *ctx)
{
apr_status_t rs;
apr_pool_t *p;
apr_file_t *file;
port_t *port;
if (!is_binary(FileName) || !is_int(Mode) || !is_int(Perms))
return A_BADARG;
apr_pool_create(&p, 0);
rs = apr_file_open(&file, (char *)bin_data(FileName), (apr_uint32_t)int_value(Mode), (apr_uint32_t)int_value(Perms), p);
if (rs != 0)
{
apr_pool_destroy(p);
return decipher_status(rs);
}
port = port_file_make(file);
//set initial port owner
//port->owner_in = port->owner_out = proc_pid(ctx, port->xp);
port->owner_in = port->owner_out = A_UNDEFINED;
//put port to polling ring
port_register(port);
result(port_id(port, proc_gc_pool(ctx)));
return AI_OK;
}
static int
pipe_slave(struct TestContext *ctx)
{
strncat(ctx->ifname_ext, "}pipeid2", sizeof(ctx->ifname_ext));
ctx->nr_mode = NR_REG_ALL_NIC;
return port_register(ctx);
}
static int
port_register_hostall_many(struct TestContext *ctx)
{
ctx->nr_mode = NR_REG_SW;
ctx->nr_host_tx_rings = 5;
ctx->nr_host_rx_rings = 4;
return port_register(ctx);
}
static int
port_register_single_host_pair(struct TestContext *ctx)
{
ctx->nr_mode = NR_REG_ONE_SW;
ctx->nr_host_tx_rings = 2;
ctx->nr_host_rx_rings = 2;
ctx->nr_ringid = 1;
return port_register(ctx);
}
term_t bif_open_socket2(term_t LocIP, term_t LocPort, process_t *ctx)
{
apr_status_t rs;
apr_pool_t *p;
apr_sockaddr_t *sa;
apr_socket_t *socket;
port_t *port;
term_t id;
const char *host;
apr_port_t udp_port;
if (LocIP != A_ANY && !is_binary(LocIP))
return A_BADARG;
if (!is_int(LocPort))
return A_BADARG;
host = (LocIP == A_ANY) ?0 :(const char *)bin_data(LocIP);
udp_port = (apr_port_t)int_value(LocPort);
apr_pool_create(&p, 0);
rs = apr_sockaddr_info_get(&sa, host, APR_INET, udp_port, 0, p);
if (rs == 0)
rs = apr_socket_create(&socket,
APR_INET, SOCK_DGRAM, APR_PROTO_UDP, p); //only APR_INET is supported, not APR_INET6
if (rs == 0)
rs = apr_socket_bind(socket, sa);
if (rs == 0)
rs = apr_socket_opt_set(socket, APR_SO_NONBLOCK, 1);
if (rs != 0)
{
apr_pool_destroy(p);
return decipher_status(rs);
}
port = port_udp_make(socket); //takes care of pool p
//add to poll ring
port_register(port);
//set initial port owner
port->owner_in = port->owner_out = proc_pid(ctx, port->xp);
id = make_port(my_node, port->key, my_creation, proc_gc_pool(ctx));
result(id);
return AI_OK;
}
static int
null_port_all_zero(struct TestContext *ctx)
{
int ret;
ctx->nr_mem_id = 1;
ctx->nr_mode = NR_REG_NULL;
ctx->nr_tx_rings = 0;
ctx->nr_rx_rings = 0;
ctx->nr_tx_slots = 0;
ctx->nr_rx_slots = 0;
ret = port_register(ctx);
if (ret != 0) {
return ret;
}
return 0;
}
static int
null_port_sync(struct TestContext *ctx)
{
int ret;
ctx->nr_mem_id = 1;
ctx->nr_mode = NR_REG_NULL;
ctx->nr_tx_rings = 10;
ctx->nr_rx_rings = 5;
ctx->nr_tx_slots = 256;
ctx->nr_rx_slots = 100;
ret = port_register(ctx);
if (ret != 0) {
return ret;
}
ret = ioctl(ctx->fd, NIOCTXSYNC, 0);
if (ret != 0) {
return ret;
}
return 0;
}
static int
pools_info_get_and_register(struct TestContext *ctx)
{
int ret;
/* Check that we can get pools info before we register
* a netmap interface. */
ret = pools_info_get(ctx);
if (ret != 0) {
return ret;
}
ctx->nr_mode = NR_REG_ONE_NIC;
ret = port_register(ctx);
if (ret != 0) {
return ret;
}
ctx->nr_mem_id = 1;
/* Check that we can get pools info also after we register. */
return pools_info_get(ctx);
}
static int
port_register_hwall(struct TestContext *ctx)
{
ctx->nr_mode = NR_REG_ALL_NIC;
return port_register(ctx);
}
static int
port_register_hostall(struct TestContext *ctx)
{
ctx->nr_mode = NR_REG_SW;
return port_register(ctx);
}
void ports_init(char *data) {
/* initializing common ports */
#ifdef HAS_GPIO0
port_register(gpio0);
#endif
#ifdef HAS_GPIO1
port_register(gpio1);
#endif
#ifdef HAS_GPIO2
port_register(gpio2);
#endif
#ifdef HAS_GPIO3
port_register(gpio3);
#endif
#ifdef HAS_GPIO4
port_register(gpio4);
#endif
#ifdef HAS_GPIO5
port_register(gpio5);
#endif
#ifdef HAS_GPIO12
port_register(gpio12);
#endif
#ifdef HAS_GPIO13
port_register(gpio13);
#endif
#ifdef HAS_GPIO14
port_register(gpio14);
#endif
#ifdef HAS_GPIO15
port_register(gpio15);
#endif
#ifdef HAS_ADC0
port_register(adc0);
#endif
/* initializing custom ports */
#ifdef _INIT_CUSTOM_PORTS
_INIT_CUSTOM_PORTS
#endif
/* loading port data */
port_t **p = all_ports;
while (*p) {
DEBUG("loading port %s data", (*p)->id);
port_load(*p, data);
p++;
}
}
