Mercredi 24 avril 2024 - 04:15  

/******************************************************************/
/*                                                                */
/* Programme: Greffeur.c                                          */
/*                                                                */
/* Auteur: L'incroyable HUNK F Mazué pour ANT le 04/11/1991       */
/*                                                                */
/* Fonction: Greffer un éxécutable écrit par vous sur n'importe   */
/*          quel éxécutable de votre choix                        */
/*                                                                */
/* Remarque: Vous êtes vivement prié de ne pas vous servir de cet */
/*           utilitaire de grande classe afin de répandre         */
/*           d'odieux virus coquilles tout partout....            */
/*                                                                */
/* Utilisation: Greffeur            */
/*                                                                */
/* Ecrit en SAS 5.10                                              */
/*                                                                */
/* Compiler et linker d'un seul coup par:                         */
/*                         lc -d0 -m0t -v -y -Ln greffeur         */
/*                                                                */
/* VIVE LES POINTEURS !                                           */
/*                                                                */
/******************************************************************/
     

#include <exec/types.h>
#include <exec/memory.h>
#include <libraries/dos.h>
#include <libraries/dosextens.h>
#include <stdio.h>

struct FileLock *LockGreffe;  /* because longword alignment */
struct FileLock *LockSource;
struct FileLock *LockTarget;

struct FileInfoBlock *InfoGreffe;  
struct FileInfoBlock *InfoSource;
struct FileInfoBlock *InfoTarget;

LONG *Source;
LONG *Greffe;
LONG *Target;
LONG *Fixe;
LONG *FixeSource;
LONG *FixeGreffe;

BPTR source;
BPTR greffe;
BPTR target;

VOID CleanUp();
LONG *Reloc(LONG *,int);
LONG *Code(LONG *);
LONG *Debug(LONG *);
LONG *Symbol(LONG *);
LONG *Data(LONG *);
LONG *Bss(LONG *);
LONG *Overlay(LONG *);


