KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > drftpd > slave > async > AsyncSlaveListener


1 /*
2  * SocketSlaveListener.java
3  *
4  * Created on April 28, 2004, 2:03 PM
5  */

6
7 package org.drftpd.slave.async;
8
9 import java.io.BufferedReader JavaDoc;
10 import java.io.EOFException JavaDoc;
11 import java.io.IOException JavaDoc;
12 import java.io.InputStreamReader JavaDoc;
13 import java.io.PrintWriter JavaDoc;
14 import java.io.StringReader JavaDoc;
15
16 import java.net.InetAddress JavaDoc;
17 import java.net.ServerSocket JavaDoc;
18 import java.net.Socket JavaDoc;
19
20 import java.util.Collection JavaDoc;
21 import java.util.Iterator JavaDoc;
22
23 import java.security.MessageDigest JavaDoc;
24
25 import net.sf.drftpd.FatalException;
26 import net.sf.drftpd.master.ConnectionManager;
27 import net.sf.drftpd.master.RemoteSlave;
28
29 import org.apache.log4j.Logger;
30 import org.apache.oro.text.GlobCompiler;
31 import org.apache.oro.text.regex.MalformedPatternException;
32 import org.apache.oro.text.regex.Pattern;
33 import org.apache.oro.text.regex.Perl5Matcher;
34
35 import socks.server.Ident;
36
37 /**
38  *
39  * @author jbarrett
40  */

