systemd: headers diff between 38 and 39 versions

	automount.h	automount.h

	skipping to change at line 39	skipping to change at line 39
	typedef enum AutomountState {	typedef enum AutomountState {
	AUTOMOUNT_DEAD,	AUTOMOUNT_DEAD,
	AUTOMOUNT_WAITING,	AUTOMOUNT_WAITING,
	AUTOMOUNT_RUNNING,	AUTOMOUNT_RUNNING,
	AUTOMOUNT_FAILED,	AUTOMOUNT_FAILED,
	_AUTOMOUNT_STATE_MAX,	_AUTOMOUNT_STATE_MAX,
	_AUTOMOUNT_STATE_INVALID = -1	_AUTOMOUNT_STATE_INVALID = -1
	} AutomountState;	} AutomountState;

	struct Automount {	struct Automount {

	Meta meta;	Unit meta;

	AutomountState state, deserialized_state;	AutomountState state, deserialized_state;

	char *where;	char *where;

	UnitRef mount;	UnitRef mount;

	int pipe_fd;	int pipe_fd;
	mode_t directory_mode;	mode_t directory_mode;
	Watch pipe_watch;	Watch pipe_watch;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	cgroup-show.h	cgroup-show.h

	skipping to change at line 25	skipping to change at line 25

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

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


	int show_cgroup_by_path(const char path, const char prefix, unsigned colu	#include <stdbool.h>
	mns);
	int show_cgroup(const char controller, const char path, const char *prefi	int show_cgroup_by_path(const char path, const char prefix, unsigned colu
	x, unsigned columns);	mns, bool kernel_threads);
		int show_cgroup(const char controller, const char path, const char *prefi
		x, unsigned columns, bool kernel_threads);

	#endif	#endif

End of changes. 1 change blocks.
	4 lines changed or deleted	6 lines changed or added

	config.h	config.h

	skipping to change at line 108	skipping to change at line 108
	/* Name of package */	/* Name of package */
	#define PACKAGE "systemd"	#define PACKAGE "systemd"

	/* Define to the address where bug reports for this package should be sent. */	/* Define to the address where bug reports for this package should be sent. */
	#define PACKAGE_BUGREPORT "systemd-devel@lists.freedesktop.org"	#define PACKAGE_BUGREPORT "systemd-devel@lists.freedesktop.org"

	/* Define to the full name of this package. */	/* Define to the full name of this package. */
	#define PACKAGE_NAME "systemd"	#define PACKAGE_NAME "systemd"

	/* Define to the full name and version of this package. */	/* Define to the full name and version of this package. */

	#define PACKAGE_STRING "systemd 38"	#define PACKAGE_STRING "systemd 39"

	/* Define to the one symbol short name of this package. */	/* Define to the one symbol short name of this package. */
	#define PACKAGE_TARNAME "systemd"	#define PACKAGE_TARNAME "systemd"

	/* Define to the home page for this package. */	/* Define to the home page for this package. */
	#define PACKAGE_URL ""	#define PACKAGE_URL ""

	/* Define to the version of this package. */	/* Define to the version of this package. */

	#define PACKAGE_VERSION "38"	#define PACKAGE_VERSION "39"

	/* Define to 1 if you have the ANSI C header files. */	/* Define to 1 if you have the ANSI C header files. */
	#define STDC_HEADERS 1	#define STDC_HEADERS 1

	/* Target is ALTLinux */	/* Target is ALTLinux */
	/* #undef TARGET_ALTLINUX */	/* #undef TARGET_ALTLINUX */

	/* Target is Ångström */	/* Target is Ångström */
	/* #undef TARGET_ANGSTROM */	/* #undef TARGET_ANGSTROM */


	skipping to change at line 186	skipping to change at line 186
	/* Enable extensions on HP NonStop. */	/* Enable extensions on HP NonStop. */
	#ifndef _TANDEM_SOURCE	#ifndef _TANDEM_SOURCE
	# define _TANDEM_SOURCE 1	# define _TANDEM_SOURCE 1
	#endif	#endif
	/* Enable general extensions on Solaris. */	/* Enable general extensions on Solaris. */
	#ifndef __EXTENSIONS__	#ifndef __EXTENSIONS__
	# define __EXTENSIONS__ 1	# define __EXTENSIONS__ 1
	#endif	#endif

	/* Version number of package */	/* Version number of package */

	#define VERSION "38"	#define VERSION "39"

	/* Number of bits in a file offset, on hosts where this is settable. */	/* Number of bits in a file offset, on hosts where this is settable. */
	#define _FILE_OFFSET_BITS 64	#define _FILE_OFFSET_BITS 64

	/* Define for large files, on AIX-style hosts. */	/* Define for large files, on AIX-style hosts. */
	/* #undef _LARGE_FILES */	/* #undef _LARGE_FILES */

	/* Define to 1 if on MINIX. */	/* Define to 1 if on MINIX. */
	/* #undef _MINIX */	/* #undef _MINIX */


End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	dbus-common.h	dbus-common.h

	skipping to change at line 99	skipping to change at line 99

	int bus_connect_system_ssh(const char user, const char host, DBusConnecti on *_bus, DBusError error);	int bus_connect_system_ssh(const char user, const char host, DBusConnecti on *_bus, DBusError error);
	int bus_connect_system_polkit(DBusConnection *_bus, DBusError error);	int bus_connect_system_polkit(DBusConnection *_bus, DBusError error);

	const char bus_error_message(const DBusError error);	const char bus_error_message(const DBusError error);

	typedef int (BusPropertyCallback)(DBusMessageIter iter, const char prope rty, void data);	typedef int (BusPropertyCallback)(DBusMessageIter iter, const char prope rty, void data);
	typedef int (BusPropertySetCallback)(DBusMessageIter iter, const char *pr operty);	typedef int (BusPropertySetCallback)(DBusMessageIter iter, const char *pr operty);

	typedef struct BusProperty {	typedef struct BusProperty {

	const char interface; / interface of the property */
	const char property; / name of the property */	const char property; / name of the property */
	BusPropertyCallback append; /* Function that is called to seri alize this property */	BusPropertyCallback append; /* Function that is called to seri alize this property */
	const char *signature;	const char *signature;

	const void data; / The data of this property */	const uint16_t offset; /* Offset from BusBoundProperties:
		:base address to the property data.
		* uint16_t is sufficient, because
		we have no structs too big.
		* -Werror=overflow will catch it
		if this does not hold. */
		bool indirect; /* data is indirect, ie. not base+
		offset, but (base+offset) /
	BusPropertySetCallback set; /* Optional: Function that is call ed to set this property */	BusPropertySetCallback set; /* Optional: Function that is call ed to set this property */
	} BusProperty;	} BusProperty;


		typedef struct BusBoundProperties {
		const char interface; / interface of the properties */
		const BusProperty properties; / array of properties, ended by a
		NULL-filled element */
		const void const base; / base pointer to which the offse
		t must be added to reach data */
		} BusBoundProperties;

	DBusHandlerResult bus_send_error_reply(	DBusHandlerResult bus_send_error_reply(
	DBusConnection *c,	DBusConnection *c,
	DBusMessage *message,	DBusMessage *message,
	DBusError *bus_error,	DBusError *bus_error,
	int error);	int error);

	DBusHandlerResult bus_default_message_handler(	DBusHandlerResult bus_default_message_handler(
	DBusConnection *c,	DBusConnection *c,
	DBusMessage *message,	DBusMessage *message,
	const char *introspection,	const char *introspection,
	const char *interfaces,	const char *interfaces,

	const BusProperty *properties);	const BusBoundProperties *bound_properties);

	int bus_property_append_string(DBusMessageIter i, const char property, vo id *data);	int bus_property_append_string(DBusMessageIter i, const char property, vo id *data);
	int bus_property_append_strv(DBusMessageIter i, const char property, void *data);	int bus_property_append_strv(DBusMessageIter i, const char property, void *data);
	int bus_property_append_bool(DBusMessageIter i, const char property, void *data);	int bus_property_append_bool(DBusMessageIter i, const char property, void *data);

		int bus_property_append_tristate_false(DBusMessageIter i, const char prop erty, void *data);
	int bus_property_append_int32(DBusMessageIter i, const char property, voi d *data);	int bus_property_append_int32(DBusMessageIter i, const char property, voi d *data);
	int bus_property_append_uint32(DBusMessageIter i, const char property, vo id *data);	int bus_property_append_uint32(DBusMessageIter i, const char property, vo id *data);
	int bus_property_append_uint64(DBusMessageIter i, const char property, vo id *data);	int bus_property_append_uint64(DBusMessageIter i, const char property, vo id *data);
	int bus_property_append_size(DBusMessageIter i, const char property, void *data);	int bus_property_append_size(DBusMessageIter i, const char property, void *data);
	int bus_property_append_ul(DBusMessageIter i, const char property, void * data);	int bus_property_append_ul(DBusMessageIter i, const char property, void * data);
	int bus_property_append_long(DBusMessageIter i, const char property, void *data);	int bus_property_append_long(DBusMessageIter i, const char property, void *data);

	#define bus_property_append_int bus_property_append_int32	#define bus_property_append_int bus_property_append_int32
	#define bus_property_append_pid bus_property_append_uint32	#define bus_property_append_pid bus_property_append_uint32
	#define bus_property_append_uid bus_property_append_uint32	#define bus_property_append_uid bus_property_append_uint32

End of changes. 5 change blocks.
	3 lines changed or deleted	18 lines changed or added

	dbus-execute.h	dbus-execute.h

	skipping to change at line 28	skipping to change at line 28
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.	General Public License for more details.

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

	#include <dbus/dbus.h>	#include <dbus/dbus.h>

	#include "manager.h"	#include "manager.h"

		#include "dbus-common.h"

	#define BUS_EXEC_STATUS_INTERFACE(prefix) \	#define BUS_EXEC_STATUS_INTERFACE(prefix) \
	" <property name=\"" prefix "StartTimestamp\" type=\"t\" access=\" read\"/>\n" \	" <property name=\"" prefix "StartTimestamp\" type=\"t\" access=\" read\"/>\n" \
	" <property name=\"" prefix "StartTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \	" <property name=\"" prefix "StartTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
	" <property name=\"" prefix "ExitTimestamp\" type=\"t\" access=\"r ead\"/>\n" \	" <property name=\"" prefix "ExitTimestamp\" type=\"t\" access=\"r ead\"/>\n" \
	" <property name=\"" prefix "ExitTimestampMonotonic\" type=\"t\" a ccess=\"read\"/>\n" \	" <property name=\"" prefix "ExitTimestampMonotonic\" type=\"t\" a ccess=\"read\"/>\n" \
	" <property name=\"" prefix "PID\" type=\"u\" access=\"read\"/>\n" \	" <property name=\"" prefix "PID\" type=\"u\" access=\"read\"/>\n" \
	" <property name=\"" prefix "Code\" type=\"i\" access=\"read\"/>\n " \	" <property name=\"" prefix "Code\" type=\"i\" access=\"read\"/>\n " \
	" <property name=\"" prefix "Status\" type=\"i\" access=\"read\"/> \n"	" <property name=\"" prefix "Status\" type=\"i\" access=\"read\"/> \n"


	skipping to change at line 96	skipping to change at line 97
	" <property name=\"ReadWriteDirectories\" type=\"as\" access=\"rea d\"/>\n" \	" <property name=\"ReadWriteDirectories\" type=\"as\" access=\"rea d\"/>\n" \
	" <property name=\"ReadOnlyDirectories\" type=\"as\" access=\"read \"/>\n" \	" <property name=\"ReadOnlyDirectories\" type=\"as\" access=\"read \"/>\n" \
	" <property name=\"InaccessibleDirectories\" type=\"as\" access=\" read\"/>\n" \	" <property name=\"InaccessibleDirectories\" type=\"as\" access=\" read\"/>\n" \
	" <property name=\"MountFlags\" type=\"t\" access=\"read\"/>\n" \	" <property name=\"MountFlags\" type=\"t\" access=\"read\"/>\n" \
	" <property name=\"PrivateTmp\" type=\"b\" access=\"read\"/>\n" \	" <property name=\"PrivateTmp\" type=\"b\" access=\"read\"/>\n" \
	" <property name=\"SameProcessGroup\" type=\"b\" access=\"read\"/> \n" \	" <property name=\"SameProcessGroup\" type=\"b\" access=\"read\"/> \n" \
	" <property name=\"KillMode\" type=\"s\" access=\"read\"/>\n" \	" <property name=\"KillMode\" type=\"s\" access=\"read\"/>\n" \
	" <property name=\"KillSignal\" type=\"i\" access=\"read\"/>\n" \	" <property name=\"KillSignal\" type=\"i\" access=\"read\"/>\n" \
	" <property name=\"UtmpIdentifier\" type=\"s\" access=\"read\"/>\n " \	" <property name=\"UtmpIdentifier\" type=\"s\" access=\"read\"/>\n " \
	" <property name=\"ControlGroupModify\" type=\"b\" access=\"read\" />\n" \	" <property name=\"ControlGroupModify\" type=\"b\" access=\"read\" />\n" \

		" <property name=\"ControlGroupPersistent\" type=\"b\" access=\"re ad\"/>\n" \
	" <property name=\"PrivateNetwork\" type=\"b\" access=\"read\"/>\n "	" <property name=\"PrivateNetwork\" type=\"b\" access=\"read\"/>\n "

	#define BUS_EXEC_COMMAND_INTERFACE(name) \	#define BUS_EXEC_COMMAND_INTERFACE(name) \
	" <property name=\"" name "\" type=\"a(sasbttuii)\" access=\"read\ "/>\n"	" <property name=\"" name "\" type=\"a(sasbttuii)\" access=\"read\ "/>\n"


	#define BUS_EXEC_CONTEXT_PROPERTIES(interface, context) \	extern const BusProperty bus_exec_context_properties[];
	{ interface, "Environment", bus_property_append_s
	trv, "as", (context).environment }, \
	{ interface, "EnvironmentFiles", bus_execute_append_en
	v_files, "a(sb)", (context).environment_files }, \
	{ interface, "UMask", bus_property_append_m
	ode, "u", &(context).umask }, \
	{ interface, "LimitCPU", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitFSIZE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitDATA", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitSTACK", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitCORE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitRSS", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitNOFILE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitAS", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitNPROC", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitMEMLOCK", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitLOCKS", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitSIGPENDING", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitMSGQUEUE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitNICE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitRTPRIO", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitRTTIME", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "WorkingDirectory", bus_property_append_s
	tring, "s", (context).working_directory }, \
	{ interface, "RootDirectory", bus_property_append_s
	tring, "s", (context).root_directory }, \
	{ interface, "OOMScoreAdjust", bus_execute_append_oo
	m_score_adjust, "i", &(context) }, \
	{ interface, "Nice", bus_execute_append_ni
	ce, "i", &(context) }, \
	{ interface, "IOScheduling", bus_execute_append_io
	prio, "i", &(context) }, \
	{ interface, "CPUSchedulingPolicy", bus_execute_append_cp
	u_sched_policy, "i", &(context) }, \
	{ interface, "CPUSchedulingPriority", bus_execute_append_cp
	u_sched_priority, "i", &(context) }, \
	{ interface, "CPUAffinity", bus_execute_append_af
	finity,"ay", &(context) }, \
	{ interface, "TimerSlackNSec", bus_execute_append_ti
	mer_slack_nsec, "t", &(context) }, \
	{ interface, "CPUSchedulingResetOnFork", bus_property_append_b
	ool, "b", &(context).cpu_sched_reset_on_fork }, \
	{ interface, "NonBlocking", bus_property_append_b
	ool, "b", &(context).non_blocking }, \
	{ interface, "StandardInput", bus_execute_append_in
	put, "s", &(context).std_input }, \
	{ interface, "StandardOutput", bus_execute_append_ou
	tput, "s", &(context).std_output }, \
	{ interface, "StandardError", bus_execute_append_ou
	tput, "s", &(context).std_error }, \
	{ interface, "TTYPath", bus_property_append_s
	tring, "s", (context).tty_path }, \
	{ interface, "TTYReset", bus_property_append_b
	ool, "b", &(context).tty_reset }, \
	{ interface, "TTYVHangup", bus_property_append_b
	ool, "b", &(context).tty_vhangup }, \
	{ interface, "TTYVTDisallocate", bus_property_append_b
	ool, "b", &(context).tty_vt_disallocate }, \
	{ interface, "SyslogPriority", bus_property_append_i
	nt, "i", &(context).syslog_priority }, \
	{ interface, "SyslogIdentifier", bus_property_append_s
	tring, "s", (context).syslog_identifier }, \
	{ interface, "SyslogLevelPrefix", bus_property_append_b
	ool, "b", &(context).syslog_level_prefix }, \
	{ interface, "Capabilities", bus_execute_append_ca
	pabilities, "s",&(context) }, \
	{ interface, "SecureBits", bus_property_append_i
	nt, "i", &(context).secure_bits }, \
	{ interface, "CapabilityBoundingSet", bus_execute_append_ca
	pability_bs, "t", &(context).capability_bounding_set_drop }, \
	{ interface, "User", bus_property_append_s
	tring, "s", (context).user }, \
	{ interface, "Group", bus_property_append_s
	tring, "s", (context).group }, \
	{ interface, "SupplementaryGroups", bus_property_append_s
	trv, "as", (context).supplementary_groups }, \
	{ interface, "TCPWrapName", bus_property_append_s
	tring, "s", (context).tcpwrap_name }, \
	{ interface, "PAMName", bus_property_append_s
	tring, "s", (context).pam_name }, \
	{ interface, "ReadWriteDirectories", bus_property_append_s
	trv, "as", (context).read_write_dirs }, \
	{ interface, "ReadOnlyDirectories", bus_property_append_s
	trv, "as", (context).read_only_dirs }, \
	{ interface, "InaccessibleDirectories", bus_property_append_s
	trv, "as", (context).inaccessible_dirs }, \
	{ interface, "MountFlags", bus_property_append_u
	l, "t", &(context).mount_flags }, \
	{ interface, "PrivateTmp", bus_property_append_b
	ool, "b", &(context).private_tmp }, \
	{ interface, "PrivateNetwork", bus_property_append_b
	ool, "b", &(context).private_network }, \
	{ interface, "SameProcessGroup", bus_property_append_b
	ool, "b", &(context).same_pgrp }, \
	{ interface, "KillMode", bus_execute_append_ki
	ll_mode, "s", &(context).kill_mode }, \
	{ interface, "KillSignal", bus_property_append_i
	nt, "i", &(context).kill_signal }, \
	{ interface, "UtmpIdentifier", bus_property_append_s
	tring, "s", (context).utmp_id }, \
	{ interface, "ControlGroupModify", bus_property_append_b
	ool, "b", &(context).control_group_modify }

	#define BUS_EXEC_STATUS_PROPERTIES(interface, estatus, prefix) \
	{ interface, prefix "StartTimestamp", bus_property_append_u
	sec, "t", &(estatus).start_timestamp.realtime }, \
	{ interface, prefix "StartTimestampMonotonic",bus_property_append_u
	sec, "t", &(estatus).start_timestamp.monotonic }, \
	{ interface, prefix "ExitTimestamp", bus_property_append_u
	sec, "t", &(estatus).start_timestamp.realtime }, \
	{ interface, prefix "ExitTimestampMonotonic", bus_property_append_u
	sec, "t", &(estatus).start_timestamp.monotonic }, \
	{ interface, prefix "PID", bus_property_append_p
	id, "u", &(estatus).pid }, \
	{ interface, prefix "Code", bus_property_append_i
	nt, "i", &(estatus).code }, \
	{ interface, prefix "Status", bus_property_append_i
	nt, "i", &(estatus).status }


	#define BUS_EXEC_COMMAND_PROPERTY(interface, command, name) \	#define BUS_EXEC_COMMAND_PROPERTY(name, command, indirect) \
	{ interface, name, bus_execute_append_command, "a(sasbttttuii)", (c	{ name, bus_execute_append_command, "a(sasbttttuii)", (command), (i
	ommand) }	ndirect), NULL }

	int bus_execute_append_output(DBusMessageIter i, const char property, voi d *data);	int bus_execute_append_output(DBusMessageIter i, const char property, voi d *data);
	int bus_execute_append_input(DBusMessageIter i, const char property, void *data);	int bus_execute_append_input(DBusMessageIter i, const char property, void *data);
	int bus_execute_append_oom_score_adjust(DBusMessageIter i, const char pro perty, void *data);	int bus_execute_append_oom_score_adjust(DBusMessageIter i, const char pro perty, void *data);
	int bus_execute_append_nice(DBusMessageIter i, const char property, void *data);	int bus_execute_append_nice(DBusMessageIter i, const char property, void *data);
	int bus_execute_append_ioprio(DBusMessageIter i, const char property, voi d *data);	int bus_execute_append_ioprio(DBusMessageIter i, const char property, voi d *data);
	int bus_execute_append_cpu_sched_policy(DBusMessageIter i, const char pro perty, void *data);	int bus_execute_append_cpu_sched_policy(DBusMessageIter i, const char pro perty, void *data);
	int bus_execute_append_cpu_sched_priority(DBusMessageIter i, const char p roperty, void *data);	int bus_execute_append_cpu_sched_priority(DBusMessageIter i, const char p roperty, void *data);
	int bus_execute_append_affinity(DBusMessageIter i, const char property, v oid *data);	int bus_execute_append_affinity(DBusMessageIter i, const char property, v oid *data);
	int bus_execute_append_timer_slack_nsec(DBusMessageIter i, const char pro perty, void *data);	int bus_execute_append_timer_slack_nsec(DBusMessageIter i, const char pro perty, void *data);

End of changes. 4 change blocks.
	138 lines changed or deleted	6 lines changed or added

	dbus-unit.h	dbus-unit.h

	skipping to change at line 28	skipping to change at line 28
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.	General Public License for more details.

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

	#include <dbus/dbus.h>	#include <dbus/dbus.h>

	#include "manager.h"	#include "manager.h"

		#include "dbus-common.h"

	#define BUS_UNIT_INTERFACE \	#define BUS_UNIT_INTERFACE \
	" <interface name=\"org.freedesktop.systemd1.Unit\">\n" \	" <interface name=\"org.freedesktop.systemd1.Unit\">\n" \
	" <method name=\"Start\">\n" \	" <method name=\"Start\">\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \	" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
	" </method>\n" \	" </method>\n" \
	" <method name=\"Stop\">\n" \	" <method name=\"Stop\">\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \	" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \

	skipping to change at line 129	skipping to change at line 130
	" <property name=\"ConditionTimestamp\" type=\"t\" access=\"read\" />\n" \	" <property name=\"ConditionTimestamp\" type=\"t\" access=\"read\" />\n" \
	" <property name=\"ConditionTimestampMonotonic\" type=\"t\" access =\"read\"/>\n" \	" <property name=\"ConditionTimestampMonotonic\" type=\"t\" access =\"read\"/>\n" \
	" <property name=\"ConditionResult\" type=\"b\" access=\"read\"/>\ n" \	" <property name=\"ConditionResult\" type=\"b\" access=\"read\"/>\ n" \
	" <property name=\"LoadError\" type=\"(ss)\" access=\"read\"/>\n" \	" <property name=\"LoadError\" type=\"(ss)\" access=\"read\"/>\n" \
	" </interface>\n"	" </interface>\n"

	#define BUS_UNIT_INTERFACES_LIST \	#define BUS_UNIT_INTERFACES_LIST \
	BUS_GENERIC_INTERFACES_LIST \	BUS_GENERIC_INTERFACES_LIST \
	"org.freedesktop.systemd1.Unit\0"	"org.freedesktop.systemd1.Unit\0"


	#define BUS_UNIT_PROPERTIES \	extern const BusProperty bus_unit_properties[];
	{ "org.freedesktop.systemd1.Unit", "Id", bus_prop
	erty_append_string, "s", u->meta.id }, \
	{ "org.freedesktop.systemd1.Unit", "Names", bus_unit
	_append_names, "as", u }, \
	{ "org.freedesktop.systemd1.Unit", "Following", bus_unit
	_append_following, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "Requires", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRES] }, \
	{ "org.freedesktop.systemd1.Unit", "RequiresOverridable", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRES_OVERRIDA
	BLE] }, \
	{ "org.freedesktop.systemd1.Unit", "Requisite", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUISITE] }, \
	{ "org.freedesktop.systemd1.Unit", "RequisiteOverridable", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUISITE_OVERRID
	ABLE] }, \
	{ "org.freedesktop.systemd1.Unit", "Wants", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_WANTS] }, \
	{ "org.freedesktop.systemd1.Unit", "BindTo", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_BIND_TO] }, \
	{ "org.freedesktop.systemd1.Unit", "RequiredBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRED_BY] }, \
	{ "org.freedesktop.systemd1.Unit", "RequiredByOverridable",bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRED_BY_OVERR
	IDABLE] }, \
	{ "org.freedesktop.systemd1.Unit", "WantedBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_WANTED_BY] }, \
	{ "org.freedesktop.systemd1.Unit", "BoundBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_BOUND_BY] }, \
	{ "org.freedesktop.systemd1.Unit", "Conflicts", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_CONFLICTS] }, \
	{ "org.freedesktop.systemd1.Unit", "ConflictedBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_CONFLICTED_BY] },
	\
	{ "org.freedesktop.systemd1.Unit", "Before", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_BEFORE] }, \
	{ "org.freedesktop.systemd1.Unit", "After", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_AFTER] }, \
	{ "org.freedesktop.systemd1.Unit", "OnFailure", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_ON_FAILURE] }, \
	{ "org.freedesktop.systemd1.Unit", "Triggers", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_TRIGGERS] }, \
	{ "org.freedesktop.systemd1.Unit", "TriggeredBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_TRIGGERED_BY] },
	\
	{ "org.freedesktop.systemd1.Unit", "PropagateReloadTo", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_PROPAGATE_RELOAD_
	TO] }, \
	{ "org.freedesktop.systemd1.Unit", "PropagateReloadFrom", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_PROPAGATE_RELOAD_
	FROM] }, \
	{ "org.freedesktop.systemd1.Unit", "Description", bus_unit
	_append_description, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "LoadState", bus_unit
	_append_load_state, "s", &u->meta.load_state }, \
	{ "org.freedesktop.systemd1.Unit", "ActiveState", bus_unit
	_append_active_state, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "SubState", bus_unit
	_append_sub_state, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "FragmentPath", bus_prop
	erty_append_string, "s", u->meta.fragment_path }, \
	{ "org.freedesktop.systemd1.Unit", "UnitFileState", bus_unit
	_append_file_state, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "InactiveExitTimestamp",bus_prop
	erty_append_usec, "t", &u->meta.inactive_exit_timestamp.realtime }
	, \
	{ "org.freedesktop.systemd1.Unit", "InactiveExitTimestampMonotonic"
	,bus_property_append_usec, "t", &u->meta.inactive_exit_timestamp.monotonic
	}, \
	{ "org.freedesktop.systemd1.Unit", "ActiveEnterTimestamp", bus_prop
	erty_append_usec, "t", &u->meta.active_enter_timestamp.realtime },
	\
	{ "org.freedesktop.systemd1.Unit", "ActiveEnterTimestampMonotonic",
	bus_property_append_usec, "t", &u->meta.active_enter_timestamp.monotonic }
	, \
	{ "org.freedesktop.systemd1.Unit", "ActiveExitTimestamp", bus_prop
	erty_append_usec, "t", &u->meta.active_exit_timestamp.realtime },
	\
	{ "org.freedesktop.systemd1.Unit", "ActiveExitTimestampMonotonic",
	bus_property_append_usec, "t", &u->meta.active_exit_timestamp.monotonic },
	\
	{ "org.freedesktop.systemd1.Unit", "InactiveEnterTimestamp",bus_pro
	perty_append_usec, "t", &u->meta.inactive_enter_timestamp.realtime
	}, \
	{ "org.freedesktop.systemd1.Unit", "InactiveEnterTimestampMonotonic
	",bus_property_append_usec,"t", &u->meta.inactive_enter_timestamp.monotonic
	}, \
	{ "org.freedesktop.systemd1.Unit", "CanStart", bus_unit
	_append_can_start, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "CanStop", bus_unit
	_append_can_stop, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "CanReload", bus_unit
	_append_can_reload, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "CanIsolate", bus_unit
	_append_can_isolate, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "Job", bus_unit
	_append_job, "(uo)", u }, \
	{ "org.freedesktop.systemd1.Unit", "StopWhenUnneeded", bus_prop
	erty_append_bool, "b", &u->meta.stop_when_unneeded }, \
	{ "org.freedesktop.systemd1.Unit", "RefuseManualStart", bus_prop
	erty_append_bool, "b", &u->meta.refuse_manual_start }, \
	{ "org.freedesktop.systemd1.Unit", "RefuseManualStop", bus_prop
	erty_append_bool, "b", &u->meta.refuse_manual_stop }, \
	{ "org.freedesktop.systemd1.Unit", "AllowIsolate", bus_prop
	erty_append_bool, "b", &u->meta.allow_isolate }, \
	{ "org.freedesktop.systemd1.Unit", "DefaultDependencies", bus_prop
	erty_append_bool, "b", &u->meta.default_dependencies }, \
	{ "org.freedesktop.systemd1.Unit", "OnFailureIsolate", bus_prop
	erty_append_bool, "b", &u->meta.on_failure_isolate }, \
	{ "org.freedesktop.systemd1.Unit", "IgnoreOnIsolate", bus_prop
	erty_append_bool, "b", &u->meta.ignore_on_isolate }, \
	{ "org.freedesktop.systemd1.Unit", "IgnoreOnSnapshot", bus_prop
	erty_append_bool, "b", &u->meta.ignore_on_snapshot }, \
	{ "org.freedesktop.systemd1.Unit", "DefaultControlGroup", bus_unit
	_append_default_cgroup, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "ControlGroup", bus_unit
	_append_cgroups, "as", u }, \
	{ "org.freedesktop.systemd1.Unit", "ControlGroupAttributes", bus_un
	it_append_cgroup_attrs, "a(sss)", u }, \
	{ "org.freedesktop.systemd1.Unit", "NeedDaemonReload", bus_unit
	_append_need_daemon_reload, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "JobTimeoutUSec", bus_prop
	erty_append_usec, "t", &u->meta.job_timeout }, \
	{ "org.freedesktop.systemd1.Unit", "ConditionTimestamp", bus_prop
	erty_append_usec, "t", &u->meta.condition_timestamp.realtime }, \
	{ "org.freedesktop.systemd1.Unit", "ConditionTimestampMonotonic", b
	us_property_append_usec,"t", &u->meta.condition_timestamp.monotonic }, \
	{ "org.freedesktop.systemd1.Unit", "ConditionResult", bus_prop
	erty_append_bool, "b", &u->meta.condition_result }, \
	{ "org.freedesktop.systemd1.Unit", "LoadError", bus_unit
	_append_load_error, "(ss)", u }

	int bus_unit_append_names(DBusMessageIter i, const char property, void *d
	ata);
	int bus_unit_append_following(DBusMessageIter i, const char property, voi
	d *data);
	int bus_unit_append_dependencies(DBusMessageIter i, const char property,
	void *data);
	int bus_unit_append_description(DBusMessageIter i, const char property, v
	oid *data);
	int bus_unit_append_load_state(DBusMessageIter i, const char property, vo
	id *data);
	int bus_unit_append_active_state(DBusMessageIter i, const char property,
	void *data);
	int bus_unit_append_sub_state(DBusMessageIter i, const char property, voi
	d *data);
	int bus_unit_append_file_state(DBusMessageIter i, const char property, vo
	id *data);
	int bus_unit_append_can_start(DBusMessageIter i, const char property, voi
	d *data);
	int bus_unit_append_can_stop(DBusMessageIter i, const char property, void
	*data);
	int bus_unit_append_can_reload(DBusMessageIter i, const char property, vo
	id *data);
	int bus_unit_append_can_isolate(DBusMessageIter i, const char property, v
	oid *data);
	int bus_unit_append_job(DBusMessageIter i, const char property, void *dat
	a);
	int bus_unit_append_default_cgroup(DBusMessageIter i, const char property
	, void *data);
	int bus_unit_append_cgroups(DBusMessageIter i, const char property, void
	*data);
	int bus_unit_append_cgroup_attrs(DBusMessageIter i, const char property,
	void *data);
	int bus_unit_append_need_daemon_reload(DBusMessageIter i, const char prop
	erty, void *data);
	int bus_unit_append_load_error(DBusMessageIter i, const char property, vo
	id *data);

	void bus_unit_send_change_signal(Unit *u);	void bus_unit_send_change_signal(Unit *u);
	void bus_unit_send_removed_signal(Unit *u);	void bus_unit_send_removed_signal(Unit *u);

	extern const DBusObjectPathVTable bus_unit_vtable;	extern const DBusObjectPathVTable bus_unit_vtable;

	extern const char bus_unit_interface[];	extern const char bus_unit_interface[];

	#endif	#endif

