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_get_tries_done(self_: *mut OstreeBootconfigParser) -> u64;
1581 #[cfg(feature = "v2025_2")]
1582 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_2")))]
1583 pub fn ostree_bootconfig_parser_get_tries_left(self_: *mut OstreeBootconfigParser) -> u64;
1584 pub fn ostree_bootconfig_parser_parse(
1585 self_: *mut OstreeBootconfigParser,
1586 path: *mut gio::GFile,
1587 cancellable: *mut gio::GCancellable,
1588 error: *mut *mut glib::GError,
1589 ) -> gboolean;
1590 pub fn ostree_bootconfig_parser_parse_at(
1591 self_: *mut OstreeBootconfigParser,
1592 dfd: c_int,
1593 path: *const c_char,
1594 cancellable: *mut gio::GCancellable,
1595 error: *mut *mut glib::GError,
1596 ) -> gboolean;
1597 pub fn ostree_bootconfig_parser_set(
1598 self_: *mut OstreeBootconfigParser,
1599 key: *const c_char,
1600 value: *const c_char,
1601 );
1602 #[cfg(feature = "v2020_7")]
1603 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
1604 pub fn ostree_bootconfig_parser_set_overlay_initrds(
1605 self_: *mut OstreeBootconfigParser,
1606 initrds: *mut *mut c_char,
1607 );
1608 pub fn ostree_bootconfig_parser_write(
1609 self_: *mut OstreeBootconfigParser,
1610 output: *mut gio::GFile,
1611 cancellable: *mut gio::GCancellable,
1612 error: *mut *mut glib::GError,
1613 ) -> gboolean;
1614 pub fn ostree_bootconfig_parser_write_at(
1615 self_: *mut OstreeBootconfigParser,
1616 dfd: c_int,
1617 path: *const c_char,
1618 cancellable: *mut gio::GCancellable,
1619 error: *mut *mut glib::GError,
1620 ) -> gboolean;
1621
1622 pub fn ostree_content_writer_get_type() -> GType;
1626 pub fn ostree_content_writer_finish(
1627 self_: *mut OstreeContentWriter,
1628 cancellable: *mut gio::GCancellable,
1629 error: *mut *mut glib::GError,
1630 ) -> *mut c_char;
1631
1632 pub fn ostree_deployment_get_type() -> GType;
1636 pub fn ostree_deployment_new(
1637 index: c_int,
1638 osname: *const c_char,
1639 csum: *const c_char,
1640 deployserial: c_int,
1641 bootcsum: *const c_char,
1642 bootserial: c_int,
1643 ) -> *mut OstreeDeployment;
1644 #[cfg(feature = "v2018_3")]
1645 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
1646 pub fn ostree_deployment_origin_remove_transient_state(origin: *mut glib::GKeyFile);
1647 #[cfg(feature = "v2016_4")]
1648 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
1649 pub fn ostree_deployment_unlocked_state_to_string(
1650 state: OstreeDeploymentUnlockedState,
1651 ) -> *const c_char;
1652 pub fn ostree_deployment_clone(self_: *mut OstreeDeployment) -> *mut OstreeDeployment;
1653 pub fn ostree_deployment_equal(ap: gconstpointer, bp: gconstpointer) -> gboolean;
1654 pub fn ostree_deployment_get_bootconfig(
1655 self_: *mut OstreeDeployment,
1656 ) -> *mut OstreeBootconfigParser;
1657 pub fn ostree_deployment_get_bootcsum(self_: *mut OstreeDeployment) -> *const c_char;
1658 pub fn ostree_deployment_get_bootserial(self_: *mut OstreeDeployment) -> c_int;
1659 pub fn ostree_deployment_get_csum(self_: *mut OstreeDeployment) -> *const c_char;
1660 pub fn ostree_deployment_get_deployserial(self_: *mut OstreeDeployment) -> c_int;
1661 pub fn ostree_deployment_get_index(self_: *mut OstreeDeployment) -> c_int;
1662 pub fn ostree_deployment_get_origin(self_: *mut OstreeDeployment) -> *mut glib::GKeyFile;
1663 pub fn ostree_deployment_get_origin_relpath(self_: *mut OstreeDeployment) -> *mut c_char;
1664 pub fn ostree_deployment_get_osname(self_: *mut OstreeDeployment) -> *const c_char;
1665 #[cfg(feature = "v2016_4")]
1666 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
1667 pub fn ostree_deployment_get_unlocked(
1668 self_: *mut OstreeDeployment,
1669 ) -> OstreeDeploymentUnlockedState;
1670 pub fn ostree_deployment_hash(v: gconstpointer) -> c_uint;
1671 #[cfg(feature = "v2023_8")]
1672 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_8")))]
1673 pub fn ostree_deployment_is_finalization_locked(self_: *mut OstreeDeployment) -> gboolean;
1674 #[cfg(feature = "v2018_3")]
1675 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
1676 pub fn ostree_deployment_is_pinned(self_: *mut OstreeDeployment) -> gboolean;
1677 #[cfg(feature = "v2025_3")]
1678 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_3")))]
1679 pub fn ostree_deployment_is_soft_reboot_target(self_: *mut OstreeDeployment) -> gboolean;
1680 #[cfg(feature = "v2018_3")]
1681 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
1682 pub fn ostree_deployment_is_staged(self_: *mut OstreeDeployment) -> gboolean;
1683 pub fn ostree_deployment_set_bootconfig(
1684 self_: *mut OstreeDeployment,
1685 bootconfig: *mut OstreeBootconfigParser,
1686 );
1687 pub fn ostree_deployment_set_bootserial(self_: *mut OstreeDeployment, index: c_int);
1688 pub fn ostree_deployment_set_index(self_: *mut OstreeDeployment, index: c_int);
1689 pub fn ostree_deployment_set_origin(self_: *mut OstreeDeployment, origin: *mut glib::GKeyFile);
1690
1691 pub fn ostree_gpg_verify_result_get_type() -> GType;
1695 pub fn ostree_gpg_verify_result_describe_variant(
1696 variant: *mut glib::GVariant,
1697 output_buffer: *mut glib::GString,
1698 line_prefix: *const c_char,
1699 flags: OstreeGpgSignatureFormatFlags,
1700 );
1701 pub fn ostree_gpg_verify_result_count_all(result: *mut OstreeGpgVerifyResult) -> c_uint;
1702 pub fn ostree_gpg_verify_result_count_valid(result: *mut OstreeGpgVerifyResult) -> c_uint;
1703 pub fn ostree_gpg_verify_result_describe(
1704 result: *mut OstreeGpgVerifyResult,
1705 signature_index: c_uint,
1706 output_buffer: *mut glib::GString,
1707 line_prefix: *const c_char,
1708 flags: OstreeGpgSignatureFormatFlags,
1709 );
1710 pub fn ostree_gpg_verify_result_get(
1711 result: *mut OstreeGpgVerifyResult,
1712 signature_index: c_uint,
1713 attrs: *mut OstreeGpgSignatureAttr,
1714 n_attrs: c_uint,
1715 ) -> *mut glib::GVariant;
1716 pub fn ostree_gpg_verify_result_get_all(
1717 result: *mut OstreeGpgVerifyResult,
1718 signature_index: c_uint,
1719 ) -> *mut glib::GVariant;
1720 pub fn ostree_gpg_verify_result_lookup(
1721 result: *mut OstreeGpgVerifyResult,
1722 key_id: *const c_char,
1723 out_signature_index: *mut c_uint,
1724 ) -> gboolean;
1725 #[cfg(feature = "v2016_6")]
1726 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
1727 pub fn ostree_gpg_verify_result_require_valid_signature(
1728 result: *mut OstreeGpgVerifyResult,
1729 error: *mut *mut glib::GError,
1730 ) -> gboolean;
1731
1732 pub fn ostree_mutable_tree_get_type() -> GType;
1736 pub fn ostree_mutable_tree_new() -> *mut OstreeMutableTree;
1737 #[cfg(feature = "v2018_7")]
1738 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_7")))]
1739 pub fn ostree_mutable_tree_new_from_checksum(
1740 repo: *mut OstreeRepo,
1741 contents_checksum: *const c_char,
1742 metadata_checksum: *const c_char,
1743 ) -> *mut OstreeMutableTree;
1744 #[cfg(feature = "v2021_5")]
1745 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_5")))]
1746 pub fn ostree_mutable_tree_new_from_commit(
1747 repo: *mut OstreeRepo,
1748 rev: *const c_char,
1749 error: *mut *mut glib::GError,
1750 ) -> *mut OstreeMutableTree;
1751 #[cfg(feature = "v2018_7")]
1752 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_7")))]
1753 pub fn ostree_mutable_tree_check_error(
1754 self_: *mut OstreeMutableTree,
1755 error: *mut *mut glib::GError,
1756 ) -> gboolean;
1757 pub fn ostree_mutable_tree_ensure_dir(
1758 self_: *mut OstreeMutableTree,
1759 name: *const c_char,
1760 out_subdir: *mut *mut OstreeMutableTree,
1761 error: *mut *mut glib::GError,
1762 ) -> gboolean;
1763 pub fn ostree_mutable_tree_ensure_parent_dirs(
1764 self_: *mut OstreeMutableTree,
1765 split_path: *mut glib::GPtrArray,
1766 metadata_checksum: *const c_char,
1767 out_parent: *mut *mut OstreeMutableTree,
1768 error: *mut *mut glib::GError,
1769 ) -> gboolean;
1770 #[cfg(feature = "v2018_7")]
1771 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_7")))]
1772 pub fn ostree_mutable_tree_fill_empty_from_dirtree(
1773 self_: *mut OstreeMutableTree,
1774 repo: *mut OstreeRepo,
1775 contents_checksum: *const c_char,
1776 metadata_checksum: *const c_char,
1777 ) -> gboolean;
1778 pub fn ostree_mutable_tree_get_contents_checksum(
1779 self_: *mut OstreeMutableTree,
1780 ) -> *const c_char;
1781 pub fn ostree_mutable_tree_get_files(self_: *mut OstreeMutableTree) -> *mut glib::GHashTable;
1782 pub fn ostree_mutable_tree_get_metadata_checksum(
1783 self_: *mut OstreeMutableTree,
1784 ) -> *const c_char;
1785 pub fn ostree_mutable_tree_get_subdirs(self_: *mut OstreeMutableTree) -> *mut glib::GHashTable;
1786 pub fn ostree_mutable_tree_lookup(
1787 self_: *mut OstreeMutableTree,
1788 name: *const c_char,
1789 out_file_checksum: *mut *mut c_char,
1790 out_subdir: *mut *mut OstreeMutableTree,
1791 error: *mut *mut glib::GError,
1792 ) -> gboolean;
1793 #[cfg(feature = "v2018_9")]
1794 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_9")))]
1795 pub fn ostree_mutable_tree_remove(
1796 self_: *mut OstreeMutableTree,
1797 name: *const c_char,
1798 allow_noent: gboolean,
1799 error: *mut *mut glib::GError,
1800 ) -> gboolean;
1801 pub fn ostree_mutable_tree_replace_file(
1802 self_: *mut OstreeMutableTree,
1803 name: *const c_char,
1804 checksum: *const c_char,
1805 error: *mut *mut glib::GError,
1806 ) -> gboolean;
1807 pub fn ostree_mutable_tree_set_contents_checksum(
1808 self_: *mut OstreeMutableTree,
1809 checksum: *const c_char,
1810 );
1811 pub fn ostree_mutable_tree_set_metadata_checksum(
1812 self_: *mut OstreeMutableTree,
1813 checksum: *const c_char,
1814 );
1815 pub fn ostree_mutable_tree_walk(
1816 self_: *mut OstreeMutableTree,
1817 split_path: *mut glib::GPtrArray,
1818 start: c_uint,
1819 out_subdir: *mut *mut OstreeMutableTree,
1820 error: *mut *mut glib::GError,
1821 ) -> gboolean;
1822
1823 pub fn ostree_repo_get_type() -> GType;
1827 pub fn ostree_repo_new(path: *mut gio::GFile) -> *mut OstreeRepo;
1828 pub fn ostree_repo_new_default() -> *mut OstreeRepo;
1829 pub fn ostree_repo_new_for_sysroot_path(
1830 repo_path: *mut gio::GFile,
1831 sysroot_path: *mut gio::GFile,
1832 ) -> *mut OstreeRepo;
1833 #[cfg(feature = "v2017_10")]
1834 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
1835 pub fn ostree_repo_create_at(
1836 dfd: c_int,
1837 path: *const c_char,
1838 mode: OstreeRepoMode,
1839 options: *mut glib::GVariant,
1840 cancellable: *mut gio::GCancellable,
1841 error: *mut *mut glib::GError,
1842 ) -> *mut OstreeRepo;
1843 pub fn ostree_repo_mode_from_string(
1844 mode: *const c_char,
1845 out_mode: *mut OstreeRepoMode,
1846 error: *mut *mut glib::GError,
1847 ) -> gboolean;
1848 #[cfg(feature = "v2017_10")]
1849 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
1850 pub fn ostree_repo_open_at(
1851 dfd: c_int,
1852 path: *const c_char,
1853 cancellable: *mut gio::GCancellable,
1854 error: *mut *mut glib::GError,
1855 ) -> *mut OstreeRepo;
1856 pub fn ostree_repo_pull_default_console_progress_changed(
1857 progress: *mut OstreeAsyncProgress,
1858 user_data: gpointer,
1859 );
1860 #[cfg(feature = "v2018_5")]
1861 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
1862 pub fn ostree_repo_traverse_new_parents() -> *mut glib::GHashTable;
1863 pub fn ostree_repo_traverse_new_reachable() -> *mut glib::GHashTable;
1864 #[cfg(feature = "v2018_5")]
1865 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
1866 pub fn ostree_repo_traverse_parents_get_commits(
1867 parents: *mut glib::GHashTable,
1868 object: *mut glib::GVariant,
1869 ) -> *mut *mut c_char;
1870 pub fn ostree_repo_abort_transaction(
1871 self_: *mut OstreeRepo,
1872 cancellable: *mut gio::GCancellable,
1873 error: *mut *mut glib::GError,
1874 ) -> gboolean;
1875 pub fn ostree_repo_add_gpg_signature_summary(
1876 self_: *mut OstreeRepo,
1877 key_id: *mut *const c_char,
1878 homedir: *const c_char,
1879 cancellable: *mut gio::GCancellable,
1880 error: *mut *mut glib::GError,
1881 ) -> gboolean;
1882 pub fn ostree_repo_append_gpg_signature(
1883 self_: *mut OstreeRepo,
1884 commit_checksum: *const c_char,
1885 signature_bytes: *mut glib::GBytes,
1886 cancellable: *mut gio::GCancellable,
1887 error: *mut *mut glib::GError,
1888 ) -> gboolean;
1889 #[cfg(feature = "v2016_8")]
1890 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_8")))]
1891 pub fn ostree_repo_checkout_at(
1892 self_: *mut OstreeRepo,
1893 options: *mut OstreeRepoCheckoutAtOptions,
1894 destination_dfd: c_int,
1895 destination_path: *const c_char,
1896 commit: *const c_char,
1897 cancellable: *mut gio::GCancellable,
1898 error: *mut *mut glib::GError,
1899 ) -> gboolean;
1900 #[cfg(feature = "v2024_7")]
1901 #[cfg_attr(docsrs, doc(cfg(feature = "v2024_7")))]
1902 pub fn ostree_repo_checkout_composefs(
1903 self_: *mut OstreeRepo,
1904 options: *mut glib::GVariant,
1905 destination_dfd: c_int,
1906 destination_path: *const c_char,
1907 checksum: *const c_char,
1908 cancellable: *mut gio::GCancellable,
1909 error: *mut *mut glib::GError,
1910 ) -> gboolean;
1911 pub fn ostree_repo_checkout_gc(
1912 self_: *mut OstreeRepo,
1913 cancellable: *mut gio::GCancellable,
1914 error: *mut *mut glib::GError,
1915 ) -> gboolean;
1916 pub fn ostree_repo_checkout_tree(
1917 self_: *mut OstreeRepo,
1918 mode: OstreeRepoCheckoutMode,
1919 overwrite_mode: OstreeRepoCheckoutOverwriteMode,
1920 destination: *mut gio::GFile,
1921 source: *mut OstreeRepoFile,
1922 source_info: *mut gio::GFileInfo,
1923 cancellable: *mut gio::GCancellable,
1924 error: *mut *mut glib::GError,
1925 ) -> gboolean;
1926 pub fn ostree_repo_checkout_tree_at(
1927 self_: *mut OstreeRepo,
1928 options: *mut OstreeRepoCheckoutOptions,
1929 destination_dfd: c_int,
1930 destination_path: *const c_char,
1931 commit: *const c_char,
1932 cancellable: *mut gio::GCancellable,
1933 error: *mut *mut glib::GError,
1934 ) -> gboolean;
1935 pub fn ostree_repo_commit_add_composefs_metadata(
1936 self_: *mut OstreeRepo,
1937 format_version: c_uint,
1938 dict: *mut glib::GVariantDict,
1939 repo_root: *mut OstreeRepoFile,
1940 cancellable: *mut gio::GCancellable,
1941 error: *mut *mut glib::GError,
1942 ) -> gboolean;
1943 pub fn ostree_repo_commit_transaction(
1944 self_: *mut OstreeRepo,
1945 out_stats: *mut OstreeRepoTransactionStats,
1946 cancellable: *mut gio::GCancellable,
1947 error: *mut *mut glib::GError,
1948 ) -> gboolean;
1949 pub fn ostree_repo_copy_config(self_: *mut OstreeRepo) -> *mut glib::GKeyFile;
1950 pub fn ostree_repo_create(
1951 self_: *mut OstreeRepo,
1952 mode: OstreeRepoMode,
1953 cancellable: *mut gio::GCancellable,
1954 error: *mut *mut glib::GError,
1955 ) -> gboolean;
1956 pub fn ostree_repo_delete_object(
1957 self_: *mut OstreeRepo,
1958 objtype: OstreeObjectType,
1959 sha256: *const c_char,
1960 cancellable: *mut gio::GCancellable,
1961 error: *mut *mut glib::GError,
1962 ) -> gboolean;
1963 #[cfg(feature = "v2017_12")]
1964 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_12")))]
1965 pub fn ostree_repo_equal(a: *mut OstreeRepo, b: *mut OstreeRepo) -> gboolean;
1966 pub fn ostree_repo_export_tree_to_archive(
1967 self_: *mut OstreeRepo,
1968 opts: *mut OstreeRepoExportArchiveOptions,
1969 root: *mut OstreeRepoFile,
1970 archive: *mut c_void,
1971 cancellable: *mut gio::GCancellable,
1972 error: *mut *mut glib::GError,
1973 ) -> gboolean;
1974 #[cfg(feature = "v2018_6")]
1975 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1976 pub fn ostree_repo_find_remotes_async(
1977 self_: *mut OstreeRepo,
1978 refs: *const *const OstreeCollectionRef,
1979 options: *mut glib::GVariant,
1980 finders: *mut *mut OstreeRepoFinder,
1981 progress: *mut OstreeAsyncProgress,
1982 cancellable: *mut gio::GCancellable,
1983 callback: gio::GAsyncReadyCallback,
1984 user_data: gpointer,
1985 );
1986 #[cfg(feature = "v2018_6")]
1987 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
1988 pub fn ostree_repo_find_remotes_finish(
1989 self_: *mut OstreeRepo,
1990 result: *mut gio::GAsyncResult,
1991 error: *mut *mut glib::GError,
1992 ) -> *mut *mut OstreeRepoFinderResult;
1993 #[cfg(feature = "v2017_15")]
1994 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_15")))]
1995 pub fn ostree_repo_fsck_object(
1996 self_: *mut OstreeRepo,
1997 objtype: OstreeObjectType,
1998 sha256: *const c_char,
1999 cancellable: *mut gio::GCancellable,
2000 error: *mut *mut glib::GError,
2001 ) -> gboolean;
2002 #[cfg(feature = "v2019_2")]
2003 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_2")))]
2004 pub fn ostree_repo_get_bootloader(self_: *mut OstreeRepo) -> *const c_char;
2005 #[cfg(feature = "v2018_6")]
2006 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2007 pub fn ostree_repo_get_collection_id(self_: *mut OstreeRepo) -> *const c_char;
2008 pub fn ostree_repo_get_config(self_: *mut OstreeRepo) -> *mut glib::GKeyFile;
2009 #[cfg(feature = "v2018_9")]
2010 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_9")))]
2011 pub fn ostree_repo_get_default_repo_finders(self_: *mut OstreeRepo) -> *const *const c_char;
2012 #[cfg(feature = "v2016_4")]
2013 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
2014 pub fn ostree_repo_get_dfd(self_: *mut OstreeRepo) -> c_int;
2015 pub fn ostree_repo_get_disable_fsync(self_: *mut OstreeRepo) -> gboolean;
2016 #[cfg(feature = "v2018_9")]
2017 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_9")))]
2018 pub fn ostree_repo_get_min_free_space_bytes(
2019 self_: *mut OstreeRepo,
2020 out_reserved_bytes: *mut u64,
2021 error: *mut *mut glib::GError,
2022 ) -> gboolean;
2023 pub fn ostree_repo_get_mode(self_: *mut OstreeRepo) -> OstreeRepoMode;
2024 pub fn ostree_repo_get_parent(self_: *mut OstreeRepo) -> *mut OstreeRepo;
2025 pub fn ostree_repo_get_path(self_: *mut OstreeRepo) -> *mut gio::GFile;
2026 #[cfg(feature = "v2016_5")]
2027 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2028 pub fn ostree_repo_get_remote_boolean_option(
2029 self_: *mut OstreeRepo,
2030 remote_name: *const c_char,
2031 option_name: *const c_char,
2032 default_value: gboolean,
2033 out_value: *mut gboolean,
2034 error: *mut *mut glib::GError,
2035 ) -> gboolean;
2036 #[cfg(feature = "v2016_5")]
2037 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2038 pub fn ostree_repo_get_remote_list_option(
2039 self_: *mut OstreeRepo,
2040 remote_name: *const c_char,
2041 option_name: *const c_char,
2042 out_value: *mut *mut *mut c_char,
2043 error: *mut *mut glib::GError,
2044 ) -> gboolean;
2045 #[cfg(feature = "v2016_5")]
2046 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2047 pub fn ostree_repo_get_remote_option(
2048 self_: *mut OstreeRepo,
2049 remote_name: *const c_char,
2050 option_name: *const c_char,
2051 default_value: *const c_char,
2052 out_value: *mut *mut c_char,
2053 error: *mut *mut glib::GError,
2054 ) -> gboolean;
2055 #[cfg(feature = "v2020_8")]
2056 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_8")))]
2057 pub fn ostree_repo_gpg_sign_data(
2058 self_: *mut OstreeRepo,
2059 data: *mut glib::GBytes,
2060 old_signatures: *mut glib::GBytes,
2061 key_id: *mut *const c_char,
2062 homedir: *const c_char,
2063 out_signatures: *mut *mut glib::GBytes,
2064 cancellable: *mut gio::GCancellable,
2065 error: *mut *mut glib::GError,
2066 ) -> gboolean;
2067 #[cfg(feature = "v2016_6")]
2068 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
2069 pub fn ostree_repo_gpg_verify_data(
2070 self_: *mut OstreeRepo,
2071 remote_name: *const c_char,
2072 data: *mut glib::GBytes,
2073 signatures: *mut glib::GBytes,
2074 keyringdir: *mut gio::GFile,
2075 extra_keyring: *mut gio::GFile,
2076 cancellable: *mut gio::GCancellable,
2077 error: *mut *mut glib::GError,
2078 ) -> *mut OstreeGpgVerifyResult;
2079 pub fn ostree_repo_has_object(
2080 self_: *mut OstreeRepo,
2081 objtype: OstreeObjectType,
2082 checksum: *const c_char,
2083 out_have_object: *mut gboolean,
2084 cancellable: *mut gio::GCancellable,
2085 error: *mut *mut glib::GError,
2086 ) -> gboolean;
2087 #[cfg(feature = "v2017_12")]
2088 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_12")))]
2089 pub fn ostree_repo_hash(self_: *mut OstreeRepo) -> c_uint;
2090 pub fn ostree_repo_import_archive_to_mtree(
2091 self_: *mut OstreeRepo,
2092 opts: *mut OstreeRepoImportArchiveOptions,
2093 archive: *mut c_void,
2094 mtree: *mut OstreeMutableTree,
2095 modifier: *mut OstreeRepoCommitModifier,
2096 cancellable: *mut gio::GCancellable,
2097 error: *mut *mut glib::GError,
2098 ) -> gboolean;
2099 pub fn ostree_repo_import_object_from(
2100 self_: *mut OstreeRepo,
2101 source: *mut OstreeRepo,
2102 objtype: OstreeObjectType,
2103 checksum: *const c_char,
2104 cancellable: *mut gio::GCancellable,
2105 error: *mut *mut glib::GError,
2106 ) -> gboolean;
2107 #[cfg(feature = "v2016_5")]
2108 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2109 pub fn ostree_repo_import_object_from_with_trust(
2110 self_: *mut OstreeRepo,
2111 source: *mut OstreeRepo,
2112 objtype: OstreeObjectType,
2113 checksum: *const c_char,
2114 trusted: gboolean,
2115 cancellable: *mut gio::GCancellable,
2116 error: *mut *mut glib::GError,
2117 ) -> gboolean;
2118 pub fn ostree_repo_is_system(repo: *mut OstreeRepo) -> gboolean;
2119 pub fn ostree_repo_is_writable(
2120 self_: *mut OstreeRepo,
2121 error: *mut *mut glib::GError,
2122 ) -> gboolean;
2123 #[cfg(feature = "v2018_6")]
2124 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2125 pub fn ostree_repo_list_collection_refs(
2126 self_: *mut OstreeRepo,
2127 match_collection_id: *const c_char,
2128 out_all_refs: *mut *mut glib::GHashTable,
2129 flags: OstreeRepoListRefsExtFlags,
2130 cancellable: *mut gio::GCancellable,
2131 error: *mut *mut glib::GError,
2132 ) -> gboolean;
2133 pub fn ostree_repo_list_commit_objects_starting_with(
2134 self_: *mut OstreeRepo,
2135 start: *const c_char,
2136 out_commits: *mut *mut glib::GHashTable,
2137 cancellable: *mut gio::GCancellable,
2138 error: *mut *mut glib::GError,
2139 ) -> gboolean;
2140 pub fn ostree_repo_list_objects(
2141 self_: *mut OstreeRepo,
2142 flags: OstreeRepoListObjectsFlags,
2143 out_objects: *mut *mut glib::GHashTable,
2144 cancellable: *mut gio::GCancellable,
2145 error: *mut *mut glib::GError,
2146 ) -> gboolean;
2147 pub fn ostree_repo_list_refs(
2148 self_: *mut OstreeRepo,
2149 refspec_prefix: *const c_char,
2150 out_all_refs: *mut *mut glib::GHashTable,
2151 cancellable: *mut gio::GCancellable,
2152 error: *mut *mut glib::GError,
2153 ) -> gboolean;
2154 #[cfg(feature = "v2016_4")]
2155 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
2156 pub fn ostree_repo_list_refs_ext(
2157 self_: *mut OstreeRepo,
2158 refspec_prefix: *const c_char,
2159 out_all_refs: *mut *mut glib::GHashTable,
2160 flags: OstreeRepoListRefsExtFlags,
2161 cancellable: *mut gio::GCancellable,
2162 error: *mut *mut glib::GError,
2163 ) -> gboolean;
2164 #[cfg(feature = "v2020_8")]
2165 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_8")))]
2166 pub fn ostree_repo_list_static_delta_indexes(
2167 self_: *mut OstreeRepo,
2168 out_indexes: *mut *mut glib::GPtrArray,
2169 cancellable: *mut gio::GCancellable,
2170 error: *mut *mut glib::GError,
2171 ) -> gboolean;
2172 pub fn ostree_repo_list_static_delta_names(
2173 self_: *mut OstreeRepo,
2174 out_deltas: *mut *mut glib::GPtrArray,
2175 cancellable: *mut gio::GCancellable,
2176 error: *mut *mut glib::GError,
2177 ) -> gboolean;
2178 #[cfg(feature = "v2015_7")]
2179 #[cfg_attr(docsrs, doc(cfg(feature = "v2015_7")))]
2180 pub fn ostree_repo_load_commit(
2181 self_: *mut OstreeRepo,
2182 checksum: *const c_char,
2183 out_commit: *mut *mut glib::GVariant,
2184 out_state: *mut OstreeRepoCommitState,
2185 error: *mut *mut glib::GError,
2186 ) -> gboolean;
2187 pub fn ostree_repo_load_file(
2188 self_: *mut OstreeRepo,
2189 checksum: *const c_char,
2190 out_input: *mut *mut gio::GInputStream,
2191 out_file_info: *mut *mut gio::GFileInfo,
2192 out_xattrs: *mut *mut glib::GVariant,
2193 cancellable: *mut gio::GCancellable,
2194 error: *mut *mut glib::GError,
2195 ) -> gboolean;
2196 pub fn ostree_repo_load_object_stream(
2197 self_: *mut OstreeRepo,
2198 objtype: OstreeObjectType,
2199 checksum: *const c_char,
2200 out_input: *mut *mut gio::GInputStream,
2201 out_size: *mut u64,
2202 cancellable: *mut gio::GCancellable,
2203 error: *mut *mut glib::GError,
2204 ) -> gboolean;
2205 pub fn ostree_repo_load_variant(
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 pub fn ostree_repo_load_variant_if_exists(
2213 self_: *mut OstreeRepo,
2214 objtype: OstreeObjectType,
2215 sha256: *const c_char,
2216 out_variant: *mut *mut glib::GVariant,
2217 error: *mut *mut glib::GError,
2218 ) -> gboolean;
2219 #[cfg(feature = "v2021_3")]
2220 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_3")))]
2221 pub fn ostree_repo_lock_pop(
2222 self_: *mut OstreeRepo,
2223 lock_type: OstreeRepoLockType,
2224 cancellable: *mut gio::GCancellable,
2225 error: *mut *mut glib::GError,
2226 ) -> gboolean;
2227 #[cfg(feature = "v2021_3")]
2228 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_3")))]
2229 pub fn ostree_repo_lock_push(
2230 self_: *mut OstreeRepo,
2231 lock_type: OstreeRepoLockType,
2232 cancellable: *mut gio::GCancellable,
2233 error: *mut *mut glib::GError,
2234 ) -> gboolean;
2235 #[cfg(feature = "v2017_15")]
2236 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_15")))]
2237 pub fn ostree_repo_mark_commit_partial(
2238 self_: *mut OstreeRepo,
2239 checksum: *const c_char,
2240 is_partial: gboolean,
2241 error: *mut *mut glib::GError,
2242 ) -> gboolean;
2243 #[cfg(feature = "v2019_4")]
2244 #[cfg_attr(docsrs, doc(cfg(feature = "v2019_4")))]
2245 pub fn ostree_repo_mark_commit_partial_reason(
2246 self_: *mut OstreeRepo,
2247 checksum: *const c_char,
2248 is_partial: gboolean,
2249 in_state: OstreeRepoCommitState,
2250 error: *mut *mut glib::GError,
2251 ) -> gboolean;
2252 pub fn ostree_repo_open(
2253 self_: *mut OstreeRepo,
2254 cancellable: *mut gio::GCancellable,
2255 error: *mut *mut glib::GError,
2256 ) -> gboolean;
2257 pub fn ostree_repo_prepare_transaction(
2258 self_: *mut OstreeRepo,
2259 out_transaction_resume: *mut gboolean,
2260 cancellable: *mut gio::GCancellable,
2261 error: *mut *mut glib::GError,
2262 ) -> gboolean;
2263 pub fn ostree_repo_prune(
2264 self_: *mut OstreeRepo,
2265 flags: OstreeRepoPruneFlags,
2266 depth: c_int,
2267 out_objects_total: *mut c_int,
2268 out_objects_pruned: *mut c_int,
2269 out_pruned_object_size_total: *mut u64,
2270 cancellable: *mut gio::GCancellable,
2271 error: *mut *mut glib::GError,
2272 ) -> gboolean;
2273 #[cfg(feature = "v2017_1")]
2274 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_1")))]
2275 pub fn ostree_repo_prune_from_reachable(
2276 self_: *mut OstreeRepo,
2277 options: *mut OstreeRepoPruneOptions,
2278 out_objects_total: *mut c_int,
2279 out_objects_pruned: *mut c_int,
2280 out_pruned_object_size_total: *mut u64,
2281 cancellable: *mut gio::GCancellable,
2282 error: *mut *mut glib::GError,
2283 ) -> gboolean;
2284 pub fn ostree_repo_prune_static_deltas(
2285 self_: *mut OstreeRepo,
2286 commit: *const c_char,
2287 cancellable: *mut gio::GCancellable,
2288 error: *mut *mut glib::GError,
2289 ) -> gboolean;
2290 pub fn ostree_repo_pull(
2291 self_: *mut OstreeRepo,
2292 remote_name: *const c_char,
2293 refs_to_fetch: *mut *mut c_char,
2294 flags: OstreeRepoPullFlags,
2295 progress: *mut OstreeAsyncProgress,
2296 cancellable: *mut gio::GCancellable,
2297 error: *mut *mut glib::GError,
2298 ) -> gboolean;
2299 #[cfg(feature = "v2018_6")]
2300 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2301 pub fn ostree_repo_pull_from_remotes_async(
2302 self_: *mut OstreeRepo,
2303 results: *const *const OstreeRepoFinderResult,
2304 options: *mut glib::GVariant,
2305 progress: *mut OstreeAsyncProgress,
2306 cancellable: *mut gio::GCancellable,
2307 callback: gio::GAsyncReadyCallback,
2308 user_data: gpointer,
2309 );
2310 #[cfg(feature = "v2018_6")]
2311 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2312 pub fn ostree_repo_pull_from_remotes_finish(
2313 self_: *mut OstreeRepo,
2314 result: *mut gio::GAsyncResult,
2315 error: *mut *mut glib::GError,
2316 ) -> gboolean;
2317 pub fn ostree_repo_pull_one_dir(
2318 self_: *mut OstreeRepo,
2319 remote_name: *const c_char,
2320 dir_to_pull: *const c_char,
2321 refs_to_fetch: *mut *mut c_char,
2322 flags: OstreeRepoPullFlags,
2323 progress: *mut OstreeAsyncProgress,
2324 cancellable: *mut gio::GCancellable,
2325 error: *mut *mut glib::GError,
2326 ) -> gboolean;
2327 pub fn ostree_repo_pull_with_options(
2328 self_: *mut OstreeRepo,
2329 remote_name_or_baseurl: *const c_char,
2330 options: *mut glib::GVariant,
2331 progress: *mut OstreeAsyncProgress,
2332 cancellable: *mut gio::GCancellable,
2333 error: *mut *mut glib::GError,
2334 ) -> gboolean;
2335 pub fn ostree_repo_query_object_storage_size(
2336 self_: *mut OstreeRepo,
2337 objtype: OstreeObjectType,
2338 sha256: *const c_char,
2339 out_size: *mut u64,
2340 cancellable: *mut gio::GCancellable,
2341 error: *mut *mut glib::GError,
2342 ) -> gboolean;
2343 pub fn ostree_repo_read_commit(
2344 self_: *mut OstreeRepo,
2345 ref_: *const c_char,
2346 out_root: *mut *mut gio::GFile,
2347 out_commit: *mut *mut c_char,
2348 cancellable: *mut gio::GCancellable,
2349 error: *mut *mut glib::GError,
2350 ) -> gboolean;
2351 pub fn ostree_repo_read_commit_detached_metadata(
2352 self_: *mut OstreeRepo,
2353 checksum: *const c_char,
2354 out_metadata: *mut *mut glib::GVariant,
2355 cancellable: *mut gio::GCancellable,
2356 error: *mut *mut glib::GError,
2357 ) -> gboolean;
2358 #[cfg(feature = "v2023_1")]
2359 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_1")))]
2360 pub fn ostree_repo_regenerate_metadata(
2361 self_: *mut OstreeRepo,
2362 additional_metadata: *mut glib::GVariant,
2363 options: *mut glib::GVariant,
2364 cancellable: *mut gio::GCancellable,
2365 error: *mut *mut glib::GError,
2366 ) -> gboolean;
2367 pub fn ostree_repo_regenerate_summary(
2368 self_: *mut OstreeRepo,
2369 additional_metadata: *mut glib::GVariant,
2370 cancellable: *mut gio::GCancellable,
2371 error: *mut *mut glib::GError,
2372 ) -> gboolean;
2373 #[cfg(feature = "v2017_2")]
2374 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_2")))]
2375 pub fn ostree_repo_reload_config(
2376 self_: *mut OstreeRepo,
2377 cancellable: *mut gio::GCancellable,
2378 error: *mut *mut glib::GError,
2379 ) -> gboolean;
2380 pub fn ostree_repo_remote_add(
2381 self_: *mut OstreeRepo,
2382 name: *const c_char,
2383 url: *const c_char,
2384 options: *mut glib::GVariant,
2385 cancellable: *mut gio::GCancellable,
2386 error: *mut *mut glib::GError,
2387 ) -> gboolean;
2388 pub fn ostree_repo_remote_change(
2389 self_: *mut OstreeRepo,
2390 sysroot: *mut gio::GFile,
2391 changeop: OstreeRepoRemoteChange,
2392 name: *const c_char,
2393 url: *const c_char,
2394 options: *mut glib::GVariant,
2395 cancellable: *mut gio::GCancellable,
2396 error: *mut *mut glib::GError,
2397 ) -> gboolean;
2398 pub fn ostree_repo_remote_delete(
2399 self_: *mut OstreeRepo,
2400 name: *const c_char,
2401 cancellable: *mut gio::GCancellable,
2402 error: *mut *mut glib::GError,
2403 ) -> gboolean;
2404 pub fn ostree_repo_remote_fetch_summary(
2405 self_: *mut OstreeRepo,
2406 name: *const c_char,
2407 out_summary: *mut *mut glib::GBytes,
2408 out_signatures: *mut *mut glib::GBytes,
2409 cancellable: *mut gio::GCancellable,
2410 error: *mut *mut glib::GError,
2411 ) -> gboolean;
2412 #[cfg(feature = "v2016_6")]
2413 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
2414 pub fn ostree_repo_remote_fetch_summary_with_options(
2415 self_: *mut OstreeRepo,
2416 name: *const c_char,
2417 options: *mut glib::GVariant,
2418 out_summary: *mut *mut glib::GBytes,
2419 out_signatures: *mut *mut glib::GBytes,
2420 cancellable: *mut gio::GCancellable,
2421 error: *mut *mut glib::GError,
2422 ) -> gboolean;
2423 #[cfg(feature = "v2021_4")]
2424 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_4")))]
2425 pub fn ostree_repo_remote_get_gpg_keys(
2426 self_: *mut OstreeRepo,
2427 name: *const c_char,
2428 key_ids: *const *const c_char,
2429 out_keys: *mut *mut glib::GPtrArray,
2430 cancellable: *mut gio::GCancellable,
2431 error: *mut *mut glib::GError,
2432 ) -> gboolean;
2433 pub fn ostree_repo_remote_get_gpg_verify(
2434 self_: *mut OstreeRepo,
2435 name: *const c_char,
2436 out_gpg_verify: *mut gboolean,
2437 error: *mut *mut glib::GError,
2438 ) -> gboolean;
2439 pub fn ostree_repo_remote_get_gpg_verify_summary(
2440 self_: *mut OstreeRepo,
2441 name: *const c_char,
2442 out_gpg_verify_summary: *mut gboolean,
2443 error: *mut *mut glib::GError,
2444 ) -> gboolean;
2445 pub fn ostree_repo_remote_get_url(
2446 self_: *mut OstreeRepo,
2447 name: *const c_char,
2448 out_url: *mut *mut c_char,
2449 error: *mut *mut glib::GError,
2450 ) -> gboolean;
2451 pub fn ostree_repo_remote_gpg_import(
2452 self_: *mut OstreeRepo,
2453 name: *const c_char,
2454 source_stream: *mut gio::GInputStream,
2455 key_ids: *const *const c_char,
2456 out_imported: *mut c_uint,
2457 cancellable: *mut gio::GCancellable,
2458 error: *mut *mut glib::GError,
2459 ) -> gboolean;
2460 pub fn ostree_repo_remote_list(
2461 self_: *mut OstreeRepo,
2462 out_n_remotes: *mut c_uint,
2463 ) -> *mut *mut c_char;
2464 #[cfg(feature = "v2018_6")]
2465 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2466 pub fn ostree_repo_remote_list_collection_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 pub fn ostree_repo_remote_list_refs(
2474 self_: *mut OstreeRepo,
2475 remote_name: *const c_char,
2476 out_all_refs: *mut *mut glib::GHashTable,
2477 cancellable: *mut gio::GCancellable,
2478 error: *mut *mut glib::GError,
2479 ) -> gboolean;
2480 #[cfg(feature = "v2018_6")]
2481 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2482 pub fn ostree_repo_resolve_collection_ref(
2483 self_: *mut OstreeRepo,
2484 ref_: *const OstreeCollectionRef,
2485 allow_noent: gboolean,
2486 flags: OstreeRepoResolveRevExtFlags,
2487 out_rev: *mut *mut c_char,
2488 cancellable: *mut gio::GCancellable,
2489 error: *mut *mut glib::GError,
2490 ) -> gboolean;
2491 #[cfg(feature = "v2018_6")]
2492 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2493 pub fn ostree_repo_resolve_keyring_for_collection(
2494 self_: *mut OstreeRepo,
2495 collection_id: *const c_char,
2496 cancellable: *mut gio::GCancellable,
2497 error: *mut *mut glib::GError,
2498 ) -> *mut OstreeRemote;
2499 pub fn ostree_repo_resolve_rev(
2500 self_: *mut OstreeRepo,
2501 refspec: *const c_char,
2502 allow_noent: gboolean,
2503 out_rev: *mut *mut c_char,
2504 error: *mut *mut glib::GError,
2505 ) -> gboolean;
2506 #[cfg(feature = "v2016_7")]
2507 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_7")))]
2508 pub fn ostree_repo_resolve_rev_ext(
2509 self_: *mut OstreeRepo,
2510 refspec: *const c_char,
2511 allow_noent: gboolean,
2512 flags: OstreeRepoResolveRevExtFlags,
2513 out_rev: *mut *mut c_char,
2514 error: *mut *mut glib::GError,
2515 ) -> gboolean;
2516 pub fn ostree_repo_scan_hardlinks(
2517 self_: *mut OstreeRepo,
2518 cancellable: *mut gio::GCancellable,
2519 error: *mut *mut glib::GError,
2520 ) -> gboolean;
2521 #[cfg(feature = "v2017_10")]
2522 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
2523 pub fn ostree_repo_set_alias_ref_immediate(
2524 self_: *mut OstreeRepo,
2525 remote: *const c_char,
2526 ref_: *const c_char,
2527 target: *const c_char,
2528 cancellable: *mut gio::GCancellable,
2529 error: *mut *mut glib::GError,
2530 ) -> gboolean;
2531 #[cfg(feature = "v2016_5")]
2532 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
2533 pub fn ostree_repo_set_cache_dir(
2534 self_: *mut OstreeRepo,
2535 dfd: c_int,
2536 path: *const c_char,
2537 cancellable: *mut gio::GCancellable,
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_id(
2543 self_: *mut OstreeRepo,
2544 collection_id: *const c_char,
2545 error: *mut *mut glib::GError,
2546 ) -> gboolean;
2547 #[cfg(feature = "v2018_6")]
2548 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2549 pub fn ostree_repo_set_collection_ref_immediate(
2550 self_: *mut OstreeRepo,
2551 ref_: *const OstreeCollectionRef,
2552 checksum: *const c_char,
2553 cancellable: *mut gio::GCancellable,
2554 error: *mut *mut glib::GError,
2555 ) -> gboolean;
2556 pub fn ostree_repo_set_disable_fsync(self_: *mut OstreeRepo, disable_fsync: gboolean);
2557 pub fn ostree_repo_set_ref_immediate(
2558 self_: *mut OstreeRepo,
2559 remote: *const c_char,
2560 ref_: *const c_char,
2561 checksum: *const c_char,
2562 cancellable: *mut gio::GCancellable,
2563 error: *mut *mut glib::GError,
2564 ) -> gboolean;
2565 pub fn ostree_repo_sign_commit(
2566 self_: *mut OstreeRepo,
2567 commit_checksum: *const c_char,
2568 key_id: *const c_char,
2569 homedir: *const c_char,
2570 cancellable: *mut gio::GCancellable,
2571 error: *mut *mut glib::GError,
2572 ) -> gboolean;
2573 pub fn ostree_repo_sign_delta(
2574 self_: *mut OstreeRepo,
2575 from_commit: *const c_char,
2576 to_commit: *const c_char,
2577 key_id: *const c_char,
2578 homedir: *const c_char,
2579 cancellable: *mut gio::GCancellable,
2580 error: *mut *mut glib::GError,
2581 ) -> gboolean;
2582 #[cfg(feature = "v2021_4")]
2583 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_4")))]
2584 pub fn ostree_repo_signature_verify_commit_data(
2585 self_: *mut OstreeRepo,
2586 remote_name: *const c_char,
2587 commit_data: *mut glib::GBytes,
2588 commit_metadata: *mut glib::GBytes,
2589 flags: OstreeRepoVerifyFlags,
2590 out_results: *mut *mut c_char,
2591 error: *mut *mut glib::GError,
2592 ) -> gboolean;
2593 pub fn ostree_repo_static_delta_execute_offline(
2594 self_: *mut OstreeRepo,
2595 dir_or_file: *mut gio::GFile,
2596 skip_validation: gboolean,
2597 cancellable: *mut gio::GCancellable,
2598 error: *mut *mut glib::GError,
2599 ) -> gboolean;
2600 #[cfg(feature = "v2020_7")]
2601 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
2602 pub fn ostree_repo_static_delta_execute_offline_with_signature(
2603 self_: *mut OstreeRepo,
2604 dir_or_file: *mut gio::GFile,
2605 sign: *mut OstreeSign,
2606 skip_validation: gboolean,
2607 cancellable: *mut gio::GCancellable,
2608 error: *mut *mut glib::GError,
2609 ) -> gboolean;
2610 pub fn ostree_repo_static_delta_generate(
2611 self_: *mut OstreeRepo,
2612 opt: OstreeStaticDeltaGenerateOpt,
2613 from: *const c_char,
2614 to: *const c_char,
2615 metadata: *mut glib::GVariant,
2616 params: *mut glib::GVariant,
2617 cancellable: *mut gio::GCancellable,
2618 error: *mut *mut glib::GError,
2619 ) -> gboolean;
2620 #[cfg(feature = "v2020_8")]
2621 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_8")))]
2622 pub fn ostree_repo_static_delta_reindex(
2623 repo: *mut OstreeRepo,
2624 flags: OstreeStaticDeltaIndexFlags,
2625 opt_to_commit: *const c_char,
2626 cancellable: *mut gio::GCancellable,
2627 error: *mut *mut glib::GError,
2628 ) -> gboolean;
2629 #[cfg(feature = "v2020_7")]
2630 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
2631 pub fn ostree_repo_static_delta_verify_signature(
2632 self_: *mut OstreeRepo,
2633 delta_id: *const c_char,
2634 sign: *mut OstreeSign,
2635 out_success_message: *mut *mut c_char,
2636 error: *mut *mut glib::GError,
2637 ) -> gboolean;
2638 #[cfg(feature = "v2018_6")]
2639 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2640 pub fn ostree_repo_transaction_set_collection_ref(
2641 self_: *mut OstreeRepo,
2642 ref_: *const OstreeCollectionRef,
2643 checksum: *const c_char,
2644 );
2645 pub fn ostree_repo_transaction_set_ref(
2646 self_: *mut OstreeRepo,
2647 remote: *const c_char,
2648 ref_: *const c_char,
2649 checksum: *const c_char,
2650 );
2651 pub fn ostree_repo_transaction_set_refspec(
2652 self_: *mut OstreeRepo,
2653 refspec: *const c_char,
2654 checksum: *const c_char,
2655 );
2656 pub fn ostree_repo_traverse_commit(
2657 repo: *mut OstreeRepo,
2658 commit_checksum: *const c_char,
2659 maxdepth: c_int,
2660 out_reachable: *mut *mut glib::GHashTable,
2661 cancellable: *mut gio::GCancellable,
2662 error: *mut *mut glib::GError,
2663 ) -> gboolean;
2664 pub fn ostree_repo_traverse_commit_union(
2665 repo: *mut OstreeRepo,
2666 commit_checksum: *const c_char,
2667 maxdepth: c_int,
2668 inout_reachable: *mut glib::GHashTable,
2669 cancellable: *mut gio::GCancellable,
2670 error: *mut *mut glib::GError,
2671 ) -> gboolean;
2672 #[cfg(feature = "v2018_5")]
2673 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
2674 pub fn ostree_repo_traverse_commit_union_with_parents(
2675 repo: *mut OstreeRepo,
2676 commit_checksum: *const c_char,
2677 maxdepth: c_int,
2678 inout_reachable: *mut glib::GHashTable,
2679 inout_parents: *mut glib::GHashTable,
2680 cancellable: *mut gio::GCancellable,
2681 error: *mut *mut glib::GError,
2682 ) -> gboolean;
2683 #[cfg(feature = "v2018_5")]
2684 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
2685 pub fn ostree_repo_traverse_commit_with_flags(
2686 repo: *mut OstreeRepo,
2687 flags: OstreeRepoCommitTraverseFlags,
2688 commit_checksum: *const c_char,
2689 maxdepth: c_int,
2690 inout_reachable: *mut glib::GHashTable,
2691 inout_parents: *mut glib::GHashTable,
2692 cancellable: *mut gio::GCancellable,
2693 error: *mut *mut glib::GError,
2694 ) -> gboolean;
2695 #[cfg(feature = "v2018_6")]
2696 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2697 pub fn ostree_repo_traverse_reachable_refs(
2698 self_: *mut OstreeRepo,
2699 depth: c_uint,
2700 reachable: *mut glib::GHashTable,
2701 cancellable: *mut gio::GCancellable,
2702 error: *mut *mut glib::GError,
2703 ) -> gboolean;
2704 pub fn ostree_repo_verify_commit(
2705 self_: *mut OstreeRepo,
2706 commit_checksum: *const c_char,
2707 keyringdir: *mut gio::GFile,
2708 extra_keyring: *mut gio::GFile,
2709 cancellable: *mut gio::GCancellable,
2710 error: *mut *mut glib::GError,
2711 ) -> gboolean;
2712 pub fn ostree_repo_verify_commit_ext(
2713 self_: *mut OstreeRepo,
2714 commit_checksum: *const c_char,
2715 keyringdir: *mut gio::GFile,
2716 extra_keyring: *mut gio::GFile,
2717 cancellable: *mut gio::GCancellable,
2718 error: *mut *mut glib::GError,
2719 ) -> *mut OstreeGpgVerifyResult;
2720 #[cfg(feature = "v2016_14")]
2721 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_14")))]
2722 pub fn ostree_repo_verify_commit_for_remote(
2723 self_: *mut OstreeRepo,
2724 commit_checksum: *const c_char,
2725 remote_name: *const c_char,
2726 cancellable: *mut gio::GCancellable,
2727 error: *mut *mut glib::GError,
2728 ) -> *mut OstreeGpgVerifyResult;
2729 pub fn ostree_repo_verify_summary(
2730 self_: *mut OstreeRepo,
2731 remote_name: *const c_char,
2732 summary: *mut glib::GBytes,
2733 signatures: *mut glib::GBytes,
2734 cancellable: *mut gio::GCancellable,
2735 error: *mut *mut glib::GError,
2736 ) -> *mut OstreeGpgVerifyResult;
2737 pub fn ostree_repo_write_archive_to_mtree(
2738 self_: *mut OstreeRepo,
2739 archive: *mut gio::GFile,
2740 mtree: *mut OstreeMutableTree,
2741 modifier: *mut OstreeRepoCommitModifier,
2742 autocreate_parents: gboolean,
2743 cancellable: *mut gio::GCancellable,
2744 error: *mut *mut glib::GError,
2745 ) -> gboolean;
2746 pub fn ostree_repo_write_archive_to_mtree_from_fd(
2747 self_: *mut OstreeRepo,
2748 fd: c_int,
2749 mtree: *mut OstreeMutableTree,
2750 modifier: *mut OstreeRepoCommitModifier,
2751 autocreate_parents: gboolean,
2752 cancellable: *mut gio::GCancellable,
2753 error: *mut *mut glib::GError,
2754 ) -> gboolean;
2755 pub fn ostree_repo_write_commit(
2756 self_: *mut OstreeRepo,
2757 parent: *const c_char,
2758 subject: *const c_char,
2759 body: *const c_char,
2760 metadata: *mut glib::GVariant,
2761 root: *mut OstreeRepoFile,
2762 out_commit: *mut *mut c_char,
2763 cancellable: *mut gio::GCancellable,
2764 error: *mut *mut glib::GError,
2765 ) -> gboolean;
2766 pub fn ostree_repo_write_commit_detached_metadata(
2767 self_: *mut OstreeRepo,
2768 checksum: *const c_char,
2769 metadata: *mut glib::GVariant,
2770 cancellable: *mut gio::GCancellable,
2771 error: *mut *mut glib::GError,
2772 ) -> gboolean;
2773 pub fn ostree_repo_write_commit_with_time(
2774 self_: *mut OstreeRepo,
2775 parent: *const c_char,
2776 subject: *const c_char,
2777 body: *const c_char,
2778 metadata: *mut glib::GVariant,
2779 root: *mut OstreeRepoFile,
2780 time: u64,
2781 out_commit: *mut *mut c_char,
2782 cancellable: *mut gio::GCancellable,
2783 error: *mut *mut glib::GError,
2784 ) -> gboolean;
2785 pub fn ostree_repo_write_config(
2786 self_: *mut OstreeRepo,
2787 new_config: *mut glib::GKeyFile,
2788 error: *mut *mut glib::GError,
2789 ) -> gboolean;
2790 pub fn ostree_repo_write_config_and_reload(
2791 self_: *mut OstreeRepo,
2792 new_config: *mut glib::GKeyFile,
2793 error: *mut *mut glib::GError,
2794 ) -> gboolean;
2795 pub fn ostree_repo_write_content(
2796 self_: *mut OstreeRepo,
2797 expected_checksum: *const c_char,
2798 object_input: *mut gio::GInputStream,
2799 length: u64,
2800 out_csum: *mut *mut [*mut u8; 32],
2801 cancellable: *mut gio::GCancellable,
2802 error: *mut *mut glib::GError,
2803 ) -> gboolean;
2804 pub fn ostree_repo_write_content_async(
2805 self_: *mut OstreeRepo,
2806 expected_checksum: *const c_char,
2807 object: *mut gio::GInputStream,
2808 length: u64,
2809 cancellable: *mut gio::GCancellable,
2810 callback: gio::GAsyncReadyCallback,
2811 user_data: gpointer,
2812 );
2813 pub fn ostree_repo_write_content_finish(
2814 self_: *mut OstreeRepo,
2815 result: *mut gio::GAsyncResult,
2816 out_csum: *mut *mut u8,
2817 error: *mut *mut glib::GError,
2818 ) -> gboolean;
2819 pub fn ostree_repo_write_content_trusted(
2820 self_: *mut OstreeRepo,
2821 checksum: *const c_char,
2822 object_input: *mut gio::GInputStream,
2823 length: u64,
2824 cancellable: *mut gio::GCancellable,
2825 error: *mut *mut glib::GError,
2826 ) -> gboolean;
2827 pub fn ostree_repo_write_dfd_to_mtree(
2828 self_: *mut OstreeRepo,
2829 dfd: c_int,
2830 path: *const c_char,
2831 mtree: *mut OstreeMutableTree,
2832 modifier: *mut OstreeRepoCommitModifier,
2833 cancellable: *mut gio::GCancellable,
2834 error: *mut *mut glib::GError,
2835 ) -> gboolean;
2836 pub fn ostree_repo_write_directory_to_mtree(
2837 self_: *mut OstreeRepo,
2838 dir: *mut gio::GFile,
2839 mtree: *mut OstreeMutableTree,
2840 modifier: *mut OstreeRepoCommitModifier,
2841 cancellable: *mut gio::GCancellable,
2842 error: *mut *mut glib::GError,
2843 ) -> gboolean;
2844 pub fn ostree_repo_write_metadata(
2845 self_: *mut OstreeRepo,
2846 objtype: OstreeObjectType,
2847 expected_checksum: *const c_char,
2848 object: *mut glib::GVariant,
2849 out_csum: *mut *mut [*mut u8; 32],
2850 cancellable: *mut gio::GCancellable,
2851 error: *mut *mut glib::GError,
2852 ) -> gboolean;
2853 pub fn ostree_repo_write_metadata_async(
2854 self_: *mut OstreeRepo,
2855 objtype: OstreeObjectType,
2856 expected_checksum: *const c_char,
2857 object: *mut glib::GVariant,
2858 cancellable: *mut gio::GCancellable,
2859 callback: gio::GAsyncReadyCallback,
2860 user_data: gpointer,
2861 );
2862 pub fn ostree_repo_write_metadata_finish(
2863 self_: *mut OstreeRepo,
2864 result: *mut gio::GAsyncResult,
2865 out_csum: *mut *mut [c_uchar; 32],
2866 error: *mut *mut glib::GError,
2867 ) -> gboolean;
2868 pub fn ostree_repo_write_metadata_stream_trusted(
2869 self_: *mut OstreeRepo,
2870 objtype: OstreeObjectType,
2871 checksum: *const c_char,
2872 object_input: *mut gio::GInputStream,
2873 length: u64,
2874 cancellable: *mut gio::GCancellable,
2875 error: *mut *mut glib::GError,
2876 ) -> gboolean;
2877 pub fn ostree_repo_write_metadata_trusted(
2878 self_: *mut OstreeRepo,
2879 objtype: OstreeObjectType,
2880 checksum: *const c_char,
2881 variant: *mut glib::GVariant,
2882 cancellable: *mut gio::GCancellable,
2883 error: *mut *mut glib::GError,
2884 ) -> gboolean;
2885 pub fn ostree_repo_write_mtree(
2886 self_: *mut OstreeRepo,
2887 mtree: *mut OstreeMutableTree,
2888 out_file: *mut *mut gio::GFile,
2889 cancellable: *mut gio::GCancellable,
2890 error: *mut *mut glib::GError,
2891 ) -> gboolean;
2892 #[cfg(feature = "v2021_2")]
2893 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_2")))]
2894 pub fn ostree_repo_write_regfile(
2895 self_: *mut OstreeRepo,
2896 expected_checksum: *const c_char,
2897 uid: u32,
2898 gid: u32,
2899 mode: u32,
2900 content_len: u64,
2901 xattrs: *mut glib::GVariant,
2902 error: *mut *mut glib::GError,
2903 ) -> *mut OstreeContentWriter;
2904 #[cfg(feature = "v2021_2")]
2905 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_2")))]
2906 pub fn ostree_repo_write_regfile_inline(
2907 self_: *mut OstreeRepo,
2908 expected_checksum: *const c_char,
2909 uid: u32,
2910 gid: u32,
2911 mode: u32,
2912 xattrs: *mut glib::GVariant,
2913 buf: *const u8,
2914 len: size_t,
2915 cancellable: *mut gio::GCancellable,
2916 error: *mut *mut glib::GError,
2917 ) -> *mut c_char;
2918 #[cfg(feature = "v2021_2")]
2919 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_2")))]
2920 pub fn ostree_repo_write_symlink(
2921 self_: *mut OstreeRepo,
2922 expected_checksum: *const c_char,
2923 uid: u32,
2924 gid: u32,
2925 xattrs: *mut glib::GVariant,
2926 symlink_target: *const c_char,
2927 cancellable: *mut gio::GCancellable,
2928 error: *mut *mut glib::GError,
2929 ) -> *mut c_char;
2930
2931 pub fn ostree_repo_file_get_type() -> GType;
2935 pub fn ostree_repo_file_ensure_resolved(
2936 self_: *mut OstreeRepoFile,
2937 error: *mut *mut glib::GError,
2938 ) -> gboolean;
2939 pub fn ostree_repo_file_get_checksum(self_: *mut OstreeRepoFile) -> *const c_char;
2940 pub fn ostree_repo_file_get_repo(self_: *mut OstreeRepoFile) -> *mut OstreeRepo;
2941 pub fn ostree_repo_file_get_root(self_: *mut OstreeRepoFile) -> *mut OstreeRepoFile;
2942 pub fn ostree_repo_file_get_xattrs(
2943 self_: *mut OstreeRepoFile,
2944 out_xattrs: *mut *mut glib::GVariant,
2945 cancellable: *mut gio::GCancellable,
2946 error: *mut *mut glib::GError,
2947 ) -> gboolean;
2948 pub fn ostree_repo_file_tree_find_child(
2949 self_: *mut OstreeRepoFile,
2950 name: *const c_char,
2951 is_dir: *mut gboolean,
2952 out_container: *mut *mut glib::GVariant,
2953 ) -> c_int;
2954 pub fn ostree_repo_file_tree_get_contents(self_: *mut OstreeRepoFile) -> *mut glib::GVariant;
2955 pub fn ostree_repo_file_tree_get_contents_checksum(self_: *mut OstreeRepoFile)
2956 -> *const c_char;
2957 pub fn ostree_repo_file_tree_get_metadata(self_: *mut OstreeRepoFile) -> *mut glib::GVariant;
2958 pub fn ostree_repo_file_tree_get_metadata_checksum(self_: *mut OstreeRepoFile)
2959 -> *const c_char;
2960 pub fn ostree_repo_file_tree_query_child(
2961 self_: *mut OstreeRepoFile,
2962 n: c_int,
2963 attributes: *const c_char,
2964 flags: gio::GFileQueryInfoFlags,
2965 out_info: *mut *mut gio::GFileInfo,
2966 cancellable: *mut gio::GCancellable,
2967 error: *mut *mut glib::GError,
2968 ) -> gboolean;
2969 pub fn ostree_repo_file_tree_set_metadata(
2970 self_: *mut OstreeRepoFile,
2971 checksum: *const c_char,
2972 metadata: *mut glib::GVariant,
2973 );
2974
2975 pub fn ostree_repo_finder_avahi_get_type() -> GType;
2979 #[cfg(feature = "v2018_6")]
2980 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2981 pub fn ostree_repo_finder_avahi_new(
2982 context: *mut glib::GMainContext,
2983 ) -> *mut OstreeRepoFinderAvahi;
2984 #[cfg(feature = "v2018_6")]
2985 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2986 pub fn ostree_repo_finder_avahi_start(
2987 self_: *mut OstreeRepoFinderAvahi,
2988 error: *mut *mut glib::GError,
2989 );
2990 #[cfg(feature = "v2018_6")]
2991 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
2992 pub fn ostree_repo_finder_avahi_stop(self_: *mut OstreeRepoFinderAvahi);
2993
2994 pub fn ostree_repo_finder_config_get_type() -> GType;
2998 #[cfg(feature = "v2018_6")]
2999 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3000 pub fn ostree_repo_finder_config_new() -> *mut OstreeRepoFinderConfig;
3001
3002 pub fn ostree_repo_finder_mount_get_type() -> GType;
3006 #[cfg(feature = "v2018_6")]
3007 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3008 pub fn ostree_repo_finder_mount_new(
3009 monitor: *mut gio::GVolumeMonitor,
3010 ) -> *mut OstreeRepoFinderMount;
3011
3012 pub fn ostree_repo_finder_override_get_type() -> GType;
3016 #[cfg(feature = "v2018_6")]
3017 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3018 pub fn ostree_repo_finder_override_new() -> *mut OstreeRepoFinderOverride;
3019 #[cfg(feature = "v2018_6")]
3020 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3021 pub fn ostree_repo_finder_override_add_uri(
3022 self_: *mut OstreeRepoFinderOverride,
3023 uri: *const c_char,
3024 );
3025
3026 pub fn ostree_sepolicy_get_type() -> GType;
3030 pub fn ostree_sepolicy_new(
3031 path: *mut gio::GFile,
3032 cancellable: *mut gio::GCancellable,
3033 error: *mut *mut glib::GError,
3034 ) -> *mut OstreeSePolicy;
3035 #[cfg(feature = "v2017_4")]
3036 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3037 pub fn ostree_sepolicy_new_at(
3038 rootfs_dfd: c_int,
3039 cancellable: *mut gio::GCancellable,
3040 error: *mut *mut glib::GError,
3041 ) -> *mut OstreeSePolicy;
3042 pub fn ostree_sepolicy_new_from_commit(
3043 repo: *mut OstreeRepo,
3044 rev: *const c_char,
3045 cancellable: *mut gio::GCancellable,
3046 error: *mut *mut glib::GError,
3047 ) -> *mut OstreeSePolicy;
3048 pub fn ostree_sepolicy_fscreatecon_cleanup(unused: *mut *mut c_void);
3049 #[cfg(feature = "v2025_2")]
3050 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_2")))]
3051 pub fn ostree_sepolicy_set_null_log();
3052 #[cfg(feature = "v2016_5")]
3053 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_5")))]
3054 pub fn ostree_sepolicy_get_csum(self_: *mut OstreeSePolicy) -> *const c_char;
3055 pub fn ostree_sepolicy_get_label(
3056 self_: *mut OstreeSePolicy,
3057 relpath: *const c_char,
3058 unix_mode: u32,
3059 out_label: *mut *mut c_char,
3060 cancellable: *mut gio::GCancellable,
3061 error: *mut *mut glib::GError,
3062 ) -> gboolean;
3063 pub fn ostree_sepolicy_get_name(self_: *mut OstreeSePolicy) -> *const c_char;
3064 pub fn ostree_sepolicy_get_path(self_: *mut OstreeSePolicy) -> *mut gio::GFile;
3065 pub fn ostree_sepolicy_restorecon(
3066 self_: *mut OstreeSePolicy,
3067 path: *const c_char,
3068 info: *mut gio::GFileInfo,
3069 target: *mut gio::GFile,
3070 flags: OstreeSePolicyRestoreconFlags,
3071 out_new_label: *mut *mut c_char,
3072 cancellable: *mut gio::GCancellable,
3073 error: *mut *mut glib::GError,
3074 ) -> gboolean;
3075 pub fn ostree_sepolicy_setfscreatecon(
3076 self_: *mut OstreeSePolicy,
3077 path: *const c_char,
3078 mode: u32,
3079 error: *mut *mut glib::GError,
3080 ) -> gboolean;
3081
3082 pub fn ostree_sysroot_get_type() -> GType;
3086 pub fn ostree_sysroot_new(path: *mut gio::GFile) -> *mut OstreeSysroot;
3087 pub fn ostree_sysroot_new_default() -> *mut OstreeSysroot;
3088 pub fn ostree_sysroot_get_deployment_origin_path(
3089 deployment_path: *mut gio::GFile,
3090 ) -> *mut gio::GFile;
3091 #[cfg(feature = "v2023_8")]
3092 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_8")))]
3093 pub fn ostree_sysroot_change_finalization(
3094 self_: *mut OstreeSysroot,
3095 deployment: *mut OstreeDeployment,
3096 error: *mut *mut glib::GError,
3097 ) -> gboolean;
3098 pub fn ostree_sysroot_cleanup(
3099 self_: *mut OstreeSysroot,
3100 cancellable: *mut gio::GCancellable,
3101 error: *mut *mut glib::GError,
3102 ) -> gboolean;
3103 #[cfg(feature = "v2018_6")]
3104 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3105 pub fn ostree_sysroot_cleanup_prune_repo(
3106 sysroot: *mut OstreeSysroot,
3107 options: *mut OstreeRepoPruneOptions,
3108 out_objects_total: *mut c_int,
3109 out_objects_pruned: *mut c_int,
3110 out_pruned_object_size_total: *mut u64,
3111 cancellable: *mut gio::GCancellable,
3112 error: *mut *mut glib::GError,
3113 ) -> gboolean;
3114 #[cfg(feature = "v2025_3")]
3115 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_3")))]
3116 pub fn ostree_sysroot_clear_soft_reboot(
3117 self_: *mut OstreeSysroot,
3118 cancellable: *mut gio::GCancellable,
3119 error: *mut *mut glib::GError,
3120 ) -> gboolean;
3121 #[cfg(feature = "v2018_5")]
3122 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
3123 pub fn ostree_sysroot_deploy_tree(
3124 self_: *mut OstreeSysroot,
3125 osname: *const c_char,
3126 revision: *const c_char,
3127 origin: *mut glib::GKeyFile,
3128 provided_merge_deployment: *mut OstreeDeployment,
3129 override_kernel_argv: *mut *mut c_char,
3130 out_new_deployment: *mut *mut OstreeDeployment,
3131 cancellable: *mut gio::GCancellable,
3132 error: *mut *mut glib::GError,
3133 ) -> gboolean;
3134 #[cfg(feature = "v2020_7")]
3135 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
3136 pub fn ostree_sysroot_deploy_tree_with_options(
3137 self_: *mut OstreeSysroot,
3138 osname: *const c_char,
3139 revision: *const c_char,
3140 origin: *mut glib::GKeyFile,
3141 provided_merge_deployment: *mut OstreeDeployment,
3142 opts: *mut OstreeSysrootDeployTreeOpts,
3143 out_new_deployment: *mut *mut OstreeDeployment,
3144 cancellable: *mut gio::GCancellable,
3145 error: *mut *mut glib::GError,
3146 ) -> gboolean;
3147 #[cfg(feature = "v2025_3")]
3148 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_3")))]
3149 pub fn ostree_sysroot_deployment_can_soft_reboot(
3150 self_: *mut OstreeSysroot,
3151 deployment: *mut OstreeDeployment,
3152 ) -> gboolean;
3153 #[cfg(feature = "v2025_1")]
3154 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_1")))]
3155 pub fn ostree_sysroot_deployment_kexec_load(
3156 self_: *mut OstreeSysroot,
3157 deployment: *mut OstreeDeployment,
3158 cancellable: *mut gio::GCancellable,
3159 error: *mut *mut glib::GError,
3160 ) -> gboolean;
3161 pub fn ostree_sysroot_deployment_set_kargs(
3162 self_: *mut OstreeSysroot,
3163 deployment: *mut OstreeDeployment,
3164 new_kargs: *mut *mut c_char,
3165 cancellable: *mut gio::GCancellable,
3166 error: *mut *mut glib::GError,
3167 ) -> gboolean;
3168 pub fn ostree_sysroot_deployment_set_kargs_in_place(
3169 self_: *mut OstreeSysroot,
3170 deployment: *mut OstreeDeployment,
3171 kargs_str: *mut c_char,
3172 cancellable: *mut gio::GCancellable,
3173 error: *mut *mut glib::GError,
3174 ) -> gboolean;
3175 pub fn ostree_sysroot_deployment_set_mutable(
3176 self_: *mut OstreeSysroot,
3177 deployment: *mut OstreeDeployment,
3178 is_mutable: gboolean,
3179 cancellable: *mut gio::GCancellable,
3180 error: *mut *mut glib::GError,
3181 ) -> gboolean;
3182 #[cfg(feature = "v2018_3")]
3183 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_3")))]
3184 pub fn ostree_sysroot_deployment_set_pinned(
3185 self_: *mut OstreeSysroot,
3186 deployment: *mut OstreeDeployment,
3187 is_pinned: gboolean,
3188 error: *mut *mut glib::GError,
3189 ) -> gboolean;
3190 #[cfg(feature = "v2025_3")]
3191 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_3")))]
3192 pub fn ostree_sysroot_deployment_set_soft_reboot(
3193 self_: *mut OstreeSysroot,
3194 deployment: *mut OstreeDeployment,
3195 allow_kernel_skew: gboolean,
3196 cancellable: *mut gio::GCancellable,
3197 error: *mut *mut glib::GError,
3198 ) -> gboolean;
3199 #[cfg(feature = "v2016_4")]
3200 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
3201 pub fn ostree_sysroot_deployment_unlock(
3202 self_: *mut OstreeSysroot,
3203 deployment: *mut OstreeDeployment,
3204 unlocked_state: OstreeDeploymentUnlockedState,
3205 cancellable: *mut gio::GCancellable,
3206 error: *mut *mut glib::GError,
3207 ) -> gboolean;
3208 pub fn ostree_sysroot_ensure_initialized(
3209 self_: *mut OstreeSysroot,
3210 cancellable: *mut gio::GCancellable,
3211 error: *mut *mut glib::GError,
3212 ) -> gboolean;
3213 pub fn ostree_sysroot_get_booted_deployment(self_: *mut OstreeSysroot)
3214 -> *mut OstreeDeployment;
3215 pub fn ostree_sysroot_get_bootversion(self_: *mut OstreeSysroot) -> c_int;
3216 pub fn ostree_sysroot_get_deployment_directory(
3217 self_: *mut OstreeSysroot,
3218 deployment: *mut OstreeDeployment,
3219 ) -> *mut gio::GFile;
3220 pub fn ostree_sysroot_get_deployment_dirpath(
3221 self_: *mut OstreeSysroot,
3222 deployment: *mut OstreeDeployment,
3223 ) -> *mut c_char;
3224 pub fn ostree_sysroot_get_deployments(self_: *mut OstreeSysroot) -> *mut glib::GPtrArray;
3225 pub fn ostree_sysroot_get_fd(self_: *mut OstreeSysroot) -> c_int;
3226 pub fn ostree_sysroot_get_merge_deployment(
3227 self_: *mut OstreeSysroot,
3228 osname: *const c_char,
3229 ) -> *mut OstreeDeployment;
3230 pub fn ostree_sysroot_get_path(self_: *mut OstreeSysroot) -> *mut gio::GFile;
3231 pub fn ostree_sysroot_get_repo(
3232 self_: *mut OstreeSysroot,
3233 out_repo: *mut *mut OstreeRepo,
3234 cancellable: *mut gio::GCancellable,
3235 error: *mut *mut glib::GError,
3236 ) -> gboolean;
3237 #[cfg(feature = "v2018_5")]
3238 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
3239 pub fn ostree_sysroot_get_staged_deployment(self_: *mut OstreeSysroot)
3240 -> *mut OstreeDeployment;
3241 pub fn ostree_sysroot_get_subbootversion(self_: *mut OstreeSysroot) -> c_int;
3242 #[cfg(feature = "v2016_4")]
3243 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
3244 pub fn ostree_sysroot_init_osname(
3245 self_: *mut OstreeSysroot,
3246 osname: *const c_char,
3247 cancellable: *mut gio::GCancellable,
3248 error: *mut *mut glib::GError,
3249 ) -> gboolean;
3250 #[cfg(feature = "v2020_1")]
3251 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3252 pub fn ostree_sysroot_initialize(
3253 self_: *mut OstreeSysroot,
3254 error: *mut *mut glib::GError,
3255 ) -> gboolean;
3256 #[cfg(feature = "v2022_7")]
3257 #[cfg_attr(docsrs, doc(cfg(feature = "v2022_7")))]
3258 pub fn ostree_sysroot_initialize_with_mount_namespace(
3259 self_: *mut OstreeSysroot,
3260 cancellable: *mut gio::GCancellable,
3261 error: *mut *mut glib::GError,
3262 ) -> gboolean;
3263 #[cfg(feature = "v2020_1")]
3264 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3265 pub fn ostree_sysroot_is_booted(self_: *mut OstreeSysroot) -> gboolean;
3266 pub fn ostree_sysroot_load(
3267 self_: *mut OstreeSysroot,
3268 cancellable: *mut gio::GCancellable,
3269 error: *mut *mut glib::GError,
3270 ) -> gboolean;
3271 #[cfg(feature = "v2016_4")]
3272 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_4")))]
3273 pub fn ostree_sysroot_load_if_changed(
3274 self_: *mut OstreeSysroot,
3275 out_changed: *mut gboolean,
3276 cancellable: *mut gio::GCancellable,
3277 error: *mut *mut glib::GError,
3278 ) -> gboolean;
3279 pub fn ostree_sysroot_lock(
3280 self_: *mut OstreeSysroot,
3281 error: *mut *mut glib::GError,
3282 ) -> gboolean;
3283 pub fn ostree_sysroot_lock_async(
3284 self_: *mut OstreeSysroot,
3285 cancellable: *mut gio::GCancellable,
3286 callback: gio::GAsyncReadyCallback,
3287 user_data: gpointer,
3288 );
3289 pub fn ostree_sysroot_lock_finish(
3290 self_: *mut OstreeSysroot,
3291 result: *mut gio::GAsyncResult,
3292 error: *mut *mut glib::GError,
3293 ) -> gboolean;
3294 pub fn ostree_sysroot_origin_new_from_refspec(
3295 self_: *mut OstreeSysroot,
3296 refspec: *const c_char,
3297 ) -> *mut glib::GKeyFile;
3298 pub fn ostree_sysroot_prepare_cleanup(
3299 self_: *mut OstreeSysroot,
3300 cancellable: *mut gio::GCancellable,
3301 error: *mut *mut glib::GError,
3302 ) -> gboolean;
3303 #[cfg(feature = "v2017_7")]
3304 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_7")))]
3305 pub fn ostree_sysroot_query_deployments_for(
3306 self_: *mut OstreeSysroot,
3307 osname: *const c_char,
3308 out_pending: *mut *mut OstreeDeployment,
3309 out_rollback: *mut *mut OstreeDeployment,
3310 );
3311 #[cfg(feature = "v2017_7")]
3312 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_7")))]
3313 pub fn ostree_sysroot_repo(self_: *mut OstreeSysroot) -> *mut OstreeRepo;
3314 #[cfg(feature = "v2021_1")]
3315 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_1")))]
3316 pub fn ostree_sysroot_require_booted_deployment(
3317 self_: *mut OstreeSysroot,
3318 error: *mut *mut glib::GError,
3319 ) -> *mut OstreeDeployment;
3320 #[cfg(feature = "v2020_1")]
3321 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3322 pub fn ostree_sysroot_set_mount_namespace_in_use(self_: *mut OstreeSysroot);
3323 pub fn ostree_sysroot_simple_write_deployment(
3324 sysroot: *mut OstreeSysroot,
3325 osname: *const c_char,
3326 new_deployment: *mut OstreeDeployment,
3327 merge_deployment: *mut OstreeDeployment,
3328 flags: OstreeSysrootSimpleWriteDeploymentFlags,
3329 cancellable: *mut gio::GCancellable,
3330 error: *mut *mut glib::GError,
3331 ) -> gboolean;
3332 #[cfg(feature = "v2020_7")]
3333 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
3334 pub fn ostree_sysroot_stage_overlay_initrd(
3335 self_: *mut OstreeSysroot,
3336 fd: c_int,
3337 out_checksum: *mut *mut c_char,
3338 cancellable: *mut gio::GCancellable,
3339 error: *mut *mut glib::GError,
3340 ) -> gboolean;
3341 #[cfg(feature = "v2018_5")]
3342 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_5")))]
3343 pub fn ostree_sysroot_stage_tree(
3344 self_: *mut OstreeSysroot,
3345 osname: *const c_char,
3346 revision: *const c_char,
3347 origin: *mut glib::GKeyFile,
3348 merge_deployment: *mut OstreeDeployment,
3349 override_kernel_argv: *mut *mut c_char,
3350 out_new_deployment: *mut *mut OstreeDeployment,
3351 cancellable: *mut gio::GCancellable,
3352 error: *mut *mut glib::GError,
3353 ) -> gboolean;
3354 #[cfg(feature = "v2020_7")]
3355 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_7")))]
3356 pub fn ostree_sysroot_stage_tree_with_options(
3357 self_: *mut OstreeSysroot,
3358 osname: *const c_char,
3359 revision: *const c_char,
3360 origin: *mut glib::GKeyFile,
3361 merge_deployment: *mut OstreeDeployment,
3362 opts: *mut OstreeSysrootDeployTreeOpts,
3363 out_new_deployment: *mut *mut OstreeDeployment,
3364 cancellable: *mut gio::GCancellable,
3365 error: *mut *mut glib::GError,
3366 ) -> gboolean;
3367 pub fn ostree_sysroot_try_lock(
3368 self_: *mut OstreeSysroot,
3369 out_acquired: *mut gboolean,
3370 error: *mut *mut glib::GError,
3371 ) -> gboolean;
3372 pub fn ostree_sysroot_unload(self_: *mut OstreeSysroot);
3373 pub fn ostree_sysroot_unlock(self_: *mut OstreeSysroot);
3374 #[cfg(feature = "v2023_11")]
3375 #[cfg_attr(docsrs, doc(cfg(feature = "v2023_11")))]
3376 pub fn ostree_sysroot_update_post_copy(
3377 self_: *mut OstreeSysroot,
3378 cancellable: *mut gio::GCancellable,
3379 error: *mut *mut glib::GError,
3380 ) -> gboolean;
3381 pub fn ostree_sysroot_write_deployments(
3382 self_: *mut OstreeSysroot,
3383 new_deployments: *mut glib::GPtrArray,
3384 cancellable: *mut gio::GCancellable,
3385 error: *mut *mut glib::GError,
3386 ) -> gboolean;
3387 #[cfg(feature = "v2017_4")]
3388 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3389 pub fn ostree_sysroot_write_deployments_with_options(
3390 self_: *mut OstreeSysroot,
3391 new_deployments: *mut glib::GPtrArray,
3392 opts: *mut OstreeSysrootWriteDeploymentsOpts,
3393 cancellable: *mut gio::GCancellable,
3394 error: *mut *mut glib::GError,
3395 ) -> gboolean;
3396 pub fn ostree_sysroot_write_origin_file(
3397 sysroot: *mut OstreeSysroot,
3398 deployment: *mut OstreeDeployment,
3399 new_origin: *mut glib::GKeyFile,
3400 cancellable: *mut gio::GCancellable,
3401 error: *mut *mut glib::GError,
3402 ) -> gboolean;
3403
3404 pub fn ostree_sysroot_upgrader_get_type() -> GType;
3408 pub fn ostree_sysroot_upgrader_new(
3409 sysroot: *mut OstreeSysroot,
3410 cancellable: *mut gio::GCancellable,
3411 error: *mut *mut glib::GError,
3412 ) -> *mut OstreeSysrootUpgrader;
3413 pub fn ostree_sysroot_upgrader_new_for_os(
3414 sysroot: *mut OstreeSysroot,
3415 osname: *const c_char,
3416 cancellable: *mut gio::GCancellable,
3417 error: *mut *mut glib::GError,
3418 ) -> *mut OstreeSysrootUpgrader;
3419 pub fn ostree_sysroot_upgrader_new_for_os_with_flags(
3420 sysroot: *mut OstreeSysroot,
3421 osname: *const c_char,
3422 flags: OstreeSysrootUpgraderFlags,
3423 cancellable: *mut gio::GCancellable,
3424 error: *mut *mut glib::GError,
3425 ) -> *mut OstreeSysrootUpgrader;
3426 pub fn ostree_sysroot_upgrader_check_timestamps(
3427 repo: *mut OstreeRepo,
3428 from_rev: *const c_char,
3429 to_rev: *const c_char,
3430 error: *mut *mut glib::GError,
3431 ) -> gboolean;
3432 pub fn ostree_sysroot_upgrader_deploy(
3433 self_: *mut OstreeSysrootUpgrader,
3434 cancellable: *mut gio::GCancellable,
3435 error: *mut *mut glib::GError,
3436 ) -> gboolean;
3437 pub fn ostree_sysroot_upgrader_dup_origin(
3438 self_: *mut OstreeSysrootUpgrader,
3439 ) -> *mut glib::GKeyFile;
3440 pub fn ostree_sysroot_upgrader_get_origin(
3441 self_: *mut OstreeSysrootUpgrader,
3442 ) -> *mut glib::GKeyFile;
3443 pub fn ostree_sysroot_upgrader_get_origin_description(
3444 self_: *mut OstreeSysrootUpgrader,
3445 ) -> *mut c_char;
3446 pub fn ostree_sysroot_upgrader_pull(
3447 self_: *mut OstreeSysrootUpgrader,
3448 flags: OstreeRepoPullFlags,
3449 upgrader_flags: OstreeSysrootUpgraderPullFlags,
3450 progress: *mut OstreeAsyncProgress,
3451 out_changed: *mut gboolean,
3452 cancellable: *mut gio::GCancellable,
3453 error: *mut *mut glib::GError,
3454 ) -> gboolean;
3455 pub fn ostree_sysroot_upgrader_pull_one_dir(
3456 self_: *mut OstreeSysrootUpgrader,
3457 dir_to_pull: *const c_char,
3458 flags: OstreeRepoPullFlags,
3459 upgrader_flags: OstreeSysrootUpgraderPullFlags,
3460 progress: *mut OstreeAsyncProgress,
3461 out_changed: *mut gboolean,
3462 cancellable: *mut gio::GCancellable,
3463 error: *mut *mut glib::GError,
3464 ) -> gboolean;
3465 pub fn ostree_sysroot_upgrader_set_origin(
3466 self_: *mut OstreeSysrootUpgrader,
3467 origin: *mut glib::GKeyFile,
3468 cancellable: *mut gio::GCancellable,
3469 error: *mut *mut glib::GError,
3470 ) -> gboolean;
3471
3472 pub fn ostree_blob_reader_get_type() -> GType;
3476 pub fn ostree_blob_reader_read_blob(
3477 self_: *mut OstreeBlobReader,
3478 cancellable: *mut gio::GCancellable,
3479 error: *mut *mut glib::GError,
3480 ) -> *mut glib::GBytes;
3481
3482 pub fn ostree_repo_finder_get_type() -> GType;
3486 #[cfg(feature = "v2018_6")]
3487 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3488 pub fn ostree_repo_finder_resolve_all_async(
3489 finders: *const *mut OstreeRepoFinder,
3490 refs: *const *const OstreeCollectionRef,
3491 parent_repo: *mut OstreeRepo,
3492 cancellable: *mut gio::GCancellable,
3493 callback: gio::GAsyncReadyCallback,
3494 user_data: gpointer,
3495 );
3496 #[cfg(feature = "v2018_6")]
3497 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3498 pub fn ostree_repo_finder_resolve_all_finish(
3499 result: *mut gio::GAsyncResult,
3500 error: *mut *mut glib::GError,
3501 ) -> *mut glib::GPtrArray;
3502 #[cfg(feature = "v2018_6")]
3503 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3504 pub fn ostree_repo_finder_resolve_async(
3505 self_: *mut OstreeRepoFinder,
3506 refs: *const *const OstreeCollectionRef,
3507 parent_repo: *mut OstreeRepo,
3508 cancellable: *mut gio::GCancellable,
3509 callback: gio::GAsyncReadyCallback,
3510 user_data: gpointer,
3511 );
3512 #[cfg(feature = "v2018_6")]
3513 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3514 pub fn ostree_repo_finder_resolve_finish(
3515 self_: *mut OstreeRepoFinder,
3516 result: *mut gio::GAsyncResult,
3517 error: *mut *mut glib::GError,
3518 ) -> *mut glib::GPtrArray;
3519
3520 pub fn ostree_sign_get_type() -> GType;
3524 #[cfg(feature = "v2020_2")]
3525 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3526 pub fn ostree_sign_get_all() -> *mut glib::GPtrArray;
3527 #[cfg(feature = "v2020_2")]
3528 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3529 pub fn ostree_sign_get_by_name(
3530 name: *const c_char,
3531 error: *mut *mut glib::GError,
3532 ) -> *mut OstreeSign;
3533 #[cfg(feature = "v2020_2")]
3534 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3535 pub fn ostree_sign_add_pk(
3536 self_: *mut OstreeSign,
3537 public_key: *mut glib::GVariant,
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_clear_keys(
3543 self_: *mut OstreeSign,
3544 error: *mut *mut glib::GError,
3545 ) -> gboolean;
3546 #[cfg(feature = "v2020_2")]
3547 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3548 pub fn ostree_sign_commit(
3549 self_: *mut OstreeSign,
3550 repo: *mut OstreeRepo,
3551 commit_checksum: *const c_char,
3552 cancellable: *mut gio::GCancellable,
3553 error: *mut *mut glib::GError,
3554 ) -> gboolean;
3555 #[cfg(feature = "v2020_2")]
3556 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3557 pub fn ostree_sign_commit_verify(
3558 self_: *mut OstreeSign,
3559 repo: *mut OstreeRepo,
3560 commit_checksum: *const c_char,
3561 out_success_message: *mut *mut c_char,
3562 cancellable: *mut gio::GCancellable,
3563 error: *mut *mut glib::GError,
3564 ) -> gboolean;
3565 #[cfg(feature = "v2020_2")]
3566 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3567 pub fn ostree_sign_data(
3568 self_: *mut OstreeSign,
3569 data: *mut glib::GBytes,
3570 signature: *mut *mut glib::GBytes,
3571 cancellable: *mut gio::GCancellable,
3572 error: *mut *mut glib::GError,
3573 ) -> gboolean;
3574 #[cfg(feature = "v2020_2")]
3575 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3576 pub fn ostree_sign_data_verify(
3577 self_: *mut OstreeSign,
3578 data: *mut glib::GBytes,
3579 signatures: *mut glib::GVariant,
3580 out_success_message: *mut *mut c_char,
3581 error: *mut *mut glib::GError,
3582 ) -> gboolean;
3583 pub fn ostree_sign_ed25519_add_pk(
3584 self_: *mut OstreeSign,
3585 public_key: *mut glib::GVariant,
3586 error: *mut *mut glib::GError,
3587 ) -> gboolean;
3588 pub fn ostree_sign_ed25519_clear_keys(
3589 self_: *mut OstreeSign,
3590 error: *mut *mut glib::GError,
3591 ) -> gboolean;
3592 pub fn ostree_sign_ed25519_data(
3593 self_: *mut OstreeSign,
3594 data: *mut glib::GBytes,
3595 signature: *mut *mut glib::GBytes,
3596 cancellable: *mut gio::GCancellable,
3597 error: *mut *mut glib::GError,
3598 ) -> gboolean;
3599 pub fn ostree_sign_ed25519_data_verify(
3600 self_: *mut OstreeSign,
3601 data: *mut glib::GBytes,
3602 signatures: *mut glib::GVariant,
3603 out_success_message: *mut *mut c_char,
3604 error: *mut *mut glib::GError,
3605 ) -> gboolean;
3606 pub fn ostree_sign_ed25519_get_name(self_: *mut OstreeSign) -> *const c_char;
3607 pub fn ostree_sign_ed25519_load_pk(
3608 self_: *mut OstreeSign,
3609 options: *mut glib::GVariant,
3610 error: *mut *mut glib::GError,
3611 ) -> gboolean;
3612 pub fn ostree_sign_ed25519_metadata_format(self_: *mut OstreeSign) -> *const c_char;
3613 pub fn ostree_sign_ed25519_metadata_key(self_: *mut OstreeSign) -> *const c_char;
3614 pub fn ostree_sign_ed25519_set_pk(
3615 self_: *mut OstreeSign,
3616 public_key: *mut glib::GVariant,
3617 error: *mut *mut glib::GError,
3618 ) -> gboolean;
3619 pub fn ostree_sign_ed25519_set_sk(
3620 self_: *mut OstreeSign,
3621 secret_key: *mut glib::GVariant,
3622 error: *mut *mut glib::GError,
3623 ) -> gboolean;
3624 #[cfg(feature = "v2020_2")]
3625 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3626 pub fn ostree_sign_get_name(self_: *mut OstreeSign) -> *const c_char;
3627 #[cfg(feature = "v2020_2")]
3628 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3629 pub fn ostree_sign_load_pk(
3630 self_: *mut OstreeSign,
3631 options: *mut glib::GVariant,
3632 error: *mut *mut glib::GError,
3633 ) -> gboolean;
3634 #[cfg(feature = "v2020_2")]
3635 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3636 pub fn ostree_sign_metadata_format(self_: *mut OstreeSign) -> *const c_char;
3637 #[cfg(feature = "v2020_2")]
3638 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3639 pub fn ostree_sign_metadata_key(self_: *mut OstreeSign) -> *const c_char;
3640 #[cfg(feature = "v2025_2")]
3641 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_2")))]
3642 pub fn ostree_sign_read_pk(
3643 self_: *mut OstreeSign,
3644 stream: *mut gio::GInputStream,
3645 ) -> *mut OstreeBlobReader;
3646 #[cfg(feature = "v2025_2")]
3647 #[cfg_attr(docsrs, doc(cfg(feature = "v2025_2")))]
3648 pub fn ostree_sign_read_sk(
3649 self_: *mut OstreeSign,
3650 stream: *mut gio::GInputStream,
3651 ) -> *mut OstreeBlobReader;
3652 #[cfg(feature = "v2020_2")]
3653 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3654 pub fn ostree_sign_set_pk(
3655 self_: *mut OstreeSign,
3656 public_key: *mut glib::GVariant,
3657 error: *mut *mut glib::GError,
3658 ) -> gboolean;
3659 #[cfg(feature = "v2020_2")]
3660 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3661 pub fn ostree_sign_set_sk(
3662 self_: *mut OstreeSign,
3663 secret_key: *mut glib::GVariant,
3664 error: *mut *mut glib::GError,
3665 ) -> gboolean;
3666 #[cfg(feature = "v2020_2")]
3667 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_2")))]
3668 pub fn ostree_sign_summary(
3669 self_: *mut OstreeSign,
3670 repo: *mut OstreeRepo,
3671 keys: *mut glib::GVariant,
3672 cancellable: *mut gio::GCancellable,
3673 error: *mut *mut glib::GError,
3674 ) -> gboolean;
3675
3676 #[cfg(feature = "v2017_15")]
3680 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_15")))]
3681 pub fn ostree_break_hardlink(
3682 dfd: c_int,
3683 path: *const c_char,
3684 skip_xattrs: gboolean,
3685 cancellable: *mut gio::GCancellable,
3686 error: *mut *mut glib::GError,
3687 ) -> gboolean;
3688 #[cfg(feature = "v2017_4")]
3689 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3690 pub fn ostree_check_version(required_year: c_uint, required_release: c_uint) -> gboolean;
3691 #[cfg(feature = "v2016_8")]
3692 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_8")))]
3693 pub fn ostree_checksum_b64_from_bytes(csum: *const [c_uchar; 32]) -> *mut c_char;
3694 pub fn ostree_checksum_b64_inplace_from_bytes(csum: *const [c_uchar; 32], buf: *mut c_char);
3695 pub fn ostree_checksum_b64_inplace_to_bytes(checksum: *const [c_char; 32], buf: *mut u8);
3696 #[cfg(feature = "v2016_8")]
3697 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_8")))]
3698 pub fn ostree_checksum_b64_to_bytes(checksum: *const c_char) -> *mut [c_uchar; 32];
3699 pub fn ostree_checksum_bytes_peek(bytes: *mut glib::GVariant) -> *const [c_uchar; 32];
3700 pub fn ostree_checksum_bytes_peek_validate(
3701 bytes: *mut glib::GVariant,
3702 error: *mut *mut glib::GError,
3703 ) -> *const [c_uchar; 32];
3704 pub fn ostree_checksum_file(
3705 f: *mut gio::GFile,
3706 objtype: OstreeObjectType,
3707 out_csum: *mut *mut [*mut u8; 32],
3708 cancellable: *mut gio::GCancellable,
3709 error: *mut *mut glib::GError,
3710 ) -> gboolean;
3711 pub fn ostree_checksum_file_async(
3712 f: *mut gio::GFile,
3713 objtype: OstreeObjectType,
3714 io_priority: c_int,
3715 cancellable: *mut gio::GCancellable,
3716 callback: gio::GAsyncReadyCallback,
3717 user_data: gpointer,
3718 );
3719 pub fn ostree_checksum_file_async_finish(
3720 f: *mut gio::GFile,
3721 result: *mut gio::GAsyncResult,
3722 out_csum: *mut *mut [*mut u8; 32],
3723 error: *mut *mut glib::GError,
3724 ) -> gboolean;
3725 #[cfg(feature = "v2017_13")]
3726 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_13")))]
3727 pub fn ostree_checksum_file_at(
3728 dfd: c_int,
3729 path: *const c_char,
3730 stbuf: *mut stat,
3731 objtype: OstreeObjectType,
3732 flags: OstreeChecksumFlags,
3733 out_checksum: *mut *mut c_char,
3734 cancellable: *mut gio::GCancellable,
3735 error: *mut *mut glib::GError,
3736 ) -> gboolean;
3737 pub fn ostree_checksum_file_from_input(
3738 file_info: *mut gio::GFileInfo,
3739 xattrs: *mut glib::GVariant,
3740 in_: *mut gio::GInputStream,
3741 objtype: OstreeObjectType,
3742 out_csum: *mut *mut [*mut u8; 32],
3743 cancellable: *mut gio::GCancellable,
3744 error: *mut *mut glib::GError,
3745 ) -> gboolean;
3746 pub fn ostree_checksum_from_bytes(csum: *const [c_uchar; 32]) -> *mut c_char;
3747 pub fn ostree_checksum_from_bytes_v(csum_v: *mut glib::GVariant) -> *mut c_char;
3748 pub fn ostree_checksum_inplace_from_bytes(csum: *const [c_uchar; 32], buf: *mut c_char);
3749 pub fn ostree_checksum_inplace_to_bytes(checksum: *const c_char, buf: *mut u8);
3750 pub fn ostree_checksum_to_bytes(checksum: *const c_char) -> *mut [c_uchar; 32];
3751 pub fn ostree_checksum_to_bytes_v(checksum: *const c_char) -> *mut glib::GVariant;
3752 pub fn ostree_cmp_checksum_bytes(a: *const u8, b: *const u8) -> c_int;
3753 #[cfg(feature = "v2018_2")]
3754 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_2")))]
3755 pub fn ostree_commit_get_content_checksum(commit_variant: *mut glib::GVariant) -> *mut c_char;
3756 #[cfg(feature = "v2020_1")]
3757 #[cfg_attr(docsrs, doc(cfg(feature = "v2020_1")))]
3758 pub fn ostree_commit_get_object_sizes(
3759 commit_variant: *mut glib::GVariant,
3760 out_sizes_entries: *mut *mut glib::GPtrArray,
3761 error: *mut *mut glib::GError,
3762 ) -> gboolean;
3763 pub fn ostree_commit_get_parent(commit_variant: *mut glib::GVariant) -> *mut c_char;
3764 #[cfg(feature = "v2016_3")]
3765 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_3")))]
3766 pub fn ostree_commit_get_timestamp(commit_variant: *mut glib::GVariant) -> u64;
3767 #[cfg(feature = "v2021_1")]
3768 #[cfg_attr(docsrs, doc(cfg(feature = "v2021_1")))]
3769 pub fn ostree_commit_metadata_for_bootable(
3770 root: *mut gio::GFile,
3771 dict: *mut glib::GVariantDict,
3772 cancellable: *mut gio::GCancellable,
3773 error: *mut *mut glib::GError,
3774 ) -> gboolean;
3775 pub fn ostree_content_file_parse(
3776 compressed: gboolean,
3777 content_path: *mut gio::GFile,
3778 trusted: gboolean,
3779 out_input: *mut *mut gio::GInputStream,
3780 out_file_info: *mut *mut gio::GFileInfo,
3781 out_xattrs: *mut *mut glib::GVariant,
3782 cancellable: *mut gio::GCancellable,
3783 error: *mut *mut glib::GError,
3784 ) -> gboolean;
3785 pub fn ostree_content_file_parse_at(
3786 compressed: gboolean,
3787 parent_dfd: c_int,
3788 path: *const c_char,
3789 trusted: gboolean,
3790 out_input: *mut *mut gio::GInputStream,
3791 out_file_info: *mut *mut gio::GFileInfo,
3792 out_xattrs: *mut *mut glib::GVariant,
3793 cancellable: *mut gio::GCancellable,
3794 error: *mut *mut glib::GError,
3795 ) -> gboolean;
3796 pub fn ostree_content_stream_parse(
3797 compressed: gboolean,
3798 input: *mut gio::GInputStream,
3799 input_length: u64,
3800 trusted: gboolean,
3801 out_input: *mut *mut gio::GInputStream,
3802 out_file_info: *mut *mut gio::GFileInfo,
3803 out_xattrs: *mut *mut glib::GVariant,
3804 cancellable: *mut gio::GCancellable,
3805 error: *mut *mut glib::GError,
3806 ) -> gboolean;
3807 pub fn ostree_create_directory_metadata(
3808 dir_info: *mut gio::GFileInfo,
3809 xattrs: *mut glib::GVariant,
3810 ) -> *mut glib::GVariant;
3811 pub fn ostree_diff_dirs(
3812 flags: OstreeDiffFlags,
3813 a: *mut gio::GFile,
3814 b: *mut gio::GFile,
3815 modified: *mut glib::GPtrArray,
3816 removed: *mut glib::GPtrArray,
3817 added: *mut glib::GPtrArray,
3818 cancellable: *mut gio::GCancellable,
3819 error: *mut *mut glib::GError,
3820 ) -> gboolean;
3821 #[cfg(feature = "v2017_4")]
3822 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_4")))]
3823 pub fn ostree_diff_dirs_with_options(
3824 flags: OstreeDiffFlags,
3825 a: *mut gio::GFile,
3826 b: *mut gio::GFile,
3827 modified: *mut glib::GPtrArray,
3828 removed: *mut glib::GPtrArray,
3829 added: *mut glib::GPtrArray,
3830 options: *mut OstreeDiffDirsOptions,
3831 cancellable: *mut gio::GCancellable,
3832 error: *mut *mut glib::GError,
3833 ) -> gboolean;
3834 pub fn ostree_diff_print(
3835 a: *mut gio::GFile,
3836 b: *mut gio::GFile,
3837 modified: *mut glib::GPtrArray,
3838 removed: *mut glib::GPtrArray,
3839 added: *mut glib::GPtrArray,
3840 );
3841 pub fn ostree_fs_get_all_xattrs(
3842 fd: c_int,
3843 cancellable: *mut gio::GCancellable,
3844 error: *mut *mut glib::GError,
3845 ) -> *mut glib::GVariant;
3846 pub fn ostree_fs_get_all_xattrs_at(
3847 dfd: c_int,
3848 path: *const c_char,
3849 cancellable: *mut gio::GCancellable,
3850 error: *mut *mut glib::GError,
3851 ) -> *mut glib::GVariant;
3852 #[cfg(feature = "v2017_10")]
3853 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_10")))]
3854 pub fn ostree_gpg_error_quark() -> glib::GQuark;
3855 pub fn ostree_hash_object_name(a: gconstpointer) -> c_uint;
3856 pub fn ostree_metadata_variant_type(objtype: OstreeObjectType) -> *const glib::GVariantType;
3857 pub fn ostree_object_from_string(
3858 str: *const c_char,
3859 out_checksum: *mut *mut c_char,
3860 out_objtype: *mut OstreeObjectType,
3861 );
3862 pub fn ostree_object_name_deserialize(
3863 variant: *mut glib::GVariant,
3864 out_checksum: *mut *const c_char,
3865 out_objtype: *mut OstreeObjectType,
3866 );
3867 pub fn ostree_object_name_serialize(
3868 checksum: *const c_char,
3869 objtype: OstreeObjectType,
3870 ) -> *mut glib::GVariant;
3871 pub fn ostree_object_to_string(
3872 checksum: *const c_char,
3873 objtype: OstreeObjectType,
3874 ) -> *mut c_char;
3875 pub fn ostree_object_type_from_string(str: *const c_char) -> OstreeObjectType;
3876 pub fn ostree_object_type_to_string(objtype: OstreeObjectType) -> *const c_char;
3877 pub fn ostree_parse_refspec(
3878 refspec: *const c_char,
3879 out_remote: *mut *mut c_char,
3880 out_ref: *mut *mut c_char,
3881 error: *mut *mut glib::GError,
3882 ) -> gboolean;
3883 #[cfg(feature = "v2016_6")]
3884 #[cfg_attr(docsrs, doc(cfg(feature = "v2016_6")))]
3885 pub fn ostree_raw_file_to_archive_z2_stream(
3886 input: *mut gio::GInputStream,
3887 file_info: *mut gio::GFileInfo,
3888 xattrs: *mut glib::GVariant,
3889 out_input: *mut *mut gio::GInputStream,
3890 cancellable: *mut gio::GCancellable,
3891 error: *mut *mut glib::GError,
3892 ) -> gboolean;
3893 #[cfg(feature = "v2017_3")]
3894 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_3")))]
3895 pub fn ostree_raw_file_to_archive_z2_stream_with_options(
3896 input: *mut gio::GInputStream,
3897 file_info: *mut gio::GFileInfo,
3898 xattrs: *mut glib::GVariant,
3899 options: *mut glib::GVariant,
3900 out_input: *mut *mut gio::GInputStream,
3901 cancellable: *mut gio::GCancellable,
3902 error: *mut *mut glib::GError,
3903 ) -> gboolean;
3904 pub fn ostree_raw_file_to_content_stream(
3905 input: *mut gio::GInputStream,
3906 file_info: *mut gio::GFileInfo,
3907 xattrs: *mut glib::GVariant,
3908 out_input: *mut *mut gio::GInputStream,
3909 out_length: *mut u64,
3910 cancellable: *mut gio::GCancellable,
3911 error: *mut *mut glib::GError,
3912 ) -> gboolean;
3913 pub fn ostree_validate_checksum_string(
3914 sha256: *const c_char,
3915 error: *mut *mut glib::GError,
3916 ) -> gboolean;
3917 #[cfg(feature = "v2018_6")]
3918 #[cfg_attr(docsrs, doc(cfg(feature = "v2018_6")))]
3919 pub fn ostree_validate_collection_id(
3920 collection_id: *const c_char,
3921 error: *mut *mut glib::GError,
3922 ) -> gboolean;
3923 #[cfg(feature = "v2017_8")]
3924 #[cfg_attr(docsrs, doc(cfg(feature = "v2017_8")))]
3925 pub fn ostree_validate_remote_name(
3926 remote_name: *const c_char,
3927 error: *mut *mut glib::GError,
3928 ) -> gboolean;
3929 pub fn ostree_validate_rev(rev: *const c_char, error: *mut *mut glib::GError) -> gboolean;
3930 pub fn ostree_validate_structureof_checksum_string(
3931 checksum: *const c_char,
3932 error: *mut *mut glib::GError,
3933 ) -> gboolean;
3934 pub fn ostree_validate_structureof_commit(
3935 commit: *mut glib::GVariant,
3936 error: *mut *mut glib::GError,
3937 ) -> gboolean;
3938 pub fn ostree_validate_structureof_csum_v(
3939 checksum: *mut glib::GVariant,
3940 error: *mut *mut glib::GError,
3941 ) -> gboolean;
3942 pub fn ostree_validate_structureof_dirmeta(
3943 dirmeta: *mut glib::GVariant,
3944 error: *mut *mut glib::GError,
3945 ) -> gboolean;
3946 pub fn ostree_validate_structureof_dirtree(
3947 dirtree: *mut glib::GVariant,
3948 error: *mut *mut glib::GError,
3949 ) -> gboolean;
3950 pub fn ostree_validate_structureof_file_mode(
3951 mode: u32,
3952 error: *mut *mut glib::GError,
3953 ) -> gboolean;
3954 pub fn ostree_validate_structureof_objtype(
3955 objtype: c_uchar,
3956 error: *mut *mut glib::GError,
3957 ) -> gboolean;
3958
3959}