WO2020178763A1

WO2020178763A1 - System and method of updating terminal device

Info

Publication number: WO2020178763A1
Application number: PCT/IB2020/051874
Authority: WO
Inventors: Chandu VADDADI POORNA; Gaurav Mehrotra
Original assignee: Innoviti Payment Solutions Private Ltd
Current assignee: Innoviti Payment Solutions Private Ltd
Priority date: 2019-03-04
Filing date: 2020-03-04
Publication date: 2020-09-10
Anticipated expiration: 2021-09-04

Abstract

The present disclosure discloses a method of performing remote updation of software in a terminal device (101). The method includes obtaining a plurality of data segments (106) associated with an update file (105). Finally, the method includes providing the plurality of data segments (106) and an instruction (302) to the terminal device (101) using at least one of a one or more payment transaction messages (301) and one or more data structures (104) associated with the server (102). The terminal device (101) updates the software using the plurality of data segments (106) based on the instruction (302).

Description

TITLE:“SYSTEM AND METHOD OF UPDATING TERMINAL DEVICE”

TECHNICAL FIELD

[001] Embodiments of the present disclosure are related, in general to, management of a terminal device. More particularly, but not exclusively, relates to a system and method of updating a terminal device remotely.

BACKGROUND

[002] Generally, a point of sale (PoS) device or a terminal device is used for processing various forms of payment transactions. For example, a department store or an e-commerce merchant may have a PoS device and use the PoS device for processing payments made by credit card, debit card, gift card, or other kinds of payment cards. The PoS device is manufactured by one or more vendors and the PoS device uses a software or a firmware provided by the one or more vendors. The software installed in the PoS device may need an updation owing to changes in payment transaction messages, one or more requirements of the merchant and the like. Conventionally, if a remote terminal device of a payment system requires a software upgrade or a configuration change or a reinstallation, the terminal device is updated using Universal Serial Bus (USB) based storage medium (with the installation software uploaded into it). The storage medium is physically connected to the remote terminal device and then the update/installation is carried out in the terminal device. This method requires the physical presence of a human with the storage medium or similar within the vicinity of the terminal device to conduct the update. Also, such process of updating software is tedious and time consuming.

[003] The existing methods generate a huge operational cost, failures due to human errors, and poor customer experience since a field engineer is scheduled to visit the premises of the terminal device. Therefore, there is a need for updating the terminal device remotely.

SUMMARY

[004] The present disclosure discloses a method of performing remote updation of software in a terminal device. The method comprises obtaining a plurality of data segments associated with an update file. Finally, the method comprises providing the plurality of data segments and an instruction to the terminal device using at least one of a one or more payment transaction messages and one or more data structures associated with the server. The terminal device updates the software using the plurality of data segments based on the instruction.

[005] Further, the present disclosure discloses a server for performing remote updation of software in a terminal device. The server comprises a processor, and a memory communicatively coupled to the processor. The memory stores the processor instructions, which, on execution, causes the processor to obtain a plurality of data segments associated with an update file. Further, the instructions cause the processor to provide the plurality of data segments and an instruction to the terminal device using at least one of a one or more payment transaction messages and one or more data structures. The terminal device updates the software using the plurality of data segments based on the instruction.

[006] Further, the present disclosure discloses a system performing remote updation of software in a terminal device. The system comprises a server comprising a processor, and a memory communicatively coupled to the processor. The memory stores the processor instructions, which, on execution, causes the processor to obtain a plurality of data segments associated with an update file from a computing unit. Further, the instructions cause the processor to provide the plurality of data segments and an instruction to the terminal device using at least one of one or more payment transaction messages and one or more data structures associated with the server. Further, the system comprises the one or more data structures for storing at least one of the plurality of data segments and the instruction. Furthermore, the system comprises the terminal device for updating the software using the plurality of data segments based on the instruction.

[007] The foregoing summary is illustrative only and is not intended to be in any way limiting. In addition to the illustrative aspects, embodiments, and features described above, further aspects, embodiments, and features will become apparent by reference to the drawings and the following detailed description.

