WO2017190663A1

WO2017190663A1 - Linux-based registry service system and method, and financial self-service device

Info

Publication number: WO2017190663A1
Application number: PCT/CN2017/082939
Authority: WO
Inventors: 林宇龙; 熊飞; 黄三朋; 潘煜豪; 梁建明
Original assignee: 广州广电运通金融电子股份有限公司
Priority date: 2016-05-04
Filing date: 2017-05-03
Publication date: 2017-11-09
Also published as: CN105912952B; CN105912952A

Abstract

Disclosed is a Linux-based registry service system, comprising: a memory registry construction unit for loading a registry data file in an operating system, reading configuration table data already saved in the registry data file by means of a database interface, and constructing, in a memory, a memory registry; a registry operation unit for collecting node data from a registry editor or a user process, and transmitting the node data to a registry service unit; and the registry service unit for performing, according to an operation mode for the memory registry, a corresponding operation on a node corresponding to the node data in the memory registry. Also disclosed are a Linux-based registry service method and a financial self-service device. By performing, in a memory, an operation of node data in a memory registry of, a unified, efficient and secure registry configuration data operation can be provided for running all the software, and the requirement of data sharing between various processes is satisfied.

Description

Linux-based registry service system, method and financial self-service device

Technical field

The invention relates to the field of self-service terminals, in particular to a Linux-based registry service system, method and financial self-service device.

Background technique

The registry is a core database in the Windows operating system, which stores various parameters, directly controls the startup of windows, the loading of hardware drivers, and the operation of some windows applications, thus playing a central role in the entire system. These functions include software and hardware related configuration and status information, such as the initial conditions, preferences, and uninstallation data of the application and the resource manager shell stored in the registry, the settings of the entire system of the networked computer, and each Permissions, file extensions associated with applications, descriptions of hardware components, status and properties, performance logging and other underlying system state information, and other data.

There is no registry service similar to Windows under Linux system. There is no operation interface for temporary configuration data under Linux system, which is the operation interface of temporary configuration data stored in memory.

However, for security reasons, Linux systems are generally used in financial industry applications. In order to solve the data configuration problem, in the now autonomous controllable Linux system, the memory configuration table can be used to ensure effective backup and restoration of memory data in the event of a disaster. However, the program reads and saves most of the configuration directly in the file. There is no unified interface operation, which is inconvenient for code compatibility between various systems. Moreover, the speed of reading data is slow, and the modification of the registry cannot be guaranteed. And the security of multiple concurrent access.

Summary of the invention

In view of the above problems, an object of the present invention is to provide a Linux-based registry service system, method, and financial self-service device, which can implement a registry service with good compatibility, read and write security, and multiple concurrent access security.

The invention provides a Linux-based registry service system, comprising:

a memory registry building unit, configured to load a registry data file under the operating system, and read the saved configuration table data in the registry data file through a database interface, and construct a memory registry in the memory;

a registry operating unit for collecting node data from a registry editor or a user process and numbering the nodes According to transmission to the registry service unit;

The registry service unit is configured to perform corresponding operations on the node corresponding to the node data in the memory registry according to an operation manner of the memory registry, and after the operation is completed, according to the operation result The registry operation unit returns an operation confirmer; wherein the operation mode is one of reading, writing, and deleting.

Preferably, the memory registry is a configuration table for writing temporary configuration data into the memory according to a pre-designed data structure without writing to the disk, wherein the memory registry is composed of at least one node, and each The nodes include a master node and a child node, and the master node includes a master node id, and the child node includes a child node id and a node data value.

Preferably, the operation confirmation code is an acknowledgement character or a negative response character, the node data includes a primary node and a child node, the primary node includes a primary node id, and the child node includes a child node id and a node data value; The mode of operation is read;

The registry service unit specifically includes:

a first id obtaining module, configured to acquire the primary node id and the child node id from the node data;

a reading module, configured to send the primary node id and the child node id into the read interface of the memory registry, and query whether the memory registry has the same primary node id as the node data and a node of the child node id; if so, reading the node data value in the node data, and returning the node data and the confirmation character to the registry operation unit; if not, to the registry operation unit Return a negative response character;

