Beispiel #1
0
bool QOperParamFile::loadParam_addRow(const char *dataBuffer)
{
    // 将数据转化为key与value,存放在map中
    SOperContainer * tempContainer = (SOperContainer * )dataBuffer;
    quint32 Key;
    SOperInfoValue Value;

    Key=atoi(tempContainer->szOper);
    Value.dwOper=Key;
    Value.sOperName=GB2312toUtf8(tempContainer->szOperName);
    Value.wOperType=qFromBigEndian(tempContainer->wOperType);
    Value.dwNetId=atoi(tempContainer->szNetId);
    Value.dwSubCenter=atoi(tempContainer->szSubCenter);
    Value.dwStation=atoi(tempContainer->szStation);
    //Value.sFormOrg=tempContainer->szFormOrg;
    Value.wGroupId=qFromBigEndian(tempContainer->wGroupId);
    Value.dwOperCardID=atoi(tempContainer->szOperCardID);
    Value.szPassWord=QString::fromLocal8Bit(tempContainer->szPassWord);
    //Value.sFunRole = QString(tempContainer->szFunRole+    16);
    memcpy(Value.szFunRole, tempContainer->szFunRole, sizeof(Value.szFunRole));
    //--DEBUG
    //qDebug() << Key << ":" << Value.dwOper << Value.sOperName << Value.wOperType;
    m_container.addItemToTemp(Key, Value);
    return true;
}
Beispiel #2
0
void Client::onRequest()
{
    QByteArray request = m_client.readAll();

    socks4request* header = reinterpret_cast<socks4request*>(request.data());

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
    const QHostAddress address(qFromBigEndian(header->address));
#else
    const QHostAddress address(header->address);
#endif

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
    const uint16_t port = qFromBigEndian(header->port);
#else
    const uint16_t port = header->port;
#endif
    //qDebug()<<"connection:"<<address<<"port:"<<port;

    m_world.connectToHost(address, port);

    disconnect(&m_client, &QTcpSocket::readyRead, this,
            &Client::onRequest);

    connect(&m_client, &QTcpSocket::readyRead, this,
            &Client::client2world);
}
Beispiel #3
0
bool MythRAOPConnection::GetPacketType(const QByteArray &buf, uint8_t &type,
                                       uint16_t &seq, uint64_t &timestamp)
{
    // All RAOP packets start with | 0x80/0x90 (first sync) | PACKET_TYPE |
    if ((uint8_t)buf[0] != 0x80 && (uint8_t)buf[0] != 0x90)
    {
        return false;
    }

    type = (char)buf[1];
    // Is it first sync packet?
    if ((uint8_t)buf[0] == 0x90 && type == FIRSTSYNC)
    {
        return true;
    }
    if (type != FIRSTAUDIO_DATA)
    {
        type &= ~0x80;
    }

    if (type != AUDIO_DATA && type != FIRSTAUDIO_DATA && type != AUDIO_RESEND)
        return true;

    const char *ptr = buf.constData();
    if (type == AUDIO_RESEND)
    {
        ptr += 4;
    }
    seq  = qFromBigEndian(*(uint16_t *)(ptr + 2));
    timestamp = qFromBigEndian(*(uint32_t*)(ptr + 4));
    return true;
}
Beispiel #4
0
/**
 * ProcessTimeResponse:
 * Calculate the network latency, we do not use the reference time send by itunes
 * instead we measure the time lapsed between the request and the response
 * the latency is calculated in ms
 */
