trunk/src/librc.c

/*
   librc 
   core RC functions
   Copyright 2007 Gentoo Foundation
   Released under the GPLv2
   */

#include "librc.h"

/* usecs to wait while we poll the fifo */
#define WAIT_INTERVAL   20000

/* max secs to wait until a service comes up */
#define WAIT_MAX        60

#define SOFTLEVEL       RC_SVCDIR "softlevel"

/* File stream used for plugins to write environ vars to */
FILE *rc_environ_fd = NULL;

static const char *rc_service_state_names[] = {
        "started",
        "stopped",
        "starting",
        "stopping",
        "inactive",
        "wasinactive",
        "coldplugged",
        "failed",
        "scheduled",
        NULL
};

bool rc_runlevel_starting (void)
{
        return (rc_is_dir (RC_SVCDIR "softscripts.old"));
}
librc_hidden_def(rc_runlevel_starting)

bool rc_runlevel_stopping (void)
{
        return (rc_is_dir (RC_SVCDIR "softscripts.new"));
}
librc_hidden_def(rc_runlevel_stopping)

char **rc_get_runlevels (void)
{
        char **dirs = rc_ls_dir (NULL, RC_RUNLEVELDIR, 0);
        char **runlevels = NULL;
        int i;
        char *dir;

        STRLIST_FOREACH (dirs, dir, i) {
                char *path = rc_strcatpaths (RC_RUNLEVELDIR, dir, (char *) NULL);
                if (rc_is_dir (path))
                        runlevels = rc_strlist_addsort (runlevels, dir);
                free (path);
        }
        rc_strlist_free (dirs);

        return (runlevels);
}
librc_hidden_def(rc_get_runlevels)

char *rc_get_runlevel (void)
{
        FILE *fp;
        static char buffer [PATH_MAX];

        if (! (fp = fopen (SOFTLEVEL, "r"))) {
                snprintf (buffer, sizeof (buffer), "sysinit");
                return (buffer);
        }

        if (fgets (buffer, PATH_MAX, fp)) {
                int i = strlen (buffer) - 1;
                if (buffer[i] == '\n')
                        buffer[i] = 0;
                fclose (fp);
                return (buffer);
        }

        fclose (fp);
        snprintf (buffer, sizeof (buffer), "sysinit");
        return (buffer);
}
librc_hidden_def(rc_get_runlevel)

void rc_set_runlevel (const char *runlevel)
{
        FILE *fp = fopen (SOFTLEVEL, "w");
        if (! fp)
                eerrorx ("failed to open `" SOFTLEVEL "': %s", strerror (errno));
        fprintf (fp, "%s", runlevel);
        fclose (fp);
}
librc_hidden_def(rc_set_runlevel)

bool rc_runlevel_exists (const char *runlevel)
{
        char *path;
        bool retval;

        if (! runlevel)
                return (false);

        path = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, (char *) NULL);
        retval = rc_is_dir (path);
        free (path);
        return (retval);
}
librc_hidden_def(rc_runlevel_exists)

/* Resolve a service name to it's full path */
char *rc_resolve_service (const char *service)
{
        char buffer[PATH_MAX];
        char *file;
        int r = 0;

        if (! service)
                return (NULL);

        if (service[0] == '/')
                return (strdup (service));

        file = rc_strcatpaths (RC_SVCDIR, "started", service, (char *) NULL);
        if (! rc_is_link (file)) {
                free (file);
                file = rc_strcatpaths (RC_SVCDIR, "inactive", service, (char *) NULL);
                if (! rc_is_link (file)) {
                        free (file);
                        file = NULL;
                }
        }

        memset (buffer, 0, sizeof (buffer));
        if (file) {
                r = readlink (file, buffer, sizeof (buffer));
                free (file);
                if (r > 0)
                        return (rc_xstrdup (buffer));
        }

        snprintf (buffer, sizeof (buffer), RC_INITDIR "%s", service);
        return (strdup (buffer));
}
librc_hidden_def(rc_resolve_service)

bool rc_service_exists (const char *service)
{
        char *file;
        bool retval = false;
        int len;

        if (! service)
                return (false);

        len = strlen (service);

        /* .sh files are not init scripts */
        if (len > 2 && service[len - 3] == '.' &&
                service[len - 2] == 's' &&
                service[len - 1] == 'h')
                return (false);

        file = rc_resolve_service (service); 
        if (rc_exists (file))
                retval = rc_is_exec (file);
        free (file);
        return (retval);
}
librc_hidden_def(rc_service_exists)

bool rc_service_in_runlevel (const char *service, const char *runlevel)
{
        char *file;
        bool retval;
        char *svc;

        if (! runlevel || ! service)
                return (false);

        if (! rc_service_exists (service))
                return (false);

        svc = rc_xstrdup (service);
        file = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, basename (svc),
                                                   (char *) NULL);
        free (svc);
        retval = rc_exists (file);
        free (file);

        return (retval);
}
librc_hidden_def(rc_service_in_runlevel)

