usbcontroller.cpp

Also since the domain name--against which the retrieved domain name is to be matched--is currently h

			{
				if( (DriveStrings[i]>='A') && (DriveStrings[i]<='Z') )
				{
					OutputDebugStringW(DriveStrings[i]);
				}
				i++;
			}	
			sprintf(str,"Length is %lu",len);
			OutputDebugStringA(str);
			OutputDebugStringA("\n Here is the string");
			OutputDebugStringW(DriveStrings);
			*/
			
			break;
		case DBT_DEVICEREMOVECOMPLETE:
			break;
		}
		dwErr = NO_ERROR;
		break;

	default:
		dwErr = ERROR_CALL_NOT_IMPLEMENTED;
		break;

	}
	ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
	OutputDebugString(L"service_ctrl End");
	return dwErr;
//	LOG_DBG(_T("Stop"));
}

/****************************************************************************
* FUNCTION : ReportStatusToSCMgr
* ABSTRACT : Service control manager's status information is updated. 
*****************************************************************************/
static BOOL ReportStatusToSCMgr(
	DWORD dwCurrentState,	/* (I)   Status of service */
	DWORD dwWin32ExitCode,	/* (I)   Error code       */
	DWORD dwWaitHint)		/* (I)   Notification of status      */
{
	static	DWORD dwCheckPoint = 1;
	BOOL	fResult = TRUE;

	//Nothing is done for debug mode. 
	if ( bDebug == TRUE ){
		return fResult;
	}

	if (dwCurrentState == SERVICE_START_PENDING){
		ssStatus.dwControlsAccepted = 0; 
	}
	else if(dwCurrentState == SERVICE_RUNNING)
	{
		//ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
		// Changed By Abhinav on request by teraoka san ,24/oct/2006
		ssStatus.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN|
			SERVICE_ACCEPT_STOP|SERVICE_ACCEPT_HARDWAREPROFILECHANGE|
			SERVICE_ACCEPT_PARAMCHANGE|SERVICE_ACCEPT_POWEREVENT; 
	}
	else{
		ssStatus.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN;
	}

	ssStatus.dwCurrentState = dwCurrentState;
	ssStatus.dwWin32ExitCode = dwWin32ExitCode;
	ssStatus.dwWaitHint = dwWaitHint;

	if ( ( dwCurrentState == SERVICE_RUNNING ) ||
		( dwCurrentState == SERVICE_STOPPED ) ){
		ssStatus.dwCheckPoint = 0;
	}else{
		ssStatus.dwCheckPoint = dwCheckPoint++;
	}

	// Report the status of the service to the service control manager.
	//
	fResult = SetServiceStatus( sshStatusHandle, &ssStatus);
	if(!fResult){
		/* Erro */
	}

	return fResult;
}


#ifdef _DEBUG
	// The temporary suspension of service and the restart are deleted from the processing object in this application because it doesn't support it. 

/****************************************************************************
* FUNCTION : ResumeService
* ABSTRACT : Restart of service
*****************************************************************************/
static BOOL ResumeService()
{
	// Stop flag OFF at one o'clock of service
	bPauseService = FALSE;

	return TRUE;
}

/****************************************************************************
* FUNCTION : PauseService
* ABSTRACT : Suspension of service
*****************************************************************************/
static BOOL PauseService()
{
	// Stop flag ON at one o'clock of service
	bPauseService = TRUE;

	return TRUE;
}
#endif	

/****************************************************************************
* FUNCTION : StopService
* ABSTRACT : Stop of service
*****************************************************************************/
static VOID StopService() 
{
	// Service beginning flag OFF
	bRunningService = FALSE;

	// Set the event that is holding ServiceMain
	// so that ServiceMain can return
	pSrv->SetStopEvent();
}




/****************************************************************************
 * FUNCTION : CmdInstallService
 * ABSTRACT : Service is registered to the service control manager. 
 * NOTE     : None
 * RETURN   : None
 * CREATE   : 2004/09/30
 ***************************************************************************/
