tutorial cgilua 3.2

Curso de Lua 3.2 CGILua 3.2

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

3

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

4

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

5

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:://<web-

server>/<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

6

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.

7

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:  ARGUMENTOS: codigo-lua: qualquer código lua

EXEMPLO: 

Diretiva de Laço Repete determinado trecho de código enquanto uma expressão testada seja verdadeira. FORMATO:  [HTML code]

8

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>  <td>$| i |$</td>  </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:  [HTML code (true condition)] ( [HTML code (false condition)])  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:  <input type="text" name="user" value="$|cgi.user|$">  $|cgi.user|$  </form>

9

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)  d)  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)  d)  e) $| escrevePrimeiroNome |$

10

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>

11

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”.

12

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">

13

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.

14

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.

15

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.

16

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">

17

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.

18

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 (cotnent-type) 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 )

19

Codifica a string de entrada, substituindo todas as ocorrências de caracteres for a da faixa a-z, A-Z, 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.

20

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.

21

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 ) )

22

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>  <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;

23

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.

24

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.

25

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

26

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.

27

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.

28

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.

29

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).

30

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()

31

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.

32

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.

33

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

34

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

35

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 Set-Cookie.

PARÂMETROS Idênticos ao setcookie.

RETORNO O código HTML para gerar o cookie no cabeçalho http.

Exemplo <html> <head>  </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" )

36

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.

37

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.

38

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.

39

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>  <b>Funcionou!</b>  <b>Não funcionou!</b>  </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">')

40

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

41

Bibliografia 1) Lua and the Web (PowerPoint) - Roberto Ierusalimschy

2) CGILua 3.2 Manual at http://www.tecgraf.puc-rio.br/cgilua

tutorial cgilua 3.2

Documents