blacklight/Snort_AIPreproc
1
0
Fork 0
mirror of https://github.com/BlackLight/Snort_AIPreproc.git synced 2024-11-24 04:35:11 +01:00
Code Issues Projects Releases Packages Wiki Activity

Improving the embedded web server

Browse source
This commit is contained in:
BlackLight 2010-10-08 14:43:33 +02:00
parent 8305581fa2
commit 6a5815f2ee
12 changed files with 1661 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
TODO
View file

@ -3,6 +3,7 @@ AVERAGE/HIGH PRIORITY:
======================
- Web interface
- Function names (private functions with _ or __ ?)
- Bayesian network
- Modules for correlation coefficients
- Code profiling

73
correlation.c
View file

@ -73,7 +73,7 @@ _AI_correlation_table_cleanup ()
*/
PRIVATE void
_AI_print_correlated_alerts ( AI_alert_correlation *corr, FILE *fp )
_AI_correlated_alerts_to_dot ( AI_alert_correlation *corr, FILE *fp )
{
char src_addr1[INET_ADDRSTRLEN],
dst_addr1[INET_ADDRSTRLEN],
@ -130,8 +130,65 @@ _AI_print_correlated_alerts ( AI_alert_correlation *corr, FILE *fp )
timestamp2,
corr->key.b->grouped_alerts_count
);
} /* ----- end of function _AI_correlation_flow_to_file ----- */
} /* ----- end of function _AI_correlated_alerts_to_dot ----- */
/**
* \brief Recursively write the flow of correlated alerts to a .json file, ready for being rendered in the web interface
*/
PRIVATE void
_AI_correlated_alerts_to_json ()
{
unsigned int i = 0;
char json_file[1040] = { 0 };
FILE *fp;
AI_snort_alert *alert_iterator = NULL;
/* If there is no directory configured for the web interface, just exit */
if ( strlen ( config->webserv_dir ) == 0 )
return;
snprintf ( json_file, sizeof ( json_file ), "%s/correlation_graph.json", config->webserv_dir );
if ( !( fp = fopen ( json_file, "w" )))
{
AI_fatal_err ( "Unable to write on correlated_graph.json in htdocs directory", __FILE__, __LINE__ );
}
fprintf ( fp, "[\n" );
for ( alert_iterator = alerts; alert_iterator; alert_iterator = alert_iterator->next )
{
fprintf ( fp, "{\n"
"\t\"id\": %lu,\n"
"\t\"label\": \"%s\"",
alert_iterator->alert_id, alert_iterator->desc );
for ( i=0; i < alert_iterator->n_derived_alerts; i++ )
{
if ( i == 0 )
{
fprintf ( fp, ",\n\t\"connectedTo\": [\n" );
}
fprintf ( fp, "\t\t{ \"id\": %lu }%s\n",
alert_iterator->derived_alerts[i]->alert_id,
((i < alert_iterator->n_derived_alerts - 1) ? "," : ""));
if ( i == alert_iterator->n_derived_alerts - 1 )
{
fprintf ( fp, "\t]" );
}
}
fprintf ( fp, "\n}%s\n",
(alert_iterator->next ? "," : ""));
}
fprintf ( fp, "]\n" );
fclose ( fp );
chmod ( json_file, 0644 );
} /* ----- end of function _AI_correlated_alerts_to_json ----- */
/**
* \brief Get the name of the function called by a pre-condition or post-condition predicate
@ -848,7 +905,7 @@ AI_alert_correlation_thread ( void *arg )
corr->key.a->derived_alerts[ corr->key.a->n_derived_alerts - 1 ] = corr->key.b;
corr->key.b->parent_alerts [ corr->key.b->n_parent_alerts - 1 ] = corr->key.a;
_AI_print_correlated_alerts ( corr, fp );
_AI_correlated_alerts_to_dot ( corr, fp );
if ( config->outdbtype != outdb_none )
{
@ -889,6 +946,16 @@ AI_alert_correlation_thread ( void *arg )
agclose ( g );
fclose ( fp );
#endif
/* If no database output is defined, then the alerts have no alert_id, so we cannot use the
* web interface for correlating them, as they have no unique identifier */
if ( config->outdbtype != outdb_none )
{
if ( strlen ( config->webserv_dir ) != 0 )
{
_AI_correlated_alerts_to_json ();
}
}
}
pthread_mutex_unlock ( &mutex );

11
htdocs/graph.json Normal file
View file

@ -0,0 +1,11 @@
[{
"id": 1,
"label": "test1",
"connectedTo": [
{ "id": 2 }
]
}, {
"id": 2,
"label": "test2"
}]

85
htdocs/index.html Normal file
View file

@ -0,0 +1,85 @@
<html>
<head>
<script type="text/javascript" src="js/raphael-min.js"></script>
<script type="text/javascript" src="js/dracula_graffle.js"></script>
<script type="text/javascript" src="js/dracula_graph.js"></script>
<script type="text/javascript">
<!--
var redraw;
var width;
var height;
var layouter = null;
var renderer = null;
var json = [];
window.onload = function() {
var req = new XMLHttpRequest();
if ( navigator.appName.indexOf('Microsoft') != -1 )
{
width = (document.body.offsetWidth > 50) ?
document.body.offsetWidth - 50 : 50;
height = (document.body.offsetHeight > 50 ) ?
document.body.offsetHeight - 50 : 50;
} else {
width = (window.innerWidth > 50) ?
window.innerWidth - 50 : 50;
height = (window.innerHeight > 50) ?
window.innerHeight- 50 : 50;
}
req.open ( 'GET', 'http://localhost:7654/correlation_graph.json', true );
req.onreadystatechange = function() {
if ( req.readyState == 4 && req.status == 200 )
{
var g = new Graph();
var connections = [];
json = JSON.parse ( req.responseText );
for ( var i=0; i < json.length; i++ )
{
g.addNode ( json[i].id, { label: json[i].label });
if ( json[i].connectedTo )
{
for ( var j=0; j < json[i].connectedTo.length; j++ )
{
connections.push ({
"from": json[i].id,
"to" : json[i].connectedTo[j].id
});
}
}
}
for ( var i=0; i < connections.length; i++ )
{
g.addEdge ( connections[i].from, connections[i].to, { directed: true });
}
var layouter = new Graph.Layout.Spring ( g );
layouter.layout();
var renderer = new Graph.Renderer.Raphael ( 'canvas', g, width, height );
renderer.draw();
redraw = function() {
layouter.layout();
renderer.draw();
};
}
};
req.send ( null );
};
-->
</script>
</head>
<body>
<div id="canvas" style="border: 1px"></div>
<button id="redraw" onclick="redraw();">redraw</button>
</body>
</html>

29
htdocs/js/Curry-1.0.1.js Normal file
View file

@ -0,0 +1,29 @@
/**
* Curry - Function currying
* Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
* Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
* Date: 10/4/2008
*
* @author Ariel Flesler
* @version 1.0.1
*/
function curry( fn ){
return function(){
var args = curry.args(arguments),
master = arguments.callee,
self = this;
return args.length >= fn.length ? fn.apply(self,args) : function(){
return master.apply( self, args.concat(curry.args(arguments)) );
};
};
};
curry.args = function( args ){
return Array.prototype.slice.call(args);
};
Function.prototype.curry = function(){
return curry(this);
};

414
htdocs/js/dracula_algorithms.js Normal file
View file

