Ausgabe eines Aufgerufenen Programms in C verwenden

mekick schrieb:

how to() ?

ist das einfach ne while-schleife, die runterläuft bis es keine nächste zeile mehr gibt und von oben alles in einen string schreibt oder wie hab ich mir das vorzustellen?

Ja, möglicherweise. Du kannst aber gleich beim lesen auswerten.

mekick schrieb:

So sieht das ganz realistisch aus, was ich einlesen muss: ...

Und was möchtest du davon haben?
Die Anzahl der Wörter oder die IP-Adressen oder .... ?
DAvon hängt es dann ab, wie du weiter machst.

rkhb

Ist das ein Rumgeeiere hier! Ich habe hier einmal ein Beispiel für drei mögliche Ansätze:

Ausgabe umleiten in eine Datei.
Ausgabe per popen zeilenweise einlesen
Ausgabe per popen im Block einlesen

Das Beispiel kann optimiert werden und auf persönliche Anforderungen angepasst werden
(und es gibt auch noch andere Möglichkeiten), aber es zeigt, wie es gehen kann:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

void to_file (char* cmd)
{
    char redirect[256] = ">tmp.txt ";
    strcat (redirect, cmd);
    system (redirect);
}

void popen_line_by_line (char* cmd)
{
    char   psBuffer[128] = {0};

    FILE   *pPipe;
    pPipe = popen( "ls -l", "r" );
    if( !pPipe ) exit( 1 );

    while(fgets(psBuffer, 128, pPipe))
    {
        printf ("%s",psBuffer);
        fflush (stdout);
    }
    pclose (pPipe);
}

void popen_to_buffer (char* cmd)
{
    char   psBuffer[128] = {0};
    char msgBuffer[4096] = {0};

    FILE   *pPipe;
    pPipe = popen(cmd , "r" );
    if( !pPipe ) exit( 1 );

    while(fgets(psBuffer, 128, pPipe))
    {
        printf ("%s",psBuffer);
        fflush (stdout);
        strcat(msgBuffer,psBuffer);
    }
    pclose (pPipe);
    printf ("%s",msgBuffer);
}

int main ( void )
{
    char* cmd = "ls -l";

    // Nach Bedarf auskommentieren
    to_file(cmd);
    popen_line_by_line (cmd);
    popen_to_buffer(cmd);

    return 0;
}

Ich persönlich hätte für die Aufgabe eine modernere Skriptsprache (z.B. PHP) gewählt,
da diese die gewünschte Funktionalität fest und relativ idiotensicher eingebaut haben.

viele grüße
ralph

SeppJ

Die wohl in den meisten Fällen "richtigste" Möglichkeit ist aber immer noch das, was Th69 vorgeschlagen hat. Alles deutet da drauf hin, dass dies auch hier die richtige Wahl wäre.
Man muss nicht immer die genaue Frage des Threaderstellers beantworten, wenn doch offensichtlich ein X-Y Problem vorliegt.

rkhb schrieb:

...
void to_file (char* cmd)
{
    char redirect[256] = ">tmp.txt ";
    strcat (redirect, cmd);
    system (redirect);
...

int main ( void )
{
    char* cmd = "ls -l";

    // Nach Bedarf auskommentieren
    to_file(cmd);
...
}

Was macht denn der Befehl >tmp.txt ls -l ?

Wutz

Das ist ein Deppenbeispiel, und genau so macht man es eben nicht.
Das Deppenbeispiel setzt voraus, dass im aktuellen Verzeichnis Schreibrechte und ausreichend Platz vorliegen, und wer räumt den Müll da hinterher wieder weg?
Genau, der Deppenprogrammierer sicherlich nicht.
All das entfällt, wie oben erwähnt, wenn man die POSIX konforme Funktion popen/pclose verwendet.

rkhb

DirkB schrieb:

Was macht denn der Befehl >tmp.txt ls -l ?

Das Gleiche wie in einer Windows-Konsole ">tmp.txt dir". Der Trick: Man kann die Umleitung auch nach vorne bringen.

viele grüße
ralph

lagalopex

Nur als Hinweis... nmap unterstützt verschiedene Ausgaben. Es gibt so zB grepable- und auch xml-Ausgaben.

mekick

Nur zur info .. ich habe jetzt folgende Lösung gewählt:

1. gesamten Output in output.txt schreiben
2. mit getline() aus dem gcc GNU Compiler Zeilenweise einlesen
3. mit den strXXX()-Funktionen die Inhalte der einzelnen Zeilen auf Muster vergleichen

Das schien mir anhand meiner bisherigen Kenntnisse die geeignetste Lösung und da ich mir nochmals die Anwendung des Programms vor Augen geführt habe ist mir klar geworden, dass es gar nicht schlecht ist, dass ich nun eine Ausgabedatei erhalte, da ich im Laufe des Programms mehrere Aufrufe machen müsste oder aber unübersichtliche Variablendefinitionen zwischenschieben müsste, so aber jetzt einfach immer wieder die output.txt als bestehenden Ausgangsstream nutzen kann.

Ich meine diese Lösung nennt sich jetzt Ausgabe in Datei umlenken und anschließendes Pathen ..?

Danke für eure Hilfe!!

Liebe Grüße,
Felix

Hier nochmal der Code:

// Pointer auf Datei = ptoutput
  FILE *ptoutput;
  // Prototyp von getline(): ssize_t getline(char** ReservierterSpeicherFürInputLine, size_t* ByteGrößeDesReserviertenSpeichers, FILE* InputStream)
  // Speicher für Buffer/InputLine festlegen
  char * ptline_in;
  ptline_in = (char *) malloc(70);

  // Variable für die Größe der Textzeile in Bytes
  size_t istorage = 70;

  // Wenn die Datei output.txt nicht geöffnet werden kann
  // Gebe Error aus
  if ( (ptoutput = fopen("output.txt","r")) == NULL) 
  {
    fprintf(stderr, "\nKonnte Datei 'output.txt' nicht öffnen!");
    return EXIT_FAILURE;
  }

  // Zeilenweises Einlesen von output.txt und Ausgeben der Gelesenen Zeilen und der Größe der Zeilen
  while(getline(&ptline_in, &istorage, ptoutput) > 0)
  {
    printf("Line: %s \nBytes: %u \n", ptline_in, istorage);
  }
  return EXIT_SUCCESS;

Du hast free vergessen.

Th69

mekick schrieb:

Ich meine diese Lösung nennt sich jetzt Ausgabe in Datei umlenken und anschließendes Pathen ..?

Du meinst "parsen"!

Und wer erzeugt jetzt die Textdatei?
Trotzdem ist meine Variante immer noch die einfachste, nämlich von der Standardeingabe (stdin) zu lesen, anstatt aus einer Datei...