svn.miranda.im is moving to a new home!

git-svn-id: http://miranda-plugins.googlecode.com/svn/trunk@7 e753b5eb-9565-29b2-b5c5-2cc6f99dfbcb

1 files changed, 706 insertions, 0 deletions

diff --git a/icqj_mod/icq_packet.c b/icqj_mod/icq_packet.c
new file mode 100644
index 0000000..a0b628b
--- /dev/null
+++ b/icqj_mod/icq_packet.c
@@ -0,0 +1,706 @@
+// ---------------------------------------------------------------------------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,2003,2004 Martin Öberg, Sam Kothari, Robert Rainwater

+// Copyright © 2004,2005,2006 Joe Kucera, Bio

+// 

+// 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.

+//

+// -----------------------------------------------------------------------------

+//

+// File name      : $Source: /cvsroot/miranda/miranda/protocols/IcqOscarJ/icq_packet.c,v $

+// Revision       : $Revision: 2991 $

+// Last change on : $Date: 2006-05-30 19:55:48 +0200 (Tue, 30 May 2006) $

+// Last change by : $Author: jokusoftware $

+//

+// DESCRIPTION:

+//

+//  Describe me here please...

+//

+// -----------------------------------------------------------------------------

+

+#include "icqoscar.h"

+

+

+

+void write_httphdr(icq_packet* pPacket, WORD wType, DWORD dwSeq)

+{

+  pPacket->wPlace = 0;

+  pPacket->wLen += 14;

+  pPacket->pData = (BYTE*)SAFE_MALLOC(pPacket->wLen);

+

+  packWord(pPacket, (WORD)(pPacket->wLen - 2));

+  packWord(pPacket, HTTP_PROXY_VERSION);

+  packWord(pPacket, wType);

+  packDWord(pPacket, 0); // Flags?

+  packDWord(pPacket, dwSeq); // Connection sequence ?

+}

+

+

+

+void __fastcall write_flap(icq_packet* pPacket, BYTE byFlapChannel)

+{

+  pPacket->wPlace = 0;

+  pPacket->wLen += 6;

+  pPacket->pData = (BYTE*)SAFE_MALLOC(pPacket->wLen);

+

+  packByte(pPacket, FLAP_MARKER);

+  packByte(pPacket, byFlapChannel);

+  packWord(pPacket, 0);                 // This is the sequence ID, it is filled in during the actual sending

+  packWord(pPacket, (WORD)(pPacket->wLen - 6)); // This counter should not include the flap header (thus the -6)

+}

+

+

+

+void __fastcall serverPacketInit(icq_packet* pPacket, WORD wSize)

+{

+  pPacket->wLen = wSize;

+  write_flap(pPacket, ICQ_DATA_CHAN);

+}

+

+

+

+void __fastcall directPacketInit(icq_packet* pPacket, DWORD dwSize)

+{

+  pPacket->wPlace = 0;

+  pPacket->wLen   = (WORD)dwSize;

+  pPacket->pData  = (BYTE *)SAFE_MALLOC(dwSize + 2);

+

+  packLEWord(pPacket, pPacket->wLen);

+}

+

+

+

+void __fastcall serverCookieInit(icq_packet* pPacket, BYTE* pCookie, WORD wCookieSize)

+{

+  pPacket->wLen = (WORD)(wCookieSize + 8);

+

+  write_flap(pPacket, ICQ_LOGIN_CHAN);

+  packDWord(pPacket, 0x00000001);

+  packTLV(pPacket, 0x06, wCookieSize, pCookie);

+}

+

+

+

+void __fastcall packByte(icq_packet* pPacket, BYTE byValue)

+{

+  pPacket->pData[pPacket->wPlace++] = byValue;

+}

+

+

+

+void __fastcall packWord(icq_packet* pPacket, WORD wValue)

+{

+  pPacket->pData[pPacket->wPlace++] = ((wValue & 0xff00) >> 8);

+  pPacket->pData[pPacket->wPlace++] = (wValue & 0x00ff);

+}

+

+

+

+void __fastcall packDWord(icq_packet* pPacket, DWORD dwValue)

+{

+  pPacket->pData[pPacket->wPlace++] = (BYTE)((dwValue & 0xff000000) >> 24);

+  pPacket->pData[pPacket->wPlace++] = (BYTE)((dwValue & 0x00ff0000) >> 16);

+  pPacket->pData[pPacket->wPlace++] = (BYTE)((dwValue & 0x0000ff00) >> 8);

+  pPacket->pData[pPacket->wPlace++] = (BYTE) (dwValue & 0x000000ff);

+}