[008] For a better understanding of exemplary embodiments of the present invention, together with other and further features and advantages thereof, reference is made to the following description, taken in conjunction with the accompanying drawings. BRIEF DESCRIPTION OF DRAWINGS

[009] The accompanying drawings, which are incorporated in and constitute a part of this disclosure, illustrate exemplary embodiments and, together with the description, serve to explain the disclosed principles. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The same numbers are used throughout the figures to reference like features and components. Some embodiments of device or system and/or methods in accordance with embodiments of the present subject matter are now described, by way of example only, and with reference to the accompanying figures, in which:

[010] FIG. 1 illustrates an exemplary system for remotely updating software in a terminal device in accordance with some embodiments of the present disclosure;

[011] FIG.2 shows a flowchart illustrating a method for remotely updating software in a terminal device in accordance with some embodiments of the present disclosure;

[012] FIG.3A shows an exemplary updation of software using one or more payment transaction messages in accordance with some embodiments of the present disclosure;

[013] FIG.3B shows an exemplary updation of software using one or more payment transaction messages and one or more data structures in accordance with some embodiments of the present disclosure;

[014] FIG.3C shows an exemplary updation of software using one or more data structures in accordance with some embodiments of the present disclosure; and

[015] FIG.4 shows an exemplary computer system for performing a remote software updation in a terminal device in accordance with some embodiments of the present disclosure.

[016] It should be appreciated by those skilled in the art that any block diagrams herein represent conceptual views of illustrative systems embodying the principles of the present subject matter. Similarly, it will be appreciated that any flow charts, flow diagrams, state transition diagrams, pseudo code, and the like represent various processes which may be substantially represented in computer-readable medium and executed by a computer or processor, whether or not such computer or processor is explicitly shown.

DETAILED DESCRIPTION

[017] In the present document, the word "exemplary" is used herein to mean "serving as an example, instance, or illustration." Any embodiment or implementation of the present subject matter described herein as "exemplary" is not necessarily to be construed as preferred or advantageous over other embodiments.

[018] While the disclosure is susceptible to various modifications and alternative forms, specific embodiment thereof has been shown by way of example in the drawings and will be described in detail below. It should be understood, however that it is not intended to limit the disclosure to the particular forms disclosed, but on the contrary, the disclosure is to cover all modifications, equivalents, and alternative falling within the scope of the disclosure.

[019] The terms“comprises”,“comprising”, or any other variations thereof, are intended to cover a non-exclusive inclusion, such that a setup, device or method that comprises a list of components or steps does not include only those components or steps but may include other components or steps not expressly listed or inherent to such setup or device or method. In other words, one or more elements in a device or system or apparatus proceeded by“comprises... a” does not, without more constraints, preclude the existence of other elements or additional elements in the device or system or apparatus.

[020] FIG. 1 illustrates an exemplary system for remotely updating software in a terminal device in accordance with some embodiments of the present disclosure.

[021] In an embodiment, the system (100) may include a terminal device (101), a server (102), a computing unit (103), one or more data structures (104) (Q1 (104A) and Q2 (104B), herein collectively denoted using (104)) associated with the server (102). The terminal device (101) is connected to the server (102) and the one or more data structures (104) via a communication network (not shown in the figure) using at least one of a wired interface or a wireless interface. Further, the terminal device (101) is at all times in connection with the server (102) via the communication network. The server (102) is connected to the one or more data structures (104) and a computing unit (103) via a communication network (not shown in the figure) using at least one of a wired interface or a wireless interface. For example, the server (102) is a payment gateway and the like. The computing unit (103) is a computer system in an embodiment, a remote server (102) associated with a vendor of the terminal device (101) may be configured to perform the functionalities of the computing unit (103). The communication network (105) may include, for example, a direct interconnection, enterprise network, a Peer to Peer (P2P) network, Local Area Network (LAN), Wide Area Network (WAN), wireless network (e.g., using Wireless Application Protocol (WAP)), the Internet, Wireless Fidelity (Wi-Fi), cellular network, and the like.

