int logger_log_header(logger_p log, unsigned int log_level, const char *srcname, unsigned int line_no)
{
int ret_val = 0;
struct tm cur_time;
struct tm cur_ftime;
struct tm create_ftime;
time_t temp_time;
char logtag[64]={0x00};
if(log == NULL)
{
return -1;
}
if(log_level > log->level)
{
log->is_log = 0;
return 0;
}
log->is_log = 1;
if(log->fp == NULL){
logger_open(log); // If Logger is running for first time
}
/////check for new file generation condition///////////
temp_time = time(NULL);
if((temp_time - log->create_time) > log->interval)
{
logger_open(log);
}
// for Sysnc For Hour Wise
localtime_r(&temp_time, &cur_ftime);
localtime_r(&log->create_time, &create_ftime);
if((cur_ftime.tm_min == 0) && (cur_ftime.tm_hour != create_ftime.tm_hour)){
logger_open(log);
}
/////prepare tag//////////
//time(&temp_time);
temp_time = time(NULL);
localtime_r(&temp_time , &cur_time);
sprintf(logtag ,"[%s|%s|%d|%02d:%02d:%02d|%s]" ,log->tag ,srcname ,line_no ,cur_time.tm_hour ,cur_time.tm_min ,cur_time.tm_sec ,log->leveltag[log_level]);
/* to be designed
if(log_level == DISP_SCREEN)
{
fprintf(stdout ,"%s",logtag);
fflush(stdout);
}
*/
ret_val = fprintf(log->fp ,"%s" ,logtag);
fflush(log->fp);
return ret_val;
}
int main(int ac, char *av[])
{
int res = 0;
size_t i;
fstorage *res_fs;
fstorage *old_fs;
struct fstorage_connect_config fscc;
size_t upd_count = 0;
fstorage *upd_fs[MAX_GSG_UPDATE_FILES];
//struct fstorage_connect_config upd_fscc[MAX_GSG_UPDATE_FILES];
#ifdef WITH_LOGGER
logger_open("updatesigdb", LOGGER_OPEN_NORMAL);
logger_add_file(2, LOGGER_ALL | LOGGER_USER);
#endif // WITH_LOGGER
memset(&upd_fs, 0, sizeof(fstorage *)*MAX_GSG_UPDATE_FILES);
#ifdef HAVE_MD5CHECK
int i;
for(i = 1; i < ac; i++)
{
if(strcmp(av[i], "--print-version") == 0)
{
print_version();
#ifdef WITH_LOGGER
logger_close()
#endif // WITH_LOGGER
return 0;
}
}
int main(int argc, char* argv[])
{
#ifdef WIN32
acl::acl_cpp_init();
#endif
logger_open("fs_benchmark.log", "fs_benchmark");
int ch;
int nthreads = 2;
#ifdef WIN32
snprintf(__path, sizeof(__path), "var/%d", (int) _getpid());
#else
snprintf(__path, sizeof(__path), "var/%d", (int) getpid());
#endif
while ((ch = getopt(argc, argv, "hn:c:l:kp:P:")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 'n':
nthreads = atoi(optarg);
break;
case 'c':
__nfiles = atoi(optarg);
break;
case 'l':
__length = atoi(optarg);
break;
case 'k':
__kernel_event = true;
break;
case 'p':
#ifdef WIN32
snprintf(__path, sizeof(__path), "%s/%d", optarg, (int) _getpid());
#else
snprintf(__path, sizeof(__path), "%s/%d", optarg, (int) getpid());
#endif
break;
case 'P':
__parallel = atoi(optarg);
if (__parallel <= 0)
__parallel = 1;
break;
default:
break;
}
}
for (size_t i = 0; i < sizeof(__data); i++)
{
__data[i] = 'X';
}
acl_make_dirs(__path, 0700);
// 创建线程池句柄
acl_pthread_pool_t* tp = acl_thread_pool_create(nthreads, 0);
// 添加线程处理任务
for (int i = 0; i < nthreads; i++)
acl_pthread_pool_add(tp, thread_main, NULL);
// 销毁线程池
acl_pthread_pool_destroy(tp);
logger_close();
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
/*
* logger -- read and log utility
*
* Reads from an input and arranges to write the result on the system
* log.
*/
int main(int argc, char **argv)
{
struct logger_ctl ctl = {
.fd = -1,
.pid = 0,
.pri = LOG_USER | LOG_NOTICE,
.prio_prefix = 0,
.tag = NULL,
.unix_socket = NULL,
.unix_socket_errors = 0,
.server = NULL,
.port = NULL,
.hdr = NULL,
.msgid = NULL,
.socket_type = ALL_TYPES,
.max_message_size = 1024,
.rfc5424_time = 1,
.rfc5424_tq = 1,
.rfc5424_host = 1,
.skip_empty_lines = 0
};
int ch;
int stdout_reopened = 0;
int unix_socket_errors_mode = AF_UNIX_ERRORS_AUTO;
#ifdef HAVE_LIBSYSTEMD
FILE *jfd = NULL;
#endif
static const struct option longopts[] = {
{ "id", optional_argument, 0, OPT_ID },
{ "stderr", no_argument, 0, 's' },
{ "file", required_argument, 0, 'f' },
{ "no-act", no_argument, 0, OPT_NOACT, },
{ "priority", required_argument, 0, 'p' },
{ "tag", required_argument, 0, 't' },
{ "socket", required_argument, 0, 'u' },
{ "socket-errors", required_argument, 0, OPT_SOCKET_ERRORS },
{ "udp", no_argument, 0, 'd' },
{ "tcp", no_argument, 0, 'T' },
{ "server", required_argument, 0, 'n' },
{ "port", required_argument, 0, 'P' },
{ "version", no_argument, 0, 'V' },
{ "help", no_argument, 0, 'h' },
{ "octet-count", no_argument, 0, OPT_OCTET_COUNT },
{ "prio-prefix", no_argument, 0, OPT_PRIO_PREFIX },
{ "rfc3164", no_argument, 0, OPT_RFC3164 },
{ "rfc5424", optional_argument, 0, OPT_RFC5424 },
{ "size", required_argument, 0, 'S' },
{ "msgid", required_argument, 0, OPT_MSGID },
{ "skip-empty", no_argument, 0, 'e' },
#ifdef HAVE_LIBSYSTEMD
{ "journald", optional_argument, 0, OPT_JOURNALD },
#endif
{ NULL, 0, 0, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((ch = getopt_long(argc, argv, "ef:ip:S:st:u:dTn:P:Vh",
longopts, NULL)) != -1) {
switch (ch) {
case 'f': /* file to log */
if (freopen(optarg, "r", stdin) == NULL)
err(EXIT_FAILURE, _("file %s"), optarg);
stdout_reopened = 1;
break;
case 'e':
ctl.skip_empty_lines = 1;
break;
case 'i': /* log process id also */
ctl.pid = logger_getpid();
break;
case OPT_ID:
if (optarg) {
const char *p = optarg;
if (*p == '=')
p++;
ctl.pid = strtoul_or_err(optarg, _("failed to parse id"));
} else
ctl.pid = logger_getpid();
break;
case 'p': /* priority */
ctl.pri = pencode(optarg);
break;
case 's': /* log to standard error */
ctl.stderr_printout = 1;
break;
case 't': /* tag */
ctl.tag = optarg;
break;
case 'u': /* unix socket */
ctl.unix_socket = optarg;
break;
case 'S': /* max message size */
ctl.max_message_size = strtosize_or_err(optarg,
_("failed to parse message size"));
break;
case 'd':
ctl.socket_type = TYPE_UDP;
break;
case 'T':
ctl.socket_type = TYPE_TCP;
break;
case 'n':
ctl.server = optarg;
break;
case 'P':
ctl.port = optarg;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
case 'h':
usage(stdout);
case OPT_OCTET_COUNT:
ctl.octet_count = 1;
break;
case OPT_PRIO_PREFIX:
ctl.prio_prefix = 1;
break;
case OPT_RFC3164:
ctl.syslogfp = syslog_rfc3164_header;
break;
case OPT_RFC5424:
ctl.syslogfp = syslog_rfc5424_header;
if (optarg)
parse_rfc5424_flags(&ctl, optarg);
break;
case OPT_MSGID:
if (strchr(optarg, ' '))
errx(EXIT_FAILURE, _("--msgid cannot contain space"));
ctl.msgid = optarg;
break;
#ifdef HAVE_LIBSYSTEMD
case OPT_JOURNALD:
if (optarg) {
jfd = fopen(optarg, "r");
if (!jfd)
err(EXIT_FAILURE, _("cannot open %s"),
optarg);
} else
jfd = stdin;
break;
#endif
case OPT_SOCKET_ERRORS:
unix_socket_errors_mode = parse_unix_socket_errors_flags(optarg);
break;
case OPT_NOACT:
ctl.noact = 1;
break;
case '?':
default:
usage(stderr);
}
}
argc -= optind;
argv += optind;
if (stdout_reopened && argc)
warnx(_("--file <file> and <message> are mutually exclusive, message is ignored"));
#ifdef HAVE_LIBSYSTEMD
if (jfd) {
int ret = journald_entry(&ctl, jfd);
if (stdin != jfd)
fclose(jfd);
if (ret)
errx(EXIT_FAILURE, _("journald entry could not be written"));
return EXIT_SUCCESS;
}
#endif
switch (unix_socket_errors_mode) {
case AF_UNIX_ERRORS_OFF:
ctl.unix_socket_errors = 0;
break;
case AF_UNIX_ERRORS_ON:
ctl.unix_socket_errors = 1;
break;
case AF_UNIX_ERRORS_AUTO:
ctl.unix_socket_errors = ctl.noact || ctl.stderr_printout;
#ifdef HAVE_LIBSYSTEMD
ctl.unix_socket_errors |= !!sd_booted();
#endif
break;
default:
abort();
}
logger_open(&ctl);
if (0 < argc)
logger_command_line(&ctl, argv);
else
/* Note. --file <arg> reopens stdin making the below
* function to be used for file inputs. */
logger_stdin(&ctl);
logger_close(&ctl);
return EXIT_SUCCESS;
}
static int logger_rollFiles(LOG_PROPERTIES_T *pLogProperties) {
int i;
char buf[16];
char logNameOld[sizeof(pLogProperties->g_logName) + sizeof(buf)];
char logNameNew[sizeof(pLogProperties->g_logName) + sizeof(buf)];
size_t len;
//struct timeval tv0, tv1;
//int ms;
#ifdef WIN32
struct _stat st;
#else // WIN32
struct stat st;
#endif // WIN32
//gettimeofday(&tv0, NULL);
len = strlen(pLogProperties->g_logName);
strcpy(logNameOld, pLogProperties->g_logName);
strcpy(logNameNew, pLogProperties->g_logName);
for(i = pLogProperties->g_maxFilesNum; i >= 1; i--) {
if(i <= 1) {
logger_close(pLogProperties);
logNameOld[len] = '\0';
} else {
sprintf(buf, ".%d", i-1);
strcpy(&logNameOld[len], buf);
}
#ifdef WIN32
if(_stat(logNameOld, &st) == 0) {
#else // WIN32
if(stat(logNameOld, &st) == 0) {
#endif // WIN32
sprintf(buf, ".%d", i);
strcpy(&logNameNew[len], buf);
if(fileops_MoveFile(logNameOld, logNameNew) != 0) {
// call internal logger_log method to avoid infinite loop possibility by
// checking for roll
logger_log(pLogProperties, X_ERROR("failed to move file '%s' -> '%s'"), logNameOld, logNameNew);
}
}
}
logger_open(pLogProperties);
//gettimeofday(&tv1, NULL);
//ms = ((tv1.tv_sec - tv0.tv_sec) * 1000) + ((tv1.tv_usec - tv0.tv_usec) / 1000);
// call internal logger_log method to avoid infinite loop possibility by
// checking for roll
//logger_log(pLogProperties, X_DEBUG("logger_rollFiles took %d ms to complete."), ms);
return 0;
}
extern void avc_dumpHex(void *fparg, const unsigned char *buf, unsigned int len, int ascii);
void logger_LogHex(int sev, const void *buf, unsigned int len, int printAscii) {
LOG_PROPERTIES_T *pLogProperties = NULL;
pLogProperties = g_plogProps;
if(!((pLogProperties->g_log_flags & (LOG_FLAG_USESYSLOG | LOG_FLAG_USESTDERR)) ||
(pLogProperties->g_fp != NULL && (pLogProperties->g_log_flags & LOG_FLAG_USEFILEOUTPUT)))) {
return;
}
if(pLogProperties->g_log_flags & LOG_FLAG_USELOCKING) {
pthread_mutex_lock(&pLogProperties->g_mtx_log);
}
if((pLogProperties->g_log_flags & LOG_FLAG_USESTDERR) &&
((sev > 0 && sev <= pLogProperties->g_log_level_stderr) ||
(sev < 0 && sev >= (-1 * pLogProperties->g_log_level_stderr)))) {
avc_dumpHex(stderr, (const unsigned char *) buf, len, printAscii);
}
if(pLogProperties->g_fp &&
(pLogProperties->g_log_flags & LOG_FLAG_USEFILEOUTPUT) &&
((sev > 0 && sev <= pLogProperties->g_log_level) ||
(sev < 0 && sev >= (-1 * pLogProperties->g_log_level)))) {
avc_dumpHex(pLogProperties->g_fp, (const unsigned char *) buf, len, printAscii);
if(logger_checkRoll(pLogProperties) > 0) {
logger_rollFiles(pLogProperties);
}
}
if(pLogProperties->g_log_flags & LOG_FLAG_USELOCKING) {
pthread_mutex_unlock(&pLogProperties->g_mtx_log);
}
}
int logger_Init(const char *filePath,
const char *fileName,
unsigned int maxFilesNum,
unsigned int maxFileSz,
unsigned int outputFlags) {
size_t len = 0u, len2 = 0u;
LOG_PROPERTIES_T *pLogProperties = g_plogProps;
// Init of "global" variables
pthread_mutex_init(&pLogProperties->g_mtx_log, NULL);
pLogProperties->g_maxFilesNum = LOGGER_MAX_FILES;
pLogProperties->g_maxFileSz = LOGGER_MAX_FILE_SZ;
pLogProperties->g_fp = NULL;
pLogProperties->g_fd = -1;
pLogProperties->g_log_flags = outputFlags;
//if(!(pLogProperties->g_log_flags & LOG_FLAG_USEFILEOUTPUT)) {
// pLogProperties->g_log_flags |= LOG_FLAG_DEFAULT;
//}
if(pLogProperties->g_log_level == 0) {
pLogProperties->g_log_level = S_INFO;
}
pLogProperties->g_log_level_stderr = pLogProperties->g_log_level;
//if(pLogProperties->g_fp) {
// logger_close(pLogProperties);
// pLogProperties->g_logName[0] = '\0';
//}
if(fileName == NULL) {
pLogProperties->g_log_flags &= ~LOG_FLAG_USEFILEOUTPUT;
return -1;
}
if(maxFilesNum > 0) {
pLogProperties->g_maxFilesNum = maxFilesNum;
}
if(maxFileSz > 0) {
pLogProperties->g_maxFileSz = maxFileSz;
}
if(filePath) {
len = strlen(filePath);
}
len2 = strlen(fileName);
if(len + len2 + 6 >= sizeof(pLogProperties->g_logName)) {
return -1;
}
memset(pLogProperties->g_logName, 0, sizeof(pLogProperties->g_logName));
if(filePath && len > 0) {
strncpy(pLogProperties->g_logName, filePath, sizeof(pLogProperties->g_logName) -1);
if(pLogProperties->g_logName[len - 1] != DIR_DELIMETER) {
pLogProperties->g_logName[len++] = DIR_DELIMETER;
}
}
strncpy(&pLogProperties->g_logName[len], fileName, sizeof(pLogProperties->g_logName) - (len +1));
len += len2;
if(!strstr(fileName, ".log")) {
strncat(&pLogProperties->g_logName[len], ".log", sizeof(pLogProperties->g_logName) - (len+1));
}
return logger_open(pLogProperties);
}
int logger_SetFile(const char *fileDir,
const char *fileName,
unsigned int maxFilesNum,
unsigned int maxFileSz,
unsigned int outputFlags) {
size_t len = 0u, len2 = 0u;
LOG_PROPERTIES_T *pLogProperties = g_plogProps;
pthread_mutex_init(&pLogProperties->g_mtx_log, NULL);
if(pLogProperties->g_fp) {
logger_close(pLogProperties);
}
if(!fileName) {
return -1;
}
//
// Init of "global" variables
//
pLogProperties->g_maxFilesNum = maxFilesNum;
pLogProperties->g_maxFileSz = maxFileSz;
// XOR with flags suitable for fileoutput
pLogProperties->g_log_flags |= LOG_FLAG_USEFILEOUTPUT | (outputFlags &
(LOG_FLAG_USELOCKING | LOG_OUTPUT_PRINT_DATE | LOG_OUTPUT_PRINT_SEV | LOG_OUTPUT_PRINT_SEV_ERROR |
LOG_OUTPUT_PRINT_PID | LOG_OUTPUT_PRINT_TID | LOG_OUTPUT_PRINT_TAG));
if(fileDir) {
len = strlen(fileDir);
}
len2 = strlen(fileName);
if(len + len2 + 6 >= sizeof(pLogProperties->g_logName)) {
return -1;
}
memset(pLogProperties->g_logName, 0, sizeof(pLogProperties->g_logName));
if(fileDir && len > 0) {
strncpy(pLogProperties->g_logName, fileDir, sizeof(pLogProperties->g_logName) -1);
if(pLogProperties->g_logName[len - 1] != DIR_DELIMETER) {
pLogProperties->g_logName[len++] = DIR_DELIMETER;
}
}
strncpy(&pLogProperties->g_logName[len], fileName,
sizeof(pLogProperties->g_logName) - (len +1));
len += len2;
if(!strstr(fileName, ".log")) {
strncat(&pLogProperties->g_logName[len], ".log",
sizeof(pLogProperties->g_logName) - (len+1));
}
return logger_open(pLogProperties);
}
/*
* logger -- read and log utility
*
* Reads from an input and arranges to write the result on the system
* log.
*/
int main(int argc, char **argv)
{
struct logger_ctl ctl = {
.fd = -1,
.pid = 0,
.pri = LOG_NOTICE,
.prio_prefix = 0,
.tag = NULL,
.unix_socket = NULL,
.server = NULL,
.port = NULL,
.socket_type = ALL_TYPES,
.rfc5424_time = 1,
.rfc5424_tq = 1,
.rfc5424_host = 1,
};
int ch;
int stdout_reopened = 0;
#ifdef HAVE_LIBSYSTEMD
FILE *jfd = NULL;
#endif
static const struct option longopts[] = {
{ "id", optional_argument, 0, 'i' },
{ "stderr", no_argument, 0, 's' },
{ "file", required_argument, 0, 'f' },
{ "priority", required_argument, 0, 'p' },
{ "tag", required_argument, 0, 't' },
{ "socket", required_argument, 0, 'u' },
{ "udp", no_argument, 0, 'd' },
{ "tcp", no_argument, 0, 'T' },
{ "server", required_argument, 0, 'n' },
{ "port", required_argument, 0, 'P' },
{ "version", no_argument, 0, 'V' },
{ "help", no_argument, 0, 'h' },
{ "prio-prefix", no_argument, 0, OPT_PRIO_PREFIX },
{ "rfc3164", no_argument, 0, OPT_RFC3164 },
{ "rfc5424", optional_argument, 0, OPT_RFC5424 },
#ifdef HAVE_LIBSYSTEMD
{ "journald", optional_argument, 0, OPT_JOURNALD },
#endif
{ NULL, 0, 0, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((ch = getopt_long(argc, argv, "f:i::p:st:u:dTn:P:Vh",
longopts, NULL)) != -1) {
switch (ch) {
case 'f': /* file to log */
if (freopen(optarg, "r", stdin) == NULL)
err(EXIT_FAILURE, _("file %s"), optarg);
stdout_reopened = 1;
break;
case 'i': /* log process id also */
if (optarg) {
const char *p = optarg;
if (*p == '=')
p++;
ctl.pid = strtoul_or_err(optarg, _("failed to parse id"));
} else
ctl.pid = getpid();
break;
case 'p': /* priority */
ctl.pri = pencode(optarg);
break;
case 's': /* log to standard error */
ctl.stderr_printout = 1;
break;
case 't': /* tag */
ctl.tag = optarg;
break;
case 'u': /* unix socket */
ctl.unix_socket = optarg;
break;
case 'd':
ctl.socket_type = TYPE_UDP;
break;
case 'T':
ctl.socket_type = TYPE_TCP;
break;
case 'n':
ctl.server = optarg;
break;
case 'P':
ctl.port = optarg;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
case 'h':
usage(stdout);
case OPT_PRIO_PREFIX:
ctl.prio_prefix = 1;
break;
case OPT_RFC3164:
ctl.syslogfp = syslog_rfc3164;
break;
case OPT_RFC5424:
ctl.syslogfp = syslog_rfc5424;
if (optarg)
parse_rfc5424_flags(&ctl, optarg);
break;
#ifdef HAVE_LIBSYSTEMD
case OPT_JOURNALD:
if (optarg) {
jfd = fopen(optarg, "r");
if (!jfd)
err(EXIT_FAILURE, _("cannot open %s"),
optarg);
} else
jfd = stdin;
break;
#endif
case '?':
default:
usage(stderr);
}
}
argc -= optind;
argv += optind;
if (stdout_reopened && argc)
warnx(_("--file <file> and <message> are mutually exclusive, message is ignored"));
#ifdef HAVE_LIBSYSTEMD
if (jfd) {
int ret = journald_entry(jfd);
if (stdin != jfd)
fclose(jfd);
if (ret)
errx(EXIT_FAILURE, _("journald entry could not be wrote"));
return EXIT_SUCCESS;
}
#endif
logger_open(&ctl);
if (0 < argc)
logger_command_line(&ctl, argv);
else
/* Note. --file <arg> reopens stdin making the below
* function to be used for file inputs. */
logger_stdin(&ctl);
logger_close(&ctl);
return EXIT_SUCCESS;
}
logger_printf(logfile, "%04d-%02d-%02d %2d:%02d:%02d "
"%s ERROR %d: %s : %s\n",
t.tm_year + 1900, t.tm_mon + 1,
t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec,
event->general_user, event->general_error_code,
event->general_command, event->general_query);
}
}
}
static int sql_error_log_init(void *p __attribute__((unused)))
{
logger_init_mutexes();
logfile= logger_open(filename, size_limit, rotations);
if (logfile == NULL) {
fprintf(stderr, "Could not create file '%s'\n",
filename);
return 1;
}
count = 0;
return 0;
}
static int sql_error_log_deinit(void *p __attribute__((unused)))
{
if (logfile)
logger_close(logfile);
return 0;
int
main(int argc, char *argv[]) {
int ret = EX_OK;
primwatch_t primwatch;
const char *log_type;
const char *log_facility;
const char *log_prefix;
char log_path[MAXPATHLEN];
const char *pid_file_path;
const char *cntrl_addr;
const char *cntrl_port;
int64_t verbose_level;
if (logger_create()) {
fprintf(stderr, "failed in create logger");
ret = EX_OSERR;
}
if (primwatch_initialize(&primwatch)) {
fprintf(stderr, "failed in initaizliae");
ret = EX_OSERR;
goto last;
}
parse_args(&primwatch, argc, argv);
if (logger_set_foreground(primwatch.foreground)) {
fprintf(stderr, "failed in create logger");
ret = EX_OSERR;
}
if (config_manager_load(primwatch.config_manager, primwatch.config_file)) {
LOG(LOG_LV_ERR, "failed in load config file %s", primwatch.config_file);
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &log_type , "logType", NULL)) {
LOG(LOG_LV_ERR, "failed in get log type from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &log_facility , "logFacility", NULL)) {
LOG(LOG_LV_ERR, "failed in get log facility from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &log_prefix , "logPath", NULL)) {
LOG(LOG_LV_ERR, "failed in get log path from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &pid_file_path , "pidFilePath", NULL)) {
LOG(LOG_LV_ERR, "failed in get pid file path from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &cntrl_addr , "controllerAddress", NULL)) {
LOG(LOG_LV_ERR, "failed in get controller address from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &cntrl_port , "controllerPort", NULL)) {
LOG(LOG_LV_ERR, "failed in get controller port from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_long(primwatch.config_manager, &verbose_level , "verboseLevel", NULL)) {
LOG(LOG_LV_ERR, "failed in get verbose level from config");
ret = EX_DATAERR;
goto last;
}
snprintf(log_path, sizeof(log_path), "%s.daemon", log_prefix);
if (logger_open((log_level_t)verbose_level, log_type, PROGIDENT, LOG_PID, log_facility, log_path)) {
LOG(LOG_LV_ERR, "failed in open log");
ret = EX_OSERR;
goto last;
}
if (!primwatch.foreground) {
if (daemon(1,1)) {
LOG(LOG_LV_ERR, "failed in daemon");
ret = EX_OSERR;
goto last;
}
setsid();
}
if (primwatch_event_initialize(&primwatch)) {
fprintf(stderr, "failed in initaizliae");
ret = EX_OSERR;
goto last;
}
if (make_pidfile(pid_file_path)) {
LOG(LOG_LV_ERR, "failed in create file of process id");
ret = EX_OSERR;
goto last;
}
if (watcher_polling_start(primwatch.watcher)) {
LOG(LOG_LV_ERR, "failed in initial polling");
ret = EX_OSERR;
goto last;
}
if (controller_start(primwatch.controller, cntrl_addr, cntrl_port)) {
LOG(LOG_LV_ERR, "failed in start controller");
ret = EX_OSERR;
goto last;
}
signal_set(&primwatch.sig_int_event, SIGINT, primwatch_terminate, &primwatch);
event_priority_set(&primwatch.sig_int_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_int_event);
signal_add(&primwatch.sig_int_event, NULL);
signal_set(&primwatch.sig_term_event, SIGTERM, primwatch_terminate, &primwatch);
event_priority_set(&primwatch.sig_term_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_term_event);
signal_add(&primwatch.sig_term_event, NULL);
signal_set(&primwatch.sig_hup_event, SIGHUP, primwatch_reload, &primwatch);
event_priority_set(&primwatch.sig_hup_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_hup_event);
signal_add(&primwatch.sig_hup_event, NULL);
signal_set(&primwatch.sig_chld_event, SIGCHLD, primwatch_sigchild, &primwatch);
event_priority_set(&primwatch.sig_chld_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_chld_event);
signal_add(&primwatch.sig_chld_event, NULL);
if (event_base_dispatch(primwatch.event_base) == -1) {
LOG(LOG_LV_ERR, "failed in event base dispatch");
ret = EX_OSERR;
goto last;
}
last:
unlink(pid_file_path);
logger_close();
logger_destroy();
primwatch_finalize(&primwatch);
return ret;
}
void _main(int argc, char *argv[])
{
(void)argc;
(void)argv;
syslog(LOG_INFO, "initializing core");
/* init SCL subsystem: */
syslog(LOG_INFO, "initializing signaling and communication link (SCL)");
if (scl_init("core") != 0)
{
syslog(LOG_CRIT, "could not init scl module");
exit(EXIT_FAILURE);
}
/* init params subsystem: */
syslog(LOG_INFO, "initializing opcd interface");
opcd_params_init("core.", 1);
/* initialize logger: */
syslog(LOG_INFO, "opening logger");
if (logger_open() != 0)
{
syslog(LOG_CRIT, "could not open logger");
exit(EXIT_FAILURE);
}
syslog(LOG_CRIT, "logger opened");
sleep(1); /* give scl some time to establish
a link between publisher and subscriber */
LOG(LL_INFO, "+------------------+");
LOG(LL_INFO, "| core startup |");
LOG(LL_INFO, "+------------------+");
LOG(LL_INFO, "initializing system");
/* set-up real-time scheduling: */
struct sched_param sp;
sp.sched_priority = sched_get_priority_max(SCHED_FIFO);
sched_setscheduler(getpid(), SCHED_FIFO, &sp);
if (mlockall(MCL_CURRENT | MCL_FUTURE))
{
LOG(LL_ERROR, "mlockall() failed");
exit(EXIT_FAILURE);
}
/* initialize hardware/drivers: */
omap_i2c_bus_init();
baro_altimeter_init();
ultra_altimeter_init();
ahrs_init();
motors_init();
voltage_reader_start();
//gps_init();
LOG(LL_INFO, "initializing model/controller");
model_init();
ctrl_init();
/* initialize command interface */
LOG(LL_INFO, "initializing cmd interface");
cmd_init();
/* prepare main loop: */
for (int i = 0; i < NUM_AVG; i++)
{
output_avg[i] = sliding_avg_create(OUTPUT_RATIO, 0.0f);
}
LOG(LL_INFO, "system up and running");
struct timespec ts_curr;
struct timespec ts_prev;
struct timespec ts_diff;
clock_gettime(CLOCK_REALTIME, &ts_curr);
/* run model and controller: */
while (1)
{
/* calculate dt: */
ts_prev = ts_curr;
clock_gettime(CLOCK_REALTIME, &ts_curr);
TIMESPEC_SUB(ts_diff, ts_curr, ts_prev);
float dt = (float)ts_diff.tv_sec + (float)ts_diff.tv_nsec / (float)NSEC_PER_SEC;
/* read sensor values into model input structure: */
model_input_t model_input;
model_input.dt = dt;
ahrs_read(&model_input.ahrs_data);
gps_read(&model_input.gps_data);
model_input.ultra_z = ultra_altimeter_read();
model_input.baro_z = baro_altimeter_read();
/* execute model step: */
model_state_t model_state;
model_step(&model_state, &model_input);
/* execute controller step: */
mixer_in_t mixer_in;
ctrl_step(&mixer_in, dt, &model_state);
/* set up mixer input: */
mixer_in.pitch = sliding_avg_calc(output_avg[AVG_PITCH], mixer_in.pitch);
mixer_in.roll = sliding_avg_calc(output_avg[AVG_ROLL], mixer_in.roll);
mixer_in.yaw = sliding_avg_calc(output_avg[AVG_YAW], mixer_in.yaw);
mixer_in.gas = sliding_avg_calc(output_avg[AVG_GAS], mixer_in.gas);
/* write data to motor mixer: */
EVERY_N_TIMES(OUTPUT_RATIO, motors_write(&mixer_in));
}
}
void main_init(int argc, char *argv[])
{
bool override_hw = false;
if (argc > 1)
{
if (strcmp(argv[1], "calibrate") == 0)
calibrate = true;
else
override_hw = true;
}
/* init data structures: */
memset(&pos_in, 0, sizeof(pos_in_t));
vec3_init(&pos_in.acc);
/* init SCL subsystem: */
syslog(LOG_INFO, "initializing signaling and communication link (SCL)");
if (scl_init("pilot") != 0)
{
syslog(LOG_CRIT, "could not init scl module");
die();
}
/* init params subsystem: */
syslog(LOG_INFO, "initializing opcd interface");
opcd_params_init("pilot.", 1);
/* initialize logger: */
syslog(LOG_INFO, "opening logger");
if (logger_open() != 0)
{
syslog(LOG_CRIT, "could not open logger");
die();
}
syslog(LOG_CRIT, "logger opened");
LOG(LL_INFO, "initializing platform");
if (arcade_quad_init(&platform, override_hw) < 0)
{
LOG(LL_ERROR, "could not initialize platform");
die();
}
acc_mag_cal_init();
cmc_init();
const size_t array_len = sizeof(float) * platform.n_motors;
setpoints = malloc(array_len);
ASSERT_NOT_NULL(setpoints);
memset(setpoints, 0, array_len);
rpm_square = malloc(array_len);
ASSERT_NOT_NULL(rpm_square);
memset(rpm_square, 0, array_len);
LOG(LL_INFO, "initializing model/controller");
pos_init();
ne_speed_ctrl_init(REALTIME_PERIOD);
att_ctrl_init();
yaw_ctrl_init();
u_ctrl_init();
u_speed_init();
navi_init();
LOG(LL_INFO, "initializing command interface");
cmd_init();
motors_state_init();
blackbox_init();
/* init flight logic: */
flight_logic_init();
/* init calibration data: */
cal_init(&gyro_cal, 3, 1000);
cal_ahrs_init();
flight_state_init(50, 150, 4.0);
piid_init(REALTIME_PERIOD);
interval_init(&gyro_move_interval);
gps_data_init(&gps_data);
mag_decl_init();
cal_init(&rc_cal, 3, 500);
tsfloat_t acc_fg;
opcd_param_t params[] =
{
{"acc_fg", &acc_fg},
OPCD_PARAMS_END
};
opcd_params_apply("main.", params);
filter1_lp_init(&lp_filter, tsfloat_get(&acc_fg), 0.06, 3);
cm_init();
mon_init();
LOG(LL_INFO, "entering main loop");
}
int
log_content_open(log_content_ctx_t **pctx, opts_t *opts,
char *srchost, char *srcport,
char *dsthost, char *dstport,
char *exec_path, char *user, char *group)
{
log_content_ctx_t *ctx;
if (*pctx)
return 0;
*pctx = malloc(sizeof(log_content_ctx_t));
if (!*pctx)
return -1;
ctx = *pctx;
if (opts->contentlog_isdir) {
/* per-connection-file content log (-S) */
char timebuf[24];
time_t epoch;
struct tm *utc;
char *dsthost_clean, *srchost_clean;
if (time(&epoch) == -1) {
log_err_printf("Failed to get time\n");
goto errout;
}
if ((utc = gmtime(&epoch)) == NULL) {
log_err_printf("Failed to convert time: %s (%i)\n",
strerror(errno), errno);
goto errout;
}
if (!strftime(timebuf, sizeof(timebuf),
"%Y%m%dT%H%M%SZ", utc)) {
log_err_printf("Failed to format time: %s (%i)\n",
strerror(errno), errno);
goto errout;
}
srchost_clean = sys_ip46str_sanitize(srchost);
if (!srchost_clean) {
log_err_printf("Failed to sanitize srchost\n");
goto errout;
}
dsthost_clean = sys_ip46str_sanitize(dsthost);
if (!dsthost_clean) {
log_err_printf("Failed to sanitize dsthost\n");
free(srchost_clean);
goto errout;
}
if (asprintf(&ctx->u.dir.filename, "%s/%s-%s,%s-%s,%s.log",
opts->contentlog, timebuf,
srchost_clean, srcport,
dsthost_clean, dstport) < 0) {
log_err_printf("Failed to format filename: %s (%i)\n",
strerror(errno), errno);
free(srchost_clean);
free(dsthost_clean);
goto errout;
}
free(srchost_clean);
free(dsthost_clean);
} else if (opts->contentlog_isspec) {
/* per-connection-file content log with logspec (-F) */
char *dsthost_clean, *srchost_clean;
srchost_clean = sys_ip46str_sanitize(srchost);
if (!srchost_clean) {
log_err_printf("Failed to sanitize srchost\n");
goto errout;
}
dsthost_clean = sys_ip46str_sanitize(dsthost);
if (!dsthost_clean) {
log_err_printf("Failed to sanitize dsthost\n");
free(srchost_clean);
goto errout;
}
ctx->u.spec.filename = log_content_format_pathspec(
opts->contentlog,
srchost_clean, srcport,
dsthost_clean, dstport,
exec_path, user, group);
free(srchost_clean);
free(dsthost_clean);
if (!ctx->u.spec.filename) {
goto errout;
}
} else {
/* single-file content log (-L) */
if (asprintf(&ctx->u.file.header_req, "[%s]:%s -> [%s]:%s",
srchost, srcport, dsthost, dstport) < 0) {
goto errout;
}
if (asprintf(&ctx->u.file.header_resp, "[%s]:%s -> [%s]:%s",
dsthost, dstport, srchost, srcport) < 0) {
free(ctx->u.file.header_req);
goto errout;
}
}
/* submit an open event */
if (logger_open(content_log, ctx) == -1)
goto errout;
ctx->open = 1;
return 0;
errout:
free(ctx);
*pctx = NULL;
return -1;
}
int main(int argc, char *argv[])
{
int ch, num = 10;
char* addr = strdup("127.0.0.1:19999");
void (*func)(const char* addr, int num, bool enable_cache) = NULL;
bool use_mysql = false, enable_cache = false;
while ((ch = getopt(argc, argv, "hs:aqgQuUn:mdc")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return (0);
case 's':
free(addr);
addr = strdup(optarg);
break;
case 'a':
func = hs_insert;
break;
case 'q':
func = hs_find;
break;
case 'g':
func = hs_find2;
break;
case 'Q':
func = hspool_find;
break;
case 'u':
func = hs_update;
break;
case 'U':
func = hspool_update;
break;
case 'n':
num = atoi(optarg);
break;
case 'm':
use_mysql = true;
break;
case 'd':
debug_on = true;
break;
case 'c':
enable_cache = true;
break;
default:
break;
}
}
if (use_mysql)
{
printf("mysql\n");
my_find(addr, num);
return (0);
}
logger_open("test.log", "test", "all:2");
if (func != NULL)
func(addr, num, enable_cache);
else
usage(argv[0]);
free(addr);
return (0);
}
