]> git.sur5r.net Git - openldap/blob - libraries/liblber/encode.c
More contrib cleanout
[openldap] / libraries / liblber / encode.c
1 /* Encode.c - ber output encoding routines */
2 /* $OpenLDAP$ */
3 /*
4  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
6  */
7 /* Portions
8  * Copyright (c) 1990 Regents of the University of Michigan.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms are permitted
12  * provided that this notice is preserved and that due credit is given
13  * to the University of Michigan at Ann Arbor. The name of the University
14  * may not be used to endorse or promote products derived from this
15  * software without specific prior written permission. This software
16  * is provided ``as is'' without express or implied warranty.
17  */
18
19 #include "portable.h"
20
21 #include <stdio.h>
22
23 #include <ac/stdlib.h>
24
25 #include <ac/stdarg.h>
26 #include <ac/socket.h>
27 #include <ac/string.h>
28
29 #include "lber-int.h"
30
31 static int ber_put_len LDAP_P((
32         BerElement *ber,
33         ber_len_t len,
34         int nosos ));
35
36 static int ber_start_seqorset LDAP_P((
37         BerElement *ber,
38         ber_tag_t tag ));
39
40 static int ber_put_seqorset LDAP_P(( BerElement *ber ));
41
42 static int ber_put_int_or_enum LDAP_P((
43         BerElement *ber,
44         ber_int_t num,
45         ber_tag_t tag ));
46
47
48 static ber_len_t
49 ber_calc_taglen( ber_tag_t tag )
50 {
51         int     i;
52         ber_tag_t       mask;
53
54         /* find the first non-all-zero byte in the tag */
55         for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) {
56                 mask = ((ber_tag_t)0xffU << (i * 8));
57                 /* not all zero */
58                 if ( tag & mask ) break;
59         }
60
61         return i + 1;
62 }
63
64 static int
65 ber_put_tag(
66         BerElement      *ber,
67         ber_tag_t tag,
68         int nosos )
69 {
70         int rc;
71         ber_len_t       taglen;
72         ber_len_t       i;
73         unsigned char nettag[sizeof(ber_tag_t)];
74
75         assert( ber != NULL );
76         assert( BER_VALID( ber ) );
77
78         taglen = ber_calc_taglen( tag );
79
80         for( i=0; i<taglen; i++ ) {
81                 nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tag & 0xffU);
82                 tag >>= 8;
83         }
84
85         rc = ber_write( ber,
86                 &nettag[sizeof(ber_tag_t) - taglen],
87             taglen, nosos );
88
89         return rc;
90 }
91
92 static ber_len_t
93 ber_calc_lenlen( ber_len_t len )
94 {
95         /*
96          * short len if it's less than 128 - one byte giving the len,
97          * with bit 8 0.
98          */
99
100         if ( len <= (ber_len_t) 0x7FU )
101                 return 1;
102
103         /*
104          * long len otherwise - one byte with bit 8 set, giving the
105          * length of the length, followed by the length itself.
106          */
107
108         if ( len <= (ber_len_t) 0xffU )
109                 return 2;
110         if ( len <= (ber_len_t) 0xffffU )
111                 return 3;
112         if ( len <= (ber_len_t) 0xffffffU )
113                 return 4;
114
115         return 5;
116 }
117
118 static int
119 ber_put_len( BerElement *ber, ber_len_t len, int nosos )
120 {
121         int rc;
122         int             i,j;
123         char            lenlen;
124         ber_len_t       mask;
125         unsigned char netlen[sizeof(ber_len_t)];
126
127         assert( ber != NULL );
128         assert( BER_VALID( ber ) );
129
130         /*
131          * short len if it's less than 128 - one byte giving the len,
132          * with bit 8 0.
133          */
134
135         if ( len <= 127 ) {
136                 char length_byte = (char) len;
137                 return ber_write( ber, &length_byte, 1, nosos );
138         }
139
140         /*
141          * long len otherwise - one byte with bit 8 set, giving the
142          * length of the length, followed by the length itself.
143          */
144
145         /* find the first non-all-zero byte */
146         for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) {
147                 mask = ((ber_len_t)0xffU << (i * 8));
148                 /* not all zero */
149                 if ( len & mask ) break;
150         }
151         lenlen = (unsigned char) ++i;
152         if ( lenlen > 4 )
153                 return -1;
154
155         lenlen |= 0x80UL;
156
157         /* write the length of the length */
158         if ( ber_write( ber, &lenlen, 1, nosos ) != 1 )
159                 return -1;
160
161         for( j=0; j<i; j++) {
162                 netlen[(sizeof(ber_len_t)-1) - j] = (unsigned char)(len & 0xffU);
163                 len >>= 8;
164         }
165
166         /* write the length itself */
167         rc = ber_write( ber,
168                 &netlen[sizeof(ber_len_t)-i],
169                 i, nosos );
170
171         return rc == i ?  i+1 : -1;
172 }
173
174 static int
175 ber_put_int_or_enum(
176         BerElement *ber,
177         ber_int_t num,
178         ber_tag_t tag )
179 {
180         int rc;
181         int     i, j, sign;
182         ber_len_t       len, lenlen, taglen;
183         ber_uint_t      unum, mask;
184         unsigned char netnum[sizeof(ber_uint_t)];
185
186         assert( ber != NULL );
187         assert( BER_VALID( ber ) );
188
189         sign = (num < 0);
190         unum = num;     /* Bit fiddling should be done with unsigned values */
191
192         /*
193          * high bit is set - look for first non-all-one byte
194          * high bit is clear - look for first non-all-zero byte
195          */
196         for ( i = sizeof(ber_int_t) - 1; i > 0; i-- ) {
197                 mask = ((ber_uint_t)0xffU << (i * 8));
198
199                 if ( sign ) {
200                         /* not all ones */
201                         if ( (unum & mask) != mask ) break;
202                 } else {
203                         /* not all zero */
204                         if ( unum & mask ) break;
205                 }
206         }
207
208         /*
209          * we now have the "leading byte".  if the high bit on this
210          * byte matches the sign bit, we need to "back up" a byte.
211          */
212         mask = (unum & ((ber_uint_t)0x80U << (i * 8)));
213         if ( (mask && !sign) || (sign && !mask) ) {
214                 i++;
215         }
216
217         len = i + 1;
218
219         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
220                 return -1;
221         }
222
223         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )
224                 return -1;
225         i++;
226
227         for( j=0; j<i; j++ ) {
228                 netnum[(sizeof(ber_int_t)-1) - j] = (unsigned char)(unum & 0xffU);
229                 unum >>= 8;
230         }
231
232         rc = ber_write( ber,
233                 &netnum[sizeof(ber_int_t) - i],
234                 i, 0 );
235
236         /* length of tag + length + contents */
237         return rc == i ? taglen + lenlen + i : -1;
238 }
239
240 int
241 ber_put_enum(
242         BerElement *ber,
243         ber_int_t num,
244         ber_tag_t tag )
245 {
246         assert( ber != NULL );
247         assert( BER_VALID( ber ) );
248
249         if ( tag == LBER_DEFAULT ) {
250                 tag = LBER_ENUMERATED;
251         }
252
253         return ber_put_int_or_enum( ber, num, tag );
254 }
255
256 int
257 ber_put_int(
258         BerElement *ber,
259         ber_int_t num,
260         ber_tag_t tag )
261 {
262         assert( ber != NULL );
263         assert( BER_VALID( ber ) );
264
265         if ( tag == LBER_DEFAULT ) {
266                 tag = LBER_INTEGER;
267         }
268
269         return ber_put_int_or_enum( ber, num, tag );
270 }
271
272 int
273 ber_put_ostring(
274         BerElement *ber,
275         LDAP_CONST char *str,
276         ber_len_t len,
277         ber_tag_t tag )
278 {
279         ber_len_t       taglen, lenlen;
280         int rc;
281
282         assert( ber != NULL );
283         assert( str != NULL );
284
285         assert( BER_VALID( ber ) );
286
287         if ( tag == LBER_DEFAULT ) {
288                 tag = LBER_OCTETSTRING;
289         }
290
291         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
292                 return -1;
293
294         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ||
295                 (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
296                 rc = -1;
297         } else {
298                 /* return length of tag + length + contents */
299                 rc = taglen + lenlen + len;
300         }
301
302         return rc;
303 }
304
305 int
306 ber_put_berval(
307         BerElement *ber,
308         LDAP_CONST struct berval *bv,
309         ber_tag_t tag )
310 {
311         assert( ber != NULL );
312         assert( BER_VALID( ber ) );
313
314         if( bv == NULL || bv->bv_len == 0 ) {
315                 return ber_put_ostring( ber, "", (ber_len_t) 0, tag );
316         }
317
318         return ber_put_ostring( ber, bv->bv_val, bv->bv_len, tag );
319 }
320
321 int
322 ber_put_string(
323         BerElement *ber,
324         LDAP_CONST char *str,
325         ber_tag_t tag )
326 {
327         assert( ber != NULL );
328         assert( str != NULL );
329
330         assert( BER_VALID( ber ) );
331
332         return ber_put_ostring( ber, str, strlen( str ), tag );
333 }
334
335 int
336 ber_put_bitstring(
337         BerElement *ber,
338         LDAP_CONST char *str,
339         ber_len_t blen /* in bits */,
340         ber_tag_t tag )
341 {
342         ber_len_t               taglen, lenlen, len;
343         unsigned char   unusedbits;
344
345         assert( ber != NULL );
346         assert( str != NULL );
347
348         assert( BER_VALID( ber ) );
349
350         if ( tag == LBER_DEFAULT ) {
351                 tag = LBER_BITSTRING;
352         }
353
354         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
355                 return -1;
356         }
357
358         len = ( blen + 7 ) / 8;
359         unusedbits = (unsigned char) ((len * 8) - blen);
360         if ( (lenlen = ber_put_len( ber, len + 1, 0 )) == -1 ) {
361                 return -1;
362         }
363
364         if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 ) {
365                 return -1;
366         }
367
368         if ( (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
369                 return -1;
370         }
371
372         /* return length of tag + length + unused bit count + contents */
373         return taglen + 1 + lenlen + len;
374 }
375
376 int
377 ber_put_null( BerElement *ber, ber_tag_t tag )
378 {
379         ber_len_t       taglen;
380
381         assert( ber != NULL );
382         assert( BER_VALID( ber ) );
383
384         if ( tag == LBER_DEFAULT ) {
385                 tag = LBER_NULL;
386         }
387
388         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
389                 return -1;
390         }
391
392         if ( ber_put_len( ber, 0, 0 ) != 1 ) {
393                 return -1;
394         }
395
396         return taglen + 1;
397 }
398
399 int
400 ber_put_boolean(
401         BerElement *ber,
402         ber_int_t boolval,
403         ber_tag_t tag )
404 {
405         ber_len_t               taglen;
406         unsigned char   trueval = (unsigned char) -1;
407         unsigned char   falseval = 0;
408
409         assert( ber != NULL );
410         assert( BER_VALID( ber ) );
411
412         if ( tag == LBER_DEFAULT )
413                 tag = LBER_BOOLEAN;
414
415         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
416                 return -1;
417         }
418
419         if ( ber_put_len( ber, 1, 0 ) != 1 ) {
420                 return -1;
421         }
422
423         if ( ber_write( ber, (char *)(boolval ? &trueval : &falseval), 1, 0 )
424                 != 1 )
425         {
426                 return -1;
427         }
428
429         return taglen + 2;
430 }
431
432 #define FOUR_BYTE_LEN   5
433
434 static int
435 ber_start_seqorset(
436         BerElement *ber,
437         ber_tag_t tag )
438 {
439         Seqorset        *new;
440
441         assert( ber != NULL );
442         assert( BER_VALID( ber ) );
443
444         new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) );
445
446         if ( new == NULL ) {
447                 return -1;
448         }
449
450         new->sos_ber = ber;
451         if ( ber->ber_sos == NULL ) {
452                 new->sos_first = ber->ber_ptr;
453         } else {
454                 new->sos_first = ber->ber_sos->sos_ptr;
455         }
456
457         /* Set aside room for a 4 byte length field */
458         new->sos_ptr = new->sos_first + ber_calc_taglen( tag ) + FOUR_BYTE_LEN;
459         new->sos_tag = tag;
460
461         new->sos_next = ber->ber_sos;
462         ber->ber_sos = new;
463
464         return 0;
465 }
466
467 int
468 ber_start_seq( BerElement *ber, ber_tag_t tag )
469 {
470         assert( ber != NULL );
471         assert( BER_VALID( ber ) );
472
473         if ( tag == LBER_DEFAULT ) {
474                 tag = LBER_SEQUENCE;
475         }
476
477         return ber_start_seqorset( ber, tag );
478 }
479
480 int
481 ber_start_set( BerElement *ber, ber_tag_t tag )
482 {
483         assert( ber != NULL );
484         assert( BER_VALID( ber ) );
485
486         if ( tag == LBER_DEFAULT ) {
487                 tag = LBER_SET;
488         }
489
490         return ber_start_seqorset( ber, tag );
491 }
492
493 static int
494 ber_put_seqorset( BerElement *ber )
495 {
496         int rc;
497         ber_len_t       len;
498         unsigned char netlen[sizeof(ber_len_t)];
499         ber_len_t       taglen, lenlen;
500         unsigned char   ltag = 0x80U + FOUR_BYTE_LEN - 1;
501         Seqorset        *next;
502         Seqorset        **sos = &ber->ber_sos;
503
504         assert( ber != NULL );
505         assert( BER_VALID( ber ) );
506
507         /*
508          * If this is the toplevel sequence or set, we need to actually
509          * write the stuff out.  Otherwise, it's already been put in
510          * the appropriate buffer and will be written when the toplevel
511          * one is written.  In this case all we need to do is update the
512          * length and tag.
513          */
514
515         len = (*sos)->sos_clen;
516
517         if ( sizeof(ber_len_t) > 4 && len > 0xffffffffUL ) {
518                 return -1;
519         }
520
521         if ( ber->ber_options & LBER_USE_DER ) {
522                 lenlen = ber_calc_lenlen( len );
523
524         } else {
525                 lenlen = FOUR_BYTE_LEN;
526         }
527
528         if( lenlen > 1 ) {
529                 ber_len_t i;
530                 for( i=0; i < lenlen-1; i++ ) {
531                         netlen[(sizeof(ber_len_t)-1) - i] = 
532                                 (unsigned char)((len >> i*8) & 0xffU);
533                 }
534         } else {
535                 netlen[sizeof(ber_len_t)-1] = (unsigned char)(len & 0x7fU);
536         }
537
538         if ( (next = (*sos)->sos_next) == NULL ) {
539                 /* write the tag */
540                 if ( (taglen = ber_put_tag( ber, (*sos)->sos_tag, 1 )) == -1 )
541                         return( -1 );
542
543                 if ( ber->ber_options & LBER_USE_DER ) {
544                         /* Write the length in the minimum # of octets */
545                         if ( ber_put_len( ber, len, 1 ) == -1 ) {
546                                 return -1;
547                         }
548
549                         if (lenlen != FOUR_BYTE_LEN) {
550                                 /*
551                                  * We set aside FOUR_BYTE_LEN bytes for
552                                  * the length field.  Move the data if
553                                  * we don't actually need that much
554                                  */
555                                 AC_MEMCPY( (*sos)->sos_first + taglen +
556                                     lenlen, (*sos)->sos_first + taglen +
557                                     FOUR_BYTE_LEN, len );
558                         }
559                 } else {
560                         /* Fill FOUR_BYTE_LEN bytes for length field */
561                         /* one byte of length length */
562                         if ( ber_write( ber, (char *)&ltag, 1, 1 ) != 1 ) {
563                                 return -1;
564                         }
565
566                         /* the length itself */
567                         rc  = ber_write( ber,
568                                 &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN-1)],
569                                 FOUR_BYTE_LEN-1, 1 );
570
571                         if( rc != FOUR_BYTE_LEN - 1 ) {
572                                 return -1;
573                         }
574                 }
575                 /* The ber_ptr is at the set/seq start - move it to the end */
576                 (*sos)->sos_ber->ber_ptr += len;
577
578         } else {
579                 ber_len_t i;
580                 unsigned char nettag[sizeof(ber_tag_t)];
581                 ber_tag_t tmptag = (*sos)->sos_tag;
582
583                 if( ber->ber_sos->sos_ptr > ber->ber_end ) {
584                         /* The sos_ptr exceeds the end of the BerElement
585                          * this can happen, for example, when the sos_ptr
586                          * is near the end and no data was written for the
587                          * 'V'.  We must realloc the BerElement to ensure
588                          * we don't overwrite the buffer when writing
589                          * the tag and length fields.
590                          */
591                         ber_len_t ext = ber->ber_sos->sos_ptr - ber->ber_end;
592
593                         if( ber_realloc( ber,  ext ) != 0 ) {
594                                 return -1;
595                         }
596                 }
597
598                 /* the tag */
599                 taglen = ber_calc_taglen( tmptag );
600
601                 for( i = 0; i < taglen; i++ ) {
602                         nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tmptag & 0xffU);
603                         tmptag >>= 8;
604                 }
605
606                 AC_FMEMCPY( (*sos)->sos_first,
607                         &nettag[sizeof(ber_tag_t) - taglen],
608                         taglen );
609
610                 if ( ber->ber_options & LBER_USE_DER ) {
611                         ltag = (lenlen == 1)
612                                 ? (unsigned char) len
613                                 : (unsigned char) (0x80U + (lenlen - 1));
614                 }
615
616                 /* one byte of length length */
617                 (*sos)->sos_first[1] = ltag;
618
619                 if ( ber->ber_options & LBER_USE_DER ) {
620                         if (lenlen > 1) {
621                                 /* Write the length itself */
622                                 AC_FMEMCPY( (*sos)->sos_first + 2,
623                                     &netlen[sizeof(ber_len_t) - (lenlen - 1)],
624                                         lenlen - 1 );
625                         }
626                         if (lenlen != FOUR_BYTE_LEN) {
627                                 /*
628                                  * We set aside FOUR_BYTE_LEN bytes for
629                                  * the length field.  Move the data if
630                                  * we don't actually need that much
631                                  */
632                                 AC_FMEMCPY( (*sos)->sos_first + taglen +
633                                     lenlen, (*sos)->sos_first + taglen +
634                                     FOUR_BYTE_LEN, len );
635                         }
636                 } else {
637                         /* the length itself */
638                         AC_FMEMCPY( (*sos)->sos_first + taglen + 1,
639                             &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN - 1)],
640                                 FOUR_BYTE_LEN - 1 );
641                 }
642
643                 next->sos_clen += (taglen + lenlen + len);
644                 next->sos_ptr += (taglen + lenlen + len);
645         }
646
647         /* we're done with this seqorset, so free it up */
648         LBER_FREE( (char *) (*sos) );
649         *sos = next;
650
651         return taglen + lenlen + len;
652 }
653
654 int
655 ber_put_seq( BerElement *ber )
656 {
657         assert( ber != NULL );
658         assert( BER_VALID( ber ) );
659
660         return ber_put_seqorset( ber );
661 }
662
663 int
664 ber_put_set( BerElement *ber )
665 {
666         assert( ber != NULL );
667         assert( BER_VALID( ber ) );
668
669         return ber_put_seqorset( ber );
670 }
671
672 /* N tag */
673 static ber_tag_t lber_int_null = 0;
674
675 /* VARARGS */
676 int
677 ber_printf( BerElement *ber, LDAP_CONST char *fmt, ... )
678 {
679         va_list         ap;
680         char            *s, **ss;
681         struct berval   *bv, **bvp;
682         int             rc;
683         ber_int_t       i;
684         ber_len_t       len;
685
686         assert( ber != NULL );
687         assert( fmt != NULL );
688
689         assert( BER_VALID( ber ) );
690
691         va_start( ap, fmt );
692
693         for ( rc = 0; *fmt && rc != -1; fmt++ ) {
694                 switch ( *fmt ) {
695                 case '!': { /* hook */
696                                 BEREncodeCallback *f;
697                                 void *p;
698
699                                 f = va_arg( ap, BEREncodeCallback * );
700                                 p = va_arg( ap, void * );
701
702                                 rc = (*f)( ber, p );
703                         } break;
704
705                 case 'b':       /* boolean */
706                         i = va_arg( ap, ber_int_t );
707                         rc = ber_put_boolean( ber, i, ber->ber_tag );
708                         break;
709
710                 case 'i':       /* int */
711                         i = va_arg( ap, ber_int_t );
712                         rc = ber_put_int( ber, i, ber->ber_tag );
713                         break;
714
715                 case 'e':       /* enumeration */
716                         i = va_arg( ap, ber_int_t );
717                         rc = ber_put_enum( ber, i, ber->ber_tag );
718                         break;
719
720                 case 'n':       /* null */
721                         rc = ber_put_null( ber, ber->ber_tag );
722                         break;
723
724                 case 'N':       /* Debug NULL */
725                         if( lber_int_null != 0 ) {
726                                 /* Insert NULL to ensure peer ignores unknown tags */
727                                 rc = ber_put_null( ber, lber_int_null );
728                         } else {
729                                 rc = 0;
730                         }
731                         break;
732
733                 case 'o':       /* octet string (non-null terminated) */
734                         s = va_arg( ap, char * );
735                         len = va_arg( ap, ber_len_t );
736                         rc = ber_put_ostring( ber, s, len, ber->ber_tag );
737                         break;
738
739                 case 'O':       /* berval octet string */
740                         bv = va_arg( ap, struct berval * );
741                         if( bv == NULL ) break;
742                         rc = ber_put_berval( ber, bv, ber->ber_tag );
743                         break;
744
745                 case 's':       /* string */
746                         s = va_arg( ap, char * );
747                         rc = ber_put_string( ber, s, ber->ber_tag );
748                         break;
749
750                 case 'B':       /* bit string */
751                 case 'X':       /* bit string (deprecated) */
752                         s = va_arg( ap, char * );
753                         len = va_arg( ap, int );        /* in bits */
754                         rc = ber_put_bitstring( ber, s, len, ber->ber_tag );
755                         break;
756
757                 case 't':       /* tag for the next element */
758                         ber->ber_tag = va_arg( ap, ber_tag_t );
759                         ber->ber_usertag = 1;
760                         break;
761
762                 case 'v':       /* vector of strings */
763                         if ( (ss = va_arg( ap, char ** )) == NULL )
764                                 break;
765                         for ( i = 0; ss[i] != NULL; i++ ) {
766                                 if ( (rc = ber_put_string( ber, ss[i],
767                                     ber->ber_tag )) == -1 )
768                                         break;
769                         }
770                         break;
771
772                 case 'V':       /* sequences of strings + lengths */
773                         if ( (bvp = va_arg( ap, struct berval ** )) == NULL )
774                                 break;
775                         for ( i = 0; bvp[i] != NULL; i++ ) {
776                                 if ( (rc = ber_put_berval( ber, bvp[i],
777                                     ber->ber_tag )) == -1 )
778                                         break;
779                         }
780                         break;
781
782                 case '{':       /* begin sequence */
783                         rc = ber_start_seq( ber, ber->ber_tag );
784                         break;
785
786                 case '}':       /* end sequence */
787                         rc = ber_put_seqorset( ber );
788                         break;
789
790                 case '[':       /* begin set */
791                         rc = ber_start_set( ber, ber->ber_tag );
792                         break;
793
794                 case ']':       /* end set */
795                         rc = ber_put_seqorset( ber );
796                         break;
797
798                 default:
799                         if( ber->ber_debug ) {
800 #ifdef NEW_LOGGING
801                                 LDAP_LOG(( "liblber", LDAP_LEVEL_ERR,
802                                            "ber_printf: unknown fmt %c\n", *fmt ));
803 #else
804                                 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
805                                         "ber_printf: unknown fmt %c\n", *fmt );
806 #endif
807                         }
808                         rc = -1;
809                         break;
810                 }
811
812                 if ( ber->ber_usertag == 0 )
813                         ber->ber_tag = LBER_DEFAULT;
814                 else
815                         ber->ber_usertag = 0;
816         }
817
818         va_end( ap );
819
820         return rc;
821 }