audiosrv.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <malloc.h>
#include <dbt.h>
#include <audiosrv/audiosrv.h>

Include dependency graph for audiosrv.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	AUDIOSRV_PRIVATE_H
#define	DestroyDeviceDescriptor(descriptor)   free(descriptor)

Functions
VOID *	CreateDeviceDescriptor (WCHAR *path, BOOL is_enabled)
BOOL	AppendAudioDeviceToList (PnP_AudioDevice *device)
BOOL	CreateAudioDeviceList (DWORD max_size)
VOID	DestroyAudioDeviceList (VOID)
BOOL	ProcessExistingDevices (VOID)
DWORD	ProcessDeviceArrival (DEV_BROADCAST_DEVICEINTERFACE *device)
BOOL	RegisterForDeviceNotifications (VOID)
VOID	UnregisterDeviceNotifications (VOID)
DWORD	HandleDeviceEvent (DWORD dwEventType, LPVOID lpEventData)
BOOL	StartSystemAudioServices (VOID)
void	logmsg (char *string,...)

Variables
SERVICE_STATUS_HANDLE	service_status_handle

Macro Definition Documentation

AUDIOSRV_PRIVATE_H

#define AUDIOSRV_PRIVATE_H

Definition at line 21 of file audiosrv.h.

DestroyDeviceDescriptor

#define DestroyDeviceDescriptor

(

descriptor

)

free(descriptor)

Definition at line 31 of file audiosrv.h.

Function Documentation

AppendAudioDeviceToList()

BOOL AppendAudioDeviceToList

(

PnP_AudioDevice *

device

)

Definition at line 57 of file pnp_list_manager.c.

{
    int device_info_size;

    /* Figure out the actual structure size */
    device_info_size = sizeof(PnP_AudioDevice);
    device_info_size += WideStringSize(device->path);

    LockAudioDeviceList();

/*
    printf("list size is %d\n", audio_device_list->size);
    printf("device info size is %d bytes\n", device_info_size);
*/

    /* We DON'T want to overshoot the end of the buffer! */
    if (audio_device_list->size + device_info_size > audio_device_list->max_size)
    {
        /*printf("max_size would be exceeded! Failing...\n");*/

        UnlockAudioDeviceList();

        return FALSE;
    }

    /* Commit the device descriptor to the list */
    memcpy((char*)audio_device_list + audio_device_list->size,
           device,
           device_info_size);

    /* Update the header */
    audio_device_list->device_count ++;
    audio_device_list->size += device_info_size;

    UnlockAudioDeviceList();

    logmsg("Device added to list\n");

    return TRUE;
}

Referenced by InitializeFakeDevice(), ProcessDeviceArrival(), and ProcessExistingDevices().

CreateAudioDeviceList()

BOOL CreateAudioDeviceList

(

DWORD

max_size

)

Definition at line 99 of file pnp_list_manager.c.

{
/*    printf("Initializing memory device list lock\n");*/

    if (!InitializeAudioDeviceListLock())
    {
        /*printf("Failed!\n");*/
        return FALSE;
    }

    /* Preliminary locking - the list memory will likely be a big
       buffer of gibberish at this point so we don't want anyone
       turning up before we're ready... */
    LockAudioDeviceList();

    logmsg("Creating file mapping\n");
    /* Expose our device list to the world */
    device_list_file = CreateFileMappingW(INVALID_HANDLE_VALUE,
                                          NULL,
                                          PAGE_READWRITE,
                                          0,
                                          max_size,
                                          AUDIO_LIST_NAME);
    if (!device_list_file)
    {
        logmsg("Creation of audio device list failed (err %d)\n", GetLastError());

        UnlockAudioDeviceList();
        KillAudioDeviceListLock();

        return FALSE;
    }

    logmsg("Mapping view of file\n");
    /* Of course, we'll need to access the list ourselves */
    audio_device_list = MapViewOfFile(device_list_file,
                                      FILE_MAP_WRITE,
                                      0,
                                      0,
                                      max_size);
    if (!audio_device_list)
    {
        logmsg("MapViewOfFile FAILED (err %d)\n", GetLastError());

        CloseHandle(device_list_file);
        device_list_file = NULL;

        UnlockAudioDeviceList();
        KillAudioDeviceListLock();

        return FALSE;
    }

    /* Clear the mem to avoid any random stray data */
    memset(audio_device_list, 0, max_size);

    /* Don't want devices to overwrite the list! */
    audio_device_list->size = sizeof(PnP_AudioHeader);
    audio_device_list->max_size = max_size;
    audio_device_list->device_count = 0;

    UnlockAudioDeviceList();

    logmsg("Device list created\n");

    return TRUE;
}

