C++ (Cpp) connman_rtnl_add_newlink_watch Examples

Example #1

File: wifi.c Project: cshnick/rpmFromGit

static int wifi_probe(struct connman_device *device)
{
	struct wifi_data *wifi;

	DBG("device %p", device);

	wifi = g_try_new0(struct wifi_data, 1);
	if (wifi == NULL)
		return -ENOMEM;

	wifi->connected = FALSE;
	wifi->disconnecting = FALSE;
	wifi->tethering = FALSE;
	wifi->bridged = FALSE;
	wifi->bridge = NULL;
	wifi->state = G_SUPPLICANT_STATE_INACTIVE;

	connman_device_set_data(device, wifi);
	wifi->device = connman_device_ref(device);

	wifi->index = connman_device_get_index(device);
	wifi->flags = 0;

	wifi->watch = connman_rtnl_add_newlink_watch(wifi->index,
							wifi_newlink, device);

	iface_list = g_list_append(iface_list, wifi);

	return 0;
}

Example #2

File: vpn.c Project: connectivity/connman-stable

static DBusMessage *vpn_notify(struct connman_task *task,
                               DBusMessage *msg, void *user_data)
{
    struct connman_provider *provider = user_data;
    struct vpn_data *data;
    struct vpn_driver_data *vpn_driver_data;
    const char *name;
    int state, index;

    data = connman_provider_get_data(provider);

    name = connman_provider_get_driver_name(provider);
    if (name == NULL)
        return NULL;

    vpn_driver_data = g_hash_table_lookup(driver_hash, name);
    if (vpn_driver_data == NULL)
        return NULL;

    state = vpn_driver_data->vpn_driver->notify(msg, provider);
    switch (state) {
    case VPN_STATE_CONNECT:
    case VPN_STATE_READY:
        index = connman_provider_get_index(provider);
        data->watch = connman_rtnl_add_newlink_watch(index,
                      vpn_newlink, provider);
        connman_inet_ifup(index);
        break;

    case VPN_STATE_UNKNOWN:
    case VPN_STATE_IDLE:
    case VPN_STATE_DISCONNECT:
    case VPN_STATE_FAILURE:
        connman_provider_set_state(provider,
                                   CONNMAN_PROVIDER_STATE_DISCONNECT);
        break;

    case VPN_STATE_AUTH_FAILURE:
        connman_provider_indicate_error(provider,
                                        CONNMAN_PROVIDER_ERROR_AUTH_FAILED);
        break;
    }

    return NULL;
}

Example #3

File: ethernet.c Project: wenhann/chromiumos

static int ethernet_probe(struct connman_device *device)
{
	struct ethernet_data *ethernet;

	_DBG_ETHERNET("device %p", device);

	ethernet = g_try_new0(struct ethernet_data, 1);
	if (ethernet == NULL)
		return -ENOMEM;

	connman_device_set_data(device, ethernet);

	ethernet->index = connman_device_get_index(device);
	ethernet->flags = 0;

	ethernet->watch = connman_rtnl_add_newlink_watch(ethernet->index,
						ethernet_newlink, device);

	return 0;
}

Example #4

File: mbm.c Project: wenhann/chromiumos

static int mbm_probe(struct connman_device *device)
{
	struct mbm_data *data;
	int index;

	_DBG_MBM("device %p", device);

	data = g_try_new0(struct mbm_data, 1);
	if (data == NULL)
		return -ENOMEM;

	connman_device_set_data(device, data);

	index = connman_device_get_index(device);

	data->watch = connman_rtnl_add_newlink_watch(index,
						mbm_newlink, device);

	return 0;
}

Example #5

File: tethering.c Project: aldebaran/connman-stable

int __connman_private_network_request(DBusMessage *msg, const char *owner)
{
	struct connman_private_network *pn;
	char *iface = NULL;
	char *path = NULL;
	int index, fd, err;

	if (DBUS_TYPE_UNIX_FD < 0)
		return -EINVAL;

	fd = connman_inet_create_tunnel(&iface);
	if (fd < 0)
		return fd;

	path = g_strdup_printf("/tethering/%s", iface);

	pn = g_hash_table_lookup(pn_hash, path);
	if (pn) {
		g_free(path);
		g_free(iface);
		close(fd);
		return -EEXIST;
	}

	index = connman_inet_ifindex(iface);
	if (index < 0) {
		err = -ENODEV;
		goto error;
	}
	DBG("interface %s", iface);

	err = connman_inet_set_mtu(index, DEFAULT_MTU);

	pn = g_try_new0(struct connman_private_network, 1);
	if (pn == NULL) {
		err = -ENOMEM;
		goto error;
	}

	pn->owner = g_strdup(owner);
	pn->path = path;
	pn->watch = g_dbus_add_disconnect_watch(connection, pn->owner,
					owner_disconnect, pn, NULL);
	pn->msg = msg;
	pn->reply = dbus_message_new_method_return(pn->msg);
	if (pn->reply == NULL)
		goto error;

	pn->fd = fd;
	pn->interface = iface;
	pn->index = index;
	pn->server_ip = PRIVATE_NETWORK_IP;
	pn->peer_ip = PRIVATE_NETWORK_PEER_IP;
	pn->primary_dns = PRIVATE_NETWORK_PRIMARY_DNS;
	pn->secondary_dns = PRIVATE_NETWORK_SECONDARY_DNS;

	pn->iface_watch = connman_rtnl_add_newlink_watch(index,
						setup_tun_interface, pn);

	g_hash_table_insert(pn_hash, pn->path, pn);

	return 0;

error:
	close(fd);
	g_free(iface);
	g_free(path);
	g_free(pn);
	return err;
}