// 下载URL文件到本地
bool CTyHttpClient::DownloadUrl( const char * url, const char *pszPath, const char *pszFileName/*=NULL*/ )
{
NormalizationUrl();
if(!ParseUrl(url))
return false;
if (!Create_Connect(m_strHost.c_str(), m_nPort))
return false;
if (GetReservedBufSize(CTySocket::typeRead) < 1024*100)
SetReservedBufSize(CTySocket::typeRead, 1024*100);
SendRequest();
if(RecvResponseHead())
{
if(!pszFileName)
pszFileName = m_strHttpFileName.c_str();
string strPathName;
if (pszPath)
{
strPathName = pszPath;
strPathName += DIR_SLASH;
}
strPathName += pszFileName;
return SaveHttpFile(strPathName.c_str());
}
return false;
}
NS_IMETHODIMP nsSmtpUrl::SetSpec(const nsACString &aSpec)
{
nsresult rv = nsMsgMailNewsUrl::SetSpec(aSpec);
if (NS_SUCCEEDED(rv))
rv = ParseUrl();
return rv;
}
NS_IMETHODIMP nsMailboxUrl::SetQuery(const nsACString &aQuery)
{
nsresult rv = nsMsgMailNewsUrl::SetQuery(aQuery);
if (NS_SUCCEEDED(rv))
rv = ParseUrl();
return rv;
}
HRESULT CHttpDownloader::Load(LPCTSTR szUrl, IStream **ppStream, LPCTSTR szMD5)
{
HRESULT hr = E_FAIL;
m_longAbort = 0;
Clear();
*ppStream = NULL;
m_dwDownloaded = 0;
m_dwTotalSize = 0;
m_request.md5 = szMD5;
hr = ParseUrl(szUrl);
if(SUCCEEDED(hr))
{
if(m_pStream)
{
m_pStream->Release();
m_pStream = NULL;
}
m_context.op = HTTP_DOWNLOADER_OP_IDLE;
m_context.hEvent = m_hEvent;
SetEvent(m_hEvent);
hr = WorkFunction();
if(SUCCEEDED(hr))
{
m_pStream->AddRef();
*ppStream = m_pStream;
}
}
return hr;
}
NS_IMETHODIMP
nsAddbookUrl::SetSpec(const nsACString &aSpec)
{
nsresult rv = m_baseURL->SetSpec(aSpec);
NS_ENSURE_SUCCESS(rv, rv);
return ParseUrl();
}
int CHttpClient::PostFile(string url)
{
string host, path;
int port = 0;
if(ParseUrl(url, host, port, path) != 0)
{
m_errno = -9;
return -1;
}
//LOG.Log("Access url: %s", url.c_str());
m_reqMsg.SetHost(host, port);
m_reqMsg.SetPath(path);
int64 startTime = GetMilSec();
int connSucc = 0;
int sock = -1;
int i;
for(i = 0; i < 1; i++)
{
sock = CTcpSock::Create();
if(CTcpSock::Connect(sock, host, port, 3000) == 0)
{
connSucc = 1;
break;
}
else
{
CTcpSock::Close(sock);
}
}
if(!connSucc)
{
m_errno = -1;
return -1;
}
if(m_reqMsg.PostFile(sock) != 0)
{
m_errno = -2;
CTcpSock::Close(sock);
return -1;
}
if(m_resMsg.RecvMsg(sock) != 0)
{
m_errno = -2;
CTcpSock::Close(sock);
return -1;
}
m_errno = 0;
CTcpSock::Close(sock);
return 0;
}
PACK *WpcCallEx(char *url, INTERNET_SETTING *setting, UINT timeout_connect, UINT timeout_comm,
char *function_name, PACK *pack, X *cert, K *key, void *sha1_cert_hash, bool *cancel, UINT max_recv_size,
char *additional_header_name, char *additional_header_value)
{
URL_DATA data;
BUF *b, *recv;
UINT error;
WPC_PACKET packet;
// Validate arguments
if (function_name == NULL || pack == NULL)
{
return PackError(ERR_INTERNAL_ERROR);
}
if (ParseUrl(&data, url, true, NULL) == false)
{
return PackError(ERR_INTERNAL_ERROR);
}
PackAddStr(pack, "function", function_name);
b = WpcGeneratePacket(pack, cert, key);
if (b == NULL)
{
return PackError(ERR_INTERNAL_ERROR);
}
SeekBuf(b, b->Size, 0);
WriteBufInt(b, 0);
SeekBuf(b, 0, 0);
if (IsEmptyStr(additional_header_name) == false && IsEmptyStr(additional_header_value) == false)
{
StrCpy(data.AdditionalHeaderName, sizeof(data.AdditionalHeaderName), additional_header_name);
StrCpy(data.AdditionalHeaderValue, sizeof(data.AdditionalHeaderValue), additional_header_value);
}
recv = HttpRequestEx(&data, setting, timeout_connect, timeout_comm, &error,
false, b->Buf, NULL, NULL, sha1_cert_hash, cancel, max_recv_size);
FreeBuf(b);
if (recv == NULL)
{
return PackError(error);
}
if (WpcParsePacket(&packet, recv) == false)
{
FreeBuf(recv);
return PackError(ERR_PROTOCOL_ERROR);
}
FreeBuf(recv);
FreeX(packet.Cert);
return packet.Pack;
}
char* HttpServer::GetArg(char *str)
{
static char clientline[CMDBUF];
if(str != NULL)
{
sprintf(clientline,"%s",ParseUrl(str));
return strtok(clientline,"/");
}
else
{
return strtok(NULL,"/");
}
}
bool CServer::ParseUrl(wxString host, const wxString& port, wxString user, wxString pass, wxString &error, CServerPath &path)
{
unsigned long nPort = 0;
if (!port.empty())
{
if (port.size() > 5 || !port.ToULong(&nPort) || !nPort || nPort > 65535)
{
error = _("Invalid port given. The port has to be a value from 1 to 65535.");
error += _T("\n");
error += _("You can leave the port field empty to use the default port.");
return false;
}
}
return ParseUrl(host, nPort, user, pass, error, path);
}
static int FontFace_ParseSrc(LCUI_CSSFontFace face, const char *str,
const char *dirname)
{
LCUI_StyleRec style;
if (face->src) {
free(face->src);
}
if (ParseUrl(&style, str, dirname)) {
face->src = style.val_string;
return 0;
}
free(face->src);
face->src = NULL;
return -1;
}
void WebProcessor::Execute()
{
m_gzip =false;
m_userAccess = uaControl;
m_authInfo[0] = '\0';
m_authToken[0] = '\0';
ParseHeaders();
if (m_httpMethod == hmPost && m_contentLen <= 0)
{
error("Invalid-request: content length is 0");
return;
}
if (m_httpMethod == hmOptions)
{
SendOptionsResponse();
return;
}
ParseUrl();
if (!CheckCredentials())
{
SendAuthResponse();
return;
}
if (m_httpMethod == hmPost)
{
// reading http body (request content)
m_request.Reserve(m_contentLen);
m_request[m_contentLen] = '\0';
if (!m_connection->Recv(m_request, m_contentLen))
{
error("Invalid-request: could not read data");
return;
}
debug("Request=%s", *m_request);
}
debug("request received from %s", m_connection->GetRemoteAddr());
Dispatch();
}
std::string Repository::PathFromUrl(std::string url) {
fs::path path(base_path_);
UrlInfo url_info = ParseUrl(url);
// добавляем директорию с схемой и доменом
{
std::string schema = url_info.schema;
std::transform(schema.begin(), schema.end(), schema.begin(), tolower);
std::string top_dir;
if(schema == std::string("https")) {
top_dir += "https_";
} else {
top_dir += "http_";
}
top_dir += url_info.domain;
path /= SanitizePath(top_dir);
}
// добавляем директории с путем
path /= SanitizePath(url_info.path);
if(path.filename()=="." || url_info.path.empty()) {
// если путь в URL заканчивается на / или пуст (только домен)
path /= "_";
}
// добавляем запрос
if(!url_info.query.empty()) {
path += '_';
path += url_info.query;
}
// добавляем расширение файла
if(path.extension().empty()) {
path += ".html";
}
return path.native();
}
CHttpUrl::CHttpUrl(std::string const &url)
{
ParseUrl(url);
}
UINT DCGetMyIpMain(DDNS_CLIENT *c, bool ipv6, char *dst, UINT dst_size, bool use_ssl, char *replace_v6)
{
char *url;
char url2[MAX_SIZE];
UINT ret = ERR_INTERNAL_ERROR;
URL_DATA data;
BUF *recv;
BUF *cert_hash;
// Validate arguments
if (dst == NULL || c == NULL)
{
return ERR_INTERNAL_ERROR;
}
if (ipv6 == false)
{
url = DDNS_URL2_V4_GLOBAL;
if (IsUseAlternativeHostname())
{
url = DDNS_URL2_V4_ALT;
}
}
else
{
url = DDNS_URL2_V6_GLOBAL;
if (IsUseAlternativeHostname())
{
url = DDNS_URL2_V6_ALT;
}
if (replace_v6)
{
url = replace_v6;
}
}
Format(url2, sizeof(url2), "%s?v=%I64u", url, Rand64());
if (use_ssl)
{
ReplaceStr(url2, sizeof(url2), url2, "http://", "https://");
}
if (ParseUrl(&data, url2, false, NULL) == false)
{
return ERR_INTERNAL_ERROR;
}
cert_hash = StrToBin(DDNS_CERT_HASH);
recv = HttpRequest(&data, (ipv6 ? NULL : &c->InternetSetting), DDNS_CONNECT_TIMEOUT, DDNS_COMM_TIMEOUT, &ret, false, NULL, NULL,
NULL, ((cert_hash != NULL && cert_hash->Size == SHA1_SIZE) ? cert_hash->Buf : NULL));
FreeBuf(cert_hash);
if (recv != NULL)
{
char *str = ZeroMalloc(recv->Size + 1);
Copy(str, recv->Buf, recv->Size);
if (StartWith(str, "IP=") == false)
{
ret = ERR_PROTOCOL_ERROR;
}
else
{
StrCpy(dst, dst_size, str + 3);
ret = ERR_NO_ERROR;
}
Free(str);
FreeBuf(recv);
}
if (IsUseAlternativeHostname() == false)
{
if (ret == ERR_CONNECT_FAILED)
{
if (ipv6 && replace_v6 == NULL && use_ssl == false)
{
UINT type = DetectFletsType();
if (type & FLETS_DETECT_TYPE_EAST_BFLETS_PRIVATE && ret != ERR_NO_ERROR)
{
ret = DCGetMyIpMain(c, ipv6, dst, dst_size, use_ssl, DDNS_REPLACE_URL2_FOR_EAST_BFLETS);
}
if (type & FLETS_DETECT_TYPE_EAST_NGN_PRIVATE && ret != ERR_NO_ERROR)
{
ret = DCGetMyIpMain(c, ipv6, dst, dst_size, use_ssl, DDNS_REPLACE_URL2_FOR_EAST_NGN);
}
if (type & FLETS_DETECT_TYPE_WEST_NGN_PRIVATE && ret != ERR_NO_ERROR)
{
ret = DCGetMyIpMain(c, ipv6, dst, dst_size, use_ssl, DDNS_REPLACE_URL2_FOR_WEST_NGN);
}
}
}
}
return ret;
}
int CHttpClient::AccessUrl(string url, int timeout, int redirectLevel)
{
if(timeout <= 0)
timeout = 99999999;
m_resMsg.Clear();
string host, path;
int port = 0;
if(ParseUrl(url, host, port, path) != 0)
{
m_errno = -1;
return -1;
}
//LOG.Log("Access url: %s", url.c_str());
m_reqMsg.SetHost(host, port);
m_reqMsg.SetPath(path);
int64 startTime = GetMilSec();
string ip;
if(ntohl(inet_addr(host.c_str())) != 0xffffffff
&& ntohl(inet_addr(host.c_str())) > ntohl(inet_addr("1.0.0.0")))
{
ip = host;
}
else
{
struct hostent * phe;
phe = gethostbyname(host.c_str());
if (phe == NULL)
{
m_errno = -1;
return -1;
}
else
{
struct in_addr addr;
addr.s_addr = *(unsigned long *) phe->h_addr_list[0];
ip = inet_ntoa(addr);
}
}
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock == -1)
{
m_errno = -2;
return -1;
}
struct sockaddr_in servAddr;
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = inet_addr(ip.c_str());
servAddr.sin_port = htons(port);
if(connect(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) == -1)
{
m_errno = -3;
CTcpSock::Close(sock);
return -1;
}
//重新计算超时时长
timeout -= GetMilSec() - startTime;
if(timeout <= 0)
{
m_errno = -4;
CTcpSock::Close(sock);
return -1;
}
startTime = GetMilSec();
if(m_reqMsg.SendMsg(sock, timeout) != 0)
{
m_errno = -5;
CTcpSock::Close(sock);
return -1;
}
//重新计算超时时长
timeout -= GetMilSec() - startTime;
if(timeout <= 0)
{
m_errno = -4;
CTcpSock::Close(sock);
return -1;
}
string reqCmd;
m_reqMsg.GetCmd(reqCmd);
if(reqCmd == "HEAD")
m_resMsg.SetOnlyHead(1);
if(m_resMsg.RecvMsg(sock, timeout) != 0)
{
m_errno = -6;
CTcpSock::Close(sock);
return -1;
}
m_errno = 0;
CTcpSock::Close(sock);
int stateCode;
m_resMsg.GetStatusCode(stateCode);
if(redirectLevel > 0 && (stateCode == 301 || stateCode == 302))
{
string location;
m_resMsg.GetHeader("Location", location);
if(location.size() > 0)
{
string newLocation;
CvtAbsUrl(url, location, newLocation);
return AccessUrl(newLocation, timeout, redirectLevel-1);
}
}
return 0;
}
void CSkypeProto::OnChatEvent(const JSONNode &node)
{
//std::string clientMsgId = node["clientmessageid"].as_string();
//std::string skypeEditedId = node["skypeeditedid"].as_string();
std::string fromLink = node["from"].as_string();
CMStringA from(ContactUrlToName(fromLink.c_str()));
time_t timestamp = IsoToUnixTime(node["composetime"].as_string().c_str());
std::string content = node["content"].as_string();
int emoteOffset = node["skypeemoteoffset"].as_int();
std::string conversationLink = node["conversationLink"].as_string();
CMStringA chatname(ChatUrlToName(conversationLink.c_str()));
CMString topic(node["threadtopic"].as_mstring());
if (FindChatRoom(chatname) == NULL)
SendRequest(new GetChatInfoRequest(m_szRegToken, chatname, m_szServer), &CSkypeProto::OnGetChatInfo, topic.Detach());
std::string messageType = node["messagetype"].as_string();
if (!mir_strcmpi(messageType.c_str(), "Text") || !mir_strcmpi(messageType.c_str(), "RichText"))
{
AddMessageToChat(_A2T(chatname), _A2T(from), content.c_str(), emoteOffset != NULL, emoteOffset, timestamp);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/AddMember"))
{
ptrA xinitiator, xtarget, initiator;
//content = <addmember><eventtime>1429186229164</eventtime><initiator>8:initiator</initiator><target>8:user</target></addmember>
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("addmember"));
if (xml == NULL)
return;
for (int i = 0; i < xmlGetChildCount(xml); i++)
{
HXML xmlNode = xmlGetNthChild(xml, L"target", i);
if (xmlNode == NULL)
break;
xtarget = mir_t2a(xmlGetText(xmlNode));
CMStringA target = ParseUrl(xtarget, "8:");
AddChatContact(_A2T(chatname), target, target, L"User");
}
xmlDestroyNode(xml);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/DeleteMember"))
{
ptrA xinitiator, xtarget;
//content = <addmember><eventtime>1429186229164</eventtime><initiator>8:initiator</initiator><target>8:user</target></addmember>
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("deletemember"));
if (xml != NULL) {
HXML xmlNode = xmlGetChildByPath(xml, _T("initiator"), 0);
xinitiator = node != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlNode = xmlGetChildByPath(xml, _T("target"), 0);
xtarget = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlDestroyNode(xml);
}
if (xtarget == NULL)
return;
CMStringA target = ParseUrl(xtarget, "8:");
CMStringA initiator = ParseUrl(xinitiator, "8:");
RemoveChatContact(_A2T(chatname), target, target, true, initiator);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/TopicUpdate"))
{
//content=<topicupdate><eventtime>1429532702130</eventtime><initiator>8:user</initiator><value>test topic</value></topicupdate>
ptrA xinitiator, value;
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("topicupdate"));
if (xml != NULL) {
HXML xmlNode = xmlGetChildByPath(xml, _T("initiator"), 0);
xinitiator = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlNode = xmlGetChildByPath(xml, _T("value"), 0);
value = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlDestroyNode(xml);
}
CMStringA initiator = ParseUrl(xinitiator, "8:");
RenameChat(chatname, value);
ChangeChatTopic(chatname, value, initiator);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/RoleUpdate"))
{
//content=<roleupdate><eventtime>1429551258363</eventtime><initiator>8:user</initiator><target><id>8:user1</id><role>admin</role></target></roleupdate>
ptrA xinitiator, xId, xRole;
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("roleupdate"));
if (xml != NULL) {
HXML xmlNode = xmlGetChildByPath(xml, _T("initiator"), 0);
xinitiator = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlNode = xmlGetChildByPath(xml, _T("target"), 0);
if (xmlNode != NULL)
{
HXML xmlId = xmlGetChildByPath(xmlNode, _T("id"), 0);
HXML xmlRole = xmlGetChildByPath(xmlNode, _T("role"), 0);
xId = xmlId != NULL ? mir_t2a(xmlGetText(xmlId)) : NULL;
xRole = xmlRole != NULL ? mir_t2a(xmlGetText(xmlRole)) : NULL;
}
xmlDestroyNode(xml);
CMStringA initiator = ParseUrl(xinitiator, "8:");
CMStringA id = ParseUrl(xId, "8:");
GCDEST gcd = { m_szModuleName, _A2T(chatname), !mir_strcmpi(xRole, "Admin") ? GC_EVENT_ADDSTATUS : GC_EVENT_REMOVESTATUS };
GCEVENT gce = { sizeof(gce), &gcd };
ptrT tszId(mir_a2t(id));
ptrT tszRole(mir_a2t(xRole));
ptrT tszInitiator(mir_a2t(initiator));
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszNick = tszId;
gce.ptszUID = tszId;
gce.ptszText = tszInitiator;
gce.time = time(NULL);
gce.bIsMe = IsMe(id);
gce.ptszStatus = TranslateT("Admin");
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
}
}
}
//describe处理
int RTSP_describe(RTSP_buffer * pRtsp)
{
char object[255], trash[255];
char *p;
unsigned short port;
char s8Url[255];
char s8Descr[MAX_DESCR_LENGTH];
char server[128];
char s8Str[128];
/*根据收到的请求请求消息，跳过方法名，分离出URL*/
if (!sscanf(pRtsp->in_buffer, " %*s %254s ", s8Url))
{
fprintf(stderr, "Error %s,%i\n", __FILE__, __LINE__);
send_reply(400, 0, pRtsp); /* bad request */
printf("get URL error");
return ERR_NOERROR;
}
/*验证URL */
switch (ParseUrl(s8Url, server, &port, object, sizeof(object)))
{
case 1: /*请求错误*/
fprintf(stderr, "Error %s,%i\n", __FILE__, __LINE__);
send_reply(400, 0, pRtsp);
printf("url request error");
return ERR_NOERROR;
break;
case -1: /*内部错误*/
fprintf(stderr,"url error while parsing !\n");
send_reply(500, 0, pRtsp);
printf("inner error");
return ERR_NOERROR;
break;
default:
break;
}
/*取得序列号,并且必须有这个选项*/
if ((p = strstr(pRtsp->in_buffer, HDR_CSEQ)) == NULL)
{
fprintf(stderr, "Error %s,%i\n", __FILE__, __LINE__);
send_reply(400, 0, pRtsp); /* Bad Request */
printf("get serial num error");
return ERR_NOERROR;
}
else
{
if (sscanf(p, "%254s %d", trash, &(pRtsp->rtsp_cseq)) != 2)
{
fprintf(stderr, "Error %s,%i\n", __FILE__, __LINE__);
send_reply(400, 0, pRtsp); /*请求错误*/
printf("get serial num 2 error");
return ERR_NOERROR;
}
}
//获取SDP内容
GetSdpDescr(pRtsp, s8Descr, s8Str);
//发送Describe响应
//printf("----------------1\r\n");
SendDescribeReply(pRtsp, object, s8Descr, s8Str);
//printf("2\r\n");
return ERR_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////
//
// [QueryCacheMissPolicy]
//
/////////////////////////////////////////////////////////////////////////////
HRESULT STDMETHODCALLTYPE
CProxyPlugin::QueryCacheMissPolicy( BSTR bstrOriginUrl,
IWMSContext *pUserContext,
IWMSCommandContext *pCommandContext,
IWMSContext *pPresentationContext,
IUnknown *pCachePluginContext,
long QueryType,
IWMSCacheProxyCallback *pCallback,
VARIANT varContext
)
{
VARIANT varContext2;
COpState *pOpState = NULL;
HRESULT hr = S_OK;
BOOL fRet;
if( ( NULL == bstrOriginUrl) ||
( NULL == pCommandContext ) ||
( NULL == pPresentationContext ) ||
( NULL == pCallback ) )
{
return( E_INVALIDARG );
}
if( QueryType & WMS_CACHE_QUERY_REVERSE_PROXY )
{
hr = pCallback->OnQueryCacheMissPolicy( S_OK,
WMS_CACHE_QUERY_MISS_SKIP,
NULL,
NULL,
NULL,
varContext );
return( hr );
}
if( ( QueryType & WMS_CACHE_QUERY_CACHE_EVENT ) ||
( QueryType & WMS_CACHE_QUERY_GET_CONTENT_INFO ) )
{
hr = pCallback->OnQueryCacheMissPolicy( S_OK,
WMS_CACHE_QUERY_MISS_FORWARD_REQUEST,
NULL,
NULL,
NULL,
varContext );
return( hr );
}
pOpState = new COpState;
if( NULL == pOpState )
{
return( E_OUTOFMEMORY );
}
pOpState->m_Op = COpState::OP_QUERY_CACHE_MISS_POLICY;
pOpState->m_bstrOriginUrl = bstrOriginUrl;
pOpState->m_pPresentationContext = pPresentationContext;
pOpState->m_pCacheProxyCallback = pCallback;
pOpState->m_varContext = varContext;
pOpState->m_pPresentationContext->AddRef();
pOpState->m_pCacheProxyCallback->AddRef();
if( NULL == pOpState->m_bstrOriginUrl.m_str )
{
pOpState->Release();
return( E_OUTOFMEMORY );
}
fRet = ParseUrl( bstrOriginUrl,
&pOpState->m_bstrProtocol,
&pOpState->m_bstrHost,
&pOpState->m_bstrPath,
&pOpState->m_wPort );
if( !fRet )
{
pOpState->Release();
return( E_FAIL );
}
// Initiate protocol rollover by calling OnGetContentInformation with an
// appropriate HRESULT
VariantInit( &varContext2 );
V_VT( &varContext2 ) = VT_UNKNOWN;
V_UNKNOWN( &varContext2 ) = (IUnknown *) pOpState;
pOpState->m_dwProtocolIndex = -1;
OnGetContentInformation( NS_E_CONNECTION_FAILURE, NULL, varContext2 );
return( S_OK );
}
NS_IMETHODIMP nsMailtoUrl::SetPath(const nsACString &aPath)
{
m_baseURL->SetPath(aPath);
return ParseUrl();
}
NS_IMETHODIMP nsMailtoUrl::SetPassword(const nsACString &aPassword)
{
m_baseURL->SetPassword(aPassword);
return ParseUrl();
}
NS_IMETHODIMP nsMailtoUrl::SetHost(const nsACString &aHost)
{
m_baseURL->SetHost(aHost);
return ParseUrl();
}
NS_IMETHODIMP nsMailtoUrl::SetUserPass(const nsACString &aUserPass)
{
m_baseURL->SetUserPass(aUserPass);
return ParseUrl();
}
NS_IMETHODIMP nsMailtoUrl::SetUsername(const nsACString &aUsername)
{
m_baseURL->SetUsername(aUsername);
return ParseUrl();
}
NS_IMETHODIMP nsMailtoUrl::SetScheme(const nsACString &aScheme)
{
m_baseURL->SetScheme(aScheme);
return ParseUrl();
}
bool AsyncDownload( char *Url, LPBYTE *lpBuffer, LPDWORD dwSize )
{
char *Host = NULL;
char *Path = NULL;
int Port = 0;
if ( !ParseUrl( Url, &Host, &Path, &Port ) )
{
return false;
}
PASYNCHTTP pData = (PASYNCHTTP)MemAlloc( sizeof( PASYNCHTTP ) );
if ( !pData )
{
return false;
}
pData->hConnectedEvent = pCreateEventW( NULL, FALSE, FALSE, NULL );
pData->hRequestOpenedEvent = pCreateEventW( NULL, FALSE, FALSE, NULL );
pData->hRequestCompleteEvent = pCreateEventW( NULL, FALSE, FALSE, NULL );
char *UserAgent = (char*)MemAlloc( 1024 );
DWORD dwUserSize = 1024;
pObtainUserAgentString( 0, UserAgent, &dwUserSize );
pData->hInstance = (HINTERNET)pInternetOpenA( UserAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC );
LPBYTE lpBuf = NULL;
DWORD dwBufSize = 0;
if ( pData->hInstance )
{
if ( pInternetSetStatusCallback( pData->hInstance, (INTERNET_STATUS_CALLBACK)&Callback) != INTERNET_INVALID_STATUS_CALLBACK)
{
pData->dwCurrent = 1;
pData->hConnect = (HINTERNET)pInternetConnectA( pData->hInstance, Host, INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0, (DWORD_PTR)pData );
if ( !pData->hConnect )
{
if ( pGetLastError() != ERROR_IO_PENDING )
{
return false;
}
pWaitForSingleObject( pData->hConnectedEvent, INFINITE );
}
pData->dwCurrent = 2;
pData->hRequest = (HINTERNET)pHttpOpenRequestA( pData->hConnect, "GET", Path, NULL, NULL, NULL, INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE, (DWORD_PTR)pData );
if ( !pData->hRequest )
{
if ( pGetLastError() != ERROR_IO_PENDING )
{
return false;
}
pWaitForSingleObject( pData->hRequestOpenedEvent, INFINITE );
}
if ( !(BOOL)pHttpSendRequestA( pData->hRequest, NULL, 0, NULL, 0 ) )
{
if ( pGetLastError() != ERROR_IO_PENDING )
{
return false;
}
}
pWaitForSingleObject( pData->hRequestCompleteEvent, INFINITE );
LPBYTE pTmpBuf = (LPBYTE)MemAlloc( 4096 );
if ( !pTmpBuf )
{
return false;
}
INTERNET_BUFFERSA ib;
m_memset( &ib, 0, sizeof( INTERNET_BUFFERSA ) );
ib.dwStructSize = sizeof( INTERNET_BUFFERSA );
ib.lpvBuffer = pTmpBuf;
do
{
ib.dwBufferLength = 4096;
if ( !(BOOL)pInternetReadFileExA( pData->hRequest, &ib, 0, 2 ) )
{
if ( pGetLastError() == ERROR_IO_PENDING)
{
pWaitForSingleObject( pData->hRequestCompleteEvent, INFINITE );
}
else
{
return false;
}
}
if ( ib.dwBufferLength )
{
if ( !lpBuf )
{
if ( !( lpBuf = (LPBYTE)MemAlloc( ib.dwBufferLength + 1 ) ) )
{
return false;
}
}
else
{
LPBYTE p = (LPBYTE)MemRealloc( lpBuf, dwBufSize + ib.dwBufferLength + 1 );
if ( !p )
{
return false;
}
lpBuf = p;
}
m_memcpy( lpBuf + dwBufSize, pTmpBuf, ib.dwBufferLength );
dwBufSize += ib.dwBufferLength;
}
else
{
pData->IsDownloaded = true;
}
} while ( !pData->IsDownloaded );
}
}
pInternetCloseHandle( pData->hRequest );
pInternetCloseHandle( pData->hConnect );
pInternetCloseHandle( pData->hInstance );
pCloseHandle( pData->hConnectedEvent );
pCloseHandle( pData->hRequestOpenedEvent );
pCloseHandle( pData->hRequestCompleteEvent );
MemFree( pData );
if ( dwSize )
{
*lpBuffer = lpBuf;
*dwSize = dwBufSize;
return true;
}
return false;
}
/*
** Resolve a sequence of URLs. Return the result in space obtained
** from malloc().
*/
char *ResolveUrl(
char *zBase, /* The base URL */
const char **azSeries /* A list of relatives. NULL terminated */
){
Url *base;
Url *term;
char *z;
base = ParseUrl(zBase);
while( azSeries[0] ){
term = ParseUrl(azSeries[0]);
azSeries++;
if( term->zScheme==0 && term->zAuthority==0 && term->zPath==0
&& term->zQuery==0 && term->zFragment ){
ReplaceStr(&base->zFragment, term->zFragment);
}else if( term->zScheme ){
Url temp;
temp = *term;
*term = *base;
*base = temp;
}else if( term->zAuthority ){
ReplaceStr(&base->zAuthority, term->zAuthority);
ReplaceStr(&base->zPath, term->zPath);
ReplaceStr(&base->zQuery, term->zQuery);
ReplaceStr(&base->zFragment, term->zFragment);
}else if( term->zPath && term->zPath[0]=='/' ){
ReplaceStr(&base->zPath, term->zPath);
ReplaceStr(&base->zQuery, term->zQuery);
ReplaceStr(&base->zFragment, term->zFragment);
}else if( term->zPath && base->zPath ){
char *zBuf;
int i, j;
zBuf = malloc( strlen(base->zPath) + strlen(term->zPath) + 2 );
if( zBuf ){
sprintf(zBuf,"%s", base->zPath);
for(i=strlen(zBuf)-1; i>=0 && zBuf[i]!='/'; i--){ zBuf[i] = 0; }
strcat(zBuf, term->zPath);
for(i=0; zBuf[i]; i++){
if( zBuf[i]=='/' && zBuf[i+1]=='.' && zBuf[i+2]=='/' ){
strcpy(&zBuf[i+1], &zBuf[i+3]);
i--;
continue;
}
if( zBuf[i]=='/' && zBuf[i+1]=='.' && zBuf[i+2]==0 ){
zBuf[i+1] = 0;
continue;
}
if( i>0 && zBuf[i]=='/' && zBuf[i+1]=='.' && zBuf[i+2]=='.'
&& (zBuf[i+3]=='/' || zBuf[i+3]==0) ){
for(j=i-1; j>=0 && zBuf[j]!='/'; j--){}
if( zBuf[i+3] ){
strcpy(&zBuf[j+1], &zBuf[i+4]);
}else{
zBuf[j+1] = 0;
}
i = j-1;
if( i<-1 ) i = -1;
continue;
}
}
free(base->zPath);
base->zPath = zBuf;
}
ReplaceStr(&base->zQuery, term->zQuery);
ReplaceStr(&base->zFragment, term->zFragment);
}
FreeUrl(term);
}
z = BuildUrl(base);
FreeUrl(base);
return z;
}
NS_IMETHODIMP nsMailtoUrl::SetSpec(const nsACString &aSpec)
{
m_baseURL->SetSpec(aSpec);
return ParseUrl();
}
NS_IMETHODIMP nsMailtoUrl::SetPort(int32_t aPort)
{
m_baseURL->SetPort(aPort);
return ParseUrl();
}
void CSkypeProto::ProcessEndpointPresence(const JSONNode &node)
{
debugLogA("CSkypeProto::ProcessEndpointPresenceRes");
std::string selfLink = node["selfLink"].as_string();
CMStringA skypename(UrlToSkypename(selfLink.c_str()));
MCONTACT hContact = FindContact(skypename);
if (hContact == NULL)
return;
const JSONNode &publicInfo = node["publicInfo"];
const JSONNode &privateInfo = node["privateInfo"];
CMStringA MirVer;
if (publicInfo)
{
std::string skypeNameVersion = publicInfo["skypeNameVersion"].as_string();
std::string version = publicInfo["version"].as_string();
std::string typ = publicInfo["typ"].as_string();
int iTyp = atoi(typ.c_str());
switch (iTyp)
{
case 0:
case 1:
MirVer.AppendFormat("Skype (Web) %s", ParseUrl(version.c_str(), "/"));
break;
case 10:
MirVer.AppendFormat("Skype (XBOX) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 17:
MirVer.AppendFormat("Skype (Android) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 16:
MirVer.AppendFormat("Skype (iOS) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 12:
MirVer.AppendFormat("Skype (WinRT) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 15:
MirVer.AppendFormat("Skype (WP) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 13:
MirVer.AppendFormat("Skype (OSX) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 11:
MirVer.AppendFormat("Skype (Windows) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 14:
MirVer.AppendFormat("Skype (Linux) %s", ParseUrl(skypeNameVersion.c_str(), "/"));
break;
case 125:
MirVer.AppendFormat("Miranda NG Skype %s", version.c_str());
break;
default:
MirVer.Append("Skype (Unknown)");
}
}
if (privateInfo != NULL)
{
std::string epname = privateInfo["epname"].as_string();
if (!epname.empty())
{
MirVer.AppendFormat(" [%s]", epname.c_str());
}
}
db_set_s(hContact, m_szModuleName, "MirVer", MirVer);
}
NS_IMETHODIMP
nsAddbookUrl::SetRef(const nsACString &aRef)
{
m_baseURL->SetRef(aRef);
return ParseUrl();
}
