1326 lines
34 KiB
C++
1326 lines
34 KiB
C++
/*
|
|
* Copyright 2010, Pier Luigi Fiorini. All rights reserved.
|
|
* Distributed under the terms of the GPL v2 License.
|
|
*
|
|
* Authors:
|
|
* Pier Luigi Fiorini, pierluigi.fiorini@gmail.com
|
|
*/
|
|
|
|
#include <Directory.h>
|
|
#include <Entry.h>
|
|
#include <File.h>
|
|
#include <FindDirectory.h>
|
|
#include <List.h>
|
|
|
|
#include <CayaProtocolMessages.h>
|
|
|
|
#include <libsupport/SHA1.h>
|
|
|
|
#include <gloox/chatstatefilter.h>
|
|
#include <gloox/messageeventfilter.h>
|
|
#include <gloox/mucroom.h>
|
|
|
|
#include "JabberHandler.h"
|
|
|
|
|
|
static status_t
|
|
connect_thread(void* data)
|
|
{
|
|
|
|
JabberHandler* handler = (JabberHandler*)data;
|
|
if (!handler)
|
|
return B_BAD_VALUE;
|
|
|
|
gloox::Client* client = handler->Client();
|
|
if (!client)
|
|
return B_BAD_VALUE;
|
|
|
|
gloox::ConnectionError e;
|
|
while ((e = client->recv(10000000)) == gloox::ConnNoError);
|
|
|
|
if (e != gloox::ConnUserDisconnected)
|
|
handler->HandleConnectionError(e);
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
JabberHandler::JabberHandler()
|
|
:
|
|
fClient(NULL),
|
|
fVCardManager(NULL),
|
|
fSession(NULL)
|
|
{
|
|
fAvatars = new BList();
|
|
}
|
|
|
|
|
|
JabberHandler::~JabberHandler()
|
|
{
|
|
Shutdown();
|
|
|
|
BString* item = NULL;
|
|
for (int32 i = 0; (item = (BString*)fAvatars->ItemAt(i)); i++)
|
|
delete item;
|
|
delete fAvatars;
|
|
}
|
|
|
|
|
|
status_t
|
|
JabberHandler::Init(CayaProtocolMessengerInterface* messenger)
|
|
{
|
|
fServerMessenger = messenger;
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
status_t
|
|
JabberHandler::Process(BMessage* msg)
|
|
{
|
|
if (msg->what != IM_MESSAGE)
|
|
return B_ERROR;
|
|
|
|
int32 im_what = 0;
|
|
|
|
msg->FindInt32("im_what", &im_what);
|
|
|
|
switch (im_what) {
|
|
case IM_SET_OWN_STATUS: {
|
|
int32 status = msg->FindInt32("status");
|
|
BString status_msg = msg->FindString("message");
|
|
|
|
switch (status) {
|
|
case CAYA_ONLINE:
|
|
// Log in if we still need to
|
|
resume_thread(fRecvThread);
|
|
break;
|
|
case CAYA_OFFLINE:
|
|
kill_thread(fRecvThread);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IM_SEND_MESSAGE: {
|
|
const char* id = msg->FindString("chat_id");
|
|
const char* subject = msg->FindString("subject");
|
|
const char* body = msg->FindString("body");
|
|
|
|
if (!id || !body)
|
|
return B_ERROR;
|
|
|
|
// Send JabberHandler message
|
|
gloox::Message jm(gloox::Message::Chat, gloox::JID(id),
|
|
body, (subject ? subject : gloox::EmptyString));
|
|
fClient->send(jm);
|
|
|
|
// Tell Caya we actually sent the message
|
|
_MessageSent(id, subject, body);
|
|
break;
|
|
}
|
|
|
|
case IM_CREATE_CHAT: {
|
|
const char* invite_id = msg->FindString("user_id");
|
|
|
|
// TODO: Contact validation, make sure permssion is granted
|
|
|
|
if (!invite_id)
|
|
return B_ERROR;
|
|
|
|
_ChatCreated(invite_id);
|
|
break;
|
|
}
|
|
|
|
case IM_JOIN_ROOM: {
|
|
BString chat_id = msg->FindString("chat_id");
|
|
BString join_id = chat_id;
|
|
join_id << "/" << fUsername;
|
|
|
|
gloox::MUCRoom* room =
|
|
new gloox::MUCRoom(fClient, gloox::JID(join_id.String()),
|
|
this, this);
|
|
room->join();
|
|
|
|
fRooms.AddItem(chat_id, room);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return B_ERROR;
|
|
}
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
status_t
|
|
JabberHandler::Shutdown()
|
|
{
|
|
if (fVCardManager)
|
|
fVCardManager->cancelVCardOperations(this);
|
|
|
|
if (fClient) {
|
|
fClient->disposeMessageSession(fSession);
|
|
fClient->disconnect();
|
|
}
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::SetAddOnPath(BPath path)
|
|
{
|
|
fPath = path;
|
|
}
|
|
|
|
|
|
BPath
|
|
JabberHandler::AddOnPath()
|
|
{
|
|
return fPath;
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::SetName(const char* name)
|
|
{
|
|
fName = name;
|
|
}
|
|
|
|
|
|
const char*
|
|
JabberHandler::GetName()
|
|
{
|
|
return fName.String();
|
|
}
|
|
|
|
|
|
status_t
|
|
JabberHandler::UpdateSettings(BMessage* msg)
|
|
{
|
|
const char* username = msg->FindString("username");
|
|
const char* password = msg->FindString("password");
|
|
const char* server = msg->FindString("server");
|
|
const char* resource = msg->FindString("resource");
|
|
|
|
// Sanity check
|
|
if (!username || !password || !resource)
|
|
return B_ERROR;
|
|
|
|
// Store settings
|
|
fUsername = username;
|
|
fPassword = password;
|
|
fServer = server;
|
|
fResource = resource;
|
|
fPort = 5222;
|
|
|
|
// Give the add-on a change to override settings
|
|
OverrideSettings();
|
|
|
|
// Compose JID
|
|
BString jid = ComposeJID();
|
|
fJid.setJID(jid.String());
|
|
|
|
// Register our client
|
|
fClient = new gloox::Client(fJid, fPassword.String());
|
|
fClient->setServer(fServer.String());
|
|
if (fPort > 0)
|
|
fClient->setPort(fPort);
|
|
fClient->registerConnectionListener(this);
|
|
fClient->registerMessageSessionHandler(this);
|
|
fClient->rosterManager()->registerRosterListener(this);
|
|
fClient->disco()->setVersion("Caya", VERSION);
|
|
fClient->disco()->setIdentity("client", "caya");
|
|
fClient->logInstance().registerLogHandler(gloox::LogLevelDebug,
|
|
gloox::LogAreaAll, this);
|
|
|
|
// Register vCard manager
|
|
fVCardManager = new gloox::VCardManager(fClient);
|
|
|
|
// Connect to the server
|
|
fClient->connect(false);
|
|
|
|
// Read data from another thread
|
|
fRecvThread = spawn_thread(connect_thread, "connect_thread",
|
|
B_NORMAL_PRIORITY, (void*)this);
|
|
if (fRecvThread < B_OK)
|
|
return B_ERROR;
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
uint32
|
|
JabberHandler::GetEncoding()
|
|
{
|
|
return 0xffff;
|
|
}
|
|
|
|
|
|
CayaProtocolMessengerInterface*
|
|
JabberHandler::MessengerInterface() const
|
|
{
|
|
return fServerMessenger;
|
|
}
|
|
|
|
|
|
gloox::Client*
|
|
JabberHandler::Client() const
|
|
{
|
|
return fClient;
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::HandleConnectionError(gloox::ConnectionError& e)
|
|
{
|
|
// Handle error
|
|
BMessage errMsg(IM_ERROR);
|
|
|
|
switch (e) {
|
|
case gloox::ConnStreamError:
|
|
{
|
|
gloox::StreamError streamError = fClient->streamError();
|
|
|
|
errMsg.AddString("error", "Bad or malformed XML stream.");
|
|
|
|
switch (streamError) {
|
|
case gloox::StreamErrorBadFormat:
|
|
errMsg.AddString("detail", "The entity has sent XML that "
|
|
"cannot be processed");
|
|
break;
|
|
case gloox::StreamErrorBadNamespacePrefix:
|
|
errMsg.AddString("detail", "The entity has sent a namespace "
|
|
"prefix which is not supported, or has sent no namespace "
|
|
"prefix on an element that requires such prefix.");
|
|
break;
|
|
case gloox::StreamErrorConflict:
|
|
errMsg.AddString("detail", "The server is closing the active "
|
|
"stream for this entity because a new stream has been "
|
|
"initiated that conflicts with the existing stream.");
|
|
break;
|
|
case gloox::StreamErrorConnectionTimeout:
|
|
errMsg.AddString("detail", "The entity has not generated any "
|
|
"traffic over the stream for some period of time.");
|
|
break;
|
|
case gloox::StreamErrorHostGone:
|
|
errMsg.AddString("detail", "The host initially used corresponds "
|
|
"to a hostname that is no longer hosted by the server.");
|
|
break;
|
|
case gloox::StreamErrorHostUnknown:
|
|
errMsg.AddString("detail", "The host initially used does not "
|
|
"correspond to a hostname that is hosted by the server.");
|
|
break;
|
|
case gloox::StreamErrorImproperAddressing:
|
|
errMsg.AddString("detail", "A stanza sent between two servers "
|
|
"lacks a 'to' or 'from' attribute (or the attribute has no "
|
|
"value.");
|
|
break;
|
|
case gloox::StreamErrorInternalServerError:
|
|
errMsg.AddString("detail", "The Server has experienced a "
|
|
"misconfiguration or an otherwise-undefined internal error "
|
|
"that prevents it from servicing the stream.");
|
|
break;
|
|
case gloox::StreamErrorInvalidFrom:
|
|
errMsg.AddString("detail", "The JID or hostname provided in a "
|
|
"'from' address does not match an authorized JID or validated "
|
|
"domain negotiation between servers via SASL or dialback, or "
|
|
"between a client and a server via authentication and resource "
|
|
"binding.");
|
|
break;
|
|
case gloox::StreamErrorInvalidId:
|
|
errMsg.AddString("detail", "The stream ID or dialback ID is invalid "
|
|
"or does not match and ID previously provdided.");
|
|
break;
|
|
case gloox::StreamErrorInvalidNamespace:
|
|
errMsg.AddString("detail", "The streams namespace name is something "
|
|
"other than \"http://etherx.jabber.org/streams\" or the dialback "
|
|
"namespace name is something other than \"jabber:server:dialback\".");
|
|
break;
|
|
case gloox::StreamErrorInvalidXml:
|
|
errMsg.AddString("detail", "The entity has sent invalid XML over the "
|
|
"stream to a server that performs validation.");
|
|
break;
|
|
case gloox::StreamErrorNotAuthorized:
|
|
errMsg.AddString("detail", "The entity has attempted to send data before "
|
|
"the stream has been authenticated, or otherwise is not authorized to "
|
|
"perform an action related to stream negotiation; the receiving entity "
|
|
"must not process the offending stanza before sending the stream error.");
|
|
break;
|
|
case gloox::StreamErrorPolicyViolation:
|
|
errMsg.AddString("detail", "The entity has violated some local service "
|
|
"policy; the server may choose to specify the policy in the <text/> "
|
|
"element or an application-specific condition element.");
|
|
break;
|
|
case gloox::StreamErrorRemoteConnectionFailed:
|
|
errMsg.AddString("detail", "The server is unable to properly connect to "
|
|
"a remote entit that is required for authentication.");
|
|
break;
|
|
case gloox::StreamErrorResourceConstraint:
|
|
errMsg.AddString("detail", "The server lacks the system resources necessary "
|
|
"to service the stream.");
|
|
break;
|
|
case gloox::StreamErrorRestrictedXml:
|
|
errMsg.AddString("detail", "The entity has attempted to send restricted XML "
|
|
"features such as a comment, processing instruction, DTD, entity reference "
|
|
"or unescaped character.");
|
|
break;
|
|
case gloox::StreamErrorSeeOtherHost:
|
|
errMsg.AddString("detail", "The server will not provide service to the initiating "
|
|
"entity but is redirecting traffic to another host; the server should specify "
|
|
"the alternate hostname or IP address (which MUST be a valid domain identifier) "
|
|
"as the XML characted data of the <see-other-host/> element.");
|
|
break;
|
|
case gloox::StreamErrorSystemShutdown:
|
|
errMsg.AddString("detail", "The server is being shut down and all active streams "
|
|
"are being closed.");
|
|
break;
|
|
case gloox::StreamErrorUndefinedCondition:
|
|
errMsg.AddString("detail", "The error condition is not one of those defined by the "
|
|
"other condition in this list; this error condition should be used only in "
|
|
"conjunction with an application-specific condition.");
|
|
break;
|
|
case gloox::StreamErrorUnsupportedEncoding:
|
|
errMsg.AddString("detail", "The initiating entity has encoded the stream in an "
|
|
"encoding that is not supported by the server.");
|
|
break;
|
|
case gloox::StreamErrorUnsupportedStanzaType:
|
|
errMsg.AddString("detail", "The initiating entity has sent a first-level child "
|
|
"of the stream that is not supported by the server.");
|
|
break;
|
|
case gloox::StreamErrorUnsupportedVersion:
|
|
errMsg.AddString("detail", "The value of the 'version' attribute provided by the "
|
|
"initiating entity in the stream header specifies a version of XMPP that is not "
|
|
"supported by the server; the server may specify the version(s) it supports in "
|
|
"the <text/> element.");
|
|
break;
|
|
case gloox::StreamErrorXmlNotWellFormed:
|
|
errMsg.AddString("detail", "The initiating entity has sent XML that is not "
|
|
"well-formed as defined by XML.");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case gloox::ConnStreamVersionError:
|
|
errMsg.AddString("detail", "The incoming stream's version is not "
|
|
"supported.");
|
|
break;
|
|
case gloox::ConnStreamClosed:
|
|
errMsg.AddString("detail", "The stream has been closed by the server.");
|
|
break;
|
|
case gloox::ConnProxyAuthRequired:
|
|
errMsg.AddString("detail", "The HTTP/SOCKS5 proxy requires authentication.");
|
|
break;
|
|
case gloox::ConnProxyAuthFailed:
|
|
errMsg.AddString("detail", "HTTP/SOCKS5 proxy authentication failed.");
|
|
break;
|
|
case gloox::ConnProxyNoSupportedAuth:
|
|
errMsg.AddString("detail", "The HTTP/SOCKS5 proxy requires an unsupported "
|
|
"authentication mechanism.");
|
|
break;
|
|
case gloox::ConnIoError:
|
|
errMsg.AddString("detail", "Input/output error.");
|
|
break;
|
|
case gloox::ConnParseError:
|
|
errMsg.AddString("detail", "A XML parse error occurred.");
|
|
break;
|
|
case gloox::ConnConnectionRefused:
|
|
errMsg.AddString("detail", "The connection was refused by the server "
|
|
"on the socket level.");
|
|
break;
|
|
case gloox::ConnDnsError:
|
|
errMsg.AddString("detail", "Server's hostname resolution failed.");
|
|
break;
|
|
case gloox::ConnOutOfMemory:
|
|
errMsg.AddString("detail", "Out of memory.");
|
|
break;
|
|
case gloox::ConnTlsFailed:
|
|
errMsg.AddString("detail", "The server's certificate could not be verified or "
|
|
"the TLS handshake did not complete successfully.");
|
|
break;
|
|
case gloox::ConnTlsNotAvailable:
|
|
errMsg.AddString("detail", "The server didn't offer TLS while it was set to be "
|
|
"required, or TLS was not compiled in.");
|
|
break;
|
|
case gloox::ConnCompressionFailed:
|
|
errMsg.AddString("detail", "Negotiating or initializing compression failed.");
|
|
break;
|
|
case gloox::ConnAuthenticationFailed:
|
|
{
|
|
gloox::AuthenticationError authError = fClient->authError();
|
|
|
|
errMsg.AddString("error", "Authentication failed. Username or password wrong "
|
|
"or account does not exist.");
|
|
|
|
switch (authError) {
|
|
case gloox::SaslAborted:
|
|
errMsg.AddString("detail", "The receiving entity acknowledges an <abort/> "
|
|
"element sent by initiating entity; sent in reply to the <abort/> "
|
|
"element.");
|
|
break;
|
|
case gloox::SaslIncorrectEncoding:
|
|
errMsg.AddString("detail", "The data provided by the initiating entity "
|
|
"could not be processed because the base64 encoding is incorrect.");
|
|
break;
|
|
case gloox::SaslInvalidAuthzid:
|
|
errMsg.AddString("detail", "The authid provided by the initiating entity "
|
|
"is invalid, either because it is incorrectly formatted or because "
|
|
"the initiating entity does not have permissions to authorize that ID; "
|
|
"sent in reply to a <response/> element or an <auth/> element with "
|
|
"initial response data.");
|
|
break;
|
|
case gloox::SaslInvalidMechanism:
|
|
errMsg.AddString("detail", "The initiating element did not provide a "
|
|
"mechanism or requested a mechanism that is not supported by the "
|
|
"receiving entity; sent in reply to an <auth/> element.");
|
|
break;
|
|
case gloox::SaslMalformedRequest:
|
|
errMsg.AddString("detail", "The request is malformed (e.g., the <auth/> "
|
|
"element includes an initial response but the mechanism does not "
|
|
"allow that); sent in reply to an <abort/>, <auth/>, <challenge/>, or "
|
|
"<response/> element.");
|
|
break;
|
|
case gloox::SaslMechanismTooWeak:
|
|
errMsg.AddString("detail", "The mechanism requested by the initiating entity "
|
|
"is weaker than server policy permits for that initiating entity; sent in "
|
|
"reply to a <response/> element or an <auth/> element with initial "
|
|
"response data.");
|
|
break;
|
|
case gloox::SaslNotAuthorized:
|
|
errMsg.AddString("detail", "The authentication failed because the initiating "
|
|
"entity did not provide valid credentials (this includes but is not "
|
|
"limited to the case of an unknown username); sent in reply to a "
|
|
"<response/> element or an <auth/> element with initial response data.");
|
|
break;
|
|
case gloox::SaslTemporaryAuthFailure:
|
|
errMsg.AddString("detail", "The authentication failed because of a temporary "
|
|
"error condition within the receiving entity; sent in reply to an "
|
|
"<auth/> element or <response/> element.");
|
|
break;
|
|
case gloox::NonSaslConflict:
|
|
errMsg.AddString("detail", "Resource conflict, see XEP-0078.");
|
|
break;
|
|
case gloox::NonSaslNotAcceptable:
|
|
errMsg.AddString("detail", "Required information not provided, "
|
|
"see XEP-0078.");
|
|
break;
|
|
case gloox::NonSaslNotAuthorized:
|
|
errMsg.AddString("detail", "Incorrect credentials.");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case gloox::ConnNotConnected:
|
|
errMsg.AddString("error", "There is no active connection.");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
_SendMessage(&errMsg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::HandleStanzaError(gloox::StanzaError error)
|
|
{
|
|
BMessage errMsg(IM_ERROR);
|
|
errMsg.AddString("error", "Stanza-related error");
|
|
BString detail;
|
|
|
|
switch (error)
|
|
{
|
|
case gloox::StanzaErrorBadRequest:
|
|
detail = "The sender has sent XML that is malformed or that cannot "
|
|
"be processed.";
|
|
break;
|
|
case gloox::StanzaErrorConflict:
|
|
detail = "Access cannot be granted because an existing resource or "
|
|
"session exists with the same name or address.";
|
|
break;
|
|
case gloox::StanzaErrorFeatureNotImplemented:
|
|
detail = "This feature hasn't been implemented by the recipient or "
|
|
"by the server.";
|
|
break;
|
|
case gloox::StanzaErrorForbidden:
|
|
detail = "You don't have permssion to do this.";
|
|
break;
|
|
case gloox::StanzaErrorGone:
|
|
detail = "The recipient or server can no longer be contacted at "
|
|
"this address. Try again later, or with a different address.";
|
|
break;
|
|
case gloox::StanzaErrorInternalServerError:
|
|
detail = "The server could not process the stanza because of a "
|
|
"misconfiguration or an otherwise-undefined internal server error.";
|
|
break;
|
|
case gloox::StanzaErrorItemNotFound:
|
|
detail = "The addressed JID or item requested cannot be found.";
|
|
break;
|
|
case gloox::StanzaErrorJidMalformed:
|
|
detail = "An invalid XMPP address or identifier was given. If you "
|
|
"can, please try a different one.";
|
|
break;
|
|
case gloox::StanzaErrorNotAcceptable:
|
|
detail = "The server or user refuses to accept this, because some "
|
|
"criteria hasn't been met (e.g., a local policy regarding "
|
|
"acceptable words in messages).";
|
|
break;
|
|
case gloox::StanzaErrorNotAllowed:
|
|
detail = "You aren't allowed to do this by the server or recepient.";
|
|
break;
|
|
case gloox::StanzaErrorNotAuthorized:
|
|
detail = "You need to be properily authenticated before doing this.";
|
|
case gloox::StanzaErrorNotModified:
|
|
detail = "The item requested has not changed since it was last "
|
|
"requested.";
|
|
case gloox::StanzaErrorPaymentRequired:
|
|
detail = "The server refuses to offer service, because payment is "
|
|
"required.";
|
|
break;
|
|
case gloox::StanzaErrorRecipientUnavailable:
|
|
detail = "The recipient is temporarily unavailable.";
|
|
break;
|
|
case gloox::StanzaErrorRedirect:
|
|
detail = "The recipient or server is redirecting requests for this "
|
|
"information to another entity, usually temporarily.";
|
|
break;
|
|
case gloox::StanzaErrorRegistrationRequired:
|
|
detail = "You can't do this before registration! Be sure your "
|
|
"finished registering for your account.";
|
|
break;
|
|
case gloox::StanzaErrorRemoteServerNotFound:
|
|
detail = "That user's server doesn't exist.";
|
|
break;
|
|
case gloox::StanzaErrorRemoteServerTimeout:
|
|
detail = "Connection to that user's server has timed out.";
|
|
break;
|
|
case gloox::StanzaErrorResourceConstraint:
|
|
detail = "The server or recipient are too busy right now; try "
|
|
"again later.";
|
|
break;
|
|
case gloox::StanzaErrorServiceUnavailable:
|
|
detail = "The server or recipient don't provide this service.";
|
|
break;
|
|
case gloox::StanzaErrorSubscribtionRequired:
|
|
detail = "You can't access this unless you are subscribed.";
|
|
break;
|
|
}
|
|
|
|
errMsg.AddString("detail", detail);
|
|
_SendMessage(&errMsg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::_SendMessage(BMessage* msg)
|
|
{
|
|
// Skip invalid messages
|
|
if (!msg)
|
|
return;
|
|
|
|
msg->AddString("protocol", Signature());
|
|
fServerMessenger->SendMessage(msg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::_Notify(notification_type type, const char* title, const char* message)
|
|
{
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_NOTIFICATION);
|
|
msg.AddInt32("type", (int32)type);
|
|
msg.AddString("title", title);
|
|
msg.AddString("message", message);
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::_NotifyProgress(const char* title, const char* message, float progress)
|
|
{
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_PROGRESS);
|
|
msg.AddString("title", title);
|
|
msg.AddString("message", message);
|
|
msg.AddFloat("progress", progress);
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::_MessageSent(const char* id, const char* subject,
|
|
const char* body)
|
|
{
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_MESSAGE_SENT);
|
|
msg.AddString("user_id", id);
|
|
msg.AddString("chat_id", id);
|
|
msg.AddString("subject", subject);
|
|
msg.AddString("body", body);
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::_ChatCreated(const char* id)
|
|
{
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_CHAT_CREATED);
|
|
msg.AddString("chat_id", id);
|
|
msg.AddString("user_id", id);
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
status_t
|
|
JabberHandler::_SetupAvatarCache()
|
|
{
|
|
if (fAvatarCachePath.InitCheck() == B_OK)
|
|
return B_OK;
|
|
|
|
BPath path;
|
|
|
|
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
|
|
return B_ERROR;
|
|
|
|
path.Append("Caya");
|
|
path.Append("Cache");
|
|
path.Append(Signature());
|
|
|
|
if (create_directory(path.Path(), 0755) != B_OK)
|
|
return B_ERROR;
|
|
|
|
fCachePath = path;
|
|
|
|
path.Append("avatar-cache");
|
|
|
|
BFile file(path.Path(), B_READ_ONLY);
|
|
fAvatarCache.Unflatten(&file);
|
|
|
|
fAvatarCachePath = path;
|
|
|
|
return B_OK;
|
|
}
|
|
|
|
|
|
status_t
|
|
JabberHandler::_SaveAvatarCache()
|
|
{
|
|
if (fAvatarCachePath.InitCheck() != B_OK)
|
|
return B_ERROR;
|
|
|
|
BFile file(fAvatarCachePath.Path(), B_CREATE_FILE | B_WRITE_ONLY | B_ERASE_FILE);
|
|
return fAvatarCache.Flatten(&file);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::_CacheAvatar(const char* id, const char* binimage, size_t length)
|
|
{
|
|
if (!id || !binimage || length <= 0)
|
|
return;
|
|
|
|
// Calculate avatar hash
|
|
CSHA1 s1;
|
|
char hash[256];
|
|
s1.Reset();
|
|
s1.Update((uchar*)binimage, length);
|
|
s1.Final();
|
|
s1.ReportHash(hash, CSHA1::REPORT_HEX);
|
|
|
|
BString sha1;
|
|
sha1.SetTo(hash, 256);
|
|
|
|
BString oldSha1;
|
|
if (fAvatarCache.FindString(id, &oldSha1) != B_OK || oldSha1 == "" || sha1 != oldSha1) {
|
|
// Replace old hash and save cache
|
|
fAvatarCache.RemoveName(id);
|
|
fAvatarCache.AddString(id, sha1);
|
|
_SaveAvatarCache();
|
|
|
|
if (oldSha1 != "") {
|
|
BPath path(fCachePath);
|
|
path.Append(oldSha1);
|
|
|
|
// Remove old image file
|
|
BEntry entry(path.Path());
|
|
entry.Remove();
|
|
|
|
// Remove old hash from the list
|
|
BString* item = NULL;
|
|
for (int32 i = 0; (item = (BString*)fAvatars->ItemAt(i)); i++) {
|
|
if (item->Compare(oldSha1) == 0) {
|
|
fAvatars->RemoveItem(item);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Determine file path
|
|
BPath path(fCachePath);
|
|
path.Append(sha1);
|
|
|
|
BEntry entry(path.Path());
|
|
if (!entry.Exists()) {
|
|
// Save to file
|
|
BFile file(path.Path(), B_CREATE_FILE | B_WRITE_ONLY | B_ERASE_FILE);
|
|
file.Write(binimage, length);
|
|
}
|
|
|
|
// Do we need to notify Caya?
|
|
bool found = false;
|
|
BString* item = NULL;
|
|
for (int32 i = 0; (item = (BString*)fAvatars->ItemAt(i)); i++) {
|
|
if (item->Compare(sha1) == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
// Add new hash to the list if needed
|
|
fAvatars->AddItem(new BString(sha1));
|
|
|
|
// Notify Caya that the avatar has changed
|
|
_AvatarChanged(id, path.Path());
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::_AvatarChanged(const char* id, const char* filename)
|
|
{
|
|
entry_ref ref;
|
|
if (get_ref_for_path(filename, &ref) != B_OK)
|
|
return;
|
|
|
|
BMessage msg(IM_MESSAGE);
|
|
if (fJid.bare() == id)
|
|
msg.AddInt32("im_what", IM_OWN_AVATAR_SET);
|
|
else {
|
|
msg.AddInt32("im_what", IM_AVATAR_SET);
|
|
msg.AddString("user_id", id);
|
|
}
|
|
msg.AddRef("ref", &ref);
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
CayaStatus
|
|
JabberHandler::_GlooxStatusToCaya(gloox::Presence::PresenceType type)
|
|
{
|
|
switch (type) {
|
|
case gloox::Presence::Available:
|
|
case gloox::Presence::Chat:
|
|
return CAYA_ONLINE;
|
|
case gloox::Presence::Away:
|
|
return CAYA_AWAY;
|
|
case gloox::Presence::XA:
|
|
return CAYA_CUSTOM_STATUS;
|
|
case gloox::Presence::DND:
|
|
return CAYA_DO_NOT_DISTURB;
|
|
case gloox::Presence::Unavailable:
|
|
return CAYA_OFFLINE;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return CAYA_OFFLINE;
|
|
}
|
|
|
|
|
|
BMessage
|
|
JabberHandler::_SettingsTemplate(const char* username, bool serverOption)
|
|
{
|
|
BMessage stemplate('IMst');
|
|
|
|
BMessage usernameText;
|
|
usernameText.AddString("name", "username");
|
|
usernameText.AddString("description", username);
|
|
usernameText.AddInt32("type", 'CSTR');
|
|
stemplate.AddMessage("setting", &usernameText);
|
|
|
|
BMessage passwordText;
|
|
passwordText.AddString("name", "password");
|
|
passwordText.AddString("description", "Password");
|
|
passwordText.AddInt32("type", 'CSTR');
|
|
passwordText.AddBool("is_secret", true);
|
|
stemplate.AddMessage("setting", &passwordText);
|
|
|
|
BMessage serverText;
|
|
serverText.AddString("name", "server");
|
|
serverText.AddString("description", "Server");
|
|
serverText.AddInt32("type", 'CSTR');
|
|
if (serverOption == true)
|
|
stemplate.AddMessage("setting", &serverText);
|
|
|
|
BMessage resourceText;
|
|
resourceText.AddString("name", "resource");
|
|
resourceText.AddString("description", "Resource");
|
|
resourceText.AddInt32("type", 'CSTR');
|
|
resourceText.AddString("default", "Caya");
|
|
stemplate.AddMessage("setting", &resourceText);
|
|
|
|
return stemplate;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* gloox callbacks
|
|
**********************************************************************/
|
|
|
|
|
|
void
|
|
JabberHandler::onConnect()
|
|
{
|
|
// We are online
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_OWN_STATUS_SET);
|
|
msg.AddInt32("status", CAYA_ONLINE);
|
|
_SendMessage(&msg);
|
|
|
|
// Notify our online status
|
|
BString content(fUsername);
|
|
content << " has logged in!";
|
|
_Notify(B_INFORMATION_NOTIFICATION, "Connected",
|
|
content.String());
|
|
|
|
fVCardManager->fetchVCard(fJid, this);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::onDisconnect(gloox::ConnectionError e)
|
|
{
|
|
// We are offline
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_OWN_STATUS_SET);
|
|
msg.AddInt32("status", CAYA_OFFLINE);
|
|
_SendMessage(&msg);
|
|
|
|
if (e == gloox::ConnNoError) {
|
|
// Notify our offline status
|
|
BString content(fUsername);
|
|
content << " has logged out!";
|
|
_Notify(B_INFORMATION_NOTIFICATION, "Disconnected",
|
|
content.String());
|
|
return;
|
|
}
|
|
|
|
// Handle error
|
|
HandleConnectionError(e);
|
|
}
|
|
|
|
|
|
bool
|
|
JabberHandler::onTLSConnect(const gloox::CertInfo& info)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::onResourceBindError(const gloox::Error* error)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleRoster(const gloox::Roster& roster)
|
|
{
|
|
std::list<BMessage> msgs;
|
|
|
|
BMessage contactListMsg(IM_MESSAGE);
|
|
contactListMsg.AddInt32("im_what", IM_CONTACT_LIST);
|
|
|
|
gloox::Roster::const_iterator it = roster.begin();
|
|
for (; it != roster.end(); ++it) {
|
|
const char* jid = (*it).second->jidJID().full().c_str();
|
|
const char* name = (*it).second->name().c_str();
|
|
int32 subscription = (*it).second->subscription();
|
|
|
|
// Add jid to the server based contact list message
|
|
contactListMsg.AddString("user_id", jid);
|
|
|
|
// Contact information message
|
|
BMessage infoMsg(IM_MESSAGE);
|
|
infoMsg.AddInt32("im_what", IM_CONTACT_INFO);
|
|
infoMsg.AddString("user_id", jid);
|
|
infoMsg.AddString("name", name);
|
|
infoMsg.AddInt32("subscription", subscription);
|
|
infoMsg.AddInt32("status", CAYA_OFFLINE);
|
|
|
|
// Groups
|
|
gloox::StringList g = (*it).second->groups();
|
|
gloox::StringList::const_iterator it_g = g.begin();
|
|
for (; it_g != g.end(); ++it_g)
|
|
infoMsg.AddString("group", (*it_g).c_str());
|
|
|
|
// Resources
|
|
gloox::RosterItem::ResourceMap::const_iterator rit
|
|
= (*it).second->resources().begin();
|
|
for (; rit != (*it).second->resources().end(); ++rit)
|
|
infoMsg.AddString("resource", (*rit).first.c_str());
|
|
|
|
// Store contact info message to be sent later
|
|
msgs.push_back(infoMsg);
|
|
}
|
|
|
|
// Send server based contact list
|
|
_SendMessage(&contactListMsg);
|
|
|
|
// Contact list and vCard request
|
|
std::list<BMessage>::iterator msgsIt;
|
|
for (msgsIt = msgs.begin(); msgsIt != msgs.end(); ++msgsIt) {
|
|
BMessage msg = (*msgsIt);
|
|
const char* jid = msg.FindString("user_id");
|
|
_SendMessage(&msg);
|
|
fVCardManager->fetchVCard(gloox::JID(jid), this);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMessageSession(gloox::MessageSession* session)
|
|
{
|
|
// Delete previous session
|
|
if (fSession)
|
|
fClient->disposeMessageSession(fSession);
|
|
fSession = session;
|
|
|
|
// Register message handler
|
|
fSession->registerMessageHandler(this);
|
|
|
|
// Message event filter
|
|
gloox::MessageEventFilter* messageFilter
|
|
= new gloox::MessageEventFilter(fSession);
|
|
messageFilter->registerMessageEventHandler(this);
|
|
|
|
// Chat state filter
|
|
gloox::ChatStateFilter* chatFilter
|
|
= new gloox::ChatStateFilter(fSession);
|
|
chatFilter->registerChatStateHandler(this);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMessage(const gloox::Message& m, gloox::MessageSession*)
|
|
{
|
|
// Only chat messages are handled now
|
|
if (m.subtype() != gloox::Message::Chat)
|
|
return;
|
|
|
|
// We need a body
|
|
if (m.body() == "")
|
|
return;
|
|
|
|
// Notify that a chat message was received
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddString("user_id", m.from().bare().c_str());
|
|
msg.AddString("chat_id", m.from().bare().c_str());
|
|
msg.AddInt32("im_what", IM_MESSAGE_RECEIVED);
|
|
if (m.subject() != "")
|
|
msg.AddString("subject", m.subject().c_str());
|
|
msg.AddString("body", m.body().c_str());
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMessageEvent(const gloox::JID& from, gloox::MessageEventType event)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleChatState(const gloox::JID& from, gloox::ChatStateType state)
|
|
{
|
|
printf("------ %d\n", state);
|
|
// We're interested only in some states
|
|
if (state == gloox::ChatStateActive || state == gloox::ChatStateInvalid)
|
|
return;
|
|
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddString("user_id", from.bare().c_str());
|
|
msg.AddString("chat_id", from.bare().c_str());
|
|
|
|
switch (state) {
|
|
case gloox::ChatStateComposing:
|
|
msg.AddInt32("im_what", IM_CONTACT_STARTED_TYPING);
|
|
break;
|
|
case gloox::ChatStatePaused:
|
|
msg.AddInt32("im_what", IM_CONTACT_STOPPED_TYPING);
|
|
break;
|
|
case gloox::ChatStateGone:
|
|
// TODO
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCParticipantPresence(gloox::MUCRoom *room,
|
|
const gloox::MUCRoomParticipant participant,
|
|
const gloox::Presence &presence)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCMessage(gloox::MUCRoom *room, const gloox::Message &m,
|
|
bool priv)
|
|
{
|
|
// We need a body
|
|
if (m.body() == "")
|
|
return;
|
|
|
|
BString chat_id(room->name().c_str());
|
|
chat_id << "@" << room->service().c_str();
|
|
|
|
// Notify that a chat message was received
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddString("user_id", m.from().resource().c_str());
|
|
msg.AddString("chat_id", chat_id);
|
|
msg.AddInt32("im_what", IM_MESSAGE_RECEIVED);
|
|
if (m.subject() != "")
|
|
msg.AddString("subject", m.subject().c_str());
|
|
msg.AddString("body", m.body().c_str());
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
bool
|
|
JabberHandler::handleMUCRoomCreation(gloox::MUCRoom *room)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCSubject(gloox::MUCRoom *room, const std::string &nick,
|
|
const std::string &subject)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCInviteDecline(gloox::MUCRoom *room, const gloox::JID &invitee,
|
|
const std::string &reason)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCError(gloox::MUCRoom *room, gloox::StanzaError error)
|
|
{
|
|
HandleStanzaError(error);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCInfo(gloox::MUCRoom *room, int features,
|
|
const std::string &name, const gloox::DataForm *infoForm)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCItems(gloox::MUCRoom *room, const gloox::Disco::ItemList &items)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCConfigList(gloox::MUCRoom* room, const gloox::MUCListItemList &items,
|
|
gloox::MUCOperation operation)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCConfigForm(gloox::MUCRoom* room, const gloox::DataForm &form)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCConfigResult(gloox::MUCRoom* room, bool success,
|
|
gloox::MUCOperation operation)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleMUCRequest(gloox::MUCRoom* room, const gloox::DataForm &form)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleItemAdded(const gloox::JID&)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleItemSubscribed(const gloox::JID&)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleItemUnsubscribed(const gloox::JID&)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleItemRemoved(const gloox::JID&)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleItemUpdated(const gloox::JID&)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleRosterPresence(const gloox::RosterItem& item,
|
|
const std::string& resource,
|
|
gloox::Presence::PresenceType type,
|
|
const std::string& presenceMsg)
|
|
{
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_STATUS_SET);
|
|
msg.AddString("user_id", item.jidJID().full().c_str());
|
|
msg.AddInt32("status", _GlooxStatusToCaya(type));
|
|
msg.AddString("resource", resource.c_str());
|
|
msg.AddString("message", presenceMsg.c_str());
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleSelfPresence(const gloox::RosterItem& item, const std::string&,
|
|
gloox::Presence::PresenceType type,
|
|
const std::string& presenceMsg)
|
|
{
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_OWN_CONTACT_INFO);
|
|
msg.AddString("protocol", Signature());
|
|
msg.AddString("user_id", item.jidJID().full().c_str());
|
|
msg.AddString("name", item.name().c_str());
|
|
msg.AddInt32("subscription", item.subscription());
|
|
msg.AddInt32("status", _GlooxStatusToCaya(type));
|
|
msg.AddString("message", presenceMsg.c_str());
|
|
|
|
// Groups
|
|
gloox::StringList g = item.groups();
|
|
gloox::StringList::const_iterator it_g = g.begin();
|
|
for (; it_g != g.end(); ++it_g)
|
|
msg.AddString("group", (*it_g).c_str());
|
|
|
|
// Resources
|
|
gloox::RosterItem::ResourceMap::const_iterator rit
|
|
= item.resources().begin();
|
|
for (; rit != item.resources().end(); ++rit)
|
|
msg.AddString("resource", (*rit).first.c_str());
|
|
|
|
_SendMessage(&msg);
|
|
}
|
|
|
|
|
|
bool
|
|
JabberHandler::handleSubscriptionRequest(const gloox::JID&, const std::string&)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
bool
|
|
JabberHandler::handleUnsubscriptionRequest(const gloox::JID&, const std::string&)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleNonrosterPresence(const gloox::Presence&)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleRosterError(const gloox::IQ&)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleLog(gloox::LogLevel level, gloox::LogArea,
|
|
const std::string& msg)
|
|
{
|
|
if (level >= gloox::LogLevelWarning)
|
|
printf("%s\n", msg.c_str());
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleVCard(const gloox::JID& jid, const gloox::VCard* card)
|
|
{
|
|
if (!card)
|
|
return;
|
|
|
|
gloox::VCard::Name name = card->name();
|
|
gloox::VCard::Photo photo = card->photo();
|
|
|
|
std::string fullName = name.family + " " + name.given;
|
|
|
|
BMessage msg(IM_MESSAGE);
|
|
msg.AddInt32("im_what", IM_EXTENDED_CONTACT_INFO);
|
|
msg.AddString("user_id", jid.bare().c_str());
|
|
msg.AddString("nick", card->nickname().c_str());
|
|
msg.AddString("family name", name.family.c_str());
|
|
msg.AddString("given name", name.given.c_str());
|
|
msg.AddString("middle name", name.middle.c_str());
|
|
msg.AddString("prefix", name.prefix.c_str());
|
|
msg.AddString("suffix", name.suffix.c_str());
|
|
msg.AddString("full name", fullName.c_str());
|
|
_SendMessage(&msg);
|
|
|
|
// Return if there's no avatar icon
|
|
if (!photo.binval.c_str())
|
|
return;
|
|
|
|
if (_SetupAvatarCache() == B_OK)
|
|
// Cache avatar icon and notify the change
|
|
_CacheAvatar(jid.bare().c_str(), photo.binval.c_str(),
|
|
photo.binval.length());
|
|
}
|
|
|
|
|
|
void
|
|
JabberHandler::handleVCardResult(gloox::VCardHandler::VCardContext context,
|
|
const gloox::JID& jid,
|
|
gloox::StanzaError)
|
|
{
|
|
//if (context == gloox::VCardHandler::FetchVCard)
|
|
//else
|
|
}
|