src/basic/unit-name.h

   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
  28 typedef enum UnitType {
  29         UNIT_SERVICE = 0,
  30         UNIT_SOCKET,
  31         UNIT_TARGET,
  32         UNIT_DEVICE,
  33         UNIT_MOUNT,
  34         UNIT_AUTOMOUNT,
  35         UNIT_SWAP,
  36         UNIT_TIMER,
  37         UNIT_PATH,
  38         UNIT_SLICE,
  39         UNIT_SCOPE,
  40         _UNIT_TYPE_MAX,
  41         _UNIT_TYPE_INVALID = -1
  42 } UnitType;
  43
  44 #if 0 /// UNNEEDED by elogind
  45 typedef enum UnitLoadState {
  46         UNIT_STUB = 0,
  47         UNIT_LOADED,
  48         UNIT_NOT_FOUND,
  49         UNIT_ERROR,
  50         UNIT_MERGED,
  51         UNIT_MASKED,
  52         _UNIT_LOAD_STATE_MAX,
  53         _UNIT_LOAD_STATE_INVALID = -1
  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 /* We simply watch devices, we cannot plug/unplug them. That
  77  * simplifies the state engine greatly */
  78 typedef enum DeviceState {
  79         DEVICE_DEAD,
  80         DEVICE_TENTATIVE, /* mounted or swapped, but not (yet) announced by udev */
  81         DEVICE_PLUGGED,   /* announced by udev */
  82         _DEVICE_STATE_MAX,
  83         _DEVICE_STATE_INVALID = -1
  84 } DeviceState;
  85
  86 typedef enum MountState {
  87         MOUNT_DEAD,
  88         MOUNT_MOUNTING,               /* /usr/bin/mount is running, but the mount is not done yet. */
  89         MOUNT_MOUNTING_DONE,          /* /usr/bin/mount is running, and the mount is done. */
  90         MOUNT_MOUNTED,
  91         MOUNT_REMOUNTING,
  92         MOUNT_UNMOUNTING,
  93         MOUNT_REMOUNTING_SIGTERM,
  94         MOUNT_REMOUNTING_SIGKILL,
  95         MOUNT_UNMOUNTING_SIGTERM,
  96         MOUNT_UNMOUNTING_SIGKILL,
  97         MOUNT_FAILED,
  98         _MOUNT_STATE_MAX,
  99         _MOUNT_STATE_INVALID = -1
 100 } MountState;
 101
 102 typedef enum PathState {
 103         PATH_DEAD,
 104         PATH_WAITING,
 105         PATH_RUNNING,
 106         PATH_FAILED,
 107         _PATH_STATE_MAX,
 108         _PATH_STATE_INVALID = -1
 109 } PathState;
 110
 111 typedef enum ScopeState {
 112         SCOPE_DEAD,
 113         SCOPE_RUNNING,
 114         SCOPE_ABANDONED,
 115         SCOPE_STOP_SIGTERM,
 116         SCOPE_STOP_SIGKILL,
 117         SCOPE_FAILED,
 118         _SCOPE_STATE_MAX,
 119         _SCOPE_STATE_INVALID = -1
 120 } ScopeState;
 121
 122 typedef enum ServiceState {
 123         SERVICE_DEAD,
 124         SERVICE_START_PRE,
 125         SERVICE_START,
 126         SERVICE_START_POST,
 127         SERVICE_RUNNING,
 128         SERVICE_EXITED,            /* Nothing is running anymore, but RemainAfterExit is true hence this is OK */
 129         SERVICE_RELOAD,
 130         SERVICE_STOP,              /* No STOP_PRE state, instead just register multiple STOP executables */
 131         SERVICE_STOP_SIGABRT,      /* Watchdog timeout */
 132         SERVICE_STOP_SIGTERM,
 133         SERVICE_STOP_SIGKILL,
 134         SERVICE_STOP_POST,
 135         SERVICE_FINAL_SIGTERM,     /* In case the STOP_POST executable hangs, we shoot that down, too */
 136         SERVICE_FINAL_SIGKILL,
 137         SERVICE_FAILED,
 138         SERVICE_AUTO_RESTART,
 139         _SERVICE_STATE_MAX,
 140         _SERVICE_STATE_INVALID = -1
 141 } ServiceState;
 142
 143 typedef enum SliceState {
 144         SLICE_DEAD,
 145         SLICE_ACTIVE,
 146         _SLICE_STATE_MAX,
 147         _SLICE_STATE_INVALID = -1
 148 } SliceState;
 149
 150 typedef enum SocketState {
 151         SOCKET_DEAD,
 152         SOCKET_START_PRE,
 153         SOCKET_START_CHOWN,
 154         SOCKET_START_POST,
 155         SOCKET_LISTENING,
 156         SOCKET_RUNNING,
 157         SOCKET_STOP_PRE,
 158         SOCKET_STOP_PRE_SIGTERM,
 159         SOCKET_STOP_PRE_SIGKILL,
 160         SOCKET_STOP_POST,
 161         SOCKET_FINAL_SIGTERM,
 162         SOCKET_FINAL_SIGKILL,
 163         SOCKET_FAILED,
 164         _SOCKET_STATE_MAX,
 165         _SOCKET_STATE_INVALID = -1
 166 } SocketState;
 167
 168 typedef enum SwapState {
 169         SWAP_DEAD,
 170         SWAP_ACTIVATING,               /* /sbin/swapon is running, but the swap not yet enabled. */
 171         SWAP_ACTIVATING_DONE,          /* /sbin/swapon is running, and the swap is done. */
 172         SWAP_ACTIVE,
 173         SWAP_DEACTIVATING,
 174         SWAP_ACTIVATING_SIGTERM,
 175         SWAP_ACTIVATING_SIGKILL,
 176         SWAP_DEACTIVATING_SIGTERM,
 177         SWAP_DEACTIVATING_SIGKILL,
 178         SWAP_FAILED,
 179         _SWAP_STATE_MAX,
 180         _SWAP_STATE_INVALID = -1
 181 } SwapState;
 182
 183 typedef enum TargetState {
 184         TARGET_DEAD,
 185         TARGET_ACTIVE,
 186         _TARGET_STATE_MAX,
 187         _TARGET_STATE_INVALID = -1
 188 } TargetState;
 189
 190 typedef enum TimerState {
 191         TIMER_DEAD,
 192         TIMER_WAITING,
 193         TIMER_RUNNING,
 194         TIMER_ELAPSED,
 195         TIMER_FAILED,
 196         _TIMER_STATE_MAX,
 197         _TIMER_STATE_INVALID = -1
 198 } TimerState;
 199
 200 typedef enum UnitDependency {
 201         /* Positive dependencies */
 202         UNIT_REQUIRES,
 203         UNIT_REQUISITE,
 204         UNIT_WANTS,
 205         UNIT_BINDS_TO,
 206         UNIT_PART_OF,
 207
 208         /* Inverse of the above */
 209         UNIT_REQUIRED_BY,             /* inverse of 'requires' is 'required_by' */
 210         UNIT_REQUISITE_OF,            /* inverse of 'requisite' is 'requisite_of' */
 211         UNIT_WANTED_BY,               /* inverse of 'wants' */
 212         UNIT_BOUND_BY,                /* inverse of 'binds_to' */
 213         UNIT_CONSISTS_OF,             /* inverse of 'part_of' */
 214
 215         /* Negative dependencies */
 216         UNIT_CONFLICTS,               /* inverse of 'conflicts' is 'conflicted_by' */
 217         UNIT_CONFLICTED_BY,
 218
 219         /* Order */
 220         UNIT_BEFORE,                  /* inverse of 'before' is 'after' and vice versa */
 221         UNIT_AFTER,
 222
 223         /* On Failure */
 224         UNIT_ON_FAILURE,
 225
 226         /* Triggers (i.e. a socket triggers a service) */
 227         UNIT_TRIGGERS,
 228         UNIT_TRIGGERED_BY,
 229
 230         /* Propagate reloads */
 231         UNIT_PROPAGATES_RELOAD_TO,
 232         UNIT_RELOAD_PROPAGATED_FROM,
 233
 234         /* Joins namespace of */
 235         UNIT_JOINS_NAMESPACE_OF,
 236
 237         /* Reference information for GC logic */
 238         UNIT_REFERENCES,              /* Inverse of 'references' is 'referenced_by' */
 239         UNIT_REFERENCED_BY,
 240
 241         _UNIT_DEPENDENCY_MAX,
 242         _UNIT_DEPENDENCY_INVALID = -1
 243 } UnitDependency;
 244 #endif // 0
 245
 246 typedef enum NotifyAccess {
 247         NOTIFY_NONE,
 248         NOTIFY_ALL,
 249         NOTIFY_MAIN,
 250         NOTIFY_EXEC,
 251         _NOTIFY_ACCESS_MAX,
 252         _NOTIFY_ACCESS_INVALID = -1
 253 } NotifyAccess;
 254
 255 typedef enum UnitNameFlags {
 256         UNIT_NAME_PLAIN = 1,      /* Allow foo.service */
 257         UNIT_NAME_INSTANCE = 2,   /* Allow foo@bar.service */
 258         UNIT_NAME_TEMPLATE = 4,   /* Allow foo@.service */
 259         UNIT_NAME_ANY = UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE|UNIT_NAME_TEMPLATE,
 260 } UnitNameFlags;
 261
 262 bool unit_name_is_valid(const char *n, UnitNameFlags flags) _pure_;
 263 bool unit_prefix_is_valid(const char *p) _pure_;
 264 bool unit_instance_is_valid(const char *i) _pure_;
 265 bool unit_suffix_is_valid(const char *s) _pure_;
 266
 267 #if 0 /// UNNEEDED by elogind
 268 static inline int unit_prefix_and_instance_is_valid(const char *p) {
 269         /* For prefix+instance and instance the same rules apply */
 270         return unit_instance_is_valid(p);
 271 }
 272
 273 int unit_name_to_prefix(const char *n, char **prefix);
 274 int unit_name_to_instance(const char *n, char **instance);
 275 int unit_name_to_prefix_and_instance(const char *n, char **ret);
 276
 277 UnitType unit_name_to_type(const char *n) _pure_;
 278
 279 int unit_name_change_suffix(const char *n, const char *suffix, char **ret);
 280 #endif // 0
 281
 282 int unit_name_build(const char *prefix, const char *instance, const char *suffix, char **ret);
 283
 284 #if 0 /// UNNEEDED by elogind
 285 char *unit_name_escape(const char *f);
 286 int unit_name_unescape(const char *f, char **ret);
 287 int unit_name_path_escape(const char *f, char **ret);
 288 int unit_name_path_unescape(const char *f, char **ret);
 289
 290 int unit_name_replace_instance(const char *f, const char *i, char **ret);
 291
 292 int unit_name_template(const char *f, char **ret);
 293
 294 int unit_name_from_path(const char *path, const char *suffix, char **ret);
 295 int unit_name_from_path_instance(const char *prefix, const char *path, const char *suffix, char **ret);
 296 int unit_name_to_path(const char *name, char **ret);
 297
 298 char *unit_dbus_path_from_name(const char *name);
 299 int unit_name_from_dbus_path(const char *path, char **name);
 300
 301 const char* unit_dbus_interface_from_type(UnitType t);
 302 const char *unit_dbus_interface_from_name(const char *name);
 303
 304 typedef enum UnitNameMangle {
 305         UNIT_NAME_NOGLOB,
 306         UNIT_NAME_GLOB,
 307 } UnitNameMangle;
 308
 309 int unit_name_mangle_with_suffix(const char *name, UnitNameMangle allow_globs, const char *suffix, char **ret);
 310
 311 static inline int unit_name_mangle(const char *name, UnitNameMangle allow_globs, char **ret) {
 312         return unit_name_mangle_with_suffix(name, allow_globs, ".service", ret);
 313 }
 314
 315 int slice_build_parent_slice(const char *slice, char **ret);
 316 #endif // 0
 317 int slice_build_subslice(const char *slice, const char*name, char **subslice);
 318 bool slice_name_is_valid(const char *name);
 319
 320 const char *unit_type_to_string(UnitType i) _const_;
 321 UnitType unit_type_from_string(const char *s) _pure_;
 322
 323 #if 0 /// UNNEEDED by elogind
 324 const char *unit_load_state_to_string(UnitLoadState i) _const_;
 325 UnitLoadState unit_load_state_from_string(const char *s) _pure_;
 326
 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* device_state_to_string(DeviceState i) _const_;
 334 DeviceState device_state_from_string(const char *s) _pure_;
 335
 336 const char* mount_state_to_string(MountState i) _const_;
 337 MountState mount_state_from_string(const char *s) _pure_;
 338
 339 const char* path_state_to_string(PathState i) _const_;
 340 PathState path_state_from_string(const char *s) _pure_;
 341
 342 const char* scope_state_to_string(ScopeState i) _const_;
 343 ScopeState scope_state_from_string(const char *s) _pure_;
 344
 345 const char* service_state_to_string(ServiceState i) _const_;
 346 ServiceState service_state_from_string(const char *s) _pure_;
 347
 348 const char* slice_state_to_string(SliceState i) _const_;
 349 SliceState slice_state_from_string(const char *s) _pure_;
 350
 351 const char* socket_state_to_string(SocketState i) _const_;
 352 SocketState socket_state_from_string(const char *s) _pure_;
 353
 354 const char* swap_state_to_string(SwapState i) _const_;
 355 SwapState swap_state_from_string(const char *s) _pure_;
 356
 357 const char* target_state_to_string(TargetState i) _const_;
 358 TargetState target_state_from_string(const char *s) _pure_;
 359
 360 const char *timer_state_to_string(TimerState i) _const_;
 361 TimerState timer_state_from_string(const char *s) _pure_;
 362
 363 const char *unit_dependency_to_string(UnitDependency i) _const_;
 364 UnitDependency unit_dependency_from_string(const char *s) _pure_;
 365 #endif // 0
 366
 367 const char* notify_access_to_string(NotifyAccess i) _const_;
 368 NotifyAccess notify_access_from_string(const char *s) _pure_;