nm-online.c 8.73 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
2 3
/*
 * Copyright (C) 2006 - 2008 Novell, Inc.
4
 * Copyright (C) 2008 - 2014 Red Hat, Inc.
5 6
 */

Robert Love's avatar
Robert Love committed
7 8 9 10 11
/*
 * nm-online.c - Are we online?
 *
 * Return values:
 *
12 13 14
 * 0: already online or connection established within given timeout
 * 1: offline or not online within given timeout
 * 2: unspecified error
Robert Love's avatar
Robert Love committed
15 16 17 18
 *
 * Robert Love <rml@novell.com>
 */

19
#include "nm-default.h"
Robert Love's avatar
Robert Love committed
20 21 22

#include <stdio.h>
#include <stdlib.h>
23
#include <getopt.h>
24
#include <locale.h>
Robert Love's avatar
Robert Love committed
25

26 27
#include "nm-libnm-aux/nm-libnm-aux.h"

28
#define PROGRESS_STEPS 15
29

30
#define EXIT_NONE               -1
31 32 33 34
#define EXIT_FAILURE_OFFLINE     1
#define EXIT_FAILURE_ERROR       2
#define EXIT_FAILURE_LIBNM_BUG   42
#define EXIT_FAILURE_UNSPECIFIED 43
35

36
typedef struct
37
{
38 39
	GMainLoop *loop;
	NMClient *client;
40 41 42 43
	GCancellable *client_new_cancellable;
	guint client_new_timeout_id;
	guint handle_timeout_id;
	gulong client_notify_id;
44 45
	gboolean exit_no_nm;
	gboolean wait_startup;
46
	gboolean quiet;
47 48 49
	gint64 start_timestamp_ms;
	gint64 end_timestamp_ms;
	gint64 progress_step_duration;
50
	int retval;
51
} OnlineData;
52

53 54 55 56 57 58 59 60 61 62 63 64 65
static gint64
_now_ms (void)
{
	return g_get_monotonic_time () / (G_USEC_PER_SEC / 1000);
}

static void
_return (OnlineData *data, int retval)
{
	nm_assert (data);
	nm_assert (data->retval == EXIT_FAILURE_UNSPECIFIED);

	data->retval = retval;
66
	nm_clear_g_signal_handler (data->client, &data->client_notify_id);
67 68 69
	g_main_loop_quit (data->loop);
}

70
static void
71
_print_progress (gboolean wait_startup, int progress_next_step_i, gint64 remaining_ms, int retval)
72 73 74 75 76 77 78 79
{
	int i, j;

	j = progress_next_step_i < 0 ? PROGRESS_STEPS : progress_next_step_i;

	g_print ("\r%s", _("Connecting"));
	for (i = 0; i < PROGRESS_STEPS; i++)
		putchar (i < j ? '.' : ' ');
80
	g_print (" %4lds", (long) (MAX (0, remaining_ms + 999) / 1000));
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
	if (retval != EXIT_NONE) {
		const char *result;

		if (wait_startup) {
			if (retval == EXIT_SUCCESS)
				result = "started";
			else if (retval == EXIT_FAILURE_OFFLINE)
				result = "startup-pending";
			else
				result = "failure";
		}
		else {
			if (retval == EXIT_SUCCESS)
				result = "online";
			else
				result = "offline";
		}

		g_print (" [%s]\n", result);
	}
101 102 103 104
	fflush (stdout);
}

static gboolean
105
quit_if_connected (OnlineData *data)
Robert Love's avatar
Robert Love committed
106
{
107
	NMState state;
108

109 110 111
	state = nm_client_get_state (data->client);
	if (!nm_client_get_nm_running (data->client)) {
		if (data->exit_no_nm) {
112 113
			_return (data, EXIT_FAILURE_OFFLINE);
			return TRUE;
114 115 116
		}
	} else if (data->wait_startup) {
		if (!nm_client_get_startup (data->client)) {
117 118
			_return (data, EXIT_SUCCESS);
			return TRUE;
119
		}
120 121 122
	} else {
		if (   state == NM_STATE_CONNECTED_LOCAL
		    || state == NM_STATE_CONNECTED_SITE
123
		    || state == NM_STATE_CONNECTED_GLOBAL) {
124 125
			_return (data, EXIT_SUCCESS);
			return TRUE;
126 127 128
		}
	}
	if (data->exit_no_nm && (state != NM_STATE_CONNECTING)) {
129 130
		_return (data, EXIT_FAILURE_OFFLINE);
		return TRUE;
131
	}
132 133

	return FALSE;
Robert Love's avatar
Robert Love committed
134 135
}