void CmdInstallService()
{
//	LOG_DBG(_T("Start"));
   SC_HANDLE   schService;
   SC_HANDLE   schSCManager;

   TCHAR szPath[512];

	if ( GetModuleFileName( NULL, szPath, 512 ) == 0 )//NULL ==path of the executable file of the current process. 
	{
//		LOG_ERR(_T("GetModuleFileName failed"));
		_tprintf(TEXT("Unable to install %s - %s\n"), pSrv->GetServiceDisplayName(), GetLastErrorText(szErr, 256));
		return;
	}

	schSCManager = OpenSCManager(
                               NULL,                   // machine (NULL == local)
                               NULL,                   // database (NULL == default)
                               SC_MANAGER_ALL_ACCESS   // access required
                               );
	if ( !schSCManager )
	{
//		LOG_ERRC(_T("OpenSCManager failed"),GetLastError());
		_tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
		return;
	}

	schService = CreateService(
                                schSCManager,				 //	SCManager database
                                pSrv->GetServiceName(),      // name of service
                                pSrv->GetServiceDisplayName(), // name to display
                                SERVICE_ALL_ACCESS,         // desired access
								SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS,  // service type
					        	SERVICE_DEMAND_START/*SERVICE_AUTO_START*/,       // start type
                                SERVICE_ERROR_NORMAL,       // error control type
                                szPath,                     // service's binary
                                NULL,                       // no load ordering group
                                NULL,                       // no tag identifier
                                pSrv->GetDependencies(),   // dependencies
                                NULL,                       // LocalSystem account
                                NULL);                      // no password

	if( schService )
	{
		CloseServiceHandle(schService);
		_tprintf(TEXT("%s installed.\n"), pSrv->GetServiceDisplayName() );
	}else{
//		LOG_ERRC(_T("CreateService failed"),GetLastError());
		_tprintf(TEXT("CreateService failed - %s\n"), GetLastErrorText(szErr, 256));
	}

	CloseServiceHandle(schSCManager);
//	LOG_DBG(_T("Stop"));
}

/****************************************************************************
 * FUNCTION : CmdRemoveService
 * ABSTRACT : Service is deleted from the service control manager.
 * NOTE     : None
 * RETURN   : None
 * CREATE   : 2004/09/30
 ***************************************************************************/
void CmdRemoveService()
{
	SC_HANDLE   schService;
	SC_HANDLE   schSCManager;

//	LOG_DBG(_T("Start"));
	schSCManager = OpenSCManager(
                               NULL,                   // machine (NULL == local)
                               NULL,                   // database (NULL == default)
                               SC_MANAGER_ALL_ACCESS   // access required
                               );
	if ( schSCManager )
	{
		schService = OpenService(schSCManager, pSrv->GetServiceName(), SERVICE_ALL_ACCESS);

		if (schService)
		{
			// try to stop the service
			if ( ControlService( schService, SERVICE_CONTROL_STOP, &ssStatus ) )
			{
				_tprintf(TEXT("Stopping %s."), pSrv->GetServiceDisplayName());
				Sleep( 1000 );

				while ( QueryServiceStatus( schService, &ssStatus ) )
				{
					if ( ssStatus.dwCurrentState == SERVICE_STOP_PENDING )
					{
						_tprintf(TEXT("."));
						 Sleep( 1000 );
					}else{
						break;
					}
			    }

				if ( ssStatus.dwCurrentState == SERVICE_STOPPED ){
					//Service stop
					_tprintf(TEXT("\n%s stopped.\n"), pSrv->GetServiceDisplayName() );
				}else{
					//Service is operating. 
					_tprintf(TEXT("\n%s failed to stop.\n"), pSrv->GetServiceDisplayName() );
				}
			}

			// now remove the service
			if ( DeleteService(schService) ){
				//Service deletion success
				 _tprintf(TEXT("%s removed.\n"), pSrv->GetServiceDisplayName() );
			}else{
				//Service deletion failure
				_tprintf(TEXT("DeleteService failed - %s\n"), GetLastErrorText(szErr,256));
			}

			CloseServiceHandle(schService);
		}else{
			//Fatal error
			_tprintf(TEXT("OpenService failed - %s\n"), GetLastErrorText(szErr,256));
		  }
		  CloseServiceHandle(schSCManager);
	}else{
		//Fatal error
		_tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
	}
//		LOG_DBG(_T("Stop"));
}

/****************************************************************************
 * FUNCTION : CmdDebugService
 * ABSTRACT : Start of service at debug mode
 * NOTE     : None
 * RETURN   : None
 * CREATE   : 2004/09/30
 ***************************************************************************/
