int config_parse_geneve_flow_label(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) { Geneve *v = userdata; uint32_t f; int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); r = safe_atou32(rvalue, &f); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse Geneve flow label '%s'.", rvalue); return 0; } if (f & ~GENEVE_FLOW_LABEL_MAX_MASK) { log_syntax(unit, LOG_ERR, filename, line, r, "Geneve flow label '%s' not valid. Flow label range should be [0-1048575].", rvalue); return 0; } v->flow_label = f; return 0; }
int config_parse_tunnel_address(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) { Tunnel *t = userdata; union in_addr_union *addr = data, buffer; int r, f; assert(filename); assert(lvalue); assert(rvalue); assert(data); r = in_addr_from_string_auto(rvalue, &f, &buffer); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Tunnel address is invalid, ignoring assignment: %s", rvalue); return 0; } if (t->family != AF_UNSPEC && t->family != f) { log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Tunnel addresses incompatible, ignoring assignment: %s", rvalue); return 0; } t->family = f; *addr = buffer; return 0; }
int config_parse_dnssd_service_type(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) { DnssdService *s = userdata; int r; assert(filename); assert(lvalue); assert(rvalue); assert(s); if (isempty(rvalue)) { log_syntax(unit, LOG_ERR, filename, line, 0, "Service type can't be empty. Ignoring."); return -EINVAL; } if (!dnssd_srv_type_is_valid(rvalue)) { log_syntax(unit, LOG_ERR, filename, line, 0, "Service type is invalid. Ignoring."); return -EINVAL; } r = free_and_strdup(&s->type, rvalue); if (r < 0) return log_oom(); return 0; }
int config_parse_6rd_prefix(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) { Tunnel *t = userdata; assert(filename); assert(lvalue); assert(rvalue); union in_addr_union p; uint8_t l; int r; r = in_addr_prefix_from_string(rvalue, AF_INET6, &p, &l); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse 6rd prefix \"%s\", ignoring: %m", rvalue); return 0; } if (l == 0) { log_syntax(unit, LOG_ERR, filename, line, 0, "6rd prefix length of \"%s\" must be greater than zero, ignoring", rvalue); return 0; } t->sixrd_prefix = p.in6; t->sixrd_prefixlen = l; return 0; }
int config_parse_brvlan_vlan(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) { Network *network = userdata; int r; uint16_t vid, vid_end; assert(filename); assert(section); assert(lvalue); assert(rvalue); assert(data); r = parse_vid_range(rvalue, &vid, &vid_end); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse VLAN, ignoring: %s", rvalue); return 0; } if (UINT16_MAX == vid_end) set_bit(vid++, network->br_vid_bitmap); else { if (vid >= vid_end) { log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid VLAN range, ignoring %s", rvalue); return 0; } for (; vid <= vid_end; vid++) set_bit(vid, network->br_vid_bitmap); } network->use_br_vlan = true; return 0; }
int config_parse_expose_port( 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) { Settings *s = data; int r; assert(filename); assert(lvalue); assert(rvalue); r = expose_port_parse(&s->expose_ports, rvalue); if (r == -EEXIST) { log_syntax(unit, LOG_ERR, filename, line, r, "Duplicate port specification, ignoring: %s", rvalue); return 0; } if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse host port %s: %m", rvalue); return 0; } return 0; }
int config_parse_geneve_vni(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) { Geneve *v = userdata; uint32_t f; int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); r = safe_atou32(rvalue, &f); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse Geneve VNI '%s'.", rvalue); return 0; } if (f > GENEVE_VID_MAX){ log_syntax(unit, LOG_ERR, filename, line, r, "Geneve VNI out is of range '%s'.", rvalue); return 0; } v->id = f; return 0; }
int config_parse_tunnel_address(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) { Tunnel *t = userdata; union in_addr_union *addr = data, buffer; int r, f; assert(filename); assert(lvalue); assert(rvalue); assert(data); /* This is used to parse addresses on both local and remote ends of the tunnel. * Address families must match. * * "any" is a special value which means that the address is unspecified. */ if (streq(rvalue, "any")) { *addr = IN_ADDR_NULL; /* As a special case, if both the local and remote addresses are * unspecified, also clear the address family. */ if (t->family != AF_UNSPEC && in_addr_is_null(t->family, &t->local) && in_addr_is_null(t->family, &t->remote)) t->family = AF_UNSPEC; return 0; } r = in_addr_from_string_auto(rvalue, &f, &buffer); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Tunnel address \"%s\" invalid, ignoring assignment: %m", rvalue); return 0; } if (t->family != AF_UNSPEC && t->family != f) { log_syntax(unit, LOG_ERR, filename, line, 0, "Tunnel addresses incompatible, ignoring assignment: %s", rvalue); return 0; } t->family = f; *addr = buffer; return 0; }
int parse_cpu_set_and_warn( const char *rvalue, cpu_set_t **cpu_set, const char *unit, const char *filename, unsigned line, const char *lvalue) { const char *whole_rvalue = rvalue; _cleanup_cpu_free_ cpu_set_t *c = NULL; unsigned ncpus = 0; assert(lvalue); assert(rvalue); for (;;) { _cleanup_free_ char *word = NULL; unsigned cpu; int r; r = extract_first_word(&rvalue, &word, WHITESPACE, EXTRACT_QUOTES); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Invalid value for %s: %s", lvalue, whole_rvalue); return r; } if (r == 0) break; if (!c) { c = cpu_set_malloc(&ncpus); if (!c) return log_oom(); } r = safe_atou(word, &cpu); if (r < 0 || cpu >= ncpus) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse CPU affinity '%s'", rvalue); return -EINVAL; } CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c); } /* On success, sets *cpu_set and returns ncpus for the system. */ if (c) { *cpu_set = c; c = NULL; } return (int) ncpus; }
int config_parse_router_preference(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) { Network *network = userdata; assert(filename); assert(section); assert(lvalue); assert(rvalue); assert(data); if (streq(rvalue, "high")) network->router_preference = SD_NDISC_PREFERENCE_HIGH; else if (STR_IN_SET(rvalue, "medium", "normal", "default")) network->router_preference = SD_NDISC_PREFERENCE_MEDIUM; else if (streq(rvalue, "low")) network->router_preference = SD_NDISC_PREFERENCE_LOW; else log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Router preference '%s' is invalid, ignoring assignment: %m", rvalue); return 0; }
int config_parse_ipv6_route_preference(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) { Network *network = userdata; _cleanup_route_free_ Route *n = NULL; int r; r = route_new_static(network, filename, section_line, &n); if (r < 0) return r; if (streq(rvalue, "low")) n->pref = ICMPV6_ROUTER_PREF_LOW; else if (streq(rvalue, "medium")) n->pref = ICMPV6_ROUTER_PREF_MEDIUM; else if (streq(rvalue, "high")) n->pref = ICMPV6_ROUTER_PREF_HIGH; else { log_syntax(unit, LOG_ERR, filename, line, 0, "Unknown route preference: %s", rvalue); return 0; } n = NULL; return 0; }
int config_parse_address_family_boolean_with_kernel( 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) { AddressFamilyBoolean *fwd = data, s; assert(filename); assert(lvalue); assert(rvalue); assert(data); s = address_family_boolean_from_string(rvalue); if (s < 0) { if (streq(rvalue, "kernel")) s = _ADDRESS_FAMILY_BOOLEAN_INVALID; else { log_syntax(unit, LOG_ERR, filename, line, s, "Failed to parse IPForwarding= option, ignoring: %s", rvalue); return 0; } } *fwd = s; return 0; }
int config_parse_tunnel_address(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) { NetDev *n = userdata; union in_addr_union *addr = data; int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); r = net_parse_inaddr(rvalue, &n->family, addr); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Tunnel address is invalid, ignoring assignment: %s", rvalue); return 0; } return 0; }
int config_parse_bytes_size(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) { size_t *sz = data; off_t o; int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); r = parse_bytes(rvalue, &o); if (r < 0 || (off_t) (size_t) o != o) { log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to parse byte value, ignoring: %s", rvalue); return 0; } *sz = (size_t) o; return 0; }
int config_parse_router_prefix_delegation( 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) { Network *network = userdata; RADVPrefixDelegation d; assert(filename); assert(section); assert(lvalue); assert(rvalue); assert(data); d = radv_prefix_delegation_from_string(rvalue); if (d < 0) { log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Invalid router prefix delegation '%s', ignoring assignment.", rvalue); return 0; } network->router_prefix_delegation = d; return 0; }
int config_parse_veth_extra( 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) { Settings *settings = data; int r; assert(filename); assert(lvalue); assert(rvalue); r = veth_extra_parse(&settings->network_veth_extra, rvalue); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Invalid extra virtual Ethernet link specification %s: %m", rvalue); return 0; } return 0; }
int config_parse_pivot_root( 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) { Settings *settings = data; int r; assert(filename); assert(lvalue); assert(rvalue); r = pivot_root_parse(&settings->pivot_root_new, &settings->pivot_root_old, rvalue); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Invalid pivot root mount specification %s: %m", rvalue); return 0; } return 0; }
int config_parse_servers( 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) { Manager *m = userdata; int r; assert(filename); assert(lvalue); assert(rvalue); if (isempty(rvalue)) manager_flush_server_names(m, ltype); else { r = manager_parse_server_string(m, ltype, rvalue); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse NTP server string '%s'. Ignoring.", rvalue); return 0; } } return 0; }
int config_parse_quickack(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_route_free_ Route *n = NULL; Network *network = userdata; int k, r; assert(filename); assert(section); assert(lvalue); assert(rvalue); assert(data); r = route_new_static(network, filename, section_line, &n); if (r < 0) return r; k = parse_boolean(rvalue); if (k < 0) { log_syntax(unit, LOG_ERR, filename, line, k, "Failed to parse TCP quickack, ignoring: %s", rvalue); return 0; } n->quickack = !!k; n = NULL; return 0; }
int config_parse_route_type(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) { Network *network = userdata; _cleanup_route_free_ Route *n = NULL; int r; r = route_new_static(network, filename, section_line, &n); if (r < 0) return r; if (streq(rvalue, "unicast")) n->type = RTN_UNICAST; else if (streq(rvalue, "blackhole")) n->type = RTN_BLACKHOLE; else if (streq(rvalue, "unreachable")) n->type = RTN_UNREACHABLE; else if (streq(rvalue, "prohibit")) n->type = RTN_PROHIBIT; else { log_syntax(unit, LOG_ERR, filename, line, r, "Could not parse route type \"%s\", ignoring assignment: %m", rvalue); return 0; } n = NULL; return 0; }
int config_parse_id128( 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) { sd_id128_t t, *result = data; int r; assert(filename); assert(lvalue); assert(rvalue); r = sd_id128_from_string(rvalue, &t); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse 128bit ID/UUID, ignoring: %s", rvalue); return 0; } *result = t; return 0; }
int config_parse_tristate(const char *unit, const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { int k; int *b = data; assert(filename); assert(lvalue); assert(rvalue); assert(data); /* Tristates are like booleans, but can also take the 'default' value, i.e. "-1" */ k = parse_boolean(rvalue); if (k < 0) { log_syntax(unit, LOG_ERR, filename, line, -k, "Failed to parse boolean value, ignoring: %s", rvalue); return 0; } *b = !!k; return 0; }
int config_parse_overlay( 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) { Settings *settings = data; int r; assert(filename); assert(lvalue); assert(rvalue); r = overlay_mount_parse(&settings->custom_mounts, &settings->n_custom_mounts, rvalue, ltype); if (r < 0) log_syntax(unit, LOG_ERR, filename, line, r, "Invalid overlay file system specification %s, ignoring: %m", rvalue); return 0; }
int config_parse_bool(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) { int k; bool *b = data; assert(filename); assert(lvalue); assert(rvalue); assert(data); k = parse_boolean(rvalue); if (k < 0) { log_syntax(unit, LOG_ERR, filename, line, -k, "Failed to parse boolean value, ignoring: %s", rvalue); return 0; } *b = !!k; return 0; }
int config_parse_network_zone( 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) { Settings *settings = data; _cleanup_free_ char *j = NULL; assert(filename); assert(lvalue); assert(rvalue); j = strappend("vz-", rvalue); if (!ifname_valid(j)) { log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid network zone name %s, ignoring: %m", rvalue); return 0; } free(settings->network_zone); settings->network_zone = j; j = NULL; return 0; }
int config_parse_link_journal( 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) { Settings *settings = data; int r; assert(rvalue); assert(settings); r = parse_link_journal(rvalue, &settings->link_journal, &settings->link_journal_try); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse link journal mode, ignoring: %s", rvalue); return 0; } return 0; }
int config_parse_bytes_off(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) { off_t *bytes = data; int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); assert_cc(sizeof(off_t) == sizeof(uint64_t)); r = parse_bytes(rvalue, bytes); if (r < 0) log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to parse bytes value, ignoring: %s", rvalue); return 0; }
int config_parse_address_label_prefix(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_address_label_free_ AddressLabel *n = NULL; Network *network = userdata; int r; assert(filename); assert(section); assert(lvalue); assert(rvalue); assert(data); r = address_label_new_static(network, filename, section_line, &n); if (r < 0) return r; r = in_addr_prefix_from_string(rvalue, AF_INET6, &n->in_addr, &n->prefixlen); if (r < 0) { log_syntax(unit, LOG_ERR, filename, line, r, "Address label is invalid, ignoring assignment: %s", rvalue); return 0; } n = NULL; return 0; }
int config_parse_show_status(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) { int k; ShowStatus *b = data; assert(filename); assert(lvalue); assert(rvalue); assert(data); k = parse_show_status(rvalue, b); if (k < 0) { log_syntax(unit, LOG_ERR, filename, line, -k, "Failed to parse show status setting, ignoring: %s", rvalue); return 0; } return 0; }
int config_parse_hostname( 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) { char **s = data; assert(rvalue); assert(s); if (!hostname_is_valid(rvalue, false)) { log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid hostname, ignoring: %s", rvalue); return 0; } if (free_and_strdup(s, empty_to_null(rvalue)) < 0) return log_oom(); return 0; }