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

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