Python的网络编程[3] -> BOOTP 协议[1] -> BOOTP 的 Python 实现

BOOTP实现 / BOOTP Implement

---

目录

1. BOOTP 的服务器建立过程
2. BOOTP 的客户端建立过程

Note: 理论部分请参考文末相关阅读链接

1 BOOTP 的服务器建立过程

服务器建立步骤主要有:

（1）      设定服务器IP，传送ip(offer_ip)，服务端口68，客户端口67;

（2）      建立send_socket/UDP，广播模式允许复用，绑定到服务器ip，客户端端口;

（3）      建立主循环，建立recv_socket进行监听广播地址和客户端口;

（4）      Recv_socket进行广播接收，筛选收到的广播报文，对有效报文进行解码;

（5）      解码报文获取相应信息，xid，mac_id等;

（6）      加码回传报文，填入收到的xid，mac_id，server ip，offer ip, 文件名等;

（7）      利用send_socket向68端口以广播形式回复报文;

（8）      判断待传文件是否还有未传送的，是则回到循环等待下一个有效广播请求

Note: BOOTP_CodeC 中的加码实现可参考 BOOTP 加码的 Python 实现部分内容

 import socket
 import struct
 import os
 from BOOTP_CodeC import ServerCodeC
 SERVERNAME = 'Bootpserver'

 class BOOTPServer():
     def __init__(self):
         self.server_ip = '127.0.0.1'
         self.offer_ip = '127.0.0.8'
         self.server_port = 68   # Respond client via this port
         self.client_port = 67   # Receive client data via this port
         self.send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self.send_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True)
         self.send_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
         #self.send_sock.bind((self.server_ip, self.client_port))
         self.file_bin = ['secondboot.b3', 'files4.rc']

     def requestCheck(self, m):
         if not (
                 m['op'] == b'\x01' and # OP
                 m['htype'] == b'\x01' and # HTYPE
                 m['hlen'] == b'\x06' and # HLEN
                 m['hops'] == b'\x00' and # HOPS
                 m['secs'] == [b'\x00', b'\x00'] and # SECS
                 m['flags'] == [b'\x80', b'\x00'] and   # FLAGS (broadcast)
                 m['ciaddr'] == '0.0.0.0' and # Client IP Address
                 m['yiaddr'] == '0.0.0.0' and # Your Client IP Address
                 m['siaddr'] == '0.0.0.0' and # Server IP
                 m['giaddr'] == '0.0.0.0'  # Gateway IP
                 ):
             return False
         if not (
                 m['sname'] == SERVERNAME or
                 m['sname'] == ''):
             return False
         return True

     def server_start(self):
         file_index = 0
         while True:
             if file_index >= len(self.file_bin):
                 break
             self.rec_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             self.rec_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True)
             self.rec_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
             self.rec_sock.bind(('', self.client_port))
             print('=== Waiting for packet')
             msg, addr = self.rec_sock.recvfrom(1024)
             msgBody = ServerCodeC.collect(msg)
             print('<<< RECV from %s, client ip is %s, xid: %s, mac id: %s' %
                   (addr, msgBody['ciaddr'], msgBody['xid'], msgBody['chaddr']))
             if self.requestCheck(msgBody):
                 print('=== This is a valid message')
                 offer = ServerCodeC.offer(transaction_id=msgBody['xid'],
                                           client_ip_offer=self.offer_ip,
                                           server_ip=self.server_ip,
                                           client_mac_id=msgBody['chaddr'],
                                           file_path=self.file_bin[file_index])
                 self.send_sock.sendto(offer, ('<broadcast>', 68))
                 print('>>> SEND ("<broadcast>", 68), offer ip "%s", file name is "%s"' %
                       (self.offer_ip, self.file_bin[file_index]))
                 file_index += 1
         print('=== BOOTP server exit')

 server = BOOTPServer()
 server.server_start()

2 BOOTP 的客户端建立过程

客户端建立步骤主要有:

（1）      客户端ip未知，服务端口68，客户端口67;

（2）      建立主循环，建立socket/UDP，广播模式允许复用，监听服务端端口;

（3）      广播模式朝客户端口67发送请求报文，请求报文中填入客户端信息，如xid，mac_id等，并等待接收回复报文;

（4）      进行接收等待，若未超时且受到有效报文，则对有效报文进行解码;

（5）      解码报文获取相应信息，确认xid，mac_id与发送时的是否匹配;

（6）      提取报文信息，为后续（TFTP下载启动文件）做准备;

 import socket
 import binascii
 import struct
 from BOOTP_CodeC import ClientCodeC

 class BOOTPClient():
     def __init__(self):
         self.client_ip = '0.0.0.0'
         self.broadcast_ip = '255.255.255.255'   # or '<broadcast>'
         self.server_ip = '127.0.0.1'
         self.target_port = 67
         self.source_port = 68
         ClientCodeC.get_xid_macid()

     def recv_check(self, m):
         if not (
                 m['op'] == b'\x02' and # OP
                 m['htype'] == b'\x01' and # HTYPE
                 m['hlen'] == b'\x06' and # HLEN
                 m['hops'] == b'\x00' and # HOPS
                 m['secs'] == [b'\x00', b'\x00'] and # SECS
                 m['flags'] == [b'\x80', b'\x00'] and   # FLAGS (broadcast)
                 m['xid'] == ClientCodeC.transaction_id and
                 m['chaddr'] == ClientCodeC.client_mac_id and
                 len(m['file'])
         ):
             return False
         return True

     def client_request(self):

         while True:
             self.client_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             self.client_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True)
             self.client_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
             self.client_sock.settimeout(5)
             #self.client_sock.bind((self.server_ip, 68))
             self.client_sock.bind(('', 68))

             self.client_sock.sendto(ClientCodeC.request(), ('<broadcast>', self.target_port))
             print('>>> SEND ("<broadcast>", %d) request command' % self.target_port)
             try:
                 data, addr = self.client_sock.recvfrom(1024)
             except socket.timeout:
                 print('=== BOOTP client exit')
                 break
             msgBody = ClientCodeC.collect(data)
             print('<<< RECV', addr)
             if self.recv_check(msgBody):
                 print('=== This is a valid message')
                 client_ip = msgBody['yiaddr']
                 server_name = msgBody['sname']
                 file_name = msgBody['file']
                 server_ip = msgBody['siaddr']
                 print('=== Server ip: %s, server name: %s, file name: %s, get ip address: %s' %
                       (server_name, server_ip, file_name, client_ip))
 client = BOOTPClient()
 client.client_request()

相关阅读

---

1. BOOTP 基本理论