|
HTML rendering created 2025-09-06 by Michael Kerrisk, author of The Linux Programming Interface. For details of in-depth Linux/UNIX system programming training courses that I teach, look here. Hosting by jambit GmbH. |
|
|
NAME | SYNOPSIS | DESCRIPTION | TEXTUAL REPRESENTATION | RETURN VALUE | CONFORMING TO | EXAMPLE | SEE ALSO | COLOPHON |
|
|
|
CAP_FROM_TEXT(3) Linux Programmer's Manual CAP_FROM_TEXT(3)
cap_from_text, cap_to_text, cap_to_name, cap_from_name -
capability state textual representation translation
#include <sys/capability.h>
cap_t cap_from_text(const char *buf_p);
char *cap_to_text(cap_t caps, ssize_t *len_p);
int cap_from_name(const char *name, cap_value_t *cap_p);
char *cap_to_name(cap_value_t cap);
Link with -lcap.
These functions translate a capability state between an internal
representation and a textual one. The internal representation is
managed by the capability functions in working storage. The
textual representation is a structured, human-readable string
suitable for display.
cap_from_text() allocates and initializes a capability state in
working storage. It then sets the contents of this newly created
capability state to the state represented by a human-readable,
nul-terminated character string pointed to by buf_p. It returns a
pointer to the newly created capability state. When the
capability state in working storage is no longer required, the
caller should free any releasable memory by calling cap_free()
with cap_t as an argument. The function returns an error if it
cannot parse the contents of the string pointed to by buf_p or
does not recognize any capability_name or flag character as valid.
The function also returns an error if any flag is both set and
cleared within a single clause.
cap_to_text() converts the capability state in working storage
identified by caps into a nul-terminated human-readable string.
This function allocates any memory necessary to contain the
string, and returns a pointer to the string. If the pointer len_p
is not NULL, the function shall also return the full length of the
string (not including the nul terminator) in the location pointed
to by len_p. The capability state in working storage, identified
by caps, is completely represented in the character string. When
the capability state in working storage is no longer required, the
caller should free any releasable memory by calling cap_free()
with the returned string pointer as an argument.
cap_from_name() converts a text representation of a capability,
such as "cap_chown", to its numerical representation
(CAP_CHOWN=0), writing the decoded value into *cap_p. If cap_p is
NULL no result is written, but the return code of the function
indicates whether or not the specified capability can be
represented by the library.
cap_to_name() converts a capability index value, cap, to a libcap-
allocated textual string. This string should be deallocated with
cap_free().
The text format is described in the cap_text_formats(7) man page.
cap_from_text(), cap_to_text() and cap_to_name() return a non-NULL
value on success, and NULL on failure. cap_from_name() returns 0
for success, and -1 on failure (unknown capability).
On failure, errno is set to EINVAL, or ENOMEM.
cap_from_text() and cap_to_text() are specified by the withdrawn
POSIX.1e draft specification. cap_from_name() and cap_to_name()
are Linux extensions.
The example program below demonstrates the use of cap_from_text()
and cap_to_text(). The following shell session shows some example
runs:
$ ./a.out "cap_chown=p cap_chown+e"
caps_to_text() returned "cap_chown=ep"
$ ./a.out "all=pe cap_chown-e cap_kill-pe"
caps_to_text() returned "=ep cap_chown-e cap_kill-ep"
The source code of the program is as follows:
#include <stdlib.h>
#include <stdio.h>
#include <sys/capability.h>
#define handle_error(msg) \
do { perror(msg); exit(EXIT_FAILURE); } while (0)
int
main(int argc, char *argv[])
{
cap_t caps;
char *txt_caps;
if (argc != 2) {
fprintf(stderr, "%s <textual-cap-set>\n", argv[0]);
exit(EXIT_FAILURE);
}
caps = cap_from_text(argv[1]);
if (caps == NULL)
handle_error("cap_from_text");
txt_caps = cap_to_text(caps, NULL);
if (txt_caps == NULL)
handle_error("cap_to_text");
printf("caps_to_text() returned \"%s\"\n", txt_caps);
if (cap_free(txt_caps) != 0 || cap_free(caps) != 0)
handle_error("cap_free");
exit(EXIT_SUCCESS);
}
libcap(3), cap_clear(3), cap_copy_ext(3), cap_get_file(3),
cap_get_proc(3), cap_init(3), cap_text_formats(7), capabilities(7)
This page is part of the libcap (capabilities commands and
library) project. Information about the project can be found at
⟨https://git.kernel.org/pub/scm/libs/libcap/libcap.git/⟩. If you
have a bug report for this manual page, send it to
morgan@kernel.org (please put "libcap" in the Subject line). This
page was obtained from the project's upstream Git repository
⟨https://git.kernel.org/pub/scm/libs/libcap/libcap.git/⟩ on
2025-08-11. (At that time, the date of the most recent commit
that was found in the repository was 2025-08-10.) If you discover
any rendering problems in this HTML version of the page, or you
believe there is a better or more up-to-date source for the page,
or you have corrections or improvements to the information in this
COLOPHON (which is not part of the original manual page), send a
mail to man-pages@man7.org
2025-03-19 CAP_FROM_TEXT(3)
Pages that refer to this page: capsh(1), cap_clear(3), cap_copy_ext(3), cap_get_file(3), cap_get_proc(3), cap_init(3), libcap(3), org.freedesktop.systemd1(5), systemd-system.conf(5), capabilities(7), cap_text_formats(7), captree(8), getcap(8), getpcaps(8), setcap(8)
|
HTML rendering created 2025-09-06 by Michael Kerrisk, author of The Linux Programming Interface. For details of in-depth Linux/UNIX system programming training courses that I teach, look here. Hosting by jambit GmbH. |
|