[systemd.git] / src / basic / unit-name.h

#pragma once

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdbool.h>

#include "macro.h"

#define UNIT_NAME_MAX 256

typedef enum UnitType {
        UNIT_SERVICE = 0,
        UNIT_SOCKET,
        UNIT_BUSNAME,
        UNIT_TARGET,
        UNIT_DEVICE,
        UNIT_MOUNT,
        UNIT_AUTOMOUNT,
        UNIT_SWAP,
        UNIT_TIMER,
        UNIT_PATH,
        UNIT_SLICE,
        UNIT_SCOPE,
        _UNIT_TYPE_MAX,
        _UNIT_TYPE_INVALID = -1
} UnitType;

typedef enum UnitLoadState {
        UNIT_STUB = 0,
        UNIT_LOADED,
        UNIT_NOT_FOUND,
        UNIT_ERROR,
        UNIT_MERGED,
        UNIT_MASKED,
        _UNIT_LOAD_STATE_MAX,
        _UNIT_LOAD_STATE_INVALID = -1
} UnitLoadState;

typedef enum UnitActiveState {
        UNIT_ACTIVE,
        UNIT_RELOADING,
        UNIT_INACTIVE,
        UNIT_FAILED,
        UNIT_ACTIVATING,
        UNIT_DEACTIVATING,
        _UNIT_ACTIVE_STATE_MAX,
        _UNIT_ACTIVE_STATE_INVALID = -1
} UnitActiveState;

typedef enum AutomountState {
        AUTOMOUNT_DEAD,
        AUTOMOUNT_WAITING,
        AUTOMOUNT_RUNNING,
        AUTOMOUNT_FAILED,
        _AUTOMOUNT_STATE_MAX,
        _AUTOMOUNT_STATE_INVALID = -1
} AutomountState;

typedef enum BusNameState {
        BUSNAME_DEAD,
        BUSNAME_MAKING,
        BUSNAME_REGISTERED,
        BUSNAME_LISTENING,
        BUSNAME_RUNNING,
        BUSNAME_SIGTERM,
        BUSNAME_SIGKILL,
        BUSNAME_FAILED,
        _BUSNAME_STATE_MAX,
        _BUSNAME_STATE_INVALID = -1
} BusNameState;

/* We simply watch devices, we cannot plug/unplug them. That
 * simplifies the state engine greatly */
typedef enum DeviceState {
        DEVICE_DEAD,
        DEVICE_TENTATIVE, /* mounted or swapped, but not (yet) announced by udev */
        DEVICE_PLUGGED,   /* announced by udev */
        _DEVICE_STATE_MAX,
        _DEVICE_STATE_INVALID = -1
} DeviceState;

typedef enum MountState {
        MOUNT_DEAD,
        MOUNT_MOUNTING,               /* /usr/bin/mount is running, but the mount is not done yet. */
        MOUNT_MOUNTING_DONE,          /* /usr/bin/mount is running, and the mount is done. */
        MOUNT_MOUNTED,
        MOUNT_REMOUNTING,
        MOUNT_UNMOUNTING,
        MOUNT_MOUNTING_SIGTERM,
        MOUNT_MOUNTING_SIGKILL,
        MOUNT_REMOUNTING_SIGTERM,
        MOUNT_REMOUNTING_SIGKILL,
        MOUNT_UNMOUNTING_SIGTERM,
        MOUNT_UNMOUNTING_SIGKILL,
        MOUNT_FAILED,
        _MOUNT_STATE_MAX,
        _MOUNT_STATE_INVALID = -1
} MountState;

typedef enum PathState {
        PATH_DEAD,
        PATH_WAITING,
        PATH_RUNNING,
        PATH_FAILED,
        _PATH_STATE_MAX,
        _PATH_STATE_INVALID = -1
} PathState;

typedef enum ScopeState {
        SCOPE_DEAD,
        SCOPE_RUNNING,
        SCOPE_ABANDONED,
        SCOPE_STOP_SIGTERM,
        SCOPE_STOP_SIGKILL,
        SCOPE_FAILED,
        _SCOPE_STATE_MAX,
        _SCOPE_STATE_INVALID = -1
} ScopeState;

