package fr.istic.pr.echo;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import org.tinylog.Logger;

public class EchoServer
{
	private static final int PORT = 8080;

	public static void main(String[] args) throws IOException
	{
		try (ServerSocket serverSocket = new ServerSocket(PORT))
		{
			int clientNumber = 0;
			
			while (serverSocket.isBound())
			{
			    Logger.info("Attente d'une connexion d'un client");
				
				Socket clientSocket = serverSocket.accept();
				
				Logger.info("Client n°" + clientNumber + " (" + clientSocket.getInetAddress() + ") connecté.");
				
				ClientHandler clientHandler = new ClientHandlerBytes(clientSocket);
				//ClientHandler clientHandler = new ClientHandlerChar(clientSocket);
				
				clientHandler.handle();
				
				++clientNumber;
			}
		}
	}
}

package fr.istic.pr.echo;

import java.io.IOException;
import java.net.Socket;

import fr.istic.pr.utils.Utils;

public class ClientHandlerBytes implements ClientHandler
{
    private static final int SIZE = 8;
    private static final String SERVER_BROADCAST = "From server: ";
    
    private Socket clientSocket;

    public ClientHandlerBytes(Socket clientSocket)
    {
        this.clientSocket = clientSocket;
    }

    @Override
    public void handle() throws IOException
    {
        Utils.handleBytes(clientSocket, SIZE, SERVER_BROADCAST);
    }
}

public static void handleBytes(Socket clientSocket, int size, String serverBroadcast) throws IOException
{
    byte[] buffer = new byte[size];
    int length = 0;
    int totalSize = 0;
    StringBuilder message = new StringBuilder();

    InputStream in = clientSocket.getInputStream();
    OutputStream out = clientSocket.getOutputStream();

    do
    {
        // We need to catch the Exception here since we just want to exit the while
        // We need to do that in case the client exit without sending an empty message
        try
        {
            // Blocking
            length = in.read(buffer);
        }
        catch (IOException e)
        {
            // Connection reseted by the client (probably the client left netcat)
            length = -1;
        }

        totalSize += length;

        // We only put in the StringBuilder what we've read
        // this will prevent bad behavior on the last call to read 
        // in case lenght < SIZE
        // On Linux netcat probably send an empty message compared
        // to Windows where it totally close the connection
        if (length > 0)
        {
            message.append(new String(buffer).toCharArray(), 0, length);
        }

        // We've read all the data from the client so display it
        if (length < size && length > 0)
        {
            // To add "SERVER_BROADCAST" in the response
            StringBuilder sbTmp = new StringBuilder();

            String tmpMessage = message.toString();

            Logger.info("From client: " + tmpMessage);

            sbTmp.append(serverBroadcast);
            sbTmp.append(tmpMessage);

            // Send back the message
            // we only send the total length of what we've read
            out.write(sbTmp.toString().getBytes(), 0, serverBroadcast.length() + totalSize);

            // allocate a new StringBuilder since there is no proper way to clear it
            message = new StringBuilder();

            // Clear the total length of what we've read
            totalSize = 0;
        }
    } while (length != -1);

    // Also close the [In|Out]putStream
    clientSocket.close();
}

package fr.istic.pr.echomt;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import org.tinylog.Logger;

public class EchoServerMT
{
	private static final int PORT = 8080;
	private static final int NUMBER_THREADS = 4;

	public static void main(String[] args) throws IOException
	{
		try (ServerSocket serverSocket = new ServerSocket(PORT))
		{
			int clientNumber = 0;
			
			Executor threadPool = Executors.newFixedThreadPool(NUMBER_THREADS);
			
			while (serverSocket.isBound())
			{
				Logger.info("Attente d'une connexion d'un client");
				
				Socket clientSocket = serverSocket.accept();
				
				Logger.info("Client n°" + clientNumber + " (" + clientSocket.getInetAddress() + ") connecté.");
				
				//threadPool.execute(new ClientHandlerCharMT(clientSocket));
				threadPool.execute(new ClientHandlerBytesMT(clientSocket));

				++clientNumber;
			}
		}
	}
}

package fr.istic.pr.ping;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import org.tinylog.Logger;

public class HttpPing
{
    public static void main(String[] args) throws IOException
    {
        Logger.info(ping("www.example.com", 80));
    }