void MythRAOPConnection::ProcessTimeResponse(const QByteArray &buf)
{
    timeval t1, t2;
    const char *req = buf.constData();

    t1.tv_sec  = qFromBigEndian(*(uint32_t*)(req + 8));
    t1.tv_usec = qFromBigEndian(*(uint32_t*)(req + 12));

    gettimeofday(&t2, NULL);
    uint64_t time1, time2;
    time1 = t1.tv_sec * 1000 + t1.tv_usec / 1000;
    time2 = t2.tv_sec * 1000 + t2.tv_usec / 1000;
    LOG(VB_GENERAL, LOG_DEBUG, LOC + QString("Read back time (Local %1.%2)")
        .arg(t1.tv_sec).arg(t1.tv_usec));
    // network latency equal time difference in ms between request and response
    // divide by two for approximate time of one way trip
    m_networkLatency = (time2 - time1) / 2;

    // now calculate the time difference between the client and us.
    // this is NTP time, where sec is in seconds, and ticks is in 1/2^32s
    uint32_t sec    = qFromBigEndian(*(uint32_t*)(req + 24));
    uint32_t ticks  = qFromBigEndian(*(uint32_t*)(req + 28));
    // convert ticks into ms
    int64_t  master = NTPToLocal(sec, ticks);
    m_clockSkew     = master - time2;
}
Beispiel #5
0
/*!
   Returns a list of writing systems supported by the font according to designer supplied
   information in the font file. Please note that this does not guarantee support for a
   specific unicode point in the font. You can use the supportsCharacter() to check support
   for a single, specific character.

   \note The list is determined based on the unicode ranges and codepage ranges set in the font's
   OS/2 table and requires such a table to be present in the underlying font file.

   \sa supportsCharacter()
*/
QList<QFontDatabase::WritingSystem> QRawFont::supportedWritingSystems() const
{
    QList<QFontDatabase::WritingSystem> writingSystems;
    if (d->isValid()) {
        QByteArray os2Table = fontTable("OS/2");
        if (os2Table.size() > 86) {
            char *data = os2Table.data();
            quint32 *bigEndianUnicodeRanges = reinterpret_cast<quint32 *>(data + 42);
            quint32 *bigEndianCodepageRanges = reinterpret_cast<quint32 *>(data + 78);

            quint32 unicodeRanges[4];
            quint32 codepageRanges[2];

            for (int i=0; i<4; ++i) {
                if (i < 2)
                    codepageRanges[i] = qFromBigEndian(bigEndianCodepageRanges[i]);
                unicodeRanges[i] = qFromBigEndian(bigEndianUnicodeRanges[i]);
            }

            QSupportedWritingSystems ws = QPlatformFontDatabase::writingSystemsFromTrueTypeBits(unicodeRanges, codepageRanges);
            for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
                if (ws.supported(QFontDatabase::WritingSystem(i)))
                    writingSystems.append(QFontDatabase::WritingSystem(i));
            }
        }
    }

    return writingSystems;
}
Beispiel #6
0
void PalmdocHeader::swap()
{
    compression = qFromBigEndian(compression);
    text_length = qFromBigEndian(text_length);
    record_count = qFromBigEndian(record_count);
    record_size = qFromBigEndian(record_size);
    encryption = qFromBigEndian(encryption);
}
Beispiel #7
0
char* Osc::createMessageInternal( char* bp, int* length, char* address, char* format, QList<OscMessageData*> msgData )
{
  // do the address
  bp = writePaddedString( bp, length, address );
  if ( bp == NULL )
    return 0;

  // do the type
  bp = writePaddedString( bp, length, format );
  if ( bp == NULL )
    return 0;

  // Going to be walking the tag string, the format string and the data
  // skip the ',' comma
  bool cont = true;
	for( int i = 0; i < msgData.count( ); i++ )
  {
    OscMessageData *data = msgData.at(i);
		if( data->omdType == OscMessageData::OmdInt )
		{
			*length -= 4;
			if ( *length >= 0 )
			{
				int v = data->i;
				v = qFromBigEndian( v );
				*((int*)bp) = v;
				bp += 4;
			}
			else 
				cont = false;
     }
		if( data->omdType == OscMessageData::OmdFloat )
		{
			*length -= 4;
			if ( *length >= 0 )
			{
				int v;
				*((float*)&v) = data->f;
				v = qFromBigEndian( v );
				*((int*)bp) = v;
				bp += 4;
			}
			else 
				cont = false;
     }
		if( data->omdType == OscMessageData::OmdString )
		{
			bp = this->writePaddedString( bp, length, data->s );
			if ( bp == NULL )
				cont = false;
    }
	}

  return ( cont ) ? bp : NULL;
}
Beispiel #8
0
void PDBHeader::swap()
{
    attributes = qFromBigEndian(attributes);
    version = qFromBigEndian(version);
    create_date = qFromBigEndian(create_date);
    mod_date = qFromBigEndian(mod_date);
    backup_date = qFromBigEndian(backup_date);
    mod_number = qFromBigEndian(mod_number);
    appInfoID = qFromBigEndian(appInfoID);
    sortInfoID = qFromBigEndian(sortInfoID);
    uniqueIDseed = qFromBigEndian(uniqueIDseed);
    num_records = qFromBigEndian(num_records);
}
void LedGridControllerUT::convertToRgb565()
{
    MyMock::expectOneCallAndReturnInt(QString("open_fbdev"), 1);
    LedGridController *controller = LedGridController::getInstance();
    quint16 bigEndianValue = controller->toRGB565(QColor(0,0,0));
    QCOMPARE(qFromBigEndian(bigEndianValue), (quint16)0);
    bigEndianValue = controller->toRGB565(QColor(0xFF,0xFF,0xFF));
    QCOMPARE(qFromBigEndian(bigEndianValue), (quint16)0xFFFF);
    bigEndianValue = controller->toRGB565(QColor(0x40,0x80,0xC0));
    const quint16 compareValueRBMultiplier = 0x01F; //B0001_1111
    const quint16 compareValueGMultiplier = 0x03F; //B0011_1111
    quint16 compareValue = (0xC0*compareValueRBMultiplier)/0xFF; //blue
    compareValue |= (((0x40*compareValueRBMultiplier)/0xFF) << 11); //red
    compareValue |= (((0x80*compareValueGMultiplier)/0xFF) << 5); //green
    QCOMPARE(qFromBigEndian(bigEndianValue), (quint16)compareValue);
}
Beispiel #10
0
// When we receive a packet, check to see whether it is a message or a bundle.
void Osc::receivePacket( char* packet, int length, QList<OscMessage*>* oscMessageList )
{
	//printf( "Raw: %s, Length: %d\n", packet, length );
	switch( *packet )
	{
		case '/':		// the '/' in front tells us this is an Osc message.
			receiveMessage( packet, length, oscMessageList );
			break;
		case '#':		// the '#' tells us this is an Osc bundle, and we check for "#bundle" just to be sure.
			if ( strcmp( packet, "#bundle" ) == 0 )
      {
        // skip bundle text and timetag
        packet += 16;
        length -= 16;
        while ( length > 0 )
        {
          // read the length (pretend packet is a pointer to integer)
          int messageLength = qFromBigEndian( *((int*)packet) );
          packet += 4;
          length -= 4;
          if ( messageLength <= length )
            receivePacket( packet, messageLength, oscMessageList );
          length -= messageLength;
          packet += messageLength;
        }
      }
      break;
		default:
			// something we don't recognize...
			QString msg = QString( "Error - Osc packets must start with either a '/' (message) or '[' (bundle).");
			messageInterface->messageThreadSafe( msg, MessageEvent::Error, preamble );
	}
}
Beispiel #11
0
inline T readNum(char *num, QFile &file) {
    file.read(num, 4);
    T n = *((T*)num);
    n = qFromBigEndian(n);

    return n;
}
Beispiel #12
0
msg_ptr
Msg::begin( char* headerToParse )
{
    quint32 lenBE = *( (quint32*) headerToParse );
    quint8 flags = *( (quint8*) (headerToParse+4) );
    return msg_ptr( new Msg( qFromBigEndian(lenBE), flags ) );
}
Beispiel #13
0
void ScriptResolver::readStdout()
{
    qDebug() << Q_FUNC_INFO << m_proc.bytesAvailable();
    if( m_msgsize == 0 )
    {
        if( m_proc.bytesAvailable() < 4 ) return;
        quint32 len_nbo;
        m_proc.read( (char*) &len_nbo, 4 );
        m_msgsize = qFromBigEndian( len_nbo );
        qDebug() << Q_FUNC_INFO << "msgsize" << m_msgsize;
    }

    if( m_msgsize > 0 )
    {
        m_msg.append( m_proc.read( m_msgsize - m_msg.length() ) );
    }

    if( m_msgsize == (quint32) m_msg.length() )
    {
        handleMsg( m_msg );
        m_msgsize = 0;
        m_msg.clear();
        if( m_proc.bytesAvailable() ) QTimer::singleShot( 0, this, SLOT(readStdout()) );
    }
}
uint32_t OsmAnd::ObfReaderUtilities::readBigEndianInt( gpb::io::CodedInputStream* cis )
{
    gpb::uint32 be;
    cis->ReadRaw(&be, sizeof(be));
    auto ne = qFromBigEndian(be);
    return ne;
}
Beispiel #15
0
void AbstractSocketClient::processGetTrack()
{
	// read data
	quint32 strLen;
	if (!recv((char *)&strLen, sizeof(strLen))) {
		close();
		return;
	}

	strLen = qFromBigEndian(strLen);

	if (!strLen) {
		close();
		return;
	}

	QByteArray trackNameBuffer;
	trackNameBuffer.resize(strLen);
	if (!recv(trackNameBuffer.data(), strLen) ||
	    trackNameBuffer.contains('\0')) {
		close();
		return;
	}

	requestTrack(QString::fromUtf8(trackNameBuffer));
}
void Common::parseHeader(const std::string &data,
                         Address &dest,
                         int &header_length)
{
    char atyp = data[0];
    int addrtype = static_cast<int>(atyp & ADDRESS_MASK);
    header_length = 0;

    if (addrtype == Address::HOST) {
        if (data.length() > 2) {
            uint8_t addrlen = static_cast<uint8_t>(data[1]);
            if (data.size() >= 2 + addrlen) {
                dest.setPort(qFromBigEndian(*reinterpret_cast<const uint16_t *>
                                            (data.data() + 2 + addrlen))
                             );
                dest.setAddress(data.substr(2, addrlen));
                header_length = 4 + addrlen;
            }
        }
    } else if (addrtype == Address::IPV4) {
        if (data.length() >= 7) {
            QHostAddress addr(qFromBigEndian(*reinterpret_cast<const uint32_t *>
                                             (data.data() + 1))
                              );
            if (!addr.isNull()) {
                header_length = 7;
                dest.setIPAddress(addr);
                dest.setPort(qFromBigEndian(*reinterpret_cast<const uint16_t *>
                                            (data.data() + 5))
                             );
            }
        }
    } else if (addrtype == Address::IPV6) {
        if (data.length() >= 19) {
            Q_IPV6ADDR ipv6_addr;
            memcpy(ipv6_addr.c, data.data() + 1, 16);
            QHostAddress addr(ipv6_addr);
            if (!addr.isNull()) {
                header_length = 19;
                dest.setIPAddress(addr);
                dest.setPort(qFromBigEndian(*reinterpret_cast<const uint16_t *>
                                            (data.data() + 17))
                             );
            }
        }
    }
}
Beispiel #17
0
/**
  createMessage
  Must put the "," as the first format letter
  */
