external/bsd/openldap/dist/libraries/liblber/options.c

   1 /* $OpenLDAP: pkg/ldap/libraries/liblber/options.c,v 1.43.2.3 2008/02/11 23:26:41 kurt Exp $ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1998-2008 The OpenLDAP Foundation.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted only as authorized by the OpenLDAP
   9  * Public License.
  10  *
  11  * A copy of this license is available in the file LICENSE in the
  12  * top-level directory of the distribution or, alternatively, at
  13  * <http://www.OpenLDAP.org/license.html>.
  14  */
  15
  16 #include "portable.h"
  17
  18 #include <ac/stdlib.h>
  19 #include <ac/string.h>
  20 #include <ac/stdarg.h>
  21 #include "lber-int.h"
  22
  23 char ber_pvt_opt_on;    /* used to get a non-NULL address for *_OPT_ON */
  24
  25 struct lber_options ber_int_options = {
  26         LBER_UNINITIALIZED, 0, 0 };
  27
  28 static BerMemoryFunctions       ber_int_memory_fns_datum;
  29
  30 int
  31 ber_get_option(
  32         void    *item,
  33         int             option,
  34         void    *outvalue)
  35 {
  36         const BerElement *ber;
  37         const Sockbuf *sb;
  38
  39         if(outvalue == NULL) {
  40                 /* no place to get to */
  41                 ber_errno = LBER_ERROR_PARAM;
  42                 return LBER_OPT_ERROR;
  43         }
  44
  45         if(item == NULL) {
  46                 switch ( option ) {
  47                 case LBER_OPT_BER_DEBUG:
  48                         * (int *) outvalue = ber_int_debug;
  49                         return LBER_OPT_SUCCESS;
  50
  51                 case LBER_OPT_MEMORY_INUSE:
  52                         /* The memory inuse is a global variable on kernal implementations.
  53                          * This means that memory debug is shared by all LDAP processes
  54                          * so for this variable to have much meaning, only one LDAP process
  55                          * should be running and memory inuse should be initialized to zero
  56                          * using the lber_set_option() function during startup.
  57                          * The counter is not accurate for multithreaded ldap applications.
  58                          */
  59 #ifdef LDAP_MEMORY_DEBUG
  60                         * (int *) outvalue = ber_int_meminuse;
  61                         return LBER_OPT_SUCCESS;
  62 #else
  63                         return LBER_OPT_ERROR;
  64 #endif
  65
  66                 case LBER_OPT_LOG_PRINT_FILE:
  67                         *((FILE**)outvalue) = (FILE*)ber_pvt_err_file;
  68                         return LBER_OPT_SUCCESS;
  69                 }
  70
  71                 ber_errno = LBER_ERROR_PARAM;
  72                 return LBER_OPT_ERROR;
  73         }
  74
  75         ber = item;
  76         sb = item;
  77
  78         switch(option) {
  79         case LBER_OPT_BER_OPTIONS:
  80                 assert( LBER_VALID( ber ) );
  81                 * (int *) outvalue = ber->ber_options;
  82                 return LBER_OPT_SUCCESS;
  83
  84         case LBER_OPT_BER_DEBUG:
  85                 assert( LBER_VALID( ber ) );
  86                 * (int *) outvalue = ber->ber_debug;
  87                 return LBER_OPT_SUCCESS;
  88
  89         case LBER_OPT_BER_REMAINING_BYTES:
  90                 assert( LBER_VALID( ber ) );
  91                 *((ber_len_t *) outvalue) = ber_pvt_ber_remaining(ber);
  92                 return LBER_OPT_SUCCESS;
  93
  94         case LBER_OPT_BER_TOTAL_BYTES:
  95                 assert( LBER_VALID( ber ) );
  96                 *((ber_len_t *) outvalue) = ber_pvt_ber_total(ber);
  97                 return LBER_OPT_SUCCESS;
  98
  99         case LBER_OPT_BER_BYTES_TO_WRITE:
 100                 assert( LBER_VALID( ber ) );
 101                 *((ber_len_t *) outvalue) = ber_pvt_ber_write(ber);
 102                 return LBER_OPT_SUCCESS;
 103
 104         case LBER_OPT_BER_MEMCTX:
 105                 assert( LBER_VALID( ber ) );
 106                 *((void **) outvalue) = ber->ber_memctx;
 107                 return LBER_OPT_SUCCESS;
 108
 109         default:
 110                 /* bad param */
 111                 ber_errno = LBER_ERROR_PARAM;
 112                 break;
 113         }
 114
 115         return LBER_OPT_ERROR;
 116 }
 117
 118 int
 119 ber_set_option(
 120         void    *item,
 121         int             option,
 122         LDAP_CONST void *invalue)
 123 {
 124         BerElement *ber;
 125         Sockbuf *sb;
 126
 127         if(invalue == NULL) {
 128                 /* no place to set from */
 129                 ber_errno = LBER_ERROR_PARAM;
 130                 return LBER_OPT_ERROR;
 131         }
 132
 133         if(item == NULL) {
 134                 switch ( option ) {
 135                 case LBER_OPT_BER_DEBUG:
 136                         ber_int_debug = * (const int *) invalue;
 137                         return LBER_OPT_SUCCESS;
 138
 139                 case LBER_OPT_LOG_PRINT_FN:
 140                         ber_pvt_log_print = (BER_LOG_PRINT_FN) invalue;
 141                         return LBER_OPT_SUCCESS;
 142
 143                 case LBER_OPT_LOG_PRINT_FILE:
 144                         ber_pvt_err_file = (void *) invalue;
 145                         return LBER_OPT_SUCCESS;
 146
 147                 case LBER_OPT_MEMORY_INUSE:
 148                         /* The memory inuse is a global variable on kernal implementations.
 149                          * This means that memory debug is shared by all LDAP processes
 150                          * so for this variable to have much meaning, only one LDAP process
 151                          * should be running and memory inuse should be initialized to zero
 152                          * using the lber_set_option() function during startup.
 153                          * The counter is not accurate for multithreaded applications.
 154                          */
 155 #ifdef LDAP_MEMORY_DEBUG
 156                         ber_int_meminuse = * (int *) invalue;
 157                         return LBER_OPT_SUCCESS;
 158 #else
 159                         return LBER_OPT_ERROR;
 160 #endif
 161                 case LBER_OPT_MEMORY_FNS:
 162                         if ( ber_int_memory_fns == NULL )
 163                         {
 164                                 const BerMemoryFunctions *f =
 165                                         (const BerMemoryFunctions *) invalue;
 166                                 /* make sure all functions are provided */
 167                                 if(!( f->bmf_malloc && f->bmf_calloc
 168                                         && f->bmf_realloc && f->bmf_free ))
 169                                 {
 170                                         ber_errno = LBER_ERROR_PARAM;
 171                                         return LBER_OPT_ERROR;
 172                                 }
 173
 174                                 ber_int_memory_fns = &ber_int_memory_fns_datum;
 175
 176                                 AC_MEMCPY(ber_int_memory_fns, f,
 177                                          sizeof(BerMemoryFunctions));
 178
 179                                 return LBER_OPT_SUCCESS;
 180                         }
 181                         break;
 182
 183                 case LBER_OPT_LOG_PROC:
 184                         ber_int_log_proc = (BER_LOG_FN)invalue;
 185                         return LBER_OPT_SUCCESS;
 186                 }
 187
 188                 ber_errno = LBER_ERROR_PARAM;
 189                 return LBER_OPT_ERROR;
 190         }
 191
 192         ber = item;
 193         sb = item;
 194
 195         switch(option) {
 196         case LBER_OPT_BER_OPTIONS:
 197                 assert( LBER_VALID( ber ) );
 198                 ber->ber_options = * (const int *) invalue;
 199                 return LBER_OPT_SUCCESS;
 200
 201         case LBER_OPT_BER_DEBUG:
 202                 assert( LBER_VALID( ber ) );
 203                 ber->ber_debug = * (const int *) invalue;
 204                 return LBER_OPT_SUCCESS;
 205
 206         case LBER_OPT_BER_REMAINING_BYTES:
 207                 assert( LBER_VALID( ber ) );
 208                 ber->ber_end = &ber->ber_ptr[* (const ber_len_t *) invalue];
 209                 return LBER_OPT_SUCCESS;
 210
 211         case LBER_OPT_BER_TOTAL_BYTES:
 212                 assert( LBER_VALID( ber ) );
 213                 ber->ber_end = &ber->ber_buf[* (const ber_len_t *) invalue];
 214                 return LBER_OPT_SUCCESS;
 215
 216         case LBER_OPT_BER_BYTES_TO_WRITE:
 217                 assert( LBER_VALID( ber ) );
 218                 ber->ber_ptr = &ber->ber_buf[* (const ber_len_t *) invalue];
 219                 return LBER_OPT_SUCCESS;
 220
 221         case LBER_OPT_BER_MEMCTX:
 222                 assert( LBER_VALID( ber ) );
 223                 ber->ber_memctx = *(void **)invalue;
 224                 return LBER_OPT_SUCCESS;
 225
 226         default:
 227                 /* bad param */
 228                 ber_errno = LBER_ERROR_PARAM;
 229                 break;
 230         }
 231
 232         return LBER_OPT_ERROR;
 233 }