Abstract: A computer system and method for preventing a Dynamic-Link Library (DLL) injection attack are provided. The computer system monitors an operation where a process attempts to dynamically link an executable code library to another process, and intercepts the dynamic link of the executable code library.

Abstract: Extension activation may be provided. A document may be opened within a software application associated with an extension. Upon determining that a data element associated with the document is associated with an activation condition of the extension, the extension may be activated.

Abstract: A method of dynamic linkage including: receiving a request to launch a program; checking a system memory for the program; reserving a unique memory block of the system memory for the program and loading the program into the unique memory block if the program is not found in the memory of the system; performing internal memory relocations for the program if the program is not found in the memory of the system; ensuring that a library required by the program has been loaded into the system memory if the program is not found in the memory of the system; and invoking the program.

Abstract: The present disclosure involves systems, software, and computer implemented methods for providing modular applications. A first module of multiple modules is received from a server system. Each module includes instructions executable by data processing apparatus to perform operations. Operations are performed by executing the first module. A request to the server system for a second module is transmitted while performing the operations. At least a portion of the second module is received from the server system while performing the operations.

Abstract: Modelling a serialized object stream can include receiving a stream of bytes corresponding to the serialized form of a first object, creating an empty initial model for containing a generic object and a generic class, and, upon detection of a class from the stream, constructing a corresponding generic class object in the model using a processor. Upon detection of a new object from the stream, a corresponding generic object in the model can be constructed. Further objects and classes in the model that are associated with the generic objects and classes can be referenced.

Abstract: A computer-usable storage medium having instructions embodied therein that when executed cause a computer system to perform a method for binding data in an application. An expression is created via a framework based on input from a developer. The expression is received at an expression engine wherein the expression describes a relation between a first property of a first data of the application to a first property of a second data of the application. A binding is created between the first data and the second data based on the relation via the expression engine. The first property of the second data is changed based on a change to the first property of the first data wherein the changing occurs because of the binding. The receiving the expression, the creating the binding, and the changing the first property are orchestrated via the framework to manage when the expression is executed in the application.

Abstract: Provided are methods and computer program products for monitoring the performance of network applications executing within operating-system-level virtualization containers. Methods may include enumerating operating-system-level virtualization containers on a networked device; creating a named pipe accessible by at least one application running in each operating-system-level virtualization container; retrieving, via the named pipe, performance data gathered by the at least one application, including an identification of each operating-system-level virtualization container; generating metrics based on the retrieved performance data; and generating an event incorporating the metrics, including operating-system-level virtualization container identifiers.

Abstract: Provided are a computing device provided with a DLL injection function and a DLL injection method. When receiving from an operating system notification of whether a target process corresponding to a program ordered by a user to be executed is created, a process creation module of an injection program executes a launcher process to create the target process as a child process of the launcher process and sets the target process to a suspend mode. A code insertion module receives allocation of a memory region where the target process is stacked, using a process handle of the target process, to insert a code for executing a DLL file to be injected into the target process. A restoration module cancels the suspend mode of the target process to allow the target process to be executed.

Abstract: A system, method and computer program product are provided. In use, a COM server dynamic link library is identified. Further, an emulation layer is inserted in association with the COM server dynamic link library to emulate interfaces exported by the COM server dynamic link library. As an option, it may be determined whether the COM server DLL is loaded, and the emulation layer may be inserted in response to the determination.

Abstract: A method and a computer system are provided for starting a process of an application. When starting the application, the computer system may load a second dll file by default. However, in instances when a first dynamic link library file is to be injected into the process, a driving module adds information about the first dynamic link library file into an import table of the second dynamic link library file. The second dynamic link library file that includes the import table with the added information of the first dynamic link library is loaded into memory. In this manner, the default-loading mechanism of the system is bypassed, and the first dll file is injected by modifying the import table of the second dll file before it is loaded into memory. Therefore, it is not required to load the first dll file while executing the process of the application.