Referenced by ServiceMain().

CreateDeviceDescriptor()

VOID* CreateDeviceDescriptor	(	WCHAR *	path,
		BOOL	is_enabled
	)

Definition at line 16 of file pnp_list_manager.c.

{
    PnP_AudioDevice* device;

    int path_length = WideStringSize(path);
    int size = sizeof(PnP_AudioDevice) + path_length;

/*    printf("path_length %d, total %d\n", path_length, size);*/

    device = malloc(size);
    if (! device)
    {
        logmsg("Failed to create a device descriptor (malloc fail)\n");
        return NULL;
    }

    device->enabled = is_enabled;
    memcpy(device->path, path, path_length);

    return device;
}

Referenced by InitializeFakeDevice(), ProcessDeviceArrival(), and ProcessExistingDevices().

DestroyAudioDeviceList()

VOID DestroyAudioDeviceList

(

VOID

)

Definition at line 168 of file pnp_list_manager.c.

{
    logmsg("Destroying device list\n");

    LockAudioDeviceList();

    /*printf("Unmapping view\n");*/
    UnmapViewOfFile(audio_device_list);
    audio_device_list = NULL;

    /*printf("Closing memory mapped file\n");*/
    CloseHandle(device_list_file);
    device_list_file = NULL;

    UnlockAudioDeviceList();

    /*printf("Killing devlist lock\n");*/
    KillAudioDeviceListLock();
}

Referenced by ServiceControlHandler(), and ServiceMain().

HandleDeviceEvent()

DWORD HandleDeviceEvent	(	DWORD	dwEventType,
		LPVOID	lpEventData
	)

Definition at line 176 of file pnp.c.

{
    switch (dwEventType)
    {
        case DBT_DEVICEARRIVAL:
        {
            DEV_BROADCAST_DEVICEINTERFACE* incoming_device =
                (DEV_BROADCAST_DEVICEINTERFACE*)lpEventData;

            return ProcessDeviceArrival(incoming_device);
        }

        default :
        {
            break;
        }
    }

    return NO_ERROR;
}

Referenced by ServiceControlHandler().

logmsg()

void logmsg	(	char *	string,
			...
	)

Definition at line 10 of file debug.c.

{
    va_list args;

#ifdef ENABLE_LOGMSG_FILE
    FILE* debug_file = fopen("c:\\audiosrv-debug.txt", "a");

    if (debug_file)
    {
        va_start(args, string);
        vfprintf(debug_file, string, args);
        va_end(args);
        fclose(debug_file);
    }
    else
#endif
    {
        char buf[256];
        va_start(args, string);
        vsprintf(buf, string, args);
        OutputDebugStringA(buf);
        va_end(args);
    }
}

Referenced by AppendAudioDeviceToList(), CreateAudioDeviceList(), CreateDeviceDescriptor(), DestroyAudioDeviceList(), ProcessExistingDevices(), RegisterForDeviceNotifications(), ServiceControlHandler(), ServiceMain(), StartAudioService(), StartSystemAudioServices(), WaitForService(), and wmain().

ProcessDeviceArrival()

DWORD ProcessDeviceArrival

(

DEV_BROADCAST_DEVICEINTERFACE *

device

)

Definition at line 111 of file pnp.c.

{
    PnP_AudioDevice* list_node;
    list_node = CreateDeviceDescriptor(device->dbcc_name, TRUE);
    AppendAudioDeviceToList(list_node);
    DestroyDeviceDescriptor(list_node);

    return NO_ERROR;
}

Referenced by HandleDeviceEvent().

ProcessExistingDevices()

BOOL ProcessExistingDevices

(

VOID

)

Definition at line 26 of file pnp.c.

