PHP DO BÁSICO AO AVANÇADO – AULA 17 – Controle de login Avançado
Tempo de Leitura: 29 Minutos
Nesta aula, vamos estender nosso controle de login, de modo a validar se o usuário possui algum bloqueio seja ele administrativo, se o email usado no cadastro foi verificado pelo uso do pincode, se ele possui algum bloqueio administrativo e qual é o bloqueio, e vamos também usar uma API externa que nos apresenta os detalhes de geolocalização do cliente, que serão salvos, junto com o IP de acesso, só para demonstrar o uso de APIs externas de maneira simples. Com base nos princípios apresentados de checagem, você pode facilmente externder essas funcionalidades para verificar login por endereço IP, controle de acesso simultâneo, controle de bloqueios de tentativa (brute force) e muitos outros.
Se você acompanhou nossas aulas, vamos adicionar as checagens a partir da linha 89 do nosso CONTROL _login_control.php basicamente, cada checagem é uma simples condicional IF, que caso seja satisfeita encerra a execução do script devolvendo o controle para o MODEL com as respectivas apresentações da VIEW, ou seja, é algo bem simples, vamos ao código:
/*
* Neste ponto, fazemos as checagens para verificação avançada de login, e LOGs de
* acesso, controle de bloqueios administrativos e verificações de pagamento, se
* for necessário.
*/
if ($r['ativado']=='0') {
$_SESSION['logado'] = '0';
$_SESSION['view'] = 'login';
$_SESSION['erro_no'] = ALERT;
$_SESSION['erro'] = 'SEU E-MAIL NÃO FOI VALIDADO, '.
'<a href="'.URL.'/login/valida/'.(int)$r['id'].
'">NESTE LINK</a> PARA RE-ENVIAR O EMAIL DE VALIDAÇÃO';
return;
}
if ($r['bloqueio_geral']!='0') {
//SE POSSUI, DEVOLVE A MENSAGEM DE BLOQUEIO CADASTRADA
$_SESSION['logado'] = '0';
$_SESSION['view'] = 'login';
if ($r['bloqueio_geral']>5) {
$_SESSION['erro_no'] = INFO;
} else {
$_SESSION['erro_no'] = $r['bloqueio_geral'];
}
$_SESSION['erro'] = $r['bloqueio_mensagem'];
return;
}
$_SESSION['usuario']=$r['nome'];
$_SESSION['userid']=(int)$r['id'];
$_SESSION['erro_no']=SUCESSO;
$_SESSION['erro']='Olá, <b class="text-primary">'.$r['nome'].
'</b><br>LOGIN efetuado Com Sucesso!';
if (isset($_SERVER['HTTP_CLIENT_IP'])) {
$ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif (isset($_SERVER['REMOTE_ADDR'])) {
$ip = $_SERVER['REMOTE_ADDR'];
} else {
$ip = '127.0.0.1'; //IP LOCALHOST PARA CASO DE FALHA
}
$ip = filter_var($ip,FILTER_VALIDATE_IP);
$geo=getIpGeolocation($ip);
unset($pr);
$pr['ip_acesso'] = $ip;
$pr['ip_country'] = $geo['code'];
$pr['details_login'] = serialize($geo['data']);
$pr['data_login'] = date('Y-m-d h:i:s');
$pr['userid'] = (int)$r['id'];
$sql = "UPDATE usuarios_login SET ip_acesso = :ip_acesso, ip_country = :ip_country,
details_login = :details_login, data_login = :data_login where id = :userid limit 1";
$rs = sqlQuery($sql, $pr);
$_SESSION['view'] = 'minhaconta';
Note que fazemos a chamada a uma função, getIpGeolocation($ip); que é uma abstração a uma chamada de uma API externa, essa é uma boa prática, pois, dessa maneira, se houver uma alteração nesta API, basta ir até essa função e fazer a alteração. O conteúdo deste arquivo é:
<?php /** * BRASAP FRAMEWORK EXTERNAL API's * php version 7.4.3 * * Funções para a ABSTRAÇÃO das CHAMADAS A API'S Externas, caso exista alguma * necessidade de alteração a API externa, basta alterar todas as chamadas a * esta, neste ponto, facilitando uma manutenção futura em caso de troca do * fornecedor, ou alterações na forma que for feita a chamada. * * @category PHP_SimplifiedFrameworkNoOOP * @package BRASAP_FRAMEWORK * @author Romeu Gomes de Sousa <[email protected]> * @license GNU GPL 3.0 - Livre uso e Distribuição * @version GIT: * @link https://brasap.com.br */ /** * API DE GEOLOCALIZAÇÃO DA ABSTRACT * https://app.abstractapi.com/ * * @param $ip = IP a ser consultado V4 ou V6 * * @return ARRAY - Geolocalização e Serialização da resposta */ function getIpGeolocation($ip = 'IP_V4 or IP_V6') { $apikey = '4fd521fbd1b94391b5917aea5a9b1a6d'; // MINHA CHAVE PARTICULAR DE ACESSO $ip = filter_var($ip, FILTER_VALIDATE_IP); $ch = curl_init( "https://ipgeolocation.abstractapi.com/v1/?api_key=$apikey&ip_address=$ip" ); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); curl_setopt($ch, CURLOPT_HEADER, 0); $data = curl_exec($ch); curl_close($ch); $data = json_decode($data,true); if(isset($data['country'])){ $r['pais'] = $data['country']; $r['code'] = $data['country_code']; $r['cidade'] = $data['city']; $r['bandeira'] = $data['flag']['svg']; $r['moeda'] = $data['currency']['currency_code']; $r['data'] = $data; } else { $r['pais'] = 'UNDEFINED'; $r['code'] = '00'; $r['cidade'] = 'UNDEFINED'; $r['bandeira'] = URL.'/resources/imagens/flag-error.svg'; $r['moeda'] = "UNDEFINED"; $r['data'] = 'FALHA NA OBTENÇÃO DA CONSULTA'; } return $r; } ?>
Note, que usamos uma função da biblioteca cURL do php, esta permite a conexão com diferentes tipos de serviços e servidores, em diversos protocolos como HTTP, HTTPS, HTTP POST, HTTP PUT, HTTPS POST, HTTPS GET, upload via FTP, upload HTTP FORM ENCODED, proxies, cookies, e autenticação com usuário e senha. Esta é uma das mais poderosas ferramentas para a conexão com API’s externas, verifique no seu phpinfo() as versões dessa biblioteca, existe uma sessão específica para essa extensão:
Quando você vai fazer uma conexão usando cURL você deve ter em mente, que sempre ela é feite em pelo menos 3 etapas distintas, sendo ABERTURA, feita pela função curl_init(), as configurações, que podem ser feitas por uma ou várias chamadas a funções curl_setopt() a execução ou troca de dados, que será feita por curl_exec() e o fechamento da conexão, feito por curl_close(); além destas, a curl implementa uma série de funções, que vamos falar mais adiante, que servem para estabelecer as mais diversas formas e tipos de comunicação com servidores externos.
Para entender todos os seus recursos, você deve estar bem familiarizado com as conexões web, a forma e a ordem em que ocorrem, e os cabeçalhos que são tocados entre as partes, além de dados como cookies, e outras particularidades. Note, que uma chamada externa, pode ser composta por uma série de chamadas diferentes ao servidor. Esta biblioteca é capaz de implementar praticamente qualquer formato de comunicação de maneira programática, e manipular praticamente qualquer dado do cabeçalho ou do corpo da chamada, e receber dados de corpo e de cabeçalhos para troca de informações dos mais diversos formatos. Lembre-se que alguns formatos podem ser conteúdos binários como arquivos executáveis, imagens, áudios e muito mais. Portanto, tenha certeza sobre a segurança dos dados e a forma correta de armazena-los evitando problemas com a segurança dos seus dados e dos dados do servidor.
Uma ajuda externa, sabe que existem aplicativos especialistas como o POSTMAN que foi detalhado um pouco de seu uso, no post do link Documentando uma API – Exemplo Prático e que permitem de maneira visual, definir os parâmetros e testar as diversas opções.
curl_init($url) – É a função que abre a comunicação com o url especificado, este url deve estar no formato completo, com protocolo://endereço:porta/caminhos/file.extensao e é ela quem cria ou abre a conexão, devolvendo um ponteiro para essa conexão, que será usado pelas outras funções para trocar dados com este servidor e serviço.
curl_version() – Retorna os dados atuais, da biblioteca cURL, os mesmos informados no PHPINFO, para ver, basta executar print_r(curl_version()); que será mostrado um dump das configurações disponíveis.
curl_setopt ( $handle , $option , $value ) – Onde o HANDLE é o ponteiro criado pela função curl_init, OPTION é um dos possíveis valores a serem configurados (veja a tabela abaixo) e VALUE é o valor que será passado nesta configuração.
Valores Booleanos de Configuração
| Opção (CONSTANTE) | VALOR | OBSERVAÇÃO |
| CURLOPT_AUTOREFERER | truedefine o Referer: nas solicitações seguintes para seguirem um redirecionamento Location: | |
| CURLOPT_BINARYTRANSFER | truepara ligar a saída de dados brutos em formato binário quando usada com CURLOPT_RETURNTRANSFER para transferencia de dados | |
| CURLOPT_COOKIESESSION | truepara marcar uma nova “sessão” de cookies. Forçará a libcurl ignorar todos os cookies que está prestes a carregar que são “cookies de sessão” anteriores. Por padrão, libcurl sempre armazena e carrega todos os cookies, independentemente se são cookies de sessão ou não. Os cookies de sessão são cookies sem data de expiração e devem estar ativos e existentes apenas para esta “sessão”. |
|
| CURLOPT_CERTINFO | truepara enviar informações de certificação SSL para STDERR durante sessões HTTPS ou SFTP ou outra conexão segura. | Requer CURLOPT_VERBOSE ligado para funcionar corretamente. |
| CURLOPT_CONNECT_ONLY | truediz a biblioteca para executar toda a autenticação de proxy necessária e configuração de conexão, mas nenhuma transferência de dados. Esta opção é implementada para HTTP, SMTP e POP3. | |
| CURLOPT_CRLF | true para converter fim de linha CRLF para o padrão UNIX (LF) | false mantém o formato (CR+LF) usado em outros sistemas |
| CURLOPT_DISALLOW_USERNAME_IN_URL | true para não permitir URLs que tenham um nome de usuário. Usernames são permitidos por default (0). | |
| CURLOPT_DNS_SHUFFLE_ADDRESSES | true para embaralhar a ordem dos endereços IP retornados, permitindo que seja usado um IP-V6 ou V4 conforme a necessidade. | false vai sempre usar o primeiro IP retornado para o nome, caso mais de 1 seja retornado, impossibilitando uso do V6 por exemplo. |
| CURLOPT_HAPROXYPROTOCOL | true envia um cabeçalho HAProxy PROXY v1 antes do inicio da conexão. | Por padrão, este cabeçalho não é enviado. |
| CURLOPT_SSH_COMPRESSION | true para habilitar a compressão ssh, se estiver disponível nos 2 servidores que estão se comunicando. | |
| CURLOPT_DNS_USE_GLOBAL_CACHE | true usa um cache DNS global. Isso não é seguro, para uso em thread-safe, e é habilitada condicionalmente se o php estiver compilado para uso sem-threaded como (CLI, FCGI, Apache2-Prefork, etc.). | |
| CURLOPT_FAILONERROR | true vai gerar uma falha, se o estado HTTP for maior ou igual a 400. | Por padrão, cURL devolve qualquer conteúdo obtido, ignorando o cabeçalho. |
| CURLOPT_SSL_FALSESTART | true habilita um falso inicio TLS | |
| CURLOPT_FILETIME | true tenta recuperar a data de modificação do conteúdo remoto. | Este valor pode ser recuperado com uso deCURLINFO_FILETIME e curl_getinfo() |
| CURLOPT_FOLLOWLOCATION | true para permitir que cURL siga qualquer informação de Location: ” até um determinado numero de vezes | Segue os direcionamento até que CURLOPT_MAXREDIRS seja alcançado ou um valor retornado. |
| CURLOPT_FORBID_REUSE | true força a conexão ser fechada explicitamente quando o processamento for concluído e não ser agrupada para reutilização. | |
| CURLOPT_FRESH_CONNECT | true forçar o uso de uma nova conexão em vez de uma em cache. | |
| CURLOPT_FTP_USE_EPRT | true usa EPRT (e LPRT) ao fazer downloads de FTP ativos. | Use false para desativar EPRT e LPRT e use apenas a PORTA definida |
| CURLOPT_FTP_USE_EPSV | true para primeiro tentar um comando EPSV para transferências FTP antes de reverter para PASV. | Defina como falso para desativar EPSV |
| CURLOPT_FTP_CREATE_MISSING_DIRS | true para criar diretórios ausentes quando uma operação de FTP encontra um caminho que atualmente não existe. | |
| CURLOPT_FTPAPPEND | true para anexar ao arquivo remoto em vez de sobrescrevê-lo. | |
| CURLOPT_TCP_NODELAY | true para desativar o algoritmo Nagle TCP, que tenta minimizar o número de pacotes pequenos na rede. | |
| CURLOPT_FTPASCII | ALIAS deCURLOPT_TRANSFERTEXT. | Prefira ESTA versão que é mais atual. |
| CURLOPT_FTPLISTONLY | true para listar apenas nomes de diretório no FTP. | |
| CURLOPT_HEADER | true para incluir os cabeçalhos como parte da resposta | |
| CURLINFO_HEADER_OUT | true para rastrear a string de codificação do cabecalho | aCURLINFO_ no prefixo é intencional para compatibilidade. |
| CURLOPT_HTTP09_ALLOWED | Permite respostas HTTP/0.9 | |
| CURLOPT_HTTPGET | true para redefinir o método de solicitação HTTP para GET. | Visto que GET é o padrão, isso só é necessário se o método de solicitação foi alterado. |
| CURLOPT_HTTPPROXYTUNNEL | true faz um túnel através de um proxy HTTP. | |
| CURLOPT_HTTP_CONTENT_DECODING | false para obter o corpo de resposta HTTP bruto (RAW). | |
| CURLOPT_KEEP_SENDING_ON_ERROR | true para continuar enviando o corpo da solicitação se o código HTTP retornado for igual ou maior que 300. A ação padrão seria interromper o envio e fechar o fluxo ou conexão. | Adequado para autenticação NTLM manual. A maioria dos aplicativos não precisa desta opção por padrão. |
| CURLOPT_MUTE | true ser completamente silencioso em relação às funções cURL. | Use CURLOPT_RETURNTRANSFER pois é a versão atual caso apresente falha. |
| CURLOPT_NETRC | true para verificar o arquivo ~/.netrc para encontrar um nome de usuário e senha para o site remoto com o qual a conexão está sendo estabelecida. | |
| CURLOPT_NOBODY | true para excluir o corpo da saída. O método de solicitação é então definido como HEAD. | Alterar isso para falso não altera as solicitações GET. |
| CURLOPT_NOPROGRESS | true para desabilitar o progresso das solicitações. | O PHP define automaticamente para FALSE caso o depurador (debug) esteja habilitado. |
| CURLOPT_NOSIGNAL | true para ignorar qualquer função cURL que faça com que um sinal seja enviado ao processo PHP. | Ativado por padrão em SAPIs multi-threaded para que opções de tempo limite possam ser usadas. |
| CURLOPT_PATH_AS_IS | true para não lidar com sequencias ponto-a-ponto | |
| CURLOPT_PIPEWAIT | true para aguardar comunicação pipelining/multiplexing. | |
| CURLOPT_POST | true para fazer um HTTP POST normal. O padrão é application/x-www-form-urlencoded que é usado comummente em formulários de browsers. | |
| CURLOPT_PUT | true para fazer o PUT HTTP de um arquivo. | Os parâmetros do arquivo são definidos por CURLOPT_INFILE e CURLOPT_INFILESIZE. |
| CURLOPT_RETURNTRANSFER | true para retornar a resposta da transferência como uma string de saída (echo) ao invés de enviá-la diretamente para uma variável. | |
| CURLOPT_SASL_IR | true para permitir o envio da resposta inicial logo no primeiro pacote. | |
| CURLOPT_SSL_ENABLE_ALPN | false para desabilitar o ALPN no handshake SSL (se o backend SSL libcurl for compilado para ser compatível), que pode ser usado para negociar http2. | |
| CURLOPT_SSL_ENABLE_NPN | false para desabilitar NPN no handshake SSL (se libcurl for compatível), que pode ser usado para negociar http2. | |
| CURLOPT_SSL_VERIFYPEER | false para impedir que cURL verifique o certificado do par. Certificados alternativos para verificação podem ser especificados com a opção CURLOPT_CAINFO ou um diretório de certificado pode ser especificado com a opção CURLOPT_CAPATH. | true é o padrão caso não esteja definido na chamada cURL |
| CURLOPT_SSL_VERIFYSTATUS | true verifica o status do certificado SSL e da cadeia | |
| CURLOPT_PROXY_SSL_VERIFYPEER | false para impedir que cURL verifique o caminho do certificado do par. Certificados alternativos para verificação podem ser especificados com a opção CURLOPT_CAINFO ou um diretório de certificado pode ser especificado com a opção CURLOPT_CAPATH. | true é o padrão. Quando FALSO, a verificação do certificado de mesmo nível é bem-sucedida independentemente. |
| CURLOPT_SUPPRESS_CONNECT_HEADERS | true para suprimir cabeçalhos de resposta de proxy CONNECT das funções de retorno de chamada do usuário CURLOPT_HEADERFUNCTION e CURLOPT_WRITEFUNCTION, quando CURLOPT_HTTPPROXYTUNNEL é usado e uma solicitação CONNECT é feita. | |
| CURLOPT_TCP_FASTOPEN | true habilita TCP Fast Open. | |
| CURLOPT_TFTP_NO_OPTIONS | true não envia opções de requests TFTP. | |
| CURLOPT_TRANSFERTEXT | true use ASCII mode para transferencias FTP. Para LDAP, ele vai recuperar dados em texto puroinvés de HTML. | Em sistemas Windows, não definirá STDOUT para o modo binário |
| CURLOPT_UNRESTRICTED_AUTH | true para continuar enviando o nome de usuário e a senha ao seguir os locais (usando CURLOPT_FOLLOWLOCATION), mesmo quando o nome do host foi alterado. | |
| CURLOPT_UPLOAD | true para preparar um upload. | |
| CURLOPT_VERBOSE | true para gerar informações detalhadas (MODO VERBOSO). | Grava a saída em STDERR ou o arquivo especificado usando CURLOPT_STDERR. |
Valores Numéricos de Configuração
| Opção | VALOR |
| CURLOPT_BUFFERSIZE | O tamanho do buffer a ser usado para cada leitura. Não há garantia de que essa solicitação será atendida, pois depende de outras configurações do servidor de origem. |
| CURLOPT_CLOSEPOLICY | Um dos CURLCLOSEPOLICY_* . Esta opção está obsoleta, pois nunca foi implementada em cURL e nunca teve qualquer efeito. |
| CURLOPT_CONNECTTIMEOUT | O número de segundos a aguardar enquanto tenta se conectar. Use 0 para esperar indefinidamente. |
| CURLOPT_CONNECTTIMEOUT_MS | O número de milissegundos a aguardar durante a tentativa de conexão. Use 0 para esperar indefinidamente. Se libcurl for construído para usar o resolvedor de nomes de sistema padrão, essa parte da conexão ainda usará resolução de segundo inteiro para tempos limite com um tempo limite mínimo permitido de um segundo. |
| CURLOPT_DNS_CACHE_TIMEOUT | O número de segundos para manter as entradas DNS na memória. Esta opção é definida para 120 (2 minutos) por padrão. |
| CURLOPT_EXPECT_100_TIMEOUT_MS | O tempo limite para respostas esperadas: continuação de 100 em milissegundos. O padrão é 1000 milissegundos. |
| CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS | Avance para o ipv6 para o algoritmo happy eyeballs. Happy eyeballs tentam se conectar aos endereços IPv4 e IPv6 para hosts de pilha dupla, preferindo IPv6 primeiro para o tempo limite de milissegundos. O padrão é CURL_HET_DEFAULT, que atualmente é de 200 milissegundos. |
| CURLOPT_FTPSSLAUTH | O método de autenticação FTP (quando ativado): CURLFTPAUTH_SSL(tente SSL primeiro), CURLFTPAUTH_TLS(tente TLS primeiro) ou CURLFTPAUTH_DEFAULT(deixe cURL decidir). |
| CURLOPT_HEADEROPT | Como lidar com cabeçalhos. Uma das seguintes constantes: os cabeçalhos especificados serão usados em solicitações para servidores e proxies. Com esta opção habilitada, não terá nenhum efeito. Faz com que os cabeçalhos sejam enviados apenas para um servidor e não para um proxy. Os cabeçalhos de proxy devem ser definidos para serem usados. Observe que, se uma solicitação NO-CONNECT for enviada a um proxy, libcurl enviará os cabeçalhos do servidor e do proxy. Ao fazer CONNECT, libcurl irá enviar cabeçalhos apenas para o proxy e, em seguida, cabeçalhos apenas para o servidor. CURLHEADER_UNIFIED CURLOPT_HTTPHEADER CURLOPT_PROXYHEADER CURLHEADER_SEPARATE CURLOPT_HTTPHEADER CURLOPT_PROXYHEADER CURLOPT_PROXYHEADER CURLOPT_HTTPHEADER CURLHEADER_SEPARATE CURLHEADER_UNIFIED |
| CURLOPT_HTTP_VERSION | CURL_HTTP_VERSION_NONE (padrão, permite que o CURL decida qual versão usar), CURL_HTTP_VERSION_1_0 (força HTTP / 1.0), CURL_HTTP_VERSION_1_1(força HTTP / 1.1), CURL_HTTP_VERSION_2_0(tenta HTTP 2), CURL_HTTP_VERSION_2 (alias de CURL_HTTP_VERSION_2_0), CURL_HTTP_VERSION_2TLS(tenta HTTP 2 sobre TLS (HTTPS) apenas) ou CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE (emite solicitações HTTP não-TLS usando HTTP/2 sem atualização HTTP / 1.1). |
| CURLOPT_HTTPAUTH | Os métodos de autenticação HTTP a serem usados. As opções são: CURLAUTH_BASIC, CURLAUTH_DIGEST, CURLAUTH_GSSNEGOTIATE, CURLAUTH_NTLM, CURLAUTH_ANY, e CURLAUTH_ANYSAFE. O |operador bit a bit (ou) pode ser usado para combinar mais de um método. Se isso for feito, cURL pesquisará o servidor para ver quais métodos ele suporta e escolher o melhor. CURLAUTH_ANY é um alias para CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. CURLAUTH_ANYSAFE é um alias para CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. |
| CURLOPT_INFILESIZE | O tamanho esperado, em bytes, do arquivo ao enviar um arquivo para um site remoto. Observe que usar esta opção não impedirá que o libcurl envie mais dados, pois depende exatamente do que é enviado CURLOPT_READFUNCTION. |
| CURLOPT_LOW_SPEED_LIMIT | A velocidade de transferência, em bytes por segundo, que a transferência deve estar abaixo durante a contagem de CURLOPT_LOW_SPEED_TIME segundos antes que o PHP considere a transferência muito lenta e aborta. |
| CURLOPT_LOW_SPEED_TIME | O número de segundos que a velocidade de transferência deve ficar abaixo CURLOPT_LOW_SPEED_LIMIT antes que o PHP considere a transferência muito lenta e aborte. |
| CURLOPT_MAXCONNECTS | A quantidade máxima de conexões persistentes permitidas. Quando o limite é atingido, CURLOPT_CLOSEPOLICY é usado para determinar qual conexão fechar. |
| CURLOPT_MAXREDIRS | A quantidade máxima de redirecionamentos HTTP a seguir. Use esta opção ao lado CURLOPT_FOLLOWLOCATION. O valor padrão 20é definido para evitar redirecionamentos infinitos. Definir como -1permite redirecionamentos infinitos e 0 recusa todos os redirecionamentos. |
| CURLOPT_PORT | Um número de porta alternativo para se conectar. |
| CURLOPT_POSTREDIR | Um bitmask de 1 (301 Moved Permanently), 2 (302 Found) e 4 (303 See Other) se o método HTTP POST deve ser mantido quando CURLOPT_FOLLOWLOCATIONé definido e um tipo específico de redirecionamento ocorre. |
| CURLOPT_PROTOCOLS | Máscara de bits de CURLPROTO_* valores. Se usado, este bitmask limita quais protocolos libcurl pode usar na transferência. Isso permite que você tenha uma libcurl construída para suportar uma ampla gama de protocolos, mas ainda limitar transferências específicas para ter permissão para usar apenas um subconjunto deles. Por padrão, libcurl aceitará todos os protocolos que suporta. Veja também CURLOPT_REDIR_PROTOCOLS. Opções de protocolo válidos são: CURLPROTO_HTTP, CURLPROTO_HTTPS, CURLPROTO_FTP, CURLPROTO_FTPS, CURLPROTO_SCP, CURLPROTO_SFTP, CURLPROTO_TELNET, CURLPROTO_LDAP, CURLPROTO_LDAPS, CURLPROTO_DICT, CURLPROTO_FILE, CURLPROTO_TFTP,CURLPROTO_ALL |
| CURLOPT_PROXYAUTH | Os métodos de autenticação HTTP a serem usados para a conexão proxy. Use as mesmas máscaras de bits conforme descrito em CURLOPT_HTTPAUTH. Para autenticação de proxy, apenas CURLAUTH_BASICe CURLAUTH_NTLM atualmente são suportados. |
| CURLOPT_PROXYPORT | O número da porta do proxy ao qual se conectar. Este número de porta também pode ser definido em CURLOPT_PROXY. |
| CURLOPT_PROXYTYPE | Ou CURLPROXY_HTTP(padrão), CURLPROXY_SOCKS4, CURLPROXY_SOCKS5, CURLPROXY_SOCKS4Aou CURLPROXY_SOCKS5_HOSTNAME. |
| CURLOPT_REDIR_PROTOCOLS | Máscara de bits de CURLPROTO_* valores. Se usado, este bitmask limita quais protocolos libcurl pode usar em uma transferência que segue para um redirecionamento quando CURLOPT_FOLLOWLOCATIONestá habilitado. Isso permite que você limite transferências específicas para ter permissão para usar apenas um subconjunto de protocolos nos redirecionamentos. Por padrão, o libcurl permitirá todos os protocolos, exceto FILE e SCP. Esta é uma diferença em comparação com as versões anteriores ao 7.19.4, que seguiriam incondicionalmente todos os protocolos suportados. Consulte também os CURLOPT_PROTOCOLSvalores das constantes do protocolo. |
| CURLOPT_RESUME_FROM | O deslocamento, em bytes, do qual retomar uma transferência. |
| CURLOPT_SOCKS5_AUTH | O (s) método (s) de autenticação SOCKS5 a serem usados. As opções são: CURLAUTH_BASIC, CURLAUTH_GSSAPI, CURLAUTH_NONE. O |operador bit a bit (ou) pode ser usado para combinar mais de um método. Se isso for feito, cURL pesquisará o servidor para ver quais métodos ele suporta e escolher o melhor. CURLAUTH_BASIC permite autenticação de nome de usuário / senha. CURLAUTH_GSSAPI permite autenticação GSS-API. CURLAUTH_NONE não permite autenticação. O padrão é CURLAUTH_BASIC|CURLAUTH_GSSAPI. Defina o nome de usuário e a senha reais com a CURLOPT_PROXYUSERPWDopção. |
| CURLOPT_SSL_OPTIONS | Defina as opções de comportamento SSL, que são uma máscara de bits de qualquer uma das seguintes constantes:: não tente usar nenhuma solução alternativa para uma falha de segurança nos protocolos SSL3 e TLS1.0. : desativa as verificações de revogação de certificado para os back-ends SSL onde tal comportamento está presente. CURLSSLOPT_ALLOW_BEAST CURLSSLOPT_NO_REVOKE |
| CURLOPT_SSL_VERIFYHOST | 1 para verificar a existência de um nome comum no certificado de mesmo nível SSL. 2para verificar a existência de um nome comum e também verificar se ele corresponde ao nome do host fornecido. 0para não verificar os nomes. Em ambientes de produção, o valor desta opção deve ser mantido em 2(valor padrão). |
| CURLOPT_SSLVERSION | Um de CURL_SSLVERSION_DEFAULT(0), CURL_SSLVERSION_TLSv1(1), CURL_SSLVERSION_SSLv2(2), CURL_SSLVERSION_SSLv3(3), CURL_SSLVERSION_TLSv1_0(4), CURL_SSLVERSION_TLSv1_1(5) ou CURL_SSLVERSION_TLSv1_2(6). A versão máxima de TLS pode ser definida usando uma das CURL_SSLVERSION_MAX_*constantes. Também é possível fazer o OR de uma das CURL_SSLVERSION_*constantes com uma das CURL_SSLVERSION_MAX_*constantes. CURL_SSLVERSION_MAX_DEFAULT(a versão máximo suportado pela biblioteca), CURL_SSLVERSION_MAX_TLSv1_0, CURL_SSLVERSION_MAX_TLSv1_1, CURL_SSLVERSION_MAX_TLSv1_2, ou CURL_SSLVERSION_MAX_TLSv1_3. Nota : Sua melhor aposta é não definir isso e deixá-lo usar o padrão. Definir como 2 ou 3 é muito perigoso devido às vulnerabilidades conhecidas em SSLv2 e SSLv3. |
| CURLOPT_PROXY_SSL_OPTIONS | Defina as opções de comportamento do proxy SSL, que é uma máscara de bits de qualquer uma das seguintes constantes:: não tente usar nenhuma solução alternativa para uma falha de segurança nos protocolos SSL3 e TLS1.0. : desativa as verificações de revogação de certificado para os back-ends SSL onde tal comportamento está presente. (curl 7.44.0) : não aceita cadeias de certificados “parciais”, o que acontece por padrão. (curl 7,68,0) CURLSSLOPT_ALLOW_BEAST CURLSSLOPT_NO_REVOKE CURLSSLOPT_NO_PARTIALCHAIN |
| CURLOPT_PROXY_SSL_VERIFYHOST | Defina como 2para verificar nos campos de nome do certificado do proxy HTTPS em relação ao nome do proxy. Quando definido para, 0a conexão é bem-sucedida, independentemente dos nomes usados no certificado. Use essa habilidade com cuidado! 1tratado como uma opção de depuração no curl 7.28.0 e anteriores. De curl 7.28.1 a 7.65.3 CURLE_BAD_FUNCTION_ARGUMENTé retornado. De curl 7.66.0 em diante 1e 2é tratado como o mesmo valor. Em ambientes de produção, o valor desta opção deve ser mantido em 2(valor padrão). |
| CURLOPT_PROXY_SSLVERSION | Um dos CURL_SSLVERSION_DEFAULT, CURL_SSLVERSION_TLSv1, CURL_SSLVERSION_TLSv1_0, CURL_SSLVERSION_TLSv1_1, CURL_SSLVERSION_TLSv1_2, CURL_SSLVERSION_TLSv1_3, CURL_SSLVERSION_MAX_DEFAULT, CURL_SSLVERSION_MAX_TLSv1_0, CURL_SSLVERSION_MAX_TLSv1_1, CURL_SSLVERSION_MAX_TLSv1_2, CURL_SSLVERSION_MAX_TLSv1_3ou CURL_SSLVERSION_SSLv3. Nota : Sua melhor aposta é não definir isso e deixá-lo usar o padrão, CURL_SSLVERSION_DEFAULTque tentará descobrir a versão do protocolo SSL remoto. |
| CURLOPT_STREAM_WEIGHT | Defina o peso numérico do fluxo (um número entre 1 e 256). |
| CURLOPT_TCP_KEEPALIVE | Se definido como 1, as sondas keepalive de TCP serão enviadas. O atraso e a frequência dessas detecções podem ser controlados pelas opções CURLOPT_TCP_KEEPIDLEe CURLOPT_TCP_KEEPINTVL, desde que o sistema operacional as suporte. Se definido como 0(padrão), os testes de manutenção de atividade são desativados. |
| CURLOPT_TCP_KEEPIDLE | Define o atraso, em segundos, que o sistema operacional aguardará enquanto a conexão está ociosa antes de enviar sondagens keep-alive, se CURLOPT_TCP_KEEPALIVEestiver habilitado. Nem todos os sistemas operacionais oferecem suporte a essa opção. O padrão é 60. |
| CURLOPT_TCP_KEEPINTVL | Define o intervalo, em segundos, que o sistema operacional aguardará entre o envio de probes keep-alive, se CURLOPT_TCP_KEEPALIVEestiver habilitado. Nem todos os sistemas operacionais oferecem suporte a essa opção. O padrão é 60. |
| CURLOPT_TIMECONDITION | Como CURLOPT_TIMEVALUE é tratado. Use CURL_TIMECOND_IFMODSINCEpara retornar a página apenas se ela tiver sido modificada desde o tempo especificado em CURLOPT_TIMEVALUE. Se não tiver sido modificado, um “304 Not Modified”cabeçalho será devolvido assumindo CURLOPT_HEADERseja true. Use CURL_TIMECOND_IFUNMODSINCEpara o efeito reverso. CURL_TIMECOND_IFMODSINCEé o padrão. |
| CURLOPT_TIMEOUT | O número máximo de segundos para permitir a execução das funções cURL. |
| CURLOPT_TIMEOUT_MS | O número máximo de milissegundos para permitir a execução das funções cURL. Se libcurl for construído para usar o resolvedor de nomes de sistema padrão, essa parte da conexão ainda usará resolução de segundo inteiro para tempos limite com um tempo limite mínimo permitido de um segundo. |
| CURLOPT_TIMEVALUE | O tempo em segundos desde 1º de janeiro de 1970. O tempo será usado por CURLOPT_TIMECONDITION. Por padrão, CURL_TIMECOND_IFMODSINCEé usado. |
| CURLOPT_TIMEVALUE_LARGE | O tempo em segundos desde 1º de janeiro de 1970. O tempo será usado por CURLOPT_TIMECONDITION. O padrão é zero. A diferença entre esta opção e CURLOPT_TIMEVALUEé o tipo de argumento. Em sistemas em que ‘long’ tem apenas 32 bits de largura, esta opção deve ser usada para definir datas além do ano 2038. |
| CURLOPT_MAX_RECV_SPEED_LARGE | Se um download exceder essa velocidade (contada em bytes por segundo) na média cumulativa durante a transferência, a transferência fará uma pausa para manter a taxa média menor ou igual ao valor do parâmetro. O padrão é velocidade ilimitada. |
| CURLOPT_MAX_SEND_SPEED_LARGE | Se um upload exceder essa velocidade (contada em bytes por segundo) na média cumulativa durante a transferência, a transferência fará uma pausa para manter a taxa média menor ou igual ao valor do parâmetro. O padrão é velocidade ilimitada. |
| CURLOPT_SSH_AUTH_TYPES | Uma máscara de bits que consiste em um ou mais de CURLSSH_AUTH_PUBLICKEY, CURLSSH_AUTH_PASSWORD, CURLSSH_AUTH_HOST, CURLSSH_AUTH_KEYBOARD. Defina como CURLSSH_AUTH_ANY para permitir que a libcurl escolha um. |
| CURLOPT_IPRESOLVE | Permite que um aplicativo selecione o tipo de endereço IP a ser usado ao resolver nomes de host. Isso só é interessante quando se utiliza nomes de host que os endereços resolver usando mais de uma versão do IP, os valores possíveis são CURL_IPRESOLVE_WHATEVER, CURL_IPRESOLVE_V4, CURL_IPRESOLVE_V6, por padrão CURL_IPRESOLVE_WHATEVER. |
| CURLOPT_FTP_FILEMETHOD | Diga ao curl qual método usar para acessar um arquivo em um servidor FTP (S). Os valores possíveis são CURLFTPMETHOD_MULTICWD, CURLFTPMETHOD_NOCWD e CURLFTPMETHOD_SINGLECWD. |
Valores do tipo STRING
| Opção | Defina o valor para |
| CURLOPT_ABSTRACT_UNIX_SOCKET | Habilita o uso de um soquete de domínio Unix abstrato em vez de estabelecer uma conexão TCP com um host e define o caminho para a string fornecida. Esta opção compartilha a mesma semântica de CURLOPT_UNIX_SOCKET_PATH. Essas duas opções compartilham o mesmo armazenamento e, portanto, apenas uma delas pode ser definida por identificador. |
| CURLOPT_CAINFO | O nome de um arquivo que contém um ou mais certificados para verificar o par. Isso só faz sentido quando usado em combinação com CURLOPT_SSL_VERIFYPEER. Pode exigir um caminho absoluto. |
| CURLOPT_CAPATH | Um diretório que contém vários certificados CA. Use esta opção junto com CURLOPT_SSL_VERIFYPEER. |
| CURLOPT_COOKIE | O conteúdo do cabeçalho “Cookie:” a ser usado na solicitação HTTP. Observe que vários cookies são separados por ponto-e-vírgula seguido por um espaço (por exemplo, “fruta = maçã; cor = vermelho”) |
| CURLOPT_COOKIEFILE | O nome do arquivo que contém os dados do cookie. O arquivo de cookie pode estar no formato Netscape ou apenas cabeçalhos simples no estilo HTTP despejados em um arquivo. Se o nome for uma string vazia, nenhum cookie será carregado, mas o tratamento de cookies ainda estará habilitado. |
| CURLOPT_COOKIEJAR | O nome de um arquivo para salvar todos os cookies internos quando o identificador é fechado, por exemplo, após uma chamada para curl_close. |
| CURLOPT_COOKIELIST | Uma string de cookie (ou seja, uma única linha no formato Netscape / Mozilla ou um cabeçalho Set-Cookie regular no estilo HTTP) adiciona esse único cookie ao armazenamento interno de cookies. “ALL” apaga todos os cookies mantidos na memória. “SESS” apaga todos os cookies de sessão mantidos na memória. “FLUSH” grava todos os cookies conhecidos no arquivo especificado por CURLOPT_COOKIEJAR. “RELOAD” carrega todos os cookies dos arquivos especificados por CURLOPT_COOKIEFILE. |
| CURLOPT_CUSTOMREQUEST | Um método de solicitação personalizado para usar em vez de “GET” ou “HEAD” ao fazer uma solicitação HTTP. Isso é útil para fazer “DELETE” ou outras solicitações HTTP mais obscuras. Os valores válidos são coisas como “GET”, “POST”, “CONNECT” e assim por diante; ou seja, não insira uma linha de solicitação HTTP inteira aqui. Por exemplo, inserir “GET /index.html HTTP / 1.0 \ r \ n \ r \ n” seria incorreto. Nota: Não faça isso sem antes ter certeza de que o servidor oferece suporte ao método de solicitação personalizada. |
| CURLOPT_DEFAULT_PROTOCOL | O protocolo padrão a ser usado se o URL não tiver um nome de esquema. |
| CURLOPT_DNS_INTERFACE | Defina o nome da interface de rede à qual o resolvedor de DNS deve se vincular. Deve ser um nome de interface (não um endereço). |
| CURLOPT_DNS_LOCAL_IP4 | Defina o endereço IPv4 local ao qual o resolvedor deve se vincular. O argumento deve conter um único endereço IPv4 numérico como string. |
| CURLOPT_DNS_LOCAL_IP6 | Defina o endereço IPv6 local ao qual o resolvedor deve se vincular. O argumento deve conter um único endereço IPv6 numérico como string. |
| CURLOPT_EGDSOCKET | Como CURLOPT_RANDOM_FILE, exceto um nome de arquivo para um soquete Entropy Gathering Daemon. |
| CURLOPT_ENCODING | O conteúdo do cabeçalho “Accept-Encoding:”. Isso permite a decodificação da resposta. As codificações com suporte são “identidade”, “deflate” e “gzip”. Se uma string vazia, “”, for definida, um cabeçalho contendo todos os tipos de codificação suportados é enviado. |
| CURLOPT_FTPPORT | O valor que será usado para obter o endereço IP a ser usado para a instrução FTP “PORT”. A instrução “PORT” diz ao servidor remoto para se conectar ao nosso endereço IP especificado. A string pode ser um endereço IP simples, um nome de host, um nome de interface de rede (no Unix) ou apenas um ‘-‘ simples para usar o endereço IP padrão do sistema. |
| CURLOPT_INTERFACE | O nome da interface de rede de saída a ser usada. Pode ser um nome de interface, um endereço IP ou um nome de host. |
| CURLOPT_KEYPASSWD | A senha necessária para usar a chave privada CURLOPT_SSLKEY ou CURLOPT_SSH_PRIVATE_KEYFILE. |
| CURLOPT_KRB4LEVEL | O nível de segurança KRB4 (Kerberos 4). Qualquer um dos seguintes valores (do menos ao mais poderoso) são válidos: “clear”, “safe”, “confidencial”, “private” .. Se a string não corresponder a um desses, “private” é usado. Definir esta opção como nula desativará a segurança KRB4. Atualmente, a segurança KRB4 funciona apenas com transações FTP. |
| CURLOPT_LOGIN_OPTIONS | Pode ser usado para definir opções de login específicas do protocolo, como o mecanismo de autenticação preferencial por meio de “AUTH = NTLM” ou “AUTH = *”, e deve ser usado em conjunto com a opção CURLOPT_USERNAME. |
| CURLOPT_PINNEDPUBLICKEY | Defina a chave pública fixada. A string pode ser o nome do arquivo de sua chave pública fixada. O formato de arquivo esperado é “PEM” ou “DER”. A string também pode ser qualquer número de hashes sha256 codificados em base64 precedidos por “sha256 //” e separados por “;”. |
| CURLOPT_POSTFIELDS | Os dados completos para postar em uma operação HTTP “POST”. Este parâmetro pode ser passado como uma string codificada por url como ‘para1 = val1 & para2 = val2 & …’ ou como uma matriz com o nome do campo como chave e os dados do campo como valor. Se o valor for uma matriz, o cabeçalho Content-Type será definido como multipart / form-data. Os arquivos podem ser enviados usando CURLFile, em cujo caso o valor deve ser uma matriz. |
| CURLOPT_PRIVATE | Quaisquer dados que devam ser associados a este identificador cURL. Esses dados podem ser posteriormente recuperados com a opção CURLINFO_PRIVATE de curl_getinfo (). cURL não faz nada com esses dados. Ao usar um identificador cURL múltiplo, esses dados privados são normalmente uma chave única para identificar um identificador cURL padrão. |
| CURLOPT_PRE_PROXY | Defina uma string contendo o nome do host ou endereço IP numérico pontilhado a ser usado como o pré-proxy ao qual o curl se conecta antes de se conectar ao proxy HTTP (S) especificado na opção CURLOPT_PROXY para a solicitação futura. O preproxy só pode ser um proxy SOCKS e deve ser prefixado com [esquema]: // para especificar que tipo de meia é usado. Um endereço IPv6 numérico deve ser escrito entre [colchetes]. Definir o preproxy como uma string vazia desabilita explicitamente o uso de um preproxy. Para especificar o número da porta nesta string, acrescente: [porta] ao final do nome do host. O número da porta do proxy pode ser especificado opcionalmente com a opção separada CURLOPT_PROXYPORT. O padrão é usar a porta 1080 para proxies se uma porta não for especificada. |
| CURLOPT_PROXY | O proxy HTTP para enviar solicitações através do túnel. |
| CURLOPT_PROXY_SERVICE_NAME | O nome do serviço de autenticação de proxy. |
| CURLOPT_PROXY_CAINFO | O caminho para o pacote proxy da Autoridade de Certificação (CA). Defina o caminho como uma string nomeando um arquivo que contém um ou mais certificados com os quais verificar o proxy HTTPS. Esta opção é para se conectar a um proxy HTTPS, não a um servidor HTTPS. Padrões definidos para o caminho do sistema onde o pacote cacert de libcurl é considerado armazenado. |
| CURLOPT_PROXY_CAPATH | O diretório que contém vários certificados CA para verificar o proxy HTTPS. |
| CURLOPT_PROXY_CRLFILE | Defina o nome do arquivo com a concatenação de CRL (lista de revogação de certificado) no formato PEM para usar na validação do certificado que ocorre durante a troca de SSL. |
| CURLOPT_PROXY_KEYPASSWD | Defina a string a ser usada como a senha necessária para usar a chave privada CURLOPT_PROXY_SSLKEY. Você nunca precisou de uma frase secreta para carregar um certificado, mas precisa de uma para carregar sua chave privada. Esta opção é para se conectar a um proxy HTTPS, não a um servidor HTTPS. |
| CURLOPT_PROXY_PINNEDPUBLICKEY | Defina a chave pública fixada para o proxy HTTPS. A string pode ser o nome do arquivo de sua chave pública fixada. O formato de arquivo esperado é “PEM” ou “DER”. A string também pode ser qualquer número de hashes sha256 codificados em base64 precedidos por “sha256 //” e separados por “;” |
| CURLOPT_PROXY_SSLCERT | O nome do arquivo do certificado do cliente usado para se conectar ao proxy HTTPS. O formato padrão é “P12” no Transporte Seguro e “PEM” em outros motores e pode ser alterado com CURLOPT_PROXY_SSLCERTTYPE. Com NSS ou Secure Transport, também pode ser o apelido do certificado com o qual você deseja se autenticar, conforme é nomeado no banco de dados de segurança. Se quiser usar um arquivo do diretório atual, coloque o prefixo “./” antes dele, para evitar confusão com um apelido. |
| CURLOPT_PROXY_SSLCERTTYPE | O formato do seu certificado de cliente usado ao se conectar a um proxy HTTPS. Os formatos suportados são “PEM” e “DER”, exceto com Transporte Seguro. OpenSSL (versões 0.9.3 e posterior) e Secure Transport (no iOS 5 ou posterior, ou OS X 10.7 ou posterior) também oferecem suporte a “P12” para arquivos codificados em PKCS # 12. O padrão é “PEM”. |
| CURLOPT_PROXY_SSL_CIPHER_LIST | A lista de cifras a serem usadas para a conexão com o proxy HTTPS. A lista deve estar sintaticamente correta, consiste em uma ou mais cadeias de criptografia separadas por dois pontos. Vírgulas ou espaços também são separadores aceitáveis, mas os dois pontos são normalmente usados,!, – e + podem ser usados como operadores. |
| CURLOPT_PROXY_TLS13_CIPHERS | A lista de conjuntos de criptografia a serem usados para a conexão TLS 1.3 a um proxy. A lista deve estar sintaticamente correta, consiste em uma ou mais cadeias de caracteres de cifras separadas por dois pontos. Esta opção é usada atualmente apenas quando curl é construído para usar OpenSSL 1.1.1 ou posterior. Se estiver usando um back-end SSL diferente, você pode tentar definir os conjuntos de criptografia TLS 1.3 usando a opção CURLOPT_PROXY_SSL_CIPHER_LIST. |
| CURLOPT_PROXY_SSLKEY | O nome do arquivo da sua chave privada usada para se conectar ao proxy HTTPS. O formato padrão é “PEM” e pode ser alterado com CURLOPT_PROXY_SSLKEYTYPE. (iOS e Mac OS X apenas) Esta opção será ignorada se o curl tiver sido criado para o transporte seguro. |
| CURLOPT_PROXY_SSLKEYTYPE | O formato da sua chave privada. Os formatos suportados são “PEM”, “DER” e “ENG”. |
| CURLOPT_PROXY_TLSAUTH_PASSWORD | A senha a ser usada para o método de autenticação TLS especificado com a opção CURLOPT_PROXY_TLSAUTH_TYPE. Requer que a opção CURLOPT_PROXY_TLSAUTH_USERNAME também seja definida. |
| CURLOPT_PROXY_TLSAUTH_TYPE | O método de autenticação TLS usado para a conexão HTTPS. O método suportado é “SRP”. Observação: a autenticação de senha remota segura (SRP) para TLS fornece autenticação mútua se ambos os lados tiverem um segredo compartilhado. Para usar o TLS-SRP, você também deve definir as opções CURLOPT_PROXY_TLSAUTH_USERNAME e CURLOPT_PROXY_TLSAUTH_PASSWORD. |
| CURLOPT_PROXY_TLSAUTH_USERNAME | Tusername a ser usado para o método de autenticação TLS do proxy HTTPS especificado com a opção CURLOPT_PROXY_TLSAUTH_TYPE. Requer que a opção CURLOPT_PROXY_TLSAUTH_PASSWORD também seja definida. |
| CURLOPT_PROXYUSERPWD | Um nome de usuário e senha formatados como “[nome de usuário]: [senha]” para usar na conexão com o proxy. |
| CURLOPT_RANDOM_FILE | Um nome de arquivo a ser usado para propagar o gerador de número aleatório para SSL. |
| CURLOPT_RANGE | Intervalo (s) de dados a serem recuperados no formato “XY”, em que X ou Y são opcionais. As transferências HTTP também suportam vários intervalos, separados por vírgulas no formato “XY, NM”. |
| CURLOPT_REFERER | O conteúdo do cabeçalho “Referer:” a ser usado em uma solicitação HTTP. |
| CURLOPT_SERVICE_NAME | O nome do serviço de autenticação. |
| CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 | Uma string contendo 32 dígitos hexadecimais. A string deve ser a soma de verificação MD5 da chave pública do host remoto, e libcurl rejeitará a conexão com o host a menos que os md5sums correspondam. Esta opção é apenas para transferências SCP e SFTP. |
| CURLOPT_SSH_PUBLIC_KEYFILE | O nome do arquivo para sua chave pública. Se não for usado, o padrão de libcurl é $ HOME / .ssh / id_dsa.pub se a variável de ambiente HOME estiver configurada e apenas “id_dsa.pub” no diretório atual se HOME não estiver configurada. |
| CURLOPT_SSH_PRIVATE_KEYFILE | O nome do arquivo para sua chave privada. Se não for usado, o padrão libcurl é $ HOME / .ssh / id_dsa se a variável de ambiente HOME estiver definida, e apenas “id_dsa” no diretório atual se HOME não estiver definida. Se o arquivo for protegido por senha, defina a senha com CURLOPT_KEYPASSWD. |
| CURLOPT_SSL_CIPHER_LIST | Uma lista de cifras a serem usadas para SSL. Por exemplo, RC4-SHA e TLSv1 são listas de cifras válidas. |
| CURLOPT_SSLCERT | O nome de um arquivo que contém um certificado formatado PEM. |
| CURLOPT_SSLCERTPASSWD | A senha necessária para usar o certificado CURLOPT_SSLCERT. |
| CURLOPT_SSLCERTTYPE | O formato do certificado. Os formatos suportados são “PEM” (padrão), “DER” e “ENG”. A partir do OpenSSL 0.9.3, “P12” (para arquivos codificados em PKCS # 12) também é compatível. |
| CURLOPT_SSLENGINE | O identificador para o mecanismo de criptografia da chave SSL privada especificada em CURLOPT_SSLKEY. |
| CURLOPT_SSLENGINE_DEFAULT | O identificador do mecanismo criptográfico usado para operações criptográficas assimétricas. |
| CURLOPT_SSLKEY | O nome de um arquivo que contém uma chave SSL privada. |
| CURLOPT_SSLKEYPASSWD | A senha secreta necessária para usar a chave SSL privada especificada em CURLOPT_SSLKEY. Nota: Uma vez que esta opção contém uma senha confidencial, lembre-se de manter o script PHP contido em um cofre. |
| CURLOPT_SSLKEYTYPE | O tipo de chave da chave SSL privada especificada em CURLOPT_SSLKEY. Os tipos de chave suportados são “PEM” (padrão), “DER” e “ENG”. |
| CURLOPT_TLS13_CIPHERS | A lista de conjuntos de criptografia a serem usados para a conexão TLS 1.3. A lista deve estar sintaticamente correta, consiste em uma ou mais cadeias de caracteres de cifras separadas por dois pontos. Esta opção é usada atualmente apenas quando curl é construído para usar OpenSSL 1.1.1 ou posterior. Se estiver usando um back-end SSL diferente, você pode tentar configurar os conjuntos de criptografia TLS 1.3 usando a opção CURLOPT_SSL_CIPHER_LIST. |
| CURLOPT_UNIX_SOCKET_PATH | Habilita o uso de soquetes de domínio Unix como endpoint de conexão e define o caminho para a string fornecida. |
| CURLOPT_URL | O URL a ser buscado. Isso também pode ser definido ao inicializar uma sessão com curl_init (). |
| CURLOPT_USERAGENT | O conteúdo do cabeçalho “User-Agent:” a ser usado em uma solicitação HTTP. |
| CURLOPT_USERNAME | O nome de usuário a ser usado na autenticação. |
| CURLOPT_USERPWD | Um nome de usuário e senha formatados como “[nome de usuário]: [senha]” para usar na conexão. |
| CURLOPT_XOAUTH2_BEARER | Especifica o token de acesso OAuth 2.0. |
Valores em formato ARRAY
| CURLOPT_CONNECT_TO | Conecte-se a um host e porta específicos em vez do host e da porta do URL. Aceita uma matriz de strings com o formato HOST: PORT: CONNECT-TO-HOST: CONNECT-TO-PORT. |
| CURLOPT_HTTP200ALIASES | Uma matriz de respostas HTTP 200 que serão tratadas como respostas válidas e não como erros. |
| CURLOPT_HTTPHEADER | Uma matriz de campos de cabeçalho HTTP para definir, na matriz de formato (‘Content-type: text / plain’, ‘Content-length: 100’) |
| CURLOPT_POSTQUOTE | Uma série de comandos FTP a serem executados no servidor após a execução da solicitação FTP. |
| CURLOPT_PROXYHEADER | Uma matriz de cabeçalhos HTTP personalizados para passar aos proxies. |
| CURLOPT_QUOTE | Uma série de comandos de FTP para executar no servidor antes da solicitação de FTP. |
| CURLOPT_RESOLVE | Fornece um endereço personalizado para um host específico e par de portas. Uma matriz de strings de nome de host, porta e endereço IP, cada elemento separado por dois pontos. No formato: array (“example.com:80:127.0.0.1”) |
Valores tipo RESOURCE ou OBJECT definidos por outras funções
| Opção | VALOR |
| CURLOPT_FILE | O arquivo no qual a transferência deve ser gravada. O padrão é STDOUT (a janela do navegador). |
| CURLOPT_INFILE | O arquivo de onde a transferência deve ser lida durante o upload. |
| CURLOPT_STDERR | Um local alternativo para enviar erros em vez de STDERR. |
| CURLOPT_WRITEHEADER | O arquivo no qual a parte do cabeçalho da transferência é gravada. |
Funções de CALLBACK aceitas
| Opção | Defina o valor para |
| CURLOPT_HEADERFUNCTION | Um retorno de chamada que aceita dois parâmetros. O primeiro é o recurso cURL, o segundo é uma string com os dados do cabeçalho a serem gravados. Os dados do cabeçalho devem ser gravados por este retorno de chamada. Retorna o número de bytes gravados. |
| CURLOPT_PASSWDFUNCTION | Um retorno de chamada que aceita três parâmetros. O primeiro é o recurso cURL, o segundo é uma string contendo um prompt de senha e o terceiro é o comprimento máximo da senha. Retorne a string contendo a senha. |
| CURLOPT_PROGRESSFUNCTION | Um retorno de chamada que aceita cinco parâmetros. O primeiro é o recurso cURL, o segundo é o número total de bytes esperados para serem baixados nesta transferência, o terceiro é o número de bytes baixados até agora, o quarto é o número total de bytes esperados para serem carregados nesta transferência, e o quinto é o número de bytes enviados até agora. Nota: O retorno de chamada só é chamado quando a opção CURLOPT_NOPROGRESS é definida como false. Retorne um valor diferente de zero para abortar a transferência. Nesse caso, a transferência definirá um erro CURLE_ABORTED_BY_CALLBACK. |
| CURLOPT_READFUNCTION | Um retorno de chamada que aceita três parâmetros. O primeiro é o recurso cURL, o segundo é um recurso de fluxo fornecido para cURL por meio da opção CURLOPT_INFILE e o terceiro é a quantidade máxima de dados a serem lidos. O retorno de chamada deve retornar uma string com um comprimento igual ou menor que a quantidade de dados solicitados, normalmente lendo-o do recurso de fluxo passado. Ele deve retornar uma string vazia para sinalizar EOF. |
| CURLOPT_WRITEFUNCTION | Um retorno de chamada que aceita dois parâmetros. O primeiro é o recurso cURL e o segundo é uma string com os dados a serem gravados. Os dados devem ser salvos por este retorno de chamada. Deve retornar o número exato de bytes gravados ou a transferência será abortada com um erro. |
| CURLOPT_SHARE | Um resultado de curl_share_init (). Faz com que o identificador cURL use os dados do identificador compartilhado. |
Na próxima aula, vamos continuar falando sobre outros recursos da cURL que vão permitir a comunicação com APIs e servidores externos.