41 public class AsyncSlaveListener extends Thread JavaDoc {
42     
43     private static final Logger logger = Logger.getLogger(AsyncSlaveListener.class.getName());
44     
45     private int _port;
46     private ServerSocket JavaDoc sock;
47     static ConnectionManager _conman;
48     static String JavaDoc _pass = "";
49     
50     static void invalidSlave(String JavaDoc msg, Socket JavaDoc sock) throws IOException JavaDoc {
51         BufferedReader JavaDoc _sinp = null;
52         PrintWriter JavaDoc _sout = null;
53         try {
54             _sout = new PrintWriter JavaDoc(sock.getOutputStream(), true);
55             _sinp = new BufferedReader JavaDoc(
56             new InputStreamReader JavaDoc(sock.getInputStream())
57             );
58             _sout.println(msg);
59             logger.info("NEW< " + msg);
60             String JavaDoc txt = AsyncSlaveListener.readLine(_sinp, 30);
61             String JavaDoc sname = "";
62             String JavaDoc spass = "";
63             String JavaDoc shash = "";
64             try {
65                 String JavaDoc[] items = txt.split(" ");
66                 sname = items[1].trim();
67                 spass = items[2].trim();
68                 shash = items[3].trim();
69             } catch (Exception JavaDoc e) {
70                 throw new IOException JavaDoc("Slave Inititalization Faailed");
71             }
72             // generate slave hash
73
String JavaDoc pass = sname + spass + _pass;
74             MessageDigest JavaDoc md5 = MessageDigest.getInstance("MD5");
75             md5.reset();
76             md5.update(pass.getBytes());
77             String JavaDoc hash = AsyncSlaveListener.hash2hex(md5.digest()).toLowerCase();
78             if (!hash.equals(shash)) {
79                 throw new IOException JavaDoc("Slave Inititalization Faailed");
80             }
81             
82             // check the passkey and create the slave
83

84         } catch (Exception JavaDoc e) {
85             
86         }
87         throw new IOException JavaDoc("Slave Inititalization Faailed");
88     }
89     
90     static String JavaDoc hash2hex(byte[] bytes) {
91         String JavaDoc res = "";
92         for (int i = 0; i < 16; i++) {
93             String JavaDoc hex = Integer.toHexString((int) bytes[i]);
94             if (hex.length() < 2)
95                 hex = "0" + hex;
96             res += hex.substring(hex.length() - 2);
97         }
98         return res;
99     }
100     
101     
102     static String JavaDoc readLine(BufferedReader JavaDoc _sinp, int secs) {
103         int cnt = secs * 10;
104         try {
105             while (true) {
106                 while (!_sinp.ready()) {
107                     if (cnt < 1)
108                         return null;
109                     sleep(100);
110                     cnt--;
111                     if (cnt == 0)
112                         return null;
113                 }
114                 String JavaDoc txt = _sinp.readLine();
115                 logger.info("NEW> " + txt);
116                 return txt;
117             }
118         } catch (Exception JavaDoc e) {
119             return null;
120         }
121     }
122     
123     /** Creates a new instance of SocketSlaveListener */
124     public AsyncSlaveListener(ConnectionManager conman, int port, String JavaDoc pass) {
125         _conman = conman;
126         _port = port;
127         _pass = pass;
128         start();
129     }
130     
131     public void run() {
132         try {
133             sock = new ServerSocket JavaDoc(_port);
134         } catch (Exception JavaDoc e) {
135             throw new FatalException(e);
136         }
137         Socket JavaDoc slave;
138         while (true) {
139             try {
140                 slave = sock.accept();
141             } catch (Exception JavaDoc e) {
142                 throw new FatalException(e);
143             }
144             InetAddress JavaDoc addr = slave.getInetAddress();
145             logger.info("AsyncSlaveListener: accepting " + addr);
146             Ident identObj = new Ident(slave);
147             String JavaDoc ident;
148             if (identObj.successful) {
149                 ident = identObj.userName;
150             } else {
151                 ident = "";
152             }
153             Perl5Matcher m = new Perl5Matcher();
154             
155             String JavaDoc ipmask = ident + "@" + addr.getHostAddress();
156             String JavaDoc hostmask = ident + "@" + addr.getHostName();
157             logger.info("AsyncSlaveListener: ipmask " + ipmask);
158             logger.info("AsyncSlaveListener: hostmask " + hostmask);
159             Collection JavaDoc slaves = _conman.getSlaveManager().getSlaves();
160             boolean match = false;
161             RemoteSlave thisone = null;
162             for (Iterator JavaDoc i=slaves.iterator(); i.hasNext();) {
163                 RemoteSlave rslave = (RemoteSlave)i.next();
164                 if (rslave.isAvailable()) {
165                     logger.info("AsyncSlaveListener: online> " + rslave.getName());
166                     continue; // already connected
167
}
168                 String JavaDoc saddr = (String JavaDoc)rslave.getConfig().get("addr");
169                 if (saddr == null) {
170                     logger.info("AsyncSlaveListener: noaddr> " + rslave.getName());
171                     continue; // not a socketslave
172
}
173                 if (!saddr.equals("Dynamic")) {
174                     logger.info("AsyncSlaveListener: static> " + rslave.getName());
175                     continue; // is a static slave
176
}
177                 // unconnected dynamic socket slave, test masks
178
logger.info("AsyncSlaveListener: testing " + rslave.getName());
179                 for (Iterator JavaDoc i2 = rslave.getMasks().iterator(); i2.hasNext(); ) {
180                     String JavaDoc mask = (String JavaDoc) i2.next();
181                     logger.info("SockSlaveListener: mask = " + mask);
182                     Pattern p;
183                     try {
184                         p = new GlobCompiler().compile(mask);
185                     } catch (MalformedPatternException ex) {
186                         throw new RuntimeException JavaDoc(
187                         "Invalid glob pattern: " + mask,
188                         ex
189                         );
190                     }
191                     
192                     // ip
193
if (m.matches(ipmask, p) || m.matches(hostmask, p)) {
194                         match = true;
195                         thisone = rslave;
196                         break;
197                     }
198                 } //for
199
if (match) break;
200             } //for
201
if (match) {
202                 // turn control over to the slave code
203
try {
204                     AsyncSlave tmp = new AsyncSlave(_conman, thisone.getConfig(), slave);
205                 } catch (Exception JavaDoc e) {
206                 }
207             } else {
208                 // allow the slave to auto-register
209
try {
210                     AsyncSlaveListener.invalidSlave("INITFAIL Unregistered", slave);
211                 } catch (Exception JavaDoc e) {
212                 }
213             }
214         }
215     }
216 }
217
Popular Tags