LCOV - code coverage report
Current view: top level - src/libvalent/device - valent-channel.c (source / functions) Coverage Total Hit
Test: Code Coverage Lines: 97.2 % 322 313
Test Date: 2025-03-21 05:08:07 Functions: 100.0 % 33 33
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 50.7 % 268 136

             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-channel"
       5                 :             : 
       6                 :             : #include "config.h"
       7                 :             : 
       8                 :             : #include <time.h>
       9                 :             : 
      10                 :             : #include <gio/gio.h>
      11                 :             : #include <json-glib/json-glib.h>
      12                 :             : #include <libvalent-core.h>
      13                 :             : 
      14                 :             : #include "valent-certificate.h"
      15                 :             : #include "valent-packet.h"
      16                 :             : 
      17                 :             : #include "valent-channel.h"
      18                 :             : 
      19                 :             : 
      20                 :             : /**
      21                 :             :  * ValentChannel:
      22                 :             :  *
      23                 :             :  * A base class for device connections.
      24                 :             :  *
      25                 :             :  * `ValentChannel` is a base class for the primary communication channel in
      26                 :             :  * Valent. It is effectively an abstraction layer around a [class@Gio.IOStream].
      27                 :             :  *
      28                 :             :  * ## Packet Exchange
      29                 :             :  *
      30                 :             :  * The core of the KDE Connect protocol is built on the exchange of JSON
      31                 :             :  * packets, similar to JSON-RPC. Packets can be queued concurrently from
      32                 :             :  * different threads with [method@Valent.Channel.write_packet] and read
      33                 :             :  * sequentially with [method@Valent.Channel.read_packet].
      34                 :             :  *
      35                 :             :  * Packets may contain payload information, allowing devices to negotiate
      36                 :             :  * auxiliary connections. Incoming connections can be accepted by passing the
      37                 :             :  * packet to [method@Valent.Channel.download], or opened by passing the packet
      38                 :             :  * to [method@Valent.Channel.upload].
      39                 :             :  *
      40                 :             :  * ## Implementation Notes
      41                 :             :  *
      42                 :             :  * Implementations should override [vfunc@Valent.Channel.download] and
      43                 :             :  * [vfunc@Valent.Channel.upload] to support accepting and opening auxiliary
      44                 :             :  * connections, respectively. To know when to store persistent data related to
      45                 :             :  * the connection, override [vfunc@Valent.Channel.store_data].
      46                 :             :  *
      47                 :             :  * Since: 1.0
      48                 :             :  */
      49                 :             : 
      50                 :             : typedef struct
      51                 :             : {
      52                 :             :   GIOStream        *base_stream;
      53                 :             :   GTlsCertificate  *certificate;
      54                 :             :   JsonNode         *identity;
      55                 :             :   GTlsCertificate  *peer_certificate;
      56                 :             :   JsonNode         *peer_identity;
      57                 :             : 
      58                 :             :   /* Packet Buffer */
      59                 :             :   GDataInputStream *input_buffer;
      60                 :             :   GMainLoop        *output_buffer;
      61                 :             : } ValentChannelPrivate;
      62                 :             : 
      63   [ +  +  +  - ]:        6648 : G_DEFINE_TYPE_WITH_PRIVATE (ValentChannel, valent_channel, VALENT_TYPE_OBJECT)
      64                 :             : 
      65                 :             : typedef enum {
      66                 :             :   PROP_BASE_STREAM = 1,
      67                 :             :   PROP_CERTIFICATE,
      68                 :             :   PROP_IDENTITY,
      69                 :             :   PROP_PEER_CERTIFICATE,
      70                 :             :   PROP_PEER_IDENTITY,
      71                 :             : } ValentChannelProperty;
      72                 :             : 
      73                 :             : static GParamSpec *properties[PROP_PEER_IDENTITY + 1] = { NULL, };
      74                 :             : 
      75                 :             : 
      76                 :             : /* LCOV_EXCL_START */
      77                 :             : static GIOStream *
      78                 :             : valent_channel_real_download (ValentChannel  *channel,
      79                 :             :                               JsonNode       *packet,
      80                 :             :                               GCancellable   *cancellable,
      81                 :             :                               GError        **error)
      82                 :             : {
      83                 :             :   g_set_error (error,
      84                 :             :                G_IO_ERROR,
      85                 :             :                G_IO_ERROR_NOT_SUPPORTED,
      86                 :             :                "%s does not implement download()",
      87                 :             :                G_OBJECT_TYPE_NAME (channel));
      88                 :             :   return NULL;
      89                 :             : }
      90                 :             : 
      91                 :             : static void
      92                 :             : valent_channel_real_download_task (GTask        *task,
      93                 :             :                                    gpointer      source_object,
      94                 :             :                                    gpointer      task_data,
      95                 :             :                                    GCancellable *cancellable)
      96                 :             : {
      97                 :             :   ValentChannel *self = source_object;
      98                 :             :   JsonNode *packet = task_data;
      99                 :             :   g_autoptr (GIOStream) stream = NULL;
     100                 :             :   GError *error = NULL;
     101                 :             : 
     102                 :             :   if (g_task_return_error_if_cancelled (task))
     103                 :             :     return;
     104                 :             : 
     105                 :             :   stream = valent_channel_download (self, packet, cancellable, &error);
     106                 :             :   if (stream != NULL)
     107                 :             :     g_task_return_pointer (task, g_steal_pointer (&stream), g_object_unref);
     108                 :             :   else
     109                 :             :     g_task_return_error (task, error);
     110                 :             : }
     111                 :             : 
     112                 :             : static void
     113                 :             : valent_channel_real_download_async (ValentChannel       *channel,
     114                 :             :                                     JsonNode            *packet,
     115                 :             :                                     GCancellable        *cancellable,
     116                 :             :                                     GAsyncReadyCallback  callback,
     117                 :             :                                     gpointer             user_data)
     118                 :             : {
     119                 :             :   g_autoptr (GTask) task = NULL;
     120                 :             : 
     121                 :             :   g_assert (VALENT_IS_CHANNEL (channel));
     122                 :             :   g_assert (VALENT_IS_PACKET (packet));
     123                 :             :   g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
     124                 :             : 
     125                 :             :   task = g_task_new (channel, cancellable, callback, user_data);
     126                 :             :   g_task_set_source_tag (task, valent_channel_real_download_async);
     127                 :             :   g_task_set_task_data (task,
     128                 :             :                         json_node_ref (packet),
     129                 :             :                         (GDestroyNotify)json_node_unref);
     130                 :             :   g_task_run_in_thread (task, valent_channel_real_download_task);
     131                 :             : }
     132                 :             : 
     133                 :             : static GIOStream *
     134                 :             : valent_channel_real_download_finish (ValentChannel  *channel,
     135                 :             :                                      GAsyncResult   *result,
     136                 :             :                                      GError        **error)
     137                 :             : {
     138                 :             :   g_assert (VALENT_IS_CHANNEL (channel));
     139                 :             :   g_assert (g_task_is_valid (result, channel));
     140                 :             :   g_assert (error == NULL || *error == NULL);
     141                 :             : 
     142                 :             :   return g_task_propagate_pointer (G_TASK (result), error);
     143                 :             : }
     144                 :             : 
     145                 :             : static GIOStream *
     146                 :             : valent_channel_real_upload (ValentChannel  *channel,
     147                 :             :                             JsonNode       *packet,
     148                 :             :                             GCancellable   *cancellable,
     149                 :             :                             GError        **error)
     150                 :             : {
     151                 :             :   g_set_error (error,
     152                 :             :                G_IO_ERROR,
     153                 :             :                G_IO_ERROR_NOT_SUPPORTED,
     154                 :             :                "%s does not implement upload()",
     155                 :             :                G_OBJECT_TYPE_NAME (channel));
     156                 :             :   return NULL;
     157                 :             : }
     158                 :             : 
     159                 :             : static void
     160                 :             : valent_channel_upload_task (GTask        *task,
     161                 :             :                             gpointer      source_object,
     162                 :             :                             gpointer      task_data,
     163                 :             :                             GCancellable *cancellable)
     164                 :             : {
     165                 :             :   ValentChannel *self = source_object;
     166                 :             :   JsonNode *packet = task_data;
     167                 :             :   g_autoptr (GIOStream) stream = NULL;
     168                 :             :   GError *error = NULL;
     169                 :             : 
     170                 :             :   if (g_task_return_error_if_cancelled (task))
     171                 :             :     return;
     172                 :             : 
     173                 :             :   stream = valent_channel_upload (self, packet, cancellable, &error);
     174                 :             :   if (stream != NULL)
     175                 :             :     g_task_return_pointer (task, g_steal_pointer (&stream), g_object_unref);
     176                 :             :   else
     177                 :             :     g_task_return_error (task, error);
     178                 :             : }
     179                 :             : 
     180                 :             : static void
     181                 :             : valent_channel_real_upload_async (ValentChannel       *channel,
     182                 :             :                                   JsonNode            *packet,
     183                 :             :                                   GCancellable        *cancellable,
     184                 :             :                                   GAsyncReadyCallback  callback,
     185                 :             :                                   gpointer             user_data)
     186                 :             : {
     187                 :             :   g_autoptr (GTask) task = NULL;
     188                 :             : 
     189                 :             :   g_assert (VALENT_IS_CHANNEL (channel));
     190                 :             :   g_assert (VALENT_IS_PACKET (packet));
     191                 :             :   g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
     192                 :             : 
     193                 :             :   task = g_task_new (channel, cancellable, callback, user_data);
     194                 :             :   g_task_set_source_tag (task, valent_channel_real_upload_async);
     195                 :             :   g_task_set_task_data (task,
     196                 :             :                         json_node_ref (packet),
     197                 :             :                         (GDestroyNotify)json_node_unref);
     198                 :             :   g_task_run_in_thread (task, valent_channel_upload_task);
     199                 :             : }
     200                 :             : 
     201                 :             : static GIOStream *
     202                 :             : valent_channel_real_upload_finish (ValentChannel  *channel,
     203                 :             :                                    GAsyncResult   *result,
     204                 :             :                                    GError        **error)
     205                 :             : {
     206                 :             :   g_assert (VALENT_IS_CHANNEL (channel));
     207                 :             :   g_assert (g_task_is_valid (result, channel));
     208                 :             :   g_assert (error == NULL || *error == NULL);
     209                 :             : 
     210                 :             :   return g_task_propagate_pointer (G_TASK (result), error);
     211                 :             : }
     212                 :             : 
     213                 :             : static void
     214                 :             : valent_channel_real_store_data (ValentChannel *channel,
     215                 :             :                                 ValentContext *context)
     216                 :             : {
     217                 :             :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     218                 :             : 
     219                 :             :   g_assert (VALENT_IS_CHANNEL (channel));
     220                 :             :   g_assert (VALENT_IS_CONTEXT (context));
     221                 :             : 
     222                 :             :   if (priv->certificate != NULL)
     223                 :             :     {
     224                 :             :       g_autofree char *certificate_pem = NULL;
     225                 :             :       g_autoptr (GFile) certificate_file = NULL;
     226                 :             :       g_autoptr (GError) error = NULL;
     227                 :             : 
     228                 :             :       g_object_get (priv->peer_certificate,
     229                 :             :                     "certificate-pem", &certificate_pem,
     230                 :             :                     NULL);
     231                 :             :       certificate_file = valent_context_get_config_file (context,
     232                 :             :                                                          "certificate.pem");
     233                 :             :       g_file_set_contents_full (g_file_peek_path (certificate_file),
     234                 :             :                                 certificate_pem,
     235                 :             :                                 strlen (certificate_pem),
     236                 :             :                                 G_FILE_SET_CONTENTS_DURABLE,
     237                 :             :                                 0600,
     238                 :             :                                 &error);
     239                 :             : 
     240                 :             :       if (error != NULL)
     241                 :             :         {
     242                 :             :           g_warning ("%s(): failed to write \"%s\": %s",
     243                 :             :                      G_STRFUNC,
     244                 :             :                      g_file_peek_path (certificate_file),
     245                 :             :                      error->message);
     246                 :             :         }
     247                 :             :     }
     248                 :             : }
     249                 :             : /* LCOV_EXCL_STOP */
     250                 :             : 
     251                 :             : 
     252                 :             : /*
     253                 :             :  * ValentChannel
     254                 :             :  */
     255                 :             : static inline gboolean
     256                 :         938 : valent_channel_return_error_if_closed (ValentChannel *self,
     257                 :             :                                        GTask         *task)
     258                 :             : {
     259                 :         938 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (self);
     260                 :             : 
     261         [ -  + ]:         938 :   if (g_task_return_error_if_cancelled (task))
     262                 :             :     return TRUE;
     263                 :             : 
     264                 :         938 :   valent_object_lock (VALENT_OBJECT (self));
     265   [ +  -  +  + ]:         938 :   if (priv->base_stream == NULL || g_io_stream_is_closed (priv->base_stream))
     266                 :             :     {
     267         [ -  + ]:           7 :       if (priv->output_buffer != NULL)
     268                 :           0 :         g_main_loop_quit (priv->output_buffer);
     269         [ -  + ]:           7 :       g_clear_pointer (&priv->output_buffer, g_main_loop_unref);
     270         [ -  + ]:           7 :       g_clear_object (&priv->input_buffer);
     271                 :           7 :       valent_object_unlock (VALENT_OBJECT (self));
     272                 :             : 
     273                 :           7 :       g_task_return_new_error (task,
     274                 :             :                                G_IO_ERROR,
     275                 :             :                                G_IO_ERROR_CONNECTION_CLOSED,
     276                 :             :                                "Channel is closed");
     277                 :           7 :       return TRUE;
     278                 :             :     }
     279                 :             : 
     280                 :             :   return FALSE;
     281                 :             : }
     282                 :             : 
     283                 :             : static gpointer
     284                 :         208 : valent_channel_write_packet_worker (gpointer data)
     285                 :             : {
     286                 :         402 :   g_autoptr (GMainLoop) loop = (GMainLoop *)data;
     287                 :         208 :   GMainContext *context = g_main_loop_get_context (loop);
     288                 :             : 
     289                 :             :   /* The loop quits when the channel is closed, then the context is drained to
     290                 :             :    * ensure all tasks return. */
     291                 :         208 :   g_main_context_push_thread_default (context);
     292                 :             : 
     293                 :         208 :   g_main_loop_run (loop);
     294                 :             : 
     295         [ -  + ]:         208 :   while (g_main_context_pending (context))
     296                 :           0 :     g_main_context_iteration (NULL, FALSE);
     297                 :             : 
     298                 :         194 :   g_main_context_pop_thread_default (context);
     299                 :             : 
     300         [ +  - ]:         194 :   return NULL;
     301                 :             : }
     302                 :             : 
     303                 :             : static void
     304                 :         208 : valent_channel_set_base_stream (ValentChannel *self,
     305                 :             :                                 GIOStream     *base_stream)
     306                 :             : {
     307                 :         208 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (self);
     308                 :             : 
     309         [ +  - ]:         208 :   g_assert (VALENT_IS_CHANNEL (self));
     310                 :             : 
     311         [ +  - ]:         208 :   if (base_stream != NULL)
     312                 :             :     {
     313                 :         416 :       g_autoptr (GMainContext) context = NULL;
     314                 :         208 :       GInputStream *input_stream;
     315                 :         208 :       GThread *thread;
     316                 :             : 
     317                 :         208 :       valent_object_lock (VALENT_OBJECT (self));
     318                 :         208 :       input_stream = g_io_stream_get_input_stream (base_stream);
     319                 :             : 
     320                 :         208 :       priv->base_stream = g_object_ref (base_stream);
     321                 :         208 :       priv->input_buffer = g_object_new (G_TYPE_DATA_INPUT_STREAM,
     322                 :             :                                          "base-stream",       input_stream,
     323                 :             :                                          "close-base-stream", FALSE,
     324                 :             :                                          NULL);
     325                 :             : 
     326                 :         208 :       context = g_main_context_new ();
     327                 :         208 :       priv->output_buffer = g_main_loop_new (context, FALSE);
     328                 :         208 :       thread = g_thread_new ("valent-channel",
     329                 :             :                              valent_channel_write_packet_worker,
     330                 :         208 :                              g_main_loop_ref (priv->output_buffer));
     331         [ +  - ]:         208 :       g_clear_pointer (&thread, g_thread_unref);
     332         [ +  - ]:         208 :       valent_object_unlock (VALENT_OBJECT (self));
     333                 :             :     }
     334                 :         208 : }
     335                 :             : 
     336                 :             : 
     337                 :             : /*
     338                 :             :  * GObject
     339                 :             :  */
     340                 :             : static void
     341                 :         207 : valent_channel_finalize (GObject *object)
     342                 :             : {
     343                 :         207 :   ValentChannel *self = VALENT_CHANNEL (object);
     344                 :         207 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (self);
     345                 :             : 
     346                 :         207 :   valent_object_lock (VALENT_OBJECT (self));
     347         [ +  + ]:         207 :   g_clear_pointer (&priv->output_buffer, g_main_loop_unref);
     348         [ +  + ]:         207 :   g_clear_object (&priv->input_buffer);
     349         [ +  - ]:         207 :   g_clear_object (&priv->base_stream);
     350         [ +  - ]:         207 :   g_clear_object (&priv->certificate);
     351         [ +  - ]:         207 :   g_clear_pointer (&priv->identity, json_node_unref);
     352         [ +  - ]:         207 :   g_clear_object (&priv->peer_certificate);
     353         [ +  - ]:         207 :   g_clear_pointer (&priv->peer_identity, json_node_unref);
     354                 :         207 :   valent_object_unlock (VALENT_OBJECT (self));
     355                 :             : 
     356                 :         207 :   G_OBJECT_CLASS (valent_channel_parent_class)->finalize (object);
     357                 :         207 : }
     358                 :             : 
     359                 :             : static void
     360                 :           5 : valent_channel_get_property (GObject    *object,
     361                 :             :                              guint       prop_id,
     362                 :             :                              GValue     *value,
     363                 :             :                              GParamSpec *pspec)
     364                 :             : {
     365                 :           5 :   ValentChannel *self = VALENT_CHANNEL (object);
     366                 :           5 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (self);
     367                 :             : 
     368   [ +  +  +  +  :           5 :   switch ((ValentChannelProperty)prop_id)
                   +  - ]
     369                 :             :     {
     370                 :           1 :     case PROP_BASE_STREAM:
     371                 :           1 :       g_value_take_object (value, valent_channel_ref_base_stream (self));
     372                 :           1 :       break;
     373                 :             : 
     374                 :           1 :     case PROP_CERTIFICATE:
     375                 :           1 :       g_value_set_object (value, priv->certificate);
     376                 :           1 :       break;
     377                 :             : 
     378                 :           1 :     case PROP_IDENTITY:
     379                 :           1 :       g_value_set_boxed (value, priv->identity);
     380                 :           1 :       break;
     381                 :             : 
     382                 :           1 :     case PROP_PEER_CERTIFICATE:
     383                 :           1 :       g_value_set_object (value, priv->peer_certificate);
     384                 :           1 :       break;
     385                 :             : 
     386                 :           1 :     case PROP_PEER_IDENTITY:
     387                 :           1 :       g_value_set_boxed (value, priv->peer_identity);
     388                 :           1 :       break;
     389                 :             : 
     390                 :           0 :     default:
     391                 :           0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     392                 :             :     }
     393                 :           5 : }
     394                 :             : 
     395                 :             : static void
     396                 :        1040 : valent_channel_set_property (GObject      *object,
     397                 :             :                              guint         prop_id,
     398                 :             :                              const GValue *value,
     399                 :             :                              GParamSpec   *pspec)
     400                 :             : {
     401                 :        1040 :   ValentChannel *self = VALENT_CHANNEL (object);
     402                 :        1040 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (self);
     403                 :             : 
     404   [ +  +  +  +  :        1040 :   switch ((ValentChannelProperty)prop_id)
                   +  - ]
     405                 :             :     {
     406                 :         208 :     case PROP_BASE_STREAM:
     407                 :         208 :       valent_channel_set_base_stream (self, g_value_get_object (value));
     408                 :         208 :       break;
     409                 :             : 
     410                 :         208 :     case PROP_CERTIFICATE:
     411                 :         208 :       priv->certificate = g_value_dup_object (value);
     412                 :         208 :       break;
     413                 :             : 
     414                 :         208 :     case PROP_IDENTITY:
     415                 :         208 :       priv->identity = g_value_dup_boxed (value);
     416                 :         208 :       break;
     417                 :             : 
     418                 :         208 :     case PROP_PEER_CERTIFICATE:
     419                 :         208 :       priv->peer_certificate = g_value_dup_object (value);
     420                 :         208 :       break;
     421                 :             : 
     422                 :         208 :     case PROP_PEER_IDENTITY:
     423                 :         208 :       priv->peer_identity = g_value_dup_boxed (value);
     424                 :         208 :       break;
     425                 :             : 
     426                 :           0 :     default:
     427                 :           0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     428                 :             :     }
     429                 :        1040 : }
     430                 :             : 
     431                 :             : static void
     432                 :          31 : valent_channel_class_init (ValentChannelClass *klass)
     433                 :             : {
     434                 :          31 :   GObjectClass *object_class = G_OBJECT_CLASS (klass);
     435                 :             : 
     436                 :          31 :   object_class->finalize = valent_channel_finalize;
     437                 :          31 :   object_class->get_property = valent_channel_get_property;
     438                 :          31 :   object_class->set_property = valent_channel_set_property;
     439                 :             : 
     440                 :          31 :   klass->download = valent_channel_real_download;
     441                 :          31 :   klass->download_async = valent_channel_real_download_async;
     442                 :          31 :   klass->download_finish = valent_channel_real_download_finish;
     443                 :          31 :   klass->upload = valent_channel_real_upload;
     444                 :          31 :   klass->upload_async = valent_channel_real_upload_async;
     445                 :          31 :   klass->upload_finish = valent_channel_real_upload_finish;
     446                 :          31 :   klass->store_data = valent_channel_real_store_data;
     447                 :             : 
     448                 :             :   /**
     449                 :             :    * ValentChannel:base-stream: (getter ref_base_stream)
     450                 :             :    *
     451                 :             :    * The base [class@Gio.IOStream] for the channel.
     452                 :             :    *
     453                 :             :    * Implementations of [class@Valent.ChannelService] must set this property
     454                 :             :    * during construction.
     455                 :             :    *
     456                 :             :    * Since: 1.0
     457                 :             :    */
     458                 :          62 :   properties [PROP_BASE_STREAM] =
     459                 :          31 :     g_param_spec_object ("base-stream", NULL, NULL,
     460                 :             :                          G_TYPE_IO_STREAM,
     461                 :             :                          (G_PARAM_READWRITE |
     462                 :             :                           G_PARAM_CONSTRUCT_ONLY |
     463                 :             :                           G_PARAM_EXPLICIT_NOTIFY |
     464                 :             :                           G_PARAM_STATIC_STRINGS));
     465                 :             : 
     466                 :             :   /**
     467                 :             :    * ValentChannel:certificate: (getter get_certificate)
     468                 :             :    *
     469                 :             :    * The peer TLS certificate.
     470                 :             :    *
     471                 :             :    * This is the TLS certificate sent by the [class@Valent.ChannelService]
     472                 :             :    * implementation to identify the host system.
     473                 :             :    *
     474                 :             :    * Implementations of [class@Valent.ChannelService] must set this property
     475                 :             :    * during construction.
     476                 :             :    *
     477                 :             :    * Since: 1.0
     478                 :             :    */
     479                 :          62 :   properties [PROP_CERTIFICATE] =
     480                 :          31 :     g_param_spec_object ("certificate", NULL, NULL,
     481                 :             :                          G_TYPE_TLS_CERTIFICATE,
     482                 :             :                          (G_PARAM_READWRITE |
     483                 :             :                           G_PARAM_CONSTRUCT_ONLY |
     484                 :             :                           G_PARAM_EXPLICIT_NOTIFY |
     485                 :             :                           G_PARAM_STATIC_STRINGS));
     486                 :             : 
     487                 :             :   /**
     488                 :             :    * ValentChannel:identity: (getter get_identity)
     489                 :             :    *
     490                 :             :    * The local identity packet.
     491                 :             :    *
     492                 :             :    * This is the identity packet sent by the [class@Valent.ChannelService]
     493                 :             :    * implementation to identify the host system.
     494                 :             :    *
     495                 :             :    * Implementations of [class@Valent.ChannelService] must set this property
     496                 :             :    * during construction.
     497                 :             :    *
     498                 :             :    * Since: 1.0
     499                 :             :    */
     500                 :          62 :   properties [PROP_IDENTITY] =
     501                 :          31 :     g_param_spec_boxed ("identity", NULL, NULL,
     502                 :             :                         JSON_TYPE_NODE,
     503                 :             :                         (G_PARAM_READWRITE |
     504                 :             :                          G_PARAM_CONSTRUCT_ONLY |
     505                 :             :                          G_PARAM_EXPLICIT_NOTIFY |
     506                 :             :                          G_PARAM_STATIC_STRINGS));
     507                 :             : 
     508                 :             :   /**
     509                 :             :    * ValentChannel:peer-certificate: (getter get_peer_certificate)
     510                 :             :    *
     511                 :             :    * The peer TLS certificate.
     512                 :             :    *
     513                 :             :    * This is the TLS certificate sent by the peer to identify itself.
     514                 :             :    *
     515                 :             :    * Implementations of [class@Valent.ChannelService] must set this property
     516                 :             :    * during construction.
     517                 :             :    *
     518                 :             :    * Since: 1.0
     519                 :             :    */
     520                 :          62 :   properties [PROP_PEER_CERTIFICATE] =
     521                 :          31 :     g_param_spec_object ("peer-certificate", NULL, NULL,
     522                 :             :                          G_TYPE_TLS_CERTIFICATE,
     523                 :             :                          (G_PARAM_READWRITE |
     524                 :             :                           G_PARAM_CONSTRUCT_ONLY |
     525                 :             :                           G_PARAM_EXPLICIT_NOTIFY |
     526                 :             :                           G_PARAM_STATIC_STRINGS));
     527                 :             : 
     528                 :             :   /**
     529                 :             :    * ValentChannel:peer-identity: (getter get_peer_identity)
     530                 :             :    *
     531                 :             :    * The peer identity packet.
     532                 :             :    *
     533                 :             :    * This is the identity packet sent by the peer to identify itself.
     534                 :             :    *
     535                 :             :    * Implementations of [class@Valent.ChannelService] must set this property
     536                 :             :    * during construction.
     537                 :             :    *
     538                 :             :    * Since: 1.0
     539                 :             :    */
     540                 :          62 :   properties [PROP_PEER_IDENTITY] =
     541                 :          31 :     g_param_spec_boxed ("peer-identity", NULL, NULL,
     542                 :             :                         JSON_TYPE_NODE,
     543                 :             :                         (G_PARAM_READWRITE |
     544                 :             :                          G_PARAM_CONSTRUCT_ONLY |
     545                 :             :                          G_PARAM_EXPLICIT_NOTIFY |
     546                 :             :                          G_PARAM_STATIC_STRINGS));
     547                 :             : 
     548                 :          31 :   g_object_class_install_properties (object_class, G_N_ELEMENTS (properties), properties);
     549                 :          31 : }
     550                 :             : 
     551                 :             : static void
     552                 :         208 : valent_channel_init (ValentChannel *self)
     553                 :             : {
     554                 :         208 : }
     555                 :             : 
     556                 :             : /**
     557                 :             :  * valent_channel_ref_base_stream: (get-property base-stream)
     558                 :             :  * @channel: a `ValentChannel`
     559                 :             :  *
     560                 :             :  * Get the base [class@Gio.IOStream].
     561                 :             :  *
     562                 :             :  * Returns: (transfer full) (nullable): the base stream
     563                 :             :  *
     564                 :             :  * Since: 1.0
     565                 :             :  */
     566                 :             : GIOStream *
     567                 :           1 : valent_channel_ref_base_stream (ValentChannel *channel)
     568                 :             : {
     569                 :           1 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     570                 :           1 :   GIOStream *ret = NULL;
     571                 :             : 
     572         [ +  - ]:           1 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
     573                 :             : 
     574                 :           1 :   valent_object_lock (VALENT_OBJECT (channel));
     575         [ +  - ]:           1 :   if (priv->base_stream != NULL)
     576                 :           1 :     ret = g_object_ref (priv->base_stream);
     577                 :           1 :   valent_object_unlock (VALENT_OBJECT (channel));
     578                 :             : 
     579                 :           1 :   return g_steal_pointer (&ret);
     580                 :             : }
     581                 :             : 
     582                 :             : /**
     583                 :             :  * valent_channel_get_certificate: (get-property certificate)
     584                 :             :  * @channel: A `ValentChannel`
     585                 :             :  *
     586                 :             :  * Get the TLS certificate.
     587                 :             :  *
     588                 :             :  * Returns: (nullable) (transfer none): a TLS certificate
     589                 :             :  *
     590                 :             :  * Since: 1.0
     591                 :             :  */
     592                 :             : GTlsCertificate *
     593                 :           7 : valent_channel_get_certificate (ValentChannel *channel)
     594                 :             : {
     595                 :           7 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     596                 :             : 
     597         [ +  - ]:           7 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
     598                 :             : 
     599                 :           7 :   return priv->certificate;
     600                 :             : }
     601                 :             : 
     602                 :             : /**
     603                 :             :  * valent_channel_get_identity: (get-property identity)
     604                 :             :  * @channel: A `ValentChannel`
     605                 :             :  *
     606                 :             :  * Get the local identity packet.
     607                 :             :  *
     608                 :             :  * Returns: (transfer none): a KDE Connect packet
     609                 :             :  *
     610                 :             :  * Since: 1.0
     611                 :             :  */
     612                 :             : JsonNode *
     613                 :           1 : valent_channel_get_identity (ValentChannel *channel)
     614                 :             : {
     615                 :           1 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     616                 :             : 
     617         [ +  - ]:           1 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
     618                 :             : 
     619                 :           1 :   return priv->identity;
     620                 :             : }
     621                 :             : 
     622                 :             : /**
     623                 :             :  * valent_channel_get_peer_certificate: (get-property peer-certificate)
     624                 :             :  * @channel: A `ValentChannel`
     625                 :             :  *
     626                 :             :  * Get the peer TLS certificate.
     627                 :             :  *
     628                 :             :  * Returns: (nullable) (transfer none): a TLS certificate
     629                 :             :  *
     630                 :             :  * Since: 1.0
     631                 :             :  */
     632                 :             : GTlsCertificate *
     633                 :          10 : valent_channel_get_peer_certificate (ValentChannel *channel)
     634                 :             : {
     635                 :          10 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     636                 :             : 
     637         [ +  - ]:          10 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
     638                 :             : 
     639                 :          10 :   return priv->peer_certificate;
     640                 :             : }
     641                 :             : 
     642                 :             : /**
     643                 :             :  * valent_channel_get_peer_identity: (get-property peer-identity)
     644                 :             :  * @channel: A `ValentChannel`
     645                 :             :  *
     646                 :             :  * Get the peer identity packet.
     647                 :             :  *
     648                 :             :  * Returns: (transfer none): a KDE Connect packet
     649                 :             :  *
     650                 :             :  * Since: 1.0
     651                 :             :  */
     652                 :             : JsonNode *
     653                 :          86 : valent_channel_get_peer_identity (ValentChannel *channel)
     654                 :             : {
     655                 :          86 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     656                 :             : 
     657         [ +  - ]:          86 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
     658                 :             : 
     659                 :          86 :   return priv->peer_identity;
     660                 :             : }
     661                 :             : 
     662                 :             : /**
     663                 :             :  * valent_channel_close:
     664                 :             :  * @channel: a `ValentChannel`
     665                 :             :  * @cancellable: (nullable): a `GCancellable`
     666                 :             :  * @error: (nullable): a `GError`
     667                 :             :  *
     668                 :             :  * Close the channel.
     669                 :             :  *
     670                 :             :  * Returns: %TRUE if successful, or %FALSE with @error set
     671                 :             :  */
     672                 :             : gboolean
     673                 :         265 : valent_channel_close (ValentChannel  *channel,
     674                 :             :                       GCancellable   *cancellable,
     675                 :             :                       GError        **error)
     676                 :             : {
     677                 :         265 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     678                 :         265 :   gboolean ret = TRUE;
     679                 :             : 
     680                 :         265 :   VALENT_ENTRY;
     681                 :             : 
     682         [ +  - ]:         265 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), FALSE);
     683   [ -  +  -  -  :         265 :   g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
             -  -  -  - ]
     684   [ +  +  -  + ]:         265 :   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
     685                 :             : 
     686                 :         265 :   valent_object_lock (VALENT_OBJECT (channel));
     687   [ -  +  +  + ]:         265 :   if (priv->base_stream != NULL && !g_io_stream_is_closed (priv->base_stream))
     688                 :             :     {
     689                 :         194 :       ret = g_io_stream_close (priv->base_stream, cancellable, error);
     690                 :             : 
     691         [ +  - ]:         194 :       if (priv->output_buffer != NULL)
     692                 :         194 :         g_main_loop_quit (priv->output_buffer);
     693         [ +  - ]:         194 :       g_clear_pointer (&priv->output_buffer, g_main_loop_unref);
     694         [ -  + ]:         194 :       g_clear_object (&priv->input_buffer);
     695                 :             :     }
     696                 :         265 :   valent_object_unlock (VALENT_OBJECT (channel));
     697                 :             : 
     698                 :         265 :   VALENT_RETURN (ret);
     699                 :             : }
     700                 :             : 
     701                 :             : static void
     702                 :          80 : valent_channel_close_task (GTask        *task,
     703                 :             :                            gpointer      source_object,
     704                 :             :                            gpointer      task_data,
     705                 :             :                            GCancellable *cancellable)
     706                 :             : {
     707                 :          80 :   ValentChannel *self = source_object;
     708                 :          80 :   GError *error = NULL;
     709                 :             : 
     710         [ -  + ]:          80 :   if (g_task_return_error_if_cancelled (task))
     711                 :           0 :     return;
     712                 :             : 
     713         [ +  - ]:          80 :   if (valent_channel_close (self, cancellable, &error))
     714                 :          80 :     g_task_return_boolean (task, TRUE);
     715                 :             :   else
     716                 :           0 :     g_task_return_error (task, error);
     717                 :             : }
     718                 :             : 
     719                 :             : /**
     720                 :             :  * valent_channel_close_async:
     721                 :             :  * @channel: a `ValentChannel`
     722                 :             :  * @cancellable: (nullable): a `GCancellable`
     723                 :             :  * @callback: (scope async): a `GAsyncReadyCallback`
     724                 :             :  * @user_data: user supplied data
     725                 :             :  *
     726                 :             :  * Close the channel asynchronously.
     727                 :             :  *
     728                 :             :  * Call [method@Valent.Channel.close_finish] to get the result.
     729                 :             :  *
     730                 :             :  * Since: 1.0
     731                 :             :  */
     732                 :             : void
     733                 :          80 : valent_channel_close_async (ValentChannel       *channel,
     734                 :             :                             GCancellable        *cancellable,
     735                 :             :                             GAsyncReadyCallback  callback,
     736                 :             :                             gpointer             user_data)
     737                 :             : {
     738                 :         160 :   g_autoptr (GTask) task = NULL;
     739                 :             : 
     740                 :          80 :   VALENT_ENTRY;
     741                 :             : 
     742         [ +  - ]:          80 :   g_return_if_fail (VALENT_IS_CHANNEL (channel));
     743   [ -  +  -  -  :          80 :   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  -  -  - ]
     744                 :             : 
     745                 :          80 :   task = g_task_new (channel, cancellable, callback, user_data);
     746         [ +  - ]:          80 :   g_task_set_source_tag (task, valent_channel_close_async);
     747                 :          80 :   g_task_run_in_thread (task, valent_channel_close_task);
     748                 :             : 
     749         [ +  - ]:          80 :   VALENT_EXIT;
     750                 :             : }
     751                 :             : 
     752                 :             : /**
     753                 :             :  * valent_channel_close_finish:
     754                 :             :  * @channel: a `ValentChannel`
     755                 :             :  * @result: a `GAsyncResult`
     756                 :             :  * @error: (nullable): a `GError`
     757                 :             :  *
     758                 :             :  * Finish an operation started by [method@Valent.Channel.close_async].
     759                 :             :  *
     760                 :             :  * Returns: %TRUE if successful, or %FALSE with @error set
     761                 :             :  *
     762                 :             :  * Since: 1.0
     763                 :             :  */
     764                 :             : gboolean
     765                 :           1 : valent_channel_close_finish (ValentChannel  *channel,
     766                 :             :                              GAsyncResult   *result,
     767                 :             :                              GError        **error)
     768                 :             : {
     769                 :           1 :   gboolean ret;
     770                 :             : 
     771                 :           1 :   VALENT_ENTRY;
     772                 :             : 
     773         [ +  - ]:           1 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), FALSE);
     774         [ -  + ]:           1 :   g_return_val_if_fail (g_task_is_valid (result, channel), FALSE);
     775   [ +  -  -  + ]:           1 :   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
     776                 :             : 
     777                 :           1 :   ret = g_task_propagate_boolean (G_TASK (result), error);
     778                 :             : 
     779                 :           1 :   VALENT_RETURN (ret);
     780                 :             : }
     781                 :             : 
     782                 :             : static void
     783                 :         360 : valent_channel_read_packet_task (GTask        *task,
     784                 :             :                                  gpointer      source_object,
     785                 :             :                                  gpointer      task_data,
     786                 :             :                                  GCancellable *cancellable)
     787                 :             : {
     788                 :         360 :   ValentChannel *self = VALENT_CHANNEL (source_object);
     789                 :         360 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (self);
     790                 :         360 :   g_autoptr (GDataInputStream) stream = NULL;
     791   [ +  -  +  + ]:         360 :   g_autofree char *line = NULL;
     792                 :         360 :   JsonNode *packet = NULL;
     793                 :         360 :   GError *error = NULL;
     794                 :             : 
     795         [ +  + ]:         360 :   if (valent_channel_return_error_if_closed (self, task))
     796                 :             :       return;
     797                 :             : 
     798                 :         353 :   stream = g_object_ref (priv->input_buffer);
     799                 :         353 :   valent_object_unlock (VALENT_OBJECT (self));
     800                 :             : 
     801                 :         353 :   line = g_data_input_stream_read_line_utf8 (stream, NULL, cancellable, &error);
     802                 :             : 
     803         [ +  + ]:         353 :   if (error != NULL)
     804                 :           7 :     return g_task_return_error (task, error);
     805                 :             : 
     806         [ +  + ]:         346 :   if (line == NULL)
     807                 :          66 :     return g_task_return_new_error (task,
     808                 :             :                                     G_IO_ERROR,
     809                 :             :                                     G_IO_ERROR_CONNECTION_CLOSED,
     810                 :             :                                     "Channel is closed");
     811                 :             : 
     812         [ -  + ]:         280 :   if ((packet = valent_packet_deserialize (line, &error)) == NULL)
     813                 :           0 :     return g_task_return_error (task, error);
     814                 :             : 
     815                 :         280 :   g_task_return_pointer (task, packet, (GDestroyNotify)json_node_unref);
     816                 :             : }
     817                 :             : 
     818                 :             : /**
     819                 :             :  * valent_channel_read_packet:
     820                 :             :  * @channel: a `ValentChannel`
     821                 :             :  * @cancellable: (nullable): a `GCancellable`
     822                 :             :  * @callback: (scope async): a `GAsyncReadyCallback`
     823                 :             :  * @user_data: user supplied data
     824                 :             :  *
     825                 :             :  * Read the next KDE Connect packet from @channel.
     826                 :             :  *
     827                 :             :  * Call [method@Valent.Channel.read_packet_finish] to get the result.
     828                 :             :  *
     829                 :             :  * Since: 1.0
     830                 :             :  */
     831                 :             : void
     832                 :         360 : valent_channel_read_packet (ValentChannel       *channel,
     833                 :             :                             GCancellable        *cancellable,
     834                 :             :                             GAsyncReadyCallback  callback,
     835                 :             :                             gpointer             user_data)
     836                 :             : {
     837                 :         720 :   g_autoptr (GTask) task = NULL;
     838                 :             : 
     839                 :         360 :   VALENT_ENTRY;
     840                 :             : 
     841         [ +  - ]:         360 :   g_return_if_fail (VALENT_IS_CHANNEL (channel));
     842   [ +  +  +  -  :         360 :   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  +  -  - ]
     843                 :             : 
     844                 :         360 :   task = g_task_new (channel, cancellable, callback, user_data);
     845         [ +  - ]:         360 :   g_task_set_source_tag (task, valent_channel_read_packet);
     846                 :         360 :   g_task_run_in_thread (task, valent_channel_read_packet_task);
     847                 :             : 
     848         [ +  - ]:         360 :   VALENT_EXIT;
     849                 :             : }
     850                 :             : 
     851                 :             : /**
     852                 :             :  * valent_channel_read_packet_finish:
     853                 :             :  * @channel: a `ValentChannel`
     854                 :             :  * @result: a `GAsyncResult`
     855                 :             :  * @error: (nullable): a `GError`
     856                 :             :  *
     857                 :             :  * Finish an operation started by [method@Valent.Channel.read_packet].
     858                 :             :  *
     859                 :             :  * Returns: (transfer full): a KDE Connect packet, or %NULL with @error set
     860                 :             :  *
     861                 :             :  * Since: 1.0
     862                 :             :  */
     863                 :             : JsonNode *
     864                 :         359 : valent_channel_read_packet_finish (ValentChannel  *channel,
     865                 :             :                                    GAsyncResult   *result,
     866                 :             :                                    GError        **error)
     867                 :             : {
     868                 :         359 :   JsonNode *ret;
     869                 :             : 
     870                 :         359 :   VALENT_ENTRY;
     871                 :             : 
     872         [ +  - ]:         359 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
     873         [ -  + ]:         359 :   g_return_val_if_fail (g_task_is_valid (result, channel), NULL);
     874   [ +  -  -  + ]:         359 :   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
     875                 :             : 
     876                 :         359 :   ret = g_task_propagate_pointer (G_TASK (result), error);
     877                 :             : 
     878                 :         359 :   VALENT_RETURN (ret);
     879                 :             : }
     880                 :             : 
     881                 :             : static gboolean
     882                 :         289 : valent_channel_write_packet_func (gpointer data)
     883                 :             : {
     884                 :         289 :   GTask *task = G_TASK (data);
     885                 :         289 :   ValentChannel *self = g_task_get_source_object (task);
     886                 :         289 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (self);
     887                 :         578 :   g_autoptr (GOutputStream) stream = NULL;
     888                 :         289 :   JsonNode *packet = NULL;
     889                 :         289 :   GCancellable *cancellable = NULL;
     890                 :         289 :   GError *error = NULL;
     891                 :             : 
     892   [ +  -  +  -  :         289 :   g_assert (G_IS_TASK (task));
             -  +  -  - ]
     893         [ -  + ]:         289 :   g_assert (VALENT_IS_CHANNEL (self));
     894                 :             : 
     895         [ +  - ]:         289 :   if (valent_channel_return_error_if_closed (self, task))
     896                 :             :     return G_SOURCE_REMOVE;
     897                 :             : 
     898                 :         289 :   stream = g_object_ref (g_io_stream_get_output_stream (priv->base_stream));
     899                 :         289 :   valent_object_unlock (VALENT_OBJECT (self));
     900                 :             : 
     901                 :         289 :   packet = g_task_get_task_data (task);
     902                 :         289 :   cancellable = g_task_get_cancellable (task);
     903                 :             : 
     904         [ +  + ]:         289 :   if (valent_packet_to_stream (stream, packet, cancellable, &error))
     905                 :         283 :     g_task_return_boolean (task, TRUE);
     906                 :             :   else
     907                 :           6 :     g_task_return_error (task, error);
     908                 :             : 
     909         [ +  - ]:         289 :   return G_SOURCE_REMOVE;
     910                 :             : }
     911                 :             : 
     912                 :             : /**
     913                 :             :  * valent_channel_write_packet:
     914                 :             :  * @channel: a `ValentChannel`
     915                 :             :  * @packet: a KDE Connect packet
     916                 :             :  * @cancellable: (nullable): a `GCancellable`
     917                 :             :  * @callback: (scope async): a `GAsyncReadyCallback`
     918                 :             :  * @user_data: user supplied data
     919                 :             :  *
     920                 :             :  * Send a packet over the channel.
     921                 :             :  *
     922                 :             :  * Internally [class@Valent.Channel] uses an outgoing packet buffer, so
     923                 :             :  * multiple requests can be started safely from any thread.
     924                 :             :  *
     925                 :             :  * Call [method@Valent.Channel.write_packet_finish] to get the result.
     926                 :             :  *
     927                 :             :  * Since: 1.0
     928                 :             :  */
     929                 :             : void
     930                 :         289 : valent_channel_write_packet (ValentChannel       *channel,
     931                 :             :                              JsonNode            *packet,
     932                 :             :                              GCancellable        *cancellable,
     933                 :             :                              GAsyncReadyCallback  callback,
     934                 :             :                              gpointer             user_data)
     935                 :             : {
     936                 :         289 :   ValentChannelPrivate *priv = valent_channel_get_instance_private (channel);
     937                 :         578 :   g_autoptr (GTask) task = NULL;
     938                 :             : 
     939                 :         289 :   VALENT_ENTRY;
     940                 :             : 
     941         [ +  - ]:         289 :   g_return_if_fail (VALENT_IS_CHANNEL (channel));
     942         [ -  + ]:         289 :   g_return_if_fail (VALENT_IS_PACKET (packet));
     943   [ +  +  +  -  :         289 :   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  +  -  - ]
     944                 :             : 
     945                 :         289 :   task = g_task_new (channel, cancellable, callback, user_data);
     946         [ +  - ]:         289 :   g_task_set_source_tag (task, valent_channel_write_packet);
     947                 :         289 :   g_task_set_task_data (task,
     948                 :         289 :                         json_node_ref (packet),
     949                 :             :                         (GDestroyNotify)json_node_unref);
     950                 :             : 
     951         [ +  - ]:         289 :   if (valent_channel_return_error_if_closed (channel, task))
     952                 :         289 :     VALENT_EXIT;
     953                 :             : 
     954                 :         289 :   g_main_context_invoke_full (g_main_loop_get_context (priv->output_buffer),
     955                 :             :                               g_task_get_priority (task),
     956                 :             :                               valent_channel_write_packet_func,
     957                 :             :                               g_object_ref (task),
     958                 :             :                               g_object_unref);
     959                 :             : 
     960                 :         289 :   valent_object_unlock (VALENT_OBJECT (channel));
     961                 :             : 
     962         [ +  - ]:         578 :   VALENT_EXIT;
     963                 :             : }
     964                 :             : 
     965                 :             : /**
     966                 :             :  * valent_channel_write_packet_finish:
     967                 :             :  * @channel: a `ValentChannel`
     968                 :             :  * @result: a `GAsyncResult`
     969                 :             :  * @error: (nullable): a `GError`
     970                 :             :  *
     971                 :             :  * Finish an operation started by [method@Valent.Channel.write_packet].
     972                 :             :  *
     973                 :             :  * Returns: %TRUE if successful, or %FALSE with @error set
     974                 :             :  *
     975                 :             :  * Since: 1.0
     976                 :             :  */
     977                 :             : gboolean
     978                 :         255 : valent_channel_write_packet_finish (ValentChannel  *channel,
     979                 :             :                                     GAsyncResult   *result,
     980                 :             :                                     GError        **error)
     981                 :             : {
     982                 :         255 :   gboolean ret;
     983                 :             : 
     984                 :         255 :   VALENT_ENTRY;
     985                 :             : 
     986         [ +  - ]:         255 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), FALSE);
     987         [ -  + ]:         255 :   g_return_val_if_fail (g_task_is_valid (result, channel), FALSE);
     988   [ +  -  -  + ]:         255 :   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
     989                 :             : 
     990                 :         255 :   ret = g_task_propagate_boolean (G_TASK (result), error);
     991                 :             : 
     992                 :         255 :   VALENT_RETURN (ret);
     993                 :             : }
     994                 :             : 
     995                 :             : /**
     996                 :             :  * valent_channel_store_data: (virtual store_data)
     997                 :             :  * @channel: a `ValentChannel`
     998                 :             :  * @context: a `ValentContext`
     999                 :             :  *
    1000                 :             :  * Store channel metadata.
    1001                 :             :  *
    1002                 :             :  * This method is called to store channel specific data. The default
    1003                 :             :  * implementation stores the peer certificate.
    1004                 :             :  *
    1005                 :             :  * Implementations that override [vfunc@Valent.Channel.store_data] must
    1006                 :             :  * chain-up.
    1007                 :             :  *
    1008                 :             :  * Since: 1.0
    1009                 :             :  */
    1010                 :             : void
    1011                 :           6 : valent_channel_store_data (ValentChannel *channel,
    1012                 :             :                            ValentContext  *context)
    1013                 :             : {
    1014                 :           6 :   VALENT_ENTRY;
    1015                 :             : 
    1016         [ +  - ]:           6 :   g_return_if_fail (VALENT_IS_CHANNEL (channel));
    1017         [ -  + ]:           6 :   g_return_if_fail (VALENT_IS_CONTEXT (context));
    1018                 :             : 
    1019                 :           6 :   VALENT_CHANNEL_GET_CLASS (channel)->store_data (channel, context);
    1020                 :             : 
    1021                 :           6 :   VALENT_EXIT;
    1022                 :             : }
    1023                 :             : 
    1024                 :             : /**
    1025                 :             :  * valent_channel_download: (virtual download)
    1026                 :             :  * @channel: a `ValentChannel`
    1027                 :             :  * @packet: a KDE Connect packet
    1028                 :             :  * @cancellable: (nullable): a `GCancellable`
    1029                 :             :  * @error: (nullable): a `GError`
    1030                 :             :  *
    1031                 :             :  * Open an auxiliary connection, usually to download data.
    1032                 :             :  *
    1033                 :             :  * Implementations should use information from the `payloadTransferInfo` field
    1034                 :             :  * to open a connection and wait for it to be accepted. In most cases the remote
    1035                 :             :  * device will write data to the stream and then close it when finished.
    1036                 :             :  *
    1037                 :             :  * For example, a TCP-based implementation could connect to a port in the
    1038                 :             :  * `payloadTransferInfo` dictionary on the same host as the channel. When the
    1039                 :             :  * connection is accepted the caller can perform operations on it as required.
    1040                 :             :  *
    1041                 :             :  * Returns: (transfer full) (nullable): a `GIOStream`
    1042                 :             :  *
    1043                 :             :  * Since: 1.0
    1044                 :             :  */
    1045                 :             : GIOStream *
    1046                 :          28 : valent_channel_download (ValentChannel  *channel,
    1047                 :             :                          JsonNode       *packet,
    1048                 :             :                          GCancellable   *cancellable,
    1049                 :             :                          GError        **error)
    1050                 :             : {
    1051                 :          28 :   GIOStream *ret;
    1052                 :             : 
    1053                 :          28 :   VALENT_ENTRY;
    1054                 :             : 
    1055         [ +  - ]:          28 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
    1056         [ -  + ]:          28 :   g_return_val_if_fail (VALENT_IS_PACKET (packet), NULL);
    1057   [ +  +  +  -  :          28 :   g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
             -  +  -  - ]
    1058   [ +  -  -  + ]:          28 :   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
    1059                 :             : 
    1060                 :          28 :   ret = VALENT_CHANNEL_GET_CLASS (channel)->download (channel,
    1061                 :             :                                                       packet,
    1062                 :             :                                                       cancellable,
    1063                 :             :                                                       error);
    1064                 :             : 
    1065                 :          28 :   VALENT_RETURN (ret);
    1066                 :             : }
    1067                 :             : 
    1068                 :             : /**
    1069                 :             :  * valent_channel_download_async: (virtual download_async)
    1070                 :             :  * @channel: a `ValentChannel`
    1071                 :             :  * @packet: a KDE Connect packet
    1072                 :             :  * @cancellable: (nullable): a `GCancellable`
    1073                 :             :  * @callback: (scope async): a `GAsyncReadyCallback`
    1074                 :             :  * @user_data: user supplied data
    1075                 :             :  *
    1076                 :             :  * Open an auxiliary connection, usually to download data.
    1077                 :             :  *
    1078                 :             :  * This is a non-blocking variant of [method@Valent.Channel.download]. Call
    1079                 :             :  * [method@Valent.Channel.download_finish] to get the result.
    1080                 :             :  *
    1081                 :             :  * The default implementation of this method invokes
    1082                 :             :  * [vfunc@Valent.Channel.download] in a thread.
    1083                 :             :  *
    1084                 :             :  * Since: 1.0
    1085                 :             :  */
    1086                 :             : void
    1087                 :           1 : valent_channel_download_async (ValentChannel       *channel,
    1088                 :             :                                JsonNode            *packet,
    1089                 :             :                                GCancellable        *cancellable,
    1090                 :             :                                GAsyncReadyCallback  callback,
    1091                 :             :                                gpointer             user_data)
    1092                 :             : {
    1093                 :           1 :   VALENT_ENTRY;
    1094                 :             : 
    1095         [ +  - ]:           1 :   g_return_if_fail (VALENT_IS_CHANNEL (channel));
    1096         [ -  + ]:           1 :   g_return_if_fail (VALENT_IS_PACKET (packet));
    1097   [ -  +  -  -  :           1 :   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  -  -  - ]
    1098                 :             : 
    1099                 :           1 :   VALENT_CHANNEL_GET_CLASS (channel)->download_async (channel,
    1100                 :             :                                                       packet,
    1101                 :             :                                                       cancellable,
    1102                 :             :                                                       callback,
    1103                 :             :                                                       user_data);
    1104                 :             : 
    1105                 :           1 :   VALENT_EXIT;
    1106                 :             : }
    1107                 :             : 
    1108                 :             : /**
    1109                 :             :  * valent_channel_download_finish: (virtual download_finish)
    1110                 :             :  * @channel: a `ValentChannel`
    1111                 :             :  * @result: a `GAsyncResult`
    1112                 :             :  * @error: (nullable): a `GError`
    1113                 :             :  *
    1114                 :             :  * Finish an operation started with [method@Valent.Channel.download_async].
    1115                 :             :  *
    1116                 :             :  * Returns: (transfer full) (nullable): a `GIOStream`
    1117                 :             :  *
    1118                 :             :  * Since: 1.0
    1119                 :             :  */
    1120                 :             : GIOStream *
    1121                 :           1 : valent_channel_download_finish (ValentChannel  *channel,
    1122                 :             :                                 GAsyncResult   *result,
    1123                 :             :                                 GError        **error)
    1124                 :             : {
    1125                 :           1 :   GIOStream *ret;
    1126                 :             : 
    1127                 :           1 :   VALENT_ENTRY;
    1128                 :             : 
    1129         [ +  - ]:           1 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
    1130         [ -  + ]:           1 :   g_return_val_if_fail (g_task_is_valid (result, channel), NULL);
    1131   [ +  -  -  + ]:           1 :   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
    1132                 :             : 
    1133                 :           1 :   ret = VALENT_CHANNEL_GET_CLASS (channel)->download_finish (channel,
    1134                 :             :                                                              result,
    1135                 :             :                                                              error);
    1136                 :             : 
    1137                 :           1 :   VALENT_RETURN (ret);
    1138                 :             : }
    1139                 :             : 
    1140                 :             : /**
    1141                 :             :  * valent_channel_upload: (virtual upload)
    1142                 :             :  * @channel: a `ValentChannel`
    1143                 :             :  * @packet: a KDE Connect packet
    1144                 :             :  * @cancellable: (nullable): a `GCancellable`
    1145                 :             :  * @error: (nullable): a `GError`
    1146                 :             :  *
    1147                 :             :  * Accept an auxiliary connection, usually to upload data.
    1148                 :             :  *
    1149                 :             :  * Implementations should set the `payloadTransferInfo` field with information
    1150                 :             :  * the peer can use to open a connection and wait to accept that connection. In
    1151                 :             :  * most cases the remote device with expect the caller to write to the stream
    1152                 :             :  * and then close it when finished.
    1153                 :             :  *
    1154                 :             :  * For example, a TCP-based implementation could start listening on a port then
    1155                 :             :  * send the packet with that port in the `payloadTransferInfo` dictionary. When
    1156                 :             :  * a connection is accepted the caller can perform operations on it as required.
    1157                 :             :  *
    1158                 :             :  * Returns: (transfer full) (nullable): a `GIOStream`
    1159                 :             :  *
    1160                 :             :  * Since: 1.0
    1161                 :             :  */
    1162                 :             : GIOStream *
    1163                 :          28 : valent_channel_upload (ValentChannel  *channel,
    1164                 :             :                        JsonNode       *packet,
    1165                 :             :                        GCancellable   *cancellable,
    1166                 :             :                        GError        **error)
    1167                 :             : {
    1168                 :          28 :   GIOStream *ret;
    1169                 :             : 
    1170                 :          28 :   VALENT_ENTRY;
    1171                 :             : 
    1172         [ +  - ]:          28 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
    1173         [ -  + ]:          28 :   g_return_val_if_fail (VALENT_IS_PACKET (packet), NULL);
    1174   [ +  +  +  -  :          28 :   g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
             -  +  -  - ]
    1175   [ +  -  -  + ]:          28 :   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
    1176                 :             : 
    1177                 :          28 :   ret = VALENT_CHANNEL_GET_CLASS (channel)->upload (channel,
    1178                 :             :                                                     packet,
    1179                 :             :                                                     cancellable,
    1180                 :             :                                                     error);
    1181                 :             : 
    1182                 :          28 :   VALENT_RETURN (ret);
    1183                 :             : }
    1184                 :             : 
    1185                 :             : /**
    1186                 :             :  * valent_channel_upload_async: (virtual upload_async)
    1187                 :             :  * @channel: a `ValentChannel`
    1188                 :             :  * @packet: a KDE Connect packet
    1189                 :             :  * @cancellable: (nullable): a `GCancellable`
    1190                 :             :  * @callback: (scope async): a `GAsyncReadyCallback`
    1191                 :             :  * @user_data: user supplied data
    1192                 :             :  *
    1193                 :             :  * Accept an auxiliary connection, usually to upload data.
    1194                 :             :  *
    1195                 :             :  * This is a non-blocking variant of [method@Valent.Channel.upload]. Call
    1196                 :             :  * [method@Valent.Channel.upload_finish] to get the result.
    1197                 :             :  *
    1198                 :             :  * The default implementation of this method invokes
    1199                 :             :  * [vfunc@Valent.Channel.upload] in a thread.
    1200                 :             :  *
    1201                 :             :  * Since: 1.0
    1202                 :             :  */
    1203                 :             : void
    1204                 :           1 : valent_channel_upload_async (ValentChannel       *channel,
    1205                 :             :                              JsonNode            *packet,
    1206                 :             :                              GCancellable        *cancellable,
    1207                 :             :                              GAsyncReadyCallback  callback,
    1208                 :             :                              gpointer             user_data)
    1209                 :             : {
    1210                 :           1 :   VALENT_ENTRY;
    1211                 :             : 
    1212         [ +  - ]:           1 :   g_return_if_fail (VALENT_IS_CHANNEL (channel));
    1213         [ -  + ]:           1 :   g_return_if_fail (VALENT_IS_PACKET (packet));
    1214   [ -  +  -  -  :           1 :   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  -  -  - ]
    1215                 :             : 
    1216                 :           1 :   VALENT_CHANNEL_GET_CLASS (channel)->upload_async (channel,
    1217                 :             :                                                     packet,
    1218                 :             :                                                     cancellable,
    1219                 :             :                                                     callback,
    1220                 :             :                                                     user_data);
    1221                 :             : 
    1222                 :           1 :   VALENT_EXIT;
    1223                 :             : }
    1224                 :             : 
    1225                 :             : /**
    1226                 :             :  * valent_channel_upload_finish: (virtual upload_finish)
    1227                 :             :  * @channel: a `ValentChannel`
    1228                 :             :  * @result: a `GAsyncResult`
    1229                 :             :  * @error: (nullable): a `GError`
    1230                 :             :  *
    1231                 :             :  * Finish an operation started with [method@Valent.Channel.upload_async].
    1232                 :             :  *
    1233                 :             :  * Returns: (transfer full) (nullable): a `GIOStream`
    1234                 :             :  *
    1235                 :             :  * Since: 1.0
    1236                 :             :  */
    1237                 :             : GIOStream *
    1238                 :           1 : valent_channel_upload_finish (ValentChannel  *channel,
    1239                 :             :                               GAsyncResult   *result,
    1240                 :             :                               GError        **error)
    1241                 :             : {
    1242                 :           1 :   GIOStream *ret;
    1243                 :             : 
    1244                 :           1 :   VALENT_ENTRY;
    1245                 :             : 
    1246         [ +  - ]:           1 :   g_return_val_if_fail (VALENT_IS_CHANNEL (channel), NULL);
    1247         [ -  + ]:           1 :   g_return_val_if_fail (g_task_is_valid (result, channel), NULL);
    1248   [ +  -  -  + ]:           1 :   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
    1249                 :             : 
    1250                 :           1 :   ret = VALENT_CHANNEL_GET_CLASS (channel)->upload_finish (channel,
    1251                 :             :                                                            result,
    1252                 :             :                                                            error);
    1253                 :             : 
    1254                 :           1 :   VALENT_RETURN (ret);
    1255                 :             : }
    1256                 :             : 
        

Generated by: LCOV version 2.0-1