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

518
exec_tracker.c
View File

@@ -13,382 +13,376 @@
#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 void free_null_terminated_pointer_array(char **ptr); static char **filenames_in_path_envvar(size_t *return_len);
static void print_event(uint32_t event); static void free_null_terminated_pointer_array(char **ptr);
static void save_result(char **filenames, int* counter, size_t arr_len); static void print_event(uint32_t event);
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;
size_t files_len; size_t files_len;
switch (argc) { switch (argc) {
case 1: case 1:
file_names = filenames_in_path_envvar(&files_len); file_names = filenames_in_path_envvar(&files_len);
break; break;
case 2: case 2:
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)
err(EXIT_FAILURE, "Error when finding files"); err(EXIT_FAILURE, "Error when finding files");
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)
err(EXIT_FAILURE, "Failed to initialize inotify instance");
if ( inotify_instance == -1 )
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)
err(EXIT_FAILURE, "Failed to allocate %zu bytes for watch descriptors",
files_len * sizeof(int));
if( watched == NULL ) for (size_t i = 0; file_names[i] != NULL; i++) {
err(EXIT_FAILURE, "Failed to allocate %zu bytes for watch descriptors", files_len*sizeof(int)); watched[i] =
inotify_add_watch(inotify_instance, file_names[i], IN_ACCESS);
for(size_t i=0; file_names[i] != NULL; i++) { if (watched[i] == -1)
watched[i] = inotify_add_watch(inotify_instance, file_names[i], IN_ACCESS); err(EXIT_FAILURE, "Cannot watch %s", file_names[i]);
}
if(watched[i] == -1) /* Prepare for polling */
err(EXIT_FAILURE, "Cannot watch %s", file_names[i]);
}
struct pollfd poll_fds[2];
nfds_t fd_count = 2;
/* Prepare for polling */ poll_fds[0].fd = STDIN_FILENO;
poll_fds[0].events = POLLIN;
struct pollfd poll_fds[2]; poll_fds[1].fd = inotify_instance;
nfds_t fd_count = 2; poll_fds[1].events = POLLIN;
poll_fds[0].fd = STDIN_FILENO; /* Wait for events and/or terminal input */
poll_fds[0].events = POLLIN;
poll_fds[1].fd = inotify_instance; int poll_num;
poll_fds[1].events = POLLIN;
fprintf(stderr, "Listening for events... (Press enter to end)\n");
/* Wait for events and/or terminal input */ while (1) {
poll_num = poll(poll_fds, fd_count, -1);
int poll_num; if (poll_num == -1 && errno != EINTR)
err(EXIT_FAILURE, "Failed to poll");
fprintf(stderr, "Listening for events... (Press enter to end)\n"); if (poll_num == 0)
continue;
while (1) { if (poll_fds[0].revents & POLLIN) {
poll_num = poll(poll_fds, fd_count, -1); char c;
while (read(STDIN_FILENO, &c, 1) > 0 && c != '\n')
if( poll_num == -1 && errno != EINTR) /* noop */;
err(EXIT_FAILURE, "Failed to poll"); save_result(file_names, use_counter, files_len);
break;
}
if (poll_num == 0) if (poll_fds[1].revents & POLLIN) {
continue; handle_event(inotify_instance, watched, file_names, use_counter,
files_len);
}
}
if (poll_fds[0].revents & POLLIN) { close(inotify_instance);
char c;
while (read(STDIN_FILENO, &c, 1) > 0 && c != '\n')
/* noop */;
save_result(file_names, use_counter, files_len);
break;
}
if( poll_fds[1].revents & POLLIN ) {
handle_event(inotify_instance, watched, file_names, use_counter, files_len);
}
}
free_null_terminated_pointer_array(file_names);
close(inotify_instance); free(watched);
free(use_counter);
free_null_terminated_pointer_array(file_names);
free(watched);
free(use_counter);
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;
path = strdup(getenv("PATH"));
saveptr = NULL; path = strdup(getenv("PATH"));
output_size = 1024;
output = malloc(output_size * sizeof(char*));
if (output == NULL) { saveptr = NULL;
warn("Failed to allocate %zu bytes", output_size); output_size = 1024;
return NULL; output = malloc(output_size * sizeof(char *));
}
token = strtok_r(path, ":", &saveptr); if (output == NULL) {
warn("Failed to allocate %zu bytes", output_size);
return NULL;
}
i = 0; token = strtok_r(path, ":", &saveptr);
while (token != NULL) {
n_files = 0;
filenames = filenames_in_dir(token, &n_files);
n_files -= 1;
if ( filenames == NULL ) { i = 0;
fprintf(stderr, "failed to get filenames in %s\n", token); while (token != NULL) {
token = strtok_r(NULL, ":", &saveptr); n_files = 0;
continue; filenames = filenames_in_dir(token, &n_files);
} n_files -= 1;
if (i + n_files > output_size) { if (filenames == NULL) {
while(i + n_files > output_size) fprintf(stderr, "failed to get filenames in %s\n", token);
output_size *= 2; token = strtok_r(NULL, ":", &saveptr);
continue;
}
tmp = realloc(output, output_size * sizeof(char*)); if (i + n_files > output_size) {
while (i + n_files > output_size)
output_size *= 2;
if (tmp == NULL) { tmp = realloc(output, output_size * sizeof(char *));
warn("failed to reallocate %zu bytes", output_size * sizeof(char*));
return NULL;
}
output = (char**) tmp; if (tmp == NULL) {
} warn("failed to reallocate %zu bytes",
output_size * sizeof(char *));
return NULL;
}
memcpy(output+i, filenames, n_files * sizeof(char*)); output = (char **)tmp;
i += n_files; }
free(filenames); memcpy(output + i, filenames, n_files * sizeof(char *));
i += n_files;
token = strtok_r(NULL, ":", &saveptr); free(filenames);
}
output_size = i + 1;
tmp = realloc(output, output_size * sizeof(char*));
if (tmp != NULL){ token = strtok_r(NULL, ":", &saveptr);
output = (char**)tmp; }
} output_size = i + 1;
tmp = realloc(output, output_size * sizeof(char *));
output[i] = NULL; if (tmp != NULL) {
output = (char **)tmp;
}
free(path); output[i] = NULL;
*return_len = output_size; free(path);
return output; *return_len = output_size;
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 = malloc(result_size * sizeof(char*));
if( result == NULL ){ result_size = 64;
warn("Failed to malloc %zu bytes", result_size); result = malloc(result_size * sizeof(char *));
return NULL;
} if (result == NULL) {
warn("Failed to malloc %zu bytes", result_size);
return NULL;
}
directory_stream = opendir(path); directory_stream = opendir(path);
if (directory_stream == NULL) { if (directory_stream == NULL) {
warn("Failed to open directory %s", path); warn("Failed to open directory %s", path);
goto fail; goto fail;
} }
n_items = 0; n_items = 0;
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(
result[n_items] = strcat(result[n_items], path); strlen(path) + strlen(dir_entity->d_name) + 2, sizeof(char));
result[n_items] = strcat(result[n_items], "/"); result[n_items] = strcat(result[n_items], path);
result[n_items] = strcat(result[n_items], dir_entity->d_name); result[n_items] = strcat(result[n_items], "/");
n_items += 1; result[n_items] = strcat(result[n_items], dir_entity->d_name);
} n_items += 1;
}
// 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;
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;
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;
} }
} }
} }
} }
/* 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;
savefile = fopen("uses.log", "w"); savefile = fopen("uses.log", "w");
if (savefile == NULL) { if (savefile == NULL) {
warn("Failed to save to file"); warn("Failed to save to file");
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);
} }