RPX Exhibit 1004
`RPX v. AIT
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 1 of 22
`
`US 6,249,291 B1
`
`n:
`
`2E-EuYma<82>
`
`o:
`
`
`
`NSwwmqofim$32
`
`mi@fiaonxmx
`l.IIlI|II
`
`H2&3
`
`CHO:
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 2 of 22
`
`US 6,249,291 B1
`
`0
`
`SNcan
`
`
`
`mmmafimfl:o:r..._:nE<am§m..s§ou.%.@n,¢_.£.%m
`
`
`
`
`
`\\newmom
`
`
`
`EmEoD.S>.am¥62:wZEmuomuou
`
`
`
`
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`22__...l03._lCBhS
`
`US 6,249,291 B1
`
`co:8__&<W_
`
`Lwbhum“atom#5929
`
`
`
`
`
`m,.._.w&
`
`Nam
`
`<mesma
`
`E25
`
`Em:U
`
`

`
`US. Patent
`
`Jun. 19, 2001
`
`22__...l04._lBBhuS
`
`US 5,249,291 B1
`
`£u_...mn._
`
`«$5.
`
`mommxumn:
`
`HD_
`
`mmmusmfl
`
`mEo£m>._..
`
`M.mm.aa._%_m_.._
`
`\
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 5 of 22
`
`US 6,249,291 B1
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 6 of 22
`
`US 6,249,291 B1
`
`application
`identified by
`request exists?
`
`t.
`1.
`t
`crea e app 1Ca ion
`
`forward request to
`application
`
`receive response
`from application
`
`return response
`to client
`
`Figure 5A
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 7 of 22
`
`US 6,249,291 B1
`
`receive request
`
`verify request
`
`526
`
`valid request?
`
`generate errer
`
`create transaction
`
`Figure 5B
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 8 of 22
`
`US 6,249,291 B1
`
`identify page to
`handle request
`
`create request object
`and page object
`
`send message
`to page
`
`page responds
`to message
`
`action needed?
`
`Yes
`
`invoke action
`
`create response page
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 9 of 22
`
`US 6,249,291 B1
`
`create root object
`for object graph
`
`send
`
`"prepareRespc-nse"
`message to page
`object
`
`send
`
`"generateDescription"
`message to page object
`
`return response
`to server
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 10 of 22
`
`US 6,249,291 B1
`
`invalid
`session ID?
`
`encrypt request
`information
`
`check portion of
`encrypted string with
`digital signature
`
`

`
`US. Patent
`
`Jun. 19, 2001
`
`22f0.I_1teBhuS
`
`US 5,249,291 B1
`
`
`
`uaa_.€_aEmama_E_.=...1_m_.no_n_.._._wmu.:em£££_:>__E:cm_:.3.
`
`ask:_mfiwuuaflwx:5:-
`3325:
`
`:c:m_ucmm<
`
`
`
`w_um_...o1Ewuumflwxcafiucozuu..._:om>...m2“2m0.._
`
`
`
`
`
`
`
`
`
`:3...ac.mu...o_nEu»u.....~3.xm,_.>.emZ"wm>D4LEm"EMO.._
`
`
`
`
`
`
`
`n.=&.:v
`
`
`
`.._£mE..um_z<2ofimzu
`
`
`
`
`
`~.mm»o._.__,...m__um2¢.z3.52»252...:
`
`
`
`
`
`,:2m:m,um:._¢>L.:2m=._W_u.n.__.;.—..._.Ez_u
`
`as853
`
`
`
`.flU4.._.nZ..__.v
`
`nufimz?
`
`2.2.5:?
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`22f021._lEBhS
`
`US 6,249,291 B1
`
`momuswwm
`
`

`
`US. Patent
`
`Jun. 19, 2001
`
`22f031._lEBhuS
`
`US 5,249,291 B1
`
`m:o:m_uomm.<
`
`
`
`...::a:an_EoUmm_€_mEmHLS_mDH
`
`
`
`_...f:mcomEoU:mn_:w_mU_1_<U
`
`Ummzsmfl
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 14 of 22
`
`US 6,249,291 B1
`
`702
`
`

