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

bool MojoSimpleMatcher::Match(const MojObject& response)
{
	if (!m_setupComplete) {
		MojLogInfo(s_log, _T("Simple Matcher: Setup successfully"));
		m_setupComplete = true;
		return false;
	} else {
		MojLogInfo(s_log, _T("Simple Matcher: Matched"));
		return true;
	}
}

void ActivityManager::InteractiveYieldTimeout()
{
	MojLogTrace(s_log);
	MojLogInfo(s_log, _T("Background interactive yield timeout triggered"));

	if (m_runQueue[RunQueueReadyInteractive].empty()) {
		MojLogInfo(s_log, _T("Ready interactive queue is empty, cancelling "
			"yield timeout"));
		CancelYieldTimeout();
		return;
	}

	/* XXX make 1 more Activity yield, but only if there are fewer Activities
	 * yielding than waiting in the interactive queue. */
	unsigned waiting = (unsigned) m_runQueue[RunQueueReadyInteractive].size();
	unsigned yielding = 0;

	boost::shared_ptr<Activity> victim;

	ActivityRunQueue::iterator iter;

	for (iter = m_runQueue[RunQueueBackgroundInteractive].begin();
		iter != m_runQueue[RunQueueBackgroundInteractive].end(); ++iter) {
		if (iter->IsYielding()) {
			if (++yielding >= waiting) {
				break;
			}
		} else {
			if (!victim) {
				victim = iter->shared_from_this();
			}
		}
	}

	/* If there aren't already too many yielding... */
	if (iter == m_runQueue[RunQueueBackgroundInteractive].end()) {
		if (victim) {
			MojLogInfo(s_log, _T("Requesting that [Activity %llu] yield"),
				victim->GetId());
			victim->YieldActivity();
		} else {
			MojLogInfo(s_log, _T("All running background interactive "
				"Activities are already yielding"));
		}
	} else {
		MojLogInfo(s_log, _T("Number of yielding Activities is already equal "
			"to the number of ready interactive Activities waiting in the "
			"queue"));
	}

	UpdateYieldTimeout();
}

void SyncFolderCommand::SyncFolder()
{
	PopClient::AccountPtr account = m_client.GetAccount();
	MojLogInfo(m_log, "inbox=%s, syncing folder=%s, force=%d",
				AsJsonString(account->GetInboxFolderId()).c_str(),
				AsJsonString(m_folderId).c_str(),
				m_force);
	if (m_folderId != account->GetInboxFolderId()) {
		// POP transport only supports inbox sync.
		MojLogInfo(m_log, "POP transport will skip non-inbox syncing");
		Complete();
		return;
	}

	SyncSessionPtr sSession = m_client.GetOrCreateSyncSession(m_folderId);
	m_activity = ActivityParser::GetActivityFromPayload(m_payload);
	if (!sSession->IsActive() && !sSession->IsEnding()) {
		// since sync session is not running, we can start the folder sync
		MojLogDebug(m_log, "Sync session is not active");
		StartFolderSync(m_activity);

		Complete();
	} else {
		if (m_force) {
			// Manual Sync and session is either active or ending

			// TODO: sync session is in progress, need to terminate the current
			// sync session first.  Then re-start sync session.
			StartFolderSync(m_activity);

			Complete();
		} else {
			// This is either auto sync, schedule sync, retry sync.
			if (sSession->IsActive()) {

				if (m_activity.get()) {
					MojLogInfo(m_log, "Attach sync activity to actively syncing session");

					// Adopt activity and then add it to sync session
					m_activity->Adopt(m_client);
					sSession->AttachActivity(m_activity);
				}

				Complete();
			} else if (sSession->IsEnding()) {
				// wait for sync session to end and then start folder sync
				MojLogInfo(m_log, "Waiting for ending sync session to complete");
				sSession->WaitForSessionComplete(m_syncSessionCompletedSlot);
			}
		}
	}
}

/*
 * Send the messages off to libpurple transport
 */
