char *SD_getServiceWSDL(const char *name, SDException *exception) {
SDServiceDetails *serviceDetails = NULL;
char *wsdl = NULL;
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
wsdl = sd_bdii_getServiceWSDL(name, exception);
if (!wsdl) {
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
}
if (serviceDetails) {
/* If we are emulating the getServiceWSDL method, we have to
* make a copy of the value */
if (serviceDetails->wsdl) {
wsdl = dupstr(serviceDetails->wsdl);
if (!wsdl)
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
} else
wsdl = NULL;
SD_freeServiceDetails(serviceDetails);
}
return wsdl;
}
int g2_sd_get_storage_path(const char *host, const char *spacetokendesc,
char **sa_path, char **sa_root, char *errbuf, int errbufsz) {
int rc = 0;
SDException exception;
LDAP *ld = NULL;
if (!host || !sa_path) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_storage_path]: Invalid Arguments passed to retrieve storage path", errbuf, errbufsz);
errno = EINVAL;
return (-1);
}
if ((ld = get_connection(&exception, errbuf, errbufsz)) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_storage_path]: Cannot connect to BDII", errbuf, errbufsz);
return (-1);
}
*sa_path = *sa_root = NULL;
rc = g2_get_voinfo(ld, host, spacetokendesc, sa_path, errbuf, errbufsz);
if (ld)
close_connection(ld);
return (rc);
}
char *SD_getServiceSite(const char *name, SDException *exception) {
SDServiceDetails *serviceDetails = NULL;
char *site = NULL;
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
serviceDetails = SD_getServiceDetails(name, exception);
if (serviceDetails) {
/* If we are emulating the getServiceSite method, we have to
* make a copy of the value */
if (serviceDetails->site) {
site = dupstr(serviceDetails->site);
if (!site)
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
} else
site = NULL;
SD_freeServiceDetails(serviceDetails);
}
if(!site){
SD_freeServiceDetails(serviceDetails);
SD_freeException(exception);
site = sd_bdii_getServiceSite(name, exception);
if(!site)
SD_freeServiceDetails(serviceDetails);
}
return site;
}
SDServiceList *SD_listServices(const char *type, const char *site, const SDVOList *vos, SDException *exception) {
SDServiceList *result = NULL;
SDVOList *tmpvos;
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
if (!site) {
site = getenv(SDEnv_SITE);
/* treat empty string as if it does not exist */
if (site && (strlen(site) == 0))
site = NULL;
}
tmpvos = NULL;
/* Let the user override the VO if the caller did not specify
* one explicitely */
if (!vos || !vos->numNames)
tmpvos = checkVOEnv();
result = SD_listServicesByData(NULL, type, site,
tmpvos ? tmpvos : vos,
exception);
if (tmpvos)
SD_freeVOList(tmpvos);
return result;
}
SDServiceDetails *SD_getServiceDetails(const char *name,
SDException *exception) {
SDServiceDetails *serviceDetails = NULL;
char delims[] = ",";
char *plugin = NULL;
plugin = plugin_is_set();
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
if (plugin == NULL) /*env is not set, query file,bdii with this order */ {
serviceDetails = sd_file_getServiceDetails(name, exception);
if (!serviceDetails) {
sd_file_freeServiceDetails(serviceDetails);
SD_freeException(exception);
serviceDetails = sd_bdii_getServiceDetails(name, exception);
}
} else /*env is set, check the order*/ {
char *comma = strchr(plugin, ',');
if (plugin && comma) {
char *result = NULL;
result = strtok(plugin, delims);
while (result != NULL) {
if (0 == strcmp(result, available_plungins[0])) /*file*/ {
SD_freeException(exception);
serviceDetails = sd_file_getServiceDetails(name, exception);
if (serviceDetails) {
break;
}
else
sd_file_freeServiceDetails(serviceDetails);
} else if (0 == strcmp(result, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
serviceDetails = sd_bdii_getServiceDetails(name, exception);
if (serviceDetails) {
break;
}
else
sd_bdii_freeServiceDetails(serviceDetails);
} else {
break;
}
result = strtok(NULL, delims);
}
} else {
if (plugin && 0 == strcmp(plugin, available_plungins[0])) /*file*/ {
SD_freeException(exception);
serviceDetails = sd_file_getServiceDetails(name, exception);
} else if (plugin && 0 == strcmp(plugin, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
serviceDetails = sd_bdii_getServiceDetails(name, exception);
}
}
}
if (plugin)
free(plugin);
return serviceDetails;
}
/*
return Glue2ServiceID as output,
by looking for an SRM Endpoint with the hostname matching the
EndpointURL and getting the Service ID from the EndpointServiceForeignKey.
*/
int g2_sd_get_service_id(LDAP *ld, const char *host, char **service_id, char **endpoint_id, char *errbuf, int errbufsz)
{
LDAPMessage *entry = NULL;
SDException exception;
LDAPMessage *reply = NULL;
struct berval **value = NULL;
char *query = NULL;
int sav_errno = 0;
*service_id = NULL;
*endpoint_id = NULL;
int rc = 0;
if (!host) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_service_id]: Hostname is not specified", errbuf, errbufsz);
return (-1);
}
query = g_strdup_printf(GLUE2_SERVICE_ID, host);
rc = connect_search_ldap(glue2_base, query, all_attrs, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply)
ldap_msgfree(reply);
if (query)
g_free(query);
return (-1);
}
if ((1 > ldap_count_entries(ld, reply))) {
if (reply)
ldap_msgfree(reply);
if (query)
g_free(query);
return (-1);
}
for (entry = ldap_first_entry(ld, reply); entry != NULL && rc == 0; entry
= ldap_next_entry(ld, entry)) {
if ( (value = ldap_get_values_len(ld, entry, GLUE2EndpointServiceForeignKey))) {
if (value && value[0]->bv_val) {
if ((*service_id = strdup(value[0]->bv_val)) == NULL) {
sav_errno = errno ? errno : ENOMEM;
}
ber_bvecfree(value);
}
}
if ( (value = ldap_get_values_len(ld, entry, GLUE2EndpointID))) {
if (value && value[0]->bv_val) {
if ((*endpoint_id = strdup(value[0]->bv_val)) == NULL) {
sav_errno = errno ? errno : ENOMEM;
}
ber_bvecfree(value);
}
}
if (reply)
ldap_msgfree(reply);
if(*service_id)
break;
}
if (query)
g_free(query);
if (!*service_id) {
if (!sav_errno) {
sav_errno = EINVAL;
}
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_service_id]: failed", errbuf, errbufsz);
errno = sav_errno;
return (-1);
}
return (0);
}
int g2_get_voinfo(LDAP *ld, const char *host, const char *spacetokendesc, char **sa_path, char *errbuf, int errbufsz) {
int i = 0;
LDAPMessage *entry = NULL;
char *filter = NULL;
int rc = 0;
LDAPMessage *reply = NULL;
struct berval **value = NULL;
int sav_errno = 0;
SDException exception;
char *vo = NULL;
storages *storage_shares = NULL;
storages *storage_shares_temp = NULL;
GSList* list = NULL;
char *GLUE2ShareID = NULL;
char *GLUE2StorageSharePath = NULL;
int list_length = 0;
char *service_id = NULL;
char *endpoint_id = NULL;
g_setenv("G_SLICE", "always-malloc", 1);
if ((vo = vo_global) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_get_voinfo]: Invalid Arguments.", errbuf, errbufsz);
errno = EINVAL;
return (-1);
}
if (!host || !sa_path) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_get_voinfo]: Invalid Arguments.", errbuf, errbufsz);
errno = EINVAL;
return (-1);
}
g2_sd_get_service_id(ld, host, &service_id, &endpoint_id, errbuf, errbufsz);
if(!service_id)
{
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_get_voinfo]: ServiceID cannot be found", errbuf, errbufsz);
if(ld)
close_connection(ld);
return (-1);
}
if (spacetokendesc)
rc = asprintf(&filter, GLUE2_STORAGE_PATH, service_id, spacetokendesc);
else
rc = asprintf(&filter, GLUE2_STORAGE_PATH_NO_ST, service_id);
if (rc < 0) return (-1);
*sa_path = NULL;
while (!*sa_path && !sav_errno) {
rc = connect_search_ldap(glue2_base, filter, g2_storage_path_attrs, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply) {
ldap_msgfree(reply);
}
if (filter)
free(filter);
sav_errno = errno;
goto out;
}
if ((1 > ldap_count_entries(ld, reply))) {
if (reply)
ldap_msgfree(reply);
if (filter)
free(filter);
goto out;
}
for (entry = ldap_first_entry(ld, reply); entry != NULL && rc == 0; entry
= ldap_next_entry(ld, entry)) {
if ((value = ldap_get_values_len(ld, entry, GLUE2_GLUE2ShareID)) != NULL) { /*get GLUE2_GLUE2ShareID*/
if (value && value[0]->bv_val) {
GLUE2ShareID = strdup(value[0]->bv_val);
if (value)
ber_bvecfree(value);
}
}
if ((value = ldap_get_values_len(ld, entry, GLUE2_GLUE2StorageSharePath)) != NULL) { /*get GLUE2_GLUE2ShareID*/
if (value && value[0]->bv_val) {
GLUE2StorageSharePath = strdup(value[0]->bv_val);
if (value)
ber_bvecfree(value);
}
}
/*append to the list*/
if (GLUE2StorageSharePath && GLUE2ShareID) {
storage_shares = g_new0(storages, 1);
storage_shares->GLUE2ShareID = GLUE2ShareID;
storage_shares->GLUE2StorageSharePath = GLUE2StorageSharePath;
list = g_slist_append(list, storage_shares);
}
} /*end for*/
if (reply)
ldap_msgfree(reply);
if (GLUE2StorageSharePath && GLUE2ShareID)
break;
} /*end while*/
if (filter)
free(filter);
if (list) {
list_length = g_slist_length(list);
for (i = 0; i < list_length; i++) {
storage_shares_temp = (storages *) g_slist_nth(list, i)->data;
rc = asprintf(&filter, GLUE2_STORAGE_POLICY, endpoint_id, vo);
rc = connect_search_ldap(glue2_base, filter, all_attrs, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply) {
ldap_msgfree(reply);
}
sav_errno = errno;
goto out;
}
if ((1 > ldap_count_entries(ld, reply))) {
if (reply)
ldap_msgfree(reply);
if (filter)
free(filter);
goto out;
} else {
if (filter)
free(filter);
if (storage_shares_temp->GLUE2StorageSharePath)
*sa_path = strdup(storage_shares_temp->GLUE2StorageSharePath);
}
}
}
out:
if (list) {
for (i = 0; i < list_length; i++) {
storage_shares_temp = (storages *) g_slist_nth(list, i)->data;
g_free(storage_shares_temp->GLUE2StorageSharePath);
g_free(storage_shares_temp->GLUE2ShareID);
g_free(storage_shares_temp);
}
g_slist_free(list);
}
if(service_id)
free(service_id);
if(endpoint_id)
free(endpoint_id);
if (!*sa_path) {
if (!sav_errno) {
if (spacetokendesc) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_storage_path]: no GLUE2StorageSharePath information found about tag and SE ", errbuf, errbufsz);
} else {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_storage_path]: no information found about SE (with no tag) ", errbuf, errbufsz);
}
sav_errno = EINVAL;
}
errno = sav_errno;
return (-1);
}
return (0);
}
/* get from the BDII the endpoint for the LFC */
int g2_sd_get_lfc_endpoint(char **lfc_endpoint, char *errbuf, int errbufsz) {
LDAPMessage *entry = NULL;
char *filter = NULL, *filter_tmp = NULL;
int rc = 0;
LDAPMessage *reply = NULL;
struct berval **value = NULL;
int sav_errno = 0;
*lfc_endpoint = NULL;
SDException exception;
char *query_policy = NULL;
char *lfc_fk = NULL;
LDAP *ld = NULL;
if ((filter_tmp = g2_generate_acbr("GLUE2PolicyID")) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_lfc_endpoint]: No GLUE2PolicyID found", errbuf, errbufsz);
return (-1);
}
if ((ld = get_connection(&exception, errbuf, errbufsz)) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_lfc_endpoint]: Cannot connect to BDII", errbuf, errbufsz);
return (-1);
}
query_policy = g_strdup_printf(GLUE2_QUERY_LFC_POLICY, filter_tmp);
free(filter_tmp);
while (!*lfc_endpoint && !sav_errno) {
/*get first the policy rule for a particular vo*/
rc = connect_search_ldap(glue2_base, query_policy, g2_lfc_endpoint_foreign_key_attrs, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply) {
ldap_msgfree(reply);
}
sav_errno = errno;
break;
}
if ((entry = ldap_first_entry(ld, reply)) && (value = ldap_get_values_len(ld, entry, GLUE2_ACCESS_POLICY_FK))) {
if (value && value[0]->bv_val) {
if ((lfc_fk = strdup(value[0]->bv_val)) == NULL)
sav_errno = errno ? errno : ENOMEM;
ldap_value_free_len(value);
}
}
/*now get the lfc endpoint*/
rc = asprintf(&filter, GLUE2_QUERY_LFC_ENDPOINT, lfc_fk);
free(lfc_fk);
if (rc < 0) {
if (reply) {
ldap_msgfree(reply);
}
if (filter)
free(filter);
break;
}
rc = connect_search_ldap(glue2_base, filter, g2_lfc_endpoint_attrs, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply) {
ldap_msgfree(reply);
}
if (filter)
free(filter);
sav_errno = errno;
break;
}
if ((entry = ldap_first_entry(ld, reply)) && (value = ldap_get_values_len(ld, entry, GLUE2_ATTR_ENDPOINT))) {
if (value && value[0]->bv_val) {
if ((*lfc_endpoint = strdup(value[0]->bv_val)) == NULL)
sav_errno = errno ? errno : ENOMEM;
ldap_value_free_len(value);
}
}
if (reply)
ldap_msgfree(reply);
if (filter)
free(filter);
if(!*lfc_endpoint)
break;
}
if (query_policy)
g_free(query_policy);
if (ld)
close_connection(ld);
if (!*lfc_endpoint) {
if (!sav_errno) {
sav_errno = EINVAL;
}
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_lfc_endpoint]: No LFC Endpoint found", errbuf, errbufsz);
errno = sav_errno;
return (-1);
}
return 0;
}
int g2_sd_get_ce_ap(const char *host, char **ce_ap, char *errbuf, int errbufsz) {
LDAPMessage *entry = NULL;
SDException exception;
LDAPMessage *reply = NULL;
struct berval **value = NULL;
char *query = NULL;
int sav_errno = 0;
*ce_ap = NULL;
int rc = 0;
LDAP *ld = NULL;
char *service_id = NULL;
char *endpoint_id = NULL;
if (!host) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_ce_ap]: Hostname is not specified", errbuf, errbufsz);
return (-1);
}
if ((ld = get_connection(&exception, errbuf, errbufsz)) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_ce_ap]: Cannot connect to BDII", errbuf, errbufsz);
if (query)
g_free(query);
return (-1);
}
g2_sd_get_service_id(ld, host, &service_id, &endpoint_id, errbuf, errbufsz);
if(!service_id)
{
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_ce_ap]: ServiceID cannot be found", errbuf, errbufsz);
if(endpoint_id)
free(endpoint_id);
if(ld)
close_connection(ld);
return (-1);
}
query = g_strdup_printf(GLUE2_QUERY_CESE_BIND, service_id);
rc = connect_search_ldap(glue2_base, query, g2_ce_ap_attrs, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply)
ldap_msgfree(reply);
if (query)
g_free(query);
if (ld)
close_connection(ld);
if(service_id)
free(service_id);
sav_errno = errno;
rc = -1;
goto out;
}
if ((1 > ldap_count_entries(ld, reply))) {
if (reply)
ldap_msgfree(reply);
if (query)
g_free(query);
if (ld)
close_connection(ld);
if(service_id)
free(service_id);
goto out;
}
for (entry = ldap_first_entry(ld, reply); entry != NULL && rc == 0; entry
= ldap_next_entry(ld, entry)) {
if ((entry = ldap_first_entry(ld, reply)) && (value
= ldap_get_values_len(ld, entry, GLUE2_ATTR_CE_AP_ATNM))) {
if (value && value[0]->bv_val) {
if ((*ce_ap = strdup(value[0]->bv_val)) == NULL) {
sav_errno = errno ? errno : ENOMEM;
}
ber_bvecfree(value);
}
}
if (reply)
ldap_msgfree(reply);
if(*ce_ap)
break;
}
if (query)
g_free(query);
if (ld)
close_connection(ld);
if(service_id)
free(service_id);
if(endpoint_id)
free(endpoint_id);
out:
if (!*ce_ap) {
if (!sav_errno) {
sav_errno = EINVAL;
}
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_ce_ap]: No GLUE2ToComputingServiceID or GLUE2ToComputingServiceLocalPath found.", errbuf, errbufsz);
errno = sav_errno;
return (-1);
}
return (0);
}
int g2_sd_is_online(char *host, char *errbuf, int errbufsz) {
char host_tmp[255];
LDAPMessage *reply = NULL;
SDException exception;
LDAP *ld = NULL;
char *query = NULL;
int rc = 0;
int is_production = 0;
char *service_id = NULL;
char *endpoint_id = NULL;
if (!host) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_is_online]: Host is empty", errbuf, errbufsz);
return (-1);
}
if ((ld = get_connection(&exception, errbuf, errbufsz)) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_is_online]: Cannot connect to BDII", errbuf, errbufsz);
return (-1);
}
g2_sd_get_service_id(ld, host, &service_id, &endpoint_id, errbuf, errbufsz);
if(!service_id)
{
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_is_online]: ServiceID cannot be found", errbuf, errbufsz);
if(ld)
close_connection(ld);
return (-1);
}
strncpy(host_tmp, host, 255);
query = g_strdup_printf(GLUE2_QUERY_SE_STATUS, service_id);
rc = connect_search_ldap(glue2_base, query, NULL, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_is_online]: No available information", errbuf, errbufsz);
goto out;
}
if ((ldap_count_entries(ld, reply)) < 1)
is_production = 0;
else
is_production = 1;
out:
if (service_id)
free(service_id);
if (endpoint_id)
free(endpoint_id);
if (reply)
ldap_msgfree(reply);
if (query)
g_free(query);
if (ld)
close_connection(ld);
if (is_production == 0)
return (-1);
return 0;
}
SDServiceList *SD_listAssociatedServices(const char *name,
const char *type, const char *site, const SDVOList *vos,
SDException *exception) {
SDServiceList *serviceDetails = NULL;
SDVOList *tmpvos;
char delims[] = ",";
char *plugin = NULL;
plugin = plugin_is_set();
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
if (!site) {
site = getenv(SDEnv_SITE);
/* treat empty string as if it does not exist */
if (site && (strlen(site) == 0))
site = NULL;
}
tmpvos = NULL;
/* Let the user override the VO if the caller did not specify
* one explicitely */
if (!vos || !vos->numNames)
tmpvos = checkVOEnv();
if (NULL == plugin) /*env is not set, query file,bdii with this order */ {
serviceDetails = sd_file_listAssociatedServices(name, type, site, tmpvos ? tmpvos : vos, exception);
if (!serviceDetails) {
sd_file_freeServiceList(serviceDetails);
SD_freeException(exception);
serviceDetails = sd_bdii_listAssociatedServices(name, type, site, tmpvos ? tmpvos : vos, exception);
}
} else /*env is set, check the order*/ {
char *comma = strchr(plugin, ',');
if (plugin && comma) {
char *result = NULL;
result = strtok(plugin, delims);
while (result != NULL) {
if (0 == strcmp(result, available_plungins[0])) /*file*/ {
SD_freeException(exception);
serviceDetails = sd_file_listAssociatedServices(name, type, site, tmpvos ? tmpvos : vos, exception);
if (serviceDetails) {
break;
}
else
sd_file_freeServiceList(serviceDetails);
} else if (0 == strcmp(result, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
serviceDetails = sd_bdii_listAssociatedServices(name, type, site, tmpvos ? tmpvos : vos, exception);
if (serviceDetails) {
break;
}
else
sd_file_freeServiceList(serviceDetails);
} else {
break;
}
result = strtok(NULL, delims);
}
} else {
if (plugin && 0 == strcmp(plugin, available_plungins[0])) /*file*/ {
SD_freeException(exception);
serviceDetails = sd_file_listAssociatedServices(name, type, site, tmpvos ? tmpvos : vos, exception);
} else if (plugin && 0 == strcmp(plugin, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
serviceDetails = sd_bdii_listAssociatedServices(name, type, site, tmpvos ? tmpvos : vos, exception);
}
}
}
if (tmpvos)
SD_freeVOList(tmpvos);
if (plugin)
free(plugin);
return serviceDetails;
}
SDServiceList *SD_listServicesByHost(const char *type, const char *host,
const SDVOList *vos, SDException *exception) {
SDServiceList *result = NULL;
SDVOList *tmpvos = NULL;
int i=0, j=0;
int numServices=0;
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
tmpvos = NULL;
/* Let the user override the VO if the caller did not specify
* one explicitely */
if (!vos || !vos->numNames)
tmpvos = checkVOEnv();
/*
result = sd_bdii_listServicesByHost(type, host, tmpvos ? tmpvos : vos, exception);
if (!result) {
sd_bdii_freeServiceList(result);
SD_freeException(exception);
*/
/* filter the host and port from the result of */
/* listServices on the client side */
result = SD_listServices(type, NULL, tmpvos ? tmpvos : vos, exception);
if (result != NULL && exception->status == SDStatus_SUCCESS) {
/* Check for the host name in the endpoint in this order:
// 1. ^host$
// 2. ^host:
// 3. /host:
// 4. /host/
// 5. host
// Run the filtering with the first matching pattern.
// TODO: implement the filtering in bdii-c */
int f, fmatched;
SD_matchEndpointHost matchFunction = NULL;
for (f = 0; f < SD_num_matches; f++) {
matchFunction = SD_matchEndpointHostFunctions[f];
fmatched = 0;
for (i = 0; i < result->numServices; i++) {
if (result->services[i]->endpoint != NULL) {
if (matchFunction(result->services[i]->endpoint, host)) {
fmatched++;
}
}
} /* end for loop
// break the loop, if there was a match and use that for filtering */
if (fmatched > 0) break;
}
/* in the worst case, when there was no match,
// matchFunction will point to the last function */
for (i = 0; i < result->numServices; i++) {
if (result->services[i]->endpoint != NULL) {
/* check if the endpoint contains the host name */
if (!matchFunction(result->services[i]->endpoint, host)) {
/* no match. Delete the service entry and mark it as null
// in the list */
SD_freeService(result->services[i]);
result->services[i] = NULL;
}
}
} /* end for loop
// Reorder the list so the nulls are at the end
// Please Note: this algorithm may not be the best one but the
// number of expected elements should be quite limited, so it
// shouldn't be a real problem */
numServices = 0;
for (i = 0; i < result->numServices; ++i) {
if (NULL == result->services[i]) {
/* Get the next valid one */
for (j = i + 1; j < result->numServices; ++j) {
if (NULL != result->services[j]) {
/* Swicth the two elements */
result->services[i] = result->services[j];
result->services[j] = 0;
++numServices;
break;
}
}
} else {
++numServices;
}
} /* end reordering loop */
result->numServices = numServices;
} /* if result != NULL */
//}
if(numServices == 0){
sd_file_freeServiceList(result);
SD_freeException(exception);
result = sd_bdii_listServicesByHost(type, host, tmpvos ? tmpvos : vos, exception);
if (!result) {
sd_bdii_freeServiceList(result);
SD_freeException(exception);
}
}
if (tmpvos)
SD_freeVOList(tmpvos);
return result;
}
SDService *SD_getService(const char *name, SDException *exception) {
SDServiceDetails *serviceDetails = NULL;
SDService *service = NULL;
char delims[] = ",";
char *plugin = NULL;
plugin = plugin_is_set();
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
if (NULL == plugin) /*env is not set, query file,bdii with this order */ {
service = sd_file_getService(name, exception);
if (!service) {
sd_file_freeService(service);
SD_freeException(exception);
service = sd_bdii_getService(name, exception);
if (!service) {
sd_bdii_freeService(service);
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
if(!serviceDetails){
SD_freeServiceDetails(serviceDetails);
}
}
}
} else /*env is set, check the order*/ {
char *comma = strchr(plugin, ',');
if (plugin && comma) {
char *result = NULL;
result = strtok(plugin, delims);
while (result != NULL) {
if (0 == strcmp(result, available_plungins[0])) /*file*/ {
SD_freeException(exception);
service = sd_file_getService(name, exception);
if (service) {
break;
}
else
sd_file_freeService(service);
} else if (0 == strcmp(result, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
service = sd_bdii_getService(name, exception);
if (service) {
break;
}
else
sd_bdii_freeService(service);
} else {
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
if (serviceDetails) {
break;
}
else
SD_freeServiceDetails(serviceDetails);
}
result = strtok(NULL, delims);
}
} else {
if (plugin && 0 == strcmp(plugin, available_plungins[0])) /*file*/ {
SD_freeException(exception);
service = sd_file_getService(name, exception);
if (!service)
sd_file_freeService(service);
} else if (plugin && 0 == strcmp(plugin, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
service = sd_bdii_getService(name, exception);
if(!service)
sd_bdii_freeService(service);
} else {
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
}
}
}
if (serviceDetails) {
/* If we are emulating the getService method, we have to make
* a copy of the data */
service = (SDService *) calloc(1, sizeof (SDService));
if (!service)
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
else {
/* Copy the basic service data */
service->name = dupstr(serviceDetails->name);
service->type = dupstr(serviceDetails->type);
service->endpoint = dupstr(serviceDetails->endpoint);
service->version = dupstr(serviceDetails->version);
/* Check for failed dupstr()s */
if (!service->name || !service->type || !service->endpoint ||
!service->version) {
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
SD_freeService(service);
service = NULL;
}
}
SD_freeServiceDetails(serviceDetails);
}
if (plugin)
free(plugin);
return service;
}
SDServiceDataList *SD_getServiceData(const char *name,
SDException *exception) {
SDServiceDetails *serviceDetails = NULL;
SDServiceDataList *list = NULL;
char delims[] = ",";
char *plugin = NULL;
plugin = plugin_is_set();
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
if (NULL == plugin) /*env is not set, query file,bdii with this order */ {
list = sd_file_getServiceData(name, exception);
if (!list) {
sd_file_freeServiceDataList(list);
SD_freeException(exception);
list = sd_bdii_getServiceData(name, exception);
if (!list) {
sd_bdii_freeServiceDataList(list);
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
}
}
} else /*env is set, check the order*/ {
char *comma = strchr(plugin, ',');
if (plugin && comma) {
char *result = NULL;
result = strtok(plugin, delims);
while (result != NULL) {
if (0 == strcmp(result, available_plungins[0])) /*file*/ {
SD_freeException(exception);
list = sd_file_getServiceData(name, exception);
if (list) {
break;
}
else
sd_file_freeServiceDataList(list);
} else if (0 == strcmp(result, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
list = sd_bdii_getServiceData(name, exception);
if (list) {
break;
}
else
sd_bdii_freeServiceDataList(list);
} else {
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
if (serviceDetails) {
break;
}
}
result = strtok(NULL, delims);
}
} else {
if (plugin && 0 == strcmp(plugin, available_plungins[0])) /*file*/ {
SD_freeException(exception);
list = sd_file_getServiceData(name, exception);
} else if (plugin && 0 == strcmp(plugin, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
list = sd_bdii_getServiceData(name, exception);
} else {
serviceDetails = SD_getServiceDetails(name, exception);
}
}
}
if (serviceDetails) {
/* If we are emulating the getServiceData method, we have to make
* a copy of the data list */
int i;
list = (SDServiceDataList *) malloc(sizeof (SDServiceDataList));
if (!list)
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
else {
list->numItems = serviceDetails->data->numItems;
list->items = (SDServiceData *) calloc(list->numItems, sizeof (SDServiceData));
if (!list->items) {
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
SD_freeServiceDataList(list);
list = NULL;
}
}
for (i = 0; list && i < list->numItems; i++) {
list->items[i].key = dupstr(serviceDetails->data->items[i].key);
list->items[i].value = dupstr(serviceDetails->data->items[i].value);
if (!list->items[i].key || !list->items[i].value) {
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
SD_freeServiceDataList(list);
list = NULL;
break;
}
}
SD_freeServiceDetails(serviceDetails);
}
if (plugin)
free(plugin);
return list;
}
int g2_sd_get_se_types_and_endpoints(const char *host, char ***se_types,
char ***se_endpoints, char *errbuf, int errbufsz) {
char host_tmp[255];
int len_tmp = 0;
char *port = NULL;
LDAPMessage *entry = NULL;
SDException exception;
char *query = NULL;
int i, nbentries = 0, n = 0, rc = 0;
char **sep = NULL, **stp = NULL, **st = NULL, **sv = NULL, **ep = NULL;
struct berval **value = NULL;
int sav_errno = 0;
LDAPMessage *reply = NULL;
LDAP *ld = NULL;
char *service_id = NULL;
char *endpoint_id = NULL;
*se_types = NULL;
*se_endpoints = NULL;
if (!host) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_se_types_and_endpoints]: Hostname in empty", errbuf, errbufsz);
return -1;
}
if ((ld = get_connection(&exception, errbuf, errbufsz)) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_se_types_and_endpoints]: Cannot connect to BDII", errbuf, errbufsz);
return (-1);
}
g2_sd_get_service_id(ld, host, &service_id, &endpoint_id, errbuf, errbufsz);
if(!service_id)
{
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_se_types_and_endpoints]: ServiceID cannot be found", errbuf, errbufsz);
if(ld)
close_connection(ld);
return (-1);
}
strncpy(host_tmp, host, 255);
if ((port = strchr(host_tmp, ':')) != NULL)
*port = 0;
query = g_strdup_printf(GLUE2_QUERY_TYPE_ENDPOINTS, service_id);
while (nbentries < 1 && !sav_errno) {
rc = connect_search_ldap(glue2_base, query, NULL, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply) {
ldap_msgfree(reply);
}
rc = -1;
sav_errno = errno;
break;
}
if ((nbentries = ldap_count_entries(ld, reply)) < 1) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_se_types_and_endpoints]: No entries found for host.", errbuf, errbufsz);
if (reply) {
ldap_msgfree(reply);
}
rc = -1;
break;
}
++nbentries;
if ((st = calloc(nbentries, sizeof (char *))) == NULL || (sv = calloc(
nbentries, sizeof (char *))) == NULL || (ep = calloc(nbentries,
sizeof (char *))) == NULL || (stp = calloc(nbentries,
sizeof (char *))) == NULL || (sep = calloc(nbentries,
sizeof (char *))) == NULL) {
if (reply) {
ldap_msgfree(reply);
}
sav_errno = errno ? errno : ENOMEM;
rc = -1;
break;
}
for (entry = ldap_first_entry(ld, reply); entry != NULL && rc == 0; entry
= ldap_next_entry(ld, entry)) {
if ((value = ldap_get_values_len(ld, entry, GLUE2_ATTR_ENDPOINT)) != NULL) {
if (value && value[0]->bv_val) {
ep[n] = strdup(value[0]->bv_val);
if (value)
ber_bvecfree(value);
if ((value = ldap_get_values_len(ld, entry, GLUE2_ATTR_TYPE)) == NULL) {
if (value && ep[n]) {
ber_bvecfree(value);
free(ep[n]);
continue;
}
}
if (st)
st[n] = strdup(value[0]->bv_val);
if (value)
ber_bvecfree(value);
if ((value = ldap_get_values_len(ld, entry, GLUE2_ATTR_VERSION))
== NULL) {
if (value && ep[n] && st[n]) {
ber_bvecfree(value);
free(ep[n]);
free(st[n]);
continue;
}
}
if (sv && value && value[0]->bv_val)
sv[n] = strdup(value[0]->bv_val);
if (value)
ber_bvecfree(value);
++n;
}
} else {
if (port == NULL) {
/* If port is not yet defined in host_tmp, and is available
// it is copied to host_tmp buffer
// ... But it will only be used if there is no GLUE2EndpointURL entry */
if (value)
ber_bvecfree(value);
value = ldap_get_values_len(ld, entry, "GLUE2EndpointURL");
if (value == NULL) {
if (nbentries == 1) {
sav_errno = EINVAL;
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_se_types_and_endpoints]: No port published in the BDII for Glue2", errbuf, errbufsz);
}
} else if (value && value[0]->bv_val && len_tmp + strlen(value[0]->bv_val) + 1 < 255) {
port = host_tmp + len_tmp;
strcpy(port + 1, value[0]->bv_val);
} else {
if (value)
ber_bvecfree(value);
sav_errno = ENAMETOOLONG;
if (reply) {
ldap_msgfree(reply);
}
break;
}
}
if (value)
ber_bvecfree(value);
}
}
if (reply) {
ldap_msgfree(reply);
}
}
if (rc < 0) {
for (i = 0; i < n; ++i) {
if (st && st[i])
free(st[i]);
if (sv && sv[i])
free(sv[i]);
if (ep && ep[i])
free(ep[i]);
}
if (st)
free(st);
if (sv)
free(sv);
if (ep)
free(ep);
if (stp)
free(stp);
if (sep)
free(sep);
errno = sav_errno ? sav_errno : EINVAL;
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_se_types_and_endpoints]: No available information", errbuf, errbufsz);
} else {
if (n > 0) {
for (i = 0; i < n; ++i) {
if ((strcmp(st[i], "srm_v1") == 0 || strcmp(st[i], "srm_v2")
== 0) && ep[i]) {
stp[i] = strdup(st[i]);
sep[i] = strdup(ep[i]);
} else if ((strcasecmp(st[i], "SRM") == 0) && (strncmp(sv[i],
"1.", 2)) == 0 && ep[i]) {
stp[i] = strdup("srm_v1");
sep[i] = strdup(ep[i]);
} else if ((strcasecmp(st[i], "SRM") == 0) && (strncmp(sv[i],
"2.2", 3)) == 0 && ep[i]) {
stp[i] = strdup("srm_v2");
sep[i] = strdup(ep[i]);
}
free(st[i]);
free(sv[i]);
free(ep[i]);
}
free(st);
free(sv);
free(ep);
} else if (n == 0 && port != NULL && stp && sep) {
/* There were no GLUE2EndpointID entries...
// ... so endpoint is hostname:port, and type is disk */
*port = ':';
stp[0] = strdup("disk");
sep[0] = strdup(host_tmp);
} else {
free(stp);
free(sep);
rc = -1;
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_se_types_and_endpoints]: No available information found for SE", errbuf, errbufsz);
errno = EINVAL;
}
if (rc == 0) {
*se_types = stp;
*se_endpoints = sep;
}
}
if (ld)
close_connection(ld);
if (query)
g_free(query);
if (service_id)
free(service_id);
if (endpoint_id)
free(endpoint_id);
return (rc);
}
/* get from the BDII the list of supported protocols with their associated
* port number
*/
int g2_sd_get_seap_info(const char *host, char ***access_protocol, int **port, char *errbuf, int errbufsz) {
char **ap = NULL, *attr = NULL;
char *query = NULL;
struct berval **value = NULL;
BerElement *ber = NULL;
int nbentries, i = 0, n = 0, rc = 0;
int *pn = NULL;
LDAPMessage *entry = NULL, *reply = NULL;
SDException exception;
int sav_errno = 0;
char *tempUrl = NULL;
char *base_scheme = NULL;
char *base_host = NULL;
char *base_path = NULL;
int base_port = 0;
LDAP *ld = NULL;
char *service_id = NULL;
char *endpoint_id = NULL;
if (!host) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_seap_info]: Hostname in null", errbuf, errbufsz);
return -1;
}
if ((ld = get_connection(&exception, errbuf, errbufsz)) == NULL) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_seap_info]: Cannot connect to BDII", errbuf, errbufsz);
return (-1);
}
g2_sd_get_service_id(ld, host, &service_id, &endpoint_id, errbuf, errbufsz);
if(!service_id)
{
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_seap_info]: ServiceID cannot be found", errbuf, errbufsz);
if(ld)
close_connection(ld);
return (-1);
}
/*prepare the query */
query = g_strdup_printf(GLUE2_QUERY_PROTO_PORT_TYPE, service_id);
while (n < 1 && !sav_errno) {
/*send query to bdii server*/
rc = connect_search_ldap(glue2_base, query, g2_seap_attrs, ld, &exception, &reply, errbuf, errbufsz);
if (rc != LDAP_SUCCESS) {
if (reply) {
ldap_msgfree(reply);
}
rc = -1;
sav_errno = errno;
break;
}
/*count entry # */
if ((nbentries = ldap_count_entries(ld, reply)) < 1) {
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_seap_info]: No entries for host.", errbuf, errbufsz);
if (reply) {
ldap_msgfree(reply);
}
sav_errno = errno ? errno : ENOMEM;
rc = -1;
break;
}
nbentries++;
/*allocate memory */
if ((ap = (char **) calloc(nbentries, sizeof (char *))) == NULL || (pn
= (int *) calloc(nbentries, sizeof (int))) == NULL) {
if (reply) {
ldap_msgfree(reply);
}
sav_errno = errno ? errno : ENOMEM;
rc = -1;
break;
}
for (entry = ldap_first_entry(ld, reply), n = 0; entry != NULL && rc
== 0; entry = ldap_next_entry(ld, entry), ++n) {
for (attr = ldap_first_attribute(ld, entry, &ber); attr != NULL
&& rc == 0; attr = ldap_next_attribute(ld, entry, ber)) {
if (!ap[n] && (value = ldap_get_values_len(ld, entry, attr))) {
if (value && value[0]->bv_val) {
if (strcmp(attr, "GLUE2EndpointURL") == 0) {
if ((ap[n] = strdup(value[0]->bv_val)) == NULL) {
rc = -1;
sav_errno = errno ? errno : ENOMEM;
} else {
tempUrl = ap[n];
if (tempUrl)
parse_url(tempUrl, &base_scheme, &base_host, &base_port, &base_path);
if (base_scheme && base_port > 0) {
free(ap[n]);
ap[n] = base_scheme; /* protocol */
pn[n] = base_port; /* port */
} else {
rc = -1;
sav_errno = errno ? errno : ENOMEM;
}
}
if (value)
ber_bvecfree(value);
}
}
}
if (attr)
ldap_memfree(attr);
}
if (ber) {
ber_free(ber, 0);
ber = NULL;
}
}
if (reply) {
ldap_msgfree(reply);
}
if (base_host)
free(base_host);
if (base_path)
free(base_path);
}
/* if something went wrong, give the memory free */
if (rc < 0) {
for (i = 0; i < n; ++i) {
if (ap[i]) {
free(ap[i]);
}
}
if (ap && pn) {
free(ap);
free(pn);
}
SD_setException(&exception, SDStatus_FAILURE, "[BDII][g2_sd_get_seap_info]: No available information", errbuf, errbufsz);
errno = sav_errno ? sav_errno : EINVAL;
} else /*return the values via pointer*/ {
*access_protocol = ap;
*port = pn;
}
if (query)
g_free(query);
if (ld)
close_connection(ld);
if (service_id)
free(service_id);
if (endpoint_id)
free(endpoint_id);
return (rc);
}
char *SD_getServiceDataItem(const char *name, const char *key,
SDException *exception) {
SDServiceDetails *serviceDetails = NULL;
SDServiceDataList *list = NULL;
char *value = NULL;
char delims[] = ",";
char *plugin = NULL;
plugin = plugin_is_set();
SD_setException(exception, SDStatus_SUCCESS, NULL, NULL, 0);
if (NULL == plugin) /*env is not set*/ {
list = sd_file_getServiceData(name, exception);
if(!list){
SD_freeException(exception);
sd_file_freeServiceDataList(list);
value = sd_bdii_getServiceDataItem(name, key, exception);
if(!value){
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
}
}
} else /*env is set, check the order*/ {
char *comma = strchr(plugin, ',');
if (plugin && comma) {
char *result = NULL;
result = strtok(plugin, delims);
while (result != NULL) {
if (0 == strcmp(result, available_plungins[0])) /*file*/ {
SD_freeException(exception);
list = sd_file_getServiceData(name, exception);
if (list) {
break;
}
} else if (0 == strcmp(result, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
value = sd_bdii_getServiceDataItem(name, key, exception);
if (value) {
break;
}
} else {
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
if (serviceDetails) {
break;
}
}
result = strtok(NULL, delims);
}
} else {
if (plugin && 0 == strcmp(plugin, available_plungins[0])) /*file*/ {
SD_freeException(exception);
list = sd_file_getServiceData(name, exception);
} else if (plugin && 0 == strcmp(plugin, available_plungins[1])) /*bdii*/ {
SD_freeException(exception);
list = sd_bdii_getServiceData(name, exception);
} else {
SD_freeException(exception);
serviceDetails = SD_getServiceDetails(name, exception);
}
}
}
if (serviceDetails)
list = serviceDetails->data;
if (list) {
/* If we are emulating the getServiceDataItem method, we have to
* look up the key and make a copy of the value */
int i;
value = NULL;
for (i = 0; i < list->numItems; i++) {
if (!strcmp(list->items[i].key, key)) {
value = dupstr(list->items[i].value);
if (!value)
SD_setException(exception, SDStatus_FAILURE, ERROR_OUTOFMEMORY, NULL, 0);
break;
}
}
}
if (serviceDetails)
SD_freeServiceDetails(serviceDetails);
else if (list)
SD_freeServiceDataList(list);
if (plugin)
free(plugin);
return value;
}
