title: read structure in function from list in c
body: <p>I'm writing some structure information in a list. The structure is Pstatus and it is global defined as pGlobal. Now I want to read from this list with pGlobal in function getStatus() but that did not work. So I created another definition pGlobal2 but that makes a lot of problems. I want to read out my list but I get some false informations. In this list the pids of the running processes are stored but when I read it out I only get the last pid and information but it I get it as much as pids are stored. If there are 5 pids stored in this list, I get the last one 5 times. I think thats because I've got pGlobal and pGlobal2. Is anybody able to help me?</p>
  
  <pre><code>    #include &lt;unistd.h&gt;
      #include &lt;stdlib.h&gt;
      #include &lt;stdio.h&gt;
      #include &lt;string.h&gt;
      #include &lt;unistd.h&gt;
      #include &lt;sys/types.h&gt;
      #include &lt;sys/wait.h&gt;
      #include &lt;fcntl.h&gt;
      #include &lt;errno.h&gt;
  
  
      #include "utils.h"
      #include "listen.h"
      #include "wortspeicher.h"
      #include "kommandos.h"
      #include "frontend.h"
      #include "parser.h"
      #include "variablen.h"
  
      int interpretiere(Kommando k, int forkexec);
      int interpretiere_einfach(Kommando k, int forkexec);
      int getStatus();
      Pstatus pGlobal;
      Pstatus *pGlobal2;
  
      Liste procTable;
  
  
      int aufruf(Kommando k, int forkexec){
  
          int kind_status, i;
  
        /* Programmaufruf im aktuellen Prozess (forkexec==0)
           oder Subprozess (forkexec==1)
        */
  
        if(forkexec){
          int pid=fork();
  
          switch (pid){
          case -1:
            perror("Fehler bei fork"); 
            return(-1);
          case 0:
            if(umlenkungen(k))
          exit(1);
            do_execvp(k-&gt;u.einfach.wortanzahl, k-&gt;u.einfach.worte);
            abbruch("interner Fehler 001"); /* sollte nie ausgeführt werden */
          default:
            if(k-&gt;endeabwarten) {
                /* So einfach geht das hier nicht! */
  
                /* schreibt die PID, den Namen und den Status in die Tabelle */  
                pGlobal = erzeugeProzess (pid, k-&gt;u.einfach.worte[0], "RUNNING"); /*k-&gt;u.einfach.worte[0] */
                /* Debug: print
                printf("\npid: %d\tstatus: %s\n", p.pid, p.status); 
                */
                i = listeLaenge(procTable);
                procTable = listeAnfuegen(procTable, &amp;pGlobal);
                if(listeLaenge(procTable) &lt;= i) {
                  fprintf(stderr, "Fehler beim Schreiben in die Liste!");
                }
  
                /* Debug printf: Bis hierhin wird alles ordentlich in die Liste geschrieben! */
                /*test = listeKopf(procTable);
                printf("pointer1: %p",test);
                printf("\npid: %d\tstatus: %s\n", test-&gt;pid, test-&gt;status); */
  
  
                waitpid(pid, &amp;kind_status, 0);
                  if(WIFEXITED(kind_status)){
                      printf("Kind mit der PID %d wurde beendet\n",pid);
                      if (WEXITSTATUS(kind_status) == 0) {
                          /** setze status exit(0) */ 
                          printf("Kind erfolgreich\n");
                          pGlobal = statusAendern(pGlobal,pid,"exit(0)"); 
                      } 
                      /* nicht erfolgreiche ausgeführt */
                      else 
                      {
                          /** setze status exit(1) */ 
                          printf("Kind nicht erfolgreich\n");
                          pGlobal = statusAendern(pGlobal,pid,"exit(1)"); 
                      }
                  }
                  else if(WIFSIGNALED(kind_status)){
                      printf("Kind mit der PID %d wurde durch Signal abgebrochen. Signalnummer: %d\n",pid, WTERMSIG(kind_status));
                      pGlobal = statusAendern(pGlobal,pid,"signal"); 
                  }
            }
            else {
              fprintf(stderr, "Programm nicht beendet\n");
              fprintf(stdout, "PID: %i\n", pid);
            }  
            return 0;
          }
        }
  
        /* nur exec, kein fork */
        if(umlenkungen(k))
          exit(1);
        do_execvp(k-&gt;u.einfach.wortanzahl, k-&gt;u.einfach.worte);
        abbruch("interner Fehler 001"); /* sollte nie ausgeführt werden */
        exit(1);
      }
  
  
      int interpretiere_einfach(Kommando k, int forkexec){    
  
        char **worte = k-&gt;u.einfach.worte;
        int anzahl=k-&gt;u.einfach.wortanzahl;
  
        /* gibt den Status der Subprozesse zurück */
        if (strcmp(worte[0], "status")==0){
  
            /* NYI */
          getStatus();
  
        }
  
        return aufruf(k, forkexec);
      }
  
      int getStatus() {
  
          Liste temp, temp2;
  
          fprintf(stdout, "---------------------\n----Statustabelle----\n---------------------\n");
  
          temp = procTable;
  
          printf("laenge der liste: %d\n",listeLaenge(temp));
  
          /*fprintf(stdout, "Pid: %d", p-&gt;pid);*/
  
          if(listeLaenge(temp) &lt; 1) {
              fprintf(stdout, "Liste ist leer.\n");
              return 0;
          }
  
          while(temp != NULL){
  
              pGlobal2 = listeKopf(temp);
  
              /*printf("check: %d\n",pGlobal2-&gt;check);*/
  
              if(pGlobal2-&gt;check &lt; 1) {
                  fprintf(stdout,"PID: %d, Programm: %s, Status: %s\n",pGlobal2-&gt;pid, pGlobal2-&gt;name, pGlobal2-&gt;status);
              }
  
              if(strcmp(pGlobal2-&gt;status, "RUNNING") != 0) {
                  pGlobal2-&gt;check = 1;
              }   
  
              /*if(strcmp(pGlobal2-&gt;status, "RUNNING") == 0) {
                  printf("eintrag behalten");
                  listeAnfuegen(temp2, pGlobal2);
              }*/
  
  
              /* wenn status != running -&gt; p.checked() */
  
              temp = listeRest(temp);
            }
          return 0;
      }
  
  }
  </code></pre>
  
  <p>I've got the struct </p>
  
  <pre><code>typedef struct {
  int pid;        /* Prozess ID */
  char* name;     /* Prozess Name (Programm) */
  char* status;   /* Status des Programms */
  int check;      /* bereits abgerufen? 1 - abgerufen, 0 - nicht abgerufen */
  } Pstatus;
  </code></pre>
  
  <p>Listen: </p>
  
  <pre><code>typedef struct liste {
    void *kopf;
    struct liste *rest;
  } *Liste;
  </code></pre>
  
  <p>listeKopf:</p>
  
  <pre><code>void* listeKopf(Liste l) { 
    if(l==NULL)
      abbruch("listeKopf(listeLeer) undefiniert");
    return l-&gt;kopf; 
  }
  </code></pre>
  
  <p>listeAnfuegen:</p>
  
  <pre><code>Liste listeAnfuegen(Liste l, void* element){
    Liste neu=reserviere(sizeof (struct liste));
    neu-&gt;kopf = element;
    neu-&gt;rest = l;
    return neu;
  }
  </code></pre>