OSTREE_OBJECT_TYPE_IS_META()

#define OSTREE_OBJECT_TYPE_IS_META(t) (t >= 2 && t <= 6)

ostree_metadata_variant_type ()

const GVariantType *
ostree_metadata_variant_type (OstreeObjectType objtype);

ostree_validate_checksum_string ()

gboolean
ostree_validate_checksum_string (const char *sha256,
                                 GError **error);

Use this function to see if input strings are checksums.

ostree_validate_collection_id ()

gboolean
ostree_validate_collection_id (const char *collection_id,
                               GError **error);

Check whether the given collection_id is valid. Return an error if it is invalid or NULL.

Valid collection IDs are reverse DNS names:

(This makes their format identical to D-Bus interface names, for consistency.)

Since: 2018.6

ostree_checksum_to_bytes ()

guchar *
ostree_checksum_to_bytes (const char *checksum);

ostree_checksum_to_bytes_v ()

GVariant *
ostree_checksum_to_bytes_v (const char *checksum);

ostree_checksum_from_bytes ()

char *
ostree_checksum_from_bytes (const guchar *csum);

ostree_checksum_from_bytes_v ()

char *
ostree_checksum_from_bytes_v (GVariant *csum_v);

ostree_checksum_inplace_from_bytes ()

void
ostree_checksum_inplace_from_bytes (const guchar *csum,
                                    char *buf);

Overwrite the contents of buf with stringified version of csum .

[skip]

ostree_checksum_inplace_to_bytes ()

void
ostree_checksum_inplace_to_bytes (const char *checksum,
                                  guchar *buf);

Convert checksum from a string to binary in-place, without allocating memory. Use this function in hot code paths.

ostree_checksum_bytes_peek ()

const guchar *
ostree_checksum_bytes_peek (GVariant *bytes);

ostree_checksum_bytes_peek_validate ()

const guchar *
ostree_checksum_bytes_peek_validate (GVariant *bytes,
                                     GError **error);

Like ostree_checksum_bytes_peek(), but also throws error .

ostree_checksum_b64_from_bytes ()

char *
ostree_checksum_b64_from_bytes (const guchar *csum);

Since: 2016.8

ostree_checksum_b64_to_bytes ()

guchar *
ostree_checksum_b64_to_bytes (const char *checksum);

Since: 2016.8

ostree_checksum_b64_inplace_from_bytes ()

void
ostree_checksum_b64_inplace_from_bytes
                               (const guchar *csum,
                                char *buf);

Overwrite the contents of buf with modified base64 encoding of csum . The "modified" term refers to the fact that instead of '/', the '_' character is used.

[skip]

ostree_checksum_b64_inplace_to_bytes ()

void
ostree_checksum_b64_inplace_to_bytes (const char *checksum,
                                      guint8 *buf);

Overwrite the contents of buf with stringified version of csum .

[skip]

ostree_cmp_checksum_bytes ()

int
ostree_cmp_checksum_bytes (const guchar *a,
                           const guchar *b);

Compare two binary checksums, using memcmp().

ostree_validate_rev ()

gboolean
ostree_validate_rev (const char *rev,
                     GError **error);

ostree_validate_remote_name ()

gboolean
ostree_validate_remote_name (const char *remote_name,
                             GError **error);

Since: 2017.8

ostree_parse_refspec ()

gboolean
ostree_parse_refspec (const char *refspec,
                      char **out_remote,
                      char **out_ref,
                      GError **error);

Split a refspec like gnome-ostree:gnome-ostree/buildmain or just gnome-ostree/buildmain into two parts. In the first case, out_remote will be set to gnome-ostree, and out_ref to gnome-ostree/buildmain. In the second case (a local ref), out_remote will be NULL, and out_ref will be gnome-ostree/buildmain. In both cases, TRUE will be returned.

ostree_object_type_to_string ()

const char *
ostree_object_type_to_string (OstreeObjectType objtype);

Serialize objtype to a string; this is used for file extensions.

ostree_object_type_from_string ()

OstreeObjectType
ostree_object_type_from_string (const char *str);

The reverse of ostree_object_type_to_string().

ostree_hash_object_name ()

guint
ostree_hash_object_name (gconstpointer a);

Use this function with GHashTable and ostree_object_name_serialize().

ostree_object_name_serialize ()

GVariant *
ostree_object_name_serialize (const char *checksum,
                              OstreeObjectType objtype);

