GCC Code Coverage Report

Line	Branch	Exec	Source
1			/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
2			*
3			* Copyright (C) 2022 Nathan-J. Hirschauer <nathanhi@deepserve.info>
4			*
5			* Licensed under the GNU General Public License Version 2
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20			*/
21
22			#include "config.h"
23
24			#include <glib/gi18n.h>
25			#include <NetworkManager.h>
26
27			#include "ce-page.h"
28			#include "ce-page-wireguard.h"
29			#include "nma-ui-utils.h"
30			#include "vpn-helpers.h"
31
32			#include <ui-helpers.h>
33
34			struct _CEPageWireguard
35			{
36			GtkBox parent;
37
38			GtkGrid *main_box;
39			GtkEntry *entry_conname;
40			GtkEntry *entry_ifname;
41			GtkEntry *entry_private_key;
42			GtkSpinButton *spin_listen_port;
43			GtkSpinButton *spin_fwmark;
44			GtkSpinButton *spin_mtu;
45			GtkWidget *peers_box;
46			GtkWidget *empty_listbox;
47			GtkButton *button_add_peer;
48			GtkCheckButton *checkbutton_peer_routes;
49
50			NMConnection *connection;
51			NMSettingConnection *setting_connection;
52			NMSettingWireGuard *setting_wireguard;
53			};
54
55			struct _WireguardPeer
56			{
57			GtkBox parent;
58
59			GtkBox *box;
60			GtkLabel *peer_label;
61			GtkMenuButton *button_configure;
62			GtkMenuButton *button_delete;
63
64			GtkPopover *peer_popover;
65
66			// Provided by peer_popover
67			GtkEntry *entry_public_key;
68			GtkEntry *entry_allowed_ips;
69			GtkEntry *entry_endpoint;
70			GtkEntry *entry_psk;
71			GtkSpinButton *spin_persistent_keepalive;
72			GtkButton *button_apply;
73
74			// Used to track whether the peer was newly constructed
75			gboolean is_unsaved;
76
77			CEPageWireguard *ce_pg_wg;
78			NMWireGuardPeer *nm_wg_peer;
79			};
80
81			static void ce_page_iface_init (CEPageInterface *);
82
83		✗	G_DEFINE_TYPE_WITH_CODE (CEPageWireguard, ce_page_wireguard, GTK_TYPE_BOX,
84			G_IMPLEMENT_INTERFACE (ce_page_get_type (), ce_page_iface_init));
85		✗	G_DEFINE_TYPE (WireguardPeer, wireguard_peer, GTK_TYPE_BOX);
86
87			static void
88		✗	ce_page_wireguard_dispose (GObject *object)
89			{
90		✗	CEPageWireguard *self = CE_PAGE_WIREGUARD (object);
91
92		✗	g_clear_object (&self->setting_connection);
93		✗	g_clear_object (&self->setting_wireguard);
94		✗	G_OBJECT_CLASS (ce_page_wireguard_parent_class)->dispose (object);
95		✗	}
96
97			static const gchar *
98		✗	ce_page_wireguard_get_security_setting (CEPage *page)
99			{
100		✗	return NM_SETTING_WIREGUARD_SETTING_NAME;
101			}
102
103			static const gchar *
104		✗	ce_page_wireguard_get_title (CEPage *page)
105			{
106		✗	return _("WireGuard");
107			}
108
109			static void
110		✗	ui_to_setting (CEPageWireguard *self,
111			GError **error)
112			{
113			// Transform UI values to NM_SETTING
114			NMSettingSecretFlags secret_flags;
115
116			// Ensure that the spin boxes are updated
117		✗	gtk_spin_button_update (self->spin_listen_port);
118		✗	gtk_spin_button_update (self->spin_fwmark);
119		✗	gtk_spin_button_update (self->spin_mtu);
120
121			// Update peers
122			GtkWidget *widget;
123		✗	GList *peers = NULL;
124		✗	guint num_peers = 0;
125		✗	for (widget = gtk_widget_get_first_child (GTK_WIDGET (self->peers_box));
126		✗	widget != NULL;
127		✗	widget = gtk_widget_get_next_sibling (widget))
128		✗	peers = g_list_append (peers, widget);
129
130		✗	for (GList *p = peers; p != NULL; p = p->next) {
131		✗	WireguardPeer *peer = p->data;
132		✗	if (!WIREGUARD_IS_PEER (peer))
133		✗	continue;
134
135		✗	nm_setting_wireguard_set_peer (self->setting_wireguard, peer->nm_wg_peer, num_peers);
136
137		✗	num_peers++;
138			}
139
140		✗	g_list_free (peers);
141		✗	g_object_set (self->setting_connection,
142		✗	NM_SETTING_CONNECTION_INTERFACE_NAME, gtk_editable_get_text (GTK_EDITABLE (self->entry_ifname)),
143		✗	NM_SETTING_CONNECTION_ID, gtk_editable_get_text (GTK_EDITABLE (self->entry_conname)),
144			NULL);
145
146		✗	g_object_set (self->setting_wireguard,
147		✗	NM_SETTING_WIREGUARD_PRIVATE_KEY, gtk_editable_get_text (GTK_EDITABLE (self->entry_private_key)),
148		✗	NM_SETTING_WIREGUARD_FWMARK, (guint32)gtk_spin_button_get_value_as_int (self->spin_fwmark),
149		✗	NM_SETTING_WIREGUARD_MTU, (guint32)gtk_spin_button_get_value_as_int (self->spin_mtu),
150		✗	NM_SETTING_WIREGUARD_LISTEN_PORT, (guint32)gtk_spin_button_get_value_as_int (self->spin_listen_port),
151			NULL);
152		✗	secret_flags = nma_utils_menu_to_secret_flags (GTK_WIDGET (self->entry_private_key));
153		✗	nm_setting_set_secret_flags ((NMSetting *)self->setting_wireguard,
154			NM_SETTING_WIREGUARD_PRIVATE_KEY,
155			secret_flags, NULL);
156		✗	nma_utils_update_password_storage (GTK_WIDGET (self->entry_private_key),
157			secret_flags,
158		✗	(NMSetting *)self->setting_wireguard,
159			NM_SETTING_WIREGUARD_PRIVATE_KEY);
160		✗	}
161
162			static gboolean
163		✗	ce_page_wireguard_validate (CEPage *page,
164			NMConnection *connection,
165			GError **error)
166			{
167		✗	CEPageWireguard *self = CE_PAGE_WIREGUARD (page);
168		✗	ui_to_setting (self, error);
169
170		✗	for (guint p = 0; p < nm_setting_wireguard_get_peers_len (self->setting_wireguard); p++) {
171		✗	NMWireGuardPeer *peer = nm_setting_wireguard_get_peer (self->setting_wireguard, p);
172
173		✗	if (!nm_wireguard_peer_is_valid (peer, TRUE, TRUE, error))
174		✗	return FALSE;
175			}
176
177		✗	return nm_setting_verify (NM_SETTING (self->setting_connection), connection, error) &&
178		✗	nm_setting_verify_secrets (NM_SETTING (self->setting_wireguard), connection, error) &&
179		✗	nm_setting_verify (NM_SETTING (self->setting_wireguard), connection, error);
180			}
181
182			static void
183		✗	ce_page_wireguard_init (CEPageWireguard *self)
184			{
185		✗	gtk_widget_init_template (GTK_WIDGET (self));
186		✗	}
187
188			static void
189		✗	ce_page_wireguard_class_init (CEPageWireguardClass *class)
190			{
191		✗	GObjectClass *object_class = G_OBJECT_CLASS (class);
192		✗	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
193
194		✗	object_class->dispose = ce_page_wireguard_dispose;
195
196		✗	gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/network/wireguard-page.ui");
197
198		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, main_box);
199		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, entry_conname);
200		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, entry_ifname);
201		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, entry_private_key);
202		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, spin_listen_port);
203		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, spin_fwmark);
204		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, spin_mtu);
205		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, checkbutton_peer_routes);
206		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, peers_box);
207		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, empty_listbox);
208		✗	gtk_widget_class_bind_template_child (widget_class, CEPageWireguard, button_add_peer);
209		✗	}
210
211			static void
212		✗	ce_page_iface_init (CEPageInterface *iface)
213			{
214		✗	iface->get_security_setting = ce_page_wireguard_get_security_setting;
215		✗	iface->get_title = ce_page_wireguard_get_title;
216		✗	iface->validate = ce_page_wireguard_validate;
217		✗	}
218
219			static void
220		✗	toggle_show_secret_cb (GtkEntry *entry_private_key, gpointer user_data)
221			{
222		✗	gtk_entry_set_visibility (entry_private_key,
223		✗	!gtk_entry_get_visibility (entry_private_key));
224		✗	}
225
226			gchar *
227		✗	peer_allowed_ips_to_str (NMWireGuardPeer *peer)
228			{
229		✗	gchar *allowed_ips = NULL;
230		✗	if (nm_wireguard_peer_get_allowed_ips_len (peer) != 0) {
231		✗	allowed_ips = (gchar *)nm_wireguard_peer_get_allowed_ip (peer, 0, NULL);
232
233		✗	for (guint i = 1; i < nm_wireguard_peer_get_allowed_ips_len (peer); i++) {
234		✗	allowed_ips = g_strconcat (allowed_ips, ", ",
235			nm_wireguard_peer_get_allowed_ip (peer, i, NULL),
236			NULL);
237			}
238			}
239		✗	return allowed_ips;
240			}
241
242			static void
243		✗	handle_peer_changed_cb (GtkButton *apply_button, WireguardPeer *wg_peer)
244			{
245			NMWireGuardPeer *nm_wg_peer;
246			NMSettingSecretFlags secret_flags;
247
248		✗	gboolean peer_is_valid = TRUE;
249		✗	const gchar *endpoint = gtk_editable_get_text (GTK_EDITABLE (wg_peer->entry_endpoint));
250		✗	const gchar *public_key = gtk_editable_get_text (GTK_EDITABLE (wg_peer->entry_public_key));
251		✗	const gchar *psk = gtk_editable_get_text (GTK_EDITABLE (wg_peer->entry_psk));
252		✗	const gchar *allowed_ips = gtk_editable_get_text (GTK_EDITABLE (wg_peer->entry_allowed_ips));
253		✗	guint16 keepalive = gtk_spin_button_get_value_as_int (wg_peer->spin_persistent_keepalive);
254
255		✗	nm_wg_peer = nm_wireguard_peer_new_clone (wg_peer->nm_wg_peer, TRUE);
256
257		✗	widget_unset_error (GTK_WIDGET (wg_peer->entry_endpoint));
258		✗	if (!nm_wireguard_peer_set_endpoint (nm_wg_peer,
259		✗	endpoint && endpoint[0] ? endpoint : NULL,
260			FALSE)) {
261		✗	widget_set_error (GTK_WIDGET (wg_peer->entry_endpoint));
262		✗	peer_is_valid = FALSE;
263			}
264
265		✗	widget_unset_error (GTK_WIDGET (wg_peer->entry_public_key));
266		✗	if (!nm_wireguard_peer_set_public_key (nm_wg_peer,
267		✗	public_key && public_key[0] ? public_key : NULL,
268			FALSE)) {
269		✗	widget_set_error (GTK_WIDGET (wg_peer->entry_public_key));
270		✗	peer_is_valid = FALSE;
271			}
272
273		✗	widget_unset_error (GTK_WIDGET (wg_peer->entry_psk));
274		✗	if (!nm_wireguard_peer_set_preshared_key (nm_wg_peer,
275		✗	psk && psk[0] ? psk : NULL,
276			FALSE)) {
277		✗	widget_set_error (GTK_WIDGET (wg_peer->entry_psk));
278		✗	peer_is_valid = FALSE;
279		✗	} else if (psk && psk[0]) {
280		✗	secret_flags = nma_utils_menu_to_secret_flags (GTK_WIDGET (wg_peer->entry_psk));
281		✗	nm_wireguard_peer_set_preshared_key_flags (nm_wg_peer, secret_flags);
282		✗	nma_utils_update_password_storage (GTK_WIDGET (wg_peer->entry_psk),
283		✗	nm_wireguard_peer_get_preshared_key_flags (wg_peer->nm_wg_peer),
284			NULL,
285			NULL);
286			}
287
288		✗	nm_wireguard_peer_set_persistent_keepalive (nm_wg_peer, keepalive);
289
290			/* Only update allowed IPs if a value actually changed.
291			* Otherwise, the comparison will always differ, touching
292			* the connection without any real changes.
293			*/
294		✗	widget_unset_error (GTK_WIDGET (wg_peer->entry_allowed_ips));
295		✗	if (g_strcmp0(peer_allowed_ips_to_str (nm_wg_peer), allowed_ips) != 0) {
296		✗	nm_wireguard_peer_clear_allowed_ips (nm_wg_peer);
297		✗	char **strv = g_strsplit (allowed_ips, ",", -1);
298		✗	for (guint i = 0; strv && strv[i]; i++) {
299		✗	if (!nm_wireguard_peer_append_allowed_ip (nm_wg_peer,
300		✗	g_strstrip (strv[i]),
301			FALSE)) {
302		✗	widget_set_error (GTK_WIDGET (wg_peer->entry_allowed_ips));
303		✗	peer_is_valid = FALSE;
304			}
305			}
306		✗	g_strfreev (strv);
307			}
308
309		✗	if (!nm_wireguard_peer_is_valid (nm_wg_peer, TRUE, TRUE, NULL) || !peer_is_valid)
310		✗	return;
311
312		✗	if (nm_wireguard_peer_cmp (wg_peer->nm_wg_peer, nm_wg_peer, NM_SETTING_COMPARE_FLAG_EXACT) == 0) {
313		✗	gtk_popover_popdown (wg_peer->peer_popover);
314		✗	return;
315			}
316
317			// Indicate that the peer has now been succesfully configured
318		✗	wg_peer->is_unsaved = FALSE;
319
320			// Update peer list
321		✗	gtk_label_set_text (wg_peer->peer_label, gtk_editable_get_text (GTK_EDITABLE (wg_peer->entry_endpoint)));
322
323		✗	wg_peer->nm_wg_peer = nm_wg_peer;
324		✗	g_signal_emit_by_name (wg_peer->ce_pg_wg, "changed", wg_peer->ce_pg_wg);
325		✗	gtk_popover_popdown (wg_peer->peer_popover);
326			}
327
328			static void
329		✗	destroy_peer (WireguardPeer *wg_peer)
330			{
331		✗	nm_wireguard_peer_unref (wg_peer->nm_wg_peer);
332		✗	GtkWidget* parent = gtk_widget_get_parent (GTK_WIDGET (wg_peer));
333		✗	gtk_box_remove (GTK_BOX (parent), GTK_WIDGET (wg_peer));
334		✗	gtk_widget_set_visible (GTK_WIDGET (wg_peer->ce_pg_wg->empty_listbox),
335		✗	nm_setting_wireguard_get_peers_len (wg_peer->ce_pg_wg->setting_wireguard) < 1);
336		✗	}
337
338			static void
339		✗	handle_peer_delete_cb (GtkButton *delete_button, WireguardPeer *wg_peer)
340			{
341			NMWireGuardPeer *peer;
342		✗	for (guint p = 0; p < nm_setting_wireguard_get_peers_len (wg_peer->ce_pg_wg->setting_wireguard); p++) {
343		✗	peer = nm_setting_wireguard_get_peer (wg_peer->ce_pg_wg->setting_wireguard, p);
344		✗	if (nm_wireguard_peer_cmp (wg_peer->nm_wg_peer, peer, NM_SETTING_COMPARE_FLAG_EXACT) == 0) {
345		✗	nm_setting_wireguard_remove_peer (wg_peer->ce_pg_wg->setting_wireguard, p);
346		✗	break;
347			}
348			}
349
350		✗	destroy_peer (wg_peer);
351		✗	g_signal_emit_by_name (wg_peer->ce_pg_wg, "changed", wg_peer->ce_pg_wg);
352		✗	}
353
354			static void
355		✗	handle_abort_new_peer (GtkPopover *peer_popover, WireguardPeer *wg_peer)
356			{
357		✗	if (wg_peer->is_unsaved == TRUE)
358		✗	destroy_peer (wg_peer);
359			else
360		✗	g_signal_handlers_disconnect_by_func (peer_popover, handle_abort_new_peer, wg_peer);
361
362		✗	gtk_widget_set_visible (GTK_WIDGET (wg_peer->ce_pg_wg->empty_listbox),
363		✗	nm_setting_wireguard_get_peers_len (wg_peer->ce_pg_wg->setting_wireguard) < 1);
364		✗	}
365
366			WireguardPeer *
367		✗	add_nm_wg_peer_to_list (CEPageWireguard *self, NMWireGuardPeer *peer)
368			{
369			WireguardPeer *wg_peer;
370		✗	gchar *endpoint = (gchar *)nm_wireguard_peer_get_endpoint (peer);
371		✗	if (!endpoint) {
372			/* Translators: Unknown endpoint host for WireGuard (invalid setting) */
373		✗	endpoint = _("Unknown");
374			}
375
376		✗	wg_peer = wireguard_peer_new (self);
377		✗	wg_peer->nm_wg_peer = peer;
378		✗	wg_peer->is_unsaved = FALSE;
379
380		✗	gtk_label_set_text (wg_peer->peer_label, endpoint);
381
382		✗	gtk_editable_set_text (GTK_EDITABLE (wg_peer->entry_endpoint), endpoint);
383		✗	if (peer_allowed_ips_to_str (peer) != NULL)
384		✗	gtk_editable_set_text (GTK_EDITABLE (wg_peer->entry_allowed_ips), peer_allowed_ips_to_str (peer));
385		✗	if (nm_wireguard_peer_get_preshared_key (peer) != NULL)
386		✗	gtk_editable_set_text (GTK_EDITABLE (wg_peer->entry_psk), nm_wireguard_peer_get_preshared_key (peer));
387		✗	if (nm_wireguard_peer_get_public_key (peer) != NULL)
388		✗	gtk_editable_set_text (GTK_EDITABLE (wg_peer->entry_public_key), nm_wireguard_peer_get_public_key (peer));
389
390		✗	gtk_spin_button_set_value (wg_peer->spin_persistent_keepalive, nm_wireguard_peer_get_persistent_keepalive (peer));
391
392		✗	g_signal_connect (wg_peer->button_apply, "clicked", G_CALLBACK (handle_peer_changed_cb), wg_peer);
393		✗	g_signal_connect (wg_peer->button_delete, "clicked", G_CALLBACK (handle_peer_delete_cb), wg_peer);
394		✗	g_signal_connect (wg_peer->entry_psk, "icon-press", G_CALLBACK (toggle_show_secret_cb), NULL);
395		✗	gtk_widget_show (GTK_WIDGET (wg_peer));
396		✗	gtk_box_append (GTK_BOX (self->peers_box), GTK_WIDGET (wg_peer));
397
398		✗	return wg_peer;
399			}
400
401			static void
402		✗	handle_peer_add_cb (CEPageWireguard *self)
403			{
404		✗	NMWireGuardPeer *nm_wg_peer = nm_wireguard_peer_new ();
405		✗	WireguardPeer *wg_peer = add_nm_wg_peer_to_list (self, nm_wg_peer);
406		✗	wg_peer->is_unsaved = TRUE;
407		✗	wg_peer->ce_pg_wg = self;
408
409		✗	gtk_widget_set_visible (GTK_WIDGET (self->empty_listbox), FALSE);
410		✗	gtk_label_set_text (wg_peer->peer_label, _("Unsaved peer"));
411		✗	gtk_popover_popup (wg_peer->peer_popover);
412		✗	g_signal_connect (wg_peer->peer_popover, "closed", G_CALLBACK (handle_abort_new_peer), wg_peer);
413		✗	}
414
415			static void
416		✗	finish_setup (CEPageWireguard *self, gpointer unused, GError *error, gpointer user_data)
417			{
418			const gchar *ifname, *conname, *privkey;
419		✗	const guint32 listen_port_default = 51820;
420			guint32 listen_port, fwmark, mtu;
421
422		✗	self->setting_connection = nm_connection_get_setting_connection (self->connection);
423		✗	self->setting_wireguard = (NMSettingWireGuard *)nm_connection_get_setting (self->connection, NM_TYPE_SETTING_WIREGUARD);
424
425		✗	conname = nm_connection_get_id (self->connection);
426		✗	if (conname != NULL)
427		✗	gtk_editable_set_text (GTK_EDITABLE (self->entry_conname), conname);
428		✗	ifname = nm_connection_get_interface_name (self->connection);
429		✗	if (ifname != NULL)
430		✗	gtk_editable_set_text (GTK_EDITABLE (self->entry_ifname), ifname);
431		✗	privkey = nm_setting_wireguard_get_private_key (self->setting_wireguard);
432		✗	if (privkey != NULL)
433		✗	gtk_editable_set_text (GTK_EDITABLE (self->entry_private_key), privkey);
434		✗	g_signal_connect (self->entry_private_key, "icon-press", G_CALLBACK (toggle_show_secret_cb), NULL);
435
436		✗	listen_port = nm_setting_wireguard_get_listen_port (self->setting_wireguard);
437		✗	if (listen_port != 0 && listen_port != 51820)
438		✗	gtk_spin_button_set_value (self->spin_listen_port, listen_port);
439			else {
440		✗	gtk_spin_button_set_value (self->spin_listen_port, listen_port_default);
441			}
442		✗	fwmark = nm_setting_wireguard_get_fwmark (self->setting_wireguard);
443		✗	gtk_spin_button_set_value (self->spin_fwmark, fwmark);
444		✗	mtu = nm_setting_wireguard_get_mtu (self->setting_wireguard);
445		✗	gtk_spin_button_set_value (self->spin_mtu, mtu);
446		✗	for (guint p = 0;
447		✗	p < nm_setting_wireguard_get_peers_len (self->setting_wireguard);
448		✗	p++) {
449		✗	NMWireGuardPeer *peer = nm_setting_wireguard_get_peer (self->setting_wireguard, p);
450		✗	add_nm_wg_peer_to_list (self, peer);
451			}
452
453		✗	gtk_widget_set_visible (self->empty_listbox,
454		✗	nm_setting_wireguard_get_peers_len (self->setting_wireguard) < 1);
455		✗	gtk_check_button_set_active (self->checkbutton_peer_routes,
456			nm_setting_wireguard_get_peer_routes (self->setting_wireguard));
457
458		✗	g_signal_connect_swapped (self->button_add_peer, "clicked", G_CALLBACK (handle_peer_add_cb), self);
459		✗	}
460
461			CEPageWireguard *
462		✗	ce_page_wireguard_new (NMConnection *connection)
463			{
464		✗	CEPageWireguard *self = CE_PAGE_WIREGUARD (g_object_new (ce_page_wireguard_get_type (), NULL));
465
466		✗	self->connection = g_object_ref (connection);
467
468		✗	g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
469
470		✗	return self;
471			}
472
473			static void
474		✗	wireguard_peer_init (WireguardPeer *self)
475			{
476		✗	gtk_widget_init_template (GTK_WIDGET (self));
477		✗	}
478
479			WireguardPeer *
480		✗	wireguard_peer_new (CEPageWireguard *parent)
481			{
482			WireguardPeer *self;
483
484		✗	self = g_object_new (wireguard_peer_get_type (), NULL);
485		✗	self->ce_pg_wg = parent;
486		✗	self->is_unsaved = TRUE;
487		✗	return self;
488			}
489
490			static void
491		✗	wireguard_peer_class_init (WireguardPeerClass *klass)
492			{
493		✗	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
494
495		✗	gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/network/wireguard-peer.ui");
496
497		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, peer_label);
498		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, button_configure);
499		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, button_delete);
500		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, entry_public_key);
501		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, entry_allowed_ips);
502		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, entry_endpoint);
503		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, entry_psk);
504		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, spin_persistent_keepalive);
505		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, peer_popover);
506		✗	gtk_widget_class_bind_template_child (widget_class, WireguardPeer, button_apply);
507		✗	}
508