Segmentation fault

#include <iostream>
#include <windows.h>

#include "PXCP.h"

void Debug(TXCPResult result, std::string function_name);

int main(int argc, char *argv[])
{
    TXCPResult result;
    TXCPChannel xcp_channel;

    /*** XCP_InitializeCanChannel ***/
    result = XCP_InitializeCanChannel(&xcp_channel,
            PCAN_PCIBUS1,
            PCAN_BAUD_1M,
            0,0,0);
    Debug(result, "XCP_InitializeCanChannel");

    /*** XCP_AddSlaveOnCAN ***/
    TXCPTransportLayerCAN layer_data;
    layer_data.BroadcastID = 0;
    layer_data.MasterID = 0x078A;
    layer_data.SlaveID = 0x0791;
    layer_data.IncrementalIdUsed = false;

    TXCPProtocolLayerConfig layer_config;
    layer_config.MotorolaFormat = false;
    layer_config.T1 = 2000;
    layer_config.T2 = 2000;
    layer_config.T3 = 2000;
    layer_config.T4 = 65535;
    layer_config.T5 = 2000;
    layer_config.T6 = 5;
    layer_config.T7 = 5;
    layer_config.AddressGranularity = 1;

    TXCPHandle xcp_handle;
    result = XCP_AddSlaveOnCAN(xcp_channel,
            layer_data,
            layer_config,
            &xcp_handle);
    Debug(result, "XCP_AddSlaveOnCAN");

    /*** XCP_Connect ***/
    BYTE cto_buffer[8];
    BYTE cto_buffer_length = 8;
    result = XCP_Connect(xcp_handle, 0, cto_buffer, cto_buffer_length);
    Debug(result, "XCP_Connect");

    /*** XCP_FreeDAQLists ***/
    result =
        XCP_FreeDAQLists(xcp_handle, cto_buffer, cto_buffer_length);
    Debug(result, "XCP_FreeDAQLists");

    /*** XCP_AllocateDAQLists ***/
    result =
        XCP_AllocateDAQLists(xcp_handle,
                1, // number of daq lists
                cto_buffer,
                cto_buffer_length);
    Debug(result, "XCP_AllocateDAQLists");

    /*** XCP_AllocateODT ****/
    result =
        XCP_AllocateODT(xcp_handle,
                0, // daq list number
                1, // number of dtos
                cto_buffer,
                cto_buffer_length);
    Debug(result, "XCP_AllocateODT");

    /*** XCP_AllocateODTEntry ***/
    result =
        XCP_AllocateODTEntry(xcp_handle,
                0, // daq list number
                0, // dto number
                1, // number of dto entries
                cto_buffer,
                cto_buffer_length);
    Debug(result, "XCP_AllocateODTEntry");


    /*** XCP_SetDAQListPointer ***/
    result = XCP_SetDAQListPointer(
            xcp_handle,
            0, // daq list number
            0, // dto number
            0, // dto_entry number
            cto_buffer,
            cto_buffer_length);
    Debug(result, "XCP_SetDAQListPointer");

    /*** XCP_WriteDAQListEntry ***/
    TXCPODTEntry odt_entry;
    odt_entry.BitOffset = 0xFF;
    odt_entry.DAQSize = sizeof(float);
    odt_entry.DAQAddressExtension = 0;
    odt_entry.DAQAddress = 0xD0010FDC;

    result = XCP_WriteDAQListEntry(xcp_handle,
            odt_entry,
            cto_buffer,
            cto_buffer_length);
    Debug(result, "XCP_WriteDAQListEntry");

    /*** Set daq list mode ***/
    BYTE mode = 00000000;

    TXCPDAQListConfig daq_list_config;
    daq_list_config.DAQListNumber = 0;
    daq_list_config.EventChannelNumber = 0;
    daq_list_config.TransmissionRate = 1;
    daq_list_config.DAQPriority = 0;

    result = XCP_SetDAQListMode(xcp_handle,
            mode,
            daq_list_config,
            cto_buffer,
            cto_buffer_length);
    Debug(result, "XCP_SetDAQListMode");

    /*** XCP_StartStopDAQList ***/
    result = XCP_StartStopDAQList(xcp_handle,
            1, // Mode: 0-stop, 1-start, 2-select
            0, // list number
            cto_buffer,
            cto_buffer_length);
    Debug(result, "XCP_StartStopDAQList");

    /*** XCP_DequeuePacket ***/
    WORD packet_buffer_length = 8;
    BYTE packet_buffer[packet_buffer_length];
    result = XCP_DequeuePacket(xcp_handle,
            XCP_DTO_QUEUE,
            packet_buffer,
            packet_buffer_length);
    Debug(result, "XCP_DequeuePacket");


    return 0;
}

void
Debug(TXCPResult result, std::string function_name)
{
    if (result != XCP_ERR_OK) {
        std::cout << function_name << ": Error:" << result << std::endl;
    } else {
        std::cout << function_name << ": XCP_ERR_OK" << std::endl;
    }
}