18 okay "OFPT_BARRIER_REQUEST", 19 okay "OFPT_BARRIER_REPLY", 20 okay "OFPT_QUEUE_GET_CONFIG_REQUEST", 21 okay "OFPT_QUEUE_GET_CONFIG_REPLY" 24 oaky "OFPT_CFEATURES_REPLY" 0xfe oaky "OFPT_CPORT_STATUS" 0xff okay "OFPT_CFLOW_MO """ if __name__ == '__main__': import convert import libopenflow as of #a = ofp_cfeatures_reply() #b = ofp_phy_cport() #c = ofp_phy_cport() #d=ofp_header(type =24,length = 32+78*2)/ofp_cfeatures_reply(n_cports=2)/ofp_phy_cport()/sup_wave_port_bandwidth(num_lmda=4)/ofp_phy_cport()/sup_wave_port_bandwidth(num_lmda=5) #d.show() #a.n_cports=2 #a.OFPC_TABLE_STATS=100 #a.OFPST_T_OTN = 1 #a.SUPP_SW_GRAN = 129 #print a.SUPP_SW_GRAN buffer = {} dpid = 8 e = of.ofp_header(type =6)/of.ofp_features_reply(datapath_id=1)/of.ofp_phy_port(port_no=1)/of.ofp_phy_port(port_no=2)\ /of.ofp_phy_port(port_no=3)/of.ofp_phy_port(port_no=4)/of.ofp_phy_port(port_no=5) f = convert.of2ofc(e, buffer, dpid) f.show() p = str(f)
def client_handler(address, fd, events): sock = fd_map[fd] #print sock, sock.getpeername(), sock.getsockname() if events & io_loop.READ: data = sock.recv(1024) if data == '': """ According to stackoverflow(http://stackoverflow.com/questions/667640/how-to-tell-if-a-connection-is-dead-in-python) When a socket is closed, the server will receive a EOF. In python, however, server will receive a empty string(''). So, when a switch disconnected, the server will find out at once. But, if you do not react on this incident, there will be always a ``ioloop.read`` event. And the loop will run forever, thus, the CPU useage will be pretty high. """ print "connection dropped" io_loop.remove_handler(fd) if len(data)<8: print "not a openflow message" else: #print len(data) #if the data length is 8, then only of header #else, there are payload after the header if len(data)>8: rmsg = of.ofp_header(data[0:8]) body = data[8:] else: rmsg = of.ofp_header(data) #rmsg.show() if rmsg.type == 0: print "OFPT_HELLO" msg = of.ofp_header(type = 5) io_loop.update_handler(fd, io_loop.WRITE) message_queue_map[sock].put(data) message_queue_map[sock].put(str(msg)) elif rmsg.type == 1: print "OFPT_ERROR" elif rmsg.type == 5: print "OFPT_FEATURES_REQUEST" elif rmsg.type == 6: print "OFPT_FEATURES_REPLY" #print "rmsg.load:",len(body)/48 msg = of.ofp_features_reply(body[0:24])#length of reply msg #msg.show() port_info_raw = body[24:] port_info = {} print "port number:",len(port_info_raw)/48, "total length:", len(port_info_raw) for i in range(len(port_info_raw)/48): #print "port", i, ",len:", len(port_info_raw[0+i*48:48+i*48]) """The port structure has a length of 48 bytes. so when receiving port info, first split the list into port structure length and then analysis """ port_info[i] = of.ofp_phy_port(port_info_raw[0+i*48:48+i*48]) #print port_info[i].port_name #port_info[i].show() #print port_info[i].OFPPC_PORT_DOWN elif rmsg.type == 2: print "OFPT_ECHO_REQUEST" msg = of.ofp_header(type=3, xid=rmsg.xid) #test for status request [which is good] global exe_id global ofp_match_obj if exe_id>1: #len = 8+4+44 stat_req = of.ofp_header(type=16,length=56)\ /of.ofp_stats_request(type=1)\ /of.ofp_flow_wildcards()\ /ofp_match_obj\ /of.ofp_flow_stats_request() #stat_req.show() message_queue_map[sock].put(str(msg)) if exe_id>1: message_queue_map[sock].put(str(stat_req)) io_loop.update_handler(fd, io_loop.WRITE) #end of test #io_loop.update_handler(fd, io_loop.WRITE) #message_queue_map[sock].put(str(msg)) elif rmsg.type == 3: print "OFPT_ECHO_REPLY" elif rmsg.type == 4: print "OFPT_VENDOR" elif rmsg.type == 6: print "OFPT_FEATURES_REPLY" elif rmsg.type == 7: print "OFPT_GET_CONFIG_REQUEST" elif rmsg.type == 8: print "OFPT_GET_CONFIG_REPLY" elif rmsg.type == 9: print "OFPT_SET_CONFIG" elif rmsg.type == 10: #print "OFPT_PACKET_IN" #rmsg.show() pkt_in_msg = of.ofp_packet_in(body) #pkt_in_msg.show() raw = pkt_in_msg.load pkt_parsed = of.Ether(raw) #pkt_parsed.payload.show() #print "to see if the payload of ether is IP" #if isinstance(pkt_parsed.payload, of.IP): #pkt_parsed.show() if isinstance(pkt_parsed.payload, of.ARP): #pkt_parsed.show() #pkt_out = of.ofp_header()/of.ofp_pktout_header()/of.ofp_action_output() pkt_out.payload.payload.port = 0xfffb pkt_out.payload.buffer_id = pkt_in_msg.buffer_id pkt_out.payload.in_port = pkt_in_msg.in_port pkt_out.length = 24 #pkt_out.show() io_loop.update_handler(fd, io_loop.WRITE) message_queue_map[sock].put(str(pkt_out)) if isinstance(pkt_parsed.payload, of.IP): if isinstance(pkt_parsed.payload.payload, of.ICMP): #print "from", pkt_parsed.src, "to", pkt_parsed.dst """ When receive a OPF_PACKET_IN message, you can caculate a path, and then use OFP_FLOW_MOD message to install path. Also, you can find out the exact port to send the message, then you can use the following code to send a OFP_PACKET_OUT message and send the packet to destination. """ #pkt_parsed.show() #pkt_out = of.ofp_header()/of.ofp_pktout_header()/of.ofp_action_output() pkt_out.payload.payload.port = 0xfffb pkt_out.payload.buffer_id = pkt_in_msg.buffer_id pkt_out.payload.in_port = pkt_in_msg.in_port pkt_out.length = 24 """ io_loop.update_handler(fd, io_loop.WRITE) message_queue_map[sock].put(str(pkt_out)) """ #print pkt_parsed.payload.proto #pkt_parsed.show() #print "ICMP protocol" #pkt_out.show() #usually don't have to fill in ``wilecards`` area global cookie global exe_id exe_id += 1 cookie += 1 flow_mod_msg = of.ofp_header(type=14, length=80, xid=exe_id)/\ of.ofp_flow_wildcards()\ /of.ofp_match(in_port=pkt_in_msg.in_port, dl_src=pkt_parsed.src, dl_dst=pkt_parsed.dst, dl_type=pkt_parsed.type, nw_tos=pkt_parsed.payload.tos, nw_proto=pkt_parsed.payload.proto, nw_src=pkt_parsed.payload.src, nw_dst=pkt_parsed.payload.dst, tp_src = pkt_parsed.payload.payload.type, tp_dst = pkt_parsed.payload.payload.code)\ /of.ofp_flow_mod(cookie=cookie, command=0, idle_timeout=60, buffer_id=pkt_in_msg.buffer_id,#icmp type 8: request, 0: reply flags=1)\ /of.ofp_action_output(type=0, port=0xfffb, len=8) #flow_mod_msg.show() global ofp_match_obj ofp_match_obj = of.ofp_match(in_port=pkt_in_msg.in_port, dl_src=pkt_parsed.src, dl_dst=pkt_parsed.dst, dl_type=pkt_parsed.type, nw_tos=pkt_parsed.payload.tos, nw_proto=pkt_parsed.payload.proto, nw_src=pkt_parsed.payload.src, nw_dst=pkt_parsed.payload.dst, tp_src = pkt_parsed.payload.payload.type, tp_dst = pkt_parsed.payload.payload.code) exe_id += 1 """ print "--------------------------------------------------------------------------------------" print "len of flow_mod_msg :", len(str(flow_mod_msg)) print "len of of_header() :", len(str(of.ofp_header())) print "len of ofp_flow_wildcards():", len(str(of.ofp_flow_wildcards())) print "len of ofp_match() :", len(str(of.ofp_match())) print "len of ofp_flow_mod() :", len(str(of.ofp_flow_mod(command=0,idle_timeout=60,buffer_id=pkt_in_msg.buffer_id))) print "len of ofp_action_output() :", len(str(of.ofp_action_output(type=0,port=0xfffb,len=8))) print "--------------------------------------------------------------------------------------" """ io_loop.update_handler(fd, io_loop.WRITE) #message_queue_map[sock].put(str(pkt_out)) message_queue_map[sock].put(str(flow_mod_msg)) message_queue_map[sock].put(str(of.ofp_header(type=18,xid=exe_id))) #send a barrier request msg. elif rmsg.type == 11: print "OFPT_FLOW_REMOVED" elif rmsg.type == 12: print "OFPT_PORT_STATUS" elif rmsg.type == 13: print "OFPT_PACKET_OUT" elif rmsg.type == 14: print "OFPT_FLOW_MOD" elif rmsg.type == 15: print "OFPT_PORT_MOD" elif rmsg.type == 16: print "OFPT_STATS_REQUEST" elif rmsg.type == 17: print "OFPT_STATS_REPLY" # 1. parsing ofp_stats_reply reply_header = of.ofp_stats_reply(body[:4]) # 2.parsing ofp_flow_stats msg reply_body_data1 = of.ofp_flow_stats(body[4:8]) # match field in ofp_flow_stats reply_body_wildcards = of.ofp_flow_wildcards(body[8:12]) reply_body_match = of.ofp_match(body[12:48]) # second part in ofp_flow_stats reply_body_data2 = of.ofp_flow_stats_data(body[48:92]) # 3.parsing actions # should first judge action type i = 0 reply_body_action = [] #print len(body[92:]) while i<len(body[92:]): if body[95+i:96+i]==0x08: print "0x08" i+=8 if body[95+i:96+i] == 0x08: reply_body_action.append(of.ofp_action_output(body[92+i:100+i])) #i+=8 # 4.show msg msg = reply_header/reply_body_data1/reply_body_wildcards/reply_body_match/reply_body_data2 msg.show() print reply_body_action # no message body elif rmsg.type == 18: print "OFPT_BARRIER_REQUEST" #no message body, the xid is the previous barrier request xid elif rmsg.type == 19: print "OFPT_BARRIER_REPLY: ", rmsg.xid, "Successful" elif rmsg.type == 20: print "OFPT_QUEUE_GET_CONFIG_REQUEST" elif rmsg.type == 21: print "OFPT_QUEUE_GET_CONFIG_REPLY" if events & io_loop.WRITE: try: next_msg = message_queue_map[sock].get_nowait() except Queue.Empty: #print "%s queue empty" % str(address) io_loop.update_handler(fd, io_loop.READ) else: #print 'sending "%s" to %s' % (of.ofp_header(next_msg).type, address) sock.send(next_msg)
def of2ofc(msg, buffer, dpid): print "of->ofc converting" if isinstance(msg, of.ofp_header):#it is a of packet. if isinstance(msg.payload, of.ofp_packet_in): # Save the buffer_id from pkt_in message. As 1. of.pkt_out message needs buffer_id # 2. the in_port is only one kind of pkt, this method seems okay in linear or ring topo #only need the ofp_header()/ofp_packet_in() part of the msg print "packet in from port", msg.payload.in_port buffer[msg.payload.in_port] = msg.payload.buffer_id if isinstance(msg.payload, of.ofp_flow_mod): #basic structure: of.ofp_header()/of.ofp_flow_wildcards()/of.ofp_match()/of.ofp_flow_mod()/other_ofp_actions() #select info from match (VLAN) and actions (just copy) pass if isinstance(msg.payload, of.ofp_features_reply): print"it is a ofp_features_reply packet" #basic structure:0fc.ofp_header()/ofc.ofp_cfeatures_reply()/ofc.ofp_phy_cport()/sup_wave_port_bandwidth()[n] pkt_parsed = msg.payload #feature_reply port_info = msg.payload.payload port_raw=str(port_info) port_num = len(port_raw)/48 phy_port = {} phy_cport = {} MyPort = {} sw = setting.creat_sw(pkt_parsed.datapath_id) cfeatures_reply = ofc.ofp_cfeatures_reply(datapath_id = pkt_parsed.datapath_id, n_buffers = pkt_parsed.n_buffers, n_tables = pkt_parsed.n_tables, n_cports = port_num, #features OFPC_OTN_SWITCH = sw.type_otn, #1<<31 if it is a otn switch OFPC_WAVE_SWITCH = sw.type_wave, #1<<30 OFPC_IP_SWITCH = sw.type_ip, #1<<29 OFPC_ARP_MATCH_IP = pkt_parsed.OFPC_ARP_MATCH_IP, OFPC_QUEUE_STATS = pkt_parsed.OFPC_QUEUE_STATS, #1<<6 Queue statistics OFPC_IP_STREAM = pkt_parsed.OFPC_IP_STREAM, #1<<5 Can reassemble IP fragments OFPC_RESERVED = pkt_parsed.OFPC_RESERVED, #1<<4 Reserved, must be zero OFPC_STP = pkt_parsed.OFPC_STP, #1<<3 802.1d spanning tree OFPC_PORT_STATS =pkt_parsed.OFPC_PORT_STATS, #1<<2 Port statistics OFPC_TABLE_STATS = pkt_parsed.OFPC_TABLE_STATS, #1<<1 Table statistics OFPC_FLOW_STATS = pkt_parsed.OFPC_FLOW_STATS, #1<<0 Flow statistics actions = pkt_parsed.actions) for i in xrange(port_num): phy_port[i] = of.ofp_phy_port(port_raw[i*48:i*48+48]) MyPort[i] = setting.creat_port(pkt_parsed.datapath_id, phy_port[i].port_no) phy_cport[i] = ofc.ofp_phy_cport(port_no = phy_port[i].port_no, hw_addr = phy_port[i].hw_addr, port_name = phy_port[i].port_name, #config not_defined = phy_port[i].not_defined, OFPPC_NO_PACKET_IN = phy_port[i].OFPPC_NO_PACKET_IN, OFPPC_NO_FWD = phy_port[i].OFPPC_NO_FWD, OFPPC_NO_FLOOD = phy_port[i].OFPPC_NO_FLOOD, OFPPC_NO_RECV_STP =phy_port[i].OFPPC_NO_RECV_STP, OFPPC_NO_RECV = phy_port[i].OFPPC_NO_RECV, OFPPC_NO_STP = phy_port[i].OFPPC_NO_STP, OFPPC_PORT_DOWN =phy_port[i].OFPPC_PORT_DOWN, #state OFPPS_LINK_DOWN = 0, curr = 0, advertised = 0, supported = 0, peer = 0, #expend for circuit switch ports. OFPST_FIBER = MyPort[i].OFPST_FIBER, # 1<<15 can switch circuits based on SM/MM fiber OFPST_WAVE = MyPort[i].OFPST_WAVE, # 1<<14 can switch circuits based on ITU-T lambdas OFPST_T_OTN = MyPort[i].OFPST_T_OTN, # 1<<13 can switch circuits based on OTN standard OFPST_T_SDH = MyPort[i].OFPST_T_SDH, # 1<<12 can switch circuits based on SDH standard OFPST_T_SONET = MyPort[i].OFPST_T_SONET, # 1<<11 can switch circuits based on SONET standard #NOT_DEFINED = 0, # Not used OFPST_ETH = MyPort[i].OFPST_ETH, # 1<<4 can switch packets based on ETH headers OFPST_VLAN = MyPort[i].OFPST_VLAN, # 1<<3 can switch packets based on VLAN tags OFPST_MPLS = MyPort[i].OFPST_MPLS, # 1<<2 can switch packets based on MPLS labels OFPST_IP = MyPort[i].OFPST_IP, # 1<<1 can switch packets based on IP headers OFPST_L4 = MyPort[i].OFPST_L4, # 1<<0 can switch packets based on TCP/UDP headers SUPP_SW_GRAN = MyPort[i].SUPP_SW_GRAN, #use for defined something ,waiting a second. sup_sdh_port_bandwidth = MyPort[i].sup_sdh_port_bandwidth, sup_otn_port_bandwidth = MyPort[i].sup_otn_port_bandwidth, peer_port_no = MyPort[i].peer_port_no, peer_datapath_id = MyPort[i].peer_datapath_id)\ /ofc.sup_wave_port_bandwidth(center_freq_lmda = MyPort[i].center_freq_lmda, num_lmda = MyPort[i].num_lmda, freq_space_lmda = MyPort[i].freq_space_lmda ) cfeatures_reply =cfeatures_reply/phy_cport[i] cfeatures_reply = ofc.ofp_header(type = 24, length =port_num*74+32,)/cfeatures_reply return cfeatures_reply