static void handle_cattrs (MonoCustomAttrInfo* cattrs) { int i; if (!cattrs) return; for (i = 0; i < cattrs->num_attrs; ++i) { add_types_from_method (cattrs->attrs [i].ctor); } mono_custom_attrs_free (cattrs); }
GDMonoClass::~GDMonoClass() { if (attributes) { mono_custom_attrs_free(attributes); } for (Map<StringName, GDMonoField *>::Element *E = fields.front(); E; E = E->next()) { memdelete(E->value()); } for (Map<StringName, GDMonoProperty *>::Element *E = properties.front(); E; E = E->next()) { memdelete(E->value()); } { // Ugly workaround... // We may have duplicated values, because we redirect snake_case methods to PascalCasel (only Godot API methods). // This way, we end with both the snake_case name and the PascalCasel name paired with the same method. // Therefore, we must avoid deleting the same pointer twice. int offset = 0; Vector<GDMonoMethod *> deleted_methods; deleted_methods.resize(methods.size()); const MethodKey *k = NULL; while ((k = methods.next(k))) { GDMonoMethod *method = methods.get(*k); if (method) { for (int i = 0; i < offset; i++) { if (deleted_methods[i] == method) { // Already deleted goto already_deleted; } } deleted_methods.write[offset] = method; ++offset; memdelete(method); } already_deleted:; } methods.clear(); } for (int i = 0; i < method_list.size(); ++i) { memdelete(method_list[i]); } }
bool MonoMethod::hasAttribute(MonoClass* monoClass) const { // TODO - Consider caching custom attributes or just initializing them all at load MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_method(mMethod); if (attrInfo == nullptr) return false; bool hasAttr = mono_custom_attrs_has_attr(attrInfo, monoClass->_getInternalClass()) != 0; mono_custom_attrs_free(attrInfo); return hasAttr; }
MonoObject* MonoMethod::getAttribute(MonoClass* monoClass) const { // TODO - Consider caching custom attributes or just initializing them all at load MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_method(mMethod); if (attrInfo == nullptr) return nullptr; MonoObject* foundAttr = mono_custom_attrs_get_attr(attrInfo, monoClass->_getInternalClass()); mono_custom_attrs_free(attrInfo); return foundAttr; }
/* * Ensure that the restrictions for partially trusted code are satisfied. * * @domain The current application domain * @caller The method calling * @callee The called method * return value: TRUE if a security violation is detected, FALSE otherwise. * * If callee's assembly is strongnamed and doesn't have an * [AllowPartiallyTrustedCallers] attribute then we must enforce a LinkDemand * for FullTrust on all public/protected methods on public class. * * Note: APTC is only effective on stongnamed assemblies. */ static gboolean mono_declsec_linkdemand_aptc (MonoDomain *domain, MonoMethod *caller, MonoMethod *callee) { MonoSecurityManager* secman = NULL; MonoAssembly *assembly; guint32 size = 0; InterlockedIncrement (&mono_jit_stats.cas_linkdemand_aptc); /* A - Applicable only if we're calling into *another* assembly */ if (caller->klass->image == callee->klass->image) return FALSE; /* B - Applicable if we're calling a public/protected method from a public class */ if (!(callee->klass->flags & TYPE_ATTRIBUTE_PUBLIC) || !(callee->flags & FIELD_ATTRIBUTE_PUBLIC)) return FALSE; /* C - Applicable if the callee's assembly is strongnamed */ if ((mono_image_get_public_key (callee->klass->image, &size) == NULL) || (size < MONO_ECMA_KEY_LENGTH)) return FALSE; /* D - the callee's assembly must have [AllowPartiallyTrustedCallers] */ assembly = mono_image_get_assembly (callee->klass->image); if (!MONO_SECMAN_FLAG_INIT (assembly->aptc)) { MonoCustomAttrInfo* cinfo = mono_custom_attrs_from_assembly (assembly); gboolean result = FALSE; secman = mono_security_manager_get_methods (); if (secman && cinfo) { /* look for AllowPartiallyTrustedCallersAttribute */ result = mono_custom_attrs_has_attr (cinfo, secman->allowpartiallytrustedcallers); } if (cinfo) mono_custom_attrs_free (cinfo); MONO_SECMAN_FLAG_SET_VALUE (assembly->aptc, result); } if (MONO_SECMAN_FLAG_GET_VALUE (assembly->aptc)) return FALSE; /* E - the caller's assembly must have full trust permissions */ assembly = mono_image_get_assembly (caller->klass->image); if (mono_declsec_is_assembly_fulltrust (domain, assembly)) return FALSE; /* g_warning ("FAILURE *** JIT LinkDemand APTC check *** %s.%s calls into %s.%s", caller->klass->name, caller->name, callee->klass->name, callee->name); */ return TRUE; /* i.e. throw new SecurityException(); */ }
MonoObject* MonoField::getAttribute(MonoClass* monoClass) { // TODO - Consider caching custom attributes or just initializing them all at load ::MonoClass* parentClass = mono_field_get_parent(mField); MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_field(parentClass, mField); if(attrInfo == nullptr) return nullptr; MonoObject* foundAttr = mono_custom_attrs_get_attr(attrInfo, monoClass->_getInternalClass()); mono_custom_attrs_free(attrInfo); return foundAttr; }
bool MonoField::hasAttribute(MonoClass* monoClass) { // TODO - Consider caching custom attributes or just initializing them all at load ::MonoClass* parentClass = mono_field_get_parent(mField); MonoCustomAttrInfo* attrInfo = mono_custom_attrs_from_field(parentClass, mField); if(attrInfo == nullptr) return false; bool hasAttr = mono_custom_attrs_has_attr(attrInfo, monoClass->_getInternalClass()) != 0; mono_custom_attrs_free(attrInfo); return hasAttr; }
GDMonoField::~GDMonoField() { if (attributes) { mono_custom_attrs_free(attributes); } }
GDMonoMethod::~GDMonoMethod() { if (attributes) { mono_custom_attrs_free(attributes); } }
GDMonoProperty::~GDMonoProperty() { if (attributes) { mono_custom_attrs_free(attributes); } }