[022] In an embodiment, the terminal device (101) is the front-end terminal device (101) (for example, a Point of Sale (PoS) device and the like) and the server (102) processes the one or more payment transaction messages (106) received from the terminal device (101) to an acquiring hank. The one or more payment transaction messages includes a request, or a response associated with a transaction between a customer and a merchant. The terminal device (101) includes a software or a firmware for processing the payment transactions via the server (102). For example, to receive details of the card during the payment transaction, receive the transaction amount, receive a personal identification number (PIN), generate a payment transaction message and communicate the payment transaction message with the server (102), receive a response to the payment transaction message and the like. The software installed in the terminal device (101) may require an updation for optimizing the performance of the terminal device (101), fixing one or more bugs in an existing software, addition, deletion or modification of functionalities associated with the terminal device (101), including compatibility with the modified payment transaction message format or new payment transaction message format and the like. The terminal device (101) may be a master or a slave. The terminal device (101) when configured to operate as a master may request the computing unit (103) via the server (102) for updation of the software. In another embodiment, the computing unit (103) when configured to function as a slave may request the server (102) for updating the software of the terminal device (101).

[023] In an embodiment, the computing unit (103) may generate an update file (105) for updating the software of the terminal device (101). The update file (105) is generated using an existing technique. The update file (105) may include binaries, configuration data, a computer program and the like. The computing unit (103) may generate a plurality of data segments (106) associated with the update file (105) based on at least one of a time lag, a bandwidth, associated with a communication network between the terminal device (101) and the server (102), and size of the update file (105). The time lag may indicate the maximum time for which the terminal may wait to receive the payment transaction message from the server (102). The bandwidth may indicate the speed of transfer of data between the terminal device (101) and the server (102). The size of the update file (105) indicates a number of bytes to be transferred to the terminal device (101). For example, a count of the plurality of data segments to be generated is determined using an equation

(1).

where ti denotes the time lag. For example, if the time lag 200 milliseconds, the size of the update file (105) is 500 megabytes, bandwidth is 1 megabits per second then the count of the plurality of data segments to be generated using the equation (1) is 800. The computing unit (103) divides the update file (105) into 800 data segments.

[024] In an embodiment, the server (102) may include a processor (102A) and a memory (102B) communicatively coupled to the processor (102A). The memory (102B) stores the processor instructions, which, on execution, causes the processor (102A) to obtain a plurality of data segments associated with an update file (105) from the computing unit (103) for updating the software of the terminal device (101). In another embodiment, the server (102) may receive the update file (105) from the computing unit (103). Further, the server (102) may generate the plurality of data segments using the equation (1). Further, the server (102) provides the plurality of data segments and an instruction to the terminal device (101) for updating the software. The server (102) provides the plurality of data segments using at least one of one or more payment transaction messages and one or more data structures (104) associated with the server (102). The one or more data structures (104) may be implemented in one of the server (102) or a remote server (102) associated with the merchant of the terminal device (101), a remote server (102) associated with a vendor or manufacturer of the terminal. For example, the one or more data structures (104) may be implemented using at least one of a point to point message broker with a queue or a pipe, publish and subscribe message broker with a queue or a pipe and the like. [025] In an embodiment, the server (102) may embed each of the plurality of data segments in the one or more payment transaction messages as a payload. The payload in the transaction message indicates a field used to store additional data apart from transaction details associated with a customer and a merchant. The server (102) after providing the plurality of data segments, provides the instruction in one of the one or more payment transaction messages to the terminal device (101). The instruction includes information required for re-constructing the plurality of data segments into the update file (105) and installing the update file (105) to update the software of the terminal device (101).

[026] In an embodiment, the server (102) may send the plurality of data segments to a first data structure (104A) from the one or more data structures (104). Further, the server (102) notifies the terminal device (101) regarding the plurality of data segments in the first data structure (104A) and provides the instruction via the one or more payment transaction messages.

