void PrintTime(){
time(&rawtime);
timeinfo = localtime(&rawtime);
strftime(time_buffer,64,"%x %H:%M:%S",timeinfo);//"%a %b %d %Y %X %z",timeinfo);
printf(time_buffer);
}
HeapString DateTime::ToString(const StringRef& formaterStr) const
{
char s[256];
strftime(s, sizeof(s), formaterStr.c_str(), &mDate);
return HeapString(s);
}
static BDMDExamineData* get_examine_data_from_table (GHashTable *table, gboolean free_table, GError **error) {
BDMDExamineData *data = g_new0 (BDMDExamineData, 1);
gchar *value = NULL;
gchar *first_space = NULL;
BSSize size = NULL;
BSError *bs_error = NULL;
struct tm tm;
char time_str[20];
gchar *name_str = NULL;
data->level = g_strdup ((gchar*) g_hash_table_lookup (table, "Raid Level"));
if (!(data->level))
/* BUG: mdadm outputs "RAID Level" for some metadata formats (rhbz#1380034) */
data->level = g_strdup ((gchar*) g_hash_table_lookup (table, "RAID Level"));
value = (gchar*) g_hash_table_lookup (table, "Raid Devices");
if (!value)
/* BUG: mdadm outputs "RAID Devices" for some metadata formats (rhbz#1380034) */
value = (gchar*) g_hash_table_lookup (table, "RAID Devices");
if (value)
data->num_devices = g_ascii_strtoull (value, NULL, 0);
else
data->num_devices = 0;
name_str = ((gchar*) g_hash_table_lookup (table, "Name"));
if (name_str) {
g_strstrip (name_str);
first_space = strchr (name_str, ' ');
if (first_space)
*first_space = '\0';
data->name = g_strdup (name_str);
}
value = (gchar*) g_hash_table_lookup (table, "Array Size");
if (value) {
first_space = strchr (value, ' ');
if (first_space)
*first_space = '\0';
if (value && first_space)
/* Array Size is in KiB */
data->size = g_ascii_strtoull (value, NULL, 0) * 1024;
} else
data->size = 0;
data->uuid = g_strdup ((gchar*) g_hash_table_lookup (table, "Array UUID"));
if (!data->uuid)
/* also try just "UUID" which may be reported e.g for IMSM FW RAID */
data->uuid = g_strdup ((gchar*) g_hash_table_lookup (table, "UUID"));
value = (gchar*) g_hash_table_lookup (table, "Update Time");
if (value) {
memset(&tm, 0, sizeof(struct tm));
strptime(value, "%a %b %e %H:%M:%S %Y", &tm);
strftime(time_str, sizeof(time_str), "%s" , &tm);
data->update_time = g_ascii_strtoull (time_str, NULL, 0);
} else
data->update_time = 0;
data->dev_uuid = g_strdup ((gchar*) g_hash_table_lookup (table, "Device UUID"));
value = (gchar*) g_hash_table_lookup (table, "Events");
if (value)
data->events = g_ascii_strtoull (value, NULL, 0);
else
data->events = 0;
value = (gchar*) g_hash_table_lookup (table, "Version");
if (value)
data->metadata = g_strdup (value);
else
data->metadata = NULL;
value = (gchar*) g_hash_table_lookup (table, "Chunk Size");
if (value) {
size = bs_size_new_from_str (value, &bs_error);
if (size) {
data->chunk_size = bs_size_get_bytes (size, NULL, &bs_error);
bs_size_free (size);
}
if (bs_error) {
g_set_error (error, BD_MD_ERROR, BD_MD_ERROR_PARSE,
"Failed to parse chunk size from mdexamine data: %s", bs_error->msg);
bs_clear_error (&bs_error);
}
} else
data->chunk_size = 0;
if (free_table)
g_hash_table_destroy (table);
return data;
}
/* Here is the deal, we read as much as we can into the empty buffer, then
* reset the buffer pointer to the end of the read material and append at
* next read
*/
void
read_request( struct cn_strct *cn )
{
char *next;
int num_recv;
time_t now = time(NULL);
struct tm *tm_struct;
/* FIXME: For now assume that RECV_BUFF_LENGTH is enough for one read */
num_recv = recv(
cn->net_socket,
cn->data_buf,
RECV_BUFF_LENGTH - cn->processed_bytes,
//MAX_READ_LENGTH,
0
);
// sanity check
if (num_recv <= 0) {
if (num_recv <= 0) /* really dead? */
remove_conn_from_list(cn);
return;
}
// set the read pointer to where we left off
next = cn->data_buf_head + cn->processed_bytes;
// adjust buffer
cn->processed_bytes += num_recv;
cn->data_buf = cn->data_buf_head + cn->processed_bytes;
/* null terminate the current buffer -> overwrite on next read */
cn->data_buf_head[cn->processed_bytes] = '\0';
/* a naive little line parser */
while ( (*next != '\0') ) {
if ( *(next)=='\r')
if (*(next+1)=='\n' &&
*(next+2)=='\r' && *(next+3)=='\n' ) {
/* proceed next stage
prepare the global date string */
if (now-_Last_loop>0) {
_Last_loop = now;
tm_struct = gmtime(&_Last_loop);
//Sun, 06 Nov 1994 08:49:37 GMT
strftime( _Master_date, 30, "%a, %d %b %Y %H:%M:%S %Z", tm_struct);
}
cn->req_state = REQSTATE_BUFF_HEAD;
/* enqueue this connection to the _App_queue */
pthread_mutex_lock( &pull_job_mutex );
if (NULL == _Queue_tail) {
_Queue_tail = _Queue_head = cn;
_Queue_count = 1;
}
else {
_Queue_tail->q_prev = cn;
_Queue_tail = cn;
_Queue_count++;
}
pthread_mutex_unlock( &pull_job_mutex );
/* wake a worker to start the application */
pthread_cond_signal (&wake_worker_cond);
}
next++;
}
}
/**
* @short Transforms a time_t to a RFC 822 date string
*
* This date format is the standard in HTTP protocol as RFC 2616, section 3.3.1
*
* The dest pointer must be at least 32 bytes long as thats the maximum size of the date.
*/
void onion_shortcut_date_string(time_t t, char *dest){
struct tm ts;
gmtime_r(&t, &ts);
strftime(dest, t, "%a, %d %b %Y %T %Z", &ts);
}
// Credit to NTAuthority
LONG WINAPI DumpHandler::CustomUnhandledExceptionFilter(LPEXCEPTION_POINTERS ExceptionInfo)
{
// Ignore breakpoints.
if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT) return EXCEPTION_CONTINUE_EXECUTION;
// Try skipping exceptions
/* Disable that, it seems unsafe
if ((ExceptionInfo->ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE) != EXCEPTION_NONCONTINUABLE)
{
OutputDebugStringA(hString::va("New exception at 0x%X, try ignoring it...", ExceptionInfo->ExceptionRecord->ExceptionAddress));
ExceptionInfo->ExceptionRecord->ExceptionFlags |= EXCEPTION_NONCONTINUABLE;
return EXCEPTION_CONTINUE_EXECUTION;
}
else
{
OutputDebugStringA("Ignoring failed. Handling it now...");
}
*/
// step 1: write minidump
char error[1024];
char filename[MAX_PATH];
__time64_t time;
tm* ltime;
_time64(&time);
ltime = _localtime64(&time);
strftime(filename, sizeof(filename) - 1, "Redacted - %H-%M-%S %d.%m.%Y.dmp", ltime);
_snprintf(error, sizeof(error) - 1, "A minidump has been written to %s.", filename);
HANDLE hFile = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
MINIDUMP_EXCEPTION_INFORMATION ex = { 0 };
ex.ThreadId = GetCurrentThreadId();
ex.ExceptionPointers = ExceptionInfo;
ex.ClientPointers = FALSE;
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal, &ex, NULL, NULL);
CloseHandle(hFile);
}
else
{
_snprintf(error, sizeof(error) - 1, "An error (0x%x) occurred during creating %s.", GetLastError(), filename);
}
// step 2: exit the application
// why was this removed?
if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)
{
MessageBox(0, "Termination because of a stack overflow.", "ERROR", MB_ICONERROR);
}
else
{
MessageBox(0, hString::va("Fatal error (0x%08x) at 0x%08x.\n%s", ExceptionInfo->ExceptionRecord->ExceptionCode, ExceptionInfo->ExceptionRecord->ExceptionAddress, error), "ERROR", MB_ICONERROR);
}
TerminateProcess(GetCurrentProcess(), ExceptionInfo->ExceptionRecord->ExceptionCode);
return 0;
}
/**
* @brief Start the storage server.
*
* This is the main entry point for the storage server. It reads the
* configuration file, starts listening on a port, and proccesses
* commands from clients.
*/
int main(int argc, char *argv[])
{
Table database[MAX_DATABASE_LEN];
//printf("Setting time\n");//remove
time ( &rawtime );
timeinfo2 = localtime ( &rawtime );
//printf("Finished rawtime stuff\n"); //remove
//printf("About to do strftime\n"); //remove
strftime (buffer2,40,"Server-%Y-%m-%d-%H-%M-%S.log",timeinfo2);
puts (buffer2);
//printf("Finished setting time\n");//remove
// Process command line arguments.
// This program expects exactly one argument: the config file name.
assert(argc > 0);
if (argc != 2) {
printf("Usage %s <config_file>\n", argv[0]);
exit(EXIT_FAILURE);
}
char *config_file = argv[1];
// Read the config file.
struct config_params params;
int status = read_config(config_file, ¶ms);
if (status != 0) {
printf("Error processing config file.\n");
exit(EXIT_FAILURE);
}
n = sprintf(message, "Server on %s:%d\n", params.server_host, params.server_port);
//printf("%i", n);
fp = fopen(buffer2, "a+");
logger(LOGGING, fp, message);
fclose(fp);
// Create a socket.
int listensock = socket(PF_INET, SOCK_STREAM, 0);
if (listensock < 0) {
printf("Error creating socket.\n");
exit(EXIT_FAILURE);
}
// Allow listening port to be reused if defunct.
int yes = 1;
status = setsockopt(listensock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
if (status != 0) {
printf("Error configuring socket.\n");
exit(EXIT_FAILURE);
}
// Bind it to the listening port.
struct sockaddr_in listenaddr;
memset(&listenaddr, 0, sizeof listenaddr);
listenaddr.sin_family = AF_INET;
listenaddr.sin_port = htons(params.server_port);
inet_pton(AF_INET, params.server_host, &(listenaddr.sin_addr)); // bind to local IP address
status = bind(listensock, (struct sockaddr*) &listenaddr, sizeof listenaddr);
if (status != 0) {
printf("Error binding socket.\n");
exit(EXIT_FAILURE);
}
// Listen for connections.
status = listen(listensock, MAX_LISTENQUEUELEN);
if (status != 0) {
printf("Error listening on socket.\n");
exit(EXIT_FAILURE);
}
// Listen loop.
int wait_for_connections = 1;
while (wait_for_connections) {
// Wait for a connection.
struct sockaddr_in clientaddr;
socklen_t clientaddrlen = sizeof clientaddr;
int clientsock = accept(listensock, (struct sockaddr*)&clientaddr, &clientaddrlen);
if (clientsock < 0) {
printf("Error accepting a connection.\n");
exit(EXIT_FAILURE);
}
n = sprintf(message, "Got a connection from %s:%d.\n", inet_ntoa(clientaddr.sin_addr), clientaddr.sin_port);
fp = fopen(buffer2, "a+");
logger(LOGGING, fp, message);
fclose(fp);
// Get commands from client.
int wait_for_commands = 1;
do {
// Read a line from the client.
char cmd[MAX_CMD_LEN];
int status = recvline(clientsock, cmd, MAX_CMD_LEN);
if (status != 0) {
// Either an error occurred or the client closed the connection.
wait_for_commands = 0;
} else {
// Handle the command from the client.
int status = handle_command(clientsock, cmd, database, params.username, params.password);
if (status != 0)
wait_for_commands = 0; // Oops. An error occured.
}
} while (wait_for_commands);
// Close the connection with the client.
close(clientsock);
n = sprintf(message, "Closed connection from %s:%d.\n", inet_ntoa(clientaddr.sin_addr), clientaddr.sin_port);
fp = fopen(buffer2, "a+");
logger(LOGGING, fp, message);
fclose(fp);
}
// Stop listening for connections.
close(listensock);
return EXIT_SUCCESS;
}
static void calculate_speed(struct progress_bar *prog, unsigned long long copied, unsigned long long current, int done, prog_stat_t *prog_stat){
char *format = "%H:%M:%S";
uint64_t speedps = 1;
uint64_t speed = 1;
double dspeed = 1.0;
float percent = 1.0;
time_t remained;
time_t elapsed;
char Rformated[12], Eformated[12];
char speed_unit[] = " ";
struct tm *Rtm, *Etm;
uint64_t gbyte=1000000000.0;
uint64_t mbyte=1000000;
uint64_t kbyte=1000;
percent = prog->unit * copied;
if (percent <= 0)
percent = 1;
else if (percent >= 100)
percent = 99.99;
elapsed = (time(0) - prog->initial_time);
if (elapsed <= 0)
elapsed = 1;
speedps = prog->block_size * copied / elapsed;
speed = speedps * 60.0;
prog_stat->percent = percent;
if (speed >= gbyte){
dspeed = (double)speed / (double)gbyte;
strncpy(speed_unit, "GB", 3);
strncpy(prog_stat->speed_unit, speed_unit, 3);
}else if (speed >= mbyte){
dspeed = (double)speed / (double)mbyte;
strncpy(speed_unit, "MB", 3);
strncpy(prog_stat->speed_unit, speed_unit, 3);
}else if (speed >= kbyte){
dspeed = (double)speed / (double)kbyte;
strncpy(speed_unit, "KB", 3);
strncpy(prog_stat->speed_unit, speed_unit, 3);
}else{
dspeed = speed;
strncpy(speed_unit, "byte", 5);
strncpy(prog_stat->speed_unit, speed_unit, 5);
}
prog_stat->total_percent = prog->total_unit * current;
prog_stat->speed = dspeed;
if (done != 1){
remained = (time_t)((elapsed/percent*100) - elapsed);
if ((unsigned int)remained > 86400){
snprintf(Rformated, sizeof(Rformated), " > %3i hrs ", ((int)remained/3600));
}else{
Rtm = gmtime(&remained);
strftime(Rformated, sizeof(Rformated), format, Rtm);
}
if ((unsigned int)elapsed > 86400){
snprintf(Eformated, sizeof(Eformated), " > %3i hrs ", ((int)elapsed/3600));
}else{
Etm = gmtime(&elapsed);
strftime(Eformated, sizeof(Eformated), format, Etm);
}
} else {
prog_stat->percent=100;
remained = (time_t)0;
Rtm = gmtime(&remained);
strftime(Rformated, sizeof(Rformated), format, Rtm);
if ((unsigned int)elapsed > 86400){
snprintf(Eformated, sizeof(Eformated), " > %3i hrs ", ((int)elapsed/3600));
}else{
Etm = gmtime(&elapsed);
strftime(Eformated, sizeof(Eformated), format, Etm);
}
}
strncpy(prog_stat->Eformated, Eformated, sizeof(prog_stat->Eformated));
strncpy(prog_stat->Rformated, Rformated, sizeof(prog_stat->Rformated));
}
void bsodFatal(const char *component)
{
/* show no more than one bsod while shutting down/crashing */
if (bsodhandled) return;
bsodhandled = true;
std::string lines = getLogBuffer();
/* find python-tracebacks, and extract " File "-strings */
size_t start = 0;
std::string crash_emailaddr = CRASH_EMAILADDR;
std::string crash_component = "enigma2";
if (component)
crash_component = component;
else
{
while ((start = lines.find("\n File \"", start)) != std::string::npos)
{
start += 9;
size_t end = lines.find("\"", start);
if (end == std::string::npos)
break;
end = lines.rfind("/", end);
/* skip a potential prefix to the path */
unsigned int path_prefix = lines.find("/usr/", start);
if (path_prefix != std::string::npos && path_prefix < end)
start = path_prefix;
if (end == std::string::npos)
break;
std::string filename(lines.substr(start, end - start) + INFOFILE);
std::ifstream in(filename.c_str());
if (in.good()) {
std::getline(in, crash_emailaddr) && std::getline(in, crash_component);
in.close();
}
}
}
FILE *f;
std::string crashlog_name;
std::ostringstream os;
os << "/media/hdd/enigma2_crash_";
os << time(0);
os << ".log";
crashlog_name = os.str();
f = fopen(crashlog_name.c_str(), "wb");
if (f == NULL)
{
/* No hardisk. If there is a crash log in /home/root, leave it
* alone because we may be in a crash loop and writing this file
* all night long may damage the flash. Also, usually the first
* crash log is the most interesting one. */
crashlog_name = "/home/root/enigma2_crash.log";
if ((access(crashlog_name.c_str(), F_OK) == 0) ||
((f = fopen(crashlog_name.c_str(), "wb")) == NULL))
{
/* Re-write the same file in /tmp/ because it's expected to
* be in RAM. So the first crash log will end up in /home
* and the last in /tmp */
crashlog_name = "/tmp/enigma2_crash.log";
f = fopen(crashlog_name.c_str(), "wb");
}
}
if (f)
{
time_t t = time(0);
struct tm tm;
char tm_str[32];
localtime_r(&t, &tm);
strftime(tm_str, sizeof(tm_str), "%a %b %_d %T %Y", &tm);
XmlGenerator xml(f);
xml.open("BlakHole");
xml.open("enigma2");
xml.string("crashdate", tm_str);
xml.string("compiledate", __DATE__);
xml.string("contactemail", crash_emailaddr);
xml.comment("Please email this crashlog to above address");
xml.string("skin", getConfigString("config.skin.primary_skin", "Default Skin"));
xml.string("sourcedate", enigma2_date);
xml.string("branch", enigma2_branch);
xml.string("rev", enigma2_rev);
xml.string("version", PACKAGE_VERSION);
xml.close();
xml.open("image");
if(access("/proc/stb/info/boxtype", F_OK) != -1) {
xml.stringFromFile("stbmodel", "/proc/stb/info/boxtype");
}
else if (access("/proc/stb/info/vumodel", F_OK) != -1) {
xml.stringFromFile("stbmodel", "/proc/stb/info/vumodel");
}
else if (access("/proc/stb/info/model", F_OK) != -1) {
xml.stringFromFile("stbmodel", "/proc/stb/info/model");
}
xml.cDataFromCmd("kernelversion", "uname -a");
xml.stringFromFile("kernelcmdline", "/proc/cmdline");
xml.stringFromFile("nimsockets", "/proc/bus/nim_sockets");
xml.cDataFromFile("imageversion", "/etc/image-version");
xml.cDataFromFile("imageissue", "/etc/issue.net");
xml.close();
xml.open("crashlogs");
xml.cDataFromString("enigma2crashlog", getLogBuffer());
xml.close();
xml.close();
fclose(f);
}
ePtr<gMainDC> my_dc;
gMainDC::getInstance(my_dc);
gPainter p(my_dc);
p.resetOffset();
p.resetClip(eRect(ePoint(0, 0), my_dc->size()));
p.setBackgroundColor(gRGB(0x008000));
p.setForegroundColor(gRGB(0xFFFFFF));
int hd = my_dc->size().width() == 1920;
ePtr<gFont> font = new gFont("Regular", hd ? 30 : 20);
p.setFont(font);
p.clear();
eRect usable_area = eRect(hd ? 30 : 100, hd ? 30 : 70, my_dc->size().width() - (hd ? 60 : 150), hd ? 150 : 100);
os.str("");
os.clear();
os << "We are really sorry. Your STB encountered "
"a software problem, and needs to be restarted.\n"
"Please send the logfile " << crashlog_name << " to " << crash_emailaddr << ".\n"
"Your STB restarts in 10 seconds!\n"
"Component: " << crash_component;
p.renderText(usable_area, os.str().c_str(), gPainter::RT_WRAP|gPainter::RT_HALIGN_LEFT);
usable_area = eRect(hd ? 30 : 100, hd ? 180 : 170, my_dc->size().width() - (hd ? 60 : 180), my_dc->size().height() - (hd ? 30 : 20));
int i;
start = std::string::npos + 1;
for (i=0; i<20; ++i)
{
start = lines.rfind('\n', start - 1);
if (start == std::string::npos)
{
start = 0;
break;
}
}
font = new gFont("Regular", hd ? 21 : 14);
p.setFont(font);
p.renderText(usable_area,
lines.substr(start), gPainter::RT_HALIGN_LEFT);
sleep(10);
/*
* When 'component' is NULL, we are called because of a python exception.
* In that case, we'd prefer to to a clean shutdown of the C++ objects,
* and this should be safe, because the crash did not occur in the
* C++ part.
* However, when we got here for some other reason, a segfault probably,
* we prefer to stop immediately instead of performing a clean shutdown.
* We'd risk destroying things with every additional instruction we're
* executing here.
*/
if (component) raise(SIGKILL);
}
void date_time_layer_format_time(
char* buffer, size_t buffer_length, struct tm* now, bool is_24h
) {
strftime(buffer, buffer_length, is_24h ? "%H:%M" : "%I:%M", now);
}
int main(int argc, char** argv){
int quadrant_line, quadrant_column;
char *videoFileName = argv[1];
char quadFileName[64];
int i = 0, k, j;
long unsigned int inc = 0;
long unsigned int incaudio = 0;
int videoStreamIndex;
int audioStreamIndex= -1;
int frameFinished, gotPacket;
AVDictionary *codecOptions = NULL;
UDP_PTSframe_t PTS_frame;
struct tm *start_time_tm;
char start_time_str[64];
long unsigned int start_time;
time_t start_timer_t;
//Crop env
int tam_quad;
int frist = 1, marginLeft = 0, marginTop = 0;
int width , height;
if(argc < 4){
usage();
return -1;
}
signal (SIGTERM, handlerToFinish);
signal (SIGINT, handlerToFinish);
tam_quad = sqrt(amount_of_quadrants);
quadrant_line = atoi(argv[2]);
quadrant_column = atoi(argv[3]);
amount_of_quadrants = (quadrant_line * quadrant_column) + 1;
strcpy (quadFileName, argv[4]);
//Allocat output streams context
ff_output = malloc (sizeof(ff_output_t) * amount_of_quadrants);
av_register_all();
avformat_network_init();
//Initialize Input
if (avformat_open_input (&ff_input.formatCtx, videoFileName, NULL, NULL) != 0) {
printf ("Cold not open input video file at %s\n", videoFileName);
return -1;
}
if (avformat_find_stream_info(ff_input.formatCtx, NULL) < 0) {
printf ("Cold not get stream info\n");
return -1;
}
av_dump_format(ff_input.formatCtx, 0, videoFileName, 0);
videoStreamIndex = av_find_best_stream(ff_input.formatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, &ff_input.encoder, 0);
if (videoStreamIndex < 0) {
printf ("no video streams found\n");
return -1;
}
audioStreamIndex = av_find_best_stream(ff_input.formatCtx, AVMEDIA_TYPE_AUDIO, -1, -1, &ff_input.audioencoder, 0);
if (audioStreamIndex < 0) {
printf ("no audio streams found\n");
return -1;
}
printf ("VIDEO ST %d, AUDIO ST %d\n", videoStreamIndex, audioStreamIndex);
ff_input.audiocodecCtx = ff_input.formatCtx->streams[audioStreamIndex]->codec;
ff_input.codecCtx = ff_input.formatCtx->streams[videoStreamIndex]->codec;
if (avcodec_open2 (ff_input.audiocodecCtx, ff_input.audioencoder, NULL) < 0) {
printf ("Could not open input codec\n");
return -1;
}
if (avcodec_open2 (ff_input.codecCtx, ff_input.encoder, NULL) < 0) {
printf ("Could not open input codec\n");
return -1;
}
//Get system time and append as metadata
getSystemTime (&PTS_frame.frameTimeVal); //Must be the same for all output contexts
start_time = PTS_frame.frameTimeVal.tv_sec;
start_timer_t = (time_t) start_time;
start_time_tm = localtime (&start_timer_t);
strftime(start_time_str, sizeof start_time_str, "%Y-%m-%d %H:%M:%S", start_time_tm);
if (avformat_alloc_output_context2(&formatCtx, NULL, AV_OUTPUT_FORMAT, quadFileName) < 0) {
printf ("could not create output context\n");
return -1;
}
//Initialize Video Output Streams
for (i = 0; i < amount_of_quadrants - 1; i++) {
ff_output[i].outStream = avformat_new_stream (formatCtx, NULL);
if (ff_output[i].outStream == NULL) {
printf ("Could not create output stream\n");
return -1;
}
ff_output[i].outStream->id = formatCtx->nb_streams - 1;
ff_output[i].codecCtx = ff_output[i].outStream->codec;
ff_output[i].encoder = avcodec_find_encoder_by_name (AV_OUTPUT_CODEC);
if (ff_output[i].encoder == NULL) {
printf ("Codec %s not found..\n", AV_OUTPUT_CODEC);
return -1;
}
//Sliced sizes
width = ff_input.codecCtx->width/quadrant_column;
height = ff_input.codecCtx->height/quadrant_line;
ff_output[i].codecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
ff_output[i].codecCtx->height = height;
ff_output[i].codecCtx->width = width;
ff_output[i].codecCtx->pix_fmt = ff_input.codecCtx->pix_fmt;
if (strcmp (AV_OUTPUT_CODEC, "libvpx") == 0) {
//Maintain input aspect ratio for codec and stream info, and b_frames for codec info
ff_output[i].codecCtx->sample_aspect_ratio = ff_input.codecCtx->sample_aspect_ratio;
ff_output[i].codecCtx->max_b_frames = ff_input.codecCtx->max_b_frames;
ff_output[i].outStream->sample_aspect_ratio = ff_output[i].codecCtx->sample_aspect_ratio;
//Set custom BIT RATE and THREADs
ff_output[i].codecCtx->bit_rate = AV_OUTPUT_BITRATE;
ff_output[i].codecCtx->thread_count = AV_OUTPUT_THREADS;
ff_output[i].codecCtx->thread_type = AV_OUTPUT_THREAD_TYPE;
//Set custo timebase for codec and streams
ff_output[i].codecCtx->time_base.num = 1;
ff_output[i].codecCtx->time_base.den = AV_FRAMERATE;
ff_output[i].outStream->time_base.num = 1;
ff_output[i].outStream->time_base.den = 10000;
}
if (strcmp (AV_OUTPUT_CODEC, "libx264") == 0) {
// ff_output[i].codecCtx->profile = FF_PROFILE_H264_MAIN;
// av_dict_set(&codecOptions, "profile","main",0);
//Set custom BIT RATE and THREADs
ff_output[i].codecCtx->bit_rate = AV_OUTPUT_BITRATE;
ff_output[i].codecCtx->thread_count = AV_OUTPUT_THREADS;
ff_output[i].codecCtx->thread_type = AV_OUTPUT_THREAD_TYPE;
ff_output[i].codecCtx->bit_rate_tolerance = 0;
ff_output[i].codecCtx->rc_max_rate = 0;
ff_output[i].codecCtx->rc_buffer_size = 0;
ff_output[i].codecCtx->gop_size = 40;
ff_output[i].codecCtx->max_b_frames = 3;
ff_output[i].codecCtx->b_frame_strategy = 1;
ff_output[i].codecCtx->coder_type = 1;
ff_output[i].codecCtx->me_cmp = 1;
ff_output[i].codecCtx->me_range = 16;
ff_output[i].codecCtx->qmin = 10;
ff_output[i].codecCtx->qmax = 51;
ff_output[i].codecCtx->scenechange_threshold = 40;
ff_output[i].codecCtx->flags |= CODEC_FLAG_LOOP_FILTER;
ff_output[i].codecCtx->me_method = ME_HEX;
ff_output[i].codecCtx->me_subpel_quality = 5;
ff_output[i].codecCtx->i_quant_factor = 0.71;
ff_output[i].codecCtx->qcompress = 0.6;
ff_output[i].codecCtx->max_qdiff = 4;
//Set custo timebase for codec and streams
ff_output[i].codecCtx->time_base.num = 1;
ff_output[i].codecCtx->time_base.den = 24;
ff_output[i].outStream->time_base.num = 1;
ff_output[i].outStream->time_base.den = 90000;
}
formatCtx->start_time_realtime = start_time;
av_dict_set (&formatCtx->metadata, "service_name", start_time_str, 0);
av_dict_set (&formatCtx->metadata, "creation_time", start_time_str, 0);
//Open codec
if (avcodec_open2(ff_output[i].codecCtx, ff_output[i].encoder, &codecOptions)) {
printf ("Could not open output codec...\n");
return -1;
}
}
//Initializing Audio Output
i = amount_of_quadrants-1; //Last stream
ff_output[i].outStream = avformat_new_stream (formatCtx, NULL);
if (ff_output[i].outStream == NULL) {
printf ("Could not create output stream\n");
return -1;
}
ff_output[i].outStream->id = formatCtx->nb_streams - 1;
ff_output[i].codecCtx = ff_output[i].outStream->codec;
ff_output[i].encoder = avcodec_find_encoder (ff_input.audiocodecCtx->codec_id);
if (ff_output[i].encoder == NULL) {
printf ("Codec %s not found..\n", AUDIO_OUTPUT_CODEC);
return -1;
}
ff_output[i].codecCtx = ff_output[amount_of_quadrants-1].outStream->codec;
ff_output[i].codecCtx->codec_id = ff_input.audiocodecCtx->codec_id;
ff_output[i].codecCtx->codec_type = AVMEDIA_TYPE_AUDIO;
ff_output[i].codecCtx->sample_fmt = ff_input.audiocodecCtx->sample_fmt;
ff_output[i].codecCtx->sample_rate = ff_input.audiocodecCtx->sample_rate;
ff_output[i].codecCtx->channel_layout = ff_input.audiocodecCtx->channel_layout;
ff_output[i].codecCtx->channels = av_get_channel_layout_nb_channels(ff_output[amount_of_quadrants-1].codecCtx->channel_layout);
ff_output[i].codecCtx->bit_rate = ff_input.audiocodecCtx->bit_rate;
ff_output[i].codecCtx->sample_aspect_ratio = ff_input.audiocodecCtx->sample_aspect_ratio;
ff_output[i].codecCtx->max_b_frames = ff_input.audiocodecCtx->max_b_frames;
ff_output[i].outStream->sample_aspect_ratio = ff_output[i].codecCtx->sample_aspect_ratio;
ff_output[i].outStream->time_base.num = ff_input.formatCtx->streams[audioStreamIndex]->time_base.num;
ff_output[i].outStream->time_base.den = ff_input.formatCtx->streams[audioStreamIndex]->time_base.den;
ff_output[i].codecCtx->time_base.num = ff_input.audiocodecCtx->time_base.num;
ff_output[i].codecCtx->time_base.den = ff_input.audiocodecCtx->time_base.den;
printf("sample_rate %d\n", ff_input.audiocodecCtx->sample_rate);
//Open codec
if (avcodec_open2(ff_output[i].codecCtx, ff_output[i].encoder, &codecOptions)) {
printf ("Could not open output codec...\n");
return -1;
}
av_dump_format (formatCtx, 0, quadFileName, 1);
//Open output context
if (avio_open (&formatCtx->pb, quadFileName, AVIO_FLAG_WRITE)) {
printf ("avio_open failed %s\n", quadFileName);
return -1;
}
//Write format context header
if (avformat_write_header (formatCtx, &formatCtx->metadata)) {
printf ("fail to write outstream header\n");
return -1;
}
printf ("OUTPUT TO %s, at %lu\n", quadFileName, start_time);
incaudio = 0;
printf("Generating video streams...\n");
while(av_read_frame (ff_input.formatCtx, &ff_input.packet) >= 0 && _keepEncoder) {
if (ff_input.packet.stream_index == audioStreamIndex)
{
av_packet_ref (&ff_output[amount_of_quadrants-1].packet, &ff_input.packet);
ff_output[amount_of_quadrants-1].packet.stream_index = amount_of_quadrants-1;
ff_output[amount_of_quadrants-1].packet.pts = incaudio;
// printf("%lu\n", ff_output[amount_of_quadrants-1].packet.pts);
// if(gotPacket){
if (av_write_frame(formatCtx, &ff_output[amount_of_quadrants-1].packet) < 0) {
printf ("Unable to write to output stream..\n");
pthread_exit(NULL);
// }
}
incaudio += 2880;
}
if (ff_input.packet.stream_index == videoStreamIndex) {
ff_input.frame = av_frame_alloc();
avcodec_decode_video2 (ff_input.codecCtx, ff_input.frame, &frameFinished, &ff_input.packet);
if (frameFinished) {
//TODO: Slice inputFrame and fill avQuadFrames[quadrant]
//By now, inputFrame are replicated to all quadrants
ff_input.frame->pts = av_frame_get_best_effort_timestamp (ff_input.frame);
i = 0;
for ( k = 0; k < quadrant_line; ++k) {
for (j = 0; j < quadrant_column; ++j) {
ff_output[i].frame = av_frame_alloc();
//make the cut quadrant ff_output[i]!
av_picture_crop((AVPicture *)ff_output[i].frame, (AVPicture *)ff_input.frame,
ff_input.formatCtx->streams[videoStreamIndex]->codec->pix_fmt, marginTop, marginLeft);
ff_output[i].frame->width = width; // updates the new width
ff_output[i].frame->height = height; // updates the new height
ff_output[i].frame->format = ff_input.frame->format;
ff_output[i].frame->pts = inc;
ff_output[i].packet.data = NULL;
ff_output[i].packet.size = 0;
av_init_packet (&ff_output[i].packet);
avcodec_encode_video2 (ff_output[i].codecCtx, &ff_output[i].packet, ff_output[i].frame, &gotPacket);
if (gotPacket) {
ff_output[i].packet.stream_index = i;
av_packet_rescale_ts (&ff_output[i].packet,
ff_output[i].codecCtx->time_base,
ff_output[i].outStream->time_base);
if (av_write_frame (formatCtx, &ff_output[i].packet) < 0) {
printf ("Unable to write to output stream..\n");
pthread_exit(NULL);
}
}
av_frame_free (&ff_output[i].frame);
i++;
marginLeft += width;
}
marginLeft = 0;
marginTop += height;
}
marginTop = 0;
i = 0;
inc++;
}
av_frame_free (&ff_input.frame);
}
}
return 0;
}
void CPlayer::Reset()
{
m_DieTick = Server()->Tick();
m_JoinTick = Server()->Tick();
if (m_pCharacter)
delete m_pCharacter;
m_pCharacter = 0;
m_KillMe = 0;
m_SpectatorID = SPEC_FREEVIEW;
m_LastActionTick = Server()->Tick();
m_TeamChangeTick = Server()->Tick();
m_WeakHookSpawn = false;
int* idMap = Server()->GetIdMap(m_ClientID);
for (int i = 1;i < VANILLA_MAX_CLIENTS;i++)
{
idMap[i] = -1;
}
idMap[0] = m_ClientID;
// DDRace
m_LastCommandPos = 0;
m_LastPlaytime = time_get();
m_Sent1stAfkWarning = 0;
m_Sent2ndAfkWarning = 0;
m_ChatScore = 0;
m_EyeEmote = true;
m_TimerType = g_Config.m_SvDefaultTimerType;
m_DefEmote = EMOTE_NORMAL;
m_Afk = false;
m_LastWhisperTo = -1;
m_LastSetSpectatorMode = 0;
m_TimeoutCode[0] = '\0';
m_TuneZone = 0;
m_TuneZoneOld = m_TuneZone;
m_Halloween = false;
m_FirstPacket = true;
m_SendVoteIndex = -1;
if (g_Config.m_SvEvents)
{
time_t rawtime;
struct tm* timeinfo;
char d[16], m[16], y[16];
int dd, mm;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
strftime (d,sizeof(y),"%d",timeinfo);
strftime (m,sizeof(m),"%m",timeinfo);
strftime (y,sizeof(y),"%Y",timeinfo);
dd = atoi(d);
mm = atoi(m);
if ((mm == 12 && dd == 31) || (mm == 1 && dd == 1))
{ // New Year
m_DefEmote = EMOTE_HAPPY;
}
else if ((mm == 10 && dd == 31) || (mm == 11 && dd == 1))
{ // Halloween
m_DefEmote = EMOTE_ANGRY;
m_Halloween = true;
}
else
{
m_DefEmote = EMOTE_NORMAL;
}
}
m_DefEmoteReset = -1;
GameServer()->Score()->PlayerData(m_ClientID)->Reset();
m_ClientVersion = VERSION_VANILLA;
m_ShowOthers = g_Config.m_SvShowOthersDefault;
m_ShowAll = g_Config.m_SvShowAllDefault;
m_SpecTeam = 0;
m_NinjaJetpack = false;
m_Paused = PAUSED_NONE;
m_DND = false;
m_NextPauseTick = 0;
// Variable initialized:
m_Last_Team = 0;
#if defined(CONF_SQL)
m_LastSQLQuery = 0;
#endif
int64 Now = Server()->Tick();
int64 TickSpeed = Server()->TickSpeed();
// If the player joins within ten seconds of the server becoming
// non-empty, allow them to vote immediately. This allows players to
// vote after map changes or when they join an empty server.
//
// Otherwise, block voting for 60 seconds after joining.
if(Now > GameServer()->m_NonEmptySince + 10 * TickSpeed)
m_FirstVoteTick = Now + g_Config.m_SvJoinVoteDelay * TickSpeed;
else
m_FirstVoteTick = Now;
}
static void
peek_report(const struct peak_packet *packet, const struct peak_track *flow,
const timeslice_t *timer)
{
unsigned int i;
for (i = 0; i < use_count; ++i) {
if (i) {
pout(", ");
}
switch (use_print[i]) {
case USE_APP:
pout("app: %s",
peak_li_name(peak_li_merge(flow->li)));
break;
case USE_APP_LEN:
pout("app_len: %hu", packet->app_len);
break;
case USE_FLOW:
pout("flow: %llu", (unsigned long long)flow->id);
break;
case USE_IP_LEN:
pout("ip_len: %hu", packet->net_len);
break;
case USE_IP_TYPE:
pout("ip_type: %hhu", packet->net_type);
break;
case USE_SRC:
if (packet->net_family == AF_INET6 &&
packet->flow_sport) {
pout("src: [%s]%s",
netprint(&packet->net_saddr),
portprint(packet->flow_sport));
} else {
pout("src: %s%s",
netprint(&packet->net_saddr),
portprint(packet->flow_sport));
}
break;
case USE_DST:
if (packet->net_family == AF_INET6 &&
packet->flow_dport) {
pout("dst: [%s]%s",
netprint(&packet->net_daddr),
portprint(packet->flow_dport));
} else {
pout("dst: %s%s",
netprint(&packet->net_daddr),
portprint(packet->flow_dport));
}
break;
case USE_TIME: {
char tsbuf[40];
pout("time: %s.%06ld", strftime(tsbuf, sizeof(tsbuf),
OUTPUT_TIME, &timer->gmt) ? tsbuf : "????",
timer->tv.tv_usec);
break;
}
default:
break;
}
}
pout("\n");
}
int main(int argc, char* argv[])
{
DIR *mydir;
struct dirent *myfile;
struct stat mystat;
struct passwd *usr;
struct group *grp;
struct tm *tme;
char buf[512];
char fileperm[512];
char tmbuf[100];
if(argv[1]==NULL){
perror("usage ./a.out file/directory_name\n");
exit(0);
}
if((mydir = opendir(argv[1]))==NULL){
perror("no such file or directory\n");
exit(0);
}
usr=getpwuid(mystat.st_mode);
grp=getgrgid(mystat.st_mode);
while((myfile = readdir(mydir)) != NULL){
sprintf(buf, "%s/%s", argv[1], myfile->d_name); //appends the filename with the path
if((lstat(buf, &mystat))<0){
perror("stat error\n");
}
switch (mystat.st_mode & S_IFMT) {
case S_IFDIR: printf("d "); break;
case S_IFREG: printf("r "); break;
default: printf("- "); break;
}
tme=localtime(&mystat.st_mtime);
strftime(tmbuf,sizeof(tmbuf),"%A %B %H:%M:%S",tme);
sprintf(fileperm,"%c%c%c%c%c%c%c%c%c",
(mystat.st_mode)& S_IRUSR ? 'r':'-',
(mystat.st_mode)& S_IWUSR ? 'w':'-',
(mystat.st_mode)& S_IXUSR ? 'x':'-',
(mystat.st_mode)& S_IRGRP ? 'r':'-',
(mystat.st_mode)& S_IRGRP ? 'w':'-',
(mystat.st_mode)& S_IXGRP ? 'x':'-',
(mystat.st_mode)& S_IROTH ? 'r':'-',
(mystat.st_mode)& S_IWOTH ? 'w':'-',
(mystat.st_mode)& S_IXOTH ? 'x':'-'
);
printf("%s ",fileperm);
printf("%d ",mystat.st_nlink);
printf("%s ",usr->pw_name);
printf("%s ",grp->gr_name);
printf("%s",tmbuf);
printf("%d ",mystat.st_size);
printf("%s\n", myfile->d_name);
}
closedir(mydir);
return 0;
}
/*
* Handle gopher menus
*/
void gopher_menu(state *st)
{
FILE *fp;
sdirent dir[MAX_SDIRENT];
struct tm *ltime;
struct stat file;
char buf[BUFSIZE];
char pathname[BUFSIZE];
char displayname[BUFSIZE];
char encodedname[BUFSIZE];
char timestr[20];
char sizestr[20];
char *parent;
char *c;
char type;
int width;
int num;
int i;
int n;
/* Check for a gophermap */
snprintf(pathname, sizeof(pathname), "%s/%s",
st->req_realpath, st->map_file);
if (stat(pathname, &file) == OK &&
(file.st_mode & S_IFMT) == S_IFREG) {
/* Parse gophermap */
if (gophermap(st, pathname, 0) == QUIT) {
footer(st);
return;
}
}
else {
/* Check for a gophertag */
snprintf(pathname, sizeof(pathname), "%s/%s",
st->req_realpath, st->tag_file);
if (stat(pathname, &file) == OK &&
(file.st_mode & S_IFMT) == S_IFREG) {
/* Read & output gophertag */
if ((fp = fopen(pathname , "r"))) {
fgets(buf, sizeof(buf), fp);
chomp(buf);
info(st, buf, TYPE_TITLE);
info(st, EMPTY, TYPE_INFO);
fclose(fp);
}
}
/* No gophermap or tag found - print default header */
else if (st->opt_header) {
/* Use the selector as menu title */
sstrlcpy(displayname, st->req_selector);
/* Shorten too long titles */
while (strlen(displayname) > (st->out_width - sizeof(HEADER_FORMAT))) {
if ((c = strchr(displayname, '/')) == NULL) break;
if (!*++c) break;
sstrlcpy(displayname, c);
}
/* Output menu title */
snprintf(buf, sizeof(buf), HEADER_FORMAT, displayname);
info(st, buf, TYPE_TITLE);
info(st, EMPTY, TYPE_INFO);
}
}
/* Scan the directory */
num = sortdir(st->req_realpath, dir, MAX_SDIRENT);
if (num < 0) die(st, ERR_NOTFOUND, "WTF?");
/* Create link to parent directory */
if (st->opt_parent) {
sstrlcpy(buf, st->req_selector);
parent = dirname(buf);
/* Root has no parent */
if (strcmp(st->req_selector, ROOT) != MATCH) {
/* Prevent double-slash */
if (strcmp(parent, ROOT) == MATCH) parent++;
/* Print link */
printf("1%-*s\t%s/\t%s\t%i" CRLF,
st->opt_date ? (st->out_width - 1) : (int) strlen(PARENT),
PARENT, parent, st->server_host, st->server_port);
}
}
/* Width of filenames for fancy listing */
width = st->out_width - DATE_WIDTH - 15;
/* Loop through the directory entries */
for (i = 0; i < num; i++) {
/* Get full path+name */
snprintf(pathname, sizeof(pathname), "%s/%s",
st->req_realpath, dir[i].name);
/* Skip dotfiles and non world-readables */
if (dir[i].name[0] == '.') continue;
if ((dir[i].mode & S_IROTH) == 0) continue;
/* Skip gophermaps and tags (but not dirs) */
if ((dir[i].mode & S_IFMT) != S_IFDIR) {
if (strcmp(dir[i].name, st->map_file) == MATCH) continue;
if (strcmp(dir[i].name, st->tag_file) == MATCH) continue;
}
/* Skip files marked for hiding */
for (n = 0; n < st->hidden_count; n++)
if (strcmp(dir[i].name, st->hidden[n]) == MATCH) break;
if (n < st->hidden_count) continue; /* Cruel hack... */
/* Generate display name with correct output charset */
if (st->opt_iconv)
sstrniconv(st->out_charset, displayname, dir[i].name);
else
sstrlcpy(displayname, dir[i].name);
/* #OCT-encode filename */
strnencode(encodedname, dir[i].name, sizeof(encodedname));
/* Handle inline .gophermap */
if (strstr(displayname, st->map_file) > displayname) {
gophermap(st, pathname, 0);
continue;
}
/* Handle directories */
if ((dir[i].mode & S_IFMT) == S_IFDIR) {
/* Check for a gophertag */
snprintf(buf, sizeof(buf), "%s/%s",
pathname, st->tag_file);
if (stat(buf, &file) == OK &&
(file.st_mode & S_IFMT) == S_IFREG) {
/* Use the gophertag as displayname */
if ((fp = fopen(buf , "r"))) {
fgets(buf, sizeof(buf), fp);
chomp(buf);
fclose(fp);
/* Skip empty gophertags */
if (*buf) {
/* Convert to output charset */
if (st->opt_iconv) sstrniconv(st->out_charset, displayname, buf);
else sstrlcpy(displayname, buf);
}
}
}
/* Dir listing with dates */
if (st->opt_date) {
ltime = localtime(&dir[i].mtime);
strftime(timestr, sizeof(timestr), DATE_FORMAT, ltime);
/* Hack to get around UTF-8 byte != char */
n = width - strcut(displayname, width);
strrepeat(buf, ' ', n);
printf("1%s%s %s - \t%s%s/\t%s\t%i" CRLF,
displayname,
buf,
timestr,
st->req_selector,
encodedname,
st->server_host,
st->server_port);
}
/* Regular dir listing */
else {
strcut(displayname, st->out_width);
printf("1%s\t%s%s/\t%s\t%i" CRLF,
displayname,
st->req_selector,
encodedname,
st->server_host,
st->server_port);
}
continue;
}
/* Skip special files (sockets, fifos etc) */
if ((dir[i].mode & S_IFMT) != S_IFREG) continue;
/* Get file type */
type = gopher_filetype(st, pathname, st->opt_magic);
/* File listing with dates & sizes */
if (st->opt_date) {
ltime = localtime(&dir[i].mtime);
strftime(timestr, sizeof(timestr), DATE_FORMAT, ltime);
strfsize(sizestr, dir[i].size, sizeof(sizestr));
/* Hack to get around UTF-8 byte != char */
n = width - strcut(displayname, width);
strrepeat(buf, ' ', n);
printf("%c%s%s %s %s\t%s%s\t%s\t%i" CRLF, type,
displayname,
buf,
timestr,
sizestr,
st->req_selector,
encodedname,
st->server_host,
st->server_port);
}
/* Regular file listing */
else {
strcut(displayname, st->out_width);
printf("%c%s\t%s%s\t%s\t%i" CRLF, type,
displayname,
st->req_selector,
encodedname,
st->server_host,
st->server_port);
}
}
/* Print footer */
footer(st);
}
int popc_logger_t(LOGLEVEL level, const char* file, int line, const char* function, const char* tag, const char* format,
...) {
// Check if message level in higher than our threshold
if (level < MIN_LOG_LEVEL)
return 0;
// Use file name without path to avoid having the full user path in logs
const char* basename = strrchr(file, '/');
if (basename == nullptr)
basename = file;
else
basename += 1;
auto log_file = get_log_file();
// Time
time_t rawtime;
time(&rawtime);
const tm* timeinfo = localtime(&rawtime);
char dd[20];
strftime(dd, sizeof(dd), "%Y-%m-%d %H:%M:%S", timeinfo);
char msg[512];
va_list ap;
va_start(ap, format);
vsnprintf(msg, sizeof(msg), format, ap);
va_end(ap);
auto msg_length = strlen(msg);
if (msg[msg_length - 1] == '\n') {
msg[msg_length - 1] = ' ';
}
// Print the message to stderr or stdout
if (level >= MIN_STDERR_LEVEL)
if (tag) {
fprintf(stderr, "%s %5d %s [%5s] %s (%s:%d %s)\n", dd, getpid(), get_prefix(level), tag, msg, basename,
line, function);
} else {
fprintf(stderr, "%s %5d %s %s (%s:%d %s)\n", dd, getpid(), get_prefix(level), msg, basename, line,
function);
}
else if (level >= MIN_STDOUT_LEVEL)
fprintf(stdout, "%s\n", msg);
// Print the message to file
FILE* f = fopen(log_file.c_str(), "a");
if (f == NULL) {
fprintf(stderr, "ERROR: Impossible to open log file %s\n", log_file.c_str());
return 1;
}
if (tag) {
fprintf(f, "%s %5d %s [%5s] %s (%s:%d %s)\n", dd, getpid(), get_prefix(level), tag, msg, basename, line,
function);
} else {
fprintf(f, "%s %5d %s %s (%s:%d %s)\n", dd, getpid(), get_prefix(level), msg, basename, line, function);
}
fclose(f);
return 0;
}
bool Aeromatic::fdm()
{
Aircraft *aircraft = _aircraft[_atype];
std::vector<System*> systems = _aircraft[_atype]->get_systems();
_engines = _MIN(_no_engines, 4);
aircraft->_engines = _engines;
//***** METRICS ***************************************
_payload = _max_weight;
_stall_weight = _max_weight;
// first, estimate wing loading in psf
float wing_loading = aircraft->get_wing_loading();
// if no wing area given, use wing loading to estimate
bool wingarea_input;
if (_wing.area == 0)
{
wingarea_input = false;
_wing.area = _max_weight / wing_loading;
}
else
{
wingarea_input = true;
wing_loading = _max_weight / _wing.area;
}
// calculate wing chord
if (_wing.aspect == 0) {
_wing.aspect = aircraft->get_aspect_ratio();
} else {
_user_wing_data++;
}
if (_wing.chord == 0)
{
if (_wing.aspect > 0) {
_wing.chord = _wing.span / _wing.aspect;
} else {
_wing.chord = _wing.area / _wing.span;
}
}
else {
_user_wing_data++;
}
// calculate aspect ratio
if (_wing.aspect == 0) {
_wing.aspect = (_wing.span*_wing.span) / _wing.area;
} else {
_user_wing_data++;
}
if (_wing.taper == 0) {
_wing.taper = 1.0f;
}
float TR = _wing.taper;
_wing.chord_mean = 0.75f*_wing.chord*(1.0f+TR+TR*TR)/(1.0f+TR);
_wing.de_da = 4.0f/(_wing.aspect+2.0f);
// leading edge sweep
// devide the span by two and account for fuselage width
float span = 0.45f*_wing.span;
float root_tip = _wing.chord*(1.0f - _wing.taper);
if (_wing.sweep_le == 0)
{
_wing.sweep_le = atanf(root_tip/span);
if (_wing.shape != DELTA) {
_wing.sweep_le *= 0.5f;
}
_wing.sweep_le *= RAD_TO_DEG;
_wing.sweep_le += _wing.sweep;
}
if (_wing.thickness == 0)
{
// Hofman equation for t/c
// float Ws = _stall_weight;
float Vs = _stall_speed * KNOTS_TO_FPS;
float sweep = _wing.sweep * DEG_TO_RAD;
float TC = 0.051f * _wing.area * powf(cosf(sweep), 5.0f)/Vs;
_wing.thickness = TC * _wing.chord;
}
// for now let's use a standard 2 degrees wing incidence
if (_wing.incidence == 0) {
_wing.incidence = 2.0;
}
// estimate horizontal tail area
if (_htail.area == 0) {
_htail.area = _wing.area * aircraft->get_htail_area();
}
// estimate distance from CG to horizontal tail aero center
if (_htail.arm == 0) {
_htail.arm = _length * aircraft->get_htail_arm();
}
if (_htail.aspect == 0) {
_htail.aspect = 5.0f; // ht_w * _wing.aspect;
}
if (_htail.taper == 0) {
_htail.taper = 0.5f;
}
float ht_w = 0.33f; // sqrtf(_htail.area / _wing.area);
if (_htail.span == 0) {
_htail.span = ht_w * _wing.span;
}
TR = _htail.taper;
_htail.chord_mean = 0.75f*_htail.chord*(1.0f+TR+TR*TR)/(1.0f+TR);
_htail.de_da = 4.0f/(_htail.aspect+2.0f);
// estimate vertical tail area
if (_vtail.area == 0) {
_vtail.area = _wing.area * aircraft->get_vtail_area();
}
// estimate distance from CG to vertical tail aero center
if (_vtail.arm == 0) {
_vtail.arm = _length * aircraft->get_vtail_arm();
}
float vt_w = 0.15f; // sqrtf(_vtail.area / _wing.area*0.5f);
if (_vtail.span == 0) {
_vtail.span = vt_w * _wing.span;
}
if (_vtail.aspect == 0) {
_vtail.aspect = 1.7f; // vt_w * _wing.aspect;
}
if (_vtail.taper == 0) {
_vtail.taper = 0.7f;
}
TR = _vtail.taper;
_vtail.chord_mean = 0.75f*_vtail.chord*(1.0f+TR+TR*TR)/(1.0f+TR);
_vtail.de_da = 4.0f/(_vtail.aspect+2.0f);
//***** EMPTY WEIGHT *********************************
// estimate empty weight, based on max weight
if (_empty_weight == 0) {
_empty_weight = _max_weight * aircraft->get_empty_weight();
}
//***** MOMENTS OF INERTIA ******************************
// use Roskam's formulae to estimate moments of inertia
if (_inertia[X] == 0.0f && _inertia[Y] == 0.0f && _inertia[Z] == 0.0f)
{
float slugs = (_empty_weight / 32.2f); // sluggishness
const float *R = aircraft->get_roskam();
// These are for an empty airplane
_inertia[X] = slugs * powf((R[X] * _wing.span / 2), 2);
_inertia[Y] = slugs * powf((R[Y] * _length / 2), 2);
_inertia[Z] = slugs * powf((R[Z] * ((_wing.span + _length)/2)/2), 2);
}
//***** CG LOCATION ***********************************
_cg_loc[X] = (_length - _htail.arm) * FEET_TO_INCH;
_cg_loc[Y] = 0;
_cg_loc[Z] = -(_length / 40.0f) * FEET_TO_INCH;
//***** AERO REFERENCE POINT **************************
_aero_rp[X] = _cg_loc[X];
_aero_rp[Y] = 0;
_aero_rp[Z] = 0;
//***** PILOT EYEPOINT *********************************
// place pilot's eyepoint based on airplane type
const float *_eyept_loc = aircraft->get_eyept_loc();
float eyept_loc[3];
eyept_loc[X] = (_length * _eyept_loc[X]) * FEET_TO_INCH;
eyept_loc[Y] = _eyept_loc[Y];
eyept_loc[Z] = _eyept_loc[Z];
//***** PAYLOAD ***************************************
// A point mass will be placed at the CG weighing
// 1/2 of the usable aircraft load.
float payload_loc[3];
payload_loc[X] = _cg_loc[X];
payload_loc[Y] = _cg_loc[Y];
payload_loc[Z] = _cg_loc[Z];
_payload -= _empty_weight;
//***** SYSTEMS ***************************************
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled()) {
systems[i]->set(_cg_loc);
}
}
//***** COEFFICIENTS **********************************
aircraft->set_lift();
aircraft->set_drag();
aircraft->set_side();
aircraft->set_roll();
aircraft->set_pitch();
aircraft->set_yaw();
//************************************************
//* *
//* Print out xml document *
//* *
//************************************************
char str[64];
time_t t;
time(&t);
#ifdef _MSC_VER
struct tm ti;
localtime_s(&ti, &t);
strftime(str, sizeof(str), "%d %b %Y", &ti);
#else
struct tm *ti= localtime(&t);
strftime(str, sizeof(str), "%d %b %Y", ti);
#endif
_dir = _subdir ? create_dir(_path, _name) : _path;
if (_dir.empty()) {
std::cout << "Unable to create directory: " << _path << "/" << _name << std::endl;
return false;
}
std::string systems_dir;
if (_system_files)
{
systems_dir = create_dir(_dir, "Systems");
if (systems_dir.empty())
{
std::cout << "Unable to create directory: " << _dir<< "/Systems" << std::endl;
_system_files = false;
}
}
std::string fname = _dir + "/" + std::string(_name) + ".xml";
std::string version = AEROMATIC_VERSION_STR;
if (!_overwrite && overwrite(fname)) {
std::cout << "File already exists: " << fname << std::endl;
return false;
}
std::ofstream file;
file.open(fname.c_str());
if (file.fail() || file.bad())
{
file.close();
return false;
}
file.precision(2);
file.flags(std::ios::right);
file << std::fixed << std::showpoint;
file << "<?xml version=\"1.0\"?>" << std::endl;
file << "<?xml-stylesheet type=\"text/xsl\" href=\"http://jsbsim.sourceforge.net/JSBSim.xsl\"?>" << std::endl;
file << std::endl;
file << "<fdm_config name=\"" << _name << "\" version=\"2.0\" release=\"ALPHA\"" << std::endl;
file << " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" << std::endl;
file << " xsi:noNamespaceSchemaLocation=\"http://jsbsim.sourceforge.net/JSBSim.xsd\">" << std::endl;
file << std::endl;
file << " <fileheader>" << std::endl;
file << " <author> Aeromatic v " << version << " </author>" << std::endl;
file << " <filecreationdate> " << str << " </filecreationdate>" << std::endl;
file << " <version>$Revision: 1.50 $</version>" << std::endl;
file << " <description> Models a " << _name << ". </description>" << std::endl;
file << " </fileheader>" << std::endl;
file << std::endl;
file << "<!--\n File: " << _name << ".xml" << std::endl;
file << " Inputs:" << std::endl;
file << " name: " << _name << std::endl;
file << " type: ";
switch(_atype)
{
case LIGHT:
if (_no_engines == 0) {
file << "glider" << std::endl;
} else {
file << "light commuter with " << _no_engines << " engines" << std::endl;
}
break;
case PERFORMANCE:
file << "WWII fighter, subsonic sport, aerobatic" << std::endl;
break;
case FIGHTER:
file << _no_engines << " engine transonic/supersonic fighter" << std::endl;
break;
case JET_TRANSPORT:
file << _no_engines << " engine transonic transport" << std::endl;
break;
case PROP_TRANSPORT:
file << "multi-engine prop transport" << std::endl;
break;
}
file << " stall speed: " << _stall_speed << "kts" << std::endl;
file << " max weight: " << _max_weight << " lb" << std::endl;
file << " length: " << _length << " ft" << std::endl;
file << " wing: " << std::endl;
file << " span: " << _wing.span << " ft" << std::endl;
file << " area: ";
if (wingarea_input) {
file << _wing.area << " sq-ft" << std::endl;
} else {
file << "unspecified" << std::endl;
}
file << " chord: " << _wing.chord << " ft" << std::endl;
file << " aspect ratio: " << _wing.aspect << ":1" << std::endl;
file << " taper ratio: " << _wing.taper << ":1" << std::endl;
file << " incidence: " << _wing.incidence << " degrees" << std::endl;
file << " dihedral: " << _wing.dihedral << " degrees" << std::endl;
file << " sweep: " << _wing.sweep << " degrees" << std::endl;
file << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled()) {
std::string comment = systems[i]->comment();
if (!comment.empty()) {
file << comment << std::endl;
}
}
}
file << " Outputs:" << std::endl;
file << " wing loading: " << wing_loading << " lb/sq-ft" << std::endl;
file << " payload: " << _payload << " lbs" << std::endl;
file << " CL-alpha: " << _CLalpha[0] << " per radian" << std::endl;
file << " CL-0: " << _CL0 << std::endl;
file << " CL-max: " << _CLmax[0] << std::endl;
file << " CD-0: " << _CD0 << std::endl;
file << " K: " << _Kdi << std::endl;
file << " Mcrit: " << _Mcrit << std::endl;
file << "-->" << std::endl;
file << std::endl;
//***** METRICS **********************************
file << " <metrics>" << std::endl;
file << " <wingarea unit=\"FT2\"> " << std::setw(8) << _wing.area << " </wingarea>" << std::endl;
file << " <wingspan unit=\"FT\" > " << std::setw(8) << _wing.span << " </wingspan>" << std::endl;
file << " <wing_incidence> " << std::setw(8) << _wing.incidence << " </wing_incidence>" << std::endl;
file << " <chord unit=\"FT\" > " << std::setw(8) << _wing.chord << " </chord>" << std::endl;
file << " <htailarea unit=\"FT2\"> " << std::setw(8) << _htail.area << " </htailarea>" << std::endl;
file << " <htailarm unit=\"FT\" > " << std::setw(8) << _htail.arm << " </htailarm>" << std::endl;
file << " <vtailarea unit=\"FT2\">" << std::setw(8) << _vtail.area << " </vtailarea>" << std::endl;
file << " <vtailarm unit=\"FT\" > " << std::setw(8) << _vtail.arm << " </vtailarm>" << std::endl;
file << " <location name=\"AERORP\" unit=\"IN\">" << std::endl;
file << " <x> " << std::setw(8) << _aero_rp[X] << " </x>" << std::endl;
file << " <y> " << std::setw(8) << _aero_rp[Y] << " </y>" << std::endl;
file << " <z> " << std::setw(8) << _aero_rp[Z] << " </z>" << std::endl;
file << " </location>" << std::endl;
file << " <location name=\"EYEPOINT\" unit=\"IN\">" << std::endl;
file << " <x> " << std::setw(8) << eyept_loc[X] << " </x>" << std::endl;
file << " <y> " << std::setw(8) << eyept_loc[Y] << " </y>" << std::endl;
file << " <z> " << std::setw(8) << eyept_loc[Z] << " </z>" << std::endl;
file << " </location>" << std::endl;
file << " <location name=\"VRP\" unit=\"IN\">" << std::endl;
file << " <x> 0.0 </x>" << std::endl;
file << " <y> 0.0 </y>" << std::endl;
file << " <z> 0.0 </z>" << std::endl;
file << " </location>" << std::endl;
file << " </metrics>"<< std::endl;
file << std::endl;
file << " <mass_balance>" << std::endl;
file << " <ixx unit=\"SLUG*FT2\"> " << std::setw(8) << _inertia[X] << " </ixx>" << std::endl;
file << " <iyy unit=\"SLUG*FT2\"> " << std::setw(8) << _inertia[Y] << " </iyy>" << std::endl;
file << " <izz unit=\"SLUG*FT2\"> " << std::setw(8) << _inertia[Z] << " </izz>" << std::endl;
file << " <emptywt unit=\"LBS\" > " << std::setw(8) << _empty_weight << " </emptywt>" << std::endl;
file << " <location name=\"CG\" unit=\"IN\">" << std::endl;
file << " <x> " << std::setw(8) << _cg_loc[X] << " </x>" << std::endl;
file << " <y> " << std::setw(8) << _cg_loc[Y] << " </y>" << std::endl;
file << " <z> " << std::setw(8) << _cg_loc[Z] << " </z>" << std::endl;
file << " </location>" << std::endl;
file << " <pointmass name=\"Payload\">" << std::endl;
file << " <description> " << _payload << " LBS should bring model up to entered max weight </description>" << std::endl;
file << " <weight unit=\"LBS\"> " << (_payload* 0.5f) << " </weight>" << std::endl;
file << " <location name=\"POINTMASS\" unit=\"IN\">" << std::endl;
file << " <x> " << std::setw(8) << payload_loc[X] << " </x>" << std::endl;
file << " <y> " << std::setw(8) << payload_loc[Y] << " </y>" << std::endl;
file << " <z> " << std::setw(8) << payload_loc[Z] << " </z>" << std::endl;
file << " </location>" << std::endl;
file << " </pointmass>" << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string mass_balance = systems[i]->mass_balance();
if (!mass_balance.empty()) {
file << mass_balance << std::endl;
}
}
}
file << " </mass_balance>" << std::endl;
file << std::endl;
//***** FDM_CONFIG ********************************************
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string fdm = systems[i]->fdm();
if (!fdm.empty()) {
file << fdm << std::endl;
}
}
}
//***** SYSTEMS ***********************************************
if (_system_files == true)
{
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string system = systems[i]->system();
if (!system.empty())
{
std::string sname = systems[i]->get_description();
std::string sfname = sname + ".xml";
if (!_overwrite && overwrite(sfname))
{
std::cout << "File already exists: " << fname << std::endl;
std::cout << "Skipping." << std::endl;
}
else
{
file << " <system file=\"" << sfname << "\"/>" << std::endl;
std::string sfpath = systems_dir + "/" + sfname;
std::ofstream sfile;
sfile.open(sfpath.c_str());
if (sfile.fail() || sfile.bad())
{
std::cout << "Error opening file: " << fname << std::endl;
std::cout << "Skipping." << std::endl;
}
else
{
sfile << "<?xml version=\"1.0\"?>" << std::endl;
sfile << "<system name=\"" << sname << "\">" << std::endl;
sfile << system << std::endl;
sfile << "</system>" << std::endl;
}
sfile.close();
}
}
}
}
file << std::endl;
}
file << " <flight_control name=\"FCS: " << _name << "\">" << std::endl;
file << std::endl;
if (_system_files == false)
{
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string system = systems[i]->system();
if (!system.empty()) {
file << system << std::endl;
}
}
}
}
file << " </flight_control>"<< std::endl;
file << std::endl;
//***** AERODYNAMICS ******************************************
file << " <aerodynamics>" << std::endl;
file << std::endl;
// ***** LIFT ******************************************
file << " <axis name=\"LIFT\">" << std::endl;
file << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string lift = systems[i]->lift();
if (!lift.empty()) {
file << lift << std::endl;
}
}
}
file << " </axis>" << std::endl;
file << std::endl;
// ***** DRAG ******************************************
file << " <axis name=\"DRAG\">" << std::endl;
file << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string drag = systems[i]->drag();
if (!drag.empty()) {
file << drag << std::endl;
}
}
}
file << " </axis>" << std::endl;
file << std::endl;
// ***** SIDE ******************************************
file << " <axis name=\"SIDE\">" << std::endl;
file << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string side = systems[i]->side();
if (!side.empty()) {
file << side << std::endl;
}
}
}
file << " </axis>" << std::endl;
file << std::endl;
// ***** PITCH *****************************************
file << " <axis name=\"PITCH\">" << std::endl;
file << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string pitch = systems[i]->pitch();
if (!pitch.empty()) {
file << pitch << std::endl;
}
}
}
file << " </axis>" << std::endl;
file << std::endl;
// ***** ROLL ******************************************
file << " <axis name=\"ROLL\">" << std::endl;
file << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string roll = systems[i]->roll();
if (!roll.empty()) {
file << roll << std::endl;
}
}
}
file << " </axis>" << std::endl;
file << std::endl;
// ***** YAW *******************************************
file << " <axis name=\"YAW\">" << std::endl;
file << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string yaw = systems[i]->yaw();
if (!yaw.empty()) {
file << yaw << std::endl;
}
}
}
file << " </axis>" << std::endl;
file << std::endl;
file << " </aerodynamics>" << std::endl;
file << std::endl;
file << " <external_reactions>" << std::endl;
for (unsigned i=0; i<systems.size(); ++i)
{
if (systems[i]->enabled())
{
std::string force = systems[i]->external_force();
if (!force.empty()) {
file << force << std::endl;
}
}
}
file << " </external_reactions>" << std::endl;
file << std::endl;
file << "</fdm_config>" << std::endl;
file.close();
return true;
}
void pre(std::ostream& out, Actions& actions)
{
// The quickbook file has been parsed. Now, it's time to
// generate the output. Here's what we'll do *before* anything else.
if (actions.doc_id.empty())
actions.doc_id = detail::make_identifier(
actions.doc_title.begin(),actions.doc_title.end());
if (actions.doc_dirname.empty())
actions.doc_dirname = actions.doc_id;
if (actions.doc_last_revision.empty())
{
// default value for last-revision is now
char strdate[ 30 ];
time_t t = time(0);
strftime(
strdate, sizeof(strdate),
"$" /* prevent CVS substitution */ "Date: %Y/%m/%d %H:%M:%S $",
gmtime(&t)
);
actions.doc_last_revision = strdate;
}
out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
<< "<!DOCTYPE library PUBLIC \"-//Boost//DTD BoostBook XML V1.0//EN\"\n"
<< " \"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd\">\n"
<< '<' << actions.doc_type << "\n"
<< " id=\"" << actions.doc_id << "\"\n"
<< " name=\"" << actions.doc_title << "\"\n"
<< " dirname=\"" << actions.doc_dirname << "\"\n"
<< " last-revision=\"" << actions.doc_last_revision << "\" \n"
<< " xmlns:xi=\"http://www.w3.org/2001/XInclude\">\n"
<< " <" << actions.doc_type << "info>\n";
for_each(
actions.doc_authors.begin()
, actions.doc_authors.end()
, xml_author(out));
if (!actions.doc_copyright_holder.empty())
{
out << "\n" << " <copyright>\n";
for_each(
actions.doc_copyright_years.begin()
, actions.doc_copyright_years.end()
, xml_year(out));
out << " <holder>" << actions.doc_copyright_holder << "</holder>\n"
<< " </copyright>\n"
<< "\n"
;
}
if (!actions.doc_license.empty())
{
out << " <legalnotice>\n"
<< " <para>\n"
<< " " << actions.doc_license << "\n"
<< " </para>\n"
<< " </legalnotice>\n"
<< "\n"
;
}
if (!actions.doc_purpose.empty())
{
out << " <" << actions.doc_type << "purpose>\n"
<< " " << actions.doc_purpose
<< " </" << actions.doc_type << "purpose>\n"
<< "\n"
;
}
if (!actions.doc_purpose.empty())
{
out << " <" << actions.doc_type << "category name=\"category:"
<< actions.doc_category
<< "\"></" << actions.doc_type << "category>\n"
<< "\n"
;
}
out << " </" << actions.doc_type << "info>\n"
<< "\n"
;
if (!actions.doc_title.empty())
{
out << " <title>" << actions.doc_title;
if (!actions.doc_version.empty())
out << ' ' << actions.doc_version;
out << "</title>\n\n\n";
}
}
void Logger::logPrint( bool hex, const char * const file, const int line, const int level, const char *fstring, ... )
{
if ( level <= mEffectiveLevel )
{
char classString[4];
char timeString[64];
char logString[8192];
va_list argPtr;
struct timeval timeVal;
if ( level < PANIC || level > DEBUG9 )
Panic( "Invalid logger level %d", level );
strncpy( classString, smCodes[level].c_str(), sizeof(classString) );
gettimeofday( &timeVal, NULL );
#if 0
if ( logRuntime )
{
static struct timeval logStart;
subtractTime( &timeVal, &logStart );
snprintf( timeString, sizeof(timeString), "%ld.%03ld", timeVal.tv_sec, timeVal.tv_usec/1000 );
}
else
{
#endif
char *timePtr = timeString;
timePtr += strftime( timePtr, sizeof(timeString), "%x %H:%M:%S", localtime(&timeVal.tv_sec) );
snprintf( timePtr, sizeof(timeString)-(timePtr-timeString), ".%06ld", timeVal.tv_usec );
#if 0
}
#endif
pid_t tid;
#ifdef HAVE_SYSCALL
if ( (tid = syscall(SYS_gettid)) < 0 ) // Thread/Process id
#endif // HAVE_SYSCALL
tid = getpid(); // Process id
char *logPtr = logString;
logPtr += snprintf( logPtr, sizeof(logString), "%s %s[%d].%s-%s/%d [",
timeString,
mId.c_str(),
tid,
classString,
file,
line
);
char *syslogStart = logPtr;
va_start( argPtr, fstring );
if ( hex )
{
unsigned char *data = va_arg( argPtr, unsigned char * );
int len = va_arg( argPtr, int );
int i;
logPtr += snprintf( logPtr, sizeof(logString)-(logPtr-logString), "%d:", len );
for ( i = 0; i < len; i++ )
{
logPtr += snprintf( logPtr, sizeof(logString)-(logPtr-logString), " %02x", data[i] );
}
}
else
{
int main(int argc, char *argv[])
{
string server("129.194.32.96");
CalendarController::InputLang lang(CalendarController::INPUT_LANG_ENG);
if (argc >= 2)
{
string arg = argv[1];
if (arg == "ENG")
{
lang = CalendarController::INPUT_LANG_ENG;
}
else if (arg == "JAP")
{
lang = CalendarController::INPUT_LANG_JAP;
}
else
{
lang = CalendarController::INPUT_LANG_ENG;
}
}
if (argc == 3)
{
server = argv[2];
}
const struct tm* tm;
size_t len;
time_t now;
char* s;
now = time(NULL);
tm = localtime(&now);
s = new char[40];
len = strftime(s, 40, "%Y-%m-%d.%H-%M-%S", tm);
string str(s);
str = "../logs/test_calendar_gui." + str + ".output";
delete s;
ACE_OSTREAM_TYPE* output =
new std::ofstream(str.c_str());
ACE_LOG_MSG->msg_ostream(output, 0);
ACE_LOG_MSG->set_flags(ACE_Log_Msg::OSTREAM);
ACE_LOG_MSG->set_flags(ACE_Log_Msg::VERBOSE_LITE);
ACE_LOG_MSG->priority_mask(LM_TRACE|LM_DEBUG, ACE_Log_Msg::PROCESS);
g_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
gtk_init(&argc, &argv);
g_set_application_name(APP_NAME);
CalendarController calendarctl;
calendarctl.SetRemoteServersIP(server);
calendarctl.SetInputLang(lang);
calendarctl.RunApp();
ACE_LOG_MSG->clr_flags(ACE_Log_Msg::OSTREAM);
delete output;
gdk_threads_leave();
return 0;
}
int
main(int argc, char *argv[])
{
fd_set rfds, wfds;
struct cn_strct *tp, *to;
int rnum, wnum, readsocks;
int i;
struct tm *tm_struct;
/* initialize the masterdate we update only every second */
_Last_loop = time(NULL);
tm_struct = gmtime(&_Last_loop);
strftime( _Master_date, 32, "%a, %d %b %Y %H:%M:%S %Z", tm_struct);
#if DEBUG_VERBOSE == 2
_Conn_count=0;
#endif
#if DEBUG_VERBOSE == 1
printf("STARTED AT: %s\n", _Master_date);
#endif
signal(SIGQUIT, die);
signal(SIGTERM, die);
signal(SIGPIPE, check_sockets);
signal(SIGINT, clean_on_quit);
/* Fill up the initial connection lists; _Free_conns is just a LIFO stack,
* there shall never be a performance issues -> single linked only */
_Free_count=0;
for (i = 0; i < INITIAL_CONNS; i++) {
tp = _Free_conns;
_Free_conns = (struct cn_strct *) calloc(1, sizeof(struct cn_strct));
_Free_conns->data_buf_head =
(char *) calloc (RECV_BUFF_LENGTH, sizeof (char));
_Free_conns->c_next = tp;
_Free_conns->c_prev = NULL;
_Free_conns->q_prev = NULL;
_Free_conns->identifier = _Conn_count++;
_Free_count++;
}
/* create the master listener */
if ((_Master_sock = create_listener(HTTP_PORT)) == -1) {
fprintf(stderr, "ERR: Couldn't bind to port %d\n",
HTTP_PORT);
exit(1);
}
/* set up LIFO queue */
_Queue_tail = _Queue_head = NULL;
_Queue_count = 0;
/* create workers for application */
for(i = 0; i < WORKER_THREADS; i++) {
pthread_create(&_Workers[i], NULL, &run_app_thread, (void *) &i);
}
sleep(1);
for(i = 0; i < WORKER_THREADS; i++) {
pthread_detach( _Workers[i] );
}
#if DEBUG_VERBOSE == 1
printf("%s: listening on port %d (http)\n",
_Server_version, HTTP_PORT);
#endif
/* main loop */
while (1) {
// clean socket lists
FD_ZERO(&rfds);
FD_ZERO(&wfds);
wnum = -1;
// Add master listener to reading sockets
FD_SET(_Master_sock, &rfds);
rnum = _Master_sock;
// Add the established sockets
tp = _Busy_conns;
/* Adding connection to the SocketSets based on state */
while (tp != NULL) {
if (REQSTATE_READ_HEAD == tp->req_state) {
FD_SET(tp->net_socket, &rfds);
rnum = (tp->net_socket > rnum) ? tp->net_socket : rnum;
}
if (REQSTATE_SEND_FILE == tp->req_state) {
FD_SET(tp->net_socket, &wfds);
wnum = (tp->net_socket > wnum) ? tp->net_socket : wnum;
}
tp = tp->c_next;
}
readsocks = select(
(wnum > rnum) ? wnum+1 : rnum+1,
(-1 != rnum) ? &rfds : NULL,
(-1 != wnum) ? &wfds : NULL,
(fd_set *) 0,
NULL
);
// is the main listener in the read set? -> New connection
if (FD_ISSET(_Master_sock, &rfds)) {
handle_new_conn(_Master_sock);
readsocks--;
}
// Handle the established sockets
tp = _Busy_conns;
while (readsocks > 0 && tp != NULL) {
to = tp;
tp = tp->c_next;
if (REQSTATE_READ_HEAD == to->req_state &&
FD_ISSET(to->net_socket, &rfds)) {
readsocks--;
#if DEBUG_VERBOSE == 1
printf("WANNA RECV HEAD\n");
#endif
read_request(to);
}
if (REQSTATE_SEND_FILE == to->req_state &&
FD_ISSET(to->net_socket, &wfds)) {
readsocks--;
#if DEBUG_VERBOSE == 1
printf("WANNA SEND FILE\n");
#endif
send_file(to);
}
}
}
return 0;
}
main( void)
{
char * host = "0.0.0.0";
char * service = "2525";
char * proto = "tcp";
//char * proto = "sctp";
struct sockaddr_in sin, remote;
struct tm *tp;
time_t t;
int i, sd, rsd, rlen, readed, pid;
char buf[513], t_str[512];
if ( (sd = mksock( host, service, proto, &sin)) == -1)
{
perror( "Ошибка при создании сокета");
return 1;
}
printf( "Адрес сервера %s = %s\n", host, (char *) (inet_ntoa( sin.sin_addr)));
printf( "Адрес порта сервера %s = %X\n", service, sin.sin_port);
i = 1;
i = setsockopt( sd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof( &i));
if( i != 0) perror("Опция сокета (SOL_SOCKET, SO_REUSEADDR))");
if( bind( sd, (struct sockaddr *) &sin, sizeof( sin)) < 0)
{
perror( "Ошибка при привязке сокета");
return 1;
}
for ( i=0; i<CHILDS; i++)
{
pid = fork();
switch ( pid)
{
case -1:
perror( "Не создается дочерний процесс");
break;
case 0:
pid = i+1;
i=CHILDS+1;
break;
default:
pid=0;
}
}
if ( listen( sd, 0) == -1)
{
perror( "Ошибка при переводе сокета в пассивный режим");
return 1;
}
while(1)
{
rlen = sizeof( remote);
rsd = accept( sd, (struct sockaddr *)&remote, &rlen);
fprintf( stderr, "Process %d accepted connection\n", pid);
t = time( NULL);
tp = localtime( &t);
strftime( t_str, 512, "%a, %d %b %Y %T %z", tp);
snprintf( buf, 512, "Server [%d]: %s\n", pid, t_str );
send(rsd, buf, strlen(buf), 0);
close( rsd);
}
return 0;
}
void find_hb (char * fname)
{
int i, ii, j, jj, k ;
int debug=0;
char buf1[20],buf2[20]; /* buffers for atomid routines */
char calendar_s[128];
/* void find_ss()*/
/* {*/
/* int i,j;*/
/* float d;*/
time_t calendar;
struct tm * calendar_tm_p;
char output_string[256]="\0";
/* /* Check for disulphide bridges */
if (!longoutflg)
{
if (debug) printf("If !longoutflg\n");
time ( &calendar );
if (debug) printf(" time\n");
calendar_tm_p = localtime ( &calendar );
if (debug) printf(" calendar\n");
strftime(calendar_s,128,"%b %d %X %Z %Y\0",calendar_tm_p);
if (debug) printf(" strftime\n");
fprintf(ofp,"HBPLUS Hydrogen Bond Calculator v %s %s\n",VERSION,calendar_s );
fprintf(ofp,"(c) I McDonald, D Naylor, D Jones and J Thornton 1993 All Rights Reserved.\n");
fprintf(ofp,"Citing HBPLUS in publications that use these results is condition of use.\n");
fprintf(ofp,"%4.4s <- Brookhaven Code \"%s\" <- PDB file\n",brcode,fname);
fprintf(ofp,"<---DONOR---> <-ACCEPTOR--> atom ^ \n");
fprintf(ofp,"c i cat <-CA-CA-> ^ H-A-AA ^ H- \n");
fprintf(ofp,"h n atom resd res DA || num DHA H-A angle D-A-AA Bond\n");
fprintf(ofp,"n s type num typ dist DA aas dist angle dist angle num\n");
/*
<---DONOR---> <-ACCEPTOR--> atom ^
c i cat <-CA-CA-> ^ H-A-AA ^ H-
h n atom resd res DA || num DHA H-A angle D-A-AA Bond
n s type num typ dist DA aas dist angle dist angle num
E0010-LEU N E0006-TYR O 3.07 MM 4 6.17 157.2 2.13 147.8 154.9 17
*/
}
/* First Pass : Check for disulphide bridges */
puts("Checking for hydrogen bonds . . . ");
for (ii = 0; ii < (natoms-1); ii++)
{
/* ignore atom incapable of H-bonding immediately */
if (atom[ii].aacode <TOTNAA &&
donors[atom[ii].aacode][atom[ii].atmtyp] == 0 &&
accepts[atom[ii].aacode][atom[ii].atmtyp] == 0)
if (!nnbflg)
continue;
for (jj = ii + 1; jj < natoms; jj++)
{
debug=0;
if (atom[jj].aacode <TOTNAA &&
donors[atom[jj].aacode][atom[jj].atmtyp] == 0 &&
accepts[atom[jj].aacode][atom[jj].atmtyp] == 0)
if (!nnbflg)
continue;
/* if the exchangeflg has been set to 2 by the -X option, only
do the hydrogen bonds for the His, Asn, and Gln side-chains */
if (exchangeflg==2)
if ( !( (atom[ii].atmtyp > 4 && (atom[ii].aacode == His
|| atom[ii].aacode == Asn || atom[ii].aacode == Gln) )
|| ( atom[jj].atmtyp > 4 && (atom[jj].aacode == Asn
|| atom[jj].aacode == Gln || atom[jj].aacode == His) )
) )
continue;
/* ignore very distant atom pairs immediately */
if (fabs(atom[ii].p.x - atom[jj].p.x) > HBDIST ||
fabs(atom[ii].p.y - atom[jj].p.y) > HBDIST ||
fabs(atom[ii].p.z - atom[jj].p.z) > HBDIST )
{
if (debug == 2)
printf(" very distant, ignoring this pair!\n");
continue;
}
/* Check each IJ atom pair twice. I.e. check for I(don) / J(acc)
and J(don) / I(acc) */
for (k = (nnbflg)?1:0; k < 2; k++) /* slightly opaque this one */
/* if nnbflg is set, then this loop only executes once,
because it doesn't matter which is the donor and which is
the acceptor */
{
if (debug == 2)
printf(" k = %1d\n",k);
/* Load/swap for correct donor/acceptor order */
if (k)
{
i = jj;
j = ii;
}
else
{
i = ii;
j = jj;
}
/* if (!strncmp(atomid(i,buf1),"6XIA/-0002-HOH O ",10) ||
!strncmp(atomid(i,buf2),"6XIA/-0038-SER OG ",10) )
debug=2;
else
debug=0;*//*debug setting line*/
if (debug == 2)
printf("Checking between %s and %s.\n",atomid(i,buf1),atomid(j,buf2));
if( is_donacc(i,j) )
{
if (debug==2)
printf(". . . are Donor/Acceptor pair.\n");
if( calc_hb(output_string,i,j))
{
fprintf_hb(output_string,i,j);
if (debug==2)
printf(". . . are H-Bonded.\n");
}
else
if(debug==2)
printf(". . . but fail the calc_hb test\n");
}
else
if (debug==2)
printf(". . . NOT Donor/Acceptor pair.\n");
} /* end k loop */
} /* end jj loop */
} /* end ii loop */
if (nnbflg)
printf("%d neighbour interactions found.\n", nhb);
else
printf("%d hydrogen bonds found.\n", nhb);
}
/*@ -compdestroy @*/
int main(int argc, char **argv)
{
char buf[4096];
bool timestamp = false;
char *format = "%F %T";
char tmstr[200];
bool daemonize = false;
bool binary = false;
bool sleepy = false;
bool new_line = true;
bool raw = false;
bool watch = false;
bool profile = false;
int option_u = 0; // option to show uSeconds
long count = -1;
int option;
unsigned int vflag = 0, l = 0;
FILE *fp;
unsigned int flags;
fd_set fds;
struct fixsource_t source;
char *serialport = NULL;
char *outfile = NULL;
/*@-branchstate@*/
flags = WATCH_ENABLE;
while ((option = getopt(argc, argv, "?dD:lhrRwStT:vVn:s:o:pPu2")) != -1) {
switch (option) {
case 'D':
debug = atoi(optarg);
#ifdef CLIENTDEBUG_ENABLE
gps_enable_debug(debug, stderr);
#endif /* CLIENTDEBUG_ENABLE */
break;
case 'n':
count = strtol(optarg, 0, 0);
break;
case 'r':
raw = true;
/*
* Yes, -r invokes NMEA mode rather than proper raw mode.
* This emulates the behavior under the old protocol.
*/
flags |= WATCH_NMEA;
break;
case 'R':
flags |= WATCH_RAW;
binary = true;
break;
case 'd':
daemonize = true;
break;
case 'l':
sleepy = true;
break;
case 't':
timestamp = true;
break;
case 'T':
timestamp = true;
format = optarg;
break;
case 'u':
timestamp = true;
option_u++;
break;
case 'v':
vflag++;
break;
case 'w':
flags |= WATCH_JSON;
watch = true;
break;
case 'S':
flags |= WATCH_SCALED;
break;
case 'p':
profile = true;
break;
case 'P':
flags |= WATCH_PPS;
break;
case 'V':
(void)fprintf(stderr, "%s: %s (revision %s)\n",
argv[0], VERSION, REVISION);
exit(EXIT_SUCCESS);
case 's':
serialport = optarg;
break;
case 'o':
outfile = optarg;
break;
case '2':
flags |= WATCH_SPLIT24;
break;
case '?':
case 'h':
default:
usage();
exit(EXIT_FAILURE);
}
}
/*@+branchstate@*/
/* Grok the server, port, and device. */
if (optind < argc) {
gpsd_source_spec(argv[optind], &source);
} else
gpsd_source_spec(NULL, &source);
if (serialport != NULL && !raw) {
(void)fprintf(stderr, "gpspipe: use of '-s' requires '-r'.\n");
exit(EXIT_FAILURE);
}
if (outfile == NULL && daemonize) {
(void)fprintf(stderr, "gpspipe: use of '-d' requires '-o'.\n");
exit(EXIT_FAILURE);
}
if (!raw && !watch && !binary) {
(void)fprintf(stderr,
"gpspipe: one of '-R', '-r', or '-w' is required.\n");
exit(EXIT_FAILURE);
}
/* Daemonize if the user requested it. */
/*@ -unrecog @*/
if (daemonize)
if (daemon(0, 0) != 0)
(void)fprintf(stderr,
"gpspipe: demonization failed: %s\n",
strerror(errno));
/*@ +unrecog @*/
/* Sleep for ten seconds if the user requested it. */
if (sleepy)
(void)sleep(10);
/* Open the output file if the user requested it. If the user
* requested '-R', we use the 'b' flag in fopen() to "do the right
* thing" in non-linux/unix OSes. */
if (outfile == NULL) {
fp = stdout;
} else {
if (binary)
fp = fopen(outfile, "wb");
else
fp = fopen(outfile, "w");
if (fp == NULL) {
(void)fprintf(stderr,
"gpspipe: unable to open output file: %s\n",
outfile);
exit(EXIT_FAILURE);
}
}
/* Open the serial port and set it up. */
if (serialport)
open_serial(serialport);
/*@ -nullpass -onlytrans @*/
if (gps_open(source.server, source.port, &gpsdata) != 0) {
(void)fprintf(stderr,
"gpspipe: could not connect to gpsd %s:%s, %s(%d)\n",
source.server, source.port, gps_errstr(errno), errno);
exit(EXIT_FAILURE);
}
/*@ +nullpass +onlytrans @*/
if (profile)
flags |= WATCH_TIMING;
if (source.device != NULL)
flags |= WATCH_DEVICE;
(void)gps_stream(&gpsdata, flags, source.device);
if ((isatty(STDERR_FILENO) == 0) || daemonize)
vflag = 0;
for (;;) {
int r = 0;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100000;
FD_ZERO(&fds);
FD_SET(gpsdata.gps_fd, &fds);
errno = 0;
r = select(gpsdata.gps_fd+1, &fds, NULL, NULL, &tv);
if (r == -1 && errno != EINTR) {
(void)fprintf(stderr, "gpspipe: select error %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
} else if (r == 0)
continue;
if (vflag)
spinner(vflag, l++);
/* reading directly from the socket avoids decode overhead */
errno = 0;
r = (int)read(gpsdata.gps_fd, buf, sizeof(buf));
if (r > 0) {
int i = 0;
int j = 0;
for (i = 0; i < r; i++) {
char c = buf[i];
if (j < (int)(sizeof(serbuf) - 1)) {
serbuf[j++] = buf[i];
}
if (new_line && timestamp) {
char tmstr_u[20]; // time with "usec" resolution
struct timeval now;
struct tm *tmp_now;
(void)gettimeofday( &now, NULL );
tmp_now = localtime((time_t *)&(now.tv_sec));
(void)strftime(tmstr, sizeof(tmstr), format, tmp_now);
new_line = 0;
switch( option_u ) {
case 2:
(void)snprintf(tmstr_u, sizeof(tmstr_u),
" %ld.%06ld", now.tv_sec, now.tv_usec);
break;
case 1:
(void)snprintf(tmstr_u, sizeof(tmstr_u),
".%06ld", now.tv_usec);
break;
default:
*tmstr_u = '\0';
break;
}
if (fprintf(fp, "%.24s%s: ", tmstr, tmstr_u) <= 0) {
(void)fprintf(stderr,
"gpspipe: write error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
}
if (fputc(c, fp) == EOF) {
fprintf(stderr, "gpspipe: Write Error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (c == '\n') {
if (serialport != NULL) {
if (write(fd_out, serbuf, (size_t) j) == -1) {
fprintf(stderr,
"gpspipe: Serial port write Error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
j = 0;
}
new_line = true;
/* flush after every good line */
if (fflush(fp)) {
(void)fprintf(stderr,
"gpspipe: fflush Error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (count > 0) {
if (0 >= --count) {
/* completed count */
exit(EXIT_SUCCESS);
}
}
}
}
} else {
if (r == -1) {
if (errno == EAGAIN)
continue;
else
(void)fprintf(stderr, "gpspipe: read error %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
} else {
exit(EXIT_SUCCESS);
}
}
}
#ifdef __UNUSED__
if (serialport != NULL) {
/* Restore the old serial port settings. */
if (tcsetattr(fd_out, TCSANOW, &oldtio) != 0) {
(void)fprintf(stderr, "Error restoring serial port settings\n");
exit(EXIT_FAILURE);
}
}
#endif /* __UNUSED__ */
exit(EXIT_SUCCESS);
}
/**
* @short Transforms a time_t to a ISO date string
*
* The dest pointer must be at least 21 bytes long as thats the maximum size of the date.
*/
void onion_shortcut_date_string_iso(time_t t, char *dest){
struct tm ts;
gmtime_r(&t, &ts);
strftime(dest, t, "%FT%TZ", &ts);
}
static int
test_merge_conflicts ()
{
SeafRepo *repo;
char *head, *remote;
char *file_a, *file_b, *file_bb, *file_c, *file_d, *file_e, *file_f;
FILE *fp_a, *fp_b, *fp_c, *fp_d;
GError *error = NULL;
char cmd[1024];
int ret;
char buf[64];
printf ("\n=== test merge conflicts\n\n");
repo = create_repo ("merge-conflicts");
first_commit (repo);
sleep (2);
printf ("*** creating branch \"test\"\n");
/* create branch "test". */
if (seafile_branch_add (repo->id, "test", NULL, &error) < 0) {
fprintf (stderr, "Failed to create branch: %s.\n", error->message);
return -1;
}
/* create a new commit on branch "local". */
file_a = g_build_filename (repo->worktree, "test-a", NULL);
file_b = g_build_filename (repo->worktree, "test-b", NULL);
file_bb = g_build_filename (repo->worktree, "test-b/b", NULL);
file_c = g_build_filename (repo->worktree, "c/test-c", NULL);
file_d = g_build_filename (repo->worktree, "a", NULL);
file_e = g_build_filename (repo->worktree, "golden-gate.jpg", NULL);
file_f = g_build_filename (repo->worktree, "a/stanford-cs.jpg", NULL);
/* modify an existing file, to test modify/modify conflict. */
fp_a = g_fopen (file_a, "wb");
if (!fp_a) {
fprintf (stderr, "Failed to open %s: %s\n", file_a, strerror(errno));
return -1;
}
fprintf (fp_a, "xyzxyz\nxyzxyz");
fclose (fp_a);
/* delete a file and create a directory with the same name,
* to test d/f conflict.
*/
g_unlink (file_b);
if (g_mkdir (file_b, 0777) < 0) {
fprintf (stderr, "Failed to create %s: %s\n", file_b, strerror(errno));
return -1;
}
fp_b = g_fopen (file_bb, "w+b");
if (!fp_b) {
fprintf (stderr, "Failed to open %s: %s\n", file_bb, strerror(errno));
return -1;
}
fprintf (fp_b, "1234\n1234\n");
fclose (fp_b);
/* modify another file, to test modify/delete conflict. */
fp_c = g_fopen (file_c, "wb");
if (!fp_c) {
fprintf (stderr, "Failed to open %s: %s\n", file_c, strerror(errno));
return -1;
}
fprintf (fp_c, "something else.\n");
fclose (fp_c);
/* delete a directory and create a file with the same name,
* to test d/f conflict.
*/
snprintf (cmd, 1024, "rm -r %s", file_d);
ret = system (cmd);
if (ret < 0 || WEXITSTATUS(ret) != 0) {
fprintf (stderr, "Failed to remove %s\n", file_d);
return -1;
}
fp_d = g_fopen (file_d, "w+b");
if (!fp_d) {
fprintf (stderr, "Failed to open %s: %s\n", file_d, strerror(errno));
return -1;
}
fprintf (fp_d, "1234\n1234\n");
fclose (fp_d);
sleep (2);
if (seaf_repo_index_add (repo, "") < 0) {
fprintf (stderr, "Failed to add on branch local\n");
return -1;
}
printf ("*** creating new commit on local\n");
head = seaf_repo_index_commit (repo, "merge test 1.", FALSE, NULL, &error);
if (!head) {
fprintf (stderr, "Failed to commit on branch test\n");
return -1;
}
printf ("*** checking out branch test.\n");
/* switch to branch "test". */
if (seafile_checkout (repo->id, "test", &error) < 0) {
fprintf (stderr, "Failed to checkout branch test\n");
fprintf (stderr, "Checkout error messages:\n%s", error->message);
return -1;
}
sleep (2);
/* create a new commit on branch "test". */
/* modify/modify conflict. */
fp_a = g_fopen (file_a, "w+b");
if (!fp_a) {
fprintf (stderr, "Failed to open %s: %s\n", file_a, strerror(errno));
return -1;
}
fprintf (fp_a, "abcabc\nabcabc");
fclose (fp_a);
/* df conflict occurs only when files are changed. */
fp_b = g_fopen (file_b, "wb");
if (!fp_b) {
fprintf (stderr, "Failed to open %s: %s\n", file_b, strerror(errno));
return -1;
}
fprintf (fp_b, "12345678");
fclose (fp_b);
/* modify/delete conflict. */
g_unlink (file_c);
/* df conflict occurs only when files are changed. */
snprintf (cmd, 1024, "cp %s %s", file_e, file_f);
ret = system (cmd);
if (ret < 0 || WEXITSTATUS(ret) != 0) {
fprintf (stderr, "Failed to cp %s to %s\n", file_e, file_f);
return -1;
}
sleep (2);
if (seaf_repo_index_add (repo, "") < 0) {
fprintf (stderr, "Failed to add on branch test\n");
return -1;
}
printf ("*** creating new commit on branch test.\n");
remote = seaf_repo_index_commit (repo, "merge test 2.", FALSE, NULL, &error);
if (!remote) {
fprintf (stderr, "Failed to commit on branch test\n");
return -1;
}
printf ("*** checking out branch local.\n");
/* switch back to branch "local". */
if (seafile_checkout (repo->id, "local", &error) < 0) {
fprintf (stderr, "Failed to checkout branch local\n");
fprintf (stderr, "Checkout error messages:\n%s", error->message);
return -1;
}
sleep (2);
printf ("*** merging test to local.\n");
/* merge branch "test". */
if (seafile_merge (repo->id, "test", &error) == 0) {
fprintf (stderr, "This merge is supposed to fail!!\n");
return -1;
}
fprintf (stderr, "Merge error messages:\n%s", error->message);
printf ("*** check merge conflict results.\n");
if (g_access (file_f, F_OK) != 0) {
fprintf (stderr, "Bug: %s should exist.\n", file_a);
return -1;
}
if (g_access (file_c, F_OK) != 0) {
fprintf (stderr, "Bug: %s should exist.\n", file_c);
return -1;
}
time_t t = time(NULL);
strftime(buf, 64, "--plt_%Y-%m-%d", localtime(&t));
char *file_a_local = g_strconcat (file_a, buf, NULL);
char *file_a_test = g_strconcat (file_a, "", NULL);
if (check_file_content (file_a_local, "xyzxyz\nxyzxyz", 13) < 0)
return -1;
if (check_file_content (file_a_test, "abcabc\nabcabc", 13) < 0)
return -1;
char *file_d_local = g_strconcat (file_d, buf, NULL);
if (check_file_content (file_d_local, "1234\n1234\n", 10) < 0)
return -1;
if (check_dir (file_d) < 0) {
return -1;
}
char *dir_b_test = g_strconcat (file_b, buf, NULL);
if (check_file_content (file_b, "12345678", 8) < 0)
return -1;
if (check_dir (dir_b_test) < 0) {
return -1;
}
printf ("\n=== Successfully handle merge conflict.\n\n");
return 0;
}
int
lws_http_action(struct lws *wsi)
{
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
enum http_connection_type connection_type;
enum http_version request_version;
char content_length_str[32];
const struct lws_http_mount *hm, *hit = NULL;
unsigned int n, count = 0;
char http_version_str[10];
char http_conn_str[20];
int http_version_len;
char *uri_ptr = NULL;
int uri_len = 0, best = 0;
int meth = -1;
static const unsigned char methods[] = {
WSI_TOKEN_GET_URI,
WSI_TOKEN_POST_URI,
WSI_TOKEN_OPTIONS_URI,
WSI_TOKEN_PUT_URI,
WSI_TOKEN_PATCH_URI,
WSI_TOKEN_DELETE_URI,
#ifdef LWS_USE_HTTP2
WSI_TOKEN_HTTP_COLON_PATH,
#endif
};
#if defined(_DEBUG) || defined(LWS_WITH_ACCESS_LOG)
static const char * const method_names[] = {
"GET", "POST", "OPTIONS", "PUT", "PATCH", "DELETE",
#ifdef LWS_USE_HTTP2
":path",
#endif
};
#endif
/* it's not websocket.... shall we accept it as http? */
for (n = 0; n < ARRAY_SIZE(methods); n++)
if (lws_hdr_total_length(wsi, methods[n]))
count++;
if (!count) {
lwsl_warn("Missing URI in HTTP request\n");
goto bail_nuke_ah;
}
if (count != 1) {
lwsl_warn("multiple methods?\n");
goto bail_nuke_ah;
}
if (lws_ensure_user_space(wsi))
goto bail_nuke_ah;
for (n = 0; n < ARRAY_SIZE(methods); n++)
if (lws_hdr_total_length(wsi, methods[n])) {
uri_ptr = lws_hdr_simple_ptr(wsi, methods[n]);
uri_len = lws_hdr_total_length(wsi, methods[n]);
lwsl_info("Method: %s request for '%s'\n",
method_names[n], uri_ptr);
meth = n;
break;
}
(void)meth;
/* we insist on absolute paths */
if (uri_ptr[0] != '/') {
lws_return_http_status(wsi, HTTP_STATUS_FORBIDDEN, NULL);
goto bail_nuke_ah;
}
/* HTTP header had a content length? */
wsi->u.http.content_length = 0;
if (lws_hdr_total_length(wsi, WSI_TOKEN_POST_URI) ||
lws_hdr_total_length(wsi, WSI_TOKEN_PATCH_URI) ||
lws_hdr_total_length(wsi, WSI_TOKEN_PUT_URI))
wsi->u.http.content_length = 100 * 1024 * 1024;
if (lws_hdr_total_length(wsi, WSI_TOKEN_HTTP_CONTENT_LENGTH)) {
lws_hdr_copy(wsi, content_length_str,
sizeof(content_length_str) - 1,
WSI_TOKEN_HTTP_CONTENT_LENGTH);
wsi->u.http.content_length = atoi(content_length_str);
}
if (wsi->http2_substream) {
wsi->u.http.request_version = HTTP_VERSION_2;
} else {
/* http_version? Default to 1.0, override with token: */
request_version = HTTP_VERSION_1_0;
/* Works for single digit HTTP versions. : */
http_version_len = lws_hdr_total_length(wsi, WSI_TOKEN_HTTP);
if (http_version_len > 7) {
lws_hdr_copy(wsi, http_version_str,
sizeof(http_version_str) - 1, WSI_TOKEN_HTTP);
if (http_version_str[5] == '1' && http_version_str[7] == '1')
request_version = HTTP_VERSION_1_1;
}
wsi->u.http.request_version = request_version;
/* HTTP/1.1 defaults to "keep-alive", 1.0 to "close" */
if (request_version == HTTP_VERSION_1_1)
connection_type = HTTP_CONNECTION_KEEP_ALIVE;
else
connection_type = HTTP_CONNECTION_CLOSE;
/* Override default if http "Connection:" header: */
if (lws_hdr_total_length(wsi, WSI_TOKEN_CONNECTION)) {
lws_hdr_copy(wsi, http_conn_str, sizeof(http_conn_str) - 1,
WSI_TOKEN_CONNECTION);
http_conn_str[sizeof(http_conn_str) - 1] = '\0';
if (!strcasecmp(http_conn_str, "keep-alive"))
connection_type = HTTP_CONNECTION_KEEP_ALIVE;
else
if (!strcasecmp(http_conn_str, "close"))
connection_type = HTTP_CONNECTION_CLOSE;
}
wsi->u.http.connection_type = connection_type;
}
n = wsi->protocol->callback(wsi, LWS_CALLBACK_FILTER_HTTP_CONNECTION,
wsi->user_space, uri_ptr, uri_len);
if (n) {
lwsl_info("LWS_CALLBACK_HTTP closing\n");
return 1;
}
/*
* if there is content supposed to be coming,
* put a timeout on it having arrived
*/
lws_set_timeout(wsi, PENDING_TIMEOUT_HTTP_CONTENT,
wsi->context->timeout_secs);
#ifdef LWS_OPENSSL_SUPPORT
if (wsi->redirect_to_https) {
/*
* we accepted http:// only so we could redirect to
* https://, so issue the redirect. Create the redirection
* URI from the host: header and ignore the path part
*/
unsigned char *start = pt->serv_buf + LWS_PRE, *p = start,
*end = p + 512;
if (!lws_hdr_total_length(wsi, WSI_TOKEN_HOST))
goto bail_nuke_ah;
n = sprintf((char *)end, "https://%s/",
lws_hdr_simple_ptr(wsi, WSI_TOKEN_HOST));
n = lws_http_redirect(wsi, HTTP_STATUS_MOVED_PERMANENTLY,
end, n, &p, end);
if ((int)n < 0)
goto bail_nuke_ah;
return lws_http_transaction_completed(wsi);
}
#endif
#ifdef LWS_WITH_ACCESS_LOG
/*
* Produce Apache-compatible log string for wsi, like this:
*
* 2.31.234.19 - - [27/Mar/2016:03:22:44 +0800]
* "GET /aep-screen.png HTTP/1.1"
* 200 152987 "https://libwebsockets.org/index.html"
* "Mozilla/5.0 (Macint... Chrome/49.0.2623.87 Safari/537.36"
*
*/
{
static const char * const hver[] = {
"http/1.0", "http/1.1", "http/2"
};
#ifdef LWS_USE_IPV6
char ads[INET6_ADDRSTRLEN];
#else
char ads[INET_ADDRSTRLEN];
#endif
char da[64];
const char *pa, *me;
struct tm *tmp;
time_t t = time(NULL);
int l = 256;
if (wsi->access_log_pending)
lws_access_log(wsi);
wsi->access_log.header_log = lws_malloc(l);
tmp = localtime(&t);
if (tmp)
strftime(da, sizeof(da), "%d/%b/%Y:%H:%M:%S %z", tmp);
else
strcpy(da, "01/Jan/1970:00:00:00 +0000");
pa = lws_get_peer_simple(wsi, ads, sizeof(ads));
if (!pa)
pa = "(unknown)";
if (meth >= 0)
me = method_names[meth];
else
me = "unknown";
snprintf(wsi->access_log.header_log, l,
"%s - - [%s] \"%s %s %s\"",
pa, da, me, uri_ptr,
hver[wsi->u.http.request_version]);
l = lws_hdr_total_length(wsi, WSI_TOKEN_HTTP_USER_AGENT);
if (l) {
wsi->access_log.user_agent = lws_malloc(l + 2);
lws_hdr_copy(wsi, wsi->access_log.user_agent,
l + 1, WSI_TOKEN_HTTP_USER_AGENT);
}
wsi->access_log_pending = 1;
}
#endif
/* can we serve it from the mount list? */
hm = wsi->vhost->mount_list;
while (hm) {
if (uri_len >= hm->mountpoint_len &&
!strncmp(uri_ptr, hm->mountpoint, hm->mountpoint_len) &&
(uri_ptr[hm->mountpoint_len] == '\0' ||
uri_ptr[hm->mountpoint_len] == '/' ||
hm->mountpoint_len == 1)
) {
if (hm->origin_protocol == LWSMPRO_CALLBACK ||
((hm->origin_protocol == LWSMPRO_CGI ||
lws_hdr_total_length(wsi, WSI_TOKEN_GET_URI)) &&
hm->mountpoint_len > best)) {
best = hm->mountpoint_len;
hit = hm;
}
}
hm = hm->mount_next;
}
if (hit) {
char *s = uri_ptr + hit->mountpoint_len;
lwsl_debug("*** hit %d %d %s\n", hit->mountpoint_len,
hit->origin_protocol , hit->origin);
/*
* if we have a mountpoint like https://xxx.com/yyy
* there is an implied / at the end for our purposes since
* we can only mount on a "directory".
*
* But if we just go with that, the browser cannot understand
* that he is actually looking down one "directory level", so
* even though we give him /yyy/abc.html he acts like the
* current directory level is /. So relative urls like "x.png"
* wrongly look outside the mountpoint.
*
* Therefore if we didn't come in on a url with an explicit
* / at the end, we must redirect to add it so the browser
* understands he is one "directory level" down.
*/
if ((hit->mountpoint_len > 1 ||
(hit->origin_protocol == LWSMPRO_REDIR_HTTP ||
hit->origin_protocol == LWSMPRO_REDIR_HTTPS)) &&
(*s != '/' ||
(hit->origin_protocol == LWSMPRO_REDIR_HTTP ||
hit->origin_protocol == LWSMPRO_REDIR_HTTPS)) &&
(hit->origin_protocol != LWSMPRO_CGI && hit->origin_protocol != LWSMPRO_CALLBACK)) {
unsigned char *start = pt->serv_buf + LWS_PRE,
*p = start, *end = p + 512;
static const char *oprot[] = {
"http://", "https://"
};
lwsl_debug("Doing 301 '%s' org %s\n", s, hit->origin);
if (!lws_hdr_total_length(wsi, WSI_TOKEN_HOST))
goto bail_nuke_ah;
/* > at start indicates deal with by redirect */
if (hit->origin_protocol & 4)
n = snprintf((char *)end, 256, "%s%s",
oprot[hit->origin_protocol & 1],
hit->origin);
else
n = snprintf((char *)end, 256,
"https://%s/%s/",
lws_hdr_simple_ptr(wsi, WSI_TOKEN_HOST),
uri_ptr);
n = lws_http_redirect(wsi, HTTP_STATUS_MOVED_PERMANENTLY,
end, n, &p, end);
if ((int)n < 0)
goto bail_nuke_ah;
return lws_http_transaction_completed(wsi);
}
/*
* A particular protocol callback is mounted here?
*
* For the duration of this http transaction, bind us to the
* associated protocol
*/
if (hit->origin_protocol == LWSMPRO_CALLBACK) {
for (n = 0; n < wsi->vhost->count_protocols; n++)
if (!strcmp(wsi->vhost->protocols[n].name,
hit->origin)) {
if (wsi->protocol != &wsi->vhost->protocols[n])
if (!wsi->user_space_externally_allocated)
lws_free_set_NULL(wsi->user_space);
wsi->protocol = &wsi->vhost->protocols[n];
if (lws_ensure_user_space(wsi)) {
lwsl_err("Unable to allocate user space\n");
return 1;
}
break;
}
if (n == wsi->vhost->count_protocols) {
n = -1;
lwsl_err("Unable to find plugin '%s'\n",
hit->origin);
}
n = wsi->protocol->callback(wsi, LWS_CALLBACK_HTTP,
wsi->user_space, uri_ptr, uri_len);
goto after;
}
/* deferred cleanup and reset to protocols[0] */
if (wsi->protocol != &wsi->vhost->protocols[0])
if (!wsi->user_space_externally_allocated)
lws_free_set_NULL(wsi->user_space);
wsi->protocol = &wsi->vhost->protocols[0];
#ifdef LWS_WITH_CGI
/* did we hit something with a cgi:// origin? */
if (hit->origin_protocol == LWSMPRO_CGI) {
const char *cmd[] = {
NULL, /* replace with cgi path */
NULL
};
unsigned char *p, *end, buffer[256];
lwsl_debug("%s: cgi\n", __func__);
cmd[0] = hit->origin;
n = 5;
if (hit->cgi_timeout)
n = hit->cgi_timeout;
n = lws_cgi(wsi, cmd, hit->mountpoint_len, n,
hit->cgienv);
if (n) {
lwsl_err("%s: cgi failed\n");
return -1;
}
p = buffer + LWS_PRE;
end = p + sizeof(buffer) - LWS_PRE;
if (lws_add_http_header_status(wsi, 200, &p, end))
return 1;
if (lws_add_http_header_by_token(wsi, WSI_TOKEN_CONNECTION,
(unsigned char *)"close", 5, &p, end))
return 1;
n = lws_write(wsi, buffer + LWS_PRE,
p - (buffer + LWS_PRE),
LWS_WRITE_HTTP_HEADERS);
goto deal_body;
}
#endif
n = strlen(s);
if (s[0] == '\0' || (n == 1 && s[n - 1] == '/'))
s = (char *)hit->def;
if (!s)
s = "index.html";
wsi->cache_secs = hit->cache_max_age;
wsi->cache_reuse = hit->cache_reusable;
wsi->cache_revalidate = hit->cache_revalidate;
wsi->cache_intermediaries = hit->cache_intermediaries;
n = lws_http_serve(wsi, s, hit->origin);
if (n) {
/*
* lws_return_http_status(wsi, HTTP_STATUS_NOT_FOUND, NULL);
*/
n = wsi->protocol->callback(wsi, LWS_CALLBACK_HTTP,
wsi->user_space, uri_ptr, uri_len);
}
} else {
/* deferred cleanup and reset to protocols[0] */
if (wsi->protocol != &wsi->vhost->protocols[0])
if (!wsi->user_space_externally_allocated)
lws_free_set_NULL(wsi->user_space);
wsi->protocol = &wsi->vhost->protocols[0];
n = wsi->protocol->callback(wsi, LWS_CALLBACK_HTTP,
wsi->user_space, uri_ptr, uri_len);
}
after:
if (n) {
lwsl_info("LWS_CALLBACK_HTTP closing\n");
return 1;
}
#ifdef LWS_WITH_CGI
deal_body:
#endif
/*
* If we're not issuing a file, check for content_length or
* HTTP keep-alive. No keep-alive header allocation for
* ISSUING_FILE, as this uses HTTP/1.0.
*
* In any case, return 0 and let lws_read decide how to
* proceed based on state
*/
if (wsi->state != LWSS_HTTP_ISSUING_FILE)
/* Prepare to read body if we have a content length: */
if (wsi->u.http.content_length > 0)
wsi->state = LWSS_HTTP_BODY;
return 0;
bail_nuke_ah:
/* we're closing, losing some rx is OK */
wsi->u.hdr.ah->rxpos = wsi->u.hdr.ah->rxlen;
lws_header_table_detach(wsi, 1);
return 1;
}
S3Status listBucketCallback(int isTruncated, const char *nextMarker,
int contentsCount,
const S3ListBucketContent *contents,
int commonPrefixesCount,
const char **commonPrefixes,
void *callbackData)
{
list_bucket_callback_data *data =
(list_bucket_callback_data *) callbackData;
data->isTruncated = isTruncated;
// This is tricky. S3 doesn't return the NextMarker if there is no
// delimiter. Why, I don't know, since it's still useful for paging
// through results. We want NextMarker to be the last content in the
// list, so set it to that if necessary.
if ((!nextMarker || !nextMarker[0]) && contentsCount) {
nextMarker = contents[contentsCount - 1].key;
}
if (nextMarker) {
snprintf(data->nextMarker, sizeof(data->nextMarker), "%s",
nextMarker);
}
else {
data->nextMarker[0] = 0;
}
// if (contentsCount && !data->keyCount) {
// printListBucketHeader(data->allDetails);
// }
int i;
for (i = 0; i < contentsCount; i++) {
const S3ListBucketContent *content = &(contents[i]);
char timebuf[256];
time_t t = (time_t) content->lastModified;
strftime(timebuf, sizeof(timebuf), "%Y-%m-%dT%H:%M:%SZ",
gmtime(&t));
char sizebuf[16];
if (content->size < 100000) {
sprintf(sizebuf, "%5llu", (unsigned long long) content->size);
}
else if (content->size < (1024 * 1024)) {
sprintf(sizebuf, "%4lluK",
((unsigned long long) content->size) / 1024ULL);
}
else if (content->size < (10 * 1024 * 1024)) {
float f = content->size;
f /= (1024 * 1024);
sprintf(sizebuf, "%1.2fM", f);
}
else if (content->size < (1024 * 1024 * 1024)) {
sprintf(sizebuf, "%4lluM",
((unsigned long long) content->size) /
(1024ULL * 1024ULL));
}
else {
float f = (content->size / 1024);
f /= (1024 * 1024);
sprintf(sizebuf, "%1.2fG", f);
}
savedContents.append(*content);
savedKeys.append(content->key);
}
data->keyCount += contentsCount;
for (i = 0; i < commonPrefixesCount; i++) {
savedCommonPrefixes.append(commonPrefixes[i]);
}
return S3StatusOK;
}
int escuchaCliente(int socket, struct sockaddr_in addr)
{
char buffer[BUFFERSIZE];
char aux[BUFFERSIZE];
int bytecount;
int fin=0;
int code=0; /* Código de salida por defecto */
time_t t;
struct tm *tmp;
socklen_t slen=sizeof(addr);
while (!fin)
{
memset(buffer, 0, BUFFERSIZE);
if((bytecount=recvfrom(socket,buffer,BUFFERSIZE,0,(struct sockaddr*)&addr,&slen))==-1)
{
error(5, "No puedo recibir información");
}
printf("%s\n",buffer);
/* Evaluamos los comandos */
/* El sistema de gestión de comandos es muy rudimentario, pero nos vale */
/* Comando TIME - Da la hora */
if (strncmp(buffer, "TIME", 4)==0)
{
memset(buffer, 0, BUFFERSIZE);
t = time(NULL);
tmp = localtime(&t);
strftime(buffer, BUFFERSIZE, "%Y-%m-%d %H:%M:%S", tmp);
}
/* Comando EXIT - Cierra la conexión actual */
else if (strncmp(buffer, "EXIT", 4)==0)
{
memset(buffer, 0, BUFFERSIZE);
sprintf(buffer, "Hasta luego. Vuelve pronto %s\n", inet_ntoa(addr.sin_addr));
fin=1;
}
/* Comando CERRAR - Cierra el servidor */
else if (strncmp(buffer, "CERRAR", 6)==0)
{
memset(buffer, 0, BUFFERSIZE);
sprintf(buffer, "Adiós. Cierro el servidor\n");
fin=1;
code=99; /* Salir del programa */
}
else
{
sprintf(aux, "ECHO: %s\n", buffer);
strcpy(buffer, aux);
}
if(bytecount = sendto(socket,buffer,strlen(buffer),0, (struct sockaddr*)&addr, sizeof(addr))==-1){
error(6, "No puedo enviar información");
}
}
close(socket);
return code;
}
static apr_size_t win32_strftime_extra(char *s, size_t max, const char *format,
const struct tm *tm)
{
/* If the new format string is bigger than max, the result string won't fit
* anyway. If format strings are added, made sure the padding below is
* enough */
char *new_format = (char *) malloc(max + 11);
size_t i, j, format_length = strlen(format);
apr_size_t return_value;
int length_written;
for (i = 0, j = 0; (i < format_length && j < max);) {
if (format[i] != '%') {
new_format[j++] = format[i++];
continue;
}
switch (format[i+1]) {
case 'C':
length_written = apr_snprintf(new_format + j, max - j, "%2d",
(tm->tm_year + 1970)/100);
j = (length_written == -1) ? max : (j + length_written);
i += 2;
break;
case 'D':
/* Is this locale dependent? Shouldn't be...
Also note the year 2000 exposure here */
memcpy(new_format + j, "%m/%d/%y", 8);
i += 2;
j += 8;
break;
case 'r':
memcpy(new_format + j, "%I:%M:%S %p", 11);
i += 2;
j += 11;
break;
case 'R':
memcpy(new_format + j, "%H:%M", 5);
i += 2;
j += 5;
break;
case 'T':
memcpy(new_format + j, "%H:%M:%S", 8);
i += 2;
j += 8;
break;
case 'e':
length_written = apr_snprintf(new_format + j, max - j, "%2d",
tm->tm_mday);
j = (length_written == -1) ? max : (j + length_written);
i += 2;
break;
default:
/* We know we can advance two characters forward here. Also
* makes sure that %% is preserved. */
new_format[j++] = format[i++];
new_format[j++] = format[i++];
}
}
if (j >= max) {
*s = '\0'; /* Defensive programming, okay since output is undefined*/
return_value = 0;
} else {
new_format[j] = '\0';
return_value = strftime(s, max, new_format, tm);
}
free(new_format);
return return_value;
}
