Internet-Draft					A. Pareek
Intended status: Experimental
Expires: January 10, 2017

			Knowledge Based Web Pages
		draft-anshul-knowledge-based-web-pages-00
Abstract

This document tries to address a problem of delivering redundant
content of a dynamic web page to the same client over the 
Internet. The dynamic web page made up of two kind of data first
one comes from external sources such as database or some text
files etc which is dynamic in the nature and may change over
the next request made from the same client, the second one is
static in the nature such as formatting tag of html[3] which
remain unchanged until the program of dynamic web page does
not modified.
Instead of sending the whole page at each subsequent request 
from the same client it is better to send the dynamic data and
client can use the static data from the cache of previous
response to format the dynamic data of current response.

Status of This Memo

This Internet-Draft is submitted in full conformance with the
provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF). Note that other groups may also distribute
working documents as Internet-Drafts. 
The list of current Internet-Drafts is at
http://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents
at any time. It is inappropriate to use Internet-Drafts 
as reference material or to cite them other than
 as "work in progress.

 Copyright (c) 2016 IETF Trust and the persons identified as the document
        authors.  All rights reserved.

Anshul,et al.		January 10, 2017			[Page	01]
Internet-Draft	Knowledge Based Web Page			July 2016

This document is subject to BCP 78 and the IETF Trust's Legal Provisions
        Relating to IETF Documents (http://trustee.ietf.org/license-info)
        in effect on the date of publication of this document.  Please
        review these documents carefully, as they describe your rights
        and restrictions with respect to this document.     

Table of Contents

	1. Introduction.................................02
	1.1	Static Web Page............................03
	1.2	Dynamic Web Page...........................03
	1.2.1		Server Side Dynamic Web Page..........03
	1.2.2		Client Side Dynamic Web Page..........03
	1.3	Terminology................................03
	1.4 	Overall Operation..........................04
	2. The Caching of Web Pages......................06
	3. The Knowledge Based Web Page..................06
	3.1 	The Content-Status Request Header 
		& Offset Response Header...................07
	3.2	Identifying Static & Dynamic Part
		of a web page..............................07
	3.3 Updating Cached Entry.......................10
	4. Offset Generation............................12
	5. Implementation in Java.......................13
	6. Difference between delta Encoding
		and Knowledge Based Web Page...............63
	7. The Version Number of HTTP Protocol..........63
	8. Security Considerations.......................63
	9. References....................................64
	10. Author's Address.............................64


1.	Introduction

A web server is a place where all World Wide Web pages simply
 called web pages reside over the internet. The Hyper Text 
Markup Language used to create a web page. When a request arrives
to the web server for a web page it simply delivers the set 

Anshul,et al.		January 10, 2017			[Page	02]
Internet-Draft	Knowledge Based Web Page			July 2016

of HTML instructions to the client using HTTP (Hyper Text 
Transfer Protocol)[1]. The HTTP is a delivery system through which 
a web page moves from a server to a client.

There are two types of Web Pages.[5]
1.1  Static Web Page: - A static web page is an html file 
stored on the web server. When a request arrives to the web server
for a static web page the server copies the file and delivers
it as it is to the client.


1.2  Dynamic Web Page: - A web page, if its content changes 
over the time   called dynamic web page. There are two types of
dynamic web page

1.2.1	Server-Side Dynamic Web Page: - A dynamic web page is a 
program stored on a web server. When a request arrives to a web 
server for the dynamic web page the server executes the program
and delivers output of the program to the client. 

1.2.2	Client-Side Dynamic Web Page: - A dynamic web page is a 
program stored on the web server. When a request arrives to a 
web server for the dynamic web page the server delivers the 
program to the client. The client executes the program and gets 
output which is the desired web page.

This Internet-Draft tries to improvise the delivery system of
the Server-Side dynamic web pages and try to develop a caching
mechanism for server side dynamic web pages.

1.3 Terminology
	This Internet-Draft uses a number of terms to refer to the roles
played by participants in, and objects of, the HTTP commu

nication for more details refer RFC 2616[1].
	Connection
		A transport layer virtual circuit established 
between two programs for the purpose of communication.
	Message
		The basic unit of HTTP communication, 
consisting of a structured
sequence of octets matching the syntax defined in rfc 2616

Anshul,et al.		January 10, 2017			[Page	03]
Internet-Draft	Knowledge Based Web Page			July 2016

	Request
		An HTTP request message, as defined in rfc 2616
	Response
		An HTTP response message, as defined in rfc 2616
	Client
		A program that establishes connections for the purpose of sending requests.
	Server
		An application program that accepts connections in order to 
		service requests by sending back responses.
	Origin server
		The server on which a given resource resides or is to be created.
	Cache
		A programs local store of response messages 
		and the subsystem that controls its message 
		storage, retrieval, and deletion.
		A cache stores cacheable responses in order to reduce 
		the response time and network bandwidth 
		consumption on future, equivalent requests.
	Validator
		A protocol element (e.g. an entity tag or a Last-Modified time)
 	that is used to find out whether a cache entry is an equivalent
 	copy of an entity.

1.4 Overall Operation
At present time, when a request for a dynamic web page arrives
at a server, the server executes the correspond program to
the request and send back the result to the client as illustrated
below

Example:-
Suppose a client makes a request of an employee named vikas to
a web server. The clients request would be as follow 

Request message format of HTTP 1.1 would be
Get /search.htmltxtCriteria=Vikas HTTP/1.1
Host: www.xyz.com
Connection: Keep-Alive
Accept: *

Anshul,et al.		January 10, 2017			[Page	04]
Internet-Draft	Knowledge Based Web Page			July 2016

The response from the server would be
HTTP/1.1 200 OK
Date: Mon, 08 Feb 2016 11:26:20 GMT
Content-Type: text/html
Content-Length: 325
Cache-Control: no-cache 

<html>
<head><title>Home Page</title></head>
<body><center>
<table>
<tr><th>Sr.No</th><th>Name</th><th>Designation</th><th>Dept</
th></tr>
<tr><th>1.</th><th>Vikas Soni</th><th>CA-II</th><th>Accounts<
/th></tr>
<tr><th>2.</th><th>Vikas Singh</th><th>CA-I</th><th>Accounts<
/th></tr>
</table></center></body></html>
Database search engine finds the two records begin with Vikas
string. Now, again a request reaches to the server with the
different search string at this time client wants the records 
begin with Viren String.

The response of the server would be as follows
HTTP/1.1 200 OK
Date: Mon, 08 Feb 2016 11:26:24 GMT
Content-Type: text/html
Content-Length: 245
Cache-Control: no-cache 

<html>
<head><title>Home Page</title></head>
<body>
<center>
<table>
<tr><th>Sr.No</th><th>Name</th><th>Designation</th><th>Dept</
th></tr>
<tr><th>1.</th><th>Viren Singh</th><th>CA-II</th><th>Accounts
</th></tr>
</table>
</center>
</body></html>

In both responses only the content of the table has changed
but the formatting tags and other part of the table and web
page remains same.
This document tries to eliminate this redundant information/ 
formatting tags to be send each time to the same client. This 
document tries to develop an algorithm which enable proxy 

Anshul,et al.		January 10, 2017			[Page	05]
Internet-Draft	Knowledge Based Web Page			July 2016

server/client to store the static part of the web page/formatting 
tags etc and ask only for the dynamic information from the
server then build the whole page.

2.	The caching of Web pages
The caching is a process of improving the response time of a 
server. In other words, when a server sends a response to satisfy
a request the response reaches to the client through the
intermediaries nodes among them some of nodes are caching proxy
servers which stores a copy of the response in order to satisfy
subsequent request of the resource which saves the time of 
both parties and improves the performance of the network.[9]

3.	The Knowledge Based Web Page 
If a client has an expired copy of a page, it requests the
latest instance of the page. If the server has a newer instance 
of the page, it will send it to the client, and it will sent
the full new instance of the page. 
Rather than sending it the entire new page, the client would 
get the page faster if the server sent just the changes to the
clients copy of the page.
Server can achieve this objective without help of a copy of 
the previous response if it delivers the OFFSETs which are the 
index of the content of a web page that separates the static
part and dynamic part of web page, the detail explanation of 
this algorithm is as follow.

The server needs two additional Header fields for accomplishing
this task first one is Content-Status and second one if Offset.
Content-Status header field present in the request message
and has a string in its value either Data or Page. Data Value
indicates the client requests only for update of a web page,

Anshul,et al.		January 10, 2017			[Page	06]
Internet-Draft	Knowledge Based Web Page			July 2016

in response to this request the server sent the changes to the
clients copy of the page along with offset header in response.
For the Page Value server sent the full new instance of the
page along with offset header in response.

3.1 Content-Status Request Header  Offset Response Header
	This Internet-Draft requests to the Internet 
Engineering Task Force to add these two new 
headers into the HTTP Protocol in
order to achieve the caching of Dynamic web page.
	The Content-Status request header presents in a request message
with value either PAGE or DATA. The value PAGE tells the
server that client wants a whole copy of a requested web page. 
The Value DATA tells the server that client wants only changes
/ Dynamic data of a requested web page.
	If content-status header is not present in a request message
 then server send the full instance of requested web page. In 
other words, server considers this case equivalent to 
Content-Status: PAGE.

	Offset header presents in the response message with paired 
integer values. The first value of a pair indicates the static 
part of the page and second value of a pair indicates the
dynamic part of a page and this header can has as many 
paired value as needed. 

3.2	Identifying Static and Dynamic Part of a Web Page
A program is a sequence of instructions every instruction has
a specific meaning to the microprocessor. A static part of page
would be those instructions which contain simple html tags.

A Dynamic Part of a page would be those instructions which call
a function or perform other processing and then their result
adds to the page.
import javax.servlet.http.*;  
import javax.servlet.*;  
import java.io.*;  
public class DemoServlet extends HttpServlet{  
public void doGet(HttpServletRequest req,HttpServletResponse 
res)  throws ServletException,IOException 

Anshul,et al.		January 10, 2017			[Page	07]
Internet-Draft	Knowledge Based Web Page			July 2016

{  
	Date d=new Date();
res.setContentType("text/html");//setting the content type  
PrintWriter pw=res.getWriter();//get the stream to write the 
data  
  
pw.println("<html><body>");  //Length is 13
pw.println("Welcome to servlet");// Length 19
pw.println(Date d); //At this time Length is 5
//The above line of code generates the dynamic data
pw.println("</body></html>");  
	  
pw.close();//closing the stream  
}}[8]  

Output of this program is
Welcome to servlet
Date May 04 09:51:52 CDT 2009

The Offset header for this Servlet program would be Offset: 
37-24
The value 37 indicates that after 37 characters, dynamic data
begins of length 24 characters long.

When a client makes a request first time of a page, the server
would sent the full instance of the page, the request and 
response messages would look like as follows.

The request message:-
----------------------------------------
Get /search.htmltxtCriteria=Viren HTTP/1.1
Accept-Encoding: gzip, compress
Date: Mon, 08 Feb 2016 11:26:20 GMT
Content-Type: text/html
Content-Status: Page
Keep-Connection: alive
----------------------------------------

On this request web server returns the full instance of the
page along with an Offset header.
The Content-Status header field tells the server that client 
needs full instance of the page.
If client needs only updated information, Content-Status value
will be set to DATA in the request message.

The response message:-
----------------------------------------
HTTP/1.1 200 OK
Date: Mon, 08 Feb 2016 11:26:20 GMT

Anshul,et al.		January 10, 2017			[Page	08]
Internet-Draft	Knowledge Based Web Page			July 2016

Cache-Control: must-revalidate
Offset: 148-72
Content-Length: 245

<html>
<head><title>Home Page</title></head>
<body>
<center>
<table>
<tr><th>Sr.No</th><th>Name</th><th>Designation</th><th>Dept</
th></tr>
<tr><th>1.</th><th>Viren Singh</th><th>CA-II</th><th>Accounts
</th></tr>
</table>
</center>
</body></html>
---------------------------------------
	
The Caching-Proxy-Server/Client Cache simply stores a copy of
the response message which helps next time to make request only
for updated information, offset header has two integer values
in a pair and may has as many paired values as necessary, in
each pair the first value represent the static data length and
second pair value represent the dynamic data length as explain
below.

Now client makes an another request for the same page with
different search criteria Vikas.

The request message:-
----------------------------------------
Get /search.htmltxtCriteria=Vikas HTTP/1.1
Accept-Encoding: gzip, compress
Date: Mon, 08 Feb 2016 11:26:20 GMT
Content-Type: text/html
Content-Status: Data
Keep-Connection: alive
----------------------------------------

On this request web server returns the changes of the page from
previous request with an Offset header as follow.

Anshul,et al.		January 10, 2017			[Page	09]
Internet-Draft	Knowledge Based Web Page			July 2016

The response message:-
----------------------------------------
HTTP/1.1 200 OK
Date: Mon, 08 Feb 2016 11:26:22 GMT
Cache-Control: must-revalidate
Offset: 148-142
Content-Length: 142

<tr><th>1.</th><th>Vikas Soni</th><th>CA-II</th><th>Accounts<
/th></tr>
<tr><th>2.</th><th>Vikas Singh</th><th>CA-I</th><th>Accounts<
/th></tr>
-----------------------------------------
Now, it a duty of the Caching Proxy Server/Client Caching 
Algorithm to generate a fresh copy of the page, the algorithm of 
updating cached copy is as discuss below for different sets of
inputs.

3.3 Updating Cached Entry
The Caching-Proxy-Server has to know the way that helps it to
generate the fresh copy with the help of Cached response and 
fresh response. The Algorithm of updating cached 
copy is discussed below with use of an example.

Input Set 1
Cached-Data: 148-72
Response-Data: 148-142

Step 1: Copy first 148 bytes from the cached copy to the fresh
copy because this is the static part of the page and initialize
the New-Offset variable to 148.

Step 2: Copy the 142 bytes from the response from it 0th position
to its 142nd position and update the New-Offset variable 
to 148-142

Step 3: Copy the remaining bytes left in the cached copy to
the fresh copy.

Step 4: Perform the following calculation on Content-Length
Header

	Content-Length=148 Bytes (Static Part) 142 Bytes (fresh 
information from the response) 25 Bytes (Remained in the 
cached to the end of the file, Static part)

Anshul,et al.		January 10, 2017			[Page	10]
Internet-Draft	Knowledge Based Web Page			July 2016


	Content-Length of Cached Data=245
	Total of Offset header of Cached Data=220 (148+72)
	245-220=25 (Remaining Static Part of Cached page)
Step 5: Exit

Input Set 2
Cached Data: 83-718,831-2,843-7
Response Data: 83-600,713-3,726-8

Step 1: Copy 83 bytes from Cached Copy to a fresh Copy and 
initialized a tempContentLength Variable to 83.

Step 2: Append 600 bytes from response to the fresh copy and 
modify the tempContentLength=600.

Step 3: Append 30 bytes from cache copy to the fresh copy 
starting 801th position and modify the tempContentLength=30.

83+718=801
831-801=30 bytes

Step 4: Append 3 bytes from response to the fresh copy and 
modify the tempContentLength=3.

Step 5: Append 10 bytes from Cached copy to the fresh copy 
and modify the tempContentLength=10.
831+2=833
843-833=10 bytes

Step 6: Append 8 bytes from the response and modify the tempC
ontentLength=8

Step 7: Use the recent Offset header from the last response.
Step 8: Perform the following calculation on Content-Length
Header
Content-Length of Cached Data=864
Total of the last pair of the Offset header of Cached Data=
850 (843+7)
864-850=14 (Remaining Static Part of Cached page)
tempContentLength=14

Step 9: Append 14 bytes of the cached response from the position
843+7 to the end of the file.
Step 10: Content-Length= tempContentLength
 
Step 11: Exit

Anshul,et al.		January 10, 2017			[Page	11]
Internet-Draft	Knowledge Based Web Page			July 2016

4.	Offset Generation

The Offset generation is a duty of a web server. However it is
a difficult to prepare a response message that contains only
changes to the previous message without having a copy of the 
delivered message.  
To accomplish this task, the web server can make use of a
program that produces the web page. If the program can be modify 
in a way that it also output the offsets along with the html
page.
The amendments into the program have to be made at the level 
of its parser and synthesize analyzer.
Suppose a parser supports the following grammar
The Grammar (Without Left Factoring)[10]

STMTS -> PRINT TEXT; STMTS |
     PRINT GETCOLUMN; STMTS |
    WHILE ( CONDITION )
	{
		STMTS
	} STMTS | NULL
CONDITION-> isNextRow | isNextColumn

For a simplicity of implementation of the parser the GETCOLUMN,
isNextRow and isNextColumn work like functions and are going
to be define into the definition of the parser.
The GETCOLUMN will be used to retrieve a column from the data
base and its functionality defines into the parser explicitly 
for simplicity.
The isNextRow returns true if there is any row in the recordset
otherwise false and its functionality defines into the parser
explicitly for simplicity.
The isNextColumn returns true if there is any column in the
recordset otherwise false and its functionality defines into the
parser explicitly for simplicity.
	
Input Program: Source Code

	PRINT <HTML><HEAD><TITLE>Simple Test</TITLE></HEAD>;
	PRINT <BODY BGCOLOR="GREEN">;

Anshul,et al.		January 10, 2017			[Page	12]
Internet-Draft	Knowledge Based Web Page			July 2016

	PRINT <TABLE BORDER="1">;
PRINT <TR><TH>Sr.No</TH><TH>Name</TH><TH>Designation</TH><TH>
Dept</TH></TR>;
	WHILE ( isNextRow )
	{
		PRINT <TR>;
		WHILE ( isNextColumn )
		{
			PRINT <TD>;
			PRINT GETCOLUMN; 
			PRINT </TD>;
		}
		PRINT </TR>;
}
PRINT </TABLE></BODY></HTML>;

The first three line and last line of this program produces
static data, the while part contains the dynamic data which 
depends on the condition in the while loop.
At the time of parsing, using symbol table the program can 
identify the static part and dynamic part. If a PRINT statement 
contains the ID (TEXT) which implies that it is a static part 
or if a PRINT statement contains the function in this grammar 
this would be GETCOLUMN only but for other languages such as 
Java Server Pages and Active Server Pages this function can be 
any which language supports.
The Evaluator which going to generate Offset for the above 
Grammar, can count the length of the static part at instantaneously
and for the dynamic part it can execute that function which
supplied in the PRINT statement and then count the length of
the result of that function. The Evaluator takes two arguments
as it parameter the program and integer variable for calculaing
offset. The Output of the Evaluator is the html page along
with the Offset.
5.	Implementation in Java [6][7]
Web Server Code
/*Class WebServer, Accept the incoming request 
And handover the request to HTTPProtocol Class 
This Server listen incoming request on port 81 Because 
all three processes i.e. Cache Server and Client 
are on the same machine*/
import java.util.*;
import java.net.*;
import java.io.*;
public class WebServer
{
	public static void main(String arg[])
	{
		ServerSocket requests;
		Socket connection; 
		Runnable r;
		Thread t;
		try
		{
Anshul,et al.		January 10, 2017			[Page	13]
Internet-Draft	Knowledge Based Web Page			July 2016

		requests=new ServerSocket(81);
		while(true)
			{
				connection=requests.accept();
				r=new HTTPProtocol(connection);
				t=new Thread(r);
				t.setDaemon(true);
				t.start();
			}
		}
		catch(Exception E)
		{
			System.out.print("Error: "+E);
		}
	}
}
/*Class HTTPProtocol, read the incoming request
And serve them as described by this draft*/
import java.util.*;
import java.net.*;
import java.io.*;
import javax.swing.*;
import java.text.*;
public class HTTPProtocol implements Runnable
{
	Socket con;
	InputStream in;
	OutputStream out;
	HTTPRequest request;
	HTTPResponse response;
	BufferedInputStream inStream;
	int ch=-1;
	public HTTPProtocol(Socket con) throws IOException,Exception
	{
		this.con=con;
		in=con.getInputStream();
		out=con.getOutputStream();
		inStream=new BufferedInputStream(in);
		inStream.mark(25);
	}
	public void run()
	{
		try{
			while((ch=inStream.read())!=-1) //This loop ensure persistent Connection with client
			{
				inStream.reset();
				request=new HTTPRequest(inStream);
				System.out.println(request);
				if(request.getMethod().equals("GET"))
				{
					if(request.getQueryString()!=null)
						{
						Thread t=Thread.currentThread();
Anshul,et al.		January 10, 2017			[Page	14]
Internet-Draft	Knowledge Based Web Page			July 2016

							try{
								String pageStatus;
			if((pageStatus=request.getHeaderValueByName("Content-Status"))==null)
	pageStatus="Page";
			ClassLoader loader=t.getContextClassLoader();
				String fileName=request.getUrl();
Class<?> cl=loader.loadClass(fileName.substring(0,fileName.indexOf('.')));
				String arg[]={request.getQueryString()," "+(request.getQueryString().length())
,""+pageStatus};
			(cl.getMethod("main",String[].class)).invoke(null,(Object)arg);
HTTPHeader hdr=
new HTTPHeader("200 OK","Pages/Result.html",
request.getMethod());
response=new HTTPResponse(out,hdr,"Pages/Result.html");
response.sendDynamicData();
}
catch(Exception e)
{
System.out.print("Client Side Error"+e);
}
}
else 
if(request.getHeaderValueByName
("If-Modified-Since")!=null)
{
String strDate=request.getHeaderValueByName
("If-Modified-Since");
boolean modified=isModified
(strDate,(new File(request.getUrl())).lastModified());
			if(modified)
			{
			//System.out.println("\n200 OK sending");
			HTTPHeader hdr=new HTTPHeader("200 OK",request);
			response=new HTTPResponse(out,hdr,request.getUrl());
			response.send();
			}
			else
			{
			//System.out.println("\n304 sending");
			HTTPHeader hdr=new HTTPHeader("304 Not Modified",request);
			response=new HTTPResponse(out,hdr);
			response.send();
			}
}
else
{
	HTTPHeader hdr=new HTTPHeader("200 OK",request);
	response=new HTTPResponse(out,hdr,request.getUrl());
	response.send();
}}
Anshul,et al.		January 10, 2017			[Page	15]
Internet-Draft	Knowledge Based Web Page			July 2016

else if(request.getMethod().equals("POST"))
{
//Request arrived from save.html, update.html
Thread t=Thread.currentThread();
	try{
	ClassLoader loader=t.getContextClassLoader();
	Class<?> cl=loader.loadClass(request.getUrl());
	String arg[]={request.getMessageBody(),request.getContentLength()};
	(cl.getMethod("main",String[].class)).invoke(null,(Object)arg);
					
HTTPHeader hdr=new HTTPHeader("200 OK","Pages/Result.html",request.getMethod());
	hdr.setContentLength("Pages/Result.html");
	response=new HTTPResponse(out,hdr,"Pages/Result.html");
	response.send();
	}
	catch(Exception e)
	{
		System.out.print("Client Side Error"+e);
	}}
	inStream.mark(25);
	}
	con.close();
	}
	catch(Exception  e)	
	{
	System.out.println("Error in Run Method: "+e+" "+ch);
	try{
		con.close();
		System.out.println("Connection Closed "+request);		
	}
	catch(Exception e1)
	{}
	}}
	public boolean isModified(String strDate, long fileDate) throws Exception
	{
	DateFormat fmt=new SimpleDateFormat("EEE, dd MMM yyyy kk:mm:ss zzz");
		TimeZone tz=TimeZone.getTimeZone("GMT");
		fmt.setTimeZone(tz);
		Date lastDate=fmt.parse(strDate);
		Date fileModified=fmt.parse(fmt.format(new Date(fileDate)));
		return (lastDate.before(fileModified));
	}
	public String toString()
	{
		return request.toString();	}}
Anshul,et al.		January 10, 2017			[Page	16]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class HTTP Response, defines the methods to handle 
the response and delivery*/
import java.io.*;
import java.util.*;
public class HTTPResponse
{
	PrintWriter out;
	HTTPHeader hdr;
	String url;
	public HTTPResponse(OutputStream out,HTTPHeader hdr,String url)throws IOException, Exception
	{
		this.out=new PrintWriter(out,true);
		this.hdr=hdr;
		this.url=url;
	}
	public HTTPResponse(OutputStream out,HTTPHeader hdr)throws IOException, Exception
	{
		this.out=new PrintWriter(out,true);
		this.hdr=hdr;
		this.url=null;
	}
	public void send()throws IOException,Exception
	{
		out.write(hdr.getStatusLine());
		out.write(hdr.getHeader());
		out.write("\r\n");
		out.flush();
		if(url!=null)
		{
			FileInputStream file=new FileInputStream(url);
			int c=0;
			String msg="";
			while((c=file.read())!=-1)
			{
				msg=msg+(char)c;
			}
			out.write(msg);
			file.close();
		}
		out.flush();
}
Anshul,et al.		January 10, 2017			[Page	17]
Internet-Draft	Knowledge Based Web Page			July 2016

	public void sendDynamicData() throws IOException, Exception
	{
		out.write(hdr.getStatusLine());
		System.out.print(hdr.getStatusLine());
		out.write(hdr.getHeader());
		System.out.print(hdr.getHeader());
		if(url!=null)
		{
			FileInputStream file=new FileInputStream(url);
			int c=0;
			String msg="";
			while((c=file.read())!=-1)
			{
				msg=msg+(char)c;
			}
			System.out.print(msg);
			out.write(msg);
			file.close();
		}
		out.flush();
	}}
Anshul,et al.		January 10, 2017			[Page	18]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class HTTPRequest, Read incoming request and process*/
import java.util.*;
import java.io.*;
public class HTTPRequest
{
	String method;
	String url;
	String HttpVer;
	String mBody;
	String queryString="";
	BufferedInputStream input;
	Map<String,String> headerList;
	public HTTPRequest(BufferedInputStream in) 
	{
		queryString=null;
		mBody="";
		try
		{
			input=in;
			headerList=new HashMap<String,String>();
			method=readRequestLine();
			url=readRequestLine();
			setQueryString(url);
			HttpVer=readRequestLine();
			String header="",value="";
			while(!((header=getHeader()).equals("\r\n")))
			{
				value=getHeaderValue();	
				headerList.put(header,value);
			}
			String temp="";
			if((temp=headerList.get("Content-Length"))!=null)
			{
		mBody=readMessageBody(Integer.parseInt(temp.substring(1)));
			}
		}
		catch(Exception e)
		{
			System.out.println("Error in HttpRequest Class "+e);
		}
	}
	public void setQueryString(String query)
	{
		if(query.indexOf('?')!=-1)
		queryString=query.substring(query.indexOf('?')+1);	
	}
	public String getQueryString()
	{
		return queryString;
	}
Anshul,et al.		January 10, 2017			[Page	19]
Internet-Draft	Knowledge Based Web Page			July 2016

	public String readMessageBody(int mLength) throws IOException, Exception
	{
		String body="";
		char ch;
		while(mLength>0)
		{
			ch=(char)input.read();
			body=body+ch;
			mLength--;
		}
		return body;
	}
	public String getHeaderValue() throws Exception, Exception
	{
		String token=new String();
		char ch;
		String CRLF="\r\n";
		ch=(char)input.read();
		while(ch!='\n')
		{
			if(ch!='\r')
			{
				token=token+ch;
			}
			ch=(char)input.read();
		}
		return token;
	}
	public String getHeader() throws IOException, Exception
	{
		String token=new String();
		char ch;
		String CRLF="\r\n";
		ch=(char)input.read();
		while((ch!=':') && (ch!='\n'))
		{
			if(ch!='\r')
			{
				token=token+ch;
			}
			else if(token.length()==0)
			{
				token=CRLF;
			}
			ch=(char)input.read();
		}
		return token;
	}
Anshul,et al.		January 10, 2017			[Page	20]
Internet-Draft	Knowledge Based Web Page			July 2016

	public String readRequestLine() throws IOException, Exception
	{
		String token=new String();
		char ch;
		String CRLF="\r\n";
		ch=(char)input.read();
		while((ch!=' ') && (ch!='\n'))
		{
			if(ch!='\r')
			{
				token=token+ch;	
			}
			else if(token.length()==0)
			{
				token=CRLF;
			}
			ch=(char)input.read();	
		}
		return token;
	}
	public String getMethod()
	{
		return method;
	}
	public String getUrl()
	{
		if(url.equals("/"))
		return "welcome.html";
		else
		{
			if(url.startsWith("/"))
			{
				if(url.indexOf('?')==-1)
				{
					int i=url.indexOf('/');
					url=url.substring(i+1);
				}
				else
				{
					url=url.substring(1,url.indexOf('?'));
				}
			}
			return url;
		}
}
	public String getHTTPVersion()
	{
		return HttpVer;
	}
Anshul,et al.		January 10, 2017			[Page	21]
Internet-Draft	Knowledge Based Web Page			July 2016

	public String getMessageBody()
	{
		return mBody;
	}
	public String getContentLength()
	{	
		return headerList.get("Content-Length");
	}
	public String getHeaderValueByName(String hName)
	{
		String temp=headerList.get(hName);
		if(temp!=null)
		return temp.substring(1);
		else
		return temp;
	}
	public String toString()
	{
		String headers="";
		for(Map.Entry<String,String> entry: headerList.entrySet())
		{
			String key=entry.getKey();
			String value=entry.getValue();
			headers+=key+": "+value+"\r\n";
		}
	return "HTTPRequest [ "+method+" "+url+" "+HttpVer+" ]\r\n"+headers;
	}}
/*Class HTTP Header, assist the HTTPResponse class and HTTPRequest Class*/
import java.util.*;
import java.io.*;
import java.text.*;
public class HTTPHeader
{
	String statusLine;
	List<String> hdr;
	static Map<String,String> mimeType;
	String CRLF="\r\n";
	public HTTPHeader(String statusCode,HTTPRequest request) throws IOException, Exception
	{
		statusLine=request.getHTTPVersion()+" "+statusCode+CRLF;
		hdr=new LinkedList<String>();
		Date d=new Date();
		DateFormat fmt=new SimpleDateFormat("EEE, dd MMM yyyy kk:mm:ss zzz");
		TimeZone tz=TimeZone.getTimeZone("GMT");
		fmt.setTimeZone(tz);
		setHeader("Date",fmt.format(d));
		// Setting Expire Header Field's Value
		d.setTime(d.getTime()+120*60*1000);
		setHeader("Expires",fmt.format(d));
Anshul,et al.	January 10, 2017	[Page	]
Internet-Draft	Knowledge Based Web Page	June55

		if(statusCode.startsWith("200"))
		{
			mimeType=new HashMap<String,String>();
			mimeType.put("html","text/html");
			mimeType.put("htm","text/htm");
			int i=request.getUrl().lastIndexOf('.');		/*This code is setting the content type of the response*/
			String ext=request.getUrl().substring(i+1);		
			ext=getMimeType(ext);
			if(ext!=null)
			setHeader("Content-Type",ext);
			setContentLength(request.getUrl());
			
		}
		if(statusCode.startsWith("200") || statusCode.startsWith("304"))
		{
			File f=new File(request.getUrl());
			if(f.exists())
			{
				d.setTime(f.lastModified());
				setHeader("Last-Modified",fmt.format(d));
			}
		}
		if(request.getHTTPVersion().equals("HTTP/1.1"))
		setHeader("Connection","keep-alive");
		else
		setHeader("Connection","close");
	}
	//Sending Daynamic pages using this constructor
	public HTTPHeader(String statusCode,String url,String method) throws Exception
	{
		statusLine="HTTP/1.1 "+statusCode+CRLF;
		hdr=new LinkedList<String>();
		mimeType=new HashMap<String,String>();
		mimeType.put("html","text/html");
		mimeType.put("htm","text/htm");
		Date d=new Date();
		DateFormat fmt=new SimpleDateFormat("EEE, dd MMM yyyy kk:mm:ss zzz");
		TimeZone tz=TimeZone.getTimeZone("GMT");
		fmt.setTimeZone(tz);
		setHeader("Date",fmt.format(d));
		if(method.equals("GET"))
		{
			setHeader("Cache-Control","must-revalidate");
		}
		setHeader("Content-Type",mimeType.get("html"));
		setHeader("Connection","keep-alive");
	}
Anshul,et al.		January 10, 2017			[Page	22]
Internet-Draft	Knowledge Based Web Page			July 2016

	public HTTPHeader(String statusLine) throws IOException, Exception
	{
		this.statusLine=statusLine;
	}
	public String getMimeType(String ext)
	{
		return mimeType.get(ext);
	}
	public String getStatusLine()
	{
		return statusLine;
	}
	public void setContentLength(String url) throws IOException, Exception
	{	
		File f;
		try{
			f=new File(url);
		}
		catch(Exception e)
		{
			f=new File("welcome.html");
		}
		hdr.add("Content-Length: "+f.length()+CRLF);
	}
	public void setHeader(String hdrName,String hdrValue)
	{
		hdr.add(hdrName+": "+hdrValue+CRLF);
	}
	public String getHeader()
	{
		Iterator itr=hdr.iterator();
		String hdrs="";
		while(itr.hasNext())
		{
			hdrs=hdrs+itr.next();
		}
		return hdrs;
	}}
Anshul,et al.		January 10, 2017			[Page	23]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class MsgBody, Read the message body of POST Method*/
public class MsgBody
{
	String str;
	int length;
	public MsgBody(String body, int length)
	{
		str=body;
		this.length=length;
	}
	public int getLength()
	{
		return length;
	}
	public String getParameter(String pName)
	{
		String temp;
		temp=str.substring(str.indexOf(pName)+pName.length()+1);
		int L=(str.indexOf(pName)+pName.length()+1);
		
		if(temp.indexOf("&")==-1)
		L=L+temp.length();
		if(L==length)
		{
			if(temp.length()!=0)
			{
				int idx=0;
				String result="";
				while(idx<temp.length())
				{
					if(temp.charAt(idx)=='+')
					result+=" ";
					else if(temp.charAt(idx)=='%')
					{
						idx+=3;
						result+="/";
					}
					else					
					result+=temp.charAt(idx);
					idx++;
				}
			temp=result;
			}
			return temp;
		}
Anshul,et al.		January 10, 2017			[Page	24]
Internet-Draft	Knowledge Based Web Page			July 2016

		else
		{
			temp=temp.substring(0,temp.indexOf("&"));
			if(temp.length()!=0)
			{
				int idx=0;
				String result="";
				while(idx<temp.length())
				{
					if(temp.charAt(idx)=='+')
					result+=" ";
					else if(temp.charAt(idx)=='%')
					{
						idx+=2;
						result+="/";
					}
					else	
					result+=temp.charAt(idx);
					idx++;
				}
			temp=result;
			}
			return temp;
		}
	}
}
Anshul,et al.		January 10, 2017			[Page	25]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class EmpRecord, Save an employee record into the database*/
import java.io.*;
public class EmpRecords extends MsgBody
{
	public String recFields[]={"Emp_FIRST_NAME","EMP_MIDDLE_NAME","EMP_LAST_NAME","EMP_DOB","EMP_GENDER","EMP_MOBILE_NO","EMP_APPOINT_ODR_NO","EMP_APPOINT_DIS_NO","EMP_APPOINT_DATE","EMP_JOIN","EMP_FILE_NO","EMP_POST","EMP_STATUS"};
	public String txtNames[]={"txtFName","txtMName","txtLName","txtDob","txtGender","txtMobile","txtOdrNo","txtDisNo","txtDate","txtDjoin","txtFileNo","txtPost","txtStatus"};
	public EmpRecords(String msgBody, String length)
	{
		super(msgBody,Integer.parseInt(length.substring(1)));
	}
	public String buildQuery()
	{
		String fields="(EMP_ID,";
		String data="('";
		int i=0;
		data+=getParameter("txtId")+"','";
		while(i<12)
		{
			if(getParameter(txtNames[i]).length()!=0)
			{
				data+=getParameter(txtNames[i])+"','";
				fields+=recFields[i]+",";
			}
			i++;
		}
		data+=getParameter(txtNames[12])+"')";
		fields+=recFields[12]+")";
		return "insert into Employee "+fields+" Values "+data;
	}}
Anshul,et al.		January 10, 2017			[Page	26]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class Emp Update, Update an employee record*/
import java.io.*;
public class EmpUpdate extends MsgBody
{
	public String recFields[]=
{"EMP_FIRST_NAME","EMP_MIDDLE_NAME","EMP_LAST_NAME","EMP_DOB","EMP_GENDER","EMP_MOBILE
_NO","EMP_APPOINT_ODR_NO","EMP_APPOINT_DIS_NO","EMP_APPOINT_DATE","EMP_JOIN","EMP_FILE_
NO","EMP_POST","EMP_STATUS"};
	public String txtNames[]=
{"txtFName","txtMName","txtLName","txtDob","txtGender","txtMobile","txtOdrNo","txtDisNo","txtDate","t
xtDjoin","txtFileNo","txtPost","txtStatus"};
	public EmpUpdate(String msgBody, String length)
	{
		super(msgBody,Integer.parseInt(length.substring(1)));
	}
	public String buildQuery()
	{
		String fields="";
		int i=0;
		
		while(i<13)
		{
			if(getParameter(txtNames[i]).length()!=0)
			{
				fields+=recFields[i]+"='"+getParameter(txtNames[i])+"',";
			}
			i++;
		}
		fields=fields.substring(0,fields.length()-1);
		return "UPDATE EMPLOYEE SET "+fields+" WHERE EMP_ID='"+getParameter
("txtId")+"'";
	}}
Anshul,et al.		January 10, 2017			[Page	27]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class View, perform a select query on the database*/
import java.io.*;
import java.util.*;
public class View extends MsgBody
{
	
	public View(String msgBody, String length)
	{
		super(msgBody,Integer.parseInt(length.substring(1)));
	}
	public String buildQuery()
	{
		String query;
		if(getParameter("cmbList").equals("ALL"))
		{
			query="SELECT * FROM EMPLOYEE";
		}
		else if(getParameter("cmbList").equals("EmpId"))
		{
			query="SELECT * FROM EMPLOYEE WHERE EMP_ID='"+getParameter("txtKey")+"'";	
		}
		else if(getParameter("cmbList").equals("Name"))
		{
			
query="SELECT * FROM EMPLOYEE WHERE EMP_FIRST_NAME LIKE '%"+getParameter("txtKey")+"%' or  EMP_MIDDLE_NAME like '%"+getParameter("txtKey")+"%' or EMP_LAST_NAME like '%"+getParameter("txtKey")+"%'";
		}
		else if(getParameter("cmbList").equals("FName"))
		{
			query="SELECT * FROM EMPLOYEE WHERE EMP_FIRST_NAME='"+getParameter("txtKey")+"'";
		}
		else if(getParameter("cmbList").equals("MName"))
		{
			query="SELECT * FROM EMPLOYEE WHERE EMP_MIDDLE_NAME='"+getParameter("txtKey")+"'";
		}
		else if(getParameter("cmbList").equals("LName"))
		{
			query="SELECT * FROM EMPLOYEE WHERE EMP_LAST_NAME='"+getParameter("txtKey")+"'";
		}
		else if(getParameter("cmbList").equals("Post"))
		{
			query="SELECT * FROM EMPLOYEE WHERE EMP_POST='"+getParameter("txtKey")+"'";
		}
		else
			query="SELECT * FROM EMPLOYEE WHERE EMP_STATUS='"+getParameter("txtKey")+"'";
		return query;	}}
Anshul,et al.		January 10, 2017			[Page	28]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class DBAccess, Handles the database connectivity to a specified database*/
import java.sql.*;
import java.util.*;
public class DBAccess
{
	boolean done;
	java.sql.Statement s;
	Connection conn;
	String database;
	public DBAccess()
	{
		 try
       		 {
            			Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            			database = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=JodhpurDiscom.mdb;";
            			conn = DriverManager.getConnection(database, "", "");
            			s = conn.createStatement();
			done=true;
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
			done=false;
		}
		if(!done)
		System.out.println("Connection to DB is not established");
	}
	public String executeQuery(String query)
	{
		try
		{
			s.execute(query);
			return "OK";
		}
		catch(Exception e)
		{
			return "Exception : "+e;
		}
	}
Anshul,et al.		January 10, 2017			[Page	29]
Internet-Draft	Knowledge Based Web Page			July 2016

	public HashMap<String,String> executeSearchQuery(String query) 
	{
		HashMap<String,String> rs=new HashMap<String,String>();
		try
		{
			ResultSet result=s.executeQuery(query);
			int total=1;
			int idx=1;
			String row="",temp="";
			String header="ID+FIRST_NAME+MIDDLE_NAME+LAST_NAME+DOB+GENDER+MOBILE_NO+APPOINT_ODR_NO+APPOINT_DIS_NO+APPOINT_DATE+JOIN_DATE+FILE_NO+POST+STATUS";
			while(result.next())
			{
				idx=1;
				row="";
				while(idx<15)
				{
					
						temp=result.getString(idx);
						if(temp!=null)
						{
							row+=temp+"+";
						}
						else
						row+="NotExist"+"+";
					
					idx++;
				}
				rs.put(""+total,row);
				total++;		
			}
			rs.put("0",header);
			total--;
			rs.put("Total",""+total);
			result.close();
			return rs;
		}
		catch(Exception e)
		{
			rs.put("Failed","-1");
			return rs;
		}
	}
	public String toString()
	{
		return "DBAccess ["+conn+" "+s+" "+database+" ]";
	}  
}
Anshul,et al.		January 10, 2017			[Page	30]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class Tag, defines Tag of the Grammer in section 4*/
public class Tag
{
	public static final int Num=256,ID=257,TEXT=258,DTEXT=259,WHILE=260,OPENBRAKET=261,CLOSEDBRAKET=262,SEMICOLON=263,OPENCURLYBRAKET=264,CLOSEDCURLYBRAKET=265,ISNEXTROW=266,ISNEXTCOLUMN=267, PRINT=268,EMPTYSTMT=269,UNKNOWN=270;
}
/*Class Token, defines Token of the Grammer in Section 4*/
public class Token
{
	public int tag;
	public Token(int t)
	{
		tag=t;
	}
	public String toString()
	{
		return ""+tag;
	}
}
/*Class HtmlString, define static part of page*/
public class HtmlString extends Token
{
	public String lexeme;
	public HtmlString(int tag, String str)
	{
		super(tag);
		lexeme=str;
	}
	public String toString()
	{
		return "String: "+lexeme;
	}
}
Anshul,et al.		January 10, 2017			[Page	31]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class Statement, define statements of grammer in section 4*/
public class Statement
{
	public Token token;
	private Statement nextStmt;
	public static Statement EmptyStmt=new Statement(new Token(Tag.EMPTYSTMT));
	public Statement(Token t)
	{
		token=t;
		nextStmt=null;
	}
	public Statement(Token t, Statement stmt)
	{
		token=t;
		nextStmt=stmt;
	}
	public void setNextStmt(Statement stmt)
	{
		nextStmt=stmt;
	}
	public Statement getNextStmt()
	{
		return nextStmt;
	}
	public Token getToken()
	{
		return token;
	}
}
/*Class Text, define Text Statements of grammer section 4*/
public class Text extends Statement
{
	private int length,offset,total;
	public Text(HtmlString html)
	{
		super(html);
		length=html.lexeme.length();
		offset=0;
		total=0;
	}
	public Text(HtmlString html,Statement stmt)
	{
		super(html,stmt);
		length=0;
		offset=0;
		total=0;
	}
Anshul,et al.		January 10, 2017			[Page	32]
Internet-Draft	Knowledge Based Web Page			July 2016

	public void setLength(int len)
	{
		length=len;
	}
	public void setOffset(int offset)
	{
		this.offset=offset;
	}
	public void setTotal()
	{
		total=length+offset;
	}
	public int getTotal()
	{
		return total;	
	}
}
/*Class OutputStatement, define Output Statements such as PRINT of grammer section 4*/
public class OutputStatement extends Statement
{
	private String lexeme;
	public OutputStatement(Word w,Statement stmt)
	{
		super(w,stmt);
		lexeme=w.lexeme;
	}
	public String getLexeme()
	{
		return lexeme;
	}
}
/*Class Word, define word of a lexeme for grammer in section 4*/
public class Word extends Token
{
	public final String lexeme;
	public Word(String lexeme, int t)
	{
		super(t);
		this.lexeme=lexeme;
	}
	public String toString()
	{
		return "Word [ Lexeme "+lexeme+" Tag "+super.toString()+" ]";
	}
}
Anshul,et al.		January 10, 2017			[Page	33]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class While, define while statements of grammer section 4*/
public class While extends Statement
{
	private Statement body;
	private int length,offset,total;
	private Condition con;
	
	public While(Word w)
	{
		super(w);
		length=0;
		offset=0;
		total=0;
	}
	public void setBody(Statement stmt)
	{
		body=stmt;
	}
	public void setNextStmt(Statement stmt)
	{
		super.setNextStmt(stmt);	
	}
	public void setCondition(Condition con)
	{
		this.con=con;
	}
	public void setLength(int len)
	{
		length=len;
	}
	public void setOffset(int offset)
	{
		this.offset=offset;
	}
	public void setTotal()
	{
		total=length+offset;
	}
	public int getTotal()
	{
		return total;
	}
	public Condition getCondition()
	{
		return con;
	}
	public Statement getBody()
	{
		return body;
	}
}
Anshul,et al.		January 10, 2017			[Page	34]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class DText, Define Dynamic data of a page*/
public class DText extends Statement
{
	private int length,offset,total;
	public DText(Word w)
	{
		super(w);
		length=0;
		offset=0;
		total=0;
	}
	public DText(Word w,Statement stmt)
	{
		super(w,stmt);
		length=0;
		offset=0;
		total=0;
	}
	public void setLength(int len)
	{
		length=len;
	}
	public void setOffset(int offset)
	{
		this.offset=offset;
	}
	public void setTotal()
	{
		total=length+offset;
	}
	public int getTotal()
	{
		return total;
	}
}
/*Class Condition, define Condition statement of grammer saction 4*/
public class Condition
{
	private Token token;
	public Condition(Word w)
	{
		token=(Token)w;
	}
	public boolean evaluate(Evaluator eval)
	{
		if(token.tag==Tag.ISNEXTROW)
		{
			return eval.isNextRow();
		}
		else
		{
			return eval.isNextColumn();
		}
	}
Anshul,et al.		January 10, 2017			[Page	35]
Internet-Draft	Knowledge Based Web Page			July 2016

	public Token getToken()
	{
		return token;
	}
}
/*Class Lexer, Define Lexical Analyzer of grammer section 4*/
import java.io.*;
import java.util.*;
public class Lexer
{
	public char peek=' ';
	public Map<String,Word> table;
	FileInputStream in;
	public Lexer(FileInputStream file) throws Exception
	{
		table=new HashMap<String, Word>();
		reserve(new Word("PRINT", Tag.PRINT));
		reserve(new Word("WHILE",Tag.WHILE));
		reserve(new Word("isNextRow",Tag.ISNEXTROW));
		reserve(new Word("isNextColumn",Tag.ISNEXTCOLUMN));
		reserve(new Word("getNextColumn",Tag.DTEXT));
		in=file;
	}
	public void reserve(Word w)
	{
		table.put(w.lexeme,w);
	}
	public Token scan() throws IOException
	{
		for(;peek==' ' || peek=='\t'|| peek=='\n'|| peek=='\r';peek=(char)in.read()){}
		
		if(peek=='"')
		{
			String text;
			StringBuffer buf=new StringBuffer();
			peek=(char)in.read();
			do
			{
				buf.append(peek);	
				peek=(char)in.read();
				if(peek=='\\')
				{
					peek=(char)in.read();
					buf.append(peek);
					peek=(char)in.read();
				}

			}while(peek!='"');
Anshul,et al.		January 10, 2017			[Page	36]
Internet-Draft	Knowledge Based Web Page			July 2016

			peek=' ';
			text=buf.toString();
			return new HtmlString(Tag.TEXT,text);
		}
		else if(Character.isLetter(peek))
		{
			StringBuffer buf=new StringBuffer();
			do
			{
				buf.append(peek);
				peek=(char)in.read();
			}while(Character.isLetterOrDigit(peek));

			String str=buf.toString();
			
			Word w=table.get(str);
			if(w!=null) return w;
			w=new Word(str,Tag.ID);
			table.put(str,w);
			return w;
		}
		else
		{
			Token t;
			if(peek=='(')
			{
				t=new Token(Tag.OPENBRAKET);
			}
			else if(peek==')')
			{
				t=new Token(Tag.CLOSEDBRAKET);
			}
			else if(peek=='{')
			{
				t=new Token(Tag.OPENCURLYBRAKET);
			}
			else if(peek=='}')
			{
				t=new Token(Tag.CLOSEDCURLYBRAKET);
			}
			else if(peek==';')
			{
				t=new Token(Tag.SEMICOLON);
			}
			else
			{
				t=new Token(Tag.UNKNOWN);	
			}
			peek=' ';
			return t;
		}
	}
}
Anshul,et al.		January 10, 2017			[Page	37]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class Parser, Define Predictive Parser for grammer in section 4*/
import java.io.*;
public class Parser
{
	private Token look;
	private Lexer lex;
	public Parser(String filename) throws Exception
	{
		lex=new Lexer(new FileInputStream(filename));
	}
	Statement Stmts() throws Exception
	{
		Statement stmt;
		look=move();
		switch(look.tag)
		{
			case Tag.PRINT:
				stmt=new OutputStatement((Word)look,rest());
			break;
			case Tag.WHILE:
				While loop=new While((Word)look);
				look=move();
				match(Tag.OPENBRAKET);
				
				look=move();
				Condition con=new Condition((Word)look);
				loop.setCondition(con);
				
				look=move();
				match(Tag.CLOSEDBRAKET);
				look=move();
				
				match(Tag.OPENCURLYBRAKET);
				loop.setBody(Stmts());
				//System.out.println(look.tag);
				match(Tag.CLOSEDCURLYBRAKET);
				
				loop.setNextStmt(Stmts());
				stmt=loop;
			break;
			default:
				stmt=Statement.EmptyStmt;
		}
		return stmt;
	}
Anshul,et al.		January 10, 2017			[Page	38]
Internet-Draft	Knowledge Based Web Page			July 2016

	Statement rest() throws Exception
	{
		Statement stmt;
		look=move();
		switch(look.tag)
		{
			case Tag.TEXT:
				stmt=new Text((HtmlString)look);
				look=move();
				match(Tag.SEMICOLON);
				stmt.setNextStmt(Stmts());
			break;
			case Tag.DTEXT:
				stmt=new DText((Word)look);
				look=move();
				match(Tag.SEMICOLON);
				stmt.setNextStmt(Stmts());
			break;
			default:
				System.out.println("Syntax Error at rest");
				stmt=null;
		}
		return stmt;
	}
	public void match(int tag)
	{
		if(look.tag!=tag)
		{
			System.out.println("Syntax Error "+look.tag+": "+tag);
			Word w=(Word)look;
			System.out.println(w.lexeme);
		}
	}
	public Token move() throws IOException
	{
		return lex.scan();
	}
	public static void printPrg(Statement stmt)
	{
		if(stmt!=null){
		if(stmt instanceof OutputStatement)
		{
			OutputStatement out=(OutputStatement)stmt;
			System.out.print(out.getLexeme());
		}
		else if(stmt instanceof Text)
		{
			Text text=(Text)stmt;
			HtmlString html=(HtmlString)text.getToken();
			System.out.println(html.lexeme+";");
		}
Anshul,et al.		January 10, 2017			[Page	39]
Internet-Draft	Knowledge Based Web Page			July 2016

		else if(stmt instanceof DText)
		{
			DText text=(DText)stmt;
			Word w=(Word)text.getToken();
			System.out.println(w.lexeme+";");
		}
		else if(stmt instanceof While)
		{
			While loop=(While)stmt;
			System.out.print("while ( ");
			Condition con=loop.getCondition();
			if(con!=null)
			{
				if(con.getToken().tag==Tag.ISNEXTROW)
				System.out.print("isNextRow ) {");
				else
				System.out.print("isNextColumn ) {");
			}
			else
			System.out.print("con null");

			printPrg(loop.getBody());
			System.out.println("}");
		}
		printPrg(stmt.getNextStmt());
		}
	}
	public void initEvaluator(String query,boolean full) 
	{
		try
		{
			Statement stmt=Stmts();
			Evaluator eval=new Evaluator(stmt,0,query,full);
			int len=eval.executeProgram();
			
		}
		catch(Exception e)		
		{
			System.out.println("Error in Evaluator "+e);
		}
	}
}
Anshul,et al.		January 10, 2017			[Page	40]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class Evaluator, Define a simple compiler for grammer in section 4
It produces html page along with Offset in output.eval file*/
import java.util.*;
import java.io.*;
public class Evaluator
{
	private int offset=0;
	private Statement stmts;
	private int length=0;
	private String query;
	private DBAccess db;
	private HashMap<String,String> rs;
	private int totalrow=0, currow=0;
	private StringTokenizer strToken;
	private String finalOffset="";
	private  boolean full;
	private String output;
	public Evaluator(Statement stmts, int offset,String qry,boolean bool)
	{
		this.offset=0;
		this.stmts=stmts;	
		length=0;
		full=bool;
		output=new String();
		query=qry;
		db=new DBAccess();
		rs=db.executeSearchQuery(query);
		currow=0;
		totalrow=Integer.parseInt(rs.get("Total"));
	}
	public int executeProgram()
	{
		length=Evaluate(stmts,offset,full);
finalOffset=finalOffset.substring(0,finalOffset.lastIndexOf(','))+"\r\n\r\n";
		try{
			FileOutputStream fout=new FileOutputStream("Pages/Result.html");
			byte header[]=("Content-Length: "+output.length()+"\r\nOffset: "+finalOffset).getBytes();
			fout.write(header);

			fout.write(output.getBytes());
			fout.close();
		}
		catch(Exception e)
		{
			System.out.println("Erro During writing output of Evaluator "+e);
		}
	return length;
	}
Anshul,et al.		January 10, 2017			[Page	41]
Internet-Draft	Knowledge Based Web Page			July 2016

	private int Evaluate(Statement stmts, int offset,boolean full)
	{
		int tempResult=0;
		switch(stmts.token.tag)
		{
			case Tag.PRINT:
				OutputStatement out=(OutputStatement)stmts;
				Statement st=out.getNextStmt();
				if(st.token.tag==Tag.TEXT)
				{
					Text text=(Text)st;
					text.setOffset(offset);
					HtmlString html=(HtmlString)text.token;
					text.setLength(html.lexeme.length());
					text.setTotal();
					if(full)
					output+=html.lexeme;
		tempResult= Evaluate(st.getNextStmt(),text.getTotal(),full);
				}
				else 
				{
					String str=getNextColum();
					DText text=(DText)st;
					text.setLength(str.length());
					text.setOffset(offset);
					text.setTotal();
					output+=str;
					finalOffset+=offset+"-"+str.length()+",";
					tempResult=Evaluate(st.getNextStmt(),text.getTotal(),full);
				}
			break;
			case Tag.WHILE:
				String tempFinalOffset=finalOffset;
				int OFFSET=offset;
				int tempOffset=offset;
				While wl=(While)stmts;
				Condition con=wl.getCondition();
				Statement body=wl.getBody();
				wl.setOffset(offset);
				wl.setTotal();
				while(con.evaluate(this))
				{
					offset=Evaluate(body,wl.getTotal(),true);
					wl.setLength(0);
					wl.setOffset(offset);
					wl.setTotal();
				}
		finalOffset=tempFinalOffset+OFFSET+"-"+(offset-tempOffset)+",";
		tempResult=Evaluate(stmts.getNextStmt(),wl.getTotal(),full);
			break;
			case Tag.EMPTYSTMT:
			tempResult=offset;
		}
Anshul,et al.		January 10, 2017			[Page	42]
Internet-Draft	Knowledge Based Web Page			July 2016


Proxy Server Code:
/*Class ProxyServer, Define Caching Proxy Server*/
import java.util.*;
import java.net.*;
import java.io.*;
public class ProxyServer
{
	public static void main(String arg[])
	{
		ServerSocket requests;
		Socket connection; 
		Runnable r;
		Thread t;
		
		try
		{
			requests=new ServerSocket(80);
			while(true)
			{
				connection=requests.accept();
				r=new HTTPProtocol(connection);
				t=new Thread(r);
				t.setDaemon(true);
				t.start();
			}
		}
catch(Exception E)
		{
			System.out.print("Error: "+E);
		}
	}
}
Anshul,et al.		January 10, 2017			[Page	43]
Internet-Draft	Knowledge Based Web Page			July 2016

Proxy Server Code:
/*Class ProxyServer, Define Caching Proxy Server*/
import java.util.*;
import java.net.*;
import java.io.*;
public class ProxyServer
{
	public static void main(String arg[])
	{
		ServerSocket requests;
		Socket connection; 
		Runnable r;
		Thread t;
		
		try
		{
			requests=new ServerSocket(80);
			while(true)
			{
				connection=requests.accept();
				r=new HTTPProtocol(connection);
				t=new Thread(r);
				t.setDaemon(true);
				t.start();
			}
		}
		catch(Exception E)
		{
			System.out.print("Error: "+E);
		}
	}
}
Anshul,et al.		January 10, 2017			[Page	44]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class HTTPProtocol, HTTP protocol for Proxy Server with 
Dynamic page caching facility*/
import java.util.*;
import java.net.*;
import java.io.*;
import java.text.*;

public class HTTPProtocol implements Runnable
{
	Socket con,serCon;
	InputStream in,serIn;
	OutputStream out,serOut;
	BufferedInputStream inStream,serInStream;
	PrintWriter serOutStream,clientOut;

	HTTPRequest request;
	int ch=-1;
	public HTTPProtocol(Socket con) throws IOException,Exception
	{
		this.con=con;
		in=con.getInputStream();
		out=con.getOutputStream();
		clientOut=new PrintWriter(out,true);
		inStream=new BufferedInputStream(in);
		inStream.mark(25);

	}
	public void run()
	{
		try
		{
			try
			{
				while((ch=inStream.read())!=-1) //This loop ensure persistent Connection with client
				{
					inStream.reset();
					request=new HTTPRequest(inStream);
					if(request.getMethod().equals("POST"))
					{
/* If request is made by POST method then the response would not be cached until it is specified in this case proxy behaves like a tunnel that means do not make any changes in either request or response*/
						serCon=new Socket("127.0.0.1",81);
						serIn=serCon.getInputStream();
						serOut=serCon.getOutputStream();
					serInStream=new BufferedInputStream(serIn);
					serOutStream=new PrintWriter(serOut,true);
Anshul,et al.		January 10, 2017			[Page	45]
Internet-Draft	Knowledge Based Web Page			July 2016
				serOutStream.write(request.getRequestHeader());
						serOutStream.flush();
				HTTPResponse response=new HTTPResponse(serInStream);
						response.send(clientOut);
					}
					else
					{
File cacheEntry=new File("Cache/"+request.getHeaderValueByName("Host")+"/"+request.getUrl()+"/"+getFileName(request.getUrl()));
						if(cacheEntry.exists())
						{
				Scanner readCacheEntry=new Scanner(cacheEntry);
							if(readCacheEntry.hasNext())
							{
								System.out.println("\nLooking cache entry");
					String line=readCacheEntry.nextLine();
								while(!(line.startsWith("Expires")) && !(line.endsWith("must-revalidate")) && readCacheEntry.hasNext())
	line=readCacheEntry.nextLine();
if(line.startsWith("Expires"))
		{
		String strDate=line.substring(line.indexOf(':')+2);
		TimeZone tz=TimeZone.getTimeZone("GMT");
SimpleDateFormat sdf=new SimpleDateFormat("EEE, dd MMM yyyy kk:mm:ss zzz");
		sdf.setTimeZone(tz);
		Date expireDate=sdf.parse(strDate);
		System.out.println("Expiry date : "+strDate);
		Date now=new Date();
		String curTime=sdf.format(now);
		now=sdf.parse(curTime);
		System.out.println("cur date : "+curTime);
		if(now.before(expireDate))
		{
		/*Cache entry is valid send output from cache*/
		System.out.println("\nCache Entry Valid");	

HTTPResponse response=new HTTPResponse(new FileInputStream(cacheEntry));
		response.send(clientOut);
		}
Anshul,et al.		January 10, 2017			[Page	46]
Internet-Draft	Knowledge Based Web Page			July 2016

		else
		{
		/*if Cache entry is stale*/
		System.out.println("\nCache Entry Stale");	
		serCon=new Socket("127.0.0.1",81);
		serIn=serCon.getInputStream();
		serOut=serCon.getOutputStream();
		serInStream=new BufferedInputStream(serIn);
		serOutStream=new PrintWriter(serOut,true);
										while(!(line.startsWith("Last-Modified")) && readCacheEntry.hasNext())
										line=readCacheEntry.nextLine();
	String lastDate=line.substring(line.indexOf(':')+2);
	serOutStream.write(request.conditionalGetRequest(lastDate));
										serOutStream.flush();
	HTTPResponse response=new HTTPResponse(serInStream);
	if(response.getStatusCode().equals("304"))
	{
	System.out.println("\nUpdating Cache Entry");
	String replaceBy=response.getHeaderByName("Expires");
	Scanner scan=new Scanner(cacheEntry);
	String curLine;
	int skip=0;
	while(!( (curLine=scan.nextLine()).startsWith("Expires:") ))
	{
	skip=skip+curLine.length()+2;
	}
	RandomAccessFile updateEntry=new RandomAccessFile(cacheEntry,"rw");
	updateEntry.seek(skip);
	updateEntry.write(replaceBy.getBytes());
	response.send(clientOut,cacheEntry);
	scan.close();
	updateEntry.close();
	}
	else
	{
	/*Override on stale entry i.e. 200 OK return*/
	System.out.println("\nOverride Previous Entry");	
	response.sendAndSave(clientOut,cacheEntry);
	}}}
	else if(line.endsWith("must-revalidate"))
	{	
	serCon=new Socket("127.0.0.1",81);
	serIn=serCon.getInputStream();
	serOut=serCon.getOutputStream();
	serInStream=new BufferedInputStream(serIn);
	serOutStream=new PrintWriter(serOut,true);
	serOutStream.write(setContentStatusHeader(request.getRequestHeader()));
Anshul,et al.		January 10, 2017			[Page	47]
Internet-Draft	Knowledge Based Web Page			July 2016

	serOutStream.flush();
	//Reading WebServer Response
	HTTPResponse response=new HTTPResponse(serInStream);
	/*Here the code of dynamic updating cache will be add*/
	UpdateDynamicCacheFiles udcf=new UpdateDynamicCacheFiles(cacheEntry,response);
	udcf.buildPage();
	response.sendAndSave(clientOut,cacheEntry,udcf.toString());
	}}
	else
	{
	/*if there is any error during reading cache entry*/
	serCon=new Socket("127.0.0.1",81);
	serIn=serCon.getInputStream();
	serOut=serCon.getOutputStream();
	serInStream=new BufferedInputStream(serIn);
	serOutStream=new PrintWriter(serOut,true);
	serOutStream.write(request.getRequestHeader());
	serOutStream.flush();
	HTTPResponse response=new HTTPResponse(serInStream);
	response.sendAndSave(clientOut,cacheEntry);
	}}
	else
	{
	/*if cache entry does not exists*/
	System.out.println("\nCache Entry not Exists");
	serCon=new Socket("127.0.0.1",81);
	serIn=serCon.getInputStream();
	serOut=serCon.getOutputStream();
	serInStream=new BufferedInputStream(serIn);
	serOutStream=new PrintWriter(serOut,true);
	serOutStream.write(request.getRequestHeader());
	serOutStream.flush();
	HTTPResponse response=new HTTPResponse(serInStream);
	response.sendAndSave(clientOut,cacheEntry);
	}}
	inStream.mark(10);
	}}
	finally
	{
	con.close();
	serCon.close();
	}}
	catch(Exception  pe)	
	{
	System.out.println("Error at Proxy Server :"+pe);
	}}
Anshul,et al.		January 10, 2017			[Page	48]
Internet-Draft	Knowledge Based Web Page			July 2016

	public String getFileName(String path)
	{
		// Pages/xxx.html
		int i=path.lastIndexOf('/');
		if(i!=-1)
		return path.substring(i+1);
		else
		return path;
	}
	public String setContentStatusHeader(String str)
	{
		StringBuffer buff=new StringBuffer();
		int i=0;
		while(str.charAt(i)!='\r')
		{
			buff.append(str.charAt(i));
			i++;
		}
		i+=2;
		buff.append("\r\n");
		buff.append("Content-Status: Data\r\n");
		int len=str.length();
		while(i<len)
		{
			if(str.charAt(i)=='\r')
			{
				buff.append("\r\n");
				i+=2;
				break;
			}

			while(str.charAt(i)!='\r')
			{
				buff.append(str.charAt(i));
				i++;
			}
			buff.append("\r\n");
			i+=2;
		}
		while(i<len)
		{
			
			System.out.print(str.charAt(i));
			buff.append(str.charAt(i));
			i++;
			
		}
		return buff.toString();
	}}
Anshul,et al.		January 10, 2017			[Page	49]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class HTTPRequest, reading request at proxy server */
import java.util.*;
import java.io.*;
public class HTTPRequest
{
	String method;
	String url;
	String HttpVer;
	String mBody;
	String queryString="";
	BufferedInputStream input;
	Map<String,String> headerList;
	public HTTPRequest(BufferedInputStream in) 
	{
		queryString=null;
		mBody="";
		try
		{
			input=in;
			headerList=new HashMap<String,String>();
		
			method=readRequestLine();
			url=readRequestLine();
			setQueryString(url);
			HttpVer=readRequestLine();
			String header="",value="";
			
			while(!((header=getHeader()).equals("\r\n")))
			{
				value=getHeaderValue();
				if(!(header.equals("If-Modified-Since")))
				{
					headerList.put(header,value);
				}
				
				
			}
			String temp="";
			if((temp=headerList.get("Content-Length"))!=null)
			{
				mBody=readMessageBody(Integer.parseInt(temp.substring(1)));
				
						
			}
		}
		catch(Exception e)
		{
			System.out.println("Error in HttpRequest Class "+e);
		}
Anshul,et al.		January 10, 2017			[Page	50]
Internet-Draft	Knowledge Based Web Page			July 2016

	}
	public String getHeaderValueByName(String name)
	{
		return headerList.get(name).substring(1);	
	}
	public String getRequestHeader()
	{
		String header=method+" "+url;
		header=header+" "+HttpVer+"\r\n";
		for(Map.Entry<String,String> entry : headerList.entrySet())
		{
			header=header+entry.getKey()+":"+entry.getValue()+"\r\n";
		}
		header=header+"\r\n";
		String temp="";
		if((temp=headerList.get("Content-Length"))!=null)
		{
			header+=getMessageBody();
		}
		return header;
	}
	public String conditionalGetRequest(String lastModifiedDate)
	{
		String header=method+" "+url;
		header=header+" "+HttpVer+"\r\n";
		for(Map.Entry<String,String> entry : headerList.entrySet())
		{
			header=header+entry.getKey()+":"+entry.getValue()+"\r\n";
		}
		header+="If-Modified-Since: "+lastModifiedDate+"\r\n";
		header=header+"\r\n";
		String temp="";
		if((temp=headerList.get("Content-Length"))!=null)
		{
			header+=getMessageBody();
		}
		return header;	
	}
	public void setQueryString(String query)
	{
		if(query.indexOf('?')!=-1)
		queryString=query.substring(query.indexOf('?')+1);	
	}
Anshul,et al.		January 10, 2017			[Page	51]
Internet-Draft	Knowledge Based Web Page			July 2016

	public String getQueryString()
	{
		return queryString;
	}
	public String readMessageBody(int mLength) throws IOException, Exception
	{
		String body="";
		char ch;
		while(mLength>0)
		{
			ch=(char)input.read();
			body=body+ch;
			mLength--;
		}
		return body;
	}
	public String getHeaderValue() throws Exception, Exception
	{
		String token=new String();
		char ch;
		String CRLF="\r\n";
		ch=(char)input.read();
		while(ch!='\n')
		{
			if(ch!='\r')
			{
				token=token+ch;
			}
			ch=(char)input.read();
		}
		return token;
	}
	public String getHeader() throws IOException, Exception
	{
		String token=new String();
		char ch;
		String CRLF="\r\n";
		ch=(char)input.read();
		while((ch!=':') && (ch!='\n'))
		{
			if(ch!='\r')
			{
				token=token+ch;
			}
			else if(token.length()==0)
			{
				token=CRLF;
			}
			ch=(char)input.read();
		}
Anshul,et al.		January 10, 2017			[Page	52]
Internet-Draft	Knowledge Based Web Page			July 2016

		return token;
	}
	public String readRequestLine() throws IOException, Exception
	{
		String token=new String();
		char ch;
		String CRLF="\r\n";
		ch=(char)input.read();
		while((ch!=' ') && (ch!='\n'))
		{
			if(ch!='\r')
			{
				token=token+ch;	
			}
			else if(token.length()==0)
			{
				token=CRLF;
			}
			ch=(char)input.read();	
		}
		return token;
	}
	public String getMethod()
	{
		return method;
	}
	public String getUrl()
	{
		String url="";
		url=this.url;
		if(url.equals("/"))
		return "welcome.html";
		else
		{
			if(url.startsWith("/"))
			{
				if(url.indexOf('?')==-1)
				{
					int i=url.indexOf('/');
					url=url.substring(i+1);
				}
				else
				{
					url=url.substring(1,url.indexOf('?'));
				}
			}
			
			return url;
		}

	}
Anshul,et al.		January 10, 2017			[Page	53]
Internet-Draft	Knowledge Based Web Page			July 2016

	public String getHTTPVersion()
	{
		return HttpVer;
	}
	public String getMessageBody()
	{
		return mBody;
	}
	public String getContentLength()
	{	
		return headerList.get("Content-Length");
	}
	public String toString()
	{
		return "HTTPRequest [ "+method+" "+url+" "+HttpVer+" ] ";
	}
}
/*Class HTTPResponse, Provide method for response messages at proxy server*/
import java.io.*;
import java.util.*;
/*This class read the server response from serInStream
and direct the output to the client*/
public class HTTPResponse
{
	BufferedInputStream serResponse;
	String response;
	String HttpVer,StatusCode,Phrase;
	int length;
	String headerList; //holds the header part of the response
	public HTTPResponse(InputStream in)throws IOException, Exception
	{
		serResponse=new BufferedInputStream(in);
		length=0;
		response=readResponseMsg()+"\r\n";
		
		Scanner scan=new Scanner(response);
		HttpVer=scan.next();
		StatusCode=scan.next();
		Phrase=scan.nextLine();
		
		String header="";
		while(!( (header=readResponseMsg()).equals("\r\n")))
		{
			if(header.startsWith("Content-Length"))
			{
				int i=header.indexOf(':');
				String temp=header.substring(i+2);
				length=Integer.parseInt(temp);
			}
			response=response+header+"\r\n";
		}
Anshul,et al.		January 10, 2017			[Page	54]
Internet-Draft	Knowledge Based Web Page			July 2016

		response+=header;

		headerList=response;

		if(length!=0)
		{
			response+=readMsgBody();
		}
	}
	public String readResponseMsg() throws IOException, Exception
	{
		String token="",CRLF="\r\n";
		char ch;
		while((ch=(char)serResponse.read())!='\n')
		{
			if(ch!='\r')
			{
				token=token+ch;
			}
			else if(token.length()==0)
			{
				token=CRLF;
			}
		}
		return token;
	}
	public String readMsgBody() throws IOException, Exception
	{
		String mBody="";
		char ch;
		while(length>0)
		{
			ch=(char)serResponse.read();
			mBody=mBody+ch;
			length--;
		}
		return mBody;
	}
	public String readMsgBody(String response) throws IOException, Exception
	{
		String mBody="",temp="";
		Scanner scan=new Scanner(response);
		while(scan.hasNext())
		{
			temp=scan.nextLine();
			if(temp.length()==0)
			break;
		}
Anshul,et al.		January 10, 2017			[Page	55]
Internet-Draft	Knowledge Based Web Page			July 2016

		while(scan.hasNext())
		mBody+=scan.nextLine();
		return mBody;	
	}
	public void send(PrintWriter out)throws IOException,Exception
	{
		int idx=response.indexOf("Expires");
		if(idx!=-1)
		{
			String output=response.substring(0,idx);
			out.write(output);
			out.write("Cache-Control: no-cache\r\n");
			//System.out.print(output);
			output=response.substring(response.indexOf("Expires"));
			output=output.substring(output.indexOf("\r\n")+2);
			out.write(output);
			//System.out.print(output);
		}
		else
		out.write(response);
		out.flush();		
	}
	public void send(PrintWriter out, File file)throws IOException,Exception
	{
		Scanner scan=new Scanner(file);
		String line;
		while(scan.hasNext())
		{
			line=scan.nextLine()+"\r\n";
			if(line.startsWith("Expires"))	
			line="Cache-Control: no-cache\r\n";
			out.write(line);
			out.flush();
		}
		scan.close();
		out.flush();
		
	}
	public void sendAndSave(PrintWriter out,File file)throws Exception
	{
		if(file.exists())
		{
			PrintWriter cache=new PrintWriter(new FileOutputStream(file));
			cache.write(response);
			cache.flush();
		}
Anshul,et al.		January 10, 2017			[Page	56]
Internet-Draft	Knowledge Based Web Page			July 2016

		else if((new File(file.getParent())).mkdirs())
		{
			PrintWriter cache=new PrintWriter(new FileOutputStream(file));
			cache.write(response);
			cache.flush();
		}
		else
		System.out.println("Failed to make cahche entry");

		int idx=response.indexOf("Expires");
		if(idx!=-1)
		{
			String output=response.substring(0,idx);
			out.write(output);
			out.write("Cache-Control: no-cache\r\n");
			//System.out.print(output);
			output=response.substring(response.indexOf("Expires"));
			output=output.substring(output.indexOf("\r\n")+2);
			out.write(output);
			System.out.print(output);
		}
		else
		out.write(response);
		out.flush();	
	}
	public void sendAndSave(PrintWriter out,File file,String page)throws Exception
	{
		if(file.exists())
		{
			FileWriter cache=new FileWriter(file);
			cache.write(page);
			cache.flush();
		}
		else if((new File(file.getParent())).mkdirs())
		{
			FileWriter cache=new FileWriter(file);
			cache.write(page);
			cache.flush();
		}
		else
		System.out.println("Failed to make cahche entry");
Anshul,et al.		January 10, 2017			[Page	57]
Internet-Draft	Knowledge Based Web Page			July 2016

		int idx=response.indexOf("Expires");
		if(idx!=-1)
		{
			String output=response.substring(0,idx);
			out.write(output);
			out.write("Cache-Control: no-cache\r\n");
			//System.out.print(output);
			output=response.substring(response.indexOf("Expires"));
			output=output.substring(output.indexOf("\r\n")+2);
			out.write(output);
			System.out.print(output);
		}
		else
		out.write(response);
		out.flush();	
	}
	public String getHeaderByName(String aName)
	{
		String temp=response;
		temp=temp.substring(temp.indexOf(aName));
		temp=temp.substring(0,temp.indexOf("\r\n"));
		return temp;
	}
	public String getHeaderList()
	{
		return headerList;
	}
	public String getHttpVersion()
	{
		return HttpVer;
	}
	public String getStatusCode()
	{
		return StatusCode;
	}
	public String getPhrase()
	{
		return Phrase;
	}
	public void printServer()
	{
		System.out.println("Get response from server\n"+response);
	}
	public String toString()
	{
		return response;
	}
}
Anshul,et al.		January 10, 2017			[Page	58]
Internet-Draft	Knowledge Based Web Page			July 2016

/*Class UpdateDynamicCacheFiles, provide algorithm which build the fresh copy page with dynamic data from response and static  data from cache*/
import java.io.*;
import java.util.*;
class UpdateDynamicCacheFiles
{
	
	HTTPResponse response,PreResponse;
	String freashCopy,cachedPage,responsePage;
	String cpOffset,rpOffset;
	public UpdateDynamicCacheFiles(File cacheEntry, HTTPResponse res) throws Exception
	{
		//Response of older request
		PreResponse=new HTTPResponse(new FileInputStream(cacheEntry));
		
		//Response of current request
		response=res;
		rpOffset=response.getHeaderByName("Offset");
		cpOffset=PreResponse.getHeaderByName("Offset");
		rpOffset=rpOffset.substring(8);
		cpOffset=cpOffset.substring(8);
		cachedPage=PreResponse.readMsgBody(PreResponse.toString());
		responsePage=response.readMsgBody(response.toString());
			
	}
	public void buildPage()
	{
		StringTokenizer stcpOffset=new StringTokenizer(cpOffset,"-,");
		StringTokenizer strpOffset=new StringTokenizer(rpOffset,"-,");
		
		String freashCopy="",temp;	
		int initIdx=0,fIdx=0,cpCL=0,rpfIdx=0;
		
		while(stcpOffset.hasMoreTokens())
		{
			if(initIdx==0)
			{
				fIdx=Integer.parseInt(stcpOffset.nextToken());
				temp=strpOffset.nextToken();
				freashCopy=cachedPage.substring(initIdx,fIdx);
				cpCL=fIdx;
				fIdx=Integer.parseInt(strpOffset.nextToken());
				freashCopy+=responsePage.substring(initIdx,fIdx);
				rpfIdx=fIdx;
				cpCL+=Integer.parseInt(stcpOffset.nextToken());
				initIdx=cpCL;
							
			}
Anshul,et al.		January 10, 2017			[Page	59]
Internet-Draft	Knowledge Based Web Page			July 2016

			else
			{
				fIdx=Integer.parseInt(stcpOffset.nextToken());
				
				freashCopy=freashCopy+cachedPage.substring(initIdx,fIdx);
				
				
				cpCL=fIdx;
				temp=strpOffset.nextToken();
				fIdx=Integer.parseInt(strpOffset.nextToken());
				freashCopy+=responsePage.substring(rpfIdx,rpfIdx+fIdx);	
				rpfIdx=rpfIdx+fIdx;
				if(stcpOffset.hasMoreTokens())
				cpCL+=Integer.parseInt(stcpOffset.nextToken());
				initIdx=cpCL;
				
			}
			
		}
		freashCopy+=cachedPage.substring(initIdx);
		System.out.println("New Page\n"+freashCopy);
	}
	public String toString()
	{
		return freashCopy;
	}
}
Anshul,et al.		January 10, 2017			[Page	60]
Internet-Draft	Knowledge Based Web Page			July 2016

File-Name: welcome.html Path WebServer/Welcome.html
<html>
<head>
<title>Welcome</title>
</head>
<body bgcolor="gray">
<center>
<h1>Welcome</center>
<BR>
<center>
<h3><a href="/Pages/Save.html">Entry Form</a>
<h3><a href="/Pages/Update.html">Update Form</a>
<h3><a href="/Pages/Search.html">View Form</a>
</body></html>
File-Name: Save.html Path WebServer/Pages/Save.html
<html>
<head>
<center><h1>Employee's Details</center>
<title>
Save Form
</title>
</head>
<body bgcolor="gray">

<center><form name="Save" action="/EmpRecords" method="post" >
<div align="right" style="margin-right: 700px; width=100%">
Employee ID : <input type="text" name="txtId"><br>
First Name : <input type="text" name="txtFName"><br>
Middle Name : <input type="text" name="txtMName"><br>
Last Name : <input type="text" name="txtLName"><br>
Date of Birth : <input type="text" name="txtDob"><br>
Gender : <input type="text" name="txtGender"><br>
Mobile No : <input type="text" name="txtMobile"><br>
<br>
<B>Appointment Order</B> <br>
Order No. : <input type="text" name="txtOdrNo"><br>
Dispatch No. : <input type="text" name="txtDisNo"><br>
Date : <input type="text" name="txtDate"><br>
<br>
Date of Joining : <input type="text" name="txtDjoin"></Label><br>
File No. : <input type="text" name="txtFileNo"><br>
Post : <input type="text" name="txtPost"><br>
Status : <input type="text" name="txtStatus"><br>
<a href="/Welcome.html">Home Page</a>
<input type="Submit" value="Save">
</div>
</form>
</center>
</body>
</html>
Anshul,et al.		January 10, 2017			[Page	61]
Internet-Draft	Knowledge Based Web Page			July 2016

File-Name: Update.html Path WebServer/Pages/Update.html
<html>
<head>
<center><h1>Update Records</center>
<title>
Updation Form
</title>
</head>
<body bgcolor="gray">

<center><form name="Update" action="/EmpUpdate" method="post">
<div align="right" style="margin-right: 700px; widh=100%">
Employee ID : <input type="text" name="txtId"><br>
First Name : <input type="text" name="txtFName"><br>
Middle Name : <input type="text" name="txtMName"><br>
Last Name : <input type="text" name="txtLName"><br>
Date of Birth : <input type="text" name="txtDob"><br>
Gender : <input type="text" name="txtGender"><br>
Mobile No : <input type="text" name="txtMobile"><br>
<br>
<B>Appointment Order</B> <br>
Order No. : <input type="text" name="txtOdrNo"><br>
Dispatch No. : <input type="text" name="txtDisNo"><br>
Date : <input type="text" name="txtDate"><br>
<br>
Date of Joining : <input type="text" name="txtDjoin"></Label><br>
File No. : <input type="text" name="txtFileNo"><br>
Post : <input type="text" name="txtPost"><br>
Status : <input type="text" name="txtStatus"><br>
<a href="/Welcome.html">Home Page</a>
<input type="Submit" value="Update">
</div>
</form>
</center>
</body>
</html>
Anshul,et al.		January 10, 2017			[Page	62]
Internet-Draft	Knowledge Based Web Page			July 2016

File-Name: Search.html Path WebServer/Pages/Search.html
<html>
<head><title>
Search Record
</title></head>
<body bgcolor="Gray" topmargin="200">
<center><h1>Query Form</h1></center>

<form name="SelectText" action="/View.java" method="GET">
<div align="right" style="margin-right: 700px; width=100%">
<B>Criteria : <select name="cmbList">
<option value="ALL">All Records</option>
<option value="EmpId">Emp ID</option>
<option value="Name">Name</option>
<option value="FName">First Name</option>
<option value="MName">Middle Name</option>
<option value="LName">Last Name</option>
<option value="Post">Post</option>
<option value="SName">Status</option>
</select>
<br>
Key : <input type="text" name="txtKey"><br>
<input type="Submit" value="View">
</div>
</form>
</body>
</html>
6.	Difference between Delta Encoding and Knowledge Based Web 
Pages
In Delta Encoding, server needs a copy of the previous reply 
in order to generate the delta but in this algorithm server can
generates delta on demand without help of previous reply[4].

7.	The Version Number of HTTP Protocol
This Draft requests to increase HTTP <Major>.<Minor> version 
numbers by one [2].
8.	Security Considerations
The Security Considerations of this draft is same as described
in the RFC 2616 for HTTP/1.1.[1]

Anshul,et al.		January 10, 2017			[Page	63]
Internet-Draft	Knowledge Based Web Page			July 2016

9.	References
[1] Fielding,R., Gettys,J., Mogul, J.C., Frystyk, H., Masinter,
L.,Leach,P. and T. Berners-Lee Hypertext Transfer Protocol-
HTTP/1.1,RFC 2616, June 1999.
[2] Mogul, J.C., ] Fielding,R., Gettys,J. and H. Frystyk Use 
and Interpretation of HTTP Version Numbers, RFC 2145, May 1997.
[3] Berners-Lee,T., Fielding, R. and H. Frystyk 
Hypertext Markupkup Language-2.0, RFC 1866, November 1995.
[4] Mogul, J.C., Krishnamurthy, B., Douglis,F., Feldmann, A.,
Goland,Y., Hoff man, A. and D. Hellerstein Delta Encoding in 
HTTP, RFC 3229, January 2002.
[5] Forouzan, B.A., Data Communications and Networking, ISBN-
13: 978-0-07-049935-5 Second Edition update, Tata McGraw-Hill 
Edition 2003.
[6] Horstmann, C.S., and G. Cornell Core Java Volume-1 
Fundamentals Eighth Edidtin, ISBN: 978-81-317-1945-9
[7] Horstmann, C.S., and G. Cornell Core Java Volume-2 Advanced
Features Eighth Edition, ISBN: 978-0-13-235479-0
[8] Hall,M. and L. Brown Core Servlets and Java Server Pages 
Volume-1: Core Technologies Second Edition, ISBN: 978-81-317-063-8
[9] D. Wessels Web Caching, ISBN1-56592-596-X
[10] Aho, A.V., Lam. S.M., Sethi, R. and J.D. Ullman Compilers
Principles, Techniques and Tools Second Edition, ISBN: 978-81-317-2101-8

10. Author's Address
	 Anshul Pareek
	 Plot No. 138, Nehru Nagar,
	 Near B.R. Public School,
	 Jodhpur-342001

	 E-Mail: pareek.anshul@yahoo.com 
Anshul,et al.		January 10, 2017			[Page	64]
Internet-Draft	Knowledge Based Web Page			July 2016