JP2002500392A - Method and apparatus for embedding, extracting and processing data in a file having HTML format - Google Patents

Abstract

(57) SUMMARY A method and apparatus for delivering data in a file having an HTML format is provided. The first process generates the data, encodes it in a known format, such as MIME base 64, and embeds the data in the annotation section of the HTML file. A second process is used to extract data from the HTML file and store the data in a separate data file, which is preferably configured as a browser plug-in application . The third process generates an HTML file that starts an applet that uses this data and includes an applet parameter, which includes the path to a separate data file where the data to be extracted resides. I have.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

TECHNICAL FIELD OF THE INVENTION

The present invention relates to digital data communications, and more particularly to a method and apparatus for confidentially distributing data and programs between network computers in a file having an HTML format in a secure and automatic manner.

[0002]

[Prior art]

In recent years, Internet web search has become ubiquitous, and web browser applications have become a standard feature on desktop computer platforms.

[0003] Most web browsers are based on literature available at http://www.w3.org/TR/REC-html40 (Dave Raggett, "HTML 4.0 Reference Specification," Dec. 1997,
), It is possible to load a file having the well-known HTML format. Most information shared on the Internet is provided via data files having the HTML format.

[0004] Most web browsers also support plug-in applications. Such plug-in applications can include programs written in the Java programming language. For the Netscape 4.0 browser environment (trade name of Netscape Communications, Inc., Mountain View, CA), the plug-in is http://developer.netscape.com/libr
References available at ary / documentation / index.html (“Plug-Ins Documentation,
Nov. 1997). As a result, browsers have become a platform for applications written in the Java programming language that can be executed. Browsers generally have many operating environments. To support, this provides a means by which applications written in one common programming language can be executed and produce the same result for different operating environments.

[0005]

[Problems to be solved by the invention]

The present invention aims to introduce the ability to exchange and process data in new and effective ways with HTML files and ordinary web browsers. An object of the present invention is to efficiently and quickly distribute data and programs between network computers. Another object of the invention is to distribute the data and the means for displaying the data in an integrated manner. It is yet another object of the present invention to uniformly distribute data and the means for displaying the data to various operating environments.

[0006]

[Means for Solving the Problems]

Methods and apparatus are provided that satisfy these and other objectives and that can deliver data in files having an HTML format. The first process generates the data, encodes it in a known format, such as MIME base 64, and embeds the data in the annotation section of the HTML file.
A second process is used to extract data from the HTML file and store the data in a separate data file, which is preferably configured as a browser plug-in application . The third process is an HTM that launches an applet that uses this data
Generate the L file and include an applet parameter that contains the path to a separate data file where the data to be extracted resides.

[0007]

BEST MODE FOR CARRYING OUT THE INVENTION

The details of the invention and the best mode of carrying out the invention will become apparent to those skilled in the art from the following detailed description and accompanying drawings. As shown in FIG. 1, the sending host 2 includes a computer 10-A and a user interface 20-A. The transmitting computer 10-A is a CPU
12-A, an executable RAM 14-A, and a mass storage drive 16-A. The receiving host 4 includes a computer 10-B and a user interface 20-B. The receiving computer 10-B includes a CPU 12-B, an executable RAM 14-B, and a mass storage drive 16-B. Computers 10-A and 10-B function to execute programs loaded into RAMs 14-A and 14-B, as is generally known, and these programs are executed by CUPs 12-A and 12-B. Contains the instruction to be executed. Such programs are available on mass storage drives 16-A and
16-B can be loaded into RAMs 14-A and 14-B. Such programs also generate and manipulate data, store data on mass storage drives 16-A and 16-B, and store data in windows 18 on user interfaces 20-A and 20-B.
-A and 18-B and receive user selections from the user interfaces 20-A and 20-B. Preferably, at least the receiving computer is loaded by a Java enabled browser.

[0008] Although the hosts are shown separately here for simplicity, they operate within the principles of the present invention as a sending host in one transaction and as a receiving host in another transaction. It should be understood that it is possible to

In accordance with the principles of the present invention, the sending host 2 and the receiving host 4 can send and receive files over the network 6, preferably as an attachment to an email message. However, many other means of sharing files are available. Such a data file may include an HTML data file 30 generated in accordance with the principles of the present invention, as described in more detail below. Network 6 can be any public or private data communication network. The receiving host 4 has a Java-based applet and a
Preferably, it is loaded with a browser program that supports a and / or a plug-in written in a native programming language.

