Ich habe folgendes Problem. Ich soll sämtlichen Inhalt eines Protokolls an einem PC aufnhemen und die Daten entweder direkt in eien SQL-Datenbank schreiben oder eben in irgendeiner Form dieser zur Verfügung stellen. Der 2. Teil sollte kein Problem darstellen.
Mein Problem ist, wie komme ich an die ethernet Daten ran? Wäre es ein File welcher Art auch immer, wäre das weniger ein Problem, aber so fhelt mir momentan jegliche Idee.
Vorgabe ist, dass alles mit C++ programmiert wird und dann eben in eine SQL-Server 2005 Datenbank geschrieben wird. Protokollauslese-Tools sind also nicht geünscht, sondern ich soll eben einen C++ Code schreiben, der die Daten von der ethernet Schnittstelle aufnimmt.
Vielen Dank shconmal für jede Hilfe!

Also geht in erster Linie wirklich nur darum, einen Datenstrom der über ethernet ankommt zu empfangen.

Es sind Positionsdaten, die ein einem selbstentwickelten (nicht von mir) Protokoll gesendet werden, was bis einschließlich Layer5 ethernet ist, also auf TCP und IP dann aufbaut. Darin steht z.b. Fritz hat Position 6.
Die Daten dann in die Datenbank zu sortieren ist kein Problem, aber ich muss ja erstmal die Daten von der Netzwerkarte irgendwie herholen.

Habe mittelgute C++ und SQLDeveloper Erfahrungen, aber keinen Schimmer, wie ich bei dem Problem starten soll. Wären die Daten in einer Datei (CSV o.ä.) wäre das ja kein Problem, sowas lernt man im Studium, aber wie man an Daten die nicht in einer Datei sind rankommt...

Wenn ich dich recht verstehe, willst du sogar irgendwo in die untersten Ebenen des Netzwerkprotokolls eingreifen. Ich wäre mir nicht so sicher, ob das überhaupt möglich ist, ohne einen eigenen Treiber zu schreiben. edit: Nein, das wolltest du wohl doch nicht. Wieso nicht einfach so etwas wie Boost ASIO? Dann hast du die betriebssystemabhängigkeit sogar weggekapselt.

Bitte beschreib´ doch mal die aktuelle Situation, insbesondere wie die Kommunikation aussieht und wo dein Logger steht. Soll dein Logger die Kommunikation selbst abwickeln oder eine fremde Verbindung belauschen?

die ein einem selbstentwickelten (nicht von mir) Protokoll gesendet werden, was bis einschließlich Layer5 ethernet ist, also auf TCP und IP dann aufbaut.

Ethernet betrifft Layer 1 und 2, Layer 3-5 haben mit Ethernet nichts zu tun.

OK, es handelt sich also um TCP/IP, das wäre die relevante Info gewesen. Ist auch keine Überraschung, ist ja auch bloss das meist verwendetste L5 Protokoll.

TCP/IP Connections kannst du mit den sog. Socket-Funktionen machen. connect, accept, recv, send etc.
Oder eben etwas wie Boost.ASIO verwenden, was die Funktionalität in mehr oder weniger einfach zu verwendende C++ Klassen einwickelt.

TCP passt nicht so ganz ins OSI Modell, weil es Layer 4 und Teile von 5 übernimmt. Wobei es sehr oft der Fall ist, dass die nicht von TCP implementierten L5 Features einfach gar nicht verwendet werden, oder in L7 implementiert werden.

Guckst du hier:
http://en.wikipedia.org/wiki/OSI_model#Examples

Heisst: in L5 ist in vielen Fällen "nix" ausser TCP, daher bezeichne ich TCP als L5 Protokoll.

Wobei es wohl üblicher ist TCP als L4 Protokoll zu bezeichnen - auch wenn ich das nicht ganz nachvollziehen kann. Vielleicht L4/5?

sock = socket(AF_INET,SOCK_PACKET,htons(ETH_P_ARP));

SOCK_PACKET steht dafür ,dass man auf Ethernet Ebene Aufbaut. Achtung man darf RAW_SOCKETS nur als Administrator erstellen sonst schlägt socket() fehl.

Und das ethernet Layer 1&2 kennzeichnet, IP Layer3 und TCP Layer4 war mir bewusst, aber man verstand (zum Glück) auch so was ich meinte.

Und die Verbindung will ich nur belauschen, ich häng nur mit einer Art Tap dazwischen. Die beiden Controller die miteinander kommunizieren haben ebenfalls ein selbstentwickeltes Betriebssystem (was ja egal sein sollte) und der PC mit dem ich zuhören will muss Windows XP haben.

