Man Linux: Main Page and Category List


       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

       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=";
       "="; "cap_chown,<every-other-capability>=".

       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;  "cap_fowner+p-i"  will  raise
       the  override-file-ownership capability in the Permitted capability set
       and  lower   this   Inheritable   capability;   "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 extensions.


       The  example  program below demonstrates the use of cap_from_text() and
       cap_to_text().  The following shell session shows a 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_compare(3),      cap_copy_ext(3),
       cap_get_file(3), cap_get_proc(3), cap_init(3), capabilities(7)