+

+

+

+void packTLV(icq_packet* pPacket, WORD wType, WORD wLength, BYTE* pbyValue)

+{

+  packWord(pPacket, wType);

+  packWord(pPacket, wLength);

+  packBuffer(pPacket, pbyValue, wLength);

+}

+

+

+

+void packTLVWord(icq_packet* pPacket, WORD wType, WORD wValue)

+{

+  packWord(pPacket, wType);

+  packWord(pPacket, 0x02);

+  packWord(pPacket, wValue);

+}

+

+

+

+void packTLVDWord(icq_packet* pPacket, WORD wType, DWORD dwValue)

+{

+  packWord(pPacket, wType);

+  packWord(pPacket, 0x04);

+  packDWord(pPacket, dwValue);

+}

+

+

+

+// Pack a preformatted buffer.

+// This can be used to pack strings or any type of raw data.

+void packBuffer(icq_packet* pPacket, const BYTE* pbyBuffer, WORD wLength)

+{

+

+  while (wLength)

+  {

+    pPacket->pData[pPacket->wPlace++] = *pbyBuffer++;

+    wLength--;

+  }

+

+}

+

+

+

+// Pack a buffer and prepend it with the size as a LE WORD.

+// Commented out since its not actually used anywhere right now.

+//void packLEWordSizedBuffer(icq_packet* pPacket, const BYTE* pbyBuffer, WORD wLength)

+//{

+//

+//  packLEWord(pPacket, wLength);

+//  packBuffer(pPacket, pbyBuffer, wLength);

+//

+//}

+

+

+int __fastcall getUINLen(DWORD dwUin)

+{ // TODO: invent something more clever

+  if (dwUin >= 1000000000) return 10;

+  if (dwUin >= 100000000) return 9;

+  if (dwUin >= 10000000) return 8;

+  if (dwUin >= 1000000) return 7;

+  if (dwUin >= 100000) return 6;

+  if (dwUin >= 10000) return 5;

+  if (dwUin >= 1000) return 4;

+  if (dwUin >= 100) return 3;

+  if (dwUin >= 10) return 2;

+  return 1;

+}

+

+

+

+int __fastcall getUIDLen(DWORD dwUin, char* szUid)

+{

+  if (dwUin) 

+    return getUINLen(dwUin);

+  else

+    return strlennull(szUid);

+}

+

+

+

+void __fastcall packUIN(icq_packet* pPacket, DWORD dwUin)

+{

+  unsigned char pszUin[UINMAXLEN];

+  BYTE nUinLen = getUINLen(dwUin);

+

+  ltoa(dwUin, pszUin, 10);

+

+  packByte(pPacket, nUinLen);           // Length of user id

+  packBuffer(pPacket, pszUin, nUinLen); // Receiving user's id

+}

+

+

+

+void __fastcall packUID(icq_packet* pPacket, DWORD dwUin, char* szUid)

+{

+  if (dwUin)

+    packUIN(pPacket, dwUin);

+  else

+  {

+    BYTE nLen = strlennull(szUid);

+    packByte(pPacket, nLen);

+    packBuffer(pPacket, szUid, nLen);

+  }

+}

+

+

+

+void packFNACHeader(icq_packet* pPacket, WORD wFamily, WORD wSubtype)

+{

+  packWord(pPacket, wFamily);   // Family type

+  packWord(pPacket, wSubtype);  // Family subtype

+  packDWord(pPacket, 0);        // SNAC flags // SNAC request id (sequence)

+  packWord(pPacket, wSubtype);  // SNAC request id (command)

+}

+

+

+

+void packFNACHeaderFull(icq_packet* pPacket, WORD wFamily, WORD wSubtype, WORD wFlags, DWORD dwSeq)

+{

+  WORD wSeq = (WORD)dwSeq & 0x7FFF; // this is necessary, if that bit is there we get disconnected

+

+  packWord(pPacket, wFamily);   // Family type

+  packWord(pPacket, wSubtype);  // Family subtype

+  packWord(pPacket, wFlags);    // SNAC flags

+  packWord(pPacket, wSeq);      // SNAC request id (sequence)

+  packWord(pPacket, (WORD)(dwSeq>>0x10));  // SNAC request id (command)

+}

+

+

+

+void __fastcall packLEWord(icq_packet* pPacket, WORD wValue)

+{

+  pPacket->pData[pPacket->wPlace++] =  (wValue & 0x00ff);

+  pPacket->pData[pPacket->wPlace++] = ((wValue & 0xff00) >> 8);

+}

