Paste Search Dynamic
exercice 1
  1. #include <sys/types.h>
  2. #include <unistd.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <sys/wait.h>
  6.  
  7. //exercice 1
  8.  
  9. main () {
  10. int code_retour ;
  11. printf (“Debut du test fork ()\n”);
  12. code_retour = fork ();
  13. switch (code_retour ) {
  14.  case1 :
  15. printf (“Pbm lors de la creation du processus\n”);
  16. break;
  17.  case 0 :
  18. printf (“Je suis le processus fils \n”);
  19. break;
  20.  default :
  21. printf (“Je suis le processus père\n”);
  22. printf (“Je viens de créer le processus fils dont le pid est %d \n”,code_retour);
  23. }
  24. printf (“code_retour %d\n”, code_retour);
  25.  
  26.        
  27. //exerice 2
  28.  
  29. int main(){
  30. pid_t pid;
  31.     int code_retour;
  32.     char buf[1024];
  33.     printf(" [%d] -- Debut du test fork()\n",getpid());
  34.     pid = fork();
  35.     switch(pid){
  36.       case -1:
  37.         printf("pbm lors de la création du processus\n");
  38.         break;
  39.       case 0:
  40.         printf("[%d] -- je suis le processus fils \n",getpid());
  41.         printf("[%d] -- pid=%d   ppid=%d \n",getpid(),getpid(),getppid());
  42.         printf("[%d] -- uid=%d  euid=%d  gid=%d  egid=%d\n",getpid(),getuid(),geteuid(),getgid(),getegid());
  43.         printf("[%d] -- repertoire de travail = %s \n", getpid(),getcwd(buf,1024));
  44.         break;
  45.       default:
  46.         printf("je suis le processus pere\n");
  47.         printf("[%d] -- pid=%d   ppid=%d \n",getpid(),getpid(),getppid());
  48.         printf("[%d] -- uid=%d  euid=%d  gid=%d  egid=%d\n",getpid(),getuid(),geteuid(),getgid(),getegid());
  49.         printf("[%d] -- repertoire de travail = %s \n", getpid(),getcwd(buf,1024));
  50.         break;
  51. }
  52.     printf("[%d] -- Fin du test fork \n",getpid());
  53.     return 0;
  54. }
  55.  
  56. void infos(){
  57.     printf("PID : %d\nPPID : %d\nProp : %d\nProp eff : %d\nGroupe prop : %d\nGroupe prop eff : %d\n", getpid(), getppid(), getuid(), geteuid(), getgid(), getegid());
  58.     char chemin[100];
  59.     getcwd(chemin, 100);
  60.     printf("%s", chemin);
  61. }
  62.  
  63.  
  64.  
  65. void main(){
  66.     int pid;
  67.     printf("Début du fork : \n");
  68.     pid = fork();
  69.     switch (pid) {
  70.         case -1:
  71.             printf("Erreur\n");
  72.             break;
  73.         case 0:
  74.             sleep(1);
  75.             printf("\nFils\n");
  76.             infos();
  77.             break;
  78.         default:
  79.             printf("\nPère de %d\n", pid);
  80.             infos();
  81.     }
  82. }
  83. // ==> Fils tué parce que père terminé.
  84.  
  85. int main(){
  86.     int pid;
  87.     int f;
  88.     char lu[100];
  89.     printf("Debut du test\n");
  90.     f = open("toto.txt", O_RDWR | O_CREAT, 0755);
  91.     printf("%d", f);
  92.     write(f, "abcdefghijklmnopqrstuvwxyz\n", 28);
  93.     pid = fork();
  94.     switch (pid) {
  95.         case -1:
  96.             printf("Erreur\n");
  97.             break;
  98.         case 0:
  99.             // Fils
  100.             write(f, "fils\n", 6);
  101.             sleep(2);
  102.             read(f, lu, 4);
  103.             lu[5]='\0';
  104.             printf("%s\n", lu);
  105.             break;
  106.         default:
  107.             // Pere
  108.             printf("pere cree %d\n", pid);
  109.             sleep(1);
  110.             read(f, lu, 4);
  111.             lu[5]='\0';
  112.             printf("%s\n", lu);
  113.             write(f, "Pere\n", 6);
  114.     }
  115.     close(f);
  116.  
  117. }
  118.  
  119. //exo 5
  120.  
  121. int main(void){
  122.  
  123.  
  124.     int code_retour,status;
  125.     printf("Debut du test fork()\n");
  126.     //toto = fork()
  127.     code_retour = fork();
  128.     switch(code_retour){
  129.         case -1:
  130.             printf("pbm lors de la création du processus\n");
  131.             break;
  132.         case 0:
  133.             sleep(1);
  134.             printf("[%d] -- je suis le processus fils \n",getpid());
  135.             exit(0);
  136.             break;
  137.         default:
  138.  
  139.             printf("je suis le processus pere\n");
  140.             printf("je viens de creer le processus fils dont le pid est %d \n",code_retour);
  141.             wait(&status);
  142.             printf("le processus fils vient de se terminer, il avait pour PID: \n", code_retour);
  143.  
  144.     }
  145.     printf("code retour %d\n", code_retour);
  146.     printf("Fin du test fork()");
  147.     wait(&status);
  148.     printf("le status estf le suivant %d \n",status);
  149.     return 0;
  150. }
  151.  
  152.  
  153. //exo 6
  154.  
  155. int main(void)
  156. {
  157.  
  158.  
  159.     int terminaison;
  160.     int code_retour,status;
  161.     printf("Debut du test fork()\n");
  162.     //toto = fork()
  163.     code_retour = fork();
  164.     switch(code_retour)
  165.     {
  166.         case -1:
  167.             printf("pbm lors de la création du processus\n");
  168.             break;
  169.         case 0:
  170.             printf("[%d] -- je suis le processus fils \n",getpid());
  171.             exit(0);
  172.             sleep(10);
  173.             break;
  174.         default:
  175.             printf("je suis le processus pere\n");
  176.             printf("je viens de creer le processus fils dont le pid est %d \n",code_retour);
  177.             waitpid(code_retour, terminaison, WNOHANG);
  178.             if (WIFEXITED(terminaison))
  179.             {
  180.                 printf("le processus fils s'est terminé normalement\n");
  181.                 printf("code de retour du processus fils est : %d\n, WEXITSTATUS(terminaison)");
  182.             }
  183.             if (WIFSIGNALED(terminaison))
  184.             {
  185.                 printf("le processus fils s'est terminé à cause d'un signal\n");
  186.                 printf("le numero du signal ayant provoque la terminaison du processus fils est : %d\n",
  187.                        WTERMSIG(terminaison));
  188.             }
  189.             else
  190.             {
  191.                 printf("le processus fils ne s'est pas terminé normalement et ce n'est pas à cause d'un signal\n");
  192.             }
  193.  
  194.             //printf("le processus fils vient de se terminer, il avait pour PID: \n", code_retour);
  195.  
  196.  
  197.     }
  198.     printf("code retour %d\n", code_retour);
  199.     printf("Fin du test fork()");
  200.     wait(&status);
  201.     printf("le status estf le suivant %d \n",status);
  202.     return 0;
  203. }
  204.  
  205.  
  206. //exercice 9
  207.  
  208. void main(){
  209.     char buf[80];
  210.  
  211.     printf("[%d]--Debut du test exec ()\n",getpid());
  212.     sprintf(buf,"--pid=[%d]",getpid());
  213.     execl("/bin/echo","echo","Execution","d'un test exec", buf, null);
  214.     printf("[%d]--Echec de la fonction execl()\n",getpid());
  215.     printf("[%d]--Fin du test execl()\n",getpid());
  216.     exit(0);
  217. }
  218.  
  219. void main(){
  220.     char buf[80];
  221.  
  222.     printf("[%d]--Debut du test exec ()\n",getpid());
  223.     sprintf(buf,"--pid=[%d]",getpid());
  224.     execl("/bin/ech","echo","Execution","d'un test exec", buf, null);
  225.     printf("[%d]--Echec de la fonction execl()\n",getpid());
  226.     printf("[%d]--Fin du test execl()\n",getpid());
  227.     exit(0);
  228. }
  229.  
  230.  
  231. //exercice 10
  232.  
  233. //question a)
  234. int main(void) {
  235.     int code_retour,status;
  236.     printf("Debut du test fork()\n");
  237.     code_retour = fork();
  238.     switch(code_retour){
  239.         case -1:
  240.             printf("pbm lors de la création du processus\n");
  241.             break;
  242.         case 0:
  243.             execl("/bin/ps","ps","-l",null);
  244.             break;
  245.         default:
  246.             wait(&status);
  247.             break;
  248.     }
  249. }
  250.  
  251. int main(void) {
  252.     char *argv[NMAX];
  253.     argv [0] = "ps";
  254.     argv [1] = "-l";
  255.     argv [2] = null;
  256.     int code_retour,status;
  257.     printf("Debut du test fork()\n");
  258.     code_retour = fork();
  259.     switch(code_retour){
  260.         case -1:
  261.             printf("pbm lors de la création du processus\n");
  262.             break;
  263.         case 0:
  264.             execv("/bin/ps",argv);
  265.             break;
  266.         default:
  267.             wait(&status);
  268.             break;
  269.     }
  270. }
  271.  
  272. extern int errno;
  273.  
  274. typedef void (*sighandler_t)(int);
  275. static char *my_argv[100], *my_envp[100];
  276. static char *search_path[10];
  277.  
  278. void handle_signal(int signo)
  279. {
  280.     printf("\n[shell_max_bourgeat ] ");
  281.     fflush(stdout);
  282. }
  283.  
  284. void fill_argv(char *tmp_argv)
  285. {
  286.     char *foo = tmp_argv;
  287.     int index = 0;
  288.     char ret[100];
  289.     bzero(ret, 100);
  290.     while(*foo != '\0') {
  291.         if(index == 10)
  292.             break;
  293.  
  294.         if(*foo == ' ') {
  295.             if(my_argv[index] == null)
  296.                 my_argv[index] = (char *)malloc(sizeof(char) * strlen(ret) + 1);
  297.             else {
  298.                 bzero(my_argv[index], strlen(my_argv[index]));
  299.             }
  300.             strncpy(my_argv[index], ret, strlen(ret));
  301.             strncat(my_argv[index], "\0", 1);
  302.             bzero(ret, 100);
  303.             index++;
  304.         } else {
  305.             strncat(ret, foo, 1);
  306.         }
  307.         foo++;
  308.         /*printf("foo is %c\n", *foo);*/
  309.     }
  310.     my_argv[index] = (char *)malloc(sizeof(char) * strlen(ret) + 1);
  311.     strncpy(my_argv[index], ret, strlen(ret));
  312.     strncat(my_argv[index], "\0", 1);
  313. }
  314.  
  315. void copy_envp(char **envp)
  316. {
  317.     int index = 0;
  318.     for(;envp[index] != null; index++) {
  319.         my_envp[index] = (char *)malloc(sizeof(char) * (strlen(envp[index]) + 1));
  320.         memcpy(my_envp[index], envp[index], strlen(envp[index]));
  321.     }
  322. }
  323.  
  324. void get_path_string(char **tmp_envp, char *bin_path)
  325. {
  326.     int count = 0;
  327.     char *tmp;
  328.     while(1) {
  329.         tmp = strstr(tmp_envp[count], "PATH");
  330.         if(tmp == null) {
  331.             count++;
  332.         } else {
  333.             break;
  334.         }
  335.     }
  336.         strncpy(bin_path, tmp, strlen(tmp));
  337. }
  338.  
  339. void insert_path_str_to_search(char *path_str)
  340. {
  341.     int index=0;
  342.     char *tmp = path_str;
  343.     char ret[100];
  344.  
  345.     while(*tmp != '=')
  346.         tmp++;
  347.     tmp++;
  348.  
  349.     while(*tmp != '\0') {
  350.         if(*tmp == ':') {
  351.             strncat(ret, "/", 1);
  352.             search_path[index] = (char *) malloc(sizeof(char) * (strlen(ret) + 1));
  353.             strncat(search_path[index], ret, strlen(ret));
  354.             strncat(search_path[index], "\0", 1);
  355.             index++;
  356.             bzero(ret, 100);
  357.         } else {
  358.             strncat(ret, tmp, 1);
  359.         }
  360.         tmp++;
  361.     }
  362. }
  363.  
  364. int attach_path(char *cmd)
  365. {
  366.     char ret[100];
  367.     int index;
  368.     int fd;
  369.     bzero(ret, 100);
  370.     for(index=0;search_path[index]!=null;index++) {
  371.         strcpy(ret, search_path[index]);
  372.         strncat(ret, cmd, strlen(cmd));
  373.         if((fd = open(ret, O_RDONLY)) > 0) {
  374.             strncpy(cmd, ret, strlen(ret));
  375.             close(fd);
  376.             return 0;
  377.         }
  378.     }
  379.     return 0;
  380. }
  381.  
  382. void call_execve(char *cmd)
  383. {
  384.     int i;
  385.     printf("cmd is %s\n", cmd);
  386.     if(fork() == 0) {
  387.         i = execve(cmd, my_argv, my_envp);
  388.         printf("errno is %d\n", errno);
  389.         if(i < 0) {
  390.             printf("%s: %s\n", cmd, "command not found");
  391.             exit(1);      
  392.         }
  393.     } else {
  394.         wait(null);
  395.     }
  396. }
  397.  
  398. void free_argv()
  399. {
  400.     int index;
  401.     for(index=0;my_argv[index]!=null;index++) {
  402.         bzero(my_argv[index], strlen(my_argv[index])+1);
  403.         my_argv[index] = null;
  404.         free(my_argv[index]);
  405.     }
  406. }
  407.  
  408. int main(int argc, char *argv[], char *envp[])
  409. {
  410.     char c;
  411.     int i, fd;
  412.     char *tmp = (char *)malloc(sizeof(char) * 100);
  413.     char *path_str = (char *)malloc(sizeof(char) * 256);
  414.     char *cmd = (char *)malloc(sizeof(char) * 100);
  415.    
  416.     signal(sigint, sig_ign);
  417.     signal(sigint, handle_signal);
  418.  
  419.     copy_envp(envp);
  420.     get_path_string(my_envp, path_str);
  421.     insert_path_str_to_search(path_str);
  422.  
  423.     if(fork() == 0) {
  424.         execve("/usr/bin/clear", argv, my_envp);
  425.         exit(1);
  426.     } else {
  427.         wait(null);
  428.     }
  429.     printf("[shell_max_bourgeat ] ");
  430.     fflush(stdout);
  431.     while(c != eof) {
  432.         c = getchar();
  433.         switch(c) {
  434.             case '\n': if(tmp[0] == '\0') {
  435.                        printf("[shell_max_bourgeat ] ");
  436.                    } else {
  437.                        fill_argv(tmp);
  438.                        strncpy(cmd, my_argv[0], strlen(my_argv[0]));
  439.                        strncat(cmd, "\0", 1);
  440.                        if(index(cmd, '/') == null) {
  441.                            if(attach_path(cmd) == 0) {
  442.                                call_execve(cmd);
  443.                            } else {
  444.                                printf("%s: command not found\n", cmd);
  445.                            }
  446.                        } else {
  447.                            if((fd = open(cmd, O_RDONLY)) > 0) {
  448.                                close(fd);
  449.                                call_execve(cmd);
  450.                            } else {
  451.                                printf("%s: command not found\n", cmd);
  452.                            }
  453.                        }
  454.                        free_argv();
  455.                        printf("[shell_max_bourgeat ] ");
  456.                        bzero(cmd, 100);
  457.                    }
  458.                    bzero(tmp, 100);
  459.                    break;
  460.             default: strncat(tmp, &c, 1);
  461.                  break;
  462.         }
  463.     }
  464.     free(tmp);
  465.     free(path_str);
  466.     for(i=0;my_envp[i]!=null;i++)
  467.         free(my_envp[i]);
  468.     for(i=0;i<10;i++)
  469.         free(search_path[i]);
  470.     printf("\n");
  471.     return 0;
  472. }
Parsed in 0.104 seconds