Package apple.networkextension

Class NEFilterDataProvider

  • All Implemented Interfaces:
    NSObject
    public class NEFilterDataProvider
extends NEFilterProvider
    [@interface] NEFilterDataProvider The NEFilterDataProvider class declares the programmatic interface for an object that evaluates network data flows based on a set of locally-available rules and makes decisions about whether to block or allow the flows.

    • Constructor Detail

      • NEFilterDataProvider

        protected NEFilterDataProvider​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • allocWithZone

        public static java.lang.Object allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(java.lang.Object aTarget,
                                                                         org.moe.natj.objc.SEL aSelector,
                                                                         java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        public static NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        public static org.moe.natj.objc.Class classForKeyedUnarchiver()

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • hash_static

        public static long hash_static()

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • keyPathsForValuesAffectingValueForKey

        public static NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(java.lang.String key)

      • new_objc

        public static java.lang.Object new_objc()

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • version_static

        public static long version_static()

      • handleInboundDataCompleteForFlow

        public NEFilterDataVerdict handleInboundDataCompleteForFlow​(NEFilterFlow flow)
        handleInboundDataCompleteForFlow: This function is called by the framework after all of the inbound data for a flow has been seen by the filter. Subclasses must override this method to return an appropriate pass/block result.
        Parameters:
        flow - The flow
        Returns:
        The final NEFilterFlowDataVerdict verdict for the flow.

      • handleInboundDataFromFlowReadBytesStartOffsetReadBytes

        public NEFilterDataVerdict handleInboundDataFromFlowReadBytesStartOffsetReadBytes​(NEFilterFlow flow,
                                                                                  long offset,
                                                                                  NSData readBytes)
        handleInboundDataFromFlow:readBytesStartOffset:readBytes: This function is called by the framework when a filtering decision needs to be made about some inbound data that the filter previously requested access to via the NEFilterFlowDataVerdict or the NEFilterNewFlowVerdict. Subclasses must override this method.
        Parameters:
        flow - The NEFilterFlow from which the data was read.
        offset - The offset in bytes from the start of the flow's inbound data at which readBytes begins.
        readBytes - The data that was read. For non-UDP/TCP flows, since data may optionally include the IP header, readBytes includes a 4-bytes NEFilterDataAttribute field preceding the user data. Handler must examine the NEFilterDataAttribute field and handle the data accordingly.
        Returns:
        An NEFilterFlowDataVerdict containing the verdict for the flow.

      • handleNewFlow

        public NEFilterNewFlowVerdict handleNewFlow​(NEFilterFlow flow)
        handleNewFlow: This function is called by the framework when a filtering decision needs to be made about a new network data flow. Subclasses must override this method to implement the steps necessary to match the flow against some locally stored rules and return an appropriate verdict.
        Parameters:
        flow - An NEFilterFlow object containing details about the new flow.
        Returns:
        An NEFilterNewFlowVerdict object containing the veridct for the new flow.

      • handleOutboundDataCompleteForFlow

        public NEFilterDataVerdict handleOutboundDataCompleteForFlow​(NEFilterFlow flow)
        handleOutboundDataCompleteForFlow: This function is called by the framework after all of the outbound data for a flow has been seen by the filter. Subclasses must override this method to return an appropriate pass/block result.
        Parameters:
        flow - The flow
        Returns:
        The final NEFilterFlowDataVerdict verdict for the flow.

      • handleOutboundDataFromFlowReadBytesStartOffsetReadBytes

        public NEFilterDataVerdict handleOutboundDataFromFlowReadBytesStartOffsetReadBytes​(NEFilterFlow flow,
                                                                                   long offset,
                                                                                   NSData readBytes)
        handleOutboundDataFromFlow:readBytesStartOffset:readBytes: This function is called by the framework when a filtering decision needs to be made about some outbound data that the filter previously requested access to via the NEFilterFlowDataVerdict or the NEFilterNewFlowVerdict. Subclasses must override this method.
        Parameters:
        flow - The NEFilterFlow from which the data was read.
        offset - The offset in bytes from the start of the flow's outbound data at which readBytes begins.
        readBytes - The data that was read. For non-UDP/TCP flows, since data may optionally include the IP header, readBytes includes a 4-bytes NEFilterDataAttribute field preceding the user data. Handler must examine the NEFilterDataAttribute field and handle the data accordingly.
        Returns:
        An NEFilterFlowDataVerdict containing the verdict for the flow.

      • handleRemediationForFlow

        public NEFilterRemediationVerdict handleRemediationForFlow​(NEFilterFlow flow)
        handleRemediationForFlow: This function is called by the framework after the user requests remediation for a blocked flow. Subclasses must override this method to return an appropriate pass/block result.
        Parameters:
        flow - The flow
        Returns:
        The final NEFilterRemediationVerdict verdict for the flow.

      • handleRulesChanged

        public void handleRulesChanged()
        handleRulesChanged This function is called by the framework when -[NEFilterControlProvider notifyRulesChanged] is called. Subclasses should override this method to reload new rules from disk.