@ -0,0 +1,414 @@
/*
* Various algorithms and data structures, licensed under the MIT-license.
* (c) 2010 by Johann Philipp Strathausen <strathausen@gmail.com>
* http://strathausen.eu
*
*/
/*
Path-finding algorithm Bellman-Ford
finds the shortest paths from one node to all nodes
- runs in O( |E| · |V| ), where E = edges and V = vertices (nodes)
- can run on graphs with negative edge weights as long as they do not have
any negative weight cycles
*/
function bellman_ford(g, source) {
/* STEP 1: initialisation */
for(var n in g.nodes)
g.nodes[n].distance = Infinity;
/* predecessors are implicitly null */
source.distance = 0;
g.snapShot("Initiallisation: Set all distances are infinite and all predecessors are null.");
/* STEP 2: relax each edge (this is at the heart of Bellman-Ford) */
/* repeat this for the number of nodes minus one */
for(var i = 1; i < g.nodes.length; i++)
/* for each edge */
for(var e in g.edges) {
var edge = g.edges[e];
if(edge.source.distance + edge.weight < edge.target.distance) {
g.snapShot("Relax edge between "+edge.source.id+" and "+edge.target.id+".");
edge.target.distance = edge.source.distance + edge.weight;
edge.target.predecessor = edge.source;
}
}
g.snapShot("Ready.");
/* STEP 3: TODO Check for negative cycles */
/* For now we assume here that the graph does not contain any negative
weights cycles. (this is left as an excercise to the reader[tm]) */
}
/*
Path-finding algorithm Dijkstra
- worst-case running time is O( |E| + |V| · log |V| ) thus better than
Bellman-Ford, but cannot handle negative edge weights
*/
function dijkstra(g, source) {
/* initially, all distances are infinite and all predecessors are null */
for(var n in g.nodes)
g.nodes[n].distance = Infinity;
/* predecessors are implicitly null */
source.distance = 0;
var counter=0;
/* set of unoptimized nodes, sorted by their distance (but a Fibonacci heap
would be better) */
var q = new BinaryMinHeap(g.nodes, "distance");
var node;
/* get the node with the smallest distance */
/* as long as we have unoptimized nodes */
while(q.min()!=undefined) {
/* remove the latest */
node=q.extractMin();
node.optimized=true;
/* no nodes accessible from this one, should not happen */
if(node.distance == Infinity)
throw "Orphaned node!";
/* for each neighbour of node */
for(e in node.edges) {
if(node.edges[e].target.optimized)
continue;
/* look for an alternative route */
var alt = node.distance + node.edges[e].weight;
/* update distance and route if a better one has been found */
if (alt < node.edges[e].target.distance) {
/* update distance of neighbour */
node.edges[e].target.distance = alt;
/* update priority queue */
q.heapify();
/* update path */
node.edges[e].target.predecessor = node;
}
}
}
}
/* Runs at worst in O(|V|³) and at best in Omega(|V|³) :-)
complexity Sigma(|V|²) */
/* This implementation is not yet ready for general use, but works with the
Dracula graph library. */
function floyd_warshall(g, source) {
/* Step 1: initialising empty path matrix (second dimension is implicit) */
var path = [];
var next = [];
var n = g.nodes.length;
/* construct path matrix, initialize with Infinity */
for(j in g.nodes) {
path[j] = [];
next[j] = [];
for(i in g.nodes)
path[j][i] = j == i ? 0 : Infinity;
}
/* initialize path with edge weights */
for(e in g.edges)
path[g.edges[e].source.id][g.edges[e].target.id] = g.edges[e].weight;
/* Note: Usually, the initialisation is done by getting the edge weights
from a node matrix representation of the graph, not by iterating through
a list of edges as done here. */
/* Step 2: find best distances (the heart of Floyd-Warshall) */
for(k in g.nodes){
for(i in g.nodes) {
for(j in g.nodes)
if(path[i][j] > path[i][k] + path[k][j]) {
path[i][j] = path[i][k] + path[k][j];
/* Step 2.b: remember the path */
next[i][j] = k;
}
}
}
/* Step 3: Path reconstruction */
function getPath(i, j) {
if(path[i][j] == Infinity)
throw "There is no path.";
var intermediate = next[i][j];
if(intermediate == undefined)
return null;
else
return getPath(i, intermediate)
.concat([intermediate])
.concat(getPath(intermediate, j));
}
// console&&console.log(path);
// console&&console.log(next);
/* TODO use the knowledge */
}
/*
A simple binary min-heap serving as a priority queue
- takes an array as the input, with elements having a key property
- elements will look like this:
{
key: "... key property ...",
value: "... element content ..."
}
- provides insert(), min(), extractMin() and heapify()
- example usage (e.g. via the Firebug console):
var x = {foo:20,hui:"bla"};
var a = new BinaryMinHeap([x,{foo:3},{foo:10},{foo:20},{foo:30},{foo:6},{foo:1},{foo:3}],"foo");
console.log(a.extractMin());
console.log(a.extractMin());
x.ma=0;
a.heapify(); // call this when key updated
console.log(a.extractMin());
console.log(a.extractMin());
- can also be used on a simple array, like [9,7,8,5]
*/
function BinaryMinHeap(array, key) {
/* Binary tree stored in an array, no need for a complicated data structure */
var tree = [];
var key = key || 'key';
/* Calculate the index of the parent or a child */
var parent = function(index) { return Math.floor((index - 1)/2); };
var right = function(index) { return 2 * index + 2; };
var left = function(index) { return 2 * index + 1; };
/* Helper function to swap elements with their parent
as long as the parent is bigger */
function bubble_up(i) {
var p = parent(i);
while((p >= 0) && (tree[i][key] < tree[p][key])) {
/* swap with parent */
tree[i] = tree.splice(p, 1, tree[i])[0];
/* go up one level */
i = p;
p = parent(i);
}
}
/* Helper function to swap elements with the smaller of their children
as long as there is one */
function bubble_down(i) {
var l = left(i);
var r = right(i);
/* as long as there are smaller children */
while(tree[l] && (tree[i][key] > tree[l][key]) || tree[r] && (tree[i][key] > tree[r][key])) {
/* find smaller child */
var child = tree[l] ? tree[r] ? tree[l][key] > tree[r][key] ? r : l : l : l;
/* swap with smaller child with current element */
tree[i] = tree.splice(child, 1, tree[i])[0];
/* go up one level */
i = child;
l = left(i);
r = right(i);
}
}
/* Insert a new element with respect to the heap property
1. Insert the element at the end
2. Bubble it up until it is smaller than its parent */
this.insert = function(element) {
/* make sure there's a key property */
(element[key] == undefined) && (element = {key:element});
/* insert element at the end */
tree.push(element);
/* bubble up the element */
bubble_up(tree.length - 1);
}
/* Only show us the minimum */
this.min = function() {
return tree.length == 1 ? undefined : tree[0];
}
/* Return and remove the minimum
1. Take the root as the minimum that we are looking for
2. Move the last element to the root (thereby deleting the root)
3. Compare the new root with both of its children, swap it with the
smaller child and then check again from there (bubble down)
*/
this.extractMin = function() {
var result = this.min();
/* move the last element to the root or empty the tree completely */
/* bubble down the new root if necessary */
(tree.length == 1) && (tree = []) || (tree[0] = tree.pop()) && bubble_down(0);
return result;
}
/* currently unused, TODO implement */
this.changeKey = function(index, key) {
throw "function not implemented";
}
this.heapify = function() {
for(var start = Math.floor((tree.length - 2) / 2); start >= 0; start--) {
bubble_down(start);
}
}
//this.debug = function() {console&&console.log("----");for(i in tree){console&&console.log(tree[i].id,tree[i].distance);};}
/* insert the input elements one by one only when we don't have a key property (TODO can be done more elegant) */
// if (key=="key")
for(i in (array || []))
this.insert(array[i]);
// else {
// this.tree = array; // TODO there's an error here, maybe the array needs to be cloned or copied, because all reference is lost after this assignment
// this.heapify();
// }
}
/*
Quick Sort:
1. Select some random value from the array, the median.
2. Divide the array in three smaller arrays according to the elements
being less, equal or greater than the median.
3. Recursively sort the array containg the elements less than the
median and the one containing elements greater than the median.
4. Concatenate the three arrays (less, equal and greater).
5. One or no element is always sorted.
Note: This could be implemented more efficiently by using only one array.
*/
function quickSort(arr) {
/* recursion anchor: one element is always sorted */
if(arr.length <= 1) return arr;
/* randomly selecting some value */
var median = arr[Math.floor(Math.random() * arr.length)];
var arr1 = [], arr2 = [], arr3 = [];
for(var i in arr) {
arr[i] < median && arr1.push(arr[i]);
arr[i] == median && arr2.push(arr[i]);
arr[i] > median && arr3.push(arr[i]);
}
/* recursive sorting and assembling final result */
return quickSort(arr1).concat(arr2).concat(quickSort(arr3));
}
/*
Selection Sort:
1. Select the minimum and remove it from the array
2. Sort the rest recursively
3. Return the minimum plus the sorted rest
4. An array with only one element is already sorted
*/
function selectionSort(arr) {
/* recursion anchor: one element is always sorted */
if(arr.length == 1) return arr;
var minimum = Infinity;
var index;
for(var i in arr) {
if(arr[i] < minimum) {
minimum = arr[i];
index = i; /* remember the minimum index for later removal */
}
}
/* remove the minimum */
arr.splice(index, 1);
/* assemble result and sort recursively (could be easily done iteratively as well)*/
return [minimum].concat(selectionSort(arr));
}
/*
Merge Sort:
1. Cut the array in half
2. Sort each of them recursively
3. Merge the two sorted arrays
4. An array with only one element is already sorted
*/
function mergeSort(arr) {
/* merges two sorted arrays into one sorted array */
function merge(a, b) {
/* result set */
var c = [];
/* as long as there are elements in the arrays to be merged */
while(a.length > 0 || b.length > 0){
/* are there elements to be merged, if yes, compare them and merge */
var n = a.length > 0 && b.length > 0 ? a[0] < b[0] ? a.shift() : b.shift() : b.length > 0 ? b.shift() : a.length > 0 ? a.shift() : null;
/* always push the smaller one onto the result set */
n != null && c.push(n);
}
return c;
}
/* this mergeSort implementation cuts the array in half, wich should be fine with randomized arrays, but introduces the risk of a worst-case scenario */
median = Math.floor(arr.length / 2);
var part1 = arr.slice(0, median); /* for some reason it doesn't work if inserted directly in the return statement (tried so with firefox) */
var part2 = arr.slice(median - arr.length);
return arr.length <= 1 ? arr : merge(
mergeSort(part1), /* first half */
mergeSort(part2) /* second half */
);
}
/* Balanced Red-Black-Tree */
function RedBlackTree(arr) {
}
function BTree(arr) {
}
function NaryTree(n, arr) {
}
/**
* Curry - Function currying
* Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
* Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
* Date: 10/4/2008
*
* @author Ariel Flesler
* @version 1.0.1
*/
function curry( fn ){
return function(){
var args = curry.args(arguments),
master = arguments.callee,
self = this;
return args.length >= fn.length ? fn.apply(self,args) : function(){
return master.apply( self, args.concat(curry.args(arguments)) );
};
};
};
curry.args = function( args ){
return Array.prototype.slice.call(args);
};
Function.prototype.curry = function(){
return curry(this);
};

