HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/bus-unit-util.c

142,933 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: f394de58800f6f44c8671d3ee9abcf76abdcad20

Lines 2001–3000 of 3,301

                        return bus_log_create_error(r);
 
                for (;;) {
                        _cleanup_free_ char *partition = NULL, *mount_options = NULL;
 
                        r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &partition, &mount_options);
                        if (r < 0)
                                return parse_log_error(r, field, eq);
                        if (r == 0)
                                break;
                        /* Single set of options, applying to the root partition/single filesystem */
                        if (r == 1) {
                                r = sd_bus_message_append(m, "(ss)", "root", partition);
                                if (r < 0)
                                        return bus_log_create_error(r);
 
                                break;
                        }
 
                        r = sd_bus_message_append(m, "(ss)", partition, mount_options);
                        if (r < 0)
                                return bus_log_create_error(r);
                }
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_directory(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_strv_free_ char **symlinks = NULL, **symlinks_ro = NULL, **sources = NULL, **sources_ro = NULL;
        const char *p = eq;
        int r;
 
        /* Adding new directories is supported from both *DirectorySymlink methods and the
         * older ones, so first parse the input, and if we are given a new-style src:dst
         * tuple use the new method, else use the old one. */
 
        for (;;) {
                _cleanup_free_ char *tuple = NULL, *source = NULL, *dest = NULL, *flags = NULL;
 
                r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                const char *t = tuple;
                r = extract_many_words(&t, ":", EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS, &source, &dest, &flags);
                if (r <= 0)
                        return parse_log_error(r, field, eq);
 
                path_simplify(source);
 
                if (isempty(dest) && isempty(flags)) {
                        r = strv_consume(&sources, TAKE_PTR(source));
                        if (r < 0)
                                return bus_log_create_error(r);
                } else if (isempty(flags)) {
                        path_simplify(dest);
                        r = strv_consume_pair(&symlinks, TAKE_PTR(source), TAKE_PTR(dest));
                        if (r < 0)
                                return log_oom();
                } else {
                        ExecDirectoryFlags exec_directory_flags = exec_directory_flags_from_string(flags);
                        if (exec_directory_flags < 0 || (exec_directory_flags & ~_EXEC_DIRECTORY_FLAGS_PUBLIC) != 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse flags for %s=: '%s'", field, flags);
 
                        if (!isempty(dest)) {
                                path_simplify(dest);
                                r = strv_consume_pair(&symlinks_ro, TAKE_PTR(source), TAKE_PTR(dest));
                        } else
                                r = strv_consume(&sources_ro, TAKE_PTR(source));
                        if (r < 0)
                                return log_oom();
                }
        }
 
        if (!strv_isempty(sources)) {
                r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_open_container(m, 'v', "as");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append_strv(m, sources);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        /* For State and Runtime directories we support an optional destination parameter, which
         * will be used to create a symlink to the source. But it is new so we cannot change the
         * old DBUS signatures, so append a new message type. */
        if (!strv_isempty(symlinks) || !strv_isempty(symlinks_ro) || !strv_isempty(sources_ro)) {
                const char *symlink_field;
 
                r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
                if (r < 0)
                        return bus_log_create_error(r);
 
                if (streq(field, "StateDirectory"))
                        symlink_field = "StateDirectorySymlink";
                else if (streq(field, "RuntimeDirectory"))
                        symlink_field = "RuntimeDirectorySymlink";
                else if (streq(field, "CacheDirectory"))
                        symlink_field = "CacheDirectorySymlink";
                else if (streq(field, "LogsDirectory"))
                        symlink_field = "LogsDirectorySymlink";
                else
                        assert_not_reached();
 
                r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, symlink_field);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_open_container(m, 'v', "a(sst)");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_open_container(m, 'a', "(sst)");
                if (r < 0)
                        return bus_log_create_error(r);
 
                STRV_FOREACH_PAIR(source, destination, symlinks) {
                        r = sd_bus_message_append(m, "(sst)", *source, *destination, UINT64_C(0));
                        if (r < 0)
                                return bus_log_create_error(r);
                }
 
                STRV_FOREACH_PAIR(source, destination, symlinks_ro) {
                        r = sd_bus_message_append(m, "(sst)", *source, *destination, (uint64_t) EXEC_DIRECTORY_READ_ONLY);
                        if (r < 0)
                                return bus_log_create_error(r);
                }
 
                STRV_FOREACH(source, sources_ro) {
                        r = sd_bus_message_append(m, "(sst)", *source, "", (uint64_t) EXEC_DIRECTORY_READ_ONLY);
                        if (r < 0)
                                return bus_log_create_error(r);
                }
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_close_container(m);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        return 1;
}
 
static int bus_append_quota_directory(sd_bus_message *m, const char *field, const char *eq) {
        uint64_t quota_absolute = UINT64_MAX;
        uint32_t quota_scale = UINT32_MAX;
        int quota_enforce = false;
        int r;
 
        if (!isempty(eq) && !streq(eq, "off")) {
                r = parse_permyriad(eq);
                if (r < 0) {
                        r = parse_size(eq, 1024, &quota_absolute);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse argument: %s=%s", field, eq);
                } else
                        quota_scale = UINT32_SCALE_FROM_PERMYRIAD(r);
 
                quota_enforce = true;
        }
 
        r = sd_bus_message_append(m, "(sv)", field, "(tus)", quota_absolute, quota_scale, yes_no(quota_enforce));
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_protect_hostname(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        /* The command-line field is called "ProtectHostname". We also accept "ProtectHostnameEx" as the
         * field name for backward compatibility. We set ProtectHostname or ProtectHostnameEx. */
 
        r = parse_boolean(eq);
        if (r >= 0)
                r = sd_bus_message_append(m, "(sv)", "ProtectHostname", "b", r);
        else {
                const char *colon = strchr(eq, ':');
                if (colon) {
                        if (isempty(colon + 1))
                                return parse_log_error(0, field, eq);
 
                        _cleanup_free_ char *p = strndup(eq, colon - eq);
                        if (!p)
                                return -ENOMEM;
 
                        r = sd_bus_message_append(m, "(sv)", "ProtectHostnameEx", "(ss)", p, colon + 1);
                } else
                        r = sd_bus_message_append(m, "(sv)", "ProtectHostnameEx", "(ss)", eq, NULL);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_boolean_or_ex_string(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        r = parse_boolean(eq);
        if (r >= 0) {
                if (endswith(field, "Ex"))
                        field = strndupa_safe(field, strlen(field) - 2);
 
                r = sd_bus_message_append(m, "(sv)", field, "b", r);
        } else {
                if (!endswith(field, "Ex"))
                        field = strjoina(field, "Ex");
 
                /* We allow any string through and let the server perform the verification. */
                r = sd_bus_message_append(m, "(sv)", field, "s", eq);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_paths(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_trivial_array(m, "Paths", eq,
                                        "a(ss)", field, eq);
}
 
static int bus_append_exit_status(sd_bus_message *m, const char *field, const char *eq) {
        _cleanup_free_ int *status = NULL, *signal = NULL;
        size_t n_status = 0, n_signal = 0;
        int r;
 
        for (const char *p = eq;;) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
                if (r < 0)
                        return parse_log_error(r, field, eq);
                if (r == 0)
                        break;
 
                /* We need to call exit_status_from_string() first, because we want
                 * to parse numbers as exit statuses, not signals. */
 
                r = exit_status_from_string(word);
                if (r >= 0) {
                        assert(r >= 0 && r < 256);
 
                        if (!GREEDY_REALLOC(status, n_status + 1))
                                return log_oom();
 
                        status[n_status++] = r;
 
                } else if ((r = signal_from_string(word)) >= 0) {
                        if (!GREEDY_REALLOC(signal, n_signal + 1))
                                return log_oom();
 
                        signal[n_signal++] = r;
 
                } else
                        /* original r from exit_status_to_string() */
                        return parse_log_error(r, field, word);
        }
 
        r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'v', "(aiai)");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'r', "aiai");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_array(m, 'i', status, n_status * sizeof(int));
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_array(m, 'i', signal, n_signal * sizeof(int));
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_action_exit_status(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", field, "i", -1);
        else {
                uint8_t u;
 
                r = safe_atou8(eq, &u);
                if (r < 0)
                        return parse_log_error(r, field, eq);
 
                r = sd_bus_message_append(m, "(sv)", field, "i", (int) u);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_listen(sd_bus_message *m, const char *field, const char *eq) {
        const char *p = ASSERT_PTR(startswith(field, "Listen"));
 
        return bus_append_trivial_array(m, "Listen", eq,
                                        "a(ss)", p, eq);
}
 
static int bus_append_timers_monotonic(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        if (isempty(eq))
                r = sd_bus_message_append(m, "(sv)", "TimersMonotonic", "a(st)", 0);
        else {
                usec_t t;
                r = parse_sec(eq, &t);
                if (r < 0)
                        return parse_log_error(r, field, eq);
 
                r = sd_bus_message_append(m, "(sv)", "TimersMonotonic", "a(st)", 1, field, t);
        }
        if (r < 0)
                return bus_log_create_error(r);
 
        return 1;
}
 
static int bus_append_timers_calendar(sd_bus_message *m, const char *field, const char *eq) {
        return bus_append_trivial_array(m, "TimersCalendar", eq,
                                        "a(ss)", field, eq);
}
 
static int bus_append_timeout_sec(sd_bus_message *m, const char *field, const char *eq) {
        int r;
 
        r = bus_append_parse_sec_rename(m, "TimeoutStartSec", eq);
        if (r < 0)
                return r;
 
        return bus_append_parse_sec_rename(m, "TimeoutStopSec", eq);
}
 
static int bus_try_append_condition(sd_bus_message *m, const char *field, const char *eq) {
        ConditionType t = condition_type_from_string(field);
        bool is_condition = t >= 0;
 
        if (!is_condition) {
                t = assert_type_from_string(field);
                if (t < 0)
                        return 0;
        }
 
        const char *p = eq;
 
        int trigger = p && *p == '|';
        if (trigger)
                p++;
 
        int negate = p && *p == '!';
        if (negate)
                p++;
 
        return bus_append_trivial_array(m,
                                        is_condition ? "Conditions" : "Asserts",
                                        eq,
                                        "a(sbbs)",
                                        field, trigger, negate, p);
}
 
static void dump_conditions(void) {
        condition_types_list();
        assert_types_list();
}
 
static int bus_try_append_unit_dependency(sd_bus_message *m, const char *field, const char *eq) {
        if (unit_dependency_from_string(field) < 0)
                return 0;
 
        return bus_append_strv(m, field, eq);
}
 
typedef struct BusProperty {
        const char *name;
        int (*convert)(sd_bus_message *m, const char *field, const char *eq);
        void (*dump)(void);
} BusProperty;
 
static const BusProperty cgroup_properties[] = {
        { "DevicePolicy",                          bus_append_string                             },
        { "Slice",                                 bus_append_string                             },
        { "ManagedOOMSwap",                        bus_append_string                             },
        { "ManagedOOMMemoryPressure",              bus_append_string                             },
        { "ManagedOOMPreference",                  bus_append_string                             },
        { "OOMRules",                              bus_append_strv                               },
        { "MemoryPressureWatch",                   bus_append_string                             },
        { "CPUPressureWatch",                      bus_append_string                             },
        { "IOPressureWatch",                       bus_append_string                             },
        { "DelegateSubgroup",                      bus_append_string                             },
        { "ManagedOOMMemoryPressureLimit",         bus_append_parse_permyriad                    },
        { "MemoryAccounting",                      bus_append_parse_boolean                      },
        { "MemoryZSwapWriteback",                  bus_append_parse_boolean                      },
        { "IOAccounting",                          bus_append_parse_boolean                      },
        { "TasksAccounting",                       bus_append_parse_boolean                      },
        { "IPAccounting",                          bus_append_parse_boolean                      },
        { "CoredumpReceive",                       bus_append_parse_boolean                      },
        { "CPUWeight",                             bus_append_cg_cpu_weight_parse                },
        { "StartupCPUWeight",                      bus_append_cg_cpu_weight_parse                },
        { "IOWeight",                              bus_append_cg_weight_parse                    },
        { "StartupIOWeight",                       bus_append_cg_weight_parse                    },
        { "AllowedCPUs",                           bus_append_parse_cpu_set                      },
        { "StartupAllowedCPUs",                    bus_append_parse_cpu_set                      },
        { "AllowedMemoryNodes",                    bus_append_parse_cpu_set                      },
        { "StartupAllowedMemoryNodes",             bus_append_parse_cpu_set                      },
        { "CPUSetPartition",                       bus_append_string                             },
        { "DisableControllers",                    bus_append_strv                               },
        { "Delegate",                              bus_append_parse_delegate                     },
        { "MemoryMin",                             bus_append_parse_resource_limit               },
        { "MemoryLow",                             bus_append_parse_resource_limit               },
        { "MemoryHigh",                            bus_append_parse_resource_limit               },
        { "MemoryMax",                             bus_append_parse_resource_limit               },
        { "MemorySwapMax",                         bus_append_parse_resource_limit               },
        { "MemoryZSwapMax",                        bus_append_parse_resource_limit               },
        { "TasksMax",                              bus_append_parse_resource_limit               },
        { "CPUQuota",                              bus_append_parse_cpu_quota                    },
        { "CPUQuotaPeriodSec",                     bus_append_parse_sec_rename_infinity          },
        { "DeviceAllow",                           bus_append_parse_device_allow                 },
        { "IODeviceWeight",                        bus_append_parse_io_device_weight             },
        { "IODeviceLatencyTargetSec",              bus_append_parse_io_device_latency            },
        { "IPAddressAllow",                        bus_append_parse_ip_address_filter            },
        { "IPAddressDeny",                         bus_append_parse_ip_address_filter            },
        { "IPIngressFilterPath",                   bus_append_ip_filter_path                     },
        { "IPEgressFilterPath",                    bus_append_ip_filter_path                     },
        { "BPFProgram",                            bus_append_bpf_program                        },
        { "SocketBindAllow",                       bus_append_socket_filter                      },
        { "SocketBindDeny",                        bus_append_socket_filter                      },
        { "MemoryPressureThresholdSec",            bus_append_parse_sec_rename                   },
        { "CPUPressureThresholdSec",               bus_append_parse_sec_rename                   },
        { "IOPressureThresholdSec",                bus_append_parse_sec_rename                   },
        { "NFTSet",                                bus_append_nft_set                            },
        { "BindNetworkInterface",                  bus_append_string                             },
 
        /* While infinity is disallowed in unit file, infinity is allowed in D-Bus API which
         * means use the default memory pressure duration from oomd.conf. */
        { "ManagedOOMMemoryPressureDurationSec",   bus_append_parse_sec_rename_infinity          },
 
        { "MemoryLimit",                           warn_deprecated                               },
        { "CPUShares",                             warn_deprecated                               },
        { "StartupCPUShares",                      warn_deprecated                               },
        { "BlockIOAccounting",                     warn_deprecated                               },
        { "BlockIOWeight",                         warn_deprecated                               },
        { "StartupBlockIOWeight",                  warn_deprecated                               },
        { "BlockIODeviceWeight",                   warn_deprecated                               },
        { "BlockIOReadBandwidth",                  warn_deprecated                               },
        { "BlockIOWriteBandwidth",                 warn_deprecated                               },
        { "CPUAccounting",                         warn_deprecated                               },
        { "DefaultMemoryMin",                      warn_deprecated                               },
        { "DefaultMemoryLow",                      warn_deprecated                               },
 
        { NULL, bus_try_append_parse_cgroup_io_limit, cgroup_io_limits_list                      },
        {}
};
 
static const BusProperty automount_properties[] = {
        { "Where",                                 bus_append_string                             },
        { "ExtraOptions",                          bus_append_string                             },
        { "DirectoryMode",                         bus_append_parse_mode                         },
        { "TimeoutIdleSec",                        bus_append_parse_sec_rename                   },
        {}
};
 
static const BusProperty execute_properties[] = {
        { "User",                                  bus_append_string                             },
        { "Group",                                 bus_append_string                             },
        { "UtmpIdentifier",                        bus_append_string                             },
        { "UtmpMode",                              bus_append_string                             },
        { "PAMName",                               bus_append_string                             },
        { "TTYPath",                               bus_append_string                             },
        { "WorkingDirectory",                      bus_append_string                             },
        { "RootDirectory",                         bus_append_string                             },
        { "SyslogIdentifier",                      bus_append_string                             },
        { "ProtectSystem",                         bus_append_string                             },
        { "ProtectHome",                           bus_append_string                             },
        { "SELinuxContext",                        bus_append_string                             },
        { "RootImage",                             bus_append_string                             },
        { "RootVerity",                            bus_append_string                             },
        { "RootMStack",                            bus_append_string                             },
        { "RuntimeDirectoryPreserve",              bus_append_string                             },
        { "Personality",                           bus_append_string                             },
        { "KeyringMode",                           bus_append_string                             },
        { "ProtectProc",                           bus_append_string                             },
        { "ProcSubset",                            bus_append_string                             },
        { "NetworkNamespacePath",                  bus_append_string                             },
        { "UserNamespacePath",                     bus_append_string                             },
        { "IPCNamespacePath",                      bus_append_string                             },
        { "LogNamespace",                          bus_append_string                             },
        { "RootImagePolicy",                       bus_append_string                             },
        { "MountImagePolicy",                      bus_append_string                             },
        { "ExtensionImagePolicy",                  bus_append_string                             },
        { "PrivatePIDs",                           bus_append_string                             },
        { "PrivateBPF",                            bus_append_string                             },
        { "BPFDelegateCommands",                   bus_append_string                             },
        { "BPFDelegateMaps",                       bus_append_string                             },
        { "BPFDelegatePrograms",                   bus_append_string                             },
        { "BPFDelegateAttachments",                bus_append_string                             },
        { "IgnoreSIGPIPE",                         bus_append_parse_boolean                      },
        { "TTYVHangup",                            bus_append_parse_boolean                      },
        { "TTYReset",                              bus_append_parse_boolean                      },
        { "TTYVTDisallocate",                      bus_append_parse_boolean                      },
        { "PrivateDevices",                        bus_append_parse_boolean                      },
        { "PrivateNetwork",                        bus_append_parse_boolean                      },
        { "PrivateMounts",                         bus_append_parse_boolean                      },
        { "PrivateIPC",                            bus_append_parse_boolean                      },
        { "NoNewPrivileges",                       bus_append_parse_boolean                      },
        { "SyslogLevelPrefix",                     bus_append_parse_boolean                      },
        { "MemoryDenyWriteExecute",                bus_append_parse_boolean                      },
        { "RestrictRealtime",                      bus_append_parse_boolean                      },
        { "DynamicUser",                           bus_append_parse_boolean                      },
        { "RemoveIPC",                             bus_append_parse_boolean                      },
        { "ProtectKernelTunables",                 bus_append_parse_boolean                      },
        { "ProtectKernelModules",                  bus_append_parse_boolean                      },
        { "ProtectKernelLogs",                     bus_append_parse_boolean                      },
        { "ProtectClock",                          bus_append_parse_boolean                      },
        { "MountAPIVFS",                           bus_append_parse_boolean                      },
        { "BindLogSockets",                        bus_append_parse_boolean                      },
        { "CPUSchedulingResetOnFork",              bus_append_parse_boolean                      },
        { "LockPersonality",                       bus_append_parse_boolean                      },
        { "MemoryKSM",                             bus_append_parse_boolean                      },
        { "MemoryTHP",                             bus_append_string                             },
        { "RestrictSUIDSGID",                      bus_append_parse_boolean                      },
        { "RootEphemeral",                         bus_append_parse_boolean                      },
        { "SetLoginEnvironment",                   bus_append_parse_boolean                      },
        { "ReadWriteDirectories",                  bus_append_strv                               },
        { "ReadOnlyDirectories",                   bus_append_strv                               },
        { "InaccessibleDirectories",               bus_append_strv                               },
        { "ReadWritePaths",                        bus_append_strv                               },
        { "ReadOnlyPaths",                         bus_append_strv                               },
        { "InaccessiblePaths",                     bus_append_strv                               },
        { "ExecPaths",                             bus_append_strv                               },
        { "NoExecPaths",                           bus_append_strv                               },
        { "ExecSearchPath",                        bus_append_strv_colon                         },
        { "ExtensionDirectories",                  bus_append_strv                               },
        { "ConfigurationDirectory",                bus_append_strv                               },
        { "SupplementaryGroups",                   bus_append_strv                               },
        { "SystemCallArchitectures",               bus_append_strv                               },
        { "SyslogLevel",                           bus_append_log_level_from_string              },
        { "LogLevelMax",                           bus_append_log_level_from_string              },
        { "SyslogFacility",                        bus_append_log_facility_unshifted_from_string },
        { "SecureBits",                            bus_append_secure_bits_from_string            },
        { "CPUSchedulingPolicy",                   bus_append_sched_policy_from_string           },
        { "CPUSchedulingPriority",                 bus_append_safe_atoi                          },
        { "OOMScoreAdjust",                        bus_append_safe_atoi                          },
        { "CoredumpFilter",                        bus_append_coredump_filter_mask_from_string   },
        { "Nice",                                  bus_append_parse_nice                         },
        { "SystemCallErrorNumber",                 bus_append_seccomp_parse_errno_or_action      },
        { "IOSchedulingClass",                     bus_append_ioprio_class_from_string           },
        { "IOSchedulingPriority",                  bus_append_ioprio_parse_priority              },
        { "RuntimeDirectoryMode",                  bus_append_parse_mode                         },
        { "StateDirectoryMode",                    bus_append_parse_mode                         },
        { "CacheDirectoryMode",                    bus_append_parse_mode                         },
        { "LogsDirectoryMode",                     bus_append_parse_mode                         },
        { "ConfigurationDirectoryMode",            bus_append_parse_mode                         },
        { "UMask",                                 bus_append_parse_mode                         },
        { "TimerSlackNSec",                        bus_append_parse_nsec                         },
        { "LogRateLimitIntervalSec",               bus_append_parse_sec_rename                   },
        { "LogRateLimitBurst",                     bus_append_safe_atou                          },
        { "TTYRows",                               bus_append_safe_atou                          },
        { "TTYColumns",                            bus_append_safe_atou                          },
        { "MountFlags",                            bus_append_mount_propagation_flag_from_string },
        { "Environment",                           bus_append_strv_cunescape                     },
        { "UnsetEnvironment",                      bus_append_strv_cunescape                     },
        { "PassEnvironment",                       bus_append_strv_cunescape                     },
        { "EnvironmentFile",                       bus_append_environment_files                  },
        { "SetCredential",                         bus_append_set_credential                     },
        { "SetCredentialEncrypted",                bus_append_set_credential                     },
        { "LoadCredential",                        bus_append_load_credential                    },
        { "LoadCredentialEncrypted",               bus_append_load_credential                    },
        { "ImportCredential",                      bus_append_import_credential                  },
        { "ImportCredentialEx",                    bus_append_import_credential                  }, /* compat */
        { "LogExtraFields",                        bus_append_log_extra_fields                   },
        { "LogFilterPatterns",                     bus_append_log_filter_patterns                },
        { "StandardInput",                         bus_append_standard_inputs                    },
        { "StandardOutput",                        bus_append_standard_inputs                    },
        { "StandardError",                         bus_append_standard_inputs                    },
        { "StandardInputText",                     bus_append_standard_input_text                },
        { "StandardInputData",                     bus_append_standard_input_data                },
        { "AppArmorProfile",                       bus_append_string_with_ignore                 },
        { "SmackProcessLabel",                     bus_append_string_with_ignore                 },
        { "CapabilityBoundingSet",                 bus_append_capabilities                       },
        { "AmbientCapabilities",                   bus_append_capabilities                       },
        { "CPUAffinity",                           bus_append_cpu_affinity                       },
        { "NUMAPolicy",                            bus_append_mpol_from_string                   },
        { "NUMAMask",                              bus_append_numa_mask                          },
        { "RestrictAddressFamilies",               bus_append_filter_list                        },
        { "RestrictFileSystems",                   bus_append_filter_list                        },
        { "SystemCallFilter",                      bus_append_filter_list                        },
        { "SystemCallLog",                         bus_append_filter_list                        },
        { "RestrictNetworkInterfaces",             bus_append_filter_list                        },
        { "RestrictNamespaces",                    bus_append_namespace_list                     },
        { "DelegateNamespaces",                    bus_append_namespace_list                     },
        { "BindPaths",                             bus_append_bind_paths                         },
        { "BindReadOnlyPaths",                     bus_append_bind_paths                         },
        { "TemporaryFileSystem",                   bus_append_temporary_file_system              },
        { "RootHash",                              bus_append_root_hash                          },
        { "RootHashSignature",                     bus_append_root_hash_signature                },
        { "RootImageOptions",                      bus_append_root_image_options                 },
        { "MountImages",                           bus_append_mount_images                       },
        { "ExtensionImages",                       bus_append_extension_images                   },
        { "StateDirectory",                        bus_append_directory                          },
        { "RuntimeDirectory",                      bus_append_directory                          },
        { "CacheDirectory",                        bus_append_directory                          },
        { "LogsDirectory",                         bus_append_directory                          },
        { "ProtectHostname",                       bus_append_protect_hostname                   },
        { "ProtectHostnameEx",                     bus_append_protect_hostname                   }, /* compat */
        { "PrivateTmp",                            bus_append_boolean_or_ex_string               },
        { "PrivateTmpEx",                          bus_append_boolean_or_ex_string               }, /* compat */
        { "ProtectControlGroups",                  bus_append_boolean_or_ex_string               },
        { "ProtectControlGroupsEx",                bus_append_boolean_or_ex_string               }, /* compat */
        { "PrivateUsers",                          bus_append_boolean_or_ex_string               },
        { "PrivateUsersEx",                        bus_append_boolean_or_ex_string               }, /* compat */
        { "StateDirectoryQuota",                   bus_append_quota_directory                    },
        { "CacheDirectoryQuota",                   bus_append_quota_directory                    },
        { "LogsDirectoryQuota",                    bus_append_quota_directory                    },
        { "StateDirectoryAccounting",              bus_append_parse_boolean                      },
        { "CacheDirectoryAccounting",              bus_append_parse_boolean                      },
        { "LogsDirectoryAccounting",               bus_append_parse_boolean                      },
 
        { NULL, bus_try_append_resource_limit,     dump_resource_limits                          },
        {}
};
 
static const BusProperty kill_properties[] = {
        { "KillMode",                              bus_append_string                             },
        { "SendSIGHUP",                            bus_append_parse_boolean                      },
        { "SendSIGKILL",                           bus_append_parse_boolean                      },
        { "KillSignal",                            bus_append_signal_from_string                 },
        { "RestartKillSignal",                     bus_append_signal_from_string                 },
        { "FinalKillSignal",                       bus_append_signal_from_string                 },
        { "WatchdogSignal",                        bus_append_signal_from_string                 },
        {}
};
 
static const BusProperty mount_properties[] = {
        { "What",                                  bus_append_string                             },
        { "Where",                                 bus_append_string                             },
        { "Options",                               bus_append_string                             },
        { "Type",                                  bus_append_string                             },
        { "TimeoutSec",                            bus_append_parse_sec_rename                   },
        { "DirectoryMode",                         bus_append_parse_mode                         },
        { "SloppyOptions",                         bus_append_parse_boolean                      },
        { "LazyUnmount",                           bus_append_parse_boolean                      },
        { "ForceUnmount",                          bus_append_parse_boolean                      },
        { "ReadwriteOnly",                         bus_append_parse_boolean                      },
        {}
};
 
static const BusProperty path_properties[] = {
        { "MakeDirectory",                         bus_append_parse_boolean                      },
        { "DirectoryMode",                         bus_append_parse_mode                         },
        { "PathExists",                            bus_append_paths                              },
        { "PathExistsGlob",                        bus_append_paths                              },
        { "PathChanged",                           bus_append_paths                              },
        { "PathModified",                          bus_append_paths                              },
        { "DirectoryNotEmpty",                     bus_append_paths                              },
        { "TriggerLimitBurst",                     bus_append_safe_atou                          },
        { "PollLimitBurst",                        bus_append_safe_atou                          },
        { "TriggerLimitIntervalSec",               bus_append_parse_sec_rename                   },
        { "PollLimitIntervalSec",                  bus_append_parse_sec_rename                   },
        {}
};
 
static const BusProperty scope_properties[] = {
        { "RuntimeMaxSec",                         bus_append_parse_sec_rename                   },
        { "RuntimeRandomizedExtraSec",             bus_append_parse_sec_rename                   },
        { "TimeoutStopSec",                        bus_append_parse_sec_rename                   },
        { "OOMPolicy",                             bus_append_string                             },
 
        /* Scope units don't have execution context but we still want to allow setting these two,
         * so let's handle them separately. */
        { "User",                                  bus_append_string                             },
        { "Group",                                 bus_append_string                             },
        {}
};
 
static const BusProperty service_properties[] = {
        { "PIDFile",                               bus_append_string                             },
        { "Type",                                  bus_append_string                             },
        { "ExitType",                              bus_append_string                             },
        { "Restart",                               bus_append_string                             },
        { "RestartMode",                           bus_append_string                             },
        { "BusName",                               bus_append_string                             },
        { "NotifyAccess",                          bus_append_string                             },
        { "USBFunctionDescriptors",                bus_append_string                             },
        { "USBFunctionStrings",                    bus_append_string                             },
        { "OOMPolicy",                             bus_append_string                             },
        { "TimeoutStartFailureMode",               bus_append_string                             },
        { "TimeoutStopFailureMode",                bus_append_string                             },
        { "FileDescriptorStorePreserve",           bus_append_string                             },
        { "LUOSession",                            bus_append_strv                               },
        { "PermissionsStartOnly",                  bus_append_parse_boolean                      },
        { "RootDirectoryStartOnly",                bus_append_parse_boolean                      },
        { "RemainAfterExit",                       bus_append_parse_boolean                      },
        { "GuessMainPID",                          bus_append_parse_boolean                      },
        { "RestartSec",                            bus_append_parse_sec_rename                   },
        { "RestartMaxDelaySec",                    bus_append_parse_sec_rename                   },
        { "RestartRandomizedDelaySec",             bus_append_parse_sec_rename                   },
        { "TimeoutStartSec",                       bus_append_parse_sec_rename                   },
        { "TimeoutStopSec",                        bus_append_parse_sec_rename                   },
        { "TimeoutAbortSec",                       bus_append_parse_sec_rename                   },
        { "RuntimeMaxSec",                         bus_append_parse_sec_rename                   },
        { "RuntimeRandomizedExtraSec",             bus_append_parse_sec_rename                   },
        { "WatchdogSec",                           bus_append_parse_sec_rename                   },
        { "TimeoutSec",                            bus_append_timeout_sec                        },
        { "FileDescriptorStoreMax",                bus_append_safe_atou                          },
        { "RestartSteps",                          bus_append_safe_atou                          },
        { "ExecCondition",                         bus_append_exec_command                       },
        { "ExecConditionEx",                       bus_append_exec_command                       }, /* compat */
        { "ExecStartPre",                          bus_append_exec_command                       },
        { "ExecStartPreEx",                        bus_append_exec_command                       }, /* compat */
        { "ExecStart",                             bus_append_exec_command                       },
        { "ExecStartEx",                           bus_append_exec_command                       }, /* compat */
        { "ExecStartPost",                         bus_append_exec_command                       },
        { "ExecStartPostEx",                       bus_append_exec_command                       }, /* compat */
        { "ExecReload",                            bus_append_exec_command                       },
        { "ExecReloadEx",                          bus_append_exec_command                       }, /* compat */
        { "ExecReloadPost",                        bus_append_exec_command                       },
        { "ExecReloadPostEx",                      bus_append_exec_command                       }, /* compat */
        { "ExecStop",                              bus_append_exec_command                       },
        { "ExecStopEx",                            bus_append_exec_command                       }, /* compat */
        { "ExecStopPost",                          bus_append_exec_command                       },
        { "ExecStopPostEx",                        bus_append_exec_command                       }, /* compat */
        { "RestartPreventExitStatus",              bus_append_exit_status                        },
        { "RestartForceExitStatus",                bus_append_exit_status                        },
        { "SuccessExitStatus",                     bus_append_exit_status                        },
        { "OpenFile",                              bus_append_open_file                          },
        { "ReloadSignal",                          bus_append_signal_from_string                 },
        { "RefreshOnReload",                       bus_append_refresh_on_reload                  },
        {}
};
 
static const BusProperty socket_properties[] = {
        { "Accept",                                bus_append_parse_boolean                      },
        { "FlushPending",                          bus_append_parse_boolean                      },
        { "Writable",                              bus_append_parse_boolean                      },
        { "KeepAlive",                             bus_append_parse_boolean                      },
        { "NoDelay",                               bus_append_parse_boolean                      },
        { "FreeBind",                              bus_append_parse_boolean                      },
        { "Transparent",                           bus_append_parse_boolean                      },
        { "Broadcast",                             bus_append_parse_boolean                      },
        { "PassCredentials",                       bus_append_parse_boolean                      },
        { "PassFileDescriptorsToExec",             bus_append_parse_boolean                      },
        { "PassSecurity",                          bus_append_parse_boolean                      },
        { "PassPacketInfo",                        bus_append_parse_boolean                      },
        { "ReusePort",                             bus_append_parse_boolean                      },
        { "RemoveOnStop",                          bus_append_parse_boolean                      },
        { "SELinuxContextFromNet",                 bus_append_parse_boolean                      },
        { "Priority",                              bus_append_safe_atoi                          },
        { "IPTTL",                                 bus_append_safe_atoi                          },
        { "Mark",                                  bus_append_safe_atoi                          },
        { "IPTOS",                                 bus_append_ip_tos_from_string                 },
        { "Backlog",                               bus_append_safe_atou                          },
        { "MaxConnections",                        bus_append_safe_atou                          },
        { "MaxConnectionsPerSource",               bus_append_safe_atou                          },
        { "KeepAliveProbes",                       bus_append_safe_atou                          },
        { "TriggerLimitBurst",                     bus_append_safe_atou                          },
        { "PollLimitBurst",                        bus_append_safe_atou                          },
        { "SocketMode",                            bus_append_parse_mode                         },
        { "DirectoryMode",                         bus_append_parse_mode                         },
        { "MessageQueueMaxMessages",               bus_append_safe_atoi64                        },
        { "TimeoutSec",                            bus_append_parse_sec_rename                   },
        { "KeepAliveTimeSec",                      bus_append_parse_sec_rename                   },
        { "KeepAliveIntervalSec",                  bus_append_parse_sec_rename                   },
        { "DeferAcceptSec",                        bus_append_parse_sec_rename                   },
        { "TriggerLimitIntervalSec",               bus_append_parse_sec_rename                   },
        { "PollLimitIntervalSec",                  bus_append_parse_sec_rename                   },
        { "DeferTriggerMaxSec",                    bus_append_parse_sec_rename                   },
        { "ReceiveBuffer",                         bus_append_parse_size                         },
        { "SendBuffer",                            bus_append_parse_size                         },
        { "PipeSize",                              bus_append_parse_size                         },
        { "MessageQueueMessageSize",               bus_append_parse_size_i64                     },
        { "ExecStartPre",                          bus_append_exec_command                       },
        { "ExecStartPost",                         bus_append_exec_command                       },
        { "ExecReload",                            bus_append_exec_command                       },
        { "ExecStopPost",                          bus_append_exec_command                       },
        { "SmackLabel",                            bus_append_string                             },
        { "SmackLabelIPIn",                        bus_append_string                             },
        { "SmackLabelIPOut",                       bus_append_string                             },
        { "TCPCongestion",                         bus_append_string                             },
        { "BindToDevice",                          bus_append_string                             },
        { "BindIPv6Only",                          bus_append_string                             },
        { "FileDescriptorName",                    bus_append_string                             },
        { "SocketUser",                            bus_append_string                             },
        { "SocketGroup",                           bus_append_string                             },
        { "Timestamping",                          bus_append_string                             },
        { "DeferTrigger",                          bus_append_string                             },
        { "Symlinks",                              bus_append_strv                               },
        { "XAttrEntryPoint",                       bus_append_xattr                              },
        { "XAttrListen",                           bus_append_xattr                              },
        { "XAttrAccept",                           bus_append_xattr                              },
        { "SocketProtocol",                        bus_append_parse_ip_protocol                  },
        { "ListenStream",                          bus_append_listen                             },
        { "ListenDatagram",                        bus_append_listen                             },
        { "ListenSequentialPacket",                bus_append_listen                             },
        { "ListenNetlink",                         bus_append_listen                             },
        { "ListenSpecial",                         bus_append_listen                             },
        { "ListenMessageQueue",                    bus_append_listen                             },
        { "ListenFIFO",                            bus_append_listen                             },
        { "ListenUSBFunction",                     bus_append_listen                             },
        {}
};
 
static const BusProperty timer_properties[] = {
        { "WakeSystem",                            bus_append_parse_boolean                      },
        { "RemainAfterElapse",                     bus_append_parse_boolean                      },
        { "Persistent",                            bus_append_parse_boolean                      },
        { "OnTimezoneChange",                      bus_append_parse_boolean                      },
        { "OnClockChange",                         bus_append_parse_boolean                      },
        { "FixedRandomDelay",                      bus_append_parse_boolean                      },
        { "DeferReactivation",                     bus_append_parse_boolean                      },
        { "AccuracySec",                           bus_append_parse_sec_rename                   },
        { "RandomizedDelaySec",                    bus_append_parse_sec_rename                   },
        { "RandomizedOffsetSec",                   bus_append_parse_sec_rename                   },
        { "OnActiveSec",                           bus_append_timers_monotonic                   },
        { "OnBootSec",                             bus_append_timers_monotonic                   },
        { "OnStartupSec",                          bus_append_timers_monotonic                   },
        { "OnUnitActiveSec",                       bus_append_timers_monotonic                   },
        { "OnUnitInactiveSec",                     bus_append_timers_monotonic                   },
        { "OnCalendar",                            bus_append_timers_calendar                    },
        {}
};
 
static const BusProperty unit_properties[] = {
        { "Description",                           bus_append_string                             },
        { "SourcePath",                            bus_append_string                             },
        { "OnFailureJobMode",                      bus_append_string                             },
        { "JobTimeoutAction",                      bus_append_string                             },
        { "JobTimeoutRebootArgument",              bus_append_string                             },
        { "StartLimitAction",                      bus_append_string                             },
        { "FailureAction",                         bus_append_string                             },
        { "SuccessAction",                         bus_append_string                             },
        { "RebootArgument",                        bus_append_string                             },
        { "CollectMode",                           bus_append_string                             },
        { "StopWhenUnneeded",                      bus_append_parse_boolean                      },
        { "RefuseManualStart",                     bus_append_parse_boolean                      },
        { "RefuseManualStop",                      bus_append_parse_boolean                      },
        { "AllowIsolate",                          bus_append_parse_boolean                      },
        { "IgnoreOnIsolate",                       bus_append_parse_boolean                      },
        { "SurviveFinalKillSignal",                bus_append_parse_boolean                      },
        { "DefaultDependencies",                   bus_append_parse_boolean                      },
        { "JobTimeoutSec",                         bus_append_parse_sec_rename                   },
        { "JobRunningTimeoutSec",                  bus_append_parse_sec_rename                   },
        { "StartLimitIntervalSec",                 bus_append_parse_sec_rename                   },
        { "StartLimitBurst",                       bus_append_safe_atou                          },
        { "SuccessActionExitStatus",               bus_append_action_exit_status                 },
        { "FailureActionExitStatus",               bus_append_action_exit_status                 },
        { "Documentation",                         bus_append_strv                               },
        { "RequiresMountsFor",                     bus_append_strv                               },
        { "WantsMountsFor",                        bus_append_strv                               },
        { "Markers",                               bus_append_strv                               },
 
        { NULL, bus_try_append_unit_dependency,    unit_types_list                               },
        { NULL, bus_try_append_condition,          dump_conditions                               },
        {}
};
 
static const BusProperty* service_unit_properties[] = {
        cgroup_properties,
        execute_properties,
        kill_properties,
        service_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* socket_unit_properties[] = {
        cgroup_properties,
        execute_properties,
        kill_properties,
        socket_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* timer_unit_properties[] = {
        timer_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* path_unit_properties[] = {
        path_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* slice_unit_properties[] = {
        cgroup_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* scope_unit_properties[] = {
        cgroup_properties,
        kill_properties,
        scope_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* mount_unit_properties[] = {
        cgroup_properties,
        execute_properties,
        kill_properties,
        mount_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* automount_unit_properties[] = {
        automount_properties,
        unit_properties,
        NULL,
};
 
static const BusProperty* other_unit_properties[] = {
        unit_properties,
        NULL,
};
 
static const BusProperty** unit_type_properties[_UNIT_TYPE_MAX] = {
        [UNIT_SERVICE]   = service_unit_properties,
        [UNIT_SOCKET]    = socket_unit_properties,
        [UNIT_TIMER]     = timer_unit_properties,
        [UNIT_PATH]      = path_unit_properties,
        [UNIT_SLICE]     = slice_unit_properties,