back2roots/padua/padua.7z/padua/uucp/auucp+-1.02/fuucp_plus_src.lzh/uucplib/support.c

C/C++ Source or Header | 1991-04-07 | 5.5 KB | 226 lines

#include <string.h>
#include "uucpbase.h"
#include "uucpproto.h"


extern VOID __stdargs SPRINTF(UBYTE *, UBYTE *, ...);

/*
 *  TempFile()
 *
 *  Liefert den Zeiger auf einen String zurⁿck.
 *  Dieser kann dann als Name zum temporΣren Anlegen von Dateien benutzt werden.
 *  Der Name enthΣlt den vollen Pfad, relativ zu T:
 *
 *  Achtung: macht Forbid()
 */
UBYTE *__asm _TempFileName(register __a6 struct UUCPBase *UUCPBase)
{
  UBYTE *name;
  ULONG zaehler;

  if((name = UUAllocMem(50, MEMF_CLEAR | MEMF_PUBLIC)) != NULL)
  {
    Forbid();
      zaehler = UUCPBase->TempCounter++;
    Permit();

    SPRINTF(name, "T:temp%ld", zaehler);

    return name;
  }
  return NULL;
}

/*
 *  UUAllocMem()
 *
 *  Alloziert einen Speicherblock in der gewⁿnschten Gr÷▀e und den gewⁿnschten
 *  Anforderungen, und trΣgt diesen in eine Liste ein, damit der Speicher,
 *  falls dies nicht eigenhΣndig getan wurde, bei einem CloseLibrary wieder
 *  freigegeben wird. (als Kennung wird die Taskaddresse verwendet.)
 *
 *  Bei Fehler wird NULL zurⁿckgeliefert.
 */
VOID *__asm _UUAllocMem(register __a6 struct UUCPBase *UUCPBase,
                        register __d0 size,
                        register __d1 ULONG memreqs)
{
  struct MinList *ml;
  struct SignalSemaphore *sm;

  struct MyMemNode *memd;
  VOID *buffer;

  sm = &UUCPBase->ub_MemList.ml_Semaphore;
  ml = &UUCPBase->ub_MemList.ml_List;


  if((memd = (struct MyMemNode *)
    AllocMem((ULONG)sizeof(struct MyMemNode), MEMF_PUBLIC | MEMF_CLEAR)) != NULL)
  {
    if((buffer = AllocMem(size, memreqs)) != NULL)
    {
      ObtainSemaphore(sm);

      memd->mn_Buf       = buffer;         // Zeiger auf Buffer
      memd->mn_BufLength = size;           // LΣnge
      memd->mn_Owner     = FindTask(NULL); // Addresse des Tasks, der Speicher
                                           // angefordert hat.
      AddHead((struct List *)ml, (struct Node *)memd);

      ReleaseSemaphore(sm);

      return buffer;
    }
    FreeMem(memd, (ULONG)sizeof(struct MyMemNode));
  }
  return NULL;
}

/*
 *  UUFreeMem(void *)
 *
 *  Gibt den angegebenen Speicherblock frei und entfernt den Node
 *  aus der Liste.
 *
 */
VOID __asm _UUFreeMem(register __a6 struct UUCPBase *UUCPBase,
                      register __a0 VOID *buffer)
{
  struct MinList *ml;
  struct SignalSemaphore *sm;
  struct MyMemNode *work_node;
  struct MyMemNode *next_node;

  sm = &UUCPBase->ub_MemList.ml_Semaphore;
  ml = &UUCPBase->ub_MemList.ml_List;

  ObtainSemaphore(sm);

  work_node = (struct MyMemNode *)ml->mlh_Head;
  while(next_node = (struct MyMemNode *)work_node->mn_Node.ln_Succ)
  {
    if(work_node->mn_Buf == buffer)
    {
      FreeMem(work_node->mn_Buf, work_node->mn_BufLength);

      // ...dann den Node entfernen...
      Remove((struct Node *)work_node);

      // ...und schlie▀lich die Node Struktur freigeben!
      FreeMem(work_node, (ULONG)sizeof(struct MyMemNode));
      break;
    }
    work_node = next_node;
  }
  ReleaseSemaphore(sm);
}

/*
 *  UUFreeAllMem(struct Task *)
 *
 *  Gibt allen allozierten Speicher frei, der dem angegebenen Task geh÷rt.
 *  Ist Task == NULL, dann wird der gesamte Speicher freigegeben!
 *
 */
VOID __asm _UUFreeAllMem(register __a6 struct UUCPBase *UUCPBase,
                         register __a0 struct Task *Owner)
{
  struct MinList *ml;
  struct SignalSemaphore *sm;
  struct MyMemNode *work_node;
  struct MyMemNode *next_node;

  sm = &UUCPBase->ub_MemList.ml_Semaphore;
  ml = &UUCPBase->ub_MemList.ml_List;

  ObtainSemaphore(sm);

  work_node = (struct MyMemNode *)ml->mlh_Head;
  while(next_node = (struct MyMemNode *)work_node->mn_Node.ln_Succ)
  {
    /*
        Wenn Owner == NULL, dann alles freigeben.
        Ansonsten nur die Nodes freigeben, die auch dem Task geh÷ren.
     */
    if( Owner == NULL || (Owner != NULL && Owner == work_node->mn_Owner) )
    {
      // erst den Buffer freigeben...
      FreeMem(work_node->mn_Buf, work_node->mn_BufLength);

      // ...dann den Node entfernen...
      Remove((struct Node *)work_node);

      // ...und schlie▀lich die Node Struktur freigeben!
      FreeMem(work_node, (ULONG)sizeof(struct MyMemNode));
      work_node = next_node;
    }
  }
  ReleaseSemaphore(sm);
}

/*
 *  CreatePort()
 *
 *  Standardfunktion einer jeden Library...
 *  Legt einen Message Port an, der public ist, wenn ein Name mit angegeben
 *  wurde.
 */
struct MsgPort *__asm _CreatePort(register __a6 struct UUCPBase *UUCPBase,
                                  register __a0 UBYTE *name,
                                  register __d0 LONG priority)
{
  struct MsgPort *mp;
  LONG sigbit;

  if((sigbit = AllocSignal(-1L)) == -1L)
    return NULL;

  if((mp = UUAllocMem(sizeof(struct MsgPort), MEMF_CLEAR | MEMF_PUBLIC)) == NULL)
  {
    FreeSignal(sigbit);
    return NULL;
  }

  mp->mp_Node.ln_Name = name;
  mp->mp_Node.ln_Pri  = priority;
  mp->mp_Node.ln_Type = NT_MSGPORT;

  mp->mp_Flags   = PA_SIGNAL;
  mp->mp_SigBit  = sigbit;
  mp->mp_SigTask = FindTask(NULL);

  if(name != NULL)
    AddPort(mp);
  else
    NewList(&(mp->mp_MsgList));

  return mp;
}

/*
 *
 *  DeletePort(struct MessagePort *)
 *  Entfernt den angegebenen MessagePort.
 *
 */
VOID __asm _DeletePort(register __a6 struct UUCPBase *UUCPBase,
                       register __a0 struct MsgPort *mp)
{
  if(mp->mp_Node.ln_Name != NULL)
    RemPort(mp);

  // Die folgenden Zeilen machen es schwierig, den MsgPort ausversehen
  // wieder zu verwenden.

  mp->mp_SigTask         = (struct Task *)-1L;
  mp->mp_MsgList.lh_Head = (struct Node *)-1L;

  // Signal freigeben
  FreeSignal(mp->mp_SigBit);

  // Und Speicher freigeben.
  UUFreeMem(mp);
}