Abstract: Techniques are described herein that are capable of providing backend custom code extensibility. Such extensibility allows custom code to be automatically loaded dynamically (e.g., on-demand) in a runtime that is hosted by a backend-as-a-service (BaaS) module while the runtime is running to provide custom backend features that are defined by the custom code to an application in response to receipt of a request from the application.

Abstract: A system that enables reconciliation of accounts between a mobile virtual network operator (MVNO) and a mobile host operator (MHO) includes an asset loader server that receives data that defines a user event. The asset loader server generates a wholesale bill associated with the user event. The rate charged in the generated wholesale bill is based on a negotiated rate between the MVNO and the MHO that is different that the may be different than the rate at which the MVNO charges the user. The asset loader communicates the generated wholesale bill to a billing interface of the MNVO that is configured to receive an extensible markup language (XML) file that defines a wholesale bill associated with the MHO. The format of the generated wholesale bill is substantially the same as the format of the XML file associated with the MHO.

Abstract: A virtualization system is described herein that facilitates communication between a virtualized application and a host operating system to allow the application to correctly access resources referenced by the application. When the operating system creates a virtualized application process, the virtualization system annotates a data structure associated with the process with an identifier that identifies the virtualized application environment associated with the process. When operating system components make requests on behalf of the originating virtual process, a virtualization driver checks the data structure associated with the process to determine that the helper process is doing work on behalf of the virtualized application process. Upon discovering that the thread is doing virtual process work, the virtualization driver directs the helper process's thread to the virtual application's resources, allowing the helper process to accomplish the requested work with the correct data.

Abstract: A system and method of accessing functions includes running n-bit based code in an n-bit supporting system environment. An m-bit based provider object is instantiated in an m-bit hardware and operating system environment server. The provider object provides an interface between the n-bit based code and m-bit based server functions. m-bit based server functions are accessed from the n-bit based code via the m-bit based provider object.

Abstract: An analysis tool analyzes a software system by simulating runtime binding in order to identify function-level code dependencies. The tool receives a list of one or more entry point functions and identifies other functions that can be invoked if the entry point functions are executed. The tool generates a tracker graph having tracker nodes representing classes that can be instantiated from the entry points. Each tracker node identifies functions/methods in that class that can be invoked from the entry points. If the software system uses an object-relational mapping to a database, the tracker graph also identifies the portions of the database that can be accessed from the entry points. The tool can be used to partition the functionalities of the software system into core and non-core functionalities in order to support upgrading while maintaining high-availability.

Abstract: A system for extending an enterprise resource planning application is provided. The system employs “Add-ins” that each have a functional behavior that is independent of the client on which it executes and a user interface behavior that is dependent on the characteristics of the display, and other characteristics, of the client (i.e., a display target). When a user attempts to invoke an Add-in via the client runtime, the client runtime determines whether the Add-in is available at the user's computer. If not, the client runtime downloads the appropriate artifact for execution at the user's computer. In this environment, neither the client runtime nor the server-side business logic contains the logic used to implement a particular Add-in behavior on the supported display targets. Instead, this logic is contained within separate artifacts associated with a single Add-in having a particular behavior, each artifact implementing the behavior for a specific display target.

Abstract: A method, apparatus, system, article of manufacture, and computer readable storage medium provides the ability to dynamically bind a native assembly from a managed assembly. A managed assembly (e.g., a dynamically linked library (DLL)) is obtained. In the managed assembly, native application program interface entry points are identified. For each of the entry points, intended platform(s) and associated correct native assembly(ies) are specified in the managed assembly. The managed assembly is deployed onto a computer. For example, the single collection of managed and native assemblies can be deployed to all targeted computers, which consist of varying platform environments. During runtime execution, the executing platform of the application is determined. Based on the executing platform, an intended platform is selected and the entry points are bound to the correct native assembly.

