private static void transferFichier(SocketUtils clientStream)
{
string result = REPONSE_NON;
try
{
// Nom du fichier a recevoir
string nom = clientStream.LireChemin();
string sTaille = clientStream.LireLigne();
Mainform.WriteMessageToConsole($"Chemin du fichier: {nom}, taille {sTaille}");
// Taille du fichier a recevoir
long taille = long.Parse(sTaille);
string path = Path.Combine(Settings.Default.RepertoireDeBase, nom);
if (checkPath(ref path))
{
FileStream f = File.Create(path);
long nbLus = clientStream.LitFichier(taille, f);
f.Close();
result = REPONSE_OUI;
}
}
catch (Exception e)
{
Mainform.WriteErrorToConsole("Erreur dans transfertfichier");
Mainform.WriteExceptionToConsole(e);
}
Mainform.WriteMessageToConsole($"Réponse: {result}");
clientStream.EcritLigne(result);
}
/// <summary>
/// Verifie l'existence d'un fichier
/// Reponse: REPONSE_OUI ou REPONSE_NON
/// </summary>
/// <param name="clientStream"></param>
private static void fichierExiste(SocketUtils clientStream)
{
string result = REPONSE_NON;
try
{
string fichier = clientStream.LireChemin();
Mainform.WriteMessageToConsole($"Test du fichier: {fichier}");
string path = Path.Combine(Settings.Default.RepertoireDeBase, fichier);
if (checkPath(ref path))
{
bool existe = File.Exists(path);
result = existe ? REPONSE_OUI : REPONSE_NON;
}
}
catch (Exception e)
{
Mainform.WriteErrorToConsole("Erreur dans lireLigne");
Mainform.WriteExceptionToConsole(e);
}
Mainform.WriteMessageToConsole($"Réponse: {result}");
clientStream.EcritLigne(result);
}
internal async Task <bool> demarre()
{
_tcpListener = null;
try
{
// Set the listener on the local IP address
// and specify the port.
_tcpListener = new TcpListener(_adresse, _port);
_enroute = true;
_tcpListener.Start();
Mainform.WriteMessageToConsole("#######################################################################");
Mainform.WriteMessageToConsole("# Sauvegarde Locale, serveur #");
Mainform.WriteMessageToConsole("# Lucien Pilloni 2019 #");
Mainform.WriteMessageToConsole("#######################################################################");
Directory.CreateDirectory(Settings.Default.RepertoireDeBase);
Mainform.WriteMessageToConsole("Répertoire de base " + Settings.Default.RepertoireDeBase);
Mainform.WriteMessageToConsole("Adresse du serveur " + _tcpListener.LocalEndpoint);
Mainform.WriteMessageToConsole("En attente de connexion...");
_serveurThread = new Thread(serveurThread);
_serveurThread.Start();
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
_enroute = false;
}
return(true);
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Obtient la liste des fichiers d'un repertoire
/// </summary>
/// <param name="clientStream"></param>
///////////////////////////////////////////////////////////////////////////////////////////////
private static void listeFichiers(SocketUtils clientStream)
{
StringBuilder sb = new StringBuilder();
try
{
string repertoire = clientStream.LireChemin();
string filtre = clientStream.LireLigne();
Mainform.WriteMessageToConsole($"{LISTE_FICHIERS} Chemin : {repertoire}, filtre {filtre}");
string path = Path.Combine(Settings.Default.RepertoireDeBase, repertoire);
string[] fileEntries = Directory.GetFiles(path, filtre);
if (checkPath(ref path))
{
if (fileEntries?.Length > 0)
{
sb.Append(Path.GetFileName(fileEntries[0]));
for (int i = 1; i < fileEntries.Length; i++)
{
sb.Append(SocketUtils.SEPARATEUR).Append(Path.GetFileName(fileEntries[i]));
}
}
}
}
catch (Exception)
{
}
clientStream.EcritLigne(sb.ToString());
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Traite une requete
/// </summary>
/// <param name="client"></param>
///////////////////////////////////////////////////////////////////////////////////////////////
public static void traiteRequete(object client)
{
nbRequetes++;
Mainform.UpdateNbRequetes();
try
{
bool continuer = true;
TcpClient tcpClient = client as TcpClient;
NetworkStream clntStream = tcpClient.GetStream();
SocketUtils clientStream = new SocketUtils(clntStream);
//do
//{
string commande = clientStream.LireLigne();
if (commande?.Length > 0)
{
Mainform.WriteMessageToConsole($"Requête: {commande}");
switch (commande)
{
case TEST_ADRESSE: testAdresse(clientStream); break;
case CREER_REPERTOIRE: creerRepertoire(clientStream); break;
case FICHIER_EXISTE: fichierExiste(clientStream); break;
case UPLOAD_FICHIER: transferFichier(clientStream); break;
case TRANSFERT_FICHIER_DATE: transferFichierDate(clientStream); break;
case CHANGE_DATE: setDate(clientStream); break;
case INVALIDES_CHEMIN: caracteresInvalidesChemin(clientStream); break;
case FERMER: continuer = false; break;
case LISTE_FICHIERS: listeFichiers(clientStream); break;
case LISTE_REPERTOIRES: listeRepertoires(clientStream); break;
case DOWNLOAD_FICHIER: downloadFichier(clientStream); break;
default:
Mainform.WriteErrorToConsole($"Commande inconnue: '{commande}'"); break;
}
}
//}
//while (continuer);
Mainform.WriteMessageToConsole("Socket closed");
}
catch (Exception e)
{
Mainform.WriteErrorToConsole("Erreur dans le traitement de la requête");
Mainform.WriteExceptionToConsole(e);
}
nbRequetes--;
Mainform.UpdateNbRequetes();
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Modification de la date d'un fichier
/// </summary>
/// <param name="clientStream"></param>
///////////////////////////////////////////////////////////////////////////////////////////////
private static void setDate(SocketUtils clientStream)
{
string fichier = clientStream.LireChemin();
DateTime date = clientStream.LitDate();
Mainform.WriteMessageToConsole($"Chemin du fichier: {fichier}, date {date}");
string path = Path.Combine(Settings.Default.RepertoireDeBase, fichier);
if (checkPath(ref path))
{
setDate(path, date);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Repondre avec la liste des caracteres invalides pour les chemins sur ce systeme
/// </summary>
/// <param name="clientStream"></param>
///////////////////////////////////////////////////////////////////////////////////////////////
private static void caracteresInvalidesChemin(SocketUtils clientStream)
{
char[] b = Path.GetInvalidPathChars();
StringBuilder sb = new StringBuilder();
foreach (char c in b)
{
if (c != SocketUtils.TERMINAL) // Attention! mettre le caractere TERMINAL dans le buffer amenerai le client a ignorer les suivants
{
sb.Append(c);
}
}
Mainform.WriteMessageToConsole($"{INVALIDES_CHEMIN}: {sb.ToString()}");
clientStream.EcritLigne(sb.ToString());
}
internal async Task <bool> arrete()
{
try
{
_enroute = false;
_tcpListener?.Stop();
_serveurThread?.Abort();
_tcpListener = null;
Mainform.WriteMessageToConsole("Serveur arrêté");
}
catch (Exception e)
{
Mainform.WriteErrorToConsole("Erreur dans serveurThread");
Mainform.WriteExceptionToConsole(e);
}
return(true);
}
/// <summary>
/// Lit un nombre donne d'octets dans la socket et les ecrit dans un fichier
/// </summary>
/// <param name="taille"></param>
/// <param name="clientStream"></param>
/// <param name="sOutput"></param>
/// <returns></returns>
public long LitFichier(long taille, FileStream sOutput)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
// Lecture des octets
byte[] buffer = new byte[1024 * 32];
long nbLus = 0;
try
{
while (nbLus < taille)
{
int nbAlire = (int)Math.Min(buffer.Length, taille - nbLus);
int nb = _clientStream.Read(buffer, 0, nbAlire);
sOutput.Write(buffer, 0, nb);
nbLus += nb;
}
}
catch (Exception e)
{
Mainform.WriteErrorToConsole("Erreur dans transfertfichier");
Mainform.WriteExceptionToConsole(e);
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
double vitesse = nbLus / ts.TotalSeconds;
String vit;
if (vitesse > 1000)
{
vit = (vitesse / 1000.0).ToString("F2") + " ko/s";
}
else
{
vit = vitesse.ToString("F2") + " o/s";
}
Mainform.WriteMessageToConsole($"{nbLus} octets lus en {ts.TotalSeconds.ToString("F3")} sec soit {vit}");
return(nbLus);
}
/// <summary>
/// Download fichier
/// </summary>
/// <param name="clientStream"></param>
private static void downloadFichier(SocketUtils clientStream)
{
string result = REPONSE_NON;
string fichier = clientStream.LireChemin();
string path = Path.Combine(Settings.Default.RepertoireDeBase, fichier);
if (checkPath(ref path))
{
bool existe = File.Exists(path);
if (existe)
{
Mainform.WriteMessageToConsole($"{DOWNLOAD_FICHIER} Chemin : {path}");
clientStream.EcritLigne(REPONSE_OUI);
FileStream fileStream = new FileStream(path, FileMode.Open);
if (fileStream != null)
{
long taille = fileStream.Length;
// Ecrire la taille
clientStream.EcritLigne(taille.ToString());
// Copier le fichier
clientStream.EcritFichier(taille, fileStream);
fileStream.Close();
result = REPONSE_OUI;
}
else
{
Mainform.WriteMessageToConsole($"{DOWNLOAD_FICHIER} Chemin : {path} fichier non trouvé!");
}
}
else
{
Mainform.WriteMessageToConsole($"{DOWNLOAD_FICHIER} Chemin : {path} fichier non trouvé!");
}
}
clientStream.EcritLigne(result);
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Obtient la liste des sous repertoires d'un repertoire
/// </summary>
/// <param name="clientStream"></param>
///////////////////////////////////////////////////////////////////////////////////////////////
private static void listeRepertoires(SocketUtils clientStream)
{
string repertoire = clientStream.LireChemin();
Mainform.WriteMessageToConsole($"Contenu de: {repertoire}");
string path = Path.Combine(Settings.Default.RepertoireDeBase, repertoire);
string[] fileEntries = Directory.GetDirectories(path);
StringBuilder sb = new StringBuilder();
if (checkPath(ref path))
{
if (fileEntries?.Length > 0)
{
sb.Append(Path.GetFileName(fileEntries[0]));
for (int i = 1; i < fileEntries.Length; i++)
{
sb.Append(SocketUtils.SEPARATEUR).Append(Path.GetFileName(fileEntries[i]));
}
}
}
clientStream.EcritLigne(sb.ToString());
}
private static void creerRepertoire(SocketUtils clientStream)
{
string result = REPONSE_NON;
try
{
string repertoire = clientStream.LireChemin();
Mainform.WriteMessageToConsole($"Répertoire à créer: {repertoire}");
string path = Path.Combine(Settings.Default.RepertoireDeBase, repertoire);
if (checkPath(ref path))
{
Directory.CreateDirectory(path);
result = REPONSE_OUI;
}
}
catch (Exception e)
{
Mainform.WriteErrorToConsole("Erreur dans creerRepertoire");
Mainform.WriteExceptionToConsole(e);
}
Mainform.WriteMessageToConsole($"Réponse: {result}");
clientStream.EcritLigne(result);
}