Tutorial CGILua 3.2

Curso de Lua 3.2
CGILua 3.2
Índice
Introdução......................................................................................................5
O que é CGILua?..........................................................................................5
Execução ....................................................................................................5
Scripts Lua e Templates HTML.........................................................................6
Scripts Lua ..................................................................................................6
Templates HTML .........................................................................................6
Templates HTML: Marcadores Especiais ...........................................................7
Campos de Expressão ..................................................................................7
Campos de Código .......................................................................................7
Diretiva de Laço ..........................................................................................7
Diretiva Condicional ....................................................................................8
Exercícios de Fixação I ....................................................................................9
Formulários .................................................................................................. 10
Exercícios de Fixação II ................................................................................. 11
Envio de Arquivos......................................................................................... 12
Introdução ................................................................................................ 12
Destino dos Arquivos ................................................................................. 12
Log de Envios............................................................................................ 13
Exercícios de Fixação III ................................................................................ 14
Construindo URLs ......................................................................................... 15
cgilua.mkurl( script, table ) ........................................................................ 15
cgilua.relativeurl( script ) ........................................................................... 15
cgilua.encodecgi( )..................................................................................... 15
cgilua.encodetable( table ).......................................................................... 16
Exercícios de Fixação IV ................................................................................ 17
Incluindo Arquivos........................................................................................ 18
cgilua.includehtml ( filename) .................................................................... 18
cgilua.preprocess( filename) ....................................................................... 18
cgilua.splitpath( path ) ............................................................................... 18
cgilua.escape( str )..................................................................................... 18
cgilua.unescape( str )................................................................................. 19
Cabeçalhos HTTP.......................................................................................... 20
2
cgilua.redirect( url, args ) ........................................................................... 20
cgilua.htmlheader( ) .................................................................................. 20
cgilua.httpheader( header ) ........................................................................ 20
Carregando Bibliotecas .................................................................................. 21
cgilua.loadlibrary(basename, initfunc) ........................................................ 21
cgilua.dofile( file ) ..................................................................................... 21
cgilua.tostring( varname ) .......................................................................... 21
cgilua.persistvar( varname ) ....................................................................... 22
cgilua.savestate( var1, var2, ... ) ................................................................. 22
Variáveis Pré-Definidas.................................................................................. 24
cgi ............................................................................................................ 24
cgilua.version ............................................................................................ 24
cgilua.script_pdir ....................................................................................... 24
cgilua.script_vdir ....................................................................................... 24
cgilua.script_path ...................................................................................... 24
cgilua.cgilua_url ........................................................................................ 25
Biblioteca: Sistema ........................................................................................ 26
mkdir( path )............................................................................................. 26
chdir( path ).............................................................................................. 26
getcwd( ) .................................................................................................. 26
cp( source, target ) .................................................................................... 26
filetype( file ) ............................................................................................ 26
filetime( fmt, file ) ..................................................................................... 27
date2sec( date, fmt ) .................................................................................. 27
sec2date( nsec, fmt ).................................................................................. 27
lock( fhandle, mode )................................................................................. 28
sleep( msec )............................................................................................. 28
Biblioteca: DBLua ......................................................................................... 29
DBOpen( dbdescr ) .................................................................................... 29
DBExec( sqlcommand ).............................................................................. 29
DBRow( ).................................................................................................. 30
DBClose( ) ................................................................................................ 30
Exercícios de Fixação V ................................................................................. 31
Biblioteca: Crypt ........................................................................................... 32
crypt( str, key ) ......................................................................................... 32
decrypt( cryptbuf, key ) ............................................................................. 32
md5( str ).................................................................................................. 32
exor( buff1, buff2 ) .................................................................................... 32
encode( strbuff )........................................................................................ 33
decode( codedbuff ) ................................................................................... 33
3
Biblioteca: Cookies........................................................................................ 34
getcookie( name ) ...................................................................................... 34
setcookie( name, value, expires, path, domain, secure ) ............................... 34
setcookiehtml( name, value, expires, path, domain, secure ) ........................ 35
deletecookie( name ).................................................................................. 35
Biblioteca: Loadlib ........................................................................................ 36
loadlib( libname, dir ) ................................................................................ 36
unloadlib( libhandle ) ................................................................................ 36
callfromlib( libhandle, funcname ) .............................................................. 36
Biblioteca: Mail ............................................................................................. 38
mail{ to=tolist, from=frm, subject=sbj, message=msg, cc=cclist,
bcc=bcclist } ............................................................................................ 38
Respostas dos Exercícios................................................................................ 39
Bibliografia................................................................................................... 41
4
Introdução
O que é CGILua?
•
•
•
•
•
•
•
•
Ferramenta para geração de páginas HTML dinâmicas via servidor HTTP.
Programa CGI que roda no servidor.
Utiliza um interpretador Lua para codificar os comandos que gerarão as páginas HTML.
É uma linguagem interpretada – não é necessária compilação.
Recebe arquivos a serem interpretados, os processa oferecendo acesso a banco de dados, E/S,
criptografia etc, e gera HTML de saída.
Manipula dados de formulário HTML.
Pode-se utilizar tanto código embutido em HTML (templates) quanto módulos Lua separados
(scripts).
Não possui estado (valores de variáveis não são guardados no servidor).
Execução
Para executar um script CGILua, deve-se utilizar a URL no formato: http:://<webserver>/<path-cgilua>/<path-script>
, onde:
path-cgilua: caminho virtual relativo ao servidor web onde o CGILua está instalado.
path-script: caminho físico (relativo ao diretório-base do diretório virtual) do script a ser
executado. Ex: http:://www.abc.com/cgi/cgilua.exe/scripts/teste.lua
5
Scripts Lua e Templates HTML
Scripts Lua
• Arquivos com extensão .lua totalmente escritos em Lua.
• Comunica-se com o servidor utilizando-se do dispositivo de saída padrão – write e print.
• No início do script, deve ser gerado um cabeçalho HTTP informando o tipo do documento
(Content-type).
EXEMPLO:
cgilua.htmlheader()
write('<html>')
if (cgi.language == 'english‘) then
greeting = 'Hello World!‘
elseif (cgi.language == 'portuguese‘) then
greeting = 'Olá Mundo!‘
else
greeting = '[unknown language]‘
end
write('<head><title>'..greeting..'</title></head>')
write('<body>')
write('<b>'..greeting..'</b>')
write('</body>')
write('</html>')
Templates HTML
• Arquivos com extensão .html ou .htm, escritos em HTML mas com código Lua e marcações
•
•
especiais.
CGILua processa o código Lua e marcações especiais para gerar código HTML dinâmico.
Código estático: HTML; Código dinâmico: Lua/marcações.
6
Templates HTML: Marcadores
Especiais
Campos de Expressão
Insere o resultado da expressão Lua no documento HTML.
FORMATO:
$| expressao-lua |$
ARGUMENTOS:
expressao-lua: qualquer expressão em Lua que retorne um valor, como por exemplo uma variável
ou o retorno de uma função. Caso retorne nil, nada é inserido.
EXEMPLO:
Bom dia, <b>$|primeiroNome|$</b>!
(mostra em bold o conteúdo da variável primeiroNome)
<a href=“$|cgilua.mkurl(“ajuda.html”, cgi)|$>Ajuda</a>
(mostra dentro do href o retorno da função cgilua.mkurl, compondo o link
para ajuda.html)
Campos de Código
Executa o código Lua entre os delimitadores.
FORMATO:
<!--$$ codigo-lua $$-->
ARGUMENTOS:
codigo-lua: qualquer código lua
EXEMPLO:
<!--$$
function executaModulo (modulo)
return dofile(modulo)
end
executaModulo(‘teste.lua’)
$$-->
Diretiva de Laço
Repete determinado trecho de código enquanto uma expressão testada seja verdadeira.
FORMATO:
<!--$$ LOOP start='cod_ini', test='cond_exec', action='cod_ciclo' $$-->
[HTML code]
<!--$$ ENDLOOP $$-->
7
ARGUMENTOS:
start: condição inicial para o laço.
test: expressão testada. Ao retornar nil (falso), pára o laço.
action: ação executada em cada ciclo do laço.
EXEMPLO:
Table of numbers 1 to 9:<br>
<table border=1>
<tr>
<!--$$ LOOP start = 'i=1', test = 'i<10', action = ‘i = i + 1' $$-->
<td>$| i |$</td>
<!--$$ ENDLOOP $$-->
</tr>
</table>
Diretiva Condicional
Testa uma expressão e Inclui determinado HTML caso a expressão seja verdadeira ou outro HTML
caso a expressão seja falsa.
FORMATO:
<!--$$ IF test='cond_exec' $$-->
[HTML code (true condition)]
(<!--$$ ELSE $$-->
[HTML code (false condition)])
<!--$$ ENDIF $$-->
ARGUMENTOS:
test: expressão testada. Se retornar não-nil (verdadeiro), inclui o primeiro trecho de código HTML.
Se retornar nil (falso), inclui o segundo trecho de código HTML, caso especificado.
EXEMPLO:
User name:
<!--$$ IF test='cgi.editmode' $$-->
<input type="text" name="user" value="$|cgi.user|$">
<!--$$ ELSE $$-->
$|cgi.user|$
<!--$$ ENDIF $$-->
</form>
8
Exercícios de Fixação I
1) Qual o correspondente script Lua correspondente ao template HTML abaixo?
<html>
<body>
<head><title>Página de Teste</title></head>
<body>
<b>Olá, mundo!</b>
</body>
</html>
2) Qual o correspondente template HTML correspondente ao script Lua abaixo?
cgilua.htmlheader()
write('<html>')
write('<head><title>Resultado</title></head>')
write('<body>')
if (cgi.resultado == "ok") then
write('<b>Funcionou!</b>')
else
write('<b>Não funcionou!</b>')
end
write('</body>')
write('</html>')
3) Em um template HTML, quais os usos corretos da função escrevePrimeiroNome definida
abaixo para imprimir o nome “João”:
function escrevePrimeiroNome()
write(“João”)
end
a) escrevePrimeiroNome()
b) $| escrevePrimeiroNome() |$
c) <!--$$ escrevePrimeiroNome $$-->
d) <!--$$ escrevePrimeiroNome() $$-->
e) $| write(escrevePrimeiroNome) |$
4) Em um template HTML, quais os usos corretos da função retornaPrimeiroNome definida
abaixo para imprimir o nome “João”:
function escrevePrimeiroNome()
return “João”
end
a) escrevePrimeiroNome()
b) $| escrevePrimeiroNome() |$
c) <!--$$ escrevePrimeiroNome $$-->
d) <!--$$ write(escrevePrimeiroNome()) $$-->
e) $| escrevePrimeiroNome |$
9
Formulários
• CGILua processa dados vindos de formulários HTML (FORM), automaticamente decodificando
os dados recebidos em uma tabela cgi.
• CGILua trata da mesma forma e transparentemente o método de envio de dados do FORM
•
•
(POST ou GET).
O script que será executado para processar os dados (campo action do FORM) pode ser tanto
um template html quanto um script lua. Recomenda-se o uso da função cgilua.mkurl para
gerar a URL deste script.
Os campos de dados recebidos do FORM são colocados como campos da tabela cgi, com o
nome original.
Ex: (formulário)
<form method="POST" action=“$|cgilua.mkurl( "processadados.html" )|$">
<input type="text" name="primeironome">
<input type="text" name="endereco">
<input type="submit" value="ok">
</form>
Ex: (arquivo que recebe os dados – processadados.html)
<html>
<head><title>Dados Recebidos</title></head>
<body>
<p>O formulário foi enviado com os seguintes dados:
<p>Nome: $|cgi.primeironome|$
<p>Endereço: $|cgi.endereco|$
</body> </html>
10
Exercícios de Fixação II
5) Implemente um formulário em em um arquivo html (form.html) e um template HTML
(result.html) que imrpimirá os valores (ambos estão em um mesmo diretório). O formulário
terá os campos “nome”, “telefone” e “endereco”.
11
Envio de Arquivos
Introdução
• CGILua permite o envio de arquivos através do HTML (<input type=“file”>).
• O arquivo é enviado do navegador cliente a um diretório do servidor.
• Os seguintes atributos do FORM devem ser especificados: method=“POST” e
enctype=“multipart/form-data”.
Destino dos Arquivos
Para definir o destino dos arquivos enviados, deve-se especificar uma tabela de regras de envio
(no mesmo contexto que o HTML de envio)
rulestable = {
{ pattern="[pattern1]", target="[target_filename1]"},
{ pattern="[pattern2]", func=[func2]},
...
; root_dir = “root_dir"
}
, onde:
pattern: expressão regular que deve casar com o arquivo sendo enviado
Deve-se utilizar ou a target ou a func:
target: expressão regular que define o nome de destino do arquivo. Pode-se usar capturas feitas
com parêntesis no pattern através de %1, %2, %3 etc.
func: nome da função que recebe o nome do arquivo de origemoriginal como parâmetro e deve
retornar o nome de destino do arquivo
root_dir: diretório destino dos arquivos enviados
Ex:
rulestable = {
{ pattern="(.*)%.doc", target="upload%.%1%.doc"},
{ pattern="(.*)%.bmp", target="upload%.%1%.bmp"},
; root_dir = "c:/temp/"
}
Para definir as regras globais default, deve-se definir esta tabela com o nome cgilua.uploadrules
Para definir uma regra específica, deve-se colocar um campo do tipo INPUT HIDDEN no
formulário HTML imediatamente antes do INPUT FILE, com o campo VALUE contendo o nome da
variável global contendo a tabela de regras, e com o campo NAME igual ao campo NAME do
INPUT FILE, mas com um prefixo “rules_”
Ex:
<input type="hidden" name="rules_upload_example“
value=“rulestable”>
<input type="file" name="upload_example">
12
Log de Envios
•
•
cgilua.upload_transferlog é uma variável com um log de todas os envios de arquivos
efetuados por um script. Contém o nome do arquivo original, o nome com o qual foi salvo no
servidor e o diretório de destino.
cgilua.uploadlog(filename) grava um relatório no arquivo filename o conteúdo da variável
cgilua.upload_transferlog, concatenando ao final do arquivo caso ele exista.
13
Exercícios de Fixação III
6) Implemente um script Lua que envie arquivos ao servidor no diretório C:\files, trocando
suas letras para minúsculas. O formulário deverá ser direcionado ao arquivo sendfile.htm.
14
Construindo URLs
cgilua.mkurl( script, table )
Gera uma URL para ser usada como um link HTML para o script CGILua, com a opção de passar
uma tabela de dados.
PARÂMETROS
script: String com o caminho virtual para o script.
Table (opcional): tabela com os parâmetros a serem passados pela URL para o script.
RETORNO
Retorna uma string com a URL pronta para uso em um documento HTML. Um erro Lua é gerado
caso o script não seja uma string, a tabela não seja uma table ou algum dos campos da tabela não
seja uma string.
Example
<a href="$|cgilua.mkurl("/~tecgraf/script.lua")|$">
<a href="$|cgilua.mkurl(“main/script.lua",{ re=1.2, im=0.4 })|$">
produz o seguinte código HTML (considerando que o CGILua está
instalado no diretório virtual do servidor /cgilua):
<a href="/cgilua/cgilua.exe/~tecgraf/script.lua">
<a href="/cgilua/cgilua.exe/main/script.lua?im=0%2E4&re=1%2E2">
cgilua.relativeurl( script )
Retorna a URL que deve ser usada para se acessar um script dado por um caminho relativo ao
diretório do script que está sendo executado. Esta função permite independência da localização
das páginas do CGILua permitindo que páginas se refiram umas às outras usando caminhos
relativos, sem a necessidade de codificar as URLs do próprio CGILua e do diretório que contém as
páginas.
PARÂMETROS
script: String com o caminho relativo do script a que se quer referir.
RETORNO
Retorna uma string com a URL pronta para uso em um documento HTML.
Exemplo
<a href=$|cgilua.relativeurl('script.html')|$>script</a>
ao ser processado, produz:
<a href=/scripts/cgilua-3.2/cgilua.exescript.html>script</a>
cgilua.encodecgi( )
Codifica a tabela cgi na forma de uma string de parâmetros passados em uma URL.
15
RETORNO
Retorna uma string de parâmetros codificados em formato de URL. Se cgi não for uma tabela ou
algum índice ou valor da mesma não for uma string ou número, gera um erro Lua.
Exemplo
cgi = {}
cgi.software = 'CGILua 2.0'
cgi.club = 'Mengão'
<a href=script.lua?$| cgilua.encodecgi() |$>
produz o seguinte código HTML:
<a href=script?software=CGILua+2%2E0&club=Meng%E3o>
cgilua.encodetable( table )
Codifica uma tabela dada na forma de uma string de parâmetros passados em uma URL.
PARÂMETROS
table: uma tabela com os dados a serem codificados.
RETORNO
Retorna uma string de parâmetros codificados em formato de URL. Se table não for uma tabela ou
algum índice ou valor da mesma não for uma string ou número, gera um erro Lua.
Exemplo
<a href="script.lua?$|cgilua.encodetable{prod='CGILua 3.2'}|$">
produz o seguinte código HTML:
<a href="/cgilua/cgilua.exe/script.lua?prod=CGILua+3%2E2">
16
Exercícios de Fixação IV
7) Implemente um link (comand <A HREF) para um template html, que passe a outro
template html de nome teste.html no mesmo diretório, todos os parâmetros de formulário
recebidos.
17
Incluindo Arquivos
cgilua.includehtml ( filename)
Insere um pedaço de HTML no documento atual. O arquivo é pré-processado e expandido no
ponto em que a função é chamada.
PARÂMETROS
Filename: string contendo o caminho do arquivo a ser processado.
RETORNO
Não retorna valor. Se houver algum problema na inclusão do arquivo, um erro Lua é gerado.
Obs.: Para inserir documentos HTML completos gerando um cabeçalho HTTP, utilize a função
cgilua.preprocess.
cgilua.preprocess( filename)
Pré-processa o template HTML, gerando um documento HTML com o cabeçalho HTTP (cotnenttype) e o envia diretamente para o dispositivo de saída no momento da chamada da função. Já
que o cabeçalho HTTP é gerado, somente faz sentido chamar esta função em scripts Lua, pois
tamplates HTML completos geram este cabeçalho automaticamente. Em templates HTML, utilize a
função cgilua.includehtml.
PARÂMETROS
Filename: String com o caminho do template HTML a ser processado.
RETORNO
Não há retorno. Se houver algum problema em abrir o arquivo, um erro é gerado.
EXEMPLO
if cgi.newuser then
cgilua.preprocess( "newuser.html" )
else
cgilua.preprocess( "main.html" )
end
cgilua.splitpath( path )
Separa o diretório do nome de arquivo em um caminho, e retorna os dois.
PARÂMETROS
Path: o caminho a ser dividido.
RETORNO
Retorna o diretório como primeiro argumento e o nome do arquivo como o segundo.
cgilua.escape( str )
18
Codifica a string de entrada, substituindo todas as ocorrências de caracteres for a da faixa a-z, AZ, e 0-9 com uma string no formato %XX, onde XX é a representação hexadecimal do número do
código do caracter.
PARÂMETROS
Str: a string a ser codificada.
RETORNO
A string codificada resultante.
cgilua.unescape( str )
Decodifica a string de entrada, substituindo cada ocorrência da substring %XX (onde XX é um
número hexadecimal) com o caracter equivalente do código decimal XX.
PARÂMETROS
Str: a string a ser decodificada.
RETURN
A string decodificada resultante.
19
Cabeçalhos HTTP
cgilua.redirect( url, args )
Gera um cabeçalho HTTP redirecionando o browser para outra URL. Corresponde ao cabeçalho
Location: HTTP.
PARÂMETROS
url: o nome do arquivo ou a URL completa a ser carregada.
args (opcional): tabela Lua com parâmetros a serem passados na URL, devidamente codificados.
EXEMPLO
if cgi.name then
cgilua.redirect( "newuser.html", { newuser = cgi.name } )
else
cgilua.redirect( "http://www.home.com" )
end
Obs.: Esta função somente se aplica a scripts Lua. Qualquer outra saída após esse comando será
ignorada, embora o script rode até o fim. Saídas escritas antes desta função só fazem sentido se
forem outros cabeçalhos HTTP.
cgilua.htmlheader( )
Escreve na saída o cabeçalho HTTP indicador de página HTML (Content-type: text/html)
EXEMPLO
O seguinte código em um .lua produz uma página válida:
cgilua.htmlheader()
write( '<h1>Olá!</h1>' )
Obs.: Esta função somente se aplica Scripts Lua.
cgilua.httpheader( header )
Adiciona um cabeçalho HTTP à página sendo criada dinamicamente.
PARÂMETROS
header: o texto do cabeçalho HTTP a ser inserido.
EXEMPLO
cgilua.httpheader( 'Expires: Tue, 20 Aug 1996 14:25:27 GMT\n' )
cgilua.httpheader( 'Content-type: text/plain\n\n' )
write( ‘Página de Teste' )
Obs.: Aplica-se somente a scripts Lua.
20
Carregando Bibliotecas
cgilua.loadlibrary(basename, initfunc)
Carrega uma biblioteca dinâmica. Procura a bibilioteca no diretório de configuração do cgilua
(normalmente cgilua.conf) e então no caminho do sistema para bilbliotecas
PARÂMETROS
basename: o nome-base do arquivo a ser carregado. Em UNIX, adiciona automaticamente o
prefixo lib e o sufixo .so. Em Windows, adiciona o sufixo .dll.
initfunc: a função exportada pela biblioteca a ser chamada após a carga da biblioteca.
Normalmente, esta é uma função que registra outras funções C da biblioteca no ambiente Lua.
EXEMPLO
O seguinte código carrega a biblioteca library libcrypt.so (ou crypt.dll no
Windows), e executa a função exportada cryptlib_open:
cgilua.loadlibrary( 'crypt', 'cryptlib_open' )
Obs.: Se a biblioteca não puder ser carregada, a execução do script é abortada mostrando uma
mensagem de erro.
cgilua.dofile( file )
Executes um arquivo Lua no ambirente Lua atual. A diferença para o comando dofile de Lua é
que os arquivos são pegos do diretório de configuração do cgilua, normalmente cgilua.conf/.
PARÂMETROS
file: o arquivo Lua a ser executado.
EXEMPLO
cgilua.dofile( 'lib.lua' )
Obs.: Se a execução falhar ou o arquivo não puder ser encontrado, a execução é abortada.
cgilua.tostring( varname )
Constrói uma representação string da variável passada. Strings são corretamente codificadas e
tabelas são convertidas para sua representação em string, com os construtuores de tabelas { e }.
PARÂMETROS
varname: o nome da variável Lua.
RETORNO
A representação string da variável passada.
EXEMPLO
item = { name="X", value=123, properties={ 2, 4, 7 } }
write( cgilua.tostring( item ) )
21
produz a seguinte saída:
{ ["value"] = 123, ["name"] = "X", ["properties"] = { [1] = 2, [2] = 4, [3] = 7, }, }
Obs.: Função útil para depurar scripts. Não funciona para variáveis do tipo "function" ou
"userdata". Tabelas Lua aninhadas são aceitas, exceto se tiverem referências em laço.
cgilua.persistvar( varname )
Produz uma string de forma que a execução da string no ambiente Lua (com dostring) recupera o
valor da variável.
PARÂMETROS
varname: o nome da variável a ser persistida em uma string.
RETORNO
A string a ser usada para se recuperar a variável.
EXEMPLO
list = { "a", "b", "c" }
keeplist = cgilua.persistvar( list )
list = nil
dostring( keeplist )
foreach( list, function (i,v) write( v ) end )
produz o seguinte resultado:
abc
cgilua.savestate( var1, var2, ... )
Salva o estado de variáveis string, number ou table para passá-las ao próximo script a ser
executado com a função cgilua.mkurl.
PARÂMETROS
varx: Nome das variáveis cujo estado deve ser salvo.
Exemplo
<html><body>
<!--$$
x = { "i", "ii", "iii" }
name = "roman"
cgilua.savestate( "x", "name" )
$$-->
<a href="$|cgilua.mkurl( 'next.lua' )|$">Link para o próximo
script</a>
</body></html>
No script chamado next.lua, é correto escrever:
cgilua.htmlheader()
i=1;
22
while x[i] do
write( name, ":", x[i] )
i=i+1
end
Obs.:
Esta função aceita um número variável de argumentos. As variáveis são formatadas para montar
uma querystring para serem passadas através da URL na próxima chamada do cgilua.mkurl.
Pode-se mudar este comportamento para passá-las através de um arquivo temporário no servidor,
através da variável cgilua.STATEMETHOD, localizada em cgilua.conf/state.lua.
23
Variáveis Pré-Definidas
cgi
Contém os dados, já decodificados, enviados para o script, independentemente do método. Os
dados podem vir de um submit a um formulário HTML ou diretamente passados pela URL.
EXEMPLO
<form method="POST" action="$|cgilua.mkurl( 'a.lua' )|$">
Nome: <input type="text" name="name">
Email: <input type="text" name="email">
<input type="submit">
</form>
Ao dar um submit no formulário, o a tabela cgi no script a.lua terá os campos name e email:
write( "Your name is " .. cgi.name .. ", and your e-mail " .. cgi.email )
Uma outra forma de enviar os mesmos campos seria através de um link:
<a href="$|cgilua.mkurl('b.lua',{nome="John",email="[email protected]" }) |$">
cgilua.version
Versão do CGILua usada.
cgilua.script_pdir
Caminho físico do script sendo executado pelo CGILua.
EXEMPLO
Se a URL:
http://www.cgilua.com/cgi-bin/cgilua/~user/script.lua
executa o script localizado em
/home/user/public_html/script.lua
esta variável possui o valor
/home/user/public_html/
cgilua.script_vdir
Caminho virtual do script sendo executado pelo CGILua.
EXEMPLO
Usando a URL http://www.cgilua.com/cgi-bin/cgilua/~user/script.lua, esta
variável possuirá o valor "/~user/".
cgilua.script_path
Caminho virtual do script sendo executado pelo CGILua.
24
EXEMPLO
Se a URL:
http://www.cgilua.com/cgi-bin/cgilua/~user/script.lua
executa o script localizado em
/home/user/public_html/script.lua
esta variável contém o valor
/home/user/public_html/script.lua
cgilua.cgilua_url
Parte da URL usada para referenciar o CGILua.
EXEMPLO
Usando a URL
http://www.cgilua.com/cgi-bin/cgilua/~user/script.lua
esta variável contém o valor:
/cgi-bin/cgilua
25
Biblioteca: Sistema
Oferece algumas funções úteis do sistema operacional, como datas e operações de E/S
mkdir( path )
Cria um diretório no sistema de arquivos local.
PARÂMETROS
path: caminho do diretório a ser criado (ou simplesmente um nome se deve-se criar abaixo do
diretório atual)
RETORNO
Retorna nil em caso de falha ou 1 em sucesso.
chdir( path )
Troca o diretório de trabalho atual para o diretório especificado.
PARÂMETROS
path: o caminho do novo diretório de trabalho.
RETORNO
Não há retorno. Em caso de falha, o script é abortado e é mostrada uma mensagem de erro.
getcwd( )
Retorna o diretório de trabalho atual.
RETORNO
Uma string contendo o caminho completo do diretório de trabalho atual.
cp( source, target )
Copia o arquivo do caminho de origem para o caminho de destino.
RETORNO
Retorna nil em caso de erro; nesse caso o segundo retorno é uma string descrevendo o erro.
EXEMPLO
cp( "c:/test/ball.gif", "c:/www/ball.gif" )
filetype( file )
Retorna o tipo do arquivo.
PARÂMETROS
file: o arquivo de que quer saber o tipo.
26
RETORNO
Uma da strings: "file", "directory" ou "other" de acordo com otipo do arquivo, ou nil se o tipo do
arquivo não pode ser retornado.
filetime( fmt, file )
Retorna a hora da última modificação feita no arquivo.
PARÂMETROS
fmt: o formato da string de saída, similar ao da função em C strftime.
file (opcional): o arquivo de que se quer saber a hora da última modificação. Caso não seja
especificado, é utilizado o caminho do script atual.
RETORNO
Uma string com a hora da última modificação, formatada conforme especificado.
EXEMPLO
$|filetime("%d/%m/%Y")|$
produz a seguinte saída:
27/04/1999
date2sec( date, fmt )
Converte uma data para o número correspondente de segundos desde primeiro de janeiro de
1970.
PARÂMETROS
date: uma string contendo uma data.
fmt: o formato da data a ser lida, de acordo com um padrão.
RETORNO
O número correspondente de segundos desde primeiro de janeiro de 1970.
EXEMPLO
$|date2sec("5/02/1997","%d/%m/%Y")|$
produz a seguinte saída:
855111600
sec2date( nsec, fmt )
Converte um número como o número de segundos desde primeiro de janeiro de 1970 para uma
data.
PARÂMETROS
nsec: número de segundos.
fmt: o formato da saída.
RETORNO:
A data correspondente ao número de segundos desde primeiro de janeiro de 1970 correspondente
ao parâmetro dado.
27
EXEMPLO
$|sec2date( date2sec("5/02/1997","%d/%m/%Y"),"%d/%m/%Y")|$
produces the following output:
05/02/1997
lock( fhandle, mode )
Tranca ou destranca o acesso a um arquivo. Na realidade, o acesso ao arquivo não é impedido, na
verdade somente permite que seja feito o controle guardando o estado.
PARÂMETRO
fhandle: handle de um arquivo aberto. Após uma chamada bem sucedida a writeto, o handle é
dado pela variável de Lua _OUTPUT.
Mode: o tipo de operação desejada. Utilize o caracter l para trancar um arquivo e u para
destrancar.
RETORNO
Retorna nil em caso de falha e 1 em caso de sucesso.
EXEMPLO
writeto( "data.txt")
while not lock( _OUTPUT, "l") do sleep (50) end
write ( "ok" )
lock( _OUTPUT, "u")
writeto ()
--espera até que nenhum outro processo está com o arquivo trancado para
trancar para si
sleep( msec )
Faz com que o processo ou thread correntes fiquem suspensos por msec milissegundos.
PARÂMETROS
msec: o número de milissegundos para ficar suspenso.
28
Biblioteca: DBLua
Oferece acesso a bancos de dados.
DBOpen( dbdescr )
Abre uma conexão com um banco de dados.
PARÂMETROS
dbdescr: string de conexão com um banco de dados.
RETORNO
Retorna nil se a conexão foi bem-sucedida ou uma string descrevendo o erro.
EXEMPLO (ODBC)
errormsg = DBOpen("DSN=agenda;UID=cgilua;PASSWD=lua;")
if errormsg then
cgilua.redirect( 'dberror.html', { msg=errormsg })
end
EXEMPLO (Mini-SQL)
DBOpen('HOST=davinci;DATABASE=agenda;')
Obs.: Para portabilidade, as palavras DATABASE e DSN são equivalentes e HOST é ignorado no
uso com ODBC. No entanto, uma string de conexão "HOST=davinci;DATABASE=agenda;" seria
válida em ambos ODBC e Mini-SQL se "agenda" é um DSN de ODBC.
DBExec( sqlcommand )
Executa um comando SQL na conexão com banco de dados atualmente aberta.
PARÂMETROS
sqlcommand: uma string com o comando SQL a ser executado.
EXEMPLO
DBExec( "create table tst (nome char(50), cpf char(15))" )
DBExec( "insert into tst values ('Luiza','001.234.567-89')" )
DBExec( "insert into tst values ('Fabiana','009.876.543-21')" )
DBExec( "delete from tst where nome = 'Luiza'")
DBExec( "update tst set cpf = '009.999.999-99' where name ='Fabiana'")
Para evitar confusão com os delimitadores de string de Lua, (" ou ') e delimitadores de string de
SQL ('), a função format de Lua pode ser usada.
Ex:
sql = format( "insert into tabela_teste values ('%s','%s')", cgi.name, cgi.cpf )
DBExec( sql )
Obs.: Em caso de erro no comando SQL, um erro de execução é mostrado, abortando a execução
do script. Para evitar este tipo de comportamento, execute comandos para testar situações de erro
(ex. teste se um registro existe com um comando SELECT antes de tentar apagá-lo).
29
DBRow( )
Retorna a próxima linha da tabela de resultados produzida pela último comando SQL executado
(com DBExec).
RETORNO
Uma tabela Lua contendo os dados da linha, com todas as coludas da tabela de resultados
indexadas na mesma ordem que sua posição no resultado (índices [1], [2], ... ) e também
indexadas pelol nome da coluna (índices [“nome_coluna1"], ["nome_coluna2"], ... ). Quando
chega no final da tabela, retorna nil.
Exemplo
Suponha que no banco de dados há a tabela “Empregados”, com o seguinte
formato: id (int), nome (char 100) e telefone (char 20)
Dados:
1 Maria 222-3333
2 Marcelo (NULL)
3 Pedro 555-3333
4 William 666-3333
Para retornar os dados da tabela:
DBOpen("DATABASE=company;")
DBExec("SELECT telephone, name FROM employees WHERE name LIKE
= 'M%'" )
row = DBRow()
while row do
write( "Name: ".. row.name .. "<br>" ) -- poderia fazer também
com "row[2]“
row = DBRow()
end
DBClose()
O resultado será::
Nome: Maria
Nome: Marcelo
Obs.: Valores nulos são traduzidos para valores nil em Lua.
DBClose( )
Fecha a conexão ativa com o banco de dados, aberta com o DBOpen
Exemplo
DBOpen( "DATABASE=example;" )
DBExec( "create table t (nome char(50), cpf char(15))" )
DBClose()
30
Exercícios de Fixação V
8) Dada uma tabela “agenda” com os campos “nome”, “telefone” e “endereco” de um banco de
dados em DSN=“teste”, escreva o código em script Lua para imprimir todos os valores no
HTML.
9) Dada uma tabela “agenda” com os campos “nome”, “telefone” e “endereco” de um banco de
dados em DSN=“teste”, e uma tabela Lua “agenda”, indexada numericamente, sendo que
cada entrada desta tabela Lua contendo uma tabela com os mesmos campos “nome”,
“telefone” e “endereco”, escreva o código em script Lua para inserir na tabela do banco de
dados todos os valores da tabela Lua.
31
Biblioteca: Crypt
Oferece algumas funcionalidades de criptografia.
crypt( str, key )
Executa uma encriptação DES de 56-bit, usado o algorítimo "Fast DES".
PARÂMETROS
str: String a ser encriptada. Pode ser um buffer binário genérico.
key (opcional): Uma string a ser utilizada na geração da chave de encriptação. Somente os 8
primeiros caracteres são utilizados. Se não especificado, utiliza uma chave interna fixa.
RETORNO
Retorna uma string encriptada em um buffer de 8 bits.
decrypt( cryptbuf, key )
Decripta um buffer, usando o algorítimo de criptografia DES.
PARAMETROS
cryptbuf: Buffer contendo o dado encriptado.
RETORNO
O dato original, decriptado.
md5( str )
Aplica o algorítimo MD5 na string de entrada.
PARÂMETROS
str: string na qual o MD5 será aplicado.
RETORNO
String de saída da aplicação do MD5 na string de entrada.
exor( buff1, buff2 )
Executa um XOR binário nos buffers passados como parâmetros. Pode ser útil para construir
outras funções de criptografia em conjunto com a função md5.
PARÂMETROS
buff1: Primeiro operando para o XOR.
buff2: Segundo operando para o XOR.
RETORNO
O buffer binário resultante.
32
encode( strbuff )
Codifica buffers de 8 bit em uma string ASCII de 7 bits, conforme especificado na RFC 822.
PARÂMETROS
strbuff: o buffer binário a ser codificada.
RETORNO
A string resultante codificada.
Exemplo
encbuff = encode( crypt( "123456789" )
write( encbuff )
Produz a seguinte saída:
uwzJJwuywCnAWQD+ynT+eQc=
decode( codedbuff )
Restaura um buffer codificado pela função encode.
PARÂMETROS
codedbuff: o buffer a ser decodificado.
RETORNO
O buffer decodificado.
Exemplo
encbuff = encode( crypt( "123456789" )
buff = decode( encbuff )
write( decrypt( buff ) )
Produz a saída:
123456789
33
Biblioteca: Cookies
Um Cookie é um mecanismo para armazenar informação no cliente de uma conexão HTTP
getcookie( name )
Faz o servidor informar o valor de um cookie armazenado sob o nome name, que foi fornecido
pelo browser cliente quando o script foi solicitado.
PARÂMETROS
name: nome do cookie a ser retornado.
RETORNO
O valor do cookie requisitado.
Exemplo
naccess = getcookie( "COUNTACCESS" )
if not naccess then
msg = “Bem-vindo, novo usuário!"
else
msg = “Bem-vindo de volta! Você já visitou nosso site "..
naccess.." vezes."
end
write( msg )
setcookie( name, value, expires, path, domain,
secure )
Despacha um cabeçalho http necessário para criar um cookie no browser cliente.
PARÂMETROS
name: o nome do cookie.
value: o valor do cookie.
expires (opcional): data de quando o cookie irá expirar, no formado dd/mm/yyyy. Se este
parâmetro não for fornecido, o cookie será apagado quando a sessão atual terminar (ex. o quando
o browser for fechado).
path (opcional): o caminho virtual no servidor apontado pelo domínio (veja abaixo) dos scripts
que poderão ver o valor do cookie. O valor mais amplo que pode ser fornecido é “/”, o que
significa que qualquer script no servidor terá acesso ao valor do cookie. O valor default é o
mesmo caminho virtual do script que está criando o cookie.
domain (opcional): indica o domínio dos servidores que poderão acessar o valor do cookie.
Domínios parciais são aceitos (ex: ".puc-rio.br“). Se nenhum valor for fornecido, o default é
restringir a visibilidade do cookie ao servidor que o criou.
secure (opcional) : se este parâmetro for igual a "secure", o cookie só será transmitido via um
canal seguro (HTTPS).
Exemplo
naccess = getcookie( "COUNTACCESS" )
if not naccess then
naccess = 1
else
34
naccess = naccess + 1
end
setcookie( "COUNTACCESS", naccess )
cgilua.htmlheader()
Obs: Esta função deve ser parte do cabeçalho HTTP do script, ou seja, deve ser chamada antes do
corpo do HTML
Como esta função deve ser chamada na construção de cabeçalhos HTTP, só faz sentido usá-la em
scripts Lua.
setcookiehtml( name, value, expires, path,
domain, secure )
Idêntica ao setcookie, mas deve ser utilizada em um template HTML. Gera o cabeçalho HTML SetCookie.
PARÂMETROS
Idênticos ao setcookie.
RETORNO
O código HTML para gerar o cookie no cabeçalho http.
Exemplo
<html>
<head>
<!--$$
naccess = getcookie( "COUNTACCESS" )
if not naccess then
naccess = 1
else
naccess = naccess + 1
end
setcookiehtml( "COUNTACCESS", naccess )
$$-->
</head>
<body>
...
Obs: Esta função deve ser chamada entre as tags HTML <head> e </head>
deletecookie( name )
Remove o cookie com o nome determinado no browser-cliente.
PARÂMETROS
name: o nome do cookie a ser removido.
Exemplo
deletecookie( "COUNTACCESS" )
35
Biblioteca: Loadlib
Fornece suporte para a carga de bibliotecas dinâmicas.
loadlib( libname, dir )
Carrega a biblioteca dinâmica especificada.
PARÂMETROS
libname: o nome da biblioteca (sem extensão) ou o caminho completo para a biblioteca. Se for o
nome de uma biblioteca, dir pode ser utilizado para especificar o caminho.
dir (opcional): o diretório onde a biblioteca está localizada.
RETORNO
A função retorna um handle para ser usada pelas funções unloadlib e callfromlib. Se a biblioteca
não puder ser carregada, retorna nil como primeiro parâmetro e uma string descrevendo o erro
como segundo parâmetro.
Exemplo
-- procura por libposlua.so no unix ou poslua.dll in windows
loadlib( "/usr/lib/libX11.so" )
loadlib( "c:\\lua\\poslua.dll" )
-- usando o caminho de busca default do sistema
loadlib( "poslua" )
-- procura por /lua/libposlua.so em unix, /lua/poslib.dll em Windows
loadlib( "poslua", "/lua/" )
unloadlib( libhandle )
Descarrega a biblioteca especificada pelo handle.
PARÂMETROS
libhandle: handle da biblioteca a ser descarregada. Este handle é fornecido pela função loadlib.
Exemplo
testlib = loadlib( 'test' )
-- "test_open" registra a função f() em lua
callfromlib( testlib, 'test_open' )
x = f()
unloadlib( testlib )
-- desregistra f()
f = nil
Obs.: As funções Lua eventualmente registradas pela biblioteca não são automaticamente
removidas.
callfromlib( libhandle, funcname )
Chama a função determinada da biblioteca correspondente ao handle fornecido.
36
PARÂMETROS
libhandle: o handle da biblioteca.
funcname : o nome da função exportada pela biblioteca a ser chamada.
Exemplo
datelib, errmsg = loadlib( 'date' )
if datelib then
callfromlib( datelib, 'date_open' )
else
error( errmsg )
end
Obs.: Tipicamente, usa-se a callfromlib somente uma fez, após a loadlib, para abrir uma função de
"open" que irá registrar as funções da biblioteca no ambiente Lua.
37
Biblioteca: Mail
Permite o envio de mensagens de e-mail via um servidor SMTP.
mail{ to=tolist, from=frm, subject=sbj,
message=msg, cc=cclist, bcc=bcclist }
Envia uma mensagem de e-mail através de um servidor SMTP.
PARÂMETROS
to: lista de recipientes da mensagem, separados por vírgula
From: o e-mail do remetente.
subject (opcional): o assunto da mensagem.
message (opcional): o corpo da mensagem.
cc (opcional): lista de recipientes “cópia-carbono” da mensagem, separados por vírgula
bcc (opcional): lista de recipientes “cópia-carbono” invisíveis da mensagem, separados por vírgula
mailserver (em sistemas Windows). O IP do servidor SMTP a ser usado.
RETORNO
Retorna 1 se a mensagem foi enviada com sucesso ou nil em caso de falha, com uma string
descrevendo o erro como segundo argumento.
Exemplo
msg = “Corpo da mensagem de teste“
ok, errmsg = mail{ mailserver="127.0.0.1",
to=“[email protected]", from="[email protected]", subject=“Teste",
message=msg }
cgilua.htmlheader()
if not ok then
write( “A mensagem não pôde ser enviada. Motivo: ".. errmsg )
else
write( “Mensagem enviada com sucesso!" )
end
Obs.: Em sistemas Windows, o campo "mailserver“ é obrigatório. É possível definir esse valor
globalmente para todos os scripts definindo-se a variável global MAILSERVER. Em sistemas Unix,
verifique se o caminho para o executável do sendmail está correto no arquivo
cgilua.conf/mail.lua.
38
Respostas dos Exercícios
1) cgilua.htmlheader()
write('<html>')
write('<head><title>Página de Teste</title></head>')
write('<body>')
write('<b>Olá, mundo!</b>')
write('</body>')
write('</html>')
2) <html>
<head><title>Resultado</title></head>
<body>
<!--$$ IF test='cgi.resultado == "ok"' $$-->
<b>Funcionou!</b>
<!--$$ ELSE $$-->
<b>Não funcionou!</b>
<!--$$ ENDIF $$-->
</body>
</html>
3) letra d
4) letras b e d
5) form.html:
<html><body>
<form method="POST" action="result.htm">
Nome:<input type="text" name="nome"><br>
Telefone:<input type="text" name="telefone"><br>
Endereço:<input type="text" name="endereco"><br>
</form>
</body></html>
result.html:
<html><body>
Nome: $|cgi.nome|$<br>
Telefone: $|cgi.telefone|$<br>
Endereço:$|cgi.endereco|$<br>
</body></html>
6) cgilua.uploadrules = {
{ pattern="(.*)", func=strlower},
; root_dir = “C:\files”
}
cgilua.htmlheader()
write('<html>')
write('<body>')
write(‘<form action = "sendfile.html" ‘)
write(‘method="POST" enctype="multipart/form-data">')
39
write('Arquivo: <input type="file">')
write('<input type="submit" value="Ok">')
write('</form>')
write('</body>')
write('</html>')
7) <a href="$|cgilua.mkurl("teste.html", cgi)|$">
8) local error = DBOpen( "DSN=teste;" )
if (error) then
write( "Não foi possível abrir conectar com o banco de dados!<br>" )
else
DBExec( "select * from agenda" )
row = DBRow()
while row do
write( "name: ".. row.nome .. "<br>" )
write( "telefone: ".. row.telefone .. "<br>" )
write( "endereco: ".. row. endereco .. "<br>" )
write("<br>" )
row = DBRow()
end
DBClose()
end
9) local error = DBOpen( "DSN=teste;" )
if (error) then
write( “Não foi possível conectar com o banco de dados!<br>")
else
foreachi(agenda, function(i, v)
local sql = format(“insert into agenda values ('%s', '%s', '%s')",
v.nome, v.telefone, v.endereco)
DBExec(sql)
end)
DBClose()
end
40
Bibliografia
1) Lua and the Web (PowerPoint) - Roberto Ierusalimschy
2) CGILua 3.2 Manual at http://www.tecgraf.puc-rio.br/cgilua
41