Example #1
0
void Bdecoder::read(qulonglong *value, bool &bSigned)
{
    if (m_pos >= m_len || m_buf[m_pos] != 'i') {
        setError("expected integer, got %c", char(m_buf[m_pos]));
        return;
    }
    m_pos++;
    int end = m_buf.indexOf('e', m_pos);
    if (end <= m_pos || end >= m_len) {
        setError("buffer overrun");
        return;
    }

    if (value) {
        QByteArray s = m_buf.mid(m_pos, end - m_pos);
        if (!validateInt(s))
            return;
        bool ok;
		if(bSigned = (s.left(1) == "-"))
			*value = s.toLongLong(&ok, 10);
		else
			*value = s.toULongLong(&ok, 10);
        if (!ok) {
            setError("Invalid integer (%s)", s.constData());
            return;
        }
    }
    m_pos = end + 1;
}
Example #2
0
qint64 QHttpNetworkHeaderPrivate::contentLength() const
{
    bool ok = false;
    QByteArray value = headerField("content-length");
    qint64 length = value.toULongLong(&ok);
    if (ok)
        return length;
    return -1; // the header field is not set
}
Example #3
0
void WatchData::setHexAddress(const QByteArray &a)
{
    bool ok;
    const qint64 av = a.toULongLong(&ok, 0);
    if (ok) {
        address = av;
    } else {
        qWarning("WatchData::setHexAddress(): Failed to parse address value '%s' for '%s', '%s'",
                 a.constData(), iname.constData(), type.constData());
        address = 0;
    }
}
Example #4
0
qint64 QHttpNetworkHeaderPrivate::contentLength() const
{
    bool ok = false;
    // We are not using the headerField() method here because servers might send us multiple content-length
    // headers which is crap (see QTBUG-15311). Therefore just take the first content-length header field.
    QByteArray value;
    QList<QPair<QByteArray, QByteArray> >::ConstIterator it = fields.constBegin(),
                                                        end = fields.constEnd();
    for ( ; it != end; ++it)
        if (qstricmp("content-length", it->first) == 0) {
            value = it->second;
            break;
        }

    qint64 length = value.toULongLong(&ok);
    if (ok)
        return length;
    return -1; // the header field is not set
}
quint64 getRecvFileSize(const QByteArray &data)
{
    int nPos = 0;
    QByteArray temp;
    const char *conL="Content-Length:";

    nPos = data.indexOf(conL);
    if(nPos != -1)
    {
        temp = data.mid(nPos + strlen(conL));
        nPos = temp.indexOf("\n");

        if(nPos != -1)
        {
            temp = temp.left(nPos);
            temp=temp.trimmed();

            return (temp.toULongLong());
        }
    }

    return -1;
}
Example #6
0
/*! \brief Read and parse data from the given socket.
 *
 * The HTTP method (e.g. GET / 200 OK), headers and content will be split out
 * for further processing.
 */
