//caller will acquire ofrw_htbl lock
cc_of_ret
add_upd_ofrw_rwsocket(int add_fd, adpoll_thread_mgr_t *thr_mgr_p,
L4_type_e layer4_proto,
cc_ofdev_key_t key, struct sockaddr_in *client_addr)
{
cc_ofrw_key_t *ofrw_key;
cc_ofrw_info_t *ofrw_info;
gboolean new_entry;
cc_of_ret rc;
CC_LOG_DEBUG("%s(%d)", __FUNCTION__, __LINE__);
ofrw_key = (cc_ofrw_key_t *)malloc(sizeof(cc_ofrw_key_t));
ofrw_info = (cc_ofrw_info_t *)malloc(sizeof(cc_ofrw_info_t));
ofrw_key->rw_sockfd = add_fd;
ofrw_info->state = CC_OF_RW_DOWN;
ofrw_info->thr_mgr_p = thr_mgr_p;
memcpy(&(ofrw_info->dev_key), &key, sizeof(cc_ofdev_key_t));
if (client_addr)
memcpy(&(ofrw_info->client_addr), client_addr, sizeof(struct sockaddr_in));
ofrw_info->layer4_proto = layer4_proto;
rc = update_global_htbl_lockfree(OFRW, ADD,
ofrw_key, ofrw_info,
&new_entry);
if (!new_entry) {
free(ofrw_key);
} else {
CC_LOG_DEBUG("%s(%d): new entry %d", __FUNCTION__, __LINE__,
add_fd);
print_ofrw_htbl();
}
return rc;
}
void
print_ofdev_htbl(void)
{
GHashTableIter ofdev_iter;
cc_ofdev_key_t *dev_key = NULL;
cc_ofdev_info_t *dev_info = NULL;
g_hash_table_iter_init(&ofdev_iter, cc_of_global.ofdev_htbl);
GList *list_elem = NULL;
int n;
n = g_hash_table_size(cc_of_global.ofdev_htbl);
CC_LOG_DEBUG("Printing ofdev Hash Table with %d entries", n);
if (n) {
while (g_hash_table_iter_next(&ofdev_iter,
(gpointer *)&dev_key,
(gpointer *)&dev_info)) {
CC_LOG_DEBUG("key: controller ip: 0x%x "
"key: switch ip: 0x%x "
"key: l4 port: %d",
dev_key->controller_ip_addr,
dev_key->switch_ip_addr,
dev_key->controller_L4_port);
}
//Iterate through the sockets in dev info
list_elem = g_list_first(dev_info->ofrw_socket_list);
while (list_elem) {
CC_LOG_DEBUG("sockfd: %d",*(int *)(list_elem->data));
list_elem = g_list_next(list_elem);
}
}
}
void
print_ofchann_htbl(void)
{
GHashTableIter ofch_iter;
cc_ofchannel_key_t *ch_key = NULL;
cc_ofchannel_info_t *ch_info = NULL;
int n;
g_hash_table_iter_init(&ofch_iter, cc_of_global.ofchannel_htbl);
n = g_hash_table_size(cc_of_global.ofchannel_htbl);
CC_LOG_DEBUG("Printing ofchannel Hash Table with %d entries",n);
if (n) {
while (g_hash_table_iter_next(&ofch_iter,
(gpointer *)&ch_key,
(gpointer *)&ch_info)) {
CC_LOG_DEBUG("key: dp id: %lu "
"key: aux id: %hu "
"info: socket: %d",
ch_key->dp_id,
ch_key->aux_id,
ch_info->rw_sockfd);
}
}
}
static int Calculator_impl2_split(
struct cc_server_Calculator *instance, double value, int32_t *whole, int32_t *fraction)
{
CC_LOG_DEBUG("invoked method Calculator_impl1_split()\n");
CC_LOG_DEBUG("with value=%g\n", value);
assert(instance);
assert(whole);
assert(fraction);
*whole = -1;
*fraction = -2;
CC_LOG_DEBUG("returning whole=%d, fraction=%d\n", *whole, *fraction);
return 0;
}
int cc_client_Ball_new(const char *address, void *data, struct cc_client_Ball **instance)
{
int result;
struct cc_client_Ball *ii;
CC_LOG_DEBUG("invoked cc_client_Ball_new\n");
assert(address);
assert(instance);
ii = (struct cc_client_Ball *) calloc(1, sizeof(*ii));
if (!ii) {
CC_LOG_ERROR("failed to allocate instance memory\n");
return -ENOMEM;
}
result = cc_instance_new(address, false, &ii->instance);
if (result < 0) {
CC_LOG_ERROR("failed to create instance: %s\n", strerror(-result));
goto fail;
}
ii->data = data;
*instance = ii;
return 0;
fail:
ii = cc_client_Ball_free(ii);
return result;
}
int cc_Ball_drop(struct cc_client_Ball *instance)
{
int result = 0;
struct cc_instance *i;
sd_bus_message *message = NULL;
CC_LOG_DEBUG("invoked cc_Ball_drop()\n");
assert(instance);
i = instance->instance;
assert(i && i->backend && i->backend->bus);
assert(i->service && i->path && i->interface);
result = sd_bus_message_new_method_call(
i->backend->bus, &message, i->service, i->path, i->interface, "drop");
if (result < 0) {
CC_LOG_ERROR("unable to create message: %s\n", strerror(-result));
goto fail;
}
result = sd_bus_message_set_expect_reply(message, 0);
if (result < 0) {
CC_LOG_ERROR("unable to flag message no-reply-expected: %s\n", strerror(-result));
goto fail;
}
/* Setting cookie=NULL in sd_bus_send() call makes the previous one redundant */
result = sd_bus_send(i->backend->bus, message, NULL);
if (result < 0) {
CC_LOG_ERROR("unable to send message: %s\n", strerror(-result));
goto fail;
}
fail:
message = sd_bus_message_unref(message);
return result;
}
static int setup_signals(sd_event *event)
{
sigset_t signals;
int result;
CC_LOG_DEBUG("invoked setup_signals()\n");
assert(event);
sigemptyset(&signals);
sigaddset(&signals, SIGTERM);
sigaddset(&signals, SIGINT);
result = sigprocmask(SIG_BLOCK, &signals, NULL);
if (result != 0) {
CC_LOG_ERROR("unable to block signals: %s\n", strerror(result));
return -result;
}
result = sd_event_add_signal(event, NULL, SIGTERM, &signal_handler, event);
if (result < 0) {
CC_LOG_ERROR("unable to setup SIGTERM handler: %s\n", strerror(-result));
return result;
}
result = sd_event_add_signal(event, NULL, SIGINT, &signal_handler, event);
if (result < 0) {
CC_LOG_ERROR("unable to setup SIGINT handler: %s\n", strerror(-result));
return result;
}
return 0;
}
static int cc_Smartie_hangup_thunk(
CC_IGNORE_BUS_ARG sd_bus_message *m, void *userdata, sd_bus_error *error)
{
int result = 0;
struct cc_server_Smartie *ii = (struct cc_server_Smartie *) userdata;
int32_t status;
CC_LOG_DEBUG("invoked cc_Smartie_hangup_thunk()\n");
assert(m);
assert(ii && ii->impl);
CC_LOG_DEBUG("with path='%s'\n", sd_bus_message_get_path(m));
result = sd_bus_message_read(m, "");
if (result < 0) {
CC_LOG_ERROR("unable to read method parameters: %s\n", strerror(-result));
return result;
}
if (!ii->impl->hangup) {
CC_LOG_ERROR("unsupported method invoked: %s\n", "Smartie.hangup");
sd_bus_error_set(
error, SD_BUS_ERROR_NOT_SUPPORTED,
"instance does not support method Smartie.hangup");
sd_bus_reply_method_error(m, error);
return -ENOTSUP;
}
result = ii->impl->hangup(ii, &status);
if (result < 0) {
CC_LOG_ERROR("failed to execute method: %s\n", strerror(-result));
sd_bus_error_setf(
error, SD_BUS_ERROR_FAILED,
"method implementation failed with error=%d", result);
sd_bus_reply_method_error(m, error);
return result;
}
result = sd_bus_reply_method_return(m, "i", status);
if (result < 0) {
CC_LOG_ERROR("unable to send method reply: %s\n", strerror(-result));
return result;
}
/* Successful method invocation must return >0 */
return 1;
}
int cc_Ball_grab(struct cc_client_Ball *instance, bool *success)
{
int result = 0;
struct cc_instance *i;
sd_bus_message *message = NULL;
sd_bus_message *reply = NULL;
sd_bus_error error = SD_BUS_ERROR_NULL;
int success_int;
CC_LOG_DEBUG("invoked cc_Ball_grab()\n");
assert(instance);
i = instance->instance;
assert(i && i->backend && i->backend->bus);
assert(i->service && i->path && i->interface);
if (instance->grab_reply_slot) {
CC_LOG_ERROR("unable to call method with already pending reply\n");
return -EBUSY;
}
assert(!instance->grab_reply_callback);
result = sd_bus_call_method(
i->backend->bus, i->service, i->path, i->interface, "grab", &error, &reply, "");
if (result < 0) {
CC_LOG_ERROR("unable to call method: %s\n", strerror(-result));
goto fail;
}
result = sd_bus_message_read(reply, "b", &success_int);
if (result < 0) {
CC_LOG_ERROR("unable to get reply value: %s\n", strerror(-result));
goto fail;
}
*success = !!success_int;
CC_LOG_DEBUG("returning success=%d\n", (int) *success);
fail:
sd_bus_error_free(&error);
reply = sd_bus_message_unref(reply);
message = sd_bus_message_unref(message);
return result;
}
int cc_Calculator_split(
struct cc_client_Calculator *instance, double value, int32_t *whole, int32_t *fraction)
{
int result = 0;
struct cc_instance *i;
sd_bus_message *message = NULL;
sd_bus_message *reply = NULL;
sd_bus_error error = SD_BUS_ERROR_NULL;
CC_LOG_DEBUG("invoked cc_Calculator_split()\n");
assert(instance);
i = instance->instance;
assert(i && i->backend && i->backend->bus);
assert(i->service && i->path && i->interface);
if (instance->split_reply_slot) {
CC_LOG_ERROR("unable to call method with already pending reply\n");
return -EBUSY;
}
assert(!instance->split_reply_callback);
result = sd_bus_call_method(
i->backend->bus, i->service, i->path, i->interface,
"split", &error, &reply, "d", value);
if (result < 0) {
CC_LOG_ERROR("unable to call method: %s\n", strerror(-result));
goto fail;
}
result = sd_bus_message_read(reply, "ii", whole, fraction);
if (result < 0) {
CC_LOG_ERROR("unable to get reply value: %s\n", strerror(-result));
goto fail;
}
CC_LOG_DEBUG("returning whole=%" PRId32 ", fraction=%" PRId32 "\n", *whole, *fraction);
fail:
sd_bus_error_free(&error);
reply = sd_bus_message_unref(reply);
message = sd_bus_message_unref(message);
return result;
}
struct cc_client_Ball *cc_client_Ball_free(struct cc_client_Ball *instance)
{
CC_LOG_DEBUG("invoked cc_client_Ball_free()\n");
if (instance) {
instance->grab_reply_slot = sd_bus_slot_unref(instance->grab_reply_slot);
instance->instance = cc_instance_free(instance->instance);
/* User is responsible for memory management of data. */
free(instance);
}
return NULL;
}
struct cc_server_Smartie *cc_server_Smartie_free(struct cc_server_Smartie *instance)
{
CC_LOG_DEBUG("invoked cc_server_Smartie_free()\n");
if (instance) {
instance->vtable_slot = sd_bus_slot_unref(instance->vtable_slot);
instance->instance = cc_instance_free(instance->instance);
/* User is resposible for memory management of impl and data. */
free(instance);
}
return NULL;
}
void
print_ofrw_htbl(void)
{
GHashTableIter ofrw_iter;
cc_ofrw_key_t *rw_key = NULL;
cc_ofrw_info_t *rw_info = NULL;
gpointer rkey = NULL, rinfo = NULL;
g_hash_table_iter_init(&ofrw_iter, cc_of_global.ofrw_htbl);
int n;
n = g_hash_table_size(cc_of_global.ofrw_htbl);
CC_LOG_DEBUG("Printing ofrw Hash Table with %d entries", n);
if (n) {
while (g_hash_table_iter_next(&ofrw_iter,
&rkey, &rinfo)) {
rw_info = (cc_ofrw_info_t *)rinfo;
rw_key = (cc_ofrw_key_t *)rkey;
if (rw_info->thr_mgr_p == NULL) {
CC_LOG_ERROR("%s(%d): no polling thread for %d",
__FUNCTION__, __LINE__, rw_key->rw_sockfd);
} else {
CC_LOG_DEBUG("key: rw_sockfd: %d "
"info: layer4_proto: %s "
"info: poll thread name: %s"
"info: devkey controller ip: 0x%x"
"info: devkey switch ip: 0x%x"
"info: devkey l4port: %d",
rw_key->rw_sockfd,
(rw_info->layer4_proto == TCP)? "TCP":"UDP",
rw_info->thr_mgr_p->tname,
rw_info->dev_key.controller_ip_addr,
rw_info->dev_key.switch_ip_addr,
rw_info->dev_key.controller_L4_port);
}
}
}
}
static int cc_Calculator_split_reply_thunk(
CC_IGNORE_BUS_ARG sd_bus_message *message, void *userdata, sd_bus_error *ret_error)
{
int result = 0;
sd_bus *bus;
struct cc_client_Calculator *ii = (struct cc_client_Calculator *) userdata;
int32_t whole;
int32_t fraction;
(void) ret_error;
CC_LOG_DEBUG("invoked cc_Calculator_split_reply_thunk()\n");
assert(message);
bus = sd_bus_message_get_bus(message);
assert(bus);
assert(ii);
assert(ii->split_reply_callback);
assert(ii->split_reply_slot == sd_bus_get_current_slot(bus));
result = sd_bus_message_get_errno(message);
if (result != 0) {
CC_LOG_ERROR("failed to receive response: %s\n", strerror(result));
goto finish;
}
result = sd_bus_message_read(message, "ii", &whole, &fraction);
if (result < 0) {
CC_LOG_ERROR("unable to get reply value: %s\n", strerror(-result));
goto finish;
}
CC_LOG_DEBUG("invoking callback in cc_Calculator_split_reply_thunk()\n");
CC_LOG_DEBUG("with whole=%" PRId32 ", fraction=%" PRId32 "\n", whole, fraction);
ii->split_reply_callback(ii, whole, fraction);
result = 1;
finish:
ii->split_reply_callback = NULL;
ii->split_reply_slot = sd_bus_slot_unref(ii->split_reply_slot);
return result;
}
static int cc_Ball_grab_reply_thunk(
CC_IGNORE_BUS_ARG sd_bus_message *message, void *userdata, sd_bus_error *ret_error)
{
int result = 0;
sd_bus *bus;
struct cc_client_Ball *ii = (struct cc_client_Ball *) userdata;
int success_int;
CC_LOG_DEBUG("invoked cc_Ball_grab_reply_thunk()\n");
assert(message);
bus = sd_bus_message_get_bus(message);
assert(bus);
assert(ii);
assert(ii->grab_reply_callback);
assert(ii->grab_reply_slot == sd_bus_get_current_slot(bus));
result = sd_bus_message_get_errno(message);
if (result != 0) {
CC_LOG_ERROR("failed to receive response: %s\n", strerror(result));
goto finish;
}
result = sd_bus_message_read(message, "b", &success_int);
if (result < 0) {
CC_LOG_ERROR("unable to get reply value: %s\n", strerror(-result));
goto finish;
}
CC_LOG_DEBUG("invoking callback in cc_Ball_grab_reply_thunk()\n");
CC_LOG_DEBUG("with success=%d\n", !!success_int);
ii->grab_reply_callback(ii, !!success_int);
result = 1;
finish:
ii->grab_reply_callback = NULL;
ii->grab_reply_slot = sd_bus_slot_unref(ii->grab_reply_slot);
return result;
}
static int signal_handler(
sd_event_source *source, const struct signalfd_siginfo *signal_info, void *user_data)
{
sd_event *event = (sd_event *) user_data;
int result;
CC_LOG_DEBUG("invoked signal_handler() with signal %d\n", signal_info->ssi_signo);
assert(event);
assert(signal_info->ssi_signo == SIGTERM || signal_info->ssi_signo == SIGINT);
result = sd_event_exit(event, 0);
if (result < 0)
CC_LOG_ERROR("unable to exit event loop: %s\n", strerror(-result));
return result;
}
int cc_Calculator_split_async(
struct cc_client_Calculator *instance, double value,
cc_Calculator_split_reply_t callback)
{
int result = 0;
struct cc_instance *i;
sd_bus_message *message = NULL;
CC_LOG_DEBUG("invoked cc_Calculator_split_async()\n");
assert(instance);
assert(callback);
i = instance->instance;
assert(i && i->backend && i->backend->bus);
assert(i->service && i->path && i->interface);
if (instance->split_reply_slot) {
CC_LOG_ERROR("unable to call method with already pending reply\n");
return -EBUSY;
}
assert(!instance->split_reply_callback);
result = sd_bus_message_new_method_call(
i->backend->bus, &message, i->service, i->path, i->interface, "split");
if (result < 0) {
CC_LOG_ERROR("unable to create message: %s\n", strerror(-result));
goto fail;
}
result = sd_bus_message_append(message, "d", value);
if (result < 0) {
CC_LOG_ERROR("unable to append message method arguments: %s\n", strerror(-result));
goto fail;
}
result = sd_bus_call_async(
i->backend->bus, &instance->split_reply_slot, message,
&cc_Calculator_split_reply_thunk, instance, CC_DBUS_ASYNC_CALL_TIMEOUT_USEC);
if (result < 0) {
CC_LOG_ERROR("unable to issue method call: %s\n", strerror(-result));
goto fail;
}
instance->split_reply_callback = callback;
fail:
message = sd_bus_message_unref(message);
return result;
}
gboolean cc_ofrw_htbl_equal_func(gconstpointer a, gconstpointer b)
{
cc_ofrw_key_t *a_rw, *b_rw;
a_rw = (cc_ofrw_key_t *)a;
b_rw = (cc_ofrw_key_t *)b;
CC_LOG_DEBUG("%s: a rw_sockfd %d b is %d",
__FUNCTION__,
a_rw->rw_sockfd,
b_rw->rw_sockfd);
if (a_rw->rw_sockfd == b_rw->rw_sockfd) {
return TRUE;
} else {
return FALSE;
}
}
gboolean cc_ofchannel_htbl_equal_func(gconstpointer a, gconstpointer b)
{
cc_ofchannel_key_t *a_chan, *b_chan;
a_chan = (cc_ofchannel_key_t *)a;
b_chan = (cc_ofchannel_key_t *)b;
CC_LOG_DEBUG("%s: a dp/aux %lu/%hu b is %lu/%hu",
__FUNCTION__,
a_chan->dp_id, a_chan->aux_id,
b_chan->dp_id, b_chan->aux_id);
if ((a_chan->dp_id == b_chan->dp_id) &&
(a_chan->aux_id == b_chan->aux_id)) {
return TRUE;
} else {
return FALSE;
}
}
gboolean cc_ofdev_htbl_equal_func(gconstpointer a, gconstpointer b)
{
cc_ofdev_key_t *a_dev, *b_dev;
a_dev = (cc_ofdev_key_t *)a;
b_dev = (cc_ofdev_key_t *)b;
CC_LOG_DEBUG("%s: a controller ip addr 0x%x b is 0x%x",
__FUNCTION__,
a_dev->controller_ip_addr,
b_dev->controller_ip_addr);
if ((a_dev->controller_ip_addr == b_dev->controller_ip_addr) &&
(a_dev->switch_ip_addr == b_dev->switch_ip_addr) &&
(a_dev->controller_L4_port == b_dev->controller_L4_port)) {
return TRUE;
} else {
return FALSE;
}
}
int cc_server_Smartie_new(
const char *address, const struct cc_server_Smartie_impl *impl, void *data,
struct cc_server_Smartie **instance)
{
int result;
struct cc_server_Smartie *ii;
struct cc_instance *i;
CC_LOG_DEBUG("invoked cc_server_Smartie_new\n");
assert(address);
assert(impl);
assert(instance);
ii = (struct cc_server_Smartie *) calloc(1, sizeof(*ii));
if (!ii) {
CC_LOG_ERROR("failed to allocate instance memory\n");
return -ENOMEM;
}
result = cc_instance_new(address, true, &i);
if (result < 0) {
CC_LOG_ERROR("failed to create instance: %s\n", strerror(-result));
goto fail;
}
ii->instance = i;
ii->impl = impl;
ii->data = data;
result = sd_bus_add_object_vtable(
i->backend->bus, &ii->vtable_slot, i->path, i->interface, vtable_Smartie, ii);
if (result < 0) {
CC_LOG_ERROR("unable to initialize instance vtable: %s\n", strerror(-result));
goto fail;
}
*instance = ii;
return 0;
fail:
ii = cc_server_Smartie_free(ii);
return result;
}
//ofrw_htbl_lock acqured by callee
cc_of_ret
find_thrmgr_rwsocket(int sockfd,
adpoll_thread_mgr_t **tmgr) {
cc_of_ret status = CC_OF_OK;
cc_ofrw_key_t rwkey;
cc_ofrw_info_t *rwinfo = NULL;
rwkey.rw_sockfd = sockfd;
g_mutex_lock(&cc_of_global.ofrw_htbl_lock);
CC_LOG_DEBUG("%s(%d)", __FUNCTION__, __LINE__);
print_ofrw_htbl();
rwinfo = g_hash_table_lookup(cc_of_global.ofrw_htbl, &rwkey);
if (rwinfo == NULL) {
CC_LOG_ERROR("%s(%d): could not find rwsock %d in ofrw_htbl",
__FUNCTION__, __LINE__, rwkey.rw_sockfd);
g_mutex_unlock(&cc_of_global.ofrw_htbl_lock);
return CC_OF_EHTBL;
}
*tmgr = rwinfo->thr_mgr_p;
g_mutex_unlock(&cc_of_global.ofrw_htbl_lock);
return status;
}
// Caller will acquire htbl locks
cc_of_ret
update_global_htbl_lockfree(htbl_type_e htbl_type,
htbl_update_ops_e htbl_op,
gpointer htbl_key,
gpointer htbl_data,
gboolean *new_entry)
{
GHashTable *cc_htbl;
gpointer key, info_data;
*new_entry = FALSE;
guint old_count;
switch(htbl_type) {
case OFDEV:
cc_htbl = cc_of_global.ofdev_htbl;
if ((htbl_op == ADD) &&
(g_hash_table_contains(cc_htbl, htbl_key))) {
htbl_op = UPD;
/* create a new key. the insert operation will free this */
key = malloc(sizeof(cc_ofdev_key_t));
memcpy(key, htbl_key, sizeof(cc_ofdev_key_t));
info_data = malloc(sizeof(cc_ofdev_info_t));
memcpy(info_data, htbl_data, sizeof(cc_ofdev_info_t));
}
break;
case OFRW:
cc_htbl = cc_of_global.ofrw_htbl;
if ((htbl_op == ADD) &&
(g_hash_table_contains(cc_htbl, htbl_key))) {
htbl_op = UPD;
/* create a new key. the insert operation will free ths */
key = malloc(sizeof(cc_ofrw_key_t));
memcpy(key, htbl_key, sizeof(cc_ofrw_key_t));
info_data = malloc(sizeof(cc_ofrw_info_t));
memcpy(info_data, htbl_data, sizeof(cc_ofrw_info_t));
}
break;
case OFCHANN:
cc_htbl = cc_of_global.ofchannel_htbl;
if ((htbl_op == ADD) &&
(g_hash_table_contains(cc_htbl, htbl_key))) {
/* create a new key. the insert operation will free this */
key = malloc(sizeof(cc_ofchannel_key_t));
memcpy(key, htbl_key, sizeof(cc_ofchannel_key_t));
info_data = malloc(sizeof(cc_ofchannel_info_t));
memcpy(info_data, htbl_data, sizeof(cc_ofchannel_info_t));
}
break;
default:
CC_LOG_ERROR("%s(%d): invalid htbl type %d",
__FUNCTION__, __LINE__, htbl_type);
}
if (htbl_op == ADD) {
old_count = g_hash_table_size(cc_htbl);
CC_LOG_DEBUG("%s(%d): insert operation for htbl_type %s",
__FUNCTION__, __LINE__,
(htbl_type == OFDEV)? "OFDEV":
((htbl_type == OFRW)?"OFRW":"OFCHANN"));
if (htbl_type == OFDEV) {
CC_LOG_DEBUG("%s(%d) key has controller ip 0x%x, switch ip 0x%x and port %d",
__FUNCTION__, __LINE__,
((cc_ofdev_key_t *)htbl_key)->controller_ip_addr,
((cc_ofdev_key_t *)htbl_key)->switch_ip_addr,
((cc_ofdev_key_t *)htbl_key)->controller_L4_port);
} else if (htbl_type == OFRW) {
CC_LOG_DEBUG("%s(%d) insert key has socket %d",
__FUNCTION__, __LINE__,
((cc_ofrw_key_t *)htbl_key)->rw_sockfd);
CC_LOG_DEBUG("%s(%d) insert info has l4 proto %s",
__FUNCTION__, __LINE__,
(((cc_ofrw_info_t *)htbl_data)->layer4_proto == TCP)?
"TCP":((((cc_ofrw_info_t *)htbl_data)->layer4_proto
== UDP)? "UDP":"INVALID"));
if (g_hash_table_contains(cc_htbl, htbl_key)) {
CC_LOG_DEBUG("(%s(%d): OFRW htbl already contains %d",
__FUNCTION__, __LINE__,
((cc_ofrw_key_t *)htbl_key)->rw_sockfd);
}
} else if (htbl_type == OFCHANN) {
CC_LOG_DEBUG("%s(%d) ofchannel key dp/aux %lu/%hu",
__FUNCTION__, __LINE__,
((cc_ofchannel_key_t *)htbl_key)->dp_id,
((cc_ofchannel_key_t *)htbl_key)->aux_id);
}
g_hash_table_insert(cc_htbl, htbl_key, htbl_data);
if (htbl_type == OFDEV) {
} else if (htbl_type == OFRW) {
gpointer rwht_key = NULL, rwht_info = NULL;
if (g_hash_table_contains(cc_htbl, htbl_key)) {
CC_LOG_DEBUG("(%s(%d): OFRW htbl contains %d",
__FUNCTION__, __LINE__,
((cc_ofrw_key_t *)htbl_key)->rw_sockfd);
}
CC_LOG_DEBUG("OFRW htbl size after insert of %d: %d",
((cc_ofrw_key_t *)htbl_key)->rw_sockfd,
g_hash_table_size(cc_htbl));
if (g_hash_table_lookup_extended(cc_of_global.ofrw_htbl,
htbl_key,
&rwht_key, &rwht_info)
== FALSE) {
CC_LOG_DEBUG("extended lookup failed");
} else {
cc_ofrw_key_t *rw_key = NULL;
cc_ofrw_info_t *rw_info = NULL;
rw_key = (cc_ofrw_key_t *)rwht_key;
rw_info = (cc_ofrw_info_t *)rwht_info;
CC_LOG_DEBUG("extended lookup passed");
CC_LOG_DEBUG("key: rw_sockfd: %d "
"info: layer4_proto: %s "
"info: poll thread name: %s"
"info: devkey controller ip: 0x%x"
"info: devkey switch ip: 0x%x"
"info: devkey l4port: %d",
rw_key->rw_sockfd,
(rw_info->layer4_proto == TCP)? "TCP":"UDP",
rw_info->thr_mgr_p->tname,
rw_info->dev_key.controller_ip_addr,
rw_info->dev_key.switch_ip_addr,
rw_info->dev_key.controller_L4_port);
}
CC_LOG_DEBUG("%s(%d) key has socket %d",
__FUNCTION__, __LINE__,
((cc_ofrw_key_t *)htbl_key)->rw_sockfd);
}
if (g_hash_table_size(cc_htbl) > old_count) {
*new_entry = TRUE;
}
} else if (htbl_op == DEL) {
CC_LOG_DEBUG("%s(%d).. HTBL DEL ", __FUNCTION__, __LINE__);
if (g_hash_table_contains(cc_htbl, htbl_key)) {
CC_LOG_DEBUG("%s(%d) DEL operation found entry",
__FUNCTION__, __LINE__);
}
if (g_hash_table_remove(cc_htbl, htbl_key) == FALSE) {
CC_LOG_DEBUG("%s(%d) DEL unsuccessful",
__FUNCTION__, __LINE__);
return CC_OF_EHTBL;
}
} else if (htbl_op == UPD) {
old_count = g_hash_table_size(cc_htbl);
CC_LOG_DEBUG("%s(%d): replace existing entry operation", __FUNCTION__, __LINE__);
if (htbl_type == OFDEV) {
CC_LOG_DEBUG("%s(%d) key has controller ip 0x%x, switch ip 0x%x and port %d",
__FUNCTION__, __LINE__,
((cc_ofdev_key_t *)key)->controller_ip_addr,
((cc_ofdev_key_t *)key)->switch_ip_addr,
((cc_ofdev_key_t *)key)->controller_L4_port);
}
g_hash_table_insert(cc_htbl, key, info_data);
if (htbl_type == OFDEV) {
} else if (htbl_type == OFCHANN) {
} else if (htbl_type == OFRW) {
gpointer rwht_key = NULL, rwht_info = NULL;
if (g_hash_table_contains(cc_htbl, htbl_key)) {
CC_LOG_DEBUG("(%s(%d): OFRW htbl contains %d",
__FUNCTION__, __LINE__,
((cc_ofrw_key_t *)htbl_key)->rw_sockfd);
}
CC_LOG_DEBUG("OFRW htbl size after insert of %d: %d",
((cc_ofrw_key_t *)htbl_key)->rw_sockfd,
g_hash_table_size(cc_htbl));
if (g_hash_table_lookup_extended(cc_of_global.ofrw_htbl,
htbl_key,
&rwht_key, &rwht_info)
== FALSE) {
CC_LOG_DEBUG("extended lookup failed");
} else {
cc_ofrw_key_t *rw_key = NULL;
cc_ofrw_info_t *rw_info = NULL;
rw_key = (cc_ofrw_key_t *)rwht_key;
rw_info = (cc_ofrw_info_t *)rwht_info;
CC_LOG_DEBUG("extended lookup passed");
CC_LOG_DEBUG("key: rw_sockfd: %d "
"info: layer4_proto: %s "
"info: poll thread name: %s"
"info: devkey controller ip: 0x%x"
"info: devkey switch ip: 0x%x"
"info: devkey l4port: %d",
rw_key->rw_sockfd,
(rw_info->layer4_proto == TCP)? "TCP":"UDP",
rw_info->thr_mgr_p->tname,
rw_info->dev_key.controller_ip_addr,
rw_info->dev_key.switch_ip_addr,
rw_info->dev_key.controller_L4_port);
}
}
if (g_hash_table_size(cc_htbl) > old_count) {
*new_entry = TRUE;
}
}
return CC_OF_OK;
}