+

+

+

+void __fastcall packLEDWord(icq_packet* pPacket, DWORD dwValue)

+{

+  pPacket->pData[pPacket->wPlace++] = (BYTE) (dwValue & 0x000000ff);

+  pPacket->pData[pPacket->wPlace++] = (BYTE)((dwValue & 0x0000ff00) >> 8);

+  pPacket->pData[pPacket->wPlace++] = (BYTE)((dwValue & 0x00ff0000) >> 16);

+  pPacket->pData[pPacket->wPlace++] = (BYTE)((dwValue & 0xff000000) >> 24);

+}

+

+

+

+void ppackByte(PBYTE *buf,int *buflen,BYTE b)

+{

+  *buf=(PBYTE)realloc(*buf,1+*buflen);

+  *(*buf+*buflen)=b;

+  ++*buflen;

+}

+

+

+

+void ppackLEWord(PBYTE *buf,int *buflen,WORD w)

+{

+  *buf=(PBYTE)realloc(*buf,2+*buflen);

+  *(PWORD)(*buf+*buflen)=w;

+  *buflen+=2;

+}

+

+

+

+void ppackLEDWord(PBYTE *buf, int *buflen, DWORD d)

+{

+  *buf = (PBYTE)realloc(*buf, 4 + *buflen);

+  *(PDWORD)(*buf + *buflen) = d;

+  *buflen += 4;

+}

+

+

+

+/*void ppackLNTS(PBYTE *buf, int *buflen, const char *str)

+{

+  WORD len = strlennull(str);

+  ppackWord(buf, buflen, len);

+  *buf = (PBYTE)realloc(*buf, *buflen + len);

+  memcpy(*buf + *buflen, str, len);

+  *buflen += len;

+}*/

+

+

+

+void ppackLELNTS(PBYTE *buf, int *buflen, const char *str)

+{

+  WORD len = strlennull(str);

+  ppackLEWord(buf, buflen, len);

+  *buf = (PBYTE)realloc(*buf, *buflen + len);

+  memcpy(*buf + *buflen, str, len);

+  *buflen += len;

+}

+

+

+

+void ppackLELNTSfromDB(PBYTE *buf, int *buflen, const char *szSetting)

+{

+  DBVARIANT dbv;

+

+  if (ICQGetContactSetting(NULL, szSetting, &dbv))

+  {

+    ppackLEWord(buf, buflen, 0);

+  }

+  else

+  {

+    ppackLELNTS(buf, buflen, dbv.pszVal);

+    ICQFreeVariant(&dbv);

+  }

+}

+

+

+

+// *** TLV based (!!! WORDs and DWORDs are LE !!!)

+void ppackTLVByte(PBYTE *buf, int *buflen, BYTE b, WORD wType, BYTE always)

+{

+  if (!always && !b) return;

+

+  *buf = (PBYTE)realloc(*buf, 5 + *buflen);

+  *(PWORD)(*buf + *buflen) = wType;

+  *(PWORD)(*buf + *buflen + 2) = 1;

+  *(*buf + *buflen + 4) = b;

+  *buflen += 5;

+}

+

+

+

+void ppackTLVWord(PBYTE *buf, int *buflen, WORD w, WORD wType, BYTE always)

+{

+  if (!always && !w) return;

+

+  *buf = (PBYTE)realloc(*buf, 6 + *buflen);

+  *(PWORD)(*buf + *buflen) = wType;

+  *(PWORD)(*buf + *buflen + 2) = 2;

+  *(PWORD)(*buf + *buflen + 4) = w;

+  *buflen += 6;

+}

+

+

+

+void ppackTLVDWord(PBYTE *buf, int *buflen, DWORD d, WORD wType, BYTE always)

+{

+  if (!always && !d) return;

+

+  *buf = (PBYTE)realloc(*buf, 8 + *buflen);

+  *(PWORD)(*buf + *buflen) = wType;

+  *(PWORD)(*buf + *buflen + 2) = 4;

+  *(PDWORD)(*buf + *buflen + 4) = d;

+  *buflen += 8;

+}

+

+

+

+void packTLVLNTS(PBYTE *buf, int *bufpos, const char *str, WORD wType)

+{

+  int len = strlennull(str) + 1;

+

+  *(PWORD)(*buf + *bufpos) = wType;

+  *(PWORD)(*buf + *bufpos + 2) = len + 2;

+  *(PWORD)(*buf + *bufpos + 4) = len;

+  memcpy(*buf + *bufpos + 6, str, len);

+  *bufpos += len + 6;

+}