The registry operating unit is further configured to: after receiving the confirmation character and the node data, confirm that the reading operation is successful, and deliver the node data to the registry editor or the user process; After receiving the negative response character, it is confirmed that the read operation has failed, and the read failure information is fed back to the registry editor or the user process.

Preferably, the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a primary node id, a child node id, a node data value, and a temporary data mark; the operation mode is writing;

The registry service unit specifically includes:

a second id obtaining module, configured to acquire the primary node id and the child node id from the node data;

a writing module, configured to send the primary node id and the child node id into a read interface of the memory registry, and query whether the memory registry has the same primary node as the node data a node of the id and the child node id; if yes, modifying the node data value of the node that is queried to the node data value of the node data; if not, adding the node data to the memory registry in;

a first temporary data determining module, configured to determine whether the temporary data flag of the node data is 0, and if yes, return a confirmation character to the registry operating unit; if not, call the database interface to call the node data Write to the registry data file and return a confirmation character to the registry operating unit.

Preferably, the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a master node id and a child. Node id, node data value, and temporary data tag; the operation mode is deletion;

The registry service unit specifically includes:

a third id obtaining module, configured to acquire the primary node id and the child node id from the node data;

a deleting module, configured to send the primary node id and the child node id into the read interface of the memory registry, and query whether the memory registry has the same primary node id and the child data as the node data a node of the node id; if so, deleting the node and notifying the second temporary data determination module; if not, returning a negative response character to the registry operation unit;

The second temporary data determining module is configured to determine whether the temporary data flag of the node data is 0, and if yes, return a confirmation character to the registry operating unit; if not, calling the database interface to Node data is deleted from the registry data file and a confirmation character is returned to the registry operating unit.

The invention also provides a Linux-based registry service method, comprising:

Loading a registry data file under the operating system, and reading the saved configuration table data in the registry data file through the database interface, and constructing a memory registry in the memory;

Collect node data from a registry editor or user process;

Performing, according to the operation mode of the memory registry, a node corresponding to the number of nodes in the memory registry, and after the operation is completed, generating an operation confirmer according to the operation result; wherein the operation The mode is one of reading, writing, and deleting.

Preferably, the memory registry is a configuration table for writing temporary configuration data into the memory according to a pre-designed data structure without writing to the disk, wherein the memory registry is composed of at least one node, and each The nodes include at least a primary node id, a child node id, and a node data value.

Preferably, the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a primary node id, a child node id, and a node data value; the operation mode is read;

Then, according to the node data and the operation mode of the memory registry, perform corresponding operations on the memory registry, and after the operation is completed, generate an operation confirmation identifier according to the operation result, which specifically includes:

Obtaining the primary node id and the child node id from the node data;

Passing the master node id and the child node id into the read interface of the memory registry, and querying whether there is a node in the memory registry that has the same master node id and child node id as the node data; If so, the node data value in the node data is read and a confirmation character is generated; if not, a negative response character is generated.

Then, according to the node data and an operation manner for the memory registry, performing the phase on the memory registry The operation should be performed, and after the operation is completed, an operation confirmation will be generated according to the operation result, including:

Obtaining the primary node id and the child node id from the node data;

Passing the master node id and the child node id into the read interface of the memory registry, and querying whether the memory registry has the same master node id and child node id as the node data. a node; if yes, modifying the node data value of the queried node to a node data value of the node data; if not, adding the node data to the memory registry;

Determining whether the temporary data flag of the node data is 0, and if so, generating a confirmation character; if not, generating a confirmation character after calling the database interface to write the node data into the registry data file.

Preferably, the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a primary node id, a child node id, a node data value, and a temporary data identifier; the operation mode is deletion;

Obtaining the primary node id and the child node id from the node data;

Passing the primary node id and the child node id into the read data interface of the memory registry, and querying whether there is a node in the memory registry that has the same primary node id and child node id as the node data. And if so, deleting the node and determining whether the temporary data tag of the node data is 0, and if so, generating a confirmation character; if not, calling the database interface to retrieve the node data from the registry data After the file is deleted, a confirmation character is generated; if not, a negative response character is generated.

The invention also provides a financial self-service device, including the above-mentioned Linux registry service system.

