int clean_network_state(void) {
int rc, i;
char cmd[MAX_PATH], file[MAX_PATH], rootwrap[MAX_PATH], *pidstr=NULL, *ipstr=NULL;
struct stat statbuf;
vnetConfig *tmpvnetconfig;
tmpvnetconfig = malloc(sizeof(vnetConfig));
if(!tmpvnetconfig) {
logprintfl(EUCAERROR, "out of memory\n");
return -1;
}
memcpy(tmpvnetconfig, vnetconfig, sizeof(vnetConfig));
rc = vnetUnsetMetadataRedirect(tmpvnetconfig);
if (rc) {
logprintfl(EUCAWARN, "failed to unset metadata redirect\n");
}
for (i=1; i<NUMBER_OF_PUBLIC_IPS; i++) {
if (tmpvnetconfig->publicips[i].ip != 0 && tmpvnetconfig->publicips[i].allocated != 0) {
ipstr = hex2dot(tmpvnetconfig->publicips[i].ip);
snprintf(cmd, MAX_PATH, EUCALYPTUS_ROOTWRAP " ip addr del %s/32 dev %s", config->eucahome, SP(ipstr), tmpvnetconfig->pubInterface);
logprintfl(EUCADEBUG, "running command '%s'\n", cmd);
rc = system(cmd);
rc = rc>>8;
if (rc && rc != 2) {
logprintfl(EUCAERROR, "running cmd '%s' failed: cannot remove ip %s\n", cmd, SP(ipstr));
}
if (ipstr) free(ipstr);
}
}
//!
//! Function description.
//!
//! @param[in] ipsh pointer to the IP set handler structure
//!
//! @return
//!
//! @see
//!
//! @pre
//!
//! @post
//!
//! @note
//!
int ips_handler_print(ips_handler * ipsh)
{
int i, j;
char *strptra = NULL;
if (!ipsh) {
return (1);
}
if (log_level_get() == EUCA_LOG_TRACE) {
for (i = 0; i < ipsh->max_sets; i++) {
LOGTRACE("IPSET NAME: %s\n", ipsh->sets[i].name);
for (j = 0; j < ipsh->sets[i].max_member_ips; j++) {
strptra = hex2dot(ipsh->sets[i].member_ips[j]);
LOGTRACE("\t MEMBER IP: %s/%d\n", strptra, ipsh->sets[i].member_nms[j]);
EUCA_FREE(strptra);
}
}
}
return (0);
}
//!
//!
//!
//! @return
//!
//! @pre
//!
//! @note
//!
int clean_network_state(void)
{
int rc = 0;
int i = 0;
char cmd[MAX_PATH] = { 0 };
char file[MAX_PATH] = { 0 };
char rootwrap[MAX_PATH] = { 0 };
char *pidstr = NULL;
char *ipstr = NULL;
vnetConfig *tmpvnetconfig = NULL;
tmpvnetconfig = EUCA_ZALLOC(1, sizeof(vnetConfig));
if (!tmpvnetconfig) {
LOGERROR("out of memory\n");
return -1;
}
memcpy(tmpvnetconfig, vnetconfig, sizeof(vnetConfig));
rc = vnetUnsetMetadataRedirect(tmpvnetconfig);
if (rc) {
LOGWARN("failed to unset metadata redirect\n");
}
for (i = 1; i < NUMBER_OF_PUBLIC_IPS; i++) {
if (tmpvnetconfig->publicips[i].ip != 0 && tmpvnetconfig->publicips[i].allocated != 0) {
ipstr = hex2dot(tmpvnetconfig->publicips[i].ip);
snprintf(cmd, MAX_PATH, EUCALYPTUS_ROOTWRAP " ip addr del %s/32 dev %s", config->eucahome, SP(ipstr), tmpvnetconfig->pubInterface);
LOGDEBUG("running command '%s'\n", cmd);
rc = system(cmd);
rc = rc >> 8;
if (rc && rc != 2) {
LOGERROR("running cmd '%s' failed: cannot remove ip %s\n", cmd, SP(ipstr));
}
EUCA_FREE(ipstr);
}
}
//!
//! Function description.
//!
//! @param[in] ipsh pointer to the IP set handler structure
//! @param[in] dodelete set to 1 if we need to flush an empty set or 0 if we ignore
//!
//! @return
//!
//! @see
//!
//! @pre
//!
//! @post
//!
//! @note
//!
int ips_handler_deploy(ips_handler * ipsh, int dodelete)
{
int i = 0;
int j = 0;
FILE *FH = NULL;
char *strptra = NULL;
if (!ipsh || !ipsh->init) {
return (1);
}
FH = fopen(ipsh->ips_file, "w");
if (!FH) {
LOGERROR("could not open file for write '%s': check permissions\n", ipsh->ips_file);
return (1);
}
for (i = 0; i < ipsh->max_sets; i++) {
if (ipsh->sets[i].ref_count) {
fprintf(FH, "create %s hash:net family inet hashsize 2048 maxelem 65536\n", ipsh->sets[i].name);
fprintf(FH, "flush %s\n", ipsh->sets[i].name);
for (j = 0; j < ipsh->sets[i].max_member_ips; j++) {
strptra = hex2dot(ipsh->sets[i].member_ips[j]);
LOGDEBUG("adding ip/nm %s/%d to ipset %s\n", strptra, ipsh->sets[i].member_nms[j], ipsh->sets[i].name);
fprintf(FH, "add %s %s/%d\n", ipsh->sets[i].name, strptra, ipsh->sets[i].member_nms[j]);
EUCA_FREE(strptra);
}
} else if ((ipsh->sets[i].ref_count == 0) && dodelete) {
fprintf(FH, "create %s hash:net family inet hashsize 2048 maxelem 65536\n", ipsh->sets[i].name);
fprintf(FH, "flush %s\n", ipsh->sets[i].name);
fprintf(FH, "destroy %s\n", ipsh->sets[i].name);
}
}
fclose(FH);
return (ips_system_restore(ipsh));
}
/**
* Perform network driver upgrade. This function should be invoked once when eucanetd
* starts.
* @param pConfig [in] a pointer to eucanetd system-wide configuration
* @param pGni [in] a pointer to the Global Network Information structure
* @return 0 on success. Integer number on failure.
*/
static int network_driver_upgrade(eucanetdConfig *pConfig, globalNetworkInfo *pGni) {
int ret = 0;
int rc = 0;
// Skip upgrade in flush mode
if (pMidoConfig && pMidoConfig->config && (pMidoConfig->config->flushmode != FLUSH_NONE)) {
LOGTRACE("\tflush mode selected. Skipping upgrade\n");
return (0);
}
LOGDEBUG("Upgrade '%s' network driver.\n", DRIVER_NAME());
if (!pConfig || !pGni) {
LOGERROR("Invalid argument: cannot process upgrade with NULL config.\n");
return (1);
}
// Make sure midoname buffer is available
midonet_api_cache_midos_init();
u32 mido_euca_version = 0;
char *mido_euca_version_str = NULL;
midoname **ipgs = NULL;
int max_ipgs = 0;
midoname **ips = NULL;
int max_ips = 0;
rc = mido_get_ipaddrgroups(VPCMIDO_TENANT, &ipgs, &max_ipgs);
boolean found = FALSE;
boolean do_upgrade = FALSE;
if (!rc && max_ipgs) {
for (int i = 0; i < max_ipgs && !found; i++) {
if (!strcmp(ipgs[i]->name, "euca_version")) {
rc = mido_get_ipaddrgroup_ips(ipgs[i], &ips, &max_ips);
if (!rc && ips && max_ips) {
if (max_ips > 1) {
LOGFATAL("Unable to detect eucanetd artifacts version - %d versions\n",
max_ips);
LOGINFO("eucanetd going down.\n");
exit(1);
}
mido_euca_version = euca_version_dot2hex(ips[0]->ipagip->ip);
mido_euca_version_str = hex2dot(mido_euca_version);
found = TRUE;
LOGTRACE("\tFound %s artifacts\n", mido_euca_version_str);
if (mido_euca_version < dot2hex("4.4.0.0")) {
LOGWARN("Unable to upgrade from version %s\n", mido_euca_version_str);
LOGINFO("eucanetd going down.\n");
exit(1);
}
if (mido_euca_version < pConfig->euca_version) {
LOGINFO("Upgrading Eucalyptus %s to %s\n", mido_euca_version_str, pConfig->euca_version_str);
mido_delete_resource(ipgs[i], ips[0]);
do_upgrade = TRUE;
}
if (mido_euca_version > pConfig->euca_version) {
LOGFATAL("Downgrading Eucalyptus %s to %s not supported\n", mido_euca_version_str, pConfig->euca_version_str);
LOGFATAL("eucanetd going down.\n");
exit(1);
}
}
EUCA_FREE(ips);
}
}
}
EUCA_FREE(ipgs);
if (do_upgrade) {
// No 4.4->5.0 upgrade action required
/*
// Retrieve all objects
rc = midonet_api_cache_refresh_v_threads(MIDO_CACHE_REFRESH_ALL);
if (rc) {
LOGERROR("failed to retrieve objects from MidoNet.\n");
} else {
mido_config *mido = pMidoConfig;
rc = do_midonet_populate(mido);
if (rc) {
LOGWARN("failed to populate VPC models prior to upgrade.\n");
}
}
*/
}
EUCA_FREE(mido_euca_version_str);
return (ret);
}
adb_DescribePublicAddressesResponse_t *DescribePublicAddressesMarshal(adb_DescribePublicAddresses_t *describePublicAddresses, const axutil_env_t *env) {
adb_describePublicAddressesType_t *dpa=NULL;
adb_DescribePublicAddressesResponse_t *ret=NULL;
adb_describePublicAddressesResponseType_t *dpart=NULL;
axis2_bool_t status=AXIS2_TRUE;
char statusMessage[256], *ipstr=NULL;
int rc, outAddressesLen, i;
ncMetadata ccMeta;
// char **outAddresses=NULL;
publicip *outAddresses;
dpa = adb_DescribePublicAddresses_get_DescribePublicAddresses(describePublicAddresses, env);
EUCA_MESSAGE_UNMARSHAL(describePublicAddressesType, dpa, (&ccMeta));
if (!DONOTHING) {
rc = doDescribePublicAddresses(&ccMeta, &outAddresses, &outAddressesLen);
}
if (rc == 2) {
snprintf(statusMessage, 256, "NOTSUPPORTED");
status = AXIS2_FALSE;
outAddressesLen = 0;
} else if (rc) {
logprintf("ERROR: doDescribePublicAddresses() returned FAIL\n");
snprintf(statusMessage, 256, "ERROR");
status = AXIS2_FALSE;
outAddressesLen = 0;
} else {
status = AXIS2_TRUE;
}
dpart = adb_describePublicAddressesResponseType_create(env);
for (i=0; i<outAddressesLen; i++) {
if (outAddresses[i].ip) {
adb_publicAddressType_t *addr;
addr = adb_publicAddressType_create(env);
adb_publicAddressType_set_uuid(addr, env, outAddresses[i].uuid);
ipstr = hex2dot(outAddresses[i].ip);
adb_publicAddressType_set_sourceAddress(addr, env, ipstr);
if (ipstr) free(ipstr);
if (outAddresses[i].dstip) {
ipstr = hex2dot(outAddresses[i].dstip);
adb_publicAddressType_set_destAddress(addr, env, ipstr);
if (ipstr) free(ipstr);
} else {
adb_publicAddressType_set_destAddress(addr, env, "0.0.0.0");
}
adb_describePublicAddressesResponseType_add_addresses(dpart, env, addr);
}
}
adb_describePublicAddressesResponseType_set_correlationId(dpart, env, ccMeta.correlationId);
adb_describePublicAddressesResponseType_set_userId(dpart, env, ccMeta.userId);
adb_describePublicAddressesResponseType_set_return(dpart, env, status);
if (status == AXIS2_FALSE) {
adb_describePublicAddressesResponseType_set_statusMessage(dpart, env, statusMessage);
}
ret = adb_DescribePublicAddressesResponse_create(env);
adb_DescribePublicAddressesResponse_set_DescribePublicAddressesResponse(ret, env, dpart);
return(ret);
}
adb_DescribeNetworksResponse_t *DescribeNetworksMarshal(adb_DescribeNetworks_t *describeNetworks, const axutil_env_t *env) {
// output vars
adb_DescribeNetworksResponse_t *ret=NULL;
adb_describeNetworksResponseType_t *snrt=NULL;
//input vars
adb_describeNetworksType_t *snt=NULL;
// working vars
int rc, i, j;
axis2_bool_t status=AXIS2_TRUE;
char statusMessage[256];
char **clusterControllers=NULL, *nameserver=NULL, *vnetSubnet=NULL, *vnetNetmask=NULL;
int clusterControllersLen=0;
ncMetadata ccMeta;
vnetConfig *outvnetConfig=NULL;
outvnetConfig = malloc(sizeof(vnetConfig));
snt = adb_DescribeNetworks_get_DescribeNetworks(describeNetworks, env);
EUCA_MESSAGE_UNMARSHAL(describeNetworksType, snt, (&ccMeta));
nameserver = adb_describeNetworksType_get_nameserver(snt, env);
clusterControllersLen = adb_describeNetworksType_sizeof_clusterControllers(snt, env);
clusterControllers = malloc(sizeof(char *) * clusterControllersLen);
for (i=0; i<clusterControllersLen; i++) {
char *incc;
incc = adb_describeNetworksType_get_clusterControllers_at(snt, env, i);
clusterControllers[i] = host2ip(incc);
}
snrt = adb_describeNetworksResponseType_create(env);
status = AXIS2_TRUE;
if (!DONOTHING) {
rc = doDescribeNetworks(&ccMeta, nameserver, clusterControllers, clusterControllersLen, outvnetConfig);
if (rc) {
logprintf("ERROR: doDescribeNetworks() returned fail %d\n", rc);
status = AXIS2_FALSE;
snprintf(statusMessage, 255, "ERROR");
} else {
if (!strcmp(outvnetConfig->mode, "MANAGED") || !strcmp(outvnetConfig->mode, "MANAGED-NOVLAN")) {
adb_describeNetworksResponseType_set_useVlans(snrt, env, 1);
} else {
adb_describeNetworksResponseType_set_useVlans(snrt, env, 0);
}
adb_describeNetworksResponseType_set_mode(snrt, env, outvnetConfig->mode);
adb_describeNetworksResponseType_set_addrsPerNet(snrt, env, outvnetConfig->numaddrs);
adb_describeNetworksResponseType_set_addrIndexMin(snrt, env, outvnetConfig->addrIndexMin);
adb_describeNetworksResponseType_set_addrIndexMax(snrt, env, outvnetConfig->addrIndexMax);
vnetSubnet = hex2dot(outvnetConfig->nw);
if (vnetSubnet) {
adb_describeNetworksResponseType_set_vnetSubnet(snrt, env, vnetSubnet);
free(vnetSubnet);
}
vnetNetmask = hex2dot(outvnetConfig->nm);
if (vnetNetmask) {
adb_describeNetworksResponseType_set_vnetNetmask(snrt, env, vnetNetmask);
free(vnetNetmask);
}
adb_describeNetworksResponseType_set_vlanMin(snrt, env, 2);
adb_describeNetworksResponseType_set_vlanMax(snrt, env, outvnetConfig->max_vlan);
for (i=2; i<NUMBER_OF_VLANS; i++) {
if (outvnetConfig->networks[i].active) {
adb_networkType_t *nt=NULL;
nt = adb_networkType_create(env);
adb_networkType_set_uuid(nt, env, outvnetConfig->users[i].uuid);
adb_networkType_set_vlan(nt, env, i);
adb_networkType_set_netName(nt, env, outvnetConfig->users[i].netName);
adb_networkType_set_userName(nt, env, outvnetConfig->users[i].userName);
for (j=0; j<NUMBER_OF_HOSTS_PER_VLAN; j++) {
if (outvnetConfig->networks[i].addrs[j].active) {
adb_networkType_add_activeAddrs(nt, env, j);
}
}
adb_describeNetworksResponseType_add_activeNetworks(snrt, env, nt);
}
}
status = AXIS2_TRUE;
}
}
for (i=0; i<clusterControllersLen; i++) {
if (clusterControllers[i]) free(clusterControllers[i]);
}
if (clusterControllers) free(clusterControllers);
adb_describeNetworksResponseType_set_return(snrt, env, status);
if (status == AXIS2_FALSE) {
adb_describeNetworksResponseType_set_statusMessage(snrt, env, statusMessage);
}
adb_describeNetworksResponseType_set_correlationId(snrt, env, ccMeta.correlationId);
adb_describeNetworksResponseType_set_userId(snrt, env, ccMeta.userId);
ret = adb_DescribeNetworksResponse_create(env);
adb_DescribeNetworksResponse_set_DescribeNetworksResponse(ret, env, snrt);
if (outvnetConfig) free(outvnetConfig);
return(ret);
}