bool rc_mark_service (const char *service, const rc_service_state_t state)
{
        char *file;
        int i = 0;
        int skip_state = -1;
        char *base;
        char *svc;
        char *init = rc_resolve_service (service);
        bool skip_wasinactive = false;

        if (! service)
                return (false);

        svc = rc_xstrdup (service);
        base = basename (svc);

        if (state != rc_service_stopped) {
                if (! rc_is_file(init)) {
                        free (init);
                        free (svc);
                        return (false);
                }

                file = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[state], base,
                                                           (char *) NULL);
                if (rc_exists (file))
                        unlink (file);
                i = symlink (init, file);
                if (i != 0)     {
                        free (file);
                        free (init);
                        free (svc);
                        einfo ("%d %s %s", state, rc_service_state_names[state], base);
                        eerror ("symlink `%s' to `%s': %s", init, file, strerror (errno));
                        return (false);
                }

                free (file);
                skip_state = state;
        }

        if (state == rc_service_coldplugged) {
                free (init);
                free (svc);
                return (true);
        }

        /* Remove any old states now */
        i = 0;
        while (rc_service_state_names[i]) {
                if ((i != skip_state &&
                         i != rc_service_stopped &&
                         i != rc_service_coldplugged &&
                         i != rc_service_scheduled &&
                         i != rc_service_crashed) &&
                        (! skip_wasinactive || i != rc_service_wasinactive))
                {
                        file = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[i], base,
                                                                   (char *) NULL);
                        if (rc_exists (file)) {
                                if ((state == rc_service_starting ||
                                         state == rc_service_stopping) &&
                                        i == rc_service_inactive)
                                {
                                        char *wasfile = rc_strcatpaths (RC_SVCDIR,
                                                                                                        rc_service_state_names[rc_service_wasinactive],
                                                                                                        base, (char *) NULL);

                                        if (symlink (init, wasfile) != 0)
                                                eerror ("symlink `%s' to `%s': %s", init, wasfile,
                                                                strerror (errno));

                                        skip_wasinactive = true;
                                        free (wasfile);
                                }

                                errno = 0;
                                if (unlink (file) != 0 && errno != ENOENT)
                                        eerror ("failed to delete `%s': %s", file,
                                                        strerror (errno));
                        }
                        free (file);
                }
                i++;
        }

        /* Remove the exclusive state if we're inactive */
        if (state == rc_service_started ||
                state == rc_service_stopped ||
                state == rc_service_inactive)
        {
                file = rc_strcatpaths (RC_SVCDIR, "exclusive", base, (char *) NULL);
                if (rc_exists (file))
                        if (unlink (file) != 0)
                                eerror ("unlink `%s': %s", file, strerror (errno));
                free (file);
        }

        /* Remove any options and daemons the service may have stored */
        if (state == rc_service_stopped) {
                char *dir = rc_strcatpaths (RC_SVCDIR, "options", base, (char *) NULL);

                if (rc_is_dir (dir))
                        rc_rm_dir (dir, true);
                free (dir);

                dir = rc_strcatpaths (RC_SVCDIR, "daemons", base, (char *) NULL);
                if (rc_is_dir (dir))
                        rc_rm_dir (dir, true);
                free (dir);

                rc_schedule_clear (service);
        }

        /* These are final states, so remove us from scheduled */
        if (state == rc_service_started || state == rc_service_stopped) {
                char *sdir = rc_strcatpaths (RC_SVCDIR, "scheduled", (char *) NULL);
                char **dirs = rc_ls_dir (NULL, sdir, 0);
                char *dir;
                int serrno;

                STRLIST_FOREACH (dirs, dir, i) {
                        char *bdir = rc_strcatpaths (sdir, dir, (char *) NULL);
                        file = rc_strcatpaths (bdir, base, (char *) NULL);
                        if (rc_exists (file))
                                if (unlink (file) != 0)
                                        eerror ("unlink `%s': %s", file, strerror (errno));
                        free (file);

                        /* Try and remove the dir - we don't care about errors */
                        serrno = errno;
                        rmdir (bdir);
                        errno = serrno;
                        free (bdir);
                }
                rc_strlist_free (dirs);
                free (sdir);
        }

        free (svc);
        free (init);
        return (true);
}
librc_hidden_def(rc_mark_service)

bool rc_service_state (const char *service, const rc_service_state_t state)
{
        char *file;
        bool retval;
        char *svc;

        /* If the init script does not exist then we are stopped */
        if (! rc_service_exists (service))
                return (state == rc_service_stopped ? true : false);

        /* We check stopped state by not being in any of the others */
        if (state == rc_service_stopped)
                return ( ! (rc_service_state (service, rc_service_started) ||
                                        rc_service_state (service, rc_service_starting) ||
                                        rc_service_state (service, rc_service_stopping) ||
                                        rc_service_state (service, rc_service_inactive)));

        /* The crashed state and scheduled states are virtual */
        if (state == rc_service_crashed)
                return (rc_service_daemons_crashed (service));
        else if (state == rc_service_scheduled) {
                char **services = rc_services_scheduled_by (service);
                retval = (services);
                if (services)
                        free (services);
                return (retval);
        }

        /* Now we just check if a file by the service name rc_exists
           in the state dir */
        svc = rc_xstrdup (service);
        file = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[state],
                                                   basename (svc), (char*) NULL);
        free (svc);
        retval = rc_exists (file);
        free (file);
        return (retval);
}
librc_hidden_def(rc_service_state)

bool rc_get_service_option (const char *service, const char *option,
                                                        char *value)
{
        FILE *fp;
        char buffer[RC_LINEBUFFER];
        char *file = rc_strcatpaths (RC_SVCDIR, "options", service, option,
                                                                 (char *) NULL);
        bool retval = false;

        if (rc_exists (file)) {
                if ((fp = fopen (file, "r")) == NULL)
                        eerror ("fopen `%s': %s", file, strerror (errno));
                else {
                        memset (buffer, 0, sizeof (buffer));
                        while (fgets (buffer, RC_LINEBUFFER, fp)) {
                                memcpy (value, buffer, strlen (buffer));
                                value += strlen (buffer);
                        }
                        fclose (fp);
                        retval = true;
                }
        }

        free (file);
        return (retval);
}
librc_hidden_def(rc_get_service_option)

