# 1 "httpd.c"



 






































 






 

































 

# 1 "globals.h"








typedef unsigned long  int u32;
typedef unsigned short int u16;
typedef unsigned      char  u8;






                                    

                                    


                                        

                                    









extern _Bool STACK_BUSY;

extern u16 temp_cgi; 		

# 87 "httpd.c"
# 1 "uip.h"



 










 


































 




# 1 "uipopt.h"









 










 

































 





 



 






 
typedef unsigned char u8_t;






 
typedef unsigned short u16_t;






 
typedef unsigned short uip_stats_t;

 

 













 









 













 


# 146 "uipopt.h"

# 159 "uipopt.h"

# 172 "uipopt.h"









 






								

 

								

 

								

 

								

 

								

 

 
 




 




 














 






 


 

 








 





 









 






 






 


 
 



 










 










 








 










 










 






 







 








 






 







  



 
 



 








 







 


 

 




 









 









 










 







 
void uip_log(char *msg);









 



 
 









 
# 493 "uipopt.h"








 




 
 































 







 






 
 



 




# 57 "uip.h"
# 1 "httpd.h"



 





 

































 




void httpd_init(void);
void httpd_appcall(void);



 




struct httpd_state {
  u8 state; 
  u16 count;
  char *dataptr;
  char *script;
};



 






extern struct httpd_state *hs;

# 58 "uip.h"
# 1 "uip_arp.h"



 




 
 




 
  

































 




# 1 "uip.h"



 










 


































 

# 1071 "uip.h"


 

# 56 "uip_arp.h"





 
struct uip_eth_addr {
  u8 addr[6];
};

extern struct uip_eth_addr uip_ethaddr;



 
struct uip_eth_hdr {
  struct uip_eth_addr dest;
  struct uip_eth_addr src;
  u16_t type;
};








 
void uip_arp_init(void);





 
void uip_arp_ipin(void);






 
void uip_arp_arpin(void);










 
void uip_arp_out(void);


 
void uip_arp_timer(void);

 




 








 










 











 










 



















 
# 193 "uip_arp.h"

 




 
extern const u16_t uip_arp_draddr[2], uip_arp_netmask[2];









# 59 "uip.h"


 



 







 











 














 



 






 






 
void uip_init(void);

 







 


















































 











































 














 



# 297 "uip.h"






















 
extern u8 uip_buf[1600+2];

 

 



 





 












 
void uip_listen(u16 port);












 
void uip_unlisten(u16 port);

































 
struct uip_conn *uip_connect(u16 *ripaddr, u16 port);











 


























 










 










 








 










 









 







 










 






 









 










 











 









 









 









 











 













  







 












 












 
struct uip_udp_conn *uip_udp_new(u16 *ripaddr, u16 rport);







 












 


 

 







 
 



















 













 
# 715 "uip.h"







 

u16 htons(u16 val);


 







 

extern volatile u8 *uip_appdata;

extern volatile unsigned int uip_appdata_length; 


extern volatile u8 *uip_sappdata; 







 
extern volatile u8 *uip_urgdata; 











 
extern volatile u16 uip_len, uip_slen;


extern volatile u8 uip_urglen, uip_surglen;












 
struct uip_conn {
  u16 ripaddr[2];    
  
  u16 lport;         
  u16 rport;        
   
  
  u8 rcv_nxt[4];    
 
  u8 snd_nxt[4];    
 
  u16 len;           
  u16 mss;          
 
  u16 initialmss;   
   
  u8 sa;            
 
  u8 sv;            
 
  u8 rto;            
  u8 tcpstateflags;  
  u8 timer;          
  u8 nrtx;          
 

   
  u8 appstate[(sizeof(struct httpd_state))];  
};


 
extern struct uip_conn *uip_conn;
 
extern struct uip_conn uip_conns[10];



 



 
extern volatile u8 uip_acc32[4];

 


# 842 "uip.h"





 
struct uip_stats {
  struct {
    uip_stats_t drop;     
 
    uip_stats_t recv;     
 
    uip_stats_t sent;     
 
    uip_stats_t vhlerr;   
 
    uip_stats_t hblenerr; 
 
    uip_stats_t lblenerr; 
 
    uip_stats_t fragerr;  
 
