Changeset 6405

Show
Ignore:
Timestamp:
07/03/2008 10:13:49 PM (12 months ago)
Author:
flynd
Message:

More UIN removed.

Location:
trunk/licq
Files:
13 modified

Legend:

Unmodified
Added
Removed
  • trunk/licq/include/licq_chat.h

    r6347 r6405  
    599599  void SendBackspace(); 
    600600  void SendCharacter(char); 
    601   void SendKick(unsigned long); 
    602   void SendKickNoVote(unsigned long); 
     601  void SendKick(const char* id); 
     602  void SendKickNoVote(const char* id); 
    603603  void SendVoteYes(unsigned long); 
    604604  void SendVoteNo(unsigned long); 
     
    659659 
    660660  void SendBuffer(CBuffer *, unsigned char, 
    661                   unsigned long _nUin = 0, 
    662                   bool bNotIter = true); 
     661      const char* id = NULL, bool bNotIter = true); 
    663662  bool SendBufferToClient(CBuffer *, unsigned char, CChatUser *); 
    664663  void SendBuffer_Raw(CBuffer *); 
  • trunk/licq/include/licq_icqd.h

    r6404 r6405  
    350350  unsigned long icqFetchAutoResponse(const char *_szId, unsigned long _nPPID, bool bServer = false); 
    351351  // Chat Request 
     352  unsigned long icqChatRequest(const char* id, const char *szReason, 
     353     unsigned short nLevel, bool bServer); 
    352354  unsigned long icqChatRequest(unsigned long nUin, const char *szReason, 
     355     unsigned short nLevel, bool bServer); 
     356  unsigned long icqMultiPartyChatRequest(const char* id, 
     357     const char *szReason, const char *szChatUsers, unsigned short nPort, 
    353358     unsigned short nLevel, bool bServer); 
    354359  unsigned long icqMultiPartyChatRequest(unsigned long nUin, 
    355360     const char *szReason, const char *szChatUsers, unsigned short nPort, 
    356361     unsigned short nLevel, bool bServer); 
     362  void icqChatRequestRefuse(const char* id, const char* szReason, 
     363      unsigned short nSequence, const unsigned long nMsgID[], bool bDirect); 
    357364  void icqChatRequestRefuse(unsigned long nUin, const char *szReason, 
    358365      unsigned short nSequence, const unsigned long nMsgID[], bool bDirect); 
     366  void icqChatRequestAccept(const char* id, unsigned short nPort, 
     367      const char* szClients, unsigned short nSequence, 
     368      const unsigned long nMsgID[], bool bDirect); 
    359369  void icqChatRequestAccept(unsigned long nUin, unsigned short nPort, 
    360370      const char* szClients, unsigned short nSequence, 
    361371      const unsigned long nMsgID[], bool bDirect); 
     372  void icqChatRequestCancel(const char* id, unsigned short nSequence); 
    362373  void icqChatRequestCancel(unsigned long nUin, unsigned short nSequence); 
    363374  // File Transfer 
     
    468479  unsigned long icqAuthorizeRefuse(unsigned long nUin, const char *szMessage); 
    469480  unsigned long icqAuthorizeRefuse(const char *szId, const char *szMessage); 
     481  void icqRequestAuth(const char* id, const char *_szMessage); 
    470482  void icqRequestAuth(unsigned long _nUin, const char *_szMessage); 
    471483  void icqAlertUser(unsigned long _nUin); 
     
    594606 
    595607  // SMS 
     608  unsigned long icqSendSms(const char* id, unsigned long ppid, 
     609      const char* number, const char* message); 
    596610  unsigned long icqSendSms(const char *szNumber, const char *szMessage, 
    597611                           unsigned long nUin); 
     
    805819  void RejectEvent(const char* id, CUserEvent* e); 
    806820  ICQUser *FindUserForInfoUpdate(const char *szId, ICQEvent *e, const char *); 
     821  std::string FindUserByCellular(const char* cellular); 
    807822  unsigned long FindUinByCellular(const char *_szCellular); 
    808823 
  • trunk/licq/include/licq_message.h

    r6347 r6405  
    477477{ 
    478478public: 
    479 #if 0 
    480479  CEventUnknownSysMsg(unsigned short _nSubCommand, 
    481480                unsigned short _nCommand, const char *_szId, unsigned long _nPPID, 
    482481                const char *_szMsg, 
    483482                time_t _tTime, unsigned long _nFlags); 
    484 #endif 
    485   CEventUnknownSysMsg(unsigned short _nSubCommand, 
    486                 unsigned short _nCommand, unsigned long _nUin, 
    487                 const char *_szMsg, 
    488                 time_t _tTime, unsigned long _nFlags); 
    489483  ~CEventUnknownSysMsg(); 
    490484  virtual CEventUnknownSysMsg* Copy() const; 
     
    492486protected: 
    493487  void CreateDescription() const; 
    494    unsigned long m_nUin; 
    495488   char *m_szMsg; 
    496 #if 0 
    497489   char *m_szId; 
    498490   unsigned long m_nPPID; 
     491}; 
     492 
    499493#endif 
    500 }; 
    501  
    502 #endif 
  • trunk/licq/include/licq_packets.h

    r6402 r6405  
    944944{ 
    945945public: 
    946   CPU_RequestAuth(unsigned long, const char *); 
     946  CPU_RequestAuth(const char* id, const char *); 
    947947}; 
    948948 
  • trunk/licq/src/fifo.cpp

    r6382 r6405  
    2828#include <cstring> 
    2929#include <cctype> 
     30#include <string> 
    3031#include <sys/types.h> 
    3132#include <unistd.h> 
     
    5758#include "licq_icqd.h" 
    5859 
     60using std::string; 
    5961 
    6062#define ReportMissingParams(cmdname) \ 
     
    469471      if (u != NULL) 
    470472      { 
    471         const char *szNumber = u->GetCellularNumber(); 
    472         if (strlen(szNumber)) 
    473           d->icqSendSms(szNumber, argv[2], u->Uin() ); 
     473        string number = u->GetCellularNumber(); 
     474        gUserManager.DropUser(u); 
     475        if (!number.empty()) 
     476          d->icqSendSms(szId, nPPID, number.c_str(), argv[2]); 
    474477        else 
    475478          gLog.Error("%sUnable to send SMS to %s, no SMS number found.\n", 
    476479                     L_ERRORxSTR, szId); 
    477  
    478         gUserManager.DropUser(u); 
    479480      } 
    480481    } 
     
    501502  } 
    502503 
    503   ICQOwner* owner = gUserManager.FetchOwner(LICQ_PPID, LOCK_R); 
    504   d->icqSendSms(argv[1], argv[2], owner->Uin()); 
    505   gUserManager.DropOwner(owner); 
     504  string id = gUserManager.OwnerId(LICQ_PPID); 
     505  d->icqSendSms(id.c_str(), LICQ_PPID, argv[1], argv[2]); 
    506506  return 0; 
    507507} 
  • trunk/licq/src/history.cpp

    r6177 r6405  
    1717#include <sys/types.h> 
    1818#include <fcntl.h> 
     19#include <string> 
    1920 
    2021// Localization 
     
    3940 
    4041#define MAX_HISTORY_MSG_SIZE 8192 
     42 
     43using std::string; 
    4144 
    4245CUserHistory::CUserHistory() 
     
    250253    { 
    251254      GET_VALID_LINE_OR_BREAK; 
    252       unsigned long nUin = atol(&szResult[1]); 
     255        char* id = strdup(&szResult[1]); 
    253256      GET_VALID_LINE_OR_BREAK; 
    254257      char *szAlias = strdup(&szResult[1]); 
     
    260263      char *szEmail = strdup(&szResult[1]); 
    261264      GET_VALID_LINES; 
    262       e = new CEventAuthRequest(nUin, szAlias, szFName, szLName, szEmail, szMsg, 
    263                             nCommand, tTime, nFlags); 
     265        e = new CEventAuthRequest(id, LICQ_PPID, szAlias, szFName, szLName, 
     266            szEmail, szMsg, nCommand, tTime, nFlags); 
     267        free(id); 
    264268      free(szAlias); 
    265269      free(szFName); 
     
    271275    { 
    272276      GET_VALID_LINE_OR_BREAK; 
    273       unsigned long nUin = atol(&szResult[1]); 
    274       GET_VALID_LINES; 
    275       e = new CEventAuthGranted(nUin, szMsg, nCommand, tTime, nFlags); 
     277        char* id = strdup(&szResult[1]); 
     278      GET_VALID_LINES; 
     279        e = new CEventAuthGranted(id, LICQ_PPID, szMsg, nCommand, tTime, nFlags); 
     280        free(id); 
    276281      break; 
    277282    } 
     
    279284    { 
    280285      GET_VALID_LINE_OR_BREAK; 
    281       unsigned long nUin = atol(&szResult[1]); 
    282       GET_VALID_LINES; 
    283       e = new CEventAuthRefused(nUin, szMsg, nCommand, tTime, nFlags); 
     286        char* id = strdup(&szResult[1]); 
     287      GET_VALID_LINES; 
     288        e = new CEventAuthRefused(id, LICQ_PPID, szMsg, nCommand, tTime, nFlags); 
     289        free(id); 
    284290      break; 
    285291    } 
     
    287293    { 
    288294      GET_VALID_LINE_OR_BREAK; 
    289       unsigned long nUin = atol(&szResult[1]); 
     295        char* id = strdup(&szResult[1]); 
    290296      GET_VALID_LINE_OR_BREAK; 
    291297      char *szAlias = strdup(&szResult[1]); 
     
    296302      GET_VALID_LINE_OR_BREAK; 
    297303      char *szEmail = strdup(&szResult[1]); 
    298       e = new CEventAdded(nUin, szAlias, szFName, szLName, szEmail, 
     304        e = new CEventAdded(id, LICQ_PPID, szAlias, szFName, szLName, szEmail, 
    299305                            nCommand, tTime, nFlags); 
     306        free(id); 
    300307      free(szAlias); 
    301308      free(szFName); 
     
    334341      ContactList vc; 
    335342      bool b = true; 
    336       unsigned long nUin = 0; 
     343      string id; 
    337344      while (true) 
    338345      { 
    339346        GET_VALID_LINE_OR_BREAK; 
    340347        if (b) 
    341           nUin = atol(&szResult[1]); 
    342         else if (nUin != 0) 
    343           vc.push_back(new CContact(nUin, &szResult[1])); 
     348          id = &szResult[1]; 
     349        else if (!id.empty()) 
     350          vc.push_back(new CContact(id.c_str(), LICQ_PPID, &szResult[1])); 
    344351        b = !b; 
    345352      } 
  • trunk/licq/src/icqd-chat.cpp

    r6402 r6405  
    124124{ 
    125125  m_nVersion = u->Version(); 
    126   m_nUin = u->Uin(); 
    127126  m_szId = strdup(u->IdString()); 
     127  m_nUin = strtoul(m_szId, NULL, 10); 
    128128  m_nPPID = u->PPID(); 
    129129  m_nIp = u->Ip(); 
     
    793793  bool bTryDirect = true; 
    794794  bool bResult = false; 
    795   ICQUser *temp_user = gUserManager.FetchUser(u->uin, LOCK_R); 
     795  ICQUser* temp_user = gUserManager.FetchUser(u->szId, u->nPPID, LOCK_R); 
    796796  if (temp_user != NULL) 
    797797  { 
     
    883883  u->m_pClient = new CChatClient(); 
    884884  u->m_pClient->m_nVersion = s->Version(); 
    885   u->m_pClient->m_nUin = s->Owner(); 
    886885  u->m_pClient->m_szId = strdup(s->OwnerId()); 
     886  u->m_pClient->m_nUin = strtoul(u->m_pClient->m_szId, NULL, 10); 
    887887  u->m_pClient->m_nPPID = s->OwnerPPID(); 
    888888  u->m_pClient->m_nIp = s->RemoteIp(); 
     
    10901090 
    10911091      CPChat_ColorFont pin(u->sock.RecvBuffer()); 
    1092       u->uin = pin.Uin(); 
    10931092      u->szId = strdup(pin.Id()); 
     1093      u->uin = strtoul(u->szId, NULL, 10); 
    10941094      u->nPPID = pin.PPID(); 
    10951095//      m_nSession = pin.Session(); 
     
    14621462        unsigned long nUin = u->chatQueue[0] | (u->chatQueue[1] << 8) | 
    14631463          (u->chatQueue[2] << 16) | (u->chatQueue[3] << 24); 
     1464        char id[16]; 
     1465        snprintf(id, 16, "%lu", nUin); 
    14641466 
    14651467        // Deque all the characters 
     
    14711473        for (iter = chatUsers.begin(); iter != chatUsers.end(); ++iter) 
    14721474        { 
    1473           if((*iter)->Uin() == nUin) 
     1475          if (strcmp((*iter)->Id(), id) == 0) 
    14741476            break; 
    14751477        } 
     
    14781480 
    14791481        CBuffer bye(4); 
    1480         SendBuffer(&bye, CHAT_DISCONNECTIONxKICKED, nUin, true); 
     1482        SendBuffer(&bye, CHAT_DISCONNECTIONxKICKED, id, true); 
    14811483 
    14821484        CloseClient(*iter); 
     
    17491751          unsigned long nUin = u->chatQueue[0] | (u->chatQueue[1] << 8) | 
    17501752            (u->chatQueue[2] << 16) | (u->chatQueue[3] << 24); 
     1753          char id[16]; 
     1754          snprintf(id, 16, "%lu", nUin); 
    17511755 
    17521756          // Find the user and say bye-bye to him 
     
    17541758          for (iter = chatUsers.begin(); iter != chatUsers.end(); ++iter) 
    17551759          { 
    1756             if((*iter)->Uin() == nUin) 
     1760            if (strcmp((*iter)->Id(), id) == 0) 
    17571761             break; 
    17581762          } 
     
    17611765 
    17621766          CBuffer bye(4); 
    1763           SendBuffer(&bye, CHAT_DISCONNECTIONxKICKED, nUin, true); 
     1767          SendBuffer(&bye, CHAT_DISCONNECTIONxKICKED, id, true); 
    17641768 
    17651769          CloseClient(*iter); 
     
    18641868//-----CChatManager::SendBuffer---------------------------------------------- 
    18651869void CChatManager::SendBuffer(CBuffer *b, unsigned char cmd, 
    1866                               unsigned long _nUin, 
    1867                               bool bNotIter) 
     1870    const char* id, bool bNotIter) 
    18681871{ 
    18691872  ChatUserList::iterator iter; 
     
    18711874  bool ok = false; 
    18721875 
    1873   if (_nUin != 0) 
     1876  if (id != NULL) 
    18741877  { 
    18751878    for (u_iter = chatUsers.begin(); u_iter != chatUsers.end(); ++u_iter) 
    18761879    { 
    1877       if ((*u_iter)->Uin() == _nUin) 
     1880      if (strcmp((*u_iter)->Id(), id) == 0) 
    18781881        break; 
    18791882    } 
     
    18881891 
    18891892    // Send it to every user 
    1890     if (_nUin == 0) 
     1893    if (id == NULL) 
    18911894    { 
    18921895      for (iter = chatUsers.begin(); iter != chatUsers.end(); ++iter) 
     
    20222025 
    20232026 
    2024 void CChatManager::SendKick(unsigned long _nUin) 
    2025 { 
     2027void CChatManager::SendKick(const char* id) 
     2028{ 
     2029  unsigned long _nUin = strtoul(id, NULL, 10); 
     2030 
    20262031  // Take care of the vote stuff now 
    20272032  // The user we are kicking automatically is a no vote 
     
    20382043  CBuffer buf(4); 
    20392044  buf.PackUnsignedLong(_nUin); 
    2040   SendBuffer(&buf, CHAT_KICK, _nUin, true); 
    2041 } 
    2042  
    2043  
    2044 void CChatManager::SendKickNoVote(unsigned long _nUin) 
    2045 { 
     2045  SendBuffer(&buf, CHAT_KICK, id, true); 
     2046} 
     2047 
     2048 
     2049void CChatManager::SendKickNoVote(const char *id) 
     2050{ 
     2051  unsigned long _nUin = strtoul(id, NULL, 10); 
     2052 
    20462053  // Tell everyone that this user has been kicked 
    20472054  CBuffer buf_TellAll(6); 
     
    20492056  buf_TellAll.PackChar(0x02); 
    20502057  buf_TellAll.PackChar(0x01); 
    2051   SendBuffer(&buf_TellAll, CHAT_KICKxPASS, _nUin, true); 
     2058  SendBuffer(&buf_TellAll, CHAT_KICKxPASS, id, true); 
    20522059 
    20532060  // They don't know if there was a vote or not, they just see they've been kicked 
     
    20552062  buf.PackChar(0x02); 
    20562063  buf.PackChar(0x01); 
    2057   SendBuffer(&buf, CHAT_KICKxYOU, _nUin, false); 
     2064  SendBuffer(&buf, CHAT_KICKxYOU, id, false); 
    20582065 
    20592066  // And close the connection to the kicked user 
     
    20612068  for (iter = chatUsers.begin(); iter != chatUsers.end(); ++iter) 
    20622069  { 
    2063     if((*iter)->Uin() == _nUin) 
     2070    if(strcmp((*iter)->Id(), id) == 0) 
    20642071      break; 
    20652072  } 
     
    20682075 
    20692076  CBuffer bye(4); 
    2070   SendBuffer(&bye, CHAT_DISCONNECTIONxKICKED, _nUin, false); 
     2077  SendBuffer(&bye, CHAT_DISCONNECTIONxKICKED, id, false); 
    20712078 
    20722079  CloseClient(*iter); 
     
    22472254void CChatManager::FinishKickVote(VoteInfoList::iterator iter, bool bPassed) 
    22482255{ 
     2256  char voteId[16]; 
     2257  snprintf(voteId, 16, "%lu", (*iter)->nUin); 
     2258 
    22492259  // Find the person we are kicking in the ChatUserList 
    22502260  ChatUserList::iterator userIter; 
    22512261  for (userIter = chatUsers.begin(); userIter != chatUsers.end(); ++userIter) 
    22522262  { 
    2253     if ((*userIter)->Uin() == (*iter)->nUin) 
     2263    if (strcmp((*userIter)->Id(), voteId) == 0) 
    22542264      break; 
    22552265  } 
     
    22712281 
    22722282  if (bPassed) 
    2273     SendBuffer(&buf, CHAT_KICKxPASS, (*iter)->nUin, true); 
     2283    SendBuffer(&buf, CHAT_KICKxPASS, voteId, true); 
    22742284  else 
    2275     SendBuffer(&buf, CHAT_KICKxFAIL, (*iter)->nUin, true); 
     2285    SendBuffer(&buf, CHAT_KICKxFAIL, voteId, true); 
    22762286 
    22772287  // Send the person a notice if they were kicked 
    22782288  if (bPassed) 
    22792289  { 
    2280     SendBuffer(&buf, CHAT_KICKxYOU, (*iter)->nUin, false); 
     2290    SendBuffer(&buf, CHAT_KICKxYOU, voteId, false); 
    22812291    CloseClient(*userIter); 
    22822292  } 
     
    23212331    if (sz[0] != '\0') nPos += sprintf(&sz[nPos], ", "); 
    23222332    if ((*iter)->Name()[0] == '\0') 
    2323       nPos += sprintf(&sz[nPos], "%lu", (*iter)->Uin()); 
     2333      nPos += sprintf(&sz[nPos], "%s", (*iter)->Id()); 
    23242334    else 
    23252335      nPos += sprintf(&sz[nPos], "%s", (*iter)->Name()); 
     
    25012511 
    25022512  bool bSendIntIp = false; 
    2503   ICQUser *temp_user = gUserManager.FetchUser(rc->u->Uin(), LOCK_R); 
     2513  ICQUser* temp_user = gUserManager.FetchUser(rc->u->Id(), rc->u->PPID(), LOCK_R); 
    25042514  if (temp_user != NULL) 
    25052515  { 
  • trunk/licq/src/icqd-srv.cpp

    r6404 r6405  
    10681068void CICQDaemon::icqRequestAuth(unsigned long _nUin, const char *_szMessage) 
    10691069{ 
    1070   CSrvPacketTcp *p = new CPU_RequestAuth(_nUin, _szMessage); 
     1070  char id[16]; 
     1071  snprintf(id, 16, "%lu", _nUin); 
     1072  icqRequestAuth(id, _szMessage); 
     1073} 
     1074 
     1075void CICQDaemon::icqRequestAuth(const char* id, const char *_szMessage) 
     1076{ 
     1077  CSrvPacketTcp* p = new CPU_RequestAuth(id, _szMessage); 
    10711078  SendEvent_Server(p); 
    10721079} 
     
    17261733                     unsigned long nUin) 
    17271734{ 
    1728   CEventSms *ue = new CEventSms(szNumber, szMessage, ICQ_CMDxSND_THRUxSERVER, TIME_NOW, INT_VERSION); 
    1729   CPU_SendSms *p = new CPU_SendSms(szNumber, szMessage); 
     1735  char id[16]; 
     1736  snprintf(id, 16, "%lu", nUin); 
     1737  return icqSendSms(id, LICQ_PPID, szNumber, szMessage); 
     1738} 
     1739 
     1740unsigned long CICQDaemon::icqSendSms(const char* id, unsigned long ppid, 
     1741    const char* number, const char* message) 
     1742{ 
     1743  CEventSms* ue = new CEventSms(number, message, ICQ_CMDxSND_THRUxSERVER, TIME_NOW, INT_VERSION); 
     1744  CPU_SendSms* p = new CPU_SendSms(number, message); 
    17301745  gLog.Info(tr("%sSending SMS through server (#%hu/#%d)...\n"), L_SRVxSTR, 
    1731             p->Sequence(), p->SubSequence()); 
    1732   ICQEvent *e = SendExpectEvent_Server(nUin, p, ue); 
     1746      p->Sequence(), p->SubSequence()); 
     1747  ICQEvent* e = SendExpectEvent_Server(id, ppid, p, ue); 
    17331748  if (e != NULL) 
    17341749    return e->EventId(); 
     
    21712186unsigned long CICQDaemon::FindUinByCellular(const char *szCellular) 
    21722187{ 
     2188  return strtoul(FindUserByCellular(szCellular).c_str(), NULL, 10); 
     2189} 
     2190 
     2191string CICQDaemon::FindUserByCellular(const char *szCellular) 
     2192{ 
    21732193  char szParsedNumber1[16], szParsedNumber2[16]; 
    2174   unsigned long nUin = 0; 
    2175    
     2194  string id; 
     2195 
    21762196  FOR_EACH_USER_START(LOCK_R) 
    21772197  { 
     
    21792199    ParseDigits(szParsedNumber2, szCellular, 15); 
    21802200    if (!strcmp(szParsedNumber1, szParsedNumber2)) 
    2181       nUin = strtoul(pUser->IdString(), NULL, 10); 
     2201      id = pUser->IdString(); 
    21822202  } 
    21832203  FOR_EACH_USER_END 
    21842204 
    2185   return nUin; 
     2205  return id; 
    21862206} 
    21872207 
     
    37733793          delete [] buf; 
    37743794          //TODO 
    3775           CEventUnknownSysMsg *e = new CEventUnknownSysMsg(nTypeMsg, ICQ_CMDxRCV_SYSxMSGxONLINE, 
    3776                                                            strtoul(szId, (char **)NULL, 10),  
    3777                                                            szMessage, nTimeSent, 0); 
     3795              CEventUnknownSysMsg* e = new CEventUnknownSysMsg(nTypeMsg, ICQ_CMDxRCV_SYSxMSGxONLINE, 
     3796                  szId, LICQ_PPID, szMessage, nTimeSent, 0); 
    37783797 
    37793798          ICQOwner *o = gUserManager.FetchOwner(LICQ_PPID, LOCK_W); 
     
    38563875        CEventSms *eSms = (CEventSms *)eEvent; 
    38573876      //TODO 
    3858         unsigned long nUinSms = FindUinByCellular(eSms->Number()); 
    3859  
    3860         if (nUinSms != 0) 
    3861         { 
     3877      string idSms = FindUserByCellular(eSms->Number()); 
     3878 
     3879      if (!idSms.empty()) 
     3880      { 
    38623881        //TODO 
    3863           ICQUser* u = gUserManager.FetchUser(nUinSms, LOCK_W); 
    3864           gLog.Info(tr("%sSMS from %s - %s (%lu).\n"), L_SBLANKxSTR, eSms->Number(),  
    3865                   u->GetAlias(), nUinSms); 
     3882        ICQUser* u = gUserManager.FetchUser(idSms.c_str(), LICQ_PPID, LOCK_W); 
     3883        gLog.Info(tr("%sSMS from %s - %s (%s).\n"), L_SBLANKxSTR, eSms->Number(), 
     3884            u->GetAlias(), idSms.c_str()); 
    38663885          if (AddUserEvent(u, eEvent)) 
    38673886            m_xOnEventManager.Do(ON_EVENT_SMS, u); 
     
    47534772      unsigned long nUin; 
    47544773      unsigned long nTimeSent; 
    4755        
     4774 
    47564775      nUin = msg.UnpackUnsignedLong(); 
     4776          char id[16]; 
     4777          snprintf(id, 16, "%lu", nUin); 
    47574778 
    47584779      sendTM.tm_year = msg.UnpackUnsignedShort() - 1900; 
     
    48084829    case ICQ_CMDxSUB_AUTHxREQUEST: 
    48094830    { 
    4810       gLog.Info(tr("%sOffline authorization request from %lu.\n"), L_SBLANKxSTR, nUin); 
    4811        
     4831              gLog.Info(tr("%sOffline authorization request from %s.\n"), L_SBLANKxSTR, id); 
     4832 
    48124833      char **szFields = new char *[6];  // alias, first name, last name, email, auth, comment 
    48134834           
     
    48294850          gTranslator.ServerToClient (szFields[5]);  // comment 
    48304851 
    4831           CEventAuthRequest *e = new CEventAuthRequest(nUin, szFields[0], szFields[1], 
    4832                                                        szFields[2], szFields[3], szFields[5], 
    4833                                                       ICQ_CMDxRCV_SYSxMSGxOFFLINE, nTimeSent, 0); 
    4834       delete [] szFields;    
     4852              CEventAuthRequest *e = new CEventAuthRequest(id, LICQ_PPID, 
     4853                  szFields[0], szFields[1], szFields[2], szFields[3], 
     4854                  szFields[5], ICQ_CMDxRCV_SYSxMSGxOFFLINE, nTimeSent, 0); 
     4855              delete [] szFields; 
    48354856      eEvent = e; 
    48364857      break; 
     
    48384859    case ICQ_CMDxSUB_AUTHxREFUSED:  // system message: authorization refused 
    48394860        { 
    4840           gLog.Info(tr("%sOffline authorization refused by %lu.\n"), L_SBLANKxSTR, nUin); 
     4861              gLog.Info(tr("%sOffline authorization refused by %s.\n"), L_SBLANKxSTR, id); 
    48414862 
    48424863          // Translating string with Translation Table 
    48434864          gTranslator.ServerToClient(szMessage); 
    48444865 
    4845           CEventAuthRefused *e = new CEventAuthRefused(nUin, szMessage, ICQ_CMDxRCV_SYSxMSGxOFFLINE, 
    4846                               nTimeSent, 0); 
     4866              CEventAuthRefused* e = new CEventAuthRefused(id, LICQ_PPID, 
     4867                  szMessage, ICQ_CMDxRCV_SYSxMSGxOFFLINE, nTimeSent, 0); 
    48474868      eEvent = e; 
    48484869      break; 
     
    48504871    case ICQ_CMDxSUB_AUTHxGRANTED:  // system message: authorized 
    48514872        { 
    4852           gLog.Info(tr("%sOffline authorization granted by %lu.\n"), L_SBLANKxSTR, nUin); 
     4873              gLog.Info(tr("%sOffline authorization granted by %s.\n"), L_SBLANKxSTR, id); 
    48534874 
    48544875          // translating string with Translation Table 
    48554876          gTranslator.ServerToClient (szMessage); 
    48564877 
    4857           ICQUser *u = gUserManager.FetchUser(nUin, LOCK_W); 
     4878              ICQUser* u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_W); 
    48584879          if (u) 
    48594880          { 
     
    48624883          } 
    48634884 
    4864           CEventAuthGranted *e = new CEventAuthGranted(nUin, szMessage, ICQ_CMDxRCV_SYSxMSGxOFFLINE, 
    4865                                                       nTimeSent, 0); 
     4885              CEventAuthGranted* e = new CEventAuthGranted(id, LICQ_PPID, 
     4886                  szMessage, ICQ_CMDxRCV_SYSxMSGxOFFLINE, nTimeSent, 0); 
    48664887      eEvent = e; 
    48674888      break; 
     
    48854906    case ICQ_CMDxSUB_ADDEDxTOxLIST:  // system message: added to a contact list 
    48864907        { 
    4887           gLog.Info(tr("%sUser %lu added you to their contact list (offline).\n"), L_SBLANKxSTR, nUin); 
     4908              gLog.Info(tr("%sUser %s added you to their contact list (offline).\n"), L_SBLANKxSTR, id); 
    48884909 
    48894910          char **szFields = new char *[6]; // alias, first name, last name, email, auth, comment 
     
    49054926          gTranslator.ServerToClient (szFields[2]);  // last name 
    49064927 
    4907           CEventAdded *e = new CEventAdded(nUin, szFields[0], szFields[1], 
    4908                                           szFields[2], szFields[3], 
    4909                                            ICQ_CMDxRCV_SYSxMSGxOFFLINE, nTimeSent, 0); 
    4910       delete [] szFields;    
     4928              CEventAdded* e = new CEventAdded(id, LICQ_PPID, szFields[0], 
     4929                  szFields[1], szFields[2], szFields[3], 
     4930                  ICQ_CMDxRCV_SYSxMSGxOFFLINE, nTimeSent, 0); 
     4931              delete [] szFields; 
    49114932      eEvent = e; 
    49124933      break; 
     
    50105031                       nTypeMsg, packet.print(buf)); 
    50115032          delete [] buf; 
    5012           CEventUnknownSysMsg *e = new CEventUnknownSysMsg(nTypeMsg, ICQ_CMDxRCV_SYSxMSGxOFFLINE, 
    5013                                                            nUin, szMessage, nTimeSent, 0); 
     5033              CEventUnknownSysMsg* e = new CEventUnknownSysMsg(nTypeMsg, 
     5034                  ICQ_CMDxRCV_SYSxMSGxOFFLINE, id, LICQ_PPID, szMessage, nTimeSent, 0); 
    50145035 
    50155036              ICQOwner* o = gUserManager.FetchOwner(LICQ_PPID, LOCK_W); 
     
    50265047      case ICQ_CMDxSUB_CONTACTxLIST: 
    50275048      { 
    5028             // Lock the user to add the message to their queue 
    5029             ICQUser* u = gUserManager.FetchUser(nUin, LOCK_W); 
    5030             if (u == NULL) 
    5031             { 
    5032               if (Ignore(IGNORE_NEWUSERS)) 
    5033               { 
    5034             gLog.Info(tr("%sOffline %s from new user (%lu), ignoring.\n"), L_SBLANKxSTR, szType, nUin); 
    5035         if (szType) free(szType); 
    5036             RejectEvent(nUin, eEvent); 
    5037             break; 
    5038               } 
    5039               gLog.Info(tr("%sOffline %s from new user (%lu).\n"), L_SBLANKxSTR, szType, nUin); 
    5040               AddUserToList(nUin); 
    5041               u = gUserManager.FetchUser(nUin, LOCK_W); 
    5042             } 
    5043             else 
    5044               gLog.Info(tr("%sOffline %s through server from %s (%lu).\n"), L_SBLANKxSTR, 
    5045                         szType, u->GetAlias(), nUin); 
     5049                // Lock the user to add the message to their queue 
     5050                ICQUser* u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_W); 
     5051                if (u == NULL) 
     5052                { 
     5053                  if (Ignore(IGNORE_NEWUSERS)) 
     5054                  { 
     5055                    gLog.Info(tr("%sOffline %s from new user (%s), ignoring.\n"), 
     5056                        L_SBLANKxSTR, szType, id); 
     5057                    if (szType) free(szType); 
     5058                      RejectEvent(id, eEvent); 
     5059                    break; 
     5060                  } 
     5061                  gLog.Info(tr("%sOffline %s from new user (%s).\n"), L_SBLANKxSTR, szType, id); 
     5062                  AddUserToList(id, LICQ_PPID); 
     5063                  u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_W); 
     5064                } 
     5065                else 
     5066                  gLog.Info(tr("%sOffline %s through server from %s (%s).\n"), 
     5067                      L_SBLANKxSTR, szType, u->GetAlias(), id); 
    50465068 
    50475069            if (szType) free(szType); 
     
    50595081      case ICQ_CMDxSUB_EMAILxPAGER: 
    50605082      { 
    5061             ICQUser *u = gUserManager.FetchUser(nUin, LOCK_R); 
     5083                ICQUser* u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_R); 
    50625084            bool bIgnore = false; 
    50635085            if (u) 
     
    50875109      case ICQ_CMDxSUB_SMS: 
    50885110      { 
    5089         CEventSms *eSms = (CEventSms *)eEvent;  
    5090         unsigned long nUinSms = FindUinByCellular(eSms->Number()); 
    5091          
    5092         if (nUinSms != 0) 
    5093         { 
    5094           ICQUser* u = gUserManager.FetchUser(nUinSms, LOCK_W); 
    5095           gLog.Info(tr("%sOffline SMS from %s - %s (%lu).\n"), L_SBLANKxSTR, eSms->Number(), u->GetAlias(), nUin); 
     5111                CEventSms* eSms = (CEventSms *)eEvent; 
     5112                string idSms = FindUserByCellular(eSms->Number()); 
     5113 
     5114                if (!idSms.empty()) 
     5115                { 
     5116                  ICQUser* u = gUserManager.FetchUser(idSms.c_str(), LICQ_PPID, LOCK_W); 
     5117                  gLog.Info(tr("%sOffline SMS from %s - %s (%s).\n"), L_SBLANKxSTR, 
     5118                      eSms->Number(), u->GetAlias(), id); 
    50965119          if (AddUserEvent(u, eEvent)) 
    50975120            m_xOnEventManager.Do(ON_EVENT_SMS, u); 
     
    55635586            icqRequestMetaInfo(szUin); 
    55645587 
    5565           e->m_pSearchAck = new CSearchAck(nUin); 
     5588          e->m_pSearchAck = new CSearchAck(szUin, LICQ_PPID); 
    55665589        } 
    55675590        else 
  • trunk/licq/src/icqd-tcp.cpp

    r6402 r6405  
    895895                                         unsigned short nLevel, bool bServer) 
    896896{ 
    897   return icqMultiPartyChatRequest(nUin, szReason, NULL, 0, nLevel, bServer); 
     897  char id[16]; 
     898  snprintf(id, 16, "%lu", nUin); 
     899  return icqMultiPartyChatRequest(id, szReason, NULL, 0, nLevel, bServer); 
     900} 
     901 
     902unsigned long CICQDaemon::icqChatRequest(const char* id, const char *szReason, 
     903                                         unsigned short nLevel, bool bServer) 
     904{ 
     905  return icqMultiPartyChatRequest(id, szReason, NULL, 0, nLevel, bServer); 
    898906} 
    899907 
     
    903911   unsigned short nLevel, bool bServer) 
    904912{ 
    905   if (nUin == gUserManager.icqOwnerUin()) 
     913  char id[16]; 
     914  snprintf(id, 16, "%lu", nUin); 
     915  return icqMultiPartyChatRequest(id, reason, szChatUsers, nPort, nLevel, bServer); 
     916} 
     917 
     918unsigned long CICQDaemon::icqMultiPartyChatRequest(const char* id, 
     919   const char *reason, const char *szChatUsers, unsigned short nPort, 
     920   unsigned short nLevel, bool bServer) 
     921{ 
     922  if (gUserManager.FindOwner(id, LICQ_PPID) != NULL) 
    906923    return 0; 
    907924 
    908   ICQUser *u = gUserManager.FetchUser(nUin, LOCK_W); 
     925  ICQUser* u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_W); 
    909926  if (u == NULL) return 0; 
    910927  char *szReasonDos = gTranslator.NToRN(reason); 
     
    969986void CICQDaemon::icqChatRequestCancel(unsigned long nUin, unsigned short nSequence) 
    970987{ 
    971   ICQUser *u = gUserManager.FetchUser(nUin, LOCK_R); 
     988  char id[16]; 
     989  snprintf(id, 16, "%lu", nUin); 
     990  icqChatRequestCancel(id, nSequence); 
     991} 
     992 
     993void CICQDaemon::icqChatRequestCancel(const char* id, unsigned short nSequence) 
     994{ 
     995  ICQUser* u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_R); 
    972996  if (u == NULL) return; 
    973997  gLog.Info(tr("%sCancelling chat request with %s (#%hu).\n"), L_TCPxSTR,  
     
    9831007    unsigned short nSequence, const unsigned long nMsgID[2], bool bDirect) 
    9841008{ 
     1009  char id[16]; 
     1010  snprintf(id, 16, "%lu", nUin); 
     1011  icqChatRequestRefuse(id, szReason, nSequence, nMsgID, bDirect); 
     1012} 
     1013 
     1014void CICQDaemon::icqChatRequestRefuse(const char* id, const char *szReason, 
     1015    unsigned short nSequence, const unsigned long nMsgID[2], bool bDirect) 
     1016{ 
    9851017  // add to history ?? 
    986   ICQUser *u = gUserManager.FetchUser(nUin, LOCK_R); 
     1018  ICQUser* u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_R); 
    9871019  if (u == NULL) return; 
    9881020  gLog.Info(tr("%sRefusing chat request with %s (#%hu).\n"),  
     
    10151047    const unsigned long nMsgID[2], bool bDirect) 
    10161048{ 
     1049  char id[16]; 
     1050  snprintf(id, 16, "%lu", nUin); 
     1051  icqChatRequestAccept(id, nPort, szClients, nSequence, nMsgID, bDirect); 
     1052} 
     1053 
     1054void CICQDaemon::icqChatRequestAccept(const char* id, unsigned short nPort, 
     1055    const char* szClients, unsigned short nSequence, 
     1056    const unsigned long nMsgID[2], bool bDirect) 
     1057{ 
    10171058  // basically a fancy tcp ack packet which is sent late 
    10181059  // add to history ?? 
    1019   ICQUser *u = gUserManager.FetchUser(nUin, LOCK_R); 
     1060  ICQUser* u = gUserManager.FetchUser(id, LICQ_PPID, LOCK_R); 
    10201061  if (u == NULL) return; 
    10211062  gLog.Info(tr("%sAccepting chat request with %s (#%hu).\n"),  
  • trunk/licq/src/icqd-threads.cpp

    r6402 r6405  
    735735        { 
    736736          INetSocket *s = gSocketManager.FetchSocket(nCurrentSocket); 
    737           if (s != NULL && s->Owner() == gUserManager.icqOwnerUin() && 
     737          if (s != NULL && s->OwnerId() == gUserManager.OwnerId(LICQ_PPID) && 
    738738              d->m_nTCPSrvSocketDesc == -1) 
    739739          { 
     
    892892            if (tcp->RecvBufferFull()) 
    893893            { 
    894               if (tcp->Owner() == 0) 
     894              if (tcp->OwnerPPID() != LICQ_PPID) 
    895895                r = d->ProcessTcpHandshake(tcp); 
    896896              else 
  • trunk/licq/src/icqd.cpp

    r6404 r6405  
    22232223 
    22242224  if (e->m_nSubCommand == ICQ_CMDxSUB_CHAT) 
    2225     icqChatRequestCancel(e->m_nDestinationUin, e->m_nSequence); 
     2225    icqChatRequestCancel(e->Id(), e->m_nSequence); 
    22262226  else if (e->m_nSubCommand == ICQ_CMDxSUB_FILE) 
    22272227    icqFileTransferCancel(e->Id(), e->m_nSequence); 
  • trunk/licq/src/icqpacket.cpp

    r6402 r6405  
    26652665 
    26662666//----RequestAuth------------------------------------------------------------ 
    2667 CPU_RequestAuth::CPU_RequestAuth(unsigned long _nUin, const char *_szMsg) 
     2667CPU_RequestAuth::CPU_RequestAuth(const char* szUin, const char *_szMsg) 
    26682668  : CPU_CommonFamily(ICQ_SNACxFAM_LIST, ICQ_SNACxLIST_AUTHxREQ) 
    26692669{ 
    2670   char szUin[13]; 
    2671   int nUinLen = snprintf(szUin, 12, "%lu", _nUin); 
    2672   szUin[12] = '\0'; 
     2670  int nUinLen = strlen(szUin); 
    26732671  int nMsgLen = strlen(_szMsg); 
    26742672 
  • trunk/licq/src/message.cpp

    r6382 r6405  
    11541154//=====CEventUnknownSysMsg===================================================== 
    11551155CEventUnknownSysMsg::CEventUnknownSysMsg(unsigned short _nSubCommand, 
    1156                              unsigned short _nCommand, unsigned long _nUin, 
     1156    unsigned short _nCommand, const char* idString, unsigned long ppid, 
    11571157                             const char *_szMsg, 
    11581158                             time_t _tTime, unsigned long _nFlags) 
     
    11601160{ 
    11611161  m_szMsg = _szMsg == NULL ? strdup("") : strdup(_szMsg); 
    1162   m_nUin = _nUin; 
     1162  m_szId = m_szId == NULL ? NULL : strdup(m_szId); 
     1163  m_nPPID = ppid; 
    11631164} 
    11641165 
     
    11671168  delete [] m_szText; 
    11681169  m_szText = new char [strlen(m_szMsg) + 128]; 
    1169   sprintf(m_szText, "Unknown system message (0x%04X) from %lu:\n%s\n", 
    1170           m_nSubCommand, m_nUin, m_szMsg); 
     1170  sprintf(m_szText, "Unknown system message (0x%04X) from %s:\n%s\n", 
     1171      m_nSubCommand, m_szId, m_szMsg); 
    11711172} 
    11721173 
     
    11751176{ 
    11761177  free(m_szMsg); 
     1178  free(m_szId); 
    11771179} 
    11781180 
    11791181CEventUnknownSysMsg* CEventUnknownSysMsg::Copy() const 
    11801182{ 
    1181 #if 0 
    11821183  CEventUnknownSysMsg *e = new CEventUnknownSysMsg(m_nSubCommand, 
    11831184      m_nCommand, m_szId, m_nPPID, m_szMsg, m_tTime, m_nFlags); 
    1184 #else 
    1185   CEventUnknownSysMsg *e = new CEventUnknownSysMsg(m_nSubCommand, 
    1186        m_nCommand, m_nUin, m_szMsg, m_tTime, m_nFlags); 
    1187 #endif 
    11881185  e->CopyBase(this); 
    11891186  return e; 
     
    11961193          _nDir == D_RECEIVER ? 'R' : 'S', 
    11971194          m_nCommand, (unsigned short)(m_nFlags >> 16), m_tTime); 
    1198   nPos += sprintf(&szOut[nPos], ":%lu\n", m_nUin); 
     1195  nPos += sprintf(&szOut[nPos], ":%s\n", m_szId); 
    11991196  AddStrWithColons(&szOut[nPos], m_szMsg); 
    12001197  AddToHistory_Flush(u, _nPPID, szOut);