int exec_pipe(int i, char **command)
{
int pid;
int fd[2];
if (command[i + 1])
{
if (pipe(fd) == -1 || (pid = fork()) == -1)
return (0);
if (pid != 0)
{
close(fd[1]);
if (dup2(fd[0], 0) == -1)
return (0);
waitpid(pid, 0, 0);
if (my_pipe(i + 1, command) == 0)
return (0);
close(fd[0]);
}
else if (father(fd, command, i) == 0)
return (0);
}
if (execlp(command[i], command[i], NULL) == -1)
return (0);
return (1);
}
int main(int argc, char** argv) {
if(argc != 3 ) {
printf("Usage:./a.out cmd1 cmd2\n");
return -1;
}
my_pipe(argv[1],argv[2]);
return 0;
}
int *first_pipe(t_param exe, t_shell *sh)
{
int *pipe_next;
int pid;
pipe_next = malloc(2 * sizeof(int));
my_pipe(pipe_next);
pid = my_fork();
if (pid == 0)
{
close(pipe_next[0]);
my_dup2(pipe_next[1], 1);
my_execve(exe, sh);
}
close(pipe_next[1]);
return (pipe_next);
}
int *between_pipe(t_param exe, int pipe_pre[2], t_shell *sh)
{
int *pipe_next;
int pid;
pipe_next = malloc(2 * sizeof(int));
my_pipe(pipe_next);
pid = my_fork();
if (pid == 0)
{
close(pipe_next[0]);
my_dup2(pipe_next[1], 1);
my_dup2(pipe_pre[0], 0);
my_execve(exe, sh);
}
close(pipe_next[1]);
free(pipe_pre);
return (pipe_next);
}
int check_fn(t_tree *tree, int in, int out, t_env_var *env)
{
if (!tree)
return (-1);
else if (strcmp(tree->data, ">") == 0)
return (redir_right(tree, in, out, env));
else if (strcmp(tree->data, ">>") == 0)
return (doble_right(tree, in, out, env));
else if (strcmp(tree->data, "<") == 0)
return (redir_left(tree, in, out, env));
else if (strcmp(tree->data, "&&") == 0)
return (my_and(tree, in, out, env));
else if (strcmp(tree->data, "||") == 0)
return (my_or(tree, in, out, env));
else if (strcmp(tree->data, ";") == 0)
return (my_semi_col(tree, in, out, env));
else if (strcmp(tree->data, "<<") == 0)
return (doble_left(tree, in, out, env));
else if (strcmp(tree->data, "|") == 0)
return (my_pipe(tree, in, out, env));
else
return (my_exec(tree->data, in, out, env));
}
int simple(char **tabeulo)
{
int status;
if (tabeulo[1][0] == '>')
{
if (redir_droite(tabeulo) == 0)
return (0);
}
else if (tabeulo[1][0] == '<')
{
if (redir_gauche(tabeulo) == 0)
return (0);
}
else if (tabeulo[1][0] == '|')
{
if (fork())
wait(&status);
else if (my_pipe(0, tabeulo) == 0)
return (0);
}
return (1);
}
FILE *
pt_popen(const char *cmd, const char *mode)
{ FILE *fptr = NULL;
PROCESS_INFORMATION piProcInfo;
STARTUPINFOW siStartInfo;
int success, redirect_error = 0;
wchar_t *wcmd = NULL;
wchar_t *err2out;
pipe_context *pc;
size_t utf8len = utf8_strlen(cmd, strlen(cmd));
if ( !(wcmd = malloc((utf8len+1)*sizeof(wchar_t))) )
{ return NULL;
}
utf8towcs(wcmd, cmd);
if ( !(pc=allocPipeContext()) )
goto finito;
if ( !mode || !*mode )
goto finito;
pc->mode = *mode;
if ( pc->mode != 'r' && pc->mode != 'w' )
goto finito;
/*
* Shall we redirect stderr to stdout ? */
if ( (err2out=wcsstr(wcmd, L"2>&1")) != NULL)
{ /* this option doesn't apply to win32 shells, so we clear it out! */
wcsncpy(err2out, L" ", 4);
redirect_error = 1;
}
/*
* Create the Pipes... */
if (my_pipe(pc->in) == -1 ||
my_pipe(pc->out) == -1)
goto finito;
if ( !redirect_error )
{ if ( my_pipe(pc->err) == -1)
goto finito;
}
/*
* Now create the child process */
ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
siStartInfo.cb = sizeof(STARTUPINFO);
siStartInfo.hStdInput = pc->in[0];
siStartInfo.hStdOutput = pc->out[1];
if ( redirect_error )
siStartInfo.hStdError = pc->out[1];
else
siStartInfo.hStdError = pc->err[1];
siStartInfo.dwFlags = STARTF_USESTDHANDLES;
success = CreateProcessW(NULL,
wcmd, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
CREATE_NO_WINDOW, // creation flags: without window (?)
NULL, // use parent's environment
NULL, // use parent's current directory
&siStartInfo, // STARTUPINFO pointer
&piProcInfo); // receives PROCESS_INFORMATION
if ( !success )
goto finito;
CloseHandle(piProcInfo.hThread);
CloseHandle(piProcInfo.hProcess);
/*
* These handles listen to the Child process */
CloseHandle(pc->in[0]); pc->in[0] = INVALID_HANDLE_VALUE;
CloseHandle(pc->out[1]); pc->out[1] = INVALID_HANDLE_VALUE;
if ( pc->err[1] != INVALID_HANDLE_VALUE )
{ CloseHandle(pc->err[1]);
pc->err[1] = INVALID_HANDLE_VALUE;
}
if ( pc->mode == 'r' )
fptr = _fdopen(_open_osfhandle((intptr_t)pc->out[0],_O_BINARY),"r");
else
fptr = _fdopen(_open_osfhandle((intptr_t)pc->in[1],_O_BINARY),"w");
finito:
if ( fptr )
{ pc->fd = fptr;
linkPipeContext(pc);
} else
{ if ( pc )
discardPipeContext(pc);
}
if ( wcmd )
free(wcmd);
return fptr;
}
/*----------------------------------------------------------------------------
Replacement for 'popen()' under WIN32.
NOTE: if cmd contains '2>&1', we connect the standard error file handle
to the standard output file handle.
----------------------------------------------------------------------------*/
FILE * pt_popen(const char *cmd, const char *mode)
{
FILE *fptr = (FILE *)0;
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
int success, umlenkung;
my_pipein[0] = INVALID_HANDLE_VALUE;
my_pipein[1] = INVALID_HANDLE_VALUE;
my_pipeout[0] = INVALID_HANDLE_VALUE;
my_pipeout[1] = INVALID_HANDLE_VALUE;
my_pipeerr[0] = INVALID_HANDLE_VALUE;
my_pipeerr[1] = INVALID_HANDLE_VALUE;
if (!mode || !*mode)
goto finito;
my_popenmode = *mode;
if (my_popenmode != 'r' && my_popenmode != 'w')
goto finito;
/*
* Shall we redirect stderr to stdout ? */
umlenkung = strstr("2>&1",(char *)cmd) != 0;
/*
* Create the Pipes... */
if (my_pipe(my_pipein) == -1 ||
my_pipe(my_pipeout) == -1)
goto finito;
if (!umlenkung && my_pipe(my_pipeerr) == -1)
goto finito;
/*
* Now create the child process */
ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
siStartInfo.cb = sizeof(STARTUPINFO);
siStartInfo.hStdInput = my_pipein[0];
siStartInfo.hStdOutput = my_pipeout[1];
if (umlenkung)
siStartInfo.hStdError = my_pipeout[1];
else
siStartInfo.hStdError = my_pipeerr[1];
siStartInfo.dwFlags = STARTF_USESTDHANDLES;
success = CreateProcess(NULL,
(LPTSTR)cmd, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
DETACHED_PROCESS, // creation flags: without window (?)
NULL, // use parent's environment
NULL, // use parent's current directory
&siStartInfo, // STARTUPINFO pointer
&piProcInfo); // receives PROCESS_INFORMATION
if (!success)
goto finito;
/*
* These handles listen to the child process */
CloseHandle(my_pipein[0]); my_pipein[0] = INVALID_HANDLE_VALUE;
CloseHandle(my_pipeout[1]); my_pipeout[1] = INVALID_HANDLE_VALUE;
CloseHandle(my_pipeerr[1]); my_pipeerr[1] = INVALID_HANDLE_VALUE;
if (my_popenmode == 'r')
fptr = _fdopen(_open_osfhandle((long)my_pipeout[0],_O_BINARY),"r");
else
fptr = _fdopen(_open_osfhandle((long)my_pipein[1],_O_BINARY),"w");
finito:
if (!fptr)
{
if (my_pipein[0] != INVALID_HANDLE_VALUE)
CloseHandle(my_pipein[0]);
if (my_pipein[1] != INVALID_HANDLE_VALUE)
CloseHandle(my_pipein[1]);
if (my_pipeout[0] != INVALID_HANDLE_VALUE)
CloseHandle(my_pipeout[0]);
if (my_pipeout[1] != INVALID_HANDLE_VALUE)
CloseHandle(my_pipeout[1]);
if (my_pipeerr[0] != INVALID_HANDLE_VALUE)
CloseHandle(my_pipeerr[0]);
if (my_pipeerr[1] != INVALID_HANDLE_VALUE)
CloseHandle(my_pipeerr[1]);
}
return fptr;
}
void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
int n = 0;
int maxfdp1 = 0;
const int on = 1;
char sendline[MAXLINE] = {0};
char recvline[MAXLINE] = {0};
fd_set rset;
socklen_t len;
struct sockaddr *preply_addr = NULL;
preply_addr = my_malloc(servlen);
my_setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
my_pipe(pipefd);
// printf("pipefd[0] = %d\n", pipefd[0]); //+
maxfdp1 = max(sockfd, pipefd[0]) + 1;
FD_ZERO(&rset);
my_signal(SIGALRM, recvfrom_alarm);
while (my_fgets(sendline, MAXLINE, fp) != NULL )
{
my_sendto(sockfd, sendline, strlen(sendline),
0, pservaddr, servlen);
alarm(3);
while (1)
{
FD_SET(sockfd, &rset);
FD_SET(pipefd[0], &rset);
if ( (n = select(maxfdp1, &rset, NULL, NULL, NULL)) < 0 )
{
if (errno == EINTR)
{
DEBUG;
printf("select errno = EINTR\n"); //+
continue;
}
else
{
err_sys("select error");
}
}
// printf("kankan!\n");
if ( FD_ISSET(sockfd, &rset) )
{
len = servlen;
n = my_recvfrom(sockfd, recvline, MAXLINE,
0, preply_addr, &len);
recvline[n] = 0;
printf("from %s: %s",
my_sock_ntop(preply_addr, len),
recvline);
}
if ( FD_ISSET(pipefd[0], &rset) )
{
// printf("read 上面\n");
my_read(pipefd[0], &n, 1); //timer expired
// printf("read 下面!\n");
break;
}
}
}
free(preply_addr);
}
/* Fonction: executer_commande
* Entrees: aucune
*
* Sortie: aucune
*
* Execute une commande
*/
void executer_commande() {
pid_t pid;
/* on commence par regarder s'il y a des pipes */
int nb_pipes = number_pipes();
if (nb_pipes > 0) {
my_pipe(nb_pipes);
}
/* on exécute les commandes internes (pas de fork) */
/* pas de pipes, donc la position de la commande est 0 */
else if (internal_command(0) == 0)
{
pid = fork(); /* le fork permet de lancer une commande en continuant d'executer le shell */
if (pid == 0) /* fils */
{
/* on commence par vérifier si on veut faire une redirection */
int i = 0; /* recherche du nombre d'éléments */
while (commande[i] != NULL)
i++;
if (commande[i-1][0] == '>') {
/* ouverture d'un fichier de destination */
int file = open(&commande[i-1][1], O_WRONLY | O_CREAT | O_TRUNC, 0666);
/* O_WRONLY : on va seulement écrire dans le fichier
* O_CREAT : créé le fichier s'il n'existe pas
* O_TRUNC : le fichier est tronqué à une longueur nulle s'il existe
* 0666 : tout le monde peut lire et écrire dans ce fichier */
if (file == -1) {
printf("Erreur, impossible de créer le fichier");
exit(1);
}
dup2(file, 1); /* remplace la sortie standard par un fichier de sortie */
close(file); /* fermeture du fichier de destination */
/* il faut supprimer le dernier argument pour effectuer la commande externe */
commande[i-1] = NULL;
}
/* on exécute ensuite les commandes externes */
const char* path = get_path(commande[0]); /* on récupère le chemin */
if (strcmp(path, "echec") != 0) { /* si on réussit à récupérer le path */
stockCommande();
execv(path, commande);
}
else
my_exit(commande);
}
else if(pid<0)
printf("Erreur, fork a échoué.\n");
else /* père */
{
int status;
waitpid(pid, &status, 0); /* attente bloquante */
}
}
}
