void addOptionTag(string& hdrs, const string& hdr_name, const string& tag) {
// see if option tag already exists
string options = getHeader(hdrs, hdr_name);
if (options.size()) {
std::vector<string> option_entries = explode(options, ",");
for (std::vector<string>::iterator it=option_entries.begin();
it != option_entries.end(); it++) {
if (trim(*it," ") == tag)
// found - no need to add again
return;
}
// tag not found - add our tag to the (first) hdr_name header
size_t pos1; size_t pos2; size_t hdr_start;
if (!findHeader(hdrs, hdr_name, 0, pos1, pos2, hdr_start)) {
ERROR("internal error: header '%s' disappeared in-between (hdrs = '%s'!\n",
hdr_name.c_str(), hdrs.c_str());
hdrs += hdr_name + COLSP + tag + CRLF;
return;
}
hdrs.insert(pos1, tag+", ");
} else {
// hdr does not exist - add it
hdrs += hdr_name + COLSP + tag + CRLF;
}
}
int HTTPRequest::onHeaderField(const char * data, size_t length)
{
m_headerField.onData(data, length);
m_currentHeader = findHeader(m_headerField.buf(), m_headerField.size());
m_headerValue = false;
return 0;
}
void HttpParser::parse(unsigned char* pData, size_t nLength)
{
sbData_.Append(pData, nLength);
findHeader();
if (hasHeader()) {
findBody();
}
}
bool MtkFormat::isValid(const unsigned char *data, std::size_t size)
{
// We have to parse the boot image so we can search for the mtk headers
// Find Android header
std::size_t headerIndex;
if (!findHeader(data, size, 512, &headerIndex)) {
return false;
}
// Check for header size overflow
if (size < headerIndex + sizeof(BootImageHeader)) {
return false;
}
// Read the Android boot image header
auto hdr = reinterpret_cast<const BootImageHeader *>(&data[headerIndex]);
uint32_t pos = 0;
// Skip header
pos += headerIndex;
pos += sizeof(BootImageHeader);
pos += skipPadding(sizeof(BootImageHeader), hdr->page_size);
// Check for kernel size overflow
if (pos + hdr->kernel_size > size) {
return false;
}
if (hdr->kernel_size >= sizeof(MtkHeader)) {
auto mtkHdr = reinterpret_cast<const MtkHeader *>(&data[pos]);
if (std::memcmp(mtkHdr->magic, MTK_MAGIC, MTK_MAGIC_SIZE) == 0) {
return true;
}
}
// Skip kernel image
pos += hdr->kernel_size;
pos += skipPadding(hdr->kernel_size, hdr->page_size);
// Check for ramdisk size overflow
if (pos + hdr->ramdisk_size > size) {
return false;
}
if (hdr->ramdisk_size >= sizeof(MtkHeader)) {
auto mtkHdr = reinterpret_cast<const MtkHeader *>(&data[pos]);
if (std::memcmp(mtkHdr->magic, MTK_MAGIC, MTK_MAGIC_SIZE) == 0) {
return true;
}
}
// Skip ramdisk image
pos += hdr->ramdisk_size;
pos += skipPadding(hdr->ramdisk_size, hdr->page_size);
// There's no need to check any other images since the mtk header should
// only exist for the kernel and ramdisk
return false;
}
void CallTimerDialog::onInvite(const AmSipRequest& req)
{
if (dlg.getStatus() == AmSipDialog::Connected) {
DBG("not acting on re-Invite\n");
return;
}
setReceiving(false);
AmMediaProcessor::instance()->removeSession(this);
m_state = BB_Dialing;
if(dlg.reply(req, 100, "Trying") != 0) {
throw AmSession::Exception(500,"Failed to reply 100");
}
invite_req = req;
size_t pos1, pos2, hdr_start;
// remove P-App-Name, P-App-Param header
if (findHeader(invite_req.hdrs,PARAM_HDR, pos1, pos2,
hdr_start)) {
while (invite_req.hdrs[pos2]=='\r' ||invite_req.hdrs[pos2]=='\n')
pos2++;
hdr_start -= 11; //"P-App-Param"
invite_req.hdrs.erase(hdr_start, pos2-hdr_start);
}
if (findHeader(invite_req.hdrs,"P-App-Name", pos1, pos2,
hdr_start)) {
while (invite_req.hdrs[pos2]=='\r' ||invite_req.hdrs[pos2]=='\n')
pos2++;
hdr_start -= 10; //"P-App-Name"
invite_req.hdrs.erase(hdr_start, pos2-hdr_start);
}
dlg.updateStatus(invite_req);
recvd_req.insert(std::make_pair(invite_req.cseq,invite_req));
set_sip_relay_only(true);
connectCallee(invite_req.to, invite_req.r_uri, true);
}
string getHeader(const string& hdrs,const string& hdr_name)
{
size_t pos1;
size_t pos2;
size_t pos_s;
if (findHeader(hdrs,hdr_name, pos1, pos2, pos_s))
return hdrs.substr(pos1,pos2-pos1);
else
return "";
}
bool LokiFormat::isValid(const unsigned char *data, std::size_t size)
{
// Check that the size of the boot image is okay
if (size < 0x400 + LOKI_MAGIC_SIZE) {
return false;
}
// Loki boot images have both the Loki header and the Android header
std::size_t headerIndex;
return std::memcmp(&data[0x400], LOKI_MAGIC, LOKI_MAGIC_SIZE) == 0
&& findHeader(data, size, 32, &headerIndex);
}
bool removeHeader(string& hdrs, const string& hdr_name) {
size_t pos1, pos2, hdr_start;
bool found = false;
while (findHeader(hdrs, hdr_name, 0, pos1, pos2, hdr_start)) {
while (pos2 < hdrs.length() &&
(hdrs[pos2]=='\r' || hdrs[pos2]=='\n'))
pos2++;
hdr_start -= hdr_name.length();
hdrs.erase(hdr_start, pos2 - hdr_start);
found = true;
}
return found;
}
string getHeader(const string& hdrs,const string& hdr_name, bool single)
{
size_t pos1;
size_t pos2;
size_t pos_s;
size_t skip = 0;
string ret = "";
while(findHeader(hdrs, hdr_name, skip, pos1, pos2, pos_s))
{
if(skip)
ret.append(", ");
else
if(single) return hdrs.substr(pos1,pos2-pos1);
ret.append(hdrs.substr(pos1,pos2-pos1));
skip = pos2+1;
}
return ret;
}
bool LokiFormat::loadImage(const unsigned char *data, std::size_t size)
{
// Make sure the file is large enough to contain the Loki header
if (!isValid(data, size)) {
return false;
}
std::size_t headerIndex;
if (!findHeader(data, size, 32, &headerIndex)) {
LOGE("Failed to find Android header in loki'd boot image");
return false;
}
LOGD("Found Android boot image header at: %" MB_PRIzu, headerIndex);
if (!loadHeader(data, size, headerIndex)) {
return false;
}
const LokiHeader *loki = reinterpret_cast<const LokiHeader *>(&data[0x400]);
LOGD("Found Loki boot image header at 0x%x", 0x400);
LOGD("- magic: %s", StringUtils::toMaxString(
reinterpret_cast<const char *>(loki->magic), 4).c_str());
LOGD("- recovery: %u", loki->recovery);
LOGD("- build: %s",
StringUtils::toMaxString(loki->build, 128).c_str());
LOGD("- orig_kernel_size: %u", loki->orig_kernel_size);
LOGD("- orig_ramdisk_size: %u", loki->orig_ramdisk_size);
LOGD("- ramdisk_addr: 0x%08x", loki->ramdisk_addr);
if (loki->orig_kernel_size != 0
&& loki->orig_ramdisk_size != 0
&& loki->ramdisk_addr != 0) {
return loadLokiNewImage(data, size, loki);
} else {
return loadLokiOldImage(data, size, loki);
}
}
bool Conf::findSimpleLibrary(const QString &incvar, const QString &libvar, const QString &incname, const QString &libname, QString *incpath, QString *libs)
{
QString inc, lib;
QString s;
s = getenv(incvar);
if(!s.isEmpty()) {
if(!checkHeader(s, incname))
return false;
inc = s;
}
else {
if(!findHeader(incname, QStringList(), &s))
return false;
inc = s;
}
s = getenv(libvar);
if(!s.isEmpty()) {
if(!checkLibrary(s, libname))
return false;
lib = s;
}
else {
if(!findLibrary(libname, &s))
return false;
lib = s;
}
QString lib_out;
if(!lib.isEmpty())
lib_out += QString("-L") + s;
lib_out += QString("-l") + libname;
*incpath = inc;
*libs = lib_out;
return true;
}
bool BumpFormat::isValid(const unsigned char *data, std::size_t size)
{
// We have to parse the boot image to find the end so we can compare the
// trailing bytes to the bump magic string
std::size_t headerIndex;
if (!findHeader(data, size, 512, &headerIndex)) {
return false;
}
// Check for header size overflow
if (size < headerIndex + sizeof(BootImageHeader)) {
return false;
}
// Read the Android boot image header
auto hdr = reinterpret_cast<const BootImageHeader *>(&data[headerIndex]);
uint32_t pos = 0;
// Skip header
pos += headerIndex;
pos += sizeof(BootImageHeader);
pos += skipPadding(sizeof(BootImageHeader), hdr->page_size);
// Check for kernel size overflow
if (pos + hdr->kernel_size > size) {
return false;
}
// Skip kernel image
pos += hdr->kernel_size;
pos += skipPadding(hdr->kernel_size, hdr->page_size);
// Check for ramdisk size overflow
if (pos + hdr->ramdisk_size > size) {
return false;
}
// Skip ramdisk image
pos += hdr->ramdisk_size;
pos += skipPadding(hdr->ramdisk_size, hdr->page_size);
// Check for second bootloader size overflow
if (pos + hdr->second_size > size) {
return false;
}
// Skip second bootloader image
pos += hdr->second_size;
pos += skipPadding(hdr->second_size, hdr->page_size);
// Check for device tree image size overflow
if (pos + hdr->dt_size > size) {
return false;
}
// Skip device tree image
pos += hdr->dt_size;
pos += skipPadding(hdr->dt_size, hdr->page_size);
// We are now at the end of the boot image, so check for the bump magic
return (size >= pos + BUMP_MAGIC_SIZE)
&& std::memcmp(data + pos, BUMP_MAGIC, BUMP_MAGIC_SIZE) == 0;
}
void CVkProto::OnOAuthAuthorize(NETLIBHTTPREQUEST *reply, AsyncHttpRequest *pReq)
{
debugLogA("CVkProto::OnOAuthAuthorize %d", reply->resultCode);
GrabCookies(reply);
if (reply->resultCode == 302) { // manual redirect
LPCSTR pszLocation = findHeader(reply, "Location");
if (pszLocation) {
if (!_strnicmp(pszLocation, szBlankUrl, sizeof(szBlankUrl)-1)) {
m_szAccessToken = NULL;
LPCSTR p = strstr(pszLocation, VK_TOKEN_BEG);
if (p) {
p += sizeof(VK_TOKEN_BEG)-1;
for (LPCSTR q = p+1; *q; q++) {
if (*q == '&' || *q == '=' || *q == '\"') {
m_szAccessToken = mir_strndup(p, q-p);
break;
}
}
if (m_szAccessToken == NULL)
m_szAccessToken = mir_strdup(p);
setString("AccessToken", m_szAccessToken);
RetrieveMyInfo();
}
else {
delSetting("AccessToken");
ConnectionFailed(LOGINERR_NOSERVER);
}
}
else {
AsyncHttpRequest *pRedirectReq = new AsyncHttpRequest();
pRedirectReq->requestType = REQUEST_GET;
pRedirectReq->flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11;
pRedirectReq->m_pFunc = &CVkProto::OnOAuthAuthorize;
pRedirectReq->AddHeader("Referer", m_prevUrl);
pRedirectReq->Redirect(reply);
if (!pRedirectReq->m_szUrl.IsEmpty()) {
if (pRedirectReq->m_szUrl[0] == '/')
pRedirectReq->m_szUrl = VK_LOGIN_DOMAIN + pRedirectReq->m_szUrl;
ApplyCookies(pRedirectReq);
m_prevUrl = pRedirectReq->m_szUrl;
}
pRedirectReq->m_bApiReq = false;
pRedirectReq->bIsMainConn = true;
Push(pRedirectReq);
}
}
else
ConnectionFailed(LOGINERR_NOSERVER);
return;
}
if (reply->resultCode != 200 || !strstr(reply->pData, "form method=\"post\"")) { // something went wrong
ConnectionFailed(LOGINERR_NOSERVER);
return;
}
if (strstr(reply->pData, "service_msg_warning")) {
ConnectionFailed(LOGINERR_WRONGPASSWORD);
return;
}
CMStringA szAction, szBody;
bool bSuccess = AutoFillForm(reply->pData, szAction, szBody);
if (!bSuccess || szAction.IsEmpty() || szBody.IsEmpty()) {
if (m_prevError) {
ConnectionFailed(LOGINERR_NOSERVER);
return;
}
m_prevError = true;
}
pReq = new AsyncHttpRequest();
pReq->requestType = REQUEST_POST;
pReq->flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11;
pReq->m_szParam = szBody;
pReq->m_szUrl = szAction;
if (!pReq->m_szUrl.IsEmpty() && pReq->m_szUrl[0] == '/')
pReq->m_szUrl = VK_LOGIN_DOMAIN + pReq->m_szUrl;
m_prevUrl = pReq->m_szUrl;
pReq->m_pFunc = &CVkProto::OnOAuthAuthorize;
pReq->AddHeader("Content-Type", "application/x-www-form-urlencoded");
pReq->Redirect(reply);
ApplyCookies(pReq);
pReq->m_bApiReq = false;
pReq->bIsMainConn = true;
Push(pReq);
}
bool containsHeader(const Headers& headers, const std::string& name)
{
return findHeader(headers, name) != headers.end();
}
int SocketReadHTTPHeader( int inSock, HTTPHeader_t *inHeader )
{
int err =0;
char * buf;
char * dst;
char * lim;
char * end;
size_t len;
ssize_t n;
const char * value;
size_t valueSize;
buf = inHeader->buf;
dst = buf + inHeader->len;
lim = buf + sizeof( inHeader->buf );
for( ;; )
{
// If there's data from a previous read, move it to the front to search it first.
len = inHeader->extraDataLen;
if( len > 0 )
{
require_action( len <= (size_t)( lim - dst ), exit, err = kParamErr );
memmove( dst, inHeader->extraDataPtr, len );
inHeader->extraDataLen = 0;
}
else
{
//do
//{
n = read( inSock, dst, (size_t)( lim - dst ) );
// err = map_socket_value_errno( inSock, n >= 0, n );
//} while( err == EINTR );
if( n > 0 ) len = (size_t) n;
else { err = kConnectionErr; goto exit; }
//else goto exit;
}
dst += len;
inHeader->len += len;
if(findHeader( inHeader, &end ))
break ;
}
inHeader->len = (size_t)( end - buf );
err = HTTPHeaderParse( inHeader );
require_noerr( err, exit );
inHeader->extraDataLen = (size_t)( dst - end );
if(inHeader->extraDataPtr) {
free((uint8_t *)inHeader->extraDataPtr);
inHeader->extraDataPtr = 0;
}
if(inHeader->otaDataPtr) {
free((uint8_t *)inHeader->otaDataPtr);
inHeader->otaDataPtr = 0;
}
err = HTTPGetHeaderField( inHeader->buf, inHeader->len, "Content-Type", NULL, NULL, &value, &valueSize, NULL );
if(err == kNoErr && strnicmpx( value, valueSize, kMIMEType_MXCHIP_OTA ) == 0){
http_utils_log("Receive OTA data!");
err = PlatformFlashInitialize();
require_noerr(err, exit);
err = PlatformFlashWrite(&flashStorageAddress, (uint32_t *)end, inHeader->extraDataLen);
require_noerr(err, exit);
}else{
inHeader->extraDataPtr = calloc(inHeader->contentLength, sizeof(uint8_t));
require_action(inHeader->extraDataPtr, exit, err = kNoMemoryErr);
memcpy((uint8_t *)inHeader->extraDataPtr, end, inHeader->extraDataLen);
err = kNoErr;
}
exit:
return err;
}
void FetchClient::connect_ready()
{
#ifdef USE_OPENSSL
if ((m_state == None) & m_bHTTPS){
m_socket->setRaw(true);
m_socket->readBuffer.init(0);
HTTPSClient *https = new HTTPSClient(m_socket->socket());
if (!https->init()){
m_socket->error_state("Can't initialize HTTPS");
return;
}
m_state = SSLConnect;
m_socket->setSocket(https);
https->connect();
https->process();
return;
}
#endif
log(L_DEBUG, "HTTP connect ready");
m_socket->setRaw(true);
m_socket->writeBuffer.packetStart();
string proto;
string host;
string user;
string pass;
string uri;
string extra;
unsigned short port;
crackUrl(m_uri.c_str(), proto, host, port, user, pass, uri, extra);
if (!extra.empty()){
uri += "?";
uri += extra;
}
m_socket->writeBuffer
<< (m_post ? "POST " : "GET ")
<< uri.c_str()
<< " HTTP/1.0\r\n";
if (!findHeader("Host"))
m_socket->writeBuffer
<< "Host: "
<< host.c_str()
<< "\r\n";
if (!findHeader("User-Agent"))
m_socket->writeBuffer
<< "User-Agent: " PACKAGE "/" VERSION "\r\n";
if (!findHeader("Authorization") && !user.empty())
m_socket->writeBuffer
<< "Authorization: basic "
<< basic_auth(user.c_str(), pass.c_str()).c_str()
<< "\r\n";
if (m_post){
if (!findHeader("Content-Length"))
m_socket->writeBuffer
<< "Content-Length: "
<< number(m_post->size()).c_str()
<< "\r\n";
}
for (HEADERS_MAP::iterator it = m_hOut.begin(); it != m_hOut.end(); ++it){
m_socket->writeBuffer
<< (*it).first.c_str()
<< ": "
<< (*it).second.c_str()
<< "\r\n";
}
m_socket->writeBuffer
<< "\r\n";
if (m_post)
m_socket->writeBuffer.pack(m_post->data(), m_post->size());
log_packet(m_socket->writeBuffer, true, HTTPPacket);
m_socket->write();
m_socket->readBuffer.init(0);
m_socket->readBuffer.packetStart();
}
UnixHTTPURLInputStream::UnixHTTPURLInputStream(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo/*=0*/)
: BinHTTPInputStreamCommon(urlSource.getMemoryManager()),
fSocket(0)
{
//
// Convert the hostName to the platform's code page for gethostbyname and
// inet_addr functions.
//
MemoryManager *memoryManager = urlSource.getMemoryManager();
const XMLCh* hostName = urlSource.getHost();
if (hostName == 0)
ThrowXMLwithMemMgr1(NetAccessorException,
XMLExcepts::File_CouldNotOpenFile,
urlSource.getURLText(),
memoryManager);
char* hostNameAsCharStar = XMLString::transcode(hostName, memoryManager);
ArrayJanitor<char> janHostNameAsCharStar(hostNameAsCharStar, memoryManager);
XMLURL url(urlSource);
int redirectCount = 0;
SocketJanitor janSock(0);
do {
//
// Set up a socket.
//
#if HAVE_GETADDRINFO
struct addrinfo hints, *res, *ai;
CharBuffer portBuffer(10, memoryManager);
portBuffer.appendDecimalNumber(url.getPortNum());
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
int n = getaddrinfo(hostNameAsCharStar,portBuffer.getRawBuffer(),&hints, &res);
if(n != 0)
{
hints.ai_flags = AI_NUMERICHOST;
n = getaddrinfo(hostNameAsCharStar,portBuffer.getRawBuffer(),&hints, &res);
if(n != 0)
ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_TargetResolution, hostName, memoryManager);
}
janSock.reset();
for (ai = res; ai != NULL; ai = ai->ai_next) {
// Open a socket with the correct address family for this address.
fSocket = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
if (fSocket < 0)
continue;
janSock.reset(&fSocket);
if (connect(fSocket, ai->ai_addr, ai->ai_addrlen) < 0)
{
freeaddrinfo(res);
ThrowXMLwithMemMgr1(NetAccessorException,
XMLExcepts::NetAcc_ConnSocket, url.getURLText(), memoryManager);
}
break;
}
freeaddrinfo(res);
if (fSocket < 0)
{
ThrowXMLwithMemMgr1(NetAccessorException,
XMLExcepts::NetAcc_CreateSocket, url.getURLText(), memoryManager);
}
#else
struct hostent *hostEntPtr = 0;
struct sockaddr_in sa;
// Use the hostName in the local code page ....
if((hostEntPtr = gethostbyname(hostNameAsCharStar)) == NULL)
{
unsigned long numAddress = inet_addr(hostNameAsCharStar);
if ((hostEntPtr =
gethostbyaddr((char *) &numAddress,
sizeof(unsigned long), AF_INET)) == NULL)
{
ThrowXMLwithMemMgr1(NetAccessorException,
XMLExcepts::NetAcc_TargetResolution, hostName, memoryManager);
}
}
memset(&sa, '\0', sizeof(sockaddr_in)); // iSeries fix ??
memcpy((void *) &sa.sin_addr,
(const void *) hostEntPtr->h_addr, hostEntPtr->h_length);
sa.sin_family = hostEntPtr->h_addrtype;
sa.sin_port = htons((unsigned short)url.getPortNum());
janSock.reset();
fSocket = socket(hostEntPtr->h_addrtype, SOCK_STREAM, 0);
if(fSocket < 0)
{
ThrowXMLwithMemMgr1(NetAccessorException,
XMLExcepts::NetAcc_CreateSocket, url.getURLText(), memoryManager);
}
janSock.reset(&fSocket);
if(connect(fSocket, (struct sockaddr *) &sa, sizeof(sa)) < 0)
{
ThrowXMLwithMemMgr1(NetAccessorException,
XMLExcepts::NetAcc_ConnSocket, url.getURLText(), memoryManager);
}
#endif
int status = sendRequest(url, httpInfo);
if(status == 200) {
// HTTP 200 OK response means we're done.
break;
}
// a 3xx response means there was an HTTP redirect
else if(status >= 300 && status <= 307) {
redirectCount++;
XMLCh *newURLString = findHeader("Location");
ArrayJanitor<XMLCh> janNewURLString(newURLString, memoryManager);
if(newURLString == 0 || *newURLString == 0) {
ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::File_CouldNotOpenFile, url.getURLText(), memoryManager);
}
XMLURL newURL(memoryManager);
newURL.setURL(url, newURLString);
if(newURL.getProtocol() != XMLURL::HTTP) {
ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::File_CouldNotOpenFile, newURL.getURLText(), memoryManager);
}
url = newURL;
hostName = newURL.getHost();
if (hostName == 0)
ThrowXMLwithMemMgr1(NetAccessorException,
XMLExcepts::File_CouldNotOpenFile,
newURL.getURLText(),
memoryManager);
janHostNameAsCharStar.release();
hostNameAsCharStar = XMLString::transcode(hostName, memoryManager);
janHostNameAsCharStar.reset(hostNameAsCharStar, memoryManager);
}
else {
// Most likely a 404 Not Found error.
ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::File_CouldNotOpenFile, url.getURLText(), memoryManager);
}
} while(redirectCount < 6);
janSock.release();
}
bool AndroidFormat::isValid(const unsigned char *data, std::size_t size)
{
std::size_t headerIndex;
return findHeader(data, size, 512, &headerIndex);
}
int InternetDownloadFile(char *szUrl, char *cookie, char *userAgent, TCHAR **szData)
{
if (userAgent == NULL || userAgent[0] == 0)
userAgent = NETLIB_USER_AGENT;
NETLIBHTTPHEADER headers[5];
headers[0].szName = "User-Agent";
headers[0].szValue = userAgent;
headers[1].szName = "Cache-Control";
headers[1].szValue = "no-cache";
headers[2].szName = "Pragma";
headers[2].szValue = "no-cache";
headers[3].szName = "Connection";
headers[3].szValue = "close";
headers[4].szName = "Cookie";
headers[4].szValue = cookie;
// initialize the netlib request
NETLIBHTTPREQUEST nlhr = { sizeof(nlhr) };
nlhr.requestType = REQUEST_GET;
nlhr.flags = NLHRF_DUMPASTEXT | NLHRF_HTTP11 | NLHRF_PERSISTENT | NLHRF_REDIRECT;
nlhr.szUrl = szUrl;
nlhr.nlc = hNetlibHttp;
nlhr.headers = headers;
nlhr.headersCount = _countof(headers);
if (cookie == NULL || cookie[0] == 0)
--nlhr.headersCount;
// download the page
NETLIBHTTPREQUEST *nlhrReply = (NETLIBHTTPREQUEST*)CallService(MS_NETLIB_HTTPTRANSACTION, (WPARAM)hNetlibUser, (LPARAM)&nlhr);
if (nlhrReply == 0) {
// if the data does not downloaded successfully (ie. disconnected), then return 1000 as error code
*szData = (TCHAR*)mir_alloc(512);
// store the error code in szData
mir_tstrcpy(*szData, _T("NetLib error occurred!!"));
hNetlibHttp = NULL;
return NLHRF_REDIRECT;
}
// if the recieved code is 200 OK
int result;
if (nlhrReply->resultCode == 200) {
if (nlhrReply->dataLength) {
bool bIsUtf = false;
result = 0;
// allocate memory and save the retrieved data
int i = findHeader(nlhrReply, "Content-Type");
if (i != -1 && strstr(_strlwr((char*)nlhrReply->headers[i].szValue), "utf-8"))
bIsUtf = true;
else {
char* end = nlhrReply->pData;
for (;;) {
char* beg = strstr(end, "<meta");
if (beg == NULL) break;
else {
char* method, tmp;
end = strchr(beg, '>');
tmp = *end; *end = 0;
method = strstr(beg, "http-equiv=\"");
if (method && _strnicmp(method + 12, "Content-Type", 12) == 0 && strstr(method, "utf-8")) {
bIsUtf = true;
break;
}
else *end = tmp;
}
}
}
TCHAR *retVal = NULL;
if (bIsUtf)
retVal = mir_utf8decodeT(nlhrReply->pData);
if (retVal == NULL)
retVal = mir_a2t(nlhrReply->pData);
*szData = retVal;
}
else result = DATA_EMPTY;
}
// return error code if the recieved code is neither 200 OK nor 302 Moved
else {
*szData = (TCHAR*)mir_alloc(512);
// store the error code in szData
mir_sntprintf(*szData, 512, _T("Error occured! HTTP Error: %i\n"), nlhrReply->resultCode);
result = (int)nlhrReply->resultCode;
}
hNetlibHttp = nlhrReply->nlc;
// make a copy of the retrieved data, then free the memory of the http reply
CallService(MS_NETLIB_FREEHTTPREQUESTSTRUCT, 0, (LPARAM)nlhrReply);
return result;
}
int SocketReadHTTPHeader( int inSock, HTTPHeader_t *inHeader )
{
int err =0;
char * buf;
char * dst;
char * lim;
char * end;
size_t len;
ssize_t n;
const char * value;
size_t valueSize;
buf = inHeader->buf;
dst = buf + inHeader->len;
lim = buf + sizeof( inHeader->buf );
for( ;; )
{
if(findHeader( inHeader, &end ))
break ;
n = read( inSock, dst, (size_t)( lim - dst ) );
if( n > 0 ) len = (size_t) n;
else { err = kConnectionErr; goto exit; }
dst += len;
inHeader->len += len;
}
inHeader->len = (size_t)( end - buf );
err = HTTPHeaderParse( inHeader );
require_noerr( err, exit );
inHeader->extraDataLen = (size_t)( dst - end );
if(inHeader->extraDataPtr) {
free((uint8_t *)inHeader->extraDataPtr);
inHeader->extraDataPtr = 0;
}
if(inHeader->otaDataPtr) {
free((uint8_t *)inHeader->otaDataPtr);
inHeader->otaDataPtr = 0;
}
/* For MXCHIP OTA function, store extra data to OTA data temporary */
err = HTTPGetHeaderField( inHeader->buf, inHeader->len, "Content-Type", NULL, NULL, &value, &valueSize, NULL );
if(err == kNoErr && strnicmpx( value, valueSize, kMIMEType_MXCHIP_OTA ) == 0){
#ifdef MICO_FLASH_FOR_UPDATE
http_utils_log("Receive OTA data!");
err = MicoFlashInitialize( MICO_FLASH_FOR_UPDATE );
require_noerr(err, exit);
err = MicoFlashWrite(MICO_FLASH_FOR_UPDATE, &flashStorageAddress, (uint8_t *)end, inHeader->extraDataLen);
require_noerr(err, exit);
#else
http_utils_log("OTA flash memory is not existed!");
err = kUnsupportedErr;
#endif
goto exit;
}
/* For chunked extra data without content length */
if(inHeader->chunkedData == true){
inHeader->chunkedDataBufferLen = (inHeader->extraDataLen > 256)? inHeader->extraDataLen:256;
inHeader->chunkedDataBufferPtr = calloc(inHeader->chunkedDataBufferLen, sizeof(uint8_t)); //Make extra data buffer larger than chunk length
require_action(inHeader->chunkedDataBufferPtr, exit, err = kNoMemoryErr);
memcpy((uint8_t *)inHeader->chunkedDataBufferPtr, end, inHeader->extraDataLen);
inHeader->extraDataPtr = inHeader->chunkedDataBufferPtr;
return kNoErr;
}
/* Extra data with content length */
if (inHeader->contentLength != 0){ //Content length >0, create a memory buffer (Content length) and store extra data
size_t copyDataLen = (inHeader->contentLength >= inHeader->extraDataLen)? inHeader->contentLength:inHeader->extraDataLen;
inHeader->extraDataPtr = calloc(copyDataLen , sizeof(uint8_t));
require_action(inHeader->extraDataPtr, exit, err = kNoMemoryErr);
memcpy((uint8_t *)inHeader->extraDataPtr, end, copyDataLen);
err = kNoErr;
} /* Extra data without content length, data is ended by conntection close */
else if(inHeader->extraDataLen != 0){ //Content length =0, but extra data length >0, create a memory buffer (1500)and store extra data
inHeader->dataEndedbyClose = true;
inHeader->extraDataPtr = calloc(1500, sizeof(uint8_t));
require_action(inHeader->extraDataPtr, exit, err = kNoMemoryErr);
memcpy((uint8_t *)inHeader->extraDataPtr, end, inHeader->extraDataLen);
err = kNoErr;
}
else
return kNoErr;
exit:
return err;
}
int SocketReadHTTPHeader( int inSock, HTTPHeader_t *inHeader )
{
int err =0;
char * buf;
char * dst;
char * lim;
char * end;
size_t len;
ssize_t n;
buf = inHeader->buf;
dst = buf + inHeader->len;
lim = buf + sizeof( inHeader->buf );
for( ;; )
{
if(findHeader( inHeader, &end ))
break ;
n = read( inSock, dst, (size_t)( lim - dst ) );
if( n > 0 ) len = (size_t) n;
else {
err = kConnectionErr;
goto exit;
}
dst += len;
inHeader->len += len;
}
inHeader->len = (size_t)( end - buf );
err = HTTPHeaderParse( inHeader );
require_noerr( err, exit );
inHeader->extraDataLen = (size_t)( dst - end );
if(inHeader->extraDataPtr) {
free((uint8_t *)inHeader->extraDataPtr);
inHeader->extraDataPtr = 0;
}
/* For chunked extra data without content length */
if(inHeader->chunkedData == true) {
inHeader->chunkedDataBufferLen = (inHeader->extraDataLen > READ_LENGTH)? inHeader->extraDataLen:READ_LENGTH;
inHeader->chunkedDataBufferPtr = calloc(inHeader->chunkedDataBufferLen, sizeof(uint8_t)); //Make extra data buffer larger than chunk length
require_action(inHeader->chunkedDataBufferPtr, exit, err = kNoMemoryErr);
memcpy((uint8_t *)inHeader->chunkedDataBufferPtr, end, inHeader->extraDataLen);
inHeader->extraDataPtr = inHeader->chunkedDataBufferPtr;
return kNoErr;
}
/* Extra data with content length */
if (inHeader->contentLength != 0) { //Content length >0, create a memory buffer (Content length) and store extra data
size_t copyDataLen = (inHeader->contentLength >= inHeader->extraDataLen)? inHeader->extraDataLen : inHeader->contentLength;
if(inHeader->onReceivedDataCallback && (inHeader->onReceivedDataCallback)(inHeader, 0, (uint8_t *)end, copyDataLen, inHeader->userContext)==kNoErr) {
inHeader->isCallbackSupported = true;
inHeader->extraDataPtr = calloc(READ_LENGTH, sizeof(uint8_t));
require_action(inHeader->extraDataPtr, exit, err = kNoMemoryErr);
} else {
inHeader->isCallbackSupported = false;
inHeader->extraDataPtr = calloc(inHeader->contentLength , sizeof(uint8_t));
require_action(inHeader->extraDataPtr, exit, err = kNoMemoryErr);
memcpy((uint8_t *)inHeader->extraDataPtr, end, copyDataLen);
}
err = kNoErr;
} /* Extra data without content length, data is ended by conntection close */
// else if(inHeader->extraDataLen != 0){ //Content length =0, but extra data length >0, create a memory buffer (1500)and store extra data
// inHeader->dataEndedbyClose = true;
// inHeader->extraDataPtr = calloc(1500, sizeof(uint8_t));
// require_action(inHeader->extraDataPtr, exit, err = kNoMemoryErr);
// memcpy((uint8_t *)inHeader->extraDataPtr, end, inHeader->extraDataLen);
// (inHeader->onReceivedDataCallback)(inHeader, 0, (uint8_t *)inHeader->extraDataPtr, inHeader->extraDataLen, inHeader->userContext);
// err = kNoErr;
// }
else
return kNoErr;
exit:
return err;
}
/**
* \todo Good idea is to check \c #include directive again and realize what kind of
* open/close chars are used... depending on this do search for files in all configured
* paths or session's only...
*
* \todo Maybe not so good, cuz this method now called from \c scanForHeadersIncluded,
* so parse status is fresh enough...
*/
void DocumentInfo::updateStatus(State& s)
{
kDebug(DEBUG_AREA) << "Update status for range: " << s.range.get();
if (!s.range->isEmpty())
{
auto* doc = s.range->document();
auto filename = doc->text(s.range->toRange());
// NOTE After editing it is possible that opening '<' or '"' could
// appear as a start symbol of the range... just try to exclude it!
if (filename.startsWith('>') || filename.startsWith('"'))
{
filename.remove(0, 1);
auto shrinked = s.range->toRange();
shrinked.end().setColumn(shrinked.start().column() + 1);
s.range->setRange(shrinked);
}
// NOTE after autocompletion it is possible that closing '>' or '"' could
// appear as the last symbol of the range... just try to exclude it!
if (filename.endsWith('>') || filename.endsWith('"'))
{
filename.resize(filename.size() - 1);
auto shrinked = s.range->toRange();
shrinked.end().setColumn(shrinked.end().column() - 1);
s.range->setRange(shrinked);
}
// Reset status
s.status = Status::NotFound;
// Check if given header available
// 0) check CWD first if allowed or #include uses quites
auto candidates = QStringList{};
if (m_plugin->config().useCwd() || s.type == IncludeStyle::local)
{
auto uri = doc->url();
uri.setFileName(filename);
const auto& check = uri.path();
kDebug(DEBUG_AREA) << "check current dir: " << check;
if (QFileInfo{check}.exists())
{
s.status = Status::Ok;
candidates << check;
}
}
// 1) Try configured dirs then
candidates << findHeader(
filename
, m_plugin->config().sessionDirs()
, m_plugin->config().systemDirs()
);
candidates.removeDuplicates(); // Same file could be found more than once!
// Analyse found files and set status
if (candidates.empty())
s.status = Status::NotFound;
else if (candidates.size() == 1)
s.status = Status::Ok;
else
s.status = Status::MultipleMatches;
kDebug(DEBUG_AREA) << "#include filename=" << filename <<
", status=" << int(s.status) <<
", r=" << s.range.get()
;
auto* iface = qobject_cast<KTextEditor::MarkInterface*>(doc);
const auto line = s.range->start().line();
switch (s.status)
{
case Status::Ok:
iface->removeMark(
line
, KTextEditor::MarkInterface::Error | KTextEditor::MarkInterface::Warning
);
s.description.clear();
break;
case Status::NotFound:
iface->removeMark(
line
, KTextEditor::MarkInterface::Error | KTextEditor::MarkInterface::Warning
);
iface->setMarkPixmap(
KTextEditor::MarkInterface::Error
, KIcon("task-reject").pixmap(QSize(16, 16))
);
iface->addMark(line, KTextEditor::MarkInterface::Error);
s.description = i18nc("@info:tooltip", "File not found");
break;
case Status::MultipleMatches:
iface->removeMark(
line
, KTextEditor::MarkInterface::Error | KTextEditor::MarkInterface::Warning
);
iface->setMarkPixmap(
KTextEditor::MarkInterface::Warning
, KIcon("task-attention").pixmap(QSize(16, 16))
);
iface->addMark(line, KTextEditor::MarkInterface::Warning);
s.description = i18nc(
"@info:tooltip"
, "Multiple files matched: <filename>%1</filename>"
, candidates.join(", ")
);
break;
default:
assert(!"Impossible");
}
}
}
bool AndroidFormat::loadImage(const unsigned char *data, std::size_t size)
{
std::size_t headerIndex;
if (!findHeader(data, size, 512, &headerIndex)) {
LOGE("Failed to find Android header in boot image");
return false;
}
LOGD("Found Android boot image header at: %" PRIzu, headerIndex);
if (!loadHeader(data, size, headerIndex)) {
return false;
}
uint32_t pos = 0;
// Save kernel image
pos += headerIndex;
pos += sizeof(BootImageHeader);
pos += skipPadding(sizeof(BootImageHeader), mI10e->pageSize);
if (pos + mI10e->hdrKernelSize > size) {
LOGE("Kernel image exceeds boot image size by %" PRIzu " bytes",
pos + mI10e->hdrKernelSize - size);
return false;
}
mI10e->kernelImage.assign(data + pos, data + pos + mI10e->hdrKernelSize);
// Save ramdisk image
pos += mI10e->hdrKernelSize;
pos += skipPadding(mI10e->hdrKernelSize, mI10e->pageSize);
if (pos + mI10e->hdrRamdiskSize > size) {
LOGE("Ramdisk image exceeds boot image size by %" PRIzu " bytes",
pos + mI10e->hdrRamdiskSize - size);
return false;
}
mI10e->ramdiskImage.assign(data + pos, data + pos + mI10e->hdrRamdiskSize);
// Save second bootloader image
pos += mI10e->hdrRamdiskSize;
pos += skipPadding(mI10e->hdrRamdiskSize, mI10e->pageSize);
if (pos + mI10e->hdrSecondSize > size) {
LOGE("Second bootloader image exceeds boot image size by %" PRIzu " bytes",
pos + mI10e->hdrSecondSize - size);
return false;
}
// The second bootloader may not exist
if (mI10e->hdrSecondSize > 0) {
mI10e->secondImage.assign(data + pos, data + pos + mI10e->hdrSecondSize);
} else {
mI10e->secondImage.clear();
}
// Save device tree image
pos += mI10e->hdrSecondSize;
pos += skipPadding(mI10e->hdrSecondSize, mI10e->pageSize);
if (pos + mI10e->hdrDtSize > size) {
std::size_t diff = pos + mI10e->hdrDtSize - size;
LOGE("WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING");
LOGE("THIS BOOT IMAGE MAY NO LONGER BE BOOTABLE. YOU HAVE BEEN WARNED");
LOGE("Device tree image exceeds boot image size by %" PRIzu
" bytes and HAS BEEN TRUNCATED", diff);
LOGE("WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING");
mI10e->dtImage.assign(data + pos, data + pos + mI10e->hdrDtSize - diff);
} else {
mI10e->dtImage.assign(data + pos, data + pos + mI10e->hdrDtSize);
}
// The device tree image may not exist as well
if (mI10e->hdrDtSize == 0) {
mI10e->dtImage.clear();
}
pos += mI10e->hdrDtSize;
pos += skipPadding(mI10e->hdrDtSize, mI10e->pageSize);
return true;
}
void handleConnection(int socketfd) {
static char buffer[BUFFER_SIZE+1];
static char* headers[HEADER_LIMIT+1];
int i;
int headerCount=0;
//int requestSize = read(socketfd,buffer,BUFFER_SIZE);
int requestSize = readUntil(socketfd,crlfcrlfCheck,buffer,BUFFER_SIZE);
if (requestSize ==0 || requestSize == -1) {
fail("failed to read browser request");
}
logText(buffer);
int done = 0;
char mode = 0; /* */
for (i=0;i<requestSize;i++) {
switch(mode) {
case '\r':
if (buffer[i] == '\n') {
buffer[i-1]=0;
mode=0;
done = (*headers[headerCount]==0) || (headerCount++ == HEADER_LIMIT);
}
break;
case 0:
headers[headerCount]=&buffer[i];
default:
mode=buffer[i];
if (mode==0) done=1; /* catch headers containing zeros */
}
if (done) break;
}
int bodyStart=i+1;
int bodyLength=requestSize-bodyStart;
headers[headerCount]=NULL; /*null terminated list*/
logFormat("%d header lines\n",headerCount);
logText("we got some headers");
for (i=0; i<headerCount;i++) {
logFormat("%d: %s\n",i,headers[i]);
}
logText("That was them headers");
/*
logText("looking for User-Agent:");
char* userAgent=findHeader(0,headerCount,headers,"User-Agent:");
if (userAgent==NULL) {logText("No User-Agent");} else {logText(userAgent);}
*/
char* aCookie = findHeader(0,headerCount,headers,"Cookie:");
int uid=getUserInfo(aCookie);
logFormat("uid of %d\n",uid);
if (uid <= 0) {
if (strncmp("POST /login ",headers[0],12) == 0 ) {
//for a non-logged-in user POST to /login try and read user credentials.
logText("Login request received");
char userpass[300];
struct passwd* pwd = NULL;
strncpy(userpass,&buffer[bodyStart],300);
if (userpass[299] == 0) {
char* user = NULL;
char* pass = NULL;
user = strstr(userpass,"user="******"pass="******"I think the userName is '%s'\n",user);
//logFormat("I think the passWord is '%s'\n",pass);
pwd = checkUserPass(user,pass);
free(pass);
}
char* resultPage;
if (pwd != NULL) {
logText("setting cookie");
char token[33];
token[32]='\0';
makeAuthenticationToken(pwd->pw_uid,token,32);
char* pageHeaders;
asprintf(&pageHeaders,"Set-Cookie: %s; Secure; HttpOnly\r\nLocation: %s\r\n",token,loginRedirect);
logText(pageHeaders);
resultPage=
"<html><head></head><body"
"<div>Login Successful</div>"
"</body></html>";
sendHTMLPage(socketfd,"303 See Other",pageHeaders,resultPage);
free(pageHeaders);
} else {
resultPage=
"<html><head></head><body"
"<div>Login Failed</div>"
"</body></html>";
sendSimpleHTMLPage(socketfd,"401 Unauthorised",resultPage);
}
} else {
sendLoginPage(socketfd);
}
} else {
struct passwd *pw = getpwuid(uid);
setgid(uid);
setuid(uid);
setenv("HOME",pw->pw_dir,1);
setenv("USER",pw->pw_name,1);
setenv("SHELL",pw->pw_shell,1);
//if we get to here, the request sent a token identifying them as a
//valid user and we have dropped privileges to be that user.
//now we can set about serving the user request.
#ifdef NOTANOS
//support for a notanos websocket server.
char* upgrade = findHeader(0,headerCount,headers,"Upgrade:");
if (upgrade) {
//Try using websockets
char* websocket_key = findHeader(0,headerCount,headers,"Sec-WebSocket-Key:");
char* websocket_protocol = findHeader(0,headerCount,headers,"Sec-WebSocket-Protocol:");
char* websocket_version = findHeader(0,headerCount,headers,"Sec-WebSocket-Version:");
char* origin = findHeader(0,headerCount,headers,"Origin:");
webSocketUpgrade(socketfd,websocket_key,websocket_protocol,websocket_version,origin);
//webSocketUpgrade should never return
}
#endif
if (strncmp("GET ",headers[0],4) == 0 ) {
char* nameStart=headers[0]+4;
int nameLen = strcspn(nameStart," ");
char* urlName=strndup(nameStart,nameLen);
char* fileName=url_decode(urlName);
char* queryStart=strchr(fileName,'?');
if (queryStart != NULL) *queryStart++='\0';
logFormat("url request '%s'\n",urlName);
logFormat("filename request '%s'\n",fileName);
char* newFileName=expandFilename(fileName);
free(fileName); fileName=newFileName;
char* contentType=getContentType(fileName);
struct stat fileInfo;
int res=stat(fileName,&fileInfo);
if (res !=0) {
if (errno == EACCES) {
sendSimpleHTMLPage(socketfd,"403 Forbidden","403: Forbidden");
} else {
sendSimpleHTMLPage(socketfd,"404 Not Found","404: Not Found");
}
} else {
if (S_ISREG(fileInfo.st_mode)) {
int filefd=open(fileName,O_RDONLY);
if (filefd < 0) {
sendSimpleHTMLPage(socketfd,"403 Forbidden","403: Forbidden");
} else {
sendFileChunked(socketfd,"200 OK",filefd,contentType);
close(filefd);
}
}
else if (S_ISDIR(fileInfo.st_mode)) {
char* command;
char* awkline = "BEGIN {printf(\"{\\\"path\\\":\\\"%s\\\",\\n \\\"contents\\\":[\\n\",path)} END{print\"\\n ]\\n};\\n\"} NR > 2 { printf(\",\\n\") } NR >1 { printf(\" {\\\"filename\\\":\\\"%s\\\", \\\"attributes\\\":\\\"%s\\\", \\\"owner\\\":\\\"%s\\\", \\\"size\\\":%s}\", $9, $1, $3, $5) }";
//int commandLength = asprintf(&command,"ls -AlQ %s| awk -v path=%s '%s'",fileName,fileName,awkline);
int commandLength = asprintf(&command,"./jsondir '%s'",fileName);
logText(command);
if (commandLength>0) {
FILE* commandPipe = popen(command,"r");
if (commandPipe) {
int commandfd=(fileno(commandPipe));
sendFileChunked(socketfd,"200 OK",commandfd,"application/json");
pclose(commandPipe);
} else {
sendSimpleHTMLPage(socketfd,"500 Internal Server Error","popen failure");
}
free(command);
} else {
sendSimpleHTMLPage(socketfd,"200 OK","That's a directory");
}
}
}
free(fileName);
free(contentType);
free(urlName);
}
}
logText("done response, closing connection");
sleep(1);
close(socketfd);
exit(1);
}
