示例#1
0
AuthStore::Digest* AuthStore::BinarySerializerDeserializer::
  deserialize_digest(const std::string& digest_s)
{
  // Helper macro that bails out if we unexpectedly hit the end of the input
  // stream.
#define ASSERT_NOT_EOF(STREAM)                                                 \
if ((STREAM).eof())                                                            \
{                                                                              \
  TRC_INFO("Failed to deserialize binary document (hit EOF at %s:%d)",         \
           __FILE__, __LINE__);                                                \
  delete digest; digest = NULL;                                                \
  return NULL;                                                                 \
}

  std::istringstream iss(digest_s, std::istringstream::in|std::istringstream::binary);
  Digest* digest = new Digest();

  getline(iss, digest->_ha1, '\0');
  ASSERT_NOT_EOF(iss);
  getline(iss, digest->_opaque, '\0');
  ASSERT_NOT_EOF(iss);
  getline(iss, digest->_nonce, '\0');
  ASSERT_NOT_EOF(iss);
  getline(iss, digest->_impi, '\0');
  ASSERT_NOT_EOF(iss);
  getline(iss, digest->_realm, '\0');
  ASSERT_NOT_EOF(iss);
  iss.read((char *)&digest->_nonce_count, sizeof(uint32_t));
  ASSERT_NOT_EOF(iss);
  getline(iss, digest->_impu, '\0');
  // Could legitimately be at the end of the stream now.

  return digest;
}
示例#2
0
SessionStore::Session* SessionStore::BinarySerializerDeserializer::
deserialize_session(const std::string& data)
{
    std::istringstream iss(data, std::istringstream::in|std::istringstream::binary);
    Session* session = new Session();

    // Helper macro that bails out if we unexpectedly hit the end of the input
    // stream.
#define ASSERT_NOT_EOF(STREAM)                                                 \
if ((STREAM).eof())                                                            \
{                                                                              \
  TRC_INFO("Failed to deserialize binary document (hit EOF at %s:%d)",         \
           __FILE__, __LINE__);                                                \
  delete session; session = NULL;                                              \
  return NULL;                                                                 \
}

    getline(iss, session->session_id, '\0');
    ASSERT_NOT_EOF(iss);

    int num_ccf;
    iss.read((char*)&num_ccf, sizeof(int));
    ASSERT_NOT_EOF(iss);

    for (int ii = 0; ii < num_ccf; ii++)
    {
        std::string ccf;
        getline(iss, ccf, '\0');
        ASSERT_NOT_EOF(iss);
        session->ccf.push_back(ccf);
    }

    iss.read((char*)&session->acct_record_number, sizeof(uint32_t));
    ASSERT_NOT_EOF(iss);

    getline(iss, session->timer_id, '\0');
    ASSERT_NOT_EOF(iss);

    iss.read((char*)&session->session_refresh_time, sizeof(uint32_t));
    ASSERT_NOT_EOF(iss);

    iss.read((char*)&session->interim_interval, sizeof(uint32_t));
    // This could legitimately be the end of the stream.

    return session;
}