hozzavalok pointer not working

key

+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEA2RESs9Gatv4FkxsGBd5Ot9KSWSnK9UlnzD7vgmqO29tiUmqa
+wvZTkanhvuiClMcGCLPHB3F/N92jiTYn1VXuNDeEoO1pMo3RczaoIc7NpoIey91y
+94vfr/CYBXZvfRPWp64v/ViK3tLz1xAfuh+xrGG/HR1HaxXd+cmP9ujjvL7XeFdU
+bZumR1Zn8WM2Y4tp2AXynuNr5yP1Sug4XGVOEhdgyPsZna7F/o1rtwTdmQhcaPiv
+T1sbJQmHhTa2UkLktUracG8qvt+wrOcvsD0Q8Xb/1JrW8RogtpW1XmlJcwCgYtx9
+Wlq/UoAiry+2UQrVXZLCIWYE/Aiw/6d7mSNhNwIDAQABAoIBAEAOdcJy/IE7/VEo
+DGL286vzjBSb7LTt8J+pguytnXLsDtvbcchPAOJfi6rW2pIlGXa/9uAPckd+NKBt
+RtwB+8WVDKKg7QZqK4EghAVWDgIxK/1lYGQE9wHosjQKe2Qh0pqxIKBW3MRc5HB2
+5aX7bGc+gTOKTGUhktv/y2hF2c78xyaeA7NdukIuFRx9j2QE78xkiRyslGrunDWu
+PYScrBr3+mT50p/RdRg8YcOVZNC0eqyC7Yx5quXxtrDlkqFDX35SxUddHaBPPBf3
+yhgBWMIzIteHQvNhUux7vwEiRxyoD0ZRKY5xh84YKd1RWeRxGMSLWxGcVGEDo/d6
+OVC6vIECgYEA+XpOPipXHX3XS3crfBovuM/qAoq1MTpF+oIockQ01vHAWrR+Jkar
+DmubI75FiSiqPWyoa4sWWrjfVmx6FzC7cgpKI7DbGLt2aVPhQonyYn+QGdZzI2wC
+4JN7fyOqWlzhj/zznlpBg48vGbvyO7J2phSY0PFJzQF//MRcFjDUWxECgYEA3r3Z
+FghfF6PYtRceNWvFAYv/D8c5z2kbhAUGC6Eih9zHM3F16fJOyMJrqajqAANik6sS
+PHfFKDRMH2CwSolilixSrnXYGDB1PUxezCqI7/Jad+7g4ME8OuyjI+XoSFEQBydf
+hw9pk99F6qUMJIDjiWEr7fIC1KG9voPbML0hJ8cCgYEAuOPVvOiwK2Ep//nPtmfJ
+2lPsf/nAkz02w5NW2miGKI5+GjsOCtvwxf0luvW2nxIOKPuwThOEe7PrgSdfzHQH
+V1sc2xqlJc040pKhrSiDBFC5wQxXxHa2Iy3qJq2OAO45FPdIraECULf7Fj1eJrP6
+jtdQ8fkA0vg7nF8CSEfj+aECgYAcHFucYzwVELGV0TAXz90SH+f1xs/t9Dbrx3KG
+3zQrb1qYjHY0K0d0IM1ToSS/Ea5MMqffh8ITG96LizlUftg5Waipqee2zc7OCKhi
+HfAgUDbIshYhZ2HBkgHY0vgowEpEjNyKgBB0ABaj0Wah6L5OpTvVENj4mt0GgT+V
+fBkGGwKBgQDR9q4gHOaTyPEgl7qhWjbGvoALTkom3LWKl8x8ASV7kIwOvA1XNvqX
+r3WswriQ67OH7xEo/fhzRmuaeuOXnjUAka/PghPa9Le1PtXt3xCX7iC0b3ecFjsJ
+SufcBPT8h4WCUL4DV0mC2lrBWguP6xSr5hMwd9n4l/GSwhG9LC+kbQ==
+-----END RSA PRIVATE KEY-----

key.pub

+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDZERKz0Zq2/gWTGwYF3k630pJZKcr1SWfMPu+Cao7b22JSaprC9lORqeG+6IKUxwYIs8cHcX833aOJNifVVe40N4Sg7WkyjdFzNqghzs2mgh7L3XL3i9+v8JgFdm99E9anri/9WIre0vPXEB+6H7GsYb8dHUdrFd35yY/26OO8vtd4V1Rtm6ZHVmfxYzZji2nYBfKe42vnI/VK6DhcZU4SF2DI+xmdrsX+jWu3BN2ZCFxo+K9PWxslCYeFNrZSQuS1Stpwbyq+37Cs5y+wPRDxdv/UmtbxGiC2lbVeaUlzAKBi3H1aWr9SgCKvL7ZRCtVdksIhZgT8CLD/p3uZI2E3 tht_krisztian@sch.bme.hu

