<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head profile="http://internetalchemy.org/2003/02/profile">
<link rel="foaf" type="application/rdf+xml" title="FOAF" href="http://www.openlinksw.com/dataspace/uda/about.rdf" />
<link rel="schema.dc" href="http://purl.org/dc/elements/1.1/" />
<meta name="dc.title" content="12. Web Application Development" />
<meta name="dc.subject" content="12. Web Application Development" />
<meta name="dc.creator" content="OpenLink Software Documentation Team ; " />
<meta name="dc.copyright" content="OpenLink Software, 1999 - 2009" />
<link rel="top" href="index.html" title="OpenLink Virtuoso Universal Server: Documentation" />
<link rel="search" href="/doc/adv_search.vspx" title="Search OpenLink Virtuoso Universal Server: Documentation" />
<link rel="parent" href="webappdevelopment.html" title="Chapter Contents" />
<link rel="prev" href="wsacl.html" title="Web Services ACL (Access Control List)" />
<link rel="next" href="vspx.html" title="Virtuoso Server Pages for XML (VSPX)" />
<link rel="shortcut icon" href="../images/misc/favicon.ico" type="image/x-icon" />
<link rel="stylesheet" type="text/css" href="doc.css" />
<link rel="stylesheet" type="text/css" href="/doc/translation.css" />
<title>12. Web Application Development</title>
<meta http-equiv="Content-Type" content="text/xhtml; charset=UTF-8" />
<meta name="author" content="OpenLink Software Documentation Team ; " />
<meta name="copyright" content="OpenLink Software, 1999 - 2009" />
<meta name="keywords" content="" />
<meta name="GENERATOR" content="OpenLink XSLT Team" />
</head>
<body>
<div id="header">
<a name="vsp1" />
<img src="../images/misc/logo.jpg" alt="" />
<h1>12. Web Application Development</h1>
</div>
<div id="navbartop">
<div>
<a class="link" href="webappdevelopment.html">Chapter Contents</a> | <a class="link" href="wsacl.html" title="Web Services ACL (Access Control List)">Prev</a> | <a class="link" href="vspx.html" title="Virtuoso Server Pages for XML (VSPX)">Next</a>
</div>
</div>
<div id="currenttoc">
<form method="post" action="/doc/adv_search.vspx">
<div class="search">Keyword Search: <br />
<input type="text" name="q" /> <input type="submit" name="go" value="Go" />
</div>
</form>
<div>
<a href="http://www.openlinksw.com/">www.openlinksw.com</a>
</div>
<div>
<a href="http://docs.openlinksw.com/">docs.openlinksw.com</a>
</div>
<br />
<div>
<a href="index.html">Book Home</a>
</div>
<br />
<div>
<a href="contents.html">Contents</a>
</div>
<div>
<a href="preface.html">Preface</a>
</div>
<br />
<div class="selected">
<a href="webappdevelopment.html">Web Application Development</a>
</div>
<br />
<div>
<a href="webserver.html">The HTTP Server</a>
</div>
<div>
<a href="wsacl.html">Web Services ACL (Access Control List)</a>
</div>
<div class="selected">
<a href="vsp1.html">Virtuoso Server Pages (VSP)</a>
<div>
<a href="#vspmarkup" title="VSP Markup & Basic Functions">VSP Markup & Basic Functions</a>
<a href="#accessrequestinfo" title="Access Request Information">Access Request Information</a>
<a href="#errorsinpage" title="Errors in Page Procedures">Errors in Page Procedures</a>
<a href="#inlinefile" title="/INLINEFILE HTTP Server Pseudo-Directory">/INLINEFILE HTTP Server Pseudo-Directory</a>
<a href="#furthervsp" title="Beyond Basics">Beyond Basics</a>
<a href="#longhttptrans" title="Long HTTP Transactions">Long HTTP Transactions</a>
<a href="#httpchunkedoutput" title="Using chunked encoding in HTTP 1.1">Using chunked encoding in HTTP 1.1</a>
<a href="#mksimpledynapages" title="Making Simple Dynamic Web Pages">Making Simple Dynamic Web Pages</a>
<a href="#xmlthtmloutmd" title="Generation of non-HTML output">Generation of non-HTML output</a>
<a href="#xmlthtmloutmd" title="Post VSP XSLT Transformation Mode">Post VSP XSLT Transformation Mode</a>
<a href="#xmlforproducingvsp" title="XML & XSLT Generated VSP Pages">XML & XSLT Generated VSP Pages</a>
</div>
</div>
<div>
<a href="vspx.html">Virtuoso Server Pages for XML (VSPX)</a>
</div>
<div>
<a href="rthwritaspxapps.html">Deploying ASP.Net Web Applications</a>
</div>
<div>
<a href="asmxhosting.html">ASMX Web Service Hosting</a>
</div>
<div>
<a href="blogger.html">Blogging & Weblogs</a>
</div>
<div>
<a href="servphpext.html">Deploying PHP Applications</a>
</div>
<div>
<a href="rthjsp.html">Deploying JSP Applications</a>
</div>
<div>
<a href="perlhosting.html">Perl Hosting</a>
</div>
<div>
<a href="pythonhosting.html">Python Hosting</a>
</div>
<div>
<a href="rubyhosting.html">Ruby Hosting</a>
</div>
<br />
</div>
<div id="text">
<a name="vsp1" />
<h2>12.3. Virtuoso Server Pages (VSP)</h2>
<p>The Virtuoso Server Pages subsystem is an integral part of the Virtuoso server.
A VSP page is a file system or DAV resident resource that contains Virtuoso/PL code intermixed with HTML or other static content.</p>
<table class="figure" border="0" cellpadding="0" cellspacing="0">
<tr>
<td>
<img alt="VSP Conceptual Diagram" src="../images/vspconcept.jpg" />
</td>
</tr>
<tr>
<td>Figure: 12.3.1. VSP Conceptual Diagram</td>
</tr>
</table>
<p>Virtuoso can serve Web pages to HTTP 1.0 and HTTP 1.1 clients. The
HTTP document root is set by the ServerRoot parameter in the [HTTPServer]
section of the Virtuoso INI file. By default this is set to <span class="computeroutput">vsp</span>
sub-directory of the installation. If this parameter is not set, then the default
document root will be the server's working directory. </p>
<div class="formalpara">
<strong>Executing VSP Pages</strong>
<p>Directories under the ServerRoot directory, including the root itself are
not automatically allowed to execute dynamic pages such as VSP. A virtual
directory must first be created with an appropriate VSP user assigned to
permit execution of dynamic pages. After this, Virtuoso will execute files
with a "<span class="computeroutput">.vsp</span>" extension as a VSP page.]
</p>
</div>
<div class="formalpara">
<strong>The VSP Stored Procedure</strong>
<p>Each VSP page constitutes a Virtuoso stored procedure named after the
URI of the page by taking the URI and pre-pending the WS.WS. qualifier and owner.
Hence the page <span class="computeroutput">/test.vsp</span> becomes the procedure
<span class="computeroutput">"WS"."WS"."/test.vsp"</span>. This is automatically performed
when a page is first requested. Subsequent requests to the page will not
reference the file. The VSP engine will check for changes in the
<span class="computeroutput">.vsp</span> source file before calling the
procedure and re-compile as required.
The <a href="">ws_proc_def()</a> SQL function
can be used to explicitly update the procedure if the .vsp file is changed.
</p>
</div>
<a name="fp_httphandleclidisconnect" />
<div class="formalpara">
<strong>The VSP Transaction</strong>
<p>Each URL is executed in its own transaction. All SQL statements in a page
procedure, whether on local or remote data, make up one transaction, unless
transaction control statements are explicitly used to divide the page into
multiple transactions. If the page procedure returns through completing execution
or through a return statement or as a result of a 'no data found' condition, the
transaction is implicitly committed. If this commit fails, the output is discarded
and the error message indicating the commit failure is sent to the HTTP client.
If a VSP procedure returns as a result of an error the transaction is rolled
back and the output discarded. The client gets the SQL error message as the
HTML body of the reply. A VSP procedure can commit or roll back explicitly with
the <span class="computeroutput">commit work</span> or
<span class="computeroutput">rollback work</span> PL statements.
</p>
<p>If the client closes the connection to the server while server-side processing
is taking place this will be detected by the server and the transaction will be
eventually interrupted and rolled back in the same way as if an ODBC client
had disconnected. To control the server reacting or not on the HTTP client
disconnecting the SET HTTP_IGNORE_DISCONNECT = ON/OFF should be used.</p>
</div>
<p>Each VSP page-procedure is called with three arguments:</p>
<ul>
<li>
<strong>path</strong> - the URI path of the VSP page itself.</li>
<li>
<strong>params</strong> - the parameters from a previous POST to the server.</li>
<li>
<strong>lines</strong> - the complete set of headers received from the calling client.</li>
</ul>
<p>Each VSP procedure runs in a context that implicitly contains the
stream to the HTTP client. The arguments of the VSP page procedure are
represented as arrays of strings. For example, GETing the URL: </p>
<div>
<pre class="programlisting">
http://www.test.net/x/y.vsp?arg1=1&arg2=2
</pre>
</div>
<p>would cause the following arguments to be given to the page-procedure
<span class="computeroutput">WS.WS./x/y.vsp</span>:</p>
<div>
<pre class="programlisting">
path ('x', 'y.vsp')
params ('arg1', '1', 'arg2', '2')
lines ('GET /x/y.vsp?arg1=1&arg2=2 HTTP/1.1', 'Host: www.test.net', ...)
</pre>
</div>
<p>Arrays are marked in parentheses with elements separated by commas.
The page procedure is called as a result of either a GET or POST request in
either HTTP/1.0 or HTTP/1.1. In the event of a POST request the params contains
the post data.</p>
<p>Virtuoso can be configured to proxy certain requests to another web
server. This allows using another web server for running cgi-bin's, Java
servelets or other web server functions. Virtuoso, however, is capable of
hosting many other dynamic engines also, such as PHP, JSP and ASP.Net.</p>
<div class="tip">
<div class="tiptitle">See Also:</div>
<p>
<a href="webserver.html#vspconf">HTTP Server Base Configuration</a>
</p>
<p>
<a href="htmlconductorbar.html#httpvirtualdirs">Virtual Directory Administration UI</a>
</p>
<p>
<a href="fn_vhost_define.html">vhost_define()</a>, <a href="fn_vhost_remove.html">vhost_remove()</a>
</p>
<p>
<a href="webserver.html#virtproxy">Virtuoso as a Proxy</a>
</p>
</div>
<a name="vspmarkup" />
<h3>12.3.2. VSP Markup & Basic Functions</h3>
<p>All VSP specific markup is represented as a processing instruction (<? ... ?>).</p>
<div>
<pre class="programlisting">
<?vsp
statement ;
statement ;
...
?>
</pre>
</div>
<p>This markup introduces Virtuoso PL code to a VSP page, which otherwise
may normally contain HTML markup. The code enclosed must begin
and end at a statement boundary but a compound statement may begin in one
<?vsp tag and end in another. Code outside of these blocks is ignored
by Virtuoso and placed directly on the HTTP stream to be sent to the client.</p>
<div class="tip">
<div class="tiptitle">See Also:</div>
<p>The <a href="sqlprocedures.html">SQL Procedure Language Guide</a> chapter.</p>
</div>
<p>Several functions exist to allow VSP code to send data to the HTTP stream.
They are basically the same but offer different escaping mechanisms to suit different purposes:</p>
<p>
<a href="fn_http.html">http (in <span class="parameter">value</span>, varchar, in <span class="parameter">stream</span> any);</a>
</p>
<p>
<a href="fn_http_value.html">http_value ( in <span class="parameter">value</span>, any, in <span class="parameter">tag</span>, varchar, in <span class="parameter">tag</span>, varchar, in <span class="parameter">stream</span> any);</a>
</p>
<p>
<a href="fn_http_url.html">http_url ( in <span class="parameter">value</span>, any, in <span class="parameter">tag</span>, varchar, in <span class="parameter">stream</span> any);</a>
</p>
<p>These functions output their <span class="computeroutput">value</span> argument
to the specified stream with varying escaping. The value argument may be any
scalar object, i.e. string, date or number and will automatically be cast to
varchar before further processing.</p>
<p>
<span class="computeroutput">http()</span> will print out the contents of <span class="computeroutput">value</span>
cast to string without any modification.</p>
<p>
<span class="computeroutput">http_value()</span> will use HTML escapes such that
'<span class="computeroutput"><</span>' will be output as
'<span class="computeroutput">&lt;</span>'.</p>
<p>The <span class="computeroutput">http_url()</span> function will use URL escapes
such that '+' replaces spaces and hex escapes like %25 will replace '%'.
If <span class="computeroutput">http_value()</span> gets an XML entity returned by a
path expression it outputs the serialization of the entity, including children.
This is not the string value since this has the entity start and end tags and
other markup. The tag argument allows specifying a tag in which the value
is to be enclosed. A non-string value, e.g. 0 or null will cause no tag to be
put around the value.</p>
<p>The stream argument may be omitted, in which case it defaults to the HTTP
client of the calling procedure. If present, a value of integer 0 will mean the
http client. If non-0 the value must be an object returned by
<a href="fn_string_output.html">string_output()</a>.</p>
<p>These HTTP functions are commonly combined with <span class="computeroutput">sprintf()</span>
which allows string composition based on a template. When
using <a href="fn_sprintf.html">sprintf()</a> to compose data
to send to the user agent the %V and %U letters can be used to introduce escapes
similar to http_value and http_url, respectively.
</p>
<a name="ex_httpfunctions" />
<div class="example">
<div class="exampletitle">HTTP Functions</div>
<div>
<pre class="programlisting">
http (' % <b>') ' % <b>'
http_value (' % <b>') ' % &lt;b&gt;'
http_url (' % <b>') '+%25+<b>'
http_value (12, 'li') '<li>12</li>'
</pre>
</div>
</div>
<a name="vspmarkupshort" />
<h4>12.3.2.1. Markup Short-hands</h4>
<p>VSP markup short-hands exist for the <span class="computeroutput">http_value()</span> and
<span class="computeroutput">http_url()</span> functions to perform the same task outside of
a VSP code block. This can improve readability of VSP pages.</p>
<div>
<pre class="programlisting">
<?= expression ?> equiv. http_value()
</pre>
</div>
<div>
<pre class="programlisting">
<?/ expression ?> equiv. http_url()
</pre>
</div>
<p>These markups are shorthand for substituting values of expressions into
the output. The <span class="computeroutput"><?= </span>tag accepts a SQL
expression and casts the value into a string, which is sent to the output. The
<span class="computeroutput"><?/ </span> markup sends the value of the
expression to the client with HTTP URL escapes.</p>
<a name="vspmkup" />
<div class="example">
<div class="exampletitle">VSP Markup</div>
<p>Here is a very simple example of making a two column HTML table
from the results of a "select" SQL statement. First using normal functions:</p>
<div>
<pre class="programlisting">
<html>
<h2>List of Users</h2>
<table>
<?vsp
for (select u_name, u_password from sys_users ) do {
http('<tr><td>');
http (u_name);
http('</td><td>');
http (u_password);
http('</td></tr>');
}
?>
</table>
</html>
</pre>
</div>
<p>This fragment outputs a table of user names and passwords. We have
chosen to not end the code block until the end of the result so we have repeatedly
used the <span class="computeroutput">http()</span> function to output parts of the table also.</p>
<p>Now the same code but including shorthands:</p>
<div>
<pre class="programlisting">
<html>
<h2>List of Users</h2>
<table>
<?vsp for (select u_name, u_password from sys_users ) do { ?>
<tr>
<td><?=u_name ?></td>
<td><?=u_password ?></td></tr>
<?vsp } ?>
</table>
</html>
</pre>
</div>
</div>
<br />
<br />
<a name="accessrequestinfo" />
<h3>12.3.3. Access Request Information</h3>
<p>Request information, resulting from an HTTP POST, is available via
the <span class="computeroutput">params</span> vector. The params vector is always
available for the purpose in a VSP context. Similarly the <span class="computeroutput">lines</span>
and <span class="computeroutput">path</span> vectors are available for the HTTP headers and
URL path respectively.</p>
<p>Parameters stored in the params vector are stored in keyword-value
pairs, such that keywords are stored in the even elements, values in the odd
numbered elements. Vectors and arrays can be accessed using the
<span class="computeroutput">aref()</span> and <span class="computeroutput">aset()</span> functions,
however, the exact position of parameters is seldom known. The
<span class="computeroutput">get_keyword()</span> function can be used to return the value of a
given parameter. You can specify a default value to return in case the
parameter you are looking for is not found.</p>
<p>
<span class="computeroutput">get_keyword (<span class="parameter">'param_name'</span>, , <span class="parameter">vector</span>, [, <span class="parameter">opt_default_value'</span>]);</span>
</p>
<p>If a default value other than '' (empty-string) is not required then a
short-hand can be used instead.</p>
<div>
<pre class="programlisting">{?'param_name'}</pre>
</div>
<p>is equivalent to <span class="computeroutput">get_keyword (<span class="parameter">'param_name'</span>, , <span class="parameter">'params'</span>);</span>
</p>
<p>Since <span class="computeroutput">get_keyword()</span> returns only strings, you will
find that <span class="computeroutput">cast</span>ing or conversion functions
such as <span class="computeroutput">atoi()</span> are very useful here.</p>
<a name="ex_usingparamsvector" />
<div class="example">
<div class="exampletitle">Reading the params Vector</div>
<p>Consider retrieving the following page by means of the URL: </p>
<div>
<pre class="programlisting">
http://myvirtuoso/test.vsp?arg1=1&arg2=test
</pre>
</div>
<div>
<pre class="programlisting">
<html>
<body>
<h1>Test Params</h1>
<?vsp
declare _arg1 integer; -- the underscore helps to differentiate from
declare _arg2 varchar; -- the keyword name, whereas the variable names
declare _arg3 varchar; -- help use remember which is which.
_arg1 := atoi(get_keyword('arg1', params));
_arg2 := {?'arg2'};
_arg3 := get_keyword('arg3', params, 'was empty'};
?>
<p>values returned:</p>
<p>arg1: <?=_arg1?></p>
<p>arg2: <?=_arg2?></p>
<p>arg3: <?=_arg3?></p>
</body>
</html>
</pre>
</div>
</div>
<div class="tip">
<div class="tiptitle">See Also:</div>
<p>
<a href="fn_get_keyword.html">get_keyword()</a>
</p>
<p>
<a href="fn_atoi.html">atoi()</a>
</p>
<p>
<a href="fn_aref.html">aref()</a>
</p>
<p>
<a href="fn_aset.html">aset()</a>
</p>
<p>
<a href="sqlrefDATATYPES.html#dtcasting">cast</a>
</p>
</div>
<div class="note">
<div class="notetitle">Note:</div>
<p>Sometimes a POST can supply a large amount of data, such as from
an <INPUT type="file">. When the length of the parameter data
exceeds 5,000,000 octets the result is stored as a string session in the
params array. In these cases the value should not be copied or converted
to a string, it is likely to be truncated. The value should be stored as a
BLOB or an external file. When processing possibly large input fields in a
form either the fourth parameter to <span class="computeroutput">get_keyword()/get_keyword_ucase()</span>
should be set to 1 or they should be accessed
through <span class="computeroutput">aref_set_0()</span>.</p>
</div>
<br />
<a name="errorsinpage" />
<h3>12.3.4. Errors in Page Procedures</h3>
<p>
VSP pages can declare handlers for errors using the normal handler declaration or whenever ... goto construct.
Any unhandled error causes the procedure to be terminated and the error
message to be sent to the HTTP client instead of the output. Because terminating
the page output at an arbitrary point would probably result in not well formed output
all the output up to the point of the error is discarded.
</p>
<p>If the SQL state signalled with the error is VSPRT the output
generated up to the point where the error was signalled is sent as
such to the user agent. This special SQL state is useful together
with the http_rewrite function for things like sending a redirect based
on a condition detected in the middle of page processing. The
http_rewrite function will clear all output buffered so far and
signaling VSPRT will make sure that whatever output is generated
after http_rewrite goes unmodified to the user agent.</p>
<br />
<a name="inlinefile" />
<h3>12.3.5. /INLINEFILE HTTP Server Pseudo-Directory</h3>
<p>This pseudo directory provides a way for a VSP page to have full
control over the data sent to the client user-agent, for example to send files to
it and to handle the HTTP response attributes.</p>
<p>URIs starting with
/INLINEFILE are handled through a VSP procedure instead of
being searched for in the HTTP root directory. This special URI has the
following syntax:</p>
<div>
<pre class="programlisting">
/INLINEFILE/some_file_name?VSP=some_vsp&arg1=x&arg2=y.....
</pre>
</div>
<p>Upon receipt of such a URI, Virtuoso will execute the "some_vsp"
VSP page with the parameters following the VSP parameter. The VSP page
can adjust the HTTP response header attributes using the
<span class="computeroutput">http_header()</span> function to reflect the content of the
HTTP body, such as specifying the encoding through "Content-Encoding" attribute,
or a MIME type through "Content-Type" attribute).</p>
<a name="ex_inlinefile" />
<div class="example">
<div class="exampletitle">Using /INLINEFILE</div>
<p>Here is a simple example for showing JPEG images stored in DAV.
The page will list the first ten images found in the DAV resources table as hyper-links.
Clicking on them will fetch the content and display using
/INLINEFILE.</p>
<div>
<pre class="programlisting">
<?vsp
if ({?'getfile'} <> '')
{
http_header ('Content-type: image/jpg\t\n'); -- set the header to jpg
declare image any;
select RES_CONTENT into image from WS..SYS_DAV_RES
where RES_ID = atoi({?'id'}); -- download image from WebDAV
http(image); -- table and display
return;
}
?>
<html>
<body>
<h1>Using /INLINEFILE to display images from the database</h1>
<table>
<tr>
<td>
<?vsp for (select top 10 RES_ID, RES_NAME from WS..SYS_DAV_RES where right(RES_NAME, 3) = 'jpg') do {?>
<a href="?id=<?=RES_ID?>"><?=RES_NAME?></a><br>
<?vsp } ?>
</td>
<td>
<p><img src="/INLINEFILE/picture.jpg?VSP=<?/http_path()?>&getfile=yes&id=<?={?'id'}?>"></p>
<p><a href="/INLINEFILE/picture.jpg?VSP=<?/http_path()?>&getfile=yes&id=<?/{?'id'}?>">download</a></p>
</td>
</tr>
</table>
</body>
</html>
</pre>
</div>
<div class="note">
<div class="notetitle">Note:</div>
<p>Note the use of the <span class="computeroutput">http_path()</span> function to find the
full path of the originating VSP file.</p>
<p>Also note the call to <span class="computeroutput">http_header()</span> to set the appropriate
content type for the returned data. When Virtuoso retrieves files normally, it will
consult the system table <span class="computeroutput">WS.WS.SYS_DAV_RES_TYPES</span>
for types based on the file extension. We do not need to refer to the table in our
example because we are making sure that only JPEGs are being returned.</p>
</div>
</div>
<div class="tip">
<div class="tiptitle">See Also:</div>
<p>
<a href="fn_http_header.html">http_header()</a>
</p>
<p>
<a href="fn_http_path.html">http_path()</a>
</p>
</div>
<br />
<a name="furthervsp" />
<h3>12.3.6. Beyond Basics</h3>
<p>All output from VSP page procedures is buffered into a local string
stream before being sent out. This is done so as to support the HTTP/1.1 required
content length and to allow recovery from errors.</p>
<p>
<a href="fn_http_rewrite.html">http_rewrite ( in <span class="parameter">stream</span> any);</a>
</p>
<p>This clears any previous output to the stream. If the stream is
omitted or 0 the stream is the HTTP client stream of the calling procedure.</p>
<p>
<a href="fn_http_file.html">http_file ( in <span class="parameter">path</span> varchar);</a>
</p>
<p>This function sends a file to the HTTP client as a response to the
current request. Any other output that may have been generated by the calling
procedure will be discarded and the contents of the file will be the exclusive
response to the current HTTP request together with appropriate headers.
The file will only be sent after the procedure handling the current HTTP
request has returned. The file name is thus not validated until the calling
procedure has returned.</p>
<p>
<a href="fn_http_get.html">http_get( in <span class="parameter">uri</span>, varchar,
out <span class="parameter">headers</span> varchar);</a>
</p>
<p>This function retrieves the document specified by the URI by HTTP and
returns the data of the response. The header output parameter is set to be
an array with an element for each line of the response's HTTP header. Each
line is a varchar object in the containing array. The header parameter is optional.</p>
<p>The URI is of the form <span class="computeroutput">host[:port]<path></span>, e.g
'<span class="computeroutput">www.openlinksw.com:80/index.html</span>'. The
port, if omitted, defaults to 80. The data following the headers is not
processed in any way. No content transfer encodings are decoded but an
eventual content transfer encoding header can be found in the header array.</p>
<p>
<a href="fn_http_flush.html">http_flush();</a>
</p>
<p>This function generates a response header, flushes a stream and
disconnects the client, however, the server will continue with the execution
of the PL code in VSP page. The final result will never be sent to the client.
This is useful when a page makes a long transaction and we do not wish the
client to wait until its end, which may result in a time-out. Suppose we have the
retrieval of news from many targets, each a thousand messages. We start from
a VSP page process, inside it we put into the internal stream (using http,
http_value etc.) redirect code and call http_flush. The client can read the
response and go to a status page that can display number of messages retrieved,
which may need refreshing a few times.</p>
<p>
<a href="fn_http_proxy.html">
http_proxy (in <span class="parameter">host_and_port</span>, varchar,
in <span class="parameter">header_lines</span>, any,
in <span class="parameter">post_parameters</span> any)</a>
</p>
<p>
The function http_proxy() is used to send request in header_lines and post_parameters
to the host_and_port, read the response and send it back to the client.
The http_proxy() function can be used inside a VSP page to send a request to
an external web server and automatically route the reply sent by this remote server
to the client of the VSP page calling http_proxy().
The output which can generated (with http functions, etc.) before and after http_proxy
is called will be discarded before sending the result of link retrieval to the user-agent.
</p>
<a name="virtpxy" />
<div class="example">
<div class="exampletitle">Virtuoso Proxy</div>
<div>
<pre class="programlisting">
...
<?vsp
http ('this never be displayed');
http_proxy ('www.foo.com', vector ('GET / HTTP/1.0'), NULL);
http ('and this also');
?>
...
</pre>
</div>
</div>
<a name="httpcharsettings" />
<h4>12.3.6.1. Virtuoso HTTP Server Character Set Settings</h4>
<p>When the HTTP server returns the HTTP header to the client it appends charset=xxxx to
the Content-Type: HTTP header fields. This informs the client user agent, the web browser,
as to the character set of the content to be displayed correctly. It uses the Web server
charset to correctly format values resulting from the <span class="computeroutput">http_value()</span> function
or the VSP equivalent <?= ...>. Wide values and XML entities, resulting from any XML
processing functions like xpath_contains, get represented using
the "HTML/XML transformation".</p>
<p>The default web server charset is governed by the <strong>Charset</strong>
setting defined in the <a href="databaseadmsrv.html#VIRTINI">Virtuoso INI file</a>. If no default
charset is specified then Virtuoso will use ISO-8859-1.</p>
<p>The HTTP character set can be changed during an HTTP session using:
<strong>set http_charset='charset_name';</strong>.</p>
<p>The XSLT output encoding can also be specified to over ride the server
default setting.</p>
<br />
<a name="sesmanvars" />
<h4>12.3.6.2. Session Management and State Variables</h4>
<p>
The Virtuoso HTTP session management consists of functions for session
variables manipulation and hooks for saving and restoring session variables.
</p>
<p>Session management must be enable by setting the flag for persistent
session variables in the virtual directory mapping. Virtual directory mappings use
the <strong>persistent_session_variables</strong> flag, which when
specified, session variables can be used in a post-process function to determine
if the session variables content must be stored on to the session table or not.
</p>
<p>
The post-processing function hook can be any user-defined Virtuoso/PL procedure,
it will be executed every time after processing of the active page.
</p>
<div class="tip">
<div class="tiptitle">See Also:</div>
<p>
<a href="fn_connection_get.html">connection_get()</a>
</p>
<p>
<a href="fn_connection_set.html">connection_set()</a>
</p>
<p>
<a href="fn_connection_vars.html">connection_vars()</a>
</p>
<p>
<a href="fn_connection_vars_set.html">connection_vars_set()</a>
</p>
<p>
<a href="fn_connection_is_dirty.html">connection_is_dirty()</a>
</p>
</div>
<br />
<br />
<a name="longhttptrans" />
<h3>12.3.7. Long HTTP Transactions</h3>
<p>Long running tasks may be invoked by web clients. In such a case,
the server should return a page for the user agent much before the tasks's completion
in order to provide feedback and avoid timeouts. Also the long running task should not be
interrupted by the user agent disconnecting. The <span class="computeroutput">http_flush()</span> function will
send the reply accumulated thus far to the user agent and then disconnect it.
In effect, this is a generic mechanism for starting an asynchronous thread.</p>
<p>Starting long running tasks may lead to denial of service.
To prevent this we can use status and stop functions to check processes and
kill them if necessary.</p>
<p>We can retrieve the URL, client IP-address, and process status code
for all currently running VSP requests, then use this information to isolate
and eliminate a process.</p>
<p>
<a href="fn_http_pending_req.html">http_pending_req()</a>
Lists the processes.</p>
<p>
<a href="fn_http_kill.html">http_kill()</a> can be used to kill them.</p>
<br />
<a name="httpchunkedoutput" />
<h3>12.3.8. Using chunked encoding in HTTP 1.1</h3>
<p>It is sometimes desirable to use the HTTP 1.1 chunked encoding to send
data to HTTP clients. Examples of such include status pages or streaming
applications. Note that the possibility of using chunked encoding depends on
external factors such as whether the client browser supports chunked
encoding. So a server page can request turning on the chunked encoding, but should
handle the case should it not be available.</p>
<p>Note that in order to successfully turn on the chunked encoding the
page should not be using the <span class="computeroutput">http_xslt()</span>. Also
all reply headers set by the <span class="computeroutput">http_header()</span> are silently
ignored after the mode is set.</p>
<p>The <span class="computeroutput">http_flush()</span> (with 1 as a value for it"s optional
argument) is used to request turning on the chunked encoding. If the client"s
user agent supports the encoding, then the data accumulated so far in the
server"s output buffer are sent to the client as the first chunk, the
request is put in special "chunked mode" and the <span class="computeroutput">http_flush()</span>
returns a non-zero integer. When in that mode a new chunk is sent
to the client either when the internal 4k buffer is filled up or when the client
calls <span class="computeroutput">http_flush()</span> again to flush the buffer and send it as a chunk.
The client disconnection is handled as <a href="webappdevelopment.html#fp_httphandleclidisconnect">usual</a>.</p>
<br />
<a name="mksimpledynapages" />
<h3>12.3.9. Making Simple Dynamic Web Pages</h3>
<p>
The directory where the pages reside must be marked as executable.
Use the <a href="fn_vhost_define.html">vhost_define</a> function or
the <a href="htmlconductorbar.html#httpvirtualdirs">Administration Interface</a> to do this:
</p>
<div>
<pre class="programlisting">
vhost_define (lpath=>'/example_location', ppath=>'/example_location/', vsp_user=>'demo');
</pre>
</div>
<p>
The usual way to make an Dynamic page is to make a HTML skeleton and insert
Virtuoso/PL code in appropriate places to fill in the rest dynamically. Consider
the following example as a demonstration of such technique. Note that the
example is made in four steps but in practice this can be one.
</p>
<p>
Suppose we have a table Demo.demo.Shippers (from the Demo database of the
standard distribution). We can make a simple page for editing it.
</p>
<ol>
<li>
<div class="formalpara">
<strong>Building The HTML Skeleton</strong>
<p>
We define one form for editing and adding entries and a table for listing the existing shippers.
</p>
<div>
<pre class="programlisting">
<HTML>
<BODY>
<!-- edit form -->
<FORM name="ShippersForm" method="POST" action="shippers.vsp">
<INPUT type="hidden" name="ShipperID" value="">
<TABLE>
<TR>
<TD>Company Name</TD>
<TD><input type="text" name="CompanyName" value=""><!-- CompanyName --></TD>
</TR>
<TR>
<TD>Phone</TD>
<TD><INPUT type="text" name="Phone" value=""><!-- Phone number --></TD>
</TR>
<TR><TD colspan="2"><input type="submit" name="accept" value="Accept"></TD></TR>
</TABLE>
</FORM>
<!-- end of form -->
<!-- list of entries -->
<TABLE>
<TR><TD>Company Name</TD><TD>Phone #</TD><TD colspan="2">Action</TD></TR>
<!--TR><TD>CompanyName</TD><TD>Phone</TD><TD>Edit URI</TD><TD>Delete URI</TD></TR-->
</TABLE>
<!-- end of list -->
</BODY>
</HTML>
</pre>
</div>
</div>
</li>
<li>
<div class="formalpara">
<strong>Filling a List of Entries</strong>
<p>
We have added in part 'list of entries' one active part (for select ...).
And using <?=...?> shortcut we have made for each row in database table
one row in table defined in step 1. Also we have added two useful links
'Edit' and 'Delete' with URL parameter 'EDIT' and 'DELETE' whose value
is equal to the primary key value of the row;
</p>
<div>
<pre class="programlisting">
<HTML>
<BODY>
<!-- edit form -->
<FORM name="ShippersForm" method="POST" action="shippers.vsp">
<INPUT type="hidden" name="ShipperID" value="">
<TABLE>
<TR>
<TD>Company Name</TD>
<TD><input type="text" name="CompanyName" value=""><!-- CompanyName --></TD>
</TR>
<TR>
<TD>Phone</TD>
<TD><INPUT type="text" name="Phone" value=""><!-- Phone number --></TD>
</TR>
<TR><TD colspan="2"><input type="submit" name="accept" value="Accept"></TD></TR>
</TABLE>
</FORM>
<!-- end of form -->
<!-- list of entries -->
<TABLE>
<TR><TD>Company Name</TD><TD>Phone #</TD><TD colspan="2">Action</TD></TR>
<!--TR><TD>CompanyName</TD><TD>Phone</TD><TD>Edit URI</TD><TD>Delete URI</TD></TR-->
<?vsp
for select ShipperID, CompanyName, Phone from Demo.demo.Shippers do
{
?>
<TR>
<TD><?=CompanyName?></TD>
<TD><?=Phone?></TD>
<TD><a href="shippers.vsp?EDIT=<?=ShipperID?>">Edit</a></TD>
<TD><a href="shippers.vsp?DELETE=<?=ShipperID?>">Delete</a></TD>
</TR>
<?vsp
}
?>
</TABLE>
<!-- end of list -->
</BODY>
</HTML>
</pre>
</div>
</div>
</li>
<li>
<div class="formalpara">
<strong>Retrieving Parameters and Filling in The Form</strong>
<p>We must retrieve the parameters 'Delete' and 'Edit' from the URL and fill in
the form elements
</p>
<p>
We have added a section to the top of the page that we use to recognize what operation to perform
and do the appropriate action in the database. In the case of editing we use the values
input on the form.
</p>
<div>
<pre class="programlisting">
<?vsp
declare company_name, phone_number varchar;
declare shipper_id, operation integer;
declare shipper_info
cursor for select CompanyName, Phone
from Demo.demo.Shippers where ShipperID = shipper_id;
company_name := '';
phone_number := '';
operation := 0;
shipper_id := atoi (get_keyword ('EDIT', params, '0'));
if (shipper_id > 0)
{
whenever not found goto not_found_any;
open shipper_info (prefetch 1);
fetch shipper_info into company_name, phone_number;
not_found_any:
close shipper_info;
goto display_page;
}
shipper_id := atoi (get_keyword ('DELETE', params, '0'));
if (shipper_id > 0)
{
delete from Demo.demo.Shippers where ShipperID = shipper_id;
goto display_page;
}
display_page:
?>
<HTML>
<BODY>
<!-- edit form -->
<FORM name="ShippersForm" method="POST" action="shippers.vsp">
<INPUT type="hidden" name="ShipperID" value="<?=shipper_id?>">
<TABLE>
<TR>
<TD>Company Name</TD>
<TD><input type="text" name="CompanyName" value="<?=company_name?>"</TD>
</TR>
<TR>
<TD>Phone</TD>
<TD><INPUT type="text" name="Phone" value="<?=phone_number?>"</TD>
</TR>
<TR><TD colspan="2"><input type="submit" name="accept" value="Accept"></TD></TR>
</TABLE>
</FORM>
<!-- end of form -->
<!-- list of entries -->
<TABLE>
<TR><TD>Company Name</TD><TD>Phone #</TD><TD colspan="2">Action</TD></TR>
<!--TR><TD>CompanyName</TD><TD>Phone</TD><TD>Edit URI</TD><TD>Delete URI</TD></TR-->
<?vsp
for select ShipperID, CompanyName, Phone from Demo.demo.Shippers do
{
?>
<TR>
<TD><?=CompanyName?></TD>
<TD><?=Phone?></TD>
<TD><a href="shippers.vsp?EDIT=<?=ShipperID?>">Edit</a></TD>
<TD><a href="shippers.vsp?DELETE=<?=ShipperID?>">Delete</a></TD>
</TR>
<?vsp
}
?>
</TABLE>
<!-- end of list -->
</BODY>
</HTML>
</pre>
</div>
</div>
</li>
<li>
<div class="formalpara">
<strong>Editing Form Logic</strong>
<p>
We have a logic in the same initialization part of the page that retrieves
a 'ShipperID' parameter, so if this parameter exists in the params array then
the operation is to perform an insert, otherwise we must update a record.
</p>
<div>
<pre class="programlisting">
<?vsp
declare company_name, phone_number varchar;
declare shipper_id integer;
declare shipper_info
cursor for select CompanyName, Phone
from Demo.demo.Shippers where ShipperID = shipper_id;
company_name := '';
phone_number := '';
shipper_id := atoi (get_keyword ('EDIT', params, '0'));
-- If the current operation is edit then we retrieve the Company Name and Phone
if (shipper_id > 0)
{
whenever not found goto not_found_any;
open shipper_info (prefetch 1);
fetch shipper_info into company_name, phone_number;
not_found_any:
close shipper_info;
goto display_page;
}
shipper_id := atoi (get_keyword ('DELETE', params, '0'));
-- If the operation is delete then delete it (if any error
-- occurred then HTTP server will handle it)
if (shipper_id > 0)
{
delete from Demo.demo.Shippers where ShipperID = shipper_id;
shipper_id := 0; -- reset it to prevent submission of wrong shipper id
goto display_page;
}
-- If pressed button Accept then we can recognize the operation
if ('' <> get_keyword ('accept', params, ''))
{
shipper_id := atoi (get_keyword ('ShipperID', params, '0'));
company_name := get_keyword ('CompanyName', params, 'unknown');
phone_number := get_keyword ('Phone', params, 'N/A');
-- the old entry going edited
if (shipper_id > 0)
update Demo.demo.Shippers set CompanyName = company_name, Phone = phone_number
where ShipperID = shipper_id;
else -- this is an new entry
{
shipper_id := coalesce ((select max(ShipperID) from Demo.demo.Shippers), 0) + 1;
insert into Demo.demo.Shippers (ShipperID,CompanyName,Phone)
values (shipper_id,company_name,phone_number);
}
company_name := ''; -- we clear all entered data
phone_number := '';
shipper_id := 0; -- to prevent setting of wrong shipper id in form
}
display_page:
?>
<HTML>
<BODY>
<H3>Editing a shipment companies</H3>
<!-- edit form -->
<FORM name="ShippersForm" method="POST" action="shippers.vsp">
<INPUT type="hidden" name="ShipperID" value="<?=shipper_id?>">
<TABLE>
<TR>
<TD>Company Name</TD>
<TD><input type="text" name="CompanyName" value="<?=company_name?>"</TD>
</TR>
<TR>
<TD>Phone</TD>
<TD><INPUT type="text" name="Phone" value="<?=phone_number?>"</TD>
</TR>
<TR><TD colspan="2"><input type="submit" name="accept" value="Accept"></TD></TR>
</TABLE>
</FORM>
<!-- end of form -->
<!-- list of entries -->
<TABLE>
<TR><TD>Company Name</TD><TD>Phone #</TD><TD colspan="2">Action</TD></TR>
<!--TR><TD>CompanyName</TD><TD>Phone</TD><TD>Edit URI</TD><TD>Delete URI</TD></TR-->
<?vsp
for select ShipperID, CompanyName, Phone from Demo.demo.Shippers do
{
?>
<TR>
<TD><?=CompanyName?></TD>
<TD><?=Phone?></TD>
<TD><a href="shippers.vsp?EDIT=<?=ShipperID?>">Edit</a></TD>
<TD><a href="shippers.vsp?DELETE=<?=ShipperID?>">Delete</a></TD>
</TR>
<?vsp
}
?>
</TABLE>
<!-- end of list -->
</BODY>
</HTML>
</pre>
</div>
</div>
</li>
<li>
<div class="formalpara">
<strong>Final Remarks</strong>
<p>
The page for shippers does not have any specific error-handling. If there are any
SQL errors produced the HTTP server will display the error number and the server
error message. For example, if we trying to delete an record of a predefined
shippers we would have a foreign key violation to which the server would respond:
</p>
<div>
<pre class="screen">
'SQL Error S1000 DELETE statement conflicted with
COLUMN REFERENCE constraint "Orders_Shippers_ShipVia_ShipperID"'
</pre>
</div>
<p>
We can, however, add PL code to handle errors and display a different page.
</p>
</div>
</li>
</ol>
<br />
<a name="xmlthtmloutmd" />
<h3>12.3.10. Generation of non-HTML output</h3>
<p>
VSP pages are not restricted to generating only HTML markup.
In order to generate non-HTML markup the VSP page MUST conform to the target format specification,
for example if XML output is needed, the markup MUST follow XML syntax rules. The output sent to the user agent is entirely controlled by the scripting on the page, no constant headers beyond the required HTTP ones are added by the serber.
</p>
<p>
Also it is important when output is not HTML that the HTTP header field
'Content-Type' be set to appropriate MIME type (for example 'text/xml', 'text/plain' etc)
using <span class="computeroutput">http_header()</span>.
</p>
<a name="" />
<div class="example">
<div class="exampletitle">XML generation</div>
<p>The following example shows how an XML document can be generated using a VSP page</p>
<div>
<pre class="programlisting">
<?vsp
-- source of the xmldemo.vsp
declare txt varchar;
http_header ('Content-Type: text/xml\r\n');
txt := 'this is a XML test';
?><?xml version="1.0" ?>
<document>
<para><?= txt ?></para>
</document>
</pre>
</div>
</div>
<a name="" />
<div class="example">
<div class="exampletitle">WML generation</div>
<p>The following example shows how a WML page can be generated using a VSP page</p>
<div>
<pre class="programlisting">
<?vsp
-- source of the wmldemo.vsp
declare txt varchar;
http_header ('Content-type: text/vnd.wap.wml\r\n');
txt := 'this is a WML test';
?><?xml version="1.0" ?>
<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">
<wml>
<card>
<p><?= txt ?></p>
</card>
</wml>
</pre>
</div>
</div>
<div class="tip">
<div class="tiptitle">See Also:</div>
<p>
<a href="/tutorial/wap/index.vsp">WML Tutorials</a>
</p>
</div>
<br />
<a name="xmlthtmloutmd" />
<h3>12.3.11. Post VSP XSLT Transformation Mode</h3>
<p>
The Virtuoso server can perform server-side XSLT transformations on the
internal stream data. Suppose we have an XML document, we can tell the
HTTP server to invoke XSLT processor before sending the reply to the user agent.
We do this by making a call to the <a href="fn_http_xslt.html">http_xslt()</a> function
inside VSP or any procedure called from it and pass the URL of the stylesheet
and probably some parameters.</p>
<p>
<a href="fn_http_xslt.html">
http_xslt(in <span class="parameter">style_sheet_URI</span>, varchar [, in <span class="parameter">parameters</span> any])</a>
</p>
<p>The VSP page will produce an XML document,
rather than HTML. The XSL stylesheet will then produce the required
output for the user-agent, which could be more XML or HTML.</p>
<p>The XSL stylesheet could also be generated using VSP.</p>
<a name="" />
<div class="example">
<div class="exampletitle">In Server Transformation of XML</div>
<div>
<pre class="programlisting">
<?vsp
declare ses any;
ses := string_output ();
xml_auto ('select ShipperID, CompanyName, Phone from Demo.demo.Shippers
for xml auto element', '', ses);
http ('<list>');
http (string_output_string (ses));
http ('</list>');
http_xslt ('file:/samples/xslt/shippers.xsl');
?>
</pre>
</div>
<p>Where shippers.xsl will have the following content:</p>
<div>
<pre class="programlisting">
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html"/>
<xsl:template match="/">
<html>
<head>
<title>Shippers list</title>
</head>
<body link="#0000b4" vlink="#0000b4" bgcolor="#ffffff">
<xsl:apply-templates/>
</body>
</html>
</xsl:template>
<xsl:template match="list">
<table>
<tr><td>ID</td><td>Name</td><td>Phone</td></tr>
<xsl:apply-templates/>
</table>
</xsl:template>
<xsl:template match="Shippers">
<tr>
<td><xsl:value-of select="ShipperID"/></td>
<td><xsl:value-of select="CompanyName"/></td>
<td><xsl:value-of select="Phone"/></td>
</tr>
</xsl:template>
</xsl:stylesheet>
</pre>
</div>
</div>
<br />
<a name="xmlforproducingvsp" />
<h3>12.3.12. XML & XSLT Generated VSP Pages</h3>
<p>
The Virtuoso HTTP server provides a special case for producing VSP pages.
For this purpose the extensions .vxml and .vxsl are reserved. If the
requested document is named dummy.vxml then the HTTP server will try to locate
dummy.vxsl. If the dummy.vxsl exists then it will perform an XSLT transformation
using .vxml as a target XML document and .vxsl as a XSLT stylesheet. After
successful transformation it will compile a result from it in the usual way
and then perform execute.</p>
<p>The requirements are: XML document with extension .vxml,
XSLT sheet with the same name, location but extension .vxsl. The
location of these files must be set to allow execution
(see <a href="webserver.html#virtdir">Virtual Directories Support and Execution Privileges</a>).
</p>
<a name="ex_vxsl1" />
<div class="example">
<div class="exampletitle">Executable (V)XSL</div>
<p>
Source of portfolio.vxml
</p>
<div>
<pre class="programlisting">
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="portfolio.xsl"?>
<portfolio xmlns:dt="urn:schemas-microsoft-com:datatypes" xml:space="preserve">
<stock exchange="nyse">
<name>zacx corp</name>
<symbol>ZCXM</symbol>
<price dt:dt="number">28.875</price>
</stock>
<stock exchange="nasdaq">
<name>zaffymat inc</name>
<symbol>ZFFX</symbol>
<price dt:dt="number">92.250</price>
</stock>
<stock exchange="nasdaq">
<name>zysmergy inc</name>
<symbol>ZYSZ</symbol>
<price dt:dt="number">20.313</price>
</stock>
</portfolio>
</pre>
</div>
<p>
Source of portfolio.vxsl
</p>
<div>
<pre class="programlisting">
<?xml version='1.0'?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<xsl:template match="/">
<HTML>
<BODY>
<TABLE BORDER="2">
<TR>
<TD>Symbol</TD>
<TD>Name</TD>
<TD>Price</TD>
</TR>
<xsl:for-each select="portfolio/stock">
<TR>
<TD><xsl:value-of select="symbol"/></TD>
<TD><xsl:value-of select="name"/></TD>
<TD><xsl:value-of select="price"/></TD>
</TR>
</xsl:for-each>
</TABLE>
</BODY>
</HTML>
</xsl:template>
</xsl:stylesheet>
</pre>
</div>
<p>
The result of retrieving portfolio.vxml
</p>
<div>
<pre class="programlisting">
<HTML>
<BODY>
<TABLE BORDER="2">
<TR><TD>Symbol</TD><TD>Name</TD><TD>Price</TD></TR>
<TR><TD>ZCXM</TD><TD>zacx corp</TD><TD>28.875</TD></TR>
<TR><TD>ZFFX</TD><TD>zaffymat inc</TD><TD>92.250</TD></TR>
<TR><TD>ZYSZ</TD><TD>zysmergy inc</TD><TD>20.313</TD></TR>
</TABLE>
</BODY>
</HTML>
</pre>
</div>
</div>
<br />
<table border="0" width="90%" id="navbarbottom">
<tr>
<td align="left" width="33%">
<a href="wsacl.html" title="Web Services ACL (Access Control List)">Previous</a>
<br />Web Services ACL (Access Control List)</td>
<td align="center" width="34%">
<a href="webappdevelopment.html">Chapter Contents</a>
</td>
<td align="right" width="33%">
<a href="vspx.html" title="Virtuoso Server Pages for XML (VSPX)">Next</a>
<br />Virtuoso Server Pages for XML (VSPX)</td>
</tr>
</table>
</div>
<div id="footer">
<div>Copyright© 1999 - 2009 OpenLink Software All rights reserved.</div>
<div id="validation">
<a href="http://validator.w3.org/check/referer">
<img src="http://www.w3.org/Icons/valid-xhtml10" alt="Valid XHTML 1.0!" height="31" width="88" />
</a>
<a href="http://jigsaw.w3.org/css-validator/">
<img src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!" height="31" width="88" />
</a>
</div>
</div>
</body>
</html>
distrib
>
Fedora
>
14
>
x86_64
>
media
>
updates
>
by-pkgid
>
71d40963b505df4524269198e237b3e3
>
files
>
984
