abstractchatcore.cpp

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

/***************************************************************************
 *   Copyright (C) 2007 by Anistratov Oleg                                 *
 *   [e-mail]                                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License version 2        *
 *   as published by the Free Software Foundation;                         *
 *                                                                         *
 *   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.                          *
 *                                                                         *
 ***************************************************************************/
#include "abstractchatcore.h"

#include "globals.h"

#include <assert.h>

#include "protocolversion3.h"
#include "protocolversion4.h"
#include "abstractprotocol.h"

#include <QDateTime>

AbstractProtocol* AbstractChatCore::m_protocol   = NULL;
ProtocolVersion3* AbstractChatCore::m_protocolV3 = new ProtocolVersion3;
ProtocolVersion4* AbstractChatCore::m_protocolV4 = new ProtocolVersion4;

AbstractChatCore::AbstractChatCore() :
  m_outputBuffer(NULL),
  m_outputBufferSize(65535),
  m_inputBuffer(NULL),
  m_inputBufferSize(65535),
  m_largeDtgrm(false),
  m_header(NULL),
  m_headerSize(0),
  m_data(NULL),
  m_dataSize(0),
  m_parametrs("")
{
  Hdr        = new QC_DatagramHeader;

  m_protocol = m_protocolV4;
//   m_protocol = m_protocolV3;

  m_outputBuffer = (char*)malloc(m_outputBufferSize);
  assert(NULL   != m_outputBuffer);
  m_inputBuffer  = (char*)malloc(m_inputBufferSize);
  assert(NULL   != m_inputBuffer );
}

AbstractChatCore::~AbstractChatCore()
{
  qDebug("[~AbstractChatCore]");

  free(m_outputBuffer);

  // we do not need to free m_data because m_data = m_header + m_headerSize;
  free(m_header);
}

