1 /*
2 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /* common.c - Functions that are common to server and clinet
7 * Rob Siemborski
8 * Tim Martin
9 * $Id: common.c,v 1.92 2003/04/16 19:36:00 rjs3 Exp $
10 */
11 /*
12 * Copyright (c) 1998-2003 Carnegie Mellon University. All rights reserved.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 *
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 *
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in
23 * the documentation and/or other materials provided with the
24 * distribution.
25 *
26 * 3. The name "Carnegie Mellon University" must not be used to
27 * endorse or promote products derived from this software without
28 * prior written permission. For permission or any other legal
29 * details, please contact
30 * Office of Technology Transfer
31 * Carnegie Mellon University
32 * 5000 Forbes Avenue
33 * Pittsburgh, PA 15213-3890
34 * (412) 268-4387, fax: (412) 268-7395
35 * tech-transfer@andrew.cmu.edu
36 *
37 * 4. Redistributions of any form whatsoever must retain the following
38 * acknowledgment:
39 * "This product includes software developed by Computing Services
40 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
41 *
42 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
43 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
44 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
45 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
46 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
47 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
48 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
49 */
50
51 #include <config.h>
52 #include <stdio.h>
53 #include <string.h>
54 #include <stdlib.h>
55 #include <limits.h>
56 #ifdef HAVE_SYSLOG
57 #include <syslog.h>
58 #endif
59 #include <stdarg.h>
60 #include <ctype.h>
61
62 #include <sasl.h>
63 #include <saslutil.h>
64 #include <saslplug.h>
65 #include "saslint.h"
66
67 #ifdef _SUN_SDK_
68 #include "md5_private.h"
69 #include "hmac-md5.h"
70 #include "plugin_common.h"
71 #endif
72
73
74 #ifdef WIN32
75 /* need to handle the fact that errno has been defined as a function
76 in a dll, not an extern int */
77 # ifdef errno
78 # undef errno
79 # endif /* errno */
80 #endif /* WIN32 */
81 #ifdef HAVE_UNISTD_H
82 #include <unistd.h>
83 #endif
84
85 static int _sasl_getpath(void *context __attribute__((unused)), const char **path);
86
87 #ifdef _SUN_SDK_
88 DEFINE_STATIC_MUTEX(global_mutex);
89 DEFINE_STATIC_MUTEX(malloc_global_mutex);
90 static void _sasl_dispose_context(_sasl_global_context_t *ctx);
91 static int _sasl_getconf(void *context, const char **conf);
92
93 #ifdef _INTEGRATED_SOLARIS_
94 static pthread_key_t errstring_key = PTHREAD_ONCE_KEY_NP;
95 #endif /* _INTEGRATED_SOLARIS_ */
96 #else
97 static const char build_ident[] = "$Build: libsasl " PACKAGE "-" VERSION " $";
98
99 /* It turns out to be conveinent to have a shared sasl_utils_t */
100 LIBSASL_VAR const sasl_utils_t *sasl_global_utils = NULL;
101
102 /* Should be a null-terminated array that lists the available mechanisms */
103 static char **global_mech_list = NULL;
104
105 void *free_mutex = NULL;
106
107 int (*_sasl_client_cleanup_hook)(void) = NULL;
108 int (*_sasl_server_cleanup_hook)(void) = NULL;
109 int (*_sasl_client_idle_hook)(sasl_conn_t *conn) = NULL;
110 int (*_sasl_server_idle_hook)(sasl_conn_t *conn) = NULL;
111
112 sasl_allocation_utils_t _sasl_allocation_utils={
113 (sasl_malloc_t *) &malloc,
114 (sasl_calloc_t *) &calloc,
115 (sasl_realloc_t *) &realloc,
116 (sasl_free_t *) &free
117 };
118 #endif /* _SUN_SDK_ */
119
120 #ifdef USE_PTHREADS
sasl_mutex_alloc(void)121 static void *sasl_mutex_alloc(void)
122 {
123 pthread_mutex_t *mutex =
124 (pthread_mutex_t *)malloc(sizeof (pthread_mutex_t));
125
126 if (mutex != NULL) {
127 if (pthread_mutex_init(mutex, NULL) != 0) {
128 free(mutex);
129 mutex = NULL;
130 }
131 }
132 return (mutex);
133 }
134
sasl_mutex_lock(void * mutex)135 static int sasl_mutex_lock(void *mutex)
136 {
137 int ret = SASL_BADPARAM;
138
139 if (mutex != NULL)
140 ret = pthread_mutex_lock((pthread_mutex_t *)mutex);
141
142 return ret;
143 }
144
sasl_mutex_unlock(void * mutex)145 static int sasl_mutex_unlock(void *mutex)
146 {
147 int ret = SASL_BADPARAM;
148
149 if (mutex != NULL)
150 ret = pthread_mutex_unlock((pthread_mutex_t *)mutex);
151
152 return ret;
153 }
154
sasl_mutex_free(void * mutex)155 static void sasl_mutex_free(void *mutex __attribute__((unused)))
156 {
157 if (mutex != NULL) {
158 pthread_mutex_destroy((pthread_mutex_t *)mutex);
159 free(mutex);
160 }
161 }
162 #else
163 /* Intenal mutex functions do as little as possible (no thread protection) */
sasl_mutex_alloc(void)164 static void *sasl_mutex_alloc(void)
165 {
166 return (void *)0x1;
167 }
168
sasl_mutex_lock(void * mutex)169 static int sasl_mutex_lock(void *mutex __attribute__((unused)))
170 {
171 return SASL_OK;
172 }
173
sasl_mutex_unlock(void * mutex)174 static int sasl_mutex_unlock(void *mutex __attribute__((unused)))
175 {
176 return SASL_OK;
177 }
178
sasl_mutex_free(void * mutex)179 static void sasl_mutex_free(void *mutex __attribute__((unused)))
180 {
181 return;
182 }
183 #endif /* USE_PTHREADS */
184
185 #ifndef _SUN_SDK_
186 sasl_mutex_utils_t _sasl_mutex_utils={
187 &sasl_mutex_alloc,
188 &sasl_mutex_lock,
189 &sasl_mutex_unlock,
190 &sasl_mutex_free
191 };
192 #endif /* !_SUN_SDK_ */
193
sasl_set_mutex(sasl_mutex_alloc_t * n,sasl_mutex_lock_t * l,sasl_mutex_unlock_t * u,sasl_mutex_free_t * d)194 void sasl_set_mutex(sasl_mutex_alloc_t *n, sasl_mutex_lock_t *l,
195 sasl_mutex_unlock_t *u, sasl_mutex_free_t *d)
196 {
197 #ifdef _SUN_SDK_
198 _sasl_global_context_t *gctx = _sasl_gbl_ctx();
199
200 gctx->sasl_mutex_utils.alloc=n;
201 gctx->sasl_mutex_utils.lock=l;
202 gctx->sasl_mutex_utils.unlock=u;
203 gctx->sasl_mutex_utils.free=d;
204 #else
205 _sasl_mutex_utils.alloc=n;
206 _sasl_mutex_utils.lock=l;
207 _sasl_mutex_utils.unlock=u;
208 _sasl_mutex_utils.free=d;
209 #endif
210 }
211
212 /* copy a string to malloced memory */
213 #ifdef _SUN_SDK_
__sasl_strdup(const _sasl_global_context_t * gctx,const char * in,char ** out,size_t * outlen)214 int __sasl_strdup(const _sasl_global_context_t *gctx, const char *in,
215 char **out, size_t *outlen)
216 #else
217 int _sasl_strdup(const char *in, char **out, size_t *outlen)
218 #endif /* _SUN_SDK_ */
219 {
220 size_t len = strlen(in);
221 if (outlen) *outlen = len;
222 *out=sasl_ALLOC(len + 1);
223 if (! *out) return SASL_NOMEM;
224 strcpy((char *) *out, in);
225 return SASL_OK;
226 }
227
228 /* adds a string to the buffer; reallocing if need be */
229 #ifdef _SUN_SDK_
__sasl_add_string(const _sasl_global_context_t * gctx,char ** out,size_t * alloclen,size_t * outlen,const char * add)230 int __sasl_add_string(const _sasl_global_context_t *gctx, char **out,
231 size_t *alloclen, size_t *outlen,
232 const char *add)
233 #else
234 int _sasl_add_string(char **out, size_t *alloclen,
235 size_t *outlen, const char *add)
236 #endif /* _SUN_SDK_ */
237 {
238 size_t addlen;
239
240 if (add==NULL) add = "(null)";
241
242 addlen=strlen(add); /* only compute once */
243 if (_buf_alloc(out, alloclen, (*outlen)+addlen)!=SASL_OK)
244 return SASL_NOMEM;
245
246 strncpy(*out + *outlen, add, addlen);
247 *outlen += addlen;
248
249 return SASL_OK;
250 }
251
252 /* return the version of the cyrus sasl library as compiled,
253 * using 32 bits: high byte is major version, second byte is minor version,
254 * low 16 bits are step # */
sasl_version(const char ** implementation,int * version)255 void sasl_version(const char **implementation, int *version)
256 {
257 #ifdef _SUN_SDK_
258 const char *implementation_string = "Sun SASL";
259 #else
260 const char *implementation_string = "Cyrus SASL";
261 #endif /* _SUN_SDK_ */
262 if(implementation) *implementation = implementation_string;
263 if(version) *version = (SASL_VERSION_MAJOR << 24) |
264 (SASL_VERSION_MINOR << 16) |
265 (SASL_VERSION_STEP);
266 }
267
268 /* security-encode a regular string. Mostly a wrapper for sasl_encodev */
269 /* output is only valid until next call to sasl_encode or sasl_encodev */
sasl_encode(sasl_conn_t * conn,const char * input,unsigned inputlen,const char ** output,unsigned * outputlen)270 int sasl_encode(sasl_conn_t *conn, const char *input,
271 unsigned inputlen,
272 const char **output, unsigned *outputlen)
273 {
274 int result;
275 struct iovec tmp;
276
277 if(!conn) return SASL_BADPARAM;
278 if(!input || !inputlen || !output || !outputlen)
279 PARAMERROR(conn);
280
281 /* maxoutbuf checking is done in sasl_encodev */
282
283 /* Note: We are casting a const pointer here, but it's okay
284 * because we believe people downstream of us are well-behaved, and the
285 * alternative is an absolute mess, performance-wise. */
286 tmp.iov_base = (void *)input;
287 tmp.iov_len = inputlen;
288
289 result = sasl_encodev(conn, &tmp, 1, output, outputlen);
290
291 RETURN(conn, result);
292 }
293
294 /* security-encode an iovec */
295 /* output is only valid until next call to sasl_encode or sasl_encodev */
sasl_encodev(sasl_conn_t * conn,const struct iovec * invec,unsigned numiov,const char ** output,unsigned * outputlen)296 int sasl_encodev(sasl_conn_t *conn,
297 const struct iovec *invec, unsigned numiov,
298 const char **output, unsigned *outputlen)
299 {
300 #ifdef _SUN_SDK_
301 int result = SASL_FAIL;
302 #else
303 int result;
304 #endif /* _SUN_SDK_ */
305 unsigned i;
306 size_t total_size = 0;
307
308 if (!conn) return SASL_BADPARAM;
309 if (! invec || ! output || ! outputlen || numiov < 1)
310 PARAMERROR(conn);
311
312 if(!conn->props.maxbufsize) {
313 #ifdef _SUN_SDK_
314 _sasl_log(conn, SASL_LOG_ERR,
315 "called sasl_encode[v] with application that does not support security layers");
316 #else
317 sasl_seterror(conn, 0,
318 "called sasl_encode[v] with application that does not support security layers");
319 #endif /* _SUN_SDK_ */
320 return SASL_TOOWEAK;
321 }
322
323 /* This might be better to check on a per-plugin basis, but I think
324 * it's cleaner and more effective here. It also encourages plugins
325 * to be honest about what they accept */
326
327 for(i=0; i<numiov;i++) {
328 #ifdef _SUN_SDK_
329 if (invec[i].iov_base == NULL)
330 PARAMERROR(conn);
331 #endif /* _SUN_SDK_ */
332 total_size += invec[i].iov_len;
333 }
334 if(total_size > conn->oparams.maxoutbuf)
335 PARAMERROR(conn);
336
337 if(conn->oparams.encode == NULL) {
338 #ifdef _SUN_SDK_
339 result = _iovec_to_buf(conn->gctx, invec, numiov, &conn->encode_buf);
340 #else
341 result = _iovec_to_buf(invec, numiov, &conn->encode_buf);
342 #endif /* _SUN_SDK_ */
343 if(result != SASL_OK) INTERROR(conn, result);
344
345 *output = conn->encode_buf->data;
346 *outputlen = conn->encode_buf->curlen;
347
348 #ifdef _INTEGRATED_SOLARIS_
349 } else if (!conn->sun_reg) {
350 INTERROR(conn, SASL_FAIL);
351 #endif /* _INTEGRATED_SOLARIS_ */
352 } else {
353 result = conn->oparams.encode(conn->context, invec, numiov,
354 output, outputlen);
355 }
356
357 RETURN(conn, result);
358 }
359
360 /* output is only valid until next call to sasl_decode */
sasl_decode(sasl_conn_t * conn,const char * input,unsigned inputlen,const char ** output,unsigned * outputlen)361 int sasl_decode(sasl_conn_t *conn,
362 const char *input, unsigned inputlen,
363 const char **output, unsigned *outputlen)
364 {
365 int result;
366 #ifdef _SUN_SDK_
367 const _sasl_global_context_t *gctx;
368 #endif /* _SUN_SDK_ */
369
370 if(!conn) return SASL_BADPARAM;
371 if(!input || !output || !outputlen)
372 PARAMERROR(conn);
373
374 #ifdef _SUN_SDK_
375 gctx = conn->gctx;
376 #endif /* _SUN_SDK_ */
377
378 if(!conn->props.maxbufsize) {
379 #ifdef _SUN_SDK_
380 _sasl_log(conn, SASL_LOG_ERR,
381 "called sasl_decode with application that does not support security layers");
382 #else
383 sasl_seterror(conn, 0,
384 "called sasl_decode with application that does not support security layers");
385 #endif /* _SUN_SDK_ */
386 RETURN(conn, SASL_TOOWEAK);
387 }
388
389 if(conn->oparams.decode == NULL)
390 {
391 /* Since we know how long the output is maximally, we can
392 * just allocate it to begin with, and never need another
393 * allocation! */
394
395 /* However, if they pass us more than they actually can take,
396 * we cannot help them... */
397 if(inputlen > conn->props.maxbufsize) {
398 #ifdef _SUN_SDK_
399 _sasl_log(conn, SASL_LOG_ERR,
400 "input too large for default sasl_decode");
401 #else
402 sasl_seterror(conn, 0,
403 "input too large for default sasl_decode");
404 #endif /* _SUN_SDK_ */
405 RETURN(conn,SASL_BUFOVER);
406 }
407
408 if(!conn->decode_buf)
409 conn->decode_buf = sasl_ALLOC(conn->props.maxbufsize + 1);
410 if(!conn->decode_buf)
411 MEMERROR(conn);
412
413 memcpy(conn->decode_buf, input, inputlen);
414 conn->decode_buf[inputlen] = '\0';
415 *output = conn->decode_buf;
416 *outputlen = inputlen;
417
418 return SASL_OK;
419 #ifdef _INTEGRATED_SOLARIS_
420 } else if (!conn->sun_reg) {
421 INTERROR(conn, SASL_FAIL);
422 #endif /* _INTEGRATED_SOLARIS_ */
423 } else {
424 result = conn->oparams.decode(conn->context, input, inputlen,
425 output, outputlen);
426
427 /* NULL an empty buffer (for misbehaved applications) */
428 if (*outputlen == 0) *output = NULL;
429
430 RETURN(conn, result);
431 }
432
433 #ifdef _SUN_SDK_
434 return SASL_FAIL;
435 #else
436 INTERROR(conn, SASL_FAIL);
437 #endif /* _SUN_SDK_ */
438 }
439
440
441 void
sasl_set_alloc(sasl_malloc_t * m,sasl_calloc_t * c,sasl_realloc_t * r,sasl_free_t * f)442 sasl_set_alloc(sasl_malloc_t *m,
443 sasl_calloc_t *c,
444 sasl_realloc_t *r,
445 sasl_free_t *f)
446 {
447 #ifdef _SUN_SDK_
448 _sasl_global_context_t *gctx = _sasl_gbl_ctx();
449
450 LOCK_MUTEX(&malloc_global_mutex);
451 gctx->sasl_allocation_utils.malloc=m;
452 gctx->sasl_allocation_utils.calloc=c;
453 gctx->sasl_allocation_utils.realloc=r;
454 gctx->sasl_allocation_utils.free=f;
455 UNLOCK_MUTEX(&malloc_global_mutex);
456 #else
457 _sasl_allocation_utils.malloc=m;
458 _sasl_allocation_utils.calloc=c;
459 _sasl_allocation_utils.realloc=r;
460 _sasl_allocation_utils.free=f;
461 #endif /* _SUN_SDK_ */
462 }
463
sasl_done(void)464 void sasl_done(void)
465 {
466 #ifdef _SUN_SDK_
467 _sasl_dispose_context(_sasl_gbl_ctx());
468 #else
469 if (_sasl_server_cleanup_hook && _sasl_server_cleanup_hook() == SASL_OK) {
470 _sasl_server_idle_hook = NULL;
471 _sasl_server_cleanup_hook = NULL;
472 }
473
474 if (_sasl_client_cleanup_hook && _sasl_client_cleanup_hook() == SASL_OK) {
475 _sasl_client_idle_hook = NULL;
476 _sasl_client_cleanup_hook = NULL;
477 }
478
479 if(_sasl_server_cleanup_hook || _sasl_client_cleanup_hook)
480 return;
481
482
483 _sasl_canonuser_free();
484 _sasl_done_with_plugins();
485
486 #ifdef _SUN_SDK_
487 sasl_config_free();
488 #endif /* _SUN_SDK_ */
489
490 sasl_MUTEX_FREE(free_mutex);
491 free_mutex = NULL;
492
493 _sasl_free_utils(&sasl_global_utils);
494
495 if(global_mech_list) sasl_FREE(global_mech_list);
496 global_mech_list = NULL;
497 #endif /* _SUN_SDK_ */
498 }
499
500 /* fills in the base sasl_conn_t info */
_sasl_conn_init(sasl_conn_t * conn,const char * service,unsigned int flags,enum Sasl_conn_type type,int (* idle_hook)(sasl_conn_t * conn),const char * serverFQDN,const char * iplocalport,const char * ipremoteport,const sasl_callback_t * callbacks,const sasl_global_callbacks_t * global_callbacks)501 int _sasl_conn_init(sasl_conn_t *conn,
502 const char *service,
503 unsigned int flags,
504 enum Sasl_conn_type type,
505 int (*idle_hook)(sasl_conn_t *conn),
506 const char *serverFQDN,
507 const char *iplocalport,
508 const char *ipremoteport,
509 const sasl_callback_t *callbacks,
510 const sasl_global_callbacks_t *global_callbacks) {
511 int result = SASL_OK;
512 #ifdef _SUN_SDK_
513 const _sasl_global_context_t *gctx = conn->gctx;
514 #endif /* _SUN_SDK_ */
515
516 conn->type = type;
517
518 result = _sasl_strdup(service, &conn->service, NULL);
519 if (result != SASL_OK)
520 MEMERROR(conn);
521
522 memset(&conn->oparams, 0, sizeof(sasl_out_params_t));
523 memset(&conn->external, 0, sizeof(_sasl_external_properties_t));
524
525 conn->flags = flags;
526
527 result = sasl_setprop(conn, SASL_IPLOCALPORT, iplocalport);
528 if(result != SASL_OK)
529 RETURN(conn, result);
530
531 result = sasl_setprop(conn, SASL_IPREMOTEPORT, ipremoteport);
532 if(result != SASL_OK)
533 RETURN(conn, result);
534
535 conn->encode_buf = NULL;
536 conn->context = NULL;
537 #ifndef _SUN_SDK_
538 conn->secret = NULL;
539 #endif /* !_SUN_SDK_ */
540 conn->idle_hook = idle_hook;
541 conn->callbacks = callbacks;
542 conn->global_callbacks = global_callbacks;
543
544 memset(&conn->props, 0, sizeof(conn->props));
545
546 /* Start this buffer out as an empty string */
547 conn->error_code = SASL_OK;
548 conn->errdetail_buf = conn->error_buf = NULL;
549 conn->errdetail_buf_len = conn->error_buf_len = 150;
550
551 result = _buf_alloc(&conn->error_buf, &conn->error_buf_len, 150);
552 if(result != SASL_OK) MEMERROR(conn);
553 result = _buf_alloc(&conn->errdetail_buf, &conn->errdetail_buf_len, 150);
554 if(result != SASL_OK) MEMERROR(conn);
555
556 conn->error_buf[0] = '\0';
557 conn->errdetail_buf[0] = '\0';
558
559 conn->decode_buf = NULL;
560
561 if(serverFQDN) {
562 result = _sasl_strdup(serverFQDN, &conn->serverFQDN, NULL);
563 } else if (conn->type == SASL_CONN_SERVER) {
564 /* We can fake it because we *are* the server */
565 char name[MAXHOSTNAMELEN];
566 memset(name, 0, sizeof(name));
567 gethostname(name, MAXHOSTNAMELEN);
568
569 result = _sasl_strdup(name, &conn->serverFQDN, NULL);
570 } else {
571 conn->serverFQDN = NULL;
572 }
573
574
575 if(result != SASL_OK) MEMERROR( conn );
576
577 #ifdef _SUN_SDK_
578 return (SASL_OK);
579 #else
580 RETURN(conn, SASL_OK);
581 #endif /* _SUN_SDK_ */
582 }
583
584 #ifdef _SUN_SDK_
_sasl_common_init(_sasl_global_context_t * gctx,sasl_global_callbacks_t * global_callbacks,int server)585 int _sasl_common_init(_sasl_global_context_t *gctx,
586 sasl_global_callbacks_t *global_callbacks,
587 int server)
588 {
589 int result;
590 sasl_utils_t *sasl_global_utils;
591
592 sasl_global_utils = (sasl_utils_t *)gctx->sasl_canonusr_global_utils;
593
594 if(!sasl_global_utils) {
595 sasl_global_utils = _sasl_alloc_utils(gctx, NULL, global_callbacks);
596 if(sasl_global_utils == NULL) return SASL_NOMEM;
597 gctx->sasl_canonusr_global_utils = sasl_global_utils;
598 }
599
600 if (server) {
601 sasl_global_utils = (sasl_utils_t *)gctx->sasl_server_global_utils;
602
603 if(!sasl_global_utils) {
604 sasl_global_utils = _sasl_alloc_utils(gctx, NULL, global_callbacks);
605 if(sasl_global_utils == NULL) return SASL_NOMEM;
606 gctx->sasl_server_global_utils = sasl_global_utils;
607 }
608 }
609
610 /* Init the canon_user plugin */
611 result = _sasl_canonuser_add_plugin(gctx, "INTERNAL",
612 internal_canonuser_init);
613 if(result != SASL_OK) return result;
614
615 if (!gctx->free_mutex)
616 gctx->free_mutex = sasl_MUTEX_ALLOC();
617 if (!gctx->free_mutex) return SASL_FAIL;
618
619 return SASL_OK;
620 }
621 #else
_sasl_common_init(sasl_global_callbacks_t * global_callbacks)622 int _sasl_common_init(sasl_global_callbacks_t *global_callbacks)
623 {
624 int result;
625
626 /* Setup the global utilities */
627 if(!sasl_global_utils) {
628 sasl_global_utils = _sasl_alloc_utils(NULL, global_callbacks);
629 if(sasl_global_utils == NULL) return SASL_NOMEM;
630 }
631
632 /* Init the canon_user plugin */
633 result = sasl_canonuser_add_plugin("INTERNAL", internal_canonuser_init);
634 if(result != SASL_OK) return result;
635
636 if (!free_mutex)
637 free_mutex = sasl_MUTEX_ALLOC();
638 if (!free_mutex) return SASL_FAIL;
639
640 return SASL_OK;
641 }
642 #endif /* _SUN_SDK_ */
643
644 /* dispose connection state, sets it to NULL
645 * checks for pointer to NULL
646 */
sasl_dispose(sasl_conn_t ** pconn)647 void sasl_dispose(sasl_conn_t **pconn)
648 {
649 int result;
650 #ifdef _SUN_SDK_
651 _sasl_global_context_t *gctx;
652 void *free_mutex;
653 #endif /* _SUN_SDK_ */
654
655 if (! pconn) return;
656 if (! *pconn) return;
657
658 /* serialize disposes. this is necessary because we can't
659 dispose of conn->mutex if someone else is locked on it */
660 #ifdef _SUN_SDK_
661 gctx = (*pconn)->gctx;
662 free_mutex = gctx->free_mutex;
663 #endif /* _SUN_SDK_ */
664 result = sasl_MUTEX_LOCK(free_mutex);
665 if (result!=SASL_OK) return;
666
667 /* *pconn might have become NULL by now */
668 #ifdef _SUN_SDK_
669 if (! (*pconn)) {
670 sasl_MUTEX_UNLOCK(free_mutex);
671 return;
672 }
673 #else
674 if (! (*pconn)) return;
675 #endif /* _SUN_SDK_ */
676
677 (*pconn)->destroy_conn(*pconn);
678 sasl_FREE(*pconn);
679 *pconn=NULL;
680
681 sasl_MUTEX_UNLOCK(free_mutex);
682 }
683
_sasl_conn_dispose(sasl_conn_t * conn)684 void _sasl_conn_dispose(sasl_conn_t *conn) {
685 #ifdef _SUN_SDK_
686 const _sasl_global_context_t *gctx = conn->gctx;
687 #endif /* _SUN_SDK_ */
688
689 if (conn->serverFQDN)
690 sasl_FREE(conn->serverFQDN);
691
692 if (conn->external.auth_id)
693 sasl_FREE(conn->external.auth_id);
694
695 if(conn->encode_buf) {
696 if(conn->encode_buf->data) sasl_FREE(conn->encode_buf->data);
697 sasl_FREE(conn->encode_buf);
698 }
699
700 if(conn->error_buf)
701 sasl_FREE(conn->error_buf);
702
703 if(conn->errdetail_buf)
704 sasl_FREE(conn->errdetail_buf);
705
706 if(conn->decode_buf)
707 sasl_FREE(conn->decode_buf);
708
709 if(conn->mechlist_buf)
710 sasl_FREE(conn->mechlist_buf);
711
712 if(conn->service)
713 sasl_FREE(conn->service);
714
715 /* oparams sub-members should be freed by the plugin, in so much
716 * as they were allocated by the plugin */
717 }
718
719
720 /* get property from SASL connection state
721 * propnum -- property number
722 * pvalue -- pointer to value
723 * returns:
724 * SASL_OK -- no error
725 * SASL_NOTDONE -- property not available yet
726 * SASL_BADPARAM -- bad property number
727 */
sasl_getprop(sasl_conn_t * conn,int propnum,const void ** pvalue)728 int sasl_getprop(sasl_conn_t *conn, int propnum, const void **pvalue)
729 {
730 int result = SASL_OK;
731 sasl_getopt_t *getopt;
732 void *context;
733
734 if (! conn) return SASL_BADPARAM;
735 if (! pvalue) PARAMERROR(conn);
736
737 switch(propnum)
738 {
739 case SASL_SSF:
740 #ifdef _INTEGRATED_SOLARIS_
741 if (!conn->sun_reg)
742 conn->oparams.mech_ssf = 0;
743 #endif /* _INTEGRATED_SOLARIS_ */
744 *(sasl_ssf_t **)pvalue= &conn->oparams.mech_ssf;
745 break;
746 case SASL_MAXOUTBUF:
747 *(unsigned **)pvalue = &conn->oparams.maxoutbuf;
748 break;
749 case SASL_GETOPTCTX:
750 result = _sasl_getcallback(conn, SASL_CB_GETOPT, &getopt, &context);
751 if(result != SASL_OK) break;
752
753 *(void **)pvalue = context;
754 break;
755 case SASL_CALLBACK:
756 *(const sasl_callback_t **)pvalue = conn->callbacks;
757 break;
758 case SASL_IPLOCALPORT:
759 if(conn->got_ip_local)
760 *(const char **)pvalue = conn->iplocalport;
761 else {
762 *(const char **)pvalue = NULL;
763 result = SASL_NOTDONE;
764 }
765 break;
766 case SASL_IPREMOTEPORT:
767 if(conn->got_ip_remote)
768 *(const char **)pvalue = conn->ipremoteport;
769 else {
770 *(const char **)pvalue = NULL;
771 result = SASL_NOTDONE;
772 }
773 break;
774 case SASL_USERNAME:
775 if(! conn->oparams.user)
776 result = SASL_NOTDONE;
777 else
778 *((const char **)pvalue) = conn->oparams.user;
779 break;
780 case SASL_AUTHUSER:
781 if(! conn->oparams.authid)
782 result = SASL_NOTDONE;
783 else
784 *((const char **)pvalue) = conn->oparams.authid;
785 break;
786 case SASL_SERVERFQDN:
787 *((const char **)pvalue) = conn->serverFQDN;
788 break;
789 case SASL_DEFUSERREALM:
790 if(conn->type != SASL_CONN_SERVER) result = SASL_BADPROT;
791 else
792 *((const char **)pvalue) = ((sasl_server_conn_t *)conn)->user_realm;
793 break;
794 case SASL_SERVICE:
795 *((const char **)pvalue) = conn->service;
796 break;
797 case SASL_AUTHSOURCE: /* name of plugin (not name of mech) */
798 if(conn->type == SASL_CONN_CLIENT) {
799 if(!((sasl_client_conn_t *)conn)->mech) {
800 result = SASL_NOTDONE;
801 break;
802 }
803 *((const char **)pvalue) =
804 ((sasl_client_conn_t *)conn)->mech->plugname;
805 } else if (conn->type == SASL_CONN_SERVER) {
806 if(!((sasl_server_conn_t *)conn)->mech) {
807 result = SASL_NOTDONE;
808 break;
809 }
810 *((const char **)pvalue) =
811 ((sasl_server_conn_t *)conn)->mech->plugname;
812 } else {
813 result = SASL_BADPARAM;
814 }
815 break;
816 case SASL_MECHNAME: /* name of mech */
817 if(conn->type == SASL_CONN_CLIENT) {
818 if(!((sasl_client_conn_t *)conn)->mech) {
819 result = SASL_NOTDONE;
820 break;
821 }
822 *((const char **)pvalue) =
823 ((sasl_client_conn_t *)conn)->mech->plug->mech_name;
824 } else if (conn->type == SASL_CONN_SERVER) {
825 if(!((sasl_server_conn_t *)conn)->mech) {
826 result = SASL_NOTDONE;
827 break;
828 }
829 *((const char **)pvalue) =
830 ((sasl_server_conn_t *)conn)->mech->plug->mech_name;
831 } else {
832 result = SASL_BADPARAM;
833 }
834
835 if(!(*pvalue) && result == SASL_OK) result = SASL_NOTDONE;
836 break;
837 case SASL_PLUGERR:
838 *((const char **)pvalue) = conn->error_buf;
839 break;
840 case SASL_SSF_EXTERNAL:
841 *((const sasl_ssf_t **)pvalue) = &conn->external.ssf;
842 break;
843 case SASL_AUTH_EXTERNAL:
844 *((const char **)pvalue) = conn->external.auth_id;
845 break;
846 case SASL_SEC_PROPS:
847 *((const sasl_security_properties_t **)pvalue) = &conn->props;
848 break;
849 default:
850 result = SASL_BADPARAM;
851 }
852
853 if(result == SASL_BADPARAM) {
854 PARAMERROR(conn);
855 } else if(result == SASL_NOTDONE) {
856 #ifdef _SUN_SDK_
857 _sasl_log(conn, SASL_LOG_NONE,
858 "Information that was requested is not yet available.");
859 #else
860 sasl_seterror(conn, SASL_NOLOG,
861 "Information that was requested is not yet available.");
862 #endif /* _SUN_SDK_ */
863 RETURN(conn, result);
864 } else if(result != SASL_OK) {
865 INTERROR(conn, result);
866 } else
867 RETURN(conn, result);
868 #ifdef _SUN_SDK_
869 return SASL_OK;
870 #endif /* _SUN_SDK_ */
871 }
872
873 /* set property in SASL connection state
874 * returns:
875 * SASL_OK -- value set
876 * SASL_BADPARAM -- invalid property or value
877 */
sasl_setprop(sasl_conn_t * conn,int propnum,const void * value)878 int sasl_setprop(sasl_conn_t *conn, int propnum, const void *value)
879 {
880 int result = SASL_OK;
881 char *str;
882 #ifdef _SUN_SDK_
883 const _sasl_global_context_t *gctx;
884 #endif /* _SUN_SDK_ */
885
886 /* make sure the sasl context is valid */
887 if (!conn)
888 return SASL_BADPARAM;
889
890 #ifdef _SUN_SDK_
891 gctx = conn->gctx;
892 #endif /* _SUN_SDK_ */
893
894 switch(propnum)
895 {
896 case SASL_SSF_EXTERNAL:
897 conn->external.ssf = *((sasl_ssf_t *)value);
898 if(conn->type == SASL_CONN_SERVER) {
899 ((sasl_server_conn_t*)conn)->sparams->external_ssf =
900 conn->external.ssf;
901 } else {
902 ((sasl_client_conn_t*)conn)->cparams->external_ssf =
903 conn->external.ssf;
904 }
905 break;
906
907 case SASL_AUTH_EXTERNAL:
908 if(value && strlen(value)) {
909 result = _sasl_strdup(value, &str, NULL);
910 if(result != SASL_OK) MEMERROR(conn);
911 } else {
912 str = NULL;
913 }
914
915 if(conn->external.auth_id)
916 sasl_FREE(conn->external.auth_id);
917
918 conn->external.auth_id = str;
919
920 break;
921
922 case SASL_DEFUSERREALM:
923 if(conn->type != SASL_CONN_SERVER) {
924 #ifdef _SUN_SDK_
925 _sasl_log(conn, SASL_LOG_WARN,
926 "Tried to set realm on non-server connection");
927 #else
928 sasl_seterror(conn, 0, "Tried to set realm on non-server connection");
929 #endif /* _SUN_SDK_ */
930 result = SASL_BADPROT;
931 break;
932 }
933
934 if(value && strlen(value)) {
935 result = _sasl_strdup(value, &str, NULL);
936 if(result != SASL_OK) MEMERROR(conn);
937 } else {
938 PARAMERROR(conn);
939 }
940
941 if(((sasl_server_conn_t *)conn)->user_realm)
942 sasl_FREE(((sasl_server_conn_t *)conn)->user_realm);
943
944 ((sasl_server_conn_t *)conn)->user_realm = str;
945 ((sasl_server_conn_t *)conn)->sparams->user_realm = str;
946
947 break;
948
949 case SASL_SEC_PROPS:
950 {
951 sasl_security_properties_t *props = (sasl_security_properties_t *)value;
952
953 if(props->maxbufsize == 0 && props->min_ssf != 0) {
954 #ifdef _SUN_SDK_
955 _sasl_log(conn, SASL_LOG_ERR,
956 "Attempt to disable security layers (maxoutbuf == 0) with min_ssf > 0");
957 #else
958 sasl_seterror(conn, 0,
959 "Attempt to disable security layers (maxoutbuf == 0) with min_ssf > 0");
960 #endif /* _SUN_SDK_ */
961 RETURN(conn, SASL_TOOWEAK);
962 }
963
964 conn->props = *props;
965
966 if(conn->type == SASL_CONN_SERVER) {
967 ((sasl_server_conn_t*)conn)->sparams->props = *props;
968 } else {
969 ((sasl_client_conn_t*)conn)->cparams->props = *props;
970 }
971
972 break;
973 }
974
975 case SASL_IPREMOTEPORT:
976 {
977 const char *ipremoteport = (const char *)value;
978 if(!value) {
979 conn->got_ip_remote = 0;
980 #ifdef _SUN_SDK_
981 } else if (strlen(ipremoteport) >= sizeof (conn->ipremoteport)) {
982 RETURN(conn, SASL_BADPARAM);
983 #endif /* _SUN_SDK_ */
984 } else if (_sasl_ipfromstring(ipremoteport, NULL, 0)
985 != SASL_OK) {
986 #ifdef _SUN_SDK_
987 _sasl_log(conn, SASL_LOG_ERR, "Bad IPREMOTEPORT value");
988 #else
989 sasl_seterror(conn, 0, "Bad IPREMOTEPORT value");
990 #endif /* _SUN_SDK_ */
991 RETURN(conn, SASL_BADPARAM);
992 } else {
993 strcpy(conn->ipremoteport, ipremoteport);
994 conn->got_ip_remote = 1;
995 }
996
997 if(conn->got_ip_remote) {
998 if(conn->type == SASL_CONN_CLIENT) {
999 ((sasl_client_conn_t *)conn)->cparams->ipremoteport
1000 = conn->ipremoteport;
1001 ((sasl_client_conn_t *)conn)->cparams->ipremlen =
1002 strlen(conn->ipremoteport);
1003 } else if (conn->type == SASL_CONN_SERVER) {
1004 ((sasl_server_conn_t *)conn)->sparams->ipremoteport
1005 = conn->ipremoteport;
1006 ((sasl_server_conn_t *)conn)->sparams->ipremlen =
1007 strlen(conn->ipremoteport);
1008 }
1009 } else {
1010 if(conn->type == SASL_CONN_CLIENT) {
1011 ((sasl_client_conn_t *)conn)->cparams->ipremoteport
1012 = NULL;
1013 ((sasl_client_conn_t *)conn)->cparams->ipremlen = 0;
1014 } else if (conn->type == SASL_CONN_SERVER) {
1015 ((sasl_server_conn_t *)conn)->sparams->ipremoteport
1016 = NULL;
1017 ((sasl_server_conn_t *)conn)->sparams->ipremlen = 0;
1018 }
1019 }
1020
1021 break;
1022 }
1023
1024 case SASL_IPLOCALPORT:
1025 {
1026 const char *iplocalport = (const char *)value;
1027 if(!value) {
1028 conn->got_ip_local = 0;
1029 #ifdef _SUN_SDK_
1030 } else if (strlen(iplocalport) >= sizeof (conn->iplocalport)) {
1031 RETURN(conn, SASL_BADPARAM);
1032 #endif /* _SUN_SDK_ */
1033 } else if (_sasl_ipfromstring(iplocalport, NULL, 0)
1034 != SASL_OK) {
1035 #ifdef _SUN_SDK_
1036 _sasl_log(conn, SASL_LOG_ERR, "Bad IPLOCALPORT value");
1037 #else
1038 sasl_seterror(conn, 0, "Bad IPLOCALPORT value");
1039 #endif /* _SUN_SDK_ */
1040 RETURN(conn, SASL_BADPARAM);
1041 } else {
1042 strcpy(conn->iplocalport, iplocalport);
1043 conn->got_ip_local = 1;
1044 }
1045
1046 if(conn->got_ip_local) {
1047 if(conn->type == SASL_CONN_CLIENT) {
1048 ((sasl_client_conn_t *)conn)->cparams->iplocalport
1049 = conn->iplocalport;
1050 ((sasl_client_conn_t *)conn)->cparams->iploclen
1051 = strlen(conn->iplocalport);
1052 } else if (conn->type == SASL_CONN_SERVER) {
1053 ((sasl_server_conn_t *)conn)->sparams->iplocalport
1054 = conn->iplocalport;
1055 ((sasl_server_conn_t *)conn)->sparams->iploclen
1056 = strlen(conn->iplocalport);
1057 }
1058 } else {
1059 if(conn->type == SASL_CONN_CLIENT) {
1060 ((sasl_client_conn_t *)conn)->cparams->iplocalport
1061 = NULL;
1062 ((sasl_client_conn_t *)conn)->cparams->iploclen = 0;
1063 } else if (conn->type == SASL_CONN_SERVER) {
1064 ((sasl_server_conn_t *)conn)->sparams->iplocalport
1065 = NULL;
1066 ((sasl_server_conn_t *)conn)->sparams->iploclen = 0;
1067 }
1068 }
1069 break;
1070 }
1071
1072 default:
1073 #ifdef _SUN_SDK_
1074 _sasl_log(conn, SASL_LOG_WARN, "Unknown parameter type");
1075 #else
1076 sasl_seterror(conn, 0, "Unknown parameter type");
1077 #endif /* _SUN_SDK_ */
1078 result = SASL_BADPARAM;
1079 }
1080
1081 RETURN(conn, result);
1082 }
1083
1084 /* this is apparently no longer a user function */
sasl_usererr(int saslerr)1085 static int sasl_usererr(int saslerr)
1086 {
1087 /* Hide the difference in a username failure and a password failure */
1088 if (saslerr == SASL_NOUSER)
1089 return SASL_BADAUTH;
1090
1091 /* otherwise return the error given; no transform necessary */
1092 return saslerr;
1093 }
1094
1095 #ifdef _INTEGRATED_SOLARIS_
free_err_tsd(void * key)1096 static void free_err_tsd(void *key)
1097 {
1098 free(key);
1099 }
1100 #endif /* _INTEGRATED_SOLARIS_ */
1101
sasl_errstring(int saslerr,const char * langlist,const char ** outlang)1102 const char *sasl_errstring(int saslerr,
1103 #ifdef _SUN_SDK_
1104 const char *langlist,
1105 #else
1106 const char *langlist __attribute__((unused)),
1107 #endif /* _SUN_SDK_ */
1108 const char **outlang)
1109 {
1110 #ifdef _INTEGRATED_SOLARIS_
1111 const char *s;
1112 const char *s_locale;
1113 char *s_utf8;
1114 void *tsd;
1115
1116 if (outlang) *outlang="i-default";
1117 #else
1118 if (outlang) *outlang="en-us";
1119 #endif /* _INTEGRATED_SOLARIS_ */
1120
1121 #ifdef _INTEGRATED_SOLARIS_
1122 switch(saslerr)
1123 {
1124 case SASL_CONTINUE: s = gettext("another step is needed in authentication");
1125 break;
1126 case SASL_OK: s = gettext("successful result");
1127 break;
1128 case SASL_FAIL: s = gettext("generic failure");
1129 break;
1130 case SASL_NOMEM: s = gettext("no memory available");
1131 break;
1132 case SASL_BUFOVER: s = gettext("overflowed buffer");
1133 break;
1134 case SASL_NOMECH: s = gettext("no mechanism available");
1135 break;
1136 case SASL_BADPROT: s = gettext("bad protocol / cancel");
1137 break;
1138 case SASL_NOTDONE: s = gettext("can't request info until later in exchange");
1139 break;
1140 case SASL_BADPARAM: s = gettext("invalid parameter supplied");
1141 break;
1142 case SASL_TRYAGAIN: s = gettext("transient failure (e.g., weak key)");
1143 break;
1144 case SASL_BADMAC: s = gettext("integrity check failed");
1145 break;
1146 case SASL_NOTINIT: s = gettext("SASL library not initialized");
1147 break;
1148 /* -- client only codes -- */
1149 case SASL_INTERACT: s = gettext("needs user interaction");
1150 break;
1151 case SASL_BADSERV: s = gettext("server failed mutual authentication step");
1152 break;
1153 case SASL_WRONGMECH: s = gettext("mechanism doesn't support requested feature");
1154 break;
1155 /* -- server only codes -- */
1156 case SASL_BADAUTH: s = gettext("authentication failure");
1157 break;
1158 case SASL_NOAUTHZ: s = gettext("authorization failure");
1159 break;
1160 case SASL_TOOWEAK: s = gettext("mechanism too weak for this user");
1161 break;
1162 case SASL_ENCRYPT: s = gettext("encryption needed to use mechanism");
1163 break;
1164 case SASL_TRANS: s = gettext("One time use of a plaintext password will enable requested mechanism for user");
1165 break;
1166 case SASL_EXPIRED: s = gettext("passphrase expired, has to be reset");
1167 break;
1168 case SASL_DISABLED: s = gettext("account disabled");
1169 break;
1170 case SASL_NOUSER: s = gettext("user not found");
1171 break;
1172 case SASL_BADVERS: s = gettext("version mismatch with plug-in");
1173 break;
1174 case SASL_UNAVAIL: s = gettext("remote authentication server unavailable");
1175 break;
1176 case SASL_NOVERIFY: s = gettext("user exists, but no verifier for user");
1177 break;
1178 case SASL_PWLOCK: s = gettext("passphrase locked");
1179 break;
1180 case SASL_NOCHANGE: s = gettext("requested change was not needed");
1181 break;
1182 case SASL_WEAKPASS: s = gettext("passphrase is too weak for security policy");
1183 break;
1184 case SASL_NOUSERPASS: s = gettext("user supplied passwords are not permitted");
1185
1186 break;
1187 default: s = gettext("undefined error!");
1188 break;
1189 }
1190
1191 if (use_locale(langlist, 0))
1192 s_locale = dgettext(TEXT_DOMAIN, s);
1193 else
1194 s_locale = s;
1195
1196 if (s == s_locale)
1197 return s;
1198
1199 s_utf8 = local_to_utf(NULL, s_locale);
1200 if (s_utf8 == NULL)
1201 return s;
1202
1203 if (pthread_key_create_once_np(&errstring_key, free_err_tsd) != 0) {
1204 free(s_utf8);
1205 return s;
1206 }
1207
1208 tsd = pthread_getspecific(errstring_key);
1209 if (tsd != NULL)
1210 free(tsd);
1211 pthread_setspecific(errstring_key, s_utf8);
1212
1213 if (outlang) *outlang="*";
1214 return s_utf8;
1215 #else
1216 switch(saslerr)
1217 {
1218 case SASL_CONTINUE: return "another step is needed in authentication";
1219 case SASL_OK: return "successful result";
1220 case SASL_FAIL: return "generic failure";
1221 case SASL_NOMEM: return "no memory available";
1222 case SASL_BUFOVER: return "overflowed buffer";
1223 case SASL_NOMECH: return "no mechanism available";
1224 case SASL_BADPROT: return "bad protocol / cancel";
1225 case SASL_NOTDONE: return "can't request info until later in exchange";
1226 case SASL_BADPARAM: return "invalid parameter supplied";
1227 case SASL_TRYAGAIN: return "transient failure (e.g., weak key)";
1228 case SASL_BADMAC: return "integrity check failed";
1229 case SASL_NOTINIT: return "SASL library not initialized";
1230 /* -- client only codes -- */
1231 case SASL_INTERACT: return "needs user interaction";
1232 case SASL_BADSERV: return "server failed mutual authentication step";
1233 case SASL_WRONGMECH: return "mechanism doesn't support requested feature";
1234 /* -- server only codes -- */
1235 case SASL_BADAUTH: return "authentication failure";
1236 case SASL_NOAUTHZ: return "authorization failure";
1237 case SASL_TOOWEAK: return "mechanism too weak for this user";
1238 case SASL_ENCRYPT: return "encryption needed to use mechanism";
1239 case SASL_TRANS: return "One time use of a plaintext password will enable requested mechanism for user";
1240 case SASL_EXPIRED: return "passphrase expired, has to be reset";
1241 case SASL_DISABLED: return "account disabled";
1242 case SASL_NOUSER: return "user not found";
1243 case SASL_BADVERS: return "version mismatch with plug-in";
1244 case SASL_UNAVAIL: return "remote authentication server unavailable";
1245 case SASL_NOVERIFY: return "user exists, but no verifier for user";
1246 case SASL_PWLOCK: return "passphrase locked";
1247 case SASL_NOCHANGE: return "requested change was not needed";
1248 case SASL_WEAKPASS: return "passphrase is too weak for security policy";
1249 case SASL_NOUSERPASS: return "user supplied passwords are not permitted";
1250
1251 default: return "undefined error!";
1252 }
1253 #endif /* _INTEGRATED_SOLARIS_ */
1254
1255 }
1256
1257 /* Return the sanitized error detail about the last error that occured for
1258 * a connection */
sasl_errdetail(sasl_conn_t * conn)1259 const char *sasl_errdetail(sasl_conn_t *conn)
1260 {
1261 unsigned need_len;
1262 const char *errstr;
1263 char leader[128];
1264 #ifdef _SUN_SDK_
1265 int ret;
1266 const _sasl_global_context_t *gctx;
1267
1268 if(!conn) return "invalid parameter supplied";
1269
1270 gctx = conn->gctx;
1271 #else
1272 if(!conn) return NULL;
1273 #endif /* _SUN_SDK_ */
1274
1275 errstr = sasl_errstring(conn->error_code, NULL, NULL);
1276 snprintf(leader,128,"SASL(%d): %s: ",
1277 sasl_usererr(conn->error_code), errstr);
1278
1279 need_len = strlen(leader) + strlen(conn->error_buf) + 12;
1280 #ifdef _SUN_SDK_
1281 ret = _buf_alloc(&conn->errdetail_buf, &conn->errdetail_buf_len, need_len);
1282 if (ret != SASL_OK)
1283 return "no memory available";
1284 #else
1285 _buf_alloc(&conn->errdetail_buf, &conn->errdetail_buf_len, need_len);
1286 #endif /* _SUN_SDK_ */
1287
1288 snprintf(conn->errdetail_buf, need_len, "%s%s", leader, conn->error_buf);
1289
1290 return conn->errdetail_buf;
1291 }
1292
1293 #ifdef _INTEGRATED_SOLARIS_
1294 DEFINE_STATIC_MUTEX(reg_mutex);
1295 typedef struct reg_list {
1296 struct reg_list *next;
1297 void *mech;
1298 } reg_list_t;
1299
1300 static reg_list_t *reg_list_base = NULL;
1301
_is_sun_reg(void * mech)1302 int _is_sun_reg(void *mech)
1303 {
1304 reg_list_t *r, *prev;
1305 int is_reg = 0;
1306
1307 LOCK_MUTEX(®_mutex);
1308 for (r = reg_list_base; r != NULL; r = r->next) {
1309 if (r->mech != mech) {
1310 prev = r;
1311 continue;
1312 }
1313 is_reg = 1;
1314 if (r == reg_list_base) {
1315 reg_list_base = reg_list_base->next;
1316 } else {
1317 prev->next = r->next;
1318 }
1319 free(r);
1320 break;
1321 }
1322 UNLOCK_MUTEX(®_mutex);
1323 return (is_reg);
1324 }
1325
1326 static void
_register_plugin(void * arg)1327 _register_plugin(void *arg)
1328 {
1329 reg_list_t *r = (reg_list_t *)calloc(1, sizeof (reg_list_t));
1330
1331 if (r != NULL) {
1332 r->mech = arg;
1333 LOCK_MUTEX(®_mutex);
1334 r->next = reg_list_base;
1335 reg_list_base = r;
1336 UNLOCK_MUTEX(®_mutex);
1337 }
1338 }
1339 #endif /* _INTEGRATED_SOLARIS_ */
1340
1341 /* Note that this needs the global callbacks, so if you don't give getcallbacks
1342 * a sasl_conn_t, you're going to need to pass it yourself (or else we couldn't
1343 * have client and server at the same time */
_sasl_global_getopt(void * context,const char * plugin_name,const char * option,const char ** result,unsigned * len)1344 static int _sasl_global_getopt(void *context,
1345 const char *plugin_name,
1346 const char *option,
1347 const char ** result,
1348 unsigned *len)
1349 {
1350 const sasl_global_callbacks_t * global_callbacks;
1351 const sasl_callback_t *callback;
1352 #ifdef _SUN_SDK_
1353 _sasl_global_context_t *gctx;
1354 #endif /* _SUN_SDK_ */
1355
1356 global_callbacks = (const sasl_global_callbacks_t *) context;
1357
1358 #ifdef _SUN_SDK_
1359 #ifdef _INTEGRATED_SOLARIS_
1360 if (strcmp("reg_sun_plug", option) == 0) {
1361 *result = (const char *)_register_plugin;
1362 *len = 0;
1363 return (SASL_OK);
1364 }
1365 #endif /* _INTEGRATED_SOLARIS_ */
1366
1367 if (global_callbacks)
1368 gctx = global_callbacks->gctx;
1369 else
1370 gctx = _sasl_gbl_ctx();
1371 #endif /* _SUN_SDK_ */
1372
1373 if (global_callbacks && global_callbacks->callbacks) {
1374 for (callback = global_callbacks->callbacks;
1375 callback->id != SASL_CB_LIST_END;
1376 callback++) {
1377 if (callback->id == SASL_CB_GETOPT) {
1378 if (!callback->proc) return SASL_FAIL;
1379 if (((sasl_getopt_t *)(callback->proc))(callback->context,
1380 plugin_name,
1381 option,
1382 result,
1383 len)
1384 == SASL_OK)
1385 return SASL_OK;
1386 }
1387 }
1388 }
1389
1390 /* look it up in our configuration file */
1391 #ifdef _SUN_SDK_
1392 *result = sasl_config_getstring(gctx, option, NULL);
1393 #else
1394 *result = sasl_config_getstring(option, NULL);
1395 #endif /* _SUN_SDK_ */
1396 if (*result != NULL) {
1397 if (len) { *len = strlen(*result); }
1398 return SASL_OK;
1399 }
1400
1401 return SASL_FAIL;
1402 }
1403
1404 static int
_sasl_conn_getopt(void * context,const char * plugin_name,const char * option,const char ** result,unsigned * len)1405 _sasl_conn_getopt(void *context,
1406 const char *plugin_name,
1407 const char *option,
1408 const char ** result,
1409 unsigned *len)
1410 {
1411 sasl_conn_t * conn;
1412 const sasl_callback_t *callback;
1413
1414 if (! context)
1415 return SASL_BADPARAM;
1416
1417 conn = (sasl_conn_t *) context;
1418
1419 if (conn->callbacks)
1420 for (callback = conn->callbacks;
1421 callback->id != SASL_CB_LIST_END;
1422 callback++)
1423 if (callback->id == SASL_CB_GETOPT
1424 && (((sasl_getopt_t *)(callback->proc))(callback->context,
1425 plugin_name,
1426 option,
1427 result,
1428 len)
1429 == SASL_OK))
1430 return SASL_OK;
1431
1432 /* If we made it here, we didn't find an appropriate callback
1433 * in the connection's callback list, or the callback we did
1434 * find didn't return SASL_OK. So we attempt to use the
1435 * global callback for this connection... */
1436 return _sasl_global_getopt((void *)conn->global_callbacks,
1437 plugin_name,
1438 option,
1439 result,
1440 len);
1441 }
1442
1443 #ifdef HAVE_SYSLOG
1444 /* this is the default logging */
_sasl_syslog(void * context,int priority,const char * message)1445 static int _sasl_syslog(void *context __attribute__((unused)),
1446 int priority,
1447 const char *message)
1448 {
1449 int syslog_priority;
1450
1451 /* set syslog priority */
1452 switch(priority) {
1453 case SASL_LOG_NONE:
1454 return SASL_OK;
1455 break;
1456 case SASL_LOG_ERR:
1457 syslog_priority = LOG_ERR;
1458 break;
1459 case SASL_LOG_WARN:
1460 syslog_priority = LOG_WARNING;
1461 break;
1462 case SASL_LOG_NOTE:
1463 case SASL_LOG_FAIL:
1464 syslog_priority = LOG_NOTICE;
1465 break;
1466 case SASL_LOG_PASS:
1467 case SASL_LOG_TRACE:
1468 case SASL_LOG_DEBUG:
1469 default:
1470 syslog_priority = LOG_DEBUG;
1471 break;
1472 }
1473
1474 /* do the syslog call. do not need to call openlog */
1475 syslog(syslog_priority | LOG_AUTH, "%s", message);
1476
1477 return SASL_OK;
1478 }
1479 #endif /* HAVE_SYSLOG */
1480
1481 static int
_sasl_getsimple(void * context,int id,const char ** result,size_t * len)1482 _sasl_getsimple(void *context,
1483 int id,
1484 const char ** result,
1485 size_t *len)
1486 {
1487 const char *userid;
1488 #ifndef _SUN_SDK_
1489 sasl_conn_t *conn;
1490 #endif /* _SUN_SDK_ */
1491
1492 if (! context || ! result) return SASL_BADPARAM;
1493
1494 #ifndef _SUN_SDK_
1495 conn = (sasl_conn_t *)context;
1496 #endif /* _SUN_SDK_ */
1497
1498 switch(id) {
1499 case SASL_CB_AUTHNAME:
1500 #ifdef _INTEGRATED_SOLARIS_
1501 userid = getenv("LOGNAME");
1502 if (userid != NULL) {
1503 *result = userid;
1504 if (len) *len = strlen(userid);
1505 return SASL_OK;
1506 }
1507 #else
1508 userid = getenv("USER");
1509 if (userid != NULL) {
1510 *result = userid;
1511 if (len) *len = strlen(userid);
1512 return SASL_OK;
1513 }
1514 userid = getenv("USERNAME");
1515 if (userid != NULL) {
1516 *result = userid;
1517 if (len) *len = strlen(userid);
1518 return SASL_OK;
1519 }
1520 #endif /* _INTEGRATED_SOLARIS_ */
1521 #ifdef WIN32
1522 /* for win32, try using the GetUserName standard call */
1523 {
1524 DWORD i;
1525 BOOL rval;
1526 static char sender[128];
1527
1528 i = sizeof(sender);
1529 rval = GetUserName(sender, &i);
1530 if ( rval) { /* got a userid */
1531 *result = sender;
1532 if (len) *len = strlen(sender);
1533 return SASL_OK;
1534 }
1535 }
1536 #endif /* WIN32 */
1537 return SASL_FAIL;
1538 default:
1539 return SASL_BADPARAM;
1540 }
1541 }
1542
1543 static int
_sasl_verifyfile(void * context,char * file,int type)1544 _sasl_verifyfile(void *context __attribute__((unused)),
1545 char *file __attribute__((unused)),
1546 int type __attribute__((unused)))
1547 {
1548 /* always say ok */
1549 return SASL_OK;
1550 }
1551
1552
1553 static int
_sasl_proxy_policy(sasl_conn_t * conn,void * context,const char * requested_user,unsigned rlen,const char * auth_identity,unsigned alen,const char * def_realm,unsigned urlen,struct propctx * propctx)1554 _sasl_proxy_policy(sasl_conn_t *conn,
1555 void *context __attribute__((unused)),
1556 const char *requested_user, unsigned rlen,
1557 const char *auth_identity, unsigned alen,
1558 const char *def_realm __attribute__((unused)),
1559 unsigned urlen __attribute__((unused)),
1560 struct propctx *propctx __attribute__((unused)))
1561 {
1562 if (!conn)
1563 return SASL_BADPARAM;
1564
1565 if (!requested_user || *requested_user == '\0')
1566 return SASL_OK;
1567
1568 if (!auth_identity || !requested_user || rlen != alen ||
1569 (memcmp(auth_identity, requested_user, rlen) != 0)) {
1570 #ifdef _INTEGRATED_SOLARIS_
1571 sasl_seterror(conn, 0,
1572 gettext("Requested identity not authenticated identity"));
1573 #else
1574 sasl_seterror(conn, 0,
1575 "Requested identity not authenticated identity");
1576 #endif /* _INTEGRATED_SOLARIS_ */
1577 RETURN(conn, SASL_BADAUTH);
1578 }
1579
1580 return SASL_OK;
1581 }
1582
_sasl_getcallback(sasl_conn_t * conn,unsigned long callbackid,int (** pproc)(),void ** pcontext)1583 int _sasl_getcallback(sasl_conn_t * conn,
1584 unsigned long callbackid,
1585 int (**pproc)(),
1586 void **pcontext)
1587 {
1588 const sasl_callback_t *callback;
1589
1590 if (!pproc || !pcontext)
1591 PARAMERROR(conn);
1592
1593 /* Some callbacks are always provided by the library */
1594 switch (callbackid) {
1595 case SASL_CB_LIST_END:
1596 /* Nothing ever gets to provide this */
1597 INTERROR(conn, SASL_FAIL);
1598 #ifdef _SUN_SDK_
1599 break;
1600 #endif /* _SUN_SDK_ */
1601 case SASL_CB_GETOPT:
1602 if (conn) {
1603 *pproc = &_sasl_conn_getopt;
1604 *pcontext = conn;
1605 } else {
1606 *pproc = &_sasl_global_getopt;
1607 *pcontext = NULL;
1608 }
1609 return SASL_OK;
1610 }
1611
1612 /* If it's not always provided by the library, see if there's
1613 * a version provided by the application for this connection... */
1614 if (conn && conn->callbacks) {
1615 for (callback = conn->callbacks; callback->id != SASL_CB_LIST_END;
1616 callback++) {
1617 if (callback->id == callbackid) {
1618 *pproc = callback->proc;
1619 *pcontext = callback->context;
1620 if (callback->proc) {
1621 return SASL_OK;
1622 } else {
1623 return SASL_INTERACT;
1624 }
1625 }
1626 }
1627 }
1628
1629 /* And, if not for this connection, see if there's one
1630 * for all {server,client} connections... */
1631 if (conn && conn->global_callbacks && conn->global_callbacks->callbacks) {
1632 for (callback = conn->global_callbacks->callbacks;
1633 callback->id != SASL_CB_LIST_END;
1634 callback++) {
1635 if (callback->id == callbackid) {
1636 *pproc = callback->proc;
1637 *pcontext = callback->context;
1638 if (callback->proc) {
1639 return SASL_OK;
1640 } else {
1641 return SASL_INTERACT;
1642 }
1643 }
1644 }
1645 }
1646
1647 /* Otherwise, see if the library provides a default callback. */
1648 switch (callbackid) {
1649 #ifdef HAVE_SYSLOG
1650 case SASL_CB_LOG:
1651 *pproc = (int (*)()) &_sasl_syslog;
1652 *pcontext = NULL;
1653 return SASL_OK;
1654 #endif /* HAVE_SYSLOG */
1655 case SASL_CB_GETPATH:
1656 *pproc = (int (*)()) &_sasl_getpath;
1657 *pcontext = NULL;
1658 return SASL_OK;
1659 case SASL_CB_AUTHNAME:
1660 *pproc = (int (*)()) &_sasl_getsimple;
1661 *pcontext = conn;
1662 return SASL_OK;
1663 case SASL_CB_VERIFYFILE:
1664 *pproc = & _sasl_verifyfile;
1665 *pcontext = NULL;
1666 return SASL_OK;
1667 case SASL_CB_PROXY_POLICY:
1668 *pproc = (int (*)()) &_sasl_proxy_policy;
1669 *pcontext = NULL;
1670 return SASL_OK;
1671 }
1672
1673 /* Unable to find a callback... */
1674 *pproc = NULL;
1675 *pcontext = NULL;
1676 #ifdef _SUN_SDK_
1677 if (callbackid != SASL_CB_LANGUAGE)
1678 _sasl_log(conn, SASL_LOG_NONE, "Unable to find a callback: %d", callbackid);
1679 #else
1680 sasl_seterror(conn, SASL_NOLOG, "Unable to find a callback: %d", callbackid);
1681 #endif /* _SUN_SDK_ */
1682 RETURN(conn,SASL_FAIL);
1683 }
1684
1685
1686 #ifdef _SUN_SDK_
1687 static void ___sasl_log (const _sasl_global_context_t *gctx,
1688 sasl_log_t *log_cb, void *log_ctx,
1689 int level, const char *fmt, va_list ap);
1690 #endif /* _SUN_SDK_ */
1691 /*
1692 * This function is typically called from a plugin.
1693 * It creates a string from the formatting and varargs given
1694 * and calls the logging callback (syslog by default)
1695 *
1696 * %m will parse the value in the next argument as an errno string
1697 * %z will parse the next argument as a SASL error code.
1698 */
1699
1700 void
_sasl_log(sasl_conn_t * conn,int level,const char * fmt,...)1701 _sasl_log (sasl_conn_t *conn,
1702 int level,
1703 const char *fmt,
1704 ...)
1705 #ifdef _SUN_SDK_
1706 {
1707 _sasl_global_context_t *gctx = conn==NULL ? _sasl_gbl_ctx() : conn->gctx;
1708 sasl_log_t *log_cb;
1709 void *log_ctx;
1710 int result;
1711 va_list ap;
1712
1713 /* See if we have a logging callback... */
1714 result = _sasl_getcallback(conn, SASL_CB_LOG, &log_cb, &log_ctx);
1715 if (result == SASL_OK && ! log_cb)
1716 return;
1717
1718 va_start(ap, fmt); /* start varargs */
1719 ___sasl_log(gctx, log_cb, log_ctx, level, fmt, ap);
1720 va_end(ap);
1721 }
1722
1723 void
__sasl_log(const _sasl_global_context_t * gctx,const sasl_callback_t * callbacks,int level,const char * fmt,...)1724 __sasl_log(const _sasl_global_context_t *gctx,
1725 const sasl_callback_t *callbacks,
1726 int level,
1727 const char *fmt,
1728 ...)
1729 {
1730 sasl_log_t *log_cb = NULL;
1731 void *log_ctx = NULL;
1732 int result;
1733 va_list ap;
1734
1735 if (callbacks)
1736 while (callbacks->id != SASL_CB_LIST_END) {
1737 if (callbacks->id == SASL_CB_LOG) {
1738 log_cb = callbacks->proc;
1739 log_ctx = callbacks->context;
1740 break;
1741 }
1742 ++callbacks;
1743 }
1744
1745 if (log_cb == NULL) {
1746 result = _sasl_getcallback(NULL, SASL_CB_LOG, &log_cb, &log_ctx);
1747 if (result != SASL_OK || ! log_cb)
1748 return;
1749 }
1750
1751 if (gctx == NULL)
1752 gctx = _sasl_gbl_ctx();
1753
1754 va_start(ap, fmt); /* start varargs */
1755 ___sasl_log(gctx, log_cb, log_ctx, level, fmt, ap);
1756 va_end(ap);
1757 }
1758
1759 static void
___sasl_log(const _sasl_global_context_t * gctx,sasl_log_t * log_cb,void * log_ctx,int level,const char * fmt,va_list ap)1760 ___sasl_log(const _sasl_global_context_t *gctx,
1761 sasl_log_t *log_cb,
1762 void *log_ctx,
1763 int level,
1764 const char *fmt,
1765 va_list ap)
1766 #endif /* _SUN_SDK_ */
1767 {
1768 char *out=(char *) sasl_ALLOC(250);
1769 size_t alloclen=100; /* current allocated length */
1770 size_t outlen=0; /* current length of output buffer */
1771 size_t formatlen;
1772 size_t pos=0; /* current position in format string */
1773 int result;
1774 #ifndef _SUN_SDK_
1775 sasl_log_t *log_cb;
1776 void *log_ctx;
1777 #endif /* !_SUN_SDK_ */
1778
1779 int ival;
1780 char *cval;
1781 #ifndef _SUN_SDK_
1782 va_list ap; /* varargs thing */
1783 #endif /* !_SUN_SDK_ */
1784
1785 if(!fmt) goto done;
1786 if(!out) return;
1787
1788 formatlen = strlen(fmt);
1789
1790 #ifndef _SUN_SDK_
1791 /* See if we have a logging callback... */
1792 result = _sasl_getcallback(conn, SASL_CB_LOG, &log_cb, &log_ctx);
1793 if (result == SASL_OK && ! log_cb)
1794 result = SASL_FAIL;
1795 if (result != SASL_OK) goto done;
1796
1797 va_start(ap, fmt); /* start varargs */
1798 #endif /* !_SUN_SDK_ */
1799
1800 while(pos<formatlen)
1801 {
1802 if (fmt[pos]!='%') /* regular character */
1803 {
1804 result = _buf_alloc(&out, &alloclen, outlen+1);
1805 if (result != SASL_OK) goto done;
1806 out[outlen]=fmt[pos];
1807 outlen++;
1808 pos++;
1809
1810 } else { /* formating thing */
1811 int done=0;
1812 char frmt[10];
1813 int frmtpos=1;
1814 char tempbuf[21];
1815 frmt[0]='%';
1816 pos++;
1817
1818 while (done==0)
1819 {
1820 switch(fmt[pos])
1821 {
1822 case 's': /* need to handle this */
1823 cval = va_arg(ap, char *); /* get the next arg */
1824 result = _sasl_add_string(&out, &alloclen,
1825 &outlen, cval);
1826
1827 if (result != SASL_OK) /* add the string */
1828 goto done;
1829
1830 done=1;
1831 break;
1832
1833 case '%': /* double % output the '%' character */
1834 result = _buf_alloc(&out,&alloclen,outlen+1);
1835 if (result != SASL_OK)
1836 goto done;
1837
1838 out[outlen]='%';
1839 outlen++;
1840 done=1;
1841 break;
1842
1843 case 'm': /* insert the errno string */
1844 result = _sasl_add_string(&out, &alloclen, &outlen,
1845 strerror(va_arg(ap, int)));
1846 if (result != SASL_OK)
1847 goto done;
1848
1849 done=1;
1850 break;
1851
1852 case 'z': /* insert the sasl error string */
1853 result = _sasl_add_string(&out, &alloclen, &outlen,
1854 (char *) sasl_errstring(va_arg(ap, int),NULL,NULL));
1855 if (result != SASL_OK)
1856 goto done;
1857
1858 done=1;
1859 break;
1860
1861 case 'c':
1862 #ifndef _SUN_SDK_
1863 frmt[frmtpos++]=fmt[pos];
1864 frmt[frmtpos]=0;
1865 #endif /* !_SUN_SDK_ */
1866 tempbuf[0] = (char) va_arg(ap, int); /* get the next arg */
1867 tempbuf[1]='\0';
1868
1869 /* now add the character */
1870 result = _sasl_add_string(&out, &alloclen, &outlen, tempbuf);
1871 if (result != SASL_OK)
1872 goto done;
1873
1874 done=1;
1875 break;
1876
1877 case 'd':
1878 case 'i':
1879 frmt[frmtpos++]=fmt[pos];
1880 frmt[frmtpos]=0;
1881 ival = va_arg(ap, int); /* get the next arg */
1882
1883 snprintf(tempbuf,20,frmt,ival); /* have snprintf do the work */
1884 /* now add the string */
1885 result = _sasl_add_string(&out, &alloclen, &outlen, tempbuf);
1886 if (result != SASL_OK)
1887 goto done;
1888
1889 done=1;
1890
1891 break;
1892 default:
1893 frmt[frmtpos++]=fmt[pos]; /* add to the formating */
1894 frmt[frmtpos]=0;
1895 #ifdef _SUN_SDK_
1896 if (frmtpos > sizeof (frmt) - 2)
1897 #else
1898 if (frmtpos>9)
1899 #endif /* _SUN_SDK_ */
1900 done=1;
1901 }
1902 pos++;
1903 if (pos>formatlen)
1904 done=1;
1905 }
1906
1907 }
1908 }
1909
1910 /* put 0 at end */
1911 result = _buf_alloc(&out, &alloclen, outlen+1);
1912 if (result != SASL_OK) goto done;
1913 out[outlen]=0;
1914
1915 va_end(ap);
1916
1917 /* send log message */
1918 result = log_cb(log_ctx, level, out);
1919
1920 done:
1921 if(out) sasl_FREE(out);
1922 }
1923
1924
1925
1926 /* Allocate and Init a sasl_utils_t structure */
1927 #ifdef _SUN_SDK_
1928 sasl_utils_t *
_sasl_alloc_utils(_sasl_global_context_t * gctx,sasl_conn_t * conn,sasl_global_callbacks_t * global_callbacks)1929 _sasl_alloc_utils(_sasl_global_context_t *gctx, sasl_conn_t *conn,
1930 sasl_global_callbacks_t *global_callbacks)
1931 #else
1932 sasl_utils_t *
1933 _sasl_alloc_utils(sasl_conn_t *conn,
1934 sasl_global_callbacks_t *global_callbacks)
1935 #endif /* _SUN_SDK_ */
1936 {
1937 sasl_utils_t *utils;
1938 #ifdef _SUN_SDK_
1939 sasl_allocation_utils_t alloc;
1940 sasl_mutex_utils_t mutex;
1941
1942 LOCK_MUTEX(&malloc_global_mutex);
1943 alloc = gctx->sasl_allocation_utils;
1944 mutex = gctx->sasl_mutex_utils;
1945 UNLOCK_MUTEX(&malloc_global_mutex);
1946 #endif /* _SUN_SDK_ */
1947
1948 /* set util functions - need to do rest*/
1949 #ifdef _SUN_SDK_
1950 utils=alloc.malloc(sizeof(sasl_utils_t));
1951 #else
1952 utils=sasl_ALLOC(sizeof(sasl_utils_t));
1953 #endif /* _SUN_SDK_ */
1954 if (utils==NULL)
1955 return NULL;
1956
1957 utils->conn = conn;
1958
1959 sasl_randcreate(&utils->rpool);
1960
1961 if (conn) {
1962 utils->getopt = &_sasl_conn_getopt;
1963 utils->getopt_context = conn;
1964 } else {
1965 utils->getopt = &_sasl_global_getopt;
1966 utils->getopt_context = global_callbacks;
1967 }
1968
1969 #ifdef _SUN_SDK_
1970 utils->malloc=alloc.malloc;
1971 utils->calloc=alloc.calloc;
1972 utils->realloc=alloc.realloc;
1973 utils->free=alloc.free;
1974
1975 utils->mutex_alloc = mutex.alloc;
1976 utils->mutex_lock = mutex.lock;
1977 utils->mutex_unlock = mutex.unlock;
1978 utils->mutex_free = mutex.free;
1979 #else
1980 utils->malloc=_sasl_allocation_utils.malloc;
1981 utils->calloc=_sasl_allocation_utils.calloc;
1982 utils->realloc=_sasl_allocation_utils.realloc;
1983 utils->free=_sasl_allocation_utils.free;
1984
1985 utils->mutex_alloc = _sasl_mutex_utils.alloc;
1986 utils->mutex_lock = _sasl_mutex_utils.lock;
1987 utils->mutex_unlock = _sasl_mutex_utils.unlock;
1988 utils->mutex_free = _sasl_mutex_utils.free;
1989 #endif /* _SUN_SDK_ */
1990
1991 #ifdef _SUN_SDK_
1992 utils->MD5Init = (void (*)(MD5_CTX *))&MD5Init;
1993 utils->MD5Update= (void (*)
1994 (MD5_CTX *, const unsigned char *, unsigned int ))&MD5Update;
1995 utils->MD5Final = (void (*)(unsigned char [16], MD5_CTX *))&MD5Final;
1996 #else
1997 utils->MD5Init = &_sasl_MD5Init;
1998 utils->MD5Update= &_sasl_MD5Update;
1999 utils->MD5Final = &_sasl_MD5Final;
2000 #endif /* _SUN_SDK_ */
2001 utils->hmac_md5 = &_sasl_hmac_md5;
2002 utils->hmac_md5_init = &_sasl_hmac_md5_init;
2003 utils->hmac_md5_final = &_sasl_hmac_md5_final;
2004 utils->hmac_md5_precalc = &_sasl_hmac_md5_precalc;
2005 utils->hmac_md5_import = &_sasl_hmac_md5_import;
2006 utils->mkchal = &sasl_mkchal;
2007 utils->utf8verify = &sasl_utf8verify;
2008 utils->rand=&sasl_rand;
2009 utils->churn=&sasl_churn;
2010 utils->checkpass=NULL;
2011
2012 utils->encode64=&sasl_encode64;
2013 utils->decode64=&sasl_decode64;
2014
2015 utils->erasebuffer=&sasl_erasebuffer;
2016
2017 utils->getprop=&sasl_getprop;
2018 utils->setprop=&sasl_setprop;
2019
2020 utils->getcallback=&_sasl_getcallback;
2021
2022 utils->log=&_sasl_log;
2023
2024 utils->seterror=&sasl_seterror;
2025
2026 #ifndef macintosh
2027 /* Aux Property Utilities */
2028 utils->prop_new=&prop_new;
2029 utils->prop_dup=&prop_dup;
2030 utils->prop_request=&prop_request;
2031 utils->prop_get=&prop_get;
2032 utils->prop_getnames=&prop_getnames;
2033 utils->prop_clear=&prop_clear;
2034 utils->prop_dispose=&prop_dispose;
2035 utils->prop_format=&prop_format;
2036 utils->prop_set=&prop_set;
2037 utils->prop_setvals=&prop_setvals;
2038 utils->prop_erase=&prop_erase;
2039 #endif
2040
2041 /* Spares */
2042 utils->spare_fptr = NULL;
2043 utils->spare_fptr1 = utils->spare_fptr2 =
2044 utils->spare_fptr3 = NULL;
2045
2046 return utils;
2047 }
2048
2049 int
_sasl_free_utils(const sasl_utils_t ** utils)2050 _sasl_free_utils(const sasl_utils_t ** utils)
2051 {
2052 sasl_utils_t *nonconst;
2053 #ifdef _SUN_SDK_
2054 sasl_free_t *free_func;
2055 #endif /* _SUN_SDK_ */
2056
2057 if(!utils) return SASL_BADPARAM;
2058 if(!*utils) return SASL_OK;
2059
2060 /* I wish we could avoid this cast, it's pretty gratuitous but it
2061 * does make life easier to have it const everywhere else. */
2062 nonconst = (sasl_utils_t *)(*utils);
2063
2064 sasl_randfree(&(nonconst->rpool));
2065 #ifdef _SUN_SDK_
2066 free_func = (*utils)->free;
2067 free_func(nonconst);
2068 #else
2069 sasl_FREE(nonconst);
2070 #endif /* _SUN_SDK_ */
2071
2072 *utils = NULL;
2073 return SASL_OK;
2074 }
2075
sasl_idle(sasl_conn_t * conn)2076 int sasl_idle(sasl_conn_t *conn)
2077 {
2078 if (! conn) {
2079 #ifdef _SUN_SDK_
2080 _sasl_global_context_t *gctx = _sasl_gbl_ctx();
2081
2082 if (gctx->sasl_server_idle_hook
2083 && gctx->sasl_server_idle_hook(NULL))
2084 return 1;
2085 if (gctx->sasl_client_idle_hook
2086 && gctx->sasl_client_idle_hook(NULL))
2087 return 1;
2088 #else
2089 if (_sasl_server_idle_hook
2090 && _sasl_server_idle_hook(NULL))
2091 return 1;
2092 if (_sasl_client_idle_hook
2093 && _sasl_client_idle_hook(NULL))
2094 return 1;
2095 #endif /* _SUN_SDK_ */
2096 return 0;
2097 }
2098
2099 if (conn->idle_hook)
2100 return conn->idle_hook(conn);
2101
2102 return 0;
2103 }
2104
2105 const sasl_callback_t *
_sasl_find_getpath_callback(const sasl_callback_t * callbacks)2106 _sasl_find_getpath_callback(const sasl_callback_t *callbacks)
2107 {
2108 static const sasl_callback_t default_getpath_cb = {
2109 SASL_CB_GETPATH,
2110 &_sasl_getpath,
2111 NULL
2112 };
2113
2114 if (callbacks)
2115 while (callbacks->id != SASL_CB_LIST_END)
2116 {
2117 if (callbacks->id == SASL_CB_GETPATH)
2118 {
2119 return callbacks;
2120 } else {
2121 ++callbacks;
2122 }
2123 }
2124
2125 return &default_getpath_cb;
2126 }
2127
2128 #ifdef _SUN_SDK_
2129 extern const sasl_callback_t *
_sasl_find_getconf_callback(const sasl_callback_t * callbacks)2130 _sasl_find_getconf_callback(const sasl_callback_t *callbacks)
2131 {
2132 static const sasl_callback_t default_getconf_cb = {
2133 SASL_CB_GETCONF,
2134 &_sasl_getconf,
2135 NULL
2136 };
2137
2138 if (callbacks)
2139 while (callbacks->id != SASL_CB_LIST_END)
2140 {
2141 if (callbacks->id == SASL_CB_GETCONF)
2142 {
2143 return callbacks;
2144 } else {
2145 ++callbacks;
2146 }
2147 }
2148
2149 return &default_getconf_cb;
2150 }
2151 #endif /* _SUN_SDK_ */
2152
2153 const sasl_callback_t *
_sasl_find_verifyfile_callback(const sasl_callback_t * callbacks)2154 _sasl_find_verifyfile_callback(const sasl_callback_t *callbacks)
2155 {
2156 static const sasl_callback_t default_verifyfile_cb = {
2157 SASL_CB_VERIFYFILE,
2158 &_sasl_verifyfile,
2159 NULL
2160 };
2161
2162 if (callbacks)
2163 while (callbacks->id != SASL_CB_LIST_END)
2164 {
2165 if (callbacks->id == SASL_CB_VERIFYFILE)
2166 {
2167 return callbacks;
2168 } else {
2169 ++callbacks;
2170 }
2171 }
2172
2173 return &default_verifyfile_cb;
2174 }
2175
2176 /* Basically a conditional call to realloc(), if we need more */
2177 #ifdef _SUN_SDK_
__buf_alloc(const _sasl_global_context_t * gctx,char ** rwbuf,size_t * curlen,size_t newlen)2178 int __buf_alloc(const _sasl_global_context_t *gctx, char **rwbuf,
2179 size_t *curlen, size_t newlen)
2180 #else
2181 int _buf_alloc(char **rwbuf, size_t *curlen, size_t newlen)
2182 #endif /* _SUN_SDK_ */
2183 {
2184 if(!(*rwbuf)) {
2185 *rwbuf = sasl_ALLOC(newlen);
2186 if (*rwbuf == NULL) {
2187 *curlen = 0;
2188 return SASL_NOMEM;
2189 }
2190 *curlen = newlen;
2191 } else if(*rwbuf && *curlen < newlen) {
2192 size_t needed = 2*(*curlen);
2193
2194 while(needed < newlen)
2195 needed *= 2;
2196
2197 *rwbuf = sasl_REALLOC(*rwbuf, needed);
2198
2199 if (*rwbuf == NULL) {
2200 *curlen = 0;
2201 return SASL_NOMEM;
2202 }
2203 *curlen = needed;
2204 }
2205
2206 return SASL_OK;
2207 }
2208
2209 /* for the mac os x cfm glue: this lets the calling function
2210 get pointers to the error buffer without having to touch the sasl_conn_t struct */
_sasl_get_errorbuf(sasl_conn_t * conn,char *** bufhdl,size_t ** lenhdl)2211 void _sasl_get_errorbuf(sasl_conn_t *conn, char ***bufhdl, size_t **lenhdl)
2212 {
2213 *bufhdl = &conn->error_buf;
2214 *lenhdl = &conn->error_buf_len;
2215 }
2216
2217 /* convert an iovec to a single buffer */
2218 #ifdef _SUN_SDK_
_iovec_to_buf(const _sasl_global_context_t * gctx,const struct iovec * vec,unsigned numiov,buffer_info_t ** output)2219 int _iovec_to_buf(const _sasl_global_context_t *gctx, const struct iovec *vec,
2220 unsigned numiov, buffer_info_t **output)
2221 #else
2222 int _iovec_to_buf(const struct iovec *vec,
2223 unsigned numiov, buffer_info_t **output)
2224 #endif /* _SUN_SDK_ */
2225 {
2226 unsigned i;
2227 int ret;
2228 buffer_info_t *out;
2229 char *pos;
2230
2231 if(!vec || !output) return SASL_BADPARAM;
2232
2233 if(!(*output)) {
2234 *output = sasl_ALLOC(sizeof(buffer_info_t));
2235 if(!*output) return SASL_NOMEM;
2236 memset(*output,0,sizeof(buffer_info_t));
2237 }
2238
2239 out = *output;
2240
2241 out->curlen = 0;
2242 for(i=0; i<numiov; i++)
2243 out->curlen += vec[i].iov_len;
2244
2245 ret = _buf_alloc(&out->data, &out->reallen, out->curlen);
2246
2247 if(ret != SASL_OK) return SASL_NOMEM;
2248
2249 memset(out->data, 0, out->reallen);
2250 pos = out->data;
2251
2252 for(i=0; i<numiov; i++) {
2253 memcpy(pos, vec[i].iov_base, vec[i].iov_len);
2254 pos += vec[i].iov_len;
2255 }
2256
2257 return SASL_OK;
2258 }
2259
2260 /* This code might be useful in the future, but it isn't now, so.... */
2261 #if 0
2262 int _sasl_iptostring(const struct sockaddr *addr, socklen_t addrlen,
2263 char *out, unsigned outlen) {
2264 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
2265
2266 if(!addr || !out) return SASL_BADPARAM;
2267
2268 getnameinfo(addr, addrlen, hbuf, sizeof(hbuf), pbuf, sizeof(pbuf),
2269 NI_NUMERICHOST | NI_WITHSCOPEID | NI_NUMERICSERV);
2270
2271 if(outlen < strlen(hbuf) + strlen(pbuf) + 2)
2272 return SASL_BUFOVER;
2273
2274 snprintf(out, outlen, "%s;%s", hbuf, pbuf);
2275
2276 return SASL_OK;
2277 }
2278 #endif
2279
2280 #ifdef _SUN_SDK_
2281 /* An ipv6 address will contain at least two colons */
can_be_ipv6(const char * addr)2282 static int can_be_ipv6(const char *addr)
2283 {
2284 const char *p;
2285
2286 if ((p = strchr(addr, ':')) == NULL)
2287 return (0);
2288
2289 p = strchr(p + 1, ':');
2290
2291 return (p != NULL);
2292 }
2293 #endif /* _SUN_SDK_ */
2294
_sasl_ipfromstring(const char * addr,struct sockaddr * out,socklen_t outlen)2295 int _sasl_ipfromstring(const char *addr,
2296 struct sockaddr *out, socklen_t outlen)
2297 {
2298 int i, j;
2299 struct addrinfo hints, *ai = NULL;
2300 char hbuf[NI_MAXHOST];
2301 #ifdef _SUN_SDK_
2302 const char *start, *end, *p;
2303 int addr_only = 1;
2304 #endif /* _SUN_SDK_ */
2305
2306 /* A NULL out pointer just implies we don't do a copy, just verify it */
2307
2308 if(!addr) return SASL_BADPARAM;
2309
2310 #ifdef _SUN_SDK_
2311 end = strchr(addr, ']');
2312 if (end != NULL) {
2313 /* This an rfc 2732 ipv6 address */
2314 start = strchr(addr, '[');
2315 if (start >= end || start == NULL)
2316 return SASL_BADPARAM;
2317 for (i = 0, p = start + 1; p < end; p++) {
2318 hbuf[i++] = *p;
2319 if (i >= NI_MAXHOST)
2320 return SASL_BADPARAM;
2321 }
2322 p = strchr(end, ':');
2323 if (p == NULL)
2324 p = end + 1;
2325 else
2326 p = p + 1;
2327 } else if (can_be_ipv6(addr) != 0) {
2328 /* Parse the address */
2329 for (i = 0; addr[i] != '\0' && addr[i] != ';'; ) {
2330 hbuf[i] = addr[i];
2331 if (++i >= NI_MAXHOST)
2332 return SASL_BADPARAM;
2333 }
2334 if (addr[i] == ';')
2335 p = &addr[i+1];
2336 else
2337 p = &addr[i];
2338 } else {
2339 for (i = 0; addr[i] != '\0' && addr[i] != ';' && addr[i] != ':'; ) {
2340 hbuf[i] = addr[i];
2341 if (isalpha(addr[i]))
2342 addr_only = 0;
2343 if (++i >= NI_MAXHOST)
2344 return SASL_BADPARAM;
2345 }
2346 if (addr[i] == ';' || addr[i] == ':')
2347 p = &addr[i+1];
2348 else
2349 p = &addr[i];
2350 }
2351 hbuf[i] = '\0';
2352 for (j = 0; p[j] != '\0'; j++)
2353 if (!isdigit((int)(p[j])))
2354 return SASL_BADPARAM;
2355 if (atoi(p) == 0)
2356 p = NULL;
2357 #else
2358 /* Parse the address */
2359 for (i = 0; addr[i] != '\0' && addr[i] != ';'; i++) {
2360 if (i >= NI_MAXHOST)
2361 return SASL_BADPARAM;
2362 hbuf[i] = addr[i];
2363 }
2364 hbuf[i] = '\0';
2365
2366 if (addr[i] == ';')
2367 i++;
2368 /* XXX: Do we need this check? */
2369 for (j = i; addr[j] != '\0'; j++)
2370 if (!isdigit((int)(addr[j])))
2371 return SASL_BADPARAM;
2372 #endif /* _SUN_SDK_ */
2373
2374 memset(&hints, 0, sizeof(hints));
2375 hints.ai_family = PF_UNSPEC;
2376 hints.ai_socktype = SOCK_STREAM;
2377 #ifdef _SUN_SDK_
2378 hints.ai_flags = addr_only ? AI_PASSIVE | AI_NUMERICHOST : AI_PASSIVE;
2379 if (getaddrinfo(hbuf, p, &hints, &ai) != 0)
2380 #else
2381 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
2382 if (getaddrinfo(hbuf, &addr[i], &hints, &ai) != 0)
2383 #endif /* _SUN_SDK_ */
2384 return SASL_BADPARAM;
2385
2386 if (out) {
2387 if (outlen < (socklen_t)ai->ai_addrlen) {
2388 freeaddrinfo(ai);
2389 return SASL_BUFOVER;
2390 }
2391 memcpy(out, ai->ai_addr, ai->ai_addrlen);
2392 }
2393
2394 freeaddrinfo(ai);
2395
2396 return SASL_OK;
2397 }
2398
2399 #ifdef _SUN_SDK_
_sasl_build_mechlist(_sasl_global_context_t * gctx)2400 int _sasl_build_mechlist(_sasl_global_context_t *gctx)
2401 #else
2402 int _sasl_build_mechlist(void)
2403 #endif /* _SUN_SDK_ */
2404 {
2405 int count = 0;
2406 sasl_string_list_t *clist = NULL, *slist = NULL, *olist = NULL;
2407 sasl_string_list_t *p, *q, **last, *p_next;
2408
2409 #ifdef _SUN_SDK_
2410 char **global_mech_list;
2411
2412 LOCK_MUTEX(&global_mutex);
2413
2414 clist = _sasl_client_mechs(gctx);
2415 slist = _sasl_server_mechs(gctx);
2416
2417 global_mech_list = gctx->global_mech_list;
2418 #else
2419 clist = _sasl_client_mechs();
2420 slist = _sasl_server_mechs();
2421 #endif /* _SUN_SDK_ */
2422
2423 if(!clist) {
2424 olist = slist;
2425 } else {
2426 int flag;
2427
2428 /* append slist to clist, and set olist to clist */
2429 for(p = slist; p; p = p_next) {
2430 flag = 0;
2431 p_next = p->next;
2432
2433 last = &clist;
2434 for(q = clist; q; q = q->next) {
2435 if(!strcmp(q->d, p->d)) {
2436 /* They match, set the flag */
2437 flag = 1;
2438 break;
2439 }
2440 last = &(q->next);
2441 }
2442
2443 if(!flag) {
2444 *last = p;
2445 p->next = NULL;
2446 } else {
2447 sasl_FREE(p);
2448 }
2449 }
2450
2451 olist = clist;
2452 }
2453
2454 if(!olist) {
2455 #ifdef _SUN_SDK_
2456 UNLOCK_MUTEX(&global_mutex);
2457 #else
2458 printf ("no olist");
2459 #endif /* _SUN_SDK_ */
2460 return SASL_FAIL;
2461 }
2462
2463 for (p = olist; p; p = p->next) count++;
2464
2465 if(global_mech_list) {
2466 sasl_FREE(global_mech_list);
2467 #ifdef _SUN_SDK_
2468 gctx->global_mech_list = NULL;
2469 #else
2470 global_mech_list = NULL;
2471 #endif /* _SUN_SDK_ */
2472 }
2473
2474 global_mech_list = sasl_ALLOC((count + 1) * sizeof(char *));
2475 if(!global_mech_list) return SASL_NOMEM;
2476
2477 memset(global_mech_list, 0, (count + 1) * sizeof(char *));
2478 #ifdef _SUN_SDK_
2479 gctx->global_mech_list = global_mech_list;
2480 #endif /* _SUN_SDK_ */
2481
2482 count = 0;
2483 for (p = olist; p; p = p_next) {
2484 p_next = p->next;
2485
2486 global_mech_list[count++] = (char *) p->d;
2487
2488 sasl_FREE(p);
2489 }
2490
2491 #ifdef _SUN_SDK_
2492 UNLOCK_MUTEX(&global_mutex);
2493 #endif /* _SUN_SDK_ */
2494
2495 return SASL_OK;
2496 }
2497
sasl_global_listmech(void)2498 const char ** sasl_global_listmech(void)
2499 {
2500 #ifdef _SUN_SDK_
2501 _sasl_global_context_t *gctx = _sasl_gbl_ctx();
2502
2503 return (const char **)gctx->global_mech_list;
2504 #else
2505 return (const char **)global_mech_list;
2506 #endif /* _SUN_SDK_ */
2507 }
2508
sasl_listmech(sasl_conn_t * conn,const char * user,const char * prefix,const char * sep,const char * suffix,const char ** result,unsigned * plen,int * pcount)2509 int sasl_listmech(sasl_conn_t *conn,
2510 const char *user,
2511 const char *prefix,
2512 const char *sep,
2513 const char *suffix,
2514 const char **result,
2515 unsigned *plen,
2516 int *pcount)
2517 {
2518 if(!conn) {
2519 return SASL_BADPARAM;
2520 } else if(conn->type == SASL_CONN_SERVER) {
2521 RETURN(conn, _sasl_server_listmech(conn, user, prefix, sep, suffix,
2522 result, plen, pcount));
2523 } else if (conn->type == SASL_CONN_CLIENT) {
2524 RETURN(conn, _sasl_client_listmech(conn, prefix, sep, suffix,
2525 result, plen, pcount));
2526 }
2527
2528 PARAMERROR(conn);
2529 }
2530
2531 #ifdef _SUN_SDK_
2532 /*
2533 * Creates a context so that libraries may use libsasl independently
2534 * of applications using libsasl.
2535 * Returns NULL on failure.
2536 *
2537 * sasl_free_context frees the context
2538 * To use libsasl independently of the default context, use
2539 * _sasl_server_init() instead of sasl_server_init()
2540 * _sasl_server_new() instead of sasl_server_new()
2541 * _sasl_client_init() instead of sasl_client_init()
2542 * _sasl_client_new() instead of sasl_client_new()
2543 * _sasl_client_add_plugin() instead of sasl_client_add_plugin()
2544 * _sasl_server_add_plugin() instead of sasl_server_add_plugin()
2545 * _sasl_canonuser_add_plugin() instead of sasl_canonuser_add_plugin()
2546 * _sasl_auxprop_add_plugin() instead of sasl_auxprop_add_plugin()
2547 */
2548
sasl_create_context(void)2549 void *sasl_create_context(void)
2550 {
2551 _sasl_global_context_t *gctx;
2552
2553 gctx = (_sasl_global_context_t *)
2554 sasl_sun_ALLOC(sizeof(_sasl_global_context_t));
2555
2556 if (gctx != NULL) {
2557 memset(gctx, 0, sizeof(_sasl_global_context_t));
2558
2559 gctx->server_global_callbacks.gctx = gctx;
2560 gctx->client_global_callbacks.gctx = gctx;
2561 LOCK_MUTEX(&malloc_global_mutex);
2562 gctx->sasl_allocation_utils.malloc = (sasl_malloc_t *)&malloc;
2563 gctx->sasl_allocation_utils.calloc = (sasl_calloc_t *)&calloc;
2564 gctx->sasl_allocation_utils.realloc = (sasl_realloc_t *)&realloc;
2565 gctx->sasl_allocation_utils.free = (sasl_free_t *)&free;
2566 gctx->sasl_mutex_utils.alloc = sasl_mutex_alloc;
2567 gctx->sasl_mutex_utils.lock = sasl_mutex_lock;
2568 gctx->sasl_mutex_utils.unlock = sasl_mutex_unlock;
2569 gctx->sasl_mutex_utils.free = sasl_mutex_free;
2570 UNLOCK_MUTEX(&malloc_global_mutex);
2571 }
2572 return gctx;
2573 }
2574
2575 /* Frees the context created by sasl_create_context() */
sasl_free_context(void * context)2576 void sasl_free_context(void *context)
2577 {
2578 _sasl_dispose_context(context);
2579 if (context != NULL) {
2580 sasl_sun_FREE(context);
2581 }
2582 }
2583
2584 /* Used by both sasl_done() and sasl_free_context() to free context */
_sasl_dispose_context(_sasl_global_context_t * gctx)2585 static void _sasl_dispose_context(_sasl_global_context_t *gctx)
2586 {
2587 if (gctx == NULL)
2588 return;
2589
2590 if (gctx->sasl_server_cleanup_hook &&
2591 gctx->sasl_server_cleanup_hook(gctx) == SASL_OK) {
2592 gctx->sasl_server_idle_hook = NULL;
2593 gctx->sasl_server_cleanup_hook = NULL;
2594 }
2595
2596 if (gctx->sasl_client_cleanup_hook &&
2597 gctx->sasl_client_cleanup_hook(gctx) == SASL_OK) {
2598 gctx->sasl_client_idle_hook = NULL;
2599 gctx->sasl_client_cleanup_hook = NULL;
2600 }
2601
2602 if(gctx->sasl_server_cleanup_hook || gctx->sasl_client_cleanup_hook)
2603 return;
2604
2605 _sasl_canonuser_free(gctx);
2606 _sasl_done_with_plugins(gctx);
2607
2608 sasl_config_free(gctx);
2609
2610 if (gctx->free_mutex != NULL)
2611 sasl_MUTEX_FREE(gctx->free_mutex);
2612 gctx->free_mutex = NULL;
2613
2614 _sasl_free_utils(&(gctx->sasl_server_global_utils));
2615 _sasl_free_utils(&(gctx->sasl_canonusr_global_utils));
2616
2617 LOCK_MUTEX(&global_mutex);
2618 sasl_FREE((void *)gctx->global_mech_list);
2619 gctx->global_mech_list = NULL;
2620 UNLOCK_MUTEX(&global_mutex);
2621
2622 /* in case of another init/done */
2623 gctx->sasl_server_cleanup_hook = NULL;
2624 gctx->sasl_client_cleanup_hook = NULL;
2625
2626 gctx->sasl_client_idle_hook = NULL;
2627 gctx->sasl_server_idle_hook = NULL;
2628 }
2629
_sasl_gbl_ctx(void)2630 _sasl_global_context_t *_sasl_gbl_ctx(void)
2631 {
2632 static _sasl_global_context_t gbl_ctx = {
2633 0, /* sasl_server_active */
2634 NULL, /* mechlist */
2635 NULL, /* splug_path_info */
2636 {NULL, NULL, &gbl_ctx}, /* server_global_callbacks */
2637 NULL, /* sasl_server_cleanup_hook */
2638 NULL, /* sasl_server_idle_hook */
2639 NULL, /* cmechlist */
2640 NULL, /* cplug_path_info */
2641 {NULL, NULL, &gbl_ctx}, /* client_global_callbacks */
2642 0, /* sasl_client_active */
2643 NULL, /* sasl_client_cleanup_hook */
2644 NULL, /* sasl_client_idle_hook */
2645 NULL, /* sasl_server_global_utils */
2646 NULL, /* sasl_client_global_utils */
2647 NULL, /* configlist */
2648 0, /* nconfiglist */
2649 NULL, /* config_path */
2650 0, /* config_last_read */
2651 NULL, /* auxprop_head */
2652 NULL, /* canonuser_head */
2653 NULL, /* global_mech_list */
2654 NULL, /* free_mutex */
2655 {(sasl_malloc_t *)&malloc, (sasl_calloc_t *)&calloc,
2656 (sasl_realloc_t *)&realloc, (sasl_free_t *)&free},
2657 /* sasl_allocation_utils */
2658 {&sasl_mutex_alloc, &sasl_mutex_lock, &sasl_mutex_unlock,
2659 &sasl_mutex_free}, /* sasl_mutex_utils */
2660 NULL /* lib_list_head */
2661 };
2662
2663 return (&gbl_ctx);
2664 }
2665
2666 static int
_sasl_getconf(void * context,const char ** conf)2667 _sasl_getconf(void *context __attribute__((unused)), const char **conf)
2668 {
2669 if (! conf)
2670 return SASL_BADPARAM;
2671
2672 *conf = SASL_CONFDIR;
2673
2674 return SASL_OK;
2675 }
2676
2677 #ifdef _INTEGRATED_SOLARIS_
2678 #pragma fini(sasl_fini)
2679 int
sasl_fini(void)2680 sasl_fini(void)
2681 {
2682 reg_list_t *next;
2683
2684 while (reg_list_base != NULL) {
2685 next = reg_list_base->next;
2686 free(reg_list_base);
2687 reg_list_base = next;
2688 }
2689 return (0);
2690 }
2691 #endif /* _INTEGRATED_SOLARIS_ */
2692
2693 #endif /* _SUN_SDK_ */
2694
2695 #ifndef WIN32
2696 static int
_sasl_getpath(void * context,const char ** path)2697 _sasl_getpath(void *context __attribute__((unused)),
2698 const char **path)
2699 {
2700 if (! path)
2701 return SASL_BADPARAM;
2702
2703 #ifdef _SUN_SDK_
2704 /* SASL_PATH is not allowed for SUN SDK */
2705 #else
2706 *path = getenv(SASL_PATH_ENV_VAR);
2707 if (! *path)
2708 #endif /* _SUN_SDK_ */
2709 *path = PLUGINDIR;
2710
2711 return SASL_OK;
2712 }
2713
2714 #else
2715 /* Return NULL on failure */
2716 static int
_sasl_getpath(void * context,const char ** path)2717 _sasl_getpath(void *context __attribute__((unused)), const char **path)
2718 {
2719 /* Open registry entry, and find all registered SASL libraries.
2720 *
2721 * Registry location:
2722 *
2723 * SOFTWARE\\Carnegie Mellon\\Project Cyrus\\SASL Library
2724 *
2725 * Key - value:
2726 *
2727 * "SearchPath" - value: PATH like (';' delimited) list
2728 * of directories where to search for plugins
2729 * The list may contain references to environment
2730 * variables (e.g. %PATH%).
2731 *
2732 */
2733 HKEY hKey;
2734 DWORD ret;
2735 DWORD ValueType; /* value type */
2736 DWORD cbData; /* value size */
2737 BYTE * ValueData; /* value */
2738 DWORD cbExpandedData; /* "expanded" value size */
2739 BYTE * ExpandedValueData; /* "expanded" value */
2740 char * return_value; /* function return value */
2741 char * tmp;
2742
2743 /* Initialization */
2744 ExpandedValueData = NULL;
2745 ValueData = NULL;
2746 return_value = NULL;
2747
2748 /* Open the registry */
2749 ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
2750 SASL_ROOT_KEY,
2751 0,
2752 KEY_READ,
2753 &hKey);
2754
2755 if (ret != ERROR_SUCCESS) {
2756 /* no registry entry */
2757 *path = PLUGINDIR;
2758 return SASL_OK;
2759 }
2760
2761 /* figure out value type and required buffer size */
2762 /* the size will include space for terminating NUL if required */
2763 RegQueryValueEx (hKey,
2764 SASL_PATH_SUBKEY,
2765 NULL, /* reserved */
2766 &ValueType,
2767 NULL,
2768 &cbData);
2769
2770 /* Only accept string related types */
2771 if (ValueType != REG_EXPAND_SZ &&
2772 ValueType != REG_MULTI_SZ &&
2773 ValueType != REG_SZ) {
2774 return_value = NULL;
2775 goto CLEANUP;
2776 }
2777
2778 /* Any high water mark? */
2779 ValueData = sasl_ALLOC(cbData);
2780 if (ValueData == NULL) {
2781 return_value = NULL;
2782 goto CLEANUP;
2783 };
2784
2785 RegQueryValueEx (hKey,
2786 SASL_PATH_SUBKEY,
2787 NULL, /* reserved */
2788 &ValueType,
2789 ValueData,
2790 &cbData);
2791
2792 switch (ValueType) {
2793 case REG_EXPAND_SZ:
2794 /* : A random starting guess */
2795 cbExpandedData = cbData + 1024;
2796 ExpandedValueData = sasl_ALLOC(cbExpandedData);
2797 if (ExpandedValueData == NULL) {
2798 return_value = NULL;
2799 goto CLEANUP;
2800 };
2801
2802 cbExpandedData = ExpandEnvironmentStrings(
2803 ValueData,
2804 ExpandedValueData,
2805 cbExpandedData);
2806
2807 if (cbExpandedData == 0) {
2808 /* : GetLastError() contains the reason for failure */
2809 return_value = NULL;
2810 goto CLEANUP;
2811 }
2812
2813 /* : Must retry expansion with the bigger buffer */
2814 if (cbExpandedData > cbData + 1024) {
2815 /* : Memory leak here if can't realloc */
2816 ExpandedValueData = sasl_REALLOC(ExpandedValueData, cbExpandedData);
2817 if (ExpandedValueData == NULL) {
2818 return_value = NULL;
2819 goto CLEANUP;
2820 };
2821
2822 cbExpandedData = ExpandEnvironmentStrings(
2823 ValueData,
2824 ExpandedValueData,
2825 cbExpandedData);
2826
2827 /* : This should not happen */
2828 if (cbExpandedData == 0) {
2829 /* : GetLastError() contains the reason for failure */
2830 return_value = NULL;
2831 goto CLEANUP;
2832 }
2833 }
2834
2835 sasl_FREE(ValueData);
2836 ValueData = ExpandedValueData;
2837 /* : This is to prevent automatical freeing of this block on cleanup */
2838 ExpandedValueData = NULL;
2839
2840 break;
2841
2842 case REG_MULTI_SZ:
2843 tmp = ValueData;
2844
2845 /* : We shouldn't overflow here, as the buffer is guarantied
2846 : to contain at least two consequent NULs */
2847 while (1) {
2848 if (tmp[0] == '\0') {
2849 /* : Stop the process if we found the end of the string (two consequent NULs) */
2850 if (tmp[1] == '\0') {
2851 break;
2852 }
2853
2854 /* : Replace delimiting NUL with our delimiter characted */
2855 tmp[0] = PATHS_DELIMITER;
2856 }
2857 tmp += strlen(tmp);
2858 }
2859 break;
2860
2861 case REG_SZ:
2862 /* Do nothing, it is good as is */
2863 break;
2864
2865 default:
2866 return_value = NULL;
2867 goto CLEANUP;
2868 }
2869
2870 return_value = ValueData;
2871
2872 CLEANUP:
2873 RegCloseKey(hKey);
2874 if (ExpandedValueData != NULL) sasl_FREE(ExpandedValueData);
2875 if (return_value == NULL) {
2876 if (ValueData != NULL) sasl_FREE(ValueData);
2877 }
2878 *path = return_value;
2879
2880 #ifdef _SUN_SDK_
2881 /* SASL_PATH is not allowed for SUN SDK */
2882 if (! *path)
2883 *path = PLUGINDIR;
2884 #endif /* _SUN_SDK_ */
2885 return SASL_OK;
2886 }
2887
2888 #endif
2889