diff options
| author | Vadim Dashevskiy <watcherhd@gmail.com> | 2014-04-15 08:46:04 +0000 |
|---|---|---|
| committer | Vadim Dashevskiy <watcherhd@gmail.com> | 2014-04-15 08:46:04 +0000 |
| commit | c015ec458520935c407aa1b2ce1d004c5c5c8a61 (patch) | |
| tree | 9c77a0b9d3368731d08468105f52dcb2726c6d3f /protocols/ICQCorp/src/protocol.cpp | |
| parent | bd7e07aa0bfb4fecdd09d0a48eabcb6899dd0601 (diff) | |
ICQCorp adopted - needs Unicode fixes
git-svn-id: http://svn.miranda-ng.org/main/trunk@8980 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c
Diffstat (limited to 'protocols/ICQCorp/src/protocol.cpp')
| -rw-r--r-- | protocols/ICQCorp/src/protocol.cpp | 2339 |
1 files changed, 2339 insertions, 0 deletions
diff --git a/protocols/ICQCorp/src/protocol.cpp b/protocols/ICQCorp/src/protocol.cpp new file mode 100644 index 0000000000..25967327d5 --- /dev/null +++ b/protocols/ICQCorp/src/protocol.cpp @@ -0,0 +1,2339 @@ +/*
+ ICQ Corporate protocol plugin for Miranda IM.
+ Copyright (C) 2003-2005 Eugene Tarasenko <zlyden13@inbox.ru>
+
+ 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.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#include "corp.h"
+
+ICQ icq;
+
+///////////////////////////////////////////////////////////////////////////////
+
+unsigned short toIcqStatus(unsigned short status)
+{
+/*
+ unsigned short icqStatus[] = { ICQ_STATUS_OFFLINE, ICQ_STATUS_ONLINE, ICQ_STATUS_AWAY, ICQ_STATUS_DND,
+ ICQ_STATUS_NA, ICQ_STATUS_OCCUPIED, ICQ_STATUS_FREEFORCHAT, ICQ_STATUS_PRIVATE };
+
+ return icqStatus[status - ID_STATUS_OFFLINE];
+*/
+ switch (status)
+ {
+ case ID_STATUS_OFFLINE: return ICQ_STATUS_OFFLINE;
+ case ID_STATUS_ONLINE: return ICQ_STATUS_ONLINE;
+ case ID_STATUS_AWAY: return ICQ_STATUS_AWAY;
+ case ID_STATUS_DND: return ICQ_STATUS_DND;
+ case ID_STATUS_NA: return ICQ_STATUS_NA;
+ case ID_STATUS_OCCUPIED: return ICQ_STATUS_OCCUPIED;
+ case ID_STATUS_FREECHAT: return ICQ_STATUS_FREECHAT;
+ case ID_STATUS_INVISIBLE: return ICQ_STATUS_PRIVATE;
+ }
+ return ICQ_STATUS_ONLINE;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+unsigned short toIdStatus(unsigned short status)
+{
+ switch (status)
+ {
+ case ICQ_STATUS_OFFLINE: return ID_STATUS_OFFLINE;
+ case ICQ_STATUS_ONLINE: return ID_STATUS_ONLINE;
+ case ICQ_STATUS_AWAY: return ID_STATUS_AWAY;
+ case ICQ_STATUS_DND: return ID_STATUS_DND;
+ case ICQ_STATUS_NA: return ID_STATUS_NA;
+ case ICQ_STATUS_OCCUPIED: return ID_STATUS_OCCUPIED;
+ case ICQ_STATUS_FREECHAT: return ID_STATUS_FREECHAT;
+ case ICQ_STATUS_PRIVATE: return ID_STATUS_INVISIBLE;
+ }
+ return ID_STATUS_ONLINE;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+LRESULT WINAPI messageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ SOCKET hSocket = (SOCKET)wParam;
+ unsigned short netEvents = LOWORD(lParam);
+ unsigned long result;
+
+ switch (msg)
+ {
+ case WM_NETEVENT_SERVER:
+ if (hSocket == icq.udpSocket.handleVal)
+ {
+ if (netEvents & FD_READ) icq.recvUDP(0);
+ break;
+ }
+ break;
+
+ case WM_NETEVENT_CONNECTION:
+ if (hSocket == icq.tcpSocket.handleVal)
+ {
+ if (netEvents & FD_ACCEPT) icq.recvNewTCP(0);
+ break;
+ }
+ break;
+
+ case WM_NETEVENT_USER:
+ if (netEvents & FD_READ)
+ {
+ ioctlsocket(hSocket, FIONREAD, &result);
+ if (result > 0) icq.recvTCP(hSocket);
+ }
+ if (netEvents & FD_CLOSE)
+ {
+ unsigned int i;
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ if (hSocket == icqUsers[i]->socket.handleVal)
+ {
+ T("[tcp] user %d is aborted connection\n", icqUsers[i]->uin);
+ icqUsers[i]->socket.closeConnection();
+ break;
+ }
+ }
+ }
+ break;
+
+ case WM_NETEVENT_TRANSFER:
+ if (netEvents & FD_READ)
+ {
+ ioctlsocket(hSocket, FIONREAD, &result);
+ if (result > 0) icq.recvTransferTCP(hSocket);
+ }
+ if (netEvents & FD_CLOSE)
+ {
+ unsigned int i;
+ for (i=0; i<icqTransfers.size(); i++)
+ {
+ if (hSocket == icqTransfers[i]->socket.handleVal)
+ {
+ T("[tcp] user %d is aborted file connection\n", icqTransfers[i]->uin);
+ ProtoBroadcastAck(protoName, icqTransfers[i]->hContact, ACKTYPE_FILE, ACKRESULT_FAILED, icqTransfers[i], 0);
+ delete icqTransfers[i];
+ icqTransfers[i] = icqTransfers[icqTransfers.size() - 1];
+ icqTransfers.pop_back();
+ break;
+ }
+ }
+ }
+ break;
+
+ default:
+ return DefWindowProc(hWnd, msg, wParam, lParam);
+ }
+
+ return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void WINAPI pingTimerProc(HWND hWnd, UINT Msg, UINT_PTR hTimer, DWORD Time)
+{
+ icq.ping();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// ICQ
+//
+///////////////////////////////////////////////////////////////////////////////
+
+ICQ::ICQ() :
+ tcpSocket(WM_NETEVENT_CONNECTION),
+ udpSocket(WM_NETEVENT_SERVER)
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool ICQ::load()
+{
+ WSADATA data;
+
+ if (WSAStartup(MAKEWORD(2,2), &data))
+ {
+ MessageBox(NULL, Translate("ICQ Corporate plugin used only WinSock v2.2 or later."), protoName, MB_ICONWARNING|MB_OK);
+ return false;
+ }
+
+ statusVal = ID_STATUS_OFFLINE;
+ searchSequenceVal = 0;
+ tcpSequenceVal = 0xFFFFFFFE;
+
+ awayMessage = new char[1];
+ awayMessage[0] = 0;
+
+ WNDCLASS wc = { 0, messageWndProc, 0, 0, hInstance, NULL, NULL, NULL, NULL, protoName };
+ if (!RegisterClass(&wc)) return false;
+
+ hWnd = CreateWindowEx(0, protoName, NULL, 0, 0, 0, 0, 0, (unsigned short)GetVersion() >= 5 ? HWND_MESSAGE : 0, NULL, hInstance, NULL);
+ if (hWnd == NULL) return false;
+
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::unload()
+{
+ if (statusVal != ID_STATUS_OFFLINE) logoff(false);
+
+ KillTimer(NULL, pingTimer);
+ pingTimer = NULL;
+
+ delete [] awayMessage;
+
+ WSACleanup();
+
+ DestroyWindow(hWnd);
+ UnregisterClass(protoName, hInstance);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool ICQ::logon(unsigned short logonStatus)
+{
+ DBVARIANT dbv;
+ char str[128];
+
+ if(!db_get(NULL, protoName, "Server", &dbv))
+ {
+ lstrcpy(str, dbv.pszVal);
+ db_free(&dbv);
+ }
+ else
+ {
+ MessageBox(NULL, Translate("You need specify ICQ Corporate login server."), protoName, MB_ICONWARNING|MB_OK);
+ return false;
+ }
+
+ if (!tcpSocket.connected() && !tcpSocket.startServer()) return false;
+ if (!udpSocket.connected())
+ {
+ if (!udpSocket.setDestination(str, db_get_w(NULL, protoName, "Port", 4000))) return false;
+ udpSocket.openConnection();
+ }
+
+ if (pingTimer == NULL) pingTimer = SetTimer(NULL, 0, PING_FREQUENCY, (TIMERPROC)pingTimerProc);
+
+ updateContactList();
+
+ uin = db_get_dw(NULL, protoName, "UIN", 0);
+ if (!db_get(NULL, protoName, "Password", &dbv))
+ {
+ lstrcpy(str, dbv.pszVal);
+ db_free(&dbv);
+ }
+
+
+ timeStampLastMessage = 0;
+ sequenceVal = 1;
+
+ Packet loginPacket;
+ loginPacket << ICQ_VERSION
+ << ICQ_CMDxSND_LOGON
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << tcpSocket.localPortVal
+ << str
+ << (unsigned short)0x7A
+ << (unsigned short)0x02
+// << LOCALHOST
+ << udpSocket.localIPVal
+ << (unsigned char)0x04
+ << (unsigned int)toIcqStatus(logonStatus)
+ << (unsigned int)0x02
+ << (unsigned int)0x00
+ << (unsigned short)0x13
+ << (unsigned short)0x7A;
+
+ T("[udp] requesting logon (%d)...\n", sequenceVal);
+ sendICQ(udpSocket, loginPacket, ICQ_CMDxSND_LOGON, sequenceVal);
+
+ desiredStatus = logonStatus;
+ statusVal = ID_STATUS_CONNECTING;
+ ProtoBroadcastAck(protoName, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)ID_STATUS_OFFLINE, statusVal);
+
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::logoff(bool reconnect)
+{
+ unsigned int i;
+
+ // if not connected then don't both logging off
+ if (udpSocket.connected())
+ {
+ Packet logoffPacket;
+ logoffPacket << ICQ_VERSION
+ << ICQ_CMDxSND_LOGOFF
+ << (unsigned int)0x00
+ << uin
+ << (unsigned int)0x00
+ << "B_USER_DISCONNECTED"
+ << (unsigned short)0x0005;
+
+ T("[udp] logging off.\n");
+ udpSocket.sendPacket(logoffPacket);
+// udpSocket.closeConnection();
+
+ // close all open events
+ for (i=0; i<icqEvents.size(); i++) delete icqEvents[i];
+ icqEvents.clear();
+ }
+
+ statusVal = ID_STATUS_OFFLINE;
+
+ if (reconnect) logon(desiredStatus);
+ else
+ {
+ udpSocket.closeConnection();
+ tcpSocket.closeConnection();
+
+ updateContactList();
+ ProtoBroadcastAck(protoName, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)ID_STATUS_ONLINE, statusVal);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::ping()
+{
+ if (statusVal > ID_STATUS_OFFLINE)
+ {
+ Packet pingPacket;
+ pingPacket << ICQ_VERSION
+ << ICQ_CMDxSND_PING
+ << sequenceVal
+ << (unsigned short)0x00
+ << uin
+ << (unsigned int)0x00;
+
+ T("[udp] keep alive (%d)\n", sequenceVal);
+ sendICQ(udpSocket, pingPacket, ICQ_CMDxSND_PING, sequenceVal);
+ }
+
+ if (statusVal == ID_STATUS_OFFLINE && desiredStatus != ID_STATUS_OFFLINE) logoff(true);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQEvent *ICQ::sendICQ(Socket &socket, Packet &packet, unsigned short cmd, unsigned long sequence,
+ unsigned long uin, unsigned short subCmd, int reply)
+{
+ ICQEvent *result;
+
+ if (!socket.connected()) return NULL;
+
+ if (cmd != ICQ_CMDxTCP_START) sequenceVal++;
+
+ icqEvents.push_back(result = new ICQEvent(cmd, subCmd, sequence, uin, &socket, &packet, reply));
+ if (!result->start())
+ {
+ cancelEvent(result);
+ return NULL;
+ }
+ return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::doneEvent(bool gotAck, int hSocket, int sequence)
+{
+ unsigned int i;
+ ICQEvent *e;
+
+ for (i=0; i<icqEvents.size(); i++)
+ {
+ e = icqEvents[i];
+ if (e->isEvent(hSocket, sequence)) break;
+ }
+ if (i == icqEvents.size()) return;
+
+ e->stop();
+ if (!gotAck || e->reply == 0)
+ {
+ icqEvents[i] = icqEvents[icqEvents.size() - 1];
+ icqEvents.pop_back();
+ }
+
+ if (!gotAck) T("[ ] sending failed (%d)\n", sequence);
+
+ switch (e->cmd)
+ {
+ case ICQ_CMDxTCP_START:
+ doneUserFcn(gotAck, e);
+ break;
+ case ICQ_CMDxSND_THRUxSERVER:
+ doneUserFcn(gotAck, e);
+ break;
+ case ICQ_CMDxSND_USERxGETxINFO:
+ //emit doneUserInfo(true, e->uin);
+ break;
+ case ICQ_CMDxSND_SETxSTATUS:
+ if (gotAck)
+ {
+ int oldStatus = statusVal;
+ statusVal = desiredStatus;
+ ProtoBroadcastAck(protoName, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, statusVal);
+ }
+ break;
+ case ICQ_CMDxSND_PING:
+ //if (!gotAck) emit doneOwnerFcn(false, cmd);
+ break;
+ case ICQ_CMDxSND_USERxADD:
+ //if (!gotAck) emit doneOwnerFcn(false, cmd);
+ break;
+ case ICQ_CMDxSND_AUTHORIZE:
+ //emit doneOwnerFcn(gotAck, cmd);
+ break;
+ case ICQ_CMDxSND_LOGON:
+ if (!gotAck)
+ {
+ logoff(false);
+ //emit doneOwnerFcn(false, cmd);
+ }
+ break;
+ case ICQ_CMDxSND_USERxLIST:
+ //if (!gotAck) emit doneOwnerFcn(false, cmd);
+ break;
+ case ICQ_CMDxSND_VISxLIST:
+ //if (!gotAck) emit doneOwnerFcn(false, cmd);
+ break;
+ case ICQ_CMDxSND_SYSxMSGxREQ:
+ //if (!gotAck) emit doneOwnerFcn(false, cmd);
+ break;
+ case ICQ_CMDxSND_SYSxMSGxDONExACK:
+ //if (!gotAck) emit doneOwnerFcn(false, cmd);
+ break;
+ }
+
+ if (!gotAck && e->cmd != ICQ_CMDxTCP_START && e->cmd != ICQ_CMDxSND_LOGON) logoff(true);
+
+
+ if (!gotAck || e->reply == 0) delete e;
+
+ else e->reply--;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::cancelEvent(ICQEvent *&e)
+{
+ unsigned int i;
+
+ for (i=0; i<icqEvents.size(); i++) if (icqEvents[i] == e) break;
+ if (i == icqEvents.size()) return;
+
+ e->stop();
+
+ icqEvents[i] = icqEvents[icqEvents.size() - 1];
+ icqEvents.pop_back();
+
+ delete e;
+ e = NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+unsigned short ICQ::processUdpPacket(Packet &packet)
+{
+ unsigned short version, command, newCommand, theSequence, theSequence1, searchSequence, junkShort;
+ unsigned int checkUin, userIP, realIP, junkl, newStatus, userPort, timedataStamp;
+ unsigned char junkChar;
+ char *message = NULL;
+ ICQUser *u;
+ ICQEvent *e;
+
+ // read in the standard UDP header info
+ packet >> version
+ >> command
+ >> theSequence
+ >> theSequence1
+ >> checkUin
+ >> junkl;
+
+ if (version != ICQ_VERSION)
+ {
+ T("[udp] bad version number %d\n", version);
+ return 0xFFFF;
+ }
+/* on offline multi packet field checkUin not equal uin :(
+
+ if (checkUin != uin)
+ {
+ T("[udp] bad uin number %d\n", checkUin);
+ return 0xFFFF;
+ }
+*/
+ switch (command)
+ {
+ case ICQ_CMDxRCV_LOGIN_ERR:
+ T("[udp] error loging to server.\n");
+ ackUDP(theSequence);
+
+ packet >> message;
+
+ T("%s\n", message);
+ MessageBox(NULL, message, protoName, MB_ICONERROR|MB_OK);
+ delete [] message;
+ break;
+
+ case ICQ_CMDxRCV_USERxONLINE: // initial user status packet
+ packet >> checkUin;
+
+ T("[udp] user %d is online\n", checkUin);
+ ackUDP(theSequence);
+
+ if ((u = getUserByUIN(checkUin, false)) == NULL) break;
+
+ packet >> userIP
+ >> userPort
+ >> realIP
+ >> junkChar
+ >> newStatus;
+
+ u->socket.closeConnection();
+ u->socket.setDestination(userIP, userPort);
+ u->setStatus(toIdStatus(newStatus));
+ u->setInfo("IP", (unsigned int)ntohl(userIP));
+ u->setInfo("Port", (unsigned short)userPort);
+ u->setInfo("RealIP", (unsigned int)ntohl(realIP));
+ break;
+
+ case ICQ_CMDxRCV_USERxOFFLINE: // user just went offline packet
+ packet >> checkUin;
+
+ T("[udp] user %d is offline\n", checkUin);
+ ackUDP(theSequence);
+
+ if ((u = getUserByUIN(checkUin, false)) == NULL) break;
+
+ u->setStatus(ID_STATUS_OFFLINE);
+ u->socket.closeConnection();
+ break;
+
+ case ICQ_CMDxRCV_USERxBASICxINFO:
+ case ICQ_CMDxRCV_USERxINFO:
+ case ICQ_CMDxRCV_USERxWORKxINFO:
+ case ICQ_CMDxRCV_USERxWORKxPAGE:
+ case ICQ_CMDxRCV_USERxHOMExINFO:
+ case ICQ_CMDxRCV_USERxHOMExPAGE:
+ T("[udp] user information packet (%d)\n", theSequence);
+ ackUDP(theSequence);
+
+ if ((e = getEvent(udpSocket.handleVal, theSequence1)) == NULL) break;
+ checkUin = e->uin;
+ if ((u = getUserByUIN(checkUin, false)) == NULL) break;
+
+ char *buffer;
+ buffer = new char[1024];
+
+ switch (command)
+ {
+ case ICQ_CMDxRCV_USERxBASICxINFO:
+ case ICQ_CMDxRCV_USERxINFO:
+ packet >> buffer;
+ u->setInfo("Nick", buffer);
+ packet >> buffer;
+ u->setInfo("FirstName", buffer);
+ packet >> buffer;
+ u->setInfo("LastName", buffer);
+ packet >> buffer;
+ u->setInfo("e-mail", buffer);
+ break;
+
+ case ICQ_CMDxRCV_USERxWORKxINFO:
+ packet >> buffer;
+ u->setInfo("CompanyStreet", buffer);
+ packet >> buffer;
+ u->setInfo("CompanyCity", buffer);
+ packet >> buffer;
+ u->setInfo("CompanyState", buffer);
+ packet >> junkShort;
+ u->setInfo("CompanyCountry", junkShort);
+ packet >> buffer;
+ u->setInfo("Company", buffer);
+ packet >> buffer;
+ u->setInfo("CompanyPosition", buffer);
+ packet >> junkl;
+ packet >> buffer;
+ u->setInfo("CompanyPhone", buffer);
+ packet >> buffer;
+ u->setInfo("CompanyFax", buffer);
+ packet >> buffer;
+ packet >> junkl;
+ if (junkl && junkl != 0xFFFFFFFF) _itoa(junkl, buffer, 10);
+ else buffer[0] = 0;
+ u->setInfo("CompanyZIP", buffer);
+ break;
+
+ case ICQ_CMDxRCV_USERxWORKxPAGE:
+ packet >> buffer;
+ u->setInfo("CompanyHomepage", buffer);
+ break;
+
+ case ICQ_CMDxRCV_USERxHOMExINFO:
+ packet >> buffer;
+ u->setInfo("Street", buffer);
+ packet >> buffer;
+ u->setInfo("City", buffer);
+ packet >> buffer;
+ u->setInfo("State", buffer);
+ packet >> junkShort;
+ u->setInfo("Country", junkShort);
+ packet >> buffer;
+ u->setInfo("Phone", buffer);
+ packet >> buffer;
+ u->setInfo("Fax", buffer);
+ packet >> buffer;
+ u->setInfo("Cellular", buffer);
+ packet >> junkl;
+ if (junkl && junkl != 0xFFFFFFFF) _itoa(junkl, buffer, 10);
+ else buffer[0] = 0;
+ u->setInfo("ZIP", buffer);
+ packet >> junkChar;
+ if (junkChar == 1) junkChar = 'F';
+ if (junkChar == 2) junkChar = 'M';
+ u->setInfo("Gender", junkChar);
+ packet >> junkShort;
+ u->setInfo("Age", (unsigned char)junkShort);
+ packet >> junkChar;
+ u->setInfo("BirthDay", junkChar);
+ packet >> junkChar;
+ u->setInfo("BirthMonth", junkChar);
+ packet >> junkShort;
+ u->setInfo("BirthYear", junkShort);
+ break;
+
+ case ICQ_CMDxRCV_USERxHOMExPAGE:
+ packet >> buffer;
+ u->setInfo("Homepage", buffer);
+ break;
+ }
+
+ if (e->reply == 0) ProtoBroadcastAck(protoName, u->hContact, ACKTYPE_GETINFO, ACKRESULT_SUCCESS, 0, 0);
+ doneEvent(true, udpSocket.handleVal, theSequence1);
+ delete [] buffer;
+ break;
+
+ case ICQ_CMDxRCV_USERxINVALIDxUIN: // not a good uin
+ T("[udp] invalid uin\n");
+ ackUDP(theSequence);
+
+ if ((e = getEvent(udpSocket.handleVal, theSequence1)) == NULL) break;
+
+ checkUin = e->uin;
+ T("invalid uin: %d\n", checkUin);
+/*
+ delete icqEvents[i2];
+ icqEvents[i2] = icqEvents[icqEvents.size() - 1];
+ icqEvents.pop_back();
+*/
+ break;
+
+ case ICQ_CMDxRCV_USERxSTATUS: // user changed status packet
+ packet >> checkUin;
+
+ T("[udp] user %d changed status\n", checkUin);
+ ackUDP(theSequence);
+
+ packet >> newStatus;
+
+ if ((u = getUserByUIN(checkUin, false)) == NULL) break;
+ u->setStatus(toIdStatus(newStatus));
+ break;
+
+ case ICQ_CMDxRCV_USERxLISTxDONE: // end of user list
+ T("[udp] end of user list.\n");
+ ackUDP(theSequence);
+ break;
+
+ case ICQ_CMDxRCV_SEARCHxFOUND: // user found in search
+ T("[udp] search found user\n");
+ ackUDP(theSequence);
+
+ char *alias, *firstName, *lastName, *email;
+ unsigned char auth;
+
+ alias = NULL;
+ firstName = NULL;
+ lastName = NULL;
+ email = NULL;
+
+ packet >> checkUin
+ >> alias
+ >> firstName
+ >> lastName
+ >> email
+ >> auth;
+
+ ICQSEARCHRESULT isr;
+
+ isr.hdr.cbSize = sizeof(isr);
+ isr.hdr.nick = alias;
+ isr.hdr.firstName = firstName;
+ isr.hdr.lastName = lastName;
+ isr.hdr.email = email;
+ isr.uin = checkUin;
+ isr.auth = auth;
+ ProtoBroadcastAck(protoName, NULL, ACKTYPE_SEARCH, ACKRESULT_DATA, (HANDLE)1, (LPARAM)&isr);
+
+ delete [] alias;
+ delete [] firstName;
+ delete [] lastName;
+ delete [] email;
+ break;
+
+ case ICQ_CMDxRCV_SEARCHxDONE:
+ T("[udp] search finished.\n");
+ ackUDP(theSequence);
+
+ packet >> searchSequence;
+ searchSequence = theSequence1;
+
+ ProtoBroadcastAck(protoName, NULL, ACKTYPE_SEARCH, ACKRESULT_SUCCESS, (HANDLE)1, 0);
+ break;
+
+ case ICQ_CMDxRCV_SYSxMSGxOFFLINE: // offline system message, now have to check the sub-command
+ T("[udp] offline system message\n");
+ ackUDP(theSequence);
+
+ packet >> checkUin
+ >> timedataStamp
+ >> newCommand;
+
+ timeStampLastMessage = timedataStamp;
+ timedataStamp = CallService(MS_DB_TIME_TIMESTAMPTOLOCAL, timedataStamp, 0);
+
+ processSystemMessage(packet, checkUin, newCommand, timedataStamp);
+ break;
+
+ case ICQ_CMDxRCV_SYSxMSGxONLINE: // online system message, now have to check the sub-command
+ T("[udp] online system message\n");
+ ackUDP(theSequence);
+
+ packet >> checkUin
+ >> newCommand;
+
+ processSystemMessage(packet, checkUin, newCommand, time(NULL));
+ break;
+
+ case ICQ_CMDxRCV_SYSxMSGxDONE: // end of system messages
+ T("[udp] end of system messages.\n");
+ ackUDP(theSequence);
+
+ if (timeStampLastMessage)
+ {
+ ackSYS(timeStampLastMessage);
+ timeStampLastMessage = 0;
+ }
+ break;
+
+ case ICQ_CMDxRCV_BROADCASTxMULTI:
+ T("[udp] broadcast multi-packet (%d)\n", theSequence);
+ ackUDP(theSequence);
+
+ unsigned int i;
+ unsigned char j, frameNo, frameSize;
+ bool found;
+
+ packet >> frameNo
+ >> frameSize;
+
+ icqEvents.push_back(new ICQEvent(ICQ_CMDxRCV_BROADCASTxMULTI, (unsigned short)frameNo, theSequence1, 0, &udpSocket, &packet, 0));
+
+ {
+ Packet multiPacket;
+
+ for (j=0; j<frameSize; j++)
+ {
+ found = false;
+ for (i=0; i<icqEvents.size(); i++)
+ {
+ e = icqEvents[i];
+ if (e->cmd == ICQ_CMDxRCV_BROADCASTxMULTI && e->subCmd == j && e->isEvent(udpSocket.handleVal, theSequence1))
+ {
+ multiPacket << e->packet;
+ found = true;
+ break;
+ }
+ }
+ if (!found) break;
+ }
+
+ if (j == frameSize)
+ {
+ for (i=0; i<icqEvents.size(); i++)
+ {
+ e = icqEvents[i];
+ if (e->cmd == ICQ_CMDxRCV_BROADCASTxMULTI && e->isEvent(udpSocket.handleVal, theSequence1))
+ {
+ icqEvents[i] = icqEvents[icqEvents.size() - 1];
+ icqEvents.pop_back();
+
+ delete e;
+ }
+ }
+
+ multiPacket.reset();
+ processUdpPacket(multiPacket);
+ }
+ }
+ break;
+
+ case ICQ_CMDxRCV_BROADCASTxOFFLINE:
+ T("[udp] offline broadcast message (%d)\n", theSequence);
+ ackUDP(theSequence);
+
+ packet >> checkUin
+ >> timedataStamp
+ >> newCommand;
+
+ db_set_dw(NULL, protoName, "LastBroadcastTime", timedataStamp);
+ timedataStamp = CallService(MS_DB_TIME_TIMESTAMPTOLOCAL, timedataStamp, 0);
+
+ processSystemMessage(packet, checkUin, newCommand, timedataStamp);
+ break;
+
+ case ICQ_CMDxRCV_BROADCASTxONLINE:
+ T("[udp] online broadcast message (%d)\n", theSequence);
+ ackUDP(theSequence);
+
+ packet >> checkUin
+ >> newCommand;
+
+ processSystemMessage(packet, checkUin, newCommand, time(NULL));
+ break;
+
+ case ICQ_CMDxRCV_BROADCASTxDONE:
+ T("[udp] end of broadcast messages.\n");
+ ackUDP(theSequence);
+ break;
+
+ case ICQ_CMDxRCV_SETxOFFLINE: // we got put offline by mirabilis for some reason
+ T("[udp] kicked offline.\n");
+ logoff(true);
+ break;
+
+ case ICQ_CMDxRCV_ACK: // icq acknowledgement
+ T("[udp] received ack (%d)\n", theSequence);
+ doneEvent(true, udpSocket.handleVal, theSequence);
+ break;
+
+ case ICQ_CMDxRCV_ERROR: // icq says go away
+ T("[udp] server says bugger off.\n");
+ logoff(true);
+ break;
+
+ case ICQ_CMDxRCV_HELLO: // hello packet from mirabilis received on logon
+ T("[udp] received hello.\n");
+ ackUDP(theSequence);
+
+ int oldStatus;
+
+ requestSystemMsg();
+ requestBroadcastMsg();
+
+// pingTimer.start(PING_FREQUENCY * 1000);
+ oldStatus = statusVal;
+ statusVal = desiredStatus;
+ ProtoBroadcastAck(protoName, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, statusVal);
+
+ updateContactList();
+// sendVisibleList();
+// sendInvisibleList();
+ break;
+
+ case ICQ_CMDxRCV_WRONGxPASSWD: // incorrect password sent in logon
+ T("[udp] incorrect password.\n");
+ ProtoBroadcastAck(protoName, NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_WRONGPASSWORD);
+ MessageBox(NULL, Translate("Your ICQ Corp number and password combination was rejected by the ICQ Corporate server. Please go to M->Options->ICQCorp and try again."), protoName, MB_ICONERROR|MB_OK);
+ break;
+
+ case ICQ_CMDxRCV_BUSY: // server too busy to respond
+ T("[udp] server busy, try again in a few minutes.\n");
+ break;
+
+ default: // what the heck is this packet?
+ T("[udp] unknown packet:\n%s", packet.print());
+ ackUDP(theSequence);
+ break;
+ }
+
+ return command;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::processSystemMessage(Packet &packet, unsigned long checkUin, unsigned short newCommand, time_t timeSent)
+{
+ char *message/*, *sysMsg*/;
+ ICQUser *u;
+ unsigned int i, /*j,*/ messageLen;
+
+ u = getUserByUIN(checkUin);
+
+ message = NULL;
+ packet >> message;
+
+ switch (newCommand)
+ {
+ case ICQ_CMDxRCV_SYSxMSG:
+ T("message through server from %d\n", checkUin);
+ addMessage(u, message, ICQ_CMDxRCV_SYSxMSGxONLINE, ICQ_CMDxTCP_MSG, 0, timeSent);
+ break;
+
+ case ICQ_CMDxRCV_SYSxURL:
+ T("url through server from %d\n", checkUin);
+ addUrl(u, message, ICQ_CMDxRCV_SYSxMSGxONLINE, ICQ_CMDxTCP_URL, 0, timeSent);
+ break;
+
+ case ICQ_CMDxRCV_SYSxBROADCAST:
+ T("broadcast message from %d\n", checkUin);
+
+ messageLen = (unsigned int)strlen(message);
+ for (i=0; i<messageLen; i++) if (message[i] == (char)0xFE) message[i] = '\n';
+
+ addMessage(u, message, ICQ_CMDxRCV_SYSxMSGxONLINE, ICQ_CMDxTCP_MSG, 0, timeSent);
+ break;
+/*
+ case ICQ_CMDxRCV_SYSxAUTHxREQ: // system message: authorisation request
+ // 02 00 04 01 08 00 8F 76 20 00 06 00 41 00 41 70 6F 74 68 65 6F 73 69 73
+ // FE 47 72 61 68 61 6D FE 52 6F 66 66 FE 67 72 6F 66 66 40 75 77 61 74 65
+ // 72 6C 6F 6F 2E 63 61 FE 31 FE 50 6C 65 61 73 65 20 61 75 74 68 6F 72 69
+ // 7A 65 20 6D 65 2E 00
+ T("authorization request from %ld.\n", checkUin);
+ packet >> messageLen;
+ message = new char[messageLen + 1];
+ for (i=0; i<=messageLen; i++)
+ {
+ packet >> message[i];
+ if (message[i] == (char)0xFE) message[i] = '\n';
+ }
+
+ sysMsg = new char[messageLen + 128];
+ sprintf(sysMsg, "(%s) Authorization request from %ld:\n%s", sm.timeRec(), checkUin, message);
+ icqOwner.addMessage(sysMsg, ICQ_CMDxRCV_SYSxMSGxONLINE, ICQ_CMDxRCV_SMxREQxAUTH, 0, timeSent);
+ sprintf(sysMsg, "Authorization request from %ld:\n%s", checkUin, message);
+ addToSystemMessageHistory(sysMsg);
+ playSound(soundSysMsg);
+ delete sysMsg;
+ delete message;
+ break;
+
+ case ICQ_CMDxRCV_SYSxAUTHxGRANTED: // system message: authorization granted
+
+ outputWindow->wprintf(" (%s) Authorization granted from %ld.", sm.timeRec(), checkUin);
+ packet >> messageLen;
+ message = new char[messageLen + 1];
+ for (i = 0; i <= messageLen; i++)
+ {
+ packet >> message[i];
+ if (message[i] == (char)0xFE) message[i] = '\n';
+ }
+
+ sysMsg = new char[messageLen + 128];
+ sprintf(sysMsg, "(%s) Authorization granted from %ld:\n%s", sm.timeRec(), checkUin, message);
+ icqOwner.addMessage(sysMsg, ICQ_CMDxRCV_SYSxMSGxONLINE, ICQ_CMDxRCV_SMxREQxAUTH, 0, timeSent);
+ sprintf(sysMsg, "Authorization granted from %ld:\n%s", checkUin, message);
+ addToSystemMessageHistory(sysMsg);
+ playSound(soundSysMsg);
+
+ delete sysMsg;
+ delete message;
+ break;
+*/
+/*
+ case ICQ_CMDxRCV_SYSxADDED: // system message: added to a contact list
+ outputWindow->wprintf(" %C(%s) user %C%ld%C added you to their contact list.", COLOR_RECEIVE, sm.timeRec(), COLOR_DATA, checkUin, COLOR_RECEIVE);
+ sysMsg = new char[128];
+ sprintf(sysMsg, "(%s) User %ld added you to their contact list.", sm.timeRec(), checkUin);
+ icqOwner.addMessage(sysMsg, ICQ_CMDxRCV_SYSxMSGxONLINE, ICQ_CMDxRCV_SMxADDED, 0, timeSent);
+ sprintf(sysMsg, "User %ld added you to their contact list.", checkUin);
+ addToSystemMessageHistory(sysMsg);
+ delete sysMsg;
+ playSound(soundSysMsg);
+*/
+ /* there is a bunch of info about the given user in the packet but the read routine to get
+ at it is totally broken right now
+ int infoLen, j;
+ packet >> infoLen;
+
+ // declare all the strings we will need for reading in the user data
+ char *userInfo, *aliasField, *firstNameField, *lastNameField, *emailField;
+ userInfo = new char[infoLen];
+ aliasField = new char[infoLen];
+ firstNameField = new char[infoLen];
+ lastNameField = new char[infoLen];
+ emailField = new char[infoLen];
+
+ // read in the user data from the packet
+ for (i = 0; i < infoLen; i++) packet >> userInfo[i];
+
+ // parse the user info string for the four fields
+ i = j = 0;
+ do { aliasField[j] = userInfo[i]; i++; j++;} while (userInfo[i] != (char)0xFE);
+ aliasField[j] = '\0'; j = 0;
+ do { firstNameField[j] = userInfo[i]; i++; j++;} while (userInfo[i] != (char)0xFE);
+ firstNameField[j] = '\0'; j = 0;
+ do { lastNameField[j] = userInfo[i]; i++; j++;} while (userInfo[i] != (char)0xFE);
+ lastNameField[j] = '\0'; j = 0;
+ do { emailField[j] = userInfo[i]; i++; j++;} while (i < infoLen);
+ emailField[j] = '\0';
+
+ *outputWindow << " " << aliasField << " (" << firstNameField << " " << lastNameField << "), " << emailField << ".";
+
+ delete userInfo; delete aliasField; delete firstNameField; delete lastNameField; delete emailField;
+ break;
+ */
+
+ default:
+ T("[udp] unknown system packet:\n%s", packet.print());
+ break;
+ }
+
+ delete [] message;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::ackUDP(unsigned short theSequence)
+{
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_ACK
+ << theSequence
+ << (unsigned short)0x00
+ << uin
+ << (unsigned int)0x00;
+
+ T("[udp] sending ack (%d)\n", theSequence);
+ udpSocket.sendPacket(packet);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::ackSYS(unsigned int timeStamp)
+{
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_SYSxMSGxDONExACK
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << timeStamp;
+
+ T("[udp] sending system message ack (%d)\n", sequenceVal);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_SYSxMSGxDONExACK, sequenceVal);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQUser *ICQ::getUserByUIN(unsigned long uin, bool allowAdd)
+{
+ unsigned long i;
+ ICQUser *u;
+
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ u = icqUsers[i];
+ if (u->uin == uin) return u;
+ }
+
+ if (allowAdd)
+ {
+ T("unknown user %d, adding them to your list\n", uin);
+ return addUser(uin, false);
+ }
+
+ T("ICQ sent unknown user %d\n", uin);
+ return NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQUser *ICQ::getUserByContact(MCONTACT hContact)
+{
+ unsigned long i;
+ ICQUser *u;
+
+// uin = db_get_dw(ccs->hContact, protoName, "UIN", 0);
+
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ u = icqUsers[i];
+ if (u->hContact == hContact) return u;
+ }
+ return NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::requestSystemMsg()
+{
+ // request offline system messages
+ // 02 00 4C 04 02 00 50 A5 82 00
+
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_SYSxMSGxREQ
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00;
+
+ T("[udp] sending offline system messages request (%d)...\n", sequenceVal);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_SYSxMSGxREQ, sequenceVal);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::requestBroadcastMsg()
+{
+ unsigned int timeStamp = db_get_dw(NULL, protoName, "LastBroadcastTime", 0);
+
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_BROADCASTxREQ
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << timeStamp
+ << (unsigned int)0x00;
+
+ T("[udp] sending offline broadcast messages request (%d)...\n", sequenceVal);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_SYSxMSGxREQ, sequenceVal);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool ICQ::setStatus(unsigned short newStatus)
+{
+ if (!udpSocket.connected()) return false;
+
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_SETxSTATUS
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << toIcqStatus(newStatus);
+
+ T("[udp] sending set status packet (%d)\n", sequenceVal);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_SETxSTATUS, sequenceVal);
+
+ desiredStatus = newStatus;
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::updateContactList()
+{
+ char *proto;
+ unsigned int i;
+ int userCount;
+ //HANDLE hContact;
+ ICQUser *u;
+
+ for (MCONTACT hContact = db_find_first(); hContact; hContact = db_find_next(hContact)) {
+ proto = (char*)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0);
+ if (proto && !strcmp(proto, protoName))
+ {
+ if ((u = getUserByContact(hContact)) == NULL)
+ {
+ u = new ICQUser();
+ u->hContact = hContact;
+ u->uin = db_get_dw(hContact, protoName, "UIN", 0);
+ icqUsers.push_back(u);
+ }
+ if (statusVal <= ID_STATUS_OFFLINE) u->setStatus(ID_STATUS_OFFLINE);
+ else u->statusVal = db_get_w(hContact, protoName, "Status", ID_STATUS_OFFLINE);
+ }
+ }
+
+ if (statusVal <= ID_STATUS_OFFLINE) return;
+
+
+ // create user info packet
+ Packet userPacket;
+ for (i=0; i<icqUsers.size(); )
+ {
+ userCount = (unsigned int)icqUsers.size() - i;
+ if (userCount > 100) userCount = 100;
+
+ userPacket.clearPacket();
+ userPacket << ICQ_VERSION
+ << ICQ_CMDxSND_USERxLIST
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << (unsigned char)userCount;
+
+ for (; userCount>0; userCount--) userPacket << icqUsers[i++]->uin;
+
+ // send user info packet
+ T("[udp] sending contact list (%d)...\n", sequenceVal);
+ sendICQ(udpSocket, userPacket, ICQ_CMDxSND_USERxLIST, sequenceVal);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::sendVisibleList()
+{
+/*
+ unsigned int i, numUsers = 0;
+ ICQUser *u;
+
+ if (statusVal != ID_STATUS_INVISIBLE) return;
+
+ Packet userPacket;
+ userPacket << ICQ_VERSION
+ << ICQ_CMDxSND_VISxLIST
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00;
+
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ u = icqUsers[i];
+ if (u->statusVal != ID_STATUS_OFFLINE && db_get_w(u->hContact, protoName, "ApparentMode", 0) == ID_STATUS_ONLINE)
+ numUsers++;
+ }
+
+ if (numUsers == 0) return;
+ userPacket << (char)numUsers;
+
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ u = icqUsers[i];
+ if (u->statusVal != ID_STATUS_OFFLINE && db_get_w(u->hContact, protoName, "ApparentMode", 0) == ID_STATUS_ONLINE)
+ userPacket << icqUsers[i]->uin;
+ }
+
+ T("[udp] sending visible list (%d)\n", sequenceVal);
+ sendICQ(udpSocket, userPacket, ICQ_CMDxSND_VISxLIST, sequenceVal);
+*/
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::sendInvisibleList()
+{
+/*
+ unsigned int i, numUsers = 0;
+
+ Packet userPacket;
+ userPacket << ICQ_VERSION
+ << ICQ_CMDxSND_INVISxLIST
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00;
+
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ if (db_get_w(icqUsers[i]->hContact, protoName, "ApparentMode", 0) == ID_STATUS_OFFLINE)
+ numUsers++;
+ }
+
+ if (numUsers == 0) return;
+ userPacket << (char)numUsers;
+
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ if (db_get_w(icqUsers[i]->hContact, protoName, "ApparentMode", 0) == ID_STATUS_OFFLINE)
+ userPacket << icqUsers[i]->uin;
+ }
+
+ T("[udp] sending invisible list (%d)\n", sequenceVal);
+ sendICQ(udpSocket, userPacket, ICQ_CMDxSND_INVISxLIST, sequenceVal);
+*/
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::updateUserList(ICQUser *u, char list, char add)
+{
+/*
+ Packet userPacket;
+ userPacket << ICQ_VERSION
+ << ICQ_CMDxSND_UPDATExLIST
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << u->uin
+ << list
+ << add;
+
+ T("[udp] update user list (%d)\n", sequenceVal);
+ sendICQ(udpSocket, userPacket, ICQ_CMDxSND_UPDATExLIST, sequenceVal);
+*/
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQUser *ICQ::addUser(unsigned int uin, bool persistent)
+{
+ unsigned int i;
+ ICQUser *u;
+
+ for (i=0; i<icqUsers.size(); i++)
+ {
+ u = icqUsers[i];
+ if (u->uin == uin)
+ {
+ if (persistent)
+ {
+ db_unset(u->hContact, "CList", "NotOnList");
+ db_unset(u->hContact, "CList", "Hidden");
+ }
+ return u;
+ }
+ }
+
+ u = new ICQUser();
+ u->uin = uin;
+ u->hContact = (MCONTACT)CallService(MS_DB_CONTACT_ADD, 0, 0);
+ icqUsers.push_back(u);
+
+ CallService(MS_PROTO_ADDTOCONTACT, (WPARAM)u->hContact, (LPARAM)protoName);
+ u->setInfo("UIN", uin);
+
+ if (persistent) getUserInfo(u, true);
+ else
+ {
+ db_set_b(u->hContact, "CList", "NotOnList", 1);
+ db_set_b(u->hContact, "CList", "Hidden", 1);
+ }
+
+ updateContactList();
+ return u;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::addNewUser(ICQUser *u)
+{
+/*
+ // update the users info from the server
+ if (statusVal != ICQ_STATUS_OFFLINE)
+ {
+ Packet packet; // alert server to new user
+
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_USERxADD
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << u->uin;
+
+ T("[udp] alerting server to new user (%d)...\n", sequenceVal);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_USERxADD, sequenceVal);
+
+// getUserInfo(u);
+ }
+*/
+ updateContactList();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::removeUser(ICQUser *u)
+{
+ unsigned int i;
+
+ for (i=0; i<icqUsers.size(); i++) if (icqUsers[i] == u) break;
+ if (i == icqUsers.size()) return;
+
+ icqUsers[i] = icqUsers[icqUsers.size() - 1];
+ icqUsers.pop_back();
+
+ delete u;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::startSearch(unsigned char skrit, unsigned char smode, char *sstring, unsigned int s)
+{
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_SEARCHxSTART
+ << sequenceVal
+ << (unsigned short)s
+// << (unsigned short)(icqOwner.sequence1())
+ << uin
+ << (unsigned int)0x00
+ << (unsigned char)0xFF
+ << skrit
+ << (unsigned char)0x00
+ << smode
+ << sstring;
+
+ T("[udp] starting search for user (%d)...\n", s);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_SEARCHxSTART, sequenceVal);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQEvent *ICQ::send(ICQUser *u, unsigned short cmd, char *cmdStr, char *m)
+{
+ ICQEvent *result;
+
+ if (u->statusVal > ID_STATUS_OFFLINE && (result = sendTCP(u, cmd, cmdStr, m)) != NULL) return result;
+ else return sendUDP(u, cmd, cmdStr, m);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool ICQ::openConnection(TCPSocket &socket)
+{
+ T("[tcp] connecting to %s on port %d...\n", inet_ntoa(*(in_addr*)&socket.remoteIPVal), socket.remotePortVal);
+ socket.openConnection();
+
+ if (!socket.connected())
+ {
+ T("[tcp] connect failed\n");
+ return false;
+ }
+
+ T("[tcp] connection successful\n");
+
+ Packet packet;
+// packet << ICQ_CMDxTCP_HANDSHAKE3
+ packet << (unsigned char)0xFF
+ << (unsigned int)0x02
+ << (unsigned int)0x00
+// << (unsigned long)tcpSocket.localPortVal
+ << uin
+ << socket.localIPVal
+ << socket.localIPVal
+ << (unsigned char)0x04
+ << (unsigned int)0x00;
+// << (unsigned long)tcpSocket.localPortVal;
+
+ T("[tcp] sending handshake\n");
+ if (!socket.sendPacket(packet))
+ {
+ T("[tcp] send failed\n");
+ return false;
+ }
+
+ T("[tcp] setup completed\n");
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQEvent *ICQ::sendTCP(ICQUser *u, unsigned short cmd, char *cmdStr, char *m)
+{
+ if (!u->socket.connected() && !openConnection(u->socket)) return NULL;
+
+ unsigned int status;
+ if (accept)
+ {
+ switch (statusVal)
+ {
+ case ID_STATUS_ONLINE: status = 0x00100000; break;
+ case ID_STATUS_FREECHAT: status = 0x00000000; break; // ??
+ case ID_STATUS_AWAY: status = 0x01100000; break;
+ case ID_STATUS_NA: status = 0x00100000; break;
+ case ID_STATUS_DND: status = 0x00100000; break;
+ case ID_STATUS_OCCUPIED: status = 0x02100000; break;
+ case ID_STATUS_INVISIBLE: status = 0x00900000; break; // ??
+ default: status = 0x00100000; break;
+ }
+ }
+ else status = 0x00000001;
+
+ Packet packet;
+ packet << uin
+ << (unsigned short)0x02 // ICQ_VERSION
+ << ICQ_CMDxTCP_START // ICQ_CMDxTCP_ACK, ICQ_CMDxTCP_START, ICQ_CMDxTCP_CANCEL
+ << (unsigned short)0x00
+ << uin
+ << cmd
+ << m
+ << udpSocket.localIPVal
+ << udpSocket.localIPVal
+ << tcpSocket.localPortVal
+ << (unsigned char)0x04
+ << status
+ << tcpSequenceVal--;
+
+ T("[tcp] sending %s (%d)\n", cmdStr, tcpSequenceVal + 1);
+ return sendICQ(u->socket, packet, ICQ_CMDxTCP_START, tcpSequenceVal + 1, u->uin, cmd);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQEvent *ICQ::sendUDP(ICQUser *u, unsigned short cmd, char *cmdStr, char *m)
+{
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_THRUxSERVER
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << u->uin
+ << cmd
+ << m;
+
+/* write for offline multi packet, but not work - little architecturial trouble:
+ one big packet must divided on several little packets and Miranda use returned ONE event for control process sending,
+ but not several events
+
+ if (packet.size() > 450)
+ {
+ unsigned int i, j = 0;
+ unsigned char c, frameNo, frameSize;
+
+ packet.reset();
+
+ frameSize = (packet.size()+449) / 450;
+ for (frameNo=0; frameNo<frameSize; frameNo++)
+ {
+ Packet frame;
+ frame << ICQ_VERSION
+ << ICQ_CMDxSND_MULTI
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << frameSize
+ << frameNo;
+
+ for (i=0; i<450 && j<packet.size(); i++, j++)
+ {
+ packet >> c;
+ frame << c;
+ }
+
+ T("[udp] sending %s through server, part %d of %d (%d)\n", cmdStr, frameNo, frameSize, sequenceVal);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_THRUxSERVER, sequenceVal, u->uin, cmd);
+ }
+ }
+ else
+*/
+ {
+ T("[udp] sending %s through server (%d)\n", cmdStr, sequenceVal);
+ return sendICQ(udpSocket, packet, ICQ_CMDxSND_THRUxSERVER, sequenceVal, u->uin, cmd);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQEvent *ICQ::sendMessage(ICQUser *u, char *m)
+{
+ return send(u, ICQ_CMDxTCP_MSG, "message", m);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQEvent *ICQ::sendUrl(ICQUser *u, char *url)
+{
+ unsigned int nameLen, descriptionLen;
+ char *m, *description;
+ ICQEvent *result;
+
+ nameLen = (unsigned int)strlen(url);
+ description = (char*)url + nameLen + 1;
+ descriptionLen = (unsigned int)strlen(description);
+
+ m = new char[nameLen + descriptionLen + 2];
+ strcpy(m, description);
+ strcpy(m + descriptionLen + 1, url);
+ m[descriptionLen] = (char)0xFE;
+
+ result = send(u, ICQ_CMDxTCP_URL, "url", m);
+ delete [] m;
+
+ return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQEvent *ICQ::sendReadAwayMsg(ICQUser *u)
+{
+ unsigned short cmd;
+
+ switch (u->statusVal)
+ {
+ case ID_STATUS_AWAY: cmd = ICQ_CMDxTCP_READxAWAYxMSG; break;
+ case ID_STATUS_DND: cmd = ICQ_CMDxTCP_READxDNDxMSG; break;
+ case ID_STATUS_NA: cmd = ICQ_CMDxTCP_READxNAxMSG; break;
+ case ID_STATUS_OCCUPIED: cmd = ICQ_CMDxTCP_READxOCCUPIEDxMSG; break;
+ case ID_STATUS_FREECHAT: cmd = ICQ_CMDxTCP_READxFREECHATxMSG; break;
+ default: return NULL;
+ }
+
+ return sendTCP(u, cmd, "away message request", "");
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ICQTransfer *ICQ::sendFile(ICQUser *u, char *description, char *filename, unsigned int size, char **files)
+{
+ if (!u->socket.connected() && !openConnection(u->socket)) return NULL;
+
+ unsigned int i;
+
+ ICQTransfer *transfer = new ICQTransfer(u, tcpSequenceVal);
+
+ for (i=0; files[i]; i++);
+ transfer->files = new char*[i + 1];
+ for (i=0; files[i]; i++) transfer->files[i] = _strdup(files[i]);
+ transfer->files[i] = 0;
+
+ transfer->description = _strdup(description);
+ transfer->count = i;
+ transfer->totalSize = size;
+
+ transfer->path = _strdup(files[0]);
+ *strrchr(transfer->path, '\\') = 0;
+
+ icqTransfers.push_back(transfer);
+ transfer->ack(ACKRESULT_SENTREQUEST);
+
+
+ unsigned short cmd = ICQ_CMDxTCP_FILE;
+ char *m = description;
+
+ unsigned int status;
+ if (accept)
+ {
+ switch (statusVal)
+ {
+ case ID_STATUS_ONLINE: status = 0x00100000; break;
+ case ID_STATUS_FREECHAT: status = 0x00000000; break; // ??
+ case ID_STATUS_AWAY: status = 0x01100000; break;
+ case ID_STATUS_NA: status = 0x00100000; break;
+ case ID_STATUS_DND: status = 0x00100000; break;
+ case ID_STATUS_OCCUPIED: status = 0x02100000; break;
+ case ID_STATUS_INVISIBLE: status = 0x00900000; break; // ??
+ default: status = 0x00100000; break;
+ }
+ }
+ else status = 0x00000001;
+
+ Packet packet;
+ packet << uin
+ << (unsigned short)0x02 // ICQ_VERSION
+ << ICQ_CMDxTCP_START // ICQ_CMDxTCP_ACK, ICQ_CMDxTCP_START, ICQ_CMDxTCP_CANCEL
+ << (unsigned short)0x00
+ << uin
+ << cmd
+ << m
+ << udpSocket.localIPVal
+ << udpSocket.localIPVal
+ << tcpSocket.localPortVal
+ << (unsigned char)0x04
+ << status;
+
+
+ packet << (unsigned int)0x00
+ << filename
+ << size
+ << (unsigned int)0x00;
+
+ packet << tcpSequenceVal--;
+
+ T("[tcp] sending file request (%d)\n", tcpSequenceVal + 1);
+ sendICQ(u->socket, packet, ICQ_CMDxTCP_START, tcpSequenceVal + 1, u->uin, cmd);
+ return transfer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::acceptFile(ICQUser *u, unsigned long hTransfer, char *path)
+{
+ unsigned int theSequence = hTransfer;
+ unsigned short cmd = ICQ_CMDxTCP_FILE;
+ char m[1] = { 0 };
+
+ unsigned long status;
+ if (accept)
+ {
+ switch (statusVal)
+ {
+ case ID_STATUS_ONLINE: status = 0x00100000; break;
+ case ID_STATUS_FREECHAT: status = 0x00000000; break; // ??
+ case ID_STATUS_AWAY: status = 0x01100000; break;
+ case ID_STATUS_NA: status = 0x00100000; break;
+ case ID_STATUS_DND: status = 0x00100000; break;
+ case ID_STATUS_OCCUPIED: status = 0x02100000; break;
+ case ID_STATUS_INVISIBLE: status = 0x00900000; break; // ??
+ default: status = 0x00100000; break;
+ }
+ }
+ else status = 0x00000001;
+
+ Packet packet;
+ packet << uin
+ << (unsigned short)0x02 // ICQ_VERSION
+ << ICQ_CMDxTCP_ACK // ICQ_CMDxTCP_ACK, ICQ_CMDxTCP_START, ICQ_CMDxTCP_CANCEL
+ << (unsigned short)0x00
+ << uin
+ << cmd
+ << m
+ << udpSocket.localIPVal
+ << udpSocket.localIPVal
+ << tcpSocket.localPortVal
+ << (unsigned char)0x04
+// << status;
+ << (unsigned int)0x00;
+
+ packet << (unsigned int)htons(tcpSocket.localPortVal)
+ << m
+ << (unsigned int)0x00
+ << tcpSocket.localPortVal;
+
+ packet << theSequence;
+
+ T("[tcp] sending accept file ack (%d)\n", theSequence);
+ u->socket.sendPacket(packet);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::refuseFile(ICQUser *u, unsigned long hTransfer, char *reason)
+{
+ unsigned int theSequence = hTransfer;
+ unsigned short cmd = ICQ_CMDxTCP_FILE;
+ char m[1] = { 0 };
+
+ unsigned int status;
+ if (accept)
+ {
+ switch (statusVal)
+ {
+ case ID_STATUS_ONLINE: status = 0x00100000; break;
+ case ID_STATUS_FREECHAT: status = 0x00000000; break; // ??
+ case ID_STATUS_AWAY: status = 0x01100000; break;
+ case ID_STATUS_NA: status = 0x00100000; break;
+ case ID_STATUS_DND: status = 0x00100000; break;
+ case ID_STATUS_OCCUPIED: status = 0x02100000; break;
+ case ID_STATUS_INVISIBLE: status = 0x00900000; break; // ??
+ default: status = 0x00100000; break;
+ }
+ }
+ else status = 0x00000001;
+
+ Packet packet;
+ packet << uin
+ << (unsigned short)0x02 // ICQ_VERSION
+ << ICQ_CMDxTCP_ACK // ICQ_CMDxTCP_ACK, ICQ_CMDxTCP_START, ICQ_CMDxTCP_CANCEL
+ << (unsigned short)0x00
+ << uin
+ << cmd
+ << reason
+ << udpSocket.localIPVal
+ << udpSocket.localIPVal
+ << tcpSocket.localPortVal
+ << (unsigned char)0x04
+// << status;
+ << (unsigned int)0x00000001;
+
+ packet << (unsigned int)0x00
+ << m
+ << (unsigned int)0x00
+ << (unsigned int)0x00;
+
+ packet << theSequence;
+
+ T("[tcp] sending refuse file ack (%d)\n", theSequence);
+ u->socket.sendPacket(packet);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool ICQ::getUserInfo(ICQUser *u, bool basicInfo)
+{
+ unsigned short cmd = basicInfo ? ICQ_CMDxSND_USERxGETxBASICxINFO : ICQ_CMDxSND_USERxGETxINFO;
+
+ Packet request;
+ request << ICQ_VERSION
+ << cmd
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << u->uin;
+
+ T("[udp] sending user %s info request (%d)...\n", basicInfo ? "basic" : "details", sequenceVal);
+ sendICQ(udpSocket, request, cmd, sequenceVal, u->uin, 0, basicInfo ? 1 : 5);
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::authorize(unsigned int uinToAuthorize)
+{
+ Packet packet;
+ packet << ICQ_VERSION
+ << ICQ_CMDxSND_AUTHORIZE
+ << sequenceVal
+ << sequenceVal
+ << uin
+ << (unsigned int)0x00
+ << uinToAuthorize
+ << (unsigned int)0x00010008 // who knows, seems to be constant
+ << (unsigned char)0x00;
+
+ T("[udp] sending authorization (%d)\n", sequenceVal);
+ sendICQ(udpSocket, packet, ICQ_CMDxSND_AUTHORIZE, sequenceVal);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::processTcpPacket(Packet &packet, unsigned int hSocket)
+{
+ unsigned int i, checkUin, senderIp, localIp, userStatus, senderPort, junkLong, thePort, theTCPSequence;
+ unsigned short version, command, junkShort, newCommand, /*messageLen,*/ cicqVersion;
+ unsigned char cicqChar, junkChar;
+ char *message = NULL;
+ ICQUser *u;
+ static unsigned int chatUin, chatSequence;
+
+ packet >> checkUin
+ >> version
+ >> command // so far either message stuff or message ack
+ >> junkShort // 00 00 to fill in the MSB of the command long int which is read in as a short
+ >> checkUin
+ >> newCommand // if a message then what type, message/chat/read away message/...
+ >> message
+ >> senderIp
+ >> localIp
+ >> senderPort
+ >> junkChar
+ >> userStatus;
+
+ u = getUserByUIN(checkUin);
+ switch(command)
+ {
+ case ICQ_CMDxTCP_START: // incoming tcp packet containing one of many possible things
+ switch(newCommand) // do a switch on what it could be
+ {
+ case ICQ_CMDxTCP_MSG: // straight message from a user
+ T("[tcp] message from %d.\n", checkUin);
+
+ packet >> theTCPSequence;
+
+ ackTCP(packet, u, newCommand, theTCPSequence);
+ addMessage(u, message, ICQ_CMDxTCP_START, ICQ_CMDxTCP_MSG, theTCPSequence, time(NULL));
+ break;
+
+ case ICQ_CMDxTCP_CHAT:
+ T("[tcp] chat request from %d.\n", checkUin);
+
+ packet >> junkLong
+ >> junkLong
+ >> junkShort
+ >> junkChar
+ >> theTCPSequence
+ >> cicqChar
+ >> cicqVersion;
+/*
+ char *chatReq;
+ chatReq = new char[messageLen + 32];
+ sprintf(chatReq, "Chat request:\n %s", message);
+// u->addMessage(chatReq, ICQ_CMDxTCP_START, ICQ_CMDxTCP_CHAT, theTCPSequence, 0, (cicqChar == 'C'), cicqVersion);
+ delete chatReq;
+*/
+ break;
+
+ case ICQ_CMDxTCP_URL: // url sent
+ T("[tcp] url from %d.\n", checkUin);
+
+ packet >> theTCPSequence;
+
+ ackTCP(packet, u, newCommand, theTCPSequence);
+ addUrl(u, message, ICQ_CMDxTCP_START, ICQ_CMDxTCP_URL, theTCPSequence, time(NULL));
+ break;
+
+ case ICQ_CMDxTCP_FILE:
+ unsigned int size;
+ char *fileName;
+
+ fileName = NULL;
+ packet >> junkLong
+ >> fileName
+ >> size
+ >> junkLong
+ >> theTCPSequence;
+
+ T("[tcp] file transfer request from %d (%d)\n", checkUin, theTCPSequence);
+
+ addFileReq(u, message, fileName, size, ICQ_CMDxTCP_START, ICQ_CMDxTCP_FILE, theTCPSequence, time(NULL));
+ delete [] fileName;
+ break;
+
+ case ICQ_CMDxTCP_READxAWAYxMSG: // read away message
+ case ICQ_CMDxTCP_READxOCCUPIEDxMSG:
+ case ICQ_CMDxTCP_READxNAxMSG:
+ case ICQ_CMDxTCP_READxDNDxMSG:
+ case ICQ_CMDxTCP_READxFREECHATxMSG:
+ T("[tcp] %d requested read of away message.\n", checkUin);
+
+ packet >> theTCPSequence;
+ ackTCP(packet, u, newCommand, theTCPSequence);
+ break;
+ }
+ break;
+
+ case ICQ_CMDxTCP_ACK: // message received packet
+ switch (newCommand)
+ {
+ case ICQ_CMDxTCP_MSG:
+ packet >> theTCPSequence;
+ break;
+
+ case ICQ_CMDxTCP_CHAT:
+ packet >> junkShort
+ >> junkChar
+ >> junkLong // port backwards
+ >> thePort // port to connect to for chat
+ >> theTCPSequence;
+
+ if (chatSequence != theTCPSequence || chatUin != checkUin) // only if this is the first chat ack packet
+ { // do we do anything
+ chatSequence = theTCPSequence;
+ chatUin = checkUin;
+// emit eventResult(u, ICQ_CMDxTCP_CHAT, userStatus == 0x0000 ? true : false, thePort);
+ }
+ break;
+
+ case ICQ_CMDxTCP_URL:
+ packet >> theTCPSequence;
+ break;
+
+ case ICQ_CMDxTCP_FILE:
+ packet >> junkLong
+ >> junkShort
+ >> junkChar
+ >> junkLong
+ >> thePort
+ >> theTCPSequence;
+
+ T("[tcp] file transfer ack from %d (%d)\n", u->uin, theTCPSequence);
+
+ ICQTransfer *t;
+ for (i=0; i<icqTransfers.size(); i++)
+ {
+ t = icqTransfers[i];
+ if (t->uin == checkUin && !t->socket.connected())
+ {
+ if (userStatus != 0)
+ {
+ T("[tcp] file transfer denied by %d\n", checkUin);
+ ProtoBroadcastAck(protoName, t->hContact, ACKTYPE_FILE, ACKRESULT_DENIED, t, 0);
+ delete t;
+ icqTransfers[i] = icqTransfers[icqTransfers.size() - 1];
+ icqTransfers.pop_back();
+ break;
+ }
+
+ if (!t->socket.setDestination(u->socket.remoteIPVal, thePort))
+ {
+ T("[tcp] can't set destination\n");
+ break;
+ }
+ t->ack(ACKRESULT_CONNECTING);
+ if (openConnection(t->socket))
+ {
+ t->ack(ACKRESULT_CONNECTED);
+ t->sendPacket0x00();
+ }
+ break;
+ }
+ }
+ break;
+
+ case ICQ_CMDxTCP_READxAWAYxMSG:
+ case ICQ_CMDxTCP_READxOCCUPIEDxMSG:
+ case ICQ_CMDxTCP_READxNAxMSG:
+ case ICQ_CMDxTCP_READxDNDxMSG:
+ case ICQ_CMDxTCP_READxFREECHATxMSG:
+ packet >> theTCPSequence;
+ addAwayMsg(u, message, ICQ_CMDxTCP_START, ICQ_CMDxTCP_READxAWAYxMSG, theTCPSequence, time(NULL));
+ break;
+ }
+
+ // output the away message if there is one (ie if user status is not online)
+ if (userStatus == 0x0000) T("[tcp] ack from %d (%d).\n", u->uin, theTCPSequence);
+ else if (userStatus == 0x0001)
+ {
+ T("[tcp] refusal from %d (%d): %s\n", u->uin, theTCPSequence, message);
+ }
+ else
+ {
+// u->setAwayMessage(message);
+ T("[tcp] ack from %d (%d).\n", u->uin, theTCPSequence);
+// T("[tcp] ack from %d (%ld): %s\n", u->uin, theTCPSequence, message);
+ }
+
+ doneEvent(true, hSocket, theTCPSequence);
+ break;
+
+ case ICQ_CMDxTCP_CANCEL:
+ switch (newCommand)
+ {
+ case ICQ_CMDxTCP_CHAT:
+ T("[tcp] chat request from %d (%d) cancelled.\n", checkUin, theTCPSequence);
+// u->addMessage(chatReq, ICQ_CMDxTCP_CANCEL, ICQ_CMDxTCP_CHAT, 0);
+ break;
+
+ case ICQ_CMDxTCP_FILE:
+ T("[tcp] file transfer request from %d (%d) cancelled.\n", u->uin, theTCPSequence);
+// u->addMessage(fileReq, ICQ_CMDxTCP_CANCEL, ICQ_CMDxTCP_FILE, 0);
+ break;
+ }
+ break;
+
+ default:
+ T("[tcp] unknown packet:\n%s", packet.print());
+ packet.reset();
+ }
+ delete [] message;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::ackTCP(Packet &packet, ICQUser *u, unsigned short newCommand, unsigned int theSequence)
+{
+ unsigned int status;
+
+ switch (statusVal)
+ {
+ case ID_STATUS_ONLINE: status = 0x00100000; break;
+ case ID_STATUS_FREECHAT: status = 0x00000000; break; // ??
+ case ID_STATUS_AWAY: status = 0x01100000; break;
+ case ID_STATUS_NA: status = 0x00100000; break;
+ case ID_STATUS_DND: status = 0x00100000; break;
+ case ID_STATUS_OCCUPIED: status = 0x02100000; break;
+ case ID_STATUS_INVISIBLE: status = 0x00900000; break; // ??
+ default: status = 0x00100000; break;
+ }
+
+ packet.clearPacket();
+ packet << uin
+ << (unsigned short)0x02
+ << (unsigned short)ICQ_CMDxTCP_ACK // ICQ_CMDxTCP_ACK, ICQ_CMDxTCP_START, ICQ_CMDxTCP_CANCEL
+ << (unsigned short)0x00
+ << uin
+ << newCommand
+ << awayMessage
+ << u->socket.localIPVal
+ << u->socket.localIPVal
+ << u->socket.localPortVal
+ << (unsigned char)0x04
+ << status
+ << theSequence;
+
+ T("[tcp] sending ack (%d)\n", theSequence);
+ u->socket.sendPacket(packet);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::recvUDP(int)
+{
+ Packet packet;
+
+ // mirabilis contacts us using udp on this server
+ if (udpSocket.receivePacket(packet)) processUdpPacket(packet);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::recvNewTCP(int)
+{
+ ICQUser *u;
+ Packet handshake;
+
+ // our tcp incoming server
+ TCPSocket newSocket(0);
+ tcpSocket.receiveConnection(newSocket);
+ newSocket.receivePacket(handshake);
+
+ unsigned int ulJunk, newUin, localHost;
+ unsigned short command, usJunk;
+ unsigned char ucJunk;
+
+ handshake >> command;
+
+ if (command != ICQ_CMDxTCP_HANDSHAKE && command != ICQ_CMDxTCP_HANDSHAKE2 && command != ICQ_CMDxTCP_HANDSHAKE3)
+ {
+ T("[tcp] garbage packet:\n%s", handshake.print());
+ handshake.reset();
+ }
+ else
+ {
+ handshake >> ulJunk
+ >> usJunk
+ >> ucJunk
+ >> newUin
+ >> localHost
+ >> localHost
+ >> ulJunk
+ >> ucJunk;
+
+ u = getUserByUIN(newUin);
+ if (!u->socket.connected())
+ {
+ T("[tcp] connection from uin %d.\n", newUin);
+ u->socket.transferConnectionFrom(newSocket);
+ }
+ else
+ {
+ unsigned int i;
+ ICQTransfer *t;
+
+ T("[tcp] file direct connection from uin %d.\n", newUin);
+ for (i=0; i<icqTransfers.size(); i++)
+ {
+ t = icqTransfers[i];
+ if (t->uin == newUin && !t->socket.connected()) t->socket.transferConnectionFrom(newSocket);
+ }
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::recvTCP(SOCKET hSocket)
+{
+ unsigned int i;
+ Packet packet;
+ ICQUser *u;
+
+ for(i=0; i<icqUsers.size(); i++)
+ {
+ u = icqUsers[i];
+ if (u->socket.handleVal == hSocket)
+ {
+ if (!u->socket.receivePacket(packet))
+ {
+ T("[tcp] connection to %d lost.\n", u->uin);
+ return;
+ }
+ processTcpPacket(packet, hSocket);
+ return;
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::recvTransferTCP(SOCKET hSocket)
+{
+ unsigned int i;
+ Packet packet;
+ ICQTransfer *transfer;
+
+ for(i=0; i<icqTransfers.size(); i++)
+ {
+ transfer = icqTransfers[i];
+ if (transfer->socket.handleVal == hSocket)
+ {
+ if (!transfer->socket.receivePacket(packet))
+ {
+// T("[tcp] connection to %d lost.\n", s->uin);
+ return;
+ }
+ transfer->processTcpPacket(packet);
+ return;
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::addMessage(ICQUser *u, char *m, unsigned short theCmd, unsigned short theSubCmd, unsigned long theSequence, time_t t)
+{
+ CCSDATA ccs;
+ PROTORECVEVENT pre;
+
+ T("message: %s\n", m);
+
+ ccs.hContact = u->hContact;
+ ccs.szProtoService = PSR_MESSAGE;
+ ccs.wParam = 0;
+ ccs.lParam = (LPARAM)⪯
+ pre.flags = 0;
+ pre.timestamp = t;
+ pre.szMessage = (char*)m;
+ pre.lParam = 0;
+ CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::addUrl(ICQUser *u, char *m, unsigned short theCmd, unsigned short theSubCmd, unsigned long theSequence, time_t t)
+{
+ unsigned int i, messageLen;
+ char *url;
+ CCSDATA ccs;
+ PROTORECVEVENT pre;
+
+ messageLen = lstrlen(m);
+ for (i=0; i<messageLen; i++) if (m[i] == (char)0xFE) m[i] = 0;
+
+ url = new char[messageLen + 1];
+ lstrcpy(url, m + lstrlen(m) + 1);
+ lstrcpy(url + lstrlen(url) + 1, m);
+
+ ccs.hContact = u->hContact;
+ ccs.szProtoService = PSR_URL;
+ ccs.wParam = 0;
+ ccs.lParam = (LPARAM)⪯
+ pre.flags = 0;
+ pre.timestamp = t;
+ pre.szMessage = url;
+ pre.lParam = 0;
+ CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs);
+
+ delete [] url;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::addAwayMsg(ICQUser *u, char *m, unsigned short theCmd, unsigned short theSubCmd, unsigned long theSequence, time_t t)
+{
+ CCSDATA ccs;
+ PROTORECVEVENT pre;
+
+ T("away msg: %s\n", m);
+
+ ccs.hContact = u->hContact;
+ ccs.szProtoService = PSR_AWAYMSG;
+ ccs.wParam = u->statusVal;
+ ccs.lParam = (LPARAM)⪯
+ pre.flags = 0;
+ pre.timestamp = t;
+ pre.szMessage = (char*)m;
+ pre.lParam = theSequence;
+ CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/*
+void ICQ::addAdded(ICQUser *u, char *m, unsigned short theCmd, unsigned short theSubCmd, unsigned long theSequence, time_t t)
+{
+ DBEVENTINFO dbei;
+ PBYTE pCurBlob;
+
+ //blob is: uin(DWORD), nick(ASCIIZ), first(ASCIIZ), last(ASCIIZ), email(ASCIIZ)
+ ZeroMemory(&dbei, sizeof(dbei));
+ dbei.cbSize=sizeof(dbei);
+ dbei.szModule="ICQ";
+ dbei.timestamp=TimestampLocalToGMT(YMDHMSToTime(year,month,day,hour,minute,0));
+ dbei.flags=0;
+ dbei.eventType=EVENTTYPE_ADDED;
+ dbei.cbBlob=sizeof(DWORD)+strlen(nick)+strlen(first)+strlen(last)+strlen(email)+4;
+ pCurBlob=dbei.pBlob=(PBYTE)malloc(dbei.cbBlob);
+ CopyMemory(pCurBlob,&uin,sizeof(DWORD)); pCurBlob+=sizeof(DWORD);
+ CopyMemory(pCurBlob,nick,strlen(nick)+1); pCurBlob+=strlen(nick)+1;
+ CopyMemory(pCurBlob,first,strlen(first)+1); pCurBlob+=strlen(first)+1;
+ CopyMemory(pCurBlob,last,strlen(last)+1); pCurBlob+=strlen(last)+1;
+ CopyMemory(pCurBlob,email,strlen(email)+1); pCurBlob+=strlen(email)+1;
+ CallService(MS_DB_EVENT_ADD,(WPARAM)(HANDLE)NULL,(LPARAM)&dbei);
+}
+*/
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::addFileReq(ICQUser *u, char *m, char *filename, unsigned long size, unsigned short theCmd, unsigned short theSubCmd, unsigned long theSequence, time_t t)
+{
+ CCSDATA ccs;
+ PROTORECVEVENT pre;
+ char *szBlob;
+/*
+ filetransfer *ft;
+
+ // Initialize a filetransfer struct
+ ft = new filetransfer;
+ memset(ft, 0, sizeof(filetransfer));
+ ft->status = 0;
+ ft->wCookie = wCookie;
+ ft->szFilename = _strdup(fileName);
+ ft->szDescription = _strdup(m);
+ ft->dwUin = u->uin;
+ ft->fileId = -1;
+ ft->dwTotalSize = size;
+ ft->nVersion = nVersion;
+ ft->TS1 = dwID1;
+ ft->TS2 = dwID2;
+*/
+ ICQTransfer *transfer = new ICQTransfer(u, theSequence);
+ transfer->description = _strdup(m);
+ transfer->totalSize = size;
+
+ icqTransfers.push_back(transfer);
+
+
+
+ // Send chain event
+ szBlob = new char[sizeof(DWORD) + strlen(filename) + strlen(m) + 2];
+
+ *(PDWORD)szBlob = (DWORD)transfer;
+ strcpy(szBlob + sizeof(DWORD), filename);
+ strcpy(szBlob + sizeof(DWORD) + strlen(filename) + 1, m);
+
+ ccs.hContact = u->hContact;
+ ccs.szProtoService = PSR_FILE;
+ ccs.wParam = 0;
+ ccs.lParam = (LPARAM)⪯
+ pre.flags = 0;
+ pre.timestamp = t;
+ pre.szMessage = szBlob;
+ pre.lParam = theSequence;
+ CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs);
+
+ delete [] szBlob;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ICQ::doneUserFcn(bool ack, ICQEvent *icqEvent)
+{
+ unsigned int type = 0;
+
+ if (icqEvent->subCmd == ICQ_CMDxTCP_MSG) type = ACKTYPE_MESSAGE;
+ if (icqEvent->subCmd == ICQ_CMDxTCP_URL) type = ACKTYPE_URL;
+
+ ProtoBroadcastAck(protoName, getUserByUIN(icqEvent->uin)->hContact, type, ack ? ACKRESULT_SUCCESS : ACKRESULT_FAILED, (HANDLE)icqEvent->sequence, 0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
|