uemf.h

嵌入式Linux系统用的web server,开源代码,非常好用

#define B_FILL_WORD		(0x77777777)		/* Fill word for buffers */
#define B_MAX_BLOCKS	(64 * 1024)			/* Maximum allocated blocks */

/*
 *	Flags. The integrity value is used as an arbitrary value to fill the flags.
 */
#define B_INTEGRITY			0x8124000		/* Integrity value */
#define B_INTEGRITY_MASK	0xFFFF000		/* Integrity mask */
#define B_USE_MALLOC		0x1				/* Okay to use malloc if required */
#define B_USER_BUF			0x2				/* User supplied buffer for mem */

/*
 *	The symbol table record for each symbol entry
 */

typedef struct sym_t {
	struct sym_t	*forw;					/* Pointer to next hash list */
	value_t			name;					/* Name of symbol */
	value_t			content;				/* Value of symbol */
	int				arg;					/* Parameter value */
} sym_t;

typedef int sym_fd_t;						/* Returned by symOpen */

/*
 *	Script engines
 */
#define EMF_SCRIPT_JSCRIPT			0		/* javascript */
#define EMF_SCRIPT_TCL	 			1		/* tcl */
#define EMF_SCRIPT_EJSCRIPT 		2		/* Ejscript */
#define EMF_SCRIPT_MAX	 			3

#define	MAXINT		INT_MAX
#define BITSPERBYTE 8
#define BITS(type)	(BITSPERBYTE * (int) sizeof(type))
#define	STRSPACE	T("\t \n\r\t")

#ifndef max
#define max(a,b)  (((a) > (b)) ? (a) : (b))
#endif /* max */

#ifndef min
#define min(a,b)  (((a) < (b)) ? (a) : (b))
#endif /* min */

/******************************************************************************/
/*                                  CRON                                      */
/******************************************************************************/

typedef struct {
	char_t	*minute;
	char_t	*hour;
	char_t	*day;
	char_t	*month;
	char_t	*dayofweek;
} cron_t;

extern long		cronUntil(cron_t *cp, int period, time_t testTime);
extern int		cronAlloc(cron_t *cp, char_t *str);
extern int		cronFree(cron_t *cp);

/******************************************************************************/
/*                                 SOCKET                                     */
/******************************************************************************/
/*
 *	Socket flags 
 */

#if ((defined (WIN) || defined (CE)) && defined (WEBS))
#define EWOULDBLOCK             WSAEWOULDBLOCK
#define ENETDOWN                WSAENETDOWN
#define ECONNRESET              WSAECONNRESET
#endif /* (WIN || CE) && WEBS) */

#define SOCKET_EOF				0x1		/* Seen end of file */
#define SOCKET_CONNECTING		0x2		/* Connect in progress */
#define SOCKET_BROADCAST		0x4		/* Broadcast mode */
#define SOCKET_PENDING			0x8		/* Message pending on this socket */
#define SOCKET_FLUSHING			0x10	/* Background flushing */
#define SOCKET_DATAGRAM			0x20	/* Use datagrams */
#define SOCKET_ASYNC			0x40	/* Use async connect */
#define SOCKET_BLOCK			0x80	/* Use blocking I/O */
#define SOCKET_LISTENING		0x100	/* Socket is server listener */
#define SOCKET_CLOSING			0x200	/* Socket is closing */
#define SOCKET_CONNRESET		0x400	/* Socket connection was reset */

#define SOCKET_PORT_MAX			0xffff	/* Max Port size */

/*
 *	Socket error values
 */
#define SOCKET_WOULDBLOCK		1		/* Socket would block on I/O */
#define SOCKET_RESET			2		/* Socket has been reset */
#define SOCKET_NETDOWN			3		/* Network is down */
#define SOCKET_AGAIN			4		/* Issue the request again */
#define SOCKET_INTR				5		/* Call was interrupted */
#define SOCKET_INVAL			6		/* Invalid */

