// a pointer, I have decided to diverge from the rest of Miranda and go with

// the convention that functions return false on failure and nonzero on success.

struct NETLIBOPENCONNECTION;

#define NETLIB_USER_AGENT "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.112 Safari/537.36"

/////////////////////////////////////////////////////////////////////////////////////////

#define REQUEST_RESPONSE 0 // used by structure returned by MS_NETLIB_RECVHTTPHEADERS

#define REQUEST_GET 1

#define REQUEST_POST 2

#define NLHRF_DUMPASTEXT 0x00080000 // dump posted and reply data as text. Headers are always dumped as text.

#define NLHRF_NODUMPSEND 0x00100000 // do not dump sent message.

{

__forceinline const char *operator[](const char *pszName) {

}

};

class NLHR_PTR

{

public:

{

}

{

if (_p)

_p = p;

return _p;

}

__forceinline ~NLHR_PTR()

{

}

};

template <class T>

class MTHttpRequest : public MHttpRequest

__forceinline MTHttpRequest()

{}

MTHttpRequestHandler m_pFunc = nullptr;

};

MIR_APP_DLL(MHttpRequest*) operator<<(MHttpRequest*, const INT_PARAM&);

MIR_APP_DLL(MHttpRequest*) operator<<(MHttpRequest*, const CHAR_PARAM&);

MIR_APP_DLL(MHttpRequest*) operator<<(MHttpRequest*, const WCHAR_PARAM&);

/////////////////////////////////////////////////////////////////////////////////////////

// Do an entire HTTP transaction

//

// Call Netlib_FreeHttpRequest() to free this.

// hUser must have been returned by MS_NETLIB_REGISTERUSER

// nlhr.szUrl should be a full HTTP URL. If it does not start with http:// , that

// Errors: ERROR_INVALID_PARAMETER, ERROR_OUTOFMEMORY, anything from the above

// list of functions

/////////////////////////////////////////////////////////////////////////////////////////

// Send data over a connection

};

// connects to a WebSocket server

// validates that the provided buffer contains full WebSocket datagram

EXTERN_C MIR_APP_DLL(bool) WebSocket_InitHeader(WSHeader &hdr, const void *pData, size_t bufSize);

{

HCURSOR hPrevCursor = ::SetCursor(::LoadCursor(nullptr, IDC_WAIT));

nlhr.flags = NLHRF_DUMPASTEXT;

IN_ADDR externIP;

externIP.s_addr = 0;

NLHR_PTR nlreply(Netlib_HttpTransaction(hNetlibUser, &nlhr));

if (nlreply) {

if (nlreply->resultCode >= 200 && nlreply->resultCode < 300) {

if (pszIp == nullptr)

else

pszIp += mir_strlen(szPattern);

while ((*pszIp < '0' || *pszIp > '9') && *pszIp)

pszIp++;

while ((*pszEnd >= '0' && *pszEnd <= '9') || *pszEnd == '.')

pszEnd++;

*pszEnd = NULL;

#define MT_NETLIBHTTPHEADERS "NETLIBHTTPHEADERS"

{

request->flags = NLHRF_HTTP11 | NLHRF_NODUMP;

return request;

}

{

request->flags |= NLHRF_SSL;

else

request->flags &= ~(NLHRF_SSL);

}

/***********************************************/

#define MT_NETLIBHTTPCONTENT "NETLIBHTTPCONTENT"

#define MT_NETLIBHTTPRESPONSE "NETLIBHTTPRESPONSE"

{

*udata = response;

luaL_setmetatable(L, MT_NETLIBHTTPRESPONSE);

return response;

static int response__index(lua_State *L)

{

const char *key = lua_tostring(L, 2);

if (mir_strcmpi(key, "IsSuccess") == 0) {

}

if (mir_strcmpi(key, "StatusCode") == 0)

lua_pushinteger(L, response->resultCode);

NETLIBHTTPHEADERS *headers = (NETLIBHTTPHEADERS*)lua_newuserdata(L, sizeof(NETLIBHTTPHEADERS));

headers->headers = response->headers;

headers->count = response->headersCount;

luaL_setmetatable(L, MT_NETLIBHTTPHEADERS);

else if (mir_strcmpi(key, "Content") == 0) {

NETLIBHTTPCONTENT *content = (NETLIBHTTPCONTENT*)lua_newuserdata(L, sizeof(NETLIBHTTPCONTENT));

luaL_setmetatable(L, MT_NETLIBHTTPCONTENT);

}

else

static int response__gc(lua_State *L)

{

Netlib_FreeHttpRequest(*response);

return 0;

}

int threadRef;

int callbackRef;

};

static void __cdecl SendHttpRequestThread(HttpRequestParam *param)

luaL_unref(param->L, LUA_REGISTRYINDEX, param->callbackRef);

luaL_unref(param->L, LUA_REGISTRYINDEX, param->threadRef);

delete param;

}

{

HttpRequestParam *param = new HttpRequestParam();

param->request = request;

/***********************************************/

static const char *httpMethods[] = { "GET", "POST", "PUT", "DELETE", nullptr };

static int request_SetMethod(lua_State *L)

{

request->requestType = (1 << (luaL_checkoption(L, 2, nullptr, httpMethods)));

lua_pushvalue(L, 1);

return 1;

static int request_SetUrl(lua_State *L)

{

const char *url = luaL_checkstring(L, 2);

SetUrl(request, url);

static int request_SetHeaders(lua_State *L)

{

luaL_checktype(L, 2, LUA_TTABLE);

for (lua_pushnil(L); lua_next(L, 2); lua_pop(L, 1)) {

const char *name = lua_tostring(L, -2);

const char *value = lua_tostring(L, -1);

}

lua_pushvalue(L, 1);

static int request_SetContent(lua_State *L)

{

switch (lua_type(L, 2)) {

case LUA_TNONE:

case LUA_TNIL:

break;

case LUA_TSTRING:

break;

case LUA_TTABLE:

}

break;

default:

luaL_argerror(L, 2, luaL_typename(L, 2));

}

static int request_SetContentType(lua_State *L)

{

if (!lua_isstring(L, 2)) {

lua_pushvalue(L, 1);

return 1;

}

const char *type = lua_tostring(L, 2);

lua_pushvalue(L, 1);

return 1;

static int request_SetTimeout(lua_State *L)

{

request->timeout = luaL_optinteger(L, -1, 0);

lua_pushvalue(L, 1);

return 1;

static int request_Send(lua_State *L)

{

newRequest->flags = request->flags;

newRequest->requestType = request->requestType;

newRequest->timeout = request->timeout;

if (lua_isfunction(L, 2)) {

SendRequestAsync(L, 2, newRequest);

}

response_Create(L, newRequest);

return 1;

}

static int request__gc(lua_State *L)

{

return 0;

}

static int http_Request(lua_State *L)

{

*udata = request;

request->requestType = (1 << (luaL_checkoption(L, 1, nullptr, httpMethods)));

SetUrl(request, luaL_checkstring(L, 2));

static int http_Get(lua_State *L)

{

request->requestType = REQUEST_GET;

const char *url = luaL_checkstring(L, 1);

}

response_Create(L, request);

return 1;

}

static int http_Post(lua_State *L)

{

request->requestType = REQUEST_POST;

const char *url = luaL_checkstring(L, 1);

}

response_Create(L, request);

return 1;

}

static int http_Put(lua_State *L)

{

request->requestType = REQUEST_PUT;

const char *url = luaL_checkstring(L, 1);

}

response_Create(L, request);

return 1;

}

static int http_Delete(lua_State *L)

{

request->requestType = REQUEST_DELETE;

const char *url = luaL_checkstring(L, 1);

luaL_setfuncs(L, responseApi, 0);

lua_pop(L, 1);

luaL_newmetatable(L, MT_NETLIBHTTPCONTENT);

luaL_setfuncs(L, contentApi, 0);

BOOL DownloadFile(LPCTSTR tszURL, LPCTSTR tszLocal)

{

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_REDIRECT | NLHRF_DUMPASTEXT | NLHRF_HTTP11;

bool ret = false;

NLHR_PTR pReply(Netlib_HttpTransaction(hNetlibUser, &nlhr));

if (pReply) {

HANDLE hFile = CreateFile(tszLocal, GENERIC_READ | GENERIC_WRITE, NULL, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);

DWORD dwBytes;

ret = true;

if (hFile)

CloseHandle(hFile);

}

}

DlgDld = ret;

return ret;

}

WideCharToMultiByte(CP_UTF8, 0, content.c_str(), -1, contentBytes, cbLen, nullptr, nullptr);

--cbLen;

nlhr.requestType = REQUEST_POST;

nlhr.flags = NLHRF_NODUMPSEND | NLHRF_DUMPASTEXT | NLHPIF_HTTP11;

char *resCont = nullptr;

NLHR_PTR nlhrReply(Netlib_HttpTransaction(g_hNetlibUser, &nlhr));

mir_free(contentBytes);

return resCont;

#endif

szUserAgent.Append(")");

ptrA szUrl(mir_u2a(pFileURL->wszDownloadURL));

nlhr.flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11 | NLHRF_PERSISTENT;

nlhr.requestType = REQUEST_GET;

nlhr.nlc = nlc;

for (int i = 0; i < MAX_RETRIES; i++) {

Netlib_LogfW(g_hNetlibUser, L"Downloading file %s to %s (attempt %d)", pFileURL->wszDownloadURL, pFileURL->wszDiskPath, i + 1);

}

nlc = pReply->nlc;

Netlib_LogfW(g_hNetlibUser, L"Downloading file %s failed with error %d", pFileURL->wszDownloadURL, pReply->resultCode);

return pReply->resultCode;

}

// Check CRC sum

if (pFileURL->CRCsum) {

if (crc != pFileURL->CRCsum) {

// crc check failed, try again

Netlib_LogfW(g_hNetlibUser, L"crc check failed for file %s", pFileURL->wszDiskPath);

HANDLE hFile = CreateFile(pFileURL->wszDiskPath, GENERIC_READ | GENERIC_WRITE, NULL, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);

if (hFile != INVALID_HANDLE_VALUE) {

// write the downloaded file directly

CloseHandle(hFile);

}

else {

mir_snwprintf(wszTempFile, L"%s\\pulocal.tmp", g_wszTempPath);

hFile = CreateFile(wszTempFile, GENERIC_READ | GENERIC_WRITE, NULL, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);

if (hFile != INVALID_HANDLE_VALUE) {

CloseHandle(hFile);

PU::SafeMoveFile(wszTempFile, pFileURL->wszDiskPath);

}

return begin;

}

{

char boundary[16];

{

union

{

}

nlhr->requestType = requestType;

nlhr->flags = NLHRF_HTTP11;

for (HTTPFormData* iter = frm, *end = frm + frmNum; iter != end; ++iter) {

}

if (!filename) filename = strrchr(iter->value_str, '/');

if (!filename) filename = iter->value_str;

else ++filename;

/// add mime type

if (fileext) {

if (!mir_strcmp(fileext, ".jpg") || !mir_strcmp(fileext, ".jpeg") || !mir_strcmp(fileext, ".jpe"))

mime = "image/jpeg";

else if (!mir_strcmp(fileext, ".tif") || !mir_strcmp(fileext, ".tiff"))

mime = "image/tiff";

}

/// add file content

size_t filesize = 0;

if (fp) {

fseek(fp, 0, SEEK_END);

filesize = ftell(fp); fseek(fp, 0, SEEK_SET);

fclose(fp), fp = nullptr;

}

}

if (!fp) {

Error(L"Error occurred when opening local file.\nAborting file upload...");

Exit(ACKRESULT_FAILED);

return 1;

}

}

}

}

else {

}

}

return 0;

}

};

static const char* GetHTMLContent(char* str, const char* startTag, const char* endTag); // changes "str", can be successfully used only once

};

#endif

{

// send DATA and wait for m_nlreply

NLHR_PTR reply(Netlib_HttpTransaction(g_hNetlibUser, &m_nlhr));

if (reply) {

const char* url = nullptr;

if (url && *url) {

m_URLthumb = m_URL = url;

return;

}

wchar_t* err = nullptr;

if (url) err = mir_a2u(url);

if (!err || !*err) { // fallback to server response mess

mir_free(err);

}

Error(L"%s", err);

mir_free(err);

}

else Error(SS_ERR_RESPONSE, m_pszSendTyp, reply->resultCode);

}

Exit(ACKRESULT_FAILED);

}

int Send() override;

protected:

void SendThread();

static void SendThreadWrapper(void * Obj);

*/

#include "stdafx.h"

{

m_EnableItem = SS_DLG_DESCRIPTION | SS_DLG_AUTOSEND | SS_DLG_DELETEAFTERSSEND;

m_pszSendTyp = LPGENW("Image upload");

CSendHost_Imgur *self = (CSendHost_Imgur*)obj;

// send DATA and wait for m_nlreply

NLHR_PTR reply(Netlib_HttpTransaction(g_hNetlibUser, &self->m_nlhr));

if (reply) {

if (root) {

if ((*root)["success"].as_bool()) {

self->m_URL = (*root)["data"]["link"].as_mstring();

}

else self->Error(SS_ERR_RESPONSE, self->m_pszSendTyp, reply->resultCode);

}

self->Exit(ACKRESULT_FAILED);

}

int Send() override;

protected:

static void SendThread(void* obj);

};

#endif

CSendHost_UploadPie* self = (CSendHost_UploadPie*)obj;

// send DATA and wait for m_nlreply

NLHR_PTR reply(Netlib_HttpTransaction(g_hNetlibUser, &self->m_nlhr));

if (reply) {

do {

char* pos;

if ((url = strstr(url, kHostURL))) {

self->svcSendMsgExit(url); return;

}

else { // check error mess from server

wchar_t* werr;

if (err) werr = mir_a2u(err);

self->Error(L"%s", werr);

mir_free(werr);

}

}

else self->Error(SS_ERR_RESPONSE, self->m_pszSendTyp, reply->resultCode);

}

self->Exit(ACKRESULT_FAILED);

}

