olemorud/execution-counter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add clang-format

Browse Source
This commit is contained in:
olemorud
2023-03-20 11:07:25 +01:00
parent c372ead127
commit 9295a9445c
2 changed files with 264 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.clang-format Normal file
View File

@@ -0,0 +1,8 @@
---
BasedOnStyle: LLVM
IndentWidth: 4
UseTab: Never
BreakBeforeBraces: Linux
AllowShortIfStatementsOnASingleLine: false
IndentCaseLabels: false
---

196
exec_tracker.c
View File

@@ -13,19 +13,19 @@
#define BUFFER_LEN 4096 #define BUFFER_LEN 4096
static void handle_event(int inotify_instance, int *watched, char **filenames, int *counter, size_t watched_len); static void handle_event(int inotify_instance, int *watched, char **filenames,
static char** filenames_in_dir(char *path, size_t *return_len); int *counter, size_t watched_len);
static char** filenames_in_path_envvar(size_t *return_len); static char **filenames_in_dir(char *path, size_t *return_len);
static char **filenames_in_path_envvar(size_t *return_len);
static void free_null_terminated_pointer_array(char **ptr); static void free_null_terminated_pointer_array(char **ptr);
static void print_event(uint32_t event); static void print_event(uint32_t event);
static void save_result(char **filenames, int* counter, size_t arr_len); static void save_result(char **filenames, int *counter, size_t arr_len);
/* This code is a bit over-commented in general */ /* This code is a bit over-commented in general */
int int main(int argc, char *const argv[])
main(int argc, char * const argv[])
{ {
/* Get null terminated list of files to watch, create counter of same size */ /* Get null terminated list of files to watch, create counter of same size
*/
char **file_names; char **file_names;
int *use_counter, *watched; int *use_counter, *watched;
@@ -39,7 +39,10 @@ main(int argc, char * const argv[])
file_names = filenames_in_dir(argv[1], &files_len); file_names = filenames_in_dir(argv[1], &files_len);
break; break;
default: default:
errx(EXIT_FAILURE, "Usage: `%s <dir>`. If dir is empty, directories in PATH will be monitored", argv[0]); errx(EXIT_FAILURE,
"Usage: `%s <dir>`. If dir is empty, directories in PATH will be "
"monitored",
argv[0]);
} }
if (file_names == NULL) if (file_names == NULL)
@@ -47,33 +50,33 @@ main(int argc, char * const argv[])
use_counter = calloc(files_len, sizeof(int)); use_counter = calloc(files_len, sizeof(int));
if( use_counter == NULL ) if (use_counter == NULL)
err(EXIT_FAILURE, "Failed to allocate %zu bytes for use counter", files_len*sizeof(int)); err(EXIT_FAILURE, "Failed to allocate %zu bytes for use counter",
files_len * sizeof(int));
/* Create file descriptor for accessing the inotify API */ /* Create file descriptor for accessing the inotify API */
int inotify_instance = inotify_init(); int inotify_instance = inotify_init();
if ( inotify_instance == -1 ) if (inotify_instance == -1)
err(EXIT_FAILURE, "Failed to initialize inotify instance"); err(EXIT_FAILURE, "Failed to initialize inotify instance");
/* Mark files for events */ /* Mark files for events */
watched = calloc(files_len, sizeof(int)); watched = calloc(files_len, sizeof(int));
if( watched == NULL ) if (watched == NULL)
err(EXIT_FAILURE, "Failed to allocate %zu bytes for watch descriptors", files_len*sizeof(int)); err(EXIT_FAILURE, "Failed to allocate %zu bytes for watch descriptors",
files_len * sizeof(int));
for(size_t i=0; file_names[i] != NULL; i++) { for (size_t i = 0; file_names[i] != NULL; i++) {
watched[i] = inotify_add_watch(inotify_instance, file_names[i], IN_ACCESS); watched[i] =
inotify_add_watch(inotify_instance, file_names[i], IN_ACCESS);
if(watched[i] == -1) if (watched[i] == -1)
err(EXIT_FAILURE, "Cannot watch %s", file_names[i]); err(EXIT_FAILURE, "Cannot watch %s", file_names[i]);
} }
/* Prepare for polling */ /* Prepare for polling */
struct pollfd poll_fds[2]; struct pollfd poll_fds[2];
@@ -85,7 +88,6 @@ main(int argc, char * const argv[])
poll_fds[1].fd = inotify_instance; poll_fds[1].fd = inotify_instance;
poll_fds[1].events = POLLIN; poll_fds[1].events = POLLIN;
/* Wait for events and/or terminal input */ /* Wait for events and/or terminal input */
int poll_num; int poll_num;
@@ -95,7 +97,7 @@ main(int argc, char * const argv[])
while (1) { while (1) {
poll_num = poll(poll_fds, fd_count, -1); poll_num = poll(poll_fds, fd_count, -1);
if( poll_num == -1 && errno != EINTR) if (poll_num == -1 && errno != EINTR)
err(EXIT_FAILURE, "Failed to poll"); err(EXIT_FAILURE, "Failed to poll");
if (poll_num == 0) if (poll_num == 0)
@@ -109,12 +111,12 @@ main(int argc, char * const argv[])
break; break;
} }
if( poll_fds[1].revents & POLLIN ) { if (poll_fds[1].revents & POLLIN) {
handle_event(inotify_instance, watched, file_names, use_counter, files_len); handle_event(inotify_instance, watched, file_names, use_counter,
files_len);
} }
} }
close(inotify_instance); close(inotify_instance);
free_null_terminated_pointer_array(file_names); free_null_terminated_pointer_array(file_names);
@@ -124,24 +126,21 @@ main(int argc, char * const argv[])
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
/* Free allocated memory pointed to by pointers /* Free allocated memory pointed to by pointers
in 'ptr', then free 'ptr' itself */ in 'ptr', then free 'ptr' itself */
static void static void free_null_terminated_pointer_array(char **ptr)
free_null_terminated_pointer_array(char **ptr)
{ {
for(char **p = ptr; *p != NULL; p++ ){ for (char **p = ptr; *p != NULL; p++) {
free(*p); free(*p);
} }
free(ptr); free(ptr);
} }
/* Returns a null terminated array of strings /* Returns a null terminated array of strings
for every file in PATH */ for every file in PATH */
static char** static char **filenames_in_path_envvar(size_t *return_len)
filenames_in_path_envvar(size_t *return_len) { {
size_t n_files, i, output_size; size_t n_files, i, output_size;
char **filenames, **output, *saveptr, *path, *token; char **filenames, **output, *saveptr, *path, *token;
void *tmp; void *tmp;
@@ -150,7 +149,7 @@ filenames_in_path_envvar(size_t *return_len) {
saveptr = NULL; saveptr = NULL;
output_size = 1024; output_size = 1024;
output = malloc(output_size * sizeof(char*)); output = malloc(output_size * sizeof(char *));
if (output == NULL) { if (output == NULL) {
warn("Failed to allocate %zu bytes", output_size); warn("Failed to allocate %zu bytes", output_size);
@@ -165,27 +164,28 @@ filenames_in_path_envvar(size_t *return_len) {
filenames = filenames_in_dir(token, &n_files); filenames = filenames_in_dir(token, &n_files);
n_files -= 1; n_files -= 1;
if ( filenames == NULL ) { if (filenames == NULL) {
fprintf(stderr, "failed to get filenames in %s\n", token); fprintf(stderr, "failed to get filenames in %s\n", token);
token = strtok_r(NULL, ":", &saveptr); token = strtok_r(NULL, ":", &saveptr);
continue; continue;
} }
if (i + n_files > output_size) { if (i + n_files > output_size) {
while(i + n_files > output_size) while (i + n_files > output_size)
output_size *= 2; output_size *= 2;
tmp = realloc(output, output_size * sizeof(char*)); tmp = realloc(output, output_size * sizeof(char *));
if (tmp == NULL) { if (tmp == NULL) {
warn("failed to reallocate %zu bytes", output_size * sizeof(char*)); warn("failed to reallocate %zu bytes",
output_size * sizeof(char *));
return NULL; return NULL;
} }
output = (char**) tmp; output = (char **)tmp;
} }
memcpy(output+i, filenames, n_files * sizeof(char*)); memcpy(output + i, filenames, n_files * sizeof(char *));
i += n_files; i += n_files;
free(filenames); free(filenames);
@@ -193,10 +193,10 @@ filenames_in_path_envvar(size_t *return_len) {
token = strtok_r(NULL, ":", &saveptr); token = strtok_r(NULL, ":", &saveptr);
} }
output_size = i + 1; output_size = i + 1;
tmp = realloc(output, output_size * sizeof(char*)); tmp = realloc(output, output_size * sizeof(char *));
if (tmp != NULL){ if (tmp != NULL) {
output = (char**)tmp; output = (char **)tmp;
} }
output[i] = NULL; output[i] = NULL;
@@ -208,22 +208,20 @@ filenames_in_path_envvar(size_t *return_len) {
return output; return output;
} }
/* Returns null terminated array /* Returns null terminated array
of filepaths in directory */ of filepaths in directory */
static char** static char **filenames_in_dir(char *path, size_t *return_len)
filenames_in_dir(char *path, size_t *return_len)
{ {
size_t result_size, n_items=0; size_t result_size, n_items = 0;
char **result; char **result;
void *tmp; void *tmp;
struct dirent *dir_entity; struct dirent *dir_entity;
DIR *directory_stream; DIR *directory_stream;
result_size = 64; result_size = 64;
result = malloc(result_size * sizeof(char*)); result = malloc(result_size * sizeof(char *));
if( result == NULL ){ if (result == NULL) {
warn("Failed to malloc %zu bytes", result_size); warn("Failed to malloc %zu bytes", result_size);
return NULL; return NULL;
} }
@@ -239,13 +237,14 @@ filenames_in_dir(char *path, size_t *return_len)
errno = 0; // To distinguish end of stream from an error, errno = 0; // To distinguish end of stream from an error,
// set errno to zero before calling readdir() // set errno to zero before calling readdir()
while ((dir_entity = readdir(directory_stream)) != NULL) { while ((dir_entity = readdir(directory_stream)) != NULL) {
if(n_items >= result_size){ if (n_items >= result_size) {
result_size *= 2; result_size *= 2;
result = realloc(result, result_size * sizeof(char*)); result = realloc(result, result_size * sizeof(char *));
} }
if (dir_entity->d_type == DT_REG ) { if (dir_entity->d_type == DT_REG) {
result[n_items] = calloc(strlen(path) + strlen(dir_entity->d_name) + 2, sizeof(char)); result[n_items] = calloc(
strlen(path) + strlen(dir_entity->d_name) + 2, sizeof(char));
result[n_items] = strcat(result[n_items], path); result[n_items] = strcat(result[n_items], path);
result[n_items] = strcat(result[n_items], "/"); result[n_items] = strcat(result[n_items], "/");
result[n_items] = strcat(result[n_items], dir_entity->d_name); result[n_items] = strcat(result[n_items], dir_entity->d_name);
@@ -254,24 +253,24 @@ filenames_in_dir(char *path, size_t *return_len)
// dirent *dir_entity is statically allocated, dont free()! // dirent *dir_entity is statically allocated, dont free()!
} }
result_size = n_items+1; result_size = n_items + 1;
tmp = realloc(result, result_size * sizeof(char*)); tmp = realloc(result, result_size * sizeof(char *));
if ( tmp == NULL ) { if (tmp == NULL) {
warn("Failed to realloc %zu bytes", result_size); warn("Failed to realloc %zu bytes", result_size);
return NULL; return NULL;
} }
result = (char**)tmp; result = (char **)tmp;
result[n_items] = NULL; result[n_items] = NULL;
if ( errno != 0 ){ if (errno != 0) {
warn("Error when reading directory %s", path); warn("Error when reading directory %s", path);
goto fail; goto fail;
} }
if ( closedir(directory_stream) == -1 ) if (closedir(directory_stream) == -1)
warn("Failed to close directory"); warn("Failed to close directory");
*return_len = result_size; *return_len = result_size;
@@ -279,12 +278,12 @@ filenames_in_dir(char *path, size_t *return_len)
return result; return result;
fail: fail:
for(size_t i=0; i<n_items; i++){ for (size_t i = 0; i < n_items; i++) {
free(result[i]); free(result[i]);
} }
free(result); free(result);
if ( closedir(directory_stream) == -1 ) if (closedir(directory_stream) == -1)
warn("Failed to close directory"); warn("Failed to close directory");
*return_len = 0; *return_len = 0;
@@ -292,33 +291,33 @@ fail:
return NULL; return NULL;
} }
/* Read all available inotify events from /* Read all available inotify events from
file descriptor 'inotify_instance' */ file descriptor 'inotify_instance' */
static void static void handle_event(int inotify_instance, int *watched, char **filenames,
handle_event(int inotify_instance, int *watched, char **filenames, int *counter, size_t watched_len) int *counter, size_t watched_len)
{ {
ssize_t length; ssize_t length;
const struct inotify_event *event; const struct inotify_event *event;
char buffer[BUFFER_LEN] char buffer[BUFFER_LEN]
__attribute__ ((aligned(__alignof__(struct inotify_event)))); __attribute__((aligned(__alignof__(struct inotify_event))));
length = read(inotify_instance, buffer, BUFFER_LEN); length = read(inotify_instance, buffer, BUFFER_LEN);
if( length == -1 && errno != EAGAIN) { if (length == -1 && errno != EAGAIN) {
warn("Failed to read inotify event"); warn("Failed to read inotify event");
return; return;
} }
if (length == 0){ if (length == 0) {
return; return;
} }
for (char *p = buffer; p < buffer+length; p += sizeof(struct inotify_event) + event->len) { for (char *p = buffer; p < buffer + length;
event = (struct inotify_event *) p; p += sizeof(struct inotify_event) + event->len) {
event = (struct inotify_event *)p;
for (int i=0; i < watched_len; i++) { for (int i = 0; i < watched_len; i++) {
if( watched[i] == event->wd ) { if (watched[i] == event->wd) {
fprintf(stderr, "%s ", filenames[i]); fprintf(stderr, "%s ", filenames[i]);
counter[i] += 1; counter[i] += 1;
break; break;
@@ -327,51 +326,47 @@ handle_event(int inotify_instance, int *watched, char **filenames, int *counter,
} }
} }
/* Prints event mask values in a human-readable format */ /* Prints event mask values in a human-readable format */
static void static void print_event(uint32_t event)
print_event(uint32_t event)
{ {
if(event & IN_ACCESS){ if (event & IN_ACCESS) {
fprintf(stderr,"IN_ACCESS "); fprintf(stderr, "IN_ACCESS ");
} }
if(event & IN_ATTRIB){ if (event & IN_ATTRIB) {
fprintf(stderr,"IN_ATTRIB "); fprintf(stderr, "IN_ATTRIB ");
} }
if(event & IN_CLOSE_WRITE){ if (event & IN_CLOSE_WRITE) {
fprintf(stderr,"IN_CLOSE_WRITE "); fprintf(stderr, "IN_CLOSE_WRITE ");
} }
if(event & IN_CLOSE_NOWRITE){ if (event & IN_CLOSE_NOWRITE) {
fprintf(stderr,"IN_CLOSE_NOWRITE "); fprintf(stderr, "IN_CLOSE_NOWRITE ");
} }
if(event & IN_CREATE){ if (event & IN_CREATE) {
fprintf(stderr,"IN_CREATE "); fprintf(stderr, "IN_CREATE ");
} }
if(event & IN_DELETE){ if (event & IN_DELETE) {
fprintf(stderr,"IN_DELETE "); fprintf(stderr, "IN_DELETE ");
} }
if(event & IN_DELETE_SELF){ if (event & IN_DELETE_SELF) {
fprintf(stderr,"IN_DELETE_SELF "); fprintf(stderr, "IN_DELETE_SELF ");
} }
if(event & IN_MODIFY){ if (event & IN_MODIFY) {
fprintf(stderr,"IN_MODIFY "); fprintf(stderr, "IN_MODIFY ");
} }
if(event & IN_MOVE_SELF){ if (event & IN_MOVE_SELF) {
fprintf(stderr,"IN_MOVE_SELF "); fprintf(stderr, "IN_MOVE_SELF ");
} }
if(event & IN_MOVED_FROM){ if (event & IN_MOVED_FROM) {
fprintf(stderr,"IN_MOVED_FROM "); fprintf(stderr, "IN_MOVED_FROM ");
} }
if(event & IN_OPEN){ if (event & IN_OPEN) {
fprintf(stderr,"IN_OPEN "); fprintf(stderr, "IN_OPEN ");
} }
} }
/* Saves number of recorded events for each /* Saves number of recorded events for each
executable t 'uses.log' */ executable t 'uses.log' */
static void static void save_result(char **filenames, int *counter, size_t arr_len)
save_result(char **filenames, int* counter, size_t arr_len)
{ {
FILE *savefile; FILE *savefile;
@@ -382,13 +377,12 @@ save_result(char **filenames, int* counter, size_t arr_len)
return; return;
} }
for (size_t i=0; i<arr_len; i++) { for (size_t i = 0; i < arr_len; i++) {
if (counter[i] == 0) if (counter[i] == 0)
continue; continue;
fprintf(stdout, "%d %s\n", counter[i], filenames[i]); // fprintf(stdout, "%d %s\n", counter[i], filenames[i]);
} }
fclose(savefile); fclose(savefile);
} }