The Linux-based registry service system and method provided by the embodiments of the present invention can provide a unified function for all running software by constructing a memory registry in the memory and performing node data operation in the memory registry in the memory. Efficient and secure registry configuration data operations to meet the needs of data sharing between processes. At the same time, it can also realize the file format compatible with the windows registry, and provide an efficient windows platform code porting interface, which can quickly transplant the windows code to the Linux kernel platform. In addition, because it operates in memory, it also provides efficient storage and secures registry read and write security and multiple concurrent access.

The Linux-based registry service system and method of the invention are applied to financial self-service devices (such as ATM ATM, remote video teller machine VTM, clearing machine, etc.), which can realize system autonomous control and improve equipment security.

DRAWINGS

In order to more clearly illustrate the technical solutions of the present invention, the drawings used in the embodiments will be briefly described below. It is obvious that the drawings in the following description are only some embodiments of the present invention, which are common in the art. Technology For the personnel, other drawings can be obtained based on these drawings without paying creative labor.

FIG. 1 is a schematic structural diagram of a Linux-based registry service system according to an embodiment of the present invention.

FIG. 2 is a schematic diagram of the working principle of a Linux-based registry service system according to an embodiment of the present invention.

FIG. 3 is a data structure diagram of a memory registry provided by an embodiment of the present invention.

4 is a data structure diagram of a node of the memory registry shown in FIG.

FIG. 5 is a schematic diagram of the working principle of a registry operation unit according to an embodiment of the present invention.

FIG. 6 is a schematic structural diagram of a registry service unit according to an embodiment of the present invention.

FIG. 7 is a schematic structural diagram of a registry service unit according to an embodiment of the present invention.

FIG. 8 is a schematic structural diagram of a registry service unit according to an embodiment of the present invention.

FIG. 9 is a schematic flowchart of a Linux-based registry service method according to an embodiment of the present invention.

FIG. 10 is a flowchart of execution of a registry operation unit according to an embodiment of the present invention.

FIG. 11 is a flowchart of execution of a memory registry building unit and a registry service unit according to an embodiment of the present invention.

detailed description

The technical solutions in the embodiments of the present invention are clearly and completely described in the following with reference to the accompanying drawings in the embodiments of the present invention. It is obvious that the described embodiments are only a part of the embodiments of the present invention, but not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative efforts are within the scope of the present invention.

Referring to FIG. 1 and FIG. 2, the present invention provides a Linux-based registry service system (hereinafter referred to as a registry service system) 100. The registry service system 100 includes a memory registry building unit 10 and a registry operating unit. 20 and registry service unit 30, wherein:

The memory registry building unit 10 is configured to load a registry data file under an operating system, and read the saved configuration table data in the registry data file through a database interface, and construct a memory registry in the memory.

In the embodiment of the present invention, after the registry service system 100 is started, the memory registry building unit 10 can load a registry data file under the operating system (for a Linux system, /etc/reg.dat can be loaded). And through the database interface (such as sqlite3 interface) read the saved configuration table data in the registry data file, build a memory registry in memory.

In the embodiment of the present invention, the memory registry is a configuration table that writes temporary configuration data into the memory according to a pre-designed data structure without writing to the disk, and the memory registry is restarted in the system. After resetting, the memory registry will be deleted after the system is restarted.

Referring to FIG. 3 together, the memory registry is composed of a plurality of nodes, wherein each node includes at least one master. A node (tabRegNode) and a child node (tabRegItem), the data structure of the master node and the child node is as shown in FIG. 4, wherein FK is a database foreign key, and PK is a database primary key.

The registry operating unit 20 is configured to collect node data from a registry editor or a user process, and transmit the node data to the registry service unit 30.

In the embodiment of the present invention, the node data also has a data structure as shown in FIG. 4.

Referring to FIG. 5 together, in the embodiment of the present invention, the registry operation unit 20 can input the node data to the interface by calling the RegAPI read/write data interface, and thereafter, the registry operation unit 20 The node data is encapsulated into a data stream format suitable for transmission (such as a binary data stream) and sent to the registry service unit 30 via the TCP/IP protocol.

In the embodiment of the present invention, after the encapsulated node data is sent to the registry service unit 30, the registry operation unit 20 waits for an operation confirmation code returned by the registry service unit 30. The operation confirmation code may include a return confirmation character (Ack) and a negative response character (Nak).

