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