void AppData::newPath(const QString& path) {
if(!QFile::exists(path)) {
fileNotExist();
} else {
m_isCurReaded = false;
m_isCurPrepeared = false;
m_isCurProcessed = false;
QString name = QFileInfo(path).baseName();
DataUnit* curDataUnit = new DataUnit(name, path, m_analyzer);
curDataUnit->prepairFile();
curDataUnit->prepairData();
if(!(curDataUnit->isFilePrepared() || curDataUnit->isDataPrepared())) {
cantPrepar();
} else {
m_curDataUnit = curDataUnit;
m_isCurReaded = m_curDataUnit->isFilePrepared();
m_isCurPrepeared = m_curDataUnit->isDataPrepared();
prepared();
}
}
}
QByteArray SNAC::header() const
{
DataUnit data;
data.append<quint16>(m_family);
data.append<quint16>(m_subtype);
data.append<quint16>(m_flags);
data.append<quint32>(m_id);
return data.data();
}
void Channel1MessageData::init(const QByteArray &message, Channel1Codec charset)
{
DataUnit msgData;
msgData.append<quint16>(charset);
msgData.append<quint16>(0);
msgData.append(message);
appendTLV(0x0501, (quint32) 0x0106);
appendTLV(0x0101, msgData.data());
}
void OftHeader::writeData(QIODevice *dev)
{
DataUnit data;
debug() << "Outgoing oft message with type" << hex << type;
data.append<quint16>(type);
data.append<quint64>(cookie);
data.append<quint16>(encrypt);
data.append<quint16>(compress);
data.append<quint16>(totalFiles);
data.append<quint16>(filesLeft);
data.append<quint16>(totalParts);
data.append<quint16>(partsLeft);
data.append<quint32>(totalSize);
data.append<quint32>(size);
data.append<quint32>(modTime);
data.append<quint32>(checksum);
data.append<quint32>(receivedResourceForkChecksum);
data.append<quint32>(resourceForkSize);
data.append<quint32>(creationTime);
data.append<quint32>(resourceForkChecksum);
data.append<quint32>(bytesReceived);
data.append<quint32>(receivedChecksum);
{
QByteArray ident = identification.toLatin1();
resizeArray(ident, 32);
data.append(ident);
}
data.append<quint8>(flags);
data.append<quint8>(0x1C);
data.append<quint8>(0x11);
{
QByteArray dummy;
resizeArray(dummy, 69);
data.append(dummy);
}
resizeArray(macFileInfo, 16);
data.append(macFileInfo);
data.append<quint16>(CodecUtf16Be);
data.append<quint16>(0);
{
QByteArray name = utf16Codec()->fromUnicode(fileName);
name = name.mid(2);
if (name.size() < 64)
resizeArray(name, 64);
else
name.append("\0\0");
data.append(name);
}
DataUnit header;
header.append<quint32>(0x4F465432); // Protocol version: "OFT2"
header.append<quint16>(data.dataSize() + 6);
header.append(data);
dev->write(header.data());
}
void FullInfoMetaRequestPrivate::handleMoreInfo(const DataUnit &data)
{
quint16 age = data.read<quint16>(LittleEndian);
if (age != 0)
values.insert(Age, age);
{
quint8 genderId = data.read<quint8>();
if (genderId)
values.insert(Gender, genders().value(genderId));
}
readString(Homepage, data);
{
quint16 y = data.read<quint16>(LittleEndian);
quint8 m = data.read<quint8>();
quint8 d = data.read<quint8>();
if (QDate::isValid(y, m, d))
values.insert(Birthday, QDate(y, m, d));
}
{
QStringList langList;
for (int i = 0; i < 3; ++i) {
QString lang = languages().value(data.read<quint8>());
if (!lang.isEmpty())
langList << lang;
}
if (!langList.isEmpty())
values.insert(Languages, langList);
}
data.skipData(2); // 0x0000 unknown
readString(OriginalCity, data);
readString(OriginalState, data);
readField<quint16>(OriginalCountry, data, countries());
values.insert(GMT, data.read<qint8>());
}
bool FindContactsMetaRequest::handleData(quint16 type, const DataUnit &data)
{
Q_D(FindContactsMetaRequest);
if (type != 0x01A4 && type != 0x01AE)
return false;
data.skipData(2); // data size
FoundContact contact;
contact.uin = QString::number(data.read<quint32>(LittleEndian));
contact.nick = readSString(data);
contact.firstName = readSString(data);
contact.lastName = readSString(data);
contact.email = readSString(data);
contact.authFlag = data.read<quint8>();
contact.status = static_cast<Status>(data.read<quint16>(LittleEndian));
contact.gender = genders().value(data.read<quint8>());
contact.age = data.read<quint16>(LittleEndian);
qDebug() << "Contact found" << contact.uin << contact.nick << contact.firstName
<< contact.lastName << contact.email << contact.authFlag << contact.status
<< contact.gender << contact.age;
emit contactFound(contact);
d->contacts.insert(contact.uin, contact);
if (type == 0x01AE)
close(true);
return true;
}
XtrazData::XtrazData(const QString &body, const Cookie &cookie) :
Tlv2711(MsgPlugin, 0, 0, 1, cookie)
{
appendEmptyPacket();
// Plugin type ID
append<quint16>(0x04f, LittleEndian); // Length
append(Capability(0x3b60b3ef, 0xd82a6c45, 0xa4e09c5a, 0x5e67e865)); // type: xtraz script
append<quint16>(xtrazNotify, LittleEndian); // Function ID
append<quint32>(0x002a, LittleEndian); // Request type
append(QString("Script Plug-in: Remote Notification Arrive"));
// unknown
append<quint32>(0x00000100);
append<quint32>(0x00000000);
append<quint32>(0x00000000);
append<quint16>(0x0000);
append<quint8>(0x00);
// data
DataUnit data;
data.append<quint32>(body, LittleEndian);
append<quint32>(data.data(), LittleEndian);
}
bool ShortInfoMetaRequest::handleData(quint16 type, const DataUnit &data)
{
Q_D(ShortInfoMetaRequest);
if (type != 0x0104)
return false;
d->readString(Nick, data);
d->readString(FirstName, data);
d->readString(LastName, data);
d->readString(Email, data);
d->readFlag(AuthFlag, data);
data.skipData(2); // 0x00 unknown
{
quint8 genderId = data.read<quint8>();
if (genderId)
d->values.insert(Gender, genders().value(genderId));
}
debug() << d->uin << "short info:";
d->dump();
close(true);
return true;
}
void OftSocket::connected()
{
m_timer.stop();
if (m_state & Proxy) {
DataUnit data;
data.append<quint8>(m_client->uin(), m_client->asciiCodec()); // uin or screen name
if (m_state == ProxyReceive)
data.append<quint16>(m_proxyPort);
data.append<quint64>(m_cookie);
data.appendTLV(0x0001, ICQ_CAPABILITY_AIMSENDFILE); // capability
DataUnit header;
header.append<quint16>(10 + data.dataSize());
header.append<quint16>(0x044A); // proto version
header.append<quint16>(m_state == ProxyInit ? 0x0002 : 0x0004); // request cmd
header.append<quint32>(0); // unknown
header.append<quint16>(0); // flags
header.append(data.data());
write(header.data());
flush();
} else {
emit initialized();
}
}
// ----------------------------------------------------------------------
void
AutoCastProcessor::
send_update_packet(const double update_time)
throw()
{
assert(stale_DataUnits_.size() == 0 || use_stale_hashes_ == false);
double now = owner().world().scheduler().current_time();
uid_counter_++;
AutoCastMessage * acm = new AutoCastMessage(uid_counter_,AUTOCAST_TYPE_UPDATE,update_time,owner().id(),owner().real_position().x(),owner().real_position().y());
autocast::AutoCastProcessor::LocalDataUnit * ldu = most_urgent_DataUnit();
/// Append complete DataUnits
int dataUnits_bytes = 0;
// NEW: The stale DataUnits
int id_space = 4 * complete_DataUnits_.size() + 4 * stale_DataUnits_.size();
while( ldu && ( acm->complete_DataUnits().size() <= max_update_data_units_ ) &&
( ( acm->size() + id_space + ldu->dataUnit()->size() ) <= max_update_packet_size_ ) ){
ldu->refresh();
ldu->last_send_time(now);
ldu->unknown_count(0);
/// Detaching DataUnit
DataUnit * du = new DataUnit( *(ldu->dataUnit()) );
/// Incrementing DataUnits hop count
du->hop_count( ldu->dataUnit()->hop_count() + 1 );
dataUnits_bytes += du->size();
// Assertion
if (now > du->time() + du->max_life_time()){
std::cerr << "object " << ldu->dataUnit()->id() << " is too old. Stop!" << std::endl;
abort();
}
acm->insert_complete_DataUnit(du);
id_space -= 4;
ldu = most_urgent_DataUnit();
}
/// Append list with also known objects
for (DataUnitsMap::iterator it = complete_DataUnits_.begin(); it != complete_DataUnits_.end(); it++){
if (it->second->last_send_time() < now) acm->insert_id(it->second->dataUnit()->id());
}
/// Stale DataUnits
for (DataUnitsMap::const_iterator it = stale_DataUnits_.begin();
it != stale_DataUnits_.end(); ++it){
acm->insert_stale_id(it->second->dataUnit()->id());
}
/// Assertion
if (acm->size() > max_update_packet_size_){
assert(max_update_packet_size_ == AUTOCAST_MAX_PACKET_LENGTH);
std::cerr << "Time: " << now << " Node: " << owner().id()
<< " wants to send " << acm->size()
<< " byte, but only " << max_update_packet_size_ << " are allowed!";
exit(1);
}
/// Statistics
packets_sent_total_++;
bytes_sent_total_ += acm->size();
dataUnits_sent_total_ += acm->complete_DataUnits().size();
dataUnits_bytes_sent_total_ += dataUnits_bytes;
owner_w().send(acm);
}
void OftSocket::onReadyRead()
{
if (m_state & Proxy) {
DataUnit data;
if (m_len == 0) {
if (bytesAvailable() <= 4)
return;
data.setData(read(4));
m_len = data.read<quint16>() - 2;
if (data.read<quint16>() != 0x044A)
debug() << "Unknown proxy protocol version";
}
if (bytesAvailable() <= m_len) {
data.setData(read(m_len));
m_len = 0;
} else {
return;
}
quint16 type = data.read<quint16>();
data.skipData(4); // unknown
quint16 flags = data.read<quint16>();
Q_UNUSED(flags);
debug() << "Rendezvous proxy packet. Type" << type;
switch (type) {
case 0x0001 : { // error
quint16 code = data.read<quint16>();
QString str;
if (code == 0x000d || code == 0x000e)
str = "Bad Request";
else if (code == 0x0010)
str = "Initial Request Timed Out";
else if (code == 0x001a)
str = "Accept Period Timed Out";
else
str = QString("Unknown rendezvous proxy error: %1").arg(code);
debug() << "Rendezvous proxy error:" << str;
setSocketError(QAbstractSocket::ProxyProtocolError);
setErrorString(str);
emit error(QAbstractSocket::ProxyProtocolError);
break;
}
case 0x0003 : { // Acknowledge
if (m_state != ProxyInit) {
setSocketError(QAbstractSocket::ProxyProtocolError);
setErrorString("Rendezvous proxy acknowledge packets are forbidden");
emit error(QAbstractSocket::ProxyProtocolError);
break;
}
m_proxyPort = data.read<quint16>();
m_proxyIP.setAddress(data.read<quint32>());
emit proxyInitialized();
break;
}
case 0x0005 : { // Ready
m_state = ReadHeader;
emit initialized();
break;
}
default:
setSocketError(QAbstractSocket::ProxyProtocolError);
setErrorString(QString("Unknown rendezvous proxy request").arg(type));
emit error(QAbstractSocket::ProxyProtocolError);
}
} else {
if (m_state == ReadHeader) {
m_lastHeader.readData(this, m_client->asciiCodec());
if (m_lastHeader.isFinished()) {
m_state = ReadData;
emit headerReaded(m_lastHeader);
}
}
if (m_state == ReadData && bytesAvailable() > 0)
emit newData();
}
}