The registry service unit 30 is configured to perform corresponding operations on the node corresponding to the node data in the memory registry for the operation mode of the memory registry, and after the operation is completed, according to the operation result The registry operation unit 20 returns an operation confirmer; wherein the operation mode is one of reading, writing, and deleting.

In the embodiment of the present invention, the operations on the memory registry mainly include reading, writing (including modification and addition), and deleting. The following will be explained one by one.

Please refer to FIG. 6 together, when the operation mode is read:

The registry service unit 30 specifically includes:

The first id obtaining module 31 is configured to obtain the primary node id and the child node id from the node data.

In the embodiment of the present invention, after receiving the node data, the registry service unit 30 obtains the master node id and the child node id from the node data after parsing the node data.

The reading module 32 is configured to pass the primary node id and the child node id into the read interface of the memory registry, and query whether the memory registry has the same primary node id as the node data. And a node of the child node id; if yes, reading the node data value in the node data, and returning the confirmation character (Ack) and the encapsulated node data to the registry operation unit 20 through the tcp/ip protocol; If not, a negative response character (Nak) is returned to the registry operating unit 20 via the tcp/ip protocol.

In the embodiment of the present invention, after receiving the confirmation character and the node data, the registry operation unit 20 confirms that the read operation is successful, and after parsing the node data, transfers the node data. Up to the registry editor or the user process; after receiving the negative response character, confirming that the read operation failed, and feeding back the read failure information to the registry editor or the user process.

Please refer to Figure 7, when the operation mode is write (including modification and addition):

The registry service unit 30 specifically includes:

The second id obtaining module 33 is configured to obtain the primary node id and the child node id from the node data.

The writing module 34 is configured to send the primary node id and the child node id into the read interface of the memory registry, and query whether the memory registry has the same master as the node data. a node id and a node of the child id; if yes, modifying the node data value of the queried node to a node data value of the node data; if not, adding the node data to the memory registration In the table.

The first temporary data determining module 35 is configured to determine whether the temporary data flag of the node data is 0, and if yes, return a confirmation character to the registry operating unit 20; if not, calling the database interface to The node data is written into the registry data file and a confirmation character is returned to the registry operation unit 20.

In the embodiment of the present invention, if the temporary data flag (tmp) is 0, the node data is temporary data, and only needs to be written on the memory registry, that is, storage to disk is not required. on. If it is not 0, it indicates that the node data is non-temporary data, in addition to writing in the memory registry, it needs to be written into the registry data file under the operating system (that is, written to /etc/ In reg.dat).

In the embodiment of the present invention, after receiving the confirmation character and the node data, the registry operation unit 20 confirms that the write operation is successful; after receiving the negative response character, confirms that the write operation fails. And feeding back the failure information to the registry editor or the user process.

Please refer to FIG. 8 when the operation mode is deleted:

The registry service unit 30 specifically includes:

The third id obtaining module 36 is configured to obtain the primary node id and the child node id from the node data.

The deleting module 37 is configured to send the primary node id and the child node id into the read interface of the memory registry, and query whether the memory registry has the same primary node id as the node data and a node of the child node id; if so, deleting the node and notifying the second temporary data determining module 38; if not, returning a negative response character to the registry operating unit 20;

The second temporary data determining module 38 is configured to determine whether the temporary data flag of the node data is 0, and if yes, return a confirmation character to the registry operating unit; if not, invoke the database interface The node data is deleted from the registry data file and a confirmation character is returned to the registry operating unit.

In the embodiment of the present invention, after receiving the confirmation character and the node data, the registry operation unit 20 confirms that the deletion operation is successful; after receiving the negative response character, confirms that the deletion operation fails, and The registry The editor or the user process feedback deletes the failure information.

It should be noted that, in the foregoing embodiment, if the registry operation unit 20 does not receive the operation confirmation code returned by the registry service unit 30 within a predetermined time, the registry operation unit 20 reports a communication timeout. , notify the registry editor or user operation failed, and end this operation.

In summary, the registry service system 100 provided by the embodiment of the present invention constructs a memory registry in the memory through the memory registry building unit 10, and the registry service unit 30 performs data operations in the memory registry. It provides a unified, efficient, and secure registry configuration data operation for all running software to meet the data sharing needs of each process. At the same time, it can also realize the file format compatible with the windows registry, and provide an efficient windows platform code porting interface, which can quickly transplant the windows code to the Linux kernel platform. In addition, because the operation of the memory registry is performed in memory, it can provide efficient storage and ensure the security of the registry read and write security and multiple concurrent access.

