abstractchatcore.cpp

用qt4 编写的局域网聊天工具

      break;
  }

  return all_pars;
}

//\*****************************************************************************
void AbstractChatCore::prepareDatagram(AbstractChatCore::DataType dtgrm_type,
                                       quint64         dest_uid,
                                       const QString & nickname,
                                       const QString & compName,
                                       quint64         src_uid,
                                       const QString & msg       /* = 0*/,
                                       AbstractChatCore::ChannelType     chnnl_type/* = 0*/, // 0 - common, 1 - private, 2 - password
                                       unsigned long   dtgrm_id  /* = 0*/,
                                       unsigned long   dtgrm_num /* = 0*/)
{
  m_largeDtgrm = false;

  QByteArray msgData      = msg     .toUtf8();
  QByteArray nameData     = nickname.toUtf8();
  QByteArray compNameData = compName.toUtf8();

  int   unl    = nameData    .size(); // user_name_len
  int   cnl    = compNameData.size(); // comp_name_len
  char* buf;

  m_outputBufferSize = protocolLen() + unl + cnl + msgData.size() + m_parametrs.size() + optionsLen();

  if(m_outputBufferSize > MAX_PACKET_LEN)
  {
    m_largeDtgrm = true;
//     addParametr("Large");
  }

  qDebug("[AbstractChatCore::prepareDatagram]: pr_len = %d, unl = %d, cnl = %d, msgData.size() = %d, m_parametrs.size() = %d", AbstractChatCore::protocolLen(), unl, cnl, msgData.size(), m_parametrs.size());

  m_headerSize = protocolLen() + unl + cnl + optionsLen();
  // 4 + 4 - dlya razmerov esli paket budet fragmented
  m_dataSize     = msgData.size() + m_parametrs.size() + 4 + 4;
  m_header       = (char*)realloc(m_header, m_dataSize + m_headerSize);
  assert(NULL   != m_header);

  m_data = m_header + m_headerSize;

  setProgramId      (m_header);
  setProgramVersion (m_header);
  setProtocolVersion(m_header);
  setDestIp         (m_header, dest_uid);
  setSrcIp          (m_header, src_uid);
  setPacketType     (m_header, dtgrm_type);
  setPacketId       (m_header, dtgrm_id);
  setPacketNum      (m_header, dtgrm_num);
  setTime           (m_header, QDateTime::currentDateTime().toTime_t()/*time(NULL)*/); // FIXME why segfaults on time() ???
  setChannelType    (m_header, chnnl_type);
  setCompNameLen    (m_header, cnl);
  setUserNameLen    (m_header, unl);
  setMessageLen     (m_header, msgData.size());
  setParametrsLen   (m_header, m_parametrs.size());
  setOptionsLen     (m_header, 1); // FIXME !!!!!!
  setCompName       (m_header, compName);
  setUserName       (m_header, nickname);
  setCompressed     (m_header, false);

  buf = m_data;
  if(m_largeDtgrm)
  {
//     SetMsgLen      (m_header, msgData.size());
//     SetParametrsLen(m_header, m_parametrs.size());
    catUL2str(buf     , msgData  .size());
    catUL2str(buf += 4, m_parametrs.size());
    buf += 4;

  }

  memcpy(buf, msgData.data(), msgData.size());

  if(!m_parametrs.isEmpty())
     memcpy (buf += msgData.size(), m_parametrs.data(), m_parametrs.size());
     // NOTE setParametrs will NOT work!!
     // FIXME remove that hack
//      setParametrs(m_header, m_parametrs);

  if(!m_largeDtgrm)
  {
    memcpy(m_outputBuffer               , m_header, m_headerSize  );
    memcpy(m_outputBuffer + m_headerSize, m_data  , m_dataSize - 8); // -8, t.k. paket ne fragmented
    m_outputBufferSize = m_headerSize + m_dataSize - 8;
  }
}