typedef enum ServiceState {
        SERVICE_DEAD,
        SERVICE_START_PRE,
        SERVICE_START,
        SERVICE_START_POST,
        SERVICE_RUNNING,
        SERVICE_EXITED,            /* Nothing is running anymore, but RemainAfterExit is true hence this is OK */
        SERVICE_RELOAD,
        SERVICE_STOP,              /* No STOP_PRE state, instead just register multiple STOP executables */
        SERVICE_STOP_SIGABRT,      /* Watchdog timeout */
        SERVICE_STOP_SIGTERM,
        SERVICE_STOP_SIGKILL,
        SERVICE_STOP_POST,
        SERVICE_FINAL_SIGTERM,     /* In case the STOP_POST executable hangs, we shoot that down, too */
        SERVICE_FINAL_SIGKILL,
        SERVICE_FAILED,
        SERVICE_AUTO_RESTART,
        _SERVICE_STATE_MAX,
        _SERVICE_STATE_INVALID = -1
} ServiceState;

typedef enum SliceState {
        SLICE_DEAD,
        SLICE_ACTIVE,
        _SLICE_STATE_MAX,
        _SLICE_STATE_INVALID = -1
} SliceState;

typedef enum SocketState {
        SOCKET_DEAD,
        SOCKET_START_PRE,
        SOCKET_START_CHOWN,
        SOCKET_START_POST,
        SOCKET_LISTENING,
        SOCKET_RUNNING,
        SOCKET_STOP_PRE,
        SOCKET_STOP_PRE_SIGTERM,
        SOCKET_STOP_PRE_SIGKILL,
        SOCKET_STOP_POST,
        SOCKET_FINAL_SIGTERM,
        SOCKET_FINAL_SIGKILL,
        SOCKET_FAILED,
        _SOCKET_STATE_MAX,
        _SOCKET_STATE_INVALID = -1
} SocketState;

typedef enum SwapState {
        SWAP_DEAD,
        SWAP_ACTIVATING,               /* /sbin/swapon is running, but the swap not yet enabled. */
        SWAP_ACTIVATING_DONE,          /* /sbin/swapon is running, and the swap is done. */
        SWAP_ACTIVE,
        SWAP_DEACTIVATING,
        SWAP_ACTIVATING_SIGTERM,
        SWAP_ACTIVATING_SIGKILL,
        SWAP_DEACTIVATING_SIGTERM,
        SWAP_DEACTIVATING_SIGKILL,
        SWAP_FAILED,
        _SWAP_STATE_MAX,
        _SWAP_STATE_INVALID = -1
} SwapState;


typedef enum TargetState {
        TARGET_DEAD,
        TARGET_ACTIVE,
        _TARGET_STATE_MAX,
        _TARGET_STATE_INVALID = -1
} TargetState;

typedef enum TimerState {
        TIMER_DEAD,
        TIMER_WAITING,
        TIMER_RUNNING,
        TIMER_ELAPSED,
        TIMER_FAILED,
        _TIMER_STATE_MAX,
        _TIMER_STATE_INVALID = -1
} TimerState;

typedef enum UnitDependency {
        /* Positive dependencies */
        UNIT_REQUIRES,
        UNIT_REQUISITE,
        UNIT_WANTS,
        UNIT_BINDS_TO,
        UNIT_PART_OF,

        /* Inverse of the above */
        UNIT_REQUIRED_BY,             /* inverse of 'requires' is 'required_by' */
        UNIT_REQUISITE_OF,            /* inverse of 'requisite' is 'requisite_of' */
        UNIT_WANTED_BY,               /* inverse of 'wants' */
        UNIT_BOUND_BY,                /* inverse of 'binds_to' */
        UNIT_CONSISTS_OF,             /* inverse of 'part_of' */

        /* Negative dependencies */
        UNIT_CONFLICTS,               /* inverse of 'conflicts' is 'conflicted_by' */
        UNIT_CONFLICTED_BY,

        /* Order */
        UNIT_BEFORE,                  /* inverse of 'before' is 'after' and vice versa */
        UNIT_AFTER,

        /* On Failure */
        UNIT_ON_FAILURE,

        /* Triggers (i.e. a socket triggers a service) */
        UNIT_TRIGGERS,
        UNIT_TRIGGERED_BY,

        /* Propagate reloads */
        UNIT_PROPAGATES_RELOAD_TO,
        UNIT_RELOAD_PROPAGATED_FROM,

        /* Joins namespace of */
        UNIT_JOINS_NAMESPACE_OF,

        /* Reference information for GC logic */
        UNIT_REFERENCES,              /* Inverse of 'references' is 'referenced_by' */
        UNIT_REFERENCED_BY,

        _UNIT_DEPENDENCY_MAX,
        _UNIT_DEPENDENCY_INVALID = -1
} UnitDependency;

