void ProtoSlaveCurrentBuilds::addBuildToSlave(Management *management, int buildID, QString buildName){ if(management == 0) return; QObject *myParent = this->parent(); if(myParent == 0) return; ProtocolHandler *handler = dynamic_cast<ProtocolHandler*>(myParent); if(handler == 0){ return; } management->addBuildToSlave(handler->getMachine()->getMachineID(), buildID, buildName); }
int UdpHandler::initContext(ProtocolHandlerContext *handlers) { ProtocolHandler *h; if (ProtocolHandler::initContext(handlers) < 0) return -1; if (!handlers) return -1; for (h = handlers->getFirstHandler(); h; h = handlers->getNextHandler(h)) { if (h->identify() == SIPHandler::id) sip = h; if (h->identify() == DNSHandler::id) dns = h; if (sip && dns) break; } return 0; }
static status_t usb_hid_open(const char *name, uint32 flags, void **cookie) { TRACE("open(%s, %lu, %p)\n", name, flags, cookie); mutex_lock(&sDriverLock); ProtocolHandler *handler = (ProtocolHandler *)gDeviceList->FindDevice(name); if (handler == NULL) { mutex_unlock(&sDriverLock); return B_ENTRY_NOT_FOUND; } status_t result = handler->Open(flags); *cookie = handler; mutex_unlock(&sDriverLock); return result; }
status_t usb_hid_device_removed(void *cookie) { mutex_lock(&sDriverLock); int32 parentCookie = (int32)cookie; TRACE("device_removed(%ld)\n", parentCookie); for (int32 i = 0; i < gDeviceList->CountDevices(); i++) { ProtocolHandler *handler = (ProtocolHandler *)gDeviceList->DeviceAt(i); if (!handler) continue; HIDDevice *device = handler->Device(); if (device->ParentCookie() != parentCookie) continue; // this handler's device belongs to the one removed if (device->IsOpen()) { // the device and it's handlers will be deleted in the free hook device->Removed(); break; } // remove all the handlers for (uint32 i = 0;; i++) { handler = device->ProtocolHandlerAt(i); if (handler == NULL) break; gDeviceList->RemoveDevice(NULL, handler); } delete device; break; } mutex_unlock(&sDriverLock); return B_OK; }
int MainProtocolHandler::doRequest( int argc, const char** argv, std::ostream& out) { m_command.clear(); m_commandtag.clear(); if (argc) { bool has_commandtag = false; bool has_command = false; for (int ii=0; ii<argc; ++ii) { if (argv[ii][0] == '&') { if (has_commandtag) { out << "ERR more than one command tag" << endl(); return stateidx(); } has_commandtag = true; m_commandtag.append( argv[ii]+1); } else { if (has_command) { out << "ERR to many arguments" << endl(); return stateidx(); } has_command = true; m_command.append( argv[ii]); } } } ProtocolHandler* ch = (ProtocolHandler*)new cmdbind::DoctypeFilterProtocolHandler(); ch->setExecContext( execContext()); delegateProcessing<&MainProtocolHandler::endDoctypeDetection>( ch); return stateidx(); }
status_t usb_hid_device_added(usb_device device, void **cookie) { TRACE("device_added()\n"); const usb_device_descriptor *deviceDescriptor = gUSBModule->get_device_descriptor(device); TRACE("vendor id: 0x%04x; product id: 0x%04x\n", deviceDescriptor->vendor_id, deviceDescriptor->product_id); // wacom devices are handled by the dedicated wacom driver if (deviceDescriptor->vendor_id == USB_VENDOR_WACOM) return B_ERROR; const usb_configuration_info *config = gUSBModule->get_nth_configuration(device, USB_DEFAULT_CONFIGURATION); if (config == NULL) { TRACE_ALWAYS("cannot get default configuration\n"); return B_ERROR; } // ensure default configuration is set status_t result = gUSBModule->set_configuration(device, config); if (result != B_OK) { TRACE_ALWAYS("set_configuration() failed 0x%08lx\n", result); return result; } // refresh config config = gUSBModule->get_configuration(device); if (config == NULL) { TRACE_ALWAYS("cannot get current configuration\n"); return B_ERROR; } bool devicesFound = false; int32 parentCookie = atomic_add(&sParentCookie, 1); for (size_t i = 0; i < config->interface_count; i++) { const usb_interface_info *interface = config->interface[i].active; uint8 interfaceClass = interface->descr->interface_class; TRACE("interface %lu: class: %u; subclass: %u; protocol: %u\n", i, interfaceClass, interface->descr->interface_subclass, interface->descr->interface_protocol); if (interfaceClass == USB_INTERFACE_CLASS_HID) { mutex_lock(&sDriverLock); HIDDevice *hidDevice = new(std::nothrow) HIDDevice(device, config, i); if (hidDevice != NULL && hidDevice->InitCheck() == B_OK) { hidDevice->SetParentCookie(parentCookie); for (uint32 i = 0;; i++) { ProtocolHandler *handler = hidDevice->ProtocolHandlerAt(i); if (handler == NULL) break; // As devices can be un- and replugged at will, we cannot // simply rely on a device count. If there is just one // keyboard, this does not mean that it uses the 0 name. // There might have been two keyboards and the one using 0 // might have been unplugged. So we just generate names // until we find one that is not currently in use. int32 index = 0; char pathBuffer[128]; const char *basePath = handler->BasePath(); while (true) { sprintf(pathBuffer, "%s%ld", basePath, index++); if (gDeviceList->FindDevice(pathBuffer) == NULL) { // this name is still free, use it handler->SetPublishPath(strdup(pathBuffer)); break; } } gDeviceList->AddDevice(handler->PublishPath(), handler); devicesFound = true; } } else delete hidDevice; mutex_unlock(&sDriverLock); } } if (!devicesFound) return B_ERROR; *cookie = (void *)parentCookie; return B_OK; }
void TabletProtocolHandler::AddHandlers(HIDDevice &device, HIDCollection &collection, ProtocolHandler *&handlerList) { bool supported = false; switch (collection.UsagePage()) { case B_HID_USAGE_PAGE_GENERIC_DESKTOP: { switch (collection.UsageID()) { case B_HID_UID_GD_MOUSE: case B_HID_UID_GD_POINTER: // NOTE: Maybe it is supported if X-axis and Y-axis are // absolute. This is determined below by scanning the // report items for absolute X and Y axis. supported = true; break; } break; } case B_HID_USAGE_PAGE_DIGITIZER: { switch (collection.UsageID()) { case B_HID_UID_DIG_DIGITIZER: case B_HID_UID_DIG_PEN: case B_HID_UID_DIG_LIGHT_PEN: case B_HID_UID_DIG_TOUCH_SCREEN: case B_HID_UID_DIG_TOUCH_PAD: case B_HID_UID_DIG_WHITE_BOARD: TRACE("found tablet/digitizer\n"); supported = true; break; } break; } } if (!supported) { TRACE("collection not a tablet/digitizer\n"); return; } HIDParser &parser = device.Parser(); uint32 maxReportCount = parser.CountReports(HID_REPORT_TYPE_INPUT); if (maxReportCount == 0) return; uint32 inputReportCount = 0; HIDReport *inputReports[maxReportCount]; collection.BuildReportList(HID_REPORT_TYPE_INPUT, inputReports, inputReportCount); for (uint32 i = 0; i < inputReportCount; i++) { HIDReport *inputReport = inputReports[i]; // try to find at least an absolute x and y axis HIDReportItem *xAxis = inputReport->FindItem( B_HID_USAGE_PAGE_GENERIC_DESKTOP, B_HID_UID_GD_X); if (xAxis == NULL || xAxis->Relative()) continue; HIDReportItem *yAxis = inputReport->FindItem( B_HID_USAGE_PAGE_GENERIC_DESKTOP, B_HID_UID_GD_Y); if (yAxis == NULL || yAxis->Relative()) continue; ProtocolHandler *newHandler = new(std::nothrow) TabletProtocolHandler( *inputReport, *xAxis, *yAxis); if (newHandler == NULL) { TRACE("failed to allocated tablet protocol handler\n"); continue; } newHandler->SetNextHandler(handlerList); handlerList = newHandler; } }
status_t usb_hid_device_added(usb_device device, void **cookie) { TRACE("device_added()\n"); const usb_device_descriptor *deviceDescriptor = gUSBModule->get_device_descriptor(device); TRACE("vendor id: 0x%04x; product id: 0x%04x\n", deviceDescriptor->vendor_id, deviceDescriptor->product_id); for (int32 i = 0; i < gBlackListedDeviceCount; i++) { usb_support_descriptor &entry = gBlackListedDevices[i]; if ((entry.vendor != 0 && deviceDescriptor->vendor_id != entry.vendor) || (entry.product != 0 && deviceDescriptor->product_id != entry.product)) { continue; } return B_ERROR; } const usb_configuration_info *config = gUSBModule->get_nth_configuration(device, USB_DEFAULT_CONFIGURATION); if (config == NULL) { TRACE_ALWAYS("cannot get default configuration\n"); return B_ERROR; } // ensure default configuration is set status_t result = gUSBModule->set_configuration(device, config); if (result != B_OK) { TRACE_ALWAYS("set_configuration() failed 0x%08" B_PRIx32 "\n", result); return result; } // refresh config config = gUSBModule->get_configuration(device); if (config == NULL) { TRACE_ALWAYS("cannot get current configuration\n"); return B_ERROR; } bool devicesFound = false; int32 parentCookie = atomic_add(&sParentCookie, 1); for (size_t i = 0; i < config->interface_count; i++) { const usb_interface_info *interface = config->interface[i].active; uint8 interfaceClass = interface->descr->interface_class; TRACE("interface %" B_PRIuSIZE ": class: %u; subclass: %u; protocol: " "%u\n", i, interfaceClass, interface->descr->interface_subclass, interface->descr->interface_protocol); // check for quirky devices first int32 quirkyIndex = -1; for (int32 j = 0; j < gQuirkyDeviceCount; j++) { usb_hid_quirky_device &quirky = gQuirkyDevices[j]; if ((quirky.vendor_id != 0 && deviceDescriptor->vendor_id != quirky.vendor_id) || (quirky.product_id != 0 && deviceDescriptor->product_id != quirky.product_id) || (quirky.device_class != 0 && interfaceClass != quirky.device_class) || (quirky.device_subclass != 0 && interface->descr->interface_subclass != quirky.device_subclass) || (quirky.device_protocol != 0 && interface->descr->interface_protocol != quirky.device_protocol)) { continue; } quirkyIndex = j; break; } if (quirkyIndex >= 0 || interfaceClass == USB_INTERFACE_CLASS_HID) { mutex_lock(&sDriverLock); HIDDevice *hidDevice = new(std::nothrow) HIDDevice(device, config, i, quirkyIndex); if (hidDevice != NULL && hidDevice->InitCheck() == B_OK) { hidDevice->SetParentCookie(parentCookie); for (uint32 i = 0;; i++) { ProtocolHandler *handler = hidDevice->ProtocolHandlerAt(i); if (handler == NULL) break; // As devices can be un- and replugged at will, we cannot // simply rely on a device count. If there is just one // keyboard, this does not mean that it uses the 0 name. // There might have been two keyboards and the one using 0 // might have been unplugged. So we just generate names // until we find one that is not currently in use. int32 index = 0; char pathBuffer[128]; const char *basePath = handler->BasePath(); while (true) { sprintf(pathBuffer, "%s%" B_PRId32, basePath, index++); if (gDeviceList->FindDevice(pathBuffer) == NULL) { // this name is still free, use it handler->SetPublishPath(strdup(pathBuffer)); break; } } gDeviceList->AddDevice(handler->PublishPath(), handler); devicesFound = true; } } else delete hidDevice; mutex_unlock(&sDriverLock); } } if (!devicesFound) return B_ERROR; *cookie = (void *)(addr_t)parentCookie; return B_OK; }