home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / auucp+-1.02 / fuucp_plus_src.lzh / uucplib / buffer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-10  |  12.3 KB  |  399 lines
  1. /* -------------------------------------------------------------------------------------- */
  2.  
  3. #include <string.h>
  4. #include "uucpbase.h"
  5. #include "uucpproto.h"
  6. #include "buffer.h"
  7.  
  8. /* -------------------------------------------------------------------------------------- */
  9.  
  10. /*  lese_puffer - !PRIVATE ROUTINE!
  11.     Liest so viel wie m÷glich Byte in den Buffer ein. Grundannahme ist, da▀ der
  12.     Puffer "ausbenutzt" ist. Es wird sowohl die neue Ausnutzung des Puffers wie
  13.     auch der Zeiger auf die aktuelle Position korrigiert.
  14. */
  15.  
  16.  
  17. STATIC BOOL __asm lese_puffer (register __a6 struct UUCPBase *UUCPBase,
  18.                                register __a0 struct datei *meine_datei)
  19. {
  20.   LONG anzahl;
  21.  
  22.   if (meine_datei->modus == MODE_OLDFILE)
  23.   {
  24.     anzahl = Read (meine_datei->datei_zeiger, meine_datei->puffer_zeiger, PUFFER_GROESSE);
  25.     if (anzahl == -1)
  26.     {
  27.       return (FALSE);
  28.     }
  29.     meine_datei->puffer_voelle = anzahl;
  30.     meine_datei->akt_position = 0;
  31.     return (TRUE);
  32.   }  
  33.   return (FALSE);
  34. }
  35.  
  36. /* -------------------------------------------------------------------------------------- */
  37.  
  38. /*  schreibe_puffer - !PRIVATE ROUTINE!
  39.     Schreib den Puffer bis "akt_position" in die Datei auf dem gewΣhlten Medium.
  40.     "akt_position" wird danach zurⁿckgesetzt, der Puffer kann neu benutzt werden.
  41.     Sollten keine Zeichen im Puffer sein (weil "akt_position" auf 0 steht), wird
  42.     "TRUE" zurⁿckgeliefert.
  43. */
  44.  
  45. STATIC BOOL __asm schreibe_puffer (register __a6 struct UUCPBase *UUCPBase,
  46.                                    register __a0 struct datei *meine_datei)
  47. {
  48.   LONG anzahl;
  49.  
  50.   if (meine_datei->modus == MODE_NEWFILE)
  51.   {
  52.     if (meine_datei->akt_position > 0)
  53.     {
  54.       anzahl = Write (meine_datei->datei_zeiger, meine_datei->puffer_zeiger, meine_datei->akt_position);
  55.       if (anzahl == -1)
  56.       {
  57.         return (FALSE);
  58.       }
  59.       if (anzahl != meine_datei->akt_position)
  60.       {
  61.         return (FALSE);
  62.       }
  63.       meine_datei->akt_position = 0;
  64.       return (TRUE);
  65.     }
  66.     else
  67.     {
  68.       return (TRUE);
  69.     }
  70.   }  
  71.   return (FALSE);
  72. }
  73.  
  74. /* -------------------------------------------------------------------------------------- */
  75.  
  76. /*  oeffne_datei
  77.     ╓ffnet Datei zum sequenziellen Lesen (Modus MODE_OLDFILE) oder legt neue
  78.     Datei zum sequenziellen Schreiben an (Modus MODE_NEWFILE). Rⁿckgabe ist
  79.     eine Struktur vom Typ "datei". Rⁿckgabe ist NULL wenn Datei nicht ge-
  80.     ÷ffnet werden kann oder kein RAM fⁿr Puffer da ist.
  81. */
  82.  
  83. struct datei *__asm oeffne_datei(register __a6 struct UUCPBase *UUCPBase,
  84.                                  register __a0 char *name,
  85.                                  register __d1 ULONG modus)
  86. {
  87.   struct datei *meine_datei;
  88.   char *mein_puffer;
  89.   BPTR mein_bptr;
  90.   BOOL ergebnis;
  91.  
  92.   meine_datei = AllocMem (sizeof (struct datei), MEMF_CLEAR|MEMF_PUBLIC);
  93.   if (meine_datei)
  94.   {
  95.     mein_puffer = AllocMem (PUFFER_GROESSE, MEMF_CLEAR);
  96.     if (mein_puffer)
  97.     {
  98.       if ((modus == MODE_OLDFILE) || (modus == MODE_NEWFILE))
  99.       {
  100.         mein_bptr = Open (name, modus);
  101.         if (mein_bptr)
  102.         {
  103.           meine_datei->datei_zeiger = mein_bptr;
  104.           meine_datei->puffer_zeiger = mein_puffer;
  105.           meine_datei->puffer_groesse = PUFFER_GROESSE;
  106.           meine_datei->akt_position = 0;
  107.           meine_datei->modus = modus;
  108.           if (modus == MODE_OLDFILE)
  109.           {
  110.             ergebnis = lese_puffer (UUCPBase, meine_datei);
  111.             if (ergebnis == TRUE)
  112.             {
  113.               return (meine_datei);
  114.             }
  115.           }
  116.           else
  117.           {
  118.             meine_datei->puffer_voelle = 0;
  119.             return (meine_datei);
  120.           }
  121.           Close (mein_bptr);
  122.         }
  123.       }
  124.       FreeMem(mein_puffer, PUFFER_GROESSE);
  125.     }
  126.     FreeMem(meine_datei, sizeof(struct datei));
  127.   }
  128.   return (NULL);
  129. }
  130.  
  131. /* -------------------------------------------------------------------------------------- */
  132.  
  133. /*  hole_zeichen
  134.     Holt aus der Datei, welche in "*meine_datei" uebergeben wird die
  135.     gewⁿnschte Anzahl von Byte und kopiert diese in den "puffer". Benutzer mu▀
  136.     selbst dafⁿr sorgen da▀ der Puffer ausreichend gro▀ ist.
  137.     Als Rⁿckgabe gibts die Anzahl der gelesenen Byte oder einen Fehlercode:
  138.  
  139.     LESE_FEHLER                   : Datei konnte gelesen werden. Pufferung
  140.                                     defekt. Datei schlie▀en und neu ÷ffnen.
  141.     FALSCHER_MODUS                : Datei ist mit Modus "MODE_NEWFILE" ge-
  142.                                     ÷ffnet und kann nicht gelesen werden.
  143. */
  144.  
  145. LONG __asm hole_zeichen (register __a6 struct UUCPBase *UUCPBase,
  146.                          register __a0 struct datei *meine_datei,
  147.                          register __a1 char *puffer,
  148.                          register __d1 ULONG anzahl)
  149. {
  150.   LONG zaehler = 0;
  151.   BOOL ergebnis;
  152.  
  153.   if (meine_datei->modus == MODE_OLDFILE)
  154.   {
  155.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  156.     {
  157.       ergebnis = lese_puffer (UUCPBase, meine_datei);
  158.       if (ergebnis == FALSE)
  159.       {
  160.         return (LESE_FEHLER);
  161.       }
  162.     }
  163.     if (meine_datei->akt_position > (LONG) (meine_datei->puffer_voelle - 1))
  164.     {
  165.       return (0L);
  166.     }
  167.     while (anzahl > 0)
  168.     {
  169.       if (meine_datei->akt_position + anzahl > meine_datei->puffer_voelle)
  170.       {
  171.         memcpy (puffer + zaehler, meine_datei->puffer_zeiger + meine_datei->akt_position,
  172.                 meine_datei->puffer_voelle - meine_datei->akt_position);
  173.         zaehler += meine_datei->puffer_voelle - meine_datei->akt_position;
  174.         anzahl -= meine_datei->puffer_voelle - meine_datei->akt_position;
  175.         ergebnis = lese_puffer (UUCPBase, meine_datei);
  176.         if (ergebnis == FALSE)
  177.         {
  178.           return (LESE_FEHLER);
  179.         }
  180.         if (meine_datei->puffer_voelle == 0)
  181.         {
  182.           return (zaehler);
  183.         }
  184.       }
  185.       else
  186.       {
  187.         memcpy (puffer + zaehler, meine_datei->puffer_zeiger + meine_datei->akt_position, anzahl);
  188.         meine_datei->akt_position += anzahl;
  189.         zaehler += anzahl;
  190.         return (zaehler);
  191.       }
  192.     }
  193.   }
  194.   else
  195.   {
  196.     return (FALSCHER_MODUS);
  197.   }
  198. }
  199.  
  200. /* -------------------------------------------------------------------------------------- */
  201.  
  202. /*  schliesse_datei
  203.     Schlie▀ die Datei (und schreibt vorher beim Schreibmodus den Puffer in
  204.     die Datei) und gibt allen allozierten Speicher wieder frei. Diese Routine
  205.     liefert einen der definierten Fehlercodes zurⁿck. Beim Fehler "NICHT_SCHLIESSBAR"
  206.     werden die Strukturen und der Puffer _*NICHT*_ freigegeben und einen
  207.     erneuten Schliessversuch m÷glich zu machen.
  208.  
  209.     NICHT_SCHLIESSBAR                 : Datei kann nicht geschlossen werden. Keine
  210.                                         ─nderung durchgefⁿhrt.
  211.     KEIN_FEHLER                       : Datei dicht und Puffer entfernt.
  212.     MEDIUM_VOLL                       : Medium ist voll oder Puffer konnte aus anderen
  213.                                         Grⁿnden nicht geschrieben werden.
  214. */
  215.  
  216. LONG __asm schliesse_datei(register __a6 struct UUCPBase *UUCPBase,
  217.                            register __a0 struct datei *meine_datei)
  218. {
  219.   BOOL ergebnis;
  220.  
  221.   if (meine_datei->modus == MODE_OLDFILE)
  222.   {
  223.     ergebnis = Close (meine_datei->datei_zeiger);
  224.     if (ergebnis == FALSE)
  225.     {
  226.       return (NICHT_SCHLIESSBAR);
  227.     }      
  228.     FreeMem(meine_datei->puffer_zeiger, PUFFER_GROESSE);
  229.     FreeMem(meine_datei, sizeof(struct datei));
  230.     return (KEIN_FEHLER);
  231.   }
  232.   else
  233.   {
  234.     ergebnis = schreibe_puffer (UUCPBase, meine_datei);
  235.     if (ergebnis == FALSE)
  236.     {
  237.       return (MEDIUM_VOLL);
  238.     }
  239.     ergebnis = Close (meine_datei->datei_zeiger);
  240.     if (ergebnis == FALSE)
  241.     {
  242.       return (NICHT_SCHLIESSBAR);
  243.     }
  244.     FreeMem(meine_datei->puffer_zeiger, PUFFER_GROESSE);
  245.     FreeMem(meine_datei, sizeof(struct datei));
  246.     return (KEIN_FEHLER);
  247.   }
  248. }
  249.  
  250. /* -------------------------------------------------------------------------------------- */
  251.  
  252. /*  schreibe_zeichen
  253.     Schreibt die gewⁿnschte Anzahl von Byte in die Datei die mit "*meine_datei"
  254.     ⁿbergeben wird. Rⁿckgabe ist ein Fehlercode:
  255.  
  256.     SCHREIB_FEHLER            : Datei konnte nicht geschrieben werden. Datei und
  257.                                 Pufferung defekt. Bitte schlie▀en und l÷schen.
  258.     FALSCHER_MODUS            : Datei ist mit Modus "MODE_OLDFILE" ge÷ffnet worden.
  259.                                 Es wurde keine ─nderung vorgenommen.
  260.     KEIN_FEHLER               : "anzahl" wurde zumindest in den Puffer korrekt ge-
  261.                                 schrieben.
  262. */
  263.  
  264. LONG __asm schreibe_zeichen(register __a6 struct UUCPBase *UUCPBase,
  265.                             register __a0 struct datei *meine_datei,
  266.                             register __a1 char *puffer,
  267.                             register __d1 ULONG anzahl)
  268. {
  269.   LONG zaehler = 0;
  270.   BOOL ergebnis;
  271.  
  272.   if (meine_datei->modus == MODE_NEWFILE)
  273.   {
  274.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  275.     {
  276.       ergebnis = schreibe_puffer (UUCPBase, meine_datei);
  277.       if (ergebnis == FALSE)
  278.       {
  279.         return (SCHREIB_FEHLER);
  280.       }
  281.     }
  282.     while (anzahl > 0)
  283.     {
  284.       if (meine_datei->akt_position + anzahl > meine_datei->puffer_groesse)
  285.       {
  286.         memcpy (meine_datei->puffer_zeiger + meine_datei->akt_position, puffer + zaehler,
  287.                 meine_datei->puffer_groesse - meine_datei->akt_position);
  288.  
  289.         zaehler += meine_datei->puffer_groesse - meine_datei->akt_position;
  290.         anzahl -= meine_datei->puffer_groesse - meine_datei->akt_position;
  291.  
  292.         meine_datei->akt_position += meine_datei->puffer_groesse - meine_datei->akt_position;
  293.  
  294.         ergebnis = schreibe_puffer (UUCPBase, meine_datei);
  295.         if (ergebnis == FALSE)
  296.         {
  297.           return (SCHREIB_FEHLER);
  298.         }
  299.       }
  300.       else
  301.       {
  302.         memcpy (meine_datei->puffer_zeiger + meine_datei->akt_position,
  303.                 puffer + zaehler, anzahl);
  304.         meine_datei->akt_position += anzahl;
  305.  
  306.         return (KEIN_FEHLER);
  307.       }
  308.     }
  309.   }
  310.   else
  311.   {
  312.     return (FALSCHER_MODUS);
  313.   }
  314. }
  315.  
  316. /* -------------------------------------------------------------------------------------- */
  317.  
  318. /*  hole_byte
  319.     Holt ein einzelnes Zeichen aus der angegebenen Datei. Rⁿckgabe ist das
  320.     Zeichen oder ein Fehlercode:
  321.  
  322.     FALSCHER_MODUS                : Datei ist zum Schreiben und nicht zum
  323.                                     Lesen er÷ffnet.
  324.     DATEI_ENDE                    : Das Ende der Datei ist erreicht.
  325.     LESE_FEHLER                   : Datei konnte aus irgendeinem Grund nicht
  326.                                     gelesen werden. Datei bitte schlie▀en und
  327.                                     neu ÷ffnen.
  328. */
  329.  
  330. WORD __asm hole_byte (register __a6 struct UUCPBase *UUCPBase,
  331.                       register __a0 struct datei *meine_datei)
  332. {
  333.   WORD zeichen;
  334.   BOOL ergebnis;
  335.  
  336.   if (meine_datei->modus == MODE_OLDFILE)
  337.   {
  338.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  339.     {
  340.       ergebnis = lese_puffer (UUCPBase, meine_datei);
  341.       if (ergebnis == FALSE)
  342.       {
  343.         return (LESE_FEHLER);
  344.       }
  345.     }
  346.     if (meine_datei->akt_position > (LONG) (meine_datei->puffer_voelle - 1))
  347.     {
  348.       return (DATEI_ENDE);
  349.     }
  350.     zeichen = (WORD) *(meine_datei->puffer_zeiger + meine_datei->akt_position);
  351.     
  352.     meine_datei->akt_position++;
  353.     return (zeichen);
  354.   }
  355.   else
  356.   {
  357.     return (FALSCHER_MODUS);
  358.   }
  359. }
  360.  
  361. /* -------------------------------------------------------------------------------------- */
  362.  
  363. /*  schreibe_byte
  364.     Schreibt ein einzelnes Zeichen in die angegebene Datei. Liefert einen
  365.     Fehlercode zurⁿck:
  366.  
  367.     FALSCHER_MODUS          : Datei wurde zum Lesen, nicht zum Schreiben ge-
  368.                               ÷ffnet.
  369.     SCHREIB_FEHLER          : Datei konnte nicht geschrieben werden, evtl.
  370.                               Medium voll.
  371.     KEIN_FEHLER             : Zeichen konnte in den Puffer geschrieben werden.
  372. */
  373.  
  374. LONG __asm schreibe_byte(register __a6 struct UUCPBase *UUCPBase,
  375.                          register __a0 struct datei *meine_datei,
  376.                          register __d1 UBYTE zeichen)
  377. {
  378.   BOOL ergebnis;
  379.  
  380.   if (meine_datei->modus == MODE_NEWFILE)
  381.   {
  382.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  383.     {
  384.       ergebnis = schreibe_puffer (UUCPBase, meine_datei);
  385.       if (ergebnis == FALSE)
  386.       {
  387.         return (SCHREIB_FEHLER);
  388.       }
  389.     }
  390.     *(meine_datei->puffer_zeiger + meine_datei->akt_position) = zeichen;
  391.     
  392.     meine_datei->akt_position++;
  393.     return (KEIN_FEHLER);
  394.   }
  395.   return (FALSCHER_MODUS);
  396. }
  397.  
  398. /* -------------------------------------------------------------------------------------- */
  399.