git.sur5r.net Git - openldap/blob - servers/slapd/tools/mimic.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*
   7  * Mimic unused interfaces of slapd...
   8  * needed for linking.
   9  */
  10 #include "portable.h"
  11
  12 #include <stdio.h>
  13
  14 #include "../slap.h"
  15
  16 #include "ldap_rq.h"
  17
  18 /* needed by WIN32 and back-monitor */
  19 time_t starttime;
  20
  21 /* because Versionstr is used in back-monitor */
  22 const char Versionstr[] = "";
  23
  24 /* bogus ../results.c */
  25 int str2result(
  26         char* s,
  27         int *code,
  28         char **matched,
  29         char **info )
  30 {
  31         assert(0);
  32     return 0;
  33 }
  34
  35 void
  36 send_ldap_disconnect( Operation *op, SlapReply *rs )
  37 {
  38         assert(0);
  39 }
  40
  41 void
  42 slap_send_ldap_extended(
  43     Operation   *op, SlapReply *rs
  44 )
  45 {
  46         assert(0);
  47 }
  48
  49 void
  50 slap_send_ldap_intermediate_resp(
  51         Operation *op, SlapReply *rs
  52 )
  53 {
  54         assert(0);
  55 }
  56
  57 void
  58 send_ldap_sasl( Operation *op, SlapReply *rs )
  59 {
  60         assert(0);
  61 }
  62
  63 void
  64 slap_send_ldap_result( Operation *op, SlapReply *rs )
  65 {
  66         assert(0);
  67 }
  68
  69 int
  70 slap_send_search_entry( Operation *op, SlapReply *rs )
  71 {
  72         assert(0);
  73         return -1;
  74 }
  75
  76 int
  77 slap_send_search_reference( Operation *op, SlapReply *rs )
  78 {
  79         assert(0);
  80         return -1;
  81 }
  82
  83 int slap_read_controls(
  84         Operation *op,
  85         SlapReply *rs,
  86         Entry *e,
  87         const struct berval *oid,
  88         LDAPControl **c )
  89 {
  90         assert(0);
  91         return -1;
  92 }
  93
  94 int slap_sasl_init(void)
  95 {
  96         return LDAP_SUCCESS;
  97 }
  98
  99 int slap_sasl_destroy(void)
 100 {
 101         return LDAP_SUCCESS;
 102 }
 103
 104 int slap_sasl_setpass( Operation *op, SlapReply *rs )
 105 {
 106         return LDAP_SUCCESS;
 107 }
 108
 109 int slap_sasl_config(
 110         int cargc,
 111         char **cargv,
 112         char *line,
 113         const char *fname,
 114         int lineno )
 115 {
 116         return LDAP_SUCCESS;
 117 }
 118
 119
 120 int connection_client_setup(
 121         ber_socket_t s,
 122         Listener *l,
 123         ldap_pvt_thread_start_t *func,
 124         void *arg )
 125 {
 126         assert(0);
 127         return 0;
 128 }
 129
 130 void connection_client_enable( ber_socket_t s )
 131 {
 132         assert(0);
 133 }
 134
 135 void connection_client_stop( ber_socket_t s )
 136 {
 137         assert(0);
 138 }
 139
 140 void connection2anonymous( Connection *c )
 141 {
 142         assert(0);
 143 }
 144
 145 Connection * connection_first( ber_socket_t *b )
 146 {
 147         assert(0);
 148         return NULL;
 149 }
 150
 151 Connection * connection_next( Connection *c, ber_socket_t *b )
 152 {
 153         assert(0);
 154         return NULL;
 155 }
 156
 157 unsigned long connections_nextid(void)
 158 {
 159         return 0;
 160 }
 161
 162 void connection_done( Connection *c )
 163 {
 164         assert(0);
 165 }
 166
 167 const char * connection_state2str( int state )
 168 {
 169         assert(0);
 170         return NULL;
 171 }
 172
 173 void replog( Operation *op )
 174 {
 175         assert(0);
 176 }
 177
 178 int add_replica_info( Backend *be, const char *host )
 179 {
 180         return 0;
 181 }
 182
 183 int add_replica_suffix( Backend *be, int nr, const char *suffix )
 184 {
 185         return 0;
 186 }
 187
 188 int add_replica_attrs( Backend *be, int nr, char *attrs, int exclude )
 189 {
 190         return 0;
 191 }
 192
 193 int parse_limits( Backend *be, const char *fname, int lineno, int argc, char **argv )
 194 {
 195         return 0;
 196 }
 197
 198 int parse_limit( const char *arg, struct slap_limits_set *limit )
 199 {
 200         return 0;
 201 }
 202
 203 int get_limits( Backend *be, struct berval *ndn, struct slap_limits_set **limit )
 204 {
 205         return 0;
 206 }
 207
 208 int read_root_dse_file ( const char *file )
 209 {
 210         return 0;
 211 }
 212
 213 Attribute *
 214 slap_operational_subschemaSubentry( Backend *be )
 215 {
 216         return NULL;
 217 }
 218
 219 Attribute *
 220 slap_operational_hasSubordinate( int hs )
 221 {
 222         return NULL;
 223 }
 224
 225 Listener **
 226 slapd_get_listeners(void)
 227 {
 228         return NULL;
 229 }
 230
 231 int
 232 slap_modrdn2mods(
 233         Operation       *op, SlapReply *rs,
 234         Entry           *e,
 235         LDAPRDN         oldrdn,
 236         LDAPRDN         newrdn,
 237         Modifications   **pmod )
 238 {
 239         return 0;
 240 }
 241
 242 int slap_sasl_getdn( Connection *conn, Operation *op, char *id, int len,
 243         char *user_realm, struct berval *dn, int flags )
 244 {
 245         return -1;
 246 }
 247
 248 int slap_sasl_authorized( Operation *op,
 249         struct berval *authcDN, struct berval *authzDN )
 250 {
 251         return -1;
 252 }
 253
 254 int root_dse_info( Connection *conn, Entry **entry, const char **text )
 255 {
 256         return -1;
 257 }
 258
 259 int slap_entry2mods( Entry *e, Modifications **mods, const char **text )
 260 {
 261         return -1;
 262 }
 263
 264 volatile sig_atomic_t slapd_abrupt_shutdown;
 265
 266 int slap_mods_check( Modifications *ml, int update, const char **text,
 267                                         char *textbuf, size_t textlen, void *ctx )
 268 {
 269         return -1;
 270 }
 271
 272 int slap_mods2entry( Modifications *mods, Entry **e, int repl_user,
 273                                     int dup, const char **text, char *textbuf, size_t textlen )
 274 {
 275         return -1;
 276 }
 277
 278 int slap_mods_opattrs( Operation *op, Modifications *mods,
 279                                            Modifications **modtail, const char **text,
 280                                            char *textbuf, size_t textlen )
 281 {
 282         return -1;
 283 }
 284