Further, according to the principles of the present invention, the receiving host 4 can send and receive files from the server 8. The files on server 8 are preferably accessible on the World Wide Web by ordinary browsers and download tools.

Referring now to the tail flowchart shown in FIG. 2, the first data used to generate and embed data in an HTML data file 30 according to the principles of the present invention.
An example of the process will be described.

The first process is preferably implemented as a program loaded into the executable RAM 14-A on the sending computer 10-A, which program is described below with reference to FIG. Contains instructions that can be executed by CPU 12-A according to the processing steps described. All of the processing steps can be implemented together as a single stand-alone program or module that executes using certain input parameters, or they are readily available commercially available tools and / or specially written tools Or it should be understood that they can be implemented separately using a combination of modules.

As shown, at the start (step S10), the process starts by generating data to be transmitted to the receiving host 4 (step S20). The data to be embedded is described in, for example, an executable file such as a Java applet, an image file such as a GIF file, U.S. patent application Ser. This can be an envelope data file, such as the one described in, or a unique code module. Although shown as a step within the current process, it should be understood that the data can in fact be a previously generated data file or object, in which case this step defines the data to be embedded. It only involves identifying and locating.

Thereafter, if requested by the user, the generated data can be encrypted (step S30). Such encryption can be performed using an encryption technique such as RC4, a registered trademark of RSA Data Security Inc. (Redwood City, CA). In step S40, the data is stored in the MIME base 6
4 format. Whether or not the HTML file has already been generated is determined in step S50. If not, an HTML file is generated (step S60). Preferably, generating the HTML file includes adding instructions in the file to cause the plug-in application to start executing to extract the embedded data.
Hereinafter, such a plug-in application will be further described. This step also includes determining whether the correct version of the plug-in application is locally present in the receiving computer, and if not, an HTML script that downloads the correct version of the plug-in application. Is preferably contained.

[0015] Finally, the encoded data is embedded in the annotation section of the HTML file (step S70). This is done by creating an annotation section and inserting the encoded data into it. This step may also include the generation of a header of the encoded data in the annotation section, the header relating information about the encoded data as well as whether or not the encoded data is encrypted. Information may be included. In addition, the HTM containing the encoded data
Care should be taken to ensure that the overall size of the L-file is within the limits of a typical browser application.

If data to be embedded still remains (determined in S80), for example, if the data to be embedded is a list of separate data objects, the process returns to step S85, where the remaining data is It is determined whether it has already been created. If no, the process returns to step S20; otherwise, step S3
Return to 0 and loop until all data is embedded.

FIG. 3 shows the format of an HTML file generated according to the first process described above. As shown, it includes a script section 50, a plug-in execution section 52, and annotation sections 54-1 through 54-N.

The script section 50, represented as pseudocode, includes HTML instructions that determine whether the correct version of the plug-in application for extracting embedded data is locally present in the receiving computer. Is preferred. If not, the correct plug-in application is downloaded, for example, from the path specified in the script instruction.

The plug-in execution section contains HTML instructions that cause the plug-in application to be executed.

The annotation sections 54-1 through 54-N are separate annotation sections for each data object embedded according to the processing steps outlined above.

Referring now to the flowchart shown in FIG. 4, an example of a second process used to extract data embedded in an HTML file according to the principles of the present invention by the above-described process. Will be described.

The second process is preferably configured as a program loaded into the executable RAM 14-B on the receiving computer 10-B, which program is executed by the CPU 12 according to the processing steps described below. Contains instructions that can be executed by -B. Such a program is preferably configured as a plug-in application to a browser. The plug-in application is executable code such as Java bytecode and / or unique code. When the browser encounters an HTML command requesting its execution,
The plug-in application is loaded into the executable memory of the computer and executed. The browser contains a plug-in directory that the browser searches when the application is requested.

As shown, after the start (step S100), the process starts by reading out the HTML page that started the program and saving it in a file (step S110). Next, the HTML file is read, and the next embedded data in the annotation is extracted (step S120). Thereafter, the embedded data is decoded from the MIME base 64 format (step S130). If the data has been encrypted, it is decrypted and returned to its original state (step S140). Whether the data needs to be decrypted may be determined from the header in the embedded data, or may be indicated by a flag or variable in or outside the HTML file.

