1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
|
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.IO;
namespace FTPBeta2
{
public class FTPHelper2
{
#region attributs
private string _RemoteHost;
private string _RemotePath;
private string _RemoteUser;
private string _RemotePass;
private string _ConnectionGroupName;
private int _RemotePort;
private bool _Passive;
private bool _Binary;
private FtpWebRequest _Request;
private FtpWebResponse _Response;
#endregion
#region accesseurs
///<summary>Adresse IP ou nom DNS du serveur FTP Distant</summary>
public string RemoteHost
{
get { return this._RemoteHost;}
set
{
this._RemoteHost = value;
if (this._RemoteHost.EndsWith("/") ||
this._RemoteHost.EndsWith(@"\"))
this._RemoteHost = this._RemoteHost.Substring(0,
this._RemoteHost.Length - 1);
}
}
///<summary> Répertoire distant</summary>
public string RemotePath
{
get { return this._RemotePath;}
set
{
this._RemotePath = value;
if (this._RemotePath.EndsWith("/") ||
this._RemotePath.EndsWith(@"\"))
this._RemotePath = this._RemotePath.Substring(0,
this._RemotePath.Length - 1);
}
}
///<summary> Nom du ConnectionGroupName</summary>
public string ConnectionGroupName
{
get { return this._ConnectionGroupName;}
set { this._ConnectionGroupName = value;}
}
///<summary> Nom d'utilisateur utilisé pour l'authentification FTP</summary>
public string RemoteUser
{
get { return this._RemoteUser;}
set { this._RemoteUser = value;}
}
///<summary>Numéro du port à utiliser pour se connecter sur le FTP Distant
///</summary>
public int RemotePort
{
get { return this._RemotePort;}
set { this._RemotePort = value;}
}
///<summary> Password utilisé pour l'authentification FTP</summary>
public string RemotePass
{
set { this._RemotePass = value;}
}
///<summary> Utilisation du mode Passif (activé par défaut)</summary>
public bool Passive
{
get { return this._Passive;}
set { this._Passive = value;}
}
///<summary>Utilisation du transfert de type Binaire (activé par défaut)
///</summary>
public bool BinaryMode
{
get { return this._Binary;}
set { this._Binary = value;}
}
#endregion
#region constructeur
///<summary> Retourne une instance de FTPHelper</summary>
public FTPHelper2()
{
_RemoteHost = "";
_RemotePath = "";
_RemoteUser = "";
_RemotePass = "";
_RemotePort = 0;
_Passive = true;
_Binary = true;
}
#endregion
#region méthodes publiques
///<summary> Etablie la connection avec le serveur FTP.</summary>
public void login()
{
//cette méthode permet juste de savoir si les crédentials fournis
// ont correct, en demandant une simple request : PWD
this.GetResponse(this.GetUri(),
WebRequestMethods.Ftp.PrintWorkingDirectory);
this._Response.Close();
}
///<summary> Ferme la connection avec le serveur FTP.</summary>
public void close()
{
// Pour fermer la connection (ie envoyer la commande QUIT)
// la seule solution trouvée est de faire un nouveau
// FtpWebRequest avec KeepAlive à faux, ainsi, apres la
// fermeture du response, la commande QUIT est envoyée...
this.CreateRequest(this.GetUri(),
WebRequestMethods.Ftp.PrintWorkingDirectory);
this._Request.KeepAlive = false;
this._Response = (FtpWebResponse)this._Request.GetResponse();
this._Response.Close();
}
///<summary> Efface un fichier distant.
///<param name="FTPFileName">Nom du fichier distant a effacer</param></summary>
public void deleteRemoteFile(string FTPFileName)
{
this.GetResponse(this.GetUri() + FTPFileName,
WebRequestMethods.Ftp.DeleteFile);
this._Response.Close();
}
///<summary> Envoi un fichier LocalFileName passé en paramètre sur
/// le répertoire FTP distant avec le meme nom dans le répertoire FTP
///. Ne modifie pas le choix du mode passif et du type de transfert
/// (par défaut, passif et binary)</summary>
///<param name="LocalFileName">Nom complet du fichier local</param>
public void upload(string LocalFileName)
{
this.upload(LocalFileName, Path.GetFileName(LocalFileName));
}
///<summary>
/// Envoi un fichier LocalFileName passé en paramètre sur le
/// répertoire FTP distant avec comme nom FTPFileName passé en
/// paramètre dans le répertoire FTP. Ne modifie pas le choix du mode
/// passif et du type de transfert (par défaut, passif et binary)
///</summary><param name="LocalFileName">
/// Nom complet du fichier local</param>
/// <param name="FTPFileName">
///Nom du fichier à créer sur le FTP distant</param>
public void upload(string LocalFileName, string FTPFileName)
{
if (!File.Exists(LocalFileName))
{
throw new Exception("Erreur lors de l'envoi du fichier " +
LocalFileName + ": Fichier inexistant.");
}
//récuperation du contenu du fichier à envoyer dans un buffer
FileStream Input = new FileStream(LocalFileName, FileMode.Open);
Byte[] tabByte = ReadFully(Input, 0);
//creation de la requete et récuperation du stream
CreateRequest(this.GetUri() + FTPFileName,
WebRequestMethods.Ftp.UploadFile);
Stream RequestStream = this._Request.GetRequestStream();
//envoi
RequestStream.Write(tabByte, 0, tabByte.Length);
RequestStream.Close();
this._Response = (FtpWebResponse)this._Request.GetResponse();
Input.Close();
this._Response.Close();
}
///<summary>
/// Télécharge un fichier passé FTPFileName en paramètre sur le
/// répertoire FTP distant,et l'enregistre localement dans le fichier
/// LocalFileName passé en paramètre. Ne modifie pas le choix du
/// mode passif et du type de transfert (par défaut, passif et binary)
///</summary><param name="LocalFileName">
/// Nom complet du fichier local</param>
///<param name="FTPFileName"> Nom du fichier distant</param>
public void download(string FTPFileName, string LocalFileName)
{
if (!File.Exists(LocalFileName))
{
Stream st = File.Create(LocalFileName);
st.Close();
}
FileStream Output = new FileStream(LocalFileName,FileMode.Open);
this.GetResponse(this.GetUri() + FTPFileName,
WebRequestMethods.Ftp.DownloadFile);
Byte[] tabByte = ReadFully(this._Response.GetResponseStream(),
0);
Output.Write(tabByte, 0, tabByte.Length);
Output.Close();
this._Response.Close();
}
///<summary>
/// Renvoit la liste de tous des fichiers répondant au critère spécifié
/// par le filtre passé en paramètre contenu sur le répertoire FTP
/// distant.</summary><param name="filter">
/// le filtre à appliquer. De la forme "*", "*.*", "nomfichier.*",
/// "*.ext", "nomfichier" ou "nomfichier.extension"</param>
/// <returns>un tableau de string contenant chaque fichier
/// répondant au critère</returns>
public string[] getFileList(string filter)
{
List<string> temp = new List<string>();
string[] listeToFilter = getFileList();
if (filter == "*.*")
{
foreach (string fileToFilter in listeToFilter)
{
if (fileToFilter.Contains("."))
temp.Add(fileToFilter);
}
}
else if (filter.EndsWith(".*"))
{
string prefixe = filter.Substring(0, filter.LastIndexOf('.'));
foreach (string fileToFilter in listeToFilter)
{
if (fileToFilter.StartsWith(prefixe) && fileToFilter.Contains("."))
temp.Add(fileToFilter);
}
}
else if (filter.StartsWith("*."))
{
string extension = filter.Substring(filter.LastIndexOf('.'));
foreach (string fileToFilter in listeToFilter)
{
if (fileToFilter.EndsWith(extension))
temp.Add(fileToFilter);
}
}
else if (filter == "*")
{ temp.AddRange(listeToFilter);}
else
{
foreach (string fileToFilter in listeToFilter)
{
if (fileToFilter == filter)
temp.Add(fileToFilter);
}
}
return temp.ToArray();
}
///<summary> Renvoit la liste de tous les fichiers contenu sur le
/// répertoire FTP distant. </summary>
/// <returns>un tableau de string contenant chaque fichier</returns>
public string[] getFileList()
{
//on demande le listing détaillé, ie de la forme :
// -rw-r--r-- 1 ftp ftp 432415232 Apr 21 2005 fichier.txt
// drwxr-xr-x 1 ftp ftp 0 May 27 15:04 repertoire
// -rw-r--r-- 1 ftp ftp 56320 May 27 12:28 ficher2.txt
// Ainsi, on pourra exclure les repertoire de la liste retournée
this.GetResponse(this.GetUri(),
WebRequestMethods.Ftp.ListDirectoryDetails);
StreamReader sr = new StreamReader
(this._Response.GetResponseStream(), Encoding.Default);
string ss = sr.ReadToEnd();
string[] seperator = { "\r\n" };
string[] tab = ss.Split(seperator,
StringSplitOptions.RemoveEmptyEntries);
List<string> result = new List<string>();
for (int i = 0; i < tab.Length; i++)
{
if (!tab.StartsWith("d"))
result.Add(tab.Substring(tab.LastIndexOf(" ") + 1));
}
this._Response.Close();
return result.ToArray();
}
///<summary> Renvoit la liste des répertoires contenu sur le
/// répertoire FTP distant.</summary>
///<returns>
/// un tableau de string contenant chaque répertoire</returns>
public string[] ListDirectories()
{
//on demande le listing détaillé, ie de la forme :
// -rw-r--r-- 1 ftp ftp 432415232 Apr 21 2005 fichier.txt
// drwxr-xr-x 1 ftp ftp 0 May 27 15:04 repertoire
// -rw-r--r-- 1 ftp ftp 56320 May 27 12:28 ficher2.txt
//
// Ainsi, on pourra exclure les fichiers de la liste retournée
this.GetResponse(this.GetUri(),
WebRequestMethods.Ftp.ListDirectoryDetails);
StreamReader sr = new StreamReader
(this._Response.GetResponseStream(), Encoding.Default);
string ss = sr.ReadToEnd();
string[] seperator = { "\r\n" };
string[] tab = ss.Split(seperator,
StringSplitOptions.RemoveEmptyEntries);
List<string> result = new List<string>();
for (int i = 0; i < tab.Length; i++)
{
if (tab.StartsWith("d"))
result.Add(tab.Substring(tab.LastIndexOf(" ") + 1));
}
this._Response.Close();
return result.ToArray();
}
#endregion
#region méthodes privées
///<summary> Crée la FtpWebResponse avec la FtpMethod passée en parametre.</summary>
private void GetResponse(string Uri, string method)
{
CreateRequest(Uri, method);
this._Response = (FtpWebResponse)this._Request.GetResponse();
}
/// <summary>
/// Crée la FtpWebRequest avec la FtpMethod passée en parametre
/// </summary>
private void CreateRequest(string Uri, string method)
{
this._Request = (FtpWebRequest)FtpWebRequest.Create(Uri);
this._Request.UsePassive = this._Passive;
this._Request.UseBinary = this._Binary;
this._Request.KeepAlive = true;
this._Request.Credentials = new NetworkCredential
(this._RemoteUser, this._RemotePass);
this._Request.Method = method;
}
///<summary> Renvoit une string representant l'URI. Celle-ci est
/// composé du préfixe "ftp://", de l'adresse du serveur, du numéro
/// de port et du repertoire distant : ftp://netfinances.fr:21/datas/
/// </summary><returns>une string contenant l'URI</returns>
private string GetUri()
{
return "ftp://" + this._RemoteHost + ":" + this._RemotePort
+ "/" + this.RemotePath + "/";
}
///<summary> Lit les données depuis un stream jusqu'a ce que la fin
/// soit atteinte. Les données sont retournées sous la forme d'un
/// tableau de Byte.</summary>
/// <param name="stream">Le stream ou lire les données</param>
/// <param name="initialLength">Taille initiale du buffer</param>
private byte[] ReadFully(Stream stream, int initialLength)
{
//voir http://www.yoda.arachsys.com/csharp/readbinary.html
if (initialLength < 1)
{ initialLength = 32768;}
byte[] buffer = new byte[initialLength];
int read = 0;
int chunk;
while ((chunk = stream.Read(buffer, read, buffer.Length - read)) > 0)
{
read += chunk;
if (read == buffer.Length)
{
int nextByte = stream.ReadByte();
if (nextByte == -1)
{ return buffer;}
byte[] newBuffer = new byte[buffer.Length * 2];
Array.Copy(buffer, newBuffer, buffer.Length);
newBuffer[read] = (byte)nextByte;
buffer = newBuffer;
read++;
}
}
// Le buffer est trop grand. On le redimensionne
byte[] ret = new byte[read];
Array.Copy(buffer, ret, read);
return ret;
}
#endregion
}
} |
