git.sur5r.net Git - openldap/blob - servers/slurpd/slurp.h

   1 /*
   2  * Copyright (c) 1996 Regents of the University of Michigan.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that this notice is preserved and that due credit is given
   7  * to the University of Michigan at Ann Arbor. The name of the University
   8  * may not be used to endorse or promote products derived from this
   9  * software without specific prior written permission. This software
  10  * is provided ``as is'' without express or implied warranty.
  11  */
  12
  13 /* slurp.h - Standalone Ldap Update Replication Daemon (slurpd) */
  14
  15 #ifndef _SLURPD_H_
  16 #define _SLURPD_H_
  17
  18 #define LDAP_SYSLOG
  19
  20 #include <syslog.h>
  21 #include <errno.h>
  22 #include <sys/types.h>
  23 #include <sys/param.h>
  24 #include "lber.h"
  25 #include "ldap.h"
  26 #include "lthread.h"
  27 #include "portable.h"
  28 #include "ldapconfig.h"
  29 #include "ldif.h"
  30
  31
  32 /* Default directory for slurpd's private copy of replication logs */
  33 #define DEFAULT_SLURPD_REPLICA_DIR      "/usr/tmp"
  34
  35 /* Default name for slurpd's private copy of the replication log */
  36 #define DEFAULT_SLURPD_REPLOGFILE       "slurpd.replog"
  37
  38 /* Name of file which stores saved slurpd state info, for restarting */
  39 #define DEFAULT_SLURPD_STATUS_FILE      "slurpd.status"
  40
  41 /* slurpd dump file - contents of rq struct are written here (debugging) */
  42 #define SLURPD_DUMPFILE                 "/tmp/slurpd.dump"
  43
  44 /* default srvtab file.  Can be overridden */
  45 #define SRVTAB                          "/etc/srvtab"
  46
  47 /* Amount of time to sleep if no more work to do */
  48 #define DEFAULT_NO_WORK_INTERVAL        3
  49
  50 /* The time we wait between checks to see if the replog file needs trimming */
  51 #define TRIMCHECK_INTERVAL              ( 60 * 5 )
  52
  53 /* Only try to trim slurpd replica files larger than this size */
  54 #define MIN_TRIM_FILESIZE               ( 10L * 1024L )
  55
  56 /* Maximum line length we can read from replication log */
  57 #define REPLBUFLEN                      256
  58
  59 /* We support simple (plaintext password) and kerberos authentication */
  60 #define AUTH_SIMPLE     1
  61 #define AUTH_KERBEROS   2
  62
  63 /* Rejection records are prefaced with this string */
  64 #define ERROR_STR       "ERROR"
  65
  66 /* Strings found in replication entries */
  67 #define T_CHANGETYPESTR         "changetype"
  68 #define T_CHANGETYPE            1
  69 #define T_TIMESTR               "time"
  70 #define T_TIME                  2
  71 #define T_DNSTR                 "dn"
  72 #define T_DN                    3
  73
  74 #define T_ADDCTSTR              "add"
  75 #define T_ADDCT                 4
  76 #define T_MODIFYCTSTR           "modify"
  77 #define T_MODIFYCT              5
  78 #define T_DELETECTSTR           "delete"
  79 #define T_DELETECT              6
  80 #define T_MODRDNCTSTR           "modrdn"
  81 #define T_MODRDNCT              7
  82
  83 #define T_MODOPADDSTR           "add"
  84 #define T_MODOPADD              8
  85 #define T_MODOPREPLACESTR       "replace"
  86 #define T_MODOPREPLACE          9
  87 #define T_MODOPDELETESTR        "delete"
  88 #define T_MODOPDELETE           10
  89 #define T_MODSEPSTR             "-"
  90 #define T_MODSEP                11
  91
  92 #define T_NEWRDNSTR             "newrdn"
  93 #define T_DRDNFLAGSTR           "deleteoldrdn"
  94
  95 #define T_ERR                   -1
  96
  97 /* Config file keywords */
  98 #define HOSTSTR                 "host"
  99 #define BINDDNSTR               "binddn"
 100 #define BINDMETHSTR             "bindmethod"
 101 #define KERBEROSSTR             "kerberos"
 102 #define SIMPLESTR               "simple"
 103 #define CREDSTR                 "credentials"
 104 #define BINDPSTR                "bindprincipal"
 105 #define SRVTABSTR               "srvtab"
 106
 107 #define REPLICA_SLEEP_TIME      ( 10 )
 108
 109 /* Enumeration of various types of bind failures */
 110 #define BIND_OK                         0
 111 #define BIND_ERR_BADLDP                 1
 112 #define BIND_ERR_OPEN                   2
 113 #define BIND_ERR_BAD_ATYPE              3
 114 #define BIND_ERR_SIMPLE_FAILED          4
 115 #define BIND_ERR_KERBEROS_FAILED        5
 116 #define BIND_ERR_BADRI                  6
 117
 118 /* Return codes for do_ldap() */
 119 #define DO_LDAP_OK                      0
 120 #define DO_LDAP_ERR_RETRYABLE           1
 121 #define DO_LDAP_ERR_FATAL               2
 122
 123 /*
 124  * Types of counts one can request from the Rq rq_getcount()
 125  * member function
 126  */
 127 /* all elements */
 128 #define RQ_COUNT_ALL                    1
 129 /* all elements with nonzero refcnt */
 130 #define RQ_COUNT_NZRC                   2
 131
 132 /* Amount of time, in seconds, for a thread to sleep when it encounters
 133  * a retryable error in do_ldap().
 134  */
 135 #define RETRY_SLEEP_TIME                60
 136
 137
 138
 139 /*
 140  * ****************************************************************************
 141  * Data types for replication queue and queue elements.
 142  * ****************************************************************************
 143  */
 144
 145
 146 /*
 147  * Replica host information.  An Ri struct will contain an array of these,
 148  * with one entry for each replica.  The end of the array is signaled
 149  * by a NULL value in the rh_hostname field.
 150  */
 151 typedef struct rh {
 152     char        *rh_hostname;           /* replica hostname  */
 153     int         rh_port;                /* replica port */
 154 } Rh;
 155
 156
 157 /*
 158  * Per-replica information.
 159  *
 160  * Notes:
 161  *  - Private data should not be manipulated expect by Ri member functions.
 162  */
 163 typedef struct ri {
 164
 165     /* Private data */
 166     char        *ri_hostname;           /* canonical hostname of replica */
 167     int         ri_port;                /* port where slave slapd running */
 168     LDAP        *ri_ldp;                /* LDAP struct for this replica */
 169     int         ri_bind_method;         /* AUTH_SIMPLE or AUTH_KERBEROS */
 170     char        *ri_bind_dn;            /* DN to bind as when replicating */
 171     char        *ri_password;           /* Password for AUTH_SIMPLE */
 172     char        *ri_principal;          /* principal for kerberos bind */
 173     char        *ri_srvtab;             /* srvtab file for kerberos bind */
 174     struct re   *ri_curr;               /* current repl entry being processed */
 175     struct stel *ri_stel;               /* pointer to Stel for this replica */
 176     unsigned long
 177                 ri_seq;                 /* seq number of last repl */
 178     pthread_t   ri_tid;                 /* ID of thread for this replica */
 179
 180     /* Member functions */
 181     int         (*ri_process)();        /* process the next repl entry */
 182     void        (*ri_wake)();           /* wake up a sleeping thread */
 183 } Ri;
 184
 185
 186
 187
 188 /*
 189  * Information about one particular modification to make.  This data should
 190  * be considered private to routines in re.c, and to routines in ri.c.
 191  */
 192 typedef struct mi {
 193
 194     /* Private data */
 195     char        *mi_type;               /* attr or type */
 196     char        *mi_val;                /* value */
 197     int         mi_len;                 /* length of mi_val */
 198
 199 } Mi;
 200
 201
 202
 203
 204 /*
 205  * Information about one particular replication entry.  Only routines in
 206  * re.c  and rq.c should touch the private data.  Other routines should
 207  * only use member functions.
 208  */
 209 typedef struct re {
 210
 211     /* Private data */
 212     pthread_mutex_t
 213                 re_mutex;               /* mutex for this Re */
 214     int         re_refcnt;              /* ref count, 0 = done */
 215     char        *re_timestamp;          /* timestamp of this re */
 216     int         re_seq;                 /* sequence number */
 217     Rh          *re_replicas;           /* array of replica info */
 218     char        *re_dn;                 /* dn of entry being modified */
 219     int         re_changetype;          /* type of modification */
 220     Mi          *re_mods;               /* array of modifications to make */
 221     struct re   *re_next;               /* pointer to next element */
 222
 223     /* Public functions */
 224     int         (*re_free)();           /* free an re struct */
 225     struct re   *(*re_getnext)();       /* return next Re in linked list */
 226     int         (*re_parse)();          /* parse a replication log entry */
 227     int         (*re_write)();          /* write a replication log entry */
 228     void        (*re_dump)();           /* debugging  - print contents */
 229     int         (*re_lock)();           /* lock this re */
 230     int         (*re_unlock)();         /* unlock this re */
 231     int         (*re_decrefcnt)();      /* decrement the refcnt */
 232     int         (*re_getrefcnt)();      /* get the refcnt */
 233 } Re;
 234
 235
 236
 237
 238 /*
 239  * Definition for the queue of replica information.  Private data is
 240  * private to rq.c.  Other routines should only touch public data or
 241  * use member functions.  Note that although we have a member function
 242  * for locking the queue's mutex, we need to expose the rq_mutex
 243  * variable so routines in ri.c can use it as a mutex for the
 244  * rq_more condition variable.
 245  */
 246 typedef struct rq {
 247
 248     /* Private data */
 249     Re          *rq_head;               /* pointer to head */
 250     Re          *rq_tail;               /* pointer to tail */
 251     int         rq_nre;                 /* total number of Re's in queue */
 252     int         rq_ndel;                /* number of deleted Re's in queue */
 253     time_t      rq_lasttrim;            /* Last time we trimmed file */
 254
 255     /* Public data */
 256     pthread_mutex_t
 257                 rq_mutex;               /* mutex for whole queue */
 258     pthread_cond_t
 259                 rq_more;                /* condition var - more work added */
 260
 261     /* Member functions */
 262     Re          *(*rq_gethead)();       /* get the element at head */
 263     Re          *(*rq_getnext)();       /* get the next element */
 264     int         (*rq_delhead)();        /* delete the element at head */
 265     int         (*rq_add)();            /* add at tail */
 266     void        (*rq_gc)();             /* garbage-collect queue */
 267     int         (*rq_lock)();           /* lock the queue */
 268     int         (*rq_unlock)();         /* unlock the queue */
 269     int         (*rq_needtrim)();       /* see if queue needs trimming */
 270     int         (*rq_write)();          /* write Rq contents to a file */
 271     int         (*rq_getcount)();       /* return queue counts */
 272     void        (*rq_dump)();           /* debugging  - print contents */
 273 } Rq;
 274
 275
 276
 277 /*
 278  * An Stel (status element) contains information about one replica.
 279  * Stel structs are associated with the St (status) struct, defined
 280  * below.
 281  */
 282 typedef struct stel {
 283     char        *hostname;              /* host name of replica */
 284     int         port;                   /* port number of replica */
 285     char        last[ 64 ];             /* timestamp of last successful repl */
 286     int         seq;                    /* Sequence number of last repl */
 287 } Stel;
 288
 289
 290 /*
 291  * An St struct in an in-core structure which contains the current
 292  * slurpd state.  Most importantly, it contains an array of Stel
 293  * structs which contain the timestamp and sequence number of the last
 294  * successful replication for each replica.  The st_write() member
 295  * function is called periodically to flush status information to
 296  * disk.  At startup time, slurpd checks for the status file, and
 297  * if present, uses the timestamps to avoid "replaying" replications
 298  * which have already been sent to a given replica.
 299  */
 300 typedef struct st {
 301
 302     /* Private data */
 303     pthread_mutex_t
 304                 st_mutex;               /* mutex to serialize access */
 305     Stel        **st_data;              /* array of pointers to Stel structs */
 306     int         st_nreplicas;           /* number of repl hosts */
 307     int         st_err_logged;          /* 1 if fopen err logged */
 308     FILE        *st_fp;                 /* st file kept open */
 309     FILE        *st_lfp;                /* lockfile fp */
 310
 311     /* Public member functions */
 312     int         (*st_update)();         /* update the entry for a host */
 313     Stel        *(*st_add)();           /* add a new repl host */
 314     int         (*st_write)();          /* write status to disk */
 315     int         (*st_read)();           /* read status info from disk */
 316     int         (*st_lock)();           /* read status info from disk */
 317     int         (*st_unlock)();         /* read status info from disk */
 318 } St;
 319
 320 #if defined( THREAD_SUNOS4_LWP )
 321 typedef struct tl {
 322     thread_t    tl_tid;         /* thread being managed */
 323     time_t      tl_wake;        /* time thread should be resumed */
 324     struct tl   *tl_next;       /* next node in list */
 325 } tl_t;
 326
 327 typedef struct tsl {
 328     tl_t        *tsl_list;
 329     mon_t       tsl_mon;
 330 } tsl_t;
 331 #endif /* THREAD_SUNOS4_LWP */
 332
 333
 334
 335 /*
 336  * Public functions used to instantiate and initialize queue objects.
 337  */
 338 #ifdef NEEDPROTOS
 339 extern int Ri_init( Ri **ri );
 340 extern int Rq_init( Rq **rq );
 341 extern int Re_init( Re **re );
 342 #else /* NEEDPROTOS */
 343 extern int Ri_init();
 344 extern int Rq_init();
 345 extern int Re_init();
 346 #endif /* NEEDPROTOS */
 347
 348 #endif /* _SLURPD_H_ */
 349