receptor/.goutputstream-093T6W

+Kelt tszta (pizza)
+2
+45
+Hozzvalk:
+1 kg liszt
+0,25 liter tej
+1 evkanl cukor
+2 kocka leszt
+1 dl olivaolaj
+0,4 l langyos vz
+fokhagyma granultum
+pizzafszerkeverk
+s
+
+5 f
\ No newline at end of file

receptor/00.txt~

+1
+01.txt

receptor/01.txt~

+Kelt tészta (pizza)
+2 (nehezseg)
+45 perc
+Hozzavalok:
+5 fő részére
+1 kg liszt
+250 ml tej
+1 evokanal cukor
+2 kocka élesztõ
+1 dl olivaolaj
+4 dl langyos víz
+fokhagyma granulátum
+pizzafûszerkeverék
+só
+
+Elkeszites:
+9 lépésből áll
+1. egy korsóba: langyos tej, cukor, élesztõ
+2. korsó tartallmát villával elkeverni és valamivel lefedni 3-4 percre
+3. lisztbe bele a korsó tartalma és ujjal kicsit elkeverni
+4. takarja le 15 perce
+5. adja hozzá az olajat, fokh. granulátumot, sót, fûszerkeveréket
+6. kézzel elkeverni a vizet amit kis adagokban adunk hozzá a liszthez
+7. két kézzel összegyúrni
+8. 15 percet hagyd állni
+9. serpenyõ alját lissztel vagy olajjal kend ki....

receptor/debugmalloc.c