105
htdocs/js/dracula_graffle.js Normal file
View file

@ -0,0 +1,105 @@
/**
* Originally grabbed from the official RaphaelJS Documentation
* http://raphaeljs.com/graffle.html
* Adopted (arrows) and commented by Philipp Strathausen http://blog.ameisenbar.de
* Licenced under the MIT licence.
*/
/**
* Usage:
* connect two shapes
* parameters:
* source shape [or connection for redrawing],
* target shape,
* style with { fg : linecolor, bg : background color, directed: boolean }
* returns:
* connection { draw = function() }
*/
Raphael.fn.connection = function (obj1, obj2, style) {
var selfRef = this;
/* create and return new connection */
var edge = {/*
from : obj1,
to : obj2,
style : style,*/
draw : function() {
/* get bounding boxes of target and source */
var bb1 = obj1.getBBox();
var bb2 = obj2.getBBox();
var off1 = 0;
var off2 = 0;
/* coordinates for potential connection coordinates from/to the objects */
var p = [
{x: bb1.x + bb1.width / 2, y: bb1.y - off1}, /* NORTH 1 */
{x: bb1.x + bb1.width / 2, y: bb1.y + bb1.height + off1}, /* SOUTH 1 */
{x: bb1.x - off1, y: bb1.y + bb1.height / 2}, /* WEST 1 */
{x: bb1.x + bb1.width + off1, y: bb1.y + bb1.height / 2}, /* EAST 1 */
{x: bb2.x + bb2.width / 2, y: bb2.y - off2}, /* NORTH 2 */
{x: bb2.x + bb2.width / 2, y: bb2.y + bb2.height + off2}, /* SOUTH 2 */
{x: bb2.x - off2, y: bb2.y + bb2.height / 2}, /* WEST 2 */
{x: bb2.x + bb2.width + off2, y: bb2.y + bb2.height / 2} /* EAST 2 */
];
/* distances between objects and according coordinates connection */
var d = {}, dis = [];
/*
* find out the best connection coordinates by trying all possible ways
*/
/* loop the first object's connection coordinates */
for (var i = 0; i < 4; i++) {
/* loop the seond object's connection coordinates */
for (var j = 4; j < 8; j++) {
var dx = Math.abs(p[i].x - p[j].x),
dy = Math.abs(p[i].y - p[j].y);
if ((i == j - 4) || (((i != 3 && j != 6) || p[i].x < p[j].x) && ((i != 2 && j != 7) || p[i].x > p[j].x) && ((i != 0 && j != 5) || p[i].y > p[j].y) && ((i != 1 && j != 4) || p[i].y < p[j].y))) {
dis.push(dx + dy);
d[dis[dis.length - 1].toFixed(3)] = [i, j];
}
}
}
var res = dis.length == 0 ? [0, 4] : d[Math.min.apply(Math, dis).toFixed(3)];
/* bezier path */
var x1 = p[res[0]].x,
y1 = p[res[0]].y,
x4 = p[res[1]].x,
y4 = p[res[1]].y,
dx = Math.max(Math.abs(x1 - x4) / 2, 10),
dy = Math.max(Math.abs(y1 - y4) / 2, 10),
x2 = [x1, x1, x1 - dx, x1 + dx][res[0]].toFixed(3),
y2 = [y1 - dy, y1 + dy, y1, y1][res[0]].toFixed(3),
x3 = [0, 0, 0, 0, x4, x4, x4 - dx, x4 + dx][res[1]].toFixed(3),
y3 = [0, 0, 0, 0, y1 + dy, y1 - dy, y4, y4][res[1]].toFixed(3);
/* assemble path and arrow */
var path = ["M", x1.toFixed(3), y1.toFixed(3), "C", x2, y2, x3, y3, x4.toFixed(3), y4.toFixed(3)].join(",");
/* arrow */
if(style && style.directed) {
/* magnitude, length of the last path vector */
var mag = Math.sqrt((y4 - y3) * (y4 - y3) + (x4 - x3) * (x4 - x3));
/* vector normalisation to specified length */
var norm = function(x,l){return (-x*(l||5)/mag);};
/* calculate array coordinates (two lines orthogonal to the path vector) */
var arr = [
{x:(norm(x4-x3)+norm(y4-y3)+x4).toFixed(3), y:(norm(y4-y3)+norm(x4-x3)+y4).toFixed(3)},
{x:(norm(x4-x3)-norm(y4-y3)+x4).toFixed(3), y:(norm(y4-y3)-norm(x4-x3)+y4).toFixed(3)}
];
path = path + ",M"+arr[0].x+","+arr[0].y+",L"+x4+","+y4+",L"+arr[1].x+","+arr[1].y;
}
/* applying path(s) */
edge.fg && edge.fg.attr({path:path})
|| (edge.fg = selfRef.path(path).attr({stroke: style && style.stroke || "#000", fill: "none"}).toBack());
edge.bg && edge.bg.attr({path:path})
|| style && style.fill && (edge.bg = style.fill.split && selfRef.path(path).attr({stroke: style.fill.split("|")[0], fill: "none", "stroke-width": style.fill.split("|")[1] || 3}).toBack());
/* setting label */
style && style.label
&& (edge.label && edge.label.attr({x:(x1+x4)/2, y:(y1+y4)/2})
|| (edge.label = selfRef.text((x1+x4)/2, (y1+y4)/2, style.label).attr({fill: "#000", "font-size":"14px"})));
// && selfRef.text(x4, y4, style.label).attr({stroke: style && style.stroke || "#fff", "font-weight":"bold", "font-size":"20px"})
// style && style.callback && style.callback(edge);
}
}
edge.draw();
return edge;
};
//Raphael.prototype.set.prototype.dodo=function(){console.log("works");};