bool TorcHTTPReader::Read(QTcpSocket *Socket, int *Abort)
{
    if (!Socket)
        return false;

    if (*Abort || Socket->state() != QAbstractSocket::ConnectedState)
        return false;

    // sanity check
    if (m_headersRead >= 200)
    {
        LOG(VB_GENERAL, LOG_ERR, "Read 200 lines of headers - aborting");
        return false;
    }

    // read headers
    if (!m_headersComplete)
    {
        while (!(*Abort) && Socket->canReadLine() && m_headersRead < 200)
        {
            QByteArray line = Socket->readLine().trimmed();

            if (line.isEmpty())
            {
                m_headersRead = 0;
                m_headersComplete = true;
                break;
            }

            if (!m_requestStarted)
            {
                LOG(VB_NETWORK, LOG_DEBUG, line);
                m_method = line;
            }
            else
            {
                m_headersRead++;
                int index = line.indexOf(":");

                if (index > 0)
                {
                    QByteArray key   = line.left(index).trimmed();
                    QByteArray value = line.mid(index + 1).trimmed();

                    if (key == "Content-Length")
                        m_contentLength = value.toULongLong();

                    LOG(VB_NETWORK, LOG_DEBUG, QString("%1: %2").arg(key.data()).arg(value.data()));

                    m_headers->insert(key, value);
                }
            }

            m_requestStarted = true;
        }
    }

    // loop if we need more header data
    if (!m_headersComplete)
        return true;

    // abort early if needed
    if (*Abort || Socket->state() != QAbstractSocket::ConnectedState)
        return false;

    // read content
    while (!(*Abort) && (m_contentReceived < m_contentLength) && Socket->bytesAvailable() &&
           Socket->state() == QAbstractSocket::ConnectedState)
    {
        static quint64 MAX_CHUNK = 32 * 1024;
        m_content->append(Socket->read(qMax(m_contentLength - m_contentReceived, qMax(MAX_CHUNK, (quint64)Socket->bytesAvailable()))));
        m_contentReceived = m_content->size();
    }

    // loop if we need more data
    if (m_contentReceived < m_contentLength)
        return true;

    // abort early if needed
    if (*Abort || Socket->state() != QAbstractSocket::ConnectedState)
        return false;

    m_ready = true;
    return true;
}
Example #7
0
void clientHandler::processClient(QTcpSocket *socket, QList<FileExec>fileExecList)
{
    //QByteArray inData;
    //QString inStr;
    //QStringList list;
    //QStringList ops;
    bool getProcess;
    //bool processHeader;
    //QString resultStr;
    executeData ed;
    QByteArray inData;
    qint64 loc;
    qint64 contentLength;
    qint64 requestLength;
    qint64 headerLength;
    quint64 timeout;
    bool processHeader;
    bool dataRecieved;

    processHeader = false;
    this->clientTCP = socket;
    this->fileExecList = fileExecList;
    contentLength = 0;
    requestLength = 0;
    loc = 0;
    getProcess = false;
    dataRecieved = false;
    timeout = 0;

    connect(this->clientTCP,SIGNAL(disconnected()),this,SLOT(socketDisconnected()));
    if (!this->clientTCP->waitForReadyRead(100)){
        this->clientTCP->disconnectFromHost();
        this->clientTCP->deleteLater();
        return;
    }


    inData.clear();
    while(1){

        if (timeout == 30000){
            break;
        }

        //we need to read the first data and determined content length
        if (this->clientTCP->bytesAvailable() > 0){
            qDebug() << this->clientTCP->bytesAvailable();
            timeout = 0;
            inData.append(this->clientTCP->readAll());
            QCoreApplication::processEvents();

            if (!processHeader){

                headerLength = inData.indexOf("\r\n\r\n",0);
                if (headerLength > 0){
                    processHeader = true;

                    //find content length;
                    loc = inData.indexOf("Content-Length:");
                    if (loc < 0){
                        contentLength = 0;
                    }

                    if (loc > 0){
                        //get the size;
                        qint64 loc2 = inData.indexOf("\r\n",loc);
                        if (loc2 < 0){
                            contentLength = 0;
                        }
                        else
                        {
                            QByteArray size;
                            size.clear();
                            size.append(inData.mid(loc,loc2 - loc).replace("Content-Length:","").trimmed());
                            contentLength = size.toULongLong();
                        }
                    }
                }
            }

            if (processHeader){
                requestLength = headerLength + contentLength;
                if (inData.size() >= requestLength){
                    dataRecieved = true;
                    break;
                }
            }
        }
        QCoreApplication::processEvents();
        timeout++;
    }

    if (!dataRecieved){
        this->clientTCP->disconnectFromHost();
        this->clientTCP->deleteLater();
        return;
    }

    //qDebug() << "DEBUG STOP" << requestLength << timeout;
    //qDebug() << "inData size" << inData.size();
    ed = this->processClientRequest(&inData,headerLength);

    /*
    //read from client browser
    inStr = QString::fromLocal8Bit(this->clientTCP->readAll());

    list = inStr.split('\n');

    resultStr.clear();
    resultStr = "<br><font size=1>Infoblox TIG DGA Web System<br>\n";
    resultStr.append("Copyright (C) 2015 Azril arahimATinfobloxDOTcom</font><br><br><b><br>\n");

    for (quint16 i =0;i < list.size();i++){

        ops = list.at(i).split(QChar(32));

        if (ops.at(0).contains("GET")){
            ed = this->processGET(ops.at(1));
            getProcess = true;
            break;
        }

        if (ops.at(0).contains("POST")){
            QString url = this->getPOSTURL(list);
            qDebug() << "POST:" << url;
            //qDebug() << "ACTUAL RAW\n" << inStr << "\n\n";
            ed = this->processPOST(url);
            getProcess = true;
            break;
        }

    }

    if(!getProcess){
        //none get process by GET or POST
        //create error Message
        resultStr.append("Invalid Request. Unknown Request</b><br>\n");
    }

    //qDebug() << resultStr << "\n";

    */

    this->clientTCP->write(this->produceHttpReply(ed));
    this->clientTCP->flush();
    this->clientTCP->waitForBytesWritten();

    //close the socker
    this->clientTCP->disconnectFromHost();
    this->clientTCP->abort();

    return;
}
Example #8
0
int JSonScanner::yylex(YYSTYPE* yylval, yy::location *yylloc)
{
  char ch;

  if (!m_io->isOpen()) {
    qCritical() << "JSonScanner::yylex - io device is not open";
    return -1;
  }

  yylloc->step();

  do {
    bool ret;
    if (m_io->atEnd()) {
      qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::END";
      return yy::json_parser::token::END;
    }
    else
      ret = m_io->getChar(&ch);

    if (!ret) {
      qCritical() << "JSonScanner::yylex - error reading from io device";
      return -1;
    }

    qjsonDebug() << "JSonScanner::yylex - got |" << ch << "|";
    yylloc->columns();

    if (ch == '\n' || ch == '\r')
      yylloc->lines();
  } while (m_quotmarkClosed && (isspace(ch) != 0));

  if (m_quotmarkClosed && ((ch == 't') || (ch == 'T'))) {
    const QByteArray buf = m_io->peek(3).toLower();
    if (buf == "rue") {
      m_io->read (3);
      yylloc->columns(3);
      qjsonDebug() << "JSonScanner::yylex - TRUE_VAL";
      return yy::json_parser::token::TRUE_VAL;
    }
  }
  else if (m_quotmarkClosed && ((ch == 'n') || (ch == 'N'))) {
    const QByteArray buf = m_io->peek(3).toLower();
    if (buf == "ull") {
      m_io->read (3);
      yylloc->columns(3);
      qjsonDebug() << "JSonScanner::yylex - NULL_VAL";
      return yy::json_parser::token::NULL_VAL;
    } else if (buf.startsWith("an") && m_allowSpecialNumbers) {
      m_io->read(2);
      yylloc->columns(2);
      qjsonDebug() << "JSonScanner::yylex - NAN_VAL";
      return yy::json_parser::token::NAN_VAL;

    }
  }
  else if (m_quotmarkClosed && ((ch == 'f') || (ch == 'F'))) {
    // check false value
    const QByteArray buf = m_io->peek(4).toLower();
    if (buf.length() == 4) {
      if (buf == "alse") {
        m_io->read (4);
        yylloc->columns(4);
        qjsonDebug() << "JSonScanner::yylex - FALSE_VAL";
        return yy::json_parser::token::FALSE_VAL;
      }
    }
  }
  else if (m_quotmarkClosed && ((ch == 'e') || (ch == 'E'))) {
    QByteArray ret(1, ch);
    const QByteArray buf = m_io->peek(1);
    if (!buf.isEmpty()) {
      if ((buf[0] == '+' ) || (buf[0] == '-' )) {
        ret += m_io->read (1);
        yylloc->columns();
      }
    }
    *yylval = QVariant(QString::fromUtf8(ret));
    return yy::json_parser::token::E;
  }
  else if (m_allowSpecialNumbers && m_quotmarkClosed && ((ch == 'I') || (ch == 'i'))) {
    QByteArray ret(1, ch);
    const QByteArray buf = m_io->peek(7);
    if (buf == "nfinity") {
      m_io->read(7);
      yylloc->columns(7);
      qjsonDebug() << "JSonScanner::yylex - INFINITY_VAL";
      return yy::json_parser::token::INFINITY_VAL;
    }
  }

  if (ch != '"' && !m_quotmarkClosed) {
    // we're inside a " " block
    QByteArray raw;
    raw += ch;
    char prevCh = ch;
    bool escape_on = (ch == '\\') ? true : false;

    while ( true ) {
      char nextCh;
      qint64 ret = m_io->peek(&nextCh, 1);
      if (ret != 1) {
        if (m_io->atEnd())
          return yy::json_parser::token::END;
        else
          return -1;
      } else if ( !escape_on && nextCh == '\"' ) {
        bool ok;
        const QString str = unescape( raw, &ok );
        *yylval = ok ? str : QString();
        return ok ? yy::json_parser::token::STRING : -1;
      }
#if 0
      if ( prevCh == '\\' && nextCh != '"' && nextCh != '\\' && nextCh != '/' &&
           nextCh != 'b' && nextCh != 'f' && nextCh != 'n' &&
           nextCh != 'r' && nextCh != 't' && nextCh != 'u') {
        qjsonDebug() << "Just read" << nextCh;
        qjsonDebug() << "JSonScanner::yylex - error decoding escaped sequence";
        return -1;
       }
#endif
      m_io->read(1); // consume
      raw += nextCh;
      prevCh = nextCh;
      if (escape_on)
        escape_on = false;
      else
        escape_on = (prevCh == '\\') ? true : false;
#if 0
      if (nextCh == '\\') {
        char buf;
        if (m_io->getChar (&buf)) {
          yylloc->columns();
          if (((buf != '"') && (buf != '\\') && (buf != '/') &&
              (buf != 'b') && (buf != 'f') && (buf != 'n') &&
              (buf != 'r') && (buf != 't') && (buf != 'u'))) {
                qjsonDebug() << "Just read" << buf;
                qjsonDebug() << "JSonScanner::yylex - error decoding escaped sequence";
                return -1;
          }
        } else {
          qCritical() << "JSonScanner::yylex - error decoding escaped sequence : io error";
          return -1;
        }
      }
#endif
    }
  }
  else if (isdigit(ch) != 0 && m_quotmarkClosed) {
    bool ok;
    QByteArray numArray = QByteArray::fromRawData( &ch, 1 * sizeof(char) );
    qulonglong number = numArray.toULongLong(&ok);
    if (!ok) {
      //This shouldn't happen
      qCritical() << "JSonScanner::yylex - error while converting char to ulonglong, returning -1";
      return -1;
    }
    if (number == 0) {
      // we have to return immediately otherwise numbers like
      // 2.04 will be converted to 2.4
      *yylval = QVariant(number);
      qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::DIGIT";
      return yy::json_parser::token::DIGIT;
    }

    char nextCh;
    qint64 ret = m_io->peek(&nextCh, 1);
    while (ret == 1 && isdigit(nextCh)) {
      m_io->read(1); //consume
      yylloc->columns(1);
      numArray = QByteArray::fromRawData( &nextCh, 1 * sizeof(char) );
      number = number * 10 + numArray.toULongLong(&ok);
      if (!ok) {
        //This shouldn't happen
        qCritical() << "JSonScanner::yylex - error while converting char to ulonglong, returning -1";
        return -1;
      }
      ret = m_io->peek(&nextCh, 1);
    }

    *yylval = QVariant(number);
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::DIGIT";
    return yy::json_parser::token::DIGIT;
  }
  else if (isalnum(ch) != 0) {
    *yylval = QVariant(QString(QChar::fromLatin1(ch)));
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::WORD ("
             << ch << ")";
    return yy::json_parser::token::STRING;
  }
  else if (ch == ':') {
    // set yylval
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::COLON";
    return yy::json_parser::token::COLON;
  }
  else if (ch == '"') {
    // yy::json_parser::token::QUOTMARK (")

    // set yylval
    m_quotmarkCount++;
    if (m_quotmarkCount %2 == 0) {
      m_quotmarkClosed = true;
      m_quotmarkCount = 0;
      qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::QUOTMARKCLOSE";
      return yy::json_parser::token::QUOTMARKCLOSE;
    }
    else {
      m_quotmarkClosed = false;
      qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::QUOTMARKOPEN";
      return yy::json_parser::token::QUOTMARKOPEN;
    }
  }
  else if (ch == ',') {
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::COMMA";
    return yy::json_parser::token::COMMA;
  }
  else if (ch == '.') {
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::DOT";
    return yy::json_parser::token::DOT;
  }
  else if (ch == '-') {
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::MINUS";
    return yy::json_parser::token::MINUS;
  }
  else if (ch == '[') {
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::SQUARE_BRACKET_OPEN";
    return yy::json_parser::token::SQUARE_BRACKET_OPEN;
  }
  else if (ch == ']') {
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::SQUARE_BRACKET_CLOSE";
    return yy::json_parser::token::SQUARE_BRACKET_CLOSE;
  }
  else if (ch == '{') {
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::CURLY_BRACKET_OPEN";
    return yy::json_parser::token::CURLY_BRACKET_OPEN;
  }
  else if (ch == '}') {
    qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::CURLY_BRACKET_CLOSE";
    return yy::json_parser::token::CURLY_BRACKET_CLOSE;
  }

  //unknown char!
  //TODO yyerror?
  qCritical() << "JSonScanner::yylex - unknown char, returning -1";
  return -1;
}