    public static PingInfo ping(String host, int port) throws IOException
    {
        PingInfo pingInfo = new PingInfo();
        long start = System.currentTimeMillis();
        
        StringBuilder reponse = new StringBuilder();
        String tmpLine = "";
        boolean firstLine = true;

        try (Socket socket = new Socket(host, port))
        {
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream());
            
            // Entête avec ligne vide pour validation
            out.print("GET / HTTP/1.1\r\n");
            out.print("Host: www.example.com\r\n");
            out.print("Connection: close\r\n");
            out.print("\r\n");
            out.flush();

            // Lecture de la réponse
            while ((tmpLine = in.readLine()) != null)
            {
                if (firstLine)
                {
                    String[] splittedLine = tmpLine.split(" ");
                    
                    pingInfo.setCode(Integer.valueOf(splittedLine[1]));
                    
                    firstLine = false;
                }
                
                reponse.append(tmpLine);
                reponse.append("\n");
            }
            
            // Affichage de la réponse
            Logger.info(reponse);
        }
        
        pingInfo.setTime(System.currentTimeMillis() - start);
        
        return pingInfo;
    }
}

...

SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();

try (Socket socket = factory.createSocket(host, port))
{
    BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    PrintWriter out = new PrintWriter(socket.getOutputStream());

    // Entête avec ligne vide pour validation
    out.print("GET / HTTP/1.0\r\n");
    out.print("Host: www.google.fr\r\n");
    out.print("Connection: close\r\n");
    out.print("\r\n");
    out.flush();

...

package fr.istic.pr.serveur;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import org.tinylog.Logger;


public class ServeurHTTP
{
    private static final int PORT = 8080;
    private static final int THREAD_NUMBER = 4;

    public static void main(String[] args) throws IOException
    {
        try (ServerSocket serverSocket = new ServerSocket(PORT))
        {
            int clientNumber = 0;
            
            Executor threadPool = Executors.newFixedThreadPool(THREAD_NUMBER);
            
            while (serverSocket.isBound())
            {
                Logger.info("Attente d'une connexion d'un client");
                
                Socket clientSocket = serverSocket.accept();
                
                Logger.info("Client n°" + clientNumber + " (" + clientSocket.getInetAddress() + ") connecté.");

                threadPool.execute(new HTTPHandler(clientSocket));

                ++clientNumber;
            }
        }
    }
}

package fr.istic.pr.serveur;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import org.tinylog.Logger;

public class HTTPHandler implements ClientHandler, Runnable
{
    private static final String WWW_FOLDER_PATH = "./www";
    private Socket socket;

    public HTTPHandler(Socket socket)
    {
        this.socket = socket;
    }

    @Override
    public void handle() throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
        PrintWriter out = new PrintWriter(this.socket.getOutputStream());

        String tmpLine = "";
        
        boolean firstLine = true;

        String methode = "";
        String fileName = "";
        //String httpVersion = "";
        
        // Lecture du header jusqu'à trouver une ligne vide
        while ((tmpLine = in.readLine()).length() != 0)
        {
            String[] splittedLine = tmpLine.split(" ");
            
            if (firstLine)
            {
                if (splittedLine.length != 3)
                {
                    doError(out);
                    
                    break;
                }
                
                methode = splittedLine[0];
                fileName = splittedLine[1];
                //httpVersion = splittedLine[2];

                firstLine = false;
            }
        }
        
        switch (methode)
        {
            case "GET":
                doGet(WWW_FOLDER_PATH + fileName, out);
                break;
            default:
                doError(out);
        }

        // Also close the [In|Out]putStream
        this.socket.close();
    }

    public void doGet(String pagepath, PrintWriter out) throws IOException
    {
        File file = new File(pagepath);

        if (!file.exists() || file.isDirectory())
        {
            send404(out);
            
            return;
        }
        
        StringBuilder htmlPage = new StringBuilder();

        try (BufferedReader buff = new BufferedReader(new FileReader(file)))
        {
            String line = "";
            

            while ((line = buff.readLine()) != null)
            {
                htmlPage.append(line);
            }
        }
        
        out.print("HTTP/1.1 200 OK\r\n");
        out.print("Content-Type: text/html; charset=utf-8\r\n");
        out.print("Content-Length: " + htmlPage.length() + "\r\n");
        out.print("Connection: close\r\n");
        out.print("\r\n");
        
        out.flush();
        
        out.print(htmlPage.toString());
        out.flush();
    }

    public void send404(PrintWriter out)
    {
        out.print("HTTP/1.1 404 Not Found\r\n");
        out.print("Content-Type: text/html; charset=utf-8\r\n");
        out.print("Content-Length: 0\r\n");
        out.print("\r\n");
        
        out.flush();
    }

    public void doError(PrintWriter out)
    {
        out.print("HTTP/1.1 405 Method Not Allowed\r\n");
        out.print("Content-Type: text/html; charset=utf-8\r\n");
        out.print("Allow: GET\r\n");
        out.print("Content-Length: 0\r\n");
        out.print("\r\n");
        
        out.flush();
    }

    @Override
    public void run()
    {
        try
        {
            handle();
        }
        catch (IOException e)
        {
            Logger.trace(e);
        }
    }
}