'sd_bus_message_get_interface',
'sd_bus_message_get_member',
'sd_bus_message_get_path',
+ 'sd_bus_message_get_priority',
'sd_bus_message_get_sender',
+ 'sd_bus_message_set_priority',
'sd_bus_message_set_sender'],
''],
['sd_bus_message_set_expect_reply',
<citerefentry><refentrytitle>sd_bus_message_dump</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_get_cookie</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_get_monotonic_usec</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
+<citerefentry><refentrytitle>sd_bus_message_get_priority</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
+<citerefentry><refentrytitle>sd_bus_message_get_sender</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_get_signature</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_get_type</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_new</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_rewind</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_seal</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_set_destination</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
+<citerefentry><refentrytitle>sd_bus_message_set_priority</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
+<citerefentry><refentrytitle>sd_bus_message_set_sender</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_set_expect_reply</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_skip</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
<citerefentry><refentrytitle>sd_bus_message_verify_type</refentrytitle><manvolnum>3</manvolnum></citerefentry>,
#define SD_INFO "<6>" /* informational */
#define SD_DEBUG "<7>" /* debug-level messages */</programlisting>
- <para>These prefixes are intended to be used in conjunction with
- stderr-based logging as implemented by systemd. If a systemd
- service definition file is configured with
- <varname>StandardError=journal</varname>,
- <varname>StandardError=syslog</varname> or
- <varname>StandardError=kmsg</varname>, these prefixes can be used
- to encode a log level in lines printed. This is similar to the
- kernel <function>printk()</function>-style logging. See
- <citerefentry><refentrytitle>klogctl</refentrytitle><manvolnum>2</manvolnum></citerefentry>
- for more information.</para>
+ <para>These prefixes are intended to be used in conjunction with stderr-based logging (or stdout-based
+ logging) as implemented by systemd. If a systemd service definition file is configured with
+ <varname>StandardError=journal</varname>, <varname>StandardError=syslog</varname> or
+ <varname>StandardError=kmsg</varname> (and similar with <varname>StandardOutput=</varname>), these
+ prefixes can be used to encode a log level in lines printed. This is similar to the kernel
+ <function>printk()</function>-style logging. See
+ <citerefentry><refentrytitle>klogctl</refentrytitle><manvolnum>2</manvolnum></citerefentry> for more
+ information.</para>
<para>The log levels are identical to
<citerefentry project='man-pages'><refentrytitle>syslog</refentrytitle><manvolnum>3</manvolnum></citerefentry>'s
<title>Description</title>
<para><function>sd_bus_call()</function> takes a complete bus message object and calls the
- corresponding D-Bus method.
The response is stored in <parameter>reply</parameter>.
+ corresponding D-Bus method.
On success, the response is stored in <parameter>reply</parameter>.
<parameter>usec</parameter> indicates the timeout in microseconds. If
<parameter>ret_error</parameter> is not <constant>NULL</constant> and
- <function>sd_bus_call()</function> returns an error, <parameter>ret_error</parameter> is
- initialized to an instance of <structname>sd_bus_error</structname> describing the error.</para>
+ <function>sd_bus_call()</function> fails (either because of an internal error or because it
+ received a D-Bus error reply), <parameter>ret_error</parameter> is initialized to an instance of
+ <structname>sd_bus_error</structname> describing the error.</para>
<para><function>sd_bus_call_async()</function> is like <function>sd_bus_call()</function> but
- works asynchronously. The <parameter>callback</parameter> shall reference a function to call
- when the event source is triggered. The <parameter>userdata</parameter> pointer will be passed
- to the callback function, and may be chosen freely by the caller. If <parameter>slot</parameter>
- is not <constant>NULL</constant> and <function>sd_bus_call_async()</function> succeeds,
+ works asynchronously. The <parameter>callback</parameter> indicates the function to call when
+ the response arrives. The <parameter>userdata</parameter> pointer will be passed to the callback
+ function, and may be chosen freely by the caller. If <parameter>slot</parameter> is not
+ <constant>NULL</constant> and <function>sd_bus_call_async()</function> succeeds,
<parameter>slot</parameter> is set to a slot object which can be used to cancel the method call
at a later time using
<citerefentry><refentrytitle>sd_bus_slot_unref</refentrytitle><manvolnum>3</manvolnum></citerefentry>.
If <parameter>slot</parameter> is <constant>NULL</constant>, the lifetime of the method call is
bound to the lifetime of the bus object itself, and it cannot be cancelled independently. See
<citerefentry><refentrytitle>sd_bus_slot_set_floating</refentrytitle><manvolnum>3</manvolnum></citerefentry>
- for details. The <parameter>callback</parameter> function is called when the response arrives
- and receives the response, <parameter>userdata</parameter> and a
- <structname>sd_bus_error</structname> object as its arguments. The
- <structname>sd_bus_error</structname> object is unused here and should be ignored. If
- <parameter>callback</parameter> returns a non-negative integer when called, a debug message is
- logged along with details about the response.</para>
-
- <para>To determine whether the method call succeeded, use
+ for details. <parameter>callback</parameter> is called when a reply arrives with the reply,
+ <parameter>userdata</parameter> and an <structname>sd_bus_error</structname> output
+ parameter as its arguments. Unlike <function>sd_bus_call()</function>, the
+ <structname>sd_bus_error</structname> output parameter passed to the callback will be empty. To
+ determine whether the method call succeeded, use
<citerefentry><refentrytitle>sd_bus_message_is_method_error</refentrytitle><manvolnum>3</manvolnum></citerefentry>
- on the reply object returned by <function>sd_bus_call()</function> or passed to the callback of
- <function>sd_bus_call_async()</function>.</para>
+ on the reply message passed to the callback instead. If the callback returns zero and the
+ <structname>sd_bus_error</structname> output parameter is still empty when the callback
+ inishes, other handlers registered with functions such as
+ <citerefentry><refentrytitle>sd_bus_add_filter</refentrytitle><manvolnum>3</manvolnum></citerefentry> or
+ <citerefentry><refentrytitle>sd_bus_add_match</refentrytitle><manvolnum>3</manvolnum></citerefentry>
+ are given a chance to process the message. If the callback returns a non-zero value or the
+ <structname>sd_bus_error</structname> output parameter is not empty when the callback finishes,
+ no further processing of the message is done. Generally, you want to return zero from the
+ callback to give other registered handlers a chance to process the reply as well.</para>
<para>If <parameter>usec</parameter> is zero, the default D-Bus method call timeout is used. See
<citerefentry><refentrytitle>sd_bus_get_method_call_timeout</refentrytitle><manvolnum>3</manvolnum></citerefentry>.
<refname>sd_bus_message_get_path</refname>
<refname>sd_bus_message_get_interface</refname>
<refname>sd_bus_message_get_member</refname>
+ <refname>sd_bus_message_set_priority</refname>
+ <refname>sd_bus_message_get_priority</refname>
<refname>sd_bus_message_set_sender</refname>
<refname>sd_bus_message_get_sender</refname>
<paramdef>sd_bus_message *<parameter>message</parameter></paramdef>
</funcprototype>
+ <funcprototype>
+ <funcdef>int <function>sd_bus_message_set_priority</function></funcdef>
+ <paramdef>sd_bus_message *<parameter>message</parameter></paramdef>
+ <paramdef>int64_t <parameter>priority</parameter></paramdef>
+ </funcprototype>
+
+ <funcprototype>
+ <funcdef>int <function>sd_bus_message_get_priority</function></funcdef>
+ <paramdef>sd_bus_message *<parameter>message</parameter></paramdef>
+ <paramdef>int64_t *<parameter>priority</parameter></paramdef>
+ </funcprototype>
+
<funcprototype>
<funcdef>int <function>sd_bus_message_set_sender</function></funcdef>
<paramdef>sd_bus_message *<parameter>message</parameter></paramdef>
member fields from <parameter>message</parameter> header. The return value will be
<constant>NULL</constant> is <parameter>message</parameter> is <constant>NULL</constant> or the
message is of a type that doesn't use those fields or the message doesn't have them set. See
- <citerefentry><refentrytitle>sd_bus_message_new_method_call</refentrytitle><manvolnum>3</manvolnum></citerefentry>
- and
+ <citerefentry><refentrytitle>sd_bus_message_new_method_call</refentrytitle><manvolnum>3</manvolnum></citerefentry> and
<citerefentry><refentrytitle>sd_bus_message_set_destination</refentrytitle><manvolnum>3</manvolnum></citerefentry>
for more discussion of those values.</para>
+ <para><function>sd_bus_message_set_priority()</function> and
+ <function>sd_bus_message_get_priority()</function> modify and query a message's priority
+ respectively. sd-bus currently doesn't make use of a message's priority.</para>
<para><function>sd_bus_message_set_sender()</function> sets the sender service name for the specified bus message
object. The specified name must be a valid unique or well-known service name. This function is useful only for
<varlistentry>
<term><constant>-EPERM</constant></term>
- <listitem><para>For <function>sd_bus_message_set_destination</function> or
- <function>sd_bus_message_set_sender</function>, the message is already
- sealed.</para></listitem>
+ <listitem><para>For <function>sd_bus_message_set_destination()</function>,
+ <function>sd_bus_message_set_sender()</function> and
+ <function>sd_bus_message_set_priority()</function>, the message is already sealed.</para>
+ </listitem>
</varlistentry>
<varlistentry>
sent even if this is set to true.</para>
</listitem>
</varlistentry>
+
+ <varlistentry>
+ <term><varname>MUDURL=</varname></term>
+ <listitem>
+ <para>When configured, the Manufacturer Usage Descriptions (MUD) URL will be sent to the
+ DHCPv4 server. Takes an URL of length up to 255 characters. A superficial verification that
+ the string is a valid URL will be performed. DHCPv4 clients are intended to have at most one
+ MUD URL associated with them. See
+ <ulink url="https://tools.ietf.org/html/rfc8520">RFC 8520</ulink>.</para>
+ </listitem>
+ </varlistentry>
+
<varlistentry>
<term><varname>UseHostname=</varname></term>
<listitem>
if (isempty(u))
return false;
- if (valid_user_group_name_full(u, strict))
+ if (parse_uid(u, NULL) >= 0)
return true;
- return parse_uid(u, NULL) >= 0;
+ return valid_user_group_name_full(u, strict);
}
bool valid_gecos(const char *d) {
pkey = X509_get0_pubkey(cert);
if (!pkey)
- return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to exract public key from X.509 certificate.");
+ return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to extract public key from X.509 certificate.");
if (EVP_PKEY_base_id(pkey) != EVP_PKEY_RSA)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "X.509 certificate does not refer to RSA key.");
string_erase(e);
if (unsetenv("NEWPASSWORD") < 0)
- return log_error_errno(errno, "Failed to unse $NEWPASSWORD: %m");
+ return log_error_errno(errno, "Failed to unset $NEWPASSWORD: %m");
return 0;
}
return 0;
}
- log_error("Password didn't mach, try again.");
+ log_error("Password didn't match, try again.");
}
}
r = read_line(f, LONG_LINE_MAX, &line);
if (r < 0)
- return log_error_errno(r, "Faile dto read from '%s': %m", optarg+1);
+ return log_error_errno(r, "Failed to read from '%s': %m", optarg+1);
if (r == 0)
break;
/* This operation might not be something we can executed immediately, hence queue it */
fd = home_create_fifo(h, please_suspend);
if (fd < 0)
- return sd_bus_reply_method_errnof(message, fd, "Failed to allocate fifo for %s: %m", h->user_name);
+ return sd_bus_reply_method_errnof(message, fd, "Failed to allocate FIFO for %s: %m", h->user_name);
o = operation_new(OPERATION_ACQUIRE, message);
if (!o)
fd = home_create_fifo(h, please_suspend);
if (fd < 0)
- return sd_bus_reply_method_errnof(message, fd, "Failed to allocate fifo for %s: %m", h->user_name);
+ return sd_bus_reply_method_errnof(message, fd, "Failed to allocate FIFO for %s: %m", h->user_name);
return sd_bus_reply_method_return(message, "h", fd);
}
case -ENOKEY:
sd_bus_error_setf(ret_error, BUS_ERROR_BAD_SIGNATURE, "User record %s is not signed by any known key, refusing.", hr->user_name);
- return log_error_errno(is_signed, "Home %s contians user record that is not signed by any known key, refusing.", hr->user_name);
+ return log_error_errno(is_signed, "Home %s contains user record that is not signed by any known key, refusing.", hr->user_name);
default:
assert(is_signed < 0);
switch (e) {
case -EMSGSIZE:
- return sd_bus_error_setf(error, BUS_ERROR_BAD_HOME_SIZE, "File systems of this type cannot shrinked");
+ return sd_bus_error_setf(error, BUS_ERROR_BAD_HOME_SIZE, "File systems of this type cannot be shrinked");
case -ETXTBSY:
return sd_bus_error_setf(error, BUS_ERROR_BAD_HOME_SIZE, "File systems of this type can only be shrinked offline");
case -ERANGE:
if (disk_size == UINT64_MAX || disk_size == h->record->disk_size) {
if (h->record->disk_size == UINT64_MAX)
- return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Not disk size to resize to specified.");
+ return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No disk size to resize to specified.");
c = user_record_ref(h->record); /* Shortcut if size is unspecified or matches the record */
} else {
goto finish;
if (statfs(hd, &sfs) < 0) {
- log_debug_errno(errno, "Failed to statfs() %s, ignoring: %m", hd);
+ log_debug_errno(errno, "Failed to statfs() %s, ignoring: %m", hd);
goto finish;
}
return -ENOMEM;
}
- log_info("Automatically locking of home of user %s.", h->user_name);
+ log_info("Automatically locking home of user %s.", h->user_name);
r = home_schedule_operation(h, o, error);
if (r < 0)
}
if (!same) {
- log_debug("Found a multiple images for a user '%s', ignoring image '%s'.", user_name, image_path);
+ log_debug("Found multiple images for user '%s', ignoring image '%s'.", user_name, image_path);
return 0;
}
} else {
r = stat(path, &st);
if (r < 0)
return log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_WARNING, errno,
- "Failed to stat directory entry '%s', ignoring: %m", dentry_name);
+ "Failed to stat() directory entry '%s', ignoring: %m", dentry_name);
if (S_ISREG(st.st_mode)) {
_cleanup_free_ char *n = NULL, *user_name = NULL, *realm = NULL;
if (errno == ENODATA)
log_debug_errno(errno, "Determined %s is not fscrypt encrypted.", path);
else if (ERRNO_IS_NOT_SUPPORTED(errno))
- log_debug_errno(errno, "Determined %s is not fscrypt encrypted because kernel or file system don't support it.", path);
+ log_debug_errno(errno, "Determined %s is not fscrypt encrypted because kernel or file system doesn't support it.", path);
else
log_debug_errno(errno, "FS_IOC_GET_ENCRYPTION_POLICY failed with unexpected error code on %s, ignoring: %m", path);
/* Write out public key (note that we only do that as a help to the user, we don't make use of this ever */
r = fopen_temporary("/var/lib/systemd/home/local.public", &fpublic, &temp_public);
if (r < 0)
- return log_error_errno(errno, "Failed ot open key file for writing: %m");
+ return log_error_errno(errno, "Failed to open key file for writing: %m");
if (PEM_write_PUBKEY(fpublic, m->private_key) <= 0)
return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to write public key.");
/* Write out the private key (this actually writes out both private and public, OpenSSL is confusing) */
r = fopen_temporary("/var/lib/systemd/home/local.private", &fprivate, &temp_private);
if (r < 0)
- return log_error_errno(errno, "Failed ot open key file for writing: %m");
+ return log_error_errno(errno, "Failed to open key file for writing: %m");
if (PEM_write_PrivateKey(fprivate, m->private_key, NULL, NULL, 0, NULL, 0) <= 0)
return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to write private key pair.");
r = sd_event_add_defer(m->event, &m->deferred_gc_event_source, on_deferred_gc, m);
if (r < 0)
- return log_error_errno(r, "Failed to allocate gc event source: %m");
+ return log_error_errno(r, "Failed to allocate GC event source: %m");
r = sd_event_source_set_priority(m->deferred_gc_event_source, SD_EVENT_PRIORITY_IDLE);
if (r < 0)
r = sd_bus_reply_method_errnof(o->message, o->ret, "Failed to execute operation: %m");
}
if (r < 0)
- log_warning_errno(r, "Failed ot reply to %s method call, ignoring: %m", sd_bus_message_get_member(o->message));
+ log_warning_errno(r, "Failed to reply to %s method call, ignoring: %m", sd_bus_message_get_member(o->message));
}
sd_bus_message_unref(o->message);
/* Verify that our key length calculations match what OpenSSL thinks */
r = EVP_CIPHER_key_length(cc);
if (r < 0 || (uint64_t) r != key_size)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Key size of selected cipher doesn't meet out expectations.");
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Key size of selected cipher doesn't meet our expectations.");
*ret = cc;
return 0;
r = json_variant_format(hr->json, 0, &text);
if (r < 0)
- return log_error_errno(r,"Failed to format user record for LUKS: %m");
+ return log_error_errno(r, "Failed to format user record for LUKS: %m");
text_length = strlen(text);
encrypted_size = text_length + 2*key_size - 1;
r = dm_deferred_remove(setup.dm_name);
if (r < 0)
- log_warning_errno(r, "Failed to relinquish dm device, ignoring: %m");
+ log_warning_errno(r, "Failed to relinquish DM device, ignoring: %m");
setup.undo_dm = false;
if (r < 0)
return log_error_errno(r, "Failed to check if mkfs for file system %s exists: %m", fstype);
if (r == 0)
- return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "Nt mkfs for file system %s installed.", fstype);
+ return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "No mkfs for file system %s installed.", fstype);
r = safe_fork("(mkfs)", FORK_RESET_SIGNALS|FORK_RLIMIT_NOFILE_SAFE|FORK_DEATHSIG|FORK_LOG|FORK_WAIT|FORK_STDOUT_TO_STDERR, NULL);
if (r < 0)
r = fdisk_create_disklabel(c, "gpt");
if (r < 0)
- return log_error_errno(r, "Failed to create gpt disk label: %m");
+ return log_error_errno(r, "Failed to create GPT disk label: %m");
p = fdisk_new_partition();
if (!p)
re_mount = true;
}
- log_info("Temporarary unmounting of file system completed.");
+ log_info("Temporary unmounting of file system completed.");
/* resize2fs requires that the file system is force checked first, do so. */
r = safe_fork("(e2fsck)", FORK_RESET_SIGNALS|FORK_RLIMIT_NOFILE_SAFE|FORK_DEATHSIG|FORK_LOG|FORK_STDOUT_TO_STDERR, &fsck_pid);
if (n < 0)
return log_error_errno(errno, "Failed to wipe partition table: %m");
if (n != 1024)
- return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short write while whiping partition table.");
+ return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short write while wiping partition table.");
c = fdisk_new_context();
if (!c)
} else {
r = stat_verify_regular(&st);
if (r < 0)
- return log_error_errno(r, "Image file %s is not a block device nor regular: %m", ip);
+ return log_error_errno(r, "Image %s is not a block device nor regular file: %m", ip);
old_image_size = st.st_size;
if (rv != CKR_OK)
return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to log into security token '%s': %s", token_label, p11_kit_strerror(rv));
- log_info("Successully logged into security token '%s' via protected authentication path.", token_label);
+ log_info("Successfully logged into security token '%s' via protected authentication path.", token_label);
goto decrypt;
}
return r;
if (!user_record_compatible(h, embedded_home))
- return log_error_errno(SYNTHETIC_ERRNO(EREMCHG), "Hmbedded home record not compatible with host record, refusing.");
+ return log_error_errno(SYNTHETIC_ERRNO(EREMCHG), "Embedded home record not compatible with host record, refusing.");
/* Insist that credentials the user supplies also unlocks any embedded records. */
r = user_record_authenticate(embedded_home, h, pkcs11_decrypted_passwords);
if (stat(ip, &st) < 0) {
if (errno != -ENOENT)
- return log_error_errno(errno, "Failed to stat %s: %m", ip);
+ return log_error_errno(errno, "Failed to stat() %s: %m", ip);
} else {
if (S_ISREG(st.st_mode)) {
k = parse_boolean(v);
if (k < 0)
- pam_syslog(handle, LOG_WARNING, "Failed to parse suspend-please= argument, ignoring: %s", v);
+ pam_syslog(handle, LOG_WARNING, "Failed to parse suspend= argument, ignoring: %s", v);
else if (please_suspend)
*please_suspend = k;
r = pam_get_data(handle, "systemd-user-record-is-homed", &b);
if (!IN_SET(r, PAM_SUCCESS, PAM_NO_MODULE_DATA)) {
/* Failure */
- pam_syslog(handle, LOG_ERR, "Failed to get PAM user record is homed flag: %s", pam_strerror(handle, r));
+ pam_syslog(handle, LOG_ERR, "Failed to get PAM user-record-is-homed flag: %s", pam_strerror(handle, r));
return r;
} else if (b == NULL)
/* Nothing cached yet, need to acquire fresh */
/* Cache this, so that we don't check again */
r = pam_set_data(handle, "systemd-user-record-is-homed", USER_RECORD_IS_OTHER, NULL);
if (r != PAM_SUCCESS)
- pam_syslog(handle, LOG_ERR, "Failed to set PAM user record is homed flag, ignoring: %s", pam_strerror(handle, r));
+ pam_syslog(handle, LOG_ERR, "Failed to set PAM user-record-is-homed flag, ignoring: %s", pam_strerror(handle, r));
return PAM_USER_UNKNOWN;
}
k = pam_set_data(handle, "systemd-user-record-is-homed", NULL, NULL);
if (k != PAM_SUCCESS)
- pam_syslog(handle, LOG_ERR, "Failed to release PAM user record is homed flag: %s", pam_strerror(handle, k));
+ pam_syslog(handle, LOG_ERR, "Failed to release PAM user-record-is-homed flag: %s", pam_strerror(handle, k));
return IN_SET(r, PAM_SUCCESS, PAM_NO_MODULE_DATA) ? k : r;
}
r = pwquality_read_config(pwq, NULL, &auxerror);
if (r < 0)
- log_warning_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to read libpwquality configuation, ignoring: %s",
+ log_warning_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to read libpwquality configuration, ignoring: %s",
pwquality_strerror(buf, sizeof(buf), r, auxerror));
pwquality_maybe_disable_dictionary(pwq);
r = pwquality_read_config(pwq, NULL, &auxerror);
if (r < 0)
- log_warning_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to read libpwquality configuation, ignoring: %s",
+ log_warning_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to read libpwquality configuration, ignoring: %s",
pwquality_strerror(buf, sizeof(buf), r, auxerror));
pwquality_maybe_disable_dictionary(pwq);
#include "random-util.h"
#include "string-util.h"
#include "strv.h"
+#include "web-util.h"
#define MAX_CLIENT_ID_LEN (sizeof(uint32_t) + MAX_DUID_LEN) /* Arbitrary limit */
#define MAX_MAC_ADDR_LEN CONST_MAX(INFINIBAND_ALEN, ETH_ALEN)
size_t client_id_len;
char *hostname;
char *vendor_class_identifier;
+ char *mudurl;
char **user_class;
uint32_t mtu;
uint32_t xid;
return free_and_strdup(&client->vendor_class_identifier, vci);
}
+int sd_dhcp_client_set_mud_url(
+ sd_dhcp_client *client,
+ const char *mudurl) {
+
+ assert_return(client, -EINVAL);
+ assert_return(mudurl, -EINVAL);
+ assert_return(strlen(mudurl) <= 255, -EINVAL);
+ assert_return(http_url_is_valid(mudurl), -EINVAL);
+
+ return free_and_strdup(&client->mudurl, mudurl);
+}
+
int sd_dhcp_client_set_user_class(
sd_dhcp_client *client,
const char* const* user_class) {
return r;
}
+ if (client->mudurl) {
+ r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
+ SD_DHCP_OPTION_MUD_URL,
+ strlen(client->mudurl),
+ client->mudurl);
+ if (r < 0)
+ return r;
+ }
+
if (client->user_class) {
r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
SD_DHCP_OPTION_USER_CLASS,
return r;
}
+ if (client->mudurl) {
+ r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
+ SD_DHCP_OPTION_MUD_URL,
+ strlen(client->mudurl),
+ client->mudurl);
+ if (r < 0)
+ return r;
+ }
+
+
r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
SD_DHCP_OPTION_END, 0, NULL);
if (r < 0)
free(client->req_opts);
free(client->hostname);
free(client->vendor_class_identifier);
+ free(client->mudurl);
client->user_class = strv_free(client->user_class);
ordered_hashmap_free(client->extra_options);
ordered_hashmap_free(client->vendor_options);
#include <linux/if.h>
#include <linux/if_arp.h>
+#include "escape.h"
#include "alloc-util.h"
#include "dhcp-client-internal.h"
#include "hostname-util.h"
#include "string-table.h"
#include "string-util.h"
#include "sysctl-util.h"
+#include "web-util.h"
static int dhcp_remove_routes(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all);
static int dhcp_remove_router(Link *link, sd_dhcp_lease *lease, const struct in_addr *address, bool remove_all);
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set vendor class identifier: %m");
}
+ if (link->network->dhcp_mudurl) {
+ r = sd_dhcp_client_set_mud_url(link->dhcp_client,
+ link->network->dhcp_mudurl);
+ if (r < 0)
+ return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set MUD URL: %m");
+ }
+
if (link->network->dhcp_user_class) {
r = sd_dhcp_client_set_user_class(link->dhcp_client, (const char **) link->network->dhcp_user_class);
if (r < 0)
return 0;
}
+int config_parse_dhcp_mud_url(
+ const char *unit,
+ const char *filename,
+ unsigned line,
+ const char *section,
+ unsigned section_line,
+ const char *lvalue,
+ int ltype,
+ const char *rvalue,
+ void *data,
+ void *userdata) {
+
+ _cleanup_free_ char *unescaped = NULL;
+ Network *network = data;
+ int r;
+
+ assert(filename);
+ assert(lvalue);
+ assert(rvalue);
+
+ if (isempty(rvalue)) {
+ network->dhcp_mudurl = mfree(network->dhcp_mudurl);
+ return 0;
+ }
+
+ r = cunescape(rvalue, 0, &unescaped);
+ if (r < 0) {
+ log_syntax(unit, LOG_ERR, filename, line, r,
+ "Failed to Failed to unescape MUD URL, ignoring: %s", rvalue);
+ return 0;
+ }
+
+ if (!http_url_is_valid(unescaped) || strlen(unescaped) > 255) {
+ log_syntax(unit, LOG_ERR, filename, line, 0,
+ "Failed to parse MUD URL '%s', ignoring: %m", rvalue);
+
+ return 0;
+ }
+
+ return free_and_strdup_warn(&network->dhcp_mudurl, unescaped);
+}
+
static const char* const dhcp_client_identifier_table[_DHCP_CLIENT_ID_MAX] = {
[DHCP_CLIENT_ID_MAC] = "mac",
[DHCP_CLIENT_ID_DUID] = "duid",
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_user_class);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_request_options);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_ip_service_type);
+CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_mud_url);
DHCPv4.Hostname, config_parse_hostname, 0, offsetof(Network, dhcp_hostname)
DHCPv4.RequestBroadcast, config_parse_bool, 0, offsetof(Network, dhcp_broadcast)
DHCPv4.VendorClassIdentifier, config_parse_string, 0, offsetof(Network, dhcp_vendor_class_identifier)
+DHCPv4.MUDURL, config_parse_dhcp_mud_url, 0, 0
DHCPv4.MaxAttempts, config_parse_dhcp_max_attempts, 0, 0
DHCPv4.UserClass, config_parse_dhcp_user_class, 0, offsetof(Network, dhcp_user_class)
DHCPv4.DUIDType, config_parse_duid_type, 0, offsetof(Network, duid)
free(network->description);
free(network->dhcp_vendor_class_identifier);
+ free(network->dhcp_mudurl);
strv_free(network->dhcp_user_class);
free(network->dhcp_hostname);
set_free(network->dhcp_black_listed_ip);
AddressFamily dhcp;
DHCPClientIdentifier dhcp_client_identifier;
char *dhcp_vendor_class_identifier;
+ char *dhcp_mudurl;
char **dhcp_user_class;
char *dhcp_hostname;
uint64_t dhcp_max_attempts;
SD_DHCP_OPTION_DOMAIN_SEARCH_LIST = 119,
SD_DHCP_OPTION_SIP_SERVER = 120,
SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE = 121,
+ SD_DHCP_OPTION_MUD_URL = 161,
SD_DHCP_OPTION_PRIVATE_BASE = 224,
/* Windows 10 option to send when Anonymize=true */
SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE = 249,
int sd_dhcp_client_set_vendor_class_identifier(
sd_dhcp_client *client,
const char *vci);
+int sd_dhcp_client_set_mud_url(
+ sd_dhcp_client *client,
+ const char *mudurl);
int sd_dhcp_client_set_user_class(
sd_dhcp_client *client,
const char* const *user_class);
if (parent <= 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Parent already died?");
- if (kill(parent, SIGUSR1) < 0)
+ if (kill(parent, SIGUSR2) < 0)
return log_error_errno(errno, "Failed to kill our own parent.");
}
}
SendOption=
SendVendorOption=
SendDecline=
+MUDURL=
RouteMTUBytes=
[DHCPv6]
UseNTP=
[Unit]
Description=Home Area Manager
Documentation=man:systemd-homed.service(8)
-RequiresMountsFor=/home
+After=home.mount
[Service]
BusName=org.freedesktop.home1
projects / thirdparty / systemd.git / commitdiff
