3. Araxis Merge File Comparison Report

Produced by Araxis Merge on 2016-08-05 08:06:52 +0000. See www.araxis.com for information about Merge. This report uses XHTML and CSS2, and is best viewed with a modern standards-compliant browser. For optimum results when printing this report, use landscape orientation and enable printing of background images and colours in your browser.

3.1 Files compared

#	Location	File	Last Modified
1	/Merge Test Files/jakarta-tomcat-4.0.6-src/catalina/src/share/org/apache/catalina/connector/http	HttpConnector.java	2002-10-08 14:15:34 +0000
2	/Merge Test Files/jakarta-tomcat-4.1.18-src/catalina/src/share/org/apache/catalina/connector/http	HttpConnector.java	2002-12-19 13:49:44 +0000

3.2 Comparison summary

Description	Between Files 1 and 2
Description	Text Blocks	Lines
Unchanged	18	2388
Changed	8	72
Inserted	9	34
Removed	0	0

3.3 Comparison options

Whitespace	Differences in whitespace are significant
Character case	Differences in character case are significant
Line endings	Differences in line endings (`CR` and `LF` characters) are significant
CR/LF characters	Not shown in the comparison detail

3.4 Active regular expressions

No regular expressions were active.

3.5 Comparison detail

1	/*	1	/*
2	* $Header: /home/cvs/jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/connector/http/HttpConnector.java,v 1.24.2.2 2002/01/3 1 23:13:5 3 craigmcc Exp $	2	* $Header: /home/cvs/jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/connector/http/HttpConnector.java,v 1.34 2002/0 3/18 07:1 5:39 remm Exp $
3	* $Revision: 1.24.2.2 $	3	* $Revision: 1.34 $
4	* $Date: 2002/01/3 1 23:13:5 3 $	4	* $Date: 2002/0 3/18 07:1 5:39 $
5	*	5	*
6	* ====================================================================	6	* ====================================================================
7	*	7	*
8	* The Apache Software License, Version 1.1	8	* The Apache Software License, Version 1.1
9	*	9	*
10	* Copyright (c) 1999 The Apache Software Foundation. All rights	10	* Copyright (c) 1999 The Apache Software Foundation. All rights
11	* reserved.	11	* reserved.
12	*	12	*
13	* Redistribution and use in source and binary forms, with or without	13	* Redistribution and use in source and binary forms, with or without
14	* modification, are permitted provided that the following conditions	14	* modification, are permitted provided that the following conditions
15	* are met:	15	* are met:
16	*	16	*
17	* 1. Redistributions of source code must retain the above copyright	17	* 1. Redistributions of source code must retain the above copyright
18	* notice, this list of conditions and the following disclaimer.	18	* notice, this list of conditions and the following disclaimer.
19	*	19	*
20	* 2. Redistributions in binary form must reproduce the above copyright	20	* 2. Redistributions in binary form must reproduce the above copyright
21	* notice, this list of conditions and the following disclaimer in	21	* notice, this list of conditions and the following disclaimer in
22	* the documentation and/or other materials provided with the	22	* the documentation and/or other materials provided with the
23	* distribution.	23	* distribution.
24	*	24	*
25	* 3. The end-user documentation included with the redistribution, if	25	* 3. The end-user documentation included with the redistribution, if
26	* any, must include the following acknowlegement:	26	* any, must include the following acknowlegement:
27	* "This product includes software developed by the	27	* "This product includes software developed by the
28	* Apache Software Foundation (http://www.apache.org/)."	28	* Apache Software Foundation (http://www.apache.org/)."
29	* Alternately, this acknowlegement may appear in the software itself,	29	* Alternately, this acknowlegement may appear in the software itself,
30	* if and wherever such third-party acknowlegements normally appear.	30	* if and wherever such third-party acknowlegements normally appear.
31	*	31	*
32	* 4. The names "The Jakarta Project", "Tomcat", and "Apache Software	32	* 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
33	* Foundation" must not be used to endorse or promote products derived	33	* Foundation" must not be used to endorse or promote products derived
34	* from this software without prior written permission. For written	34	* from this software without prior written permission. For written
35	* permission, please contact apache@apache.org.	35	* permission, please contact apache@apache.org.
36	*	36	*
37	* 5. Products derived from this software may not be called "Apache"	37	* 5. Products derived from this software may not be called "Apache"
38	* nor may "Apache" appear in their names without prior written	38	* nor may "Apache" appear in their names without prior written
39	* permission of the Apache Group.	39	* permission of the Apache Group.
40	*	40	*
41	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED	41	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
42	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	42	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
43	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE	43	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
44	* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR	44	* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
45	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,	45	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
46	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT	46	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
47	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF	47	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
48	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND	48	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
49	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,	49	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT	50	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
51	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF	51	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52	* SUCH DAMAGE.	52	* SUCH DAMAGE.
53	* ====================================================================	53	* ====================================================================
54	*	54	*
55	* This software consists of voluntary contributions made by many	55	* This software consists of voluntary contributions made by many
56	* individuals on behalf of the Apache Software Foundation. For more	56	* individuals on behalf of the Apache Software Foundation. For more
57	* information on the Apache Software Foundation, please see	57	* information on the Apache Software Foundation, please see
58	* <http://www.apache.org/>.	58	* <http://www.apache.org/>.
59	*	59	*
60	* [Additional notices, if required by prior licensing conditions]	60	* [Additional notices, if required by prior licensing conditions]
61	*	61	*
62	*/	62	*/
63		63
64		64
65	package org.apache.catalina.connector.http;	65	package org.apache.catalina.connector.http;
66		66
67		67
68	import java.io.IOException;	68	import java.io.IOException;
69	import java.net.BindException;	69	import java.net.BindException;
70	import java.net.InetAddress;	70	import java.net.InetAddress;
71	import java.net.ServerSocket;	71	import java.net.ServerSocket;
72	import java.net.Socket;	72	import java.net.Socket;
		73	import java.net.UnknownHostException;
73	import java.security.AccessControlException;	74	import java.security.AccessControlException;
74	import java.util.Stack;	75	import java.util.Stack;
75	import java.util.Vector;	76	import java.util.Vector;
76	import java.util.Enumeration;	77	import java.util.Enumeration;
		78	import java.security.KeyStoreException;
		79	import java.security.NoSuchAlgorithmException;
		80	import java.security.cert.CertificateException;
		81	import java.security.UnrecoverableKeyException;
		82	import java.security.KeyManagementException;