/*
 *	Handler event masks
 */
#define SOCKET_READABLE			0x2		/* Make socket readable */ 
#define SOCKET_WRITABLE			0x4		/* Make socket writable */
#define SOCKET_EXCEPTION		0x8		/* Interested in exceptions */
#define EMF_SOCKET_MESSAGE		(WM_USER+13)

#ifdef LITTLEFOOT
#define SOCKET_BUFSIZ			510		/* Underlying buffer size */
#else
#define SOCKET_BUFSIZ			1024	/* Underlying buffer size */
#endif /* LITTLEFOOT */

typedef void 	(*socketHandler_t)(int sid, int mask, int data);
typedef int		(*socketAccept_t)(int sid, char *ipaddr, int port, 
					int listenSid);
typedef struct {
	char			host[64];				/* Host name */
	ringq_t			inBuf;					/* Input ring queue */
	ringq_t			outBuf;					/* Output ring queue */
	ringq_t			lineBuf;				/* Line ring queue */
	socketAccept_t	accept;					/* Accept handler */
	socketHandler_t	handler;				/* User I/O handler */
	int				handler_data;			/* User handler data */
	int				handlerMask;			/* Handler events of interest */
	int				sid;					/* Index into socket[] */
	int				port;					/* Port to listen on */
	int				flags;					/* Current state flags */
	int				sock;					/* Actual socket handle */
	int				fileHandle;				/* ID of the file handler */
	int				interestEvents;			/* Mask of events to watch for */
	int				currentEvents;			/* Mask of ready events (FD_xx) */
	int				selectEvents;			/* Events being selected */
	int				saveMask;				/* saved Mask for socketFlush */
	int				error;					/* Last error */
} socket_t;

/********************************* Prototypes *********************************/
/*
 *	Balloc module
 *
 */

extern void 	 bclose();
extern int 		 bopen(void *buf, int bufsize, int flags);

/*
 *	Define NO_BALLOC to turn off our balloc module altogether
 *		#define NO_BALLOC 1
 */

#ifdef NO_BALLOC
#define balloc(B_ARGS, num) malloc(num)
#define bfree(B_ARGS, p) free(p)
#define bfreeSafe(B_ARGS, p) \
	if (p) { free(p); } else
#define brealloc(B_ARGS, p, num) realloc(p, num)
extern char_t *bstrdupNoBalloc(char_t *s);
extern char *bstrdupANoBalloc(char *s);
#define bstrdup(B_ARGS, s) bstrdupNoBalloc(s)
#define bstrdupA(B_ARGS, s) bstrdupANoBalloc(s)
#define gstrdup(B_ARGS, s) bstrdupNoBalloc(s)

#else /* BALLOC */

#ifndef B_STATS
#define balloc(B_ARGS, num) balloc(num)
#define bfree(B_ARGS, p) bfree(p)
#define bfreeSafe(B_ARGS, p) bfreeSafe(p)
#define brealloc(B_ARGS, p, size) brealloc(p, size)
#define bstrdup(B_ARGS, p) bstrdup(p)

#ifdef UNICODE
#define bstrdupA(B_ARGS, p) bstrdupA(p)
#else /* UNICODE */
#define bstrdupA bstrdup
#endif /* UNICODE */

#endif /* B_STATS */

#define gstrdup	bstrdup
extern void		*balloc(B_ARGS_DEC, int size);
extern void		bfree(B_ARGS_DEC, void *mp);
extern void		bfreeSafe(B_ARGS_DEC, void *mp);
extern void		*brealloc(B_ARGS_DEC, void *buf, int newsize);
extern char_t	*bstrdup(B_ARGS_DEC, char_t *s);

#ifdef UNICODE
extern char *bstrdupA(B_ARGS_DEC, char *s);
#else /* UNICODE */
#define bstrdupA bstrdup
#endif /* UNICODE */
#endif /* BALLOC */