    uip_stats_t chkerr;   
 
    uip_stats_t protoerr; 
 
  } ip;                    
  struct {
    uip_stats_t drop;      
    uip_stats_t recv;      
    uip_stats_t sent;      
    uip_stats_t typeerr;  
 
  } icmp;                  
  struct {
    uip_stats_t drop;      
    uip_stats_t recv;      
    uip_stats_t sent;      
    uip_stats_t chkerr;   
 
    uip_stats_t ackerr;   
 
    uip_stats_t rst;       
    uip_stats_t rexmit;    
    uip_stats_t syndrop;  
 
    uip_stats_t synrst;   
 
  } tcp;                   
};





 
extern struct uip_stats uip_stat;


 


 
 





 
extern volatile u8 uip_flags;





 

# 945 "uip.h"








 
void uip_process(u8 flag);





 

# 971 "uip.h"

 
# 983 "uip.h"
  




 
typedef struct {
   
  u8 vhl,
    tos,          
    len[2],       
    ipid[2],        
    ipoffset[2],  
    ttl,          
    proto;     
  u16 ipchksum;
  u16 srcipaddr[2], 
    destipaddr[2];
  
   
  u16 srcport,
    destport;
  u8 seqno[4],  
    ackno[4],
    tcpoffset,
    flags,
    wnd[2];     
  u16 tcpchksum;
  u8 urgp[2];
  u8 optdata[4];
} uip_tcpip_hdr;

 
typedef struct {
   
  u8 vhl,
    tos,          
    len[2],       
    ipid[2],        
    ipoffset[2],  
    ttl,          
    proto;     
  u16 ipchksum;
  u16 srcipaddr[2], 
    destipaddr[2];
   
  u8 type, icode;
  u16 icmpchksum;
  u16 id, seqno;  
} uip_icmpip_hdr;


 
typedef struct {
   
  u8 vhl,
    tos,          
    len[2],       
    ipid[2],        
    ipoffset[2],  
    ttl,          
    proto;     
  u16 ipchksum;
  u16 srcipaddr[2], 
    destipaddr[2];
  
   
  u16 srcport,
    destport;
  u16 udplen;
  u16 udpchksum;
} uip_udpip_hdr;






extern const u16 uip_hostaddr[2];











 

# 88 "httpd.c"
# 1 "fs.h"



 





 
 

































 







 
struct fs_file {
  char *data;   
  int len;      
};








 
int fs_open(const char *name, struct fs_file *file);



u16_t fs_count(char *name);





 
void fs_init(void);

# 90 "httpd.c"
# 1 "fsdata.h"

































 







struct fsdata_file {
   const struct fsdata_file *next; 
   const char *name;				
   const char *data;					
   const int len;						


  u16_t count;


};

struct fsdata_file_noconst {
  struct fsdata_file *next;
  char *name;
  char *data;
  int len;


  u16_t count;


};




extern const struct fsdata_file file_cgi_stats[];
extern const struct fsdata_file file_cgi_tcp[];
extern const struct fsdata_file file_img_bg_png[];
extern const struct fsdata_file file_about_html[];
extern const struct fsdata_file file_control_html[];
extern const struct fsdata_file file_404_html[];


extern const struct fsdata_file file_media_html[];
extern const struct fsdata_file file_index_html[];
extern const struct fsdata_file file_stats_footer_plain[];
extern const struct fsdata_file file_stats_header_html[];
extern const struct fsdata_file file_tcp_footer_plain[];
extern const struct fsdata_file file_tcp_header_html[];


# 91 "httpd.c"
# 1 "cgi.h"



 





 

































 




typedef u8_t (* cgifunction)(u8_t next);




 
extern cgifunction cgitab[];

# 92 "httpd.c"



 









# 113 "httpd.c"

struct httpd_state *hs;




static void next_scriptline(void);
static void next_scriptstate(void);

# 136 "httpd.c"


 




 
 
void
httpd_init(void)
{
  fs_init();
  
   
  uip_listen(((((u16)((80) & 0xff)) << 8) | (((80) & 0xff00) >> 8)));
}
 
