LCOV - code coverage report
Current view: top level - src/libvalent/device - valent-channel.c (source / functions) Coverage Total Hit
Test: Code Coverage Lines: 97.0 % 303 294
Test Date: 2024-12-06 20:21:07 Functions: 100.0 % 32 32
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 49.2 % 258 127

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

Generated by: LCOV version 2.0-1