+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+#include <stdarg.h>
+
+#include "debugmalloc.h"
+
+/* ervenytelenitjuk ezeket a makrokat, mert nekunk az igazi malloc/free kell */
+#ifdef malloc
+    #undef malloc
+#endif
+#ifdef free
+    #undef free
+#endif
+#ifdef calloc
+    #undef calloc
+#endif
+#ifdef realloc
+    #undef realloc
+#endif
+
+/* a kanari merete, bajtokban */
+static size_t const kanari_meret=128;
+/* a kanari karakter */
+static unsigned char const kanari='K';
+
+/* csak egy kis veletlenszam-generator.
+ * direkt van egy sajat, hogy a szabvany rand() belso allapotat
+ * ne zavarja meg a sajat malloc.
+ * 
+ * klasszikus. :D
+ */
+static unsigned char debugmalloc_random()
+{
+    static unsigned int seed_1=0x00, seed_2=0x1e;
+    unsigned int temp_1, temp_2;
+    unsigned int carry, result;
+ 
+    temp_1=(seed_1&0x0001) << 7;
+    temp_2=(seed_2 >> 1)&0x007F;
+    result=(seed_2)+((seed_2&0x0001) << 7);
+    carry=(result >> 8);
+    result=result&0x00FF;
+    result=result+carry+0x13;
+    carry=(result >> 8);
+    seed_2=result&0x00FF;
+    result=seed_1+carry+temp_1;
+    carry=(result >> 8);
+    result=result&0x00FF;
+    result=result+carry+temp_2;
+    seed_1=result&0x00FF;
+
+    return seed_1;
+}
+
+
+
+/* a lefoglalt teruleteket nyilvantarto lista. */
+typedef struct Lefoglalt {
+    void *valodi;       /* ezt mallocoltuk mi */
+    void *usernek;      /* ezt mutatjuk a juzernek */
+    size_t meret;       /* ekkora teruletet kert a juzer. */
+    
+    char fv[16];        /* foglalo fuggveny */
+    char cel[128];      /* a mallocnak ezt a kifejezest adta */
+    char file[64];      /* ebben a fajlban tortent a foglalas */
+    unsigned line;      /* a fajlnak ebben a soraban */
+    
+    struct Lefoglalt *prev, *next;  /* duplan lancolt listahoz */
+} Lefoglalt;
+
+
+static Lefoglalt eleje, vege;     /* strazsak. statikusan, hogy ne kelljen freezni :) */
+static Lefoglalt *lista=NULL;     /* maga a lista; a pointer az eleje strazsara fog mutatni */
+
+static char logfile[256]="";      /* ide logol */
+
+
+/* a naplozofajl nevet allitja be. ha ures, stderr-re fog naplozni. */
+void debugmalloc_naplofajl(char const *nev)
+{
+    strncpy(logfile, nev, sizeof(logfile));
+    logfile[sizeof(logfile)-1]=0;
+}
+
+/* elodeklaracio az init() fv. szamara */
+static void debugmalloc_programvegi_dump();
+
+/* letrehozza a listat. a sajat malloc hivja egyszer, az elso meghivasakor.
+ * a lista pointer (lista) inditaskori erteke NULL, de lesznek strazsak.
+ * innen lehet tudni, hogy mar hivodott-e.
+ * a strazsakat statikusan hoztam letre; vagyis ha inicializalva van mar a
+ * lista, de a juzer meg nem foglalt memoriat, akkor nincs mallocolva
+ * semmi! emiatt biztosan nem memleakel ez a program pluszban, ha a juzer
+ * programja nem memleakelt. */
+static void debugmalloc_init()
+{
+    eleje.prev=NULL;
+    eleje.next=&vege;
+    vege.prev=&eleje;
+    vege.next=NULL;
+    lista=&eleje;
+    eleje.valodi=eleje.usernek=NULL;
+    vege.valodi=vege.usernek=NULL;
+    
+    atexit(debugmalloc_programvegi_dump);
+}
+
+
+/* printfel a megadott fajlba, vagy stderr-re. */
+static int debugmalloc_printf(char const *format, ...)
+{
+    va_list ap;
+    int chars;
+    FILE *f=stderr;
+    
+    if (strcmp(logfile, "")!=0) {
+        f=fopen(logfile, "at");
+        if (f==NULL) {
+            f=stderr;
+            fprintf(stderr, "debugmalloc: nem tudom megnyitni a %s fajlt irasra!\n", logfile);
+        }
+    }
+    
+    va_start(ap, format);
+    chars=vfprintf(f, format, ap);
+    va_end(ap);
+    
+    if (f!=stderr)
+        fclose(f);
+    
+    return chars;
+}
+
+
+/* inicializalja a lefoglalt memoriat.
+ * az elejere es a vegere kanari_meret meretben kanari kerul;
+ * a kozepere, a juzernek valo reszbe pedig debugmalloc_random szamok. */
+static void kanari_letrehoz(Lefoglalt *mem)
+{
+    unsigned char *teljes=(unsigned char *) mem->valodi;
+    unsigned char *kanari1=teljes;
+    unsigned char *kanari2=teljes+kanari_meret+mem->meret;
+    size_t i;
+    
+    for (i=0; i<kanari_meret; ++i) {
+        kanari1[i]=kanari;
+        kanari2[i]=kanari;
+    }
+}
+
+/* ellenorzi a kanarit.
+ * igaz ertekkel ter vissza, ha rendben van. */
+static int kanari_rendben(Lefoglalt const *mem)
+{
+    unsigned char *teljes=(unsigned char *) mem->valodi;
+    unsigned char *kanari1=teljes;
+    unsigned char *kanari2=teljes+kanari_meret+mem->meret;
+    size_t i;
+    
+    for (i=0; i<kanari_meret; ++i) {
+        if (kanari1[i]!=kanari)
+            return 0;
+        if (kanari2[i]!=kanari)
+            return 0;
+    }
+    return 1;
+}
+
+/* memoriateruletet dumpol, a megadott meretben. */
+static void debugmalloc_dump_memory(void const *memoria, size_t meret)
+{
+    unsigned char const *mem=(unsigned char const *) memoria;
+    unsigned y, x;
+
+    /* soronkent 16; meret/16-nyi sor lesz, persze felfele kerekitve */
+    for (y=0; y<(meret+15)/16; y++) {
+        debugmalloc_printf("      %04x  ", y*16);
+        
+        for (x=0; x<16; x++)
+            if (y*16+x<meret)
+                debugmalloc_printf("%02x ", mem[y*16+x]);
+            else
+                debugmalloc_printf("   ");
+        debugmalloc_printf("  ");
+        for (x=0; x<16; x++)
+            if (y*16+x<meret) {
+                unsigned char c=mem[y*16+x];
+                debugmalloc_printf("%c", isprint(c)?c:'.');
+            }
+            else
+                debugmalloc_printf(" ");
+
+        /* uj sor */
+        debugmalloc_printf("\n");
+    }
+}
+
+/* egy adott lefoglalt tetelhez
+ * tartozo adatokat irja ki. foglalas helye, modja;
+ * meret, pointer. ad az elejerol dumpot is;
+ * illetve a teljes elotte es utana kanarit kiirja,
+ * ha kiderul, hogy az serult. */
+static void debugmalloc_dump_elem(Lefoglalt const *iter)
+{
+    int kanari_ok=kanari_rendben(iter);
+    
+    debugmalloc_printf("  MEMORIATERULET: %p, kanari: %s\n"
+                    "    foglalva itt: %s:%u\n"
+                    "    foglalas modja: %s(%s) (%u bajt)\n",
+        iter->usernek, kanari_ok?"ok":"**SERULT**",
+        iter->file, iter->line,
+        iter->fv, iter->cel, (unsigned) iter->meret);
+    
+    if (!kanari_ok) {
+        debugmalloc_printf("    ELOTTE KANARI: \n");
+        debugmalloc_dump_memory(iter->valodi, kanari_meret);
+    }
+
+    /* elso 64 byte dumpolasa */
+    debugmalloc_printf("    memoria eleje: \n");
+    debugmalloc_dump_memory(iter->usernek, iter->meret>64 ? 64:iter->meret);
+
+    if (!kanari_ok) {
+        /* erre a vs miatt van szukseg, mert az nem szereti a void *+size_t
+         * kifejezest... trollok */
+        unsigned char const *valodi_char=(unsigned char const *) iter->valodi;
+        debugmalloc_printf("    UTANA KANARI: \n");
+        debugmalloc_dump_memory(valodi_char+kanari_meret+iter->meret, kanari_meret);
+    }
+    
+    debugmalloc_printf("\n");
+}
+
+/* kiirja a lefoglalt memoriateruletek listajat. */
+void debugmalloc_dump()
+{
+    Lefoglalt *iter;
+    
+    debugmalloc_printf("** DEBUGMALLOC DUMP ************************************\n\n");
+    for (iter=lista->next; iter!=&vege; iter=iter->next)
+        debugmalloc_dump_elem(iter);
+    debugmalloc_printf("** DEBUGMALLOC DUMP VEGE *******************************\n");
+}
+
+
+
+
+
+
+/* ez lefoglal egy megadott meretu memoriat;
+ * pontosabban annal nagyobbat. elotte-utana kanarit inicializal,
+ * a juzernek jaro reszt pedig random szamokkal tolti fel.
+ * visszaterni a juzernek jaro terulet cimevel ter vissza. */
+void *debugmalloc_malloc_full(size_t meret, char const *fv, char const *cel, char const *file, unsigned line, int zero)
+{
+    Lefoglalt *uj;
+    void *valodi;
+    unsigned char *usernek;
+    
+    /* lefoglalunk egy adag memoriat; elotte-utana tobblet hellyel. */
+    valodi=malloc(meret+2*kanari_meret);
+    if (valodi==NULL) {
+        debugmalloc_printf("debugmalloc: %s @ %s:%u: nem sikerult %u meretu memoriat foglalni!\n",
+                            fv, file, line, (unsigned) meret);
+        /* mint az igazi malloc, nullpointert adunk */
+        return NULL;
+    }
+
+    uj=(Lefoglalt *) malloc(sizeof(Lefoglalt));
+    if (uj==NULL) {
+        debugmalloc_printf("debugmalloc: %s @ %s:%u: le tudtam foglalni %u memoriat, de utana a sajatnak nem, sry\n",
+                            fv, file, line, (unsigned) meret);
+        abort();
+    }
+    uj->valodi=valodi;
+    usernek=(unsigned char *) valodi+kanari_meret;
+    uj->usernek=usernek;
+    uj->meret=meret;
+
+    strcpy(uj->fv, fv);
+    strncpy(uj->cel, cel, sizeof(uj->cel));
+    uj->cel[sizeof(uj->cel)-1]=0;
+    strncpy(uj->file, file, sizeof(uj->file));
+    uj->file[sizeof(uj->file)-1]=0;
+    uj->line=line;
+
+    kanari_letrehoz(uj);
+    if (zero)
+        memset(usernek, 0, meret);
+    else {
+        size_t i;
+        for (i=0; i<meret; ++i)
+            usernek[i]=debugmalloc_random();
+    }
+        
+    /* lista elejere beszurja */
+    if (lista==NULL)
+        debugmalloc_init();
+    uj->prev=lista;         /* elotte a strasza */
+    uj->next=lista->next;   /* utana az eddigi elso */
+    lista->next->prev=uj;   /* az eddigi elso elott az uj */
+    lista->next=uj;         /* a strazsa utan az uj */
+    
+    return uj->usernek;
+}
+
+/* ez felszabaditja a memoriateruletet, amit a debugmalloc
+ * foglalt. mivel a listaban megvannak az epp lefoglalt
+ * teruletek, ezert ellenorizni tudja, helyes-e a free hivas.
+ * ellenorzi a kanarit is, es kiirja az adatokat, ha helytelen.
+ */
+void debugmalloc_free_full(void *mem, char const *fv, char const *file, unsigned line)
+{
+    Lefoglalt *iter;
+    unsigned char *usernek;
+    size_t i;
+
+    /* NULL pointerre nem csinalunk semmit */
+    if (mem==NULL)
+        return;
+
+    /* ha meg sose mallocolt, a lista nincs inicializalva. a free-je se lehet helyes */
+    if (lista==NULL) {
+        debugmalloc_printf("debugmalloc: %s @ %s:%u: meg egyszer se hivtal mallocot!\n", fv, file, line);
+        abort();
+    }
+
+    /* megkeressuk */
+    for (iter=lista->next; iter!=&vege; iter=iter->next)
+        if (iter->usernek==mem)
+            break;
+    
+    /* ezt nyilvan ne engedjuk, mert akkor olyan pointer van, amit nem kene
+     * free()-ni; ezt a rendes free() se birna */
+    if (iter->usernek==NULL) {
+        debugmalloc_printf("debugmalloc: %s @ %s:%u: olyan teruletet akarsz felszabaditani, ami nincs lefoglalva!\n", fv, file, line);
+        abort();
+    }
+    
+    /* szoval megtalaltuk. iter mutat a torlendo teruletre. */
+    if (!kanari_rendben(iter)) {
+        debugmalloc_printf("debugmalloc: %s @ %s:%u: a %p memoriateruletet tulindexelted!\n", fv, file, line, mem);
+        debugmalloc_dump_elem(iter);
+    }
+    
+    /* torles elott kitoltjuk randommal, ha esetleg dereferalna, akkor tuti fajjon */
+    usernek=(unsigned char *) iter->usernek;
+    for (i=0; i<iter->meret; ++i)
+        usernek[i]=debugmalloc_random();
+    /* memoria torlese; juzer memoriaja, es listabol */
+    free(iter->valodi);
+    iter->next->prev=iter->prev;
+    iter->prev->next=iter->next;
+    free(iter);
+}
+
+
+/* a megadott memoriat meretezi at.
+ * a sajat free/malloc paros segitsegevel valositom meg. */
+void *debugmalloc_realloc_full(void *oldmem, size_t newsize, char const *fv, char const *cel, char const *file, unsigned line)
+{
+    Lefoglalt *iter;
+    void *ujmem;
+    int masolni;
+    
+    /* ha null az oldmem, akkor ez ekvivalens egy malloc hivassal */
+    if (oldmem==NULL)
+        return debugmalloc_malloc_full(newsize, fv, cel, file, line, 0);
+    
+    /* ha az uj meret 0, akkor pedig egy free hivassal */
+    if (newsize==0) {
+        debugmalloc_free_full(oldmem, fv ,file, line);
+        return NULL;
+    }
+
+    /* megkeressuk a regi memoriat, mert kell a meret */
+    for (iter=lista->next; iter!=&vege; iter=iter->next)
+        if (iter->usernek==oldmem)
+            break;
+    if (iter->usernek==NULL) {
+        debugmalloc_printf("debugmalloc: %s @ %s:%u: olyan teruletet akarsz atmeretezni, ami nincs lefoglalva!\n", fv, file, line);
+        abort();
+    }
+    
+    ujmem=debugmalloc_malloc_full(newsize, fv, cel, file, line, 0);
+    if (ujmem==NULL) {
+        debugmalloc_printf("debugmalloc: %s @ %s:%u: nem sikerult uj memoriat foglalni az atmeretezeshez!\n", fv, file, line);
+        /* ilyenkor nullal ter vissza, es a regit meghagyja */
+        return NULL;
+    }
+    /* melyik kisebb? annyi bajtot kell masolni. */
+    masolni=iter->meret < newsize? iter->meret : newsize;
+    memcpy(ujmem, oldmem, masolni);
+    debugmalloc_free_full(oldmem, fv, file, line);
+    
+    return ujmem;
+}
+
+
+/* ez hivodik meg a program vegen, az atexit() altal. */
+static void debugmalloc_programvegi_dump()
+{
+    /* just in case */
+    if (lista==NULL)
+        return;
+    
+    /* ha nem ures a lista */
+    if (lista->next->next!=NULL) {
+        debugmalloc_printf("********************************************************\n"
+                           "*\n"
+                           "* MEMORIASZIVARGAS VAN A PROGRAMBAN!!!\n"
+                           "*\n"
+                           "********************************************************\n");
+        debugmalloc_dump();
+    }
+}
+
+
+
+/* ha szukseg lenne egy, az eredeti fuggvennyel prototipusban
+ * kompatibilis valtozatra, ezek hasznalhatoak. */
+void *debugmalloc_malloc(size_t meret)
+{
+    return debugmalloc_malloc_full(meret, "malloc", "ismeretlen", "(ismeretlen)", 0, 0);
+}
+
+void *debugmalloc_calloc(size_t nmemb, size_t meret)
+{
+    return debugmalloc_malloc_full(meret, "calloc", "ismeretlen", "(ismeretlen)", 0, 1);
+}
+
+void debugmalloc_free(void *mem)
+{
+    debugmalloc_free_full(mem, "free", "(ismeretlen)", 0);
+}
+
+void *debugmalloc_realloc(void *oldmem, size_t meret)
+{
+    return debugmalloc_realloc_full(oldmem, meret, "realloc", "ismeretlen", "(ismeretlen)", 0);
+}

