Centralized Hooking Routine for Server-Side Pre-Execution Tasks
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional server-based software applications face challenges in efficiently updating and customizing security and authorization tasks due to hard-coding, which is time-consuming, error-prone, and limits flexibility in responding to changing security needs.
Innovation Solution
A centralized task management system that processes function calls on a server computer, using a hooking routine to execute common and customized pre-execution tasks, including authorization checks, without modifying client software, by retrieving and updating tasks from a remote storage medium.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If common tasks are hard-coded into each function in function groups, then security and authorization checks are performed consistently, but updating or changing common tasks requires rewriting or recompiling code for all functions, which is time-consuming and error-prone
Solution Approach 1:
The patent extracts common pre-execution tasks from individual function code and places them in a separate, centralized storage location on the server. This allows the common tasks to be independently updated without modifying or recompiling the function code, resolving the contradiction between maintaining consistency and enabling quick updates.
Solution Approach 2:
The system segments the authorization process into two independent parts: (1) the function code that remains unchanged, and (2) the common tasks that are stored separately and can be updated independently. This segmentation allows updates to common tasks without affecting the function code, reducing update time while maintaining consistency.
2Device complexity
If common tasks are hard-coded into each function, then the system structure is simple, but customization of common tasks for particular function groups or users requires creating unique function groups with custom common tasks for each client
Solution Approach 1:
The patent creates a universal common task storage location that serves all function groups and clients. This centralized storage enables a single set of common tasks to be customized and applied across multiple function groups and clients, providing adaptability without requiring separate custom implementations for each client.
Solution Approach 2:
The system performs preliminary customization of common tasks in the centralized storage location based on client-specific requirements. This allows customization to be done once in advance, and then the customized common tasks can be reused across multiple function calls and clients, maintaining simplicity while enabling versatility.
3Ease of manufacture
If common tasks are updated by rewriting code, then the implementation is straightforward, but the process is extremely error-prone and arduous
Solution Approach 1:
By extracting common tasks from the function code and storing them separately, the patent eliminates the need to rewrite or recompile function code when updating common tasks. This reduces the error rate by removing complex code modification operations and replaces them with simpler storage operations.
Solution Approach 2:
The system uses copying instead of rewriting - common tasks are copied from the centralized storage location to the appropriate function groups or clients as needed. This copying mechanism is simpler and less error-prone than rewriting code, while maintaining the ability to update common tasks efficiently.
Data Source
AI summary
Methods, systems, and apparatuses for processing function calls using a hooking routines to perform pre-execution tasks are disclosed. A server computer receives a function call including a hooking routine and a request to run a particular function from a client computer. Based on a function group identifier and the credentials of the user or client computer, the server computer can perform various pre-execution tasks. The tasks can be common to all functions in the function group or be customized Both pre-execution tasks can be stored remotely from the client computer, so that updates to the pre-execution task can be made without the need to update computer readable code stored on the client computer. If the pre-execution tasks, such as an authorization, passes, then the server computer can execute the requested function, the server computer can reject or abort the requested function.