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