void
httpd_appcall(void)
{
  struct fs_file fsfile; 
  char temp=0; 

  u32 i;

  	if(temp_cgi ==1){			
		temp_cgi=66;};
  
  switch(uip_conn->lport) {
     
  case ((((u16)((80) & 0xff)) << 8) | (((80) & 0xff00) >> 8)):
     
    hs = (struct httpd_state *)(uip_conn->appstate);

    





 
    if((uip_flags & 64)) {
      




 
      hs->state = 0;
      hs->count = 0;
      return;

    } else if((uip_flags & 8)) {
      

 
      if(hs->count++ >= 10) {
	(uip_flags = 32);
      }
      return;
    } else if((uip_flags & 2) && hs->state == 0) {
      
 
      
       
      if(uip_appdata[0] != 0x47 ||
	 	 uip_appdata[1] != 0x45 ||
	 	 uip_appdata[2] != 0x54 ||
	 	 uip_appdata[3] != 0x20) {
	 
	(uip_flags = 32);
	return;
      }
	       
       
      for(i = 4; i < 40; ++i) {
		if(uip_appdata[i] == 0x20 ||
	   	   uip_appdata[i] == 0x0d ||
	   	   uip_appdata[i] == 0x0a) {
	  	   	uip_appdata[i] = 0;
	  		break;
		}
      }

      ;
      ;
      
       
      if(uip_appdata[4] == 0x2f &&
	 uip_appdata[5] == 0) {

	fs_open(file_index_html->name, &fsfile);    
 
      } else {
	if(!fs_open((const char *)&uip_appdata[4], &fsfile)) {
	  ;

  	  fs_open(file_404_html->name, &fsfile);

	}
      } 


      if(uip_appdata[4] == 0x2f &&
	 	 uip_appdata[5] == 0x63 &&
	 	 uip_appdata[6] == 0x67 &&
		 uip_appdata[7] == 0x69 &&
		 uip_appdata[8] == 0x2f) {
	
 	
	hs->script = fsfile.data;
	next_scriptstate();
	temp++;
      } else {  
	hs->script = (void *)0;
	

 
	hs->state = 1;

	
 
	hs->dataptr = fsfile.data;
	hs->count = fsfile.len;	
      }     
    }

    
    if(hs->state != 3) {
      


 
   if((uip_flags & 1)) {
	if(hs->count >= uip_conn->len) {
	  hs->count -= uip_conn->len;
	  hs->dataptr += uip_conn->len;
	} else {
	  hs->count = 0;
	}
	
	if(hs->count == 0) {
	  if(hs->script != (void *)0) {
	    next_scriptline();
	    next_scriptstate();
	  } else { (uip_flags = 16); }
	}
      }         
    } else {
       
      if(cgitab[hs->script[2] - 0x61]((uip_flags & 1))) {
	
 
	next_scriptline();
	next_scriptstate();
      }
    }

    if(hs->state != 3 && !(uip_flags & 8)) {
      
  
  	  do { uip_sappdata = ((volatile u8_t *)hs->dataptr); uip_slen = (hs->count);} while(0);
    }

    
 
   return;

  default:
     
    (uip_flags = 32);
    break;
  }  
}
 


 
static void
next_scriptline(void)
{
   
  do {
    ++(hs->script);
  } while(hs->script[0] != 0x0a);

   
  ++(hs->script);
}
 



 
static void
next_scriptstate(void)
{
  struct fs_file fsfile;
  u8_t i;
 again:
  switch(hs->script[0]) {
  case 0x74:
     
    hs->state = 2;
    hs->dataptr = &hs->script[2];

     
    for(i = 0; hs->dataptr[i] != 0x0a; ++i);
    hs->count = i;    
    break;
  case 0x63:
     
    hs->state = 3;
    hs->dataptr = (void *)0;
    hs->count = 0;
    cgitab[hs->script[2] - 0x61](0);
    break;
  case 0x69:   
     
    hs->state = 1;
    if(!fs_open(&hs->script[2], &fsfile)) {
      (uip_flags = 32);
    }
    hs->dataptr = fsfile.data;
    hs->count = fsfile.len;
    break;
  case 0x23:
     
    next_scriptline();
    goto again;

  case 0x2e:
     
    hs->state = 4;
    (uip_flags = 16);
    break;
  default:
    (uip_flags = 32);
    break;
  }
}