New upstream version 2019.6

src/libostree/libostree-devel.sym

@@ -18,8 +18,8 @@
 ***/
 
 /* Add new symbols here.  Release commits should copy this section into -released.sym. */
-LIBOSTREE_2019.5 {
-} LIBOSTREE_2019.4;
+LIBOSTREE_2019.7 {
+} LIBOSTREE_2019.6;
 
 /* Stub section for the stable release *after* this development one; don't
  * edit this other than to update the year.  This is just a copy/paste

src/libostree/libostree-released.sym

@@ -577,6 +577,10 @@ LIBOSTREE_2019.4 {
 
 /* No new symbols in 2019.5 */
 
+LIBOSTREE_2019.6 {
+  ostree_async_progress_copy_state;
+} LIBOSTREE_2019.4;
+
 /* NOTE: Only add more content here in release commits!  See the
  * comments at the top of this file.
  */

src/libostree/ostree-async-progress.c

@@ -424,6 +424,40 @@ ostree_async_progress_set_uint64 (OstreeAsyncProgress       *self,
   ostree_async_progress_set_variant (self, key, g_variant_new_uint64 (value));
 }
 
+/**
+ * ostree_async_progress_copy_state:
+ * @self: An #OstreeAsyncProgress to copy from
+ * @dest: An #OstreeAsyncProgress to copy to
+ *
+ * Atomically copies all the state from @self to @dest, without invoking the
+ * callback.
+ * This is used for proxying progress objects across different #GMainContexts.
+ *
+ * Since: 2019.6
+ */
+void
+ostree_async_progress_copy_state (OstreeAsyncProgress *self,
+                                  OstreeAsyncProgress *dest)
+{
+  g_return_if_fail (OSTREE_IS_ASYNC_PROGRESS (self));
+  g_return_if_fail (OSTREE_IS_ASYNC_PROGRESS (dest));
+
+  g_mutex_lock (&self->lock);
+
+  if (self->dead)
+    goto out;
+
+  GLNX_HASH_TABLE_FOREACH_KV (self->values, void *, key, GVariant *, value)
+    {
+      if (value)
+        g_variant_ref (value);
+      g_hash_table_replace (dest->values, key, value);
+    }
+
+ out:
+  g_mutex_unlock (&self->lock);
+}
+
 /**
  * ostree_async_progress_new:
  *

src/libostree/ostree-async-progress.h

@@ -92,4 +92,8 @@ void ostree_async_progress_set_variant (OstreeAsyncProgress *self,
 _OSTREE_PUBLIC
 void ostree_async_progress_finish (OstreeAsyncProgress *self);
 
+_OSTREE_PUBLIC
+void ostree_async_progress_copy_state (OstreeAsyncProgress *self,
+                                       OstreeAsyncProgress *dest);
+
 G_END_DECLS

src/libostree/ostree-fetcher-curl.c

@@ -261,9 +261,8 @@ destroy_and_unref_source (GSource *source)
 }
 
 static char *
-request_get_uri (FetcherRequest *req, guint idx)
+request_get_uri (FetcherRequest *req, SoupURI *baseuri)
 {
-  SoupURI *baseuri = req->mirrorlist->pdata[idx];
   if (!req->filename)
     return soup_uri_to_string (baseuri, FALSE);
   { g_autofree char *uristr = soup_uri_to_string (baseuri, FALSE);
@@ -715,7 +714,8 @@ initiate_next_curl_request (FetcherRequest *req,
 
   g_assert_cmpint (req->idx, <, req->mirrorlist->len);
 
-  { g_autofree char *uri = request_get_uri (req, req->idx);
+  SoupURI *baseuri = req->mirrorlist->pdata[req->idx];
+  { g_autofree char *uri = request_get_uri (req, baseuri);
     curl_easy_setopt (req->easy, CURLOPT_URL, uri);
   }
 
@@ -771,6 +771,12 @@ initiate_next_curl_request (FetcherRequest *req,
   if ((self->config_flags & OSTREE_FETCHER_FLAGS_TRANSFER_GZIP) > 0)
     curl_easy_setopt (req->easy, CURLOPT_ACCEPT_ENCODING, "");
 
+  /* If we have e.g. basic auth in the URL string, let's honor that */
+  const char *username = soup_uri_get_user (baseuri);
+  curl_easy_setopt (req->easy, CURLOPT_USERNAME, username);
+  const char *password = soup_uri_get_password (baseuri);
+  curl_easy_setopt (req->easy, CURLOPT_PASSWORD, password);
+
   /* We should only speak HTTP; TODO: only enable file if specified */
   curl_easy_setopt (req->easy, CURLOPT_PROTOCOLS, (long)(CURLPROTO_HTTP | CURLPROTO_HTTPS | CURLPROTO_FILE));
   /* Picked the current version in F25 as of 20170127, since

src/libostree/ostree-kernel-args.c

@@ -30,6 +30,111 @@ struct _OstreeKernelArgs {
   GHashTable *table;
 };
 
+struct _OstreeKernelArgsEntry {
+  char *key;
+  char *value;
+};
+
+char *
+_ostree_kernel_args_entry_get_key (const OstreeKernelArgsEntry *e)
+{
+  return e->key;
+}
+
+char *
+_ostree_kernel_args_entry_get_value (const OstreeKernelArgsEntry *e)
+{
+  return e->value;
+}
+
+void
+_ostree_kernel_args_entry_set_key (OstreeKernelArgsEntry *e,
+                                   char  *key)
+{
+  e->key = key;
+}
+
+void
+_ostree_kernel_args_entry_set_value (OstreeKernelArgsEntry *e,
+                                     char  *value)
+{
+  e->value = value;
+}
+
+char *
+_ostree_kernel_args_get_key_index (const OstreeKernelArgs *kargs,
+                                   int i)
+{
+  OstreeKernelArgsEntry *e = kargs->order->pdata[i];
+  return e->key;
+}
+
+char *
+_ostree_kernel_args_get_value_index (const OstreeKernelArgs *kargs,
+                                     int i)
+{
+  OstreeKernelArgsEntry *e = kargs->order->pdata[i];
+  return e->value;
+}
+
+OstreeKernelArgsEntry *
+_ostree_kernel_args_entry_new (void)
+{
+  return g_new0 (OstreeKernelArgsEntry, 1);
+}
+
+void
+_ostree_kernel_args_entry_value_free (OstreeKernelArgsEntry *e)
+{
+  g_clear_pointer (&e->value, g_free);
+}
+
+/* Free the value field, and the entry.  This should be set as the free
+ * function, for all pointer arrays stored in the hash table.
+ */
+static void
+kernel_args_entry_free_from_table (gpointer data)
+{
+  OstreeKernelArgsEntry *e = data;
+  // The hash table owns the key; do not free it here.
+  g_free (_ostree_kernel_args_entry_get_value (e));
+  g_free (e);
+}
+
+static gboolean
+kernel_args_entry_value_equal (gconstpointer data,
+                               gconstpointer value)
+{
+  const OstreeKernelArgsEntry *e = data;
+  return g_strcmp0 (_ostree_kernel_args_entry_get_value (e), value) == 0;
+}
+
+static gboolean
+kernel_args_entry_key_equal (gconstpointer data,
+                             gconstpointer key)
+{
+  const OstreeKernelArgsEntry *e = data;
+  return g_strcmp0 (_ostree_kernel_args_entry_get_key (e), key) == 0;
+}
+
+static void
+kernel_args_entry_replace_value (OstreeKernelArgsEntry *e,
+                                 const char *value)
+{
+  g_assert (e);
+  _ostree_kernel_args_entry_value_free (e);
+  _ostree_kernel_args_entry_set_value (e, g_strdup (value));
+}
+
+static void
+kernel_args_remove_entries_from_order (GPtrArray *order,
+                                       GPtrArray *entries)
+{
+  g_assert (entries);
+  for (int i = 0; i < entries->len; i++)
+    g_assert (g_ptr_array_remove (order, entries->pdata[i]));
+}
+
 static char *
 split_keyeq (char *arg)
 {
@@ -82,9 +187,11 @@ ostree_kernel_args_new (void)
 {
   OstreeKernelArgs *ret;
   ret = g_new0 (OstreeKernelArgs, 1);
-  ret->order = g_ptr_array_new_with_free_func (g_free);
+  /* Hash table owns the kernel args entries, since it uses keys to index,
+   * and its values are used to locate entries in the order array. */
   ret->table = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                      NULL, (GDestroyNotify)g_ptr_array_unref);
+                                      g_free, (GDestroyNotify)g_ptr_array_unref);
+  ret->order = g_ptr_array_new_with_free_func (NULL);
   return ret;
 }
 
