void
repair_damage(void)
{
int i;
double_t d6; /* Repair Factor */
d6 = w1;
if (w1 >= 1.0)
d6 = w1 / 10;
for (i = 1; i <= 8; i++)
{
if (d[i] < 0.0)
{
d[i] = d[i] + d6;
if (d[i] > -0.1 && d[i] < 0)
d[i] = -0.1;
else if (d[i] >= 0.0)
{
if (d1 != 1)
d1 = 1;
printf("Damage Control report:\n");
r1 = i;
get_device_name();
printf(" %s repair completed\n\n", sG2);
}
}
}
if (rnd() <= 0.2)
{
r1 = function_r();
if (rnd() < .6)
{
d[r1] = d[r1] - (rnd() * 5.0 + 1.0);
printf("Damage Control report:\n");
get_device_name();
printf(" %s damaged\n\n", sG2);
}
else
{
d[r1] = d[r1] + (rnd() * 3.0 + 1.0);
printf("Damage Control report:\n");
get_device_name();
printf(" %s state of repair improved\n\n", sG2);
}
}
}
int bgav_check_device_vcd(const char * device, char ** name)
{
CdIo_t * cdio;
cdio_drive_read_cap_t read_cap;
cdio_drive_write_cap_t write_cap;
cdio_drive_misc_cap_t misc_cap;
cdio = cdio_open (device, DRIVER_DEVICE);
if(!cdio)
return 0;
cdio_get_drive_cap(cdio, &read_cap, &write_cap, &misc_cap);
if(!(read_cap & CDIO_DRIVE_CAP_READ_MODE2_FORM2))
{
cdio_destroy(cdio);
return 0;
}
/* Seems the drive is ok */
if(name)
*name = get_device_name(cdio, read_cap, write_cap, device);
cdio_destroy(cdio);
return 1;
}
void
damage_control(void)
{
int a1;
double_t d3 = 0.0;
int i;
if (d[6] < 0.0)
{
printf("Damage Control report not available.\n");
if (d0 == 0)
return;
d3 = 0.0;
for (i = 1; i <= 8; i++)
if (d[i] < 0.0)
d3 = d3 + .1;
if (d3 == 0.0)
return;
d3 = d3 + d4;
if (d3 >= 1.0)
d3 = 0.9;
printf("\nTechnicians standing by to effect repairs to your");
/* @@@ printf("ship; Will you authorize the repair order (Y/N)? "); */
printf("ship;\nEstimated time to repair: %4.2f stardates.\n", d3);
printf("Will you authorize the repair order (Y/N)? ");
a1 = getchar();
if (a1 == 'Y' || a1 == 'y')
{
for (i = 1; i <= 8; i++)
if (d[i] < 0.0)
d[i] = 0.0;
t = t + d3 + 0.1;
}
}
printf("Device State of Repair\n");
for (r1 = 1; r1 <= 8; r1++)
{
get_device_name();
printf(sG2);
/* @@@ for (i = 1; i < 25 - strlen(sG2); i++) */
for (i = 1; i < 25 - (int)strlen(sG2); i++)
printf(" ");
/* @@@ printf("%4.1f\n", d[r1]); */
printf("%4.2f\n", d[r1]);
}
printf("\n");
}
static void add_device(IMMDevice *device, LPCWSTR devid, vector_DevMap *list)
{
DevMap entry;
AL_STRING_INIT(entry.name);
entry.devid = strdupW(devid);
get_device_name(device, &entry.name);
TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
VECTOR_PUSH_BACK(*list, entry);
}
static const char *get_command_name(struct payload_header *header)
{
size_t i;
if (get_device_name(header) == NULL)
return NULL;
for (i = 0; command_list[header->type_id][i] != NULL && i <= header->cmd_id; i++);
if ((header->cmd_id + 1) == i)
return command_list[header->type_id][i];
return NULL;
}
void log_device_error(struct payload_header *header)
{
const char *dev_name, *cmd_name;
if (header == NULL || header->payload_size >= 0)
return;
dev_name = get_device_name(header);
cmd_name = get_command_name(header);
log_message(WRND_ERROR, "Error status received from the device [%" PRIu16 "] %s:%s",
header->seq_num, dev_name != NULL ? dev_name : "UNEXPECTED",
cmd_name != NULL ? cmd_name : "UNEXPECTED");
}
static void add_device(IMMDevice *device, DevMap *devmap)
{
LPWSTR devid;
HRESULT hr;
hr = IMMDevice_GetId(device, &devid);
if(SUCCEEDED(hr))
{
devmap->devid = strdupW(devid);
devmap->name = get_device_name(device);
TRACE("Got device \"%s\", \"%ls\"\n", devmap->name, devmap->devid);
CoTaskMemFree(devid);
}
}
void
klingons_shoot(void)
{
int h, i;
if (k3 <= 0)
return;
if (d0 != 0)
{
printf("Starbase shields protect the Enterprise\n\n");
return;
}
for (i = 1; i <= 3; i++)
{
if (k[i][3] > 0)
{
h = (int) ((k[i][3] / function_d(i)) * (2 + rnd()));
s = s - h;
/* @@@ k[i][3] = k[i][3] / (3 + rnd()); */
k[i][3] = (int)(k[i][3] / (3 + rnd()));
printf("%d unit hit on Enterprise from sector ", h);
printf("%d, %d\n", k[i][1], k[i][2]);
if (s <= 0)
{
printf("\n");
ship_destroyed();
}
printf(" <Shields down to %d units>\n\n", s);
if (h >= 20)
{
if (rnd() <= 0.6 || (h / s) > 0.2)
{
r1 = function_r();
d[r1] = d[r1] - (h / s) - (0.5 * rnd());
get_device_name();
printf("Damage Control reports\n");
printf(" '%s' damaged by hit\n\n", sG2);
}
}
}
}
}
int
SiSTouch_Aegis_Multi_FOR_NEW_DRIVER::simple_io_master( int cmd, int sleepms, int wTimeout, int rTimeout )
{
int len = make_simple_buffer_master(cmd);
int ret = sis_usb_write( m_buffer, len, wTimeout );
if(ret < 0)
{
return ret;
}
if(sleepms >= 0)
{
usleep(sleepms * 1000);
}
ret = sis_usb_read( m_buffer, BUFFER_SIZE, rTimeout );
/* close m_fd for remove /dev/hidraw =======================================*/
if(cmd == 0x82 || cmd == 0x87)
{
int ret = sis_usb_start();
if(ret != 0)
{
printf("close m_fd (%s): fail , ret=%d\n", get_device_name(), ret);
}
}
/* =============================================================== */
if ( m_verbose ) dbg_print_buffer_hex( cmd, m_buffer, ret );
//usb return fixed 64 byte
if( ret >= 0)
{
ret = m_buffer[1] + 1;
}
if(m_IODelayms >= 0)
{
usleep(m_IODelayms * 1000);
}
return ret;
}
Retcode
usb_install_keyboard_driver(Environ *e, Package *pkg, USB_self *usb,
usb_device_descriptor_t *dev, usb_config_descriptor_t *cfg,
usb_interface_descriptor_t *ifc)
{
Retcode ret;
Byte name[STR_SIZE];
DPRINTF(("usb_install_keyboard_driver: addr=%d interface=%d\n",
usb->addr, usb->interface));
ret = prop_set_str(pkg->props, "device_type", CSTR, "keyboard", CSTR);
if (ret == NO_ERROR)
ret = init_entries(e, pkg->dict, usb_kbd_methods);
/* make keyboard aliases if none already exist */
if (ret == NO_ERROR)
(void)get_device_name(e, pkg, name);
if (ret == NO_ERROR &&
find_table(e->aliases->props, "keyboard", CSTR) == NULL)
ret = make_devalias(e, "keyboard", CSTR, name, CSTR);
if (ret == NO_ERROR &&
find_table(e->aliases->props, "usbkeyboard", CSTR) == NULL)
ret = make_devalias(e, "usbkeyboard", CSTR, name, CSTR);
/* set config descriptor 0 to turn on keyboard */
ret = usb_setup(e, usb, usb->addr, USB_CONTROL_ENDPOINT,
UT_WRITE_DEVICE, UR_SET_CONFIG,
0, cfg->configuration_value, 0, 0, NULL);
/* set keyboard to boot protocol (0) */
if (ret == NO_ERROR)
ret = usb_setup(e, usb, usb->addr, USB_CONTROL_ENDPOINT,
UT_WRITE_CLASS_INTERFACE, UR_SET_PROTOCOL,
0, 0, usb->interface, 0, NULL);
if (ret == NO_ERROR)
ret = usb_setup(e, usb, usb->addr, USB_CONTROL_ENDPOINT,
UT_WRITE_CLASS_INTERFACE, UR_SET_IDLE,
0, 0, usb->interface, 0, NULL);
return ret;
}
static void add_device(IMMDevice *device, vector_DevMap *list)
{
LPWSTR devid;
HRESULT hr;
hr = IMMDevice_GetId(device, &devid);
if(SUCCEEDED(hr))
{
DevMap entry;
AL_STRING_INIT(entry.name);
entry.devid = strdupW(devid);
get_device_name(device, &entry.name);
CoTaskMemFree(devid);
TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
VECTOR_PUSH_BACK(*list, entry);
}
}
static void log_header(enum command_type type, const char *msg, struct payload_header *header)
{
const char *dev_name, *cmd_name;
size_t size = sizeof(struct payload_header);
unsigned char *bytes = (unsigned char *)header;
char *header_hex = malloc(size * 3 + 1);
for (size_t i = 0; i < size; i++) {
sprintf(header_hex + i * 3, " %02X", *(bytes + i));
}
dev_name = get_device_name(header);
cmd_name = get_command_name(header);
log_message(type, "%s:%" PRId16 " [%" PRIu16 ":%s:%s]%s", msg, header->payload_size,
header->seq_num, dev_name != NULL ? dev_name : "UNEXPECTED",
cmd_name != NULL ? cmd_name : "UNEXPECTED", header_hex);
free(header_hex);
}
int vpbp_loadexec(char * file, struct SceKernelLoadExecVSHParam * param)
{
int ret;
SEConfig config;
VirtualPBP *vpbp;
int apitype;
const char *loadexec_file;
lock();
vpbp = get_vpbp_by_path(file);
if (vpbp == NULL) {
printk("%s: Unknown file %s in vpbp list\n", __func__, file);
unlock();
return -31;
}
sctrlSEGetConfig(&config);
if(config.chn_iso) {
get_ISO_shortname(vpbp->name, sizeof(vpbp->name), vpbp->name);
}
//set iso file for reboot
sctrlSESetUmdFile(vpbp->name);
//set iso mode for reboot
sctrlSESetBootConfFileIndex(config.umdmode);
sctrlSESetDiscType(PSP_UMD_TYPE_GAME);
//enable high memory on demand
if(config.retail_high_memory) sctrlHENSetMemory(55, 0);
printk("%s: ISO %s, UMD mode %d\n", __func__, vpbp->name, config.umdmode);
//reset and configure reboot parameter
memset(param, 0, sizeof(param));
param->size = sizeof(param);
if (has_prometheus_module(vpbp)) {
printk("%s: prometheus module detected, use EBOOT.OLD\n", __func__);
param->argp = "disc0:/PSP_GAME/SYSDIR/EBOOT.OLD";
} else {
param->argp = "disc0:/PSP_GAME/SYSDIR/EBOOT.BIN";
}
param->args = strlen(param->argp) + 1;
if (psp_model == PSP_GO) {
char devicename[20];
ret = get_device_name(devicename, sizeof(devicename), vpbp->name);
if(ret == 0 && 0 == stricmp(devicename, "ef0:")) {
apitype = 0x125;
} else {
apitype = 0x123;
}
param->key = "umdemu";
loadexec_file = vpbp->name;
} else {
if(config.umdmode == MODE_MARCH33) {
param->key = "game";
} else {
param->key = "umdemu";
}
apitype = 0x120;
loadexec_file = param->argp;
}
//start game image
return sctrlKernelLoadExecVSHWithApitype(apitype, loadexec_file, param);
unlock();
return ret;
}
void osc_get(osc_node *n, int h[], osc_val a[]) {
switch (n->id) {
case OSC_NODE_OSC_VERSION:
get_osc_version(a[0].val.str);break;
case OSC_NODE_OSC_TYPE_REPORTS:
get_osc_type_reports(a[0].val.str);break;
case OSC_NODE_OSC_TYPE_ACCEPTS:
get_osc_type_accepts(a[0].val.str);break;
case OSC_NODE_AVB_SOURCE_HASH_PRESENTATION:
get_avb_source_presentation(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SOURCE_HASH_MAP:
get_avb_source_map(h[0],a[0].val.word_array, &a[0].len);break;
case OSC_NODE_AVB_SOURCE_HASH_DEST:
get_avb_source_dest(h[0],a[0].val.byte_array, &a[0].len);break;
case OSC_NODE_AVB_SOURCE_HASH_FORMAT:
get_avb_source_format(h[0],(enum avb_source_format_t *) &a[0].val.word,&a[1].val.word);break;
case OSC_NODE_AVB_SOURCE_HASH_CHANNELS:
get_avb_source_channels(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SOURCE_HASH_SYNC:
get_avb_source_sync(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SOURCE_HASH_NAME:
get_avb_source_name(h[0],a[0].val.str);break;
case OSC_NODE_AVB_SOURCE_HASH_ID:
get_avb_source_id(h[0],(unsigned int *) a[0].val.word_array);break;
case OSC_NODE_AVB_SOURCE_HASH_VLAN:
get_avb_source_vlan(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SOURCE_HASH_STATE:
get_avb_source_state(h[0],(enum avb_source_state_t *) &a[0].val.word);break;
case OSC_NODE_AVB_SOURCES:
get_avb_sources(&a[0].val.word);break;
case OSC_NODE_AVB_SINKS:
get_avb_sinks(&a[0].val.word);break;
case OSC_NODE_AVB_PTP_GM:
get_avb_ptp_gm(a[0].val.byte_array, &a[0].len);break;
case OSC_NODE_AVB_PTP_PORTS:
get_avb_ptp_ports(&a[0].val.word);break;
case OSC_NODE_AVB_PTP_RATERATIO:
get_avb_ptp_rateratio(&a[0].val.word);break;
case OSC_NODE_AVB_PTP_PORT_HASH_PDELAY:
get_avb_ptp_port_pdelay(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SINK_HASH_CHANNELS:
get_avb_sink_channels(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SINK_HASH_SYNC:
get_avb_sink_sync(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SINK_HASH_NAME:
get_avb_sink_name(h[0],a[0].val.str);break;
case OSC_NODE_AVB_SINK_HASH_VLAN:
get_avb_sink_vlan(h[0],&a[0].val.word);break;
case OSC_NODE_AVB_SINK_HASH_STATE:
get_avb_sink_state(h[0],(enum avb_sink_state_t *) &a[0].val.word);break;
case OSC_NODE_AVB_SINK_HASH_MAP:
get_avb_sink_map(h[0],a[0].val.word_array, &a[0].len);break;
case OSC_NODE_AVB_SINK_HASH_ID:
get_avb_sink_id(h[0],(unsigned int *) a[0].val.word_array);break;
case OSC_NODE_AVB_SINK_HASH_ADDR:
get_avb_sink_addr(h[0],a[0].val.byte_array, &a[0].len);break;
case OSC_NODE_MEDIA_OUT_HASH_NAME:
get_media_out_name(h[0],a[0].val.str);break;
case OSC_NODE_MEDIA_OUT_HASH_TYPE:
get_media_out_type(h[0],a[0].val.str);break;
case OSC_NODE_MEDIA_OUTS:
get_media_outs(&a[0].val.word);break;
case OSC_NODE_MEDIA_INS:
get_media_ins(&a[0].val.word);break;
case OSC_NODE_MEDIA_IN_HASH_NAME:
get_media_in_name(h[0],a[0].val.str);break;
case OSC_NODE_MEDIA_IN_HASH_TYPE:
get_media_in_type(h[0],a[0].val.str);break;
case OSC_NODE_DEVICE_MEDIA_CLOCK_HASH_SOURCE:
get_device_media_clock_source(h[0],&a[0].val.word);break;
case OSC_NODE_DEVICE_MEDIA_CLOCK_HASH_RATE:
get_device_media_clock_rate(h[0],&a[0].val.word);break;
case OSC_NODE_DEVICE_MEDIA_CLOCK_HASH_TYPE:
get_device_media_clock_type(h[0],(enum device_media_clock_type_t *) &a[0].val.word);break;
case OSC_NODE_DEVICE_MEDIA_CLOCK_HASH_STATE:
get_device_media_clock_state(h[0],(enum device_media_clock_state_t *) &a[0].val.word);break;
case OSC_NODE_DEVICE_SYSTEM:
get_device_system(a[0].val.str);break;
case OSC_NODE_DEVICE_IDENTITY_SERIAL:
get_device_identity_serial(a[0].val.str);break;
case OSC_NODE_DEVICE_IDENTITY_VERSION:
get_device_identity_version(a[0].val.str);break;
case OSC_NODE_DEVICE_IDENTITY_VENDOR_ID:
get_device_identity_vendor_id(a[0].val.str);break;
case OSC_NODE_DEVICE_IDENTITY_PRODUCT:
get_device_identity_product(a[0].val.str);break;
case OSC_NODE_DEVICE_IDENTITY_VENDOR:
get_device_identity_vendor(a[0].val.str);break;
case OSC_NODE_DEVICE_NAME:
get_device_name(a[0].val.str);break;
case OSC_NODE_DEVICE_MEDIA_CLOCKS:
get_device_media_clocks(&a[0].val.word);break;
}
}
static dmgt_slice_t *
get_slice(dm_descriptor_t slice, uint32_t blocksize, int *error)
{
dmgt_slice_t *sp;
*error = 0;
sp = (dmgt_slice_t *)calloc(1, sizeof (dmgt_slice_t));
if (sp == NULL) {
*error = -1;
handle_error("out of memory");
} else {
/* Get name */
sp->name = get_device_name(slice, error);
if (!*error) {
nvlist_t *attrs = dm_get_attributes(slice, error);
if (*error) {
handle_error("could not get "
"attributes from slice: %s", sp->name);
} else {
/* Get the size in blocks */
nvpair_t *match = zjni_nvlist_walk_nvpair(
attrs, DM_SIZE, DATA_TYPE_UINT64, NULL);
uint64_t size_blocks;
sp->size = 0;
if (match == NULL ||
nvpair_value_uint64(match, &size_blocks)) {
handle_error("could not get "
"size of slice: %s", sp->name);
*error = 1;
} else {
uint64_t start_blocks;
/* Convert to bytes */
sp->size = blocksize * size_blocks;
/* Get the starting block */
match = zjni_nvlist_walk_nvpair(
attrs, DM_START, DATA_TYPE_UINT64,
NULL);
if (match == NULL ||
nvpair_value_uint64(match,
&start_blocks)) {
handle_error(
"could not get "
"start block of slice: %s",
sp->name);
*error = 1;
} else {
/* Convert to bytes */
sp->start =
blocksize * start_blocks;
/* Set slice use */
get_slice_use(slice, sp->name,
&(sp->used_name),
&(sp->used_by), error);
}
}
}
}
}
if (*error && sp != NULL) {
dmgt_free_slice(sp);
}
return (sp);
}
/*
* Gets a dmgt_disk_t for the given disk dm_descriptor_t.
*
* Results:
*
* 1. Success: error is set to 0 and a dmgt_disk_t is returned
*
* 2. Failure: error is set to -1 and NULL is returned
*/
static dmgt_disk_t *
get_disk(dm_descriptor_t disk, int *error)
{
dmgt_disk_t *dp;
*error = 0;
dp = (dmgt_disk_t *)calloc(1, sizeof (dmgt_disk_t));
if (dp == NULL) {
handle_error("out of memory");
*error = -1;
} else {
/* Get name */
dp->name = get_device_name(disk, error);
if (!*error) {
/* Get aliases */
dp->aliases = get_disk_aliases(disk, dp->name, error);
if (!*error) {
/* Get media */
dm_descriptor_t *media =
dm_get_associated_descriptors(disk,
DM_MEDIA, error);
if (*error != 0 || media == NULL ||
*media == NULL) {
handle_error(
"could not get media from disk %s",
dp->name);
*error = -1;
} else {
/* Get size */
get_disk_size(media[0], dp->name,
&(dp->size), &(dp->blocksize),
error);
if (!*error) {
/* Get free slices */
dp->slices =
get_disk_usable_slices(
media[0], dp->name,
dp->blocksize,
&(dp->in_use), error);
}
dm_free_descriptors(media);
}
}
}
}
if (*error) {
/* Normalize error */
*error = -1;
if (dp != NULL) {
dmgt_free_disk(dp);
dp = NULL;
}
}
return (dp);
}
pfc::string8 output_entry::get_device_name( const GUID & deviceID ) {
pfc::string8 temp;
if (!get_device_name(deviceID, temp)) temp = "[unknown device]";
return std::move(temp);
}
static DWORD CALLBACK MMDevApiMsgProc(void *ptr)
{
ThreadRequest *req = ptr;
IMMDeviceEnumerator *Enumerator;
ALuint deviceCount = 0;
MMDevApiData *data;
ALCdevice *device;
HRESULT hr, cohr;
MSG msg;
TRACE("Starting message thread\n");
cohr = CoInitialize(NULL);
if(FAILED(cohr))
{
WARN("Failed to initialize COM: 0x%08lx\n", cohr);
req->result = cohr;
SetEvent(req->FinishedEvt);
return 0;
}
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(FAILED(hr))
{
WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
CoUninitialize();
req->result = hr;
SetEvent(req->FinishedEvt);
return 0;
}
Enumerator = ptr;
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
TRACE("Starting message loop\n");
while(GetMessage(&msg, NULL, 0, 0))
{
TRACE("Got message %u\n", msg.message);
switch(msg.message)
{
case WM_USER_OpenDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
hr = cohr = S_OK;
if(++deviceCount == 1)
hr = cohr = CoInitialize(NULL);
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(SUCCEEDED(hr))
{
Enumerator = ptr;
if(!data->devid)
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eRender, eMultimedia, &data->mmdev);
else
hr = IMMDeviceEnumerator_GetDevice(Enumerator, data->devid, &data->mmdev);
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
}
if(SUCCEEDED(hr))
hr = IMMDevice_Activate(data->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
if(SUCCEEDED(hr))
{
data->client = ptr;
device->DeviceName = get_device_name(data->mmdev);
}
if(FAILED(hr))
{
if(data->mmdev)
IMMDevice_Release(data->mmdev);
data->mmdev = NULL;
if(--deviceCount == 0 && SUCCEEDED(cohr))
CoUninitialize();
}
req->result = hr;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_ResetDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
req->result = DoReset(device);
SetEvent(req->FinishedEvt);
continue;
case WM_USER_StartDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
ResetEvent(data->NotifyEvent);
hr = IAudioClient_SetEventHandle(data->client, data->NotifyEvent);
if(FAILED(hr))
ERR("Failed to set event handle: 0x%08lx\n", hr);
else
{
hr = IAudioClient_Start(data->client);
if(FAILED(hr))
ERR("Failed to start audio client: 0x%08lx\n", hr);
}
if(SUCCEEDED(hr))
hr = IAudioClient_GetService(data->client, &IID_IAudioRenderClient, &ptr);
if(SUCCEEDED(hr))
{
data->render = ptr;
data->thread = StartThread(MMDevApiProc, device);
if(!data->thread)
{
if(data->render)
IAudioRenderClient_Release(data->render);
data->render = NULL;
IAudioClient_Stop(data->client);
ERR("Failed to start thread\n");
hr = E_FAIL;
}
}
req->result = hr;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_StopDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
if(data->thread)
{
data->killNow = 1;
StopThread(data->thread);
data->thread = NULL;
data->killNow = 0;
IAudioRenderClient_Release(data->render);
data->render = NULL;
IAudioClient_Stop(data->client);
}
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_CloseDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
IAudioClient_Release(data->client);
data->client = NULL;
IMMDevice_Release(data->mmdev);
data->mmdev = NULL;
if(--deviceCount == 0)
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_Enumerate:
req = (ThreadRequest*)msg.wParam;
hr = cohr = S_OK;
if(++deviceCount == 1)
hr = cohr = CoInitialize(NULL);
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(SUCCEEDED(hr))
{
EDataFlow flowdir;
DevMap **devlist;
ALuint *numdevs;
ALuint i;
Enumerator = ptr;
if(msg.lParam == CAPTURE_DEVICE_PROBE)
{
flowdir = eCapture;
devlist = &CaptureDeviceList;
numdevs = &NumCaptureDevices;
}
else
{
flowdir = eRender;
devlist = &PlaybackDeviceList;
numdevs = &NumPlaybackDevices;
}
for(i = 0;i < *numdevs;i++)
{
free((*devlist)[i].name);
free((*devlist)[i].devid);
}
free(*devlist);
*devlist = NULL;
*numdevs = 0;
*devlist = ProbeDevices(Enumerator, flowdir, numdevs);
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
}
if(--deviceCount == 0 && SUCCEEDED(cohr))
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
default:
ERR("Unexpected message: %u\n", msg.message);
continue;
}
}
TRACE("Message loop finished\n");
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult err;
DFBSurfaceDescription sdsc;
DFBFontDescription fdsc;
const char *fontfile = FONTDIR"/decker.ttf";
int n;
DeviceInfo *devices = NULL;
DFBCHECK(DirectFBInit( &argc, &argv ));
DirectFBSetOption ("bg-none", NULL);
/* create the super interface */
DFBCHECK(DirectFBCreate( &dfb ));
/* create a list of input devices */
dfb->EnumInputDevices( dfb, enum_input_device, &devices );
/* create an event buffer for all devices */
DFBCHECK(dfb->CreateInputEventBuffer( dfb, DICAPS_ALL,
DFB_FALSE, &events ));
/* set our cooperative level to DFSCL_FULLSCREEN
for exclusive access to the primary layer */
dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );
/* get the primary surface, i.e. the surface of the
primary layer we have exclusive access to */
sdsc.flags = DSDESC_CAPS;
sdsc.caps = DSCAPS_PRIMARY | DSCAPS_DOUBLE;
DFBCHECK(dfb->CreateSurface( dfb, &sdsc, &primary ));
primary->GetSize( primary, &screen_width, &screen_height );
mouse_x = screen_width / 2;
mouse_y = screen_height / 2;
fdsc.flags = DFDESC_HEIGHT;
fdsc.height = screen_width / 30;
DFBCHECK(dfb->CreateFont( dfb, fontfile, &fdsc, &font_small ));
fdsc.height = screen_width / 20;
DFBCHECK(dfb->CreateFont( dfb, fontfile, &fdsc, &font_normal ));
fdsc.height = screen_width / 10;
DFBCHECK(dfb->CreateFont( dfb, fontfile, &fdsc, &font_large ));
primary->Clear( primary, 0, 0, 0, 0 );
primary->SetFont( primary, font_normal );
primary->SetColor( primary, 0x60, 0x60, 0x60, 0xFF );
primary->DrawString( primary, "Press any key to continue.", -1,
screen_width/2, screen_height/2, DSTF_CENTER );
primary->Flip( primary, NULL, 0 );
keys_image = load_image( IMGDIR "/gnu-keys.png" );
mouse_image = load_image( IMGDIR "/gnome-mouse.png" );
if (events->WaitForEventWithTimeout( events, 10, 0 ) == DFB_TIMEOUT) {
primary->Clear( primary, 0, 0, 0, 0 );
primary->DrawString( primary, "Timed out.", -1,
screen_width/2, screen_height/2, DSTF_CENTER );
primary->Flip( primary, NULL, 0 );
primary->Clear( primary, 0, 0, 0, 0 );
sleep( 1 );
}
else {
DFBInputDeviceKeySymbol last_symbol = DIKS_NULL;
while (1) {
DFBInputEvent evt;
while (events->GetEvent( events, DFB_EVENT(&evt) ) == DFB_OK) {
const char *device_name;
DFBInputDeviceTypeFlags device_type;
primary->Clear( primary, 0, 0, 0, 0 );
device_name = get_device_name( devices, evt.device_id );
device_type = get_device_type( devices, evt.device_id );
show_event( device_name, device_type, &evt );
primary->Flip( primary, NULL, 0 );
}
if (evt.type == DIET_KEYRELEASE) {
if ((last_symbol == DIKS_ESCAPE || last_symbol == DIKS_EXIT) &&
(evt.key_symbol == DIKS_ESCAPE || evt.key_symbol == DIKS_EXIT))
break;
last_symbol = evt.key_symbol;
}
events->WaitForEvent( events );
}
}
while (devices) {
DeviceInfo *next = devices->next;
free( devices );
devices = next;
}
/* release our interfaces to shutdown DirectFB */
if (keys_image)
keys_image->Release( keys_image );
if (mouse_image)
mouse_image->Release( mouse_image );
font_small->Release( font_small );
font_normal->Release( font_normal );
font_large->Release( font_large );
primary->Release( primary );
events->Release( events );
dfb->Release( dfb );
return 0;
}
/*******************************************************************************
* Initialize winPCap interface.
*/
int
pcap_init()
{
pcap_if_t *alldevs = NULL;
pcap_if_t *device = NULL;
pcap_if_t *found_device = NULL;
int exit_code = 0;
pcap_t *adhandle = NULL;
char errbuf[PCAP_ERRBUF_SIZE];
u_int netmask;
char packet_filter[0x100];
struct bpf_program fcode;
co_snprintf(packet_filter, sizeof(packet_filter),
"(ether dst %s) or (ether broadcast or multicast) or (ip broadcast or multicast)",
daemon_parameters->mac_address);
/* Retrieve the device list */
if (pcap_findalldevs(&alldevs, errbuf) == -1) {
co_terminal_print("Error in pcap_findalldevs: %s\n", errbuf);
exit_code = -1;
goto pcap_out;
}
if (daemon_parameters->name_specified == PTRUE)
co_terminal_print("Looking for interface \"%s\"\n", daemon_parameters->interface_name);
else
co_terminal_print("Auto selecting name for bridged interface\n");
device = alldevs;
char name_data[256];
char connection_name_data[256];
while (device) {
memset(connection_name_data, 0, sizeof(connection_name_data));
snprintf(name_data, sizeof(name_data), "%s", device->name+(sizeof(PCAP_NAME_HDR) - 1));
get_device_name(name_data, sizeof(name_data),
connection_name_data, sizeof(connection_name_data));
if (*connection_name_data != 0) {
co_terminal_print("Checking connection: %s\n", connection_name_data);
if (daemon_parameters->name_specified == PTRUE) {
/*
If an exact match exists, over-ride any found device,
setting exact match device to it.
*/
if (strcmp(connection_name_data, daemon_parameters->interface_name) == 0) {
found_device = device;
break;
}
/*
Do an partial search, if partial search is found,
set this device as he found device, but continue
looping through devices.
*/
if (found_device == NULL &&
strstr(connection_name_data, daemon_parameters->interface_name) != NULL) {
found_device = device;
}
} else {
/*
If no name specified and network has an address,
autoselect first device.
*/
if (device->addresses) {
found_device = device;
break;
}
}
}
else {
co_terminal_print("Adapter %s doesn't have a connection\n", device->description);
}
device = device->next;
}
if (found_device == NULL) {
co_terminal_print("colinux-bridged-net-daemon: No matching adapter\n");
exit_code = -1;
goto pcap_out_close;
}
device = found_device;
/* Open the first adapter. */
if ((adhandle = pcap_open_live(device->name, // name of the device
65536, // captures entire packet.
1, // promiscuous mode
1, // read timeout
errbuf // error buffer
)) == NULL) {
co_terminal_print("Unable to open the adapter.\n");
exit_code = -1;
goto pcap_out_close;
}
/* Check the link layer. We support only Ethernet because coLinux
* only talks 802.3 so far.
*/
if (pcap_datalink(adhandle) != DLT_EN10MB) {
co_terminal_print
("This program works only on 802.3 Ethernet networks.\n");
exit_code = -1;
goto pcap_out_close;
}
if (device->addresses != NULL) {
/* Retrieve the mask of the first address of the interface */
netmask =
((struct sockaddr_in *) (device->addresses->netmask))->sin_addr.
S_un.S_addr;
} else {
/* If the interface is without addresses we suppose to be in a C
* class network
*/
netmask = 0xffffff;
}
//compile the filter
if (pcap_compile(adhandle, &fcode, packet_filter, 1, netmask) < 0) {
co_terminal_print
("Unable to compile the packet filter. Check the syntax.\n");
exit_code = -1;
goto pcap_out_close;
}
//set the filter
if (pcap_setfilter(adhandle, &fcode) < 0) {
co_terminal_print("Error setting the filter.\n");
exit_code = -1;
goto pcap_out_close;
}
co_terminal_print("Bridged listening on: %s...\n", device->description);
co_terminal_print("Bridged listening for: %s\n", packet_filter);
pcap_packet.adhandle = adhandle;
pcap_out_close:
// At this point, we don't need any more the device list. Free it
pcap_freealldevs(alldevs);
pcap_out:
return exit_code;
}
int main(int argc,char *argv[])
{
dasdfmt_info_t info;
volume_label_t vlabel;
char old_volser[7];
char dev_filename[PATH_MAX];
char str[ERR_LENGTH];
char buf[7];
char *blksize_param_str = NULL;
char *reqsize_param_str = NULL;
char *hashstep_str = NULL;
int rc, index;
/* Establish a handler for interrupt signals. */
signal (SIGTERM, program_interrupt_signal);
signal (SIGINT, program_interrupt_signal);
signal (SIGQUIT, program_interrupt_signal);
/******************* initialization ********************/
prog_name = argv[0];
/* set default values */
init_info(&info);
vtoc_volume_label_init(&vlabel);
format_params.blksize = DEFAULT_BLOCKSIZE;
format_params.intensity = DASD_FMT_INT_COMPAT;
/*************** parse parameters **********************/
while (1)
{
rc=getopt_long(argc, argv, dasdfmt_getopt_string,
dasdfmt_getopt_long_options, &index);
switch (rc)
{
case 'F':
info.force=1;
break;
case 'C':
format_params.intensity |= DASD_FMT_INT_COMPAT;
break;
case 'd' :
if (strncmp(optarg,"cdl",3)==0)
{
format_params.intensity |= DASD_FMT_INT_COMPAT;
if (info.writenolabel)
{
printf("WARNING: using the cdl " \
"format without writing a " \
"label doesn't make much " \
"sense!\n");
exit(1);
}
}
else if (strncmp(optarg,"ldl",3)==0)
format_params.intensity &= ~DASD_FMT_INT_COMPAT;
else
{
printf("%s is not a valid option!\n", optarg);
exit(1);
}
break;
case 'y':
info.withoutprompt=1;
break;
case 'z':
format_params.intensity |= DASD_FMT_INT_FMT_NOR0;
break;
case 't':
info.testmode=1;
break;
case 'p':
if (!(info.print_hashmarks || info.print_percentage))
info.print_progressbar = 1;
break;
case 'm':
if (!(info.print_progressbar || info.print_percentage))
{
hashstep_str=optarg;
info.print_hashmarks=1;
}
break;
case 'P':
if (!(info.print_hashmarks || info.print_progressbar))
info.print_percentage = 1;
break;
case 'v':
info.verbosity=1;
break;
case 'h':
exit_usage(0);
case 'V':
print_version();
exit(0);
case 'l':
strncpy(buf, optarg, 6);
if (check_volser(buf, 0) < 0)
break;
vtoc_volume_label_set_volser(&vlabel,buf);
info.labelspec=1;
break;
case 'L':
if (format_params.intensity & DASD_FMT_INT_COMPAT)
{
printf("WARNING: using the cdl format " \
"without writing a label doesn't " \
"make much sense!\n");
exit(1);
}
info.writenolabel=1;
break;
case 'b' :
blksize_param_str=optarg;
info.blksize_specified=1;
break;
case 'r':
reqsize_param_str = optarg;
info.reqsize_specified = 1;
break;
case 'f' :
strncpy(dev_filename, optarg, PATH_MAX);
info.node_specified=1;
break;
case 'k' :
info.keep_volser=1;
break;
case -1:
/* End of options string - start of devices list */
info.device_id = optind;
break;
default:
ERRMSG_EXIT(EXIT_MISUSE,
"Try '%s --help' for more"
" information.\n",prog_name);
}
if (rc==-1) break; // exit loop if finished
}
CHECK_SPEC_MAX_ONCE(info.blksize_specified, "blocksize");
CHECK_SPEC_MAX_ONCE(info.labelspec, "label");
CHECK_SPEC_MAX_ONCE(info.writenolabel, "omit-label-writing flag");
if (info.blksize_specified)
PARSE_PARAM_INTO(format_params.blksize,blksize_param_str,10,
"blocksize");
if (info.reqsize_specified) {
PARSE_PARAM_INTO(reqsize, reqsize_param_str, 10, "requestsize");
if (reqsize < 1 || reqsize > 255)
ERRMSG_EXIT(EXIT_FAILURE,
"invalid requestsize %d specified\n",
reqsize);
} else
reqsize = DEFAULT_REQUESTSIZE;
if (info.print_hashmarks)
PARSE_PARAM_INTO(info.hashstep, hashstep_str,10,"hashstep");
get_device_name(&info, dev_filename, argc, argv);
if (!info.blksize_specified)
format_params = ask_user_for_blksize(format_params);
if (info.keep_volser) {
if(info.labelspec) {
ERRMSG_EXIT(EXIT_MISUSE,"%s: The -k and -l options are mutually exclusive\n",
prog_name);
}
if(!(format_params.intensity & DASD_FMT_INT_COMPAT)) {
printf("WARNING: VOLSER cannot be kept " \
"when using the ldl format!\n");
exit(1);
}
if(dasdfmt_get_volser(info.devname, old_volser) == 0)
vtoc_volume_label_set_volser(&vlabel, old_volser);
else
ERRMSG_EXIT(EXIT_FAILURE,"%s: VOLSER not found on device %s\n",
prog_name, info.devname);
}
if ((filedes = open(info.devname, O_RDWR)) == -1)
ERRMSG_EXIT(EXIT_FAILURE,"%s: Unable to open device %s: %s\n",
prog_name, info.devname, strerror(errno));
check_disk(&info);
if (check_param(str, ERR_LENGTH, &format_params) < 0)
ERRMSG_EXIT(EXIT_MISUSE, "%s: %s\n", prog_name, str);
do_format_dasd(&info, &format_params, &vlabel);
if (close(filedes) != 0)
ERRMSG("%s: error during close: %s\ncontinuing...\n",
prog_name, strerror(errno));
return 0;
}
