/**
* Complete interrupt transfer
*
* @v ep USB endpoint
* @v iobuf I/O buffer
* @v rc Completion status code
*/
static void acm_intr_complete ( struct usb_endpoint *ep,
struct io_buffer *iobuf, int rc ) {
struct acm_device *acm = container_of ( ep, struct acm_device,
usbnet.intr );
struct rndis_device *rndis = acm->rndis;
struct usb_setup_packet *message;
/* Profile completions */
profile_start ( &acm_intr_profiler );
/* Ignore packets cancelled when the endpoint closes */
if ( ! ep->open )
goto ignore;
/* Drop packets with errors */
if ( rc != 0 ) {
DBGC ( acm, "ACM %p interrupt failed: %s\n",
acm, strerror ( rc ) );
DBGC_HDA ( acm, 0, iobuf->data, iob_len ( iobuf ) );
goto error;
}
/* Extract message header */
if ( iob_len ( iobuf ) < sizeof ( *message ) ) {
DBGC ( acm, "ACM %p underlength interrupt:\n", acm );
DBGC_HDA ( acm, 0, iobuf->data, iob_len ( iobuf ) );
rc = -EINVAL;
goto error;
}
message = iobuf->data;
/* Parse message header */
switch ( message->request ) {
case cpu_to_le16 ( CDC_RESPONSE_AVAILABLE ) :
case cpu_to_le16 ( 0x0001 ) : /* qemu seems to use this value */
acm->responded = 1;
break;
default:
DBGC ( acm, "ACM %p unrecognised interrupt:\n", acm );
DBGC_HDA ( acm, 0, iobuf->data, iob_len ( iobuf ) );
rc = -ENOTSUP;
goto error;
}
/* Free I/O buffer */
free_iob ( iobuf );
profile_stop ( &acm_intr_profiler );
return;
error:
rndis_rx_err ( rndis, iob_disown ( iobuf ), rc );
ignore:
free_iob ( iobuf );
return;
}
/**
* Complete bulk IN transfer
*
* @v ep USB endpoint
* @v iobuf I/O buffer
* @v rc Completion status code
*/
static void smsc95xx_in_complete ( struct usb_endpoint *ep,
struct io_buffer *iobuf, int rc ) {
struct smsc95xx_device *smsc95xx =
container_of ( ep, struct smsc95xx_device, usbnet.in );
struct net_device *netdev = smsc95xx->netdev;
struct smsc95xx_rx_header *header;
/* Profile completions */
profile_start ( &smsc95xx_in_profiler );
/* Ignore packets cancelled when the endpoint closes */
if ( ! ep->open ) {
free_iob ( iobuf );
return;
}
/* Record USB errors against the network device */
if ( rc != 0 ) {
DBGC ( smsc95xx, "SMSC95XX %p bulk IN failed: %s\n",
smsc95xx, strerror ( rc ) );
goto err;
}
/* Sanity check */
if ( iob_len ( iobuf ) < ( sizeof ( *header ) + 4 /* CRC */ ) ) {
DBGC ( smsc95xx, "SMSC95XX %p underlength bulk IN\n",
smsc95xx );
DBGC_HDA ( smsc95xx, 0, iobuf->data, iob_len ( iobuf ) );
rc = -EINVAL;
goto err;
}
/* Strip header and CRC */
header = iobuf->data;
iob_pull ( iobuf, sizeof ( *header ) );
iob_unput ( iobuf, 4 /* CRC */ );
/* Check for errors */
if ( header->command & cpu_to_le32 ( SMSC95XX_RX_RUNT |
SMSC95XX_RX_LATE |
SMSC95XX_RX_CRC ) ) {
DBGC ( smsc95xx, "SMSC95XX %p receive error (%08x):\n",
smsc95xx, le32_to_cpu ( header->command ) );
DBGC_HDA ( smsc95xx, 0, iobuf->data, iob_len ( iobuf ) );
rc = -EIO;
goto err;
}
/* Hand off to network stack */
netdev_rx ( netdev, iob_disown ( iobuf ) );
profile_stop ( &smsc95xx_in_profiler );
return;
err:
/* Hand off to network stack */
netdev_rx_err ( netdev, iob_disown ( iobuf ), rc );
}
void prof_draws(TProfiler *prof, const char *str)
{
tte_set_pos(0, 0);
tte_write(prof->str);
tte_write(": \n");
VBlankIntrWait();
profile_start();
tte_write(str);
prof->time= profile_stop();
}
/**
* Transmit packet
*
* @v acm USB RNDIS device
* @v iobuf I/O buffer
* @ret rc Return status code
*/
static int acm_out_transmit ( struct acm_device *acm,
struct io_buffer *iobuf ) {
int rc;
/* Profile transmissions */
profile_start ( &acm_out_profiler );
/* Enqueue I/O buffer */
if ( ( rc = usb_stream ( &acm->usbnet.out, iobuf, 0 ) ) != 0 )
return rc;
profile_stop ( &acm_out_profiler );
return 0;
}
/*-------------------------------------------------------------------------*/
static void
optimize(curr_poly_t *c, poly_stage2_t *data,
root_sieve_t *rs, assess_t *assess,
stage2_stat_t *stats)
{
int err;
double skewness;
double pol_norm;
double alpha_proj;
double log_max_norm_2 = log(data->max_norm_2);
profile_start(PROF_ALL);
while (1) {
err = read_a5pd(c, data);
if (err < 0) {
if (feof(data->infile))
break;
continue;
}
if (!pol_expand(c, data->gmp_N)) {
mpz_out_str(stdout, 10, c->gmp_a[5]);
fprintf(stderr, "expand failed\n");
continue;
}
profile_start(PROF_INITIAL_OPTIMIZE);
optimize_1(c, &skewness, &pol_norm, &alpha_proj);
profile_stop(PROF_INITIAL_OPTIMIZE);
if (pol_norm * exp(alpha_proj) > data->max_norm_1)
continue;
root_sieve_run(c, log_max_norm_2, data, rs, assess,
stats, skewness, pol_norm, alpha_proj);
}
profile_stop(PROF_ALL);
}
int main(int argc, char** argv) {
auto& main_prof = make_profiler("main");
profile_start(main_prof);
try {
options opt = parse_cmdline(argc, argv);
switch (opt.m_mode) {
case options::init:
init();
break;
case options::config:
run_config(require_codedb_path(opt), opt);
break;
case options::build:
build(require_codedb_path(opt), opt);
break;
case options::find:
find(require_codedb_path(opt), opt);
break;
case options::serve:
serve(require_codedb_path(opt), opt);
break;
case options::undefined:
std::cout << "cdb: '" << opt.m_args[0]
<< "' is not a cdb-command. See 'cdb --help'.\n";
break;
case options::help:
help(opt);
break;
default:
std::cout << "Not implemented '" << opt.m_args.at(0) << "'\n";
break;
}
}
catch (const regex_error& error) {
std::string desc = error.what();
if (!desc.empty()) desc[0] = std::toupper(desc[0]);
std::cerr << "Error: invalid regex '" << error.m_expr << "'\n " << desc
<< '\n';
}
catch (const std::exception& e) {
std::cerr << "Error: " << e.what() << std::endl;
}
profile_stop(main_prof);
profiler_report();
}
/**
* Read from data transfer buffer
*
* @v xferbuf Data transfer buffer
* @v offset Starting offset
* @v data Data to write
* @v len Length of data
*/
int xferbuf_read ( struct xfer_buffer *xferbuf, size_t offset,
void *data, size_t len ) {
/* Check that read is within buffer range */
if ( ( offset > xferbuf->len ) ||
( len > ( xferbuf->len - offset ) ) )
return -ENOENT;
/* Copy data from buffer */
profile_start ( &xferbuf_read_profiler );
xferbuf->op->read ( xferbuf, offset, data, len );
profile_stop ( &xferbuf_read_profiler );
return 0;
}
/**
* Complete interrupt transfer
*
* @v ep USB endpoint
* @v iobuf I/O buffer
* @v rc Completion status code
*/
static void smsc95xx_intr_complete ( struct usb_endpoint *ep,
struct io_buffer *iobuf, int rc ) {
struct smsc95xx_device *smsc95xx =
container_of ( ep, struct smsc95xx_device, usbnet.intr );
struct net_device *netdev = smsc95xx->netdev;
struct smsc95xx_interrupt *intr;
/* Profile completions */
profile_start ( &smsc95xx_intr_profiler );
/* Ignore packets cancelled when the endpoint closes */
if ( ! ep->open )
goto done;
/* Record USB errors against the network device */
if ( rc != 0 ) {
DBGC ( smsc95xx, "SMSC95XX %p interrupt failed: %s\n",
smsc95xx, strerror ( rc ) );
DBGC_HDA ( smsc95xx, 0, iobuf->data, iob_len ( iobuf ) );
netdev_rx_err ( netdev, NULL, rc );
goto done;
}
/* Extract interrupt data */
if ( iob_len ( iobuf ) != sizeof ( *intr ) ) {
DBGC ( smsc95xx, "SMSC95XX %p malformed interrupt\n",
smsc95xx );
DBGC_HDA ( smsc95xx, 0, iobuf->data, iob_len ( iobuf ) );
netdev_rx_err ( netdev, NULL, rc );
goto done;
}
intr = iobuf->data;
/* Record interrupt status */
smsc95xx->int_sts = le32_to_cpu ( intr->int_sts );
profile_stop ( &smsc95xx_intr_profiler );
done:
/* Free I/O buffer */
free_iob ( iobuf );
}
/**
* Write to data transfer buffer
*
* @v xferbuf Data transfer buffer
* @v offset Starting offset
* @v data Data to write
* @v len Length of data
*/
int xferbuf_write ( struct xfer_buffer *xferbuf, size_t offset,
const void *data, size_t len ) {
size_t max_len;
int rc;
/* Check for overflow */
max_len = ( offset + len );
if ( max_len < offset )
return -EOVERFLOW;
/* Ensure buffer is large enough to contain this write */
if ( ( rc = xferbuf_ensure_size ( xferbuf, max_len ) ) != 0 )
return rc;
/* Copy data to buffer */
profile_start ( &xferbuf_write_profiler );
xferbuf->op->write ( xferbuf, offset, data, len );
profile_stop ( &xferbuf_write_profiler );
return 0;
}
/**
* Test memcpy() speed
*
* @v dest_offset Destination alignment offset
* @v src_offset Source alignment offset
* @v len Length of data to copy
*/
static void memcpy_test_speed ( unsigned int dest_offset,
unsigned int src_offset, size_t len ) {
struct profiler profiler;
uint8_t *dest;
uint8_t *src;
unsigned int i;
/* Allocate blocks */
dest = malloc ( len + dest_offset );
assert ( dest != NULL );
src = malloc ( len + src_offset );
assert ( src != NULL );
/* Generate random source data */
for ( i = 0 ; i < len ; i++ )
src[ src_offset + i ] = random();
/* Check correctness of copied data */
memcpy ( ( dest + dest_offset ), ( src + src_offset ), len );
ok ( memcmp ( ( dest + dest_offset ), ( src + src_offset ),
len ) == 0 );
/* Profile memcpy() */
memset ( &profiler, 0, sizeof ( profiler ) );
for ( i = 0 ; i < PROFILE_COUNT ; i++ ) {
profile_start ( &profiler );
memcpy ( ( dest + dest_offset ), ( src + src_offset ), len );
profile_stop ( &profiler );
}
/* Free blocks */
free ( dest );
free ( src );
DBG ( "MEMCPY copied %zd bytes (+%d => +%d) in %ld +/- %ld ticks\n",
len, src_offset, dest_offset, profile_mean ( &profiler ),
profile_stddev ( &profiler ) );
}
/**
* Transmit packet
*
* @v smsc95xx SMSC95xx device
* @v iobuf I/O buffer
* @ret rc Return status code
*/
static int smsc95xx_out_transmit ( struct smsc95xx_device *smsc95xx,
struct io_buffer *iobuf ) {
struct smsc95xx_tx_header *header;
size_t len = iob_len ( iobuf );
int rc;
/* Profile transmissions */
profile_start ( &smsc95xx_out_profiler );
/* Prepend header */
if ( ( rc = iob_ensure_headroom ( iobuf, sizeof ( *header ) ) ) != 0 )
return rc;
header = iob_push ( iobuf, sizeof ( *header ) );
header->command = cpu_to_le32 ( SMSC95XX_TX_FIRST | SMSC95XX_TX_LAST |
SMSC95XX_TX_LEN ( len ) );
header->len = cpu_to_le32 ( len );
/* Enqueue I/O buffer */
if ( ( rc = usb_stream ( &smsc95xx->usbnet.out, iobuf, 0 ) ) != 0 )
return rc;
profile_stop ( &smsc95xx_out_profiler );
return 0;
}
~profile_scope() { profile_stop(m_p); }
void Logstalgia::logic(float t, float dt) {
float sdt = dt * settings.simulation_speed;
//increment clock
elapsed_time += sdt;
currtime = starttime + (long)(elapsed_time);
if(settings.stop_time && currtime > settings.stop_time) {
currtime = settings.stop_time;
}
if(mousehide_timeout>0.0f) {
mousehide_timeout -= dt;
if(mousehide_timeout<0.0f) {
SDL_ShowCursor(false);
}
}
infowindow.hide();
if(end_reached && balls.empty()) {
appFinished = true;
return;
}
//if paused, dont move anything, only check what is under mouse
if(paused) {
for(auto& it: paddles) {
Paddle* paddle = it.second;
if(paddle->mouseOver(infowindow, mousepos)) {
break;
}
}
for(RequestBall* ball : balls) {
if(ball->mouseOver(infowindow, mousepos)) {
break;
}
}
if(!ipSummarizer->mouseOver(infowindow,mousepos)) {
for(Summarizer* s: summarizers) {
if(s->mouseOver(infowindow, mousepos)) break;
}
}
return;
}
//next will fast forward clock to the time of the next entry,
//if the next entry is in the future
if(next || (!settings.disable_auto_skip && balls.empty())) {
if(!queued_entries.empty()) {
LogEntry* le = queued_entries.front();
long entrytime = le->timestamp;
if(entrytime > currtime) {
elapsed_time = entrytime - starttime;
currtime = starttime + (long)(elapsed_time);
}
}
next = false;
}
//recalc spawn speed each second by
if(currtime != lasttime) {
//dont bother reading the log if we dont need to
if(queued_entries.empty() || queued_entries.back()->timestamp <= currtime) {
readLog();
}
profile_start("determine new entries");
int items_to_spawn=0;
for(LogEntry* le : queued_entries) {
if(le->timestamp > currtime) break;
items_to_spawn++;
addStrings(le);
}
profile_stop();
//debugLog("items to spawn %d\n", items_to_spawn);
if(items_to_spawn > 0) {
profile_start("add new strings");
//re-summarize
ipSummarizer->summarize();
for(Summarizer* s : summarizers) {
s->summarize();
}
profile_stop();
profile_start("add new entries");
float item_offset = 1.0 / (float) (items_to_spawn);
int item_no = 0;
while(!queued_entries.empty()) {
LogEntry* le = queued_entries.front();
if(le->timestamp > currtime) break;
float pos_offset = item_offset * (float) item_no++;
float start_offset = std::min(1.0f, pos_offset);
addBall(le, start_offset);
queued_entries.pop_front();
}
}
//update date
if(total_entries>0) {
char datestr[256];
char timestr[256];
struct tm* timeinfo = localtime ( &currtime );
strftime(datestr, 256, "%A, %B %d, %Y", timeinfo);
strftime(timestr, 256, "%X", timeinfo);
displaydate = datestr;
displaytime = timestr;
} else {
displaydate = "";
displaytime = "";
}
lasttime=currtime;
profile_stop();
} else {
//do small reads per frame if we havent buffered the next second
if(queued_entries.empty() || queued_entries.back()->timestamp <= currtime+1) {
readLog(50);
}
}
std::list<Paddle*> inactivePaddles;
//update paddles
for(auto& it: paddles) {
std::string paddle_token = it.first;
Paddle* paddle = it.second;
if(settings.paddle_mode > PADDLE_SINGLE && !paddle->moving() && !paddle->visible()) {
bool token_match = false;
//are there any requests that will match this paddle?
for(RequestBall* ball : balls) {
if( (settings.paddle_mode == PADDLE_VHOST && ball->le->vhost == paddle_token)
|| (settings.paddle_mode == PADDLE_PID && ball->le->pid == paddle_token)) {
token_match = true;
break;
}
}
//mark this paddle for deletion, continue
if(!token_match) {
inactivePaddles.push_back(paddle);
continue;
}
}
// find nearest ball to this paddle
if( (retarget || !paddle->getTarget())) {
RequestBall* ball = findNearest(paddle, paddle_token);
if(ball != 0) {
paddle->setTarget(ball);
} else if(!paddle->moving()) {
paddle->setTarget(0);
}
}
paddle->logic(sdt);
}
retarget = false;
profile_start("check ball status");
// NOTE: special handling for this iterator as items are being removed
for(auto it = balls.begin(); it != balls.end();) {
RequestBall* ball = *it;
highscore += ball->logic(sdt);
if(ball->isFinished()) {
it = balls.erase(it);
removeBall(ball);
} else {
it++;
}
}
profile_stop();
profile_start("ipSummarizer logic");
ipSummarizer->logic(dt);
profile_stop();
profile_start("updateGroups logic");
updateGroups(dt);
profile_stop();
screen_blank_elapsed += dt;
if(screen_blank_elapsed-screen_blank_interval > screen_blank_period)
screen_blank_elapsed = 0.0f;
//update font alpha
font_alpha = 1.0f;
if(screen_blank_elapsed>screen_blank_interval) {
font_alpha = std::min(1.0f, (float) fabs(1.0f - (screen_blank_elapsed-screen_blank_interval)/(screen_blank_period*0.5)));
font_alpha *= font_alpha;
}
}
void Logstalgia::readLog(int buffer_rows) {
profile_start("readLog");
set_utc_tz();
int entries_read = 0;
std::string linestr;
BaseLog* baselog = getLog();
time_t read_timestamp = 0;
while( baselog->getNextLine(linestr) ) {
//trim whitespace
if(linestr.size()>0) {
size_t string_end =
linestr.find_last_not_of(" \t\f\v\n\r");
if(string_end == std::string::npos) {
linestr = "";
} else if(string_end != linestr.size()-1) {
linestr = linestr.substr(0,string_end+1);
}
}
LogEntry le;
bool parsed_entry;
//determine format
if(accesslog==0) {
//is this a recognized NCSA access log?
NCSALog* ncsalog = new NCSALog();
if((parsed_entry = ncsalog->parseLine(linestr, le))) {
accesslog = ncsalog;
} else {
delete ncsalog;
}
if(accesslog==0) {
//is this a custom log?
CustomAccessLog* customlog = new CustomAccessLog();
if((parsed_entry = customlog->parseLine(linestr, le))) {
accesslog = customlog;
} else {
delete customlog;
}
}
} else {
if(!(parsed_entry = accesslog->parseLine(linestr, le))) {
debugLog("error: could not read line %s\n", linestr.c_str());
}
}
if(parsed_entry) {
if((!mintime || mintime <= le.timestamp) && (!settings.stop_time || settings.stop_time > le.timestamp)) {
queued_entries.push_back(new LogEntry(le));
total_entries++;
entries_read++;
//read at least the buffered row count if specified
//otherwise read all entries with the same time
if(buffer_rows) {
if(entries_read > buffer_rows) break;
} else {
if(read_timestamp && read_timestamp < le.timestamp) break;
}
read_timestamp = le.timestamp;
}
}
}
profile_stop();
unset_utc_tz();
if(queued_entries.empty() && seeklog != 0) {
if(total_entries==0) {
if(mintime != 0) {
logstalgia_quit("could not parse any entries in the specified time period");
} else {
logstalgia_quit("could not parse any entries");
}
}
//no more entries
end_reached = true;
return;
}
if(seeklog != 0) {
float percent = seeklog->getPercent();
if(percent > settings.stop_position) {
end_reached = true;
return;
}
if(!settings.disable_progress) slider.setPercent(percent);
}
//set start time if currently 0
if(starttime==0 && !queued_entries.empty()) {
starttime = queued_entries.front()->timestamp;
currtime = 0;
}
}
void Logstalgia::draw(float t, float dt) {
if(appFinished) return;
if(!settings.disable_progress) slider.logic(dt);
display.setClearColour(background);
display.clear();
glDisable(GL_FOG);
display.mode2D();
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
profile_start("draw ip summarizer");
ipSummarizer->draw(dt, font_alpha);
profile_stop();
profile_start("draw groups");
drawGroups(dt, font_alpha);
profile_stop();
profile_start("draw balls");
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindTexture(GL_TEXTURE_2D, balltex->textureid);
for(RequestBall* ball : balls) {
ball->draw();
}
profile_stop();
profile_start("draw response codes");
for(std::list<RequestBall*>::iterator it = balls.begin(); it != balls.end(); it++) {
RequestBall* r = *it;
if(!settings.hide_response_code && r->hasBounced()) {
r->drawResponseCode();
}
}
profile_stop();
glDisable(GL_TEXTURE_2D);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
if(settings.paddle_mode != PADDLE_NONE) {
//draw paddles shadows
for(auto& it: paddles) {
it.second->drawShadow();
}
//draw paddles
for(auto& it: paddles) {
it.second->draw();
}
}
if(settings.paddle_mode > PADDLE_SINGLE && !settings.hide_paddle_tokens) {
glEnable(GL_TEXTURE_2D);
//draw paddle tokens
for(auto& it: paddles) {
it.second->drawToken();
}
}
if(!settings.disable_glow) {
glBlendFunc (GL_ONE, GL_ONE);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, glowtex->textureid);
for(std::list<RequestBall*>::iterator it = balls.begin(); it != balls.end(); it++) {
(*it)->drawGlow();
}
}
infowindow.draw();
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
if(!take_screenshot && uimessage_timer>0.1f) {
fontLarge.setColour(vec4(1.0f,1.0f,uimessage_timer/3.0f,uimessage_timer/3.0f));
int mwidth = fontLarge.getWidth(uimessage.c_str());
fontLarge.draw(display.width/2 - mwidth/2, display.height/2 - 20, uimessage.c_str());
uimessage_timer-=dt;
}
if(settings.splash > 0.0f) {
int logowidth = fontLarge.getWidth("Logstalgia");
int logoheight = 105;
int cwidth = fontMedium.getWidth("Website Access Log Viewer");
int awidth = fontMedium.getWidth("(C) 2008 Andrew Caudwell");
vec2 corner(display.width/2 - logowidth/2 - 30.0f,
display.height/2 - 45);
float logo_alpha = std::min(1.0f, settings.splash/3.0f);
float logo_bg = std::min(0.2f, settings.splash/10.0f);
glDisable(GL_TEXTURE_2D);
glColor4f(0.0f, 0.5f, 1.0f, logo_bg);
glBegin(GL_QUADS);
glVertex2f(0.0f, corner.y);
glVertex2f(0.0f, corner.y + logoheight);
glVertex2f(display.width, corner.y + logoheight);
glVertex2f(display.width, corner.y);
glEnd();
glEnable(GL_TEXTURE_2D);
fontLarge.alignTop(true);
fontLarge.dropShadow(true);
fontLarge.setColour(vec4(1.0f,1.0f,1.0f,logo_alpha));
fontLarge.draw(display.width/2 - logowidth/2,display.height/2 - 30, "Logstalgia");
fontLarge.setColour(vec4(0.0f,1.0f,1.0f,logo_alpha));
fontLarge.draw(display.width/2 - logowidth/2,display.height/2 - 30, "Log");
fontMedium.setColour(vec4(1.0f,1.0f,1.0f,logo_alpha));
fontMedium.draw(display.width/2 - cwidth/2,display.height/2 + 17, "Website Access Log Viewer");
fontMedium.draw(display.width/2 - awidth/2,display.height/2 + 37, "(C) 2008 Andrew Caudwell");
settings.splash -= dt;
}
fontMedium.setColour(vec4(1.0f,1.0f,1.0f,font_alpha));
if(info) {
fontMedium.print(2,2, "FPS %d", (int) fps);
fontMedium.print(2,19,"Balls: %d", balls.size());
fontMedium.print(2,36,"Queue: %d", queued_entries.size());
fontMedium.print(2,53,"Paddles: %d", paddles.size());
fontMedium.print(2,70,"Simulation Speed: %.2f", settings.simulation_speed);
fontMedium.print(2,87,"Pitch Speed: %.2f", settings.pitch_speed);
} else {
fontMedium.draw(2,2, displaydate.c_str());
fontMedium.draw(2,19, displaytime.c_str());
}
fontLarge.setColour(vec4(1.0f,1.0f,1.0f,font_alpha));
int counter_width = fontLarge.getWidth("00000000");
fontLarge.alignTop(false);
fontLarge.print(display.width-10-counter_width,display.height-10, "%08d", highscore);
if(!settings.disable_progress) slider.draw(dt);
if(take_screenshot) {
takeScreenshot();
take_screenshot = false;
}
}
/* PXENV_UNDI_TRANSMIT
*
* Status: working
*/
static PXENV_EXIT_t
pxenv_undi_transmit ( struct s_PXENV_UNDI_TRANSMIT *undi_transmit ) {
struct s_PXENV_UNDI_TBD tbd;
struct DataBlk *datablk;
struct io_buffer *iobuf;
struct net_protocol *net_protocol;
struct ll_protocol *ll_protocol;
char destaddr[MAX_LL_ADDR_LEN];
const void *ll_dest;
size_t len;
unsigned int i;
int rc;
/* Start profiling */
profile_start ( &undi_tx_profiler );
/* Sanity check */
if ( ! pxe_netdev ) {
DBGC ( &pxe_netdev, "PXENV_UNDI_TRANSMIT called with no "
"network device\n" );
undi_transmit->Status = PXENV_STATUS_UNDI_INVALID_STATE;
return PXENV_EXIT_FAILURE;
}
DBGC2 ( &pxe_netdev, "PXENV_UNDI_TRANSMIT" );
/* Forcibly enable interrupts and freeze receive queue
* processing at this point, to work around callers that never
* call PXENV_UNDI_OPEN before attempting to use the UNDI API.
*/
if ( ! netdev_rx_frozen ( pxe_netdev ) ) {
netdev_rx_freeze ( pxe_netdev );
netdev_irq ( pxe_netdev, 1 );
}
/* Identify network-layer protocol */
switch ( undi_transmit->Protocol ) {
case P_IP: net_protocol = &ipv4_protocol; break;
case P_ARP: net_protocol = &arp_protocol; break;
case P_RARP: net_protocol = &rarp_protocol; break;
case P_UNKNOWN:
net_protocol = NULL;
break;
default:
DBGC2 ( &pxe_netdev, " %02x invalid protocol\n",
undi_transmit->Protocol );
undi_transmit->Status = PXENV_STATUS_UNDI_INVALID_PARAMETER;
return PXENV_EXIT_FAILURE;
}
DBGC2 ( &pxe_netdev, " %s",
( net_protocol ? net_protocol->name : "RAW" ) );
/* Calculate total packet length */
copy_from_real ( &tbd, undi_transmit->TBD.segment,
undi_transmit->TBD.offset, sizeof ( tbd ) );
len = tbd.ImmedLength;
DBGC2 ( &pxe_netdev, " %04x:%04x+%x", tbd.Xmit.segment, tbd.Xmit.offset,
tbd.ImmedLength );
for ( i = 0 ; i < tbd.DataBlkCount ; i++ ) {
datablk = &tbd.DataBlock[i];
len += datablk->TDDataLen;
DBGC2 ( &pxe_netdev, " %04x:%04x+%x",
datablk->TDDataPtr.segment, datablk->TDDataPtr.offset,
datablk->TDDataLen );
}
/* Allocate and fill I/O buffer */
iobuf = alloc_iob ( MAX_LL_HEADER_LEN +
( ( len > IOB_ZLEN ) ? len : IOB_ZLEN ) );
if ( ! iobuf ) {
DBGC2 ( &pxe_netdev, " could not allocate iobuf\n" );
undi_transmit->Status = PXENV_STATUS_OUT_OF_RESOURCES;
return PXENV_EXIT_FAILURE;
}
iob_reserve ( iobuf, MAX_LL_HEADER_LEN );
copy_from_real ( iob_put ( iobuf, tbd.ImmedLength ), tbd.Xmit.segment,
tbd.Xmit.offset, tbd.ImmedLength );
for ( i = 0 ; i < tbd.DataBlkCount ; i++ ) {
datablk = &tbd.DataBlock[i];
copy_from_real ( iob_put ( iobuf, datablk->TDDataLen ),
datablk->TDDataPtr.segment,
datablk->TDDataPtr.offset,
datablk->TDDataLen );
}
/* Add link-layer header, if required to do so */
if ( net_protocol != NULL ) {
/* Calculate destination address */
ll_protocol = pxe_netdev->ll_protocol;
if ( undi_transmit->XmitFlag == XMT_DESTADDR ) {
copy_from_real ( destaddr,
undi_transmit->DestAddr.segment,
undi_transmit->DestAddr.offset,
ll_protocol->ll_addr_len );
ll_dest = destaddr;
DBGC2 ( &pxe_netdev, " DEST %s",
ll_protocol->ntoa ( ll_dest ) );
} else {
ll_dest = pxe_netdev->ll_broadcast;
DBGC2 ( &pxe_netdev, " BCAST" );
}
/* Add link-layer header */
if ( ( rc = ll_protocol->push ( pxe_netdev, iobuf, ll_dest,
pxe_netdev->ll_addr,
net_protocol->net_proto ))!=0){
DBGC2 ( &pxe_netdev, " could not add link-layer "
"header: %s\n", strerror ( rc ) );
free_iob ( iobuf );
undi_transmit->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
}
/* Flag transmission as in-progress. Do this before starting
* to transmit the packet, because the ISR may trigger before
* we return from netdev_tx().
*/
undi_tx_count++;
/* Transmit packet */
DBGC2 ( &pxe_netdev, "\n" );
if ( ( rc = netdev_tx ( pxe_netdev, iobuf ) ) != 0 ) {
DBGC2 ( &pxe_netdev, "PXENV_UNDI_TRANSMIT could not transmit: "
"%s\n", strerror ( rc ) );
undi_tx_count--;
undi_transmit->Status = PXENV_STATUS ( rc );
return PXENV_EXIT_FAILURE;
}
profile_stop ( &undi_tx_profiler );
undi_transmit->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
void Logstalgia::readLog(int buffer_rows) {
profile_start("readLog");
//change TZ to UTC
putenv((char*)"TZ=UTC");
tzset();
int entries_read = 0;
std::string linestr;
BaseLog* baselog = getLog();
time_t read_timestamp = 0;
while( baselog->getNextLine(linestr) ) {
//trim whitespace
if(linestr.size()>0) {
size_t string_end =
linestr.find_last_not_of(" \t\f\v\n\r");
if(string_end == std::string::npos) {
linestr = "";
} else if(string_end != linestr.size()-1) {
linestr = linestr.substr(0,string_end+1);
}
}
LogEntry le;
bool parsed_entry;
//determine format
if(accesslog==0) {
//is this a recognized NCSA access log?
NCSALog* ncsalog = new NCSALog();
if((parsed_entry = ncsalog->parseLine(linestr, le))) {
accesslog = ncsalog;
} else {
delete ncsalog;
}
if(accesslog==0) {
//is this a custom log?
CustomAccessLog* customlog = new CustomAccessLog();
if((parsed_entry = customlog->parseLine(linestr, le))) {
accesslog = customlog;
} else {
delete customlog;
}
}
} else {
if(!(parsed_entry = accesslog->parseLine(linestr, le))) {
debugLog("error: could not read line %s\n", linestr.c_str());
}
}
if(parsed_entry) {
if(mintime == 0 || mintime <= le.timestamp) {
queued_entries.push_back(new LogEntry(le));
total_entries++;
entries_read++;
//read at least the buffered row count if specified
//otherwise read all entries with the same time
if(buffer_rows) {
if(entries_read > buffer_rows) break;
} else {
if(read_timestamp && read_timestamp < le.timestamp) break;
}
read_timestamp = le.timestamp;
}
}
}
profile_stop();
//reset TZ to previous value
if(!old_tz.empty()) {
putenv((char*)old_tz.c_str());
} else {
#ifdef HAVE_UNSETENV
unsetenv("TZ");
#else
putenv("TZ=");
#endif
}
tzset();
if(queued_entries.empty() && seeklog != 0) {
if(total_entries==0) {
logstalgia_quit("could not parse first entry");
}
//no more entries
end_reached = true;
return;
}
if(seeklog != 0) {
float percent = seeklog->getPercent();
if(percent > gStopPosition) {
end_reached = true;
return;
}
if(!gDisableProgress) slider.setPercent(percent);
}
//set start time if currently 0
if(starttime==0 && !queued_entries.empty()) {
starttime = queued_entries.front()->timestamp;
currtime = 0;
}
}
void Logstalgia::draw(float t, float dt) {
if(appFinished) return;
if(!gDisableProgress) slider.logic(dt);
display.setClearColour(background);
display.clear();
glDisable(GL_FOG);
display.mode2D();
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
profile_start("draw ip summarizer");
ipSummarizer->draw(dt, font_alpha);
profile_stop();
profile_start("draw groups");
drawGroups(dt, font_alpha);
profile_stop();
profile_start("draw balls");
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindTexture(GL_TEXTURE_2D, balltex->textureid);
for(std::list<RequestBall*>::iterator it = balls.begin(); it != balls.end(); it++) {
(*it)->draw(dt);
}
profile_stop();
profile_start("draw response codes");
for(std::list<RequestBall*>::iterator it = balls.begin(); it != balls.end(); it++) {
RequestBall* r = *it;
if(gResponseCode && r->hasBounced()) {
r->drawResponseCode();
}
}
profile_stop();
glDisable(GL_TEXTURE_2D);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
if(gPaddleMode != PADDLE_NONE) {
//draw paddles shadows
for(std::map<std::string, Paddle*>::iterator it= paddles.begin(); it!=paddles.end();it++) {
it->second->drawShadow();
}
//draw paddles
for(std::map<std::string, Paddle*>::iterator it= paddles.begin(); it!=paddles.end();it++) {
it->second->draw();
}
}
if(!gDisableGlow) {
glBlendFunc (GL_ONE, GL_ONE);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, glowtex->textureid);
for(std::list<RequestBall*>::iterator it = balls.begin(); it != balls.end(); it++) {
(*it)->drawGlow();
}
}
infowindow.draw();
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
if(uimessage_timer>0.1f) {
glColor4f(1.0,1.0,uimessage_timer/3.0f,uimessage_timer/3.0f);
int mwidth = fontLarge.getWidth(uimessage.c_str());
fontLarge.draw(display.width/2 - mwidth/2, display.height/2 - 20, uimessage.c_str());
uimessage_timer-=dt;
}
if(gSplash>0.0f) {
int logowidth = fontLarge.getWidth("Logstalgia");
int logoheight = 105;
int cwidth = fontMedium.getWidth("Website Access Log Viewer");
int awidth = fontMedium.getWidth("(C) 2008 Andrew Caudwell");
vec2f corner(display.width/2 - logowidth/2 - 30.0f,
display.height/2 - 45);
float logo_alpha = std::min(1.0f, gSplash/3.0f);
float logo_bg = std::min(0.2f, gSplash/10.0f);
glDisable(GL_TEXTURE_2D);
glColor4f(0.0f, 0.5f, 1.0f, logo_bg);
glBegin(GL_QUADS);
glVertex2f(0.0f, corner.y);
glVertex2f(0.0f, corner.y + logoheight);
glVertex2f(display.width, corner.y + logoheight);
glVertex2f(display.width, corner.y);
glEnd();
glEnable(GL_TEXTURE_2D);
fontLarge.alignTop(true);
fontLarge.dropShadow(true);
glColor4f(1,1,1,logo_alpha);
fontLarge.draw(display.width/2 - logowidth/2,display.height/2 - 30, "Logstalgia");
glColor4f(0,1,1,logo_alpha);
fontLarge.draw(display.width/2 - logowidth/2,display.height/2 - 30, "Log");
glColor4f(1,1,1,logo_alpha);
fontMedium.draw(display.width/2 - cwidth/2,display.height/2 + 17, "Website Access Log Viewer");
fontMedium.draw(display.width/2 - awidth/2,display.height/2 + 37, "(C) 2008 Andrew Caudwell");
gSplash-=dt;
}
if(!gDisableProgress) slider.draw(dt);
glColor4f(1,1,1,font_alpha);
if(info) {
fontMedium.print(2,2, "FPS %d", (int) fps);
fontMedium.print(2,19,"Balls %03d", balls.size());
fontMedium.print(2,36,"Queue %03d", queued_entries.size());
fontMedium.print(2,53,"Paddles %03d", paddles.size());
} else {
fontMedium.draw(2,2, displaydate.c_str());
fontMedium.draw(2,19, displaytime.c_str());
}
glColor4f(1,1,1,font_alpha);
int counter_width = fontLarge.getWidth("00000000");
fontLarge.alignTop(false);
fontLarge.print(display.width-10-counter_width,display.height-10, "%08d", highscore);
}