static int32_t ServeStaticResource(OrthancPluginRestOutput* output,
const char* url,
const OrthancPluginHttpRequest* request)
{
if (request->method != OrthancPluginHttpMethod_Get)
{
OrthancPluginSendMethodNotAllowed(context, output, "GET");
return 0;
}
std::string path = "/" + std::string(request->groups[0]);
const char* mime = GetMimeType(path);
try
{
std::string s;
Orthanc::EmbeddedResources::GetDirectoryResource
(s, Orthanc::EmbeddedResources::STATIC_RESOURCES, path.c_str());
const char* resource = s.size() ? s.c_str() : NULL;
OrthancPluginAnswerBuffer(context, output, resource, s.size(), mime);
return 0;
}
catch (std::runtime_error&)
{
std::string s = "Unknown static resource in plugin: " + std::string(request->groups[0]);
OrthancPluginLogError(context, s.c_str());
OrthancPluginSendHttpStatusCode(context, output, 404);
return 0;
}
}
void Http::SendFile(char *path, struct stat *st)
{
const char *mime_type = GetMimeType(strrchr(path, '.'));
SendHeader(mime_type, st->st_size, 200);
if (strcmp(request.request_method, "HEAD") != 0)
SendFileStream(path, st);
}
std::string CMime::GetMimeType(const CFileItem &item)
{
std::string path = item.GetPath();
if (item.HasVideoInfoTag() && !item.GetVideoInfoTag()->GetPath().empty())
path = item.GetVideoInfoTag()->GetPath();
else if (item.HasMusicInfoTag() && !item.GetMusicInfoTag()->GetURL().empty())
path = item.GetMusicInfoTag()->GetURL();
return GetMimeType(URIUtils::GetExtension(path));
}
OP_STATUS ContentDetector::IsTextOrBinary(URLContentType &url_type, OpStringC8 &mime_type)
{
unsigned long length = MIN(m_length, DETERMINISTIC_HEADER_LENGTH);
const unsigned char UTF16BE_BOM[2] = {0xFE, 0xFF};
const unsigned char UTF16LE_BOM[2] = {0xFF, 0xFE};
const unsigned char UTF8_BOM[3] = {0xEF, 0xBB, 0xBF};
if (length >= 3)
{
if (op_memcmp(m_octets, UTF16BE_BOM, 2) == 0 ||
op_memcmp(m_octets, UTF16LE_BOM, 2) == 0 ||
op_memcmp(m_octets, UTF8_BOM, 3) == 0)
{
url_type = URL_TEXT_CONTENT;
mime_type = "text/plain";
return OpStatus::OK;
}
}
if (!HasBinaryOctet(m_octets, length))
{
m_deterministic = m_length >= DETERMINISTIC_HEADER_LENGTH;
url_type = URL_TEXT_CONTENT;
mime_type = "text/plain";
return OpStatus::OK;
}
if (m_compliancy_type == WEB)
{
CharsetDetector detector(NULL);
detector.PeekAtBuffer(m_octets, length);
if (detector.GetDetectedCharset())
{
url_type = URL_TEXT_CONTENT;
mime_type = "text/plain";
}
}
int found_at_index;
RETURN_IF_ERROR(LookUpInSniffTable(m_octets, length, TRUE, TRUE, FALSE, UNDETERMINED, found_at_index));
if (found_at_index >= 0)
{
ContentDetectorPatternData pd = GetPatternData(found_at_index);
url_type = pd.content_type;
mime_type = GetMimeType(found_at_index);
}
else
{
url_type = URL_UNKNOWN_CONTENT;
mime_type = "application/octet-stream";
}
return OpStatus::OK;
}
/*******************************************************************
* Get file mime type
*
*******************************************************************/
int GetFileMimeType(char *filename)
{
char *p;
if((p = strrchr(filename, '.')) != NULL)
p = p+1;
else
p = filename;
return GetMimeType(p);
}
/*----------------------------------------------------------------------
| CUPnPRenderer::ProcessHttpRequest
+---------------------------------------------------------------------*/
NPT_Result
CUPnPRenderer::ProcessHttpGetRequest(NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response)
{
// get the address of who sent us some data back
NPT_String ip_address = context.GetRemoteAddress().GetIpAddress().ToString();
NPT_String method = request.GetMethod();
NPT_String protocol = request.GetProtocol();
NPT_HttpUrl url = request.GetUrl();
if (url.GetPath() == "/thumb") {
NPT_HttpUrlQuery query(url.GetQuery());
NPT_String filepath = query.GetField("path");
if (!filepath.IsEmpty()) {
NPT_HttpEntity* entity = response.GetEntity();
if (entity == NULL) return NPT_ERROR_INVALID_STATE;
// check the method
if (request.GetMethod() != NPT_HTTP_METHOD_GET &&
request.GetMethod() != NPT_HTTP_METHOD_HEAD) {
response.SetStatus(405, "Method Not Allowed");
return NPT_SUCCESS;
}
// prevent hackers from accessing files outside of our root
if ((filepath.Find("/..") >= 0) || (filepath.Find("\\..") >=0)) {
return NPT_FAILURE;
}
#if 1
std::string path;
//url
#else
// open the file
CStdString path = CURL::Decode((const char*) filepath);
#endif
NPT_File file(path.c_str());
NPT_Result result = file.Open(NPT_FILE_OPEN_MODE_READ);
if (NPT_FAILED(result)) {
response.SetStatus(404, "Not Found");
return NPT_SUCCESS;
}
NPT_InputStreamReference stream;
file.GetInputStream(stream);
entity->SetContentType(GetMimeType(filepath));
entity->SetInputStream(stream, true);
return NPT_SUCCESS;
}
}
return PLT_MediaRenderer::ProcessHttpGetRequest(request, context, response);
}
bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
{
wxString s;
if (GetMimeType(&s))
{
mimeTypes.Clear();
mimeTypes.Add(s);
return TRUE;
}
else
return FALSE;
}
bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
{
wxString s;
if ( !GetMimeType(&s) )
{
return false;
}
mimeTypes.Clear();
mimeTypes.Add(s);
return true;
}
OP_STATUS ContentDetector::IsImage(URLContentType &url_type, OpStringC8 &mime_type)
{
if (m_official_mime_type.CompareI("image/svg+xml") == 0)
return OpStatus::OK;
int found_at_index;
RETURN_IF_ERROR(LookUpInSniffTable(m_octets, m_length, FALSE, TRUE, TRUE, IMAGE, found_at_index));
if (found_at_index >= 0)
{
ContentDetectorPatternData pd = GetPatternData(found_at_index);
url_type = pd.content_type;
mime_type = GetMimeType(found_at_index);
}
return OpStatus::OK;
}
void ServerContext::AnswerAttachment(RestApiOutput& output,
const std::string& instancePublicId,
FileContentType content)
{
FileInfo attachment;
if (!index_.LookupAttachment(attachment, instancePublicId, content))
{
throw OrthancException(ErrorCode_InternalError);
}
accessor_.SetCompressionForNextOperations(attachment.GetCompressionType());
std::auto_ptr<HttpFileSender> sender(accessor_.ConstructHttpFileSender(attachment.GetUuid(), attachment.GetContentType()));
sender->SetContentType(GetMimeType(content));
sender->SetDownloadFilename(instancePublicId + ".dcm");
output.AnswerFile(*sender);
}
OP_STATUS ContentDetector::IsVideo(URLContentType &url_type, OpStringC8 &mime_type)
{
unsigned long length = MIN(m_length, DETERMINISTIC_HEADER_LENGTH);
int found_at_index;
RETURN_IF_ERROR(LookUpInSniffTable(m_octets, length, FALSE, TRUE, TRUE, VIDEO, found_at_index));
if (found_at_index >= 0)
{
ContentDetectorPatternData pd = GetPatternData(found_at_index);
url_type = pd.content_type;
mime_type = GetMimeType(found_at_index);
}
else if (HasMP4Signature(m_octets, length))
{
url_type = URL_MEDIA_CONTENT;
mime_type = "video/mp4";
}
m_deterministic = m_length >= DETERMINISTIC_HEADER_LENGTH;
return OpStatus::OK;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ M a g i c k T o M i m e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% MagickToMime() returns the officially registered (or de facto) MIME
% media-type corresponding to a magick string. If there is no registered
% media-type, then the string "image/x-magick" (all lower case) is returned.
% The returned string must be deallocated by the user.
%
% The format of the MagickToMime method is:
%
% char *MagickToMime(const char *magick)
%
% A description of each parameter follows.
%
% o magick: ImageMagick format specification "magick" tag.
%
*/
MagickExport char *MagickToMime(const char *magick)
{
char
filename[MagickPathExtent],
media[MagickPathExtent];
const MimeInfo
*mime_info;
ExceptionInfo
*exception;
(void) FormatLocaleString(filename,MagickPathExtent,"file.%s",magick);
LocaleLower(filename);
exception=AcquireExceptionInfo();
mime_info=GetMimeInfo(filename,(unsigned char *) " ",1,exception);
exception=DestroyExceptionInfo(exception);
if (mime_info != (const MimeInfo *) NULL)
return(ConstantString(GetMimeType(mime_info)));
(void) FormatLocaleString(media,MagickPathExtent,"image/x-%s",magick);
LocaleLower(media+8);
return(ConstantString(media));
}
std::string CMime::GetMimeType(const CURL &url, bool lookup)
{
std::string strMimeType;
if( url.IsProtocol("shout") || url.IsProtocol("http") || url.IsProtocol("https"))
{
// If lookup is false, bail out early to leave mime type empty
if (!lookup)
return strMimeType;
std::string strmime;
XFILE::CCurlFile::GetMimeType(url, strmime);
// try to get mime-type again but with an NSPlayer User-Agent
// in order for server to provide correct mime-type. Allows us
// to properly detect an MMS stream
if (StringUtils::StartsWithNoCase(strmime, "video/x-ms-"))
XFILE::CCurlFile::GetMimeType(url, strmime, "NSPlayer/11.00.6001.7000");
// make sure there are no options set in mime-type
// mime-type can look like "video/x-ms-asf ; charset=utf8"
size_t i = strmime.find(';');
if(i != std::string::npos)
strmime.erase(i, strmime.length() - i);
StringUtils::Trim(strmime);
strMimeType = strmime;
}
else
strMimeType = GetMimeType(url.GetFileType());
// if it's still empty set to an unknown type
if (strMimeType.empty())
strMimeType = "application/octet-stream";
return strMimeType;
}
/*
void CIPFilter::UpdateIPFilterURL()
*/
void CIPFilter::UpdateIPFilterURL(uint32 uNewVersion)
// <== Advanced Updates [MorphXT/Stulle] - Stulle
{
bool bHaveNewFilterFile = false;
CString url = thePrefs.GetAutoUpdateIPFilter_URL();
SYSTEMTIME SysTime;
if (!url.IsEmpty())
{
CString strTempFilePath;
_tmakepathlimit(strTempFilePath.GetBuffer(MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T("tmp"));
strTempFilePath.ReleaseBuffer();
CHttpDownloadDlg dlgDownload;
dlgDownload.m_strTitle = GetResString(IDS_DWL_IPFILTERFILE);
dlgDownload.m_sURLToDownload = url;
dlgDownload.m_sFileToDownloadInto = strTempFilePath;
if (PathFileExists(GetDefaultFilePath()))
memcpy(&SysTime, &thePrefs.m_IPfilterVersion, sizeof(SYSTEMTIME));
else
memset(&SysTime, 0, sizeof(SYSTEMTIME));
// ==> Advanced Updates [MorphXT/Stulle] - Stulle
if(thePrefs.IsIPFilterViaDynDNS())
dlgDownload.m_pLastModifiedTime = NULL;
else
// <== Advanced Updates [MorphXT/Stulle] - Stulle
dlgDownload.m_pLastModifiedTime = &SysTime; //Xman remark: m_pLastModifiedTime is a pointer which points to the SysTime-struct
if (dlgDownload.DoModal() != IDOK)
{
(void)_tremove(strTempFilePath);
CString strError = GetResString(IDS_DWLIPFILTERFAILED);
if (!dlgDownload.GetError().IsEmpty())
strError += _T("\r\n\r\n") + dlgDownload.GetError();
AfxMessageBox(strError, MB_ICONERROR);
return;
}
// ==> Advanced Updates [MorphXT/Stulle] - Stulle
/*
if (dlgDownload.m_pLastModifiedTime == NULL)
*/
if (thePrefs.IsIPFilterViaDynDNS() == false && dlgDownload.m_pLastModifiedTime == NULL)
// <== Advanced Updates [MorphXT/Stulle] - Stulle
return;
CString strMimeType;
GetMimeType(strTempFilePath, strMimeType);
bool bIsArchiveFile = false;
bool bUncompressed = false;
CZIPFile zip;
if (zip.Open(strTempFilePath))
{
bIsArchiveFile = true;
CZIPFile::File* zfile = zip.GetFile(_T("guarding.p2p"));
if (zfile == NULL)
zfile = zip.GetFile(_T("ipfilter.dat"));
if (zfile)
{
CString strTempUnzipFilePath;
_tmakepathlimit(strTempUnzipFilePath.GetBuffer(_MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T(".unzip.tmp"));
strTempUnzipFilePath.ReleaseBuffer();
if (zfile->Extract(strTempUnzipFilePath))
{
zip.Close();
zfile = NULL;
if (_tremove(theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to remove default IP filter file \"%s\" - %hs\n"), theApp.ipfilter->GetDefaultFilePath(), strerror(errno));
if (_trename(strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to rename uncompressed IP filter file \"%s\" to default IP filter file \"%s\" - %hs\n"), strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath(), strerror(errno));
if (_tremove(strTempFilePath) != 0)
TRACE(_T("*** Error: Failed to remove temporary IP filter file \"%s\" - %hs\n"), strTempFilePath, strerror(errno));
bUncompressed = true;
bHaveNewFilterFile = true;
}
else {
CString strError;
strError.Format(GetResString(IDS_ERR_IPFILTERZIPEXTR), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
}
else {
CString strError;
strError.Format(GetResString(IDS_ERR_IPFILTERCONTENTERR), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
zip.Close();
}
else if (strMimeType.CompareNoCase(_T("application/x-rar-compressed")) == 0)
{
bIsArchiveFile = true;
CRARFile rar;
if (rar.Open(strTempFilePath))
{
CString strFile;
if (rar.GetNextFile(strFile)
&& (strFile.CompareNoCase(_T("ipfilter.dat")) == 0 || strFile.CompareNoCase(_T("guarding.p2p")) == 0))
{
CString strTempUnzipFilePath;
_tmakepathlimit(strTempUnzipFilePath.GetBuffer(MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T(".unzip.tmp"));
strTempUnzipFilePath.ReleaseBuffer();
if (rar.Extract(strTempUnzipFilePath))
{
rar.Close();
if (_tremove(theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to remove default IP filter file \"%s\" - %hs\n"), theApp.ipfilter->GetDefaultFilePath(), strerror(errno));
if (_trename(strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to rename uncompressed IP filter file \"%s\" to default IP filter file \"%s\" - %hs\n"), strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath(), strerror(errno));
if (_tremove(strTempFilePath) != 0)
TRACE(_T("*** Error: Failed to remove temporary IP filter file \"%s\" - %hs\n"), strTempFilePath, strerror(errno));
bUncompressed = true;
bHaveNewFilterFile = true;
}
else
{
CString strError;
strError.Format(_T("Failed to extract IP filter file from RAR file \"%s\"."), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
}
else
{
CString strError;
strError.Format(_T("Failed to find IP filter file \"guarding.p2p\" or \"ipfilter.dat\" in RAR file \"%s\"."), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
rar.Close();
}
else
{
CString strError;
strError.Format(_T("Failed to open file \"%s\".\r\n\r\nInvalid file format?\r\n\r\nDownload latest version of UNRAR.DLL from http://www.rarlab.com and copy UNRAR.DLL into eMule installation folder."), url);
AfxMessageBox(strError, MB_ICONERROR);
}
}
else
{
CGZIPFile gz;
if (gz.Open(strTempFilePath))
{
bIsArchiveFile = true;
CString strTempUnzipFilePath;
_tmakepathlimit(strTempUnzipFilePath.GetBuffer(_MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T(".unzip.tmp"));
strTempUnzipFilePath.ReleaseBuffer();
// add filename and extension of uncompressed file to temporary file
CString strUncompressedFileName = gz.GetUncompressedFileName();
if (!strUncompressedFileName.IsEmpty())
{
strTempUnzipFilePath += _T('.');
strTempUnzipFilePath += strUncompressedFileName;
}
if (gz.Extract(strTempUnzipFilePath))
{
gz.Close();
if (_tremove(theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to remove default IP filter file \"%s\" - %hs\n"), theApp.ipfilter->GetDefaultFilePath(), strerror(errno));
if (_trename(strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to rename uncompressed IP filter file \"%s\" to default IP filter file \"%s\" - %hs\n"), strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath(), strerror(errno));
if (_tremove(strTempFilePath) != 0)
TRACE(_T("*** Error: Failed to remove temporary IP filter file \"%s\" - %hs\n"), strTempFilePath, strerror(errno));
bUncompressed = true;
bHaveNewFilterFile = true;
}
else {
CString strError;
strError.Format(GetResString(IDS_ERR_IPFILTERZIPEXTR), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
}
gz.Close();
}
if (!bIsArchiveFile && !bUncompressed)
{
// Check first lines of downloaded file for potential HTML content (e.g. 404 error pages)
bool bValidIPFilterFile = true;
FILE* fp = _tfsopen(strTempFilePath, _T("rb"), _SH_DENYWR);
if (fp)
{
char szBuff[16384];
int iRead = fread(szBuff, 1, _countof(szBuff)-1, fp);
if (iRead <= 0)
bValidIPFilterFile = false;
else
{
szBuff[iRead-1] = '\0';
const char* pc = szBuff;
while (*pc == ' ' || *pc == '\t' || *pc == '\r' || *pc == '\n')
pc++;
if (strnicmp(pc, "<html", 5) == 0
|| strnicmp(pc, "<xml", 4) == 0
|| strnicmp(pc, "<!doc", 5) == 0)
{
bValidIPFilterFile = false;
}
}
fclose(fp);
}
if (bValidIPFilterFile)
{
(void)_tremove(theApp.ipfilter->GetDefaultFilePath());
VERIFY( _trename(strTempFilePath, theApp.ipfilter->GetDefaultFilePath()) == 0 );
bHaveNewFilterFile = true;
}
else
{
AfxMessageBox(GetResString(IDS_DWLIPFILTERFAILED), MB_ICONERROR);
}
}
}
else
{
AfxMessageBox(_T("Failed to auto-update IPFilter. No URL given"), MB_ICONERROR);
return;
}
// ==> Advanced Updates [MorphXT/Stulle] - Stulle
/*
struct tm tmTemp;
thePrefs.m_last_ipfilter_check = safe_mktime(CTime::GetCurrentTime().GetLocalTm(&tmTemp));
*/
// <== Advanced Updates [MorphXT/Stulle] - Stulle
if (bHaveNewFilterFile)
{
LoadFromDefaultFile();
if (thePrefs.GetFilterServerByIP())
theApp.emuledlg->serverwnd->serverlistctrl.RemoveAllFilteredServers();
}
// In case we received an invalid IP-filter file (e.g. an 404 HTML page with HTTP status "OK"),
// warn the user that there are no IP-filters available any longer.
if (bHaveNewFilterFile && theApp.ipfilter->GetIPFilter().GetCount() == 0)
{
CString strLoaded;
strLoaded.Format(GetResString(IDS_IPFILTERLOADED), theApp.ipfilter->GetIPFilter().GetCount());
CString strError;
strError.Format(_T("%s\r\n\r\n%s"), GetResString(IDS_DWLIPFILTERFAILED), strLoaded);
AfxMessageBox(strError, MB_ICONERROR);
return;
}
//everything fine. update the stored version
if (bHaveNewFilterFile)
// ==> Advanced Updates [MorphXT/Stulle] - Stulle
/*
memcpy(&thePrefs.m_IPfilterVersion, &SysTime, sizeof SysTime);
*/
{
thePrefs.m_uIPFilterVersionNum = uNewVersion;
if(thePrefs.IsIPFilterViaDynDNS())
{
memset(&SysTime, 0, sizeof(SYSTEMTIME));
if(theApp.emuledlg->preferenceswnd &&
theApp.emuledlg->preferenceswnd->m_wndScar &&
theApp.emuledlg->preferenceswnd->m_wndScar.m_IpFilterTime)
{
CString strBuffer = NULL;
strBuffer.Format(_T("v%u"), thePrefs.GetIPFilterVersionNum());
theApp.emuledlg->preferenceswnd->m_wndScar.m_IpFilterTime.SetWindowText(strBuffer);
}
}
else
memcpy(&thePrefs.m_IPfilterVersion, &SysTime, sizeof SysTime);
}
else
{
thePrefs.m_uIPFilterVersionNum = 0;
memset(&SysTime, 0, sizeof(SYSTEMTIME));
if(thePrefs.IsIPFilterViaDynDNS())
{
if(theApp.emuledlg->preferenceswnd &&
theApp.emuledlg->preferenceswnd->m_wndScar &&
theApp.emuledlg->preferenceswnd->m_wndScar.m_IpFilterTime)
theApp.emuledlg->preferenceswnd->m_wndScar.m_IpFilterTime.SetWindowText(GetResString(IDS_DL_NONE));
}
}
if(thePrefs.IsIPFilterViaDynDNS() == false &&
theApp.emuledlg->preferenceswnd &&
theApp.emuledlg->preferenceswnd->m_wndScar &&
theApp.emuledlg->preferenceswnd->m_wndScar.m_IpFilterTime)
{
TCHAR sTime[30];
sTime[0] = _T('\0');
SysTimeToStr(thePrefs.GetIPfilterVersion(), sTime);
theApp.emuledlg->preferenceswnd->m_wndScar.m_IpFilterTime.SetWindowText(sTime);
}
// <== Advanced Updates [MorphXT/Stulle] - Stulle
}
OP_STATUS ContentDetector::IsUnknownType(URLContentType &url_type, OpStringC8 &mime_type)
{
unsigned long length = MIN(m_length, DETERMINISTIC_HEADER_LENGTH);
int found_at_index;
RETURN_IF_ERROR(LookUpInSniffTable(m_octets, length, FALSE, TRUE, FALSE, UNDETERMINED, found_at_index));
if (found_at_index >= 0)
{
ContentDetectorPatternData pd = GetPatternData(found_at_index);
// if the found content type is not displayable then try to find by extension (if feature enabled)
if ((m_extension_use_allowed || m_compliancy_type == WEB) && !IsDisplayable(pd.content_type))
{
BOOL found = FALSE;
RETURN_IF_ERROR(TryToFindByExtension(url_type, mime_type, found));
if (found)
return OpStatus::OK;
}
url_type = pd.content_type;
mime_type = GetMimeType(found_at_index);
return OpStatus::OK;
}
if (m_compliancy_type == WEB)
{
int image_type = imgManager->CheckImageType((const unsigned char *)m_octets, length);
if (image_type > 0)
{
url_type = (URLContentType)image_type;
const char *mimetype = g_viewers->GetContentTypeString(url_type);
mime_type = mimetype ? mimetype : "image/unknown";
return OpStatus::OK;
}
}
if (HasMP4Signature(m_octets, length))
{
url_type = URL_MEDIA_CONTENT;
mime_type = "video/mp4";
return OpStatus::OK;
}
if (HasBinaryOctet(m_octets, length))
{
BOOL found = FALSE;
if (m_extension_use_allowed || m_compliancy_type == WEB)
TryToFindByExtension(url_type, mime_type, found);
if (!found)
{
url_type = URL_UNKNOWN_CONTENT;
mime_type = "application/octet-stream";
}
}
else
{
m_deterministic = m_length >= DETERMINISTIC_HEADER_LENGTH;
url_type = URL_TEXT_CONTENT;
mime_type = "text/plain";
}
return OpStatus::OK;
}
void ItkImageIO::Write()
{
const mitk::Image *image = dynamic_cast<const mitk::Image *>(this->GetInput());
if (image == NULL)
{
mitkThrow() << "Cannot write non-image data";
}
// Switch the current locale to "C"
LocaleSwitch localeSwitch("C");
// Clone the image geometry, because we might have to change it
// for writing purposes
BaseGeometry::Pointer geometry = image->GetGeometry()->Clone();
// Check if geometry information will be lost
if (image->GetDimension() == 2 && !geometry->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might "
"consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = geometry->GetSpacing();
mitk::Point3D origin = geometry->GetOrigin();
geometry->SetIndexToWorldTransform(affTrans);
geometry->SetSpacing(spacing);
geometry->SetOrigin(origin);
}
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
const unsigned int dimension = image->GetDimension();
const unsigned int *const dimensions = image->GetDimensions();
const mitk::PixelType pixelType = image->GetPixelType();
const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
const mitk::Point3D mitkOrigin = geometry->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
// though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
// Set the necessary information for imageIO
m_ImageIO->SetNumberOfDimensions(dimension);
m_ImageIO->SetPixelType(pixelType.GetPixelType());
m_ImageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
m_ImageIO->SetNumberOfComponents(pixelType.GetNumberOfComponents());
itk::ImageIORegion ioRegion(dimension);
for (unsigned int i = 0; i < dimension; i++)
{
m_ImageIO->SetDimensions(i, dimensions[i]);
m_ImageIO->SetSpacing(i, spacing4D[i]);
m_ImageIO->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
{
direction4D[3] = 1; // homogenous component
}
else
{
direction4D[3] = 0;
}
vnl_vector<double> axisDirection(dimension);
for (unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
m_ImageIO->SetDirection(i, axisDirection);
ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
}
// use compression if available
m_ImageIO->UseCompressionOn();
m_ImageIO->SetIORegion(ioRegion);
m_ImageIO->SetFileName(path);
// Handle time geometry
const ArbitraryTimeGeometry *arbitraryTG = dynamic_cast<const ArbitraryTimeGeometry *>(image->GetTimeGeometry());
if (arbitraryTG)
{
itk::EncapsulateMetaData<std::string>(m_ImageIO->GetMetaDataDictionary(),
PROPERTY_KEY_TIMEGEOMETRY_TYPE,
ArbitraryTimeGeometry::GetStaticNameOfClass());
std::stringstream stream;
stream << arbitraryTG->GetTimeBounds(0)[0];
for (TimeStepType pos = 0; pos < arbitraryTG->CountTimeSteps(); ++pos)
{
stream << " " << arbitraryTG->GetTimeBounds(pos)[1];
}
std::string data = stream.str();
itk::EncapsulateMetaData<std::string>(
m_ImageIO->GetMetaDataDictionary(), PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS, data);
}
// Handle properties
mitk::PropertyList::Pointer imagePropertyList = image->GetPropertyList();
for (const auto &property : *imagePropertyList->GetMap())
{
IPropertyPersistence::InfoResultType infoList =
mitk::CoreServices::GetPropertyPersistence()->GetInfo(property.first, GetMimeType()->GetName(), true);
if (infoList.empty())
{
continue;
}
std::string value = infoList.front()->GetSerializationFunction()(property.second);
if (value == mitk::BaseProperty::VALUE_CANNOT_BE_CONVERTED_TO_STRING)
{
continue;
}
std::string key = infoList.front()->GetKey();
itk::EncapsulateMetaData<std::string>(m_ImageIO->GetMetaDataDictionary(), key, value);
}
ImageReadAccessor imageAccess(image);
m_ImageIO->Write(imageAccess.GetData());
}
catch (const std::exception &e)
{
mitkThrow() << e.what();
}
}
std::vector<BaseData::Pointer> ItkImageIO::Read()
{
std::vector<BaseData::Pointer> result;
mitk::LocaleSwitch localeSwitch("C");
Image::Pointer image = Image::New();
const unsigned int MINDIM = 2;
const unsigned int MAXDIM = 4;
const std::string path = this->GetLocalFileName();
MITK_INFO << "loading " << path << " via itk::ImageIOFactory... " << std::endl;
// Check to see if we can read the file given the name or prefix
if (path.empty())
{
mitkThrow() << "Empty filename in mitk::ItkImageIO ";
}
// Got to allocate space for the image. Determine the characteristics of
// the image.
m_ImageIO->SetFileName(path);
m_ImageIO->ReadImageInformation();
unsigned int ndim = m_ImageIO->GetNumberOfDimensions();
if (ndim < MINDIM || ndim > MAXDIM)
{
MITK_WARN << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim
<< " dimensions! Reading as 4D.";
ndim = MAXDIM;
}
itk::ImageIORegion ioRegion(ndim);
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[MAXDIM];
dimensions[0] = 0;
dimensions[1] = 0;
dimensions[2] = 0;
dimensions[3] = 0;
ScalarType spacing[MAXDIM];
spacing[0] = 1.0f;
spacing[1] = 1.0f;
spacing[2] = 1.0f;
spacing[3] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for (i = 0; i < ndim; ++i)
{
ioStart[i] = 0;
ioSize[i] = m_ImageIO->GetDimensions(i);
if (i < MAXDIM)
{
dimensions[i] = m_ImageIO->GetDimensions(i);
spacing[i] = m_ImageIO->GetSpacing(i);
if (spacing[i] <= 0)
spacing[i] = 1.0f;
}
if (i < 3)
{
origin[i] = m_ImageIO->GetOrigin(i);
}
}
ioRegion.SetSize(ioSize);
ioRegion.SetIndex(ioStart);
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
m_ImageIO->SetIORegion(ioRegion);
void *buffer = new unsigned char[m_ImageIO->GetImageSizeInBytes()];
m_ImageIO->Read(buffer);
image->Initialize(MakePixelType(m_ImageIO), ndim, dimensions);
image->SetImportChannel(buffer, 0, Image::ManageMemory);
const itk::MetaDataDictionary &dictionary = m_ImageIO->GetMetaDataDictionary();
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3 ? 3 : ndim);
for (i = 0; i < itkDimMax3; ++i)
for (j = 0; j < itkDimMax3; ++j)
matrix[i][j] = m_ImageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry *planeGeometry = image->GetSlicedGeometry(0)->GetPlaneGeometry(0);
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
SlicedGeometry3D *slicedGeometry = image->GetSlicedGeometry(0);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
MITK_INFO << slicedGeometry->GetCornerPoint(false, false, false);
MITK_INFO << slicedGeometry->GetCornerPoint(true, true, true);
// re-initialize TimeGeometry
TimeGeometry::Pointer timeGeometry;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TYPE) || dictionary.HasKey(PROPERTY_KEY_TIMEGEOMETRY_TYPE))
{ // also check for the name because of backwards compatibility. Past code version stored with the name and not with
// the key
itk::MetaDataObject<std::string>::ConstPointer timeGeometryTypeData = nullptr;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TYPE))
{
timeGeometryTypeData =
dynamic_cast<const itk::MetaDataObject<std::string> *>(dictionary.Get(PROPERTY_NAME_TIMEGEOMETRY_TYPE));
}
else
{
timeGeometryTypeData =
dynamic_cast<const itk::MetaDataObject<std::string> *>(dictionary.Get(PROPERTY_KEY_TIMEGEOMETRY_TYPE));
}
if (timeGeometryTypeData->GetMetaDataObjectValue() == ArbitraryTimeGeometry::GetStaticNameOfClass())
{
MITK_INFO << "used time geometry: " << ArbitraryTimeGeometry::GetStaticNameOfClass() << std::endl;
typedef std::vector<TimePointType> TimePointVector;
TimePointVector timePoints;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS))
{
timePoints = ConvertMetaDataObjectToTimePointList(dictionary.Get(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS));
}
else if (dictionary.HasKey(PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS))
{
timePoints = ConvertMetaDataObjectToTimePointList(dictionary.Get(PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS));
}
if (timePoints.size() - 1 != image->GetDimension(3))
{
MITK_ERROR << "Stored timepoints (" << timePoints.size() - 1 << ") and size of image time dimension ("
<< image->GetDimension(3) << ") do not match. Switch to ProportionalTimeGeometry fallback"
<< std::endl;
}
else
{
ArbitraryTimeGeometry::Pointer arbitraryTimeGeometry = ArbitraryTimeGeometry::New();
TimePointVector::const_iterator pos = timePoints.begin();
TimePointVector::const_iterator prePos = pos++;
for (; pos != timePoints.end(); ++prePos, ++pos)
{
arbitraryTimeGeometry->AppendTimeStepClone(slicedGeometry, *pos, *prePos);
}
timeGeometry = arbitraryTimeGeometry;
}
}
}
if (timeGeometry.IsNull())
{ // Fallback. If no other valid time geometry has been created, create a ProportionalTimeGeometry
MITK_INFO << "used time geometry: " << ProportionalTimeGeometry::GetStaticNameOfClass() << std::endl;
ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
propTimeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
timeGeometry = propTimeGeometry;
}
image->SetTimeGeometry(timeGeometry);
buffer = NULL;
MITK_INFO << "number of image components: " << image->GetPixelType().GetNumberOfComponents() << std::endl;
for (itk::MetaDataDictionary::ConstIterator iter = dictionary.Begin(), iterEnd = dictionary.End(); iter != iterEnd;
++iter)
{
if (iter->second->GetMetaDataObjectTypeInfo() == typeid(std::string))
{
const std::string &key = iter->first;
std::string assumedPropertyName = key;
std::replace(assumedPropertyName.begin(), assumedPropertyName.end(), '_', '.');
std::string mimeTypeName = GetMimeType()->GetName();
// Check if there is already a info for the key and our mime type.
IPropertyPersistence::InfoResultType infoList = mitk::CoreServices::GetPropertyPersistence()->GetInfoByKey(key);
auto predicate = [mimeTypeName](const PropertyPersistenceInfo::ConstPointer &x) {
return x.IsNotNull() && x->GetMimeTypeName() == mimeTypeName;
};
auto finding = std::find_if(infoList.begin(), infoList.end(), predicate);
if (finding == infoList.end())
{
auto predicateWild = [](const PropertyPersistenceInfo::ConstPointer &x) {
return x.IsNotNull() && x->GetMimeTypeName() == PropertyPersistenceInfo::ANY_MIMETYPE_NAME();
};
finding = std::find_if(infoList.begin(), infoList.end(), predicateWild);
}
PropertyPersistenceInfo::ConstPointer info;
if (finding != infoList.end())
{
assumedPropertyName = (*finding)->GetName();
info = *finding;
}
else
{ // we have not found anything suitable so we generate our own info
PropertyPersistenceInfo::Pointer newInfo = PropertyPersistenceInfo::New();
newInfo->SetNameAndKey(assumedPropertyName, key);
newInfo->SetMimeTypeName(PropertyPersistenceInfo::ANY_MIMETYPE_NAME());
info = newInfo;
}
std::string value =
dynamic_cast<itk::MetaDataObject<std::string> *>(iter->second.GetPointer())->GetMetaDataObjectValue();
mitk::BaseProperty::Pointer loadedProp = info->GetDeserializationFunction()(value);
image->SetProperty(assumedPropertyName.c_str(), loadedProp);
// Read properties should be persisted unless they are default properties
// which are written anyway
bool isDefaultKey(false);
for (const auto &defaultKey : m_DefaultMetaDataKeys)
{
if (defaultKey.length() <= assumedPropertyName.length())
{
// does the start match the default key
if (assumedPropertyName.substr(0, defaultKey.length()).find(defaultKey) != std::string::npos)
{
isDefaultKey = true;
break;
}
}
}
if (!isDefaultKey)
{
mitk::CoreServices::GetPropertyPersistence()->AddInfo(info);
}
}
}
MITK_INFO << "...finished!" << std::endl;
result.push_back(image.GetPointer());
return result;
}
void CPPgSecurity::OnLoadIPFFromURL()
{
bool bHaveNewFilterFile = false;
CString url;
GetDlgItemText(IDC_UPDATEURL,url);
if (!url.IsEmpty())
{
// add entered URL to LRU list even if it's not yet known whether we can download from this URL (it's just more convenient this way)
if (m_pacIPFilterURL && m_pacIPFilterURL->IsBound())
m_pacIPFilterURL->AddItem(url, 0);
CString strTempFilePath;
_tmakepathlimit(strTempFilePath.GetBuffer(MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T("tmp"));
strTempFilePath.ReleaseBuffer();
CHttpDownloadDlg dlgDownload;
dlgDownload.m_strTitle = GetResString(IDS_DWL_IPFILTERFILE);
dlgDownload.m_sURLToDownload = url;
dlgDownload.m_sFileToDownloadInto = strTempFilePath;
if (dlgDownload.DoModal() != IDOK)
{
(void)_tremove(strTempFilePath);
CString strError = GetResString(IDS_DWLIPFILTERFAILED);
if (!dlgDownload.GetError().IsEmpty())
strError += _T("\r\n\r\n") + dlgDownload.GetError();
AfxMessageBox(strError, MB_ICONERROR);
return;
}
CString strMimeType;
GetMimeType(strTempFilePath, strMimeType);
bool bIsArchiveFile = false;
bool bUncompressed = false;
CZIPFile zip;
if (zip.Open(strTempFilePath))
{
bIsArchiveFile = true;
CZIPFile::File* zfile = zip.GetFile(_T("guarding.p2p"));
if (zfile == NULL)
zfile = zip.GetFile(_T("ipfilter.dat"));
if (zfile)
{
CString strTempUnzipFilePath;
_tmakepathlimit(strTempUnzipFilePath.GetBuffer(_MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T(".unzip.tmp"));
strTempUnzipFilePath.ReleaseBuffer();
if (zfile->Extract(strTempUnzipFilePath))
{
zip.Close();
zfile = NULL;
if (_tremove(theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to remove default IP filter file \"%s\" - %s\n"), theApp.ipfilter->GetDefaultFilePath(), _tcserror(errno));
if (_trename(strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to rename uncompressed IP filter file \"%s\" to default IP filter file \"%s\" - %s\n"), strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath(), _tcserror(errno));
if (_tremove(strTempFilePath) != 0)
TRACE(_T("*** Error: Failed to remove temporary IP filter file \"%s\" - %s\n"), strTempFilePath, _tcserror(errno));
bUncompressed = true;
bHaveNewFilterFile = true;
}
else {
CString strError;
strError.Format(GetResString(IDS_ERR_IPFILTERZIPEXTR), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
}
else {
CString strError;
strError.Format(GetResString(IDS_ERR_IPFILTERCONTENTERR), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
zip.Close();
}
else if (strMimeType.CompareNoCase(_T("application/x-rar-compressed")) == 0)
{
bIsArchiveFile = true;
CRARFile rar;
if (rar.Open(strTempFilePath))
{
CString strFile;
if (rar.GetNextFile(strFile)
&& (strFile.CompareNoCase(_T("ipfilter.dat")) == 0 || strFile.CompareNoCase(_T("guarding.p2p")) == 0))
{
CString strTempUnzipFilePath;
_tmakepathlimit(strTempUnzipFilePath.GetBuffer(MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T(".unzip.tmp"));
strTempUnzipFilePath.ReleaseBuffer();
if (rar.Extract(strTempUnzipFilePath))
{
rar.Close();
if (_tremove(theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to remove default IP filter file \"%s\" - %s\n"), theApp.ipfilter->GetDefaultFilePath(), _tcserror(errno));
if (_trename(strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to rename uncompressed IP filter file \"%s\" to default IP filter file \"%s\" - %s\n"), strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath(), _tcserror(errno));
if (_tremove(strTempFilePath) != 0)
TRACE(_T("*** Error: Failed to remove temporary IP filter file \"%s\" - %s\n"), strTempFilePath, _tcserror(errno));
bUncompressed = true;
bHaveNewFilterFile = true;
}
else
{
CString strError;
strError.Format(_T("Failed to extract IP filter file from RAR file \"%s\"."), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
}
else
{
CString strError;
strError.Format(_T("Failed to find IP filter file \"guarding.p2p\" or \"ipfilter.dat\" in RAR file \"%s\"."), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
rar.Close();
}
else
{
CString strError;
strError.Format(_T("Failed to open file \"%s\".\r\n\r\nInvalid file format?\r\n\r\nDownload latest version of UNRAR.DLL from http://www.rarlab.com and copy UNRAR.DLL into eMule installation folder."), url);
AfxMessageBox(strError, MB_ICONERROR);
}
}
else
{
CGZIPFile gz;
if (gz.Open(strTempFilePath))
{
bIsArchiveFile = true;
CString strTempUnzipFilePath;
_tmakepathlimit(strTempUnzipFilePath.GetBuffer(_MAX_PATH), NULL, thePrefs.GetMuleDirectory(EMULE_CONFIGDIR), DFLT_IPFILTER_FILENAME, _T(".unzip.tmp"));
strTempUnzipFilePath.ReleaseBuffer();
// add filename and extension of uncompressed file to temporary file
CString strUncompressedFileName = gz.GetUncompressedFileName();
if (!strUncompressedFileName.IsEmpty())
{
strTempUnzipFilePath += _T('.');
strTempUnzipFilePath += strUncompressedFileName;
}
if (gz.Extract(strTempUnzipFilePath))
{
gz.Close();
if (_tremove(theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to remove default IP filter file \"%s\" - %s\n"), theApp.ipfilter->GetDefaultFilePath(), _tcserror(errno));
if (_trename(strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath()) != 0)
TRACE(_T("*** Error: Failed to rename uncompressed IP filter file \"%s\" to default IP filter file \"%s\" - %s\n"), strTempUnzipFilePath, theApp.ipfilter->GetDefaultFilePath(), _tcserror(errno));
if (_tremove(strTempFilePath) != 0)
TRACE(_T("*** Error: Failed to remove temporary IP filter file \"%s\" - %s\n"), strTempFilePath, _tcserror(errno));
bUncompressed = true;
bHaveNewFilterFile = true;
}
else {
CString strError;
strError.Format(GetResString(IDS_ERR_IPFILTERZIPEXTR), strTempFilePath);
AfxMessageBox(strError, MB_ICONERROR);
}
}
gz.Close();
}
if (!bIsArchiveFile && !bUncompressed)
{
// Check first lines of downloaded file for potential HTML content (e.g. 404 error pages)
bool bValidIPFilterFile = true;
FILE* fp = _tfsopen(strTempFilePath, _T("rb"), _SH_DENYWR);
if (fp)
{
char szBuff[16384];
int iRead = fread(szBuff, 1, _countof(szBuff)-1, fp);
if (iRead <= 0)
bValidIPFilterFile = false;
else
{
szBuff[iRead-1] = '\0';
const char* pc = szBuff;
while (*pc == ' ' || *pc == '\t' || *pc == '\r' || *pc == '\n')
pc++;
if (strnicmp(pc, "<html", 5) == 0
|| strnicmp(pc, "<xml", 4) == 0
|| strnicmp(pc, "<!doc", 5) == 0)
{
bValidIPFilterFile = false;
}
}
fclose(fp);
}
if (bValidIPFilterFile)
{
(void)_tremove(theApp.ipfilter->GetDefaultFilePath());
VERIFY( _trename(strTempFilePath, theApp.ipfilter->GetDefaultFilePath()) == 0 );
bHaveNewFilterFile = true;
}
else
{
AfxMessageBox(GetResString(IDS_DWLIPFILTERFAILED), MB_ICONERROR);
}
}
}
if (url.IsEmpty() || bHaveNewFilterFile)
OnReloadIPFilter();
// In case we received an invalid IP-filter file (e.g. an 404 HTML page with HTTP status "OK"),
// warn the user that there are no IP-filters available any longer.
if (bHaveNewFilterFile && theApp.ipfilter->GetIPFilter().GetCount() == 0)
{
CString strLoaded;
strLoaded.Format(GetResString(IDS_IPFILTERLOADED), theApp.ipfilter->GetIPFilter().GetCount());
CString strError;
strError.Format(_T("%s\r\n\r\n%s"), GetResString(IDS_DWLIPFILTERFAILED), strLoaded);
AfxMessageBox(strError, MB_ICONERROR);
}
}
bool CResourceHTMLItem::Start ( void )
{
if ( !m_bIsRaw )
{
// go through and search for <* or *>
FILE * pFile = fopen ( m_strResourceFileName.c_str (), "r" );
if ( !pFile )
return false;
bool bInCode = false;
bool bJustStartedCodeBlock = false;
bool bIsShorthandCodeBlock = false;
std::string strScript;
strScript += "function renderPage ( requestHeaders, form, cookies, hostname, url, querystring, user )\n";
strScript += "\nhttpWrite ( \""; // bit hacky, possibly can be terminated straight away
unsigned char c;
int i = 0;
while ( !feof ( pFile ) )
{
c = ReadChar ( pFile );
if ( feof ( pFile ) )
break;
if ( bInCode == false ) // we're in a plain HTML section
{
if ( c == '<' && !feof ( pFile ) )
{
c = ReadChar ( pFile );
if ( c == '*' ) // we've found <*
{
bInCode = true;
bJustStartedCodeBlock = true;
strScript.append("\" )\n"); // add ") to the end to terminate our last non-code section
}
else
{ // we found < but not a *, so just output both characters we read
strScript += '<';
strScript += c;
}
}
else
{
if ( c == '\r' )
{
strScript += "\\r";
}
else if ( c == '\n' )
{
strScript += "\\n";
}
else if ( c == '\\' )
{
strScript += "\\\\";
}
else if ( c == '\"' )
{
strScript += "\\\"";
}
else
strScript += c;
}
}
else
{ // we're in a code block
if ( c == '*' && !feof ( pFile ) )
{
c = ReadChar ( pFile );
if ( c == '>' ) // we've found *>
{
bInCode = false;
if ( bIsShorthandCodeBlock )
{
bIsShorthandCodeBlock = false;
strScript += ')'; // terminate the 'httpWrite' function
}
strScript.append ( "\nhttpWrite ( \"" ); // add httpWrite ( " to start a new non-code section
}
else
{ // we found * but not a >, so just output both characters we read
strScript += '*';
strScript += c;
}
}
else if ( c == '=' && bJustStartedCodeBlock )
{
strScript.append("httpWrite ( ");
bIsShorthandCodeBlock = true;
}
else
{
if ( c != '\t' && c != ' ' ) // we allow whitespace before the shorthand '=' sign
bJustStartedCodeBlock = false;
strScript += c;
}
}
i++;
}
if ( !bInCode )
strScript.append("\" )\n");
strScript.append("\nend");
/* FILE * debug = fopen ("debug.lua", "w" );
fwrite ( m_szBuffer, 1, strlen(m_szBuffer), debug );
fclose ( debug );*/
m_pVM = g_pGame->GetLuaManager()->CreateVirtualMachine ( m_resource );
m_pVM->LoadScript ( strScript.c_str () );
m_pVM->SetResourceFile ( this );
m_pVM->RegisterHTMLDFunctions();
fclose ( pFile );
GetMimeType ( m_strResourceFileName.c_str () );
return true;
}
else
{
// its a raw page
FILE * file = fopen ( m_strResourceFileName.c_str (), "rb" );
if ( file )
{
GetMimeType ( m_strResourceFileName.c_str () );
// don't actually read it here, it could be way too large
fclose ( file );
return true;
}
return false;
}
}
/*----------------------------------------------------------------------
| PLT_MimeType::GetMimeType
+---------------------------------------------------------------------*/
const char*
PLT_MimeType::GetMimeType(const NPT_String& filename,
const PLT_HttpRequestContext* context /* = NULL */)
{
return GetMimeType(filename, context?PLT_HttpHelper::GetDeviceSignature(context->GetRequest()):PLT_DEVICE_UNKNOWN);
}