MojErr SendOneMessageHandler::sendToTransport()
{
	MojErr err = MojErrNone;

	// can't log message text in production
	MojLogInfo (IMServiceApp::s_log, "sending message to transport. id: %s, serviceName: %s, username: %s, usernameTo: %s",
			m_currentMsgdbId.data(), m_serviceName.data(), m_username.data(), m_usernameTo.data());

	// Note, libpurple does not return errors on send - adapter only checks that the parameters are valid and that the user is logged in
	// otherwise assume success...
	LibpurpleAdapter::SendResult retVal = LibpurpleAdapter::sendMessage(m_serviceName.data(), m_username.data(), m_usernameTo.data(), m_messageText.data());

	// Now save the status
	MojObject propObject;
	if (LibpurpleAdapter::SENT == retVal) {
		// successful send
		propObject.putString(MOJDB_STATUS, IMMessage::statusStrings[Successful]);
		MojLogInfo(IMServiceApp::s_log, _T("LibpurpleAdapter::sendToTransport succeeded"));
	}
	else if (LibpurpleAdapter::USER_NOT_LOGGED_IN == retVal) {
		// user not logged in - put in queued state
		propObject.putString(MOJDB_STATUS, IMMessage::statusStrings[WaitingForConnection]);
		MojLogError(IMServiceApp::s_log, _T("LibpurpleAdapter::sendToTransport - user not logged in. waiting for connection"));
	}
	else {
		// permanent error - no retry option
		propObject.putString(MOJDB_STATUS, IMMessage::statusStrings[Undeliverable]);

		// set the error category string for the UI
		const MojChar* errorCategory = transportErrorToCategory(retVal);
		propObject.putString(MOJDB_ERROR_CATEGORY, errorCategory);
		MojLogError(IMServiceApp::s_log, _T("LibpurpleAdapter::sendToTransport failed. error %d, category %s"), retVal, errorCategory);
	}

	// id to update
	propObject.putString(MOJDB_ID, m_currentMsgdbId);

	// set server timestamp to current time.
	MojInt64 now = time (NULL);
	propObject.put(MOJDB_SERVER_TIMESTAMP, now);

	// save the new fields - call merge
	// MojErr merge(Signal::SlotRef handler, const MojObject& obj, MojUInt32 flags = MojDb::FlagNone);
	err = m_dbClient.merge(this->m_imSaveMessageSlot, propObject);
	if (err) {
		MojLogError(IMServiceApp::s_log, _T("call to merge message into DB failed. err %d, DB id %s: "), err, m_currentMsgdbId.data() );
		// request to save failed - not much we can do here...
		m_outgoingIMHandler->messageFinished();
	}

	return MojErrNone;
}

MojErr SmtpSyncOutboxCommand::FindOutgoingFolderResponse(MojObject &response, MojErr err)
{
	try {
		ResponseToException(response, err);
		MojLogInfo(m_log, "FindOutgoingFolderResponse, response elided");
	
		try {
			MojObject folder;
			DatabaseAdapter::GetOneResult(response, folder);

			m_retryDelay.clear();
			folder.get("smtpRetryDelay", m_retryDelay);
			ErrorToException(err);
                
			m_retryDelayNew = m_retryDelay;

			MojString json;
			m_retryDelay.toJson(json);
			MojLogInfo(m_log, "got retry delay %s", json.data());
			
			UpdateAccountWatchActivity();
		
		} catch(...) {
			MojLogInfo(m_log, "No outgoing folder, erroring out");
		
			// We must log an error if we cannot find the
			// appropriate outbox folder id, so that in the case
			// of a missing folder, we'll disconnect any
			// potentially left-over watches, and not come back
			// up until the account watches trigger us to update
			// and try again.
			
			m_error.errorCode = MailError::SMTP_OUTBOX_UNAVAILABLE;
			m_error.errorOnAccount = true;
			m_error.errorOnEmail = false;
			m_error.internalError = "Unable to establish outbox folder associated with SMTP account";
			m_error.errorText = "";
			SmtpSyncOutboxCommand::CompleteAndUpdateActivities();
			
			return MojErrNone;
		}

	} catch (std::exception & e) {
		HandleException(e, __func__);
	} catch (...) {
		HandleException(__func__);
	}
        
	return MojErrNone;
}

bool MojoWhereMatcher::Match(const MojObject& response)
{
	MojLogTrace(s_log);

	if (CheckClauses(m_where, response)) {
		MojLogInfo(s_log, _T("Where Matcher: Response %s matches"),
			MojoObjectJson(response).c_str());
		return true;
	} else {
		MojLogInfo(s_log, _T("Where Matcher: Response %s does not match"),
			MojoObjectJson(response).c_str());
		return false;
	}
}

