kcavaill/Projet_COO_POO
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

dernière version de l'appli + nettoyage code serveur

Browse source
This commit is contained in:
m-gues 2021-02-14 22:58:07 +01:00
parent 862d469da1
commit dbd3861814
36 changed files with 1816 additions and 1353 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

200
POO/src/communication/CommunicationUDP.java
View file

@ -1,200 +0,0 @@
package communication;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import main.Observer;
import main.Utilisateur;
import messages.*;
public class CommunicationUDP extends Thread {
// public enum Mode {PREMIERE_CONNEXION, CHANGEMENT_PSEUDO, DECONNEXION};
private UDPClient client;
private int portServer;
private ArrayList<Integer> portOthers;
private ArrayList<Utilisateur> users = new ArrayList<Utilisateur>();
private Observer observer;
public CommunicationUDP(int portClient, int portServer, int[] portsOther) throws IOException {
this.portServer = portServer;
this.portOthers = this.getArrayListFromArray(portsOther);
new UDPServer(portServer, this).start();
this.client = new UDPClient(portClient);
}
private ArrayList<Integer> getArrayListFromArray(int ports[]) {
ArrayList<Integer> tmp = new ArrayList<Integer>();
for (int port : ports) {
tmp.add(port);
}
tmp.remove(Integer.valueOf(portServer));
return tmp;
}
public void setObserver (Observer obs) {
this.observer=obs;
}
protected boolean containsUserFromID(String id) {
for(Utilisateur u : users) {
if(u.getId().equals(id) ) {
return true;
}
}
return false;
}
public boolean containsUserFromPseudo(String pseudo) {
for(Utilisateur u : users) {
if(u.getPseudo().equals(pseudo) ) {
return true;
}
}
return false;
}
public int getPortFromPseudo(String pseudo) {
for(int i=0; i < users.size() ; i++) {
if(users.get(i).getPseudo().equals(pseudo) ) {
return users.get(i).getPort();
}
}
return -1;
}
private int getIndexFromID(String id) {
for(int i=0; i < users.size() ; i++) {
if(users.get(i).getId().equals(id) ) {
return i;
}
}
return -1;
}
private int getIndexFromIP(InetAddress ip) {
for(int i=0; i < users.size() ; i++) {
if(users.get(i).getIp().equals(ip)) {
return i;
}
}
return -1;
}
protected synchronized void addUser(String idClient, String pseudoClient, InetAddress ipClient, int port) throws IOException {
users.add(new Utilisateur(idClient, pseudoClient, ipClient, port));
observer.update(this, users);
}
protected synchronized void changePseudoUser(String idClient, String pseudoClient, InetAddress ipClient, int port) {
int index = getIndexFromID(idClient);
users.get(index).setPseudo(pseudoClient);
observer.update(this, users);
}
protected synchronized void removeUser(String idClient, String pseudoClient,InetAddress ipClient, int port) {
int index = getIndexFromIP(ipClient);
if( index != -1) {
users.remove(index);
}
observer.update(this, users);
}
public void removeAll(){
int oSize = users.size();
for(int i=0; i<oSize;i++) {
users.remove(0);
}
}
public void sendMessageConnecte() throws UnknownHostException, IOException {
for(int port : this.portOthers) {
try {
this.client.sendMessageUDP_local(new MessageSysteme(Message.TypeMessage.JE_SUIS_CONNECTE), port, InetAddress.getLocalHost());
} catch (MauvaisTypeMessageException e) {/*Si ça marche pas essayer là*/}
}
}
// Send the message "add,id,pseudo" to localhost on all the ports in
// "portOthers"
// This allows the receivers' agent (portOthers) to create or modify an entry with the
// data of this agent
//Typically used to notify of a name change
public void sendMessageInfoPseudo() throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf();
String pseudoSelf =self.getPseudo();
String idSelf = self.getId();
int portSelf = self.getPort();
Message msout = null;
try {
msout = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, pseudoSelf, idSelf, portSelf);
for(int port : this.portOthers) {
this.client.sendMessageUDP_local(msout, port, InetAddress.getLocalHost());
}
} catch (Exception e) {
e.printStackTrace();
}
}
//Same, but on only one port
//Typically used to give your current name and id to a newly arrived host
public void sendMessageInfoPseudo(int portOther) throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf();
try {
Message msout = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, self.getPseudo(), self.getId(), self.getPort());
this.client.sendMessageUDP_local(msout, portOther, InetAddress.getLocalHost());
} catch (MauvaisTypeMessageException e) {e.printStackTrace();}
}
// Send the message "del,id,pseudo" to localhost on all the ports in
// "portOthers"
// This allows the receivers' agent (portOthers) to delete the entry
// corresponding to this agent
public void sendMessageDelete() throws UnknownHostException, IOException {
for(int port : this.portOthers) {
try {
this.client.sendMessageUDP_local(new MessageSysteme(Message.TypeMessage.JE_SUIS_DECONNECTE), port, InetAddress.getLocalHost());
} catch (MauvaisTypeMessageException e) {}
}
}
//Pas encore adapte message
// private void sendIDPseudo_broadcast(String prefixe) throws UnknownHostException, IOException {
// Utilisateur self = Utilisateur.getSelf();
// String idSelf = self.getId();
// String pseudoSelf = self.getPseudo();
//
// String message = prefixe+","+idSelf + "," + pseudoSelf;
//
//
// this.client.sendMessageUDP_broadcast(message, this.portServer);
//
// }
// public synchronized void createSenderUDP(int port, Mode mode) throws SocketException {
// new SenderUDP(mode, port).start();
// }
}

57
POO/src/communication/TCPClient.java
View file

@ -1,57 +0,0 @@
package communication;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import main.Observer;
//import main.VueSession;
import messages.MessageTexte;
import messages.MauvaisTypeMessageException;
import messages.Message;
import messages.Message.TypeMessage;
public class TCPClient {
private Socket sockTCP;
private ObjectOutputStream output;
private TCPInputThread inputThread;
//Constructor from a TCP-client socket
public TCPClient(Socket sockTCP) throws IOException {
this.sockTCP = sockTCP;
this.output = new ObjectOutputStream(sockTCP.getOutputStream()) ;
ObjectInputStream input = new ObjectInputStream(sockTCP.getInputStream());
this.inputThread = new TCPInputThread(input);
}
//Constructor from an IP address and a port
public TCPClient(InetAddress addr, int port) throws IOException {
this(new Socket(addr, port)) ;
}
public void startInputThread() {
this.inputThread.start();
}
public void sendMessage(String contenu) throws IOException, MauvaisTypeMessageException {
System.out.println("dans write");
MessageTexte message = new MessageTexte(TypeMessage.TEXTE, contenu);
this.output.writeObject(message);
}
public void setObserverInputThread(Observer o) {
this.inputThread.setObserver(o);
}
}

65
POO/src/communication/TCPInputThread.java
View file

