]> git.sur5r.net Git - openldap/blob - libraries/liblber/options.c
More contrib cleanout
[openldap] / 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 #include <ac/stdarg.h>
11 #include "lber-int.h"
12
13 /* bprint.c */
14 typedef void (*BER_LOG_FN) LDAP_P((FILE *file, char *subsys, int level, const char *fmt, va_list vl));
15 extern void * ber_pvt_err_file;
16 extern BER_LOG_FN ber_int_log_proc;
17
18 struct lber_options ber_int_options = {
19         LBER_UNINITIALIZED, 0, 0 };
20
21 int
22 ber_get_option(
23         void    *item,
24         int             option,
25         void    *outvalue)
26 {
27         LDAP_CONST BerElement *ber;
28         LDAP_CONST Sockbuf *sb;
29
30         ber_int_options.lbo_valid = LBER_INITIALIZED;
31
32         if(outvalue == NULL) {
33                 /* no place to get to */
34                 ber_errno = LBER_ERROR_PARAM;
35                 return LBER_OPT_ERROR;
36         }
37
38         if(item == NULL) {
39                 if(option == LBER_OPT_BER_DEBUG) {
40                         * (int *) outvalue = ber_int_debug;
41                         return LBER_OPT_SUCCESS;
42                 } else if(option == LBER_OPT_MEMORY_INUSE) {
43                         /* The memory inuse is a global variable on kernal implementations.
44                          * This means that memory debug is shared by all LDAP processes
45                          * so for this variable to have much meaning, only one LDAP process
46                          * should be running and memory inuse should be initialized to zero
47                          * using the lber_set_option() function during startup.
48                          * The counter is not accurate for multithreaded ldap applications.
49                          */
50 #ifdef LDAP_MEMORY_DEBUG
51                         * (int *) outvalue = ber_int_options.lbo_meminuse;
52                         return LBER_OPT_SUCCESS;
53 #else
54                         return LBER_OPT_ERROR;
55 #endif
56                 } else if(option == LBER_OPT_LOG_PRINT_FILE) {
57                         *((FILE**)outvalue) = (FILE*)ber_pvt_err_file;
58                         return LBER_OPT_SUCCESS;
59                 }
60
61                 ber_errno = LBER_ERROR_PARAM;
62                 return LBER_OPT_ERROR;
63         }
64
65         ber = item;
66         sb = item;
67
68         switch(option) {
69         case LBER_OPT_BER_OPTIONS:
70                 assert( BER_VALID( ber ) );
71                 * (int *) outvalue = ber->ber_options;
72                 return LBER_OPT_SUCCESS;
73
74         case LBER_OPT_BER_DEBUG:
75                 assert( BER_VALID( ber ) );
76                 * (int *) outvalue = ber->ber_debug;
77                 return LBER_OPT_SUCCESS;
78
79         case LBER_OPT_BER_REMAINING_BYTES:
80                 assert( BER_VALID( ber ) );
81                 *((ber_len_t *) outvalue) = ber_pvt_ber_remaining(ber);
82                 return LBER_OPT_SUCCESS;
83
84         case LBER_OPT_BER_TOTAL_BYTES:
85                 assert( BER_VALID( ber ) );
86                 *((ber_len_t *) outvalue) = ber_pvt_ber_total(ber);
87                 return LBER_OPT_SUCCESS;
88
89         case LBER_OPT_BER_BYTES_TO_WRITE:
90                 assert( BER_VALID( ber ) );
91                 *((ber_len_t *) outvalue) = ber_pvt_ber_write(ber);
92                 return LBER_OPT_SUCCESS;
93
94         default:
95                 /* bad param */
96                 ber_errno = LBER_ERROR_PARAM;
97                 break;
98         }
99
100         return LBER_OPT_ERROR;
101 }
102
103 int
104 ber_set_option(
105         void    *item,
106         int             option,
107         LDAP_CONST void *invalue)
108 {
109         BerElement *ber;
110         Sockbuf *sb;
111
112         if( (ber_int_options.lbo_valid == LBER_UNINITIALIZED)
113                 && ( ber_int_memory_fns == NULL )
114                 && ( option == LBER_OPT_MEMORY_FNS )
115                 && ( invalue != NULL ))
116         {
117                 const BerMemoryFunctions *f =
118                         (const BerMemoryFunctions *) invalue;
119
120                 /* make sure all functions are provided */
121                 if(!( f->bmf_malloc && f->bmf_calloc
122                         && f->bmf_realloc && f->bmf_free ))
123                 {
124                         ber_errno = LBER_ERROR_PARAM;
125                         return LBER_OPT_ERROR;
126                 }
127
128                 ber_int_memory_fns = (BerMemoryFunctions *)
129                         (*(f->bmf_malloc))(sizeof(BerMemoryFunctions));
130
131                 if ( ber_int_memory_fns == NULL ) {
132                         ber_errno = LBER_ERROR_MEMORY;
133                         return LBER_OPT_ERROR;
134                 }
135
136                 AC_MEMCPY(ber_int_memory_fns, f, sizeof(BerMemoryFunctions));
137
138                 ber_int_options.lbo_valid = LBER_INITIALIZED;
139                 return LBER_OPT_SUCCESS;
140         }
141
142         ber_int_options.lbo_valid = LBER_INITIALIZED;
143
144         if(invalue == NULL) {
145                 /* no place to set from */
146                 ber_errno = LBER_ERROR_PARAM;
147                 return LBER_OPT_ERROR;
148         }
149
150         if(item == NULL) {
151                 if(option == LBER_OPT_BER_DEBUG) {
152                         ber_int_debug = * (const int *) invalue;
153                         return LBER_OPT_SUCCESS;
154
155                 } else if(option == LBER_OPT_LOG_PRINT_FN) {
156                         ber_pvt_log_print = (BER_LOG_PRINT_FN) invalue;
157                         return LBER_OPT_SUCCESS;
158                 } else if(option == LBER_OPT_LOG_PRINT_FILE) {
159                         ber_pvt_err_file = (void *) invalue;
160                         return LBER_OPT_SUCCESS;
161                 } else if(option == LBER_OPT_MEMORY_INUSE) {
162                         /* The memory inuse is a global variable on kernal implementations.
163                          * This means that memory debug is shared by all LDAP processes
164                          * so for this variable to have much meaning, only one LDAP process
165                          * should be running and memory inuse should be initialized to zero
166                          * using the lber_set_option() function during startup.
167                          * The counter is not accurate for multithreaded applications.
168                          */
169 #ifdef LDAP_MEMORY_DEBUG
170                         ber_int_options.lbo_meminuse = * (int *) invalue;
171                         return LBER_OPT_SUCCESS;
172 #else
173                         return LBER_OPT_ERROR;
174 #endif
175                 } else if(option == LBER_OPT_LOG_PROC) {
176                         ber_int_log_proc = (BER_LOG_FN)invalue;
177                 }
178
179                 ber_errno = LBER_ERROR_PARAM;
180                 return LBER_OPT_ERROR;
181         }
182
183         ber = item;
184         sb = item;
185
186         switch(option) {
187         case LBER_OPT_BER_OPTIONS:
188                 assert( BER_VALID( ber ) );
189                 ber->ber_options = * (const int *) invalue;
190                 return LBER_OPT_SUCCESS;
191
192         case LBER_OPT_BER_DEBUG:
193                 assert( BER_VALID( ber ) );
194                 ber->ber_debug = * (const int *) invalue;
195                 return LBER_OPT_SUCCESS;
196
197         case LBER_OPT_BER_REMAINING_BYTES:
198                 assert( BER_VALID( ber ) );
199                 ber->ber_end = &ber->ber_ptr[* (const ber_len_t *) invalue];
200                 return LBER_OPT_SUCCESS;
201
202         case LBER_OPT_BER_TOTAL_BYTES:
203                 assert( BER_VALID( ber ) );
204                 ber->ber_end = &ber->ber_buf[* (const ber_len_t *) invalue];
205                 return LBER_OPT_SUCCESS;
206
207         case LBER_OPT_BER_BYTES_TO_WRITE:
208                 assert( BER_VALID( ber ) );
209                 ber->ber_ptr = &ber->ber_buf[* (const ber_len_t *) invalue];
210                 return LBER_OPT_SUCCESS;
211
212         default:
213                 /* bad param */
214                 ber_errno = LBER_ERROR_PARAM;
215                 break;
216         }
217
218         return LBER_OPT_ERROR;
219 }