[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 < NUM_REGISTERS; 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(STATE_REG_RIP);

  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(STATE_REG_RBP);
  
  /* I never thought I'd do this again. */
  while ((peip = demap(bp+(longmode?8:4))) != 0x0 && i--)
  {
    if (longmode) {
      next = *(uint64_t *)peip;
      len += snprintf(buf + len, LEFT, "0x%08x%08x, from\n", (uint32_t)(next >> 32), (uint32_t)next);
    } else {
      next = *(uint32_t *)peip;
      len += snprintf(buf + len, LEFT, "0x%08x, from\n", (uint32_t)next);
    }

    pebp = demap(bp);

    if (!pebp)
    {
      len += snprintf(buf + len, LEFT, "&lt;unreadable frame&gt;\n");
      break;
    }

    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
    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
	54	for (i = 0; i < NUM_REGISTERS; i++) {
	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 JW	77
	78	bp = state_get_reg(STATE_REG_RIP);
	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
4e3ef36b	85	bp = state_get_reg(STATE_REG_RBP);
9343e933 JW	86
9343e933 JW	87	/* I never thought I'd do this again. */
4e3ef36b	88	while ((peip = demap(bp+(longmode?8:4))) != 0x0 && i--)
9343e933	89	{
4e3ef36b JW	90	if (longmode) {
	91	next = (uint64_t )peip;
	92	len += snprintf(buf + len, LEFT, "0x%08x%08x, from\n", (uint32_t)(next >> 32), (uint32_t)next);
	93	} else {
	94	next = (uint32_t )peip;
	95	len += snprintf(buf + len, LEFT, "0x%08x, from\n", (uint32_t)next);
	96	}
	97
	98	pebp = demap(bp);
db9fad13	99
9343e933 JW	100	if (!pebp)
9343e933 JW	101	{
4e3ef36b	102	len += snprintf(buf + len, LEFT, "<unreadable frame>\n");
9343e933 JW	103	break;
9343e933 JW	104	}
4e3ef36b JW	105
	106	if (longmode)
	107	next = (uint64_t )pebp;
	108	else
	109	next = (uint32_t )pebp;
	110
	111	if (bp >= next && next)
9343e933	112	{
4e3ef36b	113	len += snprintf(buf + len, LEFT, "<recursive frame>\n");
9343e933 JW	114	break;
9343e933 JW	115	}
4e3ef36b JW	116
4e3ef36b JW	117	bp = next;
9343e933	118	}
db9fad13	119
9343e933	120	if (i == -1)
db9fad13	121	len += snprintf(buf + len, LEFT, "...\n");
9343e933	122	else
db9fad13 JAW	123	len += snprintf(buf + len, LEFT, "<root>");
	124
	125	len += snprintf(buf + len, LEFT, "</pre></tt></body></html>");
9343e933 JW	126
9343e933 JW	127	file->data = buf;
db9fad13	128	file->len = len;
9343e933 JW	129	}
9343e933 JW	130
923ea2c2 JW	131	void handle_reboot(struct fs_file *file)
	132	{
	133	outb(0xCF9, 0x4);
	134	file->data = "So long!";
	135	file->len = 8;
6f9272bd JW	136	}
	137
	138
	139	/-----------------------------------------------------------------------------------/
	140	int
	141	fs_open(const char name, struct fs_file file)
	142	{
	143	const struct fsdata_file *f;
	144
	145	/* /registers.html is CGI */
	146	if (!strcmp(name, "/registers.html"))
	147	{
923ea2c2 JW	148	handle_regs(file);
	149	return 1;
	150	}
9343e933 JW	151	if (!strcmp(name, "/backtrace.html"))
	152	{
	153	handle_backtrace(file);
	154	return 1;
	155	}
923ea2c2 JW	156	if (!strcmp(name, "/reboot"))
	157	{
	158	handle_reboot(file);
6f9272bd JW	159	return 1;
	160	}
	161
	162	for(f = FS_ROOT;
	163	f != NULL;
	164	f = f->next) {
	165	if (!strcmp(name, (const char*)f->name)) {
	166	file->data = f->data;
923ea2c2	167	file->len = f->len-1;
6f9272bd JW	168	return 1;
	169	}
	170	}
	171	file->data = "You clown...";
	172	file->len = 9;
	173	return 0;
	174	}
	175	/-----------------------------------------------------------------------------------/