ostree_object_name_deserialize ()

void
ostree_object_name_deserialize (GVariant *variant,
                                const char **out_checksum,
                                OstreeObjectType *out_objtype);

Reverse ostree_object_name_serialize(). Note that out_checksum is only valid for the lifetime of variant , and must not be freed.

ostree_object_to_string ()

char *
ostree_object_to_string (const char *checksum,
                         OstreeObjectType objtype);

ostree_object_from_string ()

void
ostree_object_from_string (const char *str,
                           gchar **out_checksum,
                           OstreeObjectType *out_objtype);

Reverse ostree_object_to_string().

ostree_content_stream_parse ()

gboolean
ostree_content_stream_parse (gboolean compressed,
                             GInputStream *input,
                             guint64 input_length,
                             gboolean trusted,
                             GInputStream **out_input,
                             GFileInfo **out_file_info,
                             GVariant **out_xattrs,
                             GCancellable *cancellable,
                             GError **error);

The reverse of ostree_raw_file_to_content_stream(); this function converts an object content stream back into components.

ostree_content_file_parse ()

gboolean
ostree_content_file_parse (gboolean compressed,
                           GFile *content_path,
                           gboolean trusted,
                           GInputStream **out_input,
                           GFileInfo **out_file_info,
                           GVariant **out_xattrs,
                           GCancellable *cancellable,
                           GError **error);

A thin wrapper for ostree_content_stream_parse(); this function converts an object content stream back into components.

ostree_content_file_parse_at ()

gboolean
ostree_content_file_parse_at (gboolean compressed,
                              int parent_dfd,
                              const char *path,
                              gboolean trusted,
                              GInputStream **out_input,
                              GFileInfo **out_file_info,
                              GVariant **out_xattrs,
                              GCancellable *cancellable,
                              GError **error);

A thin wrapper for ostree_content_stream_parse(); this function converts an object content stream back into components.

ostree_raw_file_to_archive_z2_stream ()

gboolean
ostree_raw_file_to_archive_z2_stream (GInputStream *input,
                                      GFileInfo *file_info,
                                      GVariant *xattrs,
                                      GInputStream **out_input,
                                      GCancellable *cancellable,
                                      GError **error);

Convert from a "bare" file representation into an OSTREE_OBJECT_TYPE_FILE stream suitable for ostree pull.

Since: 2016.6

ostree_raw_file_to_archive_z2_stream_with_options ()

gboolean
ostree_raw_file_to_archive_z2_stream_with_options
                               (GInputStream *input,
                                GFileInfo *file_info,
                                GVariant *xattrs,
                                GVariant *options,
                                GInputStream **out_input,
                                GCancellable *cancellable,
                                GError **error);

Like ostree_raw_file_to_archive_z2_stream(), but supports an extensible set of flags. The following flags are currently defined:

Since: 2017.3

ostree_raw_file_to_content_stream ()

gboolean
ostree_raw_file_to_content_stream (GInputStream *input,
                                   GFileInfo *file_info,
                                   GVariant *xattrs,
                                   GInputStream **out_input,
                                   guint64 *out_length,
                                   GCancellable *cancellable,
                                   GError **error);

Convert from a "bare" file representation into an OSTREE_OBJECT_TYPE_FILE stream. This is a fundamental operation for writing data to an OstreeRepo.

ostree_break_hardlink ()

gboolean
ostree_break_hardlink (int dfd,
                       const char *path,
                       gboolean skip_xattrs,
                       GCancellable *cancellable,
                       GError **error);

In many cases using libostree, a program may need to "break" hardlinks by performing a copy. For example, in order to logically append to a file.

This function performs full copying, including e.g. extended attributes and permissions of both regular files and symbolic links.

If the file is not hardlinked, this function does nothing and returns successfully.

This function does not perform synchronization via fsync() or fdatasync(); the idea is this will commonly be done as part of an ostree_repo_commit_transaction(), which itself takes care of synchronization.

Since: 2017.15

ostree_checksum_file_from_input ()

gboolean
ostree_checksum_file_from_input (GFileInfo *file_info,
                                 GVariant *xattrs,
                                 GInputStream *in,
                                 OstreeObjectType objtype,
                                 guchar **out_csum,
                                 GCancellable *cancellable,
                                 GError **error);

Compute the OSTree checksum for a given input.

ostree_checksum_file ()

