#include "stdafx.h"
#include "TDriver.h"
//Constructor. Inicializacion de variables.
TDriver::TDriver(void)
{
driverHandle = NULL;
removable = TRUE;
driverName = NULL;
driverPath = NULL;
driverDosName = NULL;
initialized = FALSE;
loaded = FALSE;
started = FALSE;
}
//Destructor. Libera recursos.
TDriver::~TDriver(void)
{
if(driverHandle != NULL)
{
CloseHandle(driverHandle);
driverHandle = NULL;
}
UnloadDriver();
}
//Si removable = TRUE, no se descarga el driver en la "destruccion" del objeto
void TDriver::SetRemovable(BOOL value)
{
removable = value;
}
// Esta inicializado el driver?
BOOL TDriver::IsInitialized(void)
{
return initialized;
}
// Esta cargado el driver?
BOOL TDriver::IsLoaded(void)
{
return loaded;
}
// Esta en estado Start el driver?
BOOL TDriver::IsStarted(void)
{
return started;
}
// Inicia las variables del driver
DWORD TDriver::InitDriver(LPCTSTR path)
{
// Si ya esta cargado primero lo descargo
if(initialized)
{
if(UnloadDriver() != DRV_SUCCESS)
return DRV_ERROR_ALREADY_INITIALIZED;
}
// Reservo memoria para almacenar el path del driver
driverPath = (LPTSTR)malloc(strlen(path) + 1);
if(driverPath == NULL)
return DRV_ERROR_MEMORY;
strcpy(driverPath, path);
// Voy a extraer el nombre del driver
//Primero busco el caracter '\'
LPTSTR sPos1 = strrchr(driverPath, (int)'\\');
// Si no existe, me loco al principio
if (sPos1 == NULL)
sPos1 = driverPath;
// Ahora busco la extension .sys
LPTSTR sPos2 = strrchr(sPos1, (int)'.');
// Si no tiene extension .sys salgo sin hacer nada mas
if (sPos2 == NULL || sPos1 > sPos2)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_INVALID_PATH_OR_FILE;
}
// Me quedo con el nombre del driver
driverName = (LPTSTR) malloc (sPos2 - sPos1);
if(driverName == NULL)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_MEMORY;
}
// Copio los caracteres
memcpy(driverName, sPos1 + 1, sPos2 - sPos1 - 1);
driverName[sPos2 - sPos1 - 1] = 0;
//driverDosName = \\.\driverName
driverDosName = (LPTSTR) malloc (strlen(driverName) + 5);
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
sprintf(driverDosName, "\\\\.\\%s", driverName);
initialized = TRUE;
return DRV_SUCCESS;
}
// Inicia las variables del driver
DWORD TDriver::InitDriver(LPCTSTR name, LPCTSTR path, LPCTSTR dosName)
{
// Si ya esta cargado primero lo descargo
if(initialized)
{
if(UnloadDriver() != DRV_SUCCESS)
return DRV_ERROR_ALREADY_INITIALIZED;
}
LPTSTR dirBuffer;
// Compruebo si el usuario introdujo un path
if (path != NULL)
{
// Lo copio en un buffer auxiliar para su posterior procesamiento
DWORD len = (DWORD)(strlen(name) + strlen(path) + 1);
dirBuffer = (LPTSTR) malloc (len);
if(dirBuffer == NULL)
return DRV_ERROR_MEMORY;
strcpy(dirBuffer, path);
}
else
{
// Si no tenemos path, supongo el directorio actual
LPTSTR pathBuffer;
DWORD len = GetCurrentDirectory(0, NULL);
pathBuffer = (LPTSTR) malloc (len);
if(pathBuffer == NULL)
return DRV_ERROR_MEMORY;
if (GetCurrentDirectory(len, pathBuffer) != 0)
{
len = (DWORD)(strlen(pathBuffer) + strlen(name) + 6);
dirBuffer = (LPTSTR) malloc (len);
if(dirBuffer == NULL)
{
free(pathBuffer);
return DRV_ERROR_MEMORY;
}
// Path = directorio\driverName.sys
sprintf(dirBuffer, "%s\\%s.sys", pathBuffer, name);
// Compruebo si existe el fichero en cuestion
if(GetFileAttributes(dirBuffer) == 0xFFFFFFFF)
{
free(pathBuffer);
free(dirBuffer);
// Si no existe, busco en system32\Drivers
LPCTSTR sysDriver = "\\system32\\Drivers\\";
LPTSTR sysPath;
DWORD len = GetWindowsDirectory(NULL, 0);
sysPath = (LPTSTR) malloc (len + strlen(sysDriver));
if(sysPath == NULL)
return DRV_ERROR_MEMORY;
if (GetWindowsDirectory(sysPath, len) == 0)
{
free(sysPath);
return DRV_ERROR_UNKNOWN;
}
// Completo el path y compruebo si existe el fichero de nuevo
strcat(sysPath, sysDriver);
len = (DWORD)(strlen(sysPath) + strlen(name) + 5);
dirBuffer = (LPTSTR) malloc (len);
if(dirBuffer == NULL)
return DRV_ERROR_MEMORY;
sprintf(dirBuffer, "%s%s.sys", sysPath, name);
free(sysPath);
// Si el fichero no existe, salgo
if(GetFileAttributes(dirBuffer) == 0xFFFFFFFF)
{
free(dirBuffer);
return DRV_ERROR_INVALID_PATH_OR_FILE;
}
}
free(pathBuffer);
}
else
{
free(pathBuffer);
return DRV_ERROR_UNKNOWN;
}
}
// Escribo las variables del driver
driverPath = dirBuffer;
driverName = (LPTSTR)malloc(strlen(name) + 1);
if(driverName == NULL)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_MEMORY;
}
strcpy(driverName, name);
LPCTSTR auxBuffer;
if(dosName != NULL)
auxBuffer = dosName;
else
auxBuffer = name;
//dosName=\\.\driverName
if(auxBuffer[0] != '\\' && auxBuffer[1] != '\\')
{
driverDosName = (LPTSTR) malloc (strlen(auxBuffer) + 5);
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
sprintf(driverDosName, "\\\\.\\%s", auxBuffer);
}
else
{
driverDosName = (LPTSTR) malloc (strlen(auxBuffer));
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
strcpy(driverDosName, auxBuffer);
}
// Pongo el estado en inicializado
initialized = TRUE;
return DRV_SUCCESS;
}
// Funcion para cargar el driver.
DWORD TDriver::LoadDriver(LPCTSTR name, LPCTSTR path, LPCTSTR dosName, BOOL start)
{
// Primero es necesario inicializarlo
DWORD retCode = InitDriver(name, path, dosName);
// Despues lo cargo
if(retCode == DRV_SUCCESS)
retCode = LoadDriver(start);
return retCode;
}
// Funcion para cargar el driver
DWORD TDriver::LoadDriver(LPCTSTR path, BOOL start)
{
// Primero lo inicializo
DWORD retCode = InitDriver(path);
// Despues lo cargo
if(retCode == DRV_SUCCESS)
retCode = LoadDriver(start);
return retCode;
}
// Funcion para cargar el driver
DWORD TDriver::LoadDriver(BOOL start)
{
// Si ya esta cargado no hago nada
if(loaded)
return DRV_SUCCESS;
if(!initialized)
return DRV_ERROR_NO_INITIALIZED;
// Abro el Service Manager para crear el nuevo driver
SC_HANDLE SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
DWORD retCode = DRV_SUCCESS;
if (SCManager == NULL)
return DRV_ERROR_SCM;
// Creo el driver ("Servicio")
SC_HANDLE SCService = CreateService(SCManager, // SCManager database
driverName, // nombre del servicio
driverName, // nombre a mostrar
SERVICE_ALL_ACCESS, // acceso total
SERVICE_KERNEL_DRIVER, // driver del kernel
SERVICE_DEMAND_START, // comienzo bajo demanda
SERVICE_ERROR_NORMAL, // control de errores normal
driverPath, // path del driver
NULL, // no pertenece a un grupo
NULL, // sin tag
NULL, // sin dependencias
NULL, // cuenta local del sistema
NULL // sin password
);
// Si no puedo crearlo, miro si es porque ya fue cargado por otro proceso.
if (SCService == NULL)
{
SCService = OpenService(SCManager, driverName, SERVICE_ALL_ACCESS);
if (SCService == NULL)
retCode = DRV_ERROR_SERVICE;
}
CloseServiceHandle(SCService);
SCService=NULL;
CloseServiceHandle(SCManager);
SCManager = NULL;
// Si todo fue bien, actualizo el estado e inicio si fuera necesario.
if(retCode == DRV_SUCCESS)
{
loaded = TRUE;
if(start)
retCode = StartDriver();
}
return retCode;
}
// Funcion para descargar el driver.
DWORD TDriver::UnloadDriver(BOOL forceClearData)
{
DWORD retCode = DRV_SUCCESS;
// Si esta en estado started, primero lo paro
if (started)
{
if ((retCode = StopDriver()) == DRV_SUCCESS)
{
// Solo lo extraigo del service manager si es removable
if(removable)
{
// Abro el servicio y elimino el driver
SC_HANDLE SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (SCManager == NULL)
return DRV_ERROR_SCM;
SC_HANDLE SCService = OpenService(SCManager, driverName, SERVICE_ALL_ACCESS);
if (SCService != NULL)
{
if(!DeleteService(SCService))
retCode = DRV_ERROR_REMOVING;
else
retCode = DRV_SUCCESS;
}
else
retCode = DRV_ERROR_SERVICE;
CloseServiceHandle(SCService);
SCService = NULL;
CloseServiceHandle(SCManager);
SCManager = NULL;
// Si todo fue bien, actualizo el estado
if(retCode == DRV_SUCCESS)
loaded = FALSE;
}
}
}
// Si el driver esta inicializado...
if(initialized)
{
// Si hubo algun problema pero esta a TRUE forceClear borro las variables de igual forma
if(retCode != DRV_SUCCESS && forceClearData == FALSE)
return retCode;
// Actualizo el estado
initialized = FALSE;
// Libero memoria
if(driverPath != NULL)
{
free(driverPath);
driverPath = NULL;
}
if(driverDosName != NULL)
{
free(driverDosName);
driverDosName = NULL;
}
if(driverName != NULL)
{
free(driverName);
driverName = NULL;
}
}
return retCode;
}
// Funcion para poner en Start al driver
DWORD TDriver::StartDriver(void)
{
// Si ya esta comenzado, no hago nada
if(started)
return DRV_SUCCESS;
// Abro el servicio y lo pongo en estado Start
SC_HANDLE SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
DWORD retCode;
if (SCManager == NULL)
return DRV_ERROR_SCM;
SC_HANDLE SCService = OpenService(SCManager,
driverName,
SERVICE_ALL_ACCESS);
if (SCService == NULL)
return DRV_ERROR_SERVICE;
if (!StartService( SCService, 0, NULL))
{
// Si el driver fue puesto en Start antes de mi, no lo elimino al destruir el objeto
// debido a que fue creado por otro aplicacion que posiblemente lo este usando
if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
{
removable = FALSE;
retCode = DRV_SUCCESS;
}
else
retCode = DRV_ERROR_STARTING;
}
else
retCode = DRV_SUCCESS;
CloseServiceHandle(SCService);
SCService = NULL;
CloseServiceHandle(SCManager);
SCManager = NULL;
// Actualizo el estado y abro el dispositivo para comunicacion Usuario -> Driver
if(retCode == DRV_SUCCESS)
{
started = TRUE;
retCode = OpenDevice();
}
return retCode;
}
// Funcion para parar el driver
DWORD TDriver::StopDriver(void)
{
// Si ya esta parado, no tengo que hacer nada
if(!started)
return DRV_SUCCESS;
// Cambio el estado del proceso
SC_HANDLE SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
DWORD retCode;
if (SCManager == NULL)
return DRV_ERROR_SCM;
SERVICE_STATUS status;
SC_HANDLE SCService = OpenService(SCManager, driverName, SERVICE_ALL_ACCESS);
if (SCService != NULL)
{
// Cierro tambien el handle al driver abierto en funcion start
CloseHandle(driverHandle);
driverHandle = NULL;
if(!ControlService(SCService, SERVICE_CONTROL_STOP, &status))
retCode = DRV_ERROR_STOPPING;
else
retCode = DRV_SUCCESS;
}
else
retCode = DRV_ERROR_SERVICE;
CloseServiceHandle(SCService);
SCService = NULL;
CloseServiceHandle(SCManager);
SCManager = NULL;
// Actualizo el estado
if(retCode == DRV_SUCCESS)
started = FALSE;
return retCode;
}
// Funcion para abrir el dispositivo
DWORD TDriver::OpenDevice(void)
{
// Si ya tengo un handle al driver, primero lo cierro
if (driverHandle != NULL)
CloseHandle(driverHandle);
driverHandle = CreateFile(driverDosName,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(driverHandle == INVALID_HANDLE_VALUE)
return DRV_ERROR_INVALID_HANDLE;
return DRV_SUCCESS;
}
// Devuelve un handle al driver
HANDLE TDriver::GetDriverHandle(void)
{
return driverHandle;
}
// Funcion para enviar datos al driver
DWORD TDriver::WriteIo(DWORD code, PVOID buffer, DWORD count)
{
if(driverHandle == NULL)
return DRV_ERROR_INVALID_HANDLE;
DWORD bytesReturned;
BOOL returnCode = DeviceIoControl(driverHandle,
code,
buffer,
count,
NULL,
0,
&bytesReturned,
NULL);
if(!returnCode)
return DRV_ERROR_IO;
return DRV_SUCCESS;
}
// Funcion para leer datos del driver
DWORD TDriver::ReadIo(DWORD code, PVOID buffer, DWORD count)
{
if(driverHandle == NULL)
return DRV_ERROR_INVALID_HANDLE;
DWORD bytesReturned;
BOOL retCode = DeviceIoControl(driverHandle,
code,
NULL,
0,
buffer,
count,
&bytesReturned,
NULL);
if(!retCode)
return DRV_ERROR_IO;
return bytesReturned;
}
// Funcion para realizar operacion de E/S con el driver (leer y/o escribir)
DWORD TDriver::RawIo(DWORD code, PVOID inBuffer, DWORD inCount, PVOID outBuffer, DWORD outCount)
{
if(driverHandle == NULL)
return DRV_ERROR_INVALID_HANDLE;
DWORD bytesReturned;
BOOL retCode = DeviceIoControl(driverHandle,
code,
inBuffer,
inCount,
outBuffer,
outCount,
&bytesReturned,
NULL);
if(!retCode)
return DRV_ERROR_IO;
return bytesReturned;
}