void ProfileDB::listCapabilities(string statePattern) {
vector<Profile*> profiles;
set<string> aggregateCapabilities;
getProfiles("*", profiles);
for (size_t i = 0; i < profiles.size(); i++) {
Profile* profile = profiles.at(i);
set<string> capabilities = profile->getCapabilities();
for (set<string>::iterator capabilityIt = capabilities.begin(); capabilityIt
!= capabilities.end(); capabilityIt++) {
Capability capability = profile->getCapability(*capabilityIt);
if (capability.matchCapability(statePattern)) {
aggregateCapabilities.insert(*capabilityIt);
}
}
}
ostringstream output;
XMLWriter writer = XMLWriter(&output);
writer.start();
writer.startTag("db");
writer.setAttr("version", "1.0");
writer.setAttr("id", "main");
for (set<string>::iterator capabilityIt = aggregateCapabilities.begin(); capabilityIt
!= aggregateCapabilities.end(); capabilityIt++) {
writer.startTag(ELEMENT_CAPABILITY);
writer.setAttr(ATTR_NAME, *capabilityIt);
writer.endTag();
}
writer.endTag();
writer.end();
writer.dump();
}
void EditSceneValue::slotValueChanged(int value)
{
if (m_updateValue == false)
{
return;
}
m_updateValue = false;
Capability* c = m_channel->searchCapability(value);
ASSERT(c != NULL);
for (int i = 0; i < m_presetCombo->count(); i++)
{
if (m_presetCombo->text(i) == c->name())
{
m_presetCombo->setCurrentItem(i);
break;
}
}
m_value = value;
m_updateValue = true;
}
void HandleList(std::string& out, LocalUser* user, bool show_all, bool show_values, bool minus_prefix = false) const
{
Ext show_caps = (show_all ? ~0 : capext.get(user));
for (CapMap::const_iterator i = caps.begin(); i != caps.end(); ++i)
{
Capability* cap = i->second;
if (!(show_caps & cap->GetMask()))
continue;
if ((show_all) && (!cap->OnList(user)))
continue;
if (minus_prefix)
out.push_back('-');
out.append(cap->GetName());
if (show_values)
{
const std::string* capvalue = cap->GetValue(user);
if ((capvalue) && (!capvalue->empty()) && (capvalue->find(' ') == std::string::npos))
{
out.push_back('=');
out.append(*capvalue, 0, MAX_VALUE_LENGTH);
}
}
out.push_back(' ');
}
}
void State::enable(const GLenum capability, const int index)
{
Capability* cap = getCapability(capability);
cap->enable(index);
if (m_mode == ImmediateMode)
cap->apply();
}
void State::disable(const GLenum capability)
{
Capability* cap = getCapability(capability);
cap->disable();
if (m_mode == ImmediateMode)
cap->apply();
}
unsigned long
Generic_obj_space<SPACE>::v_delete(Page_number virt, Size size,
unsigned long page_attribs = L4_fpage::CRWSD)
{
(void)size;
assert (size.value() == 1);
Entry *c;
if (Optimize_local
&& mem_space() == Mem_space::current_mem_space(current_cpu()))
{
c = cap_virt(virt.value());
if (!c)
return 0;
Capability cap = Mem_layout::read_special_safe((Capability*)c);
if (!cap.valid())
return 0;
}
else
c = get_cap(virt.value());
if (c && c->valid())
{
if (page_attribs & L4_fpage::R)
c->invalidate();
else
c->del_rights(page_attribs & L4_fpage::CWSD);
}
return 0;
}
void State::enable(GLenum capability)
{
Capability* cap = getCapability(capability);
cap->enable();
if (m_mode == ImmediateMode)
cap->apply();
}
bool
Generic_obj_space<SPACE>::v_lookup(Addr const &virt, Phys_addr *phys = 0,
Size *size = 0, unsigned *attribs = 0)
{
if (size) size->set_value(1);
Entry *cap;
if (Optimize_local
&& mem_space() == Mem_space::current_mem_space(current_cpu()))
cap = cap_virt(virt.value());
else
cap = get_cap(virt.value());
if (EXPECT_FALSE(!cap))
{
if (size) size->set_value(Caps_per_page);
return false;
}
if (Optimize_local)
{
Capability c = Mem_layout::read_special_safe((Capability*)cap);
if (phys) *phys = c.obj();
if (c.valid() && attribs) *attribs = c.rights();
return c.valid();
}
else
{
Obj::set_entry(virt, cap);
if (phys) *phys = cap->obj();
if (cap->valid() && attribs) *attribs = cap->rights();
return cap->valid();
}
}
void State::disable(GLenum capability, int index)
{
Capability* cap = getCapability(capability);
cap->disable(index);
if (m_mode == ImmediateMode)
cap->apply();
}
Obj_space_virt<SPACE>::v_delete(V_pfn virt, Order size,
L4_fpage::Rights page_attribs)
{
(void)size;
assert (size == Order(0));
Entry *c;
if (Optimize_local
&& SPACE::mem_space(this) == Mem_space::current_mem_space(current_cpu()))
{
c = cap_virt(virt);
if (!c)
return L4_fpage::Rights(0);
Capability cap = Mem_layout::read_special_safe((Capability*)c);
if (!cap.valid())
return L4_fpage::Rights(0);
}
else
c = get_cap(virt);
if (c && c->valid())
{
if (page_attribs & L4_fpage::Rights::R())
c->invalidate();
else
c->del_rights(page_attribs & L4_fpage::Rights::CWSD());
}
return L4_fpage::Rights(0);
}
~ManagerImpl()
{
for (CapMap::iterator i = caps.begin(); i != caps.end(); ++i)
{
Capability* cap = i->second;
cap->Unregister();
}
}
Kobject_iface *
Generic_obj_space<SPACE>::lookup_local(Address virt, unsigned char *rights = 0)
{
virt &= ~(~0UL << Whole_space);
Capability *c = reinterpret_cast<Capability*>(cap_virt(virt));
Capability cap = Mem_layout::read_special_safe(c);
if (rights) *rights = cap.rights();
return cap.obj();
}
Kobject_iface *
Obj_space_virt<SPACE>::lookup_local(Cap_index virt, L4_fpage::Rights *rights)
{
virt &= Cap_index(~(~0UL << Whole_space));
Capability *c = reinterpret_cast<Capability*>(cap_virt(virt));
Capability cap = Mem_layout::read_special_safe(c);
if (rights) *rights = L4_fpage::Rights(cap.rights());
return cap.obj();
}
/**
* Install a capability.
*
* @param capability -- A capability.
*/
void Strine_::InstallCapability(Capability const& capability)
{
Strine strine(shared_from_this());
capability.Install(strine);
this->capabilities.push_back(capability.Identifier());
// Re-install all builtins.
GlobalEnvironment_::InstallBuiltins( this->global_environment
, this->builtins_table);
}
static Capability get_capability (const ::Deployment::Capability &src)
{
DANCE_TRACE ("Capability_Handler::get_capability - reverse");
Capability retval (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ()));
#if 0
for (CORBA::ULong i = 0; i < src.resourceType.length (); ++i)
retval.add_resourceType (src.resourceType[i].in ());
for (CORBA::ULong i = 0; i < src.property.length (); ++i)
retval.add_property (SatisfierProperty_Handler::get_sat_property (
src.property[i]));
#endif
return retval;
}
static bool parseProfileInfo(ProfileType profileType, Profile* p, const SETTINGS& s, const char* filename,
RuntimeInfo& pi) {
bool hasBbMajor = false, hasBbMinor = false;
pi.isBlackberry = false;
pi.hasLimitedResourceSize = false;
pi.isCldc10 = false;
pi.iconSize = "default";
int iconX = -1;
int iconY = -1;
if (profileType == DEVICE_BASED) {
ifstream file(filename);
setName(file, filename);
if (!file.good())
return false;
while (file.good()) {
string line;
getline(file, line);
if (line.find("#define MA_PROF_BUG_RESOURCE_SIZE_LIMITED") == 0) {
pi.hasLimitedResourceSize = true;
}
hasBbMajor |= parseIntProp(line, "MA_PROF_BLACKBERRY_VERSION",
pi.blackberryVersion);
hasBbMinor |= parseIntProp(line,
"MA_PROF_BLACKBERRY_VERSION_MINOR", pi.blackberryMinor);
if (line.find("#define MA_PROF_SUPPORT_CLDC_10") == 0) {
pi.isCldc10 = true;
}
parseIntProp(line, "MA_PROF_CONST_ICONSIZE_X", iconX);
parseIntProp(line, "MA_PROF_CONST_ICONSIZE_Y", iconY);
}
//pi.isBlackberry = (hasBbMajor && hasBbMinor); //rapc is not available.
} else {
Capability iconSize = p->getCapability("IconSize");
if (iconSize.getValue().length() > 0) {
pi.iconSize = iconSize.getValue().c_str();
}
pi.isBlackberry = p->getFamily() == "BlackBerry";
if (pi.isBlackberry) {
Capability major = p->getCapability("Version/Major");
Capability minor = p->getCapability("Version/Minor");
sscanf(major.getValue().c_str(), "%i", &pi.blackberryVersion);
sscanf(minor.getValue().c_str(), "%i", &pi.blackberryMinor);
}
Capability cldc = p->getCapability("CLDC");
pi.isCldc10 = (cldc.getValue() == "1.0");
}
if (iconX > 0 && iconY > 0) {
char buf[32];
sprintf(buf, "%ix%i", iconX, iconY);
pi.iconSize = buf;
}
return true;
}
inline
Kobject_iface *
Obj_space_phys<SPACE>::lookup_local(Cap_index virt, L4_fpage::Rights *rights)
{
Entry *c = get_cap(virt);
if (EXPECT_FALSE(!c))
return 0;
Capability cap = *c;
if (rights)
*rights = L4_fpage::Rights(cap.rights());
return cap.obj();
}
inline
Kobject_iface *
Generic_obj_space<SPACE>::lookup_local(Address virt, unsigned char *rights = 0)
{
Entry *c = get_cap(virt);
if (EXPECT_FALSE(!c))
return 0;
Capability cap = *c;
if (rights)
*rights = cap.rights();
return cap.obj();
}
Obj_space_phys<SPACE>::v_delete(V_pfn virt, Page_order size,
L4_fpage::Rights page_attribs = L4_fpage::Rights::FULL())
{
(void)size;
assert (size == Page_order(0));
Capability *c = get_cap(virt);
if (c && c->valid())
{
if (page_attribs & L4_fpage::Rights::R())
c->invalidate();
else
c->del_rights(page_attribs);
}
return L4_fpage::Rights(0);
}
void AdvancedSceneEditor::invokePresetMenu(const QPoint &pos)
{
QPopupMenu* menu = new QPopupMenu;
menu->insertItem("Preset");
menu->insertSeparator();
int i = 0;
for (Capability* c = m_currentChannel->capabilities()->first(); c != NULL;
c = m_currentChannel->capabilities()->next())
{
menu->insertItem(c->name(), i++);
}
if (i > 0)
{
connect(menu, SIGNAL(activated(int)), this, SLOT(slotPresetMenuActivated(int)));
}
void EditSceneValue::slotPresetComboActivated(const QString &text)
{
if (m_updateValue == false)
{
return;
}
m_updateValue = false;
Capability* c = m_channel->searchCapability(text);
ASSERT(c != NULL);
int value = (int) floor((c->lo() + c->hi()) / 2);
m_valueSpin->setValue(value);
m_value = value;
m_updateValue = true;
}
unsigned long
Generic_obj_space<SPACE>::v_delete(Page_number virt, Size size,
unsigned long page_attribs = L4_fpage::RWX)
{
(void)size;
assert (size.value() == 1);
Capability *c = get_cap(virt.value());
if (c && c->valid())
{
if (page_attribs & L4_fpage::R)
c->invalidate();
else
c->del_rights(page_attribs & L4_fpage::WX);
}
return 0;
}
int XattrHelper::dumpXattr(Xattr & xattr)
{
if(xattr.m_attrName.compare( "security.capability") == 0)
{
Capability cap;
if(CapabilityHelper::rawDataToCapability(xattr.m_attrValue,cap)!=-1)
{
cap.dump();
}
}
else
{
std::string str(&xattr.m_attrValue[0],xattr.m_attrValue.size());
xattr.dump();
std::cout << "Value String ( " << str << " )"<< std::endl;
}
return 0;
}
Obj_space_phys<SPACE>::v_lookup(V_pfn const &virt, Phys_addr *phys,
Page_order *size, Attr *attribs)
{
if (size) *size = Page_order(0);
Entry *cap = get_cap(virt);
if (EXPECT_FALSE(!cap))
{
if (size) *size = Page_order(Obj::Caps_per_page_ld2);
return false;
}
Capability c = *cap;
Obj::set_entry(virt, cap);
if (phys) *phys = c.obj();
if (c.valid() && attribs) *attribs = cap->rights();
return c.valid();
}
void Profile::toXML(XMLWriter& writer, bool includeCapabilities) {
writer.startTag(ELEMENT_PLATFORM);
writer.setAttr(ATTR_FAMILY, fFamily);
writer.setAttr(ATTR_VARIANT, fVariant);
writer.setAttr(ATTR_RUNTIME, fRuntime);
if (fIsAbstract) {
writer.setAttr(ATTR_ABSTRACT, "true");
}
if (includeCapabilities) {
set<string> capabilities = Profile::getCapabilities();
for (set<string>::iterator capability = capabilities.begin(); capability
!= capabilities.end(); capability++) {
Capability value = getCapability(*capability);
value.toXML(writer);
}
}
writer.endTag();
}
EditSceneValue::EditSceneValue(QWidget* parent, LogicalChannel* ch,
SceneValue ¤tValue)
: UI_EditSceneValue(parent, "", true)
{
ASSERT(ch != NULL);
m_channel = ch;
m_updateValue = true;
for (Capability* c = m_channel->capabilities()->first();
c != NULL; c = m_channel->capabilities()->next())
{
m_presetCombo->insertItem(c->name());
}
m_typeCombo->insertItem("Fade");
m_typeCombo->insertItem("Set");
m_typeCombo->insertItem("NoSet");
if (currentValue.type == Scene::Fade)
{
m_typeCombo->setCurrentItem(0);
m_type = QString("Fade");
}
else if (currentValue.type == Scene::Set)
{
m_typeCombo->setCurrentItem(1);
m_type = QString("Set");
}
else
{
m_typeCombo->setCurrentItem(2);
m_type = QString("NoSet");
}
connect(m_valueSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotValueChanged(int)));
connect(m_presetCombo, SIGNAL(activated(const QString &)),
this, SLOT(slotPresetComboActivated(const QString &)));
m_valueSpin->setValue(currentValue.value);
m_value = currentValue.value;
}
bool
Generic_obj_space<SPACE>::v_lookup(Addr const &virt, Phys_addr *phys = 0,
Size *size = 0, unsigned *attribs = 0)
{
if (size) *size = Size::create(1);
Entry *cap = get_cap(virt.value());
if (EXPECT_FALSE(!cap))
{
if (size) *size = Size::create(Caps_per_page);
return false;
}
Capability c = *cap;
Obj::set_entry(virt, cap);
if (phys) *phys = c.obj();
if (c.valid() && attribs) *attribs = cap->rights();
return c.valid();
}
bool HandleReq(LocalUser* user, const std::string& reqlist)
{
Ext usercaps = capext.get(user);
irc::spacesepstream ss(reqlist);
for (std::string capname; ss.GetToken(capname); )
{
bool remove = (capname[0] == '-');
if (remove)
capname.erase(capname.begin());
Capability* cap = ManagerImpl::Find(capname);
if ((!cap) || (!CanRequest(user, usercaps, cap, !remove)))
return false;
if (remove)
usercaps = cap->DelFromMask(usercaps);
else
usercaps = cap->AddToMask(usercaps);
}
capext.set(user, usercaps);
return true;
}
Obj_space_virt<SPACE>::v_lookup(V_pfn const &virt, Phys_addr *phys,
Page_order *size, Attr *attribs)
{
if (size) *size = Order(0);
Entry *cap;
if (Optimize_local
&& SPACE::mem_space(this) == Mem_space::current_mem_space(current_cpu()))
cap = cap_virt(virt);
else
cap = get_cap(virt);
if (EXPECT_FALSE(!cap))
{
if (size) *size = Order(Obj::Caps_per_page_ld2);
return false;
}
if (Optimize_local)
{
Capability c = Mem_layout::read_special_safe((Capability*)cap);
if (phys) *phys = c.obj();
if (c.valid() && attribs)
*attribs = Attr(c.rights());
return c.valid();
}
else
{
Obj::set_entry(virt, cap);
if (phys) *phys = cap->obj();
if (cap->valid() && attribs)
*attribs = Attr(cap->rights());
return cap->valid();
}
}
void ConsoleChannel::contextMenuEvent(QContextMenuEvent* e)
{
QString s;
QString t;
Capability* c = NULL;
Device* device = _app->doc()->device(m_deviceID);
assert(device);
LogicalChannel* ch = device->deviceClass()->channels()->at(m_channel);
QPopupMenu* menu = new QPopupMenu();
menu->insertItem(ch->name(), KMenuTitle);
menu->setItemEnabled(KMenuTitle, false);
menu->insertSeparator();
QPtrListIterator<Capability> it(*ch->capabilities());
QPopupMenu* valueMenu = NULL;
while (it.current())
{
c = it.current();
// Set the value range and name as menu item's name
s.sprintf("%.3d - %.3d:", c->lo(), c->hi());
s += c->name();
// Create a submenu for ranges that contain more than one value
if (c->hi() - c->lo() > 0)
{
valueMenu = new QPopupMenu(menu);
connect(valueMenu, SIGNAL(activated(int)),
this, SLOT(slotContextMenuActivated(int)));
for (int i = c->lo(); i <= c->hi(); i++)
{
t.sprintf("%.3d", i);
valueMenu->insertItem(t, i);
}
menu->insertItem(s, valueMenu);
}
else
{
