diff options
Diffstat (limited to 'src/server/proto/Login/Login.pb.h')
| -rw-r--r-- | src/server/proto/Login/Login.pb.h | 982 |
1 files changed, 982 insertions, 0 deletions
diff --git a/src/server/proto/Login/Login.pb.h b/src/server/proto/Login/Login.pb.h index 9f23746d954..331c6c70406 100644 --- a/src/server/proto/Login/Login.pb.h +++ b/src/server/proto/Login/Login.pb.h @@ -42,6 +42,7 @@ class FormInput; class FormInputs; class FormInputValue; class LoginForm; +class SrpLoginChallenge; class LoginResult; class LoginRefreshResult; class GameAccountInfo; @@ -314,16 +315,46 @@ class TC_PROTO_API FormInputs : public ::google::protobuf::Message { inline ::google::protobuf::RepeatedPtrField< ::Battlenet::JSON::Login::FormInput >* mutable_inputs(); + // optional string srp_url = 3; + inline bool has_srp_url() const; + inline void clear_srp_url(); + static const int kSrpUrlFieldNumber = 3; + inline const ::std::string& srp_url() const; + inline void set_srp_url(const ::std::string& value); + inline void set_srp_url(const char* value); + inline void set_srp_url(const char* value, size_t size); + inline ::std::string* mutable_srp_url(); + inline ::std::string* release_srp_url(); + inline void set_allocated_srp_url(::std::string* srp_url); + + // optional string srp_js = 4; + inline bool has_srp_js() const; + inline void clear_srp_js(); + static const int kSrpJsFieldNumber = 4; + inline const ::std::string& srp_js() const; + inline void set_srp_js(const ::std::string& value); + inline void set_srp_js(const char* value); + inline void set_srp_js(const char* value, size_t size); + inline ::std::string* mutable_srp_js(); + inline ::std::string* release_srp_js(); + inline void set_allocated_srp_js(::std::string* srp_js); + // @@protoc_insertion_point(class_scope:Battlenet.JSON.Login.FormInputs) private: inline void set_has_type(); inline void clear_has_type(); + inline void set_has_srp_url(); + inline void clear_has_srp_url(); + inline void set_has_srp_js(); + inline void clear_has_srp_js(); ::google::protobuf::UnknownFieldSet _unknown_fields_; ::google::protobuf::uint32 _has_bits_[1]; mutable int _cached_size_; ::google::protobuf::RepeatedPtrField< ::Battlenet::JSON::Login::FormInput > inputs_; + ::std::string* srp_url_; + ::std::string* srp_js_; int type_; friend void TC_PROTO_API protobuf_AddDesc_Login_2eproto(); friend void protobuf_AssignDesc_Login_2eproto(); @@ -534,6 +565,182 @@ class TC_PROTO_API LoginForm : public ::google::protobuf::Message { }; // ------------------------------------------------------------------- +class TC_PROTO_API SrpLoginChallenge : public ::google::protobuf::Message { + public: + SrpLoginChallenge(); + virtual ~SrpLoginChallenge(); + + SrpLoginChallenge(const SrpLoginChallenge& from); + + inline SrpLoginChallenge& operator=(const SrpLoginChallenge& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const SrpLoginChallenge& default_instance(); + + void Swap(SrpLoginChallenge* other); + + // implements Message ---------------------------------------------- + + SrpLoginChallenge* New() const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 version = 1; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 1; + inline ::google::protobuf::uint32 version() const; + inline void set_version(::google::protobuf::uint32 value); + + // required uint32 iterations = 2; + inline bool has_iterations() const; + inline void clear_iterations(); + static const int kIterationsFieldNumber = 2; + inline ::google::protobuf::uint32 iterations() const; + inline void set_iterations(::google::protobuf::uint32 value); + + // required string modulus = 3; + inline bool has_modulus() const; + inline void clear_modulus(); + static const int kModulusFieldNumber = 3; + inline const ::std::string& modulus() const; + inline void set_modulus(const ::std::string& value); + inline void set_modulus(const char* value); + inline void set_modulus(const char* value, size_t size); + inline ::std::string* mutable_modulus(); + inline ::std::string* release_modulus(); + inline void set_allocated_modulus(::std::string* modulus); + + // required string generator = 4; + inline bool has_generator() const; + inline void clear_generator(); + static const int kGeneratorFieldNumber = 4; + inline const ::std::string& generator() const; + inline void set_generator(const ::std::string& value); + inline void set_generator(const char* value); + inline void set_generator(const char* value, size_t size); + inline ::std::string* mutable_generator(); + inline ::std::string* release_generator(); + inline void set_allocated_generator(::std::string* generator); + + // required string hash_function = 5; + inline bool has_hash_function() const; + inline void clear_hash_function(); + static const int kHashFunctionFieldNumber = 5; + inline const ::std::string& hash_function() const; + inline void set_hash_function(const ::std::string& value); + inline void set_hash_function(const char* value); + inline void set_hash_function(const char* value, size_t size); + inline ::std::string* mutable_hash_function(); + inline ::std::string* release_hash_function(); + inline void set_allocated_hash_function(::std::string* hash_function); + + // required string username = 6; + inline bool has_username() const; + inline void clear_username(); + static const int kUsernameFieldNumber = 6; + inline const ::std::string& username() const; + inline void set_username(const ::std::string& value); + inline void set_username(const char* value); + inline void set_username(const char* value, size_t size); + inline ::std::string* mutable_username(); + inline ::std::string* release_username(); + inline void set_allocated_username(::std::string* username); + + // required string salt = 7; + inline bool has_salt() const; + inline void clear_salt(); + static const int kSaltFieldNumber = 7; + inline const ::std::string& salt() const; + inline void set_salt(const ::std::string& value); + inline void set_salt(const char* value); + inline void set_salt(const char* value, size_t size); + inline ::std::string* mutable_salt(); + inline ::std::string* release_salt(); + inline void set_allocated_salt(::std::string* salt); + + // required string public_B = 8; + inline bool has_public_b() const; + inline void clear_public_b(); + static const int kPublicBFieldNumber = 8; + inline const ::std::string& public_b() const; + inline void set_public_b(const ::std::string& value); + inline void set_public_b(const char* value); + inline void set_public_b(const char* value, size_t size); + inline ::std::string* mutable_public_b(); + inline ::std::string* release_public_b(); + inline void set_allocated_public_b(::std::string* public_b); + + // optional bool eligible_credential_upgrade = 9; + inline bool has_eligible_credential_upgrade() const; + inline void clear_eligible_credential_upgrade(); + static const int kEligibleCredentialUpgradeFieldNumber = 9; + inline bool eligible_credential_upgrade() const; + inline void set_eligible_credential_upgrade(bool value); + + // @@protoc_insertion_point(class_scope:Battlenet.JSON.Login.SrpLoginChallenge) + private: + inline void set_has_version(); + inline void clear_has_version(); + inline void set_has_iterations(); + inline void clear_has_iterations(); + inline void set_has_modulus(); + inline void clear_has_modulus(); + inline void set_has_generator(); + inline void clear_has_generator(); + inline void set_has_hash_function(); + inline void clear_has_hash_function(); + inline void set_has_username(); + inline void clear_has_username(); + inline void set_has_salt(); + inline void clear_has_salt(); + inline void set_has_public_b(); + inline void clear_has_public_b(); + inline void set_has_eligible_credential_upgrade(); + inline void clear_has_eligible_credential_upgrade(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::uint32 version_; + ::google::protobuf::uint32 iterations_; + ::std::string* modulus_; + ::std::string* generator_; + ::std::string* hash_function_; + ::std::string* username_; + ::std::string* salt_; + ::std::string* public_b_; + bool eligible_credential_upgrade_; + friend void TC_PROTO_API protobuf_AddDesc_Login_2eproto(); + friend void protobuf_AssignDesc_Login_2eproto(); + friend void protobuf_ShutdownFile_Login_2eproto(); + + void InitAsDefaultInstance(); + static SrpLoginChallenge* default_instance_; +}; +// ------------------------------------------------------------------- + class TC_PROTO_API LoginResult : public ::google::protobuf::Message { public: LoginResult(); @@ -629,6 +836,18 @@ class TC_PROTO_API LoginResult : public ::google::protobuf::Message { inline ::std::string* release_login_ticket(); inline void set_allocated_login_ticket(::std::string* login_ticket); + // optional string server_evidence_M2 = 6; + inline bool has_server_evidence_m2() const; + inline void clear_server_evidence_m2(); + static const int kServerEvidenceM2FieldNumber = 6; + inline const ::std::string& server_evidence_m2() const; + inline void set_server_evidence_m2(const ::std::string& value); + inline void set_server_evidence_m2(const char* value); + inline void set_server_evidence_m2(const char* value, size_t size); + inline ::std::string* mutable_server_evidence_m2(); + inline ::std::string* release_server_evidence_m2(); + inline void set_allocated_server_evidence_m2(::std::string* server_evidence_m2); + // @@protoc_insertion_point(class_scope:Battlenet.JSON.Login.LoginResult) private: inline void set_has_authentication_state(); @@ -641,6 +860,8 @@ class TC_PROTO_API LoginResult : public ::google::protobuf::Message { inline void clear_has_url(); inline void set_has_login_ticket(); inline void clear_has_login_ticket(); + inline void set_has_server_evidence_m2(); + inline void clear_has_server_evidence_m2(); ::google::protobuf::UnknownFieldSet _unknown_fields_; @@ -650,6 +871,7 @@ class TC_PROTO_API LoginResult : public ::google::protobuf::Message { ::std::string* error_message_; ::std::string* url_; ::std::string* login_ticket_; + ::std::string* server_evidence_m2_; int authentication_state_; friend void TC_PROTO_API protobuf_AddDesc_Login_2eproto(); friend void protobuf_AssignDesc_Login_2eproto(); @@ -1252,6 +1474,158 @@ FormInputs::mutable_inputs() { return &inputs_; } +// optional string srp_url = 3; +inline bool FormInputs::has_srp_url() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void FormInputs::set_has_srp_url() { + _has_bits_[0] |= 0x00000004u; +} +inline void FormInputs::clear_has_srp_url() { + _has_bits_[0] &= ~0x00000004u; +} +inline void FormInputs::clear_srp_url() { + if (srp_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_url_->clear(); + } + clear_has_srp_url(); +} +inline const ::std::string& FormInputs::srp_url() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.FormInputs.srp_url) + return *srp_url_; +} +inline void FormInputs::set_srp_url(const ::std::string& value) { + set_has_srp_url(); + if (srp_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_url_ = new ::std::string; + } + srp_url_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.FormInputs.srp_url) +} +inline void FormInputs::set_srp_url(const char* value) { + set_has_srp_url(); + if (srp_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_url_ = new ::std::string; + } + srp_url_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.FormInputs.srp_url) +} +inline void FormInputs::set_srp_url(const char* value, size_t size) { + set_has_srp_url(); + if (srp_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_url_ = new ::std::string; + } + srp_url_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.FormInputs.srp_url) +} +inline ::std::string* FormInputs::mutable_srp_url() { + set_has_srp_url(); + if (srp_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_url_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.FormInputs.srp_url) + return srp_url_; +} +inline ::std::string* FormInputs::release_srp_url() { + clear_has_srp_url(); + if (srp_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = srp_url_; + srp_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FormInputs::set_allocated_srp_url(::std::string* srp_url) { + if (srp_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete srp_url_; + } + if (srp_url) { + set_has_srp_url(); + srp_url_ = srp_url; + } else { + clear_has_srp_url(); + srp_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.FormInputs.srp_url) +} + +// optional string srp_js = 4; +inline bool FormInputs::has_srp_js() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void FormInputs::set_has_srp_js() { + _has_bits_[0] |= 0x00000008u; +} +inline void FormInputs::clear_has_srp_js() { + _has_bits_[0] &= ~0x00000008u; +} +inline void FormInputs::clear_srp_js() { + if (srp_js_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_js_->clear(); + } + clear_has_srp_js(); +} +inline const ::std::string& FormInputs::srp_js() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.FormInputs.srp_js) + return *srp_js_; +} +inline void FormInputs::set_srp_js(const ::std::string& value) { + set_has_srp_js(); + if (srp_js_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_js_ = new ::std::string; + } + srp_js_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.FormInputs.srp_js) +} +inline void FormInputs::set_srp_js(const char* value) { + set_has_srp_js(); + if (srp_js_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_js_ = new ::std::string; + } + srp_js_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.FormInputs.srp_js) +} +inline void FormInputs::set_srp_js(const char* value, size_t size) { + set_has_srp_js(); + if (srp_js_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_js_ = new ::std::string; + } + srp_js_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.FormInputs.srp_js) +} +inline ::std::string* FormInputs::mutable_srp_js() { + set_has_srp_js(); + if (srp_js_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + srp_js_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.FormInputs.srp_js) + return srp_js_; +} +inline ::std::string* FormInputs::release_srp_js() { + clear_has_srp_js(); + if (srp_js_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = srp_js_; + srp_js_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void FormInputs::set_allocated_srp_js(::std::string* srp_js) { + if (srp_js_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete srp_js_; + } + if (srp_js) { + set_has_srp_js(); + srp_js_ = srp_js; + } else { + clear_has_srp_js(); + srp_js_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.FormInputs.srp_js) +} + // ------------------------------------------------------------------- // FormInputValue @@ -1672,6 +2046,538 @@ LoginForm::mutable_inputs() { // ------------------------------------------------------------------- +// SrpLoginChallenge + +// required uint32 version = 1; +inline bool SrpLoginChallenge::has_version() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SrpLoginChallenge::set_has_version() { + _has_bits_[0] |= 0x00000001u; +} +inline void SrpLoginChallenge::clear_has_version() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SrpLoginChallenge::clear_version() { + version_ = 0u; + clear_has_version(); +} +inline ::google::protobuf::uint32 SrpLoginChallenge::version() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.version) + return version_; +} +inline void SrpLoginChallenge::set_version(::google::protobuf::uint32 value) { + set_has_version(); + version_ = value; + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.version) +} + +// required uint32 iterations = 2; +inline bool SrpLoginChallenge::has_iterations() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SrpLoginChallenge::set_has_iterations() { + _has_bits_[0] |= 0x00000002u; +} +inline void SrpLoginChallenge::clear_has_iterations() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SrpLoginChallenge::clear_iterations() { + iterations_ = 0u; + clear_has_iterations(); +} +inline ::google::protobuf::uint32 SrpLoginChallenge::iterations() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.iterations) + return iterations_; +} +inline void SrpLoginChallenge::set_iterations(::google::protobuf::uint32 value) { + set_has_iterations(); + iterations_ = value; + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.iterations) +} + +// required string modulus = 3; +inline bool SrpLoginChallenge::has_modulus() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SrpLoginChallenge::set_has_modulus() { + _has_bits_[0] |= 0x00000004u; +} +inline void SrpLoginChallenge::clear_has_modulus() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SrpLoginChallenge::clear_modulus() { + if (modulus_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + modulus_->clear(); + } + clear_has_modulus(); +} +inline const ::std::string& SrpLoginChallenge::modulus() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.modulus) + return *modulus_; +} +inline void SrpLoginChallenge::set_modulus(const ::std::string& value) { + set_has_modulus(); + if (modulus_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + modulus_ = new ::std::string; + } + modulus_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.modulus) +} +inline void SrpLoginChallenge::set_modulus(const char* value) { + set_has_modulus(); + if (modulus_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + modulus_ = new ::std::string; + } + modulus_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.SrpLoginChallenge.modulus) +} +inline void SrpLoginChallenge::set_modulus(const char* value, size_t size) { + set_has_modulus(); + if (modulus_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + modulus_ = new ::std::string; + } + modulus_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.SrpLoginChallenge.modulus) +} +inline ::std::string* SrpLoginChallenge::mutable_modulus() { + set_has_modulus(); + if (modulus_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + modulus_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.SrpLoginChallenge.modulus) + return modulus_; +} +inline ::std::string* SrpLoginChallenge::release_modulus() { + clear_has_modulus(); + if (modulus_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = modulus_; + modulus_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void SrpLoginChallenge::set_allocated_modulus(::std::string* modulus) { + if (modulus_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete modulus_; + } + if (modulus) { + set_has_modulus(); + modulus_ = modulus; + } else { + clear_has_modulus(); + modulus_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.SrpLoginChallenge.modulus) +} + +// required string generator = 4; +inline bool SrpLoginChallenge::has_generator() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void SrpLoginChallenge::set_has_generator() { + _has_bits_[0] |= 0x00000008u; +} +inline void SrpLoginChallenge::clear_has_generator() { + _has_bits_[0] &= ~0x00000008u; +} +inline void SrpLoginChallenge::clear_generator() { + if (generator_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + generator_->clear(); + } + clear_has_generator(); +} +inline const ::std::string& SrpLoginChallenge::generator() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.generator) + return *generator_; +} +inline void SrpLoginChallenge::set_generator(const ::std::string& value) { + set_has_generator(); + if (generator_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + generator_ = new ::std::string; + } + generator_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.generator) +} +inline void SrpLoginChallenge::set_generator(const char* value) { + set_has_generator(); + if (generator_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + generator_ = new ::std::string; + } + generator_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.SrpLoginChallenge.generator) +} +inline void SrpLoginChallenge::set_generator(const char* value, size_t size) { + set_has_generator(); + if (generator_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + generator_ = new ::std::string; + } + generator_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.SrpLoginChallenge.generator) +} +inline ::std::string* SrpLoginChallenge::mutable_generator() { + set_has_generator(); + if (generator_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + generator_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.SrpLoginChallenge.generator) + return generator_; +} +inline ::std::string* SrpLoginChallenge::release_generator() { + clear_has_generator(); + if (generator_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = generator_; + generator_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void SrpLoginChallenge::set_allocated_generator(::std::string* generator) { + if (generator_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete generator_; + } + if (generator) { + set_has_generator(); + generator_ = generator; + } else { + clear_has_generator(); + generator_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.SrpLoginChallenge.generator) +} + +// required string hash_function = 5; +inline bool SrpLoginChallenge::has_hash_function() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void SrpLoginChallenge::set_has_hash_function() { + _has_bits_[0] |= 0x00000010u; +} +inline void SrpLoginChallenge::clear_has_hash_function() { + _has_bits_[0] &= ~0x00000010u; +} +inline void SrpLoginChallenge::clear_hash_function() { + if (hash_function_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_function_->clear(); + } + clear_has_hash_function(); +} +inline const ::std::string& SrpLoginChallenge::hash_function() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.hash_function) + return *hash_function_; +} +inline void SrpLoginChallenge::set_hash_function(const ::std::string& value) { + set_has_hash_function(); + if (hash_function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_function_ = new ::std::string; + } + hash_function_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.hash_function) +} +inline void SrpLoginChallenge::set_hash_function(const char* value) { + set_has_hash_function(); + if (hash_function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_function_ = new ::std::string; + } + hash_function_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.SrpLoginChallenge.hash_function) +} +inline void SrpLoginChallenge::set_hash_function(const char* value, size_t size) { + set_has_hash_function(); + if (hash_function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_function_ = new ::std::string; + } + hash_function_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.SrpLoginChallenge.hash_function) +} +inline ::std::string* SrpLoginChallenge::mutable_hash_function() { + set_has_hash_function(); + if (hash_function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + hash_function_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.SrpLoginChallenge.hash_function) + return hash_function_; +} +inline ::std::string* SrpLoginChallenge::release_hash_function() { + clear_has_hash_function(); + if (hash_function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = hash_function_; + hash_function_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void SrpLoginChallenge::set_allocated_hash_function(::std::string* hash_function) { + if (hash_function_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete hash_function_; + } + if (hash_function) { + set_has_hash_function(); + hash_function_ = hash_function; + } else { + clear_has_hash_function(); + hash_function_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.SrpLoginChallenge.hash_function) +} + +// required string username = 6; +inline bool SrpLoginChallenge::has_username() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void SrpLoginChallenge::set_has_username() { + _has_bits_[0] |= 0x00000020u; +} +inline void SrpLoginChallenge::clear_has_username() { + _has_bits_[0] &= ~0x00000020u; +} +inline void SrpLoginChallenge::clear_username() { + if (username_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + username_->clear(); + } + clear_has_username(); +} +inline const ::std::string& SrpLoginChallenge::username() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.username) + return *username_; +} +inline void SrpLoginChallenge::set_username(const ::std::string& value) { + set_has_username(); + if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + username_ = new ::std::string; + } + username_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.username) +} +inline void SrpLoginChallenge::set_username(const char* value) { + set_has_username(); + if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + username_ = new ::std::string; + } + username_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.SrpLoginChallenge.username) +} +inline void SrpLoginChallenge::set_username(const char* value, size_t size) { + set_has_username(); + if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + username_ = new ::std::string; + } + username_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.SrpLoginChallenge.username) +} +inline ::std::string* SrpLoginChallenge::mutable_username() { + set_has_username(); + if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + username_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.SrpLoginChallenge.username) + return username_; +} +inline ::std::string* SrpLoginChallenge::release_username() { + clear_has_username(); + if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = username_; + username_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void SrpLoginChallenge::set_allocated_username(::std::string* username) { + if (username_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete username_; + } + if (username) { + set_has_username(); + username_ = username; + } else { + clear_has_username(); + username_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.SrpLoginChallenge.username) +} + +// required string salt = 7; +inline bool SrpLoginChallenge::has_salt() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void SrpLoginChallenge::set_has_salt() { + _has_bits_[0] |= 0x00000040u; +} +inline void SrpLoginChallenge::clear_has_salt() { + _has_bits_[0] &= ~0x00000040u; +} +inline void SrpLoginChallenge::clear_salt() { + if (salt_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + salt_->clear(); + } + clear_has_salt(); +} +inline const ::std::string& SrpLoginChallenge::salt() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.salt) + return *salt_; +} +inline void SrpLoginChallenge::set_salt(const ::std::string& value) { + set_has_salt(); + if (salt_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + salt_ = new ::std::string; + } + salt_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.salt) +} +inline void SrpLoginChallenge::set_salt(const char* value) { + set_has_salt(); + if (salt_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + salt_ = new ::std::string; + } + salt_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.SrpLoginChallenge.salt) +} +inline void SrpLoginChallenge::set_salt(const char* value, size_t size) { + set_has_salt(); + if (salt_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + salt_ = new ::std::string; + } + salt_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.SrpLoginChallenge.salt) +} +inline ::std::string* SrpLoginChallenge::mutable_salt() { + set_has_salt(); + if (salt_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + salt_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.SrpLoginChallenge.salt) + return salt_; +} +inline ::std::string* SrpLoginChallenge::release_salt() { + clear_has_salt(); + if (salt_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = salt_; + salt_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void SrpLoginChallenge::set_allocated_salt(::std::string* salt) { + if (salt_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete salt_; + } + if (salt) { + set_has_salt(); + salt_ = salt; + } else { + clear_has_salt(); + salt_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.SrpLoginChallenge.salt) +} + +// required string public_B = 8; +inline bool SrpLoginChallenge::has_public_b() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void SrpLoginChallenge::set_has_public_b() { + _has_bits_[0] |= 0x00000080u; +} +inline void SrpLoginChallenge::clear_has_public_b() { + _has_bits_[0] &= ~0x00000080u; +} +inline void SrpLoginChallenge::clear_public_b() { + if (public_b_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + public_b_->clear(); + } + clear_has_public_b(); +} +inline const ::std::string& SrpLoginChallenge::public_b() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.public_B) + return *public_b_; +} +inline void SrpLoginChallenge::set_public_b(const ::std::string& value) { + set_has_public_b(); + if (public_b_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + public_b_ = new ::std::string; + } + public_b_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.public_B) +} +inline void SrpLoginChallenge::set_public_b(const char* value) { + set_has_public_b(); + if (public_b_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + public_b_ = new ::std::string; + } + public_b_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.SrpLoginChallenge.public_B) +} +inline void SrpLoginChallenge::set_public_b(const char* value, size_t size) { + set_has_public_b(); + if (public_b_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + public_b_ = new ::std::string; + } + public_b_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.SrpLoginChallenge.public_B) +} +inline ::std::string* SrpLoginChallenge::mutable_public_b() { + set_has_public_b(); + if (public_b_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + public_b_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.SrpLoginChallenge.public_B) + return public_b_; +} +inline ::std::string* SrpLoginChallenge::release_public_b() { + clear_has_public_b(); + if (public_b_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = public_b_; + public_b_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void SrpLoginChallenge::set_allocated_public_b(::std::string* public_b) { + if (public_b_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete public_b_; + } + if (public_b) { + set_has_public_b(); + public_b_ = public_b; + } else { + clear_has_public_b(); + public_b_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.SrpLoginChallenge.public_B) +} + +// optional bool eligible_credential_upgrade = 9; +inline bool SrpLoginChallenge::has_eligible_credential_upgrade() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void SrpLoginChallenge::set_has_eligible_credential_upgrade() { + _has_bits_[0] |= 0x00000100u; +} +inline void SrpLoginChallenge::clear_has_eligible_credential_upgrade() { + _has_bits_[0] &= ~0x00000100u; +} +inline void SrpLoginChallenge::clear_eligible_credential_upgrade() { + eligible_credential_upgrade_ = false; + clear_has_eligible_credential_upgrade(); +} +inline bool SrpLoginChallenge::eligible_credential_upgrade() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.SrpLoginChallenge.eligible_credential_upgrade) + return eligible_credential_upgrade_; +} +inline void SrpLoginChallenge::set_eligible_credential_upgrade(bool value) { + set_has_eligible_credential_upgrade(); + eligible_credential_upgrade_ = value; + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.SrpLoginChallenge.eligible_credential_upgrade) +} + +// ------------------------------------------------------------------- + // LoginResult // required .Battlenet.JSON.Login.AuthenticationState authentication_state = 1; @@ -2003,6 +2909,82 @@ inline void LoginResult::set_allocated_login_ticket(::std::string* login_ticket) // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.LoginResult.login_ticket) } +// optional string server_evidence_M2 = 6; +inline bool LoginResult::has_server_evidence_m2() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LoginResult::set_has_server_evidence_m2() { + _has_bits_[0] |= 0x00000020u; +} +inline void LoginResult::clear_has_server_evidence_m2() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LoginResult::clear_server_evidence_m2() { + if (server_evidence_m2_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_evidence_m2_->clear(); + } + clear_has_server_evidence_m2(); +} +inline const ::std::string& LoginResult::server_evidence_m2() const { + // @@protoc_insertion_point(field_get:Battlenet.JSON.Login.LoginResult.server_evidence_M2) + return *server_evidence_m2_; +} +inline void LoginResult::set_server_evidence_m2(const ::std::string& value) { + set_has_server_evidence_m2(); + if (server_evidence_m2_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_evidence_m2_ = new ::std::string; + } + server_evidence_m2_->assign(value); + // @@protoc_insertion_point(field_set:Battlenet.JSON.Login.LoginResult.server_evidence_M2) +} +inline void LoginResult::set_server_evidence_m2(const char* value) { + set_has_server_evidence_m2(); + if (server_evidence_m2_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_evidence_m2_ = new ::std::string; + } + server_evidence_m2_->assign(value); + // @@protoc_insertion_point(field_set_char:Battlenet.JSON.Login.LoginResult.server_evidence_M2) +} +inline void LoginResult::set_server_evidence_m2(const char* value, size_t size) { + set_has_server_evidence_m2(); + if (server_evidence_m2_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_evidence_m2_ = new ::std::string; + } + server_evidence_m2_->assign(reinterpret_cast<const char*>(value), size); + // @@protoc_insertion_point(field_set_pointer:Battlenet.JSON.Login.LoginResult.server_evidence_M2) +} +inline ::std::string* LoginResult::mutable_server_evidence_m2() { + set_has_server_evidence_m2(); + if (server_evidence_m2_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + server_evidence_m2_ = new ::std::string; + } + // @@protoc_insertion_point(field_mutable:Battlenet.JSON.Login.LoginResult.server_evidence_M2) + return server_evidence_m2_; +} +inline ::std::string* LoginResult::release_server_evidence_m2() { + clear_has_server_evidence_m2(); + if (server_evidence_m2_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + return NULL; + } else { + ::std::string* temp = server_evidence_m2_; + server_evidence_m2_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + return temp; + } +} +inline void LoginResult::set_allocated_server_evidence_m2(::std::string* server_evidence_m2) { + if (server_evidence_m2_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { + delete server_evidence_m2_; + } + if (server_evidence_m2) { + set_has_server_evidence_m2(); + server_evidence_m2_ = server_evidence_m2; + } else { + clear_has_server_evidence_m2(); + server_evidence_m2_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_set_allocated:Battlenet.JSON.Login.LoginResult.server_evidence_M2) +} + // ------------------------------------------------------------------- // LoginRefreshResult |