dlxload.cc

来自「SEAL是DOS 下的32位保护模式的GUI程序」· CC 代码 · 共 597 行 · 第 1/2 页

/******************************************************************
 * SEAL 2.0                                                       *
 * Copyright (c) 1999-2002 SEAL Developers. All Rights Reserved.  *
 *                                                                *
 * Web site: http://sealsystem.sourceforge.net/                   *
 * E-mail (current maintainer): [e-mail]      *
 ******************************************************************/

/*
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

// DLX Dynamic Loading and eXecution V2.91
// Copyright (c) 1997-1998, Nanosoft, Inc.

/*
        Todo:
              * Fix bug in bidirectional (and let libraries load themselves)
              * Fix instantiation
              * Fix VERGEN
              * Rewrite DLXList
              * Rewrite DLXGen
              * Add CodeAlloc
              - Add DPLUG interface
              * Fix use of new operator
              * Check why silent failures can occur
              * Finish memory bulletproofing
              * Add resource files
              * Add finalization for destructors
              * Insert all relevant error codes
              * Check myimps and derror for invalid usage
              * Fix auto-unloader
*/

#define __SEAL__

#include <stdio.h>
#include <malloc.h>
#include <io.h>
#include <string.h>
#include <pc.h>
#include <allegro.h>
#include <dlx.h>
#include <zlib.h>

extern "C" void *my_load_datafile(FILE *fp,long len);

#include <unistd.h>
#include <dir.h>

#define EXE_HEADER   512

#define DLX_ID(a,b,c,d)     ((a<<24) | (b<<16) | (c<<8) | d)

#define ID_DLXDATAFILE DLX_ID('0','T','A','D')

typedef long long Hdlx_t;

class CDLXImports {
        protected:
                char** names;
                long* weakoff;
                long* numlocs;
                long** relocs;
                long numimports;
                long errors;
        public:
                CDLXImports(void* infile, long nums);
                ~CDLXImports();
                void* operator new(size_t mysize);
                void operator delete(void* p);
                void Replace(char* data, char* name, char* placement);
                void ReplaceWeak(char* data, char* name, char* placement);
                long CheckEmpty();
                long Validate();
};
class CDLX;
class CDLXListLink;
class CDLXLinkedList {
        protected:
                friend CDLXListLink;
                friend CDLX;
                CDLX* mypointer;
                CDLXLinkedList* next;
                CDLXLinkedList* last;
        public:
                void* operator new(size_t mysize);
                void operator delete(void* p);
                CDLXLinkedList(CDLX*);
                ~CDLXLinkedList();
                operator CDLX*();
                void Link(CDLXLinkedList* mydlx);
};
class CDLXListLink {
        protected:
                CDLXLinkedList* mylist;
                CDLXLinkedList* lastinline;
        public:
                CDLXListLink();
                ~CDLXListLink();
                void AddLink(CDLXLinkedList* mylink);
                int AddNewLink(CDLXLinkedList* mylink);
                CDLXLinkedList* GetLink(char* name);
                CDLXLinkedList* GetLink(hdlx_t cl);
                void RemoveLink(CDLXLinkedList* mylink);
                void GetLinks(CDLXListLink& tolink);
                CDLXLinkedList* GetFullList();
        public:
                // passed on functions (for CDLX):
                void Unload1();
                void Unload2();
                void Clear();
                int Pass3();
                void RInstanceInc();
                void Initialize();
                void RInstanceDec();
                void StripToUnload();
                void DeInitialize();
                long Allow(hdlx_t toal);
                void LUnload();
                void Suicide();
};
class CDLXSymbolList {
        protected:
                char*** tosymbols;
                hdlx_t* ids;
                long numdlx;
        public:
                CDLXSymbolList();
                ~CDLXSymbolList();
                int AddExports(hdlx_t id, char** tosymbol);
                long Resolve(CDLXListLink& ils, CDLXImports& ims, char* data);
                void RemoveExports(hdlx_t id);
};
class CEntryTracker {
        protected:
                void** functions;
                char** names;
                long numentries;
        public:
                CEntryTracker();
                ~CEntryTracker();
                long AddPoint(char* name, void* function);
                long AddEntries(char **data);
                void* GetEntry(char* name);
};
class CDLX {
        public:
                friend CDLXListLink;
                char *args;
                char* data;
                long datalen;
                void* resdata;
                long reslen;
                dlxiddesc versions;
                t_xdlinfo info;

        protected:
                void (*LibMain)(int, Hdlx_t, char*);
                char* name;
                /* this was used for instance r && l, now is in public */
                long libloadpos;
                CDLXImports* myimps;
                long derror;
                // dlxiddesc versions;
                CEntryTracker myentries;
                CDLXListLink mylibs;
                long long dplugid;
        public:
                long linstance;
                long lmaxinstance;  /* new, my */
                long rinstance;
                long rmaxinstance;  /* new, my */
                int  loverload;     /* new, my */
                void*datafile;      /* new, my */
                void* operator new(size_t mysize);
                void operator delete(void* p);
                int AddDependancies(CDLXListLink& m);
                CDLX(char* iname, void* infile);
                ~CDLX();
                operator hdlx_t();
                int operator==(char*);
                int operator++();
                int operator--();
                int operator!();
                void* GetEntry(char* name);
                CDLX* Pass1();
                int Pass2();
                int Pass3();
                void RInstanceInc();
                void LInstanceInc();
                void Initialize();
                void RInstanceDec();
                void LInstanceDec();
                void DeInitialize();
};