406
htdocs/js/dracula_graph.js Normal file
View file

@ -0,0 +1,406 @@
/*
* Dracula Graph Layout and Drawing Framework 0.0.3alpha
* (c) 2010 Philipp Strathausen <strathausen@gmail.com>, http://strathausen.eu
*
* based on the Graph JavaScript framework, version 0.0.1
* (c) 2006 Aslak Hellesoy <aslak.hellesoy@gmail.com>
* (c) 2006 Dave Hoover <dave.hoover@gmail.com>
*
* Ported from Graph::Layouter::Spring in
* http://search.cpan.org/~pasky/Graph-Layderer-0.02/
* The algorithm is based on a spring-style layouter of a Java-based social
* network tracker PieSpy written by Paul Mutton E<lt>paul@jibble.orgE<gt>.
*
* This code is freely distributable under the terms of an MIT-style license.
* For details, see the Graph web site: http://dev.buildpatternd.com/trac
*
* Links:
*
* Graph Dracula JavaScript Framework:
* http://graphdracula.net
*
* Demo of the original applet:
* http://redsquirrel.com/dave/work/webdep/
*
* Mirrored original source code at snipplr:
* http://snipplr.com/view/1950/graph-javascript-framework-version-001/
*
* Original usage example:
* http://ajaxian.com/archives/new-javascriptcanvas-graph-library
*
/*--------------------------------------------------------------------------*/
/*
* Graph
*/
var Graph = function() {
this.nodes = [];
this.nodelist = []; // nodes by index number, only used once TODO use only one node container
this.edges = [];
this.snapshots = []; // previous graph states
};
Graph.prototype = {
/*
* add a node
* @id the node's ID (string or number)
* @content (optional, dictionary) can contain any information that is
* being interpreted by the layout algorithm or the graph
* representation
*/
addNode: function(id, content) {
/* testing if node is already existing in the graph */
if(this.nodes[id] == undefined) {
this.nodes[id] = new Graph.Node(id, content || {"id" : id}); /* nodes indexed by node id */
this.nodelist.push(this.nodes[id]); /* node list indexed by numbers */
}
return this.nodes[id];
},
// TODO rename style to content
addEdge: function(source, target, style) {
var s = this.addNode(source);
var t = this.addNode(target);
var edge = { source: s, target: t, style: style, weight: style&&style.weight||1 }; // TODO tidy up here
s.edges.push(edge);
this.edges.push(edge);
/* add an edge back if graph undirected */
if(!style || !style.directed) {
var backedge = { source: t, target: s, style: style, weight : style&&style.weight||1, backedge : edge }; // TODO tidy up here
this.edges.push(backedge);
t.edges.push(backedge);
}
},
/*
* Preserve a copy of the graph state (nodes, positions, ...)
* @comment a comment describing the state
* @about a list with objects to be marked as significant in this state (TODO)
*/
snapShot: function(comment, about) {
// TODO get rid of the jQuery plugin dependence just for the deep copying
var graph = new Graph();
jQuery.extend(true, graph.nodes, this.nodes);
jQuery.extend(true, graph.nodelist, this.nodelist);
jQuery.extend(true, graph.edges, this.edges);
graph.snapShot = null;
this.snapshots.push({comment: comment, graph: graph});
}
};
/*
* Node
*/
Graph.Node = function(id, value){
value.id = id;
value.edges = [];
return value;
};
Graph.Node.prototype = {
};
/*
* Renderer base class
*/
Graph.Renderer = {};
/*
* Renderer implementation using RaphaelJS
*/
Graph.Renderer.Raphael = function(element, graph, width, height) {
this.width = width||400;
this.height = height||400;
var selfRef = this;
this.r = Raphael(element, this.width, this.height);
this.radius = 40; /* max dimension of a node */
this.graph = graph;
this.mouse_in = false;
/* TODO default node rendering function */
if(!this.graph.render) {
this.graph.render = function() {
return;
}
}
/*
* Dragging
*/
this.isDrag = false;
this.dragger = function (e) {
this.dx = e.clientX;
this.dy = e.clientY;
selfRef.isDrag = this;
this.set && this.set.animate({"fill-opacity": .1}, 200) && this.set.toFront();
e.preventDefault && e.preventDefault();
};
document.onmousemove = function (e) {
e = e || window.event;
if (selfRef.isDrag) {
var bBox = selfRef.isDrag.set.getBBox();
// TODO round the coordinates here (eg. for proper image representation)
var newX = e.clientX - selfRef.isDrag.dx + (bBox.x + bBox.width / 2);
var newY = e.clientY - selfRef.isDrag.dy + (bBox.y + bBox.height / 2);
/* prevent shapes from being dragged out of the canvas */
var clientX = e.clientX - (newX < 20 ? newX - 20 : newX > selfRef.width - 20 ? newX - selfRef.width + 20 : 0);
var clientY = e.clientY - (newY < 20 ? newY - 20 : newY > selfRef.height - 20 ? newY - selfRef.height + 20 : 0);
selfRef.isDrag.set.translate(clientX - selfRef.isDrag.dx, clientY - selfRef.isDrag.dy);
for (var i in selfRef.graph.edges) {
selfRef.graph.edges[i].connection && selfRef.graph.edges[i].connection.draw();
}
//selfRef.r.safari();
selfRef.isDrag.dx = clientX;
selfRef.isDrag.dy = clientY;
}
};
document.onmouseup = function () {
selfRef.isDrag && selfRef.isDrag.set.animate({"fill-opacity": .6}, 500);
selfRef.isDrag = false;
};
};
Graph.Renderer.Raphael.prototype = {
translate: function(point) {
return [
Math.round((point[0] - this.graph.layoutMinX) * this.factorX + this.radius),
Math.round((point[1] - this.graph.layoutMinY) * this.factorY + this.radius)
];
},
rotate: function(point, length, angle) {
var dx = length * Math.cos(angle);
var dy = length * Math.sin(angle);
return [point[0]+dx, point[1]+dy];
},
draw: function() {
this.factorX = (this.width - 2 * this.radius) / (this.graph.layoutMaxX - this.graph.layoutMinX);
this.factorY = (this.height - 2 * this.radius) / (this.graph.layoutMaxY - this.graph.layoutMinY);
for (i in this.graph.nodes) {
this.drawNode(this.graph.nodes[i]);
}
for (var i = 0; i < this.graph.edges.length; i++) {
this.drawEdge(this.graph.edges[i]);
}
},
drawNode: function(node) {
var point = this.translate([node.layoutPosX, node.layoutPosY]);
node.point = point;
/* if node has already been drawn, move the nodes */
if(node.shape) {
var oBBox = node.shape.getBBox();
var opoint = [ oBBox.x + Math.round(oBBox.width / 2) , oBBox.y + Math.round(oBBox.height / 2) ];
node.shape.translate(point[0]-opoint[0], point[1]-opoint[1]);
this.r.safari();
return;
}/* else, draw new nodes */
var shape;
/* if a node renderer function is provided by the user, then use it */
if(node.render) {
shape = node.render(this.r, node);
/* or check for an ajax representation of the nodes */
} else if(node.shape) {
// TODO ajax representation
/* the default node drawing */
} else {
var color = Raphael.getColor();
shape = this.r.set().
push(this.r.ellipse(point[0], point[1], 30, 20).attr({fill: color, stroke: color, "stroke-width": 2})).
push(this.r.text(point[0], point[1] + 30, node.label || node.id));
}
shape.attr({"fill-opacity": .6});
/* reference to the node an element belongs to, needed for dragging all elements of a node */
shape.items.forEach(function(item){ item.set = shape; item.node.style.cursor = "move"; });
shape.mousedown(this.dragger);
node.shape = shape;
},
drawEdge: function(edge) {
/* if this edge already exists the other way around and is undirected */
if(edge.backedge)
return;
/* if edge already has been drawn, only refresh the edge */
edge.connection && edge.connection.draw();
if(!edge.connection) {
edge.style && edge.style.callback && edge.style.callback(edge);//TODO move this somewhere else
edge.connection = this.r.connection(edge.source.shape, edge.target.shape, edge.style);
}
}
};
Graph.Layout = {};
Graph.Layout.Spring = function(graph) {
this.graph = graph;
this.iterations = 500;
this.maxRepulsiveForceDistance = 6;
this.k = 2;
this.c = 0.01;
this.maxVertexMovement = 0.5;
};
Graph.Layout.Spring.prototype = {
layout: function() {
this.layoutPrepare();
for (var i = 0; i < this.iterations; i++) {
this.layoutIteration();
}
this.layoutCalcBounds();
},
layoutPrepare: function() {
for (i in this.graph.nodes) {
var node = this.graph.nodes[i];
node.layoutPosX = 0;
node.layoutPosY = 0;
node.layoutForceX = 0;
node.layoutForceY = 0;
}
},
layoutCalcBounds: function() {
var minx = Infinity, maxx = -Infinity, miny = Infinity, maxy = -Infinity;
for (i in this.graph.nodes) {
var x = this.graph.nodes[i].layoutPosX;
var y = this.graph.nodes[i].layoutPosY;
if(x > maxx) maxx = x;
if(x < minx) minx = x;
if(y > maxy) maxy = y;
if(y < miny) miny = y;
}
this.graph.layoutMinX = minx;
this.graph.layoutMaxX = maxx;
this.graph.layoutMinY = miny;
this.graph.layoutMaxY = maxy;
},
layoutIteration: function() {
// Forces on nodes due to node-node repulsions
for (var i = 0; i < this.graph.nodelist.length; i++) {
var node1 = this.graph.nodelist[i];
for (var j = i + 1; j < this.graph.nodelist.length; j++) {
var node2 = this.graph.nodelist[j];
this.layoutRepulsive(node1, node2);
}
}
// Forces on nodes due to edge attractions
for (var i = 0; i < this.graph.edges.length; i++) {
var edge = this.graph.edges[i];
this.layoutAttractive(edge);
}
// Move by the given force
for (i in this.graph.nodes) {
var node = this.graph.nodes[i];
var xmove = this.c * node.layoutForceX;
var ymove = this.c * node.layoutForceY;
var max = this.maxVertexMovement;
if(xmove > max) xmove = max;
if(xmove < -max) xmove = -max;
if(ymove > max) ymove = max;
if(ymove < -max) ymove = -max;
node.layoutPosX += xmove;
node.layoutPosY += ymove;
node.layoutForceX = 0;
node.layoutForceY = 0;
}
},
layoutRepulsive: function(node1, node2) {
var dx = node2.layoutPosX - node1.layoutPosX;
var dy = node2.layoutPosY - node1.layoutPosY;
var d2 = dx * dx + dy * dy;
if(d2 < 0.01) {
dx = 0.1 * Math.random() + 0.1;
dy = 0.1 * Math.random() + 0.1;
var d2 = dx * dx + dy * dy;
}
var d = Math.sqrt(d2);
if(d < this.maxRepulsiveForceDistance) {
var repulsiveForce = this.k * this.k / d;
node2.layoutForceX += repulsiveForce * dx / d;
node2.layoutForceY += repulsiveForce * dy / d;
node1.layoutForceX -= repulsiveForce * dx / d;
node1.layoutForceY -= repulsiveForce * dy / d;
}
},
layoutAttractive: function(edge) {
var node1 = edge.source;
var node2 = edge.target;
var dx = node2.layoutPosX - node1.layoutPosX;
var dy = node2.layoutPosY - node1.layoutPosY;
var d2 = dx * dx + dy * dy;
if(d2 < 0.01) {
dx = 0.1 * Math.random() + 0.1;
dy = 0.1 * Math.random() + 0.1;
var d2 = dx * dx + dy * dy;
}
var d = Math.sqrt(d2);
if(d > this.maxRepulsiveForceDistance) {
d = this.maxRepulsiveForceDistance;
d2 = d * d;
}
var attractiveForce = (d2 - this.k * this.k) / this.k;
if(edge.attraction == undefined) edge.attraction = 1;
attractiveForce *= Math.log(edge.attraction) * 0.5 + 1;
node2.layoutForceX -= attractiveForce * dx / d;
node2.layoutForceY -= attractiveForce * dy / d;
node1.layoutForceX += attractiveForce * dx / d;
node1.layoutForceY += attractiveForce * dy / d;
}
};
/*
* usefull JavaScript extensions,
*/
//Array.prototype.forEach = function(f) {
// var l = this.length;
// for( var i = 0; i < l; i++) f(this[i]);
//};
function log(a) {console.log&&console.log(a);}
// this will eventually mess up array usage with for-in-loops
//Array.prototype.onEach = function(f, arg) {
// var l = this.length;
// for( var i = 0; i < l; i++) this[i][f]( arg );
//}
/*
* Raphael Tooltip Plugin
* - attaches an element as a tooltip to another element
*
* Usage example, adding a rectangle as a tooltip to a circle:
*
* paper.circle(100,100,10).tooltip(paper.rect(0,0,20,30));
*
* If you want to use more shapes, you'll have to put them into a set.
*
*/
Raphael.el.tooltip = function (tp) {
this.tp = tp;
this.tp.o = {x: 0, y: 0};
this.tp.hide();
this.hover(
function(event){
this.mousemove(function(event){
this.tp.translate(event.clientX -
this.tp.o.x,event.clientY - this.tp.o.y);
this.tp.o = {x: event.clientX, y: event.clientY};
});
this.tp.show().toFront();
},
function(event){
this.tp.hide();
this.unmousemove();
});
return this;
};