Ich danke nochmals, werde erstmal eure ganzen Infos anschauen und verdauen und mich ggf. nochmals melden!

Und das ethernet Layer 1&2 kennzeichnet, IP Layer3 und TCP Layer4 war mir bewusst, aber man verstand (zum Glück) auch so was ich meinte.

Nein, war überhaupt nicht klar.

Wird sowieso jetzt erst klar, nachdem du schreibst...

Und die Verbindung will ich nur belauschen, ich häng nur mit einer Art Tap dazwischen. Die beiden Controller die miteinander kommunizieren haben ebenfalls ein selbstentwickeltes Betriebssystem (was ja egal sein sollte) und der PC mit dem ich zuhören will muss Windows XP haben.

Ach, das wäre aber auch ne wichtige Info gewesen.
Dann musst du erstmal deine Netzwerkkarte wo du "mitlauschen" willst in den "promiscuous" Mode schalten, sonst wirst du nämlich von dem was die zwei Controller miteinander plauschen nix mitbekommen.
Und du brauchst einen Hilfstreiber der Pakete capturen kann, wie eben WinPCap.

Und promiscuous-Mode weiß ich, brauch eh eine Karte mnit 2 Netzwerkanschlüssen, da der Netzwerk Tap (vermutlich ein Netoptics TP-CU) das Signal auf Tx und Rx auftrennt und je an eine Leitung al Rx weitergibt. Macht auch die Auswertung der Datenrichtung einfacher.

#include <pcap.h>
#include <winsock2.h>

#include <Tchar.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

using namespace std;

// default snap length (maximum bytes per packet to capture)
#define SNAP_LEN 1518

// ethernet headers are always exactly 14 bytes
#define SIZE_ETHERNET 14

// Ethernet addresses are 6 bytes
#define ETHER_ADDR_LEN	6

// Ethernet header
struct sniff_ethernet {
	u_char ether_dhost[ETHER_ADDR_LEN]; // Destination host address 
	u_char ether_shost[ETHER_ADDR_LEN]; // Source host address 
	u_short ether_type;					// IP? ARP? RARP? etc 
};

// IP header 
struct sniff_ip {
	u_char ip_vhl;				// version << 4 | header length >> 2 
	u_char ip_tos;				// type of service 
	u_short ip_len;				// total length 
	u_short ip_id;				// identification 
	u_short ip_off;				// fragment offset field 
#define IP_RF 0x8000			// reserved fragment flag 
#define IP_DF 0x4000			// dont fragment flag 
#define IP_MF 0x2000			// more fragments flag 
#define IP_OFFMASK 0x1fff		// mask for fragmenting bits 
	u_char ip_ttl;				// time to live 
	u_char ip_p;				// protocol 
	u_short ip_sum;				// checksum 
	struct in_addr ip_src,ip_dst;	// source and dest address 
};
#define IP_HL(ip)		(((ip)->ip_vhl) & 0x0f)
#define IP_V(ip)		(((ip)->ip_vhl) >> 4)

//TCP header 
struct sniff_tcp {
	u_short th_sport;	// source port 
	u_short th_dport;	// destination port 
	//tcp_seq th_seq;	// sequence number 
	//tcp_seq th_ack;	// acknowledgement number 

	u_char th_offx2;	// data offset, rsvd 
#define TH_OFF(th)	(((th)->th_offx2 & 0xf0) >> 4)
	u_char th_flags;
#define TH_FIN 0x01
#define TH_SYN 0x02
#define TH_RST 0x04
#define TH_PUSH 0x08
#define TH_ACK 0x10
#define TH_URG 0x20
#define TH_ECE 0x40
#define TH_CWR 0x80
#define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
	u_short th_win;		// window 
	u_short th_sum;		// checksum 
	u_short th_urp;		// urgent pointer 
};

// ethernet headers are always exactly 14 bytes 
#define SIZE_ETHERNET 14

struct sniff_ethernet *ethernet;	// The ethernet header 
struct sniff_ip *ip;				// The IP header 
struct sniff_tcp *tcp;				// The TCP header 
u_char *payload;					// Packet payload 

u_int size_ip;
u_int size_tcp;