bool MojoNewWhereMatcher::Match(const MojObject& response)
{
	MojLogTrace(s_log);

	MatchResult result = CheckClause(m_where, response, AndMode);
	if (result == Matched) {
		MojLogInfo(s_log, _T("Where Matcher: Response %s matches"),
			MojoObjectJson(response).c_str());
		return true;
	} else {
		MojLogInfo(s_log, _T("Where Matcher: Response %s does not match"),
			MojoObjectJson(response).c_str());
		return false;
	}
}

void SyncSession::UpdateActivities()
{
	MojLogInfo(m_log, "updating sync session %p activities", this);

	if (m_accountError.errorCode != MailError::NONE) {
		MojLogInfo(m_log, "--- account error: [%d]%s", m_accountError.errorCode, m_accountError.errorText.c_str());
	}

	if(PopErrors::IsRetryError(m_accountError)) {
		m_client.ScheduleRetrySync(m_accountError);
	} else {
		UpdateScheduledSyncActivity();
		UpdateRetryActivity();
	}
}

void SmtpSyncOutboxCommand::UpdateAccountWatchActivity()
{
	MojLogInfo(m_log, "UpdatingAccountWatchActivity");
	
	try {
		// accoundId json object
		MojString accountIdJson;
		MojErr err = m_accountId.toJson(accountIdJson);
		ErrorToException(err);

		SmtpActivityFactory factory;
		ActivityBuilder ab;

		factory.BuildSmtpConfigWatch(ab, m_accountId, m_accountRev);

		bool updating = m_accountWatchActivity.get();

		// and either update and complete the updated activity if we had adopted it, or re-create it.
		
		if ( updating ) {
			
			MojLogInfo(m_log, "updating account watch activity");
	
			m_accountWatchActivity->SetSlots(m_accountActivityUpdatedSlot, m_accountActivityErrorSlot);
	
			m_accountWatchActivity->UpdateAndComplete(m_client, ab.GetActivityObject());
			
		} else {
			// Create payload
			MojObject payload;
			err = payload.put("activity", ab.GetActivityObject());
			ErrorToException(err);
			err = payload.put("start", true);
			ErrorToException(err);
			err = payload.put("replace", true);
			ErrorToException(err);
				
			MojLogInfo(m_log, "creating account watch activity");
							
			m_client.SendRequest(m_createAccountWatchActivityResponseSlot, "com.palm.activitymanager", "create", payload);
		}

	} catch (std::exception & e) {
		HandleException(e, __func__);
	} catch (...) {
		HandleException(__func__);
	}
}

MojErr AccountFinderCommand::GetPasswordResponse(MojObject& response, MojErr err)
{
	CommandTraceFunction();

	try {
		// check the result first
		ErrorToException(err);

		MojObject credentials;
		// Credentials object can be missing if the POP account is restored from
		// backup.  Checking for its existence before using it will prevent exception
		// to be thrown.
		bool exists = response.get("credentials", credentials);
		if (exists) {
			MojString password;
			err = credentials.getRequired("password", password);
			ErrorToException(err);

			m_account->SetPassword(password.data());
		} else {
			MojLogInfo(m_log, "The credentials of POP account '%s' are missing", AsJsonString(m_accountId).c_str());
		}

		// get the transport object
		GetPopAccount();
	} catch (const std::exception& ex) {
		Failure(ex);
	} catch (...) {
		Failure(MailException("unknown exception", __FILE__, __LINE__));
	}

	return MojErrNone;
}

/*
 * inviteBuddy: tell libpurple to add the buddy
 * add buddy to buddyStatus and contact DB kinds
 *
 * imcommand:
 * {
   "params" : {
      "group"            : {"type"        : "string",
                            "optional"    : true,
                            "description" : "The name of the group to put the buddy in."},
      "message"          : {"type"        : "string",
                            "optional"    : true,
                            "description" : "If the IM transport supports custom invite messages."}
     }
 * }
 *
 */
