/// 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; }