Changeset 6165

Timestamp:

04/20/08 22:10:30 (8 months ago)

Author:

emostar

Message:

* Keep authorization when a user is moved to a new group.
* Add a new class to handle TLVs instead of a struct
* Add a TLVList to ICQUser
* Fix a few parts in the login sequence

Location:

trunk/licq

Files:

• include/licq_buffer.h (modified) (5 diffs)
• include/licq_packets.h (modified) (1 diff)
• include/licq_user.h (modified) (2 diffs)
• src/buffer.cpp (modified) (17 diffs)
• src/icqd-srv.cpp (modified) (13 diffs)
• src/icqpacket.cpp (modified) (14 diffs)
• src/user.cpp (modified) (1 diff)

trunk/licq/include/licq_buffer.h

@@ -1 +1 @@
 #ifndef LICQ_BUFFER_H
 #define LICQ_BUFFER_H
+
+#include <map>
+#include <vector>
+
+#include <boost/shared_array.hpp>
+#include <boost/shared_ptr.hpp>
 
 /*------------------------------------------------------------------------------
@@ -27 +33 @@
 extern void rev_e_long(unsigned long &);
 
-//=====TLV Structs =============================================================
-struct SOscarTLV
+//=====COscarTLV================================================================
+class COscarTLV
 {
-  unsigned short nType;
-  unsigned short nLen;
-  unsigned char *pData;
+public:
+  COscarTLV(unsigned short type = 0, unsigned short length = 0, unsigned char *data = 0) : myType(type), myLen(length)
+  {
+    if (myLen > 0)
+    {
+      myData = boost::shared_array<unsigned char>(new  unsigned char[myLen]);
+      memcpy(myData.get(), data, myLen);
+    }
+  }
+
+  COscarTLV(const COscarTLV &c)
+  {
+    myType = c.myType;
+    myLen = c.myLen;
+    myData = boost::shared_array<unsigned char>(new unsigned char[c.myLen]);
+    memcpy(myData.get(), c.myData.get(), c.myLen);
+  }
+
+  unsigned short getType() const                     { return myType; }
+  unsigned short getLength() const                   { return myLen; }
+  boost::shared_array<unsigned char> getData() const { return myData; }
+
+  void setType(unsigned short type) { myType = type; }
+  void setData(unsigned char *data, unsigned short length)
+  {
+    if (length > 0)
+    {
+      myLen = length;
+      myData = boost::shared_array<unsigned char>(new unsigned char[length]);
+      memcpy(myData.get(), data, length);
+    }
+  }
+
+private:
+  unsigned short myType;
+  unsigned short myLen;
+  boost::shared_array<unsigned char> myData;
+
+friend class CBuffer;
 };
 
-struct SOscarTLV_Chain
-{
-        SOscarTLV *pTLV;
-        SOscarTLV_Chain *pNext;
-};
+typedef boost::shared_ptr<COscarTLV> TLVPtr;
+typedef std::map<unsigned short, TLVPtr> TLVList;
+typedef TLVList::iterator TLVListIter;
 
 //=====CBuffer==================================================================
@@ -111 +151 @@
 
    bool readTLV(int count = -1, int bytes = -1); // This should be called automatically if m_pTLV == 0
-   void cleanupTLV();
 
    void PackTLV(unsigned short, unsigned short, const char *);
    void PackTLV(unsigned short, unsigned short, CBuffer *);
+   void PackTLV(const TLVPtr&);
 
    unsigned short getTLVLen(unsigned short);
@@ -123 +163 @@
    unsigned char UnpackCharTLV(unsigned short);
    char *UnpackStringTLV(unsigned short); // Need to delete[] returned string
+   //std::string UnpackStringTLV(unsigned short);
    CBuffer UnpackTLV(unsigned short);
+
+   TLVList getTLVList();
+   TLVPtr getTLV(unsigned short _nType);
 
 private:
@@ -134 +178 @@
         *m_pDataPosRead;
    unsigned long m_nDataSize;
-   SOscarTLV_Chain *m_pTLV;
+   TLVList myTLVs;
 
-   SOscarTLV *getTLV(unsigned short _nType);
    void antiwarning() { NetworkIpToPacketIp(PacketIpToNetworkIp(127)); }
 };

trunk/licq/include/licq_packets.h

@@ -309 +309 @@
 };
 
+//-----ListRequestRights-----------------------------------------------------
+class CPU_ListRequestRights : public CPU_CommonFamily
+{
+public:
+  CPU_ListRequestRights();
+};
+
 //-----ImICQ------------------------------------------------------------------
 class CPU_ImICQ : public CPU_CommonFamily

trunk/licq/include/licq_user.h

@@ -780 +780 @@
   char *PortStr(char *rbuf);
 
+  // User TLV List handling
+  void AddTLV(TLVPtr);
+  void RemoveTLV(unsigned long);
+  TLVList GetTLVList();
+
   // Don't call these:
   int SocketDesc(unsigned char);
@@ -953 +958 @@
   unsigned short m_nGSID;
 
+  // Extra TLVs attached to this user's SSI info
+  // We use a map to allow fast access to the TLV by type, even though the
+  // actual type is in SOscarTLV as well. Which should make it obvious
+  // that the TLV handling should be fixed in licq_buffer.h/buffer.cpp
+  TLVList myTLVs;
+
   UserEventList m_vcMessages;
 

trunk/licq/src/buffer.cpp

@@ -174 +174 @@
 {
   m_pDataStart = m_pDataPosRead = m_pDataPosWrite = NULL;
-  m_pTLV = NULL;
   m_nDataSize = 0;
 }
@@ -181 +180 @@
 CBuffer::CBuffer(unsigned long _nDataSize)
 {
-  m_pTLV = NULL;
   m_nDataSize = _nDataSize;
   if (_nDataSize)
@@ -204 +202 @@
   m_pDataPosRead = m_pDataStart + (b.getDataPosRead() - b.getDataStart());
   m_pDataPosWrite = m_pDataStart + (b.getDataPosWrite() - b.getDataStart());
-  // DAW FIXME
-  m_pTLV = NULL;
 }
 
@@ -214 +210 @@
   {
      m_pDataStart = m_pDataPosRead = m_pDataPosWrite = NULL;
-     m_pTLV = NULL;
      m_nDataSize = 0;
   }
   else
   {
-    m_pTLV = NULL;
     m_nDataSize = b->getDataMaxSize();
     m_pDataStart = new char[m_nDataSize];
@@ -242 +236 @@
    m_pDataPosRead = m_pDataStart + (b.getDataPosRead() - b.getDataStart());
    m_pDataPosWrite = m_pDataStart + (b.getDataPosWrite() - b.getDataStart());
-   m_pTLV = NULL;
+   myTLVs = b.myTLVs;
 
    return (*this);
@@ -275 +269 @@
    m_pDataStart = new char[m_nDataSize];
    m_pDataPosRead = m_pDataPosWrite = m_pDataStart;
-   m_pTLV = NULL;
 }
 
@@ -462 +455 @@
 {
   if (m_pDataStart != NULL) delete[] m_pDataStart;
-  if (m_pTLV) cleanupTLV();
-  m_pTLV = NULL;
+  myTLVs.clear();
   m_pDataStart = m_pDataPosRead = m_pDataPosWrite = NULL;
   m_nDataSize = 0;
@@ -499 +491 @@
 {
   if (m_pDataStart != NULL) delete[] m_pDataStart;
-  if (m_pTLV) cleanupTLV();
 }
 
@@ -630 +621 @@
 bool CBuffer::readTLV(int nCount, int nBytes)
 {
-  if (m_pTLV || !nCount) return false; // already have one
+  if (!nCount) return false;
+
+  // Clear the list if we already have some TLVs
+  if (myTLVs.size() > 0)
+    myTLVs.clear();
 
   int num = 0;
   int nCurBytes = 0;
 
+  // Keep reading until it is impossible for any TLV headers to be found
   while(getDataPosRead() + 4 < (getDataStart() + getDataSize())) {
-    SOscarTLV_Chain *now = new SOscarTLV_Chain;
-    now->pTLV = new SOscarTLV;
-
-    *this >> now->pTLV->nType;
-    *this >> now->pTLV->nLen;
-
-    rev_e_short(now->pTLV->nType);
-    rev_e_short(now->pTLV->nLen);
-
-    nCurBytes += 4 + now->pTLV->nLen;
-
-    if(getDataPosRead() + now->pTLV->nLen > (getDataStart() + getDataSize()) ||
-       now->pTLV->nLen < 1) {
-      now->pTLV->nLen = 0;
-      now->pTLV->pData = 0;
+    TLVPtr tlv(new COscarTLV);
+
+    *this >> tlv->myType;
+    *this >> tlv->myLen;
+
+    rev_e_short(tlv->myType);
+    rev_e_short(tlv->myLen);
+
+    nCurBytes += 4 + tlv->myLen;
+
+    if(getDataPosRead() + tlv->myLen > (getDataStart() + getDataSize()) ||
+       tlv->myLen < 1) {
+      tlv->myLen = 0;
     }
     else {
-      now->pTLV->pData = new unsigned char[now->pTLV->nLen];
-      memcpy(now->pTLV->pData, m_pDataPosRead, now->pTLV->nLen);
-      m_pDataPosRead += now->pTLV->nLen;
+      tlv->myData.reset(new unsigned char[tlv->myLen]);
+      memcpy(tlv->myData.get(), m_pDataPosRead, tlv->myLen);
+      m_pDataPosRead += tlv->myLen;
     }
 
-    now->pNext = m_pTLV;
-    m_pTLV = now;
+    // Save it in the map
+    myTLVs[tlv->myType] = tlv;
 
     ++num;
-    if (nCount > 0 && num == nCount)
-      return true;
-
-    if (nBytes > 0 && nCurBytes == nBytes)
+    if ((nCount > 0 && num == nCount) ||
+        (nBytes > 0 && nCurBytes == nBytes) )
       return true;
 
@@ -686 +678 @@
 }
 
-void CBuffer::cleanupTLV()
-{
-  if (!m_pTLV) return;
-
-  SOscarTLV_Chain *now = m_pTLV;
-
-  while (now) {
-    SOscarTLV_Chain *tmp;
-
-    if (now->pTLV)
-    {
-      if (now->pTLV->pData)
-    delete [] now->pTLV->pData;
-
-      delete now->pTLV;
-    }
-
-    tmp = now->pNext;
-    delete now;
-    now = tmp;
-  }
-
-  m_pTLV = NULL;
-}
-
 void CBuffer::PackTLV(unsigned short nType, unsigned short nSize,
                const char *data)
@@ -725 +692 @@
   PackUnsignedShortBE(nSize);
   Pack(b);
+}
+
+void CBuffer::PackTLV(const TLVPtr& tlv)
+{
+  PackUnsignedShortBE(tlv->myType);
+  PackUnsignedShortBE(tlv->myLen);
+  Pack(reinterpret_cast<const char *>(tlv->myData.get()), tlv->myLen);
 }
 
@@ -741 +715 @@
 unsigned short CBuffer::getTLVLen(unsigned short nType)
 {
-  SOscarTLV *pTLV = getTLV(nType);
-  if (pTLV)
-    return pTLV->nLen;
-
-  return 0;
+  unsigned short len = 0;
+  TLVListIter iter = myTLVs.find(nType);
+  if (iter != myTLVs.end())
+    len = iter->second->myLen;
+  return len;
 }
 
 bool CBuffer::hasTLV(unsigned short nType)
 {
-  bool bRet = false;
-  SOscarTLV *pTLV = getTLV(nType);
-  if (pTLV)
-    bRet = true;
-
-  return bRet;
+  TLVListIter iter = myTLVs.find(nType);
+  bool found = (iter != myTLVs.end());
+  return found;
 }
 
@@ -762 +733 @@
   unsigned long nRet = 0;
 
-  SOscarTLV *pTLV = getTLV(nType);
-  if (pTLV && pTLV->nLen > 3)
-  {
-    nRet |= (*((pTLV->pData)+0) << 24);
-    nRet |= (*((pTLV->pData)+1) << 16);
-    nRet |= (*((pTLV->pData)+2) << 8);
-    nRet |= (*((pTLV->pData)+3));
+  try
+  {
+    TLVPtr tlv = getTLV(nType);
+    if (tlv->myLen > 3)
+    {
+      nRet |= (*((tlv->myData.get())+0) << 24);
+      nRet |= (*((tlv->myData.get())+1) << 16);
+      nRet |= (*((tlv->myData.get())+2) << 8);
+      nRet |= (*((tlv->myData.get())+3));
+    }
+  }
+  catch (...)
+  {
+    // TODO Throw an exception
   }
 
@@ -778 +756 @@
   unsigned short nRet = 0;
 
-  SOscarTLV *pTLV = getTLV(nType);
-  if (pTLV && pTLV->nLen > 1)
-  {
-    nRet |= (*((pTLV->pData)+0) << 8);
-    nRet |= (*((pTLV->pData)+1));
+  try
+  {
+    TLVPtr tlv = getTLV(nType);
+    if (tlv->myLen > 1)
+    {
+      nRet |= (*((tlv->myData.get())+0) << 8);
+      nRet |= (*((tlv->myData.get())+1));
+    }
+  }
+  catch (...)
+  {
+    // TODO Throw an exception
   }
 
@@ -792 +777 @@
   unsigned char nRet = 0;
 
-  SOscarTLV *pTLV = getTLV(nType);
-  if (pTLV && pTLV->nLen > 0)
-    nRet = *(pTLV->pData);
+  try
+  {
+    TLVPtr tlv = getTLV(nType);
+    if (tlv->myLen > 0)
+      nRet = *(tlv->myData.get());
+  }
+  catch (...)
+  {
+    // TODO Throw an exception
+  }
 
   return nRet;
@@ -804 +796 @@
   char *str = 0;
 
-  SOscarTLV *pTLV = getTLV(nType);
-  if (pTLV)
-  {
-    str = new char[pTLV->nLen+1];
-    if (!str) return 0;
-
-    memcpy(str, pTLV->pData, pTLV->nLen);
-    *(str+pTLV->nLen) = '\0';
+  try
+  {
+    TLVPtr tlv = getTLV(nType);
+    str = new char[tlv->myLen+1];
+    memcpy(str, tlv->myData.get(), tlv->myLen);
+    *(str+tlv->myLen) = '\0';
+  }
+  catch (...)
+  {
+    if (str)
+    {
+      delete [] str;
+      str = 0;
+    }
   }
 
@@ -817 +815 @@
 }
 
+#if 0
+//TODO Add this function and use it everywhere so we don't have to
+// constanly remember to call delete[]
+std::string CBuffer::UnpackStringTLV(unsigned short nType)
+{
+  std::string str;
+
+  try
+  {
+    TLVPtr tlv = getTLV(nType);
+    str.assign(tlv->myData.get(), tlv->myLen);
+  }
+  catch (...)
+  {
+    // TODO Throw an exception
+  }
+
+  return str;
+}
+#endif
+
 CBuffer CBuffer::UnpackTLV(unsigned short nType)
 {
-  SOscarTLV *pTLV = getTLV(nType);
-  if (pTLV)
-  {
-    CBuffer cbuf(pTLV->nLen);
-    cbuf.Pack((const char*)pTLV->pData, pTLV->nLen);
+  try
+  {
+    TLVPtr tlv = getTLV(nType);
+    CBuffer cbuf(tlv->myLen);
+    cbuf.Pack(reinterpret_cast<const char *>(tlv->myData.get()), tlv->myLen);
     cbuf.Reset();
 
     return cbuf;
   }
-  else
+  catch (...)
+  {
     return CBuffer(0);
-}
-
-SOscarTLV *CBuffer::getTLV(unsigned short nType)
-{
-  if (!m_pTLV) return 0;
-
-  SOscarTLV_Chain *now;
-
-  for (now = m_pTLV; now; now = now->pNext)
-    if (now && now->pTLV && now->pTLV->nType == nType)
-        return now->pTLV;
-
-  return 0;
+  }
+}
+
+TLVPtr CBuffer::getTLV(unsigned short nType)
+{
+  if (myTLVs.size() == 0)
+    throw std::exception();
+
+  TLVListIter iter = myTLVs.find(nType);
+  if (iter == myTLVs.end())
+    throw std::exception();
+
+  return iter->second;
+}
+
+TLVList CBuffer::getTLVList()
+{
+  return myTLVs;
 }
 

trunk/licq/src/icqd-srv.cpp

@@ -2216 +2216 @@
 void CICQDaemon::ProcessServiceFam(CBuffer &packet, unsigned short nSubtype)
 {
-  packet.UnpackUnsignedShortBE(); // flags
+  unsigned short snacFlags = packet.UnpackUnsignedShortBE(); // flags
   packet.UnpackUnsignedLongBE(); // sequence
+
+  // TODO The TLVs should be processed first, in a common area, instead of requiring
+  // each case to do the same thing. However, the individual case's may depend on the tlv
+  // coming to them, so leave this commented out for now and do some testing
+  /*
+  if (snacFlags & 0x8000)
+  {
+    unsigned short bytes = packet.UnpackUnsignedShortBE();
+    unsigned short tlvCount = packet.UnpackUnsignedShortBE();
+    if (!packet.readTLV(tlvCount, bytes))
+    {
+      gLog.Error(tr("%sError parsing SNAC header\n"), L_SRVxSTR);
+      return;
+    }
+  }
+  */
 
   switch (nSubtype)
