///////////////////////////////////////////////////////////////////////////////
// Stellt fest, ob ein bestimmtes Feld bereits in der Datei enthalten ist
HRESULT CArcViewLayer::FieldExists (LPCSTR pcName, DBFFieldType rgType, int *piField)
{
CFieldNames::iterator it = m_Names.find (pcName);
if (it != m_Names.end()) {
int iCnt = DBFGetFieldCount(m_hDBF);
int iWidth = 0;
int iDecimals = 0;
char cbBuffer[_MAX_PATH];
for (int i = 0; i < iCnt; ++i) {
DBFFieldType rgActType = DBFGetFieldInfo(m_hDBF, i, cbBuffer, &iWidth, &iDecimals);
if ((*it).second == os_string(cbBuffer)) {
if (NULL != piField)
*piField = i;
if (rgType == rgActType || rgActType == FTString)
return S_OK; // found Field
else
return S_FALSE; // found, but type does not match
}
}
}
return E_FAIL; // does not exist
}
///////////////////////////////////////////////////////////////////////////////
// alle Dateien schließen und löschen
HRESULT CArcViewLayer::CloseAndDeleteFiles()
{
RETURN_FAILED_HRESULT(Close());
os_path pathRoot (m_strRoot);
pathRoot.extension (g_cbShp);
RETURN_EXPR_FALSE(DeleteFile(os_string(pathRoot).c_str()), HRESULT_FROM_WIN32(GetLastError()));
pathRoot.extension (g_cbShx);
RETURN_EXPR_FALSE(DeleteFile(os_string(pathRoot).c_str()), HRESULT_FROM_WIN32(GetLastError()));
pathRoot.extension (g_cbDbf);
RETURN_EXPR_FALSE(DeleteFile(os_string(pathRoot).c_str()), HRESULT_FROM_WIN32(GetLastError()));
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////
// Formatierfunktionen
os_string __cdecl FakeTRiASName (UINT resID, ...)
{
CString strText;
VERIFY(strText.LoadString (resID));
COM_TRY {
CString strOut;
LPTSTR pcOut = strOut.GetBufferSetLength(_MAX_PATH*4);
va_list params;
va_start (params, resID);
//lint --e(534)
wvsprintf (pcOut, strText, params);
va_end (params);
return os_string(pcOut);
} COM_CATCH_IGNORE; // irgendein Fehler
return os_string((LPCSTR)strText);
}
void read_write() {
ofstream outfile;
outfile.open("dictionary");
// write a sequence of strings to the ofstream named outfile
// placing each string on a separate line
ostream_iterator<string> os_string(outfile, "\n");
istream_iterator<int> input(cin), eof;
ostream_iterator<int> output(cout);
while (input != eof)
*output++ = *input++;
}
// Finden des ParentItems im Control, ansonsten TVI_ROOT liefern --------------
HTREEITEM CSelectObjectPropTree::CalcParentItem (string &strGroup)
{
HTREEITEM hItem;
CItemMap::const_iterator it = m_Items.find (strGroup.c_str());
if (it == m_Items.end()) {
// erstes mal
hItem = InsertItem (strGroup.c_str(), TVI_ROOT);
m_Items.insert (make_pair(os_string(strGroup.c_str()), hItem));
} else
hItem = (*it).second;
return hItem;
}
CString CGetFilenameControl::GetPathName(CGetFileNameDialog &rDlg)
{
m_Files.erase();
if (!(m_dwFlags & GF_MULTIPLESELECTION)) {
m_iCnt = 1;
m_Files.insert(os_string(rDlg.GetPathName()));
return rDlg.GetPathName();
}
// MultiSelDlg
POSITION pos = rDlg.GetStartPosition();
while (NULL != pos) {
CString str (rDlg.GetNextPathName (pos));
m_Files.insert(os_string(str));
}
// erste Datei liefern
if (m_Files.size() > 0)
return (*m_Files.begin()).c_str();
else
return g_cbNil;
}
os_string FakeTRiASName (LPCSTR pcTempl, ...)
{
try {
va_list params;
os_string strRes;
va_start (params, pcTempl);
FormatV (strRes, pcTempl, params);
va_end (params);
return strRes;
} catch (...) {
// irgendein Fehler
return os_string("");
}
}
///////////////////////////////////////////////////////////////////////////////
// anlegen eines neuen Feldes in der DBase-Datei
HRESULT CArcViewLayer::AddField(LPCSTR pcName, DBFFieldType rgTyp, int iLen, int iDecimal, int *piField)
{
if (NULL == piField)
return E_POINTER;
*piField = -1;
CFieldNames::iterator it = m_Names.find (pcName);
if (it == m_Names.end()) {
// Namen zuordnen
pair<CFieldNames::iterator, bool> p = m_Names.insert(CFieldNames::value_type(pcName, GetUniqueFieldName(pcName)));
if (p.second)
it = p.first;
}
if (it != m_Names.end()) {
// DBasefeld anlegen
if (FTString == rgTyp && iLen > MAX_DBASEFIELD_LEN)
iLen = MAX_DBASEFIELD_LEN;
*piField = DBFAddField(m_hDBF, (*it).second.c_str(), rgTyp, iLen, iDecimal);
// ggf. existiert das Feld schon in der DBaseDatei (eine bereits exportierte
// Datenquelle hat es hinterlassen)
if (-1 != *piField)
return S_OK; // found Field
int iCnt = DBFGetFieldCount(m_hDBF);
int iWidth = 0;
int iDecimals = 0;
char cbBuffer[_MAX_PATH];
for (int i = 0; i < iCnt; ++i) {
DBFFieldType rgActType = DBFGetFieldInfo(m_hDBF, i, cbBuffer, &iWidth, &iDecimals);
if ((*it).second == os_string(cbBuffer)
&& (rgTyp == rgActType || rgActType == FTString))
{
*piField = i;
return S_OK; // found Field
}
}
return E_FAIL;
}
return E_FAIL; // could not create field
}
os_string FakeTRiASName (ResID resID, ...)
{
try {
ResString resTempl (resID, _MAX_PATH);
va_list params;
os_string strRes;
va_start (params, resID);
FormatV (strRes, resTempl, params);
va_end (params);
return strRes;
} catch (...) {
// irgendein Fehler
return os_string("");
}
}
BOOL _XTENSN_EXPORT PASCAL EnumDataSources (LPSTR pcPath, BOOL, void *pData)
{
ENUMDATASOURCES *pEDS = (ENUMDATASOURCES *)pData;
HPROJECT hPr = DEX_GetDataSourceHandleEx (pcPath);
TX_ASSERT(NULL != hPr);
if (!DEX_GetOpenedEx(hPr))
return TRUE; // diese Datenquelle ist nicht geöffnet
os_path path (pEDS -> pcFName);
if (!path.has_extension())
path.extension ("txc");
os_string strT;
char cbBuffer[_MAX_PATH];
DEX_GetDataSourceShortName(hPr, cbBuffer);
Format (strT, "%s (%s)", path.base().c_str(), cbBuffer);
path.base (strT);
return pEDS -> pThis -> ExportDataSourceAsXml (pEDS -> pUnk, hPr, os_string(path).c_str(), pEDS -> ulCnt);
}
HRESULT CTRiASDropTarget::InitFileExtensionList (REFGUID rGuid)
{
LPOLESTR poleStr = NULL;
USES_CONVERSION;
COM_TRY {
// DBEngine instantiieren und nach EnumString fragen
WTRiASDBEngine DBEng;
WUnknown Unk;
HRESULT hr = DBEng.CreateInstance(rGuid);
if (FAILED(hr))
return hr; // ggf. nicht instantiierbar (z.B. lizensiert)
THROW_FAILED_HRESULT(DBEng -> EnumDataBaseTypes (Unk.ppi()));
// jetzt eigentliche Dataserver einfügen
WEnumString EnumStr(Unk);
for (EnumStr -> Reset(); S_OK == EnumStr -> Next (1, &poleStr, NULL); /**/)
{
CConnectParams Item;
DWORD dwDummy = 0;
HRESULT hr = TxGetExtension() -> ReadDataServerParams (dwDummy, &Item, OLE2A(poleStr));
CoTaskMemFree (poleStr);
poleStr = NULL;
// nur dateibasierte Datenquelle untersuchen
if (!Item.m_fNameIsFile)
continue;
m_lstExts.insert(CExtensions::value_type(os_string(Item.m_strDefExt), Item));
}
} COM_CATCH_OP(CoTaskMemFree (poleStr));
return S_OK;
}
/* check_rc_trojans:
* Read the file pointer specified (rootkit_trojans)
* and check if the any trojan entry is on the configured files
*/
void check_rc_trojans(char *basedir, FILE *fp)
{
int i = 0, _errors = 0, _total = 0;
char buf[OS_SIZE_1024 +1];
char file_path[OS_SIZE_1024 +1];
char *file;
char *string_to_look;
#ifndef WIN32
char *(all_paths[]) = {"bin","sbin","usr/bin","usr/sbin", NULL};
#else
char *(all_paths[]) = {"C:\\Windows\\", "D:\\Windows\\", NULL};
#endif
debug1("%s: DEBUG: Starting on check_rc_trojans", ARGV0);
while(fgets(buf, OS_SIZE_1024, fp) != NULL)
{
char *nbuf;
char *message = NULL;
i = 0;
/* Removing end of line */
nbuf = strchr(buf, '\n');
if(nbuf)
{
*nbuf = '\0';
}
/* Normalizing line */
nbuf = normalize_string(buf);
if(*nbuf == '\0' || *nbuf == '#')
{
continue;
}
/* File now may be valid */
file = nbuf;
string_to_look = strchr(file, '!');
if(!string_to_look)
{
continue;
}
*string_to_look = '\0';
string_to_look++;
message = strchr(string_to_look, '!');
if(!message)
{
continue;
}
*message = '\0';
message++;
string_to_look = normalize_string(string_to_look);
file = normalize_string(file);
message = normalize_string(message);
if(*file == '\0' || *string_to_look == '\0')
{
continue;
}
_total++;
/* Trying with all possible paths */
while(all_paths[i] != NULL)
{
if(*file != '/')
{
snprintf(file_path, OS_SIZE_1024, "%s/%s/%s",basedir,
all_paths[i],
file);
}
else
{
strncpy(file_path, file, OS_SIZE_1024);
file_path[OS_SIZE_1024 -1] = '\0';
}
/* Checking if entry is found */
if(is_file(file_path) && os_string(file_path, string_to_look))
{
char op_msg[OS_SIZE_1024 +1];
_errors = 1;
snprintf(op_msg, OS_SIZE_1024, "Trojaned version of file "
"'%s' detected. Signature used: '%s' (%s).",
file_path,
string_to_look,
*message == '\0'?
"Generic":message);
notify_rk(ALERT_ROOTKIT_FOUND, op_msg);
}
if(*file == '/')
{
break;
}
i++;
}
continue;
}
if(_errors == 0)
{
char op_msg[OS_SIZE_1024 +1];
snprintf(op_msg,OS_SIZE_1024, "No binaries with any trojan detected. "
"Analyzed %d files.", _total);
notify_rk(ALERT_OK, op_msg);
}
}
///////////////////////////////////////////////////////////////////////////////
// Datenbank öffnen
HRESULT CMiTabDatasource::Open(const char *pszNewName, bool fUpdate, bool fTestOpen)
{
_ASSERTE(0 == m_Layers.size());
_ASSERTE(NULL != pszNewName);
struct _stat stat;
m_strName = pszNewName;
m_fUpdatable = fUpdate;
// Is the given path a directory or a regular file?
os_string strPath (pszNewName); // evtl. abschließendes '\' abschneiden
size_t pos = strPath.find_last_of("\\/");
if (os_npos != pos && pos == strPath.size()-1)
strPath.replace(pos, 1, "");
if (0 != _stat(strPath.c_str(), &stat) || (!(stat.st_mode & _S_IFDIR) && !(stat.st_mode & _S_IFREG)))
{
if (fTestOpen)
return S_FALSE;
return TRIASMI_E_BADFILENAME;
}
// Build a list of filenames we figure are MapInfo files.
if (stat.st_mode & _S_IFREG) {
// given name relates to a file
if (S_OK != OpenFile(pszNewName, fUpdate, fTestOpen)) {
if (fTestOpen)
return S_FALSE;
return TRIASMI_E_OPENFILE_FAILED;
}
return S_OK;
}
else {
vector<os_string> Candidates;
os_path dir (pszNewName);
RETURN_FAILED_HRESULT(ReadDir (pszNewName, Candidates));
for (vector<os_string>::iterator it = Candidates.begin(); it != Candidates.end(); ++it) {
os_path path (*it);
if (stricmp (path.extension().c_str(), g_cbMif) && stricmp (path.extension().c_str(), g_cbTab))
continue;
// vollständigen Dateinamen bauen
if (dir.has_directory())
path.directory(dir.directory());
if (dir.has_drive())
path.drive(*dir.drive().c_str());
if (S_OK != OpenFile (os_string(path).c_str(), fUpdate, fTestOpen) && !fTestOpen)
{
return TRIASMI_E_OPENFILE_FAILED;
}
}
if (!fTestOpen && 0 == m_Layers.size() && !fUpdate)
{
return TRIASMI_W_NOFILESFOUND;
}
}
// Datenbank jetzt geöffnet
m_fOpened = true;
return (m_Layers.size() > 0 || fUpdate) ? S_OK : S_FALSE;
}
///////////////////////////////////////////////////////////////////////////////
// Open a ShapeDatasource (all shp files in a directory)
HRESULT CShapeDataSource::Open(const char *pszNewName, bool fUpdate, bool fTestOpen)
{
_ASSERTE(0 == m_Layers.size());
_ASSERTE(NULL != pszNewName);
struct _stat stat;
m_strName = pszNewName;
m_fUpdatable = fUpdate;
// Is the given path a directory or a regular file?
os_string strPath (pszNewName); // evtl. abschließendes '\' abschneiden
size_t pos = strPath.find_last_of("\\/");
if (os_npos != pos && pos == strPath.size()-1)
strPath.replace(pos, 1, "");
if (0 != _stat(strPath.c_str(), &stat) || (!(stat.st_mode & _S_IFDIR) && !(stat.st_mode & _S_IFREG)))
{
if (fTestOpen)
return S_FALSE;
return TRIASHP_E_BADFILENAME;
}
// Build a list of filenames we figure are Shape files.
if (stat.st_mode & _S_IFREG) {
// given name relates to a file
if (S_OK != OpenFile(pszNewName, fUpdate, fTestOpen)) {
if (fTestOpen)
return S_FALSE;
return TRIASHP_E_OPENFILE_FAILED;
}
return S_OK;
}
else {
vector<os_string> Candidates;
vector<os_string> Failed;
os_path dir (pszNewName);
RETURN_FAILED_HRESULT(ReadDir (pszNewName, Candidates));
for (vector<os_string>::iterator it = Candidates.begin(); it != Candidates.end(); ++it) {
os_path path (*it);
if (stricmp (path.extension().c_str(), g_cbShp))
continue;
// vollständigen Dateinamen bauen
if (dir.has_directory())
path.directory(dir.directory());
if (dir.has_drive())
path.drive(*dir.drive().c_str());
if (S_OK != OpenFile (os_string(path).c_str(), fUpdate, fTestOpen) && !fTestOpen)
Failed.push_back(os_string(path));
}
if (!fTestOpen && 0 == m_Layers.size() && !fUpdate) {
if (!m_fDeniedToOpen) {
os_path datasource(strPath);
VMessageBox(IDS_DBENGINE_DESC, MB_ICONEXCLAMATION|MB_OK,
IDS_COULDNOTOPENSHAPE, datasource.base().c_str());
m_fDeniedToOpen = true;
}
return TRIASHP_W_NOFILESFOUND;
}
// Fehlerbahandlung
if (Failed.size() > 0) {
int iResult = IDNO;
if (!m_fDeniedToOpen) {
os_path datasource(strPath);
if (1 == Failed.size()) {
iResult = VMessageBox(IDS_DBENGINE_DESC, MB_ICONQUESTION|MB_YESNO,
IDS_COULDNOTOPENFILE, Failed[0].c_str(), datasource.base().c_str());
}
else {
os_string failed;
for (vector<os_string>::iterator it = Failed.begin();
it != Failed.end(); ++it)
{
failed += " ";
failed += *it;
failed += '\n';
}
iResult = VMessageBox(IDS_DBENGINE_DESC, MB_ICONQUESTION|MB_YESNO,
IDS_COULDNOTOPENFILES, failed.c_str(), datasource.base().c_str());
}
m_fDeniedToOpen = true;
}
if (IDNO == iResult) {
m_Layers.clear();
return TRIASHP_E_OPENFILE_FAILED;
}
}
}
// Datenbank jetzt geöffnet
m_fOpened = true;
return (m_Layers.size() > 0 || fUpdate) ? S_OK : S_FALSE;
}
void CGetFilenameControl::Edit(BOOL fShowDlg)
{
//bring up the common file open dialog to select the filename
//retreive the current filename to use as the initial value
CString sCurrentFilename;
if (m_sDir.IsEmpty())
GetWindowText(sCurrentFilename);
else
sCurrentFilename = m_sDir;
if (fShowDlg || 0 == sCurrentFilename.GetLength()) {
// work out the flags to use
DWORD dwFlags = 0;
BOOL fOpenFile = TRUE;
if (m_dwFlags & GF_HIDEREADONLY)
dwFlags |= OFN_HIDEREADONLY;
if (m_dwFlags & GF_OVERWRITEPROMPT)
dwFlags |= OFN_OVERWRITEPROMPT;
if (m_dwFlags & GF_FILEMUSTEXIST)
dwFlags |= OFN_FILEMUSTEXIST;
if (m_dwFlags & GF_SAVEASDIALOG) {
fOpenFile = FALSE;
m_dwFlags |= OFN_NOREADONLYRETURN;
}
if (m_dwFlags & GF_MULTIPLESELECTION)
dwFlags |= OFN_ALLOWMULTISELECT;
if (IsWin40())
dwFlags |= OFN_EXPLORER;
else
dwFlags |= OFN_LONGNAMES;
#if defined(OFN_ENABLESIZING)
if (IsWin41() || (IsWinNT() && IsWin50())) { // Win98 oder WinNT50
dwFlags |= OFN_ENABLESIZING;
#if defined(OFN_DONTADDTORECENT)
dwFlags |= OFN_DONTADDTORECENT;
#endif // defined(OFN_DONTADDTORECENT)
}
#endif // OFN_ENABLESIZING
CGetFileNameDialog dlg (fOpenFile, m_sDefExt, sCurrentFilename, dwFlags, m_sExtFilter, GetParent());
//Modify the title to the desired value
dlg.m_ofn.lpstrTitle = m_sTitle;
//uncomment the following line if you want to use the old style file open common dialog
if (m_dwFlags & GF_OLD_STYLE_DIALOG)
dlg.m_ofn.Flags &= ~OFN_EXPLORER;
// evtl. Verzeichnis voreinstellen
if (!m_sDir.IsEmpty())
dlg.m_ofn.lpstrInitialDir = m_sDir;
//bring up the dialog and if hit ok set the text in this control to the new filename
if (dlg.DoModal() == IDOK) {
SetWindowText (GetPathName (dlg));
if (!(m_dwFlags & GF_HIDEREADONLY) && !(m_dwFlags & GF_SAVEASDIALOG)) {
m_fReadOnly = (dlg.m_ofn.Flags & OFN_READONLY) ? TRUE: FALSE;
// testen, ob die Datei evtl. schreibgeschützt ist
if (!m_fReadOnly) {
DWORD dwAttr = ::GetFileAttributes (GetPathName (dlg));
if ((UINT)(-1) != dwAttr)
m_fReadOnly = (dwAttr & FILE_ATTRIBUTE_READONLY) ? TRUE : FALSE;
}
}
GetParent()->PostMessage (WM_FILESELECTED);
}
} else {
SetWindowText(sCurrentFilename);
m_Files.insert(os_string(sCurrentFilename));
GetParent()->PostMessage (WM_FILESELECTED);
}
}
