mirror of
https://github.com/lunarmodules/luasocket.git
synced 2024-07-01 10:59:46 +02:00
266 lines
6.9 KiB
HTML
266 lines
6.9 KiB
HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
|
|
"http://www.w3.org/TR/html4/strict.dtd">
|
|
<html>
|
|
|
|
<head>
|
|
<title>LuaSocket: Network support for the Lua language</title>
|
|
<link rel="stylesheet" href="reference.css" type="text/css">
|
|
</head>
|
|
|
|
<body>
|
|
|
|
<!-- header +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<div class=header>
|
|
<hr>
|
|
<center>
|
|
<table summary="LuaSocket logo">
|
|
<tr><td align=center><a href="http://www.lua.org">
|
|
<img border=0 alt="LuaSocket" src="luasocket.png">
|
|
</a></td></tr>
|
|
<tr><td align=center valign=top>Network support for the Lua language
|
|
</td></tr>
|
|
</table>
|
|
<p class=bar>
|
|
<a href="home.html">home</a> ·
|
|
<a href="home.html#download">download</a> ·
|
|
<a href="introduction.html">introduction</a> ·
|
|
<a href="reference.html">reference</a>
|
|
</p>
|
|
</center>
|
|
<hr>
|
|
</div>
|
|
|
|
<!-- url ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<h2 id=url>URL</h2>
|
|
|
|
<p>
|
|
The module <tt>url.lua</tt> provides functions to parse, protect,
|
|
and build URLs, as well as functions to compose absolute URLs
|
|
from base and relative URLs, according to
|
|
<a href="http://www.cs.princeton.edu/~diego/rfc/rfc2396.txt">RFC
|
|
2396</a>.
|
|
</p>
|
|
|
|
<p>
|
|
An URL is defined by the following grammar:
|
|
</p>
|
|
|
|
<blockquote>
|
|
<tt>
|
|
<url> ::= [<scheme>:][//<authority>][/<path>][;<params>][?<query>][#<fragment>]<br>
|
|
<authority> ::= [<userinfo>@]<host>[:<port>]<br>
|
|
<userinfo> ::= <user>[:<password>]<br>
|
|
<path> ::= {<segment>/}<segment><br>
|
|
</tt>
|
|
</blockquote>
|
|
|
|
<!-- absolute +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<p class=name id=absolute>
|
|
socket.url.<b>absolute(</b>base, relative<b>)</b>
|
|
</p>
|
|
|
|
<p class=description>
|
|
Builds an absolute URL from a base URL and a relative URL.
|
|
</p>
|
|
|
|
<p class=parameters>
|
|
<tt>Base</tt> is a string with the base URL and <tt>relative</tt> is a
|
|
string with the relative URL.
|
|
</p>
|
|
|
|
<p class=return>
|
|
The function returns a string with the absolute URL.
|
|
</p>
|
|
|
|
<p class=note>
|
|
Note: The rules that
|
|
govern the composition are fairly complex, and are described in detail in
|
|
<a href="http://www.cs.princeton.edu/~diego/rfc/rfc2396.txt">RFC 2396</a>.
|
|
The example bellow should give an idea of what are the rules.
|
|
</p>
|
|
|
|
<pre class=example>
|
|
http://a/b/c/d;p?q
|
|
|
|
+
|
|
|
|
g:h = g:h
|
|
g = http://a/b/c/g
|
|
./g = http://a/b/c/g
|
|
g/ = http://a/b/c/g/
|
|
/g = http://a/g
|
|
//g = http://g
|
|
?y = http://a/b/c/?y
|
|
g?y = http://a/b/c/g?y
|
|
#s = http://a/b/c/d;p?q#s
|
|
g#s = http://a/b/c/g#s
|
|
g?y#s = http://a/b/c/g?y#s
|
|
;x = http://a/b/c/;x
|
|
g;x = http://a/b/c/g;x
|
|
g;x?y#s = http://a/b/c/g;x?y#s
|
|
. = http://a/b/c/
|
|
./ = http://a/b/c/
|
|
.. = http://a/b/
|
|
../ = http://a/b/
|
|
../g = http://a/b/g
|
|
../.. = http://a/
|
|
../../ = http://a/
|
|
../../g = http://a/g
|
|
</pre>
|
|
|
|
<!-- build ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<p class=name id=build>
|
|
socket.url.<b>build(</b>parsed_url<b>)</b>
|
|
</p>
|
|
|
|
<p class=description>
|
|
Rebuilds an URL from its parts.
|
|
</p>
|
|
|
|
<p class=parameters>
|
|
<tt>Parsed_url</tt> is a table with same components returned by
|
|
<a href="#parse"><tt>parse</tt></a>.
|
|
Lower level components, if specified,
|
|
take precedence over hight level components of the URL grammar.
|
|
</p>
|
|
|
|
<p class=return>
|
|
The function returns a string with the built URL.
|
|
</p>
|
|
|
|
<!-- build_path +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<p class=name id=build_path>
|
|
socket.url.<b>build_path(</b>segments, unsafe<b>)</b>
|
|
</p>
|
|
|
|
<p class=description>
|
|
Builds a <tt><path></tt> component from a list of
|
|
<tt><segment></tt> parts.
|
|
Before composition, any reserved characters found in a segment are escaped into
|
|
their protected form, so that the resulting path is a valid URL path
|
|
component.
|
|
</p>
|
|
|
|
<p class=parameters>
|
|
<tt>Segments</tt> is a list of strings with the <tt><segment></tt>
|
|
parts. If <tt>unsafe</tt> is anything but <tt>nil</tt>, reserved
|
|
characters are left untouched.
|
|
</p>
|
|
|
|
<p class=return>
|
|
The function returns a string with the
|
|
built <tt><path></tt> component.
|
|
</p>
|
|
|
|
<!-- parse ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<p class=name id=parse>
|
|
socket.url.<b>parse(</b>url, default<b>)</b>
|
|
</p>
|
|
|
|
<p class=description>
|
|
Parses an URL given as a string into a Lua table with its components.
|
|
</p>
|
|
|
|
<p class=parameters>
|
|
<tt>Url</tt> is the URL to be parsed. If the <tt>default</tt> table is
|
|
present, it is used to store the parsed fields. Only fields present in the
|
|
URL are overwritten. Therefore, this table can be used to pass default
|
|
values for each field.
|
|
</p>
|
|
|
|
<p class=return>
|
|
The function returns a table with all the URL components:
|
|
</p>
|
|
|
|
<blockquote><tt>
|
|
parsed_url = {<br>
|
|
url = <i>string</i>,<br>
|
|
scheme = <i>string</i>,<br>
|
|
authority = <i>string</i>,<br>
|
|
path = <i>string</i>,<br>
|
|
params = <i>string</i>,<br>
|
|
query = <i>string</i>,<br>
|
|
fragment = <i>string</i>,<br>
|
|
userinfo = <i>string</i>,<br>
|
|
host = <i>string</i>,<br>
|
|
port = <i>string</i>,<br>
|
|
user = <i>string</i>,<br>
|
|
password = <i>string</i><br>
|
|
}
|
|
</tt></blockquote>
|
|
|
|
<pre class=example>
|
|
parsed_url = socket.url.parse("http://www.puc-rio.br/~diego/index.lua?a=2#there")
|
|
-- parsed_url = {
|
|
-- scheme = "http",
|
|
-- authority = "www.puc-rio.br",
|
|
-- path = "/~diego/index.lua"
|
|
-- query = "a=2",
|
|
-- fragment = "there",
|
|
-- host = "www.puc-rio.br",
|
|
-- }
|
|
|
|
parsed_url = socket.url.parse("ftp://root:passwd@unsafe.org/pub/virus.exe;type=i")
|
|
-- parsed_url = {
|
|
-- scheme = "ftp",
|
|
-- authority = "root:passwd@unsafe.org",
|
|
-- path = "/pub/virus.exe",
|
|
-- params = "type=i",
|
|
-- userinfo = "root:passwd",
|
|
-- host = "unsafe.org",
|
|
-- user = "root",
|
|
-- password = "passwd",
|
|
-- }
|
|
</pre>
|
|
|
|
<!-- parse_path +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<p class=name id=parse_path>
|
|
socket.url.<b>parse_path(</b>path<b>)</b>
|
|
</p>
|
|
|
|
<p class=description>
|
|
Breaks a <tt><path></tt> URL component into all its
|
|
<tt><segment></tt> parts.
|
|
</p>
|
|
|
|
<p class=description>
|
|
<tt>Path</tt> is a string with the path to be parsed.
|
|
</p>
|
|
|
|
<p class=return>
|
|
Since some characters are reserved in URLs, they must be escaped
|
|
whenever present in a <tt><path></tt> component. Therefore, before
|
|
returning a list with all the parsed segments, the function unescapes all
|
|
of them.
|
|
</p>
|
|
|
|
<!-- footer +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
|
|
|
|
<div class=footer>
|
|
<hr>
|
|
<center>
|
|
<p class=bar>
|
|
<a href="home.html">home</a> ·
|
|
<a href="home.html#down">download</a> ·
|
|
<a href="introduction.html">introduction</a> ·
|
|
<a href="reference.html">reference</a>
|
|
</p>
|
|
<p>
|
|
<small>
|
|
Last modified by Diego Nehab on <br>
|
|
Sat Aug 9 01:00:41 PDT 2003
|
|
</small>
|
|
</p>
|
|
</center>
|
|
</div>
|
|
|
|
</body>
|
|
</html>
|