Referring to FIG. 9 together, the present invention further provides a Linux-based registry service method, which can be executed by the foregoing registry service system 100, and includes the following steps:

S101: Load a registry data file under an operating system, and read the saved configuration table data in the registry data file through a database interface, and construct a memory registry in the memory.

In the embodiment of the present invention, after the registry service system is started, the registry data file under the operating system can be loaded (for Linux system, /etc/reg.dat can be loaded), and the database interface (such as sqlite3 interface) is used. The saved configuration table data is read in the registry data file, and the memory registry is built in the memory.

The memory registry is a configuration table for writing temporary configuration data into the memory according to a pre-designed data structure without writing to the disk. The specific data structure of the memory registry can be referred to FIG. 3 and FIG. 4.

S102. Collect node data from a registry editor or a user process.

In the embodiment of the present invention, the registry operation unit 20 may pass the node data to the interface by calling the RegAPI read/write data interface, after which the registry operation unit 20 encapsulates the node data into a suitable transmission. The data stream format (e.g., binary data stream) is sent to the registry service unit 30 via the TCP/IP protocol.

S103. Perform a corresponding operation on a node corresponding to the node data in the memory registry according to an operation manner of the memory registry, and generate an operation confirmation identifier according to the operation result after the operation is completed; The operation mode is one of reading, writing, and deleting.

The operation mode is reading;

Step S103 specifically includes:

S1031: Acquire the primary node id and the child node id from the node data.

S1032, the master node id and the child node id are sent to the read interface of the memory registry, and query whether the memory registry has the same master node id and child node id as the node data. a node; if so, reading the node data value in the node data and generating a confirmation character; if not, generating a negative response character.

When the operation mode is write, step S103 specifically includes:

S1033. Acquire the primary node id and the child node id from the node data.

S1034, the master node id and the child node id are sent into the read interface of the memory registry, and query whether the memory registry has the same master node id and child node as the node data. a node of id; if so, modifying the node data value of the queried node to a node data value of the node data; if not, adding the node data to the memory registry.

S1035, determining whether the temporary data flag of the node data is 0, and if so, generating a confirmation character; if not, generating a confirmation character after calling the database interface to write the node data into the registry data file .

When the operation mode is deletion, step S103 specifically includes:

S1036. Acquire the primary node id and the child node id from the node data.

S1037. The master node id and the child node id are sent to the read data interface of the memory registry, and query whether the memory registry has the same master node id and child node id as the node data. Node; if so, delete the node and determine whether the temporary data tag of the node data is 0, and if so, generate a confirmation character; if not Yes, a confirmation character is generated after the node interface is called to delete the node data from the registry data file; if not, a negative response character is generated.

In the embodiment of the present invention, after receiving the confirmation character and the node data, the registry operation unit 20 confirms that the deletion operation is successful; after receiving the negative response character, confirms that the deletion operation fails, and The registry editor or the user process feeds back the deletion failure information.

In summary, the Linux-based registry service method provided by the embodiment of the present invention can provide all the software running by constructing a memory registry in the memory and performing node data operation on the memory registry in the memory. A unified, efficient, and secure registry configuration data operation that satisfies the need for data sharing between processes. At the same time, it can also realize the file format compatible with the windows registry, and provide an efficient windows platform code porting interface, which can quickly transplant the windows code to the Linux kernel platform. In addition, in addition, since the operation of the memory registry is performed in the memory, efficient storage can be provided, and the security of the registry read and write security and multi-concurrent access can be ensured.

Please refer to FIG. 10 and FIG. 11 together. FIG. 10 is a flowchart of execution of the registry operation unit. 11 is a flow chart showing execution of the memory registry building unit and the registry service unit.

(1) Reading data:

S13: The registry system service starts running.

S14: The memory registry building unit loads the /etc/reg.dat file, reads the saved configuration table data through sqlite3, and builds the memory registry.

S1: The registry operating unit begins to be called.

S2: The registry editor or user process builds the node data and passes in the node data.

S3: Call the Reg API to read the data interface and pass the node data to the interface.