End of changes. 2 change blocks.
	169 lines changed or deleted	2 lines changed or added

	device.h	device.h

	skipping to change at line 39	skipping to change at line 39
	/* We simply watch devices, we cannot plug/unplug them. That	/* We simply watch devices, we cannot plug/unplug them. That
	* simplifies the state engine greatly */	* simplifies the state engine greatly */
	typedef enum DeviceState {	typedef enum DeviceState {
	DEVICE_DEAD,	DEVICE_DEAD,
	DEVICE_PLUGGED,	DEVICE_PLUGGED,
	_DEVICE_STATE_MAX,	_DEVICE_STATE_MAX,
	_DEVICE_STATE_INVALID = -1	_DEVICE_STATE_INVALID = -1
	} DeviceState;	} DeviceState;

	struct Device {	struct Device {

	Meta meta;	Unit meta;

	char *sysfs;	char *sysfs;

	/* In order to be able to distinguish dependencies on	/* In order to be able to distinguish dependencies on
	different device nodes we might end up creating multiple	different device nodes we might end up creating multiple
	devices for the same sysfs path. We chain them up here. */	devices for the same sysfs path. We chain them up here. */

	LIST_FIELDS(struct Device, same_sysfs);	LIST_FIELDS(struct Device, same_sysfs);

	DeviceState state;	DeviceState state;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	execute.h	execute.h

	skipping to change at line 166	skipping to change at line 166
	int syslog_priority;	int syslog_priority;
	char *syslog_identifier;	char *syslog_identifier;
	bool syslog_level_prefix;	bool syslog_level_prefix;

	bool cpu_sched_reset_on_fork;	bool cpu_sched_reset_on_fork;
	bool non_blocking;	bool non_blocking;
	bool private_tmp;	bool private_tmp;
	bool private_network;	bool private_network;

	bool control_group_modify;	bool control_group_modify;

		int control_group_persistent;

	/* This is not exposed to the user but available	/* This is not exposed to the user but available
	* internally. We need it to make sure that whenever we spawn	* internally. We need it to make sure that whenever we spawn
	* /bin/mount it is run in the same process group as us so	* /bin/mount it is run in the same process group as us so
	* that the autofs logic detects that it belongs to us and we	* that the autofs logic detects that it belongs to us and we
	* don't enter a trigger loop. */	* don't enter a trigger loop. */
	bool same_pgrp;	bool same_pgrp;

	bool oom_score_adjust_set:1;	bool oom_score_adjust_set:1;
	bool nice_set:1;	bool nice_set:1;

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	journal-file.h	journal-file.h

	skipping to change at line 80	skipping to change at line 80
	Window windows[_WINDOW_MAX];	Window windows[_WINDOW_MAX];

	uint64_t current_offset;	uint64_t current_offset;

	JournalMetrics metrics;	JournalMetrics metrics;

	bool compress;	bool compress;

	#ifdef HAVE_XZ	#ifdef HAVE_XZ
	void *compress_buffer;	void *compress_buffer;

	size_t compress_buffer_size;	uint64_t compress_buffer_size;
	#endif	#endif
	} JournalFile;	} JournalFile;

	typedef enum direction {	typedef enum direction {
	DIRECTION_UP,	DIRECTION_UP,
	DIRECTION_DOWN	DIRECTION_DOWN
	} direction_t;	} direction_t;

	int journal_file_open(const char fname, int flags, mode_t mode, JournalFil e template, JournalFile **ret);	int journal_file_open(const char fname, int flags, mode_t mode, JournalFil e template, JournalFile **ret);
	void journal_file_close(JournalFile *j);	void journal_file_close(JournalFile *j);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	journald.h	journald.h

	skipping to change at line 76	skipping to change at line 76

	bool import_proc_kmsg;	bool import_proc_kmsg;
	char proc_kmsg_buffer[LINE_MAX+1];	char proc_kmsg_buffer[LINE_MAX+1];
	size_t proc_kmsg_length;	size_t proc_kmsg_length;

	uint64_t cached_available_space;	uint64_t cached_available_space;
	usec_t cached_available_space_timestamp;	usec_t cached_available_space_timestamp;

	uint64_t var_available_timestamp;	uint64_t var_available_timestamp;


		gid_t file_gid;
		bool file_gid_valid;

	LIST_HEAD(StdoutStream, stdout_streams);	LIST_HEAD(StdoutStream, stdout_streams);
	unsigned n_stdout_streams;	unsigned n_stdout_streams;
	} Server;	} Server;

	/* gperf lookup function */	/* gperf lookup function */
	const struct ConfigPerfItem* journald_gperf_lookup(const char *key, unsigne d length);	const struct ConfigPerfItem* journald_gperf_lookup(const char *key, unsigne d length);

	#endif	#endif

