/src/dbus-broker/src/dbus/protocol.c

Source
/*
 * DBus Protocol Constants and Definitions
 */

#include <c-stdaux.h>
#include <stdlib.h>
#include "dbus/protocol.h"

static bool dbus_validate_name_common(const char *name, size_t n_name, bool namespace) {
        bool has_dot = false, dot = true, unique = false;
        size_t i;

        if (n_name > 255)
                return false;

        if (n_name > 0 && name[0] == ':') {
                ++name;
                --n_name;
                unique = true;
        }

        for (i = 0; i < n_name; ++i) {
                if (name[i] == '.') {
                        if (dot)
                                return false;

                        has_dot = true;
                        dot = true;
                } else if (_c_unlikely_(!((name[i] >= 'a' && name[i] <= 'z') ||
                                          (name[i] >= 'A' && name[i] <= 'Z') ||
                                          (name[i] >= '0' && name[i] <= '9' && (!dot || unique)) ||
                                          name[i] == '_' ||
                                          name[i] == '-'))) {
                        return false;
                } else {
                        dot = false;
                }
        }

        return (has_dot || namespace) && !dot;
}

/**
 * dbus_validate_name() - verify validity of bus name
 * @name:               name
 * @n_name:             length of name
 *
 * This verifies the validity of the passed bus name.
 *
 * Return: True if @name is a valid bus name, false otherwise.
 */
bool dbus_validate_name(const char *name, size_t n_name) {
        return dbus_validate_name_common(name, n_name, false);
}

/**
 * dbus_validate_namespace() - verify validity of bus namespace
 * @namespace:          namespace
 * @n_namespace:        length of namespace
 *
 * This verifies the validity of the passed bus namespace.
 *
 * Return: True if @namespace is a valid bus namespace, false otherwise.
 */
bool dbus_validate_namespace(const char *namespace, size_t n_namespace) {
        return dbus_validate_name_common(namespace, n_namespace, true);
}

/**
 * dbus_validate_interface() - verify validity of interface
 * @interface           interface
 * @n_interface:        length of interface
 *
 * This verifies the validity of the passed interface.
 *
 * Return: True if @interface is a valid interface, false otherwise.
 */
bool dbus_validate_interface(const char *interface, size_t n_interface) {
        bool has_dot = false, dot = true;
        size_t i;

        if (n_interface > 255)
                return false;

        for (i = 0; i < n_interface; ++i) {
                if (interface[i] == '.') {
                        if (dot)
                                return false;

                        has_dot = true;
                        dot = true;
                } else if (_c_unlikely_(!((interface[i] >= 'a' && interface[i] <= 'z') ||
                                          (interface[i] >= 'A' && interface[i] <= 'Z') ||
                                          (interface[i] >= '0' && interface[i] <= '9' && !dot) ||
                                          interface[i] == '_'))) {
                        return false;
                } else {
                        dot = false;
                }
        }

        return has_dot && !dot;
}

/**
 * dbus_validate_member() - verify validity of member
 * @member              member
 * @n_member:           length of interface
 *
 * This verifies the validity of the passed member.
 *
 * Return: True if @member is a valid member, false otherwise.
 */
bool dbus_validate_member(const char *member, size_t n_member) {
        bool first = true;
        size_t i;

        if (n_member > 255)
                return false;

        for (i = 0; i < n_member; ++i) {
                if (_c_unlikely_(!((member[i] >= 'a' && member[i] <= 'z') ||
                                   (member[i] >= 'A' && member[i] <= 'Z') ||
                                   (member[i] >= '0' && member[i] <= '9' && !first) ||
                                   member[i] == '_')))
                        return false;
                first = false;
        }

        return !first;
}

/**
 * dbus_validate_error_name() - verify validity of error_name
 * @name:               error name
 * @n_name:             length of error name
 *
 * This verifies the validity of the passed error name.
 *
 * Return: True if @name is a valid error name, false otherwise.
 */
bool dbus_validate_error_name(const char *name, size_t n_name) {
        return dbus_validate_interface(name, n_name);
}

