int main(int argc, char *argv[])
{
int fuseStat = 0;
struct stateFilesystem * data;
//Check the permission
if((getuid() == 0) || (geteuid() == 0))
{
fprintf(stderr, "Fail in the security access.");
}
data = malloc(sizeof(struct stateFilesystem));
if(data == NULL)
{
perror("main calloc");
abort();
}
data->rootDirectory = realpath(argv[argc - 2], NULL);
argv[argc - 2] = argv[argc - 1];
argv[argc - 1] = NULL;
argc--;
data->logFile = logOpen();
fuseStat = fuse_main(argc, argv, &ospOperations, data);
return fuseStat;
}
int main(void)
{
logOpen();
initXWindows();
init_opengl();
Game game;
init(&game);
srand(time(NULL));
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
int done=0;
while (!done) {
while (XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e);
done = check_keys(&e);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while (physicsCountdown >= physicsRate) {
physics(&game);
physicsCountdown -= physicsRate;
}
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
logClose();
return 0;
}
void
SpawnLogger::logNewZone(const QString& zonename)
{
if (m_FP == NULL)
if (logOpen() != 0)
return;
outputf("----------\nNEW ZONE: %s\n----------\n", (const char*)zonename);
outputf(" :name(spawnID):Level:Xpos:Ypos:Zpos:H.m.s:Ver:Zone:eqHour.eqMinute.eqMonth.eqDay.eqYear:killedBy(spawnID)\n");
flush();
zoneShortName = zonename;
}
int main(void)
{
logOpen();
initXWindows();
init_opengl();
init();
init_sounds();
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e);
check_keys(&e);
}
//
//Below is a process to apply physics at a consistent rate.
//1. Get the time right now.
clock_gettime(CLOCK_REALTIME, &timeCurrent);
//2. How long since we were here last?
timeSpan = timeDiff(&timeStart, &timeCurrent);
//3. Save the current time as our new starting time.
timeCopy(&timeStart, &timeCurrent);
//4. Add time-span to our countdown amount.
physicsCountdown += timeSpan;
//5. Has countdown gone beyond our physics rate?
// if yes,
// In a loop...
// Apply physics
// Reducing countdown by physics-rate.
// Break when countdown < physics-rate.
// if no,
// Apply no physics this frame.
while(physicsCountdown >= physicsRate) {
//6. Apply physics
physics();
//7. Reduce the countdown by our physics-rate
physicsCountdown -= physicsRate;
}
//Always render every frame.
render();
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
#ifdef USE_SOUND
fmod_cleanup();
#endif //USE_SOUND
logClose();
return 0;
}
int
main(int argc, char *argv[])
{
const int SLEEP_TIME = 15; /* Time to sleep between messages */
int count = 0; /* Number of completed SLEEP_TIME intervals */
int unslept; /* Time remaining in sleep interval */
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sa.sa_handler = sighupHandler;
if (sigaction(SIGHUP, &sa, NULL) == -1)
errExit("sigaction");
if (becomeDaemon(0) == -1)
errExit("becomeDaemon");
logOpen(LOG_FILE);
readConfigFile(CONFIG_FILE);
unslept = SLEEP_TIME;
for (;;) {
unslept = sleep(unslept); /* Returns > 0 if interrupted */
if (hupReceived) { /* If we got SIGHUP... */
hupReceived = 0; /* Get ready for next SIGHUP */
logClose();
logOpen(LOG_FILE);
readConfigFile(CONFIG_FILE);
}
if (unslept == 0) { /* On completed interval */
count++;
logMessage("Main: %d", count);
unslept = SLEEP_TIME; /* Reset interval */
}
}
}
int main(int argc, char* argv[]){
const int SLEEP_TIME=15;
int count=0;
int unslept;
struct sigaction sa;
sigemptyset(&sa.sa_mask);
//sa.sa_flags=SA_RESTART;
sa.sa_flags=SA_NOCLDSTOP;
sa.sa_handler=sighupHandler;
if(sigaction(SIGHUP,&sa,NULL)==-1){
perror("error sigation");
}
if(becomeDaemon(0)==-1){
perror("error becomeDaemon");
}
logOpen(LOG_FILE);
readConfigFile(CONFIG_FILE);
unslept=SLEEP_TIME;
for(;;){
unslept=sleep(unslept);
if(hupReceived){
hupReceived=0;
logClose();
logOpen(LOG_FILE);
readConfigFile(CONFIG_FILE);
}
if(unslept==0){
count++;
logMessage("Main: %d", count);
unslept=SLEEP_TIME;
}
}
return 0;
}
int MicroHttpMain(int npar,char **par) {
int i,Limit=1000000;
if (npar==1) {
printf("microHttp.exe -p[port] -r[rootDir] -d[debugLevel] -m[ext=mime[&..]]) -L[limitPPS:1000000]\n");
return 0;
}
for(i=1;i<npar;i++) {
char *cmd = par[i];
if (*cmd=='-') cmd++;
switch(*cmd) {
case 'p': sscanf(cmd+1,"%d",&port); break;
//case 'S': sscanf(cmd+1,"%d",&sleepTime); break;
case 'd': sscanf(cmd+1,"%d",&logLevel); break;
case 'k': sscanf(cmd+1,"%d",&keepAlive); break;
case 'T': sscanf(cmd+1,"%d",&runTill); break;
case 'L': sscanf(cmd+1,"%d",&Limit); break;
case 'r': rootDir=cmd+1; break;
case 'm': mimes = cmd+1; break;
}
}
net_init();
TimeUpdate();
httpSrv *srv = httpSrvCreate(0); // New Instance, no ini
srv->log = srv->srv.log = logOpen("microHttp.log"); // Create a logger
srv->logLevel = srv->srv.logLevel = logLevel;
srv->keepAlive=keepAlive;
srv->readLimit.Limit = Limit;
IFLOG(srv,0,"...starting microHttp {port:%d,logLevel:%d,rootDir:'%s',keepAlive:%d,Limit:%d},\n mimes:'%s'\n",
port,logLevel,rootDir,keepAlive,Limit,
mimes);
//printf("...Creating a http server\n");
srv->defmime= vssCreate("text/plain;charset=windows-1251",-1);
httpSrvAddMimes(srv,mimes);
//httpMime *m = httpSrvGetMime(srv,vssCreate("1.HHtm",-1));printf("Mime here %*.*s\n",VSS(m->mime));
//httpSrvAddFS(srv,"/c/","c:/",0); // Adding some FS mappings
httpSrvAddFS(srv,"/",rootDir,0); // Adding some FS mappings
httpSrvAddMap(srv, strNew("/.stat",-1), onHttpStat, 0);
if (httpSrvListen(srv,port)<=0) { // Starts listen port
Logf("-FAIL start listener on port %d\n",port); return 1;
}
Logf(".. listener is ready, Ctrl+C to abort\n");
if (runTill) srv->runTill = TimeNow + runTill;
httpSrvProcess(srv); // Run All messages till CtrlC...
TimeUpdate();
IFLOG(srv,0,"...stop microHttp, done:{connects:%d,requests:%d,runtime:%d}\n",
srv->srv.connects,srv->srv.requests,TimeNow - srv->created);
return 0;
}
void
SpawnLogger::logSpawnInfo(const char *type, const char *name, int id, int level,
int x, int y, int z, time_t timeCurrent,
const char *killedBy, int kid, int guildid)
{
struct timeOfDayStruct eqDate;
struct tm* current;
if (m_FP == NULL)
if (logOpen() != 0)
return;
eqDate = l_time->eqdate(timeCurrent);
current = localtime(&timeCurrent);
outputf("%s:%s(%d):%d:%d,%d,%d:%02d.%02d.%02d:%d:%s:%02d.%02d.%02d.%02d.%04d:%s(%d):%d\n",
type,
name,
id,
level,
x,
y,
z,
current->tm_hour, current->tm_min, current->tm_sec,
version,
(const char*)zoneShortName,
eqDate.hour,
eqDate.minute,
eqDate.month,
eqDate.day,
eqDate.year,
killedBy,
kid,
guildid
);
flush();
return;
}
int main(void)
{
logOpen();
initXWindows();
init_opengl();
init();
//buttonsInit();------------------------------------------------------------------
init_sounds();
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e);
GOcheck_mouse(&e);
check_keys(&e);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while(physicsCountdown >= physicsRate) {
physics();
physicsCountdown -= physicsRate;
}
render();
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
#ifdef USE_SOUND
fmod_cleanup();
#endif //USE_SOUND
logClose();
return 0;
}
/* Initialize library
* return non-zero value on error
*/
int gigaInit()
{
//Note: Code copied from client/client.c
int ret = 0;
// initialize logging
char log_file[PATH_MAX] = {0};
snprintf(log_file, sizeof(log_file),
"%s.c.%d", DEFAULT_LOG_FILE_PATH, (int)getpid());
if ((ret = logOpen(log_file, DEFAULT_LOG_LEVEL)) < 0)
{
fprintf(stdout, "***ERROR*** during opening log(%s) : [%s]\n", log_file, strerror(ret));
return ret;
}
memset(&giga_options_t, 0, sizeof(struct giga_options));
initGIGAsetting(GIGA_CLIENT, DEFAULT_MNT, CONFIG_FILE);
GIGAinit(NULL);
fd_count = 0;
return ret;
}
int inst_logPushMsg( char *pszModule, char *pszFunctionName, int nLine, int nSeverity, int nCode, char *pszMessage )
{
int ret = LOG_ERROR;
mutex_entry();
if ( !log_tried )
{
long nMaxMessages = 10; /* \todo ODBC spec says 8 max. We would make it 0 (unlimited) but at the moment logPeekMsg
would be slow if many messages. Revisit when opt is made to log storage. */
log_tried = 1;
if ( logOpen( &hODBCINSTLog, "odbcinst", NULL, nMaxMessages ) != LOG_SUCCESS )
{
hODBCINSTLog = NULL;
}
else
{
logOn( hODBCINSTLog, 1 );
}
}
if ( hODBCINSTLog )
{
ret = logPushMsg( hODBCINSTLog,
pszModule,
pszFunctionName,
nLine,
nSeverity,
nCode,
pszMessage );
}
mutex_exit();
return ret;
}
int main(int argc, char *argv[])
{
if(argc > 1) {
if(argv[1] != NULL) {
beginTesting();
}
return 0;
}
logOpen();
initXWindows();
init_opengl();
Game game;
init(&game);
srand(time(NULL));
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
hud = new Hud(xres ,yres);
if (TEST_Hud){
hud->testHUDAll();
return 0;
}
//DEFUALT IS LEVEL 1 SELECTED:
selected_screen = LEFT;
level =1;
//--------------
is_gameover = false;
high_score = 0;
gameStarted = false;
lastPaddleHit = 'N';//'N' means no paddle hit
bombBegin = time(NULL);
bombRandom = random(7);
beginSmallLeftPaddle = time(NULL);
smallLeftPaddleTime = 7;
beginSmallRightPaddle = time(NULL);
smallRightPaddleTime = 7;
hud->setAI(false);//DEFAULT: player2 is human
ball_saved_X_velocity = 8.0f * cos(30);
ball_saved_Y_velocity = 8.0f * sin(90);
obstacle_saved_Y_velocity = -5.0;
int min;
if (xres<yres){
min=xres;
}
else{
min=yres;
}
bomb_radius = ((int)(3*min)/10);
//MAIN MENU LOOP
while(intro != 0) {
while (XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
intro = check_keys(&e, &game);
}
render(&game);
glXSwapBuffers(dpy, win);
}
//BEGIN MAIN GAME LOOP
int done=0;
while (!done) {
while (XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
done = check_keys(&e, &game);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while (physicsCountdown >= physicsRate) {
physics(&game);
physicsCountdown -= physicsRate;
}
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
logClose();
return 0;
}
SQLRETURN _AllocConnect( SQLHENV hDrvEnv,
SQLHDBC *phDrvDbc )
{
HDRVENV hEnv = (HDRVENV)hDrvEnv;
HDRVDBC *phDbc = (HDRVDBC*)phDrvDbc;
/************************
* SANITY CHECKS
************************/
if( SQL_NULL_HENV == hEnv )
return SQL_INVALID_HANDLE;
sprintf((char*) hEnv->szSqlMsg, "hEnv = $%08lX phDbc = $%08lX", (long)hEnv, (long)phDbc );
logPushMsg( hEnv->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING,(char*) hEnv->szSqlMsg );
if( SQL_NULL_HDBC == phDbc )
{
logPushMsg( hEnv->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, "SQL_ERROR *phDbc is NULL" );
return SQL_ERROR;
}
/************************
* OK LETS DO IT
************************/
/* allocate database access structure */
*phDbc = (HDRVDBC)malloc( sizeof(DRVDBC) );
if( SQL_NULL_HDBC == *phDbc )
{
*phDbc = SQL_NULL_HDBC;
logPushMsg( hEnv->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, "SQL_ERROR malloc error" );
return SQL_ERROR;
}
/* initialize structure */
memset( *phDbc, 0, sizeof(DRVDBC) );
(*phDbc)->bConnected = 0;
(*phDbc)->hDbcExtras = NULL;
(*phDbc)->hFirstStmt = NULL;
(*phDbc)->hLastStmt = NULL;
(*phDbc)->pNext = NULL;
(*phDbc)->pPrev = NULL;
(*phDbc)->hEnv = (SQLPOINTER)hEnv;
/* start logging */
if ( !logOpen( &(*phDbc)->hLog, "[template]", NULL, 50 ) )
(*phDbc)->hLog = NULL;
logOn( (*phDbc)->hLog, 1 );
/* ADD TO END OF LIST */
if ( hEnv->hFirstDbc == NULL )
{
/* 1st is null so the list is empty right now */
hEnv->hFirstDbc = (*phDbc);
hEnv->hLastDbc = (*phDbc);
}
else
{
/* at least one node in list */
hEnv->hLastDbc->pNext = (SQLPOINTER)(*phDbc);
(*phDbc)->pPrev = (SQLPOINTER)hEnv->hLastDbc;
hEnv->hLastDbc = (*phDbc);
}
/********************************************************/
/* ALLOCATE AND INIT EXTRAS HERE */
(*phDbc)->hDbcExtras = (HDBCEXTRAS)malloc( sizeof(DBCEXTRAS) );
memset( (*phDbc)->hDbcExtras, 0, sizeof(DBCEXTRAS) );
/********************************************************/
logPushMsg( hEnv->hLog, __FILE__, __FILE__, __LINE__, LOG_INFO, LOG_INFO, "SQL_SUCCESS" );
return SQL_SUCCESS;
}
LOGGER *logInitLogger (char *name, int facility, int options, int verbosity, char *logPath,
char *logName, long rollOverSize, long bufferSize) {
LOGGER *pl;
int i;
struct stat sb;
if ((logPath == NULL) || (logPath[0] == '\0')) {
fprintf (stderr, "ERROR: %s - Invalid logPath passed\n", __FUNCTION__);
return NULL;
}
if ((logName == NULL) || (logName[0] == '\0')) {
fprintf (stderr, "ERROR: %s - Invalid logName passed\n", __FUNCTION__);
return NULL;
}
if ((facility < F_MIN) || (facility > F_MAX)) {
fprintf (stderr, "ERROR: %s - Unknown facility %d\n", __FUNCTION__, facility);
return NULL;
}
if (facility != F_FILE) {
fprintf (stderr, "ERROR: %s - The only facility current supported is F_FILE (%d)\n",
__FUNCTION__, F_FILE);
return NULL;
}
if ((options & O_FLUSH_AFTER_EACH) && (options & O_TIMED_FLUSH)) {
fprintf (stderr, "ERROR: %s - O_FLUSH_AFTER_EACH and O_TIMED_FLUSH cannot both be set\n",
__FUNCTION__);
return NULL;
}
verbosity = (verbosity < V_MIN) ? V_MIN : verbosity;
verbosity = (verbosity > V_MAX) ? V_MAX : verbosity;
if (loggerStore.count == 0) {
i = 0;
if ((loggerStore.loggers = (LOGGER **) malloc (sizeof (LOGGER *))) == NULL) {
fprintf (stderr, "ERROR: %s - Could not malloc space for loggerStore array\n", __FUNCTION__);
return NULL;
}
if ((loggerStore.loggers[0] = (LOGGER *) malloc (sizeof (LOGGER))) == NULL) {
fprintf (stderr, "ERROR: %s - Could not malloc space for logger node\n", __FUNCTION__);
return NULL;
}
} else { /* Try to find an allocated logger that's not being used */
for (i = 0; i < loggerStore.count; i++) {
if (!(loggerStore.loggers[i]->optionMask & NODE_IN_USE)) {
break;
}
}
if (i >= loggerStore.count) {
if ((loggerStore.loggers = (LOGGER **) realloc (loggerStore.loggers, sizeof (LOGGER *) * (loggerStore.count+1))) == NULL) {
fprintf (stderr, "ERROR: %s - Could not realloc loggerStore\n", __FUNCTION__);
return NULL;
}
if ((loggerStore.loggers[i] = (LOGGER *) malloc (sizeof (LOGGER))) == NULL) {
fprintf (stderr, "ERROR: %s - Could not malloc space for logger node\n", __FUNCTION__);
return NULL;
}
}
}
pl = loggerStore.loggers[i];
pl->index = i;
loggerStore.count++;
pl->name = strdup (name);
options |= NODE_IN_USE;
pl->optionMask = options; /* Set the LOG_IN_USE bit and the flags passed in */
pl->verbosity = verbosity;
pl->facility = facility; /* Only supports LOG_FILE now...how to implement others? */
pl->bufferSize = bufferSize;
pl->logFd = NULL;
pl->needFlush = FALSE;
pl->flushInterval = LOG_DEFAULT_FLUSH_INTERVAL;
pl->timerSignal = SIGRTMIN;
pl->flushBufSize = 0;
pl->amArchiving = FALSE;
// switch (p_logger->facility) {
// case F_FILE:
// retval = logInitFile (p_logger);
// break;
//
// case F_DB:
// retval = logInitDB (p_logger);
// break;
//
// case F_SOCKET:
// retval = logInitSocket (p_logger);
// break;
//
// case F_PIPE:
// retval = logInitPipe (p_logger);
// break;
//
// case F_CONSOLE:
// retval = logInitConsole (p_logger);
// break;
//
// case F_PRINTER:
// retval = logInitPipe (p_logger);
// break;
//
// default: /* Shouldn't ever get here... */
// fprintf ("ERROR: %s - hit default case\n", __FUNCTION__);
// break;
// }
/* Force rollover size to LOG_MAX_FILE_SIZE if user leaves it set to 0 */
pl->rollOverSize = rollOverSize ? rollOverSize : LOG_MAX_FILE_SIZE;
if ((pl->logPath = strdup (logPath)) == NULL) {
fprintf (stderr, "ERROR: %s - Could not strdup logPath\n", __FUNCTION__);
return NULL;
}
if ((pl->logName = strdup (logName)) == NULL) {
fprintf (stderr, "ERROR: %s - Could not strdup logName\n", __FUNCTION__);
return NULL;
}
if ((pl->fullLogName = malloc (strlen (logPath) + strlen (logName) + 2)) == NULL) {
fprintf (stderr, "ERROR: %s - Could not malloc fullLogName\n", __FUNCTION__);
return NULL;
}
sprintf (pl->fullLogName, "%s/%s", logPath, logName);
/* This is kludged for now, allow it to be specified later */
if ((pl->archivePath = malloc (strlen (logPath) + strlen ("/ARCHIVE/MmmDd") + 1)) == NULL) {
fprintf (stderr, "ERROR: %s - Could not malloc archivePath\n", __FUNCTION__);
return NULL;
}
sprintf (pl->archivePath, "%s/ARCHIVE", logPath);
if ((pl->timeFormat = strdup (LOG_DEFAULT_DATE_FORMAT)) == NULL) { /* Hand jam this for now. In future make it configurable */
fprintf (stderr, "ERROR: %s - Could not strdup date format string\n", __FUNCTION__);
return NULL;
}
if ((pl->buffer = malloc (bufferSize)) == NULL) {
fprintf (stderr, "ERROR: %s - Could not malloc buffer\n", __FUNCTION__);
return NULL;
}
if ((pl->formatBuf = malloc (LOG_FORMAT_BUF_SIZE)) == NULL) {
fprintf (stderr, "ERROR: %s - Could not malloc format buffer\n", __FUNCTION__);
return NULL;
}
pl->lastLogDay = pl->lastLogTime = 0;
if (!fileExists (pl->logPath)) {
if (makeDirectory (pl->logPath, YES, DIRECTORY_CREATE_PERMS) < 0) {
fprintf (stderr, "ERROR: %s - Could not make directory for logPath\n", __FUNCTION__);
return NULL;
}
}
/* Cheat to get the device block size by checking on the block size of the logPath directory file */
pl->flushBufSize = (stat (pl->logPath, &sb) == 0) ? sb.st_blksize : DEFAULT_DISK_BLOCK_SIZE;
if (fileExists (pl->fullLogName)) {
pl->lastLogTime = getFileLastMod (pl->fullLogName);
pl->lastLogDay = pl->lastLogTime / SECONDS_PER_DAY;
pl->logSize = getFileSize (pl->fullLogName);
checkLogRollover (pl); /* Rollover the log if necessary */
} else {
pl->lastLogDay = pl->lastLogTime = 0;
pl->logSize = 0;
}
if (options & O_LOG_INIT) {
logMsg (pl, V_INFO, S_STATUS, "%s INITIALIZED", pl->name);
if (!(options & O_KEEP_OPEN)) {
logClose (pl);
}
}
if (options & O_KEEP_OPEN) {
logOpen (pl);
}
return pl;
}
static void checkLogRollover (LOGGER *p_logger) {
char archiveDate[LOG_SIZE_ARCHIVE_DATE+1];
time_t now;
if (p_logger == NULL) {
fprintf (stderr, "ERROR: %s - NULL logger provided\n", __FUNCTION__);
return;
}
if (!(p_logger->optionMask & NODE_IN_USE)) {
fprintf (stderr, "ERROR: %s - Logger not in use\n", __FUNCTION__);
return;
}
if ((p_logger->lastLogTime == 0) || (p_logger->logSize == 0))
return;
if ((p_logger->optionMask & O_ARCHIVE)) {
now = time (NULL);
/* Check if date changed since last run or log reached rollover size and archive it if so */
if (((now / 86400) != p_logger->lastLogDay) ||
(p_logger->rollOverSize && (p_logger->logSize >= p_logger->rollOverSize))) {
strftime (archiveDate, LOG_SIZE_ARCHIVE_DATE+1, "%b%d", localtime (&p_logger->lastLogTime));
if (archiveLog(p_logger, archiveDate) == 0) {
p_logger->lastLogDay = p_logger->lastLogTime = 0;
p_logger->logSize = 0;
}
if (p_logger->optionMask & O_KEEP_OPEN) {
logOpen (p_logger);
}
}
} else {
if (p_logger->rollOverSize && (p_logger->logSize >= p_logger->rollOverSize)) {
char *oldExt = ".old";
char *fname = strdup (p_logger->logName);
char *newName = malloc (strlen (p_logger->fullLogName) + strlen (oldExt) + 1); /* Reserve characters for old extension */
char *ext;
splitFilenameExt (fname, &ext);
sprintf (newName, "%s/%s.%s", p_logger->logPath, fname, oldExt);
if (p_logger->optionMask & O_LOG_INIT) {
p_logger->amArchiving = TRUE;
logMsg (p_logger, V_ALWAYS, S_STATUS, "%s TERMINATED %s FILE SIZE %d RENAMED TO %s",
p_logger->name, p_logger->fullLogName, p_logger->logSize, newName);
p_logger->amArchiving = FALSE;
}
logClose (p_logger);
if (moveFile (p_logger->fullLogName, newName, TRUE)) {
fprintf (stderr, "ERROR: %s - could not move %s to %s\n", __FUNCTION__, p_logger->fullLogName, newName);
}
p_logger->lastLogDay = p_logger->lastLogTime = 0;
p_logger->logSize = 0;
if (p_logger->optionMask & O_KEEP_OPEN) {
logOpen (p_logger);
}
free (newName);
free (fname);
}
}
}
void datagramInterpreter(uint8_t t, const uint8_t *data, int size)
{
switch(t) {
case DG_HEARTBEAT:
// Heartbeat
if(heartbeatReset) {
memcpy((void*) &heartbeatCount, data, sizeof(heartbeatCount));
heartbeatTime = time(NULL);
}
break;
case DG_CONSOLE:
// Console output
consoleWrite(data, size);
break;
case DG_INITIALIZED:
initDone = true;
break;
case DG_READY:
// Initialization done
// consoleNotef("ready\n");
logReady = true;
break;
case DG_LOGDATA:
// Log data
if(size > 0)
logStore((const uint16_t*) data, size/2);
else if(receivingLog) {
logDisplay();
logClose();
// Auto clear
if(!autoClearDone)
sendCommand("clear");
autoClearDone = true;
}
break;
case DG_LOGINFO:
// Log stamp
memcpy(&logInfo, data, sizeof(logInfo));
consoleNotef("LOG %d OF MODEL %s\n", logInfo.stamp, logInfo.name);
receivingLog = logOpen(&logInfo);
break;
case DG_PARAMS:
// Param backup
if(size > 0) {
memset(modelName, '\0', NAME_LEN);
memcpy(modelName, (char*) data, size);
consoleNotef("BACKUP %s START\n", modelName);
backupOpen(modelName);;
} else {
consoleNotef("BACKUP END\n");
backupClose();
}
break;
case DG_SIMLINK:
// Simulator link control record
udpClient(data, size);
break;
default:
consoleNotef("FUNNY DATAGRAM TYPE = %d SIZE = %d\n", t, size);
}
}
SQLRETURN _AllocStmt( SQLHDBC hDrvDbc,
SQLHSTMT *phDrvStmt )
{
HDRVDBC hDbc = (HDRVDBC)hDrvDbc;
HDRVSTMT *phStmt = (HDRVSTMT*)phDrvStmt;
/* SANITY CHECKS */
if( hDbc == SQL_NULL_HDBC )
{
logPushMsg( hDbc->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, "SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
sprintf( hDbc->szSqlMsg, "hDbc = $%08lX", hDbc );
logPushMsg( hDbc->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, hDbc->szSqlMsg );
if( NULL == phStmt )
{
logPushMsg( hDbc->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, "SQL_ERROR phStmt=NULL" );
return SQL_ERROR;
}
/* OK */
/* allocate memory */
*phStmt = malloc( sizeof(DRVSTMT) );
if( SQL_NULL_HSTMT == *phStmt )
{
logPushMsg( hDbc->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, "SQL_ERROR memory allocation failure" );
return SQL_ERROR;
}
/* initialize memory */
sprintf( hDbc->szSqlMsg, "*phstmt = $%08lX", *phStmt );
logPushMsg( hDbc->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, hDbc->szSqlMsg );
memset( *phStmt, 0, sizeof(DRVSTMT) ); /* SAFETY */
(*phStmt)->hDbc = (SQLPOINTER)hDbc;
(*phStmt)->hLog = NULL;
(*phStmt)->hStmtExtras = NULL;
(*phStmt)->pNext = NULL;
(*phStmt)->pPrev = NULL;
(*phStmt)->pszQuery = NULL;
sprintf( (*phStmt)->szCursorName, "CUR_%08lX", *phStmt );
/* ADD TO DBCs STATEMENT LIST */
/* start logging */
if ( logOpen( &(*phStmt)->hLog, DRIVER_NAME, NULL, 50 ) )
{
logOn( (*phStmt)->hLog, 1 );
logPushMsg( (*phStmt)->hLog, __FILE__, __FILE__, __LINE__, LOG_WARNING, LOG_WARNING, "Statement logging allocated ok" );
}
else
(*phStmt)->hLog = NULL;
/* ADD TO END OF LIST */
if ( hDbc->hFirstStmt == NULL )
{
/* 1st is null so the list is empty right now */
hDbc->hFirstStmt = (*phStmt);
hDbc->hLastStmt = (*phStmt);
}
else
{
/* at least one node in list */
hDbc->hLastStmt->pNext = (SQLPOINTER)(*phStmt);
(*phStmt)->pPrev = (SQLPOINTER)hDbc->hLastStmt;
hDbc->hLastStmt = (*phStmt);
}
/****************************************************************************/
/* ALLOCATE AND INIT DRIVER EXTRAS HERE */
(*phStmt)->hStmtExtras = malloc(sizeof(STMTEXTRAS));
memset( (*phStmt)->hStmtExtras, 0, sizeof(STMTEXTRAS) ); /* SAFETY */
(*phStmt)->hStmtExtras->aResults = NULL;
(*phStmt)->hStmtExtras->nCols = 0;
(*phStmt)->hStmtExtras->nRow = 0;
(*phStmt)->hStmtExtras->nRows = 0;
/****************************************************************************/
logPushMsg( hDbc->hLog, __FILE__, __FILE__, __LINE__, LOG_INFO, LOG_INFO, "SQL_SUCCESS" );
return SQL_SUCCESS;
}
int httpTestMain(int npar,char **par) {
int i,sock=1,pack=1,logLevel=1;
int MaxPacket = 1000000;
char *url,*Proxy="";
net_init();
signal(SIGINT,sig_done);
if (npar<2) {
httpTestHelp();
return 1; // Error
}
char *cmd=par[1];
if (strncmp(cmd,"-p",2)==0) return MicroHttpMain(npar,par);
if (strncmp(cmd,"http://",7)==0) cmd+=7; // RemoveHTTP
url=cmd;
static Counter read={100000}; // ReadLimit
for(i=2;i<npar;i++) { // Decode Optional
char *cmd=par[i]; int ok=1;
if (*cmd=='-') {
cmd++; ok=1;
if (*cmd=='s') sscanf(cmd+1,"%d",&sock);
//else if (*cmd=='S') sscanf(cmd+1,"%d",&sleepTime);
else if (*cmd=='p') sscanf(cmd+1,"%d",&pack);
else if (*cmd=='d') sscanf(cmd+1,"%d",&logLevel);
else if (*cmd=='M') sscanf(cmd+1,"%d",&MaxPacket);
else if (*cmd=='P') Proxy=cmd+1;
else if (*cmd=='R') sscanf(cmd+1,"%d",&ReplayCode);
else if (*cmd=='r') sscanf(cmd+1,"%d",&read.Limit);
else ok=0;
}
if (!ok) {
printf("httpTest - unknownParameter: '%s'\n",cmd);
httpTestHelp();
return 2;
}
}
//thread_create(httpClientTest1);
httpClient *Cli[sock];
logger *log;
log = logOpen("httpTest.log");
Logf("httpStressTest: {logLevel:%d,Sockets:%d,Commands:%d,MaxPacket:%d,URL:'%s',Proxy='%s'\n",
logLevel,sock,pack,MaxPacket,url,Proxy);
for(i=0;i<sock;i++) {
httpClient *c;
Cli[i]= c = httpClientNew();
c->log = log;
c->logLevel = logLevel;
snprintf(c->name,sizeof(c->name),"[%d]%s",i,url);
if (!httpClientInit(c,url,Proxy)) return 0;
c->onDisconnect = onTestDisconnect;
c->sock.readPacket = &read;
//c->sock->readPacket.Limit = readPackLimit;
//printf("Begin?\n");
int j; for(j=0;j<pack;j++) SendTestPack(c); // SendTestPacks
//printf("Done?\n");
}
TimeUpdate(); time_t Started=TimeNow;
printf("StressStarted: %s, mem=%d\n",szTimeNow,os_mem_used());
while(!aborted) {
int c=0;
TimeUpdate();
for(i=0;i<sock;i++) if (httpClientRun(Cli[i])) c++;
if (read.Total>=MaxPacket) {
Logf("MaxPacket %d received\n", MaxPacket);
break;
}
//printf("Run=%d\n",c);
RunSleep(c);
if (NeedReport()) Reportf("Time:'%s',Packet_Per_Second:%5d,Total:%5d,os_mem:%d",szTimeNow,
(read.pValue+read.ppValue)/2,read.Total,os_mem_used());
//if (!c) msleep(1);
}
TimeUpdate(); int Dur=TimeNow-Started,PPS=0; if (Dur) PPS=read.Total/Dur;
printf("StressStopped:'%s',Dur:%d,PPS:%d,Total:%5d,os_mem:%d",szTimeNow,Dur,PPS,read.Total,os_mem_used());
return 0;
//return httpClientTest1(logLevel,sock,pack,url); // Слушай - а у меня в микрохттп нету ли такого - что я останавливаюсь???
}
int logMsg (LOGGER *pl, int visibility, int severity, const char *format, ...) {
va_list args;
sigset_t mask;
sigset_t orig_mask;
int retval = SUCCESS;
char *p;
if (pl == NULL) {
fprintf (stderr, "ERROR: %s - NULL logger provided\n", __FUNCTION__);
return ERROR;
}
if (!(pl->optionMask & NODE_IN_USE)) {
fprintf (stderr, "ERROR: %s - Logger not in use\n", __FUNCTION__);
return ERROR;
}
p = pl->formatBuf;
visibility = (visibility < V_MIN) ? V_MIN : visibility;
visibility = (visibility > V_MAX) ? V_MAX : visibility;
severity = (severity < S_MIN) ? S_MIN : severity;
severity = (severity > S_MAX) ? S_MAX : severity;
if (visibility > pl->verbosity) {
return SUCCESS;
}
if (pl->optionMask & O_TIMED_FLUSH) {
/* Block the timer signal to prevent race condition when flushHandler runs */
sigemptyset (&mask);
sigaddset (&mask, pl->timerSignal);
if (sigprocmask (SIG_BLOCK, &mask, &orig_mask) < 0) {
fprintf (stderr,
"%s - Call to sigprocmask failed with eror %d - %s",
__FUNCTION__, errno, strerror (errno));
retval = ERROR;
}
}
if (!pl->amArchiving) {
checkLogRollover (pl);
}
va_start(args, format);
if ((pl->optionMask & O_TIMESTAMP)) {
char datebuf[LOG_DATE_LEN+1]; /* YYYY-MM-DD HH:MM:SS.cccc */
struct timespec hrt;
if (clock_gettime (CLOCK_REALTIME, &hrt)) {
logMsg (pl, V_ALWAYS, S_FATAL, "Call to clock_gettime failed - exiting");
exit (errno);
}
strftime (datebuf, LOG_DATE_LEN+1, LOG_DEFAULT_DATE_FORMAT, localtime (&hrt.tv_sec));
p = datebuf + strlen (datebuf);
sprintf (p, ".%06ld", hrt.tv_nsec / 1000); /* Report in microseconds */
sprintf (pl->formatBuf, "%s ", datebuf);
p = pl->formatBuf + strlen (pl->formatBuf);
}
if (pl->optionMask & O_SHOW_LEVEL) {
sprintf (p, "<%s> ", logVerbosityStrings[visibility]);
p = pl->formatBuf + strlen (pl->formatBuf);
}
if (pl->optionMask & O_SHOW_SEVERITY) {
sprintf (p, "[%s]: ", logSeverityStrings[severity]);
p = pl->formatBuf + strlen (pl->formatBuf);
}
sprintf (p, "%s%c", format, (pl->optionMask & O_ADD_NEWLINE) ? '\n' : '\0');
vsnprintf (pl->buffer, pl->bufferSize, pl->formatBuf, args);
if (logOpen (pl)) {
fprintf (stderr, "ERROR: %s - logOpen failed\n", __FUNCTION__);
} else {
int msgSize = strlen (pl->buffer);
int writeSize;
if ((writeSize = fprintf (pl->logFd, pl->buffer, args)) < msgSize) {
fprintf (stderr, "ERROR: %s - only wrote %d bytes of %d byte message\n", __FUNCTION__, writeSize, msgSize);
}
if (writeSize > 0) {
pl->logSize += writeSize;
pl->lastLogTime = time (NULL);
pl->lastLogDay = pl->lastLogTime / SECONDS_PER_DAY;
}
if (pl->optionMask & O_FLUSH_AFTER_EACH) {
if (fflush (pl->logFd) != 0) {
fprintf (stderr, "ERROR: %s - fflush returned error code %d\n", __FUNCTION__, errno);
}
}
if (pl->optionMask & O_TIMED_FLUSH) {
pl->flushBufBytes += writeSize;
if (pl->flushBufBytes >= pl->flushBufSize) {
if (fflush (pl->logFd) != 0) {
fprintf (stderr, "ERROR: %s - fflush returned error code %d\n", __FUNCTION__, errno);
}
// printf ("%s - Manually flushing %s flushBufSize: %d flushBufBytes: %d\n", __FUNCTION__, pl->name, pl->flushBufSize, pl->flushBufBytes);
pl->flushBufBytes = 0;
pl->needFlush = FALSE;
} else {
if (!pl->needFlush) {
pl->needFlush = TRUE;
/* Set flush timer */
setFlushTimer (pl->name, &pl->timerID, pl->timerSignal, pl->flushInterval);
}
}
if (sigprocmask (SIG_SETMASK, &orig_mask, NULL) < 0) {
fprintf (stderr, "%s - Call to sigprocmask failed with error %d - %s",
__FUNCTION__, errno, strerror (errno));
retval = ERROR;
}
}
}
va_end (args);
return retval;
}
int MicroHttpMain(int npar,char **par) {
int i,Limit=1000000;
if (npar==1) {
printf("microHttp.exe -p[port] -r[rootDir] -d[debugLevel] -m[ext=mime[&..]]) -L[limitPPS:1000000] -S[cert.pem]\n");
return 0;
}
for(i=1;i<npar;i++) {
char *cmd = par[i];
if (*cmd=='-') cmd++;
switch(*cmd) {
case 'p': sscanf(cmd+1,"%d",&port); break;
//case 'S': sscanf(cmd+1,"%d",&sleepTime); break;
case 'd': sscanf(cmd+1,"%d",&logLevel); break;
case 'k': sscanf(cmd+1,"%d",&keepAlive); break;
case 'T': sscanf(cmd+1,"%d",&runTill); break;
case 'L': sscanf(cmd+1,"%d",&Limit); break;
case 'r': rootDir=cmd+1; break;
case 'm': mimes = cmd+1; break;
case 'S': pem = cmd+1; break;
}
}
net_init();
TimeUpdate();
httpSrv *srv = httpSrvCreate(0); // New Instance, no ini
srv->log = srv->srv.log = logOpen("microHttp.log"); // Create a logger
srv->logLevel = srv->srv.logLevel = logLevel;
srv->keepAlive=keepAlive;
srv->readLimit.Limit = Limit;
#ifdef VOS_SSL
if (pem) {
srv->srv.pem_file=pem; // if have SSL
printf("SSL will use pem_file: %s\n",pem);
} else printf("==NO SSL==, use plain tcp_sockets\n");
#endif
ws = wsSrvCreate();
ws->onMessage = onWebMessage;
IFLOG(srv,0,"...starting microHttp {port:%d,logLevel:%d,rootDir:'%s',keepAlive:%d,Limit:%d},\n mimes:'%s'\n",
port,logLevel,rootDir,keepAlive,Limit,
mimes);
//printf("...Creating a http server\n");
srv->defmime= vssCreate("text/plain;charset=utf-8",-1);
httpSrvAddMimes(srv,mimes);
//httpMime *m = httpSrvGetMime(srv,vssCreate("1.HHtm",-1));printf("Mime here %*.*s\n",VSS(m->mime));
//httpSrvAddFS(srv,"/c/","c:/",0); // Adding some FS mappings
httpSrvAddFS(srv,"/",rootDir,0); // Adding some FS mappings
httpSrvAddMap(srv, strNew("/.stat",-1), onHttpStat, 0);
httpSrvAddMap(srv, strNew("/.chat",-1), onWebSock, 0);
if (httpSrvListen(srv,port)<=0) { // Starts listen port
Logf("-FAIL start listener on port %d\n",port); return 1;
}
Logf(".. listener is ready, Ctrl+C to abort\n");
if (runTill) srv->runTill = TimeNow + runTill;
//httpSrvProcess(srv); // Run All messages till CtrlC...
while(!aborted) {
TimeUpdate(); // TimeNow & szTimeNow
int cnt = SocketPoolRun(&srv->srv);
cnt+=wsSrvStep(ws);
//printf("SockPoolRun=%d time:%s\n",cnt,szTimeNow); msleep(1000);
RunSleep(cnt); // Empty socket circle -)))
if (srv->runTill && TimeNow>=srv->runTill) break; // Done???
}
TimeUpdate();
IFLOG(srv,0,"...stop microHttp, done:{connects:%d,requests:%d,runtime:%d}\n",
srv->srv.connects,srv->srv.requests,TimeNow - srv->created);
return 0;
}
