1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package tests.support;
19
20import java.io.FileInputStream;
21import java.io.IOException;
22import java.io.InputStream;
23import java.util.Hashtable;
24
25/**
26 * This class is responsible for providing the dynamic names and addresses for
27 * the java.net classes. There are two directories which need to be placed on an
28 * ftp server and an http server which should accompany this source. The
29 * ftp-files have to be placed on an ftp server and have to be the root of a
30 * user jcltest with password jclpass. The testres files must be available on an
31 * HTTP server and the name and location can be configured below.
32 */
33public class Support_Configuration {
34
35    public static String DomainAddress = "apache.org";
36
37    public static String WebName = "jcltest.";
38
39    public static final String HomeAddress;
40
41    public static String TestResourcesDir = "/testres231";
42
43    public static final String TestResources;
44
45    public static String HomeAddressResponse = "HTTP/1.1 200 OK";
46
47    public static String HomeAddressSoftware = "Jetty(6.0.x)";
48
49    public static String ProxyServerTestHost = "jcltest.apache.org";
50
51    public static String SocksServerTestHost = "jcltest.apache.org";
52
53    public static int SocksServerTestPort = 1080;
54
55    // Need an IP address that does not resolve to a host name
56    public static String UnresolvedIP = "192.168.99.99";
57
58    // the bytes for an address which represents an address which is not
59    // one of the addresses for any of our machines on which tests will run
60    // it is used to verify we get the expected error when we try to bind
61    // to an address that is not one of the machines local addresses
62    public static byte nonLocalAddressBytes[] = { 1, 0, 0, 0 };
63
64    public static String InetTestIP = "127.0.0.1";
65
66    public static String InetTestIP2 = "127.0.0.1";
67
68    public static final String HomeAddress6 = "jcltest6.apache.org";
69
70    public static String ProxyServerTestHostIPv6 = "jcltest6.apache.org";
71
72    // ip address that resolves to a host that is not present on the local
73    // network
74    // this allows us to check the timeouts for connect
75    public static String ResolvedNotExistingHost = "9.26.194.72";
76
77    /**
78     * You can compute the hash code with the following code: try { String name =
79     * "whatever.xxx.com";
80     * System.out.println(InetAddress.getByName(name).hashCode()); } catch
81     * (UnknownHostException e) {}
82     */
83
84    public static String FTPTestAddress = "jcltest:jclpass@localhost";
85
86    public static String URLConnectionLastModifiedString = "Mon, 14 Jun 1999 21:06:22 GMT";
87
88    public static long URLConnectionLastModified = 929394382000L;
89
90    public static boolean RunCommTests = false;
91
92    public static String Port1 = "COM1";
93
94    public static String Port2 = "COM2";
95
96    static Hashtable<String, String> props = null;
97
98    static {
99        loadProperties();
100        HomeAddress = WebName + DomainAddress;
101        TestResources = HomeAddress + TestResourcesDir;
102    }
103
104    static void loadProperties() {
105        InputStream in = null;
106        Hashtable<String, String> props = new Hashtable<String, String>();
107
108        String iniName = System.getProperty("test.ini.file", "JCLAuto.ini");
109        if (System.getProperty("test.comm") != null) {
110            RunCommTests = true;
111        }
112
113        try {
114            in = new FileInputStream(iniName);
115        } catch (IOException e) {
116        } catch (Exception e) {
117            System.out.println("SupportConfiguration.loadProperties()");
118            System.out.println(e);
119            e.printStackTrace();
120        }
121        if (in == null) {
122            try {
123                Class<?> cl = Class
124                        .forName("com.ibm.support.Support_Configuration");
125                in = cl.getResourceAsStream(iniName);
126            } catch (ClassNotFoundException e) {
127            }
128        }
129        try {
130            if (in != null) {
131                load(in, props);
132            }
133        } catch (IOException e) {
134        }
135        if (props.size() == 0) {
136            return;
137        }
138        String value;
139
140        value = props.get("DomainAddress");
141        if (value != null) {
142            DomainAddress = value;
143        }
144
145        value = props.get("WebName");
146        if (value != null) {
147            WebName = value;
148        }
149
150        value = props.get("TestResourcesDir");
151        if (value != null) {
152            TestResourcesDir = value;
153        }
154        value = props.get("HomeAddressResponse");
155        if (value != null) {
156            HomeAddressResponse = value;
157        }
158
159        value = props.get("HomeAddressSoftware");
160        if (value != null) {
161            HomeAddressSoftware = value;
162        }
163
164        value = props.get("ProxyServerTestHost");
165        if (value != null) {
166            ProxyServerTestHost = value;
167        }
168
169        value = props.get("SocksServerTestHost");
170        if (value != null) {
171            SocksServerTestHost = value;
172        }
173
174        value = props.get("SocksServerTestPort");
175        if (value != null) {
176            SocksServerTestPort = Integer.parseInt(value);
177        }
178
179        value = props.get("UnresolvedIP");
180        if (value != null) {
181            UnresolvedIP = value;
182        }
183
184        value = props.get("FTPTestAddress");
185        if (value != null) {
186            FTPTestAddress = value;
187        }
188
189        value = props.get("URLConnectionLastModifiedString");
190        if (value != null) {
191            URLConnectionLastModifiedString = value;
192        }
193
194        value = props.get("URLConnectionLastModified");
195        if (value != null) {
196            URLConnectionLastModified = Long.parseLong(value);
197        }
198
199        value = props.get("Port1");
200        if (value != null) {
201            Port1 = value;
202        }
203
204        value = props.get("Port2");
205        if (value != null) {
206            Port2 = value;
207        }
208
209        value = props.get("ProxyServerTestHostIPv6");
210        if (value != null) {
211            ProxyServerTestHostIPv6 = value;
212        }
213
214        value = props.get("ResolvedNotExistingHost");
215        if (value != null) {
216            ResolvedNotExistingHost = value;
217        }
218
219    }
220
221    static void load(InputStream in, Hashtable<String, String> result) throws IOException {
222        int NONE = 0, SLASH = 1, UNICODE = 2, CONTINUE = 3, DONE = 4, IGNORE = 5;
223        int mode = NONE, unicode = 0, count = 0, nextChar;
224        StringBuffer key = new StringBuffer(), value = new StringBuffer(), buffer = key;
225        boolean firstChar = true;
226
227        while ((nextChar = in.read()) != -1) {
228            if (mode == UNICODE) {
229                int digit = Character.digit((char) nextChar, 16);
230                if (digit >= 0) {
231                    unicode = (unicode << 4) + digit;
232                    if (++count < 4) {
233                        continue;
234                    }
235                }
236                mode = NONE;
237                buffer.append((char) unicode);
238                if (nextChar != '\n') {
239                    continue;
240                }
241            }
242            if (mode == SLASH) {
243                mode = NONE;
244                switch (nextChar) {
245                    case '\r':
246                        mode = CONTINUE; // Look for a following \n
247                        continue;
248                    case '\n':
249                        mode = IGNORE; // Ignore whitespace on the next line
250                        continue;
251                    case 'b':
252                        nextChar = '\b';
253                        break;
254                    case 'f':
255                        nextChar = '\f';
256                        break;
257                    case 'n':
258                        nextChar = '\n';
259                        break;
260                    case 'r':
261                        nextChar = '\r';
262                        break;
263                    case 't':
264                        nextChar = '\t';
265                        break;
266                    case 'u':
267                        mode = UNICODE;
268                        unicode = count = 0;
269                        continue;
270                }
271            } else {
272                switch (nextChar) {
273                    case '#':
274                    case '!':
275                        if (firstChar) {
276                            while ((nextChar = in.read()) != -1) {
277                                if (nextChar == '\r' || nextChar == '\n') {
278                                    break;
279                                }
280                            }
281                            continue;
282                        }
283                        break;
284                    case '\n':
285                        if (mode == CONTINUE) { // Part of a \r\n sequence
286                            mode = IGNORE; // Ignore whitespace on the next line
287                            continue;
288                        }
289                        // fall into the next case
290                    case '\r':
291                        mode = NONE;
292                        firstChar = true;
293                        if (key.length() > 0 || buffer == value) {
294                            result.put(key.toString(), value.toString());
295                        }
296                        key.setLength(0);
297                        value.setLength(0);
298                        buffer = key;
299                        continue;
300                    case '\\':
301                        mode = SLASH;
302                        continue;
303                    case ':':
304                    case '=':
305                        if (buffer == key) {
306                            buffer = value;
307                            continue;
308                        }
309                        break;
310                }
311                char c = (char) nextChar;
312                if ((c >= 0x1c && c <= 0x20) || (c >= 0x9 && c <= 0xd)) {
313                    if (mode == CONTINUE) {
314                        mode = IGNORE;
315                    }
316                    if (buffer.length() == 0 || mode == IGNORE) {
317                        continue;
318                    }
319                    if (buffer == key) {
320                        mode = DONE;
321                        continue;
322                    }
323                }
324                if (mode == IGNORE || mode == CONTINUE) {
325                    mode = NONE;
326                }
327            }
328            firstChar = false;
329            if (mode == DONE) {
330                buffer = value;
331                mode = NONE;
332            }
333            buffer.append((char) nextChar);
334        }
335        if (key.length() > 0 || buffer == value) {
336            result.put(key.toString(), value.toString());
337        }
338    }
339
340}
341