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; }