/* * Module Name: WSTCAT.C * * Program: WSTCAT * * * Description: * * Concatenates multiple WSP files, for the same module, into one WSP file. * Creates a single TMI file from the resulting files. * * * Modification History: * * 8-20-92 Created marklea * 4-24-98, QFE: DerrickG (mdg) * - new WSP file format for large symbol counts (ULONG vs. USHORT) * - support for long file names (LFN) of input/output files * - removed limit on symbol name lengths * * * * */ #include #include #include #include #include #include <..\wsfslib\wserror.h> #include <..\wsfslib\wsfslib.h> #include #define MODULE "WSTCAT" #define VERSION VER_PRODUCTVERSION_STR /* * Global variable declaration and initialization. */ static ULONG rc = NO_ERROR; // Return code typedef struct tagTMI{ CHAR *pszFxnName; ULONG ulAddr; ULONG ulSize; ULONG ulIndex; BOOL fSet; }TMI; typedef struct indxMOD{ ULONG ulSetCnt; // mdg 4/98 ULONG ulFxnTot; ULONG ulOffset; ULONG ulSnaps; PULONG pulBitStrings; FILE *hFileNDX; TMI *tmi; }NDXMOD; typedef struct tagMOD{ ULONG ulSetCnt; // mdg 4/98 UINT uiLeft; ULONG ulOffset; ULONG ulSnaps; FILE *hFileWxx; PULONG pulAddr; }WSTMOD; NDXMOD nmod; WSTMOD wmod[256]; CHAR *szFileWSP; //WSP file name CHAR *szFileTMI; //TMI file name CHAR *szFileWxx; //extra wsp files CHAR *szFileTxx; //extra tmi files CHAR *szModName; //Module or DLL name CHAR *szFileWSPtmp; // Temporary .WSP file name CHAR *szFileTMItmp; // Temporary .TMI file name ULONG clVarTot = 0; // Total number of dwords in bitstr UINT uiModCount; WSPHDR WspHdr, tmpHdr; FILE *hFileWSP; FILE *hFileTmpWSP; FILE *hFileTMI; FILE *hFileTmpTMI; /* * Function prototypes. */ VOID wspCatSetup(VOID); VOID wspCatUsage(VOID); VOID wspCat(VOID); INT wspCatExit(INT, USHORT, UINT, ULONG, LPSTR); int WspBCompare (ULONG, PULONG); LONG WspBSearch (ULONG ulAddr, WSTMOD wmod); /****************************** M A I N ************************************** * * Function: main (INT argc, CHAR *argv[]) * * * Purpose: Parses command line and dumps the WSP and TMI files * * Usage: [d:][path]wstcat modulename * * where: modulename is the name of the module whose wXX files * you want to concatenate. * * Returns: NONE * *****************************************************************************/ VOID __cdecl main (INT argc, CHAR *argv[]) { ConvertAppToOem( argc, argv ); if (argc != 2) { wspCatUsage(); exit( -1 ); } else { UINT nLen; char * pDot; if ((pDot = strrchr( argv[ 1 ], '.' )) != NULL) *pDot = '\0'; nLen = strlen( argv[1] ) + 1; szModName = malloc( nLen ); if (szModName) strcpy(szModName, argv[1]); else { exit(1); } szFileWSP = malloc( nLen + 4 ); if (szFileWSP) strcat( strcpy( szFileWSP, szModName ), ".WSP" ); else { free(szModName); exit(1); } szFileTMI = malloc( nLen + 4 ); if (szFileTMI) strcat( strcpy( szFileTMI, szModName ), ".TMI" ); else { free(szFileWSP); free(szModName); exit(1); } szFileWxx = malloc( nLen + 4 ); if (szFileWxx) strcat( strcpy( szFileWxx, szModName ), ".Wxx" ); else { free(szFileTMI); free(szFileWSP); free(szModName); exit(1); } szFileTxx = malloc( nLen + 4 ); if (szFileTxx) strcat( strcpy( szFileTxx, szModName ), ".Txx" ); else { free(szFileWxx); free(szFileTMI); free(szFileWSP); free(szModName); exit(1); } szFileWSPtmp = malloc( nLen + 4 ); if (szFileWSPtmp) strcat( strcpy( szFileWSPtmp, szModName ), ".Wzz" ); else { free(szFileTxx); free(szFileWxx); free(szFileTMI); free(szFileWSP); free(szModName); exit(1); } szFileTMItmp = malloc( nLen + 4 ); if (szFileTMItmp) strcat( strcpy( szFileTMItmp, szModName ), ".Tzz" ); else { free(szFileTMItmp); free(szFileTxx); free(szFileWxx); free(szFileTMI); free(szFileWSP); free(szModName); exit(1); } } // Setup input files for dump processing. wspCatSetup(); wspCat(); // Free allocated memory free( szModName ); free( szFileWSP ); free( szFileTMI ); free( szFileWxx ); free( szFileTxx ); } /* * ***LP wspCatSetup * * * Effects: * * Opens the module's WSP and TMI input files, seeks to the start of the * first function's bitstring data in the WSP file, and allocates memory * to hold one function's bitstring. * * Returns: * * Void. If an error is encountered, exits through wspCatExit() * with ERROR. * */ VOID wspCatSetup(VOID) { ULONG ulTmp; UINT uiExt = 0; UINT x; char * pszTmpName; /* Open input WSP file. Read and validate WSP file header.*/ rc = WsWSPOpen(szFileWSP, &hFileWSP,(PFN)wspCatExit, (wsphdr_t *)&WspHdr, ERROR, PRINT_MSG ); if(rc){ exit(rc); } // // Open a temporary tmi file to hold concatenated information. // This file will be renamed to module.tmi when the cat process // is complete, and the current module.tmi will be renamed to module.txx. // hFileTMI = fopen(szFileTMI, "rt"); if (!hFileTMI) { wspCatExit(ERROR, PRINT_MSG, MSG_FILE_OPEN, GetLastError(), szFileTMI); } hFileTmpTMI = fopen(szFileTMItmp, "wt"); if (!hFileTmpTMI) { wspCatExit(ERROR, PRINT_MSG, MSG_FILE_OPEN, GetLastError(), szFileTMItmp); } pszTmpName = malloc( 128 + 1 ); if (pszTmpName) { fputs (fgets (pszTmpName, 128, hFileTMI), hFileTmpTMI); fputs (fgets (pszTmpName, 128, hFileTMI), hFileTmpTMI); fputs (fgets (pszTmpName, 128, hFileTMI), hFileTmpTMI); fputs (fgets (pszTmpName, 128, hFileTMI), hFileTmpTMI); fputs (fgets (pszTmpName, 128, hFileTMI), hFileTmpTMI); free( pszTmpName ); } fclose(hFileTMI); // // Set key, module specific information // clVarTot = WspHdr.ulSnaps; nmod.ulSnaps = WspHdr.ulSnaps; nmod.ulSetCnt = WspHdr.ulSetSymbols; // mdg 4/98 nmod.ulOffset = WspHdr.ulOffset; nmod.ulFxnTot = WsTMIOpen(szFileTMI, &hFileTMI, (PFN) wspCatExit, 0, (PCHAR)0); // // Open a temporary wsp file to hold concatenated information. // This file will be renamed to module.wsp when the cat process // is complete, and the current module.wsp will be renamed to module.wxx. // The header is also written. // hFileTmpWSP = fopen(szFileWSPtmp, "wb"); if (!hFileTmpWSP) { wspCatExit(ERROR, PRINT_MSG, MSG_FILE_OPEN, GetLastError(), szFileWSPtmp); } WspHdr.ulOffset = sizeof(WSPHDR) + strlen( szModName ); // Set data location correctly fwrite(&WspHdr, sizeof(WSPHDR), 1, hFileTmpWSP); fwrite(szModName, strlen(szModName), 1, hFileTmpWSP); // // Allocate memory to hold TMI data for each Symbol in the // main TMI file // nmod.tmi = (TMI *)malloc(nmod.ulFxnTot * sizeof(TMI)); if (nmod.tmi == NULL) { wspCatExit(ERROR, PRINT_MSG, MSG_NO_MEM, nmod.ulFxnTot * sizeof(TMI), "nmod.tmi[]"); } // // Read data for each symbol record in the key TMI file // for (x = 0; x < nmod.ulFxnTot ; x++ ) { nmod.tmi[x].ulSize = WsTMIReadRec(&pszTmpName, &(nmod.tmi[x].ulIndex), &(nmod.tmi[x].ulAddr), hFileTMI, (PFN)wspCatExit, (PCHAR)0); nmod.tmi[x].pszFxnName = pszTmpName; } fclose(hFileTMI); // // Get Txx and Wxx specific information // while(rc == NO_ERROR){ // // Modify the file name to the first wxx and txx file // sprintf(szFileWxx, "%s.w%02d", szModName, uiExt+1); sprintf(szFileTxx, "%s.t%02d", szModName, uiExt+1); // // Open file.Wxx and read header information. // rc = WsWSPOpen(szFileWxx, &(wmod[uiExt].hFileWxx),(PFN)wspCatExit, (wsphdr_t *)&tmpHdr, NOEXIT, NO_MSG ); // // Check for an error from the open command. Could be the last // file. // if(rc == NO_ERROR){ clVarTot += tmpHdr.ulSnaps; //Increment the total number of //Snapshots by the number from //each data file. wmod[uiExt].ulSetCnt = tmpHdr.ulSetSymbols; // mdg 4/98 wmod[uiExt].uiLeft = tmpHdr.ulSetSymbols; // mdg 4/98 wmod[uiExt].ulOffset = tmpHdr.ulOffset; wmod[uiExt].ulSnaps = tmpHdr.ulSnaps; wmod[uiExt].pulAddr = (ULONG *)malloc(wmod[uiExt].ulSetCnt * // mdg 4/98 sizeof(ULONG)); // // Open the TMI file associated with this data file // WsTMIOpen(szFileTxx, &hFileTMI,(PFN)wspCatExit, 0, (PCHAR)0); // // Read each address from the TMI file. // if(rc == NO_ERROR){ for (x = 0; x < wmod[uiExt].ulSetCnt ; x++ ) { // mdg 4/98 WsTMIReadRec(&pszTmpName, &ulTmp, (wmod[uiExt].pulAddr)+x, hFileTMI, (PFN)wspCatExit, (PCHAR)0); free( pszTmpName ); } } } // // Increment the module index // uiExt++; } uiModCount = uiExt; // // Allocate enough memory to hold all the bit strings for each module // in a single array. // nmod.pulBitStrings = (ULONG *) malloc(clVarTot * sizeof(ULONG)); if (nmod.pulBitStrings == NULL) wspCatExit(ERROR, PRINT_MSG, MSG_NO_MEM, clVarTot * sizeof(ULONG), "pulBitStrings[]"); } /* * ***LP wspCat * * * Effects: * * For each function, * * Returns: * * Void. If an error is encountered, exits through wspCatExit() * with ERROR. * */ VOID wspCat(VOID) { UINT uiFxn = 0; // Function number. UINT x = 0; PULONG pulBitStrings; // Pointer to bitstring data. ULONG culSnaps = 0; // Cumulative snapshots. LONG lIndex = 0; // Index to WSP file. BOOL fSetBits = FALSE; CHAR szBuffer [256]; ULONG ulNewSetCnt = 0; // mdg 4/98 for (uiFxn = 0; uiFxn < nmod.ulFxnTot; uiFxn++) { pulBitStrings = &(nmod.pulBitStrings[0]); culSnaps = nmod.ulSnaps; // // Check to see if any non-zero bit strings remain // if(uiFxn < nmod.ulSetCnt){ // mdg 4/98 // // Seek to function's bitstring in WSP file. // only for the first function // if(!uiFxn){ if ((rc = fseek(hFileWSP,nmod.ulOffset,SEEK_SET))!=NO_ERROR) wspCatExit(ERROR, PRINT_MSG, MSG_FILE_OFFSET, rc, szModName); } // // Read bitstring for NDX api // if (fread(pulBitStrings, sizeof(ULONG), nmod.ulSnaps, hFileWSP) != (sizeof(ULONG) * nmod.ulSnaps)) wspCatExit(ERROR, PRINT_MSG, MSG_FILE_OFFSET, 0, szModName); fSetBits = TRUE; } // // If not, set the bitstring to '0'. This is faster than seeking // to each bit string when they are zero. // else memset(pulBitStrings, '\0' , (sizeof(ULONG) * nmod.ulSnaps)); // // Increment the pointer to allow for the addition of the next // bitstring set // pulBitStrings += nmod.ulSnaps; // // Now search WSTMOD array for a matching Function address // for (x=0; x < uiModCount - 1 ; x++ ) { culSnaps += wmod[x].ulSnaps; // // See if there are any functions that remain // and if so search for them // if(wmod[x].uiLeft){ lIndex = WspBSearch(nmod.tmi[uiFxn].ulAddr, wmod[x]); // // If search has found a matching address, get the bitstring // and append it pulBitStrings // if (lIndex >= 0L) { lIndex = wmod[x].ulOffset + ( lIndex * (wmod[x].ulSnaps * sizeof(ULONG))); if (rc = fseek(wmod[x].hFileWxx, lIndex, SEEK_SET) != NO_ERROR) wspCatExit(ERROR, PRINT_MSG, MSG_FILE_OFFSET, rc, szModName); if (fread(pulBitStrings, sizeof(ULONG), wmod[x].ulSnaps, wmod[x].hFileWxx) != (sizeof(ULONG) * wmod[x].ulSnaps)) { wspCatExit(ERROR, PRINT_MSG, MSG_FILE_OFFSET, 0, szModName); } wmod[x].uiLeft--; fSetBits = TRUE; } // // Otherwise, set all bytes to 0 // else{ memset(pulBitStrings, '\0' , (sizeof(ULONG) * wmod[x].ulSnaps)); } } // // Otherwise, set all bytes to 0 // else memset(pulBitStrings, '\0' , (sizeof(ULONG) * wmod[x].ulSnaps)); // // Now increment the pointer to allow for appending of additional // bitstring data. // pulBitStrings += wmod[x].ulSnaps; } // // Now we need to write the TMI & WSP file with the concatenated // bitstring (only if set) // nmod.tmi[uiFxn].fSet = fSetBits; if (fSetBits) { ulNewSetCnt++; // 4/98 sprintf(szBuffer, "%ld 0000:%08lx 0x%lx %ld ", (LONG)nmod.tmi[uiFxn].ulIndex, nmod.tmi[uiFxn].ulAddr, nmod.tmi[uiFxn].ulSize, strlen( nmod.tmi[uiFxn].pszFxnName )); fwrite(szBuffer, sizeof(char), strlen(szBuffer), hFileTmpTMI); fputs( nmod.tmi[uiFxn].pszFxnName, hFileTmpTMI ); fputc( '\n', hFileTmpTMI ); fwrite(nmod.pulBitStrings, sizeof(ULONG), culSnaps, hFileTmpWSP); fSetBits = FALSE; } } // // Now write all the TMI symbols not set to the temporary .tmi file // memset(nmod.pulBitStrings, '\0' , (sizeof(ULONG) * culSnaps)); for (uiFxn = 0; uiFxn < nmod.ulFxnTot; uiFxn++) { if (!nmod.tmi[uiFxn].fSet) { sprintf(szBuffer, "%ld 0000:%08lx 0x%lx %ld ", (LONG)nmod.tmi[uiFxn].ulIndex, nmod.tmi[uiFxn].ulAddr, nmod.tmi[uiFxn].ulSize, strlen( nmod.tmi[uiFxn].pszFxnName )); fwrite(szBuffer, sizeof(char), strlen(szBuffer), hFileTmpTMI); fputs( nmod.tmi[uiFxn].pszFxnName, hFileTmpTMI ); fputc( '\n', hFileTmpTMI ); fwrite(nmod.pulBitStrings, sizeof(ULONG), culSnaps, hFileTmpWSP); } } // // Seek to the beginning of the WSP file and update the snapshot // count in the header // if (!fseek(hFileTmpWSP, 0L, SEEK_SET)) { WspHdr.ulSnaps = culSnaps; WspHdr.ulSetSymbols = ulNewSetCnt; // mdg 4/98 fprintf(stdout,"Set symbols: %lu\n", WspHdr.ulSetSymbols); // mdg 4/98 fwrite(&WspHdr, sizeof(WSPHDR), 1, hFileTmpWSP); } _fcloseall(); // // Rename the non-cat'd .wsp file and rename the cat'd temporary .wsp // to the original .wsp. We might also consider deleting all the // Wxx and Txx files. // sprintf (szFileWxx, "%s.%s", szModName, "WSP"); sprintf (szFileTxx, "%s.%s", szModName, "WXX"); remove(szFileTxx); if (rename(szFileWxx, szFileTxx) !=0){ printf("Unable to rename file %s to %s\n", szFileWxx, szFileTxx); } else{ if (rename(szFileWSPtmp, szFileWSP) !=0){ printf ("Unable to rename %s to %s!\n", szFileWSPtmp, szFileWxx); } } // // Rename the non-cat'd .tmi file and rename the cat'd temporary .tmi // to the original .tmi. We might also consider deleting all the // Wxx and Txx files. // sprintf (szFileWxx, "%s.%s", szModName, "TMI"); sprintf (szFileTxx, "%s.%s", szModName, "TXX"); remove(szFileTxx); if (rename(szFileWxx, szFileTxx) !=0){ printf("Unable to rename file %s to %s\n", szFileWxx, szFileTxx); } else{ if (rename(szFileTMItmp, szFileTMI) !=0){ printf ("Unable to rename %s to %s!\n", szFileTMItmp, szFileWxx); } } } /* * * wspCatUsage * * * Effects: * * Prints out usage message, and exits with an error. * * Returns: * * Exits with ERROR. */ VOID wspCatUsage(VOID) { printf("\nUsage: %s moduleName[.WSP]\n\n", MODULE); printf(" \"moduleName\" is the name of the module file to combine.\n\n"); printf("%s %s\n", MODULE, VERSION); exit(ERROR); } /* * ***LP wspCatExit * * *** * * Effects: * * Frees up resources (as necessary). Exits with the specified * exit code, or returns void if exit code is NOEXIT. * *** * Returns: * * Void, else exits. */ INT wspCatExit(INT iExitCode, USHORT fPrintMsg, UINT uiMsgCode, ULONG ulParam1, LPSTR pszParam2) { /* Print message, if necessary. */ if (fPrintMsg) { printf(pchMsg[uiMsgCode], MODULE, VERSION , ulParam1, pszParam2); } // Special case: do NOT exit if called with NOEXIT. if (iExitCode != NOEXIT) exit(iExitCode); return(uiMsgCode); } /*********************** W s p B S e a r c h ******************************* * * Function: WspBSearch(ULONG ulAddr, PULONG pulAddr) * * Purpose: Binary search function for finding a match in the WST array * * * Parameters: * * * * Returns: ULONG lIndex; * * History: 8-5-92 Marklea - created * */ LONG WspBSearch (ULONG ulAddr, WSTMOD wmod) { int i; // ULONG ulHigh = (ULONG)wmod.usSetCnt; ULONG ulHigh = (ULONG)wmod.ulSetCnt; // mdg 4/98 ULONG ulLow = 0; ULONG ulMid; while(ulLow < ulHigh){ ulMid = ulLow + (ulHigh - ulLow) /2; if((i = WspBCompare(ulAddr, wmod.pulAddr+ulMid)) < 0) { ulHigh = ulMid; } else if (i > 0) { ulLow = ulMid + 1; } else { return (ulMid); } } return (-1L); } /* WspBSearch () */ /*********************** W s p B C o m p a r e ******************************** * * Function: WspBCompare(ULONG ulAddr, PULONG pulAddr) * * Purpose: Compare values for Binary search * * * Parameters: * * Returns: -1 if val1 < val2 * 1 if val1 > val2 * 0 if val1 == val2 * * History: 8-3-92 Marklea - created * */ int WspBCompare(ULONG ulAddr, PULONG pulAddr) { return (ulAddr < *pulAddr ? -1: ulAddr == *pulAddr ? 0: 1); } /* WspBCompare () */