本文整理汇总了C++中GF_FREE函数的典型用法代码示例。如果您正苦于以下问题：C++ GF_FREE函数的具体用法？C++ GF_FREE怎么用？C++ GF_FREE使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了GF_FREE函数的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的C++代码示例。
示例1: event_pool_new_poll
static struct event_pool *
event_pool_new_poll (int count, int eventthreadcount)
{
struct event_pool *event_pool = NULL;
int ret = -1;
event_pool = GF_CALLOC (1, sizeof (*event_pool),
gf_common_mt_event_pool);
if (!event_pool)
return NULL;
event_pool->count = count;
event_pool->reg = GF_CALLOC (event_pool->count,
sizeof (*event_pool->reg),
gf_common_mt_reg);
if (!event_pool->reg) {
GF_FREE (event_pool);
return NULL;
}
pthread_mutex_init (&event_pool->mutex, NULL);
ret = pipe (event_pool->breaker);
if (ret == -1) {
gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_PIPE_CREATE_FAILED,
"pipe creation failed");
GF_FREE (event_pool->reg);
GF_FREE (event_pool);
return NULL;
}
ret = fcntl (event_pool->breaker[0], F_SETFL, O_NONBLOCK);
if (ret == -1) {
gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
"could not set pipe to non blocking mode");
close (event_pool->breaker[0]);
close (event_pool->breaker[1]);
event_pool->breaker[0] = event_pool->breaker[1] = -1;
GF_FREE (event_pool->reg);
GF_FREE (event_pool);
return NULL;
}
ret = fcntl (event_pool->breaker[1], F_SETFL, O_NONBLOCK);
if (ret == -1) {
gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
"could not set pipe to non blocking mode");
close (event_pool->breaker[0]);
close (event_pool->breaker[1]);
event_pool->breaker[0] = event_pool->breaker[1] = -1;
GF_FREE (event_pool->reg);
GF_FREE (event_pool);
return NULL;
}
ret = event_register_poll (event_pool, event_pool->breaker[0],
__flush_fd, NULL, 1, 0);
if (ret == -1) {
gf_msg ("poll", GF_LOG_ERROR, 0, LG_MSG_REGISTER_PIPE_FAILED,
"could not register pipe fd with poll event loop");
close (event_pool->breaker[0]);
close (event_pool->breaker[1]);
event_pool->breaker[0] = event_pool->breaker[1] = -1;
GF_FREE (event_pool->reg);
GF_FREE (event_pool);
return NULL;
}
if (eventthreadcount > 1) {
gf_msg ("poll", GF_LOG_INFO, 0,
LG_MSG_POLL_IGNORE_MULTIPLE_THREADS, "Currently poll "
"does not use multiple event processing threads, "
"thread count (%d) ignored", eventthreadcount);
}
return event_pool;
}
开发者ID:rajeshjoseph，项目名称:glusterfs，代码行数:84，代码来源:event-poll.c
示例2: pidinfo
pid_t
pidinfo(pid_t pid, char **name)
{
char buf[NAME_MAX * 2] = {
0,
};
FILE *f = NULL;
char path[PATH_MAX] = {
0,
};
char *p = NULL;
int ret = 0;
snprintf(path, sizeof path, PROC "/%d/status", pid);
f = fopen(path, "r");
if (!f)
return -1;
if (name)
*name = NULL;
for (;;) {
size_t len;
memset(buf, 0, sizeof(buf));
if (fgets(buf, sizeof(buf), f) == NULL || (len = strlen(buf)) == 0 ||
buf[len - 1] != '\n') {
pid = -1;
goto out;
}
buf[len - 1] = '\0';
if (name && !*name) {
p = strtail(buf, "Name:");
if (p) {
while (isspace(*++p))
;
*name = gf_strdup(p);
if (!*name) {
pid = -2;
goto out;
}
continue;
}
}
p = strtail(buf, "PPid:");
if (p)
break;
}
while (isspace(*++p))
;
ret = gf_string2int(p, &pid);
if (ret == -1)
pid = -1;
out:
fclose(f);
if (pid == -1 && name && *name)
GF_FREE(*name);
if (pid == -2)
fprintf(stderr, "out of memory\n");
return pid;
}
开发者ID:amarts，项目名称:glusterfs，代码行数:64，代码来源:procdiggy.c
示例3: readline_destructor
static void
readline_destructor (void *ptr)
{
GF_FREE (ptr);
}
开发者ID:Jingle-Wang，项目名称:glusterfs，代码行数:5，代码来源:gf-changelog-helpers.c
示例4: gf_auth
auth_result_t
gf_auth (dict_t *input_params, dict_t *config_params)
{
auth_result_t result = AUTH_DONT_CARE;
int ret = 0;
char *name = NULL;
char *searchstr = NULL;
peer_info_t *peer_info = NULL;
data_t *peer_info_data = NULL;
data_t *allow_addr = NULL;
data_t *reject_addr = NULL;
char *addr_str = NULL;
char *tmp = NULL;
char *addr_cpy = NULL;
char *service = NULL;
uint16_t peer_port = 0;
char is_inet_sdp = 0;
char negate = 0;
char match = 0;
char peer_addr[UNIX_PATH_MAX];
char *type = NULL;
gf_boolean_t allow_insecure = _gf_false;
name = data_to_str (dict_get (input_params, "remote-subvolume"));
if (!name) {
gf_log ("authenticate/addr", GF_LOG_DEBUG,
"remote-subvolume not specified");
goto out;
}
ret = gf_asprintf (&searchstr, "auth.addr.%s.allow", name);
if (-1 == ret) {
gf_log ("auth/addr", GF_LOG_DEBUG,
"asprintf failed while setting search string");
goto out;
}
allow_addr = dict_get (config_params, searchstr);
GF_FREE (searchstr);
ret = gf_asprintf (&searchstr, "auth.addr.%s.reject", name);
if (-1 == ret) {
gf_log ("auth/addr", GF_LOG_ERROR,
"asprintf failed while setting search string");
goto out;
}
reject_addr = dict_get (config_params, searchstr);
GF_FREE (searchstr);
if (!allow_addr) {
/* TODO: backword compatibility */
ret = gf_asprintf (&searchstr, "auth.ip.%s.allow", name);
if (-1 == ret) {
gf_log ("auth/addr", GF_LOG_ERROR,
"asprintf failed while setting search string");
goto out;
}
allow_addr = dict_get (config_params, searchstr);
GF_FREE (searchstr);
}
if (!(allow_addr || reject_addr)) {
gf_log ("auth/addr", GF_LOG_DEBUG,
"none of the options auth.addr.%s.allow or "
"auth.addr.%s.reject specified, returning auth_dont_care",
name, name);
goto out;
}
peer_info_data = dict_get (input_params, "peer-info");
if (!peer_info_data) {
gf_log ("auth/addr", GF_LOG_ERROR,
"peer-info not present");
goto out;
}
peer_info = data_to_ptr (peer_info_data);
switch (((struct sockaddr *) &peer_info->sockaddr)->sa_family)
{
case AF_INET_SDP:
is_inet_sdp = 1;
((struct sockaddr *) &peer_info->sockaddr)->sa_family = AF_INET;
case AF_INET:
case AF_INET6:
{
strcpy (peer_addr, peer_info->identifier);
service = strrchr (peer_addr, ':');
*service = '\0';
service ++;
if (is_inet_sdp) {
((struct sockaddr *) &peer_info->sockaddr)->sa_family = AF_INET_SDP;
}
ret = dict_get_str (config_params, "rpc-auth-allow-insecure",
&type);
if (ret == 0) {
ret = gf_string2boolean (type, &allow_insecure);
//.........这里部分代码省略.........
开发者ID:alexbers，项目名称:glusterfs_experiments，代码行数:101，代码来源:addr.c
示例5: gf_resolve_ip6
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_log_callingfn ("resolver", GF_LOG_WARNING, "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_log ("resolver", GF_LOG_TRACE,
"flushing DNS cache");
}
if (!cache->first) {
char *port_str = NULL;
gf_log ("resolver", GF_LOG_TRACE,
"DNS cache not present, freshly probing hostname: %s",
hostname);
memset(&hints, 0, sizeof(hints));
hints.ai_family = family;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_ADDRCONFIG;
ret = gf_asprintf (&port_str, "%d", port);
if (-1 == ret) {
gf_log ("resolver", GF_LOG_ERROR, "asprintf failed");
return -1;
}
if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) != 0) {
gf_log ("resolver", GF_LOG_ERROR,
"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;
}
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_log ("resolver", GF_LOG_ERROR,
"getnameinfo failed (%s)", gai_strerror (ret));
goto err;
}
gf_log ("resolver", GF_LOG_DEBUG,
"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_log ("resolver", GF_LOG_ERROR,
"getnameinfo failed (%s)", gai_strerror (ret));
goto err;
}
gf_log ("resolver", GF_LOG_DEBUG,
"next DNS query will return: ip-%s port-%s", host, service);
}
return 0;
//.........这里部分代码省略.........
开发者ID:syoyo，项目名称:glusterfs，代码行数:101，代码来源:common-utils.c
示例6: transport_load
transport_t *
transport_load (dict_t *options,
xlator_t *xl)
{
struct transport *trans = NULL, *return_trans = NULL;
char *name = NULL;
void *handle = NULL;
char *type = NULL;
char str[] = "ERROR";
int32_t ret = -1;
int8_t is_tcp = 0, is_unix = 0, is_ibsdp = 0;
volume_opt_list_t *vol_opt = NULL;
GF_VALIDATE_OR_GOTO("transport", options, fail);
GF_VALIDATE_OR_GOTO("transport", xl, fail);
trans = GF_CALLOC (1, sizeof (struct transport),
gf_common_mt_transport);
GF_VALIDATE_OR_GOTO("transport", trans, fail);
trans->xl = xl;
type = str;
/* Backward compatibility */
ret = dict_get_str (options, "transport-type", &type);
if (ret < 0) {
ret = dict_set_str (options, "transport-type", "socket");
if (ret < 0)
gf_log ("dict", GF_LOG_DEBUG,
"setting transport-type failed");
gf_log ("transport", GF_LOG_WARNING,
"missing 'option transport-type'. defaulting to "
"\"socket\"");
} else {
{
/* Backword compatibility to handle * /client,
* * /server.
*/
char *tmp = strchr (type, '/');
if (tmp)
*tmp = '\0';
}
is_tcp = strcmp (type, "tcp");
is_unix = strcmp (type, "unix");
is_ibsdp = strcmp (type, "ib-sdp");
if ((is_tcp == 0) ||
(is_unix == 0) ||
(is_ibsdp == 0)) {
if (is_unix == 0)
ret = dict_set_str (options,
"transport.address-family",
"unix");
if (is_ibsdp == 0)
ret = dict_set_str (options,
"transport.address-family",
"inet-sdp");
if (ret < 0)
gf_log ("dict", GF_LOG_DEBUG,
"setting address-family failed");
ret = dict_set_str (options,
"transport-type", "socket");
if (ret < 0)
gf_log ("dict", GF_LOG_DEBUG,
"setting transport-type failed");
}
}
ret = dict_get_str (options, "transport-type", &type);
if (ret < 0) {
GF_FREE (trans);
gf_log ("transport", GF_LOG_ERROR,
"'option transport-type <xx>' missing in volume '%s'",
xl->name);
goto fail;
}
ret = gf_asprintf (&name, "%s/%s.so", TRANSPORTDIR, type);
if (-1 == ret) {
gf_log ("transport", GF_LOG_ERROR, "asprintf failed");
goto fail;
}
gf_log ("transport", GF_LOG_DEBUG,
"attempt to load file %s", name);
handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
if (handle == NULL) {
gf_log ("transport", GF_LOG_ERROR, "%s", dlerror ());
gf_log ("transport", GF_LOG_ERROR,
"volume '%s': transport-type '%s' is not valid or "
"not found on this machine",
xl->name, type);
GF_FREE (name);
GF_FREE (trans);
goto fail;
}
GF_FREE (name);
//.........这里部分代码省略.........
开发者ID:Gaurav-Gangalwar，项目名称:glusterfs，代码行数:101，代码来源:transport.c
示例7: glusterd_handle_mgmt_v3_unlock_fn
static int
glusterd_handle_mgmt_v3_unlock_fn (rpcsvc_request_t *req)
{
gd1_mgmt_v3_unlock_req lock_req = {{0},};
int32_t ret = -1;
glusterd_op_lock_ctx_t *ctx = NULL;
glusterd_peerinfo_t *peerinfo = NULL;
xlator_t *this = NULL;
gf_boolean_t is_synctasked = _gf_false;
gf_boolean_t free_ctx = _gf_false;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &lock_req,
(xdrproc_t)xdr_gd1_mgmt_v3_unlock_req);
if (ret < 0) {
gf_log (this->name, GF_LOG_ERROR, "Failed to decode unlock "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
gf_log (this->name, GF_LOG_DEBUG, "Received volume unlock req "
"from uuid: %s", uuid_utoa (lock_req.uuid));
if (glusterd_friend_find_by_uuid (lock_req.uuid, &peerinfo)) {
gf_log (this->name, GF_LOG_WARNING, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (lock_req.uuid));
ret = -1;
goto out;
}
ctx = GF_CALLOC (1, sizeof (*ctx), gf_gld_mt_op_lock_ctx_t);
if (!ctx) {
ret = -1;
goto out;
}
uuid_copy (ctx->uuid, lock_req.uuid);
ctx->req = req;
ctx->dict = dict_new ();
if (!ctx->dict) {
ret = -1;
goto out;
}
ret = dict_unserialize (lock_req.dict.dict_val,
lock_req.dict.dict_len, &ctx->dict);
if (ret) {
gf_log (this->name, GF_LOG_WARNING,
"failed to unserialize the dictionary");
goto out;
}
is_synctasked = dict_get_str_boolean (ctx->dict,
"is_synctasked", _gf_false);
if (is_synctasked) {
ret = glusterd_syctasked_mgmt_v3_unlock (req, &lock_req, ctx);
/* The above function does not take ownership of ctx.
* Therefore we need to free the ctx explicitly. */
free_ctx = _gf_true;
}
else {
ret = glusterd_op_state_machine_mgmt_v3_unlock (req, &lock_req,
ctx);
}
out:
if (ret || free_ctx) {
if (ctx->dict)
dict_unref (ctx->dict);
if (ctx)
GF_FREE (ctx);
}
free (lock_req.dict.dict_val);
gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);
return ret;
}
开发者ID:systemjj，项目名称:glusterfs，代码行数:85，代码来源:glusterd-mgmt-handler.c
示例8: gf_store_retrieve_value
int32_t
gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value)
{
int32_t ret = -1;
char *scan_str = NULL;
char *iter_key = NULL;
char *iter_val = NULL;
char *free_str = NULL;
struct stat st = {0,};
gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
GF_ASSERT (handle);
if (handle->locked == F_ULOCK)
/* no locking is used handle->fd gets closed() after usage */
handle->fd = open (handle->path, O_RDWR);
else
/* handle->fd is valid already, kept open for lockf() */
lseek (handle->fd, 0, SEEK_SET);
if (handle->fd == -1) {
gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",
handle->path, strerror (errno));
goto out;
}
if (!handle->read)
handle->read = fdopen (dup(handle->fd), "r");
else
fseek (handle->read, 0, SEEK_SET);
if (!handle->read) {
gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",
handle->path, strerror (errno));
goto out;
}
ret = fstat (handle->fd, &st);
if (ret < 0) {
gf_log ("", GF_LOG_WARNING, "stat on file %s failed",
handle->path);
ret = -1;
store_errno = GD_STORE_STAT_FAILED;
goto out;
}
scan_str = GF_CALLOC (1, st.st_size,
gf_common_mt_char);
if (scan_str == NULL) {
ret = -1;
store_errno = GD_STORE_ENOMEM;
goto out;
}
free_str = scan_str;
do {
ret = gf_store_read_and_tokenize (handle->read, scan_str,
&iter_key, &iter_val,
&store_errno);
if (ret < 0) {
gf_log ("", GF_LOG_TRACE, "error while reading key "
"'%s': %s", key,
gf_store_strerror (store_errno));
goto out;
}
gf_log ("", GF_LOG_TRACE, "key %s read", iter_key);
if (!strcmp (key, iter_key)) {
gf_log ("", GF_LOG_DEBUG, "key %s found", key);
ret = 0;
if (iter_val)
*value = gf_strdup (iter_val);
goto out;
}
} while (1);
out:
if (handle->read) {
fclose (handle->read);
handle->read = NULL;
}
if (handle->fd > 0 && handle->locked == F_ULOCK) {
/* only invalidate handle->fd if not locked */
close (handle->fd);
}
GF_FREE (free_str);
return ret;
}
开发者ID:Anna-Miya-Dan，项目名称:glusterfs，代码行数:91，代码来源:store.c
示例9: gf_store_iter_get_next
int32_t
gf_store_iter_get_next (gf_store_iter_t *iter, char **key, char **value,
gf_store_op_errno_t *op_errno)
{
int32_t ret = -1;
char *scan_str = NULL;
char *iter_key = NULL;
char *iter_val = NULL;
struct stat st = {0,};
gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
GF_ASSERT (iter);
GF_ASSERT (key);
GF_ASSERT (value);
ret = stat (iter->filepath, &st);
if (ret < 0) {
gf_log ("", GF_LOG_WARNING, "stat on file failed");
ret = -1;
store_errno = GD_STORE_STAT_FAILED;
goto out;
}
scan_str = GF_CALLOC (1, st.st_size,
gf_common_mt_char);
if (!scan_str) {
ret = -1;
store_errno = GD_STORE_ENOMEM;
goto out;
}
ret = gf_store_read_and_tokenize (iter->file, scan_str,
&iter_key, &iter_val,
&store_errno);
if (ret < 0) {
goto out;
}
ret = gf_store_validate_key_value (iter->filepath, iter_key,
iter_val, &store_errno);
if (ret)
goto out;
*key = gf_strdup (iter_key);
if (!*key) {
ret = -1;
store_errno = GD_STORE_ENOMEM;
goto out;
}
*value = gf_strdup (iter_val);
if (!*value) {
ret = -1;
store_errno = GD_STORE_ENOMEM;
goto out;
}
ret = 0;
out:
GF_FREE (scan_str);
if (ret) {
GF_FREE (*key);
GF_FREE (*value);
*key = NULL;
*value = NULL;
}
if (op_errno)
*op_errno = store_errno;
gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
return ret;
}
开发者ID:Anna-Miya-Dan，项目名称:glusterfs，代码行数:71，代码来源:store.c
示例10: parse_entries_and_compare
void
parse_entries_and_compare (char *option_str, char *peer_addr, char *subvol,
char *subdir, auth_result_t *result, auth_result_t status)
{
char *entry = NULL;
char *entry_cpy = NULL;
char *directory = NULL;
char *entries = NULL;
char *addr_str = NULL;
char *addr = NULL;
char *tmp = NULL;
char *tmpdir = NULL;
int ret = 0;
if (!subdir) {
gf_log (subvol, GF_LOG_WARNING,
"subdir entry not present, not performing any operation.");
goto out;
}
entries = gf_strdup (option_str);
if (!entries)
goto out;
if (entries[0] != '/' && !strchr (entries, '(')) {
/* Backward compatible option */
ret = compare_addr_and_update (entries, peer_addr, subvol,
",", result, status);
goto out;
}
entry = strtok_r (entries, ENTRY_DELIMITER, &tmp);
while (entry) {
entry_cpy = gf_strdup (entry);
if (!entry_cpy) {
goto out;
}
directory = strtok_r (entry_cpy, "(", &tmpdir);
if (directory[0] != '/')
goto out;
/* send second portion, after ' =' if directory matches */
if (strcmp (subdir, directory))
goto next_entry;
addr_str = strtok_r (NULL, ")", &tmpdir);
if (!addr_str)
goto out;
addr = gf_strdup (addr_str);
if (!addr)
goto out;
gf_log (subvol, GF_LOG_INFO, "Found an entry for dir %s (%s),"
" performing validation", subdir, addr);
ret = compare_addr_and_update (addr, peer_addr, subvol,
ADDR_DELIMITER, result, status);
if (ret == 0) {
break;
}
GF_FREE (addr);
addr = NULL;
next_entry:
entry = strtok_r (NULL, ENTRY_DELIMITER, &tmp);
GF_FREE (entry_cpy);
entry_cpy = NULL;
}
out:
GF_FREE (entries);
GF_FREE (entry_cpy);
GF_FREE (addr);
}
开发者ID:raghavendrabhat，项目名称:glusterfs，代码行数:77，代码来源:addr.c
示例11: gf_store_retrieve_value
int32_t
gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value)
{
int32_t ret = -1;
char *scan_str = NULL;
char *iter_key = NULL;
char *iter_val = NULL;
char *free_str = NULL;
struct stat st = {0,};
gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
GF_ASSERT (handle);
handle->fd = open (handle->path, O_RDWR);
if (handle->fd == -1) {
gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",
handle->path, strerror (errno));
goto out;
}
if (!handle->read)
handle->read = fdopen (handle->fd, "r");
if (!handle->read) {
gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",
handle->path, strerror (errno));
goto out;
}
ret = fstat (handle->fd, &st);
if (ret < 0) {
gf_log ("", GF_LOG_WARNING, "stat on file %s failed",
handle->path);
ret = -1;
store_errno = GD_STORE_STAT_FAILED;
goto out;
}
scan_str = GF_CALLOC (1, st.st_size,
gf_common_mt_char);
if (scan_str == NULL) {
ret = -1;
store_errno = GD_STORE_ENOMEM;
goto out;
}
free_str = scan_str;
do {
ret = gf_store_read_and_tokenize (handle->read, scan_str,
&iter_key, &iter_val,
&store_errno);
if (ret < 0) {
gf_log ("", GF_LOG_TRACE, "error while reading key "
"'%s': %s", key,
gf_store_strerror (store_errno));
goto out;
}
gf_log ("", GF_LOG_TRACE, "key %s read", iter_key);
if (!strcmp (key, iter_key)) {
gf_log ("", GF_LOG_DEBUG, "key %s found", key);
ret = 0;
if (iter_val)
*value = gf_strdup (iter_val);
goto out;
}
} while (1);
out:
if (handle->fd > 0) {
close (handle->fd);
handle->read = NULL;
}
GF_FREE (free_str);
return ret;
}
开发者ID:sytuxww，项目名称:glusterfs，代码行数:79，代码来源:store.c
示例12: gf_auth
auth_result_t
gf_auth (dict_t *input_params, dict_t *config_params)
{
auth_result_t result = AUTH_DONT_CARE;
int ret = 0;
char *name = NULL;
char *searchstr = NULL;
peer_info_t *peer_info = NULL;
data_t *peer_info_data = NULL;
data_t *allow_addr = NULL;
data_t *reject_addr = NULL;
char *service = NULL;
uint16_t peer_port = 0;
char peer_addr[UNIX_PATH_MAX] = {0,};
char *type = NULL;
gf_boolean_t allow_insecure = _gf_false;
char *subdir = NULL;
name = data_to_str (dict_get (input_params, "remote-subvolume"));
if (!name) {
gf_log ("authenticate/addr", GF_LOG_DEBUG,
"remote-subvolume not specified");
goto out;
}
ret = gf_asprintf (&searchstr, "auth.addr.%s.allow", name);
if (-1 == ret) {
gf_log ("auth/addr", GF_LOG_DEBUG,
"asprintf failed while setting search string");
goto out;
}
allow_addr = dict_get (config_params, searchstr);
GF_FREE (searchstr);
ret = gf_asprintf (&searchstr, "auth.addr.%s.reject", name);
if (-1 == ret) {
gf_log ("auth/addr", GF_LOG_ERROR,
"asprintf failed while setting search string");
goto out;
}
reject_addr = dict_get (config_params, searchstr);
GF_FREE (searchstr);
if (!allow_addr) {
/* TODO: backward compatibility */
ret = gf_asprintf (&searchstr, "auth.ip.%s.allow", name);
if (-1 == ret) {
gf_log ("auth/addr", GF_LOG_ERROR,
"asprintf failed while setting search string");
goto out;
}
allow_addr = dict_get (config_params, searchstr);
GF_FREE (searchstr);
}
if (!(allow_addr || reject_addr)) {
gf_log ("auth/addr", GF_LOG_DEBUG,
"none of the options auth.addr.%s.allow or "
"auth.addr.%s.reject specified, returning auth_dont_care",
name, name);
goto out;
}
peer_info_data = dict_get (input_params, "peer-info");
if (!peer_info_data) {
gf_log ("auth/addr", GF_LOG_ERROR,
"peer-info not present");
goto out;
}
ret = dict_get_str (input_params, "subdir-mount", &subdir);
if (ret) {
subdir = "/";
}
peer_info = data_to_ptr (peer_info_data);
switch (((struct sockaddr *) &peer_info->sockaddr)->sa_family) {
case AF_INET_SDP:
case AF_INET:
case AF_INET6:
strcpy (peer_addr, peer_info->identifier);
service = strrchr (peer_addr, ':');
*service = '\0';
service++;
ret = dict_get_str (config_params, "rpc-auth-allow-insecure",
&type);
if (ret == 0) {
ret = gf_string2boolean (type, &allow_insecure);
if (ret < 0) {
gf_log ("auth/addr", GF_LOG_WARNING,
"rpc-auth-allow-insecure option %s "
"is not a valid bool option", type);
goto out;
}
}
//.........这里部分代码省略.........
开发者ID:raghavendrabhat，项目名称:glusterfs，代码行数:101，代码来源:addr.c
示例13: gid_cache_add
/*
* Add a new list entry to the cache. If an entry for this ID already exists,
* update it.
*/
int
gid_cache_add(gid_cache_t *cache, gid_list_t *gl)
{
gid_list_t *agl;
int bucket;
int i;
time_t now;
if (!gl || !gl->gl_list)
return -1;
if (!cache->gc_max_age)
return 0;
LOCK(&cache->gc_lock);
now = time(NULL);
/*
* Scan for the first free entry or one that matches this id. The id
* check is added to address a bug where the cache might contain an
* expired entry for this id. Since lookup occurs in LRU order and
* does not reclaim entries, it will always return failure on discovery
* of an expired entry. This leads to duplicate entries being added,
* which still do not satisfy lookups until the expired entry (and
* everything before it) is reclaimed.
*
* We address this through reuse of an entry already allocated to this
* id, whether expired or not, since we have obviously already received
* more recent data. The entry is repopulated with the new data and a new
* deadline and is pushed forward to reside as the last populated entry in
* the bucket.
*/
bucket = gl->gl_id % cache->gc_nbuckets;
agl = BUCKET_START(cache->gc_cache, bucket);
for (i = 0; i < AUX_GID_CACHE_ASSOC; ++i, ++agl) {
if (agl->gl_id == gl->gl_id)
break;
if (!agl->gl_list)
break;
}
/*
* The way we allocate free entries naturally places the newest
* ones at the highest indices, so evicting the lowest makes
* sense, but that also means we can't just replace it with the
* one that caused the eviction. That would cause us to thrash
* the first entry while others remain idle. Therefore, we
* need to slide the other entries down and add the new one at
* the end just as if the *last* slot had been free.
*
* Deadline expiration is also handled here, since the oldest
* expired entry will be in the first position. This does mean
* the bucket can stay full of expired entries if we're idle
* but, if the small amount of extra memory or scan time before
* we decide to evict someone ever become issues, we could
* easily add a reaper thread.
*/
if (i >= AUX_GID_CACHE_ASSOC) {
/* cache full, evict the first (LRU) entry */
i = 0;
agl = BUCKET_START(cache->gc_cache, bucket);
GF_FREE(agl->gl_list);
} else if (agl->gl_list) {
/* evict the old entry we plan to reuse */
GF_FREE(agl->gl_list);
}
/*
* If we have evicted an entry, slide the subsequent populated entries
* back and populate the last entry.
*/
for (; i < AUX_GID_CACHE_ASSOC - 1; i++) {
if (!agl[1].gl_list)
break;
agl[0] = agl[1];
agl++;
}
agl->gl_id = gl->gl_id;
agl->gl_uid = gl->gl_uid;
agl->gl_gid = gl->gl_gid;
agl->gl_count = gl->gl_count;
agl->gl_list = gl->gl_list;
agl->gl_deadline = now + cache->gc_max_age;
UNLOCK(&cache->gc_lock);
return 1;
}
开发者ID:amarts，项目名称:glusterfs，代码行数:94，代码来源:gidcache.c
示例14: bd_aio_readv_complete
int
bd_aio_readv_complete (struct bd_aio_cb *paiocb, int res, int res2)
{
call_frame_t *frame = NULL;
xlator_t *this = NULL;
struct iobuf *iobuf = NULL;
struct iatt postbuf = {0,};
int op_ret = -1;
int op_errno = 0;
struct iovec iov;
struct iobref *iobref = NULL;
off_t offset = 0;
bd_attr_t *bdatt = NULL;
frame = paiocb->frame;
this = frame->this;
iobuf = paiocb->iobuf;
offset = paiocb->offset;
if (res < 0) {
op_ret = -1;
op_errno = -res;
gf_log (this->name, GF_LOG_ERROR,
"readv(async) failed fd=%p,size=%lu,offset=%llu (%d/%s)",
paiocb->fd, paiocb->iocb.u.c.nbytes,
(unsigned long long) paiocb->offset,
res, strerror (op_errno));
goto out;
}
bd_inode_ctx_get (paiocb->fd->inode, this, &bdatt);
memcpy (&postbuf, &bdatt->iatt, sizeof (struct iatt));
op_ret = res;
op_errno = 0;
iobref = iobref_new ();
if (!iobref) {
op_ret = -1;
op_errno = ENOMEM;
goto out;
}
iobref_add (iobref, iobuf);
iov.iov_base = iobuf_ptr (iobuf);
iov.iov_len = op_ret;
/* Hack to notify higher layers of EOF. */
if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size)
op_errno = ENOENT;
out:
STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, &iov, 1,
&postbuf, iobref, NULL);
if (iobuf)
iobuf_unref (iobuf);
if (iobref)
iobref_unref (iobref);
GF_FREE (paiocb);
return 0;
}
开发者ID:2510，项目名称:glusterfs，代码行数:64，代码来源:bd-aio.c
示例15: __exp_line_host_parse
/**
* __exp_line_host_parse -- Extract the hosts in the line
* and call helper functions to parse
* the string.
*
* The call chain goes like this:
*
* 1) __exp_line_host_parse ("/test hostip(sec=sys,rw,anonuid=0)")
* 2) __exp_line_ng_host_str_parse ("hostip(sec=sys,rw,anonuid=0)");
* 3) __exp_line_opt_parse("(sec=sys,rw,anonuid=0)");
*
*
* @line : The line to parse
* @ng_dict : Double pointer to the dict we want to
* insert hosts into.
*
* Allocates the dict, extracts host strings from the line,
* parses them into a struct export_item structure and inserts
* them in the dict.
*
* @return: success: GF_EXP_PARSE_SUCCESS
* failure: GF_EXP_PARSE_ITEM_FAILURE on parse failure,
* GF_EXP_PARSE_ITEM_NOT_FOUND if the host was not found,
* -EINVAL on bad args, -ENOMEM on allocation errors.
*
* Not for external use.
*/
static int
__exp_line_host_parse(const char *line, dict_t **host_dict)
{
dict_t *hosts = NULL;
char *strmatch = NULL;
int ret = -EINVAL;
struct export_item *exp_host = NULL;
data_t *hostdata = NULL;
GF_VALIDATE_OR_GOTO(GF_EXP, line, out);
GF_VALIDATE_OR_GOTO(GF_EXP, host_dict, out);
*host_dict = NULL;
/* Initialize a parser with the line to parse and the regex used to
* parse it.
*/
ret = parser_set_string(hostname_parser, line);
if (ret < 0) {
goto out;
}
gf_msg_trace(GF_EXP, 0, "parsing line: %s", line);
while ((strmatch = parser_get_next_match(hostname_parser))) {
if (!hosts) {
/* Allocate a new dictto store the netgroups. */
hosts = dict_new();
GF_CHECK_ALLOC(hosts, ret, free_and_out);
}
gf_msg_trace(GF_EXP, 0, "parsing hostname: %s", strmatch);
ret = __exp_line_ng_host_str_parse(strmatch, &exp_host);
if (ret != 0) {
/* Parsing or other critical error, free allocated
* memory and exit. The caller will handle the errors.
*/
_exp_dict_destroy(hosts);
goto free_and_out;
}
/* Insert export item structure into the hosts dict. */
hostdata = bin_to_data(exp_host, sizeof(*exp_host));
dict_set(hosts, exp_host->name, hostdata);
/* Free this matched string and continue parsing.*/
GF_FREE(strmatch);
}
/* If the hosts dict was not allocated, then we know that
* no matches were found.
*/
if (!exp_host) {
ret = GF_EXP_PARSE_ITEM_NOT_FOUND;
parser_unset_string(hostname_parser);
goto out;
}
ret = GF_EXP_PARSE_SUCCESS;
*host_dict = hosts;
free_and_out:
parser_unset_string(hostname_parser);
GF_FREE(strmatch);
out:
return ret;
}
开发者ID:gluster，项目名称:glusterfs，代码行数:96，代码来源:exports.c
示例16: gf_sql_delete_unwind
int
gf_sql_delete_unwind (gf_sql_connection_t *sql_conn,
gfdb_db_record_t *gfdb_db_record)
{
int ret = -1;
char *gfid_str = NULL;
char *pargfid_str = NULL;
gfdb_time_t *modtime = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
if (!gfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FA
|
客服电话
APP下载
官方微信
请发表评论