void AbiCollabSessionManager::disjoinSession(const UT_UTF8String& sSessionId)
{
UT_DEBUGMSG(("AbiCollabSessionManager::disjoinSession(%s)\n", sSessionId.utf8_str()));
AbiCollab* pSession = getSessionFromSessionId(sSessionId);
UT_return_if_fail(pSession);
const std::map<BuddyPtr, std::string> vCollaborators = pSession->getCollaborators();
if (!isLocallyControlled(pSession->getDocument()))
{
// we are joined to a session, so there should only be one collaborator:
// the person sharing the document
UT_return_if_fail(vCollaborators.size() == 1);
std::map<BuddyPtr, std::string>::const_iterator cit = vCollaborators.begin();
BuddyPtr pCollaborator = (*cit).first;
destroySession(pSession);
DisjoinSessionEvent event(sSessionId);
event.addRecipient(pCollaborator);
signal(event);
}
else
{
UT_ASSERT(UT_NOT_REACHED);
return;
}
}
void SessionServer::cleanupSessions()
{
if(_allowPersistentSessions && _expirationTime>0) {
QDateTime now = QDateTime::currentDateTime();
QList<SessionState*> expirelist;
for(SessionState *s : _sessions) {
if(s->userCount()==0) {
if(s->lastEventTime().msecsTo(now) > _expirationTime) {
expirelist << s;
}
}
}
for(SessionState *s : expirelist) {
logger::info() << s << "Vacant session expired. Uptime was" << s->uptime();
if(_store && _store->autoStore() && s->isPersistent())
s->setHibernatable(true);
destroySession(s);
}
}
}
/**
* @brief Handle client disconnect from a session
*
* The session takes care of the client itself. Here, we clean up after the session
* in case it needs to be closed.
* @param session
*/
void SessionServer::userDisconnectedEvent(SessionState *session)
{
bool delSession = false;
if(session->userCount()==0) {
logger::debug() << session << "Last user left";
bool hasSnapshot = session->mainstream().hasSnapshot();
// A non-persistent session is deleted when the last user leaves
// A persistent session can also be deleted if it doesn't contain a snapshot point.
if(!hasSnapshot || !session->isPersistent()) {
if(hasSnapshot)
logger::info() << session << "Closing non-persistent session";
else
logger::info() << session << "Closing persistent session due to lack of snapshot point!";
delSession = true;
}
// If the hibernatable flag is set, it means we want to put the session
// into storage as soon as possible
delSession |= session->isHibernatable();
}
if(delSession)
destroySession(session);
else
emit sessionChanged(SessionDescription(*session));
emit userDisconnected();
}
void BaseSessionStore::destroySession(Poco::Net::HTTPServerRequest& request,
Poco::Net::HTTPServerResponse& response)
{
// Get the cookies from the client.
Poco::Net::NameValueCollection cookies;
// Get the cookies
request.getCookies(cookies);
// Try to find a cookie with our session key name.
Poco::Net::NameValueCollection::ConstIterator cookieIter = cookies.begin();
while (cookieIter != cookies.end())
{
if (0 == cookieIter->first.compare(_sessionKeyName))
{
// Destroy the session data.
destroySession(cookieIter->second);
// Invalidate the cookies.
Poco::Net::HTTPCookie cookie(_sessionKeyName, cookieIter->second);
cookie.setMaxAge(0);
response.addCookie(cookie);
}
++cookieIter;
}
}
void IrcClient::configure(bool should_create_session)
{
// disconnect and destroy existing network connection
destroySession() ;
// validate and create network session (and login asynchronously)
if (should_create_session) createSession() ;
}
t_bool disconnect(t_list **script, t_socket *client)
{
printf("\t\tDisconnect() -> Starting Execution\n");
if (!client)
return FALSE;
if (destroySession(client->request, cookie_sessionID, cookie_sessionUsername))
return TRUE;
return FALSE;
}
void AFPSGPlayerController::clientDestroySession_Implementation() const
{
GEngine->AddOnScreenDebugMessage(-1, 40.0f, FColor::Cyan, TEXT("AFPSGPlayerController::clientDestroySession_Implementation"));
AFPSGPlayerState* myPlayerState = Cast<AFPSGPlayerState>(PlayerState);
if (myPlayerState != NULL)
{
//Destroy the session
destroySession(myPlayerState->SessionName);
}
}
void SessionServer::stopAll()
{
for(Client *c : _lobby)
c->disconnectShutdown();
auto sessions = _sessions;
for(Session *s : sessions) {
s->stopRecording();
s->kickAllUsers();
if(s->userCount()==0)
destroySession(s);
}
}
void SessionServer::stopAll()
{
for(Client *c : _lobby)
c->disconnectShutdown();
auto sessions = _sessions;
for(SessionState *s : sessions) {
if(_store)
s->setHibernatable(s->isPersistent() || _store->storeAllSessions());
s->stopRecording();
s->kickAllUsers();
if(s->userCount()==0)
destroySession(s);
}
}
bool SessionServer::killSession(const QString &id)
{
logger::info() << "Killing session" << id;
for(Session *s : _sessions) {
if(s->id() == id) {
s->killSession();
if(s->userCount()==0)
destroySession(s);
return true;
}
}
// not found
return false;
}
void AbiCollabSessionManager::removeBuddy(BuddyPtr pBuddy, bool graceful)
{
UT_return_if_fail(pBuddy);
UT_DEBUGMSG(("Dropping buddy '%s' from all sessions\n", pBuddy->getDescription().utf8_str()));
// TODO: should we send out events for every buddy we drop, or session
// we delete?
for (UT_sint32 i = m_vecSessions.getItemCount() - 1; i >= 0; i--)
{
AbiCollab* pSession = m_vecSessions.getNthItem(i);
UT_continue_if_fail(pSession);
if (pSession->isLocallyControlled())
{
pSession->removeCollaborator(pBuddy);
}
else
{
// we don't control this session, meaning we can drop it completely
// if this buddy controlled it
// TODO: when we allow more than 1 buddy in a non-locally controlled,
// then remove it from that list here
if (pSession->isController(pBuddy))
{
UT_DEBUGMSG(("This buddy controlled a session, destroying the session...\n"));
std::string docName = pSession->getDocument()->getFilename();
if (docName == "")
docName = "Untitled"; // TODO: fetch the title from the frame somehow (which frame?) - MARCM
destroySession(pSession);
if (!graceful)
{
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
UT_continue_if_fail(pFrame);
// TODO: make this localizable
UT_UTF8String msg;
UT_UTF8String_sprintf(msg, "You've been disconnected from buddy %s. The collaboration session for document %s has been stopped.", pBuddy->getDescription().utf8_str(), docName.c_str());
pFrame->showMessageBox(msg.utf8_str(), XAP_Dialog_MessageBox::b_O, XAP_Dialog_MessageBox::a_OK);
}
}
}
}
}
void AbiCollabSessionManager::closeSession(AbiCollab* pSession, bool canConfirm)
{
UT_DEBUGMSG(("Stopping collaboration session %s\n", pSession->getSessionId().utf8_str()));
UT_return_if_fail(pSession);
// TODO: in the future, we should hand over control to someone
// else within this session first, if possible
// ask for confirmation if we are in control of this session, and people are connected to us,
if (pSession->isLocallyControlled() &&
pSession->getCollaborators().size() > 0 &&
canConfirm)
{
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
UT_return_if_fail(pFrame);
UT_UTF8String msg;
// TODO: make this localizable
UT_UTF8String_sprintf(msg, "This document is currently being shared with %u people. Are you sure you want to stop sharing this document?", pSession->getCollaborators().size());
if (pFrame->showMessageBox(msg.utf8_str(), XAP_Dialog_MessageBox::b_YN, XAP_Dialog_MessageBox::a_NO) != XAP_Dialog_MessageBox::a_YES)
return;
}
// check who is controlling this session
if (pSession->isLocallyControlled())
{
UT_UTF8String pDestroyedSession = pSession->getSessionId();
// kill the session
destroySession(pSession);
// notify all that this session is closed
CloseSessionEvent event(pDestroyedSession);
event.setBroadcast(true);
signal(event);
}
else
{
// we are joined to this session, so we aren't allowed to close it;
// we should disjoin it instead
UT_ASSERT(UT_NOT_REACHED);
}
}
bool SessionServer::killSession(const QString &id)
{
logger::info() << "Killing session" << id;
for(SessionState *s : _sessions) {
if(s->id() == id) {
s->killSession();
if(s->userCount()==0)
destroySession(s);
return true;
}
}
// Not an active session? Maybe it's a stored session
if(_store) {
return _store->deleteSession(id);
}
// not found
return false;
}
void SessionServer::cleanupSessions()
{
if(_allowPersistentSessions && _expirationTime>0) {
QDateTime now = QDateTime::currentDateTime();
QList<Session*> expirelist;
for(Session *s : _sessions) {
if(s->userCount()==0) {
if(s->lastEventTime().msecsTo(now) > _expirationTime) {
expirelist << s;
}
}
}
for(Session *s : expirelist) {
logger::info() << s << "Vacant session expired. Uptime was" << s->uptime();
destroySession(s);
}
}
}
/**
* @brief Handle client disconnect from a session
*
* The session takes care of the client itself. Here, we clean up after the session
* in case it needs to be closed.
* @param session
*/
void SessionServer::userDisconnectedEvent(Session *session)
{
bool delSession = false;
if(session->userCount()==0) {
logger::debug() << session << "Last user left";
// A non-persistent session is deleted when the last user leaves
// A persistent session can also be deleted if it doesn't contain a snapshot point.
if(!session->isPersistent()) {
logger::info() << session << "Closing non-persistent session";
logger::info() << session << "History size was" << session->mainstream().lengthInBytes() << "bytes";
delSession = true;
}
}
if(delSession)
destroySession(session);
else
emit sessionChanged(SessionDescription(*session));
emit userDisconnected();
}
bool AbiCollabSessionManager::destroyAccount(AccountHandler* pHandler)
{
UT_return_val_if_fail(pHandler, false);
for (UT_uint32 i = 0; i < m_vecAccounts.size(); i++)
{
UT_continue_if_fail(m_vecAccounts[i]);
if (pHandler == m_vecAccounts[i])
{
UT_DEBUGMSG(("Destroying account handler %s\n", pHandler->getDescription().utf8_str()));
// TODO: if a number of buddies are connected, then we should ask for confirmation
// drop all buddies that belong to the account that is being deleted
// from all active sessions
for (UT_sint32 j = 0; j < m_vecSessions.getItemCount(); j++)
{
AbiCollab* pSession = m_vecSessions.getNthItem(j);
UT_continue_if_fail(pSession);
// There can only be buddies from 1 account in an active session these days/
// That means that if this session's account is the account we are destroying,
// then we can kill off the entire session. Do nothing otherwise.
if (pSession->getAclAccount() == pHandler)
{
UT_DEBUGMSG(("Session %s is running on this account, destroying it!\n", pSession->getSessionId().utf8_str()));
destroySession(pSession);
}
}
m_vecAccounts.erase(m_vecAccounts.begin() + i, m_vecAccounts.begin() + i + 1);
_deleteAccount(pHandler);
return true;
}
}
return false;
}
void
GaduSession::login( struct gg_login_params* p )
{
if ( !isConnected() ) {
// turn on in case you have any problems, and you want
// to report it better. libgadu needs to be recompiled with debug enabled
// gg_debug_level=GG_DEBUG_MISC|GG_DEBUG_FUNCTION;
kdDebug(14100) << "Login" << endl;
if ( !( session_ = gg_login( p ) ) ) {
destroySession();
kdDebug( 14100 ) << "libgadu internal error " << endl;
emit connectionFailed( GG_FAILURE_CONNECTING );
return;
}
createNotifiers( true );
enableNotifiers( session_->check );
searchSeqNr_=0;
}
}
void
GaduSession::checkDescriptor()
{
disableNotifiers();
struct gg_event* event;
// struct gg_dcc* dccSock;
KGaduMessage gaduMessage;
KGaduNotify gaduNotify;
if ( !( event = gg_watch_fd( session_ ) ) ) {
kdDebug(14100)<<"Connection was broken for some reason"<<endl;
destroyNotifiers();
logoff( Kopete::Account::ConnectionReset );
return;
}
// FD changed, recreate socket notifiers
if ( session_->state == GG_STATE_CONNECTING_HUB || session_->state == GG_STATE_CONNECTING_GG ) {
kdDebug(14100)<<"recreating notifiers"<<endl;
destroyNotifiers();
createNotifiers( true );
}
switch( event->type ) {
case GG_EVENT_MSG:
kdDebug(14100) << "incoming message:class:" << event->event.msg.msgclass << endl;
if ( event->event.msg.msgclass & GG_CLASS_CTCP ) {
kdDebug( 14100 ) << "incomming ctcp " << endl;
// TODO: DCC CONNECTION
emit incomingCtcp( event->event.msg.sender );
}
if ( (event->event.msg.msgclass & GG_CLASS_MSG) || (event->event.msg.msgclass & GG_CLASS_CHAT) ) {
gaduMessage.message =
textcodec->toUnicode((const char*)event->event.msg.message);
gaduMessage.sender_id = event->event.msg.sender;
gaduMessage.sendTime.setTime_t( event->event.msg.time, Qt::LocalTime );
gaduMessage.message = rtf->convertToHtml( gaduMessage.message, event->event.msg.formats_length, event->event.msg.formats );
emit messageReceived( &gaduMessage );
}
break;
case GG_EVENT_ACK:
emit ackReceived( event->event.ack.recipient );
break;
case GG_EVENT_STATUS:
gaduNotify.status = event->event.status.status;
gaduNotify.contact_id = event->event.status.uin;
if ( event->event.status.descr ) {
gaduNotify.description = textcodec->toUnicode( event->event.status.descr );
}
else {
gaduNotify.description = QString::null;
}
gaduNotify.remote_port = 0;
gaduNotify.version = 0;
gaduNotify.image_size = 0;
gaduNotify.time = 0;
gaduNotify.fileCap = false;
emit contactStatusChanged( &gaduNotify );
break;
case GG_EVENT_STATUS60:
gaduNotify.status = event->event.status60.status;
gaduNotify.contact_id = event->event.status60.uin;
if ( event->event.status60.descr ) {
gaduNotify.description = textcodec->toUnicode( event->event.status60.descr );
}
else {
gaduNotify.description = QString::null;
}
gaduNotify.remote_ip.setAddress( ntohl( event->event.status60.remote_ip ) );
gaduNotify.remote_port = event->event.status60.remote_port;
gaduNotify.version = event->event.status60.version;
gaduNotify.image_size = event->event.status60.image_size;
gaduNotify.time = event->event.status60.time;
if ( event->event.status60.remote_ip && gaduNotify.remote_port > 10 ) {
gaduNotify.fileCap = true;
}
else {
gaduNotify.fileCap = false;
}
emit contactStatusChanged( &gaduNotify );
break;
case GG_EVENT_NOTIFY60:
notify60( event );
break;
case GG_EVENT_CONN_SUCCESS:
kdDebug(14100) << "success server: " << session_->server_addr << endl;
emit connectionSucceed();
break;
case GG_EVENT_CONN_FAILED:
kdDebug(14100) << "failed server: " << session_->server_addr << endl;
destroySession();
kdDebug(14100) << "emit connection failed(" << event->event.failure << ") signal" << endl;
emit connectionFailed( (gg_failure_t)event->event.failure );
break;
case GG_EVENT_DISCONNECT:
kdDebug(14100)<<"event Disconnected"<<endl;
// it should be called either when we requested disconnect, or when other client connects with our UID
logoff( Kopete::Account::Manual );
break;
case GG_EVENT_PONG:
emit pong();
break;
case GG_EVENT_NONE:
break;
case GG_EVENT_PUBDIR50_SEARCH_REPLY:
case GG_EVENT_PUBDIR50_WRITE:
case GG_EVENT_PUBDIR50_READ:
sendResult( event->event.pubdir50 );
break;
case GG_EVENT_USERLIST:
handleUserlist( event );
break;
default:
kdDebug(14100)<<"Unprocessed GaduGadu Event = "<<event->type<<endl;
break;
}
if ( event ) {
gg_free_event( event );
}
if ( session_ ) {
enableNotifiers( session_->check );
}
}
void
GaduSession::logoff( Kopete::Account::DisconnectReason reason )
{
destroySession();
emit disconnect( reason );
}
void AmSessionContainer::destroySession(AmSession* s)
{
destroySession(s->getLocalTag());
}
bool AbiCollabSessionManager::processPacket(AccountHandler& /*handler*/, Packet* packet, BuddyPtr buddy)
{
UT_DEBUGMSG(("AbiCollabSessionManager::processPacket()\n"));
UT_return_val_if_fail(packet, false);
UT_return_val_if_fail(buddy, false);
// check if this is a simple import-meh-now-packet
PClassType pct = packet->getClassType();
if (pct >= _PCT_FirstSessionPacket && pct <= _PCT_LastSessionPacket)
{
// lookup session
SessionPacket* dsp = static_cast<SessionPacket*>( packet );
const UT_UTF8String& sessionId = dsp->getSessionId();
AbiCollab* pAbiCollab = getSessionFromSessionId(sessionId);
if (!pAbiCollab) {
UT_DEBUGMSG(("Unknown session id: '%s'", sessionId.utf8_str()));
UT_return_val_if_fail(pAbiCollab, true);
}
// handle packet!
pAbiCollab->import(dsp, buddy);
return true;
}
// handle packet
switch (pct) {
case PCT_StartSessionEvent:
{
StartSessionEvent event;
event.setBroadcast(true);
signal(event, buddy);
return true;
}
case PCT_JoinSessionEvent:
{
JoinSessionEvent* jse = static_cast<JoinSessionEvent*>(packet);
const UT_UTF8String& joinedSessionId = jse->getSessionId();
// someone who joined this session disconnected, remove him from the collaboration session
AbiCollab* pSession = getSessionFromSessionId(joinedSessionId);
if (pSession)
{
if (isLocallyControlled( pSession->getDocument() ))
{
// we should already know this buddy, as we sent should have already added this
// buddy when responding to his JoinSessionRequest
// TODO: check this
}
// signal all
JoinSessionEvent event(joinedSessionId);
signal( event, buddy );
}
else
{
// we don't know this session, don't forward the packet
UT_ASSERT_HARMLESS(UT_NOT_REACHED);
}
return true;
}
case PCT_DisjoinSessionEvent:
{
DisjoinSessionEvent* dse = static_cast<DisjoinSessionEvent*>(packet);
const UT_UTF8String& disjoinedSessionId = dse->getSessionId();
// someone who joined this session disconnected, remove him from the collaboration session
AbiCollab* pSession = getSessionFromSessionId(disjoinedSessionId);
if (pSession)
{
pSession->removeCollaborator(buddy);
// signal all
DisjoinSessionEvent event(disjoinedSessionId);
signal(event, buddy);
}
else
{
// we don't know this session, don't forward the packet
UT_ASSERT_HARMLESS(UT_NOT_REACHED);
}
return true;
}
case PCT_CloseSessionEvent:
{
CloseSessionEvent* cse = static_cast<CloseSessionEvent*>(packet);
const UT_UTF8String& destroyedSessionId = cse->getSessionId();
buddy->destroyDocHandle( destroyedSessionId );
// handle the event outselves
AbiCollab* pSession = getSessionFromSessionId(destroyedSessionId);
if (pSession)
{
if (!isLocallyControlled(pSession->getDocument()))
{
std::string docName = pSession->getDocument()->getFilename();
if (docName == "")
docName = "Untitled"; // TODO: fetch the title from the frame somehow (which frame?) - MARCM
// the server hosting this session is gone, so let's disconnect as well
if (!destroySession(pSession))
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
// signal all
CloseSessionEvent event( destroyedSessionId );
signal( event, buddy );
// inform the user of the disconnect
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
UT_return_val_if_fail(pFrame, true);
UT_UTF8String msg;
// TODO: make this localizable
UT_UTF8String_sprintf(msg, "Document %s is not being shared anymore by buddy %s. You are disconnected from the collaboration session.", docName.c_str(), buddy->getDescription().utf8_str());
pFrame->showMessageBox(msg.utf8_str(), XAP_Dialog_MessageBox::b_O, XAP_Dialog_MessageBox::a_OK);
}
else
{
// someone who is not controlling this session sends out messages he closed it!
// we will not forward this packet
UT_ASSERT_HARMLESS(UT_NOT_REACHED);
}
}
else
{
UT_DEBUGMSG(("Ignoring a CloseSession event for unknown session (%s)\n", destroyedSessionId.utf8_str()));
}
return true;
}
case PCT_AccountAddBuddyRequestEvent:
{
// look at this packet; I have a feeling we need to deprecate it - MARCM
UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED);
return true;
}
default:
break;
}
return false;
}
void deleteSession(struct Session *session) {
destroySession(session);
free(session);
}
IrcClient::~IrcClient() { destroySession() ; NetworkStore = ValueTree::invalid ; }