typedef enum UnitNameFlags {
        UNIT_NAME_PLAIN = 1,      /* Allow foo.service */
        UNIT_NAME_INSTANCE = 2,   /* Allow foo@bar.service */
        UNIT_NAME_TEMPLATE = 4,   /* Allow foo@.service */
        UNIT_NAME_ANY = UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE|UNIT_NAME_TEMPLATE,
} UnitNameFlags;

bool unit_name_is_valid(const char *n, UnitNameFlags flags) _pure_;
bool unit_prefix_is_valid(const char *p) _pure_;
bool unit_instance_is_valid(const char *i) _pure_;
bool unit_suffix_is_valid(const char *s) _pure_;

static inline int unit_prefix_and_instance_is_valid(const char *p) {
        /* For prefix+instance and instance the same rules apply */
        return unit_instance_is_valid(p);
}

int unit_name_to_prefix(const char *n, char **prefix);
int unit_name_to_instance(const char *n, char **instance);
int unit_name_to_prefix_and_instance(const char *n, char **ret);

UnitType unit_name_to_type(const char *n) _pure_;

int unit_name_change_suffix(const char *n, const char *suffix, char **ret);

int unit_name_build(const char *prefix, const char *instance, const char *suffix, char **ret);

char *unit_name_escape(const char *f);
int unit_name_unescape(const char *f, char **ret);
int unit_name_path_escape(const char *f, char **ret);
int unit_name_path_unescape(const char *f, char **ret);

int unit_name_replace_instance(const char *f, const char *i, char **ret);

int unit_name_template(const char *f, char **ret);

int unit_name_from_path(const char *path, const char *suffix, char **ret);
int unit_name_from_path_instance(const char *prefix, const char *path, const char *suffix, char **ret);
int unit_name_to_path(const char *name, char **ret);

char *unit_dbus_path_from_name(const char *name);
int unit_name_from_dbus_path(const char *path, char **name);

const char* unit_dbus_interface_from_type(UnitType t);
const char *unit_dbus_interface_from_name(const char *name);

typedef enum UnitNameMangle {
        UNIT_NAME_NOGLOB,
        UNIT_NAME_GLOB,
} UnitNameMangle;

int unit_name_mangle_with_suffix(const char *name, UnitNameMangle allow_globs, const char *suffix, char **ret);

static inline int unit_name_mangle(const char *name, UnitNameMangle allow_globs, char **ret) {
        return unit_name_mangle_with_suffix(name, allow_globs, ".service", ret);
}

int slice_build_parent_slice(const char *slice, char **ret);
int slice_build_subslice(const char *slice, const char*name, char **subslice);
bool slice_name_is_valid(const char *name);

const char *unit_type_to_string(UnitType i) _const_;
UnitType unit_type_from_string(const char *s) _pure_;

const char *unit_load_state_to_string(UnitLoadState i) _const_;
UnitLoadState unit_load_state_from_string(const char *s) _pure_;

const char *unit_active_state_to_string(UnitActiveState i) _const_;
UnitActiveState unit_active_state_from_string(const char *s) _pure_;

const char* automount_state_to_string(AutomountState i) _const_;
AutomountState automount_state_from_string(const char *s) _pure_;

const char* busname_state_to_string(BusNameState i) _const_;
BusNameState busname_state_from_string(const char *s) _pure_;

const char* device_state_to_string(DeviceState i) _const_;
DeviceState device_state_from_string(const char *s) _pure_;

const char* mount_state_to_string(MountState i) _const_;
MountState mount_state_from_string(const char *s) _pure_;

const char* path_state_to_string(PathState i) _const_;
PathState path_state_from_string(const char *s) _pure_;

const char* scope_state_to_string(ScopeState i) _const_;
ScopeState scope_state_from_string(const char *s) _pure_;

const char* service_state_to_string(ServiceState i) _const_;
ServiceState service_state_from_string(const char *s) _pure_;

const char* slice_state_to_string(SliceState i) _const_;
SliceState slice_state_from_string(const char *s) _pure_;