protected:

int m_expire;

static void SendThread(void* obj);

};

#endif

bool InternetDownloadFile(const char *szUrl, char *szDest, HNETLIBCONN &hHttpDwnl)

{

int result = 0xBADBAD;

// initialize the netlib request

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_NODUMP | NLHRF_HTTP11 | NLHRF_PERSISTENT | NLHRF_REDIRECT;

nlhr.nlc = hHttpDwnl;

// change the header so the plugin is pretended to be IE 6 + WinXP

while (result == 0xBADBAD) {

// download the page

int res = -1;

int fh = _open(szDest, _O_BINARY | _O_WRONLY | _O_CREAT, _S_IREAD | _S_IWRITE);

if (fh != -1) {

_close(fh);

}

if (res < 0)

else

result = 0;

}

else result = 1;

}

else {

}

}

return result == 0;

}

return;

}

if (root.empty()) {

Netlib_Logf(m_hConnection, "%s: %s", GetAccountName(), HttpStatusToError(response->resultCode));

ShowNotification(TranslateT("Server does not respond"), MB_ICONERROR);

if (!response || response->resultCode != HTTP_CODE_CONFLICT)

HttpResponseToError(response);

if (root.isnull())

throw Exception(HttpStatusToError());

NLHR_PTR response(request.Send(m_hConnection));

if (response == nullptr || response->resultCode != HTTP_CODE_OK) {

: HttpStatusToError(response ? response->resultCode : 0);

Netlib_Logf(m_hConnection, "%s: %s", GetAccountName(), error);

return;

}

if (root.empty()) {

Netlib_Logf(m_hConnection, "%s: %s", GetAccountName(), HttpStatusToError(response->resultCode));

ShowNotification(TranslateT("Server does not respond"), MB_ICONERROR);

HandleHttpError(response);

if (HTTP_CODE_SUCCESS(response->resultCode))

return std::string(pszHdr);

HttpResponseToError(response);

NLHR_PTR response(request.Send(m_hConnection));

if (response == nullptr || response->resultCode != HTTP_CODE_OK) {

: HttpStatusToError(response->resultCode);

Netlib_Logf(m_hConnection, "%s: %s", GetAccountName(), error);

return;

}

if (root.empty()) {

Netlib_Logf(m_hConnection, "%s: %s", GetAccountName(), HttpStatusToError(response->resultCode));

ShowNotification(TranslateT("Server does not respond"), MB_ICONERROR);

NLHR_PTR response(request.Send(m_hConnection));

if (response == nullptr || response->resultCode != HTTP_CODE_OK) {

: HttpStatusToError(response->resultCode);

Netlib_Logf(m_hConnection, "%s: %s", GetAccountName(), error);

return;

}

if (root.empty()) {

Netlib_Logf(m_hConnection, "%s: %s", GetAccountName(), HttpStatusToError(response->resultCode));

ShowNotification(TranslateT("Server does not respond"), MB_ICONERROR);

return "Unknown error";

}

{

if (response == nullptr)

throw Exception(HttpStatusToError());

throw Exception(HttpStatusToError(response->resultCode));

}

{

if (response == nullptr)

throw Exception(HttpStatusToError());

HttpResponseToError(response);

}

{

HandleHttpError(response);

if (root.isnull())

throw Exception(HttpStatusToError());

std::string PreparePath(const std::string &path) const;

virtual char* HttpStatusToError(int status = 0);

virtual void HandleJsonError(JSONNode &node) = 0;

// events

void OnModulesLoaded() override;

MWindow OnCreateAccMgrUI(MWindow) override;

virtual void Upload(FileTransferParam *ftp) = 0;

}

};

{

private:

CMStringA m_szUrl;

{

requestType = type;

flags = NLHRF_HTTP11 | NLHRF_SSL | NLHRF_NODUMP;

nlc = NULL;

timeout = 0;

}

protected:

void AddBasicAuthHeader(LPCSTR szLogin, LPCSTR szPassword)

{

size_t length = mir_strlen(szLogin) + mir_strlen(szPassword) + 1;

szPassword);

ptrA ePair(mir_base64_encode(cPair, length));

}

void AddBearerAuthHeader(LPCSTR szValue)

{

}

void AddOAuthHeader(LPCSTR szValue)

{

}

void AddUrlParameter(const char *urlFormat, ...)

va_end(valueArgs);

}

public:

HttpRequest(int type, LPCSTR url)

{

m_szUrl = url;

}

{

Init(type);

va_end(formatArgs);

}

{

m_szUrl.Replace('\\', '/');

return Netlib_HttpTransaction(hConnection, this);

}

};

show_popup(g_pCurrentProvider, 0, -1, TranslateW(ERROR_MSG));

}

bool CHTTPSession::OpenURL(const CMStringW &rsURL)

{

m_szUrl = rsURL;

if (m_szUrl.IsEmpty())

return false;

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11 | NLHRF_REDIRECT;

bool bResult = false;

NLHR_PTR pReply(0);

}

if (pReply) {

else

bResult = true;

}

/////////////////////////////////////////////////////////////////////////////////////////

{

PROTO_AVATAR_INFORMATION ai = { 0 };

ai.format = PA_FORMAT_UNKNOWN;

return;

}

ai.format = ProtoGetAvatarFormatByMimeType(pszHdr);

