/*F+F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F
Function: DllUnregisterServer
Summary: The standard exported function that can be called to command
this DLL server to unregister itself from the system Registry.
Args: void.
Returns: HRESULT
NOERROR
F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F-F*/
STDAPI DllUnregisterServer(void)
{
HRESULT hr = NOERROR;
TCHAR szID[GUID_SIZE+1];
TCHAR szCLSID[GUID_SIZE+1];
TCHAR szTemp[GUID_SIZE+1];
/*-------------------------------------------------------------------------
Delete registry entries for the Ball Component.
-------------------------------------------------------------------------*/
//Create some base key strings.
StringFromGUID2(CLSID_Ball, szID, GUID_SIZE);
hr = StringCbCopy(szCLSID, sizeof(szCLSID), TEXT("CLSID\\"));
assert(hr == S_OK);
hr = StringCbCat(szCLSID, sizeof(szCLSID), szID);
assert(hr == S_OK);
RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("DllBall\\CurVer"));
RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("DllBall\\CLSID"));
RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("DllBall"));
RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("DllBall1.0\\CLSID"));
RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("DllBall1.0"));
hr = StringCbPrintf(szTemp, sizeof(szTemp), TEXT("%s\\%s"), szCLSID, TEXT("ProgID"));
assert(hr == S_OK);
RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
hr = StringCbPrintf(szTemp, sizeof(szTemp), TEXT("%s\\%s"), szCLSID, TEXT("VersionIndependentProgID"));
assert(hr == S_OK);
RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
hr = StringCbPrintf(szTemp, sizeof(szTemp), TEXT("%s\\%s"), szCLSID, TEXT("NotInsertable"));
assert(hr == S_OK);
RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
hr = StringCbPrintf(szTemp, sizeof(szTemp), TEXT("%s\\%s"), szCLSID, TEXT("InprocServer32"));
assert(hr == S_OK);
RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
RegDeleteKey(HKEY_CLASSES_ROOT, szCLSID);
return hr;
}
HFCERROR StdHFCErrorCallbackMsgBox(HFCERROR nError,DWORD_PTR dwData)
{
if (nError!=HFC_NOERROR)
{
char text[1000];
StringCbPrintf(text,1000,"Code %X:%s",(DWORD)nError,GetStdErrorStr(nError));
MessageBox((HWND)dwData,text,"HFC Error",MB_ICONERROR|MB_OK);
}
return nError;
}
TCHAR *GetTimeDateStr() // Return date and time [01/01/2013]:[22:29:22]
{
TCHAR *tStr = new TCHAR[50];
SYSTEMTIME time;
GetLocalTime(&time);
StringCbPrintf(tStr,50,TEXT("[%02d/%02d/%04d]:[%02d:%02d:%02d]"),time.wDay,time.wMonth,time.wYear, time.wHour,time.wMinute,time.wSecond);
return tStr;
}
STDMETHODIMP_(ULONG) CShellExtClassFactory::AddRef()
{
ODS("CShellExtClassFactory::AddRef()");
char szNum[100];
StringCbPrintf(szNum,100,"m_cRef is after this call %d",m_cRef+1);
DebugMessage(szNum);
return ++m_cRef;
}
//***************************************************************************************************
// check if the key is already exist
bool IsKeyExist( HKEY hKey, LPCTSTR lpcsPath, LPCTSTR lpcsKeyName )
{
HKEY hSubKey = NULL;
_TCHAR tcsKey[MAX_PATH];
if ( lpcsKeyName != NULL ) {
StringCbPrintf( tcsKey, MAX_PATH* sizeof(_TCHAR), _T("%s\\%s"), lpcsPath, lpcsKeyName );
}
else {
StringCbPrintf( tcsKey, MAX_PATH* sizeof(_TCHAR), _T("%s"), lpcsPath );
}
if ( ERROR_SUCCESS == ::RegOpenKeyEx( hKey, tcsKey, 0, KEY_READ, &hSubKey)
&& hSubKey != NULL )
{
::RegCloseKey( hSubKey );
return true;
}
return false;
}
char *
AclToString(struct Acl *acl)
{
static char mydata[AFS_PIOCTL_MAXSIZE];
char tstring[AFS_PIOCTL_MAXSIZE];
char dfsstring[30];
struct AclEntry *tp;
if (acl->dfs) {
if( FAILED(StringCbPrintf(dfsstring, sizeof(dfsstring), " dfs:%d %s", acl->dfs, acl->cell))) {
fprintf (stderr, "dfsstring - cannot be populated");
exit(1);
}
} else {
dfsstring[0] = '\0';
}
if( FAILED(StringCbPrintf(mydata, sizeof(mydata), "%d%s\n%d\n", acl->nplus, dfsstring, acl->nminus))) {
fprintf (stderr, "mydata - cannot be populated");
exit(1);
}
for (tp = acl->pluslist;tp;tp=tp->next) {
if( FAILED(StringCbPrintf(tstring, sizeof(tstring), "%s %d\n", tp->name, tp->rights))) {
fprintf (stderr, "tstring - cannot be populated");
exit(1);
}
if( FAILED(StringCbCat(mydata, sizeof(mydata), tstring))) {
fprintf (stderr, "mydata - not enough space");
exit(1);
}
}
for (tp = acl->minuslist;tp;tp=tp->next) {
if( FAILED(StringCbPrintf(tstring, sizeof(tstring), "%s %d\n", tp->name, tp->rights))) {
fprintf (stderr, "tstring - cannot be populated");
exit(1);
}
if( FAILED(StringCbCat(mydata, sizeof(mydata), tstring))) {
fprintf (stderr, "mydata - not enough space");
exit(1);
}
}
return mydata;
}
const TCHAR *DeviceInfo::LocationString()
{
static TCHAR locus[30];
if (devUsbValid) {
ZeroMemory(locus, sizeof(locus));
StringCbPrintf(locus, sizeof(locus), _T("USB hub %i port %i"), devUsbHub, devUsbPort);
return locus;
}
return NULL;
}
static FILE *_OpenSettings (const TCHAR *pszSettingsLocation, const TCHAR *pszBase, const TCHAR *pszConfig) {
TCHAR szPath[PATH_MAX];
StringCbPrintf (szPath, sizeof (szPath), TEXT ("%s%s%s"), pszBase, pszConfig, pszSettingsLocation);
FILE *f = fopen (szPath, TEXT ("rt"));
if (!f) {
LOGWARN (TEXT ("Couldn't open ") << szPath << TEXT (", error ") << GetLastError ());
} else {
LOGDEBUG (TEXT ("Reading from ") << szPath);
}
return f;
}
VOID CFormatMessage::OutputDebugString(LPCTSTR szFormat,...)
{
va_list vagrc;
va_start(vagrc,szFormat);
TCHAR szParamText[2048]={NULL};
StringCbVPrintf(szParamText,sizeof(szParamText),szFormat,vagrc);
va_end(vagrc);
INT nLen = _tcslen(szParamText);
StringCbPrintf(&szParamText[nLen],sizeof(szParamText)-nLen,TEXT("\r\n╢МнСт╜рР:(%d)%s"),m_nLastError,szErrorText);
::OutputDebugString(szParamText);
}
/**\brief static dialog callback procedure
*
* The default behavior you get out of this procedure is:
* - Stores the dialog pointer passed in on lParam in GWLP_USERDATA for later use
* - Bails if there is no dialog pointer in GWLP_USERDATA on any message other than INITDIALOG
* - Forwards to the polymorphic ProcessMessage method on the BMD instance
* - Calls EndDialog if you percolate an IDOK or IDCANCEL back up the stack
*/
INT_PTR CALLBACK BasicModalDialog::_DlgProc(HWND hWndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
BasicModalDialog *bmd = (BasicModalDialog *)NULL;
// the bmd pointer will be cached in GWLP_USERDATA once we get an INITDIALOG message
bmd = reinterpret_cast<BasicModalDialog *>(GetWindowLongPtr(hWndDlg,GWLP_USERDATA));
// Toss everything to the default dialog proc until we get the INITDIALOG message that has our camera pointer
if(bmd == NULL && uMsg != WM_INITDIALOG)
{
// if we get a CANCEL in the interim, bail out
if(uMsg == WM_COMMAND && LOWORD(wParam) == IDCANCEL)
{
EndDialog(hWndDlg,LOWORD(wParam));
return TRUE;
}
return FALSE;
} // fall through: bmd != NULL and/or WM_INITDIALOG
if(uMsg == WM_INITDIALOG)
{
// bmd is in lParam
bmd = reinterpret_cast<BasicModalDialog *>(lParam);
// idiotproofing for bad bmd pointer at this point
if(bmd == NULL)
{
MessageBox(hWndDlg,"Invalid context pointer passed to DialogBoxParam!","BasicModalDialog Error",MB_OK|MB_ICONERROR);
EndDialog(hWndDlg,-1);
return TRUE;
} else {
char buf[256];
StringCbPrintf(buf,sizeof(buf),"BasicModalDialog::_DlgProc: bmd @ %p\n",bmd);
OutputDebugString(buf);
// cache in GWLP_USERDATA
SetWindowLongPtr(hWndDlg,GWLP_USERDATA,(LONG_PTR)(bmd));
}
// here bmd guaranteed non-NULL
} // else msg != WM_INITDIALOG, so bmd != NULL from previous test... fall through
// all paths here lead to bmd != NULL, so forward the message to the virtual handler
bool res = bmd->ProcessMessage(hWndDlg,uMsg,wParam,lParam);
if(!res)
{
// do minimum of watching for IDOK/IDCANCEL and closing the dialog
if(uMsg == WM_COMMAND && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) )
{
EndDialog(hWndDlg, LOWORD(wParam));
res = true;
}
}
return res ? TRUE : FALSE;
}
void DeviceInfo::UpdateDeviceState(enum DevState aDevState, FILETIME aNow, unsigned aScanId)
{
// check for change of state, eg removed etc...
if (devState != aDevState) {
BOOL chgState = FALSE;
if (aDevState == DevAbsent) {
if ((devState == DevPresent) || (devState == DevArrived)) {
#ifdef _DEBUG
PrintDebugStatus(_T("Change state to removed\n"));
#endif
// update DeviceTracker counts, decide on notifications
gdevTracker->DetermineRemovalNotifications(devType, devState, DevRemoved);
devState = DevRemoved;
devElapsed = 0;
devTimestamp = aNow;
chgState = TRUE;
// update counts
DecDeviceTypeCount();
}
} else if (aDevState == DevPresent) {
if ((devState == DevAbsent) || (devState == DevRemoved)) {
#ifdef _DEBUG
PrintDebugStatus(_T("Change state to arrived\n"));
#endif
devDeleteOnUnlock = FALSE; // device has returned, no longer need to delete
// update DeviceTracker counts, decide on notifications
gdevTracker->DetermineArrivalNotifications(devType, aDevState);
devState = gdevTracker->CheckInitialScanFlag(devType) ? DevPresent : DevArrived;
devTimestamp = aNow;
devElapsed = 0;
chgState = TRUE;
// update counts
IncDeviceTypeCount();
}
}
if (chgState) {
TCHAR buffer[20];
StringCbPrintf(buffer, sizeof(buffer), _T("%s 0min"), StateName());
SetDeviceIcon();
// update port status & icon on display
gdevTracker->UpdateViewItemIconAndState(devImage, buffer, (LPARAM)this);
}
}
devScanId = aScanId;
}
void ShowErrorMessage(HWND hwnd, PCWSTR format, HRESULT hrErr)
{
HRESULT hr = S_OK;
WCHAR msg[MAX_PATH];
hr = StringCbPrintf(msg, sizeof(msg), L"%s (hr=0x%X)", format, hrErr);
if (SUCCEEDED(hr))
{
MessageBox(hwnd, msg, L"Error", MB_ICONERROR);
}
}
void CreateLnkOnDesktop(const LPWSTR connTitle)
{
IShellLink *SLink;
IPersistFile *PF;
HRESULT HRes;
TCHAR desktop_path[MAX_PATH] = TEXT("");
TCHAR pszFullLnkPath[MAX_PATH];
CoInitialize(NULL);
ITEMIDLIST* pidl1 = NULL;
SHGetFolderLocation(NULL, CSIDL_CONNECTIONS, NULL, 0, &pidl1);
IShellFolder *desktop, *ncfolder;
SHGetDesktopFolder(&desktop);
desktop->BindToObject(pidl1, NULL, IID_IShellFolder, (void**)&ncfolder);
IEnumIDList *items;
ncfolder->EnumObjects(NULL, SHCONTF_NONFOLDERS, &items);
ITEMIDLIST* pidl2 = NULL;
while (S_OK == items->Next(1, &pidl2, NULL))
{
STRRET sr = {STRRET_WSTR};
ncfolder->GetDisplayNameOf(pidl2, SHGDN_NORMAL, &sr);
TCHAR buf[MAX_PATH] = TEXT("");
StrRetToBuf(&sr, pidl2, buf, MAX_PATH);
if (0 == StrCmpI(buf, connTitle))
{
ITEMIDLIST* pidl3 = ILCombine(pidl1, pidl2);
HRESULT HRes = CoCreateInstance(CLSID_ShellLink, 0, CLSCTX_INPROC_SERVER, IID_IShellLink, ( LPVOID*)&SLink);
SLink->SetIDList(pidl3);
SHGetFolderPath(NULL, CSIDL_DESKTOP, NULL, 0, desktop_path);
StringCbPrintf(pszFullLnkPath, MAX_PATH * sizeof(TCHAR), TEXT("%s\\%s.lnk"), desktop_path, connTitle);
HRes = SLink->QueryInterface(IID_IPersistFile, (LPVOID*)&PF);
HRes = PF->Save((LPCOLESTR)pszFullLnkPath, TRUE);
PF->Release();
SLink->Release();
ILFree(pidl3);
ILFree(pidl2);
break;
}
ILFree(pidl2);
pidl2 = NULL;
}
ncfolder->Release();
desktop->Release();
ILFree(pidl1);
CoUninitialize();
}
// 키보드 후킹 프로시저
LRESULT CALLBACK
KeyHook(int code, WPARAM w, LPARAM l)
{
if(code >= 0)
{
TCHAR buf[80];
StringCbPrintf(buf, sizeof(buf), TEXT("%c"), w);
OutputDebugString(buf);
}
return CallNextHookEx(NULL, code, w, l);
}
BOOL
InitDebugLog(LPWSTR lpLogName, LPWSTR lpVersion)
{
WCHAR szPath[MAX_PATH], szMsg[MAX_STR_LEN],
szCurrentPath[MAX_PATH];
DWORD dwBytesWritten;
if (!GetCurrentPath(szCurrentPath, MAX_PATH))
return FALSE;
StringCbPrintf(szPath, sizeof(szPath),
L"%s%s",
szCurrentPath,
lpLogName);
hDebugLog = CreateFile(szPath,
GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hDebugLog == INVALID_HANDLE_VALUE)
return FALSE;
WriteFile(hDebugLog, "\xFF\xFE", 2, &dwBytesWritten, NULL);
StringCbPrintf(szMsg, sizeof(szMsg),
#ifdef _M_IX86
L"Log file created, Aspia %s",
#else
L"Log file created, Aspia %s (x64)",
#endif
lpVersion);
DebugTrace(szMsg);
return TRUE;
}
void StartCounter()
{
int i;
TCHAR buffer[255];
for(i = 0; i < 100; i++)
{
StringCbPrintf(buffer, sizeof(buffer), TEXT("%d"), i);
if(g_dlg)
{
g_dlg->Append(buffer);
}
}
}
HRESULT MakeFullItemName(
_In_ IWiaDrvItem* pParent,
_In_ BSTR bstrItemName,
_Out_ BSTR* pbstrFullItemName)
{
HRESULT hr = S_OK;
if (pParent && bstrItemName && pbstrFullItemName)
{
BSTR bstrParentFullItemName = NULL;
hr = pParent->GetFullItemName(&bstrParentFullItemName);
if (SUCCEEDED(hr))
{
WCHAR wFullItemName[MAX_PATH * 2] = {};
hr = StringCbPrintf(wFullItemName, sizeof(wFullItemName), TEXT("%ws\\%ws"), bstrParentFullItemName, bstrItemName);
if (SUCCEEDED(hr))
{
*pbstrFullItemName = SysAllocString(wFullItemName);
if (*pbstrFullItemName)
{
hr = S_OK;
}
else
{
hr = E_OUTOFMEMORY;
WIAEX_ERROR((g_hInst, "Failed to allocate memory for BSTR full item name, hr = 0x%08X", hr));
}
}
else
{
WIAEX_ERROR((g_hInst, "Failed to allocate memory for BSTR full item name, hr = 0x%08X", hr));
}
SysFreeString(bstrParentFullItemName);
bstrParentFullItemName = NULL;
}
else
{
WIAEX_ERROR((g_hInst, "Failed to produce the full item name, hr = 0x%08X", hr));
}
}
else
{
hr = E_INVALIDARG;
WIAEX_ERROR((g_hInst, "Invalid parameter, hr = 0x%08X", hr));
}
return hr;
}
// new DeviceInfo object, transfers ownership of strings,
DeviceInfo *DeviceInfo::NewDevice(enum DevType aDevType,
enum DevState aDevState, FILETIME aNow, wchar_t *aSerialnumber, wchar_t *aPortName,
wchar_t *aFriendlyName, wchar_t *aHardwareId, int aPortNumber, wchar_t *aContainerId,
unsigned aUsbHub, unsigned aUsbPort, BOOL aUsbValid, unsigned aScanId, DeviceInfo *aDevNext,
BOOL aIsWinSerial, SerialType aSerialType)
{
DeviceInfo *newDev = NULL;
// decide if new device should be DevArrived rather than DevPresent
if ((aDevState == DevPresent) && !gdevTracker->CheckInitialScanFlag(aDevType)) {
aDevState = DevArrived;
}
newDev = new DeviceInfo(aDevType, aDevState, aNow, aSerialnumber, aPortName,
aPortNumber, aContainerId, aFriendlyName, aHardwareId,
aUsbHub, aUsbPort, aUsbValid, aScanId, aDevNext,
aIsWinSerial, aSerialType);
if (newDev) {
TCHAR buffer[20];
// update double linked list
if (aDevNext) {
aDevNext->devPrev = newDev;
}
gdevTracker->SetPortList(newDev);
StringCbPrintf(buffer, sizeof(buffer),
(newDev->DeviceState() == DevArrived) ? _T("%s 0min") : _T("%s"), newDev->StateName());
// display update shouldn't fail, but check anyway
if (!gdevTracker->AddViewItem(newDev->DisplayName(), newDev->devImage,
newDev->DevTypeName(), buffer, newDev->LocationString(), aSerialnumber,
(LPARAM)newDev)) {
newDev->Destroy();
newDev = NULL;
} else {
if ((aDevState == DevArrived) || (aDevState == DevPresent)) {
// update count
newDev->IncDeviceTypeCount();
}
// update DeviceTracker counts, decide on notifications
gdevTracker->DetermineArrivalNotifications(aDevType, aDevState);
}
}
return newDev;
}
static int connect_to_daemon(struct qdb_handle *qh) {
WCHAR pipe_name[MAX_FILE_NAME];
ULONG status;
if (qh->vmname && strcmp(qh->vmname, "dom0") != 0) {
StringCbPrintf(pipe_name, sizeof(pipe_name), QDB_DAEMON_PATH_PATTERN, qh->vmname);
} else {
#ifdef BACKEND_VMM_wni
/* on WNI we don't have separate namespace for each VM (all is in the
* single system) */
DWORD user_name_len = UNLEN + 1;
WCHAR user_name[user_name_len];
if (!GetUserName(user_name, &user_name_len)) {
perror("GetUserName");
return 0;
}
StringCbPrintf(pipe_name, sizeof(pipe_name), QDB_DAEMON_LOCAL_PATH, user_name);
#else
StringCbPrintf(pipe_name, sizeof(pipe_name), QDB_DAEMON_LOCAL_PATH);
#endif
}
qh->read_pipe = INVALID_HANDLE_VALUE;
qh->write_pipe = INVALID_HANDLE_VALUE;
status = QpsConnect(pipe_name, &qh->read_pipe, &qh->write_pipe);
if (status != ERROR_SUCCESS)
{
perror2(status, "connect to server");
return 0;
}
return 1;
}
TCHAR *generate_screenshot_name(TCHAR *fn, int num, TCHAR *dest, TCHAR *ext) {
size_t i;
for (i = _tcslen(fn) - 1; i && fn[i] != '.'; i--);
if (i) {
fn[i] = '\0';
}
StringCbPrintf(dest, _tcslen(dest) + _tcslen(ext) + 1, _T("%s%d.%s"), fn, num, ext);
if (i) {
fn[i] = '.';
}
return dest;
}
LRESULT CALLBACK
KeyHookEx(int code, WPARAM w, LPARAM l)
{
if(code >= 0)
{
TCHAR buf[80];
StringCbPrintf(buf, sizeof(buf), TEXT("W=%08X(%c) L=%08X"), w, w, l);
OutputDebugString(buf);
if(w == 'W')
return TRUE;
}
return CallNextHookEx(NULL, code, w, l);
}
STDMETHODIMP_(ULONG) CShellExtClassFactory::Release()
{
ODS("CShellExtClassFactory::Release()");
char szNum[100];
StringCbPrintf(szNum,100,"m_cRef is after this call %d",m_cRef-1);
DebugMessage(szNum);
if (--m_cRef)
return m_cRef;
DebugMessage("Removing class");
delete this;
return 0L;
}
STDMETHODIMP_(ULONG) CLocateShellExtension::Release()
{
ODS("CShellExt::Release()");
char szNum[100];
StringCbPrintf(szNum,100,"m_cRef is after this call %d",m_cRef-1);
DebugMessage(szNum);
if (--m_cRef)
return m_cRef;
DebugMessage("delete this");
delete this;
return 0L;
}
//***************************************************************************************************
// write string to registry, if the key path is not exist, will create one
bool WriteDWORD( HKEY hKey, LPCTSTR lpcsPath, LPCTSTR lpcsSubPath, LPCTSTR lpcsKey, DWORD dwValue )
{
if ( lpcsPath == NULL || _tcslen( lpcsPath ) < 1 ) {
_ASSERT( 0 );
return false;
}
if ( lpcsSubPath != NULL ) {
_TCHAR tcsPath[MAX_PATH];
StringCbPrintf( tcsPath, MAX_PATH* sizeof(_TCHAR), _T("%s\\%s"), lpcsPath, lpcsSubPath );
return WriteDWORD( hKey, tcsPath, lpcsKey, dwValue );
}
else {
return WriteDWORD( hKey, lpcsPath, lpcsKey, dwValue );
}
}
void dotitle(Char **vc, struct command * c) {
int k;
char titlebuf[512];
char errbuf[128],err2[128];
char **v;
Char **nvc;
UNREFERENCED_PARAMETER(c);
vc++;
nvc = glob_all_or_error(vc);
if (nvc == NULL)
return;
if (nvc != vc)
cleanup_push(nvc, blk_cleanup);
if ((k = GetConsoleTitle(titlebuf, sizeof(titlebuf))) != 0) {
setcopy(STRoldtitle,str2short(titlebuf),
VAR_READWRITE|VAR_NOGLOB);
}
titlebuf[0] = '\0';
v = short2blk(nvc);
if (nvc != vc)
cleanup_until(nvc);
cleanup_push((Char **)v, blk_cleanup);
for (k = 0; v[k] != NULL ; k++){
__try {
StringCbCat(titlebuf,sizeof(titlebuf),v[k]);
StringCbCat(titlebuf,sizeof(titlebuf)," ");
}
__except(GetExceptionCode()) {
stderror(ERR_TOOMANY);
}
}
if (!SetConsoleTitle(titlebuf) ) {
make_err_str(GetLastError(),errbuf,128);
(void)StringCbPrintf(err2,sizeof(err2),"%s",v[k]);
stderror(ERR_SYSTEM,err2,errbuf);
}
cleanup_until((Char **)v);
return;
}
BOOL SetTokenIL(HANDLE hToken, DWORD dwIntegrityLevel)
{
BOOL fRet = FALSE;
PSID pIntegritySid = NULL;
TOKEN_MANDATORY_LABEL TIL = { 0 };
// Low integrity SID
WCHAR wszIntegritySid[32];
if (FAILED(StringCbPrintf(wszIntegritySid, sizeof(wszIntegritySid), L"S-1-16-%d", dwIntegrityLevel)))
{
printf("Error creating IL SID\n");
goto CleanExit;
}
fRet = ConvertStringSidToSid(wszIntegritySid, &pIntegritySid);
if (!fRet)
{
printf("Error converting IL string %ls\n", GetErrorMessage().c_str());
goto CleanExit;
}
TIL.Label.Attributes = SE_GROUP_INTEGRITY;
TIL.Label.Sid = pIntegritySid;
fRet = SetTokenInformation(hToken,
TokenIntegrityLevel,
&TIL,
sizeof(TOKEN_MANDATORY_LABEL) + GetLengthSid(pIntegritySid));
if (!fRet)
{
printf("Error setting IL %d\n", GetLastError());
goto CleanExit;
}
CleanExit:
LocalFree(pIntegritySid);
return fRet;
}
void
HttpRequest::FetchFaviconForDomain()
{
HANDLE hFile = INVALID_HANDLE_VALUE;
wchar_t domain[MAX_PATH];
const wchar_t * domain_ptr = domain;
{
URL_COMPONENTS uc;
memset(&uc, 0, sizeof(uc));
uc.dwStructSize = sizeof(uc);
uc.lpszHostName = domain;
uc.dwHostNameLength = ARRAYLENGTH(domain);
if (!WinHttpCrackUrl(m_target.c_str(), 0, 0, &uc))
StringCchCopy(domain, ARRAYLENGTH(domain), m_target.c_str());
}
MuteReports();
do {
khm_int32 rv;
rv = FetchResource(domain_ptr, L"/favicon.ico", icon_mimetypes);
if (KHM_SUCCEEDED(rv) || rv != KHM_ERROR_NOT_FOUND)
break;
{
wchar_t wwwdomain[MAX_PATH];
if (SUCCEEDED(StringCbPrintf(wwwdomain, sizeof(wwwdomain), L"www.%s", domain_ptr)) &&
(KHM_SUCCEEDED(FetchResource(wwwdomain, L"/favicon.ico", icon_mimetypes))))
break;
}
domain_ptr = wcschr(domain_ptr, L'.');
if (domain_ptr)
domain_ptr++;
} while(domain_ptr != NULL && *domain_ptr != L'\0');
MuteReports(false);
ReportComplete(false);
}
static void onerr(int iserror,const char* expr,const char*file,int line,const char* function) {
int ecode=GetLastError();
char emsg[1024]={0},
str[1024]={0};
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
0, /* source */
ecode, /* id */
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* lang id */
emsg,
sizeof(emsg),
0);
StringCbPrintf(str,sizeof(str)
,"%s(%d) - %s()\n\tExpression evaluated to false\n\t%s\n\tLast Windows Error Message: %s\n"
,file,line,function,expr,emsg);
OutputDebugString(str);
MessageBox(0,str,iserror?"Error":"Warning", MB_OK);
/* PostQuitMessage(1); */ /* Closes windows */
}
/*****************************************************************************
DWORD WriteSfvHeader(CONST HANDLE hFile)
hFile : (IN) handle to an open file
Return Value:
- returns NOERROR or GetLastError()
*****************************************************************************/
DWORD WriteFileComment(CONST HANDLE hFile, CONST FILEINFO *pFileInfo, UINT startChar)
{
TCHAR szLine[MAX_LINE_LENGTH];
#ifdef UNICODE
CHAR szLineAnsi[MAX_LINE_LENGTH];
#endif
DWORD dwNumberOfBytesWritten;
size_t stStringLength;
VOID *szOutLine=szLine;
SYSTEMTIME st;
FILETIME ft;
TCHAR szTimeStamp[50];
FileTimeToLocalFileTime( &pFileInfo->ftModificationTime, &ft );
FileTimeToSystemTime( &ft, &st );
int chars = GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, TEXT("HH':'mm'.'ss"), szTimeStamp, 50 );
GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, TEXT("' 'yyyy'-'MM'-'dd"), szTimeStamp + chars - 1, 50 - chars );
StringCbPrintf(szLine, MAX_LINE_LENGTH, TEXT(";%13I64d %s %s%s"), pFileInfo->qwFilesize, szTimeStamp, pFileInfo->szFilename.GetString() + startChar,
g_program_options.bCreateUnixStyle ? TEXT("\n") : TEXT("\r\n"));
StringCbLength(szLine, MAX_LINE_LENGTH, & stStringLength);
#ifdef UNICODE
if(!g_program_options.bCreateUnicodeFiles) {
if(!WideCharToMultiByte(CP_ACP, 0, szLine, -1, szLineAnsi, MAX_UTF8_PATH, NULL, NULL) )
return GetLastError();
StringCbLengthA(szLineAnsi, MAX_LINE_LENGTH, & stStringLength);
szOutLine=szLineAnsi;
} else if(g_program_options.iUnicodeSaveType == UTF_8 || g_program_options.iUnicodeSaveType==UTF_8_BOM) {
if(!WideCharToMultiByte(CP_UTF8, 0, szLine, -1, szLineAnsi, MAX_UTF8_PATH, NULL, NULL) )
return GetLastError();
StringCbLengthA(szLineAnsi, MAX_LINE_LENGTH, & stStringLength);
szOutLine=szLineAnsi;
}
#endif
if(!WriteFile(hFile, szOutLine, (DWORD)stStringLength, & dwNumberOfBytesWritten, NULL) )
return GetLastError();
return NOERROR;
}
// TODO : This will not only start the response but also send all headers, without content!
bool FilterAgentResponse::startResponse(int status, string reason, list<pair<string, string>> headers) {
if (committed) {
jk_log(this->logger, JK_LOG_ERROR, "Response already committed!");
return false;
}
committed = true;
char statusLine[MAX_HEADER_SIZE];
statusLine[0] = '\0';
StringCbPrintf(statusLine, MAX_HEADER_SIZE, "%d %s", status, reason.c_str());
string plainHeaders = "";
list<pair<string, string>>::iterator h;
for (h = headers.begin() ; h != headers.end() ; h ++) {
pair<string, string> p = *h;
plainHeaders.append(p.first);
plainHeaders.append(": ");
plainHeaders.append(p.second);
plainHeaders.append("\r\n");
}
if (plainHeaders.empty()) {
jk_log(logger, JK_LOG_WARNING, "No HTTP headers in response");
} else {
jk_log(logger, JK_LOG_TRACE, "HTTP headers \r\n%s", plainHeaders.c_str());
}
plainHeaders.append("\r\n");
const char * cHeaders = plainHeaders.c_str();
if(!pfc->ServerSupportFunction (pfc, SF_REQ_SEND_RESPONSE_HEADER, (PVOID) statusLine, (DWORD) cHeaders, 0)) {
DWORD dwError;
dwError = GetLastError();
jk_log(logger, JK_LOG_ERROR, "ServerSupportFunction[SF_REQ_SEND_RESPONSE_HEADER] failed = %d (%x)", dwError, dwError);
return false;
}
return true;
}
