CThreadPool::CThreadPool(int nServiceType)
{
m_nThreadSum = 250;
m_nThreadRunCount = 0;
m_ServiceType = DogService4;
m_bInit = FALSE;
m_bDebug = FALSE;
m_bLogger = FALSE;
m_bThreadPoolRun = FALSE;
m_bAddTaskRun = FALSE;
m_bEndPrint = FALSE;
m_bReadCfg = FALSE;
m_ServiceType = nServiceType;
m_strIniPath = L"";
m_strLogPath = L"";
get_cfg_path();
read_cfg();
get_log_path();
m_hWaitingWork = CreateEvent(NULL, false, false, NULL);
m_hGotgWork = CreateEvent(NULL, false, false, NULL);
m_hAddTask = CreateEvent(NULL, false, false, NULL);
HANDLE hAddTask = (HANDLE)_beginthreadex(NULL, 0, _thr_add_task, this, 0, NULL);
CloseHandle(hAddTask);
HANDLE hReadCfg = (HANDLE)_beginthreadex(NULL, 0, _thr_read_config, this, 0, NULL);
CloseHandle(hReadCfg);
HANDLE hPrintState = (HANDLE)_beginthreadex(NULL, 0, _thr_print_state, this, 0, NULL);
CloseHandle(hPrintState);
init_thread_pool(m_nThreadSum);
}
/* Dumps crawler nodes list to log file. */
static int crawler_dump_log(Crawler *cwl)
{
char log_path[PATH_MAX];
if (get_log_path(log_path, sizeof(log_path)) == -1) {
return -1;
}
char log_path_temp[strlen(log_path) + strlen(TEMP_FILE_EXT) + 1];
snprintf(log_path_temp, sizeof(log_path_temp), "%s%s", log_path, TEMP_FILE_EXT);
FILE *fp = fopen(log_path_temp, "w");
if (fp == NULL) {
return -2;
}
LOCK; // ip_ntoa() isn't thread safe
for (uint32_t i = 0; i < cwl->num_nodes; ++i) {
fprintf(fp, "%s ", ip_ntoa(&cwl->nodes_list[i].ip_port.ip));
}
UNLOCK;
fclose(fp);
if (rename(log_path_temp, log_path) != 0) {
return -3;
}
return 0;
}
void logn(char *filename, char *str)
{
char buffer[4196];
char path[256];
int fd;
ASSERTLOG( filename );
ASSERTLOG( str );
sprintf(path, "%s/%s", get_log_path(), filename);
fd = open(path, O_RDWR | O_APPEND | O_BINARY );
if(fd < 0)
{
fd = open(path, O_RDWR | O_CREAT | O_BINARY, ACC);
if(fd < 0)
return;
}
lseek(fd, 0L, 2);
/* put a time stamp on everything */
sprintf(buffer, "%s: %s\n", get_time_str(), str );
write(fd, buffer, strlen(buffer));
close(fd);
return;
}
/* renames chatlog file replacing src with dest.
Returns 0 on success or if no log exists, -1 on failure. */
int rename_logfile(char *src, char *dest, const char *selfkey, const char *otherkey, int winnum)
{
ToxWindow *toxwin = get_window_ptr(winnum);
struct chatlog *log = NULL;
bool log_on = false;
/* disable log if necessary and save its state */
if (toxwin != NULL) {
log = toxwin->chatwin->log;
log_on = log->log_on;
}
if (log_on)
log_disable(log);
char newpath[MAX_STR_SIZE];
char oldpath[MAX_STR_SIZE];
if (get_log_path(oldpath, sizeof(oldpath), src, selfkey, otherkey, LOG_CHAT) == -1)
goto on_error;
if (!file_exists(oldpath))
return 0;
if (get_log_path(newpath, sizeof(newpath), dest, selfkey, otherkey, LOG_CHAT) == -1)
goto on_error;
if (rename(oldpath, newpath) != 0)
goto on_error;
if (log_on)
log_enable(dest, selfkey, otherkey, log, LOG_CHAT);
return 0;
on_error:
if (log_on)
log_enable(src, selfkey, otherkey, log, LOG_CHAT);
return -1;
}
/*================================================================*/
void mvc_log(){
/* This function renames the list of all command file to include *
* the date. This is done to preserve the list commands that *
* occured before a crash. */
char *date, mfile[128], rfile[128];
time_t i,t;
t = time(0);
date = ctime(&t);
for(i=0;i<24;i++)
if(date[i] == ' ')
date[i] = '_';
date[24] = 0;
sprintf(rfile,"%s/%s", get_log_path(), "all_cmd");
sprintf(mfile,"%s/%s_%s", get_log_path(), "all_cmd",date);
rename( rfile, mfile);
return;
}
void LogParser::get_lines(int nl, stack<string>* sl) {
ifstream fi;
fi.open(get_log_path().c_str(), ios::ate);
int end_log=fi.tellg();
while(nl>0) {
int pos=find_back(&fi, end_log, 0, '\n');
string line=get_single_line(&fi, pos, end_log);
sl->push(line);
end_log=pos;
--nl;
}
fi.close();
}
/* Opens log file or creates a new one */
static int init_logging_session(char *name, const char *selfkey, const char *otherkey, struct chatlog *log, int logtype)
{
if (selfkey == NULL || (logtype == LOG_CHAT && otherkey == NULL))
return -1;
char log_path[MAX_STR_SIZE];
if (get_log_path(log_path, sizeof(log_path), name, selfkey, otherkey, logtype) == -1)
return -1;
log->file = fopen(log_path, "a+");
snprintf(log->path, sizeof(log->path), "%s", log_path);
if (log->file == NULL)
return -1;
return 0;
}
int main(int argc, char *argv[]) {
int retval;
R_RSA_PUBLIC_KEY key;
char log_path[MAXPATHLEN];
#ifdef _USING_FCGI_
unsigned int counter=0;
#endif
for(int c = 1; c < argc; c++) {
std::string option(argv[c]);
if(option == "-v" || option == "--version") {
printf("%s\n", SVN_VERSION);
exit(0);
} else if(option == "-h" || option == "--help") {
usage(argv[0]);
exit(0);
} else if (option.length()){
fprintf(stderr, "unknown command line argument: %s\n\n", argv[c]);
usage(argv[0]);
exit(1);
}
}
installer();
get_log_path(log_path, "file_upload_handler.log");
#ifndef _USING_FCGI_
if (!freopen(log_path, "a", stderr)) {
fprintf(stderr, "Can't open log file '%s' (errno: %d)\n",
log_path, errno
);
return_error(ERR_TRANSIENT, "can't open log file '%s' (errno: %d)",
log_path, errno
);
exit(1);
}
#else
FCGI_FILE *f = FCGI::fopen(log_path, "a");
if (f) {
log_messages.redirect(f);
} else {
fprintf(stderr, "Can't redirect FCGI log messages\n");
return_error(ERR_TRANSIENT, "can't open log file (FCGI)");
exit(1);
}
#endif
retval = config.parse_file();
if (retval) {
fprintf(stderr, "Can't parse config.xml: %s\n", boincerror(retval));
return_error(ERR_TRANSIENT,
"can't parse config file", log_path, errno
);
exit(1);
}
log_messages.pid = getpid();
log_messages.set_debug_level(config.fuh_debug_level);
if (boinc_file_exists(config.project_path("stop_upload"))) {
return_error(ERR_TRANSIENT, "Maintenance underway: file uploads are temporarily disabled.");
exit(1);
}
if (!config.ignore_upload_certificates) {
retval = get_key(key);
if (retval) {
return_error(ERR_TRANSIENT, "can't read key file");
exit(1);
}
}
#ifdef _USING_FCGI_
while(FCGI_Accept() >= 0) {
counter++;
//fprintf(stderr, "file_upload_handler (FCGI): counter: %d\n", counter);
log_messages.set_indent_level(0);
#endif
handle_request(stdin, key);
#ifdef _USING_FCGI_
// flush log for FCGI, otherwise it just buffers a lot
log_messages.flush();
}
// when exiting, write headers back to apache so it won't complain
// about "incomplete headers"
fprintf(stdout,"Content-type: text/plain\n\n");
#endif
return 0;
}
void LogParser::set_num_lines() {
ifstream fi;
fi.open(get_log_path().c_str());
log_lines = (int) count(istreambuf_iterator<char>(fi), istreambuf_iterator<char>(), '\n');
fi.close();
}
int main(int argc, char** argv) {
#ifndef _USING_FCGI_
FILE* fin, *fout;
#else
FCGI_FILE *fin, *fout;
#endif
int i, retval;
char req_path[MAXPATHLEN], reply_path[MAXPATHLEN];
char log_path[MAXPATHLEN], path[MAXPATHLEN];
unsigned int counter=0;
char* code_sign_key;
int length = -1;
log_messages.pid = getpid();
bool debug_log = false;
for (i=1; i<argc; i++) {
if (!strcmp(argv[i], "--batch")) {
batch = true;
continue;
} else if (!strcmp(argv[i], "--mark_jobs_done")) {
mark_jobs_done = true;
} else if (!strcmp(argv[i], "--debug_log")) {
debug_log = true;
#ifdef GCL_SIMULATOR
} else if (!strcmp(argv[i], "--simulator")) {
if(!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
simtime = atof(argv[i]);
#endif
} else if(!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
usage(argv[0]);
exit(0);
} else if(!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else if (strlen(argv[i])){
log_messages.printf(MSG_CRITICAL, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
// install a signal handler that catches SIGTERMS sent by Apache if the CGI
// times out.
//
signal(SIGTERM, sigterm_handler);
if (debug_log) {
if (!freopen("debug_log", "w", stderr)) {
fprintf(stderr, "Can't redirect stderr\n");
exit(1);
}
} else {
char *stderr_buffer;
get_log_path(path, "scheduler.log");
#ifndef _USING_FCGI_
char buf[256];
if (!freopen(path, "a", stderr)) {
fprintf(stderr, "Can't redirect stderr\n");
sprintf(buf, "Server can't open log file (%s)", path);
send_message(buf, 3600);
exit(1);
}
#else
FCGI_FILE* f = FCGI::fopen(path, "a");
if (f) {
log_messages.redirect(f);
} else {
char buf[256];
fprintf(stderr, "Can't redirect FCGI log messages\n");
sprintf(buf, "Server can't open log file for FCGI (%s)", path);
send_message(buf, 3600);
exit(1);
}
#endif
// install a larger buffer for stderr. This ensures that
// log information from different scheduler requests running
// in parallel aren't intermingled in the log file.
//
if (config.scheduler_log_buffer) {
stderr_buffer = (char*)malloc(config.scheduler_log_buffer);
if (!stderr_buffer) {
log_messages.printf(MSG_CRITICAL,
"Unable to allocate stderr buffer\n"
);
} else {
#ifdef _USING_FCGI_
retval = setvbuf(
f->stdio_stream, stderr_buffer, _IOFBF,
config.scheduler_log_buffer
);
#else
retval = setvbuf(
stderr, stderr_buffer, _IOFBF, config.scheduler_log_buffer
);
#endif
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Unable to change stderr buffering\n"
);
}
}
}
}
srand(time(0)+getpid());
log_messages.set_debug_level(DEBUG_LEVEL);
#if DUMP_CORE_ON_SEGV
set_core_dump_size_limit();
#endif
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
send_message("Server can't parse configuration file", 3600);
exit(0);
}
log_messages.set_debug_level(config.sched_debug_level);
if (config.sched_debug_level == 4) g_print_queries = true;
gui_urls.init();
project_files.init();
init_file_delete_regex();
sprintf(path, "%s/code_sign_public", config.key_dir);
retval = read_file_malloc(path, code_sign_key);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't read code sign key file (%s)\n", path
);
send_message("Server can't find key file", 3600);
exit(0);
}
strip_whitespace(code_sign_key);
g_pid = getpid();
#ifdef _USING_FCGI_
//while(FCGI_Accept() >= 0 && counter < MAX_FCGI_COUNT) {
while(FCGI_Accept() >= 0) {
counter++;
log_messages.set_indent_level(0);
#endif
if (config.debug_request_headers) {
log_request_headers(length);
}
if (!debug_log && check_stop_sched()) {
send_message("Project is temporarily shut down for maintenance", 3600);
goto done;
}
if (!ssp) {
attach_to_feeder_shmem();
}
if (!ssp) {
send_message("Server error: can't attach shared memory", 3600);
goto done;
}
if (strlen(config.debug_req_reply_dir)) {
struct stat statbuf;
// the code below is convoluted because,
// instead of going from stdin to stdout directly,
// we go via a pair of disk files
// (this makes it easy to save the input,
// and to know the length of the output).
// NOTE: to use this, you must create group-writeable dirs
// boinc_req and boinc_reply in the project dir
//
sprintf(req_path, "%s/%d_%u_sched_request.xml", config.debug_req_reply_dir, g_pid, counter);
sprintf(reply_path, "%s/%d_%u_sched_reply.xml", config.debug_req_reply_dir, g_pid, counter);
// keep an own 'log' per PID in case general logging fails
// this allows to associate at leas the scheduler request with the client
// IP address (as shown in httpd error log) in case of a crash
sprintf(log_path, "%s/%d_%u_sched.log", config.debug_req_reply_dir, g_pid, counter);
#ifndef _USING_FCGI_
fout = fopen(log_path, "a");
#else
fout = FCGI::fopen(log_path,"a");
#endif
fprintf(fout, "PID: %d Client IP: %s\n", g_pid, get_remote_addr());
fclose(fout);
log_messages.printf(MSG_DEBUG,
"keeping sched_request in %s, sched_reply in %s, custom log in %s\n",
req_path, reply_path, log_path
);
#ifndef _USING_FCGI_
fout = fopen(req_path, "w");
#else
fout = FCGI::fopen(req_path,"w");
#endif
if (!fout) {
log_messages.printf(MSG_CRITICAL,
"can't write request file\n"
);
exit(1);
}
copy_stream(stdin, fout);
fclose(fout);
stat(req_path, &statbuf);
if (length>=0 && (statbuf.st_size != length)) {
log_messages.printf(MSG_CRITICAL,
"Request length %d != CONTENT_LENGTH %d\n",
(int)statbuf.st_size, length
);
}
#ifndef _USING_FCGI_
fin = fopen(req_path, "r");
#else
fin = FCGI::fopen(req_path,"r");
#endif
if (!fin) {
log_messages.printf(MSG_CRITICAL,
"can't read request file\n"
);
exit(1);
}
#ifndef _USING_FCGI_
fout = fopen(reply_path, "w");
#else
fout = FCGI::fopen(reply_path, "w");
#endif
if (!fout) {
log_messages.printf(MSG_CRITICAL,
"can't write reply file\n"
);
exit(1);
}
handle_request(fin, fout, code_sign_key);
fclose(fin);
fclose(fout);
#ifndef _USING_FCGI_
fin = fopen(reply_path, "r");
#else
fin = FCGI::fopen(reply_path, "r");
#endif
if (!fin) {
log_messages.printf(MSG_CRITICAL,
"can't read reply file\n"
);
exit(1);
}
copy_stream(fin, stdout);
fclose(fin);
// if not contacted from a client, don't keep the log files
/* not sure what lead to the assumption of a client setting
CONTENT_LENGTH, but it's wrong at least on our current
project / Apache / Client configuration. Commented out.
if (getenv("CONTENT_LENGTH")) {
unlink(req_path);
unlink(reply_path);
}
*/
#ifndef _USING_FCGI_
} else if (batch) {
while (!feof(stdin)) {
handle_request(stdin, stdout, code_sign_key);
fflush(stdout);
}
#endif
} else {
handle_request(stdin, stdout, code_sign_key);
fflush(stderr);
}
done:
#ifdef _USING_FCGI_
if (config.debug_fcgi) {
log_messages.printf(MSG_NORMAL,
"FCGI: counter: %d\n", counter
);
log_messages.flush();
}
} // do()
if (counter == MAX_FCGI_COUNT) {
fprintf(stderr, "FCGI: counter passed MAX_FCGI_COUNT - exiting..\n");
} else {
fprintf(stderr, "FCGI: FCGI_Accept failed - exiting..\n");
}
// when exiting, write headers back to apache so it won't complain
// about "incomplete headers"
fprintf(stdout,"Content-type: text/plain\n\n");
#endif
if (db_opened) {
boinc_db.close();
}
}
main(int argc, char *argv[])
{
char ipaddr[80], filename[127];
int oport, iport;
int return_code = 0;
char buf[80];
struct hostent *h;
struct in_addr in;
/* initialize these now in case the 20 second timer runs out */
strcpy(Output[0], "no_port");
strcpy(Output[1], "UNKNOWN");
if(argc != 4) {
fprintf(stderr, "auth v6.2\n");
fprintf(stderr, "Syntax: %s ip_address oport iport\n", argv[0]);
exit(0);
}
init_sockets();
set_abort_timer(20);
sprintf(filename, "%s/auth/lookup.%d", get_log_path(), getpid());
fp = fopen(filename, "w");
strcpy(ipaddr, argv[1]);
oport = atoi(argv[2]);
iport = atoi(argv[3]);
in.s_addr = inet_addr(ipaddr);
/* Perform the host name lookup on the IP address*/
h = gethostbyaddr((char *)&in, sizeof(in), AF_INET);
if(!h)
strcpy(Output[1], "UNKNOWN");
else
strcpy(Output[1], h->h_name);
if( strncmp(ipaddr, "127.0", 5)) {
if(check_proxies(ipaddr, 1080)) {
proxies = 1;
}
else if(check_proxies(ipaddr, 8088)) {
proxies = 1;
}
else if(check_proxies(ipaddr, 23)) {
proxies = 1;
}
}
/* Begin the user id lookup */
if(proxies != 1) {
if(start_auth(&in, oport, iport, buf))
strcpy(Output[0], buf);
else
strcpy(Output[0], "no_port");
}
/* Save the results to a file so frp can look them up */
if(fp)
{
fprintf(fp, "%s\n%s\n%d\n", Output[0], Output[1], proxies);
fclose(fp);
}
else
{
return_code = -1;
}
#ifdef WIN32
timeKillEvent(mmID);
#endif
cleanup_sockets();
return(return_code);
}
//------------------------------------------------------------
int log_cuda_result(RESULT& result, double& granted_credit) {
//------------------------------------------------------------
const char * cuda_str = "SETI@home using CUDA accelerated device ";
time_t log_time;
int i, retval;
char stderr_txt[1024];
char log_path[256];
char device_str[256];
char * p;
static FILE * log_fp=NULL;
device_str[0] = '\0';
get_log_path(log_path, "cuda_result_log");
if (!log_fp) {
log_fp = fopen(log_path, "a");
if (!log_fp) {
log_messages.printf(
SCHED_MSG_LOG::MSG_CRITICAL,
"[RESULT#%d] cannot open cuda_result_log\n",
result.id
);
exit(1);
} else {
setbuf(log_fp, NULL);
}
}
//get stderr_txt and determine cuda status
p = strstr(result.stderr_out, cuda_str);
if (p == NULL) {
log_messages.printf(
SCHED_MSG_LOG::MSG_DEBUG,
"[RESULT#%d] is not a cuda result\n",
result.id
);
return(0); // not a cuda result - nothing more to do
} else {
log_messages.printf(
SCHED_MSG_LOG::MSG_DEBUG,
"[RESULT#%d] is a cuda result\n",
result.id
);
return(1); // is a cuda result - hack - we will remove this entire routine later
}
// pull out device string and replace spaces with underscores
p += strlen(cuda_str);
for (i=0; p[i] != '\n' && p[i] != '\0'; i++) {
device_str[i] = p[i];
}
device_str[i] = '\0';
for (i=0; device_str[i] != '\0'; i++) {
if (device_str[i] == ' ') {
device_str[i] = '_';
}
}
log_time = time(NULL);
retval = fprintf(log_fp, "%d %d %d %d %d %d %lf %lf %s\n",
log_time, result.received_time, result.id,
result.hostid, result.userid,
result.teamid, result.claimed_credit,
granted_credit, device_str);
if (retval < 0) {
log_messages.printf(
SCHED_MSG_LOG::MSG_CRITICAL,
"[RESULT#%d] cannot write to cuda_result_log : %s\n",
strerror(errno)
);
}
return(1); // this was a cuda result
}
/* Initialization routine
Resume all the saved settings (if configured to do so), and setup the
timer so we know how often to save state. */
int init()
{
int loc_in_playlist = 0;
int loc_in_song = 0;
int ii = 0;
int result = 0;
char eq_string[EQSIZE];
int ini_song_name_length = 0;
char *song_filename = NULL;
char *song_title = NULL;
int song_name_len = 0;
char *str_to_check = NULL;
char song_name[SONG_NAME_BUF];
/* Initialize our global ini_path and log_path*/
get_winamp_ini_path(ini_path, INI_BUFSIZE);
get_log_path(log_path, LOG_BUFSIZE );
/* If we're supposed to, resume playing with saved settings. */
if (GetPrivateProfileInt(INI_SECTNAME, KEY_RESUME, 0, ini_path)) {
/* Resume requested */
/* Get the following information from the last saved state:
location in playlist, time in song, EQ settings */
/* Get location in playlist */
loc_in_playlist = GetPrivateProfileInt(INI_SECTNAME, KEY_PLAYLISTLOC, 0, ini_path);
/* Get location in song */
loc_in_song = GetPrivateProfileInt(INI_SECTNAME, KEY_SONGLOC, 0, ini_path);
/* Get EQ settings from INI and set them up in WinAmp */
GetPrivateProfileString(INI_SECTNAME, KEY_EQ, "0,0,0,0,0,0,0,0,0,0", eq_string, EQSIZE, ini_path);
for ( ii = 0 ; ii < NUM_EQS ; ii++ ) {
/* First request info so WinAmp knows what to modify */
SendMessage(module.hwndParent, WM_WA_IPC, ii, IPC_GETEQDATA);
/* Now assign the new data */
SendMessage(module.hwndParent, WM_WA_IPC, get_num(eq_string, ii+1, ','), IPC_SETEQDATA);
}
/* Set the Preamp */
SendMessage(module.hwndParent, WM_WA_IPC, PREAMP, IPC_GETEQDATA);
SendMessage(module.hwndParent, WM_WA_IPC, GetPrivateProfileInt(INI_SECTNAME, KEY_EQPREAMP, 0, ini_path), IPC_SETEQDATA);
/* Set the enabled status of the EQ */
SendMessage(module.hwndParent, WM_WA_IPC, EQENABLED, IPC_GETEQDATA);
SendMessage(module.hwndParent, WM_WA_IPC, GetPrivateProfileInt(INI_SECTNAME, KEY_EQENABLED, 0, ini_path), IPC_SETEQDATA);
/* Attempt to determine if we're playing the same song as we were when we exited */
/* i.e., the user didn't exit WinAmp in the middle of a song, and then load a new song by double-clicking it or */
/* something. That would cause the plug-in to resume that song in the same position as the first one left */
/* off. */
/* This addition recommended by a few of my friends, and Dave Glaeser. */
ini_song_name_length = GetPrivateProfileString(INI_SECTNAME, KEY_SONG_NAME, "", song_name, SONG_NAME_BUF, ini_path);
song_filename = strdup((char*)SendMessage(module.hwndParent, WM_WA_IPC, loc_in_playlist, IPC_GETPLAYLISTFILE));
song_title = strdup((char*)SendMessage(module.hwndParent, WM_WA_IPC, loc_in_playlist, IPC_GETPLAYLISTTITLE));
if ( (song_filename != NULL) && (song_title != NULL) ) {
song_name_len = strlen(song_title) + strlen(song_filename) + 1;
str_to_check = (char*)malloc(sizeof(char)*(song_name_len+1));
_snprintf(str_to_check, SONG_NAME_BUF, "%s-%s", song_filename, song_title);
}
else
str_to_check = NULL;
if ( (ini_song_name_length == 0) || /* Nothing returned, the user didn't have this feature before. */
((str_to_check != NULL) &&
(strcmp(str_to_check, song_name) == 0)) ) /* They match */
{
/* Jump to loc_in_playlist */
result = SendMessage(module.hwndParent, WM_WA_IPC, loc_in_playlist, IPC_SETPLAYLISTPOS);
mylog( "SetPLaylistPos=%d, res=%d", loc_in_playlist, result );
/* Start playing selected track */
//result = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY);
result = SendMessage(module.hwndParent,WM_COMMAND,MAKEWPARAM(WM_BUTTON_PLAY,0),0);
mylog( "StartPlay, res=%u ", result);
/* Jump to saved location within track */
result = SendMessage(module.hwndParent, WM_WA_IPC, loc_in_song, IPC_JUMPTOTIME);
mylog( "JumpToTime=%dms, res=%u ", loc_in_song, result);
}
if (song_filename != NULL)
free(song_filename);
if (song_title != NULL)
free(song_title);
if (str_to_check != NULL)
free(str_to_check);
}
/* Fire off an alarm clock to let us know when we need to write out the state of WinAmp */
/* Setup the timer */
do_timer();
return 0;
}
int DEFAULT_CC
main(int argc, char **argv)
{
tbus waiters[4];
int pid = 0;
char text[256];
char* log_path;
char *display_text;
char log_file[256];
enum logReturns error;
struct log_config logconfig;
unsigned int log_level;
g_init("xrdp-chansrv"); /* os_calls */
log_path = get_log_path();
if (log_path == 0)
{
g_writeln("error reading CHANSRV_LOG_PATH and HOME environment variable");
g_deinit();
return 1;
}
read_ini();
pid = g_getpid();
log_level = get_log_level(g_getenv("CHANSRV_LOG_LEVEL"), LOG_LEVEL_ERROR);
/* starting logging subsystem */
g_memset(&logconfig, 0, sizeof(struct log_config));
logconfig.program_name = "XRDP-Chansrv";
g_snprintf(log_file, 255, "%s/xrdp-chansrv.log", log_path);
g_writeln("chansrv::main: using log file [%s]", log_file);
if (g_file_exist(log_file))
{
g_file_delete(log_file);
}
logconfig.log_file = log_file;
logconfig.fd = -1;
logconfig.log_level = log_level;
logconfig.enable_syslog = 0;
logconfig.syslog_level = 0;
error = log_start_from_param(&logconfig);
if (error != LOG_STARTUP_OK)
{
switch (error)
{
case LOG_ERROR_MALLOC:
g_writeln("error on malloc. cannot start logging. quitting.");
break;
case LOG_ERROR_FILE_OPEN:
g_writeln("error opening log file [%s]. quitting.",
getLogFile(text, 255));
break;
default:
g_writeln("log_start error");
break;
}
g_deinit();
return 1;
}
LOGM((LOG_LEVEL_ALWAYS, "main: app started pid %d(0x%8.8x)", pid, pid));
/* set up signal handler */
g_signal_kill(term_signal_handler); /* SIGKILL */
g_signal_terminate(term_signal_handler); /* SIGTERM */
g_signal_user_interrupt(term_signal_handler); /* SIGINT */
g_signal_pipe(nil_signal_handler); /* SIGPIPE */
g_signal_child_stop(child_signal_handler); /* SIGCHLD */
g_signal_segfault(segfault_signal_handler);
display_text = g_getenv("DISPLAY");
LOGM((LOG_LEVEL_INFO, "main: DISPLAY env var set to %s", display_text));
get_display_num_from_display(display_text);
if (g_display_num == 0)
{
LOGM((LOG_LEVEL_ERROR, "main: error, display is zero"));
g_deinit();
return 1;
}
LOGM((LOG_LEVEL_INFO, "main: using DISPLAY %d", g_display_num));
g_snprintf(text, 255, "xrdp_chansrv_%8.8x_main_term", pid);
g_term_event = g_create_wait_obj(text);
g_snprintf(text, 255, "xrdp_chansrv_%8.8x_thread_done", pid);
g_thread_done_event = g_create_wait_obj(text);
g_snprintf(text, 255, "xrdp_chansrv_%8.8x_exec", pid);
g_exec_event = g_create_wait_obj(text);
g_exec_mutex = tc_mutex_create();
g_exec_sem = tc_sem_create(0);
tc_thread_create(channel_thread_loop, 0);
while (g_term_event > 0 && !g_is_wait_obj_set(g_term_event))
{
waiters[0] = g_term_event;
waiters[1] = g_exec_event;
if (g_obj_wait(waiters, 2, 0, 0, 0) != 0)
{
LOGM((LOG_LEVEL_ERROR, "main: error, g_obj_wait failed"));
break;
}
if (g_is_wait_obj_set(g_term_event))
{
break;
}
if (g_is_wait_obj_set(g_exec_event))
{
g_reset_wait_obj(g_exec_event);
run_exec();
}
}
while (g_thread_done_event > 0 && !g_is_wait_obj_set(g_thread_done_event))
{
/* wait for thread to exit */
if (g_obj_wait(&g_thread_done_event, 1, 0, 0, 0) != 0)
{
LOGM((LOG_LEVEL_ERROR, "main: error, g_obj_wait failed"));
break;
}
}
/* cleanup */
main_cleanup();
LOGM((LOG_LEVEL_INFO, "main: app exiting pid %d(0x%8.8x)", pid, pid));
g_deinit();
return 0;
}
int main(int argc, char** argv) {
#ifndef _USING_FCGI_
FILE* fin, *fout;
#else
FCGI_FILE *fin, *fout;
#endif
int i, retval;
char req_path[256], reply_path[256], path[256];
unsigned int counter=0;
char* code_sign_key;
int length=-1;
log_messages.pid = getpid();
bool debug_log = false;
for (i=1; i<argc; i++) {
if (!strcmp(argv[i], "--batch")) {
batch = true;
continue;
} else if (!strcmp(argv[i], "--mark_jobs_done")) {
mark_jobs_done = true;
} else if (!strcmp(argv[i], "--debug_log")) {
debug_log = true;
#ifdef GCL_SIMULATOR
} else if (!strcmp(argv[i], "--simulator")) {
simtime = atof(argv[++i]);
#endif
} else {
usage(argv[0]);
}
}
// install a signal handler that catches SIGTERMS sent by Apache if the cgi
// times out.
//
signal(SIGTERM, sigterm_handler);
if (debug_log) {
freopen("debug_log", "w", stderr);
} else {
char *stderr_buffer, buf[256];
get_log_path(path, "scheduler.log");
#ifndef _USING_FCGI_
if (!freopen(path, "a", stderr)) {
fprintf(stderr, "Can't redirect stderr\n");
sprintf(buf, "Server can't open log file (%s)", path);
send_message(buf, 3600);
exit(1);
}
// install a larger buffer for stderr. This ensures that
// log information from different scheduler requests running
// in parallel don't collide in the log file and appear intermingled.
//
if (!(stderr_buffer=(char *)malloc(32768)) || setvbuf(stderr, stderr_buffer, _IOFBF, 32768)) {
log_messages.printf(MSG_CRITICAL,
"Unable to change stderr buffering preferences\n"
);
}
#else
FCGI_FILE* f = FCGI::fopen(path, "a");
if (f) {
log_messages.redirect(f);
} else {
char buf[256];
fprintf(stderr, "Can't redirect FCGI log messages\n");
sprintf(buf, "Server can't open log file for FCGI (%s)", path);
send_message(buf, 3600);
exit(1);
}
// set buffer as above, note that f is really a struct from fcgi_stdio.h
if (!(stderr_buffer=(char *)malloc(32768)) || setvbuf(f->stdio_stream, stderr_buffer, _IOFBF, 32768)) {
log_messages.printf(MSG_CRITICAL,
"Unable to change stderr FCGI buffering preferences\n"
);
}
#endif
}
srand(time(0)+getpid());
log_messages.set_debug_level(DEBUG_LEVEL);
#if DUMP_CORE_ON_SEGV
set_core_dump_size_limit();
#endif
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
send_message("Server can't parse configuration file", 3600);
exit(0);
}
log_messages.set_debug_level(config.sched_debug_level);
gui_urls.init();
project_files.init();
sprintf(path, "%s/code_sign_public", config.key_dir);
retval = read_file_malloc(path, code_sign_key);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't read code sign key file (%s)\n", path
);
send_message("Server can't find key file", 3600);
exit(0);
}
g_pid = getpid();
#ifdef _USING_FCGI_
//while(FCGI_Accept() >= 0 && counter < MAX_FCGI_COUNT) {
while(FCGI_Accept() >= 0) {
counter++;
log_messages.set_indent_level(0);
#endif
if (config.debug_request_headers) {
log_request_headers(length);
}
if (check_stop_sched()) {
send_message("Project is temporarily shut down for maintenance", 3600);
goto done;
}
if (!ssp) {
attach_to_feeder_shmem();
}
if (!ssp) {
send_message("Server error: can't attach shared memory", 3600);
goto done;
}
if (use_files) {
struct stat statbuf;
// the code below is convoluted because,
// instead of going from stdin to stdout directly,
// we go via a pair of disk files
// (this makes it easy to save the input,
// and to know the length of the output).
// NOTE: to use this, you must create group-writeable dirs
// boinc_req and boinc_reply in the project dir
//
sprintf(req_path, "%s%d_%u", config.project_path(REQ_FILE_PREFIX), g_pid, counter);
sprintf(reply_path, "%s%d_%u", config.project_path(REPLY_FILE_PREFIX), g_pid, counter);
#ifndef _USING_FCGI_
fout = fopen(req_path, "w");
#else
fout = FCGI::fopen(req_path,"w");
#endif
if (!fout) {
log_messages.printf(MSG_CRITICAL,
"can't write request file\n"
);
exit(1);
}
copy_stream(stdin, fout);
fclose(fout);
stat(req_path, &statbuf);
if (length>=0 && (statbuf.st_size != length)) {
log_messages.printf(MSG_CRITICAL,
"Request length %d != CONTENT_LENGTH %d\n",
(int)statbuf.st_size, length
);
}
#ifndef _USING_FCGI_
fin = fopen(req_path, "r");
#else
fin = FCGI::fopen(req_path,"r");
#endif
if (!fin) {
log_messages.printf(MSG_CRITICAL,
"can't read request file\n"
);
exit(1);
}
#ifndef _USING_FCGI_
fout = fopen(reply_path, "w");
#else
fout = FCGI::fopen(reply_path, "w");
#endif
if (!fout) {
log_messages.printf(MSG_CRITICAL,
"can't write reply file\n"
);
exit(1);
}
handle_request(fin, fout, code_sign_key);
fclose(fin);
fclose(fout);
#ifndef _USING_FCGI_
fin = fopen(reply_path, "r");
#else
fin = FCGI::fopen(reply_path, "r");
#endif
if (!fin) {
log_messages.printf(MSG_CRITICAL,
"can't read reply file\n"
);
exit(1);
}
copy_stream(fin, stdout);
fclose(fin);
#ifdef EINSTEIN_AT_HOME
if (getenv("CONTENT_LENGTH")) unlink(req_path);
if (getenv("CONTENT_LENGTH")) unlink(reply_path);
#else
// unlink(req_path);
// unlink(reply_path);
#endif
#ifndef _USING_FCGI_
} else if (batch) {
while (!feof(stdin)) {
handle_request(stdin, stdout, code_sign_key);
fflush(stdout);
}
#endif
} else {
handle_request(stdin, stdout, code_sign_key);
}
done:
#ifdef _USING_FCGI_
log_messages.printf(MSG_DEBUG,
"FCGI: counter: %d\n", counter
);
log_messages.flush();
} // do()
if (counter == MAX_FCGI_COUNT) {
fprintf(stderr, "FCGI: counter passed MAX_FCGI_COUNT - exiting..\n");
} else {
fprintf(stderr, "FCGI: FCGI_Accept failed - exiting..\n");
}
// when exiting, write headers back to apache so it won't complain
// about "incomplete headers"
fprintf(stdout,"Content-type: text/plain\n\n");
#endif
if (db_opened) {
boinc_db.close();
}
}