receptor/debugmalloc.h

+#ifndef DEBUGMALLOC_H
+#define DEBUGMALLOC_H
+
+/* 
+ * Ezek azok a makrok, amelyek biztositjak, hogy a sajat
+ * fuggvenyek hivodjanak, amikor malloc() vagy free()
+ * szerepel a programban.
+ * 
+ * Semmi egyeb teendo nincsen, csak az, hogy ezt a header
+ * fajlt be kell szerkeszteni _minden_ forraskodba. A szokasos
+ * formaban megadott malloc() es free() hivasok helyett ez a
+ * valtozat fog automatikusan mindig meghivodni a makrok miatt.
+ * 
+ * Fontos, hogy ezt az include fajlt a project OSSZES
+ * forras fajljaban hasznalni kell! Siman, a beepitett
+ * free()-vel nem lehet felszabaditani egy olyan teruletet,
+ * amelyet ez a malloc() foglalt! Mas a pointer.
+ * 
+ * Ha szukseg van arra, hogy a malloc() es a free() cime
+ * kepezheto legyen, akkor a HASZNALOM_A_MALLOC_FREE_POINTERET
+ * makrot definialni kell az #include "debugmalloc.h" sor
+ * elott. Ilyenkor egy butabb valtozatot fog hasznalni,
+ * amely viszont kompatibilis prototipussal rendelkezik.
+ */
+
+#include <stdlib.h>
+
+#ifdef HASZNALOM_A_MALLOC_FREE_POINTERET
+    #define malloc debugmalloc_malloc
+    #define calloc debugmalloc_calloc
+    #define realloc debugmalloc_realloc
+    #define free debugmalloc_free
+#else
+    #define malloc(X) debugmalloc_malloc_full(X, "malloc", #X, __FILE__, __LINE__, 0)
+    #define calloc(X,Y) debugmalloc_malloc_full(X*Y, "calloc", #X ", " #Y, __FILE__, __LINE__, 1)
+    #define realloc(P,X) debugmalloc_realloc_full(P, X, "realloc", #X, __FILE__, __LINE__)
+    #define free(P) debugmalloc_free_full(P, "free", __FILE__, __LINE__)
+#endif
+
+/*
+ * Ezzel a fuggvennyel lehet megadni azt, hogy az stderr helyett
+ * egy fajlba irja az uzeneteit a debugmalloc. Ures fajlnev ("")
+ * eseten visszaallitja stderr-re.
+ */
+void debugmalloc_naplofajl(char const *nev);
+
+/*
+ * Ezt meghivva egy listat keszit az aktualisan lefoglalt
+ * memoriateruletekrol.
+ */
+void debugmalloc_dump();
+
+/* 
+ * Ezek a fuggvenyek vannak a szokasos malloc() es free()
+ * helyett. Nem kell oket hasznalni kozvetlenul; a makrok
+ * altal a rendes malloc() es free() ezekre cserelodik ki.
+ */
+void *debugmalloc_malloc_full(size_t meret, char const *fv, char const *cel, char const *file, unsigned line, int zero);
+void *debugmalloc_realloc_full(void *regimem, size_t newsize, char const *fv, char const *cel, char const *file, unsigned line);
+void debugmalloc_free_full(void *mem, char const *fv, char const *file, unsigned line);
+
+void *debugmalloc_malloc(size_t meret);
+void *debugmalloc_calloc(size_t nmemb, size_t meret);
+void *debugmalloc_realloc(void *regimem, size_t meret);
+void debugmalloc_free(void *mem);
+
+#endif  /* DEBUGMALLOC_H */

