C++ (Cpp) mongo_wire_packet_set_header_raw Examples

Example #1

File: packet_get_set_header_raw.c Project: algernon/libmongo-client

void
test_mongo_wire_packet_get_set_header_raw (void)
{
  mongo_packet *p;
  mongo_packet_header ph1, ph2;

  p = mongo_wire_packet_new ();

  ok (mongo_wire_packet_get_header_raw (NULL, &ph2) == FALSE,
      "mongo_wire_packet_get_header_raw() should fail with a NULL packet");
  ok (mongo_wire_packet_get_header_raw (p, NULL) == FALSE,
      "mongo_wire_packet_get_header_raw() should fail with a NULL header");
  ok (mongo_wire_packet_set_header_raw (NULL, &ph1) == FALSE,
      "mongo_wire_packet_set_header_raw() should fail with a NULL packet");
  ok (mongo_wire_packet_set_header_raw (p, NULL) == FALSE,
      "mongo_wire_packet_set_header_raw() should fail with a NULL header");

  ok (mongo_wire_packet_get_header_raw (p, &ph2),
      "mongo_wire_packet_get_header_raw() works on a fresh packet");
  /* Need to convert from LE, because _new() sets the length to LE. */
  cmp_ok (GINT32_FROM_LE (ph2.length), "==", sizeof (mongo_packet_header),
          "Initial packet length is the length of the header");

  ph1.length = sizeof (mongo_packet_header);
  ph1.id = 1;
  ph1.resp_to = 0;
  ph1.opcode = 1000;

  memset (&ph2, 0, sizeof (mongo_packet_header));

  ok (mongo_wire_packet_set_header_raw (p, &ph1),
      "mongo_wire_packet_set_header_raw() works");
  ok (mongo_wire_packet_get_header_raw (p, &ph2),
      "mongo_wire_packet_get_header_raw() works");

  cmp_ok (ph1.length, "==", ph2.length,
          "Packet lengths match");
  cmp_ok (ph1.id, "==", ph2.id,
          "Sequence IDs match");
  cmp_ok (ph1.resp_to, "==", ph2.resp_to,
          "Response IDs match");
  cmp_ok (ph1.opcode, "==", ph2.opcode,
          "OPCodes match");

  mongo_wire_packet_free (p);
}

Example #2

File: mongo-client.c Project: sazzer/libmongo-client

mongo_packet *
mongo_packet_recv (mongo_connection *conn)
{
  mongo_packet *p;
  guint8 *data;
  guint32 size;
  mongo_packet_header h;

  if (!conn)
    {
      errno = ENOTCONN;
      return NULL;
    }

  if (conn->fd < 0)
    {
      errno = EBADF;
      return NULL;
    }

  memset (&h, 0, sizeof (h));
  if (recv (conn->fd, &h, sizeof (mongo_packet_header), MSG_NOSIGNAL) !=
      sizeof (mongo_packet_header))
    {
      return NULL;
    }

  h.length = GINT32_FROM_LE (h.length);
  h.id = GINT32_FROM_LE (h.id);
  h.resp_to = GINT32_FROM_LE (h.resp_to);
  h.opcode = GINT32_FROM_LE (h.opcode);

  p = mongo_wire_packet_new ();

  if (!mongo_wire_packet_set_header_raw (p, &h))
    {
      int e = errno;

      mongo_wire_packet_free (p);
      errno = e;
      return NULL;
    }

  size = h.length - sizeof (mongo_packet_header);
  data = g_new0 (guint8, size);
  if ((guint32)recv (conn->fd, data, size, MSG_NOSIGNAL) != size)
    {
      int e = errno;

      g_free (data);
      mongo_wire_packet_free (p);
      errno = e;
      return NULL;
    }

  if (!mongo_wire_packet_set_data (p, data, size))
    {
      int e = errno;

      g_free (data);
      mongo_wire_packet_free (p);
      errno = e;
      return NULL;
    }

  g_free (data);

  return p;
}