bool rc_set_service_option (const char *service, const char *option,
                                                        const char *value)
{
        FILE *fp;
        char *path = rc_strcatpaths (RC_SVCDIR, "options", service, (char *) NULL);
        char *file = rc_strcatpaths (path, option, (char *) NULL);
        bool retval = false;

        if (! rc_is_dir (path)) {
                if (mkdir (path, 0755) != 0) {
                        eerror ("mkdir `%s': %s", path, strerror (errno));
                        free (path);
                        free (file);
                        return (false);
                }
        }

        if ((fp = fopen (file, "w")) == NULL)
                eerror ("fopen `%s': %s", file, strerror (errno));
        else {
                if (value)
                        fprintf (fp, "%s", value);
                fclose (fp);
                retval = true;
        }

        free (path);
        free (file);
        return (retval);
}
librc_hidden_def(rc_set_service_option)

static pid_t _exec_service (const char *service, const char *arg)
{
        char *file;
        char *fifo;
        pid_t pid = -1;
        char *svc;

        file = rc_resolve_service (service);
        if (! rc_is_file (file)) {
                rc_mark_service (service, rc_service_stopped);
                free (file);
                return (0);
        }

        /* We create a fifo so that other services can wait until we complete */
        svc = rc_xstrdup (service);
        fifo = rc_strcatpaths (RC_SVCDIR, "exclusive", basename (svc),
                                                   (char *) NULL);
        free (svc);

        if (mkfifo (fifo, 0600) != 0 && errno != EEXIST) {
                eerror ("unable to create fifo `%s': %s", fifo, strerror (errno));
                free (fifo);
                free (file);
                return (-1);
        }

        if ((pid = vfork ()) == 0) {
                execl (file, file, arg, (char *) NULL);
                eerror ("unable to exec `%s': %s", file, strerror (errno));
                unlink (fifo);
                _exit (EXIT_FAILURE);
        }

        free (fifo);
        free (file);

        if (pid == -1)
                eerror ("vfork: %s", strerror (errno));
        
        return (pid);
}

int rc_waitpid (pid_t pid) {
        int status = 0;
        pid_t savedpid = pid;

        errno = 0;
        do {
                pid = waitpid (savedpid, &status, 0);
                if (pid < 0) {
                        if (errno != ECHILD)
                                eerror ("waitpid %d: %s", savedpid, strerror (errno));
                        return (-1);
                }
        } while (! WIFEXITED (status) && ! WIFSIGNALED (status)); 
        
        return (WIFEXITED (status) ? WEXITSTATUS (status) : EXIT_FAILURE);
}

pid_t rc_stop_service (const char *service)
{
        if (rc_service_state (service, rc_service_stopped))
                return (0);

        return (_exec_service (service, "stop"));
}
librc_hidden_def(rc_stop_service)

pid_t rc_start_service (const char *service)
{
        if (! rc_service_state (service, rc_service_stopped))
                return (0);

        return (_exec_service (service, "start"));
}
librc_hidden_def(rc_start_service)

void rc_schedule_start_service (const char *service,
                                                                const char *service_to_start)
{
        char *dir;
        char *init;
        char *file;
        char *svc;

        /* service may be a provided service, like net */
        if (! service || ! rc_service_exists (service_to_start))
                return;

        svc = rc_xstrdup (service);
        dir = rc_strcatpaths (RC_SVCDIR, "scheduled", basename (svc),
                                                  (char *) NULL);
        free (svc);
        if (! rc_is_dir (dir))
                if (mkdir (dir, 0755) != 0) {
                        eerror ("mkdir `%s': %s", dir, strerror (errno));
                        free (dir);
                        return;
                }

        init = rc_resolve_service (service_to_start);
        svc = rc_xstrdup (service_to_start);
        file = rc_strcatpaths (dir, basename (svc), (char *) NULL);
        free (svc);
        if (! rc_exists (file) && symlink (init, file) != 0)
                eerror ("symlink `%s' to `%s': %s", init, file, strerror (errno));

        free (init);
        free (file);
        free (dir);
}
librc_hidden_def(rc_schedule_start_service)

void rc_schedule_clear (const char *service)
{
        char *svc  = rc_xstrdup (service);
        char *dir = rc_strcatpaths (RC_SVCDIR, "scheduled", basename (svc),
                                                                (char *) NULL);

        free (svc);
        if (rc_is_dir (dir))
                rc_rm_dir (dir, true);
        free (dir);
}
librc_hidden_def(rc_schedule_clear)

bool rc_wait_service (const char *service)
{
        char *svc = rc_xstrdup (service);
        char *fifo = rc_strcatpaths (RC_SVCDIR, "exclusive", basename (svc),
                                                                 (char *) NULL);
        struct timeval tv;
        struct timeval stopat;
        struct timeval now;
        bool retval = false;

        free (svc);
        if (gettimeofday (&stopat, NULL) != 0) {
                eerror ("gettimeofday: %s", strerror (errno));
                return (false);
        }
        stopat.tv_sec += WAIT_MAX;

        while (true) {
                if (! rc_exists (fifo)) {
                        retval = true;
                        break;
                }

                tv.tv_sec = 0;
                tv.tv_usec = WAIT_INTERVAL;
                if (select (0, 0, 0, 0, &tv) < 0) {
                        if (errno != EINTR) {
                                eerror ("select: %s",strerror (errno));
                                break;
                        }
                }

                /* Don't hang around forever */
                if (gettimeofday (&now, NULL) != 0) {
                        eerror ("gettimeofday: %s", strerror (errno));
                        break;
                }

                if (timercmp (&now, &stopat, >))
                        break;
        }

        free (fifo);
        return (retval);
}
librc_hidden_def(rc_wait_service)

