diff --git a/HelperFunctions.c b/HelperFunctions.c new file mode 100644 index 0000000000000000000000000000000000000000..3695395c6b759d7d676a1c44a151ffaac8e9d417 --- /dev/null +++ b/HelperFunctions.c @@ -0,0 +1,236 @@ +/** + * Brandon Rodriguez + * CS 3240 + * 09-19-17 + */ + + +/** + * Helper functions to have consistent value copying and error handling. + * + * + * Copy Functions: + * Copy functions use memcpy to copy data, and error.c's err_dump on + * failure. + * + * Copy functions require a "source" pointer of equivalent typing, and + * return a pointer to copied item's location. + * + * + * String Functions: + * String manipulator functions to make string handling easier. + * + * String manipulator functions require an "input" string and return + * a modified copy of original string. + */ + + +#include <ctype.h> +#include <string.h> +#include "apue.h" + + +// ************** // +// Copy Functions // +// ************** // + +/** + * Copies string from destination to source. + * + * Return: Copy of source string. + */ +char* copy_string(char* source_ptr) { + char* copy_ptr; + copy_ptr = calloc((strlen(source_ptr) + 1), sizeof(char)); + if (copy_ptr != NULL) { + memcpy(copy_ptr, source_ptr, ((strlen(source_ptr) + 1) * sizeof(char))); + } else { + err_dump("Could not allocate memory for string calloc."); + } + return copy_ptr; +} + + +/** + * Copies string from destination to source. + * Uses a buffer of indicated size. + * + * Return: Copy of source string. + */ +char* copy_string_with_buffer(char* source_ptr, int buffer_size) { + char* copy_ptr; + copy_ptr = calloc(buffer_size, sizeof(char)); + if (copy_ptr != NULL) { + memcpy(copy_ptr, source_ptr, ((strlen(source_ptr) + 1) * sizeof(char))); + } else { + err_dump("Could not allocate memory for string calloc."); + } + return copy_ptr; +} + + +/** + * Copies float from destination to source. + * + * Return: Copy of source int. + */ +int* copy_int(int* source_ptr) { + int* copy_ptr; + copy_ptr = calloc(1, (sizeof(int) + 1)); + if (copy_ptr != NULL) { + memcpy(copy_ptr, source_ptr, sizeof(int)); + } else { + err_dump("Could not allocate memory for int calloc."); + } + return copy_ptr; +} + + +/** + * Copies float from destination to source. + * + * Return: Copy of source float. + */ +float* copy_float(float* source_ptr) { + float* copy_ptr; + copy_ptr = calloc(1, (sizeof(float) + 1)); + if (copy_ptr != NULL) { + memcpy(copy_ptr, source_ptr, sizeof(float)); + } else { + err_dump("Could not allocate memory for float calloc."); + } + return copy_ptr; +} + + +/** + * Copies double from destination to source. + * + * Return: Copy of source double. + */ +double* copy_double(double* source_ptr) { + double* copy_ptr; + copy_ptr = calloc(1, (sizeof(double) + 1)); + if (copy_ptr != NULL) { + memcpy(copy_ptr, source_ptr, sizeof(double)); + } else { + err_dump("Could not allocate memory for double calloc."); + } + return copy_ptr; +} + + +// ***************************** // +// String Manipulation Functions // +// ***************************** // + +/** + * Converts provided string to lowercase. + * + * Return: Lowercase version of initial string. + */ +char* to_lower_case(char* input_string) { + int index = 0; + char* return_string = calloc((strlen(input_string) + 1), sizeof(char)); + while (input_string[index]) { + return_string[index] = tolower(input_string[index]); + index++; + } + return return_string; +} + + +/** + * Converts provided string to uppercase. + * + * Return: Uppercase version of initial string. + */ +char* to_upper_case(char* input_string) { + int index = 0; + char* return_string = calloc((strlen(input_string) + 1), sizeof(char)); + while (input_string[index]) { + return_string[index] = toupper(input_string[index]); + index++; + } + return return_string; +} + + +/** + * Converts provided string to: + * First letter of each word is uppercase. + * All other letters lowercase. + * + * Return: Converted version of initial string. + */ +char* first_letter_upper(char* input_string) { + int index = 0; + char* return_string = calloc((strlen(input_string) + 1), sizeof(char)); + while (input_string[index]) { + if (index == 0) { // First char is always upper. + return_string[index] = toupper(input_string[index]); + } else { // Check all other chars. If space preceeds, then upper. + if (input_string[index - 1] == ' ') { + return_string[index] = toupper(input_string[index]); + } else { // No space found. + return_string[index] = tolower(input_string[index]); + } + } + index++; + } + return return_string; +} + + +/** + * Removes quotes from provided string. + * + * Return: Quote-less version of initial string. + */ +char* remove_quotes(char* input_string) { + size_t string_length = strlen(input_string); + int orig_index; + int replace_index = 0; + + for (orig_index = 0; orig_index < string_length; orig_index++) { + if (input_string[orig_index] != '\"') { + input_string[replace_index] = input_string[orig_index]; + replace_index++; + } + } + + // Fill rest of values with null terminators. + while (replace_index < string_length) { + input_string[replace_index] = '\0'; + replace_index++; + } + + return input_string; +} + + +/** + * Removes newline character from string. + * + * Return: Newline-less version of initial string. + */ +char* remove_newline(char* input_string) { + size_t string_length = strlen(input_string); + int orig_index; + int replace_index = 0; + + for (orig_index = 0; orig_index < string_length; orig_index++) { + if (input_string[orig_index] != '\n') { + input_string[replace_index] = input_string[orig_index]; + replace_index++; + } + } + + // Fill rest of values with null terminators. + while (replace_index < string_length) { + input_string[replace_index] = '\0'; + replace_index++; + } + + return input_string; +} diff --git a/HelperHeader.h b/HelperHeader.h new file mode 100644 index 0000000000000000000000000000000000000000..7634698661cab1428a40ef2fdd585023c9f9ba75 --- /dev/null +++ b/HelperHeader.h @@ -0,0 +1,34 @@ +/** + * Brandon Rodriguez + * CS 3240 + * 09-19-17 + */ + + +/** + * A personal header for helper-functions. + */ + +// ANSI color escape codes. +#define ANSI_COLOR_RESET "\x1b[0m" +#define ANSI_COLOR_RED "\x1b[31m" +#define ANSI_COLOR_GREEN "\x1b[32m" +#define ANSI_COLOR_YELLOW "\x1b[33m" +#define ANSI_COLOR_BLUE "\x1b[34m" +#define ANSI_COLOR_MAGENTA "\x1b[35m" +#define ANSI_COLOR_CYAN "\x1b[36m" + + +// Function prototypes. + +char* copy_string(char* source_ptr); +char* copy_string_with_buffer(char* source_ptr, int buffer_size); +int* copy_int(int* source_ptr); +float* copy_float(float* source_ptr); +double* copy_double(double* source_ptr); + +char* to_lower_case(char* input_string); +char* to_upper_case(char* input_string); +char* first_letter_upper(char* input_string); +char* remove_quotes(char* input_string); +char* remove_newline(char* input_string); diff --git a/Main.c b/Main.c new file mode 100644 index 0000000000000000000000000000000000000000..a6e42bfc3f92590d602ce5bac942b439d460a6bb --- /dev/null +++ b/Main.c @@ -0,0 +1,45 @@ +/** + * Brandon Rodriguez + * CS 3240 + * + * a (Assignment ) + */ + + +/** + * Description: + * + */ + + +/** + * Known Issues: + * + */ + + +// Import headers. +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <ctype.h> +#include "apue.h" + + +// Define Vars. +//#define ??? + + +// Variables. + + +// Method Declaration. + + +/** + * Program's main. + * Initializes and runs program. + */ +int main(int argc, char* argv[]) { + +} diff --git a/apue.h b/apue.h new file mode 100644 index 0000000000000000000000000000000000000000..a480b9380f3e3b3f04e497bae1da7d65c7f76278 --- /dev/null +++ b/apue.h @@ -0,0 +1,108 @@ +/* Our own header, to be included *after* all standard system headers */ + +#ifndef __ourhdr_h +#define __ourhdr_h + +#include <sys/types.h> /* required for some of our prototypes */ +#include <stdio.h> /* for convenience */ +#include <stdlib.h> /* for convenience */ +#include <string.h> /* for convenience */ +#include <unistd.h> /* for convenience */ + +#define MAXLINE 4096 /* max line length */ + +#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) + /* default file access permissions for new files */ +#define DIR_MODE (FILE_MODE | S_IXUSR | S_IXGRP | S_IXOTH) + /* default permissions for new directories */ + +typedef void Sigfunc(int); /* for signal handlers */ + + /* 4.3BSD Reno <signal.h> doesn't define SIG_ERR */ +#if defined(SIG_IGN) && !defined(SIG_ERR) +#define SIG_ERR ((Sigfunc *)-1) +#endif + +#define min(a,b) ((a) < (b) ? (a) : (b)) +#define max(a,b) ((a) > (b) ? (a) : (b)) + + /* prototypes for our own functions */ +char *path_alloc(int *); /* {Prog pathalloc} */ +int open_max(void); /* {Prog openmax} */ +void clr_fl(int, int); /* {Prog setfl} */ +void set_fl(int, int); /* {Prog setfl} */ +void pr_exit(int); /* {Prog prexit} */ +void pr_mask(const char *); /* {Prog prmask} */ +Sigfunc *signal_intr(int, Sigfunc *);/* {Prog signal_intr_function} */ + +int tty_cbreak(int); /* {Prog raw} */ +int tty_raw(int); /* {Prog raw} */ +int tty_reset(int); /* {Prog raw} */ +void tty_atexit(void); /* {Prog raw} */ +#ifdef ECHO /* only if <termios.h> has been included */ +struct termios *tty_termios(void); /* {Prog raw} */ +#endif + +void sleep_us(unsigned int); /* {Ex sleepus} */ +ssize_t readn(int, void *, size_t);/* {Prog readn} */ +ssize_t writen(int, const void *, size_t);/* {Prog writen} */ +int daemon_init(void); /* {Prog daemoninit} */ + +int s_pipe(int *); /* {Progs svr4_spipe bsd_spipe} */ +int recv_fd(int, ssize_t (*func)(int, const void *, size_t)); + /* {Progs recvfd_svr4 recvfd_43bsd} */ +int send_fd(int, int); /* {Progs sendfd_svr4 sendfd_43bsd} */ +int send_err(int, int, const char *);/* {Prog senderr} */ +int serv_listen(const char *); /* {Progs servlisten_svr4 servlisten_44bsd} */ +int serv_accept(int, uid_t *); /* {Progs servaccept_svr4 servaccept_44bsd} */ +int cli_conn(const char *); /* {Progs cliconn_svr4 cliconn_44bsd} */ +int buf_args(char *, int (*func)(int, char **)); + /* {Prog bufargs} */ + +int ptym_open(char *); /* {Progs ptyopen_svr4 ptyopen_44bsd} */ +int ptys_open(int, char *); /* {Progs ptyopen_svr4 ptyopen_44bsd} */ +#ifdef TIOCGWINSZ +pid_t pty_fork(int *, char *, const struct termios *, + const struct winsize *); /* {Prog ptyfork} */ +#endif + +int lock_reg(int, int, int, off_t, int, off_t); + /* {Prog lockreg} */ +#define read_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_RDLCK, offset, whence, len) +#define readw_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLKW, F_RDLCK, offset, whence, len) +#define write_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_WRLCK, offset, whence, len) +#define writew_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLKW, F_WRLCK, offset, whence, len) +#define un_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_UNLCK, offset, whence, len) + +pid_t lock_test(int, int, off_t, int, off_t); + /* {Prog locktest} */ + +#define is_readlock(fd, offset, whence, len) \ + lock_test(fd, F_RDLCK, offset, whence, len) +#define is_writelock(fd, offset, whence, len) \ + lock_test(fd, F_WRLCK, offset, whence, len) + +void err_dump(const char *, ...); /* {App misc_source} */ +void err_msg(const char *, ...); +void err_quit(const char *, ...); +void err_ret(const char *, ...); +void err_sys(const char *, ...); + +void log_msg(const char *, ...); /* {App misc_source} */ +void log_open(const char *, int, int); +void log_quit(const char *, ...); +void log_ret(const char *, ...); +void log_sys(const char *, ...); + +void TELL_WAIT(void); /* parent/child from {Sec race_conditions} */ +void TELL_PARENT(pid_t); +void TELL_CHILD(pid_t); +void WAIT_PARENT(void); +void WAIT_CHILD(void); + +#endif /* __ourhdr_h */ diff --git a/error.c b/error.c new file mode 100644 index 0000000000000000000000000000000000000000..775cdb25b7ecf2dc626c0e6f1843ba4c21f8eeee --- /dev/null +++ b/error.c @@ -0,0 +1,98 @@ +#include <errno.h> /* for definition of errno */ +#include <stdarg.h> /* ANSI C header file */ +#include "apue.h" + +static void err_doit(int, const char *, va_list); + +char *pname = NULL; /* caller can set this from argv[0] */ + +/* Nonfatal error related to a system call. + * Print a message and return. */ + +void +err_ret(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + err_doit(1, fmt, ap); + va_end(ap); + return; +} + +/* Fatal error related to a system call. + * Print a message and terminate. */ + +void +err_sys(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + err_doit(1, fmt, ap); + va_end(ap); + exit(1); +} + +/* Fatal error related to a system call. + * Print a message, dump core, and terminate. */ + +void +err_dump(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + err_doit(1, fmt, ap); + va_end(ap); + abort(); /* dump core and terminate */ + exit(1); /* shouldn't get here */ +} + +/* Nonfatal error unrelated to a system call. + * Print a message and return. */ + +void +err_msg(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + err_doit(0, fmt, ap); + va_end(ap); + return; +} + +/* Fatal error unrelated to a system call. + * Print a message and terminate. */ + +void +err_quit(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + err_doit(0, fmt, ap); + va_end(ap); + exit(1); +} + +/* Print a message and return to caller. + * Caller specifies "errnoflag". */ + +static void +err_doit(int errnoflag, const char *fmt, va_list ap) +{ + int errno_save; + char buf[MAXLINE]; + + errno_save = errno; /* value caller might want printed */ + vsprintf(buf, fmt, ap); + if (errnoflag) + sprintf(buf+strlen(buf), ": %s", strerror(errno_save)); + strcat(buf, "\n"); + fflush(stdout); /* in case stdout and stderr are the same */ + fputs(buf, stderr); + fflush(stderr); /* SunOS 4.1.* doesn't grok NULL argument */ + return; +}