Top | ![]() |
![]() |
![]() |
![]() |
gboolean fu_common_spawn_sync (const gchar * const *argv
,FuOutputHandler handler_cb
,gpointer handler_user_data
,guint timeout_ms
,GCancellable *cancellable
,GError **error
);
Runs a subprocess and waits for it to exit. Any output on standard out or
standard error will be forwarded to handler_cb
as whole lines.
argv |
The argument list to run |
|
handler_cb |
A FuOutputHandler or |
[scope call] |
handler_user_data |
the user data to pass to |
|
timeout_ms |
a timeout in ms, or 0 for no limit |
|
cancellable |
a GCancellable, or |
|
error |
A GError or |
gchar *
fu_common_get_path (FuPathKind path_kind
);
Gets a fwupd-specific system path. These can be overridden with various
environment variables, for instance FWUPD_DATADIR
.
gchar * fu_common_realpath (const gchar *filename
,GError **error
);
Finds the canonicalized absolute filename for a path.
gboolean fu_common_rmtree (const gchar *directory
,GError **error
);
Recursively removes a directory.
GPtrArray * fu_common_get_files_recursive (const gchar *path
,GError **error
);
Returns every file found under directory
, and any subdirectory.
If any path under directory
cannot be accessed due to permissions an error
will be returned.
gboolean fu_common_mkdir_parent (const gchar *filename
,GError **error
);
Creates any required directories, including any parent directories.
gboolean fu_common_set_contents_bytes (const gchar *filename
,GBytes *bytes
,GError **error
);
Writes a blob of data to a filename, creating the parent directories as required.
GBytes * fu_common_get_contents_bytes (const gchar *filename
,GError **error
);
Reads a blob of data from a file.
GBytes * fu_common_get_contents_fd (gint fd
,gsize count
,GError **error
);
Reads a blob from a specific file descriptor.
Note: this will close the fd when done
gboolean fu_common_extract_archive (GBytes *blob
,const gchar *dir
,GError **error
);
Extracts an achive to a directory.
GBytes * fu_common_firmware_builder (GBytes *bytes
,const gchar *script_fn
,const gchar *output_fn
,GError **error
);
Builds a firmware file using tools from the host session in a bubblewrap jail. Several things happen during build:
The bytes
data is untarred to a temporary location
A bubblewrap container is set up
The startup.sh script is run inside the container
The firmware.bin is extracted from the container
The temporary location is deleted
GError *
fu_common_error_array_get_best (GPtrArray *errors
);
Finds the 'best' error to show the user from a array of errors, creating a completely bespoke error where required.
guint64
fu_common_strtoull (const gchar *str
);
Converts a string value to an integer. Values are assumed base 10, unless prefixed with "0x" where they are parsed as base 16.
gchar * fu_common_find_program_in_path (const gchar *basename
,GError **error
);
gchar *
fu_common_strstrip (const gchar *str
);
Removes leading and trailing whitespace from a constant string.
void fu_common_dump_raw (const gchar *log_domain
,const gchar *title
,const guint8 *data
,gsize len
);
Dumps a raw buffer to the screen.
log_domain |
log domain, typically |
|
title |
prefix title, or |
|
data |
buffer to print |
|
len |
the size of |
Since: 1.2.2
void fu_common_dump_full (const gchar *log_domain
,const gchar *title
,const guint8 *data
,gsize len
,guint columns
,FuDumpFlags flags
);
Dumps a raw buffer to the screen.
log_domain |
log domain, typically |
|
title |
prefix title, or |
|
data |
buffer to print |
|
len |
the size of |
|
columns |
break new lines after this many bytes |
|
flags |
some FuDumpFlags, e.g. |
Since: 1.2.4
void fu_common_dump_bytes (const gchar *log_domain
,const gchar *title
,GBytes *bytes
);
Dumps a byte buffer to the screen.
log_domain |
log domain, typically |
|
title |
prefix title, or |
|
bytes |
a GBytes |
Since: 1.2.2
GBytes * fu_common_bytes_align (GBytes *bytes
,gsize blksz
,gchar padval
);
Aligns a block of memory to blksize
using the padval
value; if
the block is already aligned then the original bytes
is returned.
Since: 1.2.4
gboolean
fu_common_bytes_is_empty (GBytes *bytes
);
Checks if a byte array are just empty (0xff) bytes.
gboolean fu_common_bytes_compare (GBytes *bytes1
,GBytes *bytes2
,GError **error
);
Compares the buffers for equality.
gboolean fu_common_bytes_compare_raw (const guint8 *buf1
,gsize bufsz1
,const guint8 *buf2
,gsize bufsz2
,GError **error
);
Compares the buffers for equality.
GBytes * fu_common_bytes_pad (GBytes *bytes
,gsize sz
);
Pads a GBytes to a given sz
with 0xff
.
gsize
fu_common_strwidth (const gchar *text
);
Returns the width of the string in displayed characters on the console.
Since: 1.3.2
gboolean fu_memcpy_safe (guint8 *dst
,gsize dst_sz
,gsize dst_offset
,const guint8 *src
,gsize src_sz
,gsize src_offset
,gsize n
,GError **error
);
Copies some memory using memcpy in a safe way. Providing the buffer sizes of both the destination and the source allows us to check for buffer overflow.
Providing the buffer offsets also allows us to check reading past the end of
the source buffer. For this reason the caller should NEVER add an offset to
src
or dst
.
You don't need to use this function in "obviously correct" cases, nor should you use it when performance is a concern. Only us it when you're not sure if malicious data from a device or firmware could cause memory corruption.
dst |
destination buffer |
|
dst_sz |
maximum size of |
|
dst_offset |
offset in bytes into |
|
src |
source buffer |
|
src_sz |
maximum size of |
|
src_offset |
offset in bytes into |
|
n |
number of bytes to copy from |
|
error |
A GError or |
void fu_byte_array_append_uint16 (GByteArray *array
,guint16 data
,FuEndianType endian
);
void fu_byte_array_append_uint32 (GByteArray *array
,guint32 data
,FuEndianType endian
);
void fu_common_write_uint16 (guint8 *buf
,guint16 val_native
,FuEndianType endian
);
Writes a value to a buffer using a specified endian.
buf |
A writable buffer |
|
val_native |
a value in host byte-order |
|
endian |
A FuEndianType, e.g. |
void fu_common_write_uint32 (guint8 *buf
,guint32 val_native
,FuEndianType endian
);
Writes a value to a buffer using a specified endian.
buf |
A writable buffer |
|
val_native |
a value in host byte-order |
|
endian |
A FuEndianType, e.g. |
guint16 fu_common_read_uint16 (const guint8 *buf
,FuEndianType endian
);
Read a value from a buffer using a specified endian.
guint32 fu_common_read_uint32 (const guint8 *buf
,FuEndianType endian
);
Read a value from a buffer using a specified endian.
guint fu_common_string_replace (GString *string
,const gchar *search
,const gchar *replace
);
Performs multiple search and replace operations on the given string.
string |
The GString to operate on |
|
search |
The text to search for |
|
replace |
The text to use for substitutions |
Since: 1.2.0
void fu_common_string_append_kv (GString *str
,guint idt
,const gchar *key
,const gchar *value
);
void fu_common_string_append_ku (GString *str
,guint idt
,const gchar *key
,guint64 value
);
void fu_common_string_append_kx (GString *str
,guint idt
,const gchar *key
,guint64 value
);
void fu_common_string_append_kb (GString *str
,guint idt
,const gchar *key
,gboolean value
);
gchar ** fu_common_strnsplit (const gchar *str
,gsize sz
,const gchar *delimiter
,gint max_tokens
);
Splits a string into a maximum of max_tokens
pieces, using the given
delimiter. If max_tokens
is reached, the remainder of string is appended
to the last token.
Path types to use when dynamically determining a path at runtime
The cache directory (IE /var/cache/fwupd) |
||
The non-volatile data store (IE /usr/share/fwupd) |
||
The location to store EFI apps before install (IE /usr/libexec/fwupd/efi) |
||
The local state directory (IE /var) |
||
The local state directory for the package (IE /var/lib/fwupd) |
||
The location to look for plugins for package (IE /usr/lib/[triplet]/fwupd-plugins-3) |
||
The configuration location (IE /etc) |
||
The package configuration location (IE /etc/fwupd) |
||
The sysfs firmware location (IE /sys/firmware) |
||
The platform sysfs directory (IE /sys/bus/platform/drivers) |
||
The TPM sysfs directory (IE /sys/class/tpm)
|
||