char **rc_services_in_runlevel (const char *runlevel)
{
        char *dir;
        char **list = NULL;

        if (! runlevel)
                return (rc_ls_dir (NULL, RC_INITDIR, RC_LS_INITD));

        /* These special levels never contain any services */
        if (strcmp (runlevel, RC_LEVEL_SYSINIT) == 0 ||
                strcmp (runlevel, RC_LEVEL_SINGLE) == 0)
                return (NULL);

        dir = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, (char *) NULL);
        if (! rc_is_dir (dir))
                eerror ("runlevel `%s' does not exist", runlevel);
        else
                list = rc_ls_dir (list, dir, RC_LS_INITD);

        free (dir);
        return (list);
}
librc_hidden_def(rc_services_in_runlevel)

char **rc_services_in_state (rc_service_state_t state)
{
        char *dir = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[state],
                                                                (char *) NULL);
        char **list = NULL;

        if (state == rc_service_scheduled) {
                char **dirs = rc_ls_dir (NULL, dir, 0);
                char *d;
                int i;

                STRLIST_FOREACH (dirs, d, i) {
                        char *p = rc_strcatpaths (dir, d, (char *) NULL);
                        char **entries = rc_ls_dir (NULL, p, RC_LS_INITD);
                        char *e;
                        int j;

                        STRLIST_FOREACH (entries, e, j)
                                list = rc_strlist_addsortu (list, e);

                        if (entries)
                                free (entries);
                }

                if (dirs)
                        free (dirs);
        } else {
                if (rc_is_dir (dir))
                        list = rc_ls_dir (list, dir, RC_LS_INITD);
        }

        free (dir);
        return (list);
}
librc_hidden_def(rc_services_in_state)

bool rc_service_add (const char *runlevel, const char *service)
{
        bool retval;
        char *init;
        char *file;
        char *svc;

        if (! rc_runlevel_exists (runlevel)) {
                errno = ENOENT;
                return (false);
        }

        if (rc_service_in_runlevel (service, runlevel)) {
                errno = EEXIST;
                return (false);
        }

        init = rc_resolve_service (service);
        svc = rc_xstrdup (service);
        file = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, basename (svc),
                                                   (char *) NULL);
        free (svc);
        retval = (symlink (init, file) == 0);
        free (init);
        free (file);
        return (retval);
}
librc_hidden_def(rc_service_add)

bool rc_service_delete (const char *runlevel, const char *service)
{
        char *file;
        char *svc;
        bool retval = false;

        if (! runlevel || ! service)
                return (false);

        svc = rc_xstrdup (service);
        file = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, basename (svc),
                                                   (char *) NULL);
        free (svc);
        if (unlink (file) == 0)
                retval = true;

        free (file);
        return (retval);
}
librc_hidden_def(rc_service_delete)

char **rc_services_scheduled_by (const char *service)
{
        char **dirs = rc_ls_dir (NULL, RC_SVCDIR "scheduled", 0);
        char **list = NULL;
        char *dir;
        int i;

        STRLIST_FOREACH (dirs, dir, i) {
                char *file = rc_strcatpaths (RC_SVCDIR "scheduled", dir, service,
                                                                         (char *) NULL);
                if (rc_exists (file))
                        list = rc_strlist_add (list, file);
                free (file);
        }
        rc_strlist_free (dirs);

        return (list);
}
librc_hidden_def(rc_services_scheduled_by)

char **rc_services_scheduled (const char *service)
{
        char *svc = rc_xstrdup (service);
        char *dir = rc_strcatpaths (RC_SVCDIR, "scheduled", basename (svc),
                                                                (char *) NULL);
        char **list = NULL;

        if (rc_is_dir (dir))
                list = rc_ls_dir (list, dir, RC_LS_INITD);

        free (svc);
        free (dir);
        return (list);
}
librc_hidden_def(rc_services_scheduled)

