1/*	$NetBSD$	*/
2
3/* io.c - ber general i/o routines */
4/* OpenLDAP: pkg/ldap/libraries/liblber/io.c,v 1.111.2.12 2010/04/13 20:22:54 kurt Exp */
5/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
6 *
7 * Copyright 1998-2010 The OpenLDAP Foundation.
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted only as authorized by the OpenLDAP
12 * Public License.
13 *
14 * A copy of this license is available in the file LICENSE in the
15 * top-level directory of the distribution or, alternatively, at
16 * <http://www.OpenLDAP.org/license.html>.
17 */
18/* Portions Copyright (c) 1990 Regents of the University of Michigan.
19 * All rights reserved.
20 *
21 * Redistribution and use in source and binary forms are permitted
22 * provided that this notice is preserved and that due credit is given
23 * to the University of Michigan at Ann Arbor. The name of the University
24 * may not be used to endorse or promote products derived from this
25 * software without specific prior written permission. This software
26 * is provided ``as is'' without express or implied warranty.
27 */
28/* ACKNOWLEDGEMENTS:
29 * This work was originally developed by the University of Michigan
30 * (as part of U-MICH LDAP).
31 */
32
33#include "portable.h"
34
35#include <stdio.h>
36
37#include <ac/stdlib.h>
38
39#include <ac/ctype.h>
40#include <ac/errno.h>
41#include <ac/socket.h>
42#include <ac/string.h>
43#include <ac/unistd.h>
44
45#ifdef HAVE_IO_H
46#include <io.h>
47#endif
48
49#include "lber-int.h"
50#include "ldap_log.h"
51
52ber_slen_t
53ber_skip_data(
54	BerElement *ber,
55	ber_len_t len )
56{
57	ber_len_t	actuallen, nleft;
58
59	assert( ber != NULL );
60	assert( LBER_VALID( ber ) );
61
62	nleft = ber_pvt_ber_remaining( ber );
63	actuallen = nleft < len ? nleft : len;
64	ber->ber_ptr += actuallen;
65	ber->ber_tag = *(unsigned char *)ber->ber_ptr;
66
67	return( (ber_slen_t) actuallen );
68}
69
70/*
71 * Read from the ber buffer.  The caller must maintain ber->ber_tag.
72 * Do not use to read whole tags.  See ber_get_tag() and ber_skip_data().
73 */
74ber_slen_t
75ber_read(
76	BerElement *ber,
77	char *buf,
78	ber_len_t len )
79{
80	ber_len_t	actuallen, nleft;
81
82	assert( ber != NULL );
83	assert( buf != NULL );
84	assert( LBER_VALID( ber ) );
85
86	nleft = ber_pvt_ber_remaining( ber );
87	actuallen = nleft < len ? nleft : len;
88
89	AC_MEMCPY( buf, ber->ber_ptr, actuallen );
90
91	ber->ber_ptr += actuallen;
92
93	return( (ber_slen_t) actuallen );
94}
95
96/*
97 * Write to the ber buffer.
98 * Note that ber_start_seqorset/ber_put_seqorset() bypass ber_write().
99 */
100ber_slen_t
101ber_write(
102	BerElement *ber,
103	LDAP_CONST char *buf,
104	ber_len_t len,
105	int zero )	/* nonzero is unsupported from OpenLDAP 2.4.18 */
106{
107	char **p;
108
109	assert( ber != NULL );
110	assert( buf != NULL );
111	assert( LBER_VALID( ber ) );
112
113	if ( zero != 0 ) {
114		ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug, "%s",
115			"ber_write: nonzero 4th argument not supported\n" );
116		return( -1 );
117	}
118
119	p = ber->ber_sos_ptr == NULL ? &ber->ber_ptr : &ber->ber_sos_ptr;
120	if ( len > (ber_len_t) (ber->ber_end - *p) ) {
121		if ( ber_realloc( ber, len ) != 0 ) return( -1 );
122	}
123	AC_MEMCPY( *p, buf, len );
124	*p += len;
125
126	return( (ber_slen_t) len );
127}
128
129/* Resize the ber buffer */
130int
131ber_realloc( BerElement *ber, ber_len_t len )
132{
133	ber_len_t	total, offset, sos_offset;
134	char		*buf;
135
136	assert( ber != NULL );
137	assert( LBER_VALID( ber ) );
138
139	/* leave room for ber_flatten() to \0-terminate ber_buf */
140	if ( ++len == 0 ) {
141		return( -1 );
142	}
143
144	total = ber_pvt_ber_total( ber );
145
146#define LBER_EXBUFSIZ	4060 /* a few words less than 2^N for binary buddy */
147#if defined( LBER_EXBUFSIZ ) && LBER_EXBUFSIZ > 0
148# ifndef notdef
149	/* don't realloc by small amounts */
150	total += len < LBER_EXBUFSIZ ? LBER_EXBUFSIZ : len;
151# else
152	{	/* not sure what value this adds.  reduce fragmentation? */
153		ber_len_t have = (total + (LBER_EXBUFSIZE - 1)) / LBER_EXBUFSIZ;
154		ber_len_t need = (len + (LBER_EXBUFSIZ - 1)) / LBER_EXBUFSIZ;
155		total = ( have + need ) * LBER_EXBUFSIZ;
156	}
157# endif
158#else
159	total += len;	/* realloc just what's needed */
160#endif
161
162	if ( total < len || total > (ber_len_t)-1 / 2 /* max ber_slen_t */ ) {
163		return( -1 );
164	}
165
166	buf = ber->ber_buf;
167	offset = ber->ber_ptr - buf;
168	sos_offset = ber->ber_sos_ptr ? ber->ber_sos_ptr - buf : 0;
169	/* if ber_sos_ptr != NULL, it is > ber_buf so that sos_offset > 0 */
170
171	buf = (char *) ber_memrealloc_x( buf, total, ber->ber_memctx );
172	if ( buf == NULL ) {
173		return( -1 );
174	}
175
176	ber->ber_buf = buf;
177	ber->ber_end = buf + total;
178	ber->ber_ptr = buf + offset;
179	if ( sos_offset )
180		ber->ber_sos_ptr = buf + sos_offset;
181
182	return( 0 );
183}
184
185void
186ber_free_buf( BerElement *ber )
187{
188	assert( LBER_VALID( ber ) );
189
190	if ( ber->ber_buf) ber_memfree_x( ber->ber_buf, ber->ber_memctx );
191
192	ber->ber_buf = NULL;
193	ber->ber_sos_ptr = NULL;
194	ber->ber_valid = LBER_UNINITIALIZED;
195}
196
197void
198ber_free( BerElement *ber, int freebuf )
199{
200	if( ber == NULL ) {
201		LDAP_MEMORY_DEBUG_ASSERT( ber != NULL );
202		return;
203	}
204
205	if( freebuf ) ber_free_buf( ber );
206
207	ber_memfree_x( (char *) ber, ber->ber_memctx );
208}
209
210int
211ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
212{
213	return ber_flush2( sb, ber,
214		freeit ? LBER_FLUSH_FREE_ON_SUCCESS
215			: LBER_FLUSH_FREE_NEVER );
216}
217
218int
219ber_flush2( Sockbuf *sb, BerElement *ber, int freeit )
220{
221	ber_len_t	towrite;
222	ber_slen_t	rc;
223
224	assert( sb != NULL );
225	assert( ber != NULL );
226	assert( SOCKBUF_VALID( sb ) );
227	assert( LBER_VALID( ber ) );
228
229	if ( ber->ber_rwptr == NULL ) {
230		ber->ber_rwptr = ber->ber_buf;
231	}
232	towrite = ber->ber_ptr - ber->ber_rwptr;
233
234	if ( sb->sb_debug ) {
235		ber_log_printf( LDAP_DEBUG_TRACE, sb->sb_debug,
236			"ber_flush2: %ld bytes to sd %ld%s\n",
237			towrite, (long) sb->sb_fd,
238			ber->ber_rwptr != ber->ber_buf ?  " (re-flush)" : "" );
239		ber_log_bprint( LDAP_DEBUG_BER, sb->sb_debug,
240			ber->ber_rwptr, towrite );
241	}
242
243	while ( towrite > 0 ) {
244#ifdef LBER_TRICKLE
245		sleep(1);
246		rc = ber_int_sb_write( sb, ber->ber_rwptr, 1 );
247#else
248		rc = ber_int_sb_write( sb, ber->ber_rwptr, towrite );
249#endif
250		if ( rc <= 0 ) {
251			if ( freeit & LBER_FLUSH_FREE_ON_ERROR ) ber_free( ber, 1 );
252			return -1;
253		}
254		towrite -= rc;
255		ber->ber_rwptr += rc;
256	}
257
258	if ( freeit & LBER_FLUSH_FREE_ON_SUCCESS ) ber_free( ber, 1 );
259
260	return 0;
261}
262
263BerElement *
264ber_alloc_t( int options )
265{
266	BerElement	*ber;
267
268	ber = (BerElement *) LBER_CALLOC( 1, sizeof(BerElement) );
269
270	if ( ber == NULL ) {
271		return NULL;
272	}
273
274	ber->ber_valid = LBER_VALID_BERELEMENT;
275	ber->ber_tag = LBER_DEFAULT;
276	ber->ber_options = options;
277	ber->ber_debug = ber_int_debug;
278
279	assert( LBER_VALID( ber ) );
280	return ber;
281}
282
283BerElement *
284ber_alloc( void )	/* deprecated */
285{
286	return ber_alloc_t( 0 );
287}
288
289BerElement *
290der_alloc( void )	/* deprecated */
291{
292	return ber_alloc_t( LBER_USE_DER );
293}
294
295BerElement *
296ber_dup( BerElement *ber )
297{
298	BerElement	*new;
299
300	assert( ber != NULL );
301	assert( LBER_VALID( ber ) );
302
303	if ( (new = ber_alloc_t( ber->ber_options )) == NULL ) {
304		return NULL;
305	}
306
307	*new = *ber;
308
309	assert( LBER_VALID( new ) );
310	return( new );
311}
312
313
314void
315ber_init2( BerElement *ber, struct berval *bv, int options )
316{
317	assert( ber != NULL );
318
319	(void) memset( (char *)ber, '\0', sizeof( BerElement ));
320	ber->ber_valid = LBER_VALID_BERELEMENT;
321	ber->ber_tag = LBER_DEFAULT;
322	ber->ber_options = (char) options;
323	ber->ber_debug = ber_int_debug;
324
325	if ( bv != NULL ) {
326		ber->ber_buf = bv->bv_val;
327		ber->ber_ptr = ber->ber_buf;
328		ber->ber_end = ber->ber_buf + bv->bv_len;
329	}
330
331	assert( LBER_VALID( ber ) );
332}
333
334/* OLD U-Mich ber_init() */
335void
336ber_init_w_nullc( BerElement *ber, int options )
337{
338	ber_init2( ber, NULL, options );
339}
340
341/* New C-API ber_init() */
342/* This function constructs a BerElement containing a copy
343** of the data in the bv argument.
344*/
345BerElement *
346ber_init( struct berval *bv )
347{
348	BerElement *ber;
349
350	assert( bv != NULL );
351
352	if ( bv == NULL ) {
353		return NULL;
354	}
355
356	ber = ber_alloc_t( 0 );
357
358	if( ber == NULL ) {
359		/* allocation failed */
360		return NULL;
361	}
362
363	/* copy the data */
364	if ( ((ber_len_t) ber_write ( ber, bv->bv_val, bv->bv_len, 0 ))
365		!= bv->bv_len )
366	{
367		/* write failed, so free and return NULL */
368		ber_free( ber, 1 );
369		return NULL;
370	}
371
372	ber_reset( ber, 1 );	/* reset the pointer to the start of the buffer */
373	return ber;
374}
375
376/* New C-API ber_flatten routine */
377/* This routine allocates a struct berval whose contents are a BER
378** encoding taken from the ber argument.  The bvPtr pointer points to
379** the returned berval.
380**
381** ber_flatten2 is the same, but uses a struct berval passed by
382** the caller. If alloc is 0 the returned bv uses the ber buf directly.
383*/
384int ber_flatten2(
385	BerElement *ber,
386	struct berval *bv,
387	int alloc )
388{
389	assert( bv != NULL );
390
391	if ( bv == NULL ) {
392		return -1;
393	}
394
395	if ( ber == NULL ) {
396		/* ber is null, create an empty berval */
397		bv->bv_val = NULL;
398		bv->bv_len = 0;
399
400	} else {
401		/* copy the berval */
402		ber_len_t len = ber_pvt_ber_write( ber );
403
404		if ( alloc ) {
405			bv->bv_val = (char *) ber_memalloc_x( len + 1, ber->ber_memctx );
406			if ( bv->bv_val == NULL ) {
407				return -1;
408			}
409			AC_MEMCPY( bv->bv_val, ber->ber_buf, len );
410			bv->bv_val[len] = '\0';
411		} else if ( ber->ber_buf != NULL ) {
412			bv->bv_val = ber->ber_buf;
413			bv->bv_val[len] = '\0';
414		} else {
415			bv->bv_val = "";
416		}
417		bv->bv_len = len;
418	}
419	return 0;
420}
421
422int ber_flatten(
423	BerElement *ber,
424	struct berval **bvPtr)
425{
426	struct berval *bv;
427	int rc;
428
429	assert( bvPtr != NULL );
430
431	if(bvPtr == NULL) {
432		return -1;
433	}
434
435	bv = ber_memalloc_x( sizeof(struct berval), ber->ber_memctx );
436	if ( bv == NULL ) {
437		return -1;
438	}
439	rc = ber_flatten2(ber, bv, 1);
440	if (rc == -1) {
441		ber_memfree_x(bv, ber->ber_memctx);
442	} else {
443		*bvPtr = bv;
444	}
445	return rc;
446}
447
448void
449ber_reset( BerElement *ber, int was_writing )
450{
451	assert( ber != NULL );
452	assert( LBER_VALID( ber ) );
453
454	if ( was_writing ) {
455		ber->ber_end = ber->ber_ptr;
456		ber->ber_ptr = ber->ber_buf;
457
458	} else {
459		ber->ber_ptr = ber->ber_end;
460	}
461
462	ber->ber_rwptr = NULL;
463}
464
465/*
466 * A rewrite of ber_get_next that can safely be called multiple times
467 * for the same packet. It will simply continue where it stopped until
468 * a full packet is read.
469 */
470
471#define LENSIZE	4
472
473ber_tag_t
474ber_get_next(
475	Sockbuf *sb,
476	ber_len_t *len,
477	BerElement *ber )
478{
479	assert( sb != NULL );
480	assert( len != NULL );
481	assert( ber != NULL );
482	assert( SOCKBUF_VALID( sb ) );
483	assert( LBER_VALID( ber ) );
484
485	if ( ber->ber_debug & LDAP_DEBUG_TRACE ) {
486		ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
487			"ber_get_next\n" );
488	}
489
490	/*
491	 * Any ber element looks like this: tag length contents.
492	 * Assuming everything's ok, we return the tag byte (we
493	 * can assume a single byte), return the length in len,
494	 * and the rest of the undecoded element in buf.
495	 *
496	 * Assumptions:
497	 *	1) small tags (less than 128)
498	 *	2) definite lengths
499	 *	3) primitive encodings used whenever possible
500	 *
501	 * The code also handles multi-byte tags. The first few bytes
502	 * of the message are read to check for multi-byte tags and
503	 * lengths. These bytes are temporarily stored in the ber_tag,
504	 * ber_len, and ber_usertag fields of the berelement until
505	 * tag/len parsing is complete. After this parsing, any leftover
506	 * bytes and the rest of the message are copied into the ber_buf.
507	 *
508	 * We expect tag and len to be at most 32 bits wide.
509	 */
510
511	if (ber->ber_rwptr == NULL) {
512		assert( ber->ber_buf == NULL );
513		ber->ber_rwptr = (char *) &ber->ber_len-1;
514		ber->ber_ptr = ber->ber_rwptr;
515		ber->ber_tag = 0;
516	}
517
518	while (ber->ber_rwptr > (char *)&ber->ber_tag && ber->ber_rwptr <
519		(char *)&ber->ber_len + LENSIZE*2) {
520		ber_slen_t sblen;
521		char buf[sizeof(ber->ber_len)-1];
522		ber_len_t tlen = 0;
523
524		/* The tag & len can be at most 9 bytes; we try to read up to 8 here */
525		sock_errset(0);
526		sblen=((char *)&ber->ber_len + LENSIZE*2 - 1)-ber->ber_rwptr;
527		/* Trying to read the last len byte of a 9 byte tag+len */
528		if (sblen<1)
529			sblen = 1;
530		sblen=ber_int_sb_read( sb, ber->ber_rwptr, sblen );
531		if (sblen<=0) return LBER_DEFAULT;
532		ber->ber_rwptr += sblen;
533
534		/* We got at least one byte, try to parse the tag. */
535		if (ber->ber_ptr == (char *)&ber->ber_len-1) {
536			ber_tag_t tag;
537			unsigned char *p = (unsigned char *)ber->ber_ptr;
538			tag = *p++;
539			if ((tag & LBER_BIG_TAG_MASK) == LBER_BIG_TAG_MASK) {
540				ber_len_t i;
541				for (i=1; (char *)p<ber->ber_rwptr; i++) {
542					tag <<= 8;
543					tag |= *p++;
544					if (!(tag & LBER_MORE_TAG_MASK))
545						break;
546					/* Is the tag too big? */
547					if (i == sizeof(ber_tag_t)-1) {
548						sock_errset(ERANGE);
549						return LBER_DEFAULT;
550					}
551				}
552				/* Did we run out of bytes? */
553				if ((char *)p == ber->ber_rwptr) {
554#if defined( EWOULDBLOCK )
555					sock_errset(EWOULDBLOCK);
556#elif defined( EAGAIN )
557					sock_errset(EAGAIN);
558#endif
559					return LBER_DEFAULT;
560				}
561			}
562			ber->ber_tag = tag;
563			ber->ber_ptr = (char *)p;
564		}
565
566		if ( ber->ber_ptr == ber->ber_rwptr ) {
567#if defined( EWOULDBLOCK )
568			sock_errset(EWOULDBLOCK);
569#elif defined( EAGAIN )
570			sock_errset(EAGAIN);
571#endif
572			return LBER_DEFAULT;
573		}
574
575		/* Now look for the length */
576		if (*ber->ber_ptr & 0x80) {	/* multi-byte */
577			int i;
578			unsigned char *p = (unsigned char *)ber->ber_ptr;
579			int llen = *p++ & 0x7f;
580			if (llen > LENSIZE) {
581				sock_errset(ERANGE);
582				return LBER_DEFAULT;
583			}
584			/* Not enough bytes? */
585			if (ber->ber_rwptr - (char *)p < llen) {
586#if defined( EWOULDBLOCK )
587				sock_errset(EWOULDBLOCK);
588#elif defined( EAGAIN )
589				sock_errset(EAGAIN);
590#endif
591				return LBER_DEFAULT;
592			}
593			for (i=0; i<llen; i++) {
594				tlen <<=8;
595				tlen |= *p++;
596			}
597			ber->ber_ptr = (char *)p;
598		} else {
599			tlen = *(unsigned char *)ber->ber_ptr++;
600		}
601
602		/* Are there leftover data bytes inside ber->ber_len? */
603		if (ber->ber_ptr < (char *)&ber->ber_usertag) {
604			if (ber->ber_rwptr < (char *)&ber->ber_usertag) {
605				sblen = ber->ber_rwptr - ber->ber_ptr;
606			} else {
607				sblen = (char *)&ber->ber_usertag - ber->ber_ptr;
608			}
609			AC_MEMCPY(buf, ber->ber_ptr, sblen);
610			ber->ber_ptr += sblen;
611		} else {
612			sblen = 0;
613		}
614		ber->ber_len = tlen;
615
616		/* now fill the buffer. */
617
618		/* make sure length is reasonable */
619		if ( ber->ber_len == 0 ) {
620			sock_errset(ERANGE);
621			return LBER_DEFAULT;
622		}
623
624		if ( sb->sb_max_incoming && ber->ber_len > sb->sb_max_incoming ) {
625			ber_log_printf( LDAP_DEBUG_CONNS, ber->ber_debug,
626				"ber_get_next: sockbuf_max_incoming exceeded "
627				"(%ld > %ld)\n", ber->ber_len, sb->sb_max_incoming );
628			sock_errset(ERANGE);
629			return LBER_DEFAULT;
630		}
631
632		if (ber->ber_buf==NULL) {
633			ber_len_t l = ber->ber_rwptr - ber->ber_ptr;
634			/* ber->ber_ptr is always <= ber->ber->ber_rwptr.
635			 * make sure ber->ber_len agrees with what we've
636			 * already read.
637			 */
638			if ( ber->ber_len < sblen + l ) {
639				sock_errset(ERANGE);
640				return LBER_DEFAULT;
641			}
642			ber->ber_buf = (char *) ber_memalloc_x( ber->ber_len + 1, ber->ber_memctx );
643			if (ber->ber_buf==NULL) {
644				return LBER_DEFAULT;
645			}
646			ber->ber_end = ber->ber_buf + ber->ber_len;
647			if (sblen) {
648				AC_MEMCPY(ber->ber_buf, buf, sblen);
649			}
650			if (l > 0) {
651				AC_MEMCPY(ber->ber_buf + sblen, ber->ber_ptr, l);
652				sblen += l;
653			}
654			*ber->ber_end = '\0';
655			ber->ber_ptr = ber->ber_buf;
656			ber->ber_usertag = 0;
657			if ((ber_len_t)sblen == ber->ber_len) {
658				goto done;
659			}
660			ber->ber_rwptr = ber->ber_buf + sblen;
661		}
662	}
663
664	if ((ber->ber_rwptr>=ber->ber_buf) && (ber->ber_rwptr<ber->ber_end)) {
665		ber_slen_t res;
666		ber_slen_t to_go;
667
668		to_go = ber->ber_end - ber->ber_rwptr;
669		assert( to_go > 0 );
670
671		sock_errset(0);
672		res = ber_int_sb_read( sb, ber->ber_rwptr, to_go );
673		if (res<=0) return LBER_DEFAULT;
674		ber->ber_rwptr+=res;
675
676		if (res<to_go) {
677#if defined( EWOULDBLOCK )
678			sock_errset(EWOULDBLOCK);
679#elif defined( EAGAIN )
680			sock_errset(EAGAIN);
681#endif
682			return LBER_DEFAULT;
683		}
684done:
685		ber->ber_rwptr = NULL;
686		*len = ber->ber_len;
687		if ( ber->ber_debug ) {
688			ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
689				"ber_get_next: tag 0x%lx len %ld contents:\n",
690				ber->ber_tag, ber->ber_len );
691			ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
692		}
693		return (ber->ber_tag);
694	}
695
696	assert( 0 ); /* ber structure is messed up ?*/
697	return LBER_DEFAULT;
698}
699
700char *
701ber_start( BerElement* ber )
702{
703	return ber->ber_buf;
704}
705
706int
707ber_len( BerElement* ber )
708{
709	return ( ber->ber_end - ber->ber_buf );
710}
711
712int
713ber_ptrlen( BerElement* ber )
714{
715	return ( ber->ber_ptr - ber->ber_buf );
716}
717
718void
719ber_rewind ( BerElement * ber )
720{
721	ber->ber_rwptr = NULL;
722	ber->ber_sos_ptr = NULL;
723	ber->ber_end = ber->ber_ptr;
724	ber->ber_ptr = ber->ber_buf;
725#if 0	/* TODO: Should we add this? */
726	ber->ber_tag = LBER_DEFAULT;
727	ber->ber_usertag = 0;
728#endif
729}
730
731int
732ber_remaining( BerElement * ber )
733{
734	return ber_pvt_ber_remaining( ber );
735}
736