Subversion Repositories openrisc_me

%/*

% * Sun RPC is a product of Sun Microsystems, Inc. and is provided for

% * unrestricted use provided that this legend is included on all tape

% * media and as a part of the software program in whole or part.  Users

% * may copy or modify Sun RPC without charge, but are not authorized

% * to license or distribute it to anyone else except as part of a product or

% * program developed by the user or with the express written consent of

% * Sun Microsystems, Inc.

% *

% * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE

% * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR

% * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.

% *

% * Sun RPC is provided with no support and without any obligation on the

% * part of Sun Microsystems, Inc. to assist in its use, correction,

% * modification or enhancement.

% *

% * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE

% * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC

% * OR ANY PART THEREOF.

% *

% * In no event will Sun Microsystems, Inc. be liable for any lost revenue

% * or profits or other special, indirect and consequential damages, even if

% * Sun has been advised of the possibility of such damages.

% *

% * Sun Microsystems, Inc.

% * 2550 Garcia Avenue

% * Mountain View, California  94043

% */

/*

 *      nis_object.x

 *

 *      Copyright (c) 1988-1992 Sun Microsystems Inc

 *      All Rights Reserved.

 */

/* From: %#pragma ident "@(#)nis_object.x       1.10    94/05/03 SMI" */

#if RPC_HDR

%

%#ifndef __nis_object_h

%#define __nis_object_h

%

#endif

/*

 *      This file defines the format for a NIS object in RPC language.

 * It is included by the main .x file and the database access protocol

 * file. It is common because both of them need to deal with the same

 * type of object. Generating the actual code though is a bit messy because

 * the nis.x file and the nis_dba.x file will generate xdr routines to

 * encode/decode objects when only one set is needed. Such is life when

 * one is using rpcgen.

 *

 * Note, the protocol doesn't specify any limits on such things as

 * maximum name length, number of attributes, etc. These are enforced

 * by the database backend. When you hit them you will no. Also see

 * the db_getlimits() function for fetching the limit values.

 *

 */

/* Some manifest constants, chosen to maximize flexibility without

 * plugging the wire full of data.

 */

const NIS_MAXSTRINGLEN = 255;

const NIS_MAXNAMELEN   = 1024;

const NIS_MAXATTRNAME  = 32;

const NIS_MAXATTRVAL   = 2048;

const NIS_MAXCOLUMNS   = 64;

const NIS_MAXATTR      = 16;

const NIS_MAXPATH      = 1024;

const NIS_MAXREPLICAS  = 128;

const NIS_MAXLINKS     = 16;

const NIS_PK_NONE      = 0;     /* no public key (unix/sys auth) */

const NIS_PK_DH        = 1;     /* Public key is Diffie-Hellman type */

const NIS_PK_RSA       = 2;     /* Public key if RSA type */

const NIS_PK_KERB      = 3;     /* Use kerberos style authentication */

/*

 * The fundamental name type of NIS. The name may consist of two parts,

 * the first being the fully qualified name, and the second being an

 * optional set of attribute/value pairs.

 */

struct nis_attr {

        string  zattr_ndx<>;    /* name of the index            */

        opaque  zattr_val<>;    /* Value for the attribute.     */

};

typedef string nis_name<>;      /* The NIS name itself. */

/* NIS object types are defined by the following enumeration. The numbers

 * they use are based on the following scheme :

 *                   0 - 1023 are reserved for Sun,

 *              1024 - 2047 are defined to be private to a particular tree.

 *              2048 - 4095 are defined to be user defined.

 *              4096 - ...  are reserved for future use.

 */

enum zotypes {

        BOGUS_OBJ       = 0,    /* Uninitialized object structure       */

        NO_OBJ          = 1,    /* NULL object (no data)                */

        DIRECTORY_OBJ   = 2,    /* Directory object describing domain   */

        GROUP_OBJ       = 3,    /* Group object (a list of names)       */

        TABLE_OBJ       = 4,    /* Table object (a database schema)     */

        ENTRY_OBJ       = 5,    /* Entry object (a database record)     */

        LINK_OBJ        = 6,    /* A name link.                         */

