def _netic_remove_path(self, request, arg): path = str(arg["{path_ID}"]) res = self.bodrt.netic_remove_path(path) if res == 0: # self.discoveryws.remove_existing_path(str(arg['{path_ID}'])) neticResponse(request, NTC_OK, responseCode=204) else: errorCode = {"errorCode": NTC_VP_ERR_PATH_NOT_FOUND} webservice.badRequest(request, errcode2str[NTC_VP_ERR_PATH_NOT_FOUND], errorCode) return NOT_DONE_YET return
def ws_deny_group(request, args): """ WS interface to permit(). """ content = webservice.json_parse_message_body(request) if content == None: print "error in getting state" return webservice.badRequest(request, "missing eaddr") for eaddr in content: if not is_valid_eth(eaddr): return webservice.badRequest(request, "malformed eaddr " + eaddr) for eaddr in content: deny(eaddr) return status()
def ws_whitelist_eth(request, args): """ Remove a mac address from filtering eap traffic. """ eaddr = args.get('eaddr') if not eaddr: return webservice.badRequest(request, "missing eaddr") eaddr = util.convert_to_eaddr(eaddr) data = Homework._dhcp.whitelist_mac_addr(eaddr) return json.dumps(Homework._dhcp.get_blacklist_mac_status())
def ws_deny(request, args): """ WS interface to deny(). """ eaddr = args.get('eaddr') if not eaddr: return webservice.badRequest(request, "missing eaddr") ipaddr = args.get('ipaddr') return deny(eaddr, ipaddr)
def ws_dns_deny_group(request, args): """ WS interface to dns_deny_group(). """ print request print args content = webservice.json_parse_message_body(request) if content == None: print "error in getting state" return webservice.badRequest(request, "missing eaddr") for permititem in content: if not is_valid_eth(permititem['eaddr']): return webservice.badRequest(request, "malformed eaddr " + eaddr) for permititem in content: dns_deny(permititem['eaddr'], permititem['hostname'])
def ws_blacklist_eth(request, args): """ Aggressive mac address exclusion at the level of wpa connectivity. """ eaddr = args.get('eaddr') if not eaddr: return webservice.badRequest(request, "missing eaddr") eaddr = util.convert_to_eaddr(eaddr) if eaddr in Homework.st['permitted']: del Homework.st['permitted'][eaddr] Homework._dhcp.revoke_mac_addr(eaddr) Homework._dhcp.blacklist_mac_addr(eaddr) return json.dumps(Homework._dhcp.get_blacklist_mac_status())
def ws_permit_group(request, args): """ WS interface to permit(). """ content = webservice.json_parse_message_body(request) if content == None: print "error in getting state" return webservice.badRequest(request, "missing eaddr") for eaddr in content: if not is_valid_eth(eaddr): return webservice.badRequest(request, "malformed eaddr " + eaddr) for eaddr in content: permit(eaddr) return status() # eaddr = args.get('eaddr') # if not eaddr: return webservice.badRequest(request, "missing eaddr") return '{"status" : "success"}' #permit(eaddr)
def ws_dns_permit(request, args): """ WS interface to dns_permit(). """ print request print args eaddr = args.get('eaddr') hostname = args.get('hostname') if not (eaddr and hostname): return webservice.badRequest(request, "missing eaddr") return dns_permit(eaddr, hostname)
def _create_flow_monitor(self, request, arg): a = {} content = request.content.read() errorCode = {} try: pathID = int(str(request.args['PathID'][0]),16) dpid = datapathid.from_host(int(request.args['dpid'][0])) except KeyError: errorCode['errorCode'] = NTC_ST_ERR_MISSING_M_FIELD webservice.badRequest(request,errcode2str[NTC_ST_ERR_MISSING_M_FIELD],errorCode) return NOT_DONE_YET except TypeError: errorCode['errorCode'] = NTC_ST_ERR_BAD_ARGUMENT webservice.badRequest(request,errcode2str[NTC_ST_ERR_BAD_ARGUMENT],errorCode) return NOT_DONE_YET try: duration = int(request.args['duration'][0]) frequency = int(request.args['frequency'][0]) except: duration = 100 frequency = 1; monitorID,error = self.ll.create_new_flow_monitor(pathID,dpid,duration,frequency) if (error == 0): hexRes = "%x" %monitorID a['MonitorID'] = hexRes self.monitorIDs.append(monitorID) neticResponse(request,NTC_OK,a) if(error == 1): errorCode['errorCode'] = NTC_ST_ERR_PATH_NOT_FOUND webservice.badRequest(request,errcode2str[NTC_ST_ERR_PATH_NOT_FOUND],errorCode) return NOT_DONE_YET elif (error == 2): errorCode['errorCode'] = NTC_ST_ERR_DPID_NOT_FOUND webservice.badRequest(request,errcode2str[NTC_ST_ERR_DPID_NOT_FOUND],errorCode) return NOT_DONE_YET
def _netic_create_path(self, request, arg): # content = json_parse_message_body(arg) content = request.content.read() errorCode = {} try: nw_src = str(request.args["nw_src"][0]) nw_dst = str(request.args["nw_dst"][0]) duration = int(request.args["duration"][0]) bandwidth = int(request.args["bandwidth"][0]) set_arp = int(request.args["set_arp"][0]) bidirectional = int(request.args["bidirectional"][0]) except: errorCode["errorCode"] = NTC_VP_ERR_MISSING_M_FIELD webservice.badRequest(request, errcode2str[NTC_VP_ERR_MISSING_M_FIELD], errorCode) return NOT_DONE_YET # bidirectional and set_arp has to be either 0 or 1: if ((set_arp != 0) and (set_arp != 1)) or ((bidirectional != 0) and (bidirectional != 1)): errorCode["errorCode"] = NTC_VP_ERR_MISSING_M_FIELD webservice.badRequest(request, errcode2str[NTC_VP_ERR_MISSING_M_FIELD], errorCode) return NOT_DONE_YET paramsMissing = 0 try: dp_src = datapathid.from_host(int(request.args["dp_src"][0])) dp_dst = datapathid.from_host(int(request.args["dp_dst"][0])) first_port = int(request.args["first_port"][0]) last_port = int(request.args["last_port"][0]) except: dp_src = -1 dp_dst = -1 first_port = -1 last_port = -1 paramsMissing = 1 info_src = self.discovery.find_host_by_ipstr(nw_src) info_dst = self.discovery.find_host_by_ipstr(nw_dst) if paramsMissing == 1: # Try to find in which port and switch the path will begin and # terminate if info_src == None or info_dst == None: errorCode["errorCode"] = NTC_VP_ERR_MISSING_LOC_INFO webservice.badRequest(request, errcode2str[NTC_VP_ERR_MISSING_LOC_INFO], errorCode) return NOT_DONE_YET else: dp_src = datapathid.from_host(info_src["dp"]) first_port = info_src["port"] dp_dst = datapathid.from_host(info_dst["dp"]) last_port = info_dst["port"] else: # the dp source and dest and also first and last ports # are those specified by the request, lets check them if not self.discoveryws.discovery.is_valid_dpid( dp_src.as_host() ) or not self.discoveryws.discovery.is_valid_dpid(dp_dst.as_host()): errorCode["errorCode"] = NTC_VP_ERR_UNKNOWN_SWITCH webservice.badRequest(request, errcode2str[NTC_VP_ERR_UNKNOWN_SWITCH], errorCode) return NOT_DONE_YET if not self.discoveryws.discovery.is_valid_port_in_dpid( dp_src.as_host(), first_port ) or not self.discoveryws.discovery.is_valid_port_in_dpid(dp_dst.as_host(), last_port): errorCode["errorCode"] = NTC_VP_ERR_UNKNOWN_PORT webservice.badRequest(request, errcode2str[NTC_VP_ERR_UNKNOWN_PORT], errorCode) return NOT_DONE_YET # At this point we have the mandatory params of the flow and # location of the source and destination point of the path paramsMissing = 0 keyError = 0 with_arp = False if set_arp == 1: with_arp = True try: dl_src = create_eaddr(str(request.args["dl_src"][0])) dl_dst = create_eaddr(str(request.args["dl_dst"][0])) except KeyError: dl_src = 0 dl_dst = 0 keyError = 1 paramsMissing = 1 except: print "other error" if (dl_src == None) | (dl_dst == None): paramsMissing = 1 if paramsMissing == 1: if info_src != None: dl_src = info_src["dl_addr"] if info_dst != None: dl_dst = info_dst["dl_addr"] if (dl_src == None) | (dl_dst == None): if keyError == 1: errorCode["errorCode"] = NTC_VP_ERR_MISSING_MAC_ADDRESS webservice.badRequest(request, errcode2str[NTC_VP_ERR_MISSING_MAC_ADDRESS], errorCode) else: errorCode["errorCode"] = NTC_VP_ERR_BAD_MAC_ADDRESS webservice.badRequest(request, errcode2str[NTC_VP_ERR_MISSING_MAC_ADDRESS], errorCode) return NOT_DONE_YET # At this point even arp info is ready tp_src = 0 tp_dst = 0 ip_proto = 255 granularity = True try: ip_proto = int(request.args["ip_proto"][0]) except: granularity = False if granularity == True: try: tp_src = int(request.args["tp_src"][0]) except: tp_src = 0 try: tp_dst = int(request.args["tp_dst"][0]) except: tp_dst = 0 else: ip_proto = 255 npi = Netic_path_info() npi.nw_src = nw_src npi.nw_dst = nw_dst npi.duration = duration npi.bandwidth = bandwidth if set_arp == True: npi.set_arp = True else: npi.set_arp = False if bidirectional == True: npi.bidirect = True else: npi.bidirect = False npi.dp_src = dp_src npi.dp_dst = dp_dst npi.first_port = first_port npi.last_port = last_port if set_arp == True: npi.dl_src = dl_src npi.dl_dst = dl_dst npi.ip_proto = ip_proto npi.tp_src = tp_src npi.tp_dst = tp_dst res, error = self.bodrt.netic_create_route(npi) if error == 0: a = {} a["directPath"] = res.directPath self.discoveryws.add_created_path(res.directPath) if res.reversPath >= 0: self.discoveryws.add_created_path(res.reversPath) a["reversPath"] = res.reversPath neticResponse(request, NTC_OK, a) else: neticResponse(request, NTC_VP_INFO_PATH_NOT_FOUND)
def handle_ws_request(self, request, data): if self.current_session != None: return webservice.conflictError(request, "Outstanding request pending. Try again later.") oscars_request = None try: json_content = webservice.json_parse_message_body(request) if json_content == None: raise ValueError('Invalid JSON request') oscars_request = OSCARSRequest(json_content) for path_element in oscars_request.path: dpid = None lg.debug("Trying to find switch in known_switches") for (curr_dpid, switch) in self.known_switches.items(): if switch["ip"] == path_element["switch"]: dpid = switch["dpip"] lg.debug("Found dpid for %s in existing switches" % (path_element["switch"])) break if not dpid: lg.debug("Trying to find switch in config") try: dpid = long(config.get(path_element["switch"], "datapath_id"), 0) except Exception as e: lg.error("Problem finding 'datapath_id' for '%s': %s" % (element["switch"], e.__str__())) raise ValueError("Unknown switch '%s'" % element["switch"]) curr_switch = None if dpid and self.known_switches.has_key(dpid): curr_switch = self.known_switches[dpid] if not curr_switch: error_msg = "Switch '%s' is not a known switch" % (path_element["switch"]) lg.error(error_msg) raise ValueError(error_msg) lg.debug("Checking for commands") for key in "del-flows", "add-flows": if key in path_element: if len(path_element[key]) != 2: raise ValueError("The flow needs to have two elements") lg.debug("Trying %s" % key) for i in range(0,1): lg.debug("Parsing port") port = int(path_element[key][i]["port"]) lg.debug("Checking ports_by_id") if port in curr_switch["ports_by_id"]: continue lg.debug("Checking ports_by_name") if str(port) in curr_switch["ports_by_name"]: path_element[key][i]["port"] = curr_switch["ports_by_name"][str(port)]["port_no"] continue raise ValueError("Unknown port: %s in %s" % (path_element[key][i]["port"], hex(dpid))) except Exception as e: lg.error("Invalid request: %s" % e.__str__()) return webservice.badRequest(request, e.__str__()) self.current_session = OSCARSSession(request=oscars_request, raw_request=request) successful = True error_msg = "" try: if self.current_session.request.path: logger.debug("Request has a path") for path_element in self.current_session.request.path: dpid = long(config.get(path_element["switch"], "datapath_id"), 0) logger.debug("Configuring switch %s: %s" % (path_element["switch"], dpid)) for key in "del-flows", "add-flows": logger.debug("Handling %s for switch %s/%s" % (key, path_element["switch"], dpid)) if key in path_element: if key == "del-flows": action = "delete" else: action = "add" logger.debug("Handling %s for switch %s" % (action, path_element["switch"])) self.modify_flow(action, dpid, path_element[key][0], path_element[key][1]); self.modify_flow(action, dpid, path_element[key][1], path_element[key][0]); except Exception as e: error_msg = "Problem handling request: %s" % e logger.error(error_msg) successful = False if successful: # wait 5 seconds and then check that the changes propagated self.post_callback(5, lambda: self.verify_changes(self.verify_changes_timeout_cb)) else: self.undo_changes() return webservice.NOT_DONE_YET