Home | History | Annotate | Download | only in libnisdb
      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_dictlog_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_DICTLOG_H
     33 %#define _DB_DICTLOG_H
     34 
     35 %
     36 %/* A log entry that describes an action to be performed and its parameters. */
     37 %
     38 #endif /* RPC_HDR */
     39 
     40 #if RPC_HDR || RPC_XDR
     41 #ifdef USINGC
     42 %#include "db_vers_c.h"
     43 #else
     44 %#include "db_vers.h"
     45 %#include "db_pickle.h"
     46 #endif /* USINGC */
     47 %#include <rpcsvc/nis.h>
     48 #endif /* RPC_HDR */
     49 %
     50 %#include "nisdb_rw.h"
     51 %
     52 %#define DB_ADD_TABLE 1
     53 %#define DB_REMOVE_TABLE 2
     54 
     55 #if RPC_HDR || RPC_XDR
     56 #ifdef USINGC
     57 struct db_dictlog_entry {
     58   vers aversion;                    /* version of log entry */
     59   int       action;                 /* action to be invoked */
     60   string table_name<>;                /* table_name supplied with action */
     61   table_obj *table_object;          /* object involved in action (if any) */
     62   struct db_dictlog_entry *next;    /* Used in constructing list */
     63   vers bversion;                    /* sanity check;should be same as aversion*/
     64 };
     65 typedef  struct db_dictlog_entry* db_dictlog_entry_p;
     66 #endif /* USINGC */
     67 #endif /* RPC_HDR */
     68 
     69 #ifdef USINGC
     70 #if RPC_HDR
     71 %bool_t xdr_table_obj();
     72 #endif
     73 #endif /* USINGC */
     74 
     75 #ifndef USINGC
     76 #ifdef RPC_HDR
     77 %class db_dictlog_entry {
     78 %  vers aversion;                     /* version of log entry */
     79 %  int action;                        /* action to be invoked */
     80 %  char *table_name;                  /* table_name supplied with action (if any) */
     81 %  table_obj *table_object;           /* object involved in action (if any) */
     82 %  db_dictlog_entry *next;                /* Used in constructing list */
     83 %  vers bversion;                     /* sanity check */
     84 % public:
     85 %
     86 %/*Constructor:  Create an empty log entry, with no table_name and not object */
     87 %  db_dictlog_entry() { table_name = NULL, table_object = NULL; next = NULL; }
     88 %
     89 %/*Constructor:  Create a log entry using the given parameters.  Note that
     90 %  pointers to table_name and table_object are simply assigned, not copied. */
     91 %  db_dictlog_entry(int, vers *, char*, table_obj*);
     92 %
     93 %  ~db_dictlog_entry();
     94 %
     95 %/* Print this log entry to stdout */
     96 %  void print();
     97 %
     98 %/* Accessor: return version of log entry */
     99 %  vers *get_version()  { return( &aversion ); }
    100 %
    101 %/* Accessor: return pointer to action of log entry */
    102 %  int get_action()  { return( action ); }
    103 %
    104 %/* Accessor:  return pointer to table_name part of log entry */
    105 %  char* get_table_name()  { return( table_name ); }
    106 %
    107 %/* Predicate:  return whether log entry is complete and not truncated */
    108 %  bool_t sane() { return( aversion.equal( &bversion ) ); }
    109 %
    110 %/* Accessor:  return pointer to copy of object in log entry */
    111 %  table_obj *get_table_object()  { return( table_object ); }
    112 %
    113 %/* Accessor:  return pointer to to next log entry */
    114 %  db_dictlog_entry * getnextptr()  { return( next ); }
    115 %
    116 %/* Accessor:  return pointer to copy of object in log entry */
    117 %  void setnextptr( db_dictlog_entry *p )  { next = p; }
    118 %};
    119 %#ifdef __cplusplus
    120 %extern "C" bool_t xdr_db_dictlog_entry(XDR*, db_dictlog_entry*);
    121 %#elif __STDC__
    122 %extern bool_t xdr_db_dictlog_entry(XDR*, db_dictlog_entry*);
    123 %#endif
    124 %typedef class db_dictlog_entry * db_dictlog_entry_p;
    125 #endif /* RPC_HDR */
    126 #endif /* USINGC */
    127 
    128 struct db_dictlog_list {
    129   db_dictlog_entry_p list<>;
    130 };
    131 
    132 #ifndef USINGC
    133 #ifdef RPC_HDR
    134 %class db_dictlog: public pickle_file {
    135 %	STRUCTRWLOCK(dictlog);
    136 % public:
    137 %
    138 %/* Constructor:  create log file; default is PICKLE_READ mode. */
    139 %  db_dictlog( char* f, pickle_mode m = PICKLE_READ ): pickle_file(f,m) {
    140 %	INITRW(dictlog);
    141 %  }
    142 %
    143 %  ~db_dictlog(void) {
    144 %	DESTROYRW(dictlog);
    145 %  }
    146 %
    147 %/* Execute given function 'func' on log.
    148 %  function takes as arguments: pointer to log entry, character pointer to
    149 %  another argument, and pointer to an integer, which is used as a counter.
    150 %  'func' should increment this value for each successful application.
    151 %  The log is traversed until either 'func' returns FALSE, or when the log
    152 %  is exhausted.  The second argument to 'execute_on_log' is passed as the
    153 %  second argument to 'func'. The third argument, 'clean' determines whether
    154 %  the log entry is deleted after the function has been applied.
    155 %  Returns the number of times that 'func' incremented its third argument. */
    156 %  int execute_on_log( bool_t(* func) (db_dictlog_entry *, char *, int *),
    157 %		      char *, bool_t = TRUE );
    158 %
    159 %/* Print contents of log file to stdout */
    160 %  int print();
    161 %
    162 %/*Append given log entry to log. */
    163 %  int append( db_dictlog_entry * );
    164 %
    165 %/* Return the next element in current log; return NULL if end of log or error.
    166 %   Log must have been opened for READ. */
    167 %  db_dictlog_entry *get();
    168 %
    169 %/*
    170 % * Locking methods. Protect the db_dictlog as well as db_dictlog_entries
    171 % * hanging off of it.
    172 % */
    173 %  int acqexcl(void) {
    174 %	return (WLOCK(dictlog));
    175 %  }
    176 %
    177 %  int relexcl(void) {
    178 %	return (WULOCK(dictlog));
    179 %  }
    180 %
    181 %  int acqnonexcl(void) {
    182 %	return (RLOCK(dictlog));
    183 %  }
    184 %
    185 %  int relnonexcl(void) {
    186 %	return (RULOCK(dictlog));
    187 %  }
    188 %
    189 %};
    190 #endif /* RPC_HDR */
    191 #endif /* USINGC */
    192 
    193 #if RPC_HDR
    194 %#endif /* _DB_DICTLOG_H */
    195 #endif /* RPC_HDR */
    196