overby.me / darling-nix
this repo has no description
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

LDAP.framework stubs

Andrew Hyatt 31c7f89b 9388d7ab

+2124
+2
src/CMakeLists.txt
··· 217 217 ${CMAKE_CURRENT_SOURCE_DIR}/ConfigurationProfiles/include 218 218 ${CMAKE_CURRENT_SOURCE_DIR}/ImageIO/include 219 219 ${CMAKE_CURRENT_SOURCE_DIR}/external/SecurityTokend/include 220 + ${CMAKE_CURRENT_SOURCE_DIR}/LDAP/include 220 221 ) 221 222 222 223 add_subdirectory(external/libkqueue) ··· 396 397 add_subdirectory(AVFoundation) 397 398 add_subdirectory(CoreAudio) 398 399 add_subdirectory(CoreMedia) 400 + add_subdirectory(LDAP) 399 401 # Just a stub 400 402 add_subdirectory(WebKit) 401 403 add_subdirectory(OpenGL)
+16
src/LDAP/CMakeLists.txt
··· 1 + project(LDAP) 2 + 3 + set(DYLIB_COMPAT_VERSION "1.0.0") 4 + set(DYLIB_CURRENT_VERSION "2.4.0") 5 + 6 + add_framework(LDAP 7 + FAT 8 + CURRENT_VERSION 9 + VERSION "A" 10 + 11 + SOURCES 12 + src/LDAP.c 13 + 14 + DEPENDENCIES 15 + system 16 + )
+318
src/LDAP/include/LDAP/LDAP.h
··· 1 + /* 2 + This file is part of Darling. 3 + 4 + Copyright (C) 2019 Lubos Dolezel 5 + 6 + Darling is free software: you can redistribute it and/or modify 7 + it under the terms of the GNU General Public License as published by 8 + the Free Software Foundation, either version 3 of the License, or 9 + (at your option) any later version. 10 + 11 + Darling is distributed in the hope that it will be useful, 12 + but WITHOUT ANY WARRANTY; without even the implied warranty of 13 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 + GNU General Public License for more details. 15 + 16 + You should have received a copy of the GNU General Public License 17 + along with Darling. If not, see <http://www.gnu.org/licenses/>. 18 + */ 19 + 20 + 21 + #ifndef _LDAP_H_ 22 + #define _LDAP_H_ 23 + 24 + void* ber_alloc(void); 25 + void* ber_alloc_t(void); 26 + void* ber_bprint(void); 27 + void* ber_bvarray_add(void); 28 + void* ber_bvarray_free(void); 29 + void* ber_bvdup(void); 30 + void* ber_bvecadd(void); 31 + void* ber_bvecfree(void); 32 + void* ber_bvfree(void); 33 + void* ber_dump(void); 34 + void* ber_dup(void); 35 + void* ber_dupbv(void); 36 + void* ber_errno_addr(void); 37 + void* ber_error_print(void); 38 + void* ber_first_element(void); 39 + void* ber_flatten(void); 40 + void* ber_flatten2(void); 41 + void* ber_flush(void); 42 + void* ber_free(void); 43 + void* ber_free_buf(void); 44 + void* ber_get_bitstringa(void); 45 + void* ber_get_boolean(void); 46 + void* ber_get_enum(void); 47 + void* ber_get_int(void); 48 + void* ber_get_next(void); 49 + void* ber_get_null(void); 50 + void* ber_get_option(void); 51 + void* ber_get_stringa(void); 52 + void* ber_get_stringal(void); 53 + void* ber_get_stringb(void); 54 + void* ber_get_stringbv(void); 55 + void* ber_get_tag(void); 56 + void* ber_init(void); 57 + void* ber_init2(void); 58 + void* ber_init_w_nullc(void); 59 + void* ber_mem2bv(void); 60 + void* ber_memalloc(void); 61 + void* ber_memcalloc(void); 62 + void* ber_memfree(void); 63 + void* ber_memrealloc(void); 64 + void* ber_memvfree(void); 65 + void* ber_next_element(void); 66 + void* ber_peek_tag(void); 67 + void* ber_printf(void); 68 + void* ber_put_berval(void); 69 + void* ber_put_bitstring(void); 70 + void* ber_put_boolean(void); 71 + void* ber_put_enum(void); 72 + void* ber_put_int(void); 73 + void* ber_put_null(void); 74 + void* ber_put_ostring(void); 75 + void* ber_put_seq(void); 76 + void* ber_put_set(void); 77 + void* ber_put_string(void); 78 + void* ber_read(void); 79 + void* ber_remaining(void); 80 + void* ber_reset(void); 81 + void* ber_scanf(void); 82 + void* ber_set_option(void); 83 + void* ber_skip_tag(void); 84 + void* ber_sockbuf_add_io(void); 85 + void* ber_sockbuf_alloc(void); 86 + void* ber_sockbuf_ctrl(void); 87 + void* ber_sockbuf_free(void); 88 + void* ber_sockbuf_remove_io(void); 89 + void* ber_sos_dump(void); 90 + void* ber_start_seq(void); 91 + void* ber_start_set(void); 92 + void* ber_str2bv(void); 93 + void* ber_strdup(void); 94 + void* ber_write(void); 95 + void* der_alloc(void); 96 + void* ldap_X509dn2bv(void); 97 + void* ldap_abandon(void); 98 + void* ldap_abandon_ext(void); 99 + void* ldap_add(void); 100 + void* ldap_add_ext(void); 101 + void* ldap_add_ext_s(void); 102 + void* ldap_add_result_entry(void); 103 + void* ldap_add_s(void); 104 + void* ldap_attributetype2bv(void); 105 + void* ldap_attributetype2name(void); 106 + void* ldap_attributetype2str(void); 107 + void* ldap_attributetype_free(void); 108 + void* ldap_bind(void); 109 + void* ldap_bind_s(void); 110 + void* ldap_bv2dn(void); 111 + void* ldap_bv2rdn(void); 112 + void* ldap_cancel(void); 113 + void* ldap_cancel_s(void); 114 + void* ldap_compare(void); 115 + void* ldap_compare_ext(void); 116 + void* ldap_compare_ext_s(void); 117 + void* ldap_compare_s(void); 118 + void* ldap_contentrule2bv(void); 119 + void* ldap_contentrule2name(void); 120 + void* ldap_contentrule2str(void); 121 + void* ldap_contentrule_free(void); 122 + void* ldap_control_create(void); 123 + void* ldap_control_find(void); 124 + void* ldap_control_free(void); 125 + void* ldap_controls_free(void); 126 + void* ldap_count_entries(void); 127 + void* ldap_count_messages(void); 128 + void* ldap_count_references(void); 129 + void* ldap_count_values(void); 130 + void* ldap_count_values_len(void); 131 + void* ldap_create(void); 132 + void* ldap_create_assertion_control_value(void); 133 + void* ldap_create_control(void); 134 + void* ldap_create_page_control(void); 135 + void* ldap_create_page_control_value(void); 136 + void* ldap_create_sort_control(void); 137 + void* ldap_create_sort_keylist(void); 138 + void* ldap_create_vlv_control(void); 139 + void* ldap_dcedn2dn(void); 140 + void* ldap_delete(void); 141 + void* ldap_delete_ext(void); 142 + void* ldap_delete_ext_s(void); 143 + void* ldap_delete_result_entry(void); 144 + void* ldap_delete_s(void); 145 + void* ldap_dn2ad_canonical(void); 146 + void* ldap_dn2bv(void); 147 + void* ldap_dn2dcedn(void); 148 + void* ldap_dn2domain(void); 149 + void* ldap_dn2str(void); 150 + void* ldap_dn2ufn(void); 151 + void* ldap_dn_normalize(void); 152 + void* ldap_dnfree(void); 153 + void* ldap_domain2dn(void); 154 + void* ldap_domain2hostlist(void); 155 + void* ldap_err2string(void); 156 + void* ldap_explode_dn(void); 157 + void* ldap_explode_rdn(void); 158 + void* ldap_extended_operation(void); 159 + void* ldap_extended_operation_s(void); 160 + void* ldap_find_control(void); 161 + void* ldap_first_attribute(void); 162 + void* ldap_first_entry(void); 163 + void* ldap_first_message(void); 164 + void* ldap_first_reference(void); 165 + void* ldap_free_sort_keylist(void); 166 + void* ldap_free_urldesc(void); 167 + void* ldap_get_attribute_ber(void); 168 + void* ldap_get_dn(void); 169 + void* ldap_get_dn_ber(void); 170 + void* ldap_get_entry_controls(void); 171 + void* ldap_get_option(void); 172 + void* ldap_get_values(void); 173 + void* ldap_get_values_len(void); 174 + void* ldap_init(void); 175 + void* ldap_initialize(void); 176 + void* ldap_is_ldap_url(void); 177 + void* ldap_is_ldapi_url(void); 178 + void* ldap_is_ldaps_url(void); 179 + void* ldap_matchingrule2bv(void); 180 + void* ldap_matchingrule2name(void); 181 + void* ldap_matchingrule2str(void); 182 + void* ldap_matchingrule_free(void); 183 + void* ldap_matchingruleuse2bv(void); 184 + void* ldap_matchingruleuse2name(void); 185 + void* ldap_matchingruleuse2str(void); 186 + void* ldap_matchingruleuse_free(void); 187 + void* ldap_memalloc(void); 188 + void* ldap_memcalloc(void); 189 + void* ldap_memfree(void); 190 + void* ldap_memrealloc(void); 191 + void* ldap_memvfree(void); 192 + void* ldap_modify(void); 193 + void* ldap_modify_ext(void); 194 + void* ldap_modify_ext_s(void); 195 + void* ldap_modify_s(void); 196 + void* ldap_modrdn(void); 197 + void* ldap_modrdn2(void); 198 + void* ldap_modrdn2_s(void); 199 + void* ldap_modrdn_s(void); 200 + void* ldap_mods_free(void); 201 + void* ldap_msgdelete(void); 202 + void* ldap_msgfree(void); 203 + void* ldap_msgid(void); 204 + void* ldap_msgtype(void); 205 + void* ldap_nameform2bv(void); 206 + void* ldap_nameform2name(void); 207 + void* ldap_nameform2str(void); 208 + void* ldap_nameform_free(void); 209 + void* ldap_next_attribute(void); 210 + void* ldap_next_entry(void); 211 + void* ldap_next_message(void); 212 + void* ldap_next_reference(void); 213 + void* ldap_objectclass2bv(void); 214 + void* ldap_objectclass2name(void); 215 + void* ldap_objectclass2str(void); 216 + void* ldap_objectclass_free(void); 217 + void* ldap_open(void); 218 + void* ldap_parse_extended_result(void); 219 + void* ldap_parse_intermediate(void); 220 + void* ldap_parse_page_control(void); 221 + void* ldap_parse_pageresponse_control(void); 222 + void* ldap_parse_passwd(void); 223 + void* ldap_parse_reference(void); 224 + void* ldap_parse_result(void); 225 + void* ldap_parse_sasl_bind_result(void); 226 + void* ldap_parse_sort_control(void); 227 + void* ldap_parse_sortresponse_control(void); 228 + void* ldap_parse_vlv_control(void); 229 + void* ldap_parse_vlvresponse_control(void); 230 + void* ldap_parse_whoami(void); 231 + void* ldap_passwd(void); 232 + void* ldap_passwd_s(void); 233 + void* ldap_perror(void); 234 + void* ldap_put_vrFilter(void); 235 + void* ldap_rdn2bv(void); 236 + void* ldap_rdn2str(void); 237 + void* ldap_rdnfree(void); 238 + void* ldap_rename(void); 239 + void* ldap_rename2(void); 240 + void* ldap_rename2_s(void); 241 + void* ldap_rename_s(void); 242 + void* ldap_result(void); 243 + void* ldap_result2error(void); 244 + void* ldap_sasl_bind(void); 245 + void* ldap_sasl_bind_s(void); 246 + void* ldap_sasl_interactive_bind_s(void); 247 + void* ldap_scherr2str(void); 248 + void* ldap_search(void); 249 + void* ldap_search_ext(void); 250 + void* ldap_search_ext_s(void); 251 + void* ldap_search_s(void); 252 + void* ldap_search_st(void); 253 + void* ldap_set_option(void); 254 + void* ldap_set_rebind_proc(void); 255 + void* ldap_set_search_results_callback(void); 256 + void* ldap_simple_bind(void); 257 + void* ldap_simple_bind_s(void); 258 + void* ldap_sort_entries(void); 259 + void* ldap_sort_strcasecmp(void); 260 + void* ldap_sort_values(void); 261 + void* ldap_start_tls_s(void); 262 + void* ldap_str2attributetype(void); 263 + void* ldap_str2contentrule(void); 264 + void* ldap_str2dn(void); 265 + void* ldap_str2matchingrule(void); 266 + void* ldap_str2matchingruleuse(void); 267 + void* ldap_str2nameform(void); 268 + void* ldap_str2objectclass(void); 269 + void* ldap_str2rdn(void); 270 + void* ldap_str2structurerule(void); 271 + void* ldap_str2syntax(void); 272 + void* ldap_strdup(void); 273 + void* ldap_structurerule2bv(void); 274 + void* ldap_structurerule2name(void); 275 + void* ldap_structurerule2str(void); 276 + void* ldap_structurerule_free(void); 277 + void* ldap_syntax2bv(void); 278 + void* ldap_syntax2name(void); 279 + void* ldap_syntax2str(void); 280 + void* ldap_syntax_free(void); 281 + void* ldap_unbind(void); 282 + void* ldap_unbind_ext(void); 283 + void* ldap_unbind_ext_s(void); 284 + void* ldap_unbind_s(void); 285 + void* ldap_url_desc2str(void); 286 + void* ldap_url_parse(void); 287 + void* ldap_value_free(void); 288 + void* ldap_value_free_len(void); 289 + void* ldap_whoami(void); 290 + void* ldap_whoami_s(void); 291 + void* ldap_x_mb_to_utf8(void); 292 + void* ldap_x_mbs_to_utf8s(void); 293 + void* ldap_x_ucs4_to_utf8(void); 294 + void* ldap_x_utf8_to_mb(void); 295 + void* ldap_x_utf8_to_ucs4(void); 296 + void* ldap_x_utf8_to_wc(void); 297 + void* ldap_x_utf8s_to_mbs(void); 298 + void* ldap_x_utf8s_to_wcs(void); 299 + void* ldap_x_wc_to_utf8(void); 300 + void* ldap_x_wcs_to_utf8s(void); 301 + void* ldif_close(void); 302 + void* ldif_countlines(void); 303 + void* ldif_fetch_url(void); 304 + void* ldif_getline(void); 305 + void* ldif_is_not_printable(void); 306 + void* ldif_must_b64_encode_register(void); 307 + void* ldif_must_b64_encode_release(void); 308 + void* ldif_open(void); 309 + void* ldif_open_url(void); 310 + void* ldif_parse_line(void); 311 + void* ldif_parse_line2(void); 312 + void* ldif_put(void); 313 + void* ldif_put_wrap(void); 314 + void* ldif_read_record(void); 315 + void* ldif_sput(void); 316 + void* ldif_sput_wrap(void); 317 + 318 + #endif
+1788
src/LDAP/src/LDAP.c
··· 1 + /* 2 + This file is part of Darling. 3 + 4 + Copyright (C) 2019 Lubos Dolezel 5 + 6 + Darling is free software: you can redistribute it and/or modify 7 + it under the terms of the GNU General Public License as published by 8 + the Free Software Foundation, either version 3 of the License, or 9 + (at your option) any later version. 10 + 11 + Darling is distributed in the hope that it will be useful, 12 + but WITHOUT ANY WARRANTY; without even the implied warranty of 13 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 + GNU General Public License for more details. 15 + 16 + You should have received a copy of the GNU General Public License 17 + along with Darling. If not, see <http://www.gnu.org/licenses/>. 18 + */ 19 + 20 + 21 + #include <LDAP/LDAP.h> 22 + #include <stdlib.h> 23 + #include <stdio.h> 24 + 25 + static int verbose = 0; 26 + 27 + __attribute__((constructor)) 28 + static void initme(void) { 29 + verbose = getenv("STUB_VERBOSE") != NULL; 30 + } 31 + 32 + void* ber_alloc(void) 33 + { 34 + if (verbose) puts("STUB: ber_alloc called"); 35 + return NULL; 36 + } 37 + 38 + void* ber_alloc_t(void) 39 + { 40 + if (verbose) puts("STUB: ber_alloc_t called"); 41 + return NULL; 42 + } 43 + 44 + void* ber_bprint(void) 45 + { 46 + if (verbose) puts("STUB: ber_bprint called"); 47 + return NULL; 48 + } 49 + 50 + void* ber_bvarray_add(void) 51 + { 52 + if (verbose) puts("STUB: ber_bvarray_add called"); 53 + return NULL; 54 + } 55 + 56 + void* ber_bvarray_free(void) 57 + { 58 + if (verbose) puts("STUB: ber_bvarray_free called"); 59 + return NULL; 60 + } 61 + 62 + void* ber_bvdup(void) 63 + { 64 + if (verbose) puts("STUB: ber_bvdup called"); 65 + return NULL; 66 + } 67 + 68 + void* ber_bvecadd(void) 69 + { 70 + if (verbose) puts("STUB: ber_bvecadd called"); 71 + return NULL; 72 + } 73 + 74 + void* ber_bvecfree(void) 75 + { 76 + if (verbose) puts("STUB: ber_bvecfree called"); 77 + return NULL; 78 + } 79 + 80 + void* ber_bvfree(void) 81 + { 82 + if (verbose) puts("STUB: ber_bvfree called"); 83 + return NULL; 84 + } 85 + 86 + void* ber_dump(void) 87 + { 88 + if (verbose) puts("STUB: ber_dump called"); 89 + return NULL; 90 + } 91 + 92 + void* ber_dup(void) 93 + { 94 + if (verbose) puts("STUB: ber_dup called"); 95 + return NULL; 96 + } 97 + 98 + void* ber_dupbv(void) 99 + { 100 + if (verbose) puts("STUB: ber_dupbv called"); 101 + return NULL; 102 + } 103 + 104 + void* ber_errno_addr(void) 105 + { 106 + if (verbose) puts("STUB: ber_errno_addr called"); 107 + return NULL; 108 + } 109 + 110 + void* ber_error_print(void) 111 + { 112 + if (verbose) puts("STUB: ber_error_print called"); 113 + return NULL; 114 + } 115 + 116 + void* ber_first_element(void) 117 + { 118 + if (verbose) puts("STUB: ber_first_element called"); 119 + return NULL; 120 + } 121 + 122 + void* ber_flatten(void) 123 + { 124 + if (verbose) puts("STUB: ber_flatten called"); 125 + return NULL; 126 + } 127 + 128 + void* ber_flatten2(void) 129 + { 130 + if (verbose) puts("STUB: ber_flatten2 called"); 131 + return NULL; 132 + } 133 + 134 + void* ber_flush(void) 135 + { 136 + if (verbose) puts("STUB: ber_flush called"); 137 + return NULL; 138 + } 139 + 140 + void* ber_free(void) 141 + { 142 + if (verbose) puts("STUB: ber_free called"); 143 + return NULL; 144 + } 145 + 146 + void* ber_free_buf(void) 147 + { 148 + if (verbose) puts("STUB: ber_free_buf called"); 149 + return NULL; 150 + } 151 + 152 + void* ber_get_bitstringa(void) 153 + { 154 + if (verbose) puts("STUB: ber_get_bitstringa called"); 155 + return NULL; 156 + } 157 + 158 + void* ber_get_boolean(void) 159 + { 160 + if (verbose) puts("STUB: ber_get_boolean called"); 161 + return NULL; 162 + } 163 + 164 + void* ber_get_enum(void) 165 + { 166 + if (verbose) puts("STUB: ber_get_enum called"); 167 + return NULL; 168 + } 169 + 170 + void* ber_get_int(void) 171 + { 172 + if (verbose) puts("STUB: ber_get_int called"); 173 + return NULL; 174 + } 175 + 176 + void* ber_get_next(void) 177 + { 178 + if (verbose) puts("STUB: ber_get_next called"); 179 + return NULL; 180 + } 181 + 182 + void* ber_get_null(void) 183 + { 184 + if (verbose) puts("STUB: ber_get_null called"); 185 + return NULL; 186 + } 187 + 188 + void* ber_get_option(void) 189 + { 190 + if (verbose) puts("STUB: ber_get_option called"); 191 + return NULL; 192 + } 193 + 194 + void* ber_get_stringa(void) 195 + { 196 + if (verbose) puts("STUB: ber_get_stringa called"); 197 + return NULL; 198 + } 199 + 200 + void* ber_get_stringal(void) 201 + { 202 + if (verbose) puts("STUB: ber_get_stringal called"); 203 + return NULL; 204 + } 205 + 206 + void* ber_get_stringb(void) 207 + { 208 + if (verbose) puts("STUB: ber_get_stringb called"); 209 + return NULL; 210 + } 211 + 212 + void* ber_get_stringbv(void) 213 + { 214 + if (verbose) puts("STUB: ber_get_stringbv called"); 215 + return NULL; 216 + } 217 + 218 + void* ber_get_tag(void) 219 + { 220 + if (verbose) puts("STUB: ber_get_tag called"); 221 + return NULL; 222 + } 223 + 224 + void* ber_init(void) 225 + { 226 + if (verbose) puts("STUB: ber_init called"); 227 + return NULL; 228 + } 229 + 230 + void* ber_init2(void) 231 + { 232 + if (verbose) puts("STUB: ber_init2 called"); 233 + return NULL; 234 + } 235 + 236 + void* ber_init_w_nullc(void) 237 + { 238 + if (verbose) puts("STUB: ber_init_w_nullc called"); 239 + return NULL; 240 + } 241 + 242 + void* ber_mem2bv(void) 243 + { 244 + if (verbose) puts("STUB: ber_mem2bv called"); 245 + return NULL; 246 + } 247 + 248 + void* ber_memalloc(void) 249 + { 250 + if (verbose) puts("STUB: ber_memalloc called"); 251 + return NULL; 252 + } 253 + 254 + void* ber_memcalloc(void) 255 + { 256 + if (verbose) puts("STUB: ber_memcalloc called"); 257 + return NULL; 258 + } 259 + 260 + void* ber_memfree(void) 261 + { 262 + if (verbose) puts("STUB: ber_memfree called"); 263 + return NULL; 264 + } 265 + 266 + void* ber_memrealloc(void) 267 + { 268 + if (verbose) puts("STUB: ber_memrealloc called"); 269 + return NULL; 270 + } 271 + 272 + void* ber_memvfree(void) 273 + { 274 + if (verbose) puts("STUB: ber_memvfree called"); 275 + return NULL; 276 + } 277 + 278 + void* ber_next_element(void) 279 + { 280 + if (verbose) puts("STUB: ber_next_element called"); 281 + return NULL; 282 + } 283 + 284 + void* ber_peek_tag(void) 285 + { 286 + if (verbose) puts("STUB: ber_peek_tag called"); 287 + return NULL; 288 + } 289 + 290 + void* ber_printf(void) 291 + { 292 + if (verbose) puts("STUB: ber_printf called"); 293 + return NULL; 294 + } 295 + 296 + void* ber_put_berval(void) 297 + { 298 + if (verbose) puts("STUB: ber_put_berval called"); 299 + return NULL; 300 + } 301 + 302 + void* ber_put_bitstring(void) 303 + { 304 + if (verbose) puts("STUB: ber_put_bitstring called"); 305 + return NULL; 306 + } 307 + 308 + void* ber_put_boolean(void) 309 + { 310 + if (verbose) puts("STUB: ber_put_boolean called"); 311 + return NULL; 312 + } 313 + 314 + void* ber_put_enum(void) 315 + { 316 + if (verbose) puts("STUB: ber_put_enum called"); 317 + return NULL; 318 + } 319 + 320 + void* ber_put_int(void) 321 + { 322 + if (verbose) puts("STUB: ber_put_int called"); 323 + return NULL; 324 + } 325 + 326 + void* ber_put_null(void) 327 + { 328 + if (verbose) puts("STUB: ber_put_null called"); 329 + return NULL; 330 + } 331 + 332 + void* ber_put_ostring(void) 333 + { 334 + if (verbose) puts("STUB: ber_put_ostring called"); 335 + return NULL; 336 + } 337 + 338 + void* ber_put_seq(void) 339 + { 340 + if (verbose) puts("STUB: ber_put_seq called"); 341 + return NULL; 342 + } 343 + 344 + void* ber_put_set(void) 345 + { 346 + if (verbose) puts("STUB: ber_put_set called"); 347 + return NULL; 348 + } 349 + 350 + void* ber_put_string(void) 351 + { 352 + if (verbose) puts("STUB: ber_put_string called"); 353 + return NULL; 354 + } 355 + 356 + void* ber_read(void) 357 + { 358 + if (verbose) puts("STUB: ber_read called"); 359 + return NULL; 360 + } 361 + 362 + void* ber_remaining(void) 363 + { 364 + if (verbose) puts("STUB: ber_remaining called"); 365 + return NULL; 366 + } 367 + 368 + void* ber_reset(void) 369 + { 370 + if (verbose) puts("STUB: ber_reset called"); 371 + return NULL; 372 + } 373 + 374 + void* ber_scanf(void) 375 + { 376 + if (verbose) puts("STUB: ber_scanf called"); 377 + return NULL; 378 + } 379 + 380 + void* ber_set_option(void) 381 + { 382 + if (verbose) puts("STUB: ber_set_option called"); 383 + return NULL; 384 + } 385 + 386 + void* ber_skip_tag(void) 387 + { 388 + if (verbose) puts("STUB: ber_skip_tag called"); 389 + return NULL; 390 + } 391 + 392 + void* ber_sockbuf_add_io(void) 393 + { 394 + if (verbose) puts("STUB: ber_sockbuf_add_io called"); 395 + return NULL; 396 + } 397 + 398 + void* ber_sockbuf_alloc(void) 399 + { 400 + if (verbose) puts("STUB: ber_sockbuf_alloc called"); 401 + return NULL; 402 + } 403 + 404 + void* ber_sockbuf_ctrl(void) 405 + { 406 + if (verbose) puts("STUB: ber_sockbuf_ctrl called"); 407 + return NULL; 408 + } 409 + 410 + void* ber_sockbuf_free(void) 411 + { 412 + if (verbose) puts("STUB: ber_sockbuf_free called"); 413 + return NULL; 414 + } 415 + 416 + void* ber_sockbuf_remove_io(void) 417 + { 418 + if (verbose) puts("STUB: ber_sockbuf_remove_io called"); 419 + return NULL; 420 + } 421 + 422 + void* ber_sos_dump(void) 423 + { 424 + if (verbose) puts("STUB: ber_sos_dump called"); 425 + return NULL; 426 + } 427 + 428 + void* ber_start_seq(void) 429 + { 430 + if (verbose) puts("STUB: ber_start_seq called"); 431 + return NULL; 432 + } 433 + 434 + void* ber_start_set(void) 435 + { 436 + if (verbose) puts("STUB: ber_start_set called"); 437 + return NULL; 438 + } 439 + 440 + void* ber_str2bv(void) 441 + { 442 + if (verbose) puts("STUB: ber_str2bv called"); 443 + return NULL; 444 + } 445 + 446 + void* ber_strdup(void) 447 + { 448 + if (verbose) puts("STUB: ber_strdup called"); 449 + return NULL; 450 + } 451 + 452 + void* ber_write(void) 453 + { 454 + if (verbose) puts("STUB: ber_write called"); 455 + return NULL; 456 + } 457 + 458 + void* der_alloc(void) 459 + { 460 + if (verbose) puts("STUB: der_alloc called"); 461 + return NULL; 462 + } 463 + 464 + void* ldap_X509dn2bv(void) 465 + { 466 + if (verbose) puts("STUB: ldap_X509dn2bv called"); 467 + return NULL; 468 + } 469 + 470 + void* ldap_abandon(void) 471 + { 472 + if (verbose) puts("STUB: ldap_abandon called"); 473 + return NULL; 474 + } 475 + 476 + void* ldap_abandon_ext(void) 477 + { 478 + if (verbose) puts("STUB: ldap_abandon_ext called"); 479 + return NULL; 480 + } 481 + 482 + void* ldap_add(void) 483 + { 484 + if (verbose) puts("STUB: ldap_add called"); 485 + return NULL; 486 + } 487 + 488 + void* ldap_add_ext(void) 489 + { 490 + if (verbose) puts("STUB: ldap_add_ext called"); 491 + return NULL; 492 + } 493 + 494 + void* ldap_add_ext_s(void) 495 + { 496 + if (verbose) puts("STUB: ldap_add_ext_s called"); 497 + return NULL; 498 + } 499 + 500 + void* ldap_add_result_entry(void) 501 + { 502 + if (verbose) puts("STUB: ldap_add_result_entry called"); 503 + return NULL; 504 + } 505 + 506 + void* ldap_add_s(void) 507 + { 508 + if (verbose) puts("STUB: ldap_add_s called"); 509 + return NULL; 510 + } 511 + 512 + void* ldap_attributetype2bv(void) 513 + { 514 + if (verbose) puts("STUB: ldap_attributetype2bv called"); 515 + return NULL; 516 + } 517 + 518 + void* ldap_attributetype2name(void) 519 + { 520 + if (verbose) puts("STUB: ldap_attributetype2name called"); 521 + return NULL; 522 + } 523 + 524 + void* ldap_attributetype2str(void) 525 + { 526 + if (verbose) puts("STUB: ldap_attributetype2str called"); 527 + return NULL; 528 + } 529 + 530 + void* ldap_attributetype_free(void) 531 + { 532 + if (verbose) puts("STUB: ldap_attributetype_free called"); 533 + return NULL; 534 + } 535 + 536 + void* ldap_bind(void) 537 + { 538 + if (verbose) puts("STUB: ldap_bind called"); 539 + return NULL; 540 + } 541 + 542 + void* ldap_bind_s(void) 543 + { 544 + if (verbose) puts("STUB: ldap_bind_s called"); 545 + return NULL; 546 + } 547 + 548 + void* ldap_bv2dn(void) 549 + { 550 + if (verbose) puts("STUB: ldap_bv2dn called"); 551 + return NULL; 552 + } 553 + 554 + void* ldap_bv2rdn(void) 555 + { 556 + if (verbose) puts("STUB: ldap_bv2rdn called"); 557 + return NULL; 558 + } 559 + 560 + void* ldap_cancel(void) 561 + { 562 + if (verbose) puts("STUB: ldap_cancel called"); 563 + return NULL; 564 + } 565 + 566 + void* ldap_cancel_s(void) 567 + { 568 + if (verbose) puts("STUB: ldap_cancel_s called"); 569 + return NULL; 570 + } 571 + 572 + void* ldap_compare(void) 573 + { 574 + if (verbose) puts("STUB: ldap_compare called"); 575 + return NULL; 576 + } 577 + 578 + void* ldap_compare_ext(void) 579 + { 580 + if (verbose) puts("STUB: ldap_compare_ext called"); 581 + return NULL; 582 + } 583 + 584 + void* ldap_compare_ext_s(void) 585 + { 586 + if (verbose) puts("STUB: ldap_compare_ext_s called"); 587 + return NULL; 588 + } 589 + 590 + void* ldap_compare_s(void) 591 + { 592 + if (verbose) puts("STUB: ldap_compare_s called"); 593 + return NULL; 594 + } 595 + 596 + void* ldap_contentrule2bv(void) 597 + { 598 + if (verbose) puts("STUB: ldap_contentrule2bv called"); 599 + return NULL; 600 + } 601 + 602 + void* ldap_contentrule2name(void) 603 + { 604 + if (verbose) puts("STUB: ldap_contentrule2name called"); 605 + return NULL; 606 + } 607 + 608 + void* ldap_contentrule2str(void) 609 + { 610 + if (verbose) puts("STUB: ldap_contentrule2str called"); 611 + return NULL; 612 + } 613 + 614 + void* ldap_contentrule_free(void) 615 + { 616 + if (verbose) puts("STUB: ldap_contentrule_free called"); 617 + return NULL; 618 + } 619 + 620 + void* ldap_control_create(void) 621 + { 622 + if (verbose) puts("STUB: ldap_control_create called"); 623 + return NULL; 624 + } 625 + 626 + void* ldap_control_find(void) 627 + { 628 + if (verbose) puts("STUB: ldap_control_find called"); 629 + return NULL; 630 + } 631 + 632 + void* ldap_control_free(void) 633 + { 634 + if (verbose) puts("STUB: ldap_control_free called"); 635 + return NULL; 636 + } 637 + 638 + void* ldap_controls_free(void) 639 + { 640 + if (verbose) puts("STUB: ldap_controls_free called"); 641 + return NULL; 642 + } 643 + 644 + void* ldap_count_entries(void) 645 + { 646 + if (verbose) puts("STUB: ldap_count_entries called"); 647 + return NULL; 648 + } 649 + 650 + void* ldap_count_messages(void) 651 + { 652 + if (verbose) puts("STUB: ldap_count_messages called"); 653 + return NULL; 654 + } 655 + 656 + void* ldap_count_references(void) 657 + { 658 + if (verbose) puts("STUB: ldap_count_references called"); 659 + return NULL; 660 + } 661 + 662 + void* ldap_count_values(void) 663 + { 664 + if (verbose) puts("STUB: ldap_count_values called"); 665 + return NULL; 666 + } 667 + 668 + void* ldap_count_values_len(void) 669 + { 670 + if (verbose) puts("STUB: ldap_count_values_len called"); 671 + return NULL; 672 + } 673 + 674 + void* ldap_create(void) 675 + { 676 + if (verbose) puts("STUB: ldap_create called"); 677 + return NULL; 678 + } 679 + 680 + void* ldap_create_assertion_control_value(void) 681 + { 682 + if (verbose) puts("STUB: ldap_create_assertion_control_value called"); 683 + return NULL; 684 + } 685 + 686 + void* ldap_create_control(void) 687 + { 688 + if (verbose) puts("STUB: ldap_create_control called"); 689 + return NULL; 690 + } 691 + 692 + void* ldap_create_page_control(void) 693 + { 694 + if (verbose) puts("STUB: ldap_create_page_control called"); 695 + return NULL; 696 + } 697 + 698 + void* ldap_create_page_control_value(void) 699 + { 700 + if (verbose) puts("STUB: ldap_create_page_control_value called"); 701 + return NULL; 702 + } 703 + 704 + void* ldap_create_sort_control(void) 705 + { 706 + if (verbose) puts("STUB: ldap_create_sort_control called"); 707 + return NULL; 708 + } 709 + 710 + void* ldap_create_sort_keylist(void) 711 + { 712 + if (verbose) puts("STUB: ldap_create_sort_keylist called"); 713 + return NULL; 714 + } 715 + 716 + void* ldap_create_vlv_control(void) 717 + { 718 + if (verbose) puts("STUB: ldap_create_vlv_control called"); 719 + return NULL; 720 + } 721 + 722 + void* ldap_dcedn2dn(void) 723 + { 724 + if (verbose) puts("STUB: ldap_dcedn2dn called"); 725 + return NULL; 726 + } 727 + 728 + void* ldap_delete(void) 729 + { 730 + if (verbose) puts("STUB: ldap_delete called"); 731 + return NULL; 732 + } 733 + 734 + void* ldap_delete_ext(void) 735 + { 736 + if (verbose) puts("STUB: ldap_delete_ext called"); 737 + return NULL; 738 + } 739 + 740 + void* ldap_delete_ext_s(void) 741 + { 742 + if (verbose) puts("STUB: ldap_delete_ext_s called"); 743 + return NULL; 744 + } 745 + 746 + void* ldap_delete_result_entry(void) 747 + { 748 + if (verbose) puts("STUB: ldap_delete_result_entry called"); 749 + return NULL; 750 + } 751 + 752 + void* ldap_delete_s(void) 753 + { 754 + if (verbose) puts("STUB: ldap_delete_s called"); 755 + return NULL; 756 + } 757 + 758 + void* ldap_dn2ad_canonical(void) 759 + { 760 + if (verbose) puts("STUB: ldap_dn2ad_canonical called"); 761 + return NULL; 762 + } 763 + 764 + void* ldap_dn2bv(void) 765 + { 766 + if (verbose) puts("STUB: ldap_dn2bv called"); 767 + return NULL; 768 + } 769 + 770 + void* ldap_dn2dcedn(void) 771 + { 772 + if (verbose) puts("STUB: ldap_dn2dcedn called"); 773 + return NULL; 774 + } 775 + 776 + void* ldap_dn2domain(void) 777 + { 778 + if (verbose) puts("STUB: ldap_dn2domain called"); 779 + return NULL; 780 + } 781 + 782 + void* ldap_dn2str(void) 783 + { 784 + if (verbose) puts("STUB: ldap_dn2str called"); 785 + return NULL; 786 + } 787 + 788 + void* ldap_dn2ufn(void) 789 + { 790 + if (verbose) puts("STUB: ldap_dn2ufn called"); 791 + return NULL; 792 + } 793 + 794 + void* ldap_dn_normalize(void) 795 + { 796 + if (verbose) puts("STUB: ldap_dn_normalize called"); 797 + return NULL; 798 + } 799 + 800 + void* ldap_dnfree(void) 801 + { 802 + if (verbose) puts("STUB: ldap_dnfree called"); 803 + return NULL; 804 + } 805 + 806 + void* ldap_domain2dn(void) 807 + { 808 + if (verbose) puts("STUB: ldap_domain2dn called"); 809 + return NULL; 810 + } 811 + 812 + void* ldap_domain2hostlist(void) 813 + { 814 + if (verbose) puts("STUB: ldap_domain2hostlist called"); 815 + return NULL; 816 + } 817 + 818 + void* ldap_err2string(void) 819 + { 820 + if (verbose) puts("STUB: ldap_err2string called"); 821 + return NULL; 822 + } 823 + 824 + void* ldap_explode_dn(void) 825 + { 826 + if (verbose) puts("STUB: ldap_explode_dn called"); 827 + return NULL; 828 + } 829 + 830 + void* ldap_explode_rdn(void) 831 + { 832 + if (verbose) puts("STUB: ldap_explode_rdn called"); 833 + return NULL; 834 + } 835 + 836 + void* ldap_extended_operation(void) 837 + { 838 + if (verbose) puts("STUB: ldap_extended_operation called"); 839 + return NULL; 840 + } 841 + 842 + void* ldap_extended_operation_s(void) 843 + { 844 + if (verbose) puts("STUB: ldap_extended_operation_s called"); 845 + return NULL; 846 + } 847 + 848 + void* ldap_find_control(void) 849 + { 850 + if (verbose) puts("STUB: ldap_find_control called"); 851 + return NULL; 852 + } 853 + 854 + void* ldap_first_attribute(void) 855 + { 856 + if (verbose) puts("STUB: ldap_first_attribute called"); 857 + return NULL; 858 + } 859 + 860 + void* ldap_first_entry(void) 861 + { 862 + if (verbose) puts("STUB: ldap_first_entry called"); 863 + return NULL; 864 + } 865 + 866 + void* ldap_first_message(void) 867 + { 868 + if (verbose) puts("STUB: ldap_first_message called"); 869 + return NULL; 870 + } 871 + 872 + void* ldap_first_reference(void) 873 + { 874 + if (verbose) puts("STUB: ldap_first_reference called"); 875 + return NULL; 876 + } 877 + 878 + void* ldap_free_sort_keylist(void) 879 + { 880 + if (verbose) puts("STUB: ldap_free_sort_keylist called"); 881 + return NULL; 882 + } 883 + 884 + void* ldap_free_urldesc(void) 885 + { 886 + if (verbose) puts("STUB: ldap_free_urldesc called"); 887 + return NULL; 888 + } 889 + 890 + void* ldap_get_attribute_ber(void) 891 + { 892 + if (verbose) puts("STUB: ldap_get_attribute_ber called"); 893 + return NULL; 894 + } 895 + 896 + void* ldap_get_dn(void) 897 + { 898 + if (verbose) puts("STUB: ldap_get_dn called"); 899 + return NULL; 900 + } 901 + 902 + void* ldap_get_dn_ber(void) 903 + { 904 + if (verbose) puts("STUB: ldap_get_dn_ber called"); 905 + return NULL; 906 + } 907 + 908 + void* ldap_get_entry_controls(void) 909 + { 910 + if (verbose) puts("STUB: ldap_get_entry_controls called"); 911 + return NULL; 912 + } 913 + 914 + void* ldap_get_option(void) 915 + { 916 + if (verbose) puts("STUB: ldap_get_option called"); 917 + return NULL; 918 + } 919 + 920 + void* ldap_get_values(void) 921 + { 922 + if (verbose) puts("STUB: ldap_get_values called"); 923 + return NULL; 924 + } 925 + 926 + void* ldap_get_values_len(void) 927 + { 928 + if (verbose) puts("STUB: ldap_get_values_len called"); 929 + return NULL; 930 + } 931 + 932 + void* ldap_init(void) 933 + { 934 + if (verbose) puts("STUB: ldap_init called"); 935 + return NULL; 936 + } 937 + 938 + void* ldap_initialize(void) 939 + { 940 + if (verbose) puts("STUB: ldap_initialize called"); 941 + return NULL; 942 + } 943 + 944 + void* ldap_is_ldap_url(void) 945 + { 946 + if (verbose) puts("STUB: ldap_is_ldap_url called"); 947 + return NULL; 948 + } 949 + 950 + void* ldap_is_ldapi_url(void) 951 + { 952 + if (verbose) puts("STUB: ldap_is_ldapi_url called"); 953 + return NULL; 954 + } 955 + 956 + void* ldap_is_ldaps_url(void) 957 + { 958 + if (verbose) puts("STUB: ldap_is_ldaps_url called"); 959 + return NULL; 960 + } 961 + 962 + void* ldap_matchingrule2bv(void) 963 + { 964 + if (verbose) puts("STUB: ldap_matchingrule2bv called"); 965 + return NULL; 966 + } 967 + 968 + void* ldap_matchingrule2name(void) 969 + { 970 + if (verbose) puts("STUB: ldap_matchingrule2name called"); 971 + return NULL; 972 + } 973 + 974 + void* ldap_matchingrule2str(void) 975 + { 976 + if (verbose) puts("STUB: ldap_matchingrule2str called"); 977 + return NULL; 978 + } 979 + 980 + void* ldap_matchingrule_free(void) 981 + { 982 + if (verbose) puts("STUB: ldap_matchingrule_free called"); 983 + return NULL; 984 + } 985 + 986 + void* ldap_matchingruleuse2bv(void) 987 + { 988 + if (verbose) puts("STUB: ldap_matchingruleuse2bv called"); 989 + return NULL; 990 + } 991 + 992 + void* ldap_matchingruleuse2name(void) 993 + { 994 + if (verbose) puts("STUB: ldap_matchingruleuse2name called"); 995 + return NULL; 996 + } 997 + 998 + void* ldap_matchingruleuse2str(void) 999 + { 1000 + if (verbose) puts("STUB: ldap_matchingruleuse2str called"); 1001 + return NULL; 1002 + } 1003 + 1004 + void* ldap_matchingruleuse_free(void) 1005 + { 1006 + if (verbose) puts("STUB: ldap_matchingruleuse_free called"); 1007 + return NULL; 1008 + } 1009 + 1010 + void* ldap_memalloc(void) 1011 + { 1012 + if (verbose) puts("STUB: ldap_memalloc called"); 1013 + return NULL; 1014 + } 1015 + 1016 + void* ldap_memcalloc(void) 1017 + { 1018 + if (verbose) puts("STUB: ldap_memcalloc called"); 1019 + return NULL; 1020 + } 1021 + 1022 + void* ldap_memfree(void) 1023 + { 1024 + if (verbose) puts("STUB: ldap_memfree called"); 1025 + return NULL; 1026 + } 1027 + 1028 + void* ldap_memrealloc(void) 1029 + { 1030 + if (verbose) puts("STUB: ldap_memrealloc called"); 1031 + return NULL; 1032 + } 1033 + 1034 + void* ldap_memvfree(void) 1035 + { 1036 + if (verbose) puts("STUB: ldap_memvfree called"); 1037 + return NULL; 1038 + } 1039 + 1040 + void* ldap_modify(void) 1041 + { 1042 + if (verbose) puts("STUB: ldap_modify called"); 1043 + return NULL; 1044 + } 1045 + 1046 + void* ldap_modify_ext(void) 1047 + { 1048 + if (verbose) puts("STUB: ldap_modify_ext called"); 1049 + return NULL; 1050 + } 1051 + 1052 + void* ldap_modify_ext_s(void) 1053 + { 1054 + if (verbose) puts("STUB: ldap_modify_ext_s called"); 1055 + return NULL; 1056 + } 1057 + 1058 + void* ldap_modify_s(void) 1059 + { 1060 + if (verbose) puts("STUB: ldap_modify_s called"); 1061 + return NULL; 1062 + } 1063 + 1064 + void* ldap_modrdn(void) 1065 + { 1066 + if (verbose) puts("STUB: ldap_modrdn called"); 1067 + return NULL; 1068 + } 1069 + 1070 + void* ldap_modrdn2(void) 1071 + { 1072 + if (verbose) puts("STUB: ldap_modrdn2 called"); 1073 + return NULL; 1074 + } 1075 + 1076 + void* ldap_modrdn2_s(void) 1077 + { 1078 + if (verbose) puts("STUB: ldap_modrdn2_s called"); 1079 + return NULL; 1080 + } 1081 + 1082 + void* ldap_modrdn_s(void) 1083 + { 1084 + if (verbose) puts("STUB: ldap_modrdn_s called"); 1085 + return NULL; 1086 + } 1087 + 1088 + void* ldap_mods_free(void) 1089 + { 1090 + if (verbose) puts("STUB: ldap_mods_free called"); 1091 + return NULL; 1092 + } 1093 + 1094 + void* ldap_msgdelete(void) 1095 + { 1096 + if (verbose) puts("STUB: ldap_msgdelete called"); 1097 + return NULL; 1098 + } 1099 + 1100 + void* ldap_msgfree(void) 1101 + { 1102 + if (verbose) puts("STUB: ldap_msgfree called"); 1103 + return NULL; 1104 + } 1105 + 1106 + void* ldap_msgid(void) 1107 + { 1108 + if (verbose) puts("STUB: ldap_msgid called"); 1109 + return NULL; 1110 + } 1111 + 1112 + void* ldap_msgtype(void) 1113 + { 1114 + if (verbose) puts("STUB: ldap_msgtype called"); 1115 + return NULL; 1116 + } 1117 + 1118 + void* ldap_nameform2bv(void) 1119 + { 1120 + if (verbose) puts("STUB: ldap_nameform2bv called"); 1121 + return NULL; 1122 + } 1123 + 1124 + void* ldap_nameform2name(void) 1125 + { 1126 + if (verbose) puts("STUB: ldap_nameform2name called"); 1127 + return NULL; 1128 + } 1129 + 1130 + void* ldap_nameform2str(void) 1131 + { 1132 + if (verbose) puts("STUB: ldap_nameform2str called"); 1133 + return NULL; 1134 + } 1135 + 1136 + void* ldap_nameform_free(void) 1137 + { 1138 + if (verbose) puts("STUB: ldap_nameform_free called"); 1139 + return NULL; 1140 + } 1141 + 1142 + void* ldap_next_attribute(void) 1143 + { 1144 + if (verbose) puts("STUB: ldap_next_attribute called"); 1145 + return NULL; 1146 + } 1147 + 1148 + void* ldap_next_entry(void) 1149 + { 1150 + if (verbose) puts("STUB: ldap_next_entry called"); 1151 + return NULL; 1152 + } 1153 + 1154 + void* ldap_next_message(void) 1155 + { 1156 + if (verbose) puts("STUB: ldap_next_message called"); 1157 + return NULL; 1158 + } 1159 + 1160 + void* ldap_next_reference(void) 1161 + { 1162 + if (verbose) puts("STUB: ldap_next_reference called"); 1163 + return NULL; 1164 + } 1165 + 1166 + void* ldap_objectclass2bv(void) 1167 + { 1168 + if (verbose) puts("STUB: ldap_objectclass2bv called"); 1169 + return NULL; 1170 + } 1171 + 1172 + void* ldap_objectclass2name(void) 1173 + { 1174 + if (verbose) puts("STUB: ldap_objectclass2name called"); 1175 + return NULL; 1176 + } 1177 + 1178 + void* ldap_objectclass2str(void) 1179 + { 1180 + if (verbose) puts("STUB: ldap_objectclass2str called"); 1181 + return NULL; 1182 + } 1183 + 1184 + void* ldap_objectclass_free(void) 1185 + { 1186 + if (verbose) puts("STUB: ldap_objectclass_free called"); 1187 + return NULL; 1188 + } 1189 + 1190 + void* ldap_open(void) 1191 + { 1192 + if (verbose) puts("STUB: ldap_open called"); 1193 + return NULL; 1194 + } 1195 + 1196 + void* ldap_parse_extended_result(void) 1197 + { 1198 + if (verbose) puts("STUB: ldap_parse_extended_result called"); 1199 + return NULL; 1200 + } 1201 + 1202 + void* ldap_parse_intermediate(void) 1203 + { 1204 + if (verbose) puts("STUB: ldap_parse_intermediate called"); 1205 + return NULL; 1206 + } 1207 + 1208 + void* ldap_parse_page_control(void) 1209 + { 1210 + if (verbose) puts("STUB: ldap_parse_page_control called"); 1211 + return NULL; 1212 + } 1213 + 1214 + void* ldap_parse_pageresponse_control(void) 1215 + { 1216 + if (verbose) puts("STUB: ldap_parse_pageresponse_control called"); 1217 + return NULL; 1218 + } 1219 + 1220 + void* ldap_parse_passwd(void) 1221 + { 1222 + if (verbose) puts("STUB: ldap_parse_passwd called"); 1223 + return NULL; 1224 + } 1225 + 1226 + void* ldap_parse_reference(void) 1227 + { 1228 + if (verbose) puts("STUB: ldap_parse_reference called"); 1229 + return NULL; 1230 + } 1231 + 1232 + void* ldap_parse_result(void) 1233 + { 1234 + if (verbose) puts("STUB: ldap_parse_result called"); 1235 + return NULL; 1236 + } 1237 + 1238 + void* ldap_parse_sasl_bind_result(void) 1239 + { 1240 + if (verbose) puts("STUB: ldap_parse_sasl_bind_result called"); 1241 + return NULL; 1242 + } 1243 + 1244 + void* ldap_parse_sort_control(void) 1245 + { 1246 + if (verbose) puts("STUB: ldap_parse_sort_control called"); 1247 + return NULL; 1248 + } 1249 + 1250 + void* ldap_parse_sortresponse_control(void) 1251 + { 1252 + if (verbose) puts("STUB: ldap_parse_sortresponse_control called"); 1253 + return NULL; 1254 + } 1255 + 1256 + void* ldap_parse_vlv_control(void) 1257 + { 1258 + if (verbose) puts("STUB: ldap_parse_vlv_control called"); 1259 + return NULL; 1260 + } 1261 + 1262 + void* ldap_parse_vlvresponse_control(void) 1263 + { 1264 + if (verbose) puts("STUB: ldap_parse_vlvresponse_control called"); 1265 + return NULL; 1266 + } 1267 + 1268 + void* ldap_parse_whoami(void) 1269 + { 1270 + if (verbose) puts("STUB: ldap_parse_whoami called"); 1271 + return NULL; 1272 + } 1273 + 1274 + void* ldap_passwd(void) 1275 + { 1276 + if (verbose) puts("STUB: ldap_passwd called"); 1277 + return NULL; 1278 + } 1279 + 1280 + void* ldap_passwd_s(void) 1281 + { 1282 + if (verbose) puts("STUB: ldap_passwd_s called"); 1283 + return NULL; 1284 + } 1285 + 1286 + void* ldap_perror(void) 1287 + { 1288 + if (verbose) puts("STUB: ldap_perror called"); 1289 + return NULL; 1290 + } 1291 + 1292 + void* ldap_put_vrFilter(void) 1293 + { 1294 + if (verbose) puts("STUB: ldap_put_vrFilter called"); 1295 + return NULL; 1296 + } 1297 + 1298 + void* ldap_rdn2bv(void) 1299 + { 1300 + if (verbose) puts("STUB: ldap_rdn2bv called"); 1301 + return NULL; 1302 + } 1303 + 1304 + void* ldap_rdn2str(void) 1305 + { 1306 + if (verbose) puts("STUB: ldap_rdn2str called"); 1307 + return NULL; 1308 + } 1309 + 1310 + void* ldap_rdnfree(void) 1311 + { 1312 + if (verbose) puts("STUB: ldap_rdnfree called"); 1313 + return NULL; 1314 + } 1315 + 1316 + void* ldap_rename(void) 1317 + { 1318 + if (verbose) puts("STUB: ldap_rename called"); 1319 + return NULL; 1320 + } 1321 + 1322 + void* ldap_rename2(void) 1323 + { 1324 + if (verbose) puts("STUB: ldap_rename2 called"); 1325 + return NULL; 1326 + } 1327 + 1328 + void* ldap_rename2_s(void) 1329 + { 1330 + if (verbose) puts("STUB: ldap_rename2_s called"); 1331 + return NULL; 1332 + } 1333 + 1334 + void* ldap_rename_s(void) 1335 + { 1336 + if (verbose) puts("STUB: ldap_rename_s called"); 1337 + return NULL; 1338 + } 1339 + 1340 + void* ldap_result(void) 1341 + { 1342 + if (verbose) puts("STUB: ldap_result called"); 1343 + return NULL; 1344 + } 1345 + 1346 + void* ldap_result2error(void) 1347 + { 1348 + if (verbose) puts("STUB: ldap_result2error called"); 1349 + return NULL; 1350 + } 1351 + 1352 + void* ldap_sasl_bind(void) 1353 + { 1354 + if (verbose) puts("STUB: ldap_sasl_bind called"); 1355 + return NULL; 1356 + } 1357 + 1358 + void* ldap_sasl_bind_s(void) 1359 + { 1360 + if (verbose) puts("STUB: ldap_sasl_bind_s called"); 1361 + return NULL; 1362 + } 1363 + 1364 + void* ldap_sasl_interactive_bind_s(void) 1365 + { 1366 + if (verbose) puts("STUB: ldap_sasl_interactive_bind_s called"); 1367 + return NULL; 1368 + } 1369 + 1370 + void* ldap_scherr2str(void) 1371 + { 1372 + if (verbose) puts("STUB: ldap_scherr2str called"); 1373 + return NULL; 1374 + } 1375 + 1376 + void* ldap_search(void) 1377 + { 1378 + if (verbose) puts("STUB: ldap_search called"); 1379 + return NULL; 1380 + } 1381 + 1382 + void* ldap_search_ext(void) 1383 + { 1384 + if (verbose) puts("STUB: ldap_search_ext called"); 1385 + return NULL; 1386 + } 1387 + 1388 + void* ldap_search_ext_s(void) 1389 + { 1390 + if (verbose) puts("STUB: ldap_search_ext_s called"); 1391 + return NULL; 1392 + } 1393 + 1394 + void* ldap_search_s(void) 1395 + { 1396 + if (verbose) puts("STUB: ldap_search_s called"); 1397 + return NULL; 1398 + } 1399 + 1400 + void* ldap_search_st(void) 1401 + { 1402 + if (verbose) puts("STUB: ldap_search_st called"); 1403 + return NULL; 1404 + } 1405 + 1406 + void* ldap_set_option(void) 1407 + { 1408 + if (verbose) puts("STUB: ldap_set_option called"); 1409 + return NULL; 1410 + } 1411 + 1412 + void* ldap_set_rebind_proc(void) 1413 + { 1414 + if (verbose) puts("STUB: ldap_set_rebind_proc called"); 1415 + return NULL; 1416 + } 1417 + 1418 + void* ldap_set_search_results_callback(void) 1419 + { 1420 + if (verbose) puts("STUB: ldap_set_search_results_callback called"); 1421 + return NULL; 1422 + } 1423 + 1424 + void* ldap_simple_bind(void) 1425 + { 1426 + if (verbose) puts("STUB: ldap_simple_bind called"); 1427 + return NULL; 1428 + } 1429 + 1430 + void* ldap_simple_bind_s(void) 1431 + { 1432 + if (verbose) puts("STUB: ldap_simple_bind_s called"); 1433 + return NULL; 1434 + } 1435 + 1436 + void* ldap_sort_entries(void) 1437 + { 1438 + if (verbose) puts("STUB: ldap_sort_entries called"); 1439 + return NULL; 1440 + } 1441 + 1442 + void* ldap_sort_strcasecmp(void) 1443 + { 1444 + if (verbose) puts("STUB: ldap_sort_strcasecmp called"); 1445 + return NULL; 1446 + } 1447 + 1448 + void* ldap_sort_values(void) 1449 + { 1450 + if (verbose) puts("STUB: ldap_sort_values called"); 1451 + return NULL; 1452 + } 1453 + 1454 + void* ldap_start_tls_s(void) 1455 + { 1456 + if (verbose) puts("STUB: ldap_start_tls_s called"); 1457 + return NULL; 1458 + } 1459 + 1460 + void* ldap_str2attributetype(void) 1461 + { 1462 + if (verbose) puts("STUB: ldap_str2attributetype called"); 1463 + return NULL; 1464 + } 1465 + 1466 + void* ldap_str2contentrule(void) 1467 + { 1468 + if (verbose) puts("STUB: ldap_str2contentrule called"); 1469 + return NULL; 1470 + } 1471 + 1472 + void* ldap_str2dn(void) 1473 + { 1474 + if (verbose) puts("STUB: ldap_str2dn called"); 1475 + return NULL; 1476 + } 1477 + 1478 + void* ldap_str2matchingrule(void) 1479 + { 1480 + if (verbose) puts("STUB: ldap_str2matchingrule called"); 1481 + return NULL; 1482 + } 1483 + 1484 + void* ldap_str2matchingruleuse(void) 1485 + { 1486 + if (verbose) puts("STUB: ldap_str2matchingruleuse called"); 1487 + return NULL; 1488 + } 1489 + 1490 + void* ldap_str2nameform(void) 1491 + { 1492 + if (verbose) puts("STUB: ldap_str2nameform called"); 1493 + return NULL; 1494 + } 1495 + 1496 + void* ldap_str2objectclass(void) 1497 + { 1498 + if (verbose) puts("STUB: ldap_str2objectclass called"); 1499 + return NULL; 1500 + } 1501 + 1502 + void* ldap_str2rdn(void) 1503 + { 1504 + if (verbose) puts("STUB: ldap_str2rdn called"); 1505 + return NULL; 1506 + } 1507 + 1508 + void* ldap_str2structurerule(void) 1509 + { 1510 + if (verbose) puts("STUB: ldap_str2structurerule called"); 1511 + return NULL; 1512 + } 1513 + 1514 + void* ldap_str2syntax(void) 1515 + { 1516 + if (verbose) puts("STUB: ldap_str2syntax called"); 1517 + return NULL; 1518 + } 1519 + 1520 + void* ldap_strdup(void) 1521 + { 1522 + if (verbose) puts("STUB: ldap_strdup called"); 1523 + return NULL; 1524 + } 1525 + 1526 + void* ldap_structurerule2bv(void) 1527 + { 1528 + if (verbose) puts("STUB: ldap_structurerule2bv called"); 1529 + return NULL; 1530 + } 1531 + 1532 + void* ldap_structurerule2name(void) 1533 + { 1534 + if (verbose) puts("STUB: ldap_structurerule2name called"); 1535 + return NULL; 1536 + } 1537 + 1538 + void* ldap_structurerule2str(void) 1539 + { 1540 + if (verbose) puts("STUB: ldap_structurerule2str called"); 1541 + return NULL; 1542 + } 1543 + 1544 + void* ldap_structurerule_free(void) 1545 + { 1546 + if (verbose) puts("STUB: ldap_structurerule_free called"); 1547 + return NULL; 1548 + } 1549 + 1550 + void* ldap_syntax2bv(void) 1551 + { 1552 + if (verbose) puts("STUB: ldap_syntax2bv called"); 1553 + return NULL; 1554 + } 1555 + 1556 + void* ldap_syntax2name(void) 1557 + { 1558 + if (verbose) puts("STUB: ldap_syntax2name called"); 1559 + return NULL; 1560 + } 1561 + 1562 + void* ldap_syntax2str(void) 1563 + { 1564 + if (verbose) puts("STUB: ldap_syntax2str called"); 1565 + return NULL; 1566 + } 1567 + 1568 + void* ldap_syntax_free(void) 1569 + { 1570 + if (verbose) puts("STUB: ldap_syntax_free called"); 1571 + return NULL; 1572 + } 1573 + 1574 + void* ldap_unbind(void) 1575 + { 1576 + if (verbose) puts("STUB: ldap_unbind called"); 1577 + return NULL; 1578 + } 1579 + 1580 + void* ldap_unbind_ext(void) 1581 + { 1582 + if (verbose) puts("STUB: ldap_unbind_ext called"); 1583 + return NULL; 1584 + } 1585 + 1586 + void* ldap_unbind_ext_s(void) 1587 + { 1588 + if (verbose) puts("STUB: ldap_unbind_ext_s called"); 1589 + return NULL; 1590 + } 1591 + 1592 + void* ldap_unbind_s(void) 1593 + { 1594 + if (verbose) puts("STUB: ldap_unbind_s called"); 1595 + return NULL; 1596 + } 1597 + 1598 + void* ldap_url_desc2str(void) 1599 + { 1600 + if (verbose) puts("STUB: ldap_url_desc2str called"); 1601 + return NULL; 1602 + } 1603 + 1604 + void* ldap_url_parse(void) 1605 + { 1606 + if (verbose) puts("STUB: ldap_url_parse called"); 1607 + return NULL; 1608 + } 1609 + 1610 + void* ldap_value_free(void) 1611 + { 1612 + if (verbose) puts("STUB: ldap_value_free called"); 1613 + return NULL; 1614 + } 1615 + 1616 + void* ldap_value_free_len(void) 1617 + { 1618 + if (verbose) puts("STUB: ldap_value_free_len called"); 1619 + return NULL; 1620 + } 1621 + 1622 + void* ldap_whoami(void) 1623 + { 1624 + if (verbose) puts("STUB: ldap_whoami called"); 1625 + return NULL; 1626 + } 1627 + 1628 + void* ldap_whoami_s(void) 1629 + { 1630 + if (verbose) puts("STUB: ldap_whoami_s called"); 1631 + return NULL; 1632 + } 1633 + 1634 + void* ldap_x_mb_to_utf8(void) 1635 + { 1636 + if (verbose) puts("STUB: ldap_x_mb_to_utf8 called"); 1637 + return NULL; 1638 + } 1639 + 1640 + void* ldap_x_mbs_to_utf8s(void) 1641 + { 1642 + if (verbose) puts("STUB: ldap_x_mbs_to_utf8s called"); 1643 + return NULL; 1644 + } 1645 + 1646 + void* ldap_x_ucs4_to_utf8(void) 1647 + { 1648 + if (verbose) puts("STUB: ldap_x_ucs4_to_utf8 called"); 1649 + return NULL; 1650 + } 1651 + 1652 + void* ldap_x_utf8_to_mb(void) 1653 + { 1654 + if (verbose) puts("STUB: ldap_x_utf8_to_mb called"); 1655 + return NULL; 1656 + } 1657 + 1658 + void* ldap_x_utf8_to_ucs4(void) 1659 + { 1660 + if (verbose) puts("STUB: ldap_x_utf8_to_ucs4 called"); 1661 + return NULL; 1662 + } 1663 + 1664 + void* ldap_x_utf8_to_wc(void) 1665 + { 1666 + if (verbose) puts("STUB: ldap_x_utf8_to_wc called"); 1667 + return NULL; 1668 + } 1669 + 1670 + void* ldap_x_utf8s_to_mbs(void) 1671 + { 1672 + if (verbose) puts("STUB: ldap_x_utf8s_to_mbs called"); 1673 + return NULL; 1674 + } 1675 + 1676 + void* ldap_x_utf8s_to_wcs(void) 1677 + { 1678 + if (verbose) puts("STUB: ldap_x_utf8s_to_wcs called"); 1679 + return NULL; 1680 + } 1681 + 1682 + void* ldap_x_wc_to_utf8(void) 1683 + { 1684 + if (verbose) puts("STUB: ldap_x_wc_to_utf8 called"); 1685 + return NULL; 1686 + } 1687 + 1688 + void* ldap_x_wcs_to_utf8s(void) 1689 + { 1690 + if (verbose) puts("STUB: ldap_x_wcs_to_utf8s called"); 1691 + return NULL; 1692 + } 1693 + 1694 + void* ldif_close(void) 1695 + { 1696 + if (verbose) puts("STUB: ldif_close called"); 1697 + return NULL; 1698 + } 1699 + 1700 + void* ldif_countlines(void) 1701 + { 1702 + if (verbose) puts("STUB: ldif_countlines called"); 1703 + return NULL; 1704 + } 1705 + 1706 + void* ldif_fetch_url(void) 1707 + { 1708 + if (verbose) puts("STUB: ldif_fetch_url called"); 1709 + return NULL; 1710 + } 1711 + 1712 + void* ldif_getline(void) 1713 + { 1714 + if (verbose) puts("STUB: ldif_getline called"); 1715 + return NULL; 1716 + } 1717 + 1718 + void* ldif_is_not_printable(void) 1719 + { 1720 + if (verbose) puts("STUB: ldif_is_not_printable called"); 1721 + return NULL; 1722 + } 1723 + 1724 + void* ldif_must_b64_encode_register(void) 1725 + { 1726 + if (verbose) puts("STUB: ldif_must_b64_encode_register called"); 1727 + return NULL; 1728 + } 1729 + 1730 + void* ldif_must_b64_encode_release(void) 1731 + { 1732 + if (verbose) puts("STUB: ldif_must_b64_encode_release called"); 1733 + return NULL; 1734 + } 1735 + 1736 + void* ldif_open(void) 1737 + { 1738 + if (verbose) puts("STUB: ldif_open called"); 1739 + return NULL; 1740 + } 1741 + 1742 + void* ldif_open_url(void) 1743 + { 1744 + if (verbose) puts("STUB: ldif_open_url called"); 1745 + return NULL; 1746 + } 1747 + 1748 + void* ldif_parse_line(void) 1749 + { 1750 + if (verbose) puts("STUB: ldif_parse_line called"); 1751 + return NULL; 1752 + } 1753 + 1754 + void* ldif_parse_line2(void) 1755 + { 1756 + if (verbose) puts("STUB: ldif_parse_line2 called"); 1757 + return NULL; 1758 + } 1759 + 1760 + void* ldif_put(void) 1761 + { 1762 + if (verbose) puts("STUB: ldif_put called"); 1763 + return NULL; 1764 + } 1765 + 1766 + void* ldif_put_wrap(void) 1767 + { 1768 + if (verbose) puts("STUB: ldif_put_wrap called"); 1769 + return NULL; 1770 + } 1771 + 1772 + void* ldif_read_record(void) 1773 + { 1774 + if (verbose) puts("STUB: ldif_read_record called"); 1775 + return NULL; 1776 + } 1777 + 1778 + void* ldif_sput(void) 1779 + { 1780 + if (verbose) puts("STUB: ldif_sput called"); 1781 + return NULL; 1782 + } 1783 + 1784 + void* ldif_sput_wrap(void) 1785 + { 1786 + if (verbose) puts("STUB: ldif_sput_wrap called"); 1787 + return NULL; 1788 + }