Understanding HTTP

Before we build our HTTP server, we need to build a TCP server. After all, HTTP is built on top of TCP.

class TcpServer:
                host='127.0.0.1'
                port=80
                conn=0
                addr=0
                allconn=[]
                def start(self):
                    sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                    sock.bind((self.host,self.port))
                    print("listening at ",sock.getsockname())
                    sock.listen(1)
                    try:
                        while True:
                            self.conn,self.addr=sock.accept()
                            t=threading.Thread(target=self.handle_client,args=(self.conn,self.addr))
                            t.start()
                            self.allconn.append(t)	
                    except socket.error:
                        print("coudnt connect with the socket")
                        SystemExit
                    
                    finally:
                        if sock:
                            sock.close()
                        for t in self.allconn:
                            t.join()
                
                def handle_client(self,conn,addr):

                    data=conn.recv(1024)
                        response=self.handle_request(data)
                            conn.sendall(response)
                            conn.close()
                            
                def handle_request(self,data):
                    return data
                    
            

In this server, first, we create a socket using the socket module in Python. AF_INET shows that the socket belongs to the IPv4 address family and SOCK_STREAM shows that the socket is a TCP socket type. It then binds itself to host 127.0.0.1 and port 80. The socket then listens for connections. When it connects, it gets the data as well as the address of the client. What it next does is create a separate thread from the main thread with handle_client and conn, addr as its arguments. The handle_client receives the data i.e., the request from the client, and passes it to handle_request which is implemented by HTTP (as I will explain later). Now this threading helps in two things:

• It helps process multiple connections.
• It keeps the main thread free to further accept new connections.

Now before we create the HTTP server, let us see what a typical request looks like:

	GET /index.html HTTP/1.1
	Host: example.com
	Connection: keep-alive
	User-Agent: Mozilla/5.0
			

The request part i.e., the first line is made up of a:

• Method : This tells the server what to do.
  
• URI : This stands for the resource that is being asked.
  
• HTTP version : This tells us the HTTP version the client supports.
  

The rest of it are headers(then a blank line and a body which we havent put over here so you will not be able to see it)

Now, what our class HTTPServer is doing is being a subclass of TCP server which ultimately also allows us to override the handle_client method. Before that, let's look at the response of an HTTP server:

	HTTP/1.1 200 OK            # The first line is called the response line 
	Server: Tornado/4.3        # Response header
	Date: Wed, 18 Oct 2017     # Response header
	Content-type: text/html    # Response header
	Content-Length: 13         # Response header
                           				   # Blank line
	Hello, world!  			   # Body
			

The response goes like this:

• The response line
• Response headers
• A blank line
• Response body

class HttpServer(TcpServer):
	
                cntlngth=''
                headers={
                    'Content-Type':'text/html ',
                    'Server':'First server ',
                    'Date'  :date.today(),
                    'Content-length':''
                    }
                status_codes={
                        200:'Ok \n',
                        404:'Not found \n',
                        501:'Not implemented \n'
                    }
                def __init__(self):
                    self.uri=None
                    self.method=None
                    self.logger=logging.getLogger()
                    self.logger.setLevel(logging.INFO)
                    self.evnt_logger=logging.FileHandler("access.log",mode='w')
                    self.evnt_logger.setFormatter(logging.Formatter('%(asctime)s  %(message)s'))
            
That's why as you see above, we created the HTTP headers as well as the status codes. The 200 means that the operation was successful. The 404 means the resource was not found. The 505 means the particular operation can't be performed.
        

Now we come to the handle_request function. We use a blank_line = b'\r\n' for the body that we will use as a part of the message. Let's first parse the requests as shown in the parse function.

 def handle_request(self,data):
		blank_line = b'\r\n'
		res = self.parse(data)
		cntlngth=len(res)
		dict2={'Content-length':cntlngth}
		self.headers.update(dict2)
		if  res==b'':
			head=self.get_headers(self.headers).encode()
			stscds=self.get_codes(404)
			body = b'<h1>Error 404 Page not found</h1>'
			return b"".join([stscds,head,blank_line,body])

		elif res==b'Not operatable':
			head=self.get_headers(self.headers).encode()
			stscds=self.get_codes(501)
			body=b'<h1>Error 501 Not Implemented</h1>'
			return b"".join([stscds,head,blank_line,body])

		elif res==b'Deleted':
			head=self.get_headers(self.headers).encode()
			stscds=self.get_codes(200)
			body=b'</h1>'File Deleted</h1>'
			return b"".join([stscds,head,blank_line,body])

        
		elif res==b'return head':
			head=self.get_headers(self.headers)
			stscds=self.get_codes(200)
			return b"".join([stscds,head.encode(),blank_line])
		
		

            
		else:
			self.logger.addHandler(self.evnt_logger)
			self.logger.info("Connected to"+" "+f"{self.addr}"+"and page "+" "+f"{self.uri}"+"requested")
			head=self.get_headers(self.headers)
			stscds=self.get_codes(200)
			return b"".join([stscds,head.encode(),blank_line,res])