Abstract: A computer implemented method, apparatus, and computer-usable program product for exchanging data using data transformation are provided. A first data binding component receives data from a function selector. A set of data bindings capable of invocation by the first data binding component is available. The function selector determines a content type associated with the data. The first data binding component receives the data and the content type from the function selector. The first data binding component invokes a data binding corresponding to the content type from the set of data bindings to transform the data into a data object. The data object has an object name. A target application is determined based on the object name, and the data object is then routed to a target application.

Abstract: Various embodiments implement agents as dynamically linked libraries to run within host processes controlled by an executable agent manager. The agent manager runs as a service or daemon continuously after being loaded into the memory of a computer system. Information concerning agents that are configured to carry out tasks on the computer system is stored in a database accessible to the agent manager. When a task that a particular agent is configured to carry out needs to be done, the agent manager assigns an executable host process to run the agent. The agent manager then sends start and stop commands to the host process to load and halt the agent, respectively.

Abstract: The claimed subject matter provides a system and/or a method that facilitates re-locating a web application associated with a network service utilizing a portion of serialized data. The network service can be any collection of resources that are maintained by a party (e.g., third-party, off-site, etc.) and accessible by an identified user over a network (e.g., WAN, Internet, etc.). An interface component can receive a portion of serialized data with transparent structure related to an application specification. A hydrate component can create a web application independent of a network service based at least in part upon the serialized data, the web application has state within the network service.

Abstract: A method manages a web system having a plurality of sub-systems using a computing device. A web project is created for the web system and is stored in a storage of the computing device. Each of the sub-systems has a directory created under the web project. Programs of each sub-system are compiled to generate a dynamic link library (DLL) document of each sub-system. The DLL document of each sub-system is written into a corresponding directory under the web project.

Abstract: A method and apparatus is disclosed for using an open application interface to enable communications between the components and sub-components of a complex system, such as an OSS system. In a first embodiment, one or more Intelligent Flow Engines (IFEs) are used to register all applications and/or components in the system. Once the applications have been registered, then a component requiring service from another application/component sends a request for service to an IFE. The IFE then determines which provider application can best provide the requested service and binds the requesting application with that provider application. In accordance with another embodiment, when a provider component is taken offline, e.g., for maintenance or to replace that component with a new or upgraded component, the applications of that component are un-registered and any applications that were bound to that component are seamlessly rerouted and are bound with another application if one is available.

Abstract: A first feature (e.g., chart or table) includes a reference to a dynamic pointer. Independently, the pointer is defined to point to a second feature (e.g., a query). The first feature is automatically updated to reflect a current value of the second feature. The reference to the pointer and pointer definition are recorded in a central registry, and changes to the pointer or second feature automatically cause the first feature to be updated to reflect the change. A mapping between features can be generated using the registry and can identify interrelationships to a developer. Further, changes in the registry can be tracked, such that a developer can view changes pertaining to a particular time period and/or feature of interest (e.g., corresponding to an operation problem).

Abstract: Application context changes associated with instantiated applications are monitored at a context tracking device. In response to each application context change, relationship context dependency properties between the instantiated applications and application resources associated with the instantiated applications are evaluated. At least one relationship context dependency property that is used by at least one of the instantiated applications is determined to have changed as a result of an application context change. The at least one relationship context dependency property is updated during runtime based upon the application context change.

Abstract: A sampling based DBR framework which leverages a separate core for program analysis. The framework includes a hardware performance monitor, a DBR service that executes as a separate process and a lightweight DBR agent that executes within a client process. The DBR service aggregates samples from the hardware performance monitor, performs region selection by deducing the program structure around hot samples, performs transformations on the selected regions (e.g. optimization), and generates replacement code. The DBR agent then patches the client process to use the replacement code.