7
htdocs/js/raphael-min.js vendored Normal file
View file

File diff suppressed because one or more lines are too long

266
htdocs/js/seedrandom.js Normal file
View file

@ -0,0 +1,266 @@
// seedrandom.js
// Author: David Bau 3/11/2010
//
// Defines a method Math.seedrandom() that, when called, substitutes
// an explicitly seeded RC4-based algorithm for Math.random(). Also
// supports automatic seeding from local or network sources of entropy.
//
// Usage:
//
// <script src=http://davidbau.com/encode/seedrandom-min.js></script>
//
// Math.seedrandom('yipee'); Sets Math.random to a function that is
// initialized using the given explicit seed.
//
// Math.seedrandom(); Sets Math.random to a function that is
// seeded using the current time, dom state,
// and other accumulated local entropy.
// The generated seed string is returned.
//
// Math.seedrandom('yowza', true);
// Seeds using the given explicit seed mixed
// together with accumulated entropy.
//
// <script src="http://bit.ly/srandom-512"></script>
// Seeds using physical random bits downloaded
// from random.org.
//
// Examples:
//
// Math.seedrandom("hello"); // Use "hello" as the seed.
// document.write(Math.random()); // Always 0.5463663768140734
// document.write(Math.random()); // Always 0.43973793770592234
// var rng1 = Math.random; // Remember the current prng.
//
// var autoseed = Math.seedrandom(); // New prng with an automatic seed.
// document.write(Math.random()); // Pretty much unpredictable.
//
// Math.random = rng1; // Continue "hello" prng sequence.
// document.write(Math.random()); // Always 0.554769432473455
//
// Math.seedrandom(autoseed); // Restart at the previous seed.
// document.write(Math.random()); // Repeat the 'unpredictable' value.
//
// Notes:
//
// Each time seedrandom('arg') is called, entropy from the passed seed
// is accumulated in a pool to help generate future seeds for the
// zero-argument form of Math.seedrandom, so entropy can be injected over
// time by calling seedrandom with explicit data repeatedly.
//
// On speed - This javascript implementation of Math.random() is about
// 3-10x slower than the built-in Math.random() because it is not native
// code, but this is typically fast enough anyway. Seeding is more expensive,
// especially if you use auto-seeding. Some details (timings on Chrome 4):
//
// Our Math.random() - avg less than 0.002 milliseconds per call
// seedrandom('explicit') - avg less than 0.5 milliseconds per call
// seedrandom('explicit', true) - avg less than 2 milliseconds per call
// seedrandom() - avg about 38 milliseconds per call
//
// LICENSE (BSD):
//
// Copyright 2010 David Bau, 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. Neither the name of this module nor the names of its contributors may
// be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "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 COPYRIGHT
// OWNER OR CONTRIBUTORS 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.
//
/**
* All code is in an anonymous closure to keep the global namespace clean.
*
* @param {number=} overflow
* @param {number=} startdenom
*/
(function (pool, math, width, chunks, significance, overflow, startdenom) {
//
// seedrandom()
// This is the seedrandom function described above.
//
math['seedrandom'] = function seedrandom(seed, use_entropy) {
var key = [];
var arc4;
// Flatten the seed string or build one from local entropy if needed.
seed = mixkey(flatten(
use_entropy ? [seed, pool] :
arguments.length ? seed :
[new Date().getTime(), pool, window], 3), key);
// Use the seed to initialize an ARC4 generator.
arc4 = new ARC4(key);
// Mix the randomness into accumulated entropy.
mixkey(arc4.S, pool);
// Override Math.random
// This function returns a random double in [0, 1) that contains
// randomness in every bit of the mantissa of the IEEE 754 value.
math['random'] = function random() { // Closure to return a random double:
var n = arc4.g(chunks); // Start with a numerator n < 2 ^ 48
var d = startdenom; // and denominator d = 2 ^ 48.
var x = 0; // and no 'extra last byte'.
while (n < significance) { // Fill up all significant digits by
n = (n + x) * width; // shifting numerator and
d *= width; // denominator and generating a
x = arc4.g(1); // new least-significant-byte.
}
while (n >= overflow) { // To avoid rounding up, before adding
n /= 2; // last byte, shift everything
d /= 2; // right using integer math until
x >>>= 1; // we have exactly the desired bits.
}
return (n + x) / d; // Form the number within [0, 1).
};
// Return the seed that was used
return seed;
};
//
// ARC4
//
// An ARC4 implementation. The constructor takes a key in the form of
// an array of at most (width) integers that should be 0 <= x < (width).
//
// The g(count) method returns a pseudorandom integer that concatenates
// the next (count) outputs from ARC4. Its return value is a number x
// that is in the range 0 <= x < (width ^ count).
//
/** @constructor */
function ARC4(key) {
var t, u, me = this, keylen = key.length;
var i = 0, j = me.i = me.j = me.m = 0;
me.S = [];
me.c = [];
// The empty key [] is treated as [0].
if (!keylen) { key = [keylen++]; }
// Set up S using the standard key scheduling algorithm.
while (i < width) { me.S[i] = i++; }
for (i = 0; i < width; i++) {
t = me.S[i];
j = lowbits(j + t + key[i % keylen]);
u = me.S[j];
me.S[i] = u;
me.S[j] = t;
}
// The "g" method returns the next (count) outputs as one number.
me.g = function getnext(count) {
var s = me.S;
var i = lowbits(me.i + 1); var t = s[i];
var j = lowbits(me.j + t); var u = s[j];
s[i] = u;
s[j] = t;
var r = s[lowbits(t + u)];
while (--count) {
i = lowbits(i + 1); t = s[i];
j = lowbits(j + t); u = s[j];
s[i] = u;
s[j] = t;
r = r * width + s[lowbits(t + u)];
}
me.i = i;
me.j = j;
return r;
};
// For robust unpredictability discard an initial batch of values.
// See http://www.rsa.com/rsalabs/node.asp?id=2009
me.g(width);
}
//
// flatten()
// Converts an object tree to nested arrays of strings.
//
/** @param {Object=} result
* @param {string=} prop */
function flatten(obj, depth, result, prop) {
result = [];
if (depth && typeof(obj) == 'object') {
for (prop in obj) {
if (prop.indexOf('S') < 5) { // Avoid FF3 bug (local/sessionStorage)
try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
}
}
}
return result.length ? result : '' + obj;
}
//
// mixkey()
// Mixes a string seed into a key that is an array of integers, and
// returns a shortened string seed that is equivalent to the result key.
//
/** @param {number=} smear
* @param {number=} j */
function mixkey(seed, key, smear, j) {
seed += ''; // Ensure the seed is a string
smear = 0;
for (j = 0; j < seed.length; j++) {
key[lowbits(j)] =
lowbits((smear ^= key[lowbits(j)] * 19) + seed.charCodeAt(j));
}
seed = '';
for (j in key) { seed += String.fromCharCode(key[j]); }
return seed;
}
//
// lowbits()
// A quick "n mod width" for width a power of 2.
//
function lowbits(n) { return n & (width - 1); }
//
// The following constants are related to IEEE 754 limits.
//
startdenom = math.pow(width, chunks);
significance = math.pow(2, significance);
overflow = significance * 2;
//
// When seedrandom.js is loaded, we immediately mix a few bits
// from the built-in RNG into the entropy pool. Because we do
// not want to intefere with determinstic PRNG state later,
// seedrandom will not call math.random on its own again after
// initialization.
//
mixkey(math.random(), pool);
// End anonymous scope, and pass initial values.
})(
[], // pool: entropy pool starts empty
Math, // math: package containing random, pow, and seedrandom
256, // width: each RC4 output is 0 <= x < 256
6, // chunks: at least six RC4 outputs for each double
52 // significance: there are 52 significant digits in a double
);