receptor/main.c.bak

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+//#include "debugmalloc.h"
+
+//adatszerkezet
+typedef enum {
+    elso_szakasz,hozzavalok,elkeszites_modja
+} beolvasas;
+
+typedef enum {
+    mg=0,g,dkg,kg,ml,cl,dl,l,db,teaskanal,kiskanal,evokanal,merokanal,par,fej,gerezd,szelet,csomag,ismeretlen
+} mertek;
+
+char mertekegysegek_szovegben[][15]={"mg","g","dkg","kg","ml","cl","dl","l","db","teaskanal","kiskanal",
+"evokanal","merokanal","pár","fej","gerezd","szelet","csomag","\0"};
+
+typedef struct hozzavalo_struk{
+    char nev[100];
+    int mennyiseg;
+    mertek mertekegyseg;
+    struct hozzavalo_strukt *kovetkezo_hoz;
+} Hozzavalo;
+
+typedef struct recept{
+    char nev[100];
+    int nehezseg;
+    int fozesi_ido; //percben kifejezve
+    Hozzavalo *hozzavalok_eleje;
+    int fo; //hány fő részére
+    int elkeszites_db;
+    char** elkeszites;
+    struct recept *kovetkezo_rec;
+} Recept;
+
+//szabadítsuk fel a dinamikus tömbnek a helyét
+void szabadit_hozzavalok(Hozzavalo * eleje)
+{
+    Hozzavalo *akt=eleje;
+    Hozzavalo *kov=NULL;
+    while(akt)
+    {
+        kov=akt->kovetkezo_hoz;
+        free(akt);
+        akt=kov;
+    }
+}
+void szabadit_elkeszites(char** pt,int db)
+{
+    int i;
+    for(i=0;i<db;i++)
+    {
+        free(pt[i]);
+    }
+    free(pt);
+}
+void szabadit_receptek(Recept *eleje)
+{
+    Recept *akt=eleje;
+    Recept *kov=NULL;
+    while(akt)
+    {
+        kov=akt->kovetkezo_rec;
+        free(akt);
+        akt=kov;
+    }
+}
+
+void kiir(Recept *akt)
+{
+    printf("Az on valasztasa a %s receptje\n",akt->nev);
+    printf("Nehezsegi szint: %2d/10\n",akt->nehezseg);
+    printf("\r");
+    printf("Varhato idotartam: %d perc\n",akt->fozesi_ido);
+    struct hozzavalo_struk *i;
+    i=akt->hozzavalok_eleje;
+    printf("Hozzavalók:\n");
+    while(i!=NULL)
+    {
+        printf("%d %s %s\n",i->mennyiseg,mertekegysegek_szovegben[i->mertekegyseg],i->nev);
+        i=i->kovetkezo_hoz;
+    }
+    printf("\nElkeszites:\n");
+    int k;
+    for(k=0;k<akt->elkeszites_db;k++)
+    {
+        printf("%s\n",akt->elkeszites[k]);
+    }
+}
+
+//új hozzavalót befűzi a lista elejére
+//!Minden egyes hozzávalóhoz külön foglalunk helyet, ami felszabadítása a hívó kötelessége
+Hozzavalo* hozzavalo_beolvas(Hozzavalo *eleje,char *sztring)
+{
+    Hozzavalo* ujelem=(Hozzavalo*)malloc(sizeof(Hozzavalo));
+    //új értékek beolvasása
+    char ujmenny[255],ujmertek[255],ujnev[100];
+    sscanf(sztring,"%s %s %s",ujmenny,ujmertek,ujnev);
+    //!!le kell kezelni, hogy ne csak ilyen formátumban fogadja elés, hogy ha több fázisa van a hozzávalóknak: (1 dl tej)... Bevonó hozzávalói:
+    if(isdigit(ujmenny[0])) ujelem->mennyiseg=atoi(ujmenny);
+
+    //állapítsuk meg milyen mértékegység
+    int i;
+    i=0;
+    while(strcmp(mertekegysegek_szovegben[i],ujmertek) && strcmp(mertekegysegek_szovegben[i],"")) i++;
+
+    if(!strcmp(mertekegysegek_szovegben[i],ujmertek)) ujelem->mertekegyseg=i;
+    else ujelem->mertekegyseg=ismeretlen;
+
+    //név eltárolása
+    strcpy(ujelem->nev,ujnev);
+
+    //befűzzük a láncolt lista elejére
+    ujelem->kovetkezo_hoz=eleje;
+
+    //visszatérünk az újdonsult elő elemmel
+    return ujelem;
+}
+
+//
+void beolvas(Recept *lista_eleje)
+{
+    char temp[400];
+    int temp2;
+    FILE *fp=NULL;
+    fp=fopen("01.txt", "rt");
+
+    //Debug
+    if (fp==NULL) printf("Nem sikerult megnyitni a fajlt!");
+    else{
+        //NÉV beolvasása
+        fgets(temp,400,fp);
+        strcpy(temp,lista_eleje->nev);
+
+        //nehézségi szint beolvasása
+        fgets(temp,400,fp);
+        sscanf(temp,"%d ",&temp2);
+        lista_eleje->nehezseg=temp2;
+
+        //becsült elkészítési idő beolvasása
+        fgets(temp,400,fp);
+        sscanf(temp,"%d ",&temp2);
+        lista_eleje->fozesi_ido=temp2;
+
+        //Hozzávalók és Elkészítés menetének beolvasása
+        beolvasas allapot;
+        allapot=elso_szakasz;
+
+        //Azért, hogy a NULL pointer mutassa a lista végét
+        lista_eleje->hozzavalok_eleje=NULL;
+
+        int i;
+        int c;
+        while((c=fgetc(fp))!=EOF)
+        {
+            fgets(temp,400,fp);
+            switch(allapot)
+            {
+                case elso_szakasz:
+                if(strstr(temp,"Hozzavalok:")!=NULL)
+                {
+                    allapot=hozzavalok;
+                    fgets(temp,400,fp);
+                    sscanf(temp,"%d ",&temp2);
+                    lista_eleje->fo=temp2;
+                }
+                break;
+
+                case hozzavalok:
+                if(strstr(temp,"Elkeszites:")!=NULL)
+                {
+                    allapot=elkeszites_modja;
+                    break;
+                }
+                else
+                {
+                    lista_eleje->hozzavalok_eleje=hozzavalo_beolvas(lista_eleje->hozzavalok_eleje,temp);
+                }
+                break;
+                case elkeszites_modja:
+                //hány utasítás lesz?
+                lista_eleje->elkeszites_db=atoi(temp);
+
+                //!a hívó feladata felszabadítani
+                lista_eleje->elkeszites= (char **) malloc(lista_eleje->elkeszites_db*sizeof(char*));
+
+                for(i=0;i<lista_eleje->elkeszites_db;i++)
+                {
+                    fgets(temp,400,fp);
+                    lista_eleje->elkeszites[i]=(char *) malloc((strlen(temp)+1)*sizeof(char));
+                    strcpy(lista_eleje->elkeszites[i],temp);
+                }
+                fgets(temp,400,fp);
+                break;
+            }
+        }
+    }
+}
+
+void beker_alapanyagok();
+
+int main()
+{
+    //debugmalloc_naplofajl("dmalloc.txt");
+    Recept *receptek=NULL;
+    beolvas(receptek);
+    kiir(receptek);
+    szabadit_hozzavalok(receptek->hozzavalok_eleje);
+    szabadit_elkeszites(receptek->elkeszites,receptek->elkeszites_db);
+    return 0;
+}