@ -1,65 +0,0 @@
package communication;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Arrays;
import main.Observer;
import messages.Message;
public class TCPInputThread extends Thread {
private ObjectInputStream input;
private boolean running;
private char[] buffer;
private Observer obs;
public TCPInputThread(ObjectInputStream input) {
this.input = input;
this.running = true;
this.buffer = new char[200];
}
@Override
public void run() {
while (this.running) {
try {
System.out.println("dans read");
Object o = this.input.readObject();
this.obs.update(this, o);
} catch (IOException | ClassNotFoundException e) {
this.interrupt();
//e.printStackTrace();
}
}
}
@Override
public void interrupt() {
try {
this.running = false;
this.input.close();
//this.obs.update(this, this.input);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void flushBuffer() {
Arrays.fill(this.buffer, '\u0000');
}
protected void setObserver(Observer o) {
this.obs = o;
}
}

40
POO/src/communication/TCPServer.java
View file

@ -1,40 +0,0 @@
package communication;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import main.Observer;
public class TCPServer extends Thread {
private ServerSocket sockListenTCP;
private Observer obs;
public TCPServer(int port) throws UnknownHostException, IOException {
this.sockListenTCP = new ServerSocket(port, 5, InetAddress.getLocalHost());
}
@Override
public void run() {
System.out.println("TCP running");
Socket sockAccept;
while(true) {
try {
sockAccept = this.sockListenTCP.accept();
this.obs.update(this, sockAccept);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public void addObserver(Observer obs) {
this.obs = obs;
}
}

41
POO/src/communication/UDPClient.java
View file

@ -1,41 +0,0 @@
package communication;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import messages.*;
public class UDPClient {
private DatagramSocket sockUDP;
private InetAddress broadcast;
public UDPClient(int port) throws SocketException, UnknownHostException {
this.sockUDP = new DatagramSocket(port);
InetAddress localHost = InetAddress.getLocalHost();
NetworkInterface networkInterface = NetworkInterface.getByInetAddress(localHost);
this.broadcast = networkInterface.getInterfaceAddresses().get(0).getBroadcast();
}
//Send a message casted as string to the specified port on localhost
protected void sendMessageUDP_local(Message message, int port, InetAddress clientAddress) throws IOException {
String messageString= message.toString();
DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), clientAddress, port);
this.sockUDP.send(outpacket);
}
// protected void sendMessageUDP_broadcast(String message, int port) throws IOException{
// String messageString=message.toString();
// DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), this.broadcast, port);
// this.sockUDP.send(outpacket);
// }
}

78
POO/src/communication/UDPServer.java
View file

@ -1,78 +0,0 @@
package communication;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Arrays;
import main.Utilisateur;
import messages.*;
public class UDPServer extends Thread {
private DatagramSocket sockUDP;
private CommunicationUDP commUDP;
private byte[] buffer;
public UDPServer(int port, CommunicationUDP commUDP) throws SocketException {
this.commUDP = commUDP;
this.sockUDP = new DatagramSocket(port);
this.buffer = new byte[256];
}
@Override
public void run() {
while (true) {
try {
DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length);
this.sockUDP.receive(inPacket);
String msgString = new String(inPacket.getData(), 0, inPacket.getLength());
Message msg = Message.stringToMessage(msgString);
switch(msg.getTypeMessage()) {
case JE_SUIS_CONNECTE :
if(Utilisateur.getSelf() != null) {
//System.out.println("first co");
int portClient = inPacket.getPort();
int portServer = portClient+1;
this.commUDP.sendMessageInfoPseudo(portServer);
}
break;
case INFO_PSEUDO :
if (this.commUDP.containsUserFromID(((MessageSysteme) msg).getId())) {
this.commUDP.changePseudoUser(((MessageSysteme) msg).getId(), ((MessageSysteme) msg).getPseudo(), inPacket.getAddress(),((MessageSysteme) msg).getPort());
}
else {
this.commUDP.addUser(((MessageSysteme) msg).getId(), ((MessageSysteme) msg).getPseudo(), inPacket.getAddress(), ((MessageSysteme) msg).getPort() );
System.out.println(((MessageSysteme) msg).getId()+", "+((MessageSysteme) msg).getPseudo());
}
break;
case JE_SUIS_DECONNECTE :
this.commUDP.removeUser( ((MessageSysteme) msg).getId() , ((MessageSysteme) msg).getPseudo(), inPacket.getAddress(), inPacket.getPort());
break;
default : //Others types of messages are ignored because they are supposed to be transmitted by TCP and not UDP
}
} catch (IOException e) {
System.out.println("receive exception");
}
}
}
}

29
POO/src/communication/filetransfer/FileTransferClient.java
View file

@ -1,31 +1,42 @@
package communication.filetransfer; package communication.filetransfer;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.net.UnknownHostException;
import java.util.ArrayList; import java.util.ArrayList;
import observers.ObserverInputMessage; import observers.ObserverInputMessage;
public class FileTransferClient { public class FileTransferClient {
private int port; private int port;
private ArrayList<File> files = null; private ArrayList<File> files;
private ObserverInputMessage obsInput; private ObserverInputMessage obsInput;
/**
public FileTransferClient(int port, ArrayList<File> filesToSend, ObserverInputMessage obs) throws UnknownHostException, IOException { * Create a client to transfer one or several files on the specified port of
* localhost. A new Thread is created for each file. The files are sent one by
* one to save bandwidth and avoid issues.
*
* @param port The port of localhost on which to send the files.
* @param filesToSend The file(s) to send.
* @param o The observer to notify each time a file is fully sent.
*/
public FileTransferClient(int port, ArrayList<File> filesToSend, ObserverInputMessage o) {
this.port = port; this.port = port;
this.files = filesToSend; this.files = filesToSend;
this.obsInput = obs; this.obsInput = o;
} }
/**
* Try to send every file on localhost on the specified port with a new thread.
* An observer is passed to the thread and it is notified each time a file is
* fully sent.
*
* @throws IOException
* @throws InterruptedException
*/
public void sendFiles() throws IOException, InterruptedException { public void sendFiles() throws IOException, InterruptedException {
for (File f : this.files) { for (File f : this.files) {
FileTransferSendingThread ftc = new FileTransferSendingThread(this.port, f, this.obsInput); FileTransferSendingThread ftc = new FileTransferSendingThread(this.port, f, this.obsInput);

32
POO/src/communication/filetransfer/FileTransferReceivingThread.java
View file

@ -1,6 +1,5 @@
package communication.filetransfer; package communication.filetransfer;
import java.io.File; import java.io.File;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
@ -19,16 +18,27 @@ public class FileTransferReceivingThread extends Thread {
private SocketChannel sockTransfert; private SocketChannel sockTransfert;
private ObserverInputMessage obsInput; private ObserverInputMessage obsInput;
public FileTransferReceivingThread(SocketChannel sock, ObserverInputMessage obs) { /**
* Create the thread that will receive one file during a file transfer. This
* allows users to write in the chat while sending/receiving files.
*
* @param sock The SocketChannel returned by ServerSocketChannel.accept().
* @param o The observer to notify once the file is fully received.
*/
public FileTransferReceivingThread(SocketChannel sock, ObserverInputMessage o) {
this.sockTransfert = sock; this.sockTransfert = sock;
this.obsInput = obs; this.obsInput = o;
} }
public void run() { public void run() {
try { try {
int nbByteRead = 0; int nbByteRead = 0;
// Buffer to receive a chunk of the file
ByteBuffer fileData = ByteBuffer.allocate(4 * FileTransferUtils.KB_SIZE); ByteBuffer fileData = ByteBuffer.allocate(4 * FileTransferUtils.KB_SIZE);
// InputStream to read the first object which is a message containing the name
// and size of the file
ObjectInputStream inputFileInformation = new ObjectInputStream( ObjectInputStream inputFileInformation = new ObjectInputStream(
this.sockTransfert.socket().getInputStream()); this.sockTransfert.socket().getInputStream());
@ -42,9 +52,10 @@ public class FileTransferReceivingThread extends Thread {
String filePath = FileTransferUtils.DOWNLOADS_RELATIVE_PATH + fileInfo[0]; String filePath = FileTransferUtils.DOWNLOADS_RELATIVE_PATH + fileInfo[0];
long fileSize = Long.parseLong(fileInfo[1]); long fileSize = Long.parseLong(fileInfo[1]);
// OutputStream to create the file if it does not exist
FileOutputStream fOutStream = new FileOutputStream(filePath); FileOutputStream fOutStream = new FileOutputStream(filePath);
// Channel to write the data received in the file
FileChannel fileWriter = fOutStream.getChannel(); FileChannel fileWriter = fOutStream.getChannel();
while (nbTotalBytesRead < fileSize && (nbByteRead = this.sockTransfert.read(fileData)) > 0) { while (nbTotalBytesRead < fileSize && (nbByteRead = this.sockTransfert.read(fileData)) > 0) {
@ -58,11 +69,13 @@ public class FileTransferReceivingThread extends Thread {
fileWriter.close(); fileWriter.close();
fOutStream.close(); fOutStream.close();
inputFileInformation.close();
// Process the message to display (thumbnails in the case of images) and notify
// the observer
Message mUpdate = FileTransferUtils.processMessageToDisplay(new File(filePath)); Message mUpdate = FileTransferUtils.processMessageToDisplay(new File(filePath));
mUpdate.setSender("other"); mUpdate.setSender("other");
this.obsInput.update(this, mUpdate); this.obsInput.updateInput(this, mUpdate);
} catch (IOException | ClassNotFoundException e) { } catch (IOException | ClassNotFoundException e) {
e.printStackTrace(); e.printStackTrace();
@ -75,6 +88,13 @@ public class FileTransferReceivingThread extends Thread {
} }
} }
/**
* Split the content of a message with the separator ";". This function is only
* used to read the name and the size of the file to receive.
*
* @param m message containing the file's information (name and size).
* @return An array with the file's name and the file's size respectively.
*/
private String[] processFileInformation(MessageFichier m) { private String[] processFileInformation(MessageFichier m) {
return m.getContenu().split(";"); return m.getContenu().split(";");
} }

26
POO/src/communication/filetransfer/FileTransferSendingThread.java
View file

@ -23,27 +23,40 @@ public class FileTransferSendingThread extends Thread{
private File file; private File file;
private ObserverInputMessage obsInput; private ObserverInputMessage obsInput;
public FileTransferSendingThread(int port, File fileToSend, ObserverInputMessage obs) throws IOException { /**
* Create the thread that will send one file during a file transfer. This allows
* users to write in the chat while sending/receiving files.
*
* @param port The port on localhost to which the SocketChannel will connect.
* @param fileToSend The file to send.
* @param o The observer to notify once the file is fully received.
* @throws IOException if the socket's creation fails.
*/
public FileTransferSendingThread(int port, File fileToSend, ObserverInputMessage o) throws IOException {
SocketChannel sock = SocketChannel.open(); SocketChannel sock = SocketChannel.open();
SocketAddress addr = new InetSocketAddress(port); SocketAddress addr = new InetSocketAddress(port);
sock.connect(addr); sock.connect(addr);
this.sockTransfert = sock; this.sockTransfert = sock;
this.file = fileToSend; this.file = fileToSend;
this.obsInput = obs; this.obsInput = o;
} }
public void run() { public void run() {
try { try {
// Buffer to send a chunk of the file
ByteBuffer fileData = ByteBuffer.allocate(4 * FileTransferUtils.KB_SIZE); ByteBuffer fileData = ByteBuffer.allocate(4 * FileTransferUtils.KB_SIZE);
// OutputStream to write the first object which is a message containing the name
// and size of the file
ObjectOutputStream outputFileInformation = new ObjectOutputStream( ObjectOutputStream outputFileInformation = new ObjectOutputStream(
this.sockTransfert.socket().getOutputStream()); this.sockTransfert.socket().getOutputStream());
// Channel to read the data of the file
FileChannel fileReader = FileChannel.open(Paths.get(file.getPath())); FileChannel fileReader = FileChannel.open(Paths.get(file.getPath()));
String str = file.getName() + ";" + file.getTotalSpace(); String str = file.getName() + ";" + file.getTotalSpace();
// Send file datas (name + size); // Send file data (name + size);
outputFileInformation.writeObject(new MessageFichier(TypeMessage.FICHIER, str, "")); outputFileInformation.writeObject(new MessageFichier(TypeMessage.FICHIER, str, ""));
while (fileReader.read(fileData) > 0) { while (fileReader.read(fileData) > 0) {
@ -53,10 +66,13 @@ public class FileTransferSendingThread extends Thread{
} }
fileReader.close(); fileReader.close();
outputFileInformation.close();
// Process the message to display (thumbnails in the case of images) and notify
// the observer
Message mUpdate = FileTransferUtils.processMessageToDisplay(this.file); Message mUpdate = FileTransferUtils.processMessageToDisplay(this.file);
mUpdate.setSender("Moi"); mUpdate.setSender("Moi");
this.obsInput.update(this, mUpdate); this.obsInput.updateInput(this, mUpdate);
} catch (IOException | MauvaisTypeMessageException e) { } catch (IOException | MauvaisTypeMessageException e) {
e.printStackTrace(); e.printStackTrace();
@ -69,6 +85,4 @@ public class FileTransferSendingThread extends Thread{
} }
} }
} }

19
POO/src/communication/filetransfer/FileTransferServer.java
View file

@ -8,21 +8,32 @@ import java.nio.channels.SocketChannel;
import observers.ObserverInputMessage; import observers.ObserverInputMessage;
public class FileTransferServer extends Thread { public class FileTransferServer extends Thread {
private ServerSocketChannel sockFTListen; private ServerSocketChannel sockFTListen;
private int nbFile; private int nbFile;
private ObserverInputMessage obsInput; private ObserverInputMessage obsInput;
/**
public FileTransferServer(int nbFile, ObserverInputMessage obs) throws UnknownHostException, IOException { * Create a server to transfer one or several files. A new socket and thread is
* created for each file to receive. The files are received one by one to save
* bandwidth and avoid issues.
*
* @param nbFile The number of file to receive.
* @param o The observer to notify once a file is fully received.
* @throws UnknownHostException
* @throws IOException
*/
public FileTransferServer(int nbFile, ObserverInputMessage o) throws UnknownHostException, IOException {
this.sockFTListen = ServerSocketChannel.open(); this.sockFTListen = ServerSocketChannel.open();
this.sockFTListen.socket().bind(new InetSocketAddress(0)); this.sockFTListen.socket().bind(new InetSocketAddress(0));
this.nbFile = nbFile; this.nbFile = nbFile;
this.obsInput = obs; this.obsInput = o;
} }
/**
* @return The port binded to the ServerSocketChannel.
*/
public int getPort() { public int getPort() {
return this.sockFTListen.socket().getLocalPort(); return this.sockFTListen.socket().getLocalPort();
} }

42
POO/src/communication/filetransfer/FileTransferUtils.java
View file

@ -23,11 +23,21 @@ import messages.Message.TypeMessage;
public class FileTransferUtils { public class FileTransferUtils {
// Relative path of the folder where are put the received files
protected static final String DOWNLOADS_RELATIVE_PATH = "../downloads/"; protected static final String DOWNLOADS_RELATIVE_PATH = "../downloads/";
protected static final ArrayList<String> IMAGE_EXTENSIONS = new ArrayList<String>(List.of("tif","tiff","bmp","jpg","jpeg","gif", "png", "eps", "svg")); protected static final ArrayList<String> IMAGE_EXTENSIONS = new ArrayList<String>(
List.of("tif", "tiff", "bmp", "jpg", "jpeg", "gif", "png", "eps", "svg"));
protected static final int KB_SIZE = 1024; protected static final int KB_SIZE = 1024;
/**
* Process what to display on the chat depending on the file sent/received. A
* thumbnail will be created in the case of an image, A String with the file's
* name will be created otherwise.
*
* @param file The file to process.
* @return A message of which content is either a thumbnail or the file's name.
* @throws IOException
*/
protected static MessageFichier processMessageToDisplay(File file) throws IOException { protected static MessageFichier processMessageToDisplay(File file) throws IOException {
String nameFile = file.getName(); String nameFile = file.getName();
String extension = processFileExtension(nameFile); String extension = processFileExtension(nameFile);
@ -45,15 +55,17 @@ public class FileTransferUtils {
} }
try { try {
//return new MessageFichier(type, contenu, extension);
return new MessageFichier(type, contenu, extension); return new MessageFichier(type, contenu, extension);
} catch (MauvaisTypeMessageException e) { } catch (MauvaisTypeMessageException e) {
System.out.println("Should never go in");
e.printStackTrace(); e.printStackTrace();
} }
return null; return null;
} }
/**
* @param fileName The name of the file (with its extension).
* @return The extension of the file.
*/
protected static String processFileExtension(String fileName) { protected static String processFileExtension(String fileName) {
String extension = ""; String extension = "";
@ -64,7 +76,10 @@ public class FileTransferUtils {
return extension; return extension;
} }
/**
* @param image A buffered image.
* @return A thumbnail of the image.
*/
private static BufferedImage createThumbnail(BufferedImage image) { private static BufferedImage createThumbnail(BufferedImage image) {
float w = image.getWidth(); float w = image.getWidth();
float ratio = (w > 150) ? (150F / w) : 1; float ratio = (w > 150) ? (150F / w) : 1;
@ -72,6 +87,12 @@ public class FileTransferUtils {
return scaled; return scaled;
} }
/**
* @param img A buffered image.
* @param extension The extension of the image.
* @return The base64 encoded string corresponding to the given image.
* @throws IOException
*/
private static String encodeImage(BufferedImage img, String extension) throws IOException { private static String encodeImage(BufferedImage img, String extension) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream(); ByteArrayOutputStream bos = new ByteArrayOutputStream();
ImageIO.write(img, extension, bos); ImageIO.write(img, extension, bos);
@ -80,7 +101,11 @@ public class FileTransferUtils {
return imgString; return imgString;
} }
/**
* @param imageString The base64 encoded string of an image.
* @return A buffered image corresponding to the given base64 encoded string.
* @throws IOException
*/
public static BufferedImage decodeImage(String imageString) throws IOException { public static BufferedImage decodeImage(String imageString) throws IOException {
byte[] imgData = Base64.getDecoder().decode(imageString); byte[] imgData = Base64.getDecoder().decode(imageString);
InputStream is = new ByteArrayInputStream(imgData); InputStream is = new ByteArrayInputStream(imgData);
@ -89,6 +114,7 @@ public class FileTransferUtils {
return img; return img;
} }
// Used to scale an image with a given ratio
private static BufferedImage scale(BufferedImage source, double ratio) { private static BufferedImage scale(BufferedImage source, double ratio) {
int w = (int) (source.getWidth() * ratio); int w = (int) (source.getWidth() * ratio);
int h = (int) (source.getHeight() * ratio); int h = (int) (source.getHeight() * ratio);
@ -110,6 +136,10 @@ public class FileTransferUtils {
return image; return image;
} }
/**
* Create the folder with the path "DOWNLOADS_RELATIVE_PATH" if it does not
* exist.
*/
public static void createDownloads() { public static void createDownloads() {
File downloads = new File(FileTransferUtils.DOWNLOADS_RELATIVE_PATH); File downloads = new File(FileTransferUtils.DOWNLOADS_RELATIVE_PATH);

59
POO/src/communication/tcp/TCPClient.java
View file

@ -5,63 +5,86 @@ import java.io.IOException;
import java.io.ObjectInputStream; import java.io.ObjectInputStream;
import java.io.ObjectOutputStream; import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket; import java.net.Socket;
import observers.ObserverInputMessage; import observers.ObserverInputMessage;
import observers.ObserverSocketState; import observers.ObserverSocketState;
import messages.MauvaisTypeMessageException;
import messages.Message; import messages.Message;
public class TCPClient { public class TCPClient {
private Socket sockTCP; private Socket sockTCP;
private ObjectOutputStream output; private ObjectOutputStream output;
private ObjectInputStream input;
private TCPInputThread inputThread; private TCPInputThread inputThread;
/**
* Create a TCP client from an existing socket. It will ensure the transmission
* of messages during a session. Two ObjectStream are created in order to
* read/write messages. The ObjectInputStream is given to a thread to read
* continuously the incoming message and allowing the user to write a message
* anytime.
*
* @param sockTCP
* @throws IOException
*/
public TCPClient(Socket sockTCP) throws IOException { public TCPClient(Socket sockTCP) throws IOException {
this.sockTCP = sockTCP; this.sockTCP = sockTCP;
this.output = new ObjectOutputStream(sockTCP.getOutputStream()); this.output = new ObjectOutputStream(sockTCP.getOutputStream());
ObjectInputStream input = new ObjectInputStream(sockTCP.getInputStream()); this.input = new ObjectInputStream(sockTCP.getInputStream());
this.inputThread = new TCPInputThread(input); this.inputThread = new TCPInputThread(this.input);
}
public TCPClient(InetAddress addr, int port) throws IOException {
this(new Socket(addr, port));
} }
/**
* Start the thread that will continuously read from the socket.
*/
public void startInputThread() { public void startInputThread() {
this.inputThread.start(); this.inputThread.start();
} }
/**
public void sendMessage(Message message) throws IOException, MauvaisTypeMessageException { * Send a message by writing it in the ObjectOutputStream of the socket
System.out.println("dans write"); *
* @param message
* @throws IOException
*/
public void sendMessage(Message message) throws IOException {
this.output.writeObject(message); this.output.writeObject(message);
} }
/**
* Set the observer to notify when a message is received
*
* @param o The observer
*/
public void setObserverInputThread(ObserverInputMessage o) { public void setObserverInputThread(ObserverInputMessage o) {
this.inputThread.setObserverInputMessage(o); this.inputThread.setObserverInputMessage(o);
} }
/**
* Set the observer to notify when the session is closed/the communication is
* broken.
*
* @param o The observer
*/
public void setObserverSocketState(ObserverSocketState o) { public void setObserverSocketState(ObserverSocketState o) {
this.inputThread.setObserverSocketState(o); this.inputThread.setObserverSocketState(o);
} }
/**
* Method used when the session is over. Set all attributes' references to null,
* interrupt the inputThread and close the streams and the socket.
*/
public void destroyAll() { public void destroyAll() {
try { try {
if (!this.sockTCP.isClosed()) { if (!this.sockTCP.isClosed()) {
this.inputThread.setObserverSocketState(null);
this.inputThread.interrupt();
this.input.close();
this.output.close(); this.output.close();
this.sockTCP.close(); this.sockTCP.close();
this.inputThread.setObserverSocketState(null);
} }
this.inputThread = null; this.inputThread = null;
this.sockTCP = null; this.sockTCP = null;

31
POO/src/communication/tcp/TCPInputThread.java
View file

@ -12,7 +12,12 @@ public class TCPInputThread extends Thread {
private ObserverInputMessage obsInput; private ObserverInputMessage obsInput;
private ObserverSocketState obsState; private ObserverSocketState obsState;
public TCPInputThread(ObjectInputStream input) { /**
* Create the thread used to read the messages
*
* @param input The ObjectInputStream to read data from
*/
protected TCPInputThread(ObjectInputStream input) {
this.input = input; this.input = input;
this.running = true; this.running = true;
} }
@ -22,10 +27,9 @@ public class TCPInputThread extends Thread {
while (this.running) { while (this.running) {
try { try {
System.out.println("dans read");
Object o = this.input.readObject(); Object o = this.input.readObject();
this.obsInput.update(this, o); // Notify the observer a message was received
this.obsInput.updateInput(this, o);
} catch (IOException | ClassNotFoundException e) { } catch (IOException | ClassNotFoundException e) {
this.interrupt(); this.interrupt();
@ -37,34 +41,35 @@ public class TCPInputThread extends Thread {
@Override @Override
public void interrupt() { public void interrupt() {
try {
// Stop the thread // Stop the thread
this.running = false; this.running = false;
// Close the stream and the socket // Close the stream and the socket
this.input.close();
if (this.obsState != null) { if (this.obsState != null) {
// Send an update to the controller // Send an update to the controller
this.obsState.updateSocketState(this, true); this.obsState.updateSocketState(this, true);
} }
// Set every attribute to null so they're collected by the GC // Set every attribute to null so they're collected by the GC
this.obsInput = null; this.obsInput = null;
this.obsState = null; this.obsState = null;
this.input = null; this.input = null;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} }
/**
* Set the observer to notify when a message is received
*
* @param o The observer
*/
protected void setObserverInputMessage(ObserverInputMessage o) { protected void setObserverInputMessage(ObserverInputMessage o) {
this.obsInput = o; this.obsInput = o;
} }
/**
* Set the observer to notify when the session is cut/closed.
*
* @param o The observer
*/
protected void setObserverSocketState(ObserverSocketState o) { protected void setObserverSocketState(ObserverSocketState o) {
this.obsState = o; this.obsState = o;
} }

29
POO/src/communication/tcp/TCPServer.java
View file

@ -8,36 +8,45 @@ import java.net.UnknownHostException;
import observers.ObserverInputMessage; import observers.ObserverInputMessage;
public class TCPServer extends Thread { public class TCPServer extends Thread {
//****
public static int PORT_SERVER = 7000;
private ServerSocket sockListenTCP; private ServerSocket sockListenTCP;
private ObserverInputMessage obs; private ObserverInputMessage obsInput;
/**
* Create a TCP Server on the specified port. It will listen continuously for
* connections in order to create new sessions between users.
*
* @param port The port on which the server will listen
* @throws UnknownHostException
* @throws IOException
*/
public TCPServer(int port) throws UnknownHostException, IOException { public TCPServer(int port) throws UnknownHostException, IOException {
this.sockListenTCP = new ServerSocket(port, 50, InetAddress.getLocalHost()); this.sockListenTCP = new ServerSocket(port, 50, InetAddress.getLocalHost());
} }
@Override @Override
public void run() { public void run() {
System.out.println("TCP running");
Socket sockAccept; Socket sockAccept;
while (true) { while (true) {
try { try {
sockAccept = this.sockListenTCP.accept(); sockAccept = this.sockListenTCP.accept();
this.obs.update(this, sockAccept);
// Notify the observer of the new connexion
this.obsInput.updateInput(this, sockAccept);
} catch (IOException e) { } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
} }
} }
public void addObserver(ObserverInputMessage obs) { /**
this.obs = obs; * Set the observer to notify when a new connection is made.
*
* @param o The observer
*/
public void addObserver(ObserverInputMessage o) {
this.obsInput = o;
} }
} }

213
POO/src/communication/udp/CommunicationUDP.java
View file

@ -2,7 +2,6 @@ package communication.udp;
import java.io.IOException; import java.io.IOException;
import java.net.InetAddress; import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException; import java.net.UnknownHostException;
import java.util.ArrayList; import java.util.ArrayList;
@ -13,18 +12,23 @@ import observers.ObserverUserList;
public class CommunicationUDP extends Thread { public class CommunicationUDP extends Thread {
// ****
protected static int PORT_SERVEUR = 3000;
// ****
protected static int PORT_CLIENT = 2000;
private UDPClient client; private UDPClient client;
private UDPServer server; private UDPServer server;
private int portServer; private int portServer;
private ArrayList<Integer> portOthers; private ArrayList<Integer> portOthers;
private ArrayList<Utilisateur> users = new ArrayList<Utilisateur>(); private ArrayList<Utilisateur> users = new ArrayList<Utilisateur>();
private ObserverUserList observer; private ObserverUserList obsList;
/**
* Create the object that will manage the userlist and contain a UDPClient and a
* UDPServer. Since the applications will run on localhost, it needs to know
* every UDPServer ports used in order to replicate a broadcast behaviour.
*
* @param portClient The port number for the UDPClient
* @param portServer The port number for the UDPServer
* @param portsOther The port numbers for every other application's UDPServer
* @throws IOException
*/
public CommunicationUDP(int portClient, int portServer, int[] portsOther) throws IOException { public CommunicationUDP(int portClient, int portServer, int[] portsOther) throws IOException {
this.portServer = portServer; this.portServer = portServer;
this.portOthers = this.getArrayListFromArray(portsOther); this.portOthers = this.getArrayListFromArray(portsOther);
@ -33,14 +37,13 @@ public class CommunicationUDP extends Thread {
this.client = new UDPClient(portClient); this.client = new UDPClient(portClient);
} }
// **** /**
public CommunicationUDP() throws SocketException, UnknownHostException { * Create an ArrayList<Integer> from the int[] list of every servers' ports and
this.portServer = PORT_SERVEUR; * remove the port of this application UDPServer.
this.server = new UDPServer(portServer, this); *
this.server.start(); * @param ports The UDPServer port numbers.
this.client = new UDPClient(PORT_CLIENT); * @return An ArrayList<Integer> without the port of this UDPServer.
} */
private ArrayList<Integer> getArrayListFromArray(int ports[]) { private ArrayList<Integer> getArrayListFromArray(int ports[]) {
ArrayList<Integer> tmp = new ArrayList<Integer>(); ArrayList<Integer> tmp = new ArrayList<Integer>();
for (int port : ports) { for (int port : ports) {
@ -51,42 +54,83 @@ public class CommunicationUDP extends Thread {
return tmp; return tmp;
} }
public void setObserver(ObserverUserList obs) { /**
this.observer = obs; * Set the observer to notify when the userList is updated.
*
* @param obs The observer
*/
public void setObserver(ObserverUserList o) {
this.obsList = o;
} }
// -------------- USER LIST UPDATE FUNCTION --------------// // -------------- USER LIST UPDATE METHODS -------------- //
protected synchronized void addUser(String idClient, String pseudoClient, InetAddress ipClient, int port) /**
throws IOException { * Add a new user to the userlist and notify the observer.
users.add(new Utilisateur(idClient, pseudoClient, ipClient, port)); *
* @param idClient
* @param pseudoClient
* @param ipClient
* @param port
* @throws UnknownHostException
*/
protected synchronized void addUser(String idUser, String pseudoUser, InetAddress ipUser, int portTCPServer)
throws UnknownHostException {
users.add(new Utilisateur(idUser, pseudoUser, ipUser, portTCPServer));
this.sendUpdate(); this.sendUpdate();
} }
protected synchronized void changePseudoUser(String idClient, String pseudoClient, InetAddress ipClient, int port) { /**
int index = getIndexFromID(idClient); * Change the pseudo of an user and notify the observer if it exists in the
users.get(index).setPseudo(pseudoClient); * userlist. Do nothing otherwise.
*
* @param idClient
* @param pseudoClient
* @param ipClient
* @param port
*/
protected synchronized void changePseudoUser(String idUser, String pseudoUser, InetAddress ipUser,
int portTCPServer) {
int index = getIndexFromID(idUser);
if (index != -1) {
users.get(index).setPseudo(pseudoUser);
this.sendUpdate(); this.sendUpdate();
} }
protected synchronized void removeUser(String idClient, String pseudoClient, InetAddress ipClient, int port) { }
int index = getIndexFromID(idClient);
/**
* Remove an user from the userlist and notify the observer if it exists in the
* userlist. Do nothing otherwise.
*
* @param idUser
* @param pseudoUser
* @param ipUser
* @param portTCPServer
*/
protected synchronized void removeUser(String idUser, String pseudoUser, InetAddress ipUser, int portTCPServer) {
int index = getIndexFromID(idUser);
if (index != -1) { if (index != -1) {
users.remove(index); users.remove(index);
}
this.sendUpdate(); this.sendUpdate();
} }
public void removeAll() {
int oSize = users.size();
for (int i = 0; i < oSize; i++) {
users.remove(0);
} }
public void removeAllUsers() {
this.users.clear();
} }
// -------------- CHECKERS -------------- // // -------------- CHECKERS -------------- //
/**
* Check if there is an user in the list that has the given id.
*
* @param id The user's id.
* @return True if the user is in the list
* false otherwise.
*/
protected boolean containsUserFromID(String id) { protected boolean containsUserFromID(String id) {
for (Utilisateur u : users) { for (Utilisateur u : users) {
if (u.getId().equals(id)) { if (u.getId().equals(id)) {
@ -96,6 +140,13 @@ public class CommunicationUDP extends Thread {
return false; return false;
} }
/**
* Check if there is an user in the list that has the given pseudo.
*
* @param pseudo The user's pseudo.
* @return True if the user is in the list
* false otherwise.
*/
public boolean containsUserFromPseudo(String pseudo) { public boolean containsUserFromPseudo(String pseudo) {
for (Utilisateur u : users) { for (Utilisateur u : users) {
if (u.getPseudo().toLowerCase().equals(pseudo)) { if (u.getPseudo().toLowerCase().equals(pseudo)) {
@ -108,6 +159,13 @@ public class CommunicationUDP extends Thread {
// -------------- GETTERS -------------- // // -------------- GETTERS -------------- //
/**
* Return the user with the given pseudo if it exists in the list.
*
* @param pseudo The user's pseudo.
* @return The user if it exists in the list.
* null otherwise.
*/
public Utilisateur getUserFromPseudo(String pseudo) { public Utilisateur getUserFromPseudo(String pseudo) {
for (int i = 0; i < users.size(); i++) { for (int i = 0; i < users.size(); i++) {
if (users.get(i).getPseudo().equals(pseudo)) { if (users.get(i).getPseudo().equals(pseudo)) {
@ -117,6 +175,13 @@ public class CommunicationUDP extends Thread {
return null; return null;
} }
/**
* Return the index of the user with the given id if it exists in the list.
*
* @param id The user's id.
* @return The index if the user exists in the list.
* null otherwise
*/
private int getIndexFromID(String id) { private int getIndexFromID(String id) {
for (int i = 0; i < users.size(); i++) { for (int i = 0; i < users.size(); i++) {
if (users.get(i).getId().equals(id)) { if (users.get(i).getId().equals(id)) {
@ -126,81 +191,105 @@ public class CommunicationUDP extends Thread {
return -1; return -1;
} }
// -------------- SEND MESSAGES --------------// // -------------- SEND MESSAGES METHODS -------------- //
/**
* Send a message indicating this application's user is connected to every
* UDPServer.
*
* @throws UnknownHostException
* @throws IOException
*/
public void sendMessageConnecte() throws UnknownHostException, IOException { public void sendMessageConnecte() throws UnknownHostException, IOException {
for (int port : this.portOthers) {
try { try {
this.client.sendMessageUDP_local(new MessageSysteme(Message.TypeMessage.JE_SUIS_CONNECTE), port, Message msgOut = new MessageSysteme(Message.TypeMessage.JE_SUIS_CONNECTE);
InetAddress.getLocalHost()); for (int port : this.portOthers) {
this.client.sendMessageUDP_local(msgOut, port);
}
} catch (MauvaisTypeMessageException e) { } catch (MauvaisTypeMessageException e) {
/* Si ça marche pas essayer là */} e.printStackTrace();
} }
} }
// Send the message "add,id,pseudo" to localhost on all the ports in /**
// "portOthers" * Send a message containing this application's user's data to every UDPServer.
// This allows the receivers' agent (portOthers) to create or modify an entry * This method is used to first add this user in the userlist or update this
// with the * user's pseudo.
// data of this agent *
// Typically used to notify of a name change * @throws UnknownHostException
* @throws IOException
*/
public void sendMessageInfoPseudo() throws UnknownHostException, IOException { public void sendMessageInfoPseudo() throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf(); Utilisateur self = Utilisateur.getSelf();
try { try {
Message msgOut = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, self.getPseudo(), self.getId(), self.getPort()); Message msgOut = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, self.getPseudo(), self.getId(),
self.getPort());
for (int port : this.portOthers) { for (int port : this.portOthers) {
this.client.sendMessageUDP_local(msgOut, port, InetAddress.getLocalHost()); this.client.sendMessageUDP_local(msgOut, port);
} }
} catch (Exception e) { } catch (MauvaisTypeMessageException e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
// Same, but on only one port /**
// Typically used to give your current name and id to a newly arrived host * Send a message containing this application's user's data to one user. This
* method is used to answer back when receiving a message with the type
* "JE_SUIS_CONNECTE"
*
* @param portOther The port on which the other user's UDPServer is listening
* @throws UnknownHostException
* @throws IOException
*/
public void sendMessageInfoPseudo(int portOther) throws UnknownHostException, IOException { public void sendMessageInfoPseudo(int portOther) throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf(); Utilisateur self = Utilisateur.getSelf();
try { try {
Message msgOut = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, self.getPseudo(), self.getId(), Message msgOut = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, self.getPseudo(), self.getId(),
self.getPort()); self.getPort());
this.client.sendMessageUDP_local(msgOut, portOther, InetAddress.getLocalHost()); this.client.sendMessageUDP_local(msgOut, portOther);
} catch (MauvaisTypeMessageException e) { } catch (MauvaisTypeMessageException e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
// Send the message "del,id,pseudo" to localhost on all the ports in /**
// "portOthers" * Send a message indicating this application's user is disconnected to every
// This allows the receivers' agent (portOthers) to delete the entry * UDPServer.
// corresponding to this agent *
* @throws UnknownHostException
* @throws IOException
*/
public void sendMessageDelete() throws UnknownHostException, IOException { public void sendMessageDelete() throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf(); Utilisateur self = Utilisateur.getSelf();
try { try {
Message msgOut = new MessageSysteme(Message.TypeMessage.JE_SUIS_DECONNECTE, self.getPseudo(), self.getId(), self.getPort()); Message msgOut = new MessageSysteme(Message.TypeMessage.JE_SUIS_DECONNECTE, self.getPseudo(), self.getId(),
self.getPort());
for (int port : this.portOthers) { for (int port : this.portOthers) {
this.client.sendMessageUDP_local(msgOut, port, InetAddress.getLocalHost()); this.client.sendMessageUDP_local(msgOut, port);
} }
} catch (MauvaisTypeMessageException e) { } catch (MauvaisTypeMessageException e) {
e.printStackTrace();
} }
} }
// -------------- OTHERS -------------- //
/**
* Notify the observer with the updated list
*/
private void sendUpdate() { private void sendUpdate() {
if(this.observer != null) { if (this.obsList != null) {
this.observer.updateList(this, users); this.obsList.updateList(this, users);
} }
} }
public void destroyAll() {
this.client.destroyAll();
this.server.interrupt();
}
} }

50
POO/src/communication/udp/UDPClient.java
View file

@ -4,40 +4,52 @@ import java.io.IOException;
import java.net.DatagramPacket; import java.net.DatagramPacket;
import java.net.DatagramSocket; import java.net.DatagramSocket;
import java.net.InetAddress; import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException; import java.net.SocketException;
import java.net.UnknownHostException; import java.net.UnknownHostException;
import messages.*; import messages.*;
public class UDPClient { class UDPClient {
private DatagramSocket sockUDP; private DatagramSocket sockUDP;
private InetAddress broadcast;
/**
* Create an UDP client on the specified port. It will be used to notify the
* other users of this application's user state (Connected/Disconnected/Pseudo
* changed).
*
* @param port
* @throws SocketException
* @throws UnknownHostException
*/
public UDPClient(int port) throws SocketException, UnknownHostException { public UDPClient(int port) throws SocketException, UnknownHostException {
this.sockUDP = new DatagramSocket(port); this.sockUDP = new DatagramSocket(port);
InetAddress localHost = InetAddress.getLocalHost();
NetworkInterface networkInterface = NetworkInterface.getByInetAddress(localHost);
this.broadcast = networkInterface.getInterfaceAddresses().get(0).getBroadcast();
System.out.println(this.broadcast);
System.out.println(InetAddress.getLocalHost());
} }
/**
* Send a message to the specified port on localhost.
*
* @param message
* @param port
* @throws IOException
*/
protected void sendMessageUDP_local(Message message, int port) throws IOException {
sendMessageUDP(message, port, InetAddress.getLocalHost());
}
//Send a message casted as string to the specified port on localhost /**
protected void sendMessageUDP_local(Message message, int port, InetAddress clientAddress) throws IOException { * Send a message to the given address on the specified port.
*
* @param message
* @param port
* @param clientAddress
* @throws IOException
*/
private void sendMessageUDP(Message message, int port, InetAddress clientAddress) throws IOException {
String messageString = message.toString(); String messageString = message.toString();
DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), clientAddress, port); DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), clientAddress,
port);
this.sockUDP.send(outpacket); this.sockUDP.send(outpacket);
}
protected void destroyAll() {
this.sockUDP.close();
this.sockUDP = null;
this.broadcast = null;
} }
} }

31
POO/src/communication/udp/UDPServer.java
View file

@ -8,13 +8,22 @@ import java.net.SocketException;
import main.Utilisateur; import main.Utilisateur;
import messages.*; import messages.*;
public class UDPServer extends Thread { class UDPServer extends Thread {
private DatagramSocket sockUDP; private DatagramSocket sockUDP;
private CommunicationUDP commUDP; private CommunicationUDP commUDP;
private byte[] buffer; private byte[] buffer;
private boolean running; private boolean running;
/**
* Create an UDP Server on the specified port. It will be used to read the
* other users states (Connected/Disconnected/Pseudo).
*
* @param port
* @param commUDP
* @throws SocketException
*/
public UDPServer(int port, CommunicationUDP commUDP) throws SocketException { public UDPServer(int port, CommunicationUDP commUDP) throws SocketException {
this.running = true; this.running = true;
this.commUDP = commUDP; this.commUDP = commUDP;
@ -28,11 +37,13 @@ public class UDPServer extends Thread {
try { try {
//When a datagram is received, converts its data in a Message
DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length); DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length);
this.sockUDP.receive(inPacket); this.sockUDP.receive(inPacket);
String msgString = new String(inPacket.getData(), 0, inPacket.getLength()); String msgString = new String(inPacket.getData(), 0, inPacket.getLength());
Message msg = Message.stringToMessage(msgString); Message msg = Message.stringToMessage(msgString);
//Depending on the type of the message
switch (msg.getTypeMessage()) { switch (msg.getTypeMessage()) {
case JE_SUIS_CONNECTE: case JE_SUIS_CONNECTE:
@ -40,34 +51,38 @@ public class UDPServer extends Thread {
int portClient = inPacket.getPort(); int portClient = inPacket.getPort();
int portServer = portClient+1; int portServer = portClient+1;
//Answer back with this application's user data
this.commUDP.sendMessageInfoPseudo(portServer); this.commUDP.sendMessageInfoPseudo(portServer);
} }
break; break;
case INFO_PSEUDO: case INFO_PSEUDO:
MessageSysteme m = (MessageSysteme) msg; MessageSysteme m = (MessageSysteme) msg;
//Update the userlist with the data received (Add the user or update it)
if (this.commUDP.containsUserFromID(m.getId())) { if (this.commUDP.containsUserFromID(m.getId())) {
this.commUDP.changePseudoUser(m.getId(), m.getPseudo(), inPacket.getAddress(), m.getPort()); this.commUDP.changePseudoUser(m.getId(), m.getPseudo(), inPacket.getAddress(), m.getPort());
} else { } else {
this.commUDP.addUser(m.getId(), m.getPseudo(), inPacket.getAddress(), m.getPort()); this.commUDP.addUser(m.getId(), m.getPseudo(), inPacket.getAddress(), m.getPort());
System.out.println(m.getId() + ", " + m.getPseudo());
} }
break; break;
case JE_SUIS_DECONNECTE: case JE_SUIS_DECONNECTE:
this.commUDP.removeUser(((MessageSysteme) msg).getId(), ((MessageSysteme) msg).getPseudo(),
inPacket.getAddress(), inPacket.getPort()); MessageSysteme m2 = (MessageSysteme) msg;
//Remove the user from the userlist
this.commUDP.removeUser(m2.getId(), m2.getPseudo(), inPacket.getAddress(), m2.getPort());
break; break;
default: // Others types of messages are ignored because they are supposed to be //Do nothing
// transmitted by TCP and not UDP default:
} }
} catch (IOException e) { } catch (IOException e) {
System.out.println("receive exception"); e.printStackTrace();
} }
} }

51
POO/src/connexion/ControleurConnexion.java
View file

@ -13,6 +13,7 @@ import standard.VueStandard;
public class ControleurConnexion implements ActionListener{ public class ControleurConnexion implements ActionListener{
//Controller state : either DEBUT at initialization or ID_OK if the user has signed in
private enum Etat {DEBUT, ID_OK}; private enum Etat {DEBUT, ID_OK};
private VueConnexion vue; private VueConnexion vue;
@ -23,16 +24,22 @@ public class ControleurConnexion implements ActionListener{
private SQLiteManager sqlManager; private SQLiteManager sqlManager;
private VueStandard vueStd; private VueStandard vueStd;
/**
* Create and initialize the object in charge of monitoring all actions depending on what the user do.
*
* @param vue : associated instance of VueConnexion
* @param numtest : on local mode, allows you to choose which port to use. Integer between 0 and 3
*
*/
public ControleurConnexion(VueConnexion vue, int numtest) { public ControleurConnexion(VueConnexion vue, int numtest) {
this.vue = vue; this.vue = vue;
this.etat = Etat.DEBUT; this.etat = Etat.DEBUT;
this.username = ""; this.username = "";
this.sqlManager = new SQLiteManager(0); this.sqlManager = new SQLiteManager(0);
this.vueStd = null; this.vueStd = null;
//Pour les tests, changer pour un truc plus général quand on change CommunicationUDP
//Note : 3334 est le port du serveur de présence int[] portServer = {2209, 2309, 2409, 2509};
int[] portServer = {2209, 2309, 2409, 2509, 3334};
try { try {
switch(numtest) { switch(numtest) {
case 0 : case 0 :
@ -55,13 +62,12 @@ public class ControleurConnexion implements ActionListener{
this.comUDP = new CommunicationUDP(2408, 2409, portServer); this.comUDP = new CommunicationUDP(2408, 2409, portServer);
this.portTCP = 7040; this.portTCP = 7040;
} }
//
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace();
} }
} }
@Override @Override
public void actionPerformed(ActionEvent e) { public void actionPerformed(ActionEvent e) {
String pseudo; String pseudo;
@ -76,32 +82,24 @@ public class ControleurConnexion implements ActionListener{
inputOK = (res == 1); inputOK = (res == 1);
} catch (SQLException e2) { } catch (SQLException e2) {
e2.printStackTrace();
} }
if (inputOK) { if (inputOK) {
this.etat=Etat.ID_OK; this.etat=Etat.ID_OK;
//Envoi broadcast du message "JeSuisActif" et, attente du retour de la liste des utilisateurs actifs //Broadcast "JE_SUIS_CONNECTE" message and waits for the other devices' answers
try { try {
comUDP.sendMessageConnecte(); comUDP.sendMessageConnecte();
} catch (UnknownHostException e1) { } catch (IOException e2) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} }
try { try {
Thread.sleep(2); Thread.sleep(2);
} catch (InterruptedException e1) { } catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} }
//Mise en place de la demande du pseudo //setup pseudo ask
this.vue.setConnexionInfo(""); this.vue.setConnexionInfo("");
this.vue.removePasswordPanel(); this.vue.removePasswordPanel();
@ -118,26 +116,22 @@ public class ControleurConnexion implements ActionListener{
else { else {
pseudo = vue.getUsernameValue(); pseudo = vue.getUsernameValue();
//Recherche dans la liste locale des utilisateurs connectes, report sur inputOK //Search in the local list of active users id the chosen pseudo is already in use
inputOK = !this.comUDP.containsUserFromPseudo(pseudo); inputOK = !this.comUDP.containsUserFromPseudo(pseudo);
if(pseudo.equals("")) { if(pseudo.equals("")) {
this.vue.setConnexionInfo("Votre pseudonyme doit contenir au moins 1 caratère"); this.vue.setConnexionInfo("Votre pseudonyme doit contenir au moins 1 caratère");
}else if (inputOK) { }else if (inputOK) {
//Reglage de l'utilisateur //setup Utilisateur "self" static attribute
try { try {
Utilisateur.setSelf(this.username, pseudo, "localhost", this.portTCP); Utilisateur.setSelf(this.username, pseudo, "localhost", this.portTCP);
} catch (UnknownHostException e2) { } catch (UnknownHostException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
} }
//Broadcast du pseudo //broadcast new pseudo
try { try {
this.comUDP.sendMessageInfoPseudo(); this.comUDP.sendMessageInfoPseudo();
} catch (UnknownHostException e1) { } catch (UnknownHostException e1) {
e1.printStackTrace();
} catch (IOException e1) { } catch (IOException e1) {
e1.printStackTrace();
} }
try { try {
@ -145,7 +139,6 @@ public class ControleurConnexion implements ActionListener{
this.vue.setVisible(false); this.vue.setVisible(false);
this.setVueStandard(); this.setVueStandard();
} catch (IOException e1) { } catch (IOException e1) {
e1.printStackTrace();
} }
} }
else this.vue.setConnexionInfo("Ce nom est déjà utilisé, veuillez en choisir un autre"); else this.vue.setConnexionInfo("Ce nom est déjà utilisé, veuillez en choisir un autre");
@ -153,6 +146,12 @@ public class ControleurConnexion implements ActionListener{
} }
// ----- SETTING & RESETTING VIEW ----- //
/**
* Create a new VueStandard instance and give it the hand.
*
*/
private void setVueStandard() throws IOException { private void setVueStandard() throws IOException {
if(this.vueStd == null) { if(this.vueStd == null) {
this.vueStd = new VueStandard("Standard", this.comUDP, this.portTCP, this.sqlManager, this.vue); this.vueStd = new VueStandard("Standard", this.comUDP, this.portTCP, this.sqlManager, this.vue);
@ -164,6 +163,10 @@ public class ControleurConnexion implements ActionListener{
} }
} }
/**
* Restore the associated instance of VueConnexion to its initial state
*
*/
private void resetView() { private void resetView() {
this.etat = Etat.DEBUT; this.etat = Etat.DEBUT;
this.vue.addPasswordPanel(); this.vue.addPasswordPanel();

114
POO/src/connexion/VueConnexion.java
View file

@ -1,6 +1,6 @@
package connexion; package connexion;
//Importe les librairies //Import librairies
import java.awt.*; import java.awt.*;
import javax.swing.*; import javax.swing.*;
@ -10,7 +10,8 @@ import main.Vue;
public class VueConnexion extends Vue { public class VueConnexion extends Vue {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
//Elements vue
//Graphical elements
private JButton boutonValider; private JButton boutonValider;
private JTextField inputUsername; private JTextField inputUsername;
private JPasswordField inputPassword; private JPasswordField inputPassword;
@ -20,40 +21,53 @@ public class VueConnexion extends Vue {
private JPanel main; private JPanel main;
private JPanel panelPassword; private JPanel panelPassword;
//Controleur //Controller
private ControleurConnexion controle; private ControleurConnexion controle;
//penser à enlever le numtest /**
* Create and initialize the view SWING window that will be used during the connection phase.
* Doing so, it also creates the controller that will monitor all changes during the connection phase.
*
* @param numtest : to be passed down to the controller
*
*/
public VueConnexion(int numtest) { public VueConnexion(int numtest) {
super("Connexion"); super("Connexion");
controle = new ControleurConnexion(this, numtest); controle = new ControleurConnexion(this, numtest);
//Creation fenetre //Window creation
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(400, 300); this.setSize(400, 300);
this.setLocationRelativeTo(null); this.setLocationRelativeTo(null);
//Ajout elements //Adding graphical elements
ajouterElements(); ajouterElements();
//Regle le bouton par défaut //Setting default button
this.getRootPane().setDefaultButton(boutonValider); this.getRootPane().setDefaultButton(boutonValider);
this.inputUsername.setText(SQLiteManager.hardcodedNames[numtest]+numtest); this.inputUsername.setText(SQLiteManager.hardcodedNames[numtest]+numtest);
this.inputPassword.setText("aze1$"+SQLiteManager.hardcodedNames[numtest].charAt(0)+numtest); this.inputPassword.setText("aze1$"+SQLiteManager.hardcodedNames[numtest].charAt(0)+numtest);
//Affiche la fenetre //Display window
this.setVisible(true); this.setVisible(true);
} }
// ----- ADDING ELEMENTS TO AND REMOVING ELEMENTS FROM THE MAIN WINDOW ----- //
/**
* Add various graphical elements to the main window : used when initializing the window
*/
private void ajouterElements() { private void ajouterElements() {
//Creation panel //Create a panel
main = new JPanel(new GridLayout(4,1)); main = new JPanel(new GridLayout(4,1));
JPanel panelUsername = new JPanel(new GridLayout(1, 2)); JPanel panelUsername = new JPanel(new GridLayout(1, 2));
this.panelPassword = new JPanel(new GridLayout(1, 2)); this.panelPassword = new JPanel(new GridLayout(1, 2));
//Cree les elements //Create various elements
this.connexionInfo = new JLabel(""); this.connexionInfo = new JLabel("");
this.inputUsername = new JTextField(); this.inputUsername = new JTextField();
@ -70,10 +84,10 @@ public class VueConnexion extends Vue {
boutonValider = new JButton("Valider"); boutonValider = new JButton("Valider");
//Le controleur guette les evenements du bouton //Make it so the controller is monitoring the button
boutonValider.addActionListener(controle); boutonValider.addActionListener(controle);
//Ajoute les elements
panelUsername.add(this.labelUsername); panelUsername.add(this.labelUsername);
panelUsername.add(this.inputUsername); panelUsername.add(this.inputUsername);
@ -82,7 +96,6 @@ public class VueConnexion extends Vue {
this.panelPassword.add(this.inputPassword); this.panelPassword.add(this.inputPassword);
main.add(connexionInfo); main.add(connexionInfo);
main.add(panelUsername); main.add(panelUsername);
main.add(this.panelPassword); main.add(this.panelPassword);
@ -91,29 +104,6 @@ public class VueConnexion extends Vue {
this.add(main); this.add(main);
} }
//Getters et setters
protected void setConnexionInfo(String text) {
this.connexionInfo.setText(text);
}
protected void setTextUsernameField(String text) {
this.labelUsername.setText(text);
}
protected String getUsernameValue() {
return this.inputUsername.getText();
}
protected char[] getPasswordValue() {
return this.inputPassword.getPassword();
}
protected void resetUsernameField() {
this.inputUsername.setText("");
}
protected void removePasswordPanel() { protected void removePasswordPanel() {
this.main.remove(2); this.main.remove(2);
} }
@ -122,6 +112,58 @@ public class VueConnexion extends Vue {
this.main.add(this.panelPassword, 2); this.main.add(this.panelPassword, 2);
} }
//----- GETTERS -----//
/**
* Returns the current value of the field inputUsername
*
* @return current value of the field inputUsername as String
*/
protected String getUsernameValue() {
return this.inputUsername.getText();
}
/**
* Returns the current value of the field inputPassword
*
* @return current value of the field inputPassword as String
*/
protected char[] getPasswordValue() {
return this.inputPassword.getPassword();
}
//----- SETTERS -----//
/**
* Set a displayed message that will give the user information (for example if they entered a wrong password)
*
* @param text : message to display as String
*/
protected void setConnexionInfo(String text) {
this.connexionInfo.setText(text);
}
/**
* Set the label for the inputUsername fiel
*
* @param text : label to display as String
*/
protected void setTextUsernameField(String text) {
this.labelUsername.setText(text);
}
/**
* Empty the inputUsername text field
*/
protected void resetUsernameField() {
this.inputUsername.setText("");
}
/**
* Empty the inputPassword text field
*/
protected void resetPasswordField() { protected void resetPasswordField() {
this.inputPassword.setText(""); this.inputPassword.setText("");
} }

68
POO/src/database/SQLiteCreateTables.java
View file

@ -6,7 +6,19 @@ import java.sql.Statement;
class SQLiteCreateTables { class SQLiteCreateTables {
/**
* Create the user table if it does not exist in the database.
* An user is characterized by :
* - an unique username,
* - a password salt,
* - a database_key salt,
* - a password hash encrypted by the database_key,
* - the encrypted database_key,
* - the initialization vector used to encrypt the database key.
*
* @param connec The opened connection to the database.
* @throws SQLException
*/
protected static void createTableUser(Connection connec) throws SQLException { protected static void createTableUser(Connection connec) throws SQLException {
String createTableUser = "CREATE TABLE IF NOT EXISTS user (\r\n" String createTableUser = "CREATE TABLE IF NOT EXISTS user (\r\n"
+ " id INTEGER PRIMARY KEY AUTOINCREMENT,\r\n" + " id INTEGER PRIMARY KEY AUTOINCREMENT,\r\n"
@ -16,29 +28,49 @@ class SQLiteCreateTables {
+ " db_datakey_salt BLOB,\r\n" + " db_datakey_salt BLOB,\r\n"
+ " encrypted_pwd_hashsalt BLOB,\r\n" + " encrypted_pwd_hashsalt BLOB,\r\n"
+ " encrypted_db_datakey BLOB,\r\n" + " encrypted_db_datakey BLOB,\r\n"
+ " iv_datakey BLOB\r\n" + " iv_datakey BLOB\r\n" + ");";
+ ");";
Statement stmt = connec.createStatement(); Statement stmt = connec.createStatement();
stmt.execute(createTableUser); stmt.execute(createTableUser);
} }
/**
* Create the conversation table if it does not exist in the database.
* A conversation is characterized by :
* - the id of the user who sends the messages,
* - the id of the user who receives the messages,
* - an initialization vector used to encrypt the conversation's messages.
*
* During an session between two users, two conversations are created.
*
* @param connec The opened connection to the database.
* @throws SQLException
*/
protected static void createTableConversation(Connection connec) throws SQLException { protected static void createTableConversation(Connection connec) throws SQLException {
String createTableConversation = "CREATE TABLE IF NOT EXISTS conversation (\r\n" String createTableConversation = "CREATE TABLE IF NOT EXISTS conversation (\r\n"
+ " id_conversation INTEGER PRIMARY KEY AUTOINCREMENT,\r\n" + " id_conversation INTEGER PRIMARY KEY AUTOINCREMENT,\r\n"
+ " id_emetteur INTEGER REFERENCES user (id) \r\n" + " id_sender INTEGER REFERENCES user (id) \r\n" + " NOT NULL,\r\n"
+ " NOT NULL,\r\n" + " id_receiver INTEGER REFERENCES user (id) \r\n" + " NOT NULL,\r\n"
+ " id_recepteur INTEGER REFERENCES user (id) \r\n" + " iv_conversation BLOB NOT NULL" + ");";
+ " NOT NULL,\r\n"
+" iv_conversation BLOB NOT NULL"
+ ");";
Statement stmt = connec.createStatement(); Statement stmt = connec.createStatement();
stmt.execute(createTableConversation); stmt.execute(createTableConversation);
} }
/**
* Create the message table if it does not exist in the database.
* A message is characterized by :
* - the id of the conversation it belongs,
* - the id of its type,
* - its content,
* - the date when it was emitted,
* - its extension if it is a file (text or image).
*
* @param connec The opened connection to the database.
* @throws SQLException
*/
protected static void createTableMessage(Connection connec) throws SQLException { protected static void createTableMessage(Connection connec) throws SQLException {
String createTableMessage = "CREATE TABLE IF NOT EXISTS message (\r\n" String createTableMessage = "CREATE TABLE IF NOT EXISTS message (\r\n"
+ " id_message INTEGER PRIMARY KEY AUTOINCREMENT,\r\n" + " id_message INTEGER PRIMARY KEY AUTOINCREMENT,\r\n"
@ -48,15 +80,27 @@ class SQLiteCreateTables {
+ " NOT NULL,\r\n" + " NOT NULL,\r\n"
+ " content BLOB,\r\n" + " content BLOB,\r\n"
+ " date INTEGER NOT NULL,\r\n" + " date INTEGER NOT NULL,\r\n"
+ " extension VARCHAR (20) \r\n" + " extension VARCHAR (20) \r\n" + ");\r\n";
+ ");\r\n";
Statement stmt = connec.createStatement(); Statement stmt = connec.createStatement();
stmt.execute(createTableMessage); stmt.execute(createTableMessage);
} }
/**
* Create the (message) type table if it does not exist and insert the different
* types of message in the database.
* A type is characterized by :
* - a label.
*
* This table only exists because the type "enumeration" does not exist in SQLite.
* It is a static table that contains the different types of message stored in the database.
*
* @param connec The opened connection to the database.
* @throws SQLException
*/
protected static void createTableType(Connection connec) throws SQLException { protected static void createTableType(Connection connec) throws SQLException {
String createTableType = "CREATE TABLE IF NOT EXISTS type (\r\n" + " id_type INTEGER PRIMARY KEY,\r\n" String createTableType = "CREATE TABLE IF NOT EXISTS type (\r\n"
+ " id_type INTEGER PRIMARY KEY,\r\n"
+ " label VARCHAR (20) NOT NULL\r\n" + ");"; + " label VARCHAR (20) NOT NULL\r\n" + ");";
Statement stmt = connec.createStatement(); Statement stmt = connec.createStatement();

84
POO/src/database/SQLiteEncprytion.java
View file

@ -1,84 +0,0 @@
package database;
import java.util.Base64;
import java.util.Random;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import java.security.spec.*;
class SQLiteEncprytion {
private static final Random RANDOM = new SecureRandom();
private static final int ITERATIONS = 10000;
private static final int KEY_LENGTH = 256;
protected static final String encryptAlgorithm = "AES/CBC/PKCS5Padding";
protected static byte[] getNextSalt() {
byte[] salt = new byte[24];
RANDOM.nextBytes(salt);
return salt;
}
protected static byte[] hash(char[] password, byte[] salt) {
return SQLiteEncprytion.getKey(password, salt).getEncoded();
}
protected static SecretKey getKey(char[] password, byte[] salt) {
PBEKeySpec saltpwd = new PBEKeySpec(password, salt, ITERATIONS, KEY_LENGTH);
try {
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
SecretKey tmp = skf.generateSecret(saltpwd);
SecretKey key = new SecretKeySpec(tmp.getEncoded(), "AES");
return key;
} catch (InvalidKeySpecException | NoSuchAlgorithmException e) {
e.printStackTrace();
} finally {
saltpwd.clearPassword();
}
return null;
}
public static IvParameterSpec generateIv() {
byte[] iv = new byte[16];
new SecureRandom().nextBytes(iv);
return new IvParameterSpec(iv);
}
protected static byte[] encrypt(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.ENCRYPT_MODE, key, iv);
byte[] cipherText = cipher.doFinal(input);
return Base64.getEncoder().encode(cipherText);
}
protected static byte[] decryptByte(String algorithm, byte[] cipherText, SecretKey key, IvParameterSpec iv) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.DECRYPT_MODE, key, iv);
byte[] plainText = cipher.doFinal(Base64.getDecoder().decode(cipherText));
return plainText;
}
protected static String decryptString(String algorithm, byte[] cipherText, SecretKey key, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
return new String(SQLiteEncprytion.decryptByte(algorithm, cipherText, key, iv) );
}
public static byte[] keyToByte(SecretKey key) {
return Base64.getEncoder().encode(key.getEncoded());
}
public static SecretKey byteToKey(byte[] encodedKey) {
byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
return new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
}
}

158
POO/src/database/SQLiteEncryption.java Normal file
View file

@ -0,0 +1,158 @@
package database;
import java.util.Base64;
import java.util.Random;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import java.security.spec.*;
class SQLiteEncryption {
private static final Random RANDOM = new SecureRandom();
private static final int ITERATIONS = 10000;
private static final int KEY_LENGTH = 256;
protected static final String encryptAlgorithm = "AES/CBC/PKCS5Padding";
/**
* Return a 24 bytes salt.
*
* @return The salt in a byte array.
*/
protected static byte[] getNextSalt() {
byte[] salt = new byte[24];
RANDOM.nextBytes(salt);
return salt;
}
/**
* Return the hash of the given password with the given salt.
*
* @param password
* @param salt
* @return The hash in a byte array.
*/
protected static byte[] hash(char[] password, byte[] salt) {
return SQLiteEncryption.getKey(password, salt).getEncoded();
}
/**
* Return a secret key generated with the given password and salt.
*
* @param password
* @param salt
* @return The secret key.
*/
protected static SecretKey getKey(char[] password, byte[] salt) {
PBEKeySpec saltpwd = new PBEKeySpec(password, salt, ITERATIONS, KEY_LENGTH);
try {
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
SecretKey tmp = skf.generateSecret(saltpwd);
SecretKey key = new SecretKeySpec(tmp.getEncoded(), "AES");
return key;
} catch (InvalidKeySpecException | NoSuchAlgorithmException e) {
e.printStackTrace();
} finally {
saltpwd.clearPassword();
}
return null;
}
/**
* Return a 16 bytes Initialization vector.
*
* @return The Initialization vector.
*/
protected static IvParameterSpec generateIv() {
byte[] iv = new byte[16];
RANDOM.nextBytes(iv);
return new IvParameterSpec(iv);
}
/**
* Encrypt the given input (byte array) with the given algorithm, secretKey and
* initialization vector.
*
*
* @param algorithm
* @param input
* @param key
* @param iv
* @return The encrypted input in a byte array.
*
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
* @throws InvalidAlgorithmParameterException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
protected static byte[] encrypt(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv)
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.ENCRYPT_MODE, key, iv);
byte[] cipherText = cipher.doFinal(input);
return Base64.getEncoder().encode(cipherText);
}
/**
* Decrypt the given input (byte array) with the given algorithm, secretKey and
* initialization vector.
*
* @param algorithm
* @param input
* @param key
* @param iv
* @return The decrypted input in a byte array.
*
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
* @throws InvalidAlgorithmParameterException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
protected static byte[] decryptByte(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv)
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.DECRYPT_MODE, key, iv);
byte[] plainText = cipher.doFinal(Base64.getDecoder().decode(input));
return plainText;
}
/**
* Decrypt the given input (byte array) with the given algorithm, secretKey and
* initialization vector.
*
* @param algorithm
* @param input
* @param key
* @param iv
* @return The decrypted input as a String.
*
* @throws InvalidKeyException
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidAlgorithmParameterException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
protected static String decryptString(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv)
throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
return new String(SQLiteEncryption.decryptByte(algorithm, input, key, iv));
}
protected static byte[] keyToByte(SecretKey key) {
return Base64.getEncoder().encode(key.getEncoded());
}
protected static SecretKey byteToKey(byte[] encodedKey) {
byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
return new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
}
}

466
POO/src/database/SQLiteManager.java
View file

@ -1,6 +1,5 @@
package database; package database;
import java.io.File;
import java.security.InvalidAlgorithmParameterException; import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException; import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException; import java.security.NoSuchAlgorithmException;
@ -19,7 +18,6 @@ import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey; import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.IvParameterSpec;
import main.Utilisateur; import main.Utilisateur;
import messages.MauvaisTypeMessageException; import messages.MauvaisTypeMessageException;
import messages.Message; import messages.Message;
@ -31,13 +29,24 @@ public class SQLiteManager {
private static final String DATABASE_RELATIVE_PATH = "../database"; private static final String DATABASE_RELATIVE_PATH = "../database";
public static String[] hardcodedNames = {"Olivia","Liam","Benjamin","Sophia","Charlotte","Noah","Elijah","Isabella", public static String[] hardcodedNames = { "Olivia", "Liam", "Benjamin", "Sophia", "Charlotte", "Noah", "Elijah",
"Oliver","Emma","William","Amelia","Evelyn","James","Mia","Ava","Lucas","Mason","Ethan","Harper"}; "Isabella", "Oliver", "Emma", "William", "Amelia", "Evelyn", "James", "Mia", "Ava", "Lucas", "Mason",
"Ethan", "Harper" };
private Connection connec; private Connection connec;
private int numDatabase; private int numDatabase;
private SecretKey dbDataKey; private SecretKey dbDataKey;
/**
* Create the object that will interact with the database. Each time a
* SQLiteManager is created, it creates the tables for the application to work
* if they do not exist already. In the context of a local usage of the
* application, this constructor takes a number that is used to manage different
* database's files (see openConnection() ).
*
* @param numDatabase
*/
public SQLiteManager(int numDatabase) { public SQLiteManager(int numDatabase) {
this.numDatabase = numDatabase; this.numDatabase = numDatabase;
@ -52,28 +61,31 @@ public class SQLiteManager {
} catch (SQLException e) { } catch (SQLException e) {
this.closeConnection(); this.closeConnection();
File db = new File("../database"+this.numDatabase+".db");
if(db.delete()) {
System.out.println("supp");
}else {
System.out.println("no supp");
}
e.printStackTrace(); e.printStackTrace();
} }
this.closeConnection(); this.closeConnection();
} }
// -------------- CONNECTION METHODS -------------- //
/**
* Open a connection to the file DATABASE_RELATIVE_PATH+this.numDatabase+".db"
*/
private void openConnection() { private void openConnection() {
String url = "jdbc:sqlite:" + DATABASE_RELATIVE_PATH + this.numDatabase + ".db"; String url = "jdbc:sqlite:" + DATABASE_RELATIVE_PATH + this.numDatabase + ".db";
try { try {
this.connec = DriverManager.getConnection(url); this.connec = DriverManager.getConnection(url);
// System.out.println("Connection to bdd established");
} catch (SQLException e) { } catch (SQLException e) {
System.out.println(e.getMessage()); System.out.println(e.getMessage());
} }
} }
/**
* Close this object connection, if it exists
*/
private void closeConnection() { private void closeConnection() {
try { try {
if (this.connec != null) { if (this.connec != null) {
@ -85,7 +97,22 @@ public class SQLiteManager {
} }
public int insertAllMessages(ArrayList<Message> messages, String usernameSender, String usernameReceiver) throws SQLException{
// -------------- INSERT METHODS -------------- //
/**
* Insert a collection of message in the database. They all correspond to the
* conversation between the sender and the receiver. The users and conversations
* are inserted in the database if they do not exist when this method is called.
*
* @param messages
* @param usernameSender
* @param usernameReceiver
* @return The number of messages inserted
* @throws SQLException
*/
public int insertAllMessages(ArrayList<Message> messages, String usernameSender, String usernameReceiver)
throws SQLException {
int nbRows = 0; int nbRows = 0;
this.openConnection(); this.openConnection();
@ -111,6 +138,7 @@ public class SQLiteManager {
IvParameterSpec ivConversation = this.getIvConversation(idConversation); IvParameterSpec ivConversation = this.getIvConversation(idConversation);
// Disable autocommit to efficiently insert all the messages.
this.connec.setAutoCommit(false); this.connec.setAutoCommit(false);
for (Message m : messages) { for (Message m : messages) {
@ -122,46 +150,143 @@ public class SQLiteManager {
} }
} }
// Commit once all the messages are inserted
this.connec.commit(); this.connec.commit();
this.closeConnection(); this.closeConnection();
//System.out.println("Nombre de message(s) insérée(s) : " + nbRows);
return nbRows; return nbRows;
} }
public ArrayList<Message> getHistoriquesMessages(String usernameOther, String pseudoOther) throws SQLException { /**
* Insert a message corresponding to a given conversation (respresented by its
* id). The message content is first encrypted with the database key and the
* given iv.
*
* @param idConversation
* @param m
* @param iv
* @return The number of rows inserted (it should be 1).
* @throws SQLException
*/
private int insertMessage(int idConversation, Message m, IvParameterSpec iv) throws SQLException {
String dateMessage = m.getDateMessage();
String extension = this.processExtension(m);
String type = this.processMessageType(m);
int idType = this.getIDType(type);
byte[] content = null;
try {
content = this.stringToBytesContent(m, iv);
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
e.printStackTrace();
}
String insertMessageRequest = "INSERT INTO message(id_conversation, id_type, content, date, extension) "
+ "VALUES (?, ?, ?, ?, ?);";
PreparedStatement prepStmt = this.connec.prepareStatement(insertMessageRequest);
prepStmt.setInt(1, idConversation);
prepStmt.setInt(2, idType);
prepStmt.setBytes(3, content);
prepStmt.setString(4, dateMessage);
prepStmt.setString(5, extension);
int nbRows = prepStmt.executeUpdate();
return nbRows;
}
/**
* Insert an user in the database with only its username.
*
* @param username
* @throws SQLException
*/
private void insertUser(String username) throws SQLException {
String insertUserRequest = "INSERT INTO user (username) " + "VALUES (?);";
PreparedStatement prepStmt = this.connec.prepareStatement(insertUserRequest);
prepStmt.setString(1, username);
prepStmt.executeUpdate();
}
/**
* Insert the two conversations corresponding to a session between two users
* (they both can be sender and receiver).
*
* @param idUser1
* @param idUser2
* @throws SQLException
*/
private void insertConversation(int idUser1, int idUser2) throws SQLException {
String insertConversationRequest = "INSERT INTO conversation (id_sender, id_receiver, iv_conversation) "
+ "VALUES " + "(?, ?, ?)," + "(?, ?, ?);";
byte[] ivConversation = SQLiteEncryption.generateIv().getIV();
PreparedStatement prepStmt = this.connec.prepareStatement(insertConversationRequest);
prepStmt.setInt(1, idUser1);
prepStmt.setInt(2, idUser2);
prepStmt.setBytes(3, ivConversation);
prepStmt.setInt(4, idUser2);
prepStmt.setInt(5, idUser1);
prepStmt.setBytes(6, ivConversation);
prepStmt.executeUpdate();
}
// -------------- GET METHODS -------------- //
/**
* Get the message record between two users. In context, it only needs the
* username and the id of the other user since we can get this application's
* user's data with Utilisateur.getSelf().
*
* @param usernameOther
* @param pseudoOther
* @return the messages previously exchanged in chronological order or null if
* there is none.
* @throws SQLException
*/
public ArrayList<Message> getMessageRecord(String usernameOther, String pseudoOther) throws SQLException {
this.openConnection(); this.openConnection();
ArrayList<Message> messages = new ArrayList<Message>(); ArrayList<Message> messages = new ArrayList<Message>();
String usernameSelf = Utilisateur.getSelf().getId(); String usernameSelf = Utilisateur.getSelf().getId();
// Get the ids from the usernames
int idSelf = this.getIDUser(usernameSelf); int idSelf = this.getIDUser(usernameSelf);
int idOther = this.getIDUser(usernameOther); int idOther = this.getIDUser(usernameOther);
// Get the two conversations corresponding to the exchanges between the two
// users
int idConversationSelf = this.getIDConversation(idSelf, idOther); int idConversationSelf = this.getIDConversation(idSelf, idOther);
int idConversationOther = this.getIDConversation(idOther, idSelf); int idConversationOther = this.getIDConversation(idOther, idSelf);
IvParameterSpec ivConversation = this.getIvConversation(idConversationSelf); IvParameterSpec ivConversation = this.getIvConversation(idConversationSelf);
// String str = "datetime(d1,'unixepoch','localtime')";
// Get all the messages
String getHistoriqueRequest = "SELECT id_conversation, id_type, content, date, extension " String getHistoriqueRequest = "SELECT id_conversation, id_type, content, date, extension " + "FROM message "
+ "FROM message " + "WHERE id_conversation IN (?,?) " + "ORDER by date";
+ "WHERE id_conversation IN (?,?) "
+ "ORDER by date";
PreparedStatement prepStmt = this.connec.prepareStatement(getHistoriqueRequest); PreparedStatement prepStmt = this.connec.prepareStatement(getHistoriqueRequest);
prepStmt.setInt(1, idConversationSelf); prepStmt.setInt(1, idConversationSelf);
prepStmt.setInt(2, idConversationOther); prepStmt.setInt(2, idConversationOther);
ResultSet res = prepStmt.executeQuery(); ResultSet res = prepStmt.executeQuery();
//Retrieve the messages one by one // Process the messages one by one
//Create the appropriate message object depending on the type and sender/receiver // Create the appropriate message object depending on the type and
// sender/receiver
// and add the message in the list // and add the message in the list
while (res.next()) { while (res.next()) {
int idType = res.getInt("id_type"); int idType = res.getInt("id_type");
@ -169,11 +294,12 @@ public class SQLiteManager {
String content = null; String content = null;
try { try {
// Decrypt the message's content with the database key and the conversation's
// iv.
content = this.bytesToStringContent(res.getBytes("content"), ivConversation); content = this.bytesToStringContent(res.getBytes("content"), ivConversation);
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException } catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException
| SQLException e1) { | SQLException e1) {
//System.out.println("erreur déchiffrement");
} }
Message message = null; Message message = null;
@ -211,22 +337,20 @@ public class SQLiteManager {
} }
this.closeConnection(); this.closeConnection();
return messages; return messages;
} }
private void insertUser(String username) throws SQLException { /**
String insertUserRequest = "INSERT INTO user (username) " + "VALUES (?);"; * Return the id of the user with the given username if it exists in the
* database.
PreparedStatement prepStmt = this.connec.prepareStatement(insertUserRequest); *
prepStmt.setString(1, username); * @param username
prepStmt.executeUpdate(); * @return The id of the user or -1 if he does not exist in the database.
} * @throws SQLException
*/
private int getIDUser(String username) throws SQLException { private int getIDUser(String username) throws SQLException {
String getIDRequest = "SELECT id " + " FROM user" + " WHERE username = ? ;"; String getIDRequest = "SELECT id " + " FROM user" + " WHERE username = ? ;";
@ -242,28 +366,18 @@ public class SQLiteManager {
} }
private void insertConversation(int idSender, int idReceiver) throws SQLException { /**
String insertConversationRequest = "INSERT INTO conversation (id_emetteur, id_recepteur, iv_conversation) " + "VALUES " * Get the id of the conversation between two users (represented by their ids).
+ "(?, ?, ?)," *
+ "(?, ?, ?);"; * @param idSender
* @param idReceiver
byte[] ivConversation = SQLiteEncprytion.generateIv().getIV(); * @return The id of the conversation or -1 if the conversation does not exists
* in the database.
PreparedStatement prepStmt = this.connec.prepareStatement(insertConversationRequest); * @throws SQLException
prepStmt.setInt(1, idSender); */
prepStmt.setInt(2, idReceiver);
prepStmt.setBytes(3, ivConversation);
prepStmt.setInt(4, idReceiver);
prepStmt.setInt(5, idSender);
prepStmt.setBytes(6, ivConversation);
prepStmt.executeUpdate();
}
private int getIDConversation(int idSender, int idReceiver) throws SQLException { private int getIDConversation(int idSender, int idReceiver) throws SQLException {
String getIDRequest = "SELECT id_conversation " + "FROM conversation " + "WHERE id_emetteur = ? " String getIDRequest = "SELECT id_conversation " + "FROM conversation " + "WHERE id_sender = ? "
+ "AND id_recepteur = ? ;"; + "AND id_receiver = ? ;";
PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest); PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
prepStmt.setInt(1, idSender); prepStmt.setInt(1, idSender);
@ -276,6 +390,16 @@ public class SQLiteManager {
return -1; return -1;
} }
/**
* Get the initialization vector for a given conversation (represented by its
* id).
*
* @param idConversation
* @return The iv corresponding to the conversation or null if the conversation
* does not exist in the database.
* @throws SQLException
*/
private IvParameterSpec getIvConversation(int idConversation) throws SQLException { private IvParameterSpec getIvConversation(int idConversation) throws SQLException {
String getIvRequest = "SELECT iv_conversation " + "FROM conversation " + "WHERE id_conversation = ?;"; String getIvRequest = "SELECT iv_conversation " + "FROM conversation " + "WHERE id_conversation = ?;";
@ -291,8 +415,14 @@ public class SQLiteManager {
} }
/**
* Get the id of the message type corresponding to the given label.
*
* @param label
* @return The id of the message type or -1 if it does not exist in the
* database.
* @throws SQLException
*/
private int getIDType(String label) throws SQLException { private int getIDType(String label) throws SQLException {
String getIDRequest = "SELECT id_type FROM type WHERE label = ?;"; String getIDRequest = "SELECT id_type FROM type WHERE label = ?;";
@ -308,6 +438,14 @@ public class SQLiteManager {
} }
/**
* Get the label of the message type corresponding to the given id.
*
* @param idType
* @return The label of the message type or "" if it does not exist in the
* database.
* @throws SQLException
*/
private String getType(int idType) throws SQLException { private String getType(int idType) throws SQLException {
String getTypeRequest = "SELECT label FROM type WHERE id_type = ?;"; String getTypeRequest = "SELECT label FROM type WHERE id_type = ?;";
@ -325,7 +463,26 @@ public class SQLiteManager {
} }
private byte[] stringToBytesContent(Message m, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { // -------------- PROCESSING MESSAGE METHODS -------------- //
/**
* Convert a message in bytes. First get the content of the message. Then
* encrypt it with the database_key and the given iv (initialization vector).
*
* @param m
* @param iv
* @return The bytes of the encrypted message's content.
*
* @throws InvalidKeyException
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidAlgorithmParameterException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
private byte[] stringToBytesContent(Message m, IvParameterSpec iv)
throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
String content; String content;
if (m.getTypeMessage() == TypeMessage.TEXTE) { if (m.getTypeMessage() == TypeMessage.TEXTE) {
MessageTexte messageTxt = (MessageTexte) m; MessageTexte messageTxt = (MessageTexte) m;
@ -334,25 +491,61 @@ public class SQLiteManager {
MessageFichier messageFichier = (MessageFichier) m; MessageFichier messageFichier = (MessageFichier) m;
content = messageFichier.getContenu(); content = messageFichier.getContenu();
} }
byte[] encryptedContent = SQLiteEncprytion.encrypt(SQLiteEncprytion.encryptAlgorithm, content.getBytes(), this.dbDataKey, iv); byte[] encryptedContent = SQLiteEncryption.encrypt(SQLiteEncryption.encryptAlgorithm, content.getBytes(),
this.dbDataKey, iv);
return encryptedContent; return encryptedContent;
} }
private String bytesToStringContent(byte[] encryptedContent, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
return SQLiteEncprytion.decryptString(SQLiteEncprytion.encryptAlgorithm, encryptedContent, this.dbDataKey, iv); /**
* Convert bytes in a String. In this context, the bytes correspond to the
* encrypted content of a message.
*
* @param encryptedContent
* @param iv
* @return The String corresponding to the decrypted bytes.
*
* @throws InvalidKeyException
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidAlgorithmParameterException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
private String bytesToStringContent(byte[] encryptedContent, IvParameterSpec iv)
throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
return SQLiteEncryption.decryptString(SQLiteEncryption.encryptAlgorithm, encryptedContent, this.dbDataKey, iv);
} }
/**
* Process the type of a message
*
* @param m
* @return The type of the message
*/
private String processMessageType(Message m) { private String processMessageType(Message m) {
switch (m.getTypeMessage()) { switch (m.getTypeMessage()) {
case TEXTE: return "text"; case TEXTE:
case FICHIER: return "file"; return "text";
case IMAGE: return "image"; case FICHIER:
default: return ""; return "file";
case IMAGE:
return "image";
default:
return "";
} }
} }
/**
* Process the extension of a message
*
* @param m
* @return The extension of the message. null if it is a simple text message.
*/
private String processExtension(Message m) { private String processExtension(Message m) {
if (m.getTypeMessage() == TypeMessage.TEXTE) { if (m.getTypeMessage() == TypeMessage.TEXTE) {
return null; return null;
@ -362,44 +555,24 @@ public class SQLiteManager {
} }
} }
// -------------- USER SECURITY RELATED METHODS -------------- //
private int insertMessage(int idConversation, Message m, IvParameterSpec iv) throws SQLException {
String dateMessage = m.getDateMessage(); /**
String extension = this.processExtension(m); * Creates a new user in the database from a given username and password. The
String type = this.processMessageType(m); * username is stored in plain text. An encrypted hash of the password is
int idType = this.getIDType(type); * stored. The key used to encrypt the password's hash is itself encrypted then
* stored. Every other useful data to decrypt the key and compare the password's
byte[] content = null; * hash is stored as plaintext.
*
try { * Fail if a user with the given username already exists in the database.
content = this.stringToBytesContent(m, iv); *
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException * @param username
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) { * @param password
*/
e.printStackTrace();
}
String insertMessageRequest = "INSERT INTO message(id_conversation, id_type, content, date, extension) "
+ "VALUES (?, ?, ?, ?, ?);";
PreparedStatement prepStmt = this.connec.prepareStatement(insertMessageRequest);
prepStmt.setInt(1, idConversation);
prepStmt.setInt(2, idType);
prepStmt.setBytes(3, content);
prepStmt.setString(4, dateMessage);
prepStmt.setString(5, extension);
int nbRows = prepStmt.executeUpdate();
return nbRows;
}
public void createNewUserEncrypt(String username, String password) { public void createNewUserEncrypt(String username, String password) {
String algo = SQLiteEncryption.encryptAlgorithm;
String algo = SQLiteEncprytion.encryptAlgorithm;
KeyGenerator keyGen = null; KeyGenerator keyGen = null;
try { try {
@ -409,28 +582,26 @@ public class SQLiteManager {
e.printStackTrace(); e.printStackTrace();
} }
byte[] passwordSalt = SQLiteEncprytion.getNextSalt(); byte[] passwordSalt = SQLiteEncryption.getNextSalt();
byte[] dbDataKeySalt = SQLiteEncprytion.getNextSalt(); byte[] dbDataKeySalt = SQLiteEncryption.getNextSalt();
SecretKey dbDataKey = keyGen.generateKey(); SecretKey dbDataKey = keyGen.generateKey();
SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password.toCharArray(), dbDataKeySalt); SecretKey dbDataEncryptKey = SQLiteEncryption.getKey(password.toCharArray(), dbDataKeySalt);
IvParameterSpec ivDbDataKey = SQLiteEncprytion.generateIv(); IvParameterSpec ivDbDataKey = SQLiteEncryption.generateIv();
byte[] passwordHash = SQLiteEncprytion.hash(password.toCharArray(), passwordSalt); byte[] passwordHash = SQLiteEncryption.hash(password.toCharArray(), passwordSalt);
byte[] dbDataKeyEncrypted = null; byte[] dbDataKeyEncrypted = null;
byte[] encryptedPasswordHash = null; byte[] encryptedPasswordHash = null;
try { try {
dbDataKeyEncrypted = SQLiteEncprytion.encrypt( dbDataKeyEncrypted = SQLiteEncryption.encrypt(algo, SQLiteEncryption.keyToByte(dbDataKey), dbDataEncryptKey,
algo, SQLiteEncprytion.keyToByte(dbDataKey), dbDataEncryptKey, ivDbDataKey); ivDbDataKey);
encryptedPasswordHash = SQLiteEncprytion.encrypt( encryptedPasswordHash = SQLiteEncryption.encrypt(algo, passwordHash, dbDataKey, ivDbDataKey);
algo, passwordHash , dbDataKey, ivDbDataKey);
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException } catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) { | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
// TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
@ -450,7 +621,6 @@ public class SQLiteManager {
prepStmt.setBytes(6, ivDbDataKey.getIV()); prepStmt.setBytes(6, ivDbDataKey.getIV());
} catch (SQLException e) { } catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
@ -465,13 +635,15 @@ public class SQLiteManager {
} }
/** /**
* Check if a given password has the same hash (= they're the same) as the one
* stored in the database for a given username.
* *
* @param username * @param username
* @param password * @param password
* @return -1 if user do not exists, * @return -1 if user do not exists, 0 if password is incorrect, 1 if password
* 0 if password incorrect, * is correct
* 1 if password correct
* @throws SQLException * @throws SQLException
*/ */
public int checkPwd(String username, char[] password) throws SQLException { public int checkPwd(String username, char[] password) throws SQLException {
@ -479,8 +651,7 @@ public class SQLiteManager {
this.openConnection(); this.openConnection();
String selectUserDataRequest = "SELECT pwd_salt, db_datakey_salt, encrypted_pwd_hashsalt, encrypted_db_datakey, iv_datakey " String selectUserDataRequest = "SELECT pwd_salt, db_datakey_salt, encrypted_pwd_hashsalt, encrypted_db_datakey, iv_datakey "
+ "FROM user " + "FROM user " + "WHERE username = ?;";
+ "WHERE username = ?;";
PreparedStatement prepStmt; PreparedStatement prepStmt;
prepStmt = this.connec.prepareStatement(selectUserDataRequest); prepStmt = this.connec.prepareStatement(selectUserDataRequest);
prepStmt.setString(1, username); prepStmt.setString(1, username);
@ -491,63 +662,90 @@ public class SQLiteManager {
} }
byte[] passwordSalt = res.getBytes("pwd_salt"); byte[] passwordSalt = res.getBytes("pwd_salt");
if (passwordSalt == null) {
return 0;
}
byte[] dbDataKeySalt = res.getBytes("db_datakey_salt"); byte[] dbDataKeySalt = res.getBytes("db_datakey_salt");
SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password, dbDataKeySalt); SecretKey dbDataEncryptKey = SQLiteEncryption.getKey(password, dbDataKeySalt);
IvParameterSpec iv = new IvParameterSpec(res.getBytes("iv_datakey"));
byte[] ivBytes = res.getBytes("iv_datakey");
if (ivBytes == null) {
return 0;
}
IvParameterSpec iv = new IvParameterSpec(ivBytes);
byte[] encryptedDbDataKey = res.getBytes("encrypted_db_datakey"); byte[] encryptedDbDataKey = res.getBytes("encrypted_db_datakey");
SecretKey dbDataKey = null; SecretKey dbDataKey = null;
try { try {
dbDataKey = SQLiteEncprytion.byteToKey( dbDataKey = SQLiteEncryption.byteToKey(SQLiteEncryption.decryptByte(SQLiteEncryption.encryptAlgorithm,
SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedDbDataKey, dbDataEncryptKey, iv) encryptedDbDataKey, dbDataEncryptKey, iv));
);
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException } catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) { | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
//System.out.println("Problème déchiffrement clé db");
} }
this.dbDataKey = dbDataKey;
byte[] encryptedPasswordHash = res.getBytes("encrypted_pwd_hashsalt"); byte[] encryptedPasswordHash = res.getBytes("encrypted_pwd_hashsalt");
byte[] passwordHash = SQLiteEncryption.hash(password, passwordSalt);
byte[] passwordHash = SQLiteEncprytion.hash(password, passwordSalt);
this.closeConnection(); this.closeConnection();
boolean checkHash = this.checkHashPwd(passwordHash, encryptedPasswordHash, dbDataKey, iv); boolean checkHash = this.checkHashPwd(passwordHash, encryptedPasswordHash, dbDataKey, iv);
if (checkHash) { if (checkHash) {
// Set the database key to be used in future encryptions if the given password is
// correct.
this.dbDataKey = dbDataKey;
return 1; return 1;
} }
return 0; return 0;
} }
private boolean checkHashPwd(byte[] passwordHash, byte[] encryptedPasswordHash, SecretKey dbDataKey, IvParameterSpec iv) { /**
* Check if two given hash are the same once the second one has been decrypted
* with the given key and iv.
*
* @param passwordHash
* @param encryptedPasswordHash
* @param dbDataKey
* @param iv
* @return true if the first hash is equal to the second one once decrypted,
* false otherwise.
*
*/
private boolean checkHashPwd(byte[] passwordHash, byte[] encryptedPasswordHash, SecretKey dbDataKey,
IvParameterSpec iv) {
byte[] expectedHash = "".getBytes(); byte[] expectedHash = "".getBytes();
try { try {
expectedHash = SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedPasswordHash, dbDataKey, iv); expectedHash = SQLiteEncryption.decryptByte(SQLiteEncryption.encryptAlgorithm, encryptedPasswordHash,
dbDataKey, iv);
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException } catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) { | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
} }
if (passwordHash.length != expectedHash.length)
return false;
if (passwordHash.length != expectedHash.length) return false;
for (int i = 0; i < passwordHash.length; i++) { for (int i = 0; i < passwordHash.length; i++) {
if (passwordHash[i] != expectedHash[i]) return false; if (passwordHash[i] != expectedHash[i])
return false;
} }
return true; return true;
} }
// Main to create 20 users in the database with the given number
public static void main(String[] args) { public static void main(String[] args) {
String[] hardcodedNames = { "Olivia", "Liam", "Benjamin", "Sophia", "Charlotte", "Noah", "Elijah", "Isabella", String[] hardcodedNames = { "Olivia", "Liam", "Benjamin", "Sophia", "Charlotte", "Noah", "Elijah", "Isabella",
"Oliver","Emma","William","Amelia","Evelyn","James","Mia","Ava","Lucas","Mason","Ethan","Harper"}; "Oliver", "Emma", "William", "Amelia", "Evelyn", "James", "Mia", "Ava", "Lucas", "Mason", "Ethan",
"Harper" };
String pwdPrefix = "aze1$"; String pwdPrefix = "aze1$";

6
POO/src/main/Observer.java
View file

@ -1,6 +0,0 @@
package main;
public interface Observer {
public void update(Object o, Object arg);
}

77
POO/src/main/Utilisateur.java
View file

@ -4,9 +4,7 @@ import java.net.*;
public class Utilisateur implements Serializable{ public class Utilisateur implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private String id; private String id;
@ -14,48 +12,103 @@ public class Utilisateur implements Serializable{
private InetAddress ip; private InetAddress ip;
private int port; private int port;
//Represents the user that is currently using the application
private static Utilisateur self; private static Utilisateur self;
/**
* Create and initialize an object representing an user
*
* @param id : user id as String
* @param pseudo : name under which other users can see this user as String
* @param ip : ip of the device this user is currently using as InetAddress
* @param port : on local mode, port used for the TCP listen socket as int
*
*/
public Utilisateur(String id, String pseudo, InetAddress ip, int port) throws UnknownHostException { public Utilisateur(String id, String pseudo, InetAddress ip, int port) throws UnknownHostException {
this.id = id; this.id = id;
this.pseudo = pseudo; this.pseudo = pseudo;
this.ip = ip; this.ip = ip;
this.port = port; this.port = port;
} }
// ----- GETTERS ----- //
/**
* Returns user id as String
*
* @return user id as String
*/
public String getId() { public String getId() {
return id; return id;
} }
/**
* Returns user pseudo as String
*
* @return user pseudo as String
*/
public String getPseudo() { public String getPseudo() {
return pseudo; return pseudo;
} }
public void setPseudo(String pseudo) { /**
this.pseudo = pseudo; * Returns user device's ip as String
} *
* @return user device's ip as String
*/
public InetAddress getIp() { public InetAddress getIp() {
return ip; return ip;
} }
/**
* Returns the port the user uses for their TCP listen socket as int
*
* @return TCP listen socket port as int
*/
public int getPort() { public int getPort() {
return port; return port;
} }
/**
* Returns the user currently using this instance of the application as Utilisateur
*
* @return current user as Utilisateur
*/
public static Utilisateur getSelf() {
return Utilisateur.self;
}
// ----- SETTERS ----- //
/**
* Change the pseudo used by an user
*
* @param pseudo : new pseudo as String
*/
public void setPseudo(String pseudo) {
this.pseudo = pseudo;
}
/**
* Sets the self static attribute with a new Utilisateur
*
* @param id : user id as String
* @param pseudo : name under which other users can see this user as String
* @param ip : ip of the device this user is currently using as InetAddress
* @param port : on local mode, port used for the TCP listen socket as int
*/
public static void setSelf(String id, String pseudo, String host, int port) throws UnknownHostException { public static void setSelf(String id, String pseudo, String host, int port) throws UnknownHostException {
if(Utilisateur.self == null) { if(Utilisateur.self == null) {
Utilisateur.self = new Utilisateur(id, pseudo, InetAddress.getByName(host), port); Utilisateur.self = new Utilisateur(id, pseudo, InetAddress.getByName(host), port);
} }
} }
public static Utilisateur getSelf() { /**
return Utilisateur.self; * Sets the self static attribute with null
} */
public static void resetSelf() { public static void resetSelf() {
Utilisateur.self = null; Utilisateur.self = null;
} }

3
POO/src/main/Vue.java
View file

@ -2,6 +2,9 @@ package main;
import javax.swing.JFrame; import javax.swing.JFrame;
// General class from which all VueX class derivate
public class Vue extends JFrame{ public class Vue extends JFrame{
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;

82
POO/src/messages/Message.java
View file

@ -6,48 +6,101 @@ import java.time.format.DateTimeFormatter;
public abstract class Message implements Serializable { public abstract class Message implements Serializable {
public enum TypeMessage {JE_SUIS_CONNECTE, JE_SUIS_DECONNECTE, INFO_PSEUDO, TEXTE, IMAGE, FICHIER, MESSAGE_NUL, FICHIER_INIT, FICHIER_ANSWER} public enum TypeMessage {JE_SUIS_CONNECTE, JE_SUIS_DECONNECTE, INFO_PSEUDO, TEXTE, IMAGE, FICHIER, FICHIER_INIT, FICHIER_ANSWER}
protected TypeMessage type; protected TypeMessage type;
private String dateMessage; private String dateMessage;
private String sender; private String sender;
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
// ------- GETTERS ------ //
/**
* Returns the current date and time as a string using DateTimeFormatter and LocalDateTime
*
* @return date and time as a String
*/
public static String getDateAndTime() { public static String getDateAndTime() {
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"); DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now(); LocalDateTime now = LocalDateTime.now();
return dtf.format(now); return dtf.format(now);
} }
/**
* Returns the type of the message
*
* @return message type as TypeMessage
*/
public TypeMessage getTypeMessage() { public TypeMessage getTypeMessage() {
return this.type; return this.type;
} }
public void setDateMessage(String dateMessage) { /**
this.dateMessage = dateMessage; * Returns the date and time to which the message was timestamped
} *
* @return date and time of timestamp as String
*/
public String getDateMessage() { public String getDateMessage() {
return this.dateMessage; return this.dateMessage;
} }
/**
* Returns the sender of the message (used in the database)
*
* @return sender of message as String
*/
public String getSender() { public String getSender() {
return this.sender ; return this.sender ;
} }
// ------ SETTERS ------ //
/**
* Set the date of the message to a specific timestamp
*
* @param timestamp as (formatted) String
*/
public void setDateMessage(String dateMessage) {
this.dateMessage = dateMessage;
}
/**
* Set the sender of the message to a specified string
*
* @param sender pseudo as String
*/
public void setSender(String sender) { public void setSender(String sender) {
this.sender = sender; this.sender = sender;
} }
// ----- MESSAGE-STRING CONVERSION METHODS -------//
/**
* Returns a string representing the formatted list of attributes
*
*@return attributes as a String
*/
protected abstract String attributsToString(); protected abstract String attributsToString();
/**
* Returns the message as a formatted string
*
*@return message as a String
*/
public String toString() { public String toString() {
return this.type+"###"+this.attributsToString(); return this.type+"###"+this.attributsToString();
} }
/**
* Static method. Returns a message obtainer by parsing a given string
*
*@param String representing a message
*@return Message
*/
public static Message stringToMessage(String messageString) { public static Message stringToMessage(String messageString) {
try { try {
String[] parts = messageString.split("###"); String[] parts = messageString.split("###");
@ -74,21 +127,4 @@ public abstract class Message implements Serializable {
return null; return null;
} }
//tests ici
public static void main(String[] args) throws MauvaisTypeMessageException {
Message m1 = new MessageSysteme(TypeMessage.JE_SUIS_CONNECTE);
Message m2 = new MessageSysteme(TypeMessage.JE_SUIS_DECONNECTE,"aker", "man", 5000);
Message m3 = new MessageSysteme(TypeMessage.INFO_PSEUDO, "pseudo156434518", "id236", 1500);
Message m4 = new MessageTexte(TypeMessage.TEXTE, "blablabla");
Message m5 = new MessageFichier(TypeMessage.FICHIER, "truc", ".pdf");
System.out.println(Message.stringToMessage(m1.toString()));
System.out.println(Message.stringToMessage(m2.toString()));
System.out.println(Message.stringToMessage(m3.toString()));
System.out.println(Message.stringToMessage(m4.toString()));
System.out.println(Message.stringToMessage(m5.toString()));
}
} }

36
POO/src/messages/MessageFichier.java
View file

@ -7,6 +7,22 @@ public class MessageFichier extends Message {
private String contenu; private String contenu;
private String extension; private String extension;
/**
* Create a file message. These message are used for all interactions regarding file transfer.
*
* The "FICHIER_INIT" messages are used to inform the recipient application that you wish to transfer them files.
* The "FICHIER_ANSWER" messages are answers to "FICHIER_INIT" messages. They indicate that you are ready to receive the file.
* The "contenu" argument then contains the port on which you wish to receive the files.
*
* The "FICHIER" messages contains the files themselves.
* The "IMAGE" messages contains images files, which means the application will display a thumbnail for the image to the recipient.
*
* @param TypeMessage type (must be FICHIER_INIT, FICHIER_ANSWER, FICHIER or IMAGE, else an error is raised)
* @param contenu : message content as String
* @param extension : file extension as string
*
* @throws MauvaisTypeMessageException
*/
public MessageFichier(TypeMessage type, String contenu, String extension) throws MauvaisTypeMessageException{ public MessageFichier(TypeMessage type, String contenu, String extension) throws MauvaisTypeMessageException{
if ((type==TypeMessage.IMAGE)||(type==TypeMessage.FICHIER) ||(type==TypeMessage.FICHIER_INIT) || (type==TypeMessage.FICHIER_ANSWER) ) { if ((type==TypeMessage.IMAGE)||(type==TypeMessage.FICHIER) ||(type==TypeMessage.FICHIER_INIT) || (type==TypeMessage.FICHIER_ANSWER) ) {
this.type=type; this.type=type;
@ -17,14 +33,34 @@ public class MessageFichier extends Message {
else throw new MauvaisTypeMessageException(); else throw new MauvaisTypeMessageException();
} }
// ----- GETTERS ----- //
/**
* Returns content of the message
*
* @return content as String
*/
public String getContenu() { public String getContenu() {
return this.contenu; return this.contenu;
} }
/**
* Returns extension of the file contained in the message (if the message contains a file)
*
* @return extension as String
*/
public String getExtension() { public String getExtension() {
return this.extension; return this.extension;
} }
// ----- MESSAGE-STRING CONVERSION METHODS -------//
/**
* Implements attributsToString method of Message
*
* @return attributes as a String
*/
@Override @Override
protected String attributsToString() { protected String attributsToString() {
return this.contenu+"###"+this.extension; return this.contenu+"###"+this.extension;

52
POO/src/messages/MessageSysteme.java
View file

@ -1,5 +1,6 @@
package messages; package messages;
public class MessageSysteme extends Message { public class MessageSysteme extends Message {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -7,8 +8,18 @@ public class MessageSysteme extends Message {
private String id; private String id;
private int port; private int port;
// ------ CONSTRUCTORS ------ //
/**
* Create a system message. These message are used for all system interactions by the UDP channel.
* The "JE_SUIS_CONNECTE" messages are used to inform the network that you just joined.
* They are sent directly after an user log in, and await multiple "INFO_PSEUDO" messages as answers, to build the table of users logged in.
*
* @param TypeMessage type (must be JE_SUIS_CONNECTE, else an error is raised)
* @throws MauvaisTypeMessageException
*/
public MessageSysteme(TypeMessage type) throws MauvaisTypeMessageException{ public MessageSysteme(TypeMessage type) throws MauvaisTypeMessageException{
if ((type==TypeMessage.JE_SUIS_CONNECTE)||(type==TypeMessage.MESSAGE_NUL)) { if (type==TypeMessage.JE_SUIS_CONNECTE) {
this.type=type; this.type=type;
this.pseudo=""; this.pseudo="";
this.id=""; this.id="";
@ -17,6 +28,20 @@ public class MessageSysteme extends Message {
else throw new MauvaisTypeMessageException(); else throw new MauvaisTypeMessageException();
} }
/**
* Create a system message. These message are used for all system interactions by the UDP channel.
* The "JE_SUIS_DECONNECTE" messages are used to inform the network that you just quit it.
*
* The "INFO_PSEUDO" are used to give informations about you to another user, much like an business card.
* They are used either as an answer to a "JE_SUIS_CONNECTE" message or to inform the network of a change of pseudo.
*
* @param TypeMessage type (must be JE_SUIS_DECONNECTE or INFO_PSEUDO, else an error is raised)
* @param pseudo : user pseudo as String
* @param id : user id as String
* @param port : "server" UDP port used by the application (used when the application id in local mode)
*
* @throws MauvaisTypeMessageException
*/
public MessageSysteme(TypeMessage type, String pseudo, String id, int port) throws MauvaisTypeMessageException { public MessageSysteme(TypeMessage type, String pseudo, String id, int port) throws MauvaisTypeMessageException {
if (type==TypeMessage.INFO_PSEUDO ||(type==TypeMessage.JE_SUIS_DECONNECTE)) { if (type==TypeMessage.INFO_PSEUDO ||(type==TypeMessage.JE_SUIS_DECONNECTE)) {
this.type=type; this.type=type;
@ -28,18 +53,43 @@ public class MessageSysteme extends Message {
} }
// ----- GETTERS ----- //
/**
* Returns pseudo of the sender of the message (when type == INFO_PSEUDO)
*
* @return user pseudo as String
*/
public String getPseudo() { public String getPseudo() {
return this.pseudo; return this.pseudo;
} }
/**
* Returns id of the sender of the message (when type == INFO_PSEUDO)
*
* @return user id as String
*/
public String getId() { public String getId() {
return this.id; return this.id;
} }
/**
* Returns the "server" UDP port used by the sender of the message
*
* @return port as integer
*/
public int getPort() { public int getPort() {
return this.port; return this.port;
} }
// ----- MESSAGE-STRING CONVERSION METHODS -------//
/**
* Implements attributsToString method of Message
*
* @return attributes as a String
*/
@Override @Override
protected String attributsToString() { protected String attributsToString() {
return this.pseudo+"###"+this.id+"###"+this.port; return this.pseudo+"###"+this.id+"###"+this.port;

22
POO/src/messages/MessageTexte.java
View file

@ -7,6 +7,14 @@ public class MessageTexte extends Message {
private String contenu; private String contenu;
/**
* Create a text message. These message are used for basic text conversation via TCP.
*
* @param TypeMessage type (must be TEXT, else an error is raised)
* @param contenu : message content as String
*
* @throws MauvaisTypeMessageException
*/
public MessageTexte(TypeMessage type, String contenu) throws MauvaisTypeMessageException{ public MessageTexte(TypeMessage type, String contenu) throws MauvaisTypeMessageException{
if (type==TypeMessage.TEXTE) { if (type==TypeMessage.TEXTE) {
this.type=type; this.type=type;
@ -16,11 +24,25 @@ public class MessageTexte extends Message {
else throw new MauvaisTypeMessageException(); else throw new MauvaisTypeMessageException();
} }
// ----- GETTERS ----- //
/**
* Returns content of the message
*
* @return content as String
*/
public String getContenu() { public String getContenu() {
return this.contenu; return this.contenu;
} }
// ----- MESSAGE-STRING CONVERSION METHODS -------//
/**
* Implements attributsToString method of Message
*
* @return attributes as a String
*/
@Override @Override
protected String attributsToString() { protected String attributsToString() {
return this.contenu; return this.contenu;

9
POO/src/observers/ObserverInputMessage.java
View file

@ -1,5 +1,12 @@
package observers; package observers;
public interface ObserverInputMessage { public interface ObserverInputMessage {
public void update(Object o, Object arg);
/**
* Method called when data is received from a TCP socket
*
* @param o : The observer to notify
* @param arg : An object
*/
public void updateInput(Object o, Object arg);
} }

6
POO/src/observers/ObserverSocketState.java
View file

@ -2,6 +2,12 @@ package observers;
public interface ObserverSocketState { public interface ObserverSocketState {
/**
* Method called when a TCP socket is closed/a communication is broken
*
* @param o : The observer to notify
* @param arg : An object
*/
public void updateSocketState(Object o, Object arg); public void updateSocketState(Object o, Object arg);
} }

6
POO/src/observers/ObserverUserList.java
View file

@ -6,6 +6,12 @@ import main.Utilisateur;
public interface ObserverUserList { public interface ObserverUserList {
/**
* Method called when the userlist is updated
*
* @param o : The observer to notify
* @param userList : The userlist
*/
public void updateList(Object o, ArrayList<Utilisateur> userList); public void updateList(Object o, ArrayList<Utilisateur> userList);
} }

174
POO/src/session/ControleurSession.java
View file

@ -39,7 +39,22 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
private SQLiteManager sqlManager; private SQLiteManager sqlManager;
private ArrayList<File> files; private ArrayList<File> files;
protected ControleurSession(VueSession vue, Socket socketComm, String idOther, String pseudoOther, SQLiteManager sqlManager) throws IOException { /**
* Create the controller for this session. It will manage all the objects used
* to send/receive messages and files as well as the ones interacting with the
* database. It will handle the actions performed on the view and call the
* appropriate methods to display messages and data on the view.
*
* @param vue The corresponding view
* @param socketComm The socket used to send/receive messages
* @param idOther The other user's id
* @param pseudoOther The other user's pseudo
* @param sqlManager The SQLManager instance to retrieve/insert
* users,conversations,messages from/into the database
* @throws IOException
*/
protected ControleurSession(VueSession vue, Socket socketComm, String idOther, String pseudoOther,
SQLiteManager sqlManager) throws IOException {
this.vue = vue; this.vue = vue;
this.tcpClient = new TCPClient(socketComm); this.tcpClient = new TCPClient(socketComm);
this.tcpClient.setObserverInputThread(this); this.tcpClient.setObserverInputThread(this);
@ -56,11 +71,12 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
this.files = new ArrayList<File>(); this.files = new ArrayList<File>();
} }
// ---------- ACTION LISTENER OPERATIONS ---------- // // ---------- ACTION LISTENER OPERATIONS ---------- //
@Override @Override
public void actionPerformed(ActionEvent e) { public void actionPerformed(ActionEvent e) {
//Quand le bouton envoyer est presse // If the button "Envoyer" is pressed
if ((JButton) e.getSource() == this.vue.getButtonEnvoyer()) { if ((JButton) e.getSource() == this.vue.getButtonEnvoyer()) {
String messageContent = this.vue.getInputedText(); String messageContent = this.vue.getInputedText();
System.out.println(messageContent); System.out.println(messageContent);
@ -75,7 +91,6 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
} }
} }
// If the text field is not empty // If the text field is not empty
if (!messageContent.equals("")) { if (!messageContent.equals("")) {
@ -89,11 +104,9 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
e2.printStackTrace(); e2.printStackTrace();
} }
try { try {
this.tcpClient.sendMessage(messageOut); this.tcpClient.sendMessage(messageOut);
} catch (MauvaisTypeMessageException | IOException e1) { } catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace(); e1.printStackTrace();
} }
@ -105,12 +118,18 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
} }
} }
// If the button "Importer" is pressed
if ((JButton) e.getSource() == this.vue.getButtonImportFile()) { if ((JButton) e.getSource() == this.vue.getButtonImportFile()) {
// Display a file chooser to select one or several files
JFileChooser fc = new JFileChooser(); JFileChooser fc = new JFileChooser();
fc.setMultiSelectionEnabled(true); fc.setMultiSelectionEnabled(true);
int returVal = fc.showDialog(this.vue, "Importer"); int returVal = fc.showDialog(this.vue, "Importer");
// If the user clicked on "Importer",
// Retrieve all the files he clicked on.
// The files are stored in this.files
// and their names are display in the ChatInput.
if (returVal == JFileChooser.APPROVE_OPTION) { if (returVal == JFileChooser.APPROVE_OPTION) {
File[] files = fc.getSelectedFiles(); File[] files = fc.getSelectedFiles();
Collections.addAll(this.files, files); Collections.addAll(this.files, files);
@ -125,12 +144,13 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
} }
// ---------- KEY LISTENER METHODS ---------- //
@Override @Override
public void keyTyped(KeyEvent e) { public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub
} }
@Override @Override
public void keyPressed(KeyEvent e) { public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_ENTER) { if (e.getKeyCode() == KeyEvent.VK_ENTER) {
@ -141,24 +161,53 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
} }
} }
@Override @Override
public void keyReleased(KeyEvent e) { public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
} }
protected ArrayList<Message> getHistorique(){ // ---------- OTHERS ---------- //
/**
* Create and send the message to ask for a file transfer.
*/
private void askFileTransfer() {
try { try {
ArrayList<Message> historique = this.sqlManager.getHistoriquesMessages(idOther, pseudoOther); MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_INIT, "" + this.files.size(), "");
return historique; this.tcpClient.sendMessage(messageOut);
} catch (SQLException e) { } catch (MauvaisTypeMessageException | IOException e1) {
e.printStackTrace(); e1.printStackTrace();
return new ArrayList<Message>();
} }
} }
/**
* Create and send the answer with the port on which the FileTransferServer is
* listening.
*
* @param port
*/
private void answerFileTransfer(int port) {
try {
MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_ANSWER, "" + port, "");
this.tcpClient.sendMessage(messageOut);
} catch (MauvaisTypeMessageException | IOException e1) {
e1.printStackTrace();
}
}
/**
* Retrieve the files' names from the given input using ";" as a separator
* Removes the files whose names are missing.
*
* This method is used to check if a file's name has been deleted/overwritten in
* the ChatInput. Indeed, the only way to cancel the import of a file is by
* deleting its name from the ChatInput.
*
* @param input
*/
private void processSelectedFiles(String input) { private void processSelectedFiles(String input) {
String[] tmp = input.split(";"); String[] tmp = input.split(";");
ArrayList<String> potentialFiles = new ArrayList<String>(); ArrayList<String> potentialFiles = new ArrayList<String>();
@ -171,34 +220,64 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
} }
} }
private void askFileTransfer() {
/**
* Retrieve the messages previously exchanged between the current user of the
* application and the other user of this session
*
* @return The ArrayList of all previous messages
*/
protected ArrayList<Message> getHistorique() {
try { try {
MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_INIT, ""+this.files.size(), ""); ArrayList<Message> historique = this.sqlManager.getMessageRecord(idOther, pseudoOther);
this.tcpClient.sendMessage(messageOut); return historique;
} catch (MauvaisTypeMessageException | IOException e1) { } catch (SQLException e) {
e1.printStackTrace(); e.printStackTrace();
return new ArrayList<Message>();
} }
} }
private void answerFileTransfer(int port) {
/**
* Method used when the session is over. Insert every message exchanged in the
* database, set all attributes' references to null, and call destroyAll() on
* the TCPClient.
*/
protected void destroyAll() {
String idSelf = Utilisateur.getSelf().getId();
String idOther = this.idOther;
try { try {
MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_ANSWER, ""+port, ""); this.sqlManager.insertAllMessages(messagesOut, idSelf, idOther);
this.tcpClient.sendMessage(messageOut); this.sqlManager.insertAllMessages(messagesIn, idOther, idSelf);
} catch (MauvaisTypeMessageException | IOException e1) { } catch (SQLException e) {
e1.printStackTrace(); e.printStackTrace();
}
} }
//Methode appelee quand l'inputStream de la socket de communication recoit des donnees this.vue = null;
this.tcpClient.destroyAll();
this.tcpClient = null;
}
// ---------- OBSERVERS ---------- //
// Method called when a message is received from the TCP socket
@Override @Override
public void update(Object o, Object arg) { public void updateInput(Object o, Object arg) {
Message message = (Message) arg; Message message = (Message) arg;
switch (message.getTypeMessage()) { switch (message.getTypeMessage()) {
// If it is a simple text message, display it
case TEXTE: case TEXTE:
System.out.println(message.toString()); System.out.println(message.toString());
this.vue.appendMessage(message); this.vue.appendMessage(message);
this.messagesIn.add(message); this.messagesIn.add(message);
break; break;
// If it is an image, display a thumbnail
case IMAGE: case IMAGE:
this.vue.appendImage(message); this.vue.appendImage(message);
@ -208,6 +287,8 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
this.messagesIn.add(message); this.messagesIn.add(message);
} }
break; break;
// If it is a file, display a message saying whether it has been sent/received.
case FICHIER: case FICHIER:
this.vue.appendMessage(message); this.vue.appendMessage(message);
@ -217,6 +298,11 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
this.messagesIn.add(message); this.messagesIn.add(message);
} }
break; break;
// If it is a demand for a file transfer, create a new FileTransferServer, start
// it
// and answer back with "FICHIER_ANSWER" message containing the port of the
// server.
case FICHIER_INIT: case FICHIER_INIT:
try { try {
MessageFichier mFichier = (MessageFichier) arg; MessageFichier mFichier = (MessageFichier) arg;
@ -230,6 +316,10 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
e.printStackTrace(); e.printStackTrace();
} }
break; break;
// If it is an answer for a file transfer, create a FilteTransferClient
// with the port received and the path of the file(s) to send,
// and send the files.
case FICHIER_ANSWER: case FICHIER_ANSWER:
try { try {
MessageFichier mFichier = (MessageFichier) arg; MessageFichier mFichier = (MessageFichier) arg;
@ -245,32 +335,18 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
} }
break; break;
// Do nothing
default: default:
} }
} }
// If the other user closes the session or the communication is broken
// Disable the view (TextArea, Buttons..) and display a message
@Override @Override
public void updateSocketState(Object o, Object arg) { public void updateSocketState(Object o, Object arg) {
this.vue.endSession(this.pseudoOther); this.vue.endSession(this.pseudoOther);
} }
protected void destroyAll() {
String idSelf = Utilisateur.getSelf().getId();
String idOther = this.idOther;
try {
this.sqlManager.insertAllMessages(messagesOut, idSelf, idOther);
this.sqlManager.insertAllMessages(messagesIn, idOther, idSelf);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.vue = null;
this.tcpClient.destroyAll();
this.tcpClient = null;
}
} }

124
POO/src/session/VueSession.java
View file

@ -39,9 +39,6 @@ import messages.Message.TypeMessage;
public class VueSession extends JPanel { public class VueSession extends JPanel {
/**
*
*/
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private JButton sendMessage; private JButton sendMessage;
@ -58,12 +55,7 @@ public class VueSession extends JPanel {
this.setBorder(new EmptyBorder(5, 5, 5, 5)); this.setBorder(new EmptyBorder(5, 5, 5, 5));
this.setLayout(new BorderLayout(0, 0)); this.setLayout(new BorderLayout(0, 0));
this.chatInput = new JTextArea(); // Create the display zone
this.chatInput.setColumns(10);
this.chatInput.setLineWrap(true);
this.chatInput.setWrapStyleWord(true);
this.chatInput.addKeyListener(this.c);
this.chatWindow = new JTextPane(); this.chatWindow = new JTextPane();
this.chatWindow.setEditable(false); this.chatWindow.setEditable(false);
this.chatWindow.setEditorKit(new WrapEditorKit()); this.chatWindow.setEditorKit(new WrapEditorKit());
@ -71,21 +63,32 @@ public class VueSession extends JPanel {
JScrollPane chatScroll = new JScrollPane(this.chatWindow); JScrollPane chatScroll = new JScrollPane(this.chatWindow);
chatScroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED); chatScroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
// Create the input zone
this.chatInput = new JTextArea();
this.chatInput.setColumns(10);
this.chatInput.setLineWrap(true);
this.chatInput.setWrapStyleWord(true);
this.chatInput.addKeyListener(this.c);
JPanel bottom = new JPanel(); JPanel bottom = new JPanel();
bottom.setLayout(new BorderLayout(0, 0)); bottom.setLayout(new BorderLayout(0, 0));
// remap "ENTER" to "none" to avoid "\n" in the input area after sending message // Remap "ENTER" to "none" to avoid "\n" in the input area when pressing "ENTER"
// to send a message
KeyStroke enter = KeyStroke.getKeyStroke("ENTER"); KeyStroke enter = KeyStroke.getKeyStroke("ENTER");
this.chatInput.getInputMap().put(enter, "none"); this.chatInput.getInputMap().put(enter, "none");
KeyStroke shiftEnter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, KeyEvent.SHIFT_DOWN_MASK); KeyStroke shiftEnter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, KeyEvent.SHIFT_DOWN_MASK);
this.chatInput.getInputMap().put(shiftEnter, "insert-break"); this.chatInput.getInputMap().put(shiftEnter, "insert-break");
this.importFile = new JButton("Importer.."); // Create a scroller to be able to send messages of several lines
this.importFile.addActionListener(this.c);
JScrollPane inputScroll = new JScrollPane(this.chatInput); JScrollPane inputScroll = new JScrollPane(this.chatInput);
inputScroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER); inputScroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
// Import file button
this.importFile = new JButton("Importer..");
this.importFile.addActionListener(this.c);
// Send message button
this.sendMessage = new JButton("Envoyer"); this.sendMessage = new JButton("Envoyer");
this.sendMessage.addActionListener(this.c); this.sendMessage.addActionListener(this.c);
@ -93,6 +96,7 @@ public class VueSession extends JPanel {
bottom.add(inputScroll, BorderLayout.CENTER); bottom.add(inputScroll, BorderLayout.CENTER);
bottom.add(this.sendMessage, BorderLayout.EAST); bottom.add(this.sendMessage, BorderLayout.EAST);
// Add the components to the view
this.add(chatScroll, BorderLayout.CENTER); this.add(chatScroll, BorderLayout.CENTER);
this.add(bottom, BorderLayout.SOUTH); this.add(bottom, BorderLayout.SOUTH);
@ -102,32 +106,30 @@ public class VueSession extends JPanel {
} }
// -------------- GETTERS -------------- //
protected JButton getButtonEnvoyer() { protected JButton getButtonEnvoyer() {
return this.sendMessage; return this.sendMessage;
} }
protected JButton getButtonImportFile() { protected JButton getButtonImportFile() {
return this.importFile; return this.importFile;
} }
protected String getInputedText() { protected String getInputedText() {
return this.chatInput.getText(); return this.chatInput.getText();
} }
protected void appendInputedText(String str) {
this.chatInput.append(str);
}
// -------------- DISPLAY METHODS -------------- //
protected void resetZoneSaisie() { /**
this.chatInput.setText(""); * Append the given string to the ChatWindow.
*
} * @param str
*/
private void setCaretToEnd() {
this.chatWindow.setCaretPosition(this.chatWindow.getDocument().getLength());
}
protected void appendString(String str) { protected void appendString(String str) {
try { try {
Document doc = this.chatWindow.getDocument(); Document doc = this.chatWindow.getDocument();
@ -137,12 +139,16 @@ public class VueSession extends JPanel {
} }
} }
/**
* Append the given Message to the ChatWindow.
*
* @param message
*/
protected void appendMessage(Message message) { protected void appendMessage(Message message) {
try { try {
StyledDocument sdoc = this.chatWindow.getStyledDocument(); StyledDocument sdoc = this.chatWindow.getStyledDocument();
// sdoc.setParagraphAttributes(sdoc.getLength(), message.toString().length()-1,
// style, false);
sdoc.insertString(sdoc.getLength(), message.toString(), null); sdoc.insertString(sdoc.getLength(), message.toString(), null);
} catch (BadLocationException e) { } catch (BadLocationException e) {
@ -150,6 +156,14 @@ public class VueSession extends JPanel {
} }
} }
/**
* Append an icon with the image contained in the given message. The message has
* to contain the base64 encoded bytes of the image as a String for it to be
* decoded and displayed.
*
* @param message
*/
protected void appendImage(Message message) { protected void appendImage(Message message) {
this.setCaretToEnd(); this.setCaretToEnd();
@ -165,22 +179,40 @@ public class VueSession extends JPanel {
e.printStackTrace(); e.printStackTrace();
} }
} }
private void printLineSeparator() { private void printLineSeparator() {
this.appendString("------------------------------------------\n"); this.appendString("------------------------------------------\n");
} }
protected void endSession(String pseudoOther) { /**
this.printLineSeparator(); * Append the given string to the ChatInput.
this.appendString(pseudoOther + " a mis fin à la session."); *
this.chatInput.setEnabled(false); * @param str
this.chatInput.setFocusable(false); */
this.sendMessage.setEnabled(false); protected void appendInputedText(String str) {
this.importFile.setEnabled(false); this.chatInput.append(str);
} }
protected void resetZoneSaisie() {
this.chatInput.setText("");
}
// -------------- OTHERS -------------- //
private void setCaretToEnd() {
this.chatWindow.setCaretPosition(this.chatWindow.getDocument().getLength());
}
/**
* Retrieve all the previous messages from the controller and display them by
* appending them one by one to the ChatWindow.
*/
private void displayHistorique() { private void displayHistorique() {
ArrayList<Message> historique = this.c.getHistorique(); ArrayList<Message> historique = this.c.getHistorique();
@ -197,6 +229,27 @@ public class VueSession extends JPanel {
} }
} }
/**
* Disable the ChatInput, the buttons "Importer" and "Envoyer" and display a
* message indicating the other user ended the session.
*
* @param pseudoOther
*/
protected void endSession(String pseudoOther) {
this.printLineSeparator();
this.appendString(pseudoOther + " a mis fin à la session.");
this.chatInput.setEnabled(false);
this.chatInput.setFocusable(false);
this.sendMessage.setEnabled(false);
this.importFile.setEnabled(false);
}
/**
* Method used when the user closes the session. Set all attributes' references
* to null, and call destroyAll() on the controller.
*/
public void destroyAll() { public void destroyAll() {
if (this.c != null) { if (this.c != null) {
this.c.destroyAll(); this.c.destroyAll();
@ -207,6 +260,7 @@ public class VueSession extends JPanel {
this.sendMessage = null; this.sendMessage = null;
} }
// ------------- PRIVATE CLASS TO WRAP TEXT -------------// // ------------- PRIVATE CLASS TO WRAP TEXT -------------//
class WrapEditorKit extends StyledEditorKit { class WrapEditorKit extends StyledEditorKit {

5
POO/src/standard/ControleurStandard.java
View file

@ -116,7 +116,7 @@ public class ControleurStandard implements ActionListener, ListSelectionListener
} }
} catch (IOException e1) { } catch (IOException e1) {
vue.displayJOptionResponse("refusee"); e1.printStackTrace();
} }
} }
@ -245,7 +245,7 @@ public class ControleurStandard implements ActionListener, ListSelectionListener
// ------------OBSERVERS------------- // // ------------OBSERVERS------------- //
@Override @Override
public void update(Object o, Object arg) { public void updateInput(Object o, Object arg) {
if (o == this.tcpServ) { if (o == this.tcpServ) {
@ -304,6 +304,7 @@ public class ControleurStandard implements ActionListener, ListSelectionListener
private void setVueConnexion() throws UnknownHostException, IOException { private void setVueConnexion() throws UnknownHostException, IOException {
this.commUDP.sendMessageDelete(); this.commUDP.sendMessageDelete();
this.commUDP.removeAllUsers();
this.vue.removeAllUsers(); this.vue.removeAllUsers();
this.vue.closeAllSession(); this.vue.closeAllSession();
this.idsSessionEnCours.clear(); this.idsSessionEnCours.clear();