src/mm-dispatcher.c - chromiumos/third_party/modemmanager-next - Git at Google

 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details:
  *
  * Copyright (C) 2021-2022 Aleksander Morgado <aleksander@aleksander.es>
  */

 #include <config.h>
 #include <sys/stat.h>

 #include <ModemManager.h>
 #include "mm-errors-types.h"
 #include "mm-utils.h"
 #include "mm-log-object.h"
 #include "mm-dispatcher.h"

 static void log_object_iface_init (MMLogObjectInterface *iface);

 G_DEFINE_TYPE_EXTENDED (MMDispatcher, mm_dispatcher, G_TYPE_OBJECT, 0,
                         G_IMPLEMENT_INTERFACE (MM_TYPE_LOG_OBJECT, log_object_iface_init))

 enum {
     PROP_0,
     PROP_OPERATION_DESCRIPTION,
     PROP_LAST
 };

 static GParamSpec *properties[PROP_LAST];

 struct _MMDispatcherPrivate {
     gchar               *operation_description;
     GSubprocessLauncher *launcher;
 };

 /*****************************************************************************/

 static gchar *
 log_object_build_id (MMLogObject *_self)
 {
     MMDispatcher *self = MM_DISPATCHER (_self);

     return g_strdup_printf ("%s dispatcher", self->priv->operation_description);
 }

 /*****************************************************************************/

 static gboolean
 validate_file (const gchar  *path,
                GError      **error)
 {
     g_autoptr(GFile)     file = NULL;
     g_autoptr(GFileInfo) file_info = NULL;
     guint32              file_mode;
     guint32              file_uid;

     file = g_file_new_for_path (path);
     file_info = g_file_query_info (file,
                                    (G_FILE_ATTRIBUTE_STANDARD_SIZE           ","
                                     G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET ","
                                     G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK     ","
                                     G_FILE_ATTRIBUTE_UNIX_MODE               ","
                                     G_FILE_ATTRIBUTE_UNIX_UID),
                                    G_FILE_QUERY_INFO_NONE,
                                    NULL,
                                    error);
     if (!file_info)
         return FALSE;

     if (g_file_info_get_is_symlink (file_info)) {
         const gchar *link_target;

         link_target = g_file_info_get_symlink_target (file_info);
         if (g_strcmp0 (link_target, "/dev/null") == 0) {
             g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
                          "Link '%s' to /dev/null is not executable", path);
             return FALSE;
         }
     }

     if (g_file_info_get_size (file_info) == 0) {
         g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
                      "File '%s' is empty", path);
         return FALSE;
     }

     file_uid = g_file_info_get_attribute_uint32 (file_info, G_FILE_ATTRIBUTE_UNIX_UID);
     if (file_uid != 0) {
         g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
                      "File '%s' not owned by root", path);
         return FALSE;
     }

     file_mode = g_file_info_get_attribute_uint32 (file_info, G_FILE_ATTRIBUTE_UNIX_MODE);
     if (!S_ISREG (file_mode)) {
         g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
                      "File '%s' is not regular", path);
         return FALSE;
     }
     if (file_mode & (S_IWGRP | S_IWOTH)) {
         g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
                      "File '%s' is writable by group or other", path);
         return FALSE;
     }
     if (file_mode & S_ISUID) {
         g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
                      "File '%s' is set-UID", path);
         return FALSE;
     }
     if (!(file_mode & S_IXUSR)) {
         g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
                      "File '%s' is not executable by the owner", path);
         return FALSE;
     }

     return TRUE;
 }

 /*****************************************************************************/

 typedef struct {
     GSubprocess *subprocess;
     guint        timeout_id;
 } RunContext;

 static void
 run_context_free (RunContext *ctx)
 {
     g_assert (!ctx->timeout_id);
     g_clear_object (&ctx->subprocess);
     g_slice_free (RunContext, ctx);
 }

 gboolean
 mm_dispatcher_run_finish (MMDispatcher  *self,
                           GAsyncResult  *res,
                           GError       **error)
 {
     return g_task_propagate_boolean (G_TASK (res), error);
 }

 static gboolean
 subprocess_wait_timed_out (GTask *task)
 {
     MMDispatcher *self;
     RunContext   *ctx;

     self = g_task_get_source_object (task);
     ctx = g_task_get_task_data (task);

     mm_obj_warn (self, "forcing exit on %s operation", self->priv->operation_description);
     g_subprocess_force_exit (ctx->subprocess);

     ctx->timeout_id = 0;
     return G_SOURCE_REMOVE;
 }

 static void
 subprocess_wait_ready (GSubprocess  *subprocess,
                        GAsyncResult *res,
                        GTask        *task)
 {
     GError       *error = NULL;
     MMDispatcher *self;
     RunContext   *ctx;

     self = g_task_get_source_object (task);
     ctx = g_task_get_task_data (task);

     /* cleanup timeout before any return */
     if (ctx->timeout_id) {
         g_source_remove (ctx->timeout_id);
         ctx->timeout_id = 0;
     }

     if (!g_subprocess_wait_finish (subprocess, res, &error)) {
         g_prefix_error (&error, "%s operation wait failed: ", self->priv->operation_description);
         g_task_return_error (task, error);
     } else if (!g_subprocess_get_successful (subprocess)) {
         if (g_subprocess_get_if_signaled (subprocess))
             g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
                                      "%s operation aborted with signal %d",
                                      self->priv->operation_description,
                                      g_subprocess_get_term_sig (subprocess));
         else if (g_subprocess_get_if_exited (subprocess))
             g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
                                      "%s operation finished with status %d",
                                      self->priv->operation_description,
                                      g_subprocess_get_exit_status (subprocess));
         else
             g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
                                      "%s operation failed", self->priv->operation_description);
     } else
         g_task_return_boolean (task, TRUE);
     g_object_unref (task);
 }

 void
 mm_dispatcher_run (MMDispatcher        *self,
                    const GStrv          argv,
                    guint                timeout_secs,
                    GCancellable        *cancellable,
                    GAsyncReadyCallback  callback,
                    gpointer             user_data)
 {
     GTask      *task;
     RunContext *ctx;
     GError     *error = NULL;

     g_assert (g_strv_length (argv) >= 1);

     task = g_task_new (self, cancellable, callback, user_data);
     ctx = g_slice_new0 (RunContext);
     g_task_set_task_data (task, ctx, (GDestroyNotify) run_context_free);

     /* Validation checks to see if we should run it or not */
     if (!validate_file (argv[0], &error)) {
         g_prefix_error (&error, "Cannot run %s operation from %s: ",
                         self->priv->operation_description, argv[0]);
         g_task_return_error (task, error);
         g_object_unref (task);
         return;
     }

     /* create and launch subprocess */
     ctx->subprocess = g_subprocess_launcher_spawnv (self->priv->launcher,
                                                     (const gchar * const *)argv,
                                                     &error);
     if (!ctx->subprocess) {
         g_prefix_error (&error, "%s operation launch from %s failed: ",
                         self->priv->operation_description, argv[0]);
         g_task_return_error (task, error);
         g_object_unref (task);
         return;
     }

     /* setup timeout */
     ctx->timeout_id = g_timeout_add_seconds (timeout_secs,
                                              (GSourceFunc)subprocess_wait_timed_out,
                                              task);

     /* wait for subprocess exit */
     g_subprocess_wait_async (ctx->subprocess,
                              cancellable,
                              (GAsyncReadyCallback)subprocess_wait_ready,
                              task);
 }

 /*****************************************************************************/

 static void
 mm_dispatcher_init (MMDispatcher *self)
 {
     /* Initialize private data */
     self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_DISPATCHER, MMDispatcherPrivate);

     /* Create launcher and inherit parent's environment */
     self->priv->launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE | G_SUBPROCESS_FLAGS_STDERR_SILENCE);
     g_subprocess_launcher_set_environ (self->priv->launcher, NULL);
 }

 static void
 set_property (GObject      *object,
               guint         prop_id,
               const GValue *value,
               GParamSpec   *pspec)
 {
     MMDispatcher *self = MM_DISPATCHER (object);

     switch (prop_id) {
     case PROP_OPERATION_DESCRIPTION:
         /* construct only */
         self->priv->operation_description = g_value_dup_string (value);
         break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
     }
 }

 static void
 get_property (GObject    *object,
               guint       prop_id,
               GValue     *value,
               GParamSpec *pspec)
 {
     MMDispatcher *self = MM_DISPATCHER (object);

     switch (prop_id) {
     case PROP_OPERATION_DESCRIPTION:
         g_value_set_string (value, self->priv->operation_description);
         break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
     }
 }

 static void
 dispose (GObject *object)
 {
     MMDispatcher *self = MM_DISPATCHER (object);

     g_clear_object (&self->priv->launcher);

     G_OBJECT_CLASS (mm_dispatcher_parent_class)->dispose (object);
 }

 static void
 finalize (GObject *object)
 {
     MMDispatcher *self = MM_DISPATCHER (object);

     g_free (self->priv->operation_description);

     G_OBJECT_CLASS (mm_dispatcher_parent_class)->finalize (object);
 }

 static void
 log_object_iface_init (MMLogObjectInterface *iface)
 {
     iface->build_id = log_object_build_id;
 }

 static void
 mm_dispatcher_class_init (MMDispatcherClass *class)
 {
     GObjectClass *object_class = G_OBJECT_CLASS (class);

     g_type_class_add_private (object_class, sizeof (MMDispatcherPrivate));

     object_class->get_property = get_property;
     object_class->set_property = set_property;
     object_class->dispose = dispose;
     object_class->finalize = finalize;

     properties[PROP_OPERATION_DESCRIPTION] =
         g_param_spec_string (MM_DISPATCHER_OPERATION_DESCRIPTION,
                              "Operation description",
                              "String describing the operation, to be used in logging",
                              NULL,
                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
     g_object_class_install_property (object_class, PROP_OPERATION_DESCRIPTION, properties[PROP_OPERATION_DESCRIPTION]);
 }
	/* -- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
	/*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details:
	*
	* Copyright (C) 2021-2022 Aleksander Morgado <aleksander@aleksander.es>
	*/

	#include <config.h>
	#include <sys/stat.h>

	#include <ModemManager.h>
	#include "mm-errors-types.h"
	#include "mm-utils.h"
	#include "mm-log-object.h"
	#include "mm-dispatcher.h"

	static void log_object_iface_init (MMLogObjectInterface *iface);

	G_DEFINE_TYPE_EXTENDED (MMDispatcher, mm_dispatcher, G_TYPE_OBJECT, 0,
	G_IMPLEMENT_INTERFACE (MM_TYPE_LOG_OBJECT, log_object_iface_init))

	enum {
	PROP_0,
	PROP_OPERATION_DESCRIPTION,
	PROP_LAST
	};

	static GParamSpec *properties[PROP_LAST];

	struct _MMDispatcherPrivate {
	gchar *operation_description;
	GSubprocessLauncher *launcher;
	};

	/*****************************************************************************/

	static gchar *
	log_object_build_id (MMLogObject *_self)
	{
	MMDispatcher *self = MM_DISPATCHER (_self);

	return g_strdup_printf ("%s dispatcher", self->priv->operation_description);
	}

	/*****************************************************************************/

	static gboolean
	validate_file (const gchar *path,
	GError **error)
	{
	g_autoptr(GFile) file = NULL;
	g_autoptr(GFileInfo) file_info = NULL;
	guint32 file_mode;
	guint32 file_uid;

	file = g_file_new_for_path (path);
	file_info = g_file_query_info (file,
	(G_FILE_ATTRIBUTE_STANDARD_SIZE ","
	G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET ","
	G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK ","
	G_FILE_ATTRIBUTE_UNIX_MODE ","
	G_FILE_ATTRIBUTE_UNIX_UID),
	G_FILE_QUERY_INFO_NONE,
	NULL,
	error);
	if (!file_info)
	return FALSE;

	if (g_file_info_get_is_symlink (file_info)) {
	const gchar *link_target;

	link_target = g_file_info_get_symlink_target (file_info);
	if (g_strcmp0 (link_target, "/dev/null") == 0) {
	g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
	"Link '%s' to /dev/null is not executable", path);
	return FALSE;
	}
	}

	if (g_file_info_get_size (file_info) == 0) {
	g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
	"File '%s' is empty", path);
	return FALSE;
	}

	file_uid = g_file_info_get_attribute_uint32 (file_info, G_FILE_ATTRIBUTE_UNIX_UID);
	if (file_uid != 0) {
	g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
	"File '%s' not owned by root", path);
	return FALSE;
	}

	file_mode = g_file_info_get_attribute_uint32 (file_info, G_FILE_ATTRIBUTE_UNIX_MODE);
	if (!S_ISREG (file_mode)) {
	g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
	"File '%s' is not regular", path);
	return FALSE;
	}
	if (file_mode & (S_IWGRP \| S_IWOTH)) {
	g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
	"File '%s' is writable by group or other", path);
	return FALSE;
	}
	if (file_mode & S_ISUID) {
	g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
	"File '%s' is set-UID", path);
	return FALSE;
	}
	if (!(file_mode & S_IXUSR)) {
	g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED,
	"File '%s' is not executable by the owner", path);
	return FALSE;
	}

	return TRUE;
	}

	/*****************************************************************************/

	typedef struct {
	GSubprocess *subprocess;
	guint timeout_id;
	} RunContext;

	static void
	run_context_free (RunContext *ctx)
	{
	g_assert (!ctx->timeout_id);
	g_clear_object (&ctx->subprocess);
	g_slice_free (RunContext, ctx);
	}

	gboolean
	mm_dispatcher_run_finish (MMDispatcher *self,
	GAsyncResult *res,
	GError **error)
	{
	return g_task_propagate_boolean (G_TASK (res), error);
	}

	static gboolean
	subprocess_wait_timed_out (GTask *task)
	{
	MMDispatcher *self;
	RunContext *ctx;

	self = g_task_get_source_object (task);
	ctx = g_task_get_task_data (task);

	mm_obj_warn (self, "forcing exit on %s operation", self->priv->operation_description);
	g_subprocess_force_exit (ctx->subprocess);

	ctx->timeout_id = 0;
	return G_SOURCE_REMOVE;
	}

	static void
	subprocess_wait_ready (GSubprocess *subprocess,
	GAsyncResult *res,
	GTask *task)
	{
	GError *error = NULL;
	MMDispatcher *self;
	RunContext *ctx;

	self = g_task_get_source_object (task);
	ctx = g_task_get_task_data (task);

	/* cleanup timeout before any return */
	if (ctx->timeout_id) {
	g_source_remove (ctx->timeout_id);
	ctx->timeout_id = 0;
	}

	if (!g_subprocess_wait_finish (subprocess, res, &error)) {
	g_prefix_error (&error, "%s operation wait failed: ", self->priv->operation_description);
	g_task_return_error (task, error);
	} else if (!g_subprocess_get_successful (subprocess)) {
	if (g_subprocess_get_if_signaled (subprocess))
	g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
	"%s operation aborted with signal %d",
	self->priv->operation_description,
	g_subprocess_get_term_sig (subprocess));
	else if (g_subprocess_get_if_exited (subprocess))
	g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
	"%s operation finished with status %d",
	self->priv->operation_description,
	g_subprocess_get_exit_status (subprocess));
	else
	g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
	"%s operation failed", self->priv->operation_description);
	} else
	g_task_return_boolean (task, TRUE);
	g_object_unref (task);
	}

	void
	mm_dispatcher_run (MMDispatcher *self,
	const GStrv argv,
	guint timeout_secs,
	GCancellable *cancellable,
	GAsyncReadyCallback callback,
	gpointer user_data)
	{
	GTask *task;
	RunContext *ctx;
	GError *error = NULL;

	g_assert (g_strv_length (argv) >= 1);

	task = g_task_new (self, cancellable, callback, user_data);
	ctx = g_slice_new0 (RunContext);
	g_task_set_task_data (task, ctx, (GDestroyNotify) run_context_free);

	/* Validation checks to see if we should run it or not */
	if (!validate_file (argv[0], &error)) {
	g_prefix_error (&error, "Cannot run %s operation from %s: ",
	self->priv->operation_description, argv[0]);
	g_task_return_error (task, error);
	g_object_unref (task);
	return;
	}

	/* create and launch subprocess */
	ctx->subprocess = g_subprocess_launcher_spawnv (self->priv->launcher,
	(const gchar * const *)argv,
	&error);
	if (!ctx->subprocess) {
	g_prefix_error (&error, "%s operation launch from %s failed: ",
	self->priv->operation_description, argv[0]);
	g_task_return_error (task, error);
	g_object_unref (task);
	return;
	}

	/* setup timeout */
	ctx->timeout_id = g_timeout_add_seconds (timeout_secs,
	(GSourceFunc)subprocess_wait_timed_out,
	task);

	/* wait for subprocess exit */
	g_subprocess_wait_async (ctx->subprocess,
	cancellable,
	(GAsyncReadyCallback)subprocess_wait_ready,
	task);
	}

	/*****************************************************************************/

	static void
	mm_dispatcher_init (MMDispatcher *self)
	{
	/* Initialize private data */
	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_DISPATCHER, MMDispatcherPrivate);

	/* Create launcher and inherit parent's environment */
	self->priv->launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE \| G_SUBPROCESS_FLAGS_STDERR_SILENCE);
	g_subprocess_launcher_set_environ (self->priv->launcher, NULL);
	}

	static void
	set_property (GObject *object,
	guint prop_id,
	const GValue *value,
	GParamSpec *pspec)
	{
	MMDispatcher *self = MM_DISPATCHER (object);

	switch (prop_id) {
	case PROP_OPERATION_DESCRIPTION:
	/* construct only */
	self->priv->operation_description = g_value_dup_string (value);
	break;
	default:
	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
	break;
	}
	}

	static void
	get_property (GObject *object,
	guint prop_id,
	GValue *value,
	GParamSpec *pspec)
	{
	MMDispatcher *self = MM_DISPATCHER (object);

	switch (prop_id) {
	case PROP_OPERATION_DESCRIPTION:
	g_value_set_string (value, self->priv->operation_description);
	break;
	default:
	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
	break;
	}
	}

	static void
	dispose (GObject *object)
	{
	MMDispatcher *self = MM_DISPATCHER (object);

	g_clear_object (&self->priv->launcher);

	G_OBJECT_CLASS (mm_dispatcher_parent_class)->dispose (object);
	}

	static void
	finalize (GObject *object)
	{
	MMDispatcher *self = MM_DISPATCHER (object);

	g_free (self->priv->operation_description);

	G_OBJECT_CLASS (mm_dispatcher_parent_class)->finalize (object);
	}

	static void
	log_object_iface_init (MMLogObjectInterface *iface)
	{
	iface->build_id = log_object_build_id;
	}

	static void
	mm_dispatcher_class_init (MMDispatcherClass *class)
	{
	GObjectClass *object_class = G_OBJECT_CLASS (class);

	g_type_class_add_private (object_class, sizeof (MMDispatcherPrivate));

	object_class->get_property = get_property;
	object_class->set_property = set_property;
	object_class->dispose = dispose;
	object_class->finalize = finalize;

	properties[PROP_OPERATION_DESCRIPTION] =
	g_param_spec_string (MM_DISPATCHER_OPERATION_DESCRIPTION,
	"Operation description",
	"String describing the operation, to be used in logging",
	NULL,
	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY);
	g_object_class_install_property (object_class, PROP_OPERATION_DESCRIPTION, properties[PROP_OPERATION_DESCRIPTION]);
	}