static gboolean
set_ip_config_common (NMPPPManager *self,
GVariant *config_dict,
const char *iface_prop,
guint32 *out_mtu)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
NMConnection *applied_connection;
NMSettingPpp *s_ppp;
const char *iface;
if (!g_variant_lookup (config_dict, iface_prop, "&s", &iface)) {
_LOGE ("no interface received!");
return FALSE;
}
if (priv->ip_iface == NULL)
priv->ip_iface = g_strdup (iface);
/* Got successful IP config; obviously the secrets worked */
applied_connection = nm_act_request_get_applied_connection (priv->act_req);
g_object_set_data (G_OBJECT (applied_connection), PPP_MANAGER_SECRET_TRIES, NULL);
if (out_mtu) {
/* Get any custom MTU */
s_ppp = nm_connection_get_setting_ppp (applied_connection);
*out_mtu = s_ppp ? nm_setting_ppp_get_mtu (s_ppp) : 0;
}
monitor_stats (self);
return TRUE;
}
static void
ppp_watch_cb (GPid pid, gint status, gpointer user_data)
{
NMPPPManager *manager = NM_PPP_MANAGER (user_data);
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
guint err;
g_assert (pid == priv->pid);
if (WIFEXITED (status)) {
err = WEXITSTATUS (status);
if (err != 0)
ppp_exit_code (err, priv->pid);
} else if (WIFSTOPPED (status)) {
_LOGI ("pppd pid %d stopped unexpectedly with signal %d", priv->pid, WSTOPSIG (status));
} else if (WIFSIGNALED (status)) {
_LOGI ("pppd pid %d died with signal %d", priv->pid, WTERMSIG (status));
} else
_LOGI ("pppd pid %d died from an unknown cause", priv->pid);
_LOGD ("pppd pid %d cleaned up", priv->pid);
priv->pid = 0;
priv->ppp_watch_id = 0;
g_signal_emit (manager, signals[STATE_CHANGED], 0, NM_PPP_STATUS_DEAD);
}
static void
remove_timeout_handler (NMPPPManager *manager)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
nm_clear_g_source (&priv->ppp_timeout_handler);
}
static GObject *
constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
NMPPPManagerPrivate *priv;
DBusGConnection *connection;
static guint32 counter = 0;
object = G_OBJECT_CLASS (nm_ppp_manager_parent_class)->constructor (type,
n_construct_params,
construct_params);
if (!object)
return NULL;
priv = NM_PPP_MANAGER_GET_PRIVATE (object);
priv->dbus_manager = nm_dbus_manager_get ();
if (!priv->dbus_manager) {
g_object_unref (object);
return NULL;
}
connection = nm_dbus_manager_get_connection (priv->dbus_manager);
priv->dbus_path = g_strdup_printf (NM_DBUS_PATH "/PPP/%d", counter++);
dbus_g_connection_register_g_object (connection, priv->dbus_path, object);
return object;
}
static void
cancel_get_secrets (NMPPPManager *self)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
if (priv->secrets_id) {
nm_act_request_cancel_secrets (priv->act_req, priv->secrets_id);
priv->secrets_id = 0;
}
}
static void
remove_timeout_handler (NMPPPManager *manager)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
if (priv->ppp_timeout_handler) {
g_source_remove (priv->ppp_timeout_handler);
priv->ppp_timeout_handler = 0;
}
}
static void
finalize (GObject *object)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (object);
g_free (priv->ip_iface);
g_free (priv->parent_iface);
G_OBJECT_CLASS (nm_ppp_manager_parent_class)->finalize (object);
}
static void
cancel_get_secrets (NMPPPManager *self)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
if (priv->secrets_id)
nm_act_request_cancel_secrets (priv->act_req, priv->secrets_id);
g_return_if_fail (!priv->secrets_id && !priv->secrets_setting_name);
}
static void
dispose (GObject *object)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (object);
_ppp_cleanup (NM_PPP_MANAGER (object));
_ppp_kill (NM_PPP_MANAGER (object));
g_clear_object (&priv->act_req);
G_OBJECT_CLASS (nm_ppp_manager_parent_class)->dispose (object);
}
static void
impl_ppp_manager_need_secrets (NMPPPManager *manager,
DBusGMethodInvocation *context)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
NMConnection *connection;
const char *setting_name;
const char *username = NULL;
const char *password = NULL;
guint32 tries;
GPtrArray *hints = NULL;
GError *error = NULL;
NMSettingsGetSecretsFlags flags = NM_SETTINGS_GET_SECRETS_FLAG_ALLOW_INTERACTION;
connection = nm_act_request_get_connection (priv->act_req);
nm_connection_clear_secrets (connection);
setting_name = nm_connection_need_secrets (connection, &hints);
if (!setting_name) {
/* Use existing secrets from the connection */
if (extract_details_from_connection (connection, &username, &password, &error)) {
/* Send existing secrets to the PPP plugin */
priv->pending_secrets_context = context;
ppp_secrets_cb (priv->act_req, priv->secrets_id, connection, NULL, manager);
} else {
nm_log_warn (LOGD_PPP, "%s", error->message);
dbus_g_method_return_error (priv->pending_secrets_context, error);
g_clear_error (&error);
}
return;
}
/* Only ask for completely new secrets after retrying them once; some devices
* appear to ask a few times when they actually don't even care what you
* pass back.
*/
tries = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (connection), PPP_MANAGER_SECRET_TRIES));
if (tries > 1)
flags |= NM_SETTINGS_GET_SECRETS_FLAG_REQUEST_NEW;
priv->secrets_id = nm_act_request_get_secrets (priv->act_req,
setting_name,
flags,
hints ? g_ptr_array_index (hints, 0) : NULL,
ppp_secrets_cb,
manager);
g_object_set_data (G_OBJECT (connection), PPP_MANAGER_SECRET_TRIES, GUINT_TO_POINTER (++tries));
priv->pending_secrets_context = context;
if (hints)
g_ptr_array_free (hints, TRUE);
}
static void
_ppp_kill (NMPPPManager *manager)
{
NMPPPManagerPrivate *priv;
g_return_if_fail (NM_IS_PPP_MANAGER (manager));
priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
if (priv->pid) {
nm_utils_kill_child_async (priv->pid, SIGTERM, LOGD_PPP, "pppd", 2000, NULL, NULL);
priv->pid = 0;
}
}
static void
ppp_secrets_cb (NMActRequest *req,
NMActRequestGetSecretsCallId call_id,
NMSettingsConnection *settings_connection, /* unused (we pass NULL here) */
GError *error,
gpointer user_data)
{
NMPPPManager *self = NM_PPP_MANAGER (user_data);
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
const char *username = NULL;
const char *password = NULL;
GError *local = NULL;
NMConnection *applied_connection;
g_return_if_fail (priv->pending_secrets_context != NULL);
g_return_if_fail (req == priv->act_req);
g_return_if_fail (call_id == priv->secrets_id);
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
goto out;
if (error) {
_LOGW ("%s", error->message);
g_dbus_method_invocation_return_gerror (priv->pending_secrets_context, error);
goto out;
}
applied_connection = nm_act_request_get_applied_connection (req);
if (!extract_details_from_connection (applied_connection, priv->secrets_setting_name, &username, &password, &local)) {
_LOGW ("%s", local->message);
g_dbus_method_invocation_take_error (priv->pending_secrets_context, local);
goto out;
}
/* This is sort of a hack but...
* pppd plugin only ever needs username and password. Passing the full
* connection there would mean some bloat: the plugin would need to link
* against libnm just to parse this. So instead, let's just send what
* it needs.
*/
g_dbus_method_invocation_return_value (
priv->pending_secrets_context,
g_variant_new ("(ss)", username ? username : "", password ? password : ""));
out:
priv->pending_secrets_context = NULL;
priv->secrets_id = NULL;
priv->secrets_setting_name = NULL;
}
static void
monitor_stats (NMPPPManager *manager)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
priv->monitor_fd = socket (AF_INET, SOCK_DGRAM, 0);
if (priv->monitor_fd > 0) {
g_warn_if_fail (priv->monitor_id == 0);
if (priv->monitor_id)
g_source_remove (priv->monitor_id);
priv->monitor_id = g_timeout_add_seconds (5, monitor_cb, manager);
} else
nm_log_warn (LOGD_PPP, "could not monitor PPP stats: %s", strerror (errno));
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (object);
switch (prop_id) {
case PROP_PARENT_IFACE:
g_value_set_string (value, priv->parent_iface);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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);
if (priv->monitor_id) {
g_source_remove (priv->monitor_id);
priv->monitor_id = 0;
}
if (priv->monitor_fd) {
/* Get the stats one last time */
monitor_cb (manager);
close (priv->monitor_fd);
priv->monitor_fd = 0;
}
if (priv->ppp_timeout_handler) {
g_source_remove (priv->ppp_timeout_handler);
priv->ppp_timeout_handler = 0;
}
if (priv->ppp_watch_id) {
g_source_remove (priv->ppp_watch_id);
priv->ppp_watch_id = 0;
}
if (priv->pid) {
if (kill (priv->pid, SIGTERM) == 0)
g_timeout_add_seconds (2, ensure_killed, GINT_TO_POINTER (priv->pid));
else {
kill (priv->pid, SIGKILL);
/* ensure the child is reaped */
nm_log_dbg (LOGD_PPP, "waiting for pppd pid %d to exit", priv->pid);
waitpid (priv->pid, NULL, 0);
nm_log_dbg (LOGD_PPP, "pppd pid %d cleaned up", priv->pid);
}
priv->pid = 0;
}
}
static void
ppp_secrets_cb (NMActRequest *req,
guint32 call_id,
NMConnection *connection,
GError *error,
gpointer user_data)
{
NMPPPManager *self = NM_PPP_MANAGER (user_data);
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
const char *username = NULL;
const char *password = NULL;
GError *local = NULL;
g_return_if_fail (priv->pending_secrets_context != NULL);
g_return_if_fail (req == priv->act_req);
g_return_if_fail (call_id == priv->secrets_id);
if (error) {
nm_log_warn (LOGD_PPP, "%s", error->message);
dbus_g_method_return_error (priv->pending_secrets_context, error);
goto out;
}
if (!extract_details_from_connection (connection, &username, &password, &local)) {
nm_log_warn (LOGD_PPP, "%s", local->message);
dbus_g_method_return_error (priv->pending_secrets_context, local);
g_clear_error (&local);
goto out;
}
/* This is sort of a hack but...
* pppd plugin only ever needs username and password. Passing the full
* connection there would mean some bloat: the plugin would need to link
* against libnm-util just to parse this. So instead, let's just send what
* it needs.
*/
dbus_g_method_return (priv->pending_secrets_context, username, password);
out:
priv->pending_secrets_context = NULL;
priv->secrets_id = 0;
}
static void
dispose (GObject *object)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (object);
if (priv->disposed == FALSE) {
priv->disposed = TRUE;
_ppp_cleanup (NM_PPP_MANAGER (object));
if (priv->act_req) {
g_object_unref (priv->act_req);
priv->act_req = NULL;
}
g_object_unref (priv->dbus_manager);
priv->dbus_manager = NULL;
}
G_OBJECT_CLASS (nm_ppp_manager_parent_class)->dispose (object);
}
static gboolean
monitor_cb (gpointer user_data)
{
NMPPPManager *manager = NM_PPP_MANAGER (user_data);
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
struct ifpppstatsreq req;
memset (&req, 0, sizeof (req));
req.stats_ptr = (caddr_t) &req.stats;
strncpy (req.ifr__name, priv->ip_iface, sizeof (req.ifr__name));
if (ioctl (priv->monitor_fd, SIOCGPPPSTATS, &req) < 0) {
nm_log_warn (LOGD_PPP, "could not read ppp stats: %s", strerror (errno));
} else {
g_signal_emit (manager, signals[STATS], 0,
req.stats.p.ppp_ibytes,
req.stats.p.ppp_obytes);
}
return TRUE;
}
void
nm_ppp_manager_stop (NMPPPManager *manager,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
StopContext *ctx;
ctx = g_slice_new0 (StopContext);
ctx->manager = g_object_ref (manager);
ctx->result = g_simple_async_result_new (G_OBJECT (manager),
callback,
user_data,
nm_ppp_manager_stop);
/* Setup cancellable */
ctx->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
if (stop_context_complete_if_cancelled (ctx))
return;
/* Cleanup internals */
_ppp_cleanup (manager);
/* If no pppd running, we're done */
if (!priv->pid) {
stop_context_complete (ctx);
return;
}
/* No cancellable operation, so just wait until it returns always */
nm_utils_kill_child_async (priv->pid,
SIGTERM,
LOGD_PPP,
"pppd",
2000,
(NMUtilsKillChildAsyncCb) kill_child_ready,
ctx);
priv->pid = 0;
}
static void
impl_ppp_manager_set_ip6_config (NMPPPManager *manager,
GDBusMethodInvocation *context,
GVariant *config_dict)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
NMIP6Config *config;
NMPlatformIP6Address addr;
struct in6_addr a;
NMUtilsIPv6IfaceId iid = NM_UTILS_IPV6_IFACE_ID_INIT;
_LOGI ("(IPv6 Config Get) reply received.");
remove_timeout_handler (manager);
config = nm_ip6_config_new (nm_platform_link_get_ifindex (NM_PLATFORM_GET, priv->ip_iface));
memset (&addr, 0, sizeof (addr));
addr.plen = 64;
if (iid_value_to_ll6_addr (config_dict, NM_PPP_IP6_CONFIG_PEER_IID, &a, NULL)) {
nm_ip6_config_set_gateway (config, &a);
addr.peer_address = a;
}
if (iid_value_to_ll6_addr (config_dict, NM_PPP_IP6_CONFIG_OUR_IID, &addr.address, &iid)) {
nm_ip6_config_add_address (config, &addr);
if (set_ip_config_common (manager, config_dict, NM_PPP_IP6_CONFIG_INTERFACE, NULL)) {
/* Push the IPv6 config and interface identifier up to the device */
g_signal_emit (manager, signals[IP6_CONFIG], 0, priv->ip_iface, &iid, config);
}
} else
_LOGE ("invalid IPv6 address received!");
g_object_unref (config);
g_dbus_method_invocation_return_value (context, NULL);
}
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 gboolean
monitor_cb (gpointer user_data)
{
NMPPPManager *manager = NM_PPP_MANAGER (user_data);
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
struct ifreq req;
struct ppp_stats stats;
memset (&req, 0, sizeof (req));
memset (&stats, 0, sizeof (stats));
req.ifr_data = (caddr_t) &stats;
strncpy (req.ifr_name, priv->ip_iface, sizeof (req.ifr_name));
if (ioctl (priv->monitor_fd, SIOCGPPPSTATS, &req) < 0) {
if (errno != ENODEV)
_LOGW ("could not read ppp stats: %s", strerror (errno));
} else {
g_signal_emit (manager, signals[STATS], 0,
stats.p.ppp_ibytes,
stats.p.ppp_obytes);
}
return TRUE;
}
static NMCmdLine *
create_pppd_cmd_line (NMPPPManager *self,
NMSettingPpp *setting,
NMSettingPppoe *pppoe,
NMSettingAdsl *adsl,
const char *ppp_name,
GError **err)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
const char *pppd_binary = NULL;
NMCmdLine *cmd;
gboolean ppp_debug;
g_return_val_if_fail (setting != NULL, NULL);
pppd_binary = nm_utils_find_helper ("pppd", NULL, err);
if (!pppd_binary)
return NULL;
/* Create pppd command line */
cmd = nm_cmd_line_new ();
nm_cmd_line_add_string (cmd, pppd_binary);
nm_cmd_line_add_string (cmd, "nodetach");
nm_cmd_line_add_string (cmd, "lock");
/* NM handles setting the default route */
nm_cmd_line_add_string (cmd, "nodefaultroute");
/* Allow IPv6 to be configured by IPV6CP */
nm_cmd_line_add_string (cmd, "ipv6");
nm_cmd_line_add_string (cmd, ",");
ppp_debug = !!getenv ("NM_PPP_DEBUG");
if (nm_logging_enabled (LOGL_DEBUG, LOGD_PPP))
ppp_debug = TRUE;
if (ppp_debug)
nm_cmd_line_add_string (cmd, "debug");
if (ppp_name) {
nm_cmd_line_add_string (cmd, "user");
nm_cmd_line_add_string (cmd, ppp_name);
}
if (pppoe) {
char *dev_str;
const char *pppoe_service;
nm_cmd_line_add_string (cmd, "plugin");
nm_cmd_line_add_string (cmd, "rp-pppoe.so");
dev_str = g_strdup_printf ("nic-%s", priv->parent_iface);
nm_cmd_line_add_string (cmd, dev_str);
g_free (dev_str);
pppoe_service = nm_setting_pppoe_get_service (pppoe);
if (pppoe_service) {
nm_cmd_line_add_string (cmd, "rp_pppoe_service");
nm_cmd_line_add_string (cmd, pppoe_service);
}
} else if (adsl) {
const gchar *protocol = nm_setting_adsl_get_protocol (adsl);
if (!strcmp (protocol, NM_SETTING_ADSL_PROTOCOL_PPPOA)) {
guint32 vpi = nm_setting_adsl_get_vpi (adsl);
guint32 vci = nm_setting_adsl_get_vci (adsl);
const char *encaps = nm_setting_adsl_get_encapsulation (adsl);
gchar *vpivci;
nm_cmd_line_add_string (cmd, "plugin");
nm_cmd_line_add_string (cmd, "pppoatm.so");
vpivci = g_strdup_printf("%d.%d", vpi, vci);
nm_cmd_line_add_string (cmd, vpivci);
g_free (vpivci);
if (g_strcmp0 (encaps, NM_SETTING_ADSL_ENCAPSULATION_LLC) == 0)
nm_cmd_line_add_string (cmd, "llc-encaps");
else /*if (g_strcmp0 (encaps, NM_SETTING_ADSL_ENCAPSULATION_VCMUX) == 0)*/
nm_cmd_line_add_string (cmd, "vc-encaps");
} else if (!strcmp (protocol, NM_SETTING_ADSL_PROTOCOL_PPPOE)) {
nm_cmd_line_add_string (cmd, "plugin");
nm_cmd_line_add_string (cmd, "rp-pppoe.so");
nm_cmd_line_add_string (cmd, priv->parent_iface);
}
nm_cmd_line_add_string (cmd, "noipdefault");
} else {
nm_cmd_line_add_string (cmd, priv->parent_iface);
/* Don't send some random address as the local address */
nm_cmd_line_add_string (cmd, "noipdefault");
}
if (nm_setting_ppp_get_baud (setting))
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_baud (setting));
/* noauth by default, because we certainly don't have any information
* with which to verify anything the peer gives us if we ask it to
* authenticate itself, which is what 'auth' really means.
*/
nm_cmd_line_add_string (cmd, "noauth");
if (nm_setting_ppp_get_refuse_eap (setting))
nm_cmd_line_add_string (cmd, "refuse-eap");
if (nm_setting_ppp_get_refuse_pap (setting))
nm_cmd_line_add_string (cmd, "refuse-pap");
if (nm_setting_ppp_get_refuse_chap (setting))
nm_cmd_line_add_string (cmd, "refuse-chap");
if (nm_setting_ppp_get_refuse_mschap (setting))
nm_cmd_line_add_string (cmd, "refuse-mschap");
if (nm_setting_ppp_get_refuse_mschapv2 (setting))
nm_cmd_line_add_string (cmd, "refuse-mschap-v2");
if (nm_setting_ppp_get_nobsdcomp (setting))
nm_cmd_line_add_string (cmd, "nobsdcomp");
if (nm_setting_ppp_get_no_vj_comp (setting))
nm_cmd_line_add_string (cmd, "novj");
if (nm_setting_ppp_get_nodeflate (setting))
nm_cmd_line_add_string (cmd, "nodeflate");
if (nm_setting_ppp_get_require_mppe (setting))
nm_cmd_line_add_string (cmd, "require-mppe");
if (nm_setting_ppp_get_require_mppe_128 (setting))
nm_cmd_line_add_string (cmd, "require-mppe-128");
if (nm_setting_ppp_get_mppe_stateful (setting))
nm_cmd_line_add_string (cmd, "mppe-stateful");
if (nm_setting_ppp_get_crtscts (setting))
nm_cmd_line_add_string (cmd, "crtscts");
/* Always ask for DNS, we don't have to use them if the connection
* overrides the returned servers.
*/
nm_cmd_line_add_string (cmd, "usepeerdns");
if (nm_setting_ppp_get_mru (setting)) {
nm_cmd_line_add_string (cmd, "mru");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_mru (setting));
}
if (nm_setting_ppp_get_mtu (setting)) {
nm_cmd_line_add_string (cmd, "mtu");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_mtu (setting));
}
nm_cmd_line_add_string (cmd, "lcp-echo-failure");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_lcp_echo_failure (setting));
nm_cmd_line_add_string (cmd, "lcp-echo-interval");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_lcp_echo_interval (setting));
/* Avoid pppd to exit if no traffic going through */
nm_cmd_line_add_string (cmd, "idle");
nm_cmd_line_add_int (cmd, 0);
nm_cmd_line_add_string (cmd, "ipparam");
nm_cmd_line_add_string (cmd, nm_exported_object_get_path (NM_EXPORTED_OBJECT (self)));
nm_cmd_line_add_string (cmd, "plugin");
nm_cmd_line_add_string (cmd, NM_PPPD_PLUGIN);
return cmd;
}
static gboolean
impl_ppp_manager_set_ip4_config (NMPPPManager *manager,
GHashTable *config_hash,
GError **err)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
NMConnection *connection;
NMSettingPPP *s_ppp;
NMIP4Config *config;
NMIP4Address *addr;
GValue *val;
int i;
nm_log_info (LOGD_PPP, "PPP manager(IP Config Get) reply received.");
remove_timeout_handler (manager);
config = nm_ip4_config_new ();
addr = nm_ip4_address_new ();
nm_ip4_address_set_prefix (addr, 32);
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_GATEWAY);
if (val) {
nm_ip4_address_set_gateway (addr, g_value_get_uint (val));
nm_ip4_config_set_ptp_address (config, g_value_get_uint (val));
}
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_ADDRESS);
if (val)
nm_ip4_address_set_address (addr, g_value_get_uint (val));
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_PREFIX);
if (val)
nm_ip4_address_set_prefix (addr, g_value_get_uint (val));
if (nm_ip4_address_get_address (addr) && nm_ip4_address_get_prefix (addr)) {
nm_ip4_config_take_address (config, addr);
} else {
nm_log_err (LOGD_PPP, "invalid IPv4 address received!");
nm_ip4_address_unref (addr);
goto out;
}
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_DNS);
if (val) {
GArray *dns = (GArray *) g_value_get_boxed (val);
for (i = 0; i < dns->len; i++)
nm_ip4_config_add_nameserver (config, g_array_index (dns, guint, i));
}
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_WINS);
if (val) {
GArray *wins = (GArray *) g_value_get_boxed (val);
for (i = 0; i < wins->len; i++)
nm_ip4_config_add_wins (config, g_array_index (wins, guint, i));
}
val = (GValue *) g_hash_table_lookup (config_hash, NM_PPP_IP4_CONFIG_INTERFACE);
if (!val || !G_VALUE_HOLDS_STRING (val)) {
nm_log_err (LOGD_PPP, "no interface received!");
goto out;
}
priv->ip_iface = g_value_dup_string (val);
/* Got successful IP4 config; obviously the secrets worked */
connection = nm_act_request_get_connection (priv->act_req);
g_assert (connection);
g_object_set_data (G_OBJECT (connection), PPP_MANAGER_SECRET_TRIES, NULL);
/* Merge in custom MTU */
s_ppp = (NMSettingPPP *) nm_connection_get_setting (connection, NM_TYPE_SETTING_PPP);
if (s_ppp) {
guint32 mtu = nm_setting_ppp_get_mtu (s_ppp);
if (mtu)
nm_ip4_config_set_mtu (config, mtu);
}
/* Push the IP4 config up to the device */
g_signal_emit (manager, signals[IP4_CONFIG], 0, priv->ip_iface, config);
monitor_stats (manager);
out:
g_object_unref (config);
return TRUE;
}
static NMCmdLine *
create_pppd_cmd_line (NMPPPManager *self,
NMSettingPPP *setting,
NMSettingPPPOE *pppoe,
const char *ppp_name,
GError **err)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
const char *ppp_binary;
NMCmdLine *cmd;
gboolean ppp_debug;
g_return_val_if_fail (setting != NULL, NULL);
ppp_binary = nm_find_pppd ();
if (!ppp_binary) {
g_set_error (err, NM_PPP_MANAGER_ERROR, NM_PPP_MANAGER_ERROR,
"Could not find ppp binary.");
return NULL;
}
/* Create pppd command line */
cmd = nm_cmd_line_new ();
nm_cmd_line_add_string (cmd, ppp_binary);
nm_cmd_line_add_string (cmd, "nodetach");
nm_cmd_line_add_string (cmd, "lock");
/* NM handles setting the default route */
nm_cmd_line_add_string (cmd, "nodefaultroute");
ppp_debug = !!getenv ("NM_PPP_DEBUG");
if ( nm_logging_level_enabled (LOGL_DEBUG)
&& nm_logging_domain_enabled (LOGD_PPP))
ppp_debug = TRUE;
if (ppp_debug)
nm_cmd_line_add_string (cmd, "debug");
if (ppp_name) {
nm_cmd_line_add_string (cmd, "user");
nm_cmd_line_add_string (cmd, ppp_name);
}
if (pppoe) {
char *dev_str;
const char *pppoe_service;
nm_cmd_line_add_string (cmd, "plugin");
nm_cmd_line_add_string (cmd, "rp-pppoe.so");
dev_str = g_strdup_printf ("nic-%s", priv->parent_iface);
nm_cmd_line_add_string (cmd, dev_str);
g_free (dev_str);
pppoe_service = nm_setting_pppoe_get_service (pppoe);
if (pppoe_service) {
nm_cmd_line_add_string (cmd, "rp_pppoe_service");
nm_cmd_line_add_string (cmd, pppoe_service);
}
} else {
nm_cmd_line_add_string (cmd, priv->parent_iface);
/* Don't send some random address as the local address */
nm_cmd_line_add_string (cmd, "noipdefault");
}
if (nm_setting_ppp_get_baud (setting))
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_baud (setting));
/* noauth by default, because we certainly don't have any information
* with which to verify anything the peer gives us if we ask it to
* authenticate itself, which is what 'auth' really means.
*/
nm_cmd_line_add_string (cmd, "noauth");
if (nm_setting_ppp_get_refuse_eap (setting))
nm_cmd_line_add_string (cmd, "refuse-eap");
if (nm_setting_ppp_get_refuse_pap (setting))
nm_cmd_line_add_string (cmd, "refuse-pap");
if (nm_setting_ppp_get_refuse_chap (setting))
nm_cmd_line_add_string (cmd, "refuse-chap");
if (nm_setting_ppp_get_refuse_mschap (setting))
nm_cmd_line_add_string (cmd, "refuse-mschap");
if (nm_setting_ppp_get_refuse_mschapv2 (setting))
nm_cmd_line_add_string (cmd, "refuse-mschap-v2");
if (nm_setting_ppp_get_nobsdcomp (setting))
nm_cmd_line_add_string (cmd, "nobsdcomp");
if (nm_setting_ppp_get_no_vj_comp (setting))
nm_cmd_line_add_string (cmd, "novj");
if (nm_setting_ppp_get_nodeflate (setting))
nm_cmd_line_add_string (cmd, "nodeflate");
if (nm_setting_ppp_get_require_mppe (setting))
nm_cmd_line_add_string (cmd, "require-mppe");
if (nm_setting_ppp_get_require_mppe_128 (setting))
nm_cmd_line_add_string (cmd, "require-mppe-128");
if (nm_setting_ppp_get_mppe_stateful (setting))
nm_cmd_line_add_string (cmd, "mppe-stateful");
if (nm_setting_ppp_get_crtscts (setting))
nm_cmd_line_add_string (cmd, "crtscts");
/* Always ask for DNS, we don't have to use them if the connection
* overrides the returned servers.
*/
nm_cmd_line_add_string (cmd, "usepeerdns");
if (nm_setting_ppp_get_mru (setting)) {
nm_cmd_line_add_string (cmd, "mru");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_mru (setting));
}
if (nm_setting_ppp_get_mtu (setting)) {
nm_cmd_line_add_string (cmd, "mtu");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_mtu (setting));
}
nm_cmd_line_add_string (cmd, "lcp-echo-failure");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_lcp_echo_failure (setting));
nm_cmd_line_add_string (cmd, "lcp-echo-interval");
nm_cmd_line_add_int (cmd, nm_setting_ppp_get_lcp_echo_interval (setting));
nm_cmd_line_add_string (cmd, "ipparam");
nm_cmd_line_add_string (cmd, priv->dbus_path);
nm_cmd_line_add_string (cmd, "plugin");
nm_cmd_line_add_string (cmd, NM_PPPD_PLUGIN);
return cmd;
}
static void
impl_ppp_manager_set_ip4_config (NMPPPManager *manager,
GDBusMethodInvocation *context,
GVariant *config_dict)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
NMIP4Config *config;
NMPlatformIP4Address address;
guint32 u32;
GVariantIter *iter;
_LOGI ("(IPv4 Config Get) reply received.");
remove_timeout_handler (manager);
config = nm_ip4_config_new (nm_platform_link_get_ifindex (NM_PLATFORM_GET, priv->ip_iface));
memset (&address, 0, sizeof (address));
address.plen = 32;
if (g_variant_lookup (config_dict, NM_PPP_IP4_CONFIG_ADDRESS, "u", &u32))
address.address = u32;
if (g_variant_lookup (config_dict, NM_PPP_IP4_CONFIG_GATEWAY, "u", &u32)) {
nm_ip4_config_set_gateway (config, u32);
address.peer_address = u32;
} else
address.peer_address = address.address;
if (g_variant_lookup (config_dict, NM_PPP_IP4_CONFIG_PREFIX, "u", &u32))
address.plen = u32;
if (address.address && address.plen) {
address.source = NM_IP_CONFIG_SOURCE_PPP;
nm_ip4_config_add_address (config, &address);
} else {
_LOGE ("invalid IPv4 address received!");
goto out;
}
if (g_variant_lookup (config_dict, NM_PPP_IP4_CONFIG_DNS, "au", &iter)) {
while (g_variant_iter_next (iter, "u", &u32))
nm_ip4_config_add_nameserver (config, u32);
g_variant_iter_free (iter);
}
if (g_variant_lookup (config_dict, NM_PPP_IP4_CONFIG_WINS, "au", &iter)) {
while (g_variant_iter_next (iter, "u", &u32))
nm_ip4_config_add_wins (config, u32);
g_variant_iter_free (iter);
}
if (!set_ip_config_common (manager, config_dict, NM_PPP_IP4_CONFIG_INTERFACE, &u32))
goto out;
if (u32)
nm_ip4_config_set_mtu (config, u32, NM_IP_CONFIG_SOURCE_PPP);
/* Push the IP4 config up to the device */
g_signal_emit (manager, signals[IP4_CONFIG], 0, priv->ip_iface, config);
out:
g_object_unref (config);
g_dbus_method_invocation_return_value (context, NULL);
}
gboolean
nm_ppp_manager_start (NMPPPManager *manager,
NMActRequest *req,
const char *ppp_name,
guint32 timeout_secs,
GError **err)
{
NMPPPManagerPrivate *priv;
NMConnection *connection;
NMSettingPpp *s_ppp;
gboolean s_ppp_created = FALSE;
NMSettingPppoe *pppoe_setting;
NMSettingAdsl *adsl_setting;
NMCmdLine *ppp_cmd;
char *cmd_str;
struct stat st;
g_return_val_if_fail (NM_IS_PPP_MANAGER (manager), FALSE);
g_return_val_if_fail (NM_IS_ACT_REQUEST (req), FALSE);
priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
#if !WITH_PPP
/* PPP support disabled */
g_set_error_literal (err,
NM_MANAGER_ERROR,
NM_MANAGER_ERROR_FAILED,
"PPP support is not enabled.");
return FALSE;
#endif
priv->pid = 0;
/* Make sure /dev/ppp exists (bgo #533064) */
if (stat ("/dev/ppp", &st) || !S_ISCHR (st.st_mode))
nm_utils_modprobe (NULL, FALSE, "ppp_generic", NULL);
connection = nm_act_request_get_applied_connection (req);
g_assert (connection);
s_ppp = nm_connection_get_setting_ppp (connection);
if (!s_ppp) {
/* If the PPP settings are all default we may not have a PPP setting yet,
* so just make a default one here.
*/
s_ppp = NM_SETTING_PPP (nm_setting_ppp_new ());
s_ppp_created = TRUE;
}
pppoe_setting = nm_connection_get_setting_pppoe (connection);
if (pppoe_setting)
pppoe_fill_defaults (s_ppp);
adsl_setting = (NMSettingAdsl *) nm_connection_get_setting (connection, NM_TYPE_SETTING_ADSL);
ppp_cmd = create_pppd_cmd_line (manager, s_ppp, pppoe_setting, adsl_setting, ppp_name, err);
if (!ppp_cmd)
goto out;
g_ptr_array_add (ppp_cmd->array, NULL);
_LOGI ("starting PPP connection");
cmd_str = nm_cmd_line_to_str (ppp_cmd);
_LOGD ("command line: %s", cmd_str);
g_free (cmd_str);
priv->pid = 0;
if (!g_spawn_async (NULL, (char **) ppp_cmd->array->pdata, NULL,
G_SPAWN_DO_NOT_REAP_CHILD,
nm_utils_setpgid, NULL,
&priv->pid, err)) {
goto out;
}
_LOGI ("pppd started with pid %d", priv->pid);
priv->ppp_watch_id = g_child_watch_add (priv->pid, (GChildWatchFunc) ppp_watch_cb, manager);
priv->ppp_timeout_handler = g_timeout_add_seconds (timeout_secs, pppd_timed_out, manager);
priv->act_req = g_object_ref (req);
out:
if (s_ppp_created)
g_object_unref (s_ppp);
if (ppp_cmd)
nm_cmd_line_destroy (ppp_cmd);
return priv->pid > 0;
}
static void
nm_ppp_manager_init (NMPPPManager *manager)
{
NM_PPP_MANAGER_GET_PRIVATE (manager)->monitor_fd = -1;
}