C++ IP-Liste einlesen und anpingen

Alfons2

Mitglied
Huhu, mein vorhaben, ist wie sich die Leute schon denken können die den Titel gelesen haben, ist eine IP-Liste in z.B. liste.txt einzulesen und sie nach und nach nur checken, ob der Rechner mit der IP online ist oder nicht. Das geht am besten mit einem Ping und das Ergebniss soll er wie unten ausgeben. Diese Datei sollte dann immer weiter laufen und praktisch alle 10min den Vorgang wiederholen. Und das ganze in C++.

Code:
192.168.1.1 - online
192.168.1.6 - online
192.168.1.8 - offline
192.168.1.22 - offline
192.168.1.34 - online
wichtig sind auch die Farben!

Also ich fang mal an:

Code:
#include <cstdlib>
#include <iostream>
#include <fstream>

using namespace std;


int main(int argc, char *argv[])
{
    
ifstream    filename;    
    filename = liste.txt;

    
do {
file_stream.open("liste.txt", ios_base::out | ios_base::in);
  
  
  
 } while()

file_stream.close();

    system("PAUSE");
    return EXIT_SUCCESS;
}
 
Zuletzt bearbeitet:
Hi,

wenn cih deinen Code so seh ersma die Frage:
Hast du Erfahrung mit C++ bzw. haste damit schonmal Programiert?
Ich sag nur:
filename = liste.txt;

Also das einlesen der IP Adressen sollte ja kein Problem sein nehme ich an.
Falls doch versuchs mal hiermit:
FILE, fopen, fclose, fscanf <--- sollte in "stdio.h" zu finden sein.

Das anpingen schon eher denke ich.
Ich weiß nich obs mit Sockets geht, vll mal googlen:
SOCKET, WinSock2.
Ansonsten mal nen Beispiel zu "Ping" in der Console angucken.

Farben:
mit
C++:
system("color xx");
kanst du die Farbe der Console ändern.
Wobei X für verschiedene Farbwerte steht.
Die erste Zahl ist die Vordergrundfarbe(Schriftfarbe),
die zweite die Hintergrundfarbe.

Vll jetzt erstmal googlen und dann nochmal melden.

MFG
Anfänger
 
Zuletzt bearbeitet von einem Moderator:
system("color xx");
Ist aber nur für die gesammte Konsole und nicht für einzelne Zeichen/Wörter.

Ich bin kein Meister in C++ aber nen bisschen kenn ich mich schon aus :D
Nur im Einlesen eines Files macht es Probleme bzw. eher beim auswerten.

Ich muss doch, die z.B. 50 IPs (können es locker werden) alle in einen array umwandeln, die er dann alle nach der Reihe abfragt. Dann das online/offline ergebniss in einen weiteren array eintragen und ausgeben.

Aber wichtig ist, das es eine Liste ist, die ich nachträglich ändern kann und wenn möglich nicht auf 50 begrenzt ist.
 
Ein std::vector ist ein dynamisches Feld!

Das würde das Problem der begrenzten Anzahl lösen.

Naja ich mache morgen weiter bin Müde

gn8
 
Hier mal eine Pingfunktion (nicht selber geschrieben und vielleicht nicht der schönste Code :) , aber ich hab bis jetzt keinen Fehler feststellen können, läuft seit einem Jahr)
C++:
#define ICMP_ECHOREPLY 0
#define ICMP_UNREACHABLE 3
#define ICMP_ECHO 8
#define ICMP_CODE_NETWORK_UNREACHABLE 0
#define ICMP_CODE_HOST_UNREACHABLE 1
#define ICMP_MIN_SIZE 8
#define STATUS_FAILED 0xFFFF
#define PING_FAILED 0xFFFFF0
#define PING_TIMEOUT 0xFFFFF1
#define PING_NOHOST 0xFFFFF2

unsigned short Ping_Checksum(unsigned short *buffer,int size){unsigned long cksum=0;while(size>1)
{cksum+=*buffer++;size-=sizeof(unsigned short);}if(size){cksum+=*(unsigned char*)buffer;}
cksum=(cksum>>16)+(cksum&0xffff);cksum+=(cksum>>16);return((unsigned short)(~cksum));}

