int file_validate_buffer(char *buf, unsigned int len, size_t offset)
{
unsigned int checksum;
unsigned int cs_offset;
cs_offset = len - (FILE_CHECKSUM_LENGTH + FILE_OFFSET_LENGTH);
checksum = (unsigned int)crc32(0, buf, cs_offset);
if (checksum != *(unsigned int *)(buf + cs_offset))
{
log_text(LOG_FATAL, "Checksum mismatch in block: ", offset);
log_text(LOG_FATAL, " Calculated value: 0x%x Stored value: 0x%x",
checksum, *(unsigned int *)(buf + cs_offset));
return 1;
}
if (offset != *(size_t *)(buf + cs_offset + FILE_CHECKSUM_LENGTH))
{
log_text(LOG_FATAL, "Offset mismatch in block:");
log_text(LOG_FATAL, " Actual offset: %ld Stored offset: %ld",
offset, *(size_t *)(buf + cs_offset + FILE_CHECKSUM_LENGTH));
return 1;
}
return 0;
}
int file_wait(int thread_id, long nreq)
{
long i;
long nr;
struct io_event *event;
sb_aio_oper_t *oper;
struct iocb *iocbp;
/* Try to read some events */
#ifdef HAVE_OLD_GETEVENTS
(void)nreq; /* unused */
nr = io_getevents(aio_ctxts[thread_id].io_ctxt, file_async_backlog,
aio_ctxts[thread_id].events, NULL);
#else
nr = io_getevents(aio_ctxts[thread_id].io_ctxt, nreq, file_async_backlog,
aio_ctxts[thread_id].events, NULL);
#endif
if (nr < 1)
{
log_errno(LOG_FATAL, "io_getevents() failed!");
return 1;
}
/* Verify results */
for (i = 0; i < nr; i++)
{
event = (struct io_event *)aio_ctxts[thread_id].events + i;
iocbp = (struct iocb *)(unsigned long)event->obj;
oper = (sb_aio_oper_t *)iocbp;
switch (oper->type) {
case FILE_OP_TYPE_FSYNC:
if (event->res != 0)
{
log_text(LOG_FATAL, "Asynchronous fsync failed!\n");
return 1;
}
break;
case FILE_OP_TYPE_READ:
if ((ssize_t)event->res != oper->len)
{
log_text(LOG_FATAL, "Asynchronous read failed!\n");
return 1;
}
break;
case FILE_OP_TYPE_WRITE:
if ((ssize_t)event->res != oper->len)
{
log_text(LOG_FATAL, "Asynchronous write failed!\n");
return 1;
}
break;
default:
break;
}
free(oper);
aio_ctxts[thread_id].nrequests--;
}
return 0;
}
static void dump_config_string(
PConfigRef config)
{
struct endpoint_data *endpoint_data;
endpoint_data= get_current_endpoint_data();
if (endpoint_data && endpoint_data->endpoint)
{
NMErr err;
char default_config_string[1024];
/* Echo the default config string. */
err= ProtocolGetConfigString(config, default_config_string, sizeof(default_config_string));
if (!err)
{
short function_length;
log_text("Created endpoint has configuration: **%s**", default_config_string);
err= ProtocolGetConfigStringLen(config, &function_length);
if (!err)
{
log_text("Actual Length: %d", strlen(default_config_string));
log_text("ProtocolGetConfigStringLen: %d",function_length);
} else {
log_text("Err: %d in ProtocolGetConfigStringLen", err);
}
} else {
log_text("Err %d on ProtocolGetConfigString", err);
}
}
return;
}
unsigned long long sb_timer_split_tmc(sb_timer_t *t)
{
struct timespec tmp;
unsigned long long res;
switch (t->state) {
case TIMER_INITIALIZED:
log_text(LOG_WARNING, "timer was never started");
return 0;
case TIMER_STOPPED:
res = TIMESPEC_DIFF(t->time_end, t->time_split);
t->time_split = t->time_end;
if (res)
return res;
else
{
log_text(LOG_WARNING, "timer was already stopped");
return 0;
}
case TIMER_RUNNING:
break;
default:
log_text(LOG_FATAL, "uninitialized timer queried");
abort();
}
SB_GETTIME(&tmp);
t->elapsed = TIMESPEC_DIFF(tmp, t->time_start);
res = TIMESPEC_DIFF(tmp, t->time_split);
return res;
}
void sb_timer_stop(sb_timer_t *t)
{
switch (t->state) {
case TIMER_INITIALIZED:
log_text(LOG_WARNING, "timer was never started");
break;
case TIMER_STOPPED:
log_text(LOG_WARNING, "timer was already stopped");
break;
case TIMER_RUNNING:
break;
default:
log_text(LOG_FATAL, "uninitialized timer stopped");
abort();
}
sb_timer_update(t);
t->events++;
t->sum_time += t->elapsed;
if (t->elapsed < t->min_time)
t->min_time = t->elapsed;
if (t->elapsed > t->max_time)
t->max_time = t->elapsed;
t->state = TIMER_STOPPED;
}
static int sql_init(dbref player) {
MYSQL *result;
/* If we are already connected, drop and retry the connection, in
* case for some reason the server went away.
*/
if (mysql_struct)
sql_shutdown(player);
/* Try to connect to the database host. If we have specified
* localhost, use the Unix domain socket instead.
*/
mysql_init(mysql_struct);
result = mysql_real_connect(mysql_struct, DB_HOST, DB_USER, DB_PASS, DB_BASE,
3306, DB_SOCKET, 0);
if (!result) {
STARTLOG(LOG_PROBLEMS, "SQL", "ERR");
log_text(unsafe_tprintf("DB connect by %s : ", player < 0 ? "SYSTEM" : Name(player)));
log_text("Failed to connect to SQL database.");
ENDLOG
return -1;
} else {
int mysql_drv_prepare(db_stmt_t *stmt, const char *query)
{
#ifdef HAVE_PS
MYSQL *con = (MYSQL *)stmt->connection->ptr;
MYSQL_STMT *mystmt;
unsigned int rc;
if (con == NULL)
return 1;
if (use_ps)
{
mystmt = mysql_stmt_init(con);
DEBUG("mysql_stmt_init(%p) = %p", con, mystmt);
if (mystmt == NULL)
{
log_text(LOG_FATAL, "mysql_stmt_init() failed");
return 1;
}
stmt->ptr = (void *)mystmt;
DEBUG("mysql_stmt_prepare(%p, \"%s\", %d) = %p", mystmt, query, strlen(query), stmt->ptr);
if (mysql_stmt_prepare(mystmt, query, strlen(query)))
{
/* Check if this statement in not supported */
rc = mysql_errno(con);
DEBUG("mysql_errno(%p) = %u", con, rc);
if (rc == ER_UNSUPPORTED_PS)
{
log_text(LOG_DEBUG,
"Failed to prepare query \"%s\", using emulation",
query);
goto emulate;
}
else
{
log_text(LOG_FATAL, "mysql_stmt_prepare() failed");
log_text(LOG_FATAL, "MySQL error: %d \"%s\"", rc,
mysql_error(con));
DEBUG("mysql_stmt_close(%p)", mystmt);
mysql_stmt_close(mystmt);
return 1;
}
}
return 0;
}
emulate:
#endif /* HAVE_PS */
/* Use client-side PS */
stmt->emulated = 1;
stmt->query = strdup(query);
return 0;
}
static void time_greyscale(void)
{
char str[32]; /* text buffer */
long time_start; /* start tickcount */
long time_end; /* end tickcount */
long time_1, time_2;
int frames_1, frames_2;
int fps, load;
gbuf = (unsigned char *) rb->plugin_get_buffer(&gbuf_size);
if (!grey_init(gbuf, gbuf_size, GREY_ON_COP,
LCD_WIDTH, LCD_HEIGHT, NULL))
{
log_text("greylib: out of memory.");
return;
}
make_grey_rect(LCD_WIDTH, LCD_HEIGHT);
/* Test 1 - greyscale overlay not yet enabled */
frames_1 = 0;
rb->sleep(0); /* sync to tick */
time_start = *rb->current_tick;
while((time_end = *rb->current_tick) - time_start < DURATION)
{
grey_ub_gray_bitmap(greydata[0], 0, 0, LCD_WIDTH, LCD_HEIGHT);
frames_1++;
}
time_1 = time_end - time_start;
/* Test 2 - greyscale overlay enabled */
grey_show(true);
frames_2 = 0;
rb->sleep(0); /* sync to tick */
time_start = *rb->current_tick;
while((time_end = *rb->current_tick) - time_start < DURATION)
{
grey_ub_gray_bitmap(greydata[0], 0, 0, LCD_WIDTH, LCD_HEIGHT);
frames_2++;
}
time_2 = time_end - time_start;
grey_release();
fps = calc_tenth_fps(frames_2, time_2);
load = 100 - (100 * frames_2 * time_1) / (frames_1 * time_2);
rb->snprintf(str, sizeof(str), "1/1: %d.%d fps", fps / 10, fps % 10);
log_text(str);
if (load > 0 && load < 100)
{
rb->snprintf(str, sizeof(str), "CPU load: %d%%", load);
log_text(str);
}
else
log_text("CPU load err (boost?)");
}
int mysql_drv_init(void)
{
char *s;
args.hosts = sb_get_value_list("mysql-host");
if (SB_LIST_IS_EMPTY(args.hosts))
{
log_text(LOG_FATAL, "No MySQL hosts specified, aborting");
return 1;
}
hosts_pos = args.hosts;
pthread_mutex_init(&hosts_mutex, NULL);
args.port = sb_get_value_int("mysql-port");
args.socket = sb_get_value_string("mysql-socket");
args.user = sb_get_value_string("mysql-user");
args.password = sb_get_value_string("mysql-password");
args.db = sb_get_value_string("mysql-db");
args.myisam_max_rows = sb_get_value_int("myisam-max-rows");
args.use_ssl = sb_get_value_flag("mysql-ssl");
args.create_options = sb_get_value_string("mysql-create-options");
if (args.create_options == NULL)
args.create_options = "";
use_ps = 0;
#ifdef HAVE_PS
mysql_drv_caps.prepared_statements = 1;
if (db_globals.ps_mode != DB_PS_MODE_DISABLE)
use_ps = 1;
#endif
s = sb_get_value_string("mysql-engine-trx");
if (s == NULL)
{
log_text(LOG_FATAL, "--mysql-engine-trx requires an argument");
return 1;
}
if (!strcasecmp(s, "yes"))
args.engine_trx = ENGINE_TRX_YES;
else if (!strcasecmp(s, "no"))
args.engine_trx = ENGINE_TRX_NO;
else if (!strcasecmp(s, "auto"))
args.engine_trx = ENGINE_TRX_AUTO;
else
{
log_text(LOG_FATAL, "Invalid value for mysql-engine-trx: %s", s);
return 1;
}
s = sb_get_value_string("mysql-table-engine");
mysql_library_init(0, NULL, NULL);
return parse_table_engine(s);
}
static char* get_line(const char* prompt, char* buf, int size)
{
#ifdef WIN32
int n,c;
//fflush(stdin);
MSG_OUT("%s", prompt);
for(n = 0; n < size-1; n++)
{
c = getchar();
if(c == EOF)
{
if(n == 0)
return NULL;
break;
}
else if(c=='\n')
{
break;
}
else
{
buf[n] = (char)c;
}
}
buf[n] = 0;
#elif defined(LINUX)
char utf8[1024];
char* sl;
A2UTF8( prompt, utf8, sizeof(utf8));
log_text(utf8);
sl = readline(utf8);
if(strlen(sl) > 0)
add_history(sl);
strncpy(buf, sl, size);
free(sl);
#endif
log_text("%s\n", buf);
return buf;
}
int parse_table_engine(const char *type)
{
/* Determine if the engine supports transactions */
if (args.engine_trx == ENGINE_TRX_AUTO)
{
if (!strcasecmp(type, "myisam") || !strcasecmp(type, "heap") ||
!strcasecmp(type, "maria"))
mysql_drv_caps.transactions = 0;
else if (!strcasecmp(type, "innodb") ||
!strcasecmp(type, "bdb") || !strcasecmp(type, "berkeleydb") ||
!strcasecmp(type, "ndbcluster") ||
!strcasecmp(type, "federated") ||
!strcasecmp(type, "pbxt") ||
!strcasecmp(type, "falcon"))
mysql_drv_caps.transactions = 1;
else
{
log_text(LOG_FATAL, "Failed to determine transactions support for "
"unknown storage engine '%s'", type);
log_text(LOG_FATAL, "Specify explicitly with --mysql-engine-trx option");
return 1;
}
}
else
mysql_drv_caps.transactions = (args.engine_trx == ENGINE_TRX_YES);
/* Get engine-specific options string */
if (!strcasecmp(type, "myisam"))
{
if (args.myisam_max_rows > 0)
snprintf(table_options_str, sizeof(table_options_str),
"%s /*! "ENGINE_CLAUSE"=MyISAM MAX_ROWS=%u */",
args.create_options,
args.myisam_max_rows);
else
snprintf(table_options_str, sizeof(table_options_str),
"%s /*! "ENGINE_CLAUSE"=MyISAM */", args.create_options);
}
else if (!strcasecmp(type, "bdb") || !strcasecmp(type, "berkeleydb"))
snprintf(table_options_str, sizeof(table_options_str),
"%s /*! "ENGINE_CLAUSE"=BerkeleyDB */", args.create_options);
else if (!strcasecmp(type, "ndbcluster"))
snprintf(table_options_str, sizeof(table_options_str),
"%s /*! "ENGINE_CLAUSE"=NDB */", args.create_options);
else
snprintf(table_options_str, sizeof(table_options_str),
"%s /*! "ENGINE_CLAUSE"=%s */", args.create_options, type);
mysql_drv_caps.table_options_str = table_options_str;
return 0;
}
void memory_print_stats(void)
{
double total_time;
total_time = NS2SEC(sb_timer_value(&sb_globals.exec_timer));
log_text(LOG_NOTICE, "Operations performed: %d (%8.2f ops/sec)\n", total_ops,
total_ops / total_time);
if (memory_oper != SB_MEM_OP_NONE)
log_text(LOG_NOTICE, "%4.2f MB transferred (%4.2f MB/sec)\n",
(double)total_bytes / (1024 * 1024),
(double)total_bytes / (1024 * 1024) / total_time);
}
int create_files(void)
{
unsigned int i;
int fd;
char file_name[512];
long long offset;
log_text(LOG_INFO, "%d files, %ldKb each, %ldMb total", num_files,
(long)(file_size / 1024),
(long)((file_size * num_files) / (1024 * 1024)));
log_text(LOG_INFO, "Creating files for the test...");
for (i=0; i < num_files; i++) {
snprintf(file_name, sizeof(file_name), "test_file.%d",i);
unlink(file_name);
fd = open(file_name, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
if (fd < 0)
{
log_errno(LOG_FATAL, "Can't open file");
return 1;
}
for (offset = 0; offset < file_size; offset += file_block_size)
{
/* If in validation mode, fill buffer with random values
and write checksum
*/
if (sb_globals.validate)
file_fill_buffer(buffer, file_block_size, offset);
if (write(fd, buffer, file_block_size) < 0)
goto error;
}
/* fsync files to prevent cache flush from affecting test results */
#ifndef _WIN32
fsync(fd);
#else
_commit(fd);
#endif
close(fd);
}
return 0;
error:
log_errno(LOG_FATAL, "Failed to write file!");
close(fd);
return 1;
}
static void time_main_yuv(void)
{
char str[32]; /* text buffer */
long time_start; /* start tickcount */
long time_end; /* end tickcount */
int frame_count;
int fps;
const int part14_x = YUV_WIDTH/4; /* x-offset for 1/4 update test */
const int part14_w = YUV_WIDTH/2; /* x-size for 1/4 update test */
const int part14_y = YUV_HEIGHT/4; /* y-offset for 1/4 update test */
const int part14_h = YUV_HEIGHT/2; /* y-size for 1/4 update test */
log_text("Main LCD YUV");
rb->memset(ydata, 128, sizeof(ydata)); /* medium grey */
/* Test 1: full LCD update */
make_gradient_rect(YUV_WIDTH, YUV_HEIGHT);
frame_count = 0;
rb->sleep(0); /* sync to tick */
time_start = *rb->current_tick;
while((time_end = *rb->current_tick) - time_start < DURATION)
{
rb->lcd_blit_yuv(yuvbuf, 0, 0, YUV_WIDTH,
0, 0, YUV_WIDTH, YUV_HEIGHT);
frame_count++;
}
fps = calc_tenth_fps(frame_count, time_end - time_start);
rb->snprintf(str, sizeof(str), "1/1: %d.%d fps", fps / 10, fps % 10);
log_text(str);
/* Test 2: quarter LCD update */
make_gradient_rect(YUV_WIDTH/2, YUV_HEIGHT/2);
frame_count = 0;
rb->sleep(0); /* sync to tick */
time_start = *rb->current_tick;
while((time_end = *rb->current_tick) - time_start < DURATION)
{
rb->lcd_blit_yuv(yuvbuf, 0, 0, YUV_WIDTH,
part14_x, part14_y, part14_w, part14_h);
frame_count++;
}
fps = calc_tenth_fps(frame_count, time_end - time_start);
rb->snprintf(str, sizeof(str), "1/4: %d.%d fps", fps / 10, fps % 10);
log_text(str);
}
void *sb_memalign(size_t size)
{
unsigned long page_size;
void *buffer;
#ifdef HAVE_POSIX_MEMALIGN
page_size = sb_getpagesize();
posix_memalign((void **)&buffer, page_size, size);
#elif defined(HAVE_MEMALIGN)
page_size = sb_getpagesize();
buffer = memalign(page_size, size);
#elif defined(HAVE_VALLOC)
(void)page_size; /* unused */
buffer = valloc(size);
#elif defined (_WIN32)
(void)page_size; /* unused */
buffer = VirtualAlloc(NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
#else
(void)page_size; /* unused */
log_text(LOG_WARNING, "None of valloc(), memalign and posix_memalign() is available, doing unaligned IO!");
buffer = malloc(size);
#endif
return buffer;
}
bool GLShader::ValidateCompile(GLuint shader)
{
GLint compiled;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled) {
GLsizei length;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
/*output shader log info*/
GLchar* log = new GLchar[length + 1];
glGetShaderInfoLog(shader, length, &length, log);
#ifdef UNICODE
std::string log_text(log);
UConverter converter;
UString log_string = converter.from_bytes(log_text);
DebugPrintF(log_string.c_str());
std::cout << log << std::endl;
#else
DebugPrintF(VTEXT("Shader Log: %s\n"),
log);
#endif
delete[] log;
return false;
}
return true;
}
void log_text(const char* fmt, ...)
{
static char path [MAX_PATH];
static int init = 0;
static int sz;
FILE* f;
va_list vl;
if(init == 0)
{
time_t t = time(NULL);
get_app_path(path, sizeof(path));
sz = strlen(path);
sz+=snprintf(path+sz, sizeof(path)-sz, "/../log");
mkdir(path, 0755);
struct tm* lt = localtime(&t);
sz+=snprintf(path+sz, sizeof(path)-sz, "/logic_%04d%02d%02d_%02d%02d%02d.log",
lt->tm_year+1900,lt->tm_mon+1, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec);
init = 1;
log_text("=========================== LOG START ======================\n%s", ctime(&t));
}
f = fopen(path, "a+");
if(f)
{
va_start(vl, fmt);
vfprintf(f, fmt, vl);
va_end(vl);
fclose(f);
}
}
static void voice_handle_touchtone_dle(int byte)
{
switch (byte)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '*':
case '#':
case 'A':
case 'B':
case 'C':
case 'D':
voice_handle_touchtone(byte);
break;
default:
log_line(L_ERROR, "Illeagal \"<DLE>\" shielded code \"");
log_char(L_ERROR, byte);
log_text(L_ERROR, "\" (ignored)...\n");
break;
}
}
int file_submit_or_wait(struct iocb *iocb, sb_file_op_t type, ssize_t len,
int thread_id)
{
sb_aio_oper_t *oper;
struct iocb *iocbp;
oper = (sb_aio_oper_t *)malloc(sizeof(sb_aio_oper_t));
if (oper == NULL)
{
log_text(LOG_FATAL, "Failed to allocate AIO operation!");
return 1;
}
memcpy(&oper->iocb, iocb, sizeof(*iocb));
oper->type = type;
oper->len = len;
iocbp = &oper->iocb;
if (io_submit(aio_ctxts[thread_id].io_ctxt, 1, &iocbp) < 1)
{
log_errno(LOG_FATAL, "io_submit() failed!");
return 1;
}
aio_ctxts[thread_id].nrequests++;
if (aio_ctxts[thread_id].nrequests < file_async_backlog)
return 0;
return file_wait(thread_id, 1);
}
void cmd_output(const char* fmt, ...)
{
char text[4096];
char utf8[4096*2];
va_list vl;
size_t sz;
va_start(vl, fmt);
sz = vsnprintf(text, sizeof(text), fmt, vl);
va_end(vl);
if(is_test_mode() && s_test_input == 0)
{
if(sz + s_out_len >= sizeof(s_out_messages))
{
sz = sizeof(s_out_messages)/sizeof(s_out_messages[0]) - s_out_len - 1;
}
memcpy(s_out_messages + s_out_len, text, sz);
s_out_len += sz;
s_out_messages[s_out_len] = 0;
}
A2UTF8(text, utf8, sizeof(utf8));
log_text("%s", utf8);
printf("%s", utf8);
}
void hs_log(char *str)
{
time_t tt;
struct tm *ttm;
char timebuf[256];
char tbuf[512];
#ifdef TM3
char *text, *newstr;
/* We make a lot of modifications in this one function, so we don't have
* to change all of the hs_log calls. Otherwise, future mainline patches
* would be harder to apply.
*/
newstr = strdup(str);
text = strchr(newstr, ':');
if (text) {
*text = '\0';
/* Skip over the colon and space */
text += 2;
STARTLOG(LOG_ALWAYS, "HSPACE", newstr)
log_text(text);
ENDLOG
} else {
void QFExtensionB040SPADMeasurement::connectMeasurementDevice(unsigned int measuremenDevice)
{
if ( measuremenDevice>=getMeasurementDeviceCount()) return;
QFSerialConnection* com=ports.getCOMPort(devices[measuremenDevice].port);
if (!com) return;
QMutex* mutex=ports.getMutex(devices[measuremenDevice].port);
QMutexLocker locker(mutex);
com->open();
if (com->isConnectionOpen()) {
QTime t;
t.start();
// wait CONNECTION_DELAY_MS ms for connection!
while (t.elapsed()<CONNECTION_DELAY_MS) {
QApplication::processEvents();
}
devices[measuremenDevice].infoMessage=devices[measuremenDevice].serial->queryCommand("?");
//qDebug()<<"infoMessage '"<<infoMessage<<"'";
if (!(devices[measuremenDevice].infoMessage.toLower().contains("spadarray controller") && devices[measuremenDevice].infoMessage.toLower().contains("jan krieger"))) {
com->close();
log_error(tr("%1 Could not connect to SPADArray Controller [port=%1 baud=%2]!!!\n").arg(com->get_port().c_str()).arg(com->get_baudrate()));
log_error(tr("%1 reason: received wrong ID string from SPADArray Controller: string was '%2'\n").arg(LOG_PREFIX).arg(devices[measuremenDevice].infoMessage));
} else {
log_text(tr("%1 Connected to SPADArray Controller [port=%2 baud=%3] \n%1 welcome message:'%4'\n").arg(LOG_PREFIX).arg(com->get_port().c_str()).arg(com->get_baudrate()).arg(devices[measuremenDevice].infoMessage));
}
} else {
log_error(tr("%1 Could not connect to SPADArray Controller [port=%1 baud=%2]!!!\n").arg(com->get_port().c_str()).arg(com->get_baudrate()));
log_error(tr("%1 reason: %2\n").arg(LOG_PREFIX).arg(devices[measuremenDevice].serial->getLastError()));
}
}
static void MainL()
{
log_clear(PRIMARY_LOG_FILENAME);
log_text(PRIMARY_LOG_FILENAME, "initializing");
logg("value is %d", 555);
log_ctx(PRIMARY_LOG_FILENAME, "context test");
// Note that if our program does not run for at least five seconds
// or so, the S60 auto launch mechanism will consider that an error,
// and this may result in some error dialog popping up. We use
// WaitWhile() to avoid that sort of thing where an intrusive error
// report is not called for. Calling WaitWhile will hopefully also
// ensure that the system is somewhat up and running even right after
// boot, so that there are no problems with querying the installed
// apps information or anything like that.
WaitWhile();
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
TBool magicFileExists = MagicFileExists(fs);
if (!magicFileExists) {
TBool isAppInstalled = IsAppInstalledL();
if (isAppInstalled) {
MainLoopL();
} else {
logt("program to launch not installed");
}
} else {
logt("magic file exists");
}
CleanupStack::PopAndDestroy(); // fs
}
int attachsql_drv_fetch_row(db_result_set_t *rs, db_row_t *row)
{
attachsql_error_t *error= NULL;
attachsql_return_t aret= ATTACHSQL_RETURN_NONE;
/* NYI */
attachsql_connect_t *con = rs->connection->ptr;
while((aret != ATTACHSQL_RETURN_EOF) && (aret != ATTACHSQL_RETURN_ROW_READY))
{
aret= attachsql_connect_poll(con, &error);
if (error)
{
log_text(LOG_ALERT, "libAttachSQL Query Failed: %u:%s", attachsql_error_code(error), attachsql_error_message(error));
attachsql_error_free(error);
return 1;
}
}
if (aret == ATTACHSQL_RETURN_EOF)
{
return 1;
}
row->ptr= attachsql_query_row_get(con, NULL);
attachsql_query_row_next(con);
return 0;
}
int file_async_init(void)
{
unsigned int i;
if (file_io_mode != FILE_IO_MODE_ASYNC)
return 0;
file_async_backlog = sb_get_value_int("file-async-backlog");
if (file_async_backlog <= 0) {
log_text(LOG_FATAL, "Invalid value of file-async-backlog: %d",
file_async_backlog);
return 1;
}
aio_ctxts = (sb_aio_context_t *)calloc(sb_globals.num_threads,
sizeof(sb_aio_context_t));
for (i = 0; i < sb_globals.num_threads; i++)
{
if (io_queue_init(file_async_backlog, &aio_ctxts[i].io_ctxt))
{
log_errno(LOG_FATAL, "io_queue_init() failed!");
return 1;
}
aio_ctxts[i].events = (struct io_event *)malloc(file_async_backlog *
sizeof(struct io_event));
if (aio_ctxts[i].events == NULL)
{
log_errno(LOG_FATAL, "Failed to allocate async I/O context!");
return 1;
}
}
return 0;
}
/* plugin entry point */
enum plugin_status plugin_start(const void* parameter)
{
#ifndef SIMULATOR
char str[32];
int cpu_freq;
#endif
/* standard stuff */
PLUGIN_IRAM_INIT(rb)
(void)parameter;
log_init();
#ifndef SIMULATOR
cpu_freq = *rb->cpu_frequency; /* remember CPU frequency */
#endif
backlight_force_on(); /* backlight control in lib/helper.c */
log_text("Main LCD Update");
time_main_update();
#if defined(HAVE_LCD_COLOR) && (MEMORYSIZE > 2)
log_text("Main LCD YUV");
time_main_yuv();
#endif
#if LCD_DEPTH < 4
log_text("Greyscale library");
time_greyscale();
#endif
#ifdef HAVE_REMOTE_LCD
log_text("Remote LCD Update");
time_remote_update();
#endif
#ifndef SIMULATOR
if (*rb->cpu_frequency != cpu_freq)
rb->snprintf(str, sizeof(str), "CPU clock changed!");
else
rb->snprintf(str, sizeof(str), "CPU: %d MHz",
(cpu_freq + 500000) / 1000000);
log_text(str);
#endif
backlight_use_settings(); /* backlight control in lib/helper.c */
/* wait until user closes plugin */
while (rb->button_get(true) != FPS_QUIT);
return PLUGIN_OK;
}
/* check if pidfile exists, check if the process is running, save pid */
void save_pid(int pid) {
int n;
FILE *file;
struct stat stat_buf;
/* if pidfile exists, check if the process is running */
if(stat(pidfile, &stat_buf) == 0) {
file = fopen(pidfile, "r");
if(!file) {
log_text(err, "'%s' already exists, but can not be read. "
"Execution shall continue, but with no logging of the pid (%d).",
pidfile, pid);
pidfile = NULL;
fclose(file);
return;
} else {
fscanf(file, "%d", &n);
fclose(file);
if(kill(n, 0) == -1) {
log_text(err, "'%s' already exists, but no process with pid %d is "
"running. Perhaps serve crashed or was forcibly killed. "
"Execution shall continue, but with no logging of the pid "
"(%d).",
pidfile, n, pid);
} else {
log_text(err, "'%s' already exists, and a process with pid %d is "
"running. Execution shall not continue.", pidfile, n);
pidfile = NULL;
exit(1);
}
}
}
/* now write the pid */
file = fopen(pidfile, "w");
if(file) {
fprintf(file, "%d\n", pid);
fclose(file);
log_text(err, "Wrote pid %d to '%s'.", pid, pidfile);
} else {
log_text(err, "Unable to open '%s' for writing. Execution shall continue, "
"but with no logging of the pid (%d).", pidfile, pid);
pidfile = NULL;
}
}
void sb_timer_start(sb_timer_t *t)
{
switch (t->state) {
case TIMER_INITIALIZED:
case TIMER_STOPPED:
break;
case TIMER_RUNNING:
log_text(LOG_WARNING, "timer was already started");
break;
default:
log_text(LOG_FATAL, "uninitialized timer started");
abort();
}
SB_GETTIME(&t->time_start);
t->time_split = t->time_start;
t->state = TIMER_RUNNING;
}
unsigned long long sb_timer_value(sb_timer_t *t)
{
switch (t->state) {
case TIMER_INITIALIZED:
log_text(LOG_WARNING, "timer was never started");
return 0;
case TIMER_STOPPED:
return t->elapsed;
case TIMER_RUNNING:
break;
default:
log_text(LOG_FATAL, "uninitialized timer queried");
abort();
}
sb_timer_update(t);
return t->elapsed;
}
void NDECL(init_version)
{
#ifdef BETA
#define INDEVEL_TAG "Beta"
#endif
#ifdef ALPHA
#define INDEVEL_TAG "Alpha"
#endif
#ifdef INDEVEL_TAG
#if PATCHLEVEL > 0
sprintf(mudstate.version, "RhostMUSH %s version %.30s%.10s patchlevel %d%s #%.10s",
INDEVEL_TAG, MUSH_VERSION, EXT_MUSH_VER, PATCHLEVEL, PATCHLEVELEXT, MUSH_BUILD_NUM);
sprintf(mudstate.short_ver, "RhostMUSH %s %.30s%.10s.p%d%s",
INDEVEL_TAG, MUSH_VERSION, EXT_MUSH_VER, PATCHLEVEL, PATCHLEVELEXT);
#else
sprintf(mudstate.version, "RhostMUSH %s version %.30s%.10s #%.10s",
INDEVEL_TAG, MUSH_VERSION, EXT_MUSH_VER, MUSH_BUILD_NUM);
sprintf(mudstate.short_ver, "RhostMUSH %s %.30s%.10s", INDEVEL_TAG,
MUSH_VERSION, EXT_MUSH_VER);
#endif /* PATCHLEVEL */
#else /* not BETA or ALPHA */
#if PATCHLEVEL > 0
sprintf(mudstate.version, "RhostMUSH version %.30s%.10s patchlevel %d%s #%.10s [%.30s]",
MUSH_VERSION, EXT_MUSH_VER, PATCHLEVEL, PATCHLEVELEXT, MUSH_BUILD_NUM, MUSH_RELEASE_DATE);
sprintf(mudstate.short_ver, "RhostMUSH %.30s%.10s.p%d%s",
MUSH_VERSION, EXT_MUSH_VER, PATCHLEVEL, PATCHLEVELEXT);
#else
sprintf(mudstate.version, "RhostMUSH version %.30s%.10s #%.10s [%.30s]",
MUSH_VERSION, EXT_MUSH_VER, MUSH_BUILD_NUM, MUSH_RELEASE_DATE);
sprintf(mudstate.short_ver, "RhostMUSH %.30s%.10s",
MUSH_VERSION, EXT_MUSH_VER);
#endif /* PATCHLEVEL */
#endif /* BETA */
STARTLOG(LOG_ALWAYS,"INI","START")
log_text((char *)"Starting: ");
log_text(mudstate.version);
ENDLOG
STARTLOG(LOG_ALWAYS,"INI","START")
log_text((char *)"Build date: ");
log_text((char *)MUSH_BUILD_DATE);
ENDLOG
}
