brauche da mal wieder eure Hilfe. Das Programm hatte ich schon einmal unter Kubuntu7.04 compiliert. Jetzt unter Ubuntu8.04 erhalte ich folgende Meldung:

trafficd.c: In Funktion »addr_chk«:
trafficd.c:207: Fehler: switch-Größe ist keine Ganzzahl
trafficd.c:209: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:211: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:213: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:215: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:217: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:219: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:221: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:223: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:225: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:227: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:229: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:231: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:233: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:235: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:237: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:239: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:241: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:243: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:245: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:247: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:249: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:251: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:253: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante
trafficd.c:255: Fehler: case-Marke reduziert nicht auf Ganzzahlkonstante

Der Code sieht so aus:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <unistd.h>
#include <signal.h>
#include <math.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <mysql/mysql.h>
#include "daemonize.h"
#include "trafficd.h"

// *****************************************************************
// Defines
#define			router	0x056FA8C0  // 192.168.111.5
#define			server	0x876FA8C0  // 192.168.111.135

// *****************************************************************
// Globals
int 			sock;
MYSQL 			mysql;

// *****************************************************************
// Main Programm
int main (int argc, char *argv[])
{
int 				bytes, i, c, daemon;
struct 				sockaddr_in my_addr;
unsigned char 		srcaddr[20], dstaddr[20], cpQuery[200];
double				dBootTime;
struct rFlow		Flow;
extern char 		*optarg;
extern int 			optind, opterr, optopt;
unsigned long		FirstTime, LastTime;

// Parameter abfrage
daemon = 1;
while ((c = getopt(argc, argv, "p:c:dh")) != -1)
{
	switch (c)
	{
	case 'p':
		// pid file *todo*
		break;
	case 'c':
		// config file *todo*
		break;
	case 'd':
		daemon = 0;
		break;
	case 'h':
		usage();
		return 0;
	default:
		fprintf(stderr, "Ungültige CommandLine Option.\n");
		exit(1);
	}
}

if (daemon) daemonize();

signal(SIGTERM,signal_handler); /* catch kill signal */
signal(SIGINT,signal_handler); /* catch kill signal */

memset(&my_addr, 0, sizeof(my_addr));			// alles mit Nullen füllen
my_addr.sin_family      = AF_INET;                   // muss hier nochmal stehen
my_addr.sin_port        = htons(2055);               // auf dem Port läuft NetFlow
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

// socket anlegen
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
	perror("couldn't create socket\n");
    exit(1);
}

// binden
if (bind(sock, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1)
{
	perror("couldn't bind\n");
	exit(2);
}

// MySQL Connecten
mysql_init(&mysql);
mysql_real_connect(&mysql, "localhost", "root", "linuxfun", "rflow", 0, NULL, 0);

// Hauptschleife
for(;;)
{
	if ((bytes = recvfrom(sock, (void *)&Flow, sizeof(struct rFlow), 0, NULL, NULL)) == -1)
	{
		perror("couldn't recvfrom\n");
	}

   	// unixtime beim start des routers
   	dBootTime = (double)ntohl(Flow.unix_secs)+((double)ntohl(Flow.unix_nsecs)/1000000000)-((double)ntohl(Flow.SysUptime)/1000);

//	printf("Länge: %u bytes, Version: %u, Count: %u, UpTime: %u min, unix_secs: %u sec.\n",
//	bytes, ntohs(Flow.Version), ntohs(Flow.RecordCount), ntohl(Flow.SysUptime)/1000/60, ntohl(Flow.unix_secs));

	for (i=0;i<ntohs(Flow.RecordCount); i++)
	{

		if (addr_chk(Flow.FlowRecs[i].srcaddr) && !((Flow.FlowRecs[i].srcaddr == router) && (Flow.FlowRecs[i].dstaddr == server) && (ntohs(Flow.FlowRecs[i].dstport) == 2055)))
		{
			num2ip(ntohl(Flow.FlowRecs[i].srcaddr), srcaddr);
			num2ip(ntohl(Flow.FlowRecs[i].dstaddr), dstaddr);

			FirstTime = (unsigned long int)(dBootTime + ((double)ntohl(Flow.FlowRecs[i].First)/1000));
			LastTime =  (unsigned long int)(dBootTime + ((double)ntohl(Flow.FlowRecs[i].Last )/1000));
			fix_time_bug(&FirstTime, &LastTime);

			sprintf(cpQuery, "INSERT INTO flows (ipSrc, ipDst, srcPort, dstPort, pktSent, bytesSent, proto, startTime, endTime, tcpFlags, tos) "
							 "VALUES ('%s', '%s', %u, %u, %u, %u, %u, FROM_UNIXTIME(%lu), FROM_UNIXTIME(%lu), %u, %u)",
							 srcaddr, dstaddr,
							 ntohs(Flow.FlowRecs[i].srcport), ntohs(Flow.FlowRecs[i].dstport),
							 ntohl(Flow.FlowRecs[i].dPkts), ntohl(Flow.FlowRecs[i].dOctets),
							 Flow.FlowRecs[i].prot,
							 FirstTime,
							 LastTime,
							 Flow.FlowRecs[i].tcp_flags, Flow.FlowRecs[i].tos);

			if(mysql_real_query(&mysql, cpQuery, strlen(cpQuery)))
			{
				perror("MySQL Query fehlgeschlagen\n");
			}
		}
	}

	printf("\n");
}
close(sock); // wir schließen den socket wieder
mysql_close(&mysql);

return 0;
}