[027] In an embodiment, the server (102) may send the plurality of data segments to a first data structure (104A) from the one or more data structures (104). Further, the server (102) notifies the terminal device (101) regarding the plurality of data segments in the first data structure (104A) and provides the instruction via the second data structure (104B) from the one or more data structures (104).

[028] In an embodiment, the terminal device (101) installs the update file (105) received from the server (102) and updates the software of the terminal device (101). The updating of the software includes at least one of upgrading the software, deploying the software (i.e. replacing the old version of the software with the new version) and configuring the software (i.e. modifying the software) in the terminal device (101) based on the instruction.

[029] In an embodiment, the terminal device (101) and the server (102) may send/receive the payment transaction messages (106) using ISO-8583 message format. Further, the terminal device (101) and the one or more data structures (104), the server (102) and the one or more data structures (104) send/receive the plurality of data segments and the instruction using a client-server protocol. For example, the client-server protocol may include at least one of Secure HyperText Transfer Protocol (HTTPS)s, HyperText Transfer Protocol (HTTP), WebSocket and the like. [030] FIG. 2 shows a flowchart illustrating a method for remotely updating software in the terminal device (101) in accordance with some embodiments of the present disclosure.

[031] The method may be described in the general context of computer executable instructions. Generally, computer executable instructions can include routines, programs, objects, components, data structures, procedures, modules, and functions, which perform specific functions or implement specific abstract data types.

[032] The order in which the method is described is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method. Additionally, individual blocks may be deleted from the methods without departing from the spirit and scope of the subject matter described herein. Furthermore, the method can be implemented in any suitable hardware, software, firmware, or combination thereof.

[033] In an embodiment, the computing unit (103) via the server (102) may check if the terminal device (101) needs the software update. In another embodiment, the terminal device (101) may poll the server (102) and check for the software update. If the terminal device (101) needs the software update, the computing unit (103) generates the plurality of data segments associated with the update file (105) based on at least one of a time lag, bandwidth, associated with a network between the terminal device (101) and the server (102), and size of the update file (105) using the equation (1). Further, the computing unit (103) provides the plurality of data segments to the server (102).

[034] At block 201, the server (102) obtains the plurality of data segments associated with an update file (105).

[035] In an embodiment, the server (102) receives from the computing unit (103) the plurality of data segments associated with the update file (105). In another embodiment, the server (102) receives the update file (105) from the computing unit (103). Further, the server (102) generates the plurality of data segments associated with the update file (105) based on at least one of a time lag, bandwidth, associated with a network between the terminal device (101) and the server (102), and size of the update file (105) using the equation (1). [036] At block 202, the server (102) provides the plurality of data segments and the instruction to the terminal device (101) using at least one of the one or more payment transaction messages and the one or more data structures (104) associated with the server (102). Further, the terminal device (101) updates the software using the plurality of data segments based on the instruction.

[037] In an embodiment, the server (102) provides the plurality of data segments (106) and the instruction (302) using the one or more payment transaction messages (301) as shown in FIG.3A. The server (102) embeds each of the plurality of data segments (106) in the one or more payment transaction messages (301) in the payload field of the payment transaction message as shown in FIG.3A. Further, the server (102) sends the one or more payment transaction messages (301) embedded with the plurality of data segments (106) to the terminal device (101) as shown in FIG.3A. The one or more payment transaction messages (301) are associated with one or more transactions initiated at the terminal device (101). For example, if a customer performs a transaction using a credit card in the terminal device (101), the terminal device (101) sends the transaction details in the one or more payment transaction messages (301) to the server (102). The server (102) may process the transaction and send the result of the transaction along with the plurality of data segments (106) to the terminal device (101) using the one or more payment transaction messages (301) as shown in FIG.3A. Therefore, no new transaction messages are generated for providing the plurality of data segments (106) to the terminal device (101). Furthermore, the server (102) after providing the plurality of the data segments to the terminal device (101), embeds the instruction (302) in the one of the one or more payment transaction messages (301). For example, if the plurality of data segments (106) is provided to the terminal device (101) using an“N” number of one or more payment transaction messages (301). The server (102) embeds the instruction (302) in the“N+l” payment transaction message as shown in FIG.3A. Thereafter, the server (102) sends the one of the one or more payment transaction messages (301) to the terminal device (101) for updating the software in the terminal device (101) as shown in FIG.3A.

