LCOV - code coverage report
Current view: top level - src/plugins/lan - valent-lan-channel-service.c (source / functions) Hit Total Coverage
Test: Code Coverage Lines: 368 476 77.3 %
Date: 2023-06-06 02:20:50 Functions: 25 28 89.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 156 387 40.3 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-3.0-or-later
       2                 :            : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
       3                 :            : 
       4                 :            : #define G_LOG_DOMAIN "valent-lan-channel-service"
       5                 :            : 
       6                 :            : #include "config.h"
       7                 :            : 
       8                 :            : #include <gio/gio.h>
       9                 :            : #include <gio/gunixinputstream.h>
      10                 :            : #include <libpeas/peas.h>
      11                 :            : #include <valent.h>
      12                 :            : 
      13                 :            : #include "valent-lan-channel.h"
      14                 :            : #include "valent-lan-channel-service.h"
      15                 :            : #include "valent-lan-utils.h"
      16                 :            : 
      17                 :            : #define IDENTITY_BUFFER_MAX  (8192)
      18                 :            : #define IDENTITY_TIMEOUT_MAX (1000)
      19                 :            : 
      20                 :            : 
      21                 :            : struct _ValentLanChannelService
      22                 :            : {
      23                 :            :   ValentChannelService  parent_instance;
      24                 :            : 
      25                 :            :   GTlsCertificate      *certificate;
      26                 :            : 
      27                 :            :   GNetworkMonitor      *monitor;
      28                 :            :   gboolean              network_available;
      29                 :            : 
      30                 :            :   /* Service */
      31                 :            :   uint16_t              port;
      32                 :            :   uint16_t              tcp_port;
      33                 :            :   char                 *broadcast_address;
      34                 :            :   GSocketService       *listener;
      35                 :            :   GMainLoop            *udp_context;
      36                 :            :   GSocket              *udp_socket4;
      37                 :            :   GSocket              *udp_socket6;
      38                 :            :   GHashTable           *channels;
      39                 :            : };
      40                 :            : 
      41                 :            : static void   g_async_initable_iface_init (GAsyncInitableIface *iface);
      42                 :            : 
      43   [ +  +  +  - ]:         32 : G_DEFINE_FINAL_TYPE_WITH_CODE (ValentLanChannelService, valent_lan_channel_service, VALENT_TYPE_CHANNEL_SERVICE,
      44                 :            :                                G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, g_async_initable_iface_init))
      45                 :            : 
      46                 :            : enum {
      47                 :            :   PROP_0,
      48                 :            :   PROP_BROADCAST_ADDRESS,
      49                 :            :   PROP_CERTIFICATE,
      50                 :            :   PROP_PORT,
      51                 :            :   N_PROPERTIES
      52                 :            : };
      53                 :            : 
      54                 :            : static GParamSpec *properties[N_PROPERTIES] = { NULL, };
      55                 :            : 
      56                 :            : 
      57                 :            : static void
      58                 :          0 : on_network_changed (GNetworkMonitor         *monitor,
      59                 :            :                     gboolean                 network_available,
      60                 :            :                     ValentLanChannelService *self)
      61                 :            : {
      62         [ #  # ]:          0 :   if (self->network_available == network_available)
      63                 :            :     return;
      64                 :            : 
      65         [ #  # ]:          0 :   if ((self->network_available = network_available))
      66                 :          0 :     valent_channel_service_identify (VALENT_CHANNEL_SERVICE (self), NULL);
      67                 :            : }
      68                 :            : 
      69                 :            : static void
      70                 :          0 : on_channel_destroyed (ValentLanChannelService *self,
      71                 :            :                       ValentLanChannel        *channel)
      72                 :            : {
      73                 :          0 :   g_autoptr (GTlsCertificate) certificate = NULL;
      74                 :          0 :   const char *device_id = NULL;
      75                 :            : 
      76         [ #  # ]:          0 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (self));
      77         [ #  # ]:          0 :   g_assert (VALENT_IS_LAN_CHANNEL (channel));
      78                 :            : 
      79                 :          0 :   certificate = valent_lan_channel_ref_peer_certificate (channel);
      80                 :          0 :   device_id = valent_certificate_get_common_name (certificate);
      81                 :            : 
      82                 :          0 :   valent_object_lock (VALENT_OBJECT (self));
      83         [ #  # ]:          0 :   if (g_hash_table_remove (self->channels, device_id))
      84                 :          0 :     g_signal_handlers_disconnect_by_data (channel, self);
      85         [ #  # ]:          0 :   valent_object_unlock (VALENT_OBJECT (self));
      86                 :          0 : }
      87                 :            : 
      88                 :            : /**
      89                 :            :  * valent_lan_channel_service_verify_channel:
      90                 :            :  * @self: a #ValentLanChannelService
      91                 :            :  * @identity: a KDE Connect identity packet
      92                 :            :  * @connection: a #GTlsConnection
      93                 :            :  *
      94                 :            :  * Verify an encrypted TLS connection.
      95                 :            :  *
      96                 :            :  * @device_id should be the `deviceID` field from an identity packet. If it does
      97                 :            :  * not match the common name for the peer certificate, %FALSE will be returned.
      98                 :            :  *
      99                 :            :  * @connection should be an encrypted TLS connection. If there is an existing
     100                 :            :  * channel for @device_id with a different certificate, %FALSE will be returned.
     101                 :            :  *
     102                 :            :  * Returns: %TRUE if successful, or %FALSE on failure
     103                 :            :  */
     104                 :            : static gboolean
     105                 :          3 : valent_lan_channel_service_verify_channel (ValentLanChannelService *self,
     106                 :            :                                            JsonNode                *identity,
     107                 :            :                                            GIOStream               *connection)
     108                 :            : {
     109                 :          3 :   ValentLanChannel *channel = NULL;
     110                 :          6 :   g_autoptr (GTlsCertificate) certificate = NULL;
     111         [ -  + ]:          3 :   g_autoptr (GTlsCertificate) peer_certificate = NULL;
     112                 :          3 :   const char *peer_certificate_cn = NULL;
     113                 :          3 :   const char *device_id = NULL;
     114                 :            : 
     115         [ +  - ]:          3 :   g_assert (VALENT_IS_CHANNEL_SERVICE (self));
     116         [ -  + ]:          3 :   g_assert (VALENT_IS_PACKET (identity));;
     117   [ +  -  +  -  :          3 :   g_assert (G_IS_TLS_CONNECTION (connection));
             +  -  -  + ]
     118                 :            : 
     119         [ -  + ]:          3 :   if (!valent_packet_get_string (identity, "deviceId", &device_id))
     120                 :            :     {
     121                 :          0 :       g_debug ("%s(): expected \"deviceId\" field holding a string",
     122                 :            :                G_STRFUNC);
     123                 :          0 :       return FALSE;
     124                 :            :     }
     125                 :            : 
     126                 :          3 :   g_object_get (connection, "peer-certificate", &peer_certificate, NULL);
     127                 :          3 :   peer_certificate_cn = valent_certificate_get_common_name (peer_certificate);
     128                 :            : 
     129         [ -  + ]:          3 :   if (g_strcmp0 (device_id, peer_certificate_cn) != 0)
     130                 :            :     {
     131                 :          0 :       g_warning ("%s(): device ID does not match certificate common name",
     132                 :            :                  G_STRFUNC);
     133                 :          0 :       return FALSE;
     134                 :            :     }
     135                 :            : 
     136                 :          3 :   valent_object_lock (VALENT_OBJECT (self));
     137         [ -  + ]:          3 :   if ((channel = g_hash_table_lookup (self->channels, device_id)) != NULL)
     138                 :          0 :     certificate = valent_lan_channel_ref_peer_certificate (channel);
     139                 :          3 :   valent_object_unlock (VALENT_OBJECT (self));
     140                 :            : 
     141   [ -  +  -  - ]:          3 :   if (certificate && !g_tls_certificate_is_same (certificate, peer_certificate))
     142                 :            :     {
     143                 :          0 :       g_warning ("%s(): existing channel with different certificate",
     144                 :            :                  G_STRFUNC);
     145                 :          0 :       return FALSE;
     146                 :            :     }
     147                 :            : 
     148                 :            :   return TRUE;
     149                 :            : }
     150                 :            : 
     151                 :            : /*
     152                 :            :  * Incoming TCP Connections
     153                 :            :  *
     154                 :            :  * When an incoming connection is opened to the TCP listener, we are operating
     155                 :            :  * as the client. The server expects us to:
     156                 :            :  *
     157                 :            :  * 1) Accept the TCP connection
     158                 :            :  * 2) Read the peer identity packet
     159                 :            :  * 3) Negotiate TLS encryption (as the TLS Client)
     160                 :            :  */
     161                 :            : static gboolean
     162                 :          1 : incoming_connection_timeout_cb (gpointer data)
     163                 :            : {
     164   [ +  -  +  -  :          1 :   g_assert (G_IS_CANCELLABLE (data));
             -  +  -  - ]
     165                 :            : 
     166                 :          1 :   g_cancellable_cancel ((GCancellable *)data);
     167                 :            : 
     168                 :          1 :   return G_SOURCE_REMOVE;
     169                 :            : }
     170                 :            : 
     171                 :            : static gboolean
     172                 :          1 : on_incoming_connection (ValentChannelService   *service,
     173                 :            :                         GSocketConnection      *connection,
     174                 :            :                         GCancellable           *cancellable,
     175                 :            :                         GThreadedSocketService *listener)
     176                 :            : {
     177                 :          1 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (service);
     178                 :          2 :   g_autoptr (GCancellable) timeout = NULL;
     179                 :          1 :   unsigned long cancellable_id = 0;
     180         [ +  - ]:          1 :   g_autoptr (GSocketAddress) s_addr = NULL;
     181                 :          1 :   GInetAddress *i_addr = NULL;
     182         [ +  - ]:          1 :   g_autofree char *host = NULL;
     183                 :          1 :   g_autoptr (JsonNode) identity = NULL;
     184         [ +  - ]:          1 :   g_autoptr (JsonNode) peer_identity = NULL;
     185                 :          1 :   const char *device_id;
     186         [ +  - ]:          1 :   g_autoptr (GTlsCertificate) certificate = NULL;
     187         [ +  - ]:          1 :   g_autoptr (GIOStream) tls_stream = NULL;
     188         [ +  - ]:          1 :   g_autoptr (ValentChannel) channel = NULL;
     189         [ +  - ]:          1 :   g_autoptr (GError) warning = NULL;
     190                 :            : 
     191         [ +  - ]:          1 :   g_assert (VALENT_IS_CHANNEL_SERVICE (service));
     192         [ -  + ]:          1 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (self));
     193                 :            : 
     194                 :            :   /* Timeout if the peer fails to authenticate in a timely fashion. */
     195                 :          1 :   timeout = g_cancellable_new ();
     196                 :          1 :   g_timeout_add_full (G_PRIORITY_DEFAULT,
     197                 :            :                       IDENTITY_TIMEOUT_MAX,
     198                 :            :                       incoming_connection_timeout_cb,
     199                 :            :                       g_object_ref (timeout),
     200                 :            :                       g_object_unref);
     201                 :            : 
     202         [ +  - ]:          1 :   if (cancellable != NULL)
     203                 :          1 :     cancellable_id = g_cancellable_connect (cancellable,
     204                 :            :                                             G_CALLBACK (g_cancellable_cancel),
     205                 :            :                                             timeout,
     206                 :            :                                             NULL);
     207                 :            : 
     208                 :            :   /* An incoming TCP connection is in response to an outgoing UDP packet, so the
     209                 :            :    * the peer must now write its identity packet. */
     210                 :          1 :   peer_identity = valent_packet_from_stream (g_io_stream_get_input_stream (G_IO_STREAM (connection)),
     211                 :            :                                              IDENTITY_BUFFER_MAX,
     212                 :            :                                              timeout,
     213                 :            :                                              &warning);
     214                 :            : 
     215         [ -  + ]:          1 :   if (peer_identity == NULL)
     216                 :            :     {
     217         [ #  # ]:          0 :       if (!g_error_matches (warning, G_IO_ERROR, G_IO_ERROR_CANCELLED))
     218                 :          0 :         g_warning ("%s(): %s", G_STRFUNC, warning->message);
     219         [ #  # ]:          0 :       else if (!g_cancellable_is_cancelled (cancellable))
     220                 :          0 :         g_warning ("%s(): timed out waiting for peer identity", G_STRFUNC);
     221                 :            : 
     222                 :          0 :       g_cancellable_disconnect (cancellable, cancellable_id);
     223                 :            : 
     224                 :          0 :       return TRUE;
     225                 :            :     }
     226                 :            : 
     227                 :            :   /* Ignore identity packets without a deviceId */
     228         [ -  + ]:          1 :   if (!valent_packet_get_string (peer_identity, "deviceId", &device_id))
     229                 :            :     {
     230                 :          0 :       g_debug ("%s(): expected \"deviceId\" field holding a string",
     231                 :            :                G_STRFUNC);
     232                 :          0 :       return TRUE;
     233                 :            :     }
     234                 :            : 
     235                 :          1 :   VALENT_JSON (peer_identity, host);
     236                 :            : 
     237                 :            :   /* NOTE: We're the client when accepting incoming connections */
     238                 :          1 :   valent_object_lock (VALENT_OBJECT (self));
     239                 :          1 :   certificate = g_object_ref (self->certificate);
     240                 :          1 :   valent_object_unlock (VALENT_OBJECT (self));
     241                 :            : 
     242                 :          1 :   tls_stream = valent_lan_encrypt_client_connection (connection,
     243                 :            :                                                      certificate,
     244                 :            :                                                      timeout,
     245                 :            :                                                      &warning);
     246                 :            : 
     247         [ -  + ]:          1 :   if (tls_stream == NULL)
     248                 :            :     {
     249         [ #  # ]:          0 :       if (!g_error_matches (warning, G_IO_ERROR, G_IO_ERROR_CANCELLED))
     250                 :          0 :         g_warning ("%s(): %s", G_STRFUNC, warning->message);
     251         [ #  # ]:          0 :       else if (!g_cancellable_is_cancelled (cancellable))
     252                 :          0 :         g_warning ("%s(): timed out waiting for authentication", G_STRFUNC);
     253                 :            : 
     254                 :          0 :       g_cancellable_disconnect (cancellable, cancellable_id);
     255                 :            : 
     256                 :          0 :       return TRUE;
     257                 :            :     }
     258                 :            : 
     259                 :          1 :   g_cancellable_disconnect (cancellable, cancellable_id);
     260                 :            : 
     261         [ +  - ]:          1 :   if (!valent_lan_channel_service_verify_channel (self, peer_identity, tls_stream))
     262                 :            :     return TRUE;
     263                 :            : 
     264                 :            :   /* Get the host from the connection */
     265                 :          1 :   s_addr = g_socket_connection_get_remote_address (connection, NULL);
     266                 :          1 :   i_addr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (s_addr));
     267                 :          1 :   host = g_inet_address_to_string (i_addr);
     268                 :            : 
     269                 :            :   /* Create the new channel */
     270                 :          1 :   identity = valent_channel_service_ref_identity (service);
     271                 :          1 :   channel = g_object_new (VALENT_TYPE_LAN_CHANNEL,
     272                 :            :                           "base-stream",   tls_stream,
     273                 :            :                           "host",          host,
     274                 :          1 :                           "port",          self->port,
     275                 :            :                           "identity",      identity,
     276                 :            :                           "peer-identity", peer_identity,
     277                 :            :                           NULL);
     278                 :            : 
     279                 :          1 :   valent_channel_service_channel (service, channel);
     280                 :            : 
     281                 :          1 :   return TRUE;
     282                 :            : }
     283                 :            : 
     284                 :            : /**
     285                 :            :  * valent_lan_channel_service_tcp_setup:
     286                 :            :  * @self: a #ValentLanChannelService
     287                 :            :  * @error: (nullable): a #GError
     288                 :            :  *
     289                 :            :  * A wrapper around g_socket_listener_add_inet_port() that can be called
     290                 :            :  * multiple times.
     291                 :            :  *
     292                 :            :  * Returns: %TRUE if successful, or %FALSE with @error set
     293                 :            :  */
     294                 :            : static gboolean
     295                 :          3 : valent_lan_channel_service_tcp_setup (ValentLanChannelService  *self,
     296                 :            :                                       GCancellable             *cancellable,
     297                 :            :                                       GError                  **error)
     298                 :            : {
     299                 :          6 :   g_autoptr (GCancellable) destroy = NULL;
     300                 :          3 :   uint16_t tcp_port_max;
     301                 :            : 
     302         [ +  - ]:          3 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (self));
     303   [ +  -  +  -  :          3 :   g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  +  -  - ]
     304   [ +  -  -  + ]:          3 :   g_assert (error == NULL || *error == NULL);
     305                 :            : 
     306         [ +  - ]:          3 :   if (g_cancellable_set_error_if_cancelled (cancellable, error))
     307                 :            :     return FALSE;
     308                 :            : 
     309                 :          3 :   valent_object_lock (VALENT_OBJECT (self));
     310                 :          3 :   destroy = valent_object_ref_cancellable (VALENT_OBJECT (self));
     311                 :          3 :   self->tcp_port = self->port;
     312                 :          3 :   tcp_port_max = self->tcp_port + (VALENT_LAN_PROTOCOL_PORT_MAX -
     313                 :            :                                    VALENT_LAN_PROTOCOL_PORT_MIN);
     314                 :            : 
     315                 :            :   /* Pass the service as the callback data for the "run" signal, while the
     316                 :            :    * listener holds a reference to the object cancellable.
     317                 :            :    */
     318                 :          3 :   self->listener = g_threaded_socket_service_new (g_get_num_processors ());
     319                 :          3 :   g_signal_connect_object (self->listener,
     320                 :            :                            "run",
     321                 :            :                            G_CALLBACK (on_incoming_connection),
     322                 :            :                            self,
     323                 :            :                            G_CONNECT_SWAPPED);
     324                 :            : 
     325         [ -  + ]:          6 :   while (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (self->listener),
     326                 :          3 :                                            self->tcp_port,
     327                 :            :                                            G_OBJECT (destroy),
     328                 :            :                                            error))
     329                 :            :     {
     330         [ #  # ]:          0 :       if (self->tcp_port >= tcp_port_max)
     331                 :            :         {
     332                 :          0 :           g_socket_service_stop (self->listener);
     333                 :          0 :           g_socket_listener_close (G_SOCKET_LISTENER (self->listener));
     334         [ #  # ]:          0 :           g_clear_object (&self->listener);
     335                 :            :           break;
     336                 :            :         }
     337                 :            : 
     338                 :          0 :       g_clear_error (error);
     339                 :          0 :       self->tcp_port++;
     340                 :            :     }
     341                 :            : 
     342                 :          3 :   valent_channel_service_build_identity (VALENT_CHANNEL_SERVICE (self));
     343                 :          3 :   valent_object_unlock (VALENT_OBJECT (self));
     344                 :            : 
     345   [ +  -  +  -  :          3 :   return G_IS_SOCKET_SERVICE (self->listener);
             +  -  -  + ]
     346                 :            : }
     347                 :            : 
     348                 :            : /*
     349                 :            :  * Incoming UDP Broadcasts
     350                 :            :  *
     351                 :            :  * When an identity packet is received over a UDP port (usually a broadcast), we
     352                 :            :  * are operating as the server. The client expects us to:
     353                 :            :  *
     354                 :            :  * 1) Open a TCP connection
     355                 :            :  * 2) Write our identity packet
     356                 :            :  * 3) Negotiate TLS encryption (as the TLS Server)
     357                 :            :  */
     358                 :            : static void
     359                 :          2 : incoming_broadcast_task (GTask        *task,
     360                 :            :                          gpointer      source_object,
     361                 :            :                          gpointer      task_data,
     362                 :            :                          GCancellable *cancellable)
     363                 :            : {
     364                 :          2 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (source_object);
     365                 :          2 :   ValentChannelService *service = VALENT_CHANNEL_SERVICE (source_object);
     366                 :          2 :   GSocketAddress *address = G_SOCKET_ADDRESS (task_data);
     367                 :          2 :   JsonNode *peer_identity = NULL;
     368                 :          2 :   g_autoptr (GSocketClient) client = NULL;
     369   [ +  -  -  - ]:          2 :   g_autoptr (GSocketConnection) connection = NULL;
     370                 :          2 :   GInetAddress *addr = NULL;
     371         [ -  - ]:          2 :   g_autoptr (JsonNode) identity = NULL;
     372   [ +  -  -  - ]:          2 :   g_autoptr (ValentChannel) channel = NULL;
     373   [ +  -  -  - ]:          2 :   g_autofree char *host = NULL;
     374                 :          2 :   int64_t port = VALENT_LAN_PROTOCOL_PORT;
     375                 :          2 :   GOutputStream *output_stream;
     376                 :          2 :   g_autoptr (GTlsCertificate) certificate = NULL;
     377   [ +  -  -  - ]:          2 :   g_autoptr (GIOStream) tls_stream = NULL;
     378         [ -  - ]:          2 :   g_autoptr (GError) error = NULL;
     379                 :            : 
     380         [ +  - ]:          2 :   g_assert (VALENT_IS_CHANNEL_SERVICE (self));
     381   [ +  -  +  -  :          2 :   g_assert (G_IS_SOCKET_ADDRESS (address));
             +  -  -  + ]
     382                 :            : 
     383                 :          2 :   addr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address));
     384                 :          2 :   host = g_inet_address_to_string (addr);
     385                 :          2 :   peer_identity = g_object_get_data (G_OBJECT (address), "valent-lan-broadcast");
     386                 :          2 :   valent_packet_get_int (peer_identity, "tcpPort", &port);
     387                 :            : 
     388                 :            :   /* Open a TCP connection to the UDP sender and defined port.
     389                 :            :    *
     390                 :            :    * Disable the system proxy:
     391                 :            :    *   - https://bugs.kde.org/show_bug.cgi?id=376187
     392                 :            :    *   - https://github.com/andyholmes/gnome-shell-extension-gsconnect/issues/125
     393                 :            :    */
     394                 :          2 :   client = g_object_new (G_TYPE_SOCKET_CLIENT,
     395                 :            :                          "enable-proxy", FALSE,
     396                 :            :                          NULL);
     397                 :          2 :   connection = g_socket_client_connect (client,
     398                 :            :                                         G_SOCKET_CONNECTABLE (address),
     399                 :            :                                         cancellable,
     400                 :            :                                         &error);
     401                 :            : 
     402         [ -  + ]:          2 :   if (connection == NULL)
     403                 :            :     {
     404                 :          0 :       g_debug ("%s(): connecting to (%s:%"G_GINT64_FORMAT"): %s",
     405                 :            :                G_STRFUNC, host, port, error->message);
     406                 :          0 :       return g_task_return_error (task, g_steal_pointer (&error));
     407                 :            :     }
     408                 :            : 
     409                 :            :   /* Write the local identity. Once we do this, both peers will have the ability
     410                 :            :    * to authenticate or reject TLS certificates.
     411                 :            :    */
     412                 :          2 :   identity = valent_channel_service_ref_identity (service);
     413                 :          2 :   output_stream = g_io_stream_get_output_stream (G_IO_STREAM (connection));
     414                 :            : 
     415         [ -  + ]:          2 :   if (!valent_packet_to_stream (output_stream, identity, cancellable, &error))
     416                 :            :     {
     417                 :          0 :       g_debug ("%s(): sending identity to (%s:%"G_GINT64_FORMAT"): %s",
     418                 :            :                G_STRFUNC, host, port, error->message);
     419                 :          0 :       return g_task_return_error (task, g_steal_pointer (&error));
     420                 :            :     }
     421                 :            : 
     422                 :            :   /* NOTE: We're the server when opening outgoing connections */
     423                 :          2 :   valent_object_lock (VALENT_OBJECT (self));
     424                 :          2 :   certificate = g_object_ref (self->certificate);
     425                 :          2 :   valent_object_unlock (VALENT_OBJECT (self));
     426                 :            : 
     427                 :          2 :   tls_stream = valent_lan_encrypt_server_connection (connection,
     428                 :            :                                                      certificate,
     429                 :            :                                                      cancellable,
     430                 :            :                                                      &error);
     431                 :            : 
     432         [ -  + ]:          2 :   if (tls_stream == NULL)
     433                 :            :     {
     434                 :          0 :       g_debug ("%s(): authenticating (%s:%"G_GINT64_FORMAT"): %s",
     435                 :            :                G_STRFUNC, host, port, error->message);
     436                 :          0 :       return g_task_return_error (task, g_steal_pointer (&error));
     437                 :            :     }
     438                 :            : 
     439         [ -  + ]:          2 :   if (!valent_lan_channel_service_verify_channel (self, peer_identity, tls_stream))
     440                 :          0 :     return g_task_return_boolean (task, TRUE);
     441                 :            : 
     442                 :          2 :   channel = g_object_new (VALENT_TYPE_LAN_CHANNEL,
     443                 :            :                           "base-stream",   tls_stream,
     444                 :            :                           "host",          host,
     445                 :            :                           "port",          port,
     446                 :            :                           "identity",      identity,
     447                 :            :                           "peer-identity", peer_identity,
     448                 :            :                           NULL);
     449                 :            : 
     450                 :          2 :   valent_channel_service_channel (service, channel);
     451         [ -  + ]:          2 :   g_task_return_boolean (task, TRUE);
     452                 :            : }
     453                 :            : 
     454                 :            : static gboolean
     455                 :          2 : on_incoming_broadcast (ValentChannelService  *service,
     456                 :            :                        GSocket               *socket,
     457                 :            :                        GCancellable          *cancellable,
     458                 :            :                        GError               **error)
     459                 :            : {
     460                 :          2 :   gssize read = 0;
     461                 :          2 :   char buffer[IDENTITY_BUFFER_MAX + 1] = { 0, };
     462                 :          4 :   g_autoptr (GSocketAddress) incoming = NULL;
     463         [ +  - ]:          2 :   g_autoptr (GSocketAddress) outgoing = NULL;
     464                 :          2 :   GInetAddress *addr = NULL;
     465                 :          2 :   int64_t port = VALENT_LAN_PROTOCOL_PORT;
     466         [ +  - ]:          2 :   g_autoptr (JsonNode) peer_identity = NULL;
     467                 :          2 :   const char *device_id;
     468         [ +  - ]:          2 :   g_autofree char *local_id = NULL;
     469                 :          2 :   g_autoptr (GTask) task = NULL;
     470         [ +  - ]:          2 :   g_autoptr (GError) warning = NULL;
     471                 :            : 
     472         [ +  - ]:          2 :   g_assert (VALENT_IS_CHANNEL_SERVICE (service));
     473   [ +  -  +  -  :          2 :   g_assert (G_IS_SOCKET (socket));
             -  +  -  - ]
     474   [ +  -  +  -  :          2 :   g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  +  -  - ]
     475   [ +  -  -  + ]:          2 :   g_assert (error == NULL || *error == NULL);
     476                 :            : 
     477                 :            :   /* Read the message data and extract the remote address */
     478                 :          2 :   read = g_socket_receive_from (socket,
     479                 :            :                                 &incoming,
     480                 :            :                                 buffer,
     481                 :            :                                 IDENTITY_BUFFER_MAX,
     482                 :            :                                 cancellable,
     483                 :            :                                 error);
     484                 :            : 
     485         [ -  + ]:          2 :   if (read == -1)
     486                 :            :     return FALSE;
     487                 :            : 
     488         [ -  + ]:          2 :   if (read == 0)
     489                 :            :     {
     490                 :          0 :       g_set_error_literal (error,
     491                 :            :                            G_IO_ERROR,
     492                 :            :                            G_IO_ERROR_CLOSED,
     493                 :            :                            "Socket is closed");
     494                 :          0 :       return FALSE;
     495                 :            :     }
     496                 :            : 
     497                 :            :   /* Validate the message as a KDE Connect packet */
     498         [ -  + ]:          2 :   if ((peer_identity = valent_packet_deserialize (buffer, &warning)) == NULL)
     499                 :            :     {
     500                 :          0 :       g_warning ("%s(): failed to parse peer-identity: %s",
     501                 :            :                  G_STRFUNC,
     502                 :            :                  warning->message);
     503                 :          0 :       return TRUE;
     504                 :            :     }
     505                 :            : 
     506                 :            :   /* Ignore broadcasts without a deviceId or from ourselves */
     507         [ -  + ]:          2 :   if (!valent_packet_get_string (peer_identity, "deviceId", &device_id))
     508                 :            :     {
     509                 :          0 :       g_debug ("%s(): expected \"deviceId\" field holding a string",
     510                 :            :                G_STRFUNC);
     511                 :          0 :       return TRUE;
     512                 :            :     }
     513                 :            : 
     514                 :          2 :   local_id = valent_channel_service_dup_id (service);
     515                 :            : 
     516         [ -  + ]:          2 :   if (g_strcmp0 (device_id, local_id) == 0)
     517                 :            :     return TRUE;
     518                 :            : 
     519                 :          2 :   VALENT_JSON (peer_identity, device_id);
     520                 :            : 
     521                 :            :   /* Get the remote address and port */
     522                 :          2 :   addr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (incoming));
     523                 :            : 
     524         [ +  - ]:          2 :   if (!valent_packet_get_int (peer_identity, "tcpPort", &port) ||
     525         [ -  + ]:          2 :       (port < VALENT_LAN_PROTOCOL_PORT_MIN || port > VALENT_LAN_PROTOCOL_PORT_MAX))
     526                 :            :     {
     527                 :          0 :       g_debug ("%s(): expected \"tcpPort\" field holding a uint16 between %u-%u",
     528                 :            :                G_STRFUNC,
     529                 :            :                VALENT_LAN_PROTOCOL_PORT_MIN,
     530                 :            :                VALENT_LAN_PROTOCOL_PORT_MAX);
     531                 :          0 :       return TRUE;
     532                 :            :     }
     533                 :            : 
     534                 :            :   /* Defer the remaining work to another thread */
     535                 :          2 :   outgoing = g_inet_socket_address_new (addr, port);
     536                 :          2 :   g_object_set_data_full (G_OBJECT (outgoing),
     537                 :            :                           "valent-lan-broadcast",
     538                 :          2 :                           json_node_ref (peer_identity),
     539                 :            :                           (GDestroyNotify)json_node_unref);
     540                 :            : 
     541                 :          2 :   task = g_task_new (service, cancellable, NULL, NULL);
     542         [ +  - ]:          2 :   g_task_set_source_tag (task, on_incoming_broadcast);
     543                 :          2 :   g_task_set_task_data (task, g_steal_pointer (&outgoing), g_object_unref);
     544                 :          2 :   g_task_run_in_thread (task, incoming_broadcast_task);
     545                 :            : 
     546                 :          2 :   return TRUE;
     547                 :            : }
     548                 :            : 
     549                 :            : static gboolean
     550                 :          5 : valent_lan_channel_service_socket_recv (GSocket      *socket,
     551                 :            :                                         GIOCondition  condition,
     552                 :            :                                         gpointer      user_data)
     553                 :            : {
     554                 :          5 :   ValentChannelService *service = VALENT_CHANNEL_SERVICE (user_data);
     555                 :         10 :   g_autoptr (GCancellable) cancellable = NULL;
     556         [ +  + ]:          5 :   g_autoptr (GError) error = NULL;
     557                 :            : 
     558   [ +  -  +  -  :          5 :   g_assert (G_IS_SOCKET (socket));
             -  +  -  - ]
     559         [ -  + ]:          5 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (user_data));
     560                 :            : 
     561         [ +  + ]:          5 :   if (condition != G_IO_IN)
     562                 :            :     return G_SOURCE_REMOVE;
     563                 :            : 
     564                 :          2 :   cancellable = valent_object_ref_cancellable (VALENT_OBJECT (service));
     565                 :            : 
     566         [ -  + ]:          2 :   if (!on_incoming_broadcast (service, socket, cancellable, &error))
     567                 :            :     {
     568         [ #  # ]:          0 :       if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
     569                 :          0 :         g_warning ("%s(): %s", G_STRFUNC, error->message);
     570                 :            : 
     571                 :          0 :       return G_SOURCE_REMOVE;
     572                 :            :     }
     573                 :            : 
     574                 :            :   return G_SOURCE_CONTINUE;
     575                 :            : }
     576                 :            : 
     577                 :            : static gboolean
     578                 :          1 : valent_lan_channel_service_socket_send (GSocket      *socket,
     579                 :            :                                         GIOCondition  condition,
     580                 :            :                                         gpointer      user_data)
     581                 :            : {
     582                 :          1 :   GSocketAddress *address = G_SOCKET_ADDRESS (user_data);
     583                 :          1 :   GBytes *bytes = NULL;
     584                 :          1 :   gssize written;
     585                 :          2 :   g_autoptr (GError) error = NULL;
     586                 :            : 
     587   [ +  -  +  -  :          1 :   g_assert (G_IS_SOCKET (socket));
             -  +  -  - ]
     588   [ +  -  +  -  :          1 :   g_assert (G_IS_SOCKET_ADDRESS (address));
             +  -  -  + ]
     589                 :            : 
     590         [ +  - ]:          1 :   if (condition != G_IO_OUT)
     591                 :            :     return G_SOURCE_REMOVE;
     592                 :            : 
     593                 :          1 :   bytes = g_object_get_data (G_OBJECT (address), "valent-lan-broadcast");
     594                 :          2 :   written = g_socket_send_to (socket,
     595                 :            :                               address,
     596                 :          1 :                               g_bytes_get_data (bytes, NULL),
     597                 :            :                               g_bytes_get_size (bytes),
     598                 :            :                               NULL,
     599                 :            :                               &error);
     600                 :            : 
     601                 :            :   /* We only check for real errors, not partial writes */
     602         [ -  + ]:          1 :   if (written == -1)
     603                 :          0 :     g_warning ("%s(): failed to identify to \"%s\": %s",
     604                 :            :                G_STRFUNC,
     605                 :            :                "FIXME",
     606                 :            :                error->message);
     607                 :            : 
     608                 :            :   return G_SOURCE_REMOVE;
     609                 :            : }
     610                 :            : 
     611                 :            : static gpointer
     612                 :          3 : valent_lan_channel_service_socket_worker (gpointer data)
     613                 :            : {
     614                 :          6 :   g_autoptr (GMainLoop) loop = (GMainLoop *)data;
     615                 :          3 :   GMainContext *context = g_main_loop_get_context (loop);
     616                 :            : 
     617                 :            :   /* The loop quits when the channel is closed, then the context is drained to
     618                 :            :    * ensure all tasks return. */
     619                 :          3 :   g_main_context_push_thread_default (context);
     620                 :            : 
     621                 :          3 :   g_main_loop_run (loop);
     622                 :            : 
     623         [ -  + ]:          3 :   while (g_main_context_pending (context))
     624                 :          0 :     g_main_context_iteration (NULL, FALSE);
     625                 :            : 
     626                 :          3 :   g_main_context_pop_thread_default (context);
     627                 :            : 
     628         [ +  - ]:          3 :   return NULL;
     629                 :            : }
     630                 :            : 
     631                 :            : /**
     632                 :            :  * valent_lan_channel_service_udp_setup:
     633                 :            :  * @self: a #ValentLanChannelService
     634                 :            :  * @cancellable: (nullable): a #GCancellable
     635                 :            :  * @error: (nullable): a #GError
     636                 :            :  *
     637                 :            :  * An analog to valent_lan_channel_service_tcp_setup() that prepares UDP sockets
     638                 :            :  * for IPv4 and IPv6, including streams for reading.
     639                 :            :  *
     640                 :            :  * Returns: %TRUE if successful, or %FALSE with @error set
     641                 :            :  */
     642                 :            : static gboolean
     643                 :          3 : valent_lan_channel_service_udp_setup (ValentLanChannelService  *self,
     644                 :            :                                       GCancellable             *cancellable,
     645                 :            :                                       GError                  **error)
     646                 :            : {
     647                 :          6 :   g_autoptr (GMainContext) context = NULL;
     648         [ +  - ]:          3 :   g_autoptr (GMainLoop) loop = NULL;
     649         [ +  - ]:          3 :   g_autoptr (GThread) thread = NULL;
     650         [ +  - ]:          3 :   g_autoptr (GSocket) socket4 = NULL;
     651         [ -  + ]:          3 :   g_autoptr (GSocket) socket6 = NULL;
     652         [ +  - ]:          3 :   g_autoptr (GCancellable) destroy = NULL;
     653                 :          3 :   uint16_t port = VALENT_LAN_PROTOCOL_PORT;
     654                 :            : 
     655         [ +  - ]:          3 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (self));
     656                 :            : 
     657                 :          3 :   valent_object_lock (VALENT_OBJECT (self));
     658                 :          3 :   destroy = valent_object_ref_cancellable (VALENT_OBJECT (self));
     659                 :          3 :   port = self->port;
     660                 :          3 :   valent_object_unlock (VALENT_OBJECT (self));
     661                 :            : 
     662                 :            :   /* Create a thread with a GMainContext to manage traffic */
     663                 :          3 :   context = g_main_context_new ();
     664                 :          3 :   loop = g_main_loop_new (context, FALSE);
     665                 :          3 :   thread = g_thread_try_new ("valent-lan-channel-service",
     666                 :            :                              valent_lan_channel_service_socket_worker,
     667                 :          3 :                              g_main_loop_ref (loop),
     668                 :            :                              error);
     669                 :            : 
     670                 :            :   /* On failure, drop the reference passed to the thread */
     671         [ -  + ]:          3 :   if (thread == NULL)
     672                 :            :     {
     673                 :          0 :       g_main_loop_unref (loop);
     674                 :          0 :       return FALSE;
     675                 :            :     }
     676                 :            : 
     677                 :          3 :   valent_object_lock (VALENT_OBJECT (self));
     678                 :          3 :   self->udp_context = g_main_loop_ref (loop);
     679                 :          3 :   valent_object_unlock (VALENT_OBJECT (self));
     680                 :            : 
     681                 :            :   /* first try to create an IPv6 socket */
     682                 :          3 :   socket6 = g_socket_new (G_SOCKET_FAMILY_IPV6,
     683                 :            :                           G_SOCKET_TYPE_DATAGRAM,
     684                 :            :                           G_SOCKET_PROTOCOL_UDP,
     685                 :            :                           NULL);
     686                 :            : 
     687         [ +  - ]:          3 :   if (socket6 != NULL)
     688                 :            :     {
     689                 :          6 :       g_autoptr (GInetAddress) inet_address = NULL;
     690   [ -  -  +  - ]:          3 :       g_autoptr (GSocketAddress) address = NULL;
     691   [ -  -  +  - ]:          3 :       g_autoptr (GSource) source = NULL;
     692                 :            : 
     693                 :          3 :       inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV6);
     694                 :          3 :       address = g_inet_socket_address_new (inet_address, port);
     695                 :            : 
     696         [ +  - ]:          3 :       if (!g_socket_bind (socket6, address, TRUE, error))
     697                 :            :         return FALSE;
     698                 :            : 
     699                 :          3 :       g_socket_set_broadcast (socket6, TRUE);
     700                 :            : 
     701                 :          3 :       valent_object_lock (VALENT_OBJECT (self));
     702                 :          3 :       self->udp_socket6 = g_object_ref (socket6);
     703                 :          3 :       valent_object_unlock (VALENT_OBJECT (self));
     704                 :            : 
     705                 :            :       /* Watch for incoming broadcasts */
     706                 :          3 :       source = g_socket_create_source (socket6, G_IO_IN, destroy);
     707                 :          3 :       g_source_set_callback (source,
     708                 :            :                              G_SOURCE_FUNC (valent_lan_channel_service_socket_recv),
     709                 :            :                              g_object_ref (self),
     710                 :            :                              g_object_unref);
     711                 :          3 :       g_source_attach (source, context);
     712                 :            : 
     713                 :            :       /* If this socket also speaks IPv4 then we are done. */
     714         [ +  - ]:          3 :       if (g_socket_speaks_ipv4 (socket6))
     715         [ -  + ]:          3 :         return TRUE;
     716                 :            :     }
     717                 :            : 
     718                 :            :   /* We need an IPv4 socket, either instead or in addition to our IPv6 */
     719                 :          0 :   socket4 = g_socket_new (G_SOCKET_FAMILY_IPV4,
     720                 :            :                           G_SOCKET_TYPE_DATAGRAM,
     721                 :            :                           G_SOCKET_PROTOCOL_UDP,
     722                 :            :                           error);
     723                 :            : 
     724         [ #  # ]:          0 :   if (socket4 != NULL)
     725                 :            :     {
     726         [ +  - ]:          3 :       g_autoptr (GInetAddress) inet_address = NULL;
     727   [ #  #  #  # ]:          0 :       g_autoptr (GSocketAddress) address = NULL;
     728   [ #  #  #  # ]:          0 :       g_autoptr (GSource) source = NULL;
     729                 :            : 
     730                 :          0 :       inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
     731                 :          0 :       address = g_inet_socket_address_new (inet_address, port);
     732                 :            : 
     733         [ #  # ]:          0 :       if (!g_socket_bind (socket4, address, TRUE, error))
     734         [ #  # ]:          0 :         return FALSE;
     735                 :            : 
     736                 :          0 :       g_socket_set_broadcast (socket4, TRUE);
     737                 :            : 
     738                 :          0 :       valent_object_lock (VALENT_OBJECT (self));
     739                 :          0 :       self->udp_socket4 = g_object_ref (socket4);
     740                 :          0 :       valent_object_unlock (VALENT_OBJECT (self));
     741                 :            : 
     742                 :            :       /* Watch for incoming broadcasts */
     743                 :          0 :       source = g_socket_create_source (socket4, G_IO_IN, destroy);
     744                 :          0 :       g_source_set_callback (source,
     745                 :            :                              G_SOURCE_FUNC (valent_lan_channel_service_socket_recv),
     746                 :            :                              g_object_ref (self),
     747                 :            :                              g_object_unref);
     748         [ #  # ]:          0 :       g_source_attach (source, context);
     749                 :            :     }
     750                 :            : 
     751   [ #  #  #  # ]:          0 :   if (self->udp_socket4 == NULL && self->udp_socket6 == NULL)
     752                 :            :     return FALSE;
     753                 :            : 
     754                 :          0 :   g_clear_error (error);
     755                 :            : 
     756                 :          0 :   return TRUE;
     757                 :            : }
     758                 :            : 
     759                 :            : 
     760                 :            : /*
     761                 :            :  * ValentChannelService
     762                 :            :  */
     763                 :            : static void
     764                 :          6 : valent_lan_channel_service_build_identity (ValentChannelService *service)
     765                 :            : {
     766                 :          6 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (service);
     767                 :          6 :   ValentChannelServiceClass *klass;
     768                 :         12 :   g_autoptr (JsonNode) identity = NULL;
     769                 :            : 
     770         [ +  - ]:          6 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (service));
     771                 :            : 
     772                 :            :   /* Chain-up */
     773                 :          6 :   klass = VALENT_CHANNEL_SERVICE_CLASS (valent_lan_channel_service_parent_class);
     774                 :          6 :   klass->build_identity (service);
     775                 :            : 
     776                 :            :   /* Set the tcpPort on the packet */
     777                 :          6 :   identity = valent_channel_service_ref_identity (service);
     778                 :            : 
     779         [ +  - ]:          6 :   if (identity != NULL)
     780                 :            :     {
     781                 :          6 :       JsonObject *body;
     782                 :            : 
     783                 :          6 :       body = valent_packet_get_body (identity);
     784                 :          6 :       json_object_set_int_member (body, "tcpPort", self->tcp_port);
     785                 :            :     }
     786                 :          6 : }
     787                 :            : 
     788                 :            : static void
     789                 :          3 : valent_lan_channel_service_channel (ValentChannelService *service,
     790                 :            :                                     ValentChannel        *channel)
     791                 :            : {
     792                 :          3 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (service);
     793                 :          3 :   ValentLanChannel *lan_channel = VALENT_LAN_CHANNEL (channel);
     794                 :          6 :   g_autoptr (GTlsCertificate) peer_certificate = NULL;
     795                 :          3 :   const char *device_id = NULL;
     796                 :            : 
     797         [ +  - ]:          3 :   g_assert (VALENT_IS_MAIN_THREAD ());
     798         [ -  + ]:          3 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (self));
     799         [ -  + ]:          3 :   g_assert (VALENT_IS_LAN_CHANNEL (lan_channel));
     800                 :            : 
     801                 :          3 :   peer_certificate = valent_lan_channel_ref_peer_certificate (lan_channel);
     802                 :          3 :   device_id = valent_certificate_get_common_name (peer_certificate);
     803                 :            : 
     804                 :          3 :   valent_object_lock (VALENT_OBJECT (service));
     805         [ -  + ]:          6 :   g_hash_table_replace (self->channels, g_strdup (device_id), channel);
     806                 :          3 :   g_signal_connect_object (channel,
     807                 :            :                            "destroy",
     808                 :            :                            G_CALLBACK (on_channel_destroyed),
     809                 :            :                            self,
     810                 :            :                            G_CONNECT_SWAPPED);
     811         [ +  - ]:          3 :   valent_object_unlock (VALENT_OBJECT (service));
     812                 :          3 : }
     813                 :            : 
     814                 :            : static void
     815                 :          1 : valent_lan_channel_service_identify (ValentChannelService *service,
     816                 :            :                                      const char           *target)
     817                 :            : {
     818                 :          1 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (service);
     819                 :          0 :   g_autoptr (GSocketConnectable) naddr = NULL;
     820         [ +  - ]:          1 :   g_autoptr (GSocketAddress) address = NULL;
     821         [ +  - ]:          1 :   g_autoptr (JsonNode) identity = NULL;
     822         [ +  - ]:          1 :   g_autofree char *identity_json = NULL;
     823                 :          1 :   const char *hostname = self->broadcast_address;
     824                 :          1 :   uint16_t port = self->port;
     825                 :            : 
     826         [ +  - ]:          1 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (self));
     827                 :            : 
     828         [ +  - ]:          1 :   if (!self->network_available)
     829                 :            :     return;
     830                 :            : 
     831         [ +  - ]:          1 :   if (target != NULL)
     832                 :            :     {
     833                 :          1 :       g_autoptr (GError) error = NULL;
     834                 :            : 
     835                 :          1 :       naddr = g_network_address_parse (target,
     836                 :            :                                        VALENT_LAN_PROTOCOL_PORT,
     837                 :            :                                        &error);
     838                 :            : 
     839         [ -  + ]:          1 :       if (naddr == NULL)
     840                 :            :         {
     841                 :          0 :           g_warning ("%s(): failed to parse \"%s\": %s",
     842                 :            :                      G_STRFUNC,
     843                 :            :                      target,
     844                 :            :                      error->message);
     845         [ #  # ]:          0 :           return;
     846                 :            :         }
     847                 :            : 
     848                 :          1 :       hostname = g_network_address_get_hostname (G_NETWORK_ADDRESS (naddr));
     849         [ -  + ]:          1 :       port = g_network_address_get_port (G_NETWORK_ADDRESS (naddr));
     850                 :            :     }
     851                 :            : 
     852                 :          1 :   address = g_inet_socket_address_new_from_string (hostname, port);
     853                 :            : 
     854                 :            :   /* Serialize the identity */
     855                 :          1 :   identity = valent_channel_service_ref_identity (service);
     856                 :          1 :   identity_json = valent_packet_serialize (identity);
     857                 :            : 
     858                 :          1 :   g_object_set_data_full (G_OBJECT (address),
     859                 :            :                           "valent-lan-broadcast",
     860                 :          1 :                           g_bytes_new (identity_json, strlen (identity_json)),
     861                 :            :                           (GDestroyNotify)g_bytes_unref);
     862                 :            : 
     863                 :            :   /* IPv6 */
     864         [ +  - ]:          1 :   if (self->udp_socket6 != NULL)
     865                 :            :     {
     866                 :          2 :       g_autoptr (GSource) source = NULL;
     867                 :            : 
     868                 :          1 :       source = g_socket_create_source (self->udp_socket6, G_IO_OUT, NULL);
     869                 :          1 :       g_source_set_callback (source,
     870                 :            :                              G_SOURCE_FUNC (valent_lan_channel_service_socket_send),
     871                 :            :                              g_object_ref (address),
     872                 :            :                              g_object_unref);
     873         [ +  - ]:          1 :       g_source_attach (source, g_main_loop_get_context (self->udp_context));
     874                 :            :     }
     875                 :            : 
     876                 :            :   /* IPv4 */
     877         [ -  + ]:          1 :   if (self->udp_socket4 != NULL)
     878                 :            :     {
     879                 :          1 :       g_autoptr (GSource) source = NULL;
     880                 :            : 
     881                 :          0 :       source = g_socket_create_source (self->udp_socket4, G_IO_OUT, NULL);
     882                 :          0 :       g_source_set_callback (source,
     883                 :            :                              G_SOURCE_FUNC (valent_lan_channel_service_socket_send),
     884                 :            :                              g_object_ref (address),
     885                 :            :                              g_object_unref);
     886         [ #  # ]:          0 :       g_source_attach (source, g_main_loop_get_context (self->udp_context));
     887                 :            :     }
     888                 :            : }
     889                 :            : 
     890                 :            : static void
     891                 :          3 : valent_lan_channel_service_init_task (GTask        *task,
     892                 :            :                                       gpointer      source_object,
     893                 :            :                                       gpointer      task_data,
     894                 :            :                                       GCancellable *cancellable)
     895                 :            : {
     896                 :          3 :   ValentLanChannelService *self = source_object;
     897                 :          3 :   g_autoptr (GError) error = NULL;
     898                 :            : 
     899         [ +  - ]:          3 :   if (g_task_return_error_if_cancelled (task))
     900                 :            :     return;
     901                 :            : 
     902                 :            :   /* TCP Listener */
     903         [ -  + ]:          3 :   if (!valent_lan_channel_service_tcp_setup (self, cancellable, &error))
     904                 :          0 :     return g_task_return_error (task, g_steal_pointer (&error));
     905                 :            : 
     906                 :            :   /* UDP Socket(s) */
     907         [ -  + ]:          3 :   if (!valent_lan_channel_service_udp_setup (self, cancellable, &error))
     908                 :          0 :     return g_task_return_error (task, g_steal_pointer (&error));
     909                 :            : 
     910         [ -  + ]:          3 :   g_task_return_boolean (task, TRUE);
     911                 :            : }
     912                 :            : 
     913                 :            : static void
     914                 :          3 : valent_certificate_new_cb (GObject      *object,
     915                 :            :                            GAsyncResult *result,
     916                 :            :                            gpointer      user_data)
     917                 :            : {
     918                 :          6 :   g_autoptr (GTask) task = G_TASK (user_data);
     919                 :          3 :   ValentLanChannelService *self = g_task_get_source_object (task);
     920                 :          3 :   GError *error = NULL;
     921                 :            : 
     922                 :          3 :   valent_object_lock (VALENT_OBJECT (self));
     923                 :          3 :   self->certificate = valent_certificate_new_finish (result, &error);
     924                 :          3 :   valent_object_unlock (VALENT_OBJECT (self));
     925                 :            : 
     926         [ +  - ]:          3 :   g_task_run_in_thread (task, valent_lan_channel_service_init_task);
     927                 :          3 : }
     928                 :            : 
     929                 :            : /*
     930                 :            :  * GAsyncInitable
     931                 :            :  */
     932                 :            : static void
     933                 :          3 : valent_lan_channel_service_init_async (GAsyncInitable      *initable,
     934                 :            :                                        int                  io_priority,
     935                 :            :                                        GCancellable        *cancellable,
     936                 :            :                                        GAsyncReadyCallback  callback,
     937                 :            :                                        gpointer             user_data)
     938                 :            : {
     939                 :          3 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (initable);
     940                 :          6 :   g_autoptr (GTask) task = NULL;
     941                 :          6 :   g_autoptr (GCancellable) destroy = NULL;
     942         [ +  - ]:          3 :   g_autoptr (GFile) config_dir = NULL;
     943         [ +  - ]:          3 :   g_autoptr (ValentContext) context = NULL;
     944                 :          3 :   ValentContext *root_context = NULL;
     945                 :            : 
     946         [ +  - ]:          3 :   g_assert (VALENT_IS_LAN_CHANNEL_SERVICE (initable));
     947   [ -  +  -  -  :          3 :   g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  -  -  - ]
     948                 :            : 
     949                 :            :   /* Cancel initialization if the object is destroyed */
     950                 :          3 :   destroy = valent_object_attach_cancellable (VALENT_OBJECT (initable),
     951                 :            :                                               cancellable);
     952                 :            : 
     953                 :          3 :   self->network_available = g_network_monitor_get_network_available (self->monitor);
     954                 :          3 :   g_signal_connect_object (self->monitor,
     955                 :            :                            "network-changed",
     956                 :            :                            G_CALLBACK (on_network_changed),
     957                 :            :                            self, 0);
     958                 :            : 
     959                 :          3 :   task = g_task_new (initable, destroy, callback, user_data);
     960                 :          3 :   g_task_set_priority (task, io_priority);
     961         [ +  - ]:          3 :   g_task_set_source_tag (task, valent_lan_channel_service_init_async);
     962                 :            : 
     963                 :            :   // TODO: the certificate is in the root context
     964                 :          3 :   g_object_get (initable, "context", &context, NULL);
     965                 :          3 :   root_context = valent_context_get_root (context);
     966                 :          3 :   config_dir = valent_context_get_config_file (root_context, ".");
     967                 :            : 
     968         [ +  - ]:          3 :   valent_certificate_new (g_file_peek_path (config_dir),
     969                 :            :                           destroy,
     970                 :            :                           valent_certificate_new_cb,
     971                 :            :                           g_steal_pointer (&task));
     972                 :          3 : }
     973                 :            : 
     974                 :            : static void
     975                 :          1 : g_async_initable_iface_init (GAsyncInitableIface *iface)
     976                 :            : {
     977                 :          1 :   iface->init_async = valent_lan_channel_service_init_async;
     978                 :          1 : }
     979                 :            : 
     980                 :            : 
     981                 :            : /*
     982                 :            :  * GObject
     983                 :            :  */
     984                 :            : static void
     985                 :          6 : valent_lan_channel_service_dispose (GObject *object)
     986                 :            : {
     987                 :          6 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (object);
     988                 :            : 
     989                 :          6 :   g_signal_handlers_disconnect_by_data (self->monitor, self);
     990                 :            : 
     991                 :          6 :   valent_object_lock (VALENT_OBJECT (self));
     992         [ +  + ]:          6 :   if (self->listener != NULL)
     993                 :            :     {
     994                 :          3 :       g_socket_service_stop (G_SOCKET_SERVICE (self->listener));
     995                 :          3 :       g_socket_listener_close (G_SOCKET_LISTENER (self->listener));
     996         [ +  - ]:          3 :       g_clear_object (&self->listener);
     997                 :            :     }
     998                 :            : 
     999         [ +  + ]:          6 :   if (self->udp_context != NULL)
    1000                 :          3 :     g_main_loop_quit (self->udp_context);
    1001         [ +  + ]:          6 :   g_clear_pointer (&self->udp_context, g_main_loop_unref);
    1002                 :            : 
    1003         [ -  + ]:          6 :   g_clear_object (&self->udp_socket4);
    1004         [ +  + ]:          6 :   g_clear_object (&self->udp_socket6);
    1005                 :          6 :   valent_object_unlock (VALENT_OBJECT (self));
    1006                 :            : 
    1007                 :          6 :   G_OBJECT_CLASS (valent_lan_channel_service_parent_class)->dispose (object);
    1008                 :          6 : }
    1009                 :            : 
    1010                 :            : static void
    1011                 :          3 : valent_lan_channel_service_finalize (GObject *object)
    1012                 :            : {
    1013                 :          3 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (object);
    1014                 :            : 
    1015         [ +  - ]:          3 :   g_clear_object (&self->certificate);
    1016         [ +  - ]:          3 :   g_clear_pointer (&self->broadcast_address, g_free);
    1017         [ +  - ]:          3 :   g_clear_pointer (&self->channels, g_hash_table_unref);
    1018                 :            : 
    1019                 :          3 :   G_OBJECT_CLASS (valent_lan_channel_service_parent_class)->finalize (object);
    1020                 :          3 : }
    1021                 :            : 
    1022                 :            : static void
    1023                 :          0 : valent_lan_channel_service_get_property (GObject    *object,
    1024                 :            :                                          guint       prop_id,
    1025                 :            :                                          GValue     *value,
    1026                 :            :                                          GParamSpec *pspec)
    1027                 :            : {
    1028                 :          0 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (object);
    1029                 :            : 
    1030   [ #  #  #  # ]:          0 :   switch (prop_id)
    1031                 :            :     {
    1032                 :          0 :     case PROP_BROADCAST_ADDRESS:
    1033                 :          0 :       g_value_set_string (value, self->broadcast_address);
    1034                 :          0 :       break;
    1035                 :            : 
    1036                 :          0 :     case PROP_CERTIFICATE:
    1037                 :          0 :       g_value_set_object (value, self->certificate);
    1038                 :          0 :       break;
    1039                 :            : 
    1040                 :          0 :     case PROP_PORT:
    1041                 :          0 :       g_value_set_uint (value, self->port);
    1042                 :          0 :       break;
    1043                 :            : 
    1044                 :          0 :     default:
    1045                 :          0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    1046                 :            :     }
    1047                 :          0 : }
    1048                 :            : 
    1049                 :            : static void
    1050                 :          6 : valent_lan_channel_service_set_property (GObject      *object,
    1051                 :            :                                          guint         prop_id,
    1052                 :            :                                          const GValue *value,
    1053                 :            :                                          GParamSpec   *pspec)
    1054                 :            : {
    1055                 :          6 :   ValentLanChannelService *self = VALENT_LAN_CHANNEL_SERVICE (object);
    1056                 :            : 
    1057      [ +  +  - ]:          6 :   switch (prop_id)
    1058                 :            :     {
    1059                 :          3 :     case PROP_BROADCAST_ADDRESS:
    1060                 :          3 :       self->broadcast_address = g_value_dup_string (value);
    1061                 :          3 :       break;
    1062                 :            : 
    1063                 :          3 :     case PROP_PORT:
    1064                 :          3 :       self->port = g_value_get_uint (value);
    1065                 :          3 :       break;
    1066                 :            : 
    1067                 :          0 :     default:
    1068                 :          0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    1069                 :            :     }
    1070                 :          6 : }
    1071                 :            : 
    1072                 :            : static void
    1073                 :          1 : valent_lan_channel_service_class_init (ValentLanChannelServiceClass *klass)
    1074                 :            : {
    1075                 :          1 :   GObjectClass *object_class = G_OBJECT_CLASS (klass);
    1076                 :          1 :   ValentChannelServiceClass *service_class = VALENT_CHANNEL_SERVICE_CLASS (klass);
    1077                 :            : 
    1078                 :          1 :   object_class->dispose = valent_lan_channel_service_dispose;
    1079                 :          1 :   object_class->finalize = valent_lan_channel_service_finalize;
    1080                 :          1 :   object_class->get_property = valent_lan_channel_service_get_property;
    1081                 :          1 :   object_class->set_property = valent_lan_channel_service_set_property;
    1082                 :            : 
    1083                 :          1 :   service_class->build_identity = valent_lan_channel_service_build_identity;
    1084                 :          1 :   service_class->channel = valent_lan_channel_service_channel;
    1085                 :          1 :   service_class->identify = valent_lan_channel_service_identify;
    1086                 :            : 
    1087                 :            :   /**
    1088                 :            :    * ValentLanChannelService:broadcast-address:
    1089                 :            :    *
    1090                 :            :    * The UDP broadcast address for the service.
    1091                 :            :    *
    1092                 :            :    * This available as a construct property primarily for use in unit tests.
    1093                 :            :    */
    1094                 :          2 :   properties [PROP_BROADCAST_ADDRESS] =
    1095                 :          1 :     g_param_spec_string ("broadcast-address", NULL, NULL,
    1096                 :            :                          VALENT_LAN_PROTOCOL_ADDR,
    1097                 :            :                          (G_PARAM_READWRITE |
    1098                 :            :                           G_PARAM_CONSTRUCT_ONLY |
    1099                 :            :                           G_PARAM_EXPLICIT_NOTIFY |
    1100                 :            :                           G_PARAM_STATIC_STRINGS));
    1101                 :            : 
    1102                 :            :   /**
    1103                 :            :    * ValentLanChannelService:certificate:
    1104                 :            :    *
    1105                 :            :    * The TLS certificate the service uses to authenticate with other devices.
    1106                 :            :    */
    1107                 :          2 :   properties [PROP_CERTIFICATE] =
    1108                 :          1 :     g_param_spec_object ("certificate", NULL, NULL,
    1109                 :            :                          G_TYPE_TLS_CERTIFICATE,
    1110                 :            :                          (G_PARAM_READABLE |
    1111                 :            :                           G_PARAM_EXPLICIT_NOTIFY |
    1112                 :            :                           G_PARAM_STATIC_STRINGS));
    1113                 :            : 
    1114                 :            :   /**
    1115                 :            :    * ValentLanChannelService:port:
    1116                 :            :    *
    1117                 :            :    * The TCP/IP port for the service.
    1118                 :            :    *
    1119                 :            :    * The current KDE Connect protocol (v7) defines port 1716 as the default.
    1120                 :            :    *
    1121                 :            :    * This available as a construct property primarily for use in unit tests.
    1122                 :            :    */
    1123                 :          2 :   properties [PROP_PORT] =
    1124                 :          1 :     g_param_spec_uint ("port", NULL, NULL,
    1125                 :            :                        VALENT_LAN_PROTOCOL_PORT_MIN, VALENT_LAN_PROTOCOL_PORT_MAX,
    1126                 :            :                        VALENT_LAN_PROTOCOL_PORT,
    1127                 :            :                        (G_PARAM_READWRITE |
    1128                 :            :                         G_PARAM_CONSTRUCT_ONLY |
    1129                 :            :                         G_PARAM_EXPLICIT_NOTIFY |
    1130                 :            :                         G_PARAM_STATIC_STRINGS));
    1131                 :            : 
    1132                 :          1 :   g_object_class_install_properties (object_class, N_PROPERTIES, properties);
    1133                 :          1 : }
    1134                 :            : 
    1135                 :            : static void
    1136                 :          3 : valent_lan_channel_service_init (ValentLanChannelService *self)
    1137                 :            : {
    1138                 :          3 :   self->channels = g_hash_table_new_full (g_str_hash,
    1139                 :            :                                           g_str_equal,
    1140                 :            :                                           g_free,
    1141                 :            :                                           NULL);
    1142                 :          3 :   self->monitor = g_network_monitor_get_default ();
    1143                 :          3 : }
    1144                 :            : 

Generated by: LCOV version 1.14