Changeset 57 for trunk/src


Ignore:
Timestamp:
Apr 9, 2001, 10:50:16 PM (24 years ago)
Author:
umoeller
Message:

Sources for V0.9.9, plus a couple of fixes.

Location:
trunk/src/helpers
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/helpers/dosh2.c

    r56 r57  
    810810 *@@changed V0.9.1 (2000-02-13) [umoeller]: fixed 32-bits flag
    811811 *@@changed V0.9.7 (2000-12-20) [lafaix]: fixed ulNewHeaderOfs
     812 *@@changed V0.9.10 (2001-04-08) [umoeller]: now setting ppExec only if NO_ERROR is returned
    812813 */
    813814
    … …  
    819820    ULONG   ulAction = 0;
    820821    HFILE   hFile;
     822    PEXECUTABLE pExec = NULL;
    821823
    822824    if (!ppExec)
    823825        return (ERROR_INVALID_PARAMETER);
    824826
    825     *ppExec = (PEXECUTABLE)malloc(sizeof(EXECUTABLE));
    826     if (!(*ppExec))
     827    pExec = (PEXECUTABLE)malloc(sizeof(EXECUTABLE));
     828    if (!(pExec))
    827829        return (ERROR_NOT_ENOUGH_MEMORY);
    828830
    829     memset((*ppExec), 0, sizeof(EXECUTABLE));
     831    memset(pExec, 0, sizeof(EXECUTABLE));
    830832
    831833    if (!(arc = DosOpen((PSZ)pcszExecutable,
    … …  
    850852
    851853        // read old DOS EXE header
    852         (*ppExec)->pDosExeHeader = (PDOSEXEHEADER)malloc(sizeof(DOSEXEHEADER));
    853         if (!((*ppExec)->pDosExeHeader))
     854        pExec->pDosExeHeader = (PDOSEXEHEADER)malloc(sizeof(DOSEXEHEADER));
     855        if (!(pExec->pDosExeHeader))
    854856            arc = ERROR_NOT_ENOUGH_MEMORY;
    855857        else
    … …  
    862864                                           &ulLocal)))      // out: new offset
    863865                 && (!(arc = DosRead(hFile,
    864                                      (*ppExec)->pDosExeHeader,
     866                                     pExec->pDosExeHeader,
    865867                                     sizeof(DOSEXEHEADER),
    866                                      &((*ppExec)->cbDosExeHeader))))
     868                                     &(pExec->cbDosExeHeader))))
    867869               )
    868870            {
    869871                // now check if we really have a DOS header
    870                 if ((*ppExec)->pDosExeHeader->usDosExeID != 0x5a4d)
     872                if (pExec->pDosExeHeader->usDosExeID != 0x5a4d)
    871873                    arc = ERROR_INVALID_EXE_SIGNATURE;
    872874                else
    873875                {
    874876                    // we have a DOS header:
    875                     if ((*ppExec)->pDosExeHeader->usRelocTableOfs < 0x40)
     877                    if (pExec->pDosExeHeader->usRelocTableOfs < 0x40)
    876878                    {
    877879                        // neither LX nor PE nor NE:
    878                         (*ppExec)->ulOS = EXEOS_DOS3;
    879                         (*ppExec)->ulExeFormat = EXEFORMAT_OLDDOS;
     880                        pExec->ulOS = EXEOS_DOS3;
     881                        pExec->ulExeFormat = EXEFORMAT_OLDDOS;
    880882                    }
    881883                    else
    … …  
    886888
    887889                        if (    (!(arc = DosSetFilePtr(hFile,
    888                                                        (*ppExec)->pDosExeHeader->ulNewHeaderOfs,
     890                                                       pExec->pDosExeHeader->ulNewHeaderOfs,
    889891                                                       FILE_BEGIN,
    890892                                                       &ulLocal)))
    … …  
    900902                            // reset file ptr
    901903                            DosSetFilePtr(hFile,
    902                                           (*ppExec)->pDosExeHeader->ulNewHeaderOfs,
     904                                          pExec->pDosExeHeader->ulNewHeaderOfs,
    903905                                          FILE_BEGIN,
    904906                                          &ulLocal);
    … …  
    907909                            {
    908910                                // New Executable:
    909                                 (*ppExec)->ulExeFormat = EXEFORMAT_NE;
     911                                pExec->ulExeFormat = EXEFORMAT_NE;
    910912                                // allocate NE header
    911                                 (*ppExec)->pNEHeader = (PNEHEADER)malloc(sizeof(NEHEADER));
    912                                 if (!((*ppExec)->pNEHeader))
     913                                pExec->pNEHeader = (PNEHEADER)malloc(sizeof(NEHEADER));
     914                                if (!(pExec->pNEHeader))
    913915                                    arc = ERROR_NOT_ENOUGH_MEMORY;
    914916                                else
    915917                                    // read in NE header
    916918                                    if (!(arc = DosRead(hFile,
    917                                                         (*ppExec)->pNEHeader,
     919                                                        pExec->pNEHeader,
    918920                                                        sizeof(NEHEADER),
    919                                                         &((*ppExec)->cbNEHeader))))
    920                                         if ((*ppExec)->cbNEHeader == sizeof(NEHEADER))
    921                                             pbCheckOS = &((*ppExec)->pNEHeader->bTargetOS);
     921                                                        &(pExec->cbNEHeader))))
     922                                        if (pExec->cbNEHeader == sizeof(NEHEADER))
     923                                            pbCheckOS = &(pExec->pNEHeader->bTargetOS);
    922924                            }
    923925                            else if (   (memcmp(achNewHeaderType, "LX", 2) == 0)
    … …  
    927929                            {
    928930                                // OS/2 Linear Executable:
    929                                 (*ppExec)->ulExeFormat = EXEFORMAT_LX;
     931                                pExec->ulExeFormat = EXEFORMAT_LX;
    930932                                // allocate LX header
    931                                 (*ppExec)->pLXHeader = (PLXHEADER)malloc(sizeof(LXHEADER));
    932                                 if (!((*ppExec)->pLXHeader))
     933                                pExec->pLXHeader = (PLXHEADER)malloc(sizeof(LXHEADER));
     934                                if (!(pExec->pLXHeader))
    933935                                    arc = ERROR_NOT_ENOUGH_MEMORY;
    934936                                else
    935937                                    // read in LX header
    936938                                    if (!(arc = DosRead(hFile,
    937                                                         (*ppExec)->pLXHeader,
     939                                                        pExec->pLXHeader,
    938940                                                        sizeof(LXHEADER),
    939                                                         &((*ppExec)->cbLXHeader))))
    940                                         if ((*ppExec)->cbLXHeader == sizeof(LXHEADER))
    941                                             pbCheckOS = (PBYTE)(&((*ppExec)->pLXHeader->usTargetOS));
     941                                                        &(pExec->cbLXHeader))))
     942                                        if (pExec->cbLXHeader == sizeof(LXHEADER))
     943                                            pbCheckOS = (PBYTE)(&(pExec->pLXHeader->usTargetOS));
    942944                            }
    943945                            else if (memcmp(achNewHeaderType, "PE", 2) == 0)
    944946                            {
    945                                 (*ppExec)->ulExeFormat = EXEFORMAT_PE;
    946                                 (*ppExec)->ulOS = EXEOS_WIN32;
    947                                 (*ppExec)->f32Bits = TRUE;
     947                                pExec->ulExeFormat = EXEFORMAT_PE;
     948                                pExec->ulOS = EXEOS_WIN32;
     949                                pExec->f32Bits = TRUE;
    948950
    949951                                // can't parse this yet
    … …  
    959961                                {
    960962                                    case NEOS_OS2:
    961                                         (*ppExec)->ulOS = EXEOS_OS2;
    962                                         if ((*ppExec)->ulExeFormat == EXEFORMAT_LX)
    963                                             (*ppExec)->f32Bits = TRUE;
     963                                        pExec->ulOS = EXEOS_OS2;
     964                                        if (pExec->ulExeFormat == EXEFORMAT_LX)
     965                                            pExec->f32Bits = TRUE;
    964966                                    break;
    965967
    966968                                    case NEOS_WIN16:
    967                                         (*ppExec)->ulOS = EXEOS_WIN16;
     969                                        pExec->ulOS = EXEOS_WIN16;
    968970                                    break;
    969971
    970972                                    case NEOS_DOS4:
    971                                         (*ppExec)->ulOS = EXEOS_DOS4;
     973                                        pExec->ulOS = EXEOS_DOS4;
    972974                                    break;
    973975
    974976                                    case NEOS_WIN386:
    975                                         (*ppExec)->ulOS = EXEOS_WIN386;
    976                                         (*ppExec)->f32Bits = TRUE;
     977                                        pExec->ulOS = EXEOS_WIN386;
     978                                        pExec->f32Bits = TRUE;
    977979                                    break;
    978980                                }
    … …  
    981983                }
    982984            } // end if (!(arc = DosSetFilePtr(hFile,
    983         } // end if (*ppExec)->pDosExeHeader = (PDOSEXEHEADER)malloc(sizeof(DOSEXEHEADER));
     985        } // end if pExec->pDosExeHeader = (PDOSEXEHEADER)malloc(sizeof(DOSEXEHEADER));
    984986
    985987        // store exec's HFILE
    986         (*ppExec)->hfExe = hFile;
     988        pExec->hfExe = hFile;
    987989    } // end if (!(arc = DosOpen((PSZ)pcszExecutable,
    988990
    989991    if (arc != NO_ERROR)
    990992        // error: clean up
    991         doshExecClose(*ppExec);
     993        doshExecClose(pExec);
     994    else
     995        *ppExec = pExec;
    992996
    993997    return (arc);
    … …  
    30053009 *@@added V0.9.0 [umoeller]
    30063010 *@@changed V0.9.9 (2001-04-07) [umoeller]: added transparent LVM support; changed prototype
    3007  *@@changed V0.9.9 (2001-04-07) [umoeller]: added memory leaks on errors
     3011 *@@changed V0.9.9 (2001-04-07) [umoeller]: fixed memory leaks on errors
    30083012 */
    30093013

  • trunk/src/helpers/procstat.c

    r44 r57  
    8484 *
    8585 *@@added V0.9.3 (2000-05-05) [umoeller]
    86  */
    87 
    88 PQPROCSTAT16 prc16GetInfo(APIRET *parc)     // out: error, ptr can be NULL
     86 *@@changed V0.9.10 (2001-04-08) [umoeller]: this returned != NULL even though item was freed, fixed
     87 *@@changed V0.9.10 (2001-04-08) [umoeller]: now using DosAllocMem, raised bufsize, changed prototype
     88 */
     89
     90APIRET prc16GetInfo(PQPROCSTAT16 *ppps)     // out: error, ptr can be NULL
    8991{
    9092    APIRET arc = NO_ERROR;
    91     PQPROCSTAT16 pps = (PQPROCSTAT16)malloc(0x8000);
     93    PQPROCSTAT16 pps = NULL;
     94
     95    /* PQPROCSTAT16 pps = (PQPROCSTAT16)malloc(0x8000);
    9296    if (!pps)
    9397        arc = ERROR_NOT_ENOUGH_MEMORY;
    94     else
    95     {
    96         arc = DosQProcStatus(pps, 0x8000);
    97         if (arc != NO_ERROR)
    98             free(pps);
    99     }
    100 
    101     if (parc)
    102         *parc = arc;
    103 
    104     return (pps);
     98    else */
     99
     100    if (!ppps)
     101        return (ERROR_INVALID_PARAMETER);
     102
     103    // changed allocation V0.9.10 (2001-04-08) [umoeller]:
     104    // malloc didn't guarantee that the object did not
     105    // cross a 64K boundary, which could cause DosQProcStat
     106    // to fail...
     107    #define BUF_SIZE        0xFFFF          // raised from 0x8000
     108
     109    if (!(arc = DosAllocMem((VOID**)&pps,
     110                            BUF_SIZE,
     111                            PAG_READ | PAG_WRITE | PAG_COMMIT
     112                                | OBJ_TILE          // 16-bit compatible, ignored really
     113                           )))
     114    {
     115        if (arc = DosQProcStatus(pps, BUF_SIZE))
     116        {
     117            // error:
     118            DosFreeMem(pps);        // V0.9.10 (2001-04-08) [umoeller]
     119
     120            // and even worse, I forgot to set the return ptr
     121            // to NULL, so this was freed twice... I guess
     122            // this produced the crashes in WarpIN with the
     123            // KILLPROCESS attribute... V0.9.10 (2001-04-08) [umoeller]
     124            pps = NULL;
     125        }
     126    }
     127
     128    *ppps = pps;
     129
     130    return (arc);
    105131}
    106132
    … …  
    110136 *
    111137 *@@added V0.9.3 (2000-05-05) [umoeller]
    112  */
    113 
    114 VOID prc16FreeInfo(PQPROCSTAT16 pInfo)
    115 {
    116     if (pInfo)
    117         free(pInfo);
     138 *@@changed V0.9.10 (2001-04-08) [umoeller]: now using DosFreeMem
     139 */
     140
     141APIRET prc16FreeInfo(PQPROCSTAT16 pInfo)
     142{
     143    if (!pInfo)
     144        return ERROR_INVALID_PARAMETER;
     145
     146    return DosFreeMem(pInfo);
    118147}
    119148
    … …  
    476505 *@@added V0.9.1 (2000-02-12) [umoeller]
    477506 *@@changed V0.9.3 (2000-05-01) [umoeller]: now using DosAllocMem
     507 *@@changed V0.9.10 (2001-04-08) [umoeller]: fixed second QuerySysState param
    478508 */
    479509
    480510PQTOPLEVEL32 prc32GetInfo(APIRET *parc)     // out: error, ptr can be NULL
    481511{
    482     #define BUFSIZE 128000l
     512    #define BUFSIZE (256 * 1024) // 128000l
    483513    PCHAR pBuf = NULL; // (PCHAR)malloc(BUFSIZE);
    484514
    … …  
    489519        if (pBuf)
    490520        {
    491             APIRET arc = DosQuerySysState(0x1f,
    492                                           0, 0, 0,
     521            APIRET arc = DosQuerySysState(QS32_SUPPORTED,
     522                                          QS32_SUPPORTED,       // this was missing
     523                                                                // V0.9.10 (2001-04-08) [umoeller]
     524                                          0, 0,
    493525                                          (PCHAR)pBuf,
    494526                                          BUFSIZE);
    … …  
    528560{
    529561    PQPROCESS32 pProcThis = pInfo->pProcessData;
    530     while (pProcThis && pProcThis->rectype == 1)
     562    while (pProcThis && pProcThis->ulRecType == 1)
    531563    {
    532564        int i;
    … …  
    561593    }
    562594
    563     if (pProcThis->rectype == 1)
     595    if (pProcThis->ulRecType == 1)
    564596        return (pProcThis);
    565597    else
    … …  
    578610 */
    579611
    580 PQSEMA32 prc32FindSem16(PQTOPLEVEL32 pInfo,     // in: as returned by prc32GetInfo
     612PQS32SEM16 prc32FindSem16(PQTOPLEVEL32 pInfo,     // in: as returned by prc32GetInfo
    581613                          USHORT usSemID)       // in: as in QPROCESS32.pausSem16
    582614{
    583     PQSEM16STRUC32  pSemData = pInfo->pSem16Data;
    584     PQSEMA32        pSemThis = &pSemData->sema;
    585     ULONG           i = 0;
     615    PQS32SEM16HEAD      pSemHead = pInfo->pSem16Data;
     616    PQS32SEM16          // pSemThis = &pSemData->sema;
     617                        pSemThis = &pSemHead->Sem16Rec;
     618    ULONG               i = 0;
    586619
    587620    while (pSemThis)
    588621    {
    589         _Pmpf(("prc32FindSem16: found usIndex 0x%lX", pSemThis->usIndex));
    590         if (/* pSemThis->usIndex */ i == usSemID)
     622        if (i == usSemID)
    591623            return (pSemThis);
    592624
    … …  
    610642 */
    611643
    612 PQSEM32STRUC32 prc32FindSem32(PQTOPLEVEL32 pInfo,     // in: as returned by prc32GetInfo
    613                               USHORT usSemID)         // in: as in QPROCESS32.pausSem16
     644PQS32SEM32 prc32FindSem32(PQTOPLEVEL32 pInfo,     // in: as returned by prc32GetInfo
     645                          USHORT usSemID)         // in: as in QPROCESS32.pausSem16
    614646{
    615647    // PQSEM32STRUC32  pSemThis = pInfo->pSem32Data;
    … …  
    687719    PQFILEDATA32 pFile = pInfo->pFileData;
    688720    while (     (pFile)
    689              && (pFile->rectype == 8)  // this is necessary, we'll crash otherwise!!
     721             && (pFile->ulRecType == 8)  // this is necessary, we'll crash otherwise!!
    690722          )
    691723    {
    692             if (pFile->filedata->sfn == usFileID)
     724        ULONG ul;
     725        // for some reason, there is an array in the file struct,
     726        // so search the array for the SFN
     727        for (ul = 0;
     728             ul < pFile->ulCFiles;
     729             ul++)
     730        {
     731            if (pFile->paFiles[ul].usSFN == usFileID)
    693732                return (pFile);
     733        }
    694734
    695735        pFile = pFile->pNext;
Note: See TracChangeset for help on using the changeset viewer.