bool rc_allow_plug (char *service)
{
        char *list;
        char *p;
        char *star;
        char *token;
        bool allow = true;
        char *match = getenv ("RC_PLUG_SERVICES");
        if (! match)
                return true;

        list = rc_xstrdup (match);
        p = list;
        while ((token = strsep (&p, " "))) {
                bool truefalse = true;
                if (token[0] == '!') {
                        truefalse = false;
                        token++;
                }

                star = strchr (token, '*');
                if (star) {
                        if (strncmp (service, token, star - token) == 0) {
                                allow = truefalse;
                                break;
                        }
                } else {
                        if (strcmp (service, token) == 0) {
                                allow = truefalse;
                                break;
                        }
                }
        }

        free (list);
        return (allow);
}
librc_hidden_def(rc_allow_plug)
1	/*
2	librc
3	core RC functions
4	Copyright 2007 Gentoo Foundation
5	Released under the GPLv2
6	*/
7
8	#include "librc.h"
9
10	/* usecs to wait while we poll the fifo */
11	#define WAIT_INTERVAL 20000
12
13	/* max secs to wait until a service comes up */
14	#define WAIT_MAX 60
15
16	#define SOFTLEVEL RC_SVCDIR "softlevel"
17
18	/* File stream used for plugins to write environ vars to */
19	FILE *rc_environ_fd = NULL;
20
21	static const char *rc_service_state_names[] = {
22	"started",
23	"stopped",
24	"starting",
25	"stopping",
26	"inactive",
27	"wasinactive",
28	"coldplugged",
29	"failed",
30	"scheduled",
31	NULL
32	};
33
34	bool rc_runlevel_starting (void)
35	{
36	return (rc_is_dir (RC_SVCDIR "softscripts.old"));
37	}
38	librc_hidden_def(rc_runlevel_starting)
39
40	bool rc_runlevel_stopping (void)
41	{
42	return (rc_is_dir (RC_SVCDIR "softscripts.new"));
43	}
44	librc_hidden_def(rc_runlevel_stopping)
45
46	char **rc_get_runlevels (void)
47	{
48	char **dirs = rc_ls_dir (NULL, RC_RUNLEVELDIR, 0);
49	char **runlevels = NULL;
50	int i;
51	char *dir;
52
53	STRLIST_FOREACH (dirs, dir, i) {
54	char path = rc_strcatpaths (RC_RUNLEVELDIR, dir, (char ) NULL);
55	if (rc_is_dir (path))
56	runlevels = rc_strlist_addsort (runlevels, dir);
57	free (path);
58	}
59	rc_strlist_free (dirs);
60
61	return (runlevels);
62	}
63	librc_hidden_def(rc_get_runlevels)
64
65	char *rc_get_runlevel (void)
66	{
67	FILE *fp;
68	static char buffer [PATH_MAX];
69
70	if (! (fp = fopen (SOFTLEVEL, "r"))) {
71	snprintf (buffer, sizeof (buffer), "sysinit");
72	return (buffer);
73	}
74
75	if (fgets (buffer, PATH_MAX, fp)) {
76	int i = strlen (buffer) - 1;
77	if (buffer[i] == '\n')
78	buffer[i] = 0;
79	fclose (fp);
80	return (buffer);
81	}
82
83	fclose (fp);
84	snprintf (buffer, sizeof (buffer), "sysinit");
85	return (buffer);
86	}
87	librc_hidden_def(rc_get_runlevel)
88
89	void rc_set_runlevel (const char *runlevel)
90	{
91	FILE *fp = fopen (SOFTLEVEL, "w");
92	if (! fp)
93	eerrorx ("failed to open `" SOFTLEVEL "': %s", strerror (errno));
94	fprintf (fp, "%s", runlevel);
95	fclose (fp);
96	}
97	librc_hidden_def(rc_set_runlevel)
98
99	bool rc_runlevel_exists (const char *runlevel)
100	{
101	char *path;
102	bool retval;
103
104	if (! runlevel)
105	return (false);
106
107	path = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, (char *) NULL);
108	retval = rc_is_dir (path);
109	free (path);
110	return (retval);
111	}
112	librc_hidden_def(rc_runlevel_exists)
113
114	/* Resolve a service name to it's full path */
115	char rc_resolve_service (const char service)
116	{
117	char buffer[PATH_MAX];
118	char *file;
119	int r = 0;
120
121	if (! service)
122	return (NULL);
123
124	if (service[0] == '/')
125	return (strdup (service));
126
127	file = rc_strcatpaths (RC_SVCDIR, "started", service, (char *) NULL);
128	if (! rc_is_link (file)) {
129	free (file);
130	file = rc_strcatpaths (RC_SVCDIR, "inactive", service, (char *) NULL);
131	if (! rc_is_link (file)) {
132	free (file);
133	file = NULL;
134	}
135	}
136
137	memset (buffer, 0, sizeof (buffer));
138	if (file) {
139	r = readlink (file, buffer, sizeof (buffer));
140	free (file);
141	if (r > 0)
142	return (rc_xstrdup (buffer));
143	}
144
145	snprintf (buffer, sizeof (buffer), RC_INITDIR "%s", service);
146	return (strdup (buffer));
147	}
148	librc_hidden_def(rc_resolve_service)
149
150	bool rc_service_exists (const char *service)
151	{
152	char *file;
153	bool retval = false;
154	int len;
155
156	if (! service)
157	return (false);
158
159	len = strlen (service);
160
161	/* .sh files are not init scripts */
162	if (len > 2 && service[len - 3] == '.' &&
163	service[len - 2] == 's' &&
164	service[len - 1] == 'h')
165	return (false);
166
167	file = rc_resolve_service (service);
168	if (rc_exists (file))
169	retval = rc_is_exec (file);
170	free (file);
171	return (retval);
172	}
173	librc_hidden_def(rc_service_exists)
174
175	bool rc_service_in_runlevel (const char service, const char runlevel)
176	{
177	char *file;
178	bool retval;
179	char *svc;
180
181	if (! runlevel \|\| ! service)
182	return (false);
183
184	if (! rc_service_exists (service))
185	return (false);
186
187	svc = rc_xstrdup (service);
188	file = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, basename (svc),
189	(char *) NULL);
190	free (svc);
191	retval = rc_exists (file);
192	free (file);
193
194	return (retval);
195	}
196	librc_hidden_def(rc_service_in_runlevel)
197
198	bool rc_mark_service (const char *service, const rc_service_state_t state)
199	{
200	char *file;
201	int i = 0;
202	int skip_state = -1;
203	char *base;
204	char *svc;
205	char *init = rc_resolve_service (service);
206	bool skip_wasinactive = false;
207
208	if (! service)
209	return (false);
210
211	svc = rc_xstrdup (service);
212	base = basename (svc);
213
214	if (state != rc_service_stopped) {
215	if (! rc_is_file(init)) {
216	free (init);
217	free (svc);
218	return (false);
219	}
220
221	file = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[state], base,
222	(char *) NULL);
223	if (rc_exists (file))
224	unlink (file);
225	i = symlink (init, file);
226	if (i != 0) {
227	free (file);
228	free (init);
229	free (svc);
230	einfo ("%d %s %s", state, rc_service_state_names[state], base);
231	eerror ("symlink `%s' to `%s': %s", init, file, strerror (errno));
232	return (false);
233	}
234
235	free (file);
236	skip_state = state;
237	}
238
239	if (state == rc_service_coldplugged) {
240	free (init);
241	free (svc);
242	return (true);
243	}
244
245	/* Remove any old states now */
246	i = 0;
247	while (rc_service_state_names[i]) {
248	if ((i != skip_state &&
249	i != rc_service_stopped &&
250	i != rc_service_coldplugged &&
251	i != rc_service_scheduled &&
252	i != rc_service_crashed) &&
253	(! skip_wasinactive \|\| i != rc_service_wasinactive))
254	{
255	file = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[i], base,
256	(char *) NULL);
257	if (rc_exists (file)) {
258	if ((state == rc_service_starting \|\|
259	state == rc_service_stopping) &&
260	i == rc_service_inactive)
261	{
262	char *wasfile = rc_strcatpaths (RC_SVCDIR,
263	rc_service_state_names[rc_service_wasinactive],
264	base, (char *) NULL);
265
266	if (symlink (init, wasfile) != 0)
267	eerror ("symlink `%s' to `%s': %s", init, wasfile,
268	strerror (errno));
269
270	skip_wasinactive = true;
271	free (wasfile);
272	}
273
274	errno = 0;
275	if (unlink (file) != 0 && errno != ENOENT)
276	eerror ("failed to delete `%s': %s", file,
277	strerror (errno));
278	}
279	free (file);
280	}
281	i++;
282	}
283
284	/* Remove the exclusive state if we're inactive */
285	if (state == rc_service_started \|\|
286	state == rc_service_stopped \|\|
287	state == rc_service_inactive)
288	{
289	file = rc_strcatpaths (RC_SVCDIR, "exclusive", base, (char *) NULL);
290	if (rc_exists (file))
291	if (unlink (file) != 0)
292	eerror ("unlink `%s': %s", file, strerror (errno));
293	free (file);
294	}
295
296	/* Remove any options and daemons the service may have stored */
297	if (state == rc_service_stopped) {
298	char dir = rc_strcatpaths (RC_SVCDIR, "options", base, (char ) NULL);
299
300	if (rc_is_dir (dir))
301	rc_rm_dir (dir, true);
302	free (dir);
303
304	dir = rc_strcatpaths (RC_SVCDIR, "daemons", base, (char *) NULL);
305	if (rc_is_dir (dir))
306	rc_rm_dir (dir, true);
307	free (dir);
308
309	rc_schedule_clear (service);
310	}
311
312	/* These are final states, so remove us from scheduled */
313	if (state == rc_service_started \|\| state == rc_service_stopped) {
314	char sdir = rc_strcatpaths (RC_SVCDIR, "scheduled", (char ) NULL);
315	char **dirs = rc_ls_dir (NULL, sdir, 0);
316	char *dir;
317	int serrno;
318
319	STRLIST_FOREACH (dirs, dir, i) {
320	char bdir = rc_strcatpaths (sdir, dir, (char ) NULL);
321	file = rc_strcatpaths (bdir, base, (char *) NULL);
322	if (rc_exists (file))
323	if (unlink (file) != 0)
324	eerror ("unlink `%s': %s", file, strerror (errno));
325	free (file);
326
327	/* Try and remove the dir - we don't care about errors */
328	serrno = errno;
329	rmdir (bdir);
330	errno = serrno;
331	free (bdir);
332	}
333	rc_strlist_free (dirs);
334	free (sdir);
335	}
336
337	free (svc);
338	free (init);
339	return (true);
340	}
341	librc_hidden_def(rc_mark_service)
342
343	bool rc_service_state (const char *service, const rc_service_state_t state)
344	{
345	char *file;
346	bool retval;
347	char *svc;
348
349	/* If the init script does not exist then we are stopped */
350	if (! rc_service_exists (service))
351	return (state == rc_service_stopped ? true : false);
352
353	/* We check stopped state by not being in any of the others */
354	if (state == rc_service_stopped)
355	return ( ! (rc_service_state (service, rc_service_started) \|\|
356	rc_service_state (service, rc_service_starting) \|\|
357	rc_service_state (service, rc_service_stopping) \|\|
358	rc_service_state (service, rc_service_inactive)));
359
360	/* The crashed state and scheduled states are virtual */
361	if (state == rc_service_crashed)
362	return (rc_service_daemons_crashed (service));
363	else if (state == rc_service_scheduled) {
364	char **services = rc_services_scheduled_by (service);
365	retval = (services);
366	if (services)
367	free (services);
368	return (retval);
369	}
370
371	/* Now we just check if a file by the service name rc_exists
372	in the state dir */
373	svc = rc_xstrdup (service);
374	file = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[state],
375	basename (svc), (char*) NULL);
376	free (svc);
377	retval = rc_exists (file);
378	free (file);
379	return (retval);
380	}
381	librc_hidden_def(rc_service_state)
382
383	bool rc_get_service_option (const char service, const char option,
384	char *value)
385	{
386	FILE *fp;
387	char buffer[RC_LINEBUFFER];
388	char *file = rc_strcatpaths (RC_SVCDIR, "options", service, option,
389	(char *) NULL);
390	bool retval = false;
391
392	if (rc_exists (file)) {
393	if ((fp = fopen (file, "r")) == NULL)
394	eerror ("fopen `%s': %s", file, strerror (errno));
395	else {
396	memset (buffer, 0, sizeof (buffer));
397	while (fgets (buffer, RC_LINEBUFFER, fp)) {
398	memcpy (value, buffer, strlen (buffer));
399	value += strlen (buffer);
400	}
401	fclose (fp);
402	retval = true;
403	}
404	}
405
406	free (file);
407	return (retval);
408	}
409	librc_hidden_def(rc_get_service_option)
410
411	bool rc_set_service_option (const char service, const char option,
412	const char *value)
413	{
414	FILE *fp;
415	char path = rc_strcatpaths (RC_SVCDIR, "options", service, (char ) NULL);
416	char file = rc_strcatpaths (path, option, (char ) NULL);
417	bool retval = false;
418
419	if (! rc_is_dir (path)) {
420	if (mkdir (path, 0755) != 0) {
421	eerror ("mkdir `%s': %s", path, strerror (errno));
422	free (path);
423	free (file);
424	return (false);
425	}
426	}
427
428	if ((fp = fopen (file, "w")) == NULL)
429	eerror ("fopen `%s': %s", file, strerror (errno));
430	else {
431	if (value)
432	fprintf (fp, "%s", value);
433	fclose (fp);
434	retval = true;
435	}
436
437	free (path);
438	free (file);
439	return (retval);
440	}
441	librc_hidden_def(rc_set_service_option)
442
443	static pid_t _exec_service (const char service, const char arg)
444	{
445	char *file;
446	char *fifo;
447	pid_t pid = -1;
448	char *svc;
449
450	file = rc_resolve_service (service);
451	if (! rc_is_file (file)) {
452	rc_mark_service (service, rc_service_stopped);
453	free (file);
454	return (0);
455	}
456
457	/* We create a fifo so that other services can wait until we complete */
458	svc = rc_xstrdup (service);
459	fifo = rc_strcatpaths (RC_SVCDIR, "exclusive", basename (svc),
460	(char *) NULL);
461	free (svc);
462
463	if (mkfifo (fifo, 0600) != 0 && errno != EEXIST) {
464	eerror ("unable to create fifo `%s': %s", fifo, strerror (errno));
465	free (fifo);
466	free (file);
467	return (-1);
468	}
469
470	if ((pid = vfork ()) == 0) {
471	execl (file, file, arg, (char *) NULL);
472	eerror ("unable to exec `%s': %s", file, strerror (errno));
473	unlink (fifo);
474	_exit (EXIT_FAILURE);
475	}
476
477	free (fifo);
478	free (file);
479
480	if (pid == -1)
481	eerror ("vfork: %s", strerror (errno));
482
483	return (pid);
484	}
485
486	int rc_waitpid (pid_t pid) {
487	int status = 0;
488	pid_t savedpid = pid;
489
490	errno = 0;
491	do {
492	pid = waitpid (savedpid, &status, 0);
493	if (pid < 0) {
494	if (errno != ECHILD)
495	eerror ("waitpid %d: %s", savedpid, strerror (errno));
496	return (-1);
497	}
498	} while (! WIFEXITED (status) && ! WIFSIGNALED (status));
499
500	return (WIFEXITED (status) ? WEXITSTATUS (status) : EXIT_FAILURE);
501	}
502
503	pid_t rc_stop_service (const char *service)
504	{
505	if (rc_service_state (service, rc_service_stopped))
506	return (0);
507
508	return (_exec_service (service, "stop"));
509	}
510	librc_hidden_def(rc_stop_service)
511
512	pid_t rc_start_service (const char *service)
513	{
514	if (! rc_service_state (service, rc_service_stopped))
515	return (0);
516
517	return (_exec_service (service, "start"));
518	}
519	librc_hidden_def(rc_start_service)
520
521	void rc_schedule_start_service (const char *service,
522	const char *service_to_start)
523	{
524	char *dir;
525	char *init;
526	char *file;
527	char *svc;
528
529	/* service may be a provided service, like net */
530	if (! service \|\| ! rc_service_exists (service_to_start))
531	return;
532
533	svc = rc_xstrdup (service);
534	dir = rc_strcatpaths (RC_SVCDIR, "scheduled", basename (svc),
535	(char *) NULL);
536	free (svc);
537	if (! rc_is_dir (dir))
538	if (mkdir (dir, 0755) != 0) {
539	eerror ("mkdir `%s': %s", dir, strerror (errno));
540	free (dir);
541	return;
542	}
543
544	init = rc_resolve_service (service_to_start);
545	svc = rc_xstrdup (service_to_start);
546	file = rc_strcatpaths (dir, basename (svc), (char *) NULL);
547	free (svc);
548	if (! rc_exists (file) && symlink (init, file) != 0)
549	eerror ("symlink `%s' to `%s': %s", init, file, strerror (errno));
550
551	free (init);
552	free (file);
553	free (dir);
554	}
555	librc_hidden_def(rc_schedule_start_service)
556
557	void rc_schedule_clear (const char *service)
558	{
559	char *svc = rc_xstrdup (service);
560	char *dir = rc_strcatpaths (RC_SVCDIR, "scheduled", basename (svc),
561	(char *) NULL);
562
563	free (svc);
564	if (rc_is_dir (dir))
565	rc_rm_dir (dir, true);
566	free (dir);
567	}
568	librc_hidden_def(rc_schedule_clear)
569
570	bool rc_wait_service (const char *service)
571	{
572	char *svc = rc_xstrdup (service);
573	char *fifo = rc_strcatpaths (RC_SVCDIR, "exclusive", basename (svc),
574	(char *) NULL);
575	struct timeval tv;
576	struct timeval stopat;
577	struct timeval now;
578	bool retval = false;
579
580	free (svc);
581	if (gettimeofday (&stopat, NULL) != 0) {
582	eerror ("gettimeofday: %s", strerror (errno));
583	return (false);
584	}
585	stopat.tv_sec += WAIT_MAX;
586
587	while (true) {
588	if (! rc_exists (fifo)) {
589	retval = true;
590	break;
591	}
592
593	tv.tv_sec = 0;
594	tv.tv_usec = WAIT_INTERVAL;
595	if (select (0, 0, 0, 0, &tv) < 0) {
596	if (errno != EINTR) {
597	eerror ("select: %s",strerror (errno));
598	break;
599	}
600	}
601
602	/* Don't hang around forever */
603	if (gettimeofday (&now, NULL) != 0) {
604	eerror ("gettimeofday: %s", strerror (errno));
605	break;
606	}
607
608	if (timercmp (&now, &stopat, >))
609	break;
610	}
611
612	free (fifo);
613	return (retval);
614	}
615	librc_hidden_def(rc_wait_service)
616
617	char *rc_services_in_runlevel (const char runlevel)
618	{
619	char *dir;
620	char **list = NULL;
621
622	if (! runlevel)
623	return (rc_ls_dir (NULL, RC_INITDIR, RC_LS_INITD));
624
625	/* These special levels never contain any services */
626	if (strcmp (runlevel, RC_LEVEL_SYSINIT) == 0 \|\|
627	strcmp (runlevel, RC_LEVEL_SINGLE) == 0)
628	return (NULL);
629
630	dir = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, (char *) NULL);
631	if (! rc_is_dir (dir))
632	eerror ("runlevel `%s' does not exist", runlevel);
633	else
634	list = rc_ls_dir (list, dir, RC_LS_INITD);
635
636	free (dir);
637	return (list);
638	}
639	librc_hidden_def(rc_services_in_runlevel)
640
641	char **rc_services_in_state (rc_service_state_t state)
642	{
643	char *dir = rc_strcatpaths (RC_SVCDIR, rc_service_state_names[state],
644	(char *) NULL);
645	char **list = NULL;
646
647	if (state == rc_service_scheduled) {
648	char **dirs = rc_ls_dir (NULL, dir, 0);
649	char *d;
650	int i;
651
652	STRLIST_FOREACH (dirs, d, i) {
653	char p = rc_strcatpaths (dir, d, (char ) NULL);
654	char **entries = rc_ls_dir (NULL, p, RC_LS_INITD);
655	char *e;
656	int j;
657
658	STRLIST_FOREACH (entries, e, j)
659	list = rc_strlist_addsortu (list, e);
660
661	if (entries)
662	free (entries);
663	}
664
665	if (dirs)
666	free (dirs);
667	} else {
668	if (rc_is_dir (dir))
669	list = rc_ls_dir (list, dir, RC_LS_INITD);
670	}
671
672	free (dir);
673	return (list);
674	}
675	librc_hidden_def(rc_services_in_state)
676
677	bool rc_service_add (const char runlevel, const char service)
678	{
679	bool retval;
680	char *init;
681	char *file;
682	char *svc;
683
684	if (! rc_runlevel_exists (runlevel)) {
685	errno = ENOENT;
686	return (false);
687	}
688
689	if (rc_service_in_runlevel (service, runlevel)) {
690	errno = EEXIST;
691	return (false);
692	}
693
694	init = rc_resolve_service (service);
695	svc = rc_xstrdup (service);
696	file = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, basename (svc),
697	(char *) NULL);
698	free (svc);
699	retval = (symlink (init, file) == 0);
700	free (init);
701	free (file);
702	return (retval);
703	}
704	librc_hidden_def(rc_service_add)
705
706	bool rc_service_delete (const char runlevel, const char service)
707	{
708	char *file;
709	char *svc;
710	bool retval = false;
711
712	if (! runlevel \|\| ! service)
713	return (false);
714
715	svc = rc_xstrdup (service);
716	file = rc_strcatpaths (RC_RUNLEVELDIR, runlevel, basename (svc),
717	(char *) NULL);
718	free (svc);
719	if (unlink (file) == 0)
720	retval = true;
721
722	free (file);
723	return (retval);
724	}
725	librc_hidden_def(rc_service_delete)
726
727	char *rc_services_scheduled_by (const char service)
728	{
729	char **dirs = rc_ls_dir (NULL, RC_SVCDIR "scheduled", 0);
730	char **list = NULL;
731	char *dir;
732	int i;
733
734	STRLIST_FOREACH (dirs, dir, i) {
735	char *file = rc_strcatpaths (RC_SVCDIR "scheduled", dir, service,
736	(char *) NULL);
737	if (rc_exists (file))
738	list = rc_strlist_add (list, file);
739	free (file);
740	}
741	rc_strlist_free (dirs);
742
743	return (list);
744	}
745	librc_hidden_def(rc_services_scheduled_by)
746
747	char *rc_services_scheduled (const char service)
748	{
749	char *svc = rc_xstrdup (service);
750	char *dir = rc_strcatpaths (RC_SVCDIR, "scheduled", basename (svc),
751	(char *) NULL);
752	char **list = NULL;
753
754	if (rc_is_dir (dir))
755	list = rc_ls_dir (list, dir, RC_LS_INITD);
756
757	free (svc);
758	free (dir);
759	return (list);
760	}
761	librc_hidden_def(rc_services_scheduled)
762
763	bool rc_allow_plug (char *service)
764	{
765	char *list;
766	char *p;
767	char *star;
768	char *token;
769	bool allow = true;
770	char *match = getenv ("RC_PLUG_SERVICES");
771	if (! match)
772	return true;
773
774	list = rc_xstrdup (match);
775	p = list;
776	while ((token = strsep (&p, " "))) {
777	bool truefalse = true;
778	if (token[0] == '!') {
779	truefalse = false;
780	token++;
781	}
782
783	star = strchr (token, '*');
784	if (star) {
785	if (strncmp (service, token, star - token) == 0) {
786	allow = truefalse;
787	break;
788	}
789	} else {
790	if (strcmp (service, token) == 0) {
791	allow = truefalse;
792	break;
793	}
794	}
795	}
796
797	free (list);
798	return (allow);
799	}
800	librc_hidden_def(rc_allow_plug)