// print payload in ascii signs
void print_hex_ascii_line(const u_char *payload, int len, int offset)
{
	int i;
	int gap;
	const u_char *ch;

	// offset
	printf("%05d   ", offset);

	// hex
	ch = payload;
	for(i = 0; i < len; i++) {
		printf("%02x ", *ch);
		ch++;
		// print extra space after 8th byte for visual aid
		if (i == 7)
			printf(" ");
	}
	//print space to handle line less than 8 bytes
	if (len < 8)
		printf(" ");

	//fill hex gap with spaces if not full line
	if (len < 16) {
		gap = 16 - len;
		for (i = 0; i < gap; i++) {
			printf("   ");
		}
	}
	printf("   ");

	// ascii (if printable)
	ch = payload;
	for(i = 0; i < len; i++) {
		if (isprint(*ch))
			printf("%c", *ch);
		else
			printf(".");
		ch++;
	}

	printf("\n");

return;
}

// print the TCP payload
void print_payload(const u_char *payload, int len)
{

	int len_rem = len;
	int line_width = 16;			// number of bytes per line
	int line_len;
	int offset = 0;					// zero-based offset counter
	const u_char *ch = payload;

	if (len <= 0)
		return;

	// data fits on one line
	if (len <= line_width) {
		print_hex_ascii_line(ch, len, offset);
		return;
	}

	// data spans multiple lines
	for ( ;; ) {
		// compute current line length
		line_len = line_width % len_rem;
		// print line
		print_hex_ascii_line(ch, line_len, offset);
		// compute total remaining
		len_rem = len_rem - line_len;
		// shift pointer to remaining bytes to print
		ch = ch + line_len;
		// add offset
		offset = offset + line_width;
		// check if we have line width chars or less
		if (len_rem <= line_width) {
			// print last line and get out
			print_hex_ascii_line(ch, len_rem, offset);
			break;
		}
	}

return;
}

void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet)
{

	static int count = 1;                   // packet counter

	// declare pointers to packet headers
	const struct sniff_ethernet *ethernet;  // The ethernet header
	const struct sniff_ip *ip;              // The IP header
	const struct sniff_tcp *tcp;            // The TCP header
	u_char *payload;						// Packet payload

	int size_ip;
	int size_tcp;
	int size_payload;

	printf("\nPacket number %d:\n", count);
	count++;

	// define ethernet header
	ethernet = (struct sniff_ethernet*)(packet);

	// define/compute ip header offset
	ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
	size_ip = IP_HL(ip)*4;
	if (size_ip < 20) {
		printf("   * Invalid IP header length: %u bytes\n", size_ip);
		return;
	}
	printf("    From: %s\n", inet_ntoa(ip->ip_src));
	printf("      To: %s\n", inet_ntoa(ip->ip_dst));

	// determine protocol	
	switch(ip->ip_p) {
		case IPPROTO_TCP:
			printf("   Protocol: TCP\n");
			break;
		case IPPROTO_UDP:
			printf("   Protocol: UDP\n");
			return;
		case IPPROTO_ICMP:
			printf("   Protocol: ICMP\n");
			return;
		case IPPROTO_IP:
			printf("   Protocol: IP\n");
			return;
		default:
			printf("   Protocol: unknown\n");
			return;
	}

	// define/compute tcp header offset
	tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
	size_tcp = TH_OFF(tcp)*4;
	if (size_tcp < 20) {
		printf("   * Invalid TCP header length: %u bytes\n", size_tcp);
		return;
	}	
	printf("   Src port: %d\n", ntohs(tcp->th_sport));
	printf("   Dst port: %d\n", ntohs(tcp->th_dport));

	// define/compute tcp payload (segment) offset
	payload = (u_char*) (packet + SIZE_ETHERNET + size_ip + size_tcp); // <--- hier Fehler-------------------------------------------------------------------
	//-------------------------------------------------------------------------------------------------------------------------------------------------------

	// compute tcp payload (segment) size
	size_payload = ntohs(ip->ip_len) - (size_ip + size_tcp);

	// Print payload data; it might be binary, so don't just treat it as a string.
	if (size_payload > 0) {
		printf("   Payload (%d bytes):\n", size_payload);
		print_payload(payload, size_payload);
	}
return;
}

