The original upstream from Debian orig.tar.gz tarball.0.9.7

9 files changed, 792 insertions, 0 deletions

diff --git a/wlp/C/Makefile b/wlp/C/Makefile
new file mode 100644
index 0000000..6bc8fc3
--- /dev/null
+++ b/wlp/C/Makefile
@@ -0,0 +1,43 @@
+CC=gcc
+AR=ar
+FLEX=flex
+YACC=bison
+
+CCOPTS=-Wall -ansi
+CCSHARED=-fPIC
+AROPTS=-rs
+FLEXOPTS=
+YACCOPTS=-d
+
+SRCDIR=.
+BINDIR=.
+
+OBJFILE=structs.o commands.tab.o lex.yy.o
+
+all: archive bin
+
+# archive file for python module
+archive: structs bison flex  /usr/lib/libfl.a macro.h structs.h commands.tab.h
+	$(AR) $(AROPTS)  $(BINDIR)/wlp.a $(OBJFILE) \
+		/usr/lib/libfl.a
+
+# binary (executable) file for testing
+executable: bin
+
+bin: structs bison flex  /usr/lib/libfl.a macro.h structs.h commands.tab.h
+	$(CC) $(CCSHARED) $(CCOPTS) $(OBJFILE) \
+		yytest.c /usr/lib/libfl.a -o ./yytest
+
+flex:
+	$(FLEX) $(FLEXOPTS) commands.l
+	$(CC) $(CCSHARED) -c lex.yy.c -o lex.yy.o
+
+bison:
+	$(YACC) $(YACCOPTS) -d commands.y -b commands
+	$(CC) $(CCSHARED) -c commands.tab.c -o commands.tab.o
+
+structs:
+	$(CC) $(CCSHARED) $(CCOPTS) -c structs.c -o structs.o 
+
+clean:
+	-rm $(OBJFILE) lex.yy.c commands.tab.h commands.tab.c wlp.a yytest
diff --git a/wlp/C/commands.l b/wlp/C/commands.l
new file mode 100644
index 0000000..8f0f28e
--- /dev/null
+++ b/wlp/C/commands.l
@@ -0,0 +1,75 @@
+%{
+/* Lex analyzer for bison grammar */
+
+#include "commands.tab.h"
+/*#define DEBUG*/
+#include "macro.h"
+%}
+
+OWNER "<"[a-zA-Z0-9_.+-]+@[a-zA-Z0-9._-]+">"
+VAL   ['`"][a-zA-Z0-9@_+.<>() -]+['`"]
+VAR   [a-zA-Z0-9_<>-]+[:]?
+
+%option noyywrap
+
+%%
+
+
+
+
+{OWNER}	{
+                DBG("OWNER %s\n",yytext);
+                yylval.text=yytext;
+                return(OWNERID);
+        }
+
+
+{VAL}	{
+                DBG("VAL %s\n",yytext);
+                yylval.text=yytext;
+                return(VALID);
+        }
+
+{VAR}	{
+		DBG("VAR %s\n",yytext);
+		yylval.text=yytext;
+		return(VARID);
+	}
+
+
+"{"	|
+"}"	|
+"="	{
+		yylval.text=yytext;
+		return(*yytext);
+	 }
+
+
+"#"[^\n]*	|
+"\n"		|
+[[:space:]]	;	/* comments 'til EOL and strip all spaces and \n */
+
+
+"."	{
+		DBG("NOTSTR %s\n",yytext);
+		yylval.text=yytext;
+		return(ERROR);
+	}
+
+
+%%
+
+#include "structs.h"
+
+extern struct wlp_list_t *list;
+
+int parse(FILE *file)
+{
+	struct wlp_node_t *tmp;
+	int count;
+	yyin=file;
+
+	DBG("go!\n");
+	yyparse();
+	DBG("EOF found\n");
+}
diff --git a/wlp/C/commands.y b/wlp/C/commands.y
new file mode 100644
index 0000000..8b720d7
--- /dev/null
+++ b/wlp/C/commands.y
@@ -0,0 +1,110 @@
+
+%{
+/*#define YYSTYPE 	char**/
+/*#define DEBUG*/
+#include "macro.h"
+%}
+
+%union {
+	char *text;
+	char c;
+}
+
+%token <text> VARID
+%token <text> VALID
+%token <text> OWNERID
+
+%token ERROR
+%token EOFTOK
+
+
+%{
+char left[80], right[80], owner[80];
+char type = 0; /*unused*/
+%}
+
+%%
+
+
+block:
+	blockstatement
+	| block  blockstatement
+	;
+	
+blockstatement:
+	owner '{' commandline '}'
+	;	
+	
+commandline: 
+	command | commandline command
+	;
+	
+command:
+	varpart '=' valpart { found(left,right,owner); }
+	;
+	
+owner:
+	OWNERID	{
+			DBG("Owner %s\n",$1);
+			strncpy(owner,$1,strlen($1)+1);
+		}
+	;
+
+varpart:
+	VARID	{
+			DBG("Left %s\n",$1);
+			strncpy(left,$1,strlen($1)+1);
+		}
+	;
+	
+valpart:
+	VALID	{
+			DBG("Right %s\n",$1);
+			strncpy(right,$1,strlen($1)+1);
+		}
+	;
+
+%%
+
+#include <ctype.h>
+#include <stdio.h>
+#include "structs.h"
+
+extern struct wlp_list_t *list;
+
+int yyerror (char *s)  /* Called by yyparse on error */
+{
+	printf ("error: %s\n", s);
+	return 1;
+}
+
+int found(const char* left, const char* right, const char *owner)
+{
+	static struct wlp_node_t *node;
+
+	/* alloc node with non-empty fields (ie alloc them too)*/
+	node = wlpn_alloc(FALSE);
+	if(!node) {
+		DBG("wlpn_alloc in found returned NULL\n");
+	}
+	
+	strncpy(node->right,right,strlen(right));
+	strncpy(node->left,left,strlen(left));
+	strncpy(node->owner,owner,strlen(owner));
+
+	#ifndef WITHQUOTES
+	/* remove quotes of value part */
+	node->right += 1;
+	node->right[strlen(node->right)-1] = '\0';
+	#endif
+	#ifndef WITHANGBRACKETS
+	/* remove angle brackets of owner part */
+	node->owner += 1;
+	node->owner[strlen(node->owner)-1] = '\0';
+	#endif
+
+	if(!list)
+		list = wlpl_init(node);
+	else
+		wlpn_add(list,node);
+}
diff --git a/wlp/C/macro.h b/wlp/C/macro.h
new file mode 100644
index 0000000..303b3c6
--- /dev/null
+++ b/wlp/C/macro.h
@@ -0,0 +1,44 @@
+/*
+ * macro.h - Copyright 2000, 2001 Cosimo Alfarano <Alfarano@CS.UniBo.It>
+ * You can use this software under the terms of the GPL. If we meet some day,
+ * and you think this stuff is worth it, you can buy me a beer in return.
+ *
+ * Thanks to md for this useful formula. Beer is beer.
+ */
+
+
+#ifndef _macro_h_
+#define _macro_h_
+
+#define LINELEN		2048
+#define TRUE		1
+#define FALSE		0
+
+/*
+#define WITHQUOTES 
+#define WITHANGBRACKETS
+*/
+
+#define ERR(a,b...)     fprintf(stderr, a, ## b)
+
+/* Define it for debug info on stderr (better if in .c module ...) */
+/*
+#ifndef DEBUG
+	#define DEBUG
+#endif
+*/
+
+
+#ifdef DEBUG
+        #define DBG(a...)	fprintf(stderr,  ## a)
+	/* for a verbose debug*/
+        #define VDBG(a,b...)	fprintf(stderr, "%s(): " a, __FUNCTION__ , ## b)
+#else
+        #define DBG(a...)
+        #define VDBG(a...)
+#endif
+
+
+#endif
+
+/* EOF */
diff --git a/wlp/C/structs.c b/wlp/C/structs.c
new file mode 100644
index 0000000..8c33443
--- /dev/null
+++ b/wlp/C/structs.c
@@ -0,0 +1,164 @@
+/*
+ * structs.c - Copyright 2000 by Cosimo Alfarano <Alfarano@CS.UniBo.It>
+ * You can use this software under the terms of the GPL. If we meet some day,
+ * and you think this stuff is worth it, you can buy me a beer in return.
+ *
+ * Thanks to md for this useful formula. Beer is beer.
+ */
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include "structs.h"
+#include "macro.h"
+
+struct wlp_node_t *wlpn_add(struct wlp_list_t *list,struct wlp_node_t *node)
+{
+	struct wlp_node_t *ret;
+	
+	if(node) {
+		node->next = list->head;
+		node->prev = list->tail;
+		
+		list->tail->next = node;
+		list->head->prev = node;
+
+		list->tail = node;
+
+		list->count++;
+		
+		ret = node;
+	} else {
+		DBG("cannot add %s %s to list. NULL pointer?\n",
+			node->left,node->right);
+		ret = NULL;	
+	}
+
+	return ret;
+}
+
+void wlpn_free(struct wlp_node_t *node)
+{
+	free(node->left);
+	free(node->right);
+	free(node->owner);
+	free(node);
+}
+
+
+struct wlp_node_t *wlpn_alloc(const char empty)
+{
+	static struct wlp_node_t *node;
+
+	node = calloc(sizeof(struct wlp_node_t),1);
+
+	if (!node) {
+		perror("wlpn_create malloc");	
+		
+	/* calloc set *node to zero, it I don't want alloc anything,
+	   leave it untouched, else alloc fields */
+	} else if (!empty) {
+		node->left = calloc(LINELEN+1,1);
+		if (!node->left) {
+			perror("wlpn_create malloc (left)");
+			free(node);
+			node = NULL;
+		}
+
+		/*if node is NULL, previous calloc returned error...*/
+		if(node && !(node->right = calloc(LINELEN+1,1))) {
+			perror("wlpn_create malloc (right)");
+			free(node);
+			node = NULL;
+		}
+	
+		if(node && !(node->owner = calloc(LINELEN+1,1))) {
+			perror("wlpn_create malloc (owner)");
+			free(node);
+			node = NULL;
+		}
+	}	
+	return node;
+}
+
+struct wlp_list_t *wlpl_init(struct wlp_node_t *node)
+{
+	static struct wlp_list_t *list;
+
+	list = malloc(sizeof(struct wlp_list_t));
+
+	if (list) {
+		list->head = node;
+		list->tail = list->head;
+
+		list->head->next = list->head;
+		list->head->prev = list->head;
+
+		list->count=1;
+	} else {
+                perror("wlpl_init malloc");
+                return NULL;
+	}
+	
+	return list;
+}
+
+
+struct wlp_node_t *wlpn_searchowner(struct wlp_list_t *mbl,const char *owner)
+{
+	struct wlp_node_t *ret;
+
+	DBG("searching for %s\n",owner);
+
+	if(!mbl)
+		ret = NULL;
+	else {
+		int found = FALSE;
+		ret = mbl->head;
+
+		do {
+			if(!strcmp(owner,ret->owner)) {
+				DBG("found!\n");
+				found = TRUE;
+			} else {
+				DBG("not found: %s\n",ret->onwer);
+				ret = ret->next;
+			}
+		} while(ret != mbl->head && !found);
+
+		if(!found)
+			ret = NULL;
+	}
+
+	DBG("%s\n", (ret)?ret->owner:"not found");
+	
+	return ret;
+}
+
+
+struct wlp_node_t *wlpn_extract(struct wlp_list_t *list,struct wlp_node_t *node)
+{
+	struct wlp_node_t *ret;
+	
+	if(list && node) {
+		node->prev->next = node->next;
+		node->next->prev = node->prev;
+
+		if(list->tail == node)
+			list->tail = node->prev;
+		if(list->head == node)
+			list->head = node->next;
+
+		list->count--;
+		
+		ret = node;
+	} else {
+		DBG("wlpn_extract: list addr %l and node %l (one is NULL)\n",list,addr)
+		ret = NULL;
+	}
+
+	return ret;
+}
diff --git a/wlp/C/structs.h b/wlp/C/structs.h
new file mode 100644
index 0000000..92036a7
--- /dev/null
+++ b/wlp/C/structs.h
@@ -0,0 +1,35 @@
+/*
+ * structs.h - Copyright 2000, 2001 by Cosimo Alfarano <Alfarano@CS.UniBo.It>
+ * You can use this software under the terms of the GPL. If we meet some day,
+ * and you think this stuff is worth it, you can buy me a beer in return.
+ *
+ * Thanks to md for this useful formula. Beer is beer.
+ */
+
+#ifndef _structs_h_
+#define _structs_h_
+
+typedef struct wlp_node_t {
+        char *left,*right;
+	char *owner;
+	char type;		/* unused */
+        struct wlp_node_t *next, *prev;
+} wlp_node_t;
+
+typedef struct wlp_list_t {
+        int count;
+        struct wlp_node_t *head, *tail;
+} wlp_list_t;
+
+
+/* white list parser data structure manipulation */
+struct wlp_list_t *wlpl_init(struct wlp_node_t *node);
+struct wlp_node_t *wlpn_alloc(const char empty);
+void wlpn_free(struct wlp_node_t *node);
+struct wlp_node_t *wlpn_add(struct wlp_list_t *wlpl,struct wlp_node_t *wlpn);
+struct wlp_node_t *wlpn_extract(struct wlp_list_t *wlpl,struct wlp_node_t *wlpn);
+/*struct wlp_node_t *wlpn_search(struct wlp_list_t *wlpl,const char id);*/
+
+#endif /* _structs_h_  */
+
+/* EOF */
diff --git a/wlp/C/test.c b/wlp/C/test.c
new file mode 100644
index 0000000..47717b5
--- /dev/null
+++ b/wlp/C/test.c
@@ -0,0 +1,113 @@
+#include <python2.1/Python.h> /* should be modified to be pythonX.Y */
+#include <stdio.h>
+#include <unistd.h>
+
+#include "structs.h"
+#include "macro.h"
+
+/* first declare static functions */
+
+struct wlp_list_t *list;
+
+static FILE *fd = NULL;
+
+static PyObject *node2dict(struct wlp_node_t *node);
+
+static PyObject *wlp_setfilebyname(PyObject *self, PyObject *args) {
+	char *file;
+
+	DBG("setfilebyname\n");
+	if (!PyArg_ParseTuple(args, "s", &file))
+		return NULL;
+
+	fd = fopen(file,"r");
+
+	return Py_None;
+}
+
+static PyObject *wlp_setfilebyfd(PyObject *self, PyObject *args) {
+	PyObject *file = NULL;
+	
+        if (!PyArg_ParseTuple(args, "O", &file))
+		return NULL;
+
+	if(!file)
+		return NULL;
+
+	if(!PyFile_Check(file))
+		return NULL;
+
+	fd = PyFile_AsFile(file);
+
+	return Py_None;
+	
+}
+
+
+
+static PyObject *wlp_mklist(PyObject *self, PyObject *args) {
+	struct wlp_node_t *tmp;
+	int count;
+
+	PyObject *pylist = NULL;
+
+	DBG("a\n");
+	parse(fd);
+
+	DBG("count %d\n"list->count);
+	pylist = PyList_New(0);
+
+	DBG("a\n");
+	if(!pylist)
+		return NULL;
+	
+	DBG("a\n");
+	if(list)
+		for(tmp = list->head, count=0;
+		    tmp != list->head || count == 0;
+		    tmp = tmp->next, count++) {
+			DBG("FOUND(%d) '%s' ('%s': '%s')\n",count,tmp->owner,tmp->left,tmp->right);
+			if(PyList_Append(pylist,node2dict(tmp))==-1) {
+				DBG("List failed\n");
+				return NULL;
+			}
+			DBG("a\n");
+		}
+
+	return pylist;
+}
+
+
+static PyObject *node2dict(struct wlp_node_t *node) {
+	PyObject *dict = PyDict_New();
+
+	if(!dict)
+		return NULL;
+	
+	PyDict_SetItem(dict,
+		Py_BuildValue("s","owner"),
+		Py_BuildValue("s",node->owner));
+	
+	PyDict_SetItem(dict,
+		Py_BuildValue("s",node->left),
+		Py_BuildValue("s",node->right));
+
+	return dict;
+
+}
+
+/* second a table with methods/functions matching  */
+
+static PyMethodDef wlp_methods[] = {
+	{"mklist", wlp_mklist, METH_VARARGS},
+	{"setfilebyname", wlp_setfilebyname, METH_VARARGS},
+	{"setfilebyfd", wlp_setfilebyfd, METH_VARARGS},
+	{NULL,NULL}
+};
+
+
+/* last the init function, the only one non-static */
+
+void initwlp() {
+	(void) Py_InitModule("wlp",wlp_methods);
+}
diff --git a/wlp/C/wlp.c b/wlp/C/wlp.c
new file mode 100644
index 0000000..8c0779d
--- /dev/null
+++ b/wlp/C/wlp.c
@@ -0,0 +1,183 @@
+/*
+ * wlp.c - Copyright 2000, 2001 by Cosimo Alfarano <Alfarano@CS.UniBo.It>
+ * You can use this software under the terms of the GPL. If we meet some day,
+ * and you think this stuff is worth it, you can buy me a beer in return.
+ *
+ * Thanks to md for this useful formula. Beer is beer.
+ */
+
+//#include <python/Python.h>
+#include <Python.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "structs.h"
+#include "macro.h"
+
+
+static FILE *fd = NULL;
+
+struct wlp_list_t *list;
+
+static PyObject *node2dict(struct wlp_node_t *node);
+static PyObject *node2dict2(struct wlp_node_t *node);
+
+
+
+
+/* 
+ * wlp_setfilebyname(): get FILE* fd from filename string.
+ */
+
+static PyObject *wlp_setfilebyname(PyObject *self, PyObject *args) {
+	char *file;
+
+	
+	DBG("setfilebyname\n");
+	if (!PyArg_ParseTuple(args, "s", &file))
+		return NULL;
+
+	if(fd = fopen(file,"r")) {
+		return Py_None;
+	} else {
+		PyErr_SetFromErrno(PyExc_Exception);
+/*	
+		    PyErr_SetString(PyExc_Exception,
+		    (errno<=sys_nerr-1)?
+		    sys_errlist[errno]:
+		    "Unknown Error on fopen() of confifuration file");
+*/		
+		return NULL;
+	}
+}
+
+
+
+/* 
+ * wlp_setfilebydf(): get FILE* fd from FileObject.
+ */
+
+static PyObject *wlp_setfilebyfd(PyObject *self, PyObject *args) {
+	PyObject *file = NULL;
+	
+        if(!PyArg_ParseTuple(args, "O", &file))
+		return NULL;
+
+	if(!file)
+		return NULL;
+
+	if(!PyFile_Check(file))
+		return NULL;
+
+	fd = PyFile_AsFile(file);
+
+	return Py_None;
+}
+
+/* 
+ * wlp_mkdict(): make a dictonary of the form
+ * {ownername: {var1: val1, var2: val2,...}}
+ */
+
+static PyObject *wlp_mkdict(PyObject *self, PyObject *args) {
+	PyObject *pydicttmp = NULL;
+	PyObject *pydict = PyDict_New();
+	struct wlp_node_t *tmp;
+	int count;
+
+	if(!pydict)
+		return NULL;
+
+	/* fopen()*/
+	if(fd)
+		parse(fd);
+	else
+		return Py_None;
+	
+	if(list)
+		for(tmp = list->head, count = 0;
+		    tmp != list->head || count == 0;
+		    tmp = tmp->next, count++) {
+			DBG("FOUND(%d) '%s' ('%s': '%s')\n",count,tmp->owner,tmp->left,tmp->right);
+			pydicttmp = PyDict_GetItem(pydict,
+				PyString_FromString(tmp->owner));
+
+			if(!pydicttmp) {
+				DBG("%s: owner not found, create new item\n",
+					tmp->owner);
+				PyDict_SetItemString(pydict,
+					tmp->owner,
+					node2dict(tmp));
+			} else {
+				DBG("%s: owner found,appendig items\n",
+					tmp->owner);
+				PyDict_SetItemString(pydicttmp,
+					tmp->left,
+					Py_BuildValue("s",tmp->right));
+				PyDict_SetItemString(pydict,
+					tmp->owner,
+					pydicttmp);
+			}
+		}
+
+	return pydict;
+}
+
+/* 
+ * node2dict(): transoform a wlp_node_t node in a python dictionary of the form
+ *	 { var: val }
+ * to be used by mkdict()
+ */
+
+static PyObject *node2dict(struct wlp_node_t *node) {
+	PyObject *dict = PyDict_New();
+
+	if(!dict)
+		dict = Py_None;
+	else {
+		PyDict_SetItem(dict,
+			Py_BuildValue("s",node->left),
+			Py_BuildValue("s",node->right));
+	}
+
+	return dict;
+
+}
+
+
+/* 
+ * node2dict2(): transoform a wlp_node_t node in a python dictionary of the form
+ *	{ 'owner': ownername, var: val}
+ * it's currently unused (obsoleted)
+ */
+
+static PyObject *node2dict2(struct wlp_node_t *node) {
+	PyObject *dict = PyDict_New();
+
+	if(!dict)
+		dict = Py_None;
+	else {
+		PyDict_SetItem(dict,
+			Py_BuildValue("s","owner"),
+			Py_BuildValue("s",node->owner));
+	
+		PyDict_SetItem(dict,
+			Py_BuildValue("s",node->left),
+			Py_BuildValue("s",node->right));
+	}
+
+	return dict;
+
+}
+
+static PyMethodDef wlp_methods[] = {
+	{"mkdict", wlp_mkdict, METH_VARARGS},
+	{"setfilebyname", wlp_setfilebyname, METH_VARARGS},
+	{"setfilebyfd", wlp_setfilebyfd, METH_VARARGS},
+	{NULL,NULL}
+};
+
+
+void initwlp() {
+	(void) Py_InitModule("wlp",wlp_methods);
+}
diff --git a/wlp/C/yytest.c b/wlp/C/yytest.c
new file mode 100644
index 0000000..74c6fe7
--- /dev/null
+++ b/wlp/C/yytest.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+#include "structs.h"
+#include "macro.h"
+
+
+
+int parse(FILE *file);
+
+struct wlp_list_t *list;
+
+int main(int argc,char **argv) {
+	struct wlp_node_t *tmp;
+	int count;
+
+	parse(NULL);
+
+	if(list)
+		for(tmp = list->head, count=0; 
+		    tmp != list->head || count == 0;
+		    tmp = tmp->next, count++)
+			printf("FOUND(%d) '%s' '%s' '%s'\n",count,tmp->left,tmp->right,tmp->owner);
+
+	return(0);
+}