int main(int argc, char *argv[])
{
struct rtnl_link *link;
struct nl_cache *link_cache;
struct nl_sock *sk;
int err;
sk = nl_socket_alloc();
if ((err = nl_connect(sk, NETLINK_ROUTE)) < 0) {
nl_perror(err, "Unable to connect socket");
return err;
}
if ((err = rtnl_link_alloc_cache(sk, AF_UNSPEC, &link_cache)) < 0) {
nl_perror(err, "Unable to allocate cache");
return err;
}
if ((err = create_bridge(sk, link_cache, TEST_BRIDGE_NAME)) < 0) {
nl_perror(err, "Unable to allocate testbridge");
return err;
}
nl_cache_refill(sk, link_cache);
link = rtnl_link_get_by_name(link_cache, TEST_BRIDGE_NAME);
struct rtnl_link *ltap = rtnl_link_get_by_name(link_cache, TEST_INTERFACE_NAME);
if (!ltap) {
fprintf(stderr, "You should create a tap interface before lunch this test (# tunctl -t %s)\n", TEST_INTERFACE_NAME);
return -1;
}
if ((err = rtnl_link_enslave(sk, link, ltap)) < 0) {
nl_perror(err, "Unable to enslave interface to his bridge\n");
return err;
}
if(rtnl_link_is_bridge(link) == 0) {
fprintf(stderr, "Link is not a bridge\n");
return -2;
}
if(rtnl_link_get_master(ltap) <= 0) {
fprintf(stderr, "Interface is not attached to a bridge\n");
return -3;
}
rtnl_link_put(ltap);
rtnl_link_put(link);
nl_cache_free(link_cache);
nl_socket_free(sk);
return 0;
}
void __connman_tethering_set_enabled(void)
{
int err;
DBG("enabled %d", tethering_enabled + 1);
if (g_atomic_int_exchange_and_add(&tethering_enabled, 1) == 0) {
const char *dns;
err = create_bridge(BRIDGE_NAME);
if (err < 0)
return;
err = enable_bridge(BRIDGE_NAME);
if (err < 0 && err != -EALREADY) {
remove_bridge(BRIDGE_NAME);
return;
}
dns = BRIDGE_IP;
if (__connman_dnsproxy_add_listener(BRIDGE_NAME) < 0) {
connman_error("Can't add listener %s to DNS proxy",
BRIDGE_NAME);
dns = BRIDGE_DNS;
}
tethering_dhcp_server =
dhcp_server_start(BRIDGE_NAME,
BRIDGE_IP, BRIDGE_SUBNET,
BRIDGE_IP_START, BRIDGE_IP_END,
24 * 3600, dns);
if (tethering_dhcp_server == NULL) {
disable_bridge(BRIDGE_NAME);
remove_bridge(BRIDGE_NAME);
return;
}
enable_nat(default_interface);
DBG("tethering started");
}
}
static int afpacket_daq_initialize(const DAQ_Config_t *config, void **ctxt_ptr, char *errbuf, size_t errlen)
{
AFPacket_Context_t *afpc;
AFPacketInstance *instance;
const char *size_str = NULL;
char *name1, *name2, *dev;
char intf[IFNAMSIZ];
uint32_t size;
size_t len;
int num_intfs = 0;
int rval = DAQ_ERROR;
DAQ_Dict *entry;
afpc = calloc(1, sizeof(AFPacket_Context_t));
if (!afpc)
{
snprintf(errbuf, errlen, "%s: Couldn't allocate memory for the new AFPacket context!", __FUNCTION__);
rval = DAQ_ERROR_NOMEM;
goto err;
}
afpc->device = strdup(config->name);
if (!afpc->device)
{
snprintf(errbuf, errlen, "%s: Couldn't allocate memory for the device string!", __FUNCTION__);
rval = DAQ_ERROR_NOMEM;
goto err;
}
afpc->snaplen = config->snaplen;
afpc->timeout = (config->timeout > 0) ? (int) config->timeout : -1;
dev = afpc->device;
if (*dev == ':' || ((len = strlen(dev)) > 0 && *(dev + len - 1) == ':') || (config->mode == DAQ_MODE_PASSIVE && strstr(dev, "::")))
{
snprintf(errbuf, errlen, "%s: Invalid interface specification: %s!", __FUNCTION__, afpc->device);
goto err;
}
while (*dev != '\0')
{
len = strcspn(dev, ":");
if (len >= IFNAMSIZ)
{
snprintf(errbuf, errlen, "%s: Interface name too long! (%zu)", __FUNCTION__, len);
goto err;
}
if (len != 0)
{
afpc->intf_count++;
if (afpc->intf_count >= AF_PACKET_MAX_INTERFACES)
{
snprintf(errbuf, errlen, "%s: Using more than %d interfaces is not supported!", __FUNCTION__, AF_PACKET_MAX_INTERFACES);
goto err;
}
snprintf(intf, len + 1, "%s", dev);
instance = create_instance(afpc, intf);
if (!instance)
goto err;
instance->next = afpc->instances;
afpc->instances = instance;
num_intfs++;
if (config->mode != DAQ_MODE_PASSIVE)
{
if (num_intfs == 2)
{
name1 = afpc->instances->next->name;
name2 = afpc->instances->name;
if (create_bridge(afpc, name1, name2) != DAQ_SUCCESS)
{
snprintf(errbuf, errlen, "%s: Couldn't create the bridge between %s and %s!", __FUNCTION__, name1, name2);
goto err;
}
num_intfs = 0;
}
else if (num_intfs > 2)
break;
}
}
else
len = 1;
dev += len;
}
/* If there are any leftover unbridged interfaces and we're not in Passive mode, error out. */
if (config->mode != DAQ_MODE_PASSIVE && num_intfs != 0)
{
snprintf(errbuf, errlen, "%s: Invalid interface specification: %s!", __FUNCTION__, afpc->device);
goto err;
}
/*
* Determine the dimensions of the kernel RX ring(s) to request.
*/
/* 1. Find the total desired packet buffer memory for all instances. */
for (entry = config->values; entry; entry = entry->next)
{
if (!strcmp(entry->key, "buffer_size_mb"))
size_str = entry->value;
else if (!strcmp(entry->key, "debug"))
afpc->debug = 1;
}
/* Fall back to the environment variable. */
if (!size_str)
size_str = getenv("AF_PACKET_BUFFER_SIZE");
if (size_str && strcmp("max", size_str) != 0)
size = strtoul(size_str, NULL, 10);
else
size = AF_PACKET_DEFAULT_BUFFER_SIZE;
/* The size is specified in megabytes. */
size = size * 1024 * 1024;
/* 2. Divide it evenly across the number of interfaces. */
num_intfs = 0;
for (instance = afpc->instances; instance; instance = instance->next)
num_intfs++;
afpc->size = size / num_intfs;
afpc->state = DAQ_STATE_INITIALIZED;
*ctxt_ptr = afpc;
return DAQ_SUCCESS;
err:
if (afpc)
{
af_packet_close(afpc);
if (afpc->device)
free(afpc->device);
free(afpc);
}
return rval;
}