unsigned int Ping_Ext(const char *ip,unsigned int datasize,int recvtimto){SOCKET sckSock;
SOCKADDR_IN saDest,saFrom;int nRecvTimeOut=recvtimto;datasize+=sizeof(icmp_header_t);
char *szICMPData=0;char szRecvBuff[65000+sizeof(ip_header_t)+sizeof(icmp_header_t)];DWORD dwStart,
dwStop;if((sckSock=socket(AF_INET,SOCK_RAW,IPPROTO_ICMP))==INVALID_SOCKET)return PING_FAILED;
if(setsockopt(sckSock,SOL_SOCKET,SO_RCVTIMEO,(char *)&nRecvTimeOut,sizeof(nRecvTimeOut))==
SOCKET_ERROR)return PING_FAILED;{unsigned long ulAddr=inet_addr(ip);HOSTENT *pHostEntity=0;
if(ulAddr==INADDR_NONE){pHostEntity=gethostbyname(ip);memcpy(&ulAddr,pHostEntity->h_addr,
pHostEntity->h_length);}saDest.sin_addr.s_addr=ulAddr;saDest.sin_family=(pHostEntity?pHostEntity->
h_addrtype:AF_INET);saDest.sin_port=0;}{szICMPData=(char *)malloc(sizeof(icmp_header_t)+datasize+1);
if(szICMPData==NULL)return PING_FAILED;((icmp_header_t *)szICMPData)->i_cksum=0;((icmp_header_t *)szICMPData)->i_code=0;
((icmp_header_t *)szICMPData)->i_id=(unsigned short)GetCurrentProcessId();((icmp_header_t *)szICMPData)->
i_seq=0;((icmp_header_t *)szICMPData)->i_type=ICMP_ECHO;memset(szICMPData+sizeof(icmp_header_t),'.',datasize);
memcpy(szICMPData+sizeof(icmp_header_t),"xyxyz pings",min(datasize,11));}{((icmp_header_t *)szICMPData)->
timestamp=GetTickCount();((icmp_header_t *)szICMPData)->i_cksum=Ping_Checksum
((unsigned short *)szICMPData,datasize+sizeof(icmp_header_t));}if(sendto(sckSock,szICMPData,
sizeof(icmp_header_t)+datasize,0,(SOCKADDR *)&saDest,sizeof(saDest))==SOCKET_ERROR)return
PING_FAILED;dwStart=GetTickCount();while(1){int iResponseLen=0;{int nFromLen=sizeof(saFrom);
iResponseLen=recvfrom(sckSock,szRecvBuff,65000+sizeof(ip_header_t)+sizeof(icmp_header_t),0,
(SOCKADDR *)&saFrom,&nFromLen);dwStop=GetTickCount();if(iResponseLen==SOCKET_ERROR)
{if(WSAGetLastError()==WSAETIMEDOUT)return PING_TIMEOUT;else{return PING_FAILED;}}}
{ip_header_t *hdrIPHeader=(ip_header_t *)szRecvBuff;icmp_header_t *hdrICMPHeader
=(icmp_header_t *)(szRecvBuff+hdrIPHeader->h_len*4);if(hdrICMPHeader->i_id!=
(unsigned short)GetCurrentProcessId())continue;if(hdrICMPHeader->i_type==
ICMP_UNREACHABLE)if(hdrICMPHeader->i_code==ICMP_CODE_HOST_UNREACHABLE||
hdrICMPHeader->i_code==ICMP_CODE_NETWORK_UNREACHABLE)return PING_NOHOST;
if(hdrICMPHeader->i_code==ICMP_ECHOREPLY)break;}}free(szICMPData);
return dwStop-dwStart;}

int Ping(const char *ip,unsigned short int z=1000){int i=Ping_Ext(ip,32,z);
if(i==PING_FAILED||i==PING_TIMEOUT||i==PING_NOHOST)return -1;return i;}