Finally, the data is moved to its appropriate directory (step S150), which directory may be predefined and pre-existing, or may be dynamically allocated and created at runtime. Next, it is determined whether or not the end of the HTML file has been reached, for example, whether or not there is no longer any annotation section including the embedded data (step S160). If so, the process ends (step S1
70), otherwise, the processing loops back to step S120, and the above processing is repeatedly performed until the end of the HTML is reached.

An example of a third process used to start an applet that uses data embedded and extracted by the above process will now be described with reference to the flowchart of FIG.

The third process is preferably configured as a program that is loaded into an executable RAM 14-B on the receiving computer 10-B, which program follows the processing steps described below. Java executable by CPU 12-B
a Contains instructions written in the programming language. Such a program is preferably constituted continuously by the above-mentioned program including the second process, and is also a part of the same executable software as the plug-in application including the second process. Is also good.

As shown, after the start (step S200), the process is started by generating an HTML page including an instruction for starting an applet (step S210). The input parameter to the applet is the file path of the embedded data extracted from the HTML file using the second process described above, which file path is communicated by the second process to the third process. Is preferred. Next, the third process is, for example, a browser plug-in application programming interface (API) or Java A
Load the HTML page generated in step S210 by a call to the PI (
A request is made to the browser as in step S220), and the process ends (step S230). Obviously, when the HTML page generated in step S210 is loaded by the browser, the applet is executed.

The executable software, including the applet, may be downloaded simultaneously with the program, including the second and third processes, or it may already be in the mass storage drive 16-B of the receiving computer 10-B. It may be installed and loaded into memory at the start command. Alternatively, the applet may be included in one of the extracted data files included in the HTML file stored in the directory on the receiving computer 10-B during the second process.

FIG. 6 shows the format of an HTML file generated according to the third process described above. As shown, it includes an applet description section 60 and applet parameter sections 62-1 through 62-N. Important within the applet description section 60 are the path xxx.jar to the archive of the Java class and the identifier yyy.class of the applet in the class container.

In operation, referring to FIG. 1 and the above description, when the sending host 2 desires to send data to the receiving host 4, the sending host computer
In the program execution instruction at 10-A, data is encoded according to the first process described above and embedded in the HTML data file 30. Thereafter, the sending host 2 sends an e-mail message to the receiving host 4 together with the HTML data file 30 as an attachment. At the receiving host 4, the e-mail message is received by an e-mail program running on the receiving host computer 10-B, read and a browser is started to view the HTML data file 30 attached to the e-mail. . For a computer running the Windows 95 (a registered trademark of Microsoft Corporation of Redmond, Washington) environment, for example, a double-click on a screen object will automatically launch a browser application with an email attachment according to the HTML file extension. Indicates that. The browser starts a second process under the browser as a plug-in application, executes it on the receiving host computer 10-B, extracts data as described above, and extracts it to the mass storage drive 16-B. Store it in B. afterwards,
A third process is invoked to initiate an applet that uses the data, which may include displaying the data on the user interface 20-B.

Hereinafter, an example of the present invention will be described with reference to FIGS. 7 and 8. In addition to web browsers, email has recently become ubiquitous. However, there remains a well-known problem with e-mail, which includes a lack of homogeneity in the display of information, lack of confidentiality, and inability to confirm receipt. Improvements in email addressing these problems have been especially addressed in the separate patent application US 08 / 845,722 to Venkatraman et al., Filed April 25, 1997, the contents of which are incorporated herein by reference. It is described in.

In the e-mail enhancements described in applicant's separate application, a container file containing one or more component objects or “Vixels”, ie, an envelope data file, is generated. A component object may include data and, for example, one or more defined “user actions” that cause the data to be displayed in a desired manner. The envelope data file is included as an email attachment and sent to the intended recipient, where the contents of the envelope can be selectively displayed and manipulated.

The specification of this separate application also includes generating executable software on the sending computer, for example, for generating the envelope data file, and receiving, for example, displaying the data in a desired manner on the receiving computer. Receiver executable software on a computer is described. The receiver executable software is included in the email attachment sent to the recipient, thereby transferring the ability to display data in a manner specific to the recipient.

With the present invention, the generation executable software that runs on the sending computer, eg, 10-A, includes a first process as described in the present invention. Thus, the generation executable software encodes the envelope data file while generating it, and generates an envelope data file such as an HTML data file 30 such as an HTML data file.
This is embedded in the L data file. Receiver executable software consisting of a number of receiver executables determined by different numbers of image, sound and functional attributes inserted into the environment container is also described, for example, in the present invention. Can be encoded and embedded in an HTML data file by such a first process.