[038] In an embodiment, the count of the plurality of data segments ( 106) provided to the terminal device (101) is stored by one of the server (102) or the computing unit (103). Further, the terminal device (101) may query the server (102) regarding the count of the plurality of data segments (106) yet to be received from the server (102). In another embodiment, the server (102) may indicate to the terminal device (101) periodically the count of the plurality of the data segments provided to the terminal device (101). Further, in an embodiment, the server (102) may embed at least one data segment from the plurality of data segments (106) in the payment transaction message and stores the remaining one or more payment transaction messages (301) for the next transmission.

[039] In an embodiment, the server (102) may provide the plurality of data segments (106) and the instruction (302) to the terminal device (101) using the first data structure (104A) and one or more payment transaction messages (301). The server (102) sends the plurality of data segments (106) to the first data structure (104 A) from the one or more data structures (104) as shown in FIG.3B. Further, the server (102) may notify the terminal device (101) to receive the plurality of data segments (106) from the first data structure (104 A) using the one or more payment transaction messages (301). In an embodiment, the server (102) may notify the terminal device (101) along with the instruction (302) for receiving the plurality of data segments (106) from the first data structure (104A). Furthermore, the server (102) embeds the instruction (302) in the one or more payment transaction messages (301) as shown in FIG.3B. Thereafter, the server (102) sends the one or more payment transaction messages (301) to the terminal device (101) for updating the software in the terminal device (101) as shown in FIG.3B.

[040] In an embodiment, the server (102) may provide the plurality of data segments (106) and the instruction (302) to the terminal device (101) using the first data structure (104A) and the second data structure (104B). The server (102) sends the plurality of data segments (106) to the first data structure (104A) from the one or more data structures (104) as shown in FIG.3C. Further, the server (102) may notify the terminal device (101) to receive the plurality of data segments (106) from the first data structure (104 A) using the second data structure (104B). In an embodiment, the server (102) may notify the terminal device (101) along with the instruction (302) for receiving the plurality of data segments (106) from the first data structure (104A). Furthermore, the server (102) sends the instruction (302) to the terminal device (101) via the second data structure (104B) from the one or more data structures (104) for updating the software of the terminal device (101) as shown in FIG.3C. In an embodiment, the terminal device (101) keeps pooling the second data structure (104B) for the instruction (302) from the server (102) for updating the software of the terminal device (101). [041] In an embodiment, the one or more data structures (104) may be implemented using a message broker. The message broker is a middleware used for converting messages from a first message format to a second message format. The Message Broker provides state management and tracking of the terminal devices so that the computing unit (103) or the server (102) need not take the responsibility and the complexity of message delivery to the terminal device (101). The message broker may be implemented using one of a Publish and Subscribe technique or a Point- to-Point technique. The person skilled in the art appreciates the use of message broker to implement the one or more data structures (104) for updating the software of the terminal device (101).

[042] In an embodiment, the instruction (302) includes information for performing at least one of reconstructing the update file (105) from the plurality of data segments (106) and updating the software in the terminal device (101). The terminal device (101) updates the software by decoding the update file (105) and installing the update file (105). Further, updating the software includes at least one of upgrading the software (i.e. adding or deleting the functionalities of the existing software), deploying the software (i.e. installing the new version of the software) and configuring the software (i.e. modifying the functionalities of the existing software) in the terminal device (101) based on the instruction (302). For example, the functionalities may include configuring a display device associated with the terminal device (101), adding a new message format for sending and receiving the payment transaction messages (301) and the like.

[043] The method of performing remote updation of software in the terminal device (101) eliminates the need for a physical user or a field engineer to update each terminal device (101). A plurality of terminal devices can be updated simultaneously. Further, the updation of software using the embodiments of the present disclosure as shown in FIG.3A (refereed as Model (a)), FIG.3B (refereed as Model (b)) and FIG.3C (refereed as Model (c)) are as shown in Table - 1.