77	import org.apache.catalina.Connector;	83	import org.apache.catalina.Connector;
78	import org.apache.catalina.Container;	84	import org.apache.catalina.Container;
79	import org.apache.catalina.HttpRequest;	85	import org.apache.catalina.HttpRequest;
80	import org.apache.catalina.HttpResponse;	86	import org.apache.catalina.HttpResponse;
81	import org.apache.catalina.Lifecycle;	87	import org.apache.catalina.Lifecycle;
82	import org.apache.catalina.LifecycleEvent;	88	import org.apache.catalina.LifecycleEvent;
83	import org.apache.catalina.LifecycleException;	89	import org.apache.catalina.LifecycleException;
84	import org.apache.catalina.LifecycleListener;	90	import org.apache.catalina.LifecycleListener;
85	import org.apache.catalina.Logger;	91	import org.apache.catalina.Logger;
86	import org.apache.catalina.Request;	92	import org.apache.catalina.Request;
87	import org.apache.catalina.Response;	93	import org.apache.catalina.Response;
88	import org.apache.catalina.Service;	94	import org.apache.catalina.Service;
89	import org.apache.catalina.net.DefaultServerSocketFactory;	95	import org.apache.catalina.net.DefaultServerSocketFactory;
90	import org.apache.catalina.net.ServerSocketFactory;	96	import org.apache.catalina.net.ServerSocketFactory;
91	import org.apache.catalina.util.LifecycleSupport;	97	import org.apache.catalina.util.LifecycleSupport;
92	import org.apache.catalina.util.StringManager;	98	import org.apache.catalina.util.StringManager;
93		99
94		100
95	/**	101	/**
96	* Implementation of an HTTP/1.1 connector.	102	* Implementation of an HTTP/1.1 connector.
97	*	103	*
98	* @author Craig R. McClanahan	104	* @author Craig R. McClanahan
99	* @author Remy Maucherat	105	* @author Remy Maucherat
100	* @version $Revision: 1.24.2.2 $ $Date: 2002/01/3 1 23:13:5 3 $	106	* @version $Revision: 1.34 $ $Date: 2002/0 3/18 07:1 5:39 $
		107	* @deprecated
101	*/	108	*/
102		109
103		110
104	public final class HttpConnector	111	public final class HttpConnector
105	implements Connector, Lifecycle, Runnable {	112	implements Connector, Lifecycle, Runnable {
106		113
107		114
108	// ----------------------------------------------------- Instance Variables	115	// ----------------------------------------------------- Instance Variables
109		116
110		117
111	/**	118	/**
112	* The <code>Service</code> we are associated with (if any).	119	* The <code>Service</code> we are associated with (if any).
113	*/	120	*/
114	private Service service = null;	121	private Service service = null;
115		122
116		123
117	/**	124	/**
118	* The accept count for this Connector.	125	* The accept count for this Connector.
119	*/	126	*/
120	private int acceptCount = 10;	127	private int acceptCount = 10;
121		128
122		129
123	/**	130	/**
124	* The IP address on which to bind, if any. If <code>null</code>, all	131	* The IP address on which to bind, if any. If <code>null</code>, all
125	* addresses on the server will be bound.	132	* addresses on the server will be bound.
126	*/	133	*/
127	private String address = null;	134	private String address = null;
128		135
129		136
130	/**	137	/**
131	* The input buffer size we should create on input streams.	138	* The input buffer size we should create on input streams.
132	*/	139	*/
133	private int bufferSize = 2048;	140	private int bufferSize = 2048;
134		141
135		142
136	/**	143	/**
137	* The Container used for processing requests received by this Connector.	144	* The Container used for processing requests received by this Connector.
138	*/	145	*/
139	protected Container container = null;	146	protected Container container = null;
140		147
141		148
142	/**	149	/**
143	* The set of processors that have ever been created.	150	* The set of processors that have ever been created.
144	*/	151	*/
145	private Vector created = new Vector();	152	private Vector created = new Vector();
146		153
147		154
148	/**	155	/**
149	* The current number of processors that have been created.	156	* The current number of processors that have been created.
150	*/	157	*/
151	private int curProcessors = 0;	158	private int curProcessors = 0;
152		159
153		160
154	/**	161	/**
155	* The debugging detail level for this component.	162	* The debugging detail level for this component.
156	*/	163	*/
157	private int debug = 0;	164	private int debug = 0;
158		165
159		166
160	/**	167	/**
161	* The "enable DNS lookups" flag for this Connector.	168	* The "enable DNS lookups" flag for this Connector.
162	*/	169	*/
163	private boolean enableLookups = false;	170	private boolean enableLookups = false;
164		171
165		172
166	/**	173	/**
167	* The server socket factory for this component.	174	* The server socket factory for this component.
168	*/	175	*/
169	private ServerSocketFactory factory = null;	176	private ServerSocketFactory factory = null;
170		177
171		178
172	/**	179	/**
173	* Descriptive information about this Connector implementation.	180	* Descriptive information about this Connector implementation.
174	*/	181	*/
175	private static final String info =	182	private static final String info =
176	"org.apache.catalina.connector.http.HttpConnector/1.0";	183	"org.apache.catalina.connector.http.HttpConnector/1.0";
177		184
178		185
179	/**	186	/**
180	* The lifecycle event support for this component.	187	* The lifecycle event support for this component.
181	*/	188	*/
182	protected LifecycleSupport lifecycle = new LifecycleSupport(this);	189	protected LifecycleSupport lifecycle = new LifecycleSupport(this);
183		190
184		191
185	/**	192	/**
186	* The minimum number of processors to start at initialization time.	193	* The minimum number of processors to start at initialization time.
187	*/	194	*/
188	protected int minProcessors = 5;	195	protected int minProcessors = 5;
189		196
190		197
191	/**	198	/**
192	* The maximum number of processors allowed, or <0 for unlimited.	199	* The maximum number of processors allowed, or <0 for unlimited.
193	*/	200	*/
194	private int maxProcessors = 20;	201	private int maxProcessors = 20;
195		202
196		203
197	/**	204	/**
198	* Timeout value on the incoming connection.	205	* Timeout value on the incoming connection.
199	* Note : a value of 0 means no timeout.	206	* Note : a value of 0 means no timeout.
200	*/	207	*/
201	private int connectionTimeout = Constants.DEFAULT_CONNECTION_TIMEOUT;	208	private int connectionTimeout = Constants.DEFAULT_CONNECTION_TIMEOUT;
202		209
203		210
204	/**	211	/**
205	* The port number on which we listen for HTTP requests.	212	* The port number on which we listen for HTTP requests.
206	*/	213	*/
207	private int port = 8080;	214	private int port = 8080;
208		215
209		216
210	/**	217	/**
211	* The set of processors that have been created but are not currently	218	* The set of processors that have been created but are not currently
212	* being used to process a request.	219	* being used to process a request.
213	*/	220	*/
214	private Stack processors = new Stack();	221	private Stack processors = new Stack();
215		222
216		223
217	/**	224	/**
218	* The server name to which we should pretend requests to this Connector	225	* The server name to which we should pretend requests to this Connector
219	* were directed. This is useful when operating Tomcat behind a proxy	226	* were directed. This is useful when operating Tomcat behind a proxy
220	* server, so that redirects get constructed accurately. If not specified,	227	* server, so that redirects get constructed accurately. If not specified,
221	* the server name included in the <code>Host</code> header is used.	228	* the server name included in the <code>Host</code> header is used.
222	*/	229	*/
223	private String proxyName = null;	230	private String proxyName = null;
224		231
225		232
226	/**	233	/**
227	* The server port to which we should pretent requests to this Connector	234	* The server port to which we should pretent requests to this Connector
228	* were directed. This is useful when operating Tomcat behind a proxy	235	* were directed. This is useful when operating Tomcat behind a proxy
229	* server, so that redirects get constructed accurately. If not specified,	236	* server, so that redirects get constructed accurately. If not specified,
230	* the port number specified by the <code>port</code> property is used.	237	* the port number specified by the <code>port</code> property is used.
231	*/	238	*/
232	private int proxyPort = 0;	239	private int proxyPort = 0;
233		240
234		241
235	/**	242	/**
236	* The redirect port for non-SSL to SSL redirects.	243	* The redirect port for non-SSL to SSL redirects.
237	*/	244	*/
238	private int redirectPort = 443;	245	private int redirectPort = 443;
239		246
240		247
241	/**	248	/**
242	* The request scheme that will be set on all requests received	249	* The request scheme that will be set on all requests received
243	* through this connector.	250	* through this connector.
244	*/	251	*/
245	private String scheme = "http";	252	private String scheme = "http";
246		253
247		254
248	/**	255	/**
249	* The secure connection flag that will be set on all requests received	256	* The secure connection flag that will be set on all requests received
250	* through this connector.	257	* through this connector.
251	*/	258	*/
252	private boolean secure = false;	259	private boolean secure = false;
253		260
254		261
255	/**	262	/**
256	* The server socket through which we listen for incoming TCP connections.	263	* The server socket through which we listen for incoming TCP connections.
257	*/	264	*/
258	private ServerSocket serverSocket = null;	265	private ServerSocket serverSocket = null;
259		266
260		267
261	/**	268	/**
262	* The string manager for this package.	269	* The string manager for this package.
263	*/	270	*/
264	private StringManager sm =	271	private StringManager sm =
265	StringManager.getManager(Constants.Package);	272	StringManager.getManager(Constants.Package);
266		273
267		274
268	/**	275	/**
269	* Has this component been initialized yet?	276	* Has this component been initialized yet?
270	*/	277	*/
271	private boolean initialized = false;	278	private boolean initialized = false;
272		279
273		280
274	/**	281	/**
275	* Has this component been started yet?	282	* Has this component been started yet?
276	*/	283	*/
277	private boolean started = false;	284	private boolean started = false;
278		285
279		286
280	/**	287	/**
281	* The shutdown signal to our background thread	288	* The shutdown signal to our background thread
282	*/	289	*/
283	private boolean stopped = false;	290	private boolean stopped = false;
284		291
285		292
286	/**	293	/**
287	* The background thread.	294	* The background thread.
288	*/	295	*/
289	private Thread thread = null;	296	private Thread thread = null;
290		297
291		298
292	/**	299	/**
293	* The name to register for the background thread.	300	* The name to register for the background thread.
294	*/	301	*/
295	private String threadName = null;	302	private String threadName = null;
296		303
297		304
298	/**	305	/**
299	* The thread synchronization object.	306	* The thread synchronization object.
300	*/	307	*/
301	private Object threadSync = new Object();	308	private Object threadSync = new Object();
302		309
303		310
304	/**	311	/**
305	* Is chunking allowed ?	312	* Is chunking allowed ?
306	*/	313	*/
307	private boolean allowChunking = true;	314	private boolean allowChunking = true;
308		315
309		316
310	/**	317	/**
311	* Use TCP no delay ?	318	* Use TCP no delay ?
312	*/	319	*/
313	private boolean tcpNoDelay = true;	320	private boolean tcpNoDelay = true;
314		321
315		322
316	// ------------------------------------------------------------- Properties	323	// ------------------------------------------------------------- Properties
317		324
318		325
319	/**	326	/**
320	* Return the <code>Service</code> with which we are associated (if any).	327	* Return the <code>Service</code> with which we are associated (if any).
321	*/	328	*/
322	public Service getService() {	329	public Service getService() {
323		330
324	return (this.service);	331	return (this.service);
325		332
326	}	333	}
327		334
328		335
329	/**	336	/**
330	* Set the <code>Service</code> with which we are associated (if any).	337	* Set the <code>Service</code> with which we are associated (if any).
331	*	338	*
332	* @param service The service that owns this Engine	339	* @param service The service that owns this Engine
333	*/	340	*/
334	public void setService(Service service) {	341	public void setService(Service service) {
335		342
336	this.service = service;	343	this.service = service;
337		344
338	}	345	}
339		346
340		347
341	/**	348	/**
342	* Return the connection timeout for this Connector.	349	* Return the connection timeout for this Connector.
343	*/	350	*/
344	public int getConnectionTimeout() {	351	public int getConnectionTimeout() {
345		352
346	return (connectionTimeout);	353	return (connectionTimeout);
347		354
348	}	355	}
349		356
350		357
351	/**	358	/**
352	* Set the connection timeout for this Connector.	359	* Set the connection timeout for this Connector.
353	*	360	*
354	* @param count The new connection timeout	361	* @param count The new connection timeout
355	*/	362	*/
356	public void setConnectionTimeout(int connectionTimeout) {	363	public void setConnectionTimeout(int connectionTimeout) {
357		364
358	this.connectionTimeout = connectionTimeout;	365	this.connectionTimeout = connectionTimeout;
359		366
360	}	367	}
361		368
362		369
363	/**	370	/**
364	* Return the accept count for this Connector.	371	* Return the accept count for this Connector.
365	*/	372	*/
366	public int getAcceptCount() {	373	public int getAcceptCount() {
367		374
368	return (acceptCount);	375	return (acceptCount);
369		376
370	}	377	}
371		378
372		379
373	/**	380	/**
374	* Set the accept count for this Connector.	381	* Set the accept count for this Connector.
375	*	382	*
376	* @param count The new accept count	383	* @param count The new accept count
377	*/	384	*/
378	public void setAcceptCount(int count) {	385	public void setAcceptCount(int count) {
379		386
380	this.acceptCount = count;	387	this.acceptCount = count;
381		388
382	}	389	}
383		390
384		391
385	/**	392	/**
386	* Get the allow chunking flag.	393	* Get the allow chunking flag.
387	*/	394	*/
388	public boolean isChunkingAllowed() {	395	public boolean isChunkingAllowed() {
389		396
390	return (allowChunking);	397	return (allowChunking);
391		398
392	}	399	}
393		400
394		401
395	/**	402	/**
		403	* Get the allow chunking flag.
		404	*/
		405	public boolean getAllowChunking() {
		406
		407	return isChunkingAllowed();
		408
		409	}
		410
		411
		412	/**
396	* Set the allow chunking flag.	413	* Set the allow chunking flag.
397	*	414	*
398	* @param allowChunking Allow chunking flag	415	* @param allowChunking Allow chunking flag
399	*/	416	*/
400	public void setAllowChunking(boolean allowChunking) {	417	public void setAllowChunking(boolean allowChunking) {
401		418
402	this.allowChunking = allowChunking;	419	this.allowChunking = allowChunking;
403		420
404	}	421	}
405		422
406		423
407	/**	424	/**
408	* Return the bind IP address for this Connector.	425	* Return the bind IP address for this Connector.
409	*/	426	*/
410	public String getAddress() {	427	public String getAddress() {
411		428
412	return (this.address);	429	return (this.address);
413		430
414	}	431	}
415		432
416		433
417	/**	434	/**
418	* Set the bind IP address for this Connector.	435	* Set the bind IP address for this Connector.
419	*	436	*
420	* @param address The bind IP address	437	* @param address The bind IP address
421	*/	438	*/
422	public void setAddress(String address) {	439	public void setAddress(String address) {
423		440
424	this.address = address;	441	this.address = address;
425		442
426	}	443	}
427		444
428		445
429	/**	446	/**
430	* Is this connector available for processing requests?	447	* Is this connector available for processing requests?
431	*/	448	*/
432	public boolean isAvailable() {	449	public boolean isAvailable() {
433		450
434	return (started);	451	return (started);
435		452
436	}	453	}
437		454
438		455
439	/**	456	/**
440	* Return the input buffer size for this Connector.	457	* Return the input buffer size for this Connector.
441	*/	458	*/
442	public int getBufferSize() {	459	public int getBufferSize() {
443		460
444	return (this.bufferSize);	461	return (this.bufferSize);
445		462
446	}	463	}
447		464
448		465
449	/**	466	/**
450	* Set the input buffer size for this Connector.	467	* Set the input buffer size for this Connector.
451	*	468	*
452	* @param bufferSize The new input buffer size.	469	* @param bufferSize The new input buffer size.
453	*/	470	*/
454	public void setBufferSize(int bufferSize) {	471	public void setBufferSize(int bufferSize) {
455		472
456	this.bufferSize = bufferSize;	473	this.bufferSize = bufferSize;
457		474
458	}	475	}
459		476
460		477
461	/**	478	/**
462	* Return the Container used for processing requests received by this	479	* Return the Container used for processing requests received by this
463	* Connector.	480	* Connector.
464	*/	481	*/
465	public Container getContainer() {	482	public Container getContainer() {
466		483
467	return (container);	484	return (container);
468		485
469	}	486	}
470		487
471		488
472	/**	489	/**
473	* Set the Container used for processing requests received by this	490	* Set the Container used for processing requests received by this
474	* Connector.	491	* Connector.
475	*	492	*
476	* @param container The new Container to use	493	* @param container The new Container to use
477	*/	494	*/
478	public void setContainer(Container container) {	495	public void setContainer(Container container) {
479		496
480	this.container = container;	497	this.container = container;
481		498
482	}	499	}
483		500
484		501
485	/**	502	/**
486	* Return the current number of processors that have been created.	503	* Return the current number of processors that have been created.
487	*/	504	*/
488	public int getCurProcessors() {	505	public int getCurProcessors() {
489		506
490	return (curProcessors);	507	return (curProcessors);
491		508
492	}	509	}
493		510
494		511
495	/**	512	/**
496	* Return the debugging detail level for this component.	513	* Return the debugging detail level for this component.
497	*/	514	*/
498	public int getDebug() {	515	public int getDebug() {
499		516
500	return (debug);	517	return (debug);
501		518
502	}	519	}
503		520
504		521
505	/**	522	/**
506	* Set the debugging detail level for this component.	523	* Set the debugging detail level for this component.
507	*	524	*
508	* @param debug The new debugging detail level	525	* @param debug The new debugging detail level
509	*/	526	*/
510	public void setDebug(int debug) {	527	public void setDebug(int debug) {
511		528
512	this.debug = debug;	529	this.debug = debug;
513		530
514	}	531	}
515		532
516		533
517	/**	534	/**
518	* Return the "enable DNS lookups" flag.	535	* Return the "enable DNS lookups" flag.
519	*/	536	*/
520	public boolean getEnableLookups() {	537	public boolean getEnableLookups() {
521		538
522	return (this.enableLookups);	539	return (this.enableLookups);
523		540
524	}	541	}
525		542
526		543
527	/**	544	/**
528	* Set the "enable DNS lookups" flag.	545	* Set the "enable DNS lookups" flag.
529	*	546	*
530	* @param enableLookups The new "enable DNS lookups" flag value	547	* @param enableLookups The new "enable DNS lookups" flag value
531	*/	548	*/
532	public void setEnableLookups(boolean enableLookups) {	549	public void setEnableLookups(boolean enableLookups) {
533		550
534	this.enableLookups = enableLookups;	551	this.enableLookups = enableLookups;
535		552
536	}	553	}
537		554
538		555
539	/**	556	/**
540	* Return the server socket factory used by this Container.	557	* Return the server socket factory used by this Container.
541	*/	558	*/
542	public ServerSocketFactory getFactory() {	559	public ServerSocketFactory getFactory() {
543		560
544	if (this.factory == null) {	561	if (this.factory == null) {
545	synchronized (this) {	562	synchronized (this) {
546	this.factory = new DefaultServerSocketFactory();	563	this.factory = new DefaultServerSocketFactory();
547	}	564	}
548	}	565	}
549	return (this.factory);	566	return (this.factory);
550		567
551	}	568	}
552		569
553		570
554	/**	571	/**
555	* Set the server socket factory used by this Container.	572	* Set the server socket factory used by this Container.
556	*	573	*
557	* @param factory The new server socket factory	574	* @param factory The new server socket factory
558	*/	575	*/
559	public void setFactory(ServerSocketFactory factory) {	576	public void setFactory(ServerSocketFactory factory) {
560		577
561	this.factory = factory;	578	this.factory = factory;
562		579
563	}	580	}
564		581
565		582
566	/**	583	/**
567	* Return descriptive information about this Connector implementation.	584	* Return descriptive information about this Connector implementation.
568	*/	585	*/
569	public String getInfo() {	586	public String getInfo() {
570		587
571	return (info);	588	return (info);
572		589
573	}	590	}
574		591
575		592
576	/**	593	/**
577	* Return the minimum number of processors to start at initialization.	594	* Return the minimum number of processors to start at initialization.
578	*/	595	*/
579	public int getMinProcessors() {	596	public int getMinProcessors() {
580		597
581	return (minProcessors);	598	return (minProcessors);
582		599
583	}	600	}
584		601
585		602
586	/**	603	/**
587	* Set the minimum number of processors to start at initialization.	604	* Set the minimum number of processors to start at initialization.
588	*	605	*
589	* @param minProcessors The new minimum processors	606	* @param minProcessors The new minimum processors
590	*/	607	*/
591	public void setMinProcessors(int minProcessors) {	608	public void setMinProcessors(int minProcessors) {
592		609
593	this.minProcessors = minProcessors;	610	this.minProcessors = minProcessors;
594		611
595	}	612	}
596		613
597		614
598	/**	615	/**
599	* Return the maximum number of processors allowed, or <0 for unlimited.	616	* Return the maximum number of processors allowed, or <0 for unlimited.
600	*/	617	*/
601	public int getMaxProcessors() {	618	public int getMaxProcessors() {
602		619
603	return (maxProcessors);	620	return (maxProcessors);
604		621
605	}	622	}
606		623
607		624
608	/**	625	/**
609	* Set the maximum number of processors allowed, or <0 for unlimited.	626	* Set the maximum number of processors allowed, or <0 for unlimited.
610	*	627	*
611	* @param maxProcessors The new maximum processors	628	* @param maxProcessors The new maximum processors
612	*/	629	*/
613	public void setMaxProcessors(int maxProcessors) {	630	public void setMaxProcessors(int maxProcessors) {
614		631
615	this.maxProcessors = maxProcessors;	632	this.maxProcessors = maxProcessors;
616		633
617	}	634	}
618		635
619		636
620	/**	637	/**
621	* Return the port number on which we listen for HTTP requests.	638	* Return the port number on which we listen for HTTP requests.
622	*/	639	*/
623	public int getPort() {	640	public int getPort() {
624		641
625	return (this.port);	642	return (this.port);
626		643
627	}	644	}
628		645
629		646
630	/**	647	/**
631	* Set the port number on which we listen for HTTP requests.	648	* Set the port number on which we listen for HTTP requests.
632	*	649	*
633	* @param port The new port number	650	* @param port The new port number
634	*/	651	*/
635	public void setPort(int port) {	652	public void setPort(int port) {
636		653
637	this.port = port;	654	this.port = port;
638		655
639	}	656	}
640		657
641		658
642	/**	659	/**
643	* Return the proxy server name for this Connector.	660	* Return the proxy server name for this Connector.
644	*/	661	*/
645	public String getProxyName() {	662	public String getProxyName() {
646		663
647	return (this.proxyName);	664	return (this.proxyName);
648		665
649	}	666	}
650		667
651		668
652	/**	669	/**
653	* Set the proxy server name for this Connector.	670	* Set the proxy server name for this Connector.
654	*	671	*
655	* @param proxyName The new proxy server name	672	* @param proxyName The new proxy server name
656	*/	673	*/
657	public void setProxyName(String proxyName) {	674	public void setProxyName(String proxyName) {
658		675
659	this.proxyName = proxyName;	676	this.proxyName = proxyName;
660		677
661	}	678	}
662		679
663		680
664	/**	681	/**
665	* Return the proxy server port for this Connector.	682	* Return the proxy server port for this Connector.
666	*/	683	*/
667	public int getProxyPort() {	684	public int getProxyPort() {
668		685
669	return (this.proxyPort);	686	return (this.proxyPort);
670		687
671	}	688	}
672		689
673		690
674	/**	691	/**
675	* Set the proxy server port for this Connector.	692	* Set the proxy server port for this Connector.
676	*	693	*
677	* @param proxyPort The new proxy server port	694	* @param proxyPort The new proxy server port
678	*/	695	*/
679	public void setProxyPort(int proxyPort) {	696	public void setProxyPort(int proxyPort) {
680		697
681	this.proxyPort = proxyPort;	698	this.proxyPort = proxyPort;
682		699
683	}	700	}
684		701
685		702
686	/**	703	/**
687	* Return the port number to which a request should be redirected if	704	* Return the port number to which a request should be redirected if
688	* it comes in on a non-SSL port and is subject to a security constraint	705	* it comes in on a non-SSL port and is subject to a security constraint
689	* with a transport guarantee that requires SSL.	706	* with a transport guarantee that requires SSL.
690	*/	707	*/
691	public int getRedirectPort() {	708	public int getRedirectPort() {
692		709
693	return (this.redirectPort);	710	return (this.redirectPort);
694		711
695	}	712	}
696		713
697		714
698	/**	715	/**
699	* Set the redirect port number.	716	* Set the redirect port number.
700	*	717	*
701	* @param redirectPort The redirect port number (non-SSL to SSL)	718	* @param redirectPort The redirect port number (non-SSL to SSL)
702	*/	719	*/
703	public void setRedirectPort(int redirectPort) {	720	public void setRedirectPort(int redirectPort) {
704		721
705	this.redirectPort = redirectPort;	722	this.redirectPort = redirectPort;
706		723
707	}	724	}
708		725
709		726
710	/**	727	/**
711	* Return the scheme that will be assigned to requests received	728	* Return the scheme that will be assigned to requests received
712	* through this connector. Default value is "http".	729	* through this connector. Default value is "http".
713	*/	730	*/
714	public String getScheme() {	731	public String getScheme() {
715		732
716	return (this.scheme);	733	return (this.scheme);
717		734
718	}	735	}
719		736
720		737
721	/**	738	/**
722	* Set the scheme that will be assigned to requests received through	739	* Set the scheme that will be assigned to requests received through
723	* this connector.	740	* this connector.
724	*	741	*
725	* @param scheme The new scheme	742	* @param scheme The new scheme
726	*/	743	*/
727	public void setScheme(String scheme) {	744	public void setScheme(String scheme) {
728		745
729	this.scheme = scheme;	746	this.scheme = scheme;
730		747
731	}	748	}
732		749
733		750
734	/**	751	/**
735	* Return the secure connection flag that will be assigned to requests	752	* Return the secure connection flag that will be assigned to requests
736	* received through this connector. Default value is "false".	753	* received through this connector. Default value is "false".
737	*/	754	*/
738	public boolean getSecure() {	755	public boolean getSecure() {
739		756
740	return (this.secure);	757	return (this.secure);
741		758
742	}	759	}
743		760
744		761
745	/**	762	/**
746	* Set the secure connection flag that will be assigned to requests	763	* Set the secure connection flag that will be assigned to requests
747	* received through this connector.	764	* received through this connector.
748	*	765	*
749	* @param secure The new secure connection flag	766	* @param secure The new secure connection flag
750	*/	767	*/
751	public void setSecure(boolean secure) {	768	public void setSecure(boolean secure) {
752		769
753	this.secure = secure;	770	this.secure = secure;
754		771
755	}	772	}
756		773
757		774
758	/**	775	/**
759	* Return the TCP no delay flag value.	776	* Return the TCP no delay flag value.
760	*/	777	*/
761	public boolean getTcpNoDelay() {	778	public boolean getTcpNoDelay() {
762		779
763	return (this.tcpNoDelay);	780	return (this.tcpNoDelay);
764		781
765	}	782	}
766		783
767		784
768	/**	785	/**
769	* Set the TCP no delay flag which will be set on the socket after	786	* Set the TCP no delay flag which will be set on the socket after
770	* accepting a connection.	787	* accepting a connection.
771	*	788	*
772	* @param tcpNoDelay The new TCP no delay flag	789	* @param tcpNoDelay The new TCP no delay flag
773	*/	790	*/
774	public void setTcpNoDelay(boolean tcpNoDelay) {	791	public void setTcpNoDelay(boolean tcpNoDelay) {
775		792
776	this.tcpNoDelay = tcpNoDelay;	793	this.tcpNoDelay = tcpNoDelay;
777		794
778	}	795	}
779		796
780		797
781	// --------------------------------------------------------- Public Methods	798	// --------------------------------------------------------- Public Methods
782		799
783		800
784	/**	801	/**
785	* Create (or allocate) and return a Request object suitable for	802	* Create (or allocate) and return a Request object suitable for
786	* specifying the contents of a Request to the responsible Container.	803	* specifying the contents of a Request to the responsible Container.
787	*/	804	*/
788	public Request createRequest() {	805	public Request createRequest() {
789		806
790	// if (debug >= 2)	807	// if (debug >= 2)
791	// log("createRequest: Creating new request");	808	// log("createRequest: Creating new request");
792	HttpRequestImpl request = new HttpRequestImpl();	809	HttpRequestImpl request = new HttpRequestImpl();
793	request.setConnector(this);	810	request.setConnector(this);
794	return (request);	811	return (request);
795		812
796	}	813	}
797		814
798		815
799	/**	816	/**
800	* Create (or allocate) and return a Response object suitable for	817	* Create (or allocate) and return a Response object suitable for
801	* receiving the contents of a Response from the responsible Container.	818	* receiving the contents of a Response from the responsible Container.
802	*/	819	*/
803	public Response createResponse() {	820	public Response createResponse() {
804		821
805	// if (debug >= 2)	822	// if (debug >= 2)
806	// log("createResponse: Creating new response");	823	// log("createResponse: Creating new response");
807	HttpResponseImpl response = new HttpResponseImpl();	824	HttpResponseImpl response = new HttpResponseImpl();
808	response.setConnector(this);	825	response.setConnector(this);
809	return (response);	826	return (response);
810		827
811	}	828	}
812		829
813		830
814	// -------------------------------------------------------- Package Methods	831	// -------------------------------------------------------- Package Methods
815		832
816		833
817	/**	834	/**
818	* Recycle the specified Processor so that it can be used again.	835	* Recycle the specified Processor so that it can be used again.
819	*	836	*
820	* @param processor The processor to be recycled	837	* @param processor The processor to be recycled
821	*/	838	*/
822	void recycle(HttpProcessor processor) {	839	void recycle(HttpProcessor processor) {
823		840
824	// if (debug >= 2)	841	// if (debug >= 2)
825	// log("recycle: Recycling processor " + processor);	842	// log("recycle: Recycling processor " + processor);
826	processors.push(processor);	843	processors.push(processor);
827		844
828	}	845	}
829		846
830		847
831	// -------------------------------------------------------- Private Methods	848	// -------------------------------------------------------- Private Methods
832		849
833		850
834	/**	851	/**
835	* Create (or allocate) and return an available processor for use in	852	* Create (or allocate) and return an available processor for use in
836	* processing a specific HTTP request, if possible. If the maximum	853	* processing a specific HTTP request, if possible. If the maximum
837	* allowed processors have already been created and are in use, return	854	* allowed processors have already been created and are in use, return
838	* <code>null</code> instead.	855	* <code>null</code> instead.
839	*/	856	*/
840	private HttpProcessor createProcessor() {	857	private HttpProcessor createProcessor() {
841		858
842	synchronized (processors) {	859	synchronized (processors) {
843	if (processors.size() > 0) {	860	if (processors.size() > 0) {
844	// if (debug >= 2)	861	// if (debug >= 2)
845	// log("createProcessor: Reusing existing processor");	862	// log("createProcessor: Reusing existing processor");
846	return ((HttpProcessor) processors.pop());	863	return ((HttpProcessor) processors.pop());
847	}	864	}
848	if ((maxProcessors > 0) && (curProcessors < maxProcessors)) {	865	if ((maxProcessors > 0) && (curProcessors < maxProcessors)) {
849	// if (debug >= 2)	866	// if (debug >= 2)
850	// log("createProcessor: Creating new processor");	867	// log("createProcessor: Creating new processor");
851	return (newProcessor());	868	return (newProcessor());
852	} else {	869	} else {
853	if (maxProcessors < 0) {	870	if (maxProcessors < 0) {
854	// if (debug >= 2)	871	// if (debug >= 2)
855	// log("createProcessor: Creating new processor");	872	// log("createProcessor: Creating new processor");
856	return (newProcessor());	873	return (newProcessor());
857	} else {	874	} else {
858	// if (debug >= 2)	875	// if (debug >= 2)
859	// log("createProcessor: Cannot create new processor");	876	// log("createProcessor: Cannot create new processor");
860	return (null);	877	return (null);
861	}	878	}
862	}	879	}
863	}	880	}
864		881
865	}	882	}
866		883
867		884
868	/**	885	/**
869	* Log a message on the Logger associated with our Container (if any).	886	* Log a message on the Logger associated with our Container (if any).
870	*	887	*
871	* @param message Message to be logged	888	* @param message Message to be logged
872	*/	889	*/
873	private void log(String message) {	890	private void log(String message) {
874		891
875	Logger logger = container.getLogger();	892	Logger logger = container.getLogger();
876	String localName = threadName;	893	String localName = threadName;
877	if (localName == null)	894	if (localName == null)
878	localName = "HttpConnector";	895	localName = "HttpConnector";
879	if (logger != null)	896	if (logger != null)
880	logger.log(localName + " " + message);	897	logger.log(localName + " " + message);
881	else	898	else
882	System.out.println(localName + " " + message);	899	System.out.println(localName + " " + message);
883		900
884	}	901	}
885		902
886		903
887	/**	904	/**
888	* Log a message on the Logger associated with our Container (if any).	905	* Log a message on the Logger associated with our Container (if any).
889	*	906	*
890	* @param message Message to be logged	907	* @param message Message to be logged
891	* @param throwable Associated exception	908	* @param throwable Associated exception
892	*/	909	*/
893	private void log(String message, Throwable throwable) {	910	private void log(String message, Throwable throwable) {
894		911
895	Logger logger = container.getLogger();	912	Logger logger = container.getLogger();
896	String localName = threadName;	913	String localName = threadName;
897	if (localName == null)	914	if (localName == null)
898	localName = "HttpConnector";	915	localName = "HttpConnector";
899	if (logger != null)	916	if (logger != null)
900	logger.log(localName + " " + message, throwable);	917	logger.log(localName + " " + message, throwable);
901	else {	918	else {
902	System.out.println(localName + " " + message);	919	System.out.println(localName + " " + message);
903	throwable.printStackTrace(System.out);	920	throwable.printStackTrace(System.out);
904	}	921	}
905		922
906	}	923	}
907		924
908		925
909	/**	926	/**
910	* Create and return a new processor suitable for processing HTTP	927	* Create and return a new processor suitable for processing HTTP
911	* requests and returning the corresponding responses.	928	* requests and returning the corresponding responses.
912	*/	929	*/
913	private HttpProcessor newProcessor() {	930	private HttpProcessor newProcessor() {
914		931
915	// if (debug >= 2)	932	// if (debug >= 2)
916	// log("newProcessor: Creating new processor");	933	// log("newProcessor: Creating new processor");
917	HttpProcessor processor = new HttpProcessor(this, curProcessors++);	934	HttpProcessor processor = new HttpProcessor(this, curProcessors++);
918	if (processor instanceof Lifecycle) {	935	if (processor instanceof Lifecycle) {
919	try {	936	try {
920	((Lifecycle) processor).start();	937	((Lifecycle) processor).start();
921	} catch (LifecycleException e) {	938	} catch (LifecycleException e) {
922	log("newProcessor", e);	939	log("newProcessor", e);
923	return (null);	940	return (null);
924	}	941	}
925	}	942	}
926	created.addElement(processor);	943	created.addElement(processor);
927	return (processor);	944	return (processor);
928		945
929	}	946	}
930		947
931		948
932	/**	949	/**
933	* Open and return the server socket for this Connector. If an IP	950	* Open and return the server socket for this Connector. If an IP
934	* address has been specified, the socket will be opened only on that	951	* address has been specified, the socket will be opened only on that
935	* address; otherwise it will be opened on all addresses.	952	* address; otherwise it will be opened on all addresses.
936	*	953	*
937	* @exception IOException if an input/output err or occurs	954	* @exception IOException input/output or network erro r
		955	* @exception KeyStoreException error instantiating the
		956	* KeyStore from file (SSL only)
		957	* @exception NoSuchAlgorithmException KeyStore algorithm unsupported
		958	* by current provider (SSL only)
		959	* @exception CertificateException general certificate error (SSL only)
		960	* @exception UnrecoverableKeyException internal KeyStore problem with
		961	* the certificate (SSL only)
		962	* @exception KeyManagementException problem in the key management
		963	* layer (SSL only)
938	*/	964	*/
939	private ServerSocket open() throws IOException {	965	private ServerSocket open()
		966	throws IOException, KeyStoreException, NoSuchAlgorithmException,
		967	CertificateException, UnrecoverableKeyException,
		968	KeyManagementException
		969	{
940		970
941	// Acquire the server socket factory for this Connector	971	// Acquire the server socket factory for this Connector
942	ServerSocketFactory factory = getFactory();	972	ServerSocketFactory factory = getFactory();
943		973
944	// If no address is specified, open a connection on all addresses	974	// If no address is specified, open a connection on all addresses
945	if (address == null) {	975	if (address == null) {
946	log(sm.getString("httpConnector.allAddresses"));	976	log(sm.getString("httpConnector.allAddresses"));
947	try {	977	try {
948	return (factory.createSocket(port, acceptCount));	978	return (factory.createSocket(port, acceptCount));
949	} catch (BindException be) {	979	} catch (BindException be) {
950	throw new BindException(be.getMessage() + ":" + port);	980	throw new BindException(be.getMessage() + ":" + port);
951	}	981	}
952	}	982	}
953		983
954	// Open a server socket on the specified address	984	// Open a server socket on the specified address
955	try {	985	try {
956	InetAddress is = InetAddress.getByName(address);	986	InetAddress is = InetAddress.getByName(address);
957	log(sm.getString("httpConnector.anAddress", address));	987	log(sm.getString("httpConnector.anAddress", address));
958	try {	988	try {
959	return (factory.createSocket(port, acceptCount, is));	989	return (factory.createSocket(port, acceptCount, is));
960	} catch (BindException be) {	990	} catch (BindException be) {
961	throw new BindException(be.getMessage() + ":" + address	991	throw new BindException(be.getMessage() + ":" + address +
962	+ ":" + port);	992	":" + port);
963	}	993	}
964	} catch (Exception e) {	994	} catch (Exception e) {
965	log(sm.getString("httpConnector.noAddress", address));	995	log(sm.getString("httpConnector.noAddress", address));
966	try {	996	try {
967	return (factory.createSocket(port, acceptCount));	997	return (factory.createSocket(port, acceptCount));
968	} catch (BindException be) {	998	} catch (BindException be) {
969	throw new BindException(be.getMessage() + ":" + port);	999	throw new BindException(be.getMessage() + ":" + port);
970	}	1000	}
971	}	1001	}
972		1002
973	}	1003	}
974		1004
975		1005
976	// ---------------------------------------------- Background Thread Methods	1006	// ---------------------------------------------- Background Thread Methods
977		1007
978		1008
979	/**	1009	/**
980	* The background thread that listens for incoming TCP/IP connections and	1010	* The background thread that listens for incoming TCP/IP connections and
981	* hands them off to an appropriate processor.	1011	* hands them off to an appropriate processor.
982	*/	1012	*/
983	public void run() {	1013	public void run() {
984		1014
985	// Loop until we receive a shutdown command	1015	// Loop until we receive a shutdown command
986	while (!stopped) {	1016	while (!stopped) {
987		1017
988	// Accept the next incoming connection from the server socket	1018	// Accept the next incoming connection from the server socket
989	Socket socket = null;	1019	Socket socket = null;
990	try {	1020	try {
991	// if (debug >= 3)	1021	// if (debug >= 3)
992	// log("run: Waiting on serverSocket.accept()");	1022	// log("run: Waiting on serverSocket.accept()");
993	socket = serverSocket.accept();	1023	socket = serverSocket.accept();
994	// if (debug >= 3)	1024	// if (debug >= 3)
995	// log("run: Returned from serverSocket.accept()");	1025	// log("run: Returned from serverSocket.accept()");
996	if (connectionTimeout > 0)	1026	if (connectionTimeout > 0)
997	socket.setSoTimeout(connectionTimeout);	1027	socket.setSoTimeout(connectionTimeout);
998	socket.setTcpNoDelay(tcpNoDelay);	1028	socket.setTcpNoDelay(tcpNoDelay);
999	} catch (AccessControlException ace) {	1029	} catch (AccessControlException ace) {
1000	log("socket accept security exception", ace);	1030	log("socket accept security exception", ace);
1001	continue;	1031	continue;
1002	} catch (IOException e) {	1032	} catch (IOException e) {
1003	// if (debug >= 3)	1033	// if (debug >= 3)
1004	// log("run: Accept returned IOException", e);	1034	// log("run: Accept returned IOException", e);
1005	try {	1035	try {
		1036	// If reopening fails, exit
1006	synchronized (threadSync) {	1037	synchronized (threadSync) {
1007	if (started && !stopped)	1038	if (started && !stopped)
1008	log("accept : ", e);	1039	log("accept error: ", e);
1009	if (!stopped) {	1040	if (!stopped) {
1010	// if (debug >= 3)	1041	// if (debug >= 3)
1011	// log("run: Closing server socket");	1042	// log("run: Closing server socket");
1012	serverSocket.close();	1043	serverSocket.close();
1013	// if (debug >= 3)	1044	// if (debug >= 3)
1014	// log("run: Reopening server socket");	1045	// log("run: Reopening server socket");
1015	serverSocket = open();	1046	serverSocket = open();
1016	}	1047	}
1017	}	1048	}
1018	// if (debug >= 3)	1049	// if (debug >= 3)
1019	// log("run: IOException processing completed");	1050	// log("run: IOException processing completed");
1020	} catch (IOException ex) {	1051	} catch (IOException ioe ) {
1021	// If reopening fai ls, exit	1052	log("socket reopen, io problem: ", ioe);
1022	log("socket reopen : ", ex);	1053	break;
		1054	} catch (KeyStoreException kse) {
		1055	log("socket reopen, keystore problem: ", kse);
		1056	break;
		1057	} catch (NoSuchAlgorithmException nsae) {
		1058	log("socket reopen, keystore algorithm problem: ", nsae);
		1059	break;
		1060	} catch (CertificateException ce) {
		1061	log("socket reopen, certificate problem: ", ce);
		1062	break;
		1063	} catch (UnrecoverableKeyException uke) {
		1064	log("socket reopen, unrecoverable key: ", uke);
		1065	break;
		1066	} catch (KeyManagementException kme) {
		1067	log("socket reopen, key management problem: ", kme );
1023	break;	1068	break;
1024	}	1069	}
		1070
1025	continue;	1071	continue;
1026	}	1072	}
1027		1073
1028	// Hand this socket off to an appropriate processor	1074	// Hand this socket off to an appropriate processor
1029	HttpProcessor processor = createProcessor();	1075	HttpProcessor processor = createProcessor();
1030	if (processor == null) {	1076	if (processor == null) {
1031	try {	1077	try {
1032	log(sm.getString("httpConnector.noProcessor"));	1078	log(sm.getString("httpConnector.noProcessor"));
1033	socket.close();	1079	socket.close();
1034	} catch (IOException e) {	1080	} catch (IOException e) {
1035	;	1081	;
1036	}	1082	}
1037	continue;	1083	continue;
1038	}	1084	}
1039	// if (debug >= 3)	1085	// if (debug >= 3)
1040	// log("run: Assigning socket to processor " + processor);	1086	// log("run: Assigning socket to processor " + processor);
1041	processor.assign(socket);	1087	processor.assign(socket);
1042		1088
1043	// The processor will recycle itself when it finishes	1089	// The processor will recycle itself when it finishes
1044		1090
1045	}	1091	}
1046		1092
1047	// Notify the threadStop() method that we have shut ourselves down	1093	// Notify the threadStop() method that we have shut ourselves down
1048	// if (debug >= 3)	1094	// if (debug >= 3)
1049	// log("run: Notifying threadStop() that we have shut down");	1095	// log("run: Notifying threadStop() that we have shut down");
1050	synchronized (threadSync) {	1096	synchronized (threadSync) {
1051	threadSync.notifyAll();	1097	threadSync.notifyAll();
1052	}	1098	}
1053		1099
1054	}	1100	}
1055		1101
1056		1102
1057	/**	1103	/**
1058	* Start the background processing thread.	1104	* Start the background processing thread.
1059	*/	1105	*/
1060	private void threadStart() {	1106	private void threadStart() {
1061		1107
1062	log(sm.getString("httpConnector.starting"));	1108	log(sm.getString("httpConnector.starting"));
1063		1109
1064	thread = new Thread(this, threadName);	1110	thread = new Thread(this, threadName);
1065	thread.setDaemon(true);	1111	thread.setDaemon(true);
1066	thread.start();	1112	thread.start();
1067		1113
1068	}	1114	}
1069		1115
1070		1116
1071	/**	1117	/**
1072	* Stop the background processing thread.	1118	* Stop the background processing thread.
1073	*/	1119	*/
1074	private void threadStop() {	1120	private void threadStop() {
1075		1121
1076	log(sm.getString("httpConnector.stopping"));	1122	log(sm.getString("httpConnector.stopping"));
1077		1123
1078	stopped = true;	1124	stopped = true;
1079	try {	1125	try {
1080	threadSync.wait(5000);	1126	threadSync.wait(5000);
1081	} catch (InterruptedException e) {	1127	} catch (InterruptedException e) {
1082	;	1128	;
1083	}	1129	}
1084	thread = null;	1130	thread = null;
1085		1131
1086	}	1132	}
1087		1133
1088		1134
1089	// ------------------------------------------------------ Lifecycle Methods	1135	// ------------------------------------------------------ Lifecycle Methods
1090		1136
1091		1137
1092	/**	1138	/**
1093	* Add a lifecycle event listener to this component.	1139	* Add a lifecycle event listener to this component.
1094	*	1140	*
1095	* @param listener The listener to add	1141	* @param listener The listener to add
1096	*/	1142	*/
1097	public void addLifecycleListener(LifecycleListener listener) {	1143	public void addLifecycleListener(LifecycleListener listener) {
1098		1144
1099	lifecycle.addLifecycleListener(listener);	1145	lifecycle.addLifecycleListener(listener);
1100		1146
1101	}	1147	}
1102		1148
1103		1149
1104	/**	1150	/**
		1151	* Get the lifecycle listeners associated with this lifecycle. If this
		1152	* Lifecycle has no listeners registered, a zero-length array is returned.
		1153	*/
		1154	public LifecycleListener[] findLifecycleListeners() {
		1155
		1156	return lifecycle.findLifecycleListeners();
		1157
		1158	}
		1159
		1160
		1161	/**
1105	* Remove a lifecycle event listener from this component.	1162	* Remove a lifecycle event listener from this component.
1106	*	1163	*
1107	* @param listener The listener to add	1164	* @param listener The listener to add
1108	*/	1165	*/
1109	public void removeLifecycleListener(LifecycleListener listener) {	1166	public void removeLifecycleListener(LifecycleListener listener) {
1110		1167
1111	lifecycle.removeLifecycleListener(listener);	1168	lifecycle.removeLifecycleListener(listener);
1112		1169
1113	}	1170	}
1114		1171
1115		1172
1116	/**	1173	/**
1117	* Initialize this connector (create ServerSocket here!)	1174	* Initialize this connector (create ServerSocket here!)
1118	*/	1175	*/
1119	public void initialize()	1176	public void initialize()
1120	throws LifecycleException {	1177	throws LifecycleException {
1121	if (initialized)	1178	if (initialized)
1122	throw new LifecycleException (	1179	throw new LifecycleException (
1123	sm.getString("httpConnector.alreadyInitialized"));	1180	sm.getString("httpConnector.alreadyInitialized"));
		1181
1124	this.initialized=true;	1182	this.initialized=true;
		1183	Exception eRethrow = null;
1125		1184
1126	// Establish a server socket on the specified port	1185	// Establish a server socket on the specified port
1127	try {	1186	try {
1128	serverSocket = open();	1187	serverSocket = open();
1129	} catch (IOException e) {	1188	} catch (IOException ioe) {
1130	throw new LifecycleException(threadName + ".o p en", e);	1189	log("httpConne c t o r, io problem: ", ioe);
		1190	eRethrow = ioe;
		1191	} catch (KeyStoreException kse) {
		1192	log("httpConnector, keystore problem: ", kse);
		1193	eRethrow = kse;
		1194	} catch (NoSuchAlgorithmException nsae) {
		1195	log("httpConnector, keystore algorithm problem: ", nsae);
		1196	eRethrow = nsae;
		1197	} catch (CertificateException ce) {
		1198	log("httpConnector, certificate problem: ", ce);
		1199	eRethrow = ce;
		1200	} catch (UnrecoverableKeyException uke) {
		1201	log("httpConnector, unrecoverable key: ", uke);
		1202	eRethrow = uke;
		1203	} catch (KeyManagementException kme) {
		1204	log("httpConnector, key management problem: ", kme);
		1205	eRethrow = kme;
1131	}	1206	}
1132		1207
		1208	if ( eRethrow != null )
		1209	throw new LifecycleException(threadName + ".open", eRethrow);
		1210
1133	}	1211	}
1134		1212
1135		1213
1136	/**	1214	/**
1137	* Begin processing requests via this Connector.	1215	* Begin processing requests via this Connector.
1138	*	1216	*
1139	* @exception LifecycleException if a fatal startup error occurs	1217	* @exception LifecycleException if a fatal startup error occurs
1140	*/	1218	*/
1141	public void start() throws LifecycleException {	1219	public void start() throws LifecycleException {
1142		1220
1143	// Validate and update our current state	1221	// Validate and update our current state
1144	if (started)	1222	if (started)
1145	throw new LifecycleException	1223	throw new LifecycleException
1146	(sm.getString("httpConnector.alreadyStarted"));	1224	(sm.getString("httpConnector.alreadyStarted"));
1147	threadName = "HttpConnector[" + port + "]";	1225	threadName = "HttpConnector[" + port + "]";
1148	lifecycle.fireLifecycleEvent(START_EVENT, null);	1226	lifecycle.fireLifecycleEvent(START_EVENT, null);
1149	started = true;	1227	started = true;
1150		1228
1151	// Start our background thread	1229	// Start our background thread
1152	threadStart();	1230	threadStart();
1153		1231
1154	// Create the specified minimum number of processors	1232	// Create the specified minimum number of processors
1155	while (curProcessors < minProcessors) {	1233	while (curProcessors < minProcessors) {
1156	if ((maxProcessors > 0) && (curProcessors >= maxProcessors))	1234	if ((maxProcessors > 0) && (curProcessors >= maxProcessors))
1157	break;	1235	break;
1158	HttpProcessor processor = newProcessor();	1236	HttpProcessor processor = newProcessor();
1159	recycle(processor);	1237	recycle(processor);
1160	}	1238	}
1161		1239
1162	}	1240	}
1163		1241
1164		1242
1165	/**	1243	/**
1166	* Terminate processing requests via this Connector.	1244	* Terminate processing requests via this Connector.
1167	*	1245	*
1168	* @exception LifecycleException if a fatal shutdown error occurs	1246	* @exception LifecycleException if a fatal shutdown error occurs
1169	*/	1247	*/
1170	public void stop() throws LifecycleException {	1248	public void stop() throws LifecycleException {
1171		1249
1172	// Validate and update our current state	1250	// Validate and update our current state
1173	if (!started)	1251	if (!started)
1174	throw new LifecycleException	1252	throw new LifecycleException
1175	(sm.getString("httpConnector.notStarted"));	1253	(sm.getString("httpConnector.notStarted"));
1176	lifecycle.fireLifecycleEvent(STOP_EVENT, null);	1254	lifecycle.fireLifecycleEvent(STOP_EVENT, null);
1177	started = false;	1255	started = false;
1178		1256
1179	// Gracefully shut down all processors we have created	1257	// Gracefully shut down all processors we have created
1180	for (int i = created.size() - 1; i >= 0; i--) {	1258	for (int i = created.size() - 1; i >= 0; i--) {
1181	HttpProcessor processor = (HttpProcessor) created.elementAt(i);	1259	HttpProcessor processor = (HttpProcessor) created.elementAt(i);
1182	if (processor instanceof Lifecycle) {	1260	if (processor instanceof Lifecycle) {
1183	try {	1261	try {
1184	((Lifecycle) processor).stop();	1262	((Lifecycle) processor).stop();
1185	} catch (LifecycleException e) {	1263	} catch (LifecycleException e) {
1186	log("HttpConnector.stop", e);	1264	log("HttpConnector.stop", e);
1187	}	1265	}
1188	}	1266	}
1189	}	1267	}
1190		1268
1191	synchronized (threadSync) {	1269	synchronized (threadSync) {
1192	// Close the server socket we were using	1270	// Close the server socket we were using
1193	if (serverSocket != null) {	1271	if (serverSocket != null) {
1194	try {	1272	try {
1195	serverSocket.close();	1273	serverSocket.close();
1196	} catch (IOException e) {	1274	} catch (IOException e) {
1197	;	1275	;
1198	}	1276	}
1199	}	1277	}
1200	// Stop our background thread	1278	// Stop our background thread
1201	threadStop();	1279	threadStop();
1202	}	1280	}
1203	serverSocket = null;	1281	serverSocket = null;
1204		1282
1205	}	1283	}
1206		1284
1207		1285
1208	}	1286	}