/* external interface called by meanwhileaccount */
void MeanwhileSession::connect(QString password)
{
HERE;
int port, clientID, versionMajor, versionMinor;
bool useCustomID;
QString host;
host = account->getServerName();
port = account->getServerPort();
useCustomID = account->getClientIDParams(&clientID,
&versionMajor, &versionMinor);
QTcpSocket *sock = new QTcpSocket(this);
Kopete::SocketTimeoutWatcher* timeoutWatcher = Kopete::SocketTimeoutWatcher::watch(sock);
if (timeoutWatcher)
QObject::connect(timeoutWatcher, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(slotSocketAboutToClose()));
sock->connectToHost(host, quint16(port));
// TODO - make asynchronous
if (!sock->waitForConnected()) {
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 */
QObject::connect(sock, SIGNAL(readyRead()), this,
SLOT(slotSocketDataAvailable()));
QObject::connect(sock, SIGNAL(aboutToClose()), this,
SLOT(slotSocketAboutToClose()));
/* set login details */
mwSession_setProperty(session, mwSession_AUTH_USER_ID,
g_strdup(account->meanwhileId().toAscii()), g_free);
mwSession_setProperty(session, mwSession_AUTH_PASSWORD,
g_strdup(password.toAscii()), 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);
}
/* go!! */
mwSession_start(session);
}
void __cdecl SessionThread(LPVOID param)
{
CSametimeProto* proto = (CSametimeProto*)param;
HANDLE hNetlibUser = proto->m_hNetlibUser;
proto->debugLog(_T("SessionThread() start"));
continue_connect = true;
//setup
NETLIBOPENCONNECTION conn_data = { 0 };
conn_data.cbSize = sizeof(NETLIBOPENCONNECTION);
conn_data.flags = NLOCF_V2;
conn_data.szHost = proto->options.server_name;
conn_data.wPort = proto->options.port;
conn_data.timeout = 20;
conn_data.waitcallback = waitcallback;
proto->BroadcastNewStatus(ID_STATUS_CONNECTING);
proto->server_connection = (HANDLE)CallService(MS_NETLIB_OPENCONNECTION, (WPARAM)hNetlibUser, (LPARAM)&conn_data);
if (!proto->server_connection) {
proto->BroadcastNewStatus(ID_STATUS_OFFLINE);
if (continue_connect) {
// real timeout - not user cancelled
proto->showPopup(TranslateT("No server connection!"), SAMETIME_POPUP_ERROR);
}
proto->debugLog(_T("SessionThread() end, no server_connection, continue_connect=[%d]"), continue_connect);
return;
}
mwSessionHandler handler = { 0 };
handler.clear = SessionClear;
handler.io_write = SessionWrite;
handler.io_close = SessionClose;
handler.on_stateChange = SessionStateChange;
handler.on_admin = SessionAdmin;
handler.on_announce = SessionAnnounce;
handler.on_setPrivacyInfo = SessionSetPrivacyInfo;
handler.on_setUserStatus = SessionSetUserStatus;
EnterCriticalSection(&proto->session_cs);
proto->session = mwSession_new(&handler);
proto->InitMeanwhileServices();
mwSession_start(proto->session);
LeaveCriticalSection(&proto->session_cs);
mir_forkthread(KeepAliveThread, (void*)proto);
unsigned char* recv_buffer = (unsigned char*)mir_alloc(1024 * 32);
int bytes;
//while(session && server_connection && mwSession_getState(session) != mwSession_STOPPED) {
while (proto->server_connection) {// && session) {// && !mwSession_isStopped(session)) { // break on error
bytes = Netlib_Recv(proto->server_connection, (char *)recv_buffer, 1024 * 32, 0);
proto->debugLog(_T("SessionThread() Netlib_Recv'ed bytes=[%d]"), bytes);
if (bytes == 0) {
break;
}
else if (bytes == SOCKET_ERROR) {
// this is normal - e.g. socket closed due to log off, during blocking read above
break;
}
else {
EnterCriticalSection(&proto->session_cs);
mwSession_recv(proto->session, recv_buffer, bytes);
LeaveCriticalSection(&proto->session_cs);
}
}
mir_free(recv_buffer);
EnterCriticalSection(&proto->session_cs);
proto->DeinitMeanwhileServices();
mwSession* old_session = proto->session;
proto->session = 0; // kills keepalive thread, if awake
mwSession_free(old_session);
LeaveCriticalSection(&proto->session_cs);
proto->BroadcastNewStatus(ID_STATUS_OFFLINE);
proto->SetAllOffline();
proto->first_online = true;
proto->debugLog(_T("SessionThread() end"));
return;
}