VOID main(int argc, char **argv)
{
   
   int i;
   int nbr_hunk = 0;
   int compteur;
   LONG *pointeur;
   LONG Test;
   
   printf("\nGreffeur de Programmes !!!\n");
   printf("Par F Mazué, L'incroyable HUNK !\n");
   
   if(argc != 4)
   {
      printf("La ligne doit avoir comme paramètres trois noms de fichiers\n\n");
      printf("D'abord le fichier source qui doit être éxécutable\n");
      printf("Ensuite le fichier à greffer sur le fichier source\n");
      printf("             ce fichier doit aussi être éxécutable\n");
      printf("Enfin le fichier cible\n");
      CleanUp();
   }
   
   InfoGreffe=(struct FileInfoBlock *)
   AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC|MEMF_CLEAR);
   if(!InfoGreffe)
   {
      CleanUp();
   }
   
   InfoSource=(struct FileInfoBlock *)
   AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC|MEMF_CLEAR);
   if(!InfoSource)
   {
      CleanUp();
   }
   
   InfoTarget=(struct FileInfoBlock *)
   AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC|MEMF_CLEAR);
   if(!InfoTarget)
   {
      CleanUp();
   }
   
   LockSource = (struct FileLock *)Lock(argv[1],SHARED_LOCK);
   Examine(LockSource,InfoSource);
   
   if(InfoSource->fib_DirEntryType >0)
   {
      printf("Nom de fichier ou de répertoire incorrect\n");
      CleanUp();
   }
   
   LockGreffe = (struct FileLock *)Lock(argv[2],SHARED_LOCK);
   Examine(LockGreffe,InfoGreffe);
   
   if(InfoGreffe->fib_DirEntryType >0)
   {
      printf("Nom de fichier ou de répertoire incorrect\n");
      CleanUp();
   }
   
   
   Source=(LONG *)AllocMem(InfoSource->fib_Size,MEMF_PUBLIC|MEMF_CLEAR);
   if(!Source)
   {
      CleanUp();
   }
   FixeSource=Source;
   source=Open(argv[1],MODE_OLDFILE);
   Read(source,Source,InfoSource->fib_Size);
   
   Greffe=(LONG *)AllocMem(InfoGreffe->fib_Size,MEMF_PUBLIC|MEMF_CLEAR);
   if(!Greffe)
   {
      CleanUp();
   }
   FixeGreffe=Greffe;
   greffe=Open(argv[2],MODE_OLDFILE);
   Read(greffe,Greffe,InfoGreffe->fib_Size);
   
   Target=(LONG *)AllocMem(InfoGreffe->fib_Size+InfoSource->fib_Size,
   MEMF_PUBLIC|MEMF_CLEAR);
   if(!Greffe)
   {
      CleanUp();
   }
   
   Fixe=Target;
   
   target=Open(argv[3],MODE_NEWFILE);
   if(!target)
   {
      CleanUp();
   }
   
   LockTarget = (struct FileLock *)Lock(argv[3],ACCESS_WRITE);
   
   if(*Source != 0x3F3 || *Greffe != 0x3F3)
   {
      printf("\nIl faut des fichiers éxécutables !!\n");
      CleanUp();
   }
   
   pointeur = Greffe+2;
   
   if(*pointeur !=2)
   {
      printf("\nLa Greffe ne rempli pas les conditions nécéssaires\n");
      printf("Opération terminée... désolé\n");
   }
         
   *Target++=*Source++;            /* 3F3 */
   *Target++=*Source++;            /* Nom du segment (à priori NULL) */
   
   nbr_hunk=*Source;
   printf("\nLe programme Source contient %d HUNKS\n",nbr_hunk);
   
   *Source +=1;                    /* un segment de plus */
   *Target++=*Source++;            /* Nbre de segment placé */
   *Target++=*Source++;            /* N° du premier segment chargé */
   
   compteur = *Source;
   compteur +=1;
   
   if(compteur != nbr_hunk)
   {
      printf("\n le nombre de segmentS de la source et le nombre de HUNKS\n");
      printf("effectivement chargés ne se correspondent pas !\n");
      printf("\nOn essaie quand même !  [RETURN]\n");
      getchar();
   }
   
   
   *Source +=1;              /* Dernier segment à charger plus 1 */
   *Target++=*Source++;
   
   
   /* ici Source pointe sur le premier identificateur de la source */
   
   pointeur=Greffe+5;        /* Taille du segment à ajouter */
   
   printf("\nLa Taille du segment greffé est %d octets\n",*pointeur*4);
   
   *Target++=*pointeur++;
   
   for(i=0;ifib_Size);  
   if(FixeGreffe) FreeMem(FixeGreffe,InfoGreffe->fib_Size);
   
   if(LockSource) UnLock(LockSource);
   if(LockGreffe) UnLock(LockGreffe);
   if(LockTarget) UnLock(LockTarget);
   
   if(source) Close(source);
   if(greffe) Close(greffe);
   if(target) Close(target);
   
   if(InfoSource) FreeMem(InfoSource,sizeof(struct FileInfoBlock));
   if(InfoGreffe) FreeMem(InfoGreffe,sizeof(struct FileInfoBlock));
   if(InfoTarget) FreeMem(InfoTarget,sizeof(struct FileInfoBlock));
   
   exit(0);  /* Fin du match ! */
}
           

LONG *Reloc(LONG *pointeur,int deplacement)
{
   int i;
   int encore=1;
   int limite;
      
   *Target++=*pointeur++;  /* 0x3EC  est mis*/
   
   while(encore)
   {
      
      limite=*pointeur;
      
      *Target++=*pointeur++; /* nbr de correction placé */
      *pointeur +=deplacement;          /* segment corrigé */
      *Target++=*pointeur++; /* et placé */                   
      
      for(i=0;i