static char read_set(FILE *txt,char *var,char *set)
{
int c;
char *cc;
fscanf(txt,"%[^=]%c",var,&c);
do
c = fgetc(txt);
while (c<33);
if (c =='"') fscanf(txt,"%[^\"]%c%c",set,&c,&c);
else if (c =='\'') fscanf(txt,"%[^']%c%c",set,&c,&c);
else
{
ungetc(c,txt);
fscanf(txt,"%[^> ]%c",set,&c);
}
while(c<33 && c != EOF) c = fgetc(txt);
if (c !='>') ungetc(c,txt);
cc = strchr(var,0);
while (cc != var)
{
cc--;
if (*cc>32)
{
cc++;
break;
}
}
*cc = 0;
_strupr(set);
_strupr(var);
return c;
}
bool ToolsOptionsWindow::SaveHotKeySettings ()
{
char szEncHotkey[SIZE_NAME];
ZeroMemory (szEncHotkey, SIZE_NAME);
GetDlgItemText (m_hwnd, ID_UTETXTHOTENC, szEncHotkey, SIZE_NAME);
char szDecHotkey[SIZE_NAME];
ZeroMemory (szDecHotkey, SIZE_NAME);
GetDlgItemText (m_hwnd, ID_UTETXTHOTDEC, szDecHotkey, SIZE_NAME);
if (strlen (szEncHotkey) != 1) {
MessageBox (NULL, "Please enter a valid Encryption Hotkey.", "Hotkey Invalid", MB_OK | MB_ICONEXCLAMATION);
return false;
} else {
_strupr (szEncHotkey);
m_registry.WriteStringSetting (UTEENCRYPTHOTKEY, szEncHotkey);
}
if (strlen (szDecHotkey) != 1) {
MessageBox (NULL, "Please enter a valid Decryption Hotkey.", "Hotkey Invalid", MB_OK | MB_ICONEXCLAMATION);
return false;
} else {
_strupr (szDecHotkey);
m_registry.WriteStringSetting (UTEDECRYPTHOTKEY, szDecHotkey);
}
return true;
}
void CMainFrame::ShowFun()
{
HANDLE h = g_EXE2C->GetFirstFuncHandle();
int i=0;
while (h)
{
st_FuncInfo info;
ZeroMemory(&info, sizeof(info));
g_EXE2C->GetFuncInfo(h, &info);
if (info.name[0] != 0)
{
dlg.m_list.InsertItem(i,"Function name");
dlg.m_list.SetItemText(i,0,info.name);
char strStep[20];
itoa(info.nStep,strStep,10);
dlg.m_list.SetItemText(i,1,strStep);
char strHeadoff[20];
itoa(info.headoff,strHeadoff,16);
dlg.m_list.SetItemText(i,2,_strupr(strHeadoff));
char strEndoff[20];
itoa(info.endoff,strEndoff,16);
dlg.m_list.SetItemText(i,3,_strupr(strEndoff));
char strStack_purge[20];
itoa(info.stack_purge,strStack_purge,10);
dlg.m_list.SetItemText(i,4,strStack_purge);
}
h = g_EXE2C->GetNextFuncHandle(h);
i+=1;
}
}
int CCmd::detectCmd(int cmdid,char *src)
{
if(NULL==src) return EOF;
if(cmdid>CMD_COUNT){
_cmd[cmdid].exception=CMDID_OVERFLOW;
return EOF;
}
_cmd[cmdid].currentCp=strstr(src,_cmd[cmdid].signature);
if(_cmd[cmdid].currentCp){
_cmd[cmdid].cmdStr=src;
return CMD_FOUND;
}
char buf[CMD_SIGNATURE_LEN];
int size=strlen(src);
if(size>CMD_SIGNATURE_LEN-1) size=CMD_SIGNATURE_LEN-1;
memset(buf,'\0',CMD_SIGNATURE_LEN);
memcpy(buf,src,size);
_strupr(buf);
_strupr(_cmd[cmdid].signature);
_cmd[cmdid].currentCp=strstr(buf,_cmd[cmdid].signature);
if(_cmd[cmdid].currentCp){
_cmd[cmdid].cmdStr=src;
return CMD_FOUND;
}
return NULL;
}
DWORD FindWinLogon(void)
{
DWORD rc = 0, SizeNeeded = 0;
PVOID InfoP = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,INITIAL_ALLOCATION);
pfnNtQuerySystemInformation(0x10,InfoP,INITIAL_ALLOCATION,&SizeNeeded);
HeapFree(GetProcessHeap(),0,InfoP);
InfoP = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,SizeNeeded);
DWORD SizeWritten = SizeNeeded;
if (pfnNtQuerySystemInformation(0x10,InfoP,SizeNeeded,&SizeWritten)) {
HeapFree(GetProcessHeap(),0,InfoP);
return (0);
}
DWORD NumHandles = SizeWritten / sizeof(QUERY_SYSTEM_INFORMATION);
if (NumHandles == 0) {
HeapFree(GetProcessHeap(),0,InfoP);
return (0);
}
PQUERY_SYSTEM_INFORMATION QuerySystemInformationP = (PQUERY_SYSTEM_INFORMATION)InfoP;
for (DWORD i = 1;i <= NumHandles;i++) {
if (QuerySystemInformationP->HandleType == 5) {
PVOID DebugBufferP = pfnRtlCreateQueryDebugBuffer(0,0);
if (pfnRtlQueryProcessDebugInformation(QuerySystemInformationP->PID,1,DebugBufferP) == 0) {
PPROCESS_INFO_HEADER ProcessInfoHeaderP = (PPROCESS_INFO_HEADER)((DWORD)DebugBufferP + 0x60);
DWORD Count = ProcessInfoHeaderP->Count;
PPROCESS_INFO ProcessInfoP = (PPROCESS_INFO)((DWORD)ProcessInfoHeaderP + sizeof(PROCESS_INFO_HEADER));
if (strstr(_strupr(ProcessInfoP->Name), "WINLOGON") != 0) {
DWORD dw = (DWORD)ProcessInfoP;
for (DWORD j = 0;j < Count;j++) {
dw += sizeof(PROCESS_INFO);
ProcessInfoP = (PPROCESS_INFO)dw;
if (strstr(_strupr(ProcessInfoP->Name), "NWGINA") != 0)
return (0);
if (strstr(_strupr(ProcessInfoP->Name), "MSGINA") == 0)
rc = QuerySystemInformationP->PID;
}
if (DebugBufferP)
pfnRtlDestroyQueryDebugBuffer(DebugBufferP);
HeapFree(GetProcessHeap(),0,InfoP);
return (rc);
}
}
if (DebugBufferP)
pfnRtlDestroyQueryDebugBuffer(DebugBufferP);
}
DWORD dw = (DWORD)QuerySystemInformationP;
dw += sizeof(QUERY_SYSTEM_INFORMATION);
QuerySystemInformationP = (PQUERY_SYSTEM_INFORMATION)dw;
}
HeapFree(GetProcessHeap(),0,InfoP);
return (rc);
}
bool CCWidget::IsMsg(const char* szMsg1, const char* szMsg2){
char szTmp1[256];
char szTmp2[256];
strcpy(szTmp1, szMsg1);
strcpy(szTmp2, szMsg2);
_strupr(szTmp1);
_strupr(szTmp2);
if(strcmp(szTmp1, szTmp2)==0) return true;
return false;
}
DWORD MsgToRequest ( LPCSTR lpMessage, LPREQUEST lpRequest )
{
//char *lpPtr1;
//char *lpPtr2;
//int i;
// Check the pointer parameter.
if( lpMessage == NULL || lpRequest == NULL )
return ERROR_INVALID_PARAMETER;
lstrcpyn( lpRequest->szUser, lpMessage, 16 );
_strupr( lpRequest->szUser );
lstrcpyn( lpRequest->szPasswd, lpMessage+16, 16 );
lstrcpyn( lpRequest->szComputer, lpMessage+32, 16 );
_strupr( lpRequest->szComputer );
// Use the current thread id to indicate the request(It's unique).
lpRequest->dwRequestId = GetCurrentThreadId();
/*
lpPtr1 = (char *)lpMessage;
lpPtr2 = strchr( lpPtr1, '\n' );
if( lpPtr2 == NULL )
return TERR_INVALID_MESSAGE;
i = lpPtr2 - lpPtr1;
if( i > MAX_USER )
return TERR_INVALID_USER;
lstrcpyn( lpRequest->szUser, lpPtr1, i+1 );
_strupr( lpRequest->szUser );
lpPtr1 = ++lpPtr2;
lpPtr2 = strchr( lpPtr1, '\n' );
if( lpPtr2 == NULL )
return TERR_INVALID_MESSAGE;
i = lpPtr2 - lpPtr1;
if( i > MAX_PASSWD )
return TERR_INVALID_PASSWORD;
lstrcpyn( lpRequest->szPasswd, lpPtr1, i+1 );
i = lstrlen( ++lpPtr2 );
if( i <= 0 )
return TERR_INVALID_MESSAGE;
if( i > MAX_COMPUTER )
return TERR_INVALID_COMPUTER;
lstrcpyn( lpRequest->szComputer, lpPtr2, i+1 );
_strupr( lpRequest->szComputer );
*/
GetLocalTime( &(lpRequest->Time) );
return TERR_SUCCESS;
}
DWORD TUserRename ( LPCSTR lpOldUserName, LPCSTR lpNewUserName )
{
CHAR szUserName[MAX_USER_NAME];
LPUSER_INFO ptr = NULL;
DWORD dwRetCode = 0;
if( lpOldUserName == NULL || lpNewUserName == NULL ||
*lpOldUserName == '\x0' || *lpNewUserName == '\x0' )
return ERROR_INVALID_PARAMETER;
if( UserDB == NULL )
return TERR_NO_USER_DB;
if( lstrcmpi( lpOldUserName, lpNewUserName ) == 0 )
return 0;
ZeroMemory( szUserName, MAX_USER_NAME );
lstrcpyn( szUserName, lpOldUserName, MAX_USER_NAME );
_strupr( szUserName );
__try {
WaitForSingleObject( hUserDBMutex, INFINITE );
ptr = (LPUSER_INFO)readBtreeData( UserDB, szUserName, NULL, sizeof( USER_INFO ) );
if( !ptr ) {
dwRetCode = TERR_USER_NOT_EXIST;
__leave;
}
ZeroMemory( ptr->szUser, MAX_USER_NAME );
lstrcpyn( ptr->szUser, lpNewUserName, MAX_USER_NAME );
_strupr( ptr->szUser );
if( writeBtreeData( UserDB, ptr->szUser, (LPSTR)ptr, sizeof( USER_INFO ) ) != 0 ) {
dwRetCode = TERR_WRITE_USER_DB;
__leave;
}
if( freeBtreeData( UserDB, szUserName ) < 0 ) {
dwRetCode = TERR_WRITE_USER_DB;
__leave;
}
}
__finally {
if( ptr )
freeBtreeMem( (LPSTR)ptr );
ReleaseMutex( hUserDBMutex );
}
return dwRetCode;
}
//=========================================================
BOOL GetTokenByName(HANDLE &hToken,LPSTR lpName)
{
if(!lpName)
{
return FALSE;
}
HANDLE hProcessSnap = NULL;
BOOL bRet = FALSE;
PROCESSENTRY32 pe32 = {0};
char SSzlC11[] = {'K','E','R','N','E','L','3','2','.','d','l','l','\0'};
char SSzlC10[] = {'C','r','e','a','t','e','T','o','o','l','h','e','l','p','3','2','S','n','a','p','s','h','o','t','\0'};
CreateToolhelp32SnapshotT pCreateToolhelp32Snapshot= (CreateToolhelp32SnapshotT)GetProcAddress(LoadLibrary(SSzlC11),SSzlC10);
hProcessSnap = pCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE)
return (FALSE);
pe32.dwSize = sizeof(PROCESSENTRY32);
char MyProcess32First[] ={'P','r','o','c','e','s','s','3','2','F','i','r','s','t','\0'};
Process32FirstT pProcess32First= (Process32FirstT)GetProcAddress(LoadLibrary(SSzlC11),MyProcess32First);
char CtxPW35[] = {'O','p','e','n','P','r','o','c','e','s','s','T','o','k','e','n','\0'};
OpenProcessTokenT pOpenProcessToken=(OpenProcessTokenT)GetProcAddress(LoadLibrary("ADVAPI32.dll"),CtxPW35);
char BrmAP29[] = {'C','l','o','s','e','H','a','n','d','l','e','\0'};
CloseHandleT pCloseHandle=(CloseHandleT)GetProcAddress(LoadLibrary("KERNEL32.dll"),BrmAP29);
char FBwWp14[] = {'O','p','e','n','P','r','o','c','e','s','s','\0'};
OpenProcessT pOpenProcess=(OpenProcessT)GetProcAddress(LoadLibrary("KERNEL32.dll"),FBwWp14);
char MyProcess32Next[] ={'P','r','o','c','e','s','s','3','2','N','e','x','t','\0'};
Process32NextT pProcess32Next= (Process32NextT)GetProcAddress(LoadLibrary(SSzlC11),MyProcess32Next);
if (pProcess32First(hProcessSnap, &pe32))
{
do
{
if(!strcmp(_strupr(pe32.szExeFile),_strupr(lpName)))
{
HANDLE hProcess = pOpenProcess(PROCESS_QUERY_INFORMATION,FALSE,pe32.th32ProcessID);
// bRet = pOpenProcessToken(hProcess,TOKEN_ALL_ACCESS,&hToken);
bRet = pOpenProcessToken(hProcess,TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,&hToken);
pCloseHandle (hProcessSnap);
return (bRet);
}
}
while (pProcess32Next(hProcessSnap, &pe32));
bRet = TRUE;
}
else
bRet = FALSE;
pCloseHandle (hProcessSnap);
return (bRet);
}
void MSVC8_Filter::write_filter_name_vs100(OutputWriter &output, int indent, const std::string &parent) const
{
std::string new_filter;
if (parent.length())
{
new_filter = parent + "\\" + name;
}
else
{
new_filter = name;
}
output.write_line(indent, " <Filter Include=\"" + new_filter + "\">");
// Create a new GUID:
unsigned char *projectGUID = 0;
GUID guid;
UuidCreate(&guid);
UuidToStringA(&guid, &projectGUID);
_strupr((char *) projectGUID);
std::string returnGUID = std::string("{") + ((char *) projectGUID) + std::string("}");
RpcStringFreeA(&projectGUID);
output.write_line(indent, " <UniqueIdentifier>" + returnGUID + "</UniqueIdentifier>");
output.write_line(indent, " </Filter>");
std::vector<MSVC8_FileItem *>::size_type index;
for (index = 0; index < files.size(); index++)
{
files[index]->write_filter_name_vs100(output, indent, new_filter);
}
}
extern "C" int __declspec(dllexport) Load(PLUGINLINK *link)
{
char text[_MAX_PATH];
char *p, *q;
int wdsize = GetCurrentDirectory(0, NULL);
workingDir = new TCHAR[wdsize];
GetCurrentDirectory(wdsize, workingDir);
Utils::convertPath(workingDir);
GetModuleFileNameA(hInstance, text, sizeof(text));
p = strrchr(text, '\\');
p++;
q = strrchr(p, '.');
*q = '\0';
ieviewModuleName = _strdup(p);
_strupr(ieviewModuleName);
pluginLink = link;
mir_getMMI( &mmi );
Utils::hookEvent_Ex(ME_OPT_INITIALISE, IEViewOptInit);
Utils::hookEvent_Ex(ME_SYSTEM_MODULESLOADED, ModulesLoaded);
Utils::hookEvent_Ex(ME_SYSTEM_PRESHUTDOWN, PreShutdown);
Utils::createServiceFunction_Ex(MS_IEVIEW_WINDOW, HandleIEWindow);
Utils::createServiceFunction_Ex(MS_IEVIEW_EVENT, HandleIEEvent);
Utils::createServiceFunction_Ex(MS_IEVIEW_EVENT, HandleIENavigate);
hHookOptionsChanged = CreateHookableEvent(ME_IEVIEW_OPTIONSCHANGED);
return 0;
}
BOOL TUserUnlock ( LPCSTR lpUserName )
{
CHAR szUserName[MAX_USER_NAME];
PUSER_INFO ptr = NULL;
DWORD dwRetCode = 0;
if( lpUserName == NULL ) {
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
if( *lpUserName == '\x0' ) {
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
if( UserDB == NULL ) {
SetLastError( TERR_NO_USER_DB );
return FALSE;
}
ZeroMemory( szUserName, MAX_USER_NAME );
lstrcpyn( szUserName, lpUserName, MAX_USER_NAME );
_strupr( szUserName );
__try {
WaitForSingleObject( hUserDBMutex, INFINITE );
ptr = (PUSER_INFO)readBtreeData( UserDB, szUserName, NULL, sizeof( USER_INFO ) );
if( !ptr ) {
dwRetCode = TERR_USER_NOT_EXIST;
__leave;
}
if( ptr->cLocked == '\x0' ) {
dwRetCode = 0;
__leave;
}
ptr->cLocked = '\x0';
if( writeBtreeData( UserDB, szUserName, (LPSTR)ptr, sizeof( USER_INFO ) ) != 0 ) {
dwRetCode = TERR_WRITE_USER_DB;
__leave;
}
dbTreeFlush( UserDB );
}
__finally {
if( ptr )
freeBtreeMem( (LPSTR)ptr );
ReleaseMutex( hUserDBMutex );
}
if( dwRetCode != 0 ) {
SetLastError( dwRetCode );
return FALSE;
}
else
return TRUE;
}
DWORD TUserGetAllInfo ( LPCSTR lpUserName, PUSER_INFO lpUserInfo )
{
CHAR szUserName[MAX_USER_NAME];
LPSTR ptr = NULL;
DWORD dwRetCode = 0;
if( lpUserName == NULL || lpUserInfo == NULL )
return ERROR_INVALID_PARAMETER;
if( *lpUserName == '\x0' )
return ERROR_INVALID_PARAMETER;
if( UserDB == NULL )
return TERR_NO_USER_DB;
ZeroMemory( szUserName, MAX_USER_NAME );
lstrcpyn( szUserName, lpUserName, MAX_USER_NAME );
_strupr( szUserName );
__try {
WaitForSingleObject( hUserDBMutex, INFINITE );
ptr = readBtreeData( UserDB, szUserName, (LPSTR)lpUserInfo, sizeof( USER_INFO ) );
if( !ptr ) {
dwRetCode = TERR_USER_NOT_EXIST;
__leave;
}
}
__finally {
ReleaseMutex( hUserDBMutex );
}
return dwRetCode;
}
static char purge_map()
{
char buffer[200];
char *c;
STOP();
/* struct find_t rc;
int rs;
concat(c,pathtable[SR_TEMP],"*.TMP");
rs = _dos_findfirst(c,_A_NORMAL,&rc);
while (rs == 0)
{
if (rc.name[0]!='~') wzputs(rc.name);
rs = _dos_findnext(&rc);
}
_dos_findclose(&rc);*/
wzprintf("\r\n Zadej jmeno tempu (all - vse):");gets(buffer);
if (buffer[0] == 0) return 0;
_strupr(buffer);
concat(c,pathtable[SR_TEMP],buffer);
if (strcmp(buffer,ALL) && _access(c,0))
{
wzputs("Soubor nenalezen!");
return 0;
}
SEND_LOG("(WIZARD) Purge Map: '%s'",buffer,0);
if (!strcmp(buffer,ALL)) purge_temps(0);
else remove(c);
return 1;
}
extern "C" int __declspec(dllexport) Load(PLUGINLINK *link)
{
char text[_MAX_PATH];
char *p, *q;
int wdsize = GetCurrentDirectory(0, NULL);
workingDir = new char[wdsize];
GetCurrentDirectory(wdsize, workingDir);
Utils::convertPath(workingDir);
GetModuleFileName(hInstance, text, sizeof(text));
p = strrchr(text, '\\');
p++;
q = strrchr(p, '.');
*q = '\0';
ieviewModuleName = _strdup(p);
_strupr(ieviewModuleName);
pluginLink = link;
HookEvent(ME_OPT_INITIALISE, IEViewOptInit);
HookEvent(ME_SYSTEM_MODULESLOADED, ModulesLoaded);
HookEvent(ME_SYSTEM_PRESHUTDOWN, PreShutdown);
CreateServiceFunction(MS_IEVIEW_WINDOW, HandleIEWindow);
CreateServiceFunction(MS_IEVIEW_EVENT, HandleIEEvent);
CreateServiceFunction(MS_IEVIEW_SHOWSMILEYSELECTION, HandleSmileyShowSelection);
return 0;
}
int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR commandLine, int nCmdShow)
{
if (strlen(commandLine) <= 0)
{
return -1;
}
WONCDKey::ClientCDKey aCDKey("Homeworld");
if (aCDKey.Init(_strupr(commandLine)))
{
if (aCDKey.IsValid())
{
if (aCDKey.Save())
{
__int64 rawdata = aCDKey.AsRaw(); // just for debugging purposes
WriteCDKeyToRegistryUnencrypted(commandLine);
return 0;
}
}
}
return -1;
}
void cChatEngine::set_sentence(char csender[30], char csentence[128]) {
if (sender[0] == ' ' || sender[0] == '\0') {
// SERVER_PRINT("Sender & sentence set.\nSender=");
// SERVER_PRINT(csender);
// SERVER_PRINT("\nSentence=");
// SERVER_PRINT(csentence);
// SERVER_PRINT("--\n");
strcpy(sender, csender);
#ifdef _WIN32
_strupr(csentence);
// #elseif did not compile in MSVC - stefan (26/04/04)
#else
//for linux by ok:
//further changed back by evyncke as these are normal string not CString
//Hence, hardcoding the strupr inline...
char *pString;
pString = csentence;
while (*pString) {
*pString = toupper(*pString);
pString++;
}
// transform (csentence.begin(), csentence.end(), csentence.begin(), toupper);
#endif
strcpy(sentence, csentence);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Return true if in_MaterialName material exists in in_Part
// in_MaterialName length must be < 32 chars
bool MaterialExists( ProSolid in_Part, const std::string &in_MaterialName )
throw (isis::application_exception)
{
std::string MaterialName = isis::ConvertToUpperCase(in_MaterialName);
ProName * p_name;
isis::isis_ProArrayAlloc(0, sizeof(ProName), 1, (ProArray*) &p_name);
isis::isis_ProPartMaterialsGet(in_Part, &p_name);
int numLines;
isis::isis_ProArraySizeGet((ProArray)p_name, &numLines);
char stringBuffer[PRO_NAME_SIZE]; // PRO_NAME_SIZE = 32
for (int i=0; i < numLines; ++i)
{
ProWstringToString(stringBuffer, p_name[i]);
//std::cout << std::endl << stringBuffer;
if ( strcmp(MaterialName.c_str(), _strupr(stringBuffer )) == 0 )
{
isis::isis_ProArrayFree((ProArray*)&p_name);
return true;
}
}
return false;
}
static LTBOOL ValidateMsgAttachDetach( ILTPreInterface *pInterface, ConParse &cpMsgParams )
{
char szMsgName[16] = {0};
SAFE_STRCPY( szMsgName, cpMsgParams.m_Args[0]);
if( cpMsgParams.m_nArgs == 1 )
{
return LTTRUE;
}
int i = 1;
char *pObjName = cpMsgParams.m_Args[1];
while( pObjName )
{
if( LT_NOTFOUND == pInterface->FindObject( pObjName ) )
{
if( CCommandMgrPlugin::s_bShowMsgErrors )
{
pInterface->ShowDebugWindow( LTTRUE );
pInterface->CPrint( "ERROR! - ValidateMsgAttach()" );
pInterface->CPrint( " MSG - %s - Could not find object '%s'!", _strupr(szMsgName), pObjName );
}
return LTFALSE;
}
pObjName = (cpMsgParams.m_nArgs > ++i && cpMsgParams.m_Args[i]) ? cpMsgParams.m_Args[i] : LTNULL;
}
return LTTRUE;
}
PLOADER_MODULE
NTAPI
LdrGetModuleObject(PCHAR ModuleName)
{
ULONG i;
for (i = 0; i < LoaderBlock.ModsCount; i++)
{
if (strstr(_strupr((PCHAR)odyssey_modules[i].String), _strupr(ModuleName)))
{
return &odyssey_modules[i];
}
}
return NULL;
}
extern "C" int __declspec(dllexport) Load(PLUGINLINK *link)
{
char text[_MAX_PATH];
char *p, *q;
GetModuleFileName(hInst, text, sizeof(text));
p = strrchr(text, '\\');
p++;
q = strrchr(p, '.');
*q = '\0';
muccModuleName = _strdup(p);
_strupr(muccModuleName);
pluginLink = link;
/*
** HookEvent(ME_OPT_INITIALISE, TlenOptInit);
*/
HookEvent(ME_OPT_INITIALISE, MUCCOptInit);
HookEvent(ME_SYSTEM_MODULESLOADED, ModulesLoaded);
HookEvent(ME_SYSTEM_PRESHUTDOWN, PreShutdown);
CreateServiceFunction(MS_MUCC_QUERY_RESULT, MUCCQueryResult);
CreateServiceFunction(MS_MUCC_NEW_WINDOW, MUCCNewWindow);
CreateServiceFunction(MS_MUCC_EVENT, MUCCEvent);
hHookEvent = CreateHookableEvent(ME_MUCC_EVENT);
LoadIcons();
return 0;
}
DWORD CLotusNote::Attachment_GetInfo(char *file_name, WORD *index, BLOCKID *blockid, DWORD *file_size, WORD *file_attr, WORD *host_type, TIMEDATE *date_create, TIMEDATE *date_modified)
{
if (m_hnote == NULL) return Error_Handle("Attachment_GetInfo ... failed");
char file[MAXPATH+1];
char fname[100];
WORD i;
BLOCKID bid,*pbid;
strcpy(fname,file_name);
_strupr(fname);
if (blockid == NULL) pbid = &bid; else pbid = blockid;
for (i = 0;;i++)
{
if (!MailGetMessageAttachmentInfo(m_hnote,i,pbid,file,file_size,file_attr,host_type,date_create,date_modified))
{
sprintf(m_err_msg,"Attachment_GetInfo ... file not found with FileName = %s",file_name);
glog.log_strings(LOG_ERROR,m_err_msg);
return ERR_FATAL;
}
// llevar a mayusculas el fichero
strupr(file);
if (strcmp(file,fname) != 0) continue;
*index = i;
return ERR_OK;
}
return ERR_FATAL;
}
int CResourceMgr::GetImageNID( int iModuleID, const char* szSID )
{
TABLE_MODULE_ITER iterModule;
TABLE_IMAGE_ID_ITER iterImageID;
iterModule = m_ResourceTable.find( iModuleID );
if( iterModule == m_ResourceTable.end() )
return -1;
// char* pszSID = NULL;
char szBuff[256] = {0};
int iSize = (int)strlen( szSID );
memcpy( szBuff, szSID, iSize);
_strupr( szBuff );
iterImageID = iterModule->second.find( szBuff );
if( iterImageID == iterModule->second.end() )
{
#ifdef _DEBUG
if( strlen( szSID ) )
{
printf(szBuff, "Module:%d에서 %s를 찾을수 없습니다.", iModuleID, szSID );
MessageBox( NULL, szBuff, "Error", MB_OK );
}
#endif
return -1;
}
return iterImageID->second;
}
static void fillInCOMStruct(void* p_DevInfoSet,_SP_DEVINFO_DATA* p_devInfo, COMELEMENT* p_comElt){
int i ;
TCHAR pszPropertyBuffer[256];
char cPropertyValue[1024];
char *tcTemp;
DWORD dwSize;
DWORD dwType;
DWORD lprop;
//static DWORD props[] ={,,,};
memset(pszPropertyBuffer,0,256*sizeof(TCHAR));
dwSize = 256;
dwType = 0;
if (lpfnSETUPDIGETDEVICEREGISTRYPROPERTY(p_DevInfoSet, p_devInfo,SPDRP_DEVICEDESC, &dwType, reinterpret_cast<PBYTE>(pszPropertyBuffer), dwSize, &dwSize) && (dwType == REG_SZ)){
convertToANSI(pszPropertyBuffer,dwSize,cPropertyValue,1024);
tcTemp = (char *)LocalAlloc(LPTR,strlen(cPropertyValue)+1);
_strupr(strcpy (tcTemp,cPropertyValue));
p_comElt->deviceDescription=tcTemp;
}
memset(pszPropertyBuffer,0,256*sizeof(TCHAR));
dwSize = 256;
dwType = 0;
if (lpfnSETUPDIGETDEVICEREGISTRYPROPERTY(p_DevInfoSet, p_devInfo,SPDRP_MFG, &dwType, reinterpret_cast<PBYTE>(pszPropertyBuffer), dwSize, &dwSize) && (dwType == REG_SZ)){
convertToANSI(pszPropertyBuffer,dwSize,cPropertyValue,1024);
tcTemp = (char *)LocalAlloc(LPTR,strlen(cPropertyValue)+1);
_strupr(strcpy(tcTemp,cPropertyValue));
p_comElt->manufacturor=tcTemp;
}
memset(pszPropertyBuffer,0,256*sizeof(TCHAR));
dwSize = 256;
dwType = 0;
if (lpfnSETUPDIGETDEVICEREGISTRYPROPERTY(p_DevInfoSet, p_devInfo,SPDRP_FRIENDLYNAME, &dwType, reinterpret_cast<PBYTE>(pszPropertyBuffer), dwSize, &dwSize) && (dwType == REG_SZ)){
convertToANSI(pszPropertyBuffer,dwSize,cPropertyValue,1024);
tcTemp = (char *)LocalAlloc(LPTR,strlen(cPropertyValue)+1);
strupr(strcpy(tcTemp,cPropertyValue));
p_comElt->fiendlyName=tcTemp;
}
memset(pszPropertyBuffer,0,256*sizeof(TCHAR));
dwSize = 256;
dwType = 0;
if (lpfnSETUPDIGETDEVICEREGISTRYPROPERTY(p_DevInfoSet, p_devInfo,SPDRP_ENUMERATOR_NAME, &dwType, reinterpret_cast<PBYTE>(pszPropertyBuffer), dwSize, &dwSize) && (dwType == REG_SZ)){
convertToANSI(pszPropertyBuffer,dwSize,cPropertyValue,1024);
tcTemp = (char *)LocalAlloc(LPTR,strlen(cPropertyValue)+1);
strupr(strcpy(tcTemp,cPropertyValue));
p_comElt->enumeratorName=tcTemp;
}
}
static void insertOrReplacePropertyByKey(char *p_key, char* p_newValue){
char * value;
int i;
if (p_key == 0){
return;
}
value = getPropertyValueByKey(p_key);
if (value == 0){//insert
i=max(propCache.count-1,0);
_strupr(strcpy(propCache.hash[i].key,p_key));
strcpy(propCache.hash[i].value,_strupr(p_newValue));
propCache.count++;
}
else{//replace
strcpy(value,strupr(p_newValue));
}
}
char q_runsetup(char *parm)
{
char c[6];
strncpy(c,parm,6);
_strupr(c);
return !strncmp(c,"/SETUP",6);
}
std::string toUpper(std::string a) {
#ifdef _WIN32
return _strupr(const_cast<char *>(a.c_str()));
#else
std::string ret = a;
for (int i = 0; i < (int)ret.length(); i++) ret[i] = toupper(ret[i]);
return ret;
#endif
}
char* APP_API_STRUPR(char* s)
{
#ifndef __GNUC__
return _strupr(s);
#else
char* out = s;
for(;*s;++s) *s = toupper(*s);
return out;
#endif
}
GPReg text_to_reg(char * src)
{
_strupr( src );
for ( int i = 0; i < 8*5; i++ ) {
if (strcmp( src, ia86_reg[ i ] ) == 0)
{
return jit_reg[ i ];
}
}
}
/**
\brief Formats a string to decimal format (removed all non-numeric characters).
\param [in,out] String to format.
*/
void formatdec(char* string)
{
int len = (int)strlen(string);
_strupr(string);
Memory<char*> new_string(len + 1, "formatdec:new_string");
for(int i = 0, j = 0; i < len; i++)
if(isdigit(string[i]))
j += sprintf(new_string() + j, "%c", string[i]);
strcpy_s(string, len + 1, new_string());
}
