int main(int argc, char** argv) {
// Pointer to singleton instance
Lobby* lobby = Lobby::Inst();
// Start the server on the given port with the specified maximum number of clients
if (lobby->Start(1337, 100)) {
int delay = 0; // Milliseconds that the server should sleep between updates
int packets; // Number of packets sent and received
// Run until the escape key is pressed
while (!GetAsyncKeyState(VK_ESCAPE)) {
// Call update and incremenent the number of packets
packets = lobby->Update();
// Print the packet count if any
if (packets > 0) {
std::cout << time(NULL) << ": Sent/received " << packets << " packet(s).\n";
delay = 0; // Reset delay any time there is activity to throttle up
}
// Throttle down when no activity is present to free cycles
if (delay < 1000) { // Sleep for no longer than a second
delay += 10;
}
Sleep(delay);
}
lobby->Stop();
}
return 0;
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
a.setFont(QFont("simsun", 9));
dataInterface = new DataInterface;
logic = new Logic;
animation = new Animation;
gui = new GUI;
//FIXME: use ClientUI login and then destroy it
ClientUI c;
#ifdef LOBBY
c.disconnect(&c);
Lobby l;
l.show();
return a.exec();
#else
if(c.exec() == QDialog::Accepted)
{
c.disconnect(&c);
Lobby l;
l.show();
return a.exec();
}
return 0;
#endif
}
void Lobbytest::test_addToMessage()
{
m_lobby->addAccount(new TestAccount());
Atlas::Message::MapType e;
m_lobby->addToMessage(e);
}
void Lobbytest::test_addToEntity()
{
m_lobby->addAccount(new TestAccount());
Atlas::Objects::Entity::RootEntity e;
m_lobby->addToEntity(e);
}
int main( )
{
Lobby myLobby;
int choice;
do
{
cout << myLobby;
cout << "\nGAME LOBBY\n";
cout << "0 - Exit the program.\n";
cout << "1 - Add a player to the lobby.\n";
cout << "2 - Remove a player from the lobby.\n";
cout << "3 - Clear the lobby.\n";
cout << endl << "Enter choice: ";
cin >> choice;
switch( choice )
{
case 0: cout << "Good-bye.\n"; break;
case 1: myLobby.AddPlayer( ); break;
case 2: myLobby.RemovePlayer( ); break;
case 3: myLobby.Clear( ); break;
default: cout << "That was not a valid choice.\n";
}
} while( choice != 0 );
return 0;
}
void Lobbytest::test_addAccount()
{
assert(m_lobby->getAccounts().size() == 0);
m_lobby->addAccount(new TestAccount());
assert(m_lobby->getAccounts().size() == 1);
}
void Lobbytest::test_delAccount_empty()
{
assert(m_lobby->getAccounts().size() == 0);
m_lobby->delAccount(new TestAccount());
assert(m_lobby->getAccounts().size() == 0);
}
void Lobbytest::test_operation_account()
{
Account * tac = new TestAccount();
m_lobby->addAccount(tac);
Atlas::Objects::Operation::RootOperation op;
OpVector res;
op->setTo("2");
m_lobby->operation(op, res);
}
int main(int argc, char *argv[])
{
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
QApplication a(argc, argv);
MainWindow w;
Lobby lobby;
QObject::connect(&lobby, SIGNAL(startGame(QString,qint16)), &w, SLOT(startGame(QString,qint16)));
lobby.show();
return a.exec();
}
void Lobbytest::test_addAccount_connected()
{
Account * tac = new TestAccount();
tac->m_connection = new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"foo", "3", 3);
m_lobby->addAccount(tac);
Atlas::Objects::Operation::RootOperation op;
OpVector res;
m_lobby->operation(op, res);
}
void Lobbytest::test_delAccount()
{
assert(m_lobby->getAccounts().size() == 0);
Account * tac = new TestAccount();
m_lobby->addAccount(tac);
assert(m_lobby->getAccounts().size() == 1);
m_lobby->delAccount(tac);
assert(m_lobby->getAccounts().size() == 0);
}
void LobbyManager::Init(const LobbyManagerConfig config, TcpNet* pNetwork, ILog* pLogger)
{
m_pRefLogger = pLogger;
m_pRefNetwork = pNetwork;
for (int i = 0; i < config.MaxLobbyCount; ++i)
{
Lobby lobby;
lobby.Init((short)i, (short)config.MaxLobbyUserCount, (short)config.MaxRoomCountByLobby, (short)config.MaxRoomUserCount);
lobby.SetNetwork(m_pRefNetwork, m_pRefLogger);
m_LobbyList.push_back(lobby);
}
}
static
tABC_CC ABC_WalletServerRepoPost(const Lobby &lobby,
DataSlice LP1,
const std::string &szWalletAcctKey,
const char *szPath,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
const auto url = ABC_SERVER_ROOT "/" + std::string(szPath);
HttpReply reply;
ServerReplyJson replyJson;
JsonPtr json(json_pack("{ssssss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str(),
ABC_SERVER_JSON_REPO_WALLET_FIELD, szWalletAcctKey.c_str()));
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, json.encode()));
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
return cc;
}
/**
* Queries the server to determine if a username is available.
*/
tABC_CC ABC_LoginServerAvailable(const Lobby &lobby,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" ABC_SERVER_ACCOUNT_AVAILABLE;
ServerReplyJson replyJson;
std::string get;
AccountAvailableJson json;
// create the json
ABC_CHECK_NEW(json.authIdSet(base64Encode(lobby.authId())));
ABC_CHECK_NEW(json.encode(get));
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, get));
// decode the result
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
return cc;
}
/**
* Activate an account on the server.
*
* @param LP1 Password hash for the account
*/
tABC_CC ABC_LoginServerActivate(const Lobby &lobby,
tABC_U08Buf LP1,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" ABC_SERVER_ACCOUNT_ACTIVATE;
ServerReplyJson replyJson;
char *szPost = NULL;
json_t *pJSON_Root = NULL;
// create the post data
pJSON_Root = json_pack("{ssss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str());
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, szPost));
// decode the result
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
ABC_FREE_STR(szPost);
if (pJSON_Root) json_decref(pJSON_Root);
return cc;
}
int main()
{
bool Run=true;
// Create object
flog::FileLogger myLog ("1", "log.txt");
// Writing warnings or errors to file is very easy and C++ style
myLog << flog::FileLogger::Type::WARNING << "Hey! ... This is a warning message!";
myLog << flog::FileLogger::Type::ERROR << "WOW! Something really wrong is happening here!";
myLog << "hello";
int choice=0;
Lobby lobby;
while(Run)
{
cout<<endl;
cout<<"Menu --> Server"<<endl;
cout<<"1.Open lobby"<<endl;
cout<<"Other.Close server"<<endl;
cout<<endl;
cin>>choice;
switch (choice)
{
case 1:
cout<<"Server open the lobby"<<endl;
cout<<endl;
lobby.open();
choice=0;
break;
default:
cout<<"exit"<<endl;
Run=false;
break;
}
}
return 0;
}
/**
* Changes the password for an account on the server.
*
* This function sends information to the server to change the password for an account.
* Either the old LP1 or LRA1 can be used for authentication.
*
* @param oldLP1 Old password hash for the account (if this is empty, LRA1 is used instead)
* @param LRA1 LRA1 for the account (used if oldP1 is empty)
*/
tABC_CC ABC_LoginServerChangePassword(const Lobby &lobby,
tABC_U08Buf oldLP1,
tABC_U08Buf newLP1,
tABC_U08Buf newLRA1,
const CarePackage &carePackage,
const LoginPackage &loginPackage,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" ABC_SERVER_CHANGE_PASSWORD_PATH;
ServerReplyJson replyJson;
char *szPost = NULL;
std::string carePackageStr;
std::string loginPackageStr;
json_t *pJSON_OldLRA1 = NULL;
json_t *pJSON_NewLRA1 = NULL;
json_t *pJSON_Root = NULL;
ABC_CHECK_NULL_BUF(oldLP1);
ABC_CHECK_NULL_BUF(newLP1);
ABC_CHECK_NEW(carePackage.encode(carePackageStr));
ABC_CHECK_NEW(loginPackage.encode(loginPackageStr));
// Encode those:
pJSON_Root = json_pack("{ss, ss, ss, ss, ss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(oldLP1).c_str(),
ABC_SERVER_JSON_NEW_LP1_FIELD, base64Encode(newLP1).c_str(),
ABC_SERVER_JSON_CARE_PACKAGE_FIELD, carePackageStr.c_str(),
ABC_SERVER_JSON_LOGIN_PACKAGE_FIELD, loginPackageStr.c_str());
// set up the recovery, if any:
if (newLRA1.size())
{
pJSON_NewLRA1 = json_string(base64Encode(newLRA1).c_str());
json_object_set(pJSON_Root, ABC_SERVER_JSON_NEW_LRA1_FIELD, pJSON_NewLRA1);
}
// create the post data
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, szPost));
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
ABC_FREE_STR(szPost);
if (pJSON_OldLRA1) json_decref(pJSON_OldLRA1);
if (pJSON_NewLRA1) json_decref(pJSON_NewLRA1);
if (pJSON_Root) json_decref(pJSON_Root);
return cc;
}
/**
* @brief Entry point of the dedicated game server
*/
int main(int /*argc*/, char ** /*argv[]*/)
{
std::string homePath = System::HomePath();
System::Initialize(); // default home path
TLogInfo("Using home path: " + homePath);
// Init lobby
Lobby lobby;
lobby.CreateTable("Console");
Server server(lobby);
ConsoleClient client;
Log::SetLogPath(System::LogPath());
Log::RegisterListener(client);
ServerOptions options = ServerConfig::GetDefault();
options.localHostOnly = true;
server.Start(options); // Blocking call. On exit, quit the executable
#ifdef USE_WINDOWS_OS
// Set the control handler so the app will be notified upon any special
// termination event.
SetConsoleCtrlHandler ((PHANDLER_ROUTINE) ControlHandler, TRUE);
(void) _set_invalid_parameter_handler(myInvalidParameterHandler);
#ifdef _MSC_VER
// Disable the message box for assertions.
_CrtSetReportMode(_CRT_ASSERT, 0);
#endif
#endif
client.Run(options.game_tcp_port);
server.Stop();
client.Stop();
return 0;
}
tABC_CC ABC_LoginServerOtpRequest(const char *szUrl,
const Lobby &lobby,
tABC_U08Buf LP1,
JsonPtr *results,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
ServerReplyJson replyJson;
char *szPost = NULL;
json_t *pJSON_Root = NULL;
// create the post data
pJSON_Root = json_pack("{ss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str());
// If there is a LP1 provided
if (LP1.data())
{
json_object_set_new(pJSON_Root, ABC_SERVER_JSON_LP1_FIELD,
json_string(base64Encode(LP1).c_str()));
}
{
auto key = lobby.otpKey();
if (key)
json_object_set_new(pJSON_Root, ABC_SERVER_JSON_OTP_FIELD, json_string(key->totp().c_str()));
}
json_object_set_new(pJSON_Root, ABC_SERVER_JSON_OTP_RESET_AUTH, json_string(gOtpResetAuth.c_str()));
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, szUrl, szPost));
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
if (results)
*results = replyJson.results();
exit:
ABC_FREE_STR(szPost);
if (pJSON_Root) json_decref(pJSON_Root);
return cc;
}
/**
* Enables 2 Factor authentication
*
* @param LP1 Password hash for the account
* @param timeout Amount of time needed for a reset to complete
*/
tABC_CC ABC_LoginServerOtpEnable(const Lobby &lobby,
tABC_U08Buf LP1,
const char *szOtpSecret,
const long timeout,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/otp/on";
ServerReplyJson replyJson;
char *szPost = NULL;
json_t *pJSON_Root = NULL;
ABC_CHECK_NULL_BUF(LP1);
// create the post data
pJSON_Root = json_pack("{sssssssi}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str(),
ABC_SERVER_JSON_OTP_SECRET_FIELD, szOtpSecret,
ABC_SERVER_JSON_OTP_TIMEOUT, timeout);
{
auto key = lobby.otpKey();
if (key)
json_object_set_new(pJSON_Root, ABC_SERVER_JSON_OTP_FIELD, json_string(key->totp().c_str()));
}
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, szPost));
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
ABC_FREE_STR(szPost);
if (pJSON_Root) json_decref(pJSON_Root);
return cc;
}
/**
* Uploads the pin package.
*
* @param LP1 Login + Password hash
* @param DID Device Id
* @param LPIN1 Hashed pin
* @param szPinPackage Pin package
* @param szAli auto-logout interval
*/
tABC_CC ABC_LoginServerUpdatePinPackage(const Lobby &lobby,
tABC_U08Buf LP1,
tABC_U08Buf DID,
tABC_U08Buf LPIN1,
const std::string &pinPackage,
time_t ali,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" ABC_SERVER_PIN_PACK_UPDATE_PATH;
ServerReplyJson replyJson;
char *szPost = NULL;
json_t *pJSON_Root = NULL;
char szALI[DATETIME_LENGTH];
ABC_CHECK_NULL_BUF(LP1);
ABC_CHECK_NULL_BUF(DID);
ABC_CHECK_NULL_BUF(LPIN1);
// format the ali
strftime(szALI, DATETIME_LENGTH, "%Y-%m-%dT%H:%M:%S", gmtime(&ali));
// Encode those:
pJSON_Root = json_pack("{ss, ss, ss, ss, ss, ss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str(),
ABC_SERVER_JSON_DID_FIELD, base64Encode(DID).c_str(),
ABC_SERVER_JSON_LPIN1_FIELD, base64Encode(LPIN1).c_str(),
JSON_ACCT_PIN_PACKAGE, pinPackage.c_str(),
ABC_SERVER_JSON_ALI_FIELD, szALI);
// create the post data
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, szPost));
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
ABC_FREE_STR(szPost);
if (pJSON_Root) json_decref(pJSON_Root);
return cc;
}
/**
* Creates an account on the server.
*
* This function sends information to the server to create an account.
* If the account was created, ABC_CC_Ok is returned.
* If the account already exists, ABC_CC_AccountAlreadyExists is returned.
*
* @param LP1 Password hash for the account
*/
tABC_CC ABC_LoginServerCreate(const Lobby &lobby,
tABC_U08Buf LP1,
const CarePackage &carePackage,
const LoginPackage &loginPackage,
const char *szRepoAcctKey,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" ABC_SERVER_ACCOUNT_CREATE_PATH;
ServerReplyJson replyJson;
char *szPost = NULL;
std::string carePackageStr;
std::string loginPackageStr;
json_t *pJSON_Root = NULL;
ABC_CHECK_NULL_BUF(LP1);
ABC_CHECK_NEW(carePackage.encode(carePackageStr));
ABC_CHECK_NEW(loginPackage.encode(loginPackageStr));
// create the post data
pJSON_Root = json_pack("{ssssssssss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str(),
ABC_SERVER_JSON_CARE_PACKAGE_FIELD, carePackageStr.c_str(),
ABC_SERVER_JSON_LOGIN_PACKAGE_FIELD, loginPackageStr.c_str(),
ABC_SERVER_JSON_REPO_FIELD, szRepoAcctKey);
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, szPost));
// decode the result
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
ABC_FREE_STR(szPost);
if (pJSON_Root) json_decref(pJSON_Root);
return cc;
}
Status
loginRecovery(std::shared_ptr<Login> &result,
Lobby &lobby, const std::string &recoveryAnswers,
AuthError &authError)
{
std::string LRA = lobby.username() + recoveryAnswers;
// Get the CarePackage:
CarePackage carePackage;
ABC_CHECK(loginServerGetCarePackage(lobby, carePackage));
// Make recoveryAuthKey (unlocks the server):
DataChunk recoveryAuthKey;
ABC_CHECK(usernameSnrp().hash(recoveryAuthKey, LRA));
// Get the LoginPackage:
LoginPackage loginPackage;
JsonPtr rootKeyBox;
ABC_CHECK(loginServerGetLoginPackage(lobby, U08Buf(), recoveryAuthKey,
loginPackage, rootKeyBox,
authError));
// Make recoveryKey (unlocks dataKey):
DataChunk recoveryKey;
ABC_CHECK(carePackage.snrp3().hash(recoveryKey, LRA));
// Decrypt dataKey (unlocks the account):
DataChunk dataKey;
ABC_CHECK(loginPackage.recoveryBox().decrypt(dataKey, recoveryKey));
// Create the Login object:
std::shared_ptr<Login> out;
ABC_CHECK(Login::create(out, lobby, dataKey,
loginPackage, rootKeyBox, false));
// Set up the on-disk login:
ABC_CHECK(carePackage.save(out->paths.carePackagePath()));
ABC_CHECK(loginPackage.save(out->paths.loginPackagePath()));
result = std::move(out);
return Status();
}
Status
loginServerCreate(const Lobby &lobby, DataSlice LP1,
const CarePackage &carePackage, const LoginPackage &loginPackage,
const std::string &syncKey)
{
const auto url = ABC_SERVER_ROOT "/account/create";
JsonPtr json(json_pack("{ssssssssss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str(),
ABC_SERVER_JSON_CARE_PACKAGE_FIELD, carePackage.encode().c_str(),
ABC_SERVER_JSON_LOGIN_PACKAGE_FIELD, loginPackage.encode().c_str(),
ABC_SERVER_JSON_REPO_FIELD, syncKey.c_str()));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply.body));
ABC_CHECK(replyJson.ok());
return Status();
}
Status
loginRecoveryQuestions(std::string &result, Lobby &lobby)
{
// Load CarePackage:
CarePackage carePackage;
ABC_CHECK(loginServerGetCarePackage(lobby, carePackage));
// Verify that the questions exist:
if (!carePackage.questionBox())
return ABC_ERROR(ABC_CC_NoRecoveryQuestions, "No recovery questions");
// Create questionKey (unlocks questions):
DataChunk questionKey;
ABC_CHECK(carePackage.snrp4().hash(questionKey, lobby.username()));
// Decrypt:
DataChunk questions;
ABC_CHECK(carePackage.questionBox().decrypt(questions, questionKey));
result = toString(questions);
return Status();
}
static
tABC_CC ABC_WalletServerRepoPost(const Lobby &lobby,
tABC_U08Buf LP1,
const char *szWalletAcctKey,
const char *szPath,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" + std::string(szPath);
ServerReplyJson replyJson;
char *szPost = NULL;
json_t *pJSON_Root = NULL;
ABC_CHECK_NULL_BUF(LP1);
// create the post data
pJSON_Root = json_pack("{ssssss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str(),
ABC_SERVER_JSON_REPO_WALLET_FIELD, szWalletAcctKey);
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, szPost));
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
exit:
ABC_FREE_STR(szPost);
if (pJSON_Root) json_decref(pJSON_Root);
return cc;
}
void Lobbytest::test_operation()
{
Atlas::Objects::Operation::RootOperation op;
OpVector res;
m_lobby->operation(op, res);
}
/**
* Helper function for getting CarePackage or LoginPackage.
*/
static
tABC_CC ABC_LoginServerGetString(const Lobby &lobby, tABC_U08Buf LP1, tABC_U08Buf LRA1,
const char *szURL, const char *szField, char **szResponse, tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
ServerReplyJson replyJson;
json_t *pJSON_Value = NULL;
json_t *pJSON_Root = NULL;
char *szPost = NULL;
// create the post data with or without LP1
if (LP1.data() == NULL && LRA1.data() == NULL)
{
pJSON_Root = json_pack("{ss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str());
}
else
{
if (LP1.data() == NULL)
{
pJSON_Root = json_pack("{ssss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LRA1_FIELD, base64Encode(LRA1).c_str());
}
else
{
pJSON_Root = json_pack("{ssss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(LP1).c_str());
}
}
{
auto key = lobby.otpKey();
if (key)
json_object_set_new(pJSON_Root, ABC_SERVER_JSON_OTP_FIELD, json_string(key->totp().c_str()));
}
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, szURL, szPost));
// Check the results, and store json if successful
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
// get the care package
pJSON_Value = replyJson.results().get();
ABC_CHECK_ASSERT((pJSON_Value && json_is_object(pJSON_Value)), ABC_CC_JSONError, "Error parsing server JSON care package results");
pJSON_Value = json_object_get(pJSON_Value, szField);
ABC_CHECK_ASSERT((pJSON_Value && json_is_string(pJSON_Value)), ABC_CC_JSONError, "Error care package JSON results");
ABC_STRDUP(*szResponse, json_string_value(pJSON_Value));
exit:
if (pJSON_Root) json_decref(pJSON_Root);
ABC_FREE_STR(szPost);
return cc;
}
int main(){
Lobby lobbyServer;
lobbyServer.run();
return 0;
}
