static Direct2DVersion systemVersion() {
static const int bufSize = 512;
TCHAR filename[bufSize];
UINT i = GetSystemDirectory(filename, bufSize);
if (i > 0 && i < bufSize) {
if (_tcscat_s(filename, bufSize, __TEXT("\\d2d1.dll")) == 0) {
DWORD versionInfoSize = GetFileVersionInfoSize(filename, NULL);
if (versionInfoSize) {
QVector<BYTE> info(versionInfoSize);
if (GetFileVersionInfo(filename, NULL, versionInfoSize, info.data())) {
UINT size;
DWORD *fi;
if (VerQueryValue(info.constData(), __TEXT("\\"), (LPVOID *) &fi, &size) && size) {
VS_FIXEDFILEINFO *verInfo = (VS_FIXEDFILEINFO *) fi;
return Direct2DVersion(HIWORD(verInfo->dwFileVersionMS),
LOWORD(verInfo->dwFileVersionMS),
HIWORD(verInfo->dwFileVersionLS),
LOWORD(verInfo->dwFileVersionLS));
}
}
}
}
}
return Direct2DVersion();
}
void Dump(PPUBLISHERINFO pPublisherInfo)
{
VERBOSE(__TEXT("pPublisherInfo:\r\n"));
VERBOSE(__TEXT("\tdwMode = %#x\r\n"), pPublisherInfo->dwMode);
VERBOSE(__TEXT("\twMinoutlinePPEM = %d\r\n"), pPublisherInfo->wMinoutlinePPEM);
VERBOSE(__TEXT("\twMaxbitmapPPEM = %d\r\n"), pPublisherInfo->wMaxbitmapPPEM);
}
/* free_space -
* return:
* path(in):
*
* Note:
* This function is designed to be compatible with both wide character
* and single byte character strings. Hence, the use of tchar.h.
* The definition of 'UNICODE' during compilation determines that TCHAR
* becomes 'wchar_t' and not 'char'. If so, we assume that 'path' is
* already a wide character type.
*/
int
free_space (const char *path)
{
ULARGE_INTEGER freebytes_user, total_bytes, freebytes_system;
TCHAR disk[PATH_MAX];
TCHAR *temp = NULL;
/* If there is a : then change c:\foo\bar to c:\ */
_tcsncpy (disk, (TCHAR *) path, PATH_MAX);
temp = _tcschr (disk, __TEXT (':'));
if (temp)
{
++temp; /* move past the colon */
if (*temp == __TEXT ('\\') || *temp == __TEXT ('/'))
{
++temp;
}
*temp = __TEXT ('\0'); /* terminate the string */
}
/* if there's no colon use the root of local dir by passing a NULL */
if (!GetDiskFreeSpaceEx ((temp) ? disk : NULL,
&freebytes_user, &total_bytes, &freebytes_system))
{
return (-1);
}
else
{
return ((int) (freebytes_user.QuadPart / IO_PAGESIZE));
}
}
static BOOL IsChildDir (WIN32_FIND_DATA *lpFindData) {
return(
((lpFindData->dwFileAttributes &
FILE_ATTRIBUTE_DIRECTORY) != 0) &&
(lstrcmp(lpFindData->cFileName, __TEXT(".")) != 0) &&
(lstrcmp(lpFindData->cFileName, __TEXT("..")) != 0));
}
bool log::init(const char_t* file_name, log::__enuLOG_TYPE type, log::size_t max_buffer_size)
{
size_t size = 0;
switch(type){
case LOG_FILE_TYPE:
{
type_ = type;
file_handle_= __matrix_fsopen(file_name, __TEXT("a+"), _SH_DENYWR);
if(file_handle_ == NULL){
OutputDebugString(__TEXT("can not open a log file!"));
return false;
}
}
break;
case DBGVIEW_TYPE:
type_ = type;
break;
case CONSOLE_TYPE:
type_ = type;
if(!alloc_console_private()){
OutputDebugString(__TEXT("can not allocate a console window!"));
return false;
}
break;
default:
if(file_name != NULL){
size = __matrix_strnlen_s(file_name, MAX_STRING_SIZE);
if(size > 0){
file_handle_= __matrix_fsopen(file_name, __TEXT("a+"), _SH_DENYWR);
type_ = file_handle_ == NULL ? log::DBGVIEW_TYPE : log::LOG_FILE_TYPE;
}
}
break;
}
if(max_buffer_size >= max_buffer_size_) max_buffer_size_ = max_buffer_size + 4;
if(buffer_internal_){
free(buffer_internal_);
buffer_internal_ = NULL;
}
else{
buffer_internal_ = (char_t*)malloc(max_buffer_size_* sizeof(char_t));
memset(buffer_internal_, 0x0, sizeof(char_t) * max_buffer_size_);
}
return true;
}
void Dump(POEMDMPARAM pOemDMParam)
{
VERBOSE(__TEXT("pOemDMParam:\r\n"));
VERBOSE(__TEXT("\tcbSize = %d\r\n"), pOemDMParam->cbSize);
VERBOSE(__TEXT("\tpdriverobj = %#x\r\n"), pOemDMParam->pdriverobj);
VERBOSE(__TEXT("\thPrinter = %#x\r\n"), pOemDMParam->hPrinter);
VERBOSE(__TEXT("\thModule = %#x\r\n"), pOemDMParam->hModule);
VERBOSE(__TEXT("\tpPublicDMIn = %#x\r\n"), pOemDMParam->pPublicDMIn);
VERBOSE(__TEXT("\tpPublicDMOut = %#x\r\n"), pOemDMParam->pPublicDMOut);
VERBOSE(__TEXT("\tpOEMDMIn = %#x\r\n"), pOemDMParam->pOEMDMIn);
VERBOSE(__TEXT("\tpOEMDMOut = %#x\r\n"), pOemDMParam->pOEMDMOut);
VERBOSE(__TEXT("\tcbBufSize = %d\r\n"), pOemDMParam->cbBufSize);
}
void Dump(PPROPSHEETUI_INFO pPSUIInfo)
{
VERBOSE(__TEXT("pPSUIInfo:\r\n"));
VERBOSE(__TEXT("\tcbSize = %d\r\n"), pPSUIInfo->cbSize);
VERBOSE(__TEXT("\tVersion = %#x\r\n"), pPSUIInfo->Version);
VERBOSE(__TEXT("\tFlags = %#x\r\n"), pPSUIInfo->Flags);
VERBOSE(__TEXT("\tReason = %d\r\n"), pPSUIInfo->Reason);
VERBOSE(__TEXT("\thComPropSheet = %#x\r\n"), pPSUIInfo->hComPropSheet);
VERBOSE(__TEXT("\tpfnComPropSheet = %#x\r\n"), pPSUIInfo->pfnComPropSheet);
VERBOSE(__TEXT("\tlParamInit = %#x\r\n"), pPSUIInfo->lParamInit);
VERBOSE(__TEXT("\tUserData = %#x\r\n"), pPSUIInfo->UserData);
VERBOSE(__TEXT("\tResult = %#x\r\n"), pPSUIInfo->Result);
}
std::string
Variant::typeToString(Type t)
{
switch (t)
{
case Void: return "void";
case Int: return "int";
case Float: return "float";
case Bool: return "bool";
case Float4: return "float4";
case String: return "string";
case Float4x4: return "float4x4";
case Blob: return "blob";
case Guid: return "guid";
case Object: return "object";
case IntArray: return "intarray";
case FloatArray: return "floatarray";
case BoolArray: return "boolarray";
case Float4Array: return "float4array";
case Float4x4Array: return "float4x4Array";
case StringArray: return "stringarray";
default:
throw failure(tformat(__TEXT("Variant::typeToString(): invalid type enum '%d'!")) % t);
}
}
void CStatic::GoUrl()
{
TCHAR urlBuf[1024];
ConvertAnsiToTChar(url, urlBuf, 1024);
ShellExecute(NULL, __TEXT("open"), urlBuf, NULL, NULL, SW_SHOWNORMAL);
}
Variant::Type
Variant::stringToType(const std::string& str)
{
if ("void" == str) return Void;
else if ("int" == str) return Int;
else if ("float" == str) return Float;
else if ("bool" == str) return Bool;
else if ("float4" == str) return Float4;
else if ("color" == str) return Float4; // NOT A BUG!
else if ("string" == str) return String;
else if ("Float4x4" == str) return Float4x4;
else if ("blob" == str) return Blob;
else if ("guid" == str) return Guid;
else if ("object" == str) return Object;
else if ("intarray" == str) return IntArray;
else if ("floatarray" == str) return FloatArray;
else if ("boolarray" == str) return BoolArray;
else if ("float4array" == str) return Float4Array;
else if ("Float4x4array" == str) return Float4x4Array;
else if ("stringarray" == str) return StringArray;
else
{
throw failure(tformat(__TEXT("Variant::stringToType(): invalid type string!")));
}
}
bool
Variant::operator<=(const Variant& rhs) const
{
if (rhs._type == _type)
{
switch (rhs._type)
{
case Void:
return true;
case Int:
return (_value.i <= rhs._value.i);
case Bool:
return (_value.b <= rhs._value.b);
case Float:
return (_value.f[0] <= rhs._value.f[0]);
case String:
return ((*_value.string) <= (*rhs._value.string));
case Float4:
return ((_value.f[0] <= rhs._value.f[0]) &&
(_value.f[1] <= rhs._value.f[1]) &&
(_value.f[2] <= rhs._value.f[2]) &&
(_value.f[3] <= rhs._value.f[3]));
case Object:
return (_value.object <= rhs._value.object);
default:
throw failure(__TEXT("Variant::operator<(): invalid variant type!"));
}
}
return false;
}
line_socket::line_socket():ip_(__TEXT("")), port_(0), recv_buff_size_(line_socket::CURRENT_RECVBUF_SIZE), stop_event_(FALSE, TRUE)
{
packet_id_ = timestep_ = GetTickCount();
recv_proc_thread_ = NULL;
check_timeout_thread_ = NULL;
send_proc_thread_ = NULL;
}
bool log::alloc_console_private()
{
char image_path[MAX_STRING_SIZE] = {0};
bool is_ok = true;
PLOADED_IMAGE loaded_image_ptr = NULL;
GetModuleFileNameA(NULL, image_path, sizeof(image_path));
loaded_image_ptr = ImageLoad(image_path, NULL);
switch(loaded_image_ptr->FileHeader->OptionalHeader.Subsystem){
case IMAGE_SUBSYSTEM_UNKNOWN:
is_ok = false;
break;
case IMAGE_SUBSYSTEM_NATIVE:
case IMAGE_SUBSYSTEM_WINDOWS_GUI:
case IMAGE_SUBSYSTEM_OS2_CUI:
case IMAGE_SUBSYSTEM_NATIVE_WINDOWS:
case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
if(AllocConsole() == FALSE) is_ok = false;
break;
case IMAGE_SUBSYSTEM_WINDOWS_CUI:
case IMAGE_SUBSYSTEM_POSIX_CUI:
break;
}
ImageUnload(loaded_image_ptr);
std_output_handler_ = GetStdHandle(STD_OUTPUT_HANDLE);
__matrix_setlocale(LC_ALL, __TEXT("chs"));
return is_ok;
}
/**
@fn void set_frame_head_and_tail(m_oCommFrameStruct& frame)
@detail 填写数据包头尾信息
@param[in] frame 数据包头
@return void
@note
*/
BOOL line_socket::Create(UINT nSocketPort, int nSocketType,LPCTSTR lpszSocketAddress)
{
BOOL b_ret = TRUE;
if(lpszSocketAddress != NULL) ip_.Format(__TEXT("%s"), lpszSocketAddress);
if(nSocketPort != 0) port_ = nSocketPort;
b_ret = CAsyncSocket::Create(0x0, nSocketType, FD_READ|FD_WRITE|FD_CONNECT|FD_CLOSE, NULL);
//设置接受缓冲
int iOptionValue = recv_buff_size_ != 0 ?recv_buff_size_ : CURRENT_RECVBUF_SIZE;
int iOptionLen = sizeof(int);
SetSockOpt(SO_RCVBUF, (void*)&iOptionValue, iOptionLen, SOL_SOCKET);
//设置发送缓冲为0
iOptionValue = 0;
iOptionLen = sizeof(int);
SetSockOpt(SO_SNDBUF, (void*)&iOptionValue, iOptionLen, SOL_SOCKET);
if(b_ret) {
recv_proc_thread_ = AfxBeginThread(recv_processing_thread_proc, this);
check_timeout_thread_ = AfxBeginThread(check_timeout_thread_proc, this);
send_proc_thread_ = AfxBeginThread(send_processing_thread_proc, this);
if(recv_proc_thread_ == NULL || check_timeout_thread_ == NULL || send_proc_thread_ == NULL) {
Close();
b_ret = FALSE;
}
}
return b_ret;
}
static void
register_service(int argc, char *argv[])
{
SC_HANDLE newService, scm;
BOOL started;
LPCTSTR dependencies = __TEXT("Tcpip\0winmgmt\0\0");
sw_debug(SW_LOG_NOTICE, "registering %s\n", argv[0]);
//
// open a connection to the SCM
//
scm = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
if (!scm)
{
service_error_handler("In OpenScManager", GetLastError());
}
//
// Install the new service
//
newService = CreateService(
scm,
SERVICE_NAME,
SERVICE_NAME,
SERVICE_ALL_ACCESS,
SERVICE_WIN32_SHARE_PROCESS,
SERVICE_AUTO_START,
SERVICE_ERROR_NORMAL,
argv[0],
0,
0,
dependencies,
0,
0);
if (!newService)
{
service_error_handler("In CreateService", GetLastError());
exit(0);
}
sw_debug(SW_LOG_NOTICE, "registered service\n");
sw_debug(SW_LOG_NOTICE, "starting service\n");
started = StartService(newService, 0, NULL);
if (!started)
{
service_error_handler("StartService", GetLastError());
exit(0);
}
//
// clean up
//
CloseServiceHandle(newService);
CloseServiceHandle(scm);
sw_debug(SW_LOG_NOTICE, "finished\n");
}
void Dlg_OnCommand (HWND hwnd, int id, HWND hwndCtl,
UINT codeNotify) {
switch (id) {
case IDC_START:
// Validate period and number of samples then
// start the timer.
g_uPeriod = GetDlgItemInt(hwnd, IDC_EDITPERIOD,
NULL, FALSE);
if (g_uPeriod > INT_MAX) {
MessageBox(NULL,
__TEXT("Period must be <= 2147483647 ")
__TEXT("or a flood of messages ensues"),
NULL, MB_OK);
}
g_nSamplesMax = GetDlgItemInt(hwnd,
IDC_EDITSAMPLES, NULL, FALSE);
if ((g_nSamplesMax < 2) || (g_nSamplesMax > 16384)) {
MessageBox(NULL,
__TEXT("Samples must be >= 2 and <= 16384"),
NULL, MB_OK);
} else {
// Clear the report
Edit_SetText(GetDlgItem(hwnd, IDC_EDITREPORT),
_TEXT(""));
if (!Dlg_StartTimer(hwnd)) {
MessageBox(NULL,
__TEXT("Unable to start timer."),
NULL, MB_OK);
}
}
break;
case IDC_STOP:
Dlg_StopTimer(hwnd);
break;
case IDCANCEL:
Dlg_StopTimer(hwnd);
EndDialog(hwnd, id);
break;
}
}
void
Variant::copy(const Variant& rhs)
{
assert(Void == _type);
_type = rhs._type;
switch (rhs._type)
{
case Void:
break;
case Int:
_value.i = rhs._value.i;
break;
case Float:
_value.f[0] = rhs._value.f[0];
break;
case Bool:
_value.b = rhs._value.b;
break;
case Float4:
_value.f[0] = rhs._value.f[0];
_value.f[1] = rhs._value.f[1];
_value.f[2] = rhs._value.f[2];
_value.f[3] = rhs._value.f[3];
break;
case String:
_value.string = new std::string(*rhs._value.string);
break;
case Float4x4:
_value.matrix = new float4x4(*rhs._value.matrix);
break;
case Object:
_value.object = rhs._value.object;
break;
case IntArray:
_value.intArray = new std::vector<int>(*rhs._value.intArray);
break;
case FloatArray:
_value.floatArray = new std::vector<float>(*rhs._value.floatArray);
break;
case BoolArray:
_value.boolArray = new std::vector<bool>(*rhs._value.boolArray);
break;
case Float4Array:
_value.float4Array = new std::vector<float4>(*rhs._value.float4Array);
break;
case Float4x4Array:
_value.float4x4Array = new std::vector<float4x4>(*rhs._value.float4x4Array);
break;
case StringArray:
_value.stringArray = new std::vector<std::string>(*rhs._value.stringArray);
break;
default:
throw failure(__TEXT("Variant::copy(): invalid type!"));
break;
}
}
int main(int argc, char* argv[] )
#endif
{
MyApplication* App = new MyApplication;
App->Create(__TEXT("Application"), true, 1280, 720);
while(App->Loop());
return 0;
}
bool OpenKeyAndSetValue(LPCTSTR szKeyName, LPCTSTR szValue) {
HKEY hKey;
long retVal;
retVal = RegOpenKeyEx(HKEY_CLASSES_ROOT,szKeyName,0,KEY_WRITE,&hKey);
if (retVal == ERROR_SUCCESS) {
RegSetValue(hKey,__TEXT(""),REG_SZ,szValue,lstrlen(szValue));
RegCloseKey(hKey);
}
return retVal == ERROR_SUCCESS;
}
void core::NativeWindow::destroy(void)
{
#if defined(VTX_PLATFORM_WIN32)
HINSTANCE instance = GetModuleHandle(NULL);
CloseWindow(this->handle);
DestroyWindow(this->handle);
UnregisterClass(__TEXT("VortexWin32"), instance);
#endif
#if defined(VTX_PLATFORM_LINUX)
// TODO: Do it!
#endif
}
Nena::Application::Window::Window()
: ScreenWidth(800)
, ScreenHeight(600)
, Width(800)
, Height(600)
, Instance(::GetModuleHandle(NULL))
, Style(GameWindowStyle)
, Name(__TEXT("NenaWindowClass"))
, Fullscreen(false)
, Raw(nullptr)
, TrustDxgi(FALSE)
{
::OutputDebugStringA("Nena::Application::Window::Window()\n");
}
BOOL CeguiInject::RegVip() {
std::string str;
_int32 i_rnd;
std::string v_msgstr;
ks_setSoftVal(v_softcode, (LPSTR)v_softkey.c_str());
//-- 传递用户相关信息给
std::string strVipCard = std::string((const char*)m_vipCard.toLocal8Bit());
strVipCard.erase(0, strVipCard.find_first_not_of(" "));
strVipCard.erase(strVipCard.find_last_not_of(" ") + 1);
ks_setUserVal(1, (LPSTR)strVipCard.c_str(), "", (LPSTR)v_bdinfo.c_str());
////-- 设置自动升级相关信息给DLL，不用自动升级功能的话，下边一段完全可以删掉
////-- 参数：1本登陆窗口的窗口句柄, 2当前软件的版本号, 3用户是否选择了检查更新
//ks_setUpVal((_int32)this->m_hWnd, v_softversion, (_int32)(m_Checkupdate.GetCheck()));
//-- 开始验证
srand((unsigned)time(NULL));
//i_rnd = (int)(49 * rand() / (RAND_MAX + 1.0));
i_rnd = rand() % 50;
v_msgstr = ks_IdCheck((LPSTR)(signData.substr(i_rnd * 8, 8)).c_str(), 1);
if (iserrno(v_msgstr)) {
MsgBox(ks_GetMsg((LPSTR)v_msgstr.c_str()));
return FALSE;
}
std::string lsS = v_msgstr;
//if(signData.Mid(i_rnd * 8 + 400, 8) != v_msgstr) {
if (signData.substr((i_rnd + 50) * 8, 8) != v_msgstr) {
lsS += __TEXT(",");
lsS += signData.substr((i_rnd + 50) * 8, 8);
w_ini(__TEXT("signdata"), "err", lsS);
myExitProcess(); //掐进程
}
return TRUE;
}
//! notifies the device that it should close itself
void CIrrDeviceWinCE::closeDevice()
{
MSG msg;
PeekMessage(&msg, NULL, WM_QUIT, WM_QUIT, PM_REMOVE);
PostQuitMessage(0);
PeekMessage(&msg, NULL, WM_QUIT, WM_QUIT, PM_REMOVE);
if (!ExternalWindow)
{
DestroyWindow(HWnd);
const fschar_t* ClassName = __TEXT("CIrrDeviceWin32");
HINSTANCE hInstance = GetModuleHandle(0);
UnregisterClass(ClassName, hInstance);
}
Close=true;
}
void
StackWalker::printModule(const util::string& img, const util::string& mod, DWORD64 baseAddr, DWORD size, DWORD result, const util::string& symType, const util::string& pdbName, ULONGLONG fileVersion) noexcept
{
if (_options & _Mybase::module_info)
{
if (_options & _Mybase::file_version)
{
DWORD v4 = (DWORD)(fileVersion)& 0xFFFF;
DWORD v3 = (DWORD)(fileVersion >> 16) & 0xFFFF;
DWORD v2 = (DWORD)(fileVersion >> 32) & 0xFFFF;
DWORD v1 = (DWORD)(fileVersion >> 48) & 0xFFFF;
this->print(tformat(__TEXT("%s:%s (%p), size: %d (result: %d), SymType: '%s', PDB: '%s', fileVersion: %d.%d.%d.%d")) % img % mod % baseAddr % size % result % symType % pdbName % v1 % v2 % v3 % v4, _module);
}
else
{
this->print(tformat(__TEXT("%s:%s (%p), size: %d (result: %d), SymType: '%s', PDB: '%s'")) % img % mod % baseAddr % size % result % symType % pdbName, _module);
//---------------------------------------------------------------------
// ThreadFunc
// Notice: - the code being injected;
// - the remote copy of this function retrieves the password;
//
// Return value: password length
//
static DWORD WINAPI ThreadFunc (INJDATA *pData)
{
// There must be less than a page-worth of local
// variables used in this function.
int nXferred = 0; // number of chars retrieved by WM_GETTEXT
// Get password
nXferred = pData->fnSendMessage( pData->hwnd, WM_GETTEXT,
sizeof(pData->pbText)/sizeof(TCHAR),
(LPARAM)pData->pbText );
pData->pbText [127 * sizeof(TCHAR)] = __TEXT('\0');
// The thread's exit code is the number
// of characters retrieved by WM_GETTEXT
return nXferred;
}
void T_char( )
{
TCHAR *pszText = __TEXT("hello");
#ifdef UNICODE
wprintf( L"%s\n", pszText );
#else
printf( "单:%s\n", pszText );
#endif
/*
#ifdef WIDECHAR
wchar_t *pszText = L"hello";
wprintf( L"%s\n", pszText );
#else
char *pszText = "hello";
printf( "单：%s\n", pszText );
#endif*/
}
BOOL on_notify(HWND hwnd, int control_id, NMHDR* param)
{
UNREFERENCED_PARAMETER(control_id);
UNREFERENCED_PARAMETER(hwnd);
TREEVIEW_ITEM_DATA_PTR data_ptr = NULL;
switch(param->code){
case TVN_SELCHANGED:
data_ptr = (TREEVIEW_ITEM_DATA_PTR)(((LPNMTREEVIEW)param)->itemNew.lParam);
if(data_ptr == NULL) return TRUE;
switch(data_ptr->type_){
case SEGD_GENERAL_HEADER_1_TYPE:
break;
case SEGD_GENERAL_HEADER_2_TYPE:
break;
case SEGD_GENERAL_HEADER_3_TYPE:
break;
case SEGD_SCAN_TYPE_HEADER_TYPE:
break;
case SEGD_EXTENDED_HEADER_TYPE:
break;
case SEGD_EXTERNAL_HEADER_TYPE:
break;
case SEGD_DEMUX_TRACE_HEADER_TYPE:
break;
case SEGD_TRACE_EXTENDED_HEADER_1_TYPE:
break;
case SEGD_TRACE_EXTENDED_HEADER_2_TYPE:
break;
case SEGD_TRACE_EXTENDED_HEADER_3_TYPE:
break;
case SEGD_TRACE_EXTENDED_HEADER_4_TYPE:
break;
case SEGD_TRACE_EXTENDED_HEADER_5_TYPE:
break;
case SEGD_TRACE_EXTENDED_HEADER_6_TYPE:
case SEGD_TRACE_EXTENDED_HEADER_7_TYPE:
break;
}
return TRUE;
case LVN_ITEMCHANGED:
OutputDebugString(__TEXT("TREEVIEW: LVN_SELCHANGED"));
return TRUE;
}
return FALSE;
}
int
main(int argc, char *argv[])
{
HANDLE s_hFileMap;
LPVOID lpDir;
LPBYTE lpByte;
// La funcion CreateFileMapping, tiene dos propositos crear un segmento de
// memoria compartida y compartir un archivo en memoria, para el primer proposito
// es importante ejecutar pasarle un handle invalido en el primer valor
// por que le indica que es un segmento y no un archivo.
// Crea un segmento de memoria indentificado por la palabra clave MMFShareData
s_hFileMap = CreateFileMapping((HANDLE) INVALID_HANDLE_VALUE,
NULL, // Atributos de seguridad, no requiere para el mismo usuario
PAGE_READWRITE, // Que forma se abre el segmento de memoria
0, 1024, // Valores del tamaño del segmento
__TEXT("MMFShareData")); // Identificador del segmento de memoria
if (s_hFileMap != NULL) {
// La funcion MapViewOfFile se encarga de mapear en memoria el segmento
// de memoria solicitado.
lpDir = MapViewOfFile(s_hFileMap,
FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
if (lpDir != NULL) {
lpByte = (LPBYTE) lpDir;
printf("%s", lpByte);
}
else {
fprintf(stderr, "Error: %ld\n", GetLastError());
CloseHandle(s_hFileMap);
ExitProcess((DWORD) 0);
}
}
Sleep(10000);
CloseHandle(s_hFileMap);
ExitProcess((DWORD) 0);
}
void GLWindow::destroyGLWindow()
{
destroyGL();
ShowTaskBar(true);
if ( hDC)
{
ReleaseDC( hWnd, hDC);
hDC = NULL;
}
if ( hWnd)
{
DestroyWindow( hWnd);
hWnd = NULL;
}
UnregisterClass(__TEXT("OGL"),hInstance);
hInstance = NULL;
}
bool
SRV_IsSystemAccount(
HSRV hSrv
)
{
PHSERVICE h = (PHSERVICE)hSrv;
DWORD dwBufSize;
if( h == NULL ||
!QueryServiceConfig(h->schService,
h->pServiceConfig,
SRV_CONFIG_SIZE,
&dwBufSize))
return false;
if( h->pServiceConfig->lpServiceStartName == NULL ||
lstrcmpi(h->pServiceConfig->lpServiceStartName, __TEXT("LocalSystem")) == 0)
return true;
return false;
}
