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 void
  58 slap_send_ldap_extended(
  59     Operation   *op, SlapReply *rs
  60 )
  61 {
  62         assert(0);
  63 }
  64
  65 void
  66 slap_send_ldap_intermediate_resp(
  67         Operation *op, SlapReply *rs
  68 )
  69 {
  70         assert(0);
  71 }
  72
  73 void
  74 send_ldap_sasl( Operation *op, SlapReply *rs )
  75 {
  76         assert(0);
  77 }
  78
  79 void
  80 slap_send_ldap_result( Operation *op, SlapReply *rs )
  81 {
  82         assert(0);
  83 }
  84
  85 int
  86 slap_send_search_entry( Operation *op, SlapReply *rs )
  87 {
  88         assert(0);
  89         return -1;
  90 }
  91
  92 int
  93 slap_send_search_reference( Operation *op, SlapReply *rs )
  94 {
  95         assert(0);
  96         return -1;
  97 }
  98
  99 int slap_read_controls(
 100         Operation *op,
 101         SlapReply *rs,
 102         Entry *e,
 103         const struct berval *oid,
 104         LDAPControl **c )
 105 {
 106         assert(0);
 107         return -1;
 108 }
 109
 110 int slap_sasl_init(void)
 111 {
 112         return LDAP_SUCCESS;
 113 }
 114
 115 int slap_sasl_destroy(void)
 116 {
 117         return LDAP_SUCCESS;
 118 }
 119
 120 int slap_sasl_setpass( Operation *op, SlapReply *rs )
 121 {
 122         return LDAP_SUCCESS;
 123 }
 124
 125 int slap_sasl_config(
 126         int cargc,
 127         char **cargv,
 128         char *line,
 129         const char *fname,
 130         int lineno )
 131 {
 132         return LDAP_SUCCESS;
 133 }
 134
 135
 136 int connection_client_setup(
 137         ber_socket_t s,
 138         Listener *l,
 139         ldap_pvt_thread_start_t *func,
 140         void *arg )
 141 {
 142         assert(0);
 143         return 0;
 144 }
 145
 146 void connection_client_enable( ber_socket_t s )
 147 {
 148         assert(0);
 149 }
 150
 151 void connection_client_stop( ber_socket_t s )
 152 {
 153         assert(0);
 154 }
 155
 156 void connection2anonymous( Connection *c )
 157 {
 158         assert(0);
 159 }
 160
 161 Connection * connection_first( ber_socket_t *b )
 162 {
 163         assert(0);
 164         return NULL;
 165 }
 166
 167 Connection * connection_next( Connection *c, ber_socket_t *b )
 168 {
 169         assert(0);
 170         return NULL;
 171 }
 172
 173 unsigned long connections_nextid(void)
 174 {
 175         return 0;
 176 }
 177
 178 void connection_done( Connection *c )
 179 {
 180         assert(0);
 181 }
 182
 183 const char * connection_state2str( int state )
 184 {
 185         assert(0);
 186         return NULL;
 187 }
 188
 189 void replog( Operation *op )
 190 {
 191         assert(0);
 192 }
 193
 194 int add_replica_info( Backend *be, const char *host )
 195 {
 196         return 0;
 197 }
 198
 199 int add_replica_suffix( Backend *be, int nr, const char *suffix )
 200 {
 201         return 0;
 202 }
 203
 204 int add_replica_attrs( Backend *be, int nr, char *attrs, int exclude )
 205 {
 206         return 0;
 207 }
 208
 209 int parse_limits( Backend *be, const char *fname, int lineno, int argc, char **argv )
 210 {
 211         return 0;
 212 }
 213
 214 int parse_limit( const char *arg, struct slap_limits_set *limit )
 215 {
 216         return 0;
 217 }
 218
 219 int get_limits( Backend *be, struct berval *ndn, struct slap_limits_set **limit )
 220 {
 221         return 0;
 222 }
 223
 224 int read_root_dse_file ( const char *file )
 225 {
 226         return 0;
 227 }
 228
 229 Attribute *
 230 slap_operational_subschemaSubentry( Backend *be )
 231 {
 232         return NULL;
 233 }
 234
 235 Attribute *
 236 slap_operational_hasSubordinate( int hs )
 237 {
 238         return NULL;
 239 }
 240
 241 Listener **
 242 slapd_get_listeners(void)
 243 {
 244         return NULL;
 245 }
 246
 247 int
 248 slap_modrdn2mods(
 249         Operation       *op, SlapReply *rs,
 250         Entry           *e,
 251         LDAPRDN         oldrdn,
 252         LDAPRDN         newrdn,
 253         Modifications   **pmod )
 254 {
 255         return 0;
 256 }
 257
 258 int slap_sasl_getdn( Connection *conn, Operation *op, char *id, int len,
 259         char *user_realm, struct berval *dn, int flags )
 260 {
 261         return -1;
 262 }
 263
 264 int slap_sasl_authorized( Operation *op,
 265         struct berval *authcDN, struct berval *authzDN )
 266 {
 267         return -1;
 268 }
 269
 270 int root_dse_info( Connection *conn, Entry **entry, const char **text )
 271 {
 272         return -1;
 273 }
 274
 275 int slap_entry2mods( Entry *e, Modifications **mods, const char **text )
 276 {
 277         return -1;
 278 }
 279
 280 volatile sig_atomic_t slapd_abrupt_shutdown;
 281
 282 int slap_mods_check( Modifications *ml, int update, const char **text,
 283                                         char *textbuf, size_t textlen, void *ctx )
 284 {
 285         return -1;
 286 }
 287
 288 int slap_mods2entry( Modifications *mods, Entry **e, int repl_user,
 289                                     int dup, const char **text, char *textbuf, size_t textlen )
 290 {
 291         return -1;
 292 }
 293
 294 int slap_mods_opattrs( Operation *op, Modifications *mods,
 295                                            Modifications **modtail, const char **text,
 296                                            char *textbuf, size_t textlen )
 297 {
 298         return -1;
 299 }
 300