public async Task <bool> HTML_AutenticarUsuario(Pacote_Auth Pacote_AuthWEB)
{
try
{
HttpClient URL = new HttpClient();
List <KeyValuePair <string, string> > pairs = Pacote_AuthWEB.ListarAtributos();
var content = new FormUrlEncodedContent(pairs);
URL.Timeout = TimeSpan.FromSeconds(3);
Task <HttpResponseMessage> Conteudo = URL.PostAsync(_Servidor, content);
await Task.WhenAll(Conteudo);
if (Conteudo.Result.IsSuccessStatusCode)
{
string Dados = await Conteudo.Result.Content.ReadAsStringAsync();
Pacote_Base PB = JsonConvert.DeserializeObject <Pacote_Base>(Dados);
if (PB.Pacote != TipoPacote.Error)
{
Pacote_Autenticacao = JsonConvert.DeserializeObject <Pacote_Auth>(PB.Conteudo);;
Pacote_Autenticacao.Autenticado = true;
Pacote_Autenticacao.Error = false;
return(true);
}
else
{
Error = JsonConvert.DeserializeObject <Pacote_Error>(PB.Conteudo);
return(false);
}
}
else
{
Pacote_AuthWEB.Autenticado = false;
Pacote_AuthWEB.Error = true;
Error = new Pacote_Error();
Error.Error = true;
Error.Mensagem = "A conexão com o URi não foi estabelecida com sucesso!";
return(false);
}
}
catch (Exception e)
{
TratadorErros(e, GetType().Name);
//Classe Tratador de erros tem métodos para tratar erro a esse nível
return(false);
}
}
/**
* Data: 27/03/2019
* Método que recebe a requisição WEB do cliente, trata e a responde.
*/
private void Receber_Dados_Responder(object Dados)
{
Pacote_Error P_Error;
HttpListenerContext Conexao = Dados as HttpListenerContext;
HttpListenerRequest ObterConteudo = Conexao.Request;
StreamReader _Conteudo = new StreamReader(ObterConteudo.InputStream);
HttpListenerResponse ObterResposta = Conexao.Response;
try
{
string __Conteudo = _Conteudo.ReadLine();
/*-----------------------Processamento----------------------------*/
dynamic QTP = DeserializarPacote(__Conteudo);
switch (Base.Pacote)
{
case TipoPacote.Comando:
Pacote_Comando CMM = (Pacote_Comando)QTP; //Transforma string em um objeto da classe Pacote_Auth
bool _Autenticado = (bool)_Auth.HTML_Autenticado(CMM.Chave);
if (!_Autenticado)
{
throw new Exception("Usuário não autenticado.");
}
_GerenciadorCliente?.ConectarCliente(Conexao.Request.RemoteEndPoint, _Autenticado);
string Executar = _ResponderRequisicao(CMM);
if (Excecao)
{
P_Error = new Pacote_Error();
P_Error.Error = Excecao;
P_Error.Mensagem = DadosExcecao.Message;
P_Error.Tracer = DadosExcecao.StackTrace;
Executar = SerializarPacote(P_Error);
Excecao = false;
DadosExcecao = null;
}
Pacote_Comando PCT = new Pacote_Comando();
PCT.Resposta = Executar;
string DadosPacote = SerializarPacote(PCT);
//Obtém o Barramento de escrita com a cliente
ObterResposta.ContentLength64 = DadosPacote.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(DadosPacote), 0, DadosPacote.Length);
ObterResposta.Close();
break;
case TipoPacote.Echo:
Pacote_PingReplay RPY = new Pacote_PingReplay();
DadosPacote = SerializarPacote(RPY);
//Obtém o Barramento de escrita com a cliente
ObterResposta.ContentLength64 = DadosPacote.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(DadosPacote), 0, DadosPacote.Length);
ObterResposta.Close();
break;
default:
P_Error = new Pacote_Error();
P_Error.Error = true;
P_Error.Mensagem = "Esse tipo de pacote não existe.";
P_Error.Tracer = "";
DadosPacote = SerializarPacote(P_Error);
ObterResposta.ContentLength64 = DadosPacote.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(DadosPacote), 0, DadosPacote.Length);
ObterResposta.Close();
break;
}
}
catch (Exception e)
{
TratadorErros(e, this.GetType().Name);
P_Error = new Pacote_Error();
P_Error.Error = Excecao;
P_Error.Mensagem = DadosExcecao.Message;
P_Error.Tracer = DadosExcecao.StackTrace;
string Erros = SerializarPacote(P_Error);
ObterResposta.ContentLength64 = Erros.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(Erros), 0, Erros.Length);
ObterResposta.Close();
Excecao = false;
DadosExcecao = null;
}
}
/**
* Data: 27/02/2019
* Método que cria os barramentos de leitura e escrita, dá início ao diálogo inicial com os clientes e
* e dá início à conversa contínua com os cliente.
* Return: void
*/
private void Receber_Dados_Responder(object Dados)
{
StreamReader BarramentoLeitura;
StreamWriter BarramentoEscrita;
Pacote_Error P_Error;
try
{
TcpClient Clients = (TcpClient)Dados;
Func <string, bool> Falha = (G) => {
if (G == null)
{
EndPoint Fl = Clients.Client.RemoteEndPoint;
throw new Exception("Ocorreu uma falha no Servidor: " + Fl.ToString());
}
else
{
return(true);
}
};
using (NetworkStream Brrm = Clients.GetStream())
{
//Barramento de Leitura, após a abertura do socket
BarramentoLeitura = new StreamReader(Brrm);
//Obtém o Barramento de escrita com a cliente
BarramentoEscrita = new StreamWriter(Brrm);
string DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos);//Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
Pacote_PingEcho Echo = DeserializarPacote(DadosLidos);
/*Verifica se, cliente e servidor estão em sintonia, ocorreu algum erro*/
if (Echo.GetTipoPacote() != TipoPacote.Echo)
{
Pacote_PingReplay Replay = new Pacote_PingReplay();
Replay.Validado = false;
Replay.ObterTempo();
/*Confirma o recebimento, do cliente, inicialização.*/
BarramentoEscrita.WriteLine(SerializarPacote(Replay));
BarramentoEscrita.Flush();
throw new Exception("Falha de comunicação inicial: Cliente");
}
else
{
Pacote_PingReplay Replay = new Pacote_PingReplay();
Replay.Validado = true;
Replay.ObterTempo();
/*Confirma o recebimento, do cliente, inicialização.*/
BarramentoEscrita.WriteLine(SerializarPacote(Replay));
BarramentoEscrita.Flush();
}
DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos);//Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
string EnviarDadosCliente = TratarInicializacao(DadosLidos);
/*Informa ao cliente que os parâmetros de inicialização foram recebidos com sucesso.*/
BarramentoEscrita.WriteLine(EnviarDadosCliente);
BarramentoEscrita.Flush();
/*Processo de leitura do pacote de autenticação.*/
DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos); //Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
Pacote_Auth PTC = DeserializarPacote(DadosLidos); //Transforma string em um objeto da classe Pacote_Auth
PTC.TEndPointServer = TEndPoint;
PTC.DominioServidor = EDominio;
Pacote_Auth _Autenticado = _Auth?.AutenticarUsuario(PTC);
if (_Autenticado != null)
{
_GerenciadorCliente?.ConectarCliente(Clients.Client.RemoteEndPoint, _Autenticado);
EnviarDadosCliente = SerializarPacote(_Autenticado);
BarramentoEscrita.WriteLine(EnviarDadosCliente);
BarramentoEscrita.Flush();
//Leitura do barramento de dados do próximo tipo de pacote
DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos);//Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
dynamic QTP = DeserializarPacote(DadosLidos);
switch (Base.Pacote)
{
case TipoPacote.Comando:
Pacote_Comando CMM = (Pacote_Comando)QTP; //Transforma string em um objeto da classe Pacote_Auth
string Executar = _ResponderRequisicao(CMM);
if (Excecao)
{
P_Error = new Pacote_Error();
P_Error.Error = Excecao;
P_Error.Mensagem = DadosExcecao.Message;
P_Error.Tracer = DadosExcecao.StackTrace;
Executar = SerializarPacote(P_Error);
Excecao = false;
DadosExcecao = null;
}
Pacote_Comando PCT = new Pacote_Comando();
PCT.Resposta = Executar;
string DadosPacote = SerializarPacote(PCT);
//Obtém o Barramento de escrita com a cliente
BarramentoEscrita.WriteLine(DadosPacote);
BarramentoEscrita.Flush();
break;
case TipoPacote.Echo:
Pacote_PingReplay RPY = new Pacote_PingReplay();
DadosPacote = SerializarPacote(RPY);
//Obtém o Barramento de escrita com a cliente
BarramentoEscrita.WriteLine(DadosPacote);
BarramentoEscrita.Flush();
break;
case TipoPacote.File:
Pacote_File FILE = (Pacote_File)QTP;
string PathFile = FILE.Path;
int ReceiveBufferClienteSize = FILE.ReceiveBufferCLiente; //Armazena o tamanho do buffer de recepção do cliente;
int SendBufferClienteSize = FILE.SendBufferCliente; //Armazena o tamanho do buffer de envio do cliente;
int ReceiveBufferServerSize = Clients.ReceiveBufferSize; //Armazena o tamanho do buffer de recepção do cliente;
int SendBufferServerSize = Clients.SendBufferSize; //Armazena o tamanho do buffer de envio do cliente;
//Enviando dados dos buffers do servidor
FILE.ReceiveBufferServidor = ReceiveBufferServerSize; //Envia para o server a capacidade de recepção
FILE.SendBufferServidor = SendBufferServerSize; //envia para o server capacidade o tamanho de envio;
int BufferTransmissao = ReceiveBufferClienteSize > SendBufferServerSize ? SendBufferServerSize : ReceiveBufferClienteSize;
FILE.Existe = File.Exists(PathFile);
if (FILE.Existe)
{
using (FileStream EnviarArquivo = new FileStream(FILE.Path, FileMode.Open))
{
long TamanhoArquivoEnviar = EnviarArquivo.Length;
FILE.Lenght = TamanhoArquivoEnviar;
DadosPacote = SerializarPacote(FILE);
BarramentoEscrita.WriteLine(DadosPacote);
BarramentoEscrita.Flush();
byte[] T = new byte[BufferTransmissao];
using (BinaryWriter EVFILE = new BinaryWriter(Brrm))
{
int LoopEnvio = 0;
do
{
int TotalEnviado = EnviarArquivo.Read(T, 0, BufferTransmissao);
EVFILE.Write(T);
LoopEnvio += TotalEnviado;
} while (LoopEnvio <= TamanhoArquivoEnviar);
EnviarArquivo.Close();
}
}
}
else
{
}
break;
default:
P_Error = new Pacote_Error();
P_Error.Error = true;
P_Error.Mensagem = "Esse tipo de pacote não existe.";
P_Error.Tracer = "";
BarramentoEscrita.WriteLine(SerializarPacote(P_Error));
BarramentoEscrita.Flush();
break;
}
}
else
{ //Não existe mecanismo de autenticação.
_Autenticado = new Pacote_Auth {
Autenticado = false,
Error = true,
EMensagem = "O servidor não está configurado com nenhum processo de autenticação."
};
EnviarDadosCliente = SerializarPacote(_Autenticado);
BarramentoEscrita.WriteLine(EnviarDadosCliente);
BarramentoEscrita.Flush();
}
BarramentoLeitura.Close();
BarramentoEscrita.Close();
//Desconectar_Cliente("10.56.34.222","80");
Clients.Close();
}
}
catch (Exception e)
{
TratadorErros(e, this.GetType().Name);;
}
}
