1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  *	db_mindex_c.x
23  *
24  * Copyright 2015 Gary Mills
25  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
26  * Use is subject to license terms.
27  */
28 
29 #if RPC_XDR
30 %#include "ldap_xdr.h"
31 %#include "nis_clnt.h"
32 #endif /* RPC_XDR */
33 
34 #if RPC_HDR
35 %#ifndef _DB_MINDEX_H
36 %#define _DB_MINDEX_H
37 
38 #ifdef USINGC
39 %#include "db_vers_c.h"
40 %#include "db_table_c.h"
41 %#include "db_index_entry_c.h"
42 %#include "db_index_c.h"
43 %#include "db_scheme_c.h"
44 %#include "db_query_c.h"
45 #else
46 %#include "db_vers.h"
47 %#include "db_table.h"
48 %#include "db_index_entry.h"
49 %#include "db_index.h"
50 %#include "db_scheme.h"
51 %#include "db_query.h"
52 #endif /* USINGC */
53 %#include "ldap_parse.h"
54 %#include "nisdb_rw.h"
55 %#include "ldap_xdr.h"
56 #endif /* RPC_HDR */
57 
58 #if RPC_HDR
59 %struct db_next_index_desc {
60 %  entryp location;
61 %  struct db_next_index_desc *next;
62 
63 #ifndef USINGC
64 %  db_next_index_desc( entryp loc, struct db_next_index_desc *n )
65 %    { location = loc; next = n; }
66 #endif /* USINGC */
67 
68 %};
69 #endif /* RPC_HDR */
70 
71 
72 #if RPC_HDR || RPC_XDR
73 #ifdef USINGC
74 
75 struct db_mindex {
76   vers rversion;
77   db_index indices<>;                /* indices[num_indices] */
78   db_table *table;
79   db_scheme *scheme;
80   __nisdb_ptr_t objPath;
81   __nisdb_flag_t noWriteThrough;
82   __nisdb_flag_t noLDAPquery;
83   __nisdb_flag_t initialLoad;
84   __nisdb_ptr_t dbptr;
85   __nisdb_rwlock_t mindex_rwlock;
86 };
87 typedef struct db_mindex  * db_mindex_p;
88 
89 typedef	string	strP<>;
90 
91 struct xdr_nis_object_s {
92 	int		xversion;
93 	nis_object	*obj;
94 	strP		dirEntry<>;
95 };
96 typedef struct xdr_nis_object_s	xdr_nis_object_t;
97 
98 #endif /* USINGC */
99 #endif /* RPC_HDR */
100 
101 #ifndef USINGC
102 #ifdef RPC_HDR
103 %
104 %struct xdr_nis_object_s {
105 %	int				version;
106 %	nis_object			*obj;
107 %	struct {
108 %		uint_t	dirEntry_len;
109 %		char	**dirEntry_val;
110 %	}				dirEntry;
111 %};
112 %typedef struct xdr_nis_object_s	xdr_nis_object_t;
113 %
114 %class db_mindex {
115 %  vers rversion;
116 %//  int num_indices;
117 %//  db_index * indices;                /* indices[num_indices] */
118 %  struct {
119 %   int indices_len;
120 %   db_index *indices_val;
121 %  } indices;
122 %  db_table *table;
123 %  db_scheme *scheme;
124 %  __nisdb_ptr_t objPath;
125 %  __nisdb_flag_t noWriteThrough;
126 %  __nisdb_flag_t noLDAPquery;
127 %  __nisdb_flag_t initialLoad;
128 %  __nisdb_ptr_t dbptr;
129 %  STRUCTRWLOCK(mindex);
130 %
131 %/* Return a list of index_entries that satsify the given query 'q'.
132 %   Return the size of the list in 'count'. Return NULL if list is empty.
133 %   Return in 'valid' FALSE if query is not well formed. */
134 %  db_index_entry_p satisfy_query(db_query *, long *, bool_t *valid,
135 %					bool_t fromLDAP = FALSE);
136 %  db_index_entry_p satisfy_query(db_query *, long *, bool_t *valid = NULL);
137 %
138 %/* Returns a newly db_query containing the index values as
139 %   obtained from the given object.  The object itself,
140 %   along with information on the scheme given, will determine
141 %   which values are extracted from the object and placed into the query.
142 %   Returns an empty query if 'obj' is not a valid entry.
143 %   Note that space is allocated for the query and the index values
144 %   (i.e. do not share pointers with strings in 'obj'.) */
145 %  db_query * extract_index_values_from_object( entry_object * );
146 %
147 %/* Returns a newly created db_query structure containing the index values
148 %   as obtained from the record named by 'recnum'.  The record itself, along
149 %   with information on the schema definition of this table, will determine
150 %   which values are extracted from the record and placed into the result.
151 %   Returns NULL if recnum is not a valid entry.
152 %   Note that space is allocated for the query and the index values
153 %   (i.e. do not share pointers with strings in 'obj'.) */
154 %  db_query * extract_index_values_from_record( entryp );
155 %
156 %/* Returns an array of size 'count' of 'entry_object_p's, pointing to
157 %   copies of entry_objects named by the result list of db_index_entries 'res'.
158 %*/
159 %  entry_object_p * prepare_results( int, db_index_entry_p, db_status* );
160 %
161 %/* Remove the entry identified by 'recloc' from:
162 %   1.  all indices, as obtained by extracting the index values from the entry
163 %   2.  table where entry is stored. */
164 %  db_status remove_aux( entryp );
165 %
166 %/*  entry_object * get_record( entryp );*/
167 % public:
168 %
169 %/* Constructor:  Create empty table (no scheme, no table or indices). */
170 %  db_mindex();
171 %
172 %/* Constructor:  Create new table using scheme defintion supplied.
173 %   (Make copy of scheme and keep it with table.) */
174 %  db_mindex(db_scheme *, char *tablePath);
175 %
176 %/* destructor */
177 %  ~db_mindex();
178 %
179 %  db_index_entry_p satisfy_query_dbonly(db_query *, long *,
180 %					bool_t checkExpire,
181 %					bool_t *valid = NULL);
182 %
183 %/* Returns whether there table is valid (i.e. has scheme). */
184 %  bool_t good() { return scheme != NULL && table != NULL; }
185 %
186 %/* Change the version of the table to the one given. */
187 %  void change_version( vers *v ) {  rversion.assign( v );}
188 %
189 %/* Return the current version of the table. */
190 %  vers *get_version()  { return( &rversion ); }
191 %
192 %/* Reset contents of tables by: deleting indice entries, table entries */
193 %  void reset_tables();
194 %
195 %/* Reset the table by: deleting all the indices, table of entries, and its
196 %   scheme. Reset version to 0 */
197 %  void reset();
198 %
199 %/* Initialize table using information from specified file.
200 %   The table is first 'reset', then the attempt to load from the file
201 %   is made.  If the load failed, the table is again reset.
202 %   Therefore, the table will be modified regardless of the success of the
203 %   load.  Returns TRUE if successful, FALSE otherwise. */
204 %  int load( char * );
205 %
206 %/* Initialize table using information given in scheme 'how'.
207 %   Record the scheme for later use (make copy of it);
208 %   create the required number of indices; and create table for storing
209 %   entries.
210 %   The 'tablePath' is passed on to db_table in order to obtain the
211 %   NIS+/LDAP mapping information (if any). */
212 %  void init( db_scheme *);
213 %
214 %/* Write this structure (table, indices, scheme) into the specified file. */
215 %  int dump( char *);
216 %
217 %/* Removes the entry in the table named by given query 'q'.
218 %   If a NULL query is supplied, all entries in table are removed.
219 %   Returns DB_NOTFOUND if no entry is found.
220 %   Returns DB_SUCCESS if one entry is found; this entry is removed from
221 %   its record storage, and it is also removed from all the indices of the
222 %   table. If more than one entry satisfying 'q' is found, all are removed. */
223 %  db_status remove( db_query *);
224 %
225 %/* Add copy of given entry to table.  Entry is identified by query 'q'.
226 %   The entry (if any) satisfying the query is first deleted, then
227 %   added to the indices (using index values extracted form the given entry)
228 %   and the table.
229 %   Returns DB_NOTUNIQUE if more than one entry satisfies the query.
230 %   Returns DB_NOTFOUND if query is not well-formed.
231 %   Returns DB_SUCCESS if entry can be added.  */
232 %  db_status add( db_query *, entry_object* );
233 %
234 %
235 %/* Finds entry that satisfy the query 'q'.  Returns the answer by
236 %   setting the pointer 'rp' to point to the list of answers.
237 %   Note that the answers are pointers to copies of the entries.
238 %   Returns the number of answers find in 'count'.
239 %   Returns DB_SUCCESS if search found at least one answer;
240 %   returns DB_NOTFOUND if none is found. */
241 %  db_status lookup( db_query *, long *, entry_object_p ** );
242 %
243 %/* Returns the next entry in the table after 'previous' by setting 'answer' to
244 %   point to a copy of the entry_object.  Returns DB_SUCCESS if 'previous'
245 %   is valid and next entry is found; DB_NOTFOUND otherwise.  Sets 'where'
246 %   to location of where entry is found for input as subsequent 'next'
247 %   operation. */
248 %  db_status next( entryp, entryp *, entry_object ** );
249 %
250 %/* Returns the next entry in the table after 'previous' by setting 'answer' to
251 %   point to a copy of the entry_object.  Returns DB_SUCCESS if 'previous'
252 %   is valid and next entry is found; DB_NOTFOUND otherwise.  Sets 'where'
253 %   to location of where entry is found for input as subsequent 'next'
254 %   operation. */
255 %  db_status next( db_next_index_desc*, db_next_index_desc **, entry_object ** );
256 %
257 %/* Returns the first entry found in the table by setting 'answer' to
258 %   a copy of the entry_object.  Returns DB_SUCCESS if found;
259 %   DB_NOTFOUND otherwise.  */
260 %  db_status first( entryp*, entry_object ** );
261 %
262 %/* Returns the first entry that satisfies query by setting 'answer' to
263 %   a copy of the entry_object.  Returns DB_SUCCESS if found;
264 %   DB_NOTFOUND otherwise.  */
265 %  db_status first( db_query *, db_next_index_desc **, entry_object ** );
266 %
267 % /* Delete the given list of results; used when no longer interested in
268 %    the results of the first/next query that returned this list.     */
269 %  db_status reset_next( db_next_index_desc *orig );
270 %
271 %/* Return all entries within table.  Returns the answer by
272 %   setting the pointer 'rp' to point to the list of answers.
273 %   Note that the answers are pointers to copies of the entries.
274 %   Returns the number of answers find in 'count'.
275 %   Returns DB_SUCCESS if search found at least one answer;
276 %   returns DB_NOTFOUND if none is found. */
277 %  db_status all( long *, entry_object_p ** );
278 %
279 %  /* for debugging */
280 %/* Prints statistics of the table.  This includes the size of the table,
281 %   the number of entries, and the index sizes. */
282 %  void print_stats();
283 %
284 %/* Prints statistics about all indices of table. */
285 %  void print_all_indices();
286 %
287 %
288 %/* Prints statistics about indices identified by 'n'. */
289 %  void print_index( int n );
290 %
291 %/* Configure LDAP mapping */
292 %  bool_t configure (char *objName);
293 %
294 %/* Mark this instance deferred */
295 %  void markDeferred(void) {
296 %	if (table != NULL) table->markDeferred();
297 %  }
298 %/* Remove deferred mark */
299 %  void unmarkDeferred(void) {
300 %	if (table != NULL) table->unmarkDeferred();
301 %  }
302 %
303 %/* Retrieve, remove, or store data from/in/to LDAP */
304 %  int queryLDAP(db_query *, char *, int);
305 %  int entriesFromLDAP(__nis_table_mapping_t *, db_query *, db_query *,
306 %			char *, nis_object *, int);
307 %
308 %  int removeLDAP(db_query *, nis_object *o);
309 %
310 %  int storeObjLDAP(__nis_table_mapping_t *t, nis_object *o);
311 %  int storeLDAP(db_query *, entry_obj *, nis_object *, entry_obj *,
312 %		char *dbId);
313 %
314 %/* Set/clear no-write-through flag */
315 %  void setNoWriteThrough(void);
316 %  void clearNoWriteThrough(void);
317 %
318 %/* Set/clear no-LDAP-query flag */
319 %  void setNoLDAPquery(void);
320 %  void clearNoLDAPquery(void);
321 %
322 %/* Set/clear initialLoad flag */
323 %  void setInitialLoad(void);
324 %  void clearInitialLoad(void);
325 %
326 %/* Store/retrieve pointer to parent 'db' class instance */
327 %  void setDbPtr(void *ptr);
328 %  void *getDbPtr(void);
329 %
330 %/* Get pointer to private 'table' field */
331 %  db_table *getTable(void);
332 %
333 %/*
334 % * Update table entry per the (entry_object *). If 'replace' is set,
335 % * the entry is replaced or added; otherwise, it is removed.
336 % */
337 %  int updateTableEntry(entry_object *e, int replace, char *tableName,
338 %			nis_object *obj, nis_object *tobj, uint32_t ttime,
339 %			int *xid);
340 %
341 %/* Touch the indicated entry */
342 %  bool_t touchEntry(entry_object *e);
343 %  bool_t touchEntry(db_query *q);
344 %
345 %/* Return the 'scheme' pointer */
346 %  db_scheme *getScheme(void) {return (scheme);}
347 %
348 %/* RW lock functions */
349 %
350 %  int tryacqexcl(void) {
351 %	return (TRYWLOCK(mindex));
352 %  }
353 %
354 %  int acqexcl(void) {
355 %	return (WLOCK(mindex));
356 %  }
357 %
358 %  int relexcl(void) {
359 %	return (WULOCK(mindex));
360 %  }
361 %
362 %  int acqnonexcl(void) {
363 %	return (RLOCK(mindex));
364 %  }
365 %
366 %  int relnonexcl(void) {
367 %	return (RULOCK(mindex));
368 %  }
369 %};
370 %#ifdef __cplusplus
371 %extern "C" bool_t xdr_db_mindex(XDR*, db_mindex*);
372 %#elif __STDC__
373 %extern bool_t xdr_db_mindex(XDR*, db_mindex*);
374 %#endif
375 %typedef class db_mindex * db_mindex_p;
376 #endif /* RPC_HDR */
377 #endif /* USINGC */
378 
379 #if RPC_HDR
380 %#endif /* _DB_MINDEX_H */
381 #endif /* RPC_HDR */
382