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

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