Abstract: Disclosed are a method and system for binding a program object in a source code to one of a number of implementations of the program object, using caching techniques. Binding a program object to a particular implementation includes performing the binding process at compile time and runtime of the source code. During compilation phase, the program objects in the source code are identified, and each of the program objects is assigned a slot in a target cache. The slot is configured to store a pointer that points to a particular implementation of a program object to which the slot is assigned. During execution phase, the particular implementation of the program object is determined based on execution flow of the source code. After the particular implementation is determined, the program object is bound to the particular implementation by updating the assigned target cache slot with a pointer pointing to the particular implementation.

Abstract: A method, a system and computer program product for resolving conflicts in applications are disclosed, A first set of instructions configured to use a second set of instructions is identified during execution of a program having the first set of instructions. A third set of instructions couples the first set of instructions to the second set of instructions. I Incompatibility between the first set of instructions and the second set of instructions is identified, in response to compiling the first set of instructions and compiling the second set of instructions. A mechanism is provided for the third set of instructions to modify the second set of instructions, which result in a modified second set of instructions compatible with the first set of instructions.

Abstract: A method, a system and computer program product for resolving conflicts in applications are disclosed, A first set of instructions configured to use a second set of instructions is identified during execution of a program having the first set of instructions. A third set of instructions couples the first set of instructions to the second set of instructions. I Incompatibility between the first set of instructions and the second set of instructions is identified, in response to compiling the first set of instructions and compiling the second set of instructions. A mechanism is provided for the third set of instructions to modify the second set of instructions, which result in a modified second set of instructions compatible with the first set of instructions.

Abstract: A system for providing programmable logic data on demand includes a portion for receiving a plurality of data requests at the programmable logic controller and a portion for processing the plurality of data requests asynchronously. An interface enables asynchronous processing to enhance and extend capabilities of the programmable logic controller.

Abstract: Systems and methods that enhance and balance a late binding and an early binding in a programming language, via supplying an option component to opt-in (or opt-out) late binding, and wherein a late binding is triggered based on a static type for the variable (e.g., object or a type/string.) Additionally, the variable is enabled to have different static types at different regions (e.g., a program fragment) of the programming language.

Abstract: A computer system may provide various resources to users through one or more programming libraries, such as application programming interfaces (APIs), in order to standardize access to such resources through various general-purpose mechanisms. These programming libraries may be operated by other programs, such as task-specific user interfaces, through which a user may utilize the programming library without having to understand its structure and functions. However, in many scenarios, a user may wish to know the manner of invoking a programming library to achieve an invoked behavior, or may wish to reproduce the behavior without having to utilize the user interface. A user may therefore capture an invocation of the programming library, and may generate an instruction set representing the captured invocation that may be studied, copied, modified, subsequently performed, etc.

Abstract: A computer system may comprise a computer platform and input-output devices. The computer platform may include a plurality of heterogeneous processors comprising a central processing unit (CPU) and a graphics processing unit) GPU, for example. The GPU may be coupled to a GPU compiler and a GPU linker/loader and the CPU may be coupled to a CPU compiler and a CPU linker/loader. The user may create a shared object in an object oriented language and the shared object may include virtual functions. The shared object may be fine grain partitioned between the heterogeneous processors. The GPU compiler may allocate the shared object to the CPU and may create a first and a second enabling path to allow the GPU to invoke virtual functions of the shared object. Thus, the shared object that may include virtual functions may be shared seamlessly between the CPU and the GPU.

Abstract: A software development application determines whether routine name and version number parameters have been identified (33). If so, the application determines whether the specified version of the routine can be accessed (35). If the specified version cannot be accessed, the application locates a substitute version of the routine (37) and compiles and links the routines and a source file to produce an executable file (39).

Abstract: Application code for deployment to a client over a data link is optimized to minimize download time by supplying only the application code with a particular object that is required by the object. In a web application that includes multiple pages, the HTML and JAVASCRIPT are scanned to identify code resources called by a particular web page. When all called resources are identified, they are extracted and concatenated into a single resource file. When the page is downloaded to the client, the import file is included with the page. The import file may be cached so that it need only be downloaded once, rather than being downloaded every time the page is requested. The invention is suitable for use with other interpreted scripting languages.