+

+

+

+void ppackTLVLNTS(PBYTE *buf, int *buflen, const char *str, WORD wType, BYTE always)

+{

+  int len = strlennull(str) + 1;

+

+  if (!always && len < 2) return;

+

+  *buf = (PBYTE)realloc(*buf, 6 + *buflen + len);

+  packTLVLNTS(buf, buflen, str, wType);

+}

+

+

+

+void ppackTLVWordLNTS(PBYTE *buf, int *buflen, WORD w, const char *str, WORD wType, BYTE always)

+{

+  int len = strlennull(str) + 1;

+

+  if (!always && len < 2 && !w) return;

+

+  *buf = (PBYTE)realloc(*buf, 8 + *buflen + len);

+  *(PWORD)(*buf + *buflen) = wType;

+  *(PWORD)(*buf + *buflen + 2) = len + 4;

+  *(PWORD)(*buf + *buflen + 4) = w;

+  *(PWORD)(*buf + *buflen + 6) = len;

+  memcpy(*buf + *buflen + 8, str, len);

+  *buflen += len + 8;

+}

+

+

+

+void ppackTLVLNTSByte(PBYTE *buf, int *buflen, const char *str, BYTE b, WORD wType)

+{

+  int len = strlennull(str) + 1;

+

+  *buf = (PBYTE)realloc(*buf, 7 + *buflen + len);

+  *(PWORD)(*buf + *buflen) = wType;

+  *(PWORD)(*buf + *buflen + 2) = len + 3;

+  *(PWORD)(*buf + *buflen + 4) = len;

+  memcpy(*buf + *buflen + 6, str, len);

+  *(*buf + *buflen + 6 + len) = b;

+  *buflen += len + 7;

+}

+

+

+

+void ppackTLVLNTSfromDB(PBYTE *buf, int *buflen, const char *szSetting, WORD wType)

+{

+  char szTmp[1024];

+  char *str = "";

+

+  if (!ICQGetContactStaticString(NULL, szSetting, szTmp, sizeof(szTmp)))

+    str = szTmp;

+

+  ppackTLVLNTS(buf, buflen, str, wType, 1);

+}

+

+

+

+void ppackTLVWordLNTSfromDB(PBYTE *buf, int *buflen, WORD w, const char *szSetting, WORD wType)

+{

+  char szTmp[1024];

+  char *str = "";

+

+  if (!ICQGetContactStaticString(NULL, szSetting, szTmp, sizeof(szTmp)))

+    str = szTmp;

+

+  ppackTLVWordLNTS(buf, buflen, w, str, wType, 1);

+}

+

+

+

+void ppackTLVLNTSBytefromDB(PBYTE *buf, int *buflen, const char *szSetting, BYTE b, WORD wType)

+{

+  char szTmp[1024];

+  char *str = "";

+

+  if (!ICQGetContactStaticString(NULL, szSetting, szTmp, sizeof(szTmp)))

+    str = szTmp;

+

+  ppackTLVLNTSByte(buf, buflen, str, b, wType);

+}

+

+

+

+void __fastcall unpackByte(BYTE** pSource, BYTE* byDestination)

+{

+  if (byDestination)

+  {

+    *byDestination = *(*pSource)++;

+  }

+  else

+  {

+    *pSource += 1;

+  }

+}

+

+

+

+void __fastcall unpackWord(BYTE** pSource, WORD* wDestination)

+{

+  unsigned char *tmp = *pSource;

+

+  if (wDestination)

+  {

+    *wDestination  = *tmp++ << 8;

+    *wDestination |= *tmp++;

+

+    *pSource = tmp;

+  }

+  else

+  {

+    *pSource += 2;

+  }

+}

+

+

+

+void __fastcall unpackDWord(BYTE** pSource, DWORD* dwDestination)

+{

+  unsigned char *tmp = *pSource;

+

+  if (dwDestination)

+  {

+    *dwDestination  = *tmp++ << 24;

+    *dwDestination |= *tmp++ << 16;

+    *dwDestination |= *tmp++ << 8;

+    *dwDestination |= *tmp++;

+

+    *pSource = tmp;

+  }

+  else

+  {

+    *pSource += 4;

+  }

+}

+

+

+

+void __fastcall unpackLEWord(unsigned char **buf, WORD *w)

+{

+  unsigned char *tmp = *buf;

+

+  if (w)

+  {

+    *w = (*tmp++);

+    *w |= ((*tmp++) << 8);

+  }

+  else

+    tmp += 2;

+

+  *buf = tmp;

+}