receptor/receptor.cscope_file_list

+"D:\Dropbox\linux\receptor\debugmalloc.h"
+"D:\Dropbox\linux\receptor\main.c"

receptor/receptor.depend

+# depslib dependency file v1.0
+1384195283 source:/home/don/Dokumentumok/receptor/main.c
+	<stdio.h>
+	<stdlib.h>
+	<string.h>
+	<ctype.h>
+
+1384196086 
+
+1384196074 source:d:\dropbox\linux\receptor\debugmalloc.c
+	<stdlib.h>
+	<stdio.h>
+	<ctype.h>
+	<string.h>
+	<time.h>
+	<stdarg.h>
+	"debugmalloc.h"
+
+1384196074 oc.h"
+
+1384196086 d:\dropbox\linux\receptor\debugmalloc.h
+	<stdlib.h>
+
+1384264204 source:d:\dropbox\linux\receptor\main.c
+	<stdio.h>
+	<stdlib.h>
+	<string.h>
+	<ctype.h>
+
+1384265384 source:/home/don/Dokumentumok/Dropbox/linux/receptor/main.c
+	<stdio.h>
+	<stdlib.h>
+	<string.h>
+	<ctype.h>
+
+1384646109 source:/home/don/Dokumentumok/Dropbox/linux/prog-i-nzh/receptor/main.c
+	<stdio.h>
+	<stdlib.h>
+	<string.h>
+	<ctype.h>
+

receptor/receptor.h~

+typedef enum menu;
+typedef struct Hozzavalo Hozzavalo;
+typedef struct Lista_hoz Lista_hoz;
+typedef struct Recept Recept;
+typedef struct lista_recept Lista_rec;
+
+void beszur_a_hoz_listaba(Hozzavalo*,Lista_hoz*);
+void beszur_a_rec_listaba(Recept*,Lista_rec*);
+Hozzavalo* hozzavalo_beolvas(char*);
+Recept* beolvas(FILE*,char*);
+void lista_letrehoz(Lista_rec*);
+void beker_alapanyagok();
+void kiir(Recept*);
+void szabadit_hozzavalok(Hozzavalo*);
+void szabadit_elkeszites(char**,int db);
+void szabadit_receptek(Recept*);

receptor/receptor.layout

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_layout_file>
+	<ActiveTarget name="Debug" />
+	<File name="main.c" open="1" top="1" tabpos="1">
+		<Cursor position="4545" topLine="233" />
+	</File>
+	<File name="receptor.h" open="1" top="0" tabpos="2">
+		<Cursor position="0" topLine="0" />
+	</File>
+</CodeBlocks_layout_file>

receptor/test/0

+104
+01.txt