Osc::Status Osc::createMessage( char* textMessageOriginal )
{  
	char* textMessage = strdup( textMessageOriginal );
	
  // try to send this message - if there's a problem somewhere, 
  // send the existing buffer - freeing up space, then try (once) again.
  int count = 0;
  char *bp;
  do
  {  
    count++;

    char* buffer = outBufferPointer;
    int remaining = outBufferRemaining;
  
    bp = buffer;
  
    // First message in the buffer?
    if ( bp == outBuffer )
    {
      bp = createBundle( bp, &remaining, 0, 0 );
      if ( bp == NULL )
        return ERROR_CREATING_BUNDLE;
    }
  
    // remember the place we're going to store the message length
    int* lp = (int *)bp;
    bp += 4;
    remaining -= 4;

    // remember the start of the message
    char* mp = bp;    

    if ( remaining > 0 )
    {          
      bp = createMessageInternal( bp, &remaining, textMessage ); 
    }
    else
      bp = 0;
      
    if ( bp != 0 )
    {
      // Set the size
      *lp = qFromBigEndian( bp - mp ); 
  
      outBufferPointer = bp;
      outBufferRemaining = remaining;
      outMessageCount++;
    }
    else
    {
      sendPacket( );
    }
  } while ( bp == 0 && count == 1 );

  free( textMessage );

  return ( bp != 0 ) ? OK : ERROR_SENDING_COMPLEX_MESSAGE;
}
Beispiel #18
0
int Sample::toInt() const
{
    if (signal->sampleSize() == 1)
    {
        if (signal->getFormat().sampleType() == QAudioFormat::SignedInt)
        {
            return constSampleData[0];
        }
        else
        {
            return static_cast<unsigned char>(sampleData[0]);
        }
    }
    else if (signal->sampleSize() == 2)
    {
        if (signal->getFormat().sampleType() == QAudioFormat::SignedInt)
        {
            const short* val = reinterpret_cast<const short*>(constSampleData);
            if (signal->getFormat().byteOrder() == QAudioFormat::LittleEndian)
            {
                return qFromLittleEndian(*val);
            }
            else
            {
                return qFromBigEndian(*val);
            }
        }
        else
        {
            const unsigned short* val = reinterpret_cast<const unsigned short*>(sampleData);
            if (signal->getFormat().byteOrder() == QAudioFormat::LittleEndian)
            {
                return qFromLittleEndian(*val);
            }
            else
            {
                return qFromBigEndian(*val);
            }
        }
    }
    else
    {
        throw Signal::SampleSizeUnset();
    }
}
Beispiel #19
0
char* Osc::createMessageInternal( char* bp, int* length, char* address, char* format, va_list args )
{
  // do the address
  bp = writePaddedString( bp, length, address );
  if ( bp == NULL )
    return 0;

  // do the type
  bp = writePaddedString( bp, length, format );
  if ( bp == NULL )
    return 0;

  // Going to be walking the tag string, the format string and the data
  // skip the ',' comma
  char* fp;
  bool cont = true;
  for ( fp = format + 1; *fp && cont; fp++ )
  {
    switch ( *fp )
    {
      case 'i':
          *length -= 4;
          if ( *length >= 0 )
          {
            int v = va_arg( args, int );
            v = qFromBigEndian( v );
            *((int*)bp) = v;
            bp += 4;
          }
          else 
            cont = false;
        break;
      case 'f':
        *length -= 4;
        if ( *length >= 0 )
        {
          int v;
          *((float*)&v) = (float)( va_arg( args, double ) ); 
          v = qFromBigEndian( v );
          *((int*)bp) = v;
          bp += 4;
        }
Beispiel #20
0
bool WebSocket::readFrame(QByteArray &buf)
{
	unsigned char header[2];
	if (!TcpSocket::recv((char *)header, 2))
		return false;

	// int flags = header[0] >> 4;
	int opcode = header[0] & 0xF;
	int masked = header[1] >> 7;
	int payload_len = header[1] & 0x7f;

	if (payload_len == 126) {
		quint16 tmp;
		if (!TcpSocket::recv((char *)&tmp, 2))
			return false;
		payload_len = qFromBigEndian(tmp);
	} else if (payload_len == 127) {
		// dude, that's one crazy big payload! let's bail!
		return false;
	}

	unsigned char mask[4] = { 0 };
	if (masked) {
		if (!TcpSocket::recv((char *)mask, sizeof(mask)))
			return false;
	}

	buf.resize(payload_len);
	if (payload_len > 0) {
		if (!TcpSocket::recv(buf.data(), payload_len))
			return false;
	}

	for (int i = 0; i < payload_len; ++i)
		buf[i] = buf[i] ^ mask[i & 3];

	switch (opcode) {
	case 9:
		// got ping, send pong!
		sendFrame(10, buf.data(), buf.length(), true);
		buf.clear();
		return true;

	case 8:
		// close
		disconnect();
		buf.clear();
		return false;
	}

	return true;
}
Beispiel #21
0
bool QAllRateParamFile::loadParam_addRow(const char *dataBuffer)
{
    SAllRateContainer *tempContainer = (SAllRateContainer * )dataBuffer;
    quint32 dwSta1,dwSta2;
    SAllRateValue value;
    SAllRateKey Key;
    dwSta1 = ArCharToInt(tempContainer->szStationIn,sizeof(tempContainer->szStationIn));
    dwSta2 = ArCharToInt(tempContainer->szStationOut,sizeof(tempContainer->szStationOut));
    //将数据转化为key与value并转存在map(内存)中
    if (dwSta1 < dwSta2)
       {
           Key.nSta1=dwSta1;
           Key.nSta2=dwSta2;
       }
       else
       {
           Key.nSta1=dwSta2;
           Key.nSta2=dwSta1;
       }
    value.dwStationIn = atoi(tempContainer->szStationIn);
    value.dwStationOut = atoi(tempContainer->szStationOut);
    value.wStationNum = qFromBigEndian(tempContainer->wStationNum);
    value.sPathInfo = QString::fromLocal8Bit(tempContainer->szPathInfo);
    //添加解析经过收费站信息tPassStaAry
    if(!ParsePassStationInfo(value.sPathInfo,value.wStationNum,value.tPassStaAry))
    return false;
    value.wCellNum = qFromBigEndian(tempContainer->wCellNum);
    value.dwTollDistance = qFromBigEndian(tempContainer->dwTollDistance);
    value.dwRealDistance = qFromBigEndian(tempContainer->dwRealDistance);
    value.szWayFlag = QString::fromLocal8Bit(tempContainer->szWayFlag);
    value.sTollInfo = QString::fromLocal8Bit(tempContainer->szTollInfo);
    //添加价格解析tPriceAry
    if(!ParseVCPrice(value.sTollInfo,value.tPriceAry))
    return false;
    value.tmLastVer = QString::fromLocal8Bit(tempContainer->szLastVer);
    value.tmVerUsertime = QString::fromLocal8Bit(tempContainer->szVerUseTime);
    m_container.addItemToTemp(Key,value);
    return true;
}
Beispiel #22
0
QString OscMessage::toString( )
{
	QString ret = QString( address );
	int j;
	for( j = 0; j < data.size( ); j++ )
	{
		ret.append( " " );
		switch( data.at( j )->omdType )
		{
			case OscMessageData::OmdBlob:
			{
				unsigned char* blob = (unsigned char*)data.at( j )->b;
				if( blob )
				{
					int blob_len = *(int*)blob;  // the first int should give us the length of the blob
					
					char c[6];
					blob_len = qFromBigEndian( blob_len ); 
					char buff[blob_len*6+10];
					blob += 4; // step past the blob_len
	        
	        buff[0] = '[';
	        buff[1] = ' ';
	        buff[2] = '\0';
	
	        while( blob_len-- )
	        {
						sprintf( c, "%.2x ", *blob++ );
						strcat( buff, c );
	        }
	        strcat( buff, "]" );
	        ret.append( buff );
				}
				else
					ret.append( "[ ]" );
				break;
			}
			case OscMessageData::OmdString:
				ret.append( data.at( j )->s );
				break;
			case OscMessageData::OmdInt:
				ret.append( QString::number(data.at( j )->i) );
				break;
			case OscMessageData::OmdFloat:
				ret.append( QString::number(data.at( j )->f) );
				break;
		}
	}
	return ret;
}
Beispiel #23
0
void ProtocolSocket::read()
{
    qDebug() << "Socket readable";

    qint64 available;
    while ((available = m_socket->bytesAvailable()) >= 6)
    {
        quint16 msgLength;
        if (m_socket->peek(reinterpret_cast<char*>(&msgLength), sizeof(msgLength)) < 2)
            return;

        /* Message length does not include the header */
        msgLength = qFromBigEndian(msgLength);
        if ((available - 6) < msgLength)
            break;

        QByteArray data;
        data.resize(msgLength + 6);

        qint64 re = m_socket->read(data.data(), msgLength + 6);
        Q_ASSERT(re == msgLength + 6);
        Q_UNUSED(re);

        if (Protocol::isReply(data[3]))
        {
            quint16 identifier = qFromBigEndian<quint16>(reinterpret_cast<const uchar*>(data.constData())+4);
            QHash<quint16,ProtocolCommand*>::Iterator it = pendingCommands.find(identifier);

            if (it != pendingCommands.end())
            {
                (*it)->processReply(data[3], reinterpret_cast<const uchar*>(data.constData())+6, msgLength);
                if (Protocol::isFinal(data[3]))
                {
                    /* Duplicated in socketDisconnected() */
                    qDebug() << "Received final reply for identifier" << identifier;
                    emit (*it)->commandFinished();
                    (*it)->deleteLater();
                    pendingCommands.erase(it);
                }
            }
        }
        else
        {
            CommandHandler handler(user, m_socket, reinterpret_cast<const uchar*>(data.constData()),
                                   msgLength + 6);
        }
    }
}
void BonjourServiceResolver::Private::bonjourResolveReply( DNSServiceRef, DNSServiceFlags, uint32_t, DNSServiceErrorType errorCode,
                                                           const char*, const char* hosttarget, quint16 port,
                                                           quint16 txtRecordLen, const unsigned char* pTxtRecord, void* context)
{
    Private* const serviceResolver = static_cast< Private* >( context );
    if( serviceResolver->bonjourPort != -1 || !serviceResolver->q->isResolving() )
        return;
    if( errorCode != kDNSServiceErr_NoError )
    {
        serviceResolver->q->error( errorCode );
        return;
    }
    Q_EMIT serviceResolver->q->bonjourTXTRecordResolved(txtRecordLen, pTxtRecord);
    serviceResolver->bonjourPort = qFromBigEndian( port );
    QHostInfo::lookupHost( QString::fromUtf8( hosttarget ), serviceResolver->q, SLOT( finishConnect( QHostInfo ) ) );
}
Beispiel #25
0
void SatelliteServer::incomingData( QObject *client )
{
   QTcpSocket *socket = static_cast<QTcpSocket*>(client);

   while( socket->bytesAvailable() > SATELLITE_PKGINFO_HEADER_SIZE )
   {
      SATELLITE_PKGINFO_HEADER_TYPE   header( 0 );

      socket->peek( (char*)(&header), SATELLITE_PKGINFO_HEADER_SIZE );
      header = qFromBigEndian( header );
      if( (header >> 32) != SATELLITE_PKGINFO_MAGIC_VALUE )
      {
         /* invalid data, flush */
         socket->readAll();
#if SATELLITESERVER_DEBUG
         emit debug( "s:got bad data, flushing" );
#endif
         break;
      }
      qint64 datasize = (header & 0xFFFFFFFF) +
         SATELLITE_PKGINFO_CHECKSUM_SIZE + SATELLITE_PKGINFO_HEADER_SIZE;
      if( socket->bytesAvailable() < datasize )
      {
         /* buffer incomplete, let the try at next signal */
#if SATELLITESERVER_DEBUG
         emit debug( "s:got incomplete data" );
#endif
         break;
      }
      QByteArray msg( socket->read( datasize ) );

#if SATELLITESERVER_DEBUG
      /* for debugging show raw message as hex dump */
      emit debug( QByteArray("s:from client: ") + msg.toHex() );
#endif
      for( int i = 0; i < mClientConnections.count(); i++ )
      {
         QTcpSocket *current = mClientConnections.at(i);
         if( current && (client != current) )
         {
            current->write( msg );
         }
      }
   }
}
Beispiel #26
0
void QxtDiscoverableServicePrivate::resolveServiceCallback(DNSServiceRef service, DNSServiceFlags flags, quint32 iface,
        DNSServiceErrorType errCode, const char* fullname, const char* host, quint16 port, quint16 txtLen,
        const unsigned char* txt, void* context)
#endif
{
    Q_UNUSED(service);
    Q_UNUSED(txtLen);
    Q_UNUSED(txt);
    Q_UNUSED(flags);
    QxtDiscoverableServicePrivate* self = reinterpret_cast<QxtDiscoverableServicePrivate*>(context);
    QxtDiscoverableService* pub = &self->qxt_p();
    if(errCode == kDNSServiceErr_NoError) {
        QxtDiscoverableServiceName name(fullname);
        pub->setServiceName(name.serviceName());
        pub->setDomain(name.domain());
	pub->setHost(host);
	pub->setPort(qFromBigEndian(port));
	self->iface = iface;
        emit pub->resolved(fullname);
    } else {
        self->state = QxtDiscoverableService::Unknown;
        emit pub->resolveError((QxtDiscoverableService::ErrorCode)errCode);
    }
}
Beispiel #27
0
void AbstractSocketClient::processSetRow()
{
	quint32 newRow;
	if (recv((char *)&newRow, sizeof(newRow)))
		emit rowChanged(qFromBigEndian(newRow));
}
Beispiel #28
0
void QxtMDNSPrivate::avahiRecordBrowserCallback(AvahiRecordBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *name, uint16_t clazz, uint16_t type, const void *rdata, size_t size, AvahiLookupResultFlags flags, void *userdata)
{
	///@TODO Support IPv6
	Q_UNUSED(interface);
	Q_UNUSED(protocol);
	Q_UNUSED(name);
	Q_UNUSED(clazz);
	Q_UNUSED(type);
	Q_UNUSED(size);
	Q_UNUSED(flags);
	QxtMDNSPrivate* self = static_cast<QxtMDNSPrivate*>(userdata);
	self->recordbrowser = b;
// 	qDebug() << "Return thing" << md->name << name << size;
	switch (event)
	{
		case AVAHI_BROWSER_NEW:
		{
			//Found an entry!
			uint32_t ip = qFromBigEndian(*static_cast<const uint32_t*>(rdata));
			if (self->sent)
			{
				QHostInfo info(self->info.lookupId());
				info.setAddresses(QList<QHostAddress>() << QHostAddress(ip));
				QMetaObject::invokeMethod(self->receiver, self->member, Q_ARG(QHostInfo, info));
			}
			else
			{
				self->addresses << QHostAddress(ip);
			}
			break;
		}
		case AVAHI_BROWSER_REMOVE:
		{
			uint32_t ip = qFromBigEndian(*static_cast<const uint32_t*>(rdata));
			self->addresses.removeAll(QHostAddress(ip));
			break;
		}
		case AVAHI_BROWSER_CACHE_EXHAUSTED:
			break;
		case AVAHI_BROWSER_ALL_FOR_NOW:
			if (self->addresses.count() == 0)
			{
				self->info.setError(QHostInfo::HostNotFound);
				self->info.setErrorString("The host was not found.");
			}
			else
			{
				self->info.setAddresses(self->addresses);
				self->addresses.clear();
			}
			QMetaObject::invokeMethod(self->receiver, self->member, Q_ARG(QHostInfo, self->info));
			self->sent = true;
			break;
		case AVAHI_BROWSER_FAILURE:

			if (self->sent)
			{
				QHostInfo info(self->info.lookupId());
				info.setError(QHostInfo::UnknownError);
				info.setErrorString(avahi_strerror(avahi_client_errno(self->client)));
				info.setAddresses(self->addresses);
				QMetaObject::invokeMethod(self->receiver, self->member, Q_ARG(QHostInfo, info));
			}
			else
			{
				self->info.setError(QHostInfo::UnknownError);
				self->info.setErrorString(avahi_strerror(avahi_client_errno(self->client)));
				self->info.setAddresses(self->addresses);
				self->addresses.clear();
				QMetaObject::invokeMethod(self->receiver, self->member, Q_ARG(QHostInfo, self->info));
				self->sent = true;
			}
			break;
	}
}
Beispiel #29
0
 inline quint32 getUint32(int offset) const
 {
     return qFromBigEndian(*reinterpret_cast<quint32 *>(data + offset));
 }
Beispiel #30
0
	Registry::ReadResult Registry::read(QVariant &result, Key key, const QString &subkey, const QString &value)
	{
		HKEY hKey;

		if(RegOpenKeyEx(enumToKey(key), subkey.toStdWString().c_str(), 0, KEY_READ, &hKey) != ERROR_SUCCESS)
			return ReadCannotFindSubKey;

		DWORD size;
		DWORD type;
		std::wstring wideValue = value.toStdWString();
		if(RegQueryValueEx(hKey, wideValue.c_str(), 0, &type, 0, &size) != ERROR_SUCCESS)
		{
			RegCloseKey(hKey);
			return ReadCannotFindValue;
		}

		switch(type)
		{
		case REG_DWORD:
		case REG_DWORD_BIG_ENDIAN:
			{
				qint32 value;
				if(RegQueryValueEx(hKey, wideValue.c_str(), 0, 0, reinterpret_cast<LPBYTE>(&value), &size) != ERROR_SUCCESS)
				{
					RegCloseKey(hKey);
					return ReadCannotFindValue;
				}

				if(type == REG_DWORD_BIG_ENDIAN)
					value = qFromBigEndian(value);

				result = value;
			}
			break;
		case REG_SZ:
		case REG_EXPAND_SZ:
		case REG_LINK:
		case REG_MULTI_SZ:
			{
                std::vector<wchar_t> buffer(size);
                if(RegQueryValueEx(hKey, wideValue.c_str(), 0, 0, reinterpret_cast<LPBYTE>(buffer.data()), &size) != ERROR_SUCCESS)
				{
					RegCloseKey(hKey);
					return ReadCannotFindValue;
				}

				if(type == REG_MULTI_SZ)
				{
                    QStringList stringList = QString::fromWCharArray(buffer.data(), size / 2).split(QChar(L'\0'), QString::SkipEmptyParts);

					if(stringList.last().isEmpty())
						stringList.removeLast();

					result = stringList;
				}
				else
                    result = QString::fromWCharArray(buffer.data(), size / 2);
			}
			break;
		case REG_BINARY:
			{
                std::vector<char> buffer(size);
                if(RegQueryValueEx(hKey, wideValue.c_str(), 0, 0, reinterpret_cast<LPBYTE>(buffer.data()), &size) != ERROR_SUCCESS)
				{
					RegCloseKey(hKey);
					return ReadCannotFindValue;
				}

                result = QByteArray::fromRawData(buffer.data(), size);
			}
			break;
		case REG_QWORD:
			{
				qint64 value;
				if(RegQueryValueEx(hKey, wideValue.c_str(), 0, 0, reinterpret_cast<LPBYTE>(&value), &size) != ERROR_SUCCESS)
				{
					RegCloseKey(hKey);
					return ReadCannotFindValue;
				}

				result = value;
			}
			break;
		case REG_NONE:
		default:
			RegCloseKey(hKey);

			return ReadInvalidValueType;
			break;
		}

		RegCloseKey(hKey);

		return ReadOk;
	}