        PRIVATE_OBJ     = 7     /* Private object (all opaque data)     */

};

/*

 * The types of Name services NIS knows about. They are enumerated

 * here. The Binder code will use this type to determine if it has

 * a set of library routines that will access the indicated name service.

 */

enum nstype {

        UNKNOWN = 0,

        NIS = 1,        /* Nis Plus Service             */

        SUNYP = 2,      /* Old NIS Service              */

        IVY = 3,        /* Nis Plus Plus Service        */

        DNS = 4,        /* Domain Name Service          */

        X500 = 5,       /* ISO/CCCIT X.500 Service      */

        DNANS = 6,      /* Digital DECNet Name Service  */

        XCHS = 7,       /* Xerox ClearingHouse Service  */

        CDS= 8

};

/*

 * DIRECTORY - The name service object. These objects identify other name

 * servers that are serving some portion of the name space. Each has a

 * type associated with it. The resolver library will note whether or not

 * is has the needed routines to access that type of service.

 * The oarmask structure defines an access rights mask on a per object

 * type basis for the name spaces. The only bits currently used are

 * create and destroy. By enabling or disabling these access rights for

 * a specific object type for a one of the accessor entities (owner,

 * group, world) the administrator can control what types of objects

 * may be freely added to the name space and which require the

 * administrator's approval.

 */

struct oar_mask {

        u_long  oa_rights;      /* Access rights mask   */

        zotypes oa_otype;       /* Object type          */

};

struct endpoint {

        string          uaddr<>;

        string          family<>;   /* Transport family (INET, OSI, etc) */

        string          proto<>;    /* Protocol (TCP, UDP, CLNP,  etc)   */

};

/*

 * Note: pkey is a netobj which is limited to 1024 bytes which limits the

 * keysize to 8192 bits. This is consider to be a reasonable limit for

 * the expected lifetime of this service.

 */

struct nis_server {

        nis_name        name;           /* Principal name of the server  */

        endpoint        ep<>;           /* Universal addr(s) for server  */

        u_long          key_type;       /* Public key type               */

        netobj          pkey;           /* server's public key           */

};

struct directory_obj {

        nis_name   do_name;      /* Name of the directory being served   */

        nstype     do_type;      /* one of NIS, DNS, IVY, YP, or X.500   */

        nis_server do_servers<>; /* <0> == Primary name server             */

        u_long     do_ttl;       /* Time To Live (for caches)            */

        oar_mask   do_armask<>;  /* Create/Destroy rights by object type */

};

/*

 * ENTRY - This is one row of data from an information base.

 * The type value is used by the client library to convert the entry to

 * it's internal structure representation. The Table name is a back pointer

 * to the table where the entry is stored. This allows the client library

 * to determine where to send a request if the client wishes to change this

 * entry but got to it through a LINK rather than directly.

 * If the entry is a "standalone" entry then this field is void.

 */

const EN_BINARY   = 1;  /* Indicates value is binary data       */

const EN_CRYPT    = 2;  /* Indicates the value is encrypted     */

const EN_XDR      = 4;  /* Indicates the value is XDR encoded   */

const EN_MODIFIED = 8;  /* Indicates entry is modified.         */

const EN_ASN1     = 64; /* Means contents use ASN.1 encoding    */

struct entry_col {

        u_long  ec_flags;       /* Flags for this value */

        opaque  ec_value<>;     /* It's textual value   */

};

struct entry_obj {

        string  en_type<>;      /* Type of entry such as "passwd" */

        entry_col en_cols<>;    /* Value for the entry            */

};

/*

 * GROUP - The group object contains a list of NIS principal names. Groups

 * are used to authorize principals. Each object has a set of access rights

 * for members of its group. Principal names in groups are in the form

 * name.directory and recursive groups are expressed as @groupname.directory

 */

struct group_obj {

        u_long          gr_flags;       /* Flags controlling group      */

        nis_name        gr_members<>;   /* List of names in group       */

};

/*

 * LINK - This is the LINK object. It is quite similar to a symbolic link

 * in the UNIX filesystem. The attributes in the main object structure are

 * relative to the LINK data and not what it points to (like the file system)

 * "modify" privleges here indicate the right to modify what the link points

 * at and not to modify that actual object pointed to by the link.

 */

