View Javadoc

1   /*
2    * Copyright 2001-2005 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package examples;
17  
18  import java.io.IOException;
19  import java.io.PrintWriter;
20  import java.net.InetAddress;
21  import org.apache.commons.net.ProtocolCommandListener;
22  import org.apache.commons.net.ftp.FTPClient;
23  import org.apache.commons.net.ftp.FTPReply;
24  
25  /***
26   * This is an example program demonstrating how to use the FTPClient class.
27   * This program arranges a server to server file transfer that transfers
28   * a file from host1 to host2.  Keep in mind, this program might only work
29   * if host2 is the same as the host you run it on (for security reasons,
30   * some ftp servers only allow PORT commands to be issued with a host
31   * argument equal to the client host).
32   * <p>
33   * Usage: ftp <host1> <user1> <pass1> <file1> <host2> <user2> <pass2> <file2>
34   * <p>
35   ***/
36  public final class server2serverFTP
37  {
38  
39      public static final void main(String[] args)
40      {
41          String server1, username1, password1, file1;
42          String server2, username2, password2, file2;
43          FTPClient ftp1, ftp2;
44          ProtocolCommandListener listener;
45  
46          if (args.length < 8)
47          {
48              System.err.println(
49                  "Usage: ftp <host1> <user1> <pass1> <file1> <host2> <user2> <pass2> <file2>"
50              );
51              System.exit(1);
52          }
53  
54          server1 = args[0];
55          username1 = args[1];
56          password1 = args[2];
57          file1 = args[3];
58          server2 = args[4];
59          username2 = args[5];
60          password2 = args[6];
61          file2 = args[7];
62  
63          listener = new PrintCommandListener(new PrintWriter(System.out));
64          ftp1 = new FTPClient();
65          ftp1.addProtocolCommandListener(listener);
66          ftp2 = new FTPClient();
67          ftp2.addProtocolCommandListener(listener);
68  
69          try
70          {
71              int reply;
72              ftp1.connect(server1);
73              System.out.println("Connected to " + server1 + ".");
74  
75              reply = ftp1.getReplyCode();
76  
77              if (!FTPReply.isPositiveCompletion(reply))
78              {
79                  ftp1.disconnect();
80                  System.err.println("FTP server1 refused connection.");
81                  System.exit(1);
82              }
83          }
84          catch (IOException e)
85          {
86              if (ftp1.isConnected())
87              {
88                  try
89                  {
90                      ftp1.disconnect();
91                  }
92                  catch (IOException f)
93                  {
94                      // do nothing
95                  }
96              }
97              System.err.println("Could not connect to server1.");
98              e.printStackTrace();
99              System.exit(1);
100         }
101 
102         try
103         {
104             int reply;
105             ftp2.connect(server2);
106             System.out.println("Connected to " + server2 + ".");
107 
108             reply = ftp2.getReplyCode();
109 
110             if (!FTPReply.isPositiveCompletion(reply))
111             {
112                 ftp2.disconnect();
113                 System.err.println("FTP server2 refused connection.");
114                 System.exit(1);
115             }
116         }
117         catch (IOException e)
118         {
119             if (ftp2.isConnected())
120             {
121                 try
122                 {
123                     ftp2.disconnect();
124                 }
125                 catch (IOException f)
126                 {
127                     // do nothing
128                 }
129             }
130             System.err.println("Could not connect to server2.");
131             e.printStackTrace();
132             System.exit(1);
133         }
134 
135 __main:
136         try
137         {
138             if (!ftp1.login(username1, password1))
139             {
140                 System.err.println("Could not login to " + server1);
141                 break __main;
142             }
143 
144             if (!ftp2.login(username2, password2))
145             {
146                 System.err.println("Could not login to " + server2);
147                 break __main;
148             }
149 
150             // Let's just assume success for now.
151             ftp2.enterRemotePassiveMode();
152 
153             ftp1.enterRemoteActiveMode(InetAddress.getByName(ftp2.getPassiveHost()),
154                                        ftp2.getPassivePort());
155 
156             // Although you would think the store command should be sent to server2
157             // first, in reality, ftp servers like wu-ftpd start accepting data
158             // connections right after entering passive mode.  Additionally, they
159             // don't even send the positive preliminary reply until after the
160             // transfer is completed (in the case of passive mode transfers).
161             // Therefore, calling store first would hang waiting for a preliminary
162             // reply.
163             if (ftp1.remoteRetrieve(file1) && ftp2.remoteStoreUnique(file2))
164             {
165                 //      if(ftp1.remoteRetrieve(file1) && ftp2.remoteStore(file2)) {
166                 // We have to fetch the positive completion reply.
167                 ftp1.completePendingCommand();
168                 ftp2.completePendingCommand();
169             }
170             else
171             {
172                 System.err.println(
173                     "Couldn't initiate transfer.  Check that filenames are valid.");
174                 break __main;
175             }
176 
177         }
178         catch (IOException e)
179         {
180             e.printStackTrace();
181             System.exit(1);
182         }
183         finally
184         {
185             try
186             {
187                 if (ftp1.isConnected())
188                 {
189                     ftp1.logout();
190                     ftp1.disconnect();
191                 }
192             }
193             catch (IOException e)
194             {
195                 // do nothing
196             }
197 
198             try
199             {
200                 if (ftp2.isConnected())
201                 {
202                     ftp2.logout();
203                     ftp2.disconnect();
204                 }
205             }
206             catch (IOException e)
207             {
208                 // do nothing
209             }
210         }
211     }
212 }