136 137 138 139 140
static void
client_properties_changed (GObject *object,
                           GParamSpec *pspec,
                           gpointer user_data)
{
141
	quit_if_connected (user_data);
142 143
}

144
static gboolean
145
handle_timeout (gpointer user_data)
Robert Love's avatar
Robert Love committed
146
{
147 148
	OnlineData *data = user_data;
	const gint64 now = _now_ms ();
149 150
	gint64 remaining_ms = data->end_timestamp_ms - now;
	const gint64 elapsed_ms = now - data->start_timestamp_ms;
151
	int progress_next_step_i = 0;
152

153
	data->handle_timeout_id = 0;
154

155
	if (remaining_ms <= 3) {
156 157
		_return (data, EXIT_FAILURE_OFFLINE);
		return G_SOURCE_REMOVE;
158
	}
159

160
	if (!data->quiet) {
161 162
		gint64 rem;

163 164
		/* calculate the next step (not the current): floor()+1 */
		progress_next_step_i = NM_MIN ((elapsed_ms / data->progress_step_duration) + 1, PROGRESS_STEPS);
165
		_print_progress (data->wait_startup, progress_next_step_i, remaining_ms, EXIT_NONE);
166

167 168 169 170
		/* synchronize the timeout with the ticking of the seconds. */
		rem = remaining_ms % 1000;
		if (rem <= 3)
			rem = rem + G_USEC_PER_SEC;
171 172
		/* add small offset to awake a bit after the second ticks */
		remaining_ms = NM_MIN (remaining_ms, rem + 10);
173 174

		/* synchronize the timeout with the steps of the progress bar. */
175
		rem = (progress_next_step_i * data->progress_step_duration) - elapsed_ms;
176
		if (rem <= 3)
177
			rem = rem + data->progress_step_duration;
178 179
		/* add small offset to awake a bit after the second ticks */
		remaining_ms = NM_MIN (remaining_ms, rem + 10);
180 181
	}

182 183 184 185 186 187 188 189 190 191 192 193 194
	data->handle_timeout_id = g_timeout_add (remaining_ms, handle_timeout, data);
	return G_SOURCE_REMOVE;
}

static gboolean
got_client_timeout (gpointer user_data)
{
	OnlineData *data = user_data;

	data->client_new_timeout_id = 0;
	data->quiet = TRUE;
	g_printerr (_("Error: timeout creating NMClient object\n"));
	_return (data, EXIT_FAILURE_LIBNM_BUG);
195
	return G_SOURCE_REMOVE;
Robert Love's avatar
Robert Love committed
196 197
}

198 199 200 201
static void
got_client (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
	OnlineData *data = user_data;
202
	gs_free_error GError *error = NULL;
203 204 205

	nm_assert (NM_IS_CLIENT (source_object));
	nm_assert (NM_CLIENT (source_object) == data->client);
206 207 208

	nm_clear_g_source (&data->client_new_timeout_id);
	g_clear_object (&data->client_new_cancellable);
209

210 211 212
	if (!g_async_initable_init_finish (G_ASYNC_INITABLE (source_object),
	                                   res,
	                                   &error)) {
213 214 215 216
		if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
			return;
		data->quiet = TRUE;
		g_printerr (_("Error: Could not create NMClient object: %s\n"),
217
		            error->message);
218 219
		_return (data, EXIT_FAILURE_ERROR);
		return;
220 221
	}

222 223 224 225 226 227
	if (quit_if_connected (data))
		return;

	data->client_notify_id = g_signal_connect (data->client, "notify",
	                                           G_CALLBACK (client_properties_changed), data);
	data->handle_timeout_id = g_timeout_add (data->quiet ? NM_MAX (0, data->end_timestamp_ms - _now_ms ()) : 0, handle_timeout, data);
228 229
}

