/*
* ReportServerUDP will generate a report of the UDP
* statistics as reported by the server on the client
* side.
*/
void ReportServerUDP( thread_Settings *agent, server_hdr *server ) {
if ( (ntohl(server->flags) & HEADER_VERSION1) != 0 &&
isServerReport( agent ) ) {
/*
* Create in one big chunk
*/
ReportHeader *reporthdr = (ReportHeader *) malloc( sizeof(ReportHeader) );
Transfer_Info *stats = &reporthdr->report.info;
if ( reporthdr != NULL ) {
stats->transferID = agent->mSock;
stats->groupID = (agent->multihdr != NULL ? agent->multihdr->groupID
: -1);
reporthdr->agentindex = -1;
reporthdr->reporterindex = -1;
reporthdr->report.type = SERVER_RELAY_REPORT;
reporthdr->report.mode = agent->mReportMode;
stats->mFormat = agent->mFormat;
stats->jitter = ntohl( server->jitter1 );
stats->jitter += ntohl( server->jitter2 ) / (double)rMillion;
#ifdef HAVE_INT64_T
stats->TotalLen = (((max_size_t) ntohl( server->total_len1 )) << 32) +
ntohl( server->total_len2 );
#else
stats->TotalLen = ntohl( server->total_len2 );
#endif
stats->startTime = 0;
stats->endTime = ntohl( server->stop_sec );
stats->endTime += ntohl( server->stop_usec ) / (double)rMillion;
stats->cntError = ntohl( server->error_cnt );
stats->cntOutofOrder = ntohl( server->outorder_cnt );
stats->cntDatagrams = ntohl( server->datagrams );
stats->mUDP = (char)kMode_Server;
reporthdr->report.connection.peer = agent->local;
reporthdr->report.connection.size_peer = agent->size_local;
reporthdr->report.connection.local = agent->peer;
reporthdr->report.connection.size_local = agent->size_peer;
#ifdef HAVE_THREAD
/*
* Update the ReportRoot to include this report.
*/
Condition_Lock( ReportCond );
reporthdr->next = ReportRoot;
ReportRoot = reporthdr;
Condition_Signal( &ReportCond );
Condition_Unlock( ReportCond );
#else
/*
* Process the report in this thread
*/
reporthdr->next = NULL;
process_report ( reporthdr );
#endif
} else {
FAIL(1, "Out of Memory!!\n", agent);
}
}
}
/**
* validate_file:
**/
static gboolean
validate_file (gchar *fname, gboolean pretty)
{
GFile *file;
gboolean ret;
gboolean errors_found;
AsValidator *validator;
GList *issues;
file = g_file_new_for_path (fname);
if (!g_file_query_exists (file, NULL)) {
g_print ("File '%s' does not exist.", fname);
g_print ("\n");
g_object_unref (file);
return FALSE;
}
validator = as_validator_new ();
ret = as_validator_validate_file (validator, file);
issues = as_validator_get_issues (validator);
errors_found = process_report (issues, pretty);
if (!ret)
errors_found = TRUE;
g_list_free (issues);
g_object_unref (file);
g_object_unref (validator);
return !errors_found;
}
/*
* ReportSettings will generate a summary report for
* settings being used with Listeners or Clients
*/
void ReportSettings( thread_Settings *agent ) {
if ( isSettingsReport( agent ) ) {
/*
* Create in one big chunk
*/
ReportHeader *reporthdr = malloc( sizeof(ReportHeader) );
if ( reporthdr != NULL ) {
ReporterData *data = &reporthdr->report;
data->info.transferID = agent->mSock;
data->info.groupID = -1;
reporthdr->agentindex = -1;
reporthdr->reporterindex = -1;
data->mHost = agent->mHost;
data->mLocalhost = agent->mLocalhost;
data->mode = agent->mReportMode;
data->type = SETTINGS_REPORT;
data->mBufLen = agent->mBufLen;
data->mMSS = agent->mMSS;
data->mTCPWin = agent->mTCPWin;
data->flags = agent->flags;
data->mThreadMode = agent->mThreadMode;
data->mPort = agent->mPort;
data->info.mFormat = agent->mFormat;
data->info.mTTL = agent->mTTL;
data->connection.peer = agent->peer;
data->connection.size_peer = agent->size_peer;
data->connection.local = agent->local;
data->connection.size_local = agent->size_local;
data->mUDPRate = agent->mUDPRate;
data->mUDPRateUnits = agent->mUDPRateUnits;
#ifdef HAVE_THREAD
/*
* Update the ReportRoot to include this report.
*/
Condition_Lock( ReportCond );
reporthdr->next = ReportRoot;
ReportRoot = reporthdr;
Condition_Signal( &ReportCond );
Condition_Unlock( ReportCond );
#else
/*
* Process the report in this thread
*/
reporthdr->next = NULL;
process_report ( reporthdr );
#endif
} else {
FAIL(1, "Out of Memory!!\n", agent);
}
}
}
/*
* EndReport signifies the agent no longer is interested
* in the report. Calls to GetReport will no longer be
* filled
*/
void EndReport( ReportHeader *agent ) {
if ( agent != NULL ) {
int index = agent->reporterindex;
while ( index != -1 ) {
thread_rest();
index = agent->reporterindex;
}
agent->agentindex = -1;
#ifndef HAVE_THREAD
/*
* Process the report in this thread
*/
process_report ( agent );
#endif
}
}
/*
* EndReport signifies the agent no longer is interested
* in the report. Calls to GetReport will no longer be
* filled
*/
void EndReport( ReportHeader *agent ) {
if ( agent != NULL ) {
int index = agent->reporterindex;
while ( index != -1 ) {
Condition_Wait_Event( &ReportDoneCond );
index = agent->reporterindex;
}
agent->agentindex = -1;
#ifndef HAVE_THREAD
/*
* Process the report in this thread
*/
process_report ( agent );
#endif
}
}
/*
* ReportPacket is called by a transfer agent to record
* the arrival or departure of a "packet" (for TCP it
* will actually represent many packets). This needs to
* be as simple and fast as possible as it gets called for
* every "packet".
*/
void ReportPacket( ReportHeader* agent, ReportStruct *packet ) {
if ( agent != NULL ) {
int index = agent->reporterindex;
/*
* First find the appropriate place to put the information
*/
if ( agent->agentindex == NUM_REPORT_STRUCTS ) {
// Just need to make sure that reporter is not on the first
// item
while ( index == 0 ) {
Condition_Signal( &ReportCond );
Condition_Lock( ReportCond );
Condition_Wait( &ReportDoneCond );
Condition_Unlock( ReportCond );
index = agent->reporterindex;
}
agent->agentindex = 0;
}
// Need to make sure that reporter is not about to be "lapped"
while ( index - 1 == agent->agentindex ) {
Condition_Signal( &ReportCond );
Condition_Lock( ReportCond );
Condition_Wait( &ReportDoneCond );
Condition_Unlock( ReportCond );
index = agent->reporterindex;
}
// Put the information there
memcpy( agent->data + agent->agentindex, packet, sizeof(ReportStruct) );
// Updating agentindex MUST be the last thing done
agent->agentindex++;
#ifndef HAVE_THREAD
/*
* Process the report in this thread
*/
process_report ( agent );
#endif
}
}
_Noreturn void* thread_start(void *ptr) {
struct message msg = ((struct thread_param*) ptr)->msg;
bool allowed = ((struct thread_param*) ptr)->allowed;
long channel = msg.channel_request.pid;
free(ptr);
check_interrupted();
if(msg.channel_request.id > 0) {
if(!allowed)
refuse_connection(channel);
else {
accept_connection(channel);
process_results(channel);
}
}
else
process_report(channel);
exit_thread();
}
void usb_callback(struct libusb_transfer* transfer)
{
int usb_number = *(int*)transfer->user_data;
struct usb_state * state = usb_states+usb_number;
struct libusb_control_setup* setup = libusb_control_transfer_get_setup(transfer);
if(transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL)
{
if(transfer->status == LIBUSB_TRANSFER_COMPLETED)
{
if(setup->bmRequestType & LIBUSB_ENDPOINT_IN)
{
if(transfer->actual_length > 0xff)
{
fprintf(stderr, "wLength (%hu) is higher than %hu\n", transfer->actual_length, BUFFER_SIZE-LIBUSB_CONTROL_SETUP_SIZE);
}
else
{
unsigned char *data = libusb_control_transfer_get_data(transfer);
if(adapter_forward_control_in(usb_number, data, transfer->actual_length) < 0)
{
fprintf(stderr, "can't forward control data to the adapter\n");
}
}
}
}
else
{
if(transfer->status != LIBUSB_TRANSFER_CANCELLED)
{
fprintf(stderr, "libusb_transfer failed with status %s (bmRequestType=0x%02x, bRequest=0x%02x, wValue=0x%04x)\n", libusb_error_name(transfer->status), setup->bmRequestType, setup->bRequest, setup->wValue);
}
}
}
else if(transfer->type == LIBUSB_TRANSFER_TYPE_INTERRUPT)
{
if(transfer->endpoint == controller[state->type].endpoints.in.address)
{
state->ack = 1;
}
if(transfer->status == LIBUSB_TRANSFER_COMPLETED)
{
if(transfer->endpoint == controller[state->type].endpoints.in.address)
{
// process joystick events
if(transfer->actual_length <= controller[state->type].endpoints.in.size
&& transfer->actual_length > 0)
{
process_report(usb_number, state, transfer);
}
}
}
else
{
if(transfer->status != LIBUSB_TRANSFER_TIMED_OUT && transfer->status != LIBUSB_TRANSFER_CANCELLED)
{
fprintf(stderr, "libusb_transfer failed with status %s (endpoint=0x%02x)\n", libusb_error_name(transfer->status), transfer->endpoint);
}
}
}
remove_transfer(transfer);
}
int main(int argc, char const *argv[])
{
list_t * colaboradores = NULL;
list_t * retiradas = NULL;
list_t * relatorio = list_blank_list();
node_t * node = NULL;
colaborador_t * colaborador = NULL;
retirada_t * retirada = NULL;
char buffer[500];
unsigned int colaborador_id = 0;
char * tipo_relatorio = NULL;
request_t * request = NULL;
response_t * response = response_empty(NULL);
var_t * var = NULL;
error_t error = ERROR_NULL;
unsigned int user_id;
unsigned char user_level;
request_process(&request);
login_info(request, &user_id, &user_level);
if (user_level > ANONYMOUS)
{
node = request->GET->first;
while (node != NULL)
{
var = (var_t *) node->data;
if (strcmp(var->name, "por") == 0)
{
tipo_relatorio = var->value;
}
if (strcmp(var->name, "colaboradorid") == 0)
{
colaborador_id = atoi(var->value);
}
node = node->next;
}
colaboradores_load(&colaboradores, NULL);
retiradas_load(&retiradas, NULL);
if (strcmp(tipo_relatorio, "item") == 0)
{
process_report(&relatorio, retiradas, 0);
login_refresh_session(&response, user_id, user_level);
response_write_template(&response, "templates/header.html");
response_write_template(&response, "templates/relatorios_item.html");
if (relatorio->first == NULL)
{
response_write(&response, "<p>Não existe informações para serem exibidas</p>");
}
else
{
response_write(&response, "<table class=\"table table-bordered table-striped\">"
"<tr><th>Item</th><th>Retirado por</th><th>Data da última retirada</th>"
"<th>Quantidade restante</th></tr>");
node = relatorio->first;
while (node != NULL)
{
retirada = (retirada_t *) node->data;
sprintf(buffer,
"<tr><td>%s</td><td>%s</td><td>%s</td><td class=\"quantidade\">%u</td></tr>",
retirada->item->nome,
retirada->colaborador->nome,
retirada->data,
retirada->item->quantidade);
response_write(&response, buffer);
retirada_free(&retirada);
node = node->next;
}
response_write(&response, "</table>");
}
response_write(&response, "<script src=\"/js/relatorios.js\"></script>");
response_write_template(&response, "templates/footer.html");
}
else if (strcmp(tipo_relatorio, "colaborador") == 0)
{
if (colaborador_id > 0)
{
process_report(&relatorio, retiradas, colaborador_id);
}
login_refresh_session(&response, user_id, user_level);
response_write_template(&response, "templates/header.html");
response_write_template(&response, "templates/relatorios_colaborador.html");
if (colaborador_id > 0)
{
if (relatorio->first == NULL)
{
response_write(&response, "<p>Não existe informações para serem exibidas</p>");
}
else
{
response_write(&response, "<table class=\"table table-bordered table-striped\">"
"<tr><th>Item</th><th>Retirado por</th><th>Data da última retirada</th>"
"<th>Quantidade restante</th></tr>");
node = relatorio->first;
while (node != NULL)
{
retirada = (retirada_t *) node->data;
sprintf(buffer,
"<tr><td>%s</td><td>%s</td><td>%s</td><td class=\"quantidade\">%u</td></tr>",
retirada->item->nome,
retirada->colaborador->nome,
retirada->data,
retirada->item->quantidade);
response_write(&response, buffer);
retirada_free(&retirada);
node = node->next;
}
response_write(&response, "</table>");
}
}
else
{
response_write(&response, "<p id=\"message\">Para ver o relatório selecione um colaborador acima e aperte \"Ver relatório\"</p>");
}
response_write(&response, "<script>var colaboradores = [");
node = colaboradores->first;
while (node != NULL)
{
colaborador = (colaborador_t *) node->data;
sprintf(buffer,
"{ id: %u, nome: \"%s\" },",
colaborador->id,
colaborador->nome);
response_write(&response, buffer);
colaborador_free(&colaborador);
node = node->next;
}
response_write(&response, "];</script>");
response_write(&response, "<script src=\"/js/relatorios.js\"></script>");
response_write(&response, "<script src=\"/js/relatorios_colaborador.js\"></script>");
response_write_template(&response, "templates/footer.html");
}
else
{
error = ERROR_RELATORIO_INVALIDO;
}
if (error != ERROR_NULL)
{
if (error == ERROR_RELATORIO_INVALIDO)
{
sprintf(buffer, "/cgi-bin/relatorios?por=item");
}
else
{
sprintf(buffer, "/cgi-bin/relatorios?por=%s", tipo_relatorio);
}
error_page(&response, error, buffer);
}
}
else
{
error_page(&response, ERROR_LOGIN_REQUIRED, "/");
}
response_send(response);
request_free(request);
return 0;
}
/*
* InitReport is called by a transfer agent (client or
* server) to setup the needed structures to communicate
* traffic.
*/
ReportHeader* InitReport( thread_Settings *agent ) {
ReportHeader *reporthdr = NULL;
ReporterData *data = NULL;
if ( isDataReport( agent ) ) {
/*
* Create in one big chunk
*/
reporthdr = malloc( sizeof(ReportHeader) +
NUM_REPORT_STRUCTS * sizeof(ReportStruct) );
if ( reporthdr != NULL ) {
// Only need to make sure the headers are clean
memset( reporthdr, 0, sizeof(ReportHeader));
reporthdr->data = (ReportStruct*)(reporthdr+1);
reporthdr->multireport = agent->multihdr;
data = &reporthdr->report;
reporthdr->reporterindex = NUM_REPORT_STRUCTS - 1;
data->info.transferID = agent->mSock;
data->info.groupID = (agent->multihdr != NULL ? agent->multihdr->groupID : 128);
data->type = TRANSFER_REPORT;
if ( agent->mInterval != 0.0 ) {
struct timeval *interval = &data->intervalTime;
interval->tv_sec = (long) agent->mInterval;
interval->tv_usec = (long) ((agent->mInterval - interval->tv_sec) * rMillion);
}
data->mHost = agent->mHost;
data->mLocalhost = agent->mLocalhost;
data->mBufLen = agent->mBufLen;
data->mMSS = agent->mMSS;
data->mTCPWin = agent->mTCPWin;
data->flags = agent->flags;
data->mThreadMode = agent->mThreadMode;
data->mode = agent->mReportMode;
data->info.mFormat = agent->mFormat;
data->info.mTTL = agent->mTTL;
if (data->mThreadMode == kMode_Server)
data->info.tcp.read.binsize = data->mBufLen / 8;
if ( isUDP( agent ) ) {
gettimeofday(&data->IPGstart, NULL);
reporthdr->report.info.mUDP = (char)agent->mThreadMode;
} else {
reporthdr->report.info.mTCP = (char)agent->mThreadMode;
}
if ( isEnhanced( agent ) ) {
data->info.mEnhanced = 1;
} else {
data->info.mEnhanced = 0;
}
} else {
FAIL(1, "Out of Memory!!\n", agent);
}
}
if ( isConnectionReport( agent ) ) {
if ( reporthdr == NULL ) {
/*
* Create in one big chunk
*/
reporthdr = malloc( sizeof(ReportHeader) );
if ( reporthdr != NULL ) {
// Only need to make sure the headers are clean
memset( reporthdr, 0, sizeof(ReportHeader));
data = &reporthdr->report;
data->info.transferID = agent->mSock;
data->info.groupID = 128;
} else {
FAIL(1, "Out of Memory!!\n", agent);
}
}
if ( reporthdr != NULL ) {
data->type |= CONNECTION_REPORT;
data->connection.peer = agent->peer;
data->connection.size_peer = agent->size_peer;
data->connection.local = agent->local;
data->connection.size_local = agent->size_local;
} else {
FAIL(1, "Out of Memory!!\n", agent);
}
}
if ( isConnectionReport( agent ) || isDataReport( agent ) ) {
#ifdef HAVE_THREAD
/*
* Update the ReportRoot to include this report.
*/
if ( reporthdr->report.mThreadMode == kMode_Client &&
reporthdr->multireport != NULL ) {
// syncronize watches on my mark......
BarrierClient( reporthdr );
} else {
if ( reporthdr->multireport != NULL && isMultipleReport( agent )) {
reporthdr->multireport->threads++;
if ( reporthdr->multireport->report->startTime.tv_sec == 0 ) {
gettimeofday( &(reporthdr->multireport->report->startTime), NULL );
}
reporthdr->report.startTime = reporthdr->multireport->report->startTime;
} else {
// set start time
gettimeofday( &(reporthdr->report.startTime), NULL );
}
reporthdr->report.nextTime = reporthdr->report.startTime;
TimeAdd( reporthdr->report.nextTime, reporthdr->report.intervalTime );
}
Condition_Lock( ReportCond );
reporthdr->next = ReportRoot;
ReportRoot = reporthdr;
Condition_Signal( &ReportCond );
Condition_Unlock( ReportCond );
#else
// set start time
gettimeofday( &(reporthdr->report.startTime), NULL );
/*
* Process the report in this thread
*/
reporthdr->next = NULL;
process_report ( reporthdr );
#endif
}
if ( !isDataReport( agent ) ) {
reporthdr = NULL;
}
return reporthdr;
}
int main(int argc, char **argv) {
config_init();
int c;
while (-1 != (c = getopt(argc, argv, "n:m:k:d:p:h"))) {
switch(c) {
case 'n':
config.num = atoi(optarg);
break;
case 'm':
config.maxbytes = ((size_t)atoi(optarg)) * 1024 * 1024;
break;
case 'k':
config.keysize = atoi(optarg);
break;
case 'd':
config.datasize = atoi(optarg);
break;
case 'p':
config.hashpower = atoi(optarg);
break;
case 'h':
usage();
return EXIT_SUCCESS;
default:
usage();
return EXIT_FAILURE;
}
}
generate_key_init();
print_env();
lru *l = lru_init(config.maxbytes, config.hashpower);
char *bvalue = malloc(config.datasize);
memset(bvalue, 'x', config.datasize);
char *key = malloc(config.keysize);
memset(key, 0, config.keysize);
int gnum = config.keysize - num_;
generate_key_reset();
bench_start("SET");
int i;
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
int r = item_set(l, key, config.keysize, bvalue, config.datasize);
assert(r == 0);
process_report();
}
bench_stop();
print_stat(l);
char *buf = malloc(config.datasize);
size_t sz;
generate_key_reset();
bench_start("GET");
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
int r = item_get(l, key, config.keysize, buf, config.datasize, &sz);
if (!r) {
assert((int)sz == config.datasize);
assert(memcmp(bvalue, buf, config.datasize) == 0);
}
memset(buf, 0, config.datasize);
process_report();
}
bench_stop();
print_stat(l);
generate_key_reset();
bench_start("DELETE");
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
item_delete(l, key, config.keysize);
process_report();
}
bench_stop();
print_stat(l);
free(buf);
free(bvalue);
free(key);
free(fmt_);
free(key_);
lru_free(l);
/*
printf("print any key to exit...\n");
getchar();
*/
return EXIT_SUCCESS;
}