const char* socket_state_to_string(SocketState i) _const_;
SocketState socket_state_from_string(const char *s) _pure_;

const char* swap_state_to_string(SwapState i) _const_;
SwapState swap_state_from_string(const char *s) _pure_;

const char* target_state_to_string(TargetState i) _const_;
TargetState target_state_from_string(const char *s) _pure_;

const char *timer_state_to_string(TimerState i) _const_;
TimerState timer_state_from_string(const char *s) _pure_;

const char *unit_dependency_to_string(UnitDependency i) _const_;
UnitDependency unit_dependency_from_string(const char *s) _pure_;
Commit	Line	Data
663996b3 MS	1	#pragma once
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <stdbool.h>
	23
	24	#include "macro.h"
	25
	26	#define UNIT_NAME_MAX 256
	27
6300502b	28	typedef enum UnitType {
663996b3 MS	29	UNIT_SERVICE = 0,
663996b3 MS	30	UNIT_SOCKET,
60f067b4	31	UNIT_BUSNAME,
663996b3 MS	32	UNIT_TARGET,
	33	UNIT_DEVICE,
	34	UNIT_MOUNT,
	35	UNIT_AUTOMOUNT,
663996b3	36	UNIT_SWAP,
60f067b4	37	UNIT_TIMER,
663996b3	38	UNIT_PATH,
14228c0d MB	39	UNIT_SLICE,
14228c0d MB	40	UNIT_SCOPE,
663996b3 MS	41	_UNIT_TYPE_MAX,
663996b3 MS	42	_UNIT_TYPE_INVALID = -1
6300502b	43	} UnitType;
663996b3	44
6300502b	45	typedef enum UnitLoadState {
663996b3 MS	46	UNIT_STUB = 0,
663996b3 MS	47	UNIT_LOADED,
14228c0d	48	UNIT_NOT_FOUND,
663996b3 MS	49	UNIT_ERROR,
	50	UNIT_MERGED,
	51	UNIT_MASKED,
	52	_UNIT_LOAD_STATE_MAX,
	53	_UNIT_LOAD_STATE_INVALID = -1
6300502b MP	54	} UnitLoadState;
	55
	56	typedef enum UnitActiveState {
	57	UNIT_ACTIVE,
	58	UNIT_RELOADING,
	59	UNIT_INACTIVE,
	60	UNIT_FAILED,
	61	UNIT_ACTIVATING,
	62	UNIT_DEACTIVATING,
	63	_UNIT_ACTIVE_STATE_MAX,
	64	_UNIT_ACTIVE_STATE_INVALID = -1
	65	} UnitActiveState;
	66
	67	typedef enum AutomountState {
	68	AUTOMOUNT_DEAD,
	69	AUTOMOUNT_WAITING,
	70	AUTOMOUNT_RUNNING,
	71	AUTOMOUNT_FAILED,
	72	_AUTOMOUNT_STATE_MAX,
	73	_AUTOMOUNT_STATE_INVALID = -1
	74	} AutomountState;
	75
	76	typedef enum BusNameState {
	77	BUSNAME_DEAD,
	78	BUSNAME_MAKING,
	79	BUSNAME_REGISTERED,
	80	BUSNAME_LISTENING,
	81	BUSNAME_RUNNING,
	82	BUSNAME_SIGTERM,
	83	BUSNAME_SIGKILL,
	84	BUSNAME_FAILED,
	85	_BUSNAME_STATE_MAX,
	86	_BUSNAME_STATE_INVALID = -1
	87	} BusNameState;
	88
	89	/* We simply watch devices, we cannot plug/unplug them. That
	90	* simplifies the state engine greatly */
	91	typedef enum DeviceState {
	92	DEVICE_DEAD,
	93	DEVICE_TENTATIVE, /* mounted or swapped, but not (yet) announced by udev */
	94	DEVICE_PLUGGED, /* announced by udev */
	95	_DEVICE_STATE_MAX,
	96	_DEVICE_STATE_INVALID = -1
	97	} DeviceState;
	98
	99	typedef enum MountState {
	100	MOUNT_DEAD,
	101	MOUNT_MOUNTING, /* /usr/bin/mount is running, but the mount is not done yet. */
	102	MOUNT_MOUNTING_DONE, /* /usr/bin/mount is running, and the mount is done. */
	103	MOUNT_MOUNTED,
	104	MOUNT_REMOUNTING,
	105	MOUNT_UNMOUNTING,
	106	MOUNT_MOUNTING_SIGTERM,
	107	MOUNT_MOUNTING_SIGKILL,
	108	MOUNT_REMOUNTING_SIGTERM,
	109	MOUNT_REMOUNTING_SIGKILL,
	110	MOUNT_UNMOUNTING_SIGTERM,
	111	MOUNT_UNMOUNTING_SIGKILL,
	112	MOUNT_FAILED,
	113	_MOUNT_STATE_MAX,
	114	_MOUNT_STATE_INVALID = -1
	115	} MountState;
	116
	117	typedef enum PathState {
118	PATH_DEAD,
119	PATH_WAITING,
120	PATH_RUNNING,
121	PATH_FAILED,
122	_PATH_STATE_MAX,
123	_PATH_STATE_INVALID = -1
124	} PathState;
125
126	typedef enum ScopeState {
127	SCOPE_DEAD,
128	SCOPE_RUNNING,
129	SCOPE_ABANDONED,
130	SCOPE_STOP_SIGTERM,
131	SCOPE_STOP_SIGKILL,
132	SCOPE_FAILED,
133	_SCOPE_STATE_MAX,
134	_SCOPE_STATE_INVALID = -1
135	} ScopeState;
136
137	typedef enum ServiceState {
138	SERVICE_DEAD,
139	SERVICE_START_PRE,
140	SERVICE_START,
141	SERVICE_START_POST,
142	SERVICE_RUNNING,
143	SERVICE_EXITED, /* Nothing is running anymore, but RemainAfterExit is true hence this is OK */
144	SERVICE_RELOAD,
145	SERVICE_STOP, /* No STOP_PRE state, instead just register multiple STOP executables */
146	SERVICE_STOP_SIGABRT, /* Watchdog timeout */
147	SERVICE_STOP_SIGTERM,
148	SERVICE_STOP_SIGKILL,
149	SERVICE_STOP_POST,
150	SERVICE_FINAL_SIGTERM, /* In case the STOP_POST executable hangs, we shoot that down, too */
151	SERVICE_FINAL_SIGKILL,
152	SERVICE_FAILED,
153	SERVICE_AUTO_RESTART,
154	_SERVICE_STATE_MAX,
155	_SERVICE_STATE_INVALID = -1
156	} ServiceState;
157
158	typedef enum SliceState {
159	SLICE_DEAD,
160	SLICE_ACTIVE,
161	_SLICE_STATE_MAX,
162	_SLICE_STATE_INVALID = -1
163	} SliceState;
164
6300502b MP	165	typedef enum SocketState {
	166	SOCKET_DEAD,
	167	SOCKET_START_PRE,
	168	SOCKET_START_CHOWN,
	169	SOCKET_START_POST,
	170	SOCKET_LISTENING,
	171	SOCKET_RUNNING,
	172	SOCKET_STOP_PRE,
	173	SOCKET_STOP_PRE_SIGTERM,
	174	SOCKET_STOP_PRE_SIGKILL,
	175	SOCKET_STOP_POST,
	176	SOCKET_FINAL_SIGTERM,
	177	SOCKET_FINAL_SIGKILL,
	178	SOCKET_FAILED,
	179	_SOCKET_STATE_MAX,
	180	_SOCKET_STATE_INVALID = -1
	181	} SocketState;
	182
	183	typedef enum SwapState {
	184	SWAP_DEAD,
	185	SWAP_ACTIVATING, /* /sbin/swapon is running, but the swap not yet enabled. */
	186	SWAP_ACTIVATING_DONE, /* /sbin/swapon is running, and the swap is done. */
	187	SWAP_ACTIVE,
	188	SWAP_DEACTIVATING,
	189	SWAP_ACTIVATING_SIGTERM,
	190	SWAP_ACTIVATING_SIGKILL,
	191	SWAP_DEACTIVATING_SIGTERM,
	192	SWAP_DEACTIVATING_SIGKILL,
	193	SWAP_FAILED,
	194	_SWAP_STATE_MAX,
	195	_SWAP_STATE_INVALID = -1
	196	} SwapState;
	197
	198
	199	typedef enum TargetState {
	200	TARGET_DEAD,
	201	TARGET_ACTIVE,
	202	_TARGET_STATE_MAX,
	203	_TARGET_STATE_INVALID = -1
	204	} TargetState;
	205
	206	typedef enum TimerState {
	207	TIMER_DEAD,
	208	TIMER_WAITING,
	209	TIMER_RUNNING,
	210	TIMER_ELAPSED,
	211	TIMER_FAILED,
	212	_TIMER_STATE_MAX,
	213	_TIMER_STATE_INVALID = -1
	214	} TimerState;
	215
	216	typedef enum UnitDependency {
5eef597e MP	217	/* Positive dependencies */
5eef597e MP	218	UNIT_REQUIRES,
5eef597e	219	UNIT_REQUISITE,
5eef597e MP	220	UNIT_WANTS,
	221	UNIT_BINDS_TO,
	222	UNIT_PART_OF,
	223
	224	/* Inverse of the above */
e3bff60a	225	UNIT_REQUIRED_BY, /* inverse of 'requires' is 'required_by' */
e3bff60a	226	UNIT_REQUISITE_OF, /* inverse of 'requisite' is 'requisite_of' */
5eef597e MP	227	UNIT_WANTED_BY, /* inverse of 'wants' */
	228	UNIT_BOUND_BY, /* inverse of 'binds_to' */
	229	UNIT_CONSISTS_OF, /* inverse of 'part_of' */
	230
	231	/* Negative dependencies */
	232	UNIT_CONFLICTS, /* inverse of 'conflicts' is 'conflicted_by' */
	233	UNIT_CONFLICTED_BY,
	234
	235	/* Order */
	236	UNIT_BEFORE, /* inverse of 'before' is 'after' and vice versa */
	237	UNIT_AFTER,
	238
	239	/* On Failure */
	240	UNIT_ON_FAILURE,
	241
	242	/* Triggers (i.e. a socket triggers a service) */
	243	UNIT_TRIGGERS,
	244	UNIT_TRIGGERED_BY,
	245
	246	/* Propagate reloads */
	247	UNIT_PROPAGATES_RELOAD_TO,
	248	UNIT_RELOAD_PROPAGATED_FROM,
	249
	250	/* Joins namespace of */
	251	UNIT_JOINS_NAMESPACE_OF,
	252
	253	/* Reference information for GC logic */
	254	UNIT_REFERENCES, /* Inverse of 'references' is 'referenced_by' */
	255	UNIT_REFERENCED_BY,
	256
	257	_UNIT_DEPENDENCY_MAX,
	258	_UNIT_DEPENDENCY_INVALID = -1
6300502b	259	} UnitDependency;
5eef597e	260
e3bff60a MP	261	typedef enum UnitNameFlags {
	262	UNIT_NAME_PLAIN = 1, /* Allow foo.service */
	263	UNIT_NAME_INSTANCE = 2, /* Allow foo@bar.service */
	264	UNIT_NAME_TEMPLATE = 4, /* Allow foo@.service */
	265	UNIT_NAME_ANY = UNIT_NAME_PLAIN\|UNIT_NAME_INSTANCE\|UNIT_NAME_TEMPLATE,
	266	} UnitNameFlags;
