static void openlogfile()
{
const char *dir="/var/log/udprx/raw/";
char timestr[80];
char filename[80];
int ret;
time_t t;
struct tm tmp;
//filename is YYYY:DD:MM:HH
t = time(NULL);
gmtime_r(&t, &tmp);
strftime(timestr, 80, "%Y/%m/%F-%H", &tmp);
//combine directory and filename
snprintf(filename, 80, "%s%s", dir, timestr);
//create directory
ret=mkpath(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if(ret<0) daemon_log(LOG_ERR, "mkpath failed: %s", strerror(errno));
//open file
logfd=open(filename,
O_CREAT | O_APPEND | O_WRONLY,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if(logfd<0) daemon_log(LOG_ERR, "open failed: %s", strerror(errno));
}
int daemon_signal_install(int s){
sigset_t ss;
struct sigaction sa;
if (_init() < 0)
return -1;
if (sigemptyset(&ss) < 0) {
daemon_log(LOG_ERR, "sigemptyset(): %s", strerror(errno));
return -1;
}
if (sigaddset(&ss, s) < 0) {
daemon_log(LOG_ERR, "sigaddset(): %s", strerror(errno));
return -1;
}
if (sigprocmask(SIG_UNBLOCK, &ss, NULL) < 0) {
daemon_log(LOG_ERR, "sigprocmask(): %s", strerror(errno));
return -1;
}
memset(&sa, 0, sizeof(sa));
sa.sa_handler = _sigfunc;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(s, &sa, NULL) < 0) {
daemon_log(LOG_ERR, "sigaction(%s, ...) failed: %s", strsignal(s), strerror(errno));
return -1;
}
return 0;
}
int welcome_iface(int fd, char *iface) {
struct ifreq ifr;
struct ethtool_drvinfo drvinfo;
char txt[256];
if (interface_auto_up)
interface_up(fd, iface);
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, sizeof(ifr.ifr_name)-1);
if (ioctl(fd, SIOCGIFHWADDR, &ifr) == -1)
snprintf(txt, sizeof(txt)-1, "Using interface %s", iface);
else
snprintf(txt, sizeof(txt)-1, "Using interface %s/%02X:%02X:%02X:%02X:%02X:%02X", iface, ifr.ifr_hwaddr.sa_data[0] & 0xFF, ifr.ifr_hwaddr.sa_data[1] & 0xFF, ifr.ifr_hwaddr.sa_data[2] & 0xFF, ifr.ifr_hwaddr.sa_data[3] & 0xFF, ifr.ifr_hwaddr.sa_data[4] & 0xFF, ifr.ifr_hwaddr.sa_data[5] & 0xFF);
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, sizeof(ifr.ifr_name)-1);
drvinfo.cmd = ETHTOOL_GDRVINFO;
ifr.ifr_data = (caddr_t) &drvinfo;
if (ioctl(fd, SIOCETHTOOL, &ifr) != -1)
daemon_log(LOG_INFO, "%s with driver <%s> (version: %s)", txt, drvinfo.driver, drvinfo.version);
else
daemon_log(LOG_INFO, "%s", txt);
cached_detect_beat_func = NULL;
return 0;
}
// 0: high, 1: low, 2: very low
void beep(int b) {
int fd = -1, argp;
if (!use_beep)
return;
if ((fd = open("/dev/tty1", O_WRONLY|O_NOCTTY)) < 0) {
use_beep = 0;
daemon_log(LOG_WARNING, "Could not open /dev/tty, cannot beep.");
goto finish;
}
switch (b) {
case 0: argp = (100<<16) + 0x637; break;
case 1: argp = (100<<16) + 0x937; break;
default: argp = (100<<16) + 0x1237; break;
}
if (ioctl(fd, KDMKTONE, argp) != 0) {
use_beep = 0;
daemon_log(LOG_WARNING, "Beep failure, disabled.");
goto finish;
}
usleep((argp >> 16)*1000);
finish:
if (fd >= 0)
close(fd);
return;
}
interface_status_t detect_beat_auto(int fd, char *iface) {
interface_status_t status;
if (cached_detect_beat_func && (status = cached_detect_beat_func(fd, iface)) != IFSTATUS_ERR)
return status;
if ((status = interface_detect_beat_ethtool(fd, iface)) != IFSTATUS_ERR) {
cached_detect_beat_func = interface_detect_beat_ethtool;
daemon_log(LOG_INFO, "Using detection mode: SIOCETHTOOL");
return status;
}
if ((status = interface_detect_beat_mii(fd, iface)) != IFSTATUS_ERR) {
cached_detect_beat_func = interface_detect_beat_mii;
daemon_log(LOG_INFO, "Using detection mode: SIOCGMIIPHY");
return status;
}
if ((status = interface_detect_beat_wlan(fd, iface)) != IFSTATUS_ERR) {
cached_detect_beat_func = interface_detect_beat_wlan;
daemon_log(LOG_INFO, "Using detection mode: wireless extension");
return status;
}
if ((status = interface_detect_beat_iff(fd, iface)) != IFSTATUS_ERR) {
cached_detect_beat_func = interface_detect_beat_iff;
daemon_log(LOG_INFO, "Using detection mode: IFF_RUNNING");
return status;
}
return IFSTATUS_ERR;
}
/* handle link coming or going away */
static int
rtm_dispatch_ifannounce(struct rtm_dispinfo *di)
{
rtmunion_t *rtm = (void *)di->di_buf;
assert(rtm->rtm.rtm_type == RTM_IFANNOUNCE);
daemon_log(LOG_DEBUG, "%s: IFANNOUNCE for ifindex %d",
__func__, rtm->ifan.ifan_index);
switch (rtm->ifan.ifan_what) {
case IFAN_ARRIVAL:
if (rtm->ifan.ifan_index == ifindex) {
daemon_log(LOG_ERR,
"RTM_IFANNOUNCE IFAN_ARRIVAL, for ifindex %d, which we already manage.",
ifindex);
return (-1);
}
break;
case IFAN_DEPARTURE:
if (rtm->ifan.ifan_index == ifindex) {
daemon_log(LOG_ERR, "Interface vanished.");
return (-1);
}
break;
default:
/* ignore */
break;
}
return (0);
}
teSerial_Status eSerial_WriteBuffer(unsigned char *data, uint32_t count)
{
int attempts = 0;
//printf("send char %d\n", data);
int total_sent_bytes = 0, sent_bytes = 0;
while (total_sent_bytes < count)
{
sent_bytes = write(serial_fd, &data[total_sent_bytes], count - total_sent_bytes);
if (sent_bytes <= 0)
{
if (errno == EAGAIN)
{
if (++attempts >= 5)
{
daemon_log(LOG_ERR, "Error writing to module(%s)", strerror(errno));
return E_SERIAL_ERROR;
}
usleep(1000);
}
else
{
daemon_log(LOG_ERR, "Error writing to module(%s)", strerror(errno));
return -1;
}
}
else
{
attempts = 0;
total_sent_bytes += sent_bytes;
}
}
return E_SERIAL_OK;
}
static int open_socket(void) {
int fd = -1;
struct sockaddr_un sa;
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
daemon_log(LOG_ERR, "socket(): %s", strerror(errno));
goto fail;
}
if (set_cloexec(fd) < 0) {
daemon_log(LOG_ERR, "fcntl(): %s", strerror(errno));
goto fail;
}
memset(&sa, 0, sizeof(sa));
sa.sun_family = AF_UNIX;
strncpy(sa.sun_path, AVAHI_SOCKET, sizeof(sa.sun_path)-1);
sa.sun_path[sizeof(sa.sun_path)-1] = 0;
if (connect(fd, (struct sockaddr*) &sa, sizeof(sa)) < 0) {
daemon_log(LOG_ERR, "connect(): %s", strerror(errno));
daemon_log(LOG_INFO, "Failed to connect to the daemon. This probably means that you");
daemon_log(LOG_INFO, "didn't start avahi-daemon before avahi-dnsconfd.");
goto fail;
}
return fd;
fail:
if (fd >= 0)
close(fd);
return -1;
}
int main(int argc, char* argv[]) {
daemon_pid_file_proc = pid_file_proc;
if ((daemon_log_ident = strrchr(argv[0], '/')))
daemon_log_ident++;
else
daemon_log_ident = argv[0];
parse_args(argc, argv);
if (geteuid() != 0) {
daemon_log(LOG_ERR, "Sorry, you need to be root to run this binary.");
return 2;
}
if (daemon_pid_file_is_running() >= 0) {
daemon_log(LOG_ERR, "Sorry, there is already an instance of ifplugd for %s running.", interface);
return 4;
}
if (daemonize) {
pid_t pid;
if (wait_on_fork)
if (daemon_retval_init() < 0) {
daemon_log(LOG_ERR, "Sorry, could not create pipe: %s", strerror(errno));
return 4;
}
if ((pid = daemon_fork()) < 0)
return 3;
if (pid) {
int c = 0;
// Parent process
if (wait_on_fork)
if ((c = daemon_retval_wait(60)) < 0) {
daemon_log(LOG_WARNING, "Killing background process.");
kill(pid, SIGTERM);
}
if (c > 3)
daemon_log(LOG_ERR, "Daemon failed with error condition #%i. See syslog for details", c);
return c;
}
}
// Let's go
work();
return 0;
}
int IPv4_TCP(const char *pcListen_address, const int iPort)
{
int listen_socket = 0;
listen_socket = Network_Listen4TCP(pcListen_address, iPort);
if (listen_socket < 0)
{
daemon_log(LOG_ERR, "Failed to bind");
return -1;
}
daemon_log(LOG_INFO, "Waiting for TCP connections");
while (1)
{
tsTCPThreadInfo *psTCPThreadInfo;
int iClient_fd;
struct sockaddr_in sClientIPv4Address;
socklen_t Addr_size = sizeof(struct sockaddr);
iClient_fd = accept(listen_socket, (struct sockaddr *)&sClientIPv4Address, &Addr_size);
{
char buffer[INET6_ADDRSTRLEN] = "Could not determine address\n";
inet_ntop(AF_INET, &sClientIPv4Address.sin_addr, buffer, INET6_ADDRSTRLEN);
if (verbosity > 0)
{
daemon_log(LOG_INFO, "Got TCP client from %s:%d", buffer, ntohs(sClientIPv4Address.sin_port));
}
}
psTCPThreadInfo = malloc(sizeof(tsTCPThreadInfo));
if (!psTCPThreadInfo)
{
daemon_log(LOG_ERR, "Error creating thread (out of memory)");
close(iClient_fd);
continue;
}
memset(psTCPThreadInfo, 0, sizeof(tsTCPThreadInfo));
psTCPThreadInfo->iClientSocket = iClient_fd;
psTCPThreadInfo->sClientIPv4Address = sClientIPv4Address;
if (pthread_create(&psTCPThreadInfo->sThreadInfo, NULL, TCP_Client_Thread, psTCPThreadInfo) != 0)
{
daemon_log(LOG_ERR, "Error starting TCP thread (%s)", strerror(errno));
free(psTCPThreadInfo);
close(iClient_fd);
continue;
}
}
return 0;
}
int Get_Module_Address(struct in6_addr *psAddress)
{
glob_t sResults;
if (glob("/tmp/6LoWPANd.*", 0, NULL, &sResults) == 0)
{
//printf("6LoWPANd files: %d\n", sResults.gl_pathc);
if (sResults.gl_pathc > 0)
{
FILE * f;
char *pcAddress = malloc(INET6_ADDRSTRLEN + 2);
int iAddressLength = INET6_ADDRSTRLEN + 2;
//printf("Opening file: %s\n", sResults.gl_pathv[0]);
f = fopen (sResults.gl_pathv[0], "r");
if (f == NULL)
{
daemon_log(LOG_ERR, "Error reading Module address: fopen (%s)", strerror(errno));
free(pcAddress);
return -2;
}
if (getline (&pcAddress, &iAddressLength, f) < 0)
{
daemon_log(LOG_ERR, "Error reading Module address: getline (%s)", strerror(errno));
fclose(f);
free(pcAddress);
return -2;
}
/* Strip off unwanted characters */
pcAddress[strcspn(pcAddress, " \t\n\r")] = '\0';
if (inet_pton(AF_INET6, pcAddress, psAddress) <= 0)
{
daemon_log(LOG_ERR, "Error converting string to address (%s)", strerror(errno));;
fclose(f);
free(pcAddress);
return -1;
}
fclose(f);
free(pcAddress);
}
globfree(&sResults);
return 0;
}
return -1;
}
int audio_init(context_t *context) {
int rc = 0;
static const pa_sample_spec ss = {
.format = PA_SAMPLE_S16LE,
.rate = 44100,
.channels = 1
};
int error;
daemon_log(LOG_INFO,
"Opening %s for input",
context->input_device ?: "default source");
context->pa_input = pa_simple_new(NULL,
"shusherd",
PA_STREAM_RECORD,
context->input_device,
"record",
&ss,
NULL,
NULL,
&error);
if (!context->pa_input) {
daemon_log(LOG_ERR, "pa_simple_new failed: %s", pa_strerror(error));
assert(context->pa_input);
}
context->ebur128_state = ebur128_init(ss.channels, ss.rate, EBUR128_MODE_S);
assert(context->ebur128_state);
context->enable_processing = 1;
rc = pthread_create(&context->audio_thread, NULL, audio_loop, (void *)context);
if (rc) {
daemon_log(LOG_ERR, "Unable to create audio thread: %d", rc);
goto cleanup_ebur128_state;
}
return 0;
cleanup_ebur128_state:
ebur128_destroy(&context->ebur128_state);
return rc;
}
void audio_destroy(context_t *context) {
context->enable_processing = 0;
pthread_join(context->audio_thread, NULL);
ebur128_destroy(&context->ebur128_state);
pa_simple_free(context->pa_input);
}
int iface_get_initial_state(State *state) {
struct nlmsghdr *n;
struct ifinfomsg *ifi;
struct ifaddrmsg *ifa;
uint8_t req[1024];
int seq = 0;
assert(fd >= 0);
assert(state);
memset(&req, 0, sizeof(req));
n = (struct nlmsghdr*) req;
n->nlmsg_len = NLMSG_LENGTH(sizeof(*ifi));
n->nlmsg_type = RTM_GETLINK;
n->nlmsg_seq = seq;
n->nlmsg_flags = NLM_F_MATCH|NLM_F_REQUEST|NLM_F_ACK;
n->nlmsg_pid = 0;
ifi = NLMSG_DATA(n);
ifi->ifi_family = AF_UNSPEC;
ifi->ifi_change = -1;
if (send(fd, n, n->nlmsg_len, 0) < 0) {
daemon_log(LOG_ERR, "send(): %s", strerror(errno));
return -1;
}
if (process_response(1, 0) < 0)
return -1;
n->nlmsg_type = RTM_GETADDR;
n->nlmsg_len = NLMSG_LENGTH(sizeof(*ifa));
n->nlmsg_seq = ++seq;
ifa = NLMSG_DATA(n);
ifa->ifa_family = AF_INET;
ifa->ifa_index = ifindex;
if (send(fd, n, n->nlmsg_len, 0) < 0) {
daemon_log(LOG_ERR, "send(): %s", strerror(errno));
return -1;
}
if (process_response(1, seq) < 0)
return -1;
*state = addresses ? STATE_SLEEPING : STATE_START;
return 0;
}
bool
start()
{
#ifdef HAVE_LIBDAEMON
pid_t pid;
// Check that the daemon is not run twice a the same time
if ((pid = daemon_pid_file_is_running()) >= 0) {
daemon_log(LOG_ERR, "Daemon already running on (PID %u)", pid);
throw Exception("Daemon already running on (PID %u)", pid);
}
pid = daemonize();
if ( pid < 0 ) {
cleanup();
throw Exception("Failed to daemonize");
} else if (pid) {
// parent
return true;
} else {
// child
return false;
}
#else
throw Exception("Daemonizing support is not available.\n"
"(libdaemon[-devel] was not available at compile time)\n");
#endif
}
int op_clear(const AvahiNatpmdIPCReq *req) {
assert(req);
assert(mapping_script);
daemon_log(LOG_DEBUG, "%s", __FUNCTION__);
/* XXX: Use daemon_exec()? */
execl( mapping_script,
mapping_script,
"CLEAR",
NULL);
daemon_log(LOG_ERR, "%s: execl() failed: %s", __FUNCTION__, strerror(errno));
return 1;
}
/* Send a key combo event, either press or release */
void uinput_key_press(struct btnx_event *bev)
{
struct input_event event;
int fd;
if (uinput_mouse_fd < 0 || uinput_kbd_fd < 0)
{
daemon_log(LOG_WARNING, OUT_PRE "Warning: uinput_fd not valid");
return;
}
if ((bev->keycode <= KEY_UNKNOWN || bev->keycode >= KEY_OK) && bev->keycode < BTNX_EXTRA_EVENTS)
fd = uinput_kbd_fd;
else
fd = uinput_mouse_fd;
gettimeofday(&event.time, NULL);
/* If button is pressed, send modifiers first and then the main key.
* If button is released, release main key first and then the modifiers. */
if (bev->pressed) {
uinput_send_mods(bev, event);
uinput_send_key(bev, event, fd);
}
else {
uinput_send_key(bev, event, fd);
uinput_send_mods(bev, event);
}
}
static int Network_Listen4UDP(const char *pcAddress, int iPort)
{
struct addrinfo hints, *res;
int s;
char acPort[10];
snprintf(acPort, 10, "%d", iPort);
// first, load up address structs with getaddrinfo():
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE; // fill in my IP for me
hints.ai_protocol = 0; /* Any protocol */
hints.ai_canonname = NULL;
hints.ai_addr = NULL;
hints.ai_next = NULL;
s = getaddrinfo(NULL, acPort, &hints, &res);
if (s != 0)
{
daemon_log(LOG_ERR, "Error in getaddrinfo: %s", gai_strerror(s));
exit(EXIT_FAILURE);
}
s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
bind(s, res->ai_addr, sizeof(struct sockaddr_in));
freeaddrinfo(res);
return s;
}
static int handle_incoming_ipv6_packet(int send_socket, tsConectionMapping *psMapping)
{
ssize_t iBytesRecieved;
struct sockaddr_in6 IPv6Address;
unsigned int AddressSize = sizeof(struct sockaddr_in6);
const uint32_t u32HeaderSize = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(struct in6_addr);
#define PACKET_BUFFER_SIZE (4096 + u32HeaderSize)
char buffer[PACKET_BUFFER_SIZE];
iBytesRecieved = recvfrom(psMapping->iIPv6Socket, &buffer[u32HeaderSize], PACKET_BUFFER_SIZE, 0,
(struct sockaddr*)&IPv6Address, &AddressSize);
if (iBytesRecieved > 0)
{
{
char buffer[INET6_ADDRSTRLEN] = "Could not determine address\n";
inet_ntop(AF_INET, &psMapping->sIPv4Address.sin_addr, buffer, INET6_ADDRSTRLEN);
if (verbosity >= LOG_DEBUG)
{
daemon_log(LOG_DEBUG, "Data to client %s:%d: %d bytes", buffer, ntohs(psMapping->sIPv4Address.sin_port), iBytesRecieved);
}
}
/* Update last packet time */
gettimeofday(&psMapping->sLastPacketTime, NULL);
{
int iBytesSent;
uint16_t u16PacketLength;
u16PacketLength = htons(iBytesRecieved + sizeof(struct in6_addr));
buffer[0] = 1; /* JIPv4 header version */
memcpy(&buffer[1], &u16PacketLength, sizeof(uint16_t));
memcpy(&buffer[3], &IPv6Address.sin6_addr, sizeof(struct in6_addr));
iBytesSent = sendto(send_socket, buffer, iBytesRecieved + u32HeaderSize, 0,
(struct sockaddr*)&psMapping->sIPv4Address, sizeof(struct sockaddr_in));
}
}
else
{
daemon_log(LOG_DEBUG, "Received a weird number of bytes %d", iBytesRecieved);
}
#undef PACKET_BUFFER_SIZE
return 0;
}
void daemon_logv(int prio, const char *fmt, va_list ap) {
char *str;
if (vasprintf(&str, fmt, ap) == -1)
return;
daemon_log(prio, str);
free(str);
}
static void sig_shutdown(int foo, siginfo_t *bar, void *baz) {
debug(1, "shutdown requested...");
shairport_shutdown();
daemon_log(LOG_NOTICE, "exit...");
daemon_retval_send(255);
daemon_pid_file_remove();
exit(0);
}
int main(int argc, char* argv[]) {
daemon_pid_file_proc = pid_file_proc;
if ((daemon_log_ident = strrchr(argv[0], '/')))
daemon_log_ident++;
else
daemon_log_ident = argv[0];
parse_args(argc, argv);
/*
if (geteuid() != 0) {
daemon_log(LOG_ERR, "Sorry, you need to be root to run this binary.");
return 2;
}
*/
if (daemon_pid_file_is_running() >= 0) {
daemon_log(LOG_ERR, "Sorry, there is already an instance of ifplugd running.");
return 4;
}
if (daemonize) {
pid_t pid;
if ((pid = daemon_fork()) < 0)
return 3;
if (pid) {
int c = 0;
// Parent process
if (c > 3)
daemon_log(LOG_ERR, "Daemon failed with error condition #%i. See syslog for details", c);
return c;
}
}
// Let's go
work();
daemon_log(LOG_ERR, "stop");
return 0;
}
void daemon_set_verbosity(int verbosity_prio) {
/* Allow using negative verbosity levels to hide _all_ messages */
if (verbosity_prio > 0 && (verbosity_prio & LOG_PRIMASK) != LOG_PRIMASK)
daemon_log(LOG_ERR, "The value %d is not a valid priority value", verbosity_prio);
daemon_verbosity_level = verbosity_prio & LOG_PRIMASK;
}
/** Function to be called when the network configuration has been changed.
* This is actually run in a separate pthread, so that a blocking program
* can't interrupt communications with the module
*/
void *ConfigChangedCallback(void *arg)
{
char acCommand[1024];
char acAddress[INET6_ADDRSTRLEN];
struct in6_addr sin6_addr;
int result;
memset(&sin6_addr, 0, sizeof(struct in6_addr));
sin6_addr.s6_addr[0] = (u64NetworkPrefix >> 56) & 0xFF;
sin6_addr.s6_addr[1] = (u64NetworkPrefix >> 48) & 0xFF;
sin6_addr.s6_addr[2] = (u64NetworkPrefix >> 40) & 0xFF;
sin6_addr.s6_addr[3] = (u64NetworkPrefix >> 32) & 0xFF;
sin6_addr.s6_addr[4] = (u64NetworkPrefix >> 24) & 0xFF;
sin6_addr.s6_addr[5] = (u64NetworkPrefix >> 16) & 0xFF;
sin6_addr.s6_addr[6] = (u64NetworkPrefix >> 8) & 0xFF;
sin6_addr.s6_addr[7] = (u64NetworkPrefix >> 0) & 0xFF;
inet_ntop(AF_INET6, &sin6_addr, acAddress, INET6_ADDRSTRLEN);
result = sprintf(acCommand, "%s --channel=%d --pan=0x%04x --network=0x%08x --prefix=%s",
pcConfigProgram, eChannel, u16PanID, u32UserData, acAddress);
if (iSecureNetwork)
{
char buffer[INET6_ADDRSTRLEN] = "Could not determine address\n";
inet_ntop(AF_INET6, &sSecurityKey, buffer, INET6_ADDRSTRLEN);
sprintf(&acCommand[result], " --key=%s", buffer);
}
daemon_log(LOG_DEBUG, "Running configuration notification:\n%s", acCommand);
result = system(acCommand);
if (result == 0)
{
daemon_log(LOG_INFO, "Configuration notification program run successfully");
}
else
{
daemon_log(LOG_ERR, "Configuration notification program result: %d\n", result);
}
return NULL;
}
void warn(char *format, ...) {
char s[1024];
s[0] = 0;
va_list args;
va_start(args, format);
vsprintf(s, format, args);
va_end(args);
daemon_log(LOG_WARNING, "%s", s);
}
void inform(char *format, ...) {
char s[1024];
s[0] = 0;
va_list args;
va_start(args, format);
vsprintf(s, format, args);
va_end(args);
daemon_log(LOG_INFO, "%s", s);
}
/**
* Returns 0 on success or 1 on failure.
* The return value is intended to be used as the child process' return value.
*/
int op_add_remove(const AvahiNatpmdIPCReq *req) {
char str_priv[6], str_pub[6];
struct in_addr saddr;
assert(req);
assert(mapping_script);
daemon_log(LOG_DEBUG, "%s: req->op = %d, req->proto = %d",
__FUNCTION__, req->op, req->proto);
assert(req->op == IPCREQ_OP_ADD || req->op == IPCREQ_OP_REMOVE);
assert(req->proto == IPCREQ_PROTO_TCP || req->proto == IPCREQ_PROTO_UDP);
saddr.s_addr = req->dest_addr;
if (snprintf(str_priv, sizeof(str_priv), "%hu", req->dest_port) >= (ssize_t)sizeof(str_priv))
return 1;
if (snprintf(str_pub, sizeof(str_pub), "%hu", req->pub_port) >= (ssize_t)sizeof(str_pub))
return 1;
daemon_log(LOG_DEBUG, "%s: Executing %s %s %s %s %s %s",
__FUNCTION__,
mapping_script,
req->op == IPCREQ_OP_ADD ? "ADD" : "REMOVE",
req->proto == IPCREQ_PROTO_TCP ? "TCP" : "UDP",
str_pub,
ip4_addr_str(saddr),
str_priv);
/* XXX: Use daemon_exec()? */
execl( mapping_script,
mapping_script,
req->op == IPCREQ_OP_ADD ? "ADD" : "REMOVE",
req->proto == IPCREQ_PROTO_TCP ? "TCP" : "UDP",
str_pub,
ip4_addr_str(saddr),
str_priv,
NULL);
daemon_log(LOG_ERR, "%s: execl() failed: %s", __FUNCTION__, strerror(errno));
return 1;
}
int daemon_signal_next(void) {
int s;
ssize_t r;
if ((r = read(_signal_pipe[0], &s, sizeof(s))) == sizeof(s))
return s;
if (r < 0) {
if (errno == EAGAIN)
return 0;
else {
daemon_log(LOG_ERR, "read(signal_pipe[0], ...): %s", strerror(errno));
return -1;
}
}
daemon_log(LOG_ERR, "Short read() on signal pipe.");
return -1;
}
void daemon_logf(log_state *s, int type, const char *fmt, ...) {
char *buf;
va_list ap;
va_start(ap, fmt);
if (dm_vasprintf(&buf, fmt, ap) >= 0) {
daemon_log(s, type, buf);
dm_free(buf);
} /* else return_0 */
va_end(ap);
}
void die(char *format, ...) {
char s[1024];
s[0] = 0;
va_list args;
va_start(args, format);
vsprintf(s, format, args);
va_end(args);
daemon_log(LOG_EMERG, "%s", s);
shairport_shutdown();
exit(1);
}
void debug(int level, char *format, ...) {
if (level > debuglev)
return;
char s[1024];
s[0] = 0;
va_list args;
va_start(args, format);
vsprintf(s, format, args);
va_end(args);
daemon_log(LOG_DEBUG, "%s", s);
}
