protected override void ExecuteApplicationSpecificStart()
{
ExWatson.Register("E12IIS");
OwaEventRegistry.RegisterHandler(typeof(ProxyEventHandler));
CalendarViewEventHandler.Register();
DatePickerEventHandler.Register();
PrintCalendarEventHandler.Register();
}
// Token: 0x06000EC7 RID: 3783 RVA: 0x0005E028 File Offset: 0x0005C228
private void ParseAndAddStruct(ArrayList itemArray)
{
OwaEventStructAttribute owaEventStructAttribute = OwaEventRegistry.FindStructInfo(this.reader.Name);
if (owaEventStructAttribute != null)
{
bool isEmptyElement = this.reader.IsEmptyElement;
object value = this.ParseStruct(owaEventStructAttribute);
if (itemArray != null)
{
base.AddStructToArray(this.paramInfo, itemArray, value);
}
else
{
base.AddStructParameter(this.paramInfo, value);
}
if (!isEmptyElement)
{
if (!this.reader.Read())
{
this.ThrowParserException("Unexpected end of request");
}
else if (this.reader.NodeType != XmlNodeType.EndElement || !string.Equals(owaEventStructAttribute.Name, this.reader.Name, StringComparison.Ordinal))
{
this.ThrowParserException("Expected end of struct");
}
}
if (!this.reader.Read())
{
this.ThrowParserException("Unexpected end of request");
return;
}
if (itemArray != null)
{
if (this.reader.NodeType != XmlNodeType.EndElement || !string.Equals(this.reader.Name, "item", StringComparison.OrdinalIgnoreCase))
{
this.ThrowParserException("Expected end of item");
return;
}
}
else if (this.reader.NodeType != XmlNodeType.EndElement || !string.Equals(this.reader.Name, this.paramInfo.Name, StringComparison.Ordinal))
{
this.ThrowParserException("Expected end of param");
return;
}
}
else
{
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Type '{0}' is unknown", new object[]
{
this.reader.Name
}));
}
}
public static void Register()
{
OwaEventRegistry.RegisterHandler(typeof(WebReadyFileEventHandler));
}
public IHttpHandler GetHandler(HttpContext httpContext, string requestType, string url, string pathTranslated)
{
ExTraceGlobals.OehCallTracer.TraceDebug(0L, "OwaEventHandlerFactory.GetHandler");
string queryStringParameter = Utilities.GetQueryStringParameter(httpContext.Request, "ns");
string queryStringParameter2 = Utilities.GetQueryStringParameter(httpContext.Request, "ev");
ISessionContext sessionContext = OwaContext.Get(httpContext).SessionContext;
ExTraceGlobals.OehDataTracer.TraceDebug <string, string>(0L, "Request namespace: '{0}', event: '{1}'", queryStringParameter, queryStringParameter2);
OwaEventNamespaceAttribute owaEventNamespaceAttribute = OwaEventRegistry.FindNamespaceInfo(queryStringParameter);
if (owaEventNamespaceAttribute == null)
{
throw new OwaInvalidRequestException(string.Format(CultureInfo.InvariantCulture, "Namespace '{0}' doesn't exist", new object[]
{
queryStringParameter
}), null, this);
}
if (sessionContext != null && !sessionContext.IsProxy && !sessionContext.AreFeaturesEnabled(owaEventNamespaceAttribute.SegmentationFlags))
{
Utilities.EndResponse(httpContext, HttpStatusCode.Forbidden);
return(null);
}
OwaEventAttribute owaEventAttribute = owaEventNamespaceAttribute.FindEventInfo(queryStringParameter2);
if (owaEventAttribute == null)
{
throw new OwaInvalidRequestException(string.Format(CultureInfo.InvariantCulture, "Event '{0}' doesn't exist", new object[]
{
queryStringParameter2
}), null, this);
}
if (Globals.OwaVDirType == OWAVDirType.Calendar && !owaEventAttribute.AllowAnonymousAccess)
{
Utilities.EndResponse(httpContext, HttpStatusCode.BadRequest);
return(null);
}
if (sessionContext != null && !sessionContext.IsProxy && !sessionContext.AreFeaturesEnabled(owaEventAttribute.SegmentationFlags))
{
Utilities.EndResponse(httpContext, HttpStatusCode.Forbidden);
return(null);
}
OwaEventVerb owaEventVerb = OwaEventVerbAttribute.Parse(httpContext.Request.HttpMethod);
ExTraceGlobals.OehDataTracer.TraceDebug <string>(0L, "Request verb: {0}", httpContext.Request.HttpMethod);
if ((owaEventAttribute.AllowedVerbs & owaEventVerb) == OwaEventVerb.Unsupported)
{
ExTraceGlobals.OehTracer.TraceDebug <OwaEventVerb, OwaEventVerb>(0L, "Verb is not allowed, returning 405. Actual verb: {0}. Allowed: {1}.", owaEventVerb, owaEventAttribute.AllowedVerbs);
Utilities.EndResponse(httpContext, HttpStatusCode.MethodNotAllowed);
return(null);
}
OwaEventHandlerBase owaEventHandlerBase = (OwaEventHandlerBase)Activator.CreateInstance(owaEventNamespaceAttribute.HandlerType);
owaEventHandlerBase.EventInfo = owaEventAttribute;
owaEventHandlerBase.OwaContext = OwaContext.Current;
owaEventHandlerBase.Verb = owaEventVerb;
if (Globals.CollectPerRequestPerformanceStats)
{
OwaContext.Current.OwaPerformanceData.SetOehRequestType(owaEventNamespaceAttribute.HandlerType.Name, owaEventAttribute.IsAsync ? owaEventAttribute.BeginMethodInfo.Name : owaEventAttribute.MethodInfo.Name);
}
if (owaEventAttribute.IsAsync)
{
OwaContext.Current.TryReleaseBudgetAndStopTiming();
ExTraceGlobals.OehTracer.TraceDebug(0L, "Created async HTTP handler to server OEH request");
OwaContext.Current.IsAsyncRequest = true;
return(new OwaEventAsyncHttpHandler(owaEventHandlerBase));
}
ExTraceGlobals.OehTracer.TraceDebug(0L, "Created sync HTTP handler to serve OEH request");
return(new OwaEventHttpHandler(owaEventHandlerBase));
}
protected object ConvertToStrongType(Type paramType, string value)
{
if (string.IsNullOrEmpty(value))
{
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Failed to parse type. Type = {0}, Value = {1}", new object[]
{
paramType,
value
}));
}
try
{
if (paramType.IsEnum)
{
OwaEventEnumAttribute owaEventEnumAttribute = OwaEventRegistry.FindEnumInfo(paramType);
int intValue = int.Parse(value, CultureInfo.InvariantCulture);
object obj = owaEventEnumAttribute.FindValueInfo(intValue);
if (obj == null)
{
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Failed to parse enum type. Type = {0}, Value = {1}", new object[]
{
paramType,
value
}));
}
return(obj);
}
if (paramType == typeof(int))
{
return(int.Parse(value, CultureInfo.InvariantCulture));
}
if (paramType == typeof(double))
{
return(double.Parse(value, CultureInfo.InvariantCulture));
}
if (paramType == typeof(ExDateTime))
{
return(DateTimeUtilities.ParseIsoDate(value, this.EventHandler.OwaContext.SessionContext.TimeZone));
}
if (paramType == typeof(bool))
{
if (string.Equals(value, "0", StringComparison.Ordinal))
{
return(false);
}
if (string.Equals(value, "1", StringComparison.Ordinal))
{
return(true);
}
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Failed to parse type. Type = {0}, Value = {1}", new object[]
{
paramType,
value
}));
}
else
{
if (paramType == typeof(StoreObjectId))
{
UserContext userContext = this.EventHandler.OwaContext.UserContext;
return(Utilities.CreateStoreObjectId(userContext.MailboxSession, value));
}
if (paramType == typeof(ADObjectId))
{
ADObjectId adobjectId = DirectoryAssistance.ParseADObjectId(value);
if (adobjectId == null)
{
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Failed to parse type. Type = {0}, Value = {1}", new object[]
{
paramType,
value
}));
}
return(adobjectId);
}
if (paramType == typeof(DocumentLibraryObjectId))
{
UserContext userContext2 = this.EventHandler.OwaContext.UserContext;
Uri uri;
if (null == (uri = Utilities.TryParseUri(value)))
{
return(null);
}
ClassifyResult[] array = null;
OwaWindowsIdentity owaWindowsIdentity = userContext2.LogonIdentity as OwaWindowsIdentity;
if (owaWindowsIdentity != null && owaWindowsIdentity.WindowsPrincipal != null)
{
array = LinkClassifier.ClassifyLinks(owaWindowsIdentity.WindowsPrincipal, new Uri[]
{
uri
});
}
if (array == null || array.Length == 0)
{
return(null);
}
return(array[0].ObjectId);
}
else if (paramType == typeof(OwaStoreObjectId))
{
UserContext userContext3 = this.EventHandler.OwaContext.UserContext;
if (OwaStoreObjectId.IsDummyArchiveFolder(value))
{
return(userContext3.GetArchiveRootFolderId());
}
return(OwaStoreObjectId.CreateFromString(value));
}
else
{
this.ThrowParserException("Internal error: unknown type");
}
}
}
catch (FormatException)
{
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Failed to parse type. Type = {0}, Value = {1}", new object[]
{
paramType,
value
}));
}
catch (OwaParsingErrorException)
{
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Failed to parse type. Type = {0}, Value = {1}", new object[]
{
paramType,
value
}));
}
catch (OverflowException)
{
this.ThrowParserException(string.Format(CultureInfo.InvariantCulture, "Type overflow. Type = {0}, Value = {1}", new object[]
{
paramType,
value
}));
}
return(null);
}
protected override void ExecuteApplicationSpecificStart()
{
ExWatson.Register("E12IIS");
StoreSession.UseRPCContextPool = true;
UMClientCommonBase.InitializePerformanceCounters(false);
OwaEventRegistry.RegisterEnum(typeof(Importance));
OwaEventRegistry.RegisterEnum(typeof(Sensitivity));
OwaEventRegistry.RegisterEnum(typeof(AddressOrigin));
OwaEventRegistry.RegisterEnum(typeof(FlagAction));
OwaEventRegistry.RegisterEnum(typeof(TaskStatus));
OwaEventRegistry.RegisterEnum(typeof(BusyType));
OwaEventRegistry.RegisterEnum(typeof(ResponseType));
OwaEventRegistry.RegisterEnum(typeof(StoreObjectType));
OwaEventRegistry.RegisterEnum(typeof(EmailAddressIndex));
OwaEventRegistry.RegisterEnum(typeof(NavigationNodeGroupSection));
OwaEventRegistry.RegisterEnum(typeof(InstantMessagingTypeOptions));
OwaEventRegistry.RegisterEnum(typeof(NavigationModule));
OwaEventRegistry.RegisterEnum(typeof(DefaultFolderType));
OwaEventRegistry.RegisterEnum(typeof(RecipientBlockType));
OwaEventRegistry.RegisterEnum(typeof(RecipientJunkEmailContextMenuType));
OwaEventRegistry.RegisterEnum(typeof(SharingLevel));
OwaEventRegistry.RegisterEnum(typeof(DenyResponseType));
OwaEventRegistry.RegisterEnum(typeof(AddressBookItemEventHandler.ItemTypeToPeople));
OwaEventRegistry.RegisterStruct(typeof(RecipientInfo));
OwaEventRegistry.RegisterStruct(typeof(DeleteItemInfo));
OwaEventRegistry.RegisterStruct(typeof(ReminderInfo));
OwaEventRegistry.RegisterHandler(typeof(ProxyEventHandler));
OwaEventRegistry.RegisterHandler(typeof(PendingRequestEventHandler));
OwaEventRegistry.RegisterHandler(typeof(ProxyToEwsEventHandler));
NotificationEventHandler.Register();
ClientCacheEventHandler.Register();
DocumentLibraryEventHandler.Register();
DocumentEventHandler.Register();
DatePickerEventHandler.Register();
ReadADOrgPersonEventHandler.Register();
ListViewEventHandler.Register();
TreeEventHandler.Register();
NavigationEventHandler.Register();
RecipientWellEventHandler.Register();
AttachmentEventHandler.Register();
ReadMessageEventHandler.Register();
ReadConversationEventHandler.Register();
ReadVoiceMessageEventHandler.Register();
OptionsEventHandler.Register();
AddressBookItemEventHandler.Register();
OwaEventRegistry.RegisterHandler(typeof(EditMessageEventHandler));
OwaEventRegistry.RegisterHandler(typeof(EditSmsEventHandler));
EditCalendarItemEventHandler.Register();
CalendarViewEventHandler.Register();
OwaEventRegistry.RegisterHandler(typeof(EditMeetingInviteEventHandler));
OwaEventRegistry.RegisterHandler(typeof(EditMeetingResponseEventHandler));
OwaEventRegistry.RegisterHandler(typeof(ErrorEventHandler));
OwaEventRegistry.RegisterHandler(typeof(FlagEventHandler));
OwaEventRegistry.RegisterHandler(typeof(CategoryEventHandler));
OwaEventRegistry.RegisterHandler(typeof(InstantMessageEventHandler));
OwaEventRegistry.RegisterHandler(typeof(MonitoringEventHandler));
OwaEventRegistry.RegisterHandler(typeof(MailTipsEventHandler));
RemindersEventHandler.Register();
EditContactItemEventHandler.Register();
EditDistributionListEventHandler.Register();
JunkEmailEventHandler.Register();
EditTaskEventHandler.Register();
ComplianceEventHandler.Register();
WebReadyFileEventHandler.Register();
EditPostEventHandler.Register();
ReadPostEventHandler.Register();
SMimeEventHandler.Register();
NavigationNodeEventHandler.Register();
MessageVirtualListViewEventHandler2.Register();
TaskVirtualListViewEventHandler.Register();
PersonalAutoAttendantOptionsEventHandler.Register();
EditPAAEventHandler.Register();
PerformanceConsoleEventHandler.Register();
DirectoryVirtualListViewEventHandler.Register();
ContactVirtualListViewEventHandler.Register();
DumpsterVirtualListViewEventHandler.Register();
SharingMessageEventHandler.Register();
DeletePolicyEventHandler.Register();
MovePolicyEventHandler.Register();
PrintCalendarEventHandler.Register();
MessageAnnotationEventHandler.Register();
}
public static void RegisterStruct(Type structType)
{
ExTraceGlobals.OehCallTracer.TraceDebug(0L, "OwaEventRegistry.RegisterStruct");
if (structType == null)
{
throw new ArgumentNullException("structType");
}
object[] customAttributes = structType.GetCustomAttributes(typeof(OwaEventStructAttribute), false);
if (customAttributes == null || customAttributes.Length == 0)
{
throw new OwaNotSupportedException("Struct type is missing the OwaEventStructAttribute attribute");
}
OwaEventStructAttribute owaEventStructAttribute = (OwaEventStructAttribute)customAttributes[0];
owaEventStructAttribute.StructType = structType;
ExTraceGlobals.OehDataTracer.TraceDebug <Type>(0L, "Struct type: '{0}'", structType);
Type type = null;
customAttributes = structType.GetCustomAttributes(typeof(OwaEventObjectIdAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
type = ((OwaEventObjectIdAttribute)customAttributes[0]).ObjectIdType;
}
FieldInfo[] fields = structType.GetFields(BindingFlags.Instance | BindingFlags.Public);
int num = 0;
uint num2 = 0U;
foreach (FieldInfo fieldInfo in fields)
{
customAttributes = fieldInfo.GetCustomAttributes(typeof(OwaEventFieldAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
OwaEventFieldAttribute owaEventFieldAttribute = (OwaEventFieldAttribute)customAttributes[0];
owaEventFieldAttribute.FieldInfo = fieldInfo;
owaEventFieldAttribute.FieldType = fieldInfo.FieldType;
if (type != null && owaEventFieldAttribute.FieldType == typeof(ObjectId))
{
owaEventFieldAttribute.FieldType = type;
}
if (!OwaEventRegistry.IsAllowedFieldType(owaEventFieldAttribute.FieldType))
{
throw new OwaNotSupportedException("Field type is not supported.");
}
owaEventFieldAttribute.FieldMask = 1U << num;
owaEventStructAttribute.AllFieldsMask |= owaEventFieldAttribute.FieldMask;
if (!owaEventFieldAttribute.IsOptional)
{
num2 |= owaEventFieldAttribute.FieldMask;
}
else if (fieldInfo.FieldType == typeof(ExDateTime))
{
owaEventFieldAttribute.DefaultValue = ExDateTime.MinValue;
}
if (num >= 32)
{
throw new OwaNotSupportedException("Struct declares more fields than allowed");
}
owaEventStructAttribute.AddFieldInfo(owaEventFieldAttribute, num);
num++;
ExTraceGlobals.OehDataTracer.TraceDebug <string, Type>(0L, "Struct field found, name: '{0}', type: '{1}'", owaEventStructAttribute.Name, owaEventFieldAttribute.FieldType);
}
}
if (num == 0)
{
throw new OwaNotSupportedException("Struct must have at least one field");
}
owaEventStructAttribute.FieldCount = num;
owaEventStructAttribute.RequiredMask = num2;
OwaEventRegistry.structTable.Add(owaEventStructAttribute.Name, owaEventStructAttribute);
OwaEventRegistry.structTypeTable.Add(owaEventStructAttribute.StructType, owaEventStructAttribute);
}
public static void RegisterHandler(Type handlerType)
{
ExTraceGlobals.OehCallTracer.TraceDebug(0L, "OwaEventRegistry.RegisterHandler");
if (handlerType == null)
{
throw new ArgumentNullException("handlerType");
}
object[] customAttributes = handlerType.GetCustomAttributes(typeof(OwaEventNamespaceAttribute), false);
if (customAttributes == null || customAttributes.Length == 0)
{
throw new OwaNotSupportedException("Internal error: Handler is missing OwaEventNamespaceAttribute attribute");
}
OwaEventNamespaceAttribute owaEventNamespaceAttribute = (OwaEventNamespaceAttribute)customAttributes[0];
owaEventNamespaceAttribute.HandlerType = handlerType;
customAttributes = handlerType.GetCustomAttributes(typeof(OwaEventSegmentationAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
OwaEventSegmentationAttribute owaEventSegmentationAttribute = (OwaEventSegmentationAttribute)customAttributes[0];
owaEventNamespaceAttribute.SegmentationFlags = owaEventSegmentationAttribute.SegmentationFlags;
}
else
{
owaEventNamespaceAttribute.SegmentationFlags = 0UL;
}
Type objectIdType = null;
customAttributes = handlerType.GetCustomAttributes(typeof(OwaEventObjectIdAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
objectIdType = ((OwaEventObjectIdAttribute)customAttributes[0]).ObjectIdType;
}
ExTraceGlobals.OehDataTracer.TraceDebug <string>(0L, "Handler type: '{0}'", handlerType.ToString());
foreach (MethodInfo methodInfo in handlerType.GetMethods(BindingFlags.Instance | BindingFlags.Public))
{
customAttributes = methodInfo.GetCustomAttributes(typeof(OwaEventAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
OwaEventAttribute owaEventAttribute = (OwaEventAttribute)customAttributes[0];
ParameterInfo[] parameters = methodInfo.GetParameters();
if (methodInfo.ReturnType == typeof(IAsyncResult))
{
if (parameters.Length != 2 || parameters[0].ParameterType != typeof(AsyncCallback) || parameters[1].ParameterType != typeof(object))
{
throw new OwaNotSupportedException("Wrong signature for async event handler method.");
}
owaEventAttribute.IsAsync = true;
owaEventAttribute.BeginMethodInfo = methodInfo;
}
else if (methodInfo.ReturnType == typeof(void))
{
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(IAsyncResult))
{
owaEventAttribute.EndMethodInfo = methodInfo;
owaEventAttribute.IsAsync = true;
}
else
{
if (parameters.Length != 0)
{
throw new OwaNotSupportedException("Wrong signature for event handler method.");
}
owaEventAttribute.MethodInfo = methodInfo;
owaEventAttribute.IsAsync = false;
}
}
if (!owaEventAttribute.IsAsync || !(null != owaEventAttribute.EndMethodInfo))
{
OwaEventRegistry.ScanHandlerAttributes(methodInfo, owaEventAttribute, objectIdType);
}
owaEventNamespaceAttribute.AddEventInfo(owaEventAttribute);
}
}
foreach (object obj in owaEventNamespaceAttribute.EventInfoTable.Values)
{
OwaEventAttribute owaEventAttribute2 = obj as OwaEventAttribute;
if (owaEventAttribute2.MethodInfo != null)
{
if (owaEventAttribute2.BeginMethodInfo != null || owaEventAttribute2.EndMethodInfo != null)
{
throw new OwaNotSupportedException("Namespace defines the same event both sync and async");
}
}
else if (owaEventAttribute2.BeginMethodInfo != null)
{
if (owaEventAttribute2.EndMethodInfo == null)
{
throw new OwaNotSupportedException(string.Format("Begin async method {0} for event {1} is missing its corresponding End method", owaEventAttribute2.BeginMethodInfo.Name, owaEventAttribute2.Name));
}
}
else if (owaEventAttribute2.EndMethodInfo != null && owaEventAttribute2.BeginMethodInfo == null)
{
throw new OwaNotSupportedException(string.Format("End async method {0} for event {1} is missing its corresponding Begin method", owaEventAttribute2.EndMethodInfo.Name, owaEventAttribute2.Name));
}
}
OwaEventRegistry.handlerTable.Add(owaEventNamespaceAttribute.Name, owaEventNamespaceAttribute);
}
private static void ScanHandlerAttributes(MethodInfo method, OwaEventAttribute eventInfo, Type objectIdType)
{
object[] customAttributes = method.GetCustomAttributes(typeof(OwaEventVerbAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
OwaEventVerbAttribute owaEventVerbAttribute = (OwaEventVerbAttribute)customAttributes[0];
eventInfo.AllowedVerbs = owaEventVerbAttribute.Verb;
}
else
{
eventInfo.AllowedVerbs = OwaEventVerb.Post;
}
customAttributes = method.GetCustomAttributes(typeof(OwaEventSegmentationAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
OwaEventSegmentationAttribute owaEventSegmentationAttribute = (OwaEventSegmentationAttribute)customAttributes[0];
eventInfo.SegmentationFlags = owaEventSegmentationAttribute.SegmentationFlags;
}
else
{
eventInfo.SegmentationFlags = 0UL;
}
ExTraceGlobals.OehDataTracer.TraceDebug <string, OwaEventVerb>(0L, "Event handler found. Name: '{0}'. Allowed verbs: '{1}'.", eventInfo.Name, eventInfo.AllowedVerbs);
ulong num = 0UL;
int num2 = 0;
if (Globals.CanaryProtectionRequired)
{
eventInfo.AddParameterInfo(new OwaEventParameterAttribute("canary", typeof(string)));
}
customAttributes = method.GetCustomAttributes(typeof(OwaEventParameterAttribute), false);
if (customAttributes != null && customAttributes.Length > 0)
{
if (customAttributes.Length >= 64)
{
throw new OwaNotSupportedException("Event handler declares more parameters than allowed");
}
if ((eventInfo.AllowedVerbs & OwaEventVerb.Get) != OwaEventVerb.Unsupported && customAttributes.Length > 16)
{
throw new OwaNotSupportedException("Event handler declares more parameters than allowed for a GET request");
}
foreach (OwaEventParameterAttribute owaEventParameterAttribute in customAttributes)
{
if (objectIdType != null && owaEventParameterAttribute.Type == typeof(ObjectId))
{
owaEventParameterAttribute = new OwaEventParameterAttribute(owaEventParameterAttribute.Name, objectIdType, owaEventParameterAttribute.IsArray, owaEventParameterAttribute.IsOptional);
}
if (!eventInfo.IsInternal && !OwaEventRegistry.IsAllowedType(owaEventParameterAttribute.Type))
{
string message = string.Format("Event handler is using a type that is not supported method: '{0}' param type '{1}'", method.Name, owaEventParameterAttribute.Type);
throw new OwaNotSupportedException(message);
}
if (string.Equals(owaEventParameterAttribute.Name, "ns", StringComparison.Ordinal) || string.Equals(owaEventParameterAttribute.Name, "ev", StringComparison.Ordinal))
{
throw new OwaNotSupportedException("Handler is trying to use a reserve name for a parameter");
}
if (OwaEventRegistry.structTypeTable[owaEventParameterAttribute.Type] != null)
{
owaEventParameterAttribute.IsStruct = true;
}
owaEventParameterAttribute.ParameterMask = 1UL << num2;
if (!owaEventParameterAttribute.IsOptional)
{
num |= owaEventParameterAttribute.ParameterMask;
}
eventInfo.AddParameterInfo(owaEventParameterAttribute);
num2++;
ExTraceGlobals.OehDataTracer.TraceDebug(0L, "Event handler parameter found, name: '{0}', type: '{1}', isArray: '{2}', isOptional: '{3}', isStruct: '{4}'", new object[]
{
owaEventParameterAttribute.Name,
owaEventParameterAttribute.Type,
owaEventParameterAttribute.IsArray,
owaEventParameterAttribute.IsOptional,
owaEventParameterAttribute.IsStruct
});
}
}
eventInfo.RequiredMask = num;
}