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 * length_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

       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 cap_p 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 cap_p, 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

       A textual representation of capability sets consists of one or more
       whitespace-separated clauses.  Each clause specifies some operations on a
       capability set; the set starts out with all capabilities lowered, and the
       meaning of the string is the state of the capability set after all the
       clauses have been applied in order.

       Each clause consists of a list of comma-separated capability names (or
       the word `all'), followed by an action-list.  An action-list consists of
       a sequence of operator flag pairs.  Legal operators are: `=', '+', and
       `-'.  Legal flags are: `e', `i', and `p'.  These flags are case-sensitive
       and specify the Effective, Inheritable and Permitted sets respectively.

       In the capability name lists, all names are case-insensitive.  The
       special name `all' specifies all capabilities; it is equivalent to a list
       naming every capability individually.

       Unnamed capabilities can also be specified by number. This feature
       ensures that libcap can support capabilities that were not allocated at
       the time libcap was compiled. However, generally upgrading libcap will
       add names for recently allocated capabilities.

       The `=' operator indicates that the listed capabilities are first reset
       in all three capability sets.  The subsequent flags (which are optional
       when associated with this operator) indicate that the listed capabilities
       for the corresponding set are to be raised.  For example: "all=p" means
       lower every capability in the Effective and Inheritable sets but raise
       all of the Permitted capabilities; or, "cap_fowner=ep" means raise the
       Effective and Permitted override-file-ownership capability, while
       lowering this Inheritable capability.

       In the case that the leading operator is `=', and no list of capabilities
       is provided, the action-list is assumed to refer to `all' capabilities.
       For example, the following three clauses are equivalent to each other
       (and indicate a completely empty capability set): "all="; "=";

       The operators, `+' and `-' both require an explicit preceding capability
       list and one or more explicit trailing flags.  The `+' operator will
       raise all of the listed capabilities in the flagged capability sets.  The
       `-' operator will lower all of the listed capabilities in the flagged
       capability sets.  For example: "all+p" will raise all of the Permitted
       capabilities and "cap_fowner-i" will lower the override-file-ownership in
       the Inheritable set.

       The action list can consist of multiple operator flag pairs; the actions
       are performed in left-to-right order.  Thus, for example,
       "cap_fowner+p-i" is equivalent to "cap_fowner+p cap_fowner-i".  As
       another example, "cap_fowner+pe-i" and "cap_fowner=+pe" are equivalent.

       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

       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)

       main(int argc, char *argv[])
           cap_t caps;
           char *txt_caps;

           if (argc != 2) {
               fprintf(stderr, "%s <textual-cap-set>\n", argv[0]);

           caps = cap_from_text(argv[1]);
           if (caps == NULL)

           txt_caps = cap_to_text(caps, NULL);
           if (txt_caps == NULL)

           printf("caps_to_text() returned \"%s\"\n", txt_caps);

           if (cap_free(txt_caps) != 0 || cap_free(caps) != 0)


       libcap(3), cap_clear(3), cap_copy_ext(3), cap_get_file(3),
       cap_get_proc(3), cap_init(3), capabilities(7)

                                   2021-03-06                   CAP_FROM_TEXT(3)