Torniamo a parlare di C#; l'argomento riaguarda le Socket, e nello specifico la parte server.
Della parte cliente ne parlerò in altro articolo....
La classe che andremo a creare avrà due metodi: una per la connessione e una per lo spegnimento del server.
Il server sarà in ascolto su una porta specifica (cercate di non usare le porte più comuni tipo la 80 o la 21) ed useremo il protocollo TCP (questo dipende anche dall'uso che ne dovete fare).
Chiariamo subito che parliamo di Visual C++, quindi il programma userà le librerie di Windows e non sarà usabile su altri sistemi (ho in programma di creare una versione per Linux).
Nello specifico useremo le librerie Winsock.
Iniziamo a creare un progetto in Visual Studio di tipo VC++ console; aggiungete anche le librerie MFC in fase di creazione.
MFC ci servirà per implementare il multi-thread!
Una volta creato il progetto aprite il file stdafx.h e aggiungete queste righe:
#include <WinSock2.h>
#include <conio.h>
using namespace std;
Così facendo avremo disponibile il tutto per tutto il progetto.
Dopo di che creiamo una nuova classe che chiameremo Server.
Nel file di intestazione ci sarà questo:
#pragma once
using namespace std;
class Server {
public:
Server();
virtual ~Server();
UINT initConnection();
void stopConnection();
private:
SOCKET server;
SOCKET inAscolto;
};
In pratica abbiamo aggiunto due funzioni (una per la connessione e una per la disconnessione) e due variabili private.
Fin qui direi nulla di difficile.
In questo articolo avevo già parlato di come trasferire file tramite socket in Java.
Il problema però è che funziona solo se sia il client che il server stanno sulla stessa macchina.
Questo perchè ho fatto uso di oggetti File che sono solo una rappresentazione di un file o directory sul pc, ma che non sanno nulla circa il lror contenuto.
Se invece server e client devono stare su macchine diverse bisogna cambiare un pò la logica.
In sostanza il client deve leggere e inviare il file byte per byte; il server legge tutti i byte e li salva sul pc.
Non si può quindi usare File.
Questo è il client:
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
private final String HOST = "host";
private final int PORT = 9977;
public static void main(String[] args) {
Client c = new Client();
c.sendFile();
}
private void sendFile() {
try {
Socket socket = new Socket(HOST, PORT);
FileInputStream fis = new FileInputStream("path/to/file");
OutputStream out = socket.getOutputStream();
byte[] buf = new byte[1024];
int read;
while ((read = fis.read(buf)) != -1) {
out.write(buf, 0, read);
}
fis.close();
out.close();
socket.close();
} catch (UnknownHostException ex) {
System.out.println(ex.getMessage());
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
}
In pratica usiamo FileInputStream per leggere il contenuto del file, e OutputStream per inviare i byte.
Mi sono fatto un piccolo server socket in Java in grado di salvare i file in arrivo (nel mio caso un log creato da un altro programma).
Il problema era l'avvio, cioè doveva avviarsi in automatico.
Non sapendo come fare mi rivolto qui e abbiamo iniziato a fare vari tentativi, che vi riporto in sequenza.
Prima ho provato a mettere semplicemente il comando dentro rc.local:
cat /etc/rc.local
#!/bin/bash
#
# /etc/rc.local: Local multi-user startup script.
#
#/bin/sleep 15
#/etc/rc.d/sshd start
java -jar /home/casa/server.jar
Provando poi con exec prima del comando, o & alla fine.
Purtroppo non si avviava (nessun problema però se lo avviavo manualmente).
Uno dei punti forti di Java, si sa, è il netoworking con le Socket.
Java mette disposizione parecchie classi e metodi per usarle; qui vi spiego tre semplici classi da usare per inviare file tramite esse:
In verità le classi server e multi-threading sono strettamente collegate, mentre la parte client può anche stare separata (alias in un altro progetto).
Cominciamo col vedere la classe predisposta al multi-threading:
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
public class MTManager implements Runnable {
private final String DIR_SAVE = "path-file";
private Socket socket;
public MTManager(Socket socket) {
this.socket = socket;
}
public void run() {
try {
System.out.println("presa in carico nuova connessione da " + socket);
ObjectInputStream oin = new ObjectInputStream(socket.getInputStream());
File inFile = (File) oin.readObject();
File saveFile = new File(DIR_SAVE + "/" + inFile.getName()); // attenti al path, io sto Linux dove il separatore è /, mentre su Windows è \
save(inFile, saveFile);
} catch (Exception e) {
System.out.println(e.getMessage());
} finally {
try {
socket.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
private void save(File in, File out) throws IOException {
System.out.println(" --ricezione file " + in.getName());
System.out.println(" --dimensione file " + in.length());
FileInputStream fis = new FileInputStream(in);
FileOutputStream fos = new FileOutputStream(out);
byte[] buf = new byte[1024];
int i = 0;
while ((i = fis.read(buf)) != -1) {
fos.write(buf, 0, i);
}
fis.close();
fos.close();
System.out.println(" --ricezione completata");
}
}
Questa classe serve per istanziare un nuovo server ad ogni connessione, sennò si dovrebbe aspettare la conclusione dell'operazione per cominciarne una nuova.