unit Dku2;

interface

uses Windows;

const
   aDevGUID:array[0..3] of TGUID = (
            '{4F919104-4ADF-11D5-882D-00B0D02FE381}',
            '{4F919102-4ADF-11D5-882D-00B0D02FE381}',
            '{4F919100-4ADF-11D5-882D-00B0D02FE381}',
            '{86E0D1E0-8089-11D0-9CE4-08003E301F73}'
   );

type
  HDEVINFO = Pointer;

function GetDKU2List:string;

implementation

uses
  SetupApi, SysUtils;

function GetDKU2List:string;
 var iDevClass,iDevice:integer;
     DevInfo:HDEVINFO;
     DevInfoData:TSpDevInfoData;
     DeviceInterfaceData:TSPDeviceInterfaceData;
     cbSize:DWORD;
     DevIFCDetailData:PSPDeviceInterfaceDetailData;
     InstanceID:PChar;
begin

  // начинаем просмотр всех возможных классов устройств в поисках
  // подходящего дивайса
  For iDevClass:=Low(aDevGUID) to High(aDevGUID) do begin
    DevInfo:=SetupDiGetClassDevs(@(aDevGUID[iDevClass]), nil, 0, DIGCF_PRESENT or DIGCF_DEVICEINTERFACE);
    If DevInfo=Pointer(INVALID_HANDLE_VALUE) then Exit
    else begin
      // дивайсы в этом классе есть
      DevInfoData.cbSize:=sizeof(SP_DEVINFO_DATA);
      // пробежимся по всем дивайсам данного класса начиная с нулевого,
      // пока функция SetupDiEnumDeviceInfo не вернёт FALSE
      iDevice:=0;
      While SetupDiEnumDeviceInfo(DevInfo,iDevice,DevInfoData) do begin
        // дивайс с таким номером найден
        // смотрим какие интерфейсы поддерживает данный дивайс
        DeviceInterfaceData.cbSize:=sizeof(SP_DEVICE_INTERFACE_DATA);
        If not SetupDiEnumDeviceInterfaces(DevInfo, nil, aDevGUID[iDevClass], iDevice, DeviceInterfaceData) then begin
          //*****ошибка
        end
        else begin
          SetupDiGetDeviceInterfaceDetail(DevInfo, @DeviceInterfaceData, nil, 0, cbSize, nil);
          GetLastError();
          DevIFCDetailData:=AllocMem(cbSize);
          DevIFCDetailData.cbSize:=sizeof(TSPDeviceInterfaceDetailData);

          If SetupDiGetDeviceInterfaceDetail(DevInfo, @DeviceInterfaceData, DevIFCDetailData, cbSize, cbSize, nil) then begin
            SetupDiGetDeviceInstanceId(DevInfo, @DevInfoData, nil, 0, @cbSize);
            GetLastError();
            InstanceID:=AllocMem(cbSize);
            SetupDiGetDeviceInstanceId(DevInfo, @DevInfoData, InstanceID, cbSize, nil);
            Dispose(InstanceID);

            If (iDevClass=1) or ((iDevClass=333) (*and (DevIFCDetailData.DevicePath[4]=Ord('u'))*)) then begin
              Result:=Result+';'+StrPas(DevIFCDetailData.DevicePath);
            end;
          end;
          Dispose(DevIFCDetailData);
        end;

        Inc(iDevice);
      end;
    end;
  end;
end;

end.

#include <ctype.h>
#include <io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#pragma pack(push,1)

#include <windows.h>
#include <setupapi.h>

#pragma pack(pop)

// тут мы будем хранить информацию о найденных устройствах
//
struct CDevice
{
    CDevice *pNext;
    bool     fNeedOpen;
    HANDLE   h;
    TCHAR    path[ANYSIZE_ARRAY];
};

// ПОРЯДОК ЭТИХ КЛАССОВ В МАССИВЕ ВАЖЕН!!!

