Context Navigation

source: roaraudio/roard/roard.c @ 4924:fad0cb1288b2

Visit:

Last change on this file since 4924:fad0cb1288b2 was 4924:fad0cb1288b2, checked in by phi, 13 years ago
added quite some functions to ignore list for win32
File size: 73.3 KB

Line
1	//roard.c:
2
3	/*
4	* Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2011
5	*
6	* This file is part of roard a part of RoarAudio,
7	* a cross-platform sound system for both, home and professional use.
8	* See README for details.
9	*
10	* This file is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License version 3
12	* as published by the Free Software Foundation.
13	*
14	* RoarAudio is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this software; see the file COPYING. If not, write to
21	* the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22	* Boston, MA 02110-1301, USA.
23	*
24	*/
25
26	/* ckport options:
27	* Stuff checked by configure:
28	* ckport: ignore-symbol: getuid of target win32
29	* ckport: ignore-symbol: setuid of target win32
30	* ckport: ignore-symbol: getgid of target win32
31	* ckport: ignore-symbol: setgid of target win32
32	* ckport: ignore-symbol: setsid of target win32
33	* ckport: ignore-symbol: kill of target win32
34	* ckport: ignore-symbol: chroot of target win32
35	* ckport: ignore-symbol: fork of target win32
36	* ckport: ignore-symbol: getservbyname of target win32
37	* ckport: ignore-symbol: nice of target win32
38	*
39	*/
40
41	#include "roard.h"
42
43	enum action {
44	START,
45	STOP,
46	RESTART,
47	RESTART_RETRY,
48	SHUTDOWN
49	};
50
51	enum af_mode {
52	AF_MODE_NONE,
53	AF_MODE_LOAD,
54	AF_MODE_GEN
55	};
56
57	#ifdef ROAR_SUPPORT_LISTEN
58	char * server[ROAR_MAX_LISTEN_SOCKETS];
59	#endif
60
61	#if defined(ROAR_HAVE_IO_POSIX) && defined(ROAR_HAVE_FS_POSIX)
62	#define SUPPORT_PIDFILE
63	char * pidfile = NULL;
64	#endif
65
66	#if defined(ROAR_HAVE_SETGID) \|\| defined(ROAR_HAVE_SETUID)
67	int setids = 0;
68	#endif
69
70	#ifdef ROAR_HAVE_LIBX11
71	char * x11display = NULL;
72	#endif
73
74	void dbg_notify_cb(struct roar_notify_core * core, struct roar_event * event, void * userdata) {
75	char buf[1024] = "";
76	char estr[1024] = "/* ROAR_??? */";
77	char ttstr[1024] = "/* ROAR_OT_??? */";
78	const char * ttname;
79	uint32_t ev = ROAR_EVENT_GET_TYPE(event);
80	int i;
81
82	ttname = roar_ot2str(event->target_type);
83	if ( ttname != NULL ) {
84	snprintf(ttstr, sizeof(ttstr)-1, "/* ROAR_OT_%s */", ttname);
85	buf[sizeof(ttstr)-1] = 0;
86	for (i = 0; ttstr[i] != 0; i++)
87	if ( islower(ttstr[i]) )
88	ttstr[i] = toupper(ttstr[i]);
89	}
90
91	if ( ev == ROAR_NOTIFY_SPECIAL ) {
92	snprintf(estr, sizeof(estr)-1, "/* ROAR_NOTIFY_SPECIAL */");
93	} else if ( ROAR_NOTIFY_IS_CMD(ev) ) {
94	if ( command_get_name(ROAR_NOTIFY_EVENT2CMD(ev), &ttname) == -1 ) {
95	snprintf(estr, sizeof(estr)-1, "/* ROAR_NOTIFY_CMD2EVENT(%i) */", ROAR_NOTIFY_EVENT2CMD(ev));
96	} else {
97	snprintf(estr, sizeof(estr)-1, "/* ROAR_NOTIFY_CMD2EVENT(ROAR_CMD_%s) */", ttname);
98	for (i = 0; estr[i] != 0; i++)
99	if ( islower(estr[i]) )
100	estr[i] = toupper(estr[i]);
101	}
102	} else if ( ROAR_NOTIFY_IS_EGRP(ev) ) {
103	snprintf(estr, sizeof(estr)-1, "/* ROAR_NOTIFY_EGRP2EVENT(%i) */", ROAR_NOTIFY_EVENT2EGRP(ev));
104	} else if ( ROAR_NOTIFY_IS_OE(ev) ) {
105	switch (ev) {
106	// OE basics:
107	case ROAR_OE_BASICS_CHANGE_STATE:
108	snprintf(estr, sizeof(estr)-1, "/* ROAR_OE_BASICS_CHANGE_STATE */");
109	break;
110	case ROAR_OE_BASICS_CHANGE_FLAGS:
111	snprintf(estr, sizeof(estr)-1, "/* ROAR_OE_BASICS_CHANGE_FLAGS */");
112	break;
113	case ROAR_OE_BASICS_NEW:
114	snprintf(estr, sizeof(estr)-1, "/* ROAR_OE_BASICS_NEW */");
115	break;
116	case ROAR_OE_BASICS_DELETE:
117	snprintf(estr, sizeof(estr)-1, "/* ROAR_OE_BASICS_DELETE */");
118	break;
119	// OE Streams:
120	case ROAR_OE_STREAM_CHANGE_VOLUME:
121	snprintf(estr, sizeof(estr)-1, "/* ROAR_OE_STREAM_CHANGE_VOLUME */");
122	break;
123	case ROAR_OE_STREAM_XRUN:
124	snprintf(estr, sizeof(estr)-1, "/* ROAR_OE_STREAM_XRUN */");
125	break;
126	case ROAR_OE_STREAM_META_UPDATE:
127	snprintf(estr, sizeof(estr)-1, "/* ROAR_OE_STREAM_META_UPDATE */");
128	break;
129	// OE Default:
130	default:
131	snprintf(estr, sizeof(estr)-1, "/* ROAR_NOTIFY_OE2EVENT(%i) */", ROAR_NOTIFY_EVENT2OE(ev));
132	break;
133	}
134	} else if ( ROAR_NOTIFY_IS_USER(ev) ) {
135	snprintf(estr, sizeof(estr)-1, "/* ROAR_NOTIFY_USER2EVENT(%i) */", ROAR_NOTIFY_EVENT2USER(ev));
136	}
137
138	buf[sizeof(estr)-1] = 0;
139
140	if ( event->flags & ROAR_EVENT_FLAG_PROXYEVENT ) {
141	snprintf(buf, sizeof(buf)-1, ".event_proxy=0x%.8x%s, ", (int)event->event_proxy, estr);
142	buf[sizeof(buf)-1] = 0;
143	}
144
145	ROAR_INFO("dbg_notify_cb(core=%p, event=%p{.flags=0x%.8x, event=0x%.8x%s, %s.emitter=%i, .target=%i, .target_type=%i%s, .arg0=%i, .arg1=%i, .arg2=%p}, userdata=%p) = (void)",
146	0 /* always print: minlevel = 0 */,
147	core, event,
148	(int)event->flags,
149	(int)event->event,
150	(event->flags & ROAR_EVENT_FLAG_PROXYEVENT ? "" : estr),
151	buf,
152	event->emitter,
153	event->target,
154	event->target_type,
155	ttstr,
156	event->arg0,
157	event->arg1,
158	event->arg2,
159	userdata);
160	}
161
162	void dbg_notify_cb_register (void) {
163	struct roar_event event;
164
165	memset(&event, 0, sizeof(event));
166
167	event.event = ROAR_EGRP_ANY_EVENT;
168
169	event.emitter = -1;
170	event.target = -1;
171	event.target_type = -1;
172
173	roar_notify_core_subscribe(NULL, &event, dbg_notify_cb, NULL);
174	}
175
176	#ifdef ROAR_HAVE_MAIN_ARGS
177	void usage (void) {
178	printf("Usage: roard [OPTIONS]...\n\n");
179
180	printf("Misc Options:\n\n");
181	printf(
182	" --daemon - Bring the server into background after init\n"
183	" --verbose - Be more verbose, can be used multiple times\n"
184	" --terminate - Terminate after last client quited\n"
185	" --start - No op parameter (starting roard is default operation)\n"
186	" --restart - Trys to stop an old instance and start a new with new settings\n"
187	" --stop - Stops a running roard (provide --pidfile!)\n"
188	" --shutdown - Terminates a running roard (provide --pidfile!)\n"
189	" --realtime - Trys to get realtime priority,\n"
190	" give multible times for being more realtime\n"
191	" --memlock LEVEL - Set default memory locking level to LEVEL\n"
192	#ifdef ROAR_HAVE_CHROOT
193	" --chroot DIR - chroots to the given dir\n"
194	#endif
195	#ifdef ROAR_HAVE_SETGID
196	" --setgid - GroupID to the audio group as specified via -G\n"
197	#endif
198	#ifdef ROAR_HAVE_SETUID
199	" --setuid - UserID to the audio user as specified via -U\n"
200	#endif
201	" --sysclocksync - calculate exact sample rate using the system clock\n"
202	" --location LOC - Set lion readable location of server\n"
203	" --description DESC - Set lion readable description of server\n"
204	#ifdef SUPPORT_PIDFILE
205	" --pidfile PIDFILE - Write a pidfile at PIDFILE\n"
206	#endif
207	#ifdef ROAR_HAVE_SYSLOG
208	" --log-syslog - Log Warnings, Errors, ... to syslog\n"
209	#endif
210	#ifdef ROAR_HAVE_SYSTEM
211	" --script-postdown S - Run command lion S after complet shutdown.\n"
212	#endif
213	);
214
215	printf("\nAuth Options:\n\n");
216	printf(
217	" --guest-acclev ACCLEV - Sets the access level for guest access to ACCLEV\n"
218	" --trust-acclev ACCLEV - Sets the access level for trust-authed\n"
219	" connections to ACCLEV\n"
220	" --trust-root - Trust root user\n"
221	" --no-trust-root - Don't trust root user\n"
222	" --authfile-gen FILE - Generate an new authfile\n"
223	" --authfile-load FILE - Load an authfile\n"
224	" --authfile-type TYPE - Type of authfile\n"
225	" --authfile-acclev ACCLEV\n"
226	" - Sets the access level for authfile\n"
227	" --new-authfile - Parameters for new authfile follow\n"
228	);
229
230	printf("\nPlugin Options:\n\n");
231	printf(
232	" --plugin-load FILE - Load plugin FILE\n"
233	);
234
235	printf("\nAudio Options:\n\n");
236	printf(
237	" -R --rate RATE - Set server rate\n"
238	" -B --bits BITS - Set server bits\n"
239	" -C --chans CHANNELS - Set server channels\n"
240	" --aiprofile PROFILE - Use the given audio profile\n"
241	);
242
243	printf("\nStream Options:\n\n");
244	printf(
245	" --stream-flags D=F - Set default flags for stream directions\n"
246	" D is the stream direction and F is a comma separated\n"
247	" list of flags in form +flag or -flag to set or unset\n"
248	" a flag as default or remove it from the default\n"
249	);
250
251	printf("\nOutput Options:\n\n");
252	printf(" -o --odriver DRV - Set the driver, use '--list-driver' to get a list\n");
253	printf(" -O --odevice DEV - Set the device\n");
254	printf(" -oO OPTS - Set output options\n");
255	printf(" -oN - Adds another output\n");
256	printf(" -oP - Mark output as primary\n");
257	#ifdef ROAR_DRIVER_DEFAULT
258	printf(" --list-driver - List all drivers (default driver: %s)\n", ROAR_DRIVER_DEFAULT);
259	#else
260	printf(" --list-driver - List all drivers (default driver: (autodetect))\n");
261	#endif
262
263	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
264	printf("\nSource Options:\n\n");
265	printf(" -s --source DRV - Use DRV as input driver\n"
266	" -S DEV - Use DEV as input device\n"
267	" -sO OPTS - Use OPTS as input options\n"
268	" -sN - Adds another source\n"
269	" -sP - Make souce as primary\n"
270	);
271	printf(" --list-sources - List all sources\n");
272	#endif
273
274	#ifndef ROAR_WITHOUT_DCOMP_MIXER
275	printf("\nHardware Mixer Options:\n\n");
276	printf(" -m --mixer DRV - Use DRV as mixer driver\n"
277	" -M DEV - Use DEV as mixer device\n"
278	" -mO OPTS - Use OPTS as mixer options\n"
279	" -mN - Adds another mixer\n"
280	" -mP - Make mixer as primary\n"
281	);
282	printf(" --list-mixers - List all mixers\n");
283	#endif
284
285	printf("\nCodec Filter Options:\n\n");
286	printf(" --list-cf - List all codec filter\n"
287	);
288
289	#ifndef ROAR_WITHOUT_DCOMP_MIDI
290	printf("\nMIDI Options:\n\n");
291	printf(" --midi-no-console - Disable console based MIDI synth\n"
292	" --midi-console-enable - Enables the console based MIDI synth\n"
293	" --midi-console DEV - Set device for MIDI console\n"
294	#ifndef ROAR_WITHOUT_DCOMP_SSYNTH
295	" --ssynth-enable - Enable simple software synth\n"
296	" --ssynth-disable - Disable simple software synth\n"
297	#endif
298	);
299	#endif
300
301	#ifndef ROAR_WITHOUT_DCOMP_LIGHT
302	printf("\nLight Control Options:\n\n");
303	printf(" --light-channels NUM - Sets the number of channels for Light control (default: %i)\n",
304	LIGHT_CHANNELS_DEFAULT
305	);
306	#endif
307
308	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
309	printf("\nRadio Data and Transmitter Control System Options:\n\n");
310	printf(" --rds-pi PI - Sets the RDS Programme Identification (PI)\n"
311	" --rds-ps PS - Sets the RDS Programme Service Name (PS)\n"
312	" --rds-pty PTY - Sets the RDS Programme Type (PTY)\n"
313	" --rds-tp - Sets the RDS Traffic Programme (TP) flag\n"
314	" --rds-ct - Enables sending of RDS Clock Time (CT)\n"
315	);
316	#endif
317
318	#ifdef ROAR_HAVE_LIBX11
319	printf("\nX11 Options:\n\n");
320	printf(
321	" --x11-display DISPLAY - Set display for X11\n"
322	" --display DISPLAY - Set display for X11\n"
323	);
324	#endif
325
326	printf("\nServer Options:\n\n");
327	printf(" -t --tcp - Use TCP listen socket\n"
328	#ifdef ROAR_HAVE_UNIX
329	" -u --unix - Use UNIX Domain listen socket (default)\n"
330	#endif
331	#ifdef ROAR_HAVE_LIBDNET
332	" -n --decnet - use DECnet listen socket\n"
333	#endif
334	" -4 - Use IPv4 connections (implies -t)\n"
335	#ifdef AF_INET6
336	" -6 - Use IPv6 connections (implies -t)\n"
337	#endif
338	#ifdef IPV6_ADDRFORM
339	" -64 - Try to downgrade sockets from IPv6 into IPv4,\n"
340	" this is normaly not useful.\n"
341	#endif
342	" -p --port - TCP Port to bind to\n"
343	" -b --bind - IP/Hostname to bind to\n"
344	" --sock - Filename for UNIX Domain Socket\n"
345	" --proto PROTO - Use PROTO as protocol on Socket\n"
346	" --proto-dir DIR - Set direction parameter for protocol\n"
347	" --proto-rate RATE - Set sample rate parameter for protocol\n"
348	" --proto-bits BITS - Set bits per sample parameter for protocol\n"
349	" --proto-codec E - Set codec parameter for protocol\n"
350	" --proto-chans C - Set number of channels parameter for protocol\n"
351	" --proto-aiprofile PROFILE\n"
352	" - Sets the audio profile for socket\n"
353	" --proto-profile P - Set profile for listen socket\n"
354	" --list-proto - List supported protocols\n"
355	" --list-profiles - List supported profiles for --proto-profile\n"
356	" --list-aiprofiles - List supported profiles for --proto-aiprofile\n"
357	" --new-sock - Parameters for new socket follow\n"
358	#ifdef ROAR_HAVE_LIBSLP
359	" --slp - Enable OpenSLP support\n"
360	#endif
361	#ifdef ROAR_HAVE_LIBX11
362	" --x11 - Enable X11 support\n"
363	#endif
364	" --jumbo-mtu MTU - Sets the MTU for Jumbo Packets\n"
365	" -G GROUP - Sets the group for the UNIX Domain Socket, (default: %s)\n"
366	" You need the permissions to change the GID\n"
367	" -U USER - Sets the user for the UNIX Domain Socket, (default: do not set)\n"
368	" You need the permissions to change the UID (normaly only root has)\n"
369	" --no-listen - Do not listen for new clients\n"
370	" (only useful for relaing, impleys --terminate)\n"
371	" --client-fh - Comunicate with a client over this handle\n"
372	" (only useful for relaing)\n"
373	" --close-fh - Closes the given fh\n"
374	" --standby - Start in standby state\n"
375	" --auto-standby - Automatical goes into standby if there are no streams\n",
376	#ifdef ROAR_DEFAULT_SOCKGRP
377	ROAR_DEFAULT_SOCKGRP
378	#else
379	"(none)"
380	#endif
381	);
382	// printf("\n Options:\n\n");
383	printf("\n");
384	}
385
386	static void list_proto (void) {
387	printf(" Protocol Flag Subsys - Description\n");
388	printf("------------------------------------------------------\n");
389	printf(" roar WM LRX - RoarAudio native protocol\n");
390	#if !defined(ROAR_WITHOUT_DCOMP_EMUL_ESD) && defined(ROAR_HAVE_H_ESD)
391	printf(" esd W - EsounD emulation\n");
392	#endif
393	#ifndef ROAR_WITHOUT_DCOMP_EMUL_SIMPLE
394	printf(" simple WM LRX - PulseAudio simple protocol\n");
395	#endif
396	#ifndef ROAR_WITHOUT_DCOMP_EMUL_RSOUND
397	printf(" rsound W - RSound emulation\n");
398	#endif
399	#ifndef ROAR_WITHOUT_DCOMP_EMUL_RPLAY
400	printf(" rplay W - RPlay emulation\n");
401	#endif
402	#ifndef ROAR_WITHOUT_DCOMP_EMUL_GOPHER
403	printf(" gopher - The Internet Gopher Protocol\n");
404	#endif
405	}
406
407	#endif
408
409	#define _pmsg(format, args...) roar_debug_msg(type, __LINE__, __FILE__, ROAR_DBG_PREFIX, format, ## args)
410	#define _pmsgc(group, counter, name) _pmsg(" Counter %-10s: %llu", (name), (long long unsigned int)counters_get(group, counter))
411	void counters_print(int type, int force) {
412	if ( type != ROAR_DEBUG_TYPE_INFO \|\| force \|\| (ROAR_DBG_INFOVAR) >= ROAR_DBG_INFO_INFO ) {
413	_pmsg("--- Counter Listing ---");
414	_pmsg(" Current:");
415	_pmsgc(cur, clients, "Clients");
416	_pmsgc(cur, streams, "Streams");
417	_pmsg(" Total:");
418	_pmsgc(sum, clients, "Clients");
419	_pmsgc(sum, streams, "Streams");
420	_pmsg("--- End of Counter Listing ---");
421	}
422	}
423	#undef _pmsgc
424	#undef _pmsg
425
426	int restart_server (char * server, int terminate) {
427	struct roar_connection con;
428	#ifdef ROAR_HAVE_KILL
429	char buf[80];
430	ssize_t l;
431	struct roar_vio_calls fh;
432	pid_t pid;
433	int ok;
434
435	ROAR_INFO("restart_server(server='%s', terminate=%i): trying to restart server", ROAR_DBG_INFO_INFO, server, terminate);
436
437	if ( pidfile != NULL ) {
438	if ( roar_vio_open_file(&fh, pidfile, O_RDONLY, 0644) == -1 ) {
439	ROAR_WARN("restart_server(*): Can not read pidfile: %s", pidfile);
440	} else {
441	l = roar_vio_read(&fh, buf, 80);
442	roar_vio_close(&fh);
443	if ( l > 0 ) {
444	buf[l-1] = 0;
445	buf[79] = 0;
446	pid = atoi(buf);
447	if ( terminate ) {
448	ok = kill(pid, SIGUSR1);
449	} else {
450	ok = kill(pid, SIGINT);
451	}
452	if ( ok == 0 ) {
453	return 0;
454	} else {
455	ROAR_WARN("restart_server(*): Can not kill roard by pidfile");
456	}
457	} else {
458	ROAR_WARN("restart_server(*): Can not find a PID in the pidfile");
459	}
460	}
461	}
462	#endif
463
464	if ( roar_simple_connect(&con, server, "roard") == -1 ) {
465	return -1;
466	}
467
468	if ( roar_terminate(&con, terminate) == -1 ) {
469	return -1;
470	}
471
472	return roar_disconnect(&con);
473	}
474
475	#define R_SETUID 1
476	#define R_SETGID 2
477
478	int init_config (void) {
479	int i;
480
481	memset(g_config, 0, sizeof(struct roard_config));
482
483	for (i = 0; i < ROAR_DIR_DIRIDS; i++) {
484	g_config->streams[i].mixer_channels = 1;
485	g_config->streams[i].mixer.rpg_mul = 1;
486	g_config->streams[i].mixer.rpg_div = 1;
487	g_config->streams[i].mixer.scale = 65535;
488	g_config->streams[i].mixer.mixer[0] = g_config->streams[i].mixer.scale;
489	}
490
491	g_config->streams[ROAR_DIR_PLAY ].flags = ROAR_FLAG_META;
492	g_config->streams[ROAR_DIR_OUTPUT ].flags = ROAR_FLAG_PASSMIXER;
493	g_config->streams[ROAR_DIR_FILTER ].flags = ROAR_FLAG_SYNC;
494	g_config->streams[ROAR_DIR_MIDI_OUT].flags = ROAR_FLAG_SYNC;
495	g_config->streams[ROAR_DIR_BIDIR ].flags = ROAR_FLAG_ANTIECHO;
496
497	g_config->location = CONF_DEF_STRING;
498	g_config->description = CONF_DEF_STRING;
499
500	g_config->memlock_level = -1;
501
502	#ifdef ROAR_HAVE_SYSTEM
503	g_config->scripts.post_shutdown = NULL;
504	#endif
505
506	return 0;
507	}
508
509	#ifdef ROAR_SUPPORT_LISTEN
510	int init_listening (void) {
511	int i;
512
513	memset(g_listen, 0, sizeof(g_listen));
514
515	for (i = 0; i < ROAR_MAX_LISTEN_SOCKETS; i++) {
516	g_listen[i].proto = ROAR_PROTO_ROARAUDIO;
517	server[i] = NULL;
518	}
519
520	return 0;
521	}
522
523	int get_listen(struct roard_listen sock, char * sockname) {
524	int i;
525
526	if ( sock == NULL )
527	return -1;
528
529	for (i = 0; i < ROAR_MAX_LISTEN_SOCKETS; i++) {
530	if ( ! g_listen[i].used ) {
531	server[i] = NULL;
532	*sock = &(g_listen[i]);
533
534	if ( sockname != NULL )
535	*sockname = &(server[i]);
536
537	return 0;
538	}
539	}
540
541	return -1;
542	}
543
544	#ifdef ROAR_SUPPORT_LISTEN
545	static struct _listen_profile {
546	const char * name;
547	int type;
548	int port;
549	const char * sockaddr;
550	int proto;
551	int dir;
552	const char * aiprofile;
553	const char * desc;
554	} _g_listen_profiles[] = {
555	// RoarAudio:
556	#ifdef ROAR_HAVE_UNIX
557	{"roar-usock", ROAR_SOCKET_TYPE_UNIX, 0, "~/" ROAR_DEFAULT_SOCK_USER,
558	ROAR_PROTO_ROARAUDIO, -1, NULL,
559	"RoarAudio default user profile"},
560	{"roar-gsock", ROAR_SOCKET_TYPE_UNIX, 0, ROAR_DEFAULT_SOCK_GLOBAL,
561	ROAR_PROTO_ROARAUDIO, -1, NULL,
562	"RoarAudio default global profile"},
563	#endif
564	#ifdef ROAR_HAVE_IPV4
565	{"roar-tcp", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_PORT, ROAR_DEFAULT_INET4_HOST,
566	ROAR_PROTO_ROARAUDIO, -1, NULL,
567	"RoarAudio local TCP profile"},
568	{"roar-tcp-pub", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_PORT, ROAR_NET_INET4_ANYHOST,
569	ROAR_PROTO_ROARAUDIO, -1, NULL,
570	"RoarAudio network TCP profile"},
571	#endif
572	#ifdef ROAR_HAVE_IPV6
573	{"roar-tcp6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_PORT, ROAR_DEFAULT_INET4_HOST,
574	ROAR_PROTO_ROARAUDIO, -1, NULL,
575	"RoarAudio local TCP profile"},
576	{"roar-tcp-pub6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_PORT, ROAR_NET_INET4_ANYHOST,
577	ROAR_PROTO_ROARAUDIO, -1, NULL,
578	"RoarAudio network TCP profile"},
579	#endif
580	#ifdef ROAR_HAVE_LIBDNET
581	{"roar-dnet", ROAR_SOCKET_TYPE_DECNET, 0, ROAR_DEFAULT_LISTEN_OBJECT,
582	ROAR_PROTO_ROARAUDIO, -1, NULL,
583	"RoarAudio default DECnet"},
584	#endif
585	#ifdef ROAR_HAVE_UNIX
586	{"roar-abstract", ROAR_SOCKET_TYPE_UNKNOWN, 0, "+abstract", ROAR_PROTO_ROARAUDIO, -1, NULL,
587	"RoarAudio abstract namespace profile"},
588	#endif
589
590	// EsounD:
591	#if !defined(ROAR_WITHOUT_DCOMP_EMUL_ESD) && defined(ROAR_HAVE_H_ESD)
592	#ifdef ROAR_HAVE_UNIX
593	{"esd-unix", ROAR_SOCKET_TYPE_UNIX, 0, ROAR_DEFAULT_ESD_GSOCK,
594	ROAR_PROTO_ESOUND, -1, NULL,
595	"EsounD default local profile"},
596	#endif
597	#ifdef ROAR_HAVE_IPV4
598	{"esd-tcp", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_ESD_PORT, ROAR_NET_INET4_LOCALHOST,
599	ROAR_PROTO_ESOUND, -1, NULL,
600	"EsounD local TCP profile"},
601	{"esd-tcp-pub", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_ESD_PORT, ROAR_NET_INET4_ANYHOST,
602	ROAR_PROTO_ESOUND, -1, NULL,
603	"EsounD network TCP profile"},
604	#endif
605	#ifdef ROAR_HAVE_IPV6
606	{"esd-tcp6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_ESD_PORT, ROAR_NET_INET6_LOCALHOST,
607	ROAR_PROTO_ESOUND, -1, NULL,
608	"EsounD local TCP profile"},
609	{"esd-tcp-pub6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_ESD_PORT, ROAR_NET_INET6_ANYHOST,
610	ROAR_PROTO_ESOUND, -1, NULL,
611	"EsounD network TCP profile"},
612	#endif
613	#endif
614
615	// RSound:
616	#ifndef ROAR_WITHOUT_DCOMP_EMUL_RSOUND
617	#ifdef ROAR_HAVE_UNIX
618	{"rsound-unix", ROAR_SOCKET_TYPE_UNIX, 0, ROAR_DEFAULT_RSOUND_GSOCK,
619	ROAR_PROTO_RSOUND, -1, NULL,
620	"RSound default local profile"},
621	#endif
622	#ifdef ROAR_HAVE_IPV4
623	{"rsound-tcp", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_RSOUND_PORT, ROAR_NET_INET4_LOCALHOST,
624	ROAR_PROTO_RSOUND, -1, NULL,
625	"RSound local TCP profile"},
626	{"rsound-tcp-pub", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_RSOUND_PORT, ROAR_NET_INET4_ANYHOST,
627	ROAR_PROTO_RSOUND, -1, NULL,
628	"RSound network TCP profile"},
629	#endif
630	#ifdef ROAR_HAVE_IPV6
631	{"rsound-tcp6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_RSOUND_PORT, ROAR_NET_INET6_LOCALHOST,
632	ROAR_PROTO_RSOUND, -1, NULL,
633	"RSound local TCP profile"},
634	{"rsound-tcp-pub6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_RSOUND_PORT, ROAR_NET_INET6_ANYHOST,
635	ROAR_PROTO_RSOUND, -1, NULL,
636	"RSound network TCP profile"},
637	#endif
638	#ifdef ROAR_HAVE_LIBDNET
639	{"rsound-dnet", ROAR_SOCKET_TYPE_DECNET, 0, ROAR_DEFAULT_RSOUND_OBJECT,
640	ROAR_PROTO_RSOUND, -1, NULL,
641	"RSound DECnet profile"},
642	#endif
643	#endif
644
645	// PulseAudio Simple:
646	#ifndef ROAR_WITHOUT_DCOMP_EMUL_SIMPLE
647	#ifdef ROAR_HAVE_IPV4
648	{"pas-play-tcp", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_PA_PORT, ROAR_NET_INET4_ANYHOST,
649	ROAR_PROTO_SIMPLE, ROAR_DIR_PLAY, "default",
650	"PulseAudio Simple TCP play profile"},
651	{"pas-mon-tcp", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_PA_PORT, ROAR_NET_INET4_ANYHOST,
652	ROAR_PROTO_SIMPLE, ROAR_DIR_MONITOR, "default",
653	"PulseAudio Simple TCP monitor profile"},
654	#endif
655	#ifdef ROAR_HAVE_IPV6
656	{"pas-play-tcp6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_PA_PORT, ROAR_NET_INET6_ANYHOST,
657	ROAR_PROTO_SIMPLE, ROAR_DIR_PLAY, "default",
658	"PulseAudio Simple TCP play profile"},
659	{"pas-mon-tcp6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_PA_PORT, ROAR_NET_INET6_ANYHOST,
660	ROAR_PROTO_SIMPLE, ROAR_DIR_MONITOR, "default",
661	"PulseAudio Simple TCP monitor profile"},
662	#endif
663	#endif
664
665	// RPlay:
666	#ifndef ROAR_WITHOUT_DCOMP_EMUL_RPLAY
667	#ifdef ROAR_HAVE_IPV4
668	{"rplay-tcp", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_RPLAY_PORT, ROAR_NET_INET4_LOCALHOST,
669	ROAR_PROTO_RPLAY, -1, NULL,
670	"RPlay local TCP profile"},
671	{"rplay-tcp-pub", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_RPLAY_PORT, ROAR_NET_INET4_ANYHOST,
672	ROAR_PROTO_RPLAY, -1, NULL,
673	"RPlay network TCP profile"},
674	#endif
675	#ifdef ROAR_HAVE_IPV6
676	{"rplay-tcp6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_RPLAY_PORT, ROAR_NET_INET6_LOCALHOST,
677	ROAR_PROTO_RPLAY, -1, NULL,
678	"RPlay local TCP profile"},
679	{"rplay-tcp-pub6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_RPLAY_PORT, ROAR_NET_INET6_ANYHOST,
680	ROAR_PROTO_RPLAY, -1, NULL,
681	"RPlay network TCP profile"},
682	#endif
683	#endif
684
685	// Gopher:
686	#ifndef ROAR_WITHOUT_DCOMP_EMUL_GOPHER
687	#ifdef ROAR_HAVE_IPV4
688	{"gopher-tcp", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_GOPHER_PORT, ROAR_NET_INET4_LOCALHOST,
689	ROAR_PROTO_GOPHER, -1, NULL,
690	"Gopher local TCP profile"},
691	{"gopher-tcp-pub", ROAR_SOCKET_TYPE_TCP, ROAR_DEFAULT_GOPHER_PORT, ROAR_NET_INET4_ANYHOST,
692	ROAR_PROTO_GOPHER, -1, NULL,
693	"Gopher network TCP profile"},
694	#endif
695	#ifdef ROAR_HAVE_IPV6
696	{"gopher-tcp6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_GOPHER_PORT, ROAR_NET_INET6_LOCALHOST,
697	ROAR_PROTO_GOPHER, -1, NULL,
698	"Gopher local TCP profile"},
699	{"gopher-tcp-pub6", ROAR_SOCKET_TYPE_TCP6, ROAR_DEFAULT_GOPHER_PORT, ROAR_NET_INET6_ANYHOST,
700	ROAR_PROTO_GOPHER, -1, NULL,
701	"Gopher network TCP profile"},
702	#endif
703	#endif
704
705	// End of List:
706	{NULL, -1, -1, NULL, -1, -1, NULL, NULL}
707	};
708
709	void listen_listen_profiles (void) {
710	struct _listen_profile * p;
711	char * type;
712	int i;
713	char port[8];
714
715	printf("Name Type Address Port Protocol Dir Audio Profile - Description\n");
716	printf("-------------------------------------------------------------------------------------------------\n");
717	//roar-tcp-pub 0.0.0.0 16002 RoarAudio unknown (null) - (null)
718
719	for (i = 0; (p = &(_g_listen_profiles[i]))->name != NULL; i++) {
720	switch (p->type) {
721	case ROAR_SOCKET_TYPE_UNIX: type = "UNIX"; break;
722	case ROAR_SOCKET_TYPE_TCP: type = "TCP"; break;
723	case ROAR_SOCKET_TYPE_DECNET: type = "DECnet"; break;
724	case ROAR_SOCKET_TYPE_TCP6: type = "TCP6"; break;
725	default:
726	type = "unknown";
727	break;
728	}
729
730	if ( p->port ) {
731	snprintf(port, sizeof(port)-1, "%i", p->port);
732	port[sizeof(port)-1] = 0;
733	} else {
734	strcpy(port, "(none)");
735	}
736
737	printf("%-15s %-7s %-16s %-7s %-9s %-10s %-13s - %s\n",
738	p->name,
739	type,
740	p->sockaddr, port,
741	roar_proto2str(p->proto),
742	p->dir == -1 ? "(none)" : roar_dir2str(p->dir), p->aiprofile == NULL ? "(none)" : p->aiprofile,
743	p->desc == NULL ? "" : p->desc);
744	}
745	}
746
747	int get_listen_profile (const char * name,
748	int * port, char ** sockaddr, int * type,
749	int * proto,
750	int * dir, struct roar_audio_info * info) {
751	static char buf[1024];
752	struct _listen_profile * p;
753	int i;
754
755	for (i = 0; (p = &(_g_listen_profiles[i]))->name != NULL; i++) {
756	if ( !strcasecmp(p->name, name) ) {
757	*port = p->port;
758
759	if ( p->type == ROAR_SOCKET_TYPE_UNIX && p->sockaddr[0] != '+' ) {
760	roar_env_render_path_r(buf, sizeof(buf), p->sockaddr);
761	} else {
762	strncpy(buf, p->sockaddr, sizeof(buf));
763	}
764	*sockaddr = buf;
765	*type = p->type;
766
767	*proto = p->proto;
768	*dir = p->dir;
769
770	if ( p->aiprofile != NULL ) {
771	if ( roar_profile2info(info, p->aiprofile) == -1 ) {
772	ROAR_ERR("Unknown audio profile: %s", p->aiprofile);
773	return -1;
774	}
775	}
776	return 0;
777	}
778	}
779
780	return -1;
781	}
782	#endif
783
784	int add_listen (char * addr, int port, int sock_type, char * user, char * group, int proto, int dir, struct roar_audio_info * info) {
785	#if defined(ROAR_HAVE_SETGID) && defined(ROAR_HAVE_IO_POSIX)
786	struct group * grp = NULL;
787	#endif
788	#if defined(ROAR_HAVE_SETUID) && defined(ROAR_HAVE_IO_POSIX)
789	struct passwd * pwd = NULL;
790	#endif
791	#ifdef ROAR_HAVE_UNIX
792	char * env_roar_proxy_backup;
793	#endif
794	int sockid = -1;
795	#ifdef ROAR_HAVE_UNIX
796	int sock;
797	#endif
798	int i;
799
800	ROAR_INFO("add_listen(addr='%s', port=%i, sock_type=%i, user='%s', group='%s', proto=%s(%i), dir=%s(%i), info={.rate=%u, .bits=%u, .channels=%u, .codec=%s(%u)}): trying to add listen socket",
801	ROAR_DBG_INFO_INFO,
802	addr, port, sock_type, user, group, roar_proto2str(proto), proto, roar_dir2str(dir), dir,
803	info->rate, info->bits, info->channels, roar_codec2str(info->codec), info->codec);
804
805	if ( *addr != 0 ) {
806	for (i = 0; i < ROAR_MAX_LISTEN_SOCKETS; i++) {
807	if ( ! g_listen[i].used ) {
808	sockid = i;
809	break;
810	}
811	}
812
813	if ( sockid == -1 )
814	return -1;
815
816	g_listen[sockid].proto = proto;
817
818	ROAR_DBG("add_listen(*): proto=0x%.4x", proto);
819
820	if ( roar_vio_open_socket_listen(&(g_listen[sockid].sock), sock_type, addr, port) == -1 ) {
821	#ifdef ROAR_HAVE_UNIX
822	if ( *addr == '/' ) {
823	if ( (env_roar_proxy_backup = getenv("ROAR_PROXY")) != NULL ) {
824	env_roar_proxy_backup = strdup(env_roar_proxy_backup);
825	unsetenv("ROAR_PROXY");
826	}
827	if ( (sock = roar_socket_connect(addr, port)) != -1 ) {
828	close(sock);
829	ROAR_ERR("Can not open listen socket: Socket allready in use");
830	return -1;
831	} else {
832	unlink(addr);
833	if ( roar_vio_open_socket_listen(&(g_listen[sockid].sock), sock_type, addr, port) == -1 ) {
834	ROAR_ERR("Can not open listen socket: %s", strerror(errno));
835	return -1;
836	}
837	}
838	if ( env_roar_proxy_backup != NULL ) {
839	setenv("ROAR_PROXY", env_roar_proxy_backup, 0);
840	free(env_roar_proxy_backup);
841	}
842	#else
843	if (0) { // noop
844	#endif
845	} else {
846	ROAR_ERR("Can not open listen socket: %s", strerror(errno));
847	return -1;
848	}
849	}
850
851	ROAR_DBG("add_listen(*) = ?");
852
853	#if defined(ROAR_HAVE_SETGID) && defined(ROAR_HAVE_IO_POSIX)
854	if ( group != NULL ) {
855	if ( (grp = getgrnam(group)) == NULL ) {
856	ROAR_ERR("Can not get GID for group %s: %s", group, strerror(errno));
857	}
858	}
859	#endif
860
861	ROAR_DBG("add_listen(*) = ?");
862
863	#if defined(ROAR_HAVE_SETUID) && defined(ROAR_HAVE_IO_POSIX)
864	if ( user ) {
865	if ( (pwd = getpwnam(user)) == NULL ) {
866	ROAR_ERR("Can not get UID for user %s: %s", user, strerror(errno));
867	}
868	}
869	#endif
870
871	ROAR_DBG("add_listen(*) = ?");
872
873	#if defined(ROAR_HAVE_IO_POSIX) && defined(ROAR_HAVE_UNIX)
874	if ( *addr == '/' ) {
875	if ( grp \|\| pwd ) {
876	if ( chown(addr, pwd ? pwd->pw_uid : -1, grp ? grp->gr_gid : -1) == -1 )
877	return -1;
878	}
879	#ifdef ROAR_HAVE_GETUID
880	if ( grp ) {
881	if ( getuid() == 0 )
882	if ( chmod(addr, S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IWGRP) == -1 )
883	return -1;
884	}
885	#endif
886	}
887	#endif
888	}
889
890	ROAR_DBG("add_listen(*) = ?");
891
892	// in case we opened the listening socket correctly.
893	if ( dir == -1 )
894	dir = ROAR_DIR_PLAY;
895
896	g_listen[sockid].inst.stpl.dir = dir;
897	memcpy(&(g_listen[sockid].inst.stpl.info), info, sizeof(struct roar_audio_info));
898
899	switch (dir) {
900	case ROAR_DIR_PLAY:
901	case ROAR_DIR_RECORD:
902	case ROAR_DIR_MONITOR:
903	case ROAR_DIR_FILTER:
904	case ROAR_DIR_BIDIR:
905	if ( !g_listen[sockid].inst.stpl.info.rate )
906	g_listen[sockid].inst.stpl.info.rate = g_sa->rate;
907
908	if ( !g_listen[sockid].inst.stpl.info.bits )
909	g_listen[sockid].inst.stpl.info.bits = g_sa->bits;
910
911	if ( !g_listen[sockid].inst.stpl.info.channels )
912	g_listen[sockid].inst.stpl.info.channels = g_sa->channels;
913
914	if ( !g_listen[sockid].inst.stpl.info.codec )
915	g_listen[sockid].inst.stpl.info.codec = g_sa->codec;
916	break;
917	}
918
919	g_listen[sockid].used = 1;
920	server[sockid] = addr;
921
922	return 0;
923	}
924	#endif
925
926	static void list_aiprofiles (void) {
927	struct roar_audio_info info;
928	const char * list[1024];
929	const char * mime;
930	ssize_t ret;
931	ssize_t i;
932
933	ret = roar_profiles_list(list, 1024, 0);
934
935	if ( ret == -1 )
936	return;
937
938	printf(" Name Rate Bits Channels Codec\n");
939	printf("---------------------------------------------\n");
940	for (i = 0; i < ret; i++) {
941	roar_profile2info(&info, list[i]);
942
943	mime = roar_codec2mime(info.codec);
944
945	printf(" %-10s %5u %4u %8u %3u (%s%s%s%s)\n", list[i],
946	info.rate, info.bits, info.channels,
947	info.codec, roar_codec2str(info.codec),
948	info.codec == ROAR_CODEC_DEFAULT ? " native" : "",
949	mime == NULL ? "" : " mimetype:",
950	mime == NULL ? "" : mime
951	);
952	}
953	}
954
955	int update_stream_flags (char * str) {
956	int dir;
957	char * flags;
958	char * k;
959	int op;
960	int flag;
961
962	if ( (flags = strstr(str, "=")) == NULL )
963	return -1;
964
965	*flags = 0;
966	flags++;
967
968	if ( (dir = roar_str2dir(str)) == -1 )
969	return -1;
970
971	while (flags != NULL) {
972	k = flags;
973	flags = strstr(flags, ",");
974
975	if ( flags != NULL )
976	*(flags++) = 0;
977
978	switch (*k) {
979	case '+': k++; op = ROAR_SET_FLAG; break;
980	case '-': k++; op = ROAR_RESET_FLAG; break;
981	default:
982	op = ROAR_SET_FLAG;
983	}
984
985	flag = 0;
986
987	if ( !strcmp(k, "sync") ) {
988	flag = ROAR_FLAG_SYNC;
989	} else if ( !strcmp(k, "meta") ) {
990	flag = ROAR_FLAG_META;
991	} else if ( !strcmp(k, "cleanmeta") ) {
992	flag = ROAR_FLAG_CLEANMETA;
993	} else if ( !strcmp(k, "pause") ) {
994	flag = ROAR_FLAG_PAUSE;
995	} else if ( !strcmp(k, "mute") ) {
996	flag = ROAR_FLAG_MUTE;
997	} else if ( !strcmp(k, "antiecho") ) {
998	flag = ROAR_FLAG_ANTIECHO;
999	} else if ( !strcmp(k, "passmixer") ) {
1000	flag = ROAR_FLAG_PASSMIXER;
1001	} else if ( !strcmp(k, "recsource") ) {
1002	flag = ROAR_FLAG_RECSOURCE;
1003	} else {
1004	return -1;
1005	}
1006
1007	g_config->streams[dir].flags \|= flag;
1008
1009	if ( op == ROAR_RESET_FLAG )
1010	g_config->streams[dir].flags -= flag;
1011	}
1012
1013	return 0;
1014	}
1015
1016	int add_authfile (const char * file, const char * type, enum af_mode mode, enum roard_client_acclev acclev) {
1017	struct roar_authfile * authfile = NULL;
1018	struct roar_authfile_key * key = NULL;
1019	int af_type = ROAR_AUTHFILE_TYPE_AUTO;
1020	void * keydata;
1021	int i;
1022
1023	if ( type == NULL ) {
1024	// noop.
1025	} else if ( !strcasecmp(type, "roar") ) {
1026	af_type = ROAR_AUTHFILE_TYPE_ROAR;
1027	} else if ( !strcasecmp(type, "roar") ) {
1028	af_type = ROAR_AUTHFILE_TYPE_ROAR;
1029	} else if ( !strcasecmp(type, "esd") ) {
1030	af_type = ROAR_AUTHFILE_TYPE_ESD;
1031	} else if ( !strcasecmp(type, "pulse") ) {
1032	af_type = ROAR_AUTHFILE_TYPE_PULSE;
1033	} else if ( !strcasecmp(type, "htpasswd") ) {
1034	af_type = ROAR_AUTHFILE_TYPE_HTPASSWD;
1035	} else if ( !strcasecmp(type, "xauth") ) {
1036	af_type = ROAR_AUTHFILE_TYPE_XAUTH;
1037	} else {
1038	ROAR_ERR("add_authfile(*): unknown authfile type '%s'.", type);
1039	return -1;
1040	}
1041
1042	if ( mode == AF_MODE_GEN && af_type == ROAR_AUTHFILE_TYPE_AUTO )
1043	af_type = ROAR_AUTHFILE_TYPE_ESD;
1044
1045	switch (mode) {
1046	case AF_MODE_NONE:
1047	return 0;
1048	break;
1049	case AF_MODE_GEN:
1050	switch (af_type) {
1051	case ROAR_AUTHFILE_TYPE_ESD:
1052	key = roar_authfile_key_new_random(ROAR_AUTH_T_COOKIE, 16, NULL);
1053	break;
1054	case ROAR_AUTHFILE_TYPE_PULSE:
1055	key = roar_authfile_key_new_random(ROAR_AUTH_T_COOKIE, 256, NULL);
1056	break;
1057	default:
1058	return -1;
1059	break;
1060	}
1061
1062	if ( key == NULL ) {
1063	ROAR_ERR("add_authfile(*): Can not generate key.");
1064	return -1;
1065	}
1066
1067	if ( (authfile = roar_authfile_open(af_type, file, 1, ROAR_AUTHFILE_VERSION_AUTO)) == NULL ) {
1068	roar_authfile_key_unref(key);
1069	return -1;
1070	}
1071
1072	if ( roar_authfile_add_key(authfile, key) == -1 ) {
1073	ROAR_WARN("add_authfile(*): Can not add key to authfile.");
1074	}
1075
1076	keydata = roar_mm_memdup(key->data, key->len);
1077
1078	if ( keydata == NULL ) {
1079	ROAR_WARN("add_authfile(*): Can not allocate memory for key.");
1080	} else if ( auth_addkey_cookie(acclev, keydata, key->len) == -1 ) {
1081	ROAR_WARN("add_authfile(*): Can not add key to internal key storage.");
1082	}
1083
1084	roar_authfile_key_unref(key);
1085	if ( roar_authfile_close(authfile) != 0 )
1086	return -1;
1087	return 0;
1088	break;
1089	case AF_MODE_LOAD:
1090	if ( (authfile = roar_authfile_open(af_type, file, 0, ROAR_AUTHFILE_VERSION_AUTO)) == NULL ) {
1091	return -1;
1092	}
1093
1094	for (i = 0; ; i++) {
1095	key = roar_authfile_lookup_key(authfile, ROAR_AUTH_T_AUTO, i, NULL);
1096	if ( key == NULL )
1097	break;
1098
1099	if ( key->type == ROAR_AUTH_T_COOKIE ) {
1100	keydata = roar_mm_memdup(key->data, key->len);
1101
1102	if ( keydata == NULL ) {
1103	ROAR_WARN("add_authfile(*): Can not allocate memory for key.");
1104	} else if ( auth_addkey_cookie(acclev, keydata, key->len) == -1 ) {
1105	ROAR_WARN("add_authfile(*): Can not add key to internal key storage.");
1106	}
1107	} else {
1108	ROAR_WARN("add_authfile(*): Unknown key type: %i", key->type);
1109	}
1110
1111	roar_authfile_key_unref(key);
1112	}
1113
1114	if ( roar_authfile_close(authfile) != 0 )
1115	return -1;
1116	return 0;
1117	break;
1118	}
1119
1120	return -1;
1121	}
1122
1123	// X11:
1124	#ifdef ROAR_HAVE_LIBX11
1125	int register_x11 (int unreg, char * sockname) {
1126	struct roar_x11_connection * x11con = NULL;
1127	int ret = 0;
1128
1129	if ( (x11con = roar_x11_connect(x11display)) == NULL ) {
1130	ROAR_ERR("Can not connect to X11 server for %sregistering", unreg ? "un" : "");
1131	return -1;
1132	}
1133
1134	if ( unreg ) {
1135	if ( roar_x11_delete_prop(x11con, "ROAR_SERVER") == -1 ) {
1136	ret = -1;
1137	ROAR_ERR("Error while unregistereing from X11", ROAR_DBG_INFO_INFO);
1138	} else {
1139	ROAR_INFO("Successfully unregistered from X11", ROAR_DBG_INFO_INFO);
1140	}
1141	} else {
1142	if ( roar_x11_set_prop(x11con, "ROAR_SERVER", sockname) == -1 ) {
1143	ret = -1;
1144	ROAR_ERR("Error while registereing to X11", ROAR_DBG_INFO_INFO);
1145	} else {
1146	ROAR_INFO("Successfully registered to X11", ROAR_DBG_INFO_INFO);
1147	}
1148	}
1149
1150	roar_x11_disconnect(x11con);
1151
1152	return ret;
1153	}
1154	#endif
1155
1156	// SLP:
1157	void register_slp_callback(SLPHandle hslp, SLPError errcode, void * cookie) {
1158	/* return the error code in the cookie */
1159	(SLPError)cookie = errcode;
1160	}
1161
1162	int register_slp (int unreg, char * sockname) {
1163	#ifdef ROAR_HAVE_LIBSLP
1164	static int regged = 0;
1165	static char * sn = NULL;
1166	SLPError err;
1167	SLPError callbackerr;
1168	SLPHandle hslp;
1169	char addr[1024];
1170	char attr[1024] = "";
1171	char * location;
1172	char * description;
1173	char * standards;
1174
1175	if ( sockname != NULL )
1176	sn = sockname;
1177
1178	snprintf(addr, sizeof(addr), ROAR_SLP_URL_TYPE_ROAR "://%s", sn);
1179
1180	err = SLPOpen("en", SLP_FALSE, &hslp);
1181
1182	if (err != SLP_OK) {
1183	ROAR_ERR("Error opening slp handle: Error #%i", err);
1184	return -1;
1185	}
1186
1187	if (!unreg) {
1188
1189	if ( SLPEscape(g_config->location, &location, SLP_FALSE) != SLP_OK ) {
1190	ROAR_ERR("Error using SLPEscape() on server location, really bad!");
1191	SLPClose(hslp);
1192	return -1;
1193	}
1194
1195	if ( SLPEscape(g_config->description, &description, SLP_FALSE) != SLP_OK ) {
1196	ROAR_ERR("Error using SLPEscape() on server location, really bad!");
1197	SLPClose(hslp);
1198	return -1;
1199	}
1200
1201	standards = stds_string();
1202
1203	if ( standards == NULL ) {
1204	if ( (standards = roar_mm_malloc(1)) == NULL ) {
1205	SLPClose(hslp);
1206	return -1;
1207	}
1208	standards[0] = 0;
1209	}
1210
1211	snprintf(attr, sizeof(attr), "(wave-rate=%i),(wave-channels=%i),(wave-bits=%i),"
1212	#ifndef ROAR_WITHOUT_DCOMP_LIGHT
1213	"(light-channels=%i),"
1214	#endif
1215	"(standards=%s),"
1216	"(location=%s),(description=%s)",
1217	g_sa->rate, g_sa->channels, g_sa->bits,
1218	#ifndef ROAR_WITHOUT_DCOMP_LIGHT
1219	g_light_state.channels,
1220	#endif
1221	standards,
1222	location, description
1223	);
1224
1225	roar_mm_free(standards);
1226
1227	/* Register a service with SLP */
1228	err = SLPReg(hslp,
1229	addr,
1230	SLP_LIFETIME_MAXIMUM,
1231	0,
1232	attr,
1233	SLP_TRUE,
1234	register_slp_callback,
1235	&callbackerr);
1236	regged = 1;
1237	} else if ( unreg && regged ) {
1238	err = SLPDereg(hslp, addr, register_slp_callback, &callbackerr);
1239	regged = 0;
1240	} else {
1241	SLPClose(hslp);
1242	return -1;
1243	}
1244
1245	/* err may contain an error code that occurred as the slp library */
1246	/* _prepared_ to make the call. */
1247	if ( err != SLP_OK ) {
1248	ROAR_ERR("Error (de)registering service with slp: Error #%i", err);
1249	return -1;
1250	}
1251
1252	/* callbackerr may contain an error code (that was assigned through */
1253	/* the callback cookie) that occurred as slp packets were sent on */
1254	/* the wire */
1255	if (callbackerr != SLP_OK) {
1256	ROAR_ERR("Error (de)registering service with slp: Error #%i", callbackerr);
1257	return -1;
1258	}
1259
1260	SLPClose(hslp);
1261	return 0;
1262	#else
1263	return -1;
1264	#endif
1265	}
1266
1267	static int auth_setup (enum roard_client_acclev none_acclev,
1268	enum roard_client_acclev trust_acclev, int trust_root, uid_t trust_uid, gid_t trust_gid) {
1269	union auth_typeunion * key;
1270	size_t i;
1271
1272	// Info:
1273	// if a authlevel is <= ACCLEV_IDENTED we do not need to add this to the keyring
1274	// as ACCLEV_IDENTED is already gained if IDENTIFY call was done correctly.
1275
1276	if ( !(none_acclev <= ACCLEV_IDENTED) ) {
1277	if ( auth_addkey_anonymous(none_acclev) == -1 )
1278	return -1;
1279	}
1280
1281	if ( !(trust_acclev <= ACCLEV_IDENTED) ) {
1282	if ( (key = auth_regkey_simple(ROAR_AUTH_T_TRUST, trust_acclev)) == NULL )
1283	return -1;
1284
1285	// zerosize all counters.
1286	memset(key, 0, sizeof(union auth_typeunion));
1287
1288	i = 0;
1289
1290	if ( trust_uid != -1 )
1291	key->trust.uids[i++] = trust_uid;
1292
1293	#ifdef ROAR_ROOT_UID
1294	if ( trust_root )
1295	key->trust.uids[i++] = ROAR_ROOT_UID;
1296	#endif
1297
1298	key->trust.uids_len = i;
1299
1300	i = 0;
1301
1302	if ( trust_gid != -1 )
1303	key->trust.gids[i++] = trust_gid;
1304
1305	key->trust.gids_len = i;
1306	}
1307
1308	return 0;
1309	}
1310
1311
1312	// MAIN:
1313
1314	#define _CKHAVEARGS(x) if ( (i + (x)) >= argc ) { \
1315	ROAR_ERR("Option %s requires more arguments. See --help for more details.", k); \
1316	return 70; \
1317	}
1318
1319	#ifdef ROAR_HAVE_MAIN_ARGS
1320	int main (int argc, char * argv[]) {
1321	#else
1322	int main (void) {
1323	#endif
1324	#ifdef ROAR_HAVE_MAIN_ARGS
1325	enum action action = START;
1326	int i;
1327	char * k;
1328	#endif
1329	#if defined(ROAR_SUPPORT_LISTEN) && defined(ROAR_HAVE_GETUID)
1330	char user_sock[80] = {0};
1331	#endif
1332	struct roar_audio_info sa, max_sa;
1333	struct roard_config config;
1334	#ifdef ROAR_HAVE_FORK
1335	int daemon = 0;
1336	#endif
1337	int realtime = 0;
1338	int sysclocksync = 0;
1339	// char * server = ROAR_DEFAULT_SOCK_GLOBAL;
1340	#ifdef ROAR_SUPPORT_LISTEN
1341	int port = ROAR_DEFAULT_PORT;
1342	char * sock_addr = NULL;
1343	int sock_proto = ROAR_PROTO_ROARAUDIO;
1344	int sock_dir = -1;
1345	struct roar_audio_info sock_info = {0, 0, 0, 0};
1346	#endif
1347	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1348	char * s_drv = "cf";
1349	char * s_dev = NULL;
1350	char * s_con = NULL;
1351	char * s_opt = NULL;
1352	int s_prim = 0;
1353	#endif
1354	char * o_drv = getenv("ROAR_DRIVER");
1355	char * o_dev = getenv("ROAR_DEVICE");
1356	char * o_opts = NULL;
1357	int o_prim = 0;
1358	int o_count = 0;
1359	#ifndef ROAR_WITHOUT_DCOMP_MIXER
1360	char * m_drv = NULL;
1361	char * m_dev = NULL;
1362	char * m_opts = NULL;
1363	int m_prim = 0;
1364	int m_count = 0;
1365	#endif
1366	enum roard_client_acclev none_acclev = ACCLEV_ALL;
1367	enum roard_client_acclev trust_acclev = ACCLEV_ALL;
1368	int trust_root = 1;
1369	char * af_file = NULL;
1370	char * af_type = NULL;
1371	enum af_mode af_mode = AF_MODE_NONE;
1372	enum roard_client_acclev af_acclev = ACCLEV_ALL;
1373	#ifndef ROAR_WITHOUT_DCOMP_LIGHT
1374	int light_channels = LIGHT_CHANNELS_DEFAULT;
1375	#endif
1376	#ifdef ROAR_DEFAULT_SOCKGRP
1377	char * sock_grp = ROAR_DEFAULT_SOCKGRP;
1378	#else
1379	char * sock_grp = NULL;
1380	#endif
1381	char * sock_user = NULL;
1382	#ifdef ROAR_SUPPORT_LISTEN
1383	int sock_type = ROAR_SOCKET_TYPE_UNKNOWN;
1384	#endif
1385	#ifdef ROAR_HAVE_LIBSLP
1386	int reg_slp = 0;
1387	#endif
1388	#ifdef ROAR_HAVE_LIBX11
1389	int reg_x11 = 0;
1390	#endif
1391	#ifdef ROAR_HAVE_CHROOT
1392	char * chrootdir = NULL;
1393	#endif
1394	#if defined(ROAR_HAVE_SETGID) && defined(ROAR_HAVE_IO_POSIX)
1395	struct group * grp = NULL;
1396	#endif
1397	#if defined(ROAR_HAVE_SETUID) && defined(ROAR_HAVE_IO_POSIX)
1398	struct passwd * pwd = NULL;
1399	#endif
1400	#ifdef ROAR_HAVE_GETSERVBYNAME
1401	struct servent * serv = NULL;
1402	#endif
1403	struct roar_client * self = NULL;
1404	#ifdef ROAR_HAVE_LIBDNET
1405	char decnethost[80];
1406	#endif
1407	#ifdef SUPPORT_PIDFILE
1408	struct roar_vio_calls pidfile_vio;
1409	#endif
1410
1411	ROAR_DBG("main(*): starting roard...");
1412
1413	g_standby = 0;
1414	g_autostandby = 0;
1415	alive = 1;
1416	#ifdef ROAR_SUPPORT_LISTEN
1417	g_no_listen = 0;
1418	#else
1419	g_terminate = 1;
1420	#endif
1421
1422	g_verbose = ROAR_DBG_INFO_NONE;
1423
1424	sa.bits = ROAR_BITS_DEFAULT;
1425	sa.channels = ROAR_CHANNELS_DEFAULT;
1426	sa.rate = ROAR_RATE_DEFAULT;
1427	sa.codec = ROAR_CODEC_DEFAULT;
1428
1429	g_sa = &sa;
1430	g_max_sa = &max_sa;
1431
1432	memcpy(g_max_sa, g_sa, sizeof(max_sa));
1433
1434	counters_init();
1435
1436	g_config = &config;
1437
1438	if ( init_config() == -1 ) {
1439	ROAR_ERR("Can not init default config!");
1440	return 1;
1441	}
1442
1443	// load config
1444	roar_libroar_get_config();
1445
1446	// init notify core:
1447	// TODO: reconsider number of lists.
1448	if ( roar_notify_core_new_global(-1) == -1 ) {
1449	ROAR_ERR("Can not init notify core!");
1450	return 1;
1451	}
1452
1453	if ( roar_notify_core_register_proxy(NULL, roar_notify_proxy_std, NULL) == -1 ) {
1454	ROAR_ERR("Can not init notify core!");
1455	return 1;
1456	}
1457
1458	#ifdef DEBUG
1459	// enable early in case we have DEBUG set.
1460	dbg_notify_cb_register();
1461	#endif
1462
1463	if ( auth_init() == -1 ) {
1464	ROAR_ERR("Can not init auth subsystem!");
1465	return 1;
1466	}
1467
1468	#ifdef ROAR_SUPPORT_LISTEN
1469	if ( init_listening() == -1 ) {
1470	ROAR_ERR("Can not init listening sockets!");
1471	return 1;
1472	}
1473	#endif
1474
1475	#ifndef ROAR_WITHOUT_DCOMP_MIDI
1476	if ( midi_init_config() == -1 ) {
1477	ROAR_ERR("Can not init MIDI config!");
1478	return 1;
1479	}
1480	#endif
1481
1482	#ifndef ROAR_WITHOUT_DCOMP_SSYNTH
1483	if ( ssynth_init_config() == -1 ) {
1484	ROAR_ERR("Can not init ssynth config!");
1485	return 1;
1486	}
1487	#endif
1488
1489	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
1490	if ( rdtcs_init_config() == -1 ) {
1491	ROAR_ERR("Can not init RDTCS config!");
1492	return 1;
1493	}
1494	#endif
1495
1496	if ( plugins_preinit() == -1 ) {
1497	ROAR_ERR("Can not pre-init plugins!");
1498	return 1;
1499	}
1500
1501	#ifdef ROAR_SUPPORT_LISTEN
1502	#ifndef ROAR_TARGET_WIN32
1503	sock_addr = ROAR_DEFAULT_SOCK_GLOBAL;
1504	#else
1505	sock_addr = ROAR_DEFAULT_HOST;
1506	#endif
1507
1508	#ifdef ROAR_HAVE_GETUID
1509	if ( getuid() != 0 && getenv("HOME") != NULL ) {
1510	/*
1511	snprintf(user_sock, 79, "%s/%s", (char*)getenv("HOME"), ROAR_DEFAULT_SOCK_USER);
1512	*/
1513	roar_env_render_path_r(user_sock, sizeof(user_sock), "~/" ROAR_DEFAULT_SOCK_USER);
1514	sock_addr = user_sock;
1515	ROAR_DBG("main(*): setting sock_addr='%s'", sock_addr);
1516	}
1517	#endif
1518
1519	if ( getenv("ROAR_SERVER") != NULL )
1520	sock_addr = getenv("ROAR_SERVER");
1521	#endif
1522
1523	if ( clients_init() == -1 ) {
1524	ROAR_ERR("Can not init clients!");
1525	return 1;
1526	}
1527
1528	if ( streams_init() == -1 ) {
1529	ROAR_ERR("Can not init streams!");
1530	return 1;
1531	}
1532
1533	if ( (g_self_client = clients_new()) == -1 ) {
1534	ROAR_ERR("Can not create self client!");
1535	return 1;
1536	}
1537
1538	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1539	if ( sources_init() == -1 ) {
1540	ROAR_ERR("Can not init sources!");
1541	return 1;
1542	}
1543
1544	if ( (sources_set_client(g_self_client)) == -1 ) {
1545	ROAR_ERR("Can not init set source client!");
1546	return 1;
1547	}
1548	#endif
1549
1550	#ifdef ROAR_HAVE_MAIN_ARGS
1551	for (i = 1; i < argc; i++) {
1552	k = argv[i];
1553
1554	if ( strcmp(k, "-h") == 0 \|\| strcmp(k, "--help") == 0 ) {
1555	usage();
1556	return 0;
1557
1558	} else if ( strcmp(k, "--start") == 0 ) {
1559	// this is a no op
1560	action = START;
1561	} else if ( strcmp(k, "--restart") == 0 ) {
1562	action = RESTART;
1563	#ifdef ROAR_SUPPORT_LISTEN
1564	if ( restart_server(sock_addr, 1) == -1 ) {
1565	ROAR_WARN("Can not terminate old server (not running at %s?), will retry later.", sock_addr);
1566	action = RESTART_RETRY;
1567	}
1568	#else
1569	ROAR_ERR("--restart not supported");
1570	#endif
1571	} else if ( strcmp(k, "--shutdown") == 0 ) {
1572	action = SHUTDOWN;
1573	} else if ( strcmp(k, "--stop") == 0 ) {
1574	action = STOP;
1575
1576
1577	} else if ( strcmp(k, "--demon") == 0 \|\| strcmp(k, "--daemon") == 0 ) {
1578	#ifdef ROAR_HAVE_FORK
1579	daemon = 1;
1580	#else
1581	ROAR_ERR("--daemon not supported");
1582	#endif
1583	} else if ( strcmp(k, "--verbose") == 0 ) {
1584	g_verbose++;
1585	} else if ( strcmp(k, "--terminate") == 0 ) {
1586	g_terminate = 1;
1587	} else if ( strcmp(k, "--sysclocksync") == 0 ) {
1588	sysclocksync = 1000;
1589	} else if ( strcmp(k, "--realtime") == 0 ) {
1590	realtime++;
1591	} else if ( strcmp(k, "--memlock") == 0 ) {
1592	_CKHAVEARGS(1);
1593	g_config->memlock_level = memlock_str2level(argv[++i]);
1594	} else if ( strcmp(k, "--chroot") == 0 ) {
1595	_CKHAVEARGS(1);
1596	#ifdef ROAR_HAVE_CHROOT
1597	chrootdir = argv[++i];
1598	#else
1599	ROAR_ERR("--chroot not supported");
1600	i++;
1601	#endif
1602	} else if ( strcmp(k, "--setgid") == 0 ) {
1603	#ifdef ROAR_HAVE_SETGID
1604	setids \|= R_SETGID;
1605	#else
1606	ROAR_ERR("--setgid not supported");
1607	#endif
1608	} else if ( strcmp(k, "--setuid") == 0 ) {
1609	#ifdef ROAR_HAVE_SETUID
1610	setids \|= R_SETUID;
1611	#else
1612	ROAR_ERR("--setuid not supported");
1613	#endif
1614	} else if ( strcmp(k, "--location") == 0 ) {
1615	_CKHAVEARGS(1);
1616	g_config->location = argv[++i];
1617	} else if ( strcmp(k, "--description") == 0 ) {
1618	_CKHAVEARGS(1);
1619	g_config->description = argv[++i];
1620	} else if ( strcmp(k, "--pidfile") == 0 ) {
1621	_CKHAVEARGS(1);
1622	#ifdef SUPPORT_PIDFILE
1623	pidfile = argv[++i];
1624	#else
1625	ROAR_ERR("--pidfile not supported");
1626	i++;
1627	#endif
1628	} else if ( strcmp(k, "--log-syslog") == 0 ) {
1629	#ifdef ROAR_HAVE_SYSLOG
1630	roar_debug_set_stderr_mode(ROAR_DEBUG_MODE_SYSLOG);
1631	#else
1632	ROAR_ERR("--log-syslog not supported");
1633	#endif
1634	} else if ( strcmp(k, "--script-postdown") == 0 ) {
1635	_CKHAVEARGS(1);
1636	#ifdef ROAR_HAVE_SYSTEM
1637	g_config->scripts.post_shutdown = argv[++i];
1638	#else
1639	ROAR_ERR("--script-postdown not supported");
1640	i++;
1641	#endif
1642
1643
1644	} else if ( strcmp(k, "--plugin-load") == 0 ) {
1645	_CKHAVEARGS(1);
1646	if ( plugins_load(argv[++i]) == -1 ) {
1647	ROAR_ERR("Can not load plugin");
1648	}
1649
1650	} else if ( strcmp(k, "--guest-acclev") == 0 ) {
1651	_CKHAVEARGS(1);
1652	none_acclev = clients_str2acclev(argv[++i]);
1653	} else if ( strcmp(k, "--trust-acclev") == 0 ) {
1654	_CKHAVEARGS(1);
1655	trust_acclev = clients_str2acclev(argv[++i]);
1656	} else if ( strcmp(k, "--trust-root") == 0 ) {
1657	trust_root = 1;
1658	} else if ( strcmp(k, "--no-trust-root") == 0 ) {
1659	trust_root = 0;
1660
1661	} else if ( strcmp(k, "--authfile-gen") == 0 ) {
1662	_CKHAVEARGS(1);
1663	af_file = argv[++i];
1664	af_mode = AF_MODE_GEN;
1665	} else if ( strcmp(k, "--authfile-load") == 0 ) {
1666	_CKHAVEARGS(1);
1667	af_file = argv[++i];
1668	af_mode = AF_MODE_LOAD;
1669	} else if ( strcmp(k, "--authfile-type") == 0 ) {
1670	_CKHAVEARGS(1);
1671	af_type = argv[++i];
1672	} else if ( strcmp(k, "--authfile-acclev") == 0 ) {
1673	_CKHAVEARGS(1);
1674	af_acclev = clients_str2acclev(argv[++i]);
1675	} else if ( strcmp(k, "--new-authfile") == 0 ) {
1676	if ( af_mode != AF_MODE_NONE ) {
1677	if ( add_authfile(af_file, af_type, af_mode, af_acclev) == -1 ) {
1678	ROAR_ERR("main(*): adding authfile '%s' failed!", af_file);
1679	}
1680	}
1681	af_file = NULL;
1682	af_type = NULL;
1683	af_mode = AF_MODE_NONE;
1684	af_acclev = ACCLEV_ALL;
1685
1686	} else if ( strcmp(k, "--list-cf") == 0 ) {
1687	print_codecfilterlist();
1688	return 0;
1689
1690	} else if ( strcmp(k, "-R") == 0 \|\| strcmp(k, "--rate") == 0 ) {
1691	_CKHAVEARGS(1);
1692	sa.rate = atoi(argv[++i]);
1693	} else if ( strcmp(k, "-B") == 0 \|\| strcmp(k, "--bits") == 0 ) {
1694	_CKHAVEARGS(1);
1695	sa.bits = atoi(argv[++i]);
1696	} else if ( strcmp(k, "-C") == 0 \|\| strcmp(k, "--chans") == 0 ) {
1697	_CKHAVEARGS(1);
1698	sa.channels = atoi(argv[++i]);
1699
1700	} else if ( strcmp(k, "--aiprofile") == 0 ) {
1701	_CKHAVEARGS(1);
1702	if ( roar_profile2info(&sa, argv[++i]) == -1 ) {
1703	ROAR_ERR("Unknown audio profile: %s", argv[i]);
1704	return 1;
1705	}
1706	sa.codec = ROAR_CODEC_DEFAULT;
1707
1708	} else if ( strcmp(k, "--stream-flags") == 0 ) {
1709	_CKHAVEARGS(1);
1710	if ( update_stream_flags(argv[++i]) == -1 ) {
1711	ROAR_ERR("Can not set stream flags");
1712	return 1;
1713	}
1714
1715	} else if ( strcmp(k, "--list-aiprofiles") == 0 ) {
1716	list_aiprofiles();
1717	return 0;
1718
1719	} else if ( strcmp(k, "--list-driver") == 0 ) {
1720	print_driverlist();
1721	return 0;
1722
1723	} else if ( strcmp(k, "-o") == 0 \|\| strcmp(k, "--odriver") == 0 ) {
1724	_CKHAVEARGS(1);
1725	o_drv = argv[++i];
1726	} else if ( strcmp(k, "-O") == 0 \|\| strcmp(k, "--odevice") == 0 ) {
1727	_CKHAVEARGS(1);
1728	o_dev = argv[++i];
1729	} else if ( strcmp(k, "-oO") == 0 ) {
1730	_CKHAVEARGS(1);
1731	o_opts = argv[++i];
1732	} else if ( strcmp(k, "-oP") == 0 ) {
1733	o_prim = 1;
1734	} else if ( strcmp(k, "-oN") == 0 ) {
1735	if ( action == START \|\| action == RESTART ) {
1736	if ( output_add(o_drv, o_dev, o_opts, o_prim, o_count) != -1 )
1737	o_count++;
1738
1739	o_drv = o_dev = o_opts = NULL;
1740	o_prim = 0;
1741	}
1742
1743	} else if ( strcmp(k, "-s") == 0 \|\| strcmp(k, "--source") == 0 ) {
1744	_CKHAVEARGS(1);
1745	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1746	s_drv = argv[++i];
1747	#else
1748	ROAR_ERR("main(*): No support for sources compiled in");
1749	i++;
1750	#endif
1751	} else if ( strcmp(k, "-S") == 0 ) {
1752	_CKHAVEARGS(1);
1753	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1754	s_dev = argv[++i];
1755	#else
1756	ROAR_ERR("main(*): No support for sources compiled in");
1757	i++;
1758	#endif
1759	} else if ( strcmp(k, "-sO") == 0 ) {
1760	_CKHAVEARGS(1);
1761	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1762	s_opt = argv[++i];
1763	#else
1764	ROAR_ERR("main(*): No support for sources compiled in");
1765	i++;
1766	#endif
1767	} else if ( strcmp(k, "-sC") == 0 ) {
1768	_CKHAVEARGS(1);
1769	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1770	s_con = argv[++i];
1771	#else
1772	ROAR_ERR("main(*): No support for sources compiled in");
1773	i++;
1774	#endif
1775	} else if ( strcmp(k, "-sP") == 0 ) {
1776	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1777	s_prim = 1;
1778	#else
1779	ROAR_ERR("main(*): No support for sources compiled in");
1780	#endif
1781	} else if ( strcmp(k, "-sN") == 0 ) {
1782	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1783	if ( sources_add(s_drv, s_dev, s_con, s_opt, s_prim) == -1 ) {
1784	ROAR_ERR("main(*): adding source '%s' via '%s' failed!", s_dev, s_drv);
1785	}
1786	s_opt = s_dev = s_con = NULL;
1787	s_drv = "cf";
1788	s_prim = 0;
1789	#else
1790	ROAR_ERR("main(*): No support for sources compiled in");
1791	#endif
1792	} else if ( strcmp(k, "--list-sources") == 0 ) {
1793	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
1794	print_sourcelist();
1795	return 0;
1796	#else
1797	ROAR_ERR("main(*): No support for sources compiled in");
1798	return 1;
1799	#endif
1800
1801	} else if ( strcmp(k, "-m") == 0 \|\| strcmp(k, "--mixer") == 0 ) {
1802	_CKHAVEARGS(1);
1803	#ifndef ROAR_WITHOUT_DCOMP_MIXER
1804	m_drv = argv[++i];
1805	#else
1806	ROAR_ERR("main(*): No support for mixer compiled in");
1807	return 1;
1808	#endif
1809	} else if ( strcmp(k, "-M") == 0 ) {
1810	_CKHAVEARGS(1);
1811	#ifndef ROAR_WITHOUT_DCOMP_MIXER
1812	m_dev = argv[++i];
1813	#else
1814	ROAR_ERR("main(*): No support for mixer compiled in");
1815	return 1;
1816	#endif
1817	} else if ( strcmp(k, "-mO") == 0 ) {
1818	_CKHAVEARGS(1);
1819	#ifndef ROAR_WITHOUT_DCOMP_MIXER
1820	m_opts = argv[++i];
1821	#else
1822	ROAR_ERR("main(*): No support for mixer compiled in");
1823	return 1;
1824	#endif
1825	} else if ( strcmp(k, "-mP") == 0 ) {
1826	#ifndef ROAR_WITHOUT_DCOMP_MIXER
1827	m_prim = 1;
1828	#else
1829	ROAR_ERR("main(*): No support for mixer compiled in");
1830	return 1;
1831	#endif
1832	} else if ( strcmp(k, "-mN") == 0 ) {
1833	#ifndef ROAR_WITHOUT_DCOMP_MIXER
1834	if ( hwmixer_add(m_drv, m_dev, m_opts, m_prim, m_count) != -1 )
1835	m_count++;
1836
1837	m_drv = o_dev = o_opts = NULL;
1838	m_prim = 0;
1839	#else
1840	ROAR_ERR("main(*): No support for mixer compiled in");
1841	return 1;
1842	#endif
1843	} else if ( strcmp(k, "--list-mixers") == 0 ) {
1844	#ifndef ROAR_WITHOUT_DCOMP_MIXER
1845	print_hwmixerlist();
1846	return 0;
1847	#else
1848	ROAR_ERR("main(*): No support for mixer compiled in");
1849	return 1;
1850	#endif
1851
1852	} else if ( strcmp(k, "--light-channels") == 0 ) {
1853	_CKHAVEARGS(1);
1854	#ifndef ROAR_WITHOUT_DCOMP_LIGHT
1855	light_channels = atoi(argv[++i]);
1856	#else
1857	ROAR_WARN("main(*): no light subsystem compiled in");
1858	i++;
1859	#endif
1860
1861	} else if ( strcmp(k, "--rds-pi") == 0 ) {
1862	_CKHAVEARGS(1);
1863	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
1864	g_rdtcs.rds.pi = atoi(argv[++i]);
1865	#else
1866	ROAR_WARN("main(*): no RDTCS subsystem compiled in");
1867	i++;
1868	#endif
1869	} else if ( strcmp(k, "--rds-ps") == 0 ) {
1870	_CKHAVEARGS(1);
1871	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
1872	if ( rdtcs_rds_set_ps(argv[++i]) == -1 ) {
1873	ROAR_ERR("Can not set RDS PS to '%s' (longer than 8 chars?)", argv[i]);
1874	return 1;
1875	}
1876	#else
1877	ROAR_WARN("main(*): no RDTCS subsystem compiled in");
1878	i++;
1879	#endif
1880	} else if ( strcmp(k, "--rds-pty") == 0 ) {
1881	_CKHAVEARGS(1);
1882	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
1883	if ( rdtcs_rds_set_pty(argv[++i]) == -1 ) {
1884	ROAR_ERR("Can not set RDS PTY to '%s'", argv[i]);
1885	return 1;
1886	}
1887	#else
1888	ROAR_WARN("main(*): no RDTCS subsystem compiled in");
1889	i++;
1890	#endif
1891	} else if ( strcmp(k, "--rds-tp") == 0 ) {
1892	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
1893	if ( rdtcs_rds_set_flag(RDTCS_RDS_FLAG_TP, 0) == -1 ) {
1894	ROAR_ERR("Can not set RDS TP flag");
1895	return 1;
1896	}
1897	#else
1898	ROAR_WARN("main(*): no RDTCS subsystem compiled in");
1899	#endif
1900	} else if ( strcmp(k, "--rds-ct") == 0 ) {
1901	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
1902	if ( rdtcs_rds_set_flag(RDTCS_RDS_FLAG_CT, 0) == -1 ) {
1903	ROAR_ERR("Can not set RDS CT flag");
1904	return 1;
1905	}
1906	#else
1907	ROAR_WARN("main(*): no RDTCS subsystem compiled in");
1908	#endif
1909
1910
1911	} else if ( strcmp(k, "--midi-no-console") == 0 ) {
1912	#ifndef ROAR_WITHOUT_DCOMP_CB
1913	midi_config.init_cb = 0;
1914	#else
1915	// no warning here as this is the disable option
1916	#endif
1917	} else if ( strcmp(k, "--midi-console-enable") == 0 ) {
1918	#ifndef ROAR_WITHOUT_DCOMP_CB
1919	midi_config.init_cb = 1;
1920	#else
1921	ROAR_ERR("main(*): No support for MIDI subsystem part CB compiled in");
1922	#endif
1923	} else if ( strcmp(k, "--midi-console") == 0 ) {
1924	_CKHAVEARGS(1);
1925	#ifndef ROAR_WITHOUT_DCOMP_CB
1926	midi_config.console_dev = argv[++i];
1927	midi_config.init_cb = 1;
1928	#else
1929	ROAR_ERR("main(*): No support for MIDI subsystem part CB compiled in");
1930	i++;
1931	#endif
1932
1933	} else if ( strcmp(k, "--ssynth-enable") == 0 ) {
1934	#ifndef ROAR_WITHOUT_DCOMP_SSYNTH
1935	ssynth_conf.enable = 1;
1936	#else
1937	ROAR_ERR("main(*): No support for ssynth compiled in");
1938	#endif
1939	} else if ( strcmp(k, "--ssynth-disable") == 0 ) {
1940	#ifndef ROAR_WITHOUT_DCOMP_SSYNTH
1941	ssynth_conf.enable = 0;
1942	#else
1943	// we can safely ignore the disable
1944	#endif
1945
1946	} else if ( strcmp(k, "--x11-display") == 0 \|\| strcmp(k, "--display") == 0 ) {
1947	_CKHAVEARGS(1);
1948	#ifdef ROAR_HAVE_LIBX11
1949	x11display = argv[++i];
1950	#else
1951	ROAR_ERR("No X11 support compiled in!");
1952	return 1;
1953	#endif
1954
1955
1956	} else if ( strcmp(k, "-p") == 0 \|\| strcmp(k, "--port") == 0 ) {
1957	_CKHAVEARGS(1);
1958	// This is only useful in INET not UNIX mode.
1959	#ifdef ROAR_SUPPORT_LISTEN
1960	if ( *sock_addr == '/' )
1961	sock_addr = ROAR_DEFAULT_HOST;
1962
1963	errno = 0;
1964	if ( (port = atoi(argv[++i])) < 1 ) {
1965	#ifdef ROAR_HAVE_GETSERVBYNAME
1966	if ( (serv = getservbyname(argv[i], "tcp")) == NULL ) {
1967	ROAR_ERR("Unknown service: %s: %s", argv[i], strerror(errno));
1968	return 1;
1969	}
1970	// NOTE: we need to use ROAR_NET2HOST16() here even if s_port is of type int!
1971	ROAR_DBG("main(*): serv = {s_name='%s', s_aliases={...}, s_port=%i, s_proto='%s'}",
1972	serv->s_name, ROAR_NET2HOST16(serv->s_port), serv->s_proto);
1973	port = ROAR_NET2HOST16(serv->s_port);
1974	#else
1975	ROAR_ERR("invalite port number: %s", argv[i]);
1976	return 1;
1977	#endif
1978	}
1979	#endif
1980	} else if ( strcmp(k, "-b") == 0 \|\| strcmp(k, "--bind") == 0 \|\| strcmp(k, "--sock") == 0 ) {
1981	_CKHAVEARGS(1);
1982	#ifdef ROAR_SUPPORT_LISTEN
1983	sock_addr = argv[++i];
1984	#else
1985	i++;
1986	#endif
1987
1988	} else if ( strcmp(k, "--proto") == 0 ) {
1989	#ifdef ROAR_SUPPORT_LISTEN
1990	if ( (sock_proto = roar_str2proto(argv[++i])) == -1 ) {
1991	ROAR_ERR("Unknown protocol: %s", argv[i]);
1992	return 1;
1993	}
1994	#endif
1995	} else if ( strcmp(k, "--proto-dir") == 0 ) {
1996	_CKHAVEARGS(1);
1997	#ifdef ROAR_SUPPORT_LISTEN
1998	if ( (sock_dir = roar_str2dir(argv[++i])) == -1 ) {
1999	ROAR_ERR("Unknown stream direction: %s", argv[i]);
2000	return 1;
2001	}
2002	#else
2003	i++;
2004	#endif
2005	} else if ( strcmp(k, "--proto-rate") == 0 ) {
2006	_CKHAVEARGS(1);
2007	#ifdef ROAR_SUPPORT_LISTEN
2008	sock_info.rate = atoi(argv[++i]);
2009	#else
2010	i++;
2011	#endif
2012	} else if ( strcmp(k, "--proto-bits") == 0 ) {
2013	_CKHAVEARGS(1);
2014	#ifdef ROAR_SUPPORT_LISTEN
2015	sock_info.bits = atoi(argv[++i]);
2016	#else
2017	i++;
2018	#endif
2019	} else if ( strcmp(k, "--proto-chans") == 0 ) {
2020	_CKHAVEARGS(1);
2021	#ifdef ROAR_SUPPORT_LISTEN
2022	sock_info.channels = atoi(argv[++i]);
2023	#else
2024	i++;
2025	#endif
2026	} else if ( strcmp(k, "--proto-codec") == 0 ) {
2027	_CKHAVEARGS(1);
2028	#ifdef ROAR_SUPPORT_LISTEN
2029	if ( (sock_info.codec = roar_str2codec(argv[++i])) == -1 ) {
2030	ROAR_ERR("Unknown codec: %s", argv[i]);
2031	return 1;
2032	}
2033	#else
2034	i++;
2035	#endif
2036	} else if ( strcmp(k, "--proto-aiprofile") == 0 ) {
2037	_CKHAVEARGS(1);
2038	#ifdef ROAR_SUPPORT_LISTEN
2039	if ( roar_profile2info(&sock_info, argv[++i]) == -1 ) {
2040	ROAR_ERR("Unknown audio profile: %s", argv[i]);
2041	return 1;
2042	}
2043	#else
2044	i++;
2045	#endif
2046	} else if ( strcmp(k, "--list-profiles") == 0 ) {
2047	#ifdef ROAR_SUPPORT_LISTEN
2048	listen_listen_profiles();
2049	return 0;
2050	#endif
2051	} else if ( strcmp(k, "--proto-profile") == 0 ) {
2052	_CKHAVEARGS(1);
2053	#ifdef ROAR_SUPPORT_LISTEN
2054	if ( get_listen_profile(argv[++i], &port, &sock_addr, &sock_type, &sock_proto, &sock_dir, &sock_info) == -1 ) {
2055	ROAR_ERR("Unknown listen profile: %s", argv[i]);
2056	return 1;
2057	}
2058	#else
2059	i++;
2060	#endif
2061
2062
2063	} else if ( strcmp(k, "--list-proto") == 0 ) {
2064	list_proto();
2065	return 0;
2066
2067	} else if ( strcmp(k, "-t") == 0 \|\| strcmp(k, "--tcp") == 0 ) {
2068	#ifdef ROAR_SUPPORT_LISTEN
2069	if ( sock_type != ROAR_SOCKET_TYPE_TCP && sock_type != ROAR_SOCKET_TYPE_TCP6 )
2070	sock_type = ROAR_SOCKET_TYPE_TCP;
2071
2072	if ( *sock_addr == '/' )
2073	sock_addr = ROAR_DEFAULT_HOST;
2074	#endif
2075
2076	} else if ( strcmp(k, "-4") == 0 ) {
2077	#ifdef ROAR_SUPPORT_LISTEN
2078	sock_type = ROAR_SOCKET_TYPE_TCP;
2079	if ( *sock_addr == '/' )
2080	sock_addr = ROAR_DEFAULT_HOST;
2081	#endif
2082	} else if ( strcmp(k, "-6") == 0 ) {
2083	#ifdef ROAR_SUPPORT_LISTEN
2084	#ifdef AF_INET6
2085	sock_type = ROAR_SOCKET_TYPE_TCP6;
2086	if ( *sock_addr == '/' )
2087	sock_addr = ROAR_DEFAULT_HOST;
2088	#else
2089	ROAR_ERR("No IPv6 support compiled in!");
2090	return 1;
2091	#endif
2092	#endif
2093
2094	} else if ( strcmp(k, "-u") == 0 \|\| strcmp(k, "--unix") == 0 ) {
2095	#ifdef ROAR_SUPPORT_LISTEN
2096	// ignore this case as it is the default behavor.
2097	sock_type = ROAR_SOCKET_TYPE_UNIX;
2098	#endif
2099
2100	} else if ( strcmp(k, "-n") == 0 \|\| strcmp(k, "--decnet") == 0 ) {
2101	#ifdef ROAR_SUPPORT_LISTEN
2102	#ifdef ROAR_HAVE_LIBDNET
2103	port = ROAR_DEFAULT_NUM;
2104	strcpy(decnethost, ROAR_DEFAULT_LISTEN_OBJECT);
2105	sock_addr = decnethost;
2106	sock_type = ROAR_SOCKET_TYPE_DECNET;
2107	#else
2108	ROAR_ERR("No DECnet support compiled in!");
2109	return 1;
2110	#endif
2111	#endif
2112	} else if ( strcmp(k, "--new-sock") == 0 ) {
2113	#ifdef ROAR_SUPPORT_LISTEN
2114	if ( action == START \|\| action == RESTART ) {
2115	if ( add_listen(sock_addr, port, sock_type, sock_user, sock_grp, sock_proto, sock_dir, &sock_info) != 0 ) {
2116	ROAR_ERR("Can not open listen socket!");
2117	return 1;
2118	}
2119	}
2120	#endif
2121
2122	} else if ( strcmp(k, "--slp") == 0 ) {
2123	#ifdef ROAR_HAVE_LIBSLP
2124	reg_slp = 1;
2125	#else
2126	ROAR_ERR("No OpenSLP support compiled in!");
2127	return 1;
2128	#endif
2129
2130	} else if ( strcmp(k, "--x11") == 0 ) {
2131	#ifdef ROAR_HAVE_LIBX11
2132	reg_x11 = 1;
2133	#else
2134	ROAR_ERR("No X11 support compiled in!");
2135	return 1;
2136	#endif
2137
2138
2139	} else if ( strcmp(k, "--jumbo-mtu") == 0 ) {
2140	_CKHAVEARGS(1);
2141	g_config->jumbo_mtu = atoi(argv[++i]);
2142
2143	} else if ( strcmp(k, "-G") == 0 ) {
2144	_CKHAVEARGS(1);
2145	sock_grp = argv[++i];
2146	} else if ( strcmp(k, "-U") == 0 ) {
2147	_CKHAVEARGS(1);
2148	sock_user = argv[++i];
2149
2150	} else if ( strcmp(k, "--no-listen") == 0 ) {
2151	#ifdef ROAR_SUPPORT_LISTEN
2152	sock_addr = "";
2153	g_terminate = 1;
2154	g_no_listen = 1;
2155	#endif
2156	} else if ( strcmp(k, "--client-fh") == 0 ) {
2157	_CKHAVEARGS(1);
2158	if ( clients_new_from_fh(atoi(argv[++i]), ROAR_PROTO_ROARAUDIO, ROAR_BYTEORDER_NETWORK, 1) == -1 ) {
2159	ROAR_ERR("main(*): Can not set client's fh");
2160	return 1;
2161	}
2162	} else if ( strcmp(k, "--close-fh") == 0 ) {
2163	_CKHAVEARGS(1);
2164	#ifdef ROAR_HAVE_IO_POSIX
2165	close(atoi(argv[++i]));
2166	#else
2167	i++;
2168	ROAR_WARN("can not close file handle %s (closing not supported)", argv[i]);
2169	#endif
2170
2171	} else if ( strcmp(k, "--standby") == 0 ) {
2172	g_standby = 1;
2173	} else if ( strcmp(k, "--auto-standby") == 0 ) {
2174	g_autostandby = 1;
2175	} else {
2176	usage();
2177	return 1;
2178	}
2179
2180	}
2181	#endif
2182
2183	#ifdef ROAR_HAVE_MAIN_ARGS
2184	switch (action) {
2185	case START:
2186	// NO-OP.
2187	break;
2188	case RESTART:
2189	// NO-OP, done before.
2190	break;
2191	case STOP:
2192	#ifdef ROAR_SUPPORT_LISTEN
2193	if ( restart_server(sock_addr, 0) == -1 ) {
2194	ROAR_WARN("Can not stop old server (not running at %s?)", sock_addr);
2195	return 1;
2196	}
2197	return 0;
2198	#else
2199	ROAR_ERR("--stop not supported");
2200	return 1;
2201	#endif
2202	break;
2203	case SHUTDOWN:
2204	#ifdef ROAR_SUPPORT_LISTEN
2205	if ( restart_server(sock_addr, 1) == -1 ) {
2206	ROAR_WARN("Can not terminate old server (not running at %s?)", sock_addr);
2207	return 1;
2208	}
2209	return 0;
2210	#else
2211	ROAR_ERR("--shutdown not supported");
2212	return 1;
2213	#endif
2214	break;
2215	case RESTART_RETRY:
2216	#ifdef ROAR_SUPPORT_LISTEN
2217	if ( restart_server(sock_addr, 1) == -1 ) {
2218	ROAR_WARN("Can not terminate old server (again) (not running at %s?), tring to continue anyway", sock_addr);
2219	action = RESTART;
2220	}
2221	#endif
2222	break;
2223	}
2224	#endif
2225
2226	#ifndef DEBUG
2227	// notify dbg if requested, if in DEBUG mode
2228	// do not able because it got enabled early.
2229	if ( g_verbose >= 4 )
2230	dbg_notify_cb_register();
2231	#endif
2232
2233	if ( af_mode != AF_MODE_NONE ) {
2234	if ( add_authfile(af_file, af_type, af_mode, af_acclev) == -1 ) {
2235	ROAR_ERR("main(*): adding authfile '%s' failed!", af_file);
2236	}
2237	}
2238
2239	#ifndef ROAR_WITHOUT_DCOMP_MIXER
2240	if ( m_drv != NULL ) {
2241	if ( hwmixer_add(m_drv, m_dev, m_opts, m_prim, m_count) == -1 ) {
2242	ROAR_ERR("main(*): adding mixer '%s' via '%s' failed!", m_dev, m_drv);
2243	}
2244	}
2245	#endif
2246
2247	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
2248	if ( s_dev != NULL ) {
2249	if ( sources_add(s_drv, s_dev, s_con, s_opt, s_prim) == -1 ) {
2250	ROAR_ERR("main(*): adding source '%s' via '%s' failed!", s_dev, s_drv);
2251	}
2252	}
2253	#endif
2254
2255	if ( output_add_default(o_drv, o_dev, o_opts, o_prim, o_count) == -1 ) {
2256	ROAR_ERR("Can not initialize default driver");
2257	return 1;
2258	}
2259
2260	ROAR_INFO("Server config: rate=%i, bits=%i, chans=%i", ROAR_DBG_INFO_NOTICE, sa.rate, sa.bits, sa.channels);
2261
2262	if ( waveform_init() == -1 ) {
2263	ROAR_ERR("Can not initialize Waveform subsystem");
2264	return 1;
2265	}
2266
2267	#ifndef ROAR_WITHOUT_DCOMP_MIDI
2268	if ( midi_init() == -1 ) {
2269	ROAR_ERR("Can not initialize MIDI subsystem");
2270	}
2271	#endif
2272
2273	#ifndef ROAR_WITHOUT_DCOMP_SSYNTH
2274	if ( ssynth_init() == -1 ) {
2275	ROAR_ERR("Can not initialize ssynth subsystem");
2276	}
2277	#endif
2278
2279	#ifndef ROAR_WITHOUT_DCOMP_LIGHT
2280	if ( light_init(light_channels) == -1 ) {
2281	ROAR_ERR("Can not initialize light control subsystem");
2282	}
2283	#endif
2284
2285	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
2286	if ( rdtcs_init() == -1 ) {
2287	ROAR_ERR("Can not initialize RDTCS subsystem");
2288	}
2289	#endif
2290
2291	if ( plugins_init() == -1 ) {
2292	ROAR_ERR("Can not initialize plugins");
2293	}
2294
2295	#ifdef ROAR_SUPPORT_LISTEN
2296	if ( !g_no_listen ) {
2297	if ( add_listen(sock_addr, port, sock_type, sock_user, sock_grp, sock_proto, sock_dir, &sock_info) != 0 ) {
2298	ROAR_ERR("Can not open listen socket!");
2299	return 1;
2300	}
2301	}
2302	#endif
2303
2304	if ( output_buffer_init(&sa) == -1 ) {
2305	ROAR_ERR("Can not init output buffer!");
2306	return 1;
2307	}
2308
2309	if ( samples_init() == -1 ) {
2310	ROAR_ERR("Can not init samples!");
2311	return 1;
2312	}
2313
2314
2315	// we should handle this on microcontrollers, too.
2316	#if !defined(ROAR_TARGET_MICROCONTROLLER) && !defined(ROAR_TARGET_WIN32)
2317	signal(SIGINT, on_sig_int);
2318	signal(SIGTERM, on_sig_term);
2319	signal(SIGCHLD, on_sig_chld);
2320	signal(SIGUSR1, on_sig_usr1);
2321	signal(SIGPIPE, SIG_IGN); // ignore broken pipes
2322	#endif
2323
2324	if ( g_config->memlock_level == -1 ) {
2325	g_config->memlock_level = MEMLOCK_DEFAULT;
2326	}
2327
2328	if ( memlock_set_level(g_config->memlock_level) == -1 ) {
2329	ROAR_WARN("Can not set memory locking level to target level.");
2330	}
2331
2332	if ( realtime ) {
2333	#ifdef DEBUG
2334	ROAR_WARN("compiled with -DDEBUG but realtime is enabled: for real realtime support compile without -DDEBUG");
2335	#endif
2336
2337	#ifdef ROAR_HAVE_NICE
2338	// this stupid error check is because type of returned data of nice() changed
2339	// too often. On some systems it may return 0/-1, on some new nice value or
2340	// mixed forms of both.
2341	errno = 0;
2342	(void)nice(-5*realtime); // -5 for each --realtime
2343	if ( errno ) {
2344	ROAR_WARN("Can not decrease nice value by %i: %s", 5*realtime, strerror(errno));
2345	}
2346	#else
2347	ROAR_WARN("Can not decrease nice value by %i: %s", 5*realtime, strerror(errno));
2348	#endif
2349	/*
2350	#ifdef __linux__
2351	if ( ioprio_set(IOPRIO_WHO_PROCESS, getpid(), IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 0)) == -1 )
2352	ROAR_WARN("Can not set io priority: %s", strerror(errno));
2353	#endif
2354	*/
2355	}
2356
2357	#if defined(ROAR_HAVE_SETGID) && defined(ROAR_HAVE_IO_POSIX)
2358	if ( setids & R_SETGID ) {
2359	if ( sock_grp == NULL ) {
2360	ROAR_ERR("Can not set GID if no groupname is supplied");
2361	return 1;
2362	}
2363	if ( (grp = getgrnam(sock_grp)) == NULL ) {
2364	ROAR_ERR("Can not get GID for group %s: %s", sock_grp, strerror(errno));
2365	return 1;
2366	}
2367	if ( setgroups(0, (const gid_t *) NULL) == -1 ) {
2368	ROAR_ERR("Can not clear supplementary group IDs: %s", strerror(errno));
2369	}
2370	if ( !grp \|\| setgid(grp->gr_gid) == -1 ) {
2371	ROAR_ERR("Can not set GroupID: %s", strerror(errno));
2372	}
2373	}
2374	#endif
2375
2376
2377	clients_set_pid(g_self_client, getpid());
2378	#ifdef ROAR_HAVE_GETUID
2379	clients_set_uid(g_self_client, getuid());
2380	#endif
2381	#ifdef ROAR_HAVE_GETGID
2382	clients_set_gid(g_self_client, getgid());
2383	#endif
2384	clients_get(g_self_client, &self);
2385
2386	if ( self == NULL ) {
2387	ROAR_ERR("Can not get self client!");
2388	return 1;
2389	}
2390
2391	strcpy(self->name, "RoarAudio daemon internal");
2392
2393	if ( roar_nnode_free(&(self->nnode)) == -1 )
2394	return 1;
2395
2396	// not fully correct but ok as workaorund
2397	// so tools assume that roard runs on the same machine as
2398	// they in case they use AF_UNIX:
2399	if ( roar_nnode_new(&(self->nnode), ROAR_SOCKET_TYPE_UNIX) == -1 )
2400	return 1;
2401
2402	#ifdef ROAR_HAVE_FORK
2403	if ( daemon ) {
2404	#ifdef ROAR_HAVE_SYSLOG
2405	roar_debug_set_stderr_mode(ROAR_DEBUG_MODE_SYSLOG);
2406	#else
2407	roar_debug_set_stderr_fh(-1);
2408	#endif
2409
2410	close(ROAR_STDIN );
2411	close(ROAR_STDOUT);
2412	close(ROAR_STDERR);
2413
2414	if ( fork() )
2415	ROAR_U_EXIT(0);
2416
2417	#ifdef ROAR_HAVE_SETSID
2418	setsid();
2419	#endif
2420	clients_set_pid(g_self_client, getpid()); // reset pid as it changed
2421	}
2422	#endif
2423
2424	#if defined(ROAR_HAVE_SETUID) && defined(ROAR_HAVE_IO_POSIX)
2425	// early test for UID as we need this for the pidfile and the setuid()
2426	if ( sock_user != NULL ) {
2427	if ( (pwd = getpwnam(sock_user)) == NULL ) {
2428	ROAR_ERR("Can not get UID for user %s: %s", sock_user, strerror(errno));
2429	return 1;
2430	}
2431	}
2432	#endif
2433
2434	ROAR_INFO("Process ID: %i", ROAR_DBG_INFO_INFO, (int)getpid());
2435
2436	#ifdef SUPPORT_PIDFILE
2437	if ( pidfile != NULL ) {
2438	if ( roar_vio_open_file(&pidfile_vio, pidfile, O_WRONLY\|O_CREAT, 0644) == -1 ) {
2439	ROAR_ERR("Can not write pidfile: %s", pidfile);
2440	} else {
2441	roar_vio_printf(&pidfile_vio, "%i\n", getpid());
2442	roar_vio_close(&pidfile_vio);
2443	}
2444	#if defined(ROAR_HAVE_SETGID) && defined(ROAR_HAVE_SETUID) && defined(ROAR_HAVE_IO_POSIX)
2445	if ( pwd \|\| grp ) {
2446	if ( chown(pidfile, pwd ? pwd->pw_uid : -1, grp ? grp->gr_gid : -1) == -1 ) {
2447	ROAR_WARN("Can not change ownership of pidfile: %s: %s", pidfile, strerror(errno));
2448	}
2449	}
2450	if ( chmod(pidfile, S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IROTH) == -1 ) {
2451	ROAR_WARN("Can not change permissions of pidfile: %s: %s", pidfile, strerror(errno));
2452	}
2453	#endif
2454	}
2455	#endif
2456
2457	#ifdef ROAR_HAVE_CHROOT
2458	if (chrootdir) {
2459	if ( chroot(chrootdir) == -1 ) {
2460	ROAR_ERR("Can not chroot to %s: %s", chrootdir, strerror(errno));
2461	return 2;
2462	}
2463	if ( chdir("/") == -1 ) {
2464	ROAR_ERR("Can not chdir to /: %s", strerror(errno));
2465	return 2;
2466	}
2467	}
2468	#endif
2469
2470	#if defined(ROAR_HAVE_SETUID) && defined(ROAR_HAVE_IO_POSIX)
2471	if ( setids & R_SETUID ) {
2472	if ( sock_user == NULL ) {
2473	ROAR_ERR("Can not set UID if no username is supplied");
2474	return 1;
2475	}
2476	if ( !pwd \|\| setuid(pwd->pw_uid) == -1 ) {
2477	ROAR_ERR("Can not set UserID: %s", strerror(errno));
2478	return 3;
2479	}
2480	#ifdef ROAR_HAVE_GETUID
2481	clients_set_uid(g_self_client, getuid());
2482	#endif
2483	}
2484	#endif
2485
2486	// setup auth:
2487	#if defined(ROAR_HAVE_GETUID) && defined(ROAR_HAVE_GETGID)
2488	if ( auth_setup(none_acclev, trust_acclev, trust_root, getuid(), getgid()) == -1 ) {
2489	#else
2490	if ( auth_setup(none_acclev, trust_acclev, trust_root, -1, -1) == -1 ) {
2491	#endif
2492	ROAR_ERR("Can not set up auth. Bad.");
2493	alive = 0;
2494	}
2495
2496	// Register with OpenSLP:
2497	#ifdef ROAR_HAVE_LIBSLP
2498	if ( reg_slp ) {
2499	register_slp(0, sock_addr);
2500	}
2501	#endif
2502
2503	#ifdef ROAR_HAVE_LIBX11
2504	if ( reg_x11 ) {
2505	register_x11(0, sock_addr);
2506	}
2507	#endif
2508
2509	// update sync counter.
2510	streams_change_sync_num(-1, 0);
2511
2512	ROAR_INFO("Startup complet", ROAR_DBG_INFO_INFO);
2513
2514	// start main loop...
2515	ROAR_INFO("Entering main loop", ROAR_DBG_INFO_INFO);
2516	main_loop(&sa, sysclocksync);
2517	ROAR_INFO("Left main loop", ROAR_DBG_INFO_INFO);
2518
2519	// clean up.
2520	clean_quit_prep();
2521	output_buffer_free();
2522
2523	roar_notify_core_free(NULL);
2524
2525	ROAR_INFO("Shuting down complete", ROAR_DBG_INFO_INFO);
2526
2527	if ( g_config->scripts.post_shutdown != NULL )
2528	system(g_config->scripts.post_shutdown);
2529
2530	ROAR_INFO("Exiting, no error", ROAR_DBG_INFO_INFO);
2531	return 0;
2532	}
2533
2534	void cleanup_listen_socket (int terminate) {
2535	int i;
2536
2537	ROAR_DBG("cleanup_listen_socket(terminate=%i) = (void)?", terminate);
2538
2539	ROAR_INFO("Cleaning up listen sockets", ROAR_DBG_INFO_INFO);
2540
2541	// Deregister from SLP:
2542	#ifdef ROAR_HAVE_LIBSLP
2543	register_slp(1, NULL);
2544	#endif
2545
2546	#ifdef ROAR_HAVE_LIBX11
2547	register_x11(1, NULL);
2548	#endif
2549
2550	#ifdef ROAR_SUPPORT_LISTEN
2551	for (i = 0; i < ROAR_MAX_LISTEN_SOCKETS; i++) {
2552	if ( g_listen[i].used ) {
2553	roar_vio_close(&(g_listen[i].sock));
2554
2555	g_listen[i].used = 0;
2556
2557	#ifdef ROAR_HAVE_UNIX
2558	if ( server[i] != NULL )
2559	if ( *(server[i]) == '/' )
2560	unlink(server[i]);
2561	#endif
2562	}
2563	}
2564
2565	#endif
2566
2567	if ( terminate )
2568	g_terminate = 1;
2569	}
2570
2571	void clean_quit_prep (void) {
2572	cleanup_listen_socket(0);
2573
2574	plugins_free();
2575
2576	#ifndef ROAR_WITHOUT_DCOMP_SOURCES
2577	sources_free();
2578	#endif
2579	streams_free();
2580	clients_free();
2581	#ifndef ROAR_WITHOUT_DCOMP_SSYNTH
2582	ssynth_free();
2583	#endif
2584	#ifndef ROAR_WITHOUT_DCOMP_CB
2585	midi_cb_stop(); // stop console beep
2586	#endif
2587	#ifndef ROAR_WITHOUT_DCOMP_MIDI
2588	midi_free();
2589	#endif
2590	#ifndef ROAR_WITHOUT_DCOMP_LIGHT
2591	light_free();
2592	#endif
2593	#ifndef ROAR_WITHOUT_DCOMP_RDTCS
2594	rdtcs_free();
2595	#endif
2596
2597	waveform_free();
2598
2599	#ifdef SUPPORT_PIDFILE
2600	if ( pidfile != NULL )
2601	unlink(pidfile);
2602	#endif
2603
2604	auth_free();
2605	}
2606
2607	void clean_quit (void) {
2608	ROAR_INFO("Shuting down", ROAR_DBG_INFO_INFO);
2609
2610	counters_print(ROAR_DEBUG_TYPE_INFO, 0);
2611
2612	clean_quit_prep();
2613	// output_buffer_free();
2614
2615	roar_notify_core_free(NULL);
2616
2617	ROAR_INFO("Shuting down complete", ROAR_DBG_INFO_INFO);
2618
2619	if ( g_config->scripts.post_shutdown != NULL )
2620	system(g_config->scripts.post_shutdown);
2621
2622	ROAR_INFO("Exiting, no error", ROAR_DBG_INFO_INFO);
2623	exit(0);
2624	}
2625
2626	//ll

Note: See TracBrowser for help on using the repository browser.

Download in other formats: