Project: Icecast

Revision: 15123

Author: karl

Date: 21 Jul 2008 22:24:30

• /icecast/trunk/icecast/src/connection.c

  ......	@@ -106,13 +106,9 @@
  106	106	static mutex_t _connection_mutex;
  107	107	static volatile unsigned long _current_id = 0;
  108	108	static int _initialized = 0;
  109		static thread_type *tid;
  110	109
  111	110	static volatile client_queue_t *_req_queue = NULL, **_req_queue_tail = &_req_queue;
  112	111	static volatile client_queue_t *_con_queue = NULL, **_con_queue_tail = &_con_queue;
  113		static mutex_t _con_queue_mutex;
  114		static mutex_t _req_queue_mutex;
  115
  116	112	static int ssl_ok;
  117	113	#ifdef HAVE_OPENSSL
  118	114	static SSL_CTX *ssl_ctx;
  ......	@@ -123,7 +119,7 @@
  123	119
  124	120	rwlock_t _source_shutdown_rwlock;
  125	121
  126		static void *_handle_connection(void *arg);
  	122	static void _handle_connection(void);
  127	123
  128	124	static int compare_ip (void *arg, void *a, void *b)
  129	125	{
  ......	@@ -146,8 +142,6 @@
  146	142	if (_initialized) return;
  147	143
  148	144	thread_mutex_create(&_connection_mutex);
  149		thread_mutex_create(&_con_queue_mutex);
  150		thread_mutex_create(&_req_queue_mutex);
  151	145	thread_mutex_create(&move_clients_mutex);
  152	146	thread_rwlock_create(&_source_shutdown_rwlock);
  153	147	thread_cond_create(&global.shutdown_cond);
  ......	@@ -177,8 +171,6 @@
  177	171
  178	172	thread_cond_destroy(&global.shutdown_cond);
  179	173	thread_rwlock_destroy(&_source_shutdown_rwlock);
  180		thread_mutex_destroy(&_con_queue_mutex);
  181		thread_mutex_destroy(&_req_queue_mutex);
  182	174	thread_mutex_destroy(&_connection_mutex);
  183	175	thread_mutex_destroy(&move_clients_mutex);
  184	176
  ......	@@ -521,12 +513,12 @@
  521	513	#endif
  522	514	}
  523	515
  524		static connection_t *_accept_connection(void)
  	516	static connection_t *_accept_connection(int duration)
  525	517	{
  526		sock_t sock, serversock;
  	518	sock_t sock, serversock;
  527	519	char *ip;
  528	520
  529		serversock = wait_for_serversock(100);
  	521	serversock = wait_for_serversock (duration);
  530	522	if (serversock == SOCK_ERROR)
  531	523	return NULL;
  532	524
  ......	@@ -566,10 +558,8 @@
  566	558	*/
  567	559	static void _add_connection (client_queue_t *node)
  568	560	{
  569		thread_mutex_lock (&_con_queue_mutex);
  570	561	*_con_queue_tail = node;
  571	562	_con_queue_tail = (volatile client_queue_t **)&node->next;
  572		thread_mutex_unlock (&_con_queue_mutex);
  573	563	}
  574	564
  575	565
  ......	@@ -583,12 +573,10 @@
  583	573	/* common case, no new connections so don't bother taking locks */
  584	574	if (_con_queue)
  585	575	{
  586		thread_mutex_lock (&_con_queue_mutex);
  587	576	node = (client_queue_t *)_con_queue;
  588	577	_con_queue = node->next;
  589	578	if (_con_queue == NULL)
  590	579	_con_queue_tail = &_con_queue;
  591		thread_mutex_unlock (&_con_queue_mutex);
  592	580	node->next = NULL;
  593	581	}
  594	582	return node;
  ......	@@ -664,12 +652,10 @@
  664	652
  665	653	if (pass_it)
  666	654	{
  667		thread_mutex_lock (&_req_queue_mutex);
  668	655	if ((client_queue_t **)_req_queue_tail == &(node->next))
  669	656	_req_queue_tail = (volatile client_queue_t **)node_ref;
  670	657	*node_ref = node->next;
  671	658	node->next = NULL;
  672		thread_mutex_unlock (&_req_queue_mutex);
  673	659	_add_connection (node);
  674	660	continue;
  675	661	}
  ......	@@ -678,11 +664,9 @@
  678	664	{
  679	665	if (len == 0 || client->con->error)
  680	666	{
  681		thread_mutex_lock (&_req_queue_mutex);
  682	667	if ((client_queue_t **)_req_queue_tail == &node->next)
  683	668	_req_queue_tail = (volatile client_queue_t **)node_ref;
  684	669	*node_ref = node->next;
  685		thread_mutex_unlock (&_req_queue_mutex);
  686	670	client_destroy (client);
  687	671	free (node);
  688	672	continue;
  ......	@@ -690,6 +674,7 @@
  690	674	}
  691	675	node_ref = &node->next;
  692	676	}
  	677	_handle_connection();
  693	678	}
  694	679
  695	680
  ......	@@ -698,27 +683,24 @@
  698	683	*/
  699	684	static void _add_request_queue (client_queue_t *node)
  700	685	{
  701		thread_mutex_lock (&_req_queue_mutex);
  702	686	*_req_queue_tail = node;
  703	687	_req_queue_tail = (volatile client_queue_t **)&node->next;
  704		thread_mutex_unlock (&_req_queue_mutex);
  705	688	}
  706	689
  707	690
  708		void connection_accept_loop(void)
  	691	void connection_accept_loop (void)
  709	692	{
  710	693	connection_t *con;
  711	694	ice_config_t *config;
  	695	int duration = 300;
  712	696
  713	697	config = config_get_config ();
  714	698	get_ssl_certificate (config);
  715	699	config_release_config ();
  716	700
  717		tid = thread_create ("connection thread", _handle_connection, NULL, THREAD_ATTACHED);
  718
  719	701	while (global.running == ICE_RUNNING)
  720	702	{
  721		con = _accept_connection();
  	703	con = _accept_connection (duration);
  722	704
  723	705	if (con)
  724	706	{
  ......	@@ -768,6 +750,12 @@
  768	750
  769	751	_add_request_queue (node);
  770	752	stats_event_inc (NULL, "connections");
  	753	duration = 5;
  	754	}
  	755	else
  	756	{
  	757	if (_req_queue == NULL)
  	758	duration = 300; /* use longer timeouts when nothing waiting */
  771	759	}
  772	760	process_request_queue ();
  773	761	}
  ......	@@ -775,9 +763,6 @@
  775	763	/* Give all the other threads notification to shut down */
  776	764	thread_cond_broadcast(&global.shutdown_cond);
  777	765
  778		if (tid)
  779		thread_join (tid);
  780
  781	766	/* wait for all the sources to shutdown */
  782	767	thread_rwlock_wlock(&_source_shutdown_rwlock);
  783	768	thread_rwlock_unlock(&_source_shutdown_rwlock);
  ......	@@ -1267,21 +1252,21 @@
  1267	1252	* the contents provided. We set up the parser then hand off to the specific
  1268	1253	* request handler.
  1269	1254	*/
  1270		static void *_handle_connection(void *arg)
  	1255	static void _handle_connection(void)
  1271	1256	{
  1272	1257	http_parser_t *parser;
  1273	1258	const char *rawuri;
  	1259	client_queue_t *node;
  1274	1260
  1275		while (global.running == ICE_RUNNING) {
  1276
  1277		client_queue_t *node = _get_connection();
  1278
  	1261	while (1)
  	1262	{
  	1263	node = _get_connection();
  1279	1264	if (node)
  1280	1265	{
  1281	1266	client_t *client = node->client;
  1282	1267
  1283	1268	/* Check for special shoutcast compatability processing */
  1284		if (node->shoutcast)
  	1269	if (node->shoutcast)
  1285	1270	{
  1286	1271	_handle_shoutcast_compatible (node);
  1287	1272	continue;
  ......	@@ -1313,7 +1298,7 @@
  1313	1298
  1314	1299	free (node->shoutcast_mount);
  1315	1300	free (node);
  1316
  	1301
  1317	1302	if (strcmp("ICE", httpp_getvar(parser, HTTPP_VAR_PROTOCOL)) &&
  1318	1303	strcmp("HTTP", httpp_getvar(parser, HTTPP_VAR_PROTOCOL))) {
  1319	1304	ERROR0("Bad HTTP protocol detected");
  ......	@@ -1353,11 +1338,8 @@
  1353	1338	}
  1354	1339	continue;
  1355	1340	}
  1356		thread_sleep (50000);
  	1341	break;
  1357	1342	}
  1358		DEBUG0 ("Connection thread done");
  1359
  1360		return NULL;
  1361	1343	}
  1362	1344
  1363	1345