[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
6300502b MP	198	typedef enum TargetState {
	199	TARGET_DEAD,
	200	TARGET_ACTIVE,
	201	_TARGET_STATE_MAX,
	202	_TARGET_STATE_INVALID = -1
	203	} TargetState;
	204
	205	typedef enum TimerState {
	206	TIMER_DEAD,
	207	TIMER_WAITING,
	208	TIMER_RUNNING,
	209	TIMER_ELAPSED,
	210	TIMER_FAILED,
	211	_TIMER_STATE_MAX,
	212	_TIMER_STATE_INVALID = -1
	213	} TimerState;
	214
	215	typedef enum UnitDependency {
5eef597e MP	216	/* Positive dependencies */
5eef597e MP	217	UNIT_REQUIRES,
5eef597e	218	UNIT_REQUISITE,
5eef597e MP	219	UNIT_WANTS,
	220	UNIT_BINDS_TO,
	221	UNIT_PART_OF,
	222
	223	/* Inverse of the above */
e3bff60a	224	UNIT_REQUIRED_BY, /* inverse of 'requires' is 'required_by' */
e3bff60a	225	UNIT_REQUISITE_OF, /* inverse of 'requisite' is 'requisite_of' */
5eef597e MP	226	UNIT_WANTED_BY, /* inverse of 'wants' */
	227	UNIT_BOUND_BY, /* inverse of 'binds_to' */
	228	UNIT_CONSISTS_OF, /* inverse of 'part_of' */
	229
	230	/* Negative dependencies */
	231	UNIT_CONFLICTS, /* inverse of 'conflicts' is 'conflicted_by' */
	232	UNIT_CONFLICTED_BY,
	233
	234	/* Order */
	235	UNIT_BEFORE, /* inverse of 'before' is 'after' and vice versa */
	236	UNIT_AFTER,
	237
	238	/* On Failure */
	239	UNIT_ON_FAILURE,
	240
	241	/* Triggers (i.e. a socket triggers a service) */
	242	UNIT_TRIGGERS,
	243	UNIT_TRIGGERED_BY,
	244
	245	/* Propagate reloads */
	246	UNIT_PROPAGATES_RELOAD_TO,
	247	UNIT_RELOAD_PROPAGATED_FROM,
	248
	249	/* Joins namespace of */
	250	UNIT_JOINS_NAMESPACE_OF,
	251
	252	/* Reference information for GC logic */
	253	UNIT_REFERENCES, /* Inverse of 'references' is 'referenced_by' */
	254	UNIT_REFERENCED_BY,
	255
	256	_UNIT_DEPENDENCY_MAX,
	257	_UNIT_DEPENDENCY_INVALID = -1
6300502b	258	} UnitDependency;
5eef597e	259
e3bff60a MP	260	typedef enum UnitNameFlags {
	261	UNIT_NAME_PLAIN = 1, /* Allow foo.service */
	262	UNIT_NAME_INSTANCE = 2, /* Allow foo@bar.service */
	263	UNIT_NAME_TEMPLATE = 4, /* Allow foo@.service */
	264	UNIT_NAME_ANY = UNIT_NAME_PLAIN\|UNIT_NAME_INSTANCE\|UNIT_NAME_TEMPLATE,
	265	} UnitNameFlags;
663996b3	266
e3bff60a	267	bool unit_name_is_valid(const char *n, UnitNameFlags flags) _pure_;
663996b3 MS	268	bool unit_prefix_is_valid(const char *p) _pure_;
663996b3 MS	269	bool unit_instance_is_valid(const char *i) _pure_;
e3bff60a MP	270	bool unit_suffix_is_valid(const char *s) _pure_;
	271
	272	static inline int unit_prefix_and_instance_is_valid(const char *p) {
	273	/* For prefix+instance and instance the same rules apply */
	274	return unit_instance_is_valid(p);
	275	}
	276
	277	int unit_name_to_prefix(const char n, char *prefix);
	278	int unit_name_to_instance(const char n, char *instance);
	279	int unit_name_to_prefix_and_instance(const char n, char *ret);
663996b3 MS	280
	281	UnitType unit_name_to_type(const char *n) _pure_;
	282
e3bff60a	283	int unit_name_change_suffix(const char n, const char suffix, char **ret);
663996b3	284
e3bff60a	285	int unit_name_build(const char prefix, const char instance, const char suffix, char *ret);
663996b3 MS	286
663996b3 MS	287	char unit_name_escape(const char f);
e3bff60a MP	288	int unit_name_unescape(const char f, char *ret);
	289	int unit_name_path_escape(const char f, char *ret);
	290	int unit_name_path_unescape(const char f, char *ret);
663996b3	291
e3bff60a	292	int unit_name_replace_instance(const char f, const char i, char **ret);
663996b3	293
e3bff60a	294	int unit_name_template(const char f, char *ret);
663996b3	295
e3bff60a MP	296	int unit_name_from_path(const char path, const char suffix, char **ret);
	297	int unit_name_from_path_instance(const char prefix, const char path, const char suffix, char *ret);
	298	int unit_name_to_path(const char name, char *ret);
663996b3 MS	299
663996b3 MS	300	char unit_dbus_path_from_name(const char name);
14228c0d	301	int unit_name_from_dbus_path(const char path, char *name);
663996b3	302
d9dfd233 MP	303	const char* unit_dbus_interface_from_type(UnitType t);
	304	const char unit_dbus_interface_from_name(const char name);
	305
e3bff60a MP	306	typedef enum UnitNameMangle {
	307	UNIT_NAME_NOGLOB,
	308	UNIT_NAME_GLOB,
	309	} UnitNameMangle;
	310
	311	int unit_name_mangle_with_suffix(const char name, UnitNameMangle allow_globs, const char suffix, char **ret);
60f067b4	312
e3bff60a MP	313	static inline int unit_name_mangle(const char name, UnitNameMangle allow_globs, char *ret) {
e3bff60a MP	314	return unit_name_mangle_with_suffix(name, allow_globs, ".service", ret);
f47781d8	315	}
14228c0d	316
e3bff60a MP	317	int slice_build_parent_slice(const char slice, char *ret);
	318	int slice_build_subslice(const char slice, const charname, char **subslice);
	319	bool slice_name_is_valid(const char *name);
	320
	321	const char *unit_type_to_string(UnitType i) _const_;
	322	UnitType unit_type_from_string(const char *s) _pure_;
	323
	324	const char *unit_load_state_to_string(UnitLoadState i) _const_;
	325	UnitLoadState unit_load_state_from_string(const char *s) _pure_;
5eef597e	326
6300502b MP	327	const char *unit_active_state_to_string(UnitActiveState i) _const_;
	328	UnitActiveState unit_active_state_from_string(const char *s) _pure_;
	329
	330	const char* automount_state_to_string(AutomountState i) _const_;
	331	AutomountState automount_state_from_string(const char *s) _pure_;
	332
	333	const char* busname_state_to_string(BusNameState i) _const_;
	334	BusNameState busname_state_from_string(const char *s) _pure_;
	335
	336	const char* device_state_to_string(DeviceState i) _const_;
	337	DeviceState device_state_from_string(const char *s) _pure_;
	338
	339	const char* mount_state_to_string(MountState i) _const_;
	340	MountState mount_state_from_string(const char *s) _pure_;
	341
	342	const char* path_state_to_string(PathState i) _const_;
	343	PathState path_state_from_string(const char *s) _pure_;
	344
	345	const char* scope_state_to_string(ScopeState i) _const_;
	346	ScopeState scope_state_from_string(const char *s) _pure_;
	347
	348	const char* service_state_to_string(ServiceState i) _const_;
	349	ServiceState service_state_from_string(const char *s) _pure_;
	350
	351	const char* slice_state_to_string(SliceState i) _const_;
	352	SliceState slice_state_from_string(const char *s) _pure_;
	353
6300502b MP	354	const char* socket_state_to_string(SocketState i) _const_;
	355	SocketState socket_state_from_string(const char *s) _pure_;
	356
	357	const char* swap_state_to_string(SwapState i) _const_;
	358	SwapState swap_state_from_string(const char *s) _pure_;
	359
	360	const char* target_state_to_string(TargetState i) _const_;
	361	TargetState target_state_from_string(const char *s) _pure_;
	362
	363	const char *timer_state_to_string(TimerState i) _const_;
	364	TimerState timer_state_from_string(const char *s) _pure_;
	365
5eef597e MP	366	const char *unit_dependency_to_string(UnitDependency i) _const_;
5eef597e MP	367	UnitDependency unit_dependency_from_string(const char *s) _pure_;