api/3.8/qgsfcgiserverresponse_8cpp_source.html

 /***************************************************************************
                           qgsfcgiserverresponse.cpp

   Define response wrapper for fcgi response
   -------------------
   begin                : 2017-01-03
   copyright            : (C) 2017 by David Marteau
   email                : david dot marteau at 3liz dot 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.                                   *
  *                                                                         *
  ***************************************************************************/

 #include "qgis.h"
 #include "qgsfcgiserverresponse.h"
 #include "qgsmessagelog.h"
 #include <fcgi_stdio.h>
 #include <QDebug>

 //
 // QgsFcgiServerResponse
 //

 QgsFcgiServerResponse::QgsFcgiServerResponse( QgsServerRequest::Method method )
   : mMethod( method )
 {
   mBuffer.open( QIODevice::ReadWrite );
   setDefaultHeaders();
 }

 void QgsFcgiServerResponse::removeHeader( const QString &key )
 {
   mHeaders.remove( key );
 }

 void QgsFcgiServerResponse::setHeader( const QString &key, const QString &value )
 {
   mHeaders.insert( key, value );
 }

 QString QgsFcgiServerResponse::header( const QString &key ) const
 {
   return mHeaders.value( key );
 }

 bool QgsFcgiServerResponse::headersSent() const
 {
   return mHeadersSent;
 }

 void QgsFcgiServerResponse::setStatusCode( int code )
 {
   // fcgi applications must return HTTP status in header
   mHeaders.insert( QStringLiteral( "Status" ), QStringLiteral( " %1" ).arg( code ) );
   // Store the code to make it available for plugins
   mStatusCode = code;
 }

 void QgsFcgiServerResponse::sendError( int code,  const QString &message )
 {
   if ( mHeadersSent )
   {
     QgsMessageLog::logMessage( "Cannot send error after headers written" );
     return;
   }

   clear();
   setStatusCode( code );
   setHeader( QStringLiteral( "Content-Type" ), QStringLiteral( "text/html;charset=utf-8" ) );
   write( QStringLiteral( "<html><body>%1</body></html>" ).arg( message ) );
   finish();
 }

 QIODevice *QgsFcgiServerResponse::io()
 {
   return &mBuffer;
 }

 void QgsFcgiServerResponse::finish()
 {
   if ( mFinished )
   {
     QgsMessageLog::logMessage( "finish() called twice" );
     return;
   }

   if ( !mHeadersSent )
   {
     if ( ! mHeaders.contains( "Content-Length" ) )
     {
       mHeaders.insert( QStringLiteral( "Content-Length" ), QStringLiteral( "%1" ).arg( mBuffer.pos() ) );
     }
   }
   flush();
   mFinished = true;
 }

 void QgsFcgiServerResponse::flush()
 {
   if ( ! mHeadersSent )
   {
     // Send all headers
     QMap<QString, QString>::const_iterator it;
     for ( it = mHeaders.constBegin(); it != mHeaders.constEnd(); ++it )
     {
       fputs( it.key().toUtf8(), FCGI_stdout );
       fputs( ": ", FCGI_stdout );
       fputs( it.value().toUtf8(), FCGI_stdout );
       fputs( "\n", FCGI_stdout );
     }
     fputs( "\n", FCGI_stdout );
     mHeadersSent = true;
   }

   mBuffer.seek( 0 );
   if ( mMethod == QgsServerRequest::HeadMethod )
   {
     // Ignore data for head method as we only
     // write headers for HEAD requests
     mBuffer.buffer().clear();
   }
   else if ( mBuffer.bytesAvailable() > 0 )
   {
     QByteArray &ba = mBuffer.buffer();
     size_t count   = fwrite( ( void * )ba.data(), ba.size(), 1, FCGI_stdout );
 #ifdef QGISDEBUG
     qDebug() << QStringLiteral( "Sent %1 blocks of %2 bytes" ).arg( count ).arg( ba.size() );
 #else
     Q_UNUSED( count )
 #endif
     // Reset the internal buffer
     ba.clear();
   }
 }


 void QgsFcgiServerResponse::clear()
 {
   mHeaders.clear();
   mBuffer.seek( 0 );
   mBuffer.buffer().clear();

   // Restore default headers
   setDefaultHeaders();
 }


 QByteArray QgsFcgiServerResponse::data() const
 {
   return mBuffer.data();
 }


 void QgsFcgiServerResponse::truncate()
 {
   mBuffer.seek( 0 );
   mBuffer.buffer().clear();
 }


 void QgsFcgiServerResponse::setDefaultHeaders()
 {
   setHeader( QStringLiteral( "Server" ), QStringLiteral( " Qgis FCGI server - QGis version %1" ).arg( Qgis::QGIS_VERSION ) );
 }
