Camera::Camera(Sector* newsector, std::string name) :
mode(NORMAL),
translation(),
sector(newsector),
lookahead_mode(LOOKAHEAD_NONE),
changetime(),
lookahead_pos(),
peek_pos(),
cached_translation(),
autoscroll_path(),
autoscroll_walker(),
shaketimer(),
shakespeed(),
shakedepth_x(),
shakedepth_y(),
scroll_from(),
scroll_goal(),
scroll_to_pos(),
scrollspeed(),
config()
{
this->name = name;
config = new CameraConfig();
reload_config();
}
HangulFactory::HangulFactory (const ConfigPointer &config)
{
m_uuid = "d75857a5-4148-4745-89e2-1da7ddaf70a9";
m_name = _("Korean");
m_config = config;
m_keyboard_layout = "2";
m_show_candidate_comment = true;
m_use_ascii_mode = false;
m_commit_by_word = false;
m_hanja_table = hanja_table_load(NULL);
m_symbol_table = NULL;
std::string symbol_file = getenv("HOME");
symbol_file += "/.scim/hangul/symbol.txt";
if (access(symbol_file.c_str(), R_OK) == 0)
m_symbol_table = hanja_table_load(symbol_file.c_str());
if (m_symbol_table == NULL) {
symbol_file = SCIM_HANGUL_DATADIR "/symbol.txt";
if (access(symbol_file.c_str(), R_OK) == 0)
m_symbol_table = hanja_table_load(symbol_file.c_str());
}
set_languages ("ko");
reload_config(m_config);
m_reload_signal_connection = m_config->signal_connect_reload(slot(this, &HangulFactory::reload_config));
}
void
sighup(gint sig)
{
LOG_INFO("%s", N_("SIGHUP received, reloading configuration"));
reload_config();
}
void process_netlink_msg(int sock)
{
int len;
char buf[4096];
struct iovec iov = { buf, sizeof(buf) };
struct sockaddr_nl sa;
struct msghdr msg = { (void *)&sa, sizeof(sa), &iov, 1, NULL, 0, 0 };
struct nlmsghdr *nh;
struct ifinfomsg * ifinfo;
char ifname[IF_NAMESIZE] = {""};
len = recvmsg (sock, &msg, 0);
if (len == -1) {
flog(LOG_ERR, "recvmsg failed: %s", strerror(errno));
}
for (nh = (struct nlmsghdr *) buf; NLMSG_OK (nh, len); nh = NLMSG_NEXT (nh, len)) {
/* The end of multipart message. */
if (nh->nlmsg_type == NLMSG_DONE)
return;
if (nh->nlmsg_type == NLMSG_ERROR) {
flog(LOG_ERR, "%s:%d Some type of netlink error.\n", __FILE__, __LINE__);
abort();
}
/*
if (nh->nlmsg_type == RTM_NEWPREFIX) {
ifinfo = NLMSG_DATA(nh);
if_indextoname(ifinfo->ifi_index, ifname);
dlog(LOG_DEBUG, 3, "%s receive new prefix.\n", ifname);
char tether_interface[PROPERTY_VALUE_MAX] = {'\0'};
if (!property_get("net.ipv6.tether", tether_interface, NULL)) {
flog(LOG_ERR, "netlink get tether interface failed!");
abort();
}
if(!strncmp(tether_interface, ifname, strlen(ifname))){
dlog(LOG_DEBUG, 2, "reload config for new prefix.\n");
reload_config();
}
return ;
}
*/
/* Continue with parsing payload. */
ifinfo = NLMSG_DATA(nh);
if_indextoname(ifinfo->ifi_index, ifname);
if (ifinfo->ifi_flags & IFF_RUNNING) {
dlog(LOG_DEBUG, 3, "%s, ifindex %d, flags is running", ifname, ifinfo->ifi_index);
}
else {
dlog(LOG_DEBUG, 3, "%s, ifindex %d, flags is *NOT* running", ifname, ifinfo->ifi_index);
set_last_prefix(ifname);
}
reload_config();
}
}
static void
signal_cb(struct ev_loop *loop, struct ev_signal *w, int revents) {
if (revents & EV_SIGNAL) {
switch (w->signum) {
case SIGHUP:
reopen_loggers();
reload_config(config, loop, 0);
break;
case SIGUSR1:
print_connections();
break;
case SIGUSR2:
reload_config(config, loop, 1);
break;
case SIGINT:
case SIGTERM:
ev_unloop(loop, EVUNLOOP_ALL);
}
}
}
/**
* child signal handler for sighup
*/
static void child_sighup_handler (int sig)
{
if (sig == SIGHUP) {
/*
* Ignore the return value of reload_config for now.
* This should actually be handled somehow...
*/
reload_config ();
#ifdef FILTER_ENABLE
filter_reload ();
#endif /* FILTER_ENABLE */
}
}
void *input_thread(void *args)
{
char c;
while((c = getchar()))
{
switch(c)
{
case 'r':
{
reload_config();
}
}
}
return NULL;
}
int main(int argc, char *argv[])
{
char tmp[MAX_AUDIT_MESSAGE_LENGTH+1];
struct sigaction sa;
/* Register sighandlers */
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
/* Set handler for the ones we care about */
sa.sa_handler = term_handler;
sigaction(SIGTERM, &sa, NULL);
sa.sa_handler = hup_handler;
sigaction(SIGHUP, &sa, NULL);
/* Initialize the auparse library */
au = auparse_init(AUSOURCE_FEED, 0);
if (au == NULL) {
printf("audisp-example is exiting due to auparse init errors");
return -1;
}
auparse_add_callback(au, handle_event, NULL, NULL);
do {
/* Load configuration */
if (hup) {
reload_config();
}
/* Now the event loop */
while (fgets_unlocked(tmp, MAX_AUDIT_MESSAGE_LENGTH, stdin) &&
hup==0 && stop==0) {
auparse_feed(au, tmp, strnlen(tmp,
MAX_AUDIT_MESSAGE_LENGTH));
}
if (feof(stdin))
break;
} while (stop == 0);
/* Flush any accumulated events from queue */
auparse_flush_feed(au);
auparse_destroy(au);
if (stop)
printf("audisp-example is exiting on stop request\n");
else
printf("audisp-example is exiting on stdin EOF\n");
return 0;
}
static void signal_callback(AvahiWatch *watch, AVAHI_GCC_UNUSED int fd, AVAHI_GCC_UNUSED AvahiWatchEvent event, AVAHI_GCC_UNUSED void *userdata) {
int sig;
const AvahiPoll *poll_api;
assert(watch);
assert(simple_poll_api);
poll_api = avahi_simple_poll_get(simple_poll_api);
if ((sig = daemon_signal_next()) <= 0) {
avahi_log_error("daemon_signal_next() failed");
poll_api->watch_free(watch);
return;
}
switch (sig) {
case SIGINT:
case SIGQUIT:
case SIGTERM:
avahi_log_info(
"Got %s, quitting.",
sig == SIGINT ? "SIGINT" :
(sig == SIGQUIT ? "SIGQUIT" : "SIGTERM"));
avahi_simple_poll_quit(simple_poll_api);
break;
case SIGHUP:
avahi_log_info("Got SIGHUP, reloading.");
reload_config();
break;
case SIGUSR1:
avahi_log_info("Got SIGUSR1, dumping record data.");
avahi_server_dump(avahi_server, dump, NULL);
break;
default:
avahi_log_warn("Got spurious signal, ignoring.");
break;
}
}
static void kqueue_callback(AvahiWatch *watch, int fd, AVAHI_GCC_UNUSED AvahiWatchEvent event, AVAHI_GCC_UNUSED void *userdata) {
struct kevent ev;
struct timespec nullts = { 0, 0 };
int res;
assert(fd == kq);
assert(watch);
res = kevent(kq, NULL, 0, &ev, 1, &nullts);
if (res > 0) {
/* Sleep for a half-second to avoid potential races
* during install/uninstall. */
usleep(500000);
avahi_log_info("Files changed, reloading.");
reload_config();
} else {
avahi_log_error("Failed to read kqueue event: %s", avahi_strerror(errno));
}
}
static void inbox_received_handler(DictionaryIterator *iter, void *context) {
#if defined(PBL_COLOR)
Tuple *bg_tuple = dict_find(iter, BACKGROUND_KEY);
if(bg_tuple) {
data_set_background_color(GColorFromHEX(bg_tuple->value->int32));
}
Tuple *tg_tuple = dict_find(iter, TIE_KEY);
if(tg_tuple) {
data_set_tie_color(GColorFromHEX(tg_tuple->value->int32));
}
Tuple *cg_tuple = dict_find(iter, COLLAR_KEY);
if(cg_tuple) {
data_set_collar_color(GColorFromHEX(cg_tuple->value->int32));
}
#endif
reload_config();
}
void
run_server() {
int maxfd;
fd_set rfds, wfds;
init_connections();
running = 1;
while (running) {
FD_ZERO(&rfds);
FD_ZERO(&wfds);
maxfd = fd_set_listeners(&config->listeners, &rfds, 0);
maxfd = fd_set_connections(&rfds, &wfds, maxfd);
if (select(maxfd + 1, &rfds, &wfds, NULL, NULL) < 0) {
/* select() might have failed because we received a signal, so we need to check */
if (errno != EINTR) {
perror("select");
return;
}
/* We where interrupted by a signal */
if (sighup_received) {
sighup_received = 0;
reload_config(config);
}
if (sigusr1_received) {
sigusr1_received = 0;
print_connections();
}
continue; /* our file descriptor sets are undefined, so select again */
}
handle_listeners(&config->listeners, &rfds, accept_connection);
handle_connections(&rfds, &wfds);
}
free_connections();
}
static void inotify_callback(AvahiWatch *watch, int fd, AVAHI_GCC_UNUSED AvahiWatchEvent event, AVAHI_GCC_UNUSED void *userdata) {
char* buffer;
int n = 0;
assert(fd == inotify_fd);
assert(watch);
ioctl(inotify_fd, FIONREAD, &n);
if (n <= 0)
n = 128;
buffer = avahi_malloc(n);
if (read(inotify_fd, buffer, n) < 0 ) {
avahi_free(buffer);
avahi_log_error("Failed to read inotify event: %s", avahi_strerror(errno));
return;
}
avahi_free(buffer);
avahi_log_info("Files changed, reloading.");
reload_config();
}
bool config_advance_last (int iw)
{
char oldfname[MAX_FILENAME_SIZE];
strcpy (oldfname, config_fname);
Numerically_sorted_glob_last (config_fname);
if (!Fexists(config_fname))
{
printf ("\n** %s: **\n", config_fname);
printf ("** There is no such file! **\n");
strcpy (config_fname, oldfname);
return (FALSE);
}
if (!Freadable(config_fname))
{
printf ("\n** %s: **\n", config_fname);
printf ("** This file is unreadable! **\n");
strcpy (config_fname, oldfname);
return (FALSE);
}
reload_config (iw, FALSE);
return (TRUE);
} /* end config_advance_last() */
void process_netlink_msg(int sock)
{
int len;
char buf[4096];
struct iovec iov = { buf, sizeof(buf) };
struct sockaddr_nl sa;
struct msghdr msg = { (void *)&sa, sizeof(sa), &iov, 1, NULL, 0, 0 };
struct nlmsghdr *nh;
struct ifinfomsg * ifinfo;
char ifname[IF_NAMESIZE] = {""};
len = recvmsg (sock, &msg, 0);
if (len == -1) {
flog(LOG_ERR, "recvmsg failed: %s", strerror(errno));
}
for (nh = (struct nlmsghdr *) buf; NLMSG_OK (nh, len); nh = NLMSG_NEXT (nh, len)) {
/* The end of multipart message. */
if (nh->nlmsg_type == NLMSG_DONE)
return;
if (nh->nlmsg_type == NLMSG_ERROR) {
flog(LOG_ERR, "%s:%d Some type of netlink error.\n", __FILE__, __LINE__);
abort();
}
/* Continue with parsing payload. */
ifinfo = NLMSG_DATA(nh);
if_indextoname(ifinfo->ifi_index, ifname);
if (ifinfo->ifi_flags & IFF_RUNNING) {
dlog(LOG_DEBUG, 3, "%s, ifindex %d, flags is running", ifname, ifinfo->ifi_index);
}
else {
dlog(LOG_DEBUG, 3, "%s, ifindex %d, flags is *NOT* running", ifname, ifinfo->ifi_index);
}
reload_config();
}
}
/**
* Complete the configuration if field is missing
**/
void complete_configuration(const char* missing_conf){
printf("Set %s\n",missing_conf);
if(missing_conf == "ip_rpi_cam") {
scanf("%s",config->ip_rpi_cam);
override_in_file(missing_conf,config->ip_rpi_cam);
} else if(missing_conf == "ip_rpi_toy") {
scanf("%s",config->ip_rpi_toy);
override_in_file(missing_conf,config->ip_rpi_toy);
} else if(missing_conf == "ip_cam") {
scanf("%s",config->ip_cam);
override_in_file(missing_conf,config->ip_cam);
} else if(missing_conf == "port_cam") {
scanf("%s",config->port_cam);
override_in_file(missing_conf,config->port_cam);
} else if(missing_conf == "port_toy") {
scanf("%s",config->port_toy);
override_in_file(missing_conf,config->port_toy);
} else if(missing_conf == "port_rpi_toy") {
scanf("%s",config->port_rpi_toy);
override_in_file(missing_conf,config->port_rpi_toy);
} else if(missing_conf == "port_rpi_cam") {
scanf("%s",config->port_rpi_cam);
override_in_file(missing_conf,config->port_rpi_cam);
} else if(missing_conf == "pwd_rpi_toy") {
scanf("%s",config->pwd_rpi_toy);
override_in_file(missing_conf,config->pwd_rpi_toy);
} else if(missing_conf == "pwd_rpi_cam") {
scanf("%s",config->pwd_rpi_cam);
override_in_file(missing_conf,config->pwd_rpi_cam);
} else if(missing_conf == "path_record") {
scanf("%s",config->path_record);
override_in_file(missing_conf,config->path_record);
}
reload_config();
}
int send_ra(struct Interface *iface, struct in6_addr *dest)
{
struct in6_addr all_hosts_addr = {{{0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,1}}};
struct nd_router_advert *radvert;
struct AdvPrefix *prefix;
struct AdvRoute *route;
struct AdvRDNSS *rdnss;
struct AdvDNSSL *dnssl;
struct AdvLowpanCo *lowpanco;
struct AdvAbro *abroo;
struct timespec time_now;
int64_t secs_since_last_ra;
char addr_str[INET6_ADDRSTRLEN];
unsigned char buff[MSG_SIZE_SEND];
size_t buff_dest = 0;
size_t len = 0;
ssize_t err;
update_device_info(iface);
/* First we need to check that the interface hasn't been removed or deactivated */
if (check_device(iface) < 0) {
if (iface->IgnoreIfMissing) /* a bit more quiet warning message.. */
dlog(LOG_DEBUG, 4, "interface %s does not exist, ignoring the interface", iface->Name);
else {
flog(LOG_WARNING, "interface %s does not exist, ignoring the interface", iface->Name);
}
iface->HasFailed = 1;
/* not really a 'success', but we need to schedule new timers.. */
return 0;
} else {
/* check_device was successful, act if it has failed previously */
if (iface->HasFailed == 1) {
flog(LOG_WARNING, "interface %s seems to have come back up, trying to reinitialize", iface->Name);
iface->HasFailed = 0;
/*
* return -1 so timer_handler() doesn't schedule new timers,
* reload_config() will kick off new timers anyway. This avoids
* timer list corruption.
*/
reload_config();
return -1;
}
}
/* Make sure that we've joined the all-routers multicast group */
if (!disableigmp6check && check_allrouters_membership(iface) < 0)
flog(LOG_WARNING, "problem checking all-routers membership on %s", iface->Name);
if (!iface->AdvSendAdvert) {
dlog(LOG_DEBUG, 2, "AdvSendAdvert is off for %s", iface->Name);
return 0;
}
dlog(LOG_DEBUG, 3, "sending RA on %s", iface->Name);
if (dest == NULL) {
dest = (struct in6_addr *)&all_hosts_addr;
clock_gettime(CLOCK_MONOTONIC, &iface->last_multicast);
}
clock_gettime(CLOCK_MONOTONIC, &time_now);
secs_since_last_ra = timespecdiff(&time_now, &iface->last_ra_time) / 1000;
if (secs_since_last_ra < 0) {
secs_since_last_ra = 0;
flog(LOG_WARNING, "clock_gettime(CLOCK_MONOTONIC) went backwards!");
}
iface->last_ra_time = time_now;
memset(buff, 0, sizeof(buff));
radvert = (struct nd_router_advert *)buff;
send_ra_inc_len(&len, sizeof(struct nd_router_advert));
radvert->nd_ra_type = ND_ROUTER_ADVERT;
radvert->nd_ra_code = 0;
radvert->nd_ra_cksum = 0;
radvert->nd_ra_curhoplimit = iface->AdvCurHopLimit;
radvert->nd_ra_flags_reserved = (iface->AdvManagedFlag) ? ND_RA_FLAG_MANAGED : 0;
radvert->nd_ra_flags_reserved |= (iface->AdvOtherConfigFlag) ? ND_RA_FLAG_OTHER : 0;
/* Mobile IPv6 ext */
radvert->nd_ra_flags_reserved |= (iface->AdvHomeAgentFlag) ? ND_RA_FLAG_HOME_AGENT : 0;
if (iface->cease_adv) {
radvert->nd_ra_router_lifetime = 0;
} else {
/* if forwarding is disabled, send zero router lifetime */
radvert->nd_ra_router_lifetime = !check_ip6_forwarding()? htons(iface->AdvDefaultLifetime) : 0;
}
radvert->nd_ra_flags_reserved |= (iface->AdvDefaultPreference << ND_OPT_RI_PRF_SHIFT) & ND_OPT_RI_PRF_MASK;
radvert->nd_ra_reachable = htonl(iface->AdvReachableTime);
radvert->nd_ra_retransmit = htonl(iface->AdvRetransTimer);
prefix = iface->AdvPrefixList;
/*
* add prefix options
*/
while (prefix) {
if (prefix->enabled && (!prefix->DecrementLifetimesFlag || prefix->curr_preferredlft > 0)) {
struct nd_opt_prefix_info *pinfo;
pinfo = (struct nd_opt_prefix_info *)(buff + len);
send_ra_inc_len(&len, sizeof(*pinfo));
pinfo->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
pinfo->nd_opt_pi_len = 4;
pinfo->nd_opt_pi_prefix_len = prefix->PrefixLen;
pinfo->nd_opt_pi_flags_reserved = (prefix->AdvOnLinkFlag) ? ND_OPT_PI_FLAG_ONLINK : 0;
pinfo->nd_opt_pi_flags_reserved |= (prefix->AdvAutonomousFlag) ? ND_OPT_PI_FLAG_AUTO : 0;
/* Mobile IPv6 ext */
pinfo->nd_opt_pi_flags_reserved |= (prefix->AdvRouterAddr) ? ND_OPT_PI_FLAG_RADDR : 0;
if (iface->cease_adv && prefix->DeprecatePrefixFlag) {
/* RFC4862, 5.5.3, step e) */
if (prefix->curr_validlft < MIN_AdvValidLifetime) {
if (prefix->DecrementLifetimesFlag) {
decrement_lifetime(secs_since_last_ra,
&prefix->curr_validlft);
}
pinfo->nd_opt_pi_valid_time = htonl(prefix->curr_validlft);
} else {
pinfo->nd_opt_pi_valid_time = htonl(MIN_AdvValidLifetime);
}
pinfo->nd_opt_pi_preferred_time = 0;
} else {
if (prefix->DecrementLifetimesFlag) {
decrement_lifetime(secs_since_last_ra, &prefix->curr_validlft);
decrement_lifetime(secs_since_last_ra, &prefix->curr_preferredlft);
if (prefix->curr_preferredlft == 0)
cease_adv_pfx_msg(iface->Name, &prefix->Prefix, prefix->PrefixLen);
}
pinfo->nd_opt_pi_valid_time = htonl(prefix->curr_validlft);
pinfo->nd_opt_pi_preferred_time = htonl(prefix->curr_preferredlft);
}
pinfo->nd_opt_pi_reserved2 = 0;
memcpy(&pinfo->nd_opt_pi_prefix, &prefix->Prefix, sizeof(struct in6_addr));
print_addr(&prefix->Prefix, addr_str);
dlog(LOG_DEBUG, 5, "adding prefix %s to advert for %s with %u seconds(s) valid lifetime and %u seconds(s) preferred time",
addr_str, iface->Name, ntohl(pinfo->nd_opt_pi_valid_time), ntohl(pinfo->nd_opt_pi_preferred_time));
}
prefix = prefix->next;
}
route = iface->AdvRouteList;
/*
* add route options
*/
while (route) {
struct nd_opt_route_info_local *rinfo;
rinfo = (struct nd_opt_route_info_local *)(buff + len);
send_ra_inc_len(&len, sizeof(*rinfo));
rinfo->nd_opt_ri_type = ND_OPT_ROUTE_INFORMATION;
/* XXX: the prefixes are allowed to be sent in smaller chunks as well */
rinfo->nd_opt_ri_len = 3;
rinfo->nd_opt_ri_prefix_len = route->PrefixLen;
rinfo->nd_opt_ri_flags_reserved = (route->AdvRoutePreference << ND_OPT_RI_PRF_SHIFT) & ND_OPT_RI_PRF_MASK;
if (iface->cease_adv && route->RemoveRouteFlag) {
rinfo->nd_opt_ri_lifetime = 0;
} else {
rinfo->nd_opt_ri_lifetime = htonl(route->AdvRouteLifetime);
}
memcpy(&rinfo->nd_opt_ri_prefix, &route->Prefix, sizeof(struct in6_addr));
route = route->next;
}
rdnss = iface->AdvRDNSSList;
/*
* add rdnss options
*/
while (rdnss) {
struct nd_opt_rdnss_info_local *rdnssinfo;
rdnssinfo = (struct nd_opt_rdnss_info_local *)(buff + len);
send_ra_inc_len(&len, sizeof(*rdnssinfo) - (3 - rdnss->AdvRDNSSNumber) * sizeof(struct in6_addr));
rdnssinfo->nd_opt_rdnssi_type = ND_OPT_RDNSS_INFORMATION;
rdnssinfo->nd_opt_rdnssi_len = 1 + 2 * rdnss->AdvRDNSSNumber;
rdnssinfo->nd_opt_rdnssi_pref_flag_reserved = 0;
if (iface->cease_adv && rdnss->FlushRDNSSFlag) {
rdnssinfo->nd_opt_rdnssi_lifetime = 0;
} else {
rdnssinfo->nd_opt_rdnssi_lifetime = htonl(rdnss->AdvRDNSSLifetime);
}
memcpy(&rdnssinfo->nd_opt_rdnssi_addr1, &rdnss->AdvRDNSSAddr1, sizeof(struct in6_addr));
memcpy(&rdnssinfo->nd_opt_rdnssi_addr2, &rdnss->AdvRDNSSAddr2, sizeof(struct in6_addr));
memcpy(&rdnssinfo->nd_opt_rdnssi_addr3, &rdnss->AdvRDNSSAddr3, sizeof(struct in6_addr));
rdnss = rdnss->next;
}
dnssl = iface->AdvDNSSLList;
/*
* add dnssl options
*/
while (dnssl) {
struct nd_opt_dnssl_info_local *dnsslinfo;
int const start_len = len;
int i;
dnsslinfo = (struct nd_opt_dnssl_info_local *)(buff + len);
send_ra_inc_len(&len, sizeof(dnsslinfo->nd_opt_dnssli_type) +
sizeof(dnsslinfo->nd_opt_dnssli_len) + sizeof(dnsslinfo->nd_opt_dnssli_reserved) + sizeof(dnsslinfo->nd_opt_dnssli_lifetime)
);
dnsslinfo->nd_opt_dnssli_type = ND_OPT_DNSSL_INFORMATION;
dnsslinfo->nd_opt_dnssli_reserved = 0;
if (iface->cease_adv && dnssl->FlushDNSSLFlag) {
dnsslinfo->nd_opt_dnssli_lifetime = 0;
} else {
dnsslinfo->nd_opt_dnssli_lifetime = htonl(dnssl->AdvDNSSLLifetime);
}
for (i = 0; i < dnssl->AdvDNSSLNumber; i++) {
char *label;
int label_len;
label = dnssl->AdvDNSSLSuffixes[i];
while (label[0] != '\0') {
if (strchr(label, '.') == NULL)
label_len = strlen(label);
else
label_len = strchr(label, '.') - label;
buff_dest = len;
send_ra_inc_len(&len, 1);
buff[buff_dest] = label_len;
buff_dest = len;
send_ra_inc_len(&len, label_len);
memcpy(buff + buff_dest, label, label_len);
label += label_len;
if (label[0] == '.')
label++;
if (label[0] == '\0') {
buff_dest = len;
send_ra_inc_len(&len, 1);
buff[buff_dest] = 0;
}
}
}
dnsslinfo->nd_opt_dnssli_len = (len - start_len) / 8;
if ((len - start_len) % 8 != 0) {
send_ra_inc_len(&len, 8 - (len - start_len) % 8);
++dnsslinfo->nd_opt_dnssli_len;
}
dnssl = dnssl->next;
}
/*
* add MTU option
*/
if (iface->AdvLinkMTU != 0) {
struct nd_opt_mtu *mtu;
mtu = (struct nd_opt_mtu *)(buff + len);
send_ra_inc_len(&len, sizeof(*mtu));
mtu->nd_opt_mtu_type = ND_OPT_MTU;
mtu->nd_opt_mtu_len = 1;
mtu->nd_opt_mtu_reserved = 0;
mtu->nd_opt_mtu_mtu = htonl(iface->AdvLinkMTU);
}
/*
* add Source Link-layer Address option
*/
if (iface->AdvSourceLLAddress && iface->if_hwaddr_len > 0) {
/*
4.6.1. Source/Target Link-layer Address
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Type | Length | Link-Layer Address ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Fields:
Type
1 for Source Link-layer Address
2 for Target Link-layer Address
Length The length of the option (including the type and
length fields) in units of 8 octets. For example,
the length for IEEE 802 addresses is 1 [IPv6-
ETHER].
Link-Layer Address
The variable length link-layer address.
The content and format of this field (including
byte and bit ordering) is expected to be specified
in specific documents that describe how IPv6
operates over different link layers. For instance,
[IPv6-ETHER].
*/
/* +2 for the ND_OPT_SOURCE_LINKADDR and the length (each occupy one byte) */
size_t const sllao_bytes = (iface->if_hwaddr_len / 8) + 2;
size_t const sllao_len = (sllao_bytes + 7) / 8;
uint8_t *sllao = (uint8_t *) (buff + len);
send_ra_inc_len(&len, sllao_len * 8);
*sllao++ = ND_OPT_SOURCE_LINKADDR;
*sllao++ = (uint8_t) sllao_len;
/* if_hwaddr_len is in bits, so divide by 8 to get the byte count. */
memcpy(sllao, iface->if_hwaddr, iface->if_hwaddr_len / 8);
}
/*
* Mobile IPv6 ext: Advertisement Interval Option to support
* movement detection of mobile nodes
*/
if (iface->AdvIntervalOpt) {
struct AdvInterval a_ival;
uint32_t ival;
if (iface->MaxRtrAdvInterval < Cautious_MaxRtrAdvInterval) {
ival = ((iface->MaxRtrAdvInterval + Cautious_MaxRtrAdvInterval_Leeway) * 1000);
} else {
ival = (iface->MaxRtrAdvInterval * 1000);
}
a_ival.type = ND_OPT_RTR_ADV_INTERVAL;
a_ival.length = 1;
a_ival.reserved = 0;
a_ival.adv_ival = htonl(ival);
buff_dest = len;
send_ra_inc_len(&len, sizeof(a_ival));
memcpy(buff + buff_dest, &a_ival, sizeof(a_ival));
}
/*
* Mobile IPv6 ext: Home Agent Information Option to support
* Dynamic Home Agent Address Discovery
*/
if (iface->AdvHomeAgentInfo && (iface->AdvMobRtrSupportFlag || iface->HomeAgentPreference != 0 || iface->HomeAgentLifetime != iface->AdvDefaultLifetime)) {
struct HomeAgentInfo ha_info;
ha_info.type = ND_OPT_HOME_AGENT_INFO;
ha_info.length = 1;
ha_info.flags_reserved = (iface->AdvMobRtrSupportFlag) ? ND_OPT_HAI_FLAG_SUPPORT_MR : 0;
ha_info.preference = htons(iface->HomeAgentPreference);
ha_info.lifetime = htons(iface->HomeAgentLifetime);
buff_dest = len;
send_ra_inc_len(&len, sizeof(ha_info));
memcpy(buff + buff_dest, &ha_info, sizeof(ha_info));
}
lowpanco = iface->AdvLowpanCoList;
/*
* Add 6co option
*/
if (lowpanco) {
struct nd_opt_6co *co;
co = (struct nd_opt_6co *)(buff + len);
send_ra_inc_len(&len, sizeof(*co));
co->nd_opt_6co_type = ND_OPT_6CO;
co->nd_opt_6co_len = 3;
co->nd_opt_6co_context_len = lowpanco->ContextLength;
co->nd_opt_6co_c = lowpanco->ContextCompressionFlag;
co->nd_opt_6co_cid = lowpanco->AdvContextID;
co->nd_opt_6co_valid_lifetime = lowpanco->AdvLifeTime;
co->nd_opt_6co_con_prefix = lowpanco->AdvContextPrefix;
}
abroo = iface->AdvAbroList;
/*
* Add ABRO option
*/
if (abroo) {
struct nd_opt_abro *abro;
abro = (struct nd_opt_abro *)(buff + len);
send_ra_inc_len(&len, sizeof(*abro));
abro->nd_opt_abro_type = ND_OPT_ABRO;
abro->nd_opt_abro_len = 3;
abro->nd_opt_abro_ver_low = abroo->Version[1];
abro->nd_opt_abro_ver_high = abroo->Version[0];
abro->nd_opt_abro_valid_lifetime = abroo->ValidLifeTime;
abro->nd_opt_abro_6lbr_address = abroo->LBRaddress;
}
err = really_send(dest, iface->if_index, iface->if_addr, buff, len);
if (err < 0) {
if (!iface->IgnoreIfMissing || !(errno == EINVAL || errno == ENODEV))
flog(LOG_WARNING, "sendmsg: %s", strerror(errno));
else
dlog(LOG_DEBUG, 3, "sendmsg: %s", strerror(errno));
}
return 0;
}
int
main(int argc, char **argv)
{
TSS_RESULT result;
int newsd, c, rv, option_index = 0;
int i;
socklen_t client_len;
char *hostname = NULL;
fd_set rdfd_set;
int num_fds = 0;
int nfds = 0;
int stor_errno;
sigset_t sigmask, termmask, oldsigmask;
struct sockaddr_storage client_addr;
struct srv_sock_info socks_info[MAX_IP_PROTO];
struct passwd *pwd;
struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"foreground", 0, NULL, 'f'},
{"config", 1, NULL, 'c'},
{0, 0, 0, 0}
};
unsetenv("TCSD_USE_TCP_DEVICE");
while ((c = getopt_long(argc, argv, "fhec:", long_options, &option_index)) != -1) {
switch (c) {
case 'f':
setenv("TCSD_FOREGROUND", "1", 1);
break;
case 'c':
tcsd_config_file = optarg;
break;
case 'e':
setenv("TCSD_USE_TCP_DEVICE", "1", 1);
break;
case 'h':
/* fall through */
default:
usage();
return -1;
break;
}
}
if (!tcsd_config_file)
tcsd_config_file = TCSD_DEFAULT_CONFIG_FILE;
if ((result = tcsd_startup()))
return (int)result;
#ifdef NOUSERCHECK
LogWarn("will not switch user or check for file permissions. "
"(Compiled with --disable-usercheck)");
#else
#ifndef SOLARIS
pwd = getpwnam(TSS_USER_NAME);
if (pwd == NULL) {
if (errno == 0) {
LogError("User \"%s\" not found, please add this user"
" manually.", TSS_USER_NAME);
} else {
LogError("getpwnam(%s): %s", TSS_USER_NAME, strerror(errno));
}
return TCSERR(TSS_E_INTERNAL_ERROR);
}
setuid(pwd->pw_uid);
#endif
#endif
if (setup_server_sockets(socks_info) == -1) {
LogError("Could not create sockets to listen to connections. Aborting...");
return -1;
}
if (getenv("TCSD_FOREGROUND") == NULL) {
if (daemon(0, 0) == -1) {
perror("daemon");
tcsd_shutdown(socks_info);
return -1;
}
}
LogInfo("%s: TCSD up and running.", PACKAGE_STRING);
sigemptyset(&sigmask);
sigaddset(&sigmask, SIGTERM);
sigaddset(&sigmask, SIGHUP);
sigemptyset(&termmask);
sigaddset(&termmask, SIGTERM);
do {
prepare_for_select(socks_info, &num_fds, &rdfd_set, &nfds);
// Sanity check
if (num_fds == 0) {
LogError("No server sockets available to listen connections. Aborting...");
return -1;
}
// Block TERM and HUP signals to prevent race condition
if (sigprocmask(SIG_BLOCK, &sigmask, &oldsigmask) == -1) {
LogError("Error setting interrupt mask before accept");
}
// TERM and HUP are blocked here, so its safe to test flags.
if (hup) {
// Config reading can be slow, so unmask SIGTERM.
if (sigprocmask(SIG_UNBLOCK, &termmask, NULL) == -1) {
LogError("Error unblocking SIGTERM before config reload");
}
if (reload_config() != TSS_SUCCESS)
LogError("Failed reloading config");
if (sigprocmask(SIG_BLOCK, &termmask, NULL) == -1) {
LogError("Error blocking SIGTERM after config reload");
}
}
if (term)
break;
// Select IPv4 and IPv6 socket descriptors with appropriate sigmask.
LogDebug("Waiting for connections");
rv = pselect(nfds+1, &rdfd_set, NULL, NULL, NULL, &oldsigmask);
stor_errno = errno; // original mask must be set ASAP, so store errno.
if (sigprocmask(SIG_SETMASK, &oldsigmask, NULL) == -1) {
LogError("Error reseting signal mask to the original configuration.");
}
if (rv == -1) {
if (stor_errno != EINTR) {
LogError("Error monitoring server socket descriptors.");
return -1;
}
continue;
}
for (i=0; i < num_fds; i++) { // accept connections from all IP versions (with valid sd)
if (!FD_ISSET(socks_info[i].sd, &rdfd_set)) {
continue;
}
client_len = socks_info[i].addr_len;
newsd = accept(socks_info[i].sd, (struct sockaddr *) &client_addr, &client_len);
if (newsd < 0) {
if (errno != EINTR)
LogError("Failed accept: %s", strerror(errno));
continue;
}
LogDebug("accepted socket %i", newsd);
hostname = fetch_hostname(&client_addr, client_len);
if (hostname == NULL)
hostname=INVALID_ADDR_STR;
tcsd_thread_create(newsd, hostname);
hostname = NULL;
} // for (i=0; i < MAX_IP_PROTO; i++)
} while (term ==0);
/* To close correctly, we must receive a SIGTERM */
tcsd_shutdown(socks_info);
return 0;
}
/*
* Keep the proper number of servers running. This is the birth of the
* servers. It monitors this at least once a second.
*/
void child_main_loop (void)
{
unsigned int i;
while (1) {
if (config.quit)
return;
/* If there are not enough spare servers, create more */
SERVER_COUNT_LOCK ();
if (*servers_waiting < child_config.minspareservers) {
log_message (LOG_NOTICE,
"Waiting servers (%d) is less than MinSpareServers (%d). "
"Creating new child.",
*servers_waiting,
child_config.minspareservers);
SERVER_COUNT_UNLOCK ();
for (i = 0; i != child_config.maxclients; i++) {
if (child_ptr[i].status == T_EMPTY) {
child_ptr[i].status = T_WAITING;
child_ptr[i].tid =
child_make (&child_ptr[i]);
if (child_ptr[i].tid < 0) {
log_message (LOG_NOTICE,
"Could not create child");
child_ptr[i].status = T_EMPTY;
break;
}
SERVER_INC ();
break;
}
}
} else {
SERVER_COUNT_UNLOCK ();
}
sleep (5);
/* Handle log rotation if it was requested */
if (received_sighup) {
/*
* Ignore the return value of reload_config for now.
* This should actually be handled somehow...
*/
reload_config ();
#ifdef FILTER_ENABLE
filter_reload ();
#endif /* FILTER_ENABLE */
/* propagate filter reload to all children */
child_kill_children (SIGHUP);
received_sighup = FALSE;
}
}
}
static struct Interface * main_loop(int sock, struct Interface *ifaces, char const *conf_path)
{
struct pollfd fds[2];
sigset_t sigmask;
sigset_t sigempty;
struct sigaction sa;
sigemptyset(&sigempty);
sigemptyset(&sigmask);
sigaddset(&sigmask, SIGHUP);
sigaddset(&sigmask, SIGTERM);
sigaddset(&sigmask, SIGINT);
sigaddset(&sigmask, SIGUSR1);
sigprocmask(SIG_BLOCK, &sigmask, NULL);
sa.sa_handler = sighup_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGHUP, &sa, 0);
sa.sa_handler = sigterm_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGTERM, &sa, 0);
sa.sa_handler = sigint_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, 0);
sa.sa_handler = sigusr1_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, 0);
memset(fds, 0, sizeof(fds));
fds[0].fd = sock;
fds[0].events = POLLIN;
#if HAVE_NETLINK
fds[1].fd = netlink_socket();
fds[1].events = POLLIN;
#else
fds[1].fd = -1;
#endif
for (;;) {
struct timespec *tsp = 0;
struct Interface *next_iface_to_expire = find_iface_by_time(ifaces);
if (next_iface_to_expire) {
static struct timespec ts;
int timeout = next_time_msec(next_iface_to_expire);
ts.tv_sec = timeout / 1000;
ts.tv_nsec = (timeout - 1000 * ts.tv_sec) * 1000000;
tsp = &ts;
dlog(LOG_DEBUG, 1, "polling for %g second(s), next iface is %s", timeout / 1000.0,
next_iface_to_expire->props.name);
} else {
dlog(LOG_DEBUG, 1, "no iface is next. Polling indefinitely");
}
#ifdef HAVE_PPOLL
int rc = ppoll(fds, sizeof(fds) / sizeof(fds[0]), tsp, &sigempty);
#else
int rc = poll(fds, sizeof(fds) / sizeof(fds[0]), 1000*tsp->tv_sec);
#endif
if (rc > 0) {
#ifdef HAVE_NETLINK
if (fds[1].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[1].fd");
} else if (fds[1].revents & POLLIN) {
process_netlink_msg(fds[1].fd, ifaces);
}
#endif
if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[0].fd");
} else if (fds[0].revents & POLLIN) {
int len, hoplimit;
struct sockaddr_in6 rcv_addr;
struct in6_pktinfo *pkt_info = NULL;
unsigned char msg[MSG_SIZE_RECV];
unsigned char chdr[CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int))];
len = recv_rs_ra(sock, msg, &rcv_addr, &pkt_info, &hoplimit, chdr);
if (len > 0 && pkt_info) {
process(sock, ifaces, msg, len, &rcv_addr, pkt_info, hoplimit);
} else if (!pkt_info) {
dlog(LOG_INFO, 4, "recv_rs_ra returned null pkt_info");
} else if (len <= 0) {
dlog(LOG_INFO, 4, "recv_rs_ra returned len <= 0: %d", len);
}
}
} else if (rc == 0) {
if (next_iface_to_expire)
timer_handler(sock, next_iface_to_expire);
} else if (rc == -1) {
dlog(LOG_INFO, 3, "poll returned early: %s", strerror(errno));
}
if (sigint_received) {
flog(LOG_WARNING, "exiting, %d sigint(s) received", sigint_received);
break;
}
if (sigterm_received) {
flog(LOG_WARNING, "exiting, %d sigterm(s) received", sigterm_received);
break;
}
if (sighup_received) {
dlog(LOG_INFO, 3, "sig hup received");
ifaces = reload_config(sock, ifaces, conf_path);
sighup_received = 0;
}
if (sigusr1_received) {
dlog(LOG_INFO, 3, "sig usr1 received");
reset_prefix_lifetimes(ifaces);
sigusr1_received = 0;
}
}
return ifaces;
}
int
main(int argc, char *argv[])
{
unsigned char msg[MSG_SIZE];
char pidstr[16];
ssize_t ret;
int c, log_method;
char *logfile, *pidfile;
sigset_t oset, nset;
int facility, fd;
char *username = NULL;
char *chrootdir = NULL;
int singleprocess = 0;
#ifdef HAVE_GETOPT_LONG
int opt_idx;
#endif
/* BEGIN: Added by z67728, 2009/10/19 */
FILE * pidfp = NULL;
int pid = 0;
/* END: Added by z67728, 2009/10/19 */
/*start: 用于查询组件版本号(dns atpv),请不要修改或删除*/
/*if ((argc == 2) && (NULL != argv[1]) && (0 == strcmp(argv[1],ATP_VERSION_CMD_KEY)))
{
printf("\r\n%s.\n", RADVD_MODULE_VERSION);
exit(0);
}*/
/*end */
pname = ((pname=strrchr(argv[0],'/')) != NULL)?pname+1:argv[0];
srand((unsigned int)time(NULL));
log_method = L_STDERR_SYSLOG;
/*BEGIN PN:2071008409 l00170266 for var problem modify 20120725 */
#define RADVD_LOG (ROUTER_VARPATH_PREFIX "/radvd/radvd.log")
#define RADVD_CONF (ROUTER_VARPATH_PREFIX "/radvd/radvd.conf")
#define RADVD_PID (ROUTER_VARPATH_PREFIX "/radvd/radvd.pid")
logfile = RADVD_LOG;
conf_file = RADVD_CONF;
facility = LOG_FACILITY;
pidfile = RADVD_PID;
/*END PN:2071008409 l00170266 for var problem modify 20120725 */
/* parse args */
#ifdef HAVE_GETOPT_LONG
while ((c = getopt_long(argc, argv, "d:C:l:m:p:t:u:vhs", prog_opt, &opt_idx)) > 0)
#else
while ((c = getopt(argc, argv, "d:C:l:m:p:t:u:vhs")) > 0)
#endif
{
switch (c) {
case 'C':
conf_file = optarg;
break;
case 'd':
set_debuglevel(atoi(optarg));
break;
case 'f':
facility = atoi(optarg);
break;
case 'l':
logfile = optarg;
break;
case 'p':
pidfile = optarg;
break;
case 'm':
if (!strcmp(optarg, "syslog"))
{
log_method = L_SYSLOG;
}
else if (!strcmp(optarg, "stderr_syslog"))
{
log_method = L_STDERR_SYSLOG;
}
else if (!strcmp(optarg, "stderr"))
{
log_method = L_STDERR;
}
else if (!strcmp(optarg, "logfile"))
{
log_method = L_LOGFILE;
}
else if (!strcmp(optarg, "none"))
{
log_method = L_NONE;
}
else
{
fprintf(stderr, "%s: unknown log method: %s\n", pname, optarg);
exit(1);
}
break;
case 't':
chrootdir = strdup(optarg);
break;
case 'u':
username = strdup(optarg);
break;
case 'v':
/* BEGIN 3061302357 y00188255 2013-6-28 Modified */
//version();
printf("%s\n", RADVD_MODULE_VERSION);
printf("BUILTTIME is: %s %s\n",__DATE__,__TIME__);
exit(1);
/* END 3061302357 y00188255 2013-6-28 Modified */
break;
case 's':
singleprocess = 1;
break;
case 'h':
usage();
#ifdef HAVE_GETOPT_LONG
case ':':
fprintf(stderr, "%s: option %s: parameter expected\n", pname,
prog_opt[opt_idx].name);
exit(1);
#endif
case '?':
exit(1);
}
}
if (chrootdir) {
if (!username) {
fprintf(stderr, "Chroot as root is not safe, exiting\n");
exit(1);
}
if (chroot(chrootdir) == -1) {
perror("chroot");
exit (1);
}
if (chdir("/") == -1) {
perror("chdir");
exit (1);
}
/* username will be switched later */
}
if (log_open(log_method, pname, logfile, facility) < 0)
exit(1);
flog(LOG_INFO, "version %s started", VERSION);
/* get a raw socket for sending and receiving ICMPv6 messages */
sock = open_icmpv6_socket();
if (sock < 0)
exit(1);
#if 0
/* check that 'other' cannot write the file
* for non-root, also that self/own group can't either
*/
if (check_conffile_perm(username, conf_file) < 0) {
if (get_debuglevel() == 0)
exit(1);
else
flog(LOG_WARNING, "Insecure file permissions, but continuing anyway");
}
/* if we know how to do it, check whether forwarding is enabled */
if (check_ip6_forwarding()) {
if (get_debuglevel() == 0) {
flog(LOG_ERR, "IPv6 forwarding seems to be disabled, exiting");
exit(1);
}
else
flog(LOG_WARNING, "IPv6 forwarding seems to be disabled, but continuing anyway.");
}
#endif
/* parse config file */
if (readin_config(conf_file) < 0){
if ( 0 != unlink(pidfile) ){
printf("\r\n Delete %s meet error. error : %s .",pidfile,strerror(errno));
}
exit(1);
}
/* drop root privileges if requested. */
if (username) {
if (!singleprocess) {
dlog(LOG_DEBUG, 3, "Initializing privsep");
if (privsep_init() < 0)
flog(LOG_WARNING, "Failed to initialize privsep.");
}
if (drop_root_privileges(username) < 0)
exit(1);
}
#if 0
if ((fd = open(pidfile, O_RDONLY, 0)) > 0)
{
ret = read(fd, pidstr, sizeof(pidstr) - 1);
if (ret < 0)
{
flog(LOG_ERR, "cannot read radvd pid file, terminating: %s", strerror(errno));
exit(1);
}
pidstr[ret] = '\0';
if (!kill((pid_t)atol(pidstr), 0))
{
flog(LOG_ERR, "radvd already running, terminating.");
exit(1);
}
close(fd);
fd = open(pidfile, O_CREAT|O_TRUNC|O_WRONLY, 0644);
}
else /* FIXME: not atomic if pidfile is on an NFS mounted volume */
fd = open(pidfile, O_CREAT|O_EXCL|O_WRONLY, 0644);
if (fd < 0)
{
flog(LOG_ERR, "cannot create radvd pid file, terminating: %s", strerror(errno));
exit(1);
}
#endif
/*
* okay, config file is read in, socket and stuff is setup, so
* lets fork now...
*/
#if 0
if (get_debuglevel() == 0) {
/* Detach from controlling terminal */
if (daemon(0, 0) < 0)
perror("daemon");
/* close old logfiles, including stderr */
log_close();
/* reopen logfiles, but don't log to stderr unless explicitly requested */
if (log_method == L_STDERR_SYSLOG)
log_method = L_SYSLOG;
if (log_open(log_method, pname, logfile, facility) < 0)
exit(1);
}
#endif
/*
* config signal handlers, also make sure ALRM isn't blocked and raise a warning if so
* (some stupid scripts/pppd appears to do this...)
*/
sigemptyset(&nset);
sigaddset(&nset, SIGALRM);
sigprocmask(SIG_UNBLOCK, &nset, &oset);
if (sigismember(&oset, SIGALRM))
flog(LOG_WARNING, "SIGALRM has been unblocked. Your startup environment might be wrong.");
signal(SIGHUP, sighup_handler);
signal(SIGTERM, sigterm_handler);
signal(SIGINT, sigint_handler);
/* BEGIN: Added by z67728, 2009/11/3 */
signal(SIGUSR1, sigdebug_handler);
signal(SIGUSR2, sigprefixchg_handler);
/* END: Added by z67728, 2009/11/3 */
#if 0
snprintf(pidstr, sizeof(pidstr), "%ld\n", (long)getpid());
write(fd, pidstr, strlen(pidstr));
close(fd);
#endif
/*BEGIN PN:2071008409 l00170266 for var problem modify 20120725 */
#define RADVD_READTEST (ROUTER_VARPATH_PREFIX "/radvd/readtest")
if ( 0 == access(RADVD_READTEST,F_OK) )
/*END PN:2071008409 l00170266 for var problem modify 20120725 */
{
/* Ready test */
g_iReadTestFlag = 1;
}
pid = getpid();
if ((pidfp = fopen(pidfile, "w")) != NULL) {
fwrite(&pid,1,4,pidfp);
fclose(pidfp);
}
config_interface();
kickoff_adverts();
/* enter loop */
for (;;)
{
int len = 0, hoplimit = 0;
struct sockaddr_in6 rcv_addr;
struct in6_pktinfo *pkt_info = NULL;
len = recv_rs_ra(sock, msg, &rcv_addr, &pkt_info, &hoplimit);
if (len > 0) {
process(sock, IfaceList, msg, len,
&rcv_addr, pkt_info, hoplimit);
}
if (sigterm_received || sigint_received) {
stop_adverts();
break;
}
if (sighup_received)
{
if ( 1 == g_iPrefixChgeFlag )
{
disable_oldprefix();
}
reload_config();
sighup_received = 0;
g_iPrefixChgeFlag = 0;
}
}
unlink(pidfile);
exit(0);
}
//运行函数
int Comm_SvrdApp_NonCtrl::run_instance()
{
ZLOG_INFO("[framework] app %s class [%s] run_instance start.",
get_app_basename(),
typeid(*this).name());
//
size_t size_io_event = 0 , size_timer_expire = 0;
size_t prc_frame = 0, idle = 0, proc_data_num = 0;
ZCE_Time_Value select_interval(0, 0);
ZCE_Timer_Queue *time_queue = ZCE_Timer_Queue::instance();
ZCE_Reactor *reactor = ZCE_Reactor::instance();
for (; app_run_;)
{
// 检查是否需要重新加载配置
if (app_reload_)
{
// 重新加载配置
reload_config();
}
//处理收到的命令
popfront_recvpipe(prc_frame);
size_timer_expire = time_queue->expire();
// 处理其他方式通信数据
proc_data_num = 0;
proc(proc_data_num);
//如果没有处理任何帧
// 处理管道的包少于要求处理的最大数则说明管道已经空了
if (prc_frame < MAX_ONCE_PROCESS_FRAME && size_timer_expire <= 0 && proc_data_num <= 0)
{
++idle;
}
else
{
idle = 0;
}
// 如果空循环太多则会白白耗电不低碳
// 理论上这里睡眠最大时间是100毫秒
// 因此只要内存管道大小>=100毫秒最大系统处理包数*每个包字节数
// 则再睡醒以后能够正常处理数据而不至于管道满而丢数据
// 假设系统所有资源够用，那么网卡速率则决定了最大处理能力
// 网卡按1Gbit计算，则管道临界大小为1Gbit-per(S)/8/10≈12MByte，再加上管道自身的内存结构占用
// 考虑为16MByte也即足以，所以只要管道大小超过16MByte应该就顶的住。
// 所以这里就不用空跑那么多次了。
if (idle < 1)
{
continue;
}
//如果空闲很多,休息一下,如果你比较空闲，在这儿SELECT相当于Sleep，
else if (idle >= HEAVY_IDLE_SLEEP_INTERVAL)
{
select_interval.usec(HEAVY_IDLE_INTERVAL_MICROSECOND);
}
//else 相当于 else if (idle >= LIGHT_IDLE_SELECT_INTERVAL)
else
{
select_interval.usec(LIGHT_IDLE_INTERVAL_MICROSECOND);
}
//
reactor->handle_events(&select_interval, &size_io_event);
}
ZLOG_INFO("[framework] app %s class [%s] run_instance end.",
get_app_basename(),
typeid(*this).name());
return SOAR_RET::SOAR_RET_SUCC;
}
void main_loop(void)
{
struct pollfd fds[2];
memset(fds, 0, sizeof(fds));
fds[0].fd = sock;
fds[0].events = POLLIN;
fds[0].revents = 0;
#if HAVE_NETLINK
fds[1].fd = netlink_socket();
fds[1].events = POLLIN;
fds[1].revents = 0;
#else
fds[1].fd = -1;
fds[1].events = 0;
fds[1].revents = 0;
#endif
for (;;) {
struct Interface *next = NULL;
struct Interface *iface;
int timeout = -1;
int rc;
if (IfaceList) {
timeout = next_time_msec(IfaceList);
next = IfaceList;
for (iface = IfaceList; iface; iface = iface->next) {
int t;
t = next_time_msec(iface);
if (timeout > t) {
timeout = t;
next = iface;
}
}
}
dlog(LOG_DEBUG, 5, "polling for %g seconds.", timeout/1000.0);
rc = poll(fds, sizeof(fds)/sizeof(fds[0]), timeout);
if (rc > 0) {
if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[0].fd");
}
else if (fds[0].revents & POLLIN) {
int len, hoplimit;
struct sockaddr_in6 rcv_addr;
struct in6_pktinfo *pkt_info = NULL;
unsigned char msg[MSG_SIZE_RECV];
len = recv_rs_ra(msg, &rcv_addr, &pkt_info, &hoplimit);
if (len > 0) {
process(IfaceList, msg, len,
&rcv_addr, pkt_info, hoplimit);
}
}
#ifdef HAVE_NETLINK
if (fds[1].revents & (POLLERR | POLLHUP | POLLNVAL)) {
flog(LOG_WARNING, "socket error on fds[1].fd");
}
else if (fds[1].revents & POLLIN) {
process_netlink_msg(fds[1].fd);
}
#endif
}
else if ( rc == 0 ) {
if (next)
timer_handler(next);
}
else if ( rc == -1 && errno != EINTR ) {
flog(LOG_ERR, "poll error: %s", strerror(errno));
}
if (sigterm_received || sigint_received) {
flog(LOG_WARNING, "Exiting, sigterm or sigint received.\n");
break;
}
if (sighup_received)
{
reload_config();
sighup_received = 0;
}
if (sigusr1_received)
{
reset_prefix_lifetimes();
sigusr1_received = 0;
}
}
}
int main(int argc, char *argv[])
{
char tmp[MAX_AUDIT_MESSAGE_LENGTH+1];
struct sigaction sa;
/* Register sighandlers */
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
/* Set handler for the ones we care about */
sa.sa_handler = term_handler;
sigaction(SIGTERM, &sa, NULL);
sa.sa_handler = hup_handler;
sigaction(SIGHUP, &sa, NULL);
/* Initialize the auparse library */
au = auparse_init(AUSOURCE_FEED, 0);
if (au == NULL) {
printf("audisp-example is exiting due to auparse init errors");
return -1;
}
auparse_add_callback(au, handle_event, NULL, NULL);
do {
fd_set read_mask;
struct timeval tv;
int retval;
/* Load configuration */
if (hup) {
reload_config();
}
do {
tv.tv_sec = 5;
tv.tv_usec = 0;
FD_ZERO(&read_mask);
FD_SET(0, &read_mask);
if (auparse_feed_has_data(au))
retval= select(1, &read_mask, NULL, NULL, &tv);
else
retval= select(1, &read_mask, NULL, NULL, NULL);
} while (retval == -1 && errno == EINTR && !hup && !stop);
/* Now the event loop */
if (!stop && !hup && retval > 0) {
if (fgets_unlocked(tmp, MAX_AUDIT_MESSAGE_LENGTH,
stdin)) {
auparse_feed(au, tmp, strnlen(tmp,
MAX_AUDIT_MESSAGE_LENGTH));
}
} else if (retval == 0)
auparse_flush_feed(au);
if (feof(stdin))
break;
} while (stop == 0);
/* Flush any accumulated events from queue */
auparse_flush_feed(au);
auparse_destroy(au);
if (stop)
printf("audisp-example is exiting on stop request\n");
else
printf("audisp-example is exiting on stdin EOF\n");
return 0;
}
int
main(int argc, char *argv[])
{
unsigned char msg[MSG_SIZE];
char pidstr[16];
ssize_t ret;
int c, log_method;
char *logfile, *pidfile;
sigset_t oset, nset;
int facility, fd;
char *username = NULL;
char *chrootdir = NULL;
int singleprocess = 0;
#ifdef HAVE_GETOPT_LONG
int opt_idx;
#endif
pname = ((pname=strrchr(argv[0],'/')) != NULL)?pname+1:argv[0];
srand((unsigned int)time(NULL));
log_method = L_STDERR_SYSLOG;
logfile = PATH_RADVD_LOG;
conf_file = PATH_RADVD_CONF;
facility = LOG_FACILITY;
pidfile = PATH_RADVD_PID;
/* parse args */
#ifdef HAVE_GETOPT_LONG
/* Add option to show advertise real lifetime */
/* while ((c = getopt_long(argc, argv, "d:C:l:m:p:t:u:vhs", prog_opt, &opt_idx)) > 0) */
while ((c = getopt_long(argc, argv, "d:C:l:m:p:t:u:vhsD", prog_opt, &opt_idx)) > 0)
#else
/* Add option to show advertise real lifetime */
/* while ((c = getopt(argc, argv, "d:C:l:m:p:t:u:vhs")) > 0) */
while ((c = getopt(argc, argv, "d:C:l:m:p:t:u:vhsD")) > 0)
#endif
{
switch (c) {
case 'C':
conf_file = optarg;
break;
case 'd':
set_debuglevel(atoi(optarg));
break;
case 'f':
facility = atoi(optarg);
break;
case 'l':
logfile = optarg;
break;
case 'p':
pidfile = optarg;
break;
case 'm':
if (!strcmp(optarg, "syslog"))
{
log_method = L_SYSLOG;
}
else if (!strcmp(optarg, "stderr_syslog"))
{
log_method = L_STDERR_SYSLOG;
}
else if (!strcmp(optarg, "stderr"))
{
log_method = L_STDERR;
}
else if (!strcmp(optarg, "logfile"))
{
log_method = L_LOGFILE;
}
else if (!strcmp(optarg, "none"))
{
log_method = L_NONE;
}
else
{
fprintf(stderr, "%s: unknown log method: %s\n", pname, optarg);
exit(1);
}
break;
case 't':
chrootdir = strdup(optarg);
break;
case 'u':
username = strdup(optarg);
break;
case 'v':
version();
break;
case 's':
singleprocess = 1;
break;
/* Add option to show advertise dynamic lifetime */
case 'D':
use_dynamic_lifetime = 1;
break;
case 'h':
usage();
#ifdef HAVE_GETOPT_LONG
case ':':
fprintf(stderr, "%s: option %s: parameter expected\n", pname,
prog_opt[opt_idx].name);
exit(1);
#endif
case '?':
exit(1);
}
}
if (chrootdir) {
if (!username) {
fprintf(stderr, "Chroot as root is not safe, exiting\n");
exit(1);
}
if (chroot(chrootdir) == -1) {
perror("chroot");
exit (1);
}
if (chdir("/") == -1) {
perror("chdir");
exit (1);
}
/* username will be switched later */
}
if (log_open(log_method, pname, logfile, facility) < 0)
exit(1);
flog(LOG_INFO, "version %s started", VERSION);
/* get a raw socket for sending and receiving ICMPv6 messages */
sock = open_icmpv6_socket();
if (sock < 0)
exit(1);
/* check that 'other' cannot write the file
* for non-root, also that self/own group can't either
*/
if (check_conffile_perm(username, conf_file) < 0) {
if (get_debuglevel() == 0)
exit(1);
else
flog(LOG_WARNING, "Insecure file permissions, but continuing anyway");
}
/* if we know how to do it, check whether forwarding is enabled */
if (check_ip6_forwarding()) {
if (get_debuglevel() == 0) {
flog(LOG_ERR, "IPv6 forwarding seems to be disabled, exiting");
exit(1);
}
else
flog(LOG_WARNING, "IPv6 forwarding seems to be disabled, but continuing anyway.");
}
/* parse config file */
if (readin_config(conf_file) < 0)
exit(1);
/* drop root privileges if requested. */
if (username) {
if (!singleprocess) {
dlog(LOG_DEBUG, 3, "Initializing privsep");
if (privsep_init() < 0)
flog(LOG_WARNING, "Failed to initialize privsep.");
}
if (drop_root_privileges(username) < 0)
exit(1);
}
if ((fd = open(pidfile, O_RDONLY, 0)) > 0)
{
ret = read(fd, pidstr, sizeof(pidstr) - 1);
if (ret < 0)
{
flog(LOG_ERR, "cannot read radvd pid file, terminating: %s", strerror(errno));
exit(1);
}
pidstr[ret] = '\0';
if (!kill((pid_t)atol(pidstr), 0))
{
flog(LOG_ERR, "radvd already running, terminating.");
exit(1);
}
close(fd);
fd = open(pidfile, O_CREAT|O_TRUNC|O_WRONLY, 0644);
}
else /* FIXME: not atomic if pidfile is on an NFS mounted volume */
fd = open(pidfile, O_CREAT|O_EXCL|O_WRONLY, 0644);
if (fd < 0)
{
flog(LOG_ERR, "cannot create radvd pid file, terminating: %s", strerror(errno));
exit(1);
}
/*
* okay, config file is read in, socket and stuff is setup, so
* lets fork now...
*/
if (get_debuglevel() == 0) {
/* Detach from controlling terminal */
if (daemon(0, 0) < 0)
perror("daemon");
/* close old logfiles, including stderr */
log_close();
/* reopen logfiles, but don't log to stderr unless explicitly requested */
if (log_method == L_STDERR_SYSLOG)
log_method = L_SYSLOG;
if (log_open(log_method, pname, logfile, facility) < 0)
exit(1);
}
/*
* config signal handlers, also make sure ALRM isn't blocked and raise a warning if so
* (some stupid scripts/pppd appears to do this...)
*/
sigemptyset(&nset);
sigaddset(&nset, SIGALRM);
sigprocmask(SIG_UNBLOCK, &nset, &oset);
if (sigismember(&oset, SIGALRM))
flog(LOG_WARNING, "SIGALRM has been unblocked. Your startup environment might be wrong.");
signal(SIGHUP, sighup_handler);
signal(SIGTERM, sigterm_handler);
signal(SIGINT, sigint_handler);
signal(SIGUSR1, sigusr1_handler);
snprintf(pidstr, sizeof(pidstr), "%ld\n", (long)getpid());
write(fd, pidstr, strlen(pidstr));
close(fd);
config_interface();
/* Record the time for first advertisement */
set_initial_advert_time();
kickoff_adverts();
/* enter loop */
for (;;)
{
int len, hoplimit;
struct sockaddr_in6 rcv_addr;
struct in6_pktinfo *pkt_info = NULL;
len = recv_rs_ra(sock, msg, &rcv_addr, &pkt_info, &hoplimit);
if (len > 0)
process(sock, IfaceList, msg, len,
&rcv_addr, pkt_info, hoplimit);
if (sigterm_received || sigint_received) {
stop_adverts();
/* WNR3500L TD192, Per Netgear spec,
* need to send RA for 3 times before termination.
*/
usleep(200000);
stop_adverts();
usleep(200000);
stop_adverts();
break;
}
if (sighup_received)
{
reload_config();
sighup_received = 0;
}
/* Reset the initial advertisement time to now */
/* This should happen after a successful IADP renew */
if (sigusr1_received)
{
set_initial_advert_time();
sigusr1_received = 0;
}
}
unlink(pidfile);
exit(0);
}
int
main(int argc, char **argv)
{
static struct option long_options[] =
{
{"config-file", required_argument, NULL, 'f'},
{"verbose", no_argument, NULL, 'v'},
{"monitoring-history", no_argument, NULL, 'm'},
{"daemonize", no_argument, NULL, 'd'},
{"pid-file", required_argument, NULL, 'p'},
{NULL, 0, NULL, 0}
};
int optindex;
int c,
ret;
bool daemonize = false;
FILE *fd;
char standby_version[MAXVERSIONSTR],
*ret_ver;
progname = get_progname(argv[0]);
if (argc > 1)
{
if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
{
help(progname);
exit(SUCCESS);
}
if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
{
printf("%s %s (PostgreSQL %s)\n", progname, REPMGR_VERSION, PG_VERSION);
exit(SUCCESS);
}
}
while ((c = getopt_long(argc, argv, "f:v:mdp:", long_options, &optindex)) != -1)
{
switch (c)
{
case 'f':
config_file = optarg;
break;
case 'v':
verbose = true;
break;
case 'm':
monitoring_history = true;
break;
case 'd':
daemonize = true;
break;
case 'p':
pid_file = optarg;
break;
default:
usage();
exit(ERR_BAD_CONFIG);
}
}
if (daemonize)
{
do_daemonize();
}
if (pid_file)
{
check_and_create_pid_file(pid_file);
}
#ifndef WIN32
setup_event_handlers();
#endif
/*
* Read the configuration file: repmgr.conf
*/
parse_config(config_file, &local_options);
if (local_options.node == -1)
{
log_err(_("Node information is missing. "
"Check the configuration file, or provide one if you have not done so.\n"));
terminate(ERR_BAD_CONFIG);
}
fd = freopen("/dev/null", "r", stdin);
if (fd == NULL)
{
fprintf(stderr, "error reopening stdin to '/dev/null': %s",
strerror(errno));
}
fd = freopen("/dev/null", "w", stdout);
if (fd == NULL)
{
fprintf(stderr, "error reopening stdout to '/dev/null': %s",
strerror(errno));
}
logger_init(&local_options, progname, local_options.loglevel,
local_options.logfacility);
if (verbose)
logger_min_verbose(LOG_INFO);
if (log_type == REPMGR_SYSLOG)
{
fd = freopen("/dev/null", "w", stderr);
if (fd == NULL)
{
fprintf(stderr, "error reopening stderr to '/dev/null': %s",
strerror(errno));
}
}
xsnprintf(repmgr_schema, MAXLEN, "%s%s", DEFAULT_REPMGR_SCHEMA_PREFIX,
local_options.cluster_name);
log_info(_("%s Connecting to database '%s'\n"), progname,
local_options.conninfo);
my_local_conn = establish_db_connection(local_options.conninfo, true);
/* should be v9 or better */
log_info(_("%s Connected to database, checking its state\n"), progname);
ret_ver = pg_version(my_local_conn, standby_version);
if (ret_ver == NULL || strcmp(standby_version, "") == 0)
{
if (ret_ver != NULL)
log_err(_("%s needs standby to be PostgreSQL 9.0 or better\n"),
progname);
terminate(ERR_BAD_CONFIG);
}
/*
* MAIN LOOP This loops cicles once per failover and at startup
* Requisites: - my_local_conn needs to be already setted with an active
* connection - no master connection
*/
do
{
/*
* Set my server mode, establish a connection to primary and start
* monitor
*/
ret = is_witness(my_local_conn, repmgr_schema,
local_options.cluster_name, local_options.node);
if (ret == 1)
my_local_mode = WITNESS_MODE;
else if (ret == 0)
{
ret = is_standby(my_local_conn);
if (ret == 1)
my_local_mode = STANDBY_MODE;
else if (ret == 0) /* is the master */
my_local_mode = PRIMARY_MODE;
}
/*
* XXX we did this before changing is_standby() to return int; we
* should not exit at this point, but for now we do until we have a
* better strategy
*/
if (ret == -1)
terminate(1);
switch (my_local_mode)
{
case PRIMARY_MODE:
primary_options.node = local_options.node;
strncpy(primary_options.conninfo, local_options.conninfo,
MAXLEN);
primary_conn = my_local_conn;
check_cluster_configuration(my_local_conn);
check_node_configuration();
if (reload_config(config_file, &local_options))
{
PQfinish(my_local_conn);
my_local_conn = establish_db_connection(local_options.conninfo, true);
primary_conn = my_local_conn;
update_registration();
}
log_info(_("%s Starting continuous primary connection check\n"),
progname);
/*
* Check that primary is still alive, and standbies are
* sending info
*/
/*
* Every local_options.monitor_interval_secs seconds, do
* master checks XXX Check that standbies are sending info
*/
do
{
if (check_connection(primary_conn, "master"))
{
/*
* CheckActiveStandbiesConnections();
* CheckInactiveStandbies();
*/
sleep(local_options.monitor_interval_secs);
}
else
{
/*
* XXX May we do something more verbose ?
*/
terminate(1);
}
if (got_SIGHUP)
{
/*
* if we can reload, then could need to change
* my_local_conn
*/
if (reload_config(config_file, &local_options))
{
PQfinish(my_local_conn);
my_local_conn = establish_db_connection(local_options.conninfo, true);
primary_conn = my_local_conn;
if (*local_options.logfile)
{
FILE *fd;
fd = freopen(local_options.logfile, "a", stderr);
if (fd == NULL)
{
fprintf(stderr, "error reopening stderr to '%s': %s",
local_options.logfile, strerror(errno));
}
}
update_registration();
}
got_SIGHUP = false;
}
} while (!failover_done);
break;
case WITNESS_MODE:
case STANDBY_MODE:
/* I need the id of the primary as well as a connection to it */
log_info(_("%s Connecting to primary for cluster '%s'\n"),
progname, local_options.cluster_name);
primary_conn = get_master_connection(my_local_conn, repmgr_schema,
local_options.cluster_name,
&primary_options.node, NULL);
if (primary_conn == NULL)
{
terminate(ERR_BAD_CONFIG);
}
check_cluster_configuration(my_local_conn);
check_node_configuration();
if (reload_config(config_file, &local_options))
{
PQfinish(my_local_conn);
my_local_conn = establish_db_connection(local_options.conninfo, true);
update_registration();
}
/*
* Every local_options.monitor_interval_secs seconds, do
* checks
*/
if (my_local_mode == WITNESS_MODE)
{
log_info(_("%s Starting continuous witness node monitoring\n"),
progname);
}
else if (my_local_mode == STANDBY_MODE)
{
log_info(_("%s Starting continuous standby node monitoring\n"),
progname);
}
do
{
if (my_local_mode == WITNESS_MODE)
witness_monitor();
else if (my_local_mode == STANDBY_MODE)
standby_monitor();
sleep(local_options.monitor_interval_secs);
if (got_SIGHUP)
{
/*
* if we can reload, then could need to change
* my_local_conn
*/
if (reload_config(config_file, &local_options))
{
PQfinish(my_local_conn);
my_local_conn = establish_db_connection(local_options.conninfo, true);
update_registration();
}
got_SIGHUP = false;
}
} while (!failover_done);
break;
default:
log_err(_("%s: Unrecognized mode for node %d\n"), progname,
local_options.node);
}
failover_done = false;
} while (true);
/* close the connection to the database and cleanup */
close_connections();
/* Shuts down logging system */
logger_shutdown();
return 0;
}
int main(int argc, char **argv)
{
unsigned char buf[256];
int size, s, cntrl_s, cntrl_fd;
socklen_t cntrl_len;
struct sockaddr_un cntrl_addr;
fd_set read_fds, write_fds;
int fd_max;
if (ax25_config_load_ports() == 0) {
fprintf(stderr, "ax25rtd: no AX.25 port configured\n");
return 1;
}
load_config();
load_cache();
if (fork())
return 0;
if ((s = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_AX25))) == -1) {
perror("AX.25 socket");
return 1;
}
if ((cntrl_s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
perror("Control socket");
return 1;
}
unlink(DATA_AX25ROUTED_CTL_SOCK);
cntrl_addr.sun_family = AF_UNIX;
strcpy(cntrl_addr.sun_path, DATA_AX25ROUTED_CTL_SOCK);
cntrl_len =
sizeof(cntrl_addr.sun_family) +
strlen(DATA_AX25ROUTED_CTL_SOCK);
if (bind(cntrl_s, (struct sockaddr *) &cntrl_addr, cntrl_len) < 0) {
perror("bind Control socket");
daemon_shutdown(1);
}
chmod(DATA_AX25ROUTED_CTL_SOCK, 0600);
listen(cntrl_s, 1);
signal(SIGUSR1, sig_debug);
signal(SIGHUP, sig_reload);
signal(SIGTERM, sig_term);
cntrl_fd = -1;
for (;;) {
fd_max = 0;
FD_ZERO(&read_fds);
FD_ZERO(&write_fds);
FD_MAX(s);
if (cntrl_fd > 0) {
FD_MAX(cntrl_fd);
FD_SET(cntrl_fd, &write_fds);
} else {
FD_MAX(cntrl_s);
}
if (select(fd_max + 1, &read_fds, NULL, &write_fds, NULL) < 0) {
if (errno == EINTR) /* woops! */
continue;
if (!FD_ISSET(cntrl_fd, &write_fds)) {
perror("select");
save_cache();
daemon_shutdown(1);
} else {
close(cntrl_fd);
cntrl_fd = -1;
continue;
}
}
if (cntrl_fd > 0) {
if (FD_ISSET(cntrl_fd, &read_fds)) {
size = read(cntrl_fd, buf, sizeof(buf));
if (size > 0) {
buf[size] = '\0';
interpret_command(cntrl_fd, buf);
} else {
close(cntrl_fd);
cntrl_fd = -1;
}
}
} else if (FD_ISSET(cntrl_s, &read_fds)) {
if ((cntrl_fd =
accept(cntrl_s,
(struct sockaddr *) &cntrl_addr,
&cntrl_len)) < 0) {
perror("accept Control");
save_cache();
daemon_shutdown(1);
}
}
if (reload)
reload_config();
if (FD_ISSET(s, &read_fds))
ax25_receive(s);
}
return 0; /* what ?! */
}
int
main(int argc, char **argv)
{
struct sockaddr_in serv_addr, client_addr;
TSS_RESULT result;
int newsd, c, option_index = 0;
unsigned client_len;
char *hostname = NULL;
struct passwd *pwd;
struct hostent *client_hostent = NULL;
struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"foreground", 0, NULL, 'f'},
{"config", 1, NULL, 'c'},
{0, 0, 0, 0}
};
unsetenv("TCSD_USE_TCP_DEVICE");
while ((c = getopt_long(argc, argv, "fhec:", long_options, &option_index)) != -1) {
switch (c) {
case 'f':
setenv("TCSD_FOREGROUND", "1", 1);
break;
case 'c':
tcsd_config_file = optarg;
break;
case 'e':
setenv("TCSD_USE_TCP_DEVICE", "1", 1);
break;
case 'h':
/* fall through */
default:
usage();
return -1;
break;
}
}
if (!tcsd_config_file)
tcsd_config_file = TCSD_DEFAULT_CONFIG_FILE;
if ((result = tcsd_startup()))
return (int)result;
sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd < 0) {
LogError("Failed socket: %s", strerror(errno));
return -1;
}
memset(&serv_addr, 0, sizeof (serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(tcsd_options.port);
/* If no remote_ops are defined, restrict connections to localhost
* only at the socket. */
if (tcsd_options.remote_ops[0] == 0)
serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
else
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
c = 1;
setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &c, sizeof(c));
if (bind(sd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) {
LogError("Failed bind: %s", strerror(errno));
return -1;
}
#ifndef SOLARIS
pwd = getpwnam(TSS_USER_NAME);
if (pwd == NULL) {
if (errno == 0) {
LogError("User \"%s\" not found, please add this user"
" manually.", TSS_USER_NAME);
} else {
LogError("getpwnam(%s): %s", TSS_USER_NAME, strerror(errno));
}
return TCSERR(TSS_E_INTERNAL_ERROR);
}
setuid(pwd->pw_uid);
#endif
if (listen(sd, TCSD_MAX_SOCKETS_QUEUED) < 0) {
LogError("Failed listen: %s", strerror(errno));
return -1;
}
client_len = (unsigned)sizeof(client_addr);
if (getenv("TCSD_FOREGROUND") == NULL) {
if (daemon(0, 0) == -1) {
perror("daemon");
tcsd_shutdown();
return -1;
}
}
LogInfo("%s: TCSD up and running.", PACKAGE_STRING);
do {
newsd = accept(sd, (struct sockaddr *) &client_addr, &client_len);
if (newsd < 0) {
if (errno == EINTR) {
if (term)
break;
else if (hup) {
if (reload_config() != TSS_SUCCESS)
LogError("Failed reloading config");
}
continue;
} else {
LogError("Failed accept: %s", strerror(errno));
continue;
}
}
LogDebug("accepted socket %i", newsd);
if ((client_hostent = gethostbyaddr((char *) &client_addr.sin_addr,
sizeof(client_addr.sin_addr),
AF_INET)) == NULL) {
char buf[16];
uint32_t addr = htonl(client_addr.sin_addr.s_addr);
snprintf(buf, 16, "%d.%d.%d.%d", (addr & 0xff000000) >> 24,
(addr & 0x00ff0000) >> 16, (addr & 0x0000ff00) >> 8,
addr & 0x000000ff);
LogWarn("Host name for connecting IP %s could not be resolved", buf);
hostname = strdup(buf);
} else {
hostname = strdup(client_hostent->h_name);
}
tcsd_thread_create(newsd, hostname);
hostname = NULL;
if (hup) {
if (reload_config() != TSS_SUCCESS)
LogError("Failed reloading config");
}
} while (term ==0);
/* Use script to produce jpeg frames */
void script_animate (int iw)
{
char buf[SCRIPT_LINE_SIZE],output[SCRIPT_LINE_SIZE],*ptr;
int i,hascontent,quality,frames;
FILE *fp;
glob_t globbuf;
strcpy(buf, "scr_anim");
if (!(fp=ropen(buf)))
{
printf ("\nAnimation script \"%s\" does not exist,\n", buf);
xterm_get_focus(iw); clear_stdin_buffer();
if (!strcasecmp("y", readline_gets
("Do you want a default one created (y/n)?","y")))
{
numerically_sorted_glob (config_fname, &globbuf);
fp=wopen(buf);
fprintf (fp, "%d\n", AX_JPG_DEF_QUALITY);
for (i=0; i<globbuf.gl_pathc; i++)
fprintf (fp, "%s Jpg/%05d.jpg\n", globbuf.gl_pathv[i], i);
globfree (&globbuf);
fclose(fp);
fp = ropen(buf);
}
else
{
xterm_release_focus(iw);
return;
}
}
if (!(ptr=fgets(buf,SCRIPT_LINE_SIZE,fp)))
{
printf ("\nThere is nothing in animation script \"%s\".\n", buf);
fclose (fp);
return;
}
for (hascontent=i=0; (buf[i]!=EOS) &&
(ISDIGIT(buf[i]) || ISBLANK(buf[i]) || (buf[i]=='\n')); i++)
if (ISALNUM(buf[i])) hascontent=1;
if (!hascontent)
{
printf ("\nThere is no content in animation script \"%s\".\n", buf);
fclose (fp);
return;
}
if (buf[i] == EOS)
{
sscanf (buf, "%d", &quality);
if ((quality<0) || (quality>100))
{
printf ("\nquality = %d is out of valid range ([0,100]).\n",
quality);
return;
}
else printf ("\nquality = %d\n", quality);
ptr = fgets(buf,SCRIPT_LINE_SIZE,fp);
}
else quality = AX_JPG_DEF_QUALITY;
frames = 0;
/* If bonds are not on now, there is no need to refresh */
temporary_disable_bond = !n[iw].bond_mode;
/* cylinder data structure during the rendering. */
while (ptr)
{
buf[SCRIPT_LINE_CHAR] = EOS;
sscanf (buf, "%s %s", config_fname, output);
reload_config (iw, FALSE);
paint_scene(iw);
AX_dump(iw); AX_show(iw);
if (str_caseend_with(output,".png"))
AX_save_pixmap_as_png
(iw,AX_JPG_QUALITY_TO_PNG_LEVEL(quality),output);
else if (str_caseend_with(output,".eps"))
AX_save_pixmap_as_eps(iw,quality,output);
else AX_save_pixmap_as_jpg(iw,quality,output);
frames++;
ptr = fgets(buf,SCRIPT_LINE_SIZE,fp);
}
fclose(fp);
printf ("%d frames saved.\n\n", frames);
if (temporary_disable_bond)
{
Config_to_3D_Bonds (n[iw].bond_radius);
if (n[iw].bond_mode)
{
bond_xtal_origin_update (iw);
bond_atom_color_update(iw);
}
else
{
n[iw].bond_xtal_origin_need_update = TRUE;
n[iw].bond_atom_color_need_update = TRUE;
}
temporary_disable_bond = 0;
}
return;
} /* end script_animate() */