As shown in FIG. 7, an example of an HTML data file generated by the first process described above with the separate specification of the present application is an HTM file.
An L script section 70, a plug-in execution section 80, a first embedded data section 90 and a second embedded data section 92 are included.

The HTML script section 70 is a form specific to the Netscape (registered trademark of Netscape, Inc., Mountain View, Calif.) Browser environment. It is the correct version of the extraction process plugin
Includes a download section 72 downloaded from the Internet site designated by 76. Field 74 identifies the path to the extraction process plug-in. It should be noted that the principles of the present invention are applicable to other browser environments and standards such as Internet Explorer (registered trademark of Microsoft Corporation of Raymond, Wash.), And those skilled in the art will recognize such other alternatives. You will be aware of the changes required to comply with the environment and standards.

The plug-in execution section 80 contains HTML instructions for executing a plug-in application as identified in field 82. It is particularly important that the path of the plug-in application shown in field 82 is the same as that shown in field 74. HT by browser
At this point in processing the ML file, the correct version of the plug-in application must be at the location shown in field 82.

[0038] The first embedded data section 90 includes a header 94 and a footer 96 that act as delimiters and identifiers for the encoded data. In this example,
The first embedded data section 90 contains the envelope data file described in the applicant's other specification.

The second embedded data section 92 includes a header 98 and a footer 100 that act as data delimiters and identifiers encoded within this section 92. In this example, the second embedded data section 92 contains data relating to "Vixel" described in the applicant's other specification.

FIG. 8 shows an HT ML file that starts an applet according to the illustrated example of the present invention.

As mentioned above, in this example of the present invention that operates in connection with the e-mail enhancements described in applicant's other patent specification, the first process is the applicant's other application. Execute as part of the generated executable software as described herein. For example, the second and third processes executing on the receiving computer 10-B may include envelope container data and executable software that uniquely display the data in accordance with the principles set forth in the applicant's separate application. Provides a means to manage the transfer of data. The applet described in the specification of the present invention corresponds to the executable software on the receiving side described in the separate application specification, and the applet may be a different type of software contained in the envelope data. Instructions for providing different image, sound and functional attributes depending on the object may be included.

Thus, the HTML file shown in FIG. 8 generated by the third process described in the present invention includes an applet description section 64 and applet parameter sections 66-1... 66-N. . Important within the applet description section 64 are the path to the Java executable software archive, EnvelopeApplet.jar, and the identifier of the applet in the executable software container, EnvelopeApplet.class. Applet parameters section 66-1
... More important within 66-N is the path to the envelope data file included in the "envelopeName" parameter.

While the invention has been described above with reference to preferred embodiments thereof, those skilled in the art will recognize that various substitutions and modifications may be made for the given examples. Would. For example, while the first, second, and third processes have been described above as being performed by instructions executing on a processor, using various combinations of hardware and software components,
It will be clear that these processes can be performed.

Therefore, such substitutions and modifications can be made within the technical scope of the present invention as defined in the appended claims.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration according to the principle of the present invention.

FIG. 2 is a flowchart illustrating a process for generating encoded data according to the principles of the present invention and embedding it in an HTML file.

FIG. 3 is a schematic diagram showing the format of an HTML file containing embedded data, such as that generated by the process shown in FIG.

FIG. 4 is a flowchart illustrating a process for extracting embedded data from an HTML file, such as that generated by the process illustrated in FIG. 2, in accordance with the principles of the present invention.

5 is a flowchart illustrating a process for initiating an applet that uses embedded data, such as that extracted in the process illustrated in FIG. 4, in accordance with the principles of the present invention.

FIG. 6 is a schematic diagram illustrating the format of an HTML file that includes instructions to start an applet, such as that generated by the process illustrated in FIG.

FIG. 7 is a schematic diagram showing a specific example of the format of an HTML data file generated according to the present invention.

FIG. 8 is a schematic diagram illustrating a specific example of the format of an HTML file that includes instructions to start an applet generated in accordance with the present invention.

