C++ (Cpp) spdy_write_int32 Examples

Example #1

File: spdy_ping.c Project: GeorgeBrown/lacewing

void spdy_emit_ping (spdy_ctx * ctx, int8_t flags, int32_t id)
{
   char message [SPDY_CTRL_HEADER_SIZE + sizeof (id)];

   spdy_build_control_header (ctx, message, PING, flags, sizeof (id));
   spdy_write_int32 (message + SPDY_CTRL_HEADER_SIZE, id);

   ctx->config->emit (ctx, message, sizeof (message));
}

Example #2

File: spdy_rst_stream.c Project: GeorgeBrown/lacewing

void spdy_emit_rst_stream (spdy_ctx * ctx, int8_t flags,
                           int32_t stream_id, int32_t status_code)
{
   char message [SPDY_CTRL_HEADER_SIZE
                    + sizeof (stream_id)
                    + sizeof (status_code)];

   spdy_build_control_header (ctx, message, RST_STREAM, flags,
                              sizeof (message) - SPDY_CTRL_HEADER_SIZE);

   spdy_write_int31 (message + SPDY_CTRL_HEADER_SIZE, stream_id);
   spdy_write_int32 (message + SPDY_CTRL_HEADER_SIZE + 4, status_code);

   ctx->config->emit (ctx, message, sizeof (message));
}

Example #3

File: spdy_nv_block.c Project: cbranch/lacewing

int spdy_pack_nv_block (spdy_ctx * ctx, char ** buffer, size_t * deflate_size,
                        spdy_nv_pair * pairs, size_t count)
{
   z_stream * stream;
   spdy_nv_pair * pair;
   size_t i = 0;
   size_t orig_size;
   size_t deflate_max;
   char * p;
   int res = Z_OK;
 
   stream = &ctx->zlib_deflate;

   orig_size = ctx->version == 2 ? 2 : 4; /* size of the pair count */

   while (i < count)
   {
      orig_size += (ctx->version == 2 ? 4 : 8) /* size of the lengths */
                   + pairs [i].name_len + pairs [i].value_len;

      ++ i;
   }

   deflate_max = deflateBound (stream, orig_size);

   if (! (*buffer = (char *) malloc (deflate_max + orig_size)))
      return SPDY_E_MEM;

   i = 0;
   p = *buffer + deflate_max;

   if (ctx->version == 2)
   {
      spdy_write_int16 (p, count);
      p += sizeof (int16_t);

      while (i < count)
      {
         pair = &pairs[i ++];

         spdy_write_int16 (p, pair->name_len);
         p += sizeof (int16_t);

         memcpy (p, pair->name, pair->name_len);
         p += pair->name_len;

         spdy_write_int16 (p, pair->value_len);
         p += sizeof (int16_t);

         memcpy (p, pair->value, pair->value_len);
         p += pair->value_len;
      }
   }
   else
   {
      spdy_write_int32 (p, count);
      p += sizeof (int32_t);

      while (i < count)
      {
         pair = &pairs[i ++];

         spdy_write_int32 (p, pair->name_len);
         p += sizeof (int32_t);

         memcpy (p, pair->name, pair->name_len);
         p += pair->name_len;

         spdy_write_int32 (p, pair->value_len);
         p += sizeof (int32_t);

         memcpy (p, pair->value, pair->value_len);
         p += pair->value_len;
      }
   }

   stream->next_in = (Bytef *) *buffer + deflate_max;
   stream->avail_in = orig_size;

   stream->next_out = (Bytef *) *buffer;
   stream->avail_out = deflate_max;

   if ((res = deflate (stream, Z_SYNC_FLUSH)) != Z_OK || stream->avail_in > 0)
   {
      free (*buffer);

      return res == Z_MEM_ERROR ?
               SPDY_E_MEM : SPDY_E_DEFLATE;
   }

   *deflate_size = deflate_max - stream->avail_out;

   return SPDY_E_OK;
}