+

+

+

+void __fastcall unpackLEDWord(unsigned char **buf, DWORD *dw)

+{

+  unsigned char *tmp = *buf;

+

+  if (dw)

+  {

+    *dw = (*tmp++);

+    *dw |= ((*tmp++) << 8);

+    *dw |= ((*tmp++) << 16);

+    *dw |= ((*tmp++) << 24);

+  }

+  else

+    tmp += 4;

+

+  *buf = tmp;

+}

+

+

+

+void unpackString(unsigned char **buf, char *string, WORD len)

+{

+  unsigned char *tmp = *buf;

+

+  if (string)

+  {

+    while (len)  /* Can have 0x00 so go by len */

+    {

+      *string++ = *tmp++;

+      len--;

+    }

+  }

+  else

+    tmp += len;

+

+  *buf = tmp;

+}

+

+

+

+void unpackWideString(unsigned char **buf, WCHAR *string, WORD len)

+{

+  unsigned char *tmp = *buf;

+

+  while (len > 1)

+  {

+    *string = (*tmp++ << 8);

+    *string |= *tmp++;

+

+    string++;

+    len -= 2;

+  }

+

+  // We have a stray byte at the end, this means that the buffer had an odd length

+  // which indicates an error.

+  _ASSERTE(len == 0);

+  if (len != 0)

+  {

+    // We dont copy the last byte but we still need to increase the buffer pointer

+    // (we assume that 'len' was correct) since the calling function expects

+    // that it is increased 'len' bytes.

+    *tmp += len;

+  }

+

+  *buf = tmp;

+}

+

+

+

+void unpackTypedTLV(unsigned char **buf, int buflen, WORD type, WORD *ttype, WORD *tlen, char **tlv)

+{

+  WORD wType, wLen;

+  unsigned char *tmp = *buf;

+

+NextTLV:

+  // Unpack type and length

+  unpackWord(&tmp, &wType);

+  unpackWord(&tmp, &wLen);

+  buflen -= 4;

+

+  if (wType != type && buflen >= wLen + 4)

+  { // Not the right TLV, try next

+    buflen -= wLen;

+    tmp += wLen;

+    goto NextTLV;

+  }

+  // Check buffer size

+  if (wLen > buflen) wLen = buflen;

+

+  // Make sure we have a good pointer

+  if (tlv)

+  {

+    // Unpack and save value

+    *tlv = (char *)SAFE_MALLOC(wLen + 1); // Add 1 for \0

+    unpackString(&tmp, *tlv, wLen);

+    *(*tlv + wLen) = '\0';

+  }

+  else

+  {

+    *tmp += wLen;

+  }

+

+  // Save type and length

+  if (ttype)

+    *ttype = wType;

+  if (tlen)

+    *tlen = wLen;

+

+  // Increase source pointer

+  *buf = tmp;

+}

+

+

+

+BOOL unpackUID(unsigned char** ppBuf, WORD* pwLen, DWORD *pdwUIN, uid_str* ppszUID)

+{

+  BYTE nUIDLen;

+  char szUIN[UINMAXLEN+1];

+  

+  // Sender UIN

+  unpackByte(ppBuf, &nUIDLen);

+  *pwLen -= 1;

+  

+  if ((nUIDLen > *pwLen) || (nUIDLen == 0))

+    return FALSE;

+

+  if (nUIDLen <= UINMAXLEN)

+  { // it can be uin, check

+    unpackString(ppBuf, szUIN, nUIDLen);

+    szUIN[nUIDLen] = '\0';

+    *pwLen -= nUIDLen;

+

+    if (IsStringUIN(szUIN))

+    {

+      *pdwUIN = atoi(szUIN);

+      return TRUE;

+    }

+    else if (!ppszUID || !gbAimEnabled)

+    {

+      NetLog_Server("Malformed UIN in packet");

+      return FALSE;

+    }

+    else

+    { // go back

+      *ppBuf -= nUIDLen;

+      *pwLen += nUIDLen;

+    }

+  }

+  else if (!ppszUID || ! gbAimEnabled)

+  {

+    NetLog_Server("Malformed UIN in packet");

+    return FALSE;

+  }

+  if (!(*ppszUID)) return FALSE;

+

+  unpackString(ppBuf, *ppszUID, nUIDLen);

+  *pwLen -= nUIDLen;

+  (*ppszUID)[nUIDLen] = '\0';

+

+  *pdwUIN = 0; // this is how we determine aim contacts internally

+

+  return TRUE;

+}