LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    cap_to_text

    
    
    
    

    SYNOPSIS

           #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.
    
    
    

    DESCRIPTION

           These functions translate a capability state between an internal repre-
           sentation 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 identi-
           fied by cap_p into a nul-terminated human-readable string.  This  func-
           tion  allocates any memory necessary to contain the string, and returns
           a pointer to the string.  If the pointer len_p is not NULL,  the  func-
           tion 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 repre-
           sented 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-allo-
           cated  textual  string.  This  string  should   be   deallocated   with
           respectively.
    
           In the capability name lists, all names are case-insensitive.  The spe-
           cial  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 capabili-
           ties 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  capabili-
           ties is provided, the action-list is assumed to refer to 'all' capabil-
           ities.  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  capabil-
           ity  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.
    
    
    

    RETURN VALUE

           cap_from_text(), cap_to_text()  and  cap_to_text()  return  a  non-NULL
           value  on  success, and NULL on failure.  cap_from_text() returns 0 for
           success, and -1 on failure (unknown capability).
    
           On failure, errno is set to EINVAL, or ENOMEM.
    
    
    

    CONFORMING TO

           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.
    
    
    

    EXAMPLE

           The example program below demonstrates the use of  cap_from_text()  and
           cap_to_text().  The following shell session shows a some example runs:
    
           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);
           }
    
    
    

    SEE ALSO

           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)
    
                                      2008-05-10                  CAP_FROM_TEXT(3)
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz