Context Navigation

source: roaraudio/roard/roard.c @ 5160:efd742a8d396

Visit:

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

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

Download in other formats: