diff options
Diffstat (limited to 'libglusterfs/src/common-utils.c')
| -rw-r--r-- | libglusterfs/src/common-utils.c | 7053 |
1 files changed, 3540 insertions, 3513 deletions
diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c index 748772bb21b..aae9858fe22 100644 --- a/libglusterfs/src/common-utils.c +++ b/libglusterfs/src/common-utils.c @@ -63,36 +63,41 @@ #define AI_ADDRCONFIG 0 #endif /* AI_ADDRCONFIG */ -char *vol_type_str[] = {"Distribute", - "Stripe", - "Replicate", - "Striped-Replicate", - "Disperse", - "Tier", - "Distributed-Stripe", - "Distributed-Replicate", - "Distributed-Striped-Replicate", - "Distributed-Disperse", - }; +char *vol_type_str[] = { + "Distribute", + "Stripe", + "Replicate", + "Striped-Replicate", + "Disperse", + "Tier", + "Distributed-Stripe", + "Distributed-Replicate", + "Distributed-Striped-Replicate", + "Distributed-Disperse", +}; typedef int32_t (*rw_op_t)(int32_t fd, char *buf, int32_t size); typedef int32_t (*rwv_op_t)(int32_t fd, const struct iovec *buf, int32_t size); void -gf_xxh64_wrapper(const unsigned char *data, size_t const len, unsigned long long const seed, - char *xxh64) +gf_xxh64_wrapper(const unsigned char *data, size_t const len, + unsigned long long const seed, char *xxh64) { - unsigned short i = 0; - const unsigned short lim = GF_XXH64_DIGEST_LENGTH*2+1; - XXH64_hash_t hash = 0; - XXH64_canonical_t c_hash = {{0,},}; - const uint8_t *p = (const uint8_t *) &c_hash; + unsigned short i = 0; + const unsigned short lim = GF_XXH64_DIGEST_LENGTH * 2 + 1; + XXH64_hash_t hash = 0; + XXH64_canonical_t c_hash = { + { + 0, + }, + }; + const uint8_t *p = (const uint8_t *)&c_hash; - hash = XXH64(data, len, seed); - XXH64_canonicalFromHash(&c_hash, hash); + hash = XXH64(data, len, seed); + XXH64_canonicalFromHash(&c_hash, hash); - for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++) - snprintf(xxh64 + i * 2, lim-i*2, "%02x", p[i]); + for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++) + snprintf(xxh64 + i * 2, lim - i * 2, "%02x", p[i]); } /** @@ -133,34 +138,35 @@ gf_xxh64_wrapper(const unsigned char *data, size_t const len, unsigned long long * tmp[15] = (hash_1) & 0xff; **/ static int -gf_gfid_from_xxh64 (xlator_t *this, uuid_t gfid, XXH64_hash_t hash, - unsigned short index) -{ - int ret = -1; - int i = -1; - - if ((index != 0) && (index != 8)) { - gf_msg_callingfn ("gfid-from-xxh64", GF_LOG_WARNING, 0, - LG_MSG_INDEX_NOT_FOUND, - "index can only be either 0 or 8, as this" - "function's purpose is to encode a 8 byte " - "hash inside the gfid (index: %d)", index); - goto out; - } - - for (i = 0; i < sizeof (hash); i++) { - /* - * As of now the below statement is equivalent of this. - * gfid[index+i] = (hash >> (64 - (8 * (i+1)))) & 0xff; - */ - gfid[index+i] = (hash >> ((sizeof (hash) * 8) - (8 * (i+1)))) - & (0xff); - } +gf_gfid_from_xxh64(xlator_t *this, uuid_t gfid, XXH64_hash_t hash, + unsigned short index) +{ + int ret = -1; + int i = -1; + + if ((index != 0) && (index != 8)) { + gf_msg_callingfn("gfid-from-xxh64", GF_LOG_WARNING, 0, + LG_MSG_INDEX_NOT_FOUND, + "index can only be either 0 or 8, as this" + "function's purpose is to encode a 8 byte " + "hash inside the gfid (index: %d)", + index); + goto out; + } + + for (i = 0; i < sizeof(hash); i++) { + /* + * As of now the below statement is equivalent of this. + * gfid[index+i] = (hash >> (64 - (8 * (i+1)))) & 0xff; + */ + gfid[index + i] = (hash >> ((sizeof(hash) * 8) - (8 * (i + 1)))) & + (0xff); + } - ret = 0; + ret = 0; out: - return ret; + return ret; } /** @@ -177,22 +183,26 @@ out: * of the hash). **/ XXH64_hash_t -gf_xxh64_hash_wrapper (const unsigned char *data, size_t const len, - unsigned long long const seed, char *xxh64) +gf_xxh64_hash_wrapper(const unsigned char *data, size_t const len, + unsigned long long const seed, char *xxh64) { - unsigned short i = 0; - const unsigned short lim = GF_XXH64_DIGEST_LENGTH*2+1; - XXH64_hash_t hash = 0; - XXH64_canonical_t c_hash = {{0,},}; - const uint8_t *p = (const uint8_t *)&c_hash; + unsigned short i = 0; + const unsigned short lim = GF_XXH64_DIGEST_LENGTH * 2 + 1; + XXH64_hash_t hash = 0; + XXH64_canonical_t c_hash = { + { + 0, + }, + }; + const uint8_t *p = (const uint8_t *)&c_hash; - hash = XXH64(data, len, seed); - XXH64_canonicalFromHash (&c_hash, hash); + hash = XXH64(data, len, seed); + XXH64_canonicalFromHash(&c_hash, hash); - for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++) - snprintf (xxh64 + i * 2, lim-i*2, "%02x", p[i]); + for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++) + snprintf(xxh64 + i * 2, lim - i * 2, "%02x", p[i]); - return hash; + return hash; } /** @@ -220,152 +230,165 @@ gf_xxh64_hash_wrapper (const unsigned char *data, size_t const len, * one 16 byte entity. **/ int -gf_gfid_generate_from_xxh64 (uuid_t gfid, char *key) -{ - char xxh64_1[GF_XXH64_DIGEST_LENGTH*2+1] = {0, }; - char xxh64_2[GF_XXH64_DIGEST_LENGTH*2+1] = {0, }; - XXH64_hash_t hash_1 = 0; - XXH64_hash_t hash_2 = 0; - int ret = -1; - xlator_t *this = THIS; - - hash_1 = gf_xxh64_hash_wrapper((unsigned char *)key, - strlen (key), GF_XXHSUM64_DEFAULT_SEED, - xxh64_1); - - hash_2 = gf_xxh64_hash_wrapper((unsigned char *)xxh64_1, - strlen (xxh64_1), - GF_XXHSUM64_DEFAULT_SEED, xxh64_2); - - /* hash_2 is saved in 1st 8 elements of uuid_t char array */ - if (gf_gfid_from_xxh64 (this, gfid, hash_2, 0)) { - gf_msg_callingfn (this->name, GF_LOG_WARNING, 0, - LG_MSG_XXH64_TO_GFID_FAILED, - "failed to encode the hash %llx into the 1st" - "half of gfid", hash_2); - goto out; - } - - /* hash_1 is saved in the remaining 8 elements of uuid_t */ - if (gf_gfid_from_xxh64 (this, gfid, hash_1, 8)) { - gf_msg_callingfn (this->name, GF_LOG_WARNING, 0, - LG_MSG_XXH64_TO_GFID_FAILED, - "failed to encode the hash %llx into the 2nd" - "half of gfid", hash_1); - goto out; - } - - gf_msg_debug (this->name, 0, "gfid generated is %s (hash1: %llx) " - "hash2: %llx, xxh64_1: %s xxh64_2: %s", uuid_utoa (gfid), - hash_1, hash_2, xxh64_1, xxh64_2); - - ret = 0; +gf_gfid_generate_from_xxh64(uuid_t gfid, char *key) +{ + char xxh64_1[GF_XXH64_DIGEST_LENGTH * 2 + 1] = { + 0, + }; + char xxh64_2[GF_XXH64_DIGEST_LENGTH * 2 + 1] = { + 0, + }; + XXH64_hash_t hash_1 = 0; + XXH64_hash_t hash_2 = 0; + int ret = -1; + xlator_t *this = THIS; + + hash_1 = gf_xxh64_hash_wrapper((unsigned char *)key, strlen(key), + GF_XXHSUM64_DEFAULT_SEED, xxh64_1); + + hash_2 = gf_xxh64_hash_wrapper((unsigned char *)xxh64_1, strlen(xxh64_1), + GF_XXHSUM64_DEFAULT_SEED, xxh64_2); + + /* hash_2 is saved in 1st 8 elements of uuid_t char array */ + if (gf_gfid_from_xxh64(this, gfid, hash_2, 0)) { + gf_msg_callingfn(this->name, GF_LOG_WARNING, 0, + LG_MSG_XXH64_TO_GFID_FAILED, + "failed to encode the hash %llx into the 1st" + "half of gfid", + hash_2); + goto out; + } + + /* hash_1 is saved in the remaining 8 elements of uuid_t */ + if (gf_gfid_from_xxh64(this, gfid, hash_1, 8)) { + gf_msg_callingfn(this->name, GF_LOG_WARNING, 0, + LG_MSG_XXH64_TO_GFID_FAILED, + "failed to encode the hash %llx into the 2nd" + "half of gfid", + hash_1); + goto out; + } + + gf_msg_debug(this->name, 0, + "gfid generated is %s (hash1: %llx) " + "hash2: %llx, xxh64_1: %s xxh64_2: %s", + uuid_utoa(gfid), hash_1, hash_2, xxh64_1, xxh64_2); + + ret = 0; out: - return ret; + return ret; } /* works similar to mkdir(1) -p. */ int -mkdir_p (char *path, mode_t mode, gf_boolean_t allow_symlinks) -{ - int i = 0; - int ret = -1; - char dir[PATH_MAX] = {0,}; - struct stat stbuf = {0,}; - - const int path_len = min(strlen(path), PATH_MAX -1); - - snprintf(dir, path_len + 1, "%s", path); - - i = (dir[0] == '/')? 1: 0; - do { - if (path[i] != '/' && path[i] != '\0') - continue; - - dir[i] = '\0'; - ret = sys_mkdir (dir, mode); - if (ret && errno != EEXIST) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, - "Failed due to reason"); - goto out; - } - - if (ret && errno == EEXIST && !allow_symlinks) { - ret = sys_lstat (dir, &stbuf); - if (ret) - goto out; - - if (S_ISLNK (stbuf.st_mode)) { - ret = -1; - gf_msg ("", GF_LOG_ERROR, 0, - LG_MSG_DIR_IS_SYMLINK, "%s is a " - "symlink", dir); - goto out; - } - } - dir[i] = '/'; - - } while (path[i++] != '\0'); - - ret = sys_stat (dir, &stbuf); - if (ret || !S_ISDIR (stbuf.st_mode)) { - if (ret == 0) - errno = 0; +mkdir_p(char *path, mode_t mode, gf_boolean_t allow_symlinks) +{ + int i = 0; + int ret = -1; + char dir[PATH_MAX] = { + 0, + }; + struct stat stbuf = { + 0, + }; + + const int path_len = min(strlen(path), PATH_MAX - 1); + + snprintf(dir, path_len + 1, "%s", path); + + i = (dir[0] == '/') ? 1 : 0; + do { + if (path[i] != '/' && path[i] != '\0') + continue; + + dir[i] = '\0'; + ret = sys_mkdir(dir, mode); + if (ret && errno != EEXIST) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, + "Failed due to reason"); + goto out; + } + + if (ret && errno == EEXIST && !allow_symlinks) { + ret = sys_lstat(dir, &stbuf); + if (ret) + goto out; + + if (S_ISLNK(stbuf.st_mode)) { ret = -1; - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, "Failed" - " to create directory, possibly some of the components" - " were not directories"); + gf_msg("", GF_LOG_ERROR, 0, LG_MSG_DIR_IS_SYMLINK, + "%s is a " + "symlink", + dir); goto out; + } } + dir[i] = '/'; - ret = 0; + } while (path[i++] != '\0'); + + ret = sys_stat(dir, &stbuf); + if (ret || !S_ISDIR(stbuf.st_mode)) { + if (ret == 0) + errno = 0; + ret = -1; + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, + "Failed" + " to create directory, possibly some of the components" + " were not directories"); + goto out; + } + + ret = 0; out: - return ret; + return ret; } int -gf_lstat_dir (const char *path, struct stat *stbuf_in) +gf_lstat_dir(const char *path, struct stat *stbuf_in) { - int ret = -1; - struct stat stbuf = {0,}; + int ret = -1; + struct stat stbuf = { + 0, + }; - if (path == NULL) { - errno = EINVAL; - goto out; - } + if (path == NULL) { + errno = EINVAL; + goto out; + } - ret = sys_lstat (path, &stbuf); - if (ret) - goto out; + ret = sys_lstat(path, &stbuf); + if (ret) + goto out; - if (!S_ISDIR (stbuf.st_mode)) { - errno = ENOTDIR; - ret = -1; - goto out; - } - ret = 0; + if (!S_ISDIR(stbuf.st_mode)) { + errno = ENOTDIR; + ret = -1; + goto out; + } + ret = 0; out: - if (!ret && stbuf_in) - *stbuf_in = stbuf; + if (!ret && stbuf_in) + *stbuf_in = stbuf; - return ret; + return ret; } int -log_base2 (unsigned long x) +log_base2(unsigned long x) { - int val = 0; + int val = 0; - while (x > 1) { - x /= 2; - val++; - } + while (x > 1) { + x /= 2; + val++; + } - return val; + return val; } /** @@ -377,22 +400,23 @@ log_base2 (unsigned long x) * failure: NULL */ char * -gf_rev_dns_lookup (const char *ip) +gf_rev_dns_lookup(const char *ip) { - char *fqdn = NULL; - int ret = 0; + char *fqdn = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO ("resolver", ip, out); + GF_VALIDATE_OR_GOTO("resolver", ip, out); - /* Get the FQDN */ - ret = gf_get_hostname_from_ip ((char *)ip, &fqdn); - if (ret != 0) { - gf_msg ("resolver", GF_LOG_INFO, errno, - LG_MSG_RESOLVE_HOSTNAME_FAILED, "could not resolve " - "hostname for %s", ip); - } + /* Get the FQDN */ + ret = gf_get_hostname_from_ip((char *)ip, &fqdn); + if (ret != 0) { + gf_msg("resolver", GF_LOG_INFO, errno, LG_MSG_RESOLVE_HOSTNAME_FAILED, + "could not resolve " + "hostname for %s", + ip); + } out: - return fqdn; + return fqdn; } /** @@ -402,144 +426,145 @@ out: * @return: The parent path if found, NULL otherwise */ char * -gf_resolve_path_parent (const char *path) +gf_resolve_path_parent(const char *path) { - char *parent = NULL; - char *tmp = NULL; - char *pathc = NULL; + char *parent = NULL; + char *tmp = NULL; + char *pathc = NULL; - GF_VALIDATE_OR_GOTO (THIS->name, path, out); + GF_VALIDATE_OR_GOTO(THIS->name, path, out); - if (strlen (path) <= 0) { - gf_msg_callingfn (THIS->name, GF_LOG_DEBUG, 0, - LG_MSG_INVALID_STRING, - "invalid string for 'path'"); - goto out; - } + if (strlen(path) <= 0) { + gf_msg_callingfn(THIS->name, GF_LOG_DEBUG, 0, LG_MSG_INVALID_STRING, + "invalid string for 'path'"); + goto out; + } - /* dup the parameter, we don't want to modify it */ - pathc = strdupa (path); - if (!pathc) { - goto out; - } + /* dup the parameter, we don't want to modify it */ + pathc = strdupa(path); + if (!pathc) { + goto out; + } - /* Get the parent directory */ - tmp = dirname (pathc); - if (strcmp (tmp, "/") == 0) - goto out; + /* Get the parent directory */ + tmp = dirname(pathc); + if (strcmp(tmp, "/") == 0) + goto out; - parent = gf_strdup (tmp); + parent = gf_strdup(tmp); out: - return parent; + return parent; } int32_t -gf_resolve_ip6 (const char *hostname, - uint16_t port, - int family, - void **dnscache, - struct addrinfo **addr_info) -{ - int32_t ret = 0; - struct addrinfo hints; - struct dnscache6 *cache = NULL; - char service[NI_MAXSERV], host[NI_MAXHOST]; - - if (!hostname) { - gf_msg_callingfn ("resolver", GF_LOG_WARNING, 0, - LG_MSG_HOSTNAME_NULL, "hostname is NULL"); - return -1; - } +gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache, + struct addrinfo **addr_info) +{ + int32_t ret = 0; + struct addrinfo hints; + struct dnscache6 *cache = NULL; + char service[NI_MAXSERV], host[NI_MAXHOST]; - if (!*dnscache) { - *dnscache = GF_CALLOC (1, sizeof (struct dnscache6), - gf_common_mt_dnscache6); - if (!*dnscache) - return -1; - } + if (!hostname) { + gf_msg_callingfn("resolver", GF_LOG_WARNING, 0, LG_MSG_HOSTNAME_NULL, + "hostname is NULL"); + return -1; + } + + if (!*dnscache) { + *dnscache = GF_CALLOC(1, sizeof(struct dnscache6), + gf_common_mt_dnscache6); + if (!*dnscache) + return -1; + } + + cache = *dnscache; + if (cache->first && !cache->next) { + freeaddrinfo(cache->first); + cache->first = cache->next = NULL; + gf_msg_trace("resolver", 0, "flushing DNS cache"); + } - cache = *dnscache; - if (cache->first && !cache->next) { - freeaddrinfo(cache->first); - cache->first = cache->next = NULL; - gf_msg_trace ("resolver", 0, "flushing DNS cache"); - } + if (!cache->first) { + char *port_str = NULL; + gf_msg_trace("resolver", 0, + "DNS cache not present, freshly " + "probing hostname: %s", + hostname); + + memset(&hints, 0, sizeof(hints)); + hints.ai_family = family; + hints.ai_socktype = SOCK_STREAM; - if (!cache->first) { - char *port_str = NULL; - gf_msg_trace ("resolver", 0, "DNS cache not present, freshly " - "probing hostname: %s", hostname); - - memset(&hints, 0, sizeof(hints)); - hints.ai_family = family; - hints.ai_socktype = SOCK_STREAM; - - ret = gf_asprintf (&port_str, "%d", port); - if (-1 == ret) { - return -1; - } - if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) != 0) { - gf_msg ("resolver", GF_LOG_ERROR, 0, - LG_MSG_GETADDRINFO_FAILED, "getaddrinfo failed" - " (%s)", gai_strerror (ret)); - - GF_FREE (*dnscache); - *dnscache = NULL; - GF_FREE (port_str); - return -1; - } - GF_FREE (port_str); - - cache->next = cache->first; + ret = gf_asprintf(&port_str, "%d", port); + if (-1 == ret) { + return -1; } + if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) != + 0) { + gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED, + "getaddrinfo failed" + " (%s)", + gai_strerror(ret)); - if (cache->next) { - ret = getnameinfo((struct sockaddr *)cache->next->ai_addr, - cache->next->ai_addrlen, - host, sizeof (host), - service, sizeof (service), - NI_NUMERICHOST); - if (ret != 0) { - gf_msg ("resolver", GF_LOG_ERROR, 0, - LG_MSG_GETNAMEINFO_FAILED, "getnameinfo failed" - " (%s)", gai_strerror (ret)); - goto err; - } - - gf_msg_debug ("resolver", 0, "returning ip-%s (port-%s) for " - "hostname: %s and port: %d", host, service, - hostname, port); - - *addr_info = cache->next; + GF_FREE(*dnscache); + *dnscache = NULL; + GF_FREE(port_str); + return -1; } + GF_FREE(port_str); + + cache->next = cache->first; + } - if (cache->next) - cache->next = cache->next->ai_next; - if (cache->next) { - ret = getnameinfo((struct sockaddr *)cache->next->ai_addr, - cache->next->ai_addrlen, - host, sizeof (host), - service, sizeof (service), - NI_NUMERICHOST); - if (ret != 0) { - gf_msg ("resolver", GF_LOG_ERROR, 0, - LG_MSG_GETNAMEINFO_FAILED, "getnameinfo failed" - " (%s)", gai_strerror (ret)); - goto err; - } - - gf_msg_debug ("resolver", 0, "next DNS query will return: " - "ip-%s port-%s", host, service); + if (cache->next) { + ret = getnameinfo((struct sockaddr *)cache->next->ai_addr, + cache->next->ai_addrlen, host, sizeof(host), service, + sizeof(service), NI_NUMERICHOST); + if (ret != 0) { + gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED, + "getnameinfo failed" + " (%s)", + gai_strerror(ret)); + goto err; + } + + gf_msg_debug("resolver", 0, + "returning ip-%s (port-%s) for " + "hostname: %s and port: %d", + host, service, hostname, port); + + *addr_info = cache->next; + } + + if (cache->next) + cache->next = cache->next->ai_next; + if (cache->next) { + ret = getnameinfo((struct sockaddr *)cache->next->ai_addr, + cache->next->ai_addrlen, host, sizeof(host), service, + sizeof(service), NI_NUMERICHOST); + if (ret != 0) { + gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED, + "getnameinfo failed" + " (%s)", + gai_strerror(ret)); + goto err; } - return 0; + gf_msg_debug("resolver", 0, + "next DNS query will return: " + "ip-%s port-%s", + host, service); + } + + return 0; err: - freeaddrinfo (cache->first); - cache->first = cache->next = NULL; - GF_FREE (cache); - *dnscache = NULL; - return -1; + freeaddrinfo(cache->first); + cache->first = cache->next = NULL; + GF_FREE(cache); + *dnscache = NULL; + return -1; } /** @@ -551,16 +576,15 @@ err: * FAILURE: NULL */ struct dnscache * -gf_dnscache_init (time_t ttl) +gf_dnscache_init(time_t ttl) { - struct dnscache *cache = GF_MALLOC (sizeof (*cache), - gf_common_mt_dnscache); - if (cache) { - cache->cache_dict = NULL; - cache->ttl = ttl; - } + struct dnscache *cache = GF_MALLOC(sizeof(*cache), gf_common_mt_dnscache); + if (cache) { + cache->cache_dict = NULL; + cache->ttl = ttl; + } - return cache; + return cache; } /** @@ -570,11 +594,11 @@ gf_dnscache_init (time_t ttl) * FAILURE: NULL */ struct dnscache_entry * -gf_dnscache_entry_init () +gf_dnscache_entry_init() { - struct dnscache_entry *entry = GF_CALLOC (1, sizeof (*entry), - gf_common_mt_dnscache_entry); - return entry; + struct dnscache_entry *entry = GF_CALLOC(1, sizeof(*entry), + gf_common_mt_dnscache_entry); + return entry; } /** @@ -583,11 +607,11 @@ gf_dnscache_entry_init () * @entry: Pointer to deallocate */ void -gf_dnscache_entry_deinit (struct dnscache_entry *entry) +gf_dnscache_entry_deinit(struct dnscache_entry *entry) { - GF_FREE (entry->ip); - GF_FREE (entry->fqdn); - GF_FREE (entry); + GF_FREE(entry->ip); + GF_FREE(entry->fqdn); + GF_FREE(entry); } /** @@ -599,1466 +623,1448 @@ gf_dnscache_entry_deinit (struct dnscache_entry *entry) * failure: NULL */ char * -gf_rev_dns_lookup_cached (const char *ip, struct dnscache *dnscache) +gf_rev_dns_lookup_cached(const char *ip, struct dnscache *dnscache) { - char *fqdn = NULL; - int ret = 0; - dict_t *cache = NULL; - data_t *entrydata = NULL; - struct dnscache_entry *dnsentry = NULL; - gf_boolean_t from_cache = _gf_false; + char *fqdn = NULL; + int ret = 0; + dict_t *cache = NULL; + data_t *entrydata = NULL; + struct dnscache_entry *dnsentry = NULL; + gf_boolean_t from_cache = _gf_false; - if (!dnscache) - goto out; + if (!dnscache) + goto out; + if (!dnscache->cache_dict) { + dnscache->cache_dict = dict_new(); if (!dnscache->cache_dict) { - dnscache->cache_dict = dict_new (); - if (!dnscache->cache_dict) { - goto out; - } - } - cache = dnscache->cache_dict; - - /* Quick cache lookup to see if we already hold it */ - entrydata = dict_get (cache, (char *)ip); - if (entrydata) { - dnsentry = (struct dnscache_entry *)entrydata->data; - /* First check the TTL & timestamp */ - if (time (NULL) - dnsentry->timestamp > dnscache->ttl) { - gf_dnscache_entry_deinit (dnsentry); - entrydata->data = NULL; /* Mark this as 'null' so - * dict_del () doesn't try free - * this after we've already - * freed it. - */ - - dict_del (cache, (char *)ip); /* Remove this entry */ - } else { - /* Cache entry is valid, get the FQDN and return */ - fqdn = dnsentry->fqdn; - from_cache = _gf_true; /* Mark this as from cache */ - goto out; - } + goto out; + } + } + cache = dnscache->cache_dict; + + /* Quick cache lookup to see if we already hold it */ + entrydata = dict_get(cache, (char *)ip); + if (entrydata) { + dnsentry = (struct dnscache_entry *)entrydata->data; + /* First check the TTL & timestamp */ + if (time(NULL) - dnsentry->timestamp > dnscache->ttl) { + gf_dnscache_entry_deinit(dnsentry); + entrydata->data = NULL; /* Mark this as 'null' so + * dict_del () doesn't try free + * this after we've already + * freed it. + */ + + dict_del(cache, (char *)ip); /* Remove this entry */ + } else { + /* Cache entry is valid, get the FQDN and return */ + fqdn = dnsentry->fqdn; + from_cache = _gf_true; /* Mark this as from cache */ + goto out; } + } - /* Get the FQDN */ - ret = gf_get_hostname_from_ip ((char *)ip, &fqdn); - if (ret != 0) - goto out; + /* Get the FQDN */ + ret = gf_get_hostname_from_ip((char *)ip, &fqdn); + if (ret != 0) + goto out; - if (!fqdn) { - gf_log_callingfn ("resolver", GF_LOG_CRITICAL, - "Allocation failed for the host address"); - goto out; - } + if (!fqdn) { + gf_log_callingfn("resolver", GF_LOG_CRITICAL, + "Allocation failed for the host address"); + goto out; + } - from_cache = _gf_false; + from_cache = _gf_false; out: - /* Insert into the cache */ - if (fqdn && !from_cache) { - struct dnscache_entry *entry = gf_dnscache_entry_init (); - - if (!entry) { - goto out; - } - entry->fqdn = fqdn; - if (!ip) { - gf_dnscache_entry_deinit (entry); - goto out; - } - - entry->ip = gf_strdup (ip); - entry->timestamp = time (NULL); - - entrydata = bin_to_data (entry, sizeof (*entry)); - dict_set (cache, (char *)ip, entrydata); + /* Insert into the cache */ + if (fqdn && !from_cache) { + struct dnscache_entry *entry = gf_dnscache_entry_init(); + + if (!entry) { + goto out; } - return fqdn; + entry->fqdn = fqdn; + if (!ip) { + gf_dnscache_entry_deinit(entry); + goto out; + } + + entry->ip = gf_strdup(ip); + entry->timestamp = time(NULL); + + entrydata = bin_to_data(entry, sizeof(*entry)); + dict_set(cache, (char *)ip, entrydata); + } + return fqdn; } struct xldump { - int lineno; + int lineno; }; /* to catch any format discrepencies that may arise in code */ -static int nprintf (struct xldump *dump, const char *fmt, ...) - __attribute__ ((__format__ (__printf__, 2, 3))); static int -nprintf (struct xldump *dump, const char *fmt, ...) +nprintf(struct xldump *dump, const char *fmt, ...) + __attribute__((__format__(__printf__, 2, 3))); +static int +nprintf(struct xldump *dump, const char *fmt, ...) { - va_list ap; - char *msg = NULL; - char header[32]; - int ret = 0; + va_list ap; + char *msg = NULL; + char header[32]; + int ret = 0; - ret = snprintf (header, 32, "%3d:", ++dump->lineno); - if (ret < 0) - goto out; + ret = snprintf(header, 32, "%3d:", ++dump->lineno); + if (ret < 0) + goto out; - va_start (ap, fmt); - ret = vasprintf (&msg, fmt, ap); - va_end (ap); - if (-1 == ret) - goto out; + va_start(ap, fmt); + ret = vasprintf(&msg, fmt, ap); + va_end(ap); + if (-1 == ret) + goto out; - /* NOTE: No ret value from gf_msg_plain, so unable to compute printed - * characters. The return value from nprintf is not used, so for now - * living with it */ - gf_msg_plain (GF_LOG_WARNING, "%s %s", header, msg); + /* NOTE: No ret value from gf_msg_plain, so unable to compute printed + * characters. The return value from nprintf is not used, so for now + * living with it */ + gf_msg_plain(GF_LOG_WARNING, "%s %s", header, msg); out: - FREE (msg); - return 0; + FREE(msg); + return 0; } - static int -xldump_options (dict_t *this, char *key, data_t *value, void *d) +xldump_options(dict_t *this, char *key, data_t *value, void *d) { - nprintf (d, " option %s %s", key, value->data); - return 0; + nprintf(d, " option %s %s", key, value->data); + return 0; } - static void -xldump_subvolumes (xlator_t *this, void *d) +xldump_subvolumes(xlator_t *this, void *d) { - xlator_list_t *subv = NULL; - int len = 0; - char *subvstr = NULL; + xlator_list_t *subv = NULL; + int len = 0; + char *subvstr = NULL; - subv = this->children; - if (!this->children) - return; + subv = this->children; + if (!this->children) + return; - for (subv = this->children; subv; subv = subv->next) - len += (strlen (subv->xlator->name) + 1); + for (subv = this->children; subv; subv = subv->next) + len += (strlen(subv->xlator->name) + 1); - subvstr = GF_MALLOC (len, gf_common_mt_strdup); + subvstr = GF_MALLOC(len, gf_common_mt_strdup); - len = 0; - for (subv = this->children; subv; subv= subv->next) - len += sprintf (subvstr + len, "%s%s", subv->xlator->name, - subv->next ? " " : ""); + len = 0; + for (subv = this->children; subv; subv = subv->next) + len += sprintf(subvstr + len, "%s%s", subv->xlator->name, + subv->next ? " " : ""); - nprintf (d, " subvolumes %s", subvstr); + nprintf(d, " subvolumes %s", subvstr); - GF_FREE (subvstr); + GF_FREE(subvstr); } - static void -xldump (xlator_t *each, void *d) +xldump(xlator_t *each, void *d) { - nprintf (d, "volume %s", each->name); - nprintf (d, " type %s", each->type); - dict_foreach (each->options, xldump_options, d); + nprintf(d, "volume %s", each->name); + nprintf(d, " type %s", each->type); + dict_foreach(each->options, xldump_options, d); - xldump_subvolumes (each, d); + xldump_subvolumes(each, d); - nprintf (d, "end-volume"); - nprintf (d, " "); + nprintf(d, "end-volume"); + nprintf(d, " "); } - void -gf_log_dump_graph (FILE *specfp, glusterfs_graph_t *graph) +gf_log_dump_graph(FILE *specfp, glusterfs_graph_t *graph) { - struct xldump xld = {0, }; + struct xldump xld = { + 0, + }; - gf_msg_plain (GF_LOG_WARNING, "Final graph:"); - gf_msg_plain (GF_LOG_WARNING, - "+---------------------------------------" - "---------------------------------------+"); + gf_msg_plain(GF_LOG_WARNING, "Final graph:"); + gf_msg_plain(GF_LOG_WARNING, + "+---------------------------------------" + "---------------------------------------+"); - xlator_foreach_depth_first (graph->top, xldump, &xld); + xlator_foreach_depth_first(graph->top, xldump, &xld); - gf_msg_plain (GF_LOG_WARNING, - "+---------------------------------------" - "---------------------------------------+"); + gf_msg_plain(GF_LOG_WARNING, + "+---------------------------------------" + "---------------------------------------+"); } static void -gf_dump_config_flags () +gf_dump_config_flags() { - gf_msg_plain_nomem (GF_LOG_ALERT, "configuration details:"); + gf_msg_plain_nomem(GF_LOG_ALERT, "configuration details:"); /* have argp */ #ifdef HAVE_ARGP - gf_msg_plain_nomem (GF_LOG_ALERT, "argp 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "argp 1"); #endif /* ifdef if found backtrace */ #ifdef HAVE_BACKTRACE - gf_msg_plain_nomem (GF_LOG_ALERT, "backtrace 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "backtrace 1"); #endif /* Berkeley-DB version has cursor->get() */ #ifdef HAVE_BDB_CURSOR_GET - gf_msg_plain_nomem (GF_LOG_ALERT, "bdb->cursor->get 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "bdb->cursor->get 1"); #endif /* Define to 1 if you have the <db.h> header file. */ #ifdef HAVE_DB_H - gf_msg_plain_nomem (GF_LOG_ALERT, "db.h 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "db.h 1"); #endif /* Define to 1 if you have the <dlfcn.h> header file. */ #ifdef HAVE_DLFCN_H - gf_msg_plain_nomem (GF_LOG_ALERT, "dlfcn 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "dlfcn 1"); #endif /* define if fdatasync exists */ #ifdef HAVE_FDATASYNC - gf_msg_plain_nomem (GF_LOG_ALERT, "fdatasync 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "fdatasync 1"); #endif /* Define to 1 if you have the `pthread' library (-lpthread). */ #ifdef HAVE_LIBPTHREAD - gf_msg_plain_nomem (GF_LOG_ALERT, "libpthread 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "libpthread 1"); #endif /* define if llistxattr exists */ #ifdef HAVE_LLISTXATTR - gf_msg_plain_nomem (GF_LOG_ALERT, "llistxattr 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "llistxattr 1"); #endif /* define if found setfsuid setfsgid */ #ifdef HAVE_SET_FSID - gf_msg_plain_nomem (GF_LOG_ALERT, "setfsid 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "setfsid 1"); #endif /* define if found spinlock */ #ifdef HAVE_SPINLOCK - gf_msg_plain_nomem (GF_LOG_ALERT, "spinlock 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "spinlock 1"); #endif /* Define to 1 if you have the <sys/epoll.h> header file. */ #ifdef HAVE_SYS_EPOLL_H - gf_msg_plain_nomem (GF_LOG_ALERT, "epoll.h 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "epoll.h 1"); #endif /* Define to 1 if you have the <sys/extattr.h> header file. */ #ifdef HAVE_SYS_EXTATTR_H - gf_msg_plain_nomem (GF_LOG_ALERT, "extattr.h 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "extattr.h 1"); #endif /* Define to 1 if you have the <sys/xattr.h> header file. */ #ifdef HAVE_SYS_XATTR_H - gf_msg_plain_nomem (GF_LOG_ALERT, "xattr.h 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "xattr.h 1"); #endif /* define if found st_atim.tv_nsec */ #ifdef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC - gf_msg_plain_nomem (GF_LOG_ALERT, "st_atim.tv_nsec 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "st_atim.tv_nsec 1"); #endif /* define if found st_atimespec.tv_nsec */ #ifdef HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC - gf_msg_plain_nomem (GF_LOG_ALERT, "st_atimespec.tv_nsec 1"); + gf_msg_plain_nomem(GF_LOG_ALERT, "st_atimespec.tv_nsec 1"); #endif /* Define to the full name and version of this package. */ #ifdef PACKAGE_STRING - { - char *msg = NULL; - int ret = -1; - - ret = gf_asprintf (&msg, "package-string: %s", PACKAGE_STRING); - if (ret >= 0) { - gf_msg_plain_nomem (GF_LOG_ALERT, msg); - GF_FREE (msg); - } + { + char *msg = NULL; + int ret = -1; + + ret = gf_asprintf(&msg, "package-string: %s", PACKAGE_STRING); + if (ret >= 0) { + gf_msg_plain_nomem(GF_LOG_ALERT, msg); + GF_FREE(msg); } + } #endif - return; + return; } /* Obtain a backtrace and print it to the log */ void -gf_print_trace (int32_t signum, glusterfs_ctx_t *ctx) -{ - char msg[1024] = {0,}; - char timestr[64] = {0,}; - call_stack_t *stack = NULL; - - /* Now every gf_log call will just write to a buffer and when the - * buffer becomes full, its written to the log-file. Suppose the process - * crashes and prints the backtrace in the log-file, then the previous - * log information will still be in the buffer itself. So flush the - * contents of the buffer to the log file before printing the backtrace - * which helps in debugging. - */ - gf_log_flush(); - - gf_log_disable_suppression_before_exit (ctx); - - /* Pending frames, (if any), list them in order */ - gf_msg_plain_nomem (GF_LOG_ALERT, "pending frames:"); +gf_print_trace(int32_t signum, glusterfs_ctx_t *ctx) +{ + char msg[1024] = { + 0, + }; + char timestr[64] = { + 0, + }; + call_stack_t *stack = NULL; + + /* Now every gf_log call will just write to a buffer and when the + * buffer becomes full, its written to the log-file. Suppose the process + * crashes and prints the backtrace in the log-file, then the previous + * log information will still be in the buffer itself. So flush the + * contents of the buffer to the log file before printing the backtrace + * which helps in debugging. + */ + gf_log_flush(); + + gf_log_disable_suppression_before_exit(ctx); + + /* Pending frames, (if any), list them in order */ + gf_msg_plain_nomem(GF_LOG_ALERT, "pending frames:"); + { + /* FIXME: traversing stacks outside pool->lock */ + list_for_each_entry(stack, &ctx->pool->all_frames, all_frames) { - /* FIXME: traversing stacks outside pool->lock */ - list_for_each_entry (stack, &ctx->pool->all_frames, - all_frames) { - if (stack->type == GF_OP_TYPE_FOP) - sprintf (msg,"frame : type(%d) op(%s)", - stack->type, - gf_fop_list[stack->op]); - else - sprintf (msg,"frame : type(%d) op(%d)", - stack->type, - stack->op); - - gf_msg_plain_nomem (GF_LOG_ALERT, msg); - } + if (stack->type == GF_OP_TYPE_FOP) + sprintf(msg, "frame : type(%d) op(%s)", stack->type, + gf_fop_list[stack->op]); + else + sprintf(msg, "frame : type(%d) op(%d)", stack->type, stack->op); + + gf_msg_plain_nomem(GF_LOG_ALERT, msg); } + } - sprintf (msg, "patchset: %s", GLUSTERFS_REPOSITORY_REVISION); - gf_msg_plain_nomem (GF_LOG_ALERT, msg); + sprintf(msg, "patchset: %s", GLUSTERFS_REPOSITORY_REVISION); + gf_msg_plain_nomem(GF_LOG_ALERT, msg); - sprintf (msg, "signal received: %d", signum); - gf_msg_plain_nomem (GF_LOG_ALERT, msg); - { - /* Dump the timestamp of the crash too, so the previous logs - can be related */ - gf_time_fmt (timestr, sizeof timestr, time (NULL), - gf_timefmt_FT); - gf_msg_plain_nomem (GF_LOG_ALERT, "time of crash: "); - gf_msg_plain_nomem (GF_LOG_ALERT, timestr); - } + sprintf(msg, "signal received: %d", signum); + gf_msg_plain_nomem(GF_LOG_ALERT, msg); + { + /* Dump the timestamp of the crash too, so the previous logs + can be related */ + gf_time_fmt(timestr, sizeof timestr, time(NULL), gf_timefmt_FT); + gf_msg_plain_nomem(GF_LOG_ALERT, "time of crash: "); + gf_msg_plain_nomem(GF_LOG_ALERT, timestr); + } - gf_dump_config_flags (); - gf_msg_backtrace_nomem (GF_LOG_ALERT, 200); - sprintf (msg, "---------"); - gf_msg_plain_nomem (GF_LOG_ALERT, msg); + gf_dump_config_flags(); + gf_msg_backtrace_nomem(GF_LOG_ALERT, 200); + sprintf(msg, "---------"); + gf_msg_plain_nomem(GF_LOG_ALERT, msg); - /* Send a signal to terminate the process */ - signal (signum, SIG_DFL); - raise (signum); + /* Send a signal to terminate the process */ + signal(signum, SIG_DFL); + raise(signum); } void -trap (void) +trap(void) { - } char * -gf_trim (char *string) +gf_trim(char *string) { - register char *s, *t; + register char *s, *t; - if (string == NULL) { - return NULL; - } + if (string == NULL) { + return NULL; + } - for (s = string; isspace (*s); s++) - ; + for (s = string; isspace(*s); s++) + ; - if (*s == 0) - return s; + if (*s == 0) + return s; - t = s + strlen (s) - 1; - while (t > s && isspace (*t)) - t--; - *++t = '\0'; + t = s + strlen(s) - 1; + while (t > s && isspace(*t)) + t--; + *++t = '\0'; - return s; + return s; } int -gf_strstr (const char *str, const char *delim, const char *match) +gf_strstr(const char *str, const char *delim, const char *match) { - char *tmp = NULL; - char *save_ptr = NULL; - char *tmp_str = NULL; + char *tmp = NULL; + char *save_ptr = NULL; + char *tmp_str = NULL; - int ret = 0; + int ret = 0; - tmp_str = strdup (str); + tmp_str = strdup(str); - if (str == NULL || delim == NULL || match == NULL || tmp_str == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - ret = -1; - goto out; - } + if (str == NULL || delim == NULL || match == NULL || tmp_str == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + ret = -1; + goto out; + } + tmp = strtok_r(tmp_str, delim, &save_ptr); - tmp = strtok_r (tmp_str, delim, &save_ptr); + while (tmp) { + ret = strcmp(tmp, match); - while (tmp) { - ret = strcmp (tmp, match); + if (ret == 0) + break; - if (ret == 0) - break; - - tmp = strtok_r (NULL, delim, &save_ptr); - } + tmp = strtok_r(NULL, delim, &save_ptr); + } out: - free (tmp_str); - - return ret; + free(tmp_str); + return ret; } int -gf_volume_name_validate (const char *volume_name) +gf_volume_name_validate(const char *volume_name) { - const char *vname = NULL; + const char *vname = NULL; - if (volume_name == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - return -1; - } + if (volume_name == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + return -1; + } - if (!isalpha (volume_name[0])) - return 1; + if (!isalpha(volume_name[0])) + return 1; - for (vname = &volume_name[1]; *vname != '\0'; vname++) { - if (!(isalnum (*vname) || *vname == '_')) - return 1; - } + for (vname = &volume_name[1]; *vname != '\0'; vname++) { + if (!(isalnum(*vname) || *vname == '_')) + return 1; + } - return 0; + return 0; } - int -gf_string2time (const char *str, uint32_t *n) -{ - unsigned long value = 0; - char *tail = NULL; - int old_errno = 0; - const char *s = NULL; - - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } - - for (s = str; *s != '\0'; s++) { - if (isspace (*s)) - continue; - if (*s == '-') - return -1; - break; - } - - old_errno = errno; - errno = 0; - value = strtol (str, &tail, 0); - if (str == tail) - errno = EINVAL; - - if (errno == ERANGE || errno == EINVAL) - return -1; - - if (errno == 0) - errno = old_errno; - - if (((tail[0] == '\0') || - ((tail[0] == 's') && (tail[1] == '\0')) || - ((tail[0] == 's') && (tail[1] == 'e') && - (tail[2] == 'c') && (tail[3] == '\0')))) - goto out; - - else if (((tail[0] == 'm') && (tail[1] == '\0')) || - ((tail[0] == 'm') && (tail[1] == 'i') && - (tail[2] == 'n') && (tail[3] == '\0'))) { - value = value * GF_MINUTE_IN_SECONDS; - goto out; - } - - else if (((tail[0] == 'h') && (tail[1] == '\0')) || - ((tail[0] == 'h') && (tail[1] == 'r') && - (tail[2] == '\0'))) { - value = value * GF_HOUR_IN_SECONDS; - goto out; - } +gf_string2time(const char *str, uint32_t *n) +{ + unsigned long value = 0; + char *tail = NULL; + int old_errno = 0; + const char *s = NULL; - else if (((tail[0] == 'd') && (tail[1] == '\0')) || - ((tail[0] == 'd') && (tail[1] == 'a') && - (tail[2] == 'y') && (tail[3] == 's') && - (tail[4] == '\0'))) { - value = value * GF_DAY_IN_SECONDS; - goto out; - } + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } + + for (s = str; *s != '\0'; s++) { + if (isspace(*s)) + continue; + if (*s == '-') + return -1; + break; + } + + old_errno = errno; + errno = 0; + value = strtol(str, &tail, 0); + if (str == tail) + errno = EINVAL; + + if (errno == ERANGE || errno == EINVAL) + return -1; - else if (((tail[0] == 'w') && (tail[1] == '\0')) || - ((tail[0] == 'w') && (tail[1] == 'k') && - (tail[2] == '\0'))) { - value = value * GF_WEEK_IN_SECONDS; - goto out; - } else { - return -1; - } + if (errno == 0) + errno = old_errno; + + if (((tail[0] == '\0') || ((tail[0] == 's') && (tail[1] == '\0')) || + ((tail[0] == 's') && (tail[1] == 'e') && (tail[2] == 'c') && + (tail[3] == '\0')))) + goto out; + + else if (((tail[0] == 'm') && (tail[1] == '\0')) || + ((tail[0] == 'm') && (tail[1] == 'i') && (tail[2] == 'n') && + (tail[3] == '\0'))) { + value = value * GF_MINUTE_IN_SECONDS; + goto out; + } + + else if (((tail[0] == 'h') && (tail[1] == '\0')) || + ((tail[0] == 'h') && (tail[1] == 'r') && (tail[2] == '\0'))) { + value = value * GF_HOUR_IN_SECONDS; + goto out; + } + + else if (((tail[0] == 'd') && (tail[1] == '\0')) || + ((tail[0] == 'd') && (tail[1] == 'a') && (tail[2] == 'y') && + (tail[3] == 's') && (tail[4] == '\0'))) { + value = value * GF_DAY_IN_SECONDS; + goto out; + } + + else if (((tail[0] == 'w') && (tail[1] == '\0')) || + ((tail[0] == 'w') && (tail[1] == 'k') && (tail[2] == '\0'))) { + value = value * GF_WEEK_IN_SECONDS; + goto out; + } else { + return -1; + } out: - *n = value; + *n = value; - return 0; + return 0; } int -gf_string2percent (const char *str, double *n) -{ - double value = 0; - char *tail = NULL; - int old_errno = 0; - const char *s = NULL; - - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } - - for (s = str; *s != '\0'; s++) { - if (isspace (*s)) - continue; - if (*s == '-') - return -1; - break; - } - - old_errno = errno; - errno = 0; - value = strtod (str, &tail); - if (str == tail) - errno = EINVAL; +gf_string2percent(const char *str, double *n) +{ + double value = 0; + char *tail = NULL; + int old_errno = 0; + const char *s = NULL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } + + for (s = str; *s != '\0'; s++) { + if (isspace(*s)) + continue; + if (*s == '-') + return -1; + break; + } + + old_errno = errno; + errno = 0; + value = strtod(str, &tail); + if (str == tail) + errno = EINVAL; + + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (!((tail[0] == '\0') || - ((tail[0] == '%') && (tail[1] == '\0')))) - return -1; + if (!((tail[0] == '\0') || ((tail[0] == '%') && (tail[1] == '\0')))) + return -1; - *n = value; + *n = value; - return 0; + return 0; } - static int -_gf_string2long (const char *str, long *n, int base) +_gf_string2long(const char *str, long *n, int base) { - long value = 0; - char *tail = NULL; - int old_errno = 0; + long value = 0; + char *tail = NULL; + int old_errno = 0; - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } - old_errno = errno; - errno = 0; - value = strtol (str, &tail, base); - if (str == tail) - errno = EINVAL; + old_errno = errno; + errno = 0; + value = strtol(str, &tail, base); + if (str == tail) + errno = EINVAL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (tail[0] != '\0') - return -1; + if (tail[0] != '\0') + return -1; - *n = value; + *n = value; - return 0; + return 0; } static int -_gf_string2ulong (const char *str, unsigned long *n, int base) -{ - unsigned long value = 0; - char *tail = NULL; - int old_errno = 0; - const char *s = NULL; - - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } - - for (s = str; *s != '\0'; s++) { - if (isspace (*s)) - continue; - if (*s == '-') - return -1; - break; - } - - old_errno = errno; - errno = 0; - value = strtoul (str, &tail, base); - if (str == tail) - errno = EINVAL; +_gf_string2ulong(const char *str, unsigned long *n, int base) +{ + unsigned long value = 0; + char *tail = NULL; + int old_errno = 0; + const char *s = NULL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } + + for (s = str; *s != '\0'; s++) { + if (isspace(*s)) + continue; + if (*s == '-') + return -1; + break; + } + + old_errno = errno; + errno = 0; + value = strtoul(str, &tail, base); + if (str == tail) + errno = EINVAL; + + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (tail[0] != '\0') - return -1; + if (tail[0] != '\0') + return -1; - *n = value; + *n = value; - return 0; + return 0; } static int -_gf_string2uint (const char *str, unsigned int *n, int base) -{ - unsigned long value = 0; - char *tail = NULL; - int old_errno = 0; - const char *s = NULL; - - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } - - for (s = str; *s != '\0'; s++) { - if (isspace (*s)) - continue; - if (*s == '-') - return -1; - break; - } - - old_errno = errno; - errno = 0; - value = strtoul (str, &tail, base); - if (str == tail) - errno = EINVAL; +_gf_string2uint(const char *str, unsigned int *n, int base) +{ + unsigned long value = 0; + char *tail = NULL; + int old_errno = 0; + const char *s = NULL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } + + for (s = str; *s != '\0'; s++) { + if (isspace(*s)) + continue; + if (*s == '-') + return -1; + break; + } + + old_errno = errno; + errno = 0; + value = strtoul(str, &tail, base); + if (str == tail) + errno = EINVAL; + + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (tail[0] != '\0') - return -1; + if (tail[0] != '\0') + return -1; - *n = (unsigned int)value; + *n = (unsigned int)value; - return 0; + return 0; } static int -_gf_string2double (const char *str, double *n) +_gf_string2double(const char *str, double *n) { - double value = 0.0; - char *tail = NULL; - int old_errno = 0; + double value = 0.0; + char *tail = NULL; + int old_errno = 0; - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } - old_errno = errno; - errno = 0; - value = strtod (str, &tail); - if (str == tail) - errno = EINVAL; + old_errno = errno; + errno = 0; + value = strtod(str, &tail); + if (str == tail) + errno = EINVAL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (tail[0] != '\0') - return -1; + if (tail[0] != '\0') + return -1; - *n = value; + *n = value; - return 0; + return 0; } static int -_gf_string2longlong (const char *str, long long *n, int base) +_gf_string2longlong(const char *str, long long *n, int base) { - long long value = 0; - char *tail = NULL; - int old_errno = 0; + long long value = 0; + char *tail = NULL; + int old_errno = 0; - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } - old_errno = errno; - errno = 0; - value = strtoll (str, &tail, base); - if (str == tail) - errno = EINVAL; + old_errno = errno; + errno = 0; + value = strtoll(str, &tail, base); + if (str == tail) + errno = EINVAL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (tail[0] != '\0') - return -1; + if (tail[0] != '\0') + return -1; - *n = value; + *n = value; - return 0; + return 0; } static int -_gf_string2ulonglong (const char *str, unsigned long long *n, int base) -{ - unsigned long long value = 0; - char *tail = NULL; - int old_errno = 0; - const char *s = NULL; - - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } - - for (s = str; *s != '\0'; s++) { - if (isspace (*s)) - continue; - if (*s == '-') - return -1; - break; - } - - old_errno = errno; - errno = 0; - value = strtoull (str, &tail, base); - if (str == tail) - errno = EINVAL; +_gf_string2ulonglong(const char *str, unsigned long long *n, int base) +{ + unsigned long long value = 0; + char *tail = NULL; + int old_errno = 0; + const char *s = NULL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } + + for (s = str; *s != '\0'; s++) { + if (isspace(*s)) + continue; + if (*s == '-') + return -1; + break; + } + + old_errno = errno; + errno = 0; + value = strtoull(str, &tail, base); + if (str == tail) + errno = EINVAL; + + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (tail[0] != '\0') - return -1; + if (tail[0] != '\0') + return -1; - *n = value; + *n = value; - return 0; + return 0; } int -gf_string2long (const char *str, long *n) +gf_string2long(const char *str, long *n) { - return _gf_string2long (str, n, 0); + return _gf_string2long(str, n, 0); } int -gf_string2ulong (const char *str, unsigned long *n) +gf_string2ulong(const char *str, unsigned long *n) { - return _gf_string2ulong (str, n, 0); + return _gf_string2ulong(str, n, 0); } int -gf_string2int (const char *str, int *n) +gf_string2int(const char *str, int *n) { - long l = 0; - int ret = 0; + long l = 0; + int ret = 0; - ret = _gf_string2long (str, &l, 0); + ret = _gf_string2long(str, &l, 0); - *n = l; - return ret; + *n = l; + return ret; } int -gf_string2uint (const char *str, unsigned int *n) +gf_string2uint(const char *str, unsigned int *n) { - return _gf_string2uint (str, n, 0); + return _gf_string2uint(str, n, 0); } int -gf_string2double (const char *str, double *n) +gf_string2double(const char *str, double *n) { - return _gf_string2double (str, n); + return _gf_string2double(str, n); } int -gf_string2longlong (const char *str, long long *n) +gf_string2longlong(const char *str, long long *n) { - return _gf_string2longlong (str, n, 0); + return _gf_string2longlong(str, n, 0); } int -gf_string2ulonglong (const char *str, unsigned long long *n) +gf_string2ulonglong(const char *str, unsigned long long *n) { - return _gf_string2ulonglong (str, n, 0); + return _gf_string2ulonglong(str, n, 0); } int -gf_string2int8 (const char *str, int8_t *n) +gf_string2int8(const char *str, int8_t *n) { - long l = 0L; - int rv = 0; + long l = 0L; + int rv = 0; - rv = _gf_string2long (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2long(str, &l, 0); + if (rv != 0) + return rv; - if ((l >= INT8_MIN) && (l <= INT8_MAX)) { - *n = (int8_t) l; - return 0; - } + if ((l >= INT8_MIN) && (l <= INT8_MAX)) { + *n = (int8_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2int16 (const char *str, int16_t *n) +gf_string2int16(const char *str, int16_t *n) { - long l = 0L; - int rv = 0; + long l = 0L; + int rv = 0; - rv = _gf_string2long (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2long(str, &l, 0); + if (rv != 0) + return rv; - if ((l >= INT16_MIN) && (l <= INT16_MAX)) { - *n = (int16_t) l; - return 0; - } + if ((l >= INT16_MIN) && (l <= INT16_MAX)) { + *n = (int16_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2int32 (const char *str, int32_t *n) +gf_string2int32(const char *str, int32_t *n) { - long l = 0L; - int rv = 0; + long l = 0L; + int rv = 0; - rv = _gf_string2long (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2long(str, &l, 0); + if (rv != 0) + return rv; - if ((l >= INT32_MIN) && (l <= INT32_MAX)) { - *n = (int32_t) l; - return 0; - } + if ((l >= INT32_MIN) && (l <= INT32_MAX)) { + *n = (int32_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2int64 (const char *str, int64_t *n) +gf_string2int64(const char *str, int64_t *n) { - long long l = 0LL; - int rv = 0; + long long l = 0LL; + int rv = 0; - rv = _gf_string2longlong (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2longlong(str, &l, 0); + if (rv != 0) + return rv; - *n = (int64_t) l; - return 0; + *n = (int64_t)l; + return 0; } int -gf_string2uint8 (const char *str, uint8_t *n) +gf_string2uint8(const char *str, uint8_t *n) { - unsigned long l = 0L; - int rv = 0; + unsigned long l = 0L; + int rv = 0; - rv = _gf_string2ulong (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2ulong(str, &l, 0); + if (rv != 0) + return rv; - if (l <= UINT8_MAX) { - *n = (uint8_t) l; - return 0; - } + if (l <= UINT8_MAX) { + *n = (uint8_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2uint16 (const char *str, uint16_t *n) +gf_string2uint16(const char *str, uint16_t *n) { - unsigned long l = 0L; - int rv = 0; + unsigned long l = 0L; + int rv = 0; - rv = _gf_string2ulong (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2ulong(str, &l, 0); + if (rv != 0) + return rv; - if (l <= UINT16_MAX) { - *n = (uint16_t) l; - return 0; - } + if (l <= UINT16_MAX) { + *n = (uint16_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2uint32 (const char *str, uint32_t *n) +gf_string2uint32(const char *str, uint32_t *n) { - unsigned long l = 0L; - int rv = 0; + unsigned long l = 0L; + int rv = 0; - rv = _gf_string2ulong (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2ulong(str, &l, 0); + if (rv != 0) + return rv; - if (l <= UINT32_MAX) { - *n = (uint32_t) l; - return 0; - } + if (l <= UINT32_MAX) { + *n = (uint32_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2uint64 (const char *str, uint64_t *n) +gf_string2uint64(const char *str, uint64_t *n) { - unsigned long long l = 0ULL; - int rv = 0; + unsigned long long l = 0ULL; + int rv = 0; - rv = _gf_string2ulonglong (str, &l, 0); - if (rv != 0) - return rv; + rv = _gf_string2ulonglong(str, &l, 0); + if (rv != 0) + return rv; - if (l <= UINT64_MAX) { - *n = (uint64_t) l; - return 0; - } + if (l <= UINT64_MAX) { + *n = (uint64_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2ulong_base10 (const char *str, unsigned long *n) +gf_string2ulong_base10(const char *str, unsigned long *n) { - return _gf_string2ulong (str, n, 10); + return _gf_string2ulong(str, n, 10); } int -gf_string2uint_base10 (const char *str, unsigned int *n) +gf_string2uint_base10(const char *str, unsigned int *n) { - return _gf_string2uint (str, n, 10); + return _gf_string2uint(str, n, 10); } int -gf_string2uint8_base10 (const char *str, uint8_t *n) +gf_string2uint8_base10(const char *str, uint8_t *n) { - unsigned long l = 0L; - int rv = 0; + unsigned long l = 0L; + int rv = 0; - rv = _gf_string2ulong (str, &l, 10); - if (rv != 0) - return rv; + rv = _gf_string2ulong(str, &l, 10); + if (rv != 0) + return rv; - if (l <= UINT8_MAX) { - *n = (uint8_t) l; - return 0; - } + if (l <= UINT8_MAX) { + *n = (uint8_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2uint16_base10 (const char *str, uint16_t *n) +gf_string2uint16_base10(const char *str, uint16_t *n) { - unsigned long l = 0L; - int rv = 0; + unsigned long l = 0L; + int rv = 0; - rv = _gf_string2ulong (str, &l, 10); - if (rv != 0) - return rv; + rv = _gf_string2ulong(str, &l, 10); + if (rv != 0) + return rv; - if (l <= UINT16_MAX) { - *n = (uint16_t) l; - return 0; - } + if (l <= UINT16_MAX) { + *n = (uint16_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2uint32_base10 (const char *str, uint32_t *n) +gf_string2uint32_base10(const char *str, uint32_t *n) { - unsigned long l = 0L; - int rv = 0; + unsigned long l = 0L; + int rv = 0; - rv = _gf_string2ulong (str, &l, 10); - if (rv != 0) - return rv; + rv = _gf_string2ulong(str, &l, 10); + if (rv != 0) + return rv; - if (l <= UINT32_MAX) { - *n = (uint32_t) l; - return 0; - } + if (l <= UINT32_MAX) { + *n = (uint32_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } int -gf_string2uint64_base10 (const char *str, uint64_t *n) +gf_string2uint64_base10(const char *str, uint64_t *n) { - unsigned long long l = 0ULL; - int rv = 0; + unsigned long long l = 0ULL; + int rv = 0; - rv = _gf_string2ulonglong (str, &l, 10); - if (rv != 0) - return rv; + rv = _gf_string2ulonglong(str, &l, 10); + if (rv != 0) + return rv; - if (l <= UINT64_MAX) { - *n = (uint64_t) l; - return 0; - } + if (l <= UINT64_MAX) { + *n = (uint64_t)l; + return 0; + } - errno = ERANGE; - return -1; + errno = ERANGE; + return -1; } char * -gf_uint64_2human_readable (uint64_t n) -{ - int ret = 0; - char *str = NULL; - - if (n >= GF_UNIT_PB) { - ret = gf_asprintf (&str, "%.1lfPB", ((double) n)/GF_UNIT_PB); - if (ret < 0) - goto err; - } else if (n >= GF_UNIT_TB) { - ret = gf_asprintf (&str, "%.1lfTB", ((double) n)/GF_UNIT_TB); - if (ret < 0) - goto err; - } else if (n >= GF_UNIT_GB) { - ret = gf_asprintf (&str, "%.1lfGB", ((double) n)/GF_UNIT_GB); - if (ret < 0) - goto err; - } else if (n >= GF_UNIT_MB) { - ret = gf_asprintf (&str, "%.1lfMB", ((double) n)/GF_UNIT_MB); - if (ret < 0) - goto err; - } else if (n >= GF_UNIT_KB) { - ret = gf_asprintf (&str, "%.1lfKB", ((double) n)/GF_UNIT_KB); - if (ret < 0) - goto err; - } else { - ret = gf_asprintf (&str, "%luBytes", n); - if (ret < 0) - goto err; - } - return str; +gf_uint64_2human_readable(uint64_t n) +{ + int ret = 0; + char *str = NULL; + + if (n >= GF_UNIT_PB) { + ret = gf_asprintf(&str, "%.1lfPB", ((double)n) / GF_UNIT_PB); + if (ret < 0) + goto err; + } else if (n >= GF_UNIT_TB) { + ret = gf_asprintf(&str, "%.1lfTB", ((double)n) / GF_UNIT_TB); + if (ret < 0) + goto err; + } else if (n >= GF_UNIT_GB) { + ret = gf_asprintf(&str, "%.1lfGB", ((double)n) / GF_UNIT_GB); + if (ret < 0) + goto err; + } else if (n >= GF_UNIT_MB) { + ret = gf_asprintf(&str, "%.1lfMB", ((double)n) / GF_UNIT_MB); + if (ret < 0) + goto err; + } else if (n >= GF_UNIT_KB) { + ret = gf_asprintf(&str, "%.1lfKB", ((double)n) / GF_UNIT_KB); + if (ret < 0) + goto err; + } else { + ret = gf_asprintf(&str, "%luBytes", n); + if (ret < 0) + goto err; + } + return str; err: - return NULL; + return NULL; } int -gf_string2bytesize_range (const char *str, uint64_t *n, uint64_t umax) -{ - double value = 0.0; - int64_t int_value = 0; - uint64_t unit = 0; - int64_t max = 0; - char *tail = NULL; - int old_errno = 0; - const char *s = NULL; - gf_boolean_t fraction = _gf_false; - - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } +gf_string2bytesize_range(const char *str, uint64_t *n, uint64_t umax) +{ + double value = 0.0; + int64_t int_value = 0; + uint64_t unit = 0; + int64_t max = 0; + char *tail = NULL; + int old_errno = 0; + const char *s = NULL; + gf_boolean_t fraction = _gf_false; + + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } - max = umax & 0x7fffffffffffffffLL; + max = umax & 0x7fffffffffffffffLL; - for (s = str; *s != '\0'; s++) { - if (isspace (*s)) - continue; - if (*s == '-') - return -1; - break; - } + for (s = str; *s != '\0'; s++) { + if (isspace(*s)) + continue; + if (*s == '-') + return -1; + break; + } - if (strrchr (str, '.')) - fraction = _gf_true; + if (strrchr(str, '.')) + fraction = _gf_true; - old_errno = errno; - errno = 0; - if (fraction) - value = strtod (str, &tail); - else - int_value = strtoll (str, &tail, 10); + old_errno = errno; + errno = 0; + if (fraction) + value = strtod(str, &tail); + else + int_value = strtoll(str, &tail, 10); - if (str == tail) - errno = EINVAL; + if (str == tail) + errno = EINVAL; - if (errno == ERANGE || errno == EINVAL) - return -1; + if (errno == ERANGE || errno == EINVAL) + return -1; - if (errno == 0) - errno = old_errno; + if (errno == 0) + errno = old_errno; - if (tail[0] != '\0') - { - if (strcasecmp (tail, GF_UNIT_KB_STRING) == 0) - unit = GF_UNIT_KB; - else if (strcasecmp (tail, GF_UNIT_MB_STRING) == 0) - unit = GF_UNIT_MB; - else if (strcasecmp (tail, GF_UNIT_GB_STRING) == 0) - unit = GF_UNIT_GB; - else if (strcasecmp (tail, GF_UNIT_TB_STRING) == 0) - unit = GF_UNIT_TB; - else if (strcasecmp (tail, GF_UNIT_PB_STRING) == 0) - unit = GF_UNIT_PB; - else if (strcasecmp (tail, GF_UNIT_B_STRING) != 0) - return -1; - - if (unit > 0) { - if (fraction) - value *= unit; - else - int_value *= unit; - } + if (tail[0] != '\0') { + if (strcasecmp(tail, GF_UNIT_KB_STRING) == 0) + unit = GF_UNIT_KB; + else if (strcasecmp(tail, GF_UNIT_MB_STRING) == 0) + unit = GF_UNIT_MB; + else if (strcasecmp(tail, GF_UNIT_GB_STRING) == 0) + unit = GF_UNIT_GB; + else if (strcasecmp(tail, GF_UNIT_TB_STRING) == 0) + unit = GF_UNIT_TB; + else if (strcasecmp(tail, GF_UNIT_PB_STRING) == 0) + unit = GF_UNIT_PB; + else if (strcasecmp(tail, GF_UNIT_B_STRING) != 0) + return -1; + + if (unit > 0) { + if (fraction) + value *= unit; + else + int_value *= unit; } + } - if (fraction) { - if ((max - value) < 0) { - errno = ERANGE; - return -1; - } - *n = (uint64_t) value; - } else { - if ((max - int_value) < 0) { - errno = ERANGE; - return -1; - } - *n = int_value; + if (fraction) { + if ((max - value) < 0) { + errno = ERANGE; + return -1; + } + *n = (uint64_t)value; + } else { + if ((max - int_value) < 0) { + errno = ERANGE; + return -1; } + *n = int_value; + } - return 0; + return 0; } int -gf_string2bytesize_size (const char *str, size_t *n) +gf_string2bytesize_size(const char *str, size_t *n) { - uint64_t u64; - size_t max = (size_t) - 1; - int val = gf_string2bytesize_range (str, &u64, max); - *n = (size_t) u64; - return val; + uint64_t u64; + size_t max = (size_t)-1; + int val = gf_string2bytesize_range(str, &u64, max); + *n = (size_t)u64; + return val; } int -gf_string2bytesize (const char *str, uint64_t *n) +gf_string2bytesize(const char *str, uint64_t *n) { - return gf_string2bytesize_range(str, n, UINT64_MAX); + return gf_string2bytesize_range(str, n, UINT64_MAX); } int -gf_string2bytesize_uint64 (const char *str, uint64_t *n) +gf_string2bytesize_uint64(const char *str, uint64_t *n) { - return gf_string2bytesize_range(str, n, UINT64_MAX); + return gf_string2bytesize_range(str, n, UINT64_MAX); } int -gf_string2bytesize_int64 (const char *str, int64_t *n) +gf_string2bytesize_int64(const char *str, int64_t *n) { - uint64_t u64 = 0; - int ret = 0; + uint64_t u64 = 0; + int ret = 0; - ret = gf_string2bytesize_range(str, &u64, INT64_MAX); - *n = (int64_t) u64; - return ret; + ret = gf_string2bytesize_range(str, &u64, INT64_MAX); + *n = (int64_t)u64; + return ret; } int -gf_string2percent_or_bytesize (const char *str, double *n, - gf_boolean_t *is_percent) -{ - double value = 0ULL; - char *tail = NULL; - int old_errno = 0; - const char *s = NULL; - - if (str == NULL || n == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - errno = EINVAL; - return -1; - } - - for (s = str; *s != '\0'; s++) { - if (isspace (*s)) - continue; - if (*s == '-') - return -1; - break; - } +gf_string2percent_or_bytesize(const char *str, double *n, + gf_boolean_t *is_percent) +{ + double value = 0ULL; + char *tail = NULL; + int old_errno = 0; + const char *s = NULL; + + if (str == NULL || n == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + errno = EINVAL; + return -1; + } + + for (s = str; *s != '\0'; s++) { + if (isspace(*s)) + continue; + if (*s == '-') + return -1; + break; + } + + old_errno = errno; + errno = 0; + value = strtod(str, &tail); + if (str == tail) + errno = EINVAL; + + if (errno == ERANGE || errno == EINVAL) + return -1; - old_errno = errno; - errno = 0; - value = strtod (str, &tail); - if (str == tail) - errno = EINVAL; - - if (errno == ERANGE || errno == EINVAL) - return -1; - - if (errno == 0) - errno = old_errno; - - /*Maximum accepted value for 64 bit OS will be (2^14 -1)PB*/ - if (tail[0] != '\0') { - if (strcasecmp (tail, GF_UNIT_KB_STRING) == 0) - value *= GF_UNIT_KB; - else if (strcasecmp (tail, GF_UNIT_MB_STRING) == 0) - value *= GF_UNIT_MB; - else if (strcasecmp (tail, GF_UNIT_GB_STRING) == 0) - value *= GF_UNIT_GB; - else if (strcasecmp (tail, GF_UNIT_TB_STRING) == 0) - value *= GF_UNIT_TB; - else if (strcasecmp (tail, GF_UNIT_PB_STRING) == 0) - value *= GF_UNIT_PB; - else if (strcasecmp (tail, GF_UNIT_PERCENT_STRING) == 0) - *is_percent = _gf_true; - else - return -1; - } + if (errno == 0) + errno = old_errno; + + /*Maximum accepted value for 64 bit OS will be (2^14 -1)PB*/ + if (tail[0] != '\0') { + if (strcasecmp(tail, GF_UNIT_KB_STRING) == 0) + value *= GF_UNIT_KB; + else if (strcasecmp(tail, GF_UNIT_MB_STRING) == 0) + value *= GF_UNIT_MB; + else if (strcasecmp(tail, GF_UNIT_GB_STRING) == 0) + value *= GF_UNIT_GB; + else if (strcasecmp(tail, GF_UNIT_TB_STRING) == 0) + value *= GF_UNIT_TB; + else if (strcasecmp(tail, GF_UNIT_PB_STRING) == 0) + value *= GF_UNIT_PB; + else if (strcasecmp(tail, GF_UNIT_PERCENT_STRING) == 0) + *is_percent = _gf_true; + else + return -1; + } - /* Error out if we cannot store the value in uint64 */ - if ((UINT64_MAX - value) < 0) { - errno = ERANGE; - return -1; - } + /* Error out if we cannot store the value in uint64 */ + if ((UINT64_MAX - value) < 0) { + errno = ERANGE; + return -1; + } - *n = value; + *n = value; - return 0; + return 0; } int64_t -gf_str_to_long_long (const char *number) -{ - int64_t unit = 1; - int64_t ret = 0; - char *endptr = NULL ; - if (!number) - return 0; - - ret = strtoll (number, &endptr, 0); - - if (endptr) { - switch (*endptr) { - case 'G': - case 'g': - if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b')) - unit = 1024 * 1024 * 1024; - break; - case 'M': - case 'm': - if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b')) - unit = 1024 * 1024; - break; - case 'K': - case 'k': - if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b')) - unit = 1024; - break; - case '%': - unit = 1; - break; - default: - unit = 1; - break; - } +gf_str_to_long_long(const char *number) +{ + int64_t unit = 1; + int64_t ret = 0; + char *endptr = NULL; + if (!number) + return 0; + + ret = strtoll(number, &endptr, 0); + + if (endptr) { + switch (*endptr) { + case 'G': + case 'g': + if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b')) + unit = 1024 * 1024 * 1024; + break; + case 'M': + case 'm': + if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b')) + unit = 1024 * 1024; + break; + case 'K': + case 'k': + if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b')) + unit = 1024; + break; + case '%': + unit = 1; + break; + default: + unit = 1; + break; } - return ret * unit; + } + return ret * unit; } int -gf_string2boolean (const char *str, gf_boolean_t *b) +gf_string2boolean(const char *str, gf_boolean_t *b) { - if (str == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - return -1; - } + if (str == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + return -1; + } - if ((strcasecmp (str, "1") == 0) || - (strcasecmp (str, "on") == 0) || - (strcasecmp (str, "yes") == 0) || - (strcasecmp (str, "true") == 0) || - (strcasecmp (str, "enable") == 0)) { - *b = _gf_true; - return 0; - } + if ((strcasecmp(str, "1") == 0) || (strcasecmp(str, "on") == 0) || + (strcasecmp(str, "yes") == 0) || (strcasecmp(str, "true") == 0) || + (strcasecmp(str, "enable") == 0)) { + *b = _gf_true; + return 0; + } - if ((strcasecmp (str, "0") == 0) || - (strcasecmp (str, "off") == 0) || - (strcasecmp (str, "no") == 0) || - (strcasecmp (str, "false") == 0) || - (strcasecmp (str, "disable") == 0)) { - *b = _gf_false; - return 0; - } + if ((strcasecmp(str, "0") == 0) || (strcasecmp(str, "off") == 0) || + (strcasecmp(str, "no") == 0) || (strcasecmp(str, "false") == 0) || + (strcasecmp(str, "disable") == 0)) { + *b = _gf_false; + return 0; + } - return -1; + return -1; } - int -gf_lockfd (int fd) +gf_lockfd(int fd) { - struct gf_flock fl; + struct gf_flock fl; - fl.l_type = F_WRLCK; - fl.l_whence = SEEK_SET; - fl.l_start = 0; - fl.l_len = 0; + fl.l_type = F_WRLCK; + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 0; - return fcntl (fd, F_SETLK, &fl); + return fcntl(fd, F_SETLK, &fl); } - int -gf_unlockfd (int fd) +gf_unlockfd(int fd) { - struct gf_flock fl; + struct gf_flock fl; - fl.l_type = F_UNLCK; - fl.l_whence = SEEK_SET; - fl.l_start = 0; - fl.l_len = 0; + fl.l_type = F_UNLCK; + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 0; - return fcntl (fd, F_SETLK, &fl); + return fcntl(fd, F_SETLK, &fl); } static void -compute_checksum (char *buf, size_t size, uint32_t *checksum) +compute_checksum(char *buf, size_t size, uint32_t *checksum) { - int ret = -1; - char *checksum_buf = NULL; + int ret = -1; + char *checksum_buf = NULL; - checksum_buf = (char *)(checksum); + checksum_buf = (char *)(checksum); - if (!(*checksum)) { - checksum_buf [0] = 0xba; - checksum_buf [1] = 0xbe; - checksum_buf [2] = 0xb0; - checksum_buf [3] = 0x0b; - } + if (!(*checksum)) { + checksum_buf[0] = 0xba; + checksum_buf[1] = 0xbe; + checksum_buf[2] = 0xb0; + checksum_buf[3] = 0x0b; + } - for (ret = 0; ret < (size - 4); ret += 4) { - checksum_buf[0] ^= (buf[ret]); - checksum_buf[1] ^= (buf[ret + 1] << 1) ; - checksum_buf[2] ^= (buf[ret + 2] << 2); - checksum_buf[3] ^= (buf[ret + 3] << 3); - } + for (ret = 0; ret < (size - 4); ret += 4) { + checksum_buf[0] ^= (buf[ret]); + checksum_buf[1] ^= (buf[ret + 1] << 1); + checksum_buf[2] ^= (buf[ret + 2] << 2); + checksum_buf[3] ^= (buf[ret + 3] << 3); + } - for (ret = 0; ret <= (size % 4); ret++) { - checksum_buf[ret] ^= (buf[(size - 4) + ret] << ret); - } + for (ret = 0; ret <= (size % 4); ret++) { + checksum_buf[ret] ^= (buf[(size - 4) + ret] << ret); + } - return; + return; } #define GF_CHECKSUM_BUF_SIZE 1024 int -get_checksum_for_file (int fd, uint32_t *checksum) +get_checksum_for_file(int fd, uint32_t *checksum) { - int ret = -1; - char buf[GF_CHECKSUM_BUF_SIZE] = {0,}; + int ret = -1; + char buf[GF_CHECKSUM_BUF_SIZE] = { + 0, + }; - /* goto first place */ - sys_lseek (fd, 0L, SEEK_SET); - do { - ret = sys_read (fd, &buf, GF_CHECKSUM_BUF_SIZE); - if (ret > 0) - compute_checksum (buf, GF_CHECKSUM_BUF_SIZE, - checksum); - } while (ret > 0); + /* goto first place */ + sys_lseek(fd, 0L, SEEK_SET); + do { + ret = sys_read(fd, &buf, GF_CHECKSUM_BUF_SIZE); + if (ret > 0) + compute_checksum(buf, GF_CHECKSUM_BUF_SIZE, checksum); + } while (ret > 0); - /* set it back */ - sys_lseek (fd, 0L, SEEK_SET); + /* set it back */ + sys_lseek(fd, 0L, SEEK_SET); - return ret; + return ret; } - int -get_checksum_for_path (char *path, uint32_t *checksum) +get_checksum_for_path(char *path, uint32_t *checksum) { - int ret = -1; - int fd = -1; + int ret = -1; + int fd = -1; - GF_ASSERT (path); - GF_ASSERT (checksum); + GF_ASSERT(path); + GF_ASSERT(checksum); - fd = open (path, O_RDWR); + fd = open(path, O_RDWR); - if (fd == -1) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_ERROR, - "Unable to open %s", path); - goto out; - } + if (fd == -1) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_ERROR, + "Unable to open %s", path); + goto out; + } - ret = get_checksum_for_file (fd, checksum); + ret = get_checksum_for_file(fd, checksum); out: - if (fd != -1) - sys_close (fd); + if (fd != -1) + sys_close(fd); - return ret; + return ret; } /** @@ -2071,26 +2077,25 @@ out: * errors : Errors returned by the stat () call */ int -get_file_mtime (const char *path, time_t *stamp) +get_file_mtime(const char *path, time_t *stamp) { - struct stat f_stat = {0}; - int ret = -EINVAL; + struct stat f_stat = {0}; + int ret = -EINVAL; - GF_VALIDATE_OR_GOTO (THIS->name, path, out); - GF_VALIDATE_OR_GOTO (THIS->name, stamp, out); + GF_VALIDATE_OR_GOTO(THIS->name, path, out); + GF_VALIDATE_OR_GOTO(THIS->name, stamp, out); - ret = sys_stat (path, &f_stat); - if (ret < 0) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - LG_MSG_FILE_STAT_FAILED, "failed to stat %s", - path); - goto out; - } + ret = sys_stat(path, &f_stat); + if (ret < 0) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED, + "failed to stat %s", path); + goto out; + } - /* Set the mtime */ - *stamp = f_stat.st_mtime; + /* Set the mtime */ + *stamp = f_stat.st_mtime; out: - return ret; + return ret; } /** @@ -2106,117 +2111,117 @@ out: * failure: -EINVAL for bad args, retval of inet_pton otherwise */ gf_boolean_t -gf_is_ip_in_net (const char *network, const char *ip_str) -{ - unsigned long ip_buf = 0; - unsigned long net_ip_buf = 0; - unsigned long subnet_mask = 0; - int ret = -EINVAL; - char *slash = NULL; - char *net_ip = NULL; - char *subnet = NULL; - char *net_str = NULL; - int family = AF_INET; - gf_boolean_t result = _gf_false; - - GF_ASSERT (network); - GF_ASSERT (ip_str); - - if (strchr (network, ':')) - family = AF_INET6; - else if (strchr (network, '.')) - family = AF_INET; - else { - family = -1; - goto out; - } - - net_str = strdupa (network); - slash = strchr (net_str, '/'); - if (!slash) - goto out; - *slash = '\0'; - - subnet = slash + 1; - net_ip = net_str; - - /* Convert IP address to a long */ - ret = inet_pton (family, ip_str, &ip_buf); - if (ret < 0) - gf_msg ("common-utils", GF_LOG_ERROR, errno, - LG_MSG_INET_PTON_FAILED, "inet_pton() failed"); - - /* Convert network IP address to a long */ - ret = inet_pton (family, net_ip, &net_ip_buf); - if (ret < 0) { - gf_msg ("common-utils", GF_LOG_ERROR, errno, - LG_MSG_INET_PTON_FAILED, "inet_pton() failed"); - goto out; - } - - /* Converts /x into a mask */ - subnet_mask = (1 << atoi (subnet)) - 1; - - result = ((ip_buf & subnet_mask) == (net_ip_buf & subnet_mask)); +gf_is_ip_in_net(const char *network, const char *ip_str) +{ + unsigned long ip_buf = 0; + unsigned long net_ip_buf = 0; + unsigned long subnet_mask = 0; + int ret = -EINVAL; + char *slash = NULL; + char *net_ip = NULL; + char *subnet = NULL; + char *net_str = NULL; + int family = AF_INET; + gf_boolean_t result = _gf_false; + + GF_ASSERT(network); + GF_ASSERT(ip_str); + + if (strchr(network, ':')) + family = AF_INET6; + else if (strchr(network, '.')) + family = AF_INET; + else { + family = -1; + goto out; + } + + net_str = strdupa(network); + slash = strchr(net_str, '/'); + if (!slash) + goto out; + *slash = '\0'; + + subnet = slash + 1; + net_ip = net_str; + + /* Convert IP address to a long */ + ret = inet_pton(family, ip_str, &ip_buf); + if (ret < 0) + gf_msg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED, + "inet_pton() failed"); + + /* Convert network IP address to a long */ + ret = inet_pton(family, net_ip, &net_ip_buf); + if (ret < 0) { + gf_msg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED, + "inet_pton() failed"); + goto out; + } + + /* Converts /x into a mask */ + subnet_mask = (1 << atoi(subnet)) - 1; + + result = ((ip_buf & subnet_mask) == (net_ip_buf & subnet_mask)); out: - return result; + return result; } char * -strtail (char *str, const char *pattern) +strtail(char *str, const char *pattern) { - int i = 0; + int i = 0; - for (i = 0; str[i] == pattern[i] && str[i]; i++); + for (i = 0; str[i] == pattern[i] && str[i]; i++) + ; - if (pattern[i] == '\0') - return str + i; + if (pattern[i] == '\0') + return str + i; - return NULL; + return NULL; } void -skipwhite (char **s) +skipwhite(char **s) { - while (isspace (**s)) - (*s)++; + while (isspace(**s)) + (*s)++; } void -gf_strTrim (char **s) +gf_strTrim(char **s) { - char *end = NULL; + char *end = NULL; - end = *s + strlen(*s) - 1; - while (end > *s && isspace ((unsigned char)*end)) - end--; + end = *s + strlen(*s) - 1; + while (end > *s && isspace((unsigned char)*end)) + end--; - *(end+1) = '\0'; + *(end + 1) = '\0'; - while (isspace (**s)) - (*s)++; + while (isspace(**s)) + (*s)++; - return; + return; } char * -nwstrtail (char *str, char *pattern) +nwstrtail(char *str, char *pattern) { - for (;;) { - skipwhite (&str); - skipwhite (&pattern); + for (;;) { + skipwhite(&str); + skipwhite(&pattern); - if (*str != *pattern || !*str) - break; + if (*str != *pattern || !*str) + break; - str++; - pattern++; - } + str++; + pattern++; + } - return *pattern ? NULL : str; + return *pattern ? NULL : str; } - /** * token_iter_init -- initialize tokenization * @@ -2231,12 +2236,12 @@ nwstrtail (char *str, char *pattern) * next_token(). */ char * -token_iter_init (char *str, char sep, token_iter_t *tit) +token_iter_init(char *str, char sep, token_iter_t *tit) { - tit->end = str + strlen (str); - tit->sep = sep; + tit->end = str + strlen(str); + tit->sep = sep; - return str; + return str; } /** @@ -2256,30 +2261,32 @@ token_iter_init (char *str, char sep, token_iter_t *tit) * apart from dropped tokens (see drop_token()). */ gf_boolean_t -next_token (char **tokenp, token_iter_t *tit) -{ - char *cursor = NULL; - gf_boolean_t is_last = _gf_false; - - for (cursor = *tokenp; *cursor; cursor++); - if (cursor < tit->end) { - /* - * We detect that in between current token and end a zero - * marker has already been inserted. This means that the - * token has already been returned. We restore the - * separator and move ahead. - */ - *cursor = tit->sep; - *tokenp = cursor + 1; - } +next_token(char **tokenp, token_iter_t *tit) +{ + char *cursor = NULL; + gf_boolean_t is_last = _gf_false; - for (cursor = *tokenp; *cursor && *cursor != tit->sep; cursor++); - /* If the cursor ended up on a zero byte, then it's the last token. */ - is_last = !*cursor; - /* Zero-terminate the token. */ - *cursor = 0; + for (cursor = *tokenp; *cursor; cursor++) + ; + if (cursor < tit->end) { + /* + * We detect that in between current token and end a zero + * marker has already been inserted. This means that the + * token has already been returned. We restore the + * separator and move ahead. + */ + *cursor = tit->sep; + *tokenp = cursor + 1; + } - return is_last; + for (cursor = *tokenp; *cursor && *cursor != tit->sep; cursor++) + ; + /* If the cursor ended up on a zero byte, then it's the last token. */ + is_last = !*cursor; + /* Zero-terminate the token. */ + *cursor = 0; + + return is_last; } /* @@ -2330,142 +2337,143 @@ next_token (char **tokenp, token_iter_t *tit) * } */ void -drop_token (char *token, token_iter_t *tit) -{ - char *cursor = NULL; - - for (cursor = token; *cursor; cursor++); - if (cursor < tit->end) { - /* - * We detect a zero inserted by next_token(). - * Step the cursor and copy what comes after - * to token. - */ - for (cursor++; cursor < tit->end; *token++ = *cursor++); - } +drop_token(char *token, token_iter_t *tit) +{ + char *cursor = NULL; + for (cursor = token; *cursor; cursor++) + ; + if (cursor < tit->end) { /* - * Zero out the remainder of the buffer. - * It would be enough to insert just a single zero, - * but we continue 'till the end to have cleaner - * memory content. + * We detect a zero inserted by next_token(). + * Step the cursor and copy what comes after + * to token. */ - for (cursor = token; cursor < tit->end; *cursor++ = 0); + for (cursor++; cursor < tit->end; *token++ = *cursor++) + ; + } - /* Adjust the end to point to the new terminating zero. */ - tit->end = token; + /* + * Zero out the remainder of the buffer. + * It would be enough to insert just a single zero, + * but we continue 'till the end to have cleaner + * memory content. + */ + for (cursor = token; cursor < tit->end; *cursor++ = 0) + ; + + /* Adjust the end to point to the new terminating zero. */ + tit->end = token; } /* Syntax formed according to RFC 1912 (RFC 1123 & 952 are more restrictive) * <hname> ::= <gen-name>*["."<gen-name>] * <gen-name> ::= <let-or-digit> <[*[<let-or-digit-or-hyphen>]<let-or-digit>] */ char -valid_host_name (char *address, int length) +valid_host_name(char *address, int length) { - int i = 0; - int str_len = 0; - char ret = 1; - char *dup_addr = NULL; - char *temp_str = NULL; - char *save_ptr = NULL; + int i = 0; + int str_len = 0; + char ret = 1; + char *dup_addr = NULL; + char *temp_str = NULL; + char *save_ptr = NULL; - if ((length > _POSIX_HOST_NAME_MAX) || (length < 1)) { - ret = 0; - goto out; - } + if ((length > _POSIX_HOST_NAME_MAX) || (length < 1)) { + ret = 0; + goto out; + } - dup_addr = gf_strdup (address); - if (!dup_addr) { - ret = 0; - goto out; - } + dup_addr = gf_strdup(address); + if (!dup_addr) { + ret = 0; + goto out; + } - if (!isalnum (dup_addr[length - 1]) && (dup_addr[length - 1] != '*')) { - ret = 0; - goto out; - } + if (!isalnum(dup_addr[length - 1]) && (dup_addr[length - 1] != '*')) { + ret = 0; + goto out; + } - /* Check for consecutive dots, which is invalid in a hostname and is - * ignored by strtok() - */ - if (strstr (dup_addr, "..")) { + /* Check for consecutive dots, which is invalid in a hostname and is + * ignored by strtok() + */ + if (strstr(dup_addr, "..")) { + ret = 0; + goto out; + } + + /* gen-name */ + temp_str = strtok_r(dup_addr, ".", &save_ptr); + do { + str_len = strlen(temp_str); + + if (!isalnum(temp_str[0]) || !isalnum(temp_str[str_len - 1])) { + ret = 0; + goto out; + } + for (i = 1; i < str_len; i++) { + if (!isalnum(temp_str[i]) && (temp_str[i] != '-')) { ret = 0; goto out; + } } - - /* gen-name */ - temp_str = strtok_r (dup_addr, ".", &save_ptr); - do { - str_len = strlen (temp_str); - - if (!isalnum (temp_str[0]) || - !isalnum (temp_str[str_len-1])) { - ret = 0; - goto out; - } - for (i = 1; i < str_len; i++) { - if (!isalnum (temp_str[i]) && (temp_str[i] != '-')) { - ret = 0; - goto out; - } - } - } while ((temp_str = strtok_r (NULL, ".", &save_ptr))); + } while ((temp_str = strtok_r(NULL, ".", &save_ptr))); out: - GF_FREE (dup_addr); - return ret; + GF_FREE(dup_addr); + return ret; } /* Matches all ipv4 address, if wildcard_acc is true '*' wildcard pattern for* - subnets is considered as valid strings as well */ + subnets is considered as valid strings as well */ char -valid_ipv4_address (char *address, int length, gf_boolean_t wildcard_acc) -{ - int octets = 0; - int value = 0; - char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL; - char ret = 1; - int is_wildcard = 0; +valid_ipv4_address(char *address, int length, gf_boolean_t wildcard_acc) +{ + int octets = 0; + int value = 0; + char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL; + char ret = 1; + int is_wildcard = 0; + + tmp = gf_strdup(address); + + /* + * To prevent cases where last character is '.' and which have + * consecutive dots like ".." as strtok ignore consecutive + * delimiters. + */ + if (length <= 0 || (strstr(address, "..")) || + (!isdigit(tmp[length - 1]) && (tmp[length - 1] != '*'))) { + ret = 0; + goto out; + } - tmp = gf_strdup (address); + prev = tmp; + prev = strtok_r(tmp, ".", &ptr); - /* - * To prevent cases where last character is '.' and which have - * consecutive dots like ".." as strtok ignore consecutive - * delimiters. - */ - if (length <= 0 || - (strstr (address, "..")) || - (!isdigit (tmp[length - 1]) && (tmp[length - 1] != '*'))) { + while (prev != NULL) { + octets++; + if (wildcard_acc && !strcmp(prev, "*")) { + is_wildcard = 1; + } else { + value = strtol(prev, &endptr, 10); + if ((value > 255) || (value < 0) || + (endptr != NULL && *endptr != '\0')) { ret = 0; goto out; + } } + prev = strtok_r(NULL, ".", &ptr); + } - prev = tmp; - prev = strtok_r (tmp, ".", &ptr); - - while (prev != NULL) { - octets++; - if (wildcard_acc && !strcmp (prev, "*")) { - is_wildcard = 1; - } else { - value = strtol (prev, &endptr, 10); - if ((value > 255) || (value < 0) || - (endptr != NULL && *endptr != '\0')) { - ret = 0; - goto out; - } - } - prev = strtok_r (NULL, ".", &ptr); - } - - if ((octets > 4) || (octets < 4 && !is_wildcard)) { - ret = 0; - } + if ((octets > 4) || (octets < 4 && !is_wildcard)) { + ret = 0; + } out: - GF_FREE (tmp); - return ret; + GF_FREE(tmp); + return ret; } /** @@ -2479,152 +2487,153 @@ out: * _gf_false otherwise. */ gf_boolean_t -valid_ipv4_subnetwork (const char *address) +valid_ipv4_subnetwork(const char *address) { - char *slash = NULL; - char *paddr = NULL; - char *endptr = NULL; - long prefixlen = -1; - gf_boolean_t retv = _gf_true; + char *slash = NULL; + char *paddr = NULL; + char *endptr = NULL; + long prefixlen = -1; + gf_boolean_t retv = _gf_true; - if (address == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - return _gf_false; - } - - paddr = gf_strdup (address); - if (paddr == NULL) /* ENOMEM */ - return _gf_false; - - /* - * INVALID: If '/' is not present OR - * Nothing specified after '/' - */ - slash = strchr(paddr, '/'); - if ((slash == NULL) || (slash[1] == '\0')) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0, - LG_MSG_INVALID_IPV4_FORMAT, "Invalid IPv4 " - "subnetwork format"); - retv = _gf_false; - goto out; - } + if (address == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + return _gf_false; + } - *slash = '\0'; - retv = valid_ipv4_address (paddr, strlen(paddr), _gf_false); - if (retv == _gf_false) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0, - LG_MSG_INVALID_IPV4_FORMAT, - "Invalid IPv4 subnetwork address"); - goto out; - } - /* - * Reset errno before checking it - */ - errno = 0; - prefixlen = strtol (slash + 1, &endptr, 10); - if ((errno != 0) || (*endptr != '\0') || - (prefixlen < 0) || (prefixlen > IPv4_ADDR_SIZE)) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0, - LG_MSG_INVALID_IPV4_FORMAT, - "Invalid IPv4 subnetwork mask"); - retv = _gf_false; - goto out; - } + paddr = gf_strdup(address); + if (paddr == NULL) /* ENOMEM */ + return _gf_false; - retv = _gf_true; + /* + * INVALID: If '/' is not present OR + * Nothing specified after '/' + */ + slash = strchr(paddr, '/'); + if ((slash == NULL) || (slash[1] == '\0')) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, + LG_MSG_INVALID_IPV4_FORMAT, + "Invalid IPv4 " + "subnetwork format"); + retv = _gf_false; + goto out; + } + + *slash = '\0'; + retv = valid_ipv4_address(paddr, strlen(paddr), _gf_false); + if (retv == _gf_false) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, + LG_MSG_INVALID_IPV4_FORMAT, + "Invalid IPv4 subnetwork address"); + goto out; + } + /* + * Reset errno before checking it + */ + errno = 0; + prefixlen = strtol(slash + 1, &endptr, 10); + if ((errno != 0) || (*endptr != '\0') || (prefixlen < 0) || + (prefixlen > IPv4_ADDR_SIZE)) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, + LG_MSG_INVALID_IPV4_FORMAT, + "Invalid IPv4 subnetwork mask"); + retv = _gf_false; + goto out; + } + + retv = _gf_true; out: - GF_FREE (paddr); - return retv; + GF_FREE(paddr); + return retv; } char -valid_ipv6_address (char *address, int length, gf_boolean_t wildcard_acc) -{ - int hex_numbers = 0; - int value = 0; - int i = 0; - char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL; - char ret = 1; - int is_wildcard = 0; - int is_compressed = 0; - - tmp = gf_strdup (address); - - /* Check for '%' for link local addresses */ - endptr = strchr(tmp, '%'); - if (endptr) { - *endptr = '\0'; - length = strlen(tmp); - endptr = NULL; - } - - /* Check for compressed form */ - if (length <= 0 || tmp[length - 1] == ':') { +valid_ipv6_address(char *address, int length, gf_boolean_t wildcard_acc) +{ + int hex_numbers = 0; + int value = 0; + int i = 0; + char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL; + char ret = 1; + int is_wildcard = 0; + int is_compressed = 0; + + tmp = gf_strdup(address); + + /* Check for '%' for link local addresses */ + endptr = strchr(tmp, '%'); + if (endptr) { + *endptr = '\0'; + length = strlen(tmp); + endptr = NULL; + } + + /* Check for compressed form */ + if (length <= 0 || tmp[length - 1] == ':') { + ret = 0; + goto out; + } + for (i = 0; i < (length - 1); i++) { + if (tmp[i] == ':' && tmp[i + 1] == ':') { + if (is_compressed == 0) + is_compressed = 1; + else { ret = 0; goto out; + } } - for (i = 0; i < (length - 1) ; i++) { - if (tmp[i] == ':' && tmp[i + 1] == ':') { - if (is_compressed == 0) - is_compressed = 1; - else { - ret = 0; - goto out; - } - } - } + } - prev = strtok_r (tmp, ":", &ptr); - - while (prev != NULL) { - hex_numbers++; - if (wildcard_acc && !strcmp (prev, "*")) { - is_wildcard = 1; - } else { - value = strtol (prev, &endptr, 16); - if ((value > 0xffff) || (value < 0) - || (endptr != NULL && *endptr != '\0')) { - ret = 0; - goto out; - } - } - prev = strtok_r (NULL, ":", &ptr); - } + prev = strtok_r(tmp, ":", &ptr); - if ((hex_numbers > 8) || (hex_numbers < 8 && !is_wildcard - && !is_compressed)) { + while (prev != NULL) { + hex_numbers++; + if (wildcard_acc && !strcmp(prev, "*")) { + is_wildcard = 1; + } else { + value = strtol(prev, &endptr, 16); + if ((value > 0xffff) || (value < 0) || + (endptr != NULL && *endptr != '\0')) { ret = 0; + goto out; + } } + prev = strtok_r(NULL, ":", &ptr); + } + + if ((hex_numbers > 8) || + (hex_numbers < 8 && !is_wildcard && !is_compressed)) { + ret = 0; + } out: - GF_FREE (tmp); - return ret; + GF_FREE(tmp); + return ret; } char -valid_internet_address (char *address, gf_boolean_t wildcard_acc) +valid_internet_address(char *address, gf_boolean_t wildcard_acc) { - char ret = 0; - int length = 0; + char ret = 0; + int length = 0; - if (address == NULL) { - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - goto out; - } + if (address == NULL) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + goto out; + } - length = strlen (address); - if (length == 0) - goto out; + length = strlen(address); + if (length == 0) + goto out; - if (valid_ipv4_address (address, length, wildcard_acc) - || valid_ipv6_address (address, length, wildcard_acc) - || valid_host_name (address, length)) - ret = 1; + if (valid_ipv4_address(address, length, wildcard_acc) || + valid_ipv6_address(address, length, wildcard_acc) || + valid_host_name(address, length)) + ret = 1; out: - return ret; + return ret; } /** @@ -2634,56 +2643,56 @@ out: * * @return _gf_true if "address" is "*" (anonymous) 'OR' * if "address" is valid FQDN or valid IPv4/6 address 'OR' - * if "address" contains wildcard chars e.g. "'*' or '?' or '['" - * if "address" is valid ipv4 subnet pattern (xx.xx.xx.xx/n) - * _gf_false otherwise + * if "address" contains wildcard chars e.g. "'*' or '?' or + * '['" if "address" is valid ipv4 subnet pattern (xx.xx.xx.xx/n) _gf_false + * otherwise * * * NB: If the user/admin set for wildcard pattern, then it does not have * to be validated. Make it similar to the way exportfs (kNFS) works. */ gf_boolean_t -valid_mount_auth_address (char *address) +valid_mount_auth_address(char *address) { - int length = 0; - char *cp = NULL; + int length = 0; + char *cp = NULL; - /* 1. Check for "NULL and empty string */ - if ((address == NULL) || (address[0] == '\0')){ - gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL, - LG_MSG_INVALID_ARG, "argument invalid"); - return _gf_false; - } + /* 1. Check for "NULL and empty string */ + if ((address == NULL) || (address[0] == '\0')) { + gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG, + "argument invalid"); + return _gf_false; + } - /* 2. Check for Anonymous */ - if (strcmp(address, "*") == 0) - return _gf_true; + /* 2. Check for Anonymous */ + if (strcmp(address, "*") == 0) + return _gf_true; - for (cp = address; *cp; cp++) { - /* 3. Check for wildcard pattern */ - if (*cp == '*' || *cp == '?' || *cp == '[') { - return _gf_true; - } - - /* - * 4. check for IPv4 subnetwork i.e. xx.xx.xx.xx/n - * TODO: check for IPv6 subnetwork - * NB: Wildcard must not be mixed with subnetwork. - */ - if (*cp == '/') { - return valid_ipv4_subnetwork (address); - } + for (cp = address; *cp; cp++) { + /* 3. Check for wildcard pattern */ + if (*cp == '*' || *cp == '?' || *cp == '[') { + return _gf_true; } - /* 5. Check for v4/v6 IP addr and FQDN/hostname */ - length = strlen (address); - if ((valid_ipv4_address (address, length, _gf_false)) || - (valid_ipv6_address (address, length, _gf_false)) || - (valid_host_name (address, length))) { - return _gf_true; + /* + * 4. check for IPv4 subnetwork i.e. xx.xx.xx.xx/n + * TODO: check for IPv6 subnetwork + * NB: Wildcard must not be mixed with subnetwork. + */ + if (*cp == '/') { + return valid_ipv4_subnetwork(address); } + } - return _gf_false; + /* 5. Check for v4/v6 IP addr and FQDN/hostname */ + length = strlen(address); + if ((valid_ipv4_address(address, length, _gf_false)) || + (valid_ipv6_address(address, length, _gf_false)) || + (valid_host_name(address, length))) { + return _gf_true; + } + + return _gf_false; } /** @@ -2694,40 +2703,39 @@ valid_mount_auth_address (char *address) * @return _gf_true if a and b have same ipv{4,6} addr, _gf_false otherwise */ gf_boolean_t -gf_sock_union_equal_addr (union gf_sock_union *a, - union gf_sock_union *b) +gf_sock_union_equal_addr(union gf_sock_union *a, union gf_sock_union *b) { - if (!a || !b) { - gf_msg ("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, - "Invalid arguments to gf_sock_union_equal_addr"); - return _gf_false; - } + if (!a || !b) { + gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, + "Invalid arguments to gf_sock_union_equal_addr"); + return _gf_false; + } - if (a->storage.ss_family != b->storage.ss_family) - return _gf_false; + if (a->storage.ss_family != b->storage.ss_family) + return _gf_false; - switch (a->storage.ss_family) { + switch (a->storage.ss_family) { case AF_INET: - if (a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr) - return _gf_true; - else - return _gf_false; + if (a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr) + return _gf_true; + else + return _gf_false; case AF_INET6: - if (memcmp ((void *)(&a->sin6.sin6_addr), - (void *)(&b->sin6.sin6_addr), - sizeof (a->sin6.sin6_addr))) - return _gf_false; - else - return _gf_true; + if (memcmp((void *)(&a->sin6.sin6_addr), + (void *)(&b->sin6.sin6_addr), sizeof(a->sin6.sin6_addr))) + return _gf_false; + else + return _gf_true; default: - gf_msg_debug ("common-utils", 0, "Unsupported/invalid address " - "family"); - break; - } + gf_msg_debug("common-utils", 0, + "Unsupported/invalid address " + "family"); + break; + } - return _gf_false; + return _gf_false; } /* @@ -2743,62 +2751,61 @@ gf_sock_union_equal_addr (union gf_sock_union *a, gf_boolean_t mask_match(const uint32_t a, const uint32_t b, const uint32_t m) { - return (((a ^ b) & m) == 0); + return (((a ^ b) & m) == 0); } - /*Thread safe conversion function*/ char * -uuid_utoa (uuid_t uuid) +uuid_utoa(uuid_t uuid) { - char *uuid_buffer = glusterfs_uuid_buf_get (); - gf_uuid_unparse (uuid, uuid_buffer); - return uuid_buffer; + char *uuid_buffer = glusterfs_uuid_buf_get(); + gf_uuid_unparse(uuid, uuid_buffer); + return uuid_buffer; } /*Re-entrant conversion function*/ char * -uuid_utoa_r (uuid_t uuid, char *dst) +uuid_utoa_r(uuid_t uuid, char *dst) { - if(!dst) - return NULL; - gf_uuid_unparse (uuid, dst); - return dst; + if (!dst) + return NULL; + gf_uuid_unparse(uuid, dst); + return dst; } /*Thread safe conversion function*/ char * -lkowner_utoa (gf_lkowner_t *lkowner) +lkowner_utoa(gf_lkowner_t *lkowner) { - char *lkowner_buffer = glusterfs_lkowner_buf_get (); - lkowner_unparse (lkowner, lkowner_buffer, GF_LKOWNER_BUF_SIZE); - return lkowner_buffer; + char *lkowner_buffer = glusterfs_lkowner_buf_get(); + lkowner_unparse(lkowner, lkowner_buffer, GF_LKOWNER_BUF_SIZE); + return lkowner_buffer; } /*Re-entrant conversion function*/ char * -lkowner_utoa_r (gf_lkowner_t *lkowner, char *dst, int len) +lkowner_utoa_r(gf_lkowner_t *lkowner, char *dst, int len) { - if(!dst) - return NULL; - lkowner_unparse (lkowner, dst, len); - return dst; + if (!dst) + return NULL; + lkowner_unparse(lkowner, dst, len); + return dst; } gf_boolean_t -is_valid_lease_id (const char *lease_id) +is_valid_lease_id(const char *lease_id) { - int i = 0; - gf_boolean_t valid = _gf_false; + int i = 0; + gf_boolean_t valid = _gf_false; - for (i = 0; i < LEASE_ID_SIZE; i++) { - if (lease_id[i] != 0) { - valid = _gf_true; - goto out; - } + for (i = 0; i < LEASE_ID_SIZE; i++) { + if (lease_id[i] != 0) { + valid = _gf_true; + goto out; } + } out: - return valid; + return valid; } /* Lease_id can be a either in printable or non printable binary @@ -2815,108 +2822,107 @@ out: * subsequent call to this function will override the same buffer. */ char * -leaseid_utoa (const char *lease_id) -{ - char *buf = NULL; - int i = 0; - int j = 0; - - buf = glusterfs_leaseid_buf_get (); - if (!buf) - goto out; - - for (i = 0; i < LEASE_ID_SIZE; i++) { - if (i && !(i % 2)) { - buf[j] = '-'; - j++; - } - sprintf (&buf[j], "%02hhx", lease_id[i]); - j += 2; - if (j == GF_LEASE_ID_BUF_SIZE) - break; - } - buf[GF_LEASE_ID_BUF_SIZE - 1] = '\0'; +leaseid_utoa(const char *lease_id) +{ + char *buf = NULL; + int i = 0; + int j = 0; + + buf = glusterfs_leaseid_buf_get(); + if (!buf) + goto out; + + for (i = 0; i < LEASE_ID_SIZE; i++) { + if (i && !(i % 2)) { + buf[j] = '-'; + j++; + } + sprintf(&buf[j], "%02hhx", lease_id[i]); + j += 2; + if (j == GF_LEASE_ID_BUF_SIZE) + break; + } + buf[GF_LEASE_ID_BUF_SIZE - 1] = '\0'; out: - return buf; + return buf; } char * -gf_leaseid_get () +gf_leaseid_get() { - return glusterfs_leaseid_buf_get (); + return glusterfs_leaseid_buf_get(); } char * -gf_existing_leaseid () +gf_existing_leaseid() { - return glusterfs_leaseid_exist (); + return glusterfs_leaseid_exist(); } -void* gf_array_elem (void *a, int index, size_t elem_size) +void * +gf_array_elem(void *a, int index, size_t elem_size) { - uint8_t* ptr = a; - return (void*)(ptr + index * elem_size); + uint8_t *ptr = a; + return (void *)(ptr + index * elem_size); } void -gf_elem_swap (void *x, void *y, size_t l) { - uint8_t *a = x, *b = y, c; - while(l--) { - c = *a; - *a++ = *b; - *b++ = c; - } +gf_elem_swap(void *x, void *y, size_t l) +{ + uint8_t *a = x, *b = y, c; + while (l--) { + c = *a; + *a++ = *b; + *b++ = c; + } } void -gf_array_insertionsort (void *A, int l, int r, size_t elem_size, - gf_cmp cmp) -{ - int i = l; - int N = r+1; - void *Temp = NULL; - int j = 0; - - for(i = l; i < N; i++) { - Temp = gf_array_elem (A, i, elem_size); - j = i - 1; - while (j >= 0 && (cmp (Temp, gf_array_elem (A, j, elem_size)) - < 0)) { - gf_elem_swap (Temp, gf_array_elem (A, j, elem_size), - elem_size); - Temp = gf_array_elem (A, j, elem_size); - j = j-1; - } +gf_array_insertionsort(void *A, int l, int r, size_t elem_size, gf_cmp cmp) +{ + int i = l; + int N = r + 1; + void *Temp = NULL; + int j = 0; + + for (i = l; i < N; i++) { + Temp = gf_array_elem(A, i, elem_size); + j = i - 1; + while (j >= 0 && (cmp(Temp, gf_array_elem(A, j, elem_size)) < 0)) { + gf_elem_swap(Temp, gf_array_elem(A, j, elem_size), elem_size); + Temp = gf_array_elem(A, j, elem_size); + j = j - 1; } + } } int -gf_is_str_int (const char *value) +gf_is_str_int(const char *value) { - int flag = 0; - char *str = NULL; - char *fptr = NULL; + int flag = 0; + char *str = NULL; + char *fptr = NULL; - GF_VALIDATE_OR_GOTO (THIS->name, value, out); + GF_VALIDATE_OR_GOTO(THIS->name, value, out); - str = gf_strdup (value); - if (!str) - goto out; + str = gf_strdup(value); + if (!str) + goto out; - fptr = str; + fptr = str; - while (*str) { - if (!isdigit(*str)) { - flag = 1; - goto out; - } - str++; + while (*str) { + if (!isdigit(*str)) { + flag = 1; + goto out; } + str++; + } out: - GF_FREE (fptr); + GF_FREE(fptr); - return flag; + return flag; } /* * rounds up nr to power of two. If nr is already a power of two, just returns @@ -2924,22 +2930,22 @@ out: */ int32_t -gf_roundup_power_of_two (int32_t nr) +gf_roundup_power_of_two(int32_t nr) { - int32_t result = 1; + int32_t result = 1; - if (nr < 0) { - gf_msg ("common-utils", GF_LOG_WARNING, 0, - LG_MSG_NEGATIVE_NUM_PASSED, "negative number passed"); - result = -1; - goto out; - } + if (nr < 0) { + gf_msg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED, + "negative number passed"); + result = -1; + goto out; + } - while (result < nr) - result *= 2; + while (result < nr) + result *= 2; out: - return result; + return result; } /* @@ -2948,392 +2954,384 @@ out: */ int32_t -gf_roundup_next_power_of_two (int32_t nr) +gf_roundup_next_power_of_two(int32_t nr) { - int32_t result = 1; + int32_t result = 1; - if (nr < 0) { - gf_msg ("common-utils", GF_LOG_WARNING, 0, - LG_MSG_NEGATIVE_NUM_PASSED, "negative number passed"); - result = -1; - goto out; - } + if (nr < 0) { + gf_msg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED, + "negative number passed"); + result = -1; + goto out; + } - while (result <= nr) - result *= 2; + while (result <= nr) + result *= 2; out: - return result; + return result; } int -get_vol_type (int type, int dist_count, int brick_count) +get_vol_type(int type, int dist_count, int brick_count) { - if ((type != GF_CLUSTER_TYPE_TIER) && (type > 0) && - (dist_count < brick_count)) - type = type + GF_CLUSTER_TYPE_MAX - 1; + if ((type != GF_CLUSTER_TYPE_TIER) && (type > 0) && + (dist_count < brick_count)) + type = type + GF_CLUSTER_TYPE_MAX - 1; - return type; + return type; } int -validate_brick_name (char *brick) +validate_brick_name(char *brick) { - char *delimiter = NULL; - int ret = 0; - delimiter = strrchr (brick, ':'); - if (!delimiter || delimiter == brick - || *(delimiter+1) != '/') - ret = -1; + char *delimiter = NULL; + int ret = 0; + delimiter = strrchr(brick, ':'); + if (!delimiter || delimiter == brick || *(delimiter + 1) != '/') + ret = -1; - return ret; + return ret; } char * -get_host_name (char *word, char **host) +get_host_name(char *word, char **host) { - char *delimiter = NULL; - delimiter = strrchr (word, ':'); - if (delimiter) - *delimiter = '\0'; - else - return NULL; - *host = word; - return *host; + char *delimiter = NULL; + delimiter = strrchr(word, ':'); + if (delimiter) + *delimiter = '\0'; + else + return NULL; + *host = word; + return *host; } - char * -get_path_name (char *word, char **path) +get_path_name(char *word, char **path) { - char *delimiter = NULL; - delimiter = strchr (word, '/'); - if (!delimiter) - return NULL; - *path = delimiter; - return *path; + char *delimiter = NULL; + delimiter = strchr(word, '/'); + if (!delimiter) + return NULL; + *path = delimiter; + return *path; } void -gf_path_strip_trailing_slashes (char *path) +gf_path_strip_trailing_slashes(char *path) { - int i = 0; - int len = 0; + int i = 0; + int len = 0; - if (!path) - return; + if (!path) + return; - len = strlen (path); - for (i = len - 1; i > 0; i--) { - if (path[i] != '/') - break; - } + len = strlen(path); + for (i = len - 1; i > 0; i--) { + if (path[i] != '/') + break; + } - if (i < (len -1)) - path [i+1] = '\0'; + if (i < (len - 1)) + path[i + 1] = '\0'; - return; + return; } uint64_t -get_mem_size () +get_mem_size() { - uint64_t memsize = -1; + uint64_t memsize = -1; #if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS - uint64_t page_size = 0; - uint64_t num_pages = 0; + uint64_t page_size = 0; + uint64_t num_pages = 0; - page_size = sysconf (_SC_PAGESIZE); - num_pages = sysconf (_SC_PHYS_PAGES); + page_size = sysconf(_SC_PAGESIZE); + num_pages = sysconf(_SC_PHYS_PAGES); - memsize = page_size * num_pages; + memsize = page_size * num_pages; #endif #if defined GF_DARWIN_HOST_OS - size_t len = sizeof(memsize); - int name [] = { CTL_HW, HW_PHYSMEM }; + size_t len = sizeof(memsize); + int name[] = {CTL_HW, HW_PHYSMEM}; - sysctl (name, 2, &memsize, &len, NULL, 0); + sysctl(name, 2, &memsize, &len, NULL, 0); #endif #if defined __NetBSD__ - size_t len = sizeof(memsize); - int name64 [] = { CTL_HW, HW_PHYSMEM64 }; + size_t len = sizeof(memsize); + int name64[] = {CTL_HW, HW_PHYSMEM64}; - sysctl (name64, 2, &memsize, &len, NULL, 0); - if (memsize == -1) - sysctl (name64, 2, &memsize, &len, NULL, 0); + sysctl(name64, 2, &memsize, &len, NULL, 0); + if (memsize == -1) + sysctl(name64, 2, &memsize, &len, NULL, 0); #endif - return memsize; + return memsize; } /* Strips all whitespace characters in a string and returns length of new string * on success */ int -gf_strip_whitespace (char *str, int len) +gf_strip_whitespace(char *str, int len) { - int i = 0; - int new_len = 0; - char *new_str = NULL; + int i = 0; + int new_len = 0; + char *new_str = NULL; - GF_ASSERT (str); + GF_ASSERT(str); - new_str = GF_MALLOC (len + 1, gf_common_mt_char); - if (new_str == NULL) - return -1; + new_str = GF_MALLOC(len + 1, gf_common_mt_char); + if (new_str == NULL) + return -1; - for (i = 0; i < len; i++) { - if (!isspace (str[i])) - new_str[new_len++] = str[i]; - } - new_str[new_len] = '\0'; + for (i = 0; i < len; i++) { + if (!isspace(str[i])) + new_str[new_len++] = str[i]; + } + new_str[new_len] = '\0'; - if (new_len != len) { - snprintf(str, new_len + 1, "%s", new_str); - } + if (new_len != len) { + snprintf(str, new_len + 1, "%s", new_str); + } - GF_FREE (new_str); - return new_len; + GF_FREE(new_str); + return new_len; } int -gf_canonicalize_path (char *path) +gf_canonicalize_path(char *path) { - int ret = -1; - int path_len = 0; - int dir_path_len = 0; - char *tmppath = NULL; - char *dir = NULL; - char *tmpstr = NULL; + int ret = -1; + int path_len = 0; + int dir_path_len = 0; + char *tmppath = NULL; + char *dir = NULL; + char *tmpstr = NULL; - if (!path || *path != '/') - goto out; + if (!path || *path != '/') + goto out; + + if (!strcmp(path, "/")) + return 0; - if (!strcmp (path, "/")) - return 0; + tmppath = gf_strdup(path); + if (!tmppath) + goto out; - tmppath = gf_strdup (path); - if (!tmppath) - goto out; + /* Strip the extra slashes and return */ + bzero(path, strlen(path)); + path[0] = '/'; + dir = strtok_r(tmppath, "/", &tmpstr); - /* Strip the extra slashes and return */ - bzero (path, strlen(path)); - path[0] = '/'; - dir = strtok_r(tmppath, "/", &tmpstr); - - while (dir) { - dir_path_len = strlen(dir); - strncpy ((path + path_len + 1), dir, dir_path_len); - path_len += dir_path_len + 1; - dir = strtok_r (NULL, "/", &tmpstr); - if (dir) { - path[path_len] = '/'; - } + while (dir) { + dir_path_len = strlen(dir); + strncpy((path + path_len + 1), dir, dir_path_len); + path_len += dir_path_len + 1; + dir = strtok_r(NULL, "/", &tmpstr); + if (dir) { + path[path_len] = '/'; } - path[path_len] = '\0'; - ret = 0; + } + path[path_len] = '\0'; + ret = 0; - out: - if (ret) - gf_msg ("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR, - "Path manipulation failed"); +out: + if (ret) + gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR, + "Path manipulation failed"); - GF_FREE(tmppath); + GF_FREE(tmppath); - return ret; + return ret; } static const char *__gf_timefmts[] = { - "%F %T", - "%Y/%m/%d-%T", - "%b %d %T", - "%F %H%M%S", - "%Y-%m-%d-%T", - "%s", + "%F %T", "%Y/%m/%d-%T", "%b %d %T", "%F %H%M%S", "%Y-%m-%d-%T", "%s", }; static const char *__gf_zerotimes[] = { - "0000-00-00 00:00:00", - "0000/00/00-00:00:00", - "xxx 00 00:00:00", - "0000-00-00 000000", - "0000-00-00-00:00:00", - "0", + "0000-00-00 00:00:00", "0000/00/00-00:00:00", "xxx 00 00:00:00", + "0000-00-00 000000", "0000-00-00-00:00:00", "0", }; void -_gf_timestuff (const char ***fmts, const char ***zeros) +_gf_timestuff(const char ***fmts, const char ***zeros) { - *fmts = __gf_timefmts; - *zeros = __gf_zerotimes; + *fmts = __gf_timefmts; + *zeros = __gf_zerotimes; } - char * -generate_glusterfs_ctx_id (void) +generate_glusterfs_ctx_id(void) { - uuid_t ctxid; - char *tmp = NULL; + uuid_t ctxid; + char *tmp = NULL; - gf_uuid_generate (ctxid); - tmp = uuid_utoa (ctxid); + gf_uuid_generate(ctxid); + tmp = uuid_utoa(ctxid); - return gf_strdup (tmp); + return gf_strdup(tmp); } char * -gf_get_reserved_ports () +gf_get_reserved_ports() { - char *ports_info = NULL; + char *ports_info = NULL; #if defined GF_LINUX_HOST_OS - int proc_fd = -1; - char *proc_file = "/proc/sys/net/ipv4/ip_local_reserved_ports"; - char buffer[4096] = {0,}; - int32_t ret = -1; - - proc_fd = open (proc_file, O_RDONLY); - if (proc_fd == -1) { - /* What should be done in this case? error out from here - * and thus stop the glusterfs process from starting or - * continue with older method of using any of the available - * port? For now 2nd option is considered. - */ - gf_msg ("glusterfs", GF_LOG_WARNING, errno, - LG_MSG_FILE_OP_FAILED, "could not open the file " - "/proc/sys/net/ipv4/ip_local_reserved_ports for " - "getting reserved ports info"); - goto out; - } - - ret = sys_read (proc_fd, buffer, sizeof (buffer)-1); - if (ret < 0) { - gf_msg ("glusterfs", GF_LOG_WARNING, errno, - LG_MSG_FILE_OP_FAILED, "could not read the file %s for" - " getting reserved ports info", proc_file); - goto out; - } - - buffer[ret] = '\0'; - ports_info = gf_strdup (buffer); + int proc_fd = -1; + char *proc_file = "/proc/sys/net/ipv4/ip_local_reserved_ports"; + char buffer[4096] = { + 0, + }; + int32_t ret = -1; + + proc_fd = open(proc_file, O_RDONLY); + if (proc_fd == -1) { + /* What should be done in this case? error out from here + * and thus stop the glusterfs process from starting or + * continue with older method of using any of the available + * port? For now 2nd option is considered. + */ + gf_msg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, + "could not open the file " + "/proc/sys/net/ipv4/ip_local_reserved_ports for " + "getting reserved ports info"); + goto out; + } + + ret = sys_read(proc_fd, buffer, sizeof(buffer) - 1); + if (ret < 0) { + gf_msg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, + "could not read the file %s for" + " getting reserved ports info", + proc_file); + goto out; + } + + buffer[ret] = '\0'; + ports_info = gf_strdup(buffer); out: - if (proc_fd != -1) - sys_close (proc_fd); + if (proc_fd != -1) + sys_close(proc_fd); #endif /* GF_LINUX_HOST_OS */ - return ports_info; + return ports_info; } int -gf_process_reserved_ports (unsigned char *ports, uint32_t ceiling) +gf_process_reserved_ports(unsigned char *ports, uint32_t ceiling) { - int ret = -1; + int ret = -1; - memset (ports, 0, GF_PORT_ARRAY_SIZE); + memset(ports, 0, GF_PORT_ARRAY_SIZE); #if defined GF_LINUX_HOST_OS - char *ports_info = NULL; - char *tmp = NULL; - char *blocked_port = NULL; - - ports_info = gf_get_reserved_ports (); - if (!ports_info) { - gf_msg ("glusterfs", GF_LOG_WARNING, 0, - LG_MSG_RESERVED_PORTS_ERROR, "Not able to get reserved" - " ports, hence there is a possibility that glusterfs " - "may consume reserved port"); - goto out; - } + char *ports_info = NULL; + char *tmp = NULL; + char *blocked_port = NULL; - blocked_port = strtok_r (ports_info, ",\n",&tmp); + ports_info = gf_get_reserved_ports(); + if (!ports_info) { + gf_msg("glusterfs", GF_LOG_WARNING, 0, LG_MSG_RESERVED_PORTS_ERROR, + "Not able to get reserved" + " ports, hence there is a possibility that glusterfs " + "may consume reserved port"); + goto out; + } - while (blocked_port) { - gf_ports_reserved (blocked_port, ports, ceiling); - blocked_port = strtok_r (NULL, ",\n", &tmp); - } + blocked_port = strtok_r(ports_info, ",\n", &tmp); - ret = 0; + while (blocked_port) { + gf_ports_reserved(blocked_port, ports, ceiling); + blocked_port = strtok_r(NULL, ",\n", &tmp); + } + + ret = 0; out: - GF_FREE (ports_info); + GF_FREE(ports_info); #else /* FIXME: Non Linux Host */ - ret = 0; + ret = 0; #endif /* GF_LINUX_HOST_OS */ - return ret; + return ret; } gf_boolean_t -gf_ports_reserved (char *blocked_port, unsigned char *ports, uint32_t ceiling) -{ - gf_boolean_t result = _gf_false; - char *range_port = NULL; - int32_t tmp_port1 = -1; - int32_t tmp_port2 = -1; - - if (strstr (blocked_port, "-") == NULL) { - /* get rid of the new line character*/ - if (blocked_port[strlen(blocked_port) -1] == '\n') - blocked_port[strlen(blocked_port) -1] = '\0'; - if (gf_string2int32 (blocked_port, &tmp_port1) == 0) { - if (tmp_port1 > ceiling - || tmp_port1 < 0) { - gf_msg ("glusterfs-socket", GF_LOG_WARNING, 0, - LG_MSG_INVALID_PORT, "invalid port %d", - tmp_port1); - result = _gf_true; - goto out; - } else { - gf_msg_debug ("glusterfs", 0, "blocking port " - "%d", tmp_port1); - BIT_SET (ports, tmp_port1); - } - } else { - gf_msg ("glusterfs-socket", GF_LOG_WARNING, 0, - LG_MSG_INVALID_PORT, "%s is not a valid port " - "identifier", blocked_port); - result = _gf_true; - goto out; - } +gf_ports_reserved(char *blocked_port, unsigned char *ports, uint32_t ceiling) +{ + gf_boolean_t result = _gf_false; + char *range_port = NULL; + int32_t tmp_port1 = -1; + int32_t tmp_port2 = -1; + + if (strstr(blocked_port, "-") == NULL) { + /* get rid of the new line character*/ + if (blocked_port[strlen(blocked_port) - 1] == '\n') + blocked_port[strlen(blocked_port) - 1] = '\0'; + if (gf_string2int32(blocked_port, &tmp_port1) == 0) { + if (tmp_port1 > ceiling || tmp_port1 < 0) { + gf_msg("glusterfs-socket", GF_LOG_WARNING, 0, + LG_MSG_INVALID_PORT, "invalid port %d", tmp_port1); + result = _gf_true; + goto out; + } else { + gf_msg_debug("glusterfs", 0, + "blocking port " + "%d", + tmp_port1); + BIT_SET(ports, tmp_port1); + } } else { - range_port = strtok (blocked_port, "-"); - if (!range_port){ - result = _gf_true; - goto out; - } - if (gf_string2int32 (range_port, &tmp_port1) == 0) { - if (tmp_port1 > ceiling) - tmp_port1 = ceiling; - if (tmp_port1 < 0) - tmp_port1 = 0; - } - range_port = strtok (NULL, "-"); - if (!range_port) { - result = _gf_true; - goto out; - } - /* get rid of the new line character*/ - if (range_port[strlen(range_port) -1] == '\n') - range_port[strlen(range_port) - 1] = '\0'; - if (gf_string2int32 (range_port, &tmp_port2) == 0) { - if (tmp_port2 > ceiling) - tmp_port2 = ceiling; - if (tmp_port2 < 0) - tmp_port2 = 0; - } - gf_msg_debug ("glusterfs", 0, "lower: %d, higher: %d", - tmp_port1, tmp_port2); - for (; tmp_port1 <= tmp_port2; tmp_port1++) - BIT_SET (ports, tmp_port1); - } + gf_msg("glusterfs-socket", GF_LOG_WARNING, 0, LG_MSG_INVALID_PORT, + "%s is not a valid port " + "identifier", + blocked_port); + result = _gf_true; + goto out; + } + } else { + range_port = strtok(blocked_port, "-"); + if (!range_port) { + result = _gf_true; + goto out; + } + if (gf_string2int32(range_port, &tmp_port1) == 0) { + if (tmp_port1 > ceiling) + tmp_port1 = ceiling; + if (tmp_port1 < 0) + tmp_port1 = 0; + } + range_port = strtok(NULL, "-"); + if (!range_port) { + result = _gf_true; + goto out; + } + /* get rid of the new line character*/ + if (range_port[strlen(range_port) - 1] == '\n') + range_port[strlen(range_port) - 1] = '\0'; + if (gf_string2int32(range_port, &tmp_port2) == 0) { + if (tmp_port2 > ceiling) + tmp_port2 = ceiling; + if (tmp_port2 < 0) + tmp_port2 = 0; + } + gf_msg_debug("glusterfs", 0, "lower: %d, higher: %d", tmp_port1, + tmp_port2); + for (; tmp_port1 <= tmp_port2; tmp_port1++) + BIT_SET(ports, tmp_port1); + } out: - return result; + return result; } /* Takes in client ip{v4,v6} and returns associated hostname, if any @@ -3341,331 +3339,326 @@ out: * Returns: 0 for success, -1 for failure */ int -gf_get_hostname_from_ip (char *client_ip, char **hostname) -{ - int ret = -1; - struct sockaddr *client_sockaddr = NULL; - struct sockaddr_in client_sock_in = {0}; - struct sockaddr_in6 client_sock_in6 = {0}; - char client_hostname[NI_MAXHOST] = {0}; - char *client_ip_copy = NULL; - char *tmp = NULL; - char *ip = NULL; - size_t addr_sz = 0; - - /* if ipv4, reverse lookup the hostname to - * allow FQDN based rpc authentication - */ - if (!valid_ipv6_address (client_ip, strlen (client_ip), 0) && - !valid_ipv4_address (client_ip, strlen (client_ip), 0)) { - /* most times, we get a.b.c.d:port form, so check that */ - client_ip_copy = gf_strdup (client_ip); - if (!client_ip_copy) - goto out; - - ip = strtok_r (client_ip_copy, ":", &tmp); - } else { - ip = client_ip; - } - - if (valid_ipv4_address (ip, strlen (ip), 0) == _gf_true) { - client_sockaddr = (struct sockaddr *)&client_sock_in; - addr_sz = sizeof (client_sock_in); - client_sock_in.sin_family = AF_INET; - ret = inet_pton (AF_INET, ip, - (void *)&client_sock_in.sin_addr.s_addr); - - } else if (valid_ipv6_address (ip, strlen (ip), 0) == _gf_true) { - client_sockaddr = (struct sockaddr *) &client_sock_in6; - addr_sz = sizeof (client_sock_in6); +gf_get_hostname_from_ip(char *client_ip, char **hostname) +{ + int ret = -1; + struct sockaddr *client_sockaddr = NULL; + struct sockaddr_in client_sock_in = {0}; + struct sockaddr_in6 client_sock_in6 = {0}; + char client_hostname[NI_MAXHOST] = {0}; + char *client_ip_copy = NULL; + char *tmp = NULL; + char *ip = NULL; + size_t addr_sz = 0; + + /* if ipv4, reverse lookup the hostname to + * allow FQDN based rpc authentication + */ + if (!valid_ipv6_address(client_ip, strlen(client_ip), 0) && + !valid_ipv4_address(client_ip, strlen(client_ip), 0)) { + /* most times, we get a.b.c.d:port form, so check that */ + client_ip_copy = gf_strdup(client_ip); + if (!client_ip_copy) + goto out; + + ip = strtok_r(client_ip_copy, ":", &tmp); + } else { + ip = client_ip; + } + + if (valid_ipv4_address(ip, strlen(ip), 0) == _gf_true) { + client_sockaddr = (struct sockaddr *)&client_sock_in; + addr_sz = sizeof(client_sock_in); + client_sock_in.sin_family = AF_INET; + ret = inet_pton(AF_INET, ip, (void *)&client_sock_in.sin_addr.s_addr); + + } else if (valid_ipv6_address(ip, strlen(ip), 0) == _gf_true) { + client_sockaddr = (struct sockaddr *)&client_sock_in6; + addr_sz = sizeof(client_sock_in6); + + client_sock_in6.sin6_family = AF_INET6; + ret = inet_pton(AF_INET6, ip, (void *)&client_sock_in6.sin6_addr); + } else { + goto out; + } + + if (ret != 1) { + ret = -1; + goto out; + } + + /* You cannot just use sizeof (*client_sockaddr), as per the man page + * the (getnameinfo) size must be the size of the underlying sockaddr + * struct e.g. sockaddr_in6 or sockaddr_in. Failure to do so will + * break IPv6 hostname resolution (IPv4 will work only because + * the sockaddr_in struct happens to be of the correct size). + */ + ret = getnameinfo(client_sockaddr, addr_sz, client_hostname, + sizeof(client_hostname), NULL, 0, 0); + if (ret) { + gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED, + "Could not lookup hostname " + "of %s : %s", + client_ip, gai_strerror(ret)); + ret = -1; + goto out; + } + + *hostname = gf_strdup((char *)client_hostname); +out: + if (client_ip_copy) + GF_FREE(client_ip_copy); - client_sock_in6.sin6_family = AF_INET6; - ret = inet_pton (AF_INET6, ip, - (void *)&client_sock_in6.sin6_addr); - } else { - goto out; - } + return ret; +} - if (ret != 1) { - ret = -1; - goto out; - } +gf_boolean_t +gf_interface_search(char *ip) +{ + int32_t ret = -1; + gf_boolean_t found = _gf_false; + struct ifaddrs *ifaddr, *ifa; + int family; + char host[NI_MAXHOST]; + xlator_t *this = NULL; + char *pct = NULL; - /* You cannot just use sizeof (*client_sockaddr), as per the man page - * the (getnameinfo) size must be the size of the underlying sockaddr - * struct e.g. sockaddr_in6 or sockaddr_in. Failure to do so will - * break IPv6 hostname resolution (IPv4 will work only because - * the sockaddr_in struct happens to be of the correct size). - */ - ret = getnameinfo (client_sockaddr, - addr_sz, - client_hostname, sizeof (client_hostname), - NULL, 0, 0); - if (ret) { - gf_msg ("common-utils", GF_LOG_ERROR, 0, - LG_MSG_GETNAMEINFO_FAILED, "Could not lookup hostname " - "of %s : %s", client_ip, gai_strerror (ret)); - ret = -1; - goto out; - } + this = THIS; - *hostname = gf_strdup ((char *)client_hostname); - out: - if (client_ip_copy) - GF_FREE (client_ip_copy); + ret = getifaddrs(&ifaddr); - return ret; -} + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED, + "getifaddrs() failed: %s\n", gai_strerror(ret)); + goto out; + } -gf_boolean_t -gf_interface_search (char *ip) -{ - int32_t ret = -1; - gf_boolean_t found = _gf_false; - struct ifaddrs *ifaddr, *ifa; - int family; - char host[NI_MAXHOST]; - xlator_t *this = NULL; - char *pct = NULL; + for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { + if (!ifa->ifa_addr) { + /* + * This seemingly happens if an interface hasn't + * been bound to a particular protocol (seen with + * TUN devices). + */ + continue; + } + family = ifa->ifa_addr->sa_family; - this = THIS; + if (family != AF_INET && family != AF_INET6) + continue; - ret = getifaddrs (&ifaddr); + ret = getnameinfo(ifa->ifa_addr, + (family == AF_INET) ? sizeof(struct sockaddr_in) + : sizeof(struct sockaddr_in6), + host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST); if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED, - "getifaddrs() failed: %s\n", gai_strerror(ret)); - goto out; + gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED, + "getnameinfo() " + "failed: %s\n", + gai_strerror(ret)); + goto out; + } + + /* + * Sometimes the address comes back as addr%eth0 or + * similar. Since % is an invalid character, we can + * strip it out with confidence that doing so won't + * harm anything. + */ + pct = index(host, '%'); + if (pct) { + *pct = '\0'; } - for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { - if (!ifa->ifa_addr) { - /* - * This seemingly happens if an interface hasn't - * been bound to a particular protocol (seen with - * TUN devices). - */ - continue; - } - family = ifa->ifa_addr->sa_family; - - if (family != AF_INET && family != AF_INET6) - continue; - - ret = getnameinfo (ifa->ifa_addr, - (family == AF_INET) ? sizeof(struct sockaddr_in) : - sizeof(struct sockaddr_in6), - host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST); - - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, - LG_MSG_GETNAMEINFO_FAILED, "getnameinfo() " - "failed: %s\n", gai_strerror(ret)); - goto out; - } - - /* - * Sometimes the address comes back as addr%eth0 or - * similar. Since % is an invalid character, we can - * strip it out with confidence that doing so won't - * harm anything. - */ - pct = index(host,'%'); - if (pct) { - *pct = '\0'; - } - - if (strncmp (ip, host, NI_MAXHOST) == 0) { - gf_msg_debug (this->name, 0, "%s is local address at " - "interface %s", ip, ifa->ifa_name); - found = _gf_true; - goto out; - } + if (strncmp(ip, host, NI_MAXHOST) == 0) { + gf_msg_debug(this->name, 0, + "%s is local address at " + "interface %s", + ip, ifa->ifa_name); + found = _gf_true; + goto out; } + } out: - if(ifaddr) - freeifaddrs (ifaddr); - return found; + if (ifaddr) + freeifaddrs(ifaddr); + return found; } char * -get_ip_from_addrinfo (struct addrinfo *addr, char **ip) +get_ip_from_addrinfo(struct addrinfo *addr, char **ip) { - char buf[64]; - void *in_addr = NULL; - struct sockaddr_in *s4 = NULL; - struct sockaddr_in6 *s6 = NULL; + char buf[64]; + void *in_addr = NULL; + struct sockaddr_in *s4 = NULL; + struct sockaddr_in6 *s6 = NULL; - switch (addr->ai_family) - { - case AF_INET: - s4 = (struct sockaddr_in *)addr->ai_addr; - in_addr = &s4->sin_addr; - break; - - case AF_INET6: - s6 = (struct sockaddr_in6 *)addr->ai_addr; - in_addr = &s6->sin6_addr; - break; - - default: - gf_msg ("glusterd", GF_LOG_ERROR, 0, - LG_MSG_INVALID_FAMILY, "Invalid family"); - return NULL; - } + switch (addr->ai_family) { + case AF_INET: + s4 = (struct sockaddr_in *)addr->ai_addr; + in_addr = &s4->sin_addr; + break; - if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED, - "String conversion failed"); - return NULL; - } + case AF_INET6: + s6 = (struct sockaddr_in6 *)addr->ai_addr; + in_addr = &s6->sin6_addr; + break; + + default: + gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY, + "Invalid family"); + return NULL; + } + + if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) { + gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED, + "String conversion failed"); + return NULL; + } - *ip = gf_strdup (buf); - return *ip; + *ip = gf_strdup(buf); + return *ip; } gf_boolean_t -gf_is_loopback_localhost (const struct sockaddr *sa, char *hostname) -{ - GF_ASSERT (sa); - - gf_boolean_t is_local = _gf_false; - const struct in_addr *addr4 = NULL; - const struct in6_addr *addr6 = NULL; - uint8_t *ap = NULL; - struct in6_addr loopbackaddr6 = IN6ADDR_LOOPBACK_INIT; - - switch (sa->sa_family) { - case AF_INET: - addr4 = &(((struct sockaddr_in *)sa)->sin_addr); - ap = (uint8_t*)&addr4->s_addr; - if (ap[0] == 127) - is_local = _gf_true; - break; - - case AF_INET6: - addr6 = &(((struct sockaddr_in6 *)sa)->sin6_addr); - if (memcmp (addr6, &loopbackaddr6, - sizeof (loopbackaddr6)) == 0) - is_local = _gf_true; - break; - - default: - if (hostname) - gf_msg ("glusterd", GF_LOG_ERROR, 0, - LG_MSG_INVALID_FAMILY, "unknown " - "address family %d for %s", - sa->sa_family, hostname); - break; - } +gf_is_loopback_localhost(const struct sockaddr *sa, char *hostname) +{ + GF_ASSERT(sa); + + gf_boolean_t is_local = _gf_false; + const struct in_addr *addr4 = NULL; + const struct in6_addr *addr6 = NULL; + uint8_t *ap = NULL; + struct in6_addr loopbackaddr6 = IN6ADDR_LOOPBACK_INIT; + + switch (sa->sa_family) { + case AF_INET: + addr4 = &(((struct sockaddr_in *)sa)->sin_addr); + ap = (uint8_t *)&addr4->s_addr; + if (ap[0] == 127) + is_local = _gf_true; + break; + + case AF_INET6: + addr6 = &(((struct sockaddr_in6 *)sa)->sin6_addr); + if (memcmp(addr6, &loopbackaddr6, sizeof(loopbackaddr6)) == 0) + is_local = _gf_true; + break; + + default: + if (hostname) + gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY, + "unknown " + "address family %d for %s", + sa->sa_family, hostname); + break; + } - return is_local; + return is_local; } gf_boolean_t -gf_is_local_addr (char *hostname) +gf_is_local_addr(char *hostname) { - int32_t ret = -1; - struct addrinfo *result = NULL; - struct addrinfo *res = NULL; - gf_boolean_t found = _gf_false; - char *ip = NULL; - xlator_t *this = NULL; - struct addrinfo hints; + int32_t ret = -1; + struct addrinfo *result = NULL; + struct addrinfo *res = NULL; + gf_boolean_t found = _gf_false; + char *ip = NULL; + xlator_t *this = NULL; + struct addrinfo hints; - this = THIS; + this = THIS; - memset (&hints, 0, sizeof (hints)); - /* - * Removing AI_ADDRCONFIG from default_hints - * for being able to use link local ipv6 addresses - */ - hints.ai_family = AF_UNSPEC; + memset(&hints, 0, sizeof(hints)); + /* + * Removing AI_ADDRCONFIG from default_hints + * for being able to use link local ipv6 addresses + */ + hints.ai_family = AF_UNSPEC; - ret = getaddrinfo (hostname, NULL, &hints, &result); + ret = getaddrinfo(hostname, NULL, &hints, &result); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED, - "error in getaddrinfo: %s\n", gai_strerror(ret)); - goto out; - } + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED, + "error in getaddrinfo: %s\n", gai_strerror(ret)); + goto out; + } + + for (res = result; res != NULL; res = res->ai_next) { + gf_msg_debug(this->name, 0, "%s ", get_ip_from_addrinfo(res, &ip)); - for (res = result; res != NULL; res = res->ai_next) { - gf_msg_debug (this->name, 0, "%s ", - get_ip_from_addrinfo (res, &ip)); - - if (ip) { - found = gf_is_loopback_localhost - (res->ai_addr, hostname) || - gf_interface_search (ip); - } - if (found) { - GF_FREE (ip); - goto out; - } - GF_FREE (ip); + if (ip) { + found = gf_is_loopback_localhost(res->ai_addr, hostname) || + gf_interface_search(ip); + } + if (found) { + GF_FREE(ip); + goto out; } + GF_FREE(ip); + } out: - if (result) - freeaddrinfo (result); + if (result) + freeaddrinfo(result); - if (!found) - gf_msg_debug (this->name, 0, "%s is not local", hostname); + if (!found) + gf_msg_debug(this->name, 0, "%s is not local", hostname); - return found; + return found; } gf_boolean_t -gf_is_same_address (char *name1, char *name2) -{ - struct addrinfo *addr1 = NULL; - struct addrinfo *addr2 = NULL; - struct addrinfo *p = NULL; - struct addrinfo *q = NULL; - gf_boolean_t ret = _gf_false; - int gai_err = 0; - struct addrinfo hints; - - memset (&hints, 0, sizeof (hints)); - hints.ai_family = AF_UNSPEC; - - gai_err = getaddrinfo(name1, NULL, &hints, &addr1); - if (gai_err != 0) { - gf_msg (name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, - "error in getaddrinfo: %s\n", gai_strerror(gai_err)); - goto out; - } - - gai_err = getaddrinfo(name2, NULL, &hints, &addr2); - if (gai_err != 0) { - gf_msg (name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, - "error in getaddrinfo: %s\n", gai_strerror(gai_err)); - goto out; - } - - for (p = addr1; p; p = p->ai_next) { - for (q = addr2; q; q = q->ai_next) { - if (p->ai_addrlen != q->ai_addrlen) { - continue; - } - if (memcmp(p->ai_addr,q->ai_addr,p->ai_addrlen)) { - continue; - } - ret = _gf_true; - goto out; - } - } +gf_is_same_address(char *name1, char *name2) +{ + struct addrinfo *addr1 = NULL; + struct addrinfo *addr2 = NULL; + struct addrinfo *p = NULL; + struct addrinfo *q = NULL; + gf_boolean_t ret = _gf_false; + int gai_err = 0; + struct addrinfo hints; + + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + + gai_err = getaddrinfo(name1, NULL, &hints, &addr1); + if (gai_err != 0) { + gf_msg(name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, + "error in getaddrinfo: %s\n", gai_strerror(gai_err)); + goto out; + } + + gai_err = getaddrinfo(name2, NULL, &hints, &addr2); + if (gai_err != 0) { + gf_msg(name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, + "error in getaddrinfo: %s\n", gai_strerror(gai_err)); + goto out; + } + + for (p = addr1; p; p = p->ai_next) { + for (q = addr2; q; q = q->ai_next) { + if (p->ai_addrlen != q->ai_addrlen) { + continue; + } + if (memcmp(p->ai_addr, q->ai_addr, p->ai_addrlen)) { + continue; + } + ret = _gf_true; + goto out; + } + } out: - if (addr1) { - freeaddrinfo(addr1); - } - if (addr2) { - freeaddrinfo(addr2); - } - return ret; - + if (addr1) { + freeaddrinfo(addr1); + } + if (addr2) { + freeaddrinfo(addr2); + } + return ret; } /* @@ -3673,511 +3666,503 @@ out: * Format: <host1>:<port1> <host2>:<port2>... */ int -gf_process_getspec_servers_list(cmd_args_t *cmd_args, - const char *servers_list) { - char *tmp = NULL; - char *address = NULL; - char *host = NULL; - char *last_colon = NULL; - char *save_ptr = NULL; - int port = 0; - int ret = -1; - - tmp = gf_strdup (servers_list); - if (!tmp) { - errno = ENOMEM; - goto out; - } - - address = strtok_r (tmp, " ", &save_ptr); +gf_process_getspec_servers_list(cmd_args_t *cmd_args, const char *servers_list) +{ + char *tmp = NULL; + char *address = NULL; + char *host = NULL; + char *last_colon = NULL; + char *save_ptr = NULL; + int port = 0; + int ret = -1; + + tmp = gf_strdup(servers_list); + if (!tmp) { + errno = ENOMEM; + goto out; + } + + address = strtok_r(tmp, " ", &save_ptr); + if (!address) { + errno = EINVAL; + goto out; + } + + while (1) { + last_colon = strrchr(address, ':'); + if (!last_colon) { + errno = EINVAL; + ret = -1; + break; + } + *last_colon = '\0'; + host = address; + port = atoi(last_colon + 1); + if (port <= 0) { + errno = EINVAL; + ret = -1; + break; + } + ret = gf_set_volfile_server_common(cmd_args, host, + GF_DEFAULT_VOLFILE_TRANSPORT, port); + if (ret && errno != EEXIST) { + break; + } + address = strtok_r(NULL, " ", &save_ptr); if (!address) { - errno = EINVAL; - goto out; - } - - while (1) { - last_colon = strrchr (address, ':'); - if (!last_colon) { - errno = EINVAL; - ret = -1; - break; - } - *last_colon = '\0'; - host = address; - port = atoi (last_colon + 1); - if (port <= 0) { - errno = EINVAL; - ret = -1; - break; - } - ret = gf_set_volfile_server_common ( - cmd_args, host, GF_DEFAULT_VOLFILE_TRANSPORT, port); - if (ret && errno != EEXIST) { - break; - } - address = strtok_r (NULL, " ", &save_ptr); - if (!address) { - errno = 0; - ret = 0; - break; - } + errno = 0; + ret = 0; + break; } + } out: - if (tmp) { - GF_FREE (tmp); - } + if (tmp) { + GF_FREE(tmp); + } - return ret; + return ret; } int -gf_set_volfile_server_common (cmd_args_t *cmd_args, const char *host, - const char *transport, int port) -{ - server_cmdline_t *server = NULL; - server_cmdline_t *tmp = NULL; - int ret = -1; - - GF_VALIDATE_OR_GOTO (THIS->name, cmd_args, out); - GF_VALIDATE_OR_GOTO (THIS->name, host, out); - GF_VALIDATE_OR_GOTO (THIS->name, transport, out); - - server = GF_CALLOC (1, sizeof (server_cmdline_t), - gf_common_mt_server_cmdline_t); - if (!server) { - errno = ENOMEM; - goto out; - } - - INIT_LIST_HEAD (&server->list); - - server->volfile_server = gf_strdup (host); - if (!server->volfile_server) { - errno = ENOMEM; - goto out; - } - - server->transport = gf_strdup (transport); - if (!server->transport) { - errno = ENOMEM; - goto out; - } - - server->port = port; - - if (!cmd_args->volfile_server) { - cmd_args->volfile_server = server->volfile_server; - cmd_args->volfile_server_transport = server->transport; - cmd_args->volfile_server_port = server->port; - cmd_args->curr_server = server; - } - - list_for_each_entry(tmp, &cmd_args->volfile_servers, list) { - if ((!strcmp(tmp->volfile_server, server->volfile_server) && - !strcmp(tmp->transport, server->transport) && - (tmp->port == server->port))) { - errno = EEXIST; - ret = -1; - goto out; - } - } - - list_add_tail (&server->list, &cmd_args->volfile_servers); - - ret = 0; +gf_set_volfile_server_common(cmd_args_t *cmd_args, const char *host, + const char *transport, int port) +{ + server_cmdline_t *server = NULL; + server_cmdline_t *tmp = NULL; + int ret = -1; + + GF_VALIDATE_OR_GOTO(THIS->name, cmd_args, out); + GF_VALIDATE_OR_GOTO(THIS->name, host, out); + GF_VALIDATE_OR_GOTO(THIS->name, transport, out); + + server = GF_CALLOC(1, sizeof(server_cmdline_t), + gf_common_mt_server_cmdline_t); + if (!server) { + errno = ENOMEM; + goto out; + } + + INIT_LIST_HEAD(&server->list); + + server->volfile_server = gf_strdup(host); + if (!server->volfile_server) { + errno = ENOMEM; + goto out; + } + + server->transport = gf_strdup(transport); + if (!server->transport) { + errno = ENOMEM; + goto out; + } + + server->port = port; + + if (!cmd_args->volfile_server) { + cmd_args->volfile_server = server->volfile_server; + cmd_args->volfile_server_transport = server->transport; + cmd_args->volfile_server_port = server->port; + cmd_args->curr_server = server; + } + + list_for_each_entry(tmp, &cmd_args->volfile_servers, list) + { + if ((!strcmp(tmp->volfile_server, server->volfile_server) && + !strcmp(tmp->transport, server->transport) && + (tmp->port == server->port))) { + errno = EEXIST; + ret = -1; + goto out; + } + } + + list_add_tail(&server->list, &cmd_args->volfile_servers); + + ret = 0; out: - if (-1 == ret) { - if (server) { - GF_FREE (server->volfile_server); - GF_FREE (server->transport); - GF_FREE (server); - } + if (-1 == ret) { + if (server) { + GF_FREE(server->volfile_server); + GF_FREE(server->transport); + GF_FREE(server); } + } - return ret; + return ret; } /* Sets log file path from user provided arguments */ int -gf_set_log_file_path (cmd_args_t *cmd_args, glusterfs_ctx_t *ctx) -{ - int i = 0; - int j = 0; - int ret = 0; - int tmp_len = 0; - char tmp_str[1024] = {0,}; - - if (!cmd_args) - goto done; - - if (cmd_args->mount_point) { - j = 0; - i = 0; - if (cmd_args->mount_point[0] == '/') - i = 1; - for (; i < strlen (cmd_args->mount_point); i++,j++) { - tmp_str[j] = cmd_args->mount_point[i]; - if (cmd_args->mount_point[i] == '/') - tmp_str[j] = '-'; - } - - ret = gf_asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s.log", - tmp_str); - if (ret > 0) - ret = 0; - goto done; - } +gf_set_log_file_path(cmd_args_t *cmd_args, glusterfs_ctx_t *ctx) +{ + int i = 0; + int j = 0; + int ret = 0; + int tmp_len = 0; + char tmp_str[1024] = { + 0, + }; - if (ctx && GF_GLUSTERD_PROCESS == ctx->process_mode) { - ret = gf_asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s.log", - GLUSTERD_NAME); - if (ret > 0) - ret = 0; + if (!cmd_args) + goto done; - goto done; + if (cmd_args->mount_point) { + j = 0; + i = 0; + if (cmd_args->mount_point[0] == '/') + i = 1; + for (; i < strlen(cmd_args->mount_point); i++, j++) { + tmp_str[j] = cmd_args->mount_point[i]; + if (cmd_args->mount_point[i] == '/') + tmp_str[j] = '-'; } - if (cmd_args->volfile) { - j = 0; - i = 0; - if (cmd_args->volfile[0] == '/') - i = 1; - for (; i < strlen (cmd_args->volfile); i++,j++) { - tmp_str[j] = cmd_args->volfile[i]; - if (cmd_args->volfile[i] == '/') - tmp_str[j] = '-'; - } - ret = gf_asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s.log", - tmp_str); - if (ret > 0) - ret = 0; - goto done; - } + ret = gf_asprintf(&cmd_args->log_file, + DEFAULT_LOG_FILE_DIRECTORY "/%s.log", tmp_str); + if (ret > 0) + ret = 0; + goto done; + } + + if (ctx && GF_GLUSTERD_PROCESS == ctx->process_mode) { + ret = gf_asprintf(&cmd_args->log_file, + DEFAULT_LOG_FILE_DIRECTORY "/%s.log", GLUSTERD_NAME); + if (ret > 0) + ret = 0; + + goto done; + } - if (cmd_args->volfile_server) { - if (strncmp (cmd_args->volfile_server_transport, - "unix", 4) == 0) { - if (cmd_args->volfile_server[0] == '/') - i = 1; - tmp_len = strlen (cmd_args->volfile_server); - for (j = 0; i < tmp_len; i++, j++) { - tmp_str[j] = cmd_args->volfile_server[i]; - if (cmd_args->volfile_server[i] == '/') - tmp_str[j] = '-'; - } - ret = gf_asprintf (&cmd_args->log_file, - "%s/%s-%s-%d.log", - DEFAULT_LOG_FILE_DIRECTORY, - tmp_str, - cmd_args->volfile_id, getpid()); - } else { - ret = gf_asprintf (&cmd_args->log_file, - "%s/%s-%s-%d.log", - DEFAULT_LOG_FILE_DIRECTORY, - cmd_args->volfile_server, - cmd_args->volfile_id, getpid()); - } - if (ret > 0) - ret = 0; + if (cmd_args->volfile) { + j = 0; + i = 0; + if (cmd_args->volfile[0] == '/') + i = 1; + for (; i < strlen(cmd_args->volfile); i++, j++) { + tmp_str[j] = cmd_args->volfile[i]; + if (cmd_args->volfile[i] == '/') + tmp_str[j] = '-'; + } + ret = gf_asprintf(&cmd_args->log_file, + DEFAULT_LOG_FILE_DIRECTORY "/%s.log", tmp_str); + if (ret > 0) + ret = 0; + goto done; + } + + if (cmd_args->volfile_server) { + if (strncmp(cmd_args->volfile_server_transport, "unix", 4) == 0) { + if (cmd_args->volfile_server[0] == '/') + i = 1; + tmp_len = strlen(cmd_args->volfile_server); + for (j = 0; i < tmp_len; i++, j++) { + tmp_str[j] = cmd_args->volfile_server[i]; + if (cmd_args->volfile_server[i] == '/') + tmp_str[j] = '-'; + } + ret = gf_asprintf(&cmd_args->log_file, "%s/%s-%s-%d.log", + DEFAULT_LOG_FILE_DIRECTORY, tmp_str, + cmd_args->volfile_id, getpid()); + } else { + ret = gf_asprintf(&cmd_args->log_file, "%s/%s-%s-%d.log", + DEFAULT_LOG_FILE_DIRECTORY, + cmd_args->volfile_server, cmd_args->volfile_id, + getpid()); } + if (ret > 0) + ret = 0; + } done: - return ret; + return ret; } int -gf_set_log_ident (cmd_args_t *cmd_args) +gf_set_log_ident(cmd_args_t *cmd_args) { - int ret = 0; - char *ptr = NULL; - - if (cmd_args->log_file == NULL) { - /* no ident source */ - return 0; - } + int ret = 0; + char *ptr = NULL; - /* TODO: Some idents would look like, etc-glusterfs-glusterd.vol, which - * seems ugly and can be bettered? */ - /* just get the filename as the ident */ - if (NULL != (ptr = strrchr (cmd_args->log_file, '/'))) { - ret = gf_asprintf (&cmd_args->log_ident, "%s", ptr + 1); - } else { - ret = gf_asprintf (&cmd_args->log_ident, "%s", - cmd_args->log_file); - } - - if (ret > 0) - ret = 0; - else - return ret; + if (cmd_args->log_file == NULL) { + /* no ident source */ + return 0; + } + + /* TODO: Some idents would look like, etc-glusterfs-glusterd.vol, which + * seems ugly and can be bettered? */ + /* just get the filename as the ident */ + if (NULL != (ptr = strrchr(cmd_args->log_file, '/'))) { + ret = gf_asprintf(&cmd_args->log_ident, "%s", ptr + 1); + } else { + ret = gf_asprintf(&cmd_args->log_ident, "%s", cmd_args->log_file); + } + + if (ret > 0) + ret = 0; + else + return ret; - /* remove .log suffix */ - if (NULL != (ptr = strrchr (cmd_args->log_ident, '.'))) { - if (strcmp (ptr, ".log") == 0) { - ptr[0] = '\0'; - } + /* remove .log suffix */ + if (NULL != (ptr = strrchr(cmd_args->log_ident, '.'))) { + if (strcmp(ptr, ".log") == 0) { + ptr[0] = '\0'; } + } - return ret; + return ret; } int -gf_thread_cleanup_xint (pthread_t thread) +gf_thread_cleanup_xint(pthread_t thread) { - int ret = 0; - void *res = NULL; + int ret = 0; + void *res = NULL; - ret = pthread_cancel (thread); - if (ret != 0) - goto error_return; + ret = pthread_cancel(thread); + if (ret != 0) + goto error_return; - ret = pthread_join (thread, &res); - if (ret != 0) - goto error_return; + ret = pthread_join(thread, &res); + if (ret != 0) + goto error_return; - if (res != PTHREAD_CANCELED) - goto error_return; + if (res != PTHREAD_CANCELED) + goto error_return; - ret = 0; + ret = 0; - error_return: - return ret; +error_return: + return ret; } int -gf_thread_create (pthread_t *thread, const pthread_attr_t *attr, - void *(*start_routine)(void *), void *arg, const char *name) -{ - sigset_t set, old; - int ret; - char thread_name[GF_THREAD_NAMEMAX+GF_THREAD_NAME_PREFIX_LEN] = {0,}; - /* Max name on Linux is 16 and on NetBSD is 32 - * All Gluster threads have a set prefix of gluster and hence the limit - * of 9 on GF_THREAD_NAMEMAX including the null character. - */ - - sigemptyset (&old); - sigfillset (&set); - sigdelset (&set, SIGSEGV); - sigdelset (&set, SIGBUS); - sigdelset (&set, SIGILL); - sigdelset (&set, SIGSYS); - sigdelset (&set, SIGFPE); - sigdelset (&set, SIGABRT); - - pthread_sigmask (SIG_BLOCK, &set, &old); - - ret = pthread_create (thread, attr, start_routine, arg); - snprintf (thread_name, sizeof(thread_name), "%s%s", - GF_THREAD_NAME_PREFIX, name); - - if (0 == ret && name) { - #ifdef GF_LINUX_HOST_OS - pthread_setname_np(*thread, thread_name); - #elif defined(__NetBSD__) - pthread_setname_np(*thread, thread_name, NULL); - #elif defined(__FreeBSD__) - pthread_set_name_np(*thread, thread_name); - #else - gf_msg (THIS->name, GF_LOG_WARNING, 0, - LG_MSG_PTHREAD_NAMING_FAILED, - "Could not set thread name: %s", - thread_name); - #endif - } +gf_thread_create(pthread_t *thread, const pthread_attr_t *attr, + void *(*start_routine)(void *), void *arg, const char *name) +{ + sigset_t set, old; + int ret; + char thread_name[GF_THREAD_NAMEMAX + GF_THREAD_NAME_PREFIX_LEN] = { + 0, + }; + /* Max name on Linux is 16 and on NetBSD is 32 + * All Gluster threads have a set prefix of gluster and hence the limit + * of 9 on GF_THREAD_NAMEMAX including the null character. + */ + + sigemptyset(&old); + sigfillset(&set); + sigdelset(&set, SIGSEGV); + sigdelset(&set, SIGBUS); + sigdelset(&set, SIGILL); + sigdelset(&set, SIGSYS); + sigdelset(&set, SIGFPE); + sigdelset(&set, SIGABRT); + + pthread_sigmask(SIG_BLOCK, &set, &old); + + ret = pthread_create(thread, attr, start_routine, arg); + snprintf(thread_name, sizeof(thread_name), "%s%s", GF_THREAD_NAME_PREFIX, + name); + + if (0 == ret && name) { +#ifdef GF_LINUX_HOST_OS + pthread_setname_np(*thread, thread_name); +#elif defined(__NetBSD__) + pthread_setname_np(*thread, thread_name, NULL); +#elif defined(__FreeBSD__) + pthread_set_name_np(*thread, thread_name); +#else + gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PTHREAD_NAMING_FAILED, + "Could not set thread name: %s", thread_name); +#endif + } - pthread_sigmask (SIG_SETMASK, &old, NULL); + pthread_sigmask(SIG_SETMASK, &old, NULL); - return ret; + return ret; } int -gf_thread_create_detached (pthread_t *thread, - void *(*start_routine)(void *), void *arg, - const char *name) +gf_thread_create_detached(pthread_t *thread, void *(*start_routine)(void *), + void *arg, const char *name) { - pthread_attr_t attr; - int ret = -1; + pthread_attr_t attr; + int ret = -1; - ret = pthread_attr_init (&attr); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, ret, - LG_MSG_PTHREAD_ATTR_INIT_FAILED, - "Thread attribute initialization failed"); - return -1; - } + ret = pthread_attr_init(&attr); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_ATTR_INIT_FAILED, + "Thread attribute initialization failed"); + return -1; + } - pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); - ret = gf_thread_create (thread, &attr, start_routine, arg, name); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, ret, - LG_MSG_PTHREAD_FAILED, - "Thread creation failed"); - ret = -1; - } + ret = gf_thread_create(thread, &attr, start_routine, arg, name); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_FAILED, + "Thread creation failed"); + ret = -1; + } - pthread_attr_destroy (&attr); + pthread_attr_destroy(&attr); - return ret; + return ret; } int -gf_skip_header_section (int fd, int header_len) +gf_skip_header_section(int fd, int header_len) { - int ret = -1; + int ret = -1; - ret = sys_lseek (fd, header_len, SEEK_SET); - if (ret == (off_t) -1) { - gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED, - "Failed to skip header section"); - } else { - ret = 0; - } + ret = sys_lseek(fd, header_len, SEEK_SET); + if (ret == (off_t)-1) { + gf_msg("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED, + "Failed to skip header section"); + } else { + ret = 0; + } - return ret; + return ret; } /* Below function is use to check at runtime if pid is running */ gf_boolean_t -gf_is_pid_running (int pid) +gf_is_pid_running(int pid) { - char fname[32] = {0,}; + char fname[32] = { + 0, + }; - snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid); - - if (sys_access (fname , R_OK) != 0) { - return _gf_false; - } + snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid); - return _gf_true; + if (sys_access(fname, R_OK) != 0) { + return _gf_false; + } + return _gf_true; } - gf_boolean_t -gf_is_service_running (char *pidfile, int *pid) -{ - FILE *file = NULL; - gf_boolean_t running = _gf_false; - int ret = 0; - int fno = 0; - - file = fopen (pidfile, "r+"); - if (!file) { - goto out; - } - - fno = fileno (file); - ret = lockf (fno, F_TEST, 0); - if (ret == -1) { - running = _gf_true; - goto out; - } - - ret = fscanf (file, "%d", pid); - if (ret <= 0) { - gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, - "Unable to read pidfile: %s", pidfile); - *pid = -1; - } - - running = gf_is_pid_running (*pid); +gf_is_service_running(char *pidfile, int *pid) +{ + FILE *file = NULL; + gf_boolean_t running = _gf_false; + int ret = 0; + int fno = 0; + + file = fopen(pidfile, "r+"); + if (!file) { + goto out; + } + + fno = fileno(file); + ret = lockf(fno, F_TEST, 0); + if (ret == -1) { + running = _gf_true; + goto out; + } + + ret = fscanf(file, "%d", pid); + if (ret <= 0) { + gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, + "Unable to read pidfile: %s", pidfile); + *pid = -1; + } + + running = gf_is_pid_running(*pid); out: - if (file) - fclose (file); - return running; + if (file) + fclose(file); + return running; } /* Check if the pid is > 0 */ gf_boolean_t -gf_valid_pid (const char *pid, int length) +gf_valid_pid(const char *pid, int length) { - gf_boolean_t ret = _gf_true; - pid_t value = 0; - char *end_ptr = NULL; + gf_boolean_t ret = _gf_true; + pid_t value = 0; + char *end_ptr = NULL; - if (length <= 0) { - ret = _gf_false; - goto out; - } + if (length <= 0) { + ret = _gf_false; + goto out; + } - value = strtol (pid, &end_ptr, 10); - if (value <= 0) { - ret = _gf_false; - } + value = strtol(pid, &end_ptr, 10); + if (value <= 0) { + ret = _gf_false; + } out: - return ret; + return ret; } static int -dht_is_linkfile_key (dict_t *this, char *key, data_t *value, void *data) +dht_is_linkfile_key(dict_t *this, char *key, data_t *value, void *data) { - gf_boolean_t *linkfile_key_found = NULL; + gf_boolean_t *linkfile_key_found = NULL; - if (!data) - goto out; + if (!data) + goto out; - linkfile_key_found = data; + linkfile_key_found = data; - *linkfile_key_found = _gf_true; + *linkfile_key_found = _gf_true; out: - return 0; + return 0; } - gf_boolean_t -dht_is_linkfile (struct iatt *buf, dict_t *dict) +dht_is_linkfile(struct iatt *buf, dict_t *dict) { - gf_boolean_t linkfile_key_found = _gf_false; + gf_boolean_t linkfile_key_found = _gf_false; - if (!IS_DHT_LINKFILE_MODE (buf)) - return _gf_false; + if (!IS_DHT_LINKFILE_MODE(buf)) + return _gf_false; - dict_foreach_fnmatch (dict, "*."DHT_LINKFILE_STR, dht_is_linkfile_key, - &linkfile_key_found); + dict_foreach_fnmatch(dict, "*." DHT_LINKFILE_STR, dht_is_linkfile_key, + &linkfile_key_found); - return linkfile_key_found; + return linkfile_key_found; } int -gf_check_log_format (const char *value) +gf_check_log_format(const char *value) { - int log_format = -1; + int log_format = -1; - if (!strcasecmp (value, GF_LOG_FORMAT_NO_MSG_ID)) - log_format = gf_logformat_traditional; - else if (!strcasecmp (value, GF_LOG_FORMAT_WITH_MSG_ID)) - log_format = gf_logformat_withmsgid; + if (!strcasecmp(value, GF_LOG_FORMAT_NO_MSG_ID)) + log_format = gf_logformat_traditional; + else if (!strcasecmp(value, GF_LOG_FORMAT_WITH_MSG_ID)) + log_format = gf_logformat_withmsgid; - if (log_format == -1) - gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG, - "Invalid log-format. possible values are " - GF_LOG_FORMAT_NO_MSG_ID "|" GF_LOG_FORMAT_WITH_MSG_ID); + if (log_format == -1) + gf_msg( + THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG, + "Invalid log-format. possible values are " GF_LOG_FORMAT_NO_MSG_ID + "|" GF_LOG_FORMAT_WITH_MSG_ID); - return log_format; + return log_format; } int -gf_check_logger (const char *value) +gf_check_logger(const char *value) { - int logger = -1; + int logger = -1; - if (!strcasecmp (value, GF_LOGGER_GLUSTER_LOG)) - logger = gf_logger_glusterlog; - else if (!strcasecmp (value, GF_LOGGER_SYSLOG)) - logger = gf_logger_syslog; + if (!strcasecmp(value, GF_LOGGER_GLUSTER_LOG)) + logger = gf_logger_glusterlog; + else if (!strcasecmp(value, GF_LOGGER_SYSLOG)) + logger = gf_logger_syslog; - if (logger == -1) - gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG, - "Invalid logger. possible values are " - GF_LOGGER_GLUSTER_LOG "|" GF_LOGGER_SYSLOG); + if (logger == -1) + gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG, + "Invalid logger. possible values are " GF_LOGGER_GLUSTER_LOG + "|" GF_LOGGER_SYSLOG); - return logger; + return logger; } /* gf_compare_sockaddr compares the given addresses @addr1 and @addr2 for @@ -4187,30 +4172,28 @@ gf_check_logger (const char *value) * https://www.opensource.apple.com/source/postfix/postfix-197/postfix/src/util/sock_addr.c */ gf_boolean_t -gf_compare_sockaddr (const struct sockaddr *addr1, - const struct sockaddr *addr2) +gf_compare_sockaddr(const struct sockaddr *addr1, const struct sockaddr *addr2) { - GF_ASSERT (addr1 != NULL); - GF_ASSERT (addr2 != NULL); - - /* Obviously, the addresses don't match if their families are different - */ - if (addr1->sa_family != addr2->sa_family) - return _gf_false; + GF_ASSERT(addr1 != NULL); + GF_ASSERT(addr2 != NULL); + /* Obviously, the addresses don't match if their families are different + */ + if (addr1->sa_family != addr2->sa_family) + return _gf_false; - if (AF_INET == addr1->sa_family) { - if (((struct sockaddr_in *)addr1)->sin_addr.s_addr == - ((struct sockaddr_in *)addr2)->sin_addr.s_addr) - return _gf_true; + if (AF_INET == addr1->sa_family) { + if (((struct sockaddr_in *)addr1)->sin_addr.s_addr == + ((struct sockaddr_in *)addr2)->sin_addr.s_addr) + return _gf_true; - } else if (AF_INET6 == addr1->sa_family) { - if (memcmp ((char *)&((struct sockaddr_in6 *)addr1)->sin6_addr, - (char *)&((struct sockaddr_in6 *)addr2)->sin6_addr, - sizeof (struct in6_addr)) == 0) - return _gf_true; - } - return _gf_false; + } else if (AF_INET6 == addr1->sa_family) { + if (memcmp((char *)&((struct sockaddr_in6 *)addr1)->sin6_addr, + (char *)&((struct sockaddr_in6 *)addr2)->sin6_addr, + sizeof(struct in6_addr)) == 0) + return _gf_true; + } + return _gf_false; } /* @@ -4219,155 +4202,168 @@ gf_compare_sockaddr (const struct sockaddr *addr1, */ int -gf_set_timestamp (const char *src, const char* dest) +gf_set_timestamp(const char *src, const char *dest) { - struct stat sb = {0, }; + struct stat sb = { + 0, + }; #if defined(HAVE_UTIMENSAT) - struct timespec new_time[2] = { {0, }, {0, } }; + struct timespec new_time[2] = {{ + 0, + }, + { + 0, + }}; #else - struct timeval new_time[2] = { {0, }, {0, } }; + struct timeval new_time[2] = {{ + 0, + }, + { + 0, + }}; #endif - int ret = 0; - xlator_t *this = NULL; - - this = THIS; - GF_ASSERT (this); - GF_ASSERT (src); - GF_ASSERT (dest); - - ret = sys_stat (src, &sb); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - LG_MSG_FILE_STAT_FAILED, "stat on %s", src); - goto out; - } - /* The granularity is nano seconds if `utimensat()` is available, - * and micro seconds otherwise. - */ + int ret = 0; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT(this); + GF_ASSERT(src); + GF_ASSERT(dest); + + ret = sys_stat(src, &sb); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED, + "stat on %s", src); + goto out; + } + /* The granularity is nano seconds if `utimensat()` is available, + * and micro seconds otherwise. + */ #if defined(HAVE_UTIMENSAT) - new_time[0].tv_sec = sb.st_atime; - new_time[0].tv_nsec = ST_ATIM_NSEC (&sb); - - new_time[1].tv_sec = sb.st_mtime; - new_time[1].tv_nsec = ST_MTIM_NSEC (&sb); - - /* dirfd = 0 is ignored because `dest` is an absolute path. */ - ret = sys_utimensat (AT_FDCWD, dest, new_time, AT_SYMLINK_NOFOLLOW); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - LG_MSG_UTIMENSAT_FAILED, "utimensat on %s", dest); - } + new_time[0].tv_sec = sb.st_atime; + new_time[0].tv_nsec = ST_ATIM_NSEC(&sb); + + new_time[1].tv_sec = sb.st_mtime; + new_time[1].tv_nsec = ST_MTIM_NSEC(&sb); + + /* dirfd = 0 is ignored because `dest` is an absolute path. */ + ret = sys_utimensat(AT_FDCWD, dest, new_time, AT_SYMLINK_NOFOLLOW); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMENSAT_FAILED, + "utimensat on %s", dest); + } #else - new_time[0].tv_sec = sb.st_atime; - new_time[0].tv_usec = ST_ATIM_NSEC (&sb)/1000; + new_time[0].tv_sec = sb.st_atime; + new_time[0].tv_usec = ST_ATIM_NSEC(&sb) / 1000; - new_time[1].tv_sec = sb.st_mtime; - new_time[1].tv_usec = ST_MTIM_NSEC (&sb)/1000; + new_time[1].tv_sec = sb.st_mtime; + new_time[1].tv_usec = ST_MTIM_NSEC(&sb) / 1000; - ret = sys_utimes (dest, new_time); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED, - "utimes on %s", dest); - } + ret = sys_utimes(dest, new_time); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED, + "utimes on %s", dest); + } #endif out: - return ret; + return ret; } static void -gf_backtrace_end (char *buf, size_t frames) +gf_backtrace_end(char *buf, size_t frames) { - size_t pos = 0; + size_t pos = 0; - if (!buf) - return; + if (!buf) + return; - pos = strlen (buf); + pos = strlen(buf); - frames = min(frames, GF_BACKTRACE_LEN - pos -1); + frames = min(frames, GF_BACKTRACE_LEN - pos - 1); - if (frames <= 0) - return; + if (frames <= 0) + return; - memset (buf+pos, ')', frames); - buf[pos+frames] = '\0'; + memset(buf + pos, ')', frames); + buf[pos + frames] = '\0'; } /*Returns bytes written*/ static int -gf_backtrace_append (char *buf, size_t pos, char *framestr) +gf_backtrace_append(char *buf, size_t pos, char *framestr) { - if (pos >= GF_BACKTRACE_LEN) - return -1; - return snprintf (buf+pos, GF_BACKTRACE_LEN-pos, "(--> %s ", framestr); + if (pos >= GF_BACKTRACE_LEN) + return -1; + return snprintf(buf + pos, GF_BACKTRACE_LEN - pos, "(--> %s ", framestr); } static int -gf_backtrace_fillframes (char *buf) -{ - void *array[GF_BACKTRACE_FRAME_COUNT]; - size_t frames = 0; - FILE *fp = NULL; - char callingfn[GF_BACKTRACE_FRAME_COUNT-2][1024] = {{0},}; - int ret = -1; - int fd = -1; - size_t idx = 0; - size_t pos = 0; - size_t inc = 0; - char tmpl[] = "/tmp/glfs-bt-XXXXXX"; - - frames = backtrace (array, GF_BACKTRACE_FRAME_COUNT); - if (!frames) - return -1; - - /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */ - fd = mkstemp (tmpl); - if (fd == -1) - return -1; - - /* Calling unlink so that when the file is closed or program - * terminates the temporary file is deleted. - */ - ret = sys_unlink (tmpl); - if (ret < 0) { - gf_msg (THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_OP_FAILED, - "Unable to delete temporary file: %s", tmpl); - } - - /*The most recent two frames are the calling function and - * gf_backtrace_save, which we can infer.*/ - - backtrace_symbols_fd (&array[2], frames-2, fd); - - fp = fdopen (fd, "r"); - if (!fp) { - sys_close (fd); - ret = -1; - goto out; - } +gf_backtrace_fillframes(char *buf) +{ + void *array[GF_BACKTRACE_FRAME_COUNT]; + size_t frames = 0; + FILE *fp = NULL; + char callingfn[GF_BACKTRACE_FRAME_COUNT - 2][1024] = { + {0}, + }; + int ret = -1; + int fd = -1; + size_t idx = 0; + size_t pos = 0; + size_t inc = 0; + char tmpl[] = "/tmp/glfs-bt-XXXXXX"; + + frames = backtrace(array, GF_BACKTRACE_FRAME_COUNT); + if (!frames) + return -1; - ret = fseek (fp, 0L, SEEK_SET); - if (ret) - goto out; + /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */ + fd = mkstemp(tmpl); + if (fd == -1) + return -1; - pos = 0; - for (idx = 0; idx < frames - 2; idx++) { - ret = fscanf (fp, "%s", callingfn[idx]); - if (ret == EOF) - break; - inc = gf_backtrace_append (buf, pos, callingfn[idx]); - if (inc == -1) - break; - pos += inc; - } - gf_backtrace_end (buf, idx); + /* Calling unlink so that when the file is closed or program + * terminates the temporary file is deleted. + */ + ret = sys_unlink(tmpl); + if (ret < 0) { + gf_msg(THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_OP_FAILED, + "Unable to delete temporary file: %s", tmpl); + } + + /*The most recent two frames are the calling function and + * gf_backtrace_save, which we can infer.*/ + + backtrace_symbols_fd(&array[2], frames - 2, fd); + + fp = fdopen(fd, "r"); + if (!fp) { + sys_close(fd); + ret = -1; + goto out; + } + + ret = fseek(fp, 0L, SEEK_SET); + if (ret) + goto out; + + pos = 0; + for (idx = 0; idx < frames - 2; idx++) { + ret = fscanf(fp, "%s", callingfn[idx]); + if (ret == EOF) + break; + inc = gf_backtrace_append(buf, pos, callingfn[idx]); + if (inc == -1) + break; + pos += inc; + } + gf_backtrace_end(buf, idx); out: - if (fp) - fclose (fp); - - return (idx > 0)? 0: -1; + if (fp) + fclose(fp); + return (idx > 0) ? 0 : -1; } /* Optionally takes @buf to save backtrace. If @buf is NULL, uses the @@ -4378,72 +4374,66 @@ out: * when there is a real-use for that.*/ char * -gf_backtrace_save (char *buf) +gf_backtrace_save(char *buf) { - char *bt = NULL; - - if (!buf) { - bt = THIS->ctx->btbuf; - GF_ASSERT (bt); + char *bt = NULL; - } else { - bt = buf; + if (!buf) { + bt = THIS->ctx->btbuf; + GF_ASSERT(bt); - } + } else { + bt = buf; + } - if ((0 == gf_backtrace_fillframes (bt))) - return bt; + if ((0 == gf_backtrace_fillframes(bt))) + return bt; - gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED, - "Failed to save the backtrace."); - return NULL; + gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED, + "Failed to save the backtrace."); + return NULL; } gf_loglevel_t -fop_log_level (glusterfs_fop_t fop, int op_errno) -{ - /* if gfid doesn't exist ESTALE comes */ - if (op_errno == ENOENT || op_errno == ESTALE) - return GF_LOG_DEBUG; - - if ((fop == GF_FOP_ENTRYLK) || - (fop == GF_FOP_FENTRYLK) || - (fop == GF_FOP_FINODELK) || - (fop == GF_FOP_INODELK) || - (fop == GF_FOP_LK)) { - /* - * if non-blocking lock fails EAGAIN comes - * if locks xlator is not loaded ENOSYS comes - */ - if (op_errno == EAGAIN || op_errno == ENOSYS) - return GF_LOG_DEBUG; - } +fop_log_level(glusterfs_fop_t fop, int op_errno) +{ + /* if gfid doesn't exist ESTALE comes */ + if (op_errno == ENOENT || op_errno == ESTALE) + return GF_LOG_DEBUG; - if ((fop == GF_FOP_GETXATTR) || - (fop == GF_FOP_FGETXATTR)) { - if (op_errno == ENOTSUP || op_errno == ENODATA) - return GF_LOG_DEBUG; - } + if ((fop == GF_FOP_ENTRYLK) || (fop == GF_FOP_FENTRYLK) || + (fop == GF_FOP_FINODELK) || (fop == GF_FOP_INODELK) || + (fop == GF_FOP_LK)) { + /* + * if non-blocking lock fails EAGAIN comes + * if locks xlator is not loaded ENOSYS comes + */ + if (op_errno == EAGAIN || op_errno == ENOSYS) + return GF_LOG_DEBUG; + } - if ((fop == GF_FOP_SETXATTR) || - (fop == GF_FOP_FSETXATTR) || - (fop == GF_FOP_REMOVEXATTR) || - (fop == GF_FOP_FREMOVEXATTR)) { - if (op_errno == ENOTSUP) - return GF_LOG_DEBUG; - } + if ((fop == GF_FOP_GETXATTR) || (fop == GF_FOP_FGETXATTR)) { + if (op_errno == ENOTSUP || op_errno == ENODATA) + return GF_LOG_DEBUG; + } + + if ((fop == GF_FOP_SETXATTR) || (fop == GF_FOP_FSETXATTR) || + (fop == GF_FOP_REMOVEXATTR) || (fop == GF_FOP_FREMOVEXATTR)) { + if (op_errno == ENOTSUP) + return GF_LOG_DEBUG; + } - if (fop == GF_FOP_MKNOD || fop == GF_FOP_MKDIR) - if (op_errno == EEXIST) - return GF_LOG_DEBUG; + if (fop == GF_FOP_MKNOD || fop == GF_FOP_MKDIR) + if (op_errno == EEXIST) + return GF_LOG_DEBUG; - if (fop == GF_FOP_SEEK) { - if (op_errno == ENXIO) { - return GF_LOG_DEBUG; - } + if (fop == GF_FOP_SEEK) { + if (op_errno == ENXIO) { + return GF_LOG_DEBUG; } + } - return GF_LOG_ERROR; + return GF_LOG_ERROR; } /* This function will build absolute path of file/directory from the @@ -4461,116 +4451,115 @@ fop_log_level (glusterfs_fop_t fop, int op_errno) */ int32_t -gf_build_absolute_path (char *current_path, char *relative_path, char **path) -{ - char *absolute_path = NULL; - char *token = NULL; - char *component = NULL; - char *saveptr = NULL; - char *end = NULL; - int ret = 0; - size_t relativepath_len = 0; - size_t currentpath_len = 0; - size_t max_absolutepath_len = 0; - - GF_ASSERT (current_path); - GF_ASSERT (relative_path); - GF_ASSERT (path); - - if (!path || !current_path || !relative_path) { - ret = -EFAULT; - goto err; - } - /* Check for current and relative path - * current path should be absolute one and start from '/' - * relative path should not start from '/' - */ - currentpath_len = strlen (current_path); - if (current_path[0] != '/' || (currentpath_len > PATH_MAX)) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, - "Wrong value for current path %s", current_path); - ret = -EINVAL; - goto err; - } - - relativepath_len = strlen (relative_path); - if (relative_path[0] == '/' || (relativepath_len > PATH_MAX)) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, - "Wrong value for relative path %s", relative_path); - ret = -EINVAL; +gf_build_absolute_path(char *current_path, char *relative_path, char **path) +{ + char *absolute_path = NULL; + char *token = NULL; + char *component = NULL; + char *saveptr = NULL; + char *end = NULL; + int ret = 0; + size_t relativepath_len = 0; + size_t currentpath_len = 0; + size_t max_absolutepath_len = 0; + + GF_ASSERT(current_path); + GF_ASSERT(relative_path); + GF_ASSERT(path); + + if (!path || !current_path || !relative_path) { + ret = -EFAULT; + goto err; + } + /* Check for current and relative path + * current path should be absolute one and start from '/' + * relative path should not start from '/' + */ + currentpath_len = strlen(current_path); + if (current_path[0] != '/' || (currentpath_len > PATH_MAX)) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, + "Wrong value for current path %s", current_path); + ret = -EINVAL; + goto err; + } + + relativepath_len = strlen(relative_path); + if (relative_path[0] == '/' || (relativepath_len > PATH_MAX)) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, + "Wrong value for relative path %s", relative_path); + ret = -EINVAL; + goto err; + } + + /* It is maximum possible value for absolute path */ + max_absolutepath_len = currentpath_len + relativepath_len + 2; + + absolute_path = GF_CALLOC(1, max_absolutepath_len, gf_common_mt_char); + if (!absolute_path) { + ret = -ENOMEM; + goto err; + } + absolute_path[0] = '\0'; + + /* If current path is root i.e contains only "/", we do not + * need to copy it + */ + if (strcmp(current_path, "/") != 0) { + strcpy(absolute_path, current_path); + + /* We trim '/' at the end for easier string manipulation */ + gf_path_strip_trailing_slashes(absolute_path); + } + + /* Used to spilt relative path based on '/' */ + component = gf_strdup(relative_path); + if (!component) { + ret = -ENOMEM; + goto err; + } + + /* In the relative path, we want to consider ".." and "." + * if token is ".." , we just need to reduce one level hierarchy + * if token is "." , we just ignore it + * if token is NULL , end of relative path + * if absolute path becomes '\0' and still "..", then it is a bad + * relative path, it points to out of boundary area and stop + * building the absolute path + * All other cases we just concatenate token to the absolute path + */ + for (token = strtok_r(component, "/", &saveptr), + end = strchr(absolute_path, '\0'); + token; token = strtok_r(NULL, "/", &saveptr)) { + if (strcmp(token, ".") == 0) + continue; + + else if (strcmp(token, "..") == 0) { + if (absolute_path[0] == '\0') { + ret = -EACCES; goto err; - } - - /* It is maximum possible value for absolute path */ - max_absolutepath_len = currentpath_len + relativepath_len + 2; - - absolute_path = GF_CALLOC (1, max_absolutepath_len, gf_common_mt_char); - if (!absolute_path) { - ret = -ENOMEM; - goto err; - } - absolute_path[0] = '\0'; - - /* If current path is root i.e contains only "/", we do not - * need to copy it - */ - if (strcmp (current_path, "/") != 0) { - strcpy (absolute_path, current_path); - - /* We trim '/' at the end for easier string manipulation */ - gf_path_strip_trailing_slashes (absolute_path); - } - - /* Used to spilt relative path based on '/' */ - component = gf_strdup (relative_path); - if (!component) { - ret = -ENOMEM; - goto err; - } + } - /* In the relative path, we want to consider ".." and "." - * if token is ".." , we just need to reduce one level hierarchy - * if token is "." , we just ignore it - * if token is NULL , end of relative path - * if absolute path becomes '\0' and still "..", then it is a bad - * relative path, it points to out of boundary area and stop - * building the absolute path - * All other cases we just concatenate token to the absolute path - */ - for (token = strtok_r (component, "/", &saveptr), - end = strchr (absolute_path, '\0'); token; - token = strtok_r (NULL, "/", &saveptr)) { - if (strcmp (token, ".") == 0) - continue; - - else if (strcmp (token, "..") == 0) { - - if (absolute_path[0] == '\0') { - ret = -EACCES; - goto err; - } - - end = strrchr (absolute_path, '/'); - *end = '\0'; - } else { - ret = snprintf (end, max_absolutepath_len - - strlen (absolute_path), "/%s", token); - end = strchr (absolute_path , '\0'); - } + end = strrchr(absolute_path, '/'); + *end = '\0'; + } else { + ret = snprintf(end, max_absolutepath_len - strlen(absolute_path), + "/%s", token); + end = strchr(absolute_path, '\0'); } + } - if (strlen (absolute_path) > PATH_MAX) { - ret = -EINVAL; - goto err; - } - *path = gf_strdup (absolute_path); + if (strlen(absolute_path) > PATH_MAX) { + ret = -EINVAL; + goto err; + } + *path = gf_strdup(absolute_path); err: - if (component) - GF_FREE (component); - if (absolute_path) - GF_FREE (absolute_path); - return ret; + if (component) + GF_FREE(component); + if (absolute_path) + GF_FREE(absolute_path); + return ret; } /* This is an utility function which will recursively delete @@ -4581,69 +4570,85 @@ err: * @return 0 on success and -1 on failure. */ int -recursive_rmdir (const char *delete_path) -{ - int ret = -1; - char path[PATH_MAX] = {0,}; - struct stat st = {0,}; - DIR *dir = NULL; - struct dirent *entry = NULL; - struct dirent scratch[2] = {{0,},}; - xlator_t *this = NULL; - - this = THIS; - GF_ASSERT (this); - GF_VALIDATE_OR_GOTO (this->name, delete_path, out); - - dir = sys_opendir (delete_path); - if (!dir) { - gf_msg_debug (this->name, 0, "Failed to open directory %s. " - "Reason : %s", delete_path, strerror (errno)); - ret = 0; - goto out; - } +recursive_rmdir(const char *delete_path) +{ + int ret = -1; + char path[PATH_MAX] = { + 0, + }; + struct stat st = { + 0, + }; + DIR *dir = NULL; + struct dirent *entry = NULL; + struct dirent scratch[2] = { + { + 0, + }, + }; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT(this); + GF_VALIDATE_OR_GOTO(this->name, delete_path, out); + + dir = sys_opendir(delete_path); + if (!dir) { + gf_msg_debug(this->name, 0, + "Failed to open directory %s. " + "Reason : %s", + delete_path, strerror(errno)); + ret = 0; + goto out; + } - GF_SKIP_IRRELEVANT_ENTRIES (entry, dir, scratch); - while (entry) { - snprintf (path, PATH_MAX, "%s/%s", delete_path, entry->d_name); - ret = sys_lstat (path, &st); - if (ret == -1) { - gf_msg_debug (this->name, 0, "Failed to stat entry %s :" - " %s", path, strerror (errno)); - (void) sys_closedir (dir); - goto out; - } - - if (S_ISDIR (st.st_mode)) - ret = recursive_rmdir (path); - else - ret = sys_unlink (path); - - if (ret) { - gf_msg_debug (this->name, 0, " Failed to remove %s. " - "Reason : %s", path, strerror (errno)); - } - - gf_msg_debug (this->name, 0, "%s %s", ret ? - "Failed to remove" : "Removed", entry->d_name); - - GF_SKIP_IRRELEVANT_ENTRIES (entry, dir, scratch); + GF_SKIP_IRRELEVANT_ENTRIES(entry, dir, scratch); + while (entry) { + snprintf(path, PATH_MAX, "%s/%s", delete_path, entry->d_name); + ret = sys_lstat(path, &st); + if (ret == -1) { + gf_msg_debug(this->name, 0, + "Failed to stat entry %s :" + " %s", + path, strerror(errno)); + (void)sys_closedir(dir); + goto out; } - ret = sys_closedir (dir); - if (ret) { - gf_msg_debug (this->name, 0, "Failed to close dir %s. Reason :" - " %s", delete_path, strerror (errno)); - } + if (S_ISDIR(st.st_mode)) + ret = recursive_rmdir(path); + else + ret = sys_unlink(path); - ret = sys_rmdir (delete_path); if (ret) { - gf_msg_debug (this->name, 0, "Failed to rmdir: %s,err: %s", - delete_path, strerror (errno)); + gf_msg_debug(this->name, 0, + " Failed to remove %s. " + "Reason : %s", + path, strerror(errno)); } + gf_msg_debug(this->name, 0, "%s %s", + ret ? "Failed to remove" : "Removed", entry->d_name); + + GF_SKIP_IRRELEVANT_ENTRIES(entry, dir, scratch); + } + + ret = sys_closedir(dir); + if (ret) { + gf_msg_debug(this->name, 0, + "Failed to close dir %s. Reason :" + " %s", + delete_path, strerror(errno)); + } + + ret = sys_rmdir(delete_path); + if (ret) { + gf_msg_debug(this->name, 0, "Failed to rmdir: %s,err: %s", delete_path, + strerror(errno)); + } + out: - return ret; + return ret; } /* * Input: Array of strings 'array' terminating in NULL @@ -4652,197 +4657,198 @@ out: * Output: Index of the element in the array if found, '-1' otherwise */ int -gf_get_index_by_elem (char **array, char *elem) +gf_get_index_by_elem(char **array, char *elem) { - int i = 0; + int i = 0; - for (i = 0; array[i]; i++) { - if (strcmp (elem, array[i]) == 0) - return i; - } + for (i = 0; array[i]; i++) { + if (strcmp(elem, array[i]) == 0) + return i; + } - return -1; + return -1; } static int -get_pathinfo_host (char *pathinfo, char *hostname, size_t size) +get_pathinfo_host(char *pathinfo, char *hostname, size_t size) { - char *start = NULL; - char *end = NULL; - int ret = -1; - int i = 0; + char *start = NULL; + char *end = NULL; + int ret = -1; + int i = 0; - if (!pathinfo) - goto out; + if (!pathinfo) + goto out; - start = strchr (pathinfo, ':'); - if (!start) - goto out; + start = strchr(pathinfo, ':'); + if (!start) + goto out; - end = strrchr (pathinfo, ':'); - if (start == end) - goto out; + end = strrchr(pathinfo, ':'); + if (start == end) + goto out; - memset (hostname, 0, size); - i = 0; - while (++start != end) - hostname[i++] = *start; - ret = 0; + memset(hostname, 0, size); + i = 0; + while (++start != end) + hostname[i++] = *start; + ret = 0; out: - return ret; + return ret; } /*Note: 'pathinfo' should be gathered only from one brick*/ int -glusterfs_is_local_pathinfo (char *pathinfo, gf_boolean_t *is_local) +glusterfs_is_local_pathinfo(char *pathinfo, gf_boolean_t *is_local) { - int ret = 0; - char pathinfohost[1024] = {0}; - char localhost[1024] = {0}; + int ret = 0; + char pathinfohost[1024] = {0}; + char localhost[1024] = {0}; - *is_local = _gf_false; - ret = get_pathinfo_host (pathinfo, pathinfohost, sizeof (pathinfohost)); - if (ret) - goto out; + *is_local = _gf_false; + ret = get_pathinfo_host(pathinfo, pathinfohost, sizeof(pathinfohost)); + if (ret) + goto out; - ret = gethostname (localhost, sizeof (localhost)); - if (ret) - goto out; + ret = gethostname(localhost, sizeof(localhost)); + if (ret) + goto out; - if (!strcmp (localhost, pathinfohost)) - *is_local = _gf_true; + if (!strcmp(localhost, pathinfohost)) + *is_local = _gf_true; out: - return ret; + return ret; } ssize_t -gf_nread (int fd, void *buf, size_t count) -{ - ssize_t ret = 0; - ssize_t read_bytes = 0; - - for (read_bytes = 0; read_bytes < count; read_bytes += ret) { - ret = sys_read (fd, buf + read_bytes, count - read_bytes); - if (ret == 0) { - break; - } else if (ret < 0) { - if (errno == EINTR) - ret = 0; - else - goto out; - } +gf_nread(int fd, void *buf, size_t count) +{ + ssize_t ret = 0; + ssize_t read_bytes = 0; + + for (read_bytes = 0; read_bytes < count; read_bytes += ret) { + ret = sys_read(fd, buf + read_bytes, count - read_bytes); + if (ret == 0) { + break; + } else if (ret < 0) { + if (errno == EINTR) + ret = 0; + else + goto out; } + } - ret = read_bytes; + ret = read_bytes; out: - return ret; + return ret; } ssize_t -gf_nwrite (int fd, const void *buf, size_t count) -{ - ssize_t ret = 0; - ssize_t written = 0; - - for (written = 0; written != count; written += ret) { - ret = sys_write (fd, buf + written, count - written); - if (ret < 0) { - if (errno == EINTR) - ret = 0; - else - goto out; - } +gf_nwrite(int fd, const void *buf, size_t count) +{ + ssize_t ret = 0; + ssize_t written = 0; + + for (written = 0; written != count; written += ret) { + ret = sys_write(fd, buf + written, count - written); + if (ret < 0) { + if (errno == EINTR) + ret = 0; + else + goto out; } + } - ret = written; + ret = written; out: - return ret; + return ret; } void -gf_free_mig_locks (lock_migration_info_t *locks) +gf_free_mig_locks(lock_migration_info_t *locks) { - lock_migration_info_t *current = NULL; - lock_migration_info_t *temp = NULL; + lock_migration_info_t *current = NULL; + lock_migration_info_t *temp = NULL; - if (!locks) - return; + if (!locks) + return; - if (list_empty (&locks->list)) - return; + if (list_empty(&locks->list)) + return; - list_for_each_entry_safe (current, temp, &locks->list, list) { - list_del_init (¤t->list); - GF_FREE (current->client_uid); - GF_FREE (current); - } + list_for_each_entry_safe(current, temp, &locks->list, list) + { + list_del_init(¤t->list); + GF_FREE(current->client_uid); + GF_FREE(current); + } } void -_mask_cancellation (void) +_mask_cancellation(void) { - (void) pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL); + (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); } void -_unmask_cancellation (void) +_unmask_cancellation(void) { - (void) pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL); + (void)pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); } /* This is a wrapper function to add a pointer to a list, * which doesn't contain list member */ -struct list_node* -_list_node_add (void *ptr, struct list_head *list, +struct list_node * +_list_node_add(void *ptr, struct list_head *list, int (*compare)(struct list_head *, struct list_head *)) { - struct list_node *node = NULL; + struct list_node *node = NULL; - if (ptr == NULL || list == NULL) - goto out; + if (ptr == NULL || list == NULL) + goto out; - node = GF_CALLOC (1, sizeof (struct list_node), gf_common_list_node); + node = GF_CALLOC(1, sizeof(struct list_node), gf_common_list_node); - if (node == NULL) - goto out; + if (node == NULL) + goto out; - node->ptr = ptr; - if (compare) - list_add_order (&node->list, list, compare); - else - list_add_tail (&node->list, list); + node->ptr = ptr; + if (compare) + list_add_order(&node->list, list, compare); + else + list_add_tail(&node->list, list); out: - return node; + return node; } -struct list_node* -list_node_add (void *ptr, struct list_head *list) +struct list_node * +list_node_add(void *ptr, struct list_head *list) { - return _list_node_add (ptr, list, NULL); + return _list_node_add(ptr, list, NULL); } -struct list_node* -list_node_add_order (void *ptr, struct list_head *list, - int (*compare)(struct list_head *, struct list_head *)) +struct list_node * +list_node_add_order(void *ptr, struct list_head *list, + int (*compare)(struct list_head *, struct list_head *)) { - return _list_node_add (ptr, list, compare); + return _list_node_add(ptr, list, compare); } void -list_node_del (struct list_node *node) +list_node_del(struct list_node *node) { - if (node == NULL) - return; + if (node == NULL) + return; - list_del_init (&node->list); - GF_FREE (node); + list_del_init(&node->list); + GF_FREE(node); } const char * -fop_enum_to_pri_string (glusterfs_fop_t fop) +fop_enum_to_pri_string(glusterfs_fop_t fop) { - switch (fop) { + switch (fop) { case GF_FOP_OPEN: case GF_FOP_STAT: case GF_FOP_FSTAT: @@ -4857,7 +4863,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop) case GF_FOP_SETACTIVELK: case GF_FOP_ICREATE: case GF_FOP_NAMELINK: - return "HIGH"; + return "HIGH"; case GF_FOP_CREATE: case GF_FOP_FLUSH: @@ -4883,7 +4889,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop) case GF_FOP_FREMOVEXATTR: case GF_FOP_IPC: case GF_FOP_LEASE: - return "NORMAL"; + return "NORMAL"; case GF_FOP_READ: case GF_FOP_WRITE: @@ -4897,7 +4903,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop) case GF_FOP_ZEROFILL: case GF_FOP_FALLOCATE: case GF_FOP_SEEK: - return "LOW"; + return "LOW"; case GF_FOP_NULL: case GF_FOP_FORGET: @@ -4906,187 +4912,184 @@ fop_enum_to_pri_string (glusterfs_fop_t fop) case GF_FOP_GETSPEC: case GF_FOP_MAXVALUE: case GF_FOP_DISCARD: - return "LEAST"; + return "LEAST"; default: - return "UNKNOWN"; - } + return "UNKNOWN"; + } } const char * -gf_inode_type_to_str (ia_type_t type) +gf_inode_type_to_str(ia_type_t type) { - static const char *const str_ia_type[] = { - "UNKNOWN", - "REGULAR FILE", - "DIRECTORY", - "LINK", - "BLOCK DEVICE", - "CHARACTER DEVICE", - "PIPE", - "SOCKET"}; - return str_ia_type[type]; + static const char *const str_ia_type[] = { + "UNKNOWN", "REGULAR FILE", "DIRECTORY", "LINK", + "BLOCK DEVICE", "CHARACTER DEVICE", "PIPE", "SOCKET"}; + return str_ia_type[type]; } gf_boolean_t -gf_is_zero_filled_stat (struct iatt *buf) +gf_is_zero_filled_stat(struct iatt *buf) { - if (!buf) - return 1; + if (!buf) + return 1; - /* Do not use st_dev because it is transformed to store the xlator id - * in place of the device number. Do not use st_ino because by this time - * we've already mapped the root ino to 1 so it is not guaranteed to be - * 0. - */ - if ((buf->ia_nlink == 0) && (buf->ia_ctime == 0)) - return 1; + /* Do not use st_dev because it is transformed to store the xlator id + * in place of the device number. Do not use st_ino because by this time + * we've already mapped the root ino to 1 so it is not guaranteed to be + * 0. + */ + if ((buf->ia_nlink == 0) && (buf->ia_ctime == 0)) + return 1; - return 0; + return 0; } void -gf_zero_fill_stat (struct iatt *buf) +gf_zero_fill_stat(struct iatt *buf) { - buf->ia_nlink = 0; - buf->ia_ctime = 0; + buf->ia_nlink = 0; + buf->ia_ctime = 0; } gf_boolean_t -gf_is_valid_xattr_namespace (char *key) +gf_is_valid_xattr_namespace(char *key) { - static char *xattr_namespaces[] = {"trusted.", "security.", "system.", - "user.", NULL }; - int i = 0; + static char *xattr_namespaces[] = {"trusted.", "security.", "system.", + "user.", NULL}; + int i = 0; - for (i = 0; xattr_namespaces[i]; i++) { - if (strncmp (key, xattr_namespaces[i], - strlen (xattr_namespaces[i])) == 0) - return _gf_true; - } + for (i = 0; xattr_namespaces[i]; i++) { + if (strncmp(key, xattr_namespaces[i], strlen(xattr_namespaces[i])) == 0) + return _gf_true; + } - return _gf_false; + return _gf_false; } ino_t -gfid_to_ino (uuid_t gfid) +gfid_to_ino(uuid_t gfid) { - ino_t ino = 0; - int32_t i; + ino_t ino = 0; + int32_t i; - for (i = 8; i < 16; i++) { - ino <<= 8; - ino += (uint8_t)gfid[i]; - } + for (i = 8; i < 16; i++) { + ino <<= 8; + ino += (uint8_t)gfid[i]; + } - return ino; + return ino; } int -gf_bits_count (uint64_t n) +gf_bits_count(uint64_t n) { - int val = 0; + int val = 0; #if defined(__GNUC__) || defined(__clang__) - val = __builtin_popcountll (n); + val = __builtin_popcountll(n); #else - n -= (n >> 1) & 0x5555555555555555ULL; - n = ((n >> 2) & 0x3333333333333333ULL) + (n & 0x3333333333333333ULL); - n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0FULL; - n += n >> 8; - n += n >> 16; - n += n >> 32; - val = n & 0xFF; + n -= (n >> 1) & 0x5555555555555555ULL; + n = ((n >> 2) & 0x3333333333333333ULL) + (n & 0x3333333333333333ULL); + n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0FULL; + n += n >> 8; + n += n >> 16; + n += n >> 32; + val = n & 0xFF; #endif - return val; + return val; } int -gf_bits_index (uint64_t n) +gf_bits_index(uint64_t n) { #if defined(__GNUC__) || defined(__clang__) - return __builtin_ffsll (n) - 1; + return __builtin_ffsll(n) - 1; #else - return ffsll (n) - 1; + return ffsll(n) - 1; #endif } -const char* -gf_fop_string (glusterfs_fop_t fop) +const char * +gf_fop_string(glusterfs_fop_t fop) { - if ((fop > GF_FOP_NULL) && (fop < GF_FOP_MAXVALUE)) - return gf_fop_list[fop]; - return "INVALID"; + if ((fop > GF_FOP_NULL) && (fop < GF_FOP_MAXVALUE)) + return gf_fop_list[fop]; + return "INVALID"; } int -gf_fop_int (char *fop) +gf_fop_int(char *fop) { - int i = 0; + int i = 0; - for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) { - if (strcasecmp (fop, gf_fop_list[i]) == 0) - return i; - } - return -1; + for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) { + if (strcasecmp(fop, gf_fop_list[i]) == 0) + return i; + } + return -1; } int -close_fds_except (int *fdv, size_t count) +close_fds_except(int *fdv, size_t count) { - int i = 0; - size_t j = 0; - gf_boolean_t should_close = _gf_true; + int i = 0; + size_t j = 0; + gf_boolean_t should_close = _gf_true; #ifdef GF_LINUX_HOST_OS - DIR *d = NULL; - struct dirent *de = NULL; - struct dirent scratch[2] = {{0,},}; - char *e = NULL; - - d = sys_opendir ("/proc/self/fd"); - if (!d) - return -1; - - for (;;) { - should_close = _gf_true; - - errno = 0; - de = sys_readdir (d, scratch); - if (!de || errno != 0) - break; - i = strtoul (de->d_name, &e, 10); - if (*e != '\0' || i == dirfd (d)) - continue; - - for (j = 0; j < count; j++) { - if (i == fdv[j]) { - should_close = _gf_false; - break; - } - } - if (should_close) - sys_close (i); - } - sys_closedir (d); -#else /* !GF_LINUX_HOST_OS */ - struct rlimit rl; - int ret = -1; + DIR *d = NULL; + struct dirent *de = NULL; + struct dirent scratch[2] = { + { + 0, + }, + }; + char *e = NULL; + + d = sys_opendir("/proc/self/fd"); + if (!d) + return -1; + + for (;;) { + should_close = _gf_true; - ret = getrlimit (RLIMIT_NOFILE, &rl); - if (ret) - return ret; - - for (i = 0; i < rl.rlim_cur; i++) { - should_close = _gf_true; - for (j = 0; j < count; j++) { - if (i == fdv[j]) { - should_close = _gf_false; - break; - } - } - if (should_close) - sys_close (i); + errno = 0; + de = sys_readdir(d, scratch); + if (!de || errno != 0) + break; + i = strtoul(de->d_name, &e, 10); + if (*e != '\0' || i == dirfd(d)) + continue; + + for (j = 0; j < count; j++) { + if (i == fdv[j]) { + should_close = _gf_false; + break; + } + } + if (should_close) + sys_close(i); + } + sys_closedir(d); +#else /* !GF_LINUX_HOST_OS */ + struct rlimit rl; + int ret = -1; + + ret = getrlimit(RLIMIT_NOFILE, &rl); + if (ret) + return ret; + + for (i = 0; i < rl.rlim_cur; i++) { + should_close = _gf_true; + for (j = 0; j < count; j++) { + if (i == fdv[j]) { + should_close = _gf_false; + break; + } } + if (should_close) + sys_close(i); + } #endif /* !GF_LINUX_HOST_OS */ - return 0; + return 0; } /** @@ -5106,105 +5109,129 @@ close_fds_except (int *fdv, size_t count) * failure: -1 */ int -gf_getgrouplist (const char *user, gid_t group, gid_t **groups) +gf_getgrouplist(const char *user, gid_t group, gid_t **groups) { - int ret = -1; - int ngroups = SMALL_GROUP_COUNT; + int ret = -1; + int ngroups = SMALL_GROUP_COUNT; - *groups = GF_CALLOC (sizeof (gid_t), ngroups, gf_common_mt_groups_t); - if (!*groups) - return -1; + *groups = GF_CALLOC(sizeof(gid_t), ngroups, gf_common_mt_groups_t); + if (!*groups) + return -1; - /* - * We are running getgrouplist() in a loop until we succeed (or hit - * certain exit conditions, see the comments below). This is because - * the indicated number of auxiliary groups that we obtain in case of - * the failure of the first invocation is not guaranteed to keep its - * validity upon the next invocation with a gid buffer of that size. - */ - for (;;) { - int ngroups_old = ngroups; - ret = getgrouplist (user, group, *groups, &ngroups); - if (ret != -1) - break; - - if (ngroups >= GF_MAX_AUX_GROUPS) { - /* - * This should not happen as GF_MAX_AUX_GROUPS is set - * to the max value of number of supported auxiliary - * groups across all platforms supported by GlusterFS. - * However, if it still happened some way, we wouldn't - * care about the incompleteness of the result, we'd - * just go on with what we got. - */ - return GF_MAX_AUX_GROUPS; - } else if (ngroups <= ngroups_old) { - /* - * There is an edge case that getgrouplist() fails but - * ngroups remains the same. This is actually not - * specified in getgrouplist(3), but implementations - * can do this upon internal failure[1]. To avoid - * falling into an infinite loop when this happens, we - * break the loop if the getgrouplist call failed - * without an increase in the indicated group number. - * - * [1] https://sourceware.org/git/?p=glibc.git;a=blob;f=grp/initgroups.c;hb=refs/heads/release/2.25/master#l168 - */ - GF_FREE (*groups); - return -1; - } - - *groups = GF_REALLOC (*groups, ngroups * sizeof (gid_t)); - if (!*groups) - return -1; - } - return ret; + /* + * We are running getgrouplist() in a loop until we succeed (or hit + * certain exit conditions, see the comments below). This is because + * the indicated number of auxiliary groups that we obtain in case of + * the failure of the first invocation is not guaranteed to keep its + * validity upon the next invocation with a gid buffer of that size. + */ + for (;;) { + int ngroups_old = ngroups; + ret = getgrouplist(user, group, *groups, &ngroups); + if (ret != -1) + break; + + if (ngroups >= GF_MAX_AUX_GROUPS) { + /* + * This should not happen as GF_MAX_AUX_GROUPS is set + * to the max value of number of supported auxiliary + * groups across all platforms supported by GlusterFS. + * However, if it still happened some way, we wouldn't + * care about the incompleteness of the result, we'd + * just go on with what we got. + */ + return GF_MAX_AUX_GROUPS; + } else if (ngroups <= ngroups_old) { + /* + * There is an edge case that getgrouplist() fails but + * ngroups remains the same. This is actually not + * specified in getgrouplist(3), but implementations + * can do this upon internal failure[1]. To avoid + * falling into an infinite loop when this happens, we + * break the loop if the getgrouplist call failed + * without an increase in the indicated group number. + * + * [1] + * https://sourceware.org/git/?p=glibc.git;a=blob;f=grp/initgroups.c;hb=refs/heads/release/2.25/master#l168 + */ + GF_FREE(*groups); + return -1; + } + + *groups = GF_REALLOC(*groups, ngroups * sizeof(gid_t)); + if (!*groups) + return -1; + } + return ret; } int -glusterfs_compute_sha256 (const unsigned char *content, size_t size, - char *sha256_hash) { - SHA256_CTX sha256; +glusterfs_compute_sha256(const unsigned char *content, size_t size, + char *sha256_hash) +{ + SHA256_CTX sha256; - SHA256_Init (&sha256); - SHA256_Update (&sha256, (const unsigned char *) (content), size); - SHA256_Final ((unsigned char *) sha256_hash, &sha256); + SHA256_Init(&sha256); + SHA256_Update(&sha256, (const unsigned char *)(content), size); + SHA256_Final((unsigned char *)sha256_hash, &sha256); - return 0; + return 0; } -char* -get_struct_variable (int mem_num, gf_gsync_status_t *sts_val) -{ - switch (mem_num) { - case 0: return (sts_val->node); - case 1: return (sts_val->master); - case 2: return (sts_val->brick); - case 3: return (sts_val->slave_user); - case 4: return (sts_val->slave); - case 5: return (sts_val->slave_node); - case 6: return (sts_val->worker_status); - case 7: return (sts_val->crawl_status); - case 8: return (sts_val->last_synced); - case 9: return (sts_val->entry); - case 10: return (sts_val->data); - case 11: return (sts_val->meta); - case 12: return (sts_val->failures); - case 13: return (sts_val->checkpoint_time); - case 14: return (sts_val->checkpoint_completed); - case 15: return (sts_val->checkpoint_completion_time); - case 16: return (sts_val->brick_host_uuid); - case 17: return (sts_val->last_synced_utc); - case 18: return (sts_val->checkpoint_time_utc); - case 19: return (sts_val->checkpoint_completion_time_utc); - case 20: return (sts_val->slavekey); - case 21: return (sts_val->session_slave); +char * +get_struct_variable(int mem_num, gf_gsync_status_t *sts_val) +{ + switch (mem_num) { + case 0: + return (sts_val->node); + case 1: + return (sts_val->master); + case 2: + return (sts_val->brick); + case 3: + return (sts_val->slave_user); + case 4: + return (sts_val->slave); + case 5: + return (sts_val->slave_node); + case 6: + return (sts_val->worker_status); + case 7: + return (sts_val->crawl_status); + case 8: + return (sts_val->last_synced); + case 9: + return (sts_val->entry); + case 10: + return (sts_val->data); + case 11: + return (sts_val->meta); + case 12: + return (sts_val->failures); + case 13: + return (sts_val->checkpoint_time); + case 14: + return (sts_val->checkpoint_completed); + case 15: + return (sts_val->checkpoint_completion_time); + case 16: + return (sts_val->brick_host_uuid); + case 17: + return (sts_val->last_synced_utc); + case 18: + return (sts_val->checkpoint_time_utc); + case 19: + return (sts_val->checkpoint_completion_time_utc); + case 20: + return (sts_val->slavekey); + case 21: + return (sts_val->session_slave); default: - goto out; - } + goto out; + } out: - return NULL; + return NULL; } /* * Safe wrapper function for strncpy. @@ -5214,73 +5241,73 @@ out: */ char * -gf_strncpy (char *dest, const char *src, const size_t dest_size) +gf_strncpy(char *dest, const char *src, const size_t dest_size) { - strncpy (dest, src, dest_size - 1); - dest[dest_size - 1] = '\0'; - return dest; + strncpy(dest, src, dest_size - 1); + dest[dest_size - 1] = '\0'; + return dest; } int -gf_replace_old_iatt_in_dict (dict_t *xdata) +gf_replace_old_iatt_in_dict(dict_t *xdata) { - int ret; - struct old_iatt *o_iatt; /* old iatt structure */ - struct iatt *c_iatt; /* current iatt */ + int ret; + struct old_iatt *o_iatt; /* old iatt structure */ + struct iatt *c_iatt; /* current iatt */ - if (!xdata) { - return 0; - } + if (!xdata) { + return 0; + } - ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **)&c_iatt); - if (ret < 0) { - return 0; - } + ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&c_iatt); + if (ret < 0) { + return 0; + } - o_iatt = GF_CALLOC (1, sizeof (struct old_iatt), gf_common_mt_char); - if (!o_iatt) { - return -1; - } + o_iatt = GF_CALLOC(1, sizeof(struct old_iatt), gf_common_mt_char); + if (!o_iatt) { + return -1; + } - oldiatt_from_iatt (o_iatt, c_iatt); + oldiatt_from_iatt(o_iatt, c_iatt); - ret = dict_set_bin (xdata, DHT_IATT_IN_XDATA_KEY, o_iatt, - sizeof (struct old_iatt)); - if (ret) { - GF_FREE (o_iatt); - } + ret = dict_set_bin(xdata, DHT_IATT_IN_XDATA_KEY, o_iatt, + sizeof(struct old_iatt)); + if (ret) { + GF_FREE(o_iatt); + } - return ret; + return ret; } int -gf_replace_new_iatt_in_dict (dict_t *xdata) +gf_replace_new_iatt_in_dict(dict_t *xdata) { - int ret; - struct old_iatt *o_iatt; /* old iatt structure */ - struct iatt *c_iatt; /* new iatt */ + int ret; + struct old_iatt *o_iatt; /* old iatt structure */ + struct iatt *c_iatt; /* new iatt */ - if (!xdata) { - return 0; - } + if (!xdata) { + return 0; + } - ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **)&o_iatt); - if (ret < 0) { - return 0; - } + ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&o_iatt); + if (ret < 0) { + return 0; + } - c_iatt = GF_CALLOC (1, sizeof (struct iatt), gf_common_mt_char); - if (!c_iatt) { - return -1; - } + c_iatt = GF_CALLOC(1, sizeof(struct iatt), gf_common_mt_char); + if (!c_iatt) { + return -1; + } - iatt_from_oldiatt (c_iatt, o_iatt); + iatt_from_oldiatt(c_iatt, o_iatt); - ret = dict_set_bin (xdata, DHT_IATT_IN_XDATA_KEY, c_iatt, - sizeof (struct iatt)); - if (ret) { - GF_FREE (c_iatt); - } + ret = dict_set_bin(xdata, DHT_IATT_IN_XDATA_KEY, c_iatt, + sizeof(struct iatt)); + if (ret) { + GF_FREE(c_iatt); + } - return ret; + return ret; } |