Context Navigation

source: roaraudio/roard/roard.c @ 4955:5a13f6cdde6e

Visit:

Last change on this file since 4955:5a13f6cdde6e was 4955:5a13f6cdde6e, checked in by phi, 13 years ago
patch to add support to list drivers in diffrent formats
File size: 74.4 KB

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

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

Download in other formats: