mirror of
https://git.hardenedbsd.org/hardenedbsd/HardenedBSD.git
synced 2024-12-30 15:38:06 +01:00
a67d6a5933
isn't gratuitously broken. This also prevents ANSI compilers from recognizing the pragma as a request to run /usr/games/hack... FreeBSD Ids should be in comments or rcsids, not in `#pragma ident's (which are equivalent to comments when compiled by gcc), and the only FreeBSD change in this file seems to be adding the Id.
318 lines
12 KiB
Plaintext
318 lines
12 KiB
Plaintext
%/*
|
|
% * 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
|