`
`US. Patent
`
`Jun. 19, 2001
`
`Sheet 15 of 22
`
`US 6,249,291 B1
`
`.“§x.H.”.“.”.H.”.”."-”-“.“.~.“._.”~.u~
`
`§
`5
`
`742
`
`E
`g
`
`WEBPEOPLE
`
`744
`
`746
`
`Repefifion
`Controller
`
`Figure 7B
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 16 of 22
`
`US 6,249,291 B1
`
`702
`
`WEBPEOPLE
`
`Repetition
`Controller
`
`Figure 7C
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 17 of 22
`
`US 6,249,291 B1
`
`send "create" message to
`document's root object
`
`identify children
`of root object
`
`send "create" message
`to children
`
`children have
`
`children?
`
`

`
`US. Patent
`
`Jun. 19, 2001
`
`Sheet 18 of 22
`
`US 6,249,291 B1
`
`Web Object
`Server
`
`Application
`
`918
`
`j
`
`924
`
`Page
`
`920
`
`L
`
`926
`
`-.-<.......y-.u¢A----E
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 19 of 22
`
`US 6,249,291 B1
`
`Response
`Page
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`Sheet 20 of 22
`
`US 6,249,291 B1
`
`11
`
`-:
`
`G)
`5-4
`53
`.9.“
`LL:
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`22f012tCB.........S
`
`US 6,249,291 B1
`
`
`
`SmzommZOE.¢U¢>
`
`
`
`E__EmzmwmomUEMZ
`
`_uw>o.aE<
`
`9&2E-main:_:o_.8m>
`
`TI
`
`mmna
`
`
`
`emmadmmZOE.<U€>
`
`
`
`£:Em£n_mmo_.umchmz
`
`
`
`$2:”E=5.&<
`
`mmaflE-mimmh”:o:mum>
`
`ll
`
`45;
`
`<22&5
`
`vmwnfi...«D
`
`/Pammunm
`
`mmcommmm
`
`8:
`
`32
`
`mwmnfimfl
`
`/sufiz
`
`fiuzmmm
`
`No.2.
`
`

`
`U.S. Patent
`
`Jun. 19, 2001
`
`22teehS
`
`22on
`
`US 6,249,291 B1
`
`
`
`emmaommZOE..<U<>
`
`
`
`mm\mQ~-mo\mm>aou§>
`
`
`
`Eflnmammmom“@982
`
`”B>o:E<
`
`
`
`Hmmaommzo:_<u<>
`
`fiwamEmma..
`
`
`
`minim-mos“:aou§>
`
`fi.._._>oEm¢.
`
`msm
`
`/Q
`.En._m.fl
`ooafi
`
`mmfiommmm
`
`wofifi
`
`/«E8:
`
`oofifi
`
`woflfi
`
`umwnwwm
`
`mmanflmfl
`
`-
`
`amsmflvummfifimfl
`
`

`
`US 6,249,291 B1
`
`1
`METHOD AND APPARATUS FOR
`IVIANAGING INTERNET TRANSACTIONS
`
`BACKGROUND OF THE lNVEN'l'I()N
`
`1. Field of the Invention
`
`This invention relates to the development and manage-
`ment of transactions on the Internet.
`
`2. Background
`The Internet
`is a worldwide matrix of interconnected
`computers. An Internet client accesses a computer on the
`network via an Internet provider. An Internet provider is an
`organization that provides a client (e.g., an individual or
`other organization) with access to the Internet (via analog
`telephone line or Integrated Services Digital Network line,
`for example). A client can, for exarnple, download a file
`from or send an electronic mail message to another
`computerfclient using the Internet.
`To retrieve a file on the Internet, a client must search for
`the file, make a connection to the computer on which the file
`is stored, and download the file. Each of these steps may
`involve a separate application and access to multiple, dis-
`similar computer systems. The World Wide Web (WWW)
`was developed to provide a simpler, more uniform means. for
`accessing information on the Internet.
`The components of the WWW include browser software,
`network links, and servers. The browser software, or
`browser, is a graphical interface (i.e., front—end) that sim-
`plifies access to the Internet. A browser allows a client to
`communicate a request without having to learn a compli-
`cated command syntax. A browser typically provides a
`graphical user interface (GUI) for displaying infonnation
`and receiving input. Examples of browsers currently avail-
`able include Mosaic, Netscape, and Cello.
`Information servers maintain the information on the '
`WW and are capable of processing a client
`request.
`Hypertext Transport Protocol (I-ITTP) is the standard pro-
`tocol for communication with an information server on the
`WWW. H‘I’I't’ has communication methods that allow cli-
`ents to request data from a server and send information to the
`S-EI'\«"El'.
`
`To submit a request, the client contacts the HTTI’ server
`and transmits the request to the l-I"l"l'l’ server. The request
`contains the communication method requested (e.g., GET an
`object from the server or POST data to an object on the
`server). The HTTP server responds to the client by sending
`a status of the request and the requested information. The
`connection is then terminated between the client and the
`
`I-ITTP server. A connection between a client and an H'l'l'l’ _
`server therefore has four stages: 1) initiation, 2) request
`transmittal, 3) response transmittal, and 4) termination. A
`connection can only process a single transaction or interac-
`tion bctween the client and the H'l'l’l’ server.
`
`_
`
`The HTTP server does not retain any infomiation about
`the request after the connection has been terminated. IITTP
`is, therefore, a stateless protocol. That is, a client can make
`several requests of an H'l'|'l’ server. but each individual
`request is treated independent of any other request. The
`server has no recollection of any previous request.
`An addressing scheme is employed to identify Internet
`resources (e. g., II'I'l'I-’ server, ille or program). This address-
`ing scheme is called Uniform Resource Locator (U RI..}. A
`URI. contains the protocol to use when accessing the server
`(e.g.. I-ITTP), the Internet domain name of the site on which
`the server is running, the port number of the server, and the
`location of the resource in the lile structure of the server.
`
`2
`The WWW uses a concept known as hypertext. Hypertext
`provides the ability to create links within a document to
`move directly to other information. To activate the link, it is
`only necessary to click on the hypertext link (e.g., a word or
`phrase). The hypertext link can be to information stored on
`a different site than the one that supplied the current infor-
`mation. A URL is associated with the link to identify the
`location of the additional
`information. When the link is
`activated, the client ’s browser uses the link to access the data
`at the site specified in the URI...
`If the client request is for a file. the HTTP server locates
`the file and sends it to the client. An I-ITTI’ server also has
`the ability to delegate work to gateway programs. The
`Common Gateway Interfaoe (CGI) specification defines the
`mechanisms by which HTTP servers communicate with
`gateway programs. A gateway program is referenced using
`a URL. The H‘I'l‘P server activates the program specified in
`the URL and uses CGI mechanisms to pass program data
`sent by the client to the gateway program. Data is passed
`from the server to the gateway program via command-line
`arguments, standard input, or environment variables. The
`gateway program processes the data and returns its response
`to the server using CGI (via standard input, for example).
`The server forwards the data to the client using lhe HTTP.
`A browser displays information to a clientfuser as pages
`or documents. A language is used to define the format for a
`page to be displayed in the WVVW. The language is called
`Hypertext Markup Language (HTML). A WWW page is
`transmitted to a client as an HTML document. The browser
`executing at the client parses the document and produces a
`displays a page based on the information in the HTML
`document.
`
`is comprised of
`language that
`HTML is a structural
`HTMI- elements that are nested within each other. An
`HTML document as a text iile in which certain strings of
`characters, called tags, mark regions of the document and
`assign special meaning to them. These regions are called
`I-l'l‘Ml.. elements. Each element has a name, or tag. An
`element can have attributes that specify properties of the
`element. Blocks or components include unordered list, text
`boxes, check boxes, radio buttons, for example. Each block
`has properties such as name, type, and value. The following
`provides an example ofthe structure of an HTML document:
`<l‘lTMI.>
`-cllli./\.I)>
`
`. element(s) valid in the document head
`.
`.
`«all IE/\D>
`-cBOI)Y>
`.
`.
`. element(s) valid in the document body
`<,-’l3()DY>
`4r'l'lTML>
`L-Zach IITML element is delimited by the pair of characters
`"<" and “>". The name of the HTML element is contained
`within the delimiting characters. The combination of the
`name and delimiting characters is referred to as a tag. Each
`element is identified by its tag. In most cases, each element
`has a start and ending tag. The ending tag is identified by the
`inclusion of an another character. "I" that follows the first
`delimiting character ("<").
`HTML is a hierarchical language. With the exception of
`the IITML element, all other elements are contained within
`another element. The HTM l. element encompasses the
`entire document. It identifies the enclosed text as an HTMI.
`document. The HEAD element
`is contained within the
`IITML element and includes information about the IITML
`document. The BODY element
`is contained within the
`
`

`
`US 6,249,291 B1
`
`3
`I-ITML. The BODY element contains all of the text and other
`information to be displayed. Other elements are described
`by any HTML reference manual.
`Web-based access has been used for simple information
`publishing that consisted of static data and no logic. For
`example, a client request might request another page. The
`HTTP server fetches a pre-defined Web page using the URL
`contained in the request. The Web page is returned to the
`client. Web-based access has progressed to dynamic infor-
`mation publishing that allows some simple queries and some
`limited logic to access a database and display database
`information. Web applications have been used in commerce
`to order articles of manufacture via the Web (e .g., a personal
`stereo cassette deck). Commerce applications provide some
`limited logic and allow a Web page to change based on the
`client input.
`Web-based applications are developed independent of
`other Web-based applications. That is, constructs used to
`implement one Web—based application remain local to the
`application. ‘They are not shared.
`Currently, a common gateway interface program is writ-
`ten to process a single transaction. Minimal state informa-
`tion is retained within the HTML document.
`it would be
`beneficial to use objeet—oriented H’l'MI_ elements to manage
`a series of Internet transactions and to maintain state infor— _
`mation across Internet transactions. It would be beneficial to
`be able to generate HTML documents dynamically using
`information from a previous transaction, corporate data, and
`data retained in HTML element objects. It would be ben-
`eficial to be able to share application development across
`applications.
`SUMMARY OF 'l'I-IE INVE.N'l'lON
`
`_
`
`The object-oriented approach used by the present inven-
`tion provides the ability to develop and manage Internet
`transactions. An HTML document can be generated dynami-
`cally. Some or all of a form can be generated based on input
`received in a receive form, generated at runtime, or retrieved
`from an external data source (e.g., database or electronic
`mail system). When the HTML document is rendered, the
`information contained in IITML template{s), declaration
`lile(s), and object(s) are used to generate standard IITML.
`Information regarding a client request is maintained by
`the application that processes the client request. The infor-
`mation is maintained in a state. or context. Different levels
`ofstate information are maintained by the present invention.
`The state level defines the duration and scope of the state
`information. Storage policies define the method of storage
`used for state information. By maintaining a context having
`levels, it is possible to form a virtual session with each user _
`accessing an application such that an application can serve
`any request in any order.
`Using the present invention, a user can connect to a local
`Internet provider and use the Web to connect to a home page.
`Once the connection is established, the present invention is _
`used with an application on the server side of the connection
`to dynamically generate Web pages. The Web pages contain
`application information and provide the ability for the user
`to specify input. A browser executing on the user’s work-
`station receives a Web page from the Internet and sends a
`response containing user input via the Internet. The present
`invention can be used to generate Web pages in response to
`the user input. Thus, a user can access an application located
`anywhere relative to the application server by using any
`local workstation hardware and software platform.
`When a client request is received by the application, the
`application manages the update and retrieval of data from
`
`4
`the form
`the context, processes the received form (i.e.,
`received from the client that includes the client request), and
`processes any return form (i.e., a form sent to the client in
`response to the client request).
`All or some portion of the Web page is dynamically
`generated. Classes of object are associated with elements
`that defined a Web page (e.g., HTML elements). By objec-
`titying Web pages it is possible to gain the advantages of
`object-oriented programming with Web pages. These advan-
`tages include rapid application development through object
`reuse, transparent distribution, simplified maintenance, and
`scalability. These advantages can be achieved using the
`common interface provided by Web browsers.
`Object instances associated with definitional elements are
`instantiated during execution to manage their respective
`portions of the Web page. Control objects are associated
`with definitional elements to facilitate the How of informa-
`tion to and from external data sources.
`
`Definitional elements can be grouped together. A group
`object class provides the ability to access these definitional
`elements as a group. A special type of control referred to as
`a repetition control allows a group to be activated multiple
`times. Each activation of a group of definitional elements
`generates one occurrence of a repeating portion of the Web
`page.
`Self-contained modules, or components, can be accessed
`to provide additional definition for the Web page. A control
`object is associated with one of these modules to manage its
`integration into the rest of the Web page definition. The
`self-contained modules can be shared by one or more Web
`pages in a single application andfor across multiple appli-
`cations executing on application server 316 (or any other
`server).
`A page definition has some combination of the following
`associated resources: template(s], association(s), and custom
`logic. A template contains an initial definition for some or all
`of the page. At runtimc, some or all of the initial definition
`can be dynamically altered. Associations provide declaration
`and binding information.
`(Tustom logic provides custom
`functionality.
`A reusable or sharable construct of the present invention
`is referred to as a component. Aeomponenl can represent an
`entire page or some portion ofa page. Acomponent has none
`or more rcsou rccs. A resource can be,
`for example,
`a
`template, association, or custom logic. A component owns
`its associated resources.
`
`One or more components can be combined to define a
`page. A component can be defined using different defini-
`tional constructs {e.g., H'l‘MI., VRML, PDF, etc.). By com-
`bining these components as a single Web page, a document
`can be derived from multiple definitional constructs.
`A control class provides object cover for components. An
`abstract class provides the ability to: associate a Web object
`(e.g., an HTML element object) with a corporate object,
`generate static elements, and modify an object tree. Sub-
`classes of the control class inherit behavior from the abstract
`class. Instances of these subclasses provide push and pull
`mode associative behavior.
`In push mode, data retrieved
`from an external data source (or another source) is used to
`dynamically generate a Web page.
`In pull mode, data
`contained in the Web page can be stored into the context or
`corporate object.
`A control object can have subcontrols that are themselves
`control objects. Subcontrols can be pre-defined or generated
`at runtime. The associative behavior of a subcontrol
`is
`attributed to the parent control object. A control object
`
`

`
`US 6,249,291 B1
`
`5
`activates a subcontrol's push and pull modes by forwarding
`the activation message that it received.
`Event objects are used to handle a client request. These
`event objects contain request infonnation and behavior to
`verify and process an client request. Custom logic can be
`invoked during event handling. The application manages the
`process and event objects.
`
`BRIEF D]:lS(.‘RlI’I'lON OF TIIIE. DRAWINGS
`
`6
`118 may contain, for example, 32 address lines for address-
`ing video memory 114 or main memory 115. The system bus
`118 also includes, for example, a 32-bit D/(FA bus for
`transferring DATA between and among the components,
`such as CPU 113, main memory 115, video memory 114 and
`mass storage 112. Alternatively. multiplex D(\TA.r’address
`lines may be used instead of separate DATA and address
`lines.
`
`In the preferred embodiment of this invention, the CPU
`113 is a 32-bit microprocessor manufactured by Motorola,
`such as the (JSUXU processor or a microprocessor manufac-
`tured by Intel, such as the 80x86, or Pentium processor.
`However, any other suitable microprocessor or microcom-
`puter may be utilized. Main memory 115 is comprised of
`dynamic random access memory (DRAM). Video memory
`114 is a dual-ported video random access memory. One port
`of the video memory 114 is coupled to video amplifier 1.16.
`The video amplifier 116 is used to drive the cathode ray tube
`(CRT) raster monitor 11?. Video amplifier 116 is well known
`in the art and may be implemented by any suitable means.
`This circuitry converts pixel DATA stored in video memory
`114 to a raster signal suitable for use by monitor 117.
`Monitor 117 is a type of monitor suitable for displaying
`graphic images.
`The computer system described above is for purposes of
`example only. The present invention may be implemented in
`any type of computer system or programming or processing
`environment. When a general purpose computer system
`such as the one described executes the processes and process
`flows described herein, it
`is a means for developing and
`managing Internet transactions.
`The present invention provides the ability to access an
`application using any interface. For example, a client can
`access the same application via the Internet using a system
`running Windows, MACIOS, Sun.OS. NextStep, etc. Refer-
`ring to FIG. 2, client 202 is resident on a corporate network
`200. Corporate network 200 is a local area network com-
`prised of personal computers such as client 202,
`for
`example. Client 202 executes a browser such as Netscape or
`Mosaic to interface with World Wide Web (WWW) 204. The
`browser executing on client 202 displays HTML documents
`transmitted to client 202 via WWW 204. When the client
`browser submits a request typically an HTML page,
`it is
`transmitted via “WVW 204 to HTTP server 206. An attribute
`of the submitted form is a Universal Resource Iocator
`(URL). The URI.. specifies procedures to be executed andior
`data input by the user.
`H’l'I'P server 206 can service the client request by, for
`example, retrieving a return form or file (specified by a URL
`contained in the I-ITML document) and transmitting it
`to
`client 202 via W 204. Further, HTTP server 206 can
`initiate a program identified in the URI.. In the preferred
`embodiment, the URL specifics CGIMesscngcr 210 to ser-
`__ vice the client request. CGlMessengcr 210 uses the Com-
`mon Gateway Interface (CGI) protocol,
`for example.
`CGIMessenger 210 can execute on the I-ITTP server 206 or
`another server connected to l-I’l’l'l’ server 206, for example.
`The following provides an example of a URL:
`
`illustrates
`
`1 provides an example of a general purpose com-
`FIG.
`puter to be used with the present invention.
`FIG. 2 provides a block-level diagram that
`components of the present invention.
`FIG. 3A provides a block-level diagram for accession a
`corporate application on the World Wide Web (WWW)
`using the present invention.
`FIG. 3B provides an example of Web pages generated by
`an Automobile Shopper’:-5 application accessed via the
`WWW using the present invention.
`FIG. 4 provides a diagram of the object tree.
`FIGS. 5A—5E provides an example of a process How for
`handling a client request.
`FIG. 6A provides an example of resources associated with ;_
`a control.
`
`FIGS. 6B—6C provide a block-level diagram associated
`with component processing.
`FIG. 7A provides the object tree that is generated when
`the I-ITMI. in Table Four is parsed.
`FIG. 7B provides an example of the object tree of FIG. ‘TA
`and an associaterl repetition controller and repetition tem-
`plate.
`FIG. 7C‘ provides an example of the object tree of FIG. 7B _
`that has been modified using a repetition controller anti
`template.
`FIG. 8 illustrates a rendering process How.
`FIGS. 9A—9B illustrate event handling object diagrams.
`FIG. [0 illustrates context objects.
`FIGS. ll/\—llB illustrate the push and pull modes of the
`present invention.
`I)E'l'AII..ED DESCRIPTION OF TI-IE
`INVENTION
`
`_
`
`A method and apparatus for developing and managing
`Internet
`transactions is described.
`In the following
`description, numerous specific details are set forth in order
`to provide a more thorough description of the present
`invention. It will be apparent, however, to one skilled in the
`art. that the present invention may be practiced without these
`specific details. In other instances, well-known features have
`not been described in detail so as not
`to obscure the
`invention.
`
`The present invention can be implemented on a general
`purpose computer such as illustrated in FIG. 1. A keyboard
`110 and mouse 111 are coupled to a bi-directional system
`bus 118. The keyboard and mouse are for introducing user
`input to the computer system and communicating that user
`input
`to CPU 113. The computer system of FIG. 1 also
`includes a video memory 114, main memory 115 and mass
`storage 112, all coupled to bidirectional system bus I18
`along with keyboard 110, mouse [11 and CPU 113. The
`mass storage 112 may include both fixed and removable
`media, such as magnetic. optical or magnetic optical storage
`systems or any other available mass storage technology. Bus
`
`http:.’.i\.v\tv\v,next.con1.n'cgi_bit't.I’cgE:r1essengeri'app_nante.-'tev_fortnf
`sertd_fo rm
`
`The above example is for illustration only. Any URL
`format can be used with the present invention. The URI- in
`the above example has multiple parts. The first part, “httpr”
`spccilies the protocol to be used. Other examples ofprotocol
`include "ftp:”, "gopher: ” and “wais”. The next part specifies
`
`

`
`US 6,249,291 B1
`
`7
`In this case, the
`the Internet domain name of the server.
`Internet domain name of the HT11’ server is “www.next-
`.corn". The next part, “fcgi bintcgi messenger" specifies
`the path and lilename of the desired resource. The resource
`can be a file, form, or program, for example. In this case, the
`resource is a common gateway interface program that is
`used to route requests to applications. The application that
`processes the client request is specilied in the URL with the
`"app name” specification. The names ofthe receiving form
`(c.g., the form containing the client request) and the sending
`form (e.g., a reply to the client request) can be included in
`the URL.
`
`_
`
`Aclient request can result in the invocation of application
`214 in the server domain 208, for example. The client
`request is received by the HTTI’ server 206. HTTP server
`206 initiates CGIMessenger 210. To service the client
`request, CGIMesseriger 210 communicates with HTTP
`server 206 to obtain information regarding the client request.
`For example. CG|Messenger 210 obtains any information
`that accompanied the user request such as form andlor
`application names andior user input. The form names can
`include the name of the form that was submitted to initiate
`the client request as well as a return form.
`The application name identifies the application that ser-
`vices the client
`request.
`If an application is specified,
`C‘GIMcssengcr 210 transmits the client request and corre-
`sponding information transmitted from HTTP Server 206 to
`application 214. Application 214 can execute on the san1e or
`different server as CGIMessenger 210 andior I-i'I'l'I’ Server
`206, for example. Application 214 executes an interaction
`flow to satisfy the user request. Application 214 can access
`an external data source such as database 224. Database 224
`can be resident on the same server as application 214.
`Alternatively, database 224 can be resident on a mparate
`server {e.g., a separate database server).
`The present
`invention can service multiple levels of
`interaction with the client browser. A simple hypertext
`request (c.g., a request [or another form specified in the
`request) is serviced by I-l’t'l‘P Server 206 by returning the
`specified form. A simple hypertext
`request can be,
`for
`example, a request for a static I-ITMI.. page (e.g., a page that
`contains static information that is defined prior to execution)
`that does not have any associated logic.
`The present invention provides the ability to satisfy more
`sophisticated requests. For example, the present invention
`can be used to access a Web page (e.g., an lITMI.Web page)
`that
`is dynamically generated using complex queries (or
`other data retrieval mechanisms)
`to retrieve data and
`dynamically generate an HTML page using complex logic.
`For more sophisticated requests, the present invention can .
`execute logic such as CGIMcss-cnger 210 and application
`214, for example, to process a client request. The apptication
`preferably includes an object class hierarchy that can be
`implemented in any object-oriented language such as objec-
`tive C, SmallTalk or JAVA. Objects (c.g., Web page defini-
`tional objects and control objects) dynamically generate a
`Web page and manage client interaction via the Internet and
`WW.
`Internal Application
`A powerful
`feature of the WWW is its accessibility
`virtually anywhere in the world using virtually any
`hardwarefsoftware platform. Using the present invention,
`this feature ofthe WWW can be used to allow an application
`such as a corporate (or local) application to be accessed
`using any workstation that provides access to the Web
`regardless of its location. The present invention can be used
`to allow an internal, corporate application to be accessed any
`
`_
`
`8
`place in the world via any hardwarefsoftwarc platform that
`is capable of accessing the Internet.
`The present
`invention provides tools to implement an
`application that can be accessed via the WWW. Further, the
`present invention provides tools to manage the interaction
`between a WWW client and the internal application. FIG.
`3A provides a block overview of an internal application that
`is accessed via the Internet.
`Clients 302, 304, 306, and 308 access WWW 310 using
`any WWW-capable workstation. For example, client 302
`can be an Intel-based workstation running Windows and a
`browser such as NetScape Navigator. Client 304 can be a
`68K workstation running MacOS and Mosaic WWW
`browser. Client306 can be an RISC machine running UNIX
`and a proprietary browser. Client 308 is an Intel-based
`workstation running DOS and the DosLynx browser.
`Requests submitted by clients 302, 304, 306, and 308 to
`IITTP server 314 are transmitted to HTTP server 314 via
`WWW 310. HTTP server 314 runs in the corporate network
`312. A client request is forwarded to application server 316
`via IITTP server 314. Application server 316 runs one or
`more internal applications.
`The present
`invention accommodates the needs of an
`internal application. For example, using the present inven-
`tion art
`internal application can provide a dynamic user
`interface that can respond to user input. Further, an internal
`application is able to access an external data source to store
`the application’s data. State information can be retained to
`allow the internal application to allow the application to
`maintain open sessions with multiple users capable of pro-
`cessing multiple transactions in any order.
`Development of an internal application can be eflicient
`and flexible. An internal application can be written using
`complex logic and complex queries. Developers have the
`ability to incorporate pre-existing modules into the internal
`application. Modules are self-contained to facilitate module
`maintenance and interaction.
`
`An internal application running on application server 316
`has the ability to respond to the client request using the
`capabilities of the present invention. The Web page defini-
`tion returned to a client can be generated from a pre-defined
`template or templates. Alternatively, all or some portion of
`the definition can he dynamically generated by the applica-
`tion. 'Ihe contents of the Web page can contain data retrieved
`from an external data source (e.g., such as database server
`318), or state information maintained by the application.
`Custom logic and declarations can be associated with each
`Web page.
`technology to
`The application can make use of object
`generate client responses. For example, the elements of a
`Web page definition are objectified. Instances of definitional
`elements are instantiated during execution to manage their
`respective portions of the Web page. Control objects are
`associated with definitional elements to facilitate the flow of
`information to and from external data sources. Aspecial type
`of control referred to as a repetition control allows a group
`to be activated multiple times. Each activation of a group of
`definitional elements generates one occurrence of a repeat-
`ing portion of the Web page.
`Defirtitional elements can be grouped together. A group
`object class provides the ability to access these definitional
`elements as a group.
`Self-contained modules, or components, can be accessed
`to provide additional definition for the Web page. Acontrol
`object is associated with one of these modules to manage its
`integration into the rest of the Web page definition. The
`self-contained modules can be shared by one or more Web
`
`

`
`US 6,249,291 B1
`
`-
`
`9
`pages in a single application andfor across multiple appli-
`cations executing on application server 316 (or any other
`server).
`Internal application 320 can be, for example an Automo-
`bile Shopper’s application. lt can be used by a prospective
`car buyer
`to select a car. A car shopper accesses the
`Automobile Shopper’s application. The application provides
`a series oliscreens (i.e., Web pages) based on user-input that
`are designed to facilitate the selection and purchase of an
`automobile. FIG. 3B provides Web pages that are generated
`using application 32!] and displayed at a client workstation
`stlch as clients 3(E—308.
`The content of the Web pages seen by the shopper are
`determined based on the shopper's input. A Web page can be
`generated from a pre-built or static definition. However, it
`would