libusb Problem

#include <errno.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>  // for assert()
#include "stdafx.h"
#include <libusb.h>
void print_devs(libusb_device **devs);
libusb_device* verify_device(libusb_device **devs);

#include <iostream>

int test2();
int do_exit = 0;
using namespace std;


BOOL WINAPI ConsoleHandler(
    DWORD dwCtrlType   //  control signal type
);

BOOL WINAPI ConsoleHandler(DWORD CEvent)
{
    char mesg[128];

    switch(CEvent)
    {
    case CTRL_C_EVENT:
        MessageBox(NULL,
            _T("CTRL+C received!"),_T("CEvent"),MB_OK);
        do_exit = true;
        break;
    case CTRL_BREAK_EVENT:
        MessageBox(NULL,
            _T("CTRL+BREAK received!"),_T("CEvent"),MB_OK);
        break;
    case CTRL_CLOSE_EVENT:
        MessageBox(NULL,
            _T("Program being closed!"),_T("CEvent"),MB_OK);
        break;
    case CTRL_LOGOFF_EVENT:
        MessageBox(NULL,
            _T("User is logging off!"),_T("CEvent"),MB_OK);
        break;
    case CTRL_SHUTDOWN_EVENT:
        MessageBox(NULL,
            _T("User is logging off!"),_T("CEvent"),MB_OK);
        break;

    }
    return TRUE;
}

int main() {
    //Handle Control+C
    if (SetConsoleCtrlHandler( (PHANDLER_ROUTINE)ConsoleHandler,TRUE)==FALSE)
    {
        printf("Unable to install handler!\n");
        return -1;
    }
    test2();
    return 0;

}

// OUT-going transfers (OUT from host PC to USB-device)
struct libusb_transfer *transfer_command_out     = NULL;  // find version

// IN-coming transfers (IN to host PC from USB-device)
struct libusb_transfer *transfer_response_in  = NULL;

extern "C" void LIBUSB_CALL receive(struct libusb_transfer *transfer);
extern "C" void LIBUSB_CALL cb_command_out(struct libusb_transfer *transfer);

extern "C" void sighandler(int signum);


// Setup Endpoints - The endpoints (2,4) are particular to the USB-connected device
#define EP_COMMAND    (0x03 | LIBUSB_ENDPOINT_OUT) // OUT of PC to USB-device //DEVICE_SPECIFIC
#define EP_RESPONSE   (0x83 | LIBUSB_ENDPOINT_IN ) // IN  PC from  USB-device //DEVICE_SPECIFIC

unsigned char buffer[1024] = {0};

int device_num = 1;

