static int prepend_component(const char **p, bool usec, unsigned nesting, CalendarComponent **c) { int r, start, stop = -1, repeat = 0; CalendarComponent *cc; const char *e = *p; assert(p); assert(c); if (nesting > CALENDARSPEC_COMPONENTS_MAX) return -ENOBUFS; r = parse_component_decimal(&e, usec, &start); if (r < 0) return r; if (e[0] == '.' && e[1] == '.') { e += 2; r = parse_component_decimal(&e, usec, &stop); if (r < 0) return r; repeat = usec ? USEC_PER_SEC : 1; } if (*e == '/') { e++; r = parse_component_decimal(&e, usec, &repeat); if (r < 0) return r; if (repeat == 0) return -ERANGE; } if (!IN_SET(*e, 0, ' ', ',', '-', '~', ':')) return -EINVAL; cc = new0(CalendarComponent, 1); if (!cc) return -ENOMEM; cc->start = start; cc->stop = stop; cc->repeat = repeat; cc->next = *c; *p = e; *c = cc; if (*e ==',') { *p += 1; return prepend_component(p, usec, nesting + 1, c); } return 0; }
static int frame_callback(Dwfl_Frame *frame, void *userdata) { struct stack_context *c = userdata; Dwarf_Addr pc, pc_adjusted, bias = 0; _cleanup_free_ Dwarf_Die *scopes = NULL; const char *fname = NULL, *symbol = NULL; Dwfl_Module *module; bool is_activation; assert(frame); assert(c); if (c->n_frame >= FRAMES_MAX) return DWARF_CB_ABORT; if (!dwfl_frame_pc(frame, &pc, &is_activation)) return DWARF_CB_ABORT; pc_adjusted = pc - (is_activation ? 0 : 1); module = dwfl_addrmodule(c->dwfl, pc_adjusted); if (module) { Dwarf_Die *s, *cudie; int n; cudie = dwfl_module_addrdie(module, pc_adjusted, &bias); if (cudie) { n = dwarf_getscopes(cudie, pc_adjusted - bias, &scopes); for (s = scopes; s < scopes + n; s++) { if (IN_SET(dwarf_tag(s), DW_TAG_subprogram, DW_TAG_inlined_subroutine, DW_TAG_entry_point)) { Dwarf_Attribute *a, space; a = dwarf_attr_integrate(s, DW_AT_MIPS_linkage_name, &space); if (!a) a = dwarf_attr_integrate(s, DW_AT_linkage_name, &space); if (a) symbol = dwarf_formstring(a); if (!symbol) symbol = dwarf_diename(s); if (symbol) break; } } } if (!symbol) symbol = dwfl_module_addrname(module, pc_adjusted); fname = dwfl_module_info(module, NULL, NULL, NULL, NULL, NULL, NULL, NULL); } fprintf(c->f, "#%-2u 0x%016" PRIx64 " %s (%s)\n", c->n_frame, (uint64_t) pc, strna(symbol), strna(fname)); c->n_frame++; return DWARF_CB_OK; }
static int builtin_uaccess(sd_device *dev, int argc, char *argv[], bool test) { const char *path = NULL, *seat; bool changed_acl = false; uid_t uid; int r; umask(0022); /* don't muck around with ACLs when the system is not running systemd */ if (!logind_running()) return 0; r = sd_device_get_devname(dev, &path); if (r < 0) { log_device_error_errno(dev, r, "Failed to get device name: %m"); goto finish; } if (sd_device_get_property_value(dev, "ID_SEAT", &seat) < 0) seat = "seat0"; r = sd_seat_get_active(seat, NULL, &uid); if (r < 0) { if (IN_SET(r, -ENXIO, -ENODATA)) /* No active session on this seat */ r = 0; else log_device_error_errno(dev, r, "Failed to determine active user on seat %s: %m", seat); goto finish; } r = devnode_acl(path, true, false, 0, true, uid); if (r < 0) { log_device_full(dev, r == -ENOENT ? LOG_DEBUG : LOG_ERR, r, "Failed to apply ACL: %m"); goto finish; } changed_acl = true; r = 0; finish: if (path && !changed_acl) { int k; /* Better be safe than sorry and reset ACL */ k = devnode_acl(path, true, false, 0, false, 0); if (k < 0) { log_device_full(dev, k == -ENOENT ? LOG_DEBUG : LOG_ERR, k, "Failed to apply ACL: %m"); if (r >= 0) r = k; } } return r; }
int calendar_spec_to_string(const CalendarSpec *c, char **p) { char *buf = NULL; size_t sz = 0; FILE *f; int r; assert(c); assert(p); f = open_memstream(&buf, &sz); if (!f) return -ENOMEM; if (c->weekdays_bits > 0 && c->weekdays_bits <= BITS_WEEKDAYS) { format_weekdays(f, c); fputc(' ', f); } format_chain(f, 4, c->year, false); fputc('-', f); format_chain(f, 2, c->month, false); fputc(c->end_of_month ? '~' : '-', f); format_chain(f, 2, c->day, false); fputc(' ', f); format_chain(f, 2, c->hour, false); fputc(':', f); format_chain(f, 2, c->minute, false); fputc(':', f); format_chain(f, 2, c->microsecond, true); if (c->utc) fputs(" UTC", f); else if (IN_SET(c->dst, 0, 1)) { /* If daylight saving is explicitly on or off, let's show the used timezone. */ tzset(); if (!isempty(tzname[c->dst])) { fputc(' ', f); fputs(tzname[c->dst], f); } } r = fflush_and_check(f); if (r < 0) { free(buf); fclose(f); return r; } fclose(f); *p = buf; return 0; }
static int busname_start(Unit *u) { BusName *n = BUSNAME(u); int r; assert(n); /* We cannot fulfill this request right now, try again later * please! */ if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) return -EAGAIN; /* Already on it! */ if (n->state == BUSNAME_MAKING) return 0; if (n->activating && UNIT_ISSET(n->service)) { Service *service; service = SERVICE(UNIT_DEREF(n->service)); if (UNIT(service)->load_state != UNIT_LOADED) { log_unit_error(u, "Bus service %s not loaded, refusing.", UNIT(service)->id); return -ENOENT; } } assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED)); r = unit_start_limit_test(u); if (r < 0) { busname_enter_dead(n, BUSNAME_FAILURE_START_LIMIT_HIT); return r; } r = unit_acquire_invocation_id(u); if (r < 0) return r; n->result = BUSNAME_SUCCESS; busname_enter_making(n); return 1; }
bool dns_type_is_valid_rr(uint16_t type) { /* The types valid as RR in packets (but not necessarily * stored on servers). */ return !IN_SET(type, DNS_TYPE_ANY, DNS_TYPE_AXFR, DNS_TYPE_IXFR); }
bool dns_type_is_valid_query(uint16_t type) { /* The types valid as questions in packets */ return !IN_SET(type, 0, DNS_TYPE_OPT, DNS_TYPE_TSIG, DNS_TYPE_TKEY); }
int sd_ipv4ll_set_index(sd_ipv4ll *ll, int interface_index) { assert_return(ll, -EINVAL); assert_return(interface_index > 0, -EINVAL); assert_return(IN_SET(ll->state, IPV4LL_STATE_INIT, IPV4LL_STATE_STOPPED), -EBUSY); ll->index = interface_index; return 0; }
int sd_dhcp_client_set_index(sd_dhcp_client *client, int interface_index) { assert_return(client, -EINVAL); assert_return (IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY); assert_return(interface_index > 0, -EINVAL); client->index = interface_index; return 0; }
static int pppoe_send(sd_pppoe *ppp, uint8_t code) { union sockaddr_union link = { .ll = { .sll_family = AF_PACKET, .sll_protocol = htons(ETH_P_PPP_DISC), .sll_halen = ETH_ALEN, }, }; _cleanup_free_ struct pppoe_hdr *packet = NULL; int r; assert(ppp); assert(ppp->fd != -1); assert(IN_SET(code, PADI_CODE, PADR_CODE, PADT_CODE)); link.ll.sll_ifindex = ppp->ifindex; if (code == PADI_CODE) memset(&link.ll.sll_addr, 0xff, ETH_ALEN); else memcpy(&link.ll.sll_addr, &ppp->peer_mac, ETH_ALEN); packet = malloc0(PPPOE_MAX_PACKET_SIZE); if (!packet) return -ENOMEM; packet->ver = 0x1; packet->type = 0x1; packet->code = code; if (code == PADT_CODE) packet->sid = ppp->session_id; /* Service-Name */ pppoe_tag_append(packet, PPPOE_MAX_PACKET_SIZE, PTT_SRV_NAME, ppp->service_name, ppp->service_name ? strlen(ppp->service_name) : 0); /* AC-Cookie */ if (code == PADR_CODE && ppp->tags.cookie) pppoe_tag_append(packet, PPPOE_MAX_PACKET_SIZE, PTT_AC_COOKIE, ppp->tags.cookie, ppp->tags.cookie_len); /* Host-Uniq */ if (code != PADT_CODE) { ppp->host_uniq = random_u64(); pppoe_tag_append(packet, PPPOE_MAX_PACKET_SIZE, PTT_HOST_UNIQ, &ppp->host_uniq, sizeof(ppp->host_uniq)); } r = sendto(ppp->fd, packet, sizeof(struct pppoe_hdr) + PPPOE_PACKET_LENGTH(packet), 0, &link.sa, sizeof(link.ll)); if (r < 0) return -errno; return 0; }
static void test_in_set(void) { assert_se(IN_SET(1, 1)); assert_se(IN_SET(1, 1, 2, 3, 4)); assert_se(IN_SET(2, 1, 2, 3, 4)); assert_se(IN_SET(3, 1, 2, 3, 4)); assert_se(IN_SET(4, 1, 2, 3, 4)); assert_se(!IN_SET(0, 1)); assert_se(!IN_SET(0, 1, 2, 3, 4)); }
bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) { assert(de); if (!IN_SET(de->d_type, DT_REG, DT_LNK, DT_UNKNOWN)) return false; if (de->d_name[0] == '.') return false; return endswith(de->d_name, suffix); }
bool dirent_is_file(const struct dirent *de) { assert(de); if (!IN_SET(de->d_type, DT_REG, DT_LNK, DT_UNKNOWN)) return false; if (hidden_or_backup_file(de->d_name)) return false; return true; }
static void scope_set_state(Scope *s, ScopeState state) { ScopeState old_state; assert(s); old_state = s->state; s->state = state; if (!IN_SET(state, SCOPE_STOP_SIGTERM, SCOPE_STOP_SIGKILL)) s->timer_event_source = sd_event_source_unref(s->timer_event_source); if (IN_SET(state, SCOPE_DEAD, SCOPE_FAILED)) { unit_unwatch_all_pids(UNIT(s)); unit_dequeue_rewatch_pids(UNIT(s)); } if (state != old_state) log_debug("%s changed %s -> %s", UNIT(s)->id, scope_state_to_string(old_state), scope_state_to_string(state)); unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], 0); }
static int rmdir_one(const char *prefix, const char *suffix) { char *p; p = strjoina(prefix, "/", suffix); if (rmdir(p) < 0) { if (!IN_SET(errno, ENOENT, ENOTEMPTY)) return log_error_errno(errno, "Failed to remove \"%s\": %m", p); } else log_info("Removed \"%s\".", p); return 0; }
static int test_bus_open(void) { _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL; int r; r = sd_bus_open_user(&bus); if (IN_SET(r, -ECONNREFUSED, -ENOENT)) return r; assert_se(r >= 0); printf("after open: refcount %u\n", REFCNT_GET(bus->n_ref)); return 0; }
bool exit_status_set_test(ExitStatusSet *x, int code, int status) { if (exit_status_set_is_empty(x)) return false; if (code == CLD_EXITED && set_contains(x->status, INT_TO_PTR(status))) return true; if (IN_SET(code, CLD_KILLED, CLD_DUMPED) && set_contains(x->signal, INT_TO_PTR(status))) return true; return false; }
/* Test with the real /etc/adjtime */ static void test_clock_is_localtime_system(void) { int r; r = clock_is_localtime(NULL); if (access("/etc/adjtime", F_OK) == 0) { log_info("/etc/adjtime exists, clock_is_localtime() == %i", r); /* if /etc/adjtime exists we expect some answer, no error or * crash */ assert_se(IN_SET(r, 0, 1)); } else /* default is UTC if there is no /etc/adjtime */ assert_se(r == 0); }
static int busname_stop(Unit *u) { BusName *n = BUSNAME(u); assert(n); /* Already on it */ if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) return 0; /* If there's already something running, we go directly into * kill mode. */ if (n->state == BUSNAME_MAKING) { busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_SUCCESS); return -EAGAIN; } assert(IN_SET(n->state, BUSNAME_REGISTERED, BUSNAME_LISTENING, BUSNAME_RUNNING)); busname_enter_dead(n, BUSNAME_SUCCESS); return 1; }
static int busname_coldplug(Unit *u, Hashmap *deferred_work) { BusName *n = BUSNAME(u); int r; assert(n); assert(n->state == BUSNAME_DEAD); if (n->deserialized_state == n->state) return 0; if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) { if (n->control_pid <= 0) return -EBADMSG; r = unit_watch_pid(UNIT(n), n->control_pid); if (r < 0) return r; r = busname_arm_timer(n); if (r < 0) return r; } if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) { r = busname_open_fd(n); if (r < 0) return r; } if (n->deserialized_state == BUSNAME_LISTENING) { r = busname_watch_fd(n); if (r < 0) return r; } busname_set_state(n, n->deserialized_state); return 0; }
int sd_dhcp_client_set_request_address(sd_dhcp_client *client, const struct in_addr *last_addr) { assert_return(client, -EINVAL); assert_return (IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY); if (last_addr) client->last_addr = last_addr->s_addr; else client->last_addr = INADDR_ANY; return 0; }
static int scope_coldplug(Unit *u) { Scope *s = SCOPE(u); int r; assert(s); assert(s->state == SCOPE_DEAD); if (s->deserialized_state == s->state) return 0; if (IN_SET(s->deserialized_state, SCOPE_STOP_SIGKILL, SCOPE_STOP_SIGTERM)) { r = scope_arm_timer(s, usec_add(u->state_change_timestamp.monotonic, s->timeout_stop_usec)); if (r < 0) return r; } if (!IN_SET(s->deserialized_state, SCOPE_DEAD, SCOPE_FAILED)) unit_watch_all_pids(UNIT(s)); scope_set_state(s, s->deserialized_state); return 0; }
static void test_in_set(void) { log_info("/* %s */", __func__); assert_se(IN_SET(1, 1)); assert_se(IN_SET(1, 1, 2, 3, 4)); assert_se(IN_SET(2, 1, 2, 3, 4)); assert_se(IN_SET(3, 1, 2, 3, 4)); assert_se(IN_SET(4, 1, 2, 3, 4)); assert_se(!IN_SET(0, 1)); assert_se(!IN_SET(0, 1, 2, 3, 4)); }
int routing_policy_rule_remove(RoutingPolicyRule *routing_policy_rule, Link *link, sd_netlink_message_handler_t callback) { _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL; int r; assert(routing_policy_rule); assert(link); assert(link->manager); assert(link->manager->rtnl); assert(link->ifindex > 0); assert(IN_SET(routing_policy_rule->family, AF_INET, AF_INET6)); r = sd_rtnl_message_new_routing_policy_rule(link->manager->rtnl, &m, RTM_DELRULE, routing_policy_rule->family); if (r < 0) return log_error_errno(r, "Could not allocate RTM_DELRULE message: %m"); if (!in_addr_is_null(routing_policy_rule->family, &routing_policy_rule->from)) { if (routing_policy_rule->family == AF_INET) r = sd_netlink_message_append_in_addr(m, FRA_SRC, &routing_policy_rule->from.in); else r = sd_netlink_message_append_in6_addr(m, FRA_SRC, &routing_policy_rule->from.in6); if (r < 0) return log_error_errno(r, "Could not append FRA_SRC attribute: %m"); r = sd_rtnl_message_routing_policy_rule_set_rtm_src_prefixlen(m, routing_policy_rule->from_prefixlen); if (r < 0) return log_error_errno(r, "Could not set source prefix length: %m"); } if (!in_addr_is_null(routing_policy_rule->family, &routing_policy_rule->to)) { if (routing_policy_rule->family == AF_INET) r = sd_netlink_message_append_in_addr(m, FRA_DST, &routing_policy_rule->to.in); else r = sd_netlink_message_append_in6_addr(m, FRA_DST, &routing_policy_rule->to.in6); if (r < 0) return log_error_errno(r, "Could not append FRA_DST attribute: %m"); r = sd_rtnl_message_routing_policy_rule_set_rtm_dst_prefixlen(m, routing_policy_rule->to_prefixlen); if (r < 0) return log_error_errno(r, "Could not set destination prefix length: %m"); } r = sd_netlink_call_async(link->manager->rtnl, m, callback, link, 0, NULL); if (r < 0) return log_error_errno(r, "Could not send rtnetlink message: %m"); link_ref(link); return 0; }
static int busname_coldplug(Unit *u) { BusName *n = BUSNAME(u); int r; assert(n); assert(n->state == BUSNAME_DEAD); if (n->deserialized_state == n->state) return 0; if (n->control_pid > 0 && pid_is_unwaited(n->control_pid) && IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) { r = unit_watch_pid(UNIT(n), n->control_pid); if (r < 0) return r; r = busname_arm_timer(n, usec_add(u->state_change_timestamp.monotonic, n->timeout_usec)); if (r < 0) return r; } if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) { r = busname_open_fd(n); if (r < 0) return r; } if (n->deserialized_state == BUSNAME_LISTENING) { r = busname_watch_fd(n); if (r < 0) return r; } busname_set_state(n, n->deserialized_state); return 0; }
int image_find(const char *name, Image **ret) { const char *path; int r; assert(name); /* There are no images with invalid names */ if (!image_name_is_valid(name)) return 0; NULSTR_FOREACH(path, image_search_path) { _cleanup_closedir_ DIR *d = NULL; d = opendir(path); if (!d) { if (errno == ENOENT) continue; return -errno; } r = image_make(NULL, dirfd(d), path, name, ret); if (IN_SET(r, 0, -ENOENT)) { _cleanup_free_ char *raw = NULL; raw = strappend(name, ".raw"); if (!raw) return -ENOMEM; r = image_make(NULL, dirfd(d), path, raw, ret); if (IN_SET(r, 0, -ENOENT)) continue; } if (r < 0) return r; return 1; }
static int scope_coldplug(Unit *u) { Scope *s = SCOPE(u); int r; assert(s); assert(s->state == SCOPE_DEAD); if (s->deserialized_state != s->state) { if (IN_SET(s->deserialized_state, SCOPE_STOP_SIGKILL, SCOPE_STOP_SIGTERM)) { r = scope_arm_timer(s); if (r < 0) return r; } if (!IN_SET(s->deserialized_state, SCOPE_DEAD, SCOPE_FAILED)) unit_watch_all_pids(UNIT(s)); scope_set_state(s, s->deserialized_state); } return 0; }
static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) { Manager *m = userdata; int r; assert(q); assert(m); assert(m->current_server_name); m->resolve_query = sd_resolve_query_unref(m->resolve_query); if (ret != 0) { log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret)); /* Try next host */ return manager_connect(m); } for (; ai; ai = ai->ai_next) { _cleanup_free_ char *pretty = NULL; ServerAddress *a; assert(ai->ai_addr); assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data)); if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) { log_warning("Unsuitable address protocol for %s", m->current_server_name->string); continue; } r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen); if (r < 0) { log_error("Failed to add server address: %s", strerror(-r)); return r; } server_address_pretty(a, &pretty); log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string); } if (!m->current_server_name->addresses) { log_error("Failed to find suitable address for host %s.", m->current_server_name->string); /* Try next host */ return manager_connect(m); } manager_set_server_address(m, m->current_server_name->addresses); return manager_begin(m); }
static void busname_set_state(BusName *n, BusNameState state) { BusNameState old_state; assert(n); old_state = n->state; n->state = state; if (!IN_SET(state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) { n->timer_event_source = sd_event_source_unref(n->timer_event_source); busname_unwatch_control_pid(n); } if (state != BUSNAME_LISTENING) busname_unwatch_fd(n); if (!IN_SET(state, BUSNAME_LISTENING, BUSNAME_MAKING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) busname_close_fd(n); if (state != old_state) log_unit_debug(UNIT(n), "Changed %s -> %s", busname_state_to_string(old_state), busname_state_to_string(state)); unit_notify(UNIT(n), state_translation_table[old_state], state_translation_table[state], true); }
static int acquire_generator_dirs( UnitFileScope scope, const char *tempdir, char **generator, char **generator_early, char **generator_late) { _cleanup_free_ char *x = NULL, *y = NULL, *z = NULL; const char *prefix; assert(generator); assert(generator_early); assert(generator_late); assert(IN_SET(scope, UNIT_FILE_SYSTEM, UNIT_FILE_USER, UNIT_FILE_GLOBAL)); if (scope == UNIT_FILE_GLOBAL) return -EOPNOTSUPP; if (tempdir) prefix = tempdir; else if (scope == UNIT_FILE_SYSTEM) prefix = "/run/systemd"; else if (scope == UNIT_FILE_USER) { const char *e; e = getenv("XDG_RUNTIME_DIR"); if (!e) return -ENXIO; prefix = strjoina(e, "/systemd"); } x = strappend(prefix, "/generator"); if (!x) return -ENOMEM; y = strappend(prefix, "/generator.early"); if (!y) return -ENOMEM; z = strappend(prefix, "/generator.late"); if (!z) return -ENOMEM; *generator = TAKE_PTR(x); *generator_early = TAKE_PTR(y); *generator_late = TAKE_PTR(z); return 0; }