doc/Informe.tex

@@ -29,7 +29,7 @@
 }
 
 \lstset{
-    basicstyle=\footnotesize\ttfamily,
+    basicstyle=\scriptsize\ttfamily,
     columns=flexible,
     breaklines=true,
     inputencoding=utf8,

doc/code/environ.txt

@@ -0,0 +1,33 @@
+typedef struct {
+    StringArray *keys;
+    StringArray *values;
+    size_t size;
+} ArrayList;
+
+void set_array_list(ArrayList *array_list, char *key, char *value) {
+    if (array_list->keys == NULL) {
+        array_list->keys = create_string_array();
+        array_list->values = create_string_array();
+    }
+    for (size_t i = 0; i < array_list->size; i++) {
+        if (strcmp(array_list->keys->array[i], key) == 0) {
+            array_list->values->array[i] = realloc(array_list->values->array[i], strlen(value) * sizeof(char *));
+            strcpy(array_list->values->array[i], value);
+            return;
+        }
+    }
+    insert_string_array(array_list->keys, key);
+    insert_string_array(array_list->values, value);
+    array_list->size++;
+}
+
+char *get_array_list(ArrayList *array_list, char *key) {
+    if (array_list->keys != NULL) {
+        for (size_t i = 0; i < array_list->size; i++) {
+            if (strcmp(array_list->keys->array[i], key) == 0) {
+                return array_list->values->array[i];
+            }
+        }
+    }
+    return NULL;
+}

doc/code/redirection.txt

@@ -0,0 +1,44 @@
+typedef struct {
+    int fd;
+    int fd_new;
+    int fd_copy;
+    char *filename;
+    int flags;
+} Redirect;
+
+Redirect in = {.fd = STDIN_FILENO, .fd_new = -1, .fd_copy = -1, .filename = NULL, .flags = O_RDONLY};
+Redirect out = {.fd = STDOUT_FILENO, .fd_new = -1, .fd_copy = -1, .filename = NULL, .flags = O_WRONLY | O_CREAT | O_TRUNC};
+Redirect err = {.fd = STDERR_FILENO, .fd_new = -1, .fd_copy = -1, .filename = NULL, .flags = O_WRONLY | O_CREAT | O_TRUNC};
+
+void open_redirect(Redirect *redirect) {
+    redirect->fd_copy = dup(redirect->fd);
+    if (redirect->fd_copy == -1) {
+        perror("dup");
+    }
+    else {
+        redirect->fd_new = open(redirect->filename, redirect->flags, 0664);
+        if (redirect->fd_new == -1) {
+            fprintf(stderr, "open: Could not open file %s: \"%s\"\n", redirect->filename, strerror(errno));
+        }
+        else {
+            if (close(redirect->fd) == -1) {
+                perror("close");
+            }
+            if (dup(redirect->fd_new) == -1) {
+                perror("dup");
+            }
+        }
+    }
+}
+
+void close_redirect(Redirect *redirect) {
+    if (close(redirect->fd_new) == -1) {
+        perror("close");
+    }
+    if (dup2(redirect->fd_copy, redirect->fd) == -1) {
+        perror("dup2");
+    }
+    if (close(redirect->fd_copy) == -1) {
+        perror("close");
+    }
+}

doc/sections/codigo.tex

@@ -1,4 +1,6 @@
 \section{Código}
 \input{sections/codigo/ciclo}
 \input{sections/codigo/builtins}
-\input{sections/codigo/launch}
+\input{sections/codigo/launch}
+\input{sections/codigo/redireccion}
+\input{sections/codigo/environ}

doc/sections/codigo/environ.tex

@@ -0,0 +1,8 @@
+\newpage
+\subsection{Entorno}
+El entorno está controlado por un struct de array de strings de llaves y valores. Se inserta y busca adentro de estos array de llaves\
+para encontrar y usar el variable de entorno. En el shell el struct es usado como un variable global para que se puede accederlo\
+desde cualquier parte del código que se necesita los variables de entorno. Lo mas importante son 2 funciones, set\_array\_list y\
+get\_array\_list. Se usa set\_array\_list para insertar o sobre escribir un variable de entorno. Y el get\_array\_list retorno un\
+valor si se encuentre en el array list basado en la llava pasado a la función como parámetro.
+\lstinputlisting{code/environ.txt}

doc/sections/codigo/redireccion.tex

@@ -0,0 +1,12 @@
+\newpage
+\subsection{Redireccionamiento}
+Para redireccionar las entradas y salidas se usa 4 comandos principales, dup, dup2, open y close. El primer paso a tomar\
+es duplicar la entrada o salida(stdin, stdout o stderr) con dup. Eso es importante para restaurarlo después. Luego se abre el archivo\
+de salida o entrada usando open y los flags correspondiente a la operación que quiere\
+hacer(O\_RDONLY, O\_WRONLY, O\_CREATE, O\_APPEND o O\_TRUNC). Después, cerra stdin, stdout o stderr. Eso va a dejar su fd disponible para\
+usar. Finalmente hacer una duplicación con dup del fd de archivo de entrad o salida. Eso va a dejar el archivo usando el fd que
+cerramos anteriormente. Ahora todos las cosas mandados al stdin, stdout o stderr van a ser redirigidas al archivo. Para terminar\
+cerramos el archivo usado. Luego usamos dup2 para duplicar la copia original en su fd original. I finalmente cerramos la copia.\
+Para que funciona eso, debe abrir el redireccionamiento antes de llamar los builtins o permutar y cerrarlo después que termina\
+correr los builtins o el proceso hijo.
+\lstinputlisting{code/redirection.txt}

doc/sections/conclusiones.tex

@@ -1,5 +1,5 @@
 \section{Conclusiones}
 Lo cosa mas importante que se puede aprender del proyecto es que el shell es un puente entre el usuario y el sistema operativo.\
-El shell es responsable para lanzar programas, interpretar comandos y un shells mas avanzados interpretar un lenguaje de\
+El shell es responsable para lanzar programas, interpretar comandos y en shells mas avanzados interpretar un lenguaje de\
 scripting para poder facilitar tareas o automatizarlas. Por lo tanto el shell es una parte integral para el sistema operativo\
 especialmente en sistemas como GNU/Linux o BSD.