int
xlator_volopt_dynload (char *xlator_type, void **dl_handle,
volume_opt_list_t *opt_list)
{
int ret = -1;
char *name = NULL;
void *handle = NULL;
GF_VALIDATE_OR_GOTO ("xlator", xlator_type, out);
/* socket.so doesn't fall under the default xlator directory, hence we
* need this check */
if (!strstr(xlator_type, "rpc-transport"))
ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xlator_type);
else
ret = gf_asprintf (&name, "%s/%s.so", XLATORPARENTDIR, xlator_type);
if (-1 == ret) {
goto out;
}
ret = -1;
gf_msg_trace ("xlator", 0, "attempt to load file %s", name);
handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
if (!handle) {
gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
"%s", dlerror ());
goto out;
}
if (!(opt_list->given_opt = dlsym (handle, "options"))) {
dlerror ();
gf_msg ("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
"Failed to load xlator opt table");
goto out;
}
*dl_handle = handle;
handle = NULL;
ret = 0;
out:
GF_FREE (name);
if (handle)
dlclose (handle);
gf_msg_debug ("xlator", 0, "Returning %d", ret);
return ret;
}
/* Function to extract PRAGMA from sqlite db
* Input:
* void *db_conn : Sqlite connection
* char *pragma_key : PRAGMA or setting to be extracted
* char **pragma_value : the value of the PRAGMA or setting that is
* extracted. This function will allocate memory
* to pragma_value. The caller should free the memory
* Return:
* On success return the lenght of the pragma/setting value that is
* extracted.
* On failure return -1
* */
int
gf_sqlite3_pragma (void *db_conn, char *pragma_key, char **pragma_value)
{
int ret = -1;
gf_sql_connection_t *sql_conn = db_conn;
sqlite3_stmt *pre_stmt = NULL;
char *sqlstring = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_key, out);
ret = gf_asprintf (&sqlstring, "PRAGMA %s;", pragma_key);
if (ret <= 0) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed allocating memory");
goto out;
}
ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn,
sqlstring, -1, &pre_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s",
sqlite3_errmsg (db_conn));
ret = -1;
goto out;
}
ret = sqlite3_step (pre_stmt);
if (ret != SQLITE_ROW) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_GET_RECORD_FAILED, "Failed to get records "
"from db : %s", sqlite3_errmsg (db_conn));
ret = -1;
goto out;
}
ret = gf_asprintf (pragma_value, "%s", sqlite3_column_text (pre_stmt, 0));
if (ret <= 0) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed to get %s from db", pragma_key);
}
ret = 0;
out:
GF_FREE (sqlstring);
sqlite3_finalize (pre_stmt);
return ret;
}
int
xlator_volopt_dynload (char *xlator_type, void **dl_handle,
volume_opt_list_t *opt_list)
{
int ret = -1;
char *name = NULL;
void *handle = NULL;
volume_opt_list_t *vol_opt = NULL;
GF_VALIDATE_OR_GOTO ("xlator", xlator_type, out);
GF_ASSERT (dl_handle);
if (*dl_handle)
if (dlclose (*dl_handle))
gf_log ("xlator", GF_LOG_WARNING, "Unable to close "
"previously opened handle( may be stale)."
"Ignoring the invalid handle");
ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xlator_type);
if (-1 == ret) {
gf_log ("xlator", GF_LOG_ERROR, "asprintf failed");
goto out;
}
ret = -1;
gf_log ("xlator", GF_LOG_TRACE, "attempt to load file %s", name);
handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
if (!handle) {
gf_log ("xlator", GF_LOG_WARNING, "%s", dlerror ());
goto out;
}
*dl_handle = handle;
vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
gf_common_mt_volume_opt_list_t);
if (!vol_opt) {
goto out;
}
if (!(vol_opt->given_opt = dlsym (handle, "options"))) {
dlerror ();
gf_log ("xlator", GF_LOG_DEBUG,
"Strict option validation not enforced -- neglecting");
}
opt_list->given_opt = vol_opt->given_opt;
INIT_LIST_HEAD (&vol_opt->list);
list_add_tail (&vol_opt->list, &opt_list->list);
ret = 0;
out:
gf_log ("xlator", GF_LOG_DEBUG, "Returning %d", ret);
return ret;
}
static int
find_gsyncd (pid_t pid, pid_t ppid, char *name, void *data)
{
char buf[NAME_MAX * 2] = {0,};
char *p = NULL;
int zeros = 0;
int ret = 0;
int fd = -1;
pid_t *pida = (pid_t *)data;
if (ppid != pida[0])
return 0;
ret = gf_asprintf (&p, PROC"/%d/cmdline", pid);
if (ret == -1) {
fprintf (stderr, "out of memory\n");
return -1;
}
fd = open (p, O_RDONLY);
if (fd == -1)
return 0;
ret = read (fd, buf, sizeof (buf));
close (fd);
if (ret == -1)
return 0;
for (zeros = 0, p = buf; zeros < 2 && p < buf + ret; p++)
zeros += !*p;
ret = 0;
switch (zeros) {
case 2:
if ((strcmp (basename (buf), basename (PYTHON)) ||
strcmp (basename (buf + strlen (buf) + 1), GSYNCD_PY)) == 0) {
ret = 1;
break;
}
/* fallthrough */
case 1:
if (strcmp (basename (buf), GSYNCD_PY) == 0)
ret = 1;
}
if (ret == 1) {
if (pida[1] != -1) {
fprintf (stderr, GSYNCD_PY" sibling is not unique");
return -1;
}
pida[1] = pid;
}
return 0;
}
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;
err:
return NULL;
}
/*
* ptr_to_str - convert a pointer to string
* @ptr: pointer
*
*/
char *
ptr_to_str (void *ptr)
{
int ret = 0;
char *str = NULL;
ret = gf_asprintf (&str, "%p", ptr);
if (-1 == ret) {
gf_log ("ioc", GF_LOG_ERROR,
"asprintf failed while converting ptr to str");
return NULL;
}
return str;
}
int
make_ghadoop_mountspec (gf_mount_spec_t *mspec, const char *volname,
char *user, char *server)
{
char *hadoop_mnt_desc = NULL;
int ret = 0;
ret = gf_asprintf (&hadoop_mnt_desc, hadoop_mnt_desc_template,
server, GF_CLIENT_PID_HADOOP, volname, user);
if (ret == -1)
return ret;
return parse_mount_pattern_desc (mspec, hadoop_mnt_desc);
}
int
xlator_volopt_dynload (char *xlator_type, void **dl_handle,
volume_opt_list_t *opt_list)
{
int ret = -1;
char *name = NULL;
void *handle = NULL;
GF_VALIDATE_OR_GOTO ("xlator", xlator_type, out);
ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xlator_type);
if (-1 == ret) {
gf_log ("xlator", GF_LOG_ERROR, "asprintf failed");
goto out;
}
ret = -1;
gf_log ("xlator", GF_LOG_TRACE, "attempt to load file %s", name);
handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
if (!handle) {
gf_log ("xlator", GF_LOG_WARNING, "%s", dlerror ());
goto out;
}
if (!(opt_list->given_opt = dlsym (handle, "options"))) {
dlerror ();
gf_log ("xlator", GF_LOG_ERROR,
"Failed to load xlator opt table");
goto out;
}
*dl_handle = handle;
handle = NULL;
ret = 0;
out:
GF_FREE (name);
if (handle)
dlclose (handle);
gf_log ("xlator", GF_LOG_DEBUG, "Returning %d", ret);
return ret;
}
static int
gf_get_basic_query_stmt (char **out_stmt)
{
int ret = -1;
ret = gf_asprintf (out_stmt, "select GF_FILE_TB.GF_ID,"
"GF_FLINK_TB.GF_PID ,"
"GF_FLINK_TB.FNAME "
"from GF_FLINK_TB, GF_FILE_TB "
"where "
"GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID ");
if (ret <= 0) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed to create base query statement");
*out_stmt = NULL;
}
return ret;
}
/* Function to extract version of sqlite db
* Input:
* void *db_conn : Sqlite connection
* char **version : the version is extracted as a string and will be stored in
* this variable. The freeing of the memory should be done by
* the caller.
* Return:
* On success return the lenght of the version string that is
* extracted.
* On failure return -1
* */
int
gf_sqlite3_version (void *db_conn, char **version)
{
int ret = -1;
gf_sql_connection_t *sql_conn = db_conn;
sqlite3_stmt *pre_stmt = NULL;
CHECK_SQL_CONN (sql_conn, out);
ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn,
"SELECT SQLITE_VERSION()",
-1, &pre_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s",
sqlite3_errmsg (db_conn));
ret = -1;
goto out;
}
ret = sqlite3_step(pre_stmt);
if (ret != SQLITE_ROW) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_GET_RECORD_FAILED, "Failed to get records "
"from db : %s", sqlite3_errmsg (db_conn));
ret = -1;
goto out;
}
ret = gf_asprintf (version, "%s", sqlite3_column_text (pre_stmt, 0));
if (ret <= 0) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed extracting version");
}
out:
sqlite3_finalize (pre_stmt);
return ret;
}
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);
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;
}
}
peer_port = atoi (service);
if (peer_port >= PRIVILEGED_PORT_CEILING && !allow_insecure) {
gf_log ("auth/addr", GF_LOG_ERROR,
"client is bound to port %d which is not privileged",
peer_port);
goto out;
}
break;
case AF_UNIX:
strcpy (peer_addr, peer_info->identifier);
break;
default:
gf_log ("authenticate/addr", GF_LOG_ERROR,
"unknown address family %d",
((struct sockaddr *) &peer_info->sockaddr)->sa_family);
goto out;
}
}
if (reject_addr) {
addr_cpy = gf_strdup (reject_addr->data);
if (!addr_cpy)
goto out;
addr_str = strtok_r (addr_cpy, ADDR_DELIMITER, &tmp);
while (addr_str) {
gf_log (name, GF_LOG_DEBUG,
"rejected = \"%s\", received addr = \"%s\"",
addr_str, peer_addr);
if (addr_str[0] == '!') {
negate = 1;
addr_str++;
}
match = fnmatch (addr_str, peer_addr, 0);
if (negate ? match : !match) {
result = AUTH_REJECT;
goto out;
}
addr_str = strtok_r (NULL, ADDR_DELIMITER, &tmp);
}
GF_FREE (addr_cpy);
}
if (allow_addr) {
addr_cpy = gf_strdup (allow_addr->data);
if (!addr_cpy)
goto out;
addr_str = strtok_r (addr_cpy, ADDR_DELIMITER, &tmp);
while (addr_str) {
gf_log (name, GF_LOG_DEBUG,
"allowed = \"%s\", received addr = \"%s\"",
addr_str, peer_addr);
if (addr_str[0] == '!') {
negate = 1;
addr_str++;
}
match = fnmatch (addr_str, peer_addr, 0);
if (negate ? match : !match) {
result = AUTH_ACCEPT;
goto out;
}
addr_str = strtok_r (NULL, ADDR_DELIMITER, &tmp);
}
}
out:
if (addr_cpy)
GF_FREE (addr_cpy);
return result;
}
auth_result_t
gf_auth(dict_t *input_params, dict_t *config_params)
{
auth_result_t result = AUTH_DONT_CARE;
int ret = 0;
data_t *allow_user = NULL;
data_t *username_data = NULL;
data_t *passwd_data = NULL;
data_t *password_data = NULL;
char *username = NULL;
char *password = NULL;
char *brick_name = NULL;
char *searchstr = NULL;
char *username_str = NULL;
char *tmp = NULL;
char *username_cpy = NULL;
gf_boolean_t using_ssl = _gf_false;
gf_boolean_t strict_auth = _gf_false;
username_data = dict_get(input_params, "ssl-name");
if (username_data) {
gf_log("auth/login", GF_LOG_INFO, "connecting user name: %s",
username_data->data);
using_ssl = _gf_true;
} else {
ret = dict_get_str_boolean(config_params, "strict-auth-accept",
_gf_false);
if (ret == -1)
strict_auth = _gf_false;
else
strict_auth = ret;
username_data = dict_get(input_params, "username");
if (!username_data) {
if (strict_auth) {
gf_log("auth/login", GF_LOG_DEBUG,
"username not found, strict auth"
" configured returning REJECT");
result = AUTH_REJECT;
} else {
gf_log("auth/login", GF_LOG_DEBUG,
"username not found, returning"
" DONT-CARE");
}
goto out;
}
password_data = dict_get(input_params, "password");
if (!password_data) {
if (strict_auth) {
gf_log("auth/login", GF_LOG_DEBUG,
"password not found, strict auth"
" configured returning REJECT");
result = AUTH_REJECT;
} else {
gf_log("auth/login", GF_LOG_WARNING,
"password not found, returning"
" DONT-CARE");
}
goto out;
}
password = data_to_str(password_data);
}
username = data_to_str(username_data);
brick_name = data_to_str(dict_get(input_params, "remote-subvolume"));
if (!brick_name) {
gf_log("auth/login", GF_LOG_ERROR, "remote-subvolume not specified");
result = AUTH_REJECT;
goto out;
}
ret = gf_asprintf(&searchstr, "auth.login.%s.%s", brick_name,
using_ssl ? "ssl-allow" : "allow");
if (-1 == ret) {
gf_log("auth/login", GF_LOG_ERROR,
"asprintf failed while setting search string, "
"returning REJECT");
result = AUTH_REJECT;
goto out;
}
allow_user = dict_get(config_params, searchstr);
GF_FREE(searchstr);
if (allow_user) {
gf_log("auth/login", GF_LOG_INFO, "allowed user names: %s",
allow_user->data);
/*
* There's a subtle difference between SSL and non-SSL behavior
* if we can't match anything in the "while" loop below.
* Intuitively, we should AUTH_REJECT if there's no match.
* However, existing code depends on allowing untrusted users
* to connect with *no credentials at all* by falling through
* the loop. They're still distinguished from trusted users
* who do provide a valid username and password (in fact that's
* pretty much the only thing we use non-SSL login auth for),
* but they are allowed to connect. It's wrong, but it's not
* worth changing elsewhere. Therefore, we do the sane thing
* only for SSL here.
*
* For SSL, if there's a list *you must be on it*. Note that
* if there's no list we don't care. In that case (and the
* ssl-allow=* case as well) authorization is effectively
* disabled, though authentication and encryption are still
* active.
*
* Read NOTE on strict_auth above.
*/
if (using_ssl || strict_auth) {
result = AUTH_REJECT;
}
username_cpy = gf_strdup(allow_user->data);
if (!username_cpy)
goto out;
username_str = strtok_r(username_cpy, " ,", &tmp);
/*
* We have to match a user's *authenticated* name to one in the
* list. If we're using SSL, they're already authenticated.
* Otherwise, they need a matching password to complete the
* process.
*/
while (username_str) {
if (!fnmatch(username_str, username, 0)) {
if (using_ssl) {
result = AUTH_ACCEPT;
break;
}
ret = gf_asprintf(&searchstr, "auth.login.%s.password",
username);
if (-1 == ret) {
gf_log("auth/login", GF_LOG_WARNING,
"asprintf failed while setting search string");
goto out;
}
passwd_data = dict_get(config_params, searchstr);
GF_FREE(searchstr);
if (!passwd_data) {
gf_log("auth/login", GF_LOG_ERROR,
"wrong username/password combination");
result = AUTH_REJECT;
goto out;
}
result = !((strcmp(data_to_str(passwd_data), password))
? AUTH_ACCEPT
: AUTH_REJECT);
if (result == AUTH_REJECT)
gf_log("auth/login", GF_LOG_ERROR,
"wrong password for user %s", username);
break;
}
username_str = strtok_r(NULL, " ,", &tmp);
}
}
out:
GF_FREE(username_cpy);
return result;
}
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);
trans->ops = dlsym (handle, "tops");
if (trans->ops == NULL) {
gf_log ("transport", GF_LOG_ERROR,
"dlsym (transport_ops) on %s", dlerror ());
GF_FREE (trans);
goto fail;
}
trans->init = dlsym (handle, "init");
if (trans->init == NULL) {
gf_log ("transport", GF_LOG_ERROR,
"dlsym (gf_transport_init) on %s", dlerror ());
GF_FREE (trans);
goto fail;
}
trans->fini = dlsym (handle, "fini");
if (trans->fini == NULL) {
gf_log ("transport", GF_LOG_ERROR,
"dlsym (gf_transport_fini) on %s", dlerror ());
GF_FREE (trans);
goto fail;
}
vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
gf_common_mt_volume_opt_list_t);
vol_opt->given_opt = dlsym (handle, "options");
if (vol_opt->given_opt == NULL) {
gf_log ("transport", GF_LOG_DEBUG,
"volume option validation not specified");
} else {
list_add_tail (&vol_opt->list, &xl->volume_options);
if (-1 ==
validate_xlator_volume_options (xl,
vol_opt->given_opt)) {
gf_log ("transport", GF_LOG_ERROR,
"volume option validation failed");
GF_FREE (trans);
goto fail;
}
}
ret = trans->init (trans);
if (ret != 0) {
gf_log ("transport", GF_LOG_ERROR,
"'%s' initialization failed", type);
GF_FREE (trans);
goto fail;
}
pthread_mutex_init (&trans->lock, NULL);
return_trans = trans;
fail:
return return_trans;
}
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;
}
}
peer_port = atoi (service);
if (peer_port >= PRIVILEGED_PORT_CEILING && !allow_insecure) {
gf_log ("auth/addr", GF_LOG_ERROR,
"client is bound to port %d which is not privileged",
peer_port);
result = AUTH_REJECT;
goto out;
}
break;
case AF_UNIX:
strcpy (peer_addr, peer_info->identifier);
break;
default:
gf_log ("authenticate/addr", GF_LOG_ERROR,
"unknown address family %d",
((struct sockaddr *) &peer_info->sockaddr)->sa_family);
goto out;
}
if (reject_addr) {
parse_entries_and_compare (reject_addr->data, peer_addr, name,
subdir, &result, AUTH_REJECT);
if (result == AUTH_REJECT)
goto out;
}
if (allow_addr) {
parse_entries_and_compare (allow_addr->data, peer_addr, name,
subdir, &result, AUTH_ACCEPT);
}
out:
return result;
}
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;
err:
freeaddrinfo (cache->first);
cache->first = cache->next = NULL;
GF_FREE (cache);
*dnscache = NULL;
return -1;
}
int
xlator_dynload (xlator_t *xl)
{
int ret = -1;
char *name = NULL;
void *handle = NULL;
volume_opt_list_t *vol_opt = NULL;
GF_VALIDATE_OR_GOTO ("xlator", xl, out);
INIT_LIST_HEAD (&xl->volume_options);
ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xl->type);
if (-1 == ret) {
gf_log ("xlator", GF_LOG_ERROR, "asprintf failed");
goto out;
}
ret = -1;
gf_log ("xlator", GF_LOG_TRACE, "attempt to load file %s", name);
handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
if (!handle) {
gf_log ("xlator", GF_LOG_WARNING, "%s", dlerror ());
goto out;
}
xl->dlhandle = handle;
if (!(xl->fops = dlsym (handle, "fops"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(fops) on %s",
dlerror ());
goto out;
}
if (!(xl->cbks = dlsym (handle, "cbks"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(cbks) on %s",
dlerror ());
goto out;
}
if (!(xl->init = dlsym (handle, "init"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(init) on %s",
dlerror ());
goto out;
}
if (!(xl->fini = dlsym (handle, "fini"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(fini) on %s",
dlerror ());
goto out;
}
if (!(xl->notify = dlsym (handle, "notify"))) {
gf_log ("xlator", GF_LOG_DEBUG,
"dlsym(notify) on %s -- neglecting", dlerror ());
}
if (!(xl->dumpops = dlsym (handle, "dumpops"))) {
gf_log ("xlator", GF_LOG_DEBUG,
"dlsym(dumpops) on %s -- neglecting", dlerror ());
}
if (!(xl->mem_acct_init = dlsym (handle, "mem_acct_init"))) {
gf_log (xl->name, GF_LOG_DEBUG,
"dlsym(mem_acct_init) on %s -- neglecting",
dlerror ());
}
if (!(xl->reconfigure = dlsym (handle, "reconfigure"))) {
gf_log ("xlator", GF_LOG_DEBUG,
"dlsym(reconfigure) on %s -- neglecting",
dlerror());
}
vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
gf_common_mt_volume_opt_list_t);
if (!vol_opt) {
goto out;
}
if (!(vol_opt->given_opt = dlsym (handle, "options"))) {
dlerror ();
gf_log (xl->name, GF_LOG_DEBUG,
"Strict option validation not enforced -- neglecting");
}
list_add_tail (&vol_opt->list, &xl->volume_options);
fill_defaults (xl);
ret = 0;
out:
if (name)
GF_FREE (name);
return ret;
}
int
make_georep_mountspec (gf_mount_spec_t *mspec, const char *volnames,
char *user)
{
char *georep_mnt_desc = NULL;
char *meetspec = NULL;
char *vols = NULL;
char *vol = NULL;
char *p = NULL;
char *savetok = NULL;
char *fa[3] = {0,};
size_t siz = 0;
int vc = 0;
int i = 0;
int ret = 0;
vols = gf_strdup ((char *)volnames);
if (!vols)
goto out;
for (vc = 1, p = vols; *p; p++) {
if (*p == ',')
vc++;
}
siz = strlen (volnames) + vc * strlen("volfile-id=");
meetspec = GF_CALLOC (1, siz + 1, gf_gld_mt_georep_meet_spec);
if (!meetspec)
goto out;
for (p = vols;;) {
vol = strtok_r (p, ",", &savetok);
if (!vol) {
GF_ASSERT (vc == 0);
break;
}
p = NULL;
strcat (meetspec, "volfile-id=");
strcat (meetspec, vol);
if (--vc > 0)
strcat (meetspec, " ");
}
ret = gf_asprintf (&georep_mnt_desc, georep_mnt_desc_template,
GF_CLIENT_PID_GSYNCD, user, meetspec);
if (ret == -1) {
georep_mnt_desc = NULL;
goto out;
}
ret = parse_mount_pattern_desc (mspec, georep_mnt_desc);
out:
fa[0] = meetspec;
fa[1] = vols;
fa[2] = georep_mnt_desc;
for (i = 0; i < 3; i++) {
if (fa[i] == NULL)
ret = -1;
else
GF_FREE (fa[i]);
}
return ret;
}
static int
set_log_file_path (cmd_args_t *cmd_args)
{
int i = 0;
int j = 0;
int ret = 0;
int port = 0;
char *tmp_ptr = NULL;
char tmp_str[1024] = {0,};
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 == -1) {
gf_log ("glusterfsd", GF_LOG_ERROR,
"asprintf failed while setting up log-file");
}
goto done;
}
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 == -1) {
gf_log ("glusterfsd", GF_LOG_ERROR,
"asprintf failed while setting up log-file");
}
goto done;
}
if (cmd_args->volfile_server) {
port = 1;
tmp_ptr = "default";
if (cmd_args->volfile_server_port)
port = cmd_args->volfile_server_port;
if (cmd_args->volfile_id)
tmp_ptr = cmd_args->volfile_id;
ret = gf_asprintf (&cmd_args->log_file,
DEFAULT_LOG_FILE_DIRECTORY "/%s-%s-%d.log",
cmd_args->volfile_server, tmp_ptr, port);
if (-1 == ret) {
gf_log ("glusterfsd", GF_LOG_ERROR,
"asprintf failed while setting up log-file");
}
}
done:
return ret;
}
/*
* Find recently changed files with a specific frequency from the DB
* Input:
* db_conn : db connection object
* query_callback : query callback fuction to handle
* result records from the query
* from_time : Time to define what is recent
* freq_write_cnt : Frequency thresold for write
* freq_read_cnt : Frequency thresold for read
* clear_counters : Clear counters (r/w) for all inodes in DB
* */
int
gf_sqlite3_find_recently_changed_files_freq (void *db_conn,
gf_query_callback_t query_callback,
void *query_cbk_args,
gfdb_time_t *from_time,
int freq_write_cnt,
int freq_read_cnt,
gf_boolean_t clear_counters)
{
int ret = -1;
char *query_str = NULL;
gf_sql_connection_t *sql_conn = db_conn;
sqlite3_stmt *prep_stmt = NULL;
uint64_t from_time_usec = 0;
char *base_query_str = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
ret = gf_get_basic_query_stmt (&base_query_str);
if (ret <= 0) {
goto out;
}
ret = gf_asprintf (&query_str, "%s AND "
/*First condition: For Writes*/
"( ( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_WMSEC ") >= ? )"
" AND "" (" GF_COL_TB_WFC " >= ? ) )"
" OR "
/*Second condition: For Reads */
"( ((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_RWMSEC ") >= ?)"
" AND "" (" GF_COL_TB_RFC " >= ? ) ) )", base_query_str);
if (ret < 0) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed to create query statement");
query_str = NULL;
goto out;
}
from_time_usec = gfdb_time_2_usec (from_time);
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
&prep_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed to prepare statment %s :"
" %s", query_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind write wind time*/
ret = sqlite3_bind_int64 (prep_stmt, 1, from_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
"%"PRIu64" : %s", from_time_usec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind write frequency thresold*/
ret = sqlite3_bind_int (prep_stmt, 2, freq_write_cnt);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed to bind freq_write_cnt "
"%d : %s", freq_write_cnt,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind read wind time*/
ret = sqlite3_bind_int64 (prep_stmt, 3, from_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
"%"PRIu64" : %s", from_time_usec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind read frequency thresold*/
ret = sqlite3_bind_int (prep_stmt, 4, freq_read_cnt);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed to bind freq_read_cnt "
"%d : %s", freq_read_cnt,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the query*/
ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed Query %s", query_str);
goto out;
}
/*Clear counters*/
if (clear_counters) {
ret = gf_sql_clear_counters (sql_conn);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear"
" counters!");
goto out;
}
}
ret = 0;
out:
sqlite3_finalize (prep_stmt);
GF_FREE (base_query_str);
GF_FREE (query_str);
return ret;
}
/*
* Find unchanged files from a specified time from the DB
* Input:
* query_callback : query callback fuction to handle
* result records from the query
* for_time : Time from where the file/s are not changed
* */
int
gf_sqlite3_find_unchanged_for_time (void *db_conn,
gf_query_callback_t query_callback,
void *query_cbk_args,
gfdb_time_t *for_time)
{
int ret = -1;
char *query_str = NULL;
gf_sql_connection_t *sql_conn = db_conn;
sqlite3_stmt *prep_stmt = NULL;
uint64_t for_time_usec = 0;
char *base_query_str = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
ret = gf_get_basic_query_stmt (&base_query_str);
if (ret <= 0) {
goto out;
}
ret = gf_asprintf (&query_str, "%s AND "
/*First condition: For writes*/
"( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_WMSEC ") <= ? )"
" AND "
/*Second condition: For reads*/
"((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
GF_COL_TB_RWMSEC ") <= ?) )", base_query_str);
if (ret < 0) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed to create query statement");
query_str = NULL;
goto out;
}
for_time_usec = gfdb_time_2_usec (for_time);
ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
&prep_stmt, 0);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PREPARE_FAILED, "Failed to prepare statment %s :"
" %s", query_str,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind write wind time*/
ret = sqlite3_bind_int64 (prep_stmt, 1, for_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
"%"PRIu64" : %s", for_time_usec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Bind read wind time*/
ret = sqlite3_bind_int64 (prep_stmt, 2, for_time_usec);
if (ret != SQLITE_OK) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
"%"PRIu64" : %s", for_time_usec,
sqlite3_errmsg (sql_conn->sqlite3_db_conn));
ret = -1;
goto out;
}
/*Execute the query*/
ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
"Failed Query %s", query_str);
goto out;
}
ret = 0;
out:
sqlite3_finalize (prep_stmt);
GF_FREE (base_query_str);
GF_FREE (query_str);
return ret;
}
/*新建一个内存池对象，然后按照传递进来的内存的大小和个数分配内存，还要加上一些额
外存储内容的内存容量，如存放链表指针的因为这些内存池对象本身是通过通用链表来管理
的，还有如标识内存是否在被使用的一个标志等
http://blog.csdn.net/wangyuling1234567890/article/details/24564891
*/
struct mem_pool *
mem_pool_new_fn (unsigned long sizeof_type,
unsigned long count, char *name)//参数的意思依次是：每个对象的长度，内存池分配对象的个数，内存池的名字。
{
struct mem_pool *mem_pool = NULL;
unsigned long padded_sizeof_type = 0;
GF_UNUSED void *pool = NULL;
GF_UNUSED int i = 0;
int ret = 0;
GF_UNUSED struct list_head *list = NULL;
glusterfs_ctx_t *ctx = NULL;
if (!sizeof_type || !count) {
gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
return NULL;
}
/*加上一些额外存储内容的内存容量*/
//计算大小：对象本身所占内存+链表头+内存池指针+int内存大小（存放in_use变量）
padded_sizeof_type = sizeof_type + GF_MEM_POOL_PAD_BOUNDARY;
//给内存池的头结点分配内存空间
mem_pool = GF_CALLOC (sizeof (*mem_pool), 1, gf_common_mt_mem_pool);
if (!mem_pool)
return NULL;
//内存池名字:哪一个xlator分配什么名字内存
ret = gf_asprintf (&mem_pool->name, "%s:%s", THIS->name, name);
if (ret < 0)
return NULL;
if (!mem_pool->name) {
GF_FREE (mem_pool);
return NULL;
}
LOCK_INIT (&mem_pool->lock);
INIT_LIST_HEAD (&mem_pool->list);
INIT_LIST_HEAD (&mem_pool->global_list);
//总的对齐内存大小，内存池中的每个对象实际分配的内存大小。
mem_pool->padded_sizeof_type = padded_sizeof_type;
//使用内存池对象的真实内存大小
mem_pool->real_sizeof_type = sizeof_type;
#ifndef DEBUG
//数量：刚开始都是冷的（未使用的）
mem_pool->cold_count = count;
pool = GF_CALLOC (count, padded_sizeof_type, gf_common_mt_long);
if (!pool) {
GF_FREE (mem_pool->name);
GF_FREE (mem_pool);
return NULL;
}
for (i = 0; i < count; i++) {
//分配每一个内存对象大小到链表
list = pool + (i * (padded_sizeof_type));
//内存的前面就是存放链表头 GF_MEM_POOL_LIST_BOUNDARY
INIT_LIST_HEAD (list);
//加入到内存池的链表中去
list_add_tail (list, &mem_pool->list);
}
//记录分配的内存区域
mem_pool->pool = pool;
//内存分配结束的地址
mem_pool->pool_end = pool + (count * (padded_sizeof_type));
#endif
/* add this pool to the global list */
ctx = THIS->ctx;
if (!ctx)
goto out;
//加入全局的内存池链表 ，内存池挂在: THIS->ctx->mempool_list 上
list_add (&mem_pool->global_list, &ctx->mempool_list);
out:
return mem_pool;
}
int
xlator_dynload (xlator_t *xl)
{
int ret = -1;
char *name = NULL;
void *handle = NULL;
volume_opt_list_t *vol_opt = NULL;
class_methods_t *vtbl = NULL;
GF_VALIDATE_OR_GOTO ("xlator", xl, out);
INIT_LIST_HEAD (&xl->volume_options);
ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xl->type);
if (-1 == ret) {
gf_log ("xlator", GF_LOG_ERROR, "asprintf failed");
goto out;
}
ret = -1;
gf_log ("xlator", GF_LOG_TRACE, "attempt to load file %s", name);
handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
if (!handle) {
gf_log ("xlator", GF_LOG_WARNING, "%s", dlerror ());
goto out;
}
xl->dlhandle = handle;
if (!(xl->fops = dlsym (handle, "fops"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(fops) on %s",
dlerror ());
goto out;
}
if (!(xl->cbks = dlsym (handle, "cbks"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(cbks) on %s",
dlerror ());
goto out;
}
/*
* If class_methods exists, its contents override any definitions of
* init or fini for that translator. Otherwise, we fall back to the
* older method of looking for init and fini directly.
*/
vtbl = dlsym(handle,"class_methods");
if (vtbl) {
xl->init = vtbl->init;
xl->fini = vtbl->fini;
xl->reconfigure = vtbl->reconfigure;
xl->notify = vtbl->notify;
}
else {
if (!(*VOID(&xl->init) = dlsym (handle, "init"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(init) on %s",
dlerror ());
goto out;
}
if (!(*VOID(&(xl->fini)) = dlsym (handle, "fini"))) {
gf_log ("xlator", GF_LOG_WARNING, "dlsym(fini) on %s",
dlerror ());
goto out;
}
if (!(*VOID(&(xl->reconfigure)) = dlsym (handle,
"reconfigure"))) {
gf_log ("xlator", GF_LOG_TRACE,
"dlsym(reconfigure) on %s -- neglecting",
dlerror());
}
if (!(*VOID(&(xl->notify)) = dlsym (handle, "notify"))) {
gf_log ("xlator", GF_LOG_TRACE,
"dlsym(notify) on %s -- neglecting",
dlerror ());
}
}
if (!(xl->dumpops = dlsym (handle, "dumpops"))) {
gf_log ("xlator", GF_LOG_TRACE,
"dlsym(dumpops) on %s -- neglecting", dlerror ());
}
if (!(*VOID(&(xl->mem_acct_init)) = dlsym (handle, "mem_acct_init"))) {
gf_log (xl->name, GF_LOG_TRACE,
"dlsym(mem_acct_init) on %s -- neglecting",
dlerror ());
}
vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
gf_common_mt_volume_opt_list_t);
if (!vol_opt) {
goto out;
}
if (!(vol_opt->given_opt = dlsym (handle, "options"))) {
dlerror ();
gf_log (xl->name, GF_LOG_TRACE,
"Strict option validation not enforced -- neglecting");
}
INIT_LIST_HEAD (&vol_opt->list);
list_add_tail (&vol_opt->list, &xl->volume_options);
fill_defaults (xl);
ret = 0;
out:
GF_FREE (name);
return ret;
}
auth_result_t gf_auth (dict_t *input_params, dict_t *config_params)
{
auth_result_t result = AUTH_DONT_CARE;
int ret = 0;
data_t *allow_user = NULL;
data_t *username_data = NULL;
data_t *passwd_data = NULL;
data_t *password_data = NULL;
char *username = NULL;
char *password = NULL;
char *brick_name = NULL;
char *searchstr = NULL;
char *username_str = NULL;
char *tmp = NULL;
char *username_cpy = NULL;
username_data = dict_get (input_params, "username");
if (!username_data) {
gf_log ("auth/login", GF_LOG_DEBUG,
"username not found, returning DONT-CARE");
goto out;
}
username = data_to_str (username_data);
password_data = dict_get (input_params, "password");
if (!password_data) {
gf_log ("auth/login", GF_LOG_WARNING,
"password not found, returning DONT-CARE");
goto out;
}
password = data_to_str (password_data);
brick_name = data_to_str (dict_get (input_params, "remote-subvolume"));
if (!brick_name) {
gf_log ("auth/login", GF_LOG_ERROR,
"remote-subvolume not specified");
result = AUTH_REJECT;
goto out;
}
ret = gf_asprintf (&searchstr, "auth.login.%s.allow", brick_name);
if (-1 == ret) {
gf_log ("auth/login", GF_LOG_WARNING,
"asprintf failed while setting search string, "
"returning DONT-CARE");
goto out;
}
allow_user = dict_get (config_params, searchstr);
GF_FREE (searchstr);
if (allow_user) {
username_cpy = gf_strdup (allow_user->data);
if (!username_cpy)
goto out;
username_str = strtok_r (username_cpy, " ,", &tmp);
while (username_str) {
if (!fnmatch (username_str, username, 0)) {
ret = gf_asprintf (&searchstr,
"auth.login.%s.password",
username);
if (-1 == ret) {
gf_log ("auth/login", GF_LOG_WARNING,
"asprintf failed while setting search string");
goto out;
}
passwd_data = dict_get (config_params, searchstr);
GF_FREE (searchstr);
if (!passwd_data) {
gf_log ("auth/login", GF_LOG_ERROR,
"wrong username/password combination");
result = AUTH_REJECT;
goto out;
}
result = !((strcmp (data_to_str (passwd_data),
password)) ?
AUTH_ACCEPT :
AUTH_REJECT);
if (result == AUTH_REJECT)
gf_log ("auth/login", GF_LOG_ERROR,
"wrong password for user %s",
username);
break;
}
username_str = strtok_r (NULL, " ,", &tmp);
}
}
out:
if (username_cpy)
GF_FREE (username_cpy);
return result;
}
static int
invoke_rsync (int argc, char **argv)
{
int i = 0;
char *p = NULL;
pid_t pid = -1;
pid_t ppid = -1;
pid_t pida[] = {-1, -1};
char *name = NULL;
char buf[PATH_MAX + 1] = {0,};
int ret = 0;
assert (argv[argc] == NULL);
if (argc < 2 || strcmp (argv[1], "--server") != 0)
goto error;
for (i = 2; i < argc && argv[i][0] == '-'; i++);
if (!(i == argc - 2 && strcmp (argv[i], ".") == 0 && argv[i + 1][0] == '/')) {
fprintf (stderr, "need an rsync invocation without protected args\n");
goto error;
}
/* look up sshd we are spawned from */
for (pid = getpid () ;; pid = ppid) {
ppid = pidinfo (pid, &name);
if (ppid < 0) {
fprintf (stderr, "sshd ancestor not found\n");
goto error;
}
if (strcmp (name, "sshd") == 0)
break;
GF_FREE (name);
name = NULL;
}
/* look up "ssh-sibling" gsyncd */
pida[0] = pid;
ret = prociter (find_gsyncd, pida);
if (ret == -1 || pida[1] == -1) {
fprintf (stderr, "gsyncd sibling not found\n");
goto error;
}
/* check if rsync target matches gsyncd target */
if (gf_asprintf (&p, PROC"/%d/cwd", pida[1]) == -1) {
fprintf (stderr, "out of memory\n");
goto error;
}
ret = readlink (p, buf, sizeof (buf));
if (ret == -1 || ret == sizeof (buf))
goto error;
if (strcmp (argv[argc - 1], "/") == 0 /* root dir cannot be a target */ ||
(strcmp (argv[argc - 1], p) /* match against gluster target */ &&
strcmp (argv[argc - 1], buf) /* match against file target */) != 0) {
fprintf (stderr, "rsync target does not match "GEOREP" session\n");
goto error;
}
argv[0] = RSYNC;
execvp (RSYNC, argv);
if (p)
GF_FREE (p);
if (name)
GF_FREE (name);
fprintf (stderr, "exec of "RSYNC" failed\n");
return 127;
error:
if (p)
GF_FREE (p);
if (name)
GF_FREE (name);
fprintf (stderr, "disallowed "RSYNC" invocation\n");
return 1;
}
struct mem_pool *
mem_pool_new_fn (unsigned long sizeof_type,
unsigned long count, char *name)
{
struct mem_pool *mem_pool = NULL;
unsigned long padded_sizeof_type = 0;
GF_UNUSED void *pool = NULL;
GF_UNUSED int i = 0;
int ret = 0;
GF_UNUSED struct list_head *list = NULL;
glusterfs_ctx_t *ctx = NULL;
if (!sizeof_type || !count) {
gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
return NULL;
}
padded_sizeof_type = sizeof_type + GF_MEM_POOL_PAD_BOUNDARY;
mem_pool = GF_CALLOC (sizeof (*mem_pool), 1, gf_common_mt_mem_pool);
if (!mem_pool)
return NULL;
ret = gf_asprintf (&mem_pool->name, "%s:%s", THIS->name, name);
if (ret < 0)
return NULL;
if (!mem_pool->name) {
GF_FREE (mem_pool);
return NULL;
}
LOCK_INIT (&mem_pool->lock);
INIT_LIST_HEAD (&mem_pool->list);
INIT_LIST_HEAD (&mem_pool->global_list);
mem_pool->padded_sizeof_type = padded_sizeof_type;
mem_pool->real_sizeof_type = sizeof_type;
#ifndef DEBUG
mem_pool->cold_count = count;
pool = GF_CALLOC (count, padded_sizeof_type, gf_common_mt_long);
if (!pool) {
GF_FREE (mem_pool->name);
GF_FREE (mem_pool);
return NULL;
}
for (i = 0; i < count; i++) {
list = pool + (i * (padded_sizeof_type));
INIT_LIST_HEAD (list);
list_add_tail (list, &mem_pool->list);
}
mem_pool->pool = pool;
mem_pool->pool_end = pool + (count * (padded_sizeof_type));
#endif
/* add this pool to the global list */
ctx = THIS->ctx;
if (!ctx)
goto out;
list_add (&mem_pool->global_list, &ctx->mempool_list);
out:
return mem_pool;
}
pid_t
pidinfo (pid_t pid, char **name)
{
char buf[NAME_MAX * 2] = {0,};
FILE *f = NULL;
char *p = NULL;
char *free_p = NULL;
int ret = 0;
ret = gf_asprintf (&p, PROC"/%d/status", pid);
if (ret == -1)
goto oom;
f = fopen (p, "r");
if (!f) {
GF_FREE (p);
return -1;
}
free_p = p;
if (name)
*name = NULL;
for (;;) {
memset (buf, 0, sizeof (buf));
if (fgets (buf, sizeof (buf), f) == NULL ||
buf[strlen (buf) - 1] != '\n') {
pid = -1;
goto out;
}
buf[strlen (buf) -1] = '\0';
if (name && !*name) {
p = strtail (buf, "Name:");
if (p) {
while (isspace (*++p));
*name = gf_strdup (p);
if (!*name)
goto oom;
continue;
}
}
p = strtail (buf, "PPid:");
if (p)
break;
}
while (isspace (*++p));
ret = gf_string2int (p, &pid);
if (ret == -1)
pid = -1;
out:
if (free_p)
GF_FREE (free_p);
fclose (f);
return pid;
oom:
if (free_p)
GF_FREE (free_p);
fclose (f);
fprintf (stderr, "out of memory\n");
return -2;
}