@@ -194,10 +301,10 @@ ostree_kernel_args_new_replace (OstreeKernelArgs *kargs,
   const char *key = arg_owned;
   const char *val = split_keyeq (arg_owned);
 
-  GPtrArray *values = g_hash_table_lookup (kargs->table, key);
-  if (!values)
+  GPtrArray *entries = g_hash_table_lookup (kargs->table, key);
+  if (!entries)
     return glnx_throw (error, "No key '%s' found", key);
-  g_assert_cmpuint (values->len, >, 0);
+  g_assert_cmpuint (entries->len, >, 0);
 
   /* first handle the case where the user just wants to replace an old value */
   if (val && strchr (val, '='))
@@ -207,20 +314,18 @@ ostree_kernel_args_new_replace (OstreeKernelArgs *kargs,
       g_assert (new_val);
 
       guint i = 0;
-      if (!ot_ptr_array_find_with_equal_func (values, old_val, strcmp0_equal, &i))
+      if (!ot_ptr_array_find_with_equal_func (entries, old_val, kernel_args_entry_value_equal, &i))
         return glnx_throw (error, "No karg '%s=%s' found", key, old_val);
 
-      g_clear_pointer (&values->pdata[i], g_free);
-      values->pdata[i] = g_strdup (new_val);
+      kernel_args_entry_replace_value (entries->pdata[i], new_val);
       return TRUE;
     }
 
   /* can't know which val to replace without the old_val=new_val syntax */
-  if (values->len > 1)
+  if (entries->len > 1)
     return glnx_throw (error, "Multiple values for key '%s' found", key);
 
-  g_clear_pointer (&values->pdata[0], g_free);
-  values->pdata[0] = g_strdup (val);
+  kernel_args_entry_replace_value (entries->pdata[0], val);
   return TRUE;
 }
 