663996b3	267
e3bff60a	268	bool unit_name_is_valid(const char *n, UnitNameFlags flags) _pure_;
663996b3 MS	269	bool unit_prefix_is_valid(const char *p) _pure_;
663996b3 MS	270	bool unit_instance_is_valid(const char *i) _pure_;
e3bff60a MP	271	bool unit_suffix_is_valid(const char *s) _pure_;
	272
	273	static inline int unit_prefix_and_instance_is_valid(const char *p) {
	274	/* For prefix+instance and instance the same rules apply */
	275	return unit_instance_is_valid(p);
	276	}
	277
	278	int unit_name_to_prefix(const char n, char *prefix);
	279	int unit_name_to_instance(const char n, char *instance);
	280	int unit_name_to_prefix_and_instance(const char n, char *ret);
663996b3 MS	281
	282	UnitType unit_name_to_type(const char *n) _pure_;
	283
e3bff60a	284	int unit_name_change_suffix(const char n, const char suffix, char **ret);
663996b3	285
e3bff60a	286	int unit_name_build(const char prefix, const char instance, const char suffix, char *ret);
663996b3 MS	287
663996b3 MS	288	char unit_name_escape(const char f);
e3bff60a MP	289	int unit_name_unescape(const char f, char *ret);
	290	int unit_name_path_escape(const char f, char *ret);
	291	int unit_name_path_unescape(const char f, char *ret);