230 231
int
main (int argc, char *argv[])
Robert Love's avatar
Robert Love committed
232
{
233 234 235
	OnlineData data = {
		.retval = EXIT_FAILURE_UNSPECIFIED,
	};
236
	int t_secs = 30;
237 238 239
	GOptionContext *opt_ctx = NULL;
	gboolean success;
	GOptionEntry options[] = {
240 241
		{"quiet", 'q', 0, G_OPTION_ARG_NONE, &data.quiet, N_("Don't print anything"), NULL},
		{"wait-for-startup", 's', 0, G_OPTION_ARG_NONE, &data.wait_startup, N_("Wait for NetworkManager startup instead of a connection"), NULL},
242 243
		{"timeout", 't', 0, G_OPTION_ARG_INT, &t_secs, N_("Time to wait for a connection, in seconds (without the option, default value is 30)"), "<timeout>"},
		{"exit", 'x', 0, G_OPTION_ARG_NONE, &data.exit_no_nm, N_("Exit immediately if NetworkManager is not running or connecting"), NULL},
244
		{ NULL },
245 246
	};

247 248 249 250 251 252 253
	/* Set locale to be able to use environment variables */
	setlocale (LC_ALL, "");

	bindtextdomain (GETTEXT_PACKAGE, NMLOCALEDIR);
	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
	textdomain (GETTEXT_PACKAGE);

254 255
	data.start_timestamp_ms = _now_ms ();

256 257
	opt_ctx = g_option_context_new (NULL);
	g_option_context_set_translation_domain (opt_ctx, GETTEXT_PACKAGE);
258 259 260 261 262
	g_option_context_set_ignore_unknown_options (opt_ctx, FALSE);
	g_option_context_set_help_enabled (opt_ctx, TRUE);
	g_option_context_add_main_entries (opt_ctx, options, NULL);

	g_option_context_set_summary (opt_ctx,
263
	                              _("Waits for NetworkManager to finish activating startup network connections."));
264 265 266 267 268

	success = g_option_context_parse (opt_ctx, &argc, &argv, NULL);
	g_option_context_free (opt_ctx);

	if (!success) {
269 270
		g_printerr ("%s: %s\n", argv[0],
		            _("Invalid option.  Please use --help to see a list of valid options."));
271
		return EXIT_FAILURE_ERROR;
272
	}
273 274

	if (t_secs < 0 || t_secs > 3600)  {
275 276
		g_printerr ("%s: %s\n", argv[0],
		            _("Invalid option.  Please use --help to see a list of valid options."));
277
		return EXIT_FAILURE_ERROR;
Robert Love's avatar
Robert Love committed
278
	}
279 280 281

	if (t_secs == 0)
		data.quiet = TRUE;
Robert Love's avatar
Robert Love committed
282

283
	data.loop = g_main_loop_new (NULL, FALSE);
284

285
	data.end_timestamp_ms = data.start_timestamp_ms + (t_secs * 1000);
286
	data.progress_step_duration = NM_MAX (1, (data.end_timestamp_ms - data.start_timestamp_ms + PROGRESS_STEPS/2) / PROGRESS_STEPS);
287

288 289 290
	data.client_new_cancellable = g_cancellable_new ();

	data.client_new_timeout_id = g_timeout_add_seconds (30, got_client_timeout, &data);
291 292 293 294

	data.client = nmc_client_new_async (data.client_new_cancellable,
	                                    got_client,
	                                    &data,
295
	                                    NM_CLIENT_INSTANCE_FLAGS, (guint) NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS,
296
	                                    NULL);
297

298
	g_main_loop_run (data.loop);
299 300 301 302 303 304 305 306 307 308

	nm_clear_g_cancellable (&data.client_new_cancellable);
	nm_clear_g_source (&data.client_new_timeout_id);
	nm_clear_g_source (&data.handle_timeout_id);
	nm_clear_g_signal_handler (data.client, &data.client_notify_id);
	g_clear_object (&data.client);

	g_clear_pointer (&data.loop, g_main_loop_unref);

	if (!data.quiet)
309
		_print_progress (data.wait_startup, -1, NM_MAX (0, data.end_timestamp_ms - _now_ms ()), data.retval);
Robert Love's avatar
Robert Love committed
310

311
	return data.retval;
Robert Love's avatar
Robert Love committed
312
}