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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * db_table_c.x 24 * 25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 26 * Use is subject to license terms. 27 */ 28 29 %#pragma ident "%Z%%M% %I% %E% SMI" 30 31 #if RPC_HDR 32 %#ifndef _DB_TABLE_H 33 %#define _DB_TABLE_H 34 35 #ifdef USINGC 36 %#include "db_query_c.h" 37 %#include "db_scheme_c.h" 38 #else 39 %#include "db_query.h" 40 %#include "db_scheme.h" 41 #endif /* USINGC */ 42 #endif /* RPC_HDR */ 43 % 44 %#include "nisdb_ldap.h" 45 %#include "nisdb_rw.h" 46 %#include "ldap_parse.h" 47 %#include "ldap_map.h" 48 %#include "ldap_util.h" 49 %#include "ldap_nisdbquery.h" 50 %#include "ldap_print.h" 51 %#include "ldap_xdr.h" 52 % 53 typedef long entryp; /* specifies location of an entry within table */ 54 55 struct db_free_entry { 56 entryp where; 57 struct db_free_entry *next; 58 }; 59 60 typedef struct db_free_entry * db_free_entry_p; 61 62 #if RPC_HDR || RPC_XDR 63 #ifdef USINGC 64 struct db_free_list { 65 db_free_entry_p head; 66 long count; 67 __nisdb_rwlock_t free_list_rwlock; 68 }; 69 typedef struct db_free_list * db_free_list_p; 70 #endif /* USINGC */ 71 #endif /* RPC_HDR */ 72 73 #ifndef USINGC 74 #ifdef RPC_HDR 75 %class db_free_list { 76 % db_free_entry_p head; 77 % long count; 78 % STRUCTRWLOCK(free_list); 79 % public: 80 % db_free_list() { /* free list constructor */ 81 % head = NULL; 82 % count = 0; 83 % INITRW(free_list); 84 % } 85 % 86 % ~db_free_list(); 87 % 88 % void reset(); /* empty contents of free list */ 89 % 90 % void init(); /* Empty free list */ 91 % 92 %/* Returns the location of a free entry, or NULL, if there aren't any. */ 93 % entryp pop(); 94 % 95 %/* Adds given location to the free list. 96 % Returns TRUE if successful, FALSE otherwise (when out of memory). */ 97 % bool_t push( entryp ); 98 % 99 %/* Returns in a vector the information in the free list. 100 % Vector returned is of form: <n free cells><n1><n2><loc1>,..<locn>. 101 % Leave the first 'n' cells free. 102 % n1 is the number of entries that should be in the freelist. 103 % n2 is the number of entries actually found in the freelist. 104 % <loc1...locn> are the entries. n2 <= n1 because we never count beyond n1. 105 % It is up to the caller to free the returned vector when he is through. */ 106 % long* stats( int n ); 107 % 108 %/* Locking methods */ 109 % 110 % int acqexcl(void) { 111 % return (WLOCK(free_list)); 112 % } 113 % 114 % int relexcl(void) { 115 % return (WULOCK(free_list)); 116 % } 117 % 118 % int acqnonexcl(void) { 119 % return (RLOCK(free_list)); 120 % } 121 % 122 % int relnonexcl(void) { 123 % return (RULOCK(free_list)); 124 % } 125 %}; 126 #endif /* RPC_HDR */ 127 #endif /* USINGC */ 128 129 #if RPC_HDR || RPC_XDR 130 #ifdef USINGC 131 struct db_table 132 { 133 entry_object_p tab <>; 134 long last_used; /* last entry used; maintained for quick insertion */ 135 long count; /* measures fullness of table */ 136 db_free_list freelist; 137 __nisdb_rwlock_t table_rwlock; 138 __nisdb_flag_t enumMode; 139 __nisdb_ptr_t enumArray; 140 __nis_table_mapping_t mapping; 141 }; 142 typedef struct db_table * db_table_p; 143 144 #endif /* USINGC */ 145 #endif /* RPC_HDR */ 146 147 #ifndef USINGC 148 #ifdef RPC_HDR 149 %class db_table 150 %{ 151 % long table_size; 152 % entry_object_p *tab; /* pointer to array of pointers to entry objects */ 153 % long last_used; /* last entry used; maintained for quick insertion */ 154 % long count; /* measures fullness of table */ 155 % db_free_list freelist; 156 % STRUCTRWLOCK(table); 157 % __nisdb_flag_t enumMode; 158 % __nisdb_flag_t enumCount; 159 % __nisdb_ptr_t enumIndex; 160 % __nisdb_ptr_t enumArray; 161 % 162 % void grow(); /* Expand the table. 163 % Fatal error if insufficient error. */ 164 % 165 %/* Allocate expiration time array */ 166 % db_status allocateExpire(long oldSize, long newSize); 167 % 168 % public: 169 % __nisdb_table_mapping_t mapping; 170 % 171 % db_table(); /* constructor for brand new, empty table. */ 172 % db_table( char * ); /* constructor for creating a table by loading 173 % in an existing one. */ 174 % 175 %/* Init of LDAP/MT portion of class instance */ 176 % void db_table_ldap_init(void); 177 %/* Size of the non-MT/LDAP portion of the db_table structure */ 178 % ulong_t oldstructsize(void) { 179 % return ((ulong_t)&(this->table_rwlock) - (ulong_t)this); 180 % } 181 %/* Mark this instance as deferred */ 182 % void markDeferred(void) { 183 % mapping.isDeferredTable = TRUE; 184 % } 185 %/* Remove deferred mark */ 186 % void unmarkDeferred(void) { 187 % mapping.isDeferredTable = FALSE; 188 % } 189 % 190 %/* Return the current 'tab' */ 191 % entry_object_p *gettab() { ASSERTRHELD(table); return (tab); }; 192 %/* Return how many entries there are in table. */ 193 % long fullness() { return count; } 194 % 195 %/* Deletes table, entries, and free list */ 196 % ~db_table(); 197 % 198 % int tryacqexcl(void) { 199 % return (TRYWLOCK(table)); 200 % } 201 % 202 % int acqexcl(void) { 203 % return (WLOCK(table)); 204 % } 205 % 206 % int relexcl(void) { 207 % return (WULOCK(table)); 208 % } 209 % 210 % int acqnonexcl(void) { 211 % return (RLOCK(table)); 212 % } 213 % 214 % int relnonexcl(void) { 215 % return (RULOCK(table)); 216 % } 217 % 218 %/* empties table by deleting all entries and other associated data structures */ 219 % void reset(); 220 % 221 % int dump( char *); 222 % 223 %/* Returns whether location is valid. */ 224 % bool_t entry_exists_p( entryp i ); 225 % 226 %/* Returns table size. */ 227 % long getsize() { return table_size; } 228 % 229 %/* Returns the first entry in table, also return its position in 230 % 'where'. Return NULL in both if no next entry is found. */ 231 % entry_object_p first_entry( entryp * where ); 232 % 233 %/* Returns the next entry in table from 'prev', also return its position in 234 % 'newentry'. Return NULL in both if no next entry is found. */ 235 % entry_object_p next_entry( entryp, entryp* ); 236 % 237 %/* Returns entry at location 'where', NULL if location is invalid. */ 238 % entry_object_p get_entry( entryp ); 239 % 240 %/* Adds given entry to table in first available slot (either look in freelist 241 % or add to end of table) and return the the position of where the record 242 % is placed. 'count' is incremented if entry is added. Table may grow 243 % as a side-effect of the addition. Copy is made of the input. */ 244 % entryp add_entry(entry_object_p, int); 245 % 246 % /* Replaces object at specified location by given entry. 247 % Returns TRUE if replacement successful; FALSE otherwise. 248 % There must something already at the specified location, otherwise, 249 % replacement fails. Copy is not made of the input. 250 % The pre-existing entry is freed.*/ 251 % bool_t replace_entry( entryp, entry_object_p ); 252 % 253 %/* Deletes entry at specified location. Returns TRUE if location is valid; 254 % FALSE if location is invalid, or the freed location cannot be added to 255 % the freelist. 'count' is decremented if the deletion occurs. The object 256 % at that location is freed. */ 257 % bool_t delete_entry( entryp ); 258 % 259 %/* Returns statistics of table. 260 % <table_size><last_used><count>[freelist]. 261 % It is up to the caller to free the returned vector when his is through 262 % The free list is included if 'fl' is TRUE. */ 263 %long * stats( bool_t fl ); 264 % 265 %/* Configure LDAP mapping */ 266 % bool_t configure(char *objName); 267 % 268 %/* Initialize the mapping structure with default values */ 269 % void initMappingStruct(__nisdb_table_mapping_t *mapping); 270 % 271 %/* Check if entry at 'loc' is valid (not expired) */ 272 % bool_t cacheValid(entryp loc); 273 % 274 %/* Update expiration time if supplied object same as the one at 'loc' */ 275 % bool_t dupEntry(entry_object *obj, entryp loc); 276 % 277 %/* Set expiration time for entry */ 278 % void setEntryExp(entryp where, entry_object *obj, int initialLoad); 279 % 280 %/* Enable enum mode */ 281 % void setEnumMode(long count); 282 %/* Clear enum mode */ 283 % void clearEnumMode(void); 284 %/* End enum mode, return array of untouched entries */ 285 % entry_object **endEnumMode(long *numEa); 286 %/* Mark the indicated entry used for enum purposes */ 287 % void enumTouch(entryp loc); 288 %/* Add entry to enumIndex array */ 289 % void enumSetup(entryp loc, long index); 290 %/* Touch the indicated entry */ 291 % void touchEntry(entryp loc); 292 % 293 % db_status allocateEnumArray(long oldSize, long newSize); 294 %}; 295 %#ifdef __cplusplus 296 %extern "C" bool_t xdr_db_table( XDR*, db_table*); 297 %#elif __STDC__ 298 %extern bool_t xdr_db_table(XDR*, db_table*); 299 %#endif 300 %typedef class db_table * db_table_p; 301 #endif /* RPC_HDR */ 302 #endif /* USINGC */ 303 304 #if RPC_HDR 305 %#endif /* _DB_TABLE_H */ 306 #endif /* RPC_HDR */ 307