eu sou iniciante em java e meu professor de redes pediu para fazer um programa que fizesse um aplicativo que realize a comunicação entre cliente e servidor,
implementando funções para
- estabelecimento e encerramento da conexão;
- seqüenciamento das mensagens;
- controle de erros (detecção) através do algoritmo CRC-32
- envio de dados (arquivos texto que serão indicados no computador de origem)
Usando recursos das linguagens de programação C ou Java, implementar os módulos
cliente e servidor para um aplicativo que realize a transferência de arquivos do cliente
para o servidor. Este arquivo deverá ser lido pelo aplicativo e dividido em blocos de 50
bytes para que possa ser enviado.
O aplicativo cliente deverá fornecer o nome do arquivo a ser enviado como parâmetro.
Sintaxe:
cliente <endereço-IP-do-servidor>
Ex.:
./cliente 10.90.3.20 /etc/hosts
O formato do pacote a ser enviado é o seguinte:
Tipo Nro.
Seqüëncia
Num. Ack Tamanho dados Dados CRC-32
Onde
Campo
Tipo: 1 ? indica um pacote de dados
2 ? indica que um ACK está sendo transmitido
3 ? indica que um NACK está sendo transmitido
O campo Num. Seqüência: indica a ordem de envio
O campo Num. ACK: indica o número do ACK ou NACK
O campo Tamanho: indica o tamanho da área de dados.
O campo Controle erro: armazena o resultado do cálculo do controle de erro usado
O módulo servidor deverá aceitar conexões pela porta 7777 e calcular o CRC dos dados
que forem recebidos para compará-los com o CRC enviado a cada 50 bytes. Havendo
erro, ele deverá solicitar o reenvio do quadro por meio do algoritmo Stop-and-wait.
A rede que suportará a simulação é uma rede de alta velocidade e com taxa de erros
muito baixa, de forma que os pacotes gerados pela aplicação não serão espontaneamente
perdidos. Assim sendo, deve haver um módulo de inserção de falhas que force as
estações a enviar uma mensagem com ?erro?. Essa função deve inserir falhas
aleatoriamente nos bits do quadro e o protótipo deverá operar em dois modos distintos:
com e sem falhas.
Requisitos
- Deve ser utilizado socket stream (TCP) .
- Devem ser estabelecimentos procedimentos para contabilização de estatísticas
como: número de pacotes de dados enviados e recebidos e número de pacotes de controle
enviados e recebidos.
e como neste semestre eu não estou fazendo nenhuma cadeira de programação achei q não ia precisar aprofundar meus conhecimetos em java pelo menos esse semestre (ingênuo) eis que o meu querido professor de redes me dá este trabalho e aee eu me fuu… to bem destreinado em programação :s
mas eu consegui ajuda com uns colegas q fizeram algo semelhante semestre passado e saiu isto:
CLIENTE
import <a href="http://java.io">java.io</a>.<em>;
import <a href="http://java.net">java.net</a>.</em>;
import java.util.ArrayList;
import javax.swing.*;
import java.awt.event.*;
public class Client extends JFrame implements ActionListener {
private static final long serialVersionUID = 1L;
private JTextArea display;
private JButton send;
private JButton read;
private Socket conn;
private DataInputStream input;
private byte[] sendData = new byte[1024];
private DatagramPacket sendPacket;
private DatagramSocket clientSocket;
private InetAddress IPAddress;
private int pos = 0, soma, div; //pos = posição de sequenciamento, soma=para controle do tamanho do pacote; div = calculo de divisao dos pacotes
private JMenuBar menuBar;
private JMenu menuArquivo;
private JMenuItem carregar;
private JFileChooser abrir;
private String caminho, sentence, aux="";
ArrayList <String> lista = new ArrayList <String>(); //lista para criar o pacote com os parâmetros solicitados
java.util.Timer timer = new java.util.Timer();
public void criaPacote(String seq, String dados, String tam){ //Criar pacote
lista.add(0, "1");
lista.add(1,seq);
lista.add(2, "1");
lista.add(3,tam);
lista.add(4, dados);
}
public Client() throws SocketException, UnknownHostException {
super("Client");
carregar = new JMenuItem("Carregar");
abrir = new JFileChooser();
display = new JTextArea();
send = new JButton("Send");
read = new JButton("Read");
send.addActionListener(this);
read.addActionListener(this);
carregar.addActionListener(this);
JScrollPane scroll = new JScrollPane(display);
JPanel p = new JPanel();
menuBar = new JMenuBar();
menuArquivo = new JMenu("Arquivo");
p.add(menuBar);
menuBar.add(menuArquivo);
menuArquivo.add(carregar);
p.add(send);
getContentPane().add("North", menuBar);
getContentPane().add("Center", scroll);
getContentPane().add("South", p);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent ev) {
timer.cancel();
System.exit(0);
}
});
setSize(300, 500);
setVisible(true);
display.append("Conectando com o servidor....\n\n");
IPAddress = InetAddress.getByName("localhost"); //capturando endereço da maquina local
while(conn == null){ //laço para efetuar conexão mesmo se o cliente for aberto antes do servidor
try {
conn = new Socket(IPAddress,9876);
clientSocket = new DatagramSocket();
input = new DataInputStream(conn.getInputStream());
new DataOutputStream(conn.getOutputStream());
display.append("*** Conexão estabelecida....***\n\n");
ReadFromServer();
} catch (Exception ex) {
timer.cancel();
conn = null;;
}
}//fim do while
}
/****************************************************************************/
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals(“Send”)) {
try {
if (sentence == null){
display.append("\nNão há mensagem para enviar…\n");
}
else{
if (sentence.length() <= 35){ //tem que ser menor que 35 bytes, pois ao adicionarmos os campos,
// o tamanho do campo irá ultrapassar 50 bytes.
sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
clientSocket.send(sendPacket);
display.append("\nMensagem enviada…\n");
clientSocket.close();
}
else{ //aqui iremos dividir o pacote e capturar o texto em partes.
int y = 0;
int x = 0, n = 0;
while (y <= div)
{
for (x=n; x <= n+34;x++)
{
if (x == sentence.length()){
break;
}
else
aux = aux + sentence.charAt(x);
}
n=x;
criaPacote(Integer.toString(pos), aux, Integer.toString(aux.length()));
sendData = lista.toString().getBytes();
pos++;
y++;
aux="";
sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
clientSocket.send(sendPacket);
lista.clear();
sendData = null;
display.append("\nPacote " + y + " enviado...\n");
}
}clientSocket.close();
}} catch (Exception ex) {
timer.cancel();
JOptionPane.showMessageDialog(null, "Server não encontrado");
}
}// end if
/****************************************************************************/
//Carregar arquivo txt//
if (e.getActionCommand().equals("Carregar")){
abrir.setFileFilter(new javax.swing.filechooser.FileFilter(){
public boolean accept(File f){
return (f.getName().endsWith(".txt")) || f.isDirectory();
}
public String getDescription(){
return "*.txt";
}
}
);
int retorno = abrir.showOpenDialog(null);
if (retorno==JFileChooser.APPROVE_OPTION)
caminho = abrir.getSelectedFile().getPath();
FileReader reader = null;
try {
reader = new FileReader(caminho);
BufferedReader leitor = new BufferedReader(reader);
try {
sentence = leitor.readLine();
if (sentence.length() <= 35){
criaPacote("1", sentence, Integer.toString(sentence.length()));
sendData = lista.toString().getBytes();
}
else{
}
}
finally{
leitor.close();
pos = 0;
}
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
reader.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
div = sentence.length() / 35; //35 bytes de dados pois tem mais 15 caracteres que irão completar o pacote
if (sentence.length()% 35 ==0) //aqui iremos saber quantas vezes devemos adicionar mais espaço para completar
soma = 15*div; // com os campos solicitados para criar o pacote.
else
soma = 15*(div+1);
display.append("Arquivo carregado com sucesso" + "\nTamanho: " + sentence.length() +" bytes" +"\n");
display.append("Pacote criado, tamanho: " + (sentence.length() + soma) + " bytes\n");
display.append("Clique em SEND para transmiti-lo" + "\n");
} //end if
/****************************************************************************/
}
public void ReadFromServer() {
try {
String msg = input.readUTF();
display.append("\nServer: " + String.valueOf(msg) + "\n"); //recebendo confirmaçao do servidor
} catch (Exception ex) {
timer.cancel();
display.append("\n\n*** Conexão encerrada ***\n");
}
}
/****************************************************************************/
@SuppressWarnings("deprecation")
public static void main(String args[]) throws SocketException, UnknownHostException {
Client c = new Client();
c.show();
}
}
SERVIDOR
package Server;
import java.io.;
import java.net.;
import javax.swing.<em>;
import java.awt.event.</em>;
import java.util.*;
public class Server extends JFrame {
private static final long serialVersionUID = 1L;
private JTextArea display;
private ServerSocket socket;
private Socket conn;
private DataOutputStream output;
private DatagramSocket serverSocket;
private byte[] receiveData = new byte[1024];
private DatagramPacket receivePacket;
private String auxiliar="";
java.util.Timer timer = new java.util.Timer();
public Server() throws SocketException {
super("Server");
display = new JTextArea();
JScrollPane scroll = new JScrollPane(display);
getContentPane().add("Center", scroll);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent ev) {
timer.cancel();
System.exit(0);
}
});
setSize(600, 500);
setVisible(true);
receivePacket = new DatagramPacket(receiveData,receiveData.length);
serverSocket = new DatagramSocket(9876);
/****************************************************************************/
try {
socket = new ServerSocket(9876);
display.append("Aguardando conexão com o Client....\n\n");
conn = socket.accept();
new DataInputStream(conn.getInputStream());
output = new DataOutputStream(conn.getOutputStream());
display.append("*** Conexão estabelecida ***\n");
} catch (Exception ex) {
timer.cancel();
display.append("*** Conexão encerrada ***\n");
}
TimerTask task = new TimerTask() {
public void run() {
ReadFromClient();
}
};
timer.schedule(task, 0, 1000);
}
/****************************************************************************/
public void ReadFromClient() {
try {
serverSocket.receive(receivePacket);
String msg = new String(
receivePacket.getData());
if (receivePacket.getLength() < 50){ //apenas para o ultimo pacote, capturando somente os dados necessários.
for (int z = 0; z<receivePacket.getLength(); z++)
{
auxiliar = auxiliar + String.valueOf(msg.charAt(z));}
display.append( "\nClient: " + auxiliar);
}
else{
display.append("\n**Pacote recebido **\n");
display.append("\nClient: " + String.valueOf(msg));}
display.append("\nTamanho do pacote: " + receivePacket.getLength()+ " bytes" + "\n");
output.writeUTF("*** Mensagem recebida ***");
String conteudo = msg;
try{
// o true significa q o arquivo será constante
FileWriter x = new FileWriter("c:/teste.txt", true);
// criando nova linha e recuo no arquivo
x.write(conteudo); // armazena o texto no objeto x, que aponta para o arquivo
x.close(); // cria o arquivo
// JOptionPane.showMessageDialog(null,"Arquivo gravado com sucesso","Concluído",JOptionPane.INFORMATION_MESSAGE);
}
// em caso de erro apreenta mensagem abaixo
catch(Exception e){
JOptionPane.showMessageDialog(null,e.getMessage(),"Atenção",JOptionPane.WARNING_MESSAGE);
}
} catch (Exception ex) {
timer.cancel();
display.append("\n*** Conexão Encerrada ***\n");
}
}
/****************************************************************************/
@SuppressWarnings("deprecation")
public static void main(String args[]) throws SocketException {
Server s = new Server();
s.show();
}
}
alguma luz por favor? estou muito perdido
eu prometo que depois dessa eu nunca mais vou deixar de estudar programação…