void AbstractChatCore::addParametr(const QString & name, const QByteArray & par, QByteArray & buf)
{
  char size[4];
  char nameSize[2];

  if(name.size() <= 65535)
  {
    catUS2str(nameSize, name.toUtf8().size());
    buf.append(nameSize[0]);
    buf.append(nameSize[1]);

    buf.append(name.toUtf8());

    catUL2str(size, par.size());
    buf.append(size[0]);
    buf.append(size[1]);
    buf.append(size[2]);
    buf.append(size[3]);

    buf.append(par);
  }
  else
    qWarning("[AbstractChatCore::addParametr]: '%s' is too large (%d bytes). not added\n", name.toLocal8Bit().data(), name.size());
}
//\*****************************************************************************
void AbstractChatCore::addParametr(const QString & name, const QByteArray & par)
{
  addParametr(name, par, parametrs());
}
//\*****************************************************************************
void AbstractChatCore::addParametr(const QString & name, const QString & filename)
{
  QFile file(filename);
  QByteArray par;
  char size[4];
  char nameSize[2];

//   qDebug("[ChatCore::addParametr]: name = %s", name.toLocal8Bit().data());

  if(name.size() <= 65535)
  {
    file.open(QIODevice::ReadOnly);

    if(file.exists ())
    {
      par = file.readAll();

      catUS2str(nameSize, name.toUtf8().size());
      parametrs().append(nameSize[0]);
      parametrs().append(nameSize[1]);

      parametrs().append(name.toUtf8());

      catUL2str(size, file.size());
      parametrs().append(size[0]);
      parametrs().append(size[1]);
      parametrs().append(size[2]);
      parametrs().append(size[3]);

      parametrs().append(par);

      par.clear();
    }
  }
  else
    qWarning("[AbstractChatCore::addParametr]: '%s' is too large (%d bytes). not added\n", name.toLocal8Bit().data(), name.size());

}
//\*****************************************************************************
void AbstractChatCore::clearParametrs()
{
  parametrs().clear();
  hdr()->parametrs.clear();
  hdr()->color = Qt::black;
}
//\*****************************************************************************
QByteArray AbstractChatCore::getParametr(const QString & par_name, const QByteArray& pars)
{
//   qDebug("[static ChatCore::getParametr]: req = '%s'", par_name.toLocal8Bit().data());

  qint32     idx = -1;
  quint32    size;
  quint32    pars_size = pars.size();
  QByteArray par("");
  uchar      n_size;
  char       arr2[2];
  char       par_size[4];
  QString    name;

  for(uint i = 0; i < pars_size; )
  {
    arr2[0] = pars.at(i++);
    arr2[1] = pars.at(i++);
    n_size  = str2US(arr2);

    name.clear();

    if(i + n_size >= pars_size)
      break;

    for(int j = 0; j < n_size; j++, i++)
      par.append(pars.at(i));
    name = QString().fromUtf8(par);

    par.resize(0);

//     qDebug("[static ChatCore::getParametr]: name = %s", name.toLocal8Bit().data());

    if(name == par_name)
    {
      idx = i - n_size;
      break;
    }

    if(i + 3 < pars_size)
    {
      par_size[0] = pars.at(i    );
      par_size[1] = pars.at(i + 1);
      par_size[2] = pars.at(i + 2);
      par_size[3] = pars.at(i + 3);

      size = str2UL(par_size);

      i += 4 + size;
    }

    else
      break;

  }

//   qDebug("[static ChatCore::getParametr]: pars.size() = %d", pars.size());
//   qDebug("[static ChatCore::getParametr]: idx = '%d'", idx);

  if(idx < 0)
    return QByteArray();
  idx += par_name.toUtf8().size();

  par_size[0] = pars.at(idx    );
  par_size[1] = pars.at(idx + 1);
  par_size[2] = pars.at(idx + 2);
  par_size[3] = pars.at(idx + 3);
  idx += 4;

  size = str2UL(par_size);

//   qDebug("[static ChatCore::getParametr]: size = %lu", (unsigned long)size);

  for(quint32 i = idx; i < idx + size && i < pars_size; i++)
    par.append(pars.at(i));

  return par;
}
//\*****************************************************************************
QByteArray AbstractChatCore::getParametr(const QString & par_name)
{
  return getParametr(par_name, parametrs());
}
//\*****************************************************************************
QColor AbstractChatCore::getColorParametr(QByteArray* pars)
{
  QByteArray par = getParametr("Color", *pars);
  QColor col(Qt::black);

  if(par.size() >= 3)
    col.setRgb((quint8)par[0], (quint8)par[1], (quint8)par[2]);
  else if(par.size() >= 4)
    col.setRgb(par[0], par[1], par[2], par[3]);

  return col;
}
//\*****************************************************************************
QMap<QString, QByteArray> AbstractChatCore::getAllParametrs(const QByteArray & pars)
{
  qint32     idx = -1;
  quint32    size;
  quint32    pars_size = pars.size();
  QByteArray par("");
  uchar      n_size;
  char       arr2[2];
  char       par_size[4];
  QString    name;

  QMap<QString, QByteArray> all_pars;

  for(uint i = 0; i < pars_size; )
  {
    arr2[0] = pars.at(i++);
    arr2[1] = pars.at(i++);
    n_size  = str2US(arr2);

    name.clear();

    if(i + n_size >= pars_size)
      break;

    for(int j = 0; j < n_size; j++, i++)
      par.append(pars.at(i));

    name = QString().fromUtf8(par);
    par.resize(0);

    //\*****************
    idx = i ;

    par_size[0] = pars.at(idx);
    par_size[1] = pars.at(idx + 1);
    par_size[2] = pars.at(idx + 2);
    par_size[3] = pars.at(idx + 3);
    idx += 4;

    size = str2UL(par_size);

    for(quint32 j = idx; j < idx + size && j < pars_size; j++)
      par.append(pars.at(j));

    all_pars[name] = par;
    par.resize(0);
    //\*****************

    if(i + 3 < pars_size)
    {
      par_size[0] = pars.at(i    );
      par_size[1] = pars.at(i + 1);
      par_size[2] = pars.at(i + 2);
      par_size[3] = pars.at(i + 3);

      size = str2UL(par_size);

      i += 4 + size;
    }

    else