git.sur5r.net Git - openldap/blob - libraries/liblber/encode.c

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