mcs/class/System/System.Net/FtpWebRequest.cs

   1 //
   2 // System.Net.FtpWebRequest.cs
   3 //
   4 // Authors:
   5 //      Carlos Alberto Cortez (calberto.cortez@gmail.com)
   6 //
   7 // (c) Copyright 2006 Novell, Inc. (http://www.novell.com)
   8 //
   9 #if NET_2_0
  10
  11 using System;
  12 using System.IO;
  13 using System.Net.Sockets;
  14 using System.Text;
  15 using System.Threading;
  16 using System.Net.Cache;
  17 using System.Security.Cryptography.X509Certificates;
  18 using System.Net;
  19
  20
  21 namespace System.Net
  22 {
  23         public sealed class FtpWebRequest : WebRequest
  24         {
  25                 Uri requestUri;
  26                 string file_name; // By now, used for upload
  27                 ServicePoint servicePoint;
  28                 Socket dataSocket;
  29                 NetworkStream controlStream;
  30                 StreamReader controlReader;
  31                 NetworkCredential credentials;
  32                 IPHostEntry hostEntry;
  33                 IPEndPoint localEndPoint;
  34                 IWebProxy proxy;
  35                 int timeout = 100000;
  36                 int rwTimeout = 300000;
  37                 long offset = 0;
  38                 bool binary = true;
  39                 bool enableSsl = false;
  40                 bool usePassive = true;
  41                 bool keepAlive = false;
  42                 string method = WebRequestMethods.Ftp.DownloadFile;
  43                 string renameTo;
  44                 object locker = new object ();
  45
  46                 RequestState requestState = RequestState.Before;
  47                 FtpAsyncResult asyncResult;
  48                 FtpWebResponse ftpResponse;
  49                 Stream requestStream;
  50                 string initial_path;
  51
  52                 const string ChangeDir = "CWD";
  53                 const string UserCommand = "USER";
  54                 const string PasswordCommand = "PASS";
  55                 const string TypeCommand = "TYPE";
  56                 const string PassiveCommand = "PASV";
  57                 const string PortCommand = "PORT";
  58                 const string AbortCommand = "ABOR";
  59                 const string AuthCommand = "AUTH";
  60                 const string RestCommand = "REST";
  61                 const string RenameFromCommand = "RNFR";
  62                 const string RenameToCommand = "RNTO";
  63                 const string QuitCommand = "QUIT";
  64                 const string EOL = "\r\n"; // Special end of line
  65
  66                 enum RequestState
  67                 {
  68                         Before,
  69                         Scheduled,
  70                         Connecting,
  71                         Authenticating,
  72                         OpeningData,
  73                         TransferInProgress,
  74                         Finished,
  75                         Aborted,
  76                         Error
  77                 }
  78
  79                 // sorted commands
  80                 static readonly string [] supportedCommands = new string [] {
  81                         WebRequestMethods.Ftp.AppendFile, // APPE
  82                         WebRequestMethods.Ftp.DeleteFile, // DELE
  83                         WebRequestMethods.Ftp.ListDirectoryDetails, // LIST
  84                         WebRequestMethods.Ftp.GetDateTimestamp, // MDTM
  85                         WebRequestMethods.Ftp.MakeDirectory, // MKD
  86                         WebRequestMethods.Ftp.ListDirectory, // NLST
  87                         WebRequestMethods.Ftp.PrintWorkingDirectory, // PWD
  88                         WebRequestMethods.Ftp.Rename, // RENAME
  89                         WebRequestMethods.Ftp.DownloadFile, // RETR
  90                         WebRequestMethods.Ftp.RemoveDirectory, // RMD
  91                         WebRequestMethods.Ftp.GetFileSize, // SIZE
  92                         WebRequestMethods.Ftp.UploadFile, // STOR
  93                         WebRequestMethods.Ftp.UploadFileWithUniqueName // STUR
  94                         };
  95
  96                 internal FtpWebRequest (Uri uri)
  97                 {
  98                         this.requestUri = uri;
  99                         this.proxy = GlobalProxySelection.Select;
 100                 }
 101
 102                 static Exception GetMustImplement ()
 103                 {
 104                         return new NotImplementedException ();
 105                 }
 106
 107                 [MonoTODO]
 108                 public X509CertificateCollection ClientCertificates
 109                 {
 110                         get {
 111                                 throw GetMustImplement ();
 112                         }
 113                         set {
 114                                 throw GetMustImplement ();
 115                         }
 116                 }
 117
 118                 [MonoTODO]
 119                 public override string ConnectionGroupName
 120                 {
 121                         get {
 122                                 throw GetMustImplement ();
 123                         }
 124                         set {
 125                                 throw GetMustImplement ();
 126                         }
 127                 }
 128
 129                 public override string ContentType {
 130                         get {
 131                                 throw new NotSupportedException ();
 132                         }
 133                         set {
 134                                 throw new NotSupportedException ();
 135                         }
 136                 }
 137
 138                 public override long ContentLength {
 139                         get {
 140                                 return 0;
 141                         }
 142                         set {
 143                                 // DO nothing
 144                         }
 145                 }
 146
 147                 public long ContentOffset {
 148                         get {
 149                                 return offset;
 150                         }
 151                         set {
 152                                 CheckRequestStarted ();
 153                                 if (value < 0)
 154                                         throw new ArgumentOutOfRangeException ();
 155
 156                                 offset = value;
 157                         }
 158                 }
 159
 160                 public override ICredentials Credentials {
 161                         get {
 162                                 return credentials;
 163                         }
 164                         set {
 165                                 CheckRequestStarted ();
 166                                 if (value == null)
 167                                         throw new ArgumentNullException ();
 168                                 if (!(value is NetworkCredential))
 169                                         throw new ArgumentException ();
 170
 171                                 credentials = value as NetworkCredential;
 172                         }
 173                 }
 174
 175                 [MonoTODO]
 176                 public static new RequestCachePolicy DefaultCachePolicy
 177                 {
 178                         get {
 179                                 throw GetMustImplement ();
 180                         }
 181                         set {
 182                                 throw GetMustImplement ();
 183                         }
 184                 }
 185
 186                 public bool EnableSsl {
 187                         get {
 188                                 return enableSsl;
 189                         }
 190                         set {
 191                                 CheckRequestStarted ();
 192                                 enableSsl = value;
 193                         }
 194                 }
 195
 196                 [MonoTODO]
 197                 public override WebHeaderCollection Headers
 198                 {
 199                         get {
 200                                 throw GetMustImplement ();
 201                         }
 202                         set {
 203                                 throw GetMustImplement ();
 204                         }
 205                 }
 206
 207                 public bool KeepAlive {
 208                         get {
 209                                 return keepAlive;
 210                         }
 211                         set {
 212                                 CheckRequestStarted ();
 213                                 keepAlive = value;
 214                         }
 215                 }
 216
 217                 public override string Method {
 218                         get {
 219                                 return method;
 220                         }
 221                         set {
 222                                 CheckRequestStarted ();
 223                                 if (value == null)
 224                                         throw new ArgumentNullException ("Method string cannot be null");
 225
 226                                 if (value.Length == 0 || Array.BinarySearch (supportedCommands, value) < 0)
 227                                         throw new ArgumentException ("Method not supported", "value");
 228
 229                                 method = value;
 230                         }
 231                 }
 232
 233                 public override bool PreAuthenticate {
 234                         get {
 235                                 throw new NotSupportedException ();
 236                         }
 237                         set {
 238                                 throw new NotSupportedException ();
 239                         }
 240                 }
 241
 242                 public override IWebProxy Proxy {
 243                         get {
 244                                 return proxy;
 245                         }
 246                         set {
 247                                 CheckRequestStarted ();
 248                                 if (value == null)
 249                                         throw new ArgumentNullException ();
 250
 251                                 proxy = value;
 252                         }
 253                 }
 254
 255                 public int ReadWriteTimeout {
 256                         get {
 257                                 return rwTimeout;
 258                         }
 259                         set {
 260                                 CheckRequestStarted ();
 261
 262                                 if (value < - 1)
 263                                         throw new ArgumentOutOfRangeException ();
 264                                 else
 265                                         rwTimeout = value;
 266                         }
 267                 }
 268
 269                 public string RenameTo {
 270                         get {
 271                                 return renameTo;
 272                         }
 273                         set {
 274                                 CheckRequestStarted ();
 275                                 if (value == null || value.Length == 0)
 276                                         throw new ArgumentException ("RenameTo value can't be null or empty", "RenameTo");
 277
 278                                 renameTo = value;
 279                         }
 280                 }
 281
 282                 public override Uri RequestUri {
 283                         get {
 284                                 return requestUri;
 285                         }
 286                 }
 287
 288                 public ServicePoint ServicePoint {
 289                         get {
 290                                 return GetServicePoint ();
 291                         }
 292                 }
 293
 294                 public bool UsePassive {
 295                         get {
 296                                 return usePassive;
 297                         }
 298                         set {
 299                                 CheckRequestStarted ();
 300                                 usePassive = value;
 301                         }
 302                 }
 303
 304                 [MonoTODO]
 305                 public override bool UseDefaultCredentials
 306                 {
 307                         get {
 308                                 throw GetMustImplement ();
 309                         }
 310                         set {
 311                                 throw GetMustImplement ();
 312                         }
 313                 }
 314
 315                 public bool UseBinary {
 316                         get {
 317                                 return binary;
 318                         } set {
 319                                 CheckRequestStarted ();
 320                                 binary = value;
 321                         }
 322                 }
 323
 324                 public override int Timeout {
 325                         get {
 326                                 return timeout;
 327                         }
 328                         set {
 329                                 CheckRequestStarted ();
 330
 331                                 if (value < -1)
 332                                         throw new ArgumentOutOfRangeException ();
 333                                 else
 334                                         timeout = value;
 335                         }
 336                 }
 337
 338                 string DataType {
 339                         get {
 340                                 return binary ? "I" : "A";
 341                         }
 342                 }
 343
 344                 RequestState State {
 345                         get {
 346                                 lock (locker) {
 347                                         return requestState;
 348                                 }
 349                         }
 350
 351                         set {
 352                                 lock (locker) {
 353                                         CheckIfAborted ();
 354                                         CheckFinalState ();
 355                                         requestState = value;
 356                                 }
 357                         }
 358                 }
 359
 360                 public override void Abort () {
 361                         lock (locker) {
 362                                 if (State == RequestState.TransferInProgress) {
 363                                         /*FtpStatus status = */
 364                                         SendCommand (false, AbortCommand);
 365                                 }
 366
 367                                 if (!InFinalState ()) {
 368                                         State = RequestState.Aborted;
 369                                         ftpResponse = new FtpWebResponse (requestUri, method, FtpStatusCode.FileActionAborted, "Aborted by request");
 370                                 }
 371                         }
 372                 }
 373
 374                 public override IAsyncResult BeginGetResponse (AsyncCallback callback, object state) {
 375                         if (asyncResult != null && !asyncResult.IsCompleted) {
 376                                 throw new InvalidOperationException ("Cannot re-call BeginGetRequestStream/BeginGetResponse while a previous call is still in progress");
 377                         }
 378
 379                         CheckIfAborted ();
 380
 381                         asyncResult = new FtpAsyncResult (callback, state);
 382
 383                         lock (locker) {
 384                                 if (InFinalState ())
 385                                         asyncResult.SetCompleted (true, ftpResponse);
 386                                 else {
 387                                         if (State == RequestState.Before)
 388                                                 State = RequestState.Scheduled;
 389
 390                                         Thread thread = new Thread (ProcessRequest);
 391                                         thread.Start ();
 392                                 }
 393                         }
 394
 395                         return asyncResult;
 396                 }
 397
 398                 public override WebResponse EndGetResponse (IAsyncResult asyncResult) {
 399                         if (asyncResult == null)
 400                                 throw new ArgumentNullException ("AsyncResult cannot be null!");
 401
 402                         if (!(asyncResult is FtpAsyncResult) || asyncResult != this.asyncResult)
 403                                 throw new ArgumentException ("AsyncResult is from another request!");
 404
 405                         FtpAsyncResult asyncFtpResult = (FtpAsyncResult) asyncResult;
 406                         if (!asyncFtpResult.WaitUntilComplete (timeout, false)) {
 407                                 Abort ();
 408                                 throw new WebException ("Transfer timed out.", WebExceptionStatus.Timeout);
 409                         }
 410
 411                         CheckIfAborted ();
 412
 413                         asyncResult = null;
 414
 415                         if (asyncFtpResult.GotException)
 416                                 throw asyncFtpResult.Exception;
 417
 418                         return asyncFtpResult.Response;
 419                 }
 420
 421                 public override WebResponse GetResponse () {
 422                         IAsyncResult asyncResult = BeginGetResponse (null, null);
 423                         return EndGetResponse (asyncResult);
 424                 }
 425
 426                 public override IAsyncResult BeginGetRequestStream (AsyncCallback callback, object state) {
 427                         if (method != WebRequestMethods.Ftp.UploadFile && method != WebRequestMethods.Ftp.UploadFileWithUniqueName &&
 428                                         method != WebRequestMethods.Ftp.AppendFile)
 429                                 throw new ProtocolViolationException ();
 430
 431                         lock (locker) {
 432                                 CheckIfAborted ();
 433
 434                                 if (State != RequestState.Before)
 435                                         throw new InvalidOperationException ("Cannot re-call BeginGetRequestStream/BeginGetResponse while a previous call is still in progress");
 436
 437                                 State = RequestState.Scheduled;
 438                         }
 439
 440                         asyncResult = new FtpAsyncResult (callback, state);
 441                         Thread thread = new Thread (ProcessRequest);
 442                         thread.Start ();
 443
 444                         return asyncResult;
 445                 }
 446
 447                 public override Stream EndGetRequestStream (IAsyncResult asyncResult) {
 448                         if (asyncResult == null)
 449                                 throw new ArgumentNullException ("asyncResult");
 450
 451                         if (!(asyncResult is FtpAsyncResult))
 452                                 throw new ArgumentException ("asyncResult");
 453
 454                         if (State == RequestState.Aborted) {
 455                                 throw new WebException ("Request aborted", WebExceptionStatus.RequestCanceled);
 456                         }
 457
 458                         if (asyncResult != this.asyncResult)
 459                                 throw new ArgumentException ("AsyncResult is from another request!");
 460
 461                         FtpAsyncResult res = (FtpAsyncResult) asyncResult;
 462
 463                         if (!res.WaitUntilComplete (timeout, false)) {
 464                                 Abort ();
 465                                 throw new WebException ("Request timed out");
 466                         }
 467
 468                         if (res.GotException)
 469                                 throw res.Exception;
 470
 471                         return res.Stream;
 472                 }
 473
 474                 public override Stream GetRequestStream () {
 475                         IAsyncResult asyncResult = BeginGetRequestStream (null, null);
 476                         return EndGetRequestStream (asyncResult);
 477                 }
 478
 479                 ServicePoint GetServicePoint ()
 480                 {
 481                         if (servicePoint == null)
 482                                 servicePoint = ServicePointManager.FindServicePoint (requestUri, proxy);
 483
 484                         return servicePoint;
 485                 }
 486
 487                 // Probably move some code of command connection here
 488                 void ResolveHost ()
 489                 {
 490                         CheckIfAborted ();
 491                         hostEntry = GetServicePoint ().HostEntry;
 492
 493                         if (hostEntry == null) {
 494                                 ftpResponse.UpdateStatus (new FtpStatus(FtpStatusCode.ActionAbortedLocalProcessingError, "Cannot resolve server name"));
 495                                 throw new WebException ("The remote server name could not be resolved: " + requestUri,
 496                                         null, WebExceptionStatus.NameResolutionFailure, ftpResponse);
 497                         }
 498                 }
 499
 500                 void ProcessRequest () {
 501
 502                         if (State == RequestState.Scheduled) {
 503                                 ftpResponse = new FtpWebResponse (requestUri, method, keepAlive);
 504
 505                                 try {
 506                                         ProcessMethod ();
 507                                         //State = RequestState.Finished;
 508                                         //finalResponse = ftpResponse;
 509                                         asyncResult.SetCompleted (false, ftpResponse);
 510                                 }
 511                                 catch (Exception e) {
 512                                         State = RequestState.Error;
 513                                         SetCompleteWithError (e);
 514                                 }
 515                         }
 516                         else {
 517                                 if (InProgress ()) {
 518                                         FtpStatus status = GetResponseStatus ();
 519
 520                                         ftpResponse.UpdateStatus (status);
 521
 522                                         if (ftpResponse.IsFinal ()) {
 523                                                 State = RequestState.Finished;
 524                                         }
 525                                 }
 526
 527                                 asyncResult.SetCompleted (false, ftpResponse);
 528                         }
 529                 }
 530
 531                 void SetType ()
 532                 {
 533                         if (binary) {
 534                                 FtpStatus status = SendCommand (TypeCommand, DataType);
 535                                 if ((int) status.StatusCode < 200 || (int) status.StatusCode >= 300)
 536                                         throw CreateExceptionFromResponse (status);
 537                         }
 538                 }
 539
 540                 string GetRemoteFolderPath (Uri uri)
 541                 {
 542                         string result;
 543                         string local_path = Uri.UnescapeDataString (uri.LocalPath);
 544                         if (initial_path == null) {
 545                                 result = local_path;
 546                         } else {
 547                                 if (local_path [0] == '/')
 548                                         local_path = local_path.Substring (1);
 549                                 Uri initial = new Uri (initial_path);
 550                                 result = new Uri (initial, local_path).LocalPath;
 551                         }
 552
 553                         int last = result.LastIndexOf ('/');
 554                         if (last == -1)
 555                                 return null;
 556
 557                         return result.Substring (0, last + 1);
 558                 }
 559
 560                 void CWDAndSetFileName (Uri uri)
 561                 {
 562                         string remote_folder = GetRemoteFolderPath (uri);
 563                         FtpStatus status;
 564                         if (remote_folder != null) {
 565                                 status = SendCommand (ChangeDir, remote_folder);
 566                                 if ((int) status.StatusCode < 200 || (int) status.StatusCode >= 300)
 567                                         throw CreateExceptionFromResponse (status);
 568
 569                                 int last = uri.LocalPath.LastIndexOf ('/');
 570                                 if (last >= 0) {
 571                                         file_name = Uri.UnescapeDataString (uri.LocalPath.Substring (last + 1));
 572                                 }
 573                         }
 574                 }
 575
 576                 void ProcessMethod ()
 577                 {
 578                         State = RequestState.Connecting;
 579
 580                         ResolveHost ();
 581
 582                         OpenControlConnection ();
 583
 584                         switch (method) {
 585                         // Open data connection and receive data
 586                         case WebRequestMethods.Ftp.DownloadFile:
 587                                 CWDAndSetFileName (requestUri);
 588                                 SetType ();
 589                                 DownloadData ();
 590                                 break;
 591                         case WebRequestMethods.Ftp.ListDirectory:
 592                         case WebRequestMethods.Ftp.ListDirectoryDetails:
 593                                 SetType ();
 594                                 DownloadData ();
 595                                 break;
 596                         // Open data connection and send data
 597                         case WebRequestMethods.Ftp.AppendFile:
 598                         case WebRequestMethods.Ftp.UploadFile:
 599                         case WebRequestMethods.Ftp.UploadFileWithUniqueName:
 600                                 CWDAndSetFileName (requestUri);
 601                                 SetType ();
 602                                 UploadData ();
 603                                 break;
 604                         // Get info from control connection
 605                         case WebRequestMethods.Ftp.GetFileSize:
 606                         case WebRequestMethods.Ftp.GetDateTimestamp:
 607                         case WebRequestMethods.Ftp.PrintWorkingDirectory:
 608                         case WebRequestMethods.Ftp.MakeDirectory:
 609                         case WebRequestMethods.Ftp.Rename:
 610                         case WebRequestMethods.Ftp.DeleteFile:
 611                                 ProcessSimpleMethod ();
 612                                 break;
 613                         default: // What to do here?
 614                                 throw new Exception (String.Format ("Support for command {0} not implemented yet", method));
 615                         }
 616
 617                         CheckIfAborted ();
 618                 }
 619
 620                 private void CloseControlConnection () {
 621                         SendCommand (QuitCommand);
 622                         controlStream.Close ();
 623                 }
 624
 625                 private void CloseDataConnection () {
 626                         if(dataSocket != null)
 627                                 dataSocket.Close ();
 628                 }
 629
 630                 private void CloseConnection () {
 631                         CloseControlConnection ();
 632                         CloseDataConnection ();
 633                 }
 634
 635                 void ProcessSimpleMethod ()
 636                 {
 637                         State = RequestState.TransferInProgress;
 638
 639                         FtpStatus status;
 640
 641                         if (method == WebRequestMethods.Ftp.PrintWorkingDirectory)
 642                                 method = ChangeDir;
 643
 644                         if (method == WebRequestMethods.Ftp.Rename)
 645                                 method = RenameFromCommand;
 646
 647                         status = SendCommand (method, requestUri.LocalPath);
 648
 649                         ftpResponse.Stream = new EmptyStream ();
 650
 651                         string desc = status.StatusDescription;
 652
 653                         switch (method) {
 654                         case WebRequestMethods.Ftp.GetFileSize: {
 655                                         if (status.StatusCode != FtpStatusCode.FileStatus)
 656                                                 throw CreateExceptionFromResponse (status);
 657
 658                                         int i, len;
 659                                         long size;
 660                                         for (i = 4, len = 0; i < desc.Length && Char.IsDigit (desc [i]); i++, len++)
 661                                                 ;
 662
 663                                         if (len == 0)
 664                                                 throw new WebException ("Bad format for server response in " + method);
 665
 666                                         if (!Int64.TryParse (desc.Substring (4, len), out size))
 667                                                 throw new WebException ("Bad format for server response in " + method);
 668
 669                                         ftpResponse.contentLength = size;
 670                                 }
 671                                 break;
 672                         case WebRequestMethods.Ftp.GetDateTimestamp:
 673                                 if (status.StatusCode != FtpStatusCode.FileStatus)
 674                                         throw CreateExceptionFromResponse (status);
 675                                 ftpResponse.LastModified = DateTime.ParseExact (desc.Substring (4), "yyyyMMddHHmmss", null);
 676                                 break;
 677                         case WebRequestMethods.Ftp.MakeDirectory:
 678                                 if (status.StatusCode != FtpStatusCode.PathnameCreated)
 679                                         throw CreateExceptionFromResponse (status);
 680                                 break;
 681                         case ChangeDir:
 682                                 method = WebRequestMethods.Ftp.PrintWorkingDirectory;
 683
 684                                 if (status.StatusCode != FtpStatusCode.FileActionOK)
 685                                         throw CreateExceptionFromResponse (status);
 686
 687                                 status = SendCommand (method);
 688
 689                                 if (status.StatusCode != FtpStatusCode.PathnameCreated)
 690                                         throw CreateExceptionFromResponse (status);
 691                                 break;
 692                         case RenameFromCommand:
 693                                 method = WebRequestMethods.Ftp.Rename;
 694                                 if (status.StatusCode != FtpStatusCode.FileCommandPending)
 695                                         throw CreateExceptionFromResponse (status);
 696                                 // Pass an empty string if RenameTo wasn't specified
 697                                 status = SendCommand (RenameToCommand, renameTo != null ? renameTo : String.Empty);
 698                                 if (status.StatusCode != FtpStatusCode.FileActionOK)
 699                                         throw CreateExceptionFromResponse (status);
 700                                 break;
 701                         case WebRequestMethods.Ftp.DeleteFile:
 702                                 if (status.StatusCode != FtpStatusCode.FileActionOK)
 703                                         throw CreateExceptionFromResponse (status);
 704                                 break;
 705                         }
 706
 707                         State = RequestState.Finished;
 708                 }
 709
 710                 void UploadData ()
 711                 {
 712                         State = RequestState.OpeningData;
 713
 714                         OpenDataConnection ();
 715
 716                         State = RequestState.TransferInProgress;
 717                         requestStream = new FtpDataStream (this, dataSocket, false);
 718                         asyncResult.Stream = requestStream;
 719                 }
 720
 721                 void DownloadData ()
 722                 {
 723                         State = RequestState.OpeningData;
 724
 725                         // Handle content offset
 726                         if (offset > 0) {
 727                                 FtpStatus status = SendCommand (RestCommand, offset.ToString ());
 728
 729                                 if (status.StatusCode != FtpStatusCode.FileCommandPending)
 730                                         throw CreateExceptionFromResponse (status);
 731                         }
 732
 733                         OpenDataConnection ();
 734
 735                         State = RequestState.TransferInProgress;
 736                         ftpResponse.Stream = new FtpDataStream (this, dataSocket, true);
 737                 }
 738
 739                 void CheckRequestStarted ()
 740                 {
 741                         if (State != RequestState.Before)
 742                                 throw new InvalidOperationException ("There is a request currently in progress");
 743                 }
 744
 745                 void OpenControlConnection ()
 746                 {
 747                         Socket sock = null;
 748                         foreach (IPAddress address in hostEntry.AddressList) {
 749                                 sock = new Socket (address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 750
 751                                 IPEndPoint remote = new IPEndPoint (address, requestUri.Port);
 752
 753                                 if (!ServicePoint.CallEndPointDelegate (sock, remote)) {
 754                                         sock.Close ();
 755                                         sock = null;
 756                                 } else {
 757                                         try {
 758                                                 sock.Connect (remote);
 759                                                 localEndPoint = (IPEndPoint) sock.LocalEndPoint;
 760                                                 break;
 761                                         } catch (SocketException) {
 762                                                 sock.Close ();
 763                                                 sock = null;
 764                                         }
 765                                 }
 766                         }
 767
 768                         // Couldn't connect to any address
 769                         if (sock == null)
 770                                 throw new WebException ("Unable to connect to remote server", null,
 771                                                 WebExceptionStatus.UnknownError, ftpResponse);
 772
 773                         controlStream = new NetworkStream (sock);
 774                         controlReader = new StreamReader (controlStream, Encoding.ASCII);
 775
 776                         State = RequestState.Authenticating;
 777
 778                         Authenticate ();
 779                         FtpStatus status = SendCommand ("OPTS", "utf8", "on");
 780                         // ignore status for OPTS
 781                         status = SendCommand (WebRequestMethods.Ftp.PrintWorkingDirectory);
 782                         initial_path = GetInitialPath (status);
 783                 }
 784
 785                 static string GetInitialPath (FtpStatus status)
 786                 {
 787                         int s = (int) status.StatusCode;
 788                         if (s < 200 || s > 300 || status.StatusDescription.Length <= 4)
 789                                 throw new WebException ("Error getting current directory: " + status.StatusDescription, null,
 790                                                 WebExceptionStatus.UnknownError, null);
 791
 792                         string msg = status.StatusDescription.Substring (4);
 793                         if (msg [0] == '"')
 794                                 msg = msg.Substring (1, msg.Length - 2);
 795
 796                         if (!msg.EndsWith ("/"))
 797                                 msg += "/";
 798                         return msg;
 799                 }
 800
 801                 // Probably we could do better having here a regex
 802                 Socket SetupPassiveConnection (string statusDescription)
 803                 {
 804                         // Current response string
 805                         string response = statusDescription;
 806                         if (response.Length < 4)
 807                                 throw new WebException ("Cannot open passive data connection");
 808
 809                         // Look for first digit after code
 810                         int i;
 811                         for (i = 3; i < response.Length && !Char.IsDigit (response [i]); i++)
 812                                 ;
 813                         if (i >= response.Length)
 814                                 throw new WebException ("Cannot open passive data connection");
 815
 816                         // Get six elements
 817                         string [] digits = response.Substring (i).Split (new char [] {','}, 6);
 818                         if (digits.Length != 6)
 819                                 throw new WebException ("Cannot open passive data connection");
 820
 821                         // Clean non-digits at the end of last element
 822                         int j;
 823                         for (j = digits [5].Length - 1; j >= 0 && !Char.IsDigit (digits [5][j]); j--)
 824                                 ;
 825                         if (j < 0)
 826                                 throw new WebException ("Cannot open passive data connection");
 827
 828                         digits [5] = digits [5].Substring (0, j + 1);
 829
 830                         IPAddress ip;
 831                         try {
 832                                 ip = IPAddress.Parse (String.Join (".", digits, 0, 4));
 833                         } catch (FormatException) {
 834                                 throw new WebException ("Cannot open passive data connection");
 835                         }
 836
 837                         // Get the port
 838                         int p1, p2, port;
 839                         if (!Int32.TryParse (digits [4], out p1) || !Int32.TryParse (digits [5], out p2))
 840                                 throw new WebException ("Cannot open passive data connection");
 841
 842                         port = (p1 << 8) + p2; // p1 * 256 + p2
 843                         //port = p1 * 256 + p2;
 844                         if (port < IPEndPoint.MinPort || port > IPEndPoint.MaxPort)
 845                                 throw new WebException ("Cannot open passive data connection");
 846
 847                         IPEndPoint ep = new IPEndPoint (ip, port);
 848                         Socket sock = new Socket (ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 849                         try {
 850                                 sock.Connect (ep);
 851                         } catch (SocketException) {
 852                                 sock.Close ();
 853                                 throw new WebException ("Cannot open passive data connection");
 854                         }
 855
 856                         return sock;
 857                 }
 858
 859                 Exception CreateExceptionFromResponse (FtpStatus status)
 860                 {
 861                         FtpWebResponse ftpResponse = new FtpWebResponse (requestUri, method, status);
 862
 863                         WebException exc = new WebException ("Server returned an error: " + status.StatusDescription,
 864                                 null, WebExceptionStatus.ProtocolError, ftpResponse);
 865                         return exc;
 866                 }
 867
 868                 // Here we could also get a server error, so be cautious
 869                 internal void SetTransferCompleted ()
 870                 {
 871                         if (InFinalState ())
 872                                 return;
 873
 874                         State = RequestState.Finished;
 875                         FtpStatus status = GetResponseStatus ();
 876                         ftpResponse.UpdateStatus (status);
 877                         if(!keepAlive)
 878                                 CloseConnection ();
 879                 }
 880
 881                 void SetCompleteWithError (Exception exc)
 882                 {
 883                         if (asyncResult != null) {
 884                                 asyncResult.SetCompleted (false, exc);
 885                         }
 886                 }
 887
 888                 Socket InitDataConnection ()
 889                 {
 890                         FtpStatus status;
 891
 892                         if (usePassive) {
 893                                 status = SendCommand (PassiveCommand);
 894                                 if (status.StatusCode != FtpStatusCode.EnteringPassive) {
 895                                         throw CreateExceptionFromResponse (status);
 896                                 }
 897
 898                                 return SetupPassiveConnection (status.StatusDescription);
 899                         }
 900
 901                         // Open a socket to listen the server's connection
 902                         Socket sock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 903                         try {
 904                                 sock.Bind (new IPEndPoint (localEndPoint.Address, 0));
 905                                 sock.Listen (1); // We only expect a connection from server
 906
 907                         } catch (SocketException e) {
 908                                 sock.Close ();
 909
 910                                 throw new WebException ("Couldn't open listening socket on client", e);
 911                         }
 912
 913                         IPEndPoint ep = (IPEndPoint) sock.LocalEndPoint;
 914                         string ipString = ep.Address.ToString ().Replace (".", ",");
 915                         int h1 = ep.Port >> 8; // ep.Port / 256
 916                         int h2 = ep.Port % 256;
 917
 918                         string portParam = ipString + "," + h1 + "," + h2;
 919                         status = SendCommand (PortCommand, portParam);
 920
 921                         if (status.StatusCode != FtpStatusCode.CommandOK) {
 922                                 sock.Close ();
 923                                 throw (CreateExceptionFromResponse (status));
 924                         }
 925
 926                         return sock;
 927                 }
 928
 929                 void OpenDataConnection ()
 930                 {
 931                         FtpStatus status;
 932
 933                         Socket s = InitDataConnection ();
 934
 935                         if(method != WebRequestMethods.Ftp.UploadFileWithUniqueName) {
 936                                 status = SendCommand (method, file_name);
 937                         } else {
 938                                 status = SendCommand (method);
 939                         }
 940
 941                         if (status.StatusCode != FtpStatusCode.OpeningData && status.StatusCode != FtpStatusCode.DataAlreadyOpen)
 942                                 throw CreateExceptionFromResponse (status);
 943
 944                         if (usePassive) {
 945                                 dataSocket = s;
 946                         }
 947                         else {
 948
 949                                 // Active connection (use Socket.Blocking to true)
 950                                 Socket incoming = null;
 951                                 try {
 952                                         incoming = s.Accept ();
 953                                 }
 954                                 catch (SocketException) {
 955                                         s.Close ();
 956                                         if (incoming != null)
 957                                                 incoming.Close ();
 958
 959                                         throw new ProtocolViolationException ("Server commited a protocol violation.");
 960                                 }
 961
 962                                 s.Close ();
 963                                 dataSocket = incoming;
 964                         }
 965
 966                         if (EnableSsl) {
 967                                 InitiateSecureConnection (ref controlStream);
 968                                 controlReader = new StreamReader (controlStream, Encoding.ASCII);
 969                         }
 970
 971                         ftpResponse.UpdateStatus (status);
 972                 }
 973
 974                 void Authenticate ()
 975                 {
 976                         string username = null;
 977                         string password = null;
 978                         string domain = null;
 979
 980                         if (credentials != null) {
 981                                 username = credentials.UserName;
 982                                 password = credentials.Password;
 983                                 domain = credentials.Domain;
 984                         }
 985
 986                         if (username == null)
 987                                 username = "anonymous";
 988                         if (password == null)
 989                                 password = "@anonymous";
 990                         if (!string.IsNullOrEmpty (domain))
 991                                 username = domain + '\\' + username;
 992
 993                         // Connect to server and get banner message
 994                         FtpStatus status = GetResponseStatus ();
 995                         ftpResponse.BannerMessage = status.StatusDescription;
 996
 997                         if (EnableSsl) {
 998                                 InitiateSecureConnection (ref controlStream);
 999                                 controlReader = new StreamReader (controlStream, Encoding.ASCII);
1000                         }
1001
1002                         if (status.StatusCode != FtpStatusCode.SendUserCommand)
1003                                 throw CreateExceptionFromResponse (status);
1004
1005                         status = SendCommand (UserCommand, username);
1006
1007                         switch (status.StatusCode) {
1008                         case FtpStatusCode.SendPasswordCommand:
1009                                 status = SendCommand (PasswordCommand, password);
1010                                 if (status.StatusCode != FtpStatusCode.LoggedInProceed)
1011                                         throw CreateExceptionFromResponse (status);
1012                                 break;
1013                         case FtpStatusCode.LoggedInProceed:
1014                                 break;
1015                         default:
1016                                 throw CreateExceptionFromResponse (status);
1017                         }
1018
1019                         ftpResponse.WelcomeMessage = status.StatusDescription;
1020                         ftpResponse.UpdateStatus (status);
1021                 }
1022
1023                 FtpStatus SendCommand (string command, params string [] parameters) {
1024                         return SendCommand (true, command, parameters);
1025                 }
1026
1027                 FtpStatus SendCommand (bool waitResponse, string command, params string [] parameters)
1028                 {
1029                         byte [] cmd;
1030                         string commandString = command;
1031                         if (parameters.Length > 0)
1032                                 commandString += " " + String.Join (" ", parameters);
1033
1034                         commandString += EOL;
1035                         cmd = Encoding.ASCII.GetBytes (commandString);
1036                         try {
1037                                 controlStream.Write (cmd, 0, cmd.Length);
1038                         } catch (IOException) {
1039                                 //controlStream.Close ();
1040                                 return new FtpStatus(FtpStatusCode.ServiceNotAvailable, "Write failed");
1041                         }
1042
1043                         if(!waitResponse)
1044                                 return null;
1045
1046                         FtpStatus result = GetResponseStatus ();
1047                         if (ftpResponse != null)
1048                                 ftpResponse.UpdateStatus (result);
1049                         return result;
1050                 }
1051
1052                 internal static FtpStatus ServiceNotAvailable ()
1053                 {
1054                         return new FtpStatus (FtpStatusCode.ServiceNotAvailable, Locale.GetText ("Invalid response from server"));
1055                 }
1056
1057                 internal FtpStatus GetResponseStatus ()
1058                 {
1059                         while (true) {
1060                                 string response = null;
1061
1062                                 try {
1063                                         response = controlReader.ReadLine ();
1064                                 } catch (IOException) {
1065                                 }
1066
1067                                 if (response == null || response.Length < 3)
1068                                         return ServiceNotAvailable ();
1069
1070                                 int code;
1071                                 if (!Int32.TryParse (response.Substring (0, 3), out code))
1072                                         return ServiceNotAvailable ();
1073
1074                                 if (response [3] == '-'){
1075                                         string line = null;
1076                                         string find = code.ToString() + ' ';
1077                                         while (true){
1078                                                 try {
1079                                                         line = controlReader.ReadLine();
1080                                                 } catch (IOException) {
1081                                                 }
1082                                                 if (line == null)
1083                                                         return ServiceNotAvailable ();
1084
1085                                                 response += Environment.NewLine + line;
1086
1087                                                 if (line.StartsWith(find, StringComparison.Ordinal))
1088                                                         break;
1089                                         }
1090                                 }
1091                                 return new FtpStatus ((FtpStatusCode) code, response);
1092                         }
1093                 }
1094
1095                 private void InitiateSecureConnection (ref NetworkStream stream) {
1096                         FtpStatus status = SendCommand (AuthCommand, "TLS");
1097
1098                         if (status.StatusCode != FtpStatusCode.ServerWantsSecureSession) {
1099                                 throw CreateExceptionFromResponse (status);
1100                         }
1101
1102                         ChangeToSSLSocket (ref stream);
1103                 }
1104
1105                 internal static bool ChangeToSSLSocket (ref NetworkStream stream) {
1106 #if TARGET_JVM
1107                         stream.ChangeToSSLSocket ();
1108                         return true;
1109 #else
1110                         throw new NotImplementedException ();
1111 #endif
1112                 }
1113
1114                 bool InFinalState () {
1115                         return (State == RequestState.Aborted || State == RequestState.Error || State == RequestState.Finished);
1116                 }
1117
1118                 bool InProgress () {
1119                         return (State != RequestState.Before && !InFinalState ());
1120                 }
1121
1122                 internal void CheckIfAborted () {
1123                         if (State == RequestState.Aborted)
1124                                 throw new WebException ("Request aborted", WebExceptionStatus.RequestCanceled);
1125                 }
1126
1127                 void CheckFinalState () {
1128                         if (InFinalState ())
1129                                 throw new InvalidOperationException ("Cannot change final state");
1130                 }
1131
1132                 class EmptyStream : MemoryStream
1133                 {
1134                         internal EmptyStream ()
1135                                 : base (new byte [0], false) {
1136                         }
1137                 }
1138         }
1139 }
1140
1141 #endif
1142