Das Original ist eigentlich Ping_Ext, aber der seltsamen Klotz ist ziemlich unpraktisch zum aufrufen.
Du übergibst der Funktion Ping einfach die IP, wenn -1 zurückkommt wars Offline, sonst sinds die Millisekunden, wielang die Antwort gebraucht hat.
Du kannst der Funktion nach der IP auch noch die Millisekunden übergeben, die sie max. warten soll.

Hoffe, dir hilft das
Sheel

edit:Wegen der Farben: SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0xAB);
Statt dem AB nimmst du halt die Werte für Hintergrund und Schrift, aufgelistet in der cmd: "color /?"
 
Zuletzt bearbeitet:
Vielen Dank! Wird mir bestimmt sehr helfen, allderdings nun keine Zeit zum programmieren :(

Aber wenn das eine eigene Funktion ist, dann kann ich sie ja in eine Headerdatei reinschreiben, mit dem Namen Ping_Ext und diese dann mit #include "Ping_Ext"
aufrufen.

Beim aufrufen dieser Funktion, die IP, gegebenfalls die Millisekunden dazu und das Script machen lassen. Den Rückgabewert auswerten,
Code:
If (Ping_Ext == -1) {
{ cout << ip <<"offline\n";
}
else
{
cout << ip <<"online\n";
}

Als was muss ich eine IP setzen? int, float, ... geht ja nicht weil das dann ja mehr als eine Nachkommastelle wären.

EDIT:

Was muss ich alles includieren?

Ich habe:
Code:
#include <iostream>
#include <cstdio>
#include <winsock2.h>
diese includiert, aber anscheinend brauch ich nochwas
 
Zuletzt bearbeitet:
Also bei der Includedatei solltest du vielleicht ein .h beim Dateinamen noch anhängen

Inkludieren müsstest du glaub ich noch windows.h

und statt
If (Ping_Ext == -1)
wäre doch

char ip[64];
...
If (Ping(ip) == -1)

Irgendwie sinnvoller

Wie gesagt, Ping_Ext liefert irgendwelche seltsamen Zahlen zurück, verwende lieber Ping

Zeig vielleicht mal deinen aktuellen Stand
 
Hab dir hier mal das Projekt schnelll hochgeladen, aber muss jetzt dringend los, bin noch nicht sehr sweit gekommen :(


In Verbindung mit windows.h macht er probleme beim compilen, da muss glaub ich nohc eine dll datei reingebunden werden

Anhang anzeigen Pinger.zip

machs gut bis nachher alfi :)
 
So, ist doch ein bisschen später geworden, aber habe nun schonmal etwas weiter gebastelt, ich hab es nun nochmal mit Visual C++ Express gemacht...

Ich muss noch die IP-Liste interpretieren lassen, geöffnet wird sie schonmal erfolgreich, und die Ips, der Funktion Ping_Ext, die ich in eine header Datei mit Namen Ping_Ext.h gelegt habe, übergeben. Den Rückgabewert wieder einsammeln und mit
Code:
char ip[64];
...
If (Ping(ip) == -1)
auswerten und anzeigen lassen.


Das mit den Farben klappt nun hundert Prozentig so wie ich es haben will :)

Code:
#include <windows.h>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <fstream>


// SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x0A);	<-- Schwarz:Grün
// SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x0c);	<-- Schwarz;Rot		
// SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x07);	<-- Schwarz;Grau Normale Konsole 
// cout << "Hallo Grüne Welt\n";

using namespace std;

int main()
{


  FILE * pFile;
  pFile = fopen ("liste.txt", "w");   // Die IP-Liste wird geöffntet und Schreibrechte gesetzt
  if (pFile==NULL)                   // Test ob das File existiert      
  {
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x0c);
	cout << "Achtung! Die Datei 'liste.txt' konnte nicht geladen werden!\n";
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x07);
    fputs ("fopen example",pFile);
    fclose (pFile);
  }
  else{
	  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x0A);
	  cout << " Die Datei 'liste.txt' konnte erfolgreich geladen werden!\n";
	  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x07);
	  }
do{




Sleep(600000); //10min warten
}while(quiter == 0); 




system("pause");
return 0;      
}
 
Zurück