Abstract: A technique is provided for generating stubs. A processing circuit receives a call to a called function. The processing circuit retrieves a called function property of the called function. The processing circuit generates a stub for the called function based on the called function property.

Abstract: A hooking system for hooking predetermined references to predetermined dynamically loaded library (DLL) functions includes a DLL version identifier provided by a hook entry code to an enhanced hook. The hook entry code is dynamically generated during runtime of an affected software application. The version identifier enables unambiguous communication of a single enhanced hook with functions of multiple versions of identically named DLLs loaded into the same isolated process memory area.

Abstract: Embodiments of the invention provide techniques that improve resource management on a massively parallel computing system having a plurality of hybrid compute nodes. For example, a job scheduler may be provided which determines a library to link to an application based on system and user requirements. In one embodiment, the libraries may provide optimizations for job execution time, and also provide optimizations directed towards a specific processor architecture. Once the library is determined, the job scheduler may configure the environment of the application so that the application links with the optimized library during run-time. Doing so may improve overall system performance of the massively parallel computing system.

Abstract: A method of providing transports for a data distribution middleware over a plurality of transport networks is provided. A data distribution middleware with a pluggable transport layer is provided. A plurality of transport plugins in the transport layer are provided. Aliases are assigned to each of the transport plugins of the plurality of transport plugins, wherein at least one of the transport plugins of the plurality of transport plugins has a plurality of aliases.

Abstract: Fault isolation capabilities made available by user space can be provided for a embedded network storage system without sacrificing efficiency. By giving user space processes direct access to specific devices (e.g., network interface cards and storage adapters), processes in a user space can initiate Input/Output requests without issuing system calls (and entering kernel mode). The multiple user spaces processes can initiate requests serviced by a user space device driver by sharing a read-only address space that maps the entire physical memory one-to-one. In addition, a user space process can initiate communication with another user space process by use of transmit and receive queues similar to transmit and receiver queues used by hardware devices. And, a mechanism of ensuring that virtual addresses that work in one address space reference the same physical page in another address space is used.

Abstract: One embodiment of the system disclosed herein facilitates identifying a system call in an application and replacing the identified system call with a customized function call. During operation, the system executes an executable file of the application, wherein the executable file has been modified to execute a hooking and injection manager at run time. Prior to executing the system call, the system executes the hooking and injection manager. While executing the hooking and injection manager, the system determines, from a symbol table, a symbol table index value corresponding to a symbol associated with the system call. The system further determines an import table entry storing a pointer to the system call based on the symbol table index value, and changes the pointer in the import table entry so that the pointer indicates an address of the customized function call.

Abstract: A computer-implemented method, system, and medium is disclosed for implementing a hybrid application server. The server is configured to determine that a bundle deployed onto a dynamic module system defines a component that is manageable by an application server component container. In response to the determining, the application server deploys the component onto the component container and creates an instance of the component in the container so that the container can manage the component. Finally, the application server registers a proxy handle to the component as a service in the dynamic module system. Thereafter, the proxy handle is discoverable and invocable by another component.

Abstract: Disclosed are various embodiments for the mapping of behavior to data. Multiple behavior elements from a code library that are compatible with one or more data elements of a document are automatically determined according to a data contract associated with each one of the behavior elements. Each of the behavior elements is configured to consume one or more data elements and produce a network page feature according to a behavior. One or more of the behavior elements are selected automatically according to a plurality of rules, thereby producing one or more selected behavior elements. A mapping of the one or more selected behavior elements to the one or more data elements is automatically generated.

