static void dispose (GObject *object) { NMVPNPlugin *plugin = NM_VPN_PLUGIN (object); NMVPNPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin); NMVPNServiceState state; GError *err = NULL; nm_clear_g_source (&priv->fail_stop_id); nm_clear_g_source (&priv->quit_timer); nm_clear_g_source (&priv->connect_timer); state = nm_vpn_plugin_get_state (plugin); if (state == NM_VPN_SERVICE_STATE_STARTED || state == NM_VPN_SERVICE_STATE_STARTING) nm_vpn_plugin_disconnect (plugin, &err); if (err) { g_warning ("Error disconnecting VPN connection: %s", err->message); g_error_free (err); } G_OBJECT_CLASS (nm_vpn_plugin_parent_class)->dispose (object); }
static void dispose (GObject *object) { NMArpingManager *self = NM_ARPING_MANAGER (object); NMArpingManagerPrivate *priv = NM_ARPING_MANAGER_GET_PRIVATE (self); nm_clear_g_source (&priv->timer); nm_clear_g_source (&priv->round2_id); g_clear_pointer (&priv->addresses, g_hash_table_destroy); G_OBJECT_CLASS (nm_arping_manager_parent_class)->dispose (object); }
/** * nm_arping_manager_reset: * @self: a #NMArpingManager * * Stop any operation in progress and reset @self to the initial state. */ void nm_arping_manager_reset (NMArpingManager *self) { NMArpingManagerPrivate *priv; g_return_if_fail (NM_IS_ARPING_MANAGER (self)); priv = NM_ARPING_MANAGER_GET_PRIVATE (self); nm_clear_g_source (&priv->timer); nm_clear_g_source (&priv->round2_id); g_hash_table_remove_all (priv->addresses); priv->state = STATE_INIT; }
static gboolean arping_timeout_cb (gpointer user_data) { NMArpingManager *self = user_data; NMArpingManagerPrivate *priv = NM_ARPING_MANAGER_GET_PRIVATE (self); GHashTableIter iter; AddressInfo *info; priv->timer = 0; g_hash_table_iter_init (&iter, priv->addresses); while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info)) { nm_clear_g_source (&info->watch); if (info->pid) { _LOGD ("DAD timed out for %s", nm_utils_inet4_ntop (info->address, NULL)); nm_utils_kill_child_async (info->pid, SIGTERM, LOGD_IP4, "arping", 1000, NULL, NULL); info->pid = 0; } } priv->state = STATE_PROBE_DONE; g_signal_emit (self, signals[PROBE_TERMINATED], 0); return G_SOURCE_REMOVE; }
static void remove_timeout_handler (NMPPPManager *manager) { NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager); nm_clear_g_source (&priv->ppp_timeout_handler); }
void nm_lldp_listener_stop (NMLldpListener *self) { NMLldpListenerPrivate *priv; guint size; g_return_if_fail (NM_IS_LLDP_LISTENER (self)); priv = NM_LLDP_LISTENER_GET_PRIVATE (self); if (priv->lldp_handle) { sd_lldp_stop (priv->lldp_handle); sd_lldp_detach_event (priv->lldp_handle); sd_lldp_unref (priv->lldp_handle); g_clear_pointer (&priv->iface, g_free); priv->lldp_handle = NULL; size = g_hash_table_size (priv->lldp_neighbors); g_hash_table_remove_all (priv->lldp_neighbors); if (size) { nm_clear_g_variant (&priv->variant); g_object_notify (G_OBJECT (self), NM_LLDP_LISTENER_NEIGHBORS); } } nm_clear_g_source (&priv->timer); }
static void adsl_cleanup (NMDeviceAdsl *self) { NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE (self); if (priv->ppp_manager) { g_signal_handlers_disconnect_by_func (priv->ppp_manager, G_CALLBACK (ppp_state_changed), self); g_signal_handlers_disconnect_by_func (priv->ppp_manager, G_CALLBACK (ppp_ip4_config), self); nm_exported_object_clear_and_unexport (&priv->ppp_manager); } g_signal_handlers_disconnect_by_func (NM_PLATFORM_GET, G_CALLBACK (link_changed_cb), self); if (priv->brfd >= 0) { close (priv->brfd); priv->brfd = -1; } nm_clear_g_source (&priv->nas_update_id); /* FIXME: kernel has no way of explicitly deleting the 'nasX' interface yet, * so it gets leaked. It does get destroyed when it's no longer in use, * but we have no control over that. */ priv->nas_ifindex = -1; g_clear_pointer (&priv->nas_ifname, g_free); }
static void arping_watch_cb (GPid pid, gint status, gpointer user_data) { AddressInfo *info = user_data; NMArpingManager *self = info->manager; NMArpingManagerPrivate *priv = NM_ARPING_MANAGER_GET_PRIVATE (self); const char *addr; info->pid = 0; info->watch = 0; addr = nm_utils_inet4_ntop (info->address, NULL); if (WIFEXITED (status)) { if (WEXITSTATUS (status) != 0) { _LOGD ("%s already used in the %s network", addr, nm_platform_link_get_name (NM_PLATFORM_GET, priv->ifindex)); info->duplicate = TRUE; } else _LOGD ("DAD succeeded for %s", addr); } else { _LOGD ("stopped unexpectedly with status %d for %s", status, addr); } if (++priv->completed == g_hash_table_size (priv->addresses)) { priv->state = STATE_PROBE_DONE; nm_clear_g_source (&priv->timer); g_signal_emit (self, signals[PROBE_TERMINATED], 0); } }
static void dispose (GObject *object) { NMSupplicantManager *self = (NMSupplicantManager *) object; NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self); GSList *ifaces; nm_clear_g_source (&priv->die_count_reset_id); if (priv->cancellable) { g_cancellable_cancel (priv->cancellable); g_clear_object (&priv->cancellable); } if (priv->ifaces) { for (ifaces = priv->ifaces; ifaces; ifaces = ifaces->next) g_object_remove_toggle_ref (ifaces->data, _sup_iface_last_ref, self); g_slist_free (priv->ifaces); priv->ifaces = NULL; } g_clear_object (&priv->proxy); G_OBJECT_CLASS (nm_supplicant_manager_parent_class)->dispose (object); }
static void connect_timer_start (NMVPNPlugin *plugin) { NMVPNPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin); nm_clear_g_source (&priv->connect_timer); priv->connect_timer = g_timeout_add_seconds (60, connect_timer_expired, plugin); }
static void schedule_fail_stop (NMVPNPlugin *plugin) { NMVPNPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin); nm_clear_g_source (&priv->fail_stop_id); priv->fail_stop_id = g_idle_add (fail_stop, plugin); }
static void dispose (GObject *object) { adsl_cleanup (NM_DEVICE_ADSL (object)); nm_clear_g_source (&NM_DEVICE_ADSL_GET_PRIVATE (object)->carrier_poll_id); G_OBJECT_CLASS (nm_device_adsl_parent_class)->dispose (object); }
static void schedule_quit_timer (NMVPNPlugin *self) { NMVPNPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (self); nm_clear_g_source (&priv->quit_timer); priv->quit_timer = g_timeout_add_seconds (NM_VPN_PLUGIN_QUIT_TIMER, quit_timer_expired, self); }
static void teamd_cleanup (NMDevice *device, gboolean free_tdc) { NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE (device); nm_clear_g_source (&priv->teamd_process_watch); nm_clear_g_source (&priv->teamd_timeout); if (priv->teamd_pid > 0) { nm_utils_kill_child_async (priv->teamd_pid, SIGTERM, LOGD_TEAM, "teamd", 2000, NULL, NULL); priv->teamd_pid = 0; } if (priv->tdc && free_tdc) { teamdctl_disconnect (priv->tdc); teamdctl_free (priv->tdc); priv->tdc = NULL; } }
void nm_checkpoint_manager_unref (NMCheckpointManager *self) { if (!self) return; nm_clear_g_source (&self->rollback_timeout_id); g_hash_table_destroy (self->checkpoints); g_slice_free (NMCheckpointManager, self); }
static void state_changed (NMVPNPlugin *plugin, NMVPNServiceState state) { NMVPNPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin); switch (state) { case NM_VPN_SERVICE_STATE_STARTING: nm_clear_g_source (&priv->quit_timer); nm_clear_g_source (&priv->fail_stop_id); break; case NM_VPN_SERVICE_STATE_STOPPED: schedule_quit_timer (plugin); break; default: /* Clean up all timers we might have set up. */ nm_clear_g_source (&priv->connect_timer); nm_clear_g_source (&priv->quit_timer); nm_clear_g_source (&priv->fail_stop_id); break; } }
/** * nm_arping_manager_announce_addresses: * @self: a #NMArpingManager * * Start announcing addresses. */ void nm_arping_manager_announce_addresses (NMArpingManager *self) { NMArpingManagerPrivate *priv = NM_ARPING_MANAGER_GET_PRIVATE (self); g_return_if_fail ( priv->state == STATE_INIT || priv->state == STATE_PROBE_DONE); send_announcements (self, "-A"); nm_clear_g_source (&priv->round2_id); priv->round2_id = g_timeout_add_seconds (2, arp_announce_round2, self); priv->state = STATE_ANNOUNCING; }
static void destroy_address_info (gpointer data) { AddressInfo *info = (AddressInfo *) data; nm_clear_g_source (&info->watch); if (info->pid) { nm_utils_kill_child_async (info->pid, SIGTERM, LOGD_IP4, "arping", 1000, NULL, NULL); } g_slice_free (AddressInfo, info); }
static void _ppp_cleanup (NMPPPManager *manager) { NMPPPManagerPrivate *priv; g_return_if_fail (NM_IS_PPP_MANAGER (manager)); priv = NM_PPP_MANAGER_GET_PRIVATE (manager); cancel_get_secrets (manager); nm_clear_g_source (&priv->monitor_id); if (priv->monitor_fd >= 0) { /* Get the stats one last time */ monitor_cb (manager); close (priv->monitor_fd); priv->monitor_fd = -1; } nm_clear_g_source (&priv->ppp_timeout_handler); nm_clear_g_source (&priv->ppp_watch_id); }
static void dispose (GObject *object) { NMConnectionEditor *editor = NM_CONNECTION_EDITOR (object); editor->disposed = TRUE; if (active_editors && editor->orig_connection) g_hash_table_remove (active_editors, editor->orig_connection); g_slist_free_full (editor->initializing_pages, g_object_unref); editor->initializing_pages = NULL; g_slist_free_full (editor->pages, g_object_unref); editor->pages = NULL; /* Mark any in-progress secrets call as canceled; it will clean up after itself. */ if (editor->secrets_call) editor->secrets_call->canceled = TRUE; while (editor->pending_secrets_calls) { get_secrets_info_free ((GetSecretsInfo *) editor->pending_secrets_calls->data); editor->pending_secrets_calls = g_slist_delete_link (editor->pending_secrets_calls, editor->pending_secrets_calls); } nm_clear_g_source (&editor->validate_id); g_clear_object (&editor->connection); g_clear_object (&editor->orig_connection); if (editor->window) { gtk_widget_destroy (editor->window); editor->window = NULL; } g_clear_object (&editor->parent_window); g_clear_object (&editor->builder); nm_clear_g_signal_handler (editor->client, &editor->permission_id); g_clear_object (&editor->client); g_clear_pointer (&editor->last_validation_error, g_free); if (editor->inter_page_hash) { g_hash_table_destroy (editor->inter_page_hash); editor->inter_page_hash = NULL; } G_OBJECT_CLASS (nm_connection_editor_parent_class)->dispose (object); }
/** * nm_vpn_plugin_secrets_required: * @plugin: the #NMVPNPlugin * @message: an information message about why secrets are required, if any * @hints: VPN specific secret names for required new secrets * * Called by VPN plugin implementations to signal to NetworkManager that secrets * are required during the connection process. This signal may be used to * request new secrets when the secrets originally provided by NetworkManager * are insufficient, or the VPN process indicates that it needs additional * information to complete the request. * * Since: 0.9.10 */ void nm_vpn_plugin_secrets_required (NMVPNPlugin *plugin, const char *message, const char **hints) { NMVPNPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin); /* Plugin must be able to accept the new secrets if it calls this method */ g_return_if_fail (NM_VPN_PLUGIN_GET_CLASS (plugin)->new_secrets); /* Plugin cannot call this method if NetworkManager didn't originally call * ConnectInteractive(). */ g_return_if_fail (priv->interactive == TRUE); /* Cancel the connect timer since secrets might take a while. It'll * get restarted when the secrets come back via NewSecrets(). */ nm_clear_g_source (&priv->connect_timer); g_signal_emit (plugin, signals[SECRETS_REQUIRED], 0, message, hints); }
static void dispose (GObject *object) { NMVpnService *self = NM_VPN_SERVICE (object); NMVpnServicePrivate *priv = NM_VPN_SERVICE_GET_PRIVATE (self); nm_clear_g_source (&priv->start_timeout); g_clear_object (&priv->plugin_info); /* VPNService owner is required to stop connections before releasing */ g_assert (priv->active == NULL); g_assert (priv->pending == NULL); if (priv->proxy) { g_signal_handlers_disconnect_by_func (priv->proxy, G_CALLBACK (_name_owner_changed), self); g_clear_object (&priv->proxy); } G_OBJECT_CLASS (nm_vpn_service_parent_class)->dispose (object); }
static void update_rollback_timeout (NMCheckpointManager *self) { NMCheckpoint *checkpoint; GHashTableIter iter; gint64 ts, delta, next = G_MAXINT64; g_hash_table_iter_init (&iter, self->checkpoints); while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &checkpoint)) { ts = nm_checkpoint_get_rollback_ts (checkpoint); if (ts && ts < next) next = ts; } nm_clear_g_source (&self->rollback_timeout_id); if (next != G_MAXINT64) { delta = MAX (next - nm_utils_get_monotonic_timestamp_ms (), 0); self->rollback_timeout_id = g_timeout_add (delta, (GSourceFunc) rollback_timeout_cb, self); _LOGT ("update timeout: next check in %" G_GINT64_FORMAT " ms", delta); } }
/* * main * */ int main (int argc, char *argv[]) { gboolean wifi_enabled = TRUE, net_enabled = TRUE, wwan_enabled = TRUE; gboolean success = FALSE; NMConfig *config; GError *error = NULL; gboolean wrote_pidfile = FALSE; char *bad_domains = NULL; NMConfigCmdLineOptions *config_cli; guint sd_id = 0; nm_g_type_init (); /* Known to cause a possible deadlock upon GDBus initialization: * https://bugzilla.gnome.org/show_bug.cgi?id=674885 */ g_type_ensure (G_TYPE_SOCKET); g_type_ensure (G_TYPE_DBUS_CONNECTION); g_type_ensure (NM_TYPE_BUS_MANAGER); _nm_utils_is_manager_process = TRUE; main_loop = g_main_loop_new (NULL, FALSE); config_cli = nm_config_cmd_line_options_new (); do_early_setup (&argc, &argv, config_cli); if (global_opt.g_fatal_warnings) _set_g_fatal_warnings (); if (global_opt.show_version) { fprintf (stdout, NM_DIST_VERSION "\n"); exit (0); } if (global_opt.print_config) { int result; result = print_config (config_cli); nm_config_cmd_line_options_free (config_cli); exit (result); } nm_main_utils_ensure_root (); nm_main_utils_ensure_not_running_pidfile (global_opt.pidfile); nm_main_utils_ensure_statedir (); nm_main_utils_ensure_rundir (); /* When running from the build directory, determine our build directory * base and set helper paths in the build tree */ if (global_opt.run_from_build_dir) { char *path, *slash; int g; /* exe is <basedir>/src/.libs/lt-NetworkManager, so chop off * the last three components */ path = realpath ("/proc/self/exe", NULL); g_assert (path != NULL); for (g = 0; g < 3; ++g) { slash = strrchr (path, '/'); g_assert (slash != NULL); *slash = '\0'; } /* don't free these strings, we need them for the entire * process lifetime */ nm_dhcp_helper_path = g_strdup_printf ("%s/src/dhcp-manager/nm-dhcp-helper", path); g_free (path); } if (!nm_logging_setup (global_opt.opt_log_level, global_opt.opt_log_domains, &bad_domains, &error)) { fprintf (stderr, _("%s. Please use --help to see a list of valid options.\n"), error->message); exit (1); } else if (bad_domains) { fprintf (stderr, _("Ignoring unrecognized log domain(s) '%s' passed on command line.\n"), bad_domains); g_clear_pointer (&bad_domains, g_free); } /* Read the config file and CLI overrides */ config = nm_config_setup (config_cli, NULL, &error); nm_config_cmd_line_options_free (config_cli); config_cli = NULL; if (config == NULL) { fprintf (stderr, _("Failed to read configuration: %s\n"), error->message); exit (1); } _init_nm_debug (nm_config_get_debug (config)); /* Initialize logging from config file *only* if not explicitly * specified by commandline. */ if (global_opt.opt_log_level == NULL && global_opt.opt_log_domains == NULL) { if (!nm_logging_setup (nm_config_get_log_level (config), nm_config_get_log_domains (config), &bad_domains, &error)) { fprintf (stderr, _("Error in configuration file: %s.\n"), error->message); exit (1); } else if (bad_domains) { fprintf (stderr, _("Ignoring unrecognized log domain(s) '%s' from config files.\n"), bad_domains); g_clear_pointer (&bad_domains, g_free); } } if (global_opt.become_daemon && !nm_config_get_is_debug (config)) { if (daemon (0, 0) < 0) { int saved_errno; saved_errno = errno; fprintf (stderr, _("Could not daemonize: %s [error %u]\n"), g_strerror (saved_errno), saved_errno); exit (1); } wrote_pidfile = nm_main_utils_write_pidfile (global_opt.pidfile); } /* Set up unix signal handling - before creating threads, but after daemonizing! */ nm_main_utils_setup_signals (main_loop); nm_logging_syslog_openlog (nm_config_get_is_debug (config) ? "debug" : nm_config_data_get_value_cached (NM_CONFIG_GET_DATA_ORIG, NM_CONFIG_KEYFILE_GROUP_LOGGING, NM_CONFIG_KEYFILE_KEY_LOGGING_BACKEND, NM_CONFIG_GET_VALUE_STRIP | NM_CONFIG_GET_VALUE_NO_EMPTY)); nm_log_info (LOGD_CORE, "NetworkManager (version " NM_DIST_VERSION ") is starting..."); /* Parse the state file */ if (!parse_state_file (global_opt.state_file, &net_enabled, &wifi_enabled, &wwan_enabled, &error)) { nm_log_err (LOGD_CORE, "State file %s parsing failed: %s", global_opt.state_file, error->message); /* Not a hard failure */ } g_clear_error (&error); nm_log_info (LOGD_CORE, "Read config: %s", nm_config_data_get_config_description (nm_config_get_data (config))); nm_config_data_log (nm_config_get_data (config), "CONFIG: ", " ", NULL); nm_log_dbg (LOGD_CORE, "WEXT support is %s", #if HAVE_WEXT "enabled" #else "disabled" #endif ); nm_auth_manager_setup (nm_config_get_auth_polkit (config)); nm_manager_setup (global_opt.state_file, net_enabled, wifi_enabled, wwan_enabled); if (!nm_bus_manager_get_connection (nm_bus_manager_get ())) { nm_log_warn (LOGD_CORE, "Failed to connect to D-Bus; only private bus is available"); } else { /* Start our DBus service */ if (!nm_bus_manager_start_service (nm_bus_manager_get ())) { nm_log_err (LOGD_CORE, "failed to start the dbus service."); goto done; } } /* Set up platform interaction layer */ nm_linux_platform_setup (); NM_UTILS_KEEP_ALIVE (config, NM_PLATFORM_GET, "NMConfig-depends-on-NMPlatform"); nm_dispatcher_init (); g_signal_connect (nm_manager_get (), NM_MANAGER_CONFIGURE_QUIT, G_CALLBACK (manager_configure_quit), config); if (!nm_manager_start (nm_manager_get (), &error)) { nm_log_err (LOGD_CORE, "failed to initialize: %s", error->message); goto done; } /* Make sure the loopback interface is up. If interface is down, we bring * it up and kernel will assign it link-local IPv4 and IPv6 addresses. If * it was already up, we assume is in clean state. * * TODO: it might be desirable to check the list of addresses and compare * it with a list of expected addresses (one of the protocol families * could be disabled). The 'lo' interface is sometimes used for assigning * global addresses so their availability doesn't depend on the state of * physical interfaces. */ nm_log_dbg (LOGD_CORE, "setting up local loopback"); nm_platform_link_set_up (NM_PLATFORM_GET, 1, NULL); success = TRUE; if (configure_and_quit == FALSE) { sd_id = nm_sd_event_attach_default (); g_main_loop_run (main_loop); } done: nm_exported_object_class_set_quitting (); nm_manager_stop (nm_manager_get ()); if (global_opt.pidfile && wrote_pidfile) unlink (global_opt.pidfile); nm_log_info (LOGD_CORE, "exiting (%s)", success ? "success" : "error"); nm_clear_g_source (&sd_id); exit (success ? 0 : 1); }
int main (int argc, char *argv[]) { char *bad_domains = NULL; GError *error = NULL; gboolean wrote_pidfile = FALSE; gs_free char *pidfile = NULL; gs_unref_object NMDhcpClient *dhcp4_client = NULL; gs_unref_object NMRDisc *rdisc = NULL; GByteArray *hwaddr = NULL; size_t hwaddr_len = 0; gconstpointer tmp; gs_free NMUtilsIPv6IfaceId *iid = NULL; guint sd_id; nm_g_type_init (); setpgid (getpid (), getpid ()); do_early_setup (&argc, &argv); if (global_opt.g_fatal_warnings) { GLogLevelFlags fatal_mask; fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK); fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL; g_log_set_always_fatal (fatal_mask); } if (global_opt.show_version) { fprintf (stdout, NM_DIST_VERSION "\n"); exit (0); } nm_main_utils_ensure_root (); if (!global_opt.ifname || !global_opt.uuid) { fprintf (stderr, _("An interface name and UUID are required\n")); exit (1); } ifindex = if_nametoindex (global_opt.ifname); if (ifindex <= 0) { fprintf (stderr, _("Failed to find interface index for %s (%s)\n"), global_opt.ifname, strerror (errno)); exit (1); } pidfile = g_strdup_printf (NMIH_PID_FILE_FMT, ifindex); nm_main_utils_ensure_not_running_pidfile (pidfile); nm_main_utils_ensure_rundir (); if (!nm_logging_setup (global_opt.opt_log_level, global_opt.opt_log_domains, &bad_domains, &error)) { fprintf (stderr, _("%s. Please use --help to see a list of valid options.\n"), error->message); exit (1); } else if (bad_domains) { fprintf (stderr, _("Ignoring unrecognized log domain(s) '%s' passed on command line.\n"), bad_domains); g_clear_pointer (&bad_domains, g_free); } if (global_opt.become_daemon && !global_opt.debug) { if (daemon (0, 0) < 0) { int saved_errno; saved_errno = errno; fprintf (stderr, _("Could not daemonize: %s [error %u]\n"), g_strerror (saved_errno), saved_errno); exit (1); } if (nm_main_utils_write_pidfile (pidfile)) wrote_pidfile = TRUE; } /* Set up unix signal handling - before creating threads, but after daemonizing! */ main_loop = g_main_loop_new (NULL, FALSE); setup_signals (); nm_logging_syslog_openlog (global_opt.logging_backend ? global_opt.logging_backend : (global_opt.debug ? "debug" : NULL)); nm_log_info (LOGD_CORE, "nm-iface-helper (version " NM_DIST_VERSION ") is starting..."); /* Set up platform interaction layer */ nm_linux_platform_setup (); tmp = nm_platform_link_get_address (NM_PLATFORM_GET, ifindex, &hwaddr_len); if (tmp) { hwaddr = g_byte_array_sized_new (hwaddr_len); g_byte_array_append (hwaddr, tmp, hwaddr_len); } if (global_opt.iid_str) { GBytes *bytes; gsize ignored = 0; bytes = nm_utils_hexstr2bin (global_opt.iid_str); if (!bytes || g_bytes_get_size (bytes) != sizeof (*iid)) { fprintf (stderr, _("(%s): Invalid IID %s\n"), global_opt.ifname, global_opt.iid_str); exit (1); } iid = g_bytes_unref_to_data (bytes, &ignored); } if (global_opt.dhcp4_address) { nm_platform_sysctl_set (NM_PLATFORM_GET, nm_utils_ip4_property_path (global_opt.ifname, "promote_secondaries"), "1"); dhcp4_client = nm_dhcp_manager_start_ip4 (nm_dhcp_manager_get (), global_opt.ifname, ifindex, hwaddr, global_opt.uuid, global_opt.priority_v4, !!global_opt.dhcp4_hostname, global_opt.dhcp4_hostname, global_opt.dhcp4_fqdn, global_opt.dhcp4_clientid, 45, NULL, global_opt.dhcp4_address); g_assert (dhcp4_client); g_signal_connect (dhcp4_client, NM_DHCP_CLIENT_SIGNAL_STATE_CHANGED, G_CALLBACK (dhcp4_state_changed), NULL); } if (global_opt.slaac) { nm_platform_link_set_user_ipv6ll_enabled (NM_PLATFORM_GET, ifindex, TRUE); rdisc = nm_lndp_rdisc_new (NM_PLATFORM_GET, ifindex, global_opt.ifname, global_opt.uuid, global_opt.addr_gen_mode, NULL); g_assert (rdisc); if (iid) nm_rdisc_set_iid (rdisc, *iid); nm_platform_sysctl_set (NM_PLATFORM_GET, nm_utils_ip6_property_path (global_opt.ifname, "accept_ra"), "1"); nm_platform_sysctl_set (NM_PLATFORM_GET, nm_utils_ip6_property_path (global_opt.ifname, "accept_ra_defrtr"), "0"); nm_platform_sysctl_set (NM_PLATFORM_GET, nm_utils_ip6_property_path (global_opt.ifname, "accept_ra_pinfo"), "0"); nm_platform_sysctl_set (NM_PLATFORM_GET, nm_utils_ip6_property_path (global_opt.ifname, "accept_ra_rtr_pref"), "0"); g_signal_connect (NM_PLATFORM_GET, NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED, G_CALLBACK (ip6_address_changed), rdisc); g_signal_connect (rdisc, NM_RDISC_CONFIG_CHANGED, G_CALLBACK (rdisc_config_changed), NULL); g_signal_connect (rdisc, NM_RDISC_RA_TIMEOUT, G_CALLBACK (rdisc_ra_timeout), NULL); nm_rdisc_start (rdisc); } sd_id = nm_sd_event_attach_default (); g_main_loop_run (main_loop); g_clear_pointer (&hwaddr, g_byte_array_unref); if (pidfile && wrote_pidfile) unlink (pidfile); nm_log_info (LOGD_CORE, "exiting"); nm_clear_g_source (&sd_id); exit (0); }
static NMActStageReturn br2684_create_iface (NMDeviceAdsl *self, NMSettingAdsl *s_adsl, NMDeviceStateReason *out_reason) { NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE (self); struct atm_newif_br2684 ni; int err, fd, errsv; NMActStageReturn ret = NM_ACT_STAGE_RETURN_FAILURE; guint num = 0; g_return_val_if_fail (s_adsl != NULL, FALSE); if (priv->nas_update_id) { g_warn_if_fail (priv->nas_update_id == 0); nm_clear_g_source (&priv->nas_update_id); } fd = socket (PF_ATMPVC, SOCK_DGRAM, ATM_AAL5); if (fd < 0) { errsv = errno; _LOGE (LOGD_ADSL, "failed to open ATM control socket (%d)", errsv); *out_reason = NM_DEVICE_STATE_REASON_BR2684_FAILED; return NM_ACT_STAGE_RETURN_FAILURE; } memset (&ni, 0, sizeof (ni)); ni.backend_num = ATM_BACKEND_BR2684; ni.media = BR2684_MEDIA_ETHERNET; ni.mtu = 1500; /* Loop attempting to create an interface that doesn't exist yet. The * kernel can create one for us automatically, but due to API issues it * cannot return that name to us. Since we want to know the name right * away, just brute-force it. */ while (num < 10000) { memset (&ni.ifname, 0, sizeof (ni.ifname)); g_snprintf (ni.ifname, sizeof (ni.ifname), "nas%d", num++); err = ioctl (fd, ATM_NEWBACKENDIF, &ni); if (err == 0) { g_free (priv->nas_ifname); priv->nas_ifname = g_strdup (ni.ifname); _LOGD (LOGD_ADSL, "waiting for br2684 iface '%s' to appear", priv->nas_ifname); priv->nas_update_count = 0; priv->nas_update_id = g_timeout_add (100, nas_update_cb, self); ret = NM_ACT_STAGE_RETURN_POSTPONE; break; } else if (errno != EEXIST) { errsv = errno; _LOGW (LOGD_ADSL, "failed to create br2684 interface (%d)", errsv); *out_reason = NM_DEVICE_STATE_REASON_BR2684_FAILED; break; } } close (fd); return ret; }