@@ -2256 +2272 @@
 
       gLog.Info(tr("%sRequesting list rights.\n"), L_SRVxSTR);
-      p = new CPU_GenericFamily(ICQ_SNACxFAM_LIST, ICQ_SNACxLIST_REQUESTxRIGHTS);
+      p = new CPU_ListRequestRights();
+      SendExpectEvent_Server(0, p, NULL);
+
+      gLog.Info(tr("%sRequesting roster rights.\n"), L_SRVxSTR);
+      p = new CPU_RequestList();
       SendEvent_Server(p);
-
-      gLog.Info(tr("%sRequesting list.\n"), L_SRVxSTR);
-      p = new CPU_RequestList();
-      SendExpectEvent_Server(0, p, NULL);
 
       gLog.Info(tr("%sRequesting location rights.\n"), L_SRVxSTR);
@@ -2304 +2320 @@
   case ICQ_SNACxRCV_NAMExINFO:
   {
-    unsigned short nUserClass, nLevel;
+    if (snacFlags & 0x8000)
+    {
+      unsigned short bytes = packet.UnpackUnsignedShortBE();
+      if (!packet.readTLV(-1, bytes))
+      {
+        gLog.Error(tr("%sError parsing SNAC header\n"), L_SRVxSTR);
+        return;
+      }
+    }
+
+    unsigned short evil, tlvBlocks;
     unsigned long nUin, realIP;
     time_t nOnlineSince = 0;
@@ -2311 +2337 @@
 
     nUin = packet.UnpackUinString();
-    nLevel = packet.UnpackUnsignedShortBE();
-    nUserClass = packet.UnpackUnsignedShortBE();
-
-    gLog.Info("%sUIN: %lu level: %04hx Class: %04hx\n", L_SRVxSTR,
-              nUin, nLevel, nUserClass );
-
-    if (!packet.readTLV()) {
+    evil = packet.UnpackUnsignedShortBE();
+    tlvBlocks = packet.UnpackUnsignedShortBE();
+
+    gLog.Info("%sUIN: %lu Evil: %04hx\n", L_SRVxSTR, nUin, evil);
+
+    if (!packet.readTLV(tlvBlocks)) {
       char *buf;
       gLog.Unknown(tr("%sUnknown server response:\n%s\n"), L_UNKNOWNxSTR,
@@ -3959 +3984 @@
   unsigned long nSubSequence = packet.UnpackUnsignedLongBE();
 
-  // First 8 bytes - unknown
-  if (nSubtype != ICQ_SNACxLIST_ROSTxREPLY)
-  {
-    packet.UnpackUnsignedLong();
-    packet.UnpackUnsignedLong();
-  } 
+  if (nFlags & 0x8000)
+  {
+    unsigned short bytes = packet.UnpackUnsignedShortBE();
+    if (!packet.readTLV(-1, bytes))
+    {
+      gLog.Error(tr("%sError parsing SNAC header\n"), L_SRVxSTR);
+      return;
+    }
+  }
 
   switch (nSubtype)
@@ -3997 +4025 @@
         if (e == NULL)
         {
-          gLog.Warn(tr("%sContact list without request.\n"), L_SRVxSTR);
+          // Try acking it, even if we didn't expect it
+          //gLog.Warn(tr("%sContact list without request.\n"), L_SRVxSTR);
+          gLog.Info(tr("%sActivate server contact list.\n"), L_SRVxSTR);
+          CSrvPacketTcp *p = new CPU_GenericFamily(ICQ_SNACxFAM_LIST, ICQ_SNACxLIST_ROSTxACK);
+          SendEvent_Server(p);
           break;
         }
@@ -4069 +4101 @@
             if (u)
             {
+              // For now, just save all the TLVs. We should change this to have awaiting auth check
+              // for the 0x0066 TLV, SMS number if it has the 0x013A TLV, etc
+              TLVList tlvList = packet.getTLVList();
+              TLVListIter iter;
+              for (iter = tlvList.begin(); iter != tlvList.end(); ++iter)
+              {
+                TLVPtr tlv = iter->second;
+                u->AddTLV(tlv);
+              }
+
               u->SetGSID(nTag);
 
@@ -4193 +4235 @@
           delete [] szUnicodeName;
 
-        packet.cleanupTLV();
         if (szId)
           delete[] szId;
@@ -4219 +4260 @@
       break;
     } // case rost reply
+
+    case ICQ_SNACxLIST_ROSTxUPD_GROUP:
+    {
+      gLog.Info(tr("%sReceived updated contact information from server.\n"), L_SRVxSTR);
+
+      char *szId = packet.UnpackStringBE();
+      if (szId == 0)
+      {
+        gLog.Error(tr("%sDid not receive user ID.\n"), L_SRVxSTR);
+        break;
+      }
+
+      unsigned short gsid    = packet.UnpackUnsignedShortBE();
+      unsigned short sid     = packet.UnpackUnsignedShortBE();
+      /*unsigned short classid =*/ packet.UnpackUnsignedShortBE();
+
+      unsigned short tlvBytes = packet.UnpackUnsignedShortBE();
+
+      if (!packet.readTLV(-1, tlvBytes))
+      {
+        gLog.Error(tr("%sError during parsing packet!\n"), L_ERRORxSTR);
+        break;
+      }
+
+      ICQUser *u = gUserManager.FetchUser(szId, LICQ_PPID, LOCK_W);
+      if (u)
+      {
+        // First update their gsid/sid
+        u->SetSID(sid);
+        u->SetGSID(gsid);
+
+        // Now the the tlv of attributes to attach to the user
+        TLVList tlvList = packet.getTLVList();
+        TLVListIter iter;
+        for (iter = tlvList.begin(); iter != tlvList.end(); ++iter)
+        {
+          TLVPtr tlv = iter->second;
+          u->AddTLV(tlv);
+        }
+
+        gUserManager.DropUser(u);
+      }
+
+      delete [] szId;
+
+      break;
+    }
 
     case ICQ_SNACxLIST_ROSTxSYNCED:
@@ -4466 +4554 @@
          {
            u->SetAwaitingAuth(false);
+           u->RemoveTLV(0x0066);
            gUserManager.DropUser(u);
          }