[netwatch.git] / net / http / fs.c

/*
 * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, with or without modification, 
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission. 
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
 * OF SUCH DAMAGE.
 *
 * This file is part of the lwIP TCP/IP stack.
 * 
 * Author: Adam Dunkels <adam@sics.se>
 *
 */
#include "lwip/def.h"
#include "fs.h"
#include "fsdata.h"
#include "fsdata.c"
#include <io.h>
#include <minilib.h>
#include <paging.h>
#include <demap.h>
#include <output.h>
#include <state.h>

static char http_output_buffer[1280];

/*-----------------------------------------------------------------------------------*/

void handle_regs(struct fs_file *file)
{
  int i;
  int len;

  len = snprintf(http_output_buffer, sizeof(http_output_buffer), "<html><pre>");

  for (i = 0; i < state_num_regs(); i++) {
    len += state_dump_reg(http_output_buffer + len, sizeof(http_output_buffer) - len, i);
  }

  file->len = len;
  file->data = http_output_buffer;
}

#define LEFT (sizeof(http_output_buffer) - len)

void handle_backtrace(struct fs_file *file)
{
  int i = 10;
  int len;
  void *pebp, *peip;
  uint64_t bp, next;

  int longmode = (get_operating_mode() == LONG_64BIT);

  char * buf = http_output_buffer;
  
  strcpy(buf, "<html><head><title>Backtrace</title></head><body><tt><pre>");
  len = strlen(buf);

  bp = state_get_reg(longmode ? STATE_REG_RIP : STATE_REG_EIP);

  if (longmode)
    len += snprintf(buf + len, LEFT, "0x%08x%08x, from\n", (uint32_t)(bp >> 32), (uint32_t)bp);
  else
    len += snprintf(buf + len, LEFT, "0x%08x, from\n", (uint32_t)bp);
  
  bp = state_get_reg(longmode ? STATE_REG_RBP : STATE_REG_EBP);
  

  outputf("Backtrace:");
  while ((peip = demap(bp+(longmode?8:4))) != 0x0 && i--)
  {
    if (longmode) {
      uint64_t rip;
      rip = *(uint64_t *)peip;
      len += snprintf(buf + len, LEFT, "0x%08x%08x, from\n", (uint32_t)(rip >> 32), (uint32_t)rip);
    } else {
      len += snprintf(buf + len, LEFT, "0x%08x, from\n", *(uint32_t *)peip);
    }
    outputf("   EIP: %08x", *(uint32_t *)peip);

    pebp = demap(bp);
    if (!pebp || (bp & 3))
    {
      len += snprintf(buf + len, LEFT, "&lt;unreadable frame&gt;\n");
      break;
    }
    outputf("   *EBP: %08x", *(uint32_t *)pebp);

    if (longmode)
      next = *(uint64_t *)pebp;
    else
      next = *(uint32_t *)pebp;

    if (bp >= next && next)
    {
      len += snprintf(buf + len, LEFT, "&lt;recursive frame&gt;\n");
      break;
    }

    bp = next;
  }

  if (i == -1)
    len += snprintf(buf + len, LEFT, "...\n");
  else if (bp && !peip)
    len += snprintf(buf + len, LEFT, "&lt;unreadable fp @ %08x&gt;\n", (uint32_t) bp);
  else
    len += snprintf(buf + len, LEFT, "&lt;root&gt;");

  len += snprintf(buf + len, LEFT, "</pre></tt></body></html>");
  
  file->data = buf;
  file->len = len;
}

void handle_reboot(struct fs_file *file)
{
  outb(0xCF9, 0x4);
  file->data = "So long!";
  file->len = 8;
}