static GUID aDevGUID[] = {
    {
        0x4D36E978,
        0xE325,
        0x11CE,
        {0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18}
    },
    {
        0x4F919104,
        0x4ADF,
        0x11D5,
        {0x88, 0x2D, 0x00, 0xB0, 0xD0, 0x2F, 0xE3, 0x81}
    },
    {
        0x4F919102,
        0x4ADF,
        0x11D5,
        {0x88, 0x2D, 0x00, 0xB0, 0xD0, 0x2F, 0xE3, 0x81}
    },
    {
        0x4F919100,
        0x4ADF,
        0x11D5,
        {0x88, 0x2D, 0x00, 0xB0, 0xD0, 0x2F, 0xE3, 0x81}
    },
    {
        0x86E0D1E0,
        0x8089,
        0x11D0,
        {0x9C, 0xE4, 0x08, 0x00, 0x3E, 0x30, 0x1F, 0x73}
    }
};

static char szLogFName[] = "dku-2.log";
static bool fNeedLog     = false;

static void logData(const char *format, ...)
{
    if (fNeedLog)
    {
        FILE *pFLog = fopen(szLogFName, "a+t");

        if (pFLog)
        {
            time_t timer = time(NULL);
            struct tm *stm = localtime(&timer);
            char *p = asctime(stm);
            p[strlen(p) - 1] = '\0';

            fprintf(pFLog, "%s: ", p);

            va_list args;
            va_start(args, format);
            vfprintf(pFLog, format, args);
            va_end(args);

            fclose(pFLog);
        }
    }
}

static void logStart()
{
    if (fNeedLog)
    {
        if (!access(szLogFName, 6))
        {
            FILE *pFLog = fopen(szLogFName, "a+t");

            if (pFLog)
            {
                fprintf(pFLog, "\n");
                fclose(pFLog);
            }
        }
    }
}

