444 lines
12 KiB
C
444 lines
12 KiB
C
/**
|
|
* file: lslib.h
|
|
* author: Tyler Murphy
|
|
*/
|
|
|
|
#ifndef SHARED_H
|
|
#define SHARED_H
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <sys/stat.h>
|
|
#include <pwd.h>
|
|
|
|
/* create define flags to be used with color anscii codes */
|
|
#define ANSCII "\x1b[" /* anscii start escape code */
|
|
#define NEXT ";" /* anscii seperator */
|
|
|
|
#define RESET "0"
|
|
#define BOLD "1"
|
|
|
|
#define NORMAL "3"
|
|
#define BACKGROUND "4"
|
|
#define HIGHLIGHT "9"
|
|
|
|
#define BLACK "0"
|
|
#define RED "1"
|
|
#define GREEN "2"
|
|
#define YELLOW "3"
|
|
#define BLUE "4"
|
|
#define MAGENTA "5"
|
|
#define TURQUOISE "6"
|
|
#define WHITE "7"
|
|
|
|
#define COLOR "m" /* color anscii code */
|
|
|
|
/**
|
|
* Define bool cause c89 dont have it
|
|
*/
|
|
typedef uint8_t bool;
|
|
#define true 1
|
|
#define false 0
|
|
|
|
/* mark argument unused */
|
|
#define UNUSED(x) (void)(x)
|
|
|
|
/*
|
|
* Flags to return from parse_args fn pointers
|
|
*/
|
|
#define ARG_UNUSED 0 /* state that the next char* wasnt used */
|
|
#define ARG_USED 1 /* state that the next char* was used */
|
|
#define ARG_IGNORE 2 /* stop parsing arguments */
|
|
#define ARG_INVALID 3 /* print error message and die */
|
|
|
|
/*
|
|
* Die is argument is null
|
|
* @param arg argument to check
|
|
*/
|
|
void check_arg (char* arg);
|
|
|
|
/**
|
|
* Print help message with lazysphere title then exit
|
|
* @param help fn pointer to call to display fn specific help msg
|
|
*/
|
|
void global_help(void (*help)(void));
|
|
|
|
/**
|
|
* Parse arguments and only check for --help message otherwise do nothing
|
|
* @param argc argument count
|
|
* @param argv argument data
|
|
* @param help fn pointer to call and display fn specific help msg
|
|
*/
|
|
void parse_help (int argc, char** argv, void (*help)(void));
|
|
|
|
/**
|
|
* Parse arguments with given short and long arg pointers, and call help fn if --help supplied
|
|
* @param argv argument count
|
|
* @param argv argument data
|
|
* @param help fn pointer to call and display fn specific help msg
|
|
* @param short_arg fn pointer to check char after a -, 2nd char* is the next unparsed argv for something like -s [str]
|
|
* @param long_arg fn pointer to check string after a --, 2nd char* is the next unparsed argv for something like --string [str]
|
|
* @returns argc where arguments ended
|
|
*/
|
|
int parse_args (int argc, char** argv, void (*help)(void), int (*short_arg)(char, char*), int (*long_arg)(char*, char*));
|
|
|
|
/*
|
|
* Open a file with a given path and type, and print error if failed
|
|
* @param path the path to the file
|
|
* @param type the mode to open the file with
|
|
* @return the file pointer if opened, NULL if failed
|
|
*/
|
|
FILE* get_file_s(const char* path, const char* type);
|
|
|
|
/*
|
|
* Open a file with a given path and type, and print error and die if failed
|
|
* @param path the path to the file
|
|
* @param type the mode to open the file with
|
|
* @return the file pointer
|
|
*/
|
|
FILE* get_file(const char* path, const char* type);
|
|
|
|
/**
|
|
* Open a tty and error and die if failed
|
|
* @return the file descripter to the tty
|
|
*/
|
|
int get_tty(void);
|
|
|
|
/**
|
|
* Open a tty stream with the given mode and error and die if failed
|
|
* @param type the mode to open the tty with
|
|
* @return the file pointer to the tty
|
|
*/
|
|
FILE* get_tty_stream(char* type);
|
|
|
|
/**
|
|
* Get a reference to the first path buffer
|
|
* @return the pointer to the first path buffer
|
|
*/
|
|
char* get_path_buffer(void);
|
|
|
|
/**
|
|
* Push a string to the first path buffer, a / as added before string if it doesnt allready exist at the end
|
|
* @param stirng the local file path to push to the first path buffer
|
|
* @return the integer index to revert to then done
|
|
*/
|
|
int push_path_buffer(const char* string);
|
|
|
|
/**
|
|
* Revert the first path buffer to the index provided by push_path_buffer
|
|
* @param i the index to revert to
|
|
*/
|
|
void pop_path_buffer(int i);
|
|
|
|
/**
|
|
* Get a reference to the second path buffer
|
|
* @return the pointer to the second path buffer
|
|
*/
|
|
char* get_path_buffer_2(void);
|
|
|
|
/**
|
|
* Push a string to the second path buffer, a / as added before string if it doesnt allready exist at the end
|
|
* @param stirng the local file path to push to the first path buffer
|
|
* @return the integer index to revert to then done
|
|
*/
|
|
int push_path_buffer_2(const char* string);
|
|
|
|
/**
|
|
* Revert the second path buffer to the index provided by push_path_buffer_2
|
|
* @param i the index to revert to
|
|
*/
|
|
void pop_path_buffer_2(int i);
|
|
|
|
/**
|
|
* Get a base 10 number from a string and error and die if failed
|
|
* @param text the string that contains the number
|
|
* @return the parsed integer if successfull
|
|
*/
|
|
long int get_number(const char* text);
|
|
|
|
/**
|
|
* Get a blkm (1024m, 38b, 26G) from a string and error and die if failed
|
|
* @param text the string that contains the blkm
|
|
* @return the blkm in bytes if successfull
|
|
*/
|
|
long int get_blkm(const char* text);
|
|
|
|
/**
|
|
* Get a mode_t from a string and error and die if failed
|
|
* @param text the string that contains the mode_t
|
|
* @return the mode_t if successfull
|
|
*/
|
|
mode_t get_mode(const char* text);
|
|
|
|
/**
|
|
* Check if two strings are exactly equal
|
|
* @param a null terminated string a
|
|
* @param b null terminated string b
|
|
* @returns true if the two strings are exactly equal else false
|
|
*/
|
|
bool streql(const char* a, const char* b);
|
|
|
|
/**
|
|
* Check if a string has a given prefix
|
|
* @param pre the null terminated prefix
|
|
* @param str the null terminated string
|
|
* @returns true if str is prefixed with pre else false
|
|
*/
|
|
bool prefix(const char* pre, const char* str);
|
|
|
|
/**
|
|
* Put a human redable file size (1024M) into buf with the given byte count
|
|
* @param bytes the byte count
|
|
* @param buf a char buf of length 5 to contain the parsed size
|
|
*/
|
|
void print_file_size(size_t bytes, char buf[5]);
|
|
|
|
/**
|
|
* Put a human redable date into buf with the given mills since unix epoch
|
|
* @param mills mills since the unix epoch
|
|
* @param buf a char buf of length 13 to contain the parsed date
|
|
*/
|
|
void print_date_time(time_t mills, char buf[13]);
|
|
|
|
/**
|
|
* Print a given file path to stdout or (standard input) if '-'
|
|
* @param path the file path
|
|
*/
|
|
void print_file_path(char* path);
|
|
|
|
/**
|
|
* Nuke a given string in memory
|
|
* @param the stirng to nuke
|
|
*/
|
|
void nuke_str(char* type);
|
|
|
|
/**
|
|
* Checks if a given character is printable symbol
|
|
* @returns if its printable
|
|
*/
|
|
bool printable_char(char c);
|
|
|
|
/**
|
|
* Checks if a directory name is . or ..
|
|
* @param path the directory name
|
|
* @return if a directory is one of the . or .. directorys
|
|
*/
|
|
bool is_dot_dir(const char* path);
|
|
|
|
/**
|
|
* Get the last component of a path
|
|
* @param path the path to parse
|
|
* @return a const reference to the last component
|
|
*/
|
|
const char* get_last_component(const char* path);
|
|
|
|
/**
|
|
* Die
|
|
*/
|
|
void die (void);
|
|
|
|
/**
|
|
* Print error message to stdout
|
|
* @param format the format string
|
|
* @param ... the rest of the arguments
|
|
*/
|
|
__attribute__ ((__format__(printf, 1, 2)))
|
|
void error_s(const char* format, ...);
|
|
|
|
/**
|
|
* Print error message to stdout and die
|
|
* @param format the format string
|
|
* @param ... the rest of the arguments
|
|
*/
|
|
__attribute__ ((__format__(printf, 1, 2)))
|
|
void error(const char* format, ...);
|
|
|
|
/**
|
|
* Output message as the given command
|
|
* @param format the format string
|
|
* @param ... the rest of the arguments
|
|
*/
|
|
__attribute__ ((__format__(printf, 1, 2)))
|
|
void output(const char* format, ...);
|
|
|
|
/**
|
|
* Refine the regex as a ADT
|
|
*/
|
|
typedef struct regex_t* re_t;
|
|
|
|
/**
|
|
* Compile a given regex pattern
|
|
* @param pattern the regex to compile
|
|
* @return the compiled regex
|
|
*/
|
|
re_t re_compile(const char* pattern);
|
|
|
|
/**
|
|
* Match a given regex pattern with the string
|
|
* @param pattern the pattern to match with
|
|
* @param text the text to match
|
|
* @param matchlength a pointer to how much was matched
|
|
* @return the index where the match was found, -1 if nothing matched
|
|
*/
|
|
int re_matchp(re_t pattern, const char* text, int* matchlength);
|
|
|
|
/**
|
|
* Compile and match a given regex pattern with the string
|
|
* @param pattern the pattern to compile and match with
|
|
* @param text the text to match
|
|
* @param matchlength a pointer to how much was matched
|
|
* @return the index where the match was found, -1 if nothing matched
|
|
*/
|
|
int re_match(const char* pattern, const char* text, int* matchlength);
|
|
|
|
/**
|
|
* A struct containing a stack
|
|
*/
|
|
struct Stack {
|
|
size_t size; /* The size of the stack */
|
|
size_t capacity; /* The capacity of the stack */
|
|
void* data; /* THe data stored in the stack */
|
|
};
|
|
|
|
/**
|
|
* Initalize a stack with a given size
|
|
* @param stack a allocated stack struct to inatalize
|
|
* @param size the initial stack capacity
|
|
*/
|
|
void stack_init(struct Stack* stack, size_t size);
|
|
|
|
/**
|
|
* Push data to the stack
|
|
* @param stack the stack to push to
|
|
* @param data the data to push
|
|
* @param len the length of the data to push
|
|
*/
|
|
void stack_push(struct Stack* stack, void* data, size_t len);
|
|
|
|
/**
|
|
* Pop the data from the stack (move the pointer back by len doesn't delete)
|
|
* @param stack the stack to pop from
|
|
* @param len the length of the data to pop
|
|
* @return the pointer to the data popped (not yet destroyed until pushed)
|
|
*/
|
|
void* stack_pop(struct Stack* stack, size_t len);
|
|
|
|
/**
|
|
* Free a stacks allocated memory
|
|
* @param stack the stack to free
|
|
*/
|
|
void stack_free(struct Stack* stack);
|
|
|
|
/**
|
|
* Wrapper function to push a int to the stack
|
|
* @param stack the stack to push to
|
|
* @param value the int to push
|
|
*/
|
|
void stack_push_int(struct Stack* stack, int value);
|
|
|
|
/**
|
|
* Wrapper function to pop a int from the stack
|
|
* @param stack the stack to pop from
|
|
* @param value the int pointer to pop
|
|
* @returns if a int was successfully popped
|
|
*/
|
|
bool stack_pop_int(struct Stack* stack, int* value);
|
|
|
|
/* The default shell if no shell is provided */
|
|
#define DEFAULT_SHELL "/bin/sh"
|
|
|
|
/* The default PATH env variable */
|
|
#define DEFAULT_PATH "/sbin:/usr/sbin:/bin:/usr/bin"
|
|
|
|
/**
|
|
* Setup the environment variables for a given user
|
|
* @param shell the shell to set
|
|
* @param new_env if to update the env variables according to pw
|
|
* @param clear_env if to remove the old env variables
|
|
* @param pw the user to update from
|
|
*/
|
|
void setup_environment(const char* shell, bool new_env, bool clear_env, const struct passwd *pw);
|
|
|
|
/**
|
|
* Exec a shell using the current environment, function will not return
|
|
* @param shell the shell to execute
|
|
* @param loginshell if to set the shell as login
|
|
* @param additional_args additional arguments to pass to the shell command
|
|
*/
|
|
void exec_shell(const char* shell, bool loginshell, const char** additional_args);
|
|
|
|
#define PASSWORD_INVALID 0 /* if the password was invalid */
|
|
#define PASSWORD_VALID 1 /* if the password was valid */
|
|
#define PASSWORD_EMPTY 2 /* if the user has an empty password */
|
|
|
|
/**
|
|
* Check if a given plaintext password matches the users /etc/shadow hash
|
|
* @param pw the user to check
|
|
* @param plaintext the plaintext password to check
|
|
* @return if the password was invalid, valid, or empty
|
|
*/
|
|
int check_password(const struct passwd* pw, char* plaintext);
|
|
|
|
/**
|
|
* Prompt the user for their password and then check the given password
|
|
* @param pw the user to check
|
|
* @param prompt the pompt to give to the user
|
|
* @return if the password was invalid, valid, or empty
|
|
*/
|
|
int prompt_password(const struct passwd* pw, char* prompt);
|
|
|
|
/**
|
|
* Set UID and GID to a given user
|
|
* @param user to change to
|
|
*/
|
|
void change_identity(const struct passwd* pw);
|
|
|
|
/**
|
|
* Alloc memory and die if failed
|
|
* @param size the amount of memory to allocate in bytes
|
|
* @return the pointer to the allocated data
|
|
*/
|
|
void* xalloc(size_t size);
|
|
|
|
/**
|
|
* Realloc memory and die if failed
|
|
* @param ptr the pointer to realloc
|
|
* @param size the new size of the data
|
|
* @return the pointer to the reallocated data
|
|
*/
|
|
void* xrealloc(void* ptr, size_t size);
|
|
|
|
/**
|
|
* Alloc memory and zero it, die if failed
|
|
* @param size the amouint of memory to allocate in bytes
|
|
* @return the zeroed pointer to the allocated data
|
|
*/
|
|
void* xzalloc(size_t size);
|
|
|
|
/**
|
|
* Set the env, die if failed
|
|
* @param name the key to set
|
|
* @param value to value to set the key to
|
|
*/
|
|
void xsetenv(const char* name, const char* value);
|
|
|
|
/**
|
|
* Set the uid, die if failed
|
|
* @param uid the uid to set to
|
|
*/
|
|
void xsetuid(uid_t uid);
|
|
|
|
/**
|
|
* Set the gid, die if failed
|
|
* @param gid the gid to set to
|
|
*/
|
|
void xsetgid(gid_t gid);
|
|
|
|
/**
|
|
* Get pw by name, die if failed
|
|
* @param name the name of the user to get
|
|
* @return the pw of the given user
|
|
*/
|
|
struct passwd* xgetpwnam(char* name);
|
|
|
|
#endif /* SHARED_H */
|