@@ -246,6 +351,13 @@ ostree_kernel_args_delete_key_entry (OstreeKernelArgs *kargs,
                                      const char       *key,
                                      GError          **error)
 {
+  GPtrArray *entries = g_hash_table_lookup (kargs->table, key);
+  if (!entries)
+    return glnx_throw (error, "No key '%s' found", key);
+  g_assert_cmpuint (entries->len, >, 0);
+
+  kernel_args_remove_entries_from_order (kargs->order, entries);
+
   if (!g_hash_table_remove (kargs->table, key))
     {
       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
@@ -254,10 +366,6 @@ ostree_kernel_args_delete_key_entry (OstreeKernelArgs *kargs,
       return FALSE;
     }
 
-  /* Then remove the key from order table */
-  guint key_index;
-  g_assert (ot_ptr_array_find_with_equal_func (kargs->order, key, g_str_equal, &key_index));
-  g_assert (g_ptr_array_remove_index (kargs->order, key_index));
   return TRUE;
 }
 
@@ -294,16 +402,17 @@ ostree_kernel_args_delete (OstreeKernelArgs  *kargs,
   const char *key = arg_owned;
   const char *val = split_keyeq (arg_owned);
 
-  GPtrArray *values = g_hash_table_lookup (kargs->table, key);
-  if (!values)
+  GPtrArray *entries = g_hash_table_lookup (kargs->table, key);
+  if (!entries)
     return glnx_throw (error, "No key '%s' found", key);
-  g_assert_cmpuint (values->len, >, 0);
+  g_assert_cmpuint (entries->len, >, 0);
 
   /* special-case: we allow deleting by key only if there's only one val */
-  if (values->len == 1)
+  if (entries->len == 1)
     {
       /* but if a specific val was passed, check that it's the same */
-      if (val && !strcmp0_equal (val, values->pdata[0]))
+      OstreeKernelArgsEntry *e = entries->pdata[0];
+      if (val && !strcmp0_equal (val, _ostree_kernel_args_entry_get_value (e)))
         return glnx_throw (error, "No karg '%s=%s' found", key, val);
       return ostree_kernel_args_delete_key_entry (kargs, key, error);
     }
@@ -311,7 +420,7 @@ ostree_kernel_args_delete (OstreeKernelArgs  *kargs,
   /* note val might be NULL here, in which case we're looking for `key`, not `key=` or
    * `key=val` */
   guint i = 0;
-  if (!ot_ptr_array_find_with_equal_func (values, val, strcmp0_equal, &i))
+  if (!ot_ptr_array_find_with_equal_func (entries, val, kernel_args_entry_value_equal, &i))
     {
       if (!val)
         /* didn't find NULL -> only key= key=val1 key=val2 style things left, so the user
@@ -320,7 +429,8 @@ ostree_kernel_args_delete (OstreeKernelArgs  *kargs,
       return glnx_throw (error, "No karg '%s' found", arg);
     }
 
-  g_ptr_array_remove_index (values, i);
+  g_assert (g_ptr_array_remove (kargs->order, entries->pdata[i]));
+  g_assert (g_ptr_array_remove_index (entries, i));
   return TRUE;
 }
 
@@ -340,22 +450,38 @@ ostree_kernel_args_replace_take (OstreeKernelArgs   *kargs,
                                  char               *arg)
 {
   gboolean existed;
-  GPtrArray *values = g_ptr_array_new_with_free_func (g_free);
+  GPtrArray *entries = g_ptr_array_new_with_free_func (kernel_args_entry_free_from_table);
   const char *value = split_keyeq (arg);
   gpointer old_key;
 
-  g_ptr_array_add (values, g_strdup (value));
-  existed = g_hash_table_lookup_extended (kargs->table, arg, &old_key, NULL);
+  OstreeKernelArgsEntry *entry = g_new0 (OstreeKernelArgsEntry, 1);
+  _ostree_kernel_args_entry_set_value (entry, g_strdup (value));
+  g_ptr_array_add (entries, entry);
+
+  gpointer old_entries_ptr;
+  existed = g_hash_table_lookup_extended (kargs->table, arg, &old_key, &old_entries_ptr);
+  GPtrArray *old_entries = old_entries_ptr;
 
   if (existed)
     {
-      g_hash_table_replace (kargs->table, old_key, values);
-      g_free (arg);
+      g_assert (old_entries);
+      g_assert_cmpuint (old_entries->len, >, 0);
+
+      guint old_order_index = 0;
+      g_assert (ot_ptr_array_find_with_equal_func (kargs->order, old_key, kernel_args_entry_key_equal, &old_order_index));
+      kernel_args_remove_entries_from_order (kargs->order, old_entries);
+
+      g_assert_cmpstr (old_key, ==, arg);
+      _ostree_kernel_args_entry_set_key (entry, old_key);
+      g_ptr_array_insert (kargs->order, old_order_index, entry);
+      // `arg` is freed by the `g_hash_table_insert` call.
+      g_hash_table_insert (kargs->table, arg, entries);
     }
   else
     {
-      g_ptr_array_add (kargs->order, arg);
-      g_hash_table_replace (kargs->table, arg, values);
+      _ostree_kernel_args_entry_set_key (entry, arg);
+      g_hash_table_replace (kargs->table, arg, entries);
+      g_ptr_array_add (kargs->order, entry);
     }
 }
 
@@ -393,28 +519,26 @@ ostree_kernel_args_append (OstreeKernelArgs  *kargs,
                            const char        *arg)
 {
   gboolean existed = TRUE;
-  GPtrArray *values;
+  GPtrArray *entries = NULL;
   char *duped = g_strdup (arg);
   const char *val = split_keyeq (duped);
 
-  values = g_hash_table_lookup (kargs->table, duped);
-  if (!values)
+  entries = g_hash_table_lookup (kargs->table, duped);
+  if (!entries)
     {
-      values = g_ptr_array_new_with_free_func (g_free);
+      entries = g_ptr_array_new_with_free_func (kernel_args_entry_free_from_table);
       existed = FALSE;
     }
 
-  g_ptr_array_add (values, g_strdup (val));
+  OstreeKernelArgsEntry *entry = _ostree_kernel_args_entry_new ();
+  _ostree_kernel_args_entry_set_key (entry, duped);
+  _ostree_kernel_args_entry_set_value (entry, g_strdup (val));
+
+  g_ptr_array_add (entries, entry);
+  g_ptr_array_add (kargs->order, entry);
 
   if (!existed)
-    {
-      g_hash_table_replace (kargs->table, duped, values);
-      g_ptr_array_add (kargs->order, duped);
-    }
-  else
-    {
-      g_free (duped);
-    }
+    g_hash_table_replace (kargs->table, duped, entries);
 }
 
 /**
@@ -598,20 +722,13 @@ ostree_kernel_args_to_strv (OstreeKernelArgs *kargs)
 
   for (i = 0; i < kargs->order->len; i++)
     {
-      const char *key = kargs->order->pdata[i];
-      GPtrArray *values = g_hash_table_lookup (kargs->table, key);
-      guint j;
+      const char *key = _ostree_kernel_args_get_key_index (kargs, i);
+      const char *value = _ostree_kernel_args_get_value_index (kargs, i);
 
-      g_assert (values != NULL);
-
-      for (j = 0; j < values->len; j++)
-        {
-          const char *value = values->pdata[j];
-          if (value == NULL)
-            g_ptr_array_add (strv, g_strconcat (key, NULL));
-          else
-            g_ptr_array_add (strv, g_strconcat (key, "=", value, NULL));
-        }
+      if (value == NULL)
+        g_ptr_array_add (strv, g_strconcat (key, NULL));
+      else
+        g_ptr_array_add (strv, g_strconcat (key, "=", value, NULL));
     }
   g_ptr_array_add (strv, NULL);
 
@@ -644,27 +761,19 @@ ostree_kernel_args_to_string (OstreeKernelArgs *kargs)
 
   for (i = 0; i < kargs->order->len; i++)
     {
-      const char *key = kargs->order->pdata[i];
-      GPtrArray *values = g_hash_table_lookup (kargs->table, key);
-      guint j;
+      const char *key = _ostree_kernel_args_get_key_index (kargs, i);
+      const char *value = _ostree_kernel_args_get_value_index (kargs, i);
 
-      g_assert (values != NULL);
+      if (first)
+        first = FALSE;
+      else
+        g_string_append_c (buf, ' ');
 
-      for (j = 0; j < values->len; j++)
+      g_string_append (buf, key);
+      if (value != NULL)
         {
-          const char *value = values->pdata[j];
-
-          if (first)
-            first = FALSE;
-          else
-            g_string_append_c (buf, ' ');
-
-          g_string_append (buf, key);
-          if (value != NULL)
-            {
-              g_string_append_c (buf, '=');
-              g_string_append (buf, value);
-            }
+          g_string_append_c (buf, '=');
+          g_string_append (buf, value);
         }
     }
 
@@ -688,11 +797,12 @@ ostree_kernel_args_to_string (OstreeKernelArgs *kargs)
 const char *
 ostree_kernel_args_get_last_value (OstreeKernelArgs *kargs, const char *key)
 {
-  GPtrArray *values = g_hash_table_lookup (kargs->table, key);
+  const GPtrArray *entries = g_hash_table_lookup (kargs->table, key);
 
-  if (!values)
+  if (!entries)
     return NULL;
 
-  g_assert (values->len > 0);
-  return (char*)values->pdata[values->len-1];
+  g_assert (entries->len > 0);
+  const OstreeKernelArgsEntry *e = entries->pdata[entries->len-1];
+  return _ostree_kernel_args_entry_get_value (e);
 }

src/libostree/ostree-kernel-args.h

@@ -27,11 +27,40 @@
 G_BEGIN_DECLS
 
 typedef struct _OstreeKernelArgs OstreeKernelArgs;
+typedef struct _OstreeKernelArgsEntry OstreeKernelArgsEntry;
 
 GHashTable *_ostree_kernel_arg_get_kargs_table (OstreeKernelArgs *kargs);
 
 GPtrArray *_ostree_kernel_arg_get_key_array (OstreeKernelArgs *kargs);
 
+char *
+_ostree_kernel_args_entry_get_key (const OstreeKernelArgsEntry *e);
+
+char *
+_ostree_kernel_args_entry_get_value (const OstreeKernelArgsEntry *e);
+
+void
+_ostree_kernel_args_entry_set_key (OstreeKernelArgsEntry *e,
+                                   char  *key);
+
+void
+_ostree_kernel_args_entry_set_value (OstreeKernelArgsEntry *e,
+                                     char  *value);
+
+char *
+_ostree_kernel_args_get_key_index (const OstreeKernelArgs *kargs,
+                                   int i);
+
+char *
+_ostree_kernel_args_get_value_index (const OstreeKernelArgs *kargs,
+                                     int i);
+
+OstreeKernelArgsEntry *
+_ostree_kernel_args_entry_new (void);
+
+void
+_ostree_kernel_args_entry_value_free (OstreeKernelArgsEntry *e);
+
 _OSTREE_PUBLIC
 void ostree_kernel_args_free (OstreeKernelArgs *kargs);
 

src/libostree/ostree-version.h

@@ -43,7 +43,7 @@
  *
  * Since: 2017.4
  */
-#define OSTREE_RELEASE_VERSION (5)
+#define OSTREE_RELEASE_VERSION (6)
 
 /**
  * OSTREE_VERSION
@@ -52,7 +52,7 @@
  *
  * Since: 2017.4
  */
-#define OSTREE_VERSION (2019.5)
+#define OSTREE_VERSION (2019.6)
 
 /**
  * OSTREE_VERSION_S:
@@ -62,7 +62,7 @@
  *
  * Since: 2017.4
  */
-#define OSTREE_VERSION_S "2019.5"
+#define OSTREE_VERSION_S "2019.6"
 
 #define OSTREE_ENCODE_VERSION(year,release) \
         ((year) << 16 | (release))