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); }