10
htdocs/test.cgi Executable file
View file

@ -0,0 +1,10 @@
#!/bin/sh
echo "Content-Type: text/html"
echo
echo "<h1>LOL</h1>"
echo "Query string: <b>$QUERY_STRING</b><br>"
echo "Accept: <b>$HTTP_ACCEPT</b><br>"
echo "User-Agent: <b>$HTTP_USER_AGENT</b><br>"
echo "Client addr : <b>$REMOTE_ADDR</b><br>"

302
webserv.c
View file

@ -36,6 +36,11 @@
"Content-Type: %s\r\n" \
"Content-Length: %u\r\n\r\n"
#define HTTP_CGI_RESPONSE_HEADERS_FORMAT "%s %d %s\r\n" \
"Date: %s\r\n" \
"Server: %s\r\n" \
"Content-Length: %u\r\n"
#define HTTP_ERR_RESPONSE_FORMAT "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n" \
"<html><head>\n" \
"<title>%u %s</title>\n" \
@ -46,6 +51,11 @@
"<i>%s</i>\n" \
"</body></html>\n\n"
typedef struct {
int sd;
struct sockaddr_in client;
} conn_info;
/**
* \brief Escape a string to be used or included in an URL
* \param str String to be escaped
@ -173,20 +183,28 @@ __AI_webservlet_thread ( void *arg )
{
time_t ltime = time ( NULL );
struct stat st;
BOOL is_cgi = false;
FILE *sock = NULL,
*fp = NULL;
*fp = NULL,
*pipe = NULL;
int i,
*sd = (int*) arg,
http_response_len = 0,
sd = ((conn_info*) arg)->sd,
nlines = 0,
nmatches = 0,
max_content_length = 0,
max_headers_length = 0,
req_file_absolute_path_size = 0;
char *line = NULL,
char ch,
client_addr[INET_ADDRSTRLEN] = { 0 },
client_port[10] = { 0 },
*line = NULL,
*unescaped = NULL,
*cgi_cmd = NULL,
*query_string = NULL,
*http_response = NULL,
*http_headers = NULL,
*strtime = NULL,
@ -200,6 +218,16 @@ __AI_webservlet_thread ( void *arg )
max_content_length = strlen ( HTTP_ERR_RESPONSE_FORMAT ) + strlen ( config->webserv_banner ) + 1000;
max_headers_length = strlen ( HTTP_RESPONSE_HEADERS_FORMAT ) + strlen ( config->webserv_banner ) + 1000;
/* Setting environment variables */
inet_ntop ( AF_INET, &(((conn_info*) arg)->client.sin_addr.s_addr), client_addr, INET_ADDRSTRLEN );
snprintf ( client_port, sizeof ( client_port ), "%d", htons (((conn_info*) arg)->client.sin_port) );
setenv ( "CLIENT_PROTOCOL", "HTTP", 1 );
setenv ( "DOCUMENT_ROOT", config->webserv_dir, 1 );
setenv ( "GATEWAY_INTERFACE", "CGI/1.1", 1 );
setenv ( "REMOTE_ADDR", client_addr, 1 );
setenv ( "REMOTE_PORT", client_port, 1 );
if ( !( http_response = (char*) alloca ( max_content_length )))
{
pthread_exit ((void*) 0);
@ -212,7 +240,7 @@ __AI_webservlet_thread ( void *arg )
return (void*) 0;
}
if ( !( sock = fdopen ( *sd, "r+" )))
if ( !( sock = fdopen ( sd, "r+" )))
{
pthread_exit ((void*) 0);
return (void*) 0;
@ -228,22 +256,41 @@ __AI_webservlet_thread ( void *arg )
for ( nlines=0; ( line = __AI_getline ( sock )); nlines++ )
{
if ( preg_match ( "^\\s*GET\\s+(/[^ ]*)\\s*(HTTP/[0-9]\\.[0-9])?", line, &matches, &nmatches ) > 0 )
if ( preg_match ( "^\\s*(GET|POST|HEAD)\\s+(/[^ \\?#]*)(\\?|#)?([^ ]+)?\\s*(HTTP/[0-9]\\.[0-9])?", line, &matches, &nmatches ) > 0 )
{
if ( strlen ( matches[1] ) > 0 )
setenv ( "REQUEST_METHOD", matches[0], 1 );
if ( !strcmp ( matches[2], "?" ))
{
strncpy ( http_ver, matches[1], sizeof ( http_ver ));
if ( strlen ( matches[3] ) > 0 )
{
query_string = strdup ( matches[3] );
setenv ( "QUERY_STRING", query_string, 1 );
}
}
if ( strlen ( matches[4] ) > 0 )
{
strncpy ( http_ver, matches[4], sizeof ( http_ver ));
} else {
strncpy ( http_ver, "HTTP/1.0", sizeof ( http_ver ));
}
if ( !strcmp ( matches[0], "/" ))
setenv ( "SERVER_PROTOCOL", http_ver, 1 );
if ( !strcmp ( matches[1], "/" ))
{
free ( matches[0] );
matches[0] = strdup ( "/index.html" );
free ( matches[1] );
matches[1] = strdup ( "/index.html" );
}
snprintf ( req_file_absolute_path, req_file_absolute_path_size, "%s%s", config->webserv_dir, matches[0] );
setenv ( "DOCUMENT_URI", matches[1], 1 );
setenv ( "DOCUMENT_URL", matches[1], 1 );
setenv ( "REQUEST_URI", matches[1], 1 );
setenv ( "URI", matches[1], 1 );
setenv ( "URL", matches[1], 1 );
snprintf ( req_file_absolute_path, req_file_absolute_path_size, "%s%s", config->webserv_dir, matches[1] );
if ( strcmp ( http_ver, "HTTP/1.0" ) && strcmp ( http_ver, "HTTP/1.1" ))
{
@ -332,14 +379,62 @@ __AI_webservlet_thread ( void *arg )
if ( !strcasecmp ( extension, "html" ))
{
strncpy ( content_type, "text/html", sizeof ( content_type ));
} else if ( !strcasecmp ( extension, "css" ))
{
} else if ( !strcasecmp ( extension, "css" )) {
strncpy ( content_type, "text/css", sizeof ( content_type ));
} else if ( !strcasecmp ( extension, "js" ))
{
} else if ( !strcasecmp ( extension, "js" )) {
strncpy ( content_type, "application/x-javascript", sizeof ( content_type ));
} else if ( !strcasecmp ( extension, "json" )) {
strncpy ( content_type, "application/json", sizeof ( content_type ));
} else if ( !strcasecmp ( extension, "jpg" ) || !strcasecmp ( extension, "jpeg" )) {
strncpy ( content_type, "image/jpeg", sizeof ( content_type ));
} else if ( !strcasecmp ( extension, "cgi" )) {
/* If it's not executable, it's not a CGI */
if ( !( st.st_mode & S_IXOTH ))
strncpy ( content_type, "text/plain", sizeof ( content_type ));
else {
is_cgi = true;
http_response = NULL;
http_response_len = 1;
if ( !( cgi_cmd = (char*) alloca ( strlen ( req_file_absolute_path ) + 20 )))
{
pthread_exit ((void*) 0);
return (void*) 0;
}
sprintf ( cgi_cmd, "/bin/sh -c %s", req_file_absolute_path );
if ( !( pipe = popen ( cgi_cmd, "r" )))
{
pthread_exit ((void*) 0);
return (void*) 0;
}
while ( fread ( &ch, 1, 1, pipe ) > 0 )
{
if ( !( http_response = (char*) realloc ( http_response, ++http_response_len )))
{
pthread_exit ((void*) 0);
return (void*) 0;
}
http_response [ http_response_len - 2 ] = ch;
}
http_response [ http_response_len - 1 ] = 0;
pclose ( pipe );
if ( !http_response )
{
if ( !( http_response = (char*) malloc ( 2 )))
{
pthread_exit ((void*) 0);
return (void*) 0;
}
http_response[0] = 0;
}
}
} else if ( !strcasecmp ( extension, "gif" ) || !strcasecmp ( extension, "png" ) ||
!strcasecmp ( extension, "bmp" ) || !strcasecmp ( extension, "tif" ) ||
!strcasecmp ( extension, "ppm" )) {
@ -349,42 +444,144 @@ __AI_webservlet_thread ( void *arg )
strncpy ( content_type, "text/plain", sizeof ( content_type ));
}
if ( !( http_response = (char*) alloca ( st.st_size + 2 )))
if ( !is_cgi )
{
pthread_exit ((void*) 0);
return (void*) 0;
if ( !( http_response = (char*) alloca ( st.st_size + 2 )))
{
pthread_exit ((void*) 0);
return (void*) 0;
}
memset ( http_response, 0, st.st_size + 2 );
fread ( http_response, st.st_size, 1, fp );
fclose ( fp );
}
memset ( http_response, 0, st.st_size + 2 );
fread ( http_response, st.st_size, 1, fp );
fclose ( fp );
ltime = time ( NULL );
strtime = strdup ( ctime ( &ltime ));
strtime [ strlen(strtime) - 1 ] = 0;
snprintf ( http_headers, max_headers_length, HTTP_RESPONSE_HEADERS_FORMAT,
http_ver, 200, "Found", strtime, config->webserv_banner,
content_type, strlen ( http_response ));
if ( is_cgi )
{
snprintf ( http_headers, max_headers_length, HTTP_CGI_RESPONSE_HEADERS_FORMAT,
http_ver, 200, "Found", strtime, config->webserv_banner, strlen ( http_response ));
} else {
snprintf ( http_headers, max_headers_length, HTTP_RESPONSE_HEADERS_FORMAT,
http_ver, 200, "Found", strtime, config->webserv_banner,
content_type, strlen ( http_response ));
}
free ( strtime );
free ( line );
line = NULL;
continue;
} else if ( nlines == 0 ) {
snprintf ( http_response, max_content_length, HTTP_ERR_RESPONSE_FORMAT,
405, "Method Not Allowed", "Method Not Allowed",
"The requested HTTP method is not allowed",
config->webserv_banner );
} else {
if ( nlines == 0 )
{
snprintf ( http_response, max_content_length, HTTP_ERR_RESPONSE_FORMAT,
405, "Method Not Allowed", "Method Not Allowed",
"The requested HTTP method is not allowed",
config->webserv_banner );
ltime = time ( NULL );
strtime = strdup ( ctime ( &ltime ));
strtime [ strlen(strtime) - 1 ] = 0;
snprintf ( http_headers, max_headers_length, HTTP_RESPONSE_HEADERS_FORMAT,
"HTTP/1.1", 405, "Method Not Allowed", strtime, "text/html",
config->webserv_banner, strlen ( http_response ));
free ( strtime );
free ( line );
line = NULL;
continue;
ltime = time ( NULL );
strtime = strdup ( ctime ( &ltime ));
strtime [ strlen(strtime) - 1 ] = 0;
snprintf ( http_headers, max_headers_length, HTTP_RESPONSE_HEADERS_FORMAT,
"HTTP/1.1", 405, "Method Not Allowed", strtime, "text/html",
config->webserv_banner, strlen ( http_response ));
free ( strtime );
free ( line );
line = NULL;
continue;
} else if ( preg_match ( "\\s*Content-Length\\s*:\\s*([0-9]+)", line, &matches, &nmatches ) > 0 ) {
setenv ( "CONTENT_LENGTH", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Content-Type\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "CONTENT_TYPE", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Accept\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_ACCEPT", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Accept-Charset\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_ACCEPT_CHARSET", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Accept-Encoding\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_ACCEPT_ENCODING", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Accept-Language\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_ACCEPT_LANGUAGE", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Connection\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_CONNECTION", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Cookie\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_COOKIE", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Reason\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_REASON", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*User-Agent\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_USER_AGENT", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
} else if ( preg_match ( "\\s*Referrer\\s*:\\s*(.+?)\r?\n?$", line, &matches, &nmatches ) > 0 ) {
setenv ( "HTTP_REFERRER", matches[0], 1 );
for ( i=0; i < nmatches; i++ )
free ( matches[i] );
free ( matches );
matches = NULL;
}
}
free ( line );
@ -393,8 +590,17 @@ __AI_webservlet_thread ( void *arg )
fprintf ( sock, "%s%s", http_headers, http_response );
fclose ( sock );
close ( *sd );
close ( sd );
free ( arg );
if ( query_string )
free ( query_string );
if ( is_cgi )
free ( http_response );
pthread_exit ( 0 );
return (void*) 0;
} /* ----- end of function __AI_webservlet_thread ----- */
/**
@ -406,11 +612,12 @@ AI_webserv_thread ( void *arg )
{
int on = 1,
sd,
client_sd;
sockaddr_size;
struct sockaddr_in addr;
pthread_t servlet_thread;
pthread_attr_t attr;
conn_info *conn;
if (( sd = socket ( AF_INET, SOCK_STREAM, 0 )) < 0 )
{
@ -432,7 +639,7 @@ AI_webserv_thread ( void *arg )
AI_fatal_err ( "Error while binding socket", __FILE__, __LINE__ );
}
if ( listen ( sd, 10 ) < 0 )
if ( listen ( sd, 100 ) < 0 )
{
AI_fatal_err ( "Error while setting the socket in listen mode", __FILE__, __LINE__ );
}
@ -442,10 +649,15 @@ AI_webserv_thread ( void *arg )
while ( 1 )
{
if (( client_sd = accept ( sd, NULL, NULL )) < 0 )
if ( !( conn = (conn_info*) malloc ( sizeof ( conn_info ))))
continue;
if ( pthread_create ( &servlet_thread, &attr, __AI_webservlet_thread, (void*) &client_sd ) != 0 )
memset ( conn, 0, sizeof ( conn ));
if (( conn->sd = accept ( sd, (struct sockaddr*) &(conn->client), (socklen_t*) &sockaddr_size )) < 0 )
continue;
if ( pthread_create ( &servlet_thread, &attr, __AI_webservlet_thread, (void*) conn ) != 0 )
{
AI_fatal_err ( "Error while creating the webservlet thread", __FILE__, __LINE__ );
}