/// Retrieve user's digest data as JSON object. Caller is responsible for deleting.
HTTPCode HSSConnection::get_digest_data(const std::string& private_user_identity,
const std::string& public_user_identity,
Json::Value*& digest_data,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
SAS::Event event(trail, SASEvent::HTTP_HOMESTEAD_DIGEST, 0);
event.add_var_param(private_user_identity);
event.add_var_param(public_user_identity);
SAS::report_event(event);
std::string path = "/impi/" +
Utils::url_escape(private_user_identity) +
"/digest";
if (!public_user_identity.empty())
{
path += "?public_id=" + Utils::url_escape(public_user_identity);
}
HTTPCode rc = get_json_object(path, digest_data, trail);
unsigned long latency_us = 0;
if (stopWatch.read(latency_us))
{
_latency_stat.accumulate(latency_us);
_digest_latency_stat.accumulate(latency_us);
}
return rc;
}
HTTPCode HSSConnection::get_registration_data(const std::string& public_user_identity,
std::string& regstate,
std::map<std::string, Ifcs >& ifcs_map,
std::vector<std::string>& associated_uris,
std::deque<std::string>& ccfs,
std::deque<std::string>& ecfs,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
SAS::Event event(trail, SASEvent::HTTP_HOMESTEAD_GET_REG, 0);
event.add_var_param(public_user_identity);
SAS::report_event(event);
std::string path = "/impu/" + Utils::url_escape(public_user_identity) + "/reg-data";
LOG_DEBUG("Making Homestead request for %s", path.c_str());
rapidxml::xml_document<>* root_underlying_ptr = NULL;
HTTPCode http_code = get_xml_object(path, root_underlying_ptr, trail);
// Needs to be a shared pointer - multiple Ifcs objects will need a reference
// to it, so we want to delete the underlying document when they all go out
// of scope.
std::shared_ptr<rapidxml::xml_document<> > root (root_underlying_ptr);
unsigned long latency_us = 0;
// Only accumulate the latency if we haven't already applied a
// penalty
if ((http_code != HTTP_SERVER_UNAVAILABLE) &&
(http_code != HTTP_GATEWAY_TIMEOUT) &&
(stopWatch.read(latency_us)))
{
_latency_stat.accumulate(latency_us);
_subscription_latency_stat.accumulate(latency_us);
}
if (http_code != HTTP_OK)
{
// If get_xml_object has returned a HTTP error code, we have either not found
// the subscriber on the HSS or been unable to communicate with
// the HSS successfully. In either case we should fail.
LOG_ERROR("Could not get subscriber data from HSS");
return http_code;
}
// Return whether the XML was successfully decoded. The XML can be decoded and
// not return any IFCs (when the subscriber isn't registered), so a successful
// response shouldn't be taken as a guarantee of IFCs.
std::vector<std::string> unused_aliases;
return decode_homestead_xml(public_user_identity,
root,
regstate,
ifcs_map,
associated_uris,
unused_aliases,
ccfs,
ecfs,
true) ? HTTP_OK : HTTP_SERVER_ERROR;
}
/// Get an Authentication Vector as JSON object. Caller is responsible for deleting.
HTTPCode HSSConnection::get_auth_vector(const std::string& private_user_identity,
const std::string& public_user_identity,
const std::string& auth_type,
const std::string& autn,
Json::Value*& av,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
SAS::Event event(trail, SASEvent::HTTP_HOMESTEAD_VECTOR, 0);
event.add_var_param(private_user_identity);
event.add_var_param(public_user_identity);
event.add_var_param(auth_type);
SAS::report_event(event);
std::string path = "/impi/" +
Utils::url_escape(private_user_identity) +
"/av";
if (!auth_type.empty())
{
path += "/" + auth_type;
}
if (!public_user_identity.empty())
{
path += "?impu=" + Utils::url_escape(public_user_identity);
}
if (!autn.empty())
{
path += public_user_identity.empty() ? "?" : "&";
path += "autn=" + Utils::url_escape(autn);
}
HTTPCode rc = get_json_object(path, av, trail);
unsigned long latency_us = 0;
// Only accumulate the latency if we haven't already applied a
// penalty
if ((rc != HTTP_SERVER_UNAVAILABLE) &&
(rc != HTTP_GATEWAY_TIMEOUT) &&
(stopWatch.read(latency_us)))
{
_latency_stat.accumulate(latency_us);
_digest_latency_stat.accumulate(latency_us);
}
if (av == NULL)
{
LOG_ERROR("Failed to get Authentication Vector for %s",
private_user_identity.c_str());
}
return rc;
}
HTTPCode HSSConnection::update_registration_state(const std::string& public_user_identity,
const std::string& private_user_identity,
const std::string& type,
std::string& regstate,
std::map<std::string, Ifcs >& ifcs_map,
std::vector<std::string>& associated_uris,
std::deque<std::string>& ccfs,
std::deque<std::string>& ecfs,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
SAS::Event event(trail, SASEvent::HTTP_HOMESTEAD_CHECK_STATE, 0);
event.add_var_param(public_user_identity);
event.add_var_param(private_user_identity);
event.add_var_param(type);
SAS::report_event(event);
std::string path = "/impu/" + Utils::url_escape(public_user_identity) + "/reg-data";
if (!private_user_identity.empty())
{
path += "?private_id=" + Utils::url_escape(private_user_identity);
}
LOG_DEBUG("Making Homestead request for %s", path.c_str());
// Needs to be a shared pointer - multiple Ifcs objects will need a reference
// to it, so we want to delete the underlying document when they all go out
// of scope.
rapidxml::xml_document<>* root_underlying_ptr = NULL;
HTTPCode http_code = put_for_xml_object(path, "{\"reqtype\": \""+type+"\"}", root_underlying_ptr, trail);
std::shared_ptr<rapidxml::xml_document<> > root (root_underlying_ptr);
unsigned long latency_us = 0;
// Only accumulate the latency if we haven't already applied a
// penalty
if ((http_code != HTTP_SERVER_UNAVAILABLE) &&
(http_code != HTTP_GATEWAY_TIMEOUT) &&
(stopWatch.read(latency_us)))
{
_latency_stat.accumulate(latency_us);
_subscription_latency_stat.accumulate(latency_us);
}
if (http_code != HTTP_OK)
{
// If get_xml_object has returned a HTTP error code, we have either not found
// the subscriber on the HSS or been unable to communicate with
// the HSS successfully. In either case we should fail.
LOG_ERROR("Could not get subscriber data from HSS");
return http_code;
}
return decode_homestead_xml(root, regstate, ifcs_map, associated_uris, ccfs, ecfs, false) ? HTTP_OK : HTTP_SERVER_ERROR;
}
// Makes a user authorization request, and returns the data as a JSON object.
HTTPCode HSSConnection::get_user_auth_status(const std::string& private_user_identity,
const std::string& public_user_identity,
const std::string& visited_network,
const std::string& auth_type,
const bool& emergency,
rapidjson::Document*& user_auth_status,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
SAS::Event event(trail, SASEvent::HTTP_HOMESTEAD_AUTH_STATUS, 0);
event.add_var_param(private_user_identity);
event.add_var_param(public_user_identity);
SAS::report_event(event);
std::string path = "/impi/" +
Utils::url_escape(private_user_identity) +
"/registration-status" +
"?impu=" +
Utils::url_escape(public_user_identity);
if (!visited_network.empty())
{
path += "&visited-network=" + Utils::url_escape(visited_network);
}
if (!auth_type.empty())
{
path += "&auth-type=" + Utils::url_escape(auth_type);
}
if (emergency)
{
path += "&sos=true";
}
HTTPCode rc = get_json_object(path, user_auth_status, trail);
unsigned long latency_us = 0;
// Only accumulate the latency if we haven't already applied a
// penalty
if ((rc != HTTP_SERVER_UNAVAILABLE) &&
(rc != HTTP_GATEWAY_TIMEOUT) &&
(stopWatch.read(latency_us)))
{
_latency_tbl->accumulate(latency_us);
_uar_latency_tbl->accumulate(latency_us);
}
return rc;
}
/// Makes a location information request, and returns the data as a JSON object.
HTTPCode HSSConnection::get_location_data(const std::string& public_user_identity,
const bool& originating,
const std::string& auth_type,
Json::Value*& location_data,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
SAS::Event event(trail, SASEvent::HTTP_HOMESTEAD_LOCATION, 0);
event.add_var_param(public_user_identity);
SAS::report_event(event);
std::string path = "/impu/" +
Utils::url_escape(public_user_identity) +
"/location";
if (originating)
{
path += "?originating=true";
}
if (!auth_type.empty())
{
std::string prefix = !originating ? "?" : "&";
path += prefix + "auth-type=" + Utils::url_escape(auth_type);
}
HTTPCode rc = get_json_object(path, location_data, trail);
unsigned long latency_us = 0;
// Only accumulate the latency if we haven't already applied a
// penalty
if ((rc != HTTP_SERVER_UNAVAILABLE) &&
(rc != HTTP_GATEWAY_TIMEOUT) &&
(stopWatch.read(latency_us)))
{
_latency_stat.accumulate(latency_us);
_location_latency_stat.accumulate(latency_us);
}
return rc;
}
bool XDMConnection::get_simservs(const std::string& user,
std::string& xml_data,
const std::string& password,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
std::string url = "/org.etsi.ngn.simservs/users/" + Utils::url_escape(user) + "/simservs.xml";
HTTPCode http_code = _http->send_get(url, xml_data, user, trail);
unsigned long latency_us = 0;
if (stopWatch.read(latency_us))
{
_latency_stat.accumulate(latency_us);
}
return (http_code == HTTP_OK);
}
// Makes a user authorization request, and returns the data as a JSON object.
HTTPCode HSSConnection::get_user_auth_status(const std::string& private_user_identity,
const std::string& public_user_identity,
const std::string& visited_network,
const std::string& auth_type,
Json::Value*& user_auth_status,
SAS::TrailId trail)
{
Utils::StopWatch stopWatch;
stopWatch.start();
SAS::Event event(trail, SASEvent::HTTP_HOMESTEAD_AUTH_STATUS, 0);
event.add_var_param(private_user_identity);
event.add_var_param(public_user_identity);
SAS::report_event(event);
std::string path = "/impi/" +
Utils::url_escape(private_user_identity) +
"/registration-status" +
"?impu=" +
Utils::url_escape(public_user_identity);
if (!visited_network.empty())
{
path += "&visited-network=" + Utils::url_escape(visited_network);
}
if (!auth_type.empty())
{
path += "&auth-type=" + Utils::url_escape(auth_type);
}
HTTPCode rc = get_json_object(path, user_auth_status, trail);
unsigned long latency_us = 0;
if (stopWatch.read(latency_us))
{
_latency_stat.accumulate(latency_us);
_user_auth_latency_stat.accumulate(latency_us);
}
return rc;
}