Kann den Fehler nicht finden "case-Marke reduziert nicht auf Ganzzahlkonstante"



  • Hallo zusammen,

    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



  • Lies die Fehlermeldung. Deutlicher geht's kaum.



  • Du versuchst in deiner Switch-Anweisung auf einen String zu prüfen. Alles was zwischen "" ist, ist ein String, alles was zwischen '' steht, ist vom Typ Char. In einer Switch-Anweisung kannst du nur Integerwerte prüfen. Somit kannst du also nur auf ein einzelnes Char Byte, Integerzahlen, Boolwerte(was wenig Sinn macht, aber funktioniert) und auf Enumwerte.
    Folglich musst du If-Verzweigungen benutzen.



  • FreakY<3Cpp schrieb:

    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.



  • ... oder alternativ ein statisches char const * Array und ein std::find(). Ggfs. könnte man die Werte auch sortiert in dem Array ablegen und dann mit binary_search() arbeiten.



  • Man könnte auch den IP-String erstmal parsen, und dann switch() oder ein set<uint32_t> verwenden.


Anmelden zum Antworten