You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
966 lines
29 KiB
966 lines
29 KiB
/*
|
|
meanwhilesession.cpp - interface to the 'C' meanwhile library
|
|
|
|
Copyright (c) 2003-2004 by Sivaram Gottimukkala <suppandi@gmail.com>
|
|
Copyright (c) 2005 by Jeremy Kerr <jk@ozlabs.org>
|
|
|
|
Kopete (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>
|
|
|
|
*************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
*************************************************************************
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <kmessagebox.h>
|
|
#include <klocale.h>
|
|
|
|
#include <kopetepassword.h>
|
|
#include <kopetechatsession.h>
|
|
#include <kopetegroup.h>
|
|
#include <kopetecontactlist.h>
|
|
#include "meanwhilesession.h"
|
|
#include "meanwhileprotocol.h"
|
|
|
|
#include <mw_channel.h>
|
|
#include <mw_message.h>
|
|
#include <mw_error.h>
|
|
#include <mw_service.h>
|
|
#include <mw_session.h>
|
|
#include <mw_srvc_aware.h>
|
|
#include <mw_srvc_conf.h>
|
|
#include <mw_srvc_im.h>
|
|
#include <mw_srvc_store.h>
|
|
#include <mw_cipher.h>
|
|
#include <mw_st_list.h>
|
|
|
|
#define set_session_handler(a,b) sessionHandler.a = _handleSession ## b
|
|
#define set_aware_handler(a,b) awareHandler.a = _handleAware ## b
|
|
#define set_aware_list_handler(a,b) \
|
|
awareListHandler.a = _handleAwareList ## b
|
|
#define set_im_handler(a,b) imHandler.a = _handleIm ## b
|
|
|
|
#define get_protocol() (static_cast<MeanwhileProtocol *>(account->protocol()))
|
|
|
|
static struct MeanwhileClientID ids[] = {
|
|
{ mwLogin_LIB, "Lotus Binary Library" },
|
|
{ mwLogin_JAVA_WEB, "Lotus Java Applet", },
|
|
{ mwLogin_BINARY, "Lotus Binary App", },
|
|
{ mwLogin_JAVA_APP, "Lotus Java App", },
|
|
{ mwLogin_LINKS, "Sametime Links", },
|
|
|
|
{ mwLogin_NOTES_6_5, "Notes 6.5", },
|
|
{ mwLogin_NOTES_6_5_3, "Notes 6.5.3", },
|
|
{ mwLogin_NOTES_7_0_beta, "Notes 7.0 beta", },
|
|
{ mwLogin_NOTES_7_0, "Notes 7.0", },
|
|
{ mwLogin_ICT, "ICT", },
|
|
{ mwLogin_ICT_1_7_8_2, "ICT 1.7.8.2", },
|
|
{ mwLogin_ICT_SIP, "ICT SIP", },
|
|
{ mwLogin_NOTESBUDDY_4_14, "NotesBuddy 4.14", },
|
|
{ mwLogin_NOTESBUDDY_4_15, "NotesBuddy 4.15" },
|
|
{ mwLogin_NOTESBUDDY_4_16, "NotesBuddy 4.16" },
|
|
{ mwLogin_SANITY, "Sanity", },
|
|
{ mwLogin_ST_PERL, "ST Perl", },
|
|
{ mwLogin_PMR_ALERT, "PMR Alert", },
|
|
{ mwLogin_TRILLIAN, "Trillian", },
|
|
{ mwLogin_TRILLIAN_IBM, "Trillian (IBM)", },
|
|
{ mwLogin_MEANWHILE, "Meanwhile Library", },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
MeanwhileSession::MeanwhileSession(MeanwhileAccount *account)
|
|
{
|
|
HERE;
|
|
this->account = account;
|
|
session = 0L;
|
|
socket = 0L;
|
|
state = mwSession_STOPPED;
|
|
|
|
/* set up main session hander */
|
|
memset(&sessionHandler, 0, sizeof(sessionHandler));
|
|
set_session_handler(io_write, IOWrite);
|
|
set_session_handler(io_close, IOClose);
|
|
set_session_handler(on_stateChange, StateChange);
|
|
set_session_handler(on_setPrivacyInfo, SetPrivacyInfo);
|
|
set_session_handler(on_setUserStatus, SetUserStatus);
|
|
set_session_handler(on_admin, Admin);
|
|
set_session_handler(on_announce, Announce);
|
|
set_session_handler(clear, Clear);
|
|
|
|
session = mwSession_new(&sessionHandler);
|
|
mwSession_setClientData(session, this, 0L);
|
|
|
|
/* set up the aware service */
|
|
memset(&awareHandler, 0, sizeof(awareHandler));
|
|
set_aware_handler(on_attrib, Attrib);
|
|
|
|
awareService = mwServiceAware_new(session, &awareHandler);
|
|
mwSession_addService(session, (struct mwService *)awareService);
|
|
|
|
/* create an aware list */
|
|
memset(&awareListHandler, 0, sizeof(awareListHandler));
|
|
set_aware_list_handler(on_aware, Aware);
|
|
set_aware_list_handler(on_attrib, Attrib);
|
|
awareList = mwAwareList_new(awareService, &awareListHandler);
|
|
mwAwareList_setClientData(awareList, this, 0L);
|
|
|
|
/* set up an im service */
|
|
memset(&imHandler, 0, sizeof(imHandler));
|
|
set_im_handler(conversation_opened, ConvOpened);
|
|
set_im_handler(conversation_closed, ConvClosed);
|
|
set_im_handler(conversation_recv, ConvReceived);
|
|
imHandler.place_invite = 0L;
|
|
imHandler.clear = 0L;
|
|
|
|
imService = mwServiceIm_new(session, &imHandler);
|
|
mwService_setClientData((struct mwService *)imService, this, 0L);
|
|
mwSession_addService(session, (struct mwService *) imService);
|
|
|
|
/* add resolve service */
|
|
resolveService = mwServiceResolve_new(session);
|
|
mwService_setClientData((struct mwService *)resolveService, this, 0L);
|
|
mwSession_addService(session, (struct mwService *) resolveService);
|
|
|
|
/* storage service */
|
|
storageService = mwServiceStorage_new(session);
|
|
mwService_setClientData((struct mwService *)storageService, this, 0L);
|
|
mwSession_addService(session, (struct mwService *) storageService);
|
|
|
|
#if 0
|
|
/* conference service setup - just declines invites for now. */
|
|
memset(&conf_handler, 0, sizeof(conf_handler));
|
|
conf_handler.on_invited = _conference_invite;
|
|
|
|
srvc_conf = mwServiceConference_new(session, &conf_handler);
|
|
mwService_setClientData((struct mwService *)srvc_conf, this, 0L);
|
|
mwSession_addService(session, (struct mwService *) srvc_conf);
|
|
#endif
|
|
|
|
/* add a necessary cipher */
|
|
mwSession_addCipher(session, mwCipher_new_RC2_40(session));
|
|
mwSession_addCipher(session, mwCipher_new_RC2_128(session));
|
|
}
|
|
|
|
MeanwhileSession::~MeanwhileSession()
|
|
{
|
|
HERE;
|
|
if (isConnected() || isConnecting())
|
|
disconnect();
|
|
|
|
mwSession_removeService(session, mwService_STORAGE);
|
|
mwSession_removeService(session, mwService_RESOLVE);
|
|
mwSession_removeService(session, mwService_IM);
|
|
mwSession_removeService(session, mwService_AWARE);
|
|
|
|
mwAwareList_free(awareList);
|
|
mwService_free(MW_SERVICE(storageService));
|
|
mwService_free(MW_SERVICE(resolveService));
|
|
mwService_free(MW_SERVICE(imService));
|
|
mwService_free(MW_SERVICE(awareService));
|
|
mwCipher_free(mwSession_getCipher(session, mwCipher_RC2_40));
|
|
mwCipher_free(mwSession_getCipher(session, mwCipher_RC2_128));
|
|
|
|
mwSession_free(session);
|
|
|
|
if (socket)
|
|
delete socket;
|
|
}
|
|
|
|
void MeanwhileSession::getDefaultClientIDParams(int *clientID,
|
|
int *verMajor, int *verMinor)
|
|
{
|
|
*clientID = mwLogin_MEANWHILE;
|
|
*verMajor = MW_PROTOCOL_VERSION_MAJOR;
|
|
*verMinor = MW_PROTOCOL_VERSION_MINOR;
|
|
}
|
|
|
|
/* external interface called by meanwhileaccount */
|
|
void MeanwhileSession::connect(TQString password)
|
|
{
|
|
int port, clientID, versionMajor, versionMinor;
|
|
bool useCustomID;
|
|
TQString host;
|
|
|
|
HERE;
|
|
|
|
host = account->getServerName();
|
|
port = account->getServerPort();
|
|
useCustomID = account->getClientIDParams(&clientID,
|
|
&versionMajor, &versionMinor);
|
|
|
|
KExtendedSocket *sock = new KExtendedSocket(host, port,
|
|
KExtendedSocket::bufferedSocket);
|
|
|
|
if (sock->connect()) {
|
|
KMessageBox::queuedMessageBox(0, KMessageBox::Error,
|
|
i18n( "Could not connect to server"), i18n("Meanwhile Plugin"),
|
|
KMessageBox::Notify);
|
|
delete sock;
|
|
return;
|
|
}
|
|
socket = sock;
|
|
/* we want to receive signals when there is data to read */
|
|
sock->enableRead(true);
|
|
TQObject::connect(sock, TQT_SIGNAL(readyRead()), this,
|
|
TQT_SLOT(slotSocketDataAvailable()));
|
|
TQObject::connect(sock, TQT_SIGNAL(closed(int)), this,
|
|
TQT_SLOT(slotSocketClosed(int)));
|
|
|
|
/* set login details */
|
|
mwSession_setProperty(session, mwSession_AUTH_USER_ID,
|
|
g_strdup(account->meanwhileId().ascii()), g_free);
|
|
mwSession_setProperty(session, mwSession_AUTH_PASSWORD,
|
|
g_strdup(password.ascii()), g_free);
|
|
|
|
/* set client type parameters */
|
|
if (useCustomID) {
|
|
mwSession_setProperty(session, mwSession_CLIENT_TYPE_ID,
|
|
GUINT_TO_POINTER(clientID), NULL);
|
|
mwSession_setProperty(session, mwSession_CLIENT_VER_MAJOR,
|
|
GUINT_TO_POINTER(versionMajor), NULL);
|
|
mwSession_setProperty(session, mwSession_CLIENT_VER_MINOR,
|
|
GUINT_TO_POINTER(versionMinor), NULL);
|
|
}
|
|
|
|
mwDebug() << "ids: "
|
|
<< mwSession_getProperty(session, mwSession_CLIENT_TYPE_ID) << " v"
|
|
<< mwSession_getProperty(session, mwSession_CLIENT_VER_MAJOR) << "."
|
|
<< mwSession_getProperty(session, mwSession_CLIENT_VER_MINOR) <<
|
|
endl;
|
|
|
|
/* go!! */
|
|
mwSession_start(session);
|
|
}
|
|
|
|
void MeanwhileSession::disconnect()
|
|
{
|
|
HERE;
|
|
if (state == mwSession_STOPPED || state == mwSession_STOPPING)
|
|
return;
|
|
|
|
mwSession_stop(session, ERR_SUCCESS);
|
|
}
|
|
|
|
bool MeanwhileSession::isConnected()
|
|
{
|
|
return mwSession_isStarted(session);
|
|
}
|
|
|
|
bool MeanwhileSession::isConnecting()
|
|
{
|
|
return mwSession_isStarting(session);
|
|
}
|
|
|
|
static void free_id_block(void *data, void *p)
|
|
{
|
|
if (p != 0L || data == 0L)
|
|
return;
|
|
struct mwAwareIdBlock *id = (struct mwAwareIdBlock *)data;
|
|
free(id->user);
|
|
free(id);
|
|
}
|
|
|
|
void MeanwhileSession::addContacts(const TQDict<Kopete::Contact>& contacts)
|
|
{
|
|
HERE;
|
|
TQDictIterator<Kopete::Contact> it(contacts);
|
|
GList *buddies = 0L;
|
|
|
|
/** Convert our TQDict of kopete contact to a GList of meanwhile buddies */
|
|
for( ; it.current(); ++it) {
|
|
MeanwhileContact *contact =
|
|
static_cast<MeanwhileContact *>(it.current());
|
|
struct mwAwareIdBlock *id = (struct mwAwareIdBlock *)
|
|
malloc(sizeof(*id));
|
|
if (id == 0L)
|
|
continue;
|
|
id->user = strdup(contact->meanwhileId().ascii());
|
|
id->community = 0L;
|
|
id->type = mwAware_USER;
|
|
buddies = g_list_append(buddies, id);
|
|
}
|
|
|
|
mwAwareList_addAware(awareList, buddies);
|
|
|
|
g_list_foreach(buddies, free_id_block, 0L);
|
|
g_list_free(buddies);
|
|
}
|
|
|
|
/* private functions used only by the meanwhile session object */
|
|
void MeanwhileSession::addContact(const Kopete::Contact *contact)
|
|
{
|
|
HERE;
|
|
struct mwAwareIdBlock id = { mwAware_USER,
|
|
strdup(static_cast<const MeanwhileContact *>(contact)
|
|
->meanwhileId().ascii()),
|
|
0L };
|
|
|
|
GList *buddies = g_list_prepend(0L, &id);
|
|
mwAwareList_addAware(awareList, buddies);
|
|
g_list_free(buddies);
|
|
free(id.user);
|
|
}
|
|
|
|
int MeanwhileSession::sendMessage(Kopete::Message &message)
|
|
{
|
|
HERE;
|
|
MeanwhileContact *contact =
|
|
static_cast<MeanwhileContact *>(message.to().first());
|
|
if (!contact) {
|
|
mwDebug() << "No target for message!" <<endl;
|
|
return 0;
|
|
}
|
|
|
|
struct mwIdBlock target = { strdup(contact->meanwhileId().ascii()), 0L };
|
|
struct mwConversation *conv;
|
|
|
|
conv = mwServiceIm_getConversation(imService, &target);
|
|
free(target.user);
|
|
if (conv == 0L) {
|
|
mwDebug() << "No target for conversation with '"
|
|
<< contact->meanwhileId() << "'" << endl;
|
|
return 0;
|
|
}
|
|
|
|
struct ConversationData *convdata = (struct ConversationData *)
|
|
mwConversation_getClientData(conv);
|
|
|
|
if (convdata == 0L) {
|
|
convdata = createConversationData(conv, contact, true);
|
|
if (convdata == 0L) {
|
|
mwDebug() << "No memory for conversation data!" << endl;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* if there's other messages in the queue, or the conversation isn't open,
|
|
* then append to the queue instead of sending right away */
|
|
if ((convdata->queue && !convdata->queue->isEmpty()) ||
|
|
!mwConversation_isOpen(conv)) {
|
|
convdata->queue->append(message);
|
|
mwConversation_open(conv);
|
|
|
|
} else if (!mwConversation_send(conv, mwImSend_PLAIN,
|
|
message.plainBody().ascii())) {
|
|
convdata->chat->appendMessage(message);
|
|
convdata->chat->messageSucceeded();
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void MeanwhileSession::sendTyping(MeanwhileContact *contact, bool isTyping)
|
|
{
|
|
HERE;
|
|
struct mwIdBlock target = { strdup(contact->meanwhileId().ascii()), 0L };
|
|
struct mwConversation *conv;
|
|
|
|
conv = mwServiceIm_getConversation(imService, &target);
|
|
free(target.user);
|
|
if (conv == 0L)
|
|
return;
|
|
|
|
if (mwConversation_isOpen(conv))
|
|
mwConversation_send(conv, mwImSend_TYPING, (void *)isTyping);
|
|
}
|
|
|
|
void MeanwhileSession::setStatus(Kopete::OnlineStatus status,
|
|
const TQString msg)
|
|
{
|
|
HERE;
|
|
mwDebug() << "setStatus: " << status.description() << "("
|
|
<< status.internalStatus() << ")" << endl;
|
|
if (status.internalStatus() == 0)
|
|
return;
|
|
|
|
struct mwUserStatus stat;
|
|
mwUserStatus_clone(&stat, mwSession_getUserStatus(session));
|
|
|
|
free(stat.desc);
|
|
|
|
stat.status = (mwStatusType)status.internalStatus();
|
|
if (msg.isNull() || msg.isEmpty())
|
|
stat.desc = strdup(status.description().ascii());
|
|
else
|
|
stat.desc = strdup(msg.ascii());
|
|
|
|
mwSession_setUserStatus(session, &stat);
|
|
/* will free stat.desc */
|
|
mwUserStatus_clear(&stat);
|
|
}
|
|
|
|
void MeanwhileSession::syncContactsToServer()
|
|
{
|
|
HERE;
|
|
struct mwSametimeList *list = mwSametimeList_new();
|
|
|
|
/* set up a fallback group for top-level contacts */
|
|
struct mwSametimeGroup *topstgroup = mwSametimeGroup_new(list,
|
|
mwSametimeGroup_DYNAMIC, "People");
|
|
mwSametimeGroup_setOpen(topstgroup, true);
|
|
|
|
TQDictIterator<Kopete::Contact> it(account->contacts());
|
|
for( ; it.current(); ++it ) {
|
|
MeanwhileContact *contact =
|
|
static_cast<MeanwhileContact *>(it.current());
|
|
|
|
/* Find the group that the metacontact is in */
|
|
Kopete::MetaContact *mc = contact->metaContact();
|
|
/* myself doesn't have a metacontact */
|
|
if (mc == 0L)
|
|
continue;
|
|
|
|
Kopete::Group *contactgroup = mc->groups().getFirst();
|
|
if (contactgroup == 0L)
|
|
continue;
|
|
|
|
if (contactgroup->type() == Kopete::Group::Temporary)
|
|
continue;
|
|
|
|
struct mwSametimeGroup *stgroup;
|
|
if (contactgroup->type() == Kopete::Group::TopLevel) {
|
|
stgroup = topstgroup;
|
|
} else {
|
|
/* find (or create) a matching sametime list group */
|
|
stgroup = mwSametimeList_findGroup(list,
|
|
contactgroup->displayName().ascii());
|
|
if (stgroup == 0L) {
|
|
stgroup = mwSametimeGroup_new(list, mwSametimeGroup_DYNAMIC,
|
|
contactgroup->displayName().ascii());
|
|
}
|
|
mwSametimeGroup_setOpen(stgroup, contactgroup->isExpanded());
|
|
mwSametimeGroup_setAlias(stgroup,
|
|
contactgroup->pluginData(account->protocol(), "alias")
|
|
.ascii());
|
|
}
|
|
|
|
/* now add the user (by IDBlock) */
|
|
struct mwIdBlock id =
|
|
{ (gchar*)contact->meanwhileId().ascii(), 0L };
|
|
struct mwSametimeUser *stuser = mwSametimeUser_new(stgroup,
|
|
mwSametimeUser_NORMAL, &id);
|
|
|
|
mwSametimeUser_setAlias(stuser, contact->nickName().ascii());
|
|
}
|
|
|
|
/* store! */
|
|
struct mwPutBuffer *buf = mwPutBuffer_new();
|
|
struct mwStorageUnit *unit = mwStorageUnit_new(mwStore_AWARE_LIST);
|
|
struct mwOpaque *opaque = mwStorageUnit_asOpaque(unit);
|
|
|
|
mwSametimeList_put(buf, list);
|
|
mwPutBuffer_finalize(opaque, buf);
|
|
|
|
mwServiceStorage_save(storageService, unit, NULL, NULL, NULL);
|
|
|
|
mwSametimeList_free(list);
|
|
}
|
|
|
|
void MeanwhileSession::syncContactsFromServer()
|
|
{
|
|
struct mwStorageUnit *unit = mwStorageUnit_new(mwStore_AWARE_LIST);
|
|
mwServiceStorage_load(storageService, unit, &_handleStorageLoad, 0L, 0L);
|
|
}
|
|
|
|
#define MEANWHILE_SESSION_BUFSIZ 4096
|
|
|
|
void MeanwhileSession::slotSocketDataAvailable()
|
|
{
|
|
HERE;
|
|
guchar *buf;
|
|
Q_LONG bytesRead;
|
|
|
|
if (socket == 0L)
|
|
return;
|
|
|
|
if (!(buf = (guchar *)malloc(MEANWHILE_SESSION_BUFSIZ))) {
|
|
mwDebug() << "buffer malloc failed" << endl;
|
|
return;
|
|
}
|
|
|
|
while (socket && socket->bytesAvailable() > 0) {
|
|
bytesRead = socket->readBlock((char *)buf, MEANWHILE_SESSION_BUFSIZ);
|
|
if (bytesRead < 0)
|
|
break;
|
|
mwSession_recv(session, buf, (unsigned int)bytesRead);
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
void MeanwhileSession::slotSocketClosed(int reason)
|
|
{
|
|
HERE;
|
|
|
|
if (reason & KExtendedSocket::involuntary)
|
|
emit serverNotification(
|
|
TQString("Lost connection with Meanwhile server"));
|
|
|
|
if (socket) {
|
|
delete socket;
|
|
socket = 0L;
|
|
}
|
|
|
|
mwSession_stop(session, 0x00);
|
|
}
|
|
|
|
|
|
Kopete::OnlineStatus MeanwhileSession::convertStatus(int mstatus)
|
|
{
|
|
MeanwhileProtocol *protocol =
|
|
static_cast<MeanwhileProtocol *>(account->protocol());
|
|
|
|
switch (mstatus) {
|
|
case mwStatus_ACTIVE:
|
|
return protocol->statusOnline;
|
|
break;
|
|
case mwStatus_IDLE:
|
|
return protocol->statusIdle;
|
|
break;
|
|
case mwStatus_AWAY:
|
|
return protocol->statusAway;
|
|
break;
|
|
case mwStatus_BUSY:
|
|
return protocol->statusBusy;
|
|
break;
|
|
case 0:
|
|
return protocol->statusOffline;
|
|
break;
|
|
default:
|
|
mwDebug() << "unknown status lookup: " << mstatus << endl;
|
|
}
|
|
return protocol->statusOffline;
|
|
}
|
|
|
|
void MeanwhileSession::resolveContactNickname(MeanwhileContact *contact)
|
|
{
|
|
/* @todo: FIXME: leak! */
|
|
char *id = strdup(contact->meanwhileId().ascii());
|
|
GList *query = g_list_prepend(NULL, id);
|
|
mwServiceResolve_resolve(resolveService, query, mwResolveFlag_USERS,
|
|
_handleResolveLookupResults, contact, NULL);
|
|
}
|
|
|
|
TQString MeanwhileSession::getNickName(struct mwLoginInfo *logininfo)
|
|
{
|
|
if (logininfo == 0L || logininfo->user_name == 0L)
|
|
return TQString::null;
|
|
return getNickName(logininfo->user_name);
|
|
}
|
|
|
|
TQString MeanwhileSession::getNickName(TQString name)
|
|
{
|
|
|
|
int index = name.find(" - ");
|
|
if (index != -1)
|
|
name = name.remove(0, index + 3);
|
|
index = name.find('/');
|
|
if (index != -1)
|
|
name = name.left(index);
|
|
|
|
return name;
|
|
}
|
|
|
|
MeanwhileContact *MeanwhileSession::conversationContact(
|
|
struct mwConversation *conv)
|
|
{
|
|
struct mwIdBlock *target = mwConversation_getTarget(conv);
|
|
if (target == 0L || target->user == 0L) {
|
|
return 0L;
|
|
}
|
|
TQString user(target->user);
|
|
|
|
MeanwhileContact *contact =
|
|
static_cast<MeanwhileContact *>(account->contacts()[user]);
|
|
|
|
struct mwLoginInfo *logininfo = mwConversation_getTargetInfo(conv);
|
|
TQString name = getNickName(logininfo);
|
|
|
|
if (!contact) {
|
|
account->addContact(user, name, 0L, Kopete::Account::Temporary);
|
|
contact = static_cast<MeanwhileContact *>(account->contacts()[user]);
|
|
} else
|
|
contact->setNickName(name);
|
|
|
|
return contact;
|
|
}
|
|
|
|
/* priave session handling functions, called by libmeanwhile callbacks */
|
|
void MeanwhileSession::handleSessionStateChange(
|
|
enum mwSessionState state, gpointer data)
|
|
{
|
|
HERE;
|
|
this->state = state;
|
|
|
|
switch (state) {
|
|
case mwSession_STARTING:
|
|
case mwSession_HANDSHAKE:
|
|
case mwSession_HANDSHAKE_ACK:
|
|
case mwSession_LOGIN:
|
|
case mwSession_LOGIN_REDIR:
|
|
case mwSession_LOGIN_CONT:
|
|
case mwSession_LOGIN_ACK:
|
|
break;
|
|
|
|
case mwSession_STARTED:
|
|
{
|
|
struct mwUserStatus stat = { mwStatus_ACTIVE, 0, 0L };
|
|
mwSession_setUserStatus(session, &stat);
|
|
struct mwLoginInfo *logininfo = mwSession_getLoginInfo(session);
|
|
if (logininfo) {
|
|
account->myself()->setNickName(getNickName(logininfo));
|
|
}
|
|
syncContactsFromServer();
|
|
}
|
|
break;
|
|
|
|
case mwSession_STOPPING:
|
|
{
|
|
unsigned int info = GPOINTER_TO_UINT(data);
|
|
if (info & ERR_FAILURE) {
|
|
if (info == INCORRECT_LOGIN)
|
|
account->password().setWrong();
|
|
char *reason = mwError(info);
|
|
emit serverNotification(TQString(reason));
|
|
free(reason);
|
|
}
|
|
}
|
|
|
|
emit sessionStateChange(
|
|
static_cast<MeanwhileProtocol *>(account->protocol())
|
|
->statusOffline);
|
|
break;
|
|
|
|
case mwSession_STOPPED:
|
|
break;
|
|
|
|
case mwSession_UNKNOWN:
|
|
default:
|
|
mwDebug() << "Unhandled state change " << state << endl;
|
|
}
|
|
}
|
|
|
|
int MeanwhileSession::handleSessionIOWrite(const guchar *buffer,
|
|
gsize count)
|
|
{
|
|
HERE;
|
|
|
|
if (socket == 0L)
|
|
return 1;
|
|
|
|
int remaining, retval = 0;
|
|
for (remaining = count; remaining > 0; remaining -= retval) {
|
|
retval = socket->writeBlock((char *)buffer, count);
|
|
if (retval <= 0)
|
|
return 1;
|
|
}
|
|
socket->flush();
|
|
return 0;
|
|
}
|
|
|
|
void MeanwhileSession::handleSessionAdmin(const char *text)
|
|
{
|
|
HERE;
|
|
emit serverNotification(TQString(text));
|
|
}
|
|
|
|
void MeanwhileSession::handleSessionAnnounce(struct mwLoginInfo *from,
|
|
gboolean /* may_reply */, const char *text)
|
|
{
|
|
HERE;
|
|
TQString message;
|
|
message.sprintf("Announcement from %s:\n%s", from->user_id, text);
|
|
emit serverNotification(message);
|
|
}
|
|
|
|
void MeanwhileSession::handleSessionSetUserStatus()
|
|
{
|
|
struct mwUserStatus *userstatus = mwSession_getUserStatus(session);
|
|
emit sessionStateChange(convertStatus((unsigned int)userstatus->status));
|
|
}
|
|
|
|
void MeanwhileSession::handleSessionSetPrivacyInfo()
|
|
{
|
|
}
|
|
|
|
void MeanwhileSession::handleSessionIOClose()
|
|
{
|
|
HERE;
|
|
|
|
if (socket == 0L)
|
|
return;
|
|
|
|
TQObject::disconnect(socket, TQT_SIGNAL(closed(int)),
|
|
this, TQT_SLOT(slotSocketClosed(int)));
|
|
socket->flush();
|
|
socket->closeNow();
|
|
|
|
delete socket;
|
|
socket = 0L;
|
|
}
|
|
|
|
void MeanwhileSession::handleSessionClear()
|
|
{
|
|
}
|
|
|
|
void MeanwhileSession::handleAwareAttrib(struct mwAwareAttribute * /* attrib */)
|
|
{
|
|
HERE;
|
|
}
|
|
|
|
void MeanwhileSession::handleAwareListAware(struct mwAwareSnapshot *snapshot)
|
|
{
|
|
HERE;
|
|
MeanwhileContact *contact = static_cast<MeanwhileContact *>
|
|
(account->contacts()[snapshot->id.user]);
|
|
|
|
if (contact == 0L)
|
|
return;
|
|
|
|
/* use the setUserStatus callback for status updates for myself. */
|
|
if (contact == account->myself())
|
|
return;
|
|
|
|
contact->setProperty(get_protocol()->statusMessage, snapshot->status.desc);
|
|
contact->setProperty(get_protocol()->awayMessage, snapshot->status.desc);
|
|
|
|
Kopete::OnlineStatus onlinestatus;
|
|
if (snapshot->online) {
|
|
onlinestatus = convertStatus(snapshot->status.status);
|
|
resolveContactNickname(contact);
|
|
} else {
|
|
onlinestatus = convertStatus(0);
|
|
}
|
|
|
|
contact->setOnlineStatus(onlinestatus);
|
|
|
|
#if 0
|
|
/* Commented out in previous kopete/meanwhile plugin for some reason,
|
|
* but has still been ported to the new API.
|
|
*/
|
|
time_t idletime = 0;
|
|
if (snapshot->status.status == mwStatus_IDLE) {
|
|
idletime = (snapshot->status.time == 0xdeadbeef) ?
|
|
0 : snapshot->status.time;
|
|
if (idletime != 0) {
|
|
contact->setStatusDescription(statusDesc + "[" +
|
|
TQString::number(idletime/60)+" mins]");
|
|
}
|
|
} else
|
|
contact->setStatusDescription(snapshot->status.desc);
|
|
#endif
|
|
}
|
|
|
|
void MeanwhileSession::handleAwareListAttrib(struct mwAwareIdBlock * /* id */,
|
|
struct mwAwareAttribute * /* attrib */)
|
|
{
|
|
HERE;
|
|
}
|
|
|
|
struct MeanwhileSession::ConversationData
|
|
*MeanwhileSession::createConversationData(
|
|
struct mwConversation *conv, MeanwhileContact *contact,
|
|
bool createQueue)
|
|
{
|
|
struct ConversationData *cd = new ConversationData();
|
|
|
|
if (cd == 0L)
|
|
return 0L;
|
|
|
|
cd->contact = contact;
|
|
cd->chat = contact->manager(Kopete::Contact::CanCreate);
|
|
cd->chat->ref();
|
|
if (createQueue)
|
|
cd->queue = new TQValueList<Kopete::Message>();
|
|
|
|
mwConversation_setClientData(conv, cd, 0L);
|
|
|
|
return cd;
|
|
}
|
|
|
|
void MeanwhileSession::handleImConvOpened(struct mwConversation *conv)
|
|
{
|
|
HERE;
|
|
|
|
struct ConversationData *convdata =
|
|
(struct ConversationData *)mwConversation_getClientData(conv);
|
|
|
|
if (convdata == 0L) {
|
|
/* a new conversation */
|
|
convdata = createConversationData(conv, conversationContact(conv));
|
|
|
|
if (convdata == 0L) {
|
|
mwDebug() << "No memory for conversation data!" << endl;
|
|
return;
|
|
}
|
|
|
|
} else if (convdata->queue && !convdata->queue->isEmpty()) {
|
|
/* send any messages that were waiting for the conversation to open */
|
|
TQValueList<Kopete::Message>::iterator it;
|
|
for (it = convdata->queue->begin(); it != convdata->queue->end();
|
|
++it) {
|
|
mwConversation_send(conv, mwImSend_PLAIN,
|
|
(*it).plainBody().ascii());
|
|
convdata->chat->appendMessage(*it);
|
|
convdata->chat->messageSucceeded();
|
|
}
|
|
convdata->queue->clear();
|
|
delete convdata->queue;
|
|
convdata->queue = 0L;
|
|
}
|
|
resolveContactNickname(convdata->contact);
|
|
}
|
|
|
|
void MeanwhileSession::handleImConvClosed(struct mwConversation *conv,
|
|
guint32)
|
|
{
|
|
HERE;
|
|
|
|
ConversationData *convdata =
|
|
(ConversationData *)mwConversation_getClientData(conv);
|
|
|
|
if (!convdata)
|
|
return;
|
|
|
|
mwConversation_setClientData(conv, 0L, 0L);
|
|
|
|
convdata->chat->removeContact(convdata->contact);
|
|
convdata->chat->deref();
|
|
convdata->chat = 0L;
|
|
if (convdata->queue != 0L) {
|
|
convdata->queue->clear();
|
|
delete convdata->queue;
|
|
convdata->queue = 0L;
|
|
}
|
|
free(convdata);
|
|
}
|
|
|
|
void MeanwhileSession::handleImConvReceived(struct mwConversation *conv,
|
|
enum mwImSendType type, gconstpointer msg)
|
|
{
|
|
HERE;
|
|
ConversationData *convdata =
|
|
(ConversationData *)mwConversation_getClientData(conv);
|
|
|
|
if (!convdata)
|
|
return;
|
|
|
|
switch (type) {
|
|
case mwImSend_PLAIN:
|
|
{
|
|
Kopete::Message message(convdata->contact, account->myself(),
|
|
TQString((char *)msg), Kopete::Message::Inbound);
|
|
convdata->chat->appendMessage(message);
|
|
}
|
|
break;
|
|
case mwImSend_TYPING:
|
|
convdata->chat->receivedTypingMsg(convdata->contact);
|
|
break;
|
|
default:
|
|
mwDebug() << "Unable to handle message type: " << type << endl;
|
|
}
|
|
}
|
|
|
|
void MeanwhileSession::handleResolveLookupResults(
|
|
struct mwServiceResolve * /* srvc */, guint32 /* id */,
|
|
guint32 /* code */, GList *results, gpointer data)
|
|
{
|
|
struct mwResolveResult *result;
|
|
struct mwResolveMatch *match;
|
|
|
|
if (results == 0L)
|
|
return;
|
|
if ((result = (struct mwResolveResult *)results->data) == 0L)
|
|
return;
|
|
|
|
if (result->matches == 0L)
|
|
return;
|
|
if ((match = (struct mwResolveMatch *)result->matches->data) == 0L)
|
|
return;
|
|
|
|
mwDebug() << "resolve lookup returned '" << match->name << "'" << endl;
|
|
|
|
MeanwhileContact *contact = (MeanwhileContact *)data;
|
|
if (contact == 0L)
|
|
return;
|
|
|
|
contact->setNickName(getNickName(match->name));
|
|
}
|
|
|
|
void MeanwhileSession::handleStorageLoad(struct mwServiceStorage * /* srvc */,
|
|
guint32 result, struct mwStorageUnit *item, gpointer /* data */)
|
|
{
|
|
HERE;
|
|
if (result != ERR_SUCCESS) {
|
|
mwDebug() << "contact list load returned " << result << endl;
|
|
return;
|
|
}
|
|
|
|
struct mwGetBuffer *buf = mwGetBuffer_wrap(mwStorageUnit_asOpaque(item));
|
|
struct mwSametimeList *list = mwSametimeList_new();
|
|
mwSametimeList_get(buf, list);
|
|
|
|
GList *gl, *glf, *cl, *clf;
|
|
|
|
Kopete::ContactList *contactlist = Kopete::ContactList::self();
|
|
|
|
for (glf = gl = mwSametimeList_getGroups(list); gl; gl = gl->next) {
|
|
struct mwSametimeGroup *stgroup = (struct mwSametimeGroup *)gl->data;
|
|
|
|
Kopete::Group *group =
|
|
contactlist->findGroup(mwSametimeGroup_getName(stgroup));
|
|
group->setPluginData(account->protocol(), "alias",
|
|
mwSametimeGroup_getAlias(stgroup));
|
|
|
|
for (clf = cl = mwSametimeGroup_getUsers(stgroup); cl; cl = cl->next) {
|
|
struct mwSametimeUser *stuser = (struct mwSametimeUser *)cl->data;
|
|
|
|
MeanwhileContact *contact = static_cast<MeanwhileContact *>
|
|
(account->contacts()[mwSametimeUser_getUser(stuser)]);
|
|
|
|
if (contact != 0L)
|
|
continue;
|
|
|
|
account->addContact(mwSametimeUser_getUser(stuser),
|
|
mwSametimeUser_getAlias(stuser), group,
|
|
Kopete::Account::ChangeKABC);
|
|
}
|
|
g_list_free(clf);
|
|
}
|
|
g_list_free(glf);
|
|
|
|
mwSametimeList_free(list);
|
|
}
|
|
|
|
const struct MeanwhileClientID *MeanwhileSession::getClientIDs()
|
|
{
|
|
return ids;
|
|
}
|
|
|
|
#if 0
|
|
MEANWHILE_HOOK_CONFERENCE(conference_invite,
|
|
(struct mwConference *conf, struct mwLoginInfo *inviter,
|
|
const char *invite),
|
|
(conf, inviter, invite))
|
|
{
|
|
HERE;
|
|
TQString message;
|
|
|
|
message.sprintf("%s has invited you to a conference called \"%s\"\n"
|
|
"However, this version of the meanwhile plugin does "
|
|
"not support conferences, so the invitiation has been declined.",
|
|
inviter->user_id, invite);
|
|
|
|
mwConference_reject(conf, ERR_SUCCESS,
|
|
"Sorry, my client doesn't support conferences!");
|
|
KMessageBox::queuedMessageBox(0, KMessageBox::Sorry , message,
|
|
i18n("Meanwhile Plugin: Conference invitation"),
|
|
KMessageBox::Notify);
|
|
}
|
|
#endif
|
|
#include "meanwhilesession.moc"
|