void GetPocketApi::UpdateTags(const QString& id, const QString& tags)
{
QVariantMap params;
params["consumer_key"] = m_ConsumerKey;
params["access_token"] = ApplicationSettings::Instance(this)->value("accessToken");
QVariantList actions;
QVariantMap action;
action["action"] = "tags_replace";
action["item_id"] = id;
action["tags"] = tags;
actions.append(action);
params ["actions"] = actions;
QJsonDocument doc(QJsonObject::fromVariantMap(params));
QNetworkReply *reply = m_NAM->post(CreateRequest("/send"),
doc.toJson());
connect(reply,
&QNetworkReply::finished,
this,
[this, id, tags]()
{
handleTagsUpdated(id, tags);
});
}
void SoundCloudService::RetrieveUserPlaylists() {
QList<Param> parameters;
parameters << Param("oauth_token", access_token_);
QNetworkReply* reply = CreateRequest("me/playlists", parameters);
NewClosure(reply, SIGNAL(finished()), this,
SLOT(UserPlaylistsRetrieved(QNetworkReply*)), reply);
}
void GetPocketApi::MarkBookmarksAsRead(const QStringList& ids, bool read)
{
QVariantMap params;
params["consumer_key"] = m_ConsumerKey;
params["access_token"] = ApplicationSettings::Instance(this)->value("accessToken");
QVariantList actions;
for (const auto& id : ids)
{
QVariantMap action;
action["action"] = read ? "archive" : "readd";
action["item_id"] = id;
actions.append(action);
}
params ["actions"] = actions;
QJsonDocument doc(QJsonObject::fromVariantMap(params));
QNetworkReply *reply = m_NAM->post(CreateRequest("/send"),
doc.toJson());
connect(reply,
&QNetworkReply::finished,
this,
[this, ids, read]()
{
handleMarkBookmarksAsRead(ids, read);
});
}
void * StarServer(void * client)
{
http_request * request = CreateRequest();
int client_socket;
client_socket = *(int *)client;
int server_status;
server_status = GetContent(client_socket, request->buf, HTTP_REQUEST_BUF_MAX_LENGTH);
if(server_status)
{
if(server_status==-1)
ReturnError(400,client_socket);
if(server_status==-2)
ReturnError(414,client_socket);
}
else
{
int analysis_status = 0;
analysis_status = AnalysisRequest(request);
if(analysis_status)
ReturnError(analysis_status, client_socket);
else
HandleRequest(client_socket, request);
}
DestroyRequest(request);
close(client_socket);
return NULL;
}
void BusClient::SendRequest(MojServiceRequest::ReplySignal::SlotRef handler, const MojChar* service,
const MojChar* method, const MojObject& payload, MojUInt32 numReplies)
{
MojRefCountedPtr<MojServiceRequest> req = CreateRequest();
MojErr err = req->send(handler, service, method, payload, numReplies);
ErrorToException(err);
}
int SoundCloudService::SimpleSearch(const QString& text) {
QList<Param> parameters;
parameters << Param("q", text);
QNetworkReply* reply = CreateRequest("tracks", parameters);
const int id = next_pending_search_id_++;
NewClosure(reply, SIGNAL(finished()), this,
SLOT(SimpleSearchFinished(QNetworkReply*, int)), reply, id);
return id;
}
void SoundCloudService::DoSearch() {
ClearSearchResults();
QList<Param> parameters;
parameters << Param("q", pending_search_);
QNetworkReply* reply = CreateRequest("tracks", parameters);
const int id = next_pending_search_id_++;
NewClosure(reply, SIGNAL(finished()), this,
SLOT(SearchFinished(QNetworkReply*, int)), reply, id);
}
void SoundCloudService::RetrievePlaylist(int playlist_id, QStandardItem* playlist_item) {
const int request_id = next_retrieve_playlist_id_++;
pending_playlists_requests_.insert(
request_id,
PlaylistInfo(playlist_id, playlist_item));
QList<Param> parameters;
parameters << Param("oauth_token", access_token_);
QNetworkReply* reply = CreateRequest("playlists/" + QString::number(playlist_id), parameters);
NewClosure(reply, SIGNAL(finished()), this,
SLOT(PlaylistRetrieved(QNetworkReply*, int)), reply, request_id);
}
HRESULT NamedPipe::Write(const void* buffer, DWORD size, Listener* listener) {
if (buffer == nullptr || listener == nullptr)
return E_INVALIDARG;
auto request = CreateRequest(Command::kWrite, listener);
if (request == nullptr)
return E_OUTOFMEMORY;
request->InternalHigh = size;
request->buffer = const_cast<void*>(buffer);
return DispatchRequest(std::move(request));
}
//-----------------------------------------------------------------------------
/// GetPendingRequests
///
/// This is a non-blocking function that will iterate through the pending
/// requests and call ProcessRequest (See IProcessRequests.h) for each request.
/// Frame-based plugins should call this function at the start of each frame.
/// Global plugins do not need to call this function.
//-----------------------------------------------------------------------------
void GetPendingRequests()
{
if (smLockGet(g_strSharedMemoryName) == false)
{
return;
}
HTTPHeaderData requestHeader;
DWORD dwSize = sizeof(HTTPHeaderData);
int nCount = 0;
while (smGet(g_strSharedMemoryName, NULL, 0) > 0)
{
smGet(g_strSharedMemoryName, (void*)&requestHeader, dwSize);
HTTPRequestHeader* pRequest = new HTTPRequestHeader(requestHeader);
// Check to see if POST data is present.
if (pRequest->GetPostDataSize() > 0)
{
string strError;
bool bRes = pRequest->ReadPostData(strError, true, g_strSharedMemoryName);
if (bRes == false)
{
Log(logERROR, "Failed to read POST data during smGet().\n");
}
// Debug code - leave in for now.
//printf ( "%s\n", pRequest->GetPostData() );
}
CommunicationID requestID = CreateRequest(pRequest, false);
nCount++;
if (g_processRequest(requestID) == false)
{
SendHTTPErrorResponse(requestID, 404);
break;
}
}
smUnlockGet(g_strSharedMemoryName);
if (nCount > 0)
{
Log(logMESSAGE, "Server loading: %d\n", nCount);
}
}
// 读请求
void SSLSession::read()
{
IMessage* req = CreateRequest();
int size = req->GetMsgHeaderSize();
boost::asio::async_read(shared_from_this()->socket,
boost::asio::buffer(req->GetMsgHeader(), req->GetMsgHeaderSize()),
boost::asio::transfer_all(),
strand.wrap(
boost::bind(&SSLSession::OnReadHead, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred, req)
)
);
}
void FotoBilderAccount::GetChallenge ()
{
auto reply = Proxy_->GetNetworkAccessManager ()->
get (CreateRequest (Util::MakeMap<QByteArray, QByteArray> ({
{ "X-FB-User", Login_.toUtf8 () },
{ "X-FB-Mode", "GetChallenge" } })));
connect (reply,
SIGNAL (finished ()),
this,
SLOT (handleGetChallengeRequestFinished ()));
connect (reply,
SIGNAL (error (QNetworkReply::NetworkError)),
this,
SLOT (handleNetworkError (QNetworkReply::NetworkError)));
}
void GetPocketApi::ObtainRequestToken()
{
QVariantMap params;
params["consumer_key"] = m_ConsumerKey;
params["redirect_uri"] = "linksbag://authorizationFinished";
QJsonDocument doc(QJsonObject::fromVariantMap(params));
QNetworkReply *reply = m_NAM->post(CreateRequest("/oauth/request"),
doc.toJson());
connect(reply,
&QNetworkReply::finished,
this,
&GetPocketApi::handleObtainRequestToken);
}
void GetPocketApi::RequestAccessToken()
{
QVariantMap params;
params["consumer_key"] = m_ConsumerKey;
params["code"] = m_RequestToken;
QJsonDocument doc(QJsonObject::fromVariantMap(params));
QNetworkReply *reply = m_NAM->post(CreateRequest("/oauth/authorize"),
doc.toJson());
connect(reply,
&QNetworkReply::finished,
this,
&GetPocketApi::handleRequestAccessToken);
}
void FotoBilderAccount::UploadOneImage (const QByteArray& id,
const UploadItem& item, const QString& challenge)
{
QFile file (item.FilePath_);
if (!file.open (QIODevice::ReadOnly))
return;
auto content = file.readAll ();
QByteArray md5 = QCryptographicHash::hash (content, QCryptographicHash::Md5);
file.close ();
auto reply = Proxy_->GetNetworkAccessManager ()->
put (CreateRequest (Util::MakeMap<QByteArray, QByteArray> ({
{ "X-FB-User", Login_.toUtf8 () },
{ "X-FB-Mode", "UploadPic" },
{ "X-FB-Auth", ("crp:" + challenge + ":" +
GetHashedChallenge (GetPassword (), challenge))
.toUtf8 () },
{ "X-FB-AuthVerifier", "md5=" + md5 + "&mode=UploadPic" },
{ "X-FB-UploadPic.ImageData", QDateTime::currentDateTime ()
.toString (Qt::ISODate).toUtf8 () },
{ "X-FB-UploadPic.MD5", md5 },
//TODO access to images
{ "X-FB-UploadPic.PicSec", "255" },
{ "X-FB-UploadPic.Meta.Filename", QFileInfo (item.FilePath_)
.fileName ().toUtf8 () },
{ "X-FB-UploadPic.Meta.Title", QFileInfo (item.FilePath_)
.fileName ().toUtf8 () },
{ "X-FB-UploadPic.Meta.Description", item.Description_.toUtf8 () },
{ "X-FB-UploadPic.Gallery._size", "1" },
{ "X-FB-UploadPic.Gallery.0.GalID", id },
{ "X-FB-UploadPic.ImageSize", QString::number (QFileInfo (item.FilePath_)
.size ()).toUtf8 () } })),
content);
Reply2UploadItem_ [reply] = item;
connect (reply,
SIGNAL (finished ()),
this,
SLOT (handleImageUploaded ()));
connect (reply,
SIGNAL (uploadProgress (qint64, qint64)),
this,
SLOT (handleUploadProgress (qint64, qint64)));
connect (reply,
SIGNAL (error (QNetworkReply::NetworkError)),
this,
SLOT (handleNetworkError (QNetworkReply::NetworkError)));
}
void FotoBilderAccount::GetPicsRequest (const QString& challenge)
{
auto reply = Proxy_->GetNetworkAccessManager ()->
get (CreateRequest (Util::MakeMap<QByteArray, QByteArray> ({
{ "X-FB-User", Login_.toUtf8 () },
{ "X-FB-Mode", "GetPics" },
{ "X-FB-Auth", ("crp:" + challenge + ":" +
GetHashedChallenge (GetPassword (), challenge))
.toUtf8 () } })));
connect (reply,
SIGNAL (finished ()),
this,
SLOT (handleGotPhotos ()));
connect (reply,
SIGNAL (error (QNetworkReply::NetworkError)),
this,
SLOT (handleNetworkError (QNetworkReply::NetworkError)));
}
void GetPocketApi::LoadBookmarks(int lastUpdate)
{
QVariantMap params;
params["consumer_key"] = m_ConsumerKey;
params["access_token"] = ApplicationSettings::Instance(this)->value("accessToken");
params["state"] = "all";
params["sort"] = "oldest";
params["detailType"] = "complete";
params["since"] = lastUpdate;
QJsonDocument doc(QJsonObject::fromVariantMap(params));
QNetworkReply *reply = m_NAM->post(CreateRequest("/get"),
doc.toJson());
connect(reply,
&QNetworkReply::finished,
this,
&GetPocketApi::handleLoadBookmarks);
}
void FotoBilderAccount::LoginRequest (const QString& challenge)
{
auto reply = Proxy_->GetNetworkAccessManager ()->
get (CreateRequest (Util::MakeMap<QByteArray, QByteArray> ({
{ "X-FB-User", Login_.toUtf8 () },
{ "X-FB-Mode", "Login" },
{ "X-FB-Auth", ("crp:" + challenge + ":" +
GetHashedChallenge (GetPassword (), challenge))
.toUtf8 () },
{ "X-FB-Login.ClientVersion",
"LeechCraft Blasq/" + Proxy_->GetVersion ()
.toUtf8 () } })));
connect (reply,
SIGNAL (finished ()),
this,
SLOT (handleLoginRequestFinished ()));
connect (reply,
SIGNAL (error (QNetworkReply::NetworkError)),
this,
SLOT (handleNetworkError (QNetworkReply::NetworkError)));
}
HRESULT NamedPipe::Accept(Listener* listener) {
if (listener == nullptr)
return E_INVALIDARG;
try {
auto request = CreateRequest(Command::kAccept, listener);
if (request == nullptr)
return E_OUTOFMEMORY;
base::AutoLock guard(lock_);
if (!IsValid())
return E_HANDLE;
queue_.push_back(std::move(request));
if (queue_.size() == 1)
SubmitThreadpoolWork(work_);
} catch (...) {
return E_FAIL;
}
return S_OK;
}
void FotoBilderAccount::CreateGallery (const QString& name, int privacyLevel,
const QString& challenge)
{
auto reply = Proxy_->GetNetworkAccessManager ()->
get (CreateRequest (Util::MakeMap<QByteArray, QByteArray> ({
{ "X-FB-User", Login_.toUtf8 () },
{ "X-FB-Mode", "CreateGals" },
{ "X-FB-Auth", ("crp:" + challenge + ":" +
GetHashedChallenge (GetPassword (), challenge))
.toUtf8 () },
{ "X-FB-CreateGals.Gallery._size", "1" },
{ "X-FB-CreateGals.Gallery.0.ParentID", "0" },
{ "X-FB-CreateGals.Gallery.0.GalName", name.toUtf8 () },
{ "X-FB-CreateGals.Gallery.0.GalSec",
QString::number (privacyLevel).toUtf8 () } })));
connect (reply,
SIGNAL (finished ()),
this,
SLOT (handleGalleryCreated ()));
connect (reply,
SIGNAL (error (QNetworkReply::NetworkError)),
this,
SLOT (handleNetworkError (QNetworkReply::NetworkError)));
}