{
    SP_DEVICE_INTERFACE_DATA interface_data;
    SP_DEVINFO_DATA device_data;
    PSP_DEVICE_INTERFACE_DETAIL_DATA_W detail_data;
    HDEVINFO dev_info;
    DWORD length;
    int index = 0;

    const GUID category_guid = {STATIC_KSCATEGORY_AUDIO};

    dev_info = SetupDiGetClassDevsExW(&category_guid,
                                      NULL,
                                      NULL,
                                      DIGCF_PRESENT | DIGCF_DEVICEINTERFACE,
                                      NULL,
                                      NULL,
                                      NULL);

/*    printf("%s:\n", ClassString); */

    interface_data.cbSize = sizeof(interface_data);
    interface_data.Reserved = 0;

    /* Enumerate the devices within the category */
    index = 0;

    length = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA)
                + (MAX_PATH * sizeof(WCHAR));

    detail_data =
        (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(),
                                                      0,
                                                      length);

    if ( ! detail_data )
    {
        logmsg("ProcessExistingDevices() failed to allocate detail_data\n");
        return TRUE;
    }

    while (
    SetupDiEnumDeviceInterfaces(dev_info,
                                NULL,
                                &category_guid,
                                index,
                                &interface_data) )
    {
        PnP_AudioDevice* list_node;

        ZeroMemory(detail_data, length);

        /* NOTE: We don't actually use device_data... */
        detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
        device_data.cbSize = sizeof(device_data);
        device_data.Reserved = 0;
        SetupDiGetDeviceInterfaceDetailW(dev_info,
                                         &interface_data,
                                         detail_data,
                                         length,
                                         NULL,
                                         &device_data);

        list_node = CreateDeviceDescriptor(detail_data->DevicePath, TRUE);
        AppendAudioDeviceToList(list_node);
        DestroyDeviceDescriptor(list_node);

        /* TODO: Cleanup the device we enumerated? */

        index ++;
    };

    HeapFree(GetProcessHeap(), 0, detail_data);

    SetupDiDestroyDeviceInfoList(dev_info);

    return TRUE;
}

Referenced by ServiceMain().

RegisterForDeviceNotifications()

BOOL RegisterForDeviceNotifications

(

VOID

)

Definition at line 127 of file pnp.c.

{
    DEV_BROADCAST_DEVICEINTERFACE notification_filter;

    const GUID wdmaud_guid = {STATIC_KSCATEGORY_AUDIO};

    ZeroMemory(&notification_filter, sizeof(notification_filter));
    notification_filter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
    notification_filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
    notification_filter.dbcc_classguid = wdmaud_guid;

    device_notification_handle =
        RegisterDeviceNotificationW((HANDLE) service_status_handle,
                                    &notification_filter,
                                    DEVICE_NOTIFY_SERVICE_HANDLE
/* |
                                   DEVICE_NOTIFY_ALL_INTERFACE_CLASSES*/);
    if (!device_notification_handle)
    {
        logmsg("RegisterDeviceNotification() failed with error %d\n", GetLastError());
    }

    return ( device_notification_handle != NULL );
}

Referenced by ServiceMain().

StartSystemAudioServices()

BOOL StartSystemAudioServices

(

VOID

)

Definition at line 70 of file services.c.

{
    SC_HANDLE hSCManager;

    logmsg("Starting system audio services\n");

    hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
    if (!hSCManager)
    {
        logmsg("Failed to open service manager %x\n", GetLastError());
        return FALSE;
    }

    logmsg("Starting sysaudio service\n");
    StartAudioService(hSCManager, L"sysaudio", 20);
    logmsg("Starting wdmaud service\n");
    StartAudioService(hSCManager, L"wdmaud", 20);

    CloseServiceHandle(hSCManager);
    return TRUE;
}

Referenced by ServiceMain().

UnregisterDeviceNotifications()

VOID UnregisterDeviceNotifications

(

VOID

)

Definition at line 159 of file pnp.c.

{
    /* TODO -- NOT IMPLEMENTED! */

    if (device_notification_handle)
    {
        /* TODO */
        device_notification_handle = NULL;
    }
}

Referenced by ServiceControlHandler(), and ServiceMain().

Variable Documentation

service_status_handle

SERVICE_STATUS_HANDLE service_status_handle

Definition at line 11 of file main.c.

Referenced by RegisterForDeviceNotifications(), ServiceControlHandler(), and ServiceMain().