1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7 clippy::approx_constant,
8 clippy::type_complexity,
9 clippy::unreadable_literal,
10 clippy::upper_case_acronyms
11)]
12#![cfg_attr(docsrs, feature(doc_cfg))]
13
14use gio_sys as gio;
15use glib_sys as glib;
16use gobject_sys as gobject;
17
18mod manual;
19
20pub use manual::*;
21
22#[cfg(unix)]
23#[allow(unused_imports)]
24use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
25#[allow(unused_imports)]
26use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
27#[allow(unused_imports)]
28use std::ffi::{
29 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
30};
31
32#[allow(unused_imports)]
33use glib::{gboolean, gconstpointer, gpointer, GType};
34
35pub type OstreeCollectionRefv = *mut *mut OstreeCollectionRef;
37pub type OstreeRepoFinderResultv = *mut *mut OstreeRepoFinderResult;
38
39pub type OstreeDeploymentUnlockedState = c_int;
41pub const OSTREE_DEPLOYMENT_UNLOCKED_NONE: OstreeDeploymentUnlockedState = 0;
42pub const OSTREE_DEPLOYMENT_UNLOCKED_DEVELOPMENT: OstreeDeploymentUnlockedState = 1;
43pub const OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX: OstreeDeploymentUnlockedState = 2;
44pub const OSTREE_DEPLOYMENT_UNLOCKED_TRANSIENT: OstreeDeploymentUnlockedState = 3;
45
46pub type OstreeGpgError = c_int;
47pub const OSTREE_GPG_ERROR_NO_SIGNATURE: OstreeGpgError = 0;
48pub const OSTREE_GPG_ERROR_INVALID_SIGNATURE: OstreeGpgError = 1;
49pub const OSTREE_GPG_ERROR_MISSING_KEY: OstreeGpgError = 2;
50pub const OSTREE_GPG_ERROR_EXPIRED_SIGNATURE: OstreeGpgError = 3;
51pub const OSTREE_GPG_ERROR_EXPIRED_KEY: OstreeGpgError = 4;
52pub const OSTREE_GPG_ERROR_REVOKED_KEY: OstreeGpgError = 5;
53
54pub type OstreeGpgSignatureAttr = c_int;
55pub const OSTREE_GPG_SIGNATURE_ATTR_VALID: OstreeGpgSignatureAttr = 0;
56pub const OSTREE_GPG_SIGNATURE_ATTR_SIG_EXPIRED: OstreeGpgSignatureAttr = 1;
57pub const OSTREE_GPG_SIGNATURE_ATTR_KEY_EXPIRED: OstreeGpgSignatureAttr = 2;
58pub const OSTREE_GPG_SIGNATURE_ATTR_KEY_REVOKED: OstreeGpgSignatureAttr = 3;
59pub const OSTREE_GPG_SIGNATURE_ATTR_KEY_MISSING: OstreeGpgSignatureAttr = 4;
60pub const OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT: OstreeGpgSignatureAttr = 5;
61pub const OSTREE_GPG_SIGNATURE_ATTR_TIMESTAMP: OstreeGpgSignatureAttr = 6;
62pub const OSTREE_GPG_SIGNATURE_ATTR_EXP_TIMESTAMP: OstreeGpgSignatureAttr = 7;
63pub const OSTREE_GPG_SIGNATURE_ATTR_PUBKEY_ALGO_NAME: OstreeGpgSignatureAttr = 8;
64pub const OSTREE_GPG_SIGNATURE_ATTR_HASH_ALGO_NAME: OstreeGpgSignatureAttr = 9;
65pub const OSTREE_GPG_SIGNATURE_ATTR_USER_NAME: OstreeGpgSignatureAttr = 10;
66pub const OSTREE_GPG_SIGNATURE_ATTR_USER_EMAIL: OstreeGpgSignatureAttr = 11;
67pub const OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT_PRIMARY: OstreeGpgSignatureAttr = 12;
68pub const OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP: OstreeGpgSignatureAttr = 13;
69pub const OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY: OstreeGpgSignatureAttr = 14;
70
71pub type OstreeObjectType = c_int;
72pub const OSTREE_OBJECT_TYPE_FILE: OstreeObjectType = 1;
73pub const OSTREE_OBJECT_TYPE_DIR_TREE: OstreeObjectType = 2;
74pub const OSTREE_OBJECT_TYPE_DIR_META: OstreeObjectType = 3;
75pub const OSTREE_OBJECT_TYPE_COMMIT: OstreeObjectType = 4;
76pub const OSTREE_OBJECT_TYPE_TOMBSTONE_COMMIT: OstreeObjectType = 5;
77pub const OSTREE_OBJECT_TYPE_COMMIT_META: OstreeObjectType = 6;
78pub const OSTREE_OBJECT_TYPE_PAYLOAD_LINK: OstreeObjectType = 7;
79pub const OSTREE_OBJECT_TYPE_FILE_XATTRS: OstreeObjectType = 8;
80pub const OSTREE_OBJECT_TYPE_FILE_XATTRS_LINK: OstreeObjectType = 9;
81
82pub type OstreeRepoCheckoutFilterResult = c_int;
83pub const OSTREE_REPO_CHECKOUT_FILTER_ALLOW: OstreeRepoCheckoutFilterResult = 0;
84pub const OSTREE_REPO_CHECKOUT_FILTER_SKIP: OstreeRepoCheckoutFilterResult = 1;
85
86pub type OstreeRepoCheckoutMode = c_int;
87pub const OSTREE_REPO_CHECKOUT_MODE_NONE: OstreeRepoCheckoutMode = 0;
88pub const OSTREE_REPO_CHECKOUT_MODE_USER: OstreeRepoCheckoutMode = 1;
89
90pub type OstreeRepoCheckoutOverwriteMode = c_int;
91pub const OSTREE_REPO_CHECKOUT_OVERWRITE_NONE: OstreeRepoCheckoutOverwriteMode = 0;
92pub const OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES: OstreeRepoCheckoutOverwriteMode = 1;
93pub const OSTREE_REPO_CHECKOUT_OVERWRITE_ADD_FILES: OstreeRepoCheckoutOverwriteMode = 2;
94pub const OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL: OstreeRepoCheckoutOverwriteMode = 3;
95
96pub type OstreeRepoCommitFilterResult = c_int;
97pub const OSTREE_REPO_COMMIT_FILTER_ALLOW: OstreeRepoCommitFilterResult = 0;
98pub const OSTREE_REPO_COMMIT_FILTER_SKIP: OstreeRepoCommitFilterResult = 1;
99
100pub type OstreeRepoCommitIterResult = c_int;
101pub const OSTREE_REPO_COMMIT_ITER_RESULT_ERROR: OstreeRepoCommitIterResult = 0;
102pub const OSTREE_REPO_COMMIT_ITER_RESULT_END: OstreeRepoCommitIterResult = 1;
103pub const OSTREE_REPO_COMMIT_ITER_RESULT_FILE: OstreeRepoCommitIterResult = 2;
104pub const OSTREE_REPO_COMMIT_ITER_RESULT_DIR: OstreeRepoCommitIterResult = 3;
105
106pub type OstreeRepoLockType = c_int;
107pub const OSTREE_REPO_LOCK_SHARED: OstreeRepoLockType = 0;
108pub const OSTREE_REPO_LOCK_EXCLUSIVE: OstreeRepoLockType = 1;
109
110pub type OstreeRepoMode = c_int;
111pub const OSTREE_REPO_MODE_BARE: OstreeRepoMode = 0;
112pub const OSTREE_REPO_MODE_ARCHIVE: OstreeRepoMode = 1;
113pub const OSTREE_REPO_MODE_ARCHIVE_Z2: OstreeRepoMode = 1;
114pub const OSTREE_REPO_MODE_BARE_USER: OstreeRepoMode = 2;
115pub const OSTREE_REPO_MODE_BARE_USER_ONLY: OstreeRepoMode = 3;
116pub const OSTREE_REPO_MODE_BARE_SPLIT_XATTRS: OstreeRepoMode = 4;
117
118pub type OstreeRepoRemoteChange = c_int;
119pub const OSTREE_REPO_REMOTE_CHANGE_ADD: OstreeRepoRemoteChange = 0;
120pub const OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS: OstreeRepoRemoteChange = 1;
121pub const OSTREE_REPO_REMOTE_CHANGE_DELETE: OstreeRepoRemoteChange = 2;
122pub const OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS: OstreeRepoRemoteChange = 3;
123pub const OSTREE_REPO_REMOTE_CHANGE_REPLACE: OstreeRepoRemoteChange = 4;
124
125pub type OstreeStaticDeltaGenerateOpt = c_int;
126pub const OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY: OstreeStaticDeltaGenerateOpt = 0;
127pub const OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR: OstreeStaticDeltaGenerateOpt = 1;
128
129pub type OstreeStaticDeltaIndexFlags = c_int;
130pub const OSTREE_STATIC_DELTA_INDEX_FLAGS_NONE: OstreeStaticDeltaIndexFlags = 0;
131
132pub const OSTREE_COMMIT_GVARIANT_STRING: &[u8] = b"(a{sv}aya(say)sstayay)\0";
134pub const OSTREE_COMMIT_META_KEY_ARCHITECTURE: &[u8] = b"ostree.architecture\0";
135pub const OSTREE_COMMIT_META_KEY_COLLECTION_BINDING: &[u8] = b"ostree.collection-binding\0";
136pub const OSTREE_COMMIT_META_KEY_ENDOFLIFE: &[u8] = b"ostree.endoflife\0";
137pub const OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE: &[u8] = b"ostree.endoflife-rebase\0";
138pub const OSTREE_COMMIT_META_KEY_REF_BINDING: &[u8] = b"ostree.ref-binding\0";
139pub const OSTREE_COMMIT_META_KEY_SOURCE_TITLE: &[u8] = b"ostree.source-title\0";
140pub const OSTREE_COMMIT_META_KEY_VERSION: &[u8] = b"version\0";
141pub const OSTREE_DIRMETA_GVARIANT_STRING: &[u8] = b"(uuua(ayay))\0";
142pub const OSTREE_FILEMETA_GVARIANT_STRING: &[u8] = b"(uuua(ayay))\0";
143pub const OSTREE_GPG_KEY_GVARIANT_STRING: &[u8] = b"(aa{sv}aa{sv}a{sv})\0";
144pub const OSTREE_MAX_METADATA_SIZE: c_int = 134217728;
145pub const OSTREE_MAX_METADATA_WARN_SIZE: c_int = 7340032;
146pub const OSTREE_METADATA_KEY_BOOTABLE: &[u8] = b"ostree.bootable\0";
147pub const OSTREE_METADATA_KEY_LINUX: &[u8] = b"ostree.linux\0";
148pub const OSTREE_META_KEY_DEPLOY_COLLECTION_ID: &[u8] = b"ostree.deploy-collection-id\0";
149pub const OSTREE_ORIGIN_TRANSIENT_GROUP: &[u8] = b"libostree-transient\0";
150pub const OSTREE_PATH_BOOTED: &[u8] = b"/run/ostree-booted\0";
151pub const OSTREE_REPO_METADATA_REF: &[u8] = b"ostree-metadata\0";
152pub const OSTREE_SHA256_DIGEST_LEN: c_int = 32;
153pub const OSTREE_SHA256_STRING_LEN: c_int = 64;
154pub const OSTREE_SIGN_NAME_ED25519: &[u8] = b"ed25519\0";
155pub const OSTREE_SIGN_NAME_SPKI: &[u8] = b"spki\0";
156pub const OSTREE_SUMMARY_GVARIANT_STRING: &[u8] = b"(a(s(taya{sv}))a{sv})\0";
157pub const OSTREE_SUMMARY_SIG_GVARIANT_STRING: &[u8] = b"a{sv}\0";
158pub const OSTREE_TIMESTAMP: c_int = 0;
159pub const OSTREE_TREE_GVARIANT_STRING: &[u8] = b"(a(say)a(sayay))\0";
160
161pub type OstreeChecksumFlags = c_uint;
163pub const OSTREE_CHECKSUM_FLAGS_NONE: OstreeChecksumFlags = 0;
164pub const OSTREE_CHECKSUM_FLAGS_IGNORE_XATTRS: OstreeChecksumFlags = 1;
165pub const OSTREE_CHECKSUM_FLAGS_CANONICAL_PERMISSIONS: OstreeChecksumFlags = 2;
166
167pub type OstreeDiffFlags = c_uint;
168pub const OSTREE_DIFF_FLAGS_NONE: OstreeDiffFlags = 0;
169pub const OSTREE_DIFF_FLAGS_IGNORE_XATTRS: OstreeDiffFlags = 1;
170
171pub type OstreeGpgSignatureFormatFlags = c_uint;
172pub const OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT: OstreeGpgSignatureFormatFlags = 0;
173
174pub type OstreeRepoCommitModifierFlags = c_uint;
175pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE: OstreeRepoCommitModifierFlags = 0;
176pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS: OstreeRepoCommitModifierFlags = 1;
177pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES: OstreeRepoCommitModifierFlags = 2;
178pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS: OstreeRepoCommitModifierFlags =
179 4;
180pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED: OstreeRepoCommitModifierFlags = 8;
181pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CONSUME: OstreeRepoCommitModifierFlags = 16;
182pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL: OstreeRepoCommitModifierFlags = 32;
183pub const OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SELINUX_LABEL_V1: OstreeRepoCommitModifierFlags = 64;
184
185pub type OstreeRepoCommitState = c_uint;
186pub const OSTREE_REPO_COMMIT_STATE_NORMAL: OstreeRepoCommitState = 0;
187pub const OSTREE_REPO_COMMIT_STATE_PARTIAL: OstreeRepoCommitState = 1;
188pub const OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL: OstreeRepoCommitState = 2;
189
190pub type OstreeRepoCommitTraverseFlags = c_uint;
191pub const OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE: OstreeRepoCommitTraverseFlags = 1;
192pub const OSTREE_REPO_COMMIT_TRAVERSE_FLAG_COMMIT_ONLY: OstreeRepoCommitTraverseFlags = 2;
193
194pub type OstreeRepoListObjectsFlags = c_uint;
195pub const OSTREE_REPO_LIST_OBJECTS_LOOSE: OstreeRepoListObjectsFlags = 1;
196pub const OSTREE_REPO_LIST_OBJECTS_PACKED: OstreeRepoListObjectsFlags = 2;
197pub const OSTREE_REPO_LIST_OBJECTS_ALL: OstreeRepoListObjectsFlags = 4;
198pub const OSTREE_REPO_LIST_OBJECTS_NO_PARENTS: OstreeRepoListObjectsFlags = 8;
199
200pub type OstreeRepoListRefsExtFlags = c_uint;
201pub const OSTREE_REPO_LIST_REFS_EXT_NONE: OstreeRepoListRefsExtFlags = 0;
202pub const OSTREE_REPO_LIST_REFS_EXT_ALIASES: OstreeRepoListRefsExtFlags = 1;
203pub const OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES: OstreeRepoListRefsExtFlags = 2;
204pub const OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_MIRRORS: OstreeRepoListRefsExtFlags = 4;
205
206pub type OstreeRepoPruneFlags = c_uint;
207pub const OSTREE_REPO_PRUNE_FLAGS_NONE: OstreeRepoPruneFlags = 0;
208pub const OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE: OstreeRepoPruneFlags = 1;
209pub const OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY: OstreeRepoPruneFlags = 2;
210pub const OSTREE_REPO_PRUNE_FLAGS_COMMIT_ONLY: OstreeRepoPruneFlags = 4;
211
212pub type OstreeRepoPullFlags = c_uint;
213pub const OSTREE_REPO_PULL_FLAGS_NONE: OstreeRepoPullFlags = 0;
214pub const OSTREE_REPO_PULL_FLAGS_MIRROR: OstreeRepoPullFlags = 1;
215pub const OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY: OstreeRepoPullFlags = 2;
216pub const OSTREE_REPO_PULL_FLAGS_UNTRUSTED: OstreeRepoPullFlags = 4;
217pub const OSTREE_REPO_PULL_FLAGS_BAREUSERONLY_FILES: OstreeRepoPullFlags = 8;
218pub const OSTREE_REPO_PULL_FLAGS_TRUSTED_HTTP: OstreeRepoPullFlags = 16;
219
220pub type OstreeRepoResolveRevExtFlags = c_uint;
221pub const OSTREE_REPO_RESOLVE_REV_EXT_NONE: OstreeRepoResolveRevExtFlags = 0;
222pub const OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY: OstreeRepoResolveRevExtFlags = 1;
223
224pub type OstreeRepoVerifyFlags = c_uint;
225pub const OSTREE_REPO_VERIFY_FLAGS_NONE: OstreeRepoVerifyFlags = 0;
226pub const OSTREE_REPO_VERIFY_FLAGS_NO_GPG: OstreeRepoVerifyFlags = 1;
227pub const OSTREE_REPO_VERIFY_FLAGS_NO_SIGNAPI: OstreeRepoVerifyFlags = 2;
228
229pub type OstreeSePolicyRestoreconFlags = c_uint;
230pub const OSTREE_SEPOLICY_RESTORECON_FLAGS_NONE: OstreeSePolicyRestoreconFlags = 0;
231pub const OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL: OstreeSePolicyRestoreconFlags = 1;
232pub const OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING: OstreeSePolicyRestoreconFlags = 2;
233
234pub type OstreeSysrootSimpleWriteDeploymentFlags = c_uint;
235pub const OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE:
236 OstreeSysrootSimpleWriteDeploymentFlags = 0;
237pub const OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN:
238 OstreeSysrootSimpleWriteDeploymentFlags = 1;
239pub const OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT:
240 OstreeSysrootSimpleWriteDeploymentFlags = 2;
241pub const OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN:
242 OstreeSysrootSimpleWriteDeploymentFlags = 4;
243pub const OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING:
244 OstreeSysrootSimpleWriteDeploymentFlags = 8;
245pub const OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK:
246 OstreeSysrootSimpleWriteDeploymentFlags = 16;
247
248pub type OstreeSysrootUpgraderFlags = c_uint;
249pub const OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED: OstreeSysrootUpgraderFlags = 2;
250pub const OSTREE_SYSROOT_UPGRADER_FLAGS_STAGE: OstreeSysrootUpgraderFlags = 4;
251pub const OSTREE_SYSROOT_UPGRADER_FLAGS_KEXEC: OstreeSysrootUpgraderFlags = 8;
252
253pub type OstreeSysrootUpgraderPullFlags = c_uint;
254pub const OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_NONE: OstreeSysrootUpgraderPullFlags = 0;
255pub const OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER: OstreeSysrootUpgraderPullFlags = 1;
256pub const OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC: OstreeSysrootUpgraderPullFlags = 2;
257
258pub type OstreeRepoCheckoutFilter = Option<
260 unsafe extern "C" fn(
261 *mut OstreeRepo,
262 *const c_char,
263 *mut stat,
264 gpointer,
265 ) -> OstreeRepoCheckoutFilterResult,
266>;
267pub type OstreeRepoCommitFilter = Option<
268 unsafe extern "C" fn(
269 *mut OstreeRepo,
270 *const c_char,
271 *mut gio::GFileInfo,
272 gpointer,
273 ) -> OstreeRepoCommitFilterResult,
274>;
275pub type OstreeRepoCommitModifierXattrCallback = Option<
276 unsafe extern "C" fn(
277 *mut OstreeRepo,
278 *const c_char,
279 *mut gio::GFileInfo,
280 gpointer,
281 ) -> *mut glib::GVariant,
282>;
283pub type OstreeRepoImportArchiveTranslatePathname = Option<
284 unsafe extern "C" fn(*mut OstreeRepo, *const stat, *const c_char, gpointer) -> *mut c_char,
285>;
286
287#[derive(Copy, Clone)]
289#[repr(C)]
290pub struct OstreeAsyncProgressClass {
291 pub parent_class: gobject::GObjectClass,
292 pub changed: Option<unsafe extern "C" fn(*mut OstreeAsyncProgress, gpointer)>,
293}
294
295impl ::std::fmt::Debug for OstreeAsyncProgressClass {
296 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
297 f.debug_struct(&format!("OstreeAsyncProgressClass @ {self:p}"))
298 .field("parent_class", &self.parent_class)
299 .field("changed", &self.changed)
300 .finish()
301 }
302}
303
304#[derive(Copy, Clone)]
305#[repr(C)]
306pub struct OstreeBlobReaderInterface {
307 pub g_iface: gobject::GTypeInterface,
308 pub read_blob: Option<
309 unsafe extern "C" fn(
310 *mut OstreeBlobReader,
311 *mut gio::GCancellable,
312 *mut *mut glib::GError,
313 ) -> *mut glib::GBytes,
314 >,
315}
316
317impl ::std::fmt::Debug for OstreeBlobReaderInterface {
318 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
319 f.debug_struct(&format!("OstreeBlobReaderInterface @ {self:p}"))
320 .field("g_iface", &self.g_iface)
321 .field("read_blob", &self.read_blob)
322 .finish()
323 }
324}
325
326#[derive(Copy, Clone)]
327#[repr(C)]
328pub struct OstreeCollectionRef {
329 pub collection_id: *mut c_char,
330 pub ref_name: *mut c_char,
331}
332
333impl ::std::fmt::Debug for OstreeCollectionRef {
334 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
335 f.debug_struct(&format!("OstreeCollectionRef @ {self:p}"))
336 .field("collection_id", &self.collection_id)
337 .field("ref_name", &self.ref_name)
338 .finish()
339 }
340}
341
342#[derive(Copy, Clone)]
343#[repr(C)]
344pub struct OstreeCommitSizesEntry {
345 pub checksum: *mut c_char,
346 pub objtype: OstreeObjectType,
347 pub unpacked: u64,
348 pub archived: u64,
349}
350
351impl ::std::fmt::Debug for OstreeCommitSizesEntry {
352 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
353 f.debug_struct(&format!("OstreeCommitSizesEntry @ {self:p}"))
354 .field("checksum", &self.checksum)
355 .field("objtype", &self.objtype)
356 .field("unpacked", &self.unpacked)
357 .field("archived", &self.archived)
358 .finish()
359 }
360}
361
362#[derive(Copy, Clone)]
363#[repr(C)]
364pub struct OstreeContentWriterClass {
365 pub parent_class: gio::GOutputStreamClass,
366}
367
368impl ::std::fmt::Debug for OstreeContentWriterClass {
369 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
370 f.debug_struct(&format!("OstreeContentWriterClass @ {self:p}"))
371 .field("parent_class", &self.parent_class)
372 .finish()
373 }
374}
375
376#[derive(Copy, Clone)]
377#[repr(C)]
378pub struct OstreeDiffDirsOptions {
379 pub owner_uid: c_int,
380 pub owner_gid: c_int,
381 pub devino_to_csum_cache: *mut OstreeRepoDevInoCache,
382 pub unused_bools: [gboolean; 7],
383 pub unused_ints: [c_int; 6],
384 pub unused_ptrs: [gpointer; 7],
385}
386
387impl ::std::fmt::Debug for OstreeDiffDirsOptions {
388 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
389 f.debug_struct(&format!("OstreeDiffDirsOptions @ {self:p}"))
390 .field("owner_uid", &self.owner_uid)
391 .field("owner_gid", &self.owner_gid)
392 .field("devino_to_csum_cache", &self.devino_to_csum_cache)
393 .field("unused_bools", &self.unused_bools)
394 .field("unused_ints", &self.unused_ints)
395 .field("unused_ptrs", &self.unused_ptrs)
396 .finish()
397 }
398}
399
400#[derive(Copy, Clone)]
401#[repr(C)]
402pub struct OstreeDiffItem {
403 pub refcount: c_int,
404 pub src: *mut gio::GFile,
405 pub target: *mut gio::GFile,
406 pub src_info: *mut gio::GFileInfo,
407 pub target_info: *mut gio::GFileInfo,
408 pub src_checksum: *mut c_char,
409 pub target_checksum: *mut c_char,
410}
411
412impl ::std::fmt::Debug for OstreeDiffItem {
413 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
414 f.debug_struct(&format!("OstreeDiffItem @ {self:p}"))
415 .field("refcount", &self.refcount)
416 .field("src", &self.src)
417 .field("target", &self.target)
418 .field("src_info", &self.src_info)
419 .field("target_info", &self.target_info)
420 .field("src_checksum", &self.src_checksum)
421 .field("target_checksum", &self.target_checksum)
422 .finish()
423 }
424}
425
426#[repr(C)]
427#[allow(dead_code)]
428pub struct _OstreeKernelArgs {
429 _data: [u8; 0],
430 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
431}
432
433pub type OstreeKernelArgs = _OstreeKernelArgs;
434
435#[derive(Copy, Clone)]
436#[repr(C)]
437pub struct OstreeMutableTreeClass {
438 pub parent_class: gobject::GObjectClass,
439}
440
441impl ::std::fmt::Debug for OstreeMutableTreeClass {
442 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
443 f.debug_struct(&format!("OstreeMutableTreeClass @ {self:p}"))
444 .field("parent_class", &self.parent_class)
445 .finish()
446 }
447}
448
449#[derive(Copy, Clone)]
450#[repr(C)]
451pub struct OstreeMutableTreeIter {
452 pub in_files: gboolean,
453 pub iter: glib::GHashTableIter,
454}
455
456impl ::std::fmt::Debug for OstreeMutableTreeIter {
457 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
458 f.debug_struct(&format!("OstreeMutableTreeIter @ {self:p}"))
459 .field("in_files", &self.in_files)
460 .field("iter", &self.iter)
461 .finish()
462 }
463}
464
465#[repr(C)]
466#[allow(dead_code)]
467pub struct OstreeRemote {
468 _data: [u8; 0],
469 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
470}
471
472impl ::std::fmt::Debug for OstreeRemote {
473 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
474 f.debug_struct(&format!("OstreeRemote @ {self:p}")).finish()
475 }
476}
477
478#[derive(Copy, Clone)]
479#[repr(C)]
480pub struct OstreeRepoCheckoutAtOptions {
481 pub mode: OstreeRepoCheckoutMode,
482 pub overwrite_mode: OstreeRepoCheckoutOverwriteMode,
483 pub enable_uncompressed_cache: gboolean,
484 pub enable_fsync: gboolean,
485 pub process_whiteouts: gboolean,
486 pub no_copy_fallback: gboolean,
487 pub force_copy: gboolean,
488 pub bareuseronly_dirs: gboolean,
489 pub force_copy_zerosized: gboolean,
490 pub process_passthrough_whiteouts: gboolean,
491 pub unused_bools: [gboolean; 3],
492 pub subpath: *const c_char,
493 pub devino_to_csum_cache: *mut OstreeRepoDevInoCache,
494 pub unused_ints: [c_int; 6],
495 pub unused_ptrs: [gpointer; 3],
496 pub filter: OstreeRepoCheckoutFilter,
497 pub filter_user_data: gpointer,
498 pub sepolicy: *mut OstreeSePolicy,
499 pub sepolicy_prefix: *const c_char,
500}
501
502impl ::std::fmt::Debug for OstreeRepoCheckoutAtOptions {
503 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
504 f.debug_struct(&format!("OstreeRepoCheckoutAtOptions @ {self:p}"))
505 .field("mode", &self.mode)
506 .field("overwrite_mode", &self.overwrite_mode)
507 .field("enable_uncompressed_cache", &self.enable_uncompressed_cache)
508 .field("enable_fsync", &self.enable_fsync)
509 .field("process_whiteouts", &self.process_whiteouts)
510 .field("no_copy_fallback", &self.no_copy_fallback)
511 .field("force_copy", &self.force_copy)
512 .field("bareuseronly_dirs", &self.bareuseronly_dirs)
513 .field("force_copy_zerosized", &self.force_copy_zerosized)
514 .field(
515 "process_passthrough_whiteouts",
516 &self.process_passthrough_whiteouts,
517 )
518 .field("unused_bools", &self.unused_bools)
519 .field("subpath", &self.subpath)
520 .field("devino_to_csum_cache", &self.devino_to_csum_cache)
521 .field("unused_ints", &self.unused_ints)
522 .field("unused_ptrs", &self.unused_ptrs)
523 .field("filter", &self.filter)
524 .field("filter_user_data", &self.filter_user_data)
525 .field("sepolicy", &self.sepolicy)
526 .field("sepolicy_prefix", &self.sepolicy_prefix)
527 .finish()
528 }
529}
530
531#[repr(C)]
532#[allow(dead_code)]
533pub struct OstreeRepoCheckoutOptions {
534 pub mode: OstreeRepoCheckoutMode,
535 pub overwrite_mode: OstreeRepoCheckoutOverwriteMode,
536 pub enable_uncompressed_cache: c_uint,
537 _truncated_record_marker: c_void,
538 }
540
541impl ::std::fmt::Debug for OstreeRepoCheckoutOptions {
542 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
543 f.debug_struct(&format!("OstreeRepoCheckoutOptions @ {self:p}"))
544 .field("mode", &self.mode)
545 .field("overwrite_mode", &self.overwrite_mode)
546 .field("enable_uncompressed_cache", &self.enable_uncompressed_cache)
547 .finish()
548 }
549}
550
551#[repr(C)]
552#[allow(dead_code)]
553pub struct OstreeRepoCommitModifier {
554 _data: [u8; 0],
555 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
556}
557
558impl ::std::fmt::Debug for OstreeRepoCommitModifier {
559 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
560 f.debug_struct(&format!("OstreeRepoCommitModifier @ {self:p}"))
561 .finish()
562 }
563}
564
565#[derive(Copy, Clone)]
566#[repr(C)]
567pub struct OstreeRepoCommitTraverseIter {
568 pub initialized: gboolean,
569 pub dummy: [gpointer; 10],
570 pub dummy_checksum_data: [c_char; 130],
571}
572
573impl ::std::fmt::Debug for OstreeRepoCommitTraverseIter {
574 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
575 f.debug_struct(&format!("OstreeRepoCommitTraverseIter @ {self:p}"))
576 .field("initialized", &self.initialized)
577 .field("dummy", &self.dummy)
578 .finish()
579 }
580}
581
582#[repr(C)]
583#[allow(dead_code)]
584pub struct OstreeRepoDevInoCache {
585 _data: [u8; 0],
586 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
587}
588
589impl ::std::fmt::Debug for OstreeRepoDevInoCache {
590 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
591 f.debug_struct(&format!("OstreeRepoDevInoCache @ {self:p}"))
592 .finish()
593 }
594}
595
596#[repr(C)]
597#[allow(dead_code)]
598pub struct OstreeRepoExportArchiveOptions {
599 pub disable_xattrs: c_uint,
600 _truncated_record_marker: c_void,
601 }
603
604impl ::std::fmt::Debug for OstreeRepoExportArchiveOptions {
605 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
606 f.debug_struct(&format!("OstreeRepoExportArchiveOptions @ {self:p}"))
607 .field("disable_xattrs", &self.disable_xattrs)
608 .finish()
609 }
610}
611
612#[derive(Copy, Clone)]
613#[repr(C)]
614pub struct OstreeRepoFileClass {
615 pub parent_class: gobject::GObjectClass,
616}
617
618impl ::std::fmt::Debug for OstreeRepoFileClass {
619 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
620 f.debug_struct(&format!("OstreeRepoFileClass @ {self:p}"))
621 .field("parent_class", &self.parent_class)
622 .finish()
623 }
624}
625
626#[derive(Copy, Clone)]
627#[repr(C)]
628pub struct OstreeRepoFinderAvahiClass {
629 pub parent_class: gobject::GObjectClass,
630}
631
632impl ::std::fmt::Debug for OstreeRepoFinderAvahiClass {
633 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
634 f.debug_struct(&format!("OstreeRepoFinderAvahiClass @ {self:p}"))
635 .field("parent_class", &self.parent_class)
636 .finish()
637 }
638}
639
640#[derive(Copy, Clone)]
641#[repr(C)]
642pub struct OstreeRepoFinderConfigClass {
643 pub parent_class: gobject::GObjectClass,
644}
645
646impl ::std::fmt::Debug for OstreeRepoFinderConfigClass {
647 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
648 f.debug_struct(&format!("OstreeRepoFinderConfigClass @ {self:p}"))
649 .field("parent_class", &self.parent_class)
650 .finish()
651 }
652}
653
654#[derive(Copy, Clone)]
655#[repr(C)]
656pub struct OstreeRepoFinderInterface {
657 pub g_iface: gobject::GTypeInterface,
658 pub resolve_async: Option<
659 unsafe extern "C" fn(
660 *mut OstreeRepoFinder,
661 *const *const OstreeCollectionRef,
662 *mut OstreeRepo,
663 *mut gio::GCancellable,
664 gio::GAsyncReadyCallback,
665 gpointer,
666 ),
667 >,
668 pub resolve_finish: Option<
669 unsafe extern "C" fn(
670 *mut OstreeRepoFinder,
671 *mut gio::GAsyncResult,
672 *mut *mut glib::GError,
673 ) -> *mut glib::GPtrArray,
674 >,
675}
676
677impl ::std::fmt::Debug for OstreeRepoFinderInterface {
678 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
679 f.debug_struct(&format!("OstreeRepoFinderInterface @ {self:p}"))
680 .field("g_iface", &self.g_iface)
681 .field("resolve_async", &self.resolve_async)
682 .field("resolve_finish", &self.resolve_finish)
683 .finish()
684 }
685}
686
687#[derive(Copy, Clone)]
688#[repr(C)]
689pub struct OstreeRepoFinderMountClass {
690 pub parent_class: gobject::GObjectClass,
691}
692
693impl ::std::fmt::Debug for OstreeRepoFinderMountClass {
694 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
695 f.debug_struct(&format!("OstreeRepoFinderMountClass @ {self:p}"))
696 .field("parent_class", &self.parent_class)
697 .finish()
698 }
699}
700
701#[derive(Copy, Clone)]
702#[repr(C)]
703pub struct OstreeRepoFinderOverrideClass {
704 pub parent_class: gobject::GObjectClass,
705}
706
707impl ::std::fmt::Debug for OstreeRepoFinderOverrideClass {
708 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
709 f.debug_struct(&format!("OstreeRepoFinderOverrideClass @ {self:p}"))
710 .field("parent_class", &self.parent_class)
711 .finish()
712 }
713}
714
715#[derive(Copy, Clone)]
716#[repr(C)]
717pub struct OstreeRepoFinderResult {
718 pub remote: *mut OstreeRemote,
719 pub finder: *mut OstreeRepoFinder,
720 pub priority: c_int,
721 pub ref_to_checksum: *mut glib::GHashTable,
722 pub summary_last_modified: u64,
723 pub ref_to_timestamp: *mut glib::GHashTable,
724 pub padding: [gpointer; 3],
725}
726
727impl ::std::fmt::Debug for OstreeRepoFinderResult {
728 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
729 f.debug_struct(&format!("OstreeRepoFinderResult @ {self:p}"))
730 .field("remote", &self.remote)
731 .field("finder", &self.finder)
732 .field("priority", &self.priority)
733 .field("ref_to_checksum", &self.ref_to_checksum)
734 .field("summary_last_modified", &self.summary_last_modified)
735 .field("ref_to_timestamp", &self.ref_to_timestamp)
736 .finish()
737 }
738}
739
740#[repr(C)]
741#[allow(dead_code)]
742pub struct OstreeRepoImportArchiveOptions {
743 pub ignore_unsupported_content: c_uint,
744 _truncated_record_marker: c_void,
745 }
747
748impl ::std::fmt::Debug for OstreeRepoImportArchiveOptions {
749 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
750 f.debug_struct(&format!("OstreeRepoImportArchiveOptions @ {self:p}"))
751 .field(
752 "ignore_unsupported_content",
753 &self.ignore_unsupported_content,
754 )
755 .finish()
756 }
757}
758
759#[derive(Copy, Clone)]
760#[repr(C)]
761pub struct OstreeRepoPruneOptions {
762 pub flags: OstreeRepoPruneFlags,
763 pub reachable: *mut glib::GHashTable,
764 pub unused_bools: [gboolean; 6],
765 pub unused_ints: [c_int; 6],
766 pub unused_ptrs: [gpointer; 7],
767}
768
769impl ::std::fmt::Debug for OstreeRepoPruneOptions {
770 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
771 f.debug_struct(&format!("OstreeRepoPruneOptions @ {self:p}"))
772 .field("flags", &self.flags)
773 .field("reachable", &self.reachable)
774 .field("unused_bools", &self.unused_bools)
775 .field("unused_ints", &self.unused_ints)
776 .field("unused_ptrs", &self.unused_ptrs)
777 .finish()
778 }
779}
780
781#[derive(Copy, Clone)]
782#[repr(C)]
783pub struct OstreeRepoTransactionStats {
784 pub metadata_objects_total: c_uint,
785 pub metadata_objects_written: c_uint,
786 pub content_objects_total: c_uint,
787 pub content_objects_written: c_uint,
788 pub content_bytes_written: u64,
789 pub devino_cache_hits: c_uint,
790 pub padding1: c_uint,
791 pub padding2: u64,
792 pub padding3: u64,
793 pub padding4: u64,
794}
795
796impl ::std::fmt::Debug for OstreeRepoTransactionStats {
797 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
798 f.debug_struct(&format!("OstreeRepoTransactionStats @ {self:p}"))
799 .field("metadata_objects_total", &self.metadata_objects_total)
800 .field("metadata_objects_written", &self.metadata_objects_written)
801 .field("content_objects_total", &self.content_objects_total)
802 .field("content_objects_written", &self.content_objects_written)
803 .field("content_bytes_written", &self.content_bytes_written)
804 .field("devino_cache_hits", &self.devino_cache_hits)
805 .field("padding1", &self.padding1)
806 .field("padding2", &self.padding2)
807 .field("padding3", &self.padding3)
808 .field("padding4", &self.padding4)
809 .finish()
810 }
811}
812
813#[derive(Copy, Clone)]
814#[repr(C)]
815pub struct OstreeSignInterface {
816 pub g_iface: gobject::GTypeInterface,
817 pub get_name: Option<unsafe extern "C" fn(*mut OstreeSign) -> *const c_char>,
818 pub data: Option<
819 unsafe extern "C" fn(
820 *mut OstreeSign,
821 *mut glib::GBytes,
822 *mut *mut glib::GBytes,
823 *mut gio::GCancellable,
824 *mut *mut glib::GError,
825 ) -> gboolean,
826 >,
827 pub data_verify: Option<
828 unsafe extern "C" fn(
829 *mut OstreeSign,
830 *mut glib::GBytes,
831 *mut glib::GVariant,
832 *mut *mut c_char,
833 *mut *mut glib::GError,
834 ) -> gboolean,
835 >,
836 pub metadata_key: Option<unsafe extern "C" fn(*mut OstreeSign) -> *const c_char>,
837 pub metadata_format: Option<unsafe extern "C" fn(*mut OstreeSign) -> *const c_char>,
838 pub clear_keys:
839 Option<unsafe extern "C" fn(*mut OstreeSign, *mut *mut glib::GError) -> gboolean>,
840 pub set_sk: Option<
841 unsafe extern "C" fn(
842 *mut OstreeSign,
843 *mut glib::GVariant,
844 *mut *mut glib::GError,
845 ) -> gboolean,
846 >,
847 pub set_pk: Option<
848 unsafe extern "C" fn(
849 *mut OstreeSign,
850 *mut glib::GVariant,
851 *mut *mut glib::GError,
852 ) -> gboolean,
853 >,
854 pub add_pk: Option<
855 unsafe extern "C" fn(
856 *mut OstreeSign,
857 *mut glib::GVariant,
858 *mut *mut glib::GError,
859 ) -> gboolean,
860 >,
861 pub load_pk: Option<
862 unsafe extern "C" fn(
863 *mut OstreeSign,
864 *mut glib::GVariant,
865 *mut *mut glib::GError,
866 ) -> gboolean,
867 >,
868}
869
870impl ::std::fmt::Debug for OstreeSignInterface {
871 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
872 f.debug_struct(&format!("OstreeSignInterface @ {self:p}"))
873 .field("g_iface", &self.g_iface)
874 .field("get_name", &self.get_name)
875 .field("data", &self.data)
876 .field("data_verify", &self.data_verify)
877 .field("metadata_key", &self.metadata_key)
878 .field("metadata_format", &self.metadata_format)
879 .field("clear_keys", &self.clear_keys)
880 .field("set_sk", &self.set_sk)
881 .field("set_pk", &self.set_pk)
882 .field("add_pk", &self.add_pk)
883 .field("load_pk", &self.load_pk)
884 .finish()
885 }
886}
887
888#[derive(Copy, Clone)]
889#[repr(C)]
890pub struct OstreeSysrootDeployTreeOpts {
891 pub locked: gboolean,
892 pub unused_bools: [gboolean; 7],
893 pub unused_ints: [c_int; 8],
894 pub override_kernel_argv: *mut *mut c_char,
895 pub overlay_initrds: *mut *mut c_char,
896 pub unused_ptrs: [gpointer; 6],
897}
898
899impl ::std::fmt::Debug for OstreeSysrootDeployTreeOpts {
900 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
901 f.debug_struct(&format!("OstreeSysrootDeployTreeOpts @ {self:p}"))
902 .field("locked", &self.locked)
903 .field("unused_bools", &self.unused_bools)
904 .field("unused_ints", &self.unused_ints)
905 .field("override_kernel_argv", &self.override_kernel_argv)
906 .field("overlay_initrds", &self.overlay_initrds)
907 .field("unused_ptrs", &self.unused_ptrs)
908 .finish()
909 }
910}
911
912#[derive(Copy, Clone)]
913#[repr(C)]
914pub struct OstreeSysrootWriteDeploymentsOpts {
915 pub do_postclean: gboolean,
916 pub disable_auto_early_prune: gboolean,
917 pub unused_bools: [gboolean; 7],
918 pub unused_ints: [c_int; 7],
919 pub unused_ptrs: [gpointer; 7],
920}
921
922impl ::std::fmt::Debug for OstreeSysrootWriteDeploymentsOpts {
923 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
924 f.debug_struct(&format!("OstreeSysrootWriteDeploymentsOpts @ {self:p}"))
925 .field("do_postclean", &self.do_postclean)
926 .field("disable_auto_early_prune", &self.disable_auto_early_prune)
927 .field("unused_bools", &self.unused_bools)
928 .field("unused_ints", &self.unused_ints)
929 .field("unused_ptrs", &self.unused_ptrs)
930 .finish()
931 }
932}
933
934#[repr(C)]
936#[allow(dead_code)]
937pub struct OstreeAsyncProgress {
938 _data: [u8; 0],
939 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
940}
941
942impl ::std::fmt::Debug for OstreeAsyncProgress {
943 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
944 f.debug_struct(&format!("OstreeAsyncProgress @ {self:p}"))
945 .finish()
946 }
947}
948
949#[repr(C)]
950#[allow(dead_code)]
951pub struct OstreeBootconfigParser {
952 _data: [u8; 0],
953 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
954}
955
956impl ::std::fmt::Debug for OstreeBootconfigParser {
957 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
958 f.debug_struct(&format!("OstreeBootconfigParser @ {self:p}"))
959 .finish()
960 }
961}
962
963#[repr(C)]
964#[allow(dead_code)]
965pub struct OstreeContentWriter {
966 _data: [u8; 0],
967 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
968}
969
970impl ::std::fmt::Debug for OstreeContentWriter {
971 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
972 f.debug_struct(&format!("OstreeContentWriter @ {self:p}"))
973 .finish()
974 }
975}
976
977#[repr(C)]
978#[allow(dead_code)]
979pub struct OstreeDeployment {
980 _data: [u8; 0],
981 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
982}
983
984impl ::std::fmt::Debug for OstreeDeployment {
985 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
986 f.debug_struct(&format!("OstreeDeployment @ {self:p}"))
987 .finish()
988 }
989}
990
991#[repr(C)]
992#[allow(dead_code)]
993pub struct OstreeGpgVerifyResult {
994 _data: [u8; 0],
995 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
996}
997
998impl ::std::fmt::Debug for OstreeGpgVerifyResult {
999 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1000 f.debug_struct(&format!("OstreeGpgVerifyResult @ {self:p}"))
1001 .finish()
1002 }
1003}
1004
1005#[repr(C)]
1006#[allow(dead_code)]
1007pub struct OstreeMutableTree {
1008 _data: [u8; 0],
1009 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1010}
1011
1012impl ::std::fmt::Debug for OstreeMutableTree {
1013 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1014 f.debug_struct(&format!("OstreeMutableTree @ {self:p}"))
1015 .finish()
1016 }
1017}
1018
1019#[repr(C)]
1020#[allow(dead_code)]
1021pub struct OstreeRepo {
1022 _data: [u8; 0],
1023 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1024}
1025
1026impl ::std::fmt::Debug for OstreeRepo {
1027 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1028 f.debug_struct(&format!("OstreeRepo @ {self:p}")).finish()
1029 }
1030}
1031
1032#[repr(C)]
1033#[allow(dead_code)]
1034pub struct OstreeRepoFile {
1035 _data: [u8; 0],
1036 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1037}
1038
1039impl ::std::fmt::Debug for OstreeRepoFile {
1040 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1041 f.debug_struct(&format!("OstreeRepoFile @ {self:p}"))
1042 .finish()
1043 }
1044}
1045
1046#[repr(C)]
1047#[allow(dead_code)]
1048pub struct OstreeRepoFinderAvahi {
1049 _data: [u8; 0],
1050 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1051}
1052
1053impl ::std::fmt::Debug for OstreeRepoFinderAvahi {
1054 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1055 f.debug_struct(&format!("OstreeRepoFinderAvahi @ {self:p}"))
1056 .finish()
1057 }
1058}
1059
1060#[repr(C)]
1061#[allow(dead_code)]
1062pub struct OstreeRepoFinderConfig {
1063 _data: [u8; 0],
1064 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1065}
1066
1067impl ::std::fmt::Debug for OstreeRepoFinderConfig {
1068 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1069 f.debug_struct(&format!("OstreeRepoFinderConfig @ {self:p}"))
1070 .finish()
1071 }
1072}
1073
1074#[repr(C)]
1075#[allow(dead_code)]
1076pub struct OstreeRepoFinderMount {
1077 _data: [u8; 0],
1078 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1079}
1080
1081impl ::std::fmt::Debug for OstreeRepoFinderMount {
1082 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1083 f.debug_struct(&format!("OstreeRepoFinderMount @ {self:p}"))
1084 .finish()
1085 }
1086}
1087
1088#[repr(C)]
1089#[allow(dead_code)]
1090pub struct OstreeRepoFinderOverride {
1091 _data: [u8; 0],
1092 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1093}
1094
1095impl ::std::fmt::Debug for OstreeRepoFinderOverride {
1096 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1097 f.debug_struct(&format!("OstreeRepoFinderOverride @ {self:p}"))
1098 .finish()
1099 }
1100}
1101
1102#[repr(C)]
1103#[allow(dead_code)]
1104pub struct OstreeSePolicy {
1105 _data: [u8; 0],
1106 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1107}
1108
1109impl ::std::fmt::Debug for OstreeSePolicy {
1110 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1111 f.debug_struct(&format!("OstreeSePolicy @ {self:p}"))
1112 .finish()
1113 }
1114}
1115
1116#[repr(C)]
1117#[allow(dead_code)]
1118pub struct OstreeSysroot {
1119 _data: [u8; 0],
1120 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1121}
1122
1123impl ::std::fmt::Debug for OstreeSysroot {
1124 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1125 f.debug_struct(&format!("OstreeSysroot @ {self:p}"))
1126 .finish()
1127 }
1128}
1129
1130#[repr(C)]
1131#[allow(dead_code)]
1132pub struct OstreeSysrootUpgrader {
1133 _data: [u8; 0],
1134 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1135}
1136
1137impl ::std::fmt::Debug for OstreeSysrootUpgrader {
1138 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1139 f.debug_struct(&format!("OstreeSysrootUpgrader @ {self:p}"))
1140 .finish()
1141 }
1142}
1143
1144#[repr(C)]
1146#[allow(dead_code)]
1147pub struct OstreeBlobReader {
1148 _data: [u8; 0],
1149 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1150}
1151
1152impl ::std::fmt::Debug for OstreeBlobReader {
1153 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1154 write!(f, "OstreeBlobReader @ {self:p}")
1155 }
1156}
1157
1158#[repr(C)]
1159#[allow(dead_code)]
1160pub struct OstreeRepoFinder {
1161 _data: [u8; 0],
1162 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1163}
1164
1165impl ::std::fmt::Debug for OstreeRepoFinder {
1166 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1167 write!(f, "OstreeRepoFinder @ {self:p}")
1168 }
1169}
1170
1171#[repr(C)]
1172#[allow(dead_code)]
1173pub struct OstreeSign {
1174 _data: [u8; 0],
1175 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1176}
1177
1178impl ::std::fmt::Debug for OstreeSign {
1179 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1180 write!(f, "OstreeSign @ {self:p}")
1181 }
1182}
1183
1184extern "C" {
1185
1186 pub fn ostree_sysroot_upgrader_flags_get_type() -> GType;
1190
1191 #[cfg(feature = "v2018_6")]
1195 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1196 pub fn ostree_collection_ref_get_type() -> GType;
1197 #[cfg(feature = "v2018_6")]
1198 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1199 pub fn ostree_collection_ref_new(
1200 collection_id: *const c_char,
1201 ref_name: *const c_char,
1202 ) -> *mut OstreeCollectionRef;
1203 #[cfg(feature = "v2018_6")]
1204 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1205 pub fn ostree_collection_ref_dup(ref_: *const OstreeCollectionRef) -> *mut OstreeCollectionRef;
1206 #[cfg(feature = "v2018_6")]
1207 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1208 pub fn ostree_collection_ref_equal(ref1: gconstpointer, ref2: gconstpointer) -> gboolean;
1209 #[cfg(feature = "v2018_6")]
1210 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1211 pub fn ostree_collection_ref_free(ref_: *mut OstreeCollectionRef);
1212 #[cfg(feature = "v2018_6")]
1213 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1214 pub fn ostree_collection_ref_hash(ref_: gconstpointer) -> c_uint;
1215 #[cfg(feature = "v2018_6")]
1216 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1217 pub fn ostree_collection_ref_dupv(
1218 refs: *const *const OstreeCollectionRef,
1219 ) -> *mut *mut OstreeCollectionRef;
1220 #[cfg(feature = "v2018_6")]
1221 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1222 pub fn ostree_collection_ref_freev(refs: *mut *mut OstreeCollectionRef);
1223
1224 #[cfg(feature = "v2020_1")]
1228 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
1229 pub fn ostree_commit_sizes_entry_get_type() -> GType;
1230 #[cfg(feature = "v2020_1")]
1231 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
1232 pub fn ostree_commit_sizes_entry_new(
1233 checksum: *const c_char,
1234 objtype: OstreeObjectType,
1235 unpacked: u64,
1236 archived: u64,
1237 ) -> *mut OstreeCommitSizesEntry;
1238 #[cfg(feature = "v2020_1")]
1239 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
1240 pub fn ostree_commit_sizes_entry_copy(
1241 entry: *const OstreeCommitSizesEntry,
1242 ) -> *mut OstreeCommitSizesEntry;
1243 #[cfg(feature = "v2020_1")]
1244 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
1245 pub fn ostree_commit_sizes_entry_free(entry: *mut OstreeCommitSizesEntry);
1246
1247 pub fn ostree_diff_item_get_type() -> GType;
1251 pub fn ostree_diff_item_ref(diffitem: *mut OstreeDiffItem) -> *mut OstreeDiffItem;
1252 pub fn ostree_diff_item_unref(diffitem: *mut OstreeDiffItem);
1253
1254 #[cfg(feature = "v2019_3")]
1258 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1259 pub fn ostree_kernel_args_append(kargs: *mut OstreeKernelArgs, arg: *const c_char);
1260 #[cfg(feature = "v2019_3")]
1261 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1262 pub fn ostree_kernel_args_append_argv(kargs: *mut OstreeKernelArgs, argv: *mut *mut c_char);
1263 #[cfg(feature = "v2019_3")]
1264 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1265 pub fn ostree_kernel_args_append_argv_filtered(
1266 kargs: *mut OstreeKernelArgs,
1267 argv: *mut *mut c_char,
1268 prefixes: *mut *mut c_char,
1269 );
1270 #[cfg(feature = "v2022_5")]
1271 #[cfg_attr(docsrs, doc(cfg(feature = "v2022_5")))]
1272 pub fn ostree_kernel_args_append_if_missing(kargs: *mut OstreeKernelArgs, arg: *const c_char);
1273 #[cfg(feature = "v2019_3")]
1274 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1275 pub fn ostree_kernel_args_append_proc_cmdline(
1276 kargs: *mut OstreeKernelArgs,
1277 cancellable: *mut gio::GCancellable,
1278 error: *mut *mut glib::GError,
1279 ) -> gboolean;
1280 #[cfg(feature = "v2022_7")]
1281 #[cfg_attr(docsrs, doc(cfg(feature = "v2022_7")))]
1282 pub fn ostree_kernel_args_contains(
1283 kargs: *mut OstreeKernelArgs,
1284 arg: *const c_char,
1285 ) -> gboolean;
1286 pub fn ostree_kernel_args_delete(
1287 kargs: *mut OstreeKernelArgs,
1288 arg: *const c_char,
1289 error: *mut *mut glib::GError,
1290 ) -> gboolean;
1291 #[cfg(feature = "v2022_7")]
1292 #[cfg_attr(docsrs, doc(cfg(feature = "v2022_7")))]
1293 pub fn ostree_kernel_args_delete_if_present(
1294 kargs: *mut OstreeKernelArgs,
1295 arg: *const c_char,
1296 error: *mut *mut glib::GError,
1297 ) -> gboolean;
1298 #[cfg(feature = "v2019_3")]
1299 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1300 pub fn ostree_kernel_args_delete_key_entry(
1301 kargs: *mut OstreeKernelArgs,
1302 key: *const c_char,
1303 error: *mut *mut glib::GError,
1304 ) -> gboolean;
1305 #[cfg(feature = "v2019_3")]
1306 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1307 pub fn ostree_kernel_args_free(kargs: *mut OstreeKernelArgs);
1308 #[cfg(feature = "v2019_3")]
1309 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1310 pub fn ostree_kernel_args_get_last_value(
1311 kargs: *mut OstreeKernelArgs,
1312 key: *const c_char,
1313 ) -> *const c_char;
1314 #[cfg(feature = "v2019_3")]
1315 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1316 pub fn ostree_kernel_args_new_replace(
1317 kargs: *mut OstreeKernelArgs,
1318 arg: *const c_char,
1319 error: *mut *mut glib::GError,
1320 ) -> gboolean;
1321 #[cfg(feature = "v2019_3")]
1322 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1323 pub fn ostree_kernel_args_parse_append(kargs: *mut OstreeKernelArgs, options: *const c_char);
1324 #[cfg(feature = "v2019_3")]
1325 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1326 pub fn ostree_kernel_args_replace(kargs: *mut OstreeKernelArgs, arg: *const c_char);
1327 #[cfg(feature = "v2019_3")]
1328 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1329 pub fn ostree_kernel_args_replace_argv(kargs: *mut OstreeKernelArgs, argv: *mut *mut c_char);
1330 #[cfg(feature = "v2019_3")]
1331 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1332 pub fn ostree_kernel_args_replace_take(kargs: *mut OstreeKernelArgs, arg: *mut c_char);
1333 #[cfg(feature = "v2019_3")]
1334 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1335 pub fn ostree_kernel_args_to_string(kargs: *mut OstreeKernelArgs) -> *mut c_char;
1336 #[cfg(feature = "v2019_3")]
1337 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1338 pub fn ostree_kernel_args_to_strv(kargs: *mut OstreeKernelArgs) -> *mut *mut c_char;
1339 #[cfg(feature = "v2019_3")]
1340 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1341 pub fn ostree_kernel_args_cleanup(loc: *mut c_void);
1342 #[cfg(feature = "v2019_3")]
1343 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1344 pub fn ostree_kernel_args_from_string(options: *const c_char) -> *mut OstreeKernelArgs;
1345 #[cfg(feature = "v2019_3")]
1346 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_3")))]
1347 pub fn ostree_kernel_args_new() -> *mut OstreeKernelArgs;
1348
1349 #[cfg(feature = "v2018_6")]
1353 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1354 pub fn ostree_remote_get_type() -> GType;
1355 #[cfg(feature = "v2018_6")]
1356 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1357 pub fn ostree_remote_get_name(remote: *mut OstreeRemote) -> *const c_char;
1358 #[cfg(feature = "v2018_6")]
1359 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1360 pub fn ostree_remote_get_url(remote: *mut OstreeRemote) -> *mut c_char;
1361 #[cfg(feature = "v2018_6")]
1362 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1363 pub fn ostree_remote_ref(remote: *mut OstreeRemote) -> *mut OstreeRemote;
1364 #[cfg(feature = "v2018_6")]
1365 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1366 pub fn ostree_remote_unref(remote: *mut OstreeRemote);
1367
1368 #[cfg(feature = "v2017_13")]
1372 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_13")))]
1373 pub fn ostree_repo_checkout_at_options_set_devino(
1374 opts: *mut OstreeRepoCheckoutAtOptions,
1375 cache: *mut OstreeRepoDevInoCache,
1376 );
1377
1378 pub fn ostree_repo_commit_modifier_get_type() -> GType;
1382 pub fn ostree_repo_commit_modifier_new(
1383 flags: OstreeRepoCommitModifierFlags,
1384 commit_filter: OstreeRepoCommitFilter,
1385 user_data: gpointer,
1386 destroy_notify: glib::GDestroyNotify,
1387 ) -> *mut OstreeRepoCommitModifier;
1388 pub fn ostree_repo_commit_modifier_ref(
1389 modifier: *mut OstreeRepoCommitModifier,
1390 ) -> *mut OstreeRepoCommitModifier;
1391 #[cfg(feature = "v2017_13")]
1392 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_13")))]
1393 pub fn ostree_repo_commit_modifier_set_devino_cache(
1394 modifier: *mut OstreeRepoCommitModifier,
1395 cache: *mut OstreeRepoDevInoCache,
1396 );
1397 pub fn ostree_repo_commit_modifier_set_sepolicy(
1398 modifier: *mut OstreeRepoCommitModifier,
1399 sepolicy: *mut OstreeSePolicy,
1400 );
1401 #[cfg(feature = "v2020_4")]
1402 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_4")))]
1403 pub fn ostree_repo_commit_modifier_set_sepolicy_from_commit(
1404 modifier: *mut OstreeRepoCommitModifier,
1405 repo: *mut OstreeRepo,
1406 rev: *const c_char,
1407 cancellable: *mut gio::GCancellable,
1408 error: *mut *mut glib::GError,
1409 ) -> gboolean;
1410 pub fn ostree_repo_commit_modifier_set_xattr_callback(
1411 modifier: *mut OstreeRepoCommitModifier,
1412 callback: OstreeRepoCommitModifierXattrCallback,
1413 destroy: glib::GDestroyNotify,
1414 user_data: gpointer,
1415 );
1416 pub fn ostree_repo_commit_modifier_unref(modifier: *mut OstreeRepoCommitModifier);
1417
1418 pub fn ostree_repo_commit_traverse_iter_clear(iter: *mut OstreeRepoCommitTraverseIter);
1422 pub fn ostree_repo_commit_traverse_iter_get_dir(
1423 iter: *mut OstreeRepoCommitTraverseIter,
1424 out_name: *mut *mut c_char,
1425 out_content_checksum: *mut *mut c_char,
1426 out_meta_checksum: *mut *mut c_char,
1427 );
1428 pub fn ostree_repo_commit_traverse_iter_get_file(
1429 iter: *mut OstreeRepoCommitTraverseIter,
1430 out_name: *mut *mut c_char,
1431 out_checksum: *mut *mut c_char,
1432 );
1433 pub fn ostree_repo_commit_traverse_iter_init_commit(
1434 iter: *mut OstreeRepoCommitTraverseIter,
1435 repo: *mut OstreeRepo,
1436 commit: *mut glib::GVariant,
1437 flags: OstreeRepoCommitTraverseFlags,
1438 error: *mut *mut glib::GError,
1439 ) -> gboolean;
1440 pub fn ostree_repo_commit_traverse_iter_init_dirtree(
1441 iter: *mut OstreeRepoCommitTraverseIter,
1442 repo: *mut OstreeRepo,
1443 dirtree: *mut glib::GVariant,
1444 flags: OstreeRepoCommitTraverseFlags,
1445 error: *mut *mut glib::GError,
1446 ) -> gboolean;
1447 pub fn ostree_repo_commit_traverse_iter_next(
1448 iter: *mut OstreeRepoCommitTraverseIter,
1449 cancellable: *mut gio::GCancellable,
1450 error: *mut *mut glib::GError,
1451 ) -> OstreeRepoCommitIterResult;
1452 pub fn ostree_repo_commit_traverse_iter_cleanup(p: *mut c_void);
1453
1454 pub fn ostree_repo_devino_cache_get_type() -> GType;
1458 pub fn ostree_repo_devino_cache_new() -> *mut OstreeRepoDevInoCache;
1459 pub fn ostree_repo_devino_cache_ref(
1460 cache: *mut OstreeRepoDevInoCache,
1461 ) -> *mut OstreeRepoDevInoCache;
1462 pub fn ostree_repo_devino_cache_unref(cache: *mut OstreeRepoDevInoCache);
1463
1464 #[cfg(feature = "v2018_6")]
1468 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1469 pub fn ostree_repo_finder_result_get_type() -> GType;
1470 #[cfg(feature = "v2018_6")]
1471 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1472 pub fn ostree_repo_finder_result_new(
1473 remote: *mut OstreeRemote,
1474 finder: *mut OstreeRepoFinder,
1475 priority: c_int,
1476 ref_to_checksum: *mut glib::GHashTable,
1477 ref_to_timestamp: *mut glib::GHashTable,
1478 summary_last_modified: u64,
1479 ) -> *mut OstreeRepoFinderResult;
1480 #[cfg(feature = "v2018_6")]
1481 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1482 pub fn ostree_repo_finder_result_compare(
1483 a: *const OstreeRepoFinderResult,
1484 b: *const OstreeRepoFinderResult,
1485 ) -> c_int;
1486 #[cfg(feature = "v2018_6")]
1487 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1488 pub fn ostree_repo_finder_result_dup(
1489 result: *mut OstreeRepoFinderResult,
1490 ) -> *mut OstreeRepoFinderResult;
1491 #[cfg(feature = "v2018_6")]
1492 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1493 pub fn ostree_repo_finder_result_free(result: *mut OstreeRepoFinderResult);
1494 #[cfg(feature = "v2018_6")]
1495 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1496 pub fn ostree_repo_finder_result_freev(results: *mut *mut OstreeRepoFinderResult);
1497
1498 pub fn ostree_repo_transaction_stats_get_type() -> GType;
1502
1503 pub fn ostree_async_progress_get_type() -> GType;
1507 pub fn ostree_async_progress_new() -> *mut OstreeAsyncProgress;
1508 pub fn ostree_async_progress_new_and_connect(
1509 changed: *mut gpointer,
1510 user_data: gpointer,
1511 ) -> *mut OstreeAsyncProgress;
1512 #[cfg(feature = "v2019_6")]
1513 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_6")))]
1514 pub fn ostree_async_progress_copy_state(
1515 self_: *mut OstreeAsyncProgress,
1516 dest: *mut OstreeAsyncProgress,
1517 );
1518 pub fn ostree_async_progress_finish(self_: *mut OstreeAsyncProgress);
1519 #[cfg(feature = "v2017_6")]
1520 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_6")))]
1521 pub fn ostree_async_progress_get(self_: *mut OstreeAsyncProgress, ...);
1522 #[cfg(feature = "v2017_6")]
1523 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_6")))]
1524 pub fn ostree_async_progress_get_status(self_: *mut OstreeAsyncProgress) -> *mut c_char;
1525 pub fn ostree_async_progress_get_uint(
1526 self_: *mut OstreeAsyncProgress,
1527 key: *const c_char,
1528 ) -> c_uint;
1529 pub fn ostree_async_progress_get_uint64(
1530 self_: *mut OstreeAsyncProgress,
1531 key: *const c_char,
1532 ) -> u64;
1533 #[cfg(feature = "v2017_6")]
1534 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_6")))]
1535 pub fn ostree_async_progress_get_variant(
1536 self_: *mut OstreeAsyncProgress,
1537 key: *const c_char,
1538 ) -> *mut glib::GVariant;
1539 #[cfg(feature = "v2017_6")]
1540 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_6")))]
1541 pub fn ostree_async_progress_set(self_: *mut OstreeAsyncProgress, ...);
1542 #[cfg(feature = "v2017_6")]
1543 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_6")))]
1544 pub fn ostree_async_progress_set_status(self_: *mut OstreeAsyncProgress, status: *const c_char);
1545 pub fn ostree_async_progress_set_uint(
1546 self_: *mut OstreeAsyncProgress,
1547 key: *const c_char,
1548 value: c_uint,
1549 );
1550 pub fn ostree_async_progress_set_uint64(
1551 self_: *mut OstreeAsyncProgress,
1552 key: *const c_char,
1553 value: u64,
1554 );
1555 #[cfg(feature = "v2017_6")]
1556 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_6")))]
1557 pub fn ostree_async_progress_set_variant(
1558 self_: *mut OstreeAsyncProgress,
1559 key: *const c_char,
1560 value: *mut glib::GVariant,
1561 );
1562
1563 pub fn ostree_bootconfig_parser_get_type() -> GType;
1567 pub fn ostree_bootconfig_parser_new() -> *mut OstreeBootconfigParser;
1568 pub fn ostree_bootconfig_parser_clone(
1569 self_: *mut OstreeBootconfigParser,
1570 ) -> *mut OstreeBootconfigParser;
1571 pub fn ostree_bootconfig_parser_get(
1572 self_: *mut OstreeBootconfigParser,
1573 key: *const c_char,
1574 ) -> *const c_char;
1575 #[cfg(feature = "v2020_7")]
1576 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
1577 pub fn ostree_bootconfig_parser_get_overlay_initrds(
1578 self_: *mut OstreeBootconfigParser,
1579 ) -> *mut *mut c_char;
1580 pub fn ostree_bootconfig_parser_parse(
1581 self_: *mut OstreeBootconfigParser,
1582 path: *mut gio::GFile,
1583 cancellable: *mut gio::GCancellable,
1584 error: *mut *mut glib::GError,
1585 ) -> gboolean;
1586 pub fn ostree_bootconfig_parser_parse_at(
1587 self_: *mut OstreeBootconfigParser,
1588 dfd: c_int,
1589 path: *const c_char,
1590 cancellable: *mut gio::GCancellable,
1591 error: *mut *mut glib::GError,
1592 ) -> gboolean;
1593 pub fn ostree_bootconfig_parser_set(
1594 self_: *mut OstreeBootconfigParser,
1595 key: *const c_char,
1596 value: *const c_char,
1597 );
1598 #[cfg(feature = "v2020_7")]
1599 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
1600 pub fn ostree_bootconfig_parser_set_overlay_initrds(
1601 self_: *mut OstreeBootconfigParser,
1602 initrds: *mut *mut c_char,
1603 );
1604 pub fn ostree_bootconfig_parser_write(
1605 self_: *mut OstreeBootconfigParser,
1606 output: *mut gio::GFile,
1607 cancellable: *mut gio::GCancellable,
1608 error: *mut *mut glib::GError,
1609 ) -> gboolean;
1610 pub fn ostree_bootconfig_parser_write_at(
1611 self_: *mut OstreeBootconfigParser,
1612 dfd: c_int,
1613 path: *const c_char,
1614 cancellable: *mut gio::GCancellable,
1615 error: *mut *mut glib::GError,
1616 ) -> gboolean;
1617
1618 pub fn ostree_content_writer_get_type() -> GType;
1622 pub fn ostree_content_writer_finish(
1623 self_: *mut OstreeContentWriter,
1624 cancellable: *mut gio::GCancellable,
1625 error: *mut *mut glib::GError,
1626 ) -> *mut c_char;
1627
1628 pub fn ostree_deployment_get_type() -> GType;
1632 pub fn ostree_deployment_new(
1633 index: c_int,
1634 osname: *const c_char,
1635 csum: *const c_char,
1636 deployserial: c_int,
1637 bootcsum: *const c_char,
1638 bootserial: c_int,
1639 ) -> *mut OstreeDeployment;
1640 #[cfg(feature = "v2018_3")]
1641 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
1642 pub fn ostree_deployment_origin_remove_transient_state(origin: *mut glib::GKeyFile);
1643 #[cfg(feature = "v2016_4")]
1644 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
1645 pub fn ostree_deployment_unlocked_state_to_string(
1646 state: OstreeDeploymentUnlockedState,
1647 ) -> *const c_char;
1648 pub fn ostree_deployment_clone(self_: *mut OstreeDeployment) -> *mut OstreeDeployment;
1649 pub fn ostree_deployment_equal(ap: gconstpointer, bp: gconstpointer) -> gboolean;
1650 pub fn ostree_deployment_get_bootconfig(
1651 self_: *mut OstreeDeployment,
1652 ) -> *mut OstreeBootconfigParser;
1653 pub fn ostree_deployment_get_bootcsum(self_: *mut OstreeDeployment) -> *const c_char;
1654 pub fn ostree_deployment_get_bootserial(self_: *mut OstreeDeployment) -> c_int;
1655 pub fn ostree_deployment_get_csum(self_: *mut OstreeDeployment) -> *const c_char;
1656 pub fn ostree_deployment_get_deployserial(self_: *mut OstreeDeployment) -> c_int;
1657 pub fn ostree_deployment_get_index(self_: *mut OstreeDeployment) -> c_int;
1658 pub fn ostree_deployment_get_origin(self_: *mut OstreeDeployment) -> *mut glib::GKeyFile;
1659 pub fn ostree_deployment_get_origin_relpath(self_: *mut OstreeDeployment) -> *mut c_char;
1660 pub fn ostree_deployment_get_osname(self_: *mut OstreeDeployment) -> *const c_char;
1661 #[cfg(feature = "v2016_4")]
1662 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
1663 pub fn ostree_deployment_get_unlocked(
1664 self_: *mut OstreeDeployment,
1665 ) -> OstreeDeploymentUnlockedState;
1666 pub fn ostree_deployment_hash(v: gconstpointer) -> c_uint;
1667 #[cfg(feature = "v2023_8")]
1668 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_8")))]
1669 pub fn ostree_deployment_is_finalization_locked(self_: *mut OstreeDeployment) -> gboolean;
1670 #[cfg(feature = "v2018_3")]
1671 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
1672 pub fn ostree_deployment_is_pinned(self_: *mut OstreeDeployment) -> gboolean;
1673 #[cfg(feature = "v2018_3")]
1674 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
1675 pub fn ostree_deployment_is_staged(self_: *mut OstreeDeployment) -> gboolean;
1676 pub fn ostree_deployment_set_bootconfig(
1677 self_: *mut OstreeDeployment,
1678 bootconfig: *mut OstreeBootconfigParser,
1679 );
1680 pub fn ostree_deployment_set_bootserial(self_: *mut OstreeDeployment, index: c_int);
1681 pub fn ostree_deployment_set_index(self_: *mut OstreeDeployment, index: c_int);
1682 pub fn ostree_deployment_set_origin(self_: *mut OstreeDeployment, origin: *mut glib::GKeyFile);
1683
1684 pub fn ostree_gpg_verify_result_get_type() -> GType;
1688 pub fn ostree_gpg_verify_result_describe_variant(
1689 variant: *mut glib::GVariant,
1690 output_buffer: *mut glib::GString,
1691 line_prefix: *const c_char,
1692 flags: OstreeGpgSignatureFormatFlags,
1693 );
1694 pub fn ostree_gpg_verify_result_count_all(result: *mut OstreeGpgVerifyResult) -> c_uint;
1695 pub fn ostree_gpg_verify_result_count_valid(result: *mut OstreeGpgVerifyResult) -> c_uint;
1696 pub fn ostree_gpg_verify_result_describe(
1697 result: *mut OstreeGpgVerifyResult,
1698 signature_index: c_uint,
1699 output_buffer: *mut glib::GString,
1700 line_prefix: *const c_char,
1701 flags: OstreeGpgSignatureFormatFlags,
1702 );
1703 pub fn ostree_gpg_verify_result_get(
1704 result: *mut OstreeGpgVerifyResult,
1705 signature_index: c_uint,
1706 attrs: *mut OstreeGpgSignatureAttr,
1707 n_attrs: c_uint,
1708 ) -> *mut glib::GVariant;
1709 pub fn ostree_gpg_verify_result_get_all(
1710 result: *mut OstreeGpgVerifyResult,
1711 signature_index: c_uint,
1712 ) -> *mut glib::GVariant;
1713 pub fn ostree_gpg_verify_result_lookup(
1714 result: *mut OstreeGpgVerifyResult,
1715 key_id: *const c_char,
1716 out_signature_index: *mut c_uint,
1717 ) -> gboolean;
1718 #[cfg(feature = "v2016_6")]
1719 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
1720 pub fn ostree_gpg_verify_result_require_valid_signature(
1721 result: *mut OstreeGpgVerifyResult,
1722 error: *mut *mut glib::GError,
1723 ) -> gboolean;
1724
1725 pub fn ostree_mutable_tree_get_type() -> GType;
1729 pub fn ostree_mutable_tree_new() -> *mut OstreeMutableTree;
1730 #[cfg(feature = "v2018_7")]
1731 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_7")))]
1732 pub fn ostree_mutable_tree_new_from_checksum(
1733 repo: *mut OstreeRepo,
1734 contents_checksum: *const c_char,
1735 metadata_checksum: *const c_char,
1736 ) -> *mut OstreeMutableTree;
1737 #[cfg(feature = "v2021_5")]
1738 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_5")))]
1739 pub fn ostree_mutable_tree_new_from_commit(
1740 repo: *mut OstreeRepo,
1741 rev: *const c_char,
1742 error: *mut *mut glib::GError,
1743 ) -> *mut OstreeMutableTree;
1744 #[cfg(feature = "v2018_7")]
1745 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_7")))]
1746 pub fn ostree_mutable_tree_check_error(
1747 self_: *mut OstreeMutableTree,
1748 error: *mut *mut glib::GError,
1749 ) -> gboolean;
1750 pub fn ostree_mutable_tree_ensure_dir(
1751 self_: *mut OstreeMutableTree,
1752 name: *const c_char,
1753 out_subdir: *mut *mut OstreeMutableTree,
1754 error: *mut *mut glib::GError,
1755 ) -> gboolean;
1756 pub fn ostree_mutable_tree_ensure_parent_dirs(
1757 self_: *mut OstreeMutableTree,
1758 split_path: *mut glib::GPtrArray,
1759 metadata_checksum: *const c_char,
1760 out_parent: *mut *mut OstreeMutableTree,
1761 error: *mut *mut glib::GError,
1762 ) -> gboolean;
1763 #[cfg(feature = "v2018_7")]
1764 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_7")))]
1765 pub fn ostree_mutable_tree_fill_empty_from_dirtree(
1766 self_: *mut OstreeMutableTree,
1767 repo: *mut OstreeRepo,
1768 contents_checksum: *const c_char,
1769 metadata_checksum: *const c_char,
1770 ) -> gboolean;
1771 pub fn ostree_mutable_tree_get_contents_checksum(
1772 self_: *mut OstreeMutableTree,
1773 ) -> *const c_char;
1774 pub fn ostree_mutable_tree_get_files(self_: *mut OstreeMutableTree) -> *mut glib::GHashTable;
1775 pub fn ostree_mutable_tree_get_metadata_checksum(
1776 self_: *mut OstreeMutableTree,
1777 ) -> *const c_char;
1778 pub fn ostree_mutable_tree_get_subdirs(self_: *mut OstreeMutableTree) -> *mut glib::GHashTable;
1779 pub fn ostree_mutable_tree_lookup(
1780 self_: *mut OstreeMutableTree,
1781 name: *const c_char,
1782 out_file_checksum: *mut *mut c_char,
1783 out_subdir: *mut *mut OstreeMutableTree,
1784 error: *mut *mut glib::GError,
1785 ) -> gboolean;
1786 #[cfg(feature = "v2018_9")]
1787 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_9")))]
1788 pub fn ostree_mutable_tree_remove(
1789 self_: *mut OstreeMutableTree,
1790 name: *const c_char,
1791 allow_noent: gboolean,
1792 error: *mut *mut glib::GError,
1793 ) -> gboolean;
1794 pub fn ostree_mutable_tree_replace_file(
1795 self_: *mut OstreeMutableTree,
1796 name: *const c_char,
1797 checksum: *const c_char,
1798 error: *mut *mut glib::GError,
1799 ) -> gboolean;
1800 pub fn ostree_mutable_tree_set_contents_checksum(
1801 self_: *mut OstreeMutableTree,
1802 checksum: *const c_char,
1803 );
1804 pub fn ostree_mutable_tree_set_metadata_checksum(
1805 self_: *mut OstreeMutableTree,
1806 checksum: *const c_char,
1807 );
1808 pub fn ostree_mutable_tree_walk(
1809 self_: *mut OstreeMutableTree,
1810 split_path: *mut glib::GPtrArray,
1811 start: c_uint,
1812 out_subdir: *mut *mut OstreeMutableTree,
1813 error: *mut *mut glib::GError,
1814 ) -> gboolean;
1815
1816 pub fn ostree_repo_get_type() -> GType;
1820 pub fn ostree_repo_new(path: *mut gio::GFile) -> *mut OstreeRepo;
1821 pub fn ostree_repo_new_default() -> *mut OstreeRepo;
1822 pub fn ostree_repo_new_for_sysroot_path(
1823 repo_path: *mut gio::GFile,
1824 sysroot_path: *mut gio::GFile,
1825 ) -> *mut OstreeRepo;
1826 #[cfg(feature = "v2017_10")]
1827 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
1828 pub fn ostree_repo_create_at(
1829 dfd: c_int,
1830 path: *const c_char,
1831 mode: OstreeRepoMode,
1832 options: *mut glib::GVariant,
1833 cancellable: *mut gio::GCancellable,
1834 error: *mut *mut glib::GError,
1835 ) -> *mut OstreeRepo;
1836 pub fn ostree_repo_mode_from_string(
1837 mode: *const c_char,
1838 out_mode: *mut OstreeRepoMode,
1839 error: *mut *mut glib::GError,
1840 ) -> gboolean;
1841 #[cfg(feature = "v2017_10")]
1842 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
1843 pub fn ostree_repo_open_at(
1844 dfd: c_int,
1845 path: *const c_char,
1846 cancellable: *mut gio::GCancellable,
1847 error: *mut *mut glib::GError,
1848 ) -> *mut OstreeRepo;
1849 pub fn ostree_repo_pull_default_console_progress_changed(
1850 progress: *mut OstreeAsyncProgress,
1851 user_data: gpointer,
1852 );
1853 #[cfg(feature = "v2018_5")]
1854 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
1855 pub fn ostree_repo_traverse_new_parents() -> *mut glib::GHashTable;
1856 pub fn ostree_repo_traverse_new_reachable() -> *mut glib::GHashTable;
1857 #[cfg(feature = "v2018_5")]
1858 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
1859 pub fn ostree_repo_traverse_parents_get_commits(
1860 parents: *mut glib::GHashTable,
1861 object: *mut glib::GVariant,
1862 ) -> *mut *mut c_char;
1863 pub fn ostree_repo_abort_transaction(
1864 self_: *mut OstreeRepo,
1865 cancellable: *mut gio::GCancellable,
1866 error: *mut *mut glib::GError,
1867 ) -> gboolean;
1868 pub fn ostree_repo_add_gpg_signature_summary(
1869 self_: *mut OstreeRepo,
1870 key_id: *mut *const c_char,
1871 homedir: *const c_char,
1872 cancellable: *mut gio::GCancellable,
1873 error: *mut *mut glib::GError,
1874 ) -> gboolean;
1875 pub fn ostree_repo_append_gpg_signature(
1876 self_: *mut OstreeRepo,
1877 commit_checksum: *const c_char,
1878 signature_bytes: *mut glib::GBytes,
1879 cancellable: *mut gio::GCancellable,
1880 error: *mut *mut glib::GError,
1881 ) -> gboolean;
1882 #[cfg(feature = "v2016_8")]
1883 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_8")))]
1884 pub fn ostree_repo_checkout_at(
1885 self_: *mut OstreeRepo,
1886 options: *mut OstreeRepoCheckoutAtOptions,
1887 destination_dfd: c_int,
1888 destination_path: *const c_char,
1889 commit: *const c_char,
1890 cancellable: *mut gio::GCancellable,
1891 error: *mut *mut glib::GError,
1892 ) -> gboolean;
1893 #[cfg(feature = "v2024_7")]
1894 #[cfg_attr(docsrs, doc(cfg(feature = "v2024_7")))]
1895 pub fn ostree_repo_checkout_composefs(
1896 self_: *mut OstreeRepo,
1897 options: *mut glib::GVariant,
1898 destination_dfd: c_int,
1899 destination_path: *const c_char,
1900 checksum: *const c_char,
1901 cancellable: *mut gio::GCancellable,
1902 error: *mut *mut glib::GError,
1903 ) -> gboolean;
1904 pub fn ostree_repo_checkout_gc(
1905 self_: *mut OstreeRepo,
1906 cancellable: *mut gio::GCancellable,
1907 error: *mut *mut glib::GError,
1908 ) -> gboolean;
1909 pub fn ostree_repo_checkout_tree(
1910 self_: *mut OstreeRepo,
1911 mode: OstreeRepoCheckoutMode,
1912 overwrite_mode: OstreeRepoCheckoutOverwriteMode,
1913 destination: *mut gio::GFile,
1914 source: *mut OstreeRepoFile,
1915 source_info: *mut gio::GFileInfo,
1916 cancellable: *mut gio::GCancellable,
1917 error: *mut *mut glib::GError,
1918 ) -> gboolean;
1919 pub fn ostree_repo_checkout_tree_at(
1920 self_: *mut OstreeRepo,
1921 options: *mut OstreeRepoCheckoutOptions,
1922 destination_dfd: c_int,
1923 destination_path: *const c_char,
1924 commit: *const c_char,
1925 cancellable: *mut gio::GCancellable,
1926 error: *mut *mut glib::GError,
1927 ) -> gboolean;
1928 pub fn ostree_repo_commit_add_composefs_metadata(
1929 self_: *mut OstreeRepo,
1930 format_version: c_uint,
1931 dict: *mut glib::GVariantDict,
1932 repo_root: *mut OstreeRepoFile,
1933 cancellable: *mut gio::GCancellable,
1934 error: *mut *mut glib::GError,
1935 ) -> gboolean;
1936 pub fn ostree_repo_commit_transaction(
1937 self_: *mut OstreeRepo,
1938 out_stats: *mut OstreeRepoTransactionStats,
1939 cancellable: *mut gio::GCancellable,
1940 error: *mut *mut glib::GError,
1941 ) -> gboolean;
1942 pub fn ostree_repo_copy_config(self_: *mut OstreeRepo) -> *mut glib::GKeyFile;
1943 pub fn ostree_repo_create(
1944 self_: *mut OstreeRepo,
1945 mode: OstreeRepoMode,
1946 cancellable: *mut gio::GCancellable,
1947 error: *mut *mut glib::GError,
1948 ) -> gboolean;
1949 pub fn ostree_repo_delete_object(
1950 self_: *mut OstreeRepo,
1951 objtype: OstreeObjectType,
1952 sha256: *const c_char,
1953 cancellable: *mut gio::GCancellable,
1954 error: *mut *mut glib::GError,
1955 ) -> gboolean;
1956 #[cfg(feature = "v2017_12")]
1957 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_12")))]
1958 pub fn ostree_repo_equal(a: *mut OstreeRepo, b: *mut OstreeRepo) -> gboolean;
1959 pub fn ostree_repo_export_tree_to_archive(
1960 self_: *mut OstreeRepo,
1961 opts: *mut OstreeRepoExportArchiveOptions,
1962 root: *mut OstreeRepoFile,
1963 archive: *mut c_void,
1964 cancellable: *mut gio::GCancellable,
1965 error: *mut *mut glib::GError,
1966 ) -> gboolean;
1967 #[cfg(feature = "v2018_6")]
1968 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1969 pub fn ostree_repo_find_remotes_async(
1970 self_: *mut OstreeRepo,
1971 refs: *const *const OstreeCollectionRef,
1972 options: *mut glib::GVariant,
1973 finders: *mut *mut OstreeRepoFinder,
1974 progress: *mut OstreeAsyncProgress,
1975 cancellable: *mut gio::GCancellable,
1976 callback: gio::GAsyncReadyCallback,
1977 user_data: gpointer,
1978 );
1979 #[cfg(feature = "v2018_6")]
1980 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1981 pub fn ostree_repo_find_remotes_finish(
1982 self_: *mut OstreeRepo,
1983 result: *mut gio::GAsyncResult,
1984 error: *mut *mut glib::GError,
1985 ) -> *mut *mut OstreeRepoFinderResult;
1986 #[cfg(feature = "v2017_15")]
1987 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_15")))]
1988 pub fn ostree_repo_fsck_object(
1989 self_: *mut OstreeRepo,
1990 objtype: OstreeObjectType,
1991 sha256: *const c_char,
1992 cancellable: *mut gio::GCancellable,
1993 error: *mut *mut glib::GError,
1994 ) -> gboolean;
1995 #[cfg(feature = "v2019_2")]
1996 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_2")))]
1997 pub fn ostree_repo_get_bootloader(self_: *mut OstreeRepo) -> *const c_char;
1998 #[cfg(feature = "v2018_6")]
1999 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2000 pub fn ostree_repo_get_collection_id(self_: *mut OstreeRepo) -> *const c_char;
2001 pub fn ostree_repo_get_config(self_: *mut OstreeRepo) -> *mut glib::GKeyFile;
2002 #[cfg(feature = "v2018_9")]
2003 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_9")))]
2004 pub fn ostree_repo_get_default_repo_finders(self_: *mut OstreeRepo) -> *const *const c_char;
2005 #[cfg(feature = "v2016_4")]
2006 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
2007 pub fn ostree_repo_get_dfd(self_: *mut OstreeRepo) -> c_int;
2008 pub fn ostree_repo_get_disable_fsync(self_: *mut OstreeRepo) -> gboolean;
2009 #[cfg(feature = "v2018_9")]
2010 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_9")))]
2011 pub fn ostree_repo_get_min_free_space_bytes(
2012 self_: *mut OstreeRepo,
2013 out_reserved_bytes: *mut u64,
2014 error: *mut *mut glib::GError,
2015 ) -> gboolean;
2016 pub fn ostree_repo_get_mode(self_: *mut OstreeRepo) -> OstreeRepoMode;
2017 pub fn ostree_repo_get_parent(self_: *mut OstreeRepo) -> *mut OstreeRepo;
2018 pub fn ostree_repo_get_path(self_: *mut OstreeRepo) -> *mut gio::GFile;
2019 #[cfg(feature = "v2016_5")]
2020 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2021 pub fn ostree_repo_get_remote_boolean_option(
2022 self_: *mut OstreeRepo,
2023 remote_name: *const c_char,
2024 option_name: *const c_char,
2025 default_value: gboolean,
2026 out_value: *mut gboolean,
2027 error: *mut *mut glib::GError,
2028 ) -> gboolean;
2029 #[cfg(feature = "v2016_5")]
2030 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2031 pub fn ostree_repo_get_remote_list_option(
2032 self_: *mut OstreeRepo,
2033 remote_name: *const c_char,
2034 option_name: *const c_char,
2035 out_value: *mut *mut *mut c_char,
2036 error: *mut *mut glib::GError,
2037 ) -> gboolean;
2038 #[cfg(feature = "v2016_5")]
2039 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2040 pub fn ostree_repo_get_remote_option(
2041 self_: *mut OstreeRepo,
2042 remote_name: *const c_char,
2043 option_name: *const c_char,
2044 default_value: *const c_char,
2045 out_value: *mut *mut c_char,
2046 error: *mut *mut glib::GError,
2047 ) -> gboolean;
2048 #[cfg(feature = "v2020_8")]
2049 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_8")))]
2050 pub fn ostree_repo_gpg_sign_data(
2051 self_: *mut OstreeRepo,
2052 data: *mut glib::GBytes,
2053 old_signatures: *mut glib::GBytes,
2054 key_id: *mut *const c_char,
2055 homedir: *const c_char,
2056 out_signatures: *mut *mut glib::GBytes,
2057 cancellable: *mut gio::GCancellable,
2058 error: *mut *mut glib::GError,
2059 ) -> gboolean;
2060 #[cfg(feature = "v2016_6")]
2061 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
2062 pub fn ostree_repo_gpg_verify_data(
2063 self_: *mut OstreeRepo,
2064 remote_name: *const c_char,
2065 data: *mut glib::GBytes,
2066 signatures: *mut glib::GBytes,
2067 keyringdir: *mut gio::GFile,
2068 extra_keyring: *mut gio::GFile,
2069 cancellable: *mut gio::GCancellable,
2070 error: *mut *mut glib::GError,
2071 ) -> *mut OstreeGpgVerifyResult;
2072 pub fn ostree_repo_has_object(
2073 self_: *mut OstreeRepo,
2074 objtype: OstreeObjectType,
2075 checksum: *const c_char,
2076 out_have_object: *mut gboolean,
2077 cancellable: *mut gio::GCancellable,
2078 error: *mut *mut glib::GError,
2079 ) -> gboolean;
2080 #[cfg(feature = "v2017_12")]
2081 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_12")))]
2082 pub fn ostree_repo_hash(self_: *mut OstreeRepo) -> c_uint;
2083 pub fn ostree_repo_import_archive_to_mtree(
2084 self_: *mut OstreeRepo,
2085 opts: *mut OstreeRepoImportArchiveOptions,
2086 archive: *mut c_void,
2087 mtree: *mut OstreeMutableTree,
2088 modifier: *mut OstreeRepoCommitModifier,
2089 cancellable: *mut gio::GCancellable,
2090 error: *mut *mut glib::GError,
2091 ) -> gboolean;
2092 pub fn ostree_repo_import_object_from(
2093 self_: *mut OstreeRepo,
2094 source: *mut OstreeRepo,
2095 objtype: OstreeObjectType,
2096 checksum: *const c_char,
2097 cancellable: *mut gio::GCancellable,
2098 error: *mut *mut glib::GError,
2099 ) -> gboolean;
2100 #[cfg(feature = "v2016_5")]
2101 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2102 pub fn ostree_repo_import_object_from_with_trust(
2103 self_: *mut OstreeRepo,
2104 source: *mut OstreeRepo,
2105 objtype: OstreeObjectType,
2106 checksum: *const c_char,
2107 trusted: gboolean,
2108 cancellable: *mut gio::GCancellable,
2109 error: *mut *mut glib::GError,
2110 ) -> gboolean;
2111 pub fn ostree_repo_is_system(repo: *mut OstreeRepo) -> gboolean;
2112 pub fn ostree_repo_is_writable(
2113 self_: *mut OstreeRepo,
2114 error: *mut *mut glib::GError,
2115 ) -> gboolean;
2116 #[cfg(feature = "v2018_6")]
2117 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2118 pub fn ostree_repo_list_collection_refs(
2119 self_: *mut OstreeRepo,
2120 match_collection_id: *const c_char,
2121 out_all_refs: *mut *mut glib::GHashTable,
2122 flags: OstreeRepoListRefsExtFlags,
2123 cancellable: *mut gio::GCancellable,
2124 error: *mut *mut glib::GError,
2125 ) -> gboolean;
2126 pub fn ostree_repo_list_commit_objects_starting_with(
2127 self_: *mut OstreeRepo,
2128 start: *const c_char,
2129 out_commits: *mut *mut glib::GHashTable,
2130 cancellable: *mut gio::GCancellable,
2131 error: *mut *mut glib::GError,
2132 ) -> gboolean;
2133 pub fn ostree_repo_list_objects(
2134 self_: *mut OstreeRepo,
2135 flags: OstreeRepoListObjectsFlags,
2136 out_objects: *mut *mut glib::GHashTable,
2137 cancellable: *mut gio::GCancellable,
2138 error: *mut *mut glib::GError,
2139 ) -> gboolean;
2140 pub fn ostree_repo_list_refs(
2141 self_: *mut OstreeRepo,
2142 refspec_prefix: *const c_char,
2143 out_all_refs: *mut *mut glib::GHashTable,
2144 cancellable: *mut gio::GCancellable,
2145 error: *mut *mut glib::GError,
2146 ) -> gboolean;
2147 #[cfg(feature = "v2016_4")]
2148 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
2149 pub fn ostree_repo_list_refs_ext(
2150 self_: *mut OstreeRepo,
2151 refspec_prefix: *const c_char,
2152 out_all_refs: *mut *mut glib::GHashTable,
2153 flags: OstreeRepoListRefsExtFlags,
2154 cancellable: *mut gio::GCancellable,
2155 error: *mut *mut glib::GError,
2156 ) -> gboolean;
2157 #[cfg(feature = "v2020_8")]
2158 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_8")))]
2159 pub fn ostree_repo_list_static_delta_indexes(
2160 self_: *mut OstreeRepo,
2161 out_indexes: *mut *mut glib::GPtrArray,
2162 cancellable: *mut gio::GCancellable,
2163 error: *mut *mut glib::GError,
2164 ) -> gboolean;
2165 pub fn ostree_repo_list_static_delta_names(
2166 self_: *mut OstreeRepo,
2167 out_deltas: *mut *mut glib::GPtrArray,
2168 cancellable: *mut gio::GCancellable,
2169 error: *mut *mut glib::GError,
2170 ) -> gboolean;
2171 #[cfg(feature = "v2015_7")]
2172 #[cfg_attr(docsrs, doc(cfg(feature = "v2015_7")))]
2173 pub fn ostree_repo_load_commit(
2174 self_: *mut OstreeRepo,
2175 checksum: *const c_char,
2176 out_commit: *mut *mut glib::GVariant,
2177 out_state: *mut OstreeRepoCommitState,
2178 error: *mut *mut glib::GError,
2179 ) -> gboolean;
2180 pub fn ostree_repo_load_file(
2181 self_: *mut OstreeRepo,
2182 checksum: *const c_char,
2183 out_input: *mut *mut gio::GInputStream,
2184 out_file_info: *mut *mut gio::GFileInfo,
2185 out_xattrs: *mut *mut glib::GVariant,
2186 cancellable: *mut gio::GCancellable,
2187 error: *mut *mut glib::GError,
2188 ) -> gboolean;
2189 pub fn ostree_repo_load_object_stream(
2190 self_: *mut OstreeRepo,
2191 objtype: OstreeObjectType,
2192 checksum: *const c_char,
2193 out_input: *mut *mut gio::GInputStream,
2194 out_size: *mut u64,
2195 cancellable: *mut gio::GCancellable,
2196 error: *mut *mut glib::GError,
2197 ) -> gboolean;
2198 pub fn ostree_repo_load_variant(
2199 self_: *mut OstreeRepo,
2200 objtype: OstreeObjectType,
2201 sha256: *const c_char,
2202 out_variant: *mut *mut glib::GVariant,
2203 error: *mut *mut glib::GError,
2204 ) -> gboolean;
2205 pub fn ostree_repo_load_variant_if_exists(
2206 self_: *mut OstreeRepo,
2207 objtype: OstreeObjectType,
2208 sha256: *const c_char,
2209 out_variant: *mut *mut glib::GVariant,
2210 error: *mut *mut glib::GError,
2211 ) -> gboolean;
2212 #[cfg(feature = "v2021_3")]
2213 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_3")))]
2214 pub fn ostree_repo_lock_pop(
2215 self_: *mut OstreeRepo,
2216 lock_type: OstreeRepoLockType,
2217 cancellable: *mut gio::GCancellable,
2218 error: *mut *mut glib::GError,
2219 ) -> gboolean;
2220 #[cfg(feature = "v2021_3")]
2221 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_3")))]
2222 pub fn ostree_repo_lock_push(
2223 self_: *mut OstreeRepo,
2224 lock_type: OstreeRepoLockType,
2225 cancellable: *mut gio::GCancellable,
2226 error: *mut *mut glib::GError,
2227 ) -> gboolean;
2228 #[cfg(feature = "v2017_15")]
2229 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_15")))]
2230 pub fn ostree_repo_mark_commit_partial(
2231 self_: *mut OstreeRepo,
2232 checksum: *const c_char,
2233 is_partial: gboolean,
2234 error: *mut *mut glib::GError,
2235 ) -> gboolean;
2236 #[cfg(feature = "v2019_4")]
2237 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_4")))]
2238 pub fn ostree_repo_mark_commit_partial_reason(
2239 self_: *mut OstreeRepo,
2240 checksum: *const c_char,
2241 is_partial: gboolean,
2242 in_state: OstreeRepoCommitState,
2243 error: *mut *mut glib::GError,
2244 ) -> gboolean;
2245 pub fn ostree_repo_open(
2246 self_: *mut OstreeRepo,
2247 cancellable: *mut gio::GCancellable,
2248 error: *mut *mut glib::GError,
2249 ) -> gboolean;
2250 pub fn ostree_repo_prepare_transaction(
2251 self_: *mut OstreeRepo,
2252 out_transaction_resume: *mut gboolean,
2253 cancellable: *mut gio::GCancellable,
2254 error: *mut *mut glib::GError,
2255 ) -> gboolean;
2256 pub fn ostree_repo_prune(
2257 self_: *mut OstreeRepo,
2258 flags: OstreeRepoPruneFlags,
2259 depth: c_int,
2260 out_objects_total: *mut c_int,
2261 out_objects_pruned: *mut c_int,
2262 out_pruned_object_size_total: *mut u64,
2263 cancellable: *mut gio::GCancellable,
2264 error: *mut *mut glib::GError,
2265 ) -> gboolean;
2266 #[cfg(feature = "v2017_1")]
2267 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_1")))]
2268 pub fn ostree_repo_prune_from_reachable(
2269 self_: *mut OstreeRepo,
2270 options: *mut OstreeRepoPruneOptions,
2271 out_objects_total: *mut c_int,
2272 out_objects_pruned: *mut c_int,
2273 out_pruned_object_size_total: *mut u64,
2274 cancellable: *mut gio::GCancellable,
2275 error: *mut *mut glib::GError,
2276 ) -> gboolean;
2277 pub fn ostree_repo_prune_static_deltas(
2278 self_: *mut OstreeRepo,
2279 commit: *const c_char,
2280 cancellable: *mut gio::GCancellable,
2281 error: *mut *mut glib::GError,
2282 ) -> gboolean;
2283 pub fn ostree_repo_pull(
2284 self_: *mut OstreeRepo,
2285 remote_name: *const c_char,
2286 refs_to_fetch: *mut *mut c_char,
2287 flags: OstreeRepoPullFlags,
2288 progress: *mut OstreeAsyncProgress,
2289 cancellable: *mut gio::GCancellable,
2290 error: *mut *mut glib::GError,
2291 ) -> gboolean;
2292 #[cfg(feature = "v2018_6")]
2293 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2294 pub fn ostree_repo_pull_from_remotes_async(
2295 self_: *mut OstreeRepo,
2296 results: *const *const OstreeRepoFinderResult,
2297 options: *mut glib::GVariant,
2298 progress: *mut OstreeAsyncProgress,
2299 cancellable: *mut gio::GCancellable,
2300 callback: gio::GAsyncReadyCallback,
2301 user_data: gpointer,
2302 );
2303 #[cfg(feature = "v2018_6")]
2304 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2305 pub fn ostree_repo_pull_from_remotes_finish(
2306 self_: *mut OstreeRepo,
2307 result: *mut gio::GAsyncResult,
2308 error: *mut *mut glib::GError,
2309 ) -> gboolean;
2310 pub fn ostree_repo_pull_one_dir(
2311 self_: *mut OstreeRepo,
2312 remote_name: *const c_char,
2313 dir_to_pull: *const c_char,
2314 refs_to_fetch: *mut *mut c_char,
2315 flags: OstreeRepoPullFlags,
2316 progress: *mut OstreeAsyncProgress,
2317 cancellable: *mut gio::GCancellable,
2318 error: *mut *mut glib::GError,
2319 ) -> gboolean;
2320 pub fn ostree_repo_pull_with_options(
2321 self_: *mut OstreeRepo,
2322 remote_name_or_baseurl: *const c_char,
2323 options: *mut glib::GVariant,
2324 progress: *mut OstreeAsyncProgress,
2325 cancellable: *mut gio::GCancellable,
2326 error: *mut *mut glib::GError,
2327 ) -> gboolean;
2328 pub fn ostree_repo_query_object_storage_size(
2329 self_: *mut OstreeRepo,
2330 objtype: OstreeObjectType,
2331 sha256: *const c_char,
2332 out_size: *mut u64,
2333 cancellable: *mut gio::GCancellable,
2334 error: *mut *mut glib::GError,
2335 ) -> gboolean;
2336 pub fn ostree_repo_read_commit(
2337 self_: *mut OstreeRepo,
2338 ref_: *const c_char,
2339 out_root: *mut *mut gio::GFile,
2340 out_commit: *mut *mut c_char,
2341 cancellable: *mut gio::GCancellable,
2342 error: *mut *mut glib::GError,
2343 ) -> gboolean;
2344 pub fn ostree_repo_read_commit_detached_metadata(
2345 self_: *mut OstreeRepo,
2346 checksum: *const c_char,
2347 out_metadata: *mut *mut glib::GVariant,
2348 cancellable: *mut gio::GCancellable,
2349 error: *mut *mut glib::GError,
2350 ) -> gboolean;
2351 #[cfg(feature = "v2023_1")]
2352 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_1")))]
2353 pub fn ostree_repo_regenerate_metadata(
2354 self_: *mut OstreeRepo,
2355 additional_metadata: *mut glib::GVariant,
2356 options: *mut glib::GVariant,
2357 cancellable: *mut gio::GCancellable,
2358 error: *mut *mut glib::GError,
2359 ) -> gboolean;
2360 pub fn ostree_repo_regenerate_summary(
2361 self_: *mut OstreeRepo,
2362 additional_metadata: *mut glib::GVariant,
2363 cancellable: *mut gio::GCancellable,
2364 error: *mut *mut glib::GError,
2365 ) -> gboolean;
2366 #[cfg(feature = "v2017_2")]
2367 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_2")))]
2368 pub fn ostree_repo_reload_config(
2369 self_: *mut OstreeRepo,
2370 cancellable: *mut gio::GCancellable,
2371 error: *mut *mut glib::GError,
2372 ) -> gboolean;
2373 pub fn ostree_repo_remote_add(
2374 self_: *mut OstreeRepo,
2375 name: *const c_char,
2376 url: *const c_char,
2377 options: *mut glib::GVariant,
2378 cancellable: *mut gio::GCancellable,
2379 error: *mut *mut glib::GError,
2380 ) -> gboolean;
2381 pub fn ostree_repo_remote_change(
2382 self_: *mut OstreeRepo,
2383 sysroot: *mut gio::GFile,
2384 changeop: OstreeRepoRemoteChange,
2385 name: *const c_char,
2386 url: *const c_char,
2387 options: *mut glib::GVariant,
2388 cancellable: *mut gio::GCancellable,
2389 error: *mut *mut glib::GError,
2390 ) -> gboolean;
2391 pub fn ostree_repo_remote_delete(
2392 self_: *mut OstreeRepo,
2393 name: *const c_char,
2394 cancellable: *mut gio::GCancellable,
2395 error: *mut *mut glib::GError,
2396 ) -> gboolean;
2397 pub fn ostree_repo_remote_fetch_summary(
2398 self_: *mut OstreeRepo,
2399 name: *const c_char,
2400 out_summary: *mut *mut glib::GBytes,
2401 out_signatures: *mut *mut glib::GBytes,
2402 cancellable: *mut gio::GCancellable,
2403 error: *mut *mut glib::GError,
2404 ) -> gboolean;
2405 #[cfg(feature = "v2016_6")]
2406 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
2407 pub fn ostree_repo_remote_fetch_summary_with_options(
2408 self_: *mut OstreeRepo,
2409 name: *const c_char,
2410 options: *mut glib::GVariant,
2411 out_summary: *mut *mut glib::GBytes,
2412 out_signatures: *mut *mut glib::GBytes,
2413 cancellable: *mut gio::GCancellable,
2414 error: *mut *mut glib::GError,
2415 ) -> gboolean;
2416 #[cfg(feature = "v2021_4")]
2417 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_4")))]
2418 pub fn ostree_repo_remote_get_gpg_keys(
2419 self_: *mut OstreeRepo,
2420 name: *const c_char,
2421 key_ids: *const *const c_char,
2422 out_keys: *mut *mut glib::GPtrArray,
2423 cancellable: *mut gio::GCancellable,
2424 error: *mut *mut glib::GError,
2425 ) -> gboolean;
2426 pub fn ostree_repo_remote_get_gpg_verify(
2427 self_: *mut OstreeRepo,
2428 name: *const c_char,
2429 out_gpg_verify: *mut gboolean,
2430 error: *mut *mut glib::GError,
2431 ) -> gboolean;
2432 pub fn ostree_repo_remote_get_gpg_verify_summary(
2433 self_: *mut OstreeRepo,
2434 name: *const c_char,
2435 out_gpg_verify_summary: *mut gboolean,
2436 error: *mut *mut glib::GError,
2437 ) -> gboolean;
2438 pub fn ostree_repo_remote_get_url(
2439 self_: *mut OstreeRepo,
2440 name: *const c_char,
2441 out_url: *mut *mut c_char,
2442 error: *mut *mut glib::GError,
2443 ) -> gboolean;
2444 pub fn ostree_repo_remote_gpg_import(
2445 self_: *mut OstreeRepo,
2446 name: *const c_char,
2447 source_stream: *mut gio::GInputStream,
2448 key_ids: *const *const c_char,
2449 out_imported: *mut c_uint,
2450 cancellable: *mut gio::GCancellable,
2451 error: *mut *mut glib::GError,
2452 ) -> gboolean;
2453 pub fn ostree_repo_remote_list(
2454 self_: *mut OstreeRepo,
2455 out_n_remotes: *mut c_uint,
2456 ) -> *mut *mut c_char;
2457 #[cfg(feature = "v2018_6")]
2458 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2459 pub fn ostree_repo_remote_list_collection_refs(
2460 self_: *mut OstreeRepo,
2461 remote_name: *const c_char,
2462 out_all_refs: *mut *mut glib::GHashTable,
2463 cancellable: *mut gio::GCancellable,
2464 error: *mut *mut glib::GError,
2465 ) -> gboolean;
2466 pub fn ostree_repo_remote_list_refs(
2467 self_: *mut OstreeRepo,
2468 remote_name: *const c_char,
2469 out_all_refs: *mut *mut glib::GHashTable,
2470 cancellable: *mut gio::GCancellable,
2471 error: *mut *mut glib::GError,
2472 ) -> gboolean;
2473 #[cfg(feature = "v2018_6")]
2474 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2475 pub fn ostree_repo_resolve_collection_ref(
2476 self_: *mut OstreeRepo,
2477 ref_: *const OstreeCollectionRef,
2478 allow_noent: gboolean,
2479 flags: OstreeRepoResolveRevExtFlags,
2480 out_rev: *mut *mut c_char,
2481 cancellable: *mut gio::GCancellable,
2482 error: *mut *mut glib::GError,
2483 ) -> gboolean;
2484 #[cfg(feature = "v2018_6")]
2485 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2486 pub fn ostree_repo_resolve_keyring_for_collection(
2487 self_: *mut OstreeRepo,
2488 collection_id: *const c_char,
2489 cancellable: *mut gio::GCancellable,
2490 error: *mut *mut glib::GError,
2491 ) -> *mut OstreeRemote;
2492 pub fn ostree_repo_resolve_rev(
2493 self_: *mut OstreeRepo,
2494 refspec: *const c_char,
2495 allow_noent: gboolean,
2496 out_rev: *mut *mut c_char,
2497 error: *mut *mut glib::GError,
2498 ) -> gboolean;
2499 #[cfg(feature = "v2016_7")]
2500 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_7")))]
2501 pub fn ostree_repo_resolve_rev_ext(
2502 self_: *mut OstreeRepo,
2503 refspec: *const c_char,
2504 allow_noent: gboolean,
2505 flags: OstreeRepoResolveRevExtFlags,
2506 out_rev: *mut *mut c_char,
2507 error: *mut *mut glib::GError,
2508 ) -> gboolean;
2509 pub fn ostree_repo_scan_hardlinks(
2510 self_: *mut OstreeRepo,
2511 cancellable: *mut gio::GCancellable,
2512 error: *mut *mut glib::GError,
2513 ) -> gboolean;
2514 #[cfg(feature = "v2017_10")]
2515 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
2516 pub fn ostree_repo_set_alias_ref_immediate(
2517 self_: *mut OstreeRepo,
2518 remote: *const c_char,
2519 ref_: *const c_char,
2520 target: *const c_char,
2521 cancellable: *mut gio::GCancellable,
2522 error: *mut *mut glib::GError,
2523 ) -> gboolean;
2524 #[cfg(feature = "v2016_5")]
2525 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2526 pub fn ostree_repo_set_cache_dir(
2527 self_: *mut OstreeRepo,
2528 dfd: c_int,
2529 path: *const c_char,
2530 cancellable: *mut gio::GCancellable,
2531 error: *mut *mut glib::GError,
2532 ) -> gboolean;
2533 #[cfg(feature = "v2018_6")]
2534 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2535 pub fn ostree_repo_set_collection_id(
2536 self_: *mut OstreeRepo,
2537 collection_id: *const c_char,
2538 error: *mut *mut glib::GError,
2539 ) -> gboolean;
2540 #[cfg(feature = "v2018_6")]
2541 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2542 pub fn ostree_repo_set_collection_ref_immediate(
2543 self_: *mut OstreeRepo,
2544 ref_: *const OstreeCollectionRef,
2545 checksum: *const c_char,
2546 cancellable: *mut gio::GCancellable,
2547 error: *mut *mut glib::GError,
2548 ) -> gboolean;
2549 pub fn ostree_repo_set_disable_fsync(self_: *mut OstreeRepo, disable_fsync: gboolean);
2550 pub fn ostree_repo_set_ref_immediate(
2551 self_: *mut OstreeRepo,
2552 remote: *const c_char,
2553 ref_: *const c_char,
2554 checksum: *const c_char,
2555 cancellable: *mut gio::GCancellable,
2556 error: *mut *mut glib::GError,
2557 ) -> gboolean;
2558 pub fn ostree_repo_sign_commit(
2559 self_: *mut OstreeRepo,
2560 commit_checksum: *const c_char,
2561 key_id: *const c_char,
2562 homedir: *const c_char,
2563 cancellable: *mut gio::GCancellable,
2564 error: *mut *mut glib::GError,
2565 ) -> gboolean;
2566 pub fn ostree_repo_sign_delta(
2567 self_: *mut OstreeRepo,
2568 from_commit: *const c_char,
2569 to_commit: *const c_char,
2570 key_id: *const c_char,
2571 homedir: *const c_char,
2572 cancellable: *mut gio::GCancellable,
2573 error: *mut *mut glib::GError,
2574 ) -> gboolean;
2575 #[cfg(feature = "v2021_4")]
2576 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_4")))]
2577 pub fn ostree_repo_signature_verify_commit_data(
2578 self_: *mut OstreeRepo,
2579 remote_name: *const c_char,
2580 commit_data: *mut glib::GBytes,
2581 commit_metadata: *mut glib::GBytes,
2582 flags: OstreeRepoVerifyFlags,
2583 out_results: *mut *mut c_char,
2584 error: *mut *mut glib::GError,
2585 ) -> gboolean;
2586 pub fn ostree_repo_static_delta_execute_offline(
2587 self_: *mut OstreeRepo,
2588 dir_or_file: *mut gio::GFile,
2589 skip_validation: gboolean,
2590 cancellable: *mut gio::GCancellable,
2591 error: *mut *mut glib::GError,
2592 ) -> gboolean;
2593 #[cfg(feature = "v2020_7")]
2594 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
2595 pub fn ostree_repo_static_delta_execute_offline_with_signature(
2596 self_: *mut OstreeRepo,
2597 dir_or_file: *mut gio::GFile,
2598 sign: *mut OstreeSign,
2599 skip_validation: gboolean,
2600 cancellable: *mut gio::GCancellable,
2601 error: *mut *mut glib::GError,
2602 ) -> gboolean;
2603 pub fn ostree_repo_static_delta_generate(
2604 self_: *mut OstreeRepo,
2605 opt: OstreeStaticDeltaGenerateOpt,
2606 from: *const c_char,
2607 to: *const c_char,
2608 metadata: *mut glib::GVariant,
2609 params: *mut glib::GVariant,
2610 cancellable: *mut gio::GCancellable,
2611 error: *mut *mut glib::GError,
2612 ) -> gboolean;
2613 #[cfg(feature = "v2020_8")]
2614 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_8")))]
2615 pub fn ostree_repo_static_delta_reindex(
2616 repo: *mut OstreeRepo,
2617 flags: OstreeStaticDeltaIndexFlags,
2618 opt_to_commit: *const c_char,
2619 cancellable: *mut gio::GCancellable,
2620 error: *mut *mut glib::GError,
2621 ) -> gboolean;
2622 #[cfg(feature = "v2020_7")]
2623 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
2624 pub fn ostree_repo_static_delta_verify_signature(
2625 self_: *mut OstreeRepo,
2626 delta_id: *const c_char,
2627 sign: *mut OstreeSign,
2628 out_success_message: *mut *mut c_char,
2629 error: *mut *mut glib::GError,
2630 ) -> gboolean;
2631 #[cfg(feature = "v2018_6")]
2632 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2633 pub fn ostree_repo_transaction_set_collection_ref(
2634 self_: *mut OstreeRepo,
2635 ref_: *const OstreeCollectionRef,
2636 checksum: *const c_char,
2637 );
2638 pub fn ostree_repo_transaction_set_ref(
2639 self_: *mut OstreeRepo,
2640 remote: *const c_char,
2641 ref_: *const c_char,
2642 checksum: *const c_char,
2643 );
2644 pub fn ostree_repo_transaction_set_refspec(
2645 self_: *mut OstreeRepo,
2646 refspec: *const c_char,
2647 checksum: *const c_char,
2648 );
2649 pub fn ostree_repo_traverse_commit(
2650 repo: *mut OstreeRepo,
2651 commit_checksum: *const c_char,
2652 maxdepth: c_int,
2653 out_reachable: *mut *mut glib::GHashTable,
2654 cancellable: *mut gio::GCancellable,
2655 error: *mut *mut glib::GError,
2656 ) -> gboolean;
2657 pub fn ostree_repo_traverse_commit_union(
2658 repo: *mut OstreeRepo,
2659 commit_checksum: *const c_char,
2660 maxdepth: c_int,
2661 inout_reachable: *mut glib::GHashTable,
2662 cancellable: *mut gio::GCancellable,
2663 error: *mut *mut glib::GError,
2664 ) -> gboolean;
2665 #[cfg(feature = "v2018_5")]
2666 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
2667 pub fn ostree_repo_traverse_commit_union_with_parents(
2668 repo: *mut OstreeRepo,
2669 commit_checksum: *const c_char,
2670 maxdepth: c_int,
2671 inout_reachable: *mut glib::GHashTable,
2672 inout_parents: *mut glib::GHashTable,
2673 cancellable: *mut gio::GCancellable,
2674 error: *mut *mut glib::GError,
2675 ) -> gboolean;
2676 #[cfg(feature = "v2018_5")]
2677 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
2678 pub fn ostree_repo_traverse_commit_with_flags(
2679 repo: *mut OstreeRepo,
2680 flags: OstreeRepoCommitTraverseFlags,
2681 commit_checksum: *const c_char,
2682 maxdepth: c_int,
2683 inout_reachable: *mut glib::GHashTable,
2684 inout_parents: *mut glib::GHashTable,
2685 cancellable: *mut gio::GCancellable,
2686 error: *mut *mut glib::GError,
2687 ) -> gboolean;
2688 #[cfg(feature = "v2018_6")]
2689 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2690 pub fn ostree_repo_traverse_reachable_refs(
2691 self_: *mut OstreeRepo,
2692 depth: c_uint,
2693 reachable: *mut glib::GHashTable,
2694 cancellable: *mut gio::GCancellable,
2695 error: *mut *mut glib::GError,
2696 ) -> gboolean;
2697 pub fn ostree_repo_verify_commit(
2698 self_: *mut OstreeRepo,
2699 commit_checksum: *const c_char,
2700 keyringdir: *mut gio::GFile,
2701 extra_keyring: *mut gio::GFile,
2702 cancellable: *mut gio::GCancellable,
2703 error: *mut *mut glib::GError,
2704 ) -> gboolean;
2705 pub fn ostree_repo_verify_commit_ext(
2706 self_: *mut OstreeRepo,
2707 commit_checksum: *const c_char,
2708 keyringdir: *mut gio::GFile,
2709 extra_keyring: *mut gio::GFile,
2710 cancellable: *mut gio::GCancellable,
2711 error: *mut *mut glib::GError,
2712 ) -> *mut OstreeGpgVerifyResult;
2713 #[cfg(feature = "v2016_14")]
2714 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_14")))]
2715 pub fn ostree_repo_verify_commit_for_remote(
2716 self_: *mut OstreeRepo,
2717 commit_checksum: *const c_char,
2718 remote_name: *const c_char,
2719 cancellable: *mut gio::GCancellable,
2720 error: *mut *mut glib::GError,
2721 ) -> *mut OstreeGpgVerifyResult;
2722 pub fn ostree_repo_verify_summary(
2723 self_: *mut OstreeRepo,
2724 remote_name: *const c_char,
2725 summary: *mut glib::GBytes,
2726 signatures: *mut glib::GBytes,
2727 cancellable: *mut gio::GCancellable,
2728 error: *mut *mut glib::GError,
2729 ) -> *mut OstreeGpgVerifyResult;
2730 pub fn ostree_repo_write_archive_to_mtree(
2731 self_: *mut OstreeRepo,
2732 archive: *mut gio::GFile,
2733 mtree: *mut OstreeMutableTree,
2734 modifier: *mut OstreeRepoCommitModifier,
2735 autocreate_parents: gboolean,
2736 cancellable: *mut gio::GCancellable,
2737 error: *mut *mut glib::GError,
2738 ) -> gboolean;
2739 pub fn ostree_repo_write_archive_to_mtree_from_fd(
2740 self_: *mut OstreeRepo,
2741 fd: c_int,
2742 mtree: *mut OstreeMutableTree,
2743 modifier: *mut OstreeRepoCommitModifier,
2744 autocreate_parents: gboolean,
2745 cancellable: *mut gio::GCancellable,
2746 error: *mut *mut glib::GError,
2747 ) -> gboolean;
2748 pub fn ostree_repo_write_commit(
2749 self_: *mut OstreeRepo,
2750 parent: *const c_char,
2751 subject: *const c_char,
2752 body: *const c_char,
2753 metadata: *mut glib::GVariant,
2754 root: *mut OstreeRepoFile,
2755 out_commit: *mut *mut c_char,
2756 cancellable: *mut gio::GCancellable,
2757 error: *mut *mut glib::GError,
2758 ) -> gboolean;
2759 pub fn ostree_repo_write_commit_detached_metadata(
2760 self_: *mut OstreeRepo,
2761 checksum: *const c_char,
2762 metadata: *mut glib::GVariant,
2763 cancellable: *mut gio::GCancellable,
2764 error: *mut *mut glib::GError,
2765 ) -> gboolean;
2766 pub fn ostree_repo_write_commit_with_time(
2767 self_: *mut OstreeRepo,
2768 parent: *const c_char,
2769 subject: *const c_char,
2770 body: *const c_char,
2771 metadata: *mut glib::GVariant,
2772 root: *mut OstreeRepoFile,
2773 time: u64,
2774 out_commit: *mut *mut c_char,
2775 cancellable: *mut gio::GCancellable,
2776 error: *mut *mut glib::GError,
2777 ) -> gboolean;
2778 pub fn ostree_repo_write_config(
2779 self_: *mut OstreeRepo,
2780 new_config: *mut glib::GKeyFile,
2781 error: *mut *mut glib::GError,
2782 ) -> gboolean;
2783 pub fn ostree_repo_write_content(
2784 self_: *mut OstreeRepo,
2785 expected_checksum: *const c_char,
2786 object_input: *mut gio::GInputStream,
2787 length: u64,
2788 out_csum: *mut *mut [*mut u8; 32],
2789 cancellable: *mut gio::GCancellable,
2790 error: *mut *mut glib::GError,
2791 ) -> gboolean;
2792 pub fn ostree_repo_write_content_async(
2793 self_: *mut OstreeRepo,
2794 expected_checksum: *const c_char,
2795 object: *mut gio::GInputStream,
2796 length: u64,
2797 cancellable: *mut gio::GCancellable,
2798 callback: gio::GAsyncReadyCallback,
2799 user_data: gpointer,
2800 );
2801 pub fn ostree_repo_write_content_finish(
2802 self_: *mut OstreeRepo,
2803 result: *mut gio::GAsyncResult,
2804 out_csum: *mut *mut u8,
2805 error: *mut *mut glib::GError,
2806 ) -> gboolean;
2807 pub fn ostree_repo_write_content_trusted(
2808 self_: *mut OstreeRepo,
2809 checksum: *const c_char,
2810 object_input: *mut gio::GInputStream,
2811 length: u64,
2812 cancellable: *mut gio::GCancellable,
2813 error: *mut *mut glib::GError,
2814 ) -> gboolean;
2815 pub fn ostree_repo_write_dfd_to_mtree(
2816 self_: *mut OstreeRepo,
2817 dfd: c_int,
2818 path: *const c_char,
2819 mtree: *mut OstreeMutableTree,
2820 modifier: *mut OstreeRepoCommitModifier,
2821 cancellable: *mut gio::GCancellable,
2822 error: *mut *mut glib::GError,
2823 ) -> gboolean;
2824 pub fn ostree_repo_write_directory_to_mtree(
2825 self_: *mut OstreeRepo,
2826 dir: *mut gio::GFile,
2827 mtree: *mut OstreeMutableTree,
2828 modifier: *mut OstreeRepoCommitModifier,
2829 cancellable: *mut gio::GCancellable,
2830 error: *mut *mut glib::GError,
2831 ) -> gboolean;
2832 pub fn ostree_repo_write_metadata(
2833 self_: *mut OstreeRepo,
2834 objtype: OstreeObjectType,
2835 expected_checksum: *const c_char,
2836 object: *mut glib::GVariant,
2837 out_csum: *mut *mut [*mut u8; 32],
2838 cancellable: *mut gio::GCancellable,
2839 error: *mut *mut glib::GError,
2840 ) -> gboolean;
2841 pub fn ostree_repo_write_metadata_async(
2842 self_: *mut OstreeRepo,
2843 objtype: OstreeObjectType,
2844 expected_checksum: *const c_char,
2845 object: *mut glib::GVariant,
2846 cancellable: *mut gio::GCancellable,
2847 callback: gio::GAsyncReadyCallback,
2848 user_data: gpointer,
2849 );
2850 pub fn ostree_repo_write_metadata_finish(
2851 self_: *mut OstreeRepo,
2852 result: *mut gio::GAsyncResult,
2853 out_csum: *mut *mut [c_uchar; 32],
2854 error: *mut *mut glib::GError,
2855 ) -> gboolean;
2856 pub fn ostree_repo_write_metadata_stream_trusted(
2857 self_: *mut OstreeRepo,
2858 objtype: OstreeObjectType,
2859 checksum: *const c_char,
2860 object_input: *mut gio::GInputStream,
2861 length: u64,
2862 cancellable: *mut gio::GCancellable,
2863 error: *mut *mut glib::GError,
2864 ) -> gboolean;
2865 pub fn ostree_repo_write_metadata_trusted(
2866 self_: *mut OstreeRepo,
2867 objtype: OstreeObjectType,
2868 checksum: *const c_char,
2869 variant: *mut glib::GVariant,
2870 cancellable: *mut gio::GCancellable,
2871 error: *mut *mut glib::GError,
2872 ) -> gboolean;
2873 pub fn ostree_repo_write_mtree(
2874 self_: *mut OstreeRepo,
2875 mtree: *mut OstreeMutableTree,
2876 out_file: *mut *mut gio::GFile,
2877 cancellable: *mut gio::GCancellable,
2878 error: *mut *mut glib::GError,
2879 ) -> gboolean;
2880 #[cfg(feature = "v2021_2")]
2881 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_2")))]
2882 pub fn ostree_repo_write_regfile(
2883 self_: *mut OstreeRepo,
2884 expected_checksum: *const c_char,
2885 uid: u32,
2886 gid: u32,
2887 mode: u32,
2888 content_len: u64,
2889 xattrs: *mut glib::GVariant,
2890 error: *mut *mut glib::GError,
2891 ) -> *mut OstreeContentWriter;
2892 #[cfg(feature = "v2021_2")]
2893 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_2")))]
2894 pub fn ostree_repo_write_regfile_inline(
2895 self_: *mut OstreeRepo,
2896 expected_checksum: *const c_char,
2897 uid: u32,
2898 gid: u32,
2899 mode: u32,
2900 xattrs: *mut glib::GVariant,
2901 buf: *const u8,
2902 len: size_t,
2903 cancellable: *mut gio::GCancellable,
2904 error: *mut *mut glib::GError,
2905 ) -> *mut c_char;
2906 #[cfg(feature = "v2021_2")]
2907 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_2")))]
2908 pub fn ostree_repo_write_symlink(
2909 self_: *mut OstreeRepo,
2910 expected_checksum: *const c_char,
2911 uid: u32,
2912 gid: u32,
2913 xattrs: *mut glib::GVariant,
2914 symlink_target: *const c_char,
2915 cancellable: *mut gio::GCancellable,
2916 error: *mut *mut glib::GError,
2917 ) -> *mut c_char;
2918
2919 pub fn ostree_repo_file_get_type() -> GType;
2923 pub fn ostree_repo_file_ensure_resolved(
2924 self_: *mut OstreeRepoFile,
2925 error: *mut *mut glib::GError,
2926 ) -> gboolean;
2927 pub fn ostree_repo_file_get_checksum(self_: *mut OstreeRepoFile) -> *const c_char;
2928 pub fn ostree_repo_file_get_repo(self_: *mut OstreeRepoFile) -> *mut OstreeRepo;
2929 pub fn ostree_repo_file_get_root(self_: *mut OstreeRepoFile) -> *mut OstreeRepoFile;
2930 pub fn ostree_repo_file_get_xattrs(
2931 self_: *mut OstreeRepoFile,
2932 out_xattrs: *mut *mut glib::GVariant,
2933 cancellable: *mut gio::GCancellable,
2934 error: *mut *mut glib::GError,
2935 ) -> gboolean;
2936 pub fn ostree_repo_file_tree_find_child(
2937 self_: *mut OstreeRepoFile,
2938 name: *const c_char,
2939 is_dir: *mut gboolean,
2940 out_container: *mut *mut glib::GVariant,
2941 ) -> c_int;
2942 pub fn ostree_repo_file_tree_get_contents(self_: *mut OstreeRepoFile) -> *mut glib::GVariant;
2943 pub fn ostree_repo_file_tree_get_contents_checksum(self_: *mut OstreeRepoFile)
2944 -> *const c_char;
2945 pub fn ostree_repo_file_tree_get_metadata(self_: *mut OstreeRepoFile) -> *mut glib::GVariant;
2946 pub fn ostree_repo_file_tree_get_metadata_checksum(self_: *mut OstreeRepoFile)
2947 -> *const c_char;
2948 pub fn ostree_repo_file_tree_query_child(
2949 self_: *mut OstreeRepoFile,
2950 n: c_int,
2951 attributes: *const c_char,
2952 flags: gio::GFileQueryInfoFlags,
2953 out_info: *mut *mut gio::GFileInfo,
2954 cancellable: *mut gio::GCancellable,
2955 error: *mut *mut glib::GError,
2956 ) -> gboolean;
2957 pub fn ostree_repo_file_tree_set_metadata(
2958 self_: *mut OstreeRepoFile,
2959 checksum: *const c_char,
2960 metadata: *mut glib::GVariant,
2961 );
2962
2963 pub fn ostree_repo_finder_avahi_get_type() -> GType;
2967 #[cfg(feature = "v2018_6")]
2968 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2969 pub fn ostree_repo_finder_avahi_new(
2970 context: *mut glib::GMainContext,
2971 ) -> *mut OstreeRepoFinderAvahi;
2972 #[cfg(feature = "v2018_6")]
2973 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2974 pub fn ostree_repo_finder_avahi_start(
2975 self_: *mut OstreeRepoFinderAvahi,
2976 error: *mut *mut glib::GError,
2977 );
2978 #[cfg(feature = "v2018_6")]
2979 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2980 pub fn ostree_repo_finder_avahi_stop(self_: *mut OstreeRepoFinderAvahi);
2981
2982 pub fn ostree_repo_finder_config_get_type() -> GType;
2986 #[cfg(feature = "v2018_6")]
2987 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2988 pub fn ostree_repo_finder_config_new() -> *mut OstreeRepoFinderConfig;
2989
2990 pub fn ostree_repo_finder_mount_get_type() -> GType;
2994 #[cfg(feature = "v2018_6")]
2995 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2996 pub fn ostree_repo_finder_mount_new(
2997 monitor: *mut gio::GVolumeMonitor,
2998 ) -> *mut OstreeRepoFinderMount;
2999
3000 pub fn ostree_repo_finder_override_get_type() -> GType;
3004 #[cfg(feature = "v2018_6")]
3005 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3006 pub fn ostree_repo_finder_override_new() -> *mut OstreeRepoFinderOverride;
3007 #[cfg(feature = "v2018_6")]
3008 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3009 pub fn ostree_repo_finder_override_add_uri(
3010 self_: *mut OstreeRepoFinderOverride,
3011 uri: *const c_char,
3012 );
3013
3014 pub fn ostree_sepolicy_get_type() -> GType;
3018 pub fn ostree_sepolicy_new(
3019 path: *mut gio::GFile,
3020 cancellable: *mut gio::GCancellable,
3021 error: *mut *mut glib::GError,
3022 ) -> *mut OstreeSePolicy;
3023 #[cfg(feature = "v2017_4")]
3024 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3025 pub fn ostree_sepolicy_new_at(
3026 rootfs_dfd: c_int,
3027 cancellable: *mut gio::GCancellable,
3028 error: *mut *mut glib::GError,
3029 ) -> *mut OstreeSePolicy;
3030 pub fn ostree_sepolicy_new_from_commit(
3031 repo: *mut OstreeRepo,
3032 rev: *const c_char,
3033 cancellable: *mut gio::GCancellable,
3034 error: *mut *mut glib::GError,
3035 ) -> *mut OstreeSePolicy;
3036 pub fn ostree_sepolicy_fscreatecon_cleanup(unused: *mut *mut c_void);
3037 #[cfg(feature = "v2025_2")]
3038 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_2")))]
3039 pub fn ostree_sepolicy_set_null_log();
3040 #[cfg(feature = "v2016_5")]
3041 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
3042 pub fn ostree_sepolicy_get_csum(self_: *mut OstreeSePolicy) -> *const c_char;
3043 pub fn ostree_sepolicy_get_label(
3044 self_: *mut OstreeSePolicy,
3045 relpath: *const c_char,
3046 unix_mode: u32,
3047 out_label: *mut *mut c_char,
3048 cancellable: *mut gio::GCancellable,
3049 error: *mut *mut glib::GError,
3050 ) -> gboolean;
3051 pub fn ostree_sepolicy_get_name(self_: *mut OstreeSePolicy) -> *const c_char;
3052 pub fn ostree_sepolicy_get_path(self_: *mut OstreeSePolicy) -> *mut gio::GFile;
3053 pub fn ostree_sepolicy_restorecon(
3054 self_: *mut OstreeSePolicy,
3055 path: *const c_char,
3056 info: *mut gio::GFileInfo,
3057 target: *mut gio::GFile,
3058 flags: OstreeSePolicyRestoreconFlags,
3059 out_new_label: *mut *mut c_char,
3060 cancellable: *mut gio::GCancellable,
3061 error: *mut *mut glib::GError,
3062 ) -> gboolean;
3063 pub fn ostree_sepolicy_setfscreatecon(
3064 self_: *mut OstreeSePolicy,
3065 path: *const c_char,
3066 mode: u32,
3067 error: *mut *mut glib::GError,
3068 ) -> gboolean;
3069
3070 pub fn ostree_sysroot_get_type() -> GType;
3074 pub fn ostree_sysroot_new(path: *mut gio::GFile) -> *mut OstreeSysroot;
3075 pub fn ostree_sysroot_new_default() -> *mut OstreeSysroot;
3076 pub fn ostree_sysroot_get_deployment_origin_path(
3077 deployment_path: *mut gio::GFile,
3078 ) -> *mut gio::GFile;
3079 #[cfg(feature = "v2023_8")]
3080 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_8")))]
3081 pub fn ostree_sysroot_change_finalization(
3082 self_: *mut OstreeSysroot,
3083 deployment: *mut OstreeDeployment,
3084 error: *mut *mut glib::GError,
3085 ) -> gboolean;
3086 pub fn ostree_sysroot_cleanup(
3087 self_: *mut OstreeSysroot,
3088 cancellable: *mut gio::GCancellable,
3089 error: *mut *mut glib::GError,
3090 ) -> gboolean;
3091 #[cfg(feature = "v2018_6")]
3092 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3093 pub fn ostree_sysroot_cleanup_prune_repo(
3094 sysroot: *mut OstreeSysroot,
3095 options: *mut OstreeRepoPruneOptions,
3096 out_objects_total: *mut c_int,
3097 out_objects_pruned: *mut c_int,
3098 out_pruned_object_size_total: *mut u64,
3099 cancellable: *mut gio::GCancellable,
3100 error: *mut *mut glib::GError,
3101 ) -> gboolean;
3102 #[cfg(feature = "v2018_5")]
3103 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
3104 pub fn ostree_sysroot_deploy_tree(
3105 self_: *mut OstreeSysroot,
3106 osname: *const c_char,
3107 revision: *const c_char,
3108 origin: *mut glib::GKeyFile,
3109 provided_merge_deployment: *mut OstreeDeployment,
3110 override_kernel_argv: *mut *mut c_char,
3111 out_new_deployment: *mut *mut OstreeDeployment,
3112 cancellable: *mut gio::GCancellable,
3113 error: *mut *mut glib::GError,
3114 ) -> gboolean;
3115 #[cfg(feature = "v2020_7")]
3116 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
3117 pub fn ostree_sysroot_deploy_tree_with_options(
3118 self_: *mut OstreeSysroot,
3119 osname: *const c_char,
3120 revision: *const c_char,
3121 origin: *mut glib::GKeyFile,
3122 provided_merge_deployment: *mut OstreeDeployment,
3123 opts: *mut OstreeSysrootDeployTreeOpts,
3124 out_new_deployment: *mut *mut OstreeDeployment,
3125 cancellable: *mut gio::GCancellable,
3126 error: *mut *mut glib::GError,
3127 ) -> gboolean;
3128 #[cfg(feature = "v2025_1")]
3129 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_1")))]
3130 pub fn ostree_sysroot_deployment_kexec_load(
3131 self_: *mut OstreeSysroot,
3132 deployment: *mut OstreeDeployment,
3133 cancellable: *mut gio::GCancellable,
3134 error: *mut *mut glib::GError,
3135 ) -> gboolean;
3136 pub fn ostree_sysroot_deployment_set_kargs(
3137 self_: *mut OstreeSysroot,
3138 deployment: *mut OstreeDeployment,
3139 new_kargs: *mut *mut c_char,
3140 cancellable: *mut gio::GCancellable,
3141 error: *mut *mut glib::GError,
3142 ) -> gboolean;
3143 pub fn ostree_sysroot_deployment_set_kargs_in_place(
3144 self_: *mut OstreeSysroot,
3145 deployment: *mut OstreeDeployment,
3146 kargs_str: *mut c_char,
3147 cancellable: *mut gio::GCancellable,
3148 error: *mut *mut glib::GError,
3149 ) -> gboolean;
3150 pub fn ostree_sysroot_deployment_set_mutable(
3151 self_: *mut OstreeSysroot,
3152 deployment: *mut OstreeDeployment,
3153 is_mutable: gboolean,
3154 cancellable: *mut gio::GCancellable,
3155 error: *mut *mut glib::GError,
3156 ) -> gboolean;
3157 #[cfg(feature = "v2018_3")]
3158 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
3159 pub fn ostree_sysroot_deployment_set_pinned(
3160 self_: *mut OstreeSysroot,
3161 deployment: *mut OstreeDeployment,
3162 is_pinned: gboolean,
3163 error: *mut *mut glib::GError,
3164 ) -> gboolean;
3165 #[cfg(feature = "v2016_4")]
3166 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
3167 pub fn ostree_sysroot_deployment_unlock(
3168 self_: *mut OstreeSysroot,
3169 deployment: *mut OstreeDeployment,
3170 unlocked_state: OstreeDeploymentUnlockedState,
3171 cancellable: *mut gio::GCancellable,
3172 error: *mut *mut glib::GError,
3173 ) -> gboolean;
3174 pub fn ostree_sysroot_ensure_initialized(
3175 self_: *mut OstreeSysroot,
3176 cancellable: *mut gio::GCancellable,
3177 error: *mut *mut glib::GError,
3178 ) -> gboolean;
3179 pub fn ostree_sysroot_get_booted_deployment(self_: *mut OstreeSysroot)
3180 -> *mut OstreeDeployment;
3181 pub fn ostree_sysroot_get_bootversion(self_: *mut OstreeSysroot) -> c_int;
3182 pub fn ostree_sysroot_get_deployment_directory(
3183 self_: *mut OstreeSysroot,
3184 deployment: *mut OstreeDeployment,
3185 ) -> *mut gio::GFile;
3186 pub fn ostree_sysroot_get_deployment_dirpath(
3187 self_: *mut OstreeSysroot,
3188 deployment: *mut OstreeDeployment,
3189 ) -> *mut c_char;
3190 pub fn ostree_sysroot_get_deployments(self_: *mut OstreeSysroot) -> *mut glib::GPtrArray;
3191 pub fn ostree_sysroot_get_fd(self_: *mut OstreeSysroot) -> c_int;
3192 pub fn ostree_sysroot_get_merge_deployment(
3193 self_: *mut OstreeSysroot,
3194 osname: *const c_char,
3195 ) -> *mut OstreeDeployment;
3196 pub fn ostree_sysroot_get_path(self_: *mut OstreeSysroot) -> *mut gio::GFile;
3197 pub fn ostree_sysroot_get_repo(
3198 self_: *mut OstreeSysroot,
3199 out_repo: *mut *mut OstreeRepo,
3200 cancellable: *mut gio::GCancellable,
3201 error: *mut *mut glib::GError,
3202 ) -> gboolean;
3203 #[cfg(feature = "v2018_5")]
3204 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
3205 pub fn ostree_sysroot_get_staged_deployment(self_: *mut OstreeSysroot)
3206 -> *mut OstreeDeployment;
3207 pub fn ostree_sysroot_get_subbootversion(self_: *mut OstreeSysroot) -> c_int;
3208 #[cfg(feature = "v2016_4")]
3209 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
3210 pub fn ostree_sysroot_init_osname(
3211 self_: *mut OstreeSysroot,
3212 osname: *const c_char,
3213 cancellable: *mut gio::GCancellable,
3214 error: *mut *mut glib::GError,
3215 ) -> gboolean;
3216 #[cfg(feature = "v2020_1")]
3217 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3218 pub fn ostree_sysroot_initialize(
3219 self_: *mut OstreeSysroot,
3220 error: *mut *mut glib::GError,
3221 ) -> gboolean;
3222 #[cfg(feature = "v2022_7")]
3223 #[cfg_attr(docsrs, doc(cfg(feature = "v2022_7")))]
3224 pub fn ostree_sysroot_initialize_with_mount_namespace(
3225 self_: *mut OstreeSysroot,
3226 cancellable: *mut gio::GCancellable,
3227 error: *mut *mut glib::GError,
3228 ) -> gboolean;
3229 #[cfg(feature = "v2020_1")]
3230 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3231 pub fn ostree_sysroot_is_booted(self_: *mut OstreeSysroot) -> gboolean;
3232 pub fn ostree_sysroot_load(
3233 self_: *mut OstreeSysroot,
3234 cancellable: *mut gio::GCancellable,
3235 error: *mut *mut glib::GError,
3236 ) -> gboolean;
3237 #[cfg(feature = "v2016_4")]
3238 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
3239 pub fn ostree_sysroot_load_if_changed(
3240 self_: *mut OstreeSysroot,
3241 out_changed: *mut gboolean,
3242 cancellable: *mut gio::GCancellable,
3243 error: *mut *mut glib::GError,
3244 ) -> gboolean;
3245 pub fn ostree_sysroot_lock(
3246 self_: *mut OstreeSysroot,
3247 error: *mut *mut glib::GError,
3248 ) -> gboolean;
3249 pub fn ostree_sysroot_lock_async(
3250 self_: *mut OstreeSysroot,
3251 cancellable: *mut gio::GCancellable,
3252 callback: gio::GAsyncReadyCallback,
3253 user_data: gpointer,
3254 );
3255 pub fn ostree_sysroot_lock_finish(
3256 self_: *mut OstreeSysroot,
3257 result: *mut gio::GAsyncResult,
3258 error: *mut *mut glib::GError,
3259 ) -> gboolean;
3260 pub fn ostree_sysroot_origin_new_from_refspec(
3261 self_: *mut OstreeSysroot,
3262 refspec: *const c_char,
3263 ) -> *mut glib::GKeyFile;
3264 pub fn ostree_sysroot_prepare_cleanup(
3265 self_: *mut OstreeSysroot,
3266 cancellable: *mut gio::GCancellable,
3267 error: *mut *mut glib::GError,
3268 ) -> gboolean;
3269 #[cfg(feature = "v2017_7")]
3270 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_7")))]
3271 pub fn ostree_sysroot_query_deployments_for(
3272 self_: *mut OstreeSysroot,
3273 osname: *const c_char,
3274 out_pending: *mut *mut OstreeDeployment,
3275 out_rollback: *mut *mut OstreeDeployment,
3276 );
3277 #[cfg(feature = "v2017_7")]
3278 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_7")))]
3279 pub fn ostree_sysroot_repo(self_: *mut OstreeSysroot) -> *mut OstreeRepo;
3280 #[cfg(feature = "v2021_1")]
3281 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_1")))]
3282 pub fn ostree_sysroot_require_booted_deployment(
3283 self_: *mut OstreeSysroot,
3284 error: *mut *mut glib::GError,
3285 ) -> *mut OstreeDeployment;
3286 #[cfg(feature = "v2020_1")]
3287 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3288 pub fn ostree_sysroot_set_mount_namespace_in_use(self_: *mut OstreeSysroot);
3289 pub fn ostree_sysroot_simple_write_deployment(
3290 sysroot: *mut OstreeSysroot,
3291 osname: *const c_char,
3292 new_deployment: *mut OstreeDeployment,
3293 merge_deployment: *mut OstreeDeployment,
3294 flags: OstreeSysrootSimpleWriteDeploymentFlags,
3295 cancellable: *mut gio::GCancellable,
3296 error: *mut *mut glib::GError,
3297 ) -> gboolean;
3298 #[cfg(feature = "v2020_7")]
3299 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
3300 pub fn ostree_sysroot_stage_overlay_initrd(
3301 self_: *mut OstreeSysroot,
3302 fd: c_int,
3303 out_checksum: *mut *mut c_char,
3304 cancellable: *mut gio::GCancellable,
3305 error: *mut *mut glib::GError,
3306 ) -> gboolean;
3307 #[cfg(feature = "v2018_5")]
3308 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
3309 pub fn ostree_sysroot_stage_tree(
3310 self_: *mut OstreeSysroot,
3311 osname: *const c_char,
3312 revision: *const c_char,
3313 origin: *mut glib::GKeyFile,
3314 merge_deployment: *mut OstreeDeployment,
3315 override_kernel_argv: *mut *mut c_char,
3316 out_new_deployment: *mut *mut OstreeDeployment,
3317 cancellable: *mut gio::GCancellable,
3318 error: *mut *mut glib::GError,
3319 ) -> gboolean;
3320 #[cfg(feature = "v2020_7")]
3321 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
3322 pub fn ostree_sysroot_stage_tree_with_options(
3323 self_: *mut OstreeSysroot,
3324 osname: *const c_char,
3325 revision: *const c_char,
3326 origin: *mut glib::GKeyFile,
3327 merge_deployment: *mut OstreeDeployment,
3328 opts: *mut OstreeSysrootDeployTreeOpts,
3329 out_new_deployment: *mut *mut OstreeDeployment,
3330 cancellable: *mut gio::GCancellable,
3331 error: *mut *mut glib::GError,
3332 ) -> gboolean;
3333 pub fn ostree_sysroot_try_lock(
3334 self_: *mut OstreeSysroot,
3335 out_acquired: *mut gboolean,
3336 error: *mut *mut glib::GError,
3337 ) -> gboolean;
3338 pub fn ostree_sysroot_unload(self_: *mut OstreeSysroot);
3339 pub fn ostree_sysroot_unlock(self_: *mut OstreeSysroot);
3340 #[cfg(feature = "v2023_11")]
3341 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_11")))]
3342 pub fn ostree_sysroot_update_post_copy(
3343 self_: *mut OstreeSysroot,
3344 cancellable: *mut gio::GCancellable,
3345 error: *mut *mut glib::GError,
3346 ) -> gboolean;
3347 pub fn ostree_sysroot_write_deployments(
3348 self_: *mut OstreeSysroot,
3349 new_deployments: *mut glib::GPtrArray,
3350 cancellable: *mut gio::GCancellable,
3351 error: *mut *mut glib::GError,
3352 ) -> gboolean;
3353 #[cfg(feature = "v2017_4")]
3354 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3355 pub fn ostree_sysroot_write_deployments_with_options(
3356 self_: *mut OstreeSysroot,
3357 new_deployments: *mut glib::GPtrArray,
3358 opts: *mut OstreeSysrootWriteDeploymentsOpts,
3359 cancellable: *mut gio::GCancellable,
3360 error: *mut *mut glib::GError,
3361 ) -> gboolean;
3362 pub fn ostree_sysroot_write_origin_file(
3363 sysroot: *mut OstreeSysroot,
3364 deployment: *mut OstreeDeployment,
3365 new_origin: *mut glib::GKeyFile,
3366 cancellable: *mut gio::GCancellable,
3367 error: *mut *mut glib::GError,
3368 ) -> gboolean;
3369
3370 pub fn ostree_sysroot_upgrader_get_type() -> GType;
3374 pub fn ostree_sysroot_upgrader_new(
3375 sysroot: *mut OstreeSysroot,
3376 cancellable: *mut gio::GCancellable,
3377 error: *mut *mut glib::GError,
3378 ) -> *mut OstreeSysrootUpgrader;
3379 pub fn ostree_sysroot_upgrader_new_for_os(
3380 sysroot: *mut OstreeSysroot,
3381 osname: *const c_char,
3382 cancellable: *mut gio::GCancellable,
3383 error: *mut *mut glib::GError,
3384 ) -> *mut OstreeSysrootUpgrader;
3385 pub fn ostree_sysroot_upgrader_new_for_os_with_flags(
3386 sysroot: *mut OstreeSysroot,
3387 osname: *const c_char,
3388 flags: OstreeSysrootUpgraderFlags,
3389 cancellable: *mut gio::GCancellable,
3390 error: *mut *mut glib::GError,
3391 ) -> *mut OstreeSysrootUpgrader;
3392 pub fn ostree_sysroot_upgrader_check_timestamps(
3393 repo: *mut OstreeRepo,
3394 from_rev: *const c_char,
3395 to_rev: *const c_char,
3396 error: *mut *mut glib::GError,
3397 ) -> gboolean;
3398 pub fn ostree_sysroot_upgrader_deploy(
3399 self_: *mut OstreeSysrootUpgrader,
3400 cancellable: *mut gio::GCancellable,
3401 error: *mut *mut glib::GError,
3402 ) -> gboolean;
3403 pub fn ostree_sysroot_upgrader_dup_origin(
3404 self_: *mut OstreeSysrootUpgrader,
3405 ) -> *mut glib::GKeyFile;
3406 pub fn ostree_sysroot_upgrader_get_origin(
3407 self_: *mut OstreeSysrootUpgrader,
3408 ) -> *mut glib::GKeyFile;
3409 pub fn ostree_sysroot_upgrader_get_origin_description(
3410 self_: *mut OstreeSysrootUpgrader,
3411 ) -> *mut c_char;
3412 pub fn ostree_sysroot_upgrader_pull(
3413 self_: *mut OstreeSysrootUpgrader,
3414 flags: OstreeRepoPullFlags,
3415 upgrader_flags: OstreeSysrootUpgraderPullFlags,
3416 progress: *mut OstreeAsyncProgress,
3417 out_changed: *mut gboolean,
3418 cancellable: *mut gio::GCancellable,
3419 error: *mut *mut glib::GError,
3420 ) -> gboolean;
3421 pub fn ostree_sysroot_upgrader_pull_one_dir(
3422 self_: *mut OstreeSysrootUpgrader,
3423 dir_to_pull: *const c_char,
3424 flags: OstreeRepoPullFlags,
3425 upgrader_flags: OstreeSysrootUpgraderPullFlags,
3426 progress: *mut OstreeAsyncProgress,
3427 out_changed: *mut gboolean,
3428 cancellable: *mut gio::GCancellable,
3429 error: *mut *mut glib::GError,
3430 ) -> gboolean;
3431 pub fn ostree_sysroot_upgrader_set_origin(
3432 self_: *mut OstreeSysrootUpgrader,
3433 origin: *mut glib::GKeyFile,
3434 cancellable: *mut gio::GCancellable,
3435 error: *mut *mut glib::GError,
3436 ) -> gboolean;
3437
3438 pub fn ostree_blob_reader_get_type() -> GType;
3442 pub fn ostree_blob_reader_read_blob(
3443 self_: *mut OstreeBlobReader,
3444 cancellable: *mut gio::GCancellable,
3445 error: *mut *mut glib::GError,
3446 ) -> *mut glib::GBytes;
3447
3448 pub fn ostree_repo_finder_get_type() -> GType;
3452 #[cfg(feature = "v2018_6")]
3453 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3454 pub fn ostree_repo_finder_resolve_all_async(
3455 finders: *const *mut OstreeRepoFinder,
3456 refs: *const *const OstreeCollectionRef,
3457 parent_repo: *mut OstreeRepo,
3458 cancellable: *mut gio::GCancellable,
3459 callback: gio::GAsyncReadyCallback,
3460 user_data: gpointer,
3461 );
3462 #[cfg(feature = "v2018_6")]
3463 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3464 pub fn ostree_repo_finder_resolve_all_finish(
3465 result: *mut gio::GAsyncResult,
3466 error: *mut *mut glib::GError,
3467 ) -> *mut glib::GPtrArray;
3468 #[cfg(feature = "v2018_6")]
3469 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3470 pub fn ostree_repo_finder_resolve_async(
3471 self_: *mut OstreeRepoFinder,
3472 refs: *const *const OstreeCollectionRef,
3473 parent_repo: *mut OstreeRepo,
3474 cancellable: *mut gio::GCancellable,
3475 callback: gio::GAsyncReadyCallback,
3476 user_data: gpointer,
3477 );
3478 #[cfg(feature = "v2018_6")]
3479 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3480 pub fn ostree_repo_finder_resolve_finish(
3481 self_: *mut OstreeRepoFinder,
3482 result: *mut gio::GAsyncResult,
3483 error: *mut *mut glib::GError,
3484 ) -> *mut glib::GPtrArray;
3485
3486 pub fn ostree_sign_get_type() -> GType;
3490 #[cfg(feature = "v2020_2")]
3491 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3492 pub fn ostree_sign_get_all() -> *mut glib::GPtrArray;
3493 #[cfg(feature = "v2020_2")]
3494 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3495 pub fn ostree_sign_get_by_name(
3496 name: *const c_char,
3497 error: *mut *mut glib::GError,
3498 ) -> *mut OstreeSign;
3499 #[cfg(feature = "v2020_2")]
3500 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3501 pub fn ostree_sign_add_pk(
3502 self_: *mut OstreeSign,
3503 public_key: *mut glib::GVariant,
3504 error: *mut *mut glib::GError,
3505 ) -> gboolean;
3506 #[cfg(feature = "v2020_2")]
3507 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3508 pub fn ostree_sign_clear_keys(
3509 self_: *mut OstreeSign,
3510 error: *mut *mut glib::GError,
3511 ) -> gboolean;
3512 #[cfg(feature = "v2020_2")]
3513 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3514 pub fn ostree_sign_commit(
3515 self_: *mut OstreeSign,
3516 repo: *mut OstreeRepo,
3517 commit_checksum: *const c_char,
3518 cancellable: *mut gio::GCancellable,
3519 error: *mut *mut glib::GError,
3520 ) -> gboolean;
3521 #[cfg(feature = "v2020_2")]
3522 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3523 pub fn ostree_sign_commit_verify(
3524 self_: *mut OstreeSign,
3525 repo: *mut OstreeRepo,
3526 commit_checksum: *const c_char,
3527 out_success_message: *mut *mut c_char,
3528 cancellable: *mut gio::GCancellable,
3529 error: *mut *mut glib::GError,
3530 ) -> gboolean;
3531 #[cfg(feature = "v2020_2")]
3532 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3533 pub fn ostree_sign_data(
3534 self_: *mut OstreeSign,
3535 data: *mut glib::GBytes,
3536 signature: *mut *mut glib::GBytes,
3537 cancellable: *mut gio::GCancellable,
3538 error: *mut *mut glib::GError,
3539 ) -> gboolean;
3540 #[cfg(feature = "v2020_2")]
3541 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3542 pub fn ostree_sign_data_verify(
3543 self_: *mut OstreeSign,
3544 data: *mut glib::GBytes,
3545 signatures: *mut glib::GVariant,
3546 out_success_message: *mut *mut c_char,
3547 error: *mut *mut glib::GError,
3548 ) -> gboolean;
3549 pub fn ostree_sign_ed25519_add_pk(
3550 self_: *mut OstreeSign,
3551 public_key: *mut glib::GVariant,
3552 error: *mut *mut glib::GError,
3553 ) -> gboolean;
3554 pub fn ostree_sign_ed25519_clear_keys(
3555 self_: *mut OstreeSign,
3556 error: *mut *mut glib::GError,
3557 ) -> gboolean;
3558 pub fn ostree_sign_ed25519_data(
3559 self_: *mut OstreeSign,
3560 data: *mut glib::GBytes,
3561 signature: *mut *mut glib::GBytes,
3562 cancellable: *mut gio::GCancellable,
3563 error: *mut *mut glib::GError,
3564 ) -> gboolean;
3565 pub fn ostree_sign_ed25519_data_verify(
3566 self_: *mut OstreeSign,
3567 data: *mut glib::GBytes,
3568 signatures: *mut glib::GVariant,
3569 out_success_message: *mut *mut c_char,
3570 error: *mut *mut glib::GError,
3571 ) -> gboolean;
3572 pub fn ostree_sign_ed25519_get_name(self_: *mut OstreeSign) -> *const c_char;
3573 pub fn ostree_sign_ed25519_load_pk(
3574 self_: *mut OstreeSign,
3575 options: *mut glib::GVariant,
3576 error: *mut *mut glib::GError,
3577 ) -> gboolean;
3578 pub fn ostree_sign_ed25519_metadata_format(self_: *mut OstreeSign) -> *const c_char;
3579 pub fn ostree_sign_ed25519_metadata_key(self_: *mut OstreeSign) -> *const c_char;
3580 pub fn ostree_sign_ed25519_set_pk(
3581 self_: *mut OstreeSign,
3582 public_key: *mut glib::GVariant,
3583 error: *mut *mut glib::GError,
3584 ) -> gboolean;
3585 pub fn ostree_sign_ed25519_set_sk(
3586 self_: *mut OstreeSign,
3587 secret_key: *mut glib::GVariant,
3588 error: *mut *mut glib::GError,
3589 ) -> gboolean;
3590 #[cfg(feature = "v2020_2")]
3591 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3592 pub fn ostree_sign_get_name(self_: *mut OstreeSign) -> *const c_char;
3593 #[cfg(feature = "v2020_2")]
3594 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3595 pub fn ostree_sign_load_pk(
3596 self_: *mut OstreeSign,
3597 options: *mut glib::GVariant,
3598 error: *mut *mut glib::GError,
3599 ) -> gboolean;
3600 #[cfg(feature = "v2020_2")]
3601 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3602 pub fn ostree_sign_metadata_format(self_: *mut OstreeSign) -> *const c_char;
3603 #[cfg(feature = "v2020_2")]
3604 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3605 pub fn ostree_sign_metadata_key(self_: *mut OstreeSign) -> *const c_char;
3606 #[cfg(feature = "v2025_2")]
3607 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_2")))]
3608 pub fn ostree_sign_read_pk(
3609 self_: *mut OstreeSign,
3610 stream: *mut gio::GInputStream,
3611 ) -> *mut OstreeBlobReader;
3612 #[cfg(feature = "v2025_2")]
3613 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_2")))]
3614 pub fn ostree_sign_read_sk(
3615 self_: *mut OstreeSign,
3616 stream: *mut gio::GInputStream,
3617 ) -> *mut OstreeBlobReader;
3618 #[cfg(feature = "v2020_2")]
3619 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3620 pub fn ostree_sign_set_pk(
3621 self_: *mut OstreeSign,
3622 public_key: *mut glib::GVariant,
3623 error: *mut *mut glib::GError,
3624 ) -> gboolean;
3625 #[cfg(feature = "v2020_2")]
3626 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3627 pub fn ostree_sign_set_sk(
3628 self_: *mut OstreeSign,
3629 secret_key: *mut glib::GVariant,
3630 error: *mut *mut glib::GError,
3631 ) -> gboolean;
3632 #[cfg(feature = "v2020_2")]
3633 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3634 pub fn ostree_sign_summary(
3635 self_: *mut OstreeSign,
3636 repo: *mut OstreeRepo,
3637 keys: *mut glib::GVariant,
3638 cancellable: *mut gio::GCancellable,
3639 error: *mut *mut glib::GError,
3640 ) -> gboolean;
3641
3642 #[cfg(feature = "v2017_15")]
3646 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_15")))]
3647 pub fn ostree_break_hardlink(
3648 dfd: c_int,
3649 path: *const c_char,
3650 skip_xattrs: gboolean,
3651 cancellable: *mut gio::GCancellable,
3652 error: *mut *mut glib::GError,
3653 ) -> gboolean;
3654 #[cfg(feature = "v2017_4")]
3655 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3656 pub fn ostree_check_version(required_year: c_uint, required_release: c_uint) -> gboolean;
3657 #[cfg(feature = "v2016_8")]
3658 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_8")))]
3659 pub fn ostree_checksum_b64_from_bytes(csum: *const [c_uchar; 32]) -> *mut c_char;
3660 pub fn ostree_checksum_b64_inplace_from_bytes(csum: *const [c_uchar; 32], buf: *mut c_char);
3661 pub fn ostree_checksum_b64_inplace_to_bytes(checksum: *const [c_char; 32], buf: *mut u8);
3662 #[cfg(feature = "v2016_8")]
3663 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_8")))]
3664 pub fn ostree_checksum_b64_to_bytes(checksum: *const c_char) -> *mut [c_uchar; 32];
3665 pub fn ostree_checksum_bytes_peek(bytes: *mut glib::GVariant) -> *const [c_uchar; 32];
3666 pub fn ostree_checksum_bytes_peek_validate(
3667 bytes: *mut glib::GVariant,
3668 error: *mut *mut glib::GError,
3669 ) -> *const [c_uchar; 32];
3670 pub fn ostree_checksum_file(
3671 f: *mut gio::GFile,
3672 objtype: OstreeObjectType,
3673 out_csum: *mut *mut [*mut u8; 32],
3674 cancellable: *mut gio::GCancellable,
3675 error: *mut *mut glib::GError,
3676 ) -> gboolean;
3677 pub fn ostree_checksum_file_async(
3678 f: *mut gio::GFile,
3679 objtype: OstreeObjectType,
3680 io_priority: c_int,
3681 cancellable: *mut gio::GCancellable,
3682 callback: gio::GAsyncReadyCallback,
3683 user_data: gpointer,
3684 );
3685 pub fn ostree_checksum_file_async_finish(
3686 f: *mut gio::GFile,
3687 result: *mut gio::GAsyncResult,
3688 out_csum: *mut *mut [*mut u8; 32],
3689 error: *mut *mut glib::GError,
3690 ) -> gboolean;
3691 #[cfg(feature = "v2017_13")]
3692 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_13")))]
3693 pub fn ostree_checksum_file_at(
3694 dfd: c_int,
3695 path: *const c_char,
3696 stbuf: *mut stat,
3697 objtype: OstreeObjectType,
3698 flags: OstreeChecksumFlags,
3699 out_checksum: *mut *mut c_char,
3700 cancellable: *mut gio::GCancellable,
3701 error: *mut *mut glib::GError,
3702 ) -> gboolean;
3703 pub fn ostree_checksum_file_from_input(
3704 file_info: *mut gio::GFileInfo,
3705 xattrs: *mut glib::GVariant,
3706 in_: *mut gio::GInputStream,
3707 objtype: OstreeObjectType,
3708 out_csum: *mut *mut [*mut u8; 32],
3709 cancellable: *mut gio::GCancellable,
3710 error: *mut *mut glib::GError,
3711 ) -> gboolean;
3712 pub fn ostree_checksum_from_bytes(csum: *const [c_uchar; 32]) -> *mut c_char;
3713 pub fn ostree_checksum_from_bytes_v(csum_v: *mut glib::GVariant) -> *mut c_char;
3714 pub fn ostree_checksum_inplace_from_bytes(csum: *const [c_uchar; 32], buf: *mut c_char);
3715 pub fn ostree_checksum_inplace_to_bytes(checksum: *const c_char, buf: *mut u8);
3716 pub fn ostree_checksum_to_bytes(checksum: *const c_char) -> *mut [c_uchar; 32];
3717 pub fn ostree_checksum_to_bytes_v(checksum: *const c_char) -> *mut glib::GVariant;
3718 pub fn ostree_cmp_checksum_bytes(a: *const u8, b: *const u8) -> c_int;
3719 #[cfg(feature = "v2018_2")]
3720 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_2")))]
3721 pub fn ostree_commit_get_content_checksum(commit_variant: *mut glib::GVariant) -> *mut c_char;
3722 #[cfg(feature = "v2020_1")]
3723 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3724 pub fn ostree_commit_get_object_sizes(
3725 commit_variant: *mut glib::GVariant,
3726 out_sizes_entries: *mut *mut glib::GPtrArray,
3727 error: *mut *mut glib::GError,
3728 ) -> gboolean;
3729 pub fn ostree_commit_get_parent(commit_variant: *mut glib::GVariant) -> *mut c_char;
3730 #[cfg(feature = "v2016_3")]
3731 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_3")))]
3732 pub fn ostree_commit_get_timestamp(commit_variant: *mut glib::GVariant) -> u64;
3733 #[cfg(feature = "v2021_1")]
3734 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_1")))]
3735 pub fn ostree_commit_metadata_for_bootable(
3736 root: *mut gio::GFile,
3737 dict: *mut glib::GVariantDict,
3738 cancellable: *mut gio::GCancellable,
3739 error: *mut *mut glib::GError,
3740 ) -> gboolean;
3741 pub fn ostree_content_file_parse(
3742 compressed: gboolean,
3743 content_path: *mut gio::GFile,
3744 trusted: gboolean,
3745 out_input: *mut *mut gio::GInputStream,
3746 out_file_info: *mut *mut gio::GFileInfo,
3747 out_xattrs: *mut *mut glib::GVariant,
3748 cancellable: *mut gio::GCancellable,
3749 error: *mut *mut glib::GError,
3750 ) -> gboolean;
3751 pub fn ostree_content_file_parse_at(
3752 compressed: gboolean,
3753 parent_dfd: c_int,
3754 path: *const c_char,
3755 trusted: gboolean,
3756 out_input: *mut *mut gio::GInputStream,
3757 out_file_info: *mut *mut gio::GFileInfo,
3758 out_xattrs: *mut *mut glib::GVariant,
3759 cancellable: *mut gio::GCancellable,
3760 error: *mut *mut glib::GError,
3761 ) -> gboolean;
3762 pub fn ostree_content_stream_parse(
3763 compressed: gboolean,
3764 input: *mut gio::GInputStream,
3765 input_length: u64,
3766 trusted: gboolean,
3767 out_input: *mut *mut gio::GInputStream,
3768 out_file_info: *mut *mut gio::GFileInfo,
3769 out_xattrs: *mut *mut glib::GVariant,
3770 cancellable: *mut gio::GCancellable,
3771 error: *mut *mut glib::GError,
3772 ) -> gboolean;
3773 pub fn ostree_create_directory_metadata(
3774 dir_info: *mut gio::GFileInfo,
3775 xattrs: *mut glib::GVariant,
3776 ) -> *mut glib::GVariant;
3777 pub fn ostree_diff_dirs(
3778 flags: OstreeDiffFlags,
3779 a: *mut gio::GFile,
3780 b: *mut gio::GFile,
3781 modified: *mut glib::GPtrArray,
3782 removed: *mut glib::GPtrArray,
3783 added: *mut glib::GPtrArray,
3784 cancellable: *mut gio::GCancellable,
3785 error: *mut *mut glib::GError,
3786 ) -> gboolean;
3787 #[cfg(feature = "v2017_4")]
3788 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3789 pub fn ostree_diff_dirs_with_options(
3790 flags: OstreeDiffFlags,
3791 a: *mut gio::GFile,
3792 b: *mut gio::GFile,
3793 modified: *mut glib::GPtrArray,
3794 removed: *mut glib::GPtrArray,
3795 added: *mut glib::GPtrArray,
3796 options: *mut OstreeDiffDirsOptions,
3797 cancellable: *mut gio::GCancellable,
3798 error: *mut *mut glib::GError,
3799 ) -> gboolean;
3800 pub fn ostree_diff_print(
3801 a: *mut gio::GFile,
3802 b: *mut gio::GFile,
3803 modified: *mut glib::GPtrArray,
3804 removed: *mut glib::GPtrArray,
3805 added: *mut glib::GPtrArray,
3806 );
3807 pub fn ostree_fs_get_all_xattrs(
3808 fd: c_int,
3809 cancellable: *mut gio::GCancellable,
3810 error: *mut *mut glib::GError,
3811 ) -> *mut glib::GVariant;
3812 pub fn ostree_fs_get_all_xattrs_at(
3813 dfd: c_int,
3814 path: *const c_char,
3815 cancellable: *mut gio::GCancellable,
3816 error: *mut *mut glib::GError,
3817 ) -> *mut glib::GVariant;
3818 #[cfg(feature = "v2017_10")]
3819 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
3820 pub fn ostree_gpg_error_quark() -> glib::GQuark;
3821 pub fn ostree_hash_object_name(a: gconstpointer) -> c_uint;
3822 pub fn ostree_metadata_variant_type(objtype: OstreeObjectType) -> *const glib::GVariantType;
3823 pub fn ostree_object_from_string(
3824 str: *const c_char,
3825 out_checksum: *mut *mut c_char,
3826 out_objtype: *mut OstreeObjectType,
3827 );
3828 pub fn ostree_object_name_deserialize(
3829 variant: *mut glib::GVariant,
3830 out_checksum: *mut *const c_char,
3831 out_objtype: *mut OstreeObjectType,
3832 );
3833 pub fn ostree_object_name_serialize(
3834 checksum: *const c_char,
3835 objtype: OstreeObjectType,
3836 ) -> *mut glib::GVariant;
3837 pub fn ostree_object_to_string(
3838 checksum: *const c_char,
3839 objtype: OstreeObjectType,
3840 ) -> *mut c_char;
3841 pub fn ostree_object_type_from_string(str: *const c_char) -> OstreeObjectType;
3842 pub fn ostree_object_type_to_string(objtype: OstreeObjectType) -> *const c_char;
3843 pub fn ostree_parse_refspec(
3844 refspec: *const c_char,
3845 out_remote: *mut *mut c_char,
3846 out_ref: *mut *mut c_char,
3847 error: *mut *mut glib::GError,
3848 ) -> gboolean;
3849 #[cfg(feature = "v2016_6")]
3850 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
3851 pub fn ostree_raw_file_to_archive_z2_stream(
3852 input: *mut gio::GInputStream,
3853 file_info: *mut gio::GFileInfo,
3854 xattrs: *mut glib::GVariant,
3855 out_input: *mut *mut gio::GInputStream,
3856 cancellable: *mut gio::GCancellable,
3857 error: *mut *mut glib::GError,
3858 ) -> gboolean;
3859 #[cfg(feature = "v2017_3")]
3860 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_3")))]
3861 pub fn ostree_raw_file_to_archive_z2_stream_with_options(
3862 input: *mut gio::GInputStream,
3863 file_info: *mut gio::GFileInfo,
3864 xattrs: *mut glib::GVariant,
3865 options: *mut glib::GVariant,
3866 out_input: *mut *mut gio::GInputStream,
3867 cancellable: *mut gio::GCancellable,
3868 error: *mut *mut glib::GError,
3869 ) -> gboolean;
3870 pub fn ostree_raw_file_to_content_stream(
3871 input: *mut gio::GInputStream,
3872 file_info: *mut gio::GFileInfo,
3873 xattrs: *mut glib::GVariant,
3874 out_input: *mut *mut gio::GInputStream,
3875 out_length: *mut u64,
3876 cancellable: *mut gio::GCancellable,
3877 error: *mut *mut glib::GError,
3878 ) -> gboolean;
3879 pub fn ostree_validate_checksum_string(
3880 sha256: *const c_char,
3881 error: *mut *mut glib::GError,
3882 ) -> gboolean;
3883 #[cfg(feature = "v2018_6")]
3884 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3885 pub fn ostree_validate_collection_id(
3886 collection_id: *const c_char,
3887 error: *mut *mut glib::GError,
3888 ) -> gboolean;
3889 #[cfg(feature = "v2017_8")]
3890 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_8")))]
3891 pub fn ostree_validate_remote_name(
3892 remote_name: *const c_char,
3893 error: *mut *mut glib::GError,
3894 ) -> gboolean;
3895 pub fn ostree_validate_rev(rev: *const c_char, error: *mut *mut glib::GError) -> gboolean;
3896 pub fn ostree_validate_structureof_checksum_string(
3897 checksum: *const c_char,
3898 error: *mut *mut glib::GError,
3899 ) -> gboolean;
3900 pub fn ostree_validate_structureof_commit(
3901 commit: *mut glib::GVariant,
3902 error: *mut *mut glib::GError,
3903 ) -> gboolean;
3904 pub fn ostree_validate_structureof_csum_v(
3905 checksum: *mut glib::GVariant,
3906 error: *mut *mut glib::GError,
3907 ) -> gboolean;
3908 pub fn ostree_validate_structureof_dirmeta(
3909 dirmeta: *mut glib::GVariant,
3910 error: *mut *mut glib::GError,
3911 ) -> gboolean;
3912 pub fn ostree_validate_structureof_dirtree(
3913 dirtree: *mut glib::GVariant,
3914 error: *mut *mut glib::GError,
3915 ) -> gboolean;
3916 pub fn ostree_validate_structureof_file_mode(
3917 mode: u32,
3918 error: *mut *mut glib::GError,
3919 ) -> gboolean;
3920 pub fn ostree_validate_structureof_objtype(
3921 objtype: c_uchar,
3922 error: *mut *mut glib::GError,
3923 ) -> gboolean;
3924
3925}