// main programm
int _tmain(int argc, _TCHAR* argv[])
{
    pcap_if_t * allAdapters;						// output device, all
    pcap_if_t * adapter;							// selected output device
    pcap_t * adapterHandle;							// packet capture handle 
    char errorBuffer[ PCAP_ERRBUF_SIZE ];			// error buffer

	unsigned int netmask = 0xffffff;				// netmask to recieve from all IPs
	char packet_filter[] = "tcp port 5055";			// Filter set to TCP Port 5055 for SCIP
	struct bpf_program filtercode;					// compiled filter version
	int num_packets = -1;							// number of packets to capture, set negative for endless

//--------------------------------------------------------------------------
    // retrieve the adapters from the computer
	// you can choose which adapter you want to use
	// also Filter for Port 5055 (can be changed above) is set here, to keep traffic as low as possible

    if( pcap_findalldevs_ex( PCAP_SRC_IF_STRING, NULL, 
            &allAdapters, errorBuffer ) == -1 )
    {
        fprintf( stderr, "Error in pcap_findalldevs_ex function: %s\n", errorBuffer );
        return -1;
    }

    // if there are no adapters, print an error
    if( allAdapters == NULL )
    {
    printf( "\nNo adapters found! Make sure WinPcap is installed.\n" );
        return 0;
    }

    // print the list of adapters along with basic information about an adapter
    int crtAdapter = 0;
    for( adapter = allAdapters; adapter != NULL; adapter = adapter->next)
    {
    printf( "\n%d.%s ", ++crtAdapter, adapter->name );
    printf( "-- %s\n", adapter->description );
    }

    printf( "\n" );

    int adapterNumber;
	// select an adapter
    printf( "Enter the adapter number between 1 and %d:", crtAdapter );
    scanf_s( "%d", &adapterNumber );

    if( adapterNumber < 1 || adapterNumber > crtAdapter )
    {
        printf( "\nAdapter number out of range.\n" );

        // Free the adapter list
        pcap_freealldevs( allAdapters );

        return -1;
    }

    // parse the list until we reach the desired adapter
    adapter = allAdapters;
    for( crtAdapter = 0; crtAdapter < adapterNumber - 1; crtAdapter++ )
    adapter = adapter->next;

	// open the adapter with promiscous mode enabled
    adapterHandle = pcap_open( adapter->name,	// name of the adapter
                               65536,			// portion of the packet to capture
												// 65536 guarantees that the whole
												// packet will be captured
                               PCAP_OPENFLAG_PROMISCUOUS,	// promiscuous mode
                               1000,            // read timeout - 1 millisecond
                               NULL,			// authentication on the remote machine
                               errorBuffer		// error buffer
                              );

    if( adapterHandle == NULL )
    {
        fprintf( stderr, "\nUnable to open the adapter\n", adapter->name );

	// Check the link layer. We support only Ethernet for simplicity.
    if(pcap_datalink(adapterHandle) != DLT_EN10MB)
    {
        fprintf(stderr,"\nThis program works only on Ethernet networks.\n");
        // Free the device list
        pcap_freealldevs(allAdapters);
        return -1;
    }

	// compile the filter
	if (pcap_compile(adapterHandle, &filtercode, packet_filter, 1, netmask) > 0)
	{
		cout<<endl<<"Unable to compile the packet filter. Check Syntax!"<<endl;
		pcap_freealldevs(allAdapters);
		return -1;
	}

	// setting the filter
	if (pcap_setfilter(adapterHandle, &filtercode) > 0)
	{
		cout<<endl<<"Error setting filter!"<<endl;
		pcap_freealldevs(allAdapters);
		return -1;
	}
        // Free the adapter list
        pcap_freealldevs( allAdapters );
        return -1;
    }

    printf( "\nCapture session started on  adapter %s...\n", adapter->name );

    // free the adapter list
    pcap_freealldevs( allAdapters );

//--------------------------------------------------------------------------
    // this is the most important part of the application
    // here we start receiving packet traffic
// then save information inside the packet into array or somethign like that

	pcap_loop(adapterHandle, num_packets, got_packet, NULL);

	// cleanup variables
	pcap_freecode(&filtercode);
	pcap_close(adapterHandle);

    system( "PAUSE" );
    return 0;
}

Ich möchte eben den payload aus dem TCP als Ascii Zeichen Kette haben und dann weiterverarbeiten. Die Weiterverarbeitung hätte ich auch funktionierend, aber bekomme an der einen Stelle, zum lokalisieren des Payload, also der Psotition im ethernet frame immer wieder einen Fehler, den ich nicht beseitigen kann.
Ist auch Code makriert wo!
In der Version wie oben, wo ich versuche explizit des Datenformat zu ändern, meckert, er das es 2 unaufgelöste externe Symbole gibt, und zwar innerhalb der got_packet funktion, wo genau, sagt er nicht.
Lass ich das Wandeln weg, funktioniert es nicht, da er ein const u_cahr* nicht in ein u_char* wandeln kann. Klar, deswegen wollte ich es ja wandeln... der Grund ist, dass die pcap das als const erwartet.

#pragma comment (lib, "Ws2_32.lib")