pb_decode.c

   1 /* pb_decode.c -- decode a protobuf using minimal resources
   2  *
   3  * 2011 Petteri Aimonen <jpa@kapsi.fi>
   4  */
   5
   6 /* The warn_unused_result attribute appeared first in gcc-3.4.0 */
   7 #if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
   8     #define checkreturn
   9 #else
  10     /* Verify that we remember to check all return values for proper error propagation */
  11     #define checkreturn __attribute__((warn_unused_result))
  12 #endif
  13
  14 #define NANOPB_INTERNALS
  15 #include "pb.h"
  16 #include "pb_decode.h"
  17 #include <string.h>
  18
  19 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
  20
  21 /* --- Function pointers to field decoders ---
  22  * Order in the array must match pb_action_t LTYPE numbering.
  23  */
  24 static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
  25     &pb_dec_varint,
  26     &pb_dec_svarint,
  27     &pb_dec_fixed32,
  28     &pb_dec_fixed64,
  29
  30     &pb_dec_bytes,
  31     &pb_dec_string,
  32     &pb_dec_submessage
  33 };
  34
  35 /**************
  36  * pb_istream *
  37  **************/
  38
  39 static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  40 {
  41     uint8_t *source = (uint8_t*)stream->state;
  42     stream->state = source + count;
  43
  44     if (buf != NULL)
  45     {
  46         while (count--)
  47             *buf++ = *source++;
  48     }
  49
  50     return true;
  51 }
  52
  53 bool checkreturn pb_read(pb_istream_t *stream, uint8_t *buf, size_t count)
  54 {
  55 #ifndef PB_BUFFER_ONLY
  56         if (buf == NULL && stream->callback != buf_read)
  57         {
  58                 /* Skip input bytes */
  59                 uint8_t tmp[16];
  60                 while (count > 16)
  61                 {
  62                         if (!pb_read(stream, tmp, 16))
  63                                 return false;
  64
  65                         count -= 16;
  66                 }
  67
  68                 return pb_read(stream, tmp, count);
  69         }
  70 #endif
  71
  72     if (stream->bytes_left < count)
  73         PB_RETURN_ERROR(stream, "end-of-stream");
  74
  75 #ifndef PB_BUFFER_ONLY
  76     if (!stream->callback(stream, buf, count))
  77         PB_RETURN_ERROR(stream, "io error");
  78 #else
  79     if (!buf_read(stream, buf, count))
  80         return false;
  81 #endif
  82
  83     stream->bytes_left -= count;
  84     return true;
  85 }
  86
  87 pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize)
  88 {
  89     pb_istream_t stream;
  90 #ifdef PB_BUFFER_ONLY
  91     stream.callback = NULL;
  92 #else
  93     stream.callback = &buf_read;
  94 #endif
  95     stream.state = buf;
  96     stream.bytes_left = bufsize;
  97 #ifndef PB_NO_ERRMSG
  98     stream.errmsg = NULL;
  99 #endif
 100     return stream;
 101 }
 102
 103 /********************
 104  * Helper functions *
 105  ********************/
 106
 107 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
 108 {
 109     uint8_t byte;
 110     uint32_t result;
 111
 112     if (!pb_read(stream, &byte, 1))
 113         return false;
 114
 115     if (!(byte & 0x80))
 116     {
 117         /* Quick case, 1 byte value */
 118         result = byte;
 119     }
 120     else
 121     {
 122         /* Multibyte case */
 123         uint8_t bitpos = 7;
 124         result = byte & 0x7F;
 125
 126         do
 127         {
 128             if (bitpos >= 32)
 129                 PB_RETURN_ERROR(stream, "varint overflow");
 130
 131             if (!pb_read(stream, &byte, 1))
 132                 return false;
 133
 134             result |= (uint32_t)(byte & 0x7F) << bitpos;
 135             bitpos = (uint8_t)(bitpos + 7);
 136         } while (byte & 0x80);
 137    }
 138
 139    *dest = result;
 140    return true;
 141 }
 142
 143 bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest)
 144 {
 145     uint8_t byte;
 146     uint8_t bitpos = 0;
 147     uint64_t result = 0;
 148
 149     do
 150     {
 151         if (bitpos >= 64)
 152             PB_RETURN_ERROR(stream, "varint overflow");
 153
 154         if (!pb_read(stream, &byte, 1))
 155             return false;
 156
 157         result |= (uint64_t)(byte & 0x7F) << bitpos;
 158         bitpos = (uint8_t)(bitpos + 7);
 159     } while (byte & 0x80);
 160
 161     *dest = result;
 162     return true;
 163 }
 164
 165 bool checkreturn pb_skip_varint(pb_istream_t *stream)
 166 {
 167     uint8_t byte;
 168     do
 169     {
 170         if (!pb_read(stream, &byte, 1))
 171             return false;
 172     } while (byte & 0x80);
 173     return true;
 174 }
 175
 176 bool checkreturn pb_skip_string(pb_istream_t *stream)
 177 {
 178     uint32_t length;
 179     if (!pb_decode_varint32(stream, &length))
 180         return false;
 181
 182     return pb_read(stream, NULL, length);
 183 }
 184
 185 bool checkreturn pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof)
 186 {
 187     uint32_t temp;
 188     *eof = false;
 189     *wire_type = (pb_wire_type_t) 0;
 190     *tag = 0;
 191
 192     if (!pb_decode_varint32(stream, &temp))
 193     {
 194         if (stream->bytes_left == 0)
 195             *eof = true;
 196
 197         return false;
 198     }
 199
 200     if (temp == 0)
 201     {
 202         *eof = true; /* Special feature: allow 0-terminated messages. */
 203         return false;
 204     }
 205
 206     *tag = temp >> 3;
 207     *wire_type = (pb_wire_type_t)(temp & 7);
 208     return true;
 209 }
 210
 211 bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type)
 212 {
 213     switch (wire_type)
 214     {
 215         case PB_WT_VARINT: return pb_skip_varint(stream);
 216         case PB_WT_64BIT: return pb_read(stream, NULL, 8);
 217         case PB_WT_STRING: return pb_skip_string(stream);
 218         case PB_WT_32BIT: return pb_read(stream, NULL, 4);
 219         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 220     }
 221 }
 222
 223 /* Read a raw value to buffer, for the purpose of passing it to callback as
 224  * a substream. Size is maximum size on call, and actual size on return.
 225  */
 226 static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size)
 227 {
 228     size_t max_size = *size;
 229     switch (wire_type)
 230     {
 231         case PB_WT_VARINT:
 232             *size = 0;
 233             do
 234             {
 235                 (*size)++;
 236                 if (*size > max_size) return false;
 237                 if (!pb_read(stream, buf, 1)) return false;
 238             } while (*buf++ & 0x80);
 239             return true;
 240
 241         case PB_WT_64BIT:
 242             *size = 8;
 243             return pb_read(stream, buf, 8);
 244
 245         case PB_WT_32BIT:
 246             *size = 4;
 247             return pb_read(stream, buf, 4);
 248
 249         default: PB_RETURN_ERROR(stream, "invalid wire_type");
 250     }
 251 }
 252
 253 /* Decode string length from stream and return a substream with limited length.
 254  * Remember to close the substream using pb_close_string_substream().
 255  */
 256 bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 257 {
 258     uint32_t size;
 259     if (!pb_decode_varint32(stream, &size))
 260         return false;
 261
 262     *substream = *stream;
 263     if (substream->bytes_left < size)
 264         PB_RETURN_ERROR(stream, "parent stream too short");
 265
 266     substream->bytes_left = size;
 267     stream->bytes_left -= size;
 268     return true;
 269 }
 270
 271 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 272 {
 273     stream->state = substream->state;
 274
 275 #ifndef PB_NO_ERRMSG
 276     stream->errmsg = substream->errmsg;
 277 #endif
 278 }
 279
 280 /* Iterator for pb_field_t list */
 281 typedef struct {
 282     const pb_field_t *start; /* Start of the pb_field_t array */
 283     const pb_field_t *current; /* Current position of the iterator */
 284     unsigned field_index; /* Zero-based index of the field. */
 285     unsigned required_field_index; /* Zero-based index that counts only the required fields */
 286     void *dest_struct; /* Pointer to the destination structure to decode to */
 287     void *pData; /* Pointer where to store current field value */
 288     void *pSize; /* Pointer where to store the size of current array field */
 289 } pb_field_iterator_t;
 290
 291 static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
 292 {
 293     iter->start = iter->current = fields;
 294     iter->field_index = 0;
 295     iter->required_field_index = 0;
 296     iter->pData = (char*)dest_struct + iter->current->data_offset;
 297     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 298     iter->dest_struct = dest_struct;
 299 }
 300
 301 static bool pb_field_next(pb_field_iterator_t *iter)
 302 {
 303     bool notwrapped = true;
 304     size_t prev_size = iter->current->data_size;
 305
 306     if (PB_HTYPE(iter->current->type) == PB_HTYPE_REPEATED)
 307         prev_size *= iter->current->array_size;
 308
 309     if (PB_HTYPE(iter->current->type) == PB_HTYPE_REQUIRED)
 310         iter->required_field_index++;
 311
 312     iter->current++;
 313     iter->field_index++;
 314     if (iter->current->tag == 0)
 315     {
 316         iter->current = iter->start;
 317         iter->field_index = 0;
 318         iter->required_field_index = 0;
 319         iter->pData = iter->dest_struct;
 320         prev_size = 0;
 321         notwrapped = false;
 322     }
 323
 324     iter->pData = (char*)iter->pData + prev_size + iter->current->data_offset;
 325     iter->pSize = (char*)iter->pData + iter->current->size_offset;
 326     return notwrapped;
 327 }
 328
 329 static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag)
 330 {
 331     unsigned start = iter->field_index;
 332
 333     do {
 334         if (iter->current->tag == tag)
 335             return true;
 336         pb_field_next(iter);
 337     } while (iter->field_index != start);
 338
 339     return false;
 340 }
 341
 342 /*************************
 343  * Decode a single field *
 344  *************************/
 345
 346 static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 347 {
 348     pb_decoder_t func = PB_DECODERS[PB_LTYPE(iter->current->type)];
 349
 350     switch (PB_HTYPE(iter->current->type))
 351     {
 352         case PB_HTYPE_REQUIRED:
 353             return func(stream, iter->current, iter->pData);
 354
 355         case PB_HTYPE_OPTIONAL:
 356             *(bool*)iter->pSize = true;
 357             return func(stream, iter->current, iter->pData);
 358
 359         case PB_HTYPE_REPEATED:
 360             if (wire_type == PB_WT_STRING
 361                 && PB_LTYPE(iter->current->type) <= PB_LTYPE_LAST_PACKABLE)
 362             {
 363                 /* Packed array */
 364                 bool status = true;
 365                 size_t *size = (size_t*)iter->pSize;
 366                 pb_istream_t substream;
 367                 if (!pb_make_string_substream(stream, &substream))
 368                     return false;
 369
 370                 while (substream.bytes_left && *size < iter->current->array_size)
 371                 {
 372                     void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 373                     if (!func(&substream, iter->current, pItem))
 374                     {
 375                         status = false;
 376                         break;
 377                     }
 378                     (*size)++;
 379                 }
 380                 pb_close_string_substream(stream, &substream);
 381
 382                 if (substream.bytes_left != 0)
 383                     PB_RETURN_ERROR(stream, "array overflow");
 384
 385                 return status;
 386             }
 387             else
 388             {
 389                 /* Repeated field */
 390                 size_t *size = (size_t*)iter->pSize;
 391                 void *pItem = (uint8_t*)iter->pData + iter->current->data_size * (*size);
 392                 if (*size >= iter->current->array_size)
 393                     PB_RETURN_ERROR(stream, "array overflow");
 394
 395                 (*size)++;
 396                 return func(stream, iter->current, pItem);
 397             }
 398
 399         case PB_HTYPE_CALLBACK:
 400         {
 401             pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
 402
 403             if (pCallback->funcs.decode == NULL)
 404                 return pb_skip_field(stream, wire_type);
 405
 406             if (wire_type == PB_WT_STRING)
 407             {
 408                 pb_istream_t substream;
 409
 410                 if (!pb_make_string_substream(stream, &substream))
 411                     return false;
 412
 413                 while (substream.bytes_left)
 414                 {
 415                     if (!pCallback->funcs.decode(&substream, iter->current, pCallback->arg))
 416                         PB_RETURN_ERROR(stream, "callback failed");
 417                 }
 418
 419                 pb_close_string_substream(stream, &substream);
 420                 return true;
 421             }
 422             else
 423             {
 424                 /* Copy the single scalar value to stack.
 425                  * This is required so that we can limit the stream length,
 426                  * which in turn allows to use same callback for packed and
 427                  * not-packed fields. */
 428                 pb_istream_t substream;
 429                 uint8_t buffer[10];
 430                 size_t size = sizeof(buffer);
 431
 432                 if (!read_raw_value(stream, wire_type, buffer, &size))
 433                     return false;
 434                 substream = pb_istream_from_buffer(buffer, size);
 435
 436                 return pCallback->funcs.decode(&substream, iter->current, pCallback->arg);
 437             }
 438         }
 439
 440         default:
 441             PB_RETURN_ERROR(stream, "invalid field type");
 442     }
 443 }
 444
 445 /* Initialize message fields to default values, recursively */
 446 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
 447 {
 448     pb_field_iterator_t iter;
 449     pb_field_init(&iter, fields, dest_struct);
 450
 451     /* Initialize size/has fields and apply default values */
 452     do
 453     {
 454         if (iter.current->tag == 0)
 455             continue;
 456
 457         /* Initialize the size field for optional/repeated fields to 0. */
 458         if (PB_HTYPE(iter.current->type) == PB_HTYPE_OPTIONAL)
 459         {
 460             *(bool*)iter.pSize = false;
 461         }
 462         else if (PB_HTYPE(iter.current->type) == PB_HTYPE_REPEATED)
 463         {
 464             *(size_t*)iter.pSize = 0;
 465             continue; /* Array is empty, no need to initialize contents */
 466         }
 467
 468         /* Initialize field contents to default value */
 469         if (PB_HTYPE(iter.current->type) == PB_HTYPE_CALLBACK)
 470         {
 471             continue; /* Don't overwrite callback */
 472         }
 473         else if (PB_LTYPE(iter.current->type) == PB_LTYPE_SUBMESSAGE)
 474         {
 475             pb_message_set_to_defaults((const pb_field_t *) iter.current->ptr, iter.pData);
 476         }
 477         else if (iter.current->ptr != NULL)
 478         {
 479             memcpy(iter.pData, iter.current->ptr, iter.current->data_size);
 480         }
 481         else
 482         {
 483             memset(iter.pData, 0, iter.current->data_size);
 484         }
 485     } while (pb_field_next(&iter));
 486 }
 487
 488 /*********************
 489  * Decode all fields *
 490  *********************/
 491
 492 bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 493 {
 494     uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0}; /* Used to check for required fields */
 495     pb_field_iterator_t iter;
 496
 497     pb_field_init(&iter, fields, dest_struct);
 498
 499     while (stream->bytes_left)
 500     {
 501         uint32_t tag;
 502         pb_wire_type_t wire_type;
 503         bool eof;
 504
 505         if (!pb_decode_tag(stream, &wire_type, &tag, &eof))
 506         {
 507             if (eof)
 508                 break;
 509             else
 510                 return false;
 511         }
 512
 513         if (!pb_field_find(&iter, tag))
 514         {
 515             /* No match found, skip data */
 516             if (!pb_skip_field(stream, wire_type))
 517                 return false;
 518             continue;
 519         }
 520
 521         if (PB_HTYPE(iter.current->type) == PB_HTYPE_REQUIRED
 522             && iter.required_field_index < PB_MAX_REQUIRED_FIELDS)
 523         {
 524             fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7));
 525         }
 526
 527         if (!decode_field(stream, wire_type, &iter))
 528             return false;
 529     }
 530
 531     /* Check that all required fields were present. */
 532     {
 533         /* First figure out the number of required fields by
 534          * seeking to the end of the field array. Usually we
 535          * are already close to end after decoding.
 536          */
 537         unsigned req_field_count;
 538         pb_type_t last_type;
 539         unsigned i;
 540         do {
 541             req_field_count = iter.required_field_index;
 542             last_type = iter.current->type;
 543         } while (pb_field_next(&iter));
 544
 545         /* Fixup if last field was also required. */
 546         if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED)
 547             req_field_count++;
 548
 549         /* Check the whole bytes */
 550         for (i = 0; i < (req_field_count >> 3); i++)
 551         {
 552             if (fields_seen[i] != 0xFF)
 553                 PB_RETURN_ERROR(stream, "missing required field");
 554         }
 555
 556         /* Check the remaining bits */
 557         if (fields_seen[req_field_count >> 3] != (0xFF >> (8 - (req_field_count & 7))))
 558             PB_RETURN_ERROR(stream, "missing required field");
 559     }
 560
 561     return true;
 562 }
 563
 564 bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 565 {
 566     pb_message_set_to_defaults(fields, dest_struct);
 567     return pb_decode_noinit(stream, fields, dest_struct);
 568 }
 569
 570 /* Field decoders */
 571
 572 bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest)
 573 {
 574     uint64_t value;
 575     if (!pb_decode_varint(stream, &value))
 576         return false;
 577
 578     if (value & 1)
 579         *dest = (int64_t)(~(value >> 1));
 580     else
 581         *dest = (int64_t)(value >> 1);
 582
 583     return true;
 584 }
 585
 586 bool pb_decode_fixed32(pb_istream_t *stream, void *dest)
 587 {
 588     #ifdef __BIG_ENDIAN__
 589     uint8_t *bytes = (uint8_t*)dest;
 590     uint8_t lebytes[4];
 591
 592     if (!pb_read(stream, lebytes, 4))
 593         return false;
 594
 595     bytes[0] = lebytes[3];
 596     bytes[1] = lebytes[2];
 597     bytes[2] = lebytes[1];
 598     bytes[3] = lebytes[0];
 599     return true;
 600     #else
 601     return pb_read(stream, (uint8_t*)dest, 4);
 602     #endif
 603 }
 604
 605 bool pb_decode_fixed64(pb_istream_t *stream, void *dest)
 606 {
 607     #ifdef __BIG_ENDIAN__
 608     uint8_t *bytes = (uint8_t*)dest;
 609     uint8_t lebytes[8];
 610
 611     if (!pb_read(stream, lebytes, 8))
 612         return false;
 613
 614     bytes[0] = lebytes[7];
 615     bytes[1] = lebytes[6];
 616     bytes[2] = lebytes[5];
 617     bytes[3] = lebytes[4];
 618     bytes[4] = lebytes[3];
 619     bytes[5] = lebytes[2];
 620     bytes[6] = lebytes[1];
 621     bytes[7] = lebytes[0];
 622     return true;
 623     #else
 624     return pb_read(stream, (uint8_t*)dest, 8);
 625     #endif
 626 }
 627
 628 bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 629 {
 630     uint64_t value;
 631     bool status = pb_decode_varint(stream, &value);
 632
 633     switch (field->data_size)
 634     {
 635         case 1: *(uint8_t*)dest = (uint8_t)value; break;
 636         case 2: *(uint16_t*)dest = (uint16_t)value; break;
 637         case 4: *(uint32_t*)dest = (uint32_t)value; break;
 638         case 8: *(uint64_t*)dest = value; break;
 639         default: PB_RETURN_ERROR(stream, "invalid data_size");
 640     }
 641
 642     return status;
 643 }
 644
 645 bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 646 {
 647     int64_t value;
 648     bool status = pb_decode_svarint(stream, &value);
 649
 650     switch (field->data_size)
 651     {
 652         case 4: *(int32_t*)dest = (int32_t)value; break;
 653         case 8: *(int64_t*)dest = value; break;
 654         default: PB_RETURN_ERROR(stream, "invalid data_size");
 655     }
 656
 657     return status;
 658 }
 659
 660 bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
 661 {
 662     UNUSED(field);
 663     return pb_decode_fixed32(stream, dest);
 664 }
 665
 666 bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
 667 {
 668     UNUSED(field);
 669     return pb_decode_fixed64(stream, dest);
 670 }
 671
 672 bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
 673 {
 674     pb_bytes_array_t *x = (pb_bytes_array_t*)dest;
 675
 676     uint32_t temp;
 677     if (!pb_decode_varint32(stream, &temp))
 678         return false;
 679     x->size = temp;
 680
 681     /* Check length, noting the space taken by the size_t header. */
 682     if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
 683         PB_RETURN_ERROR(stream, "bytes overflow");
 684
 685     return pb_read(stream, x->bytes, x->size);
 686 }
 687
 688 bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
 689 {
 690     uint32_t size;
 691     bool status;
 692     if (!pb_decode_varint32(stream, &size))
 693         return false;
 694
 695     /* Check length, noting the null terminator */
 696     if (size + 1 > field->data_size)
 697         PB_RETURN_ERROR(stream, "string overflow");
 698
 699     status = pb_read(stream, (uint8_t*)dest, size);
 700     *((uint8_t*)dest + size) = 0;
 701     return status;
 702 }
 703
 704 bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 705 {
 706     bool status;
 707     pb_istream_t substream;
 708     const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr;
 709
 710     if (!pb_make_string_substream(stream, &substream))
 711         return false;
 712
 713     if (field->ptr == NULL)
 714         PB_RETURN_ERROR(stream, "invalid field descriptor");
 715
 716     /* New array entries need to be initialized, while required and optional
 717      * submessages have already been initialized in the top-level pb_decode. */
 718     if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
 719         status = pb_decode(&substream, submsg_fields, dest);
 720     else
 721         status = pb_decode_noinit(&substream, submsg_fields, dest);
 722
 723     pb_close_string_substream(stream, &substream);
 724     return status;
 725 }