// *****************************************************************
// Fix DD-WRTs time bug
void fix_time_bug(unsigned long *FirstTime, unsigned long *LastTime)
{
	unsigned long timedif;
	struct timeval tv;
	gettimeofday(&tv, NULL);

	timedif = (unsigned long)ceil((float)(*LastTime - tv.tv_sec)/3600) * 3600;

	*FirstTime -= timedif;
	*LastTime -= timedif;

}

// *****************************************************************
// Number 2 IP (xx.xx.xx.xx)
void num2ip(unsigned long int num, char *ip)
//void num2ip(int num, char *ip)
{
	sprintf(ip, "%lu.%lu.%lu.%lu",(num&0xff000000)>>24, (num&0x00ff0000)>>16, (num&0x0000ff00)>>8, (num&0x000000ff));
}

// *****************************************************************
// Signal Handler
void signal_handler(int sig)
{
	switch(sig)
	{
	case SIGTERM:
	case SIGINT:
		printf("trafficd stopping....\n");
		mysql_close(&mysql); // MySQL Schließen
		close(sock); // wir schließen den socket wieder
		printf("trafficd stopped.\n");
		exit(0);
		break;
	}
}

// *****************************************************************
// Hilfe Text
void usage()
{
	fprintf(stderr, "Copyright (C) 2006 Ing. Markus Flattinger\n");
	fprintf(stderr, "Usage: trafficd [optionen]\n");
	fprintf(stderr, "Gültige CommandLine Optionen:\n");
	fprintf(stderr, "  -p path         pid file path (default: /var/run)\n");
	fprintf(stderr, "  -c path         Configuration file (default: /etc)\n");
	fprintf(stderr, "  -d              Debug Modus, nicht forken und debug Meldungen ausgeben\n");
	fprintf(stderr, "  -h              Display this help\n");
	fprintf(stderr, "\n");
}

// *****************************************************************
// addr_chk
int addr_chk(unsigned char addr[])
{
	switch (addr)
	{
	case "192.168.111.90":
		return 1;
	case "192.168.111.133":
		return 1;
	case "192.168.111.4":
		return 1;
	case "192.168.111.8":
		return 1;
	case "192.168.111.9":
		return 1;
	case "192.168.111.11":
		return 1;
	case "192.168.111.12":
		return 1;
	case "192.168.111.13":
		return 1;
	case "192.168.111.14":
		return 1;
	case "192.168.111.15":
		return 1;
	case "192.168.111.16":
		return 1;
	case "192.168.111.17":
		return 1;
	case "192.168.111.18":
		return 1;
	case "192.168.111.19":
		return 1;
	case "192.168.111.31":
		return 1;
	case "192.168.111.32":
		return 1;
	case "192.168.111.33":
		return 1;
	case "192.168.111.35":
		return 1;
	case "192.168.111.37":
		return 1;
	case "192.168.111.38":
		return 1;
	case "192.168.111.41":
		return 1;
	case "192.168.111.42":
		return 1;
	case "192.168.111.43":
		return 1;
	case "192.168.111.125":
		return 1;
	default:
		return 0;
	}
}

Wo liegt hier der Fehler?
Gruß Bernd

Folglich musst du If-Verzweigungen benutzen.

Oder std::map . Wobei hier auch std::set reicht - wenn eine Adresse im Set vorkommt, gibst du 1 zurück, sonst 0.