1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// SPDX-License-Identifier: LGPL-2.1+
/*
* Copyright (C) 2018 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-sd-utils-shared.h"
#include "nm-sd-adapt-shared.h"
#include "dns-domain.h"
#include "hexdecoct.h"
#include "hostname-util.h"
#include "path-util.h"
#include "web-util.h"
/*****************************************************************************/
const bool mempool_use_allowed = true;
/*****************************************************************************/
gboolean
nm_sd_utils_path_equal (const char *a, const char *b)
{
return path_equal (a, b);
}
char *
nm_sd_utils_path_simplify (char *path, gboolean kill_dots)
{
return path_simplify (path, kill_dots);
}
const char *
nm_sd_utils_path_startswith (const char *path, const char *prefix)
{
return path_startswith (path, prefix);
}
/*****************************************************************************/
int
nm_sd_utils_unbase64char (char ch, gboolean accept_padding_equal)
{
if ( ch == '='
&& accept_padding_equal)
return G_MAXINT;
return unbase64char (ch);
}
/**
* nm_sd_utils_unbase64mem:
* @p: a valid base64 string. Whitespace is ignored, but invalid encodings
* will cause the function to fail.
* @l: the length of @p. @p is not treated as NUL terminated string but
* merely as a buffer of ascii characters.
* @secure: whether the temporary memory will be cleared to avoid leaving
* secrets in memory (see also nm_explicit_bzero()).
* @mem: (transfer full): the decoded buffer on success.
* @len: the length of @mem on success.
*
* glib provides g_base64_decode(), but that does not report any errors
* from invalid encodings. Expose systemd's implementation which does
* reject invalid inputs.
*
* Returns: a non-negative code on success. Invalid encoding let the
* function fail.
*/
int
nm_sd_utils_unbase64mem (const char *p,
size_t l,
gboolean secure,
guint8 **mem,
size_t *len)
{
return unbase64mem_full (p, l, secure, (void **) mem, len);
}
int nm_sd_dns_name_to_wire_format (const char *domain,
guint8 *buffer,
size_t len,
gboolean canonical)
{
return dns_name_to_wire_format (domain, buffer, len, canonical);
}
int nm_sd_dns_name_is_valid (const char *s)
{
return dns_name_is_valid (s);
}
gboolean nm_sd_hostname_is_valid (const char *s, bool allow_trailing_dot)
{
return hostname_is_valid (s, allow_trailing_dot);
}
/*****************************************************************************/
static gboolean
_http_url_is_valid (const char *url, gboolean only_https)
{
if ( !url
|| !url[0])
return FALSE;
if ( !only_https
&& NM_STR_HAS_PREFIX (url, "http://"))
url += NM_STRLEN ("http://");
else if (NM_STR_HAS_PREFIX (url, "https://"))
url += NM_STRLEN ("https://");
else
return FALSE;
if (!url[0])
return FALSE;
return !NM_STRCHAR_ANY (url, ch, (guchar) ch >= 128u);
}
gboolean
nm_sd_http_url_is_valid_https (const char *url)
{
/* We use this function to verify connection:mud-url property, it must thus
* not change behavior.
*
* Note that sd_dhcp_client_set_mud_url() and sd_dhcp6_client_set_request_mud_url()
* assert with http_url_is_valid() that the argument is valid. We thus must make
* sure to only pass URLs that are valid according to http_url_is_valid().
*
* This is given, because our nm_sd_http_url_is_valid_https() is more strict
* than http_url_is_valid().
*
* We only must make sure that this is also correct in the future, when we
* re-import systemd code. */
nm_assert (_http_url_is_valid (url, FALSE) == http_url_is_valid (url));
return _http_url_is_valid (url, TRUE);
}
/*****************************************************************************/
int
nmtst_systemd_extract_first_word_all (const char *str, char ***out_strv)
{
gs_unref_ptrarray GPtrArray *arr = NULL;
/* we implement a str split function to parse `/proc/cmdline`. This
* code should behave like systemd, which uses extract_first_word()
* for that.
*
* As we want to unit-test our implementation to match systemd,
* expose this function for testing. */
g_assert (out_strv);
g_assert (!*out_strv);
if (!str)
return 0;
arr = g_ptr_array_new_with_free_func (g_free);
for (;;) {
gs_free char *word = NULL;
int r;
r = extract_first_word (&str, &word, NULL, EXTRACT_UNQUOTE | EXTRACT_RELAX);
if (r < 0)
return r;
if (r == 0)
break;
g_ptr_array_add (arr, g_steal_pointer (&word));
}
g_ptr_array_add (arr, NULL);
*out_strv = (char **) g_ptr_array_free (g_steal_pointer (&arr), FALSE);
return 1;
}
|