static void GUID2str(const GUID& guid, char *str)
{
    sprintf(str, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
            guid.Data1, guid.Data2, guid.Data3,
            guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
            guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
}

static void scanForDevices(CDevice **paDevices)
{
    CDevice  *aDevices = NULL;
    bool      fError = false;
    HDEVINFO  hDevInfo;
    char      szGUID[39];

    // начинаем просмотр всех возможных классов устройств в поисках
    // подходящего дивайса
    //
    for (int iDevClass = 0;
         iDevClass < sizeof(aDevGUID) / sizeof (aDevGUID[0]);
         iDevClass++)
    {
        GUID2str(aDevGUID[iDevClass], szGUID);

        hDevInfo = SetupDiGetClassDevs(&aDevGUID[iDevClass],
                                       0,
                                       0,
                                       DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);

        // попробуем посмотреть есть ли у нас какие-нибудь дивайсы
        // в этом классе
        //
        if (hDevInfo == INVALID_HANDLE_VALUE)
        {
            // нифига, литовский национальный праздник ``Обломайтис''
            // вываливаемся сразу же, все четыре класса должны быть
            //
            logData("hmm... couldn't find device class %s\n", szGUID);
            fError = true;
            break;
        }
        else
        {
            // дивайсы в этом классе есть
            //
            logData("found device class %s\n", szGUID);

            SP_DEVINFO_DATA DevInfoData;

            DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

            // пробежимся по всем дивайсам данного класса начиная с нулевого,
            // пока функция SetupDiEnumDeviceInfo не вернёт FALSE
            //
            bool fFound = false;

            for (int iDevice = 0;
                 SetupDiEnumDeviceInfo(hDevInfo, iDevice, &DevInfoData);
                 iDevice++)
            {
                fFound = true;
                // дивайс с таким номером найден
                //
                logData("  device number: #%d\n", iDevice);

                // смотрим какие интерфейсы поддерживает данный дивайс
                //
                SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;

                DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

                if (!SetupDiEnumDeviceInterfaces(hDevInfo,
                                                 NULL,
                                                 &aDevGUID[iDevClass],
                                                 iDevice,
                                                 &DeviceInterfaceData))
                {
                    // какая-то ошибка в потрохах Weendoze, такого быть
                    // не должно по хорошему
                    //
                    logData("failed to get SP_DEVICE_INTERFACE_DATA for "
                            "device #%d: %08X\n", iDevice, GetLastError());
                }
                else
                {
                    // узнаем про этот интерфейс поподробнее
                    //

                    // тут мы получим необходимый размер буфера
                    //
                    ULONG cbSize;

                    // а это сам буфер
                    //
                    PSP_DEVICE_INTERFACE_DETAIL_DATA pDevIFCDetailData = NULL;

                    // во время первого вызова SetupDiGetDeviceInterfaceDetail
                    // передаём NULL в качестве указателя на буфер,
                    // 0 в качестве размера буфера и в результате Windows
                    // должен вернуть нам требуемый размер буфера в cbSize
                    //
                    SetupDiGetDeviceInterfaceDetail(hDevInfo,
                                                    &DeviceInterfaceData,
                                                    NULL,
                                                    0,
                                                    &cbSize,
                                                    NULL);

                    // ДОЛЖНА БЫТЬ ОШИБКА ПРО МАЛЫЙ РАЗМЕР БУФЕРА !!!
                    //
                    int ec = GetLastError();

                    if (ec != ERROR_INSUFFICIENT_BUFFER)
                    {
                        // не повезло, ошибка какая-то другая, вываливаемся
                        //
                        logData("error getting interface detail: %08X, "
                                "skip going any further\n", ec);
                    }
                    else
                    {
                        // выделяем памяти ровно столько, сколько надо
                        //
                        pDevIFCDetailData =
                            (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(cbSize);

                        if (!pDevIFCDetailData)
                        {
                            logData("insufficient memory, "
                                    "skip going any further\n");
                        }
                        else
                        {
/*
 * ТУТ НАЧИНАЮТСЯ ПОЛНЫЕ НЕПОНЯТКИ. НЕСМОТРЯ НА ТО, ЧТО ВСЕ ПАРАМЕТРЫ
 * ТЕПЕРЬ БУДУТ УСТАНОВЛЕНЫ КОРРЕКТНО, LMMPC ОЖИДАЕТ, ЧТО ФУНКЦИЯ ВЕРНЁТ
 * ОШИБКУ (SIC!). ЕСЛИ ЖЕ ФУНКЦИЯ ВЫПОЛНИЛАСЬ БЕЗ ОШИБКИ, ТО LMMPC
 * ЗАЧЕМ-ТО ПОЛУЧАЕТ INSTANCE ID ДАННОГО ИНТЕРФЕЙСА (ЧТО МЫ И ДЕЛАЕМ
 * НИЖЕ ПО ТЕКСТУ) И ТОЖЕ ОЖИДАЕТ, ЧТО ФУНКЦИЯ ВЕРНЁТ ОШИБКУ! СУДЯ
 * ПО ТЕКСТУ LMMPC, ТАКОЕ ПОВЕДЕНИЕ ВПОЛНЕ ВОЗМОЖНО, НО НЕ ДЛЯ ВСЕХ
 * КЛАССОВ УСТРОЙСТВ (ВСЕГО ТАМ ЧЕТЫРЕ ВОЗМОЖНЫХ КЛАССА).
 *
 * БЫТЬ МОЖЕТ ВСЯ ЭТА БАДЯГА ТУТ НАДЕЛАНА ДЛЯ ТОГО, ЧТОБЫ ИЗБЕЖАТЬ
 * ПОВТОРНОГО ОТКРЫТИЯ УЖЕ ОТКРЫТОГО ДИВАЙСА, ФИГ ЗНАЕТ
 */

 /*
  * BIZARRE BEGIN
  */
                            // подготавливаем структуру
                            // SP_DEVICE_INTERFACE_DETAIL_DATA
                            //
                            pDevIFCDetailData->cbSize =
                                sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

                            // и опять вызываем SetupDiGetDeviceInterfaceDetail,
                            // но уже с установленными значениями параметров
                            //
/*
 * В LMMPC ДАЛЕЕ ВЫПОЛНЕНИЕ ИДЁТ НА ОТКРЫТИЕ ДИВАЙСА ЕСЛИ ЭТА ФУНКЦИЯ ВЕРНУЛА
 * ОШИБКУ И КЛАСС ДИВАЙСА РАВЕН ОПРЕДЕЛЁННОМУ ЗНАЧЕНИЮ. ЖУТЬ КАКАЯ-ТО, ЯВНО
 * КАКИЕ-ТО МАНЬЯКИ ТАКОЕ ПРИДУМЫВАЛИ
 */
                            if (!SetupDiGetDeviceInterfaceDetail(
                                hDevInfo,
                                &DeviceInterfaceData,
                                pDevIFCDetailData,
                                cbSize,
                                NULL,
                                NULL))
                            {
/*
 * НА ВСЯКИЙ СЛУЧАЙ ЗАПИСЫВАЕМ КОД ОШИБКИ В ЖУРНАЛ, МОЖЕТ БЫТЬ
 * ЧУТЬ ПОНЯТНЕЕ СТАНЕТ (ПРОВЕРИТЬ ВОТ НЕ НА ЧЕМ)
 */
                                logData("bizarre error code 0: %08X\n",
                                        GetLastError());
                            }
                            else
                            {
/*
 * ОШИБКИ НЕ БЫЛО, ЗНАЧИТ СМОТРИМ НА DEVICE INSTANCE ID
 */
                                logData("    device path: %s\n",
                                        pDevIFCDetailData->DevicePath);

                                // используем такой же способ определения
                                // требуемого размера буфера, как и выше
                                // для SetupDiGetDeviceInterfaceDetail
                                //
                                SetupDiGetDeviceInstanceId(hDevInfo,
                                                           &DevInfoData,
                                                           NULL,
                                                           0,
                                                           &cbSize);

                                ec = GetLastError();

                                if (ec != ERROR_SUCCESS)
                                {
                                    if (ec != ERROR_INSUFFICIENT_BUFFER)
                                    {
/*
 * И ЭТУ СТРАННУЮ ОШИБКУ ТОЖЕ ПИШЕМ В ЖУРНАЛ
 */
                                        logData("bizarre error code 1: %08X\n",
                                                GetLastError());
                                    }
                                    else
                                    {
/*
 * ПОПАДАЕМ СЮДА ТОЛЬКО В ТОМ СЛУЧАЕ, ЕСЛИ БЫЛА ОШИБКА ПРО МАЛЫЙ
 * РАЗМЕР БУФЕРА. В ПРОТИВНОМ СЛУЧАЕ ПРОСТО ИДЁМ НА ОТКРЫТИЕ ДИВАЙСА
 */
                                        // выделяем памяти ровно столько,
                                        //  сколько надо
                                        //
                                        char *pInstanceID =
                                            (char*)malloc(cbSize);

                                        if (pInstanceID)
                                        {
                                            if (!SetupDiGetDeviceInstanceId(
                                                hDevInfo,
                                                &DevInfoData,
                                                pInstanceID,
                                                cbSize,
                                                NULL))
                                            {
/*
 * ЖУРНАЛИРУЕМ ЕЩЁ ОДНУ СТРАННУЮ ОШИБКУ
 */
                                                logData(
                                                    "bizarre error code 2: "
                                                    "%08X\n",
                                                    GetLastError());
                                            }
                                            else
                                            {
                                                // на всякий случай записываем
                                                // device instance id в лог
                                                //
                                                logData("    instance ID: %s\n",
                                                        pInstanceID);
                                            }
                                            // следим за heap
                                            //
                                            free(pInstanceID);
                                        }
                                    }
                                }
                            }
 /*
  * BIZARRE END
  */
                            // смотрим к какому классу относится устройство
                            // (СМ. НАВЕРХУ ПРО ТО, ЧТО ПОРЯДОК КЛАССОВ В
                            // МАССИВЕ [i.e. ИХ НУМЕРАЦИЯ] ВАЖЕН!!!)
                            //
                            // устройства классов
                            // {4F919104-4ADF-11D5-882D-00B0D02FE381}
                            // {4F919100-4ADF-11D5-882D-00B0D02FE381},
                            // индексируемые через 0 и 2 соответственно,
                            // мы просто игнорируем (то есть мы проверяем
                            // эти классы только на присутствие, больше они
                            // нас никак не интересуют)
                            //
                            // устройство класса
                            // {4F919102-4ADF-11D5-882D-00B0D02FE381},
                            // индексируемое через 1, надлежит открыть
                            //
                            // устройство класса
                            // {86E0D1E0-8089-11D0-9CE4-08003E301F73},
                            // индексируемое через 3 и имеющее четвёртым
                            // символом пути букву `u' (USB?) тоже
                            // попадает под нашу юрисдикцию, однако
                            // открытия не требует (было открыто ранее?)
                            //
                            if ((iDevClass == 1) ||
                                    (iDevClass == 3 &&
                                    pDevIFCDetailData->DevicePath[4] == 'u'))
                            {
                                CDevice *pDevice =
                                    (CDevice*)malloc(sizeof (CDevice) +
                                    strlen(pDevIFCDetailData->DevicePath));

                                if(!pDevice)
                                {
                                    logData("insufficient memory to keep "
                                            "device info\n");
                                }
                                else
                                {
                                    fFound = true;

                                    if (aDevices)
                                        aDevices->pNext = pDevice;
                                    else
                                        aDevices = pDevice;

                                    pDevice->pNext = NULL;
                                    pDevice->fNeedOpen = (iDevClass == 1)
                                                                ? true
                                                                : false;
                                    pDevice->h = INVALID_HANDLE_VALUE;
                                    strcpy(pDevice->path,
                                        pDevIFCDetailData->DevicePath);
                                }
                            }

                            // следим за heap
                            //
                            free(pDevIFCDetailData);
                        }
                    }
                 }
             }
             if (!fFound)
             {
                 // в этом классе дивайсов нет
                 //
                 logData("  no any device(s)\n");
             }
             // больше нам этот класс не нужен
             //
             SetupDiDestroyDeviceInfoList(hDevInfo);
         }
    }

    // если выходим по ошибке, то освобождаем всю занятую память
    //
    if (fError)
    {
        for (CDevice *p = aDevices; p;)
        {
            CDevice *pTmp = p->pNext;
            free(p);
            p = pTmp;
        }
        aDevices = NULL;
    }

    *paDevices = aDevices;
}

static bool openDevice(CDevice&  device,
                       DWORD     IOCode,
                       BYTE     *pOutBuf,
                       DWORD    *cOutBytes)
{
    bool rc = false;

    logData("  about to open %s\n", device.path);

    if ((device.h = CreateFile(device.path,
                              0xC0000000,
                              0,
                              NULL,
                              OPEN_EXISTING,
                              FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL,
                              NULL)) == INVALID_HANDLE_VALUE)
    {
        logData("  error: %08X\n", GetLastError());
    }
    else
    {
        logData("  HANDLE: %08X\n", device.h);
        logData("  about to create event semaphore\n");

        HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

        logData("  HANDLE: %08X\n", hEvent);

        if (hEvent)
        {
            DWORD sysErr = ERROR_WAIT_NO_CHILDREN;
            OVERLAPPED ovrlpd;

            memset(&ovrlpd, 0, sizeof (OVERLAPPED));
            logData("  about to send %08X IOCTL code\n", IOCode);
            if (DeviceIoControl(device.h,
                                 IOCode,
                                 NULL,
                                 0,
                                 pOutBuf,
                                 *cOutBytes,
                                 cOutBytes,
                                 &ovrlpd));
            {
                logData("  success\n");
                sysErr = ERROR_SUCCESS;
            }
            if (sysErr)
            {
                sysErr = GetLastError();
                logData("  failed: %08X\n", sysErr);
                if (sysErr == ERROR_IO_PENDING)
                    sysErr = WaitForSingleObject(hEvent, 5000);
                    logData("  after waiting for 5000 ms: %08X\n", sysErr);
            }
            CloseHandle(hEvent);

            if (sysErr == ERROR_SUCCESS)
                rc = true;
        }
        CloseHandle(device.h);
        device.h = INVALID_HANDLE_VALUE;
    }
    return rc;
}

static void processDevice(CDevice& device)
{
    if (device.fNeedOpen)
    {
        DWORD cBytes;
        BYTE  buf[512];

        cBytes = sizeof(buf);
        memset(buf, 0, sizeof(buf));

        openDevice(device, 0x22203C, buf, &cBytes);
        openDevice(device, 0x222034, buf, &cBytes);
    }
}

static void dumpData(const char *buf, size_t len)
{
    char *dst = (char*)malloc(80);

    if (dst)
    {
        for (size_t i = 0; i < len;)
        {
            sprintf(dst, "%04X  ", i);

            size_t j;
            char   tmp[9];

            for (j = 0; j < 16; j++)
            {
                if ((i + j) == len)
                {
                    break;
                }
                sprintf(tmp, "%02X ", (unsigned char)buf[i + j]);
                strcat(dst, tmp);
            }

            for (; j < 16; j++)
                strcat(dst, "   ");

            strcat(dst, " ");

            for (j = 0; j < 16; j++)
            {
                if ((i + j) == len)
                {
                    break;
                }
                sprintf(tmp, "%c", isascii(buf[i + j]) ? buf[i + j] : '.');
                strcat(dst, tmp);
            }
            i += 16;

            logData("%s\n", dst);
        }
        free(dst);
    }
}

static void sendstuff(CDevice& device)
{
    DWORD  rc;
    HANDLE hDev;

    logData("  about to send some bytes\n");

    if ((hDev = CreateFile(device.path,
                           0xC0000000,
                           0,
                           NULL,
                           OPEN_EXISTING,
                           FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL,
                           NULL)) == INVALID_HANDLE_VALUE)
    {
        logData("  error opening: %08X\n", GetLastError());
    }
    else
    {
        HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

        if (hEvent)
        {
            OVERLAPPED ovrlpd;
            DWORD      nBytes;
            char       buf[512];

            memset(&ovrlpd, 0, sizeof (OVERLAPPED));
            ovrlpd.hEvent = hEvent;

            buf[0] = 0x1B;
            buf[1] = 0x00;
            buf[2] = 0x0C;
            buf[3] = 0xD0;
            buf[4] = 0x00;
            buf[5] = 0x01;
            buf[6] = 0x04;

            logData("  about to send data:\n");
            dumpData(buf, 7);

            rc = WriteFile(hDev,
                           buf,
                           7,
                           &nBytes,
                           &ovrlpd);

            if (rc)
            {
                if (GetLastError() == ERROR_IO_PENDING)
                {
                    printf ("waiting for 5 seconds to complete (write)\n");
                    logData("  waiting for 5 seconds to complete (write)\n");

                    rc = WaitForSingleObject(hEvent, 5000);
                }
            }
            if (rc)
            {
                logData("  error sending data: %08X\n", GetLastError());
            }
            else
            {
                logData("  about to read response:\n");
                SetEvent(hEvent);

                rc = ReadFile(hDev,
                              buf,
                              sizeof(buf),
                              &nBytes,
                              &ovrlpd);
                if (rc)
                {
                    if (GetLastError() == ERROR_IO_PENDING)
                    {
                        printf ("waiting for 5 seconds to complete (read)\n");
                        logData("  waiting for 5 seconds to complete (read)\n");

                        rc = WaitForSingleObject(hEvent, 5000);
                    }
                }
                if (rc)
                {
                    logData("  error getting response: %08X\n", GetLastError());
                }
                else
                {
                    dumpData(buf, nBytes);
                }
            }
            CloseHandle(hEvent);
        }
        CloseHandle(hDev);
    }
}

int main()
{
    CDevice *aDevices;

    char *pch = getenv("LOG_DKU-2");
    if (pch && stricmp(pch, "yes"))
        fNeedLog = true;

    logStart();
    logData("Start logging\n");

    scanForDevices(&aDevices);

    if (aDevices)
    {
        for (CDevice *p = aDevices; p; p = p->pNext)
        {
            logData("  BEFORE DeviceIoControl\n");
            sendstuff(*p);

            processDevice(*p);

            logData("  AFTER DeviceIoControl\n");
            sendstuff(*p);
        }

        for (CDevice *p = aDevices; p;)
        {
            if (p->h != INVALID_HANDLE_VALUE)
                CloseHandle(p->h);

            CDevice *pTmp = p->pNext;
            free(p);
            p = pTmp;
        }
    }

    logData("End logging\n");

    return 0;
}