Computer System [044] FIG.4 illustrates a block diagram of an exemplary computer system (400) for implementing embodiments consistent with the present disclosure. In an embodiment, the computer system (400) may be used to implement the method performing remote updation of software in the terminal device (101). The computer system (400) may comprise a central processing unit (“CPU” or“processor”) (402). The processor (402) may comprise at least one data processor for executing program components for dynamic resource allocation at run time. The processor (402) may include specialized processing units such as integrated system (bus) controllers, memory management control units, floating point units, graphics processing units, digital signal processing units, etc. [045] The processor (402) may be disposed in communication with one or more input/output

(I/O) devices (not shown) via I/O interface (401). The I/O interface (401) may employ communication protocols/methods such as, without limitation, audio, analog, digital, monoaural, RCA, stereo, IEEE-1394, serial bus, universal serial bus (USB), infrared, PS/2, BNC, coaxial, component, composite, digital visual interface (DVI), high-definition multimedia interface (HDMI), RF antennas, S-Video, VGA, IEEE 802.n /b/g/n/x, Bluetooth, cellular (e.g., code division multiple access (CDMA), high-speed packet access (HSPA+), global system for mobile communications (GSM), long-term evolution (LTE), WiMax, or the like), etc.

[046] Using the I/O interface (401), the computer system (400) may communicate with one or more I/O devices. For example, the input device (410) may be an antenna, keyboard, mouse, joystick, (infrared) remote control, camera, card reader, fax machine, dongle, biometric reader, microphone, touch screen, touchpad, trackball, stylus, scanner, storage device, transceiver, video device/source, etc. The output device (411) may be a printer, fax machine, video display (e.g., cathode ray tube (CRT), liquid crystal display (LCD), light-emitting diode (LED), plasma, Plasma display panel (PDP), Organic light-emitting diode display (OLED) or the like), audio speaker, etc.

[047] In some embodiments, the computer system (400) is connected to the service operator through a communication network (409). The processor (402) may be disposed in communication with the communication network (409) via a network interface (403). The network interface (403) may communicate with the communication network (409). The network interface (403) may employ connection protocols including, without limitation, direct connect, Ethernet (e.g., twisted pair 10/100/1000 Base T), transmission control protocol/Internet protocol (TCP/IP), token ring, IEEE 802.1 la/b/g/n/x, etc. The communication network (409) may include, without limitation, a direct interconnection, e-commerce network, a peer to peer (P2P) network, local area network (LAN), wide area network (WAN), wireless network (e.g., using Wireless Application Protocol), the Internet, Wi-Fi, etc. Using the network interface (403) and the communication network (409), the computer system (400) may communicate with the one or more service operators.