int test2()
{
    libusb_device **devs;
    int r;

    libusb_context *ctx = NULL; //a libusb session

    ssize_t cnt; //holding number of devices in list

    r = libusb_init(&ctx); //initialize the library for the session we just declared

    if(r < 0) {

        cout<<"Init Error "<<r<<endl; //there was an error
        return 1;
    }

    libusb_set_debug(ctx, 3);

    cnt = libusb_get_device_list(ctx, &devs);
    if (cnt < 0)
        return (int) cnt;

    libusb_device *dev = verify_device(devs);

    struct libusb_device_descriptor desc;
    r = libusb_get_device_descriptor(dev, &desc);
    if (r < 0) {
        fprintf(stderr, "failed to get device descriptor");
        return -1;
    }

    libusb_config_descriptor *config;

    libusb_get_config_descriptor(dev, 0, &config);

    cout<<"Interfaces: "<<(int)config->bNumInterfaces;

    const libusb_interface *inter;
    const libusb_interface_descriptor *interdesc;
    const libusb_endpoint_descriptor *epdesc;
    /*
    for(int i=0; i<(int)config->bNumInterfaces; i++) {
        inter = &config->interface[i];
        cout<<"Number of alternate settings: "<<inter->num_altsetting<<" | ";

        for(int j=0; j<inter->num_altsetting; j++) {
            interdesc = &inter->altsetting[j];
            cout<<"Interface Number: "<<(int)interdesc->bInterfaceNumber<<" | ";
            cout<<"Number of endpoints: "<<(int)interdesc->bNumEndpoints<<" | ";

            for(int k=0; k<(int)interdesc->bNumEndpoints; k++) {
                epdesc = &interdesc->endpoint[k];
                cout<<"Descriptor Type: "<<(int)epdesc->bDescriptorType<<" | ";
                cout<<"EP Address: "<<(int)epdesc->bEndpointAddress<<" | ";
            }
        }
    }*/

    libusb_free_config_descriptor(config);

    printf("%04x:%04x (bus %d, device %d)\n",
        desc.idVendor, desc.idProduct,
        libusb_get_bus_number(dev), libusb_get_device_address(dev));

    libusb_device_handle *handle = NULL;

    r = libusb_open(dev, &handle);

    printf("libusb_open = %d\n", r);

    r = libusb_kernel_driver_active(handle, device_num);
    printf("libusb_kernel_driver_active = %d\n", r);
    if (r == 1) {
        r = libusb_detach_kernel_driver(handle, device_num);
        printf("libusb_detach_kernel_driver = %d\n", r);
    }

    r = libusb_claim_interface(handle, device_num);
    if (r < 0) {
        fprintf(stderr, "usb_claim_interface error %d\n", r);
        return -1;
    }

    const int length = 1;
    unsigned char buf[length] = {0};
    buf[0] = 'a';

    transfer_response_in  = libusb_alloc_transfer(0);
    libusb_fill_bulk_transfer( transfer_response_in, handle, EP_RESPONSE,
        buffer,  1024,  // Note: version_string is where input data written.
        receive, NULL, 0); // no user data
    r = libusb_submit_transfer(transfer_response_in);
    printf("return value from libusb_submit_transfer(for transfer_response_in)= %d\n", r);

        // Define transfer of data OUT (OUT to USB-device from host PC)
    transfer_command_out = libusb_alloc_transfer(0);

    libusb_fill_bulk_transfer(transfer_command_out, handle, EP_COMMAND,
        buf, length,  // version request command, command length
        cb_command_out, NULL, 0); // callback function, NO callback data
    r = libusb_submit_transfer(transfer_command_out);
    printf("return value from libusb_submit_transfer(for transfer_command_out)=%d\n", r);

    while (!do_exit) {
        struct timeval tv;
        tv.tv_sec  = 0;     // seconds
        tv.tv_usec = 100;   // milliseconds  ( .1 sec)
        //libusb_handle_events(ctx);
        libusb_handle_events_timeout(ctx, &tv);
    }

    libusb_release_interface(handle, device_num);
    libusb_close(handle);
    libusb_free_device_list(devs, 0);
    libusb_exit(ctx);

    printf("Exit 0");
    return 0;
}

extern "C" void LIBUSB_CALL receive(struct libusb_transfer *transfer)
{   int i;
    fprintf(stderr, "cb_response_in: status =%d, actual_length=%d\n",
        transfer->status, transfer->actual_length);
    for (i=0; i < transfer->actual_length; i++){
        printf("buffer[%d]=%x \n", i, buffer[i] );
    }
    return;
}

//This is called after command for version is received.
//   - This is ONLY a mechanism to indicate the that version command has been received by libusb.
//     It does NOT signal that the version_string is ready.
//     It does NOT say when the version will be ready.
extern "C" void LIBUSB_CALL cb_command_out(struct libusb_transfer *transfer)
{
    fprintf(stderr, "cb_command_out: status =%d, actual_length=%d\n",
        transfer->status, transfer->actual_length);
    return;
}

libusb_device* verify_device(libusb_device **devs)
{
    libusb_device *dev;
    int i = 0;
    while ((dev = devs[i++]) != NULL) {
        struct libusb_device_descriptor desc;
        int r = libusb_get_device_descriptor(dev, &desc);
        if (r < 0) {
            fprintf(stderr, "failed to get device descriptor");
            return NULL;
        }
        if(desc.idVendor == 0x04D8 && desc.idProduct == 0x00DF)
        {
            puts("Found our Device!");
            return dev;
        }
    }
    return NULL;
}

void print_devs(libusb_device **devs)
{
    libusb_device *dev;
    int i = 0;

    while ((dev = devs[i++]) != NULL) {
        struct libusb_device_descriptor desc;
        int r = libusb_get_device_descriptor(dev, &desc);
        if (r < 0) {
            fprintf(stderr, "failed to get device descriptor");
            return;
        }

        printf("%04x:%04x (bus %d, device %d)\n",
            desc.idVendor, desc.idProduct,
            libusb_get_bus_number(dev), libusb_get_device_address(dev));
    }
}