void ConnectionState::getBestConnection(MojString& connectionType, MojString& ipAddress)
{
if (ConnectionState::m_connState->m_wifiConnected)
{
connectionType.assign("wifi");
ipAddress = ConnectionState::m_connState->m_wifiIpAddress;
}
else
{
connectionType.assign("wan");
ipAddress = ConnectionState::m_connState->m_wanIpAddress;
}
}
MojErr MojDbIndex::addBuiltinProps()
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojString idStr;
MojErr err = idStr.assign(MojDb::IdKey);
MojErrCheck(err);
if (m_propNames.find(idStr) == MojInvalidSize) {
MojObject idProp;
err = idProp.put(NameKey, idStr);
MojErrCheck(err);
err = addProp(idProp);
MojErrCheck(err);
}
if (m_includeDeleted && m_propNames.front() != MojDb::DelKey) {
MojObject delProp;
err = delProp.putString(NameKey, MojDb::DelKey);
MojErrCheck(err);
err = delProp.putBool(DefaultKey, false);
MojErrCheck(err);
err = addProp(delProp, true);
MojErrCheck(err);
MojAssert(m_propNames.front() == MojDb::DelKey);
}
m_idIndex = m_propNames.find(idStr);
MojAssert(m_idIndex != MojInvalidSize);
m_idIndex++; // account for prefix
return MojErrNone;
}
MojErr MojDbIndexTest::assertContainsText(TestIndex& ti, MojObject id, const MojChar* str)
{
MojString strObj;
MojErr err = strObj.assign(str);
MojErrCheck(err);
MojRefCountedPtr<MojDbTextCollator> collator(new MojDbTextCollator);
MojAllocCheck(collator.get());
err = collator->init(_T("en_US"), MojDbCollationPrimary);
MojTestErrCheck(err);
MojDbKey key;
err = collator->sortKey(strObj, key);
MojTestErrCheck(err);
MojObjectWriter writer;
err = id.visit(writer);
MojTestErrCheck(err);
const MojByte* idData = NULL;
MojSize idSize = 0;
err = writer.buf().data(idData, idSize);
MojTestErrCheck(err);
err = key.byteVec().append(idData, idData + idSize);
MojTestErrCheck(err);
err = assertContains(ti, id, key);
MojTestErrCheck(err);
return MojErrNone;
}
MojErr MojDbQuotaTest::testEnforce(MojDb& db)
{
// set quota size to current usage
MojInt64 quotaUsage1 = 0;
MojErr err = getQuotaUsage(db, _T("com.foo.bar"), quotaUsage1);
MojTestErrCheck(err);
MojObject obj;
err = obj.putString(_T("owner"), _T("com.foo.bar"));
MojErrCheck(err);
err = obj.putInt(_T("size"), quotaUsage1);
MojErrCheck(err);
err = db.putQuotas(&obj, &obj + 1);
MojErrCheck(err);
err = put(db, MojTestKind1Objects[3]);
MojTestErrExpected(err, MojErrDbQuotaExceeded);
// make sure we can delete the kind
MojString kindStr;
err = kindStr.assign(_T("Test:1"));
MojTestErrCheck(err);
bool found = false;
err = db.delKind(kindStr, found);
MojTestErrCheck(err);
MojTestAssert(found);
return MojErrNone;
}
MojErr MojDbPermissionTest::testKindPermissions(MojDb& db)
{
MojObject kind;
MojErr err = kind.fromJson(MojTestKind1);
MojTestErrCheck(err);
// new kind, mismatched owner and caller
MojDbReq req(false);
err = req.domain(_T("com.bar"));
MojTestErrCheck(err);
err = db.putKind(kind, MojDb::FlagNone, req);
MojTestErrExpected(err, MojErrDbPermissionDenied);
// new kind, matched owner and caller
err = req.domain(_T("com.foo"));
MojTestErrCheck(err);
err = db.putKind(kind, MojDb::FlagNone, req);
MojTestErrCheck(err);
// existing kind, matched owner and caller
err = db.putKind(kind, MojDb::FlagNone, req);
MojTestErrCheck(err);
// existing kind, mismatched owner and caller
err = req.domain(_T("com.bar"));
MojTestErrCheck(err);
err = db.putKind(kind, MojDb::FlagNone, req);
MojTestErrExpected(err, MojErrDbPermissionDenied);
// delKind, mismatched owner and caller
MojString id;
err = id.assign(_T("PermissionTest:1"));
MojTestErrCheck(err);
bool found = false;
err = db.delKind(id, found, MojDb::FlagNone, req);
MojTestErrExpected(err, MojErrDbPermissionDenied);
return MojErrNone;
}
MojErr MojDbQuery::createClause(WhereMap& map, const MojChar* propName, CompOp op, MojObject val, MojDbCollationStrength coll)
{
// construct the clause
MojErr err = MojErrNone;
WhereClause clause;
switch (op) {
case OpLessThan:
case OpLessThanEq:
// less-than ops define upper bound
err = clause.setUpper(op, val, coll);
MojErrCheck(err);
break;
default:
// everything else is stored as lower bound
err = clause.setLower(op, val, coll);
MojErrCheck(err);
break;
}
// add clause to map
MojString str;
err = str.assign(propName);
MojErrCheck(err);
err = map.put(str, clause);
MojErrCheck(err);
return MojErrNone;
}
MojErr ContainerManager::InfoToJson(MojObject& rep) const
{
MojObject containers(MojObject::TypeArray);
std::for_each(m_containers.begin(), m_containers.end(),
boost::bind(&ResourceContainer::PushJson,
boost::bind(&ContainerMap::value_type::second, _1),
boost::ref(containers)));
MojErr err = rep.put(_T("containers"), containers);
MojErrCheck(err);
MojObject entityMap(MojObject::TypeArray);
for (EntityContainerMap::const_iterator iter = m_entityContainers.begin();
iter != m_entityContainers.end(); ++iter) {
MojObject mapping(MojObject::TypeObject);
MojString containerName;
err = containerName.assign(iter->second->GetName().c_str());
MojErrCheck(err);
err = mapping.put(iter->first->GetName().c_str(), containerName);
MojErrCheck(err);
err = entityMap.push(mapping);
MojErrCheck(err);
}
err = rep.put(_T("entityMap"), entityMap);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojService::CategoryHandler::addMethod(const MojChar* methodName, Callback callback, bool pub, const MojChar* schemaJson)
{
MojAssert(methodName && callback);
MojString str;
MojErr err = str.assign(methodName);
MojErrCheck(err);
MojRefCountedPtr<MojSchema> schema;
if (schemaJson) {
MojObject schemaObj;
err = schemaObj.fromJson(schemaJson);
MojErrCheck(err);
// add implicit $activity property
MojObject properties;
schemaObj.get(MojSchema::PropertiesKey, properties);
MojObject activityProp;
err = activityProp.putBool(MojSchema::OptionalKey, true);
MojErrCheck(err);
err = properties.put(_T("$activity"), activityProp);
MojErrCheck(err);
err = schemaObj.put(MojSchema::PropertiesKey, properties);
MojErrCheck(err);
schema.reset(new MojSchema);
MojAllocCheck(schema.get());
err = schema->fromObject(schemaObj);
MojErrCheck(err);
}
MojAssert(!m_callbackMap.contains(str));
err = m_callbackMap.put(str, CallbackInfo(callback, schema.get(), pub));
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbTextTokenizerTest::check(const MojChar* text, const MojChar* tokens)
{
// tokenize string
MojString textStr;
MojErr err = textStr.assign(text);
MojTestErrCheck(err);
MojSet<MojDbKey> set;
MojRefCountedPtr<MojDbTextTokenizer> tokenizer(new MojDbTextTokenizer);
MojAllocCheck(tokenizer.get());
err = tokenizer->init(_T("en_US"));
MojTestErrCheck(err);
err = tokenizer->tokenize(textStr, NULL, set);
MojTestErrCheck(err);
// check that tokens match
MojObject obj;
err = obj.fromJson(tokens);
MojTestErrCheck(err);
MojSize objSize = obj.size();
MojSize setSize = set.size();
MojTestAssert(objSize == setSize);
for (MojObject::ConstArrayIterator i = obj.arrayBegin(); i != obj.arrayEnd(); ++i) {
MojDbKey key;
err = key.assign(*i);
MojTestErrCheck(err);
MojTestAssert(set.contains(key));
}
return MojErrNone;
}
MojErr MojDb::updateLocale(const MojChar* locale, MojDbReqRef req)
{
MojAssert(locale);
MojLogTrace(s_log);
MojErr err = beginReq(req, true);
MojErrCheck(err);
MojString oldLocale;
err = getLocale(oldLocale, req);
MojErrCheck(err);
MojString newLocale;
err = newLocale.assign(locale);
MojErrCheck(err);
MojErr updateErr = err = updateLocaleImpl(oldLocale, newLocale, req);
MojErrCatchAll(err) {
err = req->abort();
MojErrCheck(err);
err = m_kindEngine.close();
MojErrCheck(err);
MojDbReq openReq;
err = beginReq(openReq, true);
MojErrCheck(err);
err = m_kindEngine.open(this, openReq);
MojErrCheck(err);
err = openReq.end();
MojErrCheck(err);
MojErrThrow(updateErr);
}
return MojErrNone;
}
TEST_F(QuotaTest, enforce)
{
MojObject obj;
// put quota
MojAssertNoErr( obj.fromJson(_T("{\"owner\":\"com.foo.bar\",\"size\":1000}")) );
MojAssertNoErr( db.putQuotas(&obj, &obj + 1) );
// make kind2 inherit from kind1
MojAssertNoErr( obj.fromJson(MojTestKind2Str3) );
MojExpectNoErr( db.putKind(obj) );
//// end of prerequisites form prev tests
// set quota size to current usage
MojInt64 quotaUsage1 = 0;
EXPECT_NO_FATAL_FAILURE( getQuotaUsage(db, _T("com.foo.bar"), quotaUsage1) );
MojAssertNoErr( obj.putString(_T("owner"), _T("com.foo.bar")) );
MojAssertNoErr( obj.putInt(_T("size"), quotaUsage1) );
MojExpectNoErr( db.putQuotas(&obj, &obj + 1) );
MojAssertNoErr( obj.fromJson(MojTestKind1Objects[3]) );
EXPECT_EQ( MojErrDbQuotaExceeded, db.put(obj) );
// Try to delete the kind
MojString kindStr;
MojAssertNoErr( kindStr.assign(_T("Test:1")) );
bool found = false;
EXPECT_EQ( MojErrDbKindHasSubKinds, db.delKind(kindStr, found) )
<< "The delete should be failure, because it contain sub kind \"Test2:1\"";
EXPECT_FALSE( found );
}
MojErr MojDbQuotaEngine::informQuotaSubscribers(const MojString& kindId)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojErr err;
MojInt64 sizeOut;
MojInt64 usageOut;
MojDbKind* kind = NULL;
MojString owner;
err = owner.assign("");
MojErrCheck(err);
if(m_db->kindEngine()->isExist(kindId.data(), kind))
owner = kind->owner();
if((kind == NULL) || owner.empty())
return MojErrNone;
//ignore if quota not exist
QuotaMap::ConstIterator iter = m_quotas.find(owner.data());
if (iter == m_quotas.end())
return MojErrNone;
err = quotaUsage(owner.data(), sizeOut, usageOut);
MojErrCheck(err);
err = m_db->getQuotaAlert().notifySubscriber(owner.data(), usageOut, sizeOut);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbQuotaTest::testEnforce(MojDb& db)
{
// set quota size to current usage
MojInt64 quotaUsage1 = 0;
MojErr err = getQuotaUsage(db, _T("com.foo.bar"), quotaUsage1);
MojTestErrCheck(err);
MojObject obj;
err = obj.putString(_T("owner"), _T("com.foo.bar"));
MojErrCheck(err);
err = obj.putInt(_T("size"), quotaUsage1);
MojErrCheck(err);
err = db.putQuotas(&obj, &obj + 1);
MojErrCheck(err);
err = put(db, MojTestKind1Objects[3]);
MojTestErrExpected(err, MojErrDbQuotaExceeded);
// Try to delete the kind
MojString kindStr;
err = kindStr.assign(_T("Test:1"));
MojTestErrCheck(err);
bool found = false;
err = db.delKind(kindStr, found);
//The delete should be failure, because it contain sub kind "Test2:1"
MojTestErrExpected(err,MojErrDbKindHasSubKinds);
MojTestAssert(!found);
return MojErrNone;
}
void SmtpSendMailCommand::UpdateSendStatus()
{
try {
MojObject sendStatus;
MojObject visible;
MojErr err;
bool update = false;
if (m_error.errorCode == 0) {
MojLogInfo(m_log, "updating send status to SENT successfully");
err = sendStatus.put(EmailSchema::SendStatus::SENT, true);
ErrorToException(err);
err = visible.put(EmailSchema::Flags::VISIBLE, false);
ErrorToException(err);
update = true;
} else if (m_error.errorOnEmail) {
MojLogInfo(m_log, "updating send status on email to indicate error");
MojString str;
str.assign(m_error.errorText.c_str());
err = sendStatus.put(EmailSchema::SendStatus::LAST_ERROR, str);
ErrorToException(err);
// FIXME: Should we store an actual error code?
err = sendStatus.put(EmailSchema::SendStatus::FATAL_ERROR, true);
ErrorToException(err);
update = true;
}
// account errors are not handled in sent status: message
// status will not be changed in those cases.
if (update) {
MojString idJson;
m_emailId.toJson(idJson);
MojLogInfo(m_log, "updating send status for email %s", idJson.data());
m_session.GetDatabaseInterface().UpdateSendStatus(m_updateSendStatusSlot, m_emailId, sendStatus, visible);
} else {
// Finish up now
Done();
}
} catch (std::exception & e) {
// Error updating status, just give up.
MojLogInfo(m_log, "Exception %s hit trying to update send status, bailing", e.what());
Done();
} catch (...) {
// Error updating status, just give up.
MojLogInfo(m_log, "Unknown exception hit trying to update send status, bailing");
Done();
}
}
MojErr MojObjectTest::putTest(MojObject& obj)
{
MojString str;
MojObject obj2;
MojObject array1;
MojObject str2;
MojObject bool2(false);
MojObject int2(-260000000000LL);
MojObject MojDecimal2(MojDecimal(2.34));
MojErr err = str.assign(_T("howdy"));
MojTestErrCheck(err);
str2 = str;
err = obj2.put(_T("nested"), str);
MojTestErrCheck(err);
err = obj.put(_T("object"), obj2);
MojTestErrCheck(err);
err = obj.put(_T("string"), str2);
MojTestErrCheck(err);
err = obj.put(_T("bool1"), true);
MojTestErrCheck(err);
err = obj.put(_T("bool2"), bool2);
MojTestErrCheck(err);
err = obj.put(_T("int1"), 50);
MojTestErrCheck(err);
err = obj.put(_T("int2"), int2);
MojTestErrCheck(err);
err = obj.put(_T("MojDecimal1"), MojDecimal(0.1));
MojTestErrCheck(err);
err = obj.put(_T("MojDecimal2"), MojDecimal2);
MojTestErrCheck(err);
err = obj.put(_T("null"), MojObject(MojObject::TypeNull));
MojTestErrCheck(err);
// array
err = array1.push(MojObject(MojObject::TypeObject));
MojTestErrCheck(err);
err = array1.push(MojObject(MojObject::TypeArray));
MojTestErrCheck(err);
err = array1.push(str2);
MojTestErrCheck(err);
err = array1.push(true);
MojTestErrCheck(err);
err = array1.setAt(3, false);
MojTestErrCheck(err);
err = array1.push(MojDecimal(3, 140000));
MojTestErrCheck(err);
err = array1.push(100);
MojTestErrCheck(err);
err = array1.push(MojObject(MojObject::TypeNull));
MojTestErrCheck(err);
err = array1.setAt(7, 4);
MojTestErrCheck(err);
err = obj.put(_T("array"), array1);
MojTestErrCheck(err);
return MojErrNone;
}
MojErr MojDbQuery::select(const MojChar* propName)
{
MojString str;
MojErr err = str.assign(propName);
MojErrCheck(err);
err = m_selectProps.put(str);
MojErrCheck(err);
return MojErrNone;
}
void AuthYahooCommand::RunImpl()
{
MojLogTrace(m_log);
// HACK: Hard-code partner ID and fetch of NDUID
m_partnerId.assign("mblclt11");
char id[256];
memset(id, '\0', 256);
// Read nduid, if available, otherwise make a fake one and try to record it.
FILE * nduid = fopen("/proc/nduid", "r");
if (!nduid) {
nduid = fopen("yahooCachedFakeDeviceId", "r");
if (!nduid) {
snprintf(id, 255, "FEED0BEEF479121481533145%016llX", timeMillis());
nduid = fopen("yahooCachedFakeDeviceId", "w");
if (nduid) {
fputs(id, nduid);
fclose(nduid);
nduid = NULL;
}
}
}
if (nduid) {
if (fgets(id, 255, nduid) == NULL)
id[0] = '\0';
fclose(nduid);
nduid = NULL;
if (strlen(id) > 0 && id[strlen(id)-1] == '\n')
id[strlen(id)-1] = '\0';
}
m_deviceId.assign(id);
MojLogInfo(m_log, "Temp: partnerId=%s deviceId=%s", m_partnerId.data(), m_deviceId.data());
MojObject accountId = m_session.GetAccount()->GetAccountId();
MojObject params;
MojErr err = params.put("accountId", accountId);
ErrorToException(err);
MojString token;
token.assign(m_session.GetAccount()->GetYahooToken().c_str());
err = params.put("securityToken", token);
ErrorToException(err);
MojLogInfo(m_log, "Looking up yahoo cookies for account %s", AsJsonString(accountId).c_str());
// TODO: Should send the request with SmtpClient instead.
err = m_session.CreateRequest()->send(m_getYahooCookiesSlot, "com.palm.yahoo","fetchcookies", params);
ErrorToException(err);
}
/*
* Initialize from an incoming libPurple callback parameters
*
* payload form: (Sprint)
* { "serviceName": "gmail", "username": "******", "usernameFrom": "*****@*****.**", "messageText": "<body>test reply to phone<\/body>" }
* { "serviceName": "aol", "username": "******", "usernameFrom": "palm", "messageText": "test incoming message" }
*
*
*/
MojErr IMMessage::initFromCallback(const char* serviceName, const char* username, const char* usernameFrom, const char* message) {
MojErr err;
// unescape, strip html
// #/tmp/testsanitize "<a>foo</a>"
// sanitized: <a>foo</a>
// unsanitized: <a>foo</a>
// removed: foo
// first unescape since gtalk sends everything escaped
// message is const char* - need a char* version
char *unescapedMessage = unsanitizeHtml((char*)message);
// now remove offending html
// char * sanitizeHtml(const char *input, char **except, bool remove);
// remove set to true if you want the the tags to actually be removed vs just "escaped".
// except is an array of char* containing tags to ignore when sanitizing. The
// last element must be a null. You need to include both beginning and ending
// tag if you want both removed (i.e. "b", "/b", "i", "/i")
char *sanitizedMessage = sanitizeHtml(unescapedMessage, (char**)IMMessage::trustedTags, true);
// can't keep this log...
//MojLogInfo(IMServiceApp::s_log, _T("original message: %s, unescaped message: %s, sanitized message: %s"), message, unescapedMessage, sanitizedMessage);
err = msgText.assign(sanitizedMessage);
MojErrCheck(err);
// cleanup
free(unescapedMessage);
free(sanitizedMessage);
// remove blanks and convert to lowercase
// for AOL, this is screen name with no "@aol.com"...
MojString formattedUserName;
err = formattedUserName.assign(usernameFrom);
MojErrCheck(err);
err = unformatFromAddress(formattedUserName, fromAddress);
MojErrCheck(err);
err = toAddress.assign(username);
MojErrCheck(err);
err = msgType.assign(serviceName);
MojErrCheck(err);
// set time stamp to current time - seconds since 1/1/1970
// for some reason multiplying a time_t by 1000 doesn't work - you have to convert to a long first...
//deviceTimestamp = time (NULL) * 1000;
MojInt64 sec = time (NULL);
deviceTimestamp = sec * 1000;
// server timestamp is new Date().getTime()
serverTimestamp = sec * 1000;
return MojErrNone;
}
void SaveEmailCommand::CreateNextCacheObject()
{
MojErr err;
for(; m_partsIt != m_partsArray.arrayEnd(); ++m_partsIt) {
MojObject& part = *m_partsIt;
bool hasContent;
MojString content;
err = part.get("content", content, hasContent);
ErrorToException(err);
if(hasContent) {
MojString cacheType;
cacheType.assign("email");
bool hasDisplayName;
MojString displayName;
err = part.get("displayName", displayName, hasDisplayName);
ErrorToException(err);
MojString cacheFileName;
if(hasDisplayName && displayName.length() > 0) {
cacheFileName.assign(displayName);
} else {
// FIXME only for HTML parts
cacheFileName.assign("body.html");
}
MojLogDebug(m_log, "creating a file cache entry");
m_client.GetFileCacheClient().InsertCacheObject(m_fileCacheInsertedSlot, cacheType, cacheFileName, content.length(), EMAIL_FILECACHE_COST, EMAIL_NO_LIFE_TIME);
// Exit method and wait for response
return;
}
}
// If this is the last part with content, persist to database now
PersistToDatabase();
}
MojErr MojLunaService::addCategory(const MojChar* name, CategoryHandler* handler)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(name && handler);
MojAssertMutexUnlocked(m_mutex);
MojThreadGuard guard(m_mutex);
// create array of LSMethods
MethodVec pubMethods;
MethodVec privMethods;
const CategoryHandler::CallbackMap& callbacks = handler->callbacks();
for (CategoryHandler::CallbackMap::ConstIterator i = callbacks.begin();
i != callbacks.end();
i++) {
LSMethod m = {i.key(), &handleRequest};
MethodVec& methods = i->m_pub ? pubMethods : privMethods;
MojErr err = methods.push(m);
MojErrCheck(err);
}
LSMethod nullMethod = {NULL, NULL};
MojErr err = pubMethods.push(nullMethod);
MojErrCheck(err);
err = privMethods.push(nullMethod);
MojErrCheck(err);
// create category object to hang on to method array
MojRefCountedPtr<LunaCategory> cat(new LunaCategory(this, handler, pubMethods, privMethods));
MojAllocCheck(cat.get());
LSMethod* pubLsMethods = const_cast<LSMethod*>(cat->m_pubMethods.begin());
LSMethod* privLsMethods = const_cast<LSMethod*>(cat->m_privMethods.begin());
MojLunaErr lserr;
bool retVal;
if (m_service) {
retVal = LSPalmServiceRegisterCategory(m_service, name, pubLsMethods, privLsMethods, NULL, cat.get(), lserr);
MojLsErrCheck(retVal, lserr);
} else {
MojAssert(m_handle);
retVal = LSRegisterCategory(m_handle, name, privLsMethods, NULL, NULL, lserr);
MojLsErrCheck(retVal, lserr);
retVal = LSCategorySetData(m_handle, name, cat.get(), lserr);
MojLsErrCheck(retVal, lserr);
}
MojString categoryStr;
err = categoryStr.assign(name);
MojErrCheck(err);
err = m_categories.put(categoryStr, cat);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbQuotaEngine::kindUsage(const MojChar* kindId, MojInt64& usageOut, MojDbStorageTxn* txn)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojString kindStr;
MojErr err = kindStr.assign(kindId);
MojErrCheck(err);
MojRefCountedPtr<MojDbStorageItem> item;
err = getUsage(kindStr, txn, false, usageOut, item);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojLunaService::createRequest(MojRefCountedPtr<MojServiceRequest>& reqOut, bool onPublic, const char *proxyRequester)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojString proxyRequesterString;
MojErr err = proxyRequesterString.assign(proxyRequester);
MojErrCheck(err);
reqOut.reset(new MojLunaRequest(this, onPublic, proxyRequesterString));
MojAllocCheck(reqOut.get());
return MojErrNone;
}
MojErr MojDbQuotaEngine::kindUsage(const MojChar* kindId, MojInt64& usageOut, MojDbStorageTxn* txn)
{
MojLogTrace(s_log);
MojString kindStr;
MojErr err = kindStr.assign(kindId);
MojErrCheck(err);
MojRefCountedPtr<MojDbStorageItem> item;
err = getUsage(kindStr, txn, false, usageOut, item);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojLogEngine::loggerNames(StringSet& setOut)
{
setOut.clear();
MojThreadGuard guard(m_mutex);
for (LoggerList::ConstIterator i = m_loggers.begin(); i != m_loggers.end(); ++i) {
MojString name;
MojErr err = name.assign((*i)->name());
MojErrCheck(err);
err = setOut.put(name);
MojErrCheck(err);
}
return MojErrNone;
}
/*
* Initialize from an incoming libPurple callback parameters
*
* payload form: (Sprint)
* { "serviceName": "gmail", "username": "******", "usernameFrom": "*****@*****.**", "messageText": "<body>test reply to phone<\/body>" }
* { "serviceName": "aol", "username": "******", "usernameFrom": "palm", "messageText": "test incoming message" }
*
*
*/
MojErr IMMessage::initFromCallback(const char* serviceName, const char* username, const char* usernameFrom, const char* message) {
MojErr err;
// unescape, strip html
// #/tmp/testsanitize "<a>foo</a>"
// sanitized: <a>foo</a>
// unsanitized: <a>foo</a>
// removed: foo
char* unescapedMessage = purple_unescape_html(message);
char* sanitizedMessage = purple_markup_strip_html(unescapedMessage);
g_free(unescapedMessage);
msgText.assign("");
// Inefficient but working solution.
// TODO: Implement proper sanitization (that just keeps br, u, l and i)
for (char* ptr = sanitizedMessage; *ptr; ++ptr)
if (*ptr == '\n')
msgText.append("<br>");
else
msgText.append(*ptr);
err = msgText.assign(sanitizedMessage);
g_free(sanitizedMessage);
MojErrCheck(err);
// remove blanks and convert to lowercase
// for AOL, this is screen name with no "@aol.com"...
MojString formattedUserName;
err = formattedUserName.assign(usernameFrom);
MojErrCheck(err);
err = unformatFromAddress(formattedUserName, fromAddress);
MojErrCheck(err);
err = toAddress.assign(username);
MojErrCheck(err);
err = msgType.assign(serviceName);
MojErrCheck(err);
// set time stamp to current time - seconds since 1/1/1970
// for some reason multiplying a time_t by 1000 doesn't work - you have to convert to a long first...
//deviceTimestamp = time (NULL) * 1000;
MojInt64 sec = time (NULL);
deviceTimestamp = sec * 1000;
// server timestamp is new Date().getTime()
serverTimestamp = sec * 1000;
return MojErrNone;
}
/*
* Load preferences for account we are logging in to
*
*/
MojErr IMServiceHandler::loadpreferences(MojServiceMessage* serviceMsg, const MojObject payload)
{
//Sleep for 3 secondas to ensure DB is updated
sleep(3);
//Load server and port
MojString errorText;
bool found = false;
bool result = true;
MojString templateId;
MojString UserName;
//Get templateId
MojErr err = payload.get(_T("templateId"), templateId, found);
if (!found) {
errorText.assign(_T("Missing templateId in payload."));
result = false;
}
//Get server name
err = payload.get(_T("UserName"), UserName, found);
if (!found) {
errorText.assign(_T("Missing UserName in payload."));
result = false;
}
if (!result) {
serviceMsg->replyError(err, errorText);
return MojErrNone;
}
//Load the prefs
LoadAccountPreferences (templateId, UserName);
//Return success
serviceMsg->replySuccess();
return MojErrNone;
}
MojErr MojDbTestStorageEngine::setNextError(const MojChar* methodName, MojErr err)
{
if (err == MojErrNone) {
bool found;
MojErr errDel = m_errMap.del(methodName, found);
MojErrCheck(errDel);
} else {
MojString str;
str.assign(methodName);
MojErr errPut = m_errMap.put(str, err);
MojErrCheck(errPut);
}
return MojErrNone;
}
MojErr MojDbLevelDatabase::open(const MojChar* dbName, MojDbLevelEngine* eng, bool& createdOut, MojDbStorageTxn* txn)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(dbName && eng);
MojAssert(!txn || txn->isValid());
// save eng, name and file
createdOut = false;
m_engine = eng;
MojErr err = m_name.assign(dbName);
MojErrCheck(err);
const MojString& engPath = eng->path();
if (engPath.empty()) {
err = m_file.assign(dbName);
MojErrCheck(err);
} else {
err = m_file.format(_T("%s/%s"), engPath.data(), dbName);
MojErrCheck(err);
}
// create and open db
leveldb::Status status = leveldb::DB::Open(MojDbLevelEngine::getOpenOptions(), m_file.data(), &m_db);
if (status.IsCorruption()) { // database corrupted
// try restore database
// AHTUNG! After restore database can lost some data!
status = leveldb::RepairDB(m_file.data(), MojDbLevelEngine::getOpenOptions());
MojLdbErrCheck(status, _T("db corrupted"));
status = leveldb::DB::Open(MojDbLevelEngine::getOpenOptions(), m_file.data(), &m_db); // database restored, re-open
}
MojLdbErrCheck(status, _T("db_create"));
MojAssert(m_db);
// set up prop-vec for primary key queries
MojString idStr;
err = idStr.assign(MojDb::IdKey);
MojErrCheck(err);
err = m_primaryProps.push(idStr);
MojErrCheck(err);
//keep a reference to this database
err = eng->addDatabase(this);
MojErrCheck(err);
return MojErrNone;
}
void SmtpSyncOutboxCommand::CheckErrorCodes()
{
CommandTraceFunction();
try {
if (m_error.IsLockoutError()) {
if (m_force) {
MojLogInfo(m_log, "Account locked out due to error (code=%d,internal=%s), but continuing due to force.",
m_error.errorCode,
m_error.internalError.c_str());
} else {
MojLogInfo(m_log, "Account locked out due to error (code=%d,internal=%s), completing sync early.",
m_error.errorCode,
m_error.internalError.c_str());
SmtpSyncOutboxCommand::CompleteAndUpdateActivities();
return;
}
}
if (m_error.errorCode) {
// Reset error code before we continue -- if the
// account still has trouble, we'll put the error
// back before we're done.
// clear our state
m_error.clear();
MojString text;
text.assign("");
// clear the db state
m_client.GetDatabaseInterface().UpdateAccountErrorStatus(m_resetErrorSlot, m_accountId, 0, text);
return;
} else {
// clear entire error state
m_error.clear();
}
GetOutboxEmails();
} catch (std::exception & e) {
HandleException(e, __func__);
} catch (...) {
HandleException(__func__);
}
}
MojErr MojDbServiceHandler::open()
{
MojLogTrace(s_log);
MojErr err = addMethods(s_pubMethods, true);
MojErrCheck(err);
err = addMethods(s_privMethods, false);
MojErrCheck(err);
for (const Method* method = s_batchMethods; method->m_name != NULL; method++) {
MojString methodStr;
err = methodStr.assign(method->m_name);
MojErrCheck(err);
err = m_batchCallbacks.put(methodStr, (DbCallback) method->m_callback);
MojErrCheck(err);
}
return MojErrNone;
}