Abstract: An end-to-end approach is provided for developing and maintaining network device management applications. The approach includes an XML-based development environment for network device management applications that uses Management Data API (MDA) schemas that define a hierarchical data model for components supported by a network device. The XML-based development environment also uses XML schemas to define a common XML-based interface used by management applications to access management data maintained on the network device. The approach provides programmatic access to network device management data and management data schema with an XML-based data model and interface that is consistent across all network device components. The approach includes mechanisms for automatically generating XML requests that conform to a hierarchical data model from requests that conform to a table-based data model.

Abstract: Provided are a computing device provided with a DLL injection function and a DLL injection method. When receiving from an operating system notification of whether a target process corresponding to a program ordered by a user to be executed is created, a process creation module of an injection program executes a launcher process to create the target process as a child process of the launcher process and sets the target process to a suspend mode. A code insertion module receives allocation of a memory region where the target process is stacked, using a process handle of the target process, to insert a code for executing a DLL file to be injected into the target process. A restoration module cancels the suspend mode of the target process to allow the target process to be executed.

Abstract: An information processing terminal enables, during the execution of a predetermined application program, the addition of an additional program and the execution of the additional program in a predetermined memory. The information processing terminal includes a management device, an acquisition device, an execution device, and a deletion device. The management device manages the additional program and a plug-in point included in the application program by associating the additional program with the plug-in point. The acquisition device acquires, upon execution of the application program up to the plug-in point, the additional program associated with the plug-in point from a predetermined storage device. The execution device executes the acquired additional program in the memory. The deletion device deletes, upon completion of the execution of the additional program, the additional program from the memory.

Abstract: A method of building and assembling programs across computer networks that is dictated by the user to perform logical work without the user using a compiler. Users are able to assemble programs over a network by defining or re-defining which logical components are bound into the overall program without the use of a compiler. Logical components are called and bound into the program at run time, allowing dynamic programming which may be modified at any time without re-compiling the entire program. Each logical component can act independently of other logical components or work in concert with each other. This allows assembly of a program, even though some components may be created using totally different methodologies and/or are constructed by different programmers.

Abstract: A technique is provided for handling dynamically linked subject function calls arranged pass subject control flow to an intermediate control structure such as a procedure linkage table, then to subject linker code for modifying link information associated with the subject function calls during translation of subject code into target code in a dynamic binary translator. The subject code for execution on a subject processor is received by a translator, and corresponding target code for execution on the target processor is generated. The translator is arranged to build a function linkage table containing an entry giving the location of each function called by the subject code, so that code can be generated by the translator in which subject function calls are associated with code for performing the function, without generating target code corresponding to the intermediate control structure.

Abstract: Remote event receivers can register with a document repository computing system to receive notifications of events occurring at a document repository. The remote event receivers may register to receive notifications synchronously, whereby the remote event receivers can provide a response to the notification prior to the occurrence of the event, or asynchronously, whereby the remote event receivers provide no response. Synchronous remote event receivers can also specify in a response to the notification that the event should be canceled or may specify properties that should be changed. Remote event receivers can be pre-event receivers that receive notifications prior to the occurrence of an event, or post-event receivers that receive notifications following the event. When an event is to occur at the document repository, notifications are provided to the pre-event remote event receivers. Once the event has occurred, notifications are provided to the post-event remote event receivers.

Abstract: An installer for adding an Android platform dynamic library comprises a unit for generating an external directory which generates an external directory for storing a library, a unit for generating library information which generates library information including at least one of library name information and library location information, and a control unit which stores the library in the external directory and stores the generated library information in an external library management directory.

Abstract: Systems and methods for automatically controlling conditions of a process are disclosed. In one example, a controller is programmed with a sequence of steps and parameters required to carry out a bioreactor process. The controller receives information related to a condition of the process over a first communication network, determines a control signal based on the received information and the programmed process, and sends the control signal over a second communication network to a benchtop utility tower. In one example, the utility tower can include transmitters for temperature, pH, and dissolved oxygen that send information related to a condition of the process to the controller over the first communication network, and an agitation system, a gas control system, a temperature control system and a pump control system that perform a control action based on the control signal affecting the process condition.