//\*****************************************************************************
bool AbstractChatCore::fillHeader()
{
  QHostAddress address;

  AbstractProtocol* prot = m_protocol;

  setProtocolVersion(checkProtocolVersion(m_inputBuffer));

  // Razbor Dannyh
  if(m_inputBufferSize < protocolLen())
  {
    qWarning("[AbstractChatCore::fillHeader]: [LengthError!] (m_inputBufferSize < AbstractChatCore::protocolLen()). Ignoring this packet\n");
    m_protocol = prot;
    return 0;
  }
  if(strncmp(m_inputBuffer, programId(), programIdLen()))
  {
    qWarning("[AbstractChatCore::fillHeader]: [ID_ERROR!] (strncmp(m_inputBuffer, AbstractChatCore::programId(), 18) != 0). Ignoring this packet\n");
    m_protocol = prot;
    return 0;
  }

  Hdr->receive_tm      = QDateTime::currentDateTime().toTime_t();//time(NULL);
  Hdr->programVersion  = programVersion(m_inputBuffer);

  if(Hdr->programVersion < 5)
  {
    qWarning("[AbstractChatCore::fillHeader]: [error] packet from old version of qchat ( < 5). Ignoring this packet\n");
    m_protocol = prot;
    return 0;
  }

  Hdr->protocolVersion = protocolVersion(m_inputBuffer);

  if(Hdr->protocolVersion != protocolVersion())
  {
    qWarning("[AbstractChatCore::fillHeader]: [error] protocol version mismatch (%d != %d). Ignoring this packet\n", Hdr->protocolVersion, protocolVersion());
    m_protocol = prot;
    return 0;
  }

  Hdr->dest_ip         = destIp      (m_inputBuffer);
  Hdr->src_ip          = srcIp       (m_inputBuffer);
  Hdr->type            = packetType  (m_inputBuffer);
  Hdr->id              = packetId    (m_inputBuffer);
  Hdr->num             = packetNum   (m_inputBuffer);
  Hdr->tm              = time        (m_inputBuffer);
  Hdr->chnnl_id        = channelType (m_inputBuffer);
  Hdr->comp_name_len   = compNameLen (m_inputBuffer);
  Hdr->name_len        = userNameLen (m_inputBuffer);
  Hdr->msg_len         = messageLen  (m_inputBuffer);
  Hdr->parametrs_len   = parametrsLen(m_inputBuffer);

  qDebug("[AbstractChatCore::fillHeader]: type = %d", Hdr->type);

  uint expectedSize;

  if(protocolVersion() < 4)
    expectedSize = protocolLen() + Hdr->comp_name_len + Hdr->name_len + Hdr->msg_len + Hdr->parametrs_len;
  else
    expectedSize = packetSize(m_inputBuffer);

  if(m_inputBufferSize < expectedSize)
  {
    qWarning("[AbstractChatCore::fillHeader]: [error] wrong length of packet (actual size(%d) smaller than expected(%u)). Ignoring this packet\n", m_inputBufferSize, expectedSize);

    qDebug("[AbstractChatCore::fillHeader]: AbstractChatCore::protocolLen() = %d, Hdr->comp_name_len = %d, Hdr->name_len = %d, Hdr->msg_len = %lu, Hdr->parametrs_len = %lu", protocolLen(), Hdr->comp_name_len, Hdr->name_len, Hdr->msg_len, Hdr->parametrs_len);

    m_protocol = prot;
    return 0;
  }

  Hdr->comp_name = compName(m_inputBuffer, m_inputBufferSize);
  Hdr->name      = userName(m_inputBuffer, m_inputBufferSize);
  Hdr->msg       = message (m_inputBuffer, m_inputBufferSize);

  Hdr->parametrs.clear();
  Hdr->parametrs = parametrs(m_inputBuffer, m_inputBufferSize);
  Hdr->color = getColorParametr(&Hdr->parametrs);

  Hdr->isHtml = !getParametr("HTML", Hdr->parametrs).isNull();

  //********* getting versionName *********
  QByteArray ba = getParametr("Version", Hdr->parametrs);

  if(!ba.isEmpty())
    Hdr->versionName = QString().fromUtf8(ba);
  else if(Hdr->programVersion <= Globals::VersionID)
    Hdr->versionName = QString(Globals::VersionsTable[Hdr->programVersion - 1]);
  else
    Hdr->versionName = QString("New Version[id = %1]").arg(Hdr->programVersion);

  //********* getting status *********
  Hdr->status = Globals::FREE;
  ba = getParametr("Status", Hdr->parametrs);
  if(!ba.isEmpty())
    Hdr->status = ba[0];

  m_protocol = prot;
  return 1;
}
//\*****************************************************************************

void AbstractChatCore::newHdr()
{
  Hdr = new QC_DatagramHeader;
}

bool isSystemMsg(quint16 type)
{
  switch(type)
  {
    case AbstractChatCore::CONNECTED :
    case AbstractChatCore::DISCONNECTED :
    case AbstractChatCore::INF_STATUS_CHNGD :
      return true;
  }

  return false;
}

char* AbstractChatCore::uncompress(const char* buf, uint& size)
{
  char* data_pos;
  uint  shift = protocolLen() + optionsLen(buf) + compNameLen(buf) + userNameLen(buf);
  char* data;
  QByteArray ba;

  if(size < protocolLen() || size < shift)
    return NULL;

  data_pos = (char*)buf + shift;

  ba = qUncompress((const uchar*)data_pos, size - shift);

  size = ba.size() + shift;

  data = (char*)malloc(size);

  memcpy(data        , buf      , shift);
  memcpy(data + shift, ba.data(), ba.size());

  return data;
}

char* AbstractChatCore::compress(const char * buf, uint & size)
{
  char* data_pos;
  uint  shift = protocolLen() + optionsLen(buf) + compNameLen(buf) + userNameLen(buf);
  char* data;
  QByteArray ba;

  if(size < protocolLen() || size < shift)
    return NULL;

  data_pos = (char*)buf + shift;

  ba = qCompress((const uchar*)data_pos, size - shift, 9);

  size = ba.size() + shift;

  data = (char*)malloc(size);

  memcpy(data        , buf      , shift);
  memcpy(data + shift, ba.data(), ba.size());

  return data;
}

void AbstractChatCore::setProtocolVersion(uint ver)
{
  if     (ver == 3) m_protocol = m_protocolV3;
  else if(ver == 4) m_protocol = m_protocolV4;
}

uint AbstractChatCore::checkProtocolVersion(const char * buf)
{
  AbstractProtocol* tmp = m_protocol;
//   int res;

  m_protocol = m_protocolV3;

  if(!strncmp(buf, programId(), programIdLen()) && protocolVersion(buf) == 3)
  {
    m_protocol = tmp;
    return 3;
  }

  m_protocol = m_protocolV4;

  if(!strncmp(buf, programId(), programIdLen()) && protocolVersion(buf) == 4)
  {
    m_protocol = tmp;
    return 4;
  }

//   res = protocolVersion(buf);

  m_protocol = tmp;

  return 0;
}