/*-----------------------------------------------------------------------------------*/
int
fs_open(const char *name, struct fs_file *file)
{
  const struct fsdata_file *f;
  
  /* /registers.html is CGI */
  if (!strcmp(name, "/registers.html"))
  {
    handle_regs(file);
    return 1;
  }
  if (!strcmp(name, "/backtrace.html"))
  {
    handle_backtrace(file);
    return 1;
  }
  if (!strcmp(name, "/reboot"))
  {
    handle_reboot(file);
    return 1;
  }

  for(f = FS_ROOT;
      f != NULL;
      f = f->next) {
    if (!strcmp(name, (const char*)f->name)) {
      file->data = f->data;
      file->len = f->len-1;
      return 1;
    }
  }
  file->data = "You clown...";
  file->len = 9;
  return 0;
}
/*-----------------------------------------------------------------------------------*/
Commit	Line	Data
6f9272bd JW	1	/*
	2	* Copyright (c) 2001-2003 Swedish Institute of Computer Science.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without modification,
	6	* are permitted provided that the following conditions are met:
	7	*
	8	* 1. Redistributions of source code must retain the above copyright notice,
	9	* this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright notice,
	11	* this list of conditions and the following disclaimer in the documentation
	12	* and/or other materials provided with the distribution.
	13	* 3. The name of the author may not be used to endorse or promote products
	14	* derived from this software without specific prior written permission.
	15	*
	16	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	17	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	18	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
	19	* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	20	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
	21	* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	22	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	23	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	24	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
	25	* OF SUCH DAMAGE.
	26	*
	27	* This file is part of the lwIP TCP/IP stack.
	28	*
	29	* Author: Adam Dunkels <adam@sics.se>
	30	*
	31	*/
	32	#include "lwip/def.h"
	33	#include "fs.h"
	34	#include "fsdata.h"
	35	#include "fsdata.c"