Line	Count	Source
1		/*
2		* DBus Protocol Constants and Definitions
3		*/
4
5		#include <c-stdaux.h>
6		#include <stdlib.h>
7		#include "dbus/protocol.h"
8
9	299	static bool dbus_validate_name_common(const char *name, size_t n_name, bool namespace) {
10	299	bool has_dot = false, dot = true, unique = false;
11	299	size_t i;
12
13	299	if (n_name > 255)
14	12	return false;
15
16	287	if (n_name > 0 && name[0] == ':') {
17	21	++name;
18	21	--n_name;
19	21	unique = true;
20	21	}
21
22	2.13k	for (i = 0; i < n_name; ++i) {
23	1.93k	if (name[i] == '.') {
24	194	if (dot)
25	2	return false;
26
27	192	has_dot = true;
28	192	dot = true;
29	1.74k	} else if (_c_unlikely_(!((name[i] >= 'a' && name[i] <= 'z') \|\|
30	1.74k	(name[i] >= 'A' && name[i] <= 'Z') \|\|
31	1.74k	(name[i] >= '0' && name[i] <= '9' && (!dot \|\| unique)) \|\|
32	1.74k	name[i] == '_' \|\|
33	1.74k	name[i] == '-'))) {
34	84	return false;
35	1.65k	} else {
36	1.65k	dot = false;
37	1.65k	}
38	1.93k	}
39
40	201	return (has_dot \|\| namespace) && !dot;
41	287	}
42
43		/**
44		* dbus_validate_name() - verify validity of bus name
45		* @name: name
46		* @n_name: length of name
47		*
48		* This verifies the validity of the passed bus name.
49		*
50		* Return: True if @name is a valid bus name, false otherwise.
51		*/
52	299	bool dbus_validate_name(const char *name, size_t n_name) {
53	299	return dbus_validate_name_common(name, n_name, false);
54	299	}
55
56		/**
57		* dbus_validate_namespace() - verify validity of bus namespace
58		* @namespace: namespace
59		* @n_namespace: length of namespace
60		*
61		* This verifies the validity of the passed bus namespace.
62		*
63		* Return: True if @namespace is a valid bus namespace, false otherwise.
64		*/
65	0	bool dbus_validate_namespace(const char *namespace, size_t n_namespace) {
66	0	return dbus_validate_name_common(namespace, n_namespace, true);
67	0	}
68
69		/**
70		* dbus_validate_interface() - verify validity of interface
71		* @interface interface
72		* @n_interface: length of interface
73		*
74		* This verifies the validity of the passed interface.
75		*
76		* Return: True if @interface is a valid interface, false otherwise.
77		*/
78	495	bool dbus_validate_interface(const char *interface, size_t n_interface) {
79	495	bool has_dot = false, dot = true;
80	495	size_t i;
81
82	495	if (n_interface > 255)
83	22	return false;
84
85	4.23k	for (i = 0; i < n_interface; ++i) {
86	3.93k	if (interface[i] == '.') {
87	297	if (dot)
88	3	return false;
89
90	294	has_dot = true;
91	294	dot = true;
92	3.64k	} else if (_c_unlikely_(!((interface[i] >= 'a' && interface[i] <= 'z') \|\|
93	3.64k	(interface[i] >= 'A' && interface[i] <= 'Z') \|\|
94	3.64k	(interface[i] >= '0' && interface[i] <= '9' && !dot) \|\|
95	3.64k	interface[i] == '_'))) {
96	171	return false;
97	3.47k	} else {
98	3.47k	dot = false;
99	3.47k	}
100	3.93k	}
101
102	299	return has_dot && !dot;
103	473	}
104
105		/**
106		* dbus_validate_member() - verify validity of member
107		* @member member
108		* @n_member: length of interface
109		*
110		* This verifies the validity of the passed member.
111		*
112		* Return: True if @member is a valid member, false otherwise.
113		*/
114	154	bool dbus_validate_member(const char *member, size_t n_member) {
115	154	bool first = true;
116	154	size_t i;
117
118	154	if (n_member > 255)
119	9	return false;
120
121	1.38k	for (i = 0; i < n_member; ++i) {
122	1.30k	if (_c_unlikely_(!((member[i] >= 'a' && member[i] <= 'z') \|\|
123	1.30k	(member[i] >= 'A' && member[i] <= 'Z') \|\|
124	1.30k	(member[i] >= '0' && member[i] <= '9' && !first) \|\|
125	1.30k	member[i] == '_')))
126	65	return false;
127	1.23k	first = false;
128	1.23k	}
129
130	80	return !first;
131	145	}
132
133		/**
134		* dbus_validate_error_name() - verify validity of error_name
135		* @name: error name
136		* @n_name: length of error name
137		*
138		* This verifies the validity of the passed error name.
139		*
140		* Return: True if @name is a valid error name, false otherwise.
141		*/
142	184	bool dbus_validate_error_name(const char *name, size_t n_name) {
143	184	return dbus_validate_interface(name, n_name);
144	184	}

Coverage Report

Created: 2025-11-11 06:08