Status
loginServerUpdatePinPackage(const Login &login,
DataSlice DID, DataSlice LPIN1, const std::string &pinPackage,
time_t ali)
{
const auto url = ABC_SERVER_ROOT "/account/pinpackage/update";
// format the ali
char szALI[DATETIME_LENGTH];
strftime(szALI, DATETIME_LENGTH, "%Y-%m-%dT%H:%M:%S", gmtime(&ali));
// Encode those:
JsonPtr json(json_pack("{ss, ss, ss, ss, ss, ss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(login.lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(login.authKey()).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));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply.body));
ABC_CHECK(replyJson.ok());
return Status();
}
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;
}
Status
loginServerOtpStatus(const Login &login, bool &on, long &timeout)
{
const auto url = ABC_SERVER_ROOT "/v1/otp/status";
ServerRequestJson json;
ABC_CHECK(json.setup(login));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
struct ResultJson:
public JsonObject
{
ABC_JSON_CONSTRUCTORS(ResultJson, JsonObject)
ABC_JSON_BOOLEAN(on, "on", false)
ABC_JSON_INTEGER(timeout, "otp_timeout", 0)
} resultJson(replyJson.results());
on = resultJson.on();
if (on)
{
ABC_CHECK(resultJson.timeoutOk());
timeout = resultJson.timeout();
}
return Status();
}
Status
loginServerGetLoginPackage(const Lobby &lobby,
DataSlice LP1, DataSlice LRA1, LoginPackage &result, JsonPtr &rootKeyBox)
{
const auto url = ABC_SERVER_ROOT "/account/loginpackage/get";
ServerRequestJson json;
ABC_CHECK(json.setup(lobby));
if (LP1.size())
ABC_CHECK(json.authKeySet(base64Encode(LP1)));
if (LRA1.size())
ABC_CHECK(json.recoveryAuthKeySet(base64Encode(LRA1)));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply.body));
ABC_CHECK(replyJson.ok());
struct ResultJson:
public JsonObject
{
ABC_JSON_CONSTRUCTORS(ResultJson, JsonObject)
ABC_JSON_STRING(package, "login_package", nullptr)
ABC_JSON_VALUE(rootKeyBox, "rootKeyBox", JsonPtr)
} resultJson(replyJson.results());
ABC_CHECK(resultJson.packageOk());
ABC_CHECK(result.decode(resultJson.package()));
if (json_is_object(resultJson.rootKeyBox().get()))
rootKeyBox = resultJson.rootKeyBox();
return Status();
}
Status
loginServerPasswordSet(AuthJson authJson,
DataSlice passwordAuth,
JsonPtr passwordKeySnrp,
JsonPtr passwordBox,
JsonPtr passwordAuthBox)
{
const auto url = ABC_SERVER_ROOT "/v2/login/password";
JsonSnrp passwordAuthSnrp;
ABC_CHECK(passwordAuthSnrp.snrpSet(usernameSnrp()));
JsonObject dataJson;
ABC_CHECK(dataJson.set("passwordAuth", base64Encode(passwordAuth)));
ABC_CHECK(dataJson.set("passwordAuthSnrp", passwordAuthSnrp));
ABC_CHECK(dataJson.set("passwordKeySnrp", passwordKeySnrp));
ABC_CHECK(dataJson.set("passwordBox", passwordBox));
ABC_CHECK(dataJson.set("passwordAuthBox", passwordAuthBox));
ABC_CHECK(authJson.set("data", dataJson));
HttpReply reply;
ABC_CHECK(AirbitzRequest().request(reply, url, "PUT", authJson.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
Status
loginServerAccountUpgrade(const Login &login,
JsonPtr rootKeyBox, JsonPtr mnemonicBox, JsonPtr dataKeyBox)
{
const auto url = ABC_SERVER_ROOT "/account/upgrade";
struct RequestJson:
public ServerRequestJson
{
ABC_JSON_VALUE(rootKeyBox, "rootKeyBox", JsonPtr)
ABC_JSON_VALUE(mnemonicBox, "mnemonicBox", JsonPtr)
ABC_JSON_VALUE(dataKeyBox, "syncDataKeyBox", JsonPtr)
} json;
ABC_CHECK(json.setup(login));
ABC_CHECK(json.rootKeyBoxSet(rootKeyBox));
ABC_CHECK(json.mnemonicBoxSet(mnemonicBox));
ABC_CHECK(json.dataKeyBoxSet(dataKeyBox));
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
loginServerGetPinPackage(DataSlice DID, DataSlice LPIN1, std::string &result,
AuthError &authError)
{
const auto url = ABC_SERVER_ROOT "/v1/account/pinpackage/get";
ServerRequestJson json;
ABC_CHECK(json.set(ABC_SERVER_JSON_DID_FIELD, base64Encode(DID)));
ABC_CHECK(json.set(ABC_SERVER_JSON_LPIN1_FIELD, base64Encode(LPIN1)));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply, &authError));
struct ResultJson:
public JsonObject
{
ABC_JSON_CONSTRUCTORS(ResultJson, JsonObject)
ABC_JSON_STRING(package, "pin_package", nullptr)
} resultJson(replyJson.results());
ABC_CHECK(resultJson.packageOk());
result = resultJson.package();
return Status();
}
Status
loginServerKeyAdd(AuthJson authJson, JsonPtr keyBox, std::string syncKey)
{
const auto url = ABC_SERVER_ROOT "/v2/login/keys";
// Repos to create (optional):
JsonArray newSyncKeys;
if (syncKey.size())
ABC_CHECK(newSyncKeys.append(json_string(syncKey.c_str())));
// Key boxes to upload:
JsonArray keyBoxes;
ABC_CHECK(keyBoxes.append(keyBox));
/// Assemble request:
JsonObject requestJson;
ABC_CHECK(requestJson.set("newSyncKeys", newSyncKeys));
ABC_CHECK(requestJson.set("keyBoxes", keyBoxes));
ABC_CHECK(authJson.set("data", requestJson));
HttpReply reply;
ABC_CHECK(AirbitzRequest().request(reply, url, "POST", authJson.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
/**
* 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;
}
Status
loginServerChangePassword(const Login &login,
DataSlice newLP1, DataSlice newLRA1,
const CarePackage &carePackage, const LoginPackage &loginPackage)
{
const auto url = ABC_SERVER_ROOT "/account/password/update";
JsonPtr json(json_pack("{ss, ss, ss, ss, ss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(login.lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(login.authKey()).c_str(),
ABC_SERVER_JSON_NEW_LP1_FIELD, base64Encode(newLP1).c_str(),
ABC_SERVER_JSON_CARE_PACKAGE_FIELD, carePackage.encode().c_str(),
ABC_SERVER_JSON_LOGIN_PACKAGE_FIELD, loginPackage.encode().c_str()));
if (newLRA1.size())
{
json_object_set_new(json.get(), ABC_SERVER_JSON_NEW_LRA1_FIELD,
json_string(base64Encode(newLRA1).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();
}
/**
* 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;
}
Status
loginServerRecovery2Delete(AuthJson authJson)
{
const auto url = ABC_SERVER_ROOT "/v2/login/recovery2";
HttpReply reply;
ABC_CHECK(AirbitzRequest().request(reply, url, "DELETE", authJson.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
Status
loginServerOtpPending(std::list<DataChunk> users, std::list<bool> &isPending)
{
const auto url = ABC_SERVER_ROOT "/v1/otp/pending/check";
std::string param;
std::map<std::string, bool> userMap;
std::list<std::string> usersEncoded;
for (const auto &u : users)
{
std::string username = base64Encode(u);
param += (username + ",");
userMap[username] = false;
usersEncoded.push_back(username);
}
JsonObject json;
ABC_CHECK(json.set("l1s", param));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
JsonArray arrayJson = replyJson.results();
size_t size = arrayJson.size();
for (size_t i = 0; i < size; i++)
{
json_t *pJSON_Row = arrayJson[i].get();
if (!pJSON_Row || !json_is_object(pJSON_Row))
return ABC_ERROR(ABC_CC_JSONError, "Error parsing JSON array element object");
json_t *pJSON_Value = json_object_get(pJSON_Row, "login");
if (!pJSON_Value || !json_is_string(pJSON_Value))
return ABC_ERROR(ABC_CC_JSONError, "Error otp/pending/login JSON");
std::string username(json_string_value(pJSON_Value));
pJSON_Value = json_object_get(pJSON_Row, ABC_SERVER_JSON_OTP_PENDING);
if (!pJSON_Value || !json_is_boolean(pJSON_Value))
return ABC_ERROR(ABC_CC_JSONError, "Error otp/pending/pending JSON");
if (json_is_true(pJSON_Value))
{
userMap[username] = json_is_true(pJSON_Value);
}
}
isPending.clear();
for (auto &username: usersEncoded)
{
isPending.push_back(userMap[username]);
}
return Status();
}
Status
loginServerLobbyGet(JsonPtr &result, const std::string &id)
{
const auto url = ABC_SERVER_ROOT "/v2/lobby/" + id;
HttpReply reply;
ABC_CHECK(AirbitzRequest().get(reply, url));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
result = replyJson.results();
return Status();
}
Status
loginServerGetQuestions(JsonPtr &result)
{
const auto url = ABC_SERVER_ROOT "/v1/questions";
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
result = replyJson.results();
return Status();
}
Status
loginServerAvailable(const LoginStore &store)
{
const auto url = ABC_SERVER_ROOT "/v1/account/available";
ServerRequestJson json;
ABC_CHECK(json.setup(store));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
Status
loginServerGetGeneral(JsonPtr &result)
{
const auto url = ABC_SERVER_ROOT "/getinfo";
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply.body));
ABC_CHECK(replyJson.ok());
result = replyJson.results();
return Status();
}
Status
loginServerGetQuestions(JsonPtr &result)
{
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" ABC_SERVER_GET_QUESTIONS_PATH;
ABC_CHECK(AirbitzRequest().post(reply, url));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply.body));
ABC_CHECK(replyJson.ok());
result = replyJson.results();
return Status();
}
Status
loginServerCreateChildLogin(AuthJson authJson, JsonPtr loginJson)
{
const auto url = ABC_SERVER_ROOT "/v2/login/create";
ABC_CHECK(authJson.set("data", loginJson));
HttpReply reply;
ABC_CHECK(AirbitzRequest().request(reply, url, "PUT", authJson.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
Status
loginServerLogin(LoginReplyJson &result, AuthJson authJson,
AuthError *authError)
{
const auto url = ABC_SERVER_ROOT "/v2/login";
HttpReply reply;
ABC_CHECK(AirbitzRequest().request(reply, url, "GET", authJson.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply, authError));
result = replyJson.results();
return Status();
}
Status
loginServerOtpResetCancelPending(const Login &login)
{
const auto url = ABC_SERVER_ROOT "/v1/otp/pending/cancel";
ServerRequestJson json;
ABC_CHECK(json.setup(login));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
Status
loginServerLobbyReply(const std::string &id, JsonPtr &lobbyReplyJson)
{
const auto url = ABC_SERVER_ROOT "/v2/lobby/" + id;
JsonObject requestJson;
ABC_CHECK(requestJson.set("data", lobbyReplyJson));
HttpReply reply;
ABC_CHECK(AirbitzRequest().request(reply, url, "POST", requestJson.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
Status
loginServerOtpDisable(const Login &login)
{
const auto url = ABC_SERVER_ROOT "/otp/off";
ServerRequestJson json;
ABC_CHECK(json.setup(login));
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
loginServerWalletActivate(const Login &login, const std::string &syncKey)
{
const auto url = ABC_SERVER_ROOT "/v1/wallet/activate";
ServerRequestJson json;
ABC_CHECK(json.setup(login));
ABC_CHECK(json.set(ABC_SERVER_JSON_REPO_WALLET_FIELD, syncKey));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
/**
* 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;
}
tABC_CC ABC_LoginServerGetPinPackage(tABC_U08Buf DID,
tABC_U08Buf LPIN1,
char **szPinPackage,
tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
HttpReply reply;
std::string url = ABC_SERVER_ROOT "/" ABC_SERVER_PIN_PACK_GET_PATH;
ServerReplyJson replyJson;
json_t *pJSON_Value = NULL;
json_t *pJSON_Root = NULL;
char *szPost = NULL;
ABC_CHECK_NULL_BUF(DID);
ABC_CHECK_NULL_BUF(LPIN1);
pJSON_Root = json_pack("{ss, ss}",
ABC_SERVER_JSON_DID_FIELD, base64Encode(DID).c_str(),
ABC_SERVER_JSON_LPIN1_FIELD, base64Encode(LPIN1).c_str());
szPost = ABC_UtilStringFromJSONObject(pJSON_Root, JSON_COMPACT);
// send the command
ABC_CHECK_NEW(AirbitzRequest().post(reply, url, szPost));
// Check the result
ABC_CHECK_NEW(replyJson.decode(reply.body));
ABC_CHECK_NEW(replyJson.ok());
// get the results field
pJSON_Value = replyJson.results().get();
ABC_CHECK_ASSERT((pJSON_Value && json_is_object(pJSON_Value)), ABC_CC_JSONError, "Error parsing server JSON pin package results");
// get the pin_package field
pJSON_Value = json_object_get(pJSON_Value, JSON_ACCT_PIN_PACKAGE);
ABC_CHECK_ASSERT((pJSON_Value && json_is_string(pJSON_Value)), ABC_CC_JSONError, "Error pin package JSON results");
// copy the value
ABC_STRDUP(*szPinPackage, json_string_value(pJSON_Value));
exit:
if (pJSON_Root) json_decref(pJSON_Root);
ABC_FREE_STR(szPost);
return cc;
}
Status
loginServerOtpEnable(const Login &login, const std::string &otpToken,
const long timeout)
{
const auto url = ABC_SERVER_ROOT "/v1/otp/on";
ServerRequestJson json;
ABC_CHECK(json.setup(login));
ABC_CHECK(json.set(ABC_SERVER_JSON_OTP_SECRET_FIELD, otpToken));
ABC_CHECK(json.set(ABC_SERVER_JSON_OTP_TIMEOUT,
static_cast<json_int_t>(timeout)));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
/**
* 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
loginServerOtpReset(const LoginStore &store, const std::string &token)
{
const auto url = ABC_SERVER_ROOT "/v1/otp/reset";
struct ResetJson:
public ServerRequestJson
{
ABC_JSON_STRING(otpResetAuth, "otp_reset_auth", nullptr)
} json;
ABC_CHECK(json.setup(store));
ABC_CHECK(json.otpResetAuthSet(token));
HttpReply reply;
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
ServerReplyJson replyJson;
ABC_CHECK(replyJson.decode(reply));
return Status();
}