LibpurpleAdapter::SendResult SendOneCommandHandler::inviteBuddy(const MojObject imCmd) {

	bool found = false;

	// params
	MojObject params;
	MojString group;
	found = imCmd.get(MOJDB_PARAMS, params);
	IMServiceHandler::logMojObjectJsonString(_T("command params: %s"),params);
	if (found) {
		params.get(XPORT_GROUP, group, found);
	}

	MojLogInfo (IMServiceApp::s_log, "sending addBuddy command to transport. id: %s, serviceName: %s, username: %s, buddyUsername: %s, groupName: %s",
			m_currentCmdDbId.data(), m_serviceName.data(), m_username.data(), m_buddyName.data(), group.data());

	// Note, libpurple does not return errors on send - adapter only checks that the parameters are valid and that the user is logged in
	// otherwise assume success...
	LibpurpleAdapter::SendResult retVal = LibpurpleAdapter::addBuddy(m_serviceName.data(), m_username.data(), m_buddyName.data(), group.data());

	// Note: if the remote user rejects our invite, buddy gets deleted on the server but we do not get notified, so the contact will remain, but the buddy list gets re-synced on the next login

	if (LibpurpleAdapter::SENT == retVal) {
		// add to buddyStatus and contacts list. They will get removed later if the invite is rejected
		addBuddyToDb();
	}
	return retVal;
}

void SmtpSendMailCommand::GetEmail()
{
	try {
		// Get the email from the database
		MojLogInfo(m_log, "trying GetOutboxEmail query");

		m_session.GetDatabaseInterface().GetOutboxEmail(m_getEmailSlot, m_emailId);

		MojLogInfo(m_log, "started GetOutboxEmail query");

	} catch (const std::exception& e) {
		HandleException(e, __func__, __FILE__, __LINE__);
	} catch (...) {
		HandleUnknownException();
	}
}

MojErr MojDbIsamQuery::count(MojUInt32& countOut)
{
	MojAssert(m_isOpen);

	countOut = 0;
	MojInt32 warns = 0;
	m_plan->limit(MojUInt32Max);
	bool found = false;
	do {
		// Iterate over all the db results but only count
		// the ones that would not be excluded.  If we're not
		// excluding any kinds, getImpl does not need to get the
		// storage item.
		MojDbStorageItem* item = NULL;
		//MojErr err = getImpl(item, found, !m_excludeKinds.empty());  // orig
		//to ensure that we do not count ghost keys, me need to always try to get the item as well
		MojErr err = getImpl(item, found, true);
		if (err == MojErrInternalIndexOnFind) {
			found = true;			// to continue with counting
			warns++;
			continue;			// we ignore such keys; it is not counted in getImpl either
		}
		MojErrCheck(err);
	} while (found);
	countOut = m_count;
	if (warns > 0) {
		const MojChar * from = m_plan->query().from().data();
		MojLogInfo(MojDb::s_log, _T("isamquery_count: from: %s; indexid: %zu; warnings: %d \n"),
								 from, m_plan->idIndex(), warns);
	}
	return MojErrNone;
}

// Returns the filename of a cachedObject
const std::string
CFileCacheSet::CachedObjectFilename(const cachedObjectId_t objId) {

  MojLogTrace(s_log);

  std::string retVal;
  const std::string typeName(GetTypeForObjectId(objId));
  if (!typeName.empty()) {
    CFileCache* fileCache = GetFileCacheForType(typeName);
    if (fileCache != NULL) {
      retVal = fileCache->GetObjectFilename(objId);
      MojLogInfo(s_log,
		 _T("CachedObjectFilename: Object '%llu' has name '%s'."),
		 objId, retVal.c_str());
    } else {
      MojLogWarning(s_log,
		    _T("CachedObjectFilename: No cache of type '%s' found for id '%llu'."),
		    typeName.c_str(), objId);
    }
  } else {
    MojLogWarning(s_log,
		  _T("CachedObjectFilename: Cache type not found for id '%llu'."),
		  objId);
  }

  return retVal;

}

/*
 * Save the new incoming IM message to the DB
 *
 * @return MojErr if error - caller will log it
 */
MojErr IncomingIMHandler::saveNewIMMessage(MojRefCountedPtr<IMMessage> IMMessage) {

	MojErr err;

	// The message we are handling
	m_IMMessage = IMMessage;

	// save it
	MojObject dbObject;
	err = m_IMMessage->createDBObject(dbObject);
	MojErrCheck(err);

	//add our kind to the object
	//luna://com.palm.db/put '{"objects":[{"_kind":"com.palm.test:1","foo":1,"bar":1000}]}'
	err = dbObject.putString(_T("_kind"), PALM_DB_IMMESSAGE_KIND);
	MojErrCheck(err);

	// log it - OK to show body in debug log
	MojString json;
	err = dbObject.toJson(json);
	MojErrCheck(err);
	MojLogDebug(IMServiceApp::s_log, _T("saving message to db: %s"), json.data());
	MojLogInfo(IMServiceApp::s_log, _T("saving message to db"));

	// save it
	// the save generates a call to the save result handler
	err = m_dbClient.put(this->m_IMSaveMessageSlot, dbObject);
	MojErrCheck(err);

	return MojErrNone;
}