gboolean
ostree_checksum_file (GFile *f,
                      OstreeObjectType objtype,
                      guchar **out_csum,
                      GCancellable *cancellable,
                      GError **error);

Compute the OSTree checksum for a given file.

ostree_checksum_file_at ()

gboolean
ostree_checksum_file_at (int dfd,
                         const char *path,
                         struct stat *stbuf,
                         OstreeObjectType objtype,
                         OstreeChecksumFlags flags,
                         char **out_checksum,
                         GCancellable *cancellable,
                         GError **error);

Compute the OSTree checksum for a given file. This is an fd-relative version of ostree_checksum_file() which also takes flags and fills in a caller allocated buffer.

Since: 2017.13

ostree_checksum_file_async ()

void
ostree_checksum_file_async (GFile *f,
                            OstreeObjectType objtype,
                            int io_priority,
                            GCancellable *cancellable,
                            GAsyncReadyCallback callback,
                            gpointer user_data);

Asynchronously compute the OSTree checksum for a given file; complete with ostree_checksum_file_async_finish().

ostree_checksum_file_async_finish ()

gboolean
ostree_checksum_file_async_finish (GFile *f,
                                   GAsyncResult *result,
                                   guchar **out_csum,
                                   GError **error);

Finish computing the OSTree checksum for a given file; see ostree_checksum_file_async().

ostree_fs_get_all_xattrs ()

GVariant *
ostree_fs_get_all_xattrs (int fd,
                          GCancellable *cancellable,
                          GError **error);

Retrieve all extended attributes in a canonical (sorted) order from the given file descriptor.

ostree_fs_get_all_xattrs_at ()

GVariant *
ostree_fs_get_all_xattrs_at (int dfd,
                             const char *path,
                             GCancellable *cancellable,
                             GError **error);

Retrieve all extended attributes in a canonical (sorted) order from the given path, relative to the provided directory file descriptor. The target path will not be dereferenced. Currently on Linux, this API must be used currently to retrieve extended attributes for symbolic links because while O_PATH exists, it cannot be used with fgetxattr().

ostree_create_directory_metadata ()

GVariant *
ostree_create_directory_metadata (GFileInfo *dir_info,
                                  GVariant *xattrs);

ostree_validate_structureof_objtype ()

gboolean
ostree_validate_structureof_objtype (guchar objtype,
                                     GError **error);

ostree_validate_structureof_csum_v ()

gboolean
ostree_validate_structureof_csum_v (GVariant *checksum,
                                    GError **error);

ostree_validate_structureof_checksum_string ()

gboolean
ostree_validate_structureof_checksum_string
                               (const char *checksum,
                                GError **error);

ostree_validate_structureof_file_mode ()

gboolean
ostree_validate_structureof_file_mode (guint32 mode,
                                       GError **error);

ostree_validate_structureof_commit ()

gboolean
ostree_validate_structureof_commit (GVariant *commit,
                                    GError **error);

Use this to validate the basic structure of commit , independent of any other objects it references.

ostree_validate_structureof_dirtree ()

gboolean
ostree_validate_structureof_dirtree (GVariant *dirtree,
                                     GError **error);

Use this to validate the basic structure of dirtree , independent of any other objects it references.

ostree_validate_structureof_dirmeta ()

gboolean
ostree_validate_structureof_dirmeta (GVariant *dirmeta,
                                     GError **error);

Use this to validate the basic structure of dirmeta .

ostree_commit_get_parent ()

gchar *
ostree_commit_get_parent (GVariant *commit_variant);

ostree_commit_get_timestamp ()

guint64
ostree_commit_get_timestamp (GVariant *commit_variant);

Since: 2016.3

ostree_commit_metadata_for_bootable ()

gboolean
ostree_commit_metadata_for_bootable (GFile *root,
                                     GVariantDict *dict,
                                     GCancellable *cancellable,
                                     GError **error);

Update provided dict with standard metadata for bootable OSTree commits.

Since: 2021.1

ostree_commit_get_content_checksum ()

gchar *
ostree_commit_get_content_checksum (GVariant *commit_variant);

There are use cases where one wants a checksum just of the content of a commit. OSTree commits by default capture the current timestamp, and may have additional metadata, which means that re-committing identical content often results in a new checksum.

By comparing checksums of content, it's possible to easily distinguish cases where nothing actually changed.