[048] In some embodiments, the processor (402) may be disposed in communication with a memory (405) (e.g., RAM, ROM, etc. not shown in Figure 4 via a storage interface (404). The storage interface (404) may connect to memory (405) including, without limitation, memory drives, removable disc drives, etc., employing connection protocols such as serial advanced technology attachment (SATA), Integrated Drive Electronics (IDE), IEEE- 1394, Universal Serial Bus (USB), fiber channel, Small Computer Systems Interface (SCSI), etc. The memory drives may further include a drum, magnetic disc drive, magneto-optical drive, optical drive, Redundant Array of Independent Discs (RAID), solid-state memory devices, solid-state drives, etc. [049] The memory (405) may store a collection of program or database components, including, without limitation, user interface (406), an operating system (407), web server (408) etc. In some embodiments, computer system (400) may store user/application data (406), such as the data, variables, records, etc. as described in this disclosure. Such databases may be implemented as fault-tolerant, relational, scalable, secure databases such as Oracle or Sybase.

[050] The operating system (407) may facilitate resource management and operation of the computer system (400). Examples of operating systems include, without limitation, APPLE® MACINTOSH® OS X®, UNIX®, UNIX-like system distributions (E.G., BERKELEY SOFTWARE DISTRIBUTION® (BSD), FREEBSD®, NETBSD®, OPENBSD, etc.), LINUX® DISTRIBUTIONS (E.G., RED HAT®, UBUNTU®, KUBUNTU®, etc.), IBM®OS/2®, MICROSOFT® WINDOWS® (XP®, VISTA®/7/8, 10 etc.), APPLE® IOS®, GOOGLETM ANDROIDTM, BLACKBERRY® OS, or the like.

[051] In some embodiments, the computer system (400) may implement a web browser (not shown in the Figure) stored program component. The web browser may be a hypertext viewing application, such as MICROSOFT® INTERNET EXPLORER®, GOOGLETM CHROMETM, MOZILLA® FIREFOX®, APPLE® SAFARI®, etc. Secure web browsing may be provided using Secure Hypertext Transport Protocol (HTTPS), Secure Sockets Layer (SSL), Transport Layer Security (TLS), etc. Web browsers (408) may utilize facilities such as AJAX, HTML, ADOBE® FLASH®, JAVASCRIPT®, JAVA®, Application Programming Interfaces (APIs), etc. In some embodiments, the computer system (400) may implement a mail server (103) stored program component not shown in the Figure). The mail server (103) may be an Internet mail server (103) such as Microsoft Exchange, or the like. The mail server (103) may utilize facilities such as Active server (103) Pages (ASP), ACTIVEX®, ANSI® C++/C#, MICROSOFT®, .NET, CGI SCRIPTS, JAVA®, JAVASCRIPT®, PERL®, PHP, PYTHON®, WEBOBJECTS®, etc. The mail server (103) may utilize communication protocols such as Internet Message Access Protocol (IMAP), Messaging Application Programming Interface (MAPI), MICROSOFT® Exchange, Post Office Protocol (POP), Simple Mail Transfer Protocol (SMTP), or the like. In some embodiments, the computer system (400) may implement a mail client stored program component not shown in the Figure). The mail client may be a mail viewing application, such as APPLE® MAIL, MICROSOFT® ENTOURAGE®, MICROSOFT® OUTLOOK®, MOZILLA® THUNDERBIRD®, etc.

[052] Furthermore, one or more computer-readable storage media may be utilized in implementing embodiments consistent with the present invention. A computer-readable storage medium refers to any type of physical memory on which information or data readable by a processor may be stored. Thus, a computer-readable storage medium may store instructions for execution by one or more processors, including instructions for causing the processors to perform steps or stages consistent with the embodiments described herein. The term“computer-readable medium” should be understood to include tangible items and exclude carrier waves and transient signals, i.e., non-transitory. Examples include Random Access memory (RAM), Read-Only memory (ROM), volatile memory, non-volatile memory, hard drives, Compact Disc (CD) ROMs, Digital Video Disc (DVDs), flash drives, disks, and any other known physical storage media.

[053] In some implementation, the update file (105), and the plurality of data segments (106) may be received from the remote devices (412). In an embodiment, the remote devices (412) may be the computing unit (103).

[054] Finally, the language used in the specification has been principally selected for readability and instructional purposes, and it may not have been selected to delineate or circumscribe the inventive subject matter. It is therefore intended that the scope of the invention be limited not by this detailed description. Accordingly, the disclosure of the embodiments of the invention is intended to be illustrative, but not limiting, of the scope of the invention.

[055] While various aspects and embodiments have been disclosed herein, other aspects and embodiments will be apparent to those skilled in the art. The various aspects and embodiments disclosed herein are for purposes of illustration and are not intended to be limiting. [056] Reference numerals:

Claims

We Claim:

1. A method of performing remote updation of software in a terminal device (101), the method comprises:

obtaining, by a server (102), a plurality of data segments (106) associated with an update file (105); and

providing, by the server (102), the plurality of data segments (106) and an instruction (302) to the terminal device (101) using at least one of a one or more payment transaction messages (301) and one or more data structures (104) associated with the server (102), wherein the terminal device (101) updates the software using the plurality of data segments (106) based on the instruction (302).

