// ---------------------------------------------------------------------------80 // ICQ plugin for Miranda Instant Messenger // ________________________________________ // // Copyright © 2000-2001 Richard Hughes, Roland Rabien, Tristan Van de Vreede // Copyright © 2001-2002 Jon Keating, Richard Hughes // Copyright © 2002-2004 Martin Öberg, Sam Kothari, Robert Rainwater // Copyright © 2004-2010 Joe Kucera // // 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. // // ----------------------------------------------------------------------------- // DESCRIPTION: // // Handles packets from Family 4 ICBM Messages // // ----------------------------------------------------------------------------- #include "icqoscar.h" void CIcqProto::handleMsgFam(BYTE *pBuffer, WORD wBufferLength, snac_header *pSnacHeader) { switch (pSnacHeader->wSubtype) { case ICQ_MSG_SRV_ERROR: // SNAC(4, 0x01) handleRecvServMsgError(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; case ICQ_MSG_SRV_REPLYICBM: // SNAC(4, 0x05) SRV_REPLYICBM handleReplyICBM(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; case ICQ_MSG_SRV_RECV: // SNAC(4, 0x07) handleRecvServMsg(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; case ICQ_MSG_SRV_MISSED_MESSAGE: // SNAC(4, 0x0A) handleMissedMsg(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; case ICQ_MSG_RESPONSE: // SNAC(4, 0x0B) handleRecvMsgResponse(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; case ICQ_MSG_SRV_ACK: // SNAC(4, 0x0C) Server acknowledgements handleServerAck(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; case ICQ_MSG_MTN: // SNAC(4, 0x14) Typing notifications handleTypingNotification(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; case ICQ_MSG_SRV_OFFLINE_REPLY: // SNAC(4, 0x17) Offline Messages response handleOffineMessagesReply(pBuffer, wBufferLength, pSnacHeader->wFlags, pSnacHeader->dwRef); break; default: NetLog_Server("Warning: Ignoring SNAC(x%02x,x%02x) - Unknown SNAC (Flags: %u, Ref: %u)", ICQ_MSG_FAMILY, pSnacHeader->wSubtype, pSnacHeader->wFlags, pSnacHeader->dwRef); break; } } static void setMsgChannelParams(CIcqProto *ppro, WORD wChan, DWORD dwFlags) { icq_packet packet; // Set message parameters for channel wChan (CLI_SET_ICBM_PARAMS) serverPacketInit(&packet, 26); packFNACHeader(&packet, ICQ_MSG_FAMILY, ICQ_MSG_CLI_SETPARAMS); packWord(&packet, wChan); // Channel packDWord(&packet, dwFlags); // Flags packWord(&packet, MAX_MESSAGESNACSIZE); // Max message snac size packWord(&packet, 0x03E7); // Max sender warning level packWord(&packet, 0x03E7); // Max receiver warning level packWord(&packet, CLIENTRATELIMIT); // Minimum message interval in seconds packWord(&packet, 0x0000); // Unknown ppro->sendServPacket(&packet); } void CIcqProto::handleReplyICBM(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwRef) { // we don't care about the stuff, just change the params DWORD dwFlags = 0x00000303; #ifdef DBG_CAPHTML dwFlags |= 0x00000400; #endif #ifdef DBG_CAPMTN dwFlags |= 0x00000008; #endif // Set message parameters for all channels (imitate ICQ 6) setMsgChannelParams(this, 0x0000, dwFlags); } void CIcqProto::handleRecvServMsg(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwRef) { DWORD dwUin; DWORD dwMsgID1; DWORD dwMsgID2; WORD wTLVCount; WORD wMessageFormat; uid_str szUID; if (wLen < 11) { // just do some basic packet checking NetLog_Server("Error: Malformed message thru server"); return; } // These two values are some kind of reference, we need to save // them to send file request responses for example unpackLEDWord(&buf, &dwMsgID1); // TODO: msg cookies should be main wLen -= 4; unpackLEDWord(&buf, &dwMsgID2); wLen -= 4; // The message type used: unpackWord(&buf, &wMessageFormat); // 0x0001: Simple message format wLen -= 2; // 0x0002: Advanced message format // 0x0004: 'New' message format // Sender UIN if (!unpackUID(&buf, &wLen, &dwUin, &szUID)) return; if (dwUin && IsOnSpammerList(dwUin)) { NetLog_Server("Ignored Message from known Spammer"); return; } if (wLen < 4) { // just do some basic packet checking NetLog_Server("Error: Malformed message thru server"); return; } // Warning level? buf += 2; wLen -= 2; // Number of following TLVs, until msg-format dependant TLVs unpackWord(&buf, &wTLVCount); wLen -= 2; if (wTLVCount > 0) { // Save current buffer pointer so we can calculate // how much data we have left after the chain read. BYTE *pBufStart = buf; oscar_tlv_chain *chain = readIntoTLVChain(&buf, wLen, wTLVCount); // This chain contains info that is filled in by the server. // TLV(1): unknown // TLV(2): date: on since // TLV(3): date: on since // TLV(4): unknown, usually 0000. Not in file-req or auto-msg-req // TLV(6): sender's status // TLV(F): a time in seconds, unknown disposeChain(&chain); // Update wLen wLen -= buf - pBufStart; } // This is where the format specific data begins switch (wMessageFormat) { case 1: // Simple message format handleRecvServMsgType1(buf, wLen, dwUin, szUID, dwMsgID1, dwMsgID2, dwRef); break; case 2: // Encapsulated messages handleRecvServMsgType2(buf, wLen, dwUin, szUID, dwMsgID1, dwMsgID2, dwRef); break; case 4: // Typed messages handleRecvServMsgType4(buf, wLen, dwUin, szUID, dwMsgID1, dwMsgID2, dwRef); break; default: NetLog_Server("Unknown format message thru server - Ref %u, Type: %u, UID: %s", dwRef, wMessageFormat, strUID(dwUin, szUID)); break; } } char* CIcqProto::convertMsgToUserSpecificUtf(HANDLE hContact, const char *szMsg) { WORD wCP = getSettingWord(hContact, "CodePage", m_wAnsiCodepage); char *usMsg = NULL; if (wCP != CP_ACP) usMsg = ansi_to_utf8_codepage(szMsg, wCP); return usMsg; } void CIcqProto::handleRecvServMsgType1(BYTE *buf, WORD wLen, DWORD dwUin, char *szUID, DWORD dwMsgID1, DWORD dwMsgID2, DWORD dwRef) { WORD wTLVType; WORD wTLVLen; BYTE* pMsgTLV; if (wLen < 4) { // just perform basic structure check NetLog_Server("Message (format %u) - Ignoring empty message", 1); return; } // Unpack the first TLV(2) unpackTypedTLV(buf, wLen, 2, &wTLVType, &wTLVLen, &pMsgTLV); NetLog_Server("Message (format %u) - UID: %s", 1, strUID(dwUin, szUID)); // It must be TLV(2) if (wTLVType == 2) { BYTE *pDataBuf = pMsgTLV; oscar_tlv_chain *pChain = readIntoTLVChain(&pDataBuf, wTLVLen, 0); // TLV(2) contains yet another TLV chain with the following TLVs: // TLV(1281): Capability // TLV(257): This TLV contains the actual message (can be fragmented) if (pChain) { oscar_tlv* pMessageTLV; oscar_tlv* pCapabilityTLV; WORD wMsgPart = 1; // Find the capability TLV pCapabilityTLV = pChain->getTLV(0x0501, 1); if (pCapabilityTLV && (pCapabilityTLV->wLen > 0)) { WORD wDataLen; BYTE *pDataBuf; wDataLen = pCapabilityTLV->wLen; pDataBuf = pCapabilityTLV->pData; if (wDataLen > 0) NetLog_Server("Message (format 1) - Message has %d caps.", wDataLen); } else NetLog_Server("Message (format 1) - No message cap."); { // Parse the message parts, usually only one 0x0101 TLV containing the message, // but in some cases there can be more 0x0101 TLVs containing message parts in // different encodings (just like the new format of Offline Messages). DWORD dwRecvTime; char* szMsg = NULL; CCSDATA ccs; PROTORECVEVENT pre = {0}; int bAdded; HANDLE hContact = HContactFromUID(dwUin, szUID, &bAdded); while (pMessageTLV = pChain->getTLV(0x0101, wMsgPart)) { // Loop thru all message parts if (pMessageTLV->wLen > 4) { WORD wMsgLen; BYTE *pMsgBuf; WORD wEncoding; WORD wCodePage; char *szMsgPart = NULL; int bMsgPartUnicode = FALSE; // The message begins with a encoding specification // The first WORD is believed to have the following meaning: // 0x00: US-ASCII // 0x02: Unicode UCS-2 Big Endian encoding // 0x03: local 8bit encoding pMsgBuf = pMessageTLV->pData; unpackWord(&pMsgBuf, &wEncoding); unpackWord(&pMsgBuf, &wCodePage); wMsgLen = pMessageTLV->wLen - 4; NetLog_Server("Message (format 1) - Part %d: Encoding is 0x%X, page is 0x%X", wMsgPart, wEncoding, wCodePage); switch (wEncoding) { case 2: // UCS-2 { WCHAR* usMsgPart = (WCHAR*)SAFE_MALLOC(wMsgLen + 2); unpackWideString(&pMsgBuf, usMsgPart, wMsgLen); usMsgPart[wMsgLen/sizeof(WCHAR)] = 0; szMsgPart = make_utf8_string(usMsgPart); if (!IsUSASCII(szMsgPart, strlennull(szMsgPart))) bMsgPartUnicode = TRUE; SAFE_FREE(&usMsgPart); break; } case 0: // us-ascii case 3: // ANSI default: { // Copy the message text into a new proper string. szMsgPart = (char*)SAFE_MALLOC(wMsgLen + 1); memcpy(szMsgPart, pMsgBuf, wMsgLen); szMsgPart[wMsgLen] = '\0'; break; } } // Check if the new part is compatible with the message if (!pre.flags && bMsgPartUnicode) { // make the resulting message utf-8 encoded - need to append utf-8 encoded part if (szMsg) { // not necessary to convert - appending first part, only set flags char *szUtfMsg = ansi_to_utf8_codepage(szMsg, getSettingWord(hContact, "CodePage", m_wAnsiCodepage)); SAFE_FREE(&szMsg); szMsg = szUtfMsg; } pre.flags = PREF_UTF; } if (!bMsgPartUnicode && pre.flags == PREF_UTF) { // convert message part to utf-8 and append char *szUtfPart = ansi_to_utf8_codepage((char*)szMsgPart, getSettingWord(hContact, "CodePage", m_wAnsiCodepage)); SAFE_FREE(&szMsgPart); szMsgPart = szUtfPart; } // Append the new message part szMsg = (char*)SAFE_REALLOC(szMsg, strlennull(szMsg) + strlennull(szMsgPart) + 1); strcat(szMsg, szMsgPart); SAFE_FREE(&szMsgPart); } wMsgPart++; } if (strlennull(szMsg)) { if (_strnicmp(szMsg, "", 6) == 0) { // strip HTML formating from AIM message szMsg = EliminateHtml(szMsg, strlennull(szMsg)); } if (!pre.flags && !IsUSASCII(szMsg, strlennull(szMsg))) { // message is Ansi and contains national characters, create Unicode part by codepage char *usMsg = convertMsgToUserSpecificUtf(hContact, szMsg); if (usMsg) { SAFE_FREE(&szMsg); szMsg = usMsg; pre.flags = PREF_UTF; } } dwRecvTime = (DWORD)time(NULL); { // Check if the message was received as offline cookie_offline_messages *cookie; if (!(dwRef & 0x80000000) && FindCookie(dwRef, NULL, (void**)&cookie)) { WORD wTimeTLVType, wTimeTLVLen; BYTE *pTimeTLV; cookie->nMessages++; unpackTypedTLV(buf, wLen, 0x16, &wTimeTLVType, &wTimeTLVLen, &pTimeTLV); if (pTimeTLV && wTimeTLVType == 0x16 && wTimeTLVLen == 4) { // found Offline timestamp BYTE *pBuf = pTimeTLV; unpackDWord(&pBuf, &dwRecvTime); NetLog_Server("Message (format %u) - Offline timestamp is %s", 1, time2text(dwRecvTime)); } SAFE_FREE((void**)&pTimeTLV); } } // Create and send the message event ccs.szProtoService = PSR_MESSAGE; ccs.hContact = hContact; ccs.wParam = 0; ccs.lParam = (LPARAM)⪯ pre.timestamp = dwRecvTime; pre.szMessage = (char *)szMsg; CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs); NetLog_Server("Message (format 1) received"); // Save tick value setSettingDword(ccs.hContact, "TickTS", time(NULL) - (dwMsgID1/1000)); } else NetLog_Server("Message (format %u) - Ignoring empty message", 1); SAFE_FREE(&szMsg); } // Free the chain memory disposeChain(&pChain); } else NetLog_Server("Failed to read TLV chain in message (format 1)"); } else NetLog_Server("Unsupported TLV (%u) in message (format %u)", wTLVType, 1); SAFE_FREE((void**)&pMsgTLV); } void CIcqProto::handleRecvServMsgType2(BYTE *buf, WORD wLen, DWORD dwUin, char *szUID, DWORD dwMsgID1, DWORD dwMsgID2, DWORD dwRef) { WORD wTLVType; WORD wTLVLen; BYTE *pDataBuf = NULL; BYTE *pBuf; if (wLen < 4) { NetLog_Server("Message (format %u) - Ignoring empty message", 2); return; } // Unpack the first TLV(5) unpackTypedTLV(buf, wLen, 5, &wTLVType, &wTLVLen, &pDataBuf); NetLog_Server("Message (format %u) - UID: %s", 2, strUID(dwUin, szUID)); pBuf = pDataBuf; // It must be TLV(5) if (wTLVType == 5) { WORD wCommand; oscar_tlv_chain* chain; oscar_tlv* tlv; DWORD q1,q2,q3,q4; if (wTLVLen < 26) { // just check if all basic data is there NetLog_Server("Message (format %u) - Ignoring empty message", 2); SAFE_FREE((void**)&pBuf); return; } unpackWord(&pDataBuf, &wCommand); wTLVLen -= 2; // Command 0x0000 - Normal message/file send request #ifdef _DEBUG // 0x0001 - Abort request NetLog_Server("Command is %u", wCommand); // 0x0002 - Acknowledge request #endif // Some stuff we don't use pDataBuf += 8; // dwID1 and dwID2 again wTLVLen -= 8; unpackDWord(&pDataBuf, &q1); unpackDWord(&pDataBuf, &q2); unpackDWord(&pDataBuf, &q3); unpackDWord(&pDataBuf, &q4); // Message Capability wTLVLen -= 16; if (CompareGUIDs(q1,q2,q3,q4, MCAP_SRV_RELAY_FMT)) { // we surely have at least 4 bytes for TLV chain HANDLE hContact = HContactFromUID(dwUin, szUID, NULL); if (wCommand == 1) { NetLog_Server("Cannot handle abort messages yet... :("); SAFE_FREE((void**)&pBuf); return; } if (wTLVLen < 4) { // just check if at least one tlv is there NetLog_Server("Message (format %u) - Ignoring empty message", 2); SAFE_FREE((void**)&pBuf); return; } // This TLV chain may contain the following TLVs: // TLV(A): Acktype 0x0000 - normal message // 0x0001 - file request / abort request // 0x0002 - file ack // TLV(F): Unknown // TLV(3): External IP // TLV(5): DC port (not to use for filetransfers) // TLV(0x2711): The next message level chain = readIntoTLVChain(&pDataBuf, wTLVLen, 0); if (!chain) { // sanity check NetLog_Server("Message (format %u) - Invalid data", 2); SAFE_FREE((void**)&pBuf); return; } WORD wAckType = chain->getWord(0x0A, 1); // Update the saved DC info (if contact already exists) if (hContact != INVALID_HANDLE_VALUE) { DWORD dwIP, dwExternalIP; WORD wPort; if (dwExternalIP = chain->getDWord(0x03, 1)) setSettingDword(hContact, "RealIP", dwExternalIP); if (dwIP = chain->getDWord(0x04, 1)) setSettingDword(hContact, "IP", dwIP); if (wPort = chain->getWord(0x05, 1)) setSettingWord(hContact, "UserPort", wPort); // Save tick value BYTE bClientID = getSettingByte(hContact, "ClientID", 0); if (bClientID == CLID_GENERIC || bClientID == CLID_ICQ6) setSettingDword(hContact, "TickTS", time(NULL) - (dwMsgID1/1000)); else setSettingDword(hContact, "TickTS", 0); } // Parse the next message level if (tlv = chain->getTLV(0x2711, 1)) { parseServRelayData(tlv->pData, tlv->wLen, hContact, dwUin, szUID, dwMsgID1, dwMsgID2, wAckType); } else { NetLog_Server("Warning, no 0x2711 TLV in message (format 2)"); } // Clean up disposeChain(&chain); } else if (CompareGUIDs(q1,q2,q3,q4, MCAP_REVERSE_DC_REQ)) { // Handle reverse DC request if (wCommand == 1) { NetLog_Server("Cannot handle abort messages yet... :("); SAFE_FREE((void**)&pBuf); return; } if (wTLVLen < 4) { // just check if at least one tlv is there NetLog_Server("Message (format %u) - Ignoring empty message", 2); SAFE_FREE((void**)&pBuf); return; } if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); SAFE_FREE((void**)&pBuf); return; } chain = readIntoTLVChain(&pDataBuf, wTLVLen, 0); if (!chain) { // Malformed packet NetLog_Server("Error: Malformed data in packet"); SAFE_FREE((void**)&pBuf); return; } WORD wAckType = chain->getWord(0x0A, 1); // Parse the next message level if (tlv = chain->getTLV(0x2711, 1)) { if (tlv->wLen == 0x1B) { BYTE *buf = tlv->pData; DWORD dwUin; unpackLEDWord(&buf, &dwUin); HANDLE hContact = HContactFromUIN(dwUin, NULL); if (hContact == INVALID_HANDLE_VALUE) { NetLog_Server("Error: %s from unknown contact %u", "Reverse Connect Request", dwUin); } else { DWORD dwIp, dwPort; WORD wVersion; BYTE bMode; unpackDWord(&buf, &dwIp); unpackLEDWord(&buf, &dwPort); unpackByte(&buf, &bMode); buf += 4; // unknown if (dwPort) buf += 4; // port, again? else unpackLEDWord(&buf, &dwPort); unpackLEWord(&buf, &wVersion); setSettingDword(hContact, "IP", dwIp); setSettingWord(hContact, "UserPort", (WORD)dwPort); setSettingByte(hContact, "DCType", bMode); setSettingWord(hContact, "Version", wVersion); if (wVersion > 6) { cookie_reverse_connect *pCookie = (cookie_reverse_connect*)SAFE_MALLOC(sizeof(cookie_reverse_connect)); unpackLEDWord(&buf, (DWORD*)&pCookie->ft); pCookie->dwMsgID1 = dwMsgID1; pCookie->dwMsgID2 = dwMsgID2; OpenDirectConnection(hContact, DIRECTCONN_REVERSE, (void*)pCookie); } else NetLog_Server("Warning: Unsupported direct protocol version in %s", "Reverse Connect Request"); } } else { NetLog_Server("Malformed %s", "Reverse Connect Request"); } } else { NetLog_Server("Warning, no 0x2711 TLV in message (format 2)"); } // Clean up disposeChain(&chain); } else if (CompareGUIDs(q1,q2,q3,q4, MCAP_FILE_TRANSFER)) { // this is an OFT packet handleRecvServMsgOFT(pDataBuf, wTLVLen, dwUin, szUID, dwMsgID1, dwMsgID2, wCommand); } else if (CompareGUIDs(q1,q2,q3,q4, MCAP_CONTACTS)) { // this is Contacts Transfer handleRecvServMsgContacts(pDataBuf, wTLVLen, dwUin, szUID, dwMsgID1, dwMsgID2, wCommand); } else // here should be detection of extra data streams (Xtraz) { NetLog_Server("Unknown Message Format Capability"); } } else { NetLog_Server("Unsupported TLV (%u) in message (format %u)", wTLVType, 2); } SAFE_FREE((void**)&pBuf); } void CIcqProto::parseServRelayData(BYTE *pDataBuf, WORD wLen, HANDLE hContact, DWORD dwUin, char *szUID, DWORD dwMsgID1, DWORD dwMsgID2, WORD wAckType) { WORD wId; if (wLen < 2) { NetLog_Server("Message (format %u) - Ignoring empty message", 2); return; } unpackLEWord(&pDataBuf, &wId); // Incorrect identification, but working wLen -= 2; // Only 0x1B are real messages if (wId == 0x001B) { WORD wVersion; WORD wCookie; DWORD dwGuid1,dwGuid2,dwGuid3,dwGuid4; if (wLen < 31) { // just check if we have data to work with NetLog_Server("Message (format %u) - Ignoring empty message", 2); return; } unpackLEWord(&pDataBuf, &wVersion); wLen -= 2; if (hContact != INVALID_HANDLE_VALUE) setSettingWord(hContact, "Version", wVersion); unpackDWord(&pDataBuf, &dwGuid1); // plugin type GUID unpackDWord(&pDataBuf, &dwGuid2); unpackDWord(&pDataBuf, &dwGuid3); unpackDWord(&pDataBuf, &dwGuid4); wLen -= 16; // Skip lots of unused stuff pDataBuf += 9; wLen -= 9; unpackLEWord(&pDataBuf, &wId); wLen -= 2; unpackLEWord(&pDataBuf, &wCookie); wLen -= 2; if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, PSIG_MESSAGE)) { // is this a normal message ? BYTE bMsgType; BYTE bFlags; WORD wStatus, wPritority; WORD wMsgLen; if (wLen < 20) { // check if there is everything that should be there NetLog_Server("Message (format %u) - Ignoring empty message", 2); return; } pDataBuf += 12; /* all zeroes */ wLen -= 12; unpackByte(&pDataBuf, &bMsgType); wLen -= 1; unpackByte(&pDataBuf, &bFlags); wLen -= 1; // Status unpackLEWord(&pDataBuf, &wStatus); wLen -= 2; // Priority unpackLEWord(&pDataBuf, &wPritority); wLen -= 2; NetLog_Server("Priority: %u", wPritority); // Message unpackLEWord(&pDataBuf, &wMsgLen); wLen -= 2; // HANDLERS switch (bMsgType) { // File messages, handled by the file module case MTYPE_FILEREQ: { if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } char* szMsg = (char *)_alloca(wMsgLen + 1); memcpy(szMsg, pDataBuf, wMsgLen); szMsg[wMsgLen] = '\0'; pDataBuf += wMsgLen; wLen -= wMsgLen; if (wAckType == 0 || wAckType == 1) { // File requests 7 handleFileRequest(pDataBuf, wLen, dwUin, wCookie, dwMsgID1, dwMsgID2, szMsg, 7, FALSE); } else if (wAckType == 2) { // File reply 7 handleFileAck(pDataBuf, wLen, dwUin, wCookie, wStatus, szMsg); } else { NetLog_Server("Ignored strange file message"); } break; } // Chat messages, handled by the chat module case MTYPE_CHAT: { // TODO: this type is deprecated break; } // Plugin messages, need further parsing case MTYPE_PLUGIN: { if (wLen < wMsgLen) { // sanity check NetLog_Server("Error: Malformed server Greeting message"); return; } parseServRelayPluginData(pDataBuf + wMsgLen, wLen - wMsgLen, hContact, dwUin, szUID, dwMsgID1, dwMsgID2, wAckType, bFlags, wStatus, wCookie, wVersion); break; } // Everything else default: { if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } message_ack_params pMsgAck = {0}; pMsgAck.bType = MAT_SERVER_ADVANCED; pMsgAck.dwUin = dwUin; pMsgAck.dwMsgID1 = dwMsgID1; pMsgAck.dwMsgID2 = dwMsgID2; pMsgAck.wCookie = wCookie; pMsgAck.msgType = bMsgType; pMsgAck.bFlags = bFlags; handleMessageTypes(dwUin, szUID, time(NULL), dwMsgID1, dwMsgID2, wCookie, wVersion, bMsgType, bFlags, wAckType, wLen, wMsgLen, (char*)pDataBuf, 0, &pMsgAck); break; } } } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, PSIG_INFO_PLUGIN)) { // info manager plugin - obsolete if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } BYTE bMsgType; BYTE bLevel; pDataBuf += 16; /* unused stuff */ wLen -= 16; unpackByte(&pDataBuf, &bMsgType); wLen -= 1; pDataBuf += 3; // unknown wLen -= 3; unpackByte(&pDataBuf, &bLevel); if (bLevel != 0 || wLen < 16) { NetLog_Server("Invalid %s Manager Plugin message from %u", "Info", dwUin); return; } unpackDWord(&pDataBuf, &dwGuid1); // plugin request GUID unpackDWord(&pDataBuf, &dwGuid2); unpackDWord(&pDataBuf, &dwGuid3); unpackDWord(&pDataBuf, &dwGuid4); wLen -= 16; if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, PMSG_QUERY_INFO)) { NetLog_Server("User %u requests our %s plugin list. NOT SUPPORTED", dwUin, "info"); } else NetLog_Server("Unknown %s Manager message from %u", "Info", dwUin); } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, PSIG_STATUS_PLUGIN)) { // status manager plugin - obsolete if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } BYTE bMsgType; BYTE bLevel; pDataBuf += 16; /* unused stuff */ wLen -= 16; unpackByte(&pDataBuf, &bMsgType); wLen -= 1; pDataBuf += 3; // unknown wLen -= 3; unpackByte(&pDataBuf, &bLevel); if (bLevel != 0 || wLen < 16) { NetLog_Server("Invalid %s Manager Plugin message from %u", "Status", dwUin); return; } unpackDWord(&pDataBuf, &dwGuid1); // plugin request GUID unpackDWord(&pDataBuf, &dwGuid2); unpackDWord(&pDataBuf, &dwGuid3); unpackDWord(&pDataBuf, &dwGuid4); wLen -= 16; if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, PMSG_QUERY_STATUS)) NetLog_Server("User %u requests our %s plugin list. NOT SUPPORTED", dwUin, "status"); else NetLog_Server("Unknown %s Manager message from %u", "Status", dwUin); } else NetLog_Server("Unknown signature (%08x-%08x-%08x-%08x) in message (format 2)", dwGuid1, dwGuid2, dwGuid3, dwGuid4); } else NetLog_Server("Unknown wId1 (%u) in message (format 2)", wId); } void CIcqProto::parseServRelayPluginData(BYTE *pDataBuf, WORD wLen, HANDLE hContact, DWORD dwUin, char *szUID, DWORD dwMsgID1, DWORD dwMsgID2, WORD wAckType, BYTE bFlags, WORD wStatus, WORD wCookie, WORD wVersion) { int nTypeId; WORD wFunction; NetLog_Server("Parsing Greeting message through server"); // Message plugin identification if (!unpackPluginTypeId(&pDataBuf, &wLen, &nTypeId, &wFunction, FALSE)) return; if (wLen > 8) { DWORD dwLengthToEnd; DWORD dwDataLen; // Length of remaining data unpackLEDWord(&pDataBuf, &dwLengthToEnd); // Length of message unpackLEDWord(&pDataBuf, &dwDataLen); wLen -= 8; if (dwDataLen > wLen) dwDataLen = wLen; if (nTypeId == MTYPE_FILEREQ && wAckType == 2) { if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } NetLog_Server("This is file ack"); char *szMsg = (char *)_alloca(dwDataLen + 1); memcpy(szMsg, pDataBuf, dwDataLen); szMsg[dwDataLen] = '\0'; pDataBuf += dwDataLen; wLen -= (WORD)dwDataLen; handleFileAck(pDataBuf, wLen, dwUin, wCookie, wStatus, szMsg); } else if (nTypeId == MTYPE_FILEREQ && wAckType == 1) { if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } NetLog_Server("This is a file request"); char *szMsg = (char *)_alloca(dwDataLen + 1); memcpy(szMsg, pDataBuf, dwDataLen); szMsg[dwDataLen] = '\0'; pDataBuf += dwDataLen; wLen -= (WORD)dwDataLen; handleFileRequest(pDataBuf, wLen, dwUin, wCookie, dwMsgID1, dwMsgID2, szMsg, 8, FALSE); } else if (nTypeId == MTYPE_CHAT && wAckType == 1) { // TODO: this is deprecated if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } NetLog_Server("This is a chat request"); char *szMsg = (char *)_alloca(dwDataLen + 1); memcpy(szMsg, pDataBuf, dwDataLen); szMsg[dwDataLen] = '\0'; pDataBuf += dwDataLen; wLen -= (WORD)dwDataLen; // handleChatRequest(pDataBuf, wLen, dwUin, wCookie, dwMsgID1, dwMsgID2, szMsg, 8); } else if (nTypeId == MTYPE_STATUSMSGEXT && wFunction >= 1 && wFunction <= 3) { // handle extended status message request int nMsgType = 0; switch (wFunction) { case 1: // Away if (m_iStatus == ID_STATUS_ONLINE || m_iStatus == ID_STATUS_INVISIBLE) nMsgType = MTYPE_AUTOONLINE; else if (m_iStatus == ID_STATUS_AWAY) nMsgType = MTYPE_AUTOAWAY; else if (m_iStatus == ID_STATUS_FREECHAT) nMsgType = MTYPE_AUTOFFC; break; case 2: // Busy if (m_iStatus == ID_STATUS_OCCUPIED) nMsgType = MTYPE_AUTOBUSY; else if (m_iStatus == ID_STATUS_DND) nMsgType = MTYPE_AUTODND; break; case 3: // N/A if (m_iStatus == ID_STATUS_NA) nMsgType = MTYPE_AUTONA; } handleMessageTypes(dwUin, szUID, time(NULL), dwMsgID1, dwMsgID2, wCookie, wVersion, nMsgType, bFlags, wAckType, dwLengthToEnd, 0, (char*)pDataBuf, MTF_PLUGIN | MTF_STATUS_EXTENDED, NULL); } else if (nTypeId) { if (!dwUin) { // AIM cannot send this, just sanity NetLog_Server("Error: Malformed UIN in packet"); return; } message_ack_params pMsgAck = {0}; pMsgAck.bType = MAT_SERVER_ADVANCED; pMsgAck.dwUin = dwUin; pMsgAck.dwMsgID1 = dwMsgID1; pMsgAck.dwMsgID2 = dwMsgID2; pMsgAck.wCookie = wCookie; pMsgAck.msgType = nTypeId; pMsgAck.bFlags = bFlags; handleMessageTypes(dwUin, szUID, time(NULL), dwMsgID1, dwMsgID2, wCookie, wVersion, nTypeId, bFlags, wAckType, dwLengthToEnd, (WORD)dwDataLen, (char*)pDataBuf, MTF_PLUGIN, &pMsgAck); } else { NetLog_Server("Unsupported plugin message type %d", nTypeId); } } else NetLog_Server("Error: Malformed server plugin message"); } void CIcqProto::handleRecvServMsgContacts(BYTE *buf, WORD wLen, DWORD dwUin, char *szUID, DWORD dwID1, DWORD dwID2, WORD wCommand) { HANDLE hContact = HContactFromUID(dwUin, szUID, NULL); if (wCommand == 0) { // received contacts if (wLen < 4) { // just check if at least one tlv is there NetLog_Server("Message (format %u) - Ignoring empty contacts message", 2); return; } oscar_tlv_chain *chain = readIntoTLVChain(&buf, wLen, 0); if (!chain) { // sanity check NetLog_Server("Message (format %u) - Invalid data", 2); return; } WORD wAckType = chain->getWord(0x0A, 1); if (wAckType == 1) { // it is really message containing contacts, parse them oscar_tlv *tlvUins = chain->getTLV(0x2711, 1); oscar_tlv *tlvNames = chain->getTLV(0x2712, 1); if (!tlvUins || tlvUins->wLen < 4) { NetLog_Server("Malformed '%s' message", "contacts"); disposeChain(&chain); return; } int nContacts = 0x10, iContact = 0; ICQSEARCHRESULT **contacts = (ICQSEARCHRESULT**)SAFE_MALLOC(nContacts * sizeof(ICQSEARCHRESULT*)); WORD wContactsGroup = 0; int valid = 1; BYTE *pBuffer = tlvUins->pData; int nLen = tlvUins->wLen; while (nLen > 2) { // parse UIDs if (!wContactsGroup) { WORD wGroupLen; unpackWord(&pBuffer, &wGroupLen); nLen -= 2; if (nLen >= wGroupLen + 2) { pBuffer += wGroupLen; unpackWord(&pBuffer, &wContactsGroup); nLen -= wGroupLen + 2; } else break; } else { // group parsed, UIDs waiting WORD wUidLen; unpackWord(&pBuffer, &wUidLen); nLen -= 2; if (nLen >= wUidLen) { char *szUid = (char*)SAFE_MALLOC(wUidLen + 1); unpackString(&pBuffer, szUid, wUidLen); nLen -= wUidLen; if (iContact >= nContacts) { // the list is too small, resize it nContacts += 0x10; contacts = (ICQSEARCHRESULT**)SAFE_REALLOC(contacts, nContacts * sizeof(ICQSEARCHRESULT*)); } contacts[iContact] = (ICQSEARCHRESULT*)SAFE_MALLOC(sizeof(ICQSEARCHRESULT)); contacts[iContact]->hdr.cbSize = sizeof(ICQSEARCHRESULT); contacts[iContact]->hdr.flags = PSR_TCHAR; contacts[iContact]->hdr.nick = null_strdup(_T("")); contacts[iContact]->hdr.id = ansi_to_tchar(szUid); if (IsStringUIN(szUid)) { // icq contact contacts[iContact]->uin = atoi(szUid); if (contacts[iContact]->uin == 0) valid = 0; } else { // aim contact if (!strlennull(szUid)) valid = 0; } iContact++; SAFE_FREE(&szUid); } else { if (wContactsGroup) valid = 0; break; } wContactsGroup--; } } if (!iContact || !valid) { NetLog_Server("Malformed '%s' message", "contacts"); disposeChain(&chain); for (int i = 0; i < iContact; i++) { SAFE_FREE(&contacts[i]->hdr.id); SAFE_FREE(&contacts[i]->hdr.nick); SAFE_FREE((void**)&contacts[i]); } SAFE_FREE((void**)&contacts); return; } nContacts = iContact; if (tlvNames && tlvNames->wLen >= 4) { // parse names, if available pBuffer = tlvNames->pData; nLen = tlvNames->wLen; iContact = 0; while (nLen > 2) { // parse Names if (!wContactsGroup) { WORD wGroupLen; unpackWord(&pBuffer, &wGroupLen); nLen -= 2; if (nLen >= wGroupLen + 2) { pBuffer += wGroupLen; unpackWord(&pBuffer, &wContactsGroup); nLen -= wGroupLen + 2; } else break; } else { // group parsed, Names waiting WORD wNickLen; unpackWord(&pBuffer, &wNickLen); nLen -= 2; if (nLen >= wNickLen) { WORD wNickTLV, wNickTLVLen; char *pNick = NULL; unpackTypedTLV(pBuffer, wNickLen, 0x01, &wNickTLV, &wNickTLVLen, (LPBYTE*)&pNick); if (wNickTLV == 0x01) { SAFE_FREE(&contacts[iContact]->hdr.nick); contacts[iContact]->hdr.nick = utf8_to_tchar(pNick); } else SAFE_FREE(&pNick); pBuffer += wNickLen; nLen -= wNickLen; iContact++; if (iContact >= nContacts) break; } else break; wContactsGroup--; } } } if (!valid) { NetLog_Server("Malformed '%s' message", "contacts"); } else { int bAdded; CCSDATA ccs; PROTORECVEVENT pre = {0}; hContact = HContactFromUID(dwUin, szUID, &bAdded); // ack the message icq_sendContactsAck(dwUin, szUID, dwID1, dwID2); ccs.szProtoService = PSR_CONTACTS; ccs.hContact = hContact; ccs.wParam = 0; ccs.lParam = (LPARAM)⪯ pre.timestamp = (DWORD)time(NULL); pre.szMessage = (char *)contacts; pre.lParam = nContacts; pre.flags = PREF_TCHAR; CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs); } for (int i = 0; i < iContact; i++) { SAFE_FREE(&contacts[i]->hdr.id); SAFE_FREE(&contacts[i]->hdr.nick); SAFE_FREE((void**)&contacts[i]); } SAFE_FREE((void**)&contacts); } else NetLog_Server("Error: Received unknown contacts message, ignoring."); // Clean up disposeChain(&chain); } else if (wCommand == 1) { NetLog_Server("Cannot handle abort messages yet... :("); return; } else if (wCommand == 2) { // acknowledgement DWORD dwCookie; HANDLE hCookieContact; if (FindMessageCookie(dwID1, dwID2, &dwCookie, &hCookieContact, NULL)) { if (hCookieContact != hContact) NetLog_Server("Warning: Ack Contact does not match Cookie Contact(0x%x != 0x%x)", hContact, hCookieContact); BroadcastAck(hContact, ACKTYPE_CONTACTS, ACKRESULT_SUCCESS, (HANDLE)dwCookie, 0); ReleaseCookie(dwCookie); } else NetLog_Server("Warning: Unexpected Contact Transfer ack from %s", strUID(dwUin, szUID)); } } void CIcqProto::handleRecvServMsgType4(BYTE *buf, WORD wLen, DWORD dwUin, char *szUID, DWORD dwMsgID1, DWORD dwMsgID2, DWORD dwRef) { WORD wTLVType; WORD wTLVLen; BYTE* pDataBuf; DWORD dwUin2; if (wLen < 2) { NetLog_Server("Message (format %u) - Ignoring empty message", 4); return; } // Unpack the first TLV(5) unpackTypedTLV(buf, wLen, 5, &wTLVType, &wTLVLen, &pDataBuf); NetLog_Server("Message (format %u) - UID: %s", 4, strUID(dwUin, szUID)); // It must be TLV(5) if (wTLVType == 5) { BYTE bMsgType; BYTE bFlags; BYTE* pmsg = pDataBuf; WORD wMsgLen; unpackLEDWord(&pmsg, &dwUin2); if (dwUin2 == dwUin) { unpackByte(&pmsg, &bMsgType); unpackByte(&pmsg, &bFlags); unpackLEWord(&pmsg, &wMsgLen); if (bMsgType == 0 && wMsgLen == 1) { NetLog_Server("User %u probably checks his ignore state.", dwUin); } else { cookie_offline_messages *cookie; DWORD dwRecvTime = (DWORD)time(NULL); if (!(dwRef & 0x80000000) && FindCookie(dwRef, NULL, (void**)&cookie)) { WORD wTimeTLVType, wTimeTLVLen; BYTE *pTimeTLV = NULL; cookie->nMessages++; unpackTypedTLV(buf, wLen, 0x16, &wTimeTLVType, &wTimeTLVLen, &pTimeTLV); if (pTimeTLV && wTimeTLVType == 0x16 && wTimeTLVLen == 4) { // found Offline timestamp BYTE *pBuf = pTimeTLV; unpackDWord(&pBuf, &dwRecvTime); NetLog_Server("Message (format %u) - Offline timestamp is %s", 4, time2text(dwRecvTime)); } SAFE_FREE((void**)&pTimeTLV); } if (bMsgType == MTYPE_PLUGIN) { WORD wLen = wTLVLen - 8; int typeId; NetLog_Server("Parsing Greeting message through server"); pmsg += wMsgLen; wLen -= wMsgLen; if (unpackPluginTypeId(&pmsg, &wLen, &typeId, NULL, FALSE) && wLen > 8) { DWORD dwLengthToEnd; DWORD dwDataLen; // Length of remaining data unpackLEDWord(&pmsg, &dwLengthToEnd); // Length of message unpackLEDWord(&pmsg, &dwDataLen); wLen -= 8; if (dwDataLen > wLen) dwDataLen = wLen; if (typeId) { uid_str szUID; handleMessageTypes(dwUin, szUID, dwRecvTime, dwMsgID1, dwMsgID2, 0, 0, typeId, bFlags, 0, dwLengthToEnd, (WORD)dwDataLen, (char*)pmsg, MTF_PLUGIN, NULL); } else { NetLog_Server("Unsupported plugin message type %d", typeId); } } } else { uid_str szUID; handleMessageTypes(dwUin, szUID, dwRecvTime, dwMsgID1, dwMsgID2, 0, 0, bMsgType, bFlags, 0, wTLVLen - 8, wMsgLen, (char*)pmsg, 0, NULL); } } } else { NetLog_Server("Ignoring spoofed TYPE4 message thru server from %d", dwUin); } } else { NetLog_Server("Unsupported TLV (%u) in message (format %u)", wTLVType, 4); } SAFE_FREE((void**)&pDataBuf); } // // Helper functions // static int TypeGUIDToTypeId(DWORD dwGuid1, DWORD dwGuid2, DWORD dwGuid3, DWORD dwGuid4, WORD wType) { int nTypeID = MTYPE_UNKNOWN; if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_STATUSMSGEXT)) { nTypeID = MTYPE_STATUSMSGEXT; } else if (wType==MGTYPE_UNDEFINED) { if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, PSIG_MESSAGE)) { // icq6 message ack nTypeID = MTYPE_PLAIN; } } else if (wType==MGTYPE_STANDARD_SEND) { if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_WEBURL)) { nTypeID = MTYPE_URL; } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_CONTACTS)) { nTypeID = MTYPE_CONTACTS; } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_CHAT)) { nTypeID = MTYPE_CHAT; } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_FILE)) { nTypeID = MTYPE_FILEREQ; } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_GREETING_CARD)) { nTypeID = MTYPE_GREETINGCARD; } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_MESSAGE)) { nTypeID = MTYPE_MESSAGE; } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_SMS_MESSAGE)) { nTypeID = MTYPE_SMS_MESSAGE; } } else if (wType==MGTYPE_CONTACTS_REQUEST) { if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_CONTACTS)) { nTypeID = MTYPE_REQUESTCONTACTS; } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_XTRAZ_SCRIPT)) { nTypeID = MTYPE_SCRIPT_DATA; } } else if (CompareGUIDs(dwGuid1, dwGuid2, dwGuid3, dwGuid4, MGTYPE_XTRAZ_SCRIPT)) { if (wType==MGTYPE_SCRIPT_INVITATION) { nTypeID = MTYPE_SCRIPT_INVITATION; } else if (wType==MGTYPE_SCRIPT_NOTIFY) { nTypeID = MTYPE_SCRIPT_NOTIFY; } } return nTypeID; } int CIcqProto::unpackPluginTypeId(BYTE **pBuffer, WORD *pwLen, int *pTypeId, WORD *pFunctionId, BOOL bThruDC) { WORD wLen = *pwLen; WORD wInfoLen; DWORD dwPluginNameLen; DWORD q1,q2,q3,q4; WORD qt; if (wLen < 24) return 0; // Failure unpackLEWord(pBuffer, &wInfoLen); unpackDWord(pBuffer, &q1); // get data GUID & function id unpackDWord(pBuffer, &q2); unpackDWord(pBuffer, &q3); unpackDWord(pBuffer, &q4); unpackLEWord(pBuffer, &qt); wLen -= 20; if (pFunctionId) *pFunctionId = qt; unpackLEDWord(pBuffer, &dwPluginNameLen); wLen -= 4; if (dwPluginNameLen > wLen) { // check for malformed plugin name dwPluginNameLen = wLen; NetLog_Uni(bThruDC, "Warning: malformed size of plugin name."); } char *szPluginName = (char *)_alloca(dwPluginNameLen + 1); memcpy(szPluginName, *pBuffer, dwPluginNameLen); szPluginName[dwPluginNameLen] = '\0'; wLen -= (WORD)dwPluginNameLen; *pBuffer += dwPluginNameLen; int typeId = TypeGUIDToTypeId(q1, q2, q3, q4, qt); if (!typeId) NetLog_Uni(bThruDC, "Error: Unknown type {%08x-%08x-%08x-%08x:%04x}: %s", q1,q2,q3,q4,qt, szPluginName); if (wInfoLen >= 22 + dwPluginNameLen) { // sanity checking wInfoLen -= (WORD)(22 + dwPluginNameLen); // check if enough data is available - skip remaining bytes of info block if (wLen >= wInfoLen) { *pBuffer += wInfoLen; wLen -= wInfoLen; } } *pwLen = wLen; *pTypeId = typeId; return 1; // Success } int getPluginTypeIdLen(int nTypeID) { switch (nTypeID) { case MTYPE_SCRIPT_NOTIFY: return 0x51; case MTYPE_FILEREQ: return 0x2B; case MTYPE_AUTOONLINE: case MTYPE_AUTOAWAY: case MTYPE_AUTOBUSY: case MTYPE_AUTODND: case MTYPE_AUTOFFC: return 0x3C; case MTYPE_AUTONA: return 0x3B; default: return 0; } } void packPluginTypeId(icq_packet *packet, int nTypeID) { switch (nTypeID) { case MTYPE_SCRIPT_NOTIFY: packLEWord(packet, 0x04f); // Length packGUID(packet, MGTYPE_XTRAZ_SCRIPT); // Message Type GUID packLEWord(packet, MGTYPE_SCRIPT_NOTIFY); // Function ID packLEDWord(packet, 0x002a); // Request type string packBuffer(packet, (LPBYTE)"Script Plug-in: Remote Notification Arrive", 0x002a); packDWord(packet, 0x00000100); // Unknown binary stuff packDWord(packet, 0x00000000); packDWord(packet, 0x00000000); packWord(packet, 0x0000); packByte(packet, 0x00); break; case MTYPE_FILEREQ: packLEWord(packet, 0x029); // Length packGUID(packet, MGTYPE_FILE); // Message Type GUID packWord(packet, 0x0000); // Unknown packLEDWord(packet, 0x0004); // Request type string packBuffer(packet, (LPBYTE)"File", 0x0004); packDWord(packet, 0x00000100); // More unknown binary stuff packDWord(packet, 0x00010000); packDWord(packet, 0x00000000); packWord(packet, 0x0000); packByte(packet, 0x00); break; case MTYPE_AUTOONLINE: case MTYPE_AUTOAWAY: case MTYPE_AUTOFFC: packLEWord(packet, 0x03A); // Length packGUID(packet, MGTYPE_STATUSMSGEXT); // Message Type GUID packLEWord(packet, 1); // Function ID packLEDWord(packet, 0x13); // Request type string packBuffer(packet, (LPBYTE)"Away Status Message", 0x13); packDWord(packet, 0x01000000); // Unknown binary stuff packDWord(packet, 0x00000000); packDWord(packet, 0x00000000); packDWord(packet, 0x00000000); packByte(packet, 0x00); break; case MTYPE_AUTOBUSY: case MTYPE_AUTODND: packLEWord(packet, 0x03A); // Length packGUID(packet, MGTYPE_STATUSMSGEXT); // Message Type GUID packLEWord(packet, 2); // Function ID packLEDWord(packet, 0x13); // Request type string packBuffer(packet, (LPBYTE)"Busy Status Message", 0x13); packDWord(packet, 0x02000000); // Unknown binary stuff packDWord(packet, 0x00000000); packDWord(packet, 0x00000000); packDWord(packet, 0x00000000); packByte(packet, 0x00); break; case MTYPE_AUTONA: packLEWord(packet, 0x039); // Length packGUID(packet, MGTYPE_STATUSMSGEXT); // Message Type GUID packLEWord(packet, 3); // Function ID packLEDWord(packet, 0x12); // Request type string packBuffer(packet, (LPBYTE)"N/A Status Message", 0x12); packDWord(packet, 0x03000000); // Unknown binary stuff packDWord(packet, 0x00000000); packDWord(packet, 0x00000000); packDWord(packet, 0x00000000); packByte(packet, 0x00); break; } } void CIcqProto::handleStatusMsgReply(const char *szPrefix, HANDLE hContact, DWORD dwUin, WORD wVersion, int bMsgType, WORD wCookie, const char *szMsg, int nMsgFlags) { CCSDATA ccs; PROTORECVEVENT pre = {0}; if (hContact == INVALID_HANDLE_VALUE) { NetLog_Server("%sIgnoring status message from unknown contact %u", szPrefix, dwUin); return; } int status = AwayMsgTypeToStatus(bMsgType); if (status == ID_STATUS_OFFLINE) { NetLog_Server("%sIgnoring unknown status message from %u", szPrefix, dwUin); return; } // it is probably UTF-8 status reply if (wVersion == 9 || (nMsgFlags & MTF_PLUGIN) && wVersion == 10) { if (UTF8_IsValid(szMsg)) pre.flags |= PREF_UTF; } ccs.szProtoService = PSR_AWAYMSG; ccs.hContact = hContact; ccs.wParam = status; ccs.lParam = (LPARAM)⪯ pre.szMessage = (char*)szMsg; pre.timestamp = time(NULL); pre.lParam = wCookie; CallService(MS_PROTO_CHAINRECV,0,(LPARAM)&ccs); } HANDLE CIcqProto::handleMessageAck(DWORD dwUin, char *szUID, WORD wCookie, WORD wVersion, int type, WORD wMsgLen, PBYTE buf, BYTE bFlags, int nMsgFlags) { if (bFlags == 3) { HANDLE hCookieContact; cookie_message_data *pCookieData = NULL; HANDLE hContact = HContactFromUID(dwUin, szUID, NULL); if (!FindCookie(wCookie, &hCookieContact, (void**)&pCookieData)) { NetLog_Server("%sIgnoring unrequested status message from %u", "handleMessageAck: ", dwUin); ReleaseCookie(wCookie); return INVALID_HANDLE_VALUE; } if (hContact != hCookieContact) { NetLog_Server("%sAck Contact does not match Cookie Contact(0x%x != 0x%x)", "handleMessageAck: ", hContact, hCookieContact); ReleaseCookie(wCookie); return INVALID_HANDLE_VALUE; } ReleaseCookie(wCookie); handleStatusMsgReply("handleMessageAck: ", hContact, dwUin, wVersion, type, wCookie, (char*)buf, nMsgFlags); } else { // Should not happen NetLog_Server("%sIgnored type %u ack message (this should not happen)", "handleMessageAck: ", type); } return INVALID_HANDLE_VALUE; } /* this function send all acks from handleMessageTypes */ void CIcqProto::sendMessageTypesAck(HANDLE hContact, int bUnicode, message_ack_params *pArgs) { if (pArgs) { if ((pArgs->msgType == MTYPE_PLAIN && !CallService(MS_IGNORE_ISIGNORED, (WPARAM)hContact, IGNOREEVENT_MESSAGE)) || (pArgs->msgType == MTYPE_URL && !CallService(MS_IGNORE_ISIGNORED, (WPARAM)hContact, IGNOREEVENT_URL)) || pArgs->msgType == MTYPE_CONTACTS) { if (pArgs->bType == MAT_SERVER_ADVANCED) { // Only ack message packets icq_sendAdvancedMsgAck(pArgs->dwUin, pArgs->dwMsgID1, pArgs->dwMsgID2, pArgs->wCookie, (BYTE)pArgs->msgType, pArgs->bFlags); } else if (pArgs->bType == MAT_DIRECT) { // Send acknowledgement icq_sendDirectMsgAck(pArgs->pDC, pArgs->wCookie, (BYTE)pArgs->msgType, pArgs->bFlags, bUnicode ? (char *)CAP_UTF8MSGS : NULL); } } } } /* this function also processes direct packets, so it should be bulletproof */ /* pMsg points to the beginning of the message */ void CIcqProto::handleMessageTypes(DWORD dwUin, char *szUID, DWORD dwTimestamp, DWORD dwMsgID, DWORD dwMsgID2, WORD wCookie, WORD wVersion, int type, int flags, WORD wAckType, DWORD dwDataLen, WORD wMsgLen, char *pMsg, int nMsgFlags, message_ack_params *pAckParams) { HANDLE hContact = INVALID_HANDLE_VALUE; BOOL bThruDC = (nMsgFlags & MTF_DIRECT) == MTF_DIRECT; int bAdded; if (dwDataLen < wMsgLen) { NetLog_Uni(bThruDC, "Ignoring overflowed message"); return; } if (wAckType == 2) { handleMessageAck(dwUin, szUID, wCookie, wVersion, type, wMsgLen, (LPBYTE)pMsg, (BYTE)flags, nMsgFlags); return; } char *szMsg = (char *)SAFE_MALLOC(wMsgLen + 1); if (wMsgLen > 0) { memcpy(szMsg, pMsg, wMsgLen); pMsg += wMsgLen; dwDataLen -= wMsgLen; } szMsg[wMsgLen] = '\0'; char* pszMsgField[2*MAX_CONTACTSSEND+1]; int nMsgFields = 0; pszMsgField[0] = szMsg; if (type == MTYPE_URL || type == MTYPE_AUTHREQ || type == MTYPE_ADDED || type == MTYPE_CONTACTS || type == MTYPE_EEXPRESS || type == MTYPE_WWP) { for (char *pszMsg=szMsg, nMsgFields=1; *pszMsg; pszMsg++) { if ((BYTE)*pszMsg == 0xFE) { *pszMsg = '\0'; pszMsgField[nMsgFields++] = pszMsg + 1; if (nMsgFields >= SIZEOF(pszMsgField)) break; } } } switch (type) { case MTYPE_PLAIN: /* plain message */ { CCSDATA ccs; PROTORECVEVENT pre = {0}; // Check if this message is marked as UTF8 encoded if (dwDataLen > 12) { DWORD dwGuidLen = 0; int bDoubleMsg = 0; if (bThruDC) { DWORD dwExtraLen = *(DWORD*)pMsg; if (dwExtraLen < dwDataLen && !strncmp(szMsg, "{\\rtf", 5)) { // it is icq5 sending us crap, get real message from it WCHAR* usMsg = (WCHAR*)_alloca((dwExtraLen + 1)*sizeof(WCHAR)); // make sure it is null-terminated wcsncpy(usMsg, (WCHAR*)(pMsg + 4), dwExtraLen); usMsg[dwExtraLen] = '\0'; SAFE_FREE(&szMsg); szMsg = (char*)make_utf8_string(usMsg); if (!IsUnicodeAscii(usMsg, dwExtraLen)) pre.flags = PREF_UTF; // only mark real non-ascii messages as unicode bDoubleMsg = 1; } } if (!bDoubleMsg) { dwGuidLen = *(DWORD*)(pMsg+8); dwDataLen -= 12; pMsg += 12; } while ((dwGuidLen >= 38) && (dwDataLen >= dwGuidLen)) { if (!strncmp(pMsg, CAP_UTF8MSGS, 38)) { // Found UTF8 cap, convert message to ansi pre.flags = PREF_UTF; break; } else if (!strncmp(pMsg, CAP_RTFMSGS, 38)) { // Found RichText cap NetLog_Uni(bThruDC, "Warning: User %u sends us RichText.", dwUin); break; } dwGuidLen -= 38; dwDataLen -= 38; pMsg += 38; } } hContact = HContactFromUIN(dwUin, &bAdded); sendMessageTypesAck(hContact, pre.flags & PREF_UTF, pAckParams); if (!pre.flags && !IsUSASCII(szMsg, strlennull(szMsg))) { // message is Ansi and contains national characters, create Unicode part by codepage char *usMsg = convertMsgToUserSpecificUtf(hContact, szMsg); if (usMsg) { SAFE_FREE(&szMsg); szMsg = (char*)usMsg; pre.flags = PREF_UTF; } } ccs.szProtoService = PSR_MESSAGE; ccs.hContact = hContact; ccs.wParam = 0; ccs.lParam = (LPARAM)⪯ pre.timestamp = dwTimestamp; pre.szMessage = (char *)szMsg; CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs); } break; case MTYPE_URL: { CCSDATA ccs; PROTORECVEVENT pre = {0}; if (nMsgFields < 2) { NetLog_Uni(bThruDC, "Malformed '%s' message", "URL"); break; } hContact = HContactFromUIN(dwUin, &bAdded); sendMessageTypesAck(hContact, 0, pAckParams); char *szTitle = ICQTranslateUtf(LPGEN("Incoming URL:")); char *szDataDescr = ansi_to_utf8(pszMsgField[0]); char *szDataUrl = ansi_to_utf8(pszMsgField[1]); char *szBlob = (char *)SAFE_MALLOC(strlennull(szTitle) + strlennull(szDataDescr) + strlennull(szDataUrl) + 8); strcpy(szBlob, szTitle); strcat(szBlob, " "); strcat(szBlob, szDataDescr); // Description strcat(szBlob, "\r\n"); strcat(szBlob, szDataUrl); // URL SAFE_FREE(&szTitle); SAFE_FREE(&szDataDescr); SAFE_FREE(&szDataUrl); ccs.szProtoService = PSR_MESSAGE; ccs.hContact = hContact; ccs.wParam = 0; ccs.lParam = (LPARAM)⪯ pre.timestamp = dwTimestamp; pre.szMessage = (char *)szBlob; pre.flags = PREF_UTF; CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs); SAFE_FREE(&szBlob); } break; case MTYPE_AUTHREQ: /* auth request */ /* format: nick FE first FE last FE email FE unk-char FE msg 00 */ { CCSDATA ccs; PROTORECVEVENT pre = {0}; char* szBlob; char* pCurBlob; if (nMsgFields < 6) { NetLog_Server("Malformed '%s' message", "auth req"); break; } ccs.szProtoService=PSR_AUTH; ccs.hContact=hContact=HContactFromUIN(dwUin, &bAdded); ccs.wParam=0; ccs.lParam=(LPARAM)⪯ pre.timestamp=dwTimestamp; pre.lParam=sizeof(DWORD)+sizeof(HANDLE)+strlennull(pszMsgField[0])+strlennull(pszMsgField[1])+strlennull(pszMsgField[2])+strlennull(pszMsgField[3])+strlennull(pszMsgField[5])+5; /*blob is: uin(DWORD), hcontact(HANDLE), nick(ASCIIZ), first(ASCIIZ), last(ASCIIZ), email(ASCIIZ), reason(ASCIIZ)*/ pCurBlob=szBlob=(char *)_alloca(pre.lParam); memcpy(pCurBlob,&dwUin,sizeof(DWORD)); pCurBlob+=sizeof(DWORD); memcpy(pCurBlob,&hContact,sizeof(HANDLE)); pCurBlob+=sizeof(HANDLE); strcpy((char *)pCurBlob,pszMsgField[0]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[1]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[2]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[3]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[5]); pre.szMessage=(char *)szBlob; CallService(MS_PROTO_CHAINRECV,0,(LPARAM)&ccs); } break; case MTYPE_ADDED: /* 'you were added' */ /* format: nick FE first FE last FE email 00 */ { DWORD cbBlob; PBYTE pBlob, pCurBlob; if (nMsgFields < 4) { NetLog_Server("Malformed '%s' message", "you were added"); break; } hContact = HContactFromUIN(dwUin, &bAdded); /*blob is: uin(DWORD), hcontact(HANDLE), nick(ASCIIZ), first(ASCIIZ), last(ASCIIZ), email(ASCIIZ) */ cbBlob=sizeof(DWORD)+sizeof(HANDLE)+strlennull(pszMsgField[0])+strlennull(pszMsgField[1])+strlennull(pszMsgField[2])+strlennull(pszMsgField[3])+4; pCurBlob=pBlob=(PBYTE)_alloca(cbBlob); memcpy(pCurBlob,&dwUin,sizeof(DWORD)); pCurBlob+=sizeof(DWORD); memcpy(pCurBlob,&hContact,sizeof(HANDLE)); pCurBlob+=sizeof(HANDLE); strcpy((char *)pCurBlob,pszMsgField[0]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[1]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[2]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[3]); AddEvent(NULL, EVENTTYPE_ADDED, dwTimestamp, 0, cbBlob, pBlob); } break; case MTYPE_CONTACTS: { CCSDATA ccs; PROTORECVEVENT pre = {0}; char* pszNContactsEnd; int nContacts; int i; if (nMsgFields < 3 || (nContacts = strtol(pszMsgField[0], &pszNContactsEnd, 10)) == 0 || pszNContactsEnd - pszMsgField[0] != (int)strlennull(pszMsgField[0]) || nMsgFields < nContacts * 2 + 1) { NetLog_Uni(bThruDC, "Malformed '%s' message", "contacts"); break; } int valid = 1; ICQSEARCHRESULT** isrList = (ICQSEARCHRESULT**)_alloca(nContacts * sizeof(ICQSEARCHRESULT*)); for (i = 0; i < nContacts; i++) { isrList[i] = (ICQSEARCHRESULT*)SAFE_MALLOC(sizeof(ICQSEARCHRESULT)); isrList[i]->hdr.cbSize = sizeof(ICQSEARCHRESULT); isrList[i]->hdr.flags = PSR_TCHAR; if (IsStringUIN(pszMsgField[1 + i * 2])) { // icq contact isrList[i]->uin = atoi(pszMsgField[1 + i * 2]); if (isrList[i]->uin == 0) valid = 0; } else { // aim contact if (!strlennull(pszMsgField[1 + i * 2])) valid = 0; } isrList[i]->hdr.id = ansi_to_tchar(pszMsgField[1 + i * 2]); isrList[i]->hdr.nick = ansi_to_tchar(pszMsgField[2 + i * 2]); } if (!valid) { NetLog_Uni(bThruDC, "Malformed '%s' message", "contacts"); } else { hContact = HContactFromUIN(dwUin, &bAdded); sendMessageTypesAck(hContact, 0, pAckParams); ccs.szProtoService = PSR_CONTACTS; ccs.hContact = hContact; ccs.wParam = 0; ccs.lParam = (LPARAM)⪯ pre.timestamp = dwTimestamp; pre.szMessage = (char *)isrList; pre.lParam = nContacts; pre.flags = PREF_TCHAR; CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs); } for (i = 0; i < nContacts; i++) { SAFE_FREE(&isrList[i]->hdr.id); SAFE_FREE(&isrList[i]->hdr.nick); SAFE_FREE((void**)&isrList[i]); } } break; case MTYPE_PLUGIN: // FIXME: this should be removed - it is never called hContact = NULL; switch(dwUin) { case 1111: /* icqmail 'you've got mail' - not processed */ break; } break; case MTYPE_SMS_MESSAGE: /* it's a SMS message from a mobile - broadcast to SMS plugin */ if (dwUin != 1002) { NetLog_Uni(bThruDC, "Malformed '%s' message", "SMS Mobile"); break; } NetLog_Server("Received SMS Mobile message"); BroadcastAck(NULL, ICQACKTYPE_SMS, ACKRESULT_SUCCESS, NULL, (LPARAM)szMsg); break; case MTYPE_STATUSMSGEXT: /* it's either extended StatusMsg reply from icq2003b or a IcqWebMessage */ if (dwUin == 1003) { NetLog_Server("Received ICQWebMessage - NOT SUPPORTED"); } break; case MTYPE_WWP: /* format: fromname FE FE FE fromemail FE unknownbyte FE 'Sender IP: xxx.xxx.xxx.xxx' 0D 0A body */ { DWORD cbBlob; PBYTE pBlob, pCurBlob; if (nMsgFields < 6) { NetLog_Server("Malformed '%s' message", "web pager"); break; } /*blob is: body(ASCIIZ), name(ASCIIZ), email(ASCIIZ) */ cbBlob=strlennull(pszMsgField[0])+strlennull(pszMsgField[3])+strlennull(pszMsgField[5])+3; pCurBlob=pBlob=(PBYTE)_alloca(cbBlob); strcpy((char *)pCurBlob,pszMsgField[5]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[0]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[3]); AddEvent(NULL, ICQEVENTTYPE_WEBPAGER, dwTimestamp, 0, cbBlob, pBlob); } break; case MTYPE_EEXPRESS: /* format: fromname FE FE FE fromemail FE unknownbyte FE body */ { DWORD cbBlob; PBYTE pBlob, pCurBlob; if (nMsgFields < 6) { NetLog_Server("Malformed '%s' message", "e-mail express"); break; } /*blob is: body(ASCIIZ), name(ASCIIZ), email(ASCIIZ) */ cbBlob=strlennull(pszMsgField[0])+strlennull(pszMsgField[3])+strlennull(pszMsgField[5])+3; pCurBlob=pBlob=(PBYTE)_alloca(cbBlob); strcpy((char *)pCurBlob,pszMsgField[5]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[0]); pCurBlob+=strlennull((char *)pCurBlob)+1; strcpy((char *)pCurBlob,pszMsgField[3]); AddEvent(NULL, ICQEVENTTYPE_EMAILEXPRESS, dwTimestamp, 0, cbBlob, pBlob); } break; case MTYPE_REQUESTCONTACTS: /* it's a contacts-request */ NetLog_Uni(bThruDC, "Received %s from %u", "Request for Contacts", dwUin); break; case MTYPE_GREETINGCARD: /* it's a greeting card */ NetLog_Uni(bThruDC, "Received %s from %u", "Greeting Card", dwUin); break; case MTYPE_SCRIPT_NOTIFY: /* it's a xtraz notify request */ NetLog_Uni(bThruDC, "Received %s from %u", "Xtraz Notify Request", dwUin); handleXtrazNotify(dwUin, dwMsgID, dwMsgID2, wCookie, szMsg, wMsgLen, bThruDC); break; case MTYPE_SCRIPT_INVITATION: /* it's a xtraz invitation to session */ NetLog_Uni(bThruDC, "Received %s from %u", "Xtraz Invitation", dwUin); handleXtrazInvitation(dwUin, dwMsgID, dwMsgID2, wCookie, szMsg, wMsgLen, bThruDC); break; case MTYPE_SCRIPT_DATA: /* it's a xtraz data packet */ NetLog_Uni(bThruDC, "Received %s from %u", "Xtraz data packet", dwUin); handleXtrazData(dwUin, dwMsgID, dwMsgID2, wCookie, szMsg, wMsgLen, bThruDC); break; case MTYPE_AUTOONLINE: case MTYPE_AUTOAWAY: case MTYPE_AUTOBUSY: case MTYPE_AUTONA: case MTYPE_AUTODND: case MTYPE_AUTOFFC: { char **szMsg = MirandaStatusToAwayMsg(AwayMsgTypeToStatus(type)); if (szMsg) { struct rates_status_message_response: public rates_queue_item { protected: virtual rates_queue_item* copyItem(rates_queue_item *aDest = NULL) { rates_status_message_response *pDest = (rates_status_message_response*)aDest; if (!pDest) pDest = new rates_status_message_response(ppro, wGroup); pDest->bExtended = bExtended; pDest->dwMsgID1 = dwMsgID1; pDest->dwMsgID2 = dwMsgID2; pDest->wCookie = wCookie; pDest->wVersion = wVersion; pDest->nMsgType = nMsgType; return rates_queue_item::copyItem(pDest); }; public: rates_status_message_response(CIcqProto *ppro, WORD wGroup): rates_queue_item(ppro, wGroup) { }; virtual ~rates_status_message_response() { }; virtual void execute() { char **pszMsg = ppro->MirandaStatusToAwayMsg(AwayMsgTypeToStatus(nMsgType)); if (bExtended) ppro->icq_sendAwayMsgReplyServExt(dwUin, szUid, dwMsgID1, dwMsgID2, wCookie, wVersion, nMsgType, pszMsg); else if (dwUin) ppro->icq_sendAwayMsgReplyServ(dwUin, dwMsgID1, dwMsgID2, wCookie, wVersion, (BYTE)nMsgType, pszMsg); else ppro->NetLog_Server("Error: Malformed UIN in packet"); }; BOOL bExtended; DWORD dwMsgID1; DWORD dwMsgID2; WORD wCookie; WORD wVersion; int nMsgType; }; m_ratesMutex->Enter(); WORD wGroup = m_rates->getGroupFromSNAC(ICQ_MSG_FAMILY, ICQ_MSG_RESPONSE); m_ratesMutex->Leave(); rates_status_message_response rr(this, wGroup); rr.bExtended = (nMsgFlags & MTF_STATUS_EXTENDED) == MTF_STATUS_EXTENDED; rr.hContact = hContact; rr.dwUin = dwUin; rr.szUid = szUID; rr.dwMsgID1 = dwMsgID; rr.dwMsgID2 = dwMsgID2; rr.wCookie = wCookie; rr.wVersion = wVersion; rr.nMsgType = type; handleRateItem(&rr, RQT_RESPONSE); } break; } case MTYPE_FILEREQ: // Never happens default: NetLog_Uni(bThruDC, "Unprocessed message type %d", type); break; } SAFE_FREE(&szMsg); } void CIcqProto::handleRecvMsgResponse(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwRef) { DWORD dwUin; uid_str szUid; DWORD dwCookie; WORD wMessageFormat; WORD wStatus; WORD bMsgType = 0; BYTE bFlags; WORD wLength; HANDLE hCookieContact; DWORD dwMsgID1, dwMsgID2; WORD wVersion = 0; cookie_message_data *pCookieData = NULL; unpackLEDWord(&buf, &dwMsgID1); // Message ID unpackLEDWord(&buf, &dwMsgID2); wLen -= 8; unpackWord(&buf, &wMessageFormat); wLen -= 2; if (wMessageFormat != 2) { NetLog_Server("SNAC(4.B) Unknown type"); return; } if (!unpackUID(&buf, &wLen, &dwUin, &szUid)) return; HANDLE hContact = HContactFromUID(dwUin, szUid, NULL); buf += 2; // 3. unknown wLen -= 2; if (!FindMessageCookie(dwMsgID1, dwMsgID2, &dwCookie, &hCookieContact, &pCookieData)) { NetLog_Server("SNAC(4.B) Received an ack that I did not ask for from (%u)", dwUin); return; } if (IsValidOscarTransfer(pCookieData)) { // it is OFT response handleRecvServResponseOFT(buf, wLen, dwUin, szUid, pCookieData); return; } if (!dwUin) { // AIM cannot send this - just sanity NetLog_Server("Error: Invalid UID in message response."); return; } // Length of sub chunk? if (wLen >= 2) { unpackLEWord(&buf, &wLength); wLen -= 2; } else wLength = 0; if (wLength == 0x1b && pCookieData->bMessageType != MTYPE_REVERSE_REQUEST) { // this can be v8 greeting message reply WORD wCookie; unpackLEWord(&buf, &wVersion); buf += 27; /* unknowns from the msg we sent */ wLen -= 29; // Message sequence (SEQ2) unpackLEWord(&buf, &wCookie); wLen -= 2; // Unknown (12 bytes) buf += 12; wLen -= 12; // Message type unpackByte(&buf, (BYTE*)&bMsgType); unpackByte(&buf, &bFlags); wLen -= 2; // Status unpackLEWord(&buf, &wStatus); wLen -= 2; // Priority? buf += 2; wLen -= 2; if (!FindCookie(wCookie, &hCookieContact, (void**)&pCookieData)) { // use old reliable method NetLog_Server("Warning: Invalid cookie in %s from (%u)", "message response", dwUin); if (pCookieData->bMessageType != MTYPE_AUTOAWAY && bFlags == 3) { // most probably a broken ack of some kind (e.g. from R&Q), try to fix that bMsgType = pCookieData->bMessageType; bFlags = 0; NetLog_Server("Warning: Invalid message type in %s from (%u)", "message response", dwUin); } } else if (bMsgType != MTYPE_PLUGIN && pCookieData->bMessageType != MTYPE_AUTOAWAY) { // just because some clients break it... dwCookie = wCookie; if (bMsgType != pCookieData->bMessageType) NetLog_Server("Warning: Invalid message type in %s from (%u)", "message response", dwUin); bMsgType = pCookieData->bMessageType; } else if (pCookieData->bMessageType == MTYPE_AUTOAWAY && bMsgType != MTYPE_PLUGIN) { if (bMsgType != pCookieData->nAckType) NetLog_Server("Warning: Invalid message type in %s from (%u)", "message response", dwUin); } } else { bMsgType = pCookieData->bMessageType; bFlags = 0; } if (hCookieContact != hContact) { NetLog_Server("SNAC(4.B) Ack Contact does not match Cookie Contact(0x%x != 0x%x)", hContact, hCookieContact); ReleaseCookie(dwCookie); // This could be a bad idea, but I think it is safe return; } if (bFlags == 3) // A status message reply { handleStatusMsgReply("SNAC(4.B) ", hContact, dwUin, wVersion, bMsgType, (WORD)dwCookie, (char*)(buf + 2), 0); } else { // An ack of some kind int ackType; if (hContact == NULL || hContact == INVALID_HANDLE_VALUE) { NetLog_Server("SNAC(4.B) Message from unknown contact (%u)", dwUin); ReleaseCookie(dwCookie); // This could be a bad idea, but I think it is safe return; } switch (bMsgType) { case MTYPE_FILEREQ: { char* szMsg; WORD wMsgLen; // Message length unpackLEWord(&buf, &wMsgLen); wLen -= 2; szMsg = (char *)_alloca(wMsgLen + 1); szMsg[wMsgLen] = '\0'; if (wMsgLen > 0) { memcpy(szMsg, buf, wMsgLen); buf += wMsgLen; wLen -= wMsgLen; } handleFileAck(buf, wLen, dwUin, dwCookie, wStatus, szMsg); // No success protoack will be sent here, since all file requests // will have been 'sent' when the server returns its ack return; } case MTYPE_PLUGIN: { WORD wMsgLen; DWORD dwLengthToEnd; DWORD dwDataLen; int typeId; WORD wFunctionId; if (wLength != 0x1B) { NetLog_Server("Invalid Greeting %s", "message response"); ReleaseCookie(dwCookie); return; } NetLog_Server("Parsing Greeting %s", "message response"); // Message unpackLEWord(&buf, &wMsgLen); wLen -= 2; buf += wMsgLen; wLen -= wMsgLen; // This packet is malformed. Possibly a file accept from Miranda IM 0.1.2.1 if (wLen < 20) { ReleaseCookie(dwCookie); return; } if (!unpackPluginTypeId(&buf, &wLen, &typeId, &wFunctionId, FALSE)) { ReleaseCookie(dwCookie); return; } if (wLen < 4) { NetLog_Server("Error: Invalid greeting %s", "message response"); ReleaseCookie(dwCookie); return; } // Length of remaining data unpackLEDWord(&buf, &dwLengthToEnd); wLen -= 4; if (wLen >= 4 && dwLengthToEnd > 0) unpackLEDWord(&buf, &dwDataLen); // Length of message else dwDataLen = 0; switch (typeId) { case MTYPE_PLAIN: if (pCookieData && pCookieData->bMessageType == MTYPE_AUTOAWAY && dwLengthToEnd >= 4) { // ICQ 6 invented this char *szMsg = (char*)_alloca(dwDataLen + 1); if (dwDataLen > 0) memcpy(szMsg, buf, dwDataLen); szMsg[dwDataLen] = '\0'; handleStatusMsgReply("SNAC(4.B) ", hContact, dwUin, wVersion, pCookieData->nAckType, (WORD)dwCookie, szMsg, 0); ReleaseCookie(dwCookie); return; } else ackType = ACKTYPE_MESSAGE; break; case MTYPE_URL: ackType = ACKTYPE_URL; break; case MTYPE_CONTACTS: ackType = ACKTYPE_CONTACTS; break; case MTYPE_FILEREQ: { NetLog_Server("This is file ack"); char *szMsg = (char *)_alloca(dwDataLen + 1); if (dwDataLen > 0) memcpy(szMsg, buf, dwDataLen); szMsg[dwDataLen] = '\0'; buf += dwDataLen; wLen -= (WORD)dwDataLen; handleFileAck(buf, wLen, dwUin, dwCookie, wStatus, szMsg); // No success protoack will be sent here, since all file requests // will have been 'sent' when the server returns its ack } return; case MTYPE_SCRIPT_NOTIFY: { char *szMsg = (char*)_alloca(dwDataLen + 1); if (dwDataLen > 0) memcpy(szMsg, buf, dwDataLen); szMsg[dwDataLen] = '\0'; handleXtrazNotifyResponse(dwUin, hContact, (WORD)dwCookie, szMsg, dwDataLen); ReleaseCookie(dwCookie); } return; case MTYPE_STATUSMSGEXT: { // handle Away Message response (ICQ 6) char *szMsg = (char*)SAFE_MALLOC(dwDataLen + 1); if (dwDataLen > 0) memcpy(szMsg, buf, dwDataLen); szMsg[dwDataLen] = '\0'; szMsg = EliminateHtml(szMsg, dwDataLen); handleStatusMsgReply("SNAC(4.B) ", hContact, dwUin, wVersion, pCookieData->nAckType, (WORD)dwCookie, szMsg, MTF_PLUGIN | MTF_STATUS_EXTENDED); SAFE_FREE(&szMsg); ReleaseCookie(dwCookie); } return; default: NetLog_Server("Error: Unknown plugin message response, type %d.", typeId); return; } } break; case MTYPE_PLAIN: ackType = ACKTYPE_MESSAGE; break; case MTYPE_URL: ackType = ACKTYPE_URL; break; case MTYPE_AUTHOK: case MTYPE_AUTHDENY: ackType = ACKTYPE_AUTHREQ; break; case MTYPE_ADDED: ackType = ACKTYPE_ADDED; break; case MTYPE_CONTACTS: ackType = ACKTYPE_CONTACTS; break; case MTYPE_REVERSE_REQUEST: { cookie_reverse_connect *pReverse = (cookie_reverse_connect*)pCookieData; if (pReverse->ft) { filetransfer *ft = (filetransfer*)pReverse->ft; BroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0); } NetLog_Server("Reverse Connect request failed"); // Set DC status to failed setSettingByte(hContact, "DCStatus", 2); ReleaseCookie(dwCookie); } return; case MTYPE_CHAT: default: NetLog_Server("SNAC(4.B) Unknown message type (%u) in switch", bMsgType); return; } if ((ackType == MTYPE_PLAIN && pCookieData && (pCookieData->nAckType == ACKTYPE_CLIENT)) || ackType != MTYPE_PLAIN) { BroadcastAck(hContact, ackType, ACKRESULT_SUCCESS, (HANDLE)(WORD)dwCookie, 0); } } ReleaseCookie(dwCookie); } // A response to a CLI_SENDMSG void CIcqProto::handleRecvServMsgError(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwSequence) { WORD wError; char *pszErrorMessage; HANDLE hContact; cookie_message_data *pCookieData = NULL; int nMessageType; if (wLen < 2) return; if (FindCookie((WORD)dwSequence, &hContact, (void**)&pCookieData)) { // all packet cookies from msg family has command 0 in the queue DWORD dwUin; uid_str szUid; if (getContactUid(hContact, &dwUin, &szUid)) { // Invalid contact FreeCookie((WORD)dwSequence); return; } // Error code unpackWord(&buf, &wError); if (wError == 9 && pCookieData->bMessageType == MTYPE_AUTOAWAY) { // we failed to request away message the normal way, try it AIM way icq_packet packet; serverPacketInit(&packet, (WORD)(13 + getUINLen(dwUin))); packFNACHeader(&packet, ICQ_LOCATION_FAMILY, ICQ_LOCATION_REQ_USER_INFO, 0, (WORD)dwSequence); packWord(&packet, 0x03); packUIN(&packet, dwUin); sendServPacket(&packet); return; } // Not all of these are actually used in family 4 // This will be moved into a special error handling function later switch (wError) { case 0x0002: // Server rate limit exceeded pszErrorMessage = Translate("You are sending too fast. Wait a while and try again.\r\nSNAC(4.1) Error x02"); break; case 0x0003: // Client rate limit exceeded pszErrorMessage = Translate("You are sending too fast. Wait a while and try again.\r\nSNAC(4.1) Error x03"); break; case 0x0004: // Recipient is not logged in (resend in a offline message) if (pCookieData->bMessageType == MTYPE_PLAIN) { if (pCookieData->isOffline) { // offline failed - most probably to AIM contact pszErrorMessage = Translate("The contact does not support receiving offline messages."); break; } // TODO: this needs better solution setSettingWord(hContact, "Status", ID_STATUS_OFFLINE); } pszErrorMessage = Translate("The user has logged off. Select 'Retry' to send an offline message.\r\nSNAC(4.1) Error x04"); break; case 0x0005: // Requested service unavailable pszErrorMessage = Translate("The messaging service is temporarily unavailable. Wait a while and try again.\r\nSNAC(4.1) Error x05"); break; case 0x0009: // Not supported by client (resend in a simpler format) pszErrorMessage = Translate("The receiving client does not support this type of message.\r\nSNAC(4.1) Error x09"); break; case 0x000A: // Refused by client pszErrorMessage = Translate("You sent too long message. The receiving client does not support it.\r\nSNAC(4.1) Error x0A"); break; case 0x000E: // Incorrect SNAC format pszErrorMessage = Translate("The SNAC format was rejected by the server.\nSNAC(4.1) Error x0E"); break; case 0x0013: // User temporarily unavailable pszErrorMessage = Translate("The user is temporarily unavailable. Wait a while and try again.\r\nSNAC(4.1) Error x13"); break; case 0x0001: // Invalid SNAC header case 0x0006: // Requested service not defined case 0x0007: // You sent obsolete SNAC case 0x0008: // Not supported by server case 0x000B: // Reply too big case 0x000C: // Responses lost case 0x000D: // Request denied case 0x000F: // Insufficient rights case 0x0010: // In local permit/deny (recipient blocked) case 0x0011: // Sender too evil case 0x0012: // Receiver too evil case 0x0014: // No match case 0x0015: // List overflow case 0x0016: // Request ambiguous case 0x0017: // Server queue full case 0x0018: // Not while on AOL default: if (pszErrorMessage = (char*)_alloca(256)) null_snprintf(pszErrorMessage, 256, Translate("SNAC(4.1) SENDMSG Error (x%02x)"), wError); break; } switch (pCookieData->bMessageType) { case MTYPE_PLAIN: nMessageType = ACKTYPE_MESSAGE; break; case MTYPE_CHAT: nMessageType = ACKTYPE_CHAT; break; case MTYPE_FILEREQ: nMessageType = ACKTYPE_FILE; break; case MTYPE_URL: nMessageType = ACKTYPE_URL; break; case MTYPE_CONTACTS: nMessageType = ACKTYPE_CONTACTS; break; default: nMessageType = -1; break; } if (nMessageType != -1) { BroadcastAck(hContact, nMessageType, ACKRESULT_FAILED, (HANDLE)(WORD)dwSequence, (LPARAM)pszErrorMessage); } else { NetLog_Server("Error: Message delivery to %u failed: %s", dwUin, pszErrorMessage); } FreeCookie((WORD)dwSequence); if (pCookieData->bMessageType != MTYPE_FILEREQ) SAFE_FREE((void**)&pCookieData); } else { unpackWord(&buf, &wError); LogFamilyError(ICQ_MSG_FAMILY, wError); } } void CIcqProto::handleServerAck(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwSequence) { DWORD dwUin; uid_str szUID; WORD wChannel; cookie_message_data *pCookieData; if (wLen < 13) { NetLog_Server("Ignoring SNAC(4,C) Packet to short"); return; } buf += 8; // Skip first 8 bytes wLen -= 8; // Message channel unpackWord(&buf, &wChannel); wLen -= 2; // Sender if (!unpackUID(&buf, &wLen, &dwUin, &szUID)) return; HANDLE hContact = HContactFromUID(dwUin, szUID, NULL); if (FindCookie((WORD)dwSequence, NULL, (void**)&pCookieData)) { // If the user requested a full ack, the // server ack should be ignored here. if (pCookieData && (pCookieData->nAckType == ACKTYPE_SERVER)) { if ((hContact != NULL) && (hContact != INVALID_HANDLE_VALUE)) { int ackType; int ackRes = ACKRESULT_SUCCESS; switch (pCookieData->bMessageType) { case MTYPE_PLAIN: ackType = ACKTYPE_MESSAGE; break; case MTYPE_CONTACTS: ackType = ACKTYPE_CONTACTS; break; case MTYPE_URL: ackType = ACKTYPE_URL; break; case MTYPE_FILEREQ: ackType = ACKTYPE_FILE; ackRes = ACKRESULT_SENTREQUEST; // Note 1: We are not allowed to free the cookie here because it // contains the filetransfer struct that we will need later // Note 2: The cookiedata is NOT a message_cookie_data*, it is a // filetransfer*. IMPORTANT! (it's one of those silly things) break; default: ackType = -1; NetLog_Server("Error: Unknown message type %d in ack", pCookieData->bMessageType); break; } if (ackType != -1) BroadcastAck(hContact, ackType, ackRes, (HANDLE)(WORD)dwSequence, 0); if (pCookieData->bMessageType != MTYPE_FILEREQ) SAFE_FREE((void**)&pCookieData); // this could be a bad idea, but I think it is safe } FreeCookie((WORD)dwSequence); } else if (pCookieData && (pCookieData->nAckType == ACKTYPE_CLIENT)) NetLog_Server("Received a server ack, waiting for client ack."); else NetLog_Server("Ignored a server ack I did not ask for"); } } void CIcqProto::handleMissedMsg(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwRef) { DWORD dwUin; uid_str szUid; WORD wChannel; WORD wWarningLevel; WORD wCount; WORD wError; WORD wTLVCount; if (wLen < 14) return; // Too short // Message channel? unpackWord(&buf, &wChannel); wLen -= 2; // Sender if (!unpackUID(&buf, &wLen, &dwUin, &szUid)) return; if (wLen < 8) return; // Too short // Warning level? unpackWord(&buf, &wWarningLevel); wLen -= 2; // TLV count unpackWord(&buf, &wTLVCount); wLen -= 2; // Read past user info TLVs oscar_tlv_chain *pChain = readIntoTLVChain(&buf, (WORD)(wLen-4), wTLVCount); if (pChain) disposeChain(&pChain); if (wLen < 4) return; // Too short // Number of missed messages unpackWord(&buf, &wCount); wLen -= 2; // Error code unpackWord(&buf, &wError); wLen -= 2; { // offline retrieval process in progress, note that we received missed message notification cookie_offline_messages *cookie; if (FindCookieByType(CKT_OFFLINEMESSAGE, NULL, NULL, (void**)&cookie)) cookie->nMissed++; } switch (wError) { case 0: // The message was invalid case 1: // The message was too long case 2: // The sender has flooded the server case 4: // You are too evil break; default: // 3 = Sender too evil (sender warn level > your max_msg_sevil) return; break; } // Create event to notify user int bAdded; AddEvent(HContactFromUID(dwUin, szUid, &bAdded), ICQEVENTTYPE_MISSEDMESSAGE, time(NULL), 0, sizeof(wError), (PBYTE)&wError); } void CIcqProto::handleOffineMessagesReply(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwRef) { cookie_offline_messages *cookie; if (FindCookie(dwRef, NULL, (void**)&cookie)) { NetLog_Server("End of offline msgs, %u received", cookie->nMessages); if (cookie->nMissed) { // NASTY WORKAROUND!! // The ICQ server has a bug that causes offline messages to be received again and again when some // missed message notification is present (most probably it is not processed correctly and causes // the server to fail the purging process); try to purge them using the old offline messages // protocol. 2008/05/21 NetLog_Server("Warning: Received %u missed message notifications, trying to fix the server.", cookie->nMissed); icq_packet packet; // This will delete the messages stored on server serverPacketInit(&packet, 24); packFNACHeader(&packet, ICQ_EXTENSIONS_FAMILY, ICQ_META_CLI_REQUEST); packWord(&packet, 1); // TLV Type packWord(&packet, 10); // TLV Length packLEWord(&packet, 8); // Data length packLEDWord(&packet, m_dwLocalUIN); // My UIN packLEWord(&packet, CLI_DELETE_OFFLINE_MSGS_REQ); // Ack offline msgs packLEWord(&packet, 0x0000); // Request sequence number (we dont use this for now) // Send it sendServPacket(&packet); } ReleaseCookie(dwRef); } else NetLog_Server("Error: Received unexpected end of offline msgs."); } void CIcqProto::handleTypingNotification(BYTE *buf, WORD wLen, WORD wFlags, DWORD dwRef) { DWORD dwUin; uid_str szUid; WORD wChannel; WORD wNotification; if (wLen < 14) { NetLog_Server("Ignoring SNAC(4.x11) Packet to short"); return; } #ifndef DBG_CAPMTN { NetLog_Server("Ignoring unexpected typing notification"); return; } #endif // The message ID, unused? buf += 8; wLen -= 8; // Message channel, unused? unpackWord(&buf, &wChannel); wLen -= 2; // Sender if (!unpackUID(&buf, &wLen, &dwUin, &szUid)) return; HANDLE hContact = HContactFromUID(dwUin, szUid, NULL); if (hContact == INVALID_HANDLE_VALUE) return; // Typing notification code unpackWord(&buf, &wNotification); wLen -= 2; SetContactCapabilities(hContact, CAPF_TYPING); // Notify user switch (wNotification) { case MTN_FINISHED: case MTN_TYPED: CallService(MS_PROTO_CONTACTISTYPING, (WPARAM)hContact, (LPARAM)PROTOTYPE_CONTACTTYPING_OFF); NetLog_Server("%s has stopped typing (ch %u).", strUID(dwUin, szUid), wChannel); break; case MTN_BEGUN: CallService(MS_PROTO_CONTACTISTYPING, (WPARAM)hContact, (LPARAM)60); NetLog_Server("%s is typing a message (ch %u).", strUID(dwUin, szUid), wChannel); break; case MTN_WINDOW_CLOSED: { char szFormat[MAX_PATH]; char szMsg[MAX_PATH]; char *nick = NickFromHandleUtf(hContact); null_snprintf(szMsg, MAX_PATH, ICQTranslateUtfStatic(LPGEN("Contact \"%s\" has closed the message window."), szFormat, MAX_PATH), nick); ShowPopUpMsg(hContact, ICQTranslateUtfStatic(LPGEN("ICQ Note"), szFormat, MAX_PATH), szMsg, LOG_NOTE); SAFE_FREE((void**)&nick); NetLog_Server("%s has closed the message window.", strUID(dwUin, szUid)); } break; default: NetLog_Server("Unknown typing notification from %s, type %u (ch %u)", strUID(dwUin, szUid), wNotification, wChannel); break; } } void CIcqProto::sendTypingNotification(HANDLE hContact, WORD wMTNCode) { _ASSERTE((wMTNCode == MTN_FINISHED) || (wMTNCode == MTN_TYPED) || (wMTNCode == MTN_BEGUN) || (wMTNCode == MTN_WINDOW_CLOSED)); DWORD dwUin; uid_str szUid; if (getContactUid(hContact, &dwUin, &szUid)) return; // Invalid contact WORD wLen = getUIDLen(dwUin, szUid); icq_packet packet; serverPacketInit(&packet, 23 + wLen); packFNACHeader(&packet, ICQ_MSG_FAMILY, ICQ_MSG_MTN); packLEDWord(&packet, 0x0000); // Msg ID packLEDWord(&packet, 0x0000); // Msg ID packWord(&packet, 0x01); // Channel packUID(&packet, dwUin, szUid); // User ID packWord(&packet, wMTNCode); // Notification type sendServPacketAsync(&packet); }