S4: Encapsulate the node data into a binary data stream.

S5: Send the binary data stream to the registry service unit through the TCP/IP protocol. The Registry Operations Service Unit will operate from S15.

S6: The registry operation unit waits for the registry service unit to return an operation confirmation code. If the Ack is returned, the jump executes S8; if Nak is returned, the jump executes S7; if no confirmation code is returned, the jump executes S11.

S8: Receive Ack data and confirm that the operation is successful.

S9: It is judged whether it is a read operation, and if so, S10 is executed.

S10: Acquire the feedback binary data stream, restore to node data, and send it to the registry editor or user process. Jump to S12.

S7: The Nak data is received, the read operation fails, and the registry editor or the user process fails to be notified. Jump to S12.

S11: No data is returned, report communication timeout, notify the registry editor or the user process fails to read. Jump to S12.

S12: The reading process ends.

S15: The memory registry establishes a TCP/IP connection and waits to receive a binary data stream.

S16: It is judged whether data is received, the data jump S18 is received, and the data jump S17 is not received.

S17: Determine whether to end the service. End the service and jump to S19. Continue running to jump to S15.

S19: Exit the registry service unit.

S18: Parse the binary stream data and construct the node data.

S20: Obtain a tabRegNode id (primary node id) and a tabRegItem id (child node id) from the node data.

S21: judging the data operation mode, the process is to read the data and directly jump to S27.

S27: The node data is transmitted to the read data interface.

S28: Determine whether there is a node in the memory registry that has the same tabRegNode id and tabRegItem id as the incoming node. There is a jump S29, and there is no jump S31.

S29: Read the node data value of the node data.

S30: Send the Ack and node data and the registry operation unit through TCP/IP communication, and jump to S15.

S31: TCP/IP sends Nak and registry operation unit, and jumps to S15.

(2) Write (add/modify) data:

S13: The registry service system starts running.

S1: The registry operating unit begins to be called.

S4: Encapsulate the node data into a binary data stream.

S5: Send the binary data stream to the registry service unit through the TCP/IP protocol. The registry service unit will work from S15.

S6: the registry operation unit waits for the registry service unit to return an operation confirmation code, and if the Ack is returned, the jump executes S8; If Nak is returned, the jump proceeds to S7; if no confirmation code is returned, the jump proceeds to S11.

S8: Receive Ack data and confirm that the operation is successful.

S9: determining whether it is a read operation, the response process is not a read operation, and jumping to S12

S7: Receiving Nak data, adding/modifying data operation fails, notifying the registry editor or user process operation failure. Jump to S12.

S11: No data is returned, the communication is reported to be timed out, and the registry editor or the user process is notified to fail. Jump to S12.

S12: The reading process ends.

S16: It is judged whether data is received, the data jump S18 is received, and the data is not received and jumps to S17.

S19: Exit the registry service unit.

S18: Parse the binary data stream and construct the node data.

S20: Obtain the tabRegNode id and the tabRegItem id value from the node data.

S21: judging the data operation mode, the process is to add/modify the data operation, and directly jump to S22.

S22: Determine whether there is a node in the memory registry that has the same tabRegNode id and tabRegItem id value as the incoming node data. There is a jump S23, and there is no jump S38.

S23: directly modify the node data value with the same tabRegNode id and tabRegItem id value. Jump to S24.

S38: Add node data to the memory registry. Jump to S24.

S24: Read the temporary data mark tmp, if it is 0, jump to S26, otherwise jump to S25.

S25: Call the Sqlite3 interface to write the node data to the /etc/reg.dat file. Jump to S26.

S26: TCP/IP sends the Ack and the registry operation unit, confirms that the data is successfully written, and jumps to S15.

(3) Delete data:

S13: The registry service system starts running.

S1: The registry operating unit begins to be called.

S4: Encapsulate the node data into a binary data stream.

S5: Send the binary data stream to the registry service unit through the TCP/IP protocol. Registry service unit will be from S15 Start working.

S8: Receive Ack data and confirm that the operation is successful.

S12: The reading process ends.

S15: The memory registry establishes a TCP/IP connection and waits to receive binary stream data.

S19: Exit the registry operation service unit.

S18: Parse the binary data stream and construct the node data.

S20: Obtain a tabRegNode id and a tabRegItem id from the node data.