2. The method as claimed in claim 1, wherein obtaining the plurality of data segments (106) comprises one of:

receiving from a computing unit (103) the plurality of data segments (106) associated with the update file (105); or

generating the plurality of data segments (106) associated with the update file (105) based on at least one of a time lag, bandwidth, associated with a network between the terminal device (101) and the server (102), and size of the update file (105).

3. The method as claimed in claim 1, wherein providing the plurality of data segments (106) and the instruction (302) using the one or more payment transaction messages (301) comprises: embedding each of the plurality of data segments (106) in the one or more payment transaction messages (301);

sending the one or more payment transaction messages (301) embedded with the plurality of data segments (106) to the terminal device (101);

embedding the instruction (302) in a one of the one or more payment transaction messages (301); and

sending the one of the one or more payment transaction messages (301) to the terminal device (101).

4. The method as claimed in claim 1, wherein providing the plurality of data segments (106) and the instruction (302) to the terminal device (101) comprises:

sending the plurality of data segments (106) to a first data structure (104 A) from the one or more data structures (104);

embedding the instruction (302) in the one or more payment transaction messages (301); and

sending the one or more payment transaction to the terminal device (101).

5. The method as claimed in claim 1, wherein providing the plurality of data segments (106) and the instruction (302) to the terminal device (101) comprises:

sending the plurality of data segments (106) to a first data structure (104 A) from the one or more data structures (104); and

sending the instruction (302) to the terminal device (101) via a second data structure (104B) from the one or more data structures (104).

6. The method as claimed in claim 1, wherein the instruction (302) comprises information for performing at least one of:

reconstructing the update file (105) from the plurality of data segments (106); and updating the software in the terminal device (101).

7. The method as claimed in claim 1, wherein updating the software comprises at least one of upgrading the software, deploying the software and configuring the software in the terminal device

(101) based on the instruction (302).

8. A server (102) for performing remote updation of software in a terminal device (101), the server

(102) comprises:

a processor (102A); and

a memory (102B) communicatively coupled to the processor (102A), wherein the memory (102B) stores the processor instructions, which, on execution, causes the processor (102A) to: obtain a plurality of data segments (106) associated with an update file (105);

provide the plurality of data segments (106) and an instruction (302) to the terminal device (101) using at least one of a one or more payment transaction messages (301) and one or more data structures (104), wherein the terminal device (101) updates the software using the plurality of data segments (106) based on the instruction (302).

9. The server (102) as claimed in claim 8, wherein the processor (102A) is configured to obtain the plurality of data segments (106) comprises one of:

10. The server (102) as claimed in claim 8, wherein the processor (102A) is configured to provide the plurality of data segments (106) and the instruction (302) using the one or more payment transaction messages (301) comprises:

embedding each of the plurality of data segments (106) in the one or more payment transaction message;

11. The server (102) as claimed in claim 8, wherein the processor (102A) is configured to provide the plurality of data segments (106) and the instruction (302) to the terminal device (101) comprises:

sending the one or more payment transaction messages (301) to the terminal device (101).

12. The server (102) as claimed in claim 8, wherein the processor (102A) is configured to providing the plurality of data segments (106) and the instruction (302) to the terminal device (101) comprises:

13. The server (102) as claimed in claim 8, wherein the processor (102A) is configured to provide the instruction (302) comprises information for performing at least one of:

14. A system performing remote updation of software in a terminal device (101), the system comprises:

a server (102) comprising:

a processor (102 A); and

a memory (102B) communicatively coupled to the processor (102A), wherein the memory (102B) stores the processor instructions, which, on execution, causes the processor (102 A) to:

obtain a plurality of data segments (106) associated with an update file (105) from a computing unit (103); and

provide the plurality of data segments (106) and an instruction (302) to the terminal device (101) using at least one of one or more payment transaction messages (301) and one or more data structures (104) associated with the server (102);

the one or more data structures (104) for storing at least one of the plurality of data segments (106) and the instruction (302); and

the terminal device (101) for updating the software using the plurality of data segments (106) based on the instruction (302).