static void mmap_read(struct mmap_data *md)
{
unsigned int head = mmap_read_head(md);
unsigned int old = md->prev;
unsigned char *data = md->base + page_size;
unsigned long size;
void *buf;
int diff;
gettimeofday(&this_read, NULL);
/*
* If we're further behind than half the buffer, there's a chance
* the writer will bite our tail and mess up the samples under us.
*
* If we somehow ended up ahead of the head, we got messed up.
*
* In either case, truncate and restart at head.
*/
diff = head - old;
if (diff < 0) {
struct timeval iv;
unsigned long msecs;
timersub(&this_read, &last_read, &iv);
msecs = iv.tv_sec*1000 + iv.tv_usec/1000;
fprintf(stderr, "WARNING: failed to keep up with mmap data."
" Last read %lu msecs ago.\n", msecs);
/*
* head points to a known good entry, start there.
*/
old = head;
}
last_read = this_read;
if (old != head)
samples++;
size = head - old;
if ((old & md->mask) + size != (head & md->mask)) {
buf = &data[old & md->mask];
size = md->mask + 1 - (old & md->mask);
old += size;
write_event(buf, size);
}
buf = &data[old & md->mask];
size = head - old;
old += size;
write_event(buf, size);
md->prev = old;
mmap_write_tail(md, old);
}
void execute_move_unsynced(int fd, int version, unsigned int device_flags,
int x, int y)
{
if (version == ICS_EVENT_PROTO) {
write_event(fd, EV_ABS, ABS_MT_POSITION_X, x);
write_event(fd, EV_ABS, ABS_MT_POSITION_Y, y);
}
}
void remove_mt_tracking_id(int fd, int version, unsigned int device_flags,
int slot)
{
if (version == ICS_EVENT_PROTO) {
write_event(fd, EV_ABS, ABS_MT_SLOT, slot);
write_event(fd, EV_ABS, ABS_MT_TRACKING_ID, -1);
write_event(fd, EV_SYN, SYN_REPORT, 0);
}
}
void GeneralWriter :: columnDefault ( int stream_id, uint32_t elem_bits, const void *data, uint32_t elem_count )
{
switch ( state )
{
case opened:
break;
default:
throw "state violation setting column default";
}
if ( stream_id < 0 )
throw "Stream_id is not valid";
if ( stream_id > ( int ) streams.size () )
throw "Stream_id is out of bounds";
if ( elem_bits == 0 )
return;
if ( data == 0 && elem_count != 0 )
throw "Invalid data ptr";
if ( elem_bits != streams [ stream_id - 1 ] . elem_bits )
throw "Invalid elem_bits";
size_t num_bytes = ( ( size_t ) elem_bits * elem_count + 7 ) / 8;
if ( num_bytes == 0 )
{
gwp_evt_hdr_v1 eh;
init ( eh, stream_id, evt_empty_default );
write_event ( & eh, sizeof eh );
}
else
{
if ( num_bytes <= 256 )
{
gwp_data_evt chunk;
init ( chunk, stream_id, evt_cell_default );
set_size ( chunk, num_bytes );
write_event ( & chunk . dad, sizeof chunk );
}
else if ( num_bytes <= 0x10000 )
{
gwp_data_evt_U16 chunk;
init ( chunk, stream_id, evt_cell_default2 );
set_size ( chunk, num_bytes );
write_event ( & chunk . dad, sizeof chunk );
}
else
{
throw "default cell-data exceeds maximum";
}
internal_write ( data, num_bytes );
}
}
void execute_release(int fd, uint32_t device_flags)
{
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT) {
write_event(fd, EV_ABS, ABS_MT_PRESSURE,0);
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT_SYNC)
write_event(fd, EV_SYN, SYN_MT_REPORT, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
} else if (device_flags & INPUT_DEVICE_CLASS_TOUCH) {
write_event(fd, EV_KEY, BTN_TOUCH, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
}
}
void execute_release(int fd, int version, unsigned int device_flags)
{
if (version == ICS_EVENT_PROTO) {
write_event(fd, EV_ABS, ABS_MT_PRESSURE,0);
if (device_flags & NEED_MT_SYN)
write_event(fd, EV_SYN, SYN_MT_REPORT, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
} else if (version == FROYO_EVENT_PROTO) {
write_event(fd, EV_SYN, SYN_MT_REPORT, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
}
}
int main(int argc, char *argv[])
{
int fd;
int ret;
int i;
struct uinput_user_dev uidev;
fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
if(fd < 0) {
perror("Error");
exit(EXIT_FAILURE);
}
memset(&uidev, 0, sizeof(uidev));
/* register device information */
snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
uidev.id.bustype = BUS_USB;
uidev.id.vendor = 0x1234;
uidev.id.product = 0xfedc;
uidev.id.version = 1;
// ret = write(fd, &uidev, sizeof(uidev));
/* */
ioctl(fd, UI_SET_EVBIT, EV_KEY);
for (i=KEY_RESERVED;i<KEY_MAX;i++) {
ioctl(fd, UI_SET_KEYBIT, i);
}
ret = write(fd, &uidev, sizeof(uidev));
ioctl(fd, UI_DEV_CREATE, NULL);
sleep(1);
/* Send Keycode "a" */
write_event(EV_KEY, KEY_A, 1, fd);
write_event(EV_KEY, KEY_A, 2, fd);
write_event(EV_SYN, SYN_REPORT, 0, fd);
sleep(1);
write_event(EV_KEY, KEY_A, 0, fd);
write_event(EV_SYN, SYN_REPORT, 0, fd);
while(1){};
ioctl(fd, UI_DEV_DESTROY, NULL);
close(fd);
exit(EXIT_SUCCESS);
}
void GeneralWriter :: logMsg ( const std :: string &msg )
{
switch ( state )
{
case header_written:
case remote_name_sent:
case schema_sent:
case software_name_sent:
case remote_name_and_schema_sent:
case remote_name_and_software_name_sent:
case schema_and_software_name_sent:
case remote_name_schema_and_software_name_sent:
case have_table:
case have_column:
case opened:
break;
default:
return;
}
size_t str_size = msg . size ();
if ( str_size == 0 )
return;
if ( str_size > 0x10000 )
str_size = 0x10000;
gwp_1string_evt_U16 hdr;
init ( hdr, 0, evt_logmsg );
set_size ( hdr, str_size );
write_event ( & hdr . dad, sizeof hdr );
internal_write ( msg . data (), str_size );
}
// ask the general-loader to use this when naming its output
void GeneralWriter :: setRemotePath ( const std :: string & remote_db )
{
stream_state new_state = uninitialized;
switch ( state )
{
case header_written:
new_state = remote_name_sent;
break;
case schema_sent:
new_state = remote_name_and_schema_sent;
break;
case software_name_sent:
new_state = remote_name_and_software_name_sent;
break;
case schema_and_software_name_sent:
new_state = remote_name_schema_and_software_name_sent;
break;
default:
throw "state violation setting remote path";
}
size_t str_size = remote_db . size ();
if ( str_size > 0x10000 )
throw "remote path too long";
gwp_1string_evt_U16 hdr;
init ( hdr, 0, evt_remote_path2 );
set_size ( hdr, str_size );
write_event ( & hdr . dad, sizeof hdr );
internal_write ( remote_db . data (), str_size );
state = new_state;
}
void GeneralWriter :: endStream ()
{
switch ( state )
{
case header_written:
case remote_name_sent:
case schema_sent:
case software_name_sent:
case remote_name_and_schema_sent:
case remote_name_and_software_name_sent:
case schema_and_software_name_sent:
case remote_name_schema_and_software_name_sent:
case have_table:
case have_column:
case opened:
case error:
break;
default:
return;
}
gwp_evt_hdr hdr;
init ( hdr, 0, evt_end_stream );
write_event ( & hdr, sizeof hdr );
state = closed;
flush ();
}
void execute_move(int fd, uint32_t device_flags, int x, int y)
{
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT) {
write_event(fd, EV_ABS, ABS_MT_TOUCH_MAJOR, 32);
write_event(fd, EV_ABS, ABS_MT_WIDTH_MAJOR, 4);
write_event(fd, EV_ABS, ABS_MT_POSITION_X, x);
write_event(fd, EV_ABS, ABS_MT_POSITION_Y, y);
write_event(fd, EV_ABS, ABS_MT_PRESSURE, 90);
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT_SYNC)
write_event(fd, EV_SYN, SYN_MT_REPORT, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
} else if (device_flags & INPUT_DEVICE_CLASS_TOUCH) {
write_event(fd, EV_ABS, ABS_X, x);
write_event(fd, EV_ABS, ABS_Y, y);
write_event(fd, EV_SYN, SYN_REPORT, 0);
}
}
void send_event(const int type, const int value, const int code, const int auto_syn) {
static struct timeval prev_tv;
static struct input_event ev;
#define TV_LESS(a, b) ((a).tv_sec < (b).tv_sec || ((a).tv_sec == (b).tv_sec && (a).tv_usec < (b).tv_usec))
#define TV_NEXT_USEC(tv) do { \
(tv).tv_usec++; \
if ((tv).tv_usec >= 1000000) { \
(tv).tv_usec = 0; \
(tv).tv_sec++; \
} \
} while(0)
// write event itself
ev.type = type;
ev.value = value;
ev.code = code;
gettimeofday(&ev.time, NULL);
if (!TV_LESS(prev_tv, ev.time)) {
ev.time = prev_tv;
TV_NEXT_USEC(ev.time);
}
write_event(udev_fd, &ev);
if (auto_syn) {
// and write sync event
ev.type = EV_SYN;
ev.value = 0;
ev.code = 0;
TV_NEXT_USEC(ev.time);
write_event(udev_fd, &ev);
}
// remember previous time
prev_tv = ev.time;
#undef TV_LESS
#undef TV_NEXT_USEC
}
void execute_move(int fd, uint32_t device_flags, int x, int y)
{
print_action(ACTION_START, "move", "\"x\": %d, \"y\": %d", x, y);
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT) {
write_event(fd, EV_ABS, ABS_MT_POSITION_X, x);
write_event(fd, EV_ABS, ABS_MT_POSITION_Y, y);
write_event(fd, EV_ABS, ABS_MT_PRESSURE, 127);
write_event(fd, EV_ABS, ABS_MT_TOUCH_MAJOR, 127);
write_event(fd, EV_ABS, ABS_MT_WIDTH_MAJOR, 4);
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT_SYNC)
write_event(fd, EV_SYN, SYN_MT_REPORT, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
} else if (device_flags & INPUT_DEVICE_CLASS_TOUCH) {
write_event(fd, EV_ABS, ABS_X, x);
write_event(fd, EV_ABS, ABS_Y, y);
write_event(fd, EV_SYN, SYN_REPORT, 0);
}
print_action(ACTION_END, "move", NULL);
}
int GeneralWriter :: addTable ( const std :: string &table_name )
{
stream_state new_state = uninitialized;
switch ( state )
{
case schema_sent:
case remote_name_and_schema_sent:
case remote_name_schema_and_software_name_sent:
new_state = have_table;
break;
case have_table:
case have_column:
new_state = state;
break;
default:
throw "state violation adding table";
}
// create a pair between the outer db id ( 0 ) and this table name
// this pair will act as an unique key of tables, whereas table_name
// itself can be repeated if multiple databases are in use
int_dbtbl tbl ( 0, table_name );
// prediction this is the index
int id = ( int ) tables.size() + 1;
if ( id > 256 )
throw "maximum number of tables exceeded";
// make sure we never record a table name twice under the same db
std :: pair < std :: map < int_dbtbl, int > :: iterator, bool > result =
table_name_idx.insert ( std :: pair < int_dbtbl, int > ( tbl, id ) );
// if first time
if ( result.second )
{
tables.push_back ( tbl );
size_t str_size = table_name . size ();
if ( str_size > 0x10000 )
throw "maximum table name length exceeded";
gwp_1string_evt_U16 hdr;
init ( hdr, id, evt_new_table2 );
set_size ( hdr, str_size );
write_event ( & hdr . dad, sizeof hdr );
internal_write ( table_name.data (), str_size );
state = new_state;
}
// 1 based table id
return result.first->second;
}
void ms_filter_notify(MSFilter *f, unsigned int id, void *arg){
if (f->notify_callbacks!=NULL){
if (f->factory->evq==NULL){
/* synchronous notification */
ms_filter_invoke_callbacks(&f,id,arg,Both);
}else{
ms_filter_invoke_callbacks(&f,id,arg,OnlySynchronous);
write_event(f->factory->evq,f,id,arg);
}
}
}
int hax_notify_host_event(enum hax_notify_event event, uint32_t *param,
uint32_t size)
{
if (event >= ce2he_size)
return -EINVAL;
if (!HaxDriverObject)
return -EINVAL;
write_event(ce2he[event], HaxDriverObject, param, size);
return 0;
}
static int log_events(struct ast_channel *chan, char *signalling_type, event_node_t *event)
{
int res = 0;
char workstring[sizeof(event_spool_dir)+sizeof(event_file)] = "";
int fd;
FILE *logfile;
event_node_t *elp = event;
if (!ast_strlen_zero(event_spool_dir)) {
/* Make a template */
ast_copy_string(workstring, event_spool_dir, sizeof(workstring));
strncat(workstring, event_file, sizeof(workstring) - strlen(workstring) - 1);
/* Make the temporary file */
fd = mkstemp(workstring);
if(fd == -1){
ast_verbose(VERBOSE_PREFIX_4 "AlarmReceiver: can't make temporary file\n");
ast_log(LOG_DEBUG,"AlarmReceiver: can't make temporary file\n");
res = -1;
}
if(!res){
logfile = fdopen(fd, "w");
if(logfile){
/* Write the file */
res = write_metadata(logfile, signalling_type, chan);
if(!res)
while((!res) && (elp != NULL)){
res = write_event(logfile, elp);
elp = elp->next;
}
if(!res){
if(fflush(logfile) == EOF)
res = -1;
if(!res){
if(fclose(logfile) == EOF)
res = -1;
}
}
}
else
res = -1;
}
}
return res;
}
void GeneralWriter :: setTblMetadataNode ( int obj_id,
const std :: string & node_path,
const std :: string & value )
{
if ( obj_id <= 0 || ( size_t ) obj_id > tables.size () )
throw "Invalid table id";
size_t str1_size = node_path . size ();
if ( str1_size > STRING_LIMIT_16 )
throw "tbl_path too long";
size_t str2_size = value . size ();
if ( str2_size > STRING_LIMIT_16 )
throw "value too long";
if ( str1_size <= STRING_LIMIT_8 && str2_size <= STRING_LIMIT_8 )
{
// use 8-bit sizes
gwp_2string_evt_v1 hdr;
init ( hdr, obj_id, evt_tbl_metadata_node );
set_size1 ( hdr, str1_size );
set_size2 ( hdr, str2_size );
write_event ( & hdr . dad, sizeof hdr );
}
else
{
// use 16-bit sizes
gwp_2string_evt_U16_v1 hdr;
init ( hdr, obj_id, evt_tbl_metadata_node2 );
set_size1 ( hdr, str1_size );
set_size2 ( hdr, str2_size );
write_event ( & hdr . dad, sizeof hdr );
}
internal_write ( node_path . data (), str1_size );
internal_write ( value . data (), str2_size );
}
int main(int argc, char **argv)
{
init_interesting_keys();
if (argc >= 2 && strcmp(argv[1], "-v") == 0) {
argv++;
argc--;
verbose = 1;
}
source_evdev_fd = open(argv[1], O_RDONLY);
if (source_evdev_fd < 0) {
perror("evdev open");
exit(1);
}
while (argc > 2) {
pthread_t thread;
pthread_create(&thread, 0, events_eater, argv[--argc]);
}
create_uinput();
if (ioctl(source_evdev_fd, EVIOCGRAB, 1) < 0) {
perror("EVIOCGRAB");
exit(1);
}
struct uinput_user_dev devinfo = {
.name = "repeater",
.id = {
.bustype = BUS_VIRTUAL,
.vendor = 0xffff,
.product = 0xffff,
.version = 1
}
};
write(uinput_fd, &devinfo, sizeof(devinfo));
xioctl(uinput_fd, UI_DEV_CREATE, 0);
struct input_event ev;
while (1) {
read_all(source_evdev_fd, &ev, sizeof(ev));
if (!translate_event(&ev))
continue;
write_event(&ev);
if (verbose)
putchar('\n');
}
}
int main(int argc, char *argv[]){
int parsed, n_read, n_written;
char outfile[FILENAME_MAX];
parsed=parser(argc, argv);
if(!parsed){
return 1;
}
/* tell us what you think you are doing */
print_parsed_info();
/* open input and output files */
fpin=fopen(cat_filename,"r");
if(fpin==NULL){
fprintf(stderr,"Cannot open %s for reading. Exiting.\n",cat_filename);
return 1;
}
sprintf(outfile,"%s.txt",basename);
fpout=fopen(outfile,"w");
if(fpout==NULL){
fprintf(stderr,"Cannot open %s for writing. Exiting.\n",outfile);
return 1;
}
/* sort out headers */
print_headers(argc, argv);
n_read=0;
n_written=0;
while(!feof(fpin)){
read_event();
n_read++;
if(check_criteria()){
write_event();
n_written++;
}
}
/* close files */
fclose(fpin);
fclose(fpout);
/* report */
printf("%d / %d events matched criteria\n", n_written, n_read);
return 0;
}
void execute_reset(int fd, uint32_t device_flags) {
print_action(ACTION_START, "reset", NULL);
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT) {
write_event(fd, EV_ABS, ABS_MT_POSITION_X, 0);
write_event(fd, EV_ABS, ABS_MT_POSITION_Y, 0);
write_event(fd, EV_ABS, ABS_MT_PRESSURE, 0);
write_event(fd, EV_ABS, ABS_MT_TOUCH_MAJOR, 0);
write_event(fd, EV_ABS, ABS_MT_WIDTH_MAJOR, 0);
} else if (device_flags & INPUT_DEVICE_CLASS_TOUCH) {
write_event(fd, EV_ABS, ABS_X, 0);
write_event(fd, EV_ABS, ABS_Y, 0);
}
print_action(ACTION_END, "reset", NULL);
}
/**
* The wrapper function for the fork system call.
*
* See fork manpage for description.
*/
pid_t fork() {
pid_t child = real_fork();
if ( child == 0 ) {
reinit_udi_rt();
} else {
uint64_t thread_id = get_user_thread_id();
udi_printf(">>> fork entry for 0x%"PRIx64"/%u\n",
get_user_thread_id(),
get_kernel_thread_id());
// Need to continue waiting until this thread owns the control of the process
int block_result = 1;
while (block_result > 0) {
block_result = block_other_threads();
if ( block_result == -1 ) {
udi_printf("%s\n", "failed to block other threads");
errno = EAGAIN;
return -1;
}
}
// create the event
udi_event_internal event = create_event_fork(thread_id, child);
do {
int errnum = write_event(&event);
if ( errnum != 0 ) {
udi_printf("failed to write fork event: %s\n", strerror(errnum));
errno = EAGAIN;
return -1;
}
} while(0);
wait_and_execute_command_with_response();
int release_result = release_other_threads();
if ( release_result != 0 ) {
udi_printf("%s\n", "failed to release other threads");
errno = EAGAIN;
return -1;
}
}
return child;
}
void GeneralWriter :: nextRow ( int table_id )
{
switch ( state )
{
case opened:
break;
default:
throw "state violation advancing to next row";
}
if ( table_id < 0 || ( size_t ) table_id > tables.size () )
throw "Invalid table id";
gwp_evt_hdr hdr;
init ( hdr, table_id, evt_next_row );
write_event ( & hdr, sizeof hdr );
}
void execute_release(int fd, uint32_t device_flags)
{
print_action(ACTION_START, "release", NULL);
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT) {
write_event(fd, EV_ABS, ABS_MT_PRESSURE,0);
write_event(fd, EV_ABS, ABS_MT_TOUCH_MAJOR, 0);
if (device_flags & INPUT_DEVICE_CLASS_TOUCH_MT_SYNC)
write_event(fd, EV_SYN, SYN_MT_REPORT, 0);
write_event(fd, EV_KEY, BTN_TOUCH, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
} else if (device_flags & INPUT_DEVICE_CLASS_TOUCH) {
write_event(fd, EV_KEY, BTN_TOUCH, 0);
write_event(fd, EV_SYN, SYN_REPORT, 0);
}
print_action(ACTION_END, "release", NULL);
}
void GeneralWriter :: moveAhead ( int table_id, uint64_t nrows )
{
switch ( state )
{
case opened:
break;
default:
throw "state violation moving ahead nrows";
}
if ( table_id < 0 || ( size_t ) table_id > tables.size () )
throw "Invalid table id";
gwp_move_ahead_evt_v1 hdr;
init ( hdr, table_id, evt_move_ahead );
set_nrows ( hdr, nrows );
write_event ( & hdr . dad, sizeof hdr );
}
/*!
* \brief Log events if configuration key logindividualevents is enabled or on exit
*
* \param chan Asterisk Channel
* \param signalling_type Signaling Type
* \param event Event Structure
* \param no_checksum Expecting messages without checksum
*
* \retval 0 success
* \retval -1 failure
*/
static int log_events(struct ast_channel *chan, char *signalling_type, event_node_t *event, int no_checksum)
{
char workstring[sizeof(event_spool_dir) + sizeof(event_file)] = "";
int fd;
FILE *logfile;
event_node_t *elp = event;
if (!ast_strlen_zero(event_spool_dir)) {
/* Make a template */
ast_copy_string(workstring, event_spool_dir, sizeof(workstring));
strncat(workstring, event_file, sizeof(workstring) - strlen(workstring) - 1);
/* Make the temporary file */
fd = mkstemp(workstring);
if (fd == -1) {
ast_verb(3, "AlarmReceiver: can't make temporary file\n");
ast_debug(1, "AlarmReceiver: can't make temporary file\n");
return -1;
}
if ((logfile = fdopen(fd, "w")) == NULL) {
return -1;
}
/* Write the file */
if (write_metadata(logfile, signalling_type, chan, no_checksum)) {
fflush(logfile);
fclose(logfile);
return -1;
}
while ((elp != NULL) && (write_event(logfile, elp) == 0)) {
elp = elp->next;
}
fflush(logfile);
fclose(logfile);
}
return 0;
}
void GeneralWriter :: setSoftwareName ( const std :: string & name,
const std :: string & version )
{
stream_state new_state = uninitialized;
switch ( state )
{
case header_written:
new_state = software_name_sent;
break;
case remote_name_sent:
new_state = remote_name_and_software_name_sent;
break;
case schema_sent:
new_state = schema_and_software_name_sent;
break;
case remote_name_and_schema_sent:
new_state = remote_name_schema_and_software_name_sent;
break;
default:
throw "state violation using schema";
}
size_t str1_size = name . size ();
if ( str1_size > 0x100 )
throw "name too long";
size_t str2_size = version . size ();
if ( str2_size > 0x100 )
throw "version too long";
gwp_2string_evt_v1 hdr;
init ( hdr, 0, evt_software_name );
set_size1 ( hdr, str1_size );
set_size2 ( hdr, str2_size );
write_event ( & hdr . dad, sizeof hdr );
internal_write ( name . data (), str1_size );
internal_write ( version . data (), str2_size );
state = new_state;
}
// tell the general-loader to use this pre-defined schema
void GeneralWriter :: useSchema ( const std :: string & schema_file_name,
const std :: string & schema_db_spec )
{
stream_state new_state = uninitialized;
switch ( state )
{
case header_written:
new_state = schema_sent;
break;
case remote_name_sent:
new_state = remote_name_and_schema_sent;
break;
case software_name_sent:
new_state = schema_and_software_name_sent;
break;
case remote_name_and_software_name_sent:
new_state = remote_name_schema_and_software_name_sent;
break;
default:
throw "state violation using schema";
}
size_t str1_size = schema_file_name . size ();
if ( str1_size > 0x10000 )
throw "schema path too long";
size_t str2_size = schema_db_spec . size ();
if ( str2_size > 0x10000 )
throw "schema spec too long";
gwp_2string_evt_U16 hdr;
init ( hdr, 0, evt_use_schema2 );
set_size1 ( hdr, str1_size );
set_size2 ( hdr, str2_size );
write_event ( & hdr . dad, sizeof hdr );
internal_write ( schema_file_name . data (), str1_size );
internal_write ( schema_db_spec . data (), str2_size );
state = new_state;
}
void GeneralWriter :: progMsg ( const std :: string & name, uint32_t version,
uint64_t done, uint64_t total )
{
switch ( state )
{
case opened:
break;
default:
return;
}
size_t str_size = name . size ();
if ( str_size == 0 )
throw "zero-length app-name";
if ( str_size > 0x100 )
str_size = 0x100;
// timestamp
time_t timestamp = time ( NULL );
if ( total == 0 )
throw "illegal total value: would divide by zero";
if ( done > total )
throw "illegal done value: greater than total";
// calculate percentage done
double fpercent = ( double ) done / total;
assert ( fpercent >= 0.0 && fpercent <= 100.0 );
uint8_t percent = ( uint8_t ) ( fpercent * 100 );
gwp_status_evt_v1 hdr;
init ( hdr, 0, evt_progmsg );
set_pid ( hdr, pid );
set_version ( hdr, version );
set_timestamp ( hdr, ( uint32_t ) timestamp );
set_size ( hdr, str_size );
set_percent ( hdr, percent );
write_event ( &hdr . dad, sizeof hdr );
internal_write ( name.data (), str_size );
}
/**
* Handle the occurence of a hit on the exit breakpoint. This includes gathering all information
* neccessary to create the exit event.
*
* @param context the context for the breakpoint
* @param errmsg the error message populated on error
*
* @return the information extracted about the exit event
*/
static
event_result handle_exit_breakpoint(const ucontext_t *context, udi_errmsg *errmsg) {
event_result result;
result.failure = 0;
result.wait_for_request = 1;
exit_result exit_result = get_exit_argument(context, errmsg);
if ( exit_result.failure ) {
result.failure = exit_result.failure;
return result;
}
udi_printf("exit entered with status %d\n", exit_result.status);
exiting = 1;
// create the event
udi_event_internal exit_event = create_event_exit(get_user_thread_id(), exit_result.status);
do {
if ( exit_event.packed_data == NULL ) {
result.failure = 1;
break;
}
result.failure = write_event(&exit_event);
udi_free(exit_event.packed_data);
} while(0);
if ( result.failure ) {
udi_printf("failed to report exit status of %d\n", exit_result.status);
} else {
if ( udi_debug_on ) {
dump_heap();
}
}
return result;
}