663996b3	292
e3bff60a	293	int unit_name_replace_instance(const char f, const char i, char **ret);
663996b3	294
e3bff60a	295	int unit_name_template(const char f, char *ret);
663996b3	296
e3bff60a MP	297	int unit_name_from_path(const char path, const char suffix, char **ret);
	298	int unit_name_from_path_instance(const char prefix, const char path, const char suffix, char *ret);
	299	int unit_name_to_path(const char name, char *ret);
663996b3 MS	300
663996b3 MS	301	char unit_dbus_path_from_name(const char name);
14228c0d	302	int unit_name_from_dbus_path(const char path, char *name);
663996b3	303
d9dfd233 MP	304	const char* unit_dbus_interface_from_type(UnitType t);
	305	const char unit_dbus_interface_from_name(const char name);
	306
e3bff60a MP	307	typedef enum UnitNameMangle {
	308	UNIT_NAME_NOGLOB,
	309	UNIT_NAME_GLOB,
	310	} UnitNameMangle;
	311
	312	int unit_name_mangle_with_suffix(const char name, UnitNameMangle allow_globs, const char suffix, char **ret);
60f067b4	313
e3bff60a MP	314	static inline int unit_name_mangle(const char name, UnitNameMangle allow_globs, char *ret) {
e3bff60a MP	315	return unit_name_mangle_with_suffix(name, allow_globs, ".service", ret);
f47781d8	316	}
14228c0d	317
e3bff60a MP	318	int slice_build_parent_slice(const char slice, char *ret);
	319	int slice_build_subslice(const char slice, const charname, char **subslice);
	320	bool slice_name_is_valid(const char *name);
	321
	322	const char *unit_type_to_string(UnitType i) _const_;
	323	UnitType unit_type_from_string(const char *s) _pure_;
	324
	325	const char *unit_load_state_to_string(UnitLoadState i) _const_;
	326	UnitLoadState unit_load_state_from_string(const char *s) _pure_;