extern void bstats(int handle, void (*writefn)(int handle, char_t *fmt, ...));

/*
 *	Flags. The integrity value is used as an arbitrary value to fill the flags.
 */
#define B_USE_MALLOC		0x1				/* Okay to use malloc if required */
#define B_USER_BUF			0x2				/* User supplied buffer for mem */


#ifndef LINUX
extern char_t	*basename(char_t *name);
#endif /* !LINUX */

#if (defined (UEMF) && defined (WEBS))
/*
 *	The open source webserver uses a different callback/timer mechanism
 *	than other emf derivative products such as FieldUpgrader agents
 *	so redefine those API for webserver so that they can coexist in the
 *	same address space as the others.
 */
#define emfSchedCallback	websSchedCallBack
#define emfUnschedCallback	websUnschedCallBack
#define emfReschedCallback	websReschedCallBack
#endif /* UEMF && WEBS */

typedef void	(emfSchedProc)(void *data, int id);
extern int		emfSchedCallback(int delay, emfSchedProc *proc, void *arg);
extern void 	emfUnschedCallback(int id);
extern void 	emfReschedCallback(int id, int delay);
extern void		emfSchedProcess();
extern int		emfInstGet();
extern void		emfInstSet(int inst);
extern void		error(E_ARGS_DEC, int flags, char_t *fmt, ...);
extern void		(*errorSetHandler(void (*function)(int etype, char_t *msg))) \
					(int etype, char_t *msg);

#ifdef B_STATS
#define 		hAlloc(x) 				HALLOC(B_L, x)
#define			hAllocEntry(x, y, z)	HALLOCENTRY(B_L, x, y, z)
extern int		HALLOC(B_ARGS_DEC, void ***map);
extern int 		HALLOCENTRY(B_ARGS_DEC, void ***list, int *max, int size);
#else
extern int		hAlloc(void ***map);
extern int 		hAllocEntry(void ***list, int *max, int size);
#endif /* B_STATS */

extern int		hFree(void ***map, int handle);

extern int	 	ringqOpen(ringq_t *rq, int increment, int maxsize);
extern void 	ringqClose(ringq_t *rq);
extern int 		ringqLen(ringq_t *rq);

extern int 		ringqPutc(ringq_t *rq, char_t c);
extern int	 	ringqInsertc(ringq_t *rq, char_t c);
extern int	 	ringqPutStr(ringq_t *rq, char_t *str);
extern int 		ringqGetc(ringq_t *rq);

extern int		fmtValloc(char_t **s, int n, char_t *fmt, va_list arg);
extern int		fmtAlloc(char_t **s, int n, char_t *fmt, ...);
extern int		fmtStatic(char_t *s, int n, char_t *fmt, ...);

#ifdef UNICODE
extern int 		ringqPutcA(ringq_t *rq, char c);
extern int	 	ringqInsertcA(ringq_t *rq, char c);
extern int	 	ringqPutStrA(ringq_t *rq, char *str);
extern int 		ringqGetcA(ringq_t *rq);
#else
#define ringqPutcA ringqPutc
#define ringqInsertcA ringqInsertc
#define ringqPutStrA ringqPutStr
#define ringqGetcA ringqGetc
#endif /* UNICODE */

extern int 		ringqPutBlk(ringq_t *rq, unsigned char *buf, int len);
extern int 		ringqPutBlkMax(ringq_t *rq);
extern void 	ringqPutBlkAdj(ringq_t *rq, int size);
extern int 		ringqGetBlk(ringq_t *rq, unsigned char *buf, int len);
extern int 		ringqGetBlkMax(ringq_t *rq);
extern void 	ringqGetBlkAdj(ringq_t *rq, int size);
extern void 	ringqFlush(ringq_t *rq);
extern void 	ringqAddNull(ringq_t *rq);