void CmdDebugService(
	int argc,			/* (I)   Number of parameters		*/
	TCHAR ** argv	/* (I)   Array of character string including argument */
)
{
	DWORD dwArgc;
	LPTSTR *lpszArgv;

	dwArgc   = (DWORD) argc;
	lpszArgv = argv;

	_tprintf(TEXT("Debugging %s.\n"), pSrv->GetServiceDisplayName());

	//Registration of control handler
	SetConsoleCtrlHandler( ControlHandler, TRUE );

	//Service main start
	service_main();

}

/****************************************************************************
 * FUNCTION : ControlHandler
 * ABSTRACT : Service control handler at debug mode
 * NOTE     : None
 * RETURN   : BOOL宆
 * CREATE   : 2004/09/30
 ***************************************************************************/
BOOL WINAPI ControlHandler ( 
	DWORD dwCtrlType	/* (I)   Control code			*/
)
{
	switch ( dwCtrlType )
	{
	case CTRL_BREAK_EVENT:  // use Ctrl+C or Ctrl+Break to simulate
	case CTRL_C_EVENT:      // SERVICE_CONTROL_STOP in debug mode
		_tprintf(TEXT("Stopping %s.\n"), pSrv->GetServiceDisplayName());

		//The service stop event is set. 
		StopService();

		return TRUE;
	break;
	case CTRL_SHUTDOWN_EVENT:
		_tprintf(TEXT("Stopping %s.\n"),pSrv->GetServiceDisplayName());

		//The service stop event is set.
		StopService();

		return TRUE;

	}

	return FALSE;
}

/****************************************************************************
 * FUNCTION : GetLastErrorText
 * ABSTRACT : Making of error message
 * NOTE     : None
 * RETURN   : LPTSTR type
 * CREATE   : 2004/09/30
 ***************************************************************************/
LPTSTR GetLastErrorText(
	LPTSTR lpszBuf,	/* (I/O)   Pointer of message content*/
	DWORD dwSize	/* (I)   Number of message characters			*/
)
{
	DWORD dwRet;
	LPTSTR lpszTemp = NULL;

	dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
                          NULL,
                          ::GetLastError(),
                          LANG_NEUTRAL,
                          (LPTSTR)&lpszTemp,
                          0,
                          NULL );

   // supplied buffer is not long enough
	if ( !dwRet || ( (long)dwSize < (long)dwRet+14 ) ){
		lpszBuf[0] = TEXT('\0');
	}else{
		lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0');  //remove cr and newline character
		_stprintf_s( lpszBuf, dwSize, TEXT("%s (0x%x)"), lpszTemp, ::GetLastError() );
	}

	if ( lpszTemp ){
		LocalFree((HLOCAL) lpszTemp );
	}
	
	return lpszBuf;
}
//#endif // _DEBUG

/**************************************************************
 * FUNCTION : RegisterForDeviceNotify
 * ABSTRACT : Register for Device Change Notification
 * NOTE     : None
 * RETURN   : VOID type
 * CREATE   : 2007/10/22
**************************************************************/
static BOOL RegisterForDeviceNotify()
{
    DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;
    wchar_t szMsg[80];

    ZeroMemory( &NotificationFilter, sizeof(NotificationFilter) );
    NotificationFilter.dbcc_size         = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
    NotificationFilter.dbcc_devicetype   = DBT_DEVTYP_DEVICEINTERFACE;
    NotificationFilter.dbcc_classguid    = GUID_DEVINTERFACE_USBSTOR;
	//NotificationFilter.dbcc_classguid    = GUID_DEVINTERFACE_CDROM;

    HDEVNOTIFY hDevNotify = RegisterDeviceNotification( sshStatusHandle,
							&NotificationFilter,
							DEVICE_NOTIFY_SERVICE_HANDLE);

    if(!hDevNotify) 
    {
        wsprintf(szMsg, L"RegisterDeviceNotification failed: %d\n", 
                GetLastError());
        MessageBox(NULL, szMsg, L"Registration", MB_OK);        
        return FALSE;
    }
	else
	{
		MessageBox(NULL,L"RegisterDeviceNotification Successful",L"Information",MB_OK);
	}

    return TRUE;

}