HPROPSHEETPAGE PhCreateJobPage(
__in PPH_OPEN_OBJECT OpenObject,
__in_opt PVOID Context,
__in_opt DLGPROC HookProc
)
{
HPROPSHEETPAGE propSheetPageHandle;
PROPSHEETPAGE propSheetPage;
PJOB_PAGE_CONTEXT jobPageContext;
if (!NT_SUCCESS(PhCreateAlloc(&jobPageContext, sizeof(JOB_PAGE_CONTEXT))))
return NULL;
memset(jobPageContext, 0, sizeof(JOB_PAGE_CONTEXT));
jobPageContext->OpenObject = OpenObject;
jobPageContext->Context = Context;
jobPageContext->HookProc = HookProc;
memset(&propSheetPage, 0, sizeof(PROPSHEETPAGE));
propSheetPage.dwSize = sizeof(PROPSHEETPAGE);
propSheetPage.dwFlags = PSP_USECALLBACK;
propSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_OBJJOB);
propSheetPage.pfnDlgProc = PhpJobPageProc;
propSheetPage.lParam = (LPARAM)jobPageContext;
propSheetPage.pfnCallback = PhpJobPropPageProc;
propSheetPageHandle = CreatePropertySheetPage(&propSheetPage);
// CreatePropertySheetPage would have sent PSPCB_ADDREF (below),
// which would have added a reference.
PhDereferenceObject(jobPageContext);
return propSheetPageHandle;
}
VOID SetupShowUninstallDialog(
VOID
)
{
PVOID context;
TASKDIALOGCONFIG config;
PH_AUTO_POOL autoPool;
memset(&config, 0, sizeof(TASKDIALOGCONFIG));
PhInitializeAutoPool(&autoPool);
context = (PPH_SETUP_CONTEXT)PhCreateAlloc(sizeof(PH_SETUP_CONTEXT));
memset(context, 0, sizeof(PH_SETUP_CONTEXT));
config.cbSize = sizeof(TASKDIALOGCONFIG);
config.dwFlags = TDF_POSITION_RELATIVE_TO_WINDOW;
config.dwCommonButtons = TDCBF_CANCEL_BUTTON;
config.pszWindowTitle = PhApplicationName;
config.pfCallback = TaskDialogUninstallBootstrapCallback;
config.lpCallbackData = (LONG_PTR)context;
TaskDialogIndirect(&config, NULL, NULL, NULL);
PhDereferenceObject(context);
PhDeleteAutoPool(&autoPool);
}
static HPROPSHEETPAGE EtpCommonCreatePage(
__in PPH_PLUGIN_HANDLE_PROPERTIES_CONTEXT Context,
__in PWSTR Template,
__in DLGPROC DlgProc
)
{
HPROPSHEETPAGE propSheetPageHandle;
PROPSHEETPAGE propSheetPage;
PCOMMON_PAGE_CONTEXT pageContext;
if (!NT_SUCCESS(PhCreateAlloc(&pageContext, sizeof(COMMON_PAGE_CONTEXT))))
return NULL;
memset(pageContext, 0, sizeof(COMMON_PAGE_CONTEXT));
pageContext->HandleItem = Context->HandleItem;
pageContext->ProcessId = Context->ProcessId;
memset(&propSheetPage, 0, sizeof(PROPSHEETPAGE));
propSheetPage.dwSize = sizeof(PROPSHEETPAGE);
propSheetPage.dwFlags = PSP_USECALLBACK;
propSheetPage.hInstance = PluginInstance->DllBase;
propSheetPage.pszTemplate = Template;
propSheetPage.pfnDlgProc = DlgProc;
propSheetPage.lParam = (LPARAM)pageContext;
propSheetPage.pfnCallback = EtpCommonPropPageProc;
propSheetPageHandle = CreatePropertySheetPage(&propSheetPage);
PhDereferenceObject(pageContext); // already got a ref from above call
return propSheetPageHandle;
}
static HPROPSHEETPAGE PhpCommonCreatePage(
_In_ PPH_OPEN_OBJECT OpenObject,
_In_opt_ PVOID Context,
_In_ PWSTR Template,
_In_ DLGPROC DlgProc
)
{
HPROPSHEETPAGE propSheetPageHandle;
PROPSHEETPAGE propSheetPage;
PCOMMON_PAGE_CONTEXT pageContext;
pageContext = PhCreateAlloc(sizeof(COMMON_PAGE_CONTEXT));
memset(pageContext, 0, sizeof(COMMON_PAGE_CONTEXT));
pageContext->OpenObject = OpenObject;
pageContext->Context = Context;
memset(&propSheetPage, 0, sizeof(PROPSHEETPAGE));
propSheetPage.dwSize = sizeof(PROPSHEETPAGE);
propSheetPage.dwFlags = PSP_USECALLBACK;
propSheetPage.pszTemplate = Template;
propSheetPage.pfnDlgProc = DlgProc;
propSheetPage.lParam = (LPARAM)pageContext;
propSheetPage.pfnCallback = PhpCommonPropPageProc;
propSheetPageHandle = CreatePropertySheetPage(&propSheetPage);
// CreatePropertySheetPage would have sent PSPCB_ADDREF (below),
// which would have added a reference.
PhDereferenceObject(pageContext);
return propSheetPageHandle;
}
/**
* Allocates a text table.
*
* \param Table A variable which receives a pointer to the text table.
* \param Rows The number of rows in the table.
* \param Columns The number of columns in the table.
*/
VOID PhaCreateTextTable(
_Out_ PPH_STRING ***Table,
_In_ ULONG Rows,
_In_ ULONG Columns
)
{
PPH_STRING **table;
ULONG i;
table = PhAutoDereferenceObject(PhCreateAlloc(sizeof(PPH_STRING *) * Rows));
for (i = 0; i < Rows; i++)
{
table[i] = PhAutoDereferenceObject(PhCreateAlloc(sizeof(PPH_STRING) * Columns));
memset(table[i], 0, sizeof(PPH_STRING) * Columns);
}
*Table = table;
}
PPH_SETUP_CONTEXT CreateUpdateContext(
VOID
)
{
PPH_SETUP_CONTEXT context;
context = (PPH_SETUP_CONTEXT)PhCreateAlloc(sizeof(PH_SETUP_CONTEXT));
memset(context, 0, sizeof(PH_SETUP_CONTEXT));
return context;
}
/**
* Allocates a text table.
*
* \param Table A variable which receives a pointer to the text table.
* \param Rows The number of rows in the table.
* \param Columns The number of columns in the table.
*/
VOID PhaCreateTextTable(
__out PPH_STRING ***Table,
__in ULONG Rows,
__in ULONG Columns
)
{
PPH_STRING **table;
ULONG i;
PhCreateAlloc((PVOID *)&table, sizeof(PPH_STRING *) * Rows);
PhaDereferenceObject(table);
for (i = 0; i < Rows; i++)
{
PhCreateAlloc((PVOID *)&table[i], sizeof(PPH_STRING) * Columns);
PhaDereferenceObject(table[i]);
memset(table[i], 0, sizeof(PPH_STRING) * Columns);
}
*Table = table;
}
PPH_UPDATER_CONTEXT CreateUpdateContext(
_In_ BOOLEAN StartupCheck
)
{
PPH_UPDATER_CONTEXT context;
context = (PPH_UPDATER_CONTEXT)PhCreateAlloc(sizeof(PH_UPDATER_CONTEXT));
memset(context, 0, sizeof(PH_UPDATER_CONTEXT));
context->CurrentVersionString = PhGetPhVersion();
context->StartupCheck = StartupCheck;
return context;
}
INT CALLBACK MainPropSheet_Callback(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_Inout_ LPARAM lParam
)
{
switch (uMsg)
{
case PSCB_PRECREATE:
{
if (lParam)
{
if (((DLGTEMPLATEEX *)lParam)->signature == USHORT_MAX)
((DLGTEMPLATEEX *)lParam)->style |= WS_MINIMIZEBOX;
else
((DLGTEMPLATE *)lParam)->style |= WS_MINIMIZEBOX;
}
}
break;
case PSCB_INITIALIZED:
{
PPH_SETUP_CONTEXT context;
context = PhCreateAlloc(sizeof(PH_SETUP_CONTEXT));
memset(context, 0, sizeof(PH_SETUP_CONTEXT));
context->CurrentMajorVersion = PHAPP_VERSION_MAJOR;
context->CurrentMinorVersion = PHAPP_VERSION_MINOR;
context->CurrentRevisionVersion = PHAPP_VERSION_REVISION;
context->DialogHandle = hwndDlg;
context->PropSheetBackHandle = GetDlgItem(hwndDlg, IDC_PROPSHEET_BACK);
context->PropSheetForwardHandle = GetDlgItem(hwndDlg, IDC_PROPSHEET_NEXT);
context->PropSheetCancelHandle = GetDlgItem(hwndDlg, IDC_PROPSHEET_CANCEL);
SetupInitializeFont(context->PropSheetBackHandle, -12, FW_NORMAL);
SetupInitializeFont(context->PropSheetForwardHandle, -12, FW_NORMAL);
SetupInitializeFont(context->PropSheetCancelHandle, -12, FW_NORMAL);
SetProp(hwndDlg, L"SetupContext", (HANDLE)context);
}
break;
}
return FALSE;
}
BOOL CALLBACK PhpSymbolCallbackFunction(
_In_ HANDLE hProcess,
_In_ ULONG ActionCode,
_In_opt_ ULONG64 CallbackData,
_In_opt_ ULONG64 UserContext
)
{
PPH_SYMBOL_PROVIDER symbolProvider = (PPH_SYMBOL_PROVIDER)UserContext;
PPH_SYMBOL_EVENT_DATA data;
PIMAGEHLP_DEFERRED_SYMBOL_LOADW64 callbackData;
if (!IsListEmpty(&symbolProvider->EventCallback.ListHead))
{
switch (ActionCode)
{
case SymbolDeferredSymbolLoadStart:
case SymbolDeferredSymbolLoadComplete:
case SymbolDeferredSymbolLoadFailure:
case SymbolSymbolsUnloaded:
case SymbolDeferredSymbolLoadCancel:
PhCreateAlloc((PVOID *)&data, sizeof(PH_SYMBOL_EVENT_DATA));
memset(data, 0, sizeof(PH_SYMBOL_EVENT_DATA));
data->SymbolProvider = symbolProvider;
data->Type = ActionCode;
if (ActionCode != SymbolSymbolsUnloaded)
{
callbackData = (PIMAGEHLP_DEFERRED_SYMBOL_LOADW64)CallbackData;
data->BaseAddress = callbackData->BaseOfImage;
data->CheckSum = callbackData->CheckSum;
data->TimeStamp = callbackData->TimeDateStamp;
data->FileName = PhCreateString(callbackData->FileName);
}
PhQueueItemGlobalWorkQueue(PhpSymbolCallbackWorker, data);
break;
}
}
return FALSE;
}
/**
* Adds a menu hook.
*
* \param MenuInfo The plugin menu information structure.
* \param Plugin A plugin instance structure.
* \param Context A user-defined value that is later accessible from the callback.
*
* \remarks The \ref PluginCallbackMenuHook callback is invoked when any menu item
* from the menu is chosen.
*/
BOOLEAN PhPluginAddMenuHook(
_Inout_ PPH_PLUGIN_MENU_INFORMATION MenuInfo,
_In_ PPH_PLUGIN Plugin,
_In_opt_ PVOID Context
)
{
PPHP_PLUGIN_MENU_HOOK hook;
if (MenuInfo->Flags & PH_PLUGIN_MENU_DISALLOW_HOOKS)
return FALSE;
if (!MenuInfo->PluginHookList)
MenuInfo->PluginHookList = PhAutoDereferenceObject(PhCreateList(2));
hook = PhAutoDereferenceObject(PhCreateAlloc(sizeof(PHP_PLUGIN_MENU_HOOK)));
hook->Plugin = Plugin;
hook->Context = Context;
PhAddItemList(MenuInfo->PluginHookList, hook);
return TRUE;
}
/**
* Formats a text table to a list of lines.
*
* \param Table A pointer to the text table.
* \param Rows The number of rows in the table.
* \param Columns The number of columns in the table.
* \param Mode The export formatting mode.
*
* \return A list of strings for each line in the output. The list object and
* string objects are not auto-dereferenced.
*/
PPH_LIST PhaFormatTextTable(
__in PPH_STRING **Table,
__in ULONG Rows,
__in ULONG Columns,
__in ULONG Mode
)
{
PPH_LIST lines;
// The tab count array contains the number of tabs need to fill the biggest
// row cell in each column.
PULONG tabCount;
ULONG i;
ULONG j;
if (Mode == PH_EXPORT_MODE_TABS || Mode == PH_EXPORT_MODE_SPACES)
{
// Create the tab count array.
PhCreateAlloc(&tabCount, sizeof(ULONG) * Columns);
PhaDereferenceObject(tabCount);
memset(tabCount, 0, sizeof(ULONG) * Columns); // zero all values
for (i = 0; i < Rows; i++)
{
for (j = 0; j < Columns; j++)
{
ULONG newCount;
if (Table[i][j])
newCount = (ULONG)(Table[i][j]->Length / sizeof(WCHAR) / TAB_SIZE);
else
newCount = 0;
// Replace the existing count if this tab count is bigger.
if (tabCount[j] < newCount)
tabCount[j] = newCount;
}
}
}
// Create the final list of lines by going through each cell and appending
// the proper tab count (if we are using tabs). This will make sure each column
// is properly aligned.
lines = PhCreateList(Rows);
for (i = 0; i < Rows; i++)
{
PH_STRING_BUILDER stringBuilder;
PhInitializeStringBuilder(&stringBuilder, 100);
switch (Mode)
{
case PH_EXPORT_MODE_TABS:
{
for (j = 0; j < Columns; j++)
{
ULONG k;
if (Table[i][j])
{
// Calculate the number of tabs needed.
k = (ULONG)(tabCount[j] + 1 - Table[i][j]->Length / sizeof(WCHAR) / TAB_SIZE);
PhAppendStringBuilder(&stringBuilder, Table[i][j]);
}
else
{
k = tabCount[j] + 1;
}
PhAppendCharStringBuilder2(&stringBuilder, '\t', k);
}
}
break;
case PH_EXPORT_MODE_SPACES:
{
for (j = 0; j < Columns; j++)
{
ULONG k;
if (Table[i][j])
{
// Calculate the number of spaces needed.
k = (ULONG)((tabCount[j] + 1) * TAB_SIZE - Table[i][j]->Length / sizeof(WCHAR));
PhAppendStringBuilder(&stringBuilder, Table[i][j]);
}
else
{
k = (tabCount[j] + 1) * TAB_SIZE;
}
PhAppendCharStringBuilder2(&stringBuilder, ' ', k);
}
}
break;
case PH_EXPORT_MODE_CSV:
{
for (j = 0; j < Columns; j++)
{
PhAppendCharStringBuilder(&stringBuilder, '\"');
if (Table[i][j])
{
PhpEscapeStringForCsv(&stringBuilder, Table[i][j]);
}
PhAppendCharStringBuilder(&stringBuilder, '\"');
if (j != Columns - 1)
PhAppendCharStringBuilder(&stringBuilder, ',');
}
}
break;
}
PhAddItemList(lines, PhFinalStringBuilderString(&stringBuilder));
}
return lines;
}
