static void ignore_interactive_signals()
{
ignore_signal(SIGINT);
ignore_signal(SIGQUIT);
ignore_signal(SIGTSTP);
ignore_signal(SIGTTIN);
}
int main()
{
void *shared_memory = NULL;
struct shm_buff *shm_buff_inst;
char buffer[BUFSIZ];
int shmid,semid;
ignore_signal();
semid = semget(ftok(".",'a'),1,0666|IPC_CREAT);
init_sem(semid,1);
shmid = shmget(ftok(".",'b'),sizeof(struct shm_buff),0666|IPC_CREAT);
if(shmid == -1)
{
perror("shmget failed");
del_sem(semid);
exit(1);
}
shared_memory=shmat(shmid,(void*)0,0);
if(shared_memory==(void*)-1)
{
perror("shmat");
del_sem(semid);
exit(1);
}
printf("memory attached at %X\n",(int)shared_memory);
shm_buff_inst = (struct shm_buff*)shared_memory;
do
{
sem_p(semid);
printf("enter some text to the shared memory(enter'quit'to exit):");
if(fgets(shm_buff_inst->buffer,SHM_BUFF_SZ,stdin)==NULL)
{
perror("fgets");
sem_v(semid);
break;
}
shm_buff_inst->pid=getpid();
sem_v(semid);
} while(strncmp(shm_buff_inst->buffer,"quit",4)!=0);
del_sem(semid);
if(shmdt(shared_memory)==1)
{
perror("shmdt");
exit(1);
}
exit(0);
}
int main(int argc, char *argv[])
{
int flag;
int listenfd;
parse_args(argc, argv);
ignore_signal();
verify_authority();
load_config();
flag = systemlog_init(isdaemon? OUT_LOGFILE : OUT_SCREEN, LOG_FILENAME);
if (flag == -1) {
FATAL("log file can't create!(%s)\n", strerror(errno));
return 0;
}
if (isdaemon)
daemon(1, 0);
threadpool = Tpool_new(nthread);
Tpool_run(threadpool);
listenfd = anet_tcp_server(listen_ip, listen_port, 0);
if (listenfd == -1) {
FATAL("Server Initialize fail!(%s)", strerror(errno));
goto free;
}
INFO("Server Initialize successful!");
for (;;) {
long clientfd = anet_tcp_accept(listenfd, 0);
if (clientfd == -1) {
FATAL("accept fail!(%s)\n", strerror(errno));
close(listenfd);
goto free;
}
Tpool_addwork(threadpool, accept_request, (void*)clientfd);
}
free:
Tpool_free(threadpool);
systemlog_close();
return 0;
}
void
failsafe(int level, int ncopies)
{
pid_t *servers;
int running;
int child;
int i;
pid_t pid;
int signo;
int status;
time_t last_restart = 0, now;
int restarts = 0;
unsigned int backoff = 60;
servers = (pid_t *) xmalloc((unsigned int) (ncopies * sizeof(int)));
memset(servers, 0, ncopies * sizeof(pid_t));
/* Loop forever, until we get SIGTERM */
running = 0;
while (1) {
while (running < ncopies) {
if ((now = time(NULL)) == last_restart) {
if (++restarts > 2 * ncopies) {
dbg_printf(__FILE__, __LINE__,
L_ERROR,
"Servers restarting too "
"quickly, backing off.");
if (backoff < (60 * 60)) {
backoff <<= 1;
}
sleep(backoff);
}
} else {
last_restart = now;
restarts = 0;
backoff = 60;
}
/* Locate a free pid slot */
for (i = 0, child = -1; i < ncopies; i++) {
if (servers[i] == 0) {
child = i;
break;
}
}
if (child < 0) {
dbg_printf(__FILE__, __LINE__, L_FATAL,
"failsafe: no pid slot?!");
}
dbg_printf(__FILE__, __LINE__, D_GENERAL,
"starting server thread %d...\n",
child + 1);
pid = fork();
if (pid < 0) {
dbg_printf(__FILE__, __LINE__, L_FATAL,
"Unable to fork for failsafe: %s",
strerror(errno));
}
if (pid == 0) {
/* Child process: continue with execution. */
return;
}
servers[child] = pid;
running++;
}
/* Ignore some signals */
ignore_signal(SIGTERM);
ignore_signal(SIGHUP);
ignore_signal(SIGINT);
ignore_signal(SIGCHLD);
if ((pid = wait(&status)) < 0) {
dbg_printf(__FILE__, __LINE__,
(errno == ECHILD) ? L_FATAL : L_WARNING,
"failsafe: wait(): %s", strerror(errno));
continue;
}
/* Locate the child */
for (i = 0, child = -1; i < ncopies; i++) {
if (servers[i] == pid) {
child = i;
break;
}
}
if (child < 0) {
dbg_printf(__FILE__, __LINE__, L_WARNING,
"failsafe: unknown child (pid %d) terminated",
pid);
continue;
}
/* Book-keeping */
servers[child] = 0;
running--;
if (WIFSIGNALED(status)) {
signo = WTERMSIG(status);
if (signo == SIGTERM) {
dbg_printf(__FILE__, __LINE__, L_NOTICE,
"failsafe: "
"child %d terminated by SIGTERM. %s.",
pid,
running ? "Continue" : "Exit");
} else {
dbg_printf(__FILE__, __LINE__, L_WARNING,
"failsafe: "
"child %d terminated by SIG %s. "
"Restarting.", pid, signo);
child = -1; /* Restart */
}
} else if (WIFEXITED(status)) {
dbg_printf(__FILE__, __LINE__, L_NOTICE, "failsafe: "
"child %d exited, status %d.",
pid, WEXITSTATUS(status));
} else {
dbg_printf(__FILE__, __LINE__, L_ERROR, "failsafe: "
"abnormal child termination, "
"pid=%d status=%d. Restarting.",
pid, status);
child = -1; /* Restart */
}
/* If child >= 0, we should not restart */
if (child >= 0) {
if (!running) {
dbg_printf(__FILE__, __LINE__, D_GENERAL,
"No more children, exiting.");
exit(0);
}
for (i = child; i < ncopies - 1; i++) {
servers[i] = servers[i + 1];
}
ncopies--; /* Make sure we start no new servers */
}
}
}
static int run_server(DaemonConfig *c) {
int r = -1;
int error;
const AvahiPoll *poll_api = NULL;
AvahiWatch *sig_watch = NULL;
int retval_is_sent = 0;
#ifdef HAVE_INOTIFY
AvahiWatch *inotify_watch = NULL;
#endif
#ifdef HAVE_KQUEUE
int i;
AvahiWatch *kqueue_watch = NULL;
#endif
assert(c);
ignore_signal(SIGPIPE);
if (!(nss_support = avahi_nss_support()))
avahi_log_warn("WARNING: No NSS support for mDNS detected, consider installing nss-mdns!");
if (!(simple_poll_api = avahi_simple_poll_new())) {
avahi_log_error("Failed to create main loop object.");
goto finish;
}
poll_api = avahi_simple_poll_get(simple_poll_api);
if (daemon_signal_init(SIGINT, SIGHUP, SIGTERM, SIGUSR1, 0) < 0) {
avahi_log_error("Could not register signal handlers (%s).", strerror(errno));
goto finish;
}
if (!(sig_watch = poll_api->watch_new(poll_api, daemon_signal_fd(), AVAHI_WATCH_IN, signal_callback, simple_poll_api))) {
avahi_log_error( "Failed to create signal watcher");
goto finish;
}
if (simple_protocol_setup(poll_api) < 0)
goto finish;
#ifdef HAVE_DBUS
if (c->enable_dbus) {
if (dbus_protocol_setup(poll_api,
config.disable_user_service_publishing,
config.n_clients_max,
config.n_objects_per_client_max,
config.n_entries_per_entry_group_max,
!c->fail_on_missing_dbus
#ifdef ENABLE_CHROOT
&& !config.use_chroot
#endif
) < 0) {
avahi_log_warn("WARNING: Failed to contact D-Bus daemon.");
if (c->fail_on_missing_dbus)
goto finish;
}
}
#endif
#ifdef ENABLE_CHROOT
if (config.drop_root && config.use_chroot) {
if (chroot(AVAHI_CONFIG_DIR) < 0) {
avahi_log_error("Failed to chroot(): %s", strerror(errno));
goto finish;
}
avahi_log_info("Successfully called chroot().");
chdir("/");
if (avahi_caps_drop_all() < 0) {
avahi_log_error("Failed to drop capabilities.");
goto finish;
}
avahi_log_info("Successfully dropped remaining capabilities.");
}
#endif
#ifdef HAVE_INOTIFY
if ((inotify_fd = inotify_init()) < 0)
avahi_log_warn( "Failed to initialize inotify: %s", strerror(errno));
else {
add_inotify_watches();
if (!(inotify_watch = poll_api->watch_new(poll_api, inotify_fd, AVAHI_WATCH_IN, inotify_callback, NULL))) {
avahi_log_error( "Failed to create inotify watcher");
goto finish;
}
}
#endif
#ifdef HAVE_KQUEUE
if ((kq = kqueue()) < 0)
avahi_log_warn( "Failed to initialize kqueue: %s", strerror(errno));
else {
add_kqueue_watches();
if (!(kqueue_watch = poll_api->watch_new(poll_api, kq, AVAHI_WATCH_IN, kqueue_callback, NULL))) {
avahi_log_error( "Failed to create kqueue watcher");
goto finish;
}
}
#endif
load_resolv_conf();
#ifdef ENABLE_CHROOT
static_service_load(config.use_chroot);
static_hosts_load(config.use_chroot);
#else
static_service_load(0);
static_hosts_load(0);
#endif
if (!(avahi_server = avahi_server_new(poll_api, &c->server_config, server_callback, c, &error))) {
avahi_log_error("Failed to create server: %s", avahi_strerror(error));
goto finish;
}
update_wide_area_servers();
update_browse_domains();
if (c->daemonize) {
daemon_retval_send(0);
retval_is_sent = 1;
}
for (;;) {
if ((r = avahi_simple_poll_iterate(simple_poll_api, -1)) < 0) {
/* We handle signals through an FD, so let's continue */
if (errno == EINTR)
continue;
avahi_log_error("poll(): %s", strerror(errno));
goto finish;
} else if (r > 0)
/* Quit */
break;
}
r = 0;
finish:
static_service_remove_from_server();
static_service_free_all();
static_hosts_remove_from_server();
static_hosts_free_all();
remove_dns_server_entry_groups();
simple_protocol_shutdown();
#ifdef HAVE_DBUS
if (c->enable_dbus)
dbus_protocol_shutdown();
#endif
if (avahi_server) {
avahi_server_free(avahi_server);
avahi_server = NULL;
}
daemon_signal_done();
if (sig_watch)
poll_api->watch_free(sig_watch);
#ifdef HAVE_INOTIFY
if (inotify_watch)
poll_api->watch_free(inotify_watch);
if (inotify_fd >= 0)
close(inotify_fd);
#endif
#ifdef HAVE_KQUEUE
if (kqueue_watch)
poll_api->watch_free(kqueue_watch);
if (kq >= 0)
close(kq);
for (i = 0; i < num_kfds; i++) {
if (kfds[i] >= 0)
close(kfds[i]);
}
#endif
if (simple_poll_api) {
avahi_simple_poll_free(simple_poll_api);
simple_poll_api = NULL;
}
if (!retval_is_sent && c->daemonize)
daemon_retval_send(1);
return r;
}
int
main(int argc, char **argv)
{
int msgfd;
struct stat statBuf;
Port_t port;
char *msg;
int sockfd, newsockfd;
socklen_t addrlen = 0;
union sockaddr_u their_addr;
if (argc != 3) {
fprintf(stderr, "Usage: portmsg file port\n");
return 1;
}
port = atoi(argv[2]);
if (port == 0) {
fprintf(stderr, "error: bad port number [%s]\n", argv[2]);
return 1;
}
if ((msgfd = open(argv[1], O_RDONLY)) < 0) {
fprintf(stderr, "error: cannot open message file [%s]: %s\n", argv[1],
strerror(errno));
return 1;
}
/* read the message */
fstat(msgfd, &statBuf);
if (statBuf.st_size <= 0) {
fprintf(stderr, "error: message file [%s] is empty\n", argv[1]);
return 1;
}
msg = (char *) malloc(statBuf.st_size);
if (read(msgfd, msg, statBuf.st_size) != statBuf.st_size) {
fprintf(stderr, "error: cannot read message file [%s]\n", argv[1]);
return 1;
}
/* become a daemon */
switch (fork()) {
case -1:
perror("can't fork");
return 1;
case 0:
break;
default:
return 0;
}
#ifdef HAVE_SETSID
if (setsid() < 0)
perror("Unable to create new session id (Harmless)");
#else
if (new_process_group() < 0)
perror("Unable to set new process group (Probably harmless)");
#endif
#ifdef USE_TIOCNOTTY
if ((fd = open("/dev/tty", O_RDWR)) >= 0) {
ioctl(fd, TIOCNOTTY, NULL);
close(fd);
}
#endif
install_sig_handler(SIGCHLD, wait_on_child);
if ((sockfd = make_socket(port, SOCK_STREAM, NULL, NULL, host_ip)) < 0) {
perror("can't make socket");
return 1;
}
main_again:
if (connections > MAX_CONNECTIONS) {
sleep(1);
goto main_again;
}
addrlen = sizeof(their_addr);
newsockfd = accept(sockfd, &their_addr.addr, &addrlen);
if (newsockfd < 0) {
if (errno == EINTR)
goto main_again;
perror("Couldn't accept connection");
return 1;
}
connections++;
switch (fork()) {
case -1:
perror("server can't fork");
return 1;
case 0:
/* child process */
install_sig_handler(SIGPIPE, lostconn);
ignore_signal(SIGCHLD);
send(newsockfd, msg, statBuf.st_size, 0);
sleep(5);
closesocket(newsockfd);
break;
default:
closesocket(newsockfd);
goto main_again;
}
return 0;
}
int main(int argc, char *argv[])
{
int error __unused, i, r, s;
FILE *pidf;
int ch = 0;
while ((ch = getopt(argc, argv, "d")) != -1) {
switch(ch) {
case 'd':
debugopt = 1;
break;
default:
usage();
/* NOT REACHED */
}
}
argc -= optind;
argv += optind;
TAILQ_INIT(&pdev_array_list);
TAILQ_INIT(&udev_monitor_list);
r = ignore_signal(SIGPIPE);
if (r != 0)
err(1, "could not ignore_signal SIGPIPE");
r = pthread_mutex_init(&(monitor_lock), NULL);
if (r != 0)
err(1, "could not allocate a pthread_mutex");
if ((udevfd = open(UDEV_DEVICE_PATH, O_RDWR | O_NONBLOCK)) == -1)
err(1, "%s", UDEV_DEVICE_PATH);
unblock_descriptor(udevfd);
s = init_local_server(LISTEN_SOCKET_FILE, SOCK_STREAM, 0);
if (s < 0)
err(1, "init_local_server");
pidf = fopen("/var/run/udevd.pid", "w");
#if 0
if (pidf == NULL)
err(1, "pidfile");
#endif
set_signal(SIGTERM, killed);
set_signal(SIGHUP, hangup);
if (debugopt == 0)
if (daemon(0, 0) == -1)
err(1, "daemon");
if (pidf != NULL) {
fprintf(pidf, "%ld\n", (long)getpid());
fclose(pidf);
}
syslog(LOG_ERR, "udevd started");
pdev_array_entry_insert(udev_getdevs(udevfd));
memset(fds, 0 , sizeof(fds));
fds[UDEV_DEVICE_FD_IDX].fd = udevfd;
fds[UDEV_DEVICE_FD_IDX].events = POLLIN;
fds[UDEV_SOCKET_FD_IDX].fd = s;
fds[UDEV_SOCKET_FD_IDX].events = POLLIN | POLLPRI;
for (;;) {
r = poll(fds, NFDS, -1);
if (r < 0) {
if (hangup_ongoing == 0) {
if (errno == EINTR) {
usleep(5000);
continue;
} else {
err(1, "polling...");
}
} else {
usleep(20000); /* 20 ms */
continue;
}
}
for (i = 0; (i < NFDS) && (r > 0); i++) {
if (fds[i].revents == 0)
continue;
--r;
switch (i) {
case UDEV_DEVICE_FD_IDX:
udev_read_event(udevfd);
break;
case UDEV_SOCKET_FD_IDX:
handle_new_connection(s);
break;
default:
break;
}
}
}
syslog(LOG_ERR, "udevd is exiting normally");
return 0;
}
