warum ist das markierte calloc unzulaessig?[geloest]

[sw33tlull4by]

Hallo!
Ich habe hier eine Funktion welche mich schon seit ein paar Tagen verzweifeln laesst.
Das markierte calloc() produziert Fehler, und ich weiss absolut nicht wiso.
An die Funktion wird ein Poitnerarray/Array von Strings uebergeben, und ein Zeiger auf eine auszulesende Datei.
Zurrueckgegeben wird ein Pointer auf einen Speicherblockin welchem die Resultate stehn.
Die Datei wird Zeile fuer Zeile durchsucht.
Ich komm wie gesagt einfach nicht dahinter wiso das calloc Fehler schmeisst.
Danke im vorraus.
sw33t
//edit: Programmiersprache ist C und es soll Plattformunabhaengig bleiben.

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

char* filter(FILE *datei,char** suchkriterien)
{
	int size = 10;
	char character= ' ';
	char* working = (char*) calloc(size,sizeof(char));
	char*backup,*tmp;
	char *backup2,*result;
	char** suchkriterienbackup = suchkriterien;
	int counter = 0;
	backup2 = result = (char*) calloc(size,sizeof(char));
	tmp = backup = working;

	do
	{
		do
		{
			character = fgetc(datei);
			if(counter == size -2)
			{
				tmp = calloc(size*2,sizeof(char));
				tmp = memcpy((void*)tmp,(const char*) backup,counter);
				free(backup);
				backup = working = tmp;
				working +=size-2;
				size *=2;
			}
			counter++;
			if(!feof(datei))
				*working++ = character;
			else
				*working++ = '\n';
		}while(character != '\n'&&!feof(datei));
		
		*working = '\0';
		
		while(*(suchkriterien) != NULL)
		{
			if(NULL!= strstr(backup,*(suchkriterien)++))
			{
				backup2 = (char*) calloc(strlen(backup)+strlen(backup2),sizeof(char));
				backup2 = memcpy((void*)backup2,(const char*)result,strlen(result));
				result = backup2;
				//strncat(result,backup,strlen(backup));
				break;
			}
		}
		if(backup==NULL);
		else
			free(backup);
		suchkriterien = suchkriterienbackup;
		size = 10;
		counter = 0;
		tmp =(char*) calloc(size,sizeof(char));
		backup = working = tmp;
			
		if(feof(datei))
			break;
		
	}while(1);
	
	free(backup);
	return backup2;
}

 

[menace]

Weisst du denn, in wievieltem Schleifendurchlauf es knallt oder bestimmte Bedingungen (leere zeile oder so)?

Tipps (auch wenn evtl. nicht gerne gesehen ;D ):
1. char* working = (char*) calloc(size,sizeof(char)); <--- der sollte das automatisch casten. Wenn's ein warning beim compile gibt, wenn du das nicht machst, ist eigentlich was falsch.
2. Ausserdem kann ich empfehlen, jeden zeiger mit NULL zu initialsieren und nach jedem free auch wieder auf NULL zu setzen.
3. stellst du sicher, dass alle deine C-Strings Nullterminiert sind?
4. was ist denn die ausgabe, dass du weisst, es knallt DA?

 

[sw33tlull4by]

Hallo!
Erstmal vielen vielen Dank fuer deine Antwort und deine Tipps.
Das implizite Casting hatte ich nur gemacht weil ich lange Zeit nichtmehr in C programmiert hatte und nichts dem Zufall ueberlassen wollte.(hast aber recht ist eigentlich daemlich.
Das Initialisieren der Pointer mit NULL habe ich nun dadurch behoben das ich jedem Pointer immer einen Block zuweise und wenn ich den Block wieder freigebe
Die '\0'-Terminierung hatte ich glatt vergessen, und in meinen neuen Code mit eingebaut.
Die Eingabe ist eigentlich total egal
Ich habe den Quellcode, weil ich damit gerechnet hatte das hier niemand mehr Antwortet , mal neu geschrieben.
Meinen neuen Quellcode habe ich einfach an stelle des Alten gesetzt, damit das hier uebersichtlich bleibt.

Der Quellcode ist allerdings immer noch fehlerhaft.
Die Fehler liegen in Zeile 44 und 47.
Allerdings sehe ich die Fehler nicht.
Fehlermeldung ist immer noch free():invalid size.
valgrind ./Programm gibt mir aber die oberen Zeilen mit den Informationen:
invalid read of size 1
invalid write of size 1
fuer beide Zeilen.
mfg

sw33t


//edit
ROFL.
Ich sage noch das ich vergessen habe `\0` zu beachten, vergesse es aber backup2 und result damit zu beschreiben.
Da kann strcat() strncat() ja schoen was zusammenhaegen.
Das Programm laeuft nun.
Vielen dank nochmal fuer den Tipp mit dem `\0`
Es ist echt erstaunlich was das fehlen eines solchen kleinen Details alles erzeugen kann....