S21: judging the data operation mode, the process deletes the data operation, and directly jumps to S32.

S32: Determine whether there is a node in the memory registry that has the same tabRegNode id and tabRegItem id value as the incoming node data. There is a jump S33, there is no jump S34.

S33: Delete the node in the memory registry that is the same as the tabRegNode id and the tabRegItemid. Jump to S35.

S34: TCP/IP sends a Nak registry operation unit, notifying that the deletion fails, and jumping to S15.

S35: Read the tmp temporary data flag. If it is 0, it jumps to S36, otherwise it jumps to S37.

S37: Call the Sqlite3 interface to remove the node data from the /etc/reg.dat file. Jump to S37.

S37: TCP/IP sends the Ack and the registry operation unit, confirms that the deletion of the data is successful, and jumps to S15.

In summary, the registry service method provided by the embodiment of the present invention can provide a unified, efficient, and secure registration for all running software by constructing a memory registry and performing node data operations in the memory registry. Table configuration data operations to meet the needs of data sharing between processes. At the same time, it can also realize the file format compatible with the windows registry, and provide an efficient windows platform code porting interface, which can quickly transplant the windows code to the Linux kernel platform. In addition, due to the operation of the memory registry, it can provide efficient storage and ensure the security of the registry read and write security and multiple concurrent access.

The invention also provides a financial self-service device, which can be a self-service teller machine ATM, a remote video cabinet A VTM, a sorter, etc., including the Linux-based registry service system 100 described above (or including program code corresponding to the registry service method). The financial self-service device can realize the autonomous control of the system and improve the security of the device.

The above disclosure is only a preferred embodiment of the present invention, and of course, the scope of the present invention is not limited thereto, and those skilled in the art can understand all or part of the process of implementing the above embodiments, and according to the present invention. The equivalent changes required are still within the scope of the invention.

One of ordinary skill in the art can understand that all or part of the process of implementing the foregoing embodiments can be completed by a computer program to instruct related hardware, and the program can be stored in a computer readable storage medium. When executed, the flow of an embodiment of the methods as described above may be included. The storage medium may be a magnetic disk, an optical disk, a read-only memory (ROM), or a random access memory (RAM).

Claims

A Linux-based registry service system, comprising:

a memory registry building unit, configured to load a registry data file under the operating system, and read the saved configuration table data in the registry data file through a database interface, and construct a memory registry in the memory;

a registry operating unit, configured to collect node data from a registry editor or a user process, and transmit the node data to a registry service unit;

The registry service unit is configured to perform corresponding operations on the node corresponding to the node data in the memory registry according to an operation manner of the memory registry, and after the operation is completed, according to the operation result The registry operation unit returns an operation confirmer; wherein the operation mode is one of reading, writing, and deleting.
A Linux-based registry service system according to claim 1, wherein

The memory registry is a configuration table for writing temporary configuration data into a memory according to a pre-designed data structure without writing to a disk, wherein the memory registry is composed of at least one node, and each node includes A master node and a child node, the master node including a master node id, the child node including a child node id and a node data value.
The Linux-based registry service system according to claim 1 or 2, wherein the operation confirmation code is an acknowledgement character or a negative response character, the node data includes a master node and a child node, and the master node includes a master node id, the child node includes a child node id and a node data value; the operation mode is read;

The registry service unit specifically includes:

a first id obtaining module, configured to acquire the primary node id and the child node id from the node data;

a reading module, configured to send the primary node id and the child node id into the read interface of the memory registry, and query whether the memory registry has the same primary node id as the node data and a node of the child node id; if so, reading the node data value in the node data, and returning the node data and the confirmation character to the registry operation unit; if not, to the registry operation unit Return a negative response character;

The registry operating unit is further configured to: after receiving the confirmation character and the node data, confirm that the reading operation is successful, and deliver the node data to the registry editor or the user process; After receiving the negative response character, it is confirmed that the read operation has failed, and the read failure information is fed back to the registry editor or the user process.
The Linux-based registry service system according to claim 1 or 2, wherein the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a master node id, a child node id, and a node data value. And Time data tag; the operation mode is write;

The registry service unit specifically includes:

a second id obtaining module, configured to acquire the primary node id and the child node id from the node data;

