static int
usbReapUrb (
UsbDevice *device,
int wait
) {
UsbDeviceExtension *devx = device->extension;
if (usbOpenUsbfsFile(devx)) {
struct usbdevfs_urb *urb;
if (ioctl(devx->usbfsFile,
wait? USBDEVFS_REAPURB: USBDEVFS_REAPURBNDELAY,
&urb) != -1) {
if (urb) {
UsbEndpoint *endpoint;
if ((endpoint = usbGetEndpoint(device, urb->endpoint))) {
UsbEndpointExtension *eptx = endpoint->extension;
if (enqueueItem(eptx->completedRequests, urb)) return 1;
logSystemError("USB completed request enqueue");
free(urb);
}
} else {
errno = EAGAIN;
}
} else {
if (wait || (errno != EAGAIN)) logSystemError("USB URB reap");
}
}
return 0;
}
KeyboardInstanceObject *
newKeyboardInstanceObject (KeyboardMonitorObject *kmo) {
KeyboardInstanceObject *kio;
unsigned int count = BITMASK_ELEMENT_COUNT(keyCodeCount, BITMASK_ELEMENT_SIZE(unsigned char));
size_t size = sizeof(*kio) + count;
if ((kio = malloc(size))) {
memset(kio, 0, size);
kio->kmo = kmo;
kio->actualProperties = anyKeyboard;
kio->events.buffer = NULL;
kio->events.size = 0;
kio->events.count = 0;
kio->deferred.modifiersOnly = 0;
kio->deferred.size = count;
if (newKeyboardInstanceExtension(&kio->kix)) {
if (enqueueItem(kmo->instanceQueue, kio)) {
return kio;
}
destroyKeyboardInstanceExtension(kio->kix);
}
free(kio);
} else {
logMallocError();
}
return NULL;
}
static int
usbAddHostDevice (const char *path) {
int ok = 0;
UsbHostDevice *host;
if ((host = malloc(sizeof(*host)))) {
if ((host->usbfsPath = strdup(path))) {
host->sysfsPath = usbMakeSysfsPath(host->usbfsPath);
if (!usbReadHostDeviceDescriptor(host)) {
ok = 1;
} else if (enqueueItem(usbHostDevices, host)) {
return 1;
}
if (host->sysfsPath) free(host->sysfsPath);
free(host->usbfsPath);
} else {
logSystemError("strdup");
}
free(host);
} else {
logMallocError();
}
return ok;
}
void ScrobblerSubmitter::readSubmitQueue()
{
m_savePath = Amarok::saveLocation() + "submit.xml";
QFile file( m_savePath );
if ( !file.open( IO_ReadOnly ) )
{
debug() << "Couldn't open file: " << m_savePath << endl;
return;
}
QTextStream stream( &file );
stream.setEncoding( QTextStream::UnicodeUTF8 );
QDomDocument d;
if( !d.setContent( stream.read() ) )
{
debug() << "Couldn't read file: " << m_savePath << endl;
return;
}
uint last = 0;
if( d.namedItem( "submit" ).isElement() )
last = d.namedItem( "submit" ).toElement().attribute( "lastSubmissionFinishTime" ).toUInt();
if(last && last > m_lastSubmissionFinishTime)
m_lastSubmissionFinishTime = last;
const QString ITEM( "item" ); //so we don't construct these QStrings all the time
for( QDomNode n = d.namedItem( "submit" ).firstChild(); !n.isNull() && n.nodeName() == ITEM; n = n.nextSibling() )
enqueueItem( new SubmitItem( n.toElement() ) );
m_submitQueue.first();
}
UsbEndpoint *
usbGetEndpoint (UsbDevice *device, unsigned char endpointAddress) {
UsbEndpoint *endpoint;
const UsbEndpointDescriptor *descriptor;
if ((endpoint = findItem(device->endpoints, usbTestEndpoint, &endpointAddress))) return endpoint;
if ((descriptor = usbEndpointDescriptor(device, endpointAddress))) {
{
const char *direction;
const char *transfer;
switch (USB_ENDPOINT_DIRECTION(descriptor)) {
default: direction = "?"; break;
case UsbEndpointDirection_Input: direction = "in"; break;
case UsbEndpointDirection_Output: direction = "out"; break;
}
switch (USB_ENDPOINT_TRANSFER(descriptor)) {
default: transfer = "?"; break;
case UsbEndpointTransfer_Control: transfer = "ctl"; break;
case UsbEndpointTransfer_Isochronous: transfer = "iso"; break;
case UsbEndpointTransfer_Bulk: transfer = "blk"; break;
case UsbEndpointTransfer_Interrupt: transfer = "int"; break;
}
logMessage(LOG_DEBUG, "USB: ept=%02X dir=%s xfr=%s pkt=%d ivl=%dms",
descriptor->bEndpointAddress, direction, transfer,
getLittleEndian16(descriptor->wMaxPacketSize),
descriptor->bInterval);
}
if ((endpoint = malloc(sizeof(*endpoint)))) {
memset(endpoint, 0, sizeof(*endpoint));
endpoint->device = device;
endpoint->descriptor = descriptor;
switch (USB_ENDPOINT_DIRECTION(endpoint->descriptor)) {
case UsbEndpointDirection_Input:
endpoint->direction.input.pending = NULL;
endpoint->direction.input.completed = NULL;
endpoint->direction.input.buffer = NULL;
endpoint->direction.input.length = 0;
endpoint->direction.input.asynchronous = 0;
break;
}
endpoint->extension = NULL;
if (usbAllocateEndpointExtension(endpoint)) {
if (enqueueItem(device->endpoints, endpoint)) return endpoint;
usbDeallocateEndpointExtension(endpoint->extension);
}
free(endpoint);
}
}
return NULL;
}
int
usbAddInputFilter (UsbDevice *device, UsbInputFilter filter) {
UsbInputFilterEntry *entry;
if ((entry = malloc(sizeof(*entry)))) {
entry->filter = filter;
if (enqueueItem(device->inputFilters, entry)) return 1;
free(entry);
}
return 0;
}
/**
* Sets item for submission to Audioscrobbler. Actual submission
* depends on things like (is scrobbling enabled, are Audioscrobbler
* profile details filled in etc).
*/
void ScrobblerSubmitter::submitItem( SubmitItem* item )
{
if ( m_scrobblerEnabled ) {
enqueueItem( item );
if ( item->playStartTime() == 0 )
m_holdFakeQueue = true; // hold on to fake queue until we get it all and can compute when to submit
else if ( !schedule( false ) )
announceSubmit( item, 1, false ); // couldn't perform submit immediately, let user know
}
}
static int
addKeyEvent (KeyEvent *event) {
Queue *queue = getKeyEventQueue(1);
if (queue) {
if (enqueueItem(queue, event)) {
return 1;
}
}
return 0;
}
static Element *
getFunctionElement (FileDescriptor fileDescriptor, const FunctionMethods *methods, int create) {
Queue *functions = getFunctionQueue(create);
if (functions) {
{
FunctionKey key = {
.fileDescriptor = fileDescriptor,
.methods = methods
};
{
Element *element = findElement(functions, testFunctionEntry, &key);
if (element) return element;
}
}
if (create) {
FunctionEntry *function;
if ((function = malloc(sizeof(*function)))) {
function->fileDescriptor = fileDescriptor;
function->methods = methods;
if ((function->operations = newQueue(deallocateOperationEntry, NULL))) {
{
static AsyncQueueMethods methods = {
.cancelRequest = cancelOperation
};
setQueueData(function->operations, &methods);
}
if (methods->beginFunction) methods->beginFunction(function);
{
Element *element = enqueueItem(functions, function);
if (element) return element;
}
deallocateQueue(function->operations);
}
free(function);
} else {
/**
* Enqueues items associated with the job. This is used when the job
* has failed (e.g. network problems).
*/
void ScrobblerSubmitter::enqueueJob( KIO::Job* job )
{
SubmitItem *lastItem = 0;
SubmitItem *item = 0;
int counter = 0;
while ( ( item = m_ongoingSubmits.take( job ) ) != 0 )
{
counter++;
lastItem = item;
enqueueItem( item );
}
m_submitQueue.first();
if( lastItem )
announceSubmit( lastItem, counter, false );
schedule( true ); // arrange to flush queue after failure
}
static void
cpbPushContent (const wchar_t *characters, size_t length) {
if (length > 0) {
Queue *queue = cpbGetHistoryQueue(1);
if (queue) {
Element *element = getQueueTail(queue);
if (element) {
const HistoryEntry *entry = getElementItem(element);
if (length == entry->length) {
if (wmemcmp(characters, entry->characters, length) == 0) {
return;
}
}
}
{
HistoryEntry *entry;
if ((entry = malloc(sizeof(*entry)))) {
if ((entry->characters = cpbAllocateCharacters(length))) {
wmemcpy(entry->characters, characters, length);
entry->length = length;
if (enqueueItem(queue, entry)) {
return;
}
free(entry->characters);
} else {
logMallocError();
}
free(entry);
} else {
logMallocError();
}
}
}
}
}
static int
enqueueSpeech (const unsigned char *bytes, int length, int tags) {
if (startSynthesisThread()) {
SpeechSegment *segment;
if ((segment = allocateSpeechSegment(bytes, length, tags))) {
Element *element;
pthread_mutex_lock(&speechMutex);
element = enqueueItem(speechQueue, segment);
if (element) {
pthread_cond_signal(&speechConditional);
pthread_mutex_unlock(&speechMutex);
return 1;
}
pthread_mutex_unlock(&speechMutex);
deallocateSpeechSegment(segment);
}
}
return 0;
}
static BluetoothDeviceEntry *
bthGetDeviceEntry (uint64_t bda, int add) {
if (bthInitializeDeviceQueue()) {
BluetoothDeviceEntry *entry = findItem(bluetoothDeviceQueue, bthTestDeviceEntry, &bda);
if (entry) return entry;
if (add) {
if ((entry = malloc(sizeof(*entry)))) {
entry->bda = bda;
entry->connectError = 0;
entry->deviceName = NULL;
if (enqueueItem(bluetoothDeviceQueue, entry)) return entry;
free(entry);
} else {
logMallocError();
}
}
}
return NULL;
}
int
enqueueCommand (int command) {
if (command != EOF) {
Queue *queue = getCommandQueue(1);
if (queue) {
CommandQueueItem *item = malloc(sizeof(CommandQueueItem));
if (item) {
item->command = command;
if (enqueueItem(queue, item)) {
if (getQueueSize(queue) == 1) setExecuteCommandAlarm(NULL);
return 1;
}
free(item);
}
}
}
return 0;
}
static Element *
newAlarmElement (const void *parameters) {
const AlarmElementParameters *aep = parameters;
Queue *alarms = getAlarmQueue(1);
if (alarms) {
AlarmEntry *alarm;
if ((alarm = malloc(sizeof(*alarm)))) {
memset(alarm, 0, sizeof(*alarm));
alarm->time = *aep->time;
alarm->callback = aep->callback;
alarm->data = aep->data;
alarm->active = 0;
alarm->cancel = 0;
alarm->reschedule = 0;
{
Element *element = enqueueItem(alarms, alarm);
if (element) {
logSymbol(LOG_CATEGORY(ASYNC_EVENTS), aep->callback, "alarm added");
return element;
}
}
free(alarm);
} else {
logMallocError();
}
}
return NULL;
}
UsbEndpoint *
usbGetEndpoint (UsbDevice *device, unsigned char endpointAddress) {
UsbEndpoint *endpoint;
const UsbEndpointDescriptor *descriptor;
if ((endpoint = findItem(device->endpoints, usbTestEndpoint, &endpointAddress))) return endpoint;
if ((descriptor = usbEndpointDescriptor(device, endpointAddress))) {
{
const char *direction;
const char *transfer;
switch (USB_ENDPOINT_DIRECTION(descriptor)) {
default: direction = "?"; break;
case UsbEndpointDirection_Input: direction = "in"; break;
case UsbEndpointDirection_Output: direction = "out"; break;
}
switch (USB_ENDPOINT_TRANSFER(descriptor)) {
default: transfer = "?"; break;
case UsbEndpointTransfer_Control: transfer = "ctl"; break;
case UsbEndpointTransfer_Isochronous: transfer = "iso"; break;
case UsbEndpointTransfer_Bulk: transfer = "blk"; break;
case UsbEndpointTransfer_Interrupt: transfer = "int"; break;
}
logMessage(LOG_CATEGORY(USB_IO), "ept=%02X dir=%s xfr=%s pkt=%d ivl=%dms",
descriptor->bEndpointAddress, direction, transfer,
getLittleEndian16(descriptor->wMaxPacketSize),
descriptor->bInterval);
}
if ((endpoint = malloc(sizeof(*endpoint)))) {
memset(endpoint, 0, sizeof(*endpoint));
endpoint->device = device;
endpoint->descriptor = descriptor;
endpoint->extension = NULL;
endpoint->prepare = NULL;
switch (USB_ENDPOINT_DIRECTION(endpoint->descriptor)) {
case UsbEndpointDirection_Input:
endpoint->direction.input.pending.requests = NULL;
endpoint->direction.input.pending.alarm = NULL;
endpoint->direction.input.pending.delay = 0;
endpoint->direction.input.completed.request = NULL;
endpoint->direction.input.completed.buffer = NULL;
endpoint->direction.input.completed.length = 0;
endpoint->direction.input.pipe.input = INVALID_FILE_DESCRIPTOR;
endpoint->direction.input.pipe.output = INVALID_FILE_DESCRIPTOR;
endpoint->direction.input.pipe.monitor = NULL;
endpoint->direction.input.pipe.error = 0;
break;
}
if (usbAllocateEndpointExtension(endpoint)) {
if (enqueueItem(device->endpoints, endpoint)) {
if (device->disableEndpointReset) {
logMessage(LOG_CATEGORY(USB_IO), "endpoint reset disabled");
} else {
usbClearHalt(device, endpoint->descriptor->bEndpointAddress);
}
if (!endpoint->prepare || endpoint->prepare(endpoint)) return endpoint;
deleteItem(device->endpoints, endpoint);
}
usbDeallocateEndpointExtension(endpoint->extension);
usbDestroyInputPipe(endpoint);
}
free(endpoint);
}
}
return NULL;
}
void *
usbReapResponse (
UsbDevice *device,
unsigned char endpointAddress,
UsbResponse *response,
int wait
) {
UsbEndpoint *endpoint;
if ((endpoint = usbGetEndpoint(device, endpointAddress))) {
UsbEndpointExtension *eptx = endpoint->extension;
struct timeval timeout;
UsbAsynchronousRequest *request;
timeout.tv_sec = 0;
timeout.tv_usec = 0;
while (!(request = dequeueItem(eptx->requests))) {
aio_result_t *result;
doWait:
if ((int)(result = aiowait(wait? NULL: &timeout)) == -1) {
if (errno == EINTR) goto doWait;
if (errno != EINVAL) {
logSystemError("USB asynchronous wait");
return NULL;
}
result = NULL;
}
if (!result) {
errno = EAGAIN;
return NULL;
}
request = (UsbAsynchronousRequest *)result;
{
UsbEndpoint *ep = request->endpoint;
UsbEndpointExtension *epx = ep->extension;
if (!enqueueItem(epx->requests, request)) {
logSystemError("USB asynchronous enqueue");
}
}
}
response->context = request->context;
response->buffer = request->buffer;
response->size = request->length;
response->count = request->result.aio_return;
response->error = request->result.aio_errno;
if (response->count == -1) {
errno = response->error;
logSystemError("USB asynchronous completion");
} else {
switch (USB_ENDPOINT_DIRECTION(endpoint->descriptor)) {
case UsbEndpointDirection_Input:
if (!usbApplyInputFilters(endpoint, response->buffer, response->size, &response->count)) {
response->error = EIO;
response->count = -1;
}
break;
}
}
return request;
}
return NULL;
}
