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