git.sur5r.net Git - openldap/blob - libraries/liblber/options.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 #include "portable.h"
   7
   8 #include <ac/stdlib.h>
   9 #include <ac/string.h>
  10
  11 #include "lber-int.h"
  12
  13 extern void * ber_pvt_err_file; /* bprint.c */
  14
  15 struct lber_options ber_int_options = {
  16         LBER_UNINITIALIZED, 0, 0 };
  17
  18 int
  19 ber_get_option(
  20         void    *item,
  21         int             option,
  22         void    *outvalue)
  23 {
  24         LDAP_CONST BerElement *ber;
  25         LDAP_CONST Sockbuf *sb;
  26
  27         ber_int_options.lbo_valid = LBER_INITIALIZED;
  28
  29         if(outvalue == NULL) {
  30                 /* no place to get to */
  31                 ber_errno = LBER_ERROR_PARAM;
  32                 return LBER_OPT_ERROR;
  33         }
  34
  35         if(item == NULL) {
  36                 if(option == LBER_OPT_BER_DEBUG) {
  37                         * (int *) outvalue = ber_int_debug;
  38                         return LBER_OPT_SUCCESS;
  39                 }
  40
  41                 ber_errno = LBER_ERROR_PARAM;
  42                 return LBER_OPT_ERROR;
  43         }
  44
  45         ber = item;
  46         sb = item;
  47
  48         switch(option) {
  49         case LBER_OPT_BER_OPTIONS:
  50                 assert( BER_VALID( ber ) );
  51                 * (int *) outvalue = ber->ber_options;
  52                 return LBER_OPT_SUCCESS;
  53
  54         case LBER_OPT_BER_DEBUG:
  55                 assert( BER_VALID( ber ) );
  56                 * (int *) outvalue = ber->ber_debug;
  57                 return LBER_OPT_SUCCESS;
  58
  59         case LBER_OPT_BER_REMAINING_BYTES:
  60                 *((ber_len_t *) outvalue) = ber->ber_end - ber->ber_ptr;
  61                 return LBER_OPT_SUCCESS;
  62
  63         case LBER_OPT_BER_TOTAL_BYTES:
  64                 *((ber_len_t *) outvalue) = ber->ber_end - ber->ber_buf;
  65                 return LBER_OPT_SUCCESS;
  66
  67         case LBER_OPT_BER_BYTES_TO_WRITE:
  68                 *((ber_len_t *) outvalue) = ber->ber_ptr - ber->ber_buf;
  69                 return LBER_OPT_SUCCESS;
  70
  71         default:
  72                 /* bad param */
  73                 ber_errno = LBER_ERROR_PARAM;
  74                 break;
  75         }
  76
  77         return LBER_OPT_ERROR;
  78 }
  79
  80 int
  81 ber_set_option(
  82         void    *item,
  83         int             option,
  84         LDAP_CONST void *invalue)
  85 {
  86         BerElement *ber;
  87         Sockbuf *sb;
  88
  89         if( (ber_int_options.lbo_valid == LBER_UNINITIALIZED)
  90                 && ( ber_int_memory_fns == NULL )
  91                 && ( option == LBER_OPT_MEMORY_FNS )
  92                 && ( invalue != NULL ))
  93         {
  94                 const BerMemoryFunctions *f =
  95                         (const BerMemoryFunctions *) invalue;
  96
  97                 /* make sure all functions are provided */
  98                 if(!( f->bmf_malloc && f->bmf_calloc
  99                         && f->bmf_realloc && f->bmf_free ))
 100                 {
 101                         ber_errno = LBER_ERROR_PARAM;
 102                         return LBER_OPT_ERROR;
 103                 }
 104
 105                 ber_int_memory_fns = (BerMemoryFunctions *)
 106                         (*(f->bmf_malloc))(sizeof(BerMemoryFunctions));
 107
 108                 if ( ber_int_memory_fns == NULL ) {
 109                         ber_errno = LBER_ERROR_MEMORY;
 110                         return LBER_OPT_ERROR;
 111                 }
 112
 113                 memcpy(ber_int_memory_fns, f, sizeof(BerMemoryFunctions));
 114
 115                 ber_int_options.lbo_valid = LBER_INITIALIZED;
 116                 return LBER_OPT_SUCCESS;
 117         }
 118
 119         ber_int_options.lbo_valid = LBER_INITIALIZED;
 120
 121         if(invalue == NULL) {
 122                 /* no place to set from */
 123                 ber_errno = LBER_ERROR_PARAM;
 124                 return LBER_OPT_ERROR;
 125         }
 126
 127         if(item == NULL) {
 128                 if(option == LBER_OPT_BER_DEBUG) {
 129                         ber_int_debug = * (const int *) invalue;
 130                         return LBER_OPT_SUCCESS;
 131
 132                 } else if(option == LBER_OPT_LOG_PRINT_FN) {
 133                         ber_pvt_log_print = (BER_LOG_PRINT_FN) invalue;
 134                         return LBER_OPT_SUCCESS;
 135                 } else if(option == LBER_OPT_LOG_PRINT_FILE) {
 136                         ber_pvt_err_file = (void *) invalue;
 137                         return LBER_OPT_SUCCESS;
 138                 }
 139
 140                 ber_errno = LBER_ERROR_PARAM;
 141                 return LBER_OPT_ERROR;
 142         }
 143
 144         ber = item;
 145         sb = item;
 146
 147         switch(option) {
 148         case LBER_OPT_BER_OPTIONS:
 149                 assert( BER_VALID( ber ) );
 150                 ber->ber_options = * (const int *) invalue;
 151                 return LBER_OPT_SUCCESS;
 152
 153         case LBER_OPT_BER_DEBUG:
 154                 assert( BER_VALID( ber ) );
 155                 ber->ber_debug = * (const int *) invalue;
 156                 return LBER_OPT_SUCCESS;
 157
 158         case LBER_OPT_BER_REMAINING_BYTES:
 159                 ber->ber_end = &ber->ber_ptr[* (const ber_len_t *) invalue];
 160                 return LBER_OPT_SUCCESS;
 161
 162         case LBER_OPT_BER_TOTAL_BYTES:
 163                 ber->ber_end = &ber->ber_buf[* (const ber_len_t *) invalue];
 164                 return LBER_OPT_SUCCESS;
 165
 166         case LBER_OPT_BER_BYTES_TO_WRITE:
 167                 ber->ber_ptr = &ber->ber_buf[* (const ber_len_t *) invalue];
 168                 return LBER_OPT_SUCCESS;
 169
 170         default:
 171                 /* bad param */
 172                 ber_errno = LBER_ERROR_PARAM;
 173                 break;
 174         }
 175
 176         return LBER_OPT_ERROR;
 177 }