──────────────────────────────────────────────────続 き Continued on the front page (51) Int.Cl. ⁷ Identification symbol FI Theme coat ゛ (Reference) G06F 17/21 570 G06F 9/06 650D (81) Designated country EP (AT, BE, CH, CY, DE, DK, ES, FI, FR, GB, GR, IE, IT, LU, MC, NL, PT, SE), OA (BF, BJ, CF, CG, CI, CM, GA, GN, GW, ML, MR, NE, SN, TD, TG), AP (GH, GM, KE, LS, MW, SD, SZ, UG, ZW), EA (AM, AZ, BY, KG, KZ, MD, RU, TJ) , TM), AL, AM, AT, AU, AZ, BA, BB, BG, BR, BY, CA, CH, CN, CU, CZ, DE, DK, EE, ES FI, GB, GD, GE, GH, GM, HR, HU, ID, IL, IN, IS, JP, KE, KG, KP, KR, KZ, LC, LK, LR, LS, LT, LU, LV , MD, MG, MK, MN, MW, MX, NO, NZ, PL, PT, RO, RU, SD, SE, SG, SI, SK, SL, TJ, TM, TR, TT, UA, UG, UZ, VN, YU, ZW (72) Inventor Namja, Sekaran, Chambertin Drive 5824 San Jose, California 95118 San Jose, CA 5824 F-term (reference) 5B009 SA14 5B076 AB17 BB06 EA04 FA01 5B082 GA16 HA05

Claims (20)

[Claims] Processing the data on a sending host, embedding the data in an annotation section of an HTML file, sending the HTML file to the receiving host, and storing the embedded data in the HTML file. A method of distributing data between a sending host and a receiving host, comprising extracting from a comment section and processing a local copy of the extracted data on the receiving host. 2. The method of claim 1, further comprising: starting an applet on the receiving host that uses a portion of the extracted data. 3. The step of processing the local copy comprises: placing the extracted data in a file path on the receiving host; and starting the applet; 3. The method of claim 2, wherein parameters including the file path are sent to the applet. 4. The step of starting the applet includes: generating a second HTML file according to an instruction to start the applet; inserting the parameters into the second HTML file; and loading the HTML file 4. The method of claim 3, including calling an application to perform. 5. The method of claim 1, wherein processing the data includes encrypting the data when requested by a user and encoding the data in a predetermined format. 6. The step of processing the local copy of the extracted data comprises: decoding the data according to the predetermined format; and if the decrypted data is encrypted, The method of claim 5, including the step of decrypting the data. 7. The method of claim 1, further comprising: determining whether a process performing the extracting step is present on the receiving host; if the process is not present on the receiving host, the process is executed from an external source. The method of claim 1 including downloading. 8. The method of claim 2, wherein said applet is contained within some other portion of said extracted data. 9. An HTML file generated by the method of claim 1. 10. An apparatus for distributing data between a sending host and a receiving host, comprising: means for processing data on the sending host; means for embedding the data in an annotation section of an HTML file; Means for transmitting the HTML file to the receiving host; means for extracting the embedded data from the annotation section of the HTML file; and a local copy of the extracted data on the receiving host. An apparatus for distributing data between a sending host and a receiving host, comprising: means for processing. 11. The apparatus of claim 10, further comprising: means for initiating an applet on the receiving host that uses a portion of the extracted data. 12. The local copy processing means includes means for placing the extracted data in a file path on the receiving host, and wherein the means for starting the applet includes the local copy function. 12. The apparatus of claim 11, further comprising means for sending a parameter including the file path of the file to the applet. 13. The means for starting the applet, means for generating a second HTML file according to an instruction for starting the applet, means for inserting the parameter into the second HTML file, 13. The apparatus of claim 12, further comprising means for invoking an application for loading an HTML file. 14. The means for processing the data comprises: means for encrypting the data when requested by a user; and means for encoding the data in a predetermined format. An apparatus according to claim 10. 15. The means for processing the local copy of the extracted data, the means for decrypting the data according to the predetermined format, and wherein the decrypted data is encrypted. 15. The apparatus according to claim 14, further comprising means for decrypting said data. 16. A means for determining whether a process performing the extracting step is present on the receiving host, and, if the process is not present on the receiving host, retrieving the process from an external source. The apparatus of claim 10, further comprising means for downloading. 17. The apparatus of claim 11, wherein the applet is included in some other portion of the extracted data. 18. A method for distributing data between a sending host and a receiving host, comprising: receiving an HTML file sent by the sending host at the receiving host; and embedding from an annotation section of the HTML file. Extracting the extracted data and processing a local copy of the extracted data on the receiving host. 19. The method of claim 18, further comprising: starting an applet on the receiving host that uses a portion of the extracted data. 20. determining whether a process performing the extracting step exists on the receiving host; and, if the process does not exist on the receiving host, calling the process from an external source. 19. The method according to claim 18, comprising downloading.