extern int		scriptSetVar(int engine, char_t *var, char_t *value);
extern int		scriptEval(int engine, char_t *cmd, char_t **rslt, int chan);

extern void		socketClose();
extern void		socketCloseConnection(int sid);
extern void		socketCreateHandler(int sid, int mask, socketHandler_t 
					handler, int arg);
extern void		socketDeleteHandler(int sid);
extern int		socketEof(int sid);
extern int 		socketCanWrite(int sid);
extern void 	socketSetBufferSize(int sid, int in, int line, int out);
extern int		socketFlush(int sid);
extern int		socketGets(int sid, char_t **buf);
extern int		socketGetPort(int sid);
extern int		socketInputBuffered(int sid);
extern int		socketOpen();
extern int 		socketOpenConnection(char *host, int port, 
					socketAccept_t accept, int flags);
extern void 	socketProcess(int hid);
extern int		socketRead(int sid, char *buf, int len);
extern int 		socketReady(int hid);
extern int		socketWrite(int sid, char *buf, int len);
extern int		socketWriteString(int sid, char_t *buf);
extern int 		socketSelect(int hid, int timeout);
extern int 		socketGetHandle(int sid);
extern int 		socketSetBlock(int sid, int flags);
extern int 		socketGetBlock(int sid);
extern int 		socketAlloc(char *host, int port, socketAccept_t accept, 
					int flags);
extern void 	socketFree(int sid);
extern int		socketGetError();
extern socket_t *socketPtr(int sid);
extern int 		socketWaitForEvent(socket_t *sp, int events, int *errCode);
extern void 	socketRegisterInterest(socket_t *sp, int handlerMask);
extern int 		socketGetInput(int sid, char *buf, int toRead, int *errCode);

extern char_t	*strlower(char_t *string);
extern char_t	*strupper(char_t *string);

extern char_t	*stritoa(int n, char_t *string, int width);

extern sym_fd_t	symOpen(int hash_size);
extern void		symClose(sym_fd_t sd);
extern sym_t	*symLookup(sym_fd_t sd, char_t *name);
extern sym_t	*symEnter(sym_fd_t sd, char_t *name, value_t v, int arg);
extern int		symDelete(sym_fd_t sd, char_t *name);
extern void 	symWalk(sym_fd_t sd, void (*fn)(sym_t *symp));
extern sym_t	*symFirst(sym_fd_t sd);
extern sym_t	*symNext(sym_fd_t sd);
extern int		symSubOpen();
extern void 	symSubClose();

extern void		trace(int lev, char_t *fmt, ...);
extern void		traceRaw(char_t *buf);
extern void		(*traceSetHandler(void (*function)(int level, char_t *buf))) 
					(int level, char_t *buf);
 
extern value_t 	valueInteger(long value);
extern value_t	valueString(char_t *value, int flags);
extern value_t	valueErrmsg(char_t *value);
extern void 	valueFree(value_t *v);
extern int		vxchdir(char *dirname);

extern unsigned int hextoi(char_t *hexstring);
extern unsigned int gstrtoi(char_t *s);
extern				time_t	timeMsec();

extern char_t 	*ascToUni(char_t *ubuf, char *str, int nBytes);
extern char 	*uniToAsc(char *buf, char_t *ustr, int nBytes);
extern char_t	*ballocAscToUni(char  *cp, int alen);
extern char		*ballocUniToAsc(char_t *unip, int ulen);

extern char_t	*basicGetHost();
extern char_t	*basicGetAddress();
extern char_t	*basicGetProduct();
extern void		basicSetHost(char_t *host);
extern void		basicSetAddress(char_t *addr);

extern int		harnessOpen(char_t **argv);
extern void		harnessClose(int status);
extern void		harnessTesting(char_t *msg, ...);
extern void		harnessPassed();
extern void		harnessFailed(int line);
extern int		harnessLevel();

#endif /* _h_UEMF */

/******************************************************************************/