File indexing completed on 2024-04-21 04:36:03

 /*
  * XDebug Debugger Support
  *
  * Copyright (C) 2004-2006 by Thiago Silva <thiago.silva@kdemail.net>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * 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.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "connection.h"
 
 #include <QTcpSocket>
 #include <QTextCodec>
 #include <QDomElement>
 
 #include <QDebug>
 #include <QUrl>
 
 #include <interfaces/icore.h>
 #include <interfaces/idebugcontroller.h>
 
 #include "debugsession.h"
 #include "debuggerdebug.h"
 
 namespace XDebug {
 Connection::Connection(QTcpSocket* socket, QObject* parent)
     : QObject(parent)
     , m_socket(socket)
     , m_currentState(DebugSession::NotStartedState)
     , m_lastTransactionId(0)
 {
     Q_ASSERT(m_socket);
     m_socket->setParent(this);
 
     m_codec = QTextCodec::codecForLocale();
 
     connect(m_socket,&QTcpSocket::disconnected, this, &Connection::closed);
     connect(m_socket,  static_cast<void (QTcpSocket::*) (QAbstractSocket::SocketError)>(&QTcpSocket::error), this, &Connection::error);
 
     connect(m_socket, &QTcpSocket::readyRead, this, &Connection::readyRead);
 }
 
 Connection::~Connection()
 {
 }
 
 void Connection::close()
 {
     delete m_socket;
     m_socket = nullptr;
 }
 
 void Connection::error(QAbstractSocket::SocketError error)
 {
     //qCWarning(KDEV_PHP_DEBUGGER) << m_socket->errorString();
     qCWarning(KDEV_PHP_DEBUGGER) << error;
 }
 
 void Connection::readyRead()
 {
     while (m_socket && m_socket->bytesAvailable()) {
         long length;
         {
             QByteArray data;
             char c;
             while (m_socket->getChar(&c)) {
                 if (c == 0) {
                     break;
                 }
                 data.append(c);
             }
             length = data.toLong();
         }
         QByteArray data;
         while (data.length() <= length) {
             if (!data.isEmpty() && !m_socket->waitForReadyRead()) {
                 return;
             }
             data += m_socket->read(length - data.length() + 1);
         }
         //qCDebug(KDEV_PHP_DEBUGGER) << data;
 
         QDomDocument doc;
         doc.setContent(data);
         if (doc.documentElement().tagName() == "init") {
             processInit(doc);
         } else if (doc.documentElement().tagName() == "response") {
             processResponse(doc);
         } else if (doc.documentElement().tagName() == "stream") {
             processStream(doc);
         } else {
             //qCWarning(KDEV_PHP_DEBUGGER) << "unknown element" << xml->name();
         }
     }
 }
 void Connection::sendCommand(const QString& cmd, QStringList arguments, const QByteArray& data, CallbackBase* callback)
 {
     Q_ASSERT(m_socket);
     Q_ASSERT(m_socket->isOpen());
 
     arguments.prepend("-i " + QString::number(++m_lastTransactionId));
     if (callback) {
         m_callbacks[m_lastTransactionId] = callback;
     }
 
     QByteArray out = m_codec->fromUnicode(cmd);
     if (!arguments.isEmpty()) {
         out += ' ' + m_codec->fromUnicode(arguments.join(QString(' ')));
     }
     if (!data.isEmpty()) {
         out += " -- " + data.toBase64();
     }
     qCDebug(KDEV_PHP_DEBUGGER) << out;
     m_socket->write(out);
     m_socket->write("\0", 1);
 }
 
 void Connection::processInit(const QDomDocument& xml)
 {
     qCDebug(KDEV_PHP_DEBUGGER) << "idekey" << xml.documentElement().attribute("idekey");
 
     sendCommand("feature_get -n encoding");
     sendCommand("stderr -c 1"); //copy stderr to IDE
     sendCommand("stdout -c 1"); //copy stdout to IDE
 
     setState(DebugSession::StartingState);
 }
 
 void Connection::processResponse(const QDomDocument& xml)
 {
     QString status = xml.documentElement().attribute("status");
     if (status == "running") {
         setState(DebugSession::ActiveState);
     } else if (status == "stopping") {
         setState(DebugSession::StoppingState);
     } else if (status == "stopped") {
         setState(DebugSession::StoppedState);
     } else if (status == "break") {
         setState(DebugSession::PausedState);
         QDomElement el = xml.documentElement().firstChildElement();
         if (el.nodeName() == "xdebug:message") {
             QUrl file = QUrl(el.attribute("filename"));
             int lineNum = el.attribute("lineno").toInt() - 1;
             emit currentPositionChanged(file, lineNum);
         }
     }
     if (xml.documentElement().attribute("command") == "feature_get" && xml.documentElement().attribute("feature_name") == "encoding") {
         QTextCodec* c = QTextCodec::codecForName(xml.documentElement().text().toUtf8());
         if (c) {
             m_codec = c;
         }
     }
 
     CallbackBase* callback = nullptr;
     if (xml.documentElement().hasAttribute("transaction_id")) {
         int transactionId = xml.documentElement().attribute("transaction_id").toInt();
         if (m_callbacks.contains(transactionId)) {
             callback = m_callbacks[transactionId];
             m_callbacks.remove(transactionId);
         }
     }
     if (callback && !callback->allowError()) {
         //if callback doesn't handle errors himself
         QDomElement el = xml.documentElement().firstChildElement();
         if (el.nodeName() == "error") {
             qCWarning(KDEV_PHP_DEBUGGER) << "error" << el.attribute("code") << "for transaction" << xml.documentElement().attribute("transaction_id");
             qCDebug(KDEV_PHP_DEBUGGER) << el.firstChildElement().text();
             Q_ASSERT(false);
         }
     }
     if (callback) {
         callback->execute(xml);
         delete callback;
     }
 }
 
 void Connection::setState(DebugSession::DebuggerState state)
 {
     qCDebug(KDEV_PHP_DEBUGGER) << state;
     if (m_currentState == state) {
         return;
     }
     m_currentState = state;
     emit stateChanged(state);
 }
 
 DebugSession::DebuggerState Connection::currentState()
 {
     return m_currentState;
 }
 
 void Connection::processStream(const QDomDocument& xml)
 {
     if (xml.documentElement().attribute("encoding") == "base64") {
         /* We ignore the output type for now
            KDevelop::IRunProvider::OutputTypes outputType;
            if (xml->attributes().value("type") == "stdout") {
             outputType = KDevelop::IRunProvider::StandardOutput;
            } else if (xml->attributes().value("type") == "stderr") {
             outputType = KDevelop::IRunProvider::StandardError;
            } else {
             qCWarning(KDEV_PHP_DEBUGGER) << "unknown output type" << xml->attributes().value("type");
             return;
            }
          */
 
         QString c = m_codec->toUnicode(QByteArray::fromBase64(xml.documentElement().text().toUtf8()));
         //qCDebug(KDEV_PHP_DEBUGGER) << c;
         emit output(c);
         m_outputLine += c;
         int pos = m_outputLine.indexOf('\n');
         if (pos != -1) {
             emit outputLine(m_outputLine.left(pos));
             m_outputLine = m_outputLine.mid(pos + 1);
         }
     } else {
         qCWarning(KDEV_PHP_DEBUGGER) << "unknown encoding" << xml.documentElement().attribute("encoding");
     }
 }
 
 void Connection::processFinished(int exitCode)
 {
     Q_UNUSED(exitCode);
     /*
        QMapIterator<KDevelop::IRunProvider::OutputTypes, QString> i(m_outputLine);
        while (i.hasNext()) {
         i.next();
         emit outputLine(i.value(), i.key());
        }
      */
 }
 
 QTcpSocket* Connection::socket()
 {
     return m_socket;
 }
 }