173 lines
4.1 KiB
C
173 lines
4.1 KiB
C
/* ************************************************************************** */
|
|
/* */
|
|
/* ::: :::::::: */
|
|
/* process.h :+: :+: :+: */
|
|
/* +:+ +:+ +:+ */
|
|
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
|
|
/* +#+#+#+#+#+ +#+ */
|
|
/* Created: 2024/01/03 15:43:08 by maiboyer #+# #+# */
|
|
/* Updated: 2024/07/11 18:59:04 by maiboyer ### ########.fr */
|
|
/* */
|
|
/* ************************************************************************** */
|
|
|
|
#ifndef PROCESS_H
|
|
# define PROCESS_H
|
|
|
|
# include "me/types.h"
|
|
# include "me/vec/vec_str.h"
|
|
# include "me/vec/vec_u8.h"
|
|
|
|
typedef t_i32 t_pid;
|
|
typedef t_i32 t_exit_code;
|
|
|
|
enum e_redirection
|
|
{
|
|
R_INHERITED = 0,
|
|
R_PIPED = 1,
|
|
R_FD = 2,
|
|
};
|
|
|
|
union u_redirection
|
|
{
|
|
struct s_fd_redirection
|
|
{
|
|
int value;
|
|
} fd;
|
|
struct s_piped_redirection
|
|
{
|
|
} piped;
|
|
struct s_inherited_redirection
|
|
{
|
|
} inherited;
|
|
};
|
|
|
|
/// @brief Redirection for spawning a process
|
|
typedef struct s_redirection
|
|
{
|
|
enum e_redirection tag;
|
|
union u_redirection vals;
|
|
} t_redirection;
|
|
|
|
/// @brief Create a piped redirection
|
|
/// @param void
|
|
/// @return the redirection
|
|
static inline t_redirection piped(void)
|
|
{
|
|
return ((t_redirection){
|
|
.tag = R_PIPED,
|
|
});
|
|
}
|
|
|
|
/// @brief Create an inherited redirection (inherit from the parent process)
|
|
/// @param void
|
|
/// @return the redirection
|
|
static inline t_redirection inherited(void)
|
|
{
|
|
return ((t_redirection){
|
|
.tag = R_INHERITED,
|
|
});
|
|
}
|
|
|
|
/// @brief Create a file descriptor redirection
|
|
/// @param fd file descriptor to redirect
|
|
/// @return the redirection
|
|
static inline t_redirection fd(int fd)
|
|
{
|
|
return ((t_redirection){.tag = R_FD, \
|
|
.vals = (union u_redirection){\
|
|
.fd = {.value = fd}, \
|
|
}});
|
|
}
|
|
|
|
/// @brief Wrapped file descriptor tag
|
|
enum e_wrapped_fd_tag
|
|
{
|
|
READ_ONLY,
|
|
WRITE_ONLY,
|
|
READ_WRITE,
|
|
INVALID,
|
|
};
|
|
|
|
/// @brief Wrapped file descriptor
|
|
union u_wrapped_fd
|
|
{
|
|
struct s_read_only
|
|
{
|
|
int fd;
|
|
} ro;
|
|
struct s_write_only
|
|
{
|
|
int fd;
|
|
} wo;
|
|
struct s_read_write
|
|
{
|
|
int fd;
|
|
} rw;
|
|
};
|
|
|
|
/// @brief Wrapped file descriptor
|
|
typedef struct s_wrapped_fd
|
|
{
|
|
enum e_wrapped_fd_tag tag;
|
|
union u_wrapped_fd vals;
|
|
} t_wrapped_fd;
|
|
|
|
/// @brief Create a Read only wrapped file descriptor
|
|
/// @param fd file descriptor to wrap
|
|
/// @return the wrapped file descriptor
|
|
static inline t_wrapped_fd ro(int fd)
|
|
{
|
|
return ((t_wrapped_fd){.tag = READ_ONLY, \
|
|
.vals = (union u_wrapped_fd){\
|
|
.ro = {.fd = fd}, \
|
|
}});
|
|
}
|
|
|
|
/// @brief Create a Write only wrapped file descriptor
|
|
/// @param fd file descriptor to wrap
|
|
/// @return the wrapped file descriptor
|
|
static inline t_wrapped_fd wo(int fd)
|
|
{
|
|
return ((t_wrapped_fd){.tag = WRITE_ONLY,
|
|
.vals = (union u_wrapped_fd){.wo = {.fd = fd}}});
|
|
}
|
|
|
|
/// @brief Spawn information
|
|
typedef struct s_spawn_info
|
|
{
|
|
t_redirection stdin;
|
|
t_redirection stdout;
|
|
t_redirection stderr;
|
|
t_vec_str arguments;
|
|
t_vec_str environement;
|
|
t_str binary_path;
|
|
void (*forked_free)(void *);
|
|
void *forked_free_args;
|
|
} t_spawn_info;
|
|
|
|
/// @brief Process information
|
|
typedef struct s_process
|
|
{
|
|
t_wrapped_fd stdin;
|
|
t_wrapped_fd stdout;
|
|
t_wrapped_fd stderr;
|
|
t_pid pid;
|
|
} t_process;
|
|
/// @struct Process output
|
|
/// @brief Process output information
|
|
typedef struct s_process_output
|
|
{
|
|
t_pid pid;
|
|
t_vec_u8 stdout;
|
|
t_vec_u8 stderr;
|
|
t_exit_code exit_code;
|
|
} t_process_output;
|
|
|
|
/// @brief Spawn a new process with the given information
|
|
/// @param info the information to spawn the process
|
|
/// @param process data returned by the function
|
|
/// @return true if an error occured, false otherwise
|
|
t_error spawn_process(t_spawn_info info,
|
|
t_process *process);
|
|
|
|
#endif /* PROCESS_H */
|