End of changes. 1 change blocks.
	0 lines changed or deleted	3 lines changed or added

	log.h	log.h

	skipping to change at line 30	skipping to change at line 30

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

	#include <syslog.h>	#include <syslog.h>
	#include <stdbool.h>	#include <stdbool.h>

	#include "macro.h"	#include "macro.h"


	/* If set to SYSLOG and /dev/log can not be opened we fall back to
	* KSMG. If KMSG fails, we fall back to CONSOLE */
	typedef enum LogTarget{	typedef enum LogTarget{
	LOG_TARGET_CONSOLE,	LOG_TARGET_CONSOLE,
	LOG_TARGET_KMSG,	LOG_TARGET_KMSG,

		LOG_TARGET_JOURNAL,
		LOG_TARGET_JOURNAL_OR_KMSG,
	LOG_TARGET_SYSLOG,	LOG_TARGET_SYSLOG,
	LOG_TARGET_SYSLOG_OR_KMSG,	LOG_TARGET_SYSLOG_OR_KMSG,

	LOG_TARGET_AUTO, /* console if stderr is tty, SYSLOG_OR_KMSG otherw ise */	LOG_TARGET_AUTO, /* console if stderr is tty, JOURNAL_OR_KMSG other wise */
	LOG_TARGET_NULL,	LOG_TARGET_NULL,
	_LOG_TARGET_MAX,	_LOG_TARGET_MAX,
	_LOG_TARGET_INVALID = -1	_LOG_TARGET_INVALID = -1
	} LogTarget;	} LogTarget;

	void log_set_target(LogTarget target);	void log_set_target(LogTarget target);
	void log_set_max_level(int level);	void log_set_max_level(int level);

	int log_set_target_from_string(const char *e);	int log_set_target_from_string(const char *e);
	int log_set_max_level_from_string(const char *e);	int log_set_max_level_from_string(const char *e);

	skipping to change at line 63	skipping to change at line 63
	int log_show_location_from_string(const char *e);	int log_show_location_from_string(const char *e);

	LogTarget log_get_target(void);	LogTarget log_get_target(void);
	int log_get_max_level(void);	int log_get_max_level(void);

	int log_open(void);	int log_open(void);
	void log_close(void);	void log_close(void);
	void log_forget_fds(void);	void log_forget_fds(void);

	void log_close_syslog(void);	void log_close_syslog(void);

		void log_close_journal(void);
	void log_close_kmsg(void);	void log_close_kmsg(void);
	void log_close_console(void);	void log_close_console(void);

	void log_parse_environment(void);	void log_parse_environment(void);

	int log_meta(	int log_meta(
	int level,	int level,
	const char*file,	const char*file,
	int line,	int line,
	const char *func,	const char *func,
	const char *format, ...) _printf_attr_(5,6);	const char *format, ...) _printf_attr_(5,6);


	_noreturn_ void log_assert(	_noreturn_ void log_assert_failed(const char text, const char file, int l
	const char*file,	ine, const char *func);
	int line,	_noreturn_ void log_assert_failed_unreachable(const char *text, const char
	const char *func,	file, int line, const char func);
	const char *format, ...) _printf_attr_(4,5);

	/* This modifies the buffer passed! */	/* This modifies the buffer passed! */
	int log_dump_internal(	int log_dump_internal(
	int level,	int level,
	const char*file,	const char*file,
	int line,	int line,
	const char *func,	const char *func,
	char *buffer);	char *buffer);

	#define log_full(level, ...) log_meta(level, __FILE__, __LINE__, __func__, __VA_ARGS__)	#define log_full(level, ...) log_meta(level, __FILE__, __LINE__, __func__, __VA_ARGS__)