struct link_obj {

        zotypes  li_rtype;      /* Real type of the object      */

        nis_attr li_attrs<>;    /* Attribute/Values for tables  */

        nis_name li_name;       /* The object's real NIS name   */

};

/*

 * TABLE - This is the table object. It implements a simple

 * data base that applications and use for configuration or

 * administration purposes. The role of the table is to group together

 * a set of related entries. Tables are the simple database component

 * of NIS. Like many databases, tables are logically divided into columns

 * and rows. The columns are labeled with indexes and each ENTRY makes

 * up a row. Rows may be addressed within the table by selecting one

 * or more indexes, and values for those indexes. Each row which has

 * a value for the given index that matches the desired value is returned.

 * Within the definition of each column there is a flags variable, this

 * variable contains flags which determine whether or not the column is

 * searchable, contains binary data, and access rights for the entry objects

 * column value.

 */

const TA_BINARY     = 1;        /* Means table data is binary           */

const TA_CRYPT      = 2;        /* Means value should be encrypted      */

const TA_XDR        = 4;        /* Means value is XDR encoded           */

const TA_SEARCHABLE = 8;        /* Means this column is searchable      */

const TA_CASE       = 16;       /* Means this column is Case Sensitive  */

const TA_MODIFIED   = 32;       /* Means this columns attrs are modified*/

const TA_ASN1       = 64;       /* Means contents use ASN.1 encoding     */

struct table_col {

        string  tc_name<64>;        /* Column Name             */

        u_long  tc_flags;       /* control flags           */

        u_long  tc_rights;      /* Access rights mask      */

};

struct table_obj {

        string    ta_type<64>;       /* Table type such as "passwd" */

        int       ta_maxcol;     /* Total number of columns     */

        u_char    ta_sep;        /* Separator character         */

        table_col ta_cols<>;     /* The number of table indexes */

        string    ta_path<>;     /* A search path for this table */

};

/*

 * This union joins together all of the currently known objects.

 */

union objdata switch (zotypes zo_type) {

        case DIRECTORY_OBJ :

                struct directory_obj di_data;

        case GROUP_OBJ :

                struct group_obj gr_data;

        case TABLE_OBJ :

                struct table_obj ta_data;

        case ENTRY_OBJ:

                struct entry_obj en_data;

        case LINK_OBJ :

                struct link_obj li_data;

        case PRIVATE_OBJ :

                opaque  po_data<>;

        case NO_OBJ :

                void;

        case BOGUS_OBJ :

                void;

        default :

                void;

};

/*

 * This is the basic NIS object data type. It consists of a generic part

 * which all objects contain, and a specialized part which varies depending

 * on the type of the object. All of the specialized sections have been

 * described above. You might have wondered why they all start with an

 * integer size, followed by the useful data. The answer is, when the

 * server doesn't recognize the type returned it treats it as opaque data.

 * And the definition for opaque data is {int size; char *data;}. In this

 * way, servers and utility routines that do not understand a given type

 * may still pass it around. One has to be careful in setting

 * this variable accurately, it must take into account such things as

 * XDR padding of structures etc. The best way to set it is to note one's

 * position in the XDR encoding stream, encode the structure, look at the

 * new position and calculate the size.

 */

struct nis_oid {

        u_long  ctime;          /* Time of objects creation     */

        u_long  mtime;          /* Time of objects modification */

};

struct nis_object {

        nis_oid  zo_oid;        /* object identity verifier.            */

        nis_name zo_name;       /* The NIS name for this object         */

        nis_name zo_owner;      /* NIS name of object owner.            */

        nis_name zo_group;      /* NIS name of access group.            */

        nis_name zo_domain;     /* The administrator for the object     */

        u_long   zo_access;     /* Access rights (owner, group, world)  */

        u_long   zo_ttl;        /* Object's time to live in seconds.    */

        objdata  zo_data;       /* Data structure for this type         */

};

#if RPC_HDR

%

%#endif /* if __nis_object_h */

%

#endif