5eef597e	327
6300502b MP	328	const char *unit_active_state_to_string(UnitActiveState i) _const_;
	329	UnitActiveState unit_active_state_from_string(const char *s) _pure_;
	330
	331	const char* automount_state_to_string(AutomountState i) _const_;
	332	AutomountState automount_state_from_string(const char *s) _pure_;
	333
	334	const char* busname_state_to_string(BusNameState i) _const_;
	335	BusNameState busname_state_from_string(const char *s) _pure_;
	336
	337	const char* device_state_to_string(DeviceState i) _const_;
	338	DeviceState device_state_from_string(const char *s) _pure_;
	339
	340	const char* mount_state_to_string(MountState i) _const_;
	341	MountState mount_state_from_string(const char *s) _pure_;
	342
	343	const char* path_state_to_string(PathState i) _const_;
	344	PathState path_state_from_string(const char *s) _pure_;
	345
	346	const char* scope_state_to_string(ScopeState i) _const_;
	347	ScopeState scope_state_from_string(const char *s) _pure_;
	348
	349	const char* service_state_to_string(ServiceState i) _const_;
	350	ServiceState service_state_from_string(const char *s) _pure_;
	351
	352	const char* slice_state_to_string(SliceState i) _const_;
	353	SliceState slice_state_from_string(const char *s) _pure_;
	354
6300502b MP	355	const char* socket_state_to_string(SocketState i) _const_;
	356	SocketState socket_state_from_string(const char *s) _pure_;
	357
	358	const char* swap_state_to_string(SwapState i) _const_;
	359	SwapState swap_state_from_string(const char *s) _pure_;
	360
	361	const char* target_state_to_string(TargetState i) _const_;
	362	TargetState target_state_from_string(const char *s) _pure_;
	363
	364	const char *timer_state_to_string(TimerState i) _const_;
	365	TimerState timer_state_from_string(const char *s) _pure_;
	366
5eef597e MP	367	const char *unit_dependency_to_string(UnitDependency i) _const_;
5eef597e MP	368	UnitDependency unit_dependency_from_string(const char *s) _pure_;