able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/irda/irxfer/irxfer.cxx

2169 lines
52 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1997 - 1999
//
// File: irxfer.cxx
//
//--------------------------------------------------------------------------
/*
* IRXFER.C
*
*/
#include "precomp.h"
#include <malloc.h>
#include <userenv.h>
#include <winsta.h>
#include <ssdp.h>
#include <devlist.h>
#include <irmon.h>
// If this is defined, then we don't popup the up for devices,
// because MBert in the irmon code is doing a tool bubble for
// this now...
#define TURN_OFF_POPUP
//
#ifndef _ALPHA_
#ifndef VOLATILE
#define VOLATILE volatile
#endif
#endif
//
struct SAVED_IRDA_DEVICE_LIST
{
unsigned MaxDevices;
OBEX_DEVICE_LIST Devices;
};
typedef struct _IRXFER_CONTROL {
CRITICAL_SECTION Lock;
PVOID IrmonContext;
ADHOC_CALLBACK AdhocCallback;
SET_SOUND_STATUS_FN SoundStatusCallback;
LONG AdhocNetworkPresent;
PXFER_LIST TransferList;
FILE_TRANSFER *IrTransfer1;
FILE_TRANSFER *IrTransfer2;
} IRXFER_CONTROL, *PIRXFER_CONTROL;
IRXFER_CONTROL GlobalControl;
//
// choices for IRFTP.EXE command-line switches
//
wchar_t * WSZ_SHOW_NOTHING = L"irftp.exe /h";
wchar_t * WSZ_SHOW_WINDOW = L"irftp.exe";
wchar_t * WSZ_SHOW_PROPERTIES_PAGE = L"irftp.exe /s";
wchar_t g_UiCommandLine[ MAX_PATH ];
//
// Handle for irmon.dll (see ..\irmon\irmon.c).
//
extern "C" HINSTANCE ghInstance;
//
// Entry points for IrTran-P
//
#ifdef IRTRANP_ENABLED
extern DWORD WINAPI IrTranP( IN void *pvRpcBinding );
extern VOID IrTranPEnableIrCOMMFailed( IN DWORD dwStatus );
extern BOOL UninitializeIrTranP( IN HANDLE hThread );
extern DWORD EnableDisableIrCOMM( IN BOOL fDisable );
extern DWORD EnableDisableIrTranPv1( IN BOOL fDisable );
static HANDLE g_hIrTranPThread = INVALID_HANDLE_VALUE;
//static DWORD g_dwIrTranPThreadId;
#endif
//
// registry entries
//
const wchar_t * const WSZ_REG_KEY = L"Control Panel\\Infrared";
const wchar_t * const WSZ_REG_KEY_GLOBAL = L"Control Panel\\Infrared\\Global";
const wchar_t * const WSZ_REG_KEY_XFER = L"Control Panel\\Infrared\\File Transfer";
#ifdef IRTRANP_ENABLED
const wchar_t * const WSZ_REG_KEY_IRTRANP = L"Control Panel\\Infrared\\IrTranP";
#endif
const wchar_t * const WSZ_REG_SHOW_UI = L"PopupApp";
const wchar_t * const WSZ_REG_ALLOW_RECEIVE = L"AllowSend";
const wchar_t * const WSZ_REG_SHOW_TRAY = L"ShowTrayIcon";
const wchar_t * const WSZ_REG_PLAY_SOUND = L"PlaySound";
const wchar_t * const WSZ_REG_RECEIVED_FILES_FOLDER = L"RecvdFilesLocation";
#ifdef IRTRANP_ENABLED
const wchar_t * const WSZ_REG_PICTURES_FOLDER = L"RecvdFilesLocation";
const wchar_t * const WSZ_REG_DISABLE_IRTRANPV1 = L"DisableIrTranPv1";
const wchar_t * const WSZ_REG_DISABLE_IRCOMM = L"DisableIrCOMM";
const wchar_t * const WSZ_REG_EXPLORE = L"ExploreOnCompletion";
const wchar_t * const WSZ_REG_SAVEASUPF = L"SaveAsUPF";
const wchar_t * const WSZ_DEFAULT_MYPICTURES = L"C:\\My Pictures";
#endif
HANDLE NetworkRegistrationHandle=NULL;
SET_TRAY_STATUS_FN g_SetTrayStatus;
SET_LOGON_STATUS_FN g_SetLogonStatus;
HKEY g_hUserKey;
HKEY g_hInfraredKey;
HKEY g_hGlobalKey ;
HKEY g_hFileXferKey;
#ifdef IRTRANP_ENABLED
HKEY g_hIrTranPXferKey = 0;
BOOL g_fIrTranPv1Disabled = FALSE;
BOOL g_fIrCOMMDisabled = TRUE;
BOOL g_fExploreOnCompletion = TRUE;
BOOL g_fSaveAsUPF = FALSE;
#endif
// shared with irmon.c
//
HANDLE g_UserToken;
HANDLE g_RegistryEvent;
MUTEX * g_Mutex;
struct SAVED_IRDA_DEVICE_LIST * g_DeviceList;
wchar_t g_ReceivedFilesFolder [ MAX_PATH ];
wchar_t g_DuplicateFileTemplate[ MAX_PATH ];
wchar_t g_DesktopFolder [ MAX_PATH ];
wchar_t g_UnknownDeviceName [ 100 ];
#ifdef IRTRANP_ENABLED
wchar_t g_DefaultPicturesFolder[ MAX_PATH ];
wchar_t g_SpecifiedPicturesFolder[ MAX_PATH ];
#endif
HANDLE g_RegistryWaitHandle = 0;
void
RegistryMonitorCallback(
PVOID ignore,
BOOLEAN unknown
);
BOOL Uninit_RegistryCallback();
HANDLE g_hUi;
RPC_BINDING_HANDLE rpcBinding = 0;
BOOL fListen = TRUE;
BOOL g_fAllowReceives = FALSE;
BOOL g_fShowTrayIcon = TRUE;
BOOL g_fShutdown = FALSE;
BOOL g_fLogoff = FALSE;
BOOL g_fRegistryWaitComplete = FALSE;
BOOL Init_Rpc();
void __stdcall
ProcessRegistryChange();
unsigned long
RegistryMonitorThread(
PVOID ignore
);
DWORD ReadUserPreferences();
BOOL
GetUserToken(
ULONG LogonId,
PHANDLE pUserToken
);
HMODULE hWinstaDll;
PWINSTATIONQUERYINFORMATIONW pWinstationQueryInformation = 0;
BOOL Uninit_Token();
BOOL Uninit_Rpc();
extern "C"
{
extern RPC_IF_HANDLE _NotifyLogon_ServerIfHandle;
void
_UserLoggedOn( handle_t rpc,
error_status_t __RPC_FAR * pStatus
);
void
_UserLoggedOff( handle_t rpc,
error_status_t __RPC_FAR * pStatus
);
BOOL
ShowSendWindow();
BOOL
ShowPropertiesPage();
} // extern "c"
VOID
RemoveFromTransferList(
FILE_TRANSFER* Transfer
)
{
RemoveTransferFromList(GlobalControl.TransferList,Transfer);
return;
}
BOOL
NewAddressHandler(
HANDLE Context,
SOCKET ListenSocket,
HANDLE *AddressContext
)
{
PIRXFER_CONTROL Control=(PIRXFER_CONTROL)Context;
FILE_TRANSFER* Transfer;
BOOL bResult;
LONG Count;
Transfer=ListenForTransfer(ListenSocket,TYPE_IP);
if (Transfer == NULL) {
return FALSE;
}
bResult=AddTransferToList(Control->TransferList,Transfer);
if (!bResult) {
Transfer->StopListening();
return FALSE;
}
EnterCriticalSection(&Control->Lock);
Count=InterlockedIncrement(&Control->AdhocNetworkPresent);
LeaveCriticalSection(&Control->Lock);
if (Count == 1) {
(*Control->AdhocCallback)(Control->IrmonContext,TRUE);
}
*AddressContext=Transfer;
return TRUE;
}
VOID
AddressRemoveHandler(
HANDLE Context,
HANDLE AddressContext
)
{
PIRXFER_CONTROL Control=(PIRXFER_CONTROL)Context;
FILE_TRANSFER* Transfer=(FILE_TRANSFER*)AddressContext;
LONG Count;
RemoveTransferFromList(Control->TransferList,Transfer);
Transfer->StopListening();
EnterCriticalSection(&Control->Lock);
Count=InterlockedDecrement(&Control->AdhocNetworkPresent);
LeaveCriticalSection(&Control->Lock);
if (Count == 0) {
(*Control->AdhocCallback)(Control->IrmonContext,FALSE);
}
return;
}
BOOL
InitializeIrxfer(
PVOID IrmonContext,
ADHOC_CALLBACK AdhocCallback,
SET_LOGON_STATUS_FN x,
SET_TRAY_STATUS_FN y,
SET_SOUND_STATUS_FN SoundStatusCallback,
PVOID *IrxferContext
)
{
BOOL b;
DWORD status = 0;
DWORD dwIrTranPThreadId;
ZeroMemory(&GlobalControl,sizeof(GlobalControl));
GlobalControl.IrmonContext=IrmonContext;
GlobalControl.AdhocCallback=AdhocCallback;
GlobalControl.SoundStatusCallback=SoundStatusCallback;
InitializeCriticalSection(&GlobalControl.Lock);
*IrxferContext=&GlobalControl;
g_fShutdown = FALSE;
g_SetLogonStatus = x;
g_SetTrayStatus = y;
#ifdef TURN_OFF_POPUP
wcscpy( g_UiCommandLine, WSZ_SHOW_NOTHING);
#endif
//
// Event logging. This will make sure that the system event
// logging is configured in the registry:
//
status = EVENT_LOG::CheckConfiguration( WS_EVENT_SOURCE,
WS_CATALOG_PATH,
CATEGORY_COUNT,
0x7 );
#ifdef DBG_ERROR
if (dwEventStatus)
{
DbgPrint("IrMon: EVENT_LOG::CheckConfiguration() failed: %d\n",
status );
}
#endif
if (!LoadString( ghInstance,
IDS_DUPLICATE_FILE_PATTERN,
g_DuplicateFileTemplate,
sizeof(g_DuplicateFileTemplate) / sizeof(WCHAR)
))
{
goto abend;
}
if (!LoadString( ghInstance,
IDS_UNKNOWN_DEVICE,
g_UnknownDeviceName,
sizeof(g_UnknownDeviceName) / sizeof(WCHAR)
))
{
goto abend;
}
GlobalControl.TransferList=CreateXferList();
if (GlobalControl.TransferList == NULL) {
goto abend;
}
g_Mutex = new MUTEX(&status);
if (!g_Mutex || status)
{
goto abend;
}
#if 0
if (0 != FILE_TRANSFER::Init())
{
goto abend;
}
#endif
if (!Init_Rpc())
{
goto abend;
}
#if 0
if ( !FILE_TRANSFER::Sock_Init() )
{
goto abend;
}
#endif
g_RegistryEvent = CreateEvent( NULL, // no security
FALSE, // auto-reset
FALSE, // initially FALSE
NULL // no name
);
if (!g_RegistryEvent)
{
goto abend;
}
//
// This function allows us to get a copy of the interactive user's token.
//
{
hWinstaDll = LoadLibraryW(L"winsta.dll");
if (hWinstaDll == NULL)
{
goto abend;
}
pWinstationQueryInformation = (PWINSTATIONQUERYINFORMATIONW) GetProcAddress( hWinstaDll, "WinStationQueryInformationW" );
if (!pWinstationQueryInformation)
{
goto abend;
}
}
g_hIrTranPThread = CreateThread( NULL,
0,
IrTranP,
&rpcBinding,
0,
&dwIrTranPThreadId );
b = GetUserToken( 0, // Terminal Srv ID for the console
&g_UserToken
);
if (b)
{
if (FAILED( SHGetFolderPath( NULL,
CSIDL_DESKTOPDIRECTORY,
g_UserToken,
0,
g_DesktopFolder)))
{
wcscpy( g_DesktopFolder, L"C:\\");
}
ReadUserPreferences();
}
else
{
DbgLog1(SEV_INFO, "get user token failed %d", GetLastError());
}
// Start the IrTran-P monitor:
#ifdef IRTRANP_ENABLED
if ( (!g_UserToken)
|| FAILED( SHGetFolderPath( NULL,
CSIDL_MYPICTURES,
g_UserToken,
0,
g_DefaultPicturesFolder)))
{
wcscpy( g_DefaultPicturesFolder, WSZ_DEFAULT_MYPICTURES );
}
#endif
return TRUE;
abend:
DWORD dwEventStatus = 0;
EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus);
if (!dwEventStatus)
{
EventLog.ReportError(CAT_IRXFER, MC_IRXFER_SETUP_FAILED, GetLastError());
}
if (GlobalControl.TransferList != NULL) {
DeleteXferList(GlobalControl.TransferList);
}
delete g_Mutex;
if (g_RegistryEvent)
{
Uninit_RegistryCallback();
}
if (hWinstaDll != NULL)
{
FreeLibrary( hWinstaDll );
hWinstaDll = NULL;
}
return FALSE;
}
void
_UserLoggedOn( handle_t rpc,
error_status_t __RPC_FAR * pStatus
)
{
BOOL b;
LONG i=10;
//
// Allow only a single notification at a time, to avoid odd race conditions.
//
CLAIM_MUTEX Lock( g_Mutex );
DbgLog(SEV_INFO, "user logged on");
if (g_UserToken) {
CloseHandle( g_UserToken );
g_UserToken = NULL;
}
while (i > 0) {
b = GetUserToken( 0, // Terminal Srv ID for the console
&g_UserToken
);
if (!b) {
#if DBG
*pStatus = GetLastError();
DbgPrint("irmon: Could not get user token, status=%d, count=%d\n",*pStatus,i);
#endif
Sleep(500);
i--;
} else {
break;
}
}
if (!b && (i == 0)) {
*pStatus = GetLastError();
DWORD dwEventStatus = 0;
EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus);
if (!dwEventStatus) {
EventLog.ReportError(CAT_IRXFER, MC_IRXFER_LOGON_FAILED, GetLastError());
}
return;
}
if (FAILED( SHGetFolderPath( NULL,
CSIDL_DESKTOPDIRECTORY,
g_UserToken,
0,
g_DesktopFolder)))
{
wcscpy( g_DesktopFolder, L"C:\\");
}
#ifdef IRTRANP_ENABLED
if (FAILED( SHGetFolderPath( NULL,
CSIDL_MYPICTURES,
g_UserToken,
0,
g_DefaultPicturesFolder)))
{
wcscpy( g_DefaultPicturesFolder, WSZ_DEFAULT_MYPICTURES );
}
#endif
*pStatus = ReadUserPreferences();
if (*pStatus)
{
SetLastError(*pStatus);
}
}
DWORD
ReadUserPreferences()
{
TOKEN_USER * TokenData;
DbgLog(SEV_INFO, "ReadUserPreferences");
//
// Protect ourselves from login or logout notifications while using the token.
//
{
CLAIM_MUTEX Lock( g_Mutex );
//
// Open the user's preferences keys.
//
DWORD Status = 0;
DWORD SizeNeeded;
GetTokenInformation ( g_UserToken,
TokenUser,
0,
0,
&SizeNeeded
);
__try
{
TokenData = (TOKEN_USER *) _alloca( SizeNeeded );
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
DbgLog1(SEV_WARNING, "GetTokenInfo 1 failed %d", GetLastError());
Status = ERROR_NOT_ENOUGH_MEMORY;
}
if (Status)
{
return Status;
}
if (!GetTokenInformation ( g_UserToken,
TokenUser,
TokenData,
SizeNeeded,
&SizeNeeded
))
{
DbgLog1(SEV_WARNING, "GetTokenInfo 2 failed %d", GetLastError());
return GetLastError();
}
}
wchar_t UnicodeBuffer[256];
UNICODE_STRING UnicodeString;
UnicodeString.Buffer = UnicodeBuffer;
UnicodeString.Length = 0;
UnicodeString.MaximumLength = sizeof(UnicodeBuffer);
NTSTATUS NtStatus;
NtStatus = RtlConvertSidToUnicodeString( &UnicodeString,
TokenData->User.Sid,
FALSE
);
if (!NT_SUCCESS(NtStatus))
{
DbgLog1(SEV_WARNING, "RtlConvertSid failed %x", NtStatus);
return GetLastError();
}
UnicodeString.Buffer[UnicodeString.Length] = 0;
//
// Open all our keys. If we can't open the user's key
// or the key to watch for changes, we bail.
//
if (RegOpenKeyEx( HKEY_USERS,
UnicodeString.Buffer,
0,
KEY_READ,
&g_hUserKey
))
{
DbgLog2(SEV_WARNING, "RegOpenKey %S failed %d", UnicodeString.Buffer, GetLastError());
return GetLastError();
}
DWORD Disposition;
if (RegCreateKeyEx( g_hUserKey,
WSZ_REG_KEY,
0, // reserved MBZ
0, // class name
REG_OPTION_NON_VOLATILE,
KEY_READ,
0, // security attributes
&g_hInfraredKey,
&Disposition
))
{
DbgLog2(SEV_WARNING, "RegCreateKey '%S' failed %d", WSZ_REG_KEY, GetLastError());
return GetLastError();
}
#ifdef IRTRANP_ENABLED
RegOpenKeyEx( g_hUserKey,
WSZ_REG_KEY_IRTRANP,
0,
KEY_READ,
&g_hIrTranPXferKey );
#endif
//
// Inform MBert to start PnP'ing printers and maybe to show the tray icon.
//
(*g_SetLogonStatus)( TRUE );
//
// Start the registry snoop.
//
RegistryMonitorCallback(0, 0);
#if 0
NetworkRegistrationHandle=RegisterForAdhocNetworksNotification(
&GlobalControl,
NewAddressHandler,
AddressRemoveHandler
);
#endif
#if 1
BOOL bResult;
GlobalControl.IrTransfer1=InitializeSocket( SERVICE_NAME_1);
if (GlobalControl.IrTransfer1 != NULL) {
bResult=AddTransferToList(GlobalControl.TransferList,GlobalControl.IrTransfer1);
if (!bResult) {
GlobalControl.IrTransfer1->StopListening();
GlobalControl.IrTransfer1=NULL;
}
}
GlobalControl.IrTransfer2=InitializeSocket(SERVICE_NAME_2);
if (GlobalControl.IrTransfer2 != NULL) {
bResult=AddTransferToList(GlobalControl.TransferList,GlobalControl.IrTransfer2);
if (!bResult) {
GlobalControl.IrTransfer2->StopListening();
GlobalControl.IrTransfer2=NULL;
}
}
#endif
return 0;
}
void
_UserLoggedOff( handle_t rpc,
error_status_t __RPC_FAR * pStatus
)
{
error_status_t status = 0;
//
// Allow only a single notification at a time, to avoid odd race conditions.
//
CLAIM_MUTEX Lock( g_Mutex );
DbgLog(SEV_INFO, "user logged off");
g_fLogoff = TRUE;
g_fAllowReceives = FALSE;
#if 0
if (NetworkRegistrationHandle != NULL) {
UnRegisterForAdhocNetworksNotification(NetworkRegistrationHandle);
NetworkRegistrationHandle=NULL;
}
#endif
if (GlobalControl.IrTransfer1 != NULL) {
RemoveTransferFromList(GlobalControl.TransferList,GlobalControl.IrTransfer1);
GlobalControl.IrTransfer1->StopListening();
GlobalControl.IrTransfer1=NULL;
}
if (GlobalControl.IrTransfer2 != NULL) {
RemoveTransferFromList(GlobalControl.TransferList,GlobalControl.IrTransfer2);
GlobalControl.IrTransfer2->StopListening();
GlobalControl.IrTransfer2=NULL;
}
if (g_hUi) {
CloseHandle( g_hUi );
g_hUi = 0;
}
//
// Close down the registry watcher.
//
if (g_RegistryWaitHandle)
{
if (FALSE == UnregisterWait( g_RegistryWaitHandle ))
{
while (!*((BOOL volatile *)&g_fRegistryWaitComplete))
{
Sleep(1000);
}
}
g_RegistryWaitHandle = 0;
}
g_fRegistryWaitComplete = FALSE;
CloseHandle( g_UserToken );
g_UserToken = 0;
//
// Close the registry handles.
//
RegCloseKey( g_hUserKey );
g_hUserKey = 0;
RegCloseKey( g_hFileXferKey );
g_hFileXferKey = 0;
#ifdef IRTRANP_ENABLED
RegCloseKey( g_hIrTranPXferKey );
g_hIrTranPXferKey = 0;
#endif
RegCloseKey( g_hInfraredKey );
g_hInfraredKey = 0;
RegCloseKey( g_hGlobalKey );
g_hGlobalKey = 0;
(*g_SetLogonStatus)( FALSE );
(*g_SetTrayStatus)( GlobalControl.IrmonContext, FALSE );
NoDeviceInRange( rpcBinding, &status );
*pStatus = 0;
g_fLogoff = FALSE;
}
#ifdef IRTRANP_ENABLED
//--------------------------------------------------------------------
// RegistryCheckDwordFlag()
//
// Check to see if the specified registry key value has changed,
// if so, then update the value and return TRUE.
//--------------------------------------------------------------------
BOOL RegistryCheckDwordFlag( IN HKEY hKey,
IN const WCHAR *pwszValueName,
IN BOOL NotPresentValue,
OUT BOOL *pbValue )
{
BOOL fChanged = FALSE;
DWORD dwStatus = 0;
DWORD dwRegDword;
DWORD dwSize = sizeof(dwRegDword);
dwStatus = RegQueryValueEx( hKey,
pwszValueName,
NULL,
NULL,
(UCHAR*)&dwRegDword,
&dwSize );
if (dwStatus != ERROR_SUCCESS) {
//
// failed, no change
//
DbgLog2(SEV_INFO,"REG: Key/Value: %S: Status: %d\n",
pwszValueName, dwStatus );
if (NotPresentValue != *pbValue) {
//
// the not present value is no the same as the current, change and report a change
//
*pbValue=NotPresentValue;
return TRUE;
}
//
// No change
//
return FALSE;
} else {
//
// got value
//
if ( (dwRegDword) && (*pbValue == FALSE)) {
//
// Value changed from FALSE to TRUE.
//
fChanged = TRUE;
*pbValue = TRUE;
} else if ((!dwRegDword) && (*pbValue)) {
//
// Value changed from TRUE to FALSE.
//
fChanged = TRUE;
*pbValue = FALSE;
}
}
return fChanged;
}
//--------------------------------------------------------------------
// IrTranPFlagChanged()
//
// Check to see if the specified registry flag changed. If the value
// changed, return TRUE, if not then return FALSE. Return the new value
// in *pfDisabled.
//--------------------------------------------------------------------
BOOL IrTranPFlagChanged( IN const WCHAR *pwszDisabledValueName,
IN BOOL NotPresentValue,
IN OUT BOOL *pfDisabled )
{
DWORD dwStatus = 0;
DWORD dwSize;
DWORD dwRegDword;
BOOL fChanged = FALSE;
BOOL fDisabled = *pfDisabled;
DbgLog3(SEV_INFO, "Process IrTranP flag Change %S, def=%d, current=%d",
pwszDisabledValueName,
NotPresentValue,
*pfDisabled
);
if (!g_hIrTranPXferKey)
{
// By default, the IrTranP subkey does not exist at all until
// user brings up Wireless Link CPL and makes changes to
// to the Image Transfer page. Without trying to reopen the subkey
// here, we may fail to pick up the changes if this is the first
// time IrTranP subkey gets created.
// The other issue that might rise(although rare) is when the subkey
// is deleted for whatever reasons. We should reset everything to
// default when the key is deleted. An easy but slow solution is to
// reopen the subkey everytime this function is called. This approach
// would ensures that the HKEY to the subkey is always fresh.
// Since the case is rare and implementation is slow, lets forget
// about this for the time being. If the entire Infrared subkey is
// deleted or missing then we will return TRUE (the default is
// enabled).
//
RegOpenKeyEx(g_hUserKey,
WSZ_REG_KEY_IRTRANP,
0,
KEY_READ,
&g_hIrTranPXferKey );
}
if (!g_hIrTranPXferKey) {
DbgLog(SEV_INFO, "IrTranP: g_hIrTranPXferKey not opened");
if (NotPresentValue != *pfDisabled) {
//
// the not present value does not match the current setting, change it
//
*pfDisabled=NotPresentValue;
return TRUE;
}
//
// it must match, so no change
//
return FALSE;
}
//
// Is IrTranP over the specified channel to be disabled?
//
if (RegistryCheckDwordFlag(g_hIrTranPXferKey,
pwszDisabledValueName,
NotPresentValue,
&fDisabled))
{
#ifdef DBG_REGISTRY
DbgPrint("DisableIrCOMM: Changed: %d\n",g_fIrCOMMDisabled);
#endif
}
if (*pfDisabled != fDisabled)
{
*pfDisabled = fDisabled;
fChanged = TRUE;
}
return fChanged;
}
//--------------------------------------------------------------------
// ProcessIrTranPRegistryChanges()
//
//--------------------------------------------------------------------
void ProcessIrTranPRegistryChanges()
{
DWORD dwStatus = 0;
DWORD dwSize;
DWORD dwRegDword;
DbgLog(SEV_INFO, "Process IrTranP Registry Change");
//
// Is IrTranP over IrCOMM to be disabled?
//
if (IrTranPFlagChanged(WSZ_REG_DISABLE_IRCOMM,TRUE,&g_fIrCOMMDisabled))
{
#ifdef DBG_REGISTRY
DbgPrint("DisableIrCOMM: Changed: %d\n",g_fIrCOMMDisabled);
#endif
dwStatus = EnableDisableIrCOMM(g_fIrCOMMDisabled);
if ((g_fIrCOMMDisabled == FALSE) && (dwStatus))
{
#ifdef DBG_ERROR
if (dwStatus)
{
DbgPrint("IrTranP: EnableDisableIrCOMM() failed: %d\n",dwStatus);
}
#endif
IrTranPEnableIrCOMMFailed(dwStatus);
}
}
//
// Is IrTranP over sockets (IrTranPv1) to be disabled?
//
if (IrTranPFlagChanged(WSZ_REG_DISABLE_IRTRANPV1,FALSE,&g_fIrTranPv1Disabled))
{
#ifdef DBG_REGISTRY
DbgPrint("DisableIrTranPv1: Changed: %d\n",g_fIrTranPv1Disabled);
#endif
dwStatus = EnableDisableIrTranPv1(g_fIrTranPv1Disabled);
}
//
// Explore the new pictures automatically:
//
if (RegistryCheckDwordFlag(g_hIrTranPXferKey,
WSZ_REG_EXPLORE,
TRUE,
&g_fExploreOnCompletion))
{
#ifdef DBG_REGISTRY
DbgPrint("ExploreOnCompletion: Changed: %d\n",g_fExploreOnCompletion);
#endif
}
//
// Save pictures as .UPF files instead of .JPEG files?
//
// NOTE: This is used for testing to create full .UPF files and
// would not normally be set by the customer.
//
if (RegistryCheckDwordFlag(g_hIrTranPXferKey,
WSZ_REG_SAVEASUPF,
FALSE,
&g_fSaveAsUPF))
{
#ifdef DBG_REGISTRY
DbgPrint("SaveAsUPF: Changed: %d\n",g_fSaveAsUPF);
#endif
}
//
// Where pictures are to be stored. If this value exists then it
// is used instead of the default "My Documents\My Pictures\"
// path.
//
dwSize = sizeof(g_SpecifiedPicturesFolder);
dwStatus = RegQueryValueEx( g_hIrTranPXferKey,
WSZ_REG_PICTURES_FOLDER,
NULL,
NULL,
(UCHAR*)g_SpecifiedPicturesFolder,
&dwSize );
if (dwStatus)
{
DbgLog1( SEV_INFO, "REG: Pictures Folder Status: %d\n", dwStatus );
g_SpecifiedPicturesFolder[0] = 0;
}
else
{
DbgLog1( SEV_INFO, "REG: Pictures Folder %S\n",
g_SpecifiedPicturesFolder );
#ifdef DBG_REGISTRY
DbgPrint("RecvdFilesLocation: %S\n",g_SpecifiedPicturesFolder);
#endif
}
}
#endif
//--------------------------------------------------------------------
// ProcessRegistryChange()
//
//--------------------------------------------------------------------
void __stdcall
ProcessRegistryChange()
{
DWORD status = 0;
DWORD size = sizeof(unsigned char);
unsigned char bool = 0;
DbgLog(SEV_INFO, "process registry change");
if (!g_hGlobalKey)
{
status = RegOpenKeyEx( g_hUserKey,
WSZ_REG_KEY_GLOBAL,
0,
KEY_READ,
& g_hGlobalKey
);
if (status)
{
DbgLog2(SEV_WARNING, "RegOpenKeyEx '%S' failed %d", WSZ_REG_KEY_GLOBAL, status);
}
}
if (!g_hFileXferKey)
{
status = RegOpenKeyEx( g_hUserKey,
WSZ_REG_KEY_XFER,
0,
KEY_READ,
& g_hFileXferKey
);
if (status)
{
DbgLog2(SEV_WARNING, "RegOpenKeyEx '%S' failed %d", WSZ_REG_KEY_XFER, status);
}
}
#ifndef TURN_OFF_POPUP
status = RegQueryValueEx( g_hFileXferKey,
WSZ_REG_SHOW_UI,
NULL,
NULL,
&bool,
&size
);
if (status || bool)
{
DbgLog1( SEV_INFO, "reg: show ui key, status %d\n", status);
wcscpy( g_UiCommandLine, WSZ_SHOW_WINDOW);
}
else
{
wcscpy( g_UiCommandLine, WSZ_SHOW_NOTHING);
}
#endif
//
// Are other people allowed to send to me?
//
size = sizeof(unsigned char);
status = RegQueryValueEx( g_hFileXferKey,
WSZ_REG_ALLOW_RECEIVE,
NULL,
NULL,
&bool,
&size
);
if (!g_hUserKey)
{
g_fAllowReceives = FALSE;
}
else if (status || bool)
{
DbgLog1( SEV_INFO, "reg: allow receives key, status %d\n", status);
g_fAllowReceives = TRUE;
}
else
{
g_fAllowReceives = FALSE;
}
size = sizeof( g_ReceivedFilesFolder );
status = RegQueryValueEx( g_hFileXferKey,
WSZ_REG_RECEIVED_FILES_FOLDER,
NULL,
NULL,
(unsigned char *) g_ReceivedFilesFolder,
&size
);
if (status)
{
wcscpy( g_ReceivedFilesFolder, g_DesktopFolder );
DbgLog2( SEV_INFO, "reg: received files folder status %d\nfolder %S", status, g_ReceivedFilesFolder);
}
else
{
DbgLog1( SEV_INFO, "reg: received files folder %S\n", g_ReceivedFilesFolder);
}
// always end path with a backslash '\'
if( bNoTrailingSlash(g_ReceivedFilesFolder) )
lstrcat(g_ReceivedFilesFolder, szBACKSLASH );
size = sizeof(unsigned char);
status = RegQueryValueEx( g_hGlobalKey,
WSZ_REG_SHOW_TRAY,
NULL,
NULL,
&bool,
&size
);
if (status || bool)
{
DbgLog1( SEV_INFO, "reg: show tray key, status %d\n", status);
g_fShowTrayIcon = TRUE;
}
else
{
g_fShowTrayIcon = FALSE;
}
(*g_SetTrayStatus)( GlobalControl.IrmonContext, g_fShowTrayIcon );
size = sizeof(unsigned char);
status = RegQueryValueEx( g_hGlobalKey,
WSZ_REG_PLAY_SOUND,
NULL,
NULL,
&bool,
&size
);
if ((status != ERROR_SUCCESS)) {
DbgLog1( SEV_INFO, "reg: play sound key, status %d\n", status);
bool=TRUE;
}
(*GlobalControl.SoundStatusCallback)(
GlobalControl.IrmonContext,
bool
);
//
// Process changes specific to IrTran-P:
//
#ifdef IRTRANP_ENABLED
ProcessIrTranPRegistryChanges();
#endif
//
// Look for more changes.
//
status = RegNotifyChangeKeyValue( g_hInfraredKey,
TRUE, // watch child keys
REG_NOTIFY_CHANGE_LAST_SET,
g_RegistryEvent,
TRUE // async
);
if (status)
{
DWORD dwEventStatus = 0;
EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus);
if (!dwEventStatus)
{
EventLog.ReportError(CAT_IRXFER, MC_IRXFER_REGISTER_NOTIFY_FAILED, status);
}
}
}
void
RegistryMonitorCallback(
PVOID ignore,
BOOLEAN unknown
)
{
DbgLog(SEV_INFO, "reg callback");
if (g_fShutdown || g_fLogoff)
{
DbgLog(SEV_INFO, "reg callback: terminating");
if (g_fShutdown)
{
CloseHandle( g_RegistryEvent );
}
g_fRegistryWaitComplete = TRUE;
return;
}
ProcessRegistryChange();
if (!RegisterWaitForSingleObject( &g_RegistryWaitHandle,
g_RegistryEvent,
RegistryMonitorCallback,
0,
INFINITE,
WT_EXECUTEDEFAULT
))
{
g_RegistryWaitHandle = 0;
DWORD dwEventStatus = 0;
EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus);
if (!dwEventStatus)
{
EventLog.ReportError(CAT_IRXFER, MC_IRXFER_REGISTER_NOTIFY_FAILED, GetLastError());
}
}
}
void
UpdateDiscoveredDevices(
const OBEX_DEVICE_LIST *IrDevices,
const OBEX_DEVICE_LIST *IpDevices
)
{
BOOL fLaunch = FALSE;
error_status_t status;
DbgLog2(SEV_INFO, "device notification: %d Ir devices and %d Ip devices in range", IrDevices->DeviceCount,IpDevices->DeviceCount);
//
// Update the saved device list.
//
SAVED_IRDA_DEVICE_LIST * list;
g_Mutex->Enter();
if ((g_DeviceList == NULL)
||
(g_DeviceList->MaxDevices < (IrDevices->DeviceCount + IpDevices->DeviceCount))) {
list = (SAVED_IRDA_DEVICE_LIST *)
new char [ sizeof(SAVED_IRDA_DEVICE_LIST)
+ (IrDevices->DeviceCount + IpDevices->DeviceCount) * sizeof(OBEX_DEVICE)
];
if (!list) {
g_Mutex->Leave();
return;
}
list->MaxDevices = 1+IrDevices->DeviceCount + IpDevices->DeviceCount;
if (g_DeviceList) {
delete g_DeviceList;
}
g_DeviceList = list;
} else {
list = g_DeviceList;
}
//
// Determine how many of the existing devices support our protocol.
//
list->Devices.DeviceCount=0;
unsigned i;
for (i=0; i < IrDevices->DeviceCount; i++) {
list->Devices.DeviceList[list->Devices.DeviceCount]=IrDevices->DeviceList[i];
list->Devices.DeviceCount++;
fLaunch = fLaunch || list->Devices.DeviceList[i].DeviceSpecific.s.Irda.ObexSupport;
}
//
// add in any ip devices as well
//
for (i=0; i < IpDevices->DeviceCount; i++) {
list->Devices.DeviceList[list->Devices.DeviceCount]=IpDevices->DeviceList[i];
list->Devices.DeviceCount++;
fLaunch = TRUE;
}
//
// Inform the UI program of the new device list. Don't create the process
// unless at least one of the devices said it supports OBEX.
//
if (fLaunch) {
g_Mutex->Leave();
LaunchUi( g_UiCommandLine );
} else {
if (g_DeviceList->Devices.DeviceCount > 0) {
DeviceInRange( rpcBinding, &g_DeviceList->Devices, &status );
g_Mutex->Leave();
DbgLog1(SEV_INFO, "UpdateDiscoveredDevices: DeviceInRange returned %d", status);
} else {
g_Mutex->Leave();
NoDeviceInRange( rpcBinding, &status );
}
}
}
BOOL
UninitializeIrxfer(
PVOID IrxferContext
)
{
PIRXFER_CONTROL Control=(PIRXFER_CONTROL)IrxferContext;
error_status_t LogoffStatus;
g_fShutdown = TRUE;
DbgLog1(SEV_INFO, "start shutdown: %d", GetTickCount());
_UserLoggedOff(NULL,&LogoffStatus);
if (Control->TransferList != NULL) {
DeleteXferList(Control->TransferList);
}
ShutdownUi( rpcBinding );
DbgLog1(SEV_INFO, "after RPC: %d", GetTickCount());
BOOL fSuccess = TRUE;
// fSuccess &= FILE_TRANSFER::Shutdown();
DbgLog1(SEV_INFO, "after FILE_TRANSFER::Shutdown: %d", GetTickCount());
fSuccess &= Uninit_Rpc();
DbgLog1(SEV_INFO, "after Unit_Rpc: %d", GetTickCount());
fSuccess &= Uninit_RegistryCallback();
DbgLog1(SEV_INFO, "after registry: %d", GetTickCount());
fSuccess &= Uninit_Token();
DbgLog1(SEV_INFO, "after token: %d", GetTickCount());
#ifdef IRTRANP_ENABLED
fSuccess &= UninitializeIrTranP(g_hIrTranPThread);
#endif
if (hWinstaDll != NULL)
{
FreeLibrary( hWinstaDll );
hWinstaDll = NULL;
}
#ifdef LOGGING
Log_Close();
#endif
DeleteCriticalSection(&Control->Lock);
return fSuccess;
}
BOOL
Uninit_RegistryCallback()
{
BOOL fSuccess = TRUE;
SetEvent( g_RegistryEvent );
//
// The handle will be deleted when the callback is completed.
//
while (WAIT_TIMEOUT == WaitForSingleObject( g_RegistryEvent, 0 ))
{
Sleep(1000);
}
return fSuccess;
}
BOOL
Uninit_Token()
{
error_status_t status = 0;
_UserLoggedOff( 0, &status );
return TRUE;
}
BOOL
Init_Rpc()
{
DWORD Status = 0;
//
// This is the proper code to enable access by multiple users to an LRPC endpoint.
// It is the wrong code for a named pipe endpoint; just pass NULL instead.
//
SECURITY_DESCRIPTOR sd;
InitializeSecurityDescriptor(
&sd,
SECURITY_DESCRIPTOR_REVISION
);
if ( FALSE == SetSecurityDescriptorDacl (
&sd,
TRUE, // Dacl present
NULL, // NULL Dacl
FALSE // Not defaulted
) )
{
return FALSE;
}
Status = RpcServerUseProtseqIf( (PUSHORT)L"ncalrpc",
RPC_C_PROTSEQ_MAX_REQS_DEFAULT, _IrSendFiles_v0_2_s_ifspec, &sd);
if (Status && Status != RPC_S_DUPLICATE_ENDPOINT)
{
SetLastError(Status);
return FALSE;
}
Status = RpcServerUseProtseqIf( (PUSHORT)L"ncalrpc", RPC_C_PROTSEQ_MAX_REQS_DEFAULT, _NotifyLogon_ServerIfHandle, &sd);
if (Status && Status != RPC_S_DUPLICATE_ENDPOINT)
{
SetLastError(Status);
return FALSE;
}
Status = RpcServerRegisterIfEx( _IrSendFiles_v0_2_s_ifspec,
0, // no EPV nonsense
0, // no EPV nonsense
RPC_IF_AUTOLISTEN,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
NULL // no security callback
);
if (Status)
{
SetLastError(Status);
return FALSE;
}
Status = RpcServerRegisterIfEx( _NotifyLogon_ServerIfHandle,
0, // no EPV nonsense
0, // no EPV nonsense
RPC_IF_AUTOLISTEN,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
NULL // no security callback
);
if (Status)
{
SetLastError(Status);
return FALSE;
}
Status = RpcBindingFromStringBinding((PUSHORT)L"ncalrpc:", &rpcBinding);
if (Status)
{
SetLastError(Status);
return FALSE;
}
return TRUE;
}
BOOL
Uninit_Rpc()
{
BOOL fSuccess = TRUE;
error_status_t status;
status = RpcServerUnregisterIf( _IrSendFiles_v0_2_s_ifspec,
0, // no EPV nonsense
TRUE // wait for calls to complete
);
if (status)
{
DbgLog1(SEV_ERROR, "uninit_rpc: UnregisterIf SendFiles i/f failed %d", status);
fSuccess = FALSE;
}
status = RpcServerUnregisterIf( _NotifyLogon_ServerIfHandle,
0, // no EPV nonsense
TRUE // wait for calls to complete
);
if (status)
{
DbgLog1(SEV_ERROR, "uninit_rpc: UnregisterIf NotifyLogon i/f failed %d", status);
fSuccess = FALSE;
}
RpcBindingFree( &rpcBinding );
return fSuccess;
}
void
_SendFiles(
handle_t RpcHandle,
COOKIE ClientCookie,
wchar_t DirectoryName[],
wchar_t FileNameList[],
long ListLength,
unsigned long DeviceId,
OBEX_DEVICE_TYPE DeviceType,
error_status_t * pStatus,
FAILURE_LOCATION * pLocation
)
{
FILE_TRANSFER * Transfer;
DbgPrint("IRMON: SendFiles address=%08lx, type=%d\n",DeviceId,DeviceType);
*pStatus = 0;
*pLocation = locStartup;
if ( g_fShutdown )
{
*pStatus = ERROR_SHUTDOWN_IN_PROGRESS;
return;
}
if (DirectoryName && *DirectoryName)
{
*pStatus = ERROR_ACCESS_DENIED;
return;
}
//
// Try NT-compatible connect.
//
Transfer = new FILE_TRANSFER;
if (!Transfer || !Transfer->Xfer_Init( FileNameList, ListLength, dialNt5, DeviceType,TRUE,INVALID_SOCKET ))
{
delete Transfer;
*pStatus = ERROR_NOT_ENOUGH_MEMORY;
return;
}
Transfer->_rpcHandle = RpcHandle;
Transfer->_cookie = ClientCookie;
Transfer->BeginSend( DeviceId, DeviceType, pStatus, pLocation );
if (*pStatus == ERROR_INVALID_DATA && *pLocation == locConnect) {
//
// Try Win98-compatible connect.
//
Transfer = new FILE_TRANSFER;
if (!Transfer || !Transfer->Xfer_Init( FileNameList, ListLength, dialWin95,DeviceType,TRUE,INVALID_SOCKET ))
{
delete Transfer;
*pStatus = ERROR_NOT_ENOUGH_MEMORY;
return;
}
Transfer->_rpcHandle = RpcHandle;
Transfer->_cookie = ClientCookie;
Transfer->BeginSend( DeviceId, DeviceType, pStatus, pLocation );
}
if (*pStatus != ERROR_SUCCESS) {
DWORD dwEventStatus = 0;
EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus);
if (!dwEventStatus) {
EventLog.ReportError(CAT_IRXFER, MC_IRXFER_CONNECT_FAILED, *pStatus);
}
} else {
//
// it worked add it to the list
//
AddTransferToList(GlobalControl.TransferList,Transfer);
}
}
error_status_t
_CancelSend(
/* [in] */ handle_t binding,
/* [in] */ COOKIE cookie
)
{
FILE_TRANSFER * transfer = TransferFromCookie(GlobalControl.TransferList,cookie);
if (!transfer) {
return ERROR_FILE_NOT_FOUND;
}
transfer->Cancel();
// transfer->DecrementRefCount();
return 0;
}
error_status_t
_CancelReceive(
/* [in] */ handle_t binding,
/* [in] */ COOKIE cookie
)
{
FILE_TRANSFER * transfer = TransferFromCookie(GlobalControl.TransferList,cookie);
if (!transfer) {
return ERROR_FILE_NOT_FOUND;
}
transfer->Cancel();
// transfer->DecrementRefCount();
return 0;
}
void * __RPC_USER MIDL_user_allocate(size_t Size)
{
return MemAlloc( Size );
}
void MIDL_user_free( void * Object )
{
MemFree( Object );
}
BOOL
LaunchUi(
wchar_t * cmdline
)
{
PVOID EnvironmentBlock;
STARTUPINFO si;
PROCESS_INFORMATION ProcessInformation;
DWORD UiProcessId;
si.cb = sizeof(STARTUPINFO);
si.lpReserved = NULL;
si.lpTitle = NULL;
si.lpDesktop = L"WinSta0\\Default";
si.dwX = si.dwY = si.dwXSize = si.dwYSize = 0L;
si.dwFlags = 0;;
si.wShowWindow = SW_SHOW;
si.lpReserved2 = NULL;
si.cbReserved2 = 0;
//
// Protect ourselves from login or logout notifications while using the token.
//
{
CLAIM_MUTEX Lock( g_Mutex );
if (0 == g_UserToken)
{
return FALSE;
}
if (!CreateEnvironmentBlock( &EnvironmentBlock,
g_UserToken,
FALSE
))
{
DWORD dwEventStatus = 0;
EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus);
if (!dwEventStatus)
{
EventLog.ReportError(CAT_IRXFER, MC_IRXFER_LAUNCH_FAILED, GetLastError());
}
return FALSE;
}
if (!CreateProcessAsUser( g_UserToken,
NULL, // just use the cmd line parm
cmdline,
NULL, // default process ACL
NULL, // default thread ACL
FALSE, // don't inherit my handles
CREATE_NEW_PROCESS_GROUP |
CREATE_UNICODE_ENVIRONMENT,
EnvironmentBlock,
NULL, // same working directory
&si,
&ProcessInformation
))
{
DestroyEnvironmentBlock( EnvironmentBlock );
DWORD dwEventStatus = 0;
EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus);
if (!dwEventStatus)
{
EventLog.ReportError(CAT_IRXFER, MC_IRXFER_LAUNCH_FAILED, GetLastError());
}
return FALSE;
}
}
UiProcessId = ProcessInformation.dwProcessId;
DestroyEnvironmentBlock( EnvironmentBlock );
WaitForInputIdle( ProcessInformation.hProcess, 10 * 1000 );
CloseHandle(ProcessInformation.hThread);
if (g_hUi)
{
if (WAIT_TIMEOUT == WaitForSingleObject( g_hUi, 0 ))
{
// previous instance still lives; keep current handle
//
CloseHandle( ProcessInformation.hProcess );
}
else
{
// previous instance dead; update
//
CloseHandle( g_hUi );
g_hUi = ProcessInformation.hProcess;
}
}
else
{
// no previous instance
//
g_hUi = ProcessInformation.hProcess;
}
//
// Give the UI the current device list.
//
error_status_t status = 0;
g_Mutex->Enter();
if (g_DeviceList)
{
DeviceInRange( rpcBinding, &g_DeviceList->Devices, &status );
}
DbgLog1(SEV_INFO, "LaunchUi: DeviceInRange returned %d", status);
g_Mutex->Leave();
return TRUE;
}
BOOL GetReceivedFilesFolder( LPWSTR szDir, DWORD dwLen )
{
if (g_ReceivedFilesFolder[0] == 0)
{
ProcessRegistryChange();
}
wcscpy(szDir, g_ReceivedFilesFolder);
return TRUE;
}
BOOL
ShowSendWindow()
{
wchar_t UiCommandLine[ MAX_PATH ];
wcscpy( UiCommandLine, WSZ_SHOW_WINDOW );
return LaunchUi( UiCommandLine );
}
BOOL ShowPropertiesPage()
{
wchar_t UiCommandLine[ MAX_PATH ];
wcscpy( UiCommandLine, WSZ_SHOW_PROPERTIES_PAGE );
return LaunchUi( UiCommandLine );
}
error_status_t
_GetDesktopDirectory(
handle_t Binding,
wchar_t Directory[]
)
{
wcscpy( Directory, g_DesktopFolder );
return 0;
}
extern "C"
{
LRESULT
IrxferHandlePowerMessage(
HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam
);
}
BOOL IrxferQuerySuspend( LPARAM lParam );
void IrxferResume();
LRESULT
IrxferHandlePowerMessage(
HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam
)
{
if (message == WM_QUERYENDSESSION)
{
DbgLog1(SEV_INFO, "POWER: Query logoff %d", lParam);
return IrxferQuerySuspend( 1 );
}
ASSERT( message == WM_POWERBROADCAST );
switch (wParam)
{
case PBT_APMQUERYSUSPEND:
{
DbgLog1(SEV_INFO, "POWER: Query Suspend %d", lParam);
return ( IrxferQuerySuspend( lParam ) ? TRUE : BROADCAST_QUERY_DENY );
}
case PBT_APMQUERYSUSPENDFAILED:
{
DbgLog(SEV_INFO, "POWER: Suspend Failed");
IrxferResume();
break;
}
case PBT_APMRESUMESUSPEND:
{
DbgLog(SEV_INFO, "POWER: Resume Suspend");
IrxferResume();
break;
}
case PBT_APMRESUMECRITICAL:
{
DbgLog(SEV_INFO, "POWER: Resume Critical");
//
// Do nothing. The Winsock layer will send failures
// for reads and writes on any sockets active before
// the shutdown.
//
break;
}
default:
DbgLog2(SEV_INFO, "POWER: w=0x%x l=0x%x", wParam, lParam);
}
return DefWindowProc(hwnd, message, wParam, lParam);
}
BOOL
IrxferQuerySuspend( LPARAM lParam )
{
if (!AreThereActiveTransfers(GlobalControl.TransferList)) {
DbgLog(SEV_INFO, " no transfers active");
return TRUE;
}
if (lParam & 1)
{
//
// The app is allowed to prompt the user if necessary.
//
boolean answer;
DWORD status = ShutdownRequested( rpcBinding, &answer );
DbgLog2(SEV_INFO, " status %d answer %d", status, answer);
if (status || answer == TRUE)
{
g_fShutdown = 1;
return TRUE;
}
else
{
return FALSE;
}
}
else
{
DbgLog(SEV_INFO, " not allowed to prompt");
g_fShutdown = 1;
return TRUE;
}
}
void
IrxferResume()
{
g_fShutdown = FALSE;
// update device list
}
BOOL IsWorkstationLocked()
{
return FALSE;
}
/*****************************************************************************
*
* GetUserToken
*
* Return the token for the user currently logged onto the WinStation
*
* ENTRY:
* LogonId (input)
* LogonId of WinStation
*
* pUserToken (output)
* Variable to place the returned token handle if successfull.
*
* EXIT:
* STATUS_SUCCESS - no error
*
****************************************************************************/
BOOL
GetUserToken(
ULONG LogonId,
PHANDLE pUserToken
)
{
BOOL Result;
ULONG ReturnLength;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjA;
HANDLE ImpersonationToken;
WINSTATIONUSERTOKEN Info;
SECURITY_QUALITY_OF_SERVICE SecurityQualityOfService;
//
// This gets the token of the user logged onto the WinStation
// if we are an admin caller.
//
// This is so that CSRSS can dup the handle to our process
Info.ProcessId = (HANDLE)LongToHandle(GetCurrentProcessId());
Info.ThreadId = (HANDLE)LongToHandle(GetCurrentThreadId());
Result = (*pWinstationQueryInformation)(
SERVERNAME_CURRENT,
LogonId,
WinStationUserToken,
&Info,
sizeof(Info),
&ReturnLength
);
if( !Result )
{
return( FALSE );
}
//
// The token returned is a duplicate of a primary token.
//
*pUserToken = Info.UserToken;
return( TRUE );
}
Reference in a new issue Copy permalink