bool OovThreadedWaitQueuePrivate::waitPopPrivate(void *item) { std::unique_lock<std::mutex> lock(mProcessQueueMutex); bool gotItem = false; LOG_PROC("pop lock", this); // Wait while empty while(isQueueEmpty() && !mQuitPopping) { // Release lock and wait for signal. mProviderPushedSignal.wait(lock); // After signaled, lock is reaquired. } // In the normal case this will not be empty. // If it is empty, then there was a signal, but nothing was // in the queue. This means that the quit function was called. gotItem = !isQueueEmpty(); LOG_PROC_INT("pop got item", this, gotItem); if(gotItem) { getFront(item); } LOG_PROC_INT("pop unlock", this, gotItem); // unlock and signal to provider thread that queue is processed. lock.unlock(); mConsumerPoppedSignal.notify_one(); LOG_PROC("pop done", this); return gotItem; }
void query_value(const INT1* key, INT1* value) { INT4 status = 0; JNIEnv *jni_env = NULL; jstring arg_tableName; jstring arg_row; jstring out_res; if(0 == g_method_getonerecord) { LOG_PROC("ERROR", "Hbase client hasn't ready"); return; } status = (*g_jvm)->AttachCurrentThread(g_jvm, (void**)&jni_env, NULL); if (0 != status) { LOG_PROC("ERROR", "Query value failed by key [%s], can not get jni env", key); return; } arg_tableName = (*jni_env)->NewStringUTF(jni_env, COMMON_TABLE); arg_row = (*jni_env)->NewStringUTF(jni_env, key); out_res = (jstring)((*jni_env)->CallStaticObjectMethod(jni_env, g_hbase_client, g_method_getonerecord, arg_tableName, arg_row)); if (NULL != out_res) { const char *str = (*jni_env)->GetStringUTFChars(jni_env, out_res, NULL); //6 = strlen("VALUE|") strncpy(value, str + 6, TABLE_STRING_LEN); } //detach (*g_jvm)->DetachCurrentThread(g_jvm); }
void persist_value(const INT1* key, const INT1* value) { INT4 status = 0; JNIEnv *jni_env = NULL; jstring arg_tableName; jstring arg_row; jstring arg_columnFamily; jstring arg_column; jstring arg_value; if(0 == g_method_addrecord) { LOG_PROC("ERROR", "Hbase client hasn't ready"); return; } status = (*g_jvm)->AttachCurrentThread(g_jvm, (void**)&jni_env, NULL); if (0 != status) { LOG_PROC("ERROR", "Persist value [%s] failed by key [%s], can not get jni env", value, key); return; } arg_tableName = (*jni_env)->NewStringUTF(jni_env, COMMON_TABLE); arg_columnFamily = (*jni_env)->NewStringUTF(jni_env, COMMON_TABLE_CF); arg_row = (*jni_env)->NewStringUTF(jni_env, key); //Persist VALUE HBASE_ADD_RECORD("VALUE", value); //detach (*g_jvm)->DetachCurrentThread(g_jvm); }
void OovThreadedWaitQueuePrivate::quitPopsPrivate() { std::unique_lock<std::mutex> lock(mProcessQueueMutex); LOG_PROC("quitPops lock", this); mQuitPopping = true; // Wait to make sure all queue items were processed. while(!isQueueEmpty()) { mConsumerPoppedSignal.wait(lock); } LOG_PROC("quitPops unlock", this); lock.unlock(); mProviderPushedSignal.notify_all(); LOG_PROC("quitPops done", this); }
openstack_security_p update_openstack_security_group(char* security_group) { openstack_security_p security_p = g_openstack_security_list; while (security_p) { if (0 == strcmp(security_p->security_group, security_group)) { return security_p; } security_p = security_p->next; } // create security_p = (openstack_security_p)mem_get(g_openstack_security_group_id); if (NULL != security_p) { memset(security_p->security_group, 0, OPENSTACK_SECURITY_GROUP_LEN); memcpy(security_p->security_group, security_group, OPENSTACK_SECURITY_GROUP_LEN); security_p->next = g_openstack_security_list; g_openstack_security_list = security_p; } else { LOG_PROC("INFO", "Security: Get memeory fail!"); } return security_p; }
openstack_subnet_p create_openstack_host_subnet( char* tenant_id, char* network_id, //char* subnet_name, char* subnet_id, UINT4 gateway_ip, UINT4 start_ip, UINT4 end_ip){ openstack_subnet_p ret = NULL; ret = (openstack_subnet_p)mem_get(g_openstack_host_subnet_id); if (NULL != ret) { memset(ret,0,sizeof(openstack_subnet)); strcpy(ret->tenant_id,tenant_id); strcpy(ret->network_id,network_id); //strcpy(ret->subnet_name,subnet_name); strcpy(ret->subnet_id, subnet_id); ret->gateway_ip = gateway_ip; ret->start_ip = start_ip; ret->end_ip = end_ip; } else { LOG_PROC("ERROR", "Openstack Subnet: Create failed, Can't get memory."); } return ret; };
void OovThreadedWaitQueuePrivate::waitPushPrivate(void const *item) { std::unique_lock<std::mutex> lock(mProcessQueueMutex); LOG_PROC("push lock", this); // Wait while not empty while(!isQueueEmpty()) { // Release lock and wait for signal. mConsumerPoppedSignal.wait(lock); // After signaled, lock is reaquired. } LOG_PROC("push", this); pushBack(item); LOG_PROC("push unlock", this); lock.unlock(); // Signal to waitPop that data is ready. mProviderPushedSignal.notify_one(); }
//UINT4 find_openstack_host_ports_by_subnet_id(char* subnet_id,openstack_port_p* host_list){ // UINT4 ret = 0; // openstack_port_p port = NULL; // openstack_node_p node_p = NULL; // node_p = g_openstack_host_port_list; // // while(node_p != NULL){ // port = (openstack_port_p)(node_p->data); // if(strcmp(port->subnet_id,subnet_id) == 0){ // host_list[ret] = port; // ret++; // } // node_p = node_p->next; // } // return ret; //}; // //void delete_openstack_host_port_by_tenant_id(char* tenant_id){ // openstack_port_p port = NULL; // openstack_node node; // openstack_node_p node_p = &node,temp_p = NULL; // node_p->next = g_openstack_host_port_list; // // while(node_p->next != NULL){ // port = (openstack_port_p)(node_p->next->data); // if(strcmp(port->tenant_id,tenant_id) == 0){ // temp_p = node_p->next; // node_p->next = temp_p->next; // destory_openstack_host_node(temp_p); // destory_openstack_host_port(port); // }else{ // node_p = node_p->next; // } // } // g_openstack_host_port_list = node.next; // return; //}; //void delete_openstack_host_port_by_network_id(char* network_id){ // openstack_port_p port = NULL; // openstack_node node; // openstack_node_p node_p = &node,temp_p = NULL; // node_p->next = g_openstack_host_port_list; // // while(node_p->next != NULL){ // port = (openstack_port_p)(node_p->next->data); // if(strcmp(port->network_id,network_id) == 0){ // temp_p = node_p->next; // node_p->next = temp_p->next; // destory_openstack_host_node(temp_p); // destory_openstack_host_port(port); // }else{ // node_p = node_p->next; // } // } // g_openstack_host_port_list = node.next; // return; //}; //void delete_openstack_host_port_by_subnet_id(char* subnet_id){ // openstack_port_p port = NULL; // openstack_node node; // openstack_node_p node_p = &node,temp_p = NULL; // node_p->next = g_openstack_host_port_list; // // while(node_p->next != NULL){ // port = (openstack_port_p)(node_p->next->data); // if(strcmp(port->subnet_id,subnet_id) == 0){ // temp_p = node_p->next; // node_p->next = temp_p->next; // destory_openstack_host_node(temp_p); // destory_openstack_host_port(port); // }else{ // node_p = node_p->next; // } // } // g_openstack_host_port_list = node.next; // return; //}; //void delete_openstack_host_port_by_port_id(char* port_id){ // openstack_port_p port = NULL; // port = remove_openstack_host_port_by_port_id(port_id); // if(port != NULL){ // destory_openstack_host_port(port); // } // return; //}; //////////////////////////////////////////////////////////////////////// openstack_node_p create_openstack_host_node(UINT1* data){ openstack_node_p ret = NULL; ret = (openstack_node_p)mem_get(g_openstack_host_node_id); if (NULL != ret) { memset(ret,0,sizeof(openstack_node)); ret->data = data; } else { LOG_PROC("ERROR", "Create openstack host node: Create fail, can't get memory."); } return ret; };
void* create_openstack_host_port( gn_switch_t* sw, UINT4 port, UINT4 ip, UINT1* mac, char* tenant_id, char* network_id, char* subnet_id, char* port_id, UINT2 security_num, UINT1* security_data){ UINT8 dpid = 0; p_fabric_host_node node = NULL; openstack_port_p ret = NULL; ret = (openstack_port_p)mem_get(g_openstack_host_port_id); if (NULL != ret) { memset(ret,0,sizeof(openstack_port)); if (NULL != tenant_id) strcpy(ret->tenant_id,tenant_id); if (NULL != network_id) strcpy(ret->network_id,network_id); if (NULL != port_id) strcpy(ret->port_id,port_id); if (NULL != subnet_id) strcpy(ret->subnet_id, subnet_id); // ret->ip = ip; // ret->sw = sw; // if(sw != NULL) // ret->dpid = sw->dpid; // ret->port = port; // memcpy(ret->mac, mac, 6); if (NULL != sw) { dpid = sw->dpid; } ret->security_num = security_num; if (NULL != security_data) ret->security_data = security_data; node = insert_fabric_host_into_list_paras(sw, dpid, port, mac, ip); if (NULL != node) { node->data = (void*)ret; } else { mem_free(ret, g_openstack_host_port_id); } } else { LOG_PROC("ERROR", "Create openstack host port: Can't get memory."); } return (void*)node; };
INT4 create_l3_subnet(INT1 *name, INT1 *masked_ip) { net_mask_t net_mask; UINT1 i; masked_ip_parser(masked_ip, &net_mask); if((0 == net_mask.prefix) || (0 == net_mask.ip)) { //by:yhy add 201701051305 LOG_PROC("ERROR", "create_l3_subnet -- (0 == net_mask.prefix) || (0 == net_mask.ip) return GN_ERR"); return GN_ERR; } if(search_l3_subnet(net_mask.ip)) { //by:yhy add 201701051305 LOG_PROC("ERROR", "create_l3_subnet -- search_l3_subnet(net_mask.ip) return GN_ERR"); return GN_ERR; } for(i = 0; i < MAX_L3_SUBNET; i++) { if(g_subnet_info[i].is_using == FALSE) { strncpy(g_subnet_info[i].name, name, 64 - 1); strncpy(g_subnet_info[i].netmask, masked_ip, 16 - 1); g_subnet_info[i].gw_ip = net_mask.ip; g_subnet_info[i].gw_prefix = net_mask.prefix; g_subnet_info[i].gw_minip = net_mask.minip; g_subnet_info[i].gw_maxip = net_mask.maxip; g_subnet_info[i].is_using = TRUE; return GN_OK; } } return GN_ERR; }
void delete_record(const INT1 *table_name, const INT1 *row_key) { INT4 status = 0; JNIEnv *jni_env = NULL; jstring arg_tableName; jstring arg_row; if(0 == g_method_deleterecord) { LOG_PROC("ERROR", "Hbase client hasn't ready!\n"); return; } status = (*g_jvm)->AttachCurrentThread(g_jvm, (void**)&jni_env, NULL); if (0 != status) { LOG_PROC("ERROR", "Delete record, can not get jni env! --RowKey: %s\n", row_key); return; } arg_tableName = (*jni_env)->NewStringUTF(jni_env, table_name); arg_row = (*jni_env)->NewStringUTF(jni_env, row_key); (*jni_env)->CallStaticObjectMethod(jni_env, g_hbase_client, g_method_deleterecord, arg_tableName, arg_row); }
openstack_network_p create_openstack_host_network( char* tenant_id, //char* network_name, char* network_id, UINT1 shared){ openstack_network_p ret = NULL; ret = (openstack_network_p)mem_get(g_openstack_host_network_id); if (NULL != ret) { memset(ret,0,sizeof(openstack_network)); strcpy(ret->tenant_id,tenant_id); //strcpy(ret->network_name,network_name); strcpy(ret->network_id,network_id); ret->shared = shared; } else { LOG_PROC("ERROR", "Create openstack host network: Can't get memory."); } return ret; };
void fini_hbase_client() { JNIEnv *jni_env = (JNIEnv *)NULL; INT4 status = 0; //Get jni env for current thread status = (*g_jvm)->AttachCurrentThread(g_jvm, (void**)&jni_env, NULL); if (0 != status) { LOG_PROC("ERROR", "Fini hbase client, can not get jni env"); return; } (*jni_env)->DeleteGlobalRef(jni_env, (jobject)g_method_addrecord); (*jni_env)->DeleteGlobalRef(jni_env, (jobject)g_method_getonerecord); (*jni_env)->DeleteGlobalRef(jni_env, (jobject)g_method_getrecordsbyfilter); (*jni_env)->DeleteGlobalRef(jni_env, g_hbase_client); (*g_jvm)->DetachCurrentThread(g_jvm); (*g_jvm)->DestroyJavaVM(g_jvm); }
INT4 init_restful_svr() { UINT4 i; INT1 *value = get_value(g_controller_configure, "[controller]", "restful_service_port"); g_restful_port = (NULL == value ? 8081 : atoi(value)); for(i = 0; i < REST_CAPACITY; i++) { g_restful_get_handles[i].used = 0; g_restful_post_handles[i].used = 0; g_restful_delete_handles[i].used = 0; } init_json_server(); if (pthread_create(&g_restful_pid, NULL, start_httpd_service, NULL)) { LOG_PROC("ERROR", "Restful service state failed"); return GN_ERR; } return GN_OK; }
static int answer_to_connection(void *cls, struct MHD_Connection *connection, const INT1 *url, const char *method, const INT1 *version, const INT1 *upload_data, size_t *upload_data_size, void **con_cls) { INT4 ret = 0; UINT4 idx = 0; if (NULL == *con_cls) { struct connection_info *conn_info = (struct connection_info *)gn_malloc(sizeof(struct connection_info)); if(NULL == conn_info) { return MHD_NO; } conn_info->connection_time = g_cur_sys_time.tv_sec; *con_cls = (void *)conn_info; return MHD_YES; } if (0 == strcmp(method, "GET")) { LOG_PROC("INFO", "Restful[%s]: [%s]", method, url); g_rest_reply = proc_rest_msg(method, url, upload_data); //todo ÅÐ¿Õ ret = send_page(connection, g_rest_reply, MHD_HTTP_OK); //»Ø¸´ÏûÏ¢ memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø *upload_data_size = 0; upload_data = NULL; free(g_rest_reply); return ret; } if (0 == strcmp(method, "POST") || 0 == strcmp(method, "DELETE") || 0 == strcmp(method, "PUT") || 0 == strcmp(method, "PATCH") || 0 == strcmp(method, "HEAD")) { struct connection_info *conn_info = *con_cls; conn_info->connection_type = HTTP_POST; if (*upload_data_size) { if(is_json(upload_data, *upload_data_size)) { INT1 *tmp = (char*) upload_data; for (idx = *upload_data_size; idx > 0; --idx) { if ('}' == tmp[idx]) { tmp[idx + 1] = '\0'; break; } } LOG_PROC("INFO", "Restful[%s]: [%s] %s\n", method, url, upload_data); g_rest_reply = proc_rest_msg(method, url, upload_data); memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø *upload_data_size = 0; } else { if(conn_info->connection_time - g_cur_sys_time.tv_sec > HTTP_TIMEOUT) { memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø *upload_data_size = 0; return MHD_NO; } } return MHD_YES; } else { ret = send_page(connection, g_rest_reply, MHD_HTTP_OK); memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø *upload_data_size = 0; upload_data = NULL; gn_free((void **)&g_rest_reply); return ret; } } return ret; }
void query_topology() { INT4 status = 0; JNIEnv *jni_env = NULL; jstring arg_tableName; jstring arg_row; jstring arg_columnFamily; jstring arg_column; jstring arg_value; jarray data; UINT4 src_port = 0; UINT4 dst_port = 0; unsigned long long int src_dpid = 0; unsigned long long int dst_dpid = 0; gn_switch_t *src_sw; if(0 == g_method_addrecord) { LOG_PROC("ERROR", "Hbase client hasn't ready"); return; } //Get jni env for current thread status = (*g_jvm)->AttachCurrentThread(g_jvm, (void**)&jni_env, NULL); if (0 != status) { LOG_PROC("ERROR", "Update topology, can not get jni env"); return; } arg_value = (*jni_env)->NewStringUTF(jni_env, "0"); arg_tableName = (*jni_env)->NewStringUTF(jni_env, COMMON_TABLE); arg_row = (*jni_env)->NewStringUTF(jni_env, TOPO_VER); data = (jstring)((*jni_env)->CallStaticObjectMethod(jni_env, g_hbase_client, g_method_getonerecord, arg_tableName, arg_row)); if (NULL != data) { const char *str = (*jni_env)->GetStringUTFChars(jni_env, data, NULL); arg_value = (*jni_env)->NewStringUTF(jni_env, str + 6); } arg_tableName = (*jni_env)->NewStringUTF(jni_env, TOPO_TABLE); arg_columnFamily = (*jni_env)->NewStringUTF(jni_env, TOPO_TABLE_CF); arg_column = (*jni_env)->NewStringUTF(jni_env, "VERSION"); data = (*jni_env)->CallStaticObjectMethod(jni_env, g_hbase_client, g_method_getrecordsbyfilter, arg_tableName, arg_columnFamily, arg_column, arg_value); if (NULL != data) { const jsize length = (*jni_env)->GetArrayLength(jni_env, data); jsize index = length; while(index--) { jstring element = (jstring)((*jni_env)->GetObjectArrayElement(jni_env, data, index)); char const* nativeString = (*jni_env)->GetStringUTFChars(jni_env, element, 0); char *p_next = NULL; char *value = NULL; char *str_cpy = strdup(nativeString); char *column = strcut(str_cpy, '|', &p_next); while(column) { value = strcut(NULL, '|', &p_next); if (0 == strcmp(column, "SRC_DPID")) { src_dpid = strtoull(value, NULL, 16); } else if(0 == strcmp(column, "SRC_PORT")) { src_port = atoi(value); } else if(0 == strcmp(column, "DST_DPID")) { dst_dpid = strtoull(value, NULL, 16); } else if(0 == strcmp(column, "DST_PORT")) { dst_port = atoi(value); } if (!p_next) { break; } column = strcut(NULL, '|', &p_next); } free(str_cpy); (*jni_env)->ReleaseStringUTFChars(jni_env, element, nativeString); src_sw = find_sw_from_dpid(src_dpid); if(src_sw) { LOG_PROC("DEBUG", "----======>>>>> Mapping a new neighbor: src- %016llx.%d, dst: %016llx.%d", src_dpid, src_port, dst_dpid, dst_port); mapping_new_neighbor(src_sw, src_port, dst_dpid, dst_port); } else { LOG_PROC("DEBUG", "----======>>>>> Mapping a new neighbor failed, can not find src sw: src- %016llx.%d, dst: %016llx.%d", src_dpid, src_port, dst_dpid, dst_port); } } } //detach (*g_jvm)->DetachCurrentThread(g_jvm); }
INT4 init_hbase_client() { JNIEnv *jni_env = (JNIEnv *)NULL; jclass cls = 0; JavaVMInitArgs vm_args; JavaVMOption options[1]; jmethodID mid = 0; INT1 value[TABLE_STRING_LEN] = {0}; INT1 *conf_value = NULL; conf_value = get_value(g_controller_configure, "[controller]", "hbase_ip"); NULL == conf_value ? strncpy(g_hbase_ip, "127.0.0.1", 16 - 1) : strncpy(g_hbase_ip, conf_value, 300 - 1); conf_value = get_value(g_controller_configure, "[controller]", "hbase_port"); NULL == conf_value ? strncpy(g_hbase_port, "60000", 6 - 1) : strncpy(g_hbase_port, conf_value, 300 - 1); // int jarCount = 0; // struct dirent **jar_files; // char option_str[10240] = {0}; // strcat(option_str, "-Djava.class.path="); // strcat(option_str, g_hbase_client_file_path); // if ((jarCount = scandir(g_hbase_lib_path, &jar_files, filter_jar, alphasort)) > 0) // { // while (jarCount--) // { // strcat(option_str, ":"); // strcat(option_str, g_hbase_lib_path); // strcat(option_str, "/"); // strcat(option_str, jar_files[jarCount]->d_name); // // free(jar_files[jarCount]); // } // // free(jar_files); // } // else // { // printf("No libs found in the given hbase lib path."); // } // // options[0].optionString = option_str; // printf("Option string: %s\n", option_str); options[0].optionString = "-Djava.class.path=../hbase/hbase_client.jar:../hbase/hbase_lib.jar"; vm_args.version = JNI_VERSION_1_6; vm_args.nOptions = 1; vm_args.options = options; //Create java vm if(JNI_CreateJavaVM(&g_jvm, (void **)&jni_env, &vm_args) != JNI_OK) { LOG_PROC("ERROR", "Create JVM failed"); return GN_ERR; } //Find class "hbase_client" cls = (*jni_env)->FindClass(jni_env, "hbase_client"); g_hbase_client = (jclass)((*jni_env)->NewGlobalRef(jni_env, cls)); if(0 == g_hbase_client) { LOG_PROC("ERROR", "Jni can not find class named \"hbase_client\""); return GN_ERR; } //Init env conf mid = (*jni_env)->GetStaticMethodID(jni_env, g_hbase_client, "Init_conf", "(Ljava/lang/String;Ljava/lang/String;)V"); if(0 != mid) { jstring arg_ip = (*jni_env)->NewStringUTF(jni_env, g_hbase_ip); jstring arg_port = (*jni_env)->NewStringUTF(jni_env, g_hbase_port); (*jni_env)->CallStaticObjectMethod(jni_env, g_hbase_client, mid, arg_ip, arg_port); } else { LOG_PROC("ERROR", "Call method \"Init_conf\" failed"); return GN_ERR; } //Get method: add record mid = (*jni_env)->GetStaticMethodID(jni_env, g_hbase_client, "addRecord", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); if(0 == mid) { LOG_PROC("ERROR", "Jni can not find method named \"addRecord\""); return GN_ERR; } g_method_addrecord = (jmethodID)((*jni_env)->NewGlobalRef(jni_env, (jobject)mid)); //Get method: delete records by row key mid = (*jni_env)->GetStaticMethodID(jni_env, g_hbase_client, "deleteRecord", "(Ljava/lang/String;Ljava/lang/String;)V"); if(0 == mid) { LOG_PROC("ERROR", "Jni can not find method named \"deleteRecord\""); return GN_ERR; } g_method_deleterecord = (jmethodID)((*jni_env)->NewGlobalRef(jni_env, (jobject)mid)); //Get method: get records by filter mid = (*jni_env)->GetStaticMethodID(jni_env, g_hbase_client, "getRecordsByFilter", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Ljava/lang/String;"); if(0 == mid) { LOG_PROC("ERROR", "Jni can not find method named \"getRecordsByFilter\""); return GN_ERR; } g_method_getrecordsbyfilter = (jmethodID)((*jni_env)->NewGlobalRef(jni_env, (jobject)mid)); //Get method: get all records mid = (*jni_env)->GetStaticMethodID(jni_env, g_hbase_client, "getAllRecords", "(Ljava/lang/String;Ljava/lang/String;)[Ljava/lang/String;"); if(0 == mid) { LOG_PROC("ERROR", "Jni can not find method named \"getAllRecords\""); return GN_ERR; } g_method_getallrecords = (jmethodID)((*jni_env)->NewGlobalRef(jni_env, (jobject)mid)); //Get method: get one record mid = (*jni_env)->GetStaticMethodID(jni_env, g_hbase_client, "getOneRecord", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"); if(0 == mid) { LOG_PROC("ERROR", "Jni can not find method named \"getOneRecord\""); return GN_ERR; } g_method_getonerecord = (jmethodID)((*jni_env)->NewGlobalRef(jni_env, (jobject)mid)); //Get the latest version of topology query_value(TOPO_VER, value); g_topology_version = atoi(value); LOG_PROC("INFO", "Topology version: %d", g_topology_version); //Get the latest master of topology query_value(MASTER_ID, value); g_master_id = strtoul(value, 0, 10); LOG_PROC("INFO", "User specified master is: %llu", g_master_id); return GN_OK; }
/* INT4 add_flow_entry(gn_switch_t *sw, gn_flow_t *flow) { uuid_t uuid_gen; if(sw->conn_state == INITSTATE) { return GN_ERR; } pthread_mutex_lock(&sw->flow_entry_mutex); if(NULL == find_flow_entry(sw, flow)) { uuid_generate_random(uuid_gen); uuid_unparse(uuid_gen, flow->uuid); if(sw->flow_entries) { gn_flow_t *p_flow = sw->flow_entries; while(p_flow->next) { p_flow = p_flow->next; }; p_flow->next = flow; } else { flow->prev = NULL; flow->next = NULL; sw->flow_entries = flow; } } else { pthread_mutex_unlock(&sw->flow_entry_mutex); return GN_ERR; } flow->status = ENTRY_DISABLED; pthread_mutex_unlock(&sw->flow_entry_mutex); return GN_OK; } */ gn_flow_t* copy_flow_entry(gn_flow_t *src) { gn_instruction_t *p_ins_src,*p_ins_dst; gn_instruction_t *p_ins_src_next; gn_instruction_t *p_ins_dst_next; gn_action_t *p_act_src = NULL, *p_act_src_next = NULL; gn_action_t *p_act_dst = NULL, *p_act_dst_next = NULL; gn_instruction_actions_t* p_inact_src,* p_inact_dst; gn_flow_t *dest = NULL; dest =(gn_flow_t *)mem_get(g_gnflow_mempool_id); //addedby:yhy if(NULL == dest) { LOG_PROC("ERROR", "%s -- mem_get(g_gnflow_mempool_id) Fail",FN); return NULL; } dest->prev = NULL; dest->next = NULL; memcpy(dest->uuid,src->uuid,sizeof(src->uuid)); memcpy(dest->creater,src->creater,sizeof(src->creater)); dest->create_time = src->create_time; dest->table_id = src->table_id; dest->status = src->status; dest->idle_timeout = src->idle_timeout; dest->hard_timeout = src->hard_timeout; dest->priority = src->priority; memcpy(&dest->stats,&src->stats,sizeof(src->stats)); memcpy(&dest->match,&src->match,sizeof(src->match)); if(src->instructions == NULL) { dest->instructions = NULL; return dest; } p_ins_src = src->instructions; while(p_ins_src) { p_ins_dst_next = mem_get(g_gninstruction_mempool_id); //addedby:yhy if(NULL == p_ins_dst_next) { LOG_PROC("ERROR", "%s -- mem_get(g_gninstruction_mempool_id) Fail",FN); return NULL; } p_ins_dst_next->type = p_ins_src->type; if((p_ins_src->type == OFPIT_APPLY_ACTIONS) || (p_ins_src->type == OFPIT_WRITE_ACTIONS)) { p_inact_src = (gn_instruction_actions_t *)p_ins_src; p_inact_dst = (gn_instruction_actions_t *)p_ins_dst_next; p_act_src = p_inact_src->actions; while(p_act_src) { p_act_dst_next = mem_get(g_gnaction_mempool_id); //addedby:yhy if(NULL == p_act_dst_next) { LOG_PROC("ERROR", "%s -- mem_get(g_gnaction_mempool_id) Fail",FN); return NULL; } memcpy(p_act_dst_next,p_act_src,sizeof(gn_action_t)); p_act_dst_next->next = NULL; if(p_inact_dst->actions == NULL) { p_inact_dst->actions = p_act_dst_next; } else { p_act_dst = p_inact_dst->actions; while(p_act_dst->next) { p_act_dst = p_act_dst->next; } p_act_dst->next = p_act_dst_next; } p_act_src_next = p_act_src->next; p_act_src = p_act_src_next; } } if(dest->instructions == NULL) { dest->instructions = p_ins_dst_next; dest->instructions->next = NULL; } else { p_ins_dst = dest->instructions; while(p_ins_dst->next) { p_ins_dst = p_ins_dst->next; } p_ins_dst->next = p_ins_dst_next; } p_ins_src_next = p_ins_src->next; p_ins_src = p_ins_src_next; } return dest; }
static INT4 l3_install_flow(gn_switch_t *sw, UINT4 gw_ip, UINT4 inport, ether_t *ether) { flow_mod_req_info_t flow_mod_req; gn_flow_t *flow = NULL; gn_instruction_actions_t *instruction = NULL; gn_action_output_t *action_outport = NULL; INT4 ret = 0; UINT4 src_ip = 0; UINT4 dst_ip = 0; if(ether->proto == htons(ETHER_ARP)) { arp_t *p_arp = (arp_t *)(ether); src_ip = ntohl(p_arp->sendip); dst_ip = ntohl(p_arp->targetip); } else if(ether->proto == htons(ETHER_IP)) { ip_t *p_ip = (ip_t *)(ether); src_ip = ntohl(p_ip->src); dst_ip = ntohl(p_ip->dest); } else { //by:yhy add 201701051305 LOG_PROC("ERROR", "l3_install_flow -- ether->proto return GN_ERR"); return GN_ERR; } memset(&sw->flowmod_helper, 0, sizeof(gn_flowmod_helper_t)); // flow = (gn_flow_t *)gn_malloc(sizeof(gn_flow_t)); flow = &sw->flowmod_helper.flow; strncpy(flow->creater, FLOW_L3_CREATER, sizeof(FLOW_L3_CREATER)); flow->create_time = g_cur_sys_time.tv_sec; flow->table_id = 0; flow->idle_timeout = g_l3_flow_entry_idle_time; flow->hard_timeout = g_l3_flow_entry_hard_time; flow->priority = 1; flow->match.type = OFPMT_OXM; flow->match.oxm_fields.ipv4_dst = src_ip; flow->match.oxm_fields.mask |= (1 << OFPXMT_OFB_IPV4_DST); flow->match.oxm_fields.eth_type = ETHER_IP; flow->match.oxm_fields.mask |= (1 << OFPXMT_OFB_ETH_TYPE); // instruction = (gn_instruction_actions_t *)gn_malloc(sizeof(gn_instruction_actions_t)); instruction = &sw->flowmod_helper.instruction; instruction->type = OFPIT_APPLY_ACTIONS; instruction->next = flow->instructions; flow->instructions = (gn_instruction_t *)instruction; // action_outport = (gn_action_output_t *)gn_malloc(sizeof(gn_action_output_t)); action_outport = &sw->flowmod_helper.action_output; action_outport->port = inport; action_outport->next = instruction->actions; instruction->actions = (gn_action_t *)action_outport; flow_mod_req.xid = 0; flow_mod_req.buffer_id = 0xffffffff; flow_mod_req.out_port = 0xffffffff; flow_mod_req.out_group = 0xffffffff; flow_mod_req.command = OFPFC_ADD; flow_mod_req.flags = OFPFF13_SEND_FLOW_REM; flow_mod_req.flow = flow; // add_flow_entry(sw, flow); if(sw->ofp_version == OFP10_VERSION) { ret = sw->msg_driver.msg_handler[OFPT_FLOW_MOD](sw, (UINT1 *)&flow_mod_req); } else { ret = sw->msg_driver.msg_handler[OFPT13_FLOW_MOD](sw, (UINT1 *)&flow_mod_req); } //arp查找目的IP if(gw_ip) { UINT4 port_idx = 0; for(port_idx = 0; port_idx < sw->n_ports; port_idx++) { //if(!(sw->neighbor[port_idx])) //从非SW互联端口寻找 if(!(sw->neighbor[port_idx]->bValid)) //从非SW互联端口寻找 { arp_request(sw, ntohl(gw_ip), dst_ip, sw->ports[port_idx].port_no); } } } return ret; }