linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

get it to build

Browse Source
This commit is contained in:
Douglas Clowes
2012-11-27 13:34:05 +11:00
parent ca11a3cfe4
commit 27e89241cf
11 changed files with 502 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

274
servlog.c
View File

@@ -47,12 +47,15 @@
- NETWrites log message (if enabled) before attempt to write to file
- uses OpenVerifyLogFile helper function (removed duplicate code)
-----------------------------------------------------------------------------*/
#include <stdarg.h>
#include "fortify.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <sys/time.h>
#include <strlutil.h>
#include "ifile.h"
@@ -126,7 +129,7 @@ int LogCapture(SConnection * pCon, SicsInterp * pSics, void *pData,
/* check no af args */
if (argc < 2) {
snprintf(pBueffel,sizeof(pBueffel)-1, "Insufficient number of argumenst to %s", argv[0]);
snprintf(pBueffel,sizeof(pBueffel)-1, "Insufficient number of arguments to %s", argv[0]);
SCWrite(pCon, pBueffel, eError);
return 0;
}
@@ -203,8 +206,32 @@ static int HasLineFeed(char *pText)
}
/*---------------------------------------------------------------------------*/
#define MAXLOG 10000
#define MAXFILES 20
static const char* timestamp(struct timeval *tp) {
static char ts[80];
int year, month, day;
int hour, min, sec, usec;
struct timeval tv;
struct tm *time;
if (tp)
tv = *tp;
else
gettimeofday(&tv, NULL);
time = localtime(&tv.tv_sec);
year = 1900 + time->tm_year;
month = time->tm_mon + 1;
day = time->tm_mday;
hour = time->tm_hour;
min = time->tm_min;
sec = time->tm_sec;
usec = (int) tv.tv_usec;
snprintf(ts, 80, "%04d-%02d-%02dT%02d:%02d:%02d.%06d",
year, month, day, hour, min, sec, usec);
return ts;
}
/*---------------------------------------------------------------------------*/
#define MAXLOG 100000
#define MAXFILES 100
static FILE *fLogFile = NULL;
static int iFile = 0;
@@ -217,6 +244,10 @@ int OpenVerifyLogFile()
char pFile[256];
char filnam[512];
char *pChar = NULL;
char fPath[1024];
/* snprintf(fPath, 1023, "%s/", getenv("SICS_INIT_LOGPATH")); */
snprintf(fPath, 1023, "%s/", "../log");
pChar = IFindOption(pSICSOptions, "LogFileBaseName");
if (!pChar) { /* Try to write to file "server" in */
@@ -224,7 +255,9 @@ int OpenVerifyLogFile()
} else {
strlcpy(pFile, pChar, 255);
}
snprintf(filnam, 511, "%s%2.2d.log", pFile, iFile);
snprintf(filnam, 511, "%s%s_%19.19s.%02d.log", fPath, pFile, timestamp(NULL), iFile);
fLogFile = fopen(filnam, "w");
if (!fLogFile) {
fprintf(stderr, "ERROR: Cannot open logfile %s for writing\n", pFile);
@@ -242,23 +275,23 @@ void SICSLogEnable(int flag)
}
/*---------------------------------------------------------------------------*/
void SICSLogWrite(char *pText, OutCode eOut)
static void SICSLogWriteFile(char *pText, OutCode eOut, struct timeval *tp)
{
char pFile[256];
char *pChar = NULL;
pCaptureEntry pCurrent;
char pBueffel[256];
int text_len;
#ifdef NOLOG
return;
#endif
text_len = strlen(pText);
/* do all captured */
pCurrent = pCapture;
while (pCurrent) {
if ((pCurrent->iOut == eOut) || (pCurrent->iAllFlag == 1)) {
ANETwrite(pCurrent->pCon->sockHandle, pText, strlen(pText));
ANETwrite(pCurrent->pCon->sockHandle, "\n", 1);
ANETwrite(pCurrent->pCon->sockHandle, pText, text_len);
if (pText[text_len - 1] != '\n')
ANETwrite(pCurrent->pCon->sockHandle, "\n", 1);
}
pCurrent = pCurrent->pNext;
}
@@ -277,6 +310,7 @@ void SICSLogWrite(char *pText, OutCode eOut)
/* switch file if too many lines */
if (iLineCount >= MAXLOG) {
fprintf(fLogFile,"%s: <<<close logfile>>>\n", timestamp(NULL));
fclose(fLogFile);
fLogFile = NULL;
iFile++;
@@ -287,9 +321,225 @@ void SICSLogWrite(char *pText, OutCode eOut)
iLogUsable = OpenVerifyLogFile();
}
if (1 == iLogUsable) {
fprintf(fLogFile, "%s\n", pText);
if(1 == iLogUsable)
{
if (iLineCount == 0)
fprintf(fLogFile,"%s: <<<open logfile>>>\n", timestamp(NULL));
fprintf(fLogFile,"%s: ", timestamp(tp));
fprintf(fLogFile,"%s", pText);
if (text_len < 1 || pText[text_len - 1] != '\n')
fprintf(fLogFile,"\n");
fflush(fLogFile);
iLineCount++;
}
}
void SICSLogWriteTime(char *pText, OutCode eOut, struct timeval *tp) {
char buf[200];
const char *cp = pText;
int idx = 0;
struct timeval tv;
if (tp == NULL) {
gettimeofday(&tv, NULL);
tp = &tv;
}
while (*cp) {
if (*cp == '\n') {
buf[idx++] = '\n';
buf[idx++] = '\0';
SICSLogWriteFile(buf, eOut, tp);
idx = 0;
}
else if (*cp == '\r') {
buf[idx++] = '\\';
buf[idx++] = 'r';
}
else if (*cp == '\t') {
buf[idx++] = '\\';
buf[idx++] = 't';
}
else if (*cp < ' ' || *cp > '~') {
const char hex[] = "0123456789ABCDEF";
buf[idx++] = '<';
buf[idx++] = hex[(*cp >> 4) & 0xF];
buf[idx++] = hex[(*cp) & 0xF];
buf[idx++] = '>';
}
else {
buf[idx++] = *cp;
}
cp++;
if (idx > 132) {
buf[idx++] = '\n';
buf[idx++] = '\0';
SICSLogWriteFile(buf, eOut, tp);
idx = 0;
}
}
if (idx > 0) {
buf[idx++] = '\n';
buf[idx++] = '\0';
SICSLogWriteFile(buf, eOut, tp);
}
}
void SICSLogWrite(char *pText, OutCode eOut) {
struct timeval tv;
gettimeofday(&tv, NULL);
SICSLogWriteTime(pText, eOut, &tv);
}
void SICSLogWriteHexTime(const char* text, int count, OutCode eOut, struct timeval *tp) {
const char hex[] = "0123456789ABCDEF";
char addr[20], left[80], right[80];
char *lp = left;
char *rp = right;
int i;
int duplicates;
/* Limit the output */
if (count > 1024)
count = 1024;
duplicates = 0;
for (i = 0; i < count; ++i) {
if ((i & 0xF) == 0) {
if (i > 0) {
char line[132];
snprintf(line, sizeof(line)-1, "%-6s: %-49s | %-17s |", addr, left, right);
SICSLogWriteTime(line, eOut, tp);
}
snprintf(addr, sizeof(addr)-1, "0x%04X", i);
while (i >= 16 && i + 16 < count) {
if (memcmp(&text[i-16], &text[i], 16) != 0)
break;
++duplicates;
i += 16;
}
if (duplicates > 0) {
if (duplicates > 1) {
char line[132];
snprintf(line, sizeof(line)-1, "%-6s: ... (%d duplicates)", addr, duplicates);
SICSLogWriteTime(line, eOut, tp);
}
else {
char line[132];
snprintf(line, sizeof(line)-1, "%-6s: %-49s | %-17s |", addr, left, right);
SICSLogWriteTime(line, eOut, tp);
}
duplicates = 0;
}
snprintf(addr, sizeof(addr)-1, "0x%04X", i);
lp = left;
rp = right;
}
*lp++ = hex[(text[i] >> 4) & 0xF];
*lp++ = hex[(text[i]) & 0xF];
*lp++ = ' ';
if (text[i]>= ' ' && text[i] <= '~')
*rp++ = text[i];
else
*rp++ = '.';
/* if we just did slot 7, insert an extra space */
if ((i & 0xF) == 7) {
*lp++ = ' ';
*rp++ = ' ';
}
*lp = *rp = '\0';
}
if (i > 0) {
char line[132];
snprintf(line, sizeof(line)-1, "%-6s: %-49s | %-17s |", addr, left, right);
SICSLogWriteTime(line, eOut, tp);
}
}
void SICSLogWriteHex(const char* text, int count, OutCode eOut) {
struct timeval tv;
gettimeofday(&tv, NULL);
SICSLogWriteHexTime(text, count, eOut, &tv);
}
void SICSLogTimePrintf(OutCode eOut, struct timeval *tp, const char *fmt, ...)
{
va_list ap;
char buf[256];
char *dyn;
unsigned int l;
int res;
va_start(ap, fmt);
l = vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
if (l >= sizeof buf) {
/* we have probably a C99 conforming snprintf and
need a larger buffer
*/
dyn = malloc(l+1);
if (dyn != NULL) {
va_start(ap, fmt);
vsnprintf(dyn, l+1, fmt, ap);
va_end(ap);
SICSLogWriteTime(dyn, eOut, tp);
free(dyn);
return;
}
}
SICSLogWriteTime(buf, eOut, tp);
return;
}
void SICSLogPrintf(OutCode eOut, const char *fmt, ...)
{
va_list ap;
char buf[256];
char *dyn;
unsigned int l;
int res;
va_start(ap, fmt);
l = vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
if (l >= sizeof buf) {
/* we have probably a C99 conforming snprintf and
need a larger buffer
*/
dyn = malloc(l+1);
if (dyn != NULL) {
va_start(ap, fmt);
vsnprintf(dyn, l+1, fmt, ap);
va_end(ap);
SICSLogWrite(dyn, eOut);
free(dyn);
return;
}
}
SICSLogWrite(buf, eOut);
return;
}
/* Test of the logging facilities */
int testLogCmd(SConnection *pCon, SicsInterp *pInter, void *pData, int argc, char *argv[]) {
char lbuf[2048];
char sbuf[1000];
int i;
SICSLogWrite("Multiline:\nLine 1\r\nLine 2\r\nLine 3\r\n", eStatus);
memset(lbuf, 0, sizeof(lbuf));
memset(sbuf, ' ', sizeof(sbuf));
SICSLogPrintf(eStatus, "Hexlog %d all zero bytes", sizeof(lbuf));
SICSLogWriteHex(lbuf, sizeof(lbuf), eStatus);
for (i = 0; i <= 128; ++i)
sbuf[i] = sbuf[sizeof(sbuf)-1 - i] = i;
sbuf[sizeof(sbuf)/2] = '!';
SICSLogPrintf(eStatus, "Hexlog %d mid space bytes", sizeof(sbuf));
SICSLogWriteHex(sbuf, sizeof(sbuf), eStatus);
for (i = 0; i < 1000; ++i)
sbuf[i] = ' ' + (i % 96);
sbuf[sizeof(sbuf)-1] = '\0';
SICSLogWrite("Very long line 1000 bytes", eStatus);
SICSLogWrite(sbuf, eStatus);
SCSendOK(pCon);
return OKOK;
}