if (ai.format == PA_FORMAT_UNKNOWN) {

goto LBL_Error;

}

fclose(out);

if (ai.hContact)

{

CMStringA str;

if (!pReq->m_szParam.IsEmpty()) {

if (pReq->requestType == REQUEST_GET) {

str.Format("%s?%s", pReq->m_szUrl.c_str(), pReq->m_szParam.c_str());

}

}

}

bool bRetryable = pReq->nlc != nullptr;

LBL_Retry:

NLHR_PTR reply(Netlib_HttpTransaction(m_hNetlibUser, pReq));

bool CDiscordProto::GatewayThreadWorker()

{

if (!m_szWSCookie.IsEmpty()) {

}

if (pReply == nullptr) {

debugLogA("Gateway connection failed, exiting");

return false;

if (pReply->resultCode != 101) {

// if there's no cookie & Miranda is bounced with error 404, simply apply the cookie and try again

if (pReply->resultCode == 404) {

return true;

m_szWSCookie.Empty(); // don't use the same cookie twice

if (pRoot != nullptr) {

ptrW text(json_write(pRoot));

AddHeader("Content-Type", "application/json");

}

m_iReqNum = ::InterlockedIncrement(&g_reqNum);

}

{

if (pReply == nullptr) {

m_errorCode = 500;

m_errorCode = pReply->resultCode;

if (m_root == nullptr)

m_errorCode = 500;

}

/////////////////////////////////////////////////////////////////////////////////////////

// Basic search - by SnowFlake

{

JsonReply root(pReply);

if (!root) {

////////////////////////////////////////////////////////////////////////////////////////

// SendMsg

{

JsonReply root(pReply);

if (!root) {

/////////////////////////////////////////////////////////////////////////////////////////

{

JsonReply root(pReply);

if (root)

szBoundary.Insert(0, "\r\n");

szBoundary.Append("--\r\n");

fclose(in);

if (cbBytes != cbRead) {

debugLogA("cannot read file %S: %d bytes read instead of %d", p->wszFileName.c_str(), cbRead, cbBytes);

goto LBL_Error;

}

pReq->pUserInfo = p;

Push(pReq);

ProtoBroadcastAck(p->hContact, ACKTYPE_FILE, ACKRESULT_CONNECTED, param);

}

{

SendFileThreadParam *p = (SendFileThreadParam*)pReq->pUserInfo;

if (pReply->resultCode != 200) {

int m_errorCode = 0;

public:

~JsonReply();

__forceinline int error() const { return m_errorCode; }

void OnLoggedIn();

void OnLoggedOut();

void RetrieveMyInfo();

void RetrieveHistory(CDiscordUser *pUser, CDiscordHistoryOp iOp = MSG_NOFILTER, SnowFlake msgid = 0, int iLimit = 50);

bool RetrieveAvatar(MCONTACT hContact);

//////////////////////////////////////////////////////////////////////////////////////

// Misc

return wcscmp((*p1)["id"].as_mstring(), (*p2)["id"].as_mstring());

}

{

CDiscordUser *pUser = (CDiscordUser*)pReq->pUserInfo;

Push(new AsyncHttpRequest(this, REQUEST_GET, "/users/@me", &CDiscordProto::OnReceiveMyInfo));

}

{

JsonReply root(pReply);

if (!root) {

/////////////////////////////////////////////////////////////////////////////////////////

// finds a gateway address

{

JsonReply root(pReply);

if (!root) {

/////////////////////////////////////////////////////////////////////////////////////////

// logs a session out

{

delSetting("AccessToken");

}

/////////////////////////////////////////////////////////////////////////////////////////

// channels

{

JsonReply root(pReply);

if (root)

/////////////////////////////////////////////////////////////////////////////////////////

{

JsonReply root(pReply);

if (!root)

#define RECAPTCHA_API_KEY "6Lef5iQTAAAAAKeIvIY-DeexoO3gj7ryl9rLMEnn"

#define RECAPTCHA_SITE_URL "https://discord.com"

{

if (pReply->resultCode != 200) {

if (root) {

const JSONNode &captcha = root["captcha_key"].as_array();

if (captcha) {

void __cdecl FacebookProto::AvatarsUpdate(void *)

{

req.flags = NLHRF_NODUMP | NLHRF_SSL | NLHRF_HTTP11 | NLHRF_REDIRECT;

req.requestType = REQUEST_GET;

continue;

delSetting(cc, "UpdateNeeded");

NLHR_PTR pReply(Netlib_HttpTransaction(m_hNetlibUser, &req));

if (pReply == nullptr) {

continue;

}

GetAvatarFilename(cc, ai.filename);

bool bSuccess = false;

ai.format = ProtoGetAvatarFormatByMimeType(pszHdr);

if (ai.format != PA_FORMAT_UNKNOWN) {

FILE *fout = _wfopen(ai.filename, L"wb");

if (fout) {

fclose(fout);

bSuccess = true;

}

}

else debugLogA("unknown avatar mime type");

}

ProtoBroadcastAck(cc, ACKTYPE_AVATAR, bSuccess ? ACKRESULT_SUCCESS : ACKRESULT_FAILED, &ai);

}

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pReply == nullptr) {

m_errorCode = 500;

if (m_errorCode != 200)

return;

if (m_root == nullptr) {

m_errorCode = 500;

return;

/////////////////////////////////////////////////////////////////////////////////////////

{

AsyncHttpRequest *pReq = new AsyncHttpRequest();

pReq->requestType = REQUEST_POST;

pReq << CHAR_PARAM("api_key", FB_API_KEY)

<< CHAR_PARAM("device_id", m_szDeviceID)

return pReq;

}

{

pReq->flags |= NLHRF_HTTP11;

delete pReq;

return reply;

}

int m_errorCode = 0;

public:

~JsonReply();

__forceinline JSONNode &data() const { return *m_root; }

AsyncHttpRequest *CreateRequest(const char *szUrl, const char *szName, const char *szMethod);

AsyncHttpRequest *CreateRequestGQL(int64_t id);

CMStringA GetAgentString();

// Avatars

// wszFileName.Format(L"%s\\STK{%S}.webp", wszPath.c_str(), stickerId.c_str());

std::string szUrl = sticker["thread_image"]["uri"].as_string();

req.flags = NLHRF_NODUMP | NLHRF_SSL | NLHRF_HTTP11 | NLHRF_REDIRECT;

req.requestType = REQUEST_GET;

bSuccess = true;

FILE *out = _wfopen(wszFileName, L"wb");

fclose(out);

}

}

char szUrl[128];

mir_snprintf(szUrl, "http://api.gadu-gadu.pl/avatars/%d/0.xml", uin);

req.requestType = REQUEST_GET;

req.flags = NLHRF_NODUMP | NLHRF_HTTP11 | NLHRF_REDIRECT;

NLHR_PTR resp(Netlib_HttpTransaction(m_hNetlibUser, &req));

return false;

}

debugLogA("getAvatarFileInfo(): Invalid response code from HTTP request");

return false;

}

// if this url returned xml data (before and after 11.2013 gg convention)

TiXmlDocument doc;

auto *node = TiXmlConst(doc.FirstChildElement("result"))["users"]["user"]["avatars"]["avatar"].ToElement();

const char *blank = (node != nullptr) ? node->Attribute("blank") : nullptr;

if (mir_strcmp(blank, "1")) {

}

}

}

// if this url returns json data (11.2013 gg convention)

if (root) {

const JSONNode &respJSONavatars = root["result"].at("users").at("user").at("avatars");

if (respJSONavatars) {

ai.hContact = data->hContact;

ai.format = getByte(ai.hContact, GG_KEY_AVATARTYPE, GG_KEYDEF_AVATARTYPE);

req.requestType = REQUEST_GET;

req.flags = NLHRF_NODUMP | NLHRF_HTTP11 | NLHRF_REDIRECT;

NLHR_PTR resp(Netlib_HttpTransaction(m_hNetlibUser, &req));

if (resp) {

int file_fd;

int avatarType = PA_FORMAT_UNKNOWN;

setByte(data->hContact, GG_KEY_AVATARTYPE, (uint8_t)avatarType);

getAvatarFilename(ai.hContact, ai.filename, _countof(ai.filename));

file_fd = _wopen(ai.filename, _O_WRONLY | _O_TRUNC | _O_BINARY | _O_CREAT, _S_IREAD | _S_IWRITE);

if (file_fd != -1) {

_close(file_fd);

result = 1;

debugLogW(L"avatarrequestthread() new avatar_transfers item. Saved data to file=%s.", ai.filename);

CMStringA avatarFileB64Enc(mir_urlEncode(avatarFileB64));

oauth_checktoken(0);

char* token = getStringA(GG_KEY_TOKEN);

req.requestType = REQUEST_POST;

req.flags = NLHRF_NODUMP | NLHRF_HTTP11;

// send request

int resultSuccess = 0;

{

NLHR_PTR resp(Netlib_HttpTransaction(m_hNetlibUser, &req));

if (resp) {

resultSuccess = 1;

}

else {

oauth_checktoken(1);

mir_free(token);

token = getStringA(GG_KEY_TOKEN);

NLHR_PTR resp(Netlib_HttpTransaction(m_hNetlibUser, &req));

if (resp) {

resultSuccess = 1;

}

else debugLogA("setavatarthread(): Invalid response code from HTTP request [%d]", resp->resultCode);

//clean and end thread

mir_free(token);

if (resultSuccess) {

debugLogA("setavatarthread(): User avatar set successfully.");

int GaduProto::oauth_receivetoken()

{

int res = 0;

HNETLIBCONN nlc = nullptr;

// 1. Obtaining an Unauthorized Request Token

debugLogA("oauth_receivetoken(): Obtaining an Unauthorized Request Token...");

}

}

}

// 2. Obtaining User Authorization

debugLogA("oauth_receivetoken(): Obtaining User Authorization...");

// 3. Obtaining an Access Token

debugLogA("oauth_receivetoken(): Obtaining an Access Token...");

mir_free(token);

mir_free(token_secret);

token = nullptr;

token_secret = nullptr;

}

}

mir_free(password);

if (token != nullptr && token_secret != nullptr) {

setString(GG_KEY_TOKEN, token);

szBody.Append("&password=");

szBody.Append(curAcc->pass);

if (nlu == nullptr || nlu->resultCode != 200) {

mir_strcpy(curAcc->results.content, Translate("Can't send account data!"));

else

szUrl.Append("/mail/feed/atom");

if (nlu == nullptr) {

curAcc->results_num = -1;

}

else {

mir_snprintf(curAcc->results.content, "%s [%d]", szNick.get(), curAcc->results_num);

}

}

unsigned dwSize = (unsigned)_filelengthi64(fileId);

_close(fileId);

if (iAvatarType == PA_FORMAT_UNKNOWN) {

delete pReq;

return 3;

}

pReq->AddHeader("Content-Range", CMStringA(FORMAT, "bytes %lld-%lld/%lld", pfts.currentFileProgress, pfts.currentFileProgress + dwPortion - 1, pfts.currentFileSize));

pReq->AddHeader("Content-Length", CMStringA(FORMAT, "%d", dwPortion));

_lseek(m_fileId, pfts.currentFileProgress, SEEK_SET);

pfts.currentFileProgress += dwPortion;

pfts.totalProgress += dwPortion;

/////////////////////////////////////////////////////////////////////////////////////////

{

RobustReply root(pReply);

if (root.error() != 20000)

dlg.DoModal();

}

{

db_delete_contact(INT_PTR(pReq->pUserInfo));

}

strncpy_s(m_reqId, (char*)szId, _TRUNCATE);

RpcStringFreeA(&szId);

AddHeader("Content-Type", "application/x-www-form-urlencoded");

}

void AsyncHttpRequest::ReplaceJsonParam(const JSONNode &n)

else

root.push_back(n);

m_szParam = root.write().c_str();

}

bool CIcqProto::ExecuteRequest(AsyncHttpRequest *pReq)

{

// replace credentials inside JSON body for pure RAPI requests

CMStringA szAgent(FORMAT, "%S Mail.ru Windows ICQ (version 10.0.1999)", (wchar_t*)m_szOwnId);

pReq->AddHeader("User-Agent", szAgent);

pReq->AddHeader("Content-Type", "application/json");

if (m_iRClientId)

pReq->ReplaceJsonParam(JSONNode("clientId", m_iRClientId));

pReq->ReplaceJsonParam(JSONNode("authToken", m_szRToken));

}

if (pReq->m_conn != CONN_NONE) {

pReq->flags |= NLHRF_PERSISTENT;

auto &conn = m_ConnPool[pReq->m_conn];

conn.s = reply->nlc;

conn.timeout = 0;

int timeout;

if (1 == sscanf(pszHdr, "timeout=%d", &timeout))

conn.timeout = timeout;

}

}

RobustReply r(reply);

if (r.error() == 40201) { // robust token expired

m_szRToken.Empty();

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pReply == nullptr) {

m_errorCode = 500;

if (m_errorCode != 200)

return;

if (m_root == nullptr) {

m_errorCode = 500;

return;

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pReply == nullptr) {

m_errorCode = 500;

if (m_errorCode != 200)

return;

if (m_root == nullptr) {

m_errorCode = 500;

return;

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pReply == nullptr) {

m_errorCode = 500;

if (m_errorCode != 200)

return;

if (m_root == nullptr) {

m_errorCode = 500;

return;

CMStringA m_requestId;

public:

~JsonReply();

__forceinline const CMStringA& requestId() const { return m_requestId; }

JSONNode* m_data = nullptr;

public:

~FileReply();

__forceinline JSONNode& data() const { return *m_data; }

JSONNode *m_results = nullptr;

public:

~RobustReply();

__forceinline JSONNode &result() const { return *m_result; }

Push(new AsyncHttpRequest(CONN_MAIN, REQUEST_GET, "/preference/getPermitDeny", &CIcqProto::OnGetPermitDeny) << AIMSID(this));

}

{

JsonReply root(pReply);

if (root.error() == 200)

#include "stdafx.h"

{

m_szMraCookie = pReply->GetCookies();

Push(pReq);

}

{

JsonReply root(pReply);

switch (root.error()) {

StartSession();

}

{

JsonReply root(pReply);

switch (root.error()) {

}

}

{

switch (pReply->resultCode) {

case 200:

}

};

{

if (pReply == nullptr || pReply->resultCode != 200)

return;

pDlg->btnSendSms.Disable();

pDlg->edtCode.Disable();

CMStringW wszStatus((*root)["status"].as_mstring());

if (wszStatus != L"OK") {

pDlg->edtCode.SetText((*root)["printable"].as_mstring());

Push(pNew);

}

{

CIcqRegistrationDlg *pDlg = (CIcqRegistrationDlg*)pReq->pUserInfo;

pDlg->btnSendSms.Enable();

}

{

JsonReply root(pReply);

if (root.error() != 200)

pDlg->edtCode.SetText(L"");

}

{

CIcqRegistrationDlg *pDlg = (CIcqRegistrationDlg*)pReq->pUserInfo;

}

}

{

JsonReply root(pReply);

if (root.error() != 200) {

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pReply->resultCode != 200)

return;

return;

}

_close(fileId);

return;

}

void RetrieveUserCaps(IcqUser *pUser);

void RetrieveUserHistory(MCONTACT, __int64 startMsgId, bool bCreateRead);

void RetrieveUserInfo(MCONTACT hContact);

void SendMessageParts(MCONTACT hContact, const JSONNode &parts, IcqOwnMessage *pOwn = nullptr);

void SetOwnId(const CMStringW &wszId);

void SetServerStatus(int iNewStatus);

__int64 getId(MCONTACT hContact, const char *szSetting);

void setId(MCONTACT hContact, const char *szSetting, __int64 iValue);

void ProcessBuddyList(const JSONNode &pRoot);

void ProcessDiff(const JSONNode &pRoot);

/////////////////////////////////////////////////////////////////////////////////////////

{

IcqFileInfo **res = (IcqFileInfo **)pReq->pUserInfo;

*res = nullptr;

/////////////////////////////////////////////////////////////////////////////////////////

{

JsonReply root(pReply);

if (root.error() != 200)

/////////////////////////////////////////////////////////////////////////////////////////

{

JsonReply root(pReply);

if (root.error() != 200)

/////////////////////////////////////////////////////////////////////////////////////////

{

RobustReply root(pReply);

if (root.error() != 20000) {

/////////////////////////////////////////////////////////////////////////////////////////

{

RobustReply root(pReply);

if (root.error() != 20000)

/////////////////////////////////////////////////////////////////////////////////////////

{

RobustReply root(pReply);

if (root.error() != 20000)

/////////////////////////////////////////////////////////////////////////////////////////

{

JsonReply root(pReply);

if (root.error() != 200)

}

}

{

bool *pRet = (bool*)pReq->pUserInfo;

*pRet = true;

}

{

JsonReply root(pReply);

switch (root.error()) {

StartSession();

}

{

IcqFileTransfer *pTransfer = (IcqFileTransfer*)pOld->pUserInfo;

if (pTransfer->m_bCanceled) {

ProtoBroadcastAck(pTransfer->pfts.hContact, ACKTYPE_FILE, ACKRESULT_DATA, pTransfer, (LPARAM)&pTransfer->pfts);

}

{

IcqFileTransfer *pTransfer = (IcqFileTransfer*)pOld->pUserInfo;

if (pTransfer->m_bCanceled) {

/////////////////////////////////////////////////////////////////////////////////////////

// Support for stickers

{

if (pReply->resultCode != 200) {

debugLogA("Error getting sticker: %d", pReply->resultCode);

CMStringW wszFileName(FORMAT, L"%s\\STK{%s}.png", wszPath.c_str(), (wchar_t*)pReq->pUserInfo);

FILE *out = _wfopen(wszFileName, L"wb");

fclose(out);

SmileyAdd_LoadContactSmileys(SMADD_FILE, m_szModuleName, wszFileName);

/////////////////////////////////////////////////////////////////////////////////////////

{

RobustReply root(pReply);

if (root.error() != 20000)

m_szRToken = results["authToken"].as_mstring();

}

{

JsonReply root(pReply);

switch (root.error()) {

ForkThread(&CIcqProto::PollThread);

}

{

PROTO_AVATAR_INFORMATION ai = {};

ai.hContact = pReq->hContact;

LBL_Error:

ProtoBroadcastAck(pReq->hContact, ACKTYPE_AVATAR, ACKRESULT_FAILED, &ai);

return;

}

if (szContentType == nullptr)

szContentType = "image/jpeg";

if (out == nullptr)

goto LBL_Error;

fclose(out);

if (pReq->hContact != 0) {

else ReportSelfAvatarChanged();

}

{

RobustReply root(pReply);

if (root.error() != 20000) {

/////////////////////////////////////////////////////////////////////////////////////////

// Send message

{

IcqOwnMessage *ownMsg = (IcqOwnMessage *)pReq->pUserInfo;

/////////////////////////////////////////////////////////////////////////////////////////

{

JsonReply root(pReply);

if (root.error() == 200) {

}

// initialize the netlib request

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_HTTP11 | NLHRF_DUMPASTEXT | NLHRF_REDIRECT;

// download the page

NLHR_PTR nlhrReply(Netlib_HttpTransaction(m_hNetlibUser, &nlhr));

size_t written = 0;

if (f) {

if (encrypted) {

if (payload_len > 0) {

uint8_t ivkey[44];

hex2bin(hexkey, ivkey, 44);

EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, 12, NULL);

EVP_DecryptInit(ctx, EVP_aes_256_gcm(), ivkey + 12, ivkey);

int outl = 0, round_len = 0;

uint8_t *out = (uint8_t *)mir_alloc(payload_len);

int dec_success = EVP_DecryptFinal(ctx, out + outl, &round_len);

outl += round_len;

EVP_CIPHER_CTX_free(ctx);

mir_free(out);

}

}

fclose(f);

}

void __cdecl CJabberProto::FileReceiveHttpThread(filetransfer *ft)

{

req.requestType = REQUEST_GET;

NLHR_PTR pResp(Netlib_HttpTransaction(m_hNetlibUser, &req));

if (pResp && pResp->resultCode == 200) {

ProtoBroadcastAck(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_INITIALISING, ft);

ft->complete();

}

szName.AppendChar(*b++);

auto *pszName = szName.c_str();

req.requestType = REQUEST_HEAD;

filetransfer *ft = new filetransfer(this, 0);

ft->jid = mir_strdup(jid);

if (!szUrl)

goto LBL_Fail;

nlhr.requestType = REQUEST_PUT;

nlhr.flags = NLHRF_NODUMPSEND | NLHRF_SSL | NLHRF_REDIRECT;

for (auto *it : TiXmlFilter(putNode, "header")) {

auto *szName = it->Attribute("name");

auto *szValue = it->GetText();

}

const wchar_t *pwszFileName = ft->std.pszFiles.w[ft->std.currentFileNumber];

EVP_EncryptInit(ctx, EVP_aes_256_gcm(), key, iv);

int tmp_len = 0, outl;

unsigned char *in = (unsigned char *)mir_alloc(128 * 1024);

for (;;) {

int inl = _read(fileId, in, 128 * 1024);

EVP_CIPHER_CTX_free(ctx);

memcpy(out + tmp_len, tag, _countof(tag));

}

else {

}

_close(fileId);

OBJLIST<JABBER_HTTP_AVATARS> &avs = *(OBJLIST<JABBER_HTTP_AVATARS>*)param;

HNETLIBCONN hHttpCon = nullptr;

for (auto &it : avs) {

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_HTTP11 | NLHRF_REDIRECT | NLHRF_PERSISTENT;

nlhr.nlc = hHttpCon;

NLHR_PTR res(Netlib_HttpTransaction(m_hNetlibUser, &nlhr));

if (res) {

hHttpCon = res->nlc;

if (pictureType != PA_FORMAT_UNKNOWN) {

PROTO_AVATAR_INFORMATION ai;

ai.format = pictureType;

uint8_t digest[MIR_SHA1_HASH_SIZE];

mir_sha1_ctx sha;

mir_sha1_init(&sha);

mir_sha1_finish(&sha, digest);

bin2hex(digest, sizeof(digest), buffer);

wcsncpy_s(ai.filename, tszFileName, _TRUNCATE);

FILE* out = _wfopen(tszFileName, L"wb");

if (out != nullptr) {

fclose(out);

setString(ai.hContact, "AvatarHash", buffer);

ProtoBroadcastAck(ai.hContact, ACKTYPE_AVATAR, ACKRESULT_SUCCESS, &ai);

#include "stdafx.h"

{

// Prepare the request

// FIXME: get server

// Set request URL

std::string url = m_server + chooseAction(request_type, get_data);

// Set timeout (bigger for channel request)

nlhr.timeout = 1000 * ((request_type == MINECRAFTDYNMAP_REQUEST_EVENTS) ? 65 : 20);

// Set request type (GET/POST) and eventually also POST data

if (post_data != nullptr) {

nlhr.requestType = REQUEST_POST;

}

// Set headers - it depends on requestType so it must be after setting that

// Set flags

nlhr.flags = NLHRF_HTTP11;

break;

}

// Send the request

// Remember the persistent connection handle (or not)

switch (request_type) {

break;

}

}

//////////////////////////////////////////////////////////////////////////////

}

}

//////////////////////////////////////////////////////////////////////////////

bool MinecraftDynmapProto::doSignOn()

{

handleEntry(__FUNCTION__);

return handleError(__FUNCTION__, "Can't load configuration", true);

if (!root)

return false;

m_updateRate = rate_.as_int();

m_cookie.clear();

const char *findStr = "JSESSIONID=";

}

if (m_cookie.empty()) {

handleEntry(__FUNCTION__);

// Get update

return handleError(__FUNCTION__, "Response is not code 200");

if (!root)

return handleError(__FUNCTION__, "Invalid JSON response");

json.push_back(JSONNode("message", message_text.c_str()));

std::string data = json.write();

if (root) {

const JSONNode &error_ = root["error"];

if (error_) {

{

handleEntry(__FUNCTION__);

handleSuccess(__FUNCTION__);

}

}

void MinecraftDynmapProto::SignOnWorker(void*)

HANDLE chatHandle_;

// Data storage

std::string get_server(bool not_last = false);

std::string get_language();

void __inline reset_error() { error_count_ = 0; }

// HTTP communication

std::string chooseAction(int, std::string *get_data = nullptr);

// Requests and processing

bool doSignOn();

#define HTTP_CODE_FAKE_DISCONNECTED 0

#define HTTP_CODE_FAKE_ERROR 1

class ScopedLock

{

public:

void GetNewsData(wchar_t *tszUrl, char **szData, MCONTACT hContact, CFeedEditor *pEditDlg)

{

Netlib_LogfW(hNetlibUser, L"Getting feed data %s.", tszUrl);

// initialize the netlib request

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11 | NLHRF_REDIRECT;

if (wcsstr(tszUrl, L"https://") != nullptr)

nlhr.flags |= NLHRF_SSL;

nlhr.nlc = hNetlibHttp;

// change the header so the plugin is pretended to be IE 6 + WinXP

CreateAuthString(auth, hContact, pEditDlg);

}

// download the page

NLHR_PTR nlhrReply(Netlib_HttpTransaction(hNetlibUser, &nlhr));

if (nlhrReply) {

// if the recieved code is 200 OK

Netlib_LogfW(hNetlibUser, L"Code 200: Succeeded getting feed data %s.", tszUrl);

}

else if (nlhrReply->resultCode == 401) {

Netlib_LogfW(hNetlibUser, L"Code 401: feed %s needs auth data.", tszUrl);

else Netlib_LogfW(hNetlibUser, L"Code %d: Failed getting feed data %s.", nlhrReply->resultCode, tszUrl);

}

else Netlib_LogfW(hNetlibUser, L"Failed getting feed data %s, no response.", tszUrl);

}

time_t DateToUnixTime(const char *stamp, bool FeedType)

bool DownloadFile(LPCTSTR tszURL, LPCTSTR tszLocal)

{

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11;

NLHR_PTR pReply(Netlib_HttpTransaction(hNetlibUser, &nlhr));

if (pReply) {

if (date != nullptr && size != nullptr) {

struct _stat buf;

int fh = _wopen(tszLocal, _O_RDONLY);

if (fh != -1) {

_fstat(fh, &buf);

time_t modtime = DateToUnixTime(date, 0);

time_t filemodtime = mktime(localtime(&buf.st_atime));

}

}

}

}

}

typedef HRESULT(MarkupCallback)(IHTMLDocument3 *, BSTR &message);

int InternetDownloadFile(char *szUrl)

{

// initialize the netlib request

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_DUMPASTEXT;

// change the header so the plugin is pretended to be IE 6 + WinXP

// download the page

NLHR_PTR nlhrReply(Netlib_HttpTransaction(hNetlibUser, &nlhr));

// if the recieved code is 200 OK

else if (nlhrReply->resultCode == 200) {

// allocate memory and save the retrieved data

}

// if the recieved code is 302 Moved, Found, etc

else if (nlhrReply->resultCode == 302) { // page moved

// get the url for the new location and save it to szInfo

// look for the reply header "Location"

szData = (char *)malloc(512);

// add "Moved/Location:" in front of the new URL for identification

mir_snprintf(szData, 512, "Moved/Location: %s\n", pszHdr);

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pReq->m_host != HOST_OTHER)

pReq->m_szUrl.Insert(0, ((pReq->flags & NLHRF_SSL) ? "https://" : "http://"));

case REQUEST_PUT:

case REQUEST_POST:

if (pReq->m_szParam[0] == '[' || pReq->m_szParam[0] == '{')

pReq->AddHeader("Content-Type", "application/json; charset=UTF-8");

else

pReq->AddHeader("Content-Type", "application/x-www-form-urlencoded");

}

}

}

break;

}

return Netlib_HttpTransaction(m_hNetlibUser, pReq);

}

struct SetAvatarRequest : public AsyncHttpRequest

{

AsyncHttpRequest(REQUEST_PUT, HOST_API, 0, &CSkypeProto::OnSentAvatar)

{

m_szUrl.AppendFormat("/users/%s/profile/avatar", ppro->m_szSkypename.MakeLower().c_str());

AddHeader("Content-Type", szMime);

}

};

struct ASMObjectUploadRequest : public AsyncHttpRequest

{

AsyncHttpRequest(REQUEST_PUT, HOST_OTHER, 0, &CSkypeProto::OnASMObjectUploaded)

{

m_szUrl.AppendFormat("https://api.asm.skype.com/v1/objects/%s/content/original", szObject);

AddHeader("Authorization", CMStringA(FORMAT, "skype_token %s", ppro->m_szApiToken.get()));

AddHeader("Content-Type", "application/octet-stream");

}

};

SvcGetAvatarInfo(0, (LPARAM)&ai);

}

{

return;

MCONTACT hContact = (DWORD_PTR)pRequest->pUserInfo;

return;

PROTO_AVATAR_INFORMATION ai = { 0 };

setByte(hContact, "AvatarType", ai.format);

GetAvatarFileName(hContact, ai.filename, _countof(ai.filename));

return;

}

fclose(out);

setByte(hContact, "NeedNewAvatar", 0);

ProtoBroadcastAck(hContact, ACKTYPE_AVATAR, ACKRESULT_SUCCESS, &ai, 0);

}

{

JsonReply root(response);

if (root.error())

if (data != NULL && fread(data, sizeof(uint8_t), length, hFile) == length) {

const char *szMime = FreeImage_GetFIFMimeType(FreeImage_GetFIFFromFilenameU(path));

fclose(hFile);

return 0;

}

return si;

}

{

JsonReply reply(response);

if (reply.error())

Chat_Event(&gce);

}

{

JsonReply reply(response);

if (reply.error())

return hContact;

}

{

JsonReply reply(response);

if (reply.error())

//[{"skypeId":"echo123", "authorized" : true, "blocked" : false, ...},...]

// other properties is exists but empty

{

JsonReply reply(response);

if (reply.error())

return 0;

}

{

MCONTACT hContact = (DWORD_PTR)pRequest->pUserInfo;

if (response != nullptr)

return 0;

}

{

if (response == nullptr)

return;

PushRequest(new ASMObjectCreateRequest(this, fup));

}

{

auto *fup = (CFileUploadParam*)pRequest->pUserInfo;

LBL_Error:

FILETRANSFER_FAILED(fup);

return;

goto LBL_Error;

}

std::string strObjectId = node["id"].as_string();

if (strObjectId.empty()) {

debugLogA("Invalid server response (empty object id)");

fclose(pFile);

}

{

auto *fup = (CFileUploadParam*)pRequest->pUserInfo;

if (response == nullptr) {

/* HISTORY SYNC */

{

JsonReply reply(response);

if (reply.error())

return 0;

}

{

JsonReply reply(response);

if (reply.error())

PushRequest(new OAuthRequest());

}

{

if (!IsStatusConnecting(m_iStatus))

return;

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

return;

}

if (!json) {

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

PushRequest(new CreateEndpointRequest(this));

}

{

if (IsStatusConnecting(m_iStatus))

m_iStatus++;

case 301:

case 302: // redirect to the closest data center

CMStringA szUrl(hdr+8);

int iEnd = szUrl.Find('/');

g_plugin.szDefaultServer = (iEnd != -1) ? szUrl.Left(iEnd) : szUrl;

return;

case 401: // unauthorized

if (strstr(szStatus, "SkypeTokenExpired"))

delSetting("TokenSecret");

delSetting("TokenExpiresIn");

}

// Succeeded, decode the answer

CMStringA szValue = hdr;

int iStart = 0;

while (true) {

PushRequest(new CreateSubscriptionsRequest());

}

{

m_szId = nullptr;

m_szToken = nullptr;

}

{

if (response == nullptr) {

debugLogA(__FUNCTION__ ": failed to create subscription");

PushRequest(new SendCapabilitiesRequest(epname, this));

}

{

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

return;

if (bAutoHistorySync)

PushRequest(new SyncHistoryFirstRequest(100));

if (root)

setString("SelfEndpointName", UrlToSkypeId(root["selfLink"].as_string().c_str()));

PushRequest(new GetProfileRequest(this, 0));

}

{

debugLogA(__FUNCTION__ ": failed to change status");

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

return;

}

if (!json) {

debugLogA(__FUNCTION__ ": failed to change status");

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

return param->hMessage;

}

{

auto *param = (SendMessageParam*)pRequest->pUserInfo;

MCONTACT hContact = param->hContact;

if (response->resultCode != 201) {

std::string strError = Translate("Unknown error!");

const JSONNode &jErr = jRoot["errorCode"];

if (jErr)

strError = jErr.as_string();

return (i2 == -1) ? "" : str.substr(i1, i2 - i1);

}

{

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

return;

std::regex regex;

std::smatch match;

regex = "<input.+?type=\"hidden\".+?name=\"PPFT\".+?id=\"i0327\".+?value=\"(.+?)\".*?/>";

std::map<std::string, std::string> scookies;

regex = "^(.+?)=(.*?);";

continue;

if (std::regex_search(content, match, regex))

scookies[match[1]] = match[2];

}

return true;

}

{

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

return;

}

return;

std::string PPFT = sub(content, "sFT:'", "'");

std::string opid = sub(content, "opid=", "&");

if (PPFT.empty() || opid.empty()) {

std::smatch match;

CMStringA mscookies;

continue;

if (std::regex_search(content, match, regex))

mscookies.Append(match[1].str().c_str());

}

PushRequest(new OAuthRequest(mscookies.c_str(), PPFT.c_str(), opid.c_str()));

}

{

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

return;

}

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

}

}

{

ProtoBroadcastAck(NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGIN_ERROR_UNKNOWN);

SetStatus(ID_STATUS_OFFLINE);

return;

std::regex regex;

std::smatch match;

regex = "<input.+?type=\"hidden\".+?name=\"skypetoken\".+?value=\"(.+?)\".*?/>";

if (!std::regex_search(content, match, regex)) {

if (response->resultCode == 200) {

nErrors = 0;

}

else {

nErrors++;

const JSONNode &error = root["errorCode"];

if (error && error.as_int() == 729)

break;

}

//{"firstname":"Echo \/ Sound Test Service", "lastname" : null, "birthday" : null, "gender" : null, "country" : null, "city" : null, "language" : null, "homepage" : null, "about" : null, "province" : null, "jobtitle" : null, "emails" : [], "phoneMobile" : null, "phoneHome" : null, "phoneOffice" : null, "mood" : null, "richMood" : null, "avatarUrl" : null, "username" : "echo123"}

{

MCONTACT hContact = (DWORD_PTR)pRequest->pUserInfo;

/////////////////////////////////////////////////////////////////////////////////////////

{

JsonReply reply(response);

if (reply.error())

return getMStringA(hContact, SKYPE_SETTINGS_ID);

}

// login

// oauth

void CheckConvert(void);

bool CheckOauth(const char *szResponse);

static INT_PTR __cdecl GlobalParseSkypeUriService(WPARAM, LPARAM lParam);

void StartQueue();

void StopQueue();

void Execute(AsyncHttpRequest *request);

void PushRequest(AsyncHttpRequest *request);

PushRequest(new GetSearchRequest(T2Utf((wchar_t *)id)));

}

{

debugLogA(__FUNCTION__);

SendPresence();

}

{

JsonReply reply(response);

if (reply.error())

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pReply == nullptr) {

m_errorCode = 500;

if (m_errorCode != 200)

return;

if (m_root == nullptr) {

m_errorCode = 500;

return;

int m_errorCode = 0;

public:

~JsonReply();

__forceinline JSONNode &data() const { return *m_root; }

class HttpResponse

{

public:

m_response(response)

{

}

bool operator!() const

{

}

operator bool() const

{

}

bool IsSuccess() const

char* data() const

{

}

unsigned length() const

{

}

int GetStatusCode() const

{

if (m_response)

{

HttpRequest(int iRequestType, const char *pszUrl);

};

struct ProtoRequest

bool CSteamProto::SendRequest(HttpRequest *request)

{

HttpResponse response(pResp);

delete request;

return response.IsSuccess();

bool CSteamProto::SendRequest(HttpRequest *request, HttpCallback callback, void *param)

{

HttpResponse response(pResp);

if (callback)

(this->*callback)(response, param);

bool CSteamProto::SendRequest(HttpRequest *request, JsonCallback callback, void *param)

{

HttpResponse response(pResp);

if (callback) {

JSONNode root = JSONNode::parse(response.data());

m_szUrl = szUrl;

}

{

if (m_szUrl[0]== '/') {

m_szUrl.Insert(0, STEAM_API_URL);

AddHeader("User-Agent", STEAM_USER_AGENT);

}

return this;

}

}

};

{

void Init(int type)

{

requestType = type;

flags = NLHRF_HTTP11 | NLHRF_SSL | NLHRF_NODUMPSEND | NLHRF_DUMPASTEXT;

nlc = nullptr;

timeout = 0;

}

~HttpRequest()

{

}

void AddUrlParameter(const char *urlFormat, ...)

va_end(urlArgs);

}

{

m_szUrl.Replace('\\', '/');

return Netlib_HttpTransaction(hNetlibConnection, this);

}

};

debugLogA(__FUNCTION__": updating nodes");

HttpRequest request(REQUEST_GET, "https://nodes.tox.chat/json");

NLHR_PTR response(request.Send(m_hNetlibUser));

debugLogA(__FUNCTION__": failed to dowload tox.json");

return;

}

if (root.empty()) {

debugLogA(__FUNCTION__": failed to dowload tox.json");

return;

return;

}

debugLogA(__FUNCTION__": failed to write tox.json");

fclose(hFile);

}

else pReq->AddHeader("Content-Type", "application/x-www-form-urlencoded");

pReq->AddHeader("Cache-Control", "no-cache");

}

else {

if (pReq->requestType == REQUEST_PATCH)

// auth = OAuthWebRequestSubmit(pReq->m_szUrl, "POST", (bIsJson) ? "" : pReq->pData);

// pReq->AddHeader("Authorization", auth);

pReq->flags = NLHRF_HTTP11 | NLHRF_PERSISTENT | NLHRF_REDIRECT;

pReq->nlc = m_hConnHttp;

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pResp->resultCode != 200) {

OnLoggedFail();

/////////////////////////////////////////////////////////////////////////////////////////

{

if (pResp->resultCode != 200) {

OnLoggedFail();

void RequestOauthToken(const char *szPin = nullptr);

void ResetOauthKeys();

CMStringA OAuthWebRequestSubmit(const CMStringA &url, const char *httpMethod, const char *postData);

bool save_url(HNETLIBUSER hNetlib, const CMStringA &url, const CMStringW &filename)

{

req.requestType = REQUEST_GET;

req.flags = NLHRF_HTTP11 | NLHRF_REDIRECT;

NLHR_PTR resp(Netlib_HttpTransaction(hNetlib, &req));

if (!resp)

// Write to file

if (FILE *f = _wfopen(filename, L"wb")) {

fclose(f);

}

else return false;

/////////////////////////////////////////////////////////////////////////////////////////

{

debugLogA("CVkProto::CheckJsonResponse");

return nullNode;

if (!CheckJsonResult(pReq, root))

return nullNode;

return (iErrorCode == 0);

}

{

JSONNode jnRoot;

const JSONNode &jnResponse = CheckJsonResponse(pReq, reply, jnRoot);

/////////////////////////////////////////////////////////////////////////////////////////

{

debugLogA("CVkProto::GrabCookies");

continue;

int iStart = 0;

while (true) {

bool bFirstToken = (iStart == 0);

if (GetFileAttributesW(wszFileName) == INVALID_FILE_ATTRIBUTES) {

T2Utf szUrl(wszUrl);

req.flags = NLHRF_NODUMP | NLHRF_SSL | NLHRF_HTTP11 | NLHRF_REDIRECT;

req.requestType = REQUEST_GET;

bSuccess = true;

FILE* out = _wfopen(wszFileName, L"wb");

fclose(out);

}

}

#include "stdafx.h"

{

if (reply->resultCode != 200 || !pReq->pUserInfo)

return;

PROTO_AVATAR_INFORMATION ai = { 0 };

CVkSendMsgParam *param = (CVkSendMsgParam *)pReq->pUserInfo;

GetAvatarFileName(param->hContact, ai.filename, _countof(ai.filename));

FILE *out = _wfopen(ai.filename, L"wb");

if (out == nullptr) {

return;

}

fclose(out);

setByte(param->hContact, "NeedNewAvatar", 0);

ProtoBroadcastAck(param->hContact, ACKTYPE_AVATAR, ACKRESULT_SUCCESS, &ai);

Utils_OpenUrl(szCaptchaAssistant);

}

else {

req.requestType = REQUEST_GET;

req.flags = VK_NODUMPHEADERS;

if (reply == nullptr)

return false;

return false;

}

BITMAP bmp = { 0 };

GetObject(param.bmp, sizeof(bmp), &bmp);

)->pUserInfo = cc;

}

{

debugLogA("CVkProto::OnReceiveChatInfo %d", reply->resultCode);

if (reply->resultCode != 200)

return 1;

}

{

debugLogA("CVkProto::OnSendChatMsg %d", reply->resultCode);

int iResult = ACKRESULT_FAILED;

LeaveChat(iChatId);

}

{

debugLogA("CVkProto::OnChatLeave %d", reply->resultCode);

if (reply->resultCode != 200)

}

{

debugLogA("CVkProto::OnChatDestroy %d", reply->resultCode);

if (reply->resultCode != 200)

<< CHAR_PARAM("user_ids", uids));

}

{

debugLogA("CVkProto::OnCreateNewChat %d", reply->resultCode);

if (reply->resultCode != 200)

return compareType ? compareDate : (compareId ? (int)compareDate : 0);

}

{

debugLogA("CVkProto::OnReceiveUnreadNews %d", reply->resultCode);

db_unset(0, m_szModuleName, "LastNewsReqTime");

Push(new AsyncHttpRequest(this, REQUEST_GET, "/method/notifications.markAsViewed.json", true, &CVkProto::OnReceiveSmth));

}

{

debugLogA("CVkProto::OnReceiveUnreadNotifications %d", reply->resultCode);

db_unset(0, m_szModuleName, "LastNotificationsReqTime");

}

{

CVkFileUploadParam *fup = (CVkFileUploadParam *)pReq->pUserInfo;

if (!IsOnline()) {

// Body size

long dataLength = iFileLen + DataBegin.GetLength() + DataEnd.GetLength();

// Body {

memcpy(pData, (void *)DataBegin.GetBuffer(), DataBegin.GetLength());

pData += DataBegin.GetLength();

long lBytes = (long)fread(pData, 1, iFileLen, pFile);

if (lBytes != iFileLen) {

SendFileFiled(fup, VKERR_ERR_READ_FILE);

delete pUploadReq;

return;

}

memcpy(pData, (void *)DataEnd.GetBuffer(), DataEnd.GetLength());

// } Body

pUploadReq->pUserInfo = pReq->pUserInfo;

Push(pUploadReq);

}

{

CVkFileUploadParam *fup = (CVkFileUploadParam *)pReq->pUserInfo;

if (!IsOnline()) {

Push(pUploadReq);

}

{

CVkFileUploadParam *fup = (CVkFileUploadParam *)pReq->pUserInfo;

if (!IsOnline()) {

}

}

{

debugLogA("CVkProto::OnReceiveHistoryMessages %d", reply->resultCode);

if (reply->resultCode != 200 || !pReq->pUserInfo) {

return uMsgId;

}

{

int iResult = ACKRESULT_FAILED;

if (pReq->pUserInfo == nullptr) {

Push(new AsyncHttpRequest(this, REQUEST_GET, "/method/execute.RetrieveUnreadConversations", true, &CVkProto::OnReceiveDlgs, AsyncHttpRequest::rpHigh));

}

{

debugLogA("CVkProto::OnReceiveMessages %d", reply->resultCode);

if (reply->resultCode != 200)

}

}

{

debugLogA("CVkProto::OnReceiveDlgs %d", reply->resultCode);

if (reply->resultCode != 200)

);

}

{

debugLogA("CVkProto::OnReceivePollingInfo %d", reply->resultCode);

if (reply->resultCode != 200)

CMStringA szReqUrl(FORMAT, "https://%s?act=a_check&key=%s&ts=%s&wait=25&access_token=%s&mode=%d&version=%d", m_szPollingServer, m_szPollingKey, m_szPollingTs, m_szAccessToken, 106, 2);

// see mode parametr description on https://vk.com/dev/using_longpoll (Russian version)

req.requestType = REQUEST_GET;

req.flags = VK_NODUMPHEADERS | NLHRF_PERSISTENT | NLHRF_HTTP11 | NLHRF_SSL;

req.timeout = 30000;

req.nlc = m_hPollingConn;

int retVal = 0;

if (reply->resultCode == 200) {

const JSONNode &jnFailed = jnRoot["failed"];

if (jnFailed && jnFailed.as_int() > 1) {

RetrievePollingInfo();

return 0;

}

{

debugLogA("CVkProto::OnReceiveAuthRequest %d", reply->resultCode);

CVkSendMsgParam *param = (CVkSendMsgParam*)pReq->pUserInfo;

//==== Events ========================================================================

int __cdecl OnOptionsInit(WPARAM, LPARAM);

//==== Services ======================================================================

//==== Search ========================================================================

void FreeProtoShearchStruct(PROTOSEARCHBYNAME *pParam);

//==== Files Upload ==================================================================

void SendFileFiled(CVkFileUploadParam *fup, int ErrorCode);

//==== Feed ==========================================================================

CMStringW GetVkFeedback(const JSONNode &jnFeedback, VKObjType vkFeedbackType, OBJLIST<CVkUserInfo> &vkUsers, CVkUserInfo *vkUser);

CVKNewsItem* GetVkParent(const JSONNode &jnParent, VKObjType vkParentType, LPCWSTR pwszReplyText = nullptr, LPCWSTR pwszReplyLink = nullptr);

void RetrieveUnreadNews(time_t tLastNewsTime);

void RetrieveUnreadNotifications(time_t tLastNotificationsTime);

bool FilterNotification(CVKNewsItem *vkNotificationItem, bool& bIsCommented);

void NotificationMarkAsViewed();

void RetrieveUnreadEvents();

void NewsClearHistory();

INT_PTR __cdecl SvcLoadVKNews(WPARAM, LPARAM);

void RetrieveUsersInfo(bool bFlag = false, bool bRepeat = false);

void RetrieveStatusMsg(const CMStringW &StatusMsg);

void RetrieveStatusMusic(const CMStringW &StatusMsg);

MCONTACT SetContactInfo(const JSONNode &jnItem, bool bFlag = false, VKContactType vkContactType = VKContactType::vkContactNormal);

void TrackVisitor();

void RetrieveMyInfo(void);

void RetrieveUserInfo(VKUserID_t iUserId);

void RetrieveGroupInfo(VKUserID_t iGroupID);

void RetrieveGroupInfo(CMStringA & groupIDs);

void RetrieveFriends(bool bCleanNonFriendContacts = false);

void MarkMessagesRead(const MCONTACT hContact);

void RetrieveMessagesByIds(const CMStringA &szMids);

void RetrieveUnreadMessages();

void WallPost(MCONTACT hContact, wchar_t *pwszMsg, wchar_t *pwszUrl, bool bFriendsOnly);

void GetServerHistoryLastNDay(MCONTACT hContact, int iNDay);

void GetServerHistory(MCONTACT hContact, int iOffset, int iCount, time_t tTime, VKMessageID_t iLastMsgId, bool bOnce = false);

void GetHistoryDlg(MCONTACT hContact, VKMessageID_t iLastMsg);

void RetrievePollingInfo();

void __cdecl PollingThread(void*);

int PollServer();

void PollUpdates(const JSONNode&);

//==== Misc ==========================================================================

void SetAllContactStatuses(int iStatus);

MCONTACT FindUser(VKUserID_t iUserId, bool bCreate = false);

MCONTACT FindChat(VKUserID_t iUserId);

bool CheckJsonResult(AsyncHttpRequest *pReq, const JSONNode &Node);

bool AutoFillForm(char*, CMStringA&, CMStringA&);

CMStringW RunConfirmationCode(LPCWSTR pwszTitle);

CMStringW RunRenameNick(LPCWSTR pwszOldName);

void ApplyCookies(AsyncHttpRequest*);

bool IsAuthContactLater(MCONTACT hContact);

bool AddAuthContactLater(MCONTACT hContact);

void StopChatContactTyping(VKUserID_t iChatId, VKUserID_t iUserId);

CVkChatInfo* AppendConversationChat(VKUserID_t iChatId, const JSONNode& jnItem);

void SetChatTitle(CVkChatInfo *cc, LPCWSTR wszTopic);

void AppendChatConversationMessage(VKUserID_t iChatId, const JSONNode& jnMsg, const JSONNode& jnFUsers, bool bIsHistory);

void AppendChatMessage(CVkChatInfo* vkChatInfo, VKMessageID_t iMessageId, VKUserID_t iUserId, time_t tMsgTime, LPCWSTR pwszBody, bool bIsHistory, bool bIsAction = false);

void RetrieveChatInfo(CVkChatInfo*);

int __cdecl OnChatEvent(WPARAM, LPARAM);

int __cdecl OnGcMenuHook(WPARAM, LPARAM);

void KickFromChat(VKUserID_t iChatId, VKUserID_t iUserId, const JSONNode &jnMsg, const JSONNode &jnFUsers);

do {

pReq->bNeedsRestart = false;

pReq->m_iErrorCode = 0;

if (!pReq->m_szParam.IsEmpty()) {

if (pReq->requestType == REQUEST_GET) {

str.Format("%s?%s", pReq->m_szUrl.c_str(), pReq->m_szParam.c_str());

}

}

tLocalWorkThreadTimer = m_tWorkThreadTimer = time(0);

}

NLHR_PTR reply(Netlib_HttpTransaction(m_hNetlibUser, pReq));

{

mir_cslock lck(m_csWorkThreadTimer);

delete pParam;

}

{

PROTOSEARCHBYNAME *pParam = (PROTOSEARCHBYNAME *)pReq->pUserInfo;

debugLogA("CVkProto::OnSearch %d", reply->resultCode);

FreeProtoShearchStruct(pParam);

}

{

debugLogA("CVkProto::OnSearch %d", reply->resultCode);

if (reply->resultCode != 200) {

return 0;

}

{

debugLogA("CVkProto::OnReceiveStatusMsg %d", reply->resultCode);

if (reply->resultCode != 200)

setWString("OldStatusMsg", pwszOldStatusMsg);

}

{

debugLogA("CVkProto::OnReceiveStatus %d", reply->resultCode);

if (reply->resultCode != 200)

m_priority = rpPriority;

}

{

m_szUrl = pszHdr;

}

AsyncHttpRequest();

AsyncHttpRequest(CVkProto*, int iRequestType, LPCSTR szUrl, bool bSecure, MTHttpRequestHandler pFunc, RequestPriority rpPriority = rpMedium);

int m_iRetry;

int m_iErrorCode;

/////////////////////////////////////////////////////////////////////////////////////////

{

debugLogA("CVkProto::OnOAuthAuthorize %d", reply->resultCode);

GrabCookies(reply, szVKCookieDomain);

}

if (reply->resultCode == 302) { // manual redirect

if (pszLocation) {

if (!_strnicmp(pszLocation, szBlankUrl, sizeof(szBlankUrl) - 1)) {

m_szAccessToken = nullptr;

return;

}

ConnectionFailed(LOGINERR_NOSERVER);

return;

}

if (pBlankUrl) {

debugLogA("CVkProto::OnOAuthAuthorize blank ulr found");

m_szAccessToken = nullptr;

return;

}

if (pMsgWarning) {

if (p1 && p2 && (p1 + 1 < p2)) {

CMStringA szMsg(p1 + 1, (int)(p2 - p1 - 1));

MsgPopup(ptrW(mir_utf8decodeW(szMsg)), TranslateT("Service message"), true);

}

CMStringA szAction, szBody;

if (!bSuccess || szAction.IsEmpty() || szBody.IsEmpty()) {

if (m_bPrevError) {

ConnectionFailed(LOGINERR_NOSERVER);

Push(new AsyncHttpRequest(this, REQUEST_GET, "/method/users.get.json", true, &CVkProto::OnReceiveMyInfo, AsyncHttpRequest::rpHigh));

}

{

debugLogA("CVkProto::OnReceiveMyInfo %d", reply->resultCode);

if (reply->resultCode != 200) {

}

{

debugLogA("CVkProto::OnReceiveUserInfo %d", reply->resultCode);

}

}

{

debugLogA("CVkProto::OnReceiveUserInfo %d", reply->resultCode);

<< CHAR_PARAM("fields", szFieldsName))->pUserInfo = new CVkSendMsgParam(0, bCleanNonFriendContacts ? 1 : 0);

}

{

debugLogA("CVkProto::OnReceiveFriends %d", reply->resultCode);

if (reply->resultCode != 200 || !IsOnline())

return 0;

}

{

debugLogA("CVkProto::OnReceiveDeleteFriend %d", reply->resultCode);

CVkSendMsgParam *param = (CVkSendMsgParam*)pReq->pUserInfo;

if (userAgent == nullptr || userAgent[0] == 0)

userAgent = NETLIB_USER_AGENT;

// initialize the netlib request

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11 | NLHRF_REDIRECT;

// download the page

NLHR_PTR nlhrReply(Netlib_HttpTransaction(hNetlibUser, &nlhr));

// if the recieved code is 200 OK

int result;

if (nlhrReply->resultCode == 200) {

bool bIsUtf = false;

result = 0;

// allocate memory and save the retrieved data

// look for Content-Type=utf-8 in header

if (pszHdr && strstr(_strlwr(pszHdr), "utf-8"))

bIsUtf = true;

else {

while (end) {

// look for

// <meta http-equiv="Content-Type" content="utf-8" />

wchar_t *retVal = nullptr;

if (bIsUtf)

if (retVal == nullptr)

*szData = retVal;

}

else result = DATA_EMPTY;

if (mir_strlen(url) < 3)

WErrorPopup(hContact, TranslateT("URL not supplied"));

nlhr.requestType = REQUEST_GET;

nlhr.flags = NLHRF_DUMPASTEXT;

if ( g_plugin.getByte(NO_PROTECT_KEY, 0)) // disable

AlreadyDownloading = 0;

WErrorPopup(hContact, statusText);

db_set_ws(hContact, "CList", "StatusMsg", statusText);

}

trunccount = 0;

AlreadyDownloading = 1;

} // END DATELENGTH

} // END REPLY

bool CMPlugin::SaveFile(const char *pszUrl, PROTO_AVATAR_INFORMATION &ai)

{

req.flags = NLHRF_NODUMP | NLHRF_PERSISTENT | NLHRF_SSL | NLHRF_HTTP11 | NLHRF_REDIRECT;

req.requestType = REQUEST_GET;

req.nlc = hAvatarConn;

NLHR_PTR pReply(Netlib_HttpTransaction(hAvatarUser, &req));

hAvatarConn = pReply->nlc;

bool bSuccess = false;

ai.format = ProtoGetAvatarFormatByMimeType(pszHdr);

if (ai.format != PA_FORMAT_UNKNOWN) {

FILE *fout = _wfopen(ai.filename, L"wb");

if (fout) {

fclose(fout);

bSuccess = true;

}

void WhatsAppProto::ServerThreadWorker()

{

// connect websocket

if (pReply == nullptr) {

debugLogA("Server connection failed, exiting");

return;

uint32_t decodeBigEndian(const uint8_t *buf, size_t len)

{

uint32_t ret = 0;

ret <<= 8;

ret += buf[i];

}

std::string encodeBigEndian(uint32_t num, size_t len)

{

std::string res;

char c = num & 0xFF;

res = c + res;

num >>= 8;

MBinBuffer WhatsAppProto::DownloadEncryptedFile(const char *url, const ProtobufCBinaryData &mediaKeys, const char *pszMediaType)

{

req.requestType = REQUEST_GET;

MBinBuffer ret;

auto *pResp = Netlib_HttpTransaction(m_hNetlibUser, &req);

if (pResp) {

if (pResp->resultCode == 200) {

WAMediaKeys out(mediaKeys.data, mediaKeys.len, pszMediaType);

}

}

<ClCompile Include="src\meta_options.cpp" />

<ClCompile Include="src\meta_services.cpp" />

<ClCompile Include="src\meta_utils.cpp" />

<ClCompile Include="src\MHttpRequest.cpp" />

<ClCompile Include="src\miranda.cpp" />

<ClCompile Include="src\modules.cpp" />

<ClCompile Include="src\movetogroup.cpp" />

<ClCompile Include="src\srmm_main.cpp">

<Filter>Source Files\SRMM</Filter>

</ClCompile>

</ItemGroup>

<ItemGroup>

<ClInclude Include="src\filter.h">

MHttpRequest::MHttpRequest()

{

}

MHttpRequest::~MHttpRequest()

{

}

{

}

/////////////////////////////////////////////////////////////////////////////////////////

MIR_APP_DLL(MHttpRequest*) operator<<(MHttpRequest *pReq, const INT_PARAM &param)