static CDLXListLink _dlxlist;
static CDLXListLink _toilist;
static CDLXListLink _toflist;
static void dlx_auto_unload() __attribute__((destructor));
static CDLXSymbolList GlobalSymbols;

void DLXAddInAppList ( hdlx_t id, CDLX* o, char* filename );
char DelInAppList ( hdlx_t id );

#define LMAXINSTANCE    ((1<<31)-1) /* my */
#define RMAXINSTANCE    ((1<<31)-1) /* my */

static void  _DefaultSetLOverload(hdlx_t n, int i ){ /* my */
  CDLXLinkedList* tdlx = _dlxlist.GetLink(n);
  if ( tdlx && (CDLX*)*tdlx ) ((CDLX*)*tdlx)->loverload = i;
};

static void  _DefaultSetLMaxInstance(hdlx_t n, long i ){ /* my */
  CDLXLinkedList* tdlx = _dlxlist.GetLink(n);
  if ( tdlx && (CDLX*)*tdlx ) ((CDLX*)*tdlx)->lmaxinstance = i;
};

static  long _DefaultGetLInstance(hdlx_t n){ /* my */
  CDLXLinkedList* tdlx = _dlxlist.GetLink(n);
  if ( tdlx && (CDLX*)*tdlx ) return ((CDLX*)*tdlx)->linstance;
  return 0;
};

static  long _DefaultGetLMaxInstance(hdlx_t n){ /* my */
  CDLXLinkedList* tdlx = _dlxlist.GetLink(n);
  if ( tdlx && (CDLX*)*tdlx ) return ((CDLX*)*tdlx)->lmaxinstance;
  return 0;
};

static  int _DefaultGetLOverload(hdlx_t n){ /* my */
  CDLXLinkedList* tdlx = _dlxlist.GetLink(n);
  if ( tdlx && (CDLX*)*tdlx ) return ((CDLX*)*tdlx)->loverload;
  return 0;
};

static hdlx_t _DefaultGet(char* f){  /* my */
  CDLXLinkedList* tdlx = _dlxlist.GetLink(f);
  if ( tdlx ) return (hdlx_t)((CDLX*)*tdlx);
  return 0;
}

static  void* _DefaultGetFileData(hdlx_t n) { /* my */
  CDLXLinkedList* tdlx = _dlxlist.GetLink(n);
  if ( tdlx && (CDLX*)*tdlx ) return ((CDLX*)*tdlx)->datafile;
  return NULL;
};


static  long  DLXGetLInstanceC(CDLX *c) { return (c?c->linstance:0); }; /* my */
static  long  DLXGetLMaxInstanceC(CDLX *c) { return (c?c->lmaxinstance:0); }; /* my */
static  int   DLXGetLOverloadC(CDLX *c) { return (c?c->loverload:0); }; /* my */

static void* _DefaultOpen(char* name){return((void*)SealFileOpen(name,"rb"));}
static void _DefaultClose(void* fl){fclose((FILE*)fl); }
static long _DefaultRead(void* d, long l, void* fl){ return fread(d,1,l,(FILE*)fl); }
static void* _DefaultMalloc(size_t s){return malloc(s);}
static void* _DefaultCodeAlloc(size_t s, long memcls){if(memcls!=0) return NULL; return malloc(s);}
static void* _DefaultRealloc(void* m, size_t s){return realloc(m,s);}
static void _DefaultFree(void* m){free(m);}
static char* __dlxerrortbl[]= { "File Error:", "DLX Not In Memory:",
                                "Unresolved Externals:", "Error Unloading Named Symbols:",
                                "Invalid DLX:", "Illegal Operating System:",
                                "Load Error:", "Memory Allocation Error:",
                                "Code Memory Allocation Error:",
                                "File Read Error:","DLX Critical Failure:",//10
                                "Incorrect Seal version", "Error while decompressing" };
//#ifndef __SEAL__*/
//static void _DefaultError(long t,char *i){printf("%s %s", __dlxerrortbl[t], i); DEBUG_printf("Error: %s %s\n", __dlxerrortbl[t], i);};
//#else
//#include"object.h"
static void _DefaultError(long t,char *i){
seal_error(ERR_INFO, "%s %s\n", __dlxerrortbl[t], i);
DEBUG_printf("XDL :: Error ! %s %s\n", __dlxerrortbl[t], i);
};
//#endif
void* (*DLXOpenFile)(char*)=_DefaultOpen;
void (*DLXCloseFile)(void*)=_DefaultClose;
long (*DLXReadFile)(void*,long,void*)=_DefaultRead;
void (*DLXError)(long,char*)=_DefaultError;
void* (*DLXMalloc)(size_t)=_DefaultMalloc;
void (*DLXFree)(void*)=_DefaultFree;
void* (*DLXRealloc)(void*,size_t)=_DefaultRealloc;
int   (*DLXGetLOverload)(hdlx_t n) = _DefaultGetLOverload; /* my */
long  (*DLXGetLMaxInstance)(hdlx_t n) = _DefaultGetLMaxInstance; /* my */
long  (*DLXGetLInstance)(hdlx_t n) = _DefaultGetLInstance; /* my */