923ea2c2	36	#include <io.h>
9343e933 JW	37	#include <minilib.h>
9343e933 JW	38	#include <paging.h>
4e3ef36b	39	#include <demap.h>
9343e933	40	#include <output.h>
4e3ef36b	41	#include <state.h>
6f9272bd	42
4e3ef36b	43	static char http_output_buffer[1280];
db9fad13	44
6f9272bd JW	45	/-----------------------------------------------------------------------------------/
6f9272bd JW	46
923ea2c2	47	void handle_regs(struct fs_file *file)
6f9272bd	48	{
4e3ef36b JW	49	int i;
	50	int len;
	51
	52	len = snprintf(http_output_buffer, sizeof(http_output_buffer), "<html><pre>");
	53
8e7d9af0	54	for (i = 0; i < state_num_regs(); i++) {
4e3ef36b JW	55	len += state_dump_reg(http_output_buffer + len, sizeof(http_output_buffer) - len, i);
	56	}
	57
	58	file->len = len;
db9fad13	59	file->data = http_output_buffer;
923ea2c2 JW	60	}
923ea2c2 JW	61
db9fad13 JAW	62	#define LEFT (sizeof(http_output_buffer) - len)
db9fad13 JAW	63
9343e933 JW	64	void handle_backtrace(struct fs_file *file)
9343e933 JW	65	{
9343e933	66	int i = 10;
db9fad13	67	int len;
4e3ef36b JW	68	void pebp, peip;
	69	uint64_t bp, next;
	70
	71	int longmode = (get_operating_mode() == LONG_64BIT);
db9fad13 JAW	72
db9fad13 JAW	73	char * buf = http_output_buffer;
9343e933 JW	74
9343e933 JW	75	strcpy(buf, "<html><head><title>Backtrace</title></head><body><tt><pre>");
db9fad13	76	len = strlen(buf);
4e3ef36b	77
8e7d9af0	78	bp = state_get_reg(longmode ? STATE_REG_RIP : STATE_REG_EIP);
4e3ef36b JW	79
	80	if (longmode)
	81	len += snprintf(buf + len, LEFT, "0x%08x%08x, from\n", (uint32_t)(bp >> 32), (uint32_t)bp);
	82	else
	83	len += snprintf(buf + len, LEFT, "0x%08x, from\n", (uint32_t)bp);
9343e933	84
8e7d9af0	85	bp = state_get_reg(longmode ? STATE_REG_RBP : STATE_REG_EBP);
9343e933	86
8e7d9af0 JW	87
8e7d9af0 JW	88	outputf("Backtrace:");
4e3ef36b	89	while ((peip = demap(bp+(longmode?8:4))) != 0x0 && i--)
9343e933	90	{
4e3ef36b	91	if (longmode) {
8e7d9af0 JW	92	uint64_t rip;
	93	rip = (uint64_t )peip;
	94	len += snprintf(buf + len, LEFT, "0x%08x%08x, from\n", (uint32_t)(rip >> 32), (uint32_t)rip);
4e3ef36b	95	} else {
8e7d9af0	96	len += snprintf(buf + len, LEFT, "0x%08x, from\n", (uint32_t )peip);
4e3ef36b	97	}
8e7d9af0	98	outputf(" EIP: %08x", (uint32_t )peip);
4e3ef36b JW	99
4e3ef36b JW	100	pebp = demap(bp);
8e7d9af0	101	if (!pebp \|\| (bp & 3))
9343e933	102	{
4e3ef36b	103	len += snprintf(buf + len, LEFT, "<unreadable frame>\n");
9343e933 JW	104	break;
9343e933 JW	105	}
8e7d9af0	106	outputf(" EBP: %08x", (uint32_t *)pebp);
4e3ef36b JW	107
	108	if (longmode)
	109	next = (uint64_t )pebp;
	110	else
	111	next = (uint32_t )pebp;
	112
	113	if (bp >= next && next)
9343e933	114	{
4e3ef36b	115	len += snprintf(buf + len, LEFT, "<recursive frame>\n");
9343e933 JW	116	break;
9343e933 JW	117	}
4e3ef36b JW	118
4e3ef36b JW	119	bp = next;
9343e933	120	}
db9fad13	121
9343e933	122	if (i == -1)
db9fad13	123	len += snprintf(buf + len, LEFT, "...\n");
8e7d9af0 JW	124	else if (bp && !peip)
8e7d9af0 JW	125	len += snprintf(buf + len, LEFT, "<unreadable fp @ %08x>\n", (uint32_t) bp);
9343e933	126	else
db9fad13 JAW	127	len += snprintf(buf + len, LEFT, "<root>");
	128
	129	len += snprintf(buf + len, LEFT, "</pre></tt></body></html>");
9343e933 JW	130
9343e933 JW	131	file->data = buf;
db9fad13	132	file->len = len;
9343e933 JW	133	}
9343e933 JW	134
923ea2c2 JW	135	void handle_reboot(struct fs_file *file)
	136	{
	137	outb(0xCF9, 0x4);
	138	file->data = "So long!";
	139	file->len = 8;
6f9272bd JW	140	}
	141
	142
	143	/-----------------------------------------------------------------------------------/
	144	int
	145	fs_open(const char name, struct fs_file file)
	146	{
	147	const struct fsdata_file *f;
	148
	149	/* /registers.html is CGI */
	150	if (!strcmp(name, "/registers.html"))
	151	{
923ea2c2 JW	152	handle_regs(file);
	153	return 1;
	154	}
9343e933 JW	155	if (!strcmp(name, "/backtrace.html"))
	156	{
	157	handle_backtrace(file);
	158	return 1;
	159	}
923ea2c2 JW	160	if (!strcmp(name, "/reboot"))
	161	{
	162	handle_reboot(file);
6f9272bd JW	163	return 1;
	164	}
	165
	166	for(f = FS_ROOT;
	167	f != NULL;
	168	f = f->next) {
	169	if (!strcmp(name, (const char*)f->name)) {
	170	file->data = f->data;
923ea2c2	171	file->len = f->len-1;
6f9272bd JW	172	return 1;
	173	}
	174	}
	175	file->data = "You clown...";
	176	file->len = 9;
	177	return 0;
	178	}
	179	/-----------------------------------------------------------------------------------/