static int hostapd_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[64]; int res; if (argc != 2) { printf("Invalid 'nfc_get_handover_sel' command - two arguments " "are required.\n"); return -1; } res = os_snprintf(cmd, sizeof(cmd), "NFC_GET_HANDOVER_SEL %s %s", argv[0], argv[1]); if (os_snprintf_error(sizeof(cmd), res)) { printf("Too long NFC_GET_HANDOVER_SEL command.\n"); return -1; } return wpa_ctrl_command(ctrl, cmd); }
static int hostapd_get_sta_conn_time(struct sta_info *sta, char *buf, size_t buflen) { struct os_time now, age; int len = 0, ret; if (!sta->connected_time.sec) return 0; os_get_time(&now); os_time_sub(&now, &sta->connected_time, &age); ret = os_snprintf(buf + len, buflen - len, "connected_time=%u\n", (unsigned int) age.sec); if (ret < 0 || (size_t) ret >= buflen - len) return len; len += ret; return len; }
static int hostapd_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[64]; int res; if (argc != 1) { printf("Invalid 'wps_nfc_config_token' command - one argument " "is required.\n"); return -1; } res = os_snprintf(cmd, sizeof(cmd), "WPS_NFC_CONFIG_TOKEN %s", argv[0]); if (os_snprintf_error(sizeof(cmd), res)) { printf("Too long WPS_NFC_CONFIG_TOKEN command.\n"); return -1; } return wpa_ctrl_command(ctrl, cmd); }
const char * hostapd_ip_txt(const struct hostapd_ip_addr *addr, char *buf, size_t buflen) { if (buflen == 0 || addr == NULL) return NULL; if (addr->af == AF_INET) { os_snprintf(buf, buflen, "%s", inet_ntoa(addr->u.v4)); } else { buf[0] = '\0'; } #ifdef CONFIG_IPV6 if (addr->af == AF_INET6) { if (inet_ntop(AF_INET6, &addr->u.v6, buf, buflen) == NULL) buf[0] = '\0'; } #endif /* CONFIG_IPV6 */ return buf; }
static struct eap_sim_reauth * db_get_reauth(struct eap_sim_db_data *data, const char *reauth_id) { char cmd[256]; if (!valid_db_string(reauth_id)) return NULL; os_memset(&data->db_tmp_reauth, 0, sizeof(data->db_tmp_reauth)); os_strlcpy(data->db_tmp_pseudonym_str, reauth_id, sizeof(data->db_tmp_pseudonym_str)); data->db_tmp_reauth.reauth_id = data->db_tmp_pseudonym_str; os_snprintf(cmd, sizeof(cmd), "SELECT * FROM reauth WHERE reauth_id='%s';", reauth_id); if (sqlite3_exec(data->sqlite_db, cmd, get_reauth_cb, data, NULL) != SQLITE_OK) return NULL; if (data->db_tmp_reauth.permanent == NULL) return NULL; return &data->db_tmp_reauth; }
/** * rsn_preauth_get_status - Get pre-authentication status * @sm: Pointer to WPA state machine data from wpa_sm_init() * @buf: Buffer for status information * @buflen: Maximum buffer length * @verbose: Whether to include verbose status information * Returns: Number of bytes written to buf. * * Query WPA2 pre-authentication for status information. This function fills in * a text area with current status information. If the buffer (buf) is not * large enough, status information will be truncated to fit the buffer. */ int rsn_preauth_get_status(struct wpa_sm *sm, char *buf, size_t buflen, int verbose) { char *pos = buf, *end = buf + buflen; int res, ret; if (sm->preauth_eapol) { ret = os_snprintf(pos, end - pos, "Pre-authentication " "EAPOL state machines:\n"); if (ret < 0 || ret >= end - pos) return pos - buf; pos += ret; res = eapol_sm_get_status(sm->preauth_eapol, pos, end - pos, verbose); if (res >= 0) pos += res; } return pos - buf; }
static int hostapd_cli_cmd_set_neighbor(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[2048]; int res; if (argc < 3 || argc > 5) { printf("Invalid set_neighbor command: needs 3-5 arguments\n"); return -1; } res = os_snprintf(cmd, sizeof(cmd), "SET_NEIGHBOR %s %s %s %s %s", argv[0], argv[1], argv[2], argc >= 4 ? argv[3] : "", argc == 5 ? argv[4] : ""); if (os_snprintf_error(sizeof(cmd), res)) { printf("Too long SET_NEIGHBOR command.\n"); return -1; } return wpa_ctrl_command(ctrl, cmd); }
static int wrapd_vap_destroy(struct wrap_demon *aptr, int ifname_num) { struct ifreq ifr; int res; os_memset(&ifr, 0, sizeof(ifr)); res = os_snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ath%d", ifname_num); if (res < 0 || res >= sizeof(ifr.ifr_name)) { wrapd_printf("os_snprintf err"); return -1; } if (ioctl(aptr->ioctl_sock, SIOC80211IFDESTROY, &ifr) < 0){ wrapd_printf("ioctl(SIOC80211IFDESTROY)"); return -1; } return 0; }
int hostapd_ctrl_iface_sta_next(struct hostapd_data *hapd, const char *txtaddr, char *buf, size_t buflen) { u8 addr[ETH_ALEN]; struct sta_info *sta; int ret; if (hwaddr_aton(txtaddr, addr) || (sta = ap_get_sta(hapd, addr)) == NULL) { ret = os_snprintf(buf, buflen, "FAIL\n"); if (os_snprintf_error(buflen, ret)) return 0; return ret; } if (!sta->next) return 0; return hostapd_ctrl_iface_sta_mib(hapd, sta->next, buf, buflen); }
static int wpa_supplicant_ctrl_iface_list_networks( struct wpa_supplicant *wpa_s, char *buf, size_t buflen) { char *pos, *end; struct wpa_ssid *ssid; int ret; pos = buf; end = buf + buflen; ret = os_snprintf(pos, end - pos, "network id / ssid / bssid / flags\n"); if (ret < 0 || ret >= end - pos) return pos - buf; pos += ret; ssid = wpa_s->conf->ssid; while (ssid) { ret = os_snprintf(pos, end - pos, "%d\t%s", ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len)); if (ret < 0 || ret >= end - pos) return pos - buf; pos += ret; if (ssid->bssid_set) { ret = os_snprintf(pos, end - pos, "\t" MACSTR, MAC2STR(ssid->bssid)); } else { ret = os_snprintf(pos, end - pos, "\tany"); } if (ret < 0 || ret >= end - pos) return pos - buf; pos += ret; ret = os_snprintf(pos, end - pos, "\t%s%s", ssid == wpa_s->current_ssid ? "[CURRENT]" : "", ssid->disabled ? "[DISABLED]" : ""); if (ret < 0 || ret >= end - pos) return pos - buf; pos += ret; ret = os_snprintf(pos, end - pos, "\n"); if (ret < 0 || ret >= end - pos) return pos - buf; pos += ret; ssid = ssid->next; } return pos - buf; }
static void recursive_flush_changed_properties(DBusConnection *con, const char *path) { char **objects = NULL; char subobj_path[WPAS_DBUS_OBJECT_PATH_MAX]; int i; wpa_dbus_flush_object_changed_properties(con, path); if (!dbus_connection_list_registered(con, path, &objects)) goto out; for (i = 0; objects[i]; i++) { os_snprintf(subobj_path, WPAS_DBUS_OBJECT_PATH_MAX, "%s/%s", path, objects[i]); recursive_flush_changed_properties(con, subobj_path); } out: dbus_free_string_array(objects); }
int linux_br_get(char *brname, const char *ifname) { char path[128], brlink[128], *pos; ssize_t res; if (!ovs_br_get(brname, ifname)) return 0; os_snprintf(path, sizeof(path), "/sys/class/net/%s/brport/bridge", ifname); res = readlink(path, brlink, sizeof(brlink)); if (res < 0 || (size_t) res >= sizeof(brlink)) return -1; brlink[res] = '\0'; pos = os_strrchr(brlink, '/'); if (pos == NULL) return -1; pos++; os_strlcpy(brname, pos, IFNAMSIZ); return 0; }
int wpas_wps_ap_pin_set(struct wpa_supplicant *wpa_s, const char *pin, int timeout) { struct hostapd_data *hapd; char pin_txt[9]; int ret; if (wpa_s->ap_iface == NULL) return -1; hapd = wpa_s->ap_iface->bss[0]; ret = os_snprintf(pin_txt, sizeof(pin_txt), "%s", pin); if (ret < 0 || ret >= (int) sizeof(pin_txt)) return -1; os_free(hapd->conf->ap_pin); hapd->conf->ap_pin = os_strdup(pin_txt); if (hapd->conf->ap_pin == NULL) return -1; wpas_wps_ap_pin_enable(wpa_s, timeout); return 0; }
int hostapd_ctrl_iface_sta(struct hostapd_data *hapd, const char *txtaddr, char *buf, size_t buflen) { u8 addr[ETH_ALEN]; int ret; const char *pos; struct sta_info *sta; if (hwaddr_aton(txtaddr, addr)) { ret = os_snprintf(buf, buflen, "FAIL\n"); if (os_snprintf_error(buflen, ret)) return 0; return ret; } sta = ap_get_sta(hapd, addr); if (sta == NULL) return -1; pos = os_strchr(txtaddr, ' '); if (pos) { pos++; #ifdef HOSTAPD_DUMP_STATE if (os_strcmp(pos, "eapol") == 0) { if (sta->eapol_sm == NULL) return -1; return eapol_auth_dump_state(sta->eapol_sm, buf, buflen); } #endif /* HOSTAPD_DUMP_STATE */ return -1; } ret = hostapd_ctrl_iface_sta_mib(hapd, sta, buf, buflen); ret += fst_ctrl_iface_mb_info(addr, buf + ret, buflen - ret); return ret; }
static int wpa_supplicant_global_iface_list(struct wpa_global *global, char *buf, int len) { int i, res; struct wpa_interface_info *iface = NULL, *last = NULL, *tmp; char *pos, *end; for (i = 0; wpa_supplicant_drivers[i]; i++) { struct wpa_driver_ops *drv = wpa_supplicant_drivers[i]; if (drv->get_interfaces == NULL) continue; tmp = drv->get_interfaces(global->drv_priv); if (tmp == NULL) continue; if (last == NULL) iface = last = tmp; else last->next = tmp; while (last->next) last = last->next; } pos = buf; end = buf + len; for (tmp = iface; tmp; tmp = tmp->next) { res = os_snprintf(pos, end - pos, "%s\t%s\t%s\n", tmp->drv_name, tmp->ifname, tmp->desc ? tmp->desc : ""); if (res < 0 || res >= end - pos) { *pos = '\0'; break; } pos += res; } wpa_free_iface_info(iface); return pos - buf; }
static struct wpa_ctrl * wpa_cli_open_connection(const char *ifname) { struct wpa_ctrl *cur_conn; #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE) cur_conn = wpa_ctrl_open(ifname); return cur_conn; #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */ char *cfile; int flen; if (ifname == NULL) return NULL; #ifdef ANDROID if (access(ctrl_iface_dir, F_OK) < 0) cfile = (char *)ifname; else { #endif flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2; cfile = os_malloc(flen); if (cfile == NULL) return NULL; os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ifname); #ifdef ANDROID } #endif cur_conn = wpa_ctrl_open(cfile); /* Dm: */ #ifdef CTRL_INTERFACE_2_SOCKETS monitor_conn = wpa_ctrl_open(cfile); #else monitor_conn = cur_conn; #endif #ifdef ANDROID if (cfile != ifname) #endif os_free(cfile); return cur_conn; #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */ }
int vlan_init(struct hostapd_data *hapd) { #ifdef CONFIG_FULL_DYNAMIC_VLAN hapd->full_dynamic_vlan = full_dynamic_vlan_init(hapd); #endif /* CONFIG_FULL_DYNAMIC_VLAN */ if ((hapd->conf->ssid.dynamic_vlan != DYNAMIC_VLAN_DISABLED || hapd->conf->ssid.per_sta_vif) && !hapd->conf->vlan) { /* dynamic vlans enabled but no (or empty) vlan_file given */ struct hostapd_vlan *vlan; int ret; vlan = os_zalloc(sizeof(*vlan)); if (vlan == NULL) { wpa_printf(MSG_ERROR, "Out of memory while assigning " "VLAN interfaces"); return -1; } vlan->vlan_id = VLAN_ID_WILDCARD; ret = os_snprintf(vlan->ifname, sizeof(vlan->ifname), "%s.#", hapd->conf->iface); if (ret >= (int) sizeof(vlan->ifname)) { wpa_printf(MSG_WARNING, "VLAN: Interface name was truncated to %s", vlan->ifname); } else if (ret < 0) { os_free(vlan); return ret; } vlan->next = hapd->conf->vlan; hapd->conf->vlan = vlan; } if (vlan_dynamic_add(hapd, hapd->conf->vlan)) return -1; return 0; }
void wpa_msg(void *ctx, int level, const char *fmt, ...) { va_list ap; char *buf; const int buflen = 2048; int len; char prefix[130]; buf = os_malloc(buflen); if (buf == NULL) { wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message " "buffer"); return; } va_start(ap, fmt); prefix[0] = '\0'; if (wpa_msg_ifname_cb) { const char *ifname = wpa_msg_ifname_cb(ctx); if (ifname) { int res = os_snprintf(prefix, sizeof(prefix), "%s: ", ifname); if (res < 0 || res >= (int) sizeof(prefix)) prefix[0] = '\0'; } } len = vsnprintf(buf, buflen, fmt, ap); va_end(ap); #ifdef CONFIG_SYSTEM_TIMESTAMP struct os_time tv; os_get_time(&tv); wpa_printf(level, "%ld.%06u: %s%s",(long) tv.sec, (unsigned int) tv.usec, prefix, buf); #else wpa_printf(level, "%s%s", prefix, buf); #endif if (wpa_msg_cb) wpa_msg_cb(ctx, level, 0, buf, len); os_free(buf); }
static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global, char *buf, int len) { int res; char *pos, *end; struct wpa_supplicant *wpa_s; wpa_s = global->ifaces; pos = buf; end = buf + len; while (wpa_s) { res = os_snprintf(pos, end - pos, "%s\n", wpa_s->ifname); if (res < 0 || res >= end - pos) { *pos = '\0'; break; } pos += res; wpa_s = wpa_s->next; } return pos - buf; }
static int wpa_supplicant_ctrl_iface_get_network( struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen) { int id; struct wpa_ssid *ssid; char *name, *value; /* cmd: "<network id> <variable name>" */ name = os_strchr(cmd, ' '); if (name == NULL || buflen == 0) return -1; *name++ = '\0'; id = atoi(cmd); wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_NETWORK id=%d name='%s'", id, name); ssid = wpa_config_get_network(wpa_s->conf, id); if (ssid == NULL) { wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network " "id=%d", id); return -1; } value = wpa_config_get_no_key(ssid, name); if (value == NULL) { wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to get network " "variable '%s'", name); return -1; } os_snprintf(buf, buflen, "%s", value); buf[buflen - 1] = '\0'; os_free(value); return os_strlen(buf); }
static char * wpa_supplicant_cipher_txt(char *pos, char *end, int cipher) { int first = 1, ret; ret = os_snprintf(pos, end - pos, "-"); if (ret < 0 || ret >= end - pos) return pos; pos += ret; if (cipher & WPA_CIPHER_NONE) { ret = os_snprintf(pos, end - pos, "%sNONE", first ? "" : "+"); if (ret < 0 || ret >= end - pos) return pos; pos += ret; first = 0; } if (cipher & WPA_CIPHER_WEP40) { ret = os_snprintf(pos, end - pos, "%sWEP40", first ? "" : "+"); if (ret < 0 || ret >= end - pos) return pos; pos += ret; first = 0; } if (cipher & WPA_CIPHER_WEP104) { ret = os_snprintf(pos, end - pos, "%sWEP104", first ? "" : "+"); if (ret < 0 || ret >= end - pos) return pos; pos += ret; first = 0; } if (cipher & WPA_CIPHER_TKIP) { ret = os_snprintf(pos, end - pos, "%sTKIP", first ? "" : "+"); if (ret < 0 || ret >= end - pos) return pos; pos += ret; first = 0; } if (cipher & WPA_CIPHER_CCMP) { ret = os_snprintf(pos, end - pos, "%sCCMP", first ? "" : "+"); if (ret < 0 || ret >= end - pos) return pos; pos += ret; first = 0; } return pos; }
static int hostap_set_iface_flags(void *priv, int dev_up) { struct hostap_driver_data *drv = priv; struct ifreq ifr; char ifname[IFNAMSIZ]; os_snprintf(ifname, IFNAMSIZ, "%sap", drv->iface); if (linux_set_iface_flags(drv->ioctl_sock, ifname, dev_up) < 0) return -1; if (dev_up) { memset(&ifr, 0, sizeof(ifr)); os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ); ifr.ifr_mtu = HOSTAPD_MTU; if (ioctl(drv->ioctl_sock, SIOCSIFMTU, &ifr) != 0) { wpa_printf(MSG_INFO, "Setting MTU failed - trying to survive with current value: ioctl[SIOCSIFMTU]: %s", strerror(errno)); } } return 0; }
/** * eap_get_names - Get space separated list of names for supported EAP methods * @buf: Buffer for names * @buflen: Buffer length * Returns: Number of characters written into buf (not including nul * termination) */ size_t eap_get_names(char *buf, size_t buflen) { char *pos, *end; struct eap_method *m; int ret; if (buflen == 0) return 0; pos = buf; end = pos + buflen; for (m = eap_methods; m; m = m->next) { ret = os_snprintf(pos, end - pos, "%s%s", m == eap_methods ? "" : " ", m->name); if (ret < 0 || ret >= end - pos) break; pos += ret; } buf[buflen - 1] = '\0'; return pos - buf; }
static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[256]; int res; if (argc == 0) { wpa_cli_show_variables(); return 0; } if (argc != 2) { printf("Invalid SET command: needs two arguments (variable " "name and value)\n"); return -1; } res = os_snprintf(cmd, sizeof(cmd), "SET %s %s", argv[0], argv[1]); if (res < 0 || (size_t) res >= sizeof(cmd) - 1) { printf("Too long SET command.\n"); return -1; } return wpa_ctrl_command(ctrl, cmd); }
static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[64]; if (argc < 1 || argc > 2) { printf("Invalid GET_CAPABILITY command: need either one or " "two arguments\n"); return -1; } if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) { printf("Invalid GET_CAPABILITY command: second argument, " "if any, must be 'strict'\n"); return -1; } os_snprintf(cmd, sizeof(cmd), "GET_CAPABILITY %s%s", argv[0], (argc == 2) ? " strict" : ""); cmd[sizeof(cmd) - 1] = '\0'; return wpa_ctrl_command(ctrl, cmd); }
static void hostapd_wps_pin_needed_cb(void *ctx, const u8 *uuid_e, const struct wps_device_data *dev) { struct hostapd_data *hapd = ctx; char uuid[40], txt[400]; int len; char devtype[WPS_DEV_TYPE_BUFSIZE]; if (uuid_bin2str(uuid_e, uuid, sizeof(uuid))) return; wpa_printf(MSG_DEBUG, "WPS: PIN needed for E-UUID %s", uuid); len = os_snprintf(txt, sizeof(txt), WPS_EVENT_PIN_NEEDED "%s " MACSTR " [%s|%s|%s|%s|%s|%s]", uuid, MAC2STR(dev->mac_addr), dev->device_name, dev->manufacturer, dev->model_name, dev->model_number, dev->serial_number, wps_dev_type_bin2str(dev->pri_dev_type, devtype, sizeof(devtype))); if (len > 0 && len < (int) sizeof(txt)) wpa_msg(hapd->msg_ctx, MSG_INFO, "%s", txt); if (hapd->conf->wps_pin_requests) { FILE *f; struct os_time t; f = fopen(hapd->conf->wps_pin_requests, "a"); if (f == NULL) return; os_get_time(&t); fprintf(f, "%ld\t%s\t" MACSTR "\t%s\t%s\t%s\t%s\t%s" "\t%s\n", t.sec, uuid, MAC2STR(dev->mac_addr), dev->device_name, dev->manufacturer, dev->model_name, dev->model_number, dev->serial_number, wps_dev_type_bin2str(dev->pri_dev_type, devtype, sizeof(devtype))); fclose(f); } }
void wpa_msg(void *ctx, int level, const char *fmt, ...) { va_list ap; char *buf; int buflen; int len; char prefix[130]; va_start(ap, fmt); buflen = vsnprintf(NULL, 0, fmt, ap) + 1; va_end(ap); buf = os_malloc(buflen); if (buf == NULL) { wpa_printf(MSG_ERROR, "wpa_msg: Failed to allocate message " "buffer"); return; } va_start(ap, fmt); prefix[0] = '\0'; if (wpa_msg_ifname_cb) { const char *ifname = wpa_msg_ifname_cb(ctx); if (ifname) { int res = os_snprintf(prefix, sizeof(prefix), "%s: ", ifname); if (os_snprintf_error(sizeof(prefix), res)) prefix[0] = '\0'; } } len = vsnprintf(buf, buflen, fmt, ap); va_end(ap); wpa_printf(level, "%s%s", prefix, buf); if (wpa_msg_cb) wpa_msg_cb(ctx, level, WPA_MSG_PER_INTERFACE, buf, len); bin_clear_free(buf, buflen); }
/** * eap_peer_tls_status - Get TLS status * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init() * @data: Data for TLS processing * @buf: Buffer for status information * @buflen: Maximum buffer length * @verbose: Whether to include verbose status information * Returns: Number of bytes written to buf. */ int eap_peer_tls_status(struct eap_sm *sm, struct eap_ssl_data *data, char *buf, size_t buflen, int verbose) { char version[20], name[128]; int len = 0, ret; if (tls_get_version(data->ssl_ctx, data->conn, version, sizeof(version)) < 0) version[0] = '\0'; if (tls_get_cipher(data->ssl_ctx, data->conn, name, sizeof(name)) < 0) name[0] = '\0'; ret = os_snprintf(buf + len, buflen - len, "eap_tls_version=%s\n" "EAP TLS cipher=%s\n" "tls_session_reused=%d\n", version, name, tls_connection_resumed(data->ssl_ctx, data->conn)); if (os_snprintf_error(buflen - len, ret)) return len; len += ret; return len; }
static int hostapd_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc, char *argv[]) { int ret; char *buf; size_t buflen; if (argc != 1) { printf("Invalid 'wps_nfc_tag_read' command - one argument " "is required.\n"); return -1; } buflen = 18 + os_strlen(argv[0]); buf = os_malloc(buflen); if (buf == NULL) return -1; os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]); ret = wpa_ctrl_command(ctrl, buf); os_free(buf); return ret; }
static int check_name(names_to_check_t* names) { char test_conf[1024]; char error_msg[EXA_MAXSIZE_LINE + 1]; int res; putenv("EXANODES_NODE_CONF_DIR=" OS_FILE_SEP "does_not_exist"); adm_cluster_cleanup(); os_snprintf(test_conf, sizeof(test_conf), test_conf_format, EXA_VERSION, names->cluster_name, names->node_name, names->host_name, names->disk_path, adm_hostname()); res = adm_deserialize_from_memory(test_conf, strlen(test_conf), error_msg, true); if (res != EXA_SUCCESS) ut_printf("check_name(cluster:\"%s\", node:\"%s\", host:\"%s\", disk:\"%s\") failed: %s", names->cluster_name, names->node_name, names->host_name, names->disk_path, error_msg); return res; }