End of changes. 5 change blocks.
	8 lines changed or deleted	8 lines changed or added

	logs-show.h	logs-show.h

	skipping to change at line 37	skipping to change at line 37
	#include <systemd/sd-journal.h>	#include <systemd/sd-journal.h>

	#include "util.h"	#include "util.h"

	typedef enum OutputMode {	typedef enum OutputMode {
	OUTPUT_SHORT,	OUTPUT_SHORT,
	OUTPUT_SHORT_MONOTONIC,	OUTPUT_SHORT_MONOTONIC,
	OUTPUT_VERBOSE,	OUTPUT_VERBOSE,
	OUTPUT_EXPORT,	OUTPUT_EXPORT,
	OUTPUT_JSON,	OUTPUT_JSON,

		OUTPUT_CAT,
	_OUTPUT_MODE_MAX,	_OUTPUT_MODE_MAX,
	_OUTPUT_MODE_INVALID = -1	_OUTPUT_MODE_INVALID = -1
	} OutputMode;	} OutputMode;

	int output_journal(sd_journal *j, OutputMode mode, unsigned line, bool show _all);	int output_journal(sd_journal *j, OutputMode mode, unsigned line, bool show _all);

	int show_journal_by_unit(	int show_journal_by_unit(
	const char *unit,	const char *unit,
	OutputMode mode,	OutputMode mode,
	const char *prefix,	const char *prefix,

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	macro.h	macro.h

	skipping to change at line 94	skipping to change at line 94
	__extension__ ({ \	__extension__ ({ \
	typeof(x) _x = (x); \	typeof(x) _x = (x); \
	typeof(low) _low = (low); \	typeof(low) _low = (low); \
	typeof(high) _high = (high); \	typeof(high) _high = (high); \
	((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \	((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
	})	})

	#define assert_se(expr) \	#define assert_se(expr) \
	do { \	do { \
	if (_unlikely_(!(expr))) \	if (_unlikely_(!(expr))) \

	log_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__,	log_assert_failed(#expr, __FILE__, __LINE__, __PRET
	\	TY_FUNCTION__); \
	"Assertion '%s' failed at %s:%u, functio
	n %s(). Aborting.", \
	#expr , __FILE__, __LINE__, __PRETTY_FUN
	CTION__); \
	} while (false) \	} while (false) \

	/* We override the glibc assert() here. */	/* We override the glibc assert() here. */
	#undef assert	#undef assert
	#ifdef NDEBUG	#ifdef NDEBUG
	#define assert(expr) do {} while(false)	#define assert(expr) do {} while(false)
	#else	#else
	#define assert(expr) assert_se(expr)	#define assert(expr) assert_se(expr)
	#endif	#endif

	#define assert_not_reached(t) \	#define assert_not_reached(t) \
	do { \	do { \

	log_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \	log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRET
	"Code should not be reached '%s' at %s:%u, funct	TY_FUNCTION__); \
	ion %s(). Aborting.", \
	t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
	} while (false)	} while (false)

	#define assert_cc(expr) \	#define assert_cc(expr) \
	do { \	do { \
	switch (0) { \	switch (0) { \
	case 0: \	case 0: \
	case !!(expr): \	case !!(expr): \
	; \	; \
	} \	} \
	} while (false)	} while (false)

End of changes. 2 change blocks.
	10 lines changed or deleted	4 lines changed or added

	manager.h	manager.h

	skipping to change at line 77	skipping to change at line 77
	WATCH_SWAP,	WATCH_SWAP,
	WATCH_UDEV,	WATCH_UDEV,
	WATCH_DBUS_WATCH,	WATCH_DBUS_WATCH,
	WATCH_DBUS_TIMEOUT	WATCH_DBUS_TIMEOUT
	};	};

	struct Watch {	struct Watch {
	int fd;	int fd;
	WatchType type;	WatchType type;
	union {	union {

	union Unit *unit;	struct Unit *unit;
	struct Job *job;	struct Job *job;
	DBusWatch *bus_watch;	DBusWatch *bus_watch;
	DBusTimeout *bus_timeout;	DBusTimeout *bus_timeout;
	} data;	} data;
	bool fd_is_dupped:1;	bool fd_is_dupped:1;
	bool socket_accept:1;	bool socket_accept:1;
	};	};

	#include "unit.h"	#include "unit.h"
	#include "job.h"	#include "job.h"

	skipping to change at line 105	skipping to change at line 105
	/* Note that the set of units we know of is allowed to be	/* Note that the set of units we know of is allowed to be
	* inconsistent. However the subset of it that is loaded may	* inconsistent. However the subset of it that is loaded may
	* not, and the list of jobs may neither. */	* not, and the list of jobs may neither. */

	/* Active jobs and units */	/* Active jobs and units */
	Hashmap units; / name string => Unit object n:1 */	Hashmap units; / name string => Unit object n:1 */
	Hashmap jobs; / job id => Job object 1:1 */	Hashmap jobs; / job id => Job object 1:1 */

	/* To make it easy to iterate through the units of a specific	/* To make it easy to iterate through the units of a specific
	* type we maintain a per type linked list */	* type we maintain a per type linked list */

	LIST_HEAD(Meta, units_by_type[_UNIT_TYPE_MAX]);	LIST_HEAD(Unit, units_by_type[_UNIT_TYPE_MAX]);

	/* Units that need to be loaded */	/* Units that need to be loaded */

	LIST_HEAD(Meta, load_queue); /* this is actually more a stack than a queue, but uh. */	LIST_HEAD(Unit, load_queue); /* this is actually more a stack than a queue, but uh. */

	/* Jobs that need to be run */	/* Jobs that need to be run */
	LIST_HEAD(Job, run_queue); /* more a stack than a queue, too */	LIST_HEAD(Job, run_queue); /* more a stack than a queue, too */

	/* Units and jobs that have not yet been announced via	/* Units and jobs that have not yet been announced via
	* D-Bus. When something about a job changes it is added here	* D-Bus. When something about a job changes it is added here
	* if it is not in there yet. This allows easy coalescing of	* if it is not in there yet. This allows easy coalescing of
	* D-Bus change signals. */	* D-Bus change signals. */

	LIST_HEAD(Meta, dbus_unit_queue);	LIST_HEAD(Unit, dbus_unit_queue);
	LIST_HEAD(Job, dbus_job_queue);	LIST_HEAD(Job, dbus_job_queue);

	/* Units to remove */	/* Units to remove */

	LIST_HEAD(Meta, cleanup_queue);	LIST_HEAD(Unit, cleanup_queue);

	/* Units to check when doing GC */	/* Units to check when doing GC */

	LIST_HEAD(Meta, gc_queue);	LIST_HEAD(Unit, gc_queue);

	/* Jobs to be added */	/* Jobs to be added */
	Hashmap transaction_jobs; / Unit object => Job object list 1 :1 */	Hashmap transaction_jobs; / Unit object => Job object list 1 :1 */
	JobDependency *transaction_anchor;	JobDependency *transaction_anchor;

	Hashmap watch_pids; / pid => Unit object n:1 */	Hashmap watch_pids; / pid => Unit object n:1 */

	char *notify_socket;	char *notify_socket;

	Watch notify_watch;	Watch notify_watch;

	skipping to change at line 292	skipping to change at line 292
	void manager_send_unit_audit(Manager m, Unit u, int type, bool success);	void manager_send_unit_audit(Manager m, Unit u, int type, bool success);
	void manager_send_unit_plymouth(Manager m, Unit u);	void manager_send_unit_plymouth(Manager m, Unit u);

	bool manager_unit_pending_inactive(Manager m, const char name);	bool manager_unit_pending_inactive(Manager m, const char name);

	void manager_check_finished(Manager *m);	void manager_check_finished(Manager *m);

	void manager_run_generators(Manager *m);	void manager_run_generators(Manager *m);
	void manager_undo_generators(Manager *m);	void manager_undo_generators(Manager *m);


	void manager_recheck_syslog(Manager *m);	void manager_recheck_journal(Manager *m);

	void manager_set_show_status(Manager *m, bool b);	void manager_set_show_status(Manager *m, bool b);
	bool manager_get_show_status(Manager *m);	bool manager_get_show_status(Manager *m);

	const char *manager_running_as_to_string(ManagerRunningAs i);	const char *manager_running_as_to_string(ManagerRunningAs i);
	ManagerRunningAs manager_running_as_from_string(const char *s);	ManagerRunningAs manager_running_as_from_string(const char *s);

	#endif	#endif

End of changes. 7 change blocks.
	7 lines changed or deleted	7 lines changed or added

	mount.h	mount.h

	skipping to change at line 63	skipping to change at line 63
	} MountExecCommand;	} MountExecCommand;

	typedef struct MountParameters {	typedef struct MountParameters {
	char *what;	char *what;
	char *options;	char *options;
	char *fstype;	char *fstype;
	int passno;	int passno;
	} MountParameters;	} MountParameters;

	struct Mount {	struct Mount {

	Meta meta;	Unit meta;

	char *where;	char *where;

	MountParameters parameters_etc_fstab;	MountParameters parameters_etc_fstab;
	MountParameters parameters_proc_self_mountinfo;	MountParameters parameters_proc_self_mountinfo;
	MountParameters parameters_fragment;	MountParameters parameters_fragment;

	bool from_etc_fstab:1;	bool from_etc_fstab:1;
	bool from_proc_self_mountinfo:1;	bool from_proc_self_mountinfo:1;
	bool from_fragment:1;	bool from_fragment:1;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	path.h	path.h

	skipping to change at line 73	skipping to change at line 73
	int path_spec_watch(PathSpec s, Unit u);	int path_spec_watch(PathSpec s, Unit u);
	void path_spec_unwatch(PathSpec s, Unit u);	void path_spec_unwatch(PathSpec s, Unit u);
	int path_spec_fd_event(PathSpec *s, uint32_t events);	int path_spec_fd_event(PathSpec *s, uint32_t events);
	void path_spec_done(PathSpec *s);	void path_spec_done(PathSpec *s);

	static inline bool path_spec_owns_inotify_fd(PathSpec *s, int fd) {	static inline bool path_spec_owns_inotify_fd(PathSpec *s, int fd) {
	return s->inotify_fd == fd;	return s->inotify_fd == fd;
	}	}

	struct Path {	struct Path {

	Meta meta;	Unit meta;

	LIST_HEAD(PathSpec, specs);	LIST_HEAD(PathSpec, specs);

	UnitRef unit;	UnitRef unit;

	PathState state, deserialized_state;	PathState state, deserialized_state;

	bool failure;	bool failure;
	bool inotify_triggered;	bool inotify_triggered;


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	sd-id128.h	sd-id128.h

	skipping to change at line 29	skipping to change at line 29
	General Public License for more details.	General Public License for more details.

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

	#include <inttypes.h>	#include <inttypes.h>
	#include <stdbool.h>	#include <stdbool.h>
	#include <string.h>	#include <string.h>


		#ifdef __cplusplus
		extern "C" {
		#endif

	typedef union sd_id128 sd_id128_t;	typedef union sd_id128 sd_id128_t;

	union sd_id128 {	union sd_id128 {
	uint8_t bytes[16];	uint8_t bytes[16];
	uint64_t qwords[2];	uint64_t qwords[2];
	};	};

	char *sd_id128_to_string(sd_id128_t id, char s[33]);	char *sd_id128_to_string(sd_id128_t id, char s[33]);

	int sd_id128_from_string(const char s[33], sd_id128_t *ret);	int sd_id128_from_string(const char s[33], sd_id128_t *ret);

	skipping to change at line 61	skipping to change at line 65
	* times. It is hence not a good idea to call this macro with an	* times. It is hence not a good idea to call this macro with an
	* expensive function as paramater or an expression with side	* expensive function as paramater or an expression with side
	* effects */	* effects */
	#define SD_ID128_FORMAT_STR "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%0 2x%02x%02x%02x%02x"	#define SD_ID128_FORMAT_STR "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%0 2x%02x%02x%02x%02x"
	#define SD_ID128_FORMAT_VAL(x) (x).bytes[0], (x).bytes[1], (x).bytes[2], (x ).bytes[3], (x).bytes[4], (x).bytes[5], (x).bytes[6], (x).bytes[7], (x).byt es[8], (x).bytes[9], (x).bytes[10], (x).bytes[11], (x).bytes[12], (x).bytes [13], (x).bytes[14], (x).bytes[15]	#define SD_ID128_FORMAT_VAL(x) (x).bytes[0], (x).bytes[1], (x).bytes[2], (x ).bytes[3], (x).bytes[4], (x).bytes[5], (x).bytes[6], (x).bytes[7], (x).byt es[8], (x).bytes[9], (x).bytes[10], (x).bytes[11], (x).bytes[12], (x).bytes [13], (x).bytes[14], (x).bytes[15]

	static inline bool sd_id128_equal(sd_id128_t a, sd_id128_t b) {	static inline bool sd_id128_equal(sd_id128_t a, sd_id128_t b) {
	return memcmp(&a, &b, 16) == 0;	return memcmp(&a, &b, 16) == 0;
	}	}


		#ifdef __cplusplus
		}
		#endif

	#endif	#endif

End of changes. 2 change blocks.
	0 lines changed or deleted	8 lines changed or added

	sd-journal.h	sd-journal.h

	skipping to change at line 32	skipping to change at line 32
	along with systemd; If not, see <http://www.gnu.org/licenses/>.	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/	***/

	#include <inttypes.h>	#include <inttypes.h>
	#include <sys/types.h>	#include <sys/types.h>
	#include <stdarg.h>	#include <stdarg.h>
	#include <sys/uio.h>	#include <sys/uio.h>

	#include <systemd/sd-id128.h>	#include <systemd/sd-id128.h>


	/* TODO:	#ifdef __cplusplus
	*	extern "C" {
	* - OR of matches is borked...	#endif
	* - extend hash tables table as we go
	* - accelerate looking for "all hostnames" and suchlike.
	* - handle incomplete header
	*
	* - kann NTP nicht finden?
	*
	* - local deserializer
	* - http server
	* - message catalog
	*
	* - check LE/BE conversion for 8bit, 16bit, 32bit values
	* - cryptographic hash
	* - think about manipulations of header
	* - implement audit gateway
	*/

	/* Write to daemon */	/* Write to daemon */

	int sd_journal_print(int piority, const char *format, ...) __attribute__ (( format (printf, 2, 3)));	int sd_journal_print(int piority, const char *format, ...) __attribute__ (( format (printf, 2, 3)));
	int sd_journal_printv(int priority, const char *format, va_list ap);	int sd_journal_printv(int priority, const char *format, va_list ap);

	int sd_journal_send(const char *format, ...) __attribute__((sentinel));	int sd_journal_send(const char *format, ...) __attribute__((sentinel));
	int sd_journal_sendv(const struct iovec *iov, int n);	int sd_journal_sendv(const struct iovec *iov, int n);

	int sd_journal_stream_fd(const char *identifier, int priority, int level_pr efix);	int sd_journal_stream_fd(const char *identifier, int priority, int level_pr efix);

	skipping to change at line 125	skipping to change at line 110
	#define SD_JOURNAL_FOREACH_BACKWARDS(j) \	#define SD_JOURNAL_FOREACH_BACKWARDS(j) \
	if (sd_journal_seek_tail(j) >= 0) \	if (sd_journal_seek_tail(j) >= 0) \
	while (sd_journal_previous(j) > 0)	while (sd_journal_previous(j) > 0)

	#define SD_JOURNAL_FOREACH_DATA(j, data, l) \	#define SD_JOURNAL_FOREACH_DATA(j, data, l) \
	for (sd_journal_restart_data(j); sd_journal_enumerate_data((j), &(d ata), &(l)) > 0; )	for (sd_journal_restart_data(j); sd_journal_enumerate_data((j), &(d ata), &(l)) > 0; )

	#define SD_JOURNAL_FOREACH_UNIQUE(j, data, l) \	#define SD_JOURNAL_FOREACH_UNIQUE(j, data, l) \
	for (sd_journal_restart_unique(j); sd_journal_enumerate_data((j), & (data), &(l)) > 0; )	for (sd_journal_restart_unique(j); sd_journal_enumerate_data((j), & (data), &(l)) > 0; )


		#ifdef __cplusplus
		}
		#endif

	#endif	#endif

End of changes. 2 change blocks.
	18 lines changed or deleted	7 lines changed or added

	sd-login.h	sd-login.h

	skipping to change at line 27	skipping to change at line 27
	WITHOUT ANY WARRANTY; without even the implied warranty of	WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.	General Public License for more details.

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

	#include <sys/types.h>	#include <sys/types.h>


		#ifdef __cplusplus
		extern "C" {
		#endif

	/*	/*
	* A few points:	* A few points:
	*	*
	* Instead of returning an empty string array or empty uid array, we	* Instead of returning an empty string array or empty uid array, we
	* may return NULL.	* may return NULL.
	*	*
	* Free the data we return with libc free().	* Free the data we return with libc free().
	*	*
	* We return error codes as negative errno, kernel-style. 0 or	* We return error codes as negative errno, kernel-style. 0 or
	* positive on success.	* positive on success.

	skipping to change at line 128	skipping to change at line 132

	/* Destroys the passed monitor. Returns NULL. */	/* Destroys the passed monitor. Returns NULL. */
	sd_login_monitor* sd_login_monitor_unref(sd_login_monitor *m);	sd_login_monitor* sd_login_monitor_unref(sd_login_monitor *m);

	/* Flushes the monitor */	/* Flushes the monitor */
	int sd_login_monitor_flush(sd_login_monitor *m);	int sd_login_monitor_flush(sd_login_monitor *m);

	/* Get FD from monitor */	/* Get FD from monitor */
	int sd_login_monitor_get_fd(sd_login_monitor *m);	int sd_login_monitor_get_fd(sd_login_monitor *m);


		#ifdef __cplusplus
		}
		#endif

	#endif	#endif

End of changes. 2 change blocks.
	0 lines changed or deleted	8 lines changed or added

	sd-messages.h	sd-messages.h

	skipping to change at line 27	skipping to change at line 27
	WITHOUT ANY WARRANTY; without even the implied warranty of	WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.	General Public License for more details.

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

	#include <systemd/sd-id128.h>	#include <systemd/sd-id128.h>


		#ifdef __cplusplus
		extern "C" {
		#endif

	#define SD_MESSAGE_JOURNAL_START SD_ID128_MAKE(f7,73,79,a8,49,0b,40,8b,be ,5f,69,40,50,5a,77,7b)	#define SD_MESSAGE_JOURNAL_START SD_ID128_MAKE(f7,73,79,a8,49,0b,40,8b,be ,5f,69,40,50,5a,77,7b)
	#define SD_MESSAGE_JOURNAL_STOP SD_ID128_MAKE(d9,3f,b3,c9,c2,4d,45,1a,97 ,ce,a6,15,ce,59,c0,0b)	#define SD_MESSAGE_JOURNAL_STOP SD_ID128_MAKE(d9,3f,b3,c9,c2,4d,45,1a,97 ,ce,a6,15,ce,59,c0,0b)
	#define SD_MESSAGE_JOURNAL_DROPPED SD_ID128_MAKE(a5,96,d6,fe,7b,fa,49,94,82 ,8e,72,30,9e,95,d6,1e)	#define SD_MESSAGE_JOURNAL_DROPPED SD_ID128_MAKE(a5,96,d6,fe,7b,fa,49,94,82 ,8e,72,30,9e,95,d6,1e)


		#define SD_MESSAGE_COREDUMP SD_ID128_MAKE(fc,2e,22,bc,6e,e6,47,b6,b9
		,07,29,ab,34,a2,50,b1)

		#ifdef __cplusplus
		}
		#endif

	#endif	#endif

End of changes. 2 change blocks.
	0 lines changed or deleted	11 lines changed or added

	service.h	service.h

	skipping to change at line 92	skipping to change at line 92

	typedef enum NotifyAccess {	typedef enum NotifyAccess {
	NOTIFY_NONE,	NOTIFY_NONE,
	NOTIFY_ALL,	NOTIFY_ALL,
	NOTIFY_MAIN,	NOTIFY_MAIN,
	_NOTIFY_ACCESS_MAX,	_NOTIFY_ACCESS_MAX,
	_NOTIFY_ACCESS_INVALID = -1	_NOTIFY_ACCESS_INVALID = -1
	} NotifyAccess;	} NotifyAccess;

	struct Service {	struct Service {

	Meta meta;	Unit meta;

	ServiceType type;	ServiceType type;
	ServiceRestart restart;	ServiceRestart restart;

	/* If set we'll read the main daemon PID from this file */	/* If set we'll read the main daemon PID from this file */
	char *pid_file;	char *pid_file;

	usec_t restart_usec;	usec_t restart_usec;
	usec_t timeout_usec;	usec_t timeout_usec;


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	snapshot.h	snapshot.h

	skipping to change at line 37	skipping to change at line 37
	#include "unit.h"	#include "unit.h"

	typedef enum SnapshotState {	typedef enum SnapshotState {
	SNAPSHOT_DEAD,	SNAPSHOT_DEAD,
	SNAPSHOT_ACTIVE,	SNAPSHOT_ACTIVE,
	_SNAPSHOT_STATE_MAX,	_SNAPSHOT_STATE_MAX,
	_SNAPSHOT_STATE_INVALID = -1	_SNAPSHOT_STATE_INVALID = -1
	} SnapshotState;	} SnapshotState;

	struct Snapshot {	struct Snapshot {

	Meta meta;	Unit meta;

	SnapshotState state, deserialized_state;	SnapshotState state, deserialized_state;

	bool cleanup;	bool cleanup;
	bool by_snapshot_create:1;	bool by_snapshot_create:1;
	};	};

	extern const UnitVTable snapshot_vtable;	extern const UnitVTable snapshot_vtable;

	int snapshot_create(Manager m, const char name, bool cleanup, DBusError * e, Snapshot **s);	int snapshot_create(Manager m, const char name, bool cleanup, DBusError * e, Snapshot **s);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	socket.h	socket.h

	skipping to change at line 80	skipping to change at line 80
	int fd;	int fd;

	SocketAddress address;	SocketAddress address;
	char *path;	char *path;
	Watch fd_watch;	Watch fd_watch;

	LIST_FIELDS(struct SocketPort, port);	LIST_FIELDS(struct SocketPort, port);
	} SocketPort;	} SocketPort;

	struct Socket {	struct Socket {

	Meta meta;	Unit meta;

	LIST_HEAD(SocketPort, ports);	LIST_HEAD(SocketPort, ports);

	unsigned n_accepted;	unsigned n_accepted;
	unsigned n_connections;	unsigned n_connections;
	unsigned max_connections;	unsigned max_connections;

	unsigned backlog;	unsigned backlog;
	usec_t timeout_usec;	usec_t timeout_usec;


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	swap.h	swap.h

	skipping to change at line 60	skipping to change at line 60

	typedef struct SwapParameters {	typedef struct SwapParameters {
	char *what;	char *what;
	int priority;	int priority;
	bool noauto:1;	bool noauto:1;
	bool nofail:1;	bool nofail:1;
	bool handle:1;	bool handle:1;
	} SwapParameters;	} SwapParameters;

	struct Swap {	struct Swap {

	Meta meta;	Unit meta;

	char *what;	char *what;

	SwapParameters parameters_etc_fstab;	SwapParameters parameters_etc_fstab;
	SwapParameters parameters_proc_swaps;	SwapParameters parameters_proc_swaps;
	SwapParameters parameters_fragment;	SwapParameters parameters_fragment;

	bool from_etc_fstab:1;	bool from_etc_fstab:1;
	bool from_proc_swaps:1;	bool from_proc_swaps:1;
	bool from_fragment:1;	bool from_fragment:1;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	target.h	target.h

	skipping to change at line 37	skipping to change at line 37
	#include "unit.h"	#include "unit.h"

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

	struct Target {	struct Target {

	Meta meta;	Unit meta;

	TargetState state, deserialized_state;	TargetState state, deserialized_state;
	};	};

	extern const UnitVTable target_vtable;	extern const UnitVTable target_vtable;

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

	#endif	#endif

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	timer.h	timer.h

	skipping to change at line 60	skipping to change at line 60
	usec_t value;	usec_t value;
	usec_t next_elapse;	usec_t next_elapse;

	LIST_FIELDS(struct TimerValue, value);	LIST_FIELDS(struct TimerValue, value);

	TimerBase base;	TimerBase base;
	bool disabled;	bool disabled;
	} TimerValue;	} TimerValue;

	struct Timer {	struct Timer {

	Meta meta;	Unit meta;

	LIST_HEAD(TimerValue, values);	LIST_HEAD(TimerValue, values);
	usec_t next_elapse;	usec_t next_elapse;

	TimerState state, deserialized_state;	TimerState state, deserialized_state;
	UnitRef unit;	UnitRef unit;

	Watch timer_watch;	Watch timer_watch;

	bool failure;	bool failure;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	unit.h	unit.h

	skipping to change at line 28	skipping to change at line 28
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.	General Public License for more details.

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

	#include <stdbool.h>	#include <stdbool.h>
	#include <stdlib.h>	#include <stdlib.h>


	typedef union Unit Unit;	typedef struct Unit Unit;
	typedef struct Meta Meta;
	typedef struct UnitVTable UnitVTable;	typedef struct UnitVTable UnitVTable;
	typedef enum UnitType UnitType;	typedef enum UnitType UnitType;
	typedef enum UnitLoadState UnitLoadState;	typedef enum UnitLoadState UnitLoadState;
	typedef enum UnitActiveState UnitActiveState;	typedef enum UnitActiveState UnitActiveState;
	typedef enum UnitDependency UnitDependency;	typedef enum UnitDependency UnitDependency;
	typedef struct UnitRef UnitRef;	typedef struct UnitRef UnitRef;

	#include "set.h"	#include "set.h"
	#include "util.h"	#include "util.h"
	#include "list.h"	#include "list.h"

	skipping to change at line 144	skipping to change at line 143

	_UNIT_DEPENDENCY_MAX,	_UNIT_DEPENDENCY_MAX,
	_UNIT_DEPENDENCY_INVALID = -1	_UNIT_DEPENDENCY_INVALID = -1
	};	};

	#include "manager.h"	#include "manager.h"
	#include "job.h"	#include "job.h"
	#include "cgroup.h"	#include "cgroup.h"
	#include "cgroup-attr.h"	#include "cgroup-attr.h"


	struct Meta {	struct Unit {
	Manager *manager;	Manager *manager;

	UnitType type;	UnitType type;
	UnitLoadState load_state;	UnitLoadState load_state;
	Unit *merged_into;	Unit *merged_into;

	char id; / One name is special because we use it for identificati on. Points to an entry in the names set */	char id; / One name is special because we use it for identificati on. Points to an entry in the names set */
	char *instance;	char *instance;

	Set *names;	Set *names;

	skipping to change at line 186	skipping to change at line 185
	dual_timestamp inactive_exit_timestamp;	dual_timestamp inactive_exit_timestamp;
	dual_timestamp active_enter_timestamp;	dual_timestamp active_enter_timestamp;
	dual_timestamp active_exit_timestamp;	dual_timestamp active_exit_timestamp;
	dual_timestamp inactive_enter_timestamp;	dual_timestamp inactive_enter_timestamp;

	/* Counterparts in the cgroup filesystem */	/* Counterparts in the cgroup filesystem */
	CGroupBonding *cgroup_bondings;	CGroupBonding *cgroup_bondings;
	CGroupAttribute *cgroup_attributes;	CGroupAttribute *cgroup_attributes;

	/* Per type list */	/* Per type list */

	LIST_FIELDS(Meta, units_by_type);	LIST_FIELDS(Unit, units_by_type);

	/* Load queue */	/* Load queue */

	LIST_FIELDS(Meta, load_queue);	LIST_FIELDS(Unit, load_queue);

	/* D-Bus queue */	/* D-Bus queue */

	LIST_FIELDS(Meta, dbus_queue);	LIST_FIELDS(Unit, dbus_queue);

	/* Cleanup queue */	/* Cleanup queue */

	LIST_FIELDS(Meta, cleanup_queue);	LIST_FIELDS(Unit, cleanup_queue);

	/* GC queue */	/* GC queue */

	LIST_FIELDS(Meta, gc_queue);	LIST_FIELDS(Unit, gc_queue);

	/* Used during GC sweeps */	/* Used during GC sweeps */
	unsigned gc_marker;	unsigned gc_marker;

	/* When deserializing, temporarily store the job type for this	/* When deserializing, temporarily store the job type for this
	* unit here, if there was a job scheduled */	* unit here, if there was a job scheduled */
	int deserialized_job; /* This is actually of type JobType */	int deserialized_job; /* This is actually of type JobType */

	/* Error code when we didn't manage to load the unit (negative) */	/* Error code when we didn't manage to load the unit (negative) */
	int load_error;	int load_error;

	skipping to change at line 272	skipping to change at line 271
	#include "timer.h"	#include "timer.h"
	#include "socket.h"	#include "socket.h"
	#include "target.h"	#include "target.h"
	#include "device.h"	#include "device.h"
	#include "mount.h"	#include "mount.h"
	#include "automount.h"	#include "automount.h"
	#include "snapshot.h"	#include "snapshot.h"
	#include "swap.h"	#include "swap.h"
	#include "path.h"	#include "path.h"


	union Unit {
	Meta meta;
	Service service;
	Timer timer;
	Socket socket;
	Target target;
	Device device;
	Mount mount;
	Automount automount;
	Snapshot snapshot;
	Swap swap;
	Path path;
	};

	struct UnitVTable {	struct UnitVTable {
	const char *suffix;	const char *suffix;


		/* How much memory does an object of this unit type need */
		size_t object_size;

	/* Config file sections this unit type understands, separated	/* Config file sections this unit type understands, separated
	* by NUL chars */	* by NUL chars */
	const char *sections;	const char *sections;

	/* This should reset all type-specific variables. This should	/* This should reset all type-specific variables. This should
	* not allocate memory, and is called with zero-initialized	* not allocate memory, and is called with zero-initialized
	* data. It should hence only initialize variables that need	* data. It should hence only initialize variables that need
	* to be set != 0. */	* to be set != 0. */
	void (init)(Unit u);	void (init)(Unit u);


	skipping to change at line 413	skipping to change at line 401

	/* Exclude from automatic gc */	/* Exclude from automatic gc */
	bool no_gc:1;	bool no_gc:1;

	/* Show status updates on the console */	/* Show status updates on the console */
	bool show_status:1;	bool show_status:1;
	};	};

	extern const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX];	extern const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX];


	#define UNIT_VTABLE(u) unit_vtable[(u)->meta.type]	#define UNIT_VTABLE(u) unit_vtable[(u)->type]

	/* For casting a unit into the various unit types */	/* For casting a unit into the various unit types */
	#define DEFINE_CAST(UPPERCASE, MixedCase) \	#define DEFINE_CAST(UPPERCASE, MixedCase) \
	static inline MixedCase* UPPERCASE(Unit *u) { \	static inline MixedCase* UPPERCASE(Unit *u) { \

	if (_unlikely_(!u \|\| u->meta.type != UNIT_##UPPERCASE)) \	if (_unlikely_(!u \|\| u->type != UNIT_##UPPERCASE)) \
	return NULL; \	return NULL; \
	\	\
	return (MixedCase*) u; \	return (MixedCase*) u; \
	}	}

	/* For casting the various unit types into a unit */	/* For casting the various unit types into a unit */

	#define UNIT(u) ((Unit*) (&(u)->meta))	#define UNIT(u) (&(u)->meta)

	DEFINE_CAST(SOCKET, Socket);	DEFINE_CAST(SOCKET, Socket);
	DEFINE_CAST(TIMER, Timer);	DEFINE_CAST(TIMER, Timer);
	DEFINE_CAST(SERVICE, Service);	DEFINE_CAST(SERVICE, Service);
	DEFINE_CAST(TARGET, Target);	DEFINE_CAST(TARGET, Target);
	DEFINE_CAST(DEVICE, Device);	DEFINE_CAST(DEVICE, Device);
	DEFINE_CAST(MOUNT, Mount);	DEFINE_CAST(MOUNT, Mount);
	DEFINE_CAST(AUTOMOUNT, Automount);	DEFINE_CAST(AUTOMOUNT, Automount);
	DEFINE_CAST(SNAPSHOT, Snapshot);	DEFINE_CAST(SNAPSHOT, Snapshot);
	DEFINE_CAST(SWAP, Swap);	DEFINE_CAST(SWAP, Swap);
	DEFINE_CAST(PATH, Path);	DEFINE_CAST(PATH, Path);


	Unit unit_new(Manager m);	Unit unit_new(Manager m, size_t size);
	void unit_free(Unit *u);	void unit_free(Unit *u);

	int unit_add_name(Unit u, const char name);	int unit_add_name(Unit u, const char name);

	int unit_add_dependency(Unit u, UnitDependency d, Unit other, bool add_re ference);	int unit_add_dependency(Unit u, UnitDependency d, Unit other, bool add_re ference);
	int unit_add_two_dependencies(Unit u, UnitDependency d, UnitDependency e, Unit other, bool add_reference);	int unit_add_two_dependencies(Unit u, UnitDependency d, UnitDependency e, Unit other, bool add_reference);

	int unit_add_dependency_by_name(Unit u, UnitDependency d, const char name , const char *filename, bool add_reference);	int unit_add_dependency_by_name(Unit u, UnitDependency d, const char name , const char *filename, bool add_reference);
	int unit_add_two_dependencies_by_name(Unit u, UnitDependency d, UnitDepend ency e, const char name, const char *path, bool add_reference);	int unit_add_two_dependencies_by_name(Unit u, UnitDependency d, UnitDepend ency e, const char name, const char *path, bool add_reference);


End of changes. 13 change blocks.
	26 lines changed or deleted	14 lines changed or added

	util.h	util.h

	skipping to change at line 70	skipping to change at line 70

	/* What is interpreted as whitespace? */	/* What is interpreted as whitespace? */
	#define WHITESPACE " \t\n\r"	#define WHITESPACE " \t\n\r"
	#define NEWLINE "\n\r"	#define NEWLINE "\n\r"
	#define QUOTES "\"\'"	#define QUOTES "\"\'"
	#define COMMENTS "#;\n"	#define COMMENTS "#;\n"

	#define FORMAT_TIMESTAMP_MAX 64	#define FORMAT_TIMESTAMP_MAX 64
	#define FORMAT_TIMESTAMP_PRETTY_MAX 256	#define FORMAT_TIMESTAMP_PRETTY_MAX 256
	#define FORMAT_TIMESPAN_MAX 64	#define FORMAT_TIMESPAN_MAX 64

		#define FORMAT_BYTES_MAX 8


	#define ANSI_HIGHLIGHT_ON "\x1B[1;31m"	#define ANSI_HIGHLIGHT_ON "\x1B[1;39m"
		#define ANSI_HIGHLIGHT_RED_ON "\x1B[1;31m"
	#define ANSI_HIGHLIGHT_GREEN_ON "\x1B[1;32m"	#define ANSI_HIGHLIGHT_GREEN_ON "\x1B[1;32m"
	#define ANSI_HIGHLIGHT_OFF "\x1B[0m"	#define ANSI_HIGHLIGHT_OFF "\x1B[0m"

	usec_t now(clockid_t clock);	usec_t now(clockid_t clock);

	dual_timestamp* dual_timestamp_get(dual_timestamp *ts);	dual_timestamp* dual_timestamp_get(dual_timestamp *ts);
	dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);	dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);

	#define dual_timestamp_is_set(ts) ((ts)->realtime > 0)	#define dual_timestamp_is_set(ts) ((ts)->realtime > 0)


	skipping to change at line 328	skipping to change at line 330

	int fd_nonblock(int fd, bool nonblock);	int fd_nonblock(int fd, bool nonblock);
	int fd_cloexec(int fd, bool cloexec);	int fd_cloexec(int fd, bool cloexec);

	int close_all_fds(const int except[], unsigned n_except);	int close_all_fds(const int except[], unsigned n_except);

	bool fstype_is_network(const char *fstype);	bool fstype_is_network(const char *fstype);

	int chvt(int vt);	int chvt(int vt);


	int read_one_char(FILE f, char ret, bool *need_nl);	int read_one_char(FILE f, char ret, usec_t timeout, bool *need_nl);
	int ask(char ret, const char replies, const char *text, ...);	int ask(char ret, const char replies, const char *text, ...);

	int reset_terminal_fd(int fd);	int reset_terminal_fd(int fd);
	int reset_terminal(const char *name);	int reset_terminal(const char *name);

	int open_terminal(const char *name, int mode);	int open_terminal(const char *name, int mode);
	int acquire_terminal(const char *name, bool fail, bool force, bool ignore_t iocstty_eperm);	int acquire_terminal(const char *name, bool fail, bool force, bool ignore_t iocstty_eperm);
	int release_terminal(void);	int release_terminal(void);

	int flush_fd(int fd);	int flush_fd(int fd);

	skipping to change at line 385	skipping to change at line 387

	cpu_set_t* cpu_set_malloc(unsigned *ncpus);	cpu_set_t* cpu_set_malloc(unsigned *ncpus);

	void status_vprintf(const char status, bool ellipse, const char format, v a_list ap);	void status_vprintf(const char status, bool ellipse, const char format, v a_list ap);
	void status_printf(const char status, bool ellipse, const char format, .. .);	void status_printf(const char status, bool ellipse, const char format, .. .);
	void status_welcome(void);	void status_welcome(void);

	int fd_columns(int fd);	int fd_columns(int fd);
	unsigned columns(void);	unsigned columns(void);


		int fd_lines(int fd);
		unsigned lines(void);

	int running_in_chroot(void);	int running_in_chroot(void);

	char ellipsize(const char s, size_t length, unsigned percent);	char ellipsize(const char s, size_t length, unsigned percent);
	char ellipsize_mem(const char s, size_t old_length, size_t new_length, un signed percent);	char ellipsize_mem(const char s, size_t old_length, size_t new_length, un signed percent);

	int touch(const char *path);	int touch(const char *path);

	char unquote(const char s, const char *quotes);	char unquote(const char s, const char *quotes);
	char normalize_env_assignment(const char s);	char normalize_env_assignment(const char s);


	skipping to change at line 413	skipping to change at line 418
	DIR xopendirat(int dirfd, const char name, int flags);	DIR xopendirat(int dirfd, const char name, int flags);

	void dual_timestamp_serialize(FILE f, const char name, dual_timestamp *t) ;	void dual_timestamp_serialize(FILE f, const char name, dual_timestamp *t) ;
	void dual_timestamp_deserialize(const char value, dual_timestamp t);	void dual_timestamp_deserialize(const char value, dual_timestamp t);

	char fstab_node_to_udev_node(const char p);	char fstab_node_to_udev_node(const char p);

	void filter_environ(const char *prefix);	void filter_environ(const char *prefix);

	bool tty_is_vc(const char *tty);	bool tty_is_vc(const char *tty);

		bool tty_is_vc_resolve(const char *tty);
	int vtnr_from_tty(const char *tty);	int vtnr_from_tty(const char *tty);
	const char default_term_for_tty(const char tty);	const char default_term_for_tty(const char tty);

	void execute_directory(const char directory, DIR _d, char *argv[]);	void execute_directory(const char directory, DIR _d, char *argv[]);

	int kill_and_sigcont(pid_t pid, int sig);	int kill_and_sigcont(pid_t pid, int sig);

	bool nulstr_contains(const charnulstr, const char needle);	bool nulstr_contains(const charnulstr, const char needle);

	bool plymouth_running(void);	bool plymouth_running(void);

	skipping to change at line 478	skipping to change at line 484
	int get_files_in_directory(const char path, char **list);	int get_files_in_directory(const char path, char **list);

	char join(const char x, ...) _sentinel_;	char join(const char x, ...) _sentinel_;

	bool is_main_thread(void);	bool is_main_thread(void);

	bool in_charset(const char s, const char charset);	bool in_charset(const char s, const char charset);

	int block_get_whole_disk(dev_t d, dev_t *ret);	int block_get_whole_disk(dev_t d, dev_t *ret);


	int file_is_sticky(const char *p);	int file_is_priv_sticky(const char *p);

	int strdup_or_null(const char a, char *b);	int strdup_or_null(const char a, char *b);

	#define NULSTR_FOREACH(i, l) \	#define NULSTR_FOREACH(i, l) \
	for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)	for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)

	#define NULSTR_FOREACH_PAIR(i, j, l) \	#define NULSTR_FOREACH_PAIR(i, j, l) \
	for ((i) = (l), (j) = strchr((i), 0)+1; (i) && (i); (i) = strchr(( j), 0)+1, (j) = (i) ? strchr((i), 0)+1 : (i))	for ((i) = (l), (j) = strchr((i), 0)+1; (i) && (i); (i) = strchr(( j), 0)+1, (j) = (i) ? strchr((i), 0)+1 : (i))

	const char *ioprio_class_to_string(int i);	const char *ioprio_class_to_string(int i);

	skipping to change at line 525	skipping to change at line 531
	extern char **saved_argv;	extern char **saved_argv;

	bool kexec_loaded(void);	bool kexec_loaded(void);

	int prot_from_flags(int flags);	int prot_from_flags(int flags);

	unsigned long cap_last_cap(void);	unsigned long cap_last_cap(void);

	char format_bytes(char buf, size_t l, off_t t);	char format_bytes(char buf, size_t l, off_t t);


	int fd_wait_for_event(int fd, int event);	int fd_wait_for_event(int fd, int event, usec_t timeout);

	void* memdup(const void *p, size_t l);	void* memdup(const void *p, size_t l);


		int rtc_open(int flags);

		int is_kernel_thread(pid_t pid);

	#endif	#endif

End of changes. 8 change blocks.
	4 lines changed or deleted	14 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	cgroup-util.h	cgroup-util.h

	skipping to change at line 63	skipping to change at line 63
	int cg_trim(const char controller, const char path, bool delete_root);	int cg_trim(const char controller, const char path, bool delete_root);

	int cg_rmdir(const char controller, const char path, bool honour_sticky);	int cg_rmdir(const char controller, const char path, bool honour_sticky);
	int cg_delete(const char controller, const char path);	int cg_delete(const char controller, const char path);

	int cg_create(const char controller, const char path);	int cg_create(const char controller, const char path);
	int cg_attach(const char controller, const char path, pid_t pid);	int cg_attach(const char controller, const char path, pid_t pid);
	int cg_create_and_attach(const char controller, const char path, pid_t pi d);	int cg_create_and_attach(const char controller, const char path, pid_t pi d);

	int cg_set_group_access(const char controller, const char path, mode_t mo de, uid_t uid, gid_t gid);	int cg_set_group_access(const char controller, const char path, mode_t mo de, uid_t uid, gid_t gid);

	int cg_set_task_access(const char controller, const char path, mode_t mod e, uid_t uid, gid_t gid);	int cg_set_task_access(const char controller, const char path, mode_t mod e, uid_t uid, gid_t gid, int sticky);

	int cg_install_release_agent(const char controller, const char agent);	int cg_install_release_agent(const char controller, const char agent);

	int cg_is_empty(const char controller, const char path, bool ignore_self) ;	int cg_is_empty(const char controller, const char path, bool ignore_self) ;
	int cg_is_empty_recursive(const char controller, const char path, bool ig nore_self);	int cg_is_empty_recursive(const char controller, const char path, bool ig nore_self);

	int cg_get_user_path(char **path);	int cg_get_user_path(char **path);

	#endif	#endif

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	cgroup.h	cgroup.h

	skipping to change at line 56	skipping to change at line 56
	/* If we cannot create this group, or add a process to it, is this fatal? */	/* If we cannot create this group, or add a process to it, is this fatal? */
	bool essential:1;	bool essential:1;

	/* This cgroup is realized */	/* This cgroup is realized */
	bool realized:1;	bool realized:1;
	};	};

	int cgroup_bonding_realize(CGroupBonding *b);	int cgroup_bonding_realize(CGroupBonding *b);
	int cgroup_bonding_realize_list(CGroupBonding *first);	int cgroup_bonding_realize_list(CGroupBonding *first);


	void cgroup_bonding_free(CGroupBonding *b, bool remove_or_trim);	void cgroup_bonding_free(CGroupBonding *b, bool trim);
	void cgroup_bonding_free_list(CGroupBonding *first, bool remove_or_trim);	void cgroup_bonding_free_list(CGroupBonding *first, bool trim);

	int cgroup_bonding_install(CGroupBonding *b, pid_t pid);	int cgroup_bonding_install(CGroupBonding *b, pid_t pid);
	int cgroup_bonding_install_list(CGroupBonding *first, pid_t pid);	int cgroup_bonding_install_list(CGroupBonding *first, pid_t pid);

	int cgroup_bonding_set_group_access(CGroupBonding *b, mode_t mode, uid_t ui d, gid_t gid);	int cgroup_bonding_set_group_access(CGroupBonding *b, mode_t mode, uid_t ui d, gid_t gid);
	int cgroup_bonding_set_group_access_list(CGroupBonding *b, mode_t mode, uid _t uid, gid_t gid);	int cgroup_bonding_set_group_access_list(CGroupBonding *b, mode_t mode, uid _t uid, gid_t gid);


	int cgroup_bonding_set_task_access(CGroupBonding *b, mode_t mode, uid_t uid	int cgroup_bonding_set_task_access(CGroupBonding *b, mode_t mode, uid_t uid
	, gid_t gid);	, gid_t gid, int sticky);
	int cgroup_bonding_set_task_access_list(CGroupBonding *b, mode_t mode, uid_	int cgroup_bonding_set_task_access_list(CGroupBonding *b, mode_t mode, uid_
	t uid, gid_t gid);	t uid, gid_t gid, int sticky);

	int cgroup_bonding_kill(CGroupBonding b, int sig, bool sigcont, Set s);	int cgroup_bonding_kill(CGroupBonding b, int sig, bool sigcont, Set s);
	int cgroup_bonding_kill_list(CGroupBonding first, int sig, bool sigcont, S et s);	int cgroup_bonding_kill_list(CGroupBonding first, int sig, bool sigcont, S et s);

	void cgroup_bonding_trim(CGroupBonding *first, bool delete_root);	void cgroup_bonding_trim(CGroupBonding *first, bool delete_root);
	void cgroup_bonding_trim_list(CGroupBonding *first, bool delete_root);	void cgroup_bonding_trim_list(CGroupBonding *first, bool delete_root);

	int cgroup_bonding_is_empty(CGroupBonding *b);	int cgroup_bonding_is_empty(CGroupBonding *b);
	int cgroup_bonding_is_empty_list(CGroupBonding *first);	int cgroup_bonding_is_empty_list(CGroupBonding *first);


End of changes. 2 change blocks.
	6 lines changed or deleted	6 lines changed or added

	conf-parser.h	conf-parser.h

	skipping to change at line 98	skipping to change at line 98
	bool relaxed,	bool relaxed,
	void *userdata);	void *userdata);

	/* Generic parsers */	/* Generic parsers */
	int config_parse_int(const char filename, unsigned line, const char secti on, const char lvalue, int ltype, const char rvalue, void data, void us erdata);	int config_parse_int(const char filename, unsigned line, const char secti on, const char lvalue, int ltype, const char rvalue, void data, void us erdata);
	int config_parse_unsigned(const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, voi d userdata);	int config_parse_unsigned(const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, voi d userdata);
	int config_parse_long(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);	int config_parse_long(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);
	int config_parse_uint64(const char filename, unsigned line, const char se ction, const char lvalue, int ltype, const char rvalue, void data, void userdata);	int config_parse_uint64(const char filename, unsigned line, const char se ction, const char lvalue, int ltype, const char rvalue, void data, void userdata);
	int config_parse_size(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);	int config_parse_size(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);
	int config_parse_bool(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);	int config_parse_bool(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);

		int config_parse_tristate(const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, voi d userdata);
	int config_parse_string(const char filename, unsigned line, const char se ction, const char lvalue, int ltype, const char rvalue, void data, void userdata);	int config_parse_string(const char filename, unsigned line, const char se ction, const char lvalue, int ltype, const char rvalue, void data, void userdata);
	int config_parse_path(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);	int config_parse_path(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);
	int config_parse_strv(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);	int config_parse_strv(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);
	int config_parse_path_strv(const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, vo id userdata);	int config_parse_path_strv(const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, vo id userdata);
	int config_parse_usec(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);	int config_parse_usec(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);
	int config_parse_mode(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);	int config_parse_mode(const char filename, unsigned line, const char sect ion, const char lvalue, int ltype, const char rvalue, void data, void u serdata);
	int config_parse_bytes(const char filename, unsigned line, const char sec tion, const char lvalue, int ltype, const char rvalue, void data, void userdata);	int config_parse_bytes(const char filename, unsigned line, const char sec tion, const char lvalue, int ltype, const char rvalue, void data, void userdata);

	#define DEFINE_CONFIG_PARSE_ENUM(function,name,type,msg) \	#define DEFINE_CONFIG_PARSE_ENUM(function,name,type,msg) \
	int function( \	int function( \

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added