QgsFcgiServerResponse::setDefaultHeaders
void setDefaultHeaders()
Set the default headers.
Definition: qgsfcgiserverresponse.cpp:167

qgsfcgiserverresponse.h

Qgis::QGIS_VERSION
static const QString QGIS_VERSION
Version string.
Definition: qgis.h:51

QgsFcgiServerResponse::truncate
void truncate() override
Truncate data.
Definition: qgsfcgiserverresponse.cpp:160

QgsServerRequest::Method
Method
HTTP Method (or equivalent) used for the request.
Definition: qgsserverrequest.h:48

QgsServerResponse::write
virtual void write(const QString &data)
Write string This is a convenient method that will write directly to the underlying I/O device...
Definition: qgsserverresponse.cpp:25

QgsFcgiServerResponse::clear
void clear() override
Reset all headers and content for this response.
Definition: qgsfcgiserverresponse.cpp:143

QgsServerRequest::HeadMethod
Definition: qgsserverrequest.h:50

QgsFcgiServerResponse::headersSent
bool headersSent() const override
Returns true if the headers have already been sent.
Definition: qgsfcgiserverresponse.cpp:52

QgsFcgiServerResponse::data
QByteArray data() const override
Gets the data written so far.
Definition: qgsfcgiserverresponse.cpp:154

QgsFcgiServerResponse::header
QString header(const QString &key) const override
Returns the header value.
Definition: qgsfcgiserverresponse.cpp:47

QgsMessageLog::logMessage
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
Definition: qgsmessagelog.cpp:27

qgsmessagelog.h

QgsFcgiServerResponse::sendError
void sendError(int code, const QString &message) override
Send error This method delegates error handling at the server level.
Definition: qgsfcgiserverresponse.cpp:65

QgsFcgiServerResponse::finish
void finish() override
Finish the response, ending the transaction.
Definition: qgsfcgiserverresponse.cpp:85

QgsFcgiServerResponse::QgsFcgiServerResponse
QgsFcgiServerResponse(QgsServerRequest::Method method=QgsServerRequest::GetMethod)
Constructor for QgsFcgiServerResponse.
Definition: qgsfcgiserverresponse.cpp:30

QgsFcgiServerResponse::setStatusCode
void setStatusCode(int code) override
Set the http status code.
Definition: qgsfcgiserverresponse.cpp:57

QgsFcgiServerResponse::removeHeader
void removeHeader(const QString &key) override
Clear header Undo a previous &#39;setHeader&#39; call.
Definition: qgsfcgiserverresponse.cpp:37

QgsFcgiServerResponse::flush
void flush() override
Flushes the current output buffer to the network.
Definition: qgsfcgiserverresponse.cpp:104

qgis.h

QgsFcgiServerResponse::io
QIODevice * io() override
Returns the underlying QIODevice.
Definition: qgsfcgiserverresponse.cpp:80

QgsFcgiServerResponse::setHeader
void setHeader(const QString &key, const QString &value) override
Set Header entry Add Header entry to the response Note that it is usually an error to set Header afte...
Definition: qgsfcgiserverresponse.cpp:42