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; }