int NLog::startup( const char* _log_path, int _level, int _daemon_mode ) { if ( start() < 0 ) return -1; if ( ! _log_path ) return -1; strncpy( log_path_, _log_path, sizeof(log_path_) ); daemon_mode_ = _daemon_mode; if( !daemon_mode_ ) { for ( int i = 0; i < MAX_LOG_TYPE; i++ ) log_[i] = stdout; } else { log_[ LOG_TYPE_FATAL ] = open_log_file( "fatal" ); log_[ LOG_TYPE_EMERGENCY ] = open_log_file( "emergency" ); log_[ LOG_TYPE_ERROR ] = open_log_file( "error" ); log_[ LOG_TYPE_LOG ] = open_log_file( "log" ); log_[ LOG_TYPE_DEBUG ] = open_log_file( "debug" ); } set_level( _level ); return 0; }
bool log_init() { //Creat log directory if(mkdir(LOG_DIR, S_IRWXU | S_IRWXG | S_IRWXO) != 0) { if(errno != EEXIST) { return false; } } //Read config max_size = cfg_get_log_file_size(); max_num = cfg_get_log_file_num(); //Open log file ssh_fp = open_log_file(SSH_LOG_NAME, &ssh_log_num, &ssh_size); if(ssh_fp == NULL) { return false; } minecraft_fp = open_log_file(MC_LOG_NAME, &mc_log_num, &mc_size); if(minecraft_fp == NULL) { fclose(ssh_fp); return false; } //Initialize mutex pthread_mutex_init(&ssh_mutex, NULL); pthread_mutex_init(&mc_mutex, NULL); return true; }
void open_all_log_files() { // disable stdin open_log_file(STDIN_FILENO, &stdin, "/dev/null", NULL); open_log_file(STDOUT_FILENO, &stdout, stdout_filename, &output_log_syslog); open_log_file(STDERR_FILENO, &stderr, stderr_filename, &error_log_syslog); stdaccess_fd = open_log_file(stdaccess_fd, &stdaccess, stdaccess_filename, &access_log_syslog); }
void reopen_all_log_files() { if(stdout_filename) open_log_file(STDOUT_FILENO, &stdout, stdout_filename, &output_log_syslog); if(stderr_filename) open_log_file(STDERR_FILENO, &stderr, stderr_filename, &error_log_syslog); if(stdaccess_filename) stdaccess_fd = open_log_file(stdaccess_fd, &stdaccess, stdaccess_filename, &access_log_syslog); }
static VALUE bossan_access_log(VALUE self, VALUE args) { log_path = StringValuePtr(args); if(log_fd > 0){ close(log_fd); } if(!strcasecmp(log_path, "stdout")){ log_fd = 1; return Qnil; } if(!strcasecmp(log_path, "stderr")){ log_fd = 2; return Qnil; } log_fd = open_log_file(log_path); if(log_fd < 0){ rb_raise(rb_eTypeError, "not open file. %s", log_path); } return Qnil; }
static gboolean write_log_for_event (CkLogEvent *event) { GString *str; FILE *file; int fd; str = g_string_new (NULL); ck_log_event_to_string (event, str); if (! open_log_file (DEFAULT_LOG_FILENAME, &fd, &file)) { exit (1); } if (file != NULL) { int rc; rc = fprintf (file, "%s\n", str->str); if (rc <= 0) { g_warning ("Record was not written to disk (%s)", g_strerror (errno)); } } else { g_warning ("Log file not open for writing"); } g_string_free (str, TRUE); return TRUE; }
void perf_end(const char* kname) { if (!enabled) return; int i, n; prctl(PR_TASK_PERF_EVENTS_DISABLE); static int first_time = 1; if (first_time) { first_time = 0; char name[128]; for (n = 0; n < g_nthreads; n++) { sprintf (name, mxpa_profile_log, n); FILE* fp = fopen(name, "w"); fclose(fp); } } char name[128]; for (n = 0; n < g_nthreads; n++) { sprintf (name, mxpa_profile_log, n); FILE* fp = open_log_file(name); perf_event_desc_t *fds = g_fds[n]; print_counts(fds, num_fds, kname, fp); for (i = 0; i < num_fds; i++) close(fds[i].fd); perf_free_fds(fds, num_fds); g_fds[n] = fds = NULL; fclose(fp); } }
int SrsFastLog::on_reload_log_tank() { int ret = ERROR_SUCCESS; if (!_srs_config) { return ret; } bool tank = log_to_file_tank; log_to_file_tank = _srs_config->get_log_tank_file(); if (tank) { return ret; } if (!log_to_file_tank) { return ret; } if (fd > 0) { ::close(fd); } open_log_file(); return ret; }
JNIEXPORT jint JNICALL Java_org_openoverlayrouter_noroot_OOR_1JNI_oor_1start (JNIEnv *env, jobject thisObj, jint vpn_tun_fd, jstring storage_path) { oor_dev_type_e dev_type; jintArray fd_list; uint32_t iseed = 0; /* initial random number generator */ pid_t pid = 0; /* child pid */ pid_t sid = 0; char log_file[1024]; const char *path = NULL; lisp_xtr_t *tunnel_router; memset (log_file,0,sizeof(char)*1024); initial_setup(); jni_init(env,thisObj); /* create socket master, timer wheel, initialize interfaces */ smaster = sockmstr_create(); oor_timers_init(); ifaces_init(); /* create control. Only one instance for now */ lctrl = ctrl_create(); /* Detect the data plane type */ data_plane_select(); /** parse config and create ctrl_dev **/ /* obtain the configuration file */ path = (*env)->GetStringUTFChars(env, storage_path, 0); config_file = calloc(1024, sizeof(char)); strcat(config_file,path); strcat(config_file,"oor.conf"); strcat(log_file,path); strcat(log_file,"oor.log"); (*env)->ReleaseStringUTFChars(env, storage_path, path); open_log_file(log_file); if (parse_config_file()!=GOOD){ exit_cleanup(); close(vpn_tun_fd); return (BAD); } dev_type = ctrl_dev_mode(ctrl_dev); if (dev_type == xTR_MODE || dev_type == RTR_MODE || dev_type == MN_MODE) { OOR_LOG(LDBG_2, "Configuring data plane"); tunnel_router = CONTAINER_OF(ctrl_dev, lisp_xtr_t, super); data_plane->datap_init(dev_type, tr_get_encap_type(tunnel_router), vpn_tun_fd); OOR_LOG(LDBG_1, "Data plane initialized"); } ctrl_init(lctrl); init_netlink(); /* run lisp control device xtr/ms */ if (!ctrl_dev) { OOR_LOG(LDBG_1, "device NULL"); return (BAD); } return (GOOD); }
void kstat_init() { kstat_frequency_per_msec = get_timer_frequency(); kstat_ignore_context_switch = KSTAT_OUTLIER_THRESHOLD_MS * kstat_frequency_per_msec; LOG(GLOBAL, LOG_STATS, 1, "Processor speed: "UINT64_FORMAT_STRING"MHz\n", kstat_frequency_per_msec/1000); /* FIXME: There is no check for TSC feature and whether CR4.TSD is set * so we can read it at CPL 3 */ if (!DYNAMO_OPTION(kstats)) return; kstat_init_variables(&process_kstats); #ifdef DEBUG process_kstats_outfile = GLOBAL; #else /* Open a process-wide kstats file. open_thread_private_file() does the * job when passed the appropriate basename (2nd arg). */ process_kstats_outfile = open_log_file(kstats_main_logfile_name(), NULL, 0); #endif }
/** * Initializes the Logger. This creates a log file to which messages * are written. * * @param ident name of the log file, used as an identifier. * @param log_directory the directory in which log file is created. * @param type log output type. * @return true on success; false otherwise. */ bool init_log( const char *ident, const char *directory, logging_type type ) { assert( ident != NULL ); assert( directory != NULL ); pthread_mutex_lock( &mutex ); // set_logging_level() may be called before init_log(). // level = -1 indicates that logging level is not set yet. if ( level < 0 || level > LOG_DEBUG ) { level = LOG_INFO; } char *level_string = getenv( "LOGGING_LEVEL" ); if ( level_string != NULL ) { set_logging_level( level_string ); } set_ident_string( ident ); set_log_directory( directory ); output = type; if ( output & LOGGING_TYPE_FILE ) { fd = open_log_file( false ); } if ( output & LOGGING_TYPE_SYSLOG ) { open_log_syslog(); } initialized = true; pthread_mutex_unlock( &mutex ); return true; }
void kstat_thread_init(dcontext_t *dcontext) { thread_kstats_t *new_thread_kstats; if (!DYNAMO_OPTION(kstats)) return; /* dcontext->thread_kstats stays NULL */ /* allocated on thread heap - use global if timing initialization matters */ new_thread_kstats = HEAP_TYPE_ALLOC(dcontext, thread_kstats_t, ACCT_STATS, UNPROTECTED); LOG(THREAD, LOG_STATS, 2, "thread_kstats="PFX" size=%d\n", new_thread_kstats, sizeof(thread_kstats_t)); /* initialize any thread stats bookkeeping fields before assigning to dcontext */ kstat_init_variables(&new_thread_kstats->vars_kstats); /* add a dummy node to save one branch in UPDATE_CURRENT_COUNTER */ new_thread_kstats->stack_kstats.depth = 1; new_thread_kstats->thread_id = get_thread_id(); #ifdef DEBUG new_thread_kstats->outfile_kstats = THREAD; #else new_thread_kstats->outfile_kstats = open_log_file(kstats_thread_logfile_name(), NULL, 0); #endif dcontext->thread_kstats = new_thread_kstats; /* need to do this in a thread after it's initialized */ kstat_calibrate(); KSTART_DC(dcontext, thread_measured); LOG(THREAD, LOG_STATS, 2, "threads_started\n"); }
int main (int argc, char ** argv){ int i; signal(SIGINT, sigint_handler); if (open_log_file() != 0) { printf("Error opening log file\n"); return -1; } if(create_db_comm() <0){ LOG_MESSAGE("could not create db comm\n"); return -1; } if(create_hist_comm() <0){ LOG_MESSAGE("could not create hist comm\n"); finish_with_error(con); return -1; } while(running){ check_packet(); } LOG_MESSAGE("Total Receive %d - A:%d D:%d E:%d (%d) | Error: %d\n", (digital_msgs+analog_msgs+events_msgs), analog_msgs, digital_msgs, events_msgs, should_be_type_30, error_msgs); close(hist_socket_receive); mysql_close(con); return 0; }
static int write_log(const char *new_path, int fd, const char *data, size_t len) { int openfd; flock(fd, LOCK_EX); if(write(fd, data, len) < 0){ flock(fd, LOCK_UN); //reopen openfd = open_log_file(new_path); if(openfd < 0){ //fail return -1; } flock(openfd, LOCK_EX); if(write(openfd, data, len) < 0){ flock(openfd, LOCK_UN); // write fail return -1; } flock(openfd, LOCK_UN); return openfd; } flock(fd, LOCK_UN); return fd; }
static BOOL check_head_valid( void ) { fs_handle_type file; file = open_log_file(); if( file == FS_NULL_HANDLE ) { return FALSE; } // 로그크기(LOG_SIZE) 동일한지 검사 if( get_value( file, LOG_SIZE_POS, 6 ) != LOG_SIZE ) { goto _fail; } // 로그최대개수(MAX_LOG) 일치하는지 검사 if( get_value( file, MAX_POS, 4 ) != MAX_LOG ) { goto _fail; } pantech_fclose( file ); return TRUE; _fail: pantech_fclose( file ); pantech_fremove( LOG_PATH ); return FALSE; }
void msg(const int level, const char *fmt, ...) { static const size_t time_part_size = (4 + 1 + 2 + 1 + 2) + 1 + (2 + 1 + 2 + 1 + 2); // YYYY.MM.DD HH:MM:SS const int file_fd = open_log_file(); const int fd = file_fd >= 0 ? file_fd : 2; va_list lst, lst2; va_start(lst, fmt); va_copy(lst2, lst); const int isize = vsnprintf(NULL, 0, fmt, lst); const intmax_t pid = (intmax_t) getpid(); const size_t pid_part_size = snprintf(NULL, 0, "[%jd]", pid); char buf[1 + 1 + time_part_size + 1 + pid_part_size + 1 + isize + 1]; size_t sz = 0; buf[0] = level; buf[1] = '\t'; sz = 2; time_t timer; struct tm tm_info; strftime(&buf[sz], time_part_size + 1, "%Y.%m.%d %H:%M:%S", localtime_r((time(&timer), &timer), &tm_info) ); sz += time_part_size; buf[sz] = ' '; ++sz; sprintf(&buf[sz], "[%jd]", pid); sz += pid_part_size; buf[sz] = '\t'; ++sz; vsnprintf(&buf[sz], isize + 1, fmt, lst2); sz += isize; buf[sz] = '\n'; ++sz; va_end(lst); va_end(lst2); assert(sz == sizeof(buf)); for (size_t i = 0; i < sizeof(buf); ) { const ssize_t ret = write(fd, buf, sz); if (ret < 0) { return; } assert(ret > 0); i += (size_t)ret; } if (file_fd >= 0) { close(file_fd); } }
static BOOL load_head( LOG_HEADER_T* head ) { BOOL create = FALSE; fs_handle_type file; sys_mkdir(LOG_DIR, 0700);//make directory.. if((file = pantech_fopen( LOG_PATH, O_RDONLY, S_IRUSR | S_IWUSR)) != NULL) { if( check_head_valid() == FALSE ) { create = TRUE; } pantech_fclose(file); } else { create = TRUE; } if( create == TRUE ) { if( create_log_file() == FALSE ) { return FALSE; } } file = open_log_file(); if( file == FS_NULL_HANDLE ) { return FALSE; } head->first_log_pos_ = get_value( file, FIRST_LOG_POS, 6 ); // FIRST LOG head->count_ = get_value( file, LOG_COUNT_POS, 4 ); // 로그수 head->head_ = get_value( file, HEAD_POS, 4 ); // head head->tail_ = get_value( file, TAIL_POS, 4 ); // tail head->free_head_ = get_value( file, FREE_HEAD_POS, 4 ); // free head if( head->first_log_pos_ == (UINT32)-1 || head->count_ == (UINT32)-1 || head->head_ == (UINT32)-1 || head->tail_ == (UINT32)-1 || head->free_head_ == (UINT32)-1 ) { goto _fail; } if( get_prev_next( file, head ) == FALSE ) { goto _fail; } pantech_fclose( file ); return TRUE; _fail: pantech_fclose( file ); return FALSE; }
// Checks Either Log file opened or not. void linux_log_check(){ if (log_file_fd == STDERR_FILENO) { //printf("Log File not opened. Opening Log file \nNote: Here Standard stdout file is opened \n"); if(open_log_file(log_file) > STDERR_FILENO){ log_message(LG_MSG, "linux_logging started"); }else{ printf("Failed To open Log file\n"); } } }
void log_error(const char* msg){ open_log_file(); time_t now_timestamp = time(NULL); struct tm* now_time = localtime(&now_timestamp); fprintf(log_file, "[ERROR][%d / %d / %d][%d : %d : %d] : %s : %s\n", now_time->tm_mon, now_time->tm_mday, now_time->tm_year + 1990, now_time->tm_hour, now_time->tm_min, now_time->tm_sec, strerror(errno), msg); }
int pantech_logfile_save_log( const char* msg ) { fs_handle_type file; file = open_log_file(); if( file == FS_NULL_HANDLE ) { return -1; } if( g_head.count_ < MAX_LOG ) { IDX_T new_idx; new_idx = add_log( file, &g_head, msg ); if( new_idx == NULL_IDX ) return FALSE; if( set_value( file, LOG_COUNT_POS, g_head.count_, 4 ) == FALSE ) return FALSE; if( set_value( file, TAIL_POS, g_head.tail_, 4 ) == FALSE ) return FALSE; if( set_value( file, FREE_HEAD_POS, g_head.free_head_, 4 ) == FALSE ) return FALSE; if( set_prev_next( file, &g_head, new_idx ) == FALSE ) return FALSE; if( g_head.count_ == 1 ) { if( set_value( file, HEAD_POS, g_head.head_, 4 ) == FALSE ) return FALSE; } else { if( set_prev_next( file, &g_head, g_head.prev_[ new_idx ] ) == FALSE ) return FALSE; } } else { IDX_T idx; idx = g_head.head_; g_head.head_ = g_head.next_[ idx ]; g_head.free_head_ = idx; g_head.next_[ idx ] = NULL_IDX; g_head.count_--; if( add_log( file, &g_head, msg ) != idx ) return FALSE; if( set_value( file, HEAD_POS, g_head.head_, 4 ) == FALSE ) return FALSE; if( set_value( file, TAIL_POS, g_head.tail_, 4 ) == FALSE ) return FALSE; if( set_prev_next( file, &g_head, idx ) == FALSE ) return FALSE; if( set_prev_next( file, &g_head, g_head.prev_[ idx ] ) == FALSE ) return FALSE; } pantech_fclose( file ); return 0; }
static void log_init_file(const char *path, unsigned line) { out_filename = path; out_fd = open_log_file(); if (out_fd < 0) g_error("problem opening log file \"%s\" (config line %u) for " "writing\n", path, line); g_log_set_default_handler(file_log_func, NULL); }
/* * @brief 初始化,包括设置本次循环时间,改变工作目录,加载日志文件(每次循环都加载,以便修改配置文件后不需要重启),打开日志 * @prame 执行路径 argv[0] */ int initiate(char *path) { //获取程序运行时路径前缀,改变工作目录,找到配置文件、打开错误文件.他们与可执行程序位于同一目录 if (change_working_path(path) == -1) return -1; //在当前位置打开日志记录文件 if (open_log_file() == -1) { fprintf(stderr, "open log file failed!\n"); return -1; } return 0; }
void init_persist_log(void) { int ret = 0; int i = 0; pthread_t p_async_writer; log_fd_invalid = 1; ret = parser_log_configure(); if (ret < 0) { printf("parser_log_configure failed\n"); /* set the default value */ level_log = LOG_NOTICE; } if (open_log_file(PERSIST_LOG) < 0) { printf("open log file failed\n"); return; //just return, logdaemon without log } g_index = 0; while (i < 2) { pthread_mutex_init(&g_locks[i], NULL); g_buffer[i] = (char *)malloc(MAX_BUFFER_SIZE); if (NULL == g_buffer[i]) { goto failed; } memset(g_buffer[i], 0, MAX_BUFFER_SIZE); g_buffer_pos[i] = 0; i++; } if (pthread_create(&p_async_writer, NULL, async_write, NULL) < 0) { goto failed; } return; failed: if (g_buffer[0] != NULL) { free(g_buffer[0]); } if (g_buffer[1] != NULL) { free(g_buffer[1]); } log_fd_invalid = 1; return; //logdaemon without log }
static duk_ret_t js_new_Logger(duk_context* ctx) { const char* filename = duk_get_string(ctx, 0); char* path = get_asset_path(filename, "logs", true); logger_t* logger = open_log_file(path); free(path); if (logger == NULL) duk_error_ni(ctx, -1, DUK_ERR_ERROR, "OpenLog(): Failed to open file for logging '%s'", filename); duk_push_sphere_obj(ctx, "Logger", logger); return 1; }
void inline log_packet_hook(struct sockaddr_in *sender, char *line) { static time_t current_timestamp = 0; static struct tm current_time; static char current_time_str[TIME_STRING_BUFFER_SIZE]; int i; static char new_log_destination_path[TIME_STRING_BUFFER_SIZE]; /* Update our timestamp string (if necessary). */ if ((! current_timestamp) || (current_timestamp != time(NULL))) { current_timestamp = time(NULL); if (current_timestamp == (time_t)-1) { perror("udploggerc.c time()"); return; } if (localtime_r(¤t_timestamp, ¤t_time) == NULL) { perror("udploggerc.c localtime_r()"); return; } strftime(current_time_str, TIME_STRING_BUFFER_SIZE, "[%Y-%m-%d %H:%M:%S]", ¤t_time); current_time_str[TIME_STRING_BUFFER_SIZE - 1] = '\0'; /* Update our log file destination path (if necessary). */ if (udploggerc_conf.log_destination_format != NULL) { strftime(new_log_destination_path, TIME_STRING_BUFFER_SIZE, udploggerc_conf.log_destination_format, ¤t_time); new_log_destination_path[TIME_STRING_BUFFER_SIZE - 1] = '\0'; if (strncmp(new_log_destination_path, udploggerc_conf.log_destination_path, TIME_STRING_BUFFER_SIZE)) { open_log_file(new_log_destination_path); } } } /* Format the log line for output. */ if (udploggerc_conf.delimiter_character != DELIMITER_CHARACTER) { for (i = 0; i < strnlen(line, PACKET_MAXIMUM_SIZE); i++) { if (line[i] == DELIMITER_CHARACTER) { line[i] = udploggerc_conf.delimiter_character; } } } fprintf(udploggerc_conf.log_destination, "%s%c[%s:%hu]%c%s\n", current_time_str, udploggerc_conf.delimiter_character, inet_ntoa(sender->sin_addr), ntohs(sender->sin_port), udploggerc_conf.delimiter_character, line); }
static void oi( char * psin ) { int len, w; char * ps = psin; if (!ps) return; len = (int)strlen(ps); if (len) { if( outfile == 0 ) { open_log_file(); } if( VFP(outfile) ) { char *tb; if (addsysdate) { tb = GetNxtBuf(); len = sprintf( tb, "%s - %s", get_date_time_stg(), ps ); ps = tb; } else if( addsystime ) { tb = GetNxtBuf(); len = sprintf( tb, "%s - %s", get_time_stg(), ps ); ps = tb; } w = (int)fwrite( ps, 1, len, outfile ); if( w != len ) { fclose(outfile); outfile = (FILE *)-1; sprtf("WARNING: Failed write to log file [%s] ...\n", logfile); exit(1); } else if (addflush) { fflush( outfile ); } } if( addstdout ) { fwrite( ps, 1, len, stderr ); /* 20170917 - Switch to using 'stderr' in place of 'stdout' */ } #ifdef ADD_LISTVIEW if (add2listview) { LVInsertItem(ps); } #endif /* ADD_LISTVIEW */ #ifdef ADD_SCREENOUT if (add2screen) { Add_String(ps); /* add string to screen list */ } #endif /* #ifdef ADD_SCREENOUT */ } }
void log_event(const char *log_name, time_t time, const char *event) { ensure_log_file_exists(log_name); FILE *log = open_log_file(log_name, "a"); char *time_str = to_utc_str(time); if (fprintf(log, "%s %s\n", time_str, event) < 0) { fatal("could not write to log file: %s", strerror(errno)); } fclose(log); free(time_str); }
static bool log_init_file(const char *path, unsigned line, GError **error_r) { out_filename = path; out_fd = open_log_file(); if (out_fd < 0) { g_set_error(error_r, log_quark(), errno, "failed to open log file \"%s\" (config line %u): %s", path, line, g_strerror(errno)); return false; } g_log_set_default_handler(file_log_func, NULL); return true; }
void ensure_pdf_open(void) { if (output_file_name == 0) { if (job_name == 0) open_log_file(); pack_job_name(".pdf"); while (!b_open_out(pdf_file)) prompt_file_name("file name for output", ".pdf"); output_file_name = b_make_name_string(pdf_file); } }
void set_log_file( char * nf, int open ) { if (logfile[0] == 0) strcpy(logfile,def_log); if ( nf && *nf && strcmpi(nf,logfile) ) { close_log_file(); /* remove any previous */ strcpy(logfile,nf); /* set new name */ if (strcmp(logfile,"none") == 0) { /* if equal 'none' */ outfile = (FILE *)-1; /* disable the log file */ } else if (open) { open_log_file(); /* and open it ... anything previous written is 'lost' */ } else outfile = 0; /* else set 0 to open on first write */ } }