MojErr UpSyncSentEmailsCommand::GetSentEmailsResponse(MojObject& response, MojErr err)
{
	CommandTraceFunction();

	try {
		ErrorToException(err);

		// Store all sent emails in a vector.
		BOOST_FOREACH(const MojObject& emailObj, DatabaseAdapter::GetResultsIterators(response))
		{
			EmailPtr email = boost::make_shared<Email>();
			EmailAdapter::ParseDatabaseObject(emailObj, *email);
			MojObject id;
			err = emailObj.getRequired(DatabaseAdapter::ID, id);
			ErrorToException(err);
			email->SetId(id);
			m_sentEmails.push_back(email);
		}

		// Check for more results
		bool hasMoreResults = DatabaseAdapter::GetNextPage(response, m_sentEmailsPage);

		if(hasMoreResults) {
			GetSentEmails();
		} else {
			if(!m_sentEmails.empty()) {
				MojLogInfo(m_log, "up sync %d sent emails to the server", m_sentEmails.size());
				m_emailP = m_sentEmails.back();
				CreateAndRunAppendCommand();
			} else {
				UpSyncSentItemsComplete();
			}
		}

	} CATCH_AS_FAILURE

MojErr
DevelCategoryHandler::PriorityControl(MojServiceMessage *msg, MojObject& payload)
{
	ACTIVITY_SERVICEMETHOD_BEGIN();

	MojLogTrace(s_log);
	MojLogInfo(s_log, _T("PriorityControl: %s"),
		MojoObjectJson(payload).c_str());

	MojErr err;

	bool enabled = false;
	bool found = payload.get(_T("enabled"), enabled);
	if (!found) {
		err = msg->replyError(MojErrInvalidArg, _T("Must specify "
			"\"enabled\":true or \"enabled\":false"));
		MojErrCheck(err);
		return MojErrNone;
	}

	if (enabled) {
		m_resourceManager->Enable();
	} else {
		m_resourceManager->Disable();
	}

	err = msg->replySuccess();
	MojErrCheck(err);

	ACTIVITY_SERVICEMETHOD_END(msg);

	return MojErrNone;
}

void ConnectCommand::RunImpl()
{
    CommandTraceFunction();

    try {
        const ImapLoginSettings& loginSettings = m_session.GetLoginSettings();

        std::string hostname = loginSettings.GetHostname();
        int port = loginSettings.GetPort();
        ImapLoginSettings::EncryptionType encryption = loginSettings.GetEncryption();

        if(hostname.empty() || port <= 0) {
            throw MailException("empty hostname or port", __FILE__, __LINE__);
        }

        MojLogInfo(m_log, "connecting to %s:%d%s on interface %s",
                   hostname.c_str(), port, (encryption == ImapLoginSettings::Encrypt_SSL) ? " with SSL" : "",
                   !m_bindAddress.empty() ? m_bindAddress.c_str() : "0.0.0.0");

        m_connection = SocketConnection::CreateSocket(hostname.c_str(), port,
                       (encryption == ImapLoginSettings::Encrypt_SSL), m_bindAddress);

        int connectTimeout = ImapConfig::GetConfig().GetConnectTimeout();

        if(connectTimeout) {
            m_connection->SetConnectTimeout(connectTimeout);
        }

        m_connection->Connect(m_connectedSlot);
    } catch(const exception& e) {
        ConnectFailure(e);
    }
}

void PopSession::FetchEmail(Request::RequestPtr request)
{
	MojLogInfo(m_log, "Fetching email '%s' with '%s' priority", AsJsonString(request->GetEmailId()).c_str(), ((request->GetPriority() == Request::Priority_High) ? "high" : "low"));
	MojRefCountedPtr<FetchEmailCommand> command(new FetchEmailCommand(*this, request));
	m_commandManager->QueueCommand(command, (request->GetPriority() == Request::Priority_High));
	CheckQueue();
}