VFS_curlauth.cpp

Go to the documentation of this file.

 
#include "VFS_curlauth.h"
#include "VFS.h"
 
#include <QUrlQuery>
#include <QNetworkRequest>
 
VFS_curlauth::VFS_curlauth(QString url,QString token)
: VFS_auth()
, _url(url)
, _manager(this)
, _token(token)
{
        if (!_url.isValid())
                VFS::WARN("The provided url is invalid: \""+url+"\".  Requests will fail.");
 
        connect(        &_manager,      SIGNAL(finished(QNetworkReply*)),
                        this,           SLOT(replyFinished(QNetworkReply*))     );
 
        connect(        &_manager,      SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
                        this,           SLOT(sslErrors(QNetworkReply*,QList<QSslError>))        );
}
 
VFS_curlauth::~VFS_curlauth()
{
}
 
//http://www.qtcentre.org/threads/42545-HTTP-request-POST-in-QT-application
 
void VFS_curlauth::read(VFS_request *r)
{
        QJsonObject o = r->_data.object();
 
        //FIXME: check if r->_path is empty!
 
        QString user = o["username"].toString();
        QString pass = o["password"].toString();
 
        QUrlQuery params;
        params.addQueryItem("username",user);
        params.addQueryItem("password",pass);
 
        //VFS_request *s = r->getCallback(this);
        r->_isCallback = true;                          //defer the response as if there were a callback.
 
        QNetworkRequest request(_url);
        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
 
        QNetworkReply *p = _manager.post(request,params.query().toUtf8());
 
        _requests[p] = r;
 
        //r->_success = false;
        //r->_user = username;
}
 
 
void VFS_curlauth::ls(VFS_request *r)
{
        //printf("curlauth LS\n");
        QUrlQuery params;
        params.addQueryItem("mode","list");
 
        if (!_token.isEmpty())
                params.addQueryItem("vfscurltoken",_token);
 
        //VFS_request *s = r->getCallback(this);
        r->_isCallback = true;                          //defer the response as if there were a callback.
 
        QNetworkRequest request(_url);
        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
 
        QNetworkReply *p = _manager.post(request,params.query().toUtf8());
 
        _requests[p] = r;
}
 
 
void VFS_curlauth::replyFinished(QNetworkReply *reply)
{
        if (_requests.contains(reply))
        {
                VFS_request *r = _requests.take(reply);
 
                if (reply->error())
                {
                        r->_reason = QString("Curlauth error: %1").arg(reply->errorString());
                        r->_success = false;
                }
                else
                {
                        QByteArray response = reply->readAll();
                        //printf("received: %s\n",qUtf8Printable(response));
 
                        QJsonParseError error;
                        QJsonDocument doc = QJsonDocument::fromJson(response,&error);
                        if (error.error == QJsonParseError::NoError)
                        {
                                switch(r->_requestType)
                                {
                                        case VFS_request::read: {
                                                                        QJsonObject o = doc.object();
                                                                        QJsonObject d = r->_data.object();
 
                                                                        if (o["valid"].toBool() && o.contains("username"))
                                                                        {
                                                                                //d["username"] = d["username"];
                                                                                d["uidnumber"] = o["uidnumber"].toInt( 0 );
                                                                                d["realname"] = o.contains("realname") ? o["realname"] : o["username"];
 
                                                                                d["groups"] = o.contains("groups") ? o["groups"].toArray() : QJsonArray();
 
                                                                                //d["type"] = d["type"].toString("default");
 
                                                                                r->_data.setObject(d);
 
                                                                                r->_success = true;
                                                                                r->_user = o["username"].toString();
                                                                        }
                                                                        else
                                                                        {
                                                                                //printf("CURLAUTH NOT VALID!\n");
                                                                                if (o.contains("error"))
                                                                                        r->_reason = "Curlauth error: "+o["error"].toString();
                                                                                else
                                                                                        r->_reason = "Unspecified curlauth error";
 
                                                                                r->_success = false;
                                                                                r->_user = d["username"].toString();
                                                                        }
                                                                }
                                                                break;
 
                                        case VFS_request::ls:   {
                                                                        QJsonObject o = doc.object();
 
                                                                        if (o["valid"].toBool() && o.contains("users"))
                                                                        {
                                                                                QJsonObject u = r->_data.object();
                                                                                //u["curlauth"] = o["users"].toObject();
                                                                                u[r->_initialPath] = o["users"].toObject();
 
                                                                                r->_data.setObject(u);
                                                                                r->_success = true;
                                                                        }
                                                                        else
                                                                        {
                                                                                //printf("CURLAUTH NOT VALID!\n");
                                                                                if (o.contains("error"))
                                                                                        r->_reason = o["error"].toString();
                                                                                else
                                                                                        r->_reason = "Unspecified curlauth error";
 
                                                                                r->_success = false;
                                                                        }
                                                                }
                                                                break;
 
                                        default:                r->_reason = QString("Unknown curlauth type: %2 (%1)").arg(r->_requestType).arg(VFS_request::requestTypeStrings[r->_requestType]);
                                                                r->_success = false;
                                                                break;
                                }
 
 
                        }
                        else
                        {
                                r->_success = false;
                                r->_reason = QString("JSON parse error in respone to curl request at '%1': %2\n%3").arg(_url.toString()).arg(error.errorString()).arg(QString(response));
                        }
                }
 
                issueResponse(r);
        }
        else
        {
                VFS::ERROR( QString("Unable to find a VFS_request for network reply on \"%1\".  If there was a request, it will not be deleted and will leak memory.").arg(reply->url().toString()), 0, className() );
        }
 
        reply->deleteLater();
}
 
void VFS_curlauth::sslErrors(QNetworkReply *reply, QList<QSslError> errors)
{
        for (int i=0;i<errors.size();i++)
                VFS::ERROR( errors.at(i).errorString(), 0, className() );
 
        replyFinished(reply);
}