The content checksums is simply defined as SHA256(root dirtree_checksum || root_dirmeta_checksum), i.e. the SHA-256 of the root "dirtree" object's checksum concatenated with the root "dirmeta" checksum (both in binary form, not hexadecimal).

Since: 2018.2

ostree_commit_get_object_sizes ()

gboolean
ostree_commit_get_object_sizes (GVariant *commit_variant,
                                GPtrArray **out_sizes_entries,
                                GError **error);

Reads a commit's "ostree.sizes" metadata and returns an array of OstreeCommitSizesEntry in out_sizes_entries . Each element represents an object in the commit. If the commit does not contain the "ostree.sizes" metadata, a G_IO_ERROR_NOT_FOUND error will be returned.

Since: 2020.1

ostree_commit_sizes_entry_new ()

OstreeCommitSizesEntry *
ostree_commit_sizes_entry_new (const gchar *checksum,
                               OstreeObjectType objtype,
                               guint64 unpacked,
                               guint64 archived);

Create a new OstreeCommitSizesEntry for representing an object in a commit's "ostree.sizes" metadata.

Since: 2020.1

ostree_commit_sizes_entry_copy ()

OstreeCommitSizesEntry *
ostree_commit_sizes_entry_copy (const OstreeCommitSizesEntry *entry);

Create a copy of the given entry .

Since: 2020.1

ostree_commit_sizes_entry_free ()

void
ostree_commit_sizes_entry_free (OstreeCommitSizesEntry *entry);

Free given entry .

Since: 2020.1

ostree_check_version ()

gboolean
ostree_check_version (guint required_year,
                      guint required_release);

Since: 2017.4

OSTREE_MAX_METADATA_SIZE

#define OSTREE_MAX_METADATA_SIZE (128 * 1024 * 1024)

Default limit for maximum permitted size in bytes of metadata objects fetched over HTTP (including repo/config files, refs, and commit/dirtree/dirmeta objects). This is an arbitrary number intended to mitigate disk space exhaustion attacks.

OSTREE_MAX_METADATA_WARN_SIZE

#define OSTREE_MAX_METADATA_WARN_SIZE (7 * 1024 * 1024)

This variable is no longer meaningful, it is kept only for compatibility.

enum OstreeObjectType

Enumeration for core object types; OSTREE_OBJECT_TYPE_FILE is for content, the other types are metadata.

OSTREE_OBJECT_TYPE_LAST

#define OSTREE_OBJECT_TYPE_LAST OSTREE_OBJECT_TYPE_FILE_XATTRS_LINK

Last valid object type; use this to validate ranges.

OSTREE_DIRMETA_GVARIANT_STRING

#define OSTREE_DIRMETA_GVARIANT_STRING "(uuua(ayay))"

OSTREE_DIRMETA_GVARIANT_FORMAT

#define OSTREE_DIRMETA_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_DIRMETA_GVARIANT_STRING)

OSTREE_FILEMETA_GVARIANT_STRING

#define OSTREE_FILEMETA_GVARIANT_STRING "(uuua(ayay))"

OSTREE_FILEMETA_GVARIANT_FORMAT

#define OSTREE_FILEMETA_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_FILEMETA_GVARIANT_STRING)

This is not a regular object type, but used as an xattr on a .file object in bare-user repositories. This allows us to store metadata information that we can't store in the real filesystem but we can still use a regular .file object that we can hardlink to in the case of a user-mode checkout.

OSTREE_TREE_GVARIANT_STRING

#define OSTREE_TREE_GVARIANT_STRING "(a(say)a(sayay))"

OSTREE_TREE_GVARIANT_FORMAT

#define OSTREE_TREE_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_TREE_GVARIANT_STRING)

OSTREE_COMMIT_GVARIANT_STRING

#define OSTREE_COMMIT_GVARIANT_STRING "(a{sv}aya(say)sstayay)"

OSTREE_COMMIT_GVARIANT_FORMAT

#define OSTREE_COMMIT_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_COMMIT_GVARIANT_STRING)

OSTREE_SUMMARY_GVARIANT_STRING

#define OSTREE_SUMMARY_GVARIANT_STRING "(a(s(taya{sv}))a{sv})"

OSTREE_SUMMARY_GVARIANT_FORMAT

#define OSTREE_SUMMARY_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_SUMMARY_GVARIANT_STRING)

The currently defined keys for the a{sv} of additional metadata for each commit are: