Viewing file:  attributes.h (7.09 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* Copyright (c) 2001-2002,2004 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2.1 of the GNU Lesser General Public License
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
* USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
*/
#ifndef __ATTRIBUTES_H__
#define __ATTRIBUTES_H__
#ifdef __cplusplus
extern "C" {
#endif
/*
* An almost-IRIX-compatible extended attributes API
* (the IRIX attribute "list" operation is missing, added ATTR_SECURE).
*/
/*
* The maximum size (into the kernel or returned from the kernel) of an
* attribute value or the buffer used for an attr_list() call. Larger
* sizes will result in an E2BIG return code.
*/
#define ATTR_MAX_VALUELEN (64*1024) /* max length of a value */
/*
* Flags that can be used with any of the simple attribute calls.
* All desired flags should be bit-wise OR'ed together.
*/
#define ATTR_DONTFOLLOW 0x0001 /* do not follow symlinks for a pathname */
#define ATTR_ROOT 0x0002 /* use root namespace attributes in op */
#define ATTR_TRUST 0x0004 /* tell server we can be trusted to properly
handle extended attributes */
#define ATTR_SECURE 0x0008 /* use security namespace attributes in op */
/*
* Additional flags that can be used with the set() attribute call.
* All desired flags (from both lists) should be bit-wise OR'ed together.
*/
#define ATTR_CREATE 0x0010 /* pure create: fail if attr already exists */
#define ATTR_REPLACE 0x0020 /* pure set: fail if attr does not exist */
/*
* Define how lists of attribute names are returned to the user from
* the attr_list() call. A large, 32bit aligned, buffer is passed in
* along with its size. We put an array of offsets at the top that each
* reference an attrlist_ent_t and pack the attrlist_ent_t's at the bottom.
*/
typedef struct attrlist {
int32_t al_count; /* number of entries in attrlist */
int32_t al_more; /* T/F: more attrs (do call again) */
int32_t al_offset[1]; /* byte offsets of attrs [var-sized] */
} attrlist_t;
/*
* Show the interesting info about one attribute. This is what the
* al_offset[i] entry points to.
*/
typedef struct attrlist_ent { /* data from attr_list() */
u_int32_t a_valuelen; /* number bytes in value of attr */
char a_name[1]; /* attr name (NULL terminated) */
} attrlist_ent_t;
/*
* Given a pointer to the (char*) buffer containing the attr_list() result,
* and an index, return a pointer to the indicated attribute in the buffer.
*/
#define ATTR_ENTRY(buffer, index) \
((attrlist_ent_t *) \
&((char *)buffer)[ ((attrlist_t *)(buffer))->al_offset[index] ])
/*
* Implement a "cursor" for use in successive attr_list() calls.
* It provides a way to find the last attribute that was returned in the
* last attr_list() call so that we can get the next one without missing
* any. This should be bzero()ed before use and whenever it is desired to
* start over from the beginning of the attribute list. The only valid
* operation on a cursor is to bzero() it.
*/
typedef struct attrlist_cursor {
u_int32_t opaque[4]; /* an opaque cookie */
} attrlist_cursor_t;
/*
* Multi-attribute operation vector.
*/
typedef struct attr_multiop {
int32_t am_opcode; /* operation to perform (ATTR_OP_GET, etc.) */
int32_t am_error; /* [out arg] result of this sub-op (an errno) */
char *am_attrname; /* attribute name to work with */
char *am_attrvalue; /* [in/out arg] attribute value (raw bytes) */
int32_t am_length; /* [in/out arg] length of value */
int32_t am_flags; /* flags (bit-wise OR of #defines above) */
} attr_multiop_t;
#define ATTR_MAX_MULTIOPS 128 /* max number ops in an oplist array */
/*
* Valid values of am_opcode.
*/
#define ATTR_OP_GET 1 /* return the indicated attr's value */
#define ATTR_OP_SET 2 /* set/create the indicated attr/value pair */
#define ATTR_OP_REMOVE 3 /* remove the indicated attr */
/*
* Get the value of an attribute.
* Valuelength must be set to the maximum size of the value buffer, it will
* be set to the actual number of bytes used in the value buffer upon return.
* The return value is -1 on error (w/errno set appropriately), 0 on success.
*/
extern int attr_get (const char *__path, const char *__attrname,
char *__attrvalue, int *__valuelength, int __flags);
extern int attr_getf (int __fd, const char *__attrname, char *__attrvalue,
int *__valuelength, int __flags);
/*
* Set the value of an attribute, creating the attribute if necessary.
* The return value is -1 on error (w/errno set appropriately), 0 on success.
*/
extern int attr_set (const char *__path, const char *__attrname,
const char *__attrvalue, const int __valuelength,
int __flags);
extern int attr_setf (int __fd, const char *__attrname,
const char *__attrvalue, const int __valuelength,
int __flags);
/*
* Remove an attribute.
* The return value is -1 on error (w/errno set appropriately), 0 on success.
*/
extern int attr_remove (const char *__path, const char *__attrname,
int __flags);
extern int attr_removef (int __fd, const char *__attrname, int __flags);
/*
* Operate on multiple attributes of the same object simultaneously.
*
* This call will save on system call overhead when many attributes are
* going to be operated on.
*
* The return value is -1 on error (w/errno set appropriately), 0 on success.
* Note that this call will not return -1 as a result of failure of any
* of the sub-operations, their return value is stored in each element
* of the operation array. This call will return -1 for a failure of the
* call as a whole, eg: if the pathname doesn't exist, or the fd is bad.
*
* The semantics and allowable values for the fields in a attr_multiop_t
* are the same as the semantics and allowable values for the arguments to
* the corresponding "simple" attribute interface. For example: the args
* to a ATTR_OP_GET are the same as the args to an attr_get() call.
*/
extern int attr_multi (const char *__path, attr_multiop_t *__oplist,
int __count, int __flags);
extern int attr_multif (int __fd, attr_multiop_t *__oplist,
int __count, int __flags);
#ifdef __cplusplus
}
#endif
#endif /* __ATTRIBUTES_H__ */
|