a writing module, configured to send the primary node id and the child node id into a read interface of the memory registry, and query whether the memory registry has the same primary node as the node data a node of the id and the child node id; if yes, modifying the node data value of the node that is queried to the node data value of the node data; if not, adding the node data to the memory registry in;

a first temporary data determining module, configured to determine whether the temporary data flag of the node data is 0, and if yes, return a confirmation character to the registry operating unit; if not, call the database interface to call the node data Write to the registry data file and return a confirmation character to the registry operating unit.
The Linux-based registry service system according to claim 1 or 2, wherein the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a master node id, a child node id, and a node data value. And temporary data tags; the operation mode is deletion;

The registry service unit specifically includes:

a third id obtaining module, configured to acquire the primary node id and the child node id from the node data;

a deleting module, configured to send the primary node id and the child node id into the read interface of the memory registry, and query whether the memory registry has the same primary node id and the child data as the node data a node of the node id; if so, deleting the node and notifying the second temporary data determination module; if not, returning a negative response character to the registry operation unit;

The second temporary data determining module is configured to determine whether the temporary data flag of the node data is 0, and if yes, return a confirmation character to the registry operating unit; if not, calling the database interface to Node data is deleted from the registry data file and a confirmation character is returned to the registry operating unit.
A Linux-based registry service method, comprising:

Loading a registry data file under the operating system, and reading the saved configuration table data in the registry data file through the database interface, and constructing a memory registry in the memory;

Collect node data from a registry editor or user process;

Performing, according to the operation mode of the memory registry, a node corresponding to the number of nodes in the memory registry, and after the operation is completed, generating an operation confirmer according to the operation result; wherein the operation The mode is one of reading, writing, and deleting.
The Linux-based registry service method according to claim 6, wherein

The memory registry is a configuration table for writing temporary configuration data into a memory according to a pre-designed data structure without writing to a disk, wherein the memory registry is composed of at least one node, and each node is at least Includes the primary node id, child node id, and node data values.
The Linux-based registry service method according to claim 6 or 7, wherein the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a primary node id, a child node id, and a node data value. The operation mode is read;

Then, according to the node data and the operation mode of the memory registry, perform corresponding operations on the memory registry, and after the operation is completed, generate an operation confirmation identifier according to the operation result, which specifically includes:

Obtaining the primary node id and the child node id from the node data;

Passing the master node id and the child node id into the read interface of the memory registry, and querying whether there is a node in the memory registry that has the same master node id and child node id as the node data; If so, the node data value in the node data is read and a confirmation character is generated; if not, a negative response character is generated.
The Linux-based registry service method according to claim 6 or 7, wherein the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a primary node id, a child node id, and a node data value. And temporary data mark; the operation mode is write;

Then, according to the node data and the operation mode of the memory registry, perform corresponding operations on the memory registry, and after the operation is completed, generate an operation confirmation identifier according to the operation result, which specifically includes:

Obtaining the primary node id and the child node id from the node data;

Passing the master node id and the child node id into the read interface of the memory registry, and querying whether the memory registry has the same master node id and child node id as the node data. a node; if yes, modifying the node data value of the queried node to a node data value of the node data; if not, adding the node data to the memory registry;

Determining whether the temporary data flag of the node data is 0, and if so, generating a confirmation character; if not, generating a confirmation character after calling the database interface to write the node data into the registry data file.
The Linux-based registry service method according to claim 6 or 7, wherein the operation confirmation code is an acknowledgement character or a negative response character, and the node data includes a primary node id, a child node id, and a node data value. And Temporary data tag; the operation mode is deletion;

Then, according to the node data and the operation mode of the memory registry, perform corresponding operations on the memory registry, and after the operation is completed, generate an operation confirmation identifier according to the operation result, which specifically includes:

Obtaining the primary node id and the child node id from the node data;

Passing the primary node id and the child node id into the read data interface of the memory registry, and querying whether there is a node in the memory registry that has the same primary node id and child node id as the node data. And if so, deleting the node and determining whether the temporary data tag of the node data is 0, and if so, generating a confirmation character; if not, calling the database interface to retrieve the node data from the registry data After the file is deleted, a confirmation character is generated; if not, a negative response character is generated.
A financial self-service device, comprising the Linux-based registry service system according to any one of claims 1-5.