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