#define NLOCF_HTTP 0x0001 // this connection will be used for HTTP communications. If configured for an HTTP/HTTPS proxy the connection is opened as if there was no proxy.

#define NLOCF_STICKYHEADERS 0x0002 // this connection should send the sticky headers associated with NetLib user apart of any HTTP request

#define NLOCF_UDP 0x0008 // this connection is UDP

#define NLOCF_SSL 0x0010 // this connection is SSL

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

// Sets the required information for an HTTP proxy connection

return result;

}

{

ShellExecute(nullptr, L"explore", CrashLogFolder, nullptr, nullptr, SW_SHOW);

return 0;

clock_t start_tcp = clock();

clock_t end_tcp = clock();

void Start(void*)

{

Connected = FALSE;

if (ghConnection)

ghPacketReciever = Netlib_CreatePacketReceiver(ghConnection, 2048);

}

}

// connect to MQTT server

if (m_mqttConn == nullptr) {

debugLogA("connection failed, exiting");

ConnectionFailed();

{

codepage = m_codepage;

if (con == nullptr) {

wchar_t szTemp[300];

mir_snwprintf(szTemp, L"%c5%s %c%s%c (%S: %u).", irc::COLOR, TranslateT("Failed to connect to"), irc::BOLD, m_tszUserName, irc::BOLD, m_sessionInfo.sServer.c_str(), m_sessionInfo.iPort);

// If a remote computer initiates a chat session this is used to connect to the remote computer (user already accepted at this point).

// also used for connecting to a remote computer for remote file transfers

// If a remote computer initiates a filetransfer this is used to connect to that computer (the user has chosen to accept but it is possible the file exists/needs to be resumed etc still)

if (di->iType == DCC_SEND && !di->bSender) {

}

// connect to the remote computer from which you are receiving the file (now all actions to take (resume/overwrite etc) have been decided

}

// if for some reason the plugin has failed to connect to the remote computer the object is destroyed.

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

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

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

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

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

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

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

<Filter>Source Files</Filter>

</ClCompile>

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

<Filter>Source Files</Filter>

</ClCompile>

char *szPort = jbt->szProxyPort;

char *szHost = jbt->szProxyHost;

replaceStr(jbt->streamhostJID, jbt->szProxyJid);

if (hConn != nullptr) {

jbt->hConn = hConn;

replaceStr(jbt->streamhostJID, str);

debugLogA("bytestream_recv connecting to %s:%d", szHost, port);

if (hConn == nullptr) {

debugLogA("bytestream_recv_connection connection failed (%d), try next streamhost", WSAGetLastError());

continue;

ft->type = FT_OOB;

if (info.s == nullptr) {

debugLogA("Connection failed (%d), thread ended", WSAGetLastError());

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

char fileBuffer[2048];

int bytes = mir_snprintf(fileBuffer, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n", _filelength(fileId));

ft->std.flags |= PFTS_SENDING;

ft->std.currentFileProgress = 0;

IconsInit();

InitPopups();

GlobalMenuInit();

m_pepServices.insert(new CPepMood(this));

m_pepServices.insert(new CPepActivity(this));

OmemoInitDevice();

}

// group chats

GCREGISTER gcr = {};

gcr.dwFlags = GC_TYPNOTIF | GC_CHANMGR;

struct CJabberProto : public PROTO<CJabberProto>, public IJabberInterface

{

class CJabberProtoImpl

{

friend struct CJabberProto;

CMOption<uint32_t> m_iConnectionKeepAliveTimeout;

PVOID m_sslCtx;

HANDLE m_hThreadHandle;

void SetServerVcard(BOOL bPhotoChanged, wchar_t* szPhotoFileName);

void SaveVcardToDB(HWND hwndPage, int iPage);

//---- jabber_xml.c ------------------------------------------------------------------

void OnConsoleProcessXml(const TiXmlElement *node, uint32_t flags);

private:

char *m_szXmlStreamToBeInitialized;

HANDLE m_hPopupClass;

LONG m_nSerial;

void CJabberProto::CheckKeepAlive()

{

}

}

if (m_bEnableStreamMgmt)

char* dnsHost = it->pNameTarget;

proto->debugLogA("%s%s resolved to %s:%d", "_xmpp-client._tcp.", conn.server, dnsHost, dnsPort);

if (s) {

strncpy_s(conn.manualHost, dnsHost, _TRUNCATE);

conn.port = dnsPort;

info.xmpp_client_query();

if (info.s == nullptr) {

strncpy_s(info.conn.manualHost, info.conn.server, _TRUNCATE);

}

}

debugLogA("Thread type=%d server='%s' port='%d'", info.bIsReg, info.conn.manualHost, info.conn.port);

if (info.s == nullptr) {

debugLogA("Entering main recv loop");

int datalen = 0;

for (;;) {

int recvResult = info.recv(info.buffer + datalen, jabberNetworkBufferSize - datalen);

debugLogA("recvResult = %d", recvResult);

resolveID = -1;

proto = _pro;

if (param != nullptr) {

bIsReg = true;

mir_free(gssapiHostName);

mir_free(zRecvData);

mir_free(buffer);

}

void ThreadData::close(void)

if (this == nullptr)

return 0;

if (useZlib)

return zlibRecv(buf, (long)len);

}

int ThreadData::send(char* buf, int bufsize)

if (this == nullptr)

return 0;

if (bufsize == -1)

bufsize = (int)mir_strlen(buf);

int result;

if (useZlib)

result = zlibSend(buf, bufsize);

else

if (result == SOCKET_ERROR)

close();

return result;

}

}

int send_datalen = ZLIB_CHUNK_SIZE - zStreamOut.avail_out;

if (len == SOCKET_ERROR || len != send_datalen) {

proto->debugLogA("Netlib_Send() failed, error=%d", WSAGetLastError());

return SOCKET_ERROR;

{

if (zRecvReady) {

retry:

if (zRecvDatalen == SOCKET_ERROR) {

proto->debugLogA("Netlib_Recv() failed, error=%d", WSAGetLastError());

return SOCKET_ERROR;

}

return 0;

zStreamIn.avail_in = zRecvDatalen;

zStreamIn.next_in = (Bytef*)zRecvData;

ptrA szStreamId;

char* buffer;

// network support

HNETLIBCONN s;

CJabberProto *proto;

// XEP-0138 (Compression support)

bool bIsReg;

bool reg_done, bIsSessionAvailable;

bool bBookmarksLoaded;

// connection & login data

JABBER_CONN_DATA conn;

return;

}

void __cdecl CSametimeProto::SessionThread(LPVOID)

{

debugLogW(L"SessionThread() start");

BroadcastNewStatus(ID_STATUS_CONNECTING);

// setup

if (!server_connection) {

BroadcastNewStatus(ID_STATUS_OFFLINE);

DebugLog(CommFile, "<connect>\n");

#endif

try {

SystemError = WSAGetLastError();

throw NetworkError = (uint32_t)ENL_CONNECT;

}

Srmm_GetButtonGap @883

?addPopupOption@CMPluginBase@@QAEHPBDAAV?$CMOption@_N@@@Z @884 NONAME

?addPopupOption@CMPluginBase@@QAEHPB_WAAV?$CMOption@_N@@@Z @885 NONAME

Srmm_GetButtonGap @883

?addPopupOption@CMPluginBase@@QEAAHPEBDAEAV?$CMOption@_N@@@Z @884 NONAME

?addPopupOption@CMPluginBase@@QEAAHPEB_WAEAV?$CMOption@_N@@@Z @885 NONAME

USHORT si_family;

};

struct NetlibConnection : public MZeroedObject

{

NetlibConnection();

bool termRequested;

NetlibUser *nlu;

char *szNewUrl;

bool usingSsl = false;

char szUrl[1024];

usingSsl = true;

}

else {

noHttp = true;

}

return nullptr;

}

{

secur = secur || _strnicmp(szUrl, "https", 5) == 0;

const char* phost = strstr(szUrl, "://");

char* ppath = strchr(szHost, '/');

if (ppath) *ppath = '\0';

char* pcolon = strrchr(szHost, ':');

if (pcolon) {

*pcolon = '\0';

}

}

static NetlibConnection* NetlibHttpProcessUrl(NETLIBHTTPREQUEST *nlhr, NetlibUser *nlu, NetlibConnection *nlc, const char *szUrl = nullptr)

{

if (szUrl == nullptr)

else

nlhr->flags |= NLHRF_SSL;

else

nlhr->flags &= ~NLHRF_SSL;

if (nlc != nullptr) {

if (!httpProxy && !sameHost) {

NetlibDoCloseSocket(nlc);

return NetlibDoConnect(nlc) ? nlc : nullptr;

}

}

return nlc;

}

}

if (close &&

(!isConnect || nlhrReply->resultCode != 200))

NetlibDoCloseSocket(nlc);

return false;

}

{

// http://www.socks.nec.com/protocol/socks4.protocol and http://www.socks.nec.com/protocol/socks4a.protocol

size_t nUserLen = nlu->settings.szProxyAuthUser ? mir_strlen(nlu->settings.szProxyAuthUser) + 1 : 1;

size_t len = 8 + nUserLen;

char* pInit = (char*)alloca(len + nHostLen);

pInit[0] = 4; // SOCKS4

pInit[1] = 1; //connect

if (nUserLen <= 1) pInit[8] = 0;

else memcpy(&pInit[8], nlu->settings.szProxyAuthUser, nUserLen);

//if cannot resolve host, try resolving through proxy (requires SOCKS4a)

*(PDWORD)&pInit[4] = ip ? ip : 0x01000000;

if (!ip) {

len += nHostLen;

}

return 0;

}

{

//rfc1928

uint8_t buf[258];

buf[0] = 5; //yep, socks5

buf[1] = 1; //one auth method

size_t nHostLen;

uint32_t hostIP;

if (nlc->dnsThroughProxy) {

}

else {

if (hostIP == 0)

return 0;

nHostLen = 4;

}

uint8_t *pInit = (uint8_t*)mir_alloc(6 + nHostLen);

pInit[0] = 5; //SOCKS5

pInit[2] = 0; //reserved

if (hostIP == INADDR_NONE) { //DNS lookup through proxy

pInit[3] = 3;

pInit[4] = uint8_t(nHostLen - 1);

}

else {

pInit[3] = 1;

*(PDWORD)(pInit + 4) = hostIP;

}

if (Netlib_Send(nlc, (char*)pInit, int(6 + nHostLen), MSG_DUMPPROXY) == SOCKET_ERROR) {

Netlib_Logf(nlu, "%s %d: %s() failed (%u)", __FILE__, __LINE__, "Netlib_Send", GetLastError());

mir_free(pInit);

return 1;

}

{

// rfc2817

CMStringA szUrl;

if (nlc->dnsThroughProxy)

else {

if (ip == 0) return false;

}

NETLIBHTTPREQUEST nlhrSend = { 0 };

if (nlhrReply->resultCode == 403 && nlc->dnsThroughProxy) {

Netlib_FreeHttpRequest(nlhrReply);

nlc->dnsThroughProxy = 0;

}

NetlibHttpSetLastErrorUsingHttpResult(nlhrReply->resultCode);

Netlib_FreeHttpRequest(nlhrReply);

return 0;

}

SetLastError(dwOriginalLastError);

}

{

NetlibUser *nlu = nlc->nlu;

int rc = SOCKET_ERROR, retrycnt = 0;

u_long notblocking = 1;

uint32_t lasterr = 0;

static const TIMEVAL tv = { 1, 0 };

// this is for XP SP2 where there is a default connection attempt limit of 10/second

if (connectionTimeout) {

g_LastConnectionTick = GetTickCount();

ReleaseMutex(hConnectionOpenMutex);

}

char szPort[6];

hints.ai_family = AF_UNSPEC;

hints.ai_socktype = SOCK_DGRAM;

hints.ai_protocol = IPPROTO_UDP;

}

if (!nlc->szProxyServer)

return false;

_itoa(nlc->wProxyPort, szPort, 10);

if (GetAddrInfoA(nlc->szProxyServer, szPort, &hints, &air)) {

}

}

else {

return false;

return false;

}

}

lasterr = ERROR_TIMEOUT;

break;

}

rc = SOCKET_ERROR;

lasterr = ERROR_TIMEOUT;

break;

return rc == 0;

}

{

NetlibDoCloseSocket(nlc, true);

nlc->proxyAuthNeeded = false;

nlc->proxyType = 0;

replaceStr(nlc->szProxyServer, nullptr);

return false;

}

return true;

bool NetlibDoConnect(NetlibConnection *nlc)

{

NetlibUser *nlu = nlc->nlu;

replaceStr(nlc->szProxyServer, nullptr);

}

}

// if connection failed, the state of nlc might be unpredictable

if (GetNetlibHandleType(nlc) == NLH_CONNECTION) {

// Fallback to direct only when using HTTP proxy, as this is what used by companies

return false;

}

if (!WaitUntilWritable(nlc->s, 30000))

return false;

switch (nlc->proxyType) {

case PROXYTYPE_SOCKS4:

return false;

break;

case PROXYTYPE_SOCKS5:

return false;

break;

case PROXYTYPE_HTTPS:

case PROXYTYPE_HTTP:

nlc->proxyAuthNeeded = true;

usingProxy = false;

return false;

}

break;

}

}

if (GetSubscribersCount((THook*)hEventConnected)) {

NETLIBCONNECTIONEVENTINFO ncei = {};

size = sizeof(SOCKADDR_IN);

getpeername(nlc->s, (SOCKADDR *)&ncei.proxy, &size);

ncei.remote.sin_family = AF_INET;

}

else {

size = sizeof(SOCKADDR_IN);

NotifyFastHook(hEventConnected, (WPARAM)&ncei, 0);

}

return Netlib_StartSsl(nlc, nullptr) != 0;

return true;

return true;

}

{

SetLastError(ERROR_INVALID_PARAMETER);

return nullptr;

}

if (GetNetlibHandleType(nlu) != NLH_USER || !(nlu->user.flags & NUF_OUTGOING))

return nullptr;

NetlibConnection *nlc = new NetlibConnection();

nlc->nlu = nlu;

nlc->dnsThroughProxy = nlu->settings.dnsThroughProxy != 0;

if (!NetlibDoConnect(nlc)) {

mir_free(nlhpi.szHttpPostUrl);

mir_free(nlhpi.szHttpGetUrl);

NetlibDeleteNestedCS(&ncsSend);

NetlibDeleteNestedCS(&ncsRecv);

NetlibUser *nlu = nlc->nlu;

if (szHost == nullptr)

szHost = NEWSTR_ALLOCA(